@triflare/fx 2.0.0 → 2.1.0-beta.1

package/src/merge.js

@@ -0,0 +1,109 @@
+/**
+ * Multi-file project merge.
+ *
+ * Kept separate from `project.js` because merging is pure: it needs no
+ * filesystem access, so editor tooling (including the browser VS Code
+ * extension host) can reuse it without pulling in `node:fs`.
+ */
+import { ParseError } from "./errors.js";
+
+/** @param {object} loc */
+function errorInfo(loc) {
+  return {
+    file: loc && loc.file,
+    line: loc && loc.line,
+    column: loc && loc.column,
+  };
+}
+
+/**
+ * Merge parsed programs into a single project AST.
+ *
+ * - At most one `stage { }` declaration is allowed across all files.
+ * - Top-level statements from every file become stage content.
+ * - At most one plain `sprite "Name" { }` declaration is allowed per name.
+ *   Additional `partial sprite "Name" { }` fragments are appended to it.
+ * - Partial sprites only merge when `partialSprites` is enabled.
+ *
+ * Bodies are composed base-first, then fragments in build order, so costume
+ * order and local variable initializers stay predictable regardless of which
+ * file happens to sort first.
+ *
+ * @param {Array<{ast: object, file: string}>} entries
+ * @param {{partialSprites?: boolean, configName?: string}} [options]
+ * @returns {object} a `Program` node
+ */
+export function mergePrograms(
+  entries,
+  { partialSprites = false, configName = "fx.yml" } = {},
+) {
+  let stage = null;
+  const topItems = [];
+  /** @type {Map<string, {name: string, loc: object, base: object|null, fragments: object[], files: string[]}>} */
+  const groups = new Map();
+
+  for (const { ast, file } of entries) {
+    if (ast.stage) {
+      if (stage) {
+        throw new ParseError(
+          "A project may only declare one stage",
+          errorInfo(ast.stage.loc),
+        );
+      }
+      stage = ast.stage;
+    }
+    topItems.push(...ast.topItems);
+    for (const sprite of ast.sprites) {
+      if (sprite.partial && !partialSprites) {
+        throw new ParseError(
+          `partial sprite ${JSON.stringify(sprite.name)} is disabled; ` +
+            `set "fx.partialSprites: true" in ${configName} to enable it`,
+          errorInfo(sprite.loc),
+        );
+      }
+
+      let group = groups.get(sprite.name);
+      if (!group) {
+        group = {
+          name: sprite.name,
+          loc: sprite.loc,
+          base: null,
+          fragments: [],
+          files: [],
+        };
+        groups.set(sprite.name, group);
+      }
+      group.files.push(file);
+
+      if (sprite.partial) {
+        group.fragments.push({ decl: sprite, file });
+      } else if (group.base) {
+        throw new ParseError(
+          `Duplicate sprite ${JSON.stringify(sprite.name)} ` +
+            `(declared in ${group.base.file} and ${file}); ` +
+            `use \`partial sprite ${JSON.stringify(sprite.name)}\` to split it across files`,
+          errorInfo(sprite.loc),
+        );
+      } else {
+        group.base = { decl: sprite, file };
+      }
+    }
+  }
+
+  const sprites = [...groups.values()].map((group) => {
+    const base = group.base ? [group.base.decl] : [];
+    const fragments = group.fragments.map(({ decl }) => decl);
+    const [first] = base.length ? base : fragments;
+    return {
+      type: "SpriteDecl",
+      name: group.name,
+      body: [...base, ...fragments].flatMap((decl) => decl.body),
+      loc: first.loc,
+      open: first.open ?? null,
+      partial: false,
+      files: group.files,
+    };
+  });
+
+  return { type: "Program", stage, sprites, topItems };
+}

package/src/parser.js

