agency-lang 0.0.85 → 0.0.87

package/dist/lib/backends/agencyGenerator.d.ts

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyMultiLineComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, Scope, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AgencyComment, AgencyMultiLineComment, AgencyNode, AgencyProgram, Assignment, DebuggerStatement, Literal, NewLine, Scope, TypeAlias, VariableType } from "../types.js";
 import { AccessChainElement, ValueAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
@@ -18,7 +18,6 @@ import { BinOpArgument, BinOpExpression, Operator } from "../types/binop.js";
 import { Keyword } from "../types/keyword.js";
 import { HandleBlock } from "../types/handleBlock.js";
 export declare class AgencyGenerator {
-    protected typeHints: TypeHintMap;
     protected graphNodes: GraphNodeDefinition[];
     protected generatedStatements: string[];
     protected generatedTypeAliases: string[];
@@ -48,7 +47,7 @@ export declare class AgencyGenerator {
     protected postprocess(): string;
     protected collectFunctionSignature(node: FunctionDefinition): void;
     protected processGraphNodeName(node: GraphNodeDefinition): void;
-    protected processNode(node: AgencyNode): string;
+    processNode(node: AgencyNode): string;
     protected needsParensLeft(child: BinOpArgument, parentOp: Operator): boolean;
     protected needsParensRight(child: BinOpArgument, parentOp: Operator): boolean;
     protected startScope(scope: Scope): void;
@@ -63,7 +62,6 @@ export declare class AgencyGenerator {
     private stringifyProp;
     protected aliasedTypeToString(aliasedType: VariableType): string;
     protected processTypeAlias(node: TypeAlias): string;
-    protected processTypeHint(node: TypeHint): string;
     protected processAssignment(node: Assignment): string;
     protected generateLiteral(literal: Literal): string;
     private generateStringLiteral;
@@ -80,6 +78,7 @@ export declare class AgencyGenerator {
     protected processWhileLoop(node: WhileLoop): string;
     protected processIfElse(node: IfElse): string;
     protected processReturnStatement(node: ReturnStatement): string;
+    protected processDebuggerStatement(node: DebuggerStatement): string;
     protected processComment(node: AgencyComment): string;
     protected processMultiLineComment(node: AgencyMultiLineComment): string;
     protected processImportStatement(node: ImportStatement): string;

package/dist/lib/backends/agencyGenerator.js

@@ -3,7 +3,6 @@ import { mergeDeep } from "../utils.js";
 import { PRECEDENCE, } from "../types/binop.js";
 import { expressionToString } from "../utils/node.js";
 export class AgencyGenerator {
-    typeHints = {};
     graphNodes = [];
     generatedStatements = [];
     generatedTypeAliases = [];
@@ -35,19 +34,13 @@ export class AgencyGenerator {
                 this.processTypeAlias(node);
             }
         }
-        // Pass 2: Collect all type hints
-        for (const node of program.nodes) {
-            if (node.type === "typeHint") {
-                this.processTypeHint(node);
-            }
-        }
-        // Pass 3: Collect all node names
+        // Pass 2: Collect all node names
         for (const node of program.nodes) {
             if (node.type === "graphNode") {
                 this.processGraphNodeName(node);
             }
         }
-        // Pass 4: Collect all node and tool imports
+        // Pass 3: Collect all node and tool imports
         for (const node of program.nodes) {
             if (node.type === "importNodeStatement") {
                 this.importedNodes.push(node);
@@ -56,7 +49,7 @@ export class AgencyGenerator {
                 this.importedTools.push(node);
             }
         }
-        // Pass 5: Generate code for tools
+        // Pass 4: Generate code for tools
         for (const node of program.nodes) {
             if (node.type === "function") {
                 this.generatedStatements.push(this.processTool(node));
@@ -64,10 +57,33 @@ export class AgencyGenerator {
             }
         }
         this.preprocessAST();
-        // Pass 7: Process all nodes and generate code
+        // Types that should have a blank line before/after them at the top level
+        const BLOCK_TYPES = new Set([
+            "graphNode", "function", "typeAlias",
+        ]);
+        const NO_SPACE_TYPES = new Set([
+            "comment", "multiLineComment"
+        ]);
+        // Pass 5: Process all nodes and generate code
+        const stmtPairs = [];
         for (const node of program.nodes) {
             const result = this.processNode(node);
-            this.generatedStatements.push(result);
+            if (result !== "") {
+                stmtPairs.push({ type: node.type, code: result });
+            }
+        }
+        // Join top-level statements: blank line between block declarations,
+        // single newline between simple statements
+        const stmtLines = [];
+        for (let i = 0; i < stmtPairs.length; i++) {
+            if (i > 0) {
+                const prev = stmtPairs[i - 1];
+                const curr = stmtPairs[i];
+                if (BLOCK_TYPES.has(prev.type) || (BLOCK_TYPES.has(curr.type) && !NO_SPACE_TYPES.has(prev.type))) {
+                    stmtLines.push(""); // blank line
+                }
+            }
+            stmtLines.push(stmtPairs[i].code);
         }
         const output = [];
         this.addIfNonEmpty(this.preprocess(), output);
@@ -75,7 +91,7 @@ export class AgencyGenerator {
         this.addIfNonEmpty(this.generateImports(), output);
         this.addIfNonEmpty(this.generateBuiltins(), output);
         output.push(...this.generatedTypeAliases);
-        output.push(this.generatedStatements.join(""));
+        output.push(stmtLines.join("\n"));
         this.addIfNonEmpty(this.postprocess(), output);
         return {
             output: output.join("\n"),
@@ -105,8 +121,6 @@ export class AgencyGenerator {
     processGraphNodeName(node) { }
     processNode(node) {
         switch (node.type) {
-            case "typeHint":
-                return this.processTypeHint(node);
             case "typeAlias":
                 return this.processTypeAlias(node);
             case "assignment":
@@ -128,9 +142,12 @@ export class AgencyGenerator {
             case "string":
             case "variableName":
             case "boolean":
+            case "null":
                 return this.generateLiteral(node);
             case "returnStatement":
                 return this.processReturnStatement(node);
+            case "debuggerStatement":
+                return this.processDebuggerStatement(node);
             case "agencyArray":
                 return this.processAgencyArray(node);
             case "agencyObject":
@@ -195,8 +212,8 @@ export class AgencyGenerator {
     }
     isImportedTool(functionName) {
         return this.importedTools
-            .map((node) => node.importedTools)
-            .flat()
+            .flatMap((node) => node.importedTools)
+            .flatMap((n) => n.importedNames)
             .includes(functionName);
     }
     isAgencyFunction(functionName, context) {
@@ -261,11 +278,6 @@ export class AgencyGenerator {
         const aliasedTypeStr = this.aliasedTypeToString(node.aliasedType);
         return this.indentStr(`type ${node.aliasName} = ${aliasedTypeStr}`);
     }
-    processTypeHint(node) {
-        this.typeHints[node.variableName] = node.variableType;
-        const typeStr = variableTypeToString(node.variableType, this.typeAliases);
-        return this.indentStr(`${node.variableName} :: ${typeStr}`);
-    }
     // Assignment and literals
     processAssignment(node) {
         const chainStr = node.accessChain
@@ -274,9 +286,10 @@ export class AgencyGenerator {
         const varName = node.typeHint
             ? `${node.variableName}${chainStr}: ${variableTypeToString(node.typeHint, this.typeAliases)}`
             : `${node.variableName}${chainStr}`;
-        const prefix = node.shared ? "shared " : "";
+        const sharedPrefix = node.shared ? "shared " : "";
+        const declPrefix = node.declKind ? `${node.declKind} ` : "";
         let valueCode = this.processNode(node.value).trim();
-        return this.indentStr(`${prefix}${varName} = ${valueCode}`);
+        return this.indentStr(`${sharedPrefix}${declPrefix}${varName} = ${valueCode}`);
     }
     generateLiteral(literal) {
         switch (literal.type) {
@@ -290,6 +303,8 @@ export class AgencyGenerator {
                 return this.generateMultiLineStringLiteral(literal);
             case "boolean":
                 return literal.value ? "true" : "false";
+            case "null":
+                return "null";
             default:
                 return "";
         }
@@ -328,12 +343,16 @@ export class AgencyGenerator {
         const { functionName, body, parameters } = node;
         const params = parameters
             .map((p) => {
+            const prefix = p.variadic ? "..." : "";
+            const defaultSuffix = p.defaultValue
+                ? ` = ${this.processNode(p.defaultValue).trim()}`
+                : "";
             if (p.typeHint) {
                 const typeStr = variableTypeToString(p.typeHint, this.typeAliases);
-                return `${p.name}: ${typeStr}`;
+                return `${prefix}${p.name}: ${typeStr}${defaultSuffix}`;
             }
             else {
-                return p.name;
+                return `${prefix}${p.name}${defaultSuffix}`;
             }
         })
             .join(", ");
@@ -341,14 +360,8 @@ export class AgencyGenerator {
             ? ": " + variableTypeToString(node.returnType, this.typeAliases)
             : "";
         let safePrefix = node.safe ? "safe " : "";
-        let asyncPrefix = "";
-        if (node.async === true) {
-            asyncPrefix = "async ";
-        }
-        else if (node.async === false) {
-            asyncPrefix = "sync ";
-        }
-        let result = this.indentStr(`${safePrefix}${asyncPrefix}def ${functionName}(${params})${returnTypeStr} {\n`);
+        const exportPrefix = node.exported ? "export " : "";
+        let result = this.indentStr(`${exportPrefix}${safePrefix}def ${functionName}(${params})${returnTypeStr} {\n`);
         this.increaseIndent();
         if (node.docString) {
             const docLines = [`"""`, ...node.docString.value.split("\n"), `"""`];
@@ -359,7 +372,7 @@ export class AgencyGenerator {
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
-        const bodyCode = lines.join("").trimEnd() + "\n";
+        const bodyCode = lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         result += bodyCode;
         this.decreaseIndent();
         result += this.indentStr(`}`);
@@ -371,6 +384,12 @@ export class AgencyGenerator {
     }
     generateFunctionCallExpression(node, context) {
         const args = node.arguments.map((arg) => {
+            if (arg.type === "namedArgument") {
+                return `${arg.name}: ${this.processNode(arg.value).trim()}`;
+            }
+            if (arg.type === "splat") {
+                return `...${this.processNode(arg.value).trim()}`;
+            }
             return this.processNode(arg).trim();
         });
         let asyncPrefix = "";
@@ -380,7 +399,26 @@ export class AgencyGenerator {
         else if (node.async === false) {
             asyncPrefix = "await ";
         }
-        return `${asyncPrefix}${node.functionName}(${args.join(", ")})`;
+        let result = `${asyncPrefix}${node.functionName}(${args.join(", ")})`;
+        if (node.block) {
+            const block = node.block;
+            let asClause = "as ";
+            if (block.params.length === 1) {
+                asClause = `as ${block.params[0].name} `;
+            }
+            else if (block.params.length > 1) {
+                asClause = `as (${block.params.map((p) => p.name).join(", ")}) `;
+            }
+            this.increaseIndent();
+            const bodyLines = [];
+            for (const stmt of block.body) {
+                bodyLines.push(this.processNode(stmt));
+            }
+            this.decreaseIndent();
+            const bodyStr = bodyLines.filter((s) => s !== "").join("\n").trimEnd() + "\n";
+            result += ` ${asClause}{\n${bodyStr}${this.indentStr("}")}`;
+        }
+        return result;
     }
     // Data structures
     processAgencyArray(node) {
@@ -459,9 +497,11 @@ export class AgencyGenerator {
             : node.itemVar;
         let result = this.indentStr(`for (${vars} in ${iterableCode}) {\n`);
         this.increaseIndent();
+        const lines = [];
         for (const stmt of node.body) {
-            result += this.processNode(stmt);
+            lines.push(this.processNode(stmt));
         }
+        result += lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         this.decreaseIndent();
         result += this.indentStr(`}`);
         return result;
@@ -470,9 +510,11 @@ export class AgencyGenerator {
         const conditionCode = this.processNode(node.condition).trim();
         let result = this.indentStr(`while (${conditionCode}) {\n`);
         this.increaseIndent();
+        const lines = [];
         for (const stmt of node.body) {
-            result += this.processNode(stmt);
+            lines.push(this.processNode(stmt));
         }
+        result += lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         this.decreaseIndent();
         result += this.indentStr(`}`);
         return result;
@@ -487,7 +529,7 @@ export class AgencyGenerator {
             bodyLines.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        lines.push(bodyLines.join("").trimEnd() + "\n");
+        lines.push(bodyLines.filter(s => s !== "").join("\n").trimEnd() + "\n");
         if (node.elseBody && node.elseBody.length > 0) {
             if (node.elseBody.length === 1 && node.elseBody[0].type === "ifElse") {
                 const elseIfCode = this.processIfElse(node.elseBody[0]);
@@ -502,7 +544,7 @@ export class AgencyGenerator {
                     elseBodyLines.push(this.processNode(stmt));
                 }
                 this.decreaseIndent();
-                lines.push(elseBodyLines.join("").trimEnd() + "\n");
+                lines.push(elseBodyLines.filter(s => s !== "").join("\n").trimEnd() + "\n");
             }
         }
         lines.push(this.indentStr(`}`));
@@ -512,6 +554,9 @@ export class AgencyGenerator {
         const valueCode = this.processNode(node.value).trim();
         return this.indentStr(`return ${valueCode}`);
     }
+    processDebuggerStatement(node) {
+        return this.indentStr(node.label ? `debugger(${JSON.stringify(node.label)})` : "debugger()");
+    }
     // Utility methods
     processComment(node) {
         return this.indentStr(`//${node.content}`);
@@ -521,7 +566,10 @@ export class AgencyGenerator {
     }
     processImportStatement(node) {
         const importedNames = node.importedNames.map((name) => this.processImportNameType(name));
-        const str = this.indentStr(`import ${importedNames.join(", ")} from "${node.modulePath}"`);
+        const modulePath = node.modulePath.startsWith("std::")
+            ? node.modulePath.replace(/\.agency$/, "")
+            : node.modulePath;
+        const str = this.indentStr(`import ${importedNames.join(", ")} from "${modulePath}"`);
         return str;
     }
     processImportNameType(node) {
@@ -540,7 +588,8 @@ export class AgencyGenerator {
         return `import node { ${node.importedNodes.join(", ")} } from "${node.agencyFile}"`;
     }
     processImportToolStatement(node) {
-        return `import tool { ${node.importedTools.join(", ")} } from "${node.agencyFile}"`;
+        const toolNames = node.importedTools.flatMap((n) => n.importedNames);
+        return `import tool { ${toolNames.join(", ")} } from "${node.agencyFile}"`;
     }
     visibilityToString(vis) {
         switch (vis) {
@@ -569,7 +618,7 @@ export class AgencyGenerator {
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
-        const bodyCode = lines.join("").trimEnd() + "\n";
+        const bodyCode = lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         result += bodyCode;
         this.decreaseIndent();
         result += this.indentStr(`}`);
@@ -585,7 +634,7 @@ export class AgencyGenerator {
         return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}`);
     }
     processNewLine(_node) {
-        return "\n";
+        return "";
     }
     processMessageThread(node) {
         this.increaseIndent();
@@ -594,7 +643,7 @@ export class AgencyGenerator {
             bodyCodes.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        const bodyCodeStr = bodyCodes.join("");
+        const bodyCodeStr = bodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
         const threadType = node.threadType;
         return this.indentStr(`${threadType} {\n${bodyCodeStr}${this.indentStr("}")}`);
     }
@@ -605,7 +654,7 @@ export class AgencyGenerator {
             bodyCodes.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        const bodyCodeStr = bodyCodes.join("");
+        const bodyCodeStr = bodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
         let handlerStr;
         if (node.handler.kind === "inline") {
             const paramStr = node.handler.param.typeHint
@@ -617,7 +666,7 @@ export class AgencyGenerator {
                 handlerBodyCodes.push(this.processNode(stmt));
             }
             this.decreaseIndent();
-            const handlerBodyStr = handlerBodyCodes.join("");
+            const handlerBodyStr = handlerBodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
             handlerStr = `(${paramStr}) {\n${handlerBodyStr}${this.indentStr("}")}`;
         }
         else {

package/dist/lib/backends/agencyGenerator.test.js

@@ -57,7 +57,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         ];
         testCases.forEach(({ description, input, expectedOutput }) => {
             it(`should correctly generate ${description}`, () => {
-                const parseResult = parseAgency(input);
+                const parseResult = parseAgency(input, {}, false);
                 expect(parseResult.success).toBe(true);
                 if (!parseResult.success)
                     return;
@@ -73,7 +73,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
     describe("Type preservation", () => {
         it("should preserve primitive types", () => {
             const input = "def test(n: number, s: string, b: boolean) { n }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -85,7 +85,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve array types", () => {
             const input = "def test(nums: number[], strs: string[]) { nums }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -96,7 +96,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve union types", () => {
             const input = "def test(val: string | number | boolean) { val }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -106,7 +106,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve nested array types", () => {
             const input = "def test(matrix: number[][]) { matrix }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -118,7 +118,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
     describe("Mixed typed and untyped parameters", () => {
         it("should handle first parameter typed, second untyped", () => {
             const input = "def test(x: number, y) { x }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -130,7 +130,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should handle first parameter untyped, second typed", () => {
             const input = "def test(x, y: string) { x }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -142,7 +142,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should handle alternating typed and untyped parameters", () => {
             const input = "def test(a, b: number, c, d: string) { a }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;

package/dist/lib/backends/index.d.ts

@@ -1 +1,2 @@
 export * from "./typescriptGenerator.js";
+export * from "./sourceMap.js";

package/dist/lib/backends/index.js

@@ -1 +1,2 @@
 export * from "./typescriptGenerator.js";
+export * from "./sourceMap.js";

package/dist/lib/backends/sourceMap.d.ts

@@ -0,0 +1,13 @@
+import type { SourceLocation } from "../types/base.js";
+export type SourceMapLocation = {
+    line: number;
+    col: number;
+};
+export type SourceMap = Record<string, Record<string, SourceMapLocation>>;
+export declare class SourceMapBuilder {
+    private currentKey;
+    private map;
+    enterScope(moduleId: string, scopeName: string): void;
+    record(subStepPath: number[], loc: SourceLocation | undefined): void;
+    build(): SourceMap;
+}

package/dist/lib/backends/sourceMap.js

@@ -0,0 +1,18 @@
+export class SourceMapBuilder {
+    currentKey = "";
+    map = {};
+    enterScope(moduleId, scopeName) {
+        this.currentKey = `${moduleId}:${scopeName}`;
+        if (!this.map[this.currentKey]) {
+            this.map[this.currentKey] = {};
+        }
+    }
+    record(subStepPath, loc) {
+        if (!loc || !this.currentKey)
+            return;
+        this.map[this.currentKey][subStepPath.join(".")] = { line: loc.line, col: loc.col };
+    }
+    build() {
+        return structuredClone(this.map);
+    }
+}

package/dist/lib/backends/sourceMap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/backends/sourceMap.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { SourceMapBuilder } from "./sourceMap.js";
+describe("SourceMapBuilder", () => {
+    it("records entries and builds correct structure", () => {
+        const builder = new SourceMapBuilder();
+        builder.enterScope("foo.agency", "main");
+        builder.record([0], { line: 1, col: 2, start: 0, end: 10 });
+        builder.record([1], { line: 3, col: 2, start: 20, end: 30 });
+        const result = builder.build();
+        expect(result).toEqual({
+            "foo.agency:main": {
+                "0": { line: 1, col: 2 },
+                "1": { line: 3, col: 2 },
+            },
+        });
+    });
+    it("handles multiple scopes", () => {
+        const builder = new SourceMapBuilder();
+        builder.enterScope("foo.agency", "main");
+        builder.record([0], { line: 1, col: 2, start: 0, end: 10 });
+        builder.enterScope("foo.agency", "greet");
+        builder.record([0], { line: 5, col: 2, start: 50, end: 60 });
+        const result = builder.build();
+        expect(result).toHaveProperty("foo.agency:main");
+        expect(result).toHaveProperty("foo.agency:greet");
+    });
+    it("silently skips undefined loc", () => {
+        const builder = new SourceMapBuilder();
+        builder.enterScope("foo.agency", "main");
+        builder.record([0], undefined);
+        builder.record([1], { line: 3, col: 2, start: 20, end: 30 });
+        const result = builder.build();
+        expect(result["foo.agency:main"]).toEqual({
+            "1": { line: 3, col: 2 },
+        });
+    });
+    it("formats substep paths with dot separator", () => {
+        const builder = new SourceMapBuilder();
+        builder.enterScope("foo.agency", "main");
+        builder.record([2, 0, 1], { line: 10, col: 4, start: 100, end: 120 });
+        const result = builder.build();
+        expect(result["foo.agency:main"]).toHaveProperty("2.0.1");
+    });
+    it("returns empty object when nothing recorded", () => {
+        const builder = new SourceMapBuilder();
+        expect(builder.build()).toEqual({});
+    });
+    it("build returns a copy, not the internal reference", () => {
+        const builder = new SourceMapBuilder();
+        builder.enterScope("foo.agency", "main");
+        builder.record([0], { line: 1, col: 2, start: 0, end: 10 });
+        const result1 = builder.build();
+        result1["foo.agency:main"]["0"].line = 999;
+        const result2 = builder.build();
+        expect(result2["foo.agency:main"]["0"].line).toBe(1);
+    });
+});

package/dist/lib/backends/typescriptBuilder.d.ts

@@ -15,12 +15,17 @@ export declare class TypeScriptBuilder {
     private loopVars;
     private insideMessageThread;
     private insideHandlerBody;
+    private _blockCounter;
+    /** Stack of loop subKeys for generating break/continue cleanup code.
+     * Pushed when entering a stepped loop, popped when leaving. */
+    private _loopContextStack;
     private _asyncBranchCheckNeeded;
     /** Tracks the current substep nesting path. Empty when at the top level
      * of a stepped body. Non-empty when inside a block (if/else, etc.) that
      * has been broken into substeps. Used to generate unique variable names
      * like __substep_3_1 for nested blocks. */
     private _subStepPath;
+    private _sourceMapBuilder;
     private programInfo;
     private moduleId;
     /**
@@ -44,9 +49,11 @@ export declare class TypeScriptBuilder {
      */
     private scopedAssign;
     private currentScopeKey;
-    private getTypeHint;
+    /** Returns the name of the current scope (function, node, or block name, or empty string for global). */
+    private currentScopeName;
+    /** Returns the template opts for checkpoint creation (moduleId, scopeName, stepPath as JSON-quoted strings). */
+    private checkpointOpts;
     private getVisibleTypeAliases;
-    private getVisibleTypeHints;
     private forkBranchSetup;
     private isImportedTool;
     private static RUNTIME_STATEFUL_FUNCTIONS;
@@ -59,9 +66,19 @@ export declare class TypeScriptBuilder {
     private needsParensLeft;
     private needsParensRight;
     build(program: AgencyProgram): TsNode;
+    /** Named args are cosmetic/positional — validate name matches the param at that index. */
+    private validateNamedArgs;
+    /** Process a function call argument, unwrapping NamedArgument and SplatExpression. */
+    private processCallArg;
+    /**
+     * Adjust call-site arguments to match the function's parameter list:
+     * 1. Pad omitted optional args (those with defaults) with null
+     * 2. Wrap extra args into an array for variadic params
+     */
+    private adjustCallArgs;
     private processNode;
+    private processKeyword;
     private processTypeAlias;
-    private processTypeHint;
     private processComment;
     private processAgencyObject;
     private processAgencyArray;
@@ -86,6 +103,7 @@ export declare class TypeScriptBuilder {
     private generateToolRegistry;
     private processFunctionDefinition;
     private processStatement;
+    private buildInterruptReturn;
     private processFunctionCallAsStatement;
     private processFunctionCall;
     private generateFunctionCallExpression;
@@ -101,11 +119,16 @@ export declare class TypeScriptBuilder {
      * response format from type hints, and tools from config object.
      */
     private processLlmCall;
-    private buildPromptString;
+    private processSentinel;
+    private processDebuggerStatement;
     private processSpecialVar;
     private processMessageThread;
     private processBlockPlain;
     private processHandleBlockWithSteps;
+    /** In debugger mode, insert debuggerStatement nodes before each
+     *  step-triggering statement so that debugStep() is called at every
+     *  substep boundary, not just top-level steps. */
+    private insertDebugSteps;
     private processBodyAsParts;
     private generateBuiltins;
     private generateImports;