@triflare/fx 2.0.0 → 2.1.0-beta.2

package/src/vm.js

@@ -0,0 +1,325 @@
+/**
+ * Headless PenguinMod VM adapter.
+ *
+ * `fx test` runs projects against the real PenguinMod runtime. The VM is a
+ * browser module that touches a handful of DOM globals at import time, so this
+ * module provides minimal in-memory stand-ins for storage and rendering and
+ * requires the VM lazily. Loading a project never draws anything, so the
+ * no-op renderer is enough to deserialize targets, costumes, and blocks.
+ *
+ * The VM is shipped as a runtime dependency: `fx test` reports a clear
+ * error when it is not installed instead of failing at import time.
+ */
+import crypto from "node:crypto";
+import { createRequire } from "node:module";
+import { runInThisContext } from "node:vm";
+
+let modules = null;
+
+/** Blob URLs the VM created for project extension sources, keyed by URL. */
+const extensionBlobs = new Map();
+
+/** Install the DOM globals the VM reads while it is being imported. */
+function installGlobals() {
+  globalThis.location ||= {
+    search: "",
+    href: "http://localhost/",
+    origin: "http://localhost",
+    protocol: "http:",
+    host: "localhost",
+    hostname: "localhost",
+    pathname: "/",
+    hash: "",
+  };
+  globalThis.DOMParser ||= class {
+    parseFromString() {
+      const empty = () => [];
+      return {
+        querySelectorAll: empty,
+        getElementsByTagName: empty,
+        querySelector: () => null,
+      };
+    }
+  };
+  globalThis.window ||= globalThis;
+  globalThis.self ||= globalThis;
+
+  // The VM loads a project extension like a page does: fetch its URL, wrap the
+  // result in a Blob, read that Blob with FileReader, then append a script.
+  // These shims keep that flow working without a DOM.
+  globalThis.FileReader ||= class {
+    readAsText(blob) {
+      Promise.resolve(blob.text()).then(
+        (result) => this.onload?.({ target: { result } }),
+        (error) => this.onerror?.(error),
+      );
+    }
+  };
+  if (!globalThis.URL.createObjectURL.__fxHeadless) {
+    const createObjectURL = globalThis.URL.createObjectURL.bind(globalThis.URL);
+    globalThis.URL.createObjectURL = (blob) => {
+      const url = createObjectURL(blob);
+      extensionBlobs.set(url, blob);
+      return url;
+    };
+    globalThis.URL.createObjectURL.__fxHeadless = true;
+  }
+
+  /** Run an appended `<script>` whose `src` is one of the VM's Blob URLs. */
+  const runScript = (node) => {
+    const blob = extensionBlobs.get(node.src);
+    if (!blob) {
+      node.onerror?.(new Error(`Cannot read extension script ${node.src}`));
+      return;
+    }
+    Promise.resolve(blob.text()).then(
+      (source) => {
+        try {
+          // The unsandboxed loader installs `global.Scratch` before appending
+          // the script, so evaluating here matches a browser script tag.
+          runInThisContext(source, { filename: node.src });
+          node.onload?.();
+        } catch (error) {
+          node.onerror?.(error);
+        }
+      },
+      (error) => node.onerror?.(error),
+    );
+  };
+
+  globalThis.document ||= {
+    createElement: (tagName) => ({
+      tagName: String(tagName).toUpperCase(),
+      style: {},
+      getContext: () => null,
+      appendChild() {},
+      setAttribute() {},
+      addEventListener() {},
+      remove() {},
+    }),
+    body: {
+      appendChild(node) {
+        if (node?.tagName === "SCRIPT") runScript(node);
+      },
+    },
+    querySelector: () => null,
+    addEventListener() {},
+  };
+}
+
+/**
+ * Load `scratch-vm` on first use.
+ * @returns {{VirtualMachine: any, centralDispatch: any}}
+ */
+export function loadVmModules() {
+  if (modules) return modules;
+  installGlobals();
+  const require = createRequire(import.meta.url);
+  let VirtualMachine;
+  let centralDispatch;
+  try {
+    VirtualMachine = require("scratch-vm");
+    centralDispatch = require("scratch-vm/src/dispatch/central-dispatch");
+  } catch (error) {
+    throw new Error(
+      "Running tests needs the PenguinMod VM, which could not be loaded. " +
+        "Reinstall @triflare/fx with its runtime dependencies and try again.",
+      { cause: error },
+    );
+  }
+  modules = { VirtualMachine, centralDispatch };
+  return modules;
+}
+
+const AssetType = {
+  ImageVector: { name: "ImageVector", runtimeFormat: "svg" },
+  ImageBitmap: { name: "ImageBitmap", runtimeFormat: "png" },
+  Sound: { name: "Sound", runtimeFormat: "wav" },
+};
+
+const DataFormat = {
+  SVG: "svg",
+  PNG: "png",
+  JPG: "jpg",
+  BMP: "bmp",
+  GIF: "gif",
+  WAV: "wav",
+  MP3: "mp3",
+  OGG: "ogg",
+  FLAC: "flac",
+};
+
+const md5 = (data) =>
+  crypto.createHash("md5").update(Buffer.from(data)).digest("hex");
+
+/** In-memory storage module so the VM can load assets headlessly. */
+export function createStorage() {
+  return {
+    AssetType,
+    DataFormat,
+    createAsset(assetType, dataFormat, data, assetId, generateId) {
+      const bytes =
+        data instanceof Uint8Array ? data : new Uint8Array(data ?? []);
+      return {
+        assetType,
+        dataFormat,
+        data: bytes,
+        assetId: assetId ?? (generateId ? md5(bytes) : null),
+        clean: true,
+        encodeDataURI() {
+          const base64 = Buffer.from(this.data).toString("base64");
+          return `data:${dataFormat};base64,${base64}`;
+        },
+        decodeText() {
+          return Buffer.from(this.data).toString("utf8");
+        },
+        encodeTextData(text) {
+          this.data = new Uint8Array(Buffer.from(text, "utf8"));
+          this.assetId = md5(this.data);
+        },
+      };
+    },
+  };
+}
+
+/** No-op renderer: enough state for blocks that inspect or create skins. */
+export function createRenderer() {
+  let nextId = 0;
+  const skins = {};
+  const createSkin = (size = [0, 0]) => {
+    const skinId = nextId++;
+    skins[skinId] = {
+      id: skinId,
+      renderQuality: 1,
+      _size: size,
+      _setTexture() {},
+    };
+    return skinId;
+  };
+  return {
+    _allSkins: skins,
+    _groupOrdering: [],
+    useHighQualityRender: true,
+    setLayerGroupOrdering() {},
+    setPrivateSkinAccess() {},
+    setUseHighQualityRender() {},
+    setRenderOffscreen() {},
+    setStageSize() {},
+    draw() {},
+    markDrawableAsNoninteractive() {},
+    createDrawable() {
+      return nextId++;
+    },
+    destroyDrawable() {},
+    updateDrawableSkinId() {},
+    updateDrawablePosition() {},
+    updateDrawableDirectionScale() {},
+    updateDrawableVisible() {},
+    updateDrawableEffect() {},
+    setDrawableOrder() {},
+    getDrawableOrder() {
+      return 0;
+    },
+    getFencedPositionOfDrawable(id, position) {
+      return position;
+    },
+    getBounds() {
+      return { left: 0, right: 0, top: 0, bottom: 0 };
+    },
+    getBoundsForBubble() {
+      return { left: 0, right: 0, top: 0, bottom: 0 };
+    },
+    isTouchingDrawables() {
+      return false;
+    },
+    drawableTouching() {
+      return false;
+    },
+    getTouchingDrawablesPoint() {
+      return [];
+    },
+    isTouchingColor() {
+      return false;
+    },
+    createSVGSkin() {
+      return createSkin();
+    },
+    createBitmapSkin() {
+      return createSkin();
+    },
+    createPenSkin() {
+      return createSkin();
+    },
+    getSkinSize(skinId) {
+      return skins[skinId] ? skins[skinId]._size : [0, 0];
+    },
+    getSkinRotationCenter() {
+      return [0, 0];
+    },
+    penClear() {},
+    penLine() {},
+    penPoint() {},
+    penStamp() {},
+    penTranslate() {},
+  };
+}
+
+/**
+ * Create a headless VM with in-memory storage and a no-op renderer.
+ *
+ * Project extensions are plain JavaScript, and the only way to run them here is
+ * unsandboxed in this Node process: loading one is equivalent to running the
+ * project's code with full filesystem and network access. Nothing is loaded
+ * unless `allowProjectExtensions` is set. Callers opt in explicitly (for `fx
+ * test` that means the user passes `--allow-project-extensions`) to state that
+ * the project's extensions are trusted for this run.
+ *
+ * The dispatch broker is a process-wide singleton; dropping its services keeps
+ * one VM's extensions from logging a provider conflict for the next.
+ *
+ * @param {{allowProjectExtensions?: boolean}} [options]
+ */
+export function createVm({ allowProjectExtensions = false } = {}) {
+  const { VirtualMachine, centralDispatch } = loadVmModules();
+  centralDispatch.services = {};
+  const vm = new VirtualMachine();
+  vm.attachStorage(createStorage());
+  vm.attachRenderer(createRenderer());
+  // Denying the load keeps both the extension source and its top-level code
+  // from running, even when the project only configured it and no block uses
+  // it. The VM reports "Permission to load extension denied" for the project.
+  vm.securityManager.canLoadExtensionFromProject = () =>
+    Promise.resolve(allowProjectExtensions);
+  // Node has neither the web worker nor the iframe sandbox the VM would use, so
+  // a permitted extension runs in this process, exactly like PenguinMod's
+  // unsandboxed mode. Denied extensions never reach the sandbox selector.
+  vm.securityManager.getSandboxMode = () =>
+    Promise.resolve(allowProjectExtensions ? "unsandboxed" : "iframe");
+  return vm;
+}
+
+/**
+ * Build a fresh VM and load an sb3/pmp buffer into it.
+ * @param {Buffer} sb3
+ * @param {{allowProjectExtensions?: boolean}} [options]
+ */
+export const loadProject = async (sb3, options = {}) => {
+  const vm = createVm(options);
+  // Loading an extension logs its whole source to the console; keep reporter
+  // output (especially JSON and JUnit) parseable.
+  const log = console.log;
+  console.log = () => {};
+  try {
+    await vm.loadProject(sb3);
+  } catch (error) {
+    try {
+      vm.stopAll();
+    } catch {
+      // Preserve the original load error if cleanup also fails.
+    }
+    throw error;
+  } finally {
+    console.log = log;
+  }
+  return vm;
+};

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);