exprforge 0.1.0

package/emitters/rust.js

@@ -0,0 +1,90 @@
+// exprforge/emitters/rust.js
+//
+// Rust's f64 math is method-call syntax (x.sqrt()), not free functions
+// (sqrt(x)) like every other target here. The base Emitter's `calls` table
+// just holds string templates, so this needs no special-casing in base.js —
+// it's the reason `calls` was designed as arbitrary templates instead of a
+// plain "language function name" lookup.
+const Emitter = require("./base.js");
+
+function method0(name) {
+    return ([x]) => `(${x}).${name}()`;
+}
+
+function method1(name) {
+    return ([recv, arg]) => `(${recv}).${name}(${arg})`;
+}
+
+const emitter = new Emitter({
+    ext: "rs",
+    // Explicit f64 suffix: a bare literal like `5.0` is only usable as a
+    // method-call receiver (`5.0.sqrt()`) once its type is unambiguous, and
+    // rustc won't always infer it from context (E0689).
+    formatNumber: (v) => (Number.isInteger(v) ? `${v}.0f64` : `${v}f64`),
+    calls: {
+        sqrt: method0("sqrt"), abs: method0("abs"), sin: method0("sin"), cos: method0("cos"),
+        tan: method0("tan"), asin: method0("asin"), acos: method0("acos"), atan: method0("atan"),
+        ln: method0("ln"), log2: method0("log2"), log10: method0("log10"), exp: method0("exp"),
+        floor: method0("floor"), ceil: method0("ceil"), round: method0("round"), trunc: method0("trunc"),
+        log: method0("ln"),   // Math.log is natural log; Rust spells it ln()
+        // NOT .signum(): Rust's docs specify 1.0 at positive zero (it only
+        // reads the sign bit), unlike JS's Math.sign(0) === 0 (and C's/
+        // Java's sign, which both special-case zero). Found by the
+        // kitchen-sink conformance test at exactly x - y == 0.
+        sign: ([x]) => `(if ${x} > 0.0 { 1.0f64 } else if ${x} < 0.0 { -1.0f64 } else { 0.0f64 })`,
+        pow: method1("powf"), atan2: method1("atan2"), min: method1("min"),
+        max: method1("max"), hypot: method1("hypot"),
+    },
+    // Rust has no C-style ?: ternary; `if` is itself an expression instead
+    // (`if cond { a } else { b }`), and it's just as short-circuiting.
+    emitSelect: function (condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `(if ${L} ${condNode.op} ${R} { ${thenStr} } else { ${elseStr} })`;
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `${p}: f64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    let ${name}: f64 = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        // Param/function names come from the AST author (may not be snake_case,
+        // e.g. "P0"), every bin node keeps explicit parens by design (see
+        // header), and a shared let-chain can bind more names than one
+        // function's body reads (e.g. ux/uy/uz computed for three sibling
+        // single-component functions) — all trip default rustc lints
+        // without being bugs, so silence them rather than let a
+        // `-D warnings` build choke on them.
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `#[allow(non_snake_case, unused_parens, unused_variables)]\n` +
+               `pub fn ${fn.name}(${params}) -> f64 {\n` +
+               letsBlock +
+               `    ${body}\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: Rust has no native multi-return
+    // with names (tuples are positional and easy to mix up for 6 fields),
+    // so this emits a small struct alongside the function and constructs it
+    // directly — the idiomatic Rust shape for "several named values out."
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `${p}: f64`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    let ${name}: f64 = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const structName = `${capitalize(fn.name)}Result`;
+        const structFields = outputNames.map((n) => `    pub ${n}: f64,`).join("\n");
+        const initFields = outputNames.map((n) => `${n}: ${outputStrs[n]}`).join(", ");
+        return `// AUTO-GENERATED by ExprForge -- do not hand-edit.\n` +
+               `#[allow(non_snake_case)]\n` +
+               `pub struct ${structName} {\n${structFields}\n}\n\n` +
+               `#[allow(non_snake_case, unused_parens, unused_variables)]\n` +
+               `pub fn ${fn.name}(${params}) -> ${structName} {\n` +
+               letsBlock +
+               `    ${structName} { ${initFields} }\n` +
+               `}\n`;
+    },
+});
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+module.exports = emitter;

