lemmascript 0.2.0 → 0.3.1

package/README.md

@@ -16,8 +16,9 @@ See the external case studies:
 - **[colorwheel-lemmascript](https://github.com/midspiral/colorwheel-lemmascript/)** — verified color palette generator with mood + harmony constraints. 31 Lean proofs + 18 behavioral properties, 115 Dafny lemmas (invariant preservation, commutativity, NoOp completeness).
 - **[clear-split-lemmascript](https://github.com/midspiral/clear-split-lemmascript/)** — greenfield verified expense splitting web app. Conservation theorem, invariant preservation, delta laws — all proven in both Lean (no sorry) and Dafny (56 lemmas).
 - **[node-casbin-lemmascript](https://github.com/midspiral/node-casbin-lemmascript/blob/lemmascript/README_LemmaScript.md)** — brownfield verification of [node-casbin](https://github.com/casbin/node-casbin). 5 functions verified, 217 existing tests pass. End-to-end correctness and order independence for all 4 effect modes in both Lean and Dafny (39 lemmas).
-- **[hono-lemmascript](https://github.com/midspiral/hono-lemmascript/blob/lemmascript/README_LemmaScript.md)** — brownfield verification of [hono](https://github.com/honojs/hono)'s security middleware. Two CVEs verified: IP restriction bypass ([CVE-2026-39409](https://github.com/honojs/hono/security/advisories/GHSA-3mpf-rcc7-5347)) and cookie name bypass ([CVE-2026-39410](https://github.com/honojs/hono/security/advisories/GHSA-r5rp-j6wh-rvv4)) — 51 Dafny lemmas. Cookie verification done in-place. Dafny only.
-- **[charmchat](https://github.com/CHARM-BDF/charmchat/tree/lemma)** — in-progress verification of some sub-components, in Dafny.
+- **[hono-lemmascript](https://github.com/midspiral/hono-lemmascript/blob/lemmascript/README_LemmaScript.md)** — brownfield verification of [hono](https://github.com/honojs/hono)'s security middleware. Two CVEs verified: IP restriction bypass ([CVE-2026-39409](https://github.com/honojs/hono/security/advisories/GHSA-3mpf-rcc7-5347)) and cookie name bypass ([CVE-2026-39410](https://github.com/honojs/hono/security/advisories/GHSA-r5rp-j6wh-rvv4)) — 51 Dafny lemmas. [Cookie verification done **in-place**](https://github.com/midspiral/hono-lemmascript/blob/lemmascript/src/utils/cookie.ts#L79). Dafny only.
+- **[charmchat](https://github.com/CHARM-BDF/charmchat/tree/lemma)** — brownfield verification of an AI agent orchestration backend. `isEmptyResult` (string emptiness predicate, 8 postconditions, <1s) and `topologicalSort` (Kahn's algorithm — memory safety, output bounds, completeness via acyclicity ranking witness, termination; 5 helper lemmas, 28 loop invariants). Dafny only.
+- **[xyflow-lemmascript](https://github.com/midspiral/xyflow-lemmascript/blob/lemmascript/README_LemmaScript.md)** — brownfield verification of [xyflow](https://github.com/xyflow/xyflow)'s core edge and geometry utilities. 9 functions verified: `addEdge` (dedup — never loses edges, adds at most one), `reconnectEdge` (replace — bounded length), `connectionExists`, `getEdgeCenter` (midpoint correctness), `clamp` (bounds), `rectToBox`/`boxToRect` (field arithmetic), `getBoundsOfBoxes` (enclosure), `getOverlappingArea` (non-negative), `areSetsEqual` (subset + same size). 14 Dafny proof obligations. Dafny only.
 
 ## Setup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "bin": {

package/tools/dist/dafny-commands.js

@@ -31,13 +31,14 @@ export function dafnyCheckDiff(genPath, dfyPath) {
     catch { /* diff not available */ }
     return true;
 }
-export function dafnyVerify(dfyPath, dir, timeLimit) {
+export function dafnyVerify(dfyPath, dir, timeLimit, extraFlags) {
     console.log("Running dafny verify...");
     try {
         const content = readFileSync(dfyPath, "utf-8");
-        const stdLibFlag = content.includes("import Std.") ? " --standard-libraries" : "";
+        const stdLibFlag = content.includes("Std.") ? " --standard-libraries" : "";
         const timeLimitFlag = timeLimit ? ` --verification-time-limit ${timeLimit}` : "";
-        execSync(`dafny verify${stdLibFlag}${timeLimitFlag} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
+        const extra = extraFlags ? ` ${extraFlags}` : "";
+        execSync(`dafny verify${stdLibFlag}${timeLimitFlag}${extra} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
         return true;
     }
     catch {

package/tools/dist/dafny-emit.js

@@ -14,7 +14,7 @@ function tyToDafny(ty) {
         case "map": return `map<${tyToDafny(ty.key)}, ${tyToDafny(ty.value)}>`;
         case "set": return `set<${tyToDafny(ty.elem)}>`;
         case "optional": {
-            needsOptionType = true;
+            needPreamble("OptionType");
             return `Option<${tyToDafny(ty.inner)}>`;
         }
         case "user": return ty.name;
@@ -51,12 +51,29 @@ function paramList(params) {
 const OP_MAP = {
     "=": "==", "≠": "!=", "≥": ">=", "≤": "<=",
     "∧": "&&", "∨": "||", "¬": "!",
+    "arrayConcat": "+",
 };
 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);
+}
+/** Collapse nested forall/exists into a single quantifier with multiple bound vars. */
+function emitQuantifier(e, keyword) {
+    const vars = [];
+    let body = e;
+    while (body.kind === e.kind) {
+        const dty = tyToDafny(body.type);
+        const ann = dty === "string" ? "" : `: ${dty}`;
+        vars.push(`${body.var}${ann}`);
+        body = body.body;
+    }
+    return `${keyword} ${vars.join(", ")} :: ${emitExpr(body)}`;
+}
 function emitExpr(e) {
     switch (e.kind) {
-        case "var": return escapeName(e.name);
+        case "var": return e.name === "undefined" ? "None" : escapeName(e.name);
         case "num": return `${e.value}`;
         case "bool": return e.value ? "true" : "false";
         case "str": return `"${e.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')}"`;
@@ -79,20 +96,18 @@ function emitExpr(e) {
                     return `(${args[0]} in ${obj})`;
                 if (e.method === "push")
                     return `(${obj} + [${args[0]}])`;
-                if (e.method === "slice")
+                if (e.method === "concat")
+                    return `(${obj} + [${args[0]}])`;
+                if (e.method === "slice" && args.length === 1)
                     return `${obj}[${args[0]}..]`;
-                if (e.method === "map") {
-                    needsStdCollections = true;
-                    return `Seq.Map(${args[0]}, ${obj})`;
-                }
-                if (e.method === "filter") {
-                    needsStdCollections = true;
-                    return `Seq.Filter(${args[0]}, ${obj})`;
-                }
-                if (e.method === "every") {
-                    needsStdCollections = true;
-                    return `Seq.All(${obj}, ${args[0]})`;
-                }
+                if (e.method === "slice" && args.length === 2)
+                    return `${obj}[${args[0]}..${args[1]}]`;
+                if (e.method === "map")
+                    return `Std.Collections.Seq.Map(${args[0]}, ${obj})`;
+                if (e.method === "filter")
+                    return `Std.Collections.Seq.Filter(${args[0]}, ${obj})`;
+                if (e.method === "every")
+                    return `Std.Collections.Seq.All(${obj}, ${args[0]})`;
                 if (e.method === "some" && e.args[0].kind === "lambda" &&
                     e.args[0].body.length === 1 && e.args[0].body[0].kind === "return") {
                     const lam = e.args[0];
@@ -107,25 +122,25 @@ function emitExpr(e) {
             // String methods
             if (ty === "string") {
                 if (e.method === "indexOf") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `StringIndexOf(${obj}, ${args[0]})`;
                 }
                 if (e.method === "slice")
                     return `${obj}[${args[0]}..${args[1]}]`;
                 if (e.method === "trim") {
-                    needsStringTrim = true;
+                    needPreamble("StringTrim");
                     return `StringTrim(${obj})`;
                 }
                 if (e.method === "toLowerCase") {
-                    needsStringToLower = true;
+                    needPreamble("StringToLower");
                     return `StringToLower(${obj})`;
                 }
                 if (e.method === "toUpperCase") {
-                    needsStringToUpper = true;
+                    needPreamble("StringToUpper");
                     return `StringToUpper(${obj})`;
                 }
                 if (e.method === "includes") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `(StringIndexOf(${obj}, ${args[0]}) >= 0)`;
                 }
                 if (e.method === "charCodeAt")
@@ -136,13 +151,15 @@ function emitExpr(e) {
                 if (e.method === "getDirect")
                     return `${obj}[${args[0]}]`;
                 if (e.method === "get") {
-                    needsOptionType = true;
+                    needPreamble("OptionType");
                     return `(if ${args[0]} in ${obj} then Some(${obj}[${args[0]}]) else None)`;
                 }
                 if (e.method === "set")
                     return `${obj}[${args[0]} := ${args[1]}]`;
                 if (e.method === "has")
                     return `(${args[0]} in ${obj})`;
+                if (e.method === "delete")
+                    return `(map k | k in ${obj} && k != ${args[0]} :: ${obj}[k])`;
             }
             // Set methods
             if (ty === "set") {
@@ -186,14 +203,14 @@ function emitExpr(e) {
                 if (e.right.kind === "num") {
                     return `(${emitExpr(e.left)} / ${Math.pow(2, e.right.value)})`;
                 }
-                needsPow2 = true;
+                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)})`;
                 }
-                needsPow2 = true;
+                needPreamble("Pow2");
                 return `(${emitExpr(e.left)} * Pow2(${emitExpr(e.right)}))`;
             }
             // x & mask → x % (mask + 1) for literal masks of form 2^n - 1, else BitAnd
@@ -205,7 +222,7 @@ function emitExpr(e) {
                         return `(${emitExpr(e.left)} % ${modulus})`;
                     }
                 }
-                needsBitAnd = true;
+                needPreamble("BitAnd");
                 return `BitAnd(${emitExpr(e.left)}, ${emitExpr(e.right)})`;
             }
             // int * real coercion: wrap int side with "as real"
@@ -227,18 +244,29 @@ function emitExpr(e) {
         case "app": {
             const args = e.args.map(emitExpr);
             if (e.fn === "SetToSeq") {
-                needsSetToSeq = true;
+                needPreamble("SetToSeq");
                 return `SetToSeq(${args.join(", ")})`;
             }
             if (e.fn === "BigInt" || e.fn === "Number")
                 return args[0]; // identity: both map to int
+            // Set literal: {a, b, c}
+            if (e.fn === "SetLiteral")
+                return `{${args.join(", ")}}`;
             if (e.fn === "JSFloorDiv")
-                needsJSFloorDiv = true;
+                needPreamble("JSFloorDiv");
             if (e.fn === "CeilReal")
-                needsCeilReal = true;
+                needPreamble("CeilReal");
             if (e.fn === "FloorReal")
-                needsFloorReal = true;
-            return `${e.fn}(${args.join(", ")})`;
+                needPreamble("FloorReal");
+            if (e.fn === "NatToString")
+                needPreamble("NatToString");
+            if (e.fn === "MathAbs")
+                needPreamble("MathAbs");
+            if (e.fn === "MathMin")
+                needPreamble("MathMin");
+            if (e.fn === "MathMax")
+                needPreamble("MathMax");
+            return `${escapeName(e.fn)}(${args.join(", ")})`;
         }
         case "field": {
             const obj = emitExpr(e.obj);
@@ -260,43 +288,51 @@ function emitExpr(e) {
                 const updates = e.fields.map(f => `${escapeName(f.name)} := ${emitExpr(f.value)}`);
                 return `${emitExpr(e.spread)}.(${updates.join(", ")})`;
             }
-            const ctorName = e.fields.length > 0 ? _recordCtors.get(e.fields[0].name) : undefined;
-            const vals = e.fields.map(f => emitExpr(f.value));
-            if (ctorName)
+            // Match constructor by field names — prefer exact match over first-field heuristic
+            let ctorName;
+            if (e.fields.length > 0) {
+                const fieldNames = new Set(e.fields.map(f => f.name));
+                for (const [name, fields] of _structureDecls) {
+                    if (fields.length >= e.fields.length && fields.every(f => fieldNames.has(f.name) || f.type.kind === "optional")) {
+                        ctorName = name;
+                        break;
+                    }
+                }
+                if (!ctorName)
+                    ctorName = _recordCtors.get(e.fields[0].name);
+            }
+            if (ctorName) {
+                const structFields = _structureDecls.get(ctorName);
+                if (structFields && e.fields.length < structFields.length) {
+                    // Pad missing fields: match by name, fill None for optional
+                    const provided = new Map(e.fields.map(f => [f.name, f]));
+                    const vals = structFields.map(sf => {
+                        const f = provided.get(sf.name);
+                        if (f)
+                            return emitExpr(f.value);
+                        if (sf.type.kind === "optional") {
+                            needPreamble("OptionType");
+                            return "None";
+                        }
+                        return `/* missing: ${sf.name} */`;
+                    });
+                    return `${ctorName}(${vals.join(", ")})`;
+                }
+                const vals = e.fields.map(f => emitExpr(f.value));
                 return `${ctorName}(${vals.join(", ")})`;
+            }
+            const vals = e.fields.map(f => emitExpr(f.value));
             return `(${vals.join(", ")})`;
         }
         case "if":
             return `if ${emitExpr(e.cond)} then ${emitExpr(e.then)} else ${emitExpr(e.else)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const arms = e.arms.map(a => `case ${translatePattern(a.pattern)} => ${emitExpr(a.body)}`);
             return `(match ${scrut} { ${arms.join(" ")} })`;
         }
-        case "forall": {
-            // Collapse nested foralls: forall x :: forall y :: P → forall x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "forall") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `forall ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
-        case "exists": {
-            // Collapse nested exists: exists x :: exists y :: P → exists x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "exists") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `exists ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
+        case "forall": return emitQuantifier(e, "forall");
+        case "exists": return emitQuantifier(e, "exists");
         case "let": return `var ${escapeName(e.name)} := ${emitExpr(e.value)}; ${emitExpr(e.body)}`;
         case "havoc": return "*";
     }
@@ -308,7 +344,7 @@ function emitPureExpr(e, indent) {
         case "if":
             return `${pad}if ${emitExpr(e.cond)} then\n${emitPureExpr(e.then, indent + 1)}\n${pad}else\n${emitPureExpr(e.else, indent + 1)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of e.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -331,7 +367,13 @@ function emitStmt(s, indent) {
     const pad = "  ".repeat(indent);
     switch (s.kind) {
         case "let":
-            if (s.value.kind === "havoc")
+            // Record literal assigned to map type → emit as map[k := v, ...]
+            if (s.type.kind === "map" && s.value.kind === "record" && !s.value.spread) {
+                const entries = s.value.fields.map(f => `${emitExpr({ kind: "str", value: f.name })} := ${emitExpr(f.value)}`);
+                return `${pad}var ${escapeName(s.name)}: ${tyToDafny(resolveTy(s.type))} := map[${entries.join(", ")}];`;
+            }
+            if (s.value.kind === "havoc" || s.value.kind === "emptyMap" || s.value.kind === "emptySet" ||
+                (s.value.kind === "arrayLiteral" && s.value.elems.length === 0))
                 return `${pad}var ${escapeName(s.name)}: ${tyToDafny(s.type)} := ${emitExpr(s.value)};`;
             return `${pad}var ${escapeName(s.name)} := ${emitExpr(s.value)};`;
         case "assign":
@@ -367,7 +409,7 @@ function emitStmt(s, indent) {
             return out;
         }
         case "match": {
-            const scrut = typeof s.scrutinee === "string" ? escapeName(s.scrutinee) : emitExpr(s.scrutinee);
+            const scrut = emitScrutinee(s.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of s.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -408,18 +450,23 @@ function emitStmt(s, indent) {
 function emitDecl(d) {
     switch (d.kind) {
         case "inductive": {
+            const tp = d.typeParams?.length ? `<${d.typeParams.join(", ")}>` : "";
             const ctors = d.constructors.map(c => {
                 if (c.fields.length === 0)
                     return escapeName(c.name);
                 return `${escapeName(c.name)}(${paramList(c.fields)})`;
             });
-            return `datatype ${d.name} = ${ctors.join(" | ")}`;
+            return `datatype ${d.name}${tp} = ${ctors.join(" | ")}`;
         }
         case "structure": {
             return `datatype ${d.name} = ${d.name}(${paramList(d.fields)})`;
         }
+        case "type-alias": {
+            return `type ${d.name} = ${tyToDafny(d.target)}`;
+        }
         case "def": {
-            const lines = [`function ${d.name}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
+            const tp = d.typeParams.length > 0 ? `<${d.typeParams.join(", ")}>` : "";
+            const lines = [`function ${d.name}${tp}(${paramList(d.params)}): ${tyToDafny(d.returnType)}`];
             for (const r of d.requires)
                 lines.push(`  requires ${emitExpr(r)}`);
             lines.push(`{`);
@@ -427,8 +474,10 @@ function emitDecl(d) {
             lines.push(`}`);
             // Companion lemma for ensures (proof target for LLM)
             if (d.ensures.length > 0) {
+                // Strip constraints like (==) from type params — ghost lemmas don't need them
+                const lemmaTP = d.typeParams.length > 0 ? `<${d.typeParams.map(t => t.replace(/\(.*\)/, '')).join(", ")}>` : "";
                 lines.push("");
-                lines.push(`lemma ${d.name}_ensures(${paramList(d.params)})`);
+                lines.push(`lemma ${d.name}_ensures${lemmaTP}(${paramList(d.params)})`);
                 for (const r of d.requires)
                     lines.push(`  requires ${emitExpr(r)}`);
                 for (const e of d.ensures)
@@ -439,7 +488,8 @@ function emitDecl(d) {
             return lines.join("\n");
         }
         case "method": {
-            const lines = [`method ${d.name}(${paramList(d.params)}) returns (res: ${tyToDafny(d.returnType)})`];
+            const tp = d.typeParams.length > 0 ? `<${d.typeParams.join(", ")}>` : "";
+            const lines = [`method ${d.name}${tp}(${paramList(d.params)}) returns (res: ${tyToDafny(d.returnType)})`];
             for (const r of d.requires)
                 lines.push(`  requires ${emitExpr(r)}`);
             for (const e of d.ensures)
@@ -480,18 +530,9 @@ function emitDecl(d) {
 }
 // ── File emission ───────────────────────────────────────────
 // ── Preamble helpers ────────────────────────────────────────
-let needsStringIndexOf = false;
-let needsStringTrim = false;
-let needsStringToLower = false;
-let needsStringToUpper = false;
-let needsJSFloorDiv = false;
-let needsCeilReal = false;
-let needsFloorReal = false;
-let needsStdCollections = false;
-let needsOptionType = false;
-let needsSetToSeq = false;
-let needsBitAnd = false;
-let needsPow2 = false;
+/** Preamble tracking — emitters add keys via `needPreamble(key)`, emitDafnyFile emits them. */
+const _neededPreambles = new Set();
+function needPreamble(key) { _neededPreambles.add(key); }
 const POW2 = `function Pow2(n: int): int
   requires n >= 0
   decreases n
@@ -579,25 +620,99 @@ const STRING_TO_UPPER = `function StringToUpper(s: string): string
     var upper := if 'a' <= c <= 'z' then (c - 'a' + 'A') as char else c;
     [upper] + StringToUpper(s[1..])
 }`;
+const MATH_MIN = `function MathMin(a: int, b: int): int { if a <= b then a else b }`;
+const MATH_MAX = `function MathMax(a: int, b: int): int { if a >= b then a else b }`;
+const NAT_TO_STRING = `function NatToString(n: nat): string
+  decreases n
+{
+  var digit := ('0' as int + n % 10) as char;
+  if n < 10 then [digit]
+  else NatToString(n / 10) + [digit]
+}`;
+const MATH_ABS = `function MathAbs(x: int): nat { if x >= 0 then x else -x }`;
+const SET_TO_SEQ = `method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
+  ensures forall x :: x in s <==> x in res
+  ensures |res| == |s|
+{
+  var remaining := s;
+  res := [];
+  while remaining != {}
+    invariant remaining <= s
+    invariant forall x :: x in res <==> (x in s && x !in remaining)
+    invariant |res| + |remaining| == |s|
+    decreases remaining
+  {
+    var x :| x in remaining;
+    res := res + [x];
+    remaining := remaining - {x};
+  }
+}`;
+/** Preamble code keyed by name. Emitted in this order when needed. */
+const PREAMBLE_CODE = [
+    ["OptionType", "datatype Option<T> = None | Some(value: T)"],
+    ["SetToSeq", SET_TO_SEQ],
+    ["Pow2", POW2],
+    ["BitAnd", BIT_AND],
+    ["JSFloorDiv", JS_FLOOR_DIV],
+    ["CeilReal", CEIL_REAL],
+    ["FloorReal", FLOOR_REAL],
+    ["StringIndexOf", STRING_INDEX_OF],
+    ["StringTrim", STRING_TRIM],
+    ["StringToLower", STRING_TO_LOWER],
+    ["StringToUpper", STRING_TO_UPPER],
+    ["NatToString", NAT_TO_STRING],
+    ["MathAbs", MATH_ABS],
+    ["MathMin", MATH_MIN],
+    ["MathMax", MATH_MAX],
+];
 // ── Constructor and record helpers ───────────────────────────
 let _recordCtors = new Map();
+let _structureDecls = new Map();
+let _declaredTypes = new Set();
 function buildRecordCtorMap(decls) {
     _recordCtors = new Map();
-    for (const d of decls) {
-        if (d.kind === "structure" && d.fields.length > 0)
-            _recordCtors.set(d.fields[0].name, d.name);
+    _structureDecls = new Map();
+    _declaredTypes = new Set();
+    function collectDecl(d) {
+        if (d.kind === "structure") {
+            _declaredTypes.add(d.name);
+            _structureDecls.set(d.name, d.fields);
+            if (d.fields.length > 0)
+                _recordCtors.set(d.fields[0].name, d.name);
+        }
+        if (d.kind === "inductive")
+            _declaredTypes.add(d.name);
+        if (d.kind === "type-alias")
+            _declaredTypes.add(d.name);
+        if (d.kind === "def")
+            _declaredTypes.add(d.name);
         if (d.kind === "namespace")
-            for (const inner of d.decls) {
-                if (inner.kind === "structure" && inner.fields.length > 0)
-                    _recordCtors.set(inner.fields[0].name, inner.name);
-            }
+            for (const inner of d.decls)
+                collectDecl(inner);
     }
+    for (const d of decls)
+        collectDecl(d);
+}
+/** Resolve a Ty to a Dafny-safe type, falling back to string for undeclared user types. */
+function resolveTy(ty) {
+    if (ty.kind === "user" && !_declaredTypes.has(ty.name))
+        return { kind: "string" };
+    if (ty.kind === "optional")
+        return { kind: "optional", inner: resolveTy(ty.inner) };
+    if (ty.kind === "array")
+        return { kind: "array", elem: resolveTy(ty.elem) };
+    if (ty.kind === "map")
+        return { kind: "map", key: resolveTy(ty.key), value: resolveTy(ty.value) };
+    if (ty.kind === "set")
+        return { kind: "set", elem: resolveTy(ty.elem) };
+    return ty;
 }
 function qualifyCtor(name, type) {
     const rawName = name.replace(/^\./, "");
+    const mapped = CTOR_MAP[rawName] ?? escapeName(rawName);
     if (type)
-        return `${type}.${escapeName(rawName)}`;
-    return escapeName(rawName);
+        return `${type}.${mapped}`;
+    return mapped;
 }
 /** Translate a Lean match pattern to Dafny syntax.
  *  ".ctorName field1 field2" → "ctorName(field1, field2)"
@@ -618,23 +733,9 @@ function translatePattern(pattern) {
     const fieldNames = fields.split(/\s+/).map(escapeName);
     return `${ctorName}(${fieldNames.join(", ")})`;
 }
-const PREAMBLES = {
-    StringIndexOf: STRING_INDEX_OF,
-};
 export function emitDafnyFile(file, tsFileName) {
     buildRecordCtorMap(file.decls);
-    needsStringIndexOf = false;
-    needsStringTrim = false;
-    needsStringToLower = false;
-    needsStringToUpper = false;
-    needsJSFloorDiv = false;
-    needsCeilReal = false;
-    needsFloorReal = false;
-    needsStdCollections = false;
-    needsOptionType = false;
-    needsSetToSeq = false;
-    needsBitAnd = false;
-    needsPow2 = false;
+    _neededPreambles.clear();
     // Collect pure def names so we can skip their method wrappers
     const pureDefs = new Set();
     for (const d of file.decls) {
@@ -671,67 +772,11 @@ export function emitDafnyFile(file, tsFileName) {
     const lines = [];
     if (tsFileName)
         lines.push(`// Generated by lsc from ${tsFileName}`);
-    if (needsStdCollections)
-        lines.push("import Std.Collections.Seq");
-    if (needsOptionType) {
-        lines.push("");
-        lines.push("datatype Option<T> = None | Some(value: T)");
-    }
-    if (needsSetToSeq) {
-        lines.push("");
-        lines.push(`method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
-  ensures forall x :: x in s <==> x in res
-  ensures |res| == |s|
-{
-  var remaining := s;
-  res := [];
-  while remaining != {}
-    invariant remaining <= s
-    invariant forall x :: x in res <==> (x in s && x !in remaining)
-    invariant |res| + |remaining| == |s|
-    decreases remaining
-  {
-    var x :| x in remaining;
-    res := res + [x];
-    remaining := remaining - {x};
-  }
-}`);
-    }
-    if (needsPow2) {
-        lines.push("");
-        lines.push(POW2);
-    }
-    if (needsBitAnd) {
-        lines.push("");
-        lines.push(BIT_AND);
-    }
-    if (needsJSFloorDiv) {
-        lines.push("");
-        lines.push(JS_FLOOR_DIV);
-    }
-    if (needsCeilReal) {
-        lines.push("");
-        lines.push(CEIL_REAL);
-    }
-    if (needsFloorReal) {
-        lines.push("");
-        lines.push(FLOOR_REAL);
-    }
-    if (needsStringIndexOf) {
-        lines.push("");
-        lines.push(PREAMBLES.StringIndexOf);
-    }
-    if (needsStringTrim) {
-        lines.push("");
-        lines.push(STRING_TRIM);
-    }
-    if (needsStringToLower) {
-        lines.push("");
-        lines.push(STRING_TO_LOWER);
-    }
-    if (needsStringToUpper) {
-        lines.push("");
-        lines.push(STRING_TO_UPPER);
+    for (const [key, code] of PREAMBLE_CODE) {
+        if (_neededPreambles.has(key)) {
+            lines.push("");
+            lines.push(code);
+        }
     }
     lines.push(...declLines);
     return lines.join("\n") + "\n";