lemmascript 0.0.1 → 0.1.0

package/tools/dist/emit.js

@@ -0,0 +1,253 @@
+/**
+ * Lean IR → text. Trivial pretty-printer.
+ * No logic, no type decisions — just serialization.
+ */
+// ── Lean keyword escaping ────────────────────────────────────
+const LEAN_KEYWORDS = new Set([
+    "def", "theorem", "lemma", "example", "structure", "class", "instance",
+    "inductive", "where", "match", "with", "if", "then", "else", "do",
+    "let", "mut", "return", "for", "in", "while", "break", "continue",
+    "import", "open", "section", "namespace", "end", "set_option",
+    "variable", "axiom", "constant", "private", "protected", "noncomputable",
+    "partial", "unsafe", "macro", "syntax", "by", "fun", "have", "show",
+    "at", "from", "to", "deriving", "extends", "true", "false",
+]);
+function escapeName(name) {
+    return LEAN_KEYWORDS.has(name) ? `«${name}»` : name;
+}
+// ── Operator precedence (for parenthesization) ──────────────
+const PREC = {
+    "→": 1, "∨": 2, "∧": 3,
+    "=": 4, "≠": 4, "≥": 4, "≤": 4, ">": 4, "<": 4,
+    "+": 5, "-": 5, "*": 6, "/": 6, "%": 6,
+};
+function prec(op) { return PREC[op] ?? 10; }
+// ── Expression emission ─────────────────────────────────────
+function emitExpr(e, parentPrec) {
+    switch (e.kind) {
+        case "var": return escapeName(e.name);
+        case "num": return `${e.value}`;
+        case "bool": return e.value ? "true" : "false";
+        case "str": return `"${e.value}"`;
+        case "constructor": return `.${e.name}`;
+        case "arrayLiteral":
+            if (e.elems.length === 0)
+                return `#[]`;
+            return `#[${e.elems.map(el => emitExpr(el)).join(", ")}]`;
+        case "dotCall": {
+            const obj = emitExpr(e.obj);
+            const wrap = e.obj.kind === "binop" || e.obj.kind === "app" || e.obj.kind === "dotCall";
+            const receiver = wrap ? `(${obj})` : obj;
+            const args = e.args.map(a => (a.kind === "binop" || a.kind === "unop" || a.kind === "implies" || a.kind === "app") ? `(${emitExpr(a)})` : emitExpr(a));
+            return args.length > 0 ? `${receiver}.${e.method} ${args.join(" ")}` : `${receiver}.${e.method}`;
+        }
+        case "lambda": {
+            const params = e.params.map(p => p.name).join(" ");
+            // Single return statement → expression lambda
+            if (e.body.length === 1 && e.body[0].kind === "return") {
+                return `(fun ${params} => ${emitExpr(e.body[0].value)})`;
+            }
+            // Multi-statement → do block
+            return `(fun ${params} => do\n${emitStmts(e.body, 2)})`;
+        }
+        case "unop":
+            if (e.op === "¬")
+                return `¬(${emitExpr(e.expr)})`;
+            if (e.op === "-" && e.expr.kind === "num")
+                return `-${e.expr.value}`;
+            return `(-${emitExpr(e.expr)})`;
+        case "binop": {
+            const s = `${emitExpr(e.left, prec(e.op))} ${e.op} ${emitExpr(e.right, prec(e.op))}`;
+            return (parentPrec !== undefined && prec(e.op) < parentPrec) ? `(${s})` : s;
+        }
+        case "implies": {
+            const parts = [...e.premises.map(p => emitExpr(p)), emitExpr(e.conclusion)];
+            const s = parts.join(" → ");
+            return parentPrec !== undefined ? `(${s})` : s;
+        }
+        case "app": {
+            const args = e.args.map(a => (a.kind === "binop" || a.kind === "unop" || a.kind === "implies" || a.kind === "app") ? `(${emitExpr(a)})` : emitExpr(a));
+            return `${e.fn} ${args.join(" ")}`;
+        }
+        case "field": {
+            const obj = emitExpr(e.obj);
+            const wrap = e.obj.kind !== "var" && e.obj.kind !== "num" && e.obj.kind !== "bool";
+            return wrap ? `(${obj}).${escapeName(e.field)}` : `${obj}.${escapeName(e.field)}`;
+        }
+        case "toNat": {
+            const inner = emitExpr(e.expr);
+            const wrap = e.expr.kind !== "var" && e.expr.kind !== "num";
+            return wrap ? `(${inner}).toNat` : `${inner}.toNat`;
+        }
+        case "index":
+            return `${emitExpr(e.arr)}[${emitExpr(e.idx)}]!`;
+        case "record": {
+            const fields = e.fields.map(f => `${escapeName(f.name)} := ${emitExpr(f.value)}`);
+            if (e.spread)
+                return `{ ${emitExpr(e.spread)} with ${fields.join(", ")} }`;
+            return `{ ${fields.join(", ")} }`;
+        }
+        case "if":
+            return `if ${emitExpr(e.cond)} then ${emitExpr(e.then)} else ${emitExpr(e.else)}`;
+        case "match": {
+            const arms = e.arms.map(a => `| ${a.pattern} => ${emitExpr(a.body)}`);
+            return `match ${e.scrutinee} with ${arms.join(" ")}`;
+        }
+        case "forall": return `∀ ${e.var} : ${e.type}, ${emitExpr(e.body)}`;
+        case "exists": return `∃ ${e.var} : ${e.type}, ${emitExpr(e.body)}`;
+        case "let": return `let ${e.name} := ${emitExpr(e.value)}\n${emitExpr(e.body)}`;
+    }
+}
+// ── Statement emission ──────────────────────────────────────
+function emitStmts(stmts, indent) {
+    const pad = "  ".repeat(indent);
+    return stmts.map(s => emitStmt(s, indent)).join("\n");
+}
+function emitStmt(s, indent) {
+    const pad = "  ".repeat(indent);
+    switch (s.kind) {
+        case "let":
+            return s.mutable
+                ? `${pad}let mut ${escapeName(s.name)} : ${s.type} := ${emitExpr(s.value)}`
+                : `${pad}let ${escapeName(s.name)} := ${emitExpr(s.value)}`;
+        case "assign": return `${pad}${escapeName(s.target)} := ${emitExpr(s.value)}`;
+        case "bind": return `${pad}${escapeName(s.target)} ← ${emitExpr(s.value)}`;
+        case "let-bind": return `${pad}let ${s.name} ← ${emitExpr(s.value)}`;
+        case "return": return `${pad}return ${emitExpr(s.value)}`;
+        case "break": return `${pad}break`;
+        case "continue": return `${pad}continue`;
+        case "if": {
+            let out = `${pad}if ${emitExpr(s.cond)} then\n${emitStmts(s.then, indent + 1)}`;
+            if (s.else.length > 0) {
+                if (s.else.length === 1 && s.else[0].kind === "if") {
+                    const ei = s.else[0];
+                    out += `\n${pad}else if ${emitExpr(ei.cond)} then\n${emitStmts(ei.then, indent + 1)}`;
+                    if (ei.else.length > 0)
+                        out += `\n${pad}else\n${emitStmts(ei.else, indent + 1)}`;
+                }
+                else {
+                    out += `\n${pad}else\n${emitStmts(s.else, indent + 1)}`;
+                }
+            }
+            return out;
+        }
+        case "match": {
+            const lines = [`${pad}match ${s.scrutinee} with`];
+            for (const arm of s.arms) {
+                lines.push(`${pad}| ${arm.pattern} =>`);
+                lines.push(emitStmts(arm.body, indent + 1));
+            }
+            return lines.join("\n");
+        }
+        case "while": {
+            const lines = [`${pad}while ${emitExpr(s.cond)}`];
+            for (const inv of s.invariants)
+                lines.push(`${pad}  invariant ${emitExpr(inv)}`);
+            if (s.doneWith)
+                lines.push(`${pad}  done_with ${emitExpr(s.doneWith)}`);
+            if (s.decreasing)
+                lines.push(`${pad}  decreasing ${emitExpr(s.decreasing)}`);
+            lines.push(`${pad}do`);
+            lines.push(emitStmts(s.body, indent + 1));
+            return lines.join("\n");
+        }
+        case "forin": {
+            const lines = [`${pad}for ${s.idx} in [:${emitExpr(s.bound)}]`];
+            for (const inv of s.invariants)
+                lines.push(`${pad}  invariant ${emitExpr(inv)}`);
+            lines.push(`${pad}do`);
+            lines.push(emitStmts(s.body, indent + 1));
+            return lines.join("\n");
+        }
+    }
+}
+// ── Declaration emission ─────────────────────────────────────
+function emitDecl(d) {
+    switch (d.kind) {
+        case "inductive": {
+            const lines = [`inductive ${d.name} where`];
+            for (const c of d.constructors) {
+                if (c.fields.length === 0) {
+                    lines.push(`  | ${c.name} : ${d.name}`);
+                }
+                else {
+                    const params = c.fields.map(f => `(${escapeName(f.name)} : ${f.type})`).join(" ");
+                    lines.push(`  | ${c.name} ${params} : ${d.name}`);
+                }
+            }
+            if (d.deriving.length > 0)
+                lines.push(`deriving ${d.deriving.join(", ")}`);
+            return lines.join("\n");
+        }
+        case "structure": {
+            const lines = [`structure ${d.name} where`];
+            for (const f of d.fields)
+                lines.push(`  ${escapeName(f.name)} : ${f.type}`);
+            if (d.deriving.length > 0)
+                lines.push(`deriving ${d.deriving.join(", ")}`);
+            return lines.join("\n");
+        }
+        case "def": {
+            const params = d.params.map(p => `(${escapeName(p.name)} : ${p.type})`).join(" ");
+            return `def ${d.name} ${params} : ${d.returnType} :=\n${emitPureExpr(d.body, 1)}`;
+        }
+        case "method": {
+            const params = d.params.map(p => `(${escapeName(p.name)} : ${p.type})`).join(" ");
+            const lines = [`method ${d.name} ${params} return (res : ${d.returnType})`];
+            for (const r of d.requires)
+                lines.push(`  require ${emitExpr(r)}`);
+            for (const e of d.ensures)
+                lines.push(`  ensures ${emitExpr(e)}`);
+            lines.push("  do");
+            lines.push(emitStmts(d.body, 2));
+            return lines.join("\n");
+        }
+        case "namespace": {
+            const lines = [`namespace ${d.name}`];
+            for (const inner of d.decls)
+                lines.push("", emitDecl(inner));
+            lines.push("", `end ${d.name}`);
+            return lines.join("\n");
+        }
+    }
+}
+/** Emit a pure expression with indented if/match blocks. */
+function emitPureExpr(e, indent) {
+    const pad = "  ".repeat(indent);
+    switch (e.kind) {
+        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 lines = [`${pad}match ${e.scrutinee} with`];
+            for (const arm of e.arms) {
+                lines.push(`${pad}| ${arm.pattern} =>`);
+                lines.push(emitPureExpr(arm.body, indent + 1));
+            }
+            return lines.join("\n");
+        }
+        case "let":
+            return `${pad}let ${e.name} := ${emitExpr(e.value)}\n${emitPureExpr(e.body, indent)}`;
+        default:
+            return `${pad}${emitExpr(e)}`;
+    }
+}
+// ── File emission ────────────────────────────────────────────
+export function emitFile(file) {
+    const lines = [];
+    if (file.comment) {
+        lines.push("/-");
+        lines.push(file.comment);
+        lines.push("-/");
+    }
+    for (const imp of file.imports)
+        lines.push(`import ${imp}`);
+    if (file.options.length > 0)
+        lines.push("");
+    for (const opt of file.options)
+        lines.push(`set_option ${opt.key} ${opt.value}`);
+    for (const decl of file.decls) {
+        lines.push("");
+        lines.push(emitDecl(decl));
+    }
+    return lines.join("\n") + "\n";
+}