package/emitters/typescript.js

@@ -0,0 +1,63 @@
+// exprforge/emitters/typescript.js
+//
+// Almost identical to js.js at the expression level -- same Math.* calls,
+// same number literal syntax, native ternary for select() (no override
+// needed) -- since TS numbers are JS numbers. What's different is purely
+// surface: typed signatures, ESM `export` instead of CommonJS
+// `module.exports` (this targets a frontend build tool, not Node), and a
+// named `interface` for multi-output suites instead of an untyped object.
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `Math.${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `Math.${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "ts",
+    formatNumber: (v) => String(v),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("abs"), sin: fn1("sin"), cos: fn1("cos"), tan: fn1("tan"),
+        asin: fn1("asin"), acos: fn1("acos"), atan: fn1("atan"), log: fn1("log"),
+        log2: fn1("log2"), log10: fn1("log10"), exp: fn1("exp"), floor: fn1("floor"),
+        ceil: fn1("ceil"), round: fn1("round"), trunc: fn1("trunc"), sign: fn1("sign"),
+        pow: fn2("pow"), atan2: fn2("atan2"), min: fn2("min"), max: fn2("max"), hypot: fn2("hypot"),
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `${p}: number`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `// AUTO-GENERATED by ExprForge — do not hand-edit.\n` +
+               `export function ${fn.name}(${params}): number {\n` +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: a named interface, returned as
+    // an object literal — TS's structural typing means this is checked at
+    // every call site, unlike JS's untyped equivalent.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `${p}: number`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    const ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const interfaceName = `${capitalize(fn.name)}Result`;
+        const interfaceFields = outputNames.map((n) => `    ${n}: number;`).join("\n");
+        const objectFields = outputNames.map((n) => `        ${n}: ${outputStrs[n]},`).join("\n");
+        return `// AUTO-GENERATED by ExprForge — do not hand-edit.\n` +
+               `export interface ${interfaceName} {\n${interfaceFields}\n}\n\n` +
+               `export function ${fn.name}(${params}): ${interfaceName} {\n` +
+               letsBlock +
+               `    return {\n${objectFields}\n    };\n` +
+               `}\n`;
+    },
+});
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+module.exports = emitter;

package/index.js

@@ -0,0 +1,44 @@
+// exprforge/index.js
+const { num, v, bin, call, add, mul, sub, div, neg, letIn, cmp, select, outputs, collectLets } = require("./ast.js");
+const { forComponents } = require("./util.js");
+const emitters = require("./emitters/registry.js");
+const { catmullRomAst } = require("./samples/catmull-rom.js");
+const { fibonacciAst } = require("./samples/fibonacci.js");
+const { splineFrameAsts } = require("./samples/spline-frame.js");
+const { kitchenSinkAst } = require("./samples/kitchen-sink.js");
+
+/**
+ * Run every registered emitter against one AST function definition.
+ * Returns { [lang]: { ext, source } }.
+ */
+function emitAll(fn) {
+    const result = {};
+    for (const [lang, emitter] of Object.entries(emitters)) {
+        result[lang] = { ext: emitter.ext, source: emitter.emitFunction(fn) };
+    }
+    return result;
+}
+
+module.exports = {
+    // AST builders — use these to define your own formulas.
+    num, v, bin, call, add, mul, sub, div, neg, letIn, cmp, select, outputs, collectLets,
+    // Authoring convenience — not an AST primitive, see util.js.
+    forComponents,
+    // Built-in example formulas — see samples/ for the source.
+    catmullRomAst,
+    fibonacciAst,
+    splineFrameAsts,
+    // Not a worked example -- a conformance-test fixture that calls every
+    // supported Math function once. See samples/kitchen-sink.js.
+    kitchenSinkAst,
+    samples: {
+        catmullRom: catmullRomAst,
+        fibonacci: fibonacciAst,
+        splineFrame: splineFrameAsts,
+        kitchenSink: kitchenSinkAst,
+    },
+    // Per-language emitter instances, keyed by name (js, qb64, c, java, go, rust).
+    emitters,
+    // Convenience: run every emitter at once.
+    emitAll,
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "exprforge",
+  "version": "0.1.0",
+  "description": "Author a math expression once as an AST, emit identical-behavior implementations in JS, TypeScript, Python, C#, Lua, QB64, C, Java, Go, and Rust.",
+  "main": "index.js",
+  "type": "commonjs",
+  "files": [
+    "index.js",
+    "ast.js",
+    "util.js",
+    "build.js",
+    "emitters/",
+    "samples/"
+  ],
+  "scripts": {
+    "build": "node build.js",
+    "test": "node --test",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "codegen",
+    "ast",
+    "math",
+    "cross-language",
+    "transpiler",
+    "qb64"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Don Smith",
+    "url": "https://github.com/theraccoonbear"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theraccoonbear/exprforge.git"
+  },
+  "homepage": "https://github.com/theraccoonbear/exprforge#readme",
+  "bugs": {
+    "url": "https://github.com/theraccoonbear/exprforge/issues"
+  }
+}

