lemmascript 0.5.18 → 0.5.19

package/tools/dist/dafny-emit.js

@@ -1,14 +1,14 @@
 /**
  * Dafny emitter — IR → Dafny text.
  */
-import { usesName, usesNameInDecl } from "./ir.js";
-import { freshName, userNames } from "./names.js";
+import { exactIntegerLiteral, usesName, usesNameInDecl, usesNameInStmts } from "./ir.js";
+import { freshNameWhere, userNames } from "./names.js";
 import { renameFreeVar } from "./transform.js";
 /** Fresh binder for a comprehension wrapping the given subexpressions: `base`
  *  verbatim unless one of them references it, then primed until free. A *local*
  *  check — a same-named name elsewhere in the module keeps the plain binder. */
 function freshBinder(base, ...wrapped) {
-    return freshName(base, name => wrapped.some(w => usesName(w, name)));
+    return freshNameWhere(base, name => wrapped.some(w => usesName(w, name)));
 }
 /** Binder + body for lowering a single-return lambda to a comprehension whose
  *  receiver is emitted inside the binder's scope. TS scoping keeps the receiver
@@ -128,6 +128,13 @@ function resetDafnyNameCache() {
             _takenDafnyNames.add(emitted);
         }
 }
+/** Source-name → emitted-Dafny-name pairs from the most recent emitDafnyFile
+ *  call (identity-mapped names included). Consumed by `lsc info --typed` so
+ *  satellites (e.g. lemmascript-crosscheck) can address emitted declarations
+ *  by their mangled names (`_Box` → `i_Box'`) without re-deriving the rules. */
+export function emittedNameMap() {
+    return new Map([..._generatedDafnyNames, ..._userDafnyNames]);
+}
 function escapeName(name) {
     // \result is carried through the IR as var "\\result"; render it as the
     // current method's out-parameter name (chosen locally by methodHeader).
@@ -171,7 +178,7 @@ function methodHeader(prefix, params, returnType, scope) {
     // name is recorded so `\result` references resolve to it.
     const taken = (n) => params.some(p => escapeName(p.name) === n) ||
         (scope !== undefined && usesNameInDecl(scope.requires, scope.ensures, scope.body, n));
-    const resName = freshName("res", taken);
+    const resName = freshNameWhere("res", taken);
     _resultName = resName;
     return `${sig} returns (${resName}: ${tyToDafny(returnType)})`;
 }
@@ -183,9 +190,8 @@ const OP_MAP = {
 };
 function mapOp(op) { return OP_MAP[op] ?? op; }
 // ── Expression emission ─────────────────────────────────────
-/** Emit a match scrutinee — either a variable name (string) or an expression. */
 function emitScrutinee(s) {
-    return typeof s === "string" ? escapeName(s) : emitExpr(s);
+    return emitExpr(s);
 }
 /** Collapse nested forall/exists into a single quantifier with multiple bound vars. */
 function emitQuantifier(e, keyword) {
@@ -212,6 +218,8 @@ function emitExpr(e) {
     switch (e.kind) {
         case "var": return e.name === "undefined" ? "None" : escapeName(e.name);
         case "num": return `${e.value}`;
+        // Already canonical decimal; Dafny's `int` is mathematical, so no `n` suffix.
+        case "bigint": return e.value;
         case "bool": return e.value ? "true" : "false";
         case "str": return `"${e.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
         case "constructor": {
@@ -281,8 +289,43 @@ function emitExpr(e) {
                     }
                     return `${obj}[${args[0]}..${args[1]}]`;
                 }
-                if (e.method === "map")
-                    return `Std.Collections.Seq.Map(${args[0]}, ${obj})`;
+                if (e.method === "map") {
+                    // Always a seq comprehension: Seq.Map would hide the element access
+                    // behind a closure, defeating Dafny's termination checker for
+                    // recursive rebuild walkers. A literal lambda argument is
+                    // beta-reduced through a `var` binding — an applied closure defeats
+                    // the checker too; any other argument is applied to the element
+                    // directly. A non-variable receiver is bound once up front: the
+                    // comprehension mentions it three times, and splicing would make
+                    // any closure literal inside it (e.g. a Filter predicate) three
+                    // distinct closures, unprovably equal through an opaque callee.
+                    // Name freshness is a local IR-level check until a backend name
+                    // allocator exists.
+                    const lam = e.args[0];
+                    const fresh = (base, taken) => {
+                        let name = base;
+                        for (let n = 2; taken(name); n++)
+                            name = `${base}${n}`;
+                        return name;
+                    };
+                    const taken = (n) => usesName(e.obj, n) || usesName(lam, n) ||
+                        (lam.kind === "lambda" && (lam.params.some(pp => pp.name === n) ||
+                            usesNameInStmts(lam.body, n)));
+                    const bind = e.obj.kind !== "var";
+                    const s = bind ? fresh("s_map", taken) : obj;
+                    const idx = fresh("i_map", n => taken(n) || n === s);
+                    let core;
+                    if (lam.kind === "lambda" && lam.params.length === 1 &&
+                        lam.body.length === 1 && lam.body[0].kind === "return") {
+                        const p = escapeName(lam.params[0].name);
+                        core = `var ${p} := ${s}[${idx}]; ${emitExpr(lam.body[0].value)}`;
+                    }
+                    else {
+                        core = `(${args[0]})(${s}[${idx}])`;
+                    }
+                    const comp = `seq(|${s}|, ${idx} requires 0 <= ${idx} < |${s}| => ${core})`;
+                    return bind ? `(var ${s} := ${obj}; ${comp})` : comp;
+                }
                 if (e.method === "filter")
                     return `Std.Collections.Seq.Filter(${args[0]}, ${obj})`;
                 // filterMap (synthesized in resolve): drop Nones and unwrap to seq<T>.
@@ -293,6 +336,11 @@ function emitExpr(e) {
                 }
                 if (e.method === "every")
                     return `Std.Collections.Seq.All(${obj}, ${args[0]})`;
+                if (e.method === "find") {
+                    needPreamble("OptionType");
+                    needPreamble("SeqFind");
+                    return `SeqFind(${obj}, ${args[0]})`;
+                }
                 if (e.method === "findLast") {
                     needPreamble("OptionType");
                     needPreamble("SeqFindLast");
@@ -348,10 +396,14 @@ function emitExpr(e) {
                     return `StringSplit(${obj}, ${args[0]})`;
                 }
                 if (e.method === "slice") {
-                    // JS negative index: arr.slice(0, -N) → arr[0..|arr|-N]. After
-                    // transform, unary minus on a numeric literal is folded to a
-                    // negative `num` IR node, so check for that here.
-                    const negVal = (a) => a.kind === "num" && a.value < 0 ? -a.value : null;
+                    // JS negative index: arr.slice(0, -N) → arr[0..|arr|-N]. Transform
+                    // folds unary minus on a numeric literal into a negative `num` node,
+                    // but leaves a negated bigint structural — `exactIntegerLiteral`
+                    // recognizes both.
+                    const negVal = (a) => {
+                        const v = exactIntegerLiteral(a);
+                        return v !== null && v < 0n ? (-v).toString(10) : null;
+                    };
                     const loN = negVal(e.args[0]);
                     const loEx = loN !== null ? `|${obj}|-${loN}` : args[0];
                     if (args.length === 1)
@@ -453,6 +505,8 @@ function emitExpr(e) {
                 return `!(${emitExpr(e.expr)})`;
             if (e.op === "-" && e.expr.kind === "num")
                 return `(-(${e.expr.value}))`;
+            if (e.op === "-" && e.expr.kind === "bigint")
+                return `(-(${e.expr.value}))`;
             if (e.op === "-")
                 return `(-(${emitExpr(e.expr)}))`;
             return `${op}(${emitExpr(e.expr)})`;
@@ -468,27 +522,23 @@ function emitExpr(e) {
             // Bitwise operators on int: translate to arithmetic
             // x >> n → x / 2^n (right shift)
             // x << n → x * 2^n (left shift)
-            if (e.op === ">>") {
-                if (e.right.kind === "num") {
-                    return `(${emitExpr(e.left)} / ${Math.pow(2, e.right.value)})`;
+            if (e.op === ">>" || e.op === "<<") {
+                const shift = exactIntegerLiteral(e.right);
+                // Cap the fold: a huge literal shift would inline an absurd numeral.
+                if (shift !== null && shift >= 0n && shift <= 1024n) {
+                    const factor = (1n << shift).toString(10);
+                    return `(${emitExpr(e.left)} ${e.op === ">>" ? "/" : "*"} ${factor})`;
                 }
                 needPreamble("Pow2");
-                return `(${emitExpr(e.left)} / Pow2(${emitExpr(e.right)}))`;
-            }
-            if (e.op === "<<") {
-                if (e.right.kind === "num") {
-                    return `(${emitExpr(e.left)} * ${Math.pow(2, e.right.value)})`;
-                }
-                needPreamble("Pow2");
-                return `(${emitExpr(e.left)} * Pow2(${emitExpr(e.right)}))`;
+                return `(${emitExpr(e.left)} ${e.op === ">>" ? "/" : "*"} Pow2(${emitExpr(e.right)}))`;
             }
             // x & mask → x % (mask + 1) for literal masks of form 2^n - 1, else BitAnd
             if (e.op === "&") {
-                if (e.right.kind === "num") {
-                    const mask = e.right.value;
-                    const modulus = mask + 1;
-                    if ((modulus & (modulus - 1)) === 0) {
-                        return `(${emitExpr(e.left)} % ${modulus})`;
+                const mask = exactIntegerLiteral(e.right);
+                if (mask !== null && mask >= 0n) {
+                    const modulus = mask + 1n;
+                    if ((modulus & (modulus - 1n)) === 0n) {
+                        return `(${emitExpr(e.left)} % ${modulus.toString(10)})`;
                     }
                 }
                 needPreamble("BitAnd");
@@ -556,6 +606,15 @@ function emitExpr(e) {
                 needPreamble("Perm");
             if (e.fn === "SetFromSeq")
                 needPreamble("SetFromSeq");
+            // A constructor application must spell the name the same way the
+            // datatype declaration does — `dafnyCtorName`, not `escapeName`, since
+            // tags come from source strings ("spec-pure") that escapeName leaves alone.
+            if (e.ctorOf) {
+                const ctor = dafnyCtorName(e.fn);
+                return _ambiguousCtors.has(e.fn)
+                    ? `${e.ctorOf}.${ctor}(${args.join(", ")})`
+                    : `${ctor}(${args.join(", ")})`;
+            }
             return `${escapeName(e.fn)}(${args.join(", ")})`;
         }
         case "field": {
@@ -568,6 +627,11 @@ function emitExpr(e) {
                 return `${obj}.Keys`;
             if (e.field === "toNat")
                 return obj;
+            if (e.ctor && e.fromUnion) {
+                const renamed = _ctorFieldRenames.get(`${e.fromUnion}.${e.ctor}.${e.field}`);
+                if (renamed)
+                    return `${obj}.${escapeName(renamed)}`;
+            }
             return `${obj}.${escapeName(e.field)}`;
         }
         case "toNat":
@@ -588,7 +652,10 @@ function emitExpr(e) {
                 if (e.fields.length === 0) {
                     return emitExpr(e.spread);
                 }
-                const updates = e.fields.map(f => `${escapeName(f.name)} := ${emitExpr(f.value)}`);
+                const updates = e.fields.map(f => {
+                    const renamed = e.ctor && e.ctorOf ? _ctorFieldRenames.get(`${e.ctorOf}.${e.ctor}.${f.name}`) : undefined;
+                    return `${escapeName(renamed ?? f.name)} := ${emitExpr(f.value)}`;
+                });
                 return `${emitExpr(e.spread)}.(${updates.join(", ")})`;
             }
             // Match constructor by field names — prefer exact match over first-field heuristic
@@ -792,9 +859,9 @@ function emitDecl(d) {
             const collides = new Set([...typesByField].filter(([, s]) => s.size > 1).map(([n]) => n));
             const ctors = d.constructors.map(c => {
                 if (c.fields.length === 0)
-                    return escapeName(c.name);
-                const fields = c.fields.map(f => collides.has(f.name) ? { ...f, name: `${f.name}_${c.name}` } : f);
-                return `${escapeName(c.name)}(${paramList(fields)})`;
+                    return dafnyCtorName(c.name);
+                const fields = c.fields.map(f => collides.has(f.name) ? { ...f, name: `${f.name}_${c.name.replace(/[^A-Za-z0-9_'?]/g, "_")}` } : f);
+                return `${dafnyCtorName(c.name)}(${paramList(fields)})`;
             });
             return `datatype ${escapeName(d.name)}${tp} = ${ctors.join(" | ")}`;
         }
@@ -1036,6 +1103,19 @@ const SEQ_FIND_LAST_INDEX = `function SeqFindLastIndex<T>(s: seq<T>, p: T -> boo
   else if p(s[|s|-1]) then |s| - 1
   else SeqFindLastIndex(s[..|s|-1], p)
 }`;
+const SEQ_FIND = `function SeqFind<T>(s: seq<T>, p: T -> bool): Option<T>
+  ensures SeqFind(s, p).Some? ==> p(SeqFind(s, p).value)
+  ensures SeqFind(s, p).Some? ==> SeqFind(s, p).value in s
+  ensures SeqFind(s, p).Some? ==>
+    exists i: nat :: i < |s| && s[i] == SeqFind(s, p).value && p(s[i]) &&
+                     (forall j: nat :: j < i ==> !p(s[j]))
+  ensures SeqFind(s, p).None? ==> forall i :: 0 <= i < |s| ==> !p(s[i])
+  decreases |s|
+{
+  if |s| == 0 then None
+  else if p(s[0]) then Some(s[0])
+  else SeqFind(s[1..], p)
+}`;
 const SEQ_FIND_LAST = `function SeqFindLast<T>(s: seq<T>, p: T -> bool): Option<T>
   ensures SeqFindLast(s, p).Some? ==> p(SeqFindLast(s, p).value)
   ensures SeqFindLast(s, p).Some? ==> SeqFindLast(s, p).value in s
@@ -1294,6 +1374,7 @@ const PREAMBLE_CODE = [
     ["SeqFindIndex", SEQ_FIND_INDEX],
     ["SeqFindLastIndex", SEQ_FIND_LAST_INDEX],
     ["SeqFilterSome", SEQ_FILTER_SOME],
+    ["SeqFind", SEQ_FIND],
     ["SeqFindLast", SEQ_FIND_LAST],
     ["SeqFlatten", SEQ_FLATTEN],
     ["SeqJoin", SEQ_JOIN],
@@ -1319,10 +1400,18 @@ const PREAMBLE_CODE = [
 let _recordCtors = new Map();
 let _structureDecls = new Map();
 let _declaredTypes = new Set();
+let _ambiguousCtors = new Set();
+// `"<union>.<ctor>.<field>"` → per-constructor destructor name, for fields the
+// inductive emission renames (shared name, differing types). Field reads and
+// datatype updates with a pinned ctor must use the renamed destructor.
+let _ctorFieldRenames = new Map();
 function buildRecordCtorMap(decls) {
     _recordCtors = new Map();
     _structureDecls = new Map();
     _declaredTypes = new Set();
+    _ambiguousCtors = new Set();
+    _ctorFieldRenames = new Map();
+    const ctorSeen = new Set();
     function collectDecl(d) {
         if (d.kind === "structure") {
             _declaredTypes.add(d.name);
@@ -1330,8 +1419,36 @@ function buildRecordCtorMap(decls) {
             if (d.fields.length > 0)
                 _recordCtors.set(d.fields[0].name, d.name);
         }
-        if (d.kind === "inductive")
+        if (d.kind === "inductive") {
             _declaredTypes.add(d.name);
+            // Constructor names shared by two datatypes in this module (Expr.let vs
+            // Stmt.let) can't be used bare — emitters must qualify them.
+            for (const c of d.constructors) {
+                if (ctorSeen.has(c.name))
+                    _ambiguousCtors.add(c.name);
+                ctorSeen.add(c.name);
+            }
+            // Mirror the destructor renaming the inductive case of emitDecl performs
+            // (shared field name, differing types → per-constructor names), so reads
+            // and updates can be translated to the renamed destructors.
+            const typesByField = new Map();
+            for (const c of d.constructors)
+                for (const f of c.fields) {
+                    let s = typesByField.get(f.name);
+                    if (!s) {
+                        s = new Set();
+                        typesByField.set(f.name, s);
+                    }
+                    s.add(tyToDafny(f.type));
+                }
+            const collides = new Set([...typesByField].filter(([, s]) => s.size > 1).map(([n]) => n));
+            for (const c of d.constructors)
+                for (const f of c.fields) {
+                    if (!collides.has(f.name))
+                        continue;
+                    _ctorFieldRenames.set(`${d.name}.${c.name}.${f.name}`, `${f.name}_${c.name.replace(/[^A-Za-z0-9_'?]/g, "_")}`);
+                }
+        }
         if (d.kind === "type-alias")
             _declaredTypes.add(d.name);
         if (d.kind === "def")
@@ -1359,9 +1476,19 @@ function resolveTy(ty) {
         return { kind: "set", elem: resolveTy(ty.elem) };
     return ty;
 }
+/** Constructor names come from source strings (string-union values like
+ *  "spec-pure", discriminated-union tags), which may contain characters no
+ *  TS identifier has; map those to `_` before the ordinary escaping. A
+ *  collision after mapping fails loudly in Dafny (duplicate constructor)
+ *  rather than silently merging. */
+function dafnyCtorName(name) {
+    return escapeName(name.replace(/[^A-Za-z0-9_'?]/g, "_"));
+}
 function qualifyCtor(name, type) {
     const rawName = name.replace(/^\./, "");
-    const mapped = CTOR_MAP[rawName] ?? escapeName(rawName);
+    // hasOwn: a ctor literally named "constructor" (the IR's own Expr variant)
+    // must not hit Object.prototype.constructor through the bare index.
+    const mapped = (Object.hasOwn(CTOR_MAP, rawName) ? CTOR_MAP[rawName] : undefined) ?? dafnyCtorName(rawName);
     if (type)
         return `${type}.${mapped}`;
     return mapped;
@@ -1375,7 +1502,7 @@ const CTOR_MAP = { "some": "Some", "none": "None" };
 function translatePattern(p) {
     if (p.kind === "wild")
         return "_";
-    const ctorName = CTOR_MAP[p.ctor] ?? escapeName(p.ctor);
+    const ctorName = (Object.hasOwn(CTOR_MAP, p.ctor) ? CTOR_MAP[p.ctor] : undefined) ?? dafnyCtorName(p.ctor);
     if (p.binders.length === 0)
         return ctorName;
     return `${ctorName}(${p.binders.map(escapeName).join(", ")})`;

package/tools/dist/extract.js

@@ -6,6 +6,7 @@
  */
 import { Project, Node, SyntaxKind, ScriptTarget, ts } from "ts-morph";
 import { initTypeParser } from "./types.js";
+import { normalizeBigIntLiteral } from "./rawir.js";
 import { setUserNames, freshName } from "./names.js";
 // ── Expression extraction ────────────────────────────────────
 /** When set, calls whose function/method name matches this key are replaced with havoc. */
@@ -15,6 +16,14 @@ let _havocKey = null;
  *  different `.ts` source file. Emitted in Dafny as `function {:axiom} <flat>`.
  *  Cleared at the start of every `extractModule`. */
 const _externs = new Map();
+/** Signature types of *kept* externs, for the imported-type resolver: a type
+ *  reachable ONLY through an imported function's signature (e.g. an extern
+ *  returning PresentFact that no local signature mentions) must still be
+ *  resolved into a full decl, or it synthesizes opaque. Filled only after the
+ *  extern survives the `_externs` dedup — a cross-file signature superseded by a
+ *  same-file `//@ extern` contributes nothing to the output, so resolving its
+ *  types would emit decls that no emitted declaration mentions. */
+const _externSigTypes = [];
 let _currentSourceFile = null;
 /** True only while extracting a function body. Module-level constants that
  *  reference cross-file callees (e.g., `BusEvent.define(...)` inside a
@@ -30,10 +39,14 @@ let _destrCounter = 0;
  *  lifted `requires`/`ensures` see all the symbols they reference). Idempotent
  *  via the `_externs` dedup. */
 function registerExternIfCrossFile(callee, sourceFile) {
-    const ext = detectCrossFileExtern(callee, sourceFile);
+    const sigTypes = [];
+    const ext = detectCrossFileExtern(callee, sourceFile, sigTypes);
     if (!ext || _externs.has(ext.qualified))
         return;
     _externs.set(ext.qualified, ext);
+    // Only now that the extern is kept do its signature types become resolver
+    // seeds — see `_externSigTypes`.
+    _externSigTypes.push(...sigTypes);
     // Recurse: scan the source decl's body for nested cross-file calls so any
     // symbol referenced by the copied spec is itself declared in the output.
     let symbol = callee.getSymbol();
@@ -56,7 +69,7 @@ function registerExternIfCrossFile(callee, sourceFile) {
         }
     }
 }
-function detectCrossFileExtern(callee, sourceFile) {
+function detectCrossFileExtern(callee, sourceFile, sigTypesOut) {
     let symbol = callee.getSymbol();
     if (!symbol)
         return null;
@@ -92,12 +105,32 @@ function detectCrossFileExtern(callee, sourceFile) {
     // kept): a bare `TMsg`, not `import("/abs/path/transcript").TMsg` — the
     // importing module declares the datatype locally, so the axiom must use the
     // local name.
-    const externTypeText = (t) => t.getText(callee, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    // NoTruncation: a wide expansion (e.g. an alias for a large string-literal
+    // union, not importable at the call site) must print whole — a truncated
+    // union is unparseable and synthesizes an opaque decl named by its own text.
+    const externTypeText = (t) => t.getText(callee, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation);
     const params = sig.getParameters().map(p => ({
         name: p.getName(),
         tsType: externTypeText(p.getTypeAtLocation(callee)),
     }));
     const returnType = externTypeText(sig.getReturnType());
+    for (const p of sig.getParameters()) {
+        sigTypesOut.push({ type: p.getTypeAtLocation(callee), node: callee });
+    }
+    sigTypesOut.push({ type: sig.getReturnType(), node: callee });
+    // Also seed from the source declaration's syntactic type nodes: symbol-based
+    // types can drop the alias symbol (the printed signature then names an alias
+    // like `TypeDecls` that would otherwise synthesize opaque), while a type
+    // node's type keeps it.
+    const srcDecl = externalDecl;
+    for (const sp of srcDecl.getParameters?.() ?? []) {
+        const tn = sp.getTypeNode?.();
+        if (tn)
+            sigTypesOut.push({ type: tn.getType(), node: tn });
+    }
+    const rtn = srcDecl.getReturnTypeNode?.();
+    if (rtn)
+        sigTypesOut.push({ type: rtn.getType(), node: rtn });
     let qualified;
     if (Node.isPropertyAccessExpression(callee)) {
         qualified = `${callee.getExpression().getText()}.${callee.getName()}`;
@@ -307,10 +340,11 @@ function extractExpr(node) {
     if (Node.isNumericLiteral(node)) {
         return { kind: "num", value: Number(node.getLiteralValue()) };
     }
-    // BigInt literal (e.g. 32n, 0xffffn) — integer, with bigint division semantics
+    // BigInt literal (e.g. 32n, 0xffffn) — exact integer, with bigint division
+    // semantics. Kept as a decimal string: `getLiteralValue()`/`Number()` would
+    // round anything past 2^53 (`9007199254740993n` → `9007199254740992`).
     if (Node.isBigIntLiteral(node)) {
-        const text = node.getText().replace(/n$/, '');
-        return { kind: "num", value: Number(text), big: true };
+        return { kind: "bigint", value: normalizeBigIntLiteral(node.getText()) };
     }
     // Template literal: `foo${x}bar` → "foo" + x + "bar"
     if (Node.isTemplateExpression(node)) {
@@ -462,10 +496,9 @@ function extractExpr(node) {
             const typeNode = p.getTypeNode();
             return { name: p.getName(), tsType: typeNode ? typeNode.getText() : undefined };
         });
-        // Capture an explicit return annotation (`(x): Out => …`) so resolve can type
-        // return-position record literals to their named type instead of a tuple.
-        const retNode = node.getReturnTypeNode();
-        const returnTsType = retNode ? typeToString(node.getReturnType()) : undefined;
+        // Return type from the checker — inferred when unannotated — so resolve can
+        // type return-position record literals and give the lambda a real fn type.
+        const returnTsType = typeToString(node.getReturnType());
         const body = node.getBody();
         if (Node.isExpression(body)) {
             return { kind: "lambda", params, body: extractExpr(body), returnTsType };
@@ -688,8 +721,14 @@ function extractTypeDecl(decl, extraDecls) {
                             continue;
                         let tsType = typeToString(prop.getTypeAtLocation(decl));
                         const propDecl = prop.getDeclarations()[0];
-                        if (propDecl && propDecl.hasQuestionToken?.() && !tsType.includes(" | undefined")) {
-                            tsType = `${tsType} | undefined`;
+                        tsType = declaredTypeTextIfBetter(propDecl, tsType);
+                        if (propDecl && propDecl.hasQuestionToken?.()) {
+                            // Normalize checker output that puts `undefined` first, then
+                            // ensure exactly one trailing `| undefined`.
+                            if (tsType.startsWith("undefined | "))
+                                tsType = `${tsType.slice("undefined | ".length)} | undefined`;
+                            else if (!tsType.includes(" | undefined"))
+                                tsType = `${tsType} | undefined`;
                         }
                         fields.push({ name: prop.getName(), tsType });
                     }
@@ -780,12 +819,18 @@ function extractRecord(name, type, locationNode, overrides, extraDecls) {
         }
         const propType = prop.getTypeAtLocation(locationNode);
         let tsType = typeToString(propType);
+        const propDecl = prop.getDeclarations()[0];
+        tsType = declaredTypeTextIfBetter(propDecl, tsType);
         // Optional property: `foo?: T` reports as `T` (ts-morph strips the
         // `| undefined` from a question-token type). Add it back so the field
         // resolves to `Optional<T>`.
-        const propDecl = prop.getDeclarations()[0];
-        if (propDecl && propDecl.hasQuestionToken?.() && !tsType.includes(" | undefined")) {
-            tsType = `${tsType} | undefined`;
+        if (propDecl && propDecl.hasQuestionToken?.()) {
+            // Normalize checker output that puts `undefined` first, then ensure
+            // exactly one trailing `| undefined`.
+            if (tsType.startsWith("undefined | "))
+                tsType = `${tsType.slice("undefined | ".length)} | undefined`;
+            else if (!tsType.includes(" | undefined"))
+                tsType = `${tsType} | undefined`;
         }
         // Inline anonymous object types: ts-morph names them __type.
         // Generate a synthetic named record and reference it by name instead.
@@ -832,6 +877,23 @@ function findDiscriminant(members) {
     }
     return null;
 }
+/** Recover a field's *declared* type text when the semantic printer degraded
+ *  to ts-morph's anonymous `__type` — a self-referential alias reached
+ *  through a `| null` union expands structurally and loses its name. The
+ *  syntactic node text preserves the alias spelling (`TExpr | null`). Only
+ *  plain reference text is used: inline object literals (containing `{`)
+ *  keep the `__type` marker so record synthesis can handle them. */
+function declaredTypeTextIfBetter(propDecl, tsType) {
+    if (!tsType.includes("__type") || !propDecl)
+        return tsType;
+    const tn = propDecl.getTypeNode?.();
+    if (!tn)
+        return tsType;
+    const text = tn.getText();
+    if (text.includes("__type") || text.includes("{"))
+        return tsType;
+    return text;
+}
 function typeToString(type) {
     if (type.isUndefined())
         return "undefined";
@@ -1031,6 +1093,7 @@ function renameRawExpr(e, from, to) {
     switch (e.kind) {
         case "var": return e.name === from ? { kind: "var", name: to } : e;
         case "num":
+        case "bigint":
         case "str":
         case "bool":
         case "result":
@@ -1870,6 +1933,7 @@ export function extractModule(sourceFile) {
     // `extractExpr` during call extraction (only symbols *actually used* end up
     // here), deduped by qualified name.
     _externs.clear();
+    _externSigTypes.length = 0;
     // Share the module's ts-morph Project with parseTsType (scratch source file
     // for type-string parsing). Done before declare-type parsing so any
     // parseTsType call downstream uses the same Project.
@@ -2431,13 +2495,12 @@ export function extractModule(sourceFile) {
     // Resolve imported types: extract types referenced in function signatures but not in this file
     const knownTypes = new Set(typeDecls.map(d => d.name));
     const builtins = new Set(["Map", "Set", "Array", "String", "Number", "Boolean", "Promise", "Date", "RegExp", "Error"]);
+    const visitedTypes = new Set();
     function resolveType(t, locationNode) {
-        // Unwrap arrays and generics to find user-defined types
-        if (t.isArray()) {
-            resolveType(t.getArrayElementTypeOrThrow(), locationNode);
-            return;
-        }
-        // Resolve type aliases (e.g. string unions imported from other files)
+        // Resolve type aliases (e.g. string unions imported from other files).
+        // BEFORE the visited guard: the same interned compilerType can arrive both
+        // with and without its alias symbol (getTypeAtLocation drops it), and an
+        // aliasless first visit must not suppress the alias extraction.
         const alias = t.getAliasSymbol();
         if (alias) {
             const aliasName = alias.getName();
@@ -2470,6 +2533,18 @@ export function extractModule(sourceFile) {
                 }
             }
         }
+        // Recursion guard: recursive unions (Expr → variant → body: Expr) are
+        // reachable now that anonymous variant fields are walked below. Keyed on
+        // the compiler's interned Type object — alias names are not enough,
+        // because getTypeAtLocation can drop the alias symbol.
+        if (visitedTypes.has(t.compilerType))
+            return;
+        visitedTypes.add(t.compilerType);
+        // Unwrap arrays and generics to find user-defined types
+        if (t.isArray()) {
+            resolveType(t.getArrayElementTypeOrThrow(), locationNode);
+            return;
+        }
         if (t.isUnion()) {
             for (const u of t.getUnionTypes())
                 resolveType(u, locationNode);
@@ -2492,6 +2567,15 @@ export function extractModule(sourceFile) {
                 }
             }
         }
+        else if (t.isObject() && (!name || name.startsWith("__")) && t.getCallSignatures().length === 0) {
+            // Anonymous object type — typically a variant of an imported
+            // discriminated union. There is no decl to extract, but its fields can
+            // reference named types (`arms: MatchArm[]`) that downstream passes
+            // need declared, so walk them.
+            for (const prop of t.getProperties()) {
+                resolveType(prop.getTypeAtLocation(locationNode), locationNode);
+            }
+        }
     }
     for (let i = 0; i < fnsToExtract.length; i++) {
         const f = fnsToExtract[i];
@@ -2507,6 +2591,9 @@ export function extractModule(sourceFile) {
             resolveType(p.getType(), p);
         }
     }
+    // Extern signature types: see _externSigTypes.
+    for (const r of _externSigTypes)
+        resolveType(r.type, r.node);
     // Resolve anonymous object return types into synthetic named types
     for (let i = 0; i < fnsToExtract.length; i++) {
         const f = fnsToExtract[i];