package/tools/dist/extract.js

@@ -0,0 +1,435 @@
+/**
+ * Extract — ts-morph → Raw IR.
+ *
+ * Produces structured AST nodes, not strings.
+ * The only strings are //@ annotation expressions (parsed later by specparser).
+ */
+import { Project, Node, SyntaxKind } from "ts-morph";
+// ── Expression extraction ────────────────────────────────────
+function extractExpr(node) {
+    // Numeric literal
+    if (Node.isNumericLiteral(node)) {
+        return { kind: "num", value: Number(node.getLiteralValue()) };
+    }
+    // String literal
+    if (Node.isStringLiteral(node)) {
+        return { kind: "str", value: node.getLiteralValue() };
+    }
+    // Boolean literals: true, false
+    if (Node.isTrueLiteral(node))
+        return { kind: "bool", value: true };
+    if (Node.isFalseLiteral(node))
+        return { kind: "bool", value: false };
+    // Identifier
+    if (Node.isIdentifier(node)) {
+        return { kind: "var", name: node.getText() };
+    }
+    // Property access: x.foo
+    if (Node.isPropertyAccessExpression(node)) {
+        return { kind: "field", obj: extractExpr(node.getExpression()), field: node.getName() };
+    }
+    // Element access: arr[i]
+    if (Node.isElementAccessExpression(node)) {
+        const arg = node.getArgumentExpression();
+        if (!arg)
+            throw new Error(`Missing index in element access: ${node.getText()}`);
+        return { kind: "index", obj: extractExpr(node.getExpression()), idx: extractExpr(arg) };
+    }
+    // Call expression: f(a, b)
+    if (Node.isCallExpression(node)) {
+        return {
+            kind: "call",
+            fn: extractExpr(node.getExpression()),
+            args: node.getArguments().map(a => extractExpr(a)),
+        };
+    }
+    // Binary expression: a + b, a === b, etc.
+    if (Node.isBinaryExpression(node)) {
+        const op = node.getOperatorToken().getText();
+        // Assignment: a = b → handled at statement level, but can appear in expressions
+        if (op === "=") {
+            // This is an assignment expression; extract as binop for now
+            return { kind: "binop", op: "=", left: extractExpr(node.getLeft()), right: extractExpr(node.getRight()) };
+        }
+        return { kind: "binop", op, left: extractExpr(node.getLeft()), right: extractExpr(node.getRight()) };
+    }
+    // Prefix unary: !x, -x
+    if (Node.isPrefixUnaryExpression(node)) {
+        const opToken = node.getOperatorToken();
+        let op;
+        switch (opToken) {
+            case SyntaxKind.ExclamationToken:
+                op = "!";
+                break;
+            case SyntaxKind.MinusToken:
+                op = "-";
+                break;
+            case SyntaxKind.PlusToken:
+                op = "+";
+                break;
+            default: op = String(opToken);
+        }
+        return { kind: "unop", op, expr: extractExpr(node.getOperand()) };
+    }
+    // Parenthesized: (x)
+    if (Node.isParenthesizedExpression(node)) {
+        return extractExpr(node.getExpression());
+    }
+    // Arrow function: (x) => expr or (x) => { stmts }
+    if (Node.isArrowFunction(node)) {
+        const params = node.getParameters().map(p => {
+            const typeNode = p.getTypeNode();
+            return { name: p.getName(), tsType: typeNode ? typeNode.getText() : undefined };
+        });
+        const body = node.getBody();
+        if (Node.isExpression(body)) {
+            return { kind: "lambda", params, body: extractExpr(body) };
+        }
+        if (Node.isBlock(body)) {
+            return { kind: "lambda", params, body: extractStmts(body.getStatements()) };
+        }
+        throw new Error(`Unsupported arrow function body: ${node.getText().slice(0, 80)}`);
+    }
+    // Array literal: [a, b, c] → arrayLiteral, [...arr, elem] → push(arr, elem)
+    if (Node.isArrayLiteralExpression(node)) {
+        const elems = node.getElements();
+        // [...arr, elem] → push(arr, elem)
+        if (elems.length === 2 && Node.isSpreadElement(elems[0])) {
+            return { kind: "call", fn: { kind: "field", obj: extractExpr(elems[0].getExpression()), field: "push" }, args: [extractExpr(elems[1])] };
+        }
+        // [a, b, c] or [] → arrayLiteral
+        return { kind: "arrayLiteral", elems: elems.map(e => extractExpr(e)) };
+    }
+    // Object literal: { res: true, done: false } or { ...obj, res: true }
+    if (Node.isObjectLiteralExpression(node)) {
+        let spread = null;
+        const fields = [];
+        for (const prop of node.getProperties()) {
+            if (Node.isSpreadAssignment(prop)) {
+                spread = extractExpr(prop.getExpression());
+            }
+            else if (Node.isPropertyAssignment(prop)) {
+                const init = prop.getInitializer();
+                if (init)
+                    fields.push({ name: prop.getName(), value: extractExpr(init) });
+            }
+        }
+        return { kind: "record", spread, fields };
+    }
+    // Ternary: cond ? then : else
+    if (Node.isConditionalExpression(node)) {
+        return { kind: "conditional", cond: extractExpr(node.getCondition()), then: extractExpr(node.getWhenTrue()), else: extractExpr(node.getWhenFalse()) };
+    }
+    throw new Error(`Unsupported expression: ${node.getText()}`);
+}
+// ── Annotation parsing ───────────────────────────────────────
+const PREFIX = "//@ ";
+const KEYWORDS = ["requires", "ensures", "invariant", "decreases", "done_with", "type"];
+function parseAnnotations(node) {
+    const result = [];
+    for (const range of node.getLeadingCommentRanges()) {
+        const text = range.getText().trim();
+        if (!text.startsWith(PREFIX))
+            continue;
+        const content = text.slice(PREFIX.length);
+        const sp = content.indexOf(" ");
+        if (sp === -1)
+            continue;
+        const kw = content.slice(0, sp);
+        if (!KEYWORDS.includes(kw))
+            continue;
+        result.push({ kind: kw, expr: content.slice(sp + 1).trim() });
+    }
+    return result;
+}
+function collectAnnotations(node, body) {
+    const own = parseAnnotations(node);
+    if (body && body.length > 0)
+        return [...own, ...parseAnnotations(body[0])];
+    return own;
+}
+// ── Type declaration extraction ──────────────────────────────
+function extractTypeDecl(decl) {
+    const name = decl.getName();
+    const type = decl.getType();
+    if (type.isUnion()) {
+        const members = type.getUnionTypes();
+        if (members.every(m => m.isStringLiteral())) {
+            return { name, kind: "string-union", values: members.map(m => m.getLiteralValue()) };
+        }
+        if (members.every(m => m.isObject())) {
+            const discriminant = findDiscriminant(members);
+            if (discriminant) {
+                const variants = members.map(m => {
+                    const tagProp = m.getProperty(discriminant);
+                    const tagType = tagProp?.getTypeAtLocation(decl);
+                    const tag = tagType?.getLiteralValue();
+                    const fields = [];
+                    for (const prop of m.getProperties()) {
+                        if (prop.getName() === discriminant)
+                            continue;
+                        fields.push({ name: prop.getName(), tsType: typeToString(prop.getTypeAtLocation(decl)) });
+                    }
+                    return { name: tag, fields };
+                });
+                return { name, kind: "discriminated-union", discriminant, variants };
+            }
+        }
+    }
+    if (type.isObject())
+        return extractRecord(name, type, decl);
+    return null;
+}
+function extractInterface(decl) {
+    // Collect field type overrides from trailing //@ type annotations
+    const overrides = new Map();
+    for (const member of decl.getMembers()) {
+        if (Node.isPropertySignature(member)) {
+            const text = member.getTrailingCommentRanges().map(r => r.getText()).join(" ");
+            const match = text.match(/\/\/@ type (\w+)/);
+            if (match)
+                overrides.set(member.getName(), match[1]);
+        }
+    }
+    return extractRecord(decl.getName(), decl.getType(), decl, overrides);
+}
+function extractRecord(name, type, locationNode, overrides) {
+    const props = type.getProperties();
+    if (props.length === 0)
+        return null;
+    const fields = [];
+    for (const prop of props) {
+        const override = overrides?.get(prop.getName());
+        const tsType = override ?? typeToString(prop.getTypeAtLocation(locationNode));
+        fields.push({ name: prop.getName(), tsType });
+    }
+    return { name, kind: "record", fields };
+}
+function findDiscriminant(members) {
+    if (members.length === 0)
+        return null;
+    const firstProps = members[0].getProperties();
+    for (const prop of firstProps) {
+        const name = prop.getName();
+        const allHave = members.every(m => {
+            const p = m.getProperty(name);
+            if (!p)
+                return false;
+            const t = p.getDeclarations()[0] ? p.getTypeAtLocation(p.getDeclarations()[0]) : null;
+            return t?.isStringLiteral() ?? false;
+        });
+        if (allHave)
+            return name;
+    }
+    return null;
+}
+function typeToString(type) {
+    if (type.isNumber())
+        return "number";
+    if (type.isString())
+        return "string";
+    if (type.isBoolean())
+        return "boolean";
+    if (type.isArray()) {
+        const elem = type.getArrayElementTypeOrThrow();
+        return `${typeToString(elem)}[]`;
+    }
+    const symbol = type.getSymbol() ?? type.getAliasSymbol();
+    if (symbol)
+        return symbol.getName();
+    return type.getText();
+}
+const COMPOUND_OPS = {
+    "+=": "+", "-=": "-", "*=": "*", "/=": "/", "%=": "%",
+};
+// ── Statement extraction ─────────────────────────────────────
+function extractStmts(stmts) {
+    const result = [];
+    for (const s of stmts) {
+        const line = s.getStartLineNumber();
+        if (Node.isVariableStatement(s)) {
+            for (const d of s.getDeclarations()) {
+                const declType = d.getType();
+                const init = d.getInitializer();
+                result.push({
+                    kind: "let",
+                    name: d.getName(),
+                    mutable: s.getDeclarationKind() === "let",
+                    tsType: typeToString(declType),
+                    init: init ? extractExpr(init) : { kind: "var", name: "default" },
+                    line,
+                });
+            }
+            continue;
+        }
+        if (Node.isWhileStatement(s)) {
+            const bodyNode = s.getStatement();
+            const bodyStmts = Node.isBlock(bodyNode) ? bodyNode.getStatements() : [];
+            const annots = collectAnnotations(s, bodyStmts);
+            result.push({
+                kind: "while",
+                cond: extractExpr(s.getExpression()),
+                invariants: annots.filter(a => a.kind === "invariant").map(a => a.expr),
+                decreases: annots.find(a => a.kind === "decreases")?.expr ?? null,
+                doneWith: annots.find(a => a.kind === "done_with")?.expr ?? null,
+                body: extractStmts(bodyStmts),
+                line,
+            });
+            continue;
+        }
+        if (Node.isForOfStatement(s)) {
+            const init = s.getInitializer();
+            const varName = Node.isVariableDeclarationList(init) ? init.getDeclarations()[0]?.getName() ?? "_" : "_";
+            const bodyNode = s.getStatement();
+            const bodyStmts = Node.isBlock(bodyNode) ? bodyNode.getStatements() : [bodyNode];
+            const annots = collectAnnotations(s, bodyStmts);
+            result.push({
+                kind: "forof",
+                varName,
+                iterable: extractExpr(s.getExpression()),
+                invariants: annots.filter(a => a.kind === "invariant").map(a => a.expr),
+                doneWith: annots.find(a => a.kind === "done_with")?.expr ?? null,
+                body: extractStmts(bodyStmts),
+                line,
+            });
+            continue;
+        }
+        if (Node.isIfStatement(s)) {
+            const thenNode = s.getThenStatement();
+            const elseNode = s.getElseStatement();
+            result.push({
+                kind: "if",
+                cond: extractExpr(s.getExpression()),
+                then: Node.isBlock(thenNode) ? extractStmts(thenNode.getStatements()) : extractStmts([thenNode]),
+                else: elseNode
+                    ? Node.isBlock(elseNode) ? extractStmts(elseNode.getStatements()) : extractStmts([elseNode])
+                    : [],
+                line,
+            });
+            continue;
+        }
+        if (Node.isSwitchStatement(s)) {
+            const exprNode = s.getExpression();
+            const exprAst = extractExpr(exprNode);
+            const discriminant = exprAst.kind === "field" ? exprAst.field : "";
+            const switchExpr = exprAst.kind === "field" ? exprAst.obj : exprAst;
+            const cases = [];
+            let defaultBody = [];
+            for (const clause of s.getClauses()) {
+                if (Node.isCaseClause(clause)) {
+                    const label = clause.getExpression().getText().replace(/^["']|["']$/g, "");
+                    const bodyStmts = clause.getStatements().filter(st => !Node.isBreakStatement(st));
+                    cases.push({ label, body: extractStmts(bodyStmts) });
+                }
+                else {
+                    const bodyStmts = clause.getStatements().filter(st => !Node.isBreakStatement(st));
+                    defaultBody = extractStmts(bodyStmts);
+                }
+            }
+            result.push({ kind: "switch", expr: switchExpr, discriminant, cases, defaultBody, line });
+            continue;
+        }
+        if (Node.isReturnStatement(s)) {
+            const expr = s.getExpression();
+            result.push({ kind: "return", value: expr ? extractExpr(expr) : { kind: "var", name: "()" }, line });
+            continue;
+        }
+        if (Node.isBreakStatement(s)) {
+            result.push({ kind: "break", line });
+            continue;
+        }
+        if (Node.isContinueStatement(s)) {
+            result.push({ kind: "continue", line });
+            continue;
+        }
+        if (Node.isExpressionStatement(s)) {
+            const expr = s.getExpression();
+            // x = e
+            if (Node.isBinaryExpression(expr) && expr.getOperatorToken().getText() === "=") {
+                result.push({ kind: "assign", target: expr.getLeft().getText(), value: extractExpr(expr.getRight()), line });
+                // x += e, x -= e, etc.
+            }
+            else if (Node.isBinaryExpression(expr) && COMPOUND_OPS[expr.getOperatorToken().getText()]) {
+                const op = COMPOUND_OPS[expr.getOperatorToken().getText()];
+                const target = expr.getLeft().getText();
+                result.push({ kind: "assign", target, value: { kind: "binop", op, left: { kind: "var", name: target }, right: extractExpr(expr.getRight()) }, line });
+                // i++, i--
+            }
+            else if (Node.isPostfixUnaryExpression(expr)) {
+                const target = expr.getOperand().getText();
+                const op = expr.getOperatorToken() === SyntaxKind.PlusPlusToken ? "+" : "-";
+                result.push({ kind: "assign", target, value: { kind: "binop", op, left: { kind: "var", name: target }, right: { kind: "num", value: 1 } }, line });
+                // ++i, --i
+            }
+            else if (Node.isPrefixUnaryExpression(expr) && (expr.getOperatorToken() === SyntaxKind.PlusPlusToken || expr.getOperatorToken() === SyntaxKind.MinusMinusToken)) {
+                const target = expr.getOperand().getText();
+                const op = expr.getOperatorToken() === SyntaxKind.PlusPlusToken ? "+" : "-";
+                result.push({ kind: "assign", target, value: { kind: "binop", op, left: { kind: "var", name: target }, right: { kind: "num", value: 1 } }, line });
+            }
+            else {
+                result.push({ kind: "expr", expr: extractExpr(expr), line });
+            }
+            continue;
+        }
+        throw new Error(`Unsupported statement at line ${line}: ${s.getText().slice(0, 80)}`);
+    }
+    return result;
+}
+// ── Function extraction ──────────────────────────────────────
+function extractFunction(fn) {
+    const body = fn.getBody();
+    if (!body || !Node.isBlock(body))
+        throw new Error(`${fn.getName()}: function body is not a block`);
+    const bodyStmts = body.getStatements();
+    const annots = collectAnnotations(fn, bodyStmts);
+    const typeAnnotations = [];
+    for (const a of annots) {
+        if (a.kind === "type") {
+            const parts = a.expr.split(/\s+/);
+            if (parts.length === 2)
+                typeAnnotations.push({ name: parts[0], type: parts[1] });
+        }
+    }
+    return {
+        name: fn.getName() ?? "<anonymous>",
+        params: fn.getParameters().map(p => ({ name: p.getName(), tsType: p.getTypeNode()?.getText() ?? "unknown" })),
+        returnType: fn.getReturnTypeNode()?.getText() ?? "unknown",
+        requires: annots.filter(a => a.kind === "requires").map(a => a.expr),
+        ensures: annots.filter(a => a.kind === "ensures").map(a => a.expr),
+        typeAnnotations,
+        body: extractStmts(bodyStmts),
+        line: fn.getStartLineNumber(),
+    };
+}
+// ── Module extraction ────────────────────────────────────────
+export function extractModule(sourceFile) {
+    const typeDecls = [];
+    // Extract type declarations in source order to respect dependencies
+    for (const stmt of sourceFile.getStatements()) {
+        if (Node.isTypeAliasDeclaration(stmt)) {
+            const info = extractTypeDecl(stmt);
+            if (info)
+                typeDecls.push(info);
+        }
+        else if (Node.isInterfaceDeclaration(stmt)) {
+            const info = extractInterface(stmt);
+            if (info)
+                typeDecls.push(info);
+        }
+    }
+    return {
+        file: sourceFile.getFilePath(),
+        typeDecls,
+        functions: sourceFile.getFunctions().map(extractFunction),
+    };
+}
+// ── Main ─────────────────────────────────────────────────────
+if (process.argv[1]?.match(/extract\.(ts|js)$/)) {
+    const file = process.argv[2];
+    if (!file) {
+        console.error("Usage: extract <file.ts>");
+        process.exit(1);
+    }
+    const proj = new Project({ compilerOptions: { strict: true } });
+    console.log(JSON.stringify(extractModule(proj.addSourceFileAtPath(file)), null, 2));
+}