package/samples/catmull-rom.js

@@ -0,0 +1,26 @@
+// exprforge/samples/catmull-rom.js
+// Uniform Catmull-Rom spline interpolation, one scalar component at a time
+// (call once per x/y/z with P0..P3 = that axis' control values).
+const { num, v, mul, add, sub } = require("../ast.js");
+
+// P(t) = 0.5 * ( 2*P1 + (-P0+P2)*t + (2*P0-5*P1+4*P2-P3)*t^2 + (-P0+3*P1-3*P2+P3)*t^3 )
+const P0 = v("P0");
+const P1 = v("P1");
+const P2 = v("P2");
+const P3 = v("P3");
+const t = v("t");
+const t2 = mul(t, t);
+const t3 = mul(t, t, t);
+
+const term0 = mul(num(2), P1);
+const term1 = mul(sub(P2, P0), t);
+const term2 = mul(add(mul(num(2), P0), mul(num(-5), P1), mul(num(4), P2), mul(num(-1), P3)), t2);
+const term3 = mul(add(mul(num(-1), P0), mul(num(3), P1), mul(num(-3), P2), P3), t3);
+
+const catmullRomAst = {
+    name: "catmullRom1D",
+    params: ["P0", "P1", "P2", "P3", "t"],
+    body: mul(num(0.5), add(term0, term1, term2, term3)),
+};
+
+module.exports = { catmullRomAst };

package/samples/fibonacci.js

@@ -0,0 +1,24 @@
+// exprforge/samples/fibonacci.js
+// nth Fibonacci number via the closed form (Binet's formula), not recursion
+// or a loop — exprforge has no control flow (see README), so this is the
+// shape a "fibonacci" example has to take here:
+//
+//   F(n) = (phi^n - psi^n) / sqrt(5)
+//   phi  = (1 + sqrt(5)) / 2   (golden ratio)
+//   psi  = (1 - sqrt(5)) / 2
+//
+// float64 throughout, so exact only up to about n=70 before precision drifts.
+const { num, v, call, sub, add, div } = require("../ast.js");
+
+const sqrt5 = call("sqrt", num(5));
+const phi = div(add(num(1), sqrt5), num(2));
+const psi = div(sub(num(1), sqrt5), num(2));
+const n = v("n");
+
+const fibonacciAst = {
+    name: "fibonacci",
+    params: ["n"],
+    body: div(sub(call("pow", phi, n), call("pow", psi, n)), sqrt5),
+};
+
+module.exports = { fibonacciAst };

package/samples/kitchen-sink.js

