@triflare/fx 2.1.0 → 2.2.0-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflare/fx",
-  "version": "2.1.0",
+  "version": "2.2.0-alpha.1",
   "description": "Code PenguinMod projects with text.",
   "type": "module",
   "license": "Apache-2.0",
@@ -18,6 +18,10 @@
     "./language": "./src/language.js",
     "./lint": "./src/lint/analyze.js"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "files": [
     "bin",
     "src",
@@ -64,10 +68,15 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^11.0.1",
+    "conventional-changelog-conventionalcommits": "^8.0.0",
     "eslint": "^10.14.0",
     "eslint-config-prettier": "^10.1.8",
     "globals": "^17.13.0",
-    "prettier": "^3.9.10"
+    "prettier": "^3.9.10",
+    "semantic-release": "^25.0.9"
   },
   "overrides": {
     "minimatch": "^11.0.4",

package/product.yml

@@ -1,7 +1,7 @@
 # Identity
 name: "Triflare Fx"
 command: "fx"
-version: "2.1.0"
+version: "2.2.0-alpha.1"
 tagline: "Code PenguinMod projects with text."
 author: "Triflare"
 homepage: "https://github.com/triflare/fx"

package/src/catalog.js

@@ -13,6 +13,9 @@
  *   - `args` describes a hat's parameters (`field` or `input`).
  *   - `extension` names the providing extension for non-core opcodes.
  *   - `dynamicNext` / `stopBlock` flag blocks with special stack behaviour.
+ *   - `extendable` marks a two-input block whose call may pass extra values;
+ *     compilation folds them into a chain of the same block (see the
+ *     compiler's `emitExtendableCall`).
  *
  * Input descriptors:
  *   NUMBER, STRING, BOOLEAN, ANGLE, COLOR, INTEGER, POSITIVE, WHOLE, SUBSTACK
@@ -387,21 +390,25 @@ const CORE_CATALOG = {
   "operators.add": {
     opcode: "operator_add",
     kind: "reporter",
+    extendable: true,
     inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.subtract": {
     opcode: "operator_subtract",
     kind: "reporter",
+    extendable: true,
     inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.multiply": {
     opcode: "operator_multiply",
     kind: "reporter",
+    extendable: true,
     inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.divide": {
     opcode: "operator_divide",
     kind: "reporter",
+    extendable: true,
     inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.random": {
@@ -427,11 +434,13 @@ const CORE_CATALOG = {
   "operators.and": {
     opcode: "operator_and",
     kind: "boolean",
+    extendable: true,
     inputs: { OPERAND1: BOOLEAN, OPERAND2: BOOLEAN },
   },
   "operators.or": {
     opcode: "operator_or",
     kind: "boolean",
+    extendable: true,
     inputs: { OPERAND1: BOOLEAN, OPERAND2: BOOLEAN },
   },
   "operators.not": {
@@ -442,6 +451,7 @@ const CORE_CATALOG = {
   "operators.join": {
     opcode: "operator_join",
     kind: "reporter",
+    extendable: true,
     inputs: { STRING1: STRING, STRING2: STRING },
   },
   "operators.letterOf": {
@@ -462,6 +472,7 @@ const CORE_CATALOG = {
   "operators.mod": {
     opcode: "operator_mod",
     kind: "reporter",
+    extendable: true,
     inputs: { NUM1: NUMBER, NUM2: NUMBER },
   },
   "operators.round": {

package/src/compiler.js

@@ -1076,10 +1076,22 @@ export class Compiler {
       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 || {});
 
+    // Extendable blocks take any number of arguments. A call with more than
+    // the block's own inputs folds into a left-associated chain of the same
+    // two-input vanilla block, so `operators.join(a, b, c)` becomes
+    // `join(join(a, b), c)` and still loads in plain Scratch.
+    if (
+      entry.extendable &&
+      node.args.length > inputNames.length + fieldNames.length
+    ) {
+      return this.emitExtendableCall(ctx, node, entry, parentId);
+    }
+
+    const id = this.addBlock(ctx, { opcode: entry.opcode, parent: parentId });
+
     if (node.args.length > inputNames.length + fieldNames.length) {
       this.fail(
         `${node.name} expects at most ${inputNames.length + fieldNames.length} argument(s)`,
@@ -1160,6 +1172,56 @@ export class Compiler {
     return { id, kind: entry.kind, entry };
   }
 
+  /**
+   * Emit an extendable block called with more arguments than it has inputs.
+   * The first two arguments fill the block and every further argument wraps
+   * the result so far in another copy, keeping left-associative order:
+   * `operators.subtract(10, 3, 2)` is `(10 - 3) - 2`.
+   * @param {Context} ctx
+   * @param {object} node
+   * @param {object} entry
+   * @param {string|null} parentId
+   */
+  emitExtendableCall(ctx, node, entry, parentId) {
+    const specs = entry.inputs || {};
+    const inputNames = Object.keys(specs);
+    if (Object.keys(entry.fields || {}).length || inputNames.length !== 2)
+      this.fail(
+        `Internal error: ${node.name} is marked extendable but is not a two-input block`,
+        node.loc,
+      );
+
+    const [first, second] = inputNames;
+    // A chain position holds a reporter directly; boolean inputs take the
+    // reporter without the shadow-value fallback.
+    const chainInput = (spec, id) =>
+      spec.type === "boolean" ? [2, id] : [3, id, this.defaultPrim(spec)];
+
+    let id = this.addBlock(ctx, { opcode: entry.opcode, parent: parentId });
+    let inputs = {
+      [first]: this.buildInputForSpec(specs[first], node.args[0], id),
+      [second]: this.buildInputForSpec(specs[second], node.args[1], id),
+    };
+    ctx.target.blocks[id].inputs = inputs;
+    this.reparentInputs(ctx, id, inputs);
+
+    for (let i = 2; i < node.args.length; i++) {
+      const wrapId = this.addBlock(ctx, {
+        opcode: entry.opcode,
+        parent: parentId,
+      });
+      inputs = {
+        [first]: chainInput(specs[first], id),
+        [second]: this.buildInputForSpec(specs[second], node.args[i], wrapId),
+      };
+      ctx.target.blocks[wrapId].inputs = inputs;
+      this.reparentInputs(ctx, wrapId, inputs);
+      id = wrapId;
+    }
+
+    return { id, kind: entry.kind, entry };
+  }
+
   emitListCall(ctx, node, listInfo, parentId) {
     const method = node.segments[1];
     let spec = null;

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

@@ -2,5 +2,5 @@
   "name": "@penguinmod/packager",
   "version": "1.9.2",
   "commit": "53f868b85ec21d2edab9ce00fd2d709da93da6d6",
-  "builtAt": "2026-11-11T19:06:00.040Z"
+  "builtAt": "2026-11-13T05:41:23.450Z"
 }

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

@@ -3,5 +3,5 @@
   "version": "0.2.0",
   "commit": "50fddfed34f4eed9eef28ef32bc1022397d29f46",
   "inputHash": "9557b90be391ad2f1deaccfd034fddf0a9591c354da50b13e4cf142a8e2654fc",
-  "builtAt": "2026-11-11T19:08:05.605Z"
+  "builtAt": "2026-11-13T05:43:32.997Z"
 }