@triflare/fx 2.0.0 → 2.1.0-beta.2

package/src/compiler.js

@@ -137,6 +137,7 @@ export class Compiler {
     this.loadAsset = loadAsset || null;
     this.catalog = catalog ? { ...CATALOG, ...catalog } : CATALOG;
     this.extensionUrls = extensionUrls;
+    this.requiredExtensions = new Map();
     this.file = file;
     /** @type {string[]} Non-fatal problems worth surfacing to the user. */
     this.warnings = [];
@@ -252,6 +253,8 @@ export class Compiler {
     // can only be given their mutation once every stack is complete.
     for (const ctx of contexts) this.applyDynamicNextMutations(ctx);
 
+    this.validateRequiredExtensions();
+
     return { project: this.assembleProject(contexts), assets: this.assets };
   }
 
@@ -335,6 +338,11 @@ export class Compiler {
   }
 
   declareTargetVar(ctx, decl) {
+    if (decl.name.startsWith("$"))
+      this.fail(
+        `Names starting with "$" are reserved for temporary variables; rename ${JSON.stringify(decl.name)}.`,
+        decl.loc,
+      );
     const global = ctx.isStage;
     if (global && this.globals.has(decl.name)) {
       const first = this.globals.get(decl.name);
@@ -380,6 +388,11 @@ export class Compiler {
   }
 
   declareTargetList(ctx, decl) {
+    if (decl.name.startsWith("$"))
+      this.fail(
+        `Names starting with "$" are reserved for temporary variables; rename ${JSON.stringify(decl.name)}.`,
+        decl.loc,
+      );
     if (ctx.isStage && this.globals.has(decl.name)) {
       const first = this.globals.get(decl.name);
       const where = this.where(first.loc);
@@ -421,6 +434,13 @@ export class Compiler {
         decl.loc,
       );
     }
+    for (const param of decl.params) {
+      if (param.name.startsWith("$"))
+        this.fail(
+          `Names starting with "$" are reserved for temporary variables; rename parameter ${JSON.stringify(param.name)}.`,
+          decl.loc,
+        );
+    }
     const argIds = decl.params.map((_, i) => `arg${i}`);
     const proccode = decl.params.length
       ? `${decl.name} ${decl.params.map((param) => (param.boolean ? "%b" : "%s")).join(" ")}`
@@ -785,6 +805,8 @@ export class Compiler {
         return this.compileForever(ctx, node);
       case "Return":
         return this.compileReturn(ctx, node);
+      case "TempVarDecl":
+        return this.compileTempVarDecl(ctx, node);
       default:
         this.fail(`Unsupported statement ${node.type}`, node.loc);
     }
@@ -824,6 +846,13 @@ export class Compiler {
   }
 
   compileAssign(ctx, node) {
+    const sigil = /^(\$\$?)([A-Za-z_][A-Za-z0-9_]*)$/.exec(node.name);
+    if (sigil) return this.compileSigilAssign(ctx, node, sigil);
+    if (node.name.startsWith("$"))
+      this.fail(
+        `Invalid temporary variable reference ${JSON.stringify(node.name)}`,
+        node.loc,
+      );
     const resolved = ctx.resolveValue(node.name);
     if (!resolved || resolved.kind !== "var") {
       this.fail(`Unknown variable ${JSON.stringify(node.name)}`, node.loc);
@@ -880,6 +909,64 @@ export class Compiler {
     return id;
   }
 
+  compileTempVarDecl(ctx, node) {
+    if (node.name.startsWith("$"))
+      this.fail(
+        'Temporary variable names cannot start with "$"; use a plain name.',
+        node.loc,
+      );
+    const name =
+      node.kind === "runtime" ? "tempvars.setRuntime" : "tempvars.setThread";
+    const entry = this.catalog[name];
+    if (!entry)
+      this.fail(
+        "Temporary variables are not available in this Fx build",
+        node.loc,
+      );
+    return this.emitCatalogCall(
+      ctx,
+      {
+        name,
+        segments: name.split("."),
+        args: [
+          { type: "String", value: node.name, loc: node.loc },
+          node.init ?? { type: "String", value: "0", loc: node.loc },
+        ],
+        loc: node.loc,
+      },
+      entry,
+      null,
+    ).id;
+  }
+
+  compileSigilAssign(ctx, node, sigil) {
+    if (node.op !== "=" && node.op !== "+=")
+      this.fail(
+        `Temporary variables only support "=" and "+="; ${JSON.stringify(node.op)} is not available.`,
+        node.loc,
+      );
+    const kind = sigil[1] === "$$" ? "Runtime" : "Thread";
+    const action = node.op === "=" ? "set" : "change";
+    const name = `tempvars.${action}${kind}`;
+    const entry = this.catalog[name];
+    if (!entry)
+      this.fail(
+        "Temporary variables are not available in this Fx build",
+        node.loc,
+      );
+    return this.emitCatalogCall(
+      ctx,
+      {
+        name,
+        segments: name.split("."),
+        args: [{ type: "String", value: sigil[2], loc: node.loc }, node.value],
+        loc: node.loc,
+      },
+      entry,
+      null,
+    ).id;
+  }
+
   compileIf(ctx, node) {
     const id = this.addBlock(ctx, {
       opcode: node.else ? "control_if_else" : "control_if",
@@ -976,6 +1063,11 @@ export class Compiler {
   emitCatalogCall(ctx, node, entry, parentId) {
     if (entry.kind === "hat")
       this.fail(`${node.name} is an event and cannot be called`, node.loc);
+    if (entry.requiresExtension) {
+      const id = entry.extension || extensionForOpcode(entry.opcode);
+      if (id && !this.requiredExtensions.has(id))
+        this.requiredExtensions.set(id, node.loc);
+    }
     const id = this.addBlock(ctx, { opcode: entry.opcode, parent: parentId });
     const fieldNames = Object.keys(entry.fields || {});
     const inputNames = Object.keys(entry.inputs || {});
@@ -1282,6 +1374,33 @@ export class Compiler {
   }
 
   emitIdentifier(ctx, node) {
+    const sigil = /^(\$\$?)([A-Za-z_][A-Za-z0-9_]*)$/.exec(node.name);
+    if (sigil) {
+      const name = sigil[1] === "$$" ? "tempvars.runtime" : "tempvars.thread";
+      const entry = this.catalog[name];
+      if (!entry)
+        this.fail(
+          "Temporary variables are not available in this Fx build",
+          node.loc,
+        );
+      const result = this.emitCatalogCall(
+        ctx,
+        {
+          name,
+          segments: name.split("."),
+          args: [{ type: "String", value: sigil[2], loc: node.loc }],
+          loc: node.loc,
+        },
+        entry,
+        null,
+      );
+      return { k: "block", id: result.id, kind: "reporter" };
+    }
+    if (node.name.startsWith("$"))
+      this.fail(
+        `Invalid temporary variable reference ${JSON.stringify(node.name)}`,
+        node.loc,
+      );
     if (node.segments.length > 1)
       this.fail(
         `Unexpected dotted name ${JSON.stringify(node.name)}`,
@@ -1537,6 +1656,20 @@ export class Compiler {
 
   // ------------------------------------------------------------ assembly
 
+  validateRequiredExtensions() {
+    for (const [id, loc] of this.requiredExtensions) {
+      if (this.extensionUrls[id]) continue;
+      const feature = id === "fxTempVars" ? "temporaryvariables" : null;
+      const hint = feature
+        ? ` Run "fx feature ${feature} enable" to install it.`
+        : "";
+      this.fail(
+        `This project uses blocks from extension ${JSON.stringify(id)}, which is not loaded.${hint}`,
+        loc,
+      );
+    }
+  }
+
   assembleProject(contexts) {
     const targets = [];
     const extensions = new Set();

package/src/config-edit.js

@@ -615,3 +615,200 @@ export function removeVendorEntry(configPath, name) {
   writeDocument(configPath, lines.join(""));
   return { removed: source ?? key };
 }
+
+// -------------------------------------------------------------- feature edits
+
+/**
+ * Add or replace a `features:` entry without reformatting the rest of fx.yml.
+ *
+ * @param {string} configPath
+ * @param {string} name
+ * @param {string} file
+ * @returns {{added: boolean, updated: boolean}}
+ */
+export function addFeatureEntry(configPath, name, file) {
+  const text = fs.readFileSync(configPath, "utf8");
+  const lines = splitLines(text);
+  const eol = eolOf(text);
+  const key = String(name);
+  let added = false;
+  let updated = false;
+  const entryLine = (indent) =>
+    `${indent}${quoteKey(key)}: ${quote(file)}${eol}`;
+
+  const bounds = topLevelBounds(lines, "features");
+  if (!bounds) {
+    if (lines.length > 0 && !lines[lines.length - 1].endsWith("\n"))
+      lines[lines.length - 1] += eol;
+    lines.push(`features:${eol}`, entryLine("  "));
+    added = true;
+  } else if (bounds.inline) {
+    const mapping = parseValue(bounds.inline) || {};
+    updated = Object.hasOwn(mapping, key);
+    added = !updated;
+    mapping[key] = file;
+    const dumped = yaml
+      .dump({ features: mapping }, { lineWidth: -1, noRefs: true })
+      .split("\n")
+      .filter((line, index, all) => !(index === all.length - 1 && line === ""))
+      .map((line) => `${line}${eol}`);
+    if (bounds.comment) dumped[0] = `features: ${bounds.comment}${eol}`;
+    replaceRange(lines, bounds.index, bounds.index + 1, dumped);
+  } else {
+    const spans = mappingEntrySpans(lines, bounds.index, bounds.end);
+    const existing = spans.find((span) => span.key === key);
+    if (existing) {
+      replaceRange(lines, existing.index, existing.end, [
+        entryLine(existing.indent),
+      ]);
+      updated = true;
+    } else {
+      const indent = childIndent(lines, bounds.index, bounds.end);
+      insertAt(lines, bounds.end, [entryLine(indent)], eol);
+      added = true;
+    }
+  }
+
+  if (added || updated) writeDocument(configPath, lines.join(""));
+  return { added, updated };
+}
+
+/** Read a raw `fx.<key>` value without normalising the rest of the config. */
+export function readFxValue(configPath, key) {
+  const raw = yaml.load(fs.readFileSync(configPath, "utf8")) ?? {};
+  if (typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const fx = raw.fx;
+  if (!fx || typeof fx !== "object" || Array.isArray(fx)) return undefined;
+  return fx[key];
+}
+
+/**
+ * Set a scalar `fx.<key>` value while preserving the rest of the file.
+ *
+ * A nested block under the key (for example a hand-written `fx.tests:`
+ * mapping) is replaced by the scalar, so enabling and disabling a feature
+ * always leaves one canonical value behind.
+ *
+ * @param {string} configPath
+ * @param {string} key
+ * @param {string|number|boolean} value
+ * @returns {{changed: boolean}}
+ */
+export function setFxScalar(configPath, key, value) {
+  const text = fs.readFileSync(configPath, "utf8");
+  const lines = splitLines(text);
+  const eol = eolOf(text);
+  const scalar = typeof value === "string" ? quote(value) : String(value);
+  const fx = topLevel(lines, "fx");
+
+  if (!fx) {
+    if (lines.length > 0 && !lines[lines.length - 1].endsWith("\n"))
+      lines[lines.length - 1] += eol;
+    lines.push(`fx:${eol}`, `  ${key}: ${scalar}${eol}`);
+    writeDocument(configPath, lines.join(""));
+    return { changed: true };
+  }
+
+  const { value: rest, comment } = splitComment(fx.rest);
+  if (rest !== "") {
+    if (!rest.startsWith("{") || !rest.endsWith("}"))
+      throw new Error("fx must be a block mapping to edit it");
+    const mapping = parseValue(rest);
+    if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+      throw new Error("fx must be a mapping to edit it");
+    if (mapping[key] === value) return { changed: false };
+    mapping[key] = value;
+    const dumped = yaml
+      .dump({ fx: mapping }, { lineWidth: -1, noRefs: true })
+      .split("\n")
+      .filter((line, index, all) => !(index === all.length - 1 && line === ""))
+      .map((line) => `${line}${eol}`);
+    if (comment) dumped[0] = `fx: ${comment}${eol}`;
+    replaceRange(lines, fx.index, fx.index + 1, dumped);
+    writeDocument(configPath, lines.join(""));
+    return { changed: true };
+  }
+
+  const end = sectionEnd(lines, fx.index);
+  const existing = mappingEntrySpans(lines, fx.index, end).find(
+    (span) => span.key === key,
+  );
+  if (existing) {
+    let entryEnd = existing.end;
+    while (
+      entryEnd > existing.index + 1 &&
+      /^(?:[ \t]*#.*|[ \t]*)$/.test(content(lines[entryEnd - 1]))
+    )
+      entryEnd--;
+    replaceRange(lines, existing.index, entryEnd, [
+      `${existing.indent}${quoteKey(key)}: ${scalar}${eol}`,
+    ]);
+  } else {
+    const indent = childIndent(lines, fx.index, end);
+    insertAt(lines, end, [`${indent}${quoteKey(key)}: ${scalar}${eol}`], eol);
+  }
+  writeDocument(configPath, lines.join(""));
+  return { changed: true };
+}
+
+/**
+ * Remove a `features:` entry.
+ * @param {string} configPath
+ * @param {string} name
+ * @returns {{removed: string|null}}
+ */
+export function removeFeatureEntry(configPath, name) {
+  const text = fs.readFileSync(configPath, "utf8");
+  const lines = splitLines(text);
+  const eol = eolOf(text);
+  const key = String(name);
+  const bounds = topLevelBounds(lines, "features");
+  if (!bounds) return { removed: null };
+
+  if (bounds.inline) {
+    const mapping = parseValue(bounds.inline);
+    if (!mapping || typeof mapping !== "object" || Array.isArray(mapping))
+      return { removed: null };
+    if (!Object.hasOwn(mapping, key)) return { removed: null };
+    const source = mapping[key];
+    delete mapping[key];
+    const rest = Object.keys(mapping).length
+      ? ` ${JSON.stringify(mapping)}`
+      : " {}";
+    const comment = bounds.comment ? ` ${bounds.comment}` : "";
+    const line = lines[bounds.index];
+    lines[bounds.index] = `features:${rest}${comment}${
+      /\r?\n$/.test(line) ? ending(line) : eol
+    }`;
+    writeDocument(configPath, lines.join(""));
+    return { removed: source == null ? null : String(source) };
+  }
+
+  const spans = mappingEntrySpans(lines, bounds.index, bounds.end);
+  const existing = spans.find((span) => span.key === key);
+  if (!existing) return { removed: null };
+
+  let source = null;
+  try {
+    const parsed = yaml.load(
+      [
+        content(lines[bounds.index]),
+        ...lines.slice(existing.index, existing.end),
+      ].join("\n"),
+    );
+    const entry = parsed?.features?.[key];
+    source =
+      typeof entry === "string" ? entry : (entry?.file ?? entry?.path ?? null);
+  } catch {
+    // The entry is removed either way.
+  }
+
+  replaceRange(lines, existing.index, existing.end, []);
+  const end = bounds.end - (existing.end - existing.index);
+  const remaining = mappingEntrySpans(lines, bounds.index, end);
+  if (remaining.length === 0) {
+    replaceRange(lines, bounds.index, end, [`features: {}${eol}`]);
+  }
+  writeDocument(configPath, lines.join(""));
+  return { removed: source ?? key };
+}

package/src/config.js

@@ -11,6 +11,7 @@ import fs from "node:fs";
 import path from "node:path";
 import * as yaml from "js-yaml";
 import { configFilename, configFilenames, productName } from "./brand.js";
+import { DEFAULT_LINT, normalizeLintConfig } from "./lint/config.js";
 
 export const DEFAULT_PROJECT = {
   name: `${productName()} Project`,
@@ -25,6 +26,19 @@ export const DEFAULT_PROJECT = {
   unsandboxed: [],
 };
 
+/**
+ * Deterministic defaults for `fx test`. Virtual time is derived from
+ * `ticksPerSecond`; `seed` seeds the pseudo-random generator for the run.
+ */
+export const DEFAULT_TESTS = {
+  pattern: "test/**/*.test.tfx",
+  seed: 12345,
+  timeout: 1000,
+  ticksPerSecond: 30,
+  failOnRuntimeError: true,
+  parallel: false,
+};
+
 /**
  * Fx-only settings that never reach PenguinMod's project runtime config.
  * Kept in a separate top-level `fx:` block in fx.yml.
@@ -32,8 +46,72 @@ export const DEFAULT_PROJECT = {
 export const DEFAULT_FX = {
   partialSprites: false,
   vendorDir: "extensions",
+  tests: false,
+  lint: { ...DEFAULT_LINT, rules: { ...DEFAULT_LINT.rules } },
 };
 
+/**
+ * Normalize the `fx.tests` setting.
+ *
+ * `true` enables testing with the defaults, `false` (or an absent key)
+ * disables it, and a mapping may override any default. The mapping form is
+ * what `fx feature tests enable` writes and later edits by hand.
+ *
+ * @param {unknown} value
+ * @returns {false | (typeof DEFAULT_TESTS & {enabled: true})}
+ */
+export function normalizeTestConfig(value) {
+  if (value == null || value === false) return false;
+  if (value === true) return { enabled: true, ...DEFAULT_TESTS };
+  if (!isPlainObject(value))
+    throw new Error(
+      `${configFilename()}: fx.tests must be true, false, or a mapping`,
+    );
+
+  const unknown = Object.keys(value).filter(
+    (key) => !Object.hasOwn(DEFAULT_TESTS, key),
+  );
+  if (unknown.length)
+    throw new Error(
+      `${configFilename()}: unknown fx.tests setting(s): ${unknown
+        .map((key) => `"${key}"`)
+        .join(", ")}`,
+    );
+
+  const tests = { enabled: true, ...DEFAULT_TESTS };
+  if (value.pattern != null) {
+    if (typeof value.pattern !== "string" || value.pattern.trim() === "")
+      throw new Error(`${configFilename()}: fx.tests.pattern must be a glob`);
+    tests.pattern = value.pattern.trim();
+  }
+  if (value.seed != null) {
+    const seed = Number(value.seed);
+    if (!Number.isFinite(seed))
+      throw new Error(`${configFilename()}: fx.tests.seed must be a number`);
+    tests.seed = seed;
+  }
+  if (value.timeout != null) {
+    const timeout = Number(value.timeout);
+    if (!Number.isFinite(timeout) || timeout <= 0)
+      throw new Error(
+        `${configFilename()}: fx.tests.timeout must be a positive number of milliseconds`,
+      );
+    tests.timeout = timeout;
+  }
+  if (value.ticksPerSecond != null) {
+    const ticks = Number(value.ticksPerSecond);
+    if (!Number.isFinite(ticks) || ticks <= 0)
+      throw new Error(
+        `${configFilename()}: fx.tests.ticksPerSecond must be positive`,
+      );
+    tests.ticksPerSecond = ticks;
+  }
+  if (value.failOnRuntimeError != null)
+    tests.failOnRuntimeError = Boolean(value.failOnRuntimeError);
+  if (value.parallel != null) tests.parallel = Boolean(value.parallel);
+  return tests;
+}
+
 /** Default directory that receives vendored extension sources. */
 export const DEFAULT_VENDOR_DIR = "extensions";
 
@@ -121,6 +199,32 @@ export function normalizeVendorEntry(name, raw) {
   };
 }
 
+/**
+ * Normalize the top-level `features:` mapping. Values are file paths (or
+ * `{ file }` mappings), relative to the config directory.
+ *
+ * @param {unknown} raw
+ * @returns {Array<{name: string, file: string}>}
+ */
+export function normalizeFeatures(raw = {}) {
+  if (raw == null) return [];
+  if (!isPlainObject(raw))
+    throw new Error(`${configFilename()}: "features" must be a mapping`);
+  return Object.entries(raw).map(([name, value]) => {
+    const file =
+      typeof value === "string"
+        ? value
+        : isPlainObject(value) && typeof value.file === "string"
+          ? value.file
+          : null;
+    if (!file || file.trim() === "")
+      throw new Error(
+        `${configFilename()}: features.${name} must be a file path or { file: "<path>" }`,
+      );
+    return { name: String(name), file: file.trim() };
+  });
+}
+
 /**
  * Normalize the top-level `vendor:` mapping. Order is load order, so this is an
  * array rather than a plain object.
@@ -381,7 +485,7 @@ export function normalizeProject(raw = {}) {
  * @returns {typeof DEFAULT_FX}
  */
 export function normalizeFx(raw = {}) {
-  const fx = { ...DEFAULT_FX };
+  const fx = { ...DEFAULT_FX, lint: { ...DEFAULT_LINT, rules: {} } };
   if (raw && typeof raw === "object" && !Array.isArray(raw)) {
     if (raw.partialSprites != null)
       fx.partialSprites = Boolean(raw.partialSprites);
@@ -390,6 +494,11 @@ export function normalizeFx(raw = {}) {
         throw new Error(`${configFilename()}: fx.vendorDir must be a path`);
       fx.vendorDir = raw.vendorDir.trim();
     }
+    if (raw.tests !== undefined) fx.tests = normalizeTestConfig(raw.tests);
+    fx.lint = normalizeLintConfig(
+      raw.lint,
+      (message) => new Error(`${configFilename()}: ${message}`),
+    );
   }
   return fx;
 }
@@ -420,6 +529,7 @@ export function parseConfig(text) {
     fx,
     package: normalizePackage(raw.package || {}),
     vendor: normalizeVendor(raw.vendor || {}),
+    features: normalizeFeatures(raw.features || {}),
     vendorDir: fx.vendorDir,
     raw,
   };
@@ -459,6 +569,7 @@ export function loadConfigFrom(dir) {
       fx,
       package: pkg,
       vendor,
+      features,
       vendorDir,
       raw,
     } = parseConfig(fs.readFileSync(found, "utf8"));
@@ -467,6 +578,7 @@ export function loadConfigFrom(dir) {
       fx,
       package: pkg,
       vendor,
+      features,
       vendorDir,
       raw,
       path: found,
@@ -477,6 +589,7 @@ export function loadConfigFrom(dir) {
     fx: { ...DEFAULT_FX },
     package: normalizePackage({}),
     vendor: [],
+    features: [],
     vendorDir: DEFAULT_VENDOR_DIR,
     raw: {},
     path: null,

package/src/decompiler.js

@@ -49,6 +49,8 @@ const LIST_OPCODE_METHOD = {
   data_listcontainsitem: { method: "contains", inputs: ["ITEM"] },
 };
 
+const SAFE_TEMP_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
 function escapeString(value) {
   return String(value)
     .replace(/\\/g, "\\\\")
@@ -172,6 +174,14 @@ class Decompiler {
     }
     if (block.opcode === "data_variable") return block.fields.VARIABLE[0];
     if (block.opcode === "data_listcontents") return block.fields.LIST[0];
+    if (block.opcode === "fxTempVars_getThreadVariable") {
+      const name = this.tempVarName(block);
+      if (name != null && SAFE_TEMP_NAME.test(name)) return `$${name}`;
+    }
+    if (block.opcode === "fxTempVars_getRuntimeVariable") {
+      const name = this.tempVarName(block);
+      if (name != null && SAFE_TEMP_NAME.test(name)) return `$$${name}`;
+    }
     if (
       Object.prototype.hasOwnProperty.call(LIST_OPCODE_METHOD, block.opcode)
     ) {
@@ -254,6 +264,27 @@ class Decompiler {
     return lines.filter(Boolean).join("\n");
   }
 
+  /** Literal name stored in a temporary-variable block's VAR input. */
+  tempVarName(block) {
+    const raw = (block.inputs || {}).VAR;
+    const inner = Array.isArray(raw) ? raw[1] : null;
+    if (!Array.isArray(inner) || ![4, 5, 6, 7, 8, 9, 10, 11].includes(inner[0]))
+      return null;
+    return inner[1] == null ? null : String(inner[1]);
+  }
+
+  /** Render set/change on a temporary variable, with sugar when the name is safe. */
+  renderTempVarAssign(block, pad, prefix, op, catalogName) {
+    const name = this.tempVarName(block);
+    const value = this.renderExpression(
+      block.inputs.STRING ?? block.inputs.NUM,
+    );
+    if (name != null && SAFE_TEMP_NAME.test(name))
+      return `${pad}${prefix}${name} ${op} ${value};`;
+    const input = this.renderExpression(block.inputs.VAR);
+    return `${pad}tempvars.${catalogName}(${input}, ${value});`;
+  }
+
   renderStatement(block, indent) {
     const pad = "    ".repeat(indent);
     const sub = (firstId) => {
@@ -289,6 +320,20 @@ class Decompiler {
         return `${pad}${this.renderProcedureCall(block)};`;
       case "control_stop":
         return `${pad}control.stop("${block.fields.STOP_OPTION[0]}");`;
+      case "fxTempVars_setThreadVariable":
+        return this.renderTempVarAssign(block, pad, "$", "=", "setThread");
+      case "fxTempVars_changeThreadVariable":
+        return this.renderTempVarAssign(block, pad, "$", "+=", "changeThread");
+      case "fxTempVars_setRuntimeVariable":
+        return this.renderTempVarAssign(block, pad, "$$", "=", "setRuntime");
+      case "fxTempVars_changeRuntimeVariable":
+        return this.renderTempVarAssign(
+          block,
+          pad,
+          "$$",
+          "+=",
+          "changeRuntime",
+        );
       default: {
         if (
           Object.prototype.hasOwnProperty.call(LIST_OPCODE_METHOD, block.opcode)