@@ -0,0 +1,56 @@
+// exprforge/samples/kitchen-sink.js
+// Not a worked example like the other samples/ — a synthetic function with
+// no real-world meaning, built to call every supported Math function
+// (see README's "Supported Math functions") at least once in a single
+// expression. Exists purely as a conformance-test fixture: the other
+// samples only exercise 5 of the 22 functions between them, so most of
+// the `calls` tables in emitters/*.js — several with hand-rolled,
+// easy-to-get-wrong expansions (QB64's asin/acos as ATN+SQR identities,
+// C's ternary-based sign, Java's log2/round/trunc, Go's Copysign-based
+// sign) — had never actually been run through a compiler.
+//
+// x is kept in (0, 1) by every caller (see test/conformance.test.js's
+// inputs for this sample) so sqrt/log/log2/log10/asin/acos all stay in
+// their valid domain simultaneously. d = x - y is free to land anywhere
+// -- positive, negative, or exactly zero -- and carries the functions
+// that care about sign: floor/ceil/round/trunc/sign. (Test inputs
+// deliberately avoid exact .5 fractional values for d: JS/Java round
+// half-up while C/Go/Rust round half-away-from-zero, which disagree at
+// exact .5 for negative numbers -- a real cross-language difference in
+// round() itself, not an emitter bug, and out of scope to fix here.)
+const { v, call, add, sub } = require("../ast.js");
+
+const x = v("x");
+const y = v("y");
+const d = sub(x, y);
+
+const kitchenSinkAst = {
+    name: "kitchenSink",
+    params: ["x", "y"],
+    body: add(
+        call("sqrt", x),
+        call("abs", d),
+        call("pow", x, y),
+        call("sin", x),
+        call("cos", x),
+        call("tan", x),
+        call("asin", x),
+        call("acos", x),
+        call("atan", x),
+        call("atan2", y, x),
+        call("log", x),
+        call("log2", x),
+        call("log10", x),
+        call("exp", x),
+        call("floor", d),
+        call("ceil", d),
+        call("round", d),
+        call("trunc", d),
+        call("sign", d),
+        call("min", x, y),
+        call("max", x, y),
+        call("hypot", x, y),
+    ),
+};
+
+module.exports = { kitchenSinkAst };

package/samples/spline-frame.js

