@opencode/codemode 0.0.0-dev-19567 → 0.0.0-dev-19570

package/dist/interpreter/model.d.ts

@@ -5,7 +5,11 @@ import type { DiagnosticKind } from "../codemode.js";
 import type { ProgramError } from "./objects.js";
 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
 export type AstNode = Node;
-export declare const CallSite: Context.Reference<Node | undefined>;
+/** The program call a built-in is running under: where to locate failures born inside it, and how deep the stack is there. */
+export declare const CallSite: Context.Reference<{
+    readonly node?: AstNode;
+    readonly depth: number;
+}>;
 export type Binding = {
     mutable: boolean;
     value: unknown;

package/dist/interpreter/model.js

@@ -1,5 +1,8 @@
 import { Context } from "effect";
-export const CallSite = Context.Reference("codemode/CallSite", { defaultValue: () => undefined });
+/** The program call a built-in is running under: where to locate failures born inside it, and how deep the stack is there. */
+export const CallSite = Context.Reference("codemode/CallSite", {
+    defaultValue: () => ({ depth: 0 }),
+});
 export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
 export const IteratorSymbol = Symbol("codemode.iterator");
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];

package/dist/interpreter/promises.js

@@ -35,7 +35,7 @@ export class PromiseRuntime {
         return Effect.flatMap(CallSite, (site) => {
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
             const id = this.nextID++;
-            const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site)));
+            const body = Effect.catchDefect(effect, (defect) => Effect.die(locate(defect, site.node)));
             return Effect.map(Effect.forkIn(body, this.scope, { startImmediately: true }), (fiber) => {
                 const promise = new ProgramPromise(this.proto, fiber);
                 this.active.add(promise);

package/dist/interpreter/runtime.js

@@ -175,15 +175,20 @@ export class Runtime {
         return this.root.run(program);
     }
 }
+const MAX_CALL_DEPTH = 10_000;
 /** One activation: the top-level program or a single function call, evaluating against its own scope chain. */
 class Frame {
     runtime;
     scopes;
+    depth;
     generatorState;
     generatorAsync = false;
-    constructor(runtime, scopes) {
+    constructor(runtime, scopes, 
+    /** Nested call depth; resets when an await resumes, since the continuation runs from the job queue. */
+    depth = 0) {
         this.runtime = runtime;
         this.scopes = scopes;
+        this.depth = depth;
     }
     run(program) {
         const self = this;
@@ -523,7 +528,7 @@ class Frame {
         })));
     }
     awaitValue(value) {
-        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value), (promise) => this.settlePromise(promise));
+        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value), (promise) => Effect.ensuring(this.settlePromise(promise), Effect.sync(() => (this.depth = 0))));
     }
     awaitAsyncFromSyncValue(iterator, value, node, closeOnRejection) {
         const self = this;
@@ -1280,7 +1285,7 @@ class Frame {
                 return yield* self.createToolCallPromise(callable.path, args);
             }
             if (callable instanceof ProgramFunction)
-                return yield* self.invokeFunction(callable, args);
+                return yield* self.invokeFunction(callable, args, node);
             if (callable instanceof NativeFunction) {
                 return yield* self.native(() => callable.call(thisValue, args), node);
             }
@@ -1289,7 +1294,7 @@ class Frame {
     }
     // Built-ins throw without a location, synchronously or inside their Effect; the call site supplies it.
     native(body, node) {
-        return Effect.provideService(Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))), CallSite, node);
+        return Effect.provideService(Effect.catchDefect(Effect.suspend(body), (defect) => Effect.die(locate(defect, node))), CallSite, { node, depth: this.depth });
     }
     evaluateCallArguments(argNodes) {
         const self = this;
@@ -1315,37 +1320,43 @@ class Frame {
             return args;
         });
     }
-    invokeFunction(fn, args) {
+    // A callback invoked by a built-in runs below the call that invoked the built-in, so the deeper of the two counts.
+    invokeFunction(fn, args, node) {
         const self = this;
-        const invocation = new Frame(this.runtime, new ScopeStack([...fn.capturedScopes, new Map()]));
-        const run = Effect.gen(function* () {
-            // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
-            const paramScope = invocation.scopes.current();
-            for (const parameter of fn.parameters) {
-                for (const name of collectPatternNames(parameter)) {
-                    paramScope.set(name, { mutable: true, value: undefined, initialized: false });
+        return Effect.flatMap(CallSite, (site) => {
+            const depth = Math.max(self.depth, site.depth) + 1;
+            if (depth > MAX_CALL_DEPTH)
+                throw rangeError("Maximum call stack size exceeded", node);
+            const invocation = new Frame(this.runtime, new ScopeStack([...fn.capturedScopes, new Map()]), depth);
+            const run = Effect.gen(function* () {
+                // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
+                const paramScope = invocation.scopes.current();
+                for (const parameter of fn.parameters) {
+                    for (const name of collectPatternNames(parameter)) {
+                        paramScope.set(name, { mutable: true, value: undefined, initialized: false });
+                    }
                 }
-            }
-            for (const [index, parameter] of fn.parameters.entries()) {
-                if (parameter.type === "RestElement") {
-                    yield* invocation.declarePattern(parameter.argument, new ProgramArray(self.runtime.prototypes.Array, args.slice(index)), true, parameter, true);
-                    break;
+                for (const [index, parameter] of fn.parameters.entries()) {
+                    if (parameter.type === "RestElement") {
+                        yield* invocation.declarePattern(parameter.argument, new ProgramArray(self.runtime.prototypes.Array, args.slice(index)), true, parameter, true);
+                        break;
+                    }
+                    yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
                 }
-                yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
-            }
-            if (fn.body.type === "BlockStatement") {
-                invocation.scopes.push();
-                invocation.hoistVars(fn.body.body, paramScope);
-                const result = yield* invocation.evaluateStatement(fn.body);
-                return result.kind === "return" ? result.value : undefined;
-            }
-            return yield* invocation.evaluateExpression(fn.body);
+                if (fn.body.type === "BlockStatement") {
+                    invocation.scopes.push();
+                    invocation.hoistVars(fn.body.body, paramScope);
+                    const result = yield* invocation.evaluateStatement(fn.body);
+                    return result.kind === "return" ? result.value : undefined;
+                }
+                return yield* invocation.evaluateExpression(fn.body);
+            });
+            if (fn.generator)
+                return Effect.succeed(this.createGenerator(invocation, run, fn.async));
+            if (!fn.async)
+                return run;
+            return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, self)));
         });
-        if (fn.generator)
-            return Effect.succeed(this.createGenerator(invocation, run, fn.async));
-        if (!fn.async)
-            return run;
-        return this.runtime.promises.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, self)));
     }
     createGenerator(invocation, run, asynchronous) {
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };

package/dist/tool-runtime.d.ts

@@ -3,7 +3,7 @@ import type { Prototypes } from "./interpreter/intrinsics.js";
 import { type Namespace } from "./namespace.js";
 import { type Tool } from "./tool.js";
 import type { Tools } from "./tools.js";
-export declare const compareText: (left: string, right: string) => 1 | -1 | 0;
+export declare const compareText: (left: string, right: string) => 0 | 1 | -1;
 export type Services<T> = ServicesOf<T, []>;
 type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
     readonly _tag: "CodeModeTool";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19567",
+  "version": "0.0.0-dev-19570",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",