@@ -127,18 +127,31 @@ class Parser {
   parseSprite(partial = false, startTok = null) {
     const tok = this.expect("sprite");
     const name = this.expectType("string", "a sprite name string").value;
-    const body = this.parseBlockBody();
-    return { type: "SpriteDecl", name, body, loc: startTok ?? tok, partial };
+    const { body, open } = this.parseBlockBody(true);
+    return {
+      type: "SpriteDecl",
+      name,
+      body,
+      loc: startTok ?? tok,
+      // Tokens are the brace's position, needed to insert declarations into
+      // the body when the brace is not on the declaration line.
+      open,
+      partial,
+    };
   }
 
   parseStage() {
     const tok = this.expect("stage");
-    const body = this.parseBlockBody();
-    return { type: "StageDecl", name: "Stage", body, loc: tok };
+    const { body, open } = this.parseBlockBody(true);
+    return { type: "StageDecl", name: "Stage", body, loc: tok, open };
   }
 
-  parseBlockBody() {
-    this.expect("{");
+  /**
+   * Parse `{ ... }`.
+   * @param {boolean} [withOpen] return `{body, open}` instead of the items only
+   */
+  parseBlockBody(withOpen = false) {
+    const open = this.expect("{");
     const items = [];
     while (!this.atPunct("}")) {
       if (this.peek().type === "eof")
@@ -146,7 +159,7 @@ class Parser {
       items.push(this.parseBodyItem());
     }
     this.expect("}");
-    return items;
+    return withOpen ? { body: items, open } : items;
   }
 
   parseBodyItem() {
@@ -161,6 +174,12 @@ class Parser {
             return this.parseVarDecl(true);
           }
           break;
+        case "thread":
+        case "runtime":
+          if (this.peek(1).type === "ident" && this.peek(1).value === "let") {
+            return this.parseTempVarDecl(tok.value);
+          }
+          break;
         case "list":
           if (this.peek(1).type === "ident") {
             return this.parseListDecl();
@@ -224,6 +243,16 @@ class Parser {
     return { type: "VarDecl", name, init, cloud, loc: tok };
   }
 
+  parseTempVarDecl(kind) {
+    const tok = this.next();
+    this.expect("let");
+    const name = this.expectIdent();
+    let init = null;
+    if (this.eat("=")) init = this.parseExpression();
+    this.expect(";");
+    return { type: "TempVarDecl", kind, name, init, loc: tok };
+  }
+
   parseListDecl() {
     const tok = this.expect("list");
     const name = this.expectIdent();
@@ -248,15 +277,16 @@ class Parser {
       const ptok = this.peek();
       const paramName = this.expectIdent();
       let boolean = false;
+      let type = null;
       // Optional type annotation: `flag: boolean`
       if (this.eat(":")) {
-        const typeName = this.expectIdent();
-        if (typeName === "boolean") boolean = true;
-        else if (typeName !== "number" && typeName !== "string") {
-          this.fail(`Unknown parameter type ${JSON.stringify(typeName)}`, ptok);
+        type = this.expectIdent();
+        if (type === "boolean") boolean = true;
+        else if (type !== "number" && type !== "string") {
+          this.fail(`Unknown parameter type ${JSON.stringify(type)}`, ptok);
         }
       }
-      params.push({ name: paramName, boolean });
+      params.push({ name: paramName, boolean, type });
       if (!this.eat(",")) break;
     }
     this.expect(")");
@@ -603,6 +633,16 @@ class Parser {
  * @param {string} [file]
  */
 export function parse(source, file = "<input>") {
-  const tokens = tokenize(source, file);
+  return parseTokens(tokenize(source, file), source, file);
+}
+
+/**
+ * Parse an existing token stream. Keeping the caller's tokens lets tools such
+ * as the formatter match AST locations back to tokens without re-lexing.
+ * @param {import('./lexer.js').Token[]} tokens
+ * @param {string} source
+ * @param {string} [file]
+ */
+export function parseTokens(tokens, source, file = "<input>") {
   return new Parser(tokens, source, file).parse();
 }

package/src/project.js

@@ -7,8 +7,8 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { ParseError } from "./errors.js";
 import { configFilename, sourceExtension } from "./brand.js";
+import { mergePrograms as mergeParsed } from "./merge.js";
 
 /** Directories never scanned for `.tfx` sources. */
 const IGNORED_DIRS = new Set([
@@ -58,99 +58,19 @@ export function discoverSources(dir) {
   return found.sort();
 }
 
-/** @param {object} loc */
-function errorInfo(loc) {
-  return {
-    file: loc && loc.file,
-    line: loc && loc.line,
-    column: loc && loc.column,
-  };
-}
-
 /**
  * Merge parsed programs into a single project AST.
  *
- * - At most one `stage { }` declaration is allowed across all files.
- * - Top-level statements from every file become stage content.
- * - At most one plain `sprite "Name" { }` declaration is allowed per name.
- *   Additional `partial sprite "Name" { }` fragments are appended to it.
- * - Partial sprites only merge when `partialSprites` is enabled.
- *
- * Bodies are composed base-first, then fragments in build order, so costume
- * order and local variable initializers stay predictable regardless of which
- * file happens to sort first.
+ * The merge itself is pure (see `merge.js`); this wrapper only injects the
+ * configured config filename so project-facing errors keep the right name.
  *
  * @param {Array<{ast: object, file: string}>} entries
  * @param {{partialSprites?: boolean}} [options]
  * @returns {object} a `Program` node
  */
-export function mergePrograms(entries, { partialSprites = false } = {}) {
-  let stage = null;
-  const topItems = [];
-  /** @type {Map<string, {name: string, loc: object, base: object|null, fragments: object[], files: string[]}>} */
-  const groups = new Map();
-
-  for (const { ast, file } of entries) {
-    if (ast.stage) {
-      if (stage) {
-        throw new ParseError(
-          "A project may only declare one stage",
-          errorInfo(ast.stage.loc),
-        );
-      }
-      stage = ast.stage;
-    }
-    topItems.push(...ast.topItems);
-    for (const sprite of ast.sprites) {
-      if (sprite.partial && !partialSprites) {
-        throw new ParseError(
-          `partial sprite ${JSON.stringify(sprite.name)} is disabled; ` +
-            `set "fx.partialSprites: true" in ${configFilename()} to enable it`,
-          errorInfo(sprite.loc),
-        );
-      }
-
-      let group = groups.get(sprite.name);
-      if (!group) {
-        group = {
-          name: sprite.name,
-          loc: sprite.loc,
-          base: null,
-          fragments: [],
-          files: [],
-        };
-        groups.set(sprite.name, group);
-      }
-      group.files.push(file);
-
-      if (sprite.partial) {
-        group.fragments.push({ decl: sprite, file });
-      } else if (group.base) {
-        throw new ParseError(
-          `Duplicate sprite ${JSON.stringify(sprite.name)} ` +
-            `(declared in ${group.base.file} and ${file}); ` +
-            `use \`partial sprite ${JSON.stringify(sprite.name)}\` to split it across files`,
-          errorInfo(sprite.loc),
-        );
-      } else {
-        group.base = { decl: sprite, file };
-      }
-    }
-  }
-
-  const sprites = [...groups.values()].map((group) => {
-    const base = group.base ? [group.base.decl] : [];
-    const fragments = group.fragments.map(({ decl }) => decl);
-    const [first] = base.length ? base : fragments;
-    return {
-      type: "SpriteDecl",
-      name: group.name,
-      body: [...base, ...fragments].flatMap((decl) => decl.body),
-      loc: first.loc,
-      partial: false,
-      files: group.files,
-    };
+export function mergePrograms(entries, options = {}) {
+  return mergeParsed(entries, {
+    ...options,
+    configName: configFilename(),
   });
-
-  return { type: "Program", stage, sprites, topItems };
 }

package/vendor/pm-packager-dist/.fx-build.json

@@ -2,5 +2,5 @@
   "name": "@penguinmod/packager",
   "version": "1.9.2",
   "commit": "53f868b85ec21d2edab9ce00fd2d709da93da6d6",
-  "builtAt": "2026-11-05T20:22:27.350Z"
+  "builtAt": "2026-11-06T05:46:49.113Z"
 }

package/vendor/tempvars/fx-tempvars.js

@@ -0,0 +1,321 @@
+// Fx fork of Temporary Variables (upstream id lmsTempVars2).
+// Only the extension id and the runtime expose key differ; see README.md.
+//
+// Name: Temporary Variables
+// ID: fxTempVars
+// Description: Create disposable runtime or thread variables.
+// By: LilyMakesThings <https://scratch.mit.edu/users/LilyMakesThings/>
+// By: Mio <https://scratch.mit.edu/users/0znzw/>
+// License: MIT AND LGPL-3.0
+
+/* generated l10n code */Scratch.translate.setup({"de":{"_Temporary Variables":"Temporäre Variablen"},"fi":{"_Runtime Variables":"Ajonaikaiset muuttujat","_Temporary Variables":"Väliaikaiset muuttujat","_Thread Variables":"Säiemuuttujat","_active runtime variables":"käytössä olevat ajonaikaiset muuttujat","_active thread variables":"käytössä olevat säiemuuttujat","_change runtime var [VAR] by [NUM]":"lisää ajonaikaiseen muuttujaan [VAR] arvo [NUM]","_change thread var [VAR] by [NUM]":"lisää säiemuuttujaan [VAR] arvo [NUM]","_delete all runtime variables":"poista kaikki ajonaikaiset muuttujat","_delete runtime var [VAR]":"poista ajonaikainen muuttuja [VAR]","_for [VAR] in [NUM]":"toista [NUM] kertaa ja laske säiemuuttujalla [VAR]","_runtime var [VAR]":"ajonaikainen muuttuja [VAR]","_runtime var [VAR] exists?":"onko ajonaikainen muuttuja [VAR] olemassa?","_set runtime var [VAR] to [STRING]":"aseta ajonaikainen muuttuja [VAR] arvoon [STRING] ","_set thread var [VAR] to [STRING]":"aseta säiemuuttuja [VAR] arvoon [STRING]","_thread var [VAR]":"säiemuuttuja [VAR]","_thread var [VAR] exists?":"onko säiemuuttuja [VAR] olemassa?"},"it":{"_Runtime Variables":"Variabili Runtime","_Temporary Variables":"Variabili Temporanee","_Thread Variables":"Varabili del Thread","_active runtime variables":"variabili runtime attive","_active thread variables":"variabili del thread attivo","_change runtime var [VAR] by [NUM]":"change variabile runtime [VAR] di [NUM]","_change thread var [VAR] by [NUM]":"cambia variabile [VAR] del thread di [NUM]","_delete all runtime variables":"rimuovi tutte le variabili runtime","_delete runtime var [VAR]":"rimuovi variabile runtime [VAR]","_for [VAR] in [NUM]":"per ciascun valore della variabile [VAR] da 1 a [NUM]","_runtime var [VAR]":"variabile runtime [VAR]","_runtime var [VAR] exists?":"variabile runtime [VAR] esiste","_set runtime var [VAR] to [STRING]":"imposta variabile runtime [VAR] a [STRING]","_set thread var [VAR] to [STRING]":"imposta variabile [VAR] del thread a [STRING]","_thread var [VAR]":"variabile [VAR] del thread","_thread var [VAR] exists?":"variabile [VAR] del thread esiste"},"ja":{"_Runtime Variables":"ランタイム変数","_Temporary Variables":"一時変数","_Thread Variables":"スレッド変数","_active runtime variables":"アクティブなランタイム変数","_active thread variables":"アクティブなスレッド変数","_change runtime var [VAR] by [NUM]":"ランタイム変数[VAR]を[NUM]ずつ変える","_change thread var [VAR] by [NUM]":"スレッド変数[VAR]を[NUM]ずつ変える","_delete all runtime variables":"すべてのランタイム変数を削除する","_delete runtime var [VAR]":"ランタイム変数[VAR]を削除する","_for [VAR] in [NUM]":"[NUM]の要素を[VAR]に入れて繰り返す","_runtime var [VAR]":"ランタイム変数[VAR]","_runtime var [VAR] exists?":"ランタイム変数[VAR]が存在している","_set runtime var [VAR] to [STRING]":"ランタイム変数[VAR]を[STRING]にする","_set thread var [VAR] to [STRING]":"スレッド変数[VAR]を[STRING]にする","_thread var [VAR]":"スレッド変数[VAR]","_thread var [VAR] exists?":"スレッド変数[VAR]が存在している"},"ko":{"_Runtime Variables":"런타임 변수","_Temporary Variables":"일시적 변수","_Thread Variables":"스레드 변수","_active runtime variables":"활성화된 런타임 변수 목록","_active thread variables":"활성화된 스레드 변수 목록","_change runtime var [VAR] by [NUM]":"런타임 변수 [VAR]을(를) [NUM]만큼 바꾸기","_change thread var [VAR] by [NUM]":"스레드 변수 [VAR]을(를) [NUM]만큼 바꾸기","_delete all runtime variables":"모든 런타임 변수 삭제하기","_delete runtime var [VAR]":"런타임 변수 [VAR] 삭제하기","_for [VAR] in [NUM]":"[NUM]만큼 [VAR](으)로 순회하기","_runtime var [VAR]":"런타임 변수 [VAR]","_runtime var [VAR] exists?":"런타임 변수 [VAR]이(가) 존재하는가?","_set runtime var [VAR] to [STRING]":"런타임 변수 [VAR]을(를) [STRING](으)로 정하기","_set thread var [VAR] to [STRING]":"스레드 변수 [VAR]을(를) [STRING](으)로 정하기","_thread var [VAR]":"스레드 변수 [VAR]","_thread var [VAR] exists?":"스레드 변수 [VAR]이(가) 존재하는가?"},"nb":{"_Temporary Variables":"Midlertidige variabler"},"nl":{"_Runtime Variables":"Looptijdvariabelen","_Temporary Variables":"Tijdelijke variabelen","_Thread Variables":"Threadvariabelen","_active runtime variables":"actieve looptijdvariabelen","_active thread variables":"actieve threadvariabelen","_change runtime var [VAR] by [NUM]":"verander looptijdvar. [VAR] met [NUM]","_change thread var [VAR] by [NUM]":"verander threadvar. [VAR] met [NUM]","_delete all runtime variables":"verwijder alle looptijdvariabelen","_delete runtime var [VAR]":"verwijder looptijdvar. [VAR]","_for [VAR] in [NUM]":"voor elke [VAR] in [NUM]","_runtime var [VAR]":"looptijdvar. [VAR]","_runtime var [VAR] exists?":"looptijdvar. [VAR] bestaat?","_set runtime var [VAR] to [STRING]":"maak looptijdvar. [VAR] [STRING]","_set thread var [VAR] to [STRING]":"maak threadvar. [VAR] [STRING]","_thread var [VAR]":"threadvar. [VAR]","_thread var [VAR] exists?":"threadvar. [VAR] bestaat?"},"ru":{"_Runtime Variables":"Время Выполнения Переменных","_Temporary Variables":"Временные Переменные","_Thread Variables":"Переменные Ветки","_active runtime variables":"активные переменные с временем выполнения","_active thread variables":"активные веточные переменные","_change runtime var [VAR] by [NUM]":"изменить время выполнения переменной [VAR] в [NUM]","_change thread var [VAR] by [NUM]":"изменить веточную переменную [VAR] на [NUM]","_delete all runtime variables":"удалить все переменные с временем выполнения","_delete runtime var [VAR]":"удалить переменную [VAR] с временем выполнения","_for [VAR] in [NUM]":"повторить [VAR] раз [NUM]","_runtime var [VAR]":"время выполнения переменной [VAR]","_runtime var [VAR] exists?":"время выполнения для переменной [VAR] существует?","_set runtime var [VAR] to [STRING]":"задать время выполнения переменной [VAR] в [STRING]","_set thread var [VAR] to [STRING]":"задать веточную переменную [VAR] в [STRING]","_thread var [VAR]":"веточная переменная [VAR]","_thread var [VAR] exists?":"веточная переменная [VAR] существует?"},"tr":{"_Temporary Variables":"Geçici Değişkenler"},"uk":{"_Temporary Variables":"Тимчасові Змінні"},"zh-cn":{"_Runtime Variables":"临时变量","_Temporary Variables":"临时变量","_Thread Variables":"线程变量","_active runtime variables":"所有临时变量","_active thread variables":"所有线程变量","_change runtime var [VAR] by [NUM]":"将临时变量[VAR]增加[NUM]","_change thread var [VAR] by [NUM]":"将线程变量[VAR]增加[NUM]","_delete all runtime variables":"删除所有临时变量","_delete runtime var [VAR]":"删除临时变量[VAR]","_for [VAR] in [NUM]":"对于[NUM]中的每个线程变量[VAR]","_runtime var [VAR]":"临时变量[VAR]","_runtime var [VAR] exists?":"临时变量[VAR]是否存在？","_set runtime var [VAR] to [STRING]":"将临时变量[VAR]设为[STRING]","_set thread var [VAR] to [STRING]":"将线程变量[VAR]设为[STRING]","_thread var [VAR]":"线程变量[VAR]","_thread var [VAR] exists?":"线程变量[VAR]是否存在？"}});/* end generated l10n code */(function (Scratch) {
+  "use strict";
+
+  // Credit to skyhigh173 for the idea of this.
+  const label = (name, hidden) => ({
+    blockType: Scratch.BlockType.LABEL,
+    text: name,
+    hideFromPalette: hidden,
+  });
+
+  class TempVars {
+    constructor() {
+      // this.resetRuntimeVariables would be preferable but,
+      // its easier on TS when defined in the constructor,
+      // and not abstracted out.
+      //
+      // Object.create(null) prevents "variable [toString]" from returning a function.
+      this.runtimeVariables = Object.create(null);
+
+      Scratch.vm.runtime.on("PROJECT_START", () => {
+        this.resetRuntimeVariables();
+      });
+
+      Scratch.vm.runtime.on("PROJECT_STOP_ALL", () => {
+        this.resetRuntimeVariables();
+      });
+    }
+
+    getInfo() {
+      return {
+        id: "fxTempVars",
+        name: Scratch.translate("Temporary Variables"),
+        color1: "#FF791A",
+        color2: "#E15D00",
+        blocks: [
+          label(Scratch.translate("Thread Variables"), false),
+
+          {
+            opcode: "setThreadVariable",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("set thread var [VAR] to [STRING]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+              STRING: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "0",
+              },
+            },
+          },
+          {
+            opcode: "changeThreadVariable",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("change thread var [VAR] by [NUM]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+              NUM: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: "1",
+              },
+            },
+          },
+
+          "---",
+
+          {
+            opcode: "getThreadVariable",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("thread var [VAR]"),
+            disableMonitor: true,
+            allowDropAnywhere: true,
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+            },
+          },
+          {
+            opcode: "threadVariableExists",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("thread var [VAR] exists?"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+            },
+          },
+
+          "---",
+
+          {
+            opcode: "forEachThreadVariable",
+            blockType: Scratch.BlockType.LOOP,
+            text: Scratch.translate("for [VAR] in [NUM]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "thread variable",
+              },
+              NUM: {
+                type: Scratch.ArgumentType.NUMBER,
+                defaultValue: "10",
+              },
+            },
+          },
+          {
+            opcode: "listThreadVariables",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("active thread variables"),
+            disableMonitor: true,
+          },
+
+          "---",
+
+          label(Scratch.translate("Runtime Variables"), false),
+
+          {
+            opcode: "setRuntimeVariable",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("set runtime var [VAR] to [STRING]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+              STRING: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "0",
+              },
+            },
+          },
+          {
+            opcode: "changeRuntimeVariable",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("change runtime var [VAR] by [NUM]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+              NUM: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "1",
+              },
+            },
+          },
+
+          "---",
+
+          {
+            opcode: "getRuntimeVariable",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("runtime var [VAR]"),
+            disableMonitor: true,
+            allowDropAnywhere: true,
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+            },
+          },
+          {
+            opcode: "runtimeVariableExists",
+            blockType: Scratch.BlockType.BOOLEAN,
+            text: Scratch.translate("runtime var [VAR] exists?"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+            },
+          },
+
+          "---",
+
+          {
+            opcode: "deleteRuntimeVariable",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("delete runtime var [VAR]"),
+            arguments: {
+              VAR: {
+                type: Scratch.ArgumentType.STRING,
+                defaultValue: "variable",
+              },
+            },
+          },
+          {
+            opcode: "deleteAllRuntimeVariables",
+            func: "resetRuntimeVariables",
+            blockType: Scratch.BlockType.COMMAND,
+            text: Scratch.translate("delete all runtime variables"),
+          },
+          {
+            opcode: "listRuntimeVariables",
+            blockType: Scratch.BlockType.REPORTER,
+            text: Scratch.translate("active runtime variables"),
+          },
+        ],
+      };
+    }
+
+    /* THREAD VARIABLES */
+
+    setThreadVariable(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      thread.variables[args.VAR] = args.STRING;
+    }
+
+    changeThreadVariable(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      const vars = thread.variables;
+      const prev = Scratch.Cast.toNumber(vars[args.VAR]);
+      const next = Scratch.Cast.toNumber(args.NUM);
+      vars[args.VAR] = prev + next;
+    }
+
+    getThreadVariable(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      return thread.variables[args.VAR] ?? "";
+    }
+
+    threadVariableExists(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      return Object.prototype.hasOwnProperty.call(thread.variables, args.VAR);
+    }
+
+    forEachThreadVariable(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      const vars = thread.variables;
+      if (!Object.prototype.hasOwnProperty.call(util.stackFrame, "index")) {
+        util.stackFrame.index = 0;
+      }
+      if (util.stackFrame.index < Scratch.Cast.toNumber(args.NUM)) {
+        util.stackFrame.index++;
+        vars[args.VAR] = util.stackFrame.index;
+        return true;
+      }
+    }
+
+    listThreadVariables(args, util) {
+      const thread = util.thread;
+      if (!thread.variables) {
+        thread.variables = Object.create(null);
+      }
+      return Object.keys(thread.variables).join(",");
+    }
+
+    /* RUNTIME VARIABLES */
+
+    setRuntimeVariable(args) {
+      this.runtimeVariables[args.VAR] = args.STRING;
+    }
+
+    changeRuntimeVariable(args) {
+      const prev = Scratch.Cast.toNumber(this.runtimeVariables[args.VAR]);
+      const next = Scratch.Cast.toNumber(args.NUM);
+      this.runtimeVariables[args.VAR] = prev + next;
+    }
+
+    getRuntimeVariable(args) {
+      return this.runtimeVariables[args.VAR] ?? "";
+    }
+
+    runtimeVariableExists(args) {
+      return Object.prototype.hasOwnProperty.call(
+        this.runtimeVariables,
+        args.VAR
+      );
+    }
+
+    listRuntimeVariables(args, util) {
+      return Object.keys(this.runtimeVariables).join(",");
+    }
+
+    deleteRuntimeVariable(args) {
+      Reflect.deleteProperty(this.runtimeVariables, args.VAR);
+    }
+
+    resetRuntimeVariables() {
+      this.runtimeVariables = Object.create(null);
+    }
+  }
+  // The expose format follows TurboWarp's convention of `ext_${extensionId}`.
+  // Expose the extension on runtime for others to use.
+  const extension = new TempVars();
+  Scratch.vm.runtime.ext_fxTempVars = extension;
+  Scratch.extensions.register(extension);
+})(Scratch);