@paradoc/expr 0.3.0

package/dist/index.js

@@ -0,0 +1,1659 @@
+// src/types.ts
+var T = {
+  string: { kind: "string" },
+  number: { kind: "number" },
+  boolean: { kind: "boolean" },
+  date: { kind: "date" },
+  datetime: { kind: "datetime" },
+  time: { kind: "time" },
+  duration: { kind: "duration" },
+  money: { kind: "money" },
+  object: { kind: "object" },
+  null: { kind: "null" },
+  unknown: { kind: "unknown" },
+  array: (element) => ({ kind: "array", element })
+};
+function formatType(t) {
+  return t.kind === "array" ? `array<${formatType(t.element)}>` : t.kind;
+}
+function typesEqual(a, b) {
+  if (a.kind === "array" && b.kind === "array") {
+    return typesEqual(a.element, b.element);
+  }
+  return a.kind === b.kind;
+}
+
+// src/grammar/grammar.ts
+var KEYWORDS = ["and", "or", "not", "in", "true", "false", "null"];
+var BINARY_OPERATORS = [
+  { token: "or", precedence: 1, associativity: "left" },
+  { token: "and", precedence: 2, associativity: "left" },
+  { token: "==", precedence: 3, associativity: "left" },
+  { token: "!=", precedence: 3, associativity: "left" },
+  { token: "<", precedence: 4, associativity: "left" },
+  { token: "<=", precedence: 4, associativity: "left" },
+  { token: ">", precedence: 4, associativity: "left" },
+  { token: ">=", precedence: 4, associativity: "left" },
+  { token: "in", precedence: 5, associativity: "left" },
+  { token: "+", precedence: 6, associativity: "left" },
+  { token: "-", precedence: 6, associativity: "left" },
+  { token: "*", precedence: 7, associativity: "left" },
+  { token: "/", precedence: 7, associativity: "left" },
+  { token: "%", precedence: 7, associativity: "left" }
+];
+var UNARY_OPERATORS = ["not", "!", "-"];
+var FORBIDDEN_OPERATORS = {
+  "=": "Use '==' for equality; '=' (assignment) is not allowed.",
+  "||": "Use 'or' for logic and '+' to concatenate strings; '||' is not supported.",
+  "&&": "Use 'and'; '&&' is not supported."
+};
+var KEYWORD_SET = new Set(KEYWORDS);
+var BINARY_OPERATOR_TOKENS = new Set(
+  BINARY_OPERATORS.map((o) => o.token)
+);
+
+// src/registry/registry.ts
+var fixed = (type) => ({ kind: "fixed", type });
+var DEFAULT_SIGNATURES = [
+  // --- string ---
+  {
+    name: "contains",
+    category: "string",
+    params: [
+      { name: "haystack", type: T.unknown },
+      { name: "needle", type: T.unknown }
+    ],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "startsWith",
+    category: "string",
+    params: [
+      { name: "value", type: T.string },
+      { name: "prefix", type: T.string }
+    ],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "endsWith",
+    category: "string",
+    params: [
+      { name: "value", type: T.string },
+      { name: "suffix", type: T.string }
+    ],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "trim",
+    category: "string",
+    params: [{ name: "value", type: T.string }],
+    returns: fixed(T.string),
+    deterministic: true
+  },
+  {
+    name: "lower",
+    category: "string",
+    params: [{ name: "value", type: T.string }],
+    returns: fixed(T.string),
+    deterministic: true
+  },
+  {
+    name: "upper",
+    category: "string",
+    params: [{ name: "value", type: T.string }],
+    returns: fixed(T.string),
+    deterministic: true
+  },
+  {
+    name: "matches",
+    category: "string",
+    params: [
+      { name: "value", type: T.string },
+      { name: "pattern", type: T.string }
+    ],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "isEmpty",
+    category: "string",
+    params: [{ name: "value", type: T.unknown }],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "isNotEmpty",
+    category: "string",
+    params: [{ name: "value", type: T.unknown }],
+    returns: fixed(T.boolean),
+    deterministic: true
+  },
+  {
+    name: "length",
+    category: "string",
+    params: [{ name: "value", type: T.unknown }],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "coalesce",
+    category: "logical",
+    params: [{ name: "value", type: T.unknown }],
+    variadic: true,
+    returns: { kind: "commonOfArgs" },
+    deterministic: true
+  },
+  // --- number (decimal-aware) ---
+  {
+    name: "round",
+    category: "number",
+    params: [
+      { name: "value", type: T.number },
+      { name: "digits", type: T.number, optional: true }
+    ],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "floor",
+    category: "number",
+    params: [{ name: "value", type: T.number }],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "ceil",
+    category: "number",
+    params: [{ name: "value", type: T.number }],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "abs",
+    category: "number",
+    params: [{ name: "value", type: T.number }],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "min",
+    category: "number",
+    params: [{ name: "value", type: T.number }],
+    variadic: true,
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "max",
+    category: "number",
+    params: [{ name: "value", type: T.number }],
+    variadic: true,
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  // --- date (host-injected as-of clock) ---
+  {
+    name: "today",
+    category: "date",
+    params: [],
+    returns: fixed(T.date),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "now",
+    category: "date",
+    params: [],
+    returns: fixed(T.datetime),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "yearsBetween",
+    category: "date",
+    params: [
+      { name: "from", type: T.date },
+      { name: "to", type: T.date }
+    ],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "dateDiff",
+    category: "date",
+    params: [
+      { name: "from", type: T.date },
+      { name: "to", type: T.date },
+      { name: "unit", type: T.string, optional: true }
+    ],
+    returns: fixed(T.number),
+    deterministic: true
+  },
+  {
+    name: "addDuration",
+    category: "date",
+    params: [
+      { name: "date", type: T.date },
+      { name: "duration", type: T.duration }
+    ],
+    returns: fixed(T.date),
+    deterministic: true
+  },
+  {
+    name: "addDays",
+    category: "date",
+    params: [
+      { name: "date", type: T.date },
+      { name: "days", type: T.number }
+    ],
+    returns: fixed(T.date),
+    deterministic: true
+  },
+  // --- domain: party / witness (host-injected party context) ---
+  {
+    name: "partyCount",
+    category: "domain",
+    params: [{ name: "roleId", type: T.string }],
+    returns: fixed(T.number),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "signedCount",
+    category: "domain",
+    params: [{ name: "roleId", type: T.string }],
+    returns: fixed(T.number),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "allSigned",
+    category: "domain",
+    params: [{ name: "roleId", type: T.string }],
+    returns: fixed(T.boolean),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "anySigned",
+    category: "domain",
+    params: [{ name: "roleId", type: T.string }],
+    returns: fixed(T.boolean),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "partyType",
+    category: "domain",
+    params: [{ name: "roleId", type: T.string }],
+    returns: fixed(T.string),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "witnessCount",
+    category: "domain",
+    params: [],
+    returns: fixed(T.number),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "allWitnessesSigned",
+    category: "domain",
+    params: [],
+    returns: fixed(T.boolean),
+    hostInjected: true,
+    deterministic: true
+  },
+  {
+    name: "anyWitnessSigned",
+    category: "domain",
+    params: [],
+    returns: fixed(T.boolean),
+    hostInjected: true,
+    deterministic: true
+  }
+];
+function buildRegistry(extra = []) {
+  const map = /* @__PURE__ */ new Map();
+  for (const sig of [...DEFAULT_SIGNATURES, ...extra]) {
+    map.set(sig.name, sig);
+  }
+  return {
+    signatures: map,
+    has: (name) => map.has(name),
+    get: (name) => map.get(name),
+    names: () => [...map.keys()]
+  };
+}
+
+// src/parser/lexer.ts
+var LexError = class extends Error {
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "LexError";
+  }
+  position;
+};
+var TWO_CHAR_OPERATORS = /* @__PURE__ */ new Set(["==", "!=", "<=", ">=", "||", "&&"]);
+function isDigit(ch) {
+  return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function isIdentStart(ch) {
+  return ch !== void 0 && (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_");
+}
+function isIdentPart(ch) {
+  return isIdentStart(ch) || isDigit(ch);
+}
+function tokenize(source) {
+  const tokens = [];
+  let offset = 0;
+  let line = 1;
+  let column = 1;
+  const pos = () => ({ offset, line, column });
+  const advance = (n = 1) => {
+    for (let i = 0; i < n; i++) {
+      if (source[offset] === "\n") {
+        line++;
+        column = 1;
+      } else {
+        column++;
+      }
+      offset++;
+    }
+  };
+  const push = (type, value, start) => {
+    tokens.push({ type, value, span: { start, end: pos() } });
+  };
+  while (offset < source.length) {
+    const ch = source[offset];
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+      advance();
+      continue;
+    }
+    const start = pos();
+    if (isDigit(ch)) {
+      let value = "";
+      while (offset < source.length && isDigit(source[offset])) {
+        value += source[offset];
+        advance();
+      }
+      if (source[offset] === "." && isDigit(source[offset + 1])) {
+        value += ".";
+        advance();
+        while (offset < source.length && isDigit(source[offset])) {
+          value += source[offset];
+          advance();
+        }
+      }
+      push("number", value, start);
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      advance();
+      let value = "";
+      let closed = false;
+      while (offset < source.length) {
+        const c = source[offset];
+        if (c === "\\") {
+          const next = source[offset + 1];
+          value += next === void 0 ? "\\" : unescape(next);
+          advance(2);
+          continue;
+        }
+        if (c === quote) {
+          advance();
+          closed = true;
+          break;
+        }
+        if (c === "\n") break;
+        value += c;
+        advance();
+      }
+      if (!closed) throw new LexError("Unterminated string literal", start);
+      push("string", value, start);
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let value = "";
+      while (offset < source.length && isIdentPart(source[offset])) {
+        value += source[offset];
+        advance();
+      }
+      push(KEYWORD_SET.has(value) ? "keyword" : "identifier", value, start);
+      continue;
+    }
+    const single = {
+      "(": "lparen",
+      ")": "rparen",
+      "[": "lbracket",
+      "]": "rbracket",
+      ",": "comma",
+      ".": "dot",
+      "?": "question",
+      ":": "colon"
+    };
+    const punct = single[ch];
+    if (punct) {
+      advance();
+      push(punct, ch, start);
+      continue;
+    }
+    const two = source.slice(offset, offset + 2);
+    if (TWO_CHAR_OPERATORS.has(two)) {
+      advance(2);
+      push("operator", two, start);
+      continue;
+    }
+    if ("=<>+-*/%!".includes(ch)) {
+      advance();
+      push("operator", ch, start);
+      continue;
+    }
+    throw new LexError(`Unexpected character '${ch}'`, start);
+  }
+  tokens.push({ type: "eof", value: "", span: { start: pos(), end: pos() } });
+  return tokens;
+}
+function unescape(ch) {
+  switch (ch) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    default:
+      return ch;
+  }
+}
+
+// src/parser/parser.ts
+var ParseError = class extends Error {
+  constructor(diagnostic) {
+    super(diagnostic.message);
+    this.diagnostic = diagnostic;
+    this.name = "ParseError";
+  }
+  diagnostic;
+};
+var OPERATOR_INFO = new Map(
+  BINARY_OPERATORS.map((o) => [o.token, o])
+);
+var ARITHMETIC = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%"]);
+var COMPARISON = /* @__PURE__ */ new Set(["==", "!=", "<", "<=", ">", ">="]);
+function spanBetween(a, b) {
+  return { start: a.start, end: b.end };
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  pos = 0;
+  peek(ahead = 0) {
+    return this.tokens[Math.min(this.pos + ahead, this.tokens.length - 1)];
+  }
+  next() {
+    const t = this.tokens[this.pos];
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return t;
+  }
+  fail(message, span, code = "syntax") {
+    throw new ParseError({ severity: "error", code, message, span });
+  }
+  parse() {
+    if (this.peek().type === "eof") {
+      this.fail("Empty expression", this.peek().span);
+    }
+    const expr = this.parseExpression();
+    const tok = this.peek();
+    if (tok.type !== "eof") {
+      const forbidden = FORBIDDEN_OPERATORS[tok.value];
+      if (forbidden) this.fail(forbidden, tok.span, "forbidden-operator");
+      this.fail(`Unexpected '${tok.value || "end of input"}'`, tok.span);
+    }
+    return expr;
+  }
+  parseExpression() {
+    return this.parseTernary();
+  }
+  parseTernary() {
+    const test = this.parseBinary(0);
+    if (this.peek().type === "question") {
+      this.next();
+      const consequent = this.parseExpression();
+      if (this.peek().type !== "colon") {
+        this.fail("Expected ':' in ternary expression", this.peek().span);
+      }
+      this.next();
+      const alternate = this.parseExpression();
+      return {
+        kind: "Conditional",
+        test,
+        consequent,
+        alternate,
+        span: spanBetween(test.span, alternate.span)
+      };
+    }
+    return test;
+  }
+  /** Precedence climbing, with `not in` and forbidden-operator handling. */
+  parseBinary(minPrec) {
+    let left = this.parseUnary();
+    for (; ; ) {
+      const tok = this.peek();
+      if (tok.type === "keyword" && tok.value === "not" && this.peek(1).value === "in") {
+        const info2 = OPERATOR_INFO.get("in");
+        if (info2.precedence < minPrec) break;
+        this.next();
+        this.next();
+        const right2 = this.parseBinary(info2.precedence + 1);
+        left = {
+          kind: "Membership",
+          negated: true,
+          element: left,
+          collection: right2,
+          span: spanBetween(left.span, right2.span)
+        };
+        continue;
+      }
+      const forbidden = FORBIDDEN_OPERATORS[tok.value];
+      if (forbidden && (tok.type === "operator" || tok.type === "keyword")) {
+        this.fail(forbidden, tok.span, "forbidden-operator");
+      }
+      const info = OPERATOR_INFO.get(tok.value);
+      if (!info || tok.type !== "operator" && tok.type !== "keyword" || info.precedence < minPrec) {
+        break;
+      }
+      this.next();
+      const nextMin = info.associativity === "left" ? info.precedence + 1 : info.precedence;
+      const right = this.parseBinary(nextMin);
+      left = this.makeBinary(info.token, left, right);
+    }
+    return left;
+  }
+  makeBinary(op, left, right) {
+    const span = spanBetween(left.span, right.span);
+    if (op === "and" || op === "or") {
+      return { kind: "Logical", op, left, right, span };
+    }
+    if (op === "in") {
+      return { kind: "Membership", negated: false, element: left, collection: right, span };
+    }
+    if (ARITHMETIC.has(op) || COMPARISON.has(op)) {
+      return { kind: "Binary", op, left, right, span };
+    }
+    this.fail(`Unknown operator '${op}'`, span);
+  }
+  parseUnary() {
+    const tok = this.peek();
+    const isNot = tok.type === "keyword" && tok.value === "not";
+    const isBang = tok.type === "operator" && tok.value === "!";
+    const isNeg = tok.type === "operator" && tok.value === "-";
+    if (isNot || isBang || isNeg) {
+      this.next();
+      const operand = this.parseUnary();
+      return {
+        kind: "Unary",
+        op: isNeg ? "neg" : "not",
+        operand,
+        span: spanBetween(tok.span, operand.span)
+      };
+    }
+    return this.parsePostfix();
+  }
+  parsePostfix() {
+    let expr = this.parsePrimary();
+    for (; ; ) {
+      const tok = this.peek();
+      if (tok.type === "dot") {
+        this.next();
+        const prop = this.peek();
+        if (prop.type !== "identifier") {
+          this.fail('Expected a property name after "."', prop.span);
+        }
+        this.next();
+        expr = { kind: "Member", object: expr, property: prop.value, span: spanBetween(expr.span, prop.span) };
+        continue;
+      }
+      if (tok.type === "lbracket") {
+        this.next();
+        const index = this.parseExpression();
+        const close = this.peek();
+        if (close.type !== "rbracket") this.fail('Expected "]"', close.span);
+        this.next();
+        expr = { kind: "Index", object: expr, index, span: spanBetween(expr.span, close.span) };
+        continue;
+      }
+      break;
+    }
+    return expr;
+  }
+  parsePrimary() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case "number":
+        this.next();
+        return { kind: "NumberLiteral", value: tok.value, span: tok.span };
+      case "string":
+        this.next();
+        return { kind: "StringLiteral", value: tok.value, span: tok.span };
+      case "keyword":
+        if (tok.value === "true" || tok.value === "false") {
+          this.next();
+          return { kind: "BooleanLiteral", value: tok.value === "true", span: tok.span };
+        }
+        if (tok.value === "null") {
+          this.next();
+          return { kind: "NullLiteral", span: tok.span };
+        }
+        this.fail(`Unexpected keyword '${tok.value}'`, tok.span);
+        break;
+      case "identifier": {
+        this.next();
+        if (this.peek().type === "lparen") {
+          return this.parseCall(tok.value, tok.span);
+        }
+        return { kind: "Identifier", name: tok.value, span: tok.span };
+      }
+      case "lparen": {
+        this.next();
+        const inner = this.parseExpression();
+        const close = this.peek();
+        if (close.type !== "rparen") this.fail('Expected ")"', close.span);
+        this.next();
+        return inner;
+      }
+      case "lbracket":
+        return this.parseArrayLiteral(tok.span);
+      default: {
+        const forbidden = FORBIDDEN_OPERATORS[tok.value];
+        if (forbidden) this.fail(forbidden, tok.span, "forbidden-operator");
+        this.fail(`Unexpected '${tok.value || "end of input"}'`, tok.span);
+      }
+    }
+  }
+  parseCall(callee, calleeSpan) {
+    this.next();
+    const args = [];
+    if (this.peek().type !== "rparen") {
+      for (; ; ) {
+        args.push(this.parseExpression());
+        if (this.peek().type === "comma") {
+          this.next();
+          continue;
+        }
+        break;
+      }
+    }
+    const close = this.peek();
+    if (close.type !== "rparen") this.fail('Expected ")" to close arguments', close.span);
+    this.next();
+    return { kind: "Call", callee, args, span: spanBetween(calleeSpan, close.span) };
+  }
+  parseArrayLiteral(openSpan) {
+    this.next();
+    const elements = [];
+    if (this.peek().type !== "rbracket") {
+      for (; ; ) {
+        elements.push(this.parseExpression());
+        if (this.peek().type === "comma") {
+          this.next();
+          continue;
+        }
+        break;
+      }
+    }
+    const close = this.peek();
+    if (close.type !== "rbracket") this.fail('Expected "]" to close array', close.span);
+    this.next();
+    return { kind: "ArrayLiteral", elements, span: spanBetween(openSpan, close.span) };
+  }
+};
+function parse(source) {
+  try {
+    const tokens = tokenize(source);
+    const ast = new Parser(tokens).parse();
+    return { ast, errors: [] };
+  } catch (e) {
+    if (e instanceof ParseError) {
+      return { ast: null, errors: [e.diagnostic] };
+    }
+    if (e instanceof LexError) {
+      const span = { start: e.position, end: e.position };
+      return { ast: null, errors: [{ severity: "error", code: "syntax", message: e.message, span }] };
+    }
+    throw e;
+  }
+}
+function parseOrThrow(source) {
+  const { ast, errors } = parse(source);
+  if (!ast) {
+    const first = errors[0];
+    throw new Error(first ? `${first.message} (at ${first.span.start.line}:${first.span.start.column})` : "Parse failed");
+  }
+  return ast;
+}
+
+// src/analyze/references.ts
+function staticPath(node) {
+  if (node.kind === "Identifier") return node.name;
+  if (node.kind === "Member") {
+    const base = staticPath(node.object);
+    return base === null ? null : `${base}.${node.property}`;
+  }
+  return null;
+}
+function extractReferences(ast) {
+  const paths = /* @__PURE__ */ new Set();
+  let fullyStatic = true;
+  const visit = (node) => {
+    switch (node.kind) {
+      case "Identifier":
+        paths.add(node.name);
+        return;
+      case "Member": {
+        const path = staticPath(node);
+        if (path !== null) {
+          paths.add(path);
+        } else {
+          visit(node.object);
+        }
+        return;
+      }
+      case "Index":
+        fullyStatic = false;
+        visit(node.object);
+        visit(node.index);
+        return;
+      case "Unary":
+        visit(node.operand);
+        return;
+      case "Binary":
+      case "Logical":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "Membership":
+        visit(node.element);
+        visit(node.collection);
+        return;
+      case "Conditional":
+        visit(node.test);
+        visit(node.consequent);
+        visit(node.alternate);
+        return;
+      case "Call":
+        for (const arg2 of node.args) visit(arg2);
+        return;
+      case "ArrayLiteral":
+        for (const el of node.elements) visit(el);
+        return;
+      case "NumberLiteral":
+      case "StringLiteral":
+      case "BooleanLiteral":
+      case "NullLiteral":
+        return;
+    }
+  };
+  visit(ast);
+  return { paths: [...paths].sort(), fullyStatic };
+}
+
+// src/decimal/decimal.ts
+var DIV_SCALE = 20;
+var DivisionByZeroError = class extends Error {
+  constructor() {
+    super("Division by zero");
+    this.name = "DivisionByZeroError";
+  }
+};
+var DECIMAL_RE = /^-?\d+(\.\d+)?$/;
+function pow10(n) {
+  return 10n ** BigInt(n);
+}
+function absBig(x) {
+  return x < 0n ? -x : x;
+}
+var Decimal = class _Decimal {
+  constructor(n, scale) {
+    this.n = n;
+    this.scale = scale;
+  }
+  n;
+  scale;
+  static fromString(s) {
+    const str = s.trim();
+    if (!DECIMAL_RE.test(str)) {
+      throw new RangeError(`Invalid decimal literal: ${JSON.stringify(s)}`);
+    }
+    const negative = str.startsWith("-");
+    const body = negative ? str.slice(1) : str;
+    const dot = body.indexOf(".");
+    if (dot === -1) {
+      return new _Decimal(BigInt((negative ? "-" : "") + body), 0);
+    }
+    const intPart = body.slice(0, dot);
+    const fracPart = body.slice(dot + 1);
+    const digits = (intPart + fracPart).replace(/^0+(?=\d)/, "");
+    const mag = BigInt(digits === "" ? "0" : digits);
+    return new _Decimal(negative ? -mag : mag, fracPart.length).trim();
+  }
+  static fromInt(i) {
+    return new _Decimal(typeof i === "bigint" ? i : BigInt(Math.trunc(i)), 0);
+  }
+  static ZERO = new _Decimal(0n, 0);
+  /** Bring two decimals to a common scale, returning aligned magnitudes. */
+  static align(a, b) {
+    if (a.scale === b.scale) return { an: a.n, bn: b.n, scale: a.scale };
+    const scale = Math.max(a.scale, b.scale);
+    return {
+      an: a.n * pow10(scale - a.scale),
+      bn: b.n * pow10(scale - b.scale),
+      scale
+    };
+  }
+  add(b) {
+    const { an, bn, scale } = _Decimal.align(this, b);
+    return new _Decimal(an + bn, scale).trim();
+  }
+  sub(b) {
+    const { an, bn, scale } = _Decimal.align(this, b);
+    return new _Decimal(an - bn, scale).trim();
+  }
+  mul(b) {
+    return new _Decimal(this.n * b.n, this.scale + b.scale).trim();
+  }
+  div(b, rm = "half-up") {
+    if (b.n === 0n) throw new DivisionByZeroError();
+    const exp = DIV_SCALE + b.scale - this.scale;
+    let num = this.n;
+    let den = b.n;
+    if (exp >= 0) num *= pow10(exp);
+    else den *= pow10(-exp);
+    return new _Decimal(roundDiv(num, den, rm), DIV_SCALE).trim();
+  }
+  mod(b) {
+    if (b.n === 0n) throw new DivisionByZeroError();
+    const { an, bn, scale } = _Decimal.align(this, b);
+    return new _Decimal(an % bn, scale).trim();
+  }
+  neg() {
+    return new _Decimal(-this.n, this.scale);
+  }
+  abs() {
+    return this.n < 0n ? this.neg() : this;
+  }
+  /** -1, 0, or 1. */
+  cmp(b) {
+    const { an, bn } = _Decimal.align(this, b);
+    return an < bn ? -1 : an > bn ? 1 : 0;
+  }
+  eq(b) {
+    return this.cmp(b) === 0;
+  }
+  lt(b) {
+    return this.cmp(b) < 0;
+  }
+  lte(b) {
+    return this.cmp(b) <= 0;
+  }
+  gt(b) {
+    return this.cmp(b) > 0;
+  }
+  gte(b) {
+    return this.cmp(b) >= 0;
+  }
+  isZero() {
+    return this.n === 0n;
+  }
+  /** Round to `digits` decimal places (default 0). Negative/fractional
+   * digits are clamped to a valid non-negative integer scale. */
+  round(digits = 0, rm = "half-up") {
+    return this.toScale(Math.max(0, Math.trunc(digits)), rm);
+  }
+  floor() {
+    return this.toScale(0, "floor");
+  }
+  ceil() {
+    return this.toScale(0, "ceil");
+  }
+  toScale(target, rm) {
+    if (target >= this.scale) {
+      return new _Decimal(this.n * pow10(target - this.scale), target).trim();
+    }
+    const factor = pow10(this.scale - target);
+    return new _Decimal(roundDiv(this.n, factor, rm), target).trim();
+  }
+  /** Remove trailing fractional zeros, keeping the value identical. */
+  trim() {
+    let { n, scale } = this;
+    while (scale > 0 && n % 10n === 0n) {
+      n /= 10n;
+      scale--;
+    }
+    return new _Decimal(n, scale);
+  }
+  toString() {
+    const neg = this.n < 0n;
+    const digits = absBig(this.n).toString();
+    if (this.scale === 0) return (neg ? "-" : "") + digits;
+    const padded = digits.padStart(this.scale + 1, "0");
+    const cut = padded.length - this.scale;
+    return `${neg ? "-" : ""}${padded.slice(0, cut)}.${padded.slice(cut)}`;
+  }
+  /** Lossy conversion to a JS number, for interop only. */
+  toNumber() {
+    return Number(this.toString());
+  }
+  toJSON() {
+    return this.toString();
+  }
+};
+function roundDiv(num, den, rm) {
+  if (den < 0n) {
+    num = -num;
+    den = -den;
+  }
+  const q = num / den;
+  const r = num % den;
+  if (r === 0n) return q;
+  const negative = num < 0n;
+  switch (rm) {
+    case "down":
+      return q;
+    case "floor":
+      return negative ? q - 1n : q;
+    case "ceil":
+      return negative ? q : q + 1n;
+    case "half-up": {
+      if (absBig(r) * 2n >= den) return negative ? q - 1n : q + 1n;
+      return q;
+    }
+  }
+}
+
+// src/eval/values.ts
+var NULL = { kind: "null" };
+var Values = {
+  number: (d) => ({ kind: "number", value: d }),
+  num: (s) => ({ kind: "number", value: Decimal.fromString(s) }),
+  string: (s) => ({ kind: "string", value: s }),
+  boolean: (b) => ({ kind: "boolean", value: b }),
+  null: NULL,
+  array: (v) => ({ kind: "array", value: v }),
+  object: (entries) => ({
+    kind: "object",
+    value: new Map(entries)
+  })
+};
+function numberToDecimalString(n) {
+  if (!Number.isFinite(n)) throw new RangeError("Cannot convert a non-finite number");
+  if (Number.isInteger(n)) return n.toString();
+  const s = n.toString();
+  if (s.includes("e") || s.includes("E")) {
+    return n.toFixed(20).replace(/0+$/, "").replace(/\.$/, "");
+  }
+  return s;
+}
+function toValue(js) {
+  if (js === null || js === void 0) return NULL;
+  switch (typeof js) {
+    case "boolean":
+      return Values.boolean(js);
+    case "number":
+      return Values.number(Decimal.fromString(numberToDecimalString(js)));
+    case "bigint":
+      return Values.number(Decimal.fromInt(js));
+    case "string":
+      return Values.string(js);
+    case "object": {
+      if (Array.isArray(js)) return Values.array(js.map(toValue));
+      const entries = [];
+      for (const [k, v] of Object.entries(js)) {
+        entries.push([k, toValue(v)]);
+      }
+      return Values.object(entries);
+    }
+    default:
+      return NULL;
+  }
+}
+function truthy(v) {
+  switch (v.kind) {
+    case "null":
+      return false;
+    case "boolean":
+      return v.value;
+    case "number":
+      return !v.value.isZero();
+    case "string":
+      return v.value.length > 0;
+    case "array":
+      return v.value.length > 0;
+    case "object":
+      return true;
+  }
+}
+function valueToString(v) {
+  switch (v.kind) {
+    case "null":
+      return "";
+    case "boolean":
+      return v.value ? "true" : "false";
+    case "number":
+      return v.value.toString();
+    case "string":
+      return v.value;
+    case "array":
+      return v.value.map(valueToString).join(",");
+    case "object":
+      return "[object]";
+  }
+}
+function valueEquals(a, b) {
+  if (a.kind !== b.kind) return false;
+  switch (a.kind) {
+    case "null":
+      return true;
+    case "boolean":
+      return a.value === b.value;
+    case "string":
+      return a.value === b.value;
+    case "number":
+      return a.value.eq(b.value);
+    case "array": {
+      const bv = b.value;
+      return a.value.length === bv.length && a.value.every((el, i) => valueEquals(el, bv[i]));
+    }
+    case "object": {
+      const bv = b.value;
+      if (a.value.size !== bv.size) return false;
+      for (const [k, v] of a.value) {
+        const other = bv.get(k);
+        if (other === void 0 || !valueEquals(v, other)) return false;
+      }
+      return true;
+    }
+  }
+}
+
+// src/eval/errors.ts
+var EvaluationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EvaluationError";
+  }
+  code;
+};
+
+// src/eval/context.ts
+function createContext(data, opts = {}) {
+  const root = toValue(data);
+  const map = root.kind === "object" ? root.value : /* @__PURE__ */ new Map();
+  return {
+    lookup: (name) => map.get(name),
+    asOf: opts.asOf,
+    hostFunctions: opts.hostFunctions
+  };
+}
+
+// src/eval/temporal.ts
+var MS_PER_DAY = 864e5;
+function parse2(s) {
+  const d = new Date(s);
+  if (Number.isNaN(d.getTime())) {
+    throw new EvaluationError("type-error", `Invalid date: ${JSON.stringify(s)}`);
+  }
+  return d;
+}
+function formatDate(d) {
+  return d.toISOString().slice(0, 10);
+}
+function diffDays(a, b) {
+  return Math.trunc((parse2(b).getTime() - parse2(a).getTime()) / MS_PER_DAY);
+}
+function yearsBetween(from, to) {
+  const a = parse2(from);
+  const b = parse2(to);
+  let years = b.getUTCFullYear() - a.getUTCFullYear();
+  const beforeAnniversary = b.getUTCMonth() < a.getUTCMonth() || b.getUTCMonth() === a.getUTCMonth() && b.getUTCDate() < a.getUTCDate();
+  if (beforeAnniversary) years--;
+  return years;
+}
+function dateDiff(from, to, unit = "days") {
+  switch (unit) {
+    case "days":
+      return diffDays(from, to);
+    case "years":
+      return yearsBetween(from, to);
+    case "months": {
+      const a = parse2(from);
+      const b = parse2(to);
+      let months = (b.getUTCFullYear() - a.getUTCFullYear()) * 12 + (b.getUTCMonth() - a.getUTCMonth());
+      if (b.getUTCDate() < a.getUTCDate()) months--;
+      return months;
+    }
+    default:
+      throw new EvaluationError("type-error", `Unknown date unit: ${JSON.stringify(unit)}`);
+  }
+}
+function addDays(date, days) {
+  const d = parse2(date);
+  d.setUTCDate(d.getUTCDate() + Math.trunc(days));
+  return formatDate(d);
+}
+var DURATION_RE = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?$/;
+function addDuration(date, duration) {
+  const m = DURATION_RE.exec(duration);
+  if (!m || duration === "P") {
+    throw new EvaluationError("type-error", `Invalid duration: ${JSON.stringify(duration)}`);
+  }
+  const [, y, mo, w, d] = m;
+  const result = parse2(date);
+  if (y) result.setUTCFullYear(result.getUTCFullYear() + Number(y));
+  if (mo) result.setUTCMonth(result.getUTCMonth() + Number(mo));
+  const days = (w ? Number(w) * 7 : 0) + (d ? Number(d) : 0);
+  if (days) result.setUTCDate(result.getUTCDate() + days);
+  return formatDate(result);
+}
+
+// src/eval/functions.ts
+function arg(args, i) {
+  return args[i] ?? NULL;
+}
+function asString(v, fn) {
+  if (v.kind === "string") return v.value;
+  throw new EvaluationError("type-error", `${fn} expects a string, got ${v.kind}`);
+}
+function asNumber(v, fn) {
+  if (v.kind === "number") return v.value;
+  throw new EvaluationError("type-error", `${fn} expects a number, got ${v.kind}`);
+}
+function isEmptyValue(v) {
+  if (v.kind === "null") return true;
+  if (v.kind === "string") return v.value.length === 0;
+  if (v.kind === "array") return v.value.length === 0;
+  return false;
+}
+var BUILTIN_IMPLS = {
+  // --- string ---
+  contains: (args) => {
+    const haystack = arg(args, 0);
+    const needle = arg(args, 1);
+    if (haystack.kind === "null") return Values.boolean(false);
+    if (haystack.kind === "string") return Values.boolean(haystack.value.includes(asString(needle, "contains")));
+    if (haystack.kind === "array") return Values.boolean(haystack.value.some((el) => valueEquals(el, needle)));
+    throw new EvaluationError("type-error", `contains expects a string or array, got ${haystack.kind}`);
+  },
+  startsWith: (args) => Values.boolean(asString(arg(args, 0), "startsWith").startsWith(asString(arg(args, 1), "startsWith"))),
+  endsWith: (args) => Values.boolean(asString(arg(args, 0), "endsWith").endsWith(asString(arg(args, 1), "endsWith"))),
+  trim: (args) => Values.string(asString(arg(args, 0), "trim").trim()),
+  lower: (args) => Values.string(asString(arg(args, 0), "lower").toLowerCase()),
+  upper: (args) => Values.string(asString(arg(args, 0), "upper").toUpperCase()),
+  matches: (args) => {
+    const value = asString(arg(args, 0), "matches");
+    const pattern = asString(arg(args, 1), "matches");
+    let re;
+    try {
+      re = new RegExp(pattern);
+    } catch {
+      throw new EvaluationError("type-error", `Invalid pattern: ${JSON.stringify(pattern)}`);
+    }
+    return Values.boolean(re.test(value));
+  },
+  isEmpty: (args) => Values.boolean(isEmptyValue(arg(args, 0))),
+  isNotEmpty: (args) => Values.boolean(!isEmptyValue(arg(args, 0))),
+  length: (args) => {
+    const v = arg(args, 0);
+    if (v.kind === "null") return Values.num("0");
+    if (v.kind === "string") return Values.num(String(v.value.length));
+    if (v.kind === "array") return Values.num(String(v.value.length));
+    throw new EvaluationError("type-error", `length expects a string or array, got ${v.kind}`);
+  },
+  coalesce: (args) => {
+    for (const a of args) if (a.kind !== "null") return a;
+    return NULL;
+  },
+  // --- number (exact decimal) ---
+  round: (args) => {
+    const value = asNumber(arg(args, 0), "round");
+    const digitsArg = args[1];
+    const digits = digitsArg && digitsArg.kind === "number" ? digitsArg.value.toNumber() : 0;
+    return Values.number(value.round(digits));
+  },
+  floor: (args) => Values.number(asNumber(arg(args, 0), "floor").floor()),
+  ceil: (args) => Values.number(asNumber(arg(args, 0), "ceil").ceil()),
+  abs: (args) => Values.number(asNumber(arg(args, 0), "abs").abs()),
+  min: (args) => reduceNumbers(args, "min", (a, b) => a.lte(b) ? a : b),
+  max: (args) => reduceNumbers(args, "max", (a, b) => a.gte(b) ? a : b),
+  // --- date (today/now read the injected as-of clock) ---
+  today: (_args, ctx) => {
+    if (!ctx.asOf) throw new EvaluationError("missing-clock", "today() requires an as-of date in the context");
+    return Values.string(ctx.asOf.date);
+  },
+  now: (_args, ctx) => {
+    if (!ctx.asOf) throw new EvaluationError("missing-clock", "now() requires an as-of datetime in the context");
+    return Values.string(ctx.asOf.datetime);
+  },
+  yearsBetween: (args) => Values.num(String(yearsBetween(asString(arg(args, 0), "yearsBetween"), asString(arg(args, 1), "yearsBetween")))),
+  dateDiff: (args) => {
+    const unitArg = args[2];
+    const unit = unitArg && unitArg.kind === "string" ? unitArg.value : void 0;
+    return Values.num(String(dateDiff(asString(arg(args, 0), "dateDiff"), asString(arg(args, 1), "dateDiff"), unit)));
+  },
+  addDuration: (args) => Values.string(addDuration(asString(arg(args, 0), "addDuration"), asString(arg(args, 1), "addDuration"))),
+  addDays: (args) => Values.string(addDays(asString(arg(args, 0), "addDays"), asNumber(arg(args, 1), "addDays").toNumber()))
+};
+function reduceNumbers(args, fn, pick) {
+  if (args.length === 0) throw new EvaluationError("arity", `${fn} requires at least one argument`);
+  let acc = asNumber(arg(args, 0), fn);
+  for (let i = 1; i < args.length; i++) acc = pick(acc, asNumber(arg(args, i), fn));
+  return Values.number(acc);
+}
+
+// src/eval/evaluate.ts
+function evaluate(node, ctx) {
+  switch (node.kind) {
+    case "NumberLiteral":
+      return Values.number(Decimal.fromString(node.value));
+    case "StringLiteral":
+      return Values.string(node.value);
+    case "BooleanLiteral":
+      return Values.boolean(node.value);
+    case "NullLiteral":
+      return NULL;
+    case "ArrayLiteral":
+      return Values.array(node.elements.map((el) => evaluate(el, ctx)));
+    case "Identifier":
+      return ctx.lookup(node.name) ?? NULL;
+    case "Member": {
+      const obj = evaluate(node.object, ctx);
+      if (obj.kind === "object") return obj.value.get(node.property) ?? NULL;
+      return NULL;
+    }
+    case "Index": {
+      const obj = evaluate(node.object, ctx);
+      const idx = evaluate(node.index, ctx);
+      if (obj.kind === "array" && idx.kind === "number") {
+        return obj.value[idx.value.toNumber()] ?? NULL;
+      }
+      return NULL;
+    }
+    case "Unary":
+      return evalUnary(node.op, evaluate(node.operand, ctx));
+    case "Binary":
+      return evalBinary(node.op, node, ctx);
+    case "Logical":
+      return evalLogical(node.op, node, ctx);
+    case "Membership":
+      return evalMembership(node, ctx);
+    case "Conditional":
+      return truthy(evaluate(node.test, ctx)) ? evaluate(node.consequent, ctx) : evaluate(node.alternate, ctx);
+    case "Call":
+      return evalCall(node, ctx);
+  }
+}
+function evalUnary(op, operand) {
+  if (op === "not") return Values.boolean(!truthy(operand));
+  if (operand.kind !== "number") {
+    throw new EvaluationError("type-error", `Cannot negate ${operand.kind}`);
+  }
+  return Values.number(operand.value.neg());
+}
+function evalBinary(op, node, ctx) {
+  const left = evaluate(node.left, ctx);
+  const right = evaluate(node.right, ctx);
+  switch (op) {
+    case "==":
+      return Values.boolean(valueEquals(left, right));
+    case "!=":
+      return Values.boolean(!valueEquals(left, right));
+    case "<":
+    case "<=":
+    case ">":
+    case ">=":
+      return compareOrdered(op, left, right);
+    case "+":
+      if (left.kind === "number" && right.kind === "number") {
+        return Values.number(left.value.add(right.value));
+      }
+      if (left.kind === "string" || right.kind === "string") {
+        return Values.string(valueToString(left) + valueToString(right));
+      }
+      throw new EvaluationError("type-error", `Cannot add ${left.kind} and ${right.kind}`);
+    case "-":
+    case "*":
+    case "/":
+    case "%":
+      return arithmetic(op, left, right);
+    default:
+      throw new EvaluationError("type-error", `Unknown operator ${op}`);
+  }
+}
+function arithmetic(op, left, right) {
+  if (left.kind !== "number" || right.kind !== "number") {
+    throw new EvaluationError("type-error", `Operator '${op}' requires numbers, got ${left.kind} and ${right.kind}`);
+  }
+  try {
+    switch (op) {
+      case "-":
+        return Values.number(left.value.sub(right.value));
+      case "*":
+        return Values.number(left.value.mul(right.value));
+      case "/":
+        return Values.number(left.value.div(right.value));
+      case "%":
+        return Values.number(left.value.mod(right.value));
+      default:
+        throw new EvaluationError("type-error", `Unknown operator ${op}`);
+    }
+  } catch (e) {
+    if (e instanceof DivisionByZeroError) {
+      throw new EvaluationError("division-by-zero", "Division by zero");
+    }
+    throw e;
+  }
+}
+function compareOrdered(op, left, right) {
+  let c;
+  if (left.kind === "number" && right.kind === "number") {
+    c = left.value.cmp(right.value);
+  } else if (left.kind === "string" && right.kind === "string") {
+    c = left.value < right.value ? -1 : left.value > right.value ? 1 : 0;
+  } else {
+    return Values.boolean(false);
+  }
+  switch (op) {
+    case "<":
+      return Values.boolean(c < 0);
+    case "<=":
+      return Values.boolean(c <= 0);
+    case ">":
+      return Values.boolean(c > 0);
+    default:
+      return Values.boolean(c >= 0);
+  }
+}
+function evalLogical(op, node, ctx) {
+  const left = truthy(evaluate(node.left, ctx));
+  if (op === "and") return left ? Values.boolean(truthy(evaluate(node.right, ctx))) : Values.boolean(false);
+  return left ? Values.boolean(true) : Values.boolean(truthy(evaluate(node.right, ctx)));
+}
+function evalMembership(node, ctx) {
+  const element = evaluate(node.element, ctx);
+  const collection = evaluate(node.collection, ctx);
+  let present;
+  if (collection.kind === "array") {
+    present = collection.value.some((el) => valueEquals(el, element));
+  } else if (collection.kind === "string") {
+    if (element.kind !== "string") {
+      throw new EvaluationError("type-error", `Cannot test ${element.kind} membership in a string`);
+    }
+    present = collection.value.includes(element.value);
+  } else if (collection.kind === "null") {
+    present = false;
+  } else {
+    throw new EvaluationError("type-error", `'in' requires an array or string, got ${collection.kind}`);
+  }
+  return Values.boolean(node.negated ? !present : present);
+}
+function evalCall(node, ctx) {
+  const args = node.args.map((a) => evaluate(a, ctx));
+  const host = ctx.hostFunctions?.[node.callee];
+  if (host) return host(args);
+  const impl = BUILTIN_IMPLS[node.callee];
+  if (impl) return impl(args, ctx);
+  throw new EvaluationError("unknown-function", `Unknown function: ${node.callee}`);
+}
+function evaluateExpression(source, ctx) {
+  const { ast, errors } = parse(source);
+  if (!ast) {
+    return { success: false, error: errors[0]?.message ?? "Parse error", diagnostics: errors };
+  }
+  try {
+    return { success: true, value: evaluate(ast, ctx) };
+  } catch (e) {
+    if (e instanceof EvaluationError) return { success: false, error: e.message, code: e.code };
+    throw e;
+  }
+}
+function evaluateBoolean(condExpr, ctx, defaultValue) {
+  if (condExpr === void 0) return defaultValue;
+  if (typeof condExpr === "boolean") return condExpr;
+  const result = evaluateExpression(condExpr, ctx);
+  return result.success ? truthy(result.value) : defaultValue;
+}
+
+// src/check/checker.ts
+function staticPath2(node) {
+  if (node.kind === "Identifier") return node.name;
+  if (node.kind === "Member") {
+    const base = staticPath2(node.object);
+    return base === null ? null : `${base}.${node.property}`;
+  }
+  return null;
+}
+function assignable(expected, actual) {
+  return expected.kind === "unknown" || actual.kind === "unknown" || typesEqual(expected, actual);
+}
+var NUMERIC = (t) => t.kind === "number" || t.kind === "unknown";
+var STRINGY = (t) => t.kind === "string" || t.kind === "unknown";
+var Checker = class {
+  constructor(env) {
+    this.env = env;
+  }
+  env;
+  diagnostics = [];
+  error(code, message, span) {
+    this.diagnostics.push({ severity: "error", code, message, span });
+  }
+  infer(node) {
+    switch (node.kind) {
+      case "NumberLiteral":
+        return T.number;
+      case "StringLiteral":
+        return T.string;
+      case "BooleanLiteral":
+        return T.boolean;
+      case "NullLiteral":
+        return T.null;
+      case "ArrayLiteral":
+        return this.inferArray(node);
+      case "Identifier":
+        return this.inferRef(node.name, node.span);
+      case "Member":
+        return this.inferMember(node);
+      case "Index": {
+        const obj = this.infer(node.object);
+        const idx = this.infer(node.index);
+        if (!NUMERIC(idx)) this.error("type-mismatch", "Array index must be a number", node.index.span);
+        return obj.kind === "array" ? obj.element : T.unknown;
+      }
+      case "Unary":
+        return this.inferUnary(node);
+      case "Binary":
+        return this.inferBinary(node);
+      case "Logical":
+        this.infer(node.left);
+        this.infer(node.right);
+        return T.boolean;
+      case "Membership":
+        return this.inferMembership(node);
+      case "Conditional":
+        return this.inferConditional(node);
+      case "Call":
+        return this.inferCall(node);
+    }
+  }
+  inferArray(node) {
+    if (node.elements.length === 0) return T.array(T.unknown);
+    const types = node.elements.map((el) => this.infer(el));
+    const first = types[0];
+    const uniform = types.every((t) => typesEqual(t, first));
+    return T.array(uniform ? first : T.unknown);
+  }
+  inferRef(path, span) {
+    const t = this.env.resolve(path);
+    if (t === void 0) {
+      this.error("unknown-identifier", `Unknown reference: ${path}`, span);
+      return T.unknown;
+    }
+    return t;
+  }
+  inferMember(node) {
+    const path = staticPath2(node);
+    if (path !== null) return this.inferRef(path, node.span);
+    this.infer(node.object);
+    return T.unknown;
+  }
+  inferUnary(node) {
+    const t = this.infer(node.operand);
+    if (node.op === "not") return T.boolean;
+    if (!NUMERIC(t)) this.error("type-mismatch", `Cannot negate ${formatType(t)}`, node.span);
+    return T.number;
+  }
+  inferBinary(node) {
+    const l = this.infer(node.left);
+    const r = this.infer(node.right);
+    const op = node.op;
+    if (op === "==" || op === "!=") return T.boolean;
+    if (op === "<" || op === "<=" || op === ">" || op === ">=") {
+      const ok = NUMERIC(l) && NUMERIC(r) || STRINGY(l) && STRINGY(r);
+      if (!ok) this.error("type-mismatch", `Cannot compare ${formatType(l)} and ${formatType(r)}`, node.span);
+      return T.boolean;
+    }
+    if (op === "+") {
+      if (NUMERIC(l) && NUMERIC(r)) return T.number;
+      if (l.kind === "string" || r.kind === "string") return T.string;
+      if (l.kind === "unknown" || r.kind === "unknown") return T.unknown;
+      this.error("type-mismatch", `Cannot add ${formatType(l)} and ${formatType(r)}`, node.span);
+      return T.unknown;
+    }
+    if (!NUMERIC(l) || !NUMERIC(r)) {
+      this.error("type-mismatch", `Operator '${op}' requires numbers, got ${formatType(l)} and ${formatType(r)}`, node.span);
+    }
+    return T.number;
+  }
+  inferMembership(node) {
+    this.infer(node.element);
+    const coll = this.infer(node.collection);
+    if (coll.kind !== "array" && coll.kind !== "string" && coll.kind !== "unknown") {
+      this.error("type-mismatch", `'in' requires an array or string, got ${formatType(coll)}`, node.collection.span);
+    }
+    return T.boolean;
+  }
+  inferConditional(node) {
+    this.infer(node.test);
+    const a = this.infer(node.consequent);
+    const b = this.infer(node.alternate);
+    return typesEqual(a, b) ? a : T.unknown;
+  }
+  inferCall(node) {
+    const sig = this.env.registry.get(node.callee);
+    if (!sig) {
+      this.error("unknown-function", `Unknown function: ${node.callee}`, node.span);
+      node.args.forEach((a) => this.infer(a));
+      return T.unknown;
+    }
+    const argTypes = node.args.map((a) => this.infer(a));
+    const required = sig.params.filter((p) => !p.optional).length;
+    const max = sig.variadic ? Infinity : sig.params.length;
+    if (argTypes.length < required || argTypes.length > max) {
+      this.error("arity", `${node.callee} expects ${arityText(required, max)}, got ${argTypes.length}`, node.span);
+    }
+    argTypes.forEach((at, i) => {
+      const param = sig.params[Math.min(i, sig.params.length - 1)];
+      if (param && !assignable(param.type, at)) {
+        this.error("type-mismatch", `${node.callee}: argument ${i + 1} expects ${formatType(param.type)}, got ${formatType(at)}`, node.args[i].span);
+      }
+    });
+    return resolveReturn(sig.returns, argTypes);
+  }
+};
+function arityText(required, max) {
+  if (max === Infinity) return `at least ${required} argument(s)`;
+  if (required === max) return `${required} argument(s)`;
+  return `${required} to ${max} argument(s)`;
+}
+function resolveReturn(spec, argTypes) {
+  if (spec.kind === "fixed") return spec.type;
+  if (spec.kind === "elementOf") {
+    const t = argTypes[spec.arg];
+    return t && t.kind === "array" ? t.element : T.unknown;
+  }
+  const known = argTypes.filter((t) => t.kind !== "null" && t.kind !== "unknown");
+  const first = known[0];
+  if (first && known.every((t) => typesEqual(t, first))) return first;
+  return T.unknown;
+}
+function createTypeEnv(paths, registry = buildRegistry()) {
+  const map = new Map(Object.entries(paths));
+  return { resolve: (p) => map.get(p), registry };
+}
+function checkAst(ast, env) {
+  const checker = new Checker(env);
+  const type = checker.infer(ast);
+  return { type, diagnostics: checker.diagnostics };
+}
+function check(source, env) {
+  const { ast, errors } = parse(source);
+  if (!ast) return { type: T.unknown, diagnostics: errors };
+  return checkAst(ast, env);
+}
+function checkBooleanGate(source, env) {
+  const result = check(source, env);
+  if (result.diagnostics.length === 0 && result.type.kind !== "boolean" && result.type.kind !== "unknown") {
+    const { ast } = parse(source);
+    const span = ast ? ast.span : { start: { offset: 0, line: 1, column: 1 }, end: { offset: 0, line: 1, column: 1 } };
+    return {
+      type: result.type,
+      diagnostics: [{ severity: "error", code: "non-boolean-gate", message: `A gate must be boolean, got ${formatType(result.type)}`, span }]
+    };
+  }
+  return result;
+}
+export {
+  BINARY_OPERATORS,
+  BINARY_OPERATOR_TOKENS,
+  BUILTIN_IMPLS,
+  DEFAULT_SIGNATURES,
+  Decimal,
+  DivisionByZeroError,
+  EvaluationError,
+  FORBIDDEN_OPERATORS,
+  KEYWORDS,
+  KEYWORD_SET,
+  LexError,
+  NULL,
+  T,
+  UNARY_OPERATORS,
+  Values,
+  buildRegistry,
+  check,
+  checkAst,
+  checkBooleanGate,
+  createContext,
+  createTypeEnv,
+  evaluate,
+  evaluateBoolean,
+  evaluateExpression,
+  extractReferences,
+  formatType,
+  parse,
+  parseOrThrow,
+  toValue,
+  tokenize,
+  truthy,
+  typesEqual,
+  valueEquals,
+  valueToString
+};