exprforge 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,6 @@
 # ExprForge 🔢🔨
 
+[![npm version](https://img.shields.io/npm/v/exprforge.svg)](https://www.npmjs.com/package/exprforge)
 [![TypeScript](https://github.com/theraccoonbear/exprforge/actions/workflows/test-typescript.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-typescript.yml)
 [![Python](https://github.com/theraccoonbear/exprforge/actions/workflows/test-python.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-python.yml)
 [![C#](https://github.com/theraccoonbear/exprforge/actions/workflows/test-csharp.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-csharp.yml)
@@ -69,6 +70,9 @@ package individually, or together as `samples`):
   purely as a conformance-test fixture. It's what caught Go's and Rust's
   `sign()` disagreeing with everyone else at exactly zero (see below) —
   the other samples between them only ever exercised 5 of the 22.
+- `samples/math-demo.js` — also not a worked example: a conformance-test
+  fixture exercising every `exprforge/math` helper (see below) in one
+  suite.
 
 `npm run build` emits all of them, for every target language, into `out/`.
 
@@ -80,6 +84,46 @@ floor ceil round trunc sign min max hypot`
 Add more by extending a target's `calls` table in `emitters/<lang>.js`.
 Requesting an unmapped function throws at build time, not silently.
 
+## Math utilities (`exprforge/math`)
+
+A separate, additive export — `require("exprforge")` is unchanged — of
+pre-built compositions of the core AST builders for common 3-D math
+patterns, so consumers stop re-implementing the same safe-math and vector
+code in every project (`samples/spline-frame.js` had local, hand-rolled
+versions of most of these before this module existed).
+
+```js
+const { num, v } = require("exprforge");
+const { safeDiv, dot3, len3, cross3, normalize3, clamp, EPS } = require("exprforge/math");
+
+// Safe-normalize x component, falling back to 0 near zero length.
+safeDiv(v("x"), len3(v("x"), v("y"), v("z")), num(0));
+```
+
+- `safeDiv(numerator, denominatorExpr, fallback)` — `numerator /
+  denominatorExpr` when `|denominatorExpr| > EPS`, else `fallback`. Clamps
+  the denominator before dividing rather than guarding the division
+  directly, since `select()` always evaluates both branches (see below).
+- `dot3(ax, ay, az, bx, by, bz)` — `ax*bx + ay*by + az*bz`.
+- `len3(x, y, z)` — `sqrt(x² + y² + z²)`.
+- `cross3(ax, ay, az, bx, by, bz)` — 3-D cross product. Returns a plain JS
+  object `{ x, y, z }` of AST nodes (not a Node itself), for destructuring
+  into your own `letIn` chain.
+- `normalize3(x, y, z, fx?, fy?, fz?)` — safe-normalize; same `{ x, y, z }`
+  shape as `cross3`. Falls back to `(fx, fy, fz)` (default `(0, 1, 0)`)
+  below `EPS` length. Computes the length once and shares it across all
+  three divisions.
+- `clamp(val, lo, hi)` — clamps to `[lo, hi]` via nested `select`/`cmp`; no
+  runtime intrinsic.
+- `EPS` — `num(0.000001)`, the epsilon every guard above uses; exported for
+  callers who want the same threshold in their own `cmp()` calls.
+
+What deliberately stays out (project-specific conventions, not general
+math): a "near-vertical" world-up check, baked-in-PI degree/radian
+conversion, Rodrigues rotation, and a full Gram-Schmidt frame — see
+`samples/spline-frame.js` for those, and
+`docs/v0.2.0-math-utilities.md` for the full design rationale.
+
 ## Adding a language
 
 Write `emitters/<lang>.js` exporting an `Emitter` instance (see any
@@ -97,6 +141,33 @@ expression model without introducing control flow:
   components by it). Every `let` in a function gets lifted into an ordered
   list of local declarations ahead of the return statement/expression, in
   every target.
+
+  Chaining several is normally hand-nested `letIn` calls, one inside the
+  next, closing parens piling up at the end with no real hierarchy behind
+  them — just bookkeeping to get everything hoisted before it's used.
+  **`letChain(bindings, body)`** is that same nesting, built for you from a
+  flat, ordered list instead:
+
+  ```js
+  const { v, num, mul, add, letChain, outputs } = require("exprforge");
+
+  letChain(
+      [
+          ["t2", mul(v("t"), v("t"))],
+          ["t3", mul(v("t2"), v("t"))],
+      ],
+      outputs({ t2: v("t2"), t3: v("t3") }),
+  );
+  // same tree as letIn("t2", ..., letIn("t3", ..., outputs({...})))
+  ```
+
+  `bindings` is an ordered array of `[name, valueNode]` pairs, not a
+  `{name: valueNode}` object like `outputs()` takes — order is
+  load-bearing here (a later binding's value can reference an earlier
+  one's name), and that's clearer as an explicit sequence than resting on
+  an object's key order. Pure authoring sugar: builds the identical `let`
+  node structure `letIn` would, so it needs no emitter changes and
+  round-trips through `collectLets` the same way.
 - **`select(cond, then, else)` + `cmp(left, op, right)`** — conditional
   *value* selection. Every target has a genuinely different way to spell
   this: a native ternary where one exists (C, Java, C#), `if`-as-expression

package/ast.js

@@ -62,6 +62,27 @@ function letIn(name, value, body) {
     return { type: "let", name, value, body };
 }
 
+// Chains N letIn bindings without hand-nesting them (and hand-balancing the
+// resulting N closing parens — the nesting depth reflects no real
+// hierarchy, only that each binding must be lifted ahead of anything using
+// it). Builds the exact same nested `let` structure letIn() would if
+// written out by hand: pure authoring sugar, not a new node type, so
+// collectLets and every emitter already understand the result unchanged.
+//
+// `bindings` is an ORDERED array of [name, valueNode] pairs, not a
+// {name: valueNode} object like outputs() takes — order is load-bearing
+// here (a later binding's value can reference an earlier one's name via
+// v(name)), and a plain object's key order isn't reliably that: a binding
+// named e.g. "0" would silently sort ahead of everything else. An array
+// keeps "this is a strict sequence" explicit instead of resting on that.
+//
+// Doesn't check for duplicate names itself — collectLets already does,
+// with the whole function body in view (see its doc comment); duplicating
+// that check here would only see this one chain, not the whole picture.
+function letChain(bindings, body) {
+    return bindings.reduceRight((acc, [name, value]) => letIn(name, value, acc), body);
+}
+
 // Comparison predicate — only valid as the `cond` of a select(); not a
 // general boolean expression, and shouldn't appear anywhere else in a tree.
 function cmp(left, op, right) {
@@ -139,4 +160,4 @@ function collectLets(node) {
     return { bindings, body };
 }
 
-module.exports = { num, v, bin, call, add, mul, sub, div, neg, letIn, cmp, select, outputs, collectLets };
+module.exports = { num, v, bin, call, add, mul, sub, div, neg, letIn, letChain, cmp, select, outputs, collectLets };

package/index.js

@@ -1,11 +1,12 @@
 // exprforge/index.js
-const { num, v, bin, call, add, mul, sub, div, neg, letIn, cmp, select, outputs, collectLets } = require("./ast.js");
+const { num, v, bin, call, add, mul, sub, div, neg, letIn, letChain, 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");
+const { mathDemoAst } = require("./samples/math-demo.js");
 
 /**
  * Run every registered emitter against one AST function definition.
@@ -21,7 +22,7 @@ function emitAll(fn) {
 
 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,
+    num, v, bin, call, add, mul, sub, div, neg, letIn, letChain, cmp, select, outputs, collectLets,
     // Authoring convenience — not an AST primitive, see util.js.
     forComponents,
     // Built-in example formulas — see samples/ for the source.
@@ -31,11 +32,15 @@ module.exports = {
     // Not a worked example -- a conformance-test fixture that calls every
     // supported Math function once. See samples/kitchen-sink.js.
     kitchenSinkAst,
+    // Also not a worked example -- a conformance-test fixture for
+    // require("exprforge/math"). See samples/math-demo.js.
+    mathDemoAst,
     samples: {
         catmullRom: catmullRomAst,
         fibonacci: fibonacciAst,
         splineFrame: splineFrameAsts,
         kitchenSink: kitchenSinkAst,
+        mathDemo: mathDemoAst,
     },
     // Per-language emitter instances, keyed by name (js, qb64, c, java, go, rust).
     emitters,

package/math/index.js

@@ -0,0 +1,105 @@
+// exprforge/math/index.js
+// Standard math utilities — see docs/v0.2.0-math-utilities.md for the
+// design doc this implements. This module is level 1: pure compositions of
+// the level-0 AST primitives (ast.js), built to save every consumer from
+// re-deriving the same safe-math/vector patterns samples/spline-frame.js
+// used to hand-roll locally (dot3/len3/safeDiv/EPS there predate this file
+// and motivated it). No new emitter logic — emitAll handles these
+// transparently, same as any other AST the caller builds by hand.
+//
+// require("exprforge/math") is a separate export path from require("exprforge")
+// itself (see package.json's "exports" map) — additive, not merged into the
+// core barrel.
+const { num, v, call, add, mul, sub, div, letIn, cmp, select } = require("../ast.js");
+
+// Shared epsilon for all near-zero guards below. Exposed so callers can
+// reuse it in their own cmp() calls for consistency with safeDiv/normalize3,
+// same convention as samples/spline-frame.js's local EPS.
+const EPS = num(0.000001);
+
+// Guard against division by zero: numerator/denominatorExpr when
+// |denominatorExpr| > EPS, else fallback. Per select()'s doc comment in
+// ast.js, both branches of a select are always evaluated on every target —
+// so this does NOT guard the division directly (div(numerator,
+// denominatorExpr) would still be reached with a near-zero denominator on
+// any target that can't short-circuit, e.g. QB64). Instead the denominator
+// is clamped to a safe, always-nonzero value by its own select first,
+// mirroring the local safeDiv in samples/spline-frame.js.
+//
+// denominatorExpr is referenced twice in the resulting tree (once for the
+// |.| > EPS check, once in the clamped-denominator select) — cheap if it's
+// a var reference or a simple expression, but if it's an expensive
+// subexpression (e.g. a len3() call), pass an already-letIn-bound v(name)
+// instead of the raw expression to avoid computing it twice per emitted
+// target. normalize3() below does exactly that internally.
+function safeDiv(numerator, denominatorExpr, fallback) {
+    const isSafe = cmp(call("abs", denominatorExpr), ">", EPS);
+    const safeDenom = select(isSafe, denominatorExpr, num(1));
+    return select(isSafe, div(numerator, safeDenom), fallback);
+}
+
+// 3-D dot product: ax*bx + ay*by + az*bz.
+function dot3(ax, ay, az, bx, by, bz) {
+    return add(mul(ax, bx), mul(ay, by), mul(az, bz));
+}
+
+// 3-D Euclidean length: sqrt(x² + y² + z²). Emits a sqrt intrinsic (see
+// README's "Supported Math functions").
+function len3(x, y, z) {
+    return call("sqrt", dot3(x, y, z, x, y, z));
+}
+
+// 3-D cross product. Returns a plain JS object { x, y, z } of AST nodes,
+// NOT an AST node itself — a deliberate ergonomic choice so callers can
+// destructure and name each component in their own letIn chain, rather
+// than exprforge picking the names for them.
+function cross3(ax, ay, az, bx, by, bz) {
+    return {
+        x: sub(mul(ay, bz), mul(az, by)),
+        y: sub(mul(az, bx), mul(ax, bz)),
+        z: sub(mul(ax, by), mul(ay, bx)),
+    };
+}
+
+// Monotonic counter behind normalize3's internal let-binding names — see
+// the comment inside normalize3 for why it needs one at all. Global (not
+// per-call-site) is deliberately overkill: it only has to avoid colliding
+// with another normalize3() binding inside the same function body, and a
+// process-wide counter trivially guarantees that regardless of how many
+// times normalize3 is called across however many functions.
+let normalizeGensymCounter = 0;
+
+// Safe-normalize a 3-D vector. Returns { x, y, z } (same shape as cross3).
+// Falls back to (fx, fy, fz) — default (0, 1, 0) — when the vector's length
+// is at or below EPS.
+//
+// Per the spec's recommendation, this computes len3(x, y, z) ONCE and
+// shares it across all three divisions (one EPS check, one sqrt), instead
+// of calling safeDiv three times against three independent len3() calls.
+// The mechanism: the length is let-bound inside the `x` field's own tree,
+// and `y`/`z` just reference that bound name bare. collectLets (ast.js)
+// hoists a let found anywhere in a function body to one flat, ordered list
+// regardless of which sibling subtree it was found in — see
+// test/ast.test.js's "collectLets hoists a let nested inside one output
+// field's own value" for the exact behavior this relies on. The gensym'd
+// name avoids a "duplicate let binding name" throw if normalize3 is called
+// more than once inside one function (e.g. normalizing two vectors).
+function normalize3(x, y, z, fx = num(0), fy = num(1), fz = num(0)) {
+    const lenName = `__exprforgeMathNrmLen${normalizeGensymCounter++}`;
+    return {
+        x: letIn(lenName, len3(x, y, z), safeDiv(x, v(lenName), fx)),
+        y: safeDiv(y, v(lenName), fy),
+        z: safeDiv(z, v(lenName), fz),
+    };
+}
+
+// Clamps val to [lo, hi]. Expressed as nested select/cmp — no runtime
+// intrinsic required, matching cmp/select's existing usage elsewhere (see
+// samples/spline-frame.js). val is referenced three times in the resulting
+// tree; pass a var reference (or an already-let-bound one) if it's not
+// already cheap to re-evaluate.
+function clamp(val, lo, hi) {
+    return select(cmp(val, "<", lo), lo, select(cmp(val, ">", hi), hi, val));
+}
+
+module.exports = { EPS, safeDiv, dot3, len3, cross3, normalize3, clamp };

package/package.json

@@ -1,16 +1,22 @@
 {
   "name": "exprforge",
-  "version": "0.1.0",
+  "version": "0.2.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",
+  "exports": {
+    ".": "./index.js",
+    "./math": "./math/index.js",
+    "./package.json": "./package.json"
+  },
   "files": [
     "index.js",
     "ast.js",
     "util.js",
     "build.js",
     "emitters/",
-    "samples/"
+    "samples/",
+    "math/"
   ],
   "scripts": {
     "build": "node build.js",

package/samples/math-demo.js

@@ -0,0 +1,44 @@
+// exprforge/samples/math-demo.js
+// Not a worked example -- a conformance-test fixture for math/index.js,
+// same role samples/kitchen-sink.js plays for the core Math intrinsics:
+// exercises every exprforge/math helper in one suite, purely so
+// test/conformance.test.js can prove the generated code agrees across
+// every target. Calls normalize3() twice (once per input vector) in the
+// same function specifically to prove its internal gensym'd let-binding
+// doesn't collide with itself -- see the comment on normalizeGensymCounter
+// in math/index.js.
+const { v, num, outputs } = require("../ast.js");
+const { safeDiv, dot3, len3, cross3, normalize3, clamp } = require("../math/index.js");
+
+const MATH_DEMO_PARAMS = ["ax", "ay", "az", "bx", "by", "bz", "t", "lo", "hi"];
+
+const cross = cross3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz"));
+const normA = normalize3(v("ax"), v("ay"), v("az"));
+const normB = normalize3(v("bx"), v("by"), v("bz"));
+
+const MathDemo = {
+    name: "MathDemo",
+    params: MATH_DEMO_PARAMS,
+    body: outputs({
+        dot: dot3(v("ax"), v("ay"), v("az"), v("bx"), v("by"), v("bz")),
+        // "mag", not "len": LEN is a reserved QB64 builtin (string/array
+        // length) -- see test/conformance.test.js's normalizeXAst comment.
+        mag: len3(v("ax"), v("ay"), v("az")),
+        crossX: cross.x,
+        crossY: cross.y,
+        crossZ: cross.z,
+        normAX: normA.x,
+        normAY: normA.y,
+        normAZ: normA.z,
+        normBX: normB.x,
+        normBY: normB.y,
+        normBZ: normB.z,
+        clamped: clamp(v("t"), v("lo"), v("hi")),
+        // ax/bx as numerator/denominator: exercises both the safe path
+        // (bx away from zero) and the fallback (bx == 0, see
+        // test/conformance.test.js's math-demo input rows).
+        safeDivResult: safeDiv(v("ax"), v("bx"), num(-1)),
+    }),
+};
+
+module.exports = { mathDemoAst: MathDemo };

package/samples/spline-frame.js

@@ -15,7 +15,12 @@
 // 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");
+//
+// mfLetChain/apLetChain/rfLetChain/SpEfCrWeights use letChain() (ast.js)
+// instead of hand-nested letIn calls -- apLetChain was 14 levels deep
+// before, all hand-balanced closing parens with no real hierarchy behind
+// the nesting, exactly the kind of thing that's easy to miscount editing.
+const { num, v, call, add, mul, sub, div, neg, letChain, select, cmp, outputs } = require("../ast.js");
 
 // ── Helpers ──────────────────────────────────────────────────────────────
 const PI = num(3.141592653589793);
@@ -66,17 +71,20 @@ 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
-           )))))))));
+    return letChain(
+        [
+            ["wy", select(nearVert, num(0), num(1))],
+            ["wz", select(nearVert, num(1), num(0))],
+            ["crossX", sub(mul(v("ty"), v("wz")), mul(v("tz"), v("wy")))],
+            ["crossY", neg(mul(v("tx"), v("wz")))],
+            ["crossZ", mul(v("tx"), v("wy"))],
+            ["rLen", len3(v("crossX"), v("crossY"), v("crossZ"))],
+            ["rxN", safeDiv(v("crossX"), "rLen", num(0))],
+            ["ryN", safeDiv(v("crossY"), "rLen", num(0))],
+            ["rzN", safeDiv(v("crossZ"), "rLen", num(1))],
+        ],
+        body,
+    );
 }
 
 // U = R × T (using normalized R) — a cyclic permutation, not one formula,
@@ -101,23 +109,26 @@ const SpEfMkFrame = {
 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
-           )))))))))))))));
+    return letChain(
+        [
+            ["wy", select(nearVert, num(0), num(1))],
+            ["wz", select(nearVert, num(1), num(0))],
+            ["crossX", sub(mul(v("ty"), v("wz")), mul(v("tz"), v("wy")))],
+            ["crossY", neg(mul(v("tx"), v("wz")))],
+            ["crossZ", mul(v("tx"), v("wy"))],
+            ["rLen", len3(v("crossX"), v("crossY"), v("crossZ"))],
+            ["rxN", safeDiv(v("crossX"), "rLen", num(0))],
+            ["ryN", safeDiv(v("crossY"), "rLen", num(0))],
+            ["rzN", safeDiv(v("crossZ"), "rLen", num(1))],
+            ["ux", sub(mul(v("ryN"), v("tz")), mul(v("rzN"), v("ty")))],
+            ["uy", sub(mul(v("rzN"), v("tx")), mul(v("rxN"), v("tz")))],
+            ["uz", sub(mul(v("rxN"), v("ty")), mul(v("ryN"), v("tx")))],
+            ["rad", degToRad(v("prDeg"))],
+            ["c", call("cos", v("rad"))],
+            ["s", call("sin", v("rad"))],
+        ],
+        body,
+    );
 }
 
 const SpEfActualPos = {
@@ -139,10 +150,14 @@ const SpEfActualPos = {
 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)));
+    return letChain(
+        [
+            ["rad", degToRad(v("crDeg"))],
+            ["c", call("cos", v("rad"))],
+            ["s", call("sin", v("rad"))],
+        ],
+        body,
+    );
 }
 
 const SpEfRollFrame = {
@@ -167,15 +182,18 @@ 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")))),
-              })
-          )),
+    body: letChain(
+        [
+            ["t2", mul(v("t"), v("t"))],
+            ["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 ──────────────────────────────────────────────────────────────