@uwmd/core 1.1.0

package/dist/calc/evaluator.js

@@ -0,0 +1,184 @@
+// Tier-3 Calc Host — AST evaluator.
+// Variable resolution per §VIII.2; null propagation per §VIII.2.
+import { getSection } from '../parser.js';
+import { BUILTINS } from './builtins.js';
+import { CalcError } from './errors.js';
+const MAX_NODES = 1024;
+export function evaluate(expr, ctx) {
+    const state = { nodes: 0 };
+    return evalNode(expr, ctx, state);
+}
+function evalNode(expr, ctx, state) {
+    if (++state.nodes > MAX_NODES) {
+        throw new CalcError('CALC-LIMIT-001', `Expression exceeds ${MAX_NODES} AST nodes.`);
+    }
+    switch (expr.kind) {
+        case 'literal':
+            return expr.value;
+        case 'ident':
+            return resolveIdentifier(expr.name, ctx);
+        case 'path': {
+            const head = resolveIdentifier(expr.head, ctx);
+            if (head === null || head === undefined)
+                return null;
+            let cur = head;
+            for (const seg of expr.segments) {
+                if (cur === null || cur === undefined)
+                    return null;
+                cur = cur[seg];
+            }
+            return coerceCalcValue(cur);
+        }
+        case 'call': {
+            const fn = BUILTINS[expr.name];
+            if (!fn) {
+                throw new CalcError('CALC-RESOLVE-001', `Unknown function '${expr.name}'.`);
+            }
+            const args = expr.args.map((a) => evalNode(a, ctx, state));
+            return fn(args);
+        }
+        case 'unary': {
+            const v = evalNode(expr.operand, ctx, state);
+            if (v === null)
+                return null;
+            if (expr.op === '-') {
+                if (typeof v !== 'number') {
+                    throw new CalcError('CALC-TYPE-001', `Unary '-' requires number, got ${typeof v}.`);
+                }
+                return -v;
+            }
+            // !
+            if (typeof v !== 'boolean') {
+                throw new CalcError('CALC-TYPE-001', `Unary '!' requires boolean, got ${typeof v}.`);
+            }
+            return !v;
+        }
+        case 'binary': {
+            // Logical operators short-circuit and propagate null. The right side is
+            // only evaluated if the left side does not already determine the answer.
+            if (expr.op === '&&' || expr.op === '||') {
+                const left = evalNode(expr.left, ctx, state);
+                if (left === null)
+                    return null;
+                if (typeof left !== 'boolean') {
+                    throw new CalcError('CALC-TYPE-001', `Operator '${expr.op}' requires booleans, got ${typeof left} on left.`);
+                }
+                // Short-circuit: false && _ = false; true || _ = true.
+                if (expr.op === '&&' && left === false)
+                    return false;
+                if (expr.op === '||' && left === true)
+                    return true;
+                const right = evalNode(expr.right, ctx, state);
+                if (right === null)
+                    return null;
+                if (typeof right !== 'boolean') {
+                    throw new CalcError('CALC-TYPE-001', `Operator '${expr.op}' requires booleans, got ${typeof right} on right.`);
+                }
+                return right;
+            }
+            return evalBinary(expr.op, evalNode(expr.left, ctx, state), evalNode(expr.right, ctx, state));
+        }
+        case 'cond': {
+            const test = evalNode(expr.test, ctx, state);
+            if (test === null)
+                return null;
+            if (typeof test !== 'boolean') {
+                throw new CalcError('CALC-TYPE-001', `Ternary condition must be boolean, got ${typeof test}.`);
+            }
+            return test ? evalNode(expr.consequent, ctx, state) : evalNode(expr.else, ctx, state);
+        }
+    }
+}
+// ─── Variable resolution ──────────────────────────────────────────────────────
+function resolveIdentifier(name, ctx) {
+    const fm = ctx.parsed.frontmatter;
+    if (fm && Object.prototype.hasOwnProperty.call(fm, name)) {
+        return coerceCalcValue(fm[name]);
+    }
+    const section = getSection(ctx.parsed, name);
+    if (section) {
+        // Per §VIII.2: identifier maps to the canonical block's content (user data
+        // inside the JSON envelope). The parser stores the full envelope on
+        // block.content; the user-facing data lives at block.content.content.
+        const envelope = section.content;
+        const inner = envelope && typeof envelope === 'object' && 'content' in envelope
+            ? envelope.content
+            : envelope;
+        return coerceCalcValue(inner);
+    }
+    if (Object.prototype.hasOwnProperty.call(ctx.prior_results, name)) {
+        return ctx.prior_results[name] ?? null;
+    }
+    return null;
+}
+function coerceCalcValue(v) {
+    if (v === null || v === undefined)
+        return null;
+    if (typeof v === 'number' || typeof v === 'string' || typeof v === 'boolean')
+        return v;
+    // Objects/arrays remain accessible via path traversal — return them as-is so
+    // the caller (path walker) can drill in. Convert to null for terminal use.
+    return v;
+}
+// ─── Binary operator evaluation ───────────────────────────────────────────────
+function evalBinary(op, l, r) {
+    switch (op) {
+        case '+':
+            if (l === null || r === null)
+                return null;
+            if (typeof l === 'number' && typeof r === 'number')
+                return l + r;
+            if (typeof l === 'string' && typeof r === 'string')
+                return l + r;
+            throw new CalcError('CALC-TYPE-001', `'+' requires number+number or string+string.`);
+        case '-':
+        case '*':
+        case '/':
+        case '%': {
+            if (l === null || r === null)
+                return null;
+            if (typeof l !== 'number' || typeof r !== 'number') {
+                throw new CalcError('CALC-TYPE-001', `Operator '${op}' requires numbers.`);
+            }
+            if ((op === '/' || op === '%') && r === 0) {
+                throw new CalcError('CALC-DIV-ZERO', 'Division by zero.');
+            }
+            if (op === '-')
+                return l - r;
+            if (op === '*')
+                return l * r;
+            if (op === '/')
+                return l / r;
+            return l - Math.trunc(l / r) * r; // %
+        }
+        case '==': return strictEqual(l, r);
+        case '!=': return !strictEqual(l, r);
+        case '<':
+        case '<=':
+        case '>':
+        case '>=': {
+            if (l === null || r === null)
+                return null;
+            if (typeof l !== typeof r) {
+                throw new CalcError('CALC-TYPE-001', `Comparison '${op}' requires same types.`);
+            }
+            if (typeof l !== 'number' && typeof l !== 'string') {
+                throw new CalcError('CALC-TYPE-001', `Comparison '${op}' requires numbers or strings.`);
+            }
+            if (op === '<')
+                return l < r;
+            if (op === '<=')
+                return l <= r;
+            if (op === '>')
+                return l > r;
+            return l >= r;
+        }
+    }
+    throw new CalcError('CALC-PARSE-001', `Unknown binary operator '${op}'.`);
+}
+function strictEqual(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return a === b;
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/calc/evaluator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.js","sourceRoot":"","sources":["../../src/calc/evaluator.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,iEAAiE;AAEjE,OAAO,EAAW,UAAU,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAkB,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,SAAS,GAAG,IAAI,CAAC;AAMvB,MAAM,UAAU,QAAQ,CAAC,IAAU,EAAE,GAA0B;IAC7D,MAAM,KAAK,GAAc,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IACtC,OAAO,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AACpC,CAAC;AAED,SAAS,QAAQ,CAAC,IAAU,EAAE,GAA0B,EAAE,KAAgB;IACxE,IAAI,EAAE,KAAK,CAAC,KAAK,GAAG,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,SAAS,CAAC,gBAAgB,EAAE,sBAAsB,SAAS,aAAa,CAAC,CAAC;IACtF,CAAC;IAED,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,SAAS;YACZ,OAAO,IAAI,CAAC,KAAK,CAAC;QAEpB,KAAK,OAAO;YACV,OAAO,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAE3C,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,IAAI,GAAG,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YAC/C,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS;gBAAE,OAAO,IAAI,CAAC;YACrD,IAAI,GAAG,GAAY,IAAI,CAAC;YACxB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAChC,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS;oBAAE,OAAO,IAAI,CAAC;gBACnD,GAAG,GAAI,GAA+B,CAAC,GAAG,CAAC,CAAC;YAC9C,CAAC;YACD,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;QAED,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC/B,IAAI,CAAC,EAAE,EAAE,CAAC;gBACR,MAAM,IAAI,SAAS,CAAC,kBAAkB,EAAE,qBAAqB,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;YAC9E,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;YAC3D,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC;QAED,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YAC7C,IAAI,CAAC,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC5B,IAAI,IAAI,CAAC,EAAE,KAAK,GAAG,EAAE,CAAC;gBACpB,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;oBAC1B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,kCAAkC,OAAO,CAAC,GAAG,CAAC,CAAC;gBACtF,CAAC;gBACD,OAAO,CAAC,CAAC,CAAC;YACZ,CAAC;YACD,IAAI;YACJ,IAAI,OAAO,CAAC,KAAK,SAAS,EAAE,CAAC;gBAC3B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,mCAAmC,OAAO,CAAC,GAAG,CAAC,CAAC;YACvF,CAAC;YACD,OAAO,CAAC,CAAC,CAAC;QACZ,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,wEAAwE;YACxE,yEAAyE;YACzE,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;gBACzC,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC7C,IAAI,IAAI,KAAK,IAAI;oBAAE,OAAO,IAAI,CAAC;gBAC/B,IAAI,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;oBAC9B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,aAAa,IAAI,CAAC,EAAE,4BAA4B,OAAO,IAAI,WAAW,CAAC,CAAC;gBAC/G,CAAC;gBACD,uDAAuD;gBACvD,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK;oBAAE,OAAO,KAAK,CAAC;gBACrD,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,KAAK,IAAI;oBAAE,OAAO,IAAI,CAAC;gBACnD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;gBAC/C,IAAI,KAAK,KAAK,IAAI;oBAAE,OAAO,IAAI,CAAC;gBAChC,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;oBAC/B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,aAAa,IAAI,CAAC,EAAE,4BAA4B,OAAO,KAAK,YAAY,CAAC,CAAC;gBACjH,CAAC;gBACD,OAAO,KAAK,CAAC;YACf,CAAC;YACD,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;QAChG,CAAC;QAED,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YAC7C,IAAI,IAAI,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC/B,IAAI,OAAO,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC9B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,0CAA0C,OAAO,IAAI,GAAG,CAAC,CAAC;YACjG,CAAC;YACD,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QACxF,CAAC;IACH,CAAC;AACH,CAAC;AAED,iFAAiF;AAEjF,SAAS,iBAAiB,CAAC,IAAY,EAAE,GAA0B;IACjE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,WAAiD,CAAC;IACxE,IAAI,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,CAAC;QACzD,OAAO,eAAe,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7C,IAAI,OAAO,EAAE,CAAC;QACZ,2EAA2E;QAC3E,oEAAoE;QACpE,sEAAsE;QACtE,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAqD,CAAC;QAC/E,MAAM,KAAK,GAAG,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,SAAS,IAAI,QAAQ;YAC7E,CAAC,CAAC,QAAQ,CAAC,OAAO;YAClB,CAAC,CAAC,QAAQ,CAAC;QACb,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,EAAE,CAAC;QAClE,OAAO,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;IACzC,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,eAAe,CAAC,CAAU;IACjC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC/C,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IACvF,6EAA6E;IAC7E,2EAA2E;IAC3E,OAAO,CAAyB,CAAC;AACnC,CAAC;AAED,iFAAiF;AAEjF,SAAS,UAAU,CAAC,EAAU,EAAE,CAAY,EAAE,CAAY;IACxD,QAAQ,EAAE,EAAE,CAAC;QACX,KAAK,GAAG;YACN,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC1C,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YACjE,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YACjE,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,8CAA8C,CAAC,CAAC;QAEvF,KAAK,GAAG,CAAC;QACT,KAAK,GAAG,CAAC;QACT,KAAK,GAAG,CAAC;QACT,KAAK,GAAG,CAAC,CAAC,CAAC;YACT,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC1C,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACnD,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,aAAa,EAAE,qBAAqB,CAAC,CAAC;YAC7E,CAAC;YACD,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC1C,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;YAC5D,CAAC;YACD,IAAI,EAAE,KAAK,GAAG;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YAC7B,IAAI,EAAE,KAAK,GAAG;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YAC7B,IAAI,EAAE,KAAK,GAAG;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC;YAC7B,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI;QACxC,CAAC;QAED,KAAK,IAAI,CAAC,CAAC,OAAO,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpC,KAAK,IAAI,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAErC,KAAK,GAAG,CAAC;QACT,KAAK,IAAI,CAAC;QACV,KAAK,GAAG,CAAC;QACT,KAAK,IAAI,CAAC,CAAC,CAAC;YACV,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC1C,IAAI,OAAO,CAAC,KAAK,OAAO,CAAC,EAAE,CAAC;gBAC1B,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,eAAe,EAAE,wBAAwB,CAAC,CAAC;YAClF,CAAC;YACD,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACnD,MAAM,IAAI,SAAS,CAAC,eAAe,EAAE,eAAe,EAAE,gCAAgC,CAAC,CAAC;YAC1F,CAAC;YACD,IAAI,EAAE,KAAK,GAAG;gBAAE,OAAQ,CAAqB,GAAI,CAAqB,CAAC;YACvE,IAAI,EAAE,KAAK,IAAI;gBAAE,OAAQ,CAAqB,IAAK,CAAqB,CAAC;YACzE,IAAI,EAAE,KAAK,GAAG;gBAAE,OAAQ,CAAqB,GAAI,CAAqB,CAAC;YACvE,OAAQ,CAAqB,IAAK,CAAqB,CAAC;QAC1D,CAAC;IACH,CAAC;IACD,MAAM,IAAI,SAAS,CAAC,gBAAgB,EAAE,4BAA4B,EAAE,IAAI,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,WAAW,CAAC,CAAY,EAAE,CAAY;IAC7C,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC"}

package/dist/calc/index.d.ts

@@ -0,0 +1,14 @@
+import type { CalcEvaluationContext, CalcResult, ModuleCalcDecl } from '../protocol.js';
+export { parseExpression } from './parser.js';
+export { evaluate } from './evaluator.js';
+export { BUILTINS } from './builtins.js';
+export type { CalcValue, Builtin } from './builtins.js';
+export { CalcError, calcError } from './errors.js';
+export type { CalcErrorCode } from './errors.js';
+/**
+ * Evaluate a single calculation declaration against a context.
+ * Always returns a CalcResult — exceptions from the engine are captured
+ * into the `error` field, never thrown.
+ */
+export declare function evaluateCalc(decl: ModuleCalcDecl, ctx: CalcEvaluationContext): CalcResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/calc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/calc/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAKxF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,qBAAqB,GAAG,UAAU,CAwBzF"}

package/dist/calc/index.js

@@ -0,0 +1,56 @@
+// Tier-3 Calc Host — public entry point.
+// `evaluateCalc()` parses a calc declaration's formula, resolves variables
+// against the CalcEvaluationContext, and returns a CalcResult per §VIII.
+import { formatCurrency, formatPercent, formatRatio, formatValue } from '../format.js';
+import { CalcError } from './errors.js';
+import { evaluate } from './evaluator.js';
+import { parseExpression } from './parser.js';
+export { parseExpression } from './parser.js';
+export { evaluate } from './evaluator.js';
+export { BUILTINS } from './builtins.js';
+export { CalcError, calcError } from './errors.js';
+/**
+ * Evaluate a single calculation declaration against a context.
+ * Always returns a CalcResult — exceptions from the engine are captured
+ * into the `error` field, never thrown.
+ */
+export function evaluateCalc(decl, ctx) {
+    try {
+        const ast = parseExpression(decl.formula);
+        const value = evaluate(ast, ctx);
+        return {
+            calc_id: decl.id,
+            ok: true,
+            value: value,
+            ...(decl.unit ? { unit: decl.unit } : {}),
+            display: formatForDisplay(value, decl.unit),
+        };
+    }
+    catch (e) {
+        const proto = e instanceof CalcError
+            ? e.proto
+            : { category: 'calc', code: 'CALC-PARSE-001', message: e instanceof Error ? e.message : String(e) };
+        return {
+            calc_id: decl.id,
+            ok: false,
+            value: null,
+            ...(decl.unit ? { unit: decl.unit } : {}),
+            error: proto,
+        };
+    }
+}
+function formatForDisplay(value, unit) {
+    if (value === null || value === undefined)
+        return formatValue(null);
+    if (typeof value !== 'number')
+        return String(value);
+    switch (unit) {
+        case '%': return formatPercent(value);
+        case '$': return formatCurrency(value);
+        case 'x': return formatRatio(value);
+        default:
+            // Fall back to a fixed-decimal display.
+            return Number.isInteger(value) ? value.toString() : value.toFixed(4);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/calc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/calc/index.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,2EAA2E;AAC3E,yEAAyE;AAEzE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEvF,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGnD;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,IAAoB,EAAE,GAA0B;IAC3E,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1C,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAEjC,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,EAAE;YAChB,EAAE,EAAE,IAAI;YACR,KAAK,EAAE,KAAyC;YAChD,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzC,OAAO,EAAE,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC;SAC5C,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,KAAK,GAAG,CAAC,YAAY,SAAS;YAClC,CAAC,CAAC,CAAC,CAAC,KAAK;YACT,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAe,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/G,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,EAAE;YAChB,EAAE,EAAE,KAAK;YACT,KAAK,EAAE,IAAI;YACX,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACzC,KAAK,EAAE,KAAK;SACb,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc,EAAE,IAAa;IACrD,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC;IACpE,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACpD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,GAAG,CAAC,CAAC,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC;QACtC,KAAK,GAAG,CAAC,CAAC,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC;QACvC,KAAK,GAAG,CAAC,CAAC,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;QACpC;YACE,wCAAwC;YACxC,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACzE,CAAC;AACH,CAAC"}

package/dist/calc/parser.d.ts

@@ -0,0 +1,32 @@
+export type Expr = {
+    kind: 'literal';
+    value: number | string | boolean | null;
+} | {
+    kind: 'ident';
+    name: string;
+} | {
+    kind: 'path';
+    head: string;
+    segments: string[];
+} | {
+    kind: 'call';
+    name: string;
+    args: Expr[];
+} | {
+    kind: 'unary';
+    op: '-' | '!';
+    operand: Expr;
+} | {
+    kind: 'binary';
+    op: BinaryOp;
+    left: Expr;
+    right: Expr;
+} | {
+    kind: 'cond';
+    test: Expr;
+    consequent: Expr;
+    else: Expr;
+};
+export type BinaryOp = '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||';
+export declare function parseExpression(input: string): Expr;
+//# sourceMappingURL=parser.d.ts.map

package/dist/calc/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/calc/parser.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,IAAI,GACZ;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,EAAE,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,OAAO,EAAE,IAAI,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,QAAQ,GAChB,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAC3B,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GACrC,IAAI,GAAG,IAAI,CAAC;AAsShB,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAGnD"}

package/dist/calc/parser.js

@@ -0,0 +1,361 @@
+// Tier-3 Calc Host — recursive-descent parser for the safe-expression
+// grammar in UW_PROTOCOL_v1.md §VIII.1. Produces an AST that evaluator.ts
+// walks. Any input that does not parse against the grammar is rejected
+// with CALC-PARSE-001.
+import { CalcError } from './errors.js';
+const _KEYWORDS = new Set(['true', 'false', 'null']);
+// Maximum input length — guards against accidental enormous inputs.
+const MAX_INPUT_LEN = 4096;
+function tokenize(input) {
+    if (input.length > MAX_INPUT_LEN) {
+        throw new CalcError('CALC-LIMIT-001', `Expression exceeds ${MAX_INPUT_LEN} characters.`);
+    }
+    const out = [];
+    let i = 0;
+    while (i < input.length) {
+        const c = input[i];
+        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+            i++;
+            continue;
+        }
+        if (c >= '0' && c <= '9') {
+            const start = i;
+            while (i < input.length && input[i] >= '0' && input[i] <= '9')
+                i++;
+            if (input[i] === '.' && input[i + 1] && input[i + 1] >= '0' && input[i + 1] <= '9') {
+                i++;
+                while (i < input.length && input[i] >= '0' && input[i] <= '9')
+                    i++;
+            }
+            out.push({ kind: 'number', value: input.slice(start, i), pos: start });
+            continue;
+        }
+        if (c === "'") {
+            const start = i;
+            i++;
+            const sb = [];
+            while (i < input.length && input[i] !== "'") {
+                sb.push(input[i]);
+                i++;
+            }
+            if (input[i] !== "'") {
+                throw new CalcError('CALC-PARSE-001', `Unterminated string starting at position ${start}.`);
+            }
+            i++;
+            out.push({ kind: 'string', value: sb.join(''), pos: start });
+            continue;
+        }
+        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_') {
+            const start = i;
+            while (i < input.length) {
+                const k = input[i];
+                if ((k >= 'A' && k <= 'Z') || (k >= 'a' && k <= 'z') || (k >= '0' && k <= '9') || k === '_')
+                    i++;
+                else
+                    break;
+            }
+            const text = input.slice(start, i);
+            if (text === 'true' || text === 'false')
+                out.push({ kind: 'bool', value: text, pos: start });
+            else if (text === 'null')
+                out.push({ kind: 'null', value: text, pos: start });
+            else
+                out.push({ kind: 'ident', value: text, pos: start });
+            continue;
+        }
+        // Two-char operators first.
+        const two = input.slice(i, i + 2);
+        if (two === '==') {
+            out.push({ kind: 'eq', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        if (two === '!=') {
+            out.push({ kind: 'neq', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        if (two === '<=') {
+            out.push({ kind: 'lte', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        if (two === '>=') {
+            out.push({ kind: 'gte', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        if (two === '&&') {
+            out.push({ kind: 'amp_amp', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        if (two === '||') {
+            out.push({ kind: 'pipe_pipe', value: two, pos: i });
+            i += 2;
+            continue;
+        }
+        switch (c) {
+            case '(':
+                out.push({ kind: 'lparen', value: c, pos: i });
+                i++;
+                continue;
+            case ')':
+                out.push({ kind: 'rparen', value: c, pos: i });
+                i++;
+                continue;
+            case '[':
+                out.push({ kind: 'lbracket', value: c, pos: i });
+                i++;
+                continue;
+            case ']':
+                out.push({ kind: 'rbracket', value: c, pos: i });
+                i++;
+                continue;
+            case ',':
+                out.push({ kind: 'comma', value: c, pos: i });
+                i++;
+                continue;
+            case '.':
+                out.push({ kind: 'dot', value: c, pos: i });
+                i++;
+                continue;
+            case '?':
+                out.push({ kind: 'qmark', value: c, pos: i });
+                i++;
+                continue;
+            case ':':
+                out.push({ kind: 'colon', value: c, pos: i });
+                i++;
+                continue;
+            case '+':
+                out.push({ kind: 'plus', value: c, pos: i });
+                i++;
+                continue;
+            case '-':
+                out.push({ kind: 'minus', value: c, pos: i });
+                i++;
+                continue;
+            case '*':
+                out.push({ kind: 'star', value: c, pos: i });
+                i++;
+                continue;
+            case '/':
+                out.push({ kind: 'slash', value: c, pos: i });
+                i++;
+                continue;
+            case '%':
+                out.push({ kind: 'percent', value: c, pos: i });
+                i++;
+                continue;
+            case '!':
+                out.push({ kind: 'bang', value: c, pos: i });
+                i++;
+                continue;
+            case '<':
+                out.push({ kind: 'lt', value: c, pos: i });
+                i++;
+                continue;
+            case '>':
+                out.push({ kind: 'gt', value: c, pos: i });
+                i++;
+                continue;
+        }
+        throw new CalcError('CALC-PARSE-001', `Unexpected character '${c}' at position ${i}.`);
+    }
+    out.push({ kind: 'eof', value: '', pos: input.length });
+    return out;
+}
+// ─── Parser ───────────────────────────────────────────────────────────────────
+class Parser {
+    tokens;
+    pos = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const expr = this.parseExpr();
+        this.expect('eof', 'Expected end of expression');
+        return expr;
+    }
+    peek() { return this.tokens[this.pos]; }
+    advance() { return this.tokens[this.pos++]; }
+    match(...kinds) {
+        return kinds.includes(this.peek().kind);
+    }
+    expect(kind, msg) {
+        const tok = this.peek();
+        if (tok.kind !== kind) {
+            throw new CalcError('CALC-PARSE-001', `${msg} (got '${tok.value || tok.kind}' at ${tok.pos}).`);
+        }
+        return this.advance();
+    }
+    // expr := conditional
+    parseExpr() {
+        return this.parseConditional();
+    }
+    // conditional := logicalOr ( "?" expr ":" expr )?
+    parseConditional() {
+        const test = this.parseLogicalOr();
+        if (this.match('qmark')) {
+            this.advance();
+            const consequent = this.parseExpr();
+            this.expect('colon', "Expected ':' in ternary");
+            const alternate = this.parseExpr();
+            return { kind: 'cond', test, consequent, else: alternate };
+        }
+        return test;
+    }
+    // logicalOr := logicalAnd ( "||" logicalAnd )*
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.match('pipe_pipe')) {
+            this.advance();
+            const right = this.parseLogicalAnd();
+            left = { kind: 'binary', op: '||', left, right };
+        }
+        return left;
+    }
+    // logicalAnd := comparison ( "&&" comparison )*
+    parseLogicalAnd() {
+        let left = this.parseComparison();
+        while (this.match('amp_amp')) {
+            this.advance();
+            const right = this.parseComparison();
+            left = { kind: 'binary', op: '&&', left, right };
+        }
+        return left;
+    }
+    // comparison := additive ( ( "==" | "!=" | "<=" | ">=" | "<" | ">" ) additive )?
+    parseComparison() {
+        const left = this.parseAdditive();
+        const tok = this.peek();
+        let op = null;
+        switch (tok.kind) {
+            case 'eq':
+                op = '==';
+                break;
+            case 'neq':
+                op = '!=';
+                break;
+            case 'lte':
+                op = '<=';
+                break;
+            case 'gte':
+                op = '>=';
+                break;
+            case 'lt':
+                op = '<';
+                break;
+            case 'gt':
+                op = '>';
+                break;
+        }
+        if (op !== null) {
+            this.advance();
+            const right = this.parseAdditive();
+            return { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // additive := multiplicative ( ("+" | "-") multiplicative )*
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.match('plus', 'minus')) {
+            const op = this.advance().kind === 'plus' ? '+' : '-';
+            const right = this.parseMultiplicative();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // multiplicative := unary ( ("*" | "/" | "%") unary )*
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.match('star', 'slash', 'percent')) {
+            const t = this.advance().kind;
+            const op = t === 'star' ? '*' : t === 'slash' ? '/' : '%';
+            const right = this.parseUnary();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // unary := ( "-" | "!" )? primary
+    parseUnary() {
+        if (this.match('minus')) {
+            this.advance();
+            return { kind: 'unary', op: '-', operand: this.parsePrimary() };
+        }
+        if (this.match('bang')) {
+            this.advance();
+            return { kind: 'unary', op: '!', operand: this.parsePrimary() };
+        }
+        return this.parsePrimary();
+    }
+    // primary := literal | identifier | call | path | "(" expr ")"
+    parsePrimary() {
+        const tok = this.peek();
+        if (tok.kind === 'number') {
+            this.advance();
+            return { kind: 'literal', value: Number.parseFloat(tok.value) };
+        }
+        if (tok.kind === 'string') {
+            this.advance();
+            return { kind: 'literal', value: tok.value };
+        }
+        if (tok.kind === 'bool') {
+            this.advance();
+            return { kind: 'literal', value: tok.value === 'true' };
+        }
+        if (tok.kind === 'null') {
+            this.advance();
+            return { kind: 'literal', value: null };
+        }
+        if (tok.kind === 'lparen') {
+            this.advance();
+            const inner = this.parseExpr();
+            this.expect('rparen', "Expected ')'");
+            return inner;
+        }
+        if (tok.kind === 'ident') {
+            this.advance();
+            // Function call?
+            if (this.match('lparen')) {
+                this.advance();
+                const args = [];
+                if (!this.match('rparen')) {
+                    args.push(this.parseExpr());
+                    while (this.match('comma')) {
+                        this.advance();
+                        args.push(this.parseExpr());
+                    }
+                }
+                this.expect('rparen', "Expected ')' to close call");
+                return { kind: 'call', name: tok.value, args };
+            }
+            // Member chain (dot or bracket-string)?
+            const segments = [];
+            while (this.match('dot', 'lbracket')) {
+                if (this.match('dot')) {
+                    this.advance();
+                    const idTok = this.expect('ident', 'Expected identifier after .');
+                    segments.push(idTok.value);
+                }
+                else {
+                    this.advance();
+                    const strTok = this.expect('string', "Expected string inside [ ]");
+                    this.expect('rbracket', "Expected ']'");
+                    segments.push(strTok.value);
+                }
+            }
+            if (segments.length > 0)
+                return { kind: 'path', head: tok.value, segments };
+            return { kind: 'ident', name: tok.value };
+        }
+        throw new CalcError('CALC-PARSE-001', `Unexpected token '${tok.value || tok.kind}' at position ${tok.pos}.`);
+    }
+}
+export function parseExpression(input) {
+    const tokens = tokenize(input);
+    return new Parser(tokens).parse();
+}
+//# sourceMappingURL=parser.js.map