@opencode/codemode 0.0.0-dev-19370 → 0.0.0-dev-19372

package/dist/interpreter/execute.js

@@ -8,7 +8,7 @@ import { ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
 import { InterpreterRuntimeError } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
-import { Interpreter } from "./runtime.js";
+import { Runtime } from "./runtime.js";
 export const executeProgram = (code, prepared, limits, hooks) => {
     if (code.trim().length === 0) {
         return Effect.succeed({
@@ -27,8 +27,7 @@ export const executeProgram = (code, prepared, limits, hooks) => {
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
             const program = parseProgram(code);
             const promises = new PromiseRuntime(scope);
-            const interpreter = new Interpreter(tools.execute, tools.search, tools.keys, promises, logs);
-            const value = yield* interpreter.run(program);
+            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs).run(program);
             const result = toData(value, "Execution result", "result");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();

package/dist/interpreter/runtime.d.ts

@@ -1,86 +1,16 @@
 import type { Program } from "acorn";
 import { Effect } from "effect";
+import { type Runner } from "./runner.js";
 import { PromiseRuntime } from "./promises.js";
-export declare class Interpreter<R> {
-    private scopes;
-    private readonly executeTool;
-    private readonly invokeSearch;
-    private readonly toolKeys;
-    private readonly logs;
-    private readonly promises;
-    private generatorState?;
-    private generatorAsync;
-    private readonly runner;
-    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, invokeSearch: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
+/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
+export declare class Runtime<R> {
+    readonly executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
+    readonly promises: PromiseRuntime<R>;
+    readonly logs: Array<string>;
+    readonly runner: Runner<R>;
+    private readonly root;
+    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, logs?: Array<string>);
     run(program: Program): Effect.Effect<unknown, unknown, R>;
-    private createToolCallPromise;
-    private createPromise;
-    private settlePromise;
-    private evaluateStatement;
-    private evaluateBlock;
-    private createFunction;
-    private hoistFunctions;
-    private predeclareLexical;
-    private predeclarePattern;
-    private evaluateIfStatement;
-    private evaluateSwitchStatement;
-    private evaluateWhileStatement;
-    private evaluateDoWhileStatement;
-    private evaluateForStatement;
-    private evaluateForOfStatement;
-    private awaitValue;
-    private awaitAsyncFromSyncValue;
-    private syncIterator;
-    private customIterator;
-    private nextIteratorResult;
-    private closeIterator;
-    private requireIteratorObject;
-    private requireIterator;
-    private requireIteratorMethod;
-    private enumerableKeys;
-    private evaluateForInStatement;
-    private evaluateBreakStatement;
-    private evaluateContinueStatement;
-    private evaluateLabeledStatement;
-    private evaluateThrowStatement;
-    private evaluateTryStatement;
-    private evaluateVariableDeclaration;
-    private declarePattern;
-    private assignPattern;
-    private destructureArrayPattern;
-    private destructuringPropertyKey;
-    private destructuringPropertyValue;
-    private evaluateExpression;
-    private evaluateNewExpression;
-    private evaluateBinaryExpression;
-    private applyBinaryOperator;
-    private evaluateLogicalExpression;
-    private evaluateUnaryExpression;
-    private evaluateAssignmentExpression;
-    private evaluateLogicalAssignment;
-    private evaluateUpdateExpression;
-    private evaluateCallExpression;
-    private invokeCallable;
-    private evaluateCallArguments;
-    private invokeFunction;
-    private createGenerator;
-    private completeGeneratorRequests;
-    private takeGeneratorRequest;
-    private dequeueGeneratorRequest;
-    private evaluateYieldExpression;
-    private suspendGenerator;
-    private delegateYield;
-    private evaluateObjectExpression;
-    private evaluateArrayExpression;
-    private evaluateTemplateLiteral;
-    private evaluateConditionalExpression;
-    private applyCompoundAssignment;
-    private getMemberReference;
-    private readMember;
-    private writeMember;
-    private evaluateDeleteExpression;
-    private modifyMember;
-    private readReferenceValue;
-    private assignToReference;
-    private toPropertyKey;
 }

package/dist/interpreter/runtime.js

@@ -97,33 +97,47 @@ const copyIteratorSymbols = (source, target, consumed) => {
     }
 };
 const promiseResolutionNode = { type: "PromiseResolution", start: 0, end: 0 };
-export class Interpreter {
-    scopes;
+/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
+export class Runtime {
     executeTool;
-    invokeSearch;
+    search;
     toolKeys;
-    logs;
     promises;
-    generatorState;
-    generatorAsync = false;
-    runner = {
-        invokeFunction: (fn, args) => this.invokeFunction(fn, args),
-        invokeCallable: (callable, args, node) => this.invokeCallable(callable, args, node),
-        settlePromise: (promise) => this.settlePromise(promise),
-        syncIterator: (value, node) => this.syncIterator(value, node),
-    };
-    constructor(executeTool, invokeSearch, toolKeys, promises, logs = []) {
-        const globalScope = new Map();
-        this.scopes = new ScopeStack([globalScope]);
+    logs;
+    runner;
+    root;
+    constructor(executeTool, search, toolKeys, promises, logs = []) {
         this.executeTool = executeTool;
-        this.invokeSearch = invokeSearch;
+        this.search = search;
         this.toolKeys = toolKeys;
-        this.logs = logs;
         this.promises = promises;
-        const host = { runner: this.runner, promises, search: invokeSearch, toolKeys, logs };
-        for (const [name, value] of globals(host))
+        this.logs = logs;
+        const globalScope = new Map();
+        // Calling back into the program never reads frame state, so any frame serves; the root is always alive.
+        this.root = new Frame(this, new ScopeStack([globalScope]));
+        this.runner = {
+            invokeFunction: (fn, args) => this.root.invokeFunction(fn, args),
+            invokeCallable: (callable, args, node) => this.root.invokeCallable(callable, args, node),
+            settlePromise: (promise) => this.root.settlePromise(promise),
+            syncIterator: (value, node) => this.root.syncIterator(value, node),
+        };
+        for (const [name, value] of globals(this))
             globalScope.set(name, { mutable: false, value });
     }
+    run(program) {
+        return this.root.run(program);
+    }
+}
+/** One activation: the top-level program or a single function call, evaluating against its own scope chain. */
+class Frame {
+    runtime;
+    scopes;
+    generatorState;
+    generatorAsync = false;
+    constructor(runtime, scopes) {
+        this.runtime = runtime;
+        this.scopes = scopes;
+    }
     run(program) {
         const self = this;
         // Keep top-level declarations separate so they can shadow builtins.
@@ -147,20 +161,20 @@ export class Interpreter {
                 }
             }
             // The implicit async body adopts returned promises before copy-out.
-            value = yield* resolvePromiseValue(self.runner, value, program);
+            value = yield* resolvePromiseValue(self.runtime.runner, value, program);
             return value;
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     // Fork at the call site so admission and hooks occur when the call is made.
     createToolCallPromise(path, args) {
-        return this.createPromise(Effect.suspend(() => this.executeTool(path, args)));
+        return this.createPromise(Effect.suspend(() => this.runtime.executeTool(path, args)));
     }
     createPromise(effect) {
-        return this.promises.create(effect);
+        return this.runtime.promises.create(effect);
     }
     // Fiber exits make settlement idempotent; yielding prevents inline continuation.
     settlePromise(promise) {
-        const promises = this.promises;
+        const promises = this.runtime.promises;
         return Effect.suspend(() => {
             promises.markObserved(promise);
             return Effect.flatMap(promises.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit));
@@ -483,7 +497,7 @@ export class Interpreter {
         })));
     }
     awaitValue(value, node = promiseResolutionNode) {
-        return Effect.flatMap(resolvePromise(this.runner, this.promises, value, node), (promise) => this.settlePromise(promise));
+        return Effect.flatMap(resolvePromise(this.runtime.runner, this.runtime.promises, value, node), (promise) => this.settlePromise(promise));
     }
     awaitAsyncFromSyncValue(iterator, value, node, closeOnRejection) {
         const self = this;
@@ -630,7 +644,7 @@ export class Interpreter {
     }
     enumerableKeys(value) {
         if (value instanceof ToolReference) {
-            return [...this.toolKeys(value.path)];
+            return [...this.runtime.toolKeys(value.path)];
         }
         if (Array.isArray(value)) {
             return Object.keys(value);
@@ -1267,10 +1281,10 @@ export class Interpreter {
                 return callable.generator.asynchronous ? yield* self.createPromise(requested) : yield* requested;
             }
             if (callable instanceof IntrinsicReference) {
-                return yield* invokeIntrinsic(self.runner, callable, args, node);
+                return yield* invokeIntrinsic(self.runtime.runner, callable, args, node);
             }
             if (callable instanceof PromiseInstanceMethodReference) {
-                return yield* invokePromiseInstanceMethod(self.runner, self.promises, callable, args, node);
+                return yield* invokePromiseInstanceMethod(self.runtime.runner, self.runtime.promises, callable, args, node);
             }
             if (callable instanceof HostFunction)
                 return yield* callable.call(args, node);
@@ -1305,8 +1319,7 @@ export class Interpreter {
         });
     }
     invokeFunction(fn, args) {
-        const invocation = new Interpreter(this.executeTool, this.invokeSearch, this.toolKeys, this.promises, this.logs);
-        invocation.scopes = new ScopeStack([...fn.capturedScopes, new Map()]);
+        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();
@@ -1334,7 +1347,7 @@ export class Interpreter {
             return run;
         // The initial yield assigns the promise before the body can self-resolve.
         const box = {};
-        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runner, value, fn.body, box))), (promise) => {
+        return Effect.map(this.createPromise(Effect.flatMap(run, (value) => resolvePromiseValue(invocation.runtime.runner, value, fn.body, box))), (promise) => {
             box.promise = promise;
             return promise;
         });
@@ -1355,7 +1368,7 @@ export class Interpreter {
                 if (state.draining)
                     return Deferred.await(request.response);
                 state.draining = true;
-                return Effect.andThen(this.promises.fork(invocation
+                return Effect.andThen(this.runtime.promises.fork(invocation
                     .completeGeneratorRequests(state, true)
                     .pipe(Effect.ensuring(Effect.sync(() => (state.draining = false))))), Deferred.await(request.response));
             }
@@ -1393,7 +1406,7 @@ export class Interpreter {
                     yield* invocation.completeGeneratorRequests(state, asynchronous);
                     state.completed = true;
                 });
-                return Effect.andThen(this.promises.fork(body), Deferred.await(request.response));
+                return Effect.andThen(this.runtime.promises.fork(body), Deferred.await(request.response));
             }
             return Deferred.await(request.response);
         });

package/package.json

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