lemmascript 0.3.3 → 0.5.0

package/tools/dist/transform.js

@@ -21,10 +21,11 @@ function mapExpr(e, f) {
         case "num":
         case "bool":
         case "str":
-        case "constructor":
         case "emptyMap":
         case "emptySet":
         case "havoc": return e;
+        case "mapLiteral": return { ...e, entries: e.entries.map(en => ({ key: r(en.key), value: r(en.value) })) };
+        case "constructor": return e.args ? { ...e, args: e.args.map(r) } : e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
         case "implies": return { ...e, premises: e.premises.map(r), conclusion: r(e.conclusion) };
@@ -80,7 +81,6 @@ function mapTExpr(e, f) {
         case "num":
         case "str":
         case "bool":
-        case "result":
         case "havoc": return e;
         case "binop": return { ...e, left: r(e.left), right: r(e.right) };
         case "unop": return { ...e, expr: r(e.expr) };
@@ -90,6 +90,15 @@ function mapTExpr(e, f) {
         case "record": return { ...e, spread: e.spread ? r(e.spread) : null, fields: e.fields.map(fi => ({ ...fi, value: r(fi.value) })) };
         case "arrayLiteral": return { ...e, elems: e.elems.map(r) };
         case "conditional": return { ...e, cond: r(e.cond), then: r(e.then), else: r(e.else) };
+        case "optChain": return { ...e, obj: r(e.obj),
+            chain: e.chain.map(s => s.kind === "call" ? { ...s, args: s.args.map(r) }
+                : s.kind === "index" ? { ...s, idx: r(s.idx) }
+                    : s) };
+        case "nullish": return { ...e, left: r(e.left), right: r(e.right) };
+        case "someMatch": return { ...e, scrutinee: r(e.scrutinee), someBody: r(e.someBody), noneBody: r(e.noneBody) };
+        case "tagMatch": return { ...e, scrutinee: r(e.scrutinee),
+            cases: e.cases.map(c => ({ ...c, body: r(c.body) })),
+            fallthrough: e.fallthrough ? r(e.fallthrough) : null };
         case "forall": return { ...e, body: r(e.body) };
         case "exists": return { ...e, body: r(e.body) };
         case "lambda": return e;
@@ -113,6 +122,10 @@ function mapTStmt(s, f) {
         case "ghostLet": return { ...s, init: r(s.init) };
         case "ghostAssign": return { ...s, value: r(s.value) };
         case "assert": return { ...s, expr: r(s.expr) };
+        case "someMatch": return { ...s, scrutinee: r(s.scrutinee), someBody: s.someBody.map(t => mapTStmt(t, f)), noneBody: s.noneBody.map(t => mapTStmt(t, f)) };
+        case "tagMatch": return { ...s, scrutinee: r(s.scrutinee),
+            cases: s.cases.map(c => ({ ...c, body: c.body.map(t => mapTStmt(t, f)) })),
+            fallthrough: s.fallthrough.map(t => mapTStmt(t, f)) };
     }
 }
 export const LEAN_OPTIONS = {
@@ -174,6 +187,40 @@ const BOOL_OP_MAP = {
     ...OP_MAP, "===": "==", "!==": "!=",
 };
 function transformExpr(e) { return lowerExpr(e, null); }
+/** Reduce an if/let/return-shaped statement body to a single expression, for
+ *  expression-only lambda bodies. Returns null for shapes that can't be a pure
+ *  expression (loops, assignments, bare side effects), so callers leave the
+ *  body as statements. A `return` is terminal — statements after it are
+ *  unreachable and dropped.
+ *    [return e]                          → e
+ *    [let x = e, …rest]                  → Expr.let(x, e, flatten(rest))
+ *    [if (c) thenStmts elseStmts, …rest] → Expr.if(c, …) where each branch
+ *        absorbs `rest` if it doesn't already terminate with a return. */
+function flattenLambdaBody(stmts) {
+    if (stmts.length === 0)
+        return null;
+    const first = stmts[0];
+    const rest = stmts.slice(1);
+    if (first.kind === "return")
+        return first.value;
+    if (first.kind === "let" && !first.mutable) {
+        const body = flattenLambdaBody(rest);
+        return body === null ? null : { kind: "let", name: first.name, value: first.value, body };
+    }
+    if (first.kind === "if") {
+        const thenTerminates = flattenLambdaBody(first.then);
+        if (thenTerminates !== null) {
+            // then-branch yields a value (ends in return) → `rest` is the else path.
+            const elseExpr = flattenLambdaBody(first.else.length > 0 ? [...first.else, ...rest] : rest);
+            return elseExpr === null ? null : { kind: "if", cond: first.cond, then: thenTerminates, else: elseExpr };
+        }
+        // then-branch falls through → both branches continue into `rest`.
+        const thenExpr = flattenLambdaBody([...first.then, ...rest]);
+        const elseExpr = flattenLambdaBody(first.else.length > 0 ? [...first.else, ...rest] : rest);
+        return thenExpr === null || elseExpr === null ? null : { kind: "if", cond: first.cond, then: thenExpr, else: elseExpr };
+    }
+    return null;
+}
 /**
  * Lower a typed expression to Backend IR.
  *
@@ -183,28 +230,47 @@ function transformExpr(e) { return lowerExpr(e, null); }
  * a method call can appear inline in TS.  It does NOT propagate into
  * field, index, record, forall, or exists sub-expressions.
  */
+/** JS truthiness coercion for `if`/`while`/`?:` conditions.
+ *  Dafny requires bool; TS treats number/string/array as truthy when non-empty.
+ *  Optional conds are handled separately by narrow.ts (rewritten to someMatch). */
+function coerceCondToBool(cond, ty) {
+    if (ty.kind === "bool")
+        return cond;
+    if (ty.kind === "int" || ty.kind === "nat")
+        return { kind: "binop", op: ">", left: cond, right: { kind: "num", value: 0 } };
+    if (ty.kind === "string" || ty.kind === "array")
+        return { kind: "binop", op: ">", left: { kind: "field", obj: cond, field: "size" }, right: { kind: "num", value: 0 } };
+    return cond;
+}
 /** Wrap an expression in Some/None for optional-typed conditionals.
  *  If the raw TExpr is `undefined`, emit `.none`; otherwise wrap in `Some`. */
 function wrapOptionalBranch(expr, raw) {
-    return (raw.kind === "var" && raw.name === "undefined")
-        ? { kind: "constructor", name: ".none" }
-        : { kind: "app", fn: "Some", args: [expr] };
+    // Set type: "Option" so Lean emits `Option.some`/`Option.none` (qualified).
+    // The dotted form `.some`/`.none` would be ambiguous in expression positions
+    // like the scrutinee of an outer match. Dafny treats `Option.Some` and bare
+    // `Some` equivalently — the qualification is harmless there.
+    if (raw.kind === "var" && raw.name === "undefined")
+        return { kind: "constructor", name: "none", type: "Option" };
+    if (raw.ty.kind === "optional")
+        return expr; // already Option<T>, don't double-wrap
+    return { kind: "constructor", name: "some", type: "Option", args: [expr] };
 }
 function lowerExpr(e, binds) {
-    // Monadic lifting: extract embedded method calls to let-binds
-    // Pass binds through to args so nested method calls are also lifted
-    if (binds && e.kind === "call" && e.callKind === "method") {
+    // Monadic lifting: extract embedded method calls to let-binds.
+    // `callKind: "method"` means a global var-fn call (classifyCall returns
+    // "method" only for `fn.kind === "var"`). Receiver method calls have
+    // callKind "unknown" and fall through to the regular case below where
+    // they become `methodCall`.
+    if (binds && e.kind === "call" && e.callKind === "method" && e.fn.kind === "var") {
         const name = `_t${_liftCounter++}`;
-        const fn = e.fn.kind === "var" ? e.fn.name : `${lowerExpr(e.fn, binds)}`;
         const args = e.args.map(a => lowerExpr(a, binds));
-        binds.push({ kind: "let-bind", name, value: { kind: "app", fn, args } });
+        binds.push({ kind: "let-bind", name, value: { kind: "app", fn: e.fn.name, args } });
         return { kind: "var", name };
     }
     switch (e.kind) {
         case "var": return { kind: "var", name: e.name };
         case "num": return { kind: "num", value: e.value };
         case "bool": return { kind: "bool", value: e.value };
-        case "result": return { kind: "var", name: "res" };
         case "str":
             if (e.ty.kind === "user")
                 return { kind: "constructor", name: e.value, type: e.ty.name };
@@ -315,10 +381,27 @@ function lowerExpr(e, binds) {
                 (e.left.ty.kind === "user" && e.right.ty.kind === "string"))) {
                 const left = lowerExpr(e.left, binds);
                 const right = lowerExpr(e.right, binds);
+                // `s || undefined` produces `Option<string>` — wrap the truthy branch in Some.
+                const rightIsUndef = e.right.kind === "var" && e.right.name === "undefined";
                 return {
                     kind: "if",
                     cond: { kind: "binop", op: ">", left: { kind: "field", obj: left, field: "size" }, right: { kind: "num", value: 0 } },
-                    then: left, else: right,
+                    then: rightIsUndef ? { kind: "app", fn: "Some", args: [left] } : left,
+                    else: right,
+                };
+            }
+            // `bool || undefined` → `if bool then Some(bool) else None`. Used in
+            // optional-field initialization where the source assigns a truthy/false
+            // bool to a `T?` field. Without this, emit produces `bool || None`,
+            // which Dafny rejects (bool || Option<?> is ill-typed).
+            if (e.op === "||" && e.left.ty.kind === "bool" &&
+                e.right.kind === "var" && e.right.name === "undefined") {
+                const left = lowerExpr(e.left, binds);
+                return {
+                    kind: "if",
+                    cond: left,
+                    then: { kind: "app", fn: "Some", args: [left] },
+                    else: { kind: "var", name: "undefined" },
                 };
             }
             // int + string → NatToString(int) + string (string concatenation)
@@ -366,12 +449,35 @@ function lowerExpr(e, binds) {
         case "index": {
             const idx = transformExpr(e.idx);
             if (e.obj.ty.kind === "map") {
-                return { kind: "methodCall", obj: transformExpr(e.obj), objTy: e.obj.ty, method: "get", args: [idx], monadic: false };
+                // Mirrors the .get() → .getDirect switch at line ~453: when resolve has
+                // narrowed the index type to non-optional (via `k in m` atoms in scope),
+                // emit direct access; otherwise keep the Option-producing `get`.
+                const method = e.ty.kind !== "optional" ? "getDirect" : "get";
+                return { kind: "methodCall", obj: transformExpr(e.obj), objTy: e.obj.ty, method, args: [idx], monadic: false };
             }
             const wrappedIdx = isArray(e.obj.ty) && !isNat(e.idx.ty) ? { kind: "toNat", expr: idx } : idx;
             return { kind: "index", arr: transformExpr(e.obj), idx: wrappedIdx };
         }
         case "call": {
+            // Array.isArray(x) on a synth array-union (discriminant "__isArray__")
+            // → constructor predicate `x.ArrayBranch?`. Used in spec ensures and
+            // anywhere `Array.isArray` escapes the narrowing rule (narrow rewrites
+            // top-level if-cond Array.isArray uses; this catches the rest).
+            if (e.fn.kind === "field" && e.fn.obj.kind === "var" && e.fn.obj.name === "Array" &&
+                e.fn.field === "isArray" && e.args.length === 1) {
+                const arg = e.args[0];
+                if (arg.ty.kind === "user") {
+                    const baseName = arg.ty.name.includes("<") ? arg.ty.name.slice(0, arg.ty.name.indexOf("<")) : arg.ty.name;
+                    const decl = _typeDecls.find(d => d.name === baseName);
+                    if (decl?.kind === "discriminated-union" && decl.discriminant === "__isArray__") {
+                        return {
+                            kind: "binop", op: "=",
+                            left: lowerExpr(arg, binds),
+                            right: { kind: "constructor", name: "ArrayBranch", type: arg.ty.name },
+                        };
+                    }
+                }
+            }
             // Math.abs/min/max → preamble functions
             if (e.fn.kind === "field" && e.fn.obj.kind === "var" && e.fn.obj.name === "Math") {
                 if (e.fn.field === "abs" && e.args.length === 1)
@@ -408,6 +514,10 @@ function lowerExpr(e, binds) {
                         return { kind: "toNat", expr: lowered };
                     return lowered;
                 });
+                // arr.concat(otherArr): array argument → real concatenation, not push
+                if (method === "concat" && e.fn.obj.ty.kind === "array" && e.args.length === 1 && e.args[0].ty.kind === "array") {
+                    return { kind: "binop", op: "arrayConcat", left: recv, right: args[0] };
+                }
                 // Spec-context map get: result type is non-optional → direct access
                 if (method === "get" && e.fn.obj.ty.kind === "map" && e.ty.kind !== "optional") {
                     method = "getDirect";
@@ -507,6 +617,19 @@ function lowerExpr(e, binds) {
             if (e.fields.length === 0 && !e.spread && e.ty.kind === "map") {
                 return { kind: "emptyMap" };
             }
+            // Non-empty record literal with map type — emit as a flat Dafny map
+            // literal `map[k1 := v1, k2 := v2, ...]`. (A chain of `m["k" := v]`
+            // works for a handful of entries but Dafny's type resolver stack-
+            // overflows on hundreds; the flat form is fine at any size.)
+            if (e.fields.length > 0 && !e.spread && e.ty.kind === "map") {
+                return {
+                    kind: "mapLiteral",
+                    entries: e.fields.map(f => ({
+                        key: { kind: "str", value: f.name },
+                        value: lowerExpr(f.value, binds),
+                    })),
+                };
+            }
             return { kind: "record", spread: null, fields: e.fields.map(f => ({ name: f.name, value: lowerExpr(f.value, binds) })) };
         }
         case "arrayLiteral":
@@ -518,73 +641,29 @@ function lowerExpr(e, binds) {
             if (e.ty.kind === "set")
                 return { kind: "app", fn: "SetLiteral", args: e.elems.map(el => lowerExpr(el, binds)) };
             return { kind: "arrayLiteral", elems: e.elems.map(el => lowerExpr(el, binds)) };
-        case "lambda":
-            return { kind: "lambda", params: e.params.map(p => ({ name: p.name, type: p.ty })), body: transformStmts(e.body, []) };
+        case "lambda": {
+            const body = transformStmts(e.body, []);
+            // Flatten an if/let/return-shaped multi-statement body into a single
+            // `return <expr>` so both backends' single-return-lambda fast path emits
+            // it (Dafny lambdas are expression-only; Lean prefers the expression form
+            // over a `do` block). Bodies with shapes we can't reduce (loops, bare
+            // side effects) are left as-is.
+            const flat = flattenLambdaBody(body);
+            return {
+                kind: "lambda",
+                params: e.params.map(p => ({ name: p.name, type: p.ty })),
+                body: flat === null ? body : [{ kind: "return", value: flat }],
+            };
+        }
         case "forall":
             return { kind: "forall", var: e.var, type: e.varTy, body: transformExpr(e.body) };
         case "exists":
             return { kind: "exists", var: e.var, type: e.varTy, body: transformExpr(e.body) };
         case "conditional": {
-            // Phase 0: Complex expression check (call results, etc.) — resolve substituted
-            // and set narrowedVar + narrowedExpr because transform can't detect these.
-            if (e.narrowedVar && e.narrowedExpr) {
-                const scrutinee = lowerExpr(e.narrowedExpr, binds);
-                const bound = matchBinder(e.narrowedVar);
-                let thenExpr = lowerExpr(e.then, binds);
-                let elseExpr = lowerExpr(e.else, binds);
-                if (bound !== e.narrowedVar) {
-                    thenExpr = replaceVar(thenExpr, e.narrowedVar, { kind: "var", name: bound });
-                }
-                if (e.ty.kind === "optional") {
-                    thenExpr = wrapOptionalBranch(thenExpr, e.then);
-                    elseExpr = wrapOptionalBranch(elseExpr, e.else);
-                }
-                return {
-                    kind: "match", scrutinee,
-                    arms: [
-                        { pattern: `.some ${bound}`, body: thenExpr },
-                        { pattern: ".none", body: elseExpr },
-                    ],
-                };
-            }
-            // Phase 1: Truthiness — cond itself is optional (e.g. opt ? X : Y)
-            // Uses narrowedVar set by resolve's Phase 1 (unchanged).
-            if (e.narrowedVar && e.cond.ty.kind === "optional") {
-                const cond = lowerExpr(e.cond, binds);
-                let thenExpr = lowerExpr(e.then, binds);
-                let elseExpr = lowerExpr(e.else, binds);
-                const bound = matchBinder(e.narrowedVar);
-                if (bound !== e.narrowedVar) {
-                    thenExpr = replaceVar(thenExpr, e.narrowedVar, { kind: "var", name: bound });
-                }
-                thenExpr = wrapOptionalBranch(thenExpr, e.then);
-                elseExpr = wrapOptionalBranch(elseExpr, e.else);
-                return {
-                    kind: "match", scrutinee: cond,
-                    arms: [
-                        { pattern: `.some ${bound}`, body: thenExpr },
-                        { pattern: ".none", body: elseExpr },
-                    ],
-                };
-            }
-            // Phase 2: Explicit check — x !== undefined ? A : B
-            // Transform detects the pattern itself (no narrowedVar/narrowedExpr from resolve).
-            const check = parseOptionalCheck(e.cond);
-            if (check && !check.negated) {
-                return lowerOptionalConditional(e, check, null, binds);
-            }
-            // Phase 3: && with optional check — x !== undefined && guard(x) ? A : B
-            if (e.cond.kind === "binop" && e.cond.op === "&&") {
-                const extracted = extractLeftmostOptional(e.cond);
-                if (extracted) {
-                    const innerCheck = parseOptionalCheck(extracted.optCond);
-                    if (innerCheck && !innerCheck.negated) {
-                        return lowerOptionalConditional(e, innerCheck, extracted.rest, binds);
-                    }
-                }
-            }
-            // Phase 4: Regular conditional (no optional narrowing)
-            const cond = lowerExpr(e.cond, binds);
+            // JS truthiness coercion (string/array/int → ... > 0).  Matches SPEC §3.1
+            // negation forms (`!s` → `s == ""`).  Optional conds are already
+            // rewritten to someMatch by narrow.ts.
+            const cond = coerceCondToBool(lowerExpr(e.cond, binds), e.cond.ty);
             let thenExpr = lowerExpr(e.then, binds);
             let elseExpr = lowerExpr(e.else, binds);
             if (e.ty.kind === "optional") {
@@ -593,6 +672,12 @@ function lowerExpr(e, binds) {
             }
             return { kind: "if", cond, then: thenExpr, else: elseExpr };
         }
+        case "optChain":
+            // Narrow should have rewritten optChain to someMatch.
+            throw new Error(`optChain reached transform — narrow should have rewritten it`);
+        case "nullish":
+            // Narrow should have rewritten nullish to someMatch.
+            throw new Error(`nullish reached transform — narrow should have rewritten it`);
         case "havoc":
             // Dafny's * only works in var/assign positions — lift to own declaration
             if (binds) {
@@ -601,6 +686,82 @@ function lowerExpr(e, binds) {
                 return { kind: "var", name };
             }
             return { kind: "havoc", type: e.ty };
+        case "someMatch": {
+            let someBody;
+            let scrutinee;
+            const path = asTAccessPath(e.scrutinee);
+            if (path) {
+                // Pure access path (var or any depth of obj.f.g.h) — substitute the
+                // path with the binder pre-lowering.
+                const replaced = replacePathInTExpr(e.someBody, path, e.binder, e.binderTy);
+                someBody = lowerExpr(replaced, binds);
+                // Bare-var shortcut, but route \result through lowerExpr so the
+                // lemma-side replaceVar pass can substitute it with the function call.
+                scrutinee = path.fields.length === 0 && path.rootVar !== "\\result"
+                    ? path.rootVar
+                    : lowerExpr(e.scrutinee, binds);
+            }
+            else {
+                // Complex scrutinee — narrow pre-bound the someBody to use the binder directly,
+                // so no substitution needed. Used by optChain rewrites.
+                someBody = lowerExpr(e.someBody, binds);
+                scrutinee = lowerExpr(e.scrutinee, binds);
+            }
+            let noneBody = lowerExpr(e.noneBody, binds);
+            if (e.ty.kind === "optional") {
+                someBody = wrapOptionalBranch(someBody, e.someBody);
+                noneBody = wrapOptionalBranch(noneBody, e.noneBody);
+            }
+            return {
+                kind: "match", scrutinee,
+                arms: [
+                    { pattern: `.some ${e.binder}`, body: someBody },
+                    { pattern: ".none", body: noneBody },
+                ],
+            };
+        }
+        case "tagMatch": {
+            // Expression-form tagMatch — emitted by `ruleImplArrayIsArray` for spec
+            // implications like `Array.isArray(x) ==> B` and by
+            // `ruleConditionalArrayIsArray` for ternary narrowing. Substitutes
+            // scrutinee field accesses and (for synth array-unions) scrutinee
+            // path occurrences inside each arm with the variant's payload binder.
+            // Path scrutinees (e.g. `m.content`) get a synthesized hint derived
+            // from the last field/var name so the binder reads naturally.
+            const scrutinee = lowerExpr(e.scrutinee, binds);
+            const decl = _typeDecls.find(d => d.name === e.typeName);
+            const isSynthArrayUnion = decl?.discriminant === "__isArray__";
+            const varName = e.scrutinee.kind === "var" ? e.scrutinee.name : undefined;
+            const pathHint = varName ?? scrutineeHint(e.scrutinee);
+            const wrapOpt = e.ty.kind === "optional";
+            const arms = e.cases.map(c => {
+                const variant = decl?.variants?.find(v => v.name === c.variant);
+                const fields = variant?.fields ?? [];
+                let body = lowerExpr(c.body, binds);
+                if (varName && fields.length > 0) {
+                    body = replaceFieldAccess(body, varName, fields);
+                    if (isSynthArrayUnion && fields.length === 1) {
+                        body = replaceVarInExpr(body, varName, matchBinder(fields[0].name, varName));
+                    }
+                }
+                else if (!varName && isSynthArrayUnion && fields.length === 1) {
+                    // Path scrutinee (e.g. `m.content`): replace structural occurrences
+                    // with the binder var ref.
+                    const binderName = matchBinder(fields[0].name, pathHint);
+                    body = replaceExprInExpr(body, scrutinee, { kind: "var", name: binderName });
+                }
+                if (wrapOpt)
+                    body = wrapOptionalBranch(body, c.body);
+                return { pattern: buildMatchPattern(c.variant, fields, pathHint), body };
+            });
+            if (e.fallthrough) {
+                let body = lowerExpr(e.fallthrough, binds);
+                if (wrapOpt)
+                    body = wrapOptionalBranch(body, e.fallthrough);
+                arms.push({ pattern: "_", body });
+            }
+            return { kind: "match", scrutinee: varName ?? scrutinee, arms };
+        }
     }
 }
 function flattenImpl(e) {
@@ -654,33 +815,124 @@ function replaceFieldAccess(e, varName, fields) {
         return null;
     });
 }
+/** Replace bare `var(oldName)` references → `var(newName)` in lowered IR.
+ *  Used inside synth array-union match arms: the user code refers to the
+ *  scrutinee by its bare name (`content`), but in the arm body that name
+ *  must refer to the variant's sole payload binder (`i_content_arr`). */
+function replaceVarInExpr(e, oldName, newName) {
+    return mapExpr(e, x => {
+        if (x.kind === "var" && x.name === oldName)
+            return { kind: "var", name: newName };
+        // If a binding shadows the name, stop substituting inside its body.
+        if (x.kind === "let" && x.name === oldName)
+            return { ...x, value: replaceVarInExpr(x.value, oldName, newName) };
+        return null;
+    });
+}
+/** Structural equality on Expr access-paths (var / field chain). Enough to
+ *  match the scrutinee `m.content` against later occurrences in a match arm. */
+function exprPathEqual(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === "var" && b.kind === "var")
+        return a.name === b.name;
+    if (a.kind === "field" && b.kind === "field")
+        return a.field === b.field && exprPathEqual(a.obj, b.obj);
+    return false;
+}
+/** Substitute every occurrence of `target` (an access-path Expr) with `repl`
+ *  inside `e`. Mirror of `replaceVarInExpr` but keyed on a sub-path rather
+ *  than a bare name — needed when the narrowing scrutinee is `m.content`
+ *  (field access) rather than a bare `content` (var). */
+function replaceExprInExpr(e, target, repl) {
+    return mapExpr(e, x => {
+        if (exprPathEqual(x, target))
+            return repl;
+        return null;
+    });
+}
+/** Extract a short reader-friendly hint for a TExpr access-path: the last
+ *  field name in a field chain, or the var name. Used to derive a stable
+ *  binder prefix when the scrutinee isn't a bare var. */
+function scrutineeHint(e) {
+    if (e.kind === "var")
+        return e.name;
+    if (e.kind === "field")
+        return e.field;
+    return "x";
+}
 // ── Transform statements ─────────────────────────────────────
+// `if (X) continue; rest` → `if (!X) { rest }` at the top of a loop body.
+// Dafny's lowered while-loops have the index increment at the bottom, so a
+// `continue` would skip it and loop forever; rewriting to if/else lets the
+// loop fall through normally.
+function negateExpr(e) {
+    if (e.kind === "unop" && e.op === "!")
+        return e.expr;
+    return { kind: "unop", op: "!", expr: e };
+}
+/** Build the two pieces of an `arr.pop()` lowering on a named array variable:
+ *  - `optValue` is `(if |arr|>0 then Some(arr[|arr|-1]) else None)` (the popped element)
+ *  - `guardedTrunc` is `(if |arr|>0 then arr[..|arr|-1] else arr)` (the array minus its last element)
+ *  Callers wrap these in let/assign statements appropriate to their context. */
+function buildPopLowering(arrName, arrTy) {
+    const arrVar = { kind: "var", name: arrName };
+    const arrLen = { kind: "field", obj: arrVar, field: "size" };
+    const lastIdx = { kind: "binop", op: "-", left: arrLen, right: { kind: "num", value: 1 } };
+    const lastElem = { kind: "index", arr: arrVar, idx: lastIdx };
+    const isNonEmpty = { kind: "binop", op: ">", left: arrLen, right: { kind: "num", value: 0 } };
+    const optValue = { kind: "if", cond: isNonEmpty,
+        then: { kind: "app", fn: "Some", args: [lastElem] },
+        else: { kind: "var", name: "undefined" } };
+    const truncated = { kind: "methodCall", obj: arrVar, objTy: arrTy, method: "slice",
+        args: [{ kind: "num", value: 0 }, lastIdx], monadic: false };
+    const guardedTrunc = { kind: "if", cond: isNonEmpty, then: truncated, else: arrVar };
+    return { optValue, guardedTrunc };
+}
+function eliminateTopLevelContinue(stmts) {
+    const out = [];
+    for (let i = 0; i < stmts.length; i++) {
+        const s = stmts[i];
+        // `if (X) {...A, continue}; rest` (empty else, trailing continue in then)
+        // — if A is empty, rewrite to `if (!X) { rest }`; otherwise rewrite to
+        // `if (X) { ...A } else { rest }`. Either form lets the loop fall through
+        // naturally past the bottom of the body.
+        if (s.kind === "if" && s.else.length === 0 &&
+            s.then.length >= 1 && s.then[s.then.length - 1].kind === "continue") {
+            const rest = eliminateTopLevelContinue(stmts.slice(i + 1));
+            const thenWithoutContinue = s.then.slice(0, -1);
+            if (thenWithoutContinue.length === 0) {
+                out.push({ kind: "if", cond: negateExpr(s.cond), then: rest, else: [] });
+            }
+            else {
+                out.push({ kind: "if", cond: s.cond, then: thenWithoutContinue, else: rest });
+            }
+            return out;
+        }
+        // narrow.ts's ruleEarlyReturnConsume rewrites `if (!x) continue; rest`
+        // (when x is Optional) to a someMatch which transform.ts then emits as a
+        // `match`. A trailing `continue` inside a match arm is a no-op when the
+        // match is the last statement in the loop body — drop it.
+        if (s.kind === "match" && i === stmts.length - 1) {
+            const arms = s.arms.map(arm => {
+                const b = arm.body;
+                if (b.length > 0 && b[b.length - 1].kind === "continue") {
+                    return { ...arm, body: b.slice(0, -1) };
+                }
+                return arm;
+            });
+            out.push({ ...s, arms });
+            continue;
+        }
+        out.push(s);
+    }
+    return out;
+}
 function transformStmts(stmts, typeDecls) {
     const result = [];
     let i = 0;
     while (i < stmts.length) {
         const s = stmts[i];
-        // Detect discriminant if-chain → match
-        if (s.kind === "if") {
-            const chain = detectDiscriminantChain(stmts.slice(i));
-            if (chain) {
-                result.push(emitMatchStmt(chain.chain, typeDecls));
-                i += chain.consumed;
-                continue;
-            }
-            // Detect optional check → match on Some/None
-            const optMatch = prepareOptionalMatch(s, stmts.slice(i + 1));
-            if (optMatch) {
-                result.push(emitOptionalMatch(optMatch.check.varName, optMatch.check.negated, s, typeDecls, stmts.slice(i + 1), optMatch.check.fieldExpr));
-                // If rest was consumed into the Some branch, skip remaining
-                const origSome = optMatch.check.negated ? s.else : s.then;
-                if (origSome.length === 0 && i + 1 < stmts.length) {
-                    return result;
-                }
-                i++;
-                continue;
-            }
-        }
         // Transform for-of → for-in over range
         if (s.kind === "forof") {
             const varName = s.names[0];
@@ -700,7 +952,7 @@ function transformStmts(stmts, typeDecls) {
                 const idxName = `_${keyName}_idx${suffix}`;
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
-                const bodyStmts = transformStmts(s.body, typeDecls);
+                const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
                 const letKey = { kind: "let", name: keyName, type: keyTy, mutable: false, value: { kind: "index", arr: keysVar, idx } };
                 const boundInv = { kind: "binop", op: "≤", left: idx, right: arrSize };
                 result.push({
@@ -726,7 +978,7 @@ function transformStmts(stmts, typeDecls) {
                 const idxName = `_${keyName}_idx${suffix}`;
                 const idx = { kind: "var", name: idxName };
                 const arrSize = { kind: "field", obj: keysVar, field: "size" };
-                const bodyStmts = transformStmts(s.body, typeDecls);
+                const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
                 const letKey = { kind: "let", name: keyName, type: keyTy, mutable: false, value: { kind: "index", arr: keysVar, idx } };
                 const letVal = { kind: "let", name: valueName, type: valueTy, mutable: false,
                     value: { kind: "methodCall", obj: iterExpr, objTy: s.iterable.ty, method: "getDirect", args: [{ kind: "var", name: keyName }], monadic: false } };
@@ -753,7 +1005,7 @@ function transformStmts(stmts, typeDecls) {
             const idxName = `_${varName}_idx${suffix}`;
             const idx = { kind: "var", name: idxName };
             const arrSize = { kind: "field", obj: iterExpr, field: "size" };
-            const bodyStmts = transformStmts(s.body, typeDecls);
+            const bodyStmts = eliminateTopLevelContinue(transformStmts(s.body, typeDecls));
             const letElem = { kind: "let", name: varName, type: varTy, mutable: false, value: { kind: "index", arr: iterExpr, idx } };
             // Auto-add bound invariant: idx ≤ bound (always true for range loops)
             const boundInv = { kind: "binop", op: "≤", left: idx, right: arrSize };
@@ -798,6 +1050,17 @@ function transformStmt(s, typeDecls) {
                     return [letHead, sliceTail];
                 }
             }
+            // let x = arr.pop() → let x: T? = (Option-expr); arr := (truncated-or-self)
+            if (init && init.fn.kind === "field" && init.fn.field === "pop" && init.fn.obj.ty.kind === "array") {
+                const arrName = init.fn.obj.kind === "var" ? init.fn.obj.name : undefined;
+                if (arrName) {
+                    const { optValue, guardedTrunc } = buildPopLowering(arrName, init.fn.obj.ty);
+                    return [
+                        { kind: "let", name: s.name, type: s.ty, mutable: s.mutable, value: optValue },
+                        { kind: "assign", target: arrName, value: guardedTrunc },
+                    ];
+                }
+            }
             // new Map(arr.map(n => [n.field, n])) → let m = map[]; for (n of arr) m[n.field] := n
             if (init && init.fn.kind === "var" && init.fn.name === "__mapFromArray" &&
                 init.args.length === 1 && init.args[0].kind === "call" &&
@@ -844,25 +1107,21 @@ function transformStmt(s, typeDecls) {
                     return stmts;
                 }
             }
-            // Desugar: const x = optCheck && guard ? A : B
-            // → var x := B; if (optCheck && guard) { x := A; }
-            // This avoids putting method calls (from guard) inside a match expression,
-            // which Dafny doesn't allow.  The if-case in transformStmt handles the &&
-            // via extractLeftmostOptional → emitOptionalMatch (statement-level match).
-            if (s.init.kind === "conditional" && s.init.cond.kind === "binop" && s.init.cond.op === "&&") {
-                const extracted = extractLeftmostOptional(s.init.cond);
-                if (extracted) {
-                    const desugared = [
-                        { kind: "let", name: s.name, ty: s.ty, mutable: true, init: s.init.else },
-                        { kind: "if", cond: s.init.cond, then: [{ kind: "assign", target: s.name, value: s.init.then }], else: [] },
-                    ];
-                    return desugared.flatMap(ds => transformStmt(ds, typeDecls));
-                }
-            }
             const { binds, expr } = liftMethodCalls(s.init);
             return [...binds, { kind: "let", name: s.name, type: s.ty, mutable: s.mutable, value: expr }];
         }
         case "assign": {
+            // x = arr.pop() → x := (Option-expr); arr := (truncated-or-self)
+            if (s.value.kind === "call" && s.value.fn.kind === "field" &&
+                s.value.fn.field === "pop" && s.value.fn.obj.ty.kind === "array" &&
+                s.value.fn.obj.kind === "var") {
+                const arrName = s.value.fn.obj.name;
+                const { optValue, guardedTrunc } = buildPopLowering(arrName, s.value.fn.obj.ty);
+                return [
+                    { kind: "assign", target: s.target, value: optValue },
+                    { kind: "assign", target: arrName, value: guardedTrunc },
+                ];
+            }
             // Top-level method call → direct monadic bind, no lifting needed
             if (s.value.kind === "call" && s.value.callKind === "method")
                 return [{ kind: "bind", target: s.target, value: transformExpr(s.value) }];
@@ -889,15 +1148,19 @@ function transformStmt(s, typeDecls) {
                 const { binds, expr } = liftMethodCalls(s.expr);
                 return [...binds, { kind: "assign", target: receiver, value: expr }];
             }
-            // Optional chaining on map.get: m.get(k)?.push(v) → if k in m { m[k] := m[k] + [v] }
-            if (s.expr.kind === "call" && s.expr.fn.kind === "field" &&
-                s.expr.fn.obj.kind === "call" && s.expr.fn.obj.fn.kind === "field" &&
-                s.expr.fn.obj.fn.obj.ty.kind === "map" && s.expr.fn.obj.fn.field === "get" &&
-                s.expr.fn.field === "push") {
-                const mapExpr = s.expr.fn.obj.fn.obj;
+            // Optional chaining on map.get at statement level: m.get(k)?.push(v)
+            // → if k in m { m[k] := m[k] + [v] } (actual mutation, not value-discard).
+            // Narrow rewrote this to a someMatch — destructure to find the underlying
+            // m.get(k) scrutinee and the .push(v) body call.
+            if (s.expr.kind === "someMatch" &&
+                s.expr.scrutinee.kind === "call" && s.expr.scrutinee.fn.kind === "field" &&
+                s.expr.scrutinee.fn.field === "get" && s.expr.scrutinee.fn.obj.ty.kind === "map" &&
+                s.expr.someBody.kind === "call" && s.expr.someBody.fn.kind === "field" &&
+                s.expr.someBody.fn.field === "push") {
+                const mapExpr = s.expr.scrutinee.fn.obj;
                 const mapName = mapExpr.kind === "var" ? mapExpr.name : undefined;
-                const keyExpr = lowerExpr(s.expr.fn.obj.args[0], null);
-                const pushArg = lowerExpr(s.expr.args[0], null);
+                const keyExpr = lowerExpr(s.expr.scrutinee.args[0], null);
+                const pushArg = lowerExpr(s.expr.someBody.args[0], null);
                 if (mapName) {
                     const mapVar = { kind: "var", name: mapName };
                     const directGet = { kind: "methodCall", obj: mapVar, objTy: mapExpr.ty, method: "getDirect", args: [keyExpr], monadic: false };
@@ -911,29 +1174,18 @@ function transformStmt(s, typeDecls) {
             return [...binds, { kind: "assign", target: "_", value: expr }];
         }
         case "if": {
-            // Restructure && with optional check: extract the leftmost optional check
-            // from a && chain and nest the rest inside. Handles left-associative chains:
-            // if ((x !== undefined && b) && c) → if (x !== undefined) { if (b && c) { ... } }
-            if (s.cond.kind === "binop" && s.cond.op === "&&" && s.else.length === 0) {
-                const extracted = extractLeftmostOptional(s.cond);
-                if (extracted) {
-                    const innerIf = { kind: "if", cond: extracted.rest, then: s.then, else: [] };
-                    const outerIf = { kind: "if", cond: extracted.optCond, then: [innerIf], else: [] };
-                    return transformStmts([outerIf], typeDecls);
-                }
-            }
-            // Lift from condition only (Lean rule: don't lift from branches)
+            // Lift from condition only (Lean rule: don't lift from branches).
             const { binds, expr: cond } = liftMethodCalls(s.cond);
-            return [...binds, { kind: "if", cond, then: transformStmts(s.then, typeDecls), else: transformStmts(s.else, typeDecls) }];
+            return [...binds, { kind: "if", cond: coerceCondToBool(cond, s.cond.ty), then: transformStmts(s.then, typeDecls), else: transformStmts(s.else, typeDecls) }];
         }
         case "while":
             return [{
                     kind: "while",
-                    cond: transformExpr(s.cond),
+                    cond: coerceCondToBool(transformExpr(s.cond), s.cond.ty),
                     invariants: s.invariants.map(transformExpr),
                     decreasing: s.decreases ? transformExpr(s.decreases) : null,
                     doneWith: s.doneWith ? transformExpr(s.doneWith) : null,
-                    body: transformStmts(s.body, typeDecls),
+                    body: eliminateTopLevelContinue(transformStmts(s.body, typeDecls)),
                 }];
         case "throw":
             return [{ kind: "assert", expr: { kind: "bool", value: false } }];
@@ -946,181 +1198,32 @@ function transformStmt(s, typeDecls) {
         case "ghostAssign":
             return [{ kind: "ghostAssign", target: s.target, value: transformExpr(s.value) }];
         case "assert":
-            return [{ kind: "assert", expr: transformExpr(s.expr) }];
-    }
-}
-function detectDiscriminantChain(stmts) {
-    if (stmts.length === 0 || stmts[0].kind !== "if")
-        return null;
-    const first = parseDiscriminantCond(stmts[0].cond);
-    if (!first)
-        return null;
-    const cases = [];
-    // Follow else branches within one if-else-if tree
-    function collectElse(s) {
-        const p = parseDiscriminantCond(s.cond);
-        if (!p || p.varName !== first.varName)
-            return [s];
-        cases.push({ variant: p.variant, body: s.then });
-        if (s.else.length === 0)
-            return [];
-        if (s.else.length === 1 && s.else[0].kind === "if")
-            return collectElse(s.else[0]);
-        return s.else;
-    }
-    // Walk consecutive top-level ifs on the same discriminant
-    let consumed = 0;
-    for (let i = 0; i < stmts.length; i++) {
-        const s = stmts[i];
-        if (s.kind !== "if")
-            break;
-        const p = parseDiscriminantCond(s.cond);
-        if (!p || p.varName !== first.varName)
-            break;
-        cases.push({ variant: p.variant, body: s.then });
-        consumed = i + 1;
-        if (s.else.length > 0) {
-            const ft = (s.else.length === 1 && s.else[0].kind === "if") ? collectElse(s.else[0]) : s.else;
-            return cases.length > 0 ? { chain: { ...first, cases, fallthrough: ft }, consumed } : null;
+            return [{ kind: "assert", expr: transformExpr(s.expr), assumed: s.assumed }];
+        case "someMatch": {
+            const path = asTAccessPath(s.scrutinee);
+            if (path) {
+                const replaced = replacePathInTStmts(s.someBody, path, s.binder, s.binderTy);
+                const someBody = transformStmts(replaced, typeDecls);
+                const noneBody = transformStmts(s.noneBody, typeDecls);
+                const scrutinee = path.fields.length === 0 ? path.rootVar : transformExpr(s.scrutinee);
+                return [{
+                        kind: "match", scrutinee,
+                        arms: [
+                            { pattern: `.some ${s.binder}`, body: someBody },
+                            { pattern: ".none", body: noneBody },
+                        ],
+                    }];
+            }
+            throw new Error(`someMatch stmt scrutinee must be a pure access path, got ${s.scrutinee.kind}`);
         }
+        case "tagMatch":
+            return [emitMatchStmt(s.scrutinee, s.typeName, s.cases, s.fallthrough, typeDecls)];
     }
-    if (cases.length === 0)
-        return null;
-    return { chain: { ...first, cases, fallthrough: stmts.slice(consumed) }, consumed: stmts.length };
-}
-function parseDiscriminantCond(cond) {
-    // Pattern: x.discriminant === "variant"
-    if (cond.kind !== "binop" || cond.op !== "===" || cond.right.kind !== "str")
-        return null;
-    if (cond.left.kind !== "field" || !cond.left.isDiscriminant)
-        return null;
-    if (cond.left.obj.kind !== "var" || cond.left.obj.ty.kind !== "user")
-        return null;
-    return { varName: cond.left.obj.name, typeName: cond.left.obj.ty.name, variant: cond.right.value };
-}
-function emitOptionalMatch(varName, negated, s, typeDecls, restStmts, fieldExpr) {
-    let someBranch = negated ? s.else : s.then;
-    const noneBranch = negated ? s.then : s.else;
-    // Early-return pattern: if (x === undefined) { return ... } — Some branch is empty,
-    // so include remaining statements as the Some body
-    if (someBranch.length === 0 && restStmts && restStmts.length > 0) {
-        someBranch = restStmts;
-    }
-    const sanitized = varName.replace(/\./g, "_");
-    const bound = matchBinder(`${sanitized}_val`);
-    // Replace the narrowed variable/field in the Some branch body.
-    // Field chains: replace in TStmt before transform (so downstream narrowing sees simple vars).
-    // Simple vars: replace in IR after transform (the original mechanism).
-    let someBody;
-    if (fieldExpr && fieldExpr.kind === "field" && fieldExpr.obj.kind === "var") {
-        const innerTy = fieldExpr.ty.kind === "optional" ? fieldExpr.ty.inner : fieldExpr.ty;
-        const replaced = replaceFieldsInTStmts(someBranch, fieldExpr.obj.name, [
-            { fieldName: fieldExpr.field, newName: bound, fallbackTy: innerTy },
-        ]);
-        someBody = transformStmts(replaced, typeDecls);
-    }
-    else {
-        const transformed = transformStmts(someBranch, typeDecls);
-        someBody = transformed.map(stmt => mapStmtExprs(stmt, e => replaceVar(e, varName, { kind: "var", name: bound }, true)));
-    }
-    // For field chains, use an Expr scrutinee so outer match replaceVar can
-    // substitute the object variable (e.g. task → i_task_val in task.deletedFromList).
-    // String scrutinees are opaque to replaceVar/mapExpr.
-    const scrutinee = fieldExpr ? transformExpr(fieldExpr) : varName;
-    return {
-        kind: "match", scrutinee,
-        arms: [
-            { pattern: `.some ${bound}`, body: someBody },
-            { pattern: ".none", body: noneBranch.length > 0 ? transformStmts(noneBranch, typeDecls) : [] },
-        ],
-    };
 }
 /** Apply an expression transform to all expressions in a statement (convenience wrapper). */
 function mapStmtExprs(s, r) {
     return mapStmt(s, e => r(e));
 }
-// ── Optional narrowing helpers ──────────────────────────────
-//
-// Optional narrowing converts TS `if (x === undefined)` / `x !== undefined ? a : b`
-// patterns to `match x { Some(val) => ..., None => ... }`.
-//
-// The resolve phase (resolve.ts) handles TYPE narrowing only:
-//   - Flow narrowing: after `if (x === undefined) return`, x is non-optional
-//   - && narrowing: in `x !== undefined && f(x)`, f(x) sees x as non-optional
-//   - Conditional type narrowing: extends env (simple vars) or narrowedFields context
-//     (field chains) so the then-branch resolves with the unwrapped type
-//
-// The transform phase (here) handles ALL structural narrowing:
-//   - Statement-level: `transformStmts` detects optional checks → `emitOptionalMatch`
-//   - Expression-level: `lowerExpr` detects optional checks via `parseOptionalCheck`
-//     and `extractLeftmostOptional` → `lowerOptionalConditional`
-//   - && restructuring: `extractLeftmostOptional` splits `&&` chains, generating
-//     match with guard: `match x { Some(val) => if guard then A else B, None => B }`
-/** Shared logic for optional match in both imperative and pure function paths.
- *  Detects optional check, selects branches, handles early-return consumption.
- *  Returns null if the condition is not an optional check. */
-function prepareOptionalMatch(s, restStmts) {
-    const check = parseOptionalCheck(s.cond);
-    if (!check)
-        return null;
-    let someBranch = check.negated ? s.else : s.then;
-    const noneBranch = check.negated ? s.then : (s.else.length > 0 ? s.else : restStmts);
-    // Early-return pattern: Some branch is empty → consume rest of block
-    if (someBranch.length === 0 && restStmts.length > 0)
-        someBranch = restStmts;
-    const sanitized = check.varName.replace(/\./g, "_");
-    const bound = matchBinder(`${sanitized}_val`);
-    return { check, someBranch, noneBranch, bound };
-}
-/** Extract the leftmost optional check from a && chain, returning the check and the rest.
- *  (x !== undefined && b) && c → { optCond: x !== undefined, rest: b && c } */
-function extractLeftmostOptional(cond) {
-    if (cond.kind !== "binop" || cond.op !== "&&")
-        return null;
-    const check = parseOptionalCheck(cond.left);
-    if (check && !check.negated)
-        return { optCond: cond.left, rest: cond.right };
-    if (cond.left.kind === "binop" && cond.left.op === "&&") {
-        const inner = extractLeftmostOptional(cond.left);
-        if (inner)
-            return { optCond: inner.optCond, rest: { ...cond, left: inner.rest } };
-    }
-    return null;
-}
-/** Detect `v !== undefined` or `undefined !== v` where v has optional type.
- *  Also handles field access chains like `obj.field !== undefined`.
- *  When `fieldExpr` is returned, callers must use field-aware replacement. */
-function parseOptionalCheck(cond) {
-    if (cond.kind !== "binop" || (cond.op !== "!==" && cond.op !== "==="))
-        return null;
-    let varExpr = null;
-    if (cond.right.kind === "var" && cond.right.name === "undefined")
-        varExpr = cond.left;
-    if (cond.left.kind === "var" && cond.left.name === "undefined")
-        varExpr = cond.right;
-    if (!varExpr)
-        return null;
-    if (varExpr.kind === "var" && varExpr.ty.kind === "optional") {
-        return { varName: varExpr.name, negated: cond.op === "===" };
-    }
-    if (varExpr.kind === "field" && varExpr.ty.kind === "optional") {
-        // Serialize field chain as a dotted name for use as match scrutinee
-        const chain = serializeFieldChain(varExpr);
-        if (chain)
-            return { varName: chain, negated: cond.op === "===", fieldExpr: varExpr };
-    }
-    return null;
-}
-/** Serialize a field access chain to a dotted variable path, or null if not a simple chain. */
-function serializeFieldChain(e) {
-    if (e.kind === "var")
-        return e.name;
-    if (e.kind === "field") {
-        const parent = serializeFieldChain(e.obj);
-        return parent ? `${parent}.${e.field}` : null;
-    }
-    return null;
-}
 /** Build match arms from variant cases — shared by imperative and pure paths.
  *  Looks up variant fields from typeDecls, builds patterns via buildMatchPattern,
  *  and delegates body transformation to the caller-provided function.
@@ -1139,12 +1242,84 @@ function buildMatchArms(cases, varName, typeName, typeDecls, transformBody) {
     }
     return arms;
 }
-function emitMatchStmt(chain, typeDecls) {
-    const cases = chain.cases.map(c => ({ name: c.variant, body: c.body }));
-    const arms = buildMatchArms(cases, chain.varName, chain.typeName, typeDecls, (body, vn, fields) => transformStmts(replaceFieldAccessInTStmts(body, vn, fields), typeDecls));
-    if (chain.fallthrough.length > 0)
-        arms.push({ pattern: "_", body: transformStmts(chain.fallthrough, typeDecls) });
-    return { kind: "match", scrutinee: chain.varName, arms };
+function emitMatchStmt(scrutinee, typeName, cases, fallthrough, typeDecls) {
+    const decl = typeDecls.find(d => d.name === typeName);
+    // Synth array-unions (discriminant "__isArray__") have single-field variants
+    // ArrayBranch(arr) / NonArrayBranch(val). The matched arm refers to the
+    // scrutinee by its bare name/path (`content`, `m.content`), not `.arr`, so
+    // we substitute that whole reference with the variant's sole field binder.
+    const isSynthArrayUnion = decl?.discriminant === "__isArray__";
+    // The scrutinee is a bare var (`current`) or a field-access path
+    // (`current.content`). `prefix` names the binder scope — the var name, or a
+    // safe id derived from the path (`current.content` → `current_content`) —
+    // and is used for both pattern binders and arm-body substitution so they
+    // always agree. A var scrutinee has empty `fields`, so `prefix` is just its
+    // name and the emitted code is unchanged from before this generalization.
+    const path = asTAccessPath(scrutinee);
+    const isPath = !!path && path.fields.length > 0;
+    const prefix = path ? [path.rootVar, ...path.fields].join("_") : "?";
+    function transformArmBody(body, fields) {
+        let stmts;
+        if (isPath && path) {
+            // Path scrutinee: the matched value is referred to by the bare path, so
+            // substitute the whole path (only the synth single-field shape arises
+            // here — discriminant chains require a var scrutinee).
+            stmts = isSynthArrayUnion && fields.length === 1
+                ? replacePathInTStmts(body, path, matchBinder(fields[0].name, prefix), fields[0].type ?? parseTsType(fields[0].tsType))
+                : body;
+        }
+        else {
+            stmts = replaceFieldAccessInTStmts(body, prefix, fields);
+            if (isSynthArrayUnion && fields.length === 1) {
+                const f = fields[0];
+                stmts = replaceVarInTStmts(stmts, prefix, matchBinder(f.name, prefix), f.type ?? parseTsType(f.tsType));
+            }
+        }
+        return transformStmts(stmts, typeDecls);
+    }
+    const armCases = cases.map(c => ({ name: c.variant, body: c.body }));
+    const arms = buildMatchArms(armCases, prefix, typeName, typeDecls, (body, _vn, fields) => transformArmBody(body, fields));
+    // Add the fallthrough arm whenever the listed cases don't cover every
+    // variant — needed for exhaustiveness even when there's no `else`
+    // (`fallthrough` empty), e.g. `if (Array.isArray(x)) {...}` with no else
+    // becomes `match x { case ArrayBranch(..) => ... case NonArrayBranch(..) => }`.
+    const allCovered = !!decl?.variants && cases.length >= decl.variants.length;
+    if (!allCovered) {
+        const remaining = remainingVariant(typeName, cases, typeDecls);
+        if (remaining) {
+            // Exactly one variant left — destructure so the fallthrough body can
+            // access variant-specific fields (Lean requires this; Dafny tolerates `_`).
+            const pattern = buildMatchPattern(remaining.name, remaining.fields, prefix);
+            const body = transformArmBody(fallthrough, remaining.fields);
+            arms.push({ pattern, body });
+        }
+        else {
+            arms.push({ pattern: "_", body: transformStmts(fallthrough, typeDecls) });
+        }
+    }
+    return { kind: "match", scrutinee: isPath ? transformExpr(scrutinee) : prefix, arms };
+}
+/** Replace bare `var(oldName)` references → `var(newName)` with the given type.
+ *  Used by emitMatchStmt for synth array-unions where the variant has a single
+ *  payload field and the user code refers to the scrutinee by its bare name. */
+function replaceVarInTStmts(stmts, oldName, newName, newTy) {
+    return stmts.map(s => mapTStmt(s, e => {
+        if (e.kind === "var" && e.name === oldName) {
+            return { kind: "var", name: newName, ty: newTy };
+        }
+        return null;
+    }));
+}
+/** If the chain has matched all variants but one, return that remaining variant. */
+function remainingVariant(typeName, cases, typeDecls) {
+    const decl = typeDecls.find(d => d.name === typeName);
+    if (!decl?.variants)
+        return null;
+    const matched = new Set(cases.map(c => c.variant));
+    const remaining = decl.variants.filter(v => !matched.has(v.name));
+    if (remaining.length !== 1)
+        return null;
+    return remaining[0];
 }
 function emitSwitchStmt(s, typeDecls) {
     const varName = s.expr.kind === "var" ? s.expr.name : "?";
@@ -1155,10 +1330,7 @@ function emitSwitchStmt(s, typeDecls) {
         arms.push({ pattern: "_", body: transformStmts(s.defaultBody, typeDecls) });
     return { kind: "match", scrutinee: varName, arms };
 }
-/** Replace obj.field → replacement var in typed IR (before transform).
- *  Used by discriminant match/switch and optional match to rewrite field accesses
- *  into simple variables before the transform phase, so downstream narrowing
- *  (parseOptionalCheck, extractLeftmostOptional) sees simple variable references.
+/** Replace obj.field → replacement var in typed IR.
  *  Uses the TExpr's resolved type when available, falling back to `fallbackTy`. */
 function replaceFieldsInTStmts(stmts, objName, replacements) {
     if (replacements.length === 0)
@@ -1199,6 +1371,40 @@ function replaceFieldInTExpr(expr, objName, replacements) {
         return null;
     });
 }
+function asTAccessPath(e) {
+    if (e.kind === "var")
+        return { rootVar: e.name, fields: [] };
+    if (e.kind === "field") {
+        const inner = asTAccessPath(e.obj);
+        if (!inner)
+            return null;
+        return { rootVar: inner.rootVar, fields: [...inner.fields, e.field] };
+    }
+    return null;
+}
+/** Does TExpr `e` match the given access path exactly? */
+function matchesAccessPath(e, path) {
+    const collected = [];
+    let cur = e;
+    while (cur.kind === "field") {
+        collected.unshift(cur.field);
+        cur = cur.obj;
+    }
+    if (cur.kind !== "var" || cur.name !== path.rootVar)
+        return false;
+    if (collected.length !== path.fields.length)
+        return false;
+    return collected.every((f, i) => f === path.fields[i]);
+}
+/** Replace every TExpr matching `path` with `var(binder, binderTy)`. */
+function replacePathInTExpr(expr, path, binder, binderTy) {
+    return mapTExpr(expr, e => matchesAccessPath(e, path)
+        ? { kind: "var", name: binder, ty: binderTy } : null);
+}
+function replacePathInTStmts(stmts, path, binder, binderTy) {
+    return stmts.map(s => mapTStmt(s, e => matchesAccessPath(e, path)
+        ? { kind: "var", name: binder, ty: binderTy } : null));
+}
 /** Unwrap optional type on match-bound variables in TExpr.
  *  After replaceFieldInTExpr, the replaced variable carries the original optional
  *  type from the field declaration. The match binding unwraps it to the inner type. */
@@ -1206,80 +1412,14 @@ function fixBoundType(expr, boundName) {
     return mapTExpr(expr, e => e.kind === "var" && e.name === boundName && e.ty.kind === "optional"
         ? { ...e, ty: e.ty.inner } : null);
 }
-/** Lower a conditional with an optional check (Phase 2: explicit, Phase 3: && with guard).
- *  Generates: match scrutinee { Some(val) => [if guard then] A [else B], None => B }
- *  For field chains, replaces field accesses in TExpr before lowering.
- *  For simple vars, replaces variable names in Expr after lowering. */
-function lowerOptionalConditional(e, check, guard, binds) {
-    const sanitized = check.varName.replace(/\./g, "_");
-    const bound = matchBinder(`${sanitized}_val`);
-    const isFieldChain = check.fieldExpr && check.fieldExpr.kind === "field" &&
-        check.fieldExpr.obj.kind === "var";
-    // Determine which branch is Some (unwrapped) vs None
-    let thenTExpr = e.then;
-    let guardTExpr = guard;
-    // For field chains: replace field access with bound var in TExpr before lowering
-    if (isFieldChain) {
-        const fe = check.fieldExpr;
-        const innerTy = fe.ty.kind === "optional" ? fe.ty.inner : fe.ty;
-        const replacements = [{ fieldName: fe.field, newName: bound, fallbackTy: innerTy }];
-        thenTExpr = fixBoundType(replaceFieldInTExpr(thenTExpr, fe.obj.name, replacements), bound);
-        if (guardTExpr) {
-            guardTExpr = fixBoundType(replaceFieldInTExpr(guardTExpr, fe.obj.name, replacements), bound);
-        }
-    }
-    let thenExpr = lowerExpr(thenTExpr, binds);
-    let elseExpr = lowerExpr(e.else, binds);
-    // For simple vars: replace after lowering
-    if (!isFieldChain) {
-        thenExpr = replaceVar(thenExpr, check.varName, { kind: "var", name: bound }, true);
-    }
-    // Optional wrapping: check if either branch is undefined (produces optional result)
-    const isOptionalResult = (e.then.kind === "var" && e.then.name === "undefined") ||
-        (e.else.kind === "var" && e.else.name === "undefined");
-    if (isOptionalResult) {
-        thenExpr = wrapOptionalBranch(thenExpr, e.then);
-        elseExpr = wrapOptionalBranch(elseExpr, e.else);
-    }
-    // Build Some arm body — add guard for && patterns
-    // Note: if the guard has method calls, the impure path desugars the let to a
-    // statement-level if+match in transformStmt, so this expression-level path only
-    // runs for pure guards. Use null for binds to avoid escaping the match scope.
-    let someBody;
-    if (guard) {
-        let guardExpr = lowerExpr(guardTExpr, null);
-        if (!isFieldChain) {
-            guardExpr = replaceVar(guardExpr, check.varName, { kind: "var", name: bound }, true);
-        }
-        // Guard-else gets the same expression as None arm
-        let guardElse = lowerExpr(e.else, null);
-        if (isOptionalResult) {
-            guardElse = wrapOptionalBranch(guardElse, e.else);
-        }
-        someBody = { kind: "if", cond: guardExpr, then: thenExpr, else: guardElse };
-    }
-    else {
-        someBody = thenExpr;
-    }
-    // Build scrutinee
-    const scrutinee = isFieldChain
-        ? lowerExpr(check.fieldExpr, binds)
-        : check.varName;
-    return {
-        kind: "match", scrutinee,
-        arms: [
-            { pattern: `.some ${bound}`, body: someBody },
-            { pattern: ".none", body: elseExpr },
-        ],
-    };
-}
 // ── Pure function generation ─────────────────────────────────
 function transformPureBody(stmts, typeDecls) {
-    // Detect discriminant if-chain
-    if (stmts.length > 0 && stmts[0].kind === "if") {
-        const chain = detectDiscriminantChain(stmts);
-        if (chain)
-            return transformPureMatch(chain.chain, typeDecls);
+    // tagMatch (from narrow's discriminant detection) is the leading stmt and consumes the rest.
+    if (stmts.length > 0 && stmts[0].kind === "tagMatch") {
+        const t = stmts[0];
+        const varName = t.scrutinee.kind === "var" ? t.scrutinee.name : "?";
+        const chain = { varName, typeName: t.typeName, cases: t.cases, fallthrough: t.fallthrough };
+        return transformPureMatch(chain, typeDecls);
     }
     for (let i = 0; i < stmts.length; i++) {
         const s = stmts[i];
@@ -1293,52 +1433,8 @@ function transformPureBody(stmts, typeDecls) {
                 return { kind: "let", name: s.name, value: transformExpr(s.init), body: restExpr };
             }
             case "if": {
-                // Restructure && with optional check: split into nested ifs so
-                // prepareOptionalMatch can detect the optional check and bind the unwrapped value
-                if (s.cond.kind === "binop" && s.cond.op === "&&" && s.else.length === 0) {
-                    const extracted = extractLeftmostOptional(s.cond);
-                    if (extracted) {
-                        const innerIf = { kind: "if", cond: extracted.rest, then: s.then, else: [] };
-                        const outerIf = { kind: "if", cond: extracted.optCond, then: [innerIf], else: [] };
-                        return transformPureBody([outerIf, ...rest], typeDecls);
-                    }
-                }
-                // Optional narrowing: if (x === undefined) → match x { None => ..., Some(x_val) => ... }
-                const optMatch = prepareOptionalMatch(s, rest);
-                if (optMatch) {
-                    // For field chains (a.dueDate !== undefined), replace in TStmt before transform
-                    let someBranch = [...optMatch.someBranch, ...rest];
-                    const fe = optMatch.check.fieldExpr;
-                    if (fe && fe.kind === "field" && fe.obj.kind === "var") {
-                        const innerTy = fe.ty.kind === "optional" ? fe.ty.inner : fe.ty;
-                        someBranch = replaceFieldsInTStmts(someBranch, fe.obj.name, [
-                            { fieldName: fe.field, newName: optMatch.bound, fallbackTy: innerTy },
-                        ]);
-                        // The replacement keeps the original optional type, but the match binding
-                        // unwraps it. Fix the type so downstream record coercion re-wraps with Some().
-                        someBranch = someBranch.map(s => mapTStmt(s, e => e.kind === "var" && e.name === optMatch.bound && e.ty.kind === "optional"
-                            ? { ...e, ty: e.ty.inner } : null));
-                    }
-                    const someExpr = transformPureBody(someBranch, typeDecls);
-                    if (!someExpr)
-                        return null;
-                    const noneExpr = transformPureBody(optMatch.noneBranch, typeDecls);
-                    if (!noneExpr)
-                        return null;
-                    // For simple vars, replace in Expr after transform
-                    const someReplaced = optMatch.check.fieldExpr
-                        ? someExpr
-                        : replaceVar(someExpr, optMatch.check.varName, { kind: "var", name: optMatch.bound }, true);
-                    return {
-                        kind: "match", scrutinee: optMatch.check.varName,
-                        arms: [
-                            { pattern: `.some ${optMatch.bound}`, body: someReplaced },
-                            { pattern: ".none", body: noneExpr },
-                        ],
-                    };
-                }
                 // Append rest to both branches so nested ifs that fall through
-                // can reach the continuation (e.g. early return inside then-branch)
+                // can reach the continuation (e.g. early return inside then-branch).
                 const thenExpr = transformPureBody([...s.then, ...rest], typeDecls);
                 if (!thenExpr)
                     return null;
@@ -1349,6 +1445,27 @@ function transformPureBody(stmts, typeDecls) {
                 return { kind: "if", cond: transformExpr(s.cond), then: thenExpr, else: elseExpr };
             }
             case "switch": return transformPureSwitch(s, typeDecls);
+            case "someMatch": {
+                const path = asTAccessPath(s.scrutinee);
+                if (path) {
+                    const replaced = replacePathInTStmts(s.someBody, path, s.binder, s.binderTy);
+                    const someExpr = transformPureBody([...replaced, ...rest], typeDecls);
+                    if (!someExpr)
+                        return null;
+                    const noneExpr = transformPureBody([...s.noneBody, ...rest], typeDecls);
+                    if (!noneExpr)
+                        return null;
+                    const scrutinee = path.fields.length === 0 ? path.rootVar : transformExpr(s.scrutinee);
+                    return {
+                        kind: "match", scrutinee,
+                        arms: [
+                            { pattern: `.some ${s.binder}`, body: someExpr },
+                            { pattern: ".none", body: noneExpr },
+                        ],
+                    };
+                }
+                throw new Error(`someMatch pure-body scrutinee must be a pure access path, got ${s.scrutinee.kind}`);
+            }
             default: return null;
         }
     }
@@ -1382,12 +1499,20 @@ function transformPureSwitch(s, typeDecls) {
 }
 function transformPureMatch(chain, typeDecls) {
     const cases = chain.cases.map(c => ({ name: c.variant, body: c.body }));
+    const decl = typeDecls.find(d => d.name === chain.typeName);
+    // Synth array-unions have single-field variants and user code refers to the
+    // scrutinee by its bare name, not field-accessed. See emitMatchStmt for
+    // the statement-level counterpart of this substitution.
+    const isSynthArrayUnion = decl?.discriminant === "__isArray__";
     const arms = buildMatchArms(cases, chain.varName, chain.typeName, typeDecls, (body, vn, fields) => {
         let result = transformPureBody(body, typeDecls);
         if (!result)
             return null;
         if (fields.length > 0 && vn)
             result = replaceFieldAccess(result, vn, fields);
+        if (isSynthArrayUnion && fields.length === 1 && vn) {
+            result = replaceVarInExpr(result, vn, matchBinder(fields[0].name, vn));
+        }
         return result;
     });
     if (!arms)
@@ -1395,13 +1520,27 @@ function transformPureMatch(chain, typeDecls) {
     // Idiomatic TS often has an unreachable fallthrough after exhaustive if-chains on
     // discriminated unions. Skip the catch-all arm when all variants are matched,
     // since Lean errors on redundant match arms.
-    const decl = typeDecls.find(d => d.name === chain.typeName);
     const allCovered = decl?.variants && chain.cases.length >= decl.variants.length;
     if (chain.fallthrough.length > 0 && !allCovered) {
-        const body = transformPureBody(chain.fallthrough, typeDecls);
-        if (!body)
-            return null;
-        arms.push({ pattern: "_", body });
+        const remaining = remainingVariant(chain.typeName, chain.cases, typeDecls);
+        if (remaining) {
+            // Exactly one variant left — destructure for variant-specific field access.
+            let body = transformPureBody(chain.fallthrough, typeDecls);
+            if (!body)
+                return null;
+            if (remaining.fields.length > 0)
+                body = replaceFieldAccess(body, chain.varName, remaining.fields);
+            if (isSynthArrayUnion && remaining.fields.length === 1) {
+                body = replaceVarInExpr(body, chain.varName, matchBinder(remaining.fields[0].name, chain.varName));
+            }
+            arms.push({ pattern: buildMatchPattern(remaining.name, remaining.fields, chain.varName), body });
+        }
+        else {
+            const body = transformPureBody(chain.fallthrough, typeDecls);
+            if (!body)
+                return null;
+            arms.push({ pattern: "_", body });
+        }
     }
     return { kind: "match", scrutinee: chain.varName, arms };
 }
@@ -1552,9 +1691,9 @@ export function transformModule(mod, specImport) {
             continue;
         const body = transformPureBody(fn.body, mod.typeDecls);
         if (body) {
-            // For ensures, replace \result (→ "res") with the function call
+            // For pure-function lemmas, replace \result with the function call.
             const fnCall = { kind: "app", fn: fn.name, args: fn.params.map(p => ({ kind: "var", name: p.name })) };
-            const ensures = fn.ensures.map(e => replaceVar(transformExpr(e), "res", fnCall));
+            const ensures = fn.ensures.map(e => replaceVar(transformExpr(e), "\\result", fnCall));
             pureDefs.push({
                 kind: "def",
                 name: fn.name,
@@ -1585,18 +1724,35 @@ export function transformModule(mod, specImport) {
         }
     }
     const base = mod.file.split("/").pop()?.replace(/\.ts$/, "") ?? "module";
+    // Externs: emit as top-of-file `function {:axiom}` (Dafny) declarations.
+    // Any `requires`/`ensures` from the source declaration come along so callers
+    // see the same spec the source itself verified. Substitute `\result` with the
+    // function call (same pattern as for in-file pure-function ensures).
+    const externDecls = (mod.externs ?? []).map(ext => {
+        const fnCall = { kind: "app", fn: ext.flat, args: ext.params.map(p => ({ kind: "var", name: p.name })) };
+        return {
+            kind: "extern",
+            name: ext.flat,
+            typeParams: ext.typeParams,
+            params: ext.params.map(p => ({ name: p.name, type: p.ty })),
+            returnType: ext.returnTy,
+            requires: ext.requires.map(transformExpr),
+            ensures: ext.ensures.map(e => replaceVar(transformExpr(e), "\\result", fnCall)),
+        };
+    });
     // Types file
     const typesImports = ["LemmaScript"];
     let typesFile = null;
     const pureNamespace = pureDefs.length > 0
         ? [{ kind: "namespace", name: "Pure", decls: pureDefs }]
         : [];
-    if (typeDecls.length > 0 || pureDefs.length > 0) {
+    if (typeDecls.length > 0 || pureDefs.length > 0 || externDecls.length > 0) {
         typesFile = {
             comment: "  Generated by lsc — Lean types and pure function mirrors.",
             imports: typesImports,
             options: [],
-            decls: [...typeDecls, ...pureNamespace],
+            // Externs come first so they're in scope for every later declaration.
+            decls: [...externDecls, ...typeDecls, ...pureNamespace],
         };
     }
     // Def file: Velvet methods