@@ -0,0 +1,184 @@
+// exprforge/samples/spline-frame.js
+// Gram-Schmidt frame construction and related ops for Catmull-Rom spline
+// paths — the motivating use case for the let/cmp/select AST additions,
+// and now for outputs() (see ast.js). Mirrors math from a private game
+// project's spline_path.bi / spline.ts.
+//
+// Each group below shares one let-chain across several *related* outputs
+// (e.g. SpMakeFrame's R and U vectors) and is emitted as ONE suite —
+// computed once — instead of one function per output. That used to be six
+// separate functions here, each independently re-deriving the same
+// 9-step chain (including a sqrt) from scratch; a caller wanting the
+// whole frame paid for that chain six times over for one tangent vector.
+// See docs/planned-additions.md and the outputs() doc comment in ast.js.
+//
+// IMPORTANT for QB64: function/SUB names must be unique across the entire
+// QB64 compilation unit. The SpEf prefix (SplineExprforge) exists to avoid
+// collisions with hand-written code elsewhere in that project.
+const { num, v, call, add, mul, sub, div, neg, letIn, select, cmp, outputs } = require("../ast.js");
+
+// ── Helpers ──────────────────────────────────────────────────────────────
+const PI = num(3.141592653589793);
+const degToRad = (degVar) => mul(degVar, div(PI, num(180)));
+const dot3 = (ax, ay, az, bx, by, bz) => add(mul(ax, bx), mul(ay, by), mul(az, bz));
+const len3 = (x, y, z) => call("sqrt", dot3(x, y, z, x, y, z));
+
+// Epsilon guard: normalize when len is big enough to trust, else fallback.
+//
+// select() always evaluates both branches (see ast.js), so this does NOT
+// divide by lenVar directly — that would be undefined right when the guard
+// is supposed to matter. Instead the denominator is clamped to a safe,
+// always-nonzero value by its own select first, so the div() itself never
+// sees anything near zero on any target, no matter which logical branch
+// "wins".
+const EPS = num(0.000001);
+function safeDiv(component, lenVar, fallback) {
+    const isSafe = cmp(v(lenVar), ">", EPS);
+    const safeLen = select(isSafe, v(lenVar), num(1));
+    return select(isSafe, div(component, safeLen), fallback);
+}
+
+// ── SpMakeFrame ──────────────────────────────────────────────────────────
+// Gram-Schmidt frame from normalized tangent (tx, ty, tz).
+// worldUp = (0,0,1) when |ty|>0.98, else (0,1,0). worldUp.x is always 0.
+// R = normalize(T × worldUp)   U = R × T
+//
+// One shared let chain, six named outputs (rx,ry,rz,ux,uy,uz), computed
+// once per call instead of once per output. The pre-normalization cross
+// product is named crossX/Y/Z, deliberately NOT rx/ry/rz, even though
+// that's its usual name here: it would collide with the "rx"/"ry"/"rz"
+// *output* field names below in any language whose multi-return mechanism
+// shares a namespace with local variables (this collided for real in Go's
+// named-return-values form before that was changed to avoid relying on it —
+// kept renamed anyway, both for clarity and because QB64's output-param
+// SUBs are structurally the same risk and can't be verified here).
+//   wy = select(|ty|>0.98, 0, 1)
+//   wz = select(|ty|>0.98, 1, 0)
+//   crossX = ty*wz - tz*wy
+//   crossY = -tx*wz        (worldUp.x=0 collapses two terms)
+//   crossZ = tx*wy
+//   rLen = sqrt(crossX²+crossY²+crossZ²)
+//   rxN = safeDiv(crossX, rLen, 0)  — fallback 0
+//   ryN = safeDiv(crossY, rLen, 0)
+//   rzN = safeDiv(crossZ, rLen, 1)  — fallback z=1 keeps a valid frame
+
+const MF_PARAMS = ["tx", "ty", "tz"];
+const nearVert = cmp(call("abs", v("ty")), ">", num(0.98));
+
+function mfLetChain(body) {
+    return letIn("wy", select(nearVert, num(0), num(1)),
+           letIn("wz", select(nearVert, num(1), num(0)),
+           letIn("crossX", sub(mul(v("ty"), v("wz")), mul(v("tz"), v("wy"))),
+           letIn("crossY", neg(mul(v("tx"), v("wz"))),
+           letIn("crossZ", mul(v("tx"), v("wy")),
+           letIn("rLen", len3(v("crossX"), v("crossY"), v("crossZ")),
+           letIn("rxN", safeDiv(v("crossX"), "rLen", num(0)),
+           letIn("ryN", safeDiv(v("crossY"), "rLen", num(0)),
+           letIn("rzN", safeDiv(v("crossZ"), "rLen", num(1)),
+               body
+           )))))))));
+}
+
+// U = R × T (using normalized R) — a cyclic permutation, not one formula,
+// so it's tabulated by axis rather than derived generically.
+const uX = sub(mul(v("ryN"), v("tz")), mul(v("rzN"), v("ty")));
+const uY = sub(mul(v("rzN"), v("tx")), mul(v("rxN"), v("tz")));
+const uZ = sub(mul(v("rxN"), v("ty")), mul(v("ryN"), v("tx")));
+
+const SpEfMkFrame = {
+    name: "SpEfMkFrame",
+    params: MF_PARAMS,
+    body: mfLetChain(outputs({
+        rx: v("rxN"), ry: v("ryN"), rz: v("rzN"),
+        ux: uX, uy: uY, uz: uZ,
+    })),
+};
+
+// ── SpActualPos ──────────────────────────────────────────────────────────
+// actual = wire + standoff*(cos(pathRoll)*U + sin(pathRoll)*R)
+// Params: wx, wy_wire, wz_wire, tx, ty, tz, prDeg, so
+// (wy_wire to avoid colliding with the 'wy' let-binding name inside the chain)
+const AP_PARAMS = ["wx", "wy_wire", "wz_wire", "tx", "ty", "tz", "prDeg", "so"];
+
+function apLetChain(body) {
+    return letIn("wy", select(nearVert, num(0), num(1)),
+           letIn("wz", select(nearVert, num(1), num(0)),
+           letIn("crossX", sub(mul(v("ty"), v("wz")), mul(v("tz"), v("wy"))),
+           letIn("crossY", neg(mul(v("tx"), v("wz"))),
+           letIn("crossZ", mul(v("tx"), v("wy")),
+           letIn("rLen", len3(v("crossX"), v("crossY"), v("crossZ")),
+           letIn("rxN", safeDiv(v("crossX"), "rLen", num(0)),
+           letIn("ryN", safeDiv(v("crossY"), "rLen", num(0)),
+           letIn("rzN", safeDiv(v("crossZ"), "rLen", num(1)),
+           letIn("ux", sub(mul(v("ryN"), v("tz")), mul(v("rzN"), v("ty"))),
+           letIn("uy", sub(mul(v("rzN"), v("tx")), mul(v("rxN"), v("tz"))),
+           letIn("uz", sub(mul(v("rxN"), v("ty")), mul(v("ryN"), v("tx"))),
+           letIn("rad", degToRad(v("prDeg")),
+           letIn("c", call("cos", v("rad")),
+           letIn("s", call("sin", v("rad")),
+               body
+           )))))))))))))));
+}
+
+const SpEfActualPos = {
+    name: "SpEfActualPos",
+    params: AP_PARAMS,
+    body: apLetChain(outputs({
+        x: add(v("wx"), mul(v("so"), add(mul(v("c"), v("ux")), mul(v("s"), v("rxN"))))),
+        y: add(v("wy_wire"), mul(v("so"), add(mul(v("c"), v("uy")), mul(v("s"), v("ryN"))))),
+        z: add(v("wz_wire"), mul(v("so"), add(mul(v("c"), v("uz")), mul(v("s"), v("rzN"))))),
+    })),
+};
+
+// ── SpRollFrame ──────────────────────────────────────────────────────────
+// rolledU = cos(rad)*U - sin(rad)*R
+// rolledR = sin(rad)*U + cos(rad)*R
+// Params: ux, uy, uz, rx, ry, rz, crDeg
+// Output field names are prefixed (rolledUx, not ux) since ux/uy/uz/rx/ry/rz
+// are already taken by the *input* params.
+const RF_PARAMS = ["ux", "uy", "uz", "rx", "ry", "rz", "crDeg"];
+
+function rfLetChain(body) {
+    return letIn("rad", degToRad(v("crDeg")),
+           letIn("c", call("cos", v("rad")),
+           letIn("s", call("sin", v("rad")),
+               body)));
+}
+
+const SpEfRollFrame = {
+    name: "SpEfRollFrame",
+    params: RF_PARAMS,
+    body: rfLetChain(outputs({
+        rolledUx: sub(mul(v("c"), v("ux")), mul(v("s"), v("rx"))),
+        rolledUy: sub(mul(v("c"), v("uy")), mul(v("s"), v("ry"))),
+        rolledUz: sub(mul(v("c"), v("uz")), mul(v("s"), v("rz"))),
+        rolledRx: add(mul(v("s"), v("ux")), mul(v("c"), v("rx"))),
+        rolledRy: add(mul(v("s"), v("uy")), mul(v("c"), v("ry"))),
+        rolledRz: add(mul(v("s"), v("uz")), mul(v("c"), v("rz"))),
+    })),
+};
+
+// ── CR basis weights ────────────────────────────────────────────────────
+// Already expressible without let/select, but kept here so all spline
+// math lives in one sample. Shares t2/t3 across all four weights.
+// Params: t
+const CRW_PARAMS = ["t"];
+
+const SpEfCrWeights = {
+    name: "SpEfCrWeights",
+    params: CRW_PARAMS,
+    body: letIn("t2", mul(v("t"), v("t")),
+          letIn("t3", mul(v("t2"), v("t")),
+              outputs({
+                  w0: mul(num(0.5), add(neg(v("t3")), mul(num(2), v("t2")), neg(v("t")))),
+                  w1: mul(num(0.5), add(mul(num(3), v("t3")), mul(num(-5), v("t2")), num(2))),
+                  w2: mul(num(0.5), add(mul(num(-3), v("t3")), mul(num(4), v("t2")), v("t"))),
+                  w3: mul(num(0.5), add(v("t3"), neg(v("t2")))),
+              })
+          )),
+};
+
+// ── Exports ──────────────────────────────────────────────────────────────
+const splineFrameAsts = [SpEfMkFrame, SpEfActualPos, SpEfRollFrame, SpEfCrWeights];
+
+module.exports = { splineFrameAsts };

package/util.js

@@ -0,0 +1,15 @@
+// exprforge/util.js
+// Authoring conveniences — NOT AST primitives (see ast.js for those). These
+// don't return Nodes and the emitters never see them; they just help you
+// write the { name, params, body } function definitions exprforge already
+// understands, without hand-duplicating near-identical ones.
+
+// Expands a template into one function definition per axis. Purely
+// `axes.map(templateFn)` under a name that signals intent: this is a vector
+// operation expanded component-wise, not an arbitrary loop. See
+// samples/spline-frame.js for a real call site (SpMakeFrame's R/U vectors).
+function forComponents(axes, templateFn) {
+    return axes.map(templateFn);
+}
+
+module.exports = { forComponents };