exprforge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Don Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# 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)
+[![Lua](https://github.com/theraccoonbear/exprforge/actions/workflows/test-lua.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-lua.yml)
+[![QB64](https://github.com/theraccoonbear/exprforge/actions/workflows/test-qb64.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-qb64.yml)
+[![C](https://github.com/theraccoonbear/exprforge/actions/workflows/test-c.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-c.yml)
+[![Java](https://github.com/theraccoonbear/exprforge/actions/workflows/test-java.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-java.yml)
+[![Go](https://github.com/theraccoonbear/exprforge/actions/workflows/test-go.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-go.yml)
+[![Rust](https://github.com/theraccoonbear/exprforge/actions/workflows/test-rust.yml/badge.svg)](https://github.com/theraccoonbear/exprforge/actions/workflows/test-rust.yml)
+
+Author a math expression once, as a small AST, and emit verified,
+identical-behavior implementations in JavaScript, TypeScript, Python, C#,
+Lua, QB64, C, Java, Go, and Rust.
+
+No parser, no dependencies. You build the AST directly with plain JS
+functions; the same tree is walked once per target language.
+
+## Why
+
+Codegen tools like SymPy already turn math expressions into code for
+mainstream languages. This exists for two things SymPy doesn't do:
+
+- Targets like QB64/BASIC that no general codegen project supports.
+- A conformance test harness that actually proves the emitted targets
+  agree numerically, not just that they compile.
+
+## Install
+
+```
+npm install exprforge
+```
+
+## Usage
+
+```js
+const { num, v, bin, mul, add, sub, emitAll } = require("exprforge");
+
+const fn = {
+    name: "lerp",
+    params: ["a", "b", "t"],
+    body: add(v("a"), mul(sub(v("b"), v("a")), v("t"))),
+};
+
+const outputs = emitAll(fn);
+console.log(outputs.rust.source);
+console.log(outputs.c.source);
+```
+
+## Samples
+
+`samples/` has worked, non-trivial examples (also exported from the
+package individually, or together as `samples`):
+
+- `samples/catmull-rom.js` — uniform Catmull-Rom spline interpolation.
+- `samples/fibonacci.js` — nth Fibonacci number via Binet's closed form.
+  There's no loop/recursion version because exprforge has no control flow
+  (see below) — this is what "fibonacci" looks like as a pure expression.
+- `samples/spline-frame.js` — Gram-Schmidt frame construction for spline
+  paths (worldUp selection, tangent normalization with a safe-division
+  fallback, roll). 4 suites exercising `letIn`/`cmp`/`select`/`outputs` on
+  a real-world case — this is the actual motivating use case for those
+  node types, not a toy. Used to be 19 separate functions, each
+  independently re-deriving the same let-chain (including a `sqrt`) for
+  one output; now each related group shares that work once per call.
+- `samples/kitchen-sink.js` — not a worked example: a synthetic function
+  that calls all 22 supported Math functions in one expression, existing
+  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.
+
+`npm run build` emits all of them, for every target language, into `out/`.
+
+## Supported Math functions
+
+`sqrt abs pow sin cos tan asin acos atan atan2 log log2 log10 exp
+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.
+
+## Adding a language
+
+Write `emitters/<lang>.js` exporting an `Emitter` instance (see any
+existing file as a template), then add one line to
+`emitters/registry.js`. Nothing else changes — proven by the TypeScript
+emitter, added with no changes to `base.js`, `build.js`, or `index.js`.
+
+## Named subexpressions and conditional values
+
+Beyond `num`/`v`/`bin`/`call`, two more node types stay inside the
+expression model without introducing control flow:
+
+- **`letIn(name, value, body)`** — name a subexpression to avoid
+  recomputing it (e.g. `sqrt(x²+y²+z²)` once, then divide three
+  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.
+- **`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
+  in Rust, `a if cond else b` in Python, `cond and a or b` in Lua (safe
+  there specifically because only `nil`/`false` are falsy in Lua — a
+  number is always truthy, so this never mis-selects at zero), an
+  immediately-invoked function in Go (which has neither ternary nor an
+  `if`-expression), and the equivalent arithmetic expression in QB64
+  (which has no conditional expression syntax whatsoever).
+
+  **`select` is not a branch** — every target evaluates both `then` and
+  `else`. Don't use it to guard division by zero or anything else
+  undefined; clamp the operand itself with its own `select` first (see
+  `safeDiv` in `samples/spline-frame.js`), or keep a real guard as
+  hand-written code around the generated function.
+
+See [`docs/planned-additions.md`](./docs/planned-additions.md) for the
+full design rationale, including why the naive "guard division with
+select" pattern is wrong.
+
+## Multiple named outputs
+
+`outputs({ name: Node, ... })` computes several named values from ONE
+shared `letIn` chain, instead of one function per value each re-deriving
+the whole chain from scratch:
+
+```js
+const { num, v, add, sub, letIn, outputs } = require("exprforge");
+
+const sumAndDiff = {
+    name: "sumAndDiff",
+    params: ["a", "b"],
+    body: letIn("total", add(v("a"), v("b")),
+          letIn("delta", sub(v("a"), v("b")),
+              outputs({ sum: v("total"), diff: v("delta") })
+          )),
+};
+```
+
+Only valid as a function's top-level body (wrap it in `letIn`s, don't nest
+it inside `bin`/`call`/`select`). Each target renders it as whatever
+multi-value idiom it has, since none of them agree:
+
+| Target | Shape |
+|---|---|
+| JS | object literal |
+| Go, Lua | native multiple return values |
+| C# | a native named value tuple (`(double rx, double ry)`) |
+| C / Rust | a small `...Result` struct, returned by value |
+| Java, Python | a nested/local `Result` class |
+| QB64 | a `SUB` with the outputs as trailing by-reference parameters |
+
+Go specifically does **not** use *named* return values (`(rx, ry float64)`)
+even though Go supports them and it reads nicer: those are sugar for
+pre-declared locals in the function's own scope, and that collides — for
+real, on the first suite this feature was built for — whenever an output
+name matches an internal `letIn` name. Plain unnamed return types side-step
+the whole collision class regardless of naming; a leading comment documents
+the order instead (same reason Lua's return, also positional, gets one).
+C#'s tuple has no such risk — a tuple literal's element names aren't
+pre-declared locals the way Go's named returns are.
+
+## What this deliberately doesn't do
+
+- No control flow (loops, branches, calling other generated functions) —
+  this is an expression AST, not a program AST.
+- No RNG — can't be made to produce identical output across languages,
+  so it isn't offered as if it could.
+- No arbitrary precision / complex numbers — float64 only, for now.
+
+## Testing
+
+```
+npm test
+```
+
+Runs `node --test`. For each sample, that's two kinds of check:
+
+- Emitted JS vs. an independently hand-written reference implementation
+  (catches a wrong formula in the AST itself).
+- Every other emitted target vs. that same JS, compiled (and, for
+  TypeScript, also type-checked under `--strict`) and run, with the sample
+  inputs as arguments (catches an emitter bug).
+
+The compiled/interpreted-language checks need their toolchain on `PATH`
+and skip (not fail) when it's missing, so `npm test` degrades gracefully
+on any one machine. Every one of `tsc`/`qb64pe`/`dotnet`/`python3`/`lua`
+is treated exactly like gcc/go/rustc/javac: looked up on `PATH`, never a
+project dependency — exprforge only ever generates source text for these,
+it doesn't execute or type-check any of it itself. `package.json` has
+zero dependencies of any kind, matching this.
+
+CI is one workflow file per target language (`.github/workflows/test-*.yml`),
+run in parallel — they have nothing to do with each other, so there's no
+reason to serialize installing nine different toolchains (QB64-PE alone,
+built from source and cached by version, takes several minutes) into one
+job, and splitting by file rather than by job within one file is also
+what gets each language its own real status badge above, not just one
+combined "did everything pass" badge. Each workflow installs only its own
+toolchain and runs `EXPRFORGE_TEST_TARGETS=<Label> npm test`; that
+environment variable (read once in `test/conformance.test.js`) filters
+the target lists down to just that one language, plus the toolchain-
+independent JS/reference checks, which every workflow repeats — cheap,
+and a redundant sanity check each time. Unset locally, so a plain
+`npm test` still runs everything your own machine's installed toolchains
+allow.
+
+A few of these needed real debugging to get right, all found by actually
+compiling/running against a real toolchain rather than assumed to work:
+
+- **QB64**: `Dim x# AS DOUBLE` (sigil *and* an `AS` clause together) is a
+  syntax error; has to be `Dim x AS DOUBLE`. Its own exponential notation
+  uses `D`, not `E` (`1D-9`, not `1e-9#`) — including when reading its
+  `PRINT` output back, not just in literals. A chunk of QB64/BASIC
+  builtins (`len`, `val`, `pos`, `log`, ... — see `QB64_RESERVED` in
+  `emitters/qb64.js`) silently conflict with a same-named variable; the
+  emitter throws a clear error at emission time instead of failing to
+  compile later with no context. The test harness runs compiled binaries
+  headless via the `$CONSOLE:ONLY` metacommand, so no display (real or
+  virtual) is needed — no `xvfb-run` required for these console-only test
+  programs, unlike a typical QB64 build.
+- **C#**: forbids a member sharing its enclosing type's *exact* name
+  (`CS0542`) — every SpEf-prefixed sample name here is already
+  capitalized, so the obvious `capitalize(fn.name)` wrapper-class name
+  collided with the method name outright; see `wrapperClassName` in
+  `emitters/csharp.js`. Bare integer-valued literals are `int` by
+  default, and `int / int` is integer division — every literal is
+  suffixed `d` unconditionally to rule that out, not just the cases that
+  would otherwise break.
+- **Python**: `math.floor`/`math.ceil`/`math.trunc`/`round` all return
+  `int`, not `float` — wrapped with `float(...)` to stay float64
+  throughout, matching every other target.
+- **Lua**: 5.3+ removed `math.pow` (use the `^` operator) and
+  `math.atan2` (use two-argument `math.atan(y, x)`); there's no
+  `math.round` or `math.trunc` or `math.sign` at any version (manual
+  `floor(x+0.5)`, `math.modf(x)`, and an `and`/`or` chain respectively).
+
+One test (`normalizeX`) is deliberately excluded from the QB64 check
+only: it exists specifically to demonstrate the "don't guard division
+with `select`" pitfall from the section above, and QB64 is the one
+target where that pitfall actually produces `NaN` (every other target,
+including Lua's `and`/`or`, genuinely short-circuits around it) — that's
+the AST being correctly unsafe on purpose, not an emitter bug.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/ast.js

@@ -0,0 +1,142 @@
+// exprforge/ast.js
+// Generic AST builder primitives — this is the actual library API. Compose
+// these into your own expression trees; see samples/ for worked examples.
+//
+// Node shapes:
+//   { type: "num",    value: number }
+//   { type: "var",    name: string }
+//   { type: "bin",    op: "+" | "-" | "*" | "/", left: Node, right: Node }
+//   { type: "call",   name: string, args: Node[] }   // any Math.* function
+//   { type: "let",    name: string, value: Node, body: Node }
+//   { type: "cmp",    op: ">" | "<" | ">=" | "<=" | "==" | "!=", left: Node, right: Node }
+//   { type: "select", cond: CmpNode, then: Node, else: Node }
+//   { type: "outputs", fields: { [name: string]: Node } }
+//
+// Every "bin" node is emitted with explicit parens in every target, so
+// operation order (and therefore floating-point rounding behavior) is
+// identical everywhere.
+
+function num(value) {
+    return { type: "num", value };
+}
+
+function v(name) {
+    return { type: "var", name };
+}
+
+function bin(op, left, right) {
+    return { type: "bin", op, left, right };
+}
+
+function call(name, ...args) {
+    return { type: "call", name, args };
+}
+
+function add(...terms) {
+    return terms.reduce((acc, t) => (acc === null ? t : bin("+", acc, t)), null);
+}
+
+function mul(...terms) {
+    return terms.reduce((acc, t) => (acc === null ? t : bin("*", acc, t)), null);
+}
+
+function sub(a, b) {
+    return bin("-", a, b);
+}
+
+function div(a, b) {
+    return bin("/", a, b);
+}
+
+// Unary negation, since there's no unary operator in the AST — every
+// operator here is binary. `0 - x` rather than `-1 * x`: both are always
+// safe to emit, but subtraction from zero is the more direct reading.
+function neg(x) {
+    return sub(num(0), x);
+}
+
+// Name a subexpression to avoid recomputing it (e.g. sqrt(x²+y²+z²) once,
+// then divide three components by it). Lifted out by collectLets before
+// emission — see there for how `v(name)` ends up referring to it.
+function letIn(name, value, body) {
+    return { type: "let", name, value, 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) {
+    return { type: "cmp", op, left, right };
+}
+
+// Conditional *value* selection, not a branch — both `then` and `else` are
+// always evaluated by every emitter (this is a value expression, not
+// control flow). Do not use this to guard division by zero or any other
+// undefined operation: ensure the operands are already safe (e.g. clamp a
+// denominator with its own select before dividing by it), or keep a real
+// guard as hand-written code in the caller of the generated function.
+function select(cond, thenNode, elseNode) {
+    return { type: "select", cond, then: thenNode, else: elseNode };
+}
+
+// Multiple named outputs computed from ONE shared let-chain, instead of N
+// separate function definitions each re-deriving the whole chain from
+// scratch. Only valid as a function's (post-let-lifting) top-level body —
+// wrap it, don't nest it inside bin/call/select. Each emitter renders it as
+// whatever multi-value idiom its language has (a struct, a native multiple
+// return, an object literal, output parameters) — see formatSuite in each
+// emitters/<lang>.js.
+function outputs(fields) {
+    return { type: "outputs", fields };
+}
+
+// Lifts every `let` node out of the tree into a flat, ordered list of
+// { name, node } bindings, replacing each with a plain v(name) reference.
+// The list is in dependency order — safe to declare/assign top-to-bottom.
+// Throws if two bindings share a name: they'd silently shadow or fail to
+// redeclare depending on the target language, and there's no lexical
+// scoping here to make that meaningful — every binding lands in one flat
+// list per function.
+function collectLets(node) {
+    const bindings = [];
+
+    function walk(n) {
+        if (n.type === "let") {
+            const { bindings: inner, body: val } = collectLets(n.value);
+            bindings.push(...inner);
+            bindings.push({ name: n.name, node: val });
+            return walk(n.body);
+        }
+        if (n.type === "bin") return { ...n, left: walk(n.left), right: walk(n.right) };
+        if (n.type === "call") return { ...n, args: n.args.map(walk) };
+        if (n.type === "select") {
+            return {
+                ...n,
+                then: walk(n.then),
+                else: walk(n.else),
+                cond: { ...n.cond, left: walk(n.cond.left), right: walk(n.cond.right) },
+            };
+        }
+        if (n.type === "outputs") {
+            const fields = {};
+            for (const [name, fieldNode] of Object.entries(n.fields)) {
+                fields[name] = walk(fieldNode);
+            }
+            return { ...n, fields };
+        }
+        return n; // num, var
+    }
+
+    const body = walk(node);
+
+    const seen = new Set();
+    for (const { name } of bindings) {
+        if (seen.has(name)) {
+            throw new Error(`collectLets: duplicate let binding name "${name}" in one function`);
+        }
+        seen.add(name);
+    }
+
+    return { bindings, body };
+}
+
+module.exports = { num, v, bin, call, add, mul, sub, div, neg, letIn, cmp, select, outputs, collectLets };

package/build.js

@@ -0,0 +1,35 @@
+// exprforge/build.js
+const fs = require("fs");
+const path = require("path");
+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 samples = { "catmull-rom": catmullRomAst, fibonacci: fibonacciAst, "kitchen-sink": kitchenSinkAst };
+
+const outDir = path.join(__dirname, "out");
+if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir);
+}
+
+for (const [sampleName, ast] of Object.entries(samples)) {
+    for (const [lang, emitter] of Object.entries(emitters)) {
+        const source = emitter.emitFunction(ast);
+        const outPath = path.join(outDir, `${sampleName}.generated.${emitter.ext}`);
+        fs.writeFileSync(outPath, source);
+        console.log(`[${lang}] wrote ${path.relative(__dirname, outPath)}`);
+    }
+}
+
+// spline-frame.js exports many functions (one per output component) rather
+// than one AST, so it gets its own loop: one file per (function, language).
+for (const ast of splineFrameAsts) {
+    for (const [lang, emitter] of Object.entries(emitters)) {
+        const source = emitter.emitFunction(ast);
+        const outPath = path.join(outDir, `spline-frame.${ast.name}.generated.${emitter.ext}`);
+        fs.writeFileSync(outPath, source);
+        console.log(`[${lang}] wrote ${path.relative(__dirname, outPath)}`);
+    }
+}

package/emitters/base.js

@@ -0,0 +1,113 @@
+// exprforge/emitters/base.js
+//
+// A language plugin is just a config object passed to `new Emitter(config)`.
+// This is the extension point: adding a new language means writing ONE new
+// file that builds an Emitter, not touching this file or any other emitter.
+//
+// config shape:
+//   ext            — output file extension, e.g. "rs"
+//   formatNumber   — (value: number) => string        (literal syntax)
+//   calls          — { [mathFnName]: (argStrs: string[]) => string }
+//                    Covers BOTH "direct" (sqrt -> `sqrt(${x})`) and
+//                    "expanded" (sign -> ternary expression) cases, and
+//                    postfix/method-call languages like Rust (`${x}.sqrt()`),
+//                    uniformly — it's just a string template either way.
+//   formatFunction — (fn: {name, params, body}, bodyStr: string, letBindings: {name, valueStr}[]) => string
+//                    Full source text for one function, including any
+//                    language-specific signature/type/wrapper syntax.
+//                    letBindings is [] for let-free expressions.
+//   emitSelect     — optional override: (condNode, thenStr, elseStr) => string
+//                    Default is a ternary; QB64 has no ternary and overrides
+//                    this with the equivalent arithmetic expression instead.
+//   formatSuite    — (fn: {name, params}, outputStrs: {name: string}, letBindings) => string
+//                    Only needed for targets that support multi-output
+//                    suites (see ast.js's outputs()). Renders whatever
+//                    multi-value idiom the language has. Required if any
+//                    suite gets emitted through this emitter; omitted
+//                    otherwise.
+
+const { collectLets } = require("../ast.js");
+
+class Emitter {
+    constructor(config) {
+        this.ext = config.ext;
+        this.formatNumber = config.formatNumber;
+        this.calls = config.calls || {};
+        this.formatFunctionImpl = config.formatFunction;
+        this.formatSuiteImpl = config.formatSuite || null;
+        this.emitSelectImpl = config.emitSelect
+            ? config.emitSelect.bind(this)
+            : this._defaultSelect.bind(this);
+    }
+
+    // Default ternary (cond ? a : b) — correct for JS, C, and Java, which
+    // all share this syntax. Go has no ternary at all (and `if` is a
+    // statement, not an expression); Rust uses `if`-as-expression instead
+    // of ?:; QB64 has no conditional expression syntax whatsoever. Those
+    // three override emitSelect with their own syntax — see their files.
+    _defaultSelect(condNode, thenStr, elseStr) {
+        const L = this.emitExpr(condNode.left);
+        const R = this.emitExpr(condNode.right);
+        return `((${L} ${condNode.op} ${R}) ? ${thenStr} : ${elseStr})`;
+    }
+
+    emitExpr(node) {
+        switch (node.type) {
+            case "num": {
+                return this.formatNumber(node.value);
+            }
+            case "var": {
+                return node.name;
+            }
+            case "bin": {
+                return `(${this.emitExpr(node.left)} ${node.op} ${this.emitExpr(node.right)})`;
+            }
+            case "call": {
+                const args = node.args.map((a) => this.emitExpr(a));
+                const template = this.calls[node.name];
+                if (!template) {
+                    throw new Error(`emitter for .${this.ext}: no mapping for Math function "${node.name}"`);
+                }
+                return template(args);
+            }
+            case "select": {
+                const thenStr = this.emitExpr(node.then);
+                const elseStr = this.emitExpr(node.else);
+                return this.emitSelectImpl(node.cond, thenStr, elseStr);
+            }
+            case "cmp": {
+                // cmp only ever appears as a select's cond, consumed directly
+                // by emitSelectImpl above — it never reaches emitExpr in a
+                // well-formed tree. Landing here means a cmp node was used
+                // somewhere else (e.g. as a plain operand), which isn't
+                // supported: cmp isn't a general boolean expression.
+                throw new Error(`emitter for .${this.ext}: "cmp" is only valid inside a select() — got it elsewhere`);
+            }
+            default: {
+                throw new Error(`emitter for .${this.ext}: unknown node type "${node.type}"`);
+            }
+        }
+    }
+
+    emitFunction(fn) {
+        const { bindings, body } = collectLets(fn.body);
+        const letBindings = bindings.map(({ name, node }) => ({
+            name,
+            valueStr: this.emitExpr(node),
+        }));
+        if (body.type === "outputs") {
+            if (!this.formatSuiteImpl) {
+                throw new Error(`emitter for .${this.ext}: no formatSuite configured — multi-output suites aren't supported for this target yet`);
+            }
+            const outputStrs = {};
+            for (const [name, node] of Object.entries(body.fields)) {
+                outputStrs[name] = this.emitExpr(node);
+            }
+            return this.formatSuiteImpl(fn, outputStrs, letBindings);
+        }
+        const bodyStr = this.emitExpr(body);
+        return this.formatFunctionImpl(fn, bodyStr, letBindings);
+    }
+}
+
+module.exports = Emitter;

package/emitters/c.js

@@ -0,0 +1,64 @@
+// exprforge/emitters/c.js
+const Emitter = require("./base.js");
+
+function fn1(name) {
+    return ([x]) => `${name}(${x})`;
+}
+
+function fn2(name) {
+    return ([a, b]) => `${name}(${a}, ${b})`;
+}
+
+const emitter = new Emitter({
+    ext: "c",
+    formatNumber: (v) => (Number.isInteger(v) ? `${v}.0` : String(v)),
+    calls: {
+        sqrt: fn1("sqrt"), abs: fn1("fabs"), 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"),
+        pow: fn2("pow"), atan2: fn2("atan2"), min: fn2("fmin"), max: fn2("fmax"), hypot: fn2("hypot"),
+        // No standard libm "sign" function — emit the comparison directly.
+        sign: ([x]) => `((${x}) > 0.0 ? 1.0 : ((${x}) < 0.0 ? -1.0 : 0.0))`,
+    },
+    formatFunction: (fn, body, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        return `/* AUTO-GENERATED by ExprForge -- do not hand-edit. */\n` +
+               `#include <math.h>\n\n` +
+               `double ${fn.name}(${params})\n` +
+               `{\n` +
+               letsBlock +
+               `    return ${body};\n` +
+               `}\n`;
+    },
+    // Multiple named outputs from one call: C has no native multi-return,
+    // so this emits a small out-struct alongside the function and returns
+    // it by value (a C99 designated-initializer compound literal) — named
+    // field access at the call site, not a positional tuple that's easy to
+    // mix up.
+    formatSuite: (fn, outputStrs, letBindings = []) => {
+        const params = fn.params.map((p) => `double ${p}`).join(", ");
+        const lets = letBindings.map(({ name, valueStr }) => `    double ${name} = ${valueStr};`).join("\n");
+        const letsBlock = lets ? lets + "\n" : "";
+        const outputNames = Object.keys(outputStrs);
+        const structName = `${capitalize(fn.name)}Result`;
+        const structFields = outputNames.map((n) => `    double ${n};`).join("\n");
+        const initFields = outputNames.map((n) => `.${n} = ${outputStrs[n]}`).join(", ");
+        return `/* AUTO-GENERATED by ExprForge -- do not hand-edit. */\n` +
+               `#include <math.h>\n\n` +
+               `typedef struct {\n${structFields}\n} ${structName};\n\n` +
+               `${structName} ${fn.name}(${params})\n` +
+               `{\n` +
+               letsBlock +
+               `    return (${structName}){ ${initFields} };\n` +
+               `}\n`;
+    },
+});
+
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+module.exports = emitter;