Merge branch 'TurboWarp:develop' into develop

Author: CubesterYT

.github/workflows/deploy.yml

@@ -13,9 +13,11 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          persist-credentials: false
       - name: Install Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af
         with:
           node-version: 20
           cache: npm
@@ -29,7 +31,7 @@ jobs:
         # It will still generate what it can, so it's safe to ignore the error
         continue-on-error: true
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa
         with:
           path: ./playground/
 
@@ -45,4 +47,4 @@ jobs:
     steps:
     - name: Deploy to GitHub Pages
       id: deployment
-      uses: actions/deploy-pages@v4
+      uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e

.github/workflows/node.js.yml

@@ -8,9 +8,11 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+        with:
+          persist-credentials: false
       - name: Install Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af
         with:
           node-version: 20
           cache: npm

src/compiler/irgen.js

@@ -19,17 +19,12 @@ const LIST_TYPE = 'list';
  */
 
 /**
- * Create a variable codegen object.
- * @param {'target'|'stage'} scope The scope of this variable -- which object owns it.
- * @param {import('../engine/variable.js')} varObj The Scratch Variable
- * @returns {*} A variable codegen object.
+ * @typedef DescendedVariable
+ * @property {'target'|'stage'} scope
+ * @property {string} id
+ * @property {string} name
+ * @property {boolean} isCloud
  */
-const createVariableData = (scope, varObj) => ({
-    scope,
-    id: varObj.id,
-    name: varObj.name,
-    isCloud: varObj.isCloud
-});
 
 /**
  * @param {string} code
@@ -1420,35 +1415,49 @@ class ScriptTreeGenerator {
         const variable = block.fields[fieldName];
         const id = variable.id;
 
-        if (Object.prototype.hasOwnProperty.call(this.variableCache, id)) {
+        if (id && Object.prototype.hasOwnProperty.call(this.variableCache, id)) {
             return this.variableCache[id];
         }
 
         const data = this._descendVariable(id, variable.value, type);
-        this.variableCache[id] = data;
+        // If variable ID was null, this might do some unnecessary updates, but that is a rare
+        // edge case and it won't have any adverse effects anyways.
+        this.variableCache[data.id] = data;
         return data;
     }
 
     /**
-     * @param {string} id The ID of the variable.
+     * @param {string|null} id The ID of the variable.
      * @param {string} name The name of the variable.
      * @param {''|'list'} type The variable type.
      * @private
-     * @returns {*} A parsed variable object.
+     * @returns {DescendedVariable} A parsed variable object.
      */
     _descendVariable (id, name, type) {
         const target = this.target;
         const stage = this.stage;
 
         // Look for by ID in target...
         if (Object.prototype.hasOwnProperty.call(target.variables, id)) {
-            return createVariableData('target', target.variables[id]);
+            const currVar = target.variables[id];
+            return {
+                scope: 'target',
+                id: currVar.id,
+                name: currVar.name,
+                isCloud: currVar.isCloud
+            };
         }
 
         // Look for by ID in stage...
         if (!target.isStage) {
             if (stage && Object.prototype.hasOwnProperty.call(stage.variables, id)) {
-                return createVariableData('stage', stage.variables[id]);
+                const currVar = stage.variables[id];
+                return {
+                    scope: 'stage',
+                    id: currVar.id,
+                    name: currVar.name,
+                    isCloud: currVar.isCloud
+                };
             }
         }
 
@@ -1457,7 +1466,12 @@ class ScriptTreeGenerator {
             if (Object.prototype.hasOwnProperty.call(target.variables, varId)) {
                 const currVar = target.variables[varId];
                 if (currVar.name === name && currVar.type === type) {
-                    return createVariableData('target', currVar);
+                    return {
+                        scope: 'target',
+                        id: currVar.id,
+                        name: currVar.name,
+                        isCloud: currVar.isCloud
+                    };
                 }
             }
         }
@@ -1468,14 +1482,22 @@ class ScriptTreeGenerator {
                 if (Object.prototype.hasOwnProperty.call(stage.variables, varId)) {
                     const currVar = stage.variables[varId];
                     if (currVar.name === name && currVar.type === type) {
-                        return createVariableData('stage', currVar);
+                        return {
+                            scope: 'stage',
+                            id: currVar.id,
+                            name: currVar.name,
+                            isCloud: currVar.isCloud
+                        };
                     }
                 }
             }
         }
 
         // Create it locally...
         const newVariable = new Variable(id, name, type, false);
+
+        // Intentionally not using newVariable.id so that this matches vanilla Scratch quirks regarding
+        // handling of null variable IDs.
         target.variables[id] = newVariable;
 
         if (target.sprite) {
@@ -1489,7 +1511,14 @@ class ScriptTreeGenerator {
             }
         }
 
-        return createVariableData('target', newVariable);
+        return {
+            scope: 'target',
+            // If the given ID was null, this won't match the .id property of the Variable object.
+            // This is intentional to match vanilla Scratch quirks.
+            id,
+            name: newVariable.name,
+            isCloud: newVariable.isCloud
+        };
     }
 
     descendProcedure (block) {

src/engine/thread.js

@@ -451,7 +451,8 @@ class Thread {
         let callCount = 5; // Max number of enclosing procedure calls to examine.
         const sp = this.stackFrames.length - 1;
         for (let i = sp - 1; i >= 0; i--) {
-            const block = this.target.blocks.getBlock(this.stackFrames[i].op.id);
+            const block = this.target.blocks.getBlock(this.stackFrames[i].op.id) ||
+                this.target.runtime.flyoutBlocks.getBlock(this.stackFrames[i].op.id);
             if (block.opcode === 'procedures_call' &&
                 block.mutation.proccode === procedureCode) {
                 return true;

src/engine/tw-font-manager.js

@@ -3,6 +3,11 @@ const AssetUtil = require('../util/tw-asset-util');
 const StringUtil = require('../util/string-util');
 const log = require('../util/log');
 
+/*
+ * In general in this file, note that font names in browsers are case-insensitive
+ * but are whitespace-sensitive.
+ */
+
 /**
  * @typedef InternalFont
  * @property {boolean} system True if the font is built in to the system
@@ -11,40 +16,121 @@ const log = require('../util/log');
  * @property {Asset} [asset] scratch-storage asset if system: false
  */
 
+/**
+ * @param {string} font
+ * @returns {string}
+ */
+const removeInvalidCharacters = font => font.replace(/[^-\w ]/g, '');
+
+/**
+ * @param {InternalFont[]} fonts Modified in-place
+ * @param {InternalFont} newFont
+ * @returns {InternalFont|null}
+ */
+const addOrUpdateFont = (fonts, newFont) => {
+    let oldFont;
+    const oldIndex = fonts.findIndex(i => i.family.toLowerCase() === newFont.family.toLowerCase());
+    if (oldIndex !== -1) {
+        oldFont = fonts[oldIndex];
+        fonts.splice(oldIndex, 1);
+    }
+    fonts.push(newFont);
+    return oldFont;
+};
+
 class FontManager extends EventEmitter {
     /**
      * @param {Runtime} runtime
      */
     constructor (runtime) {
         super();
+
+        /** @type {Runtime} */
         this.runtime = runtime;
+
         /** @type {Array<InternalFont>} */
         this.fonts = [];
+
+        /**
+         * All entries should be lowercase.
+         * @type {Set<string>}
+         */
+        this.restrictedFonts = new Set();
     }
 
     /**
-     * @param {string} family An unknown font family
-     * @returns {boolean} true if the family is valid
+     * Prevents a family from being overridden by a custom font. The project may still use it as a system font.
+     * @param {string} family
      */
-    isValidFamily (family) {
+    restrictFont (family) {
+        if (!this.isValidSystemFont(family)) {
+            throw new Error('Invalid font');
+        }
+
+        this.restrictedFonts.add(family.toLowerCase());
+
+        const oldLength = this.fonts.length;
+        this.fonts = this.fonts.filter(font => font.system || this.isValidCustomFont(font.family));
+        if (this.fonts.length !== oldLength) {
+            this.updateRenderer();
+            this.changed();
+        }
+    }
+
+    /**
+     * @param {string} family Untrusted font name input
+     * @returns {boolean} true if the family is valid for a system font
+     */
+    isValidSystemFont (family) {
         return /^[-\w ]+$/.test(family);
     }
 
     /**
-     * @param {string} family
-     * @returns {boolean}
+     * @param {string} family Untrusted font name input
+     * @returns {boolean} true if the family is valid for a custom font
      */
-    hasFont (family) {
-        return !!this.fonts.find(i => i.family === family);
+    isValidCustomFont (family) {
+        return /^[-\w ]+$/.test(family) && !this.restrictedFonts.has(family.toLowerCase());
+    }
+
+    /**
+     * @deprecated only exists for extension compatibility, use isValidSystemFont or isValidCustomFont instead
+     */
+    isValidFamily (family) {
+        return this.isValidSystemFont(family) && this.isValidCustomFont(family);
+    }
+    
+    /**
+     * @param {string} family Untrusted font name input
+     * @returns {string}
+     */
+    getUnusedSystemFont (family) {
+        return StringUtil.caseInsensitiveUnusedName(
+            removeInvalidCharacters(family),
+            this.fonts.map(i => i.family)
+        );
+    }
+
+    /**
+     * @param {string} family Untrusted font name input
+     * @returns {string}
+     */
+    getUnusedCustomFont (family) {
+        return StringUtil.caseInsensitiveUnusedName(
+            removeInvalidCharacters(family),
+            [
+                ...this.fonts.map(i => i.family),
+                ...this.restrictedFonts
+            ]
+        );
     }
 
     /**
      * @param {string} family
      * @returns {boolean}
      */
-    getSafeName (family) {
-        family = family.replace(/[^-\w ]/g, '');
-        return StringUtil.unusedName(family, this.fonts.map(i => i.family));
+    hasFont (family) {
+        return !!this.fonts.find(i => i.family.toLowerCase() === family.toLowerCase());
     }
 
     changed () {
@@ -56,14 +142,17 @@ class FontManager extends EventEmitter {
      * @param {string} fallback
      */
     addSystemFont (family, fallback) {
-        if (!this.isValidFamily(family)) {
-            throw new Error('Invalid family');
+        if (!this.isValidSystemFont(family)) {
+            throw new Error('Invalid system font family');
         }
-        this.fonts.push({
+        const oldFont = addOrUpdateFont(this.fonts, {
             system: true,
             family,
             fallback
         });
+        if (oldFont && !oldFont.system) {
+            this.updateRenderer();
+        }
         this.changed();
     }
 
@@ -73,17 +162,15 @@ class FontManager extends EventEmitter {
      * @param {Asset} asset scratch-storage asset
      */
     addCustomFont (family, fallback, asset) {
-        if (!this.isValidFamily(family)) {
-            throw new Error('Invalid family');
+        if (!this.isValidCustomFont(family)) {
+            throw new Error('Invalid custom font family');
         }
-
-        this.fonts.push({
+        addOrUpdateFont(this.fonts, {
             system: false,
             family,
             fallback,
             asset
         });
-
         this.updateRenderer();
         this.changed();
     }