@opencode/codemode 0.0.0-dev-19436 → 0.0.0-dev-19438

package/dist/codemode.d.ts

@@ -136,7 +136,7 @@ export declare const Result: Schema.Union<readonly [Schema.Struct<{
 export type Result = typeof Result.Type;
 /** Reusable confined runtime over explicit tools. */
 export type Runtime<R = never> = {
-    readonly catalog: () => ReadonlyArray<ToolDescription>;
+    readonly catalog: ReadonlyArray<ToolDescription>;
     readonly execute: (code: string) => Effect.Effect<Result, never, R>;
 };
 /** Executes one Effect-native CodeMode program without constructing a reusable runtime. */

package/dist/codemode.js

@@ -60,7 +60,7 @@ export const make = (options = {}) => {
     const prepared = ToolRuntime.prepare((options.tools ?? {}));
     const limits = resolveExecutionLimits(options.limits);
     return {
-        catalog: () => prepared.catalog,
+        catalog: prepared.catalog,
         execute: (code) => executeProgram(code, prepared, limits, options),
     };
 };

package/dist/interpreter/promises.d.ts

@@ -12,6 +12,9 @@ export declare class PromiseRuntime<R> {
     private readonly failures;
     private nextID;
     constructor(scope: Scope.Scope);
+    createWithSelf(body: (self: {
+        promise?: Values.Promise;
+    }) => Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
     create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<Values.Promise, never, R>;
     markObserved(promise: Values.Promise): void;
     await(promise: Values.Promise): Effect.Effect<Exit.Exit<unknown, unknown>>;

package/dist/interpreter/promises.js

@@ -22,6 +22,14 @@ export class PromiseRuntime {
     constructor(scope) {
         this.scope = scope;
     }
+    // Resolution bodies need the promise's own identity to reject `resolve(promise)` self-resolution.
+    createWithSelf(body) {
+        const self = {};
+        return Effect.map(this.create(body(self)), (promise) => {
+            self.promise = promise;
+            return promise;
+        });
+    }
     create(effect) {
         return Effect.suspend(() => {
             // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
@@ -103,11 +111,7 @@ export const resolvePromiseValue = (runner, value, node, own) => {
 export const resolvePromise = (runner, promises, value, node) => {
     if (value instanceof Values.Promise)
         return Effect.succeed(value);
-    const box = {};
-    return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
-        box.promise = promise;
-        return promise;
-    });
+    return promises.createWithSelf((self) => resolvePromiseValue(runner, value, node, self));
 };
 const promiseStatics = ["all", "allSettled", "race", "any", "resolve", "reject"];
 const invokePromiseMethod = (runner, promises, name, args, node) => {
@@ -184,9 +188,7 @@ const constructPromise = (runner, promises, executor, node) => {
     }
     return Effect.gen(function* () {
         const deferred = Deferred.makeUnsafe();
-        const box = {};
-        const promise = yield* promises.create(Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)));
-        box.promise = promise;
+        const promise = yield* promises.createWithSelf((self) => Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, self)));
         const resolve = capability("resolve", (value) => Deferred.doneUnsafe(deferred, Exit.succeed(value)));
         const reject = capability("reject", (value) => Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value))));
         const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]));
@@ -223,20 +225,15 @@ const reactionExit = (promises, source) => Effect.gen(function* () {
     return exit;
 });
 const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
-    const box = {};
-    const body = Effect.gen(function* () {
+    return promises.createWithSelf((self) => Effect.gen(function* () {
         const exit = yield* reactionExit(promises, source);
         const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected;
         if (handler === undefined)
             return yield* exit;
         const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause));
         const result = yield* applyCollectionCallback(runner, handler, method, node)([input]);
-        return yield* resolvePromiseValue(runner, result, node, box);
-    });
-    return Effect.map(promises.create(body), (derived) => {
-        box.promise = derived;
-        return derived;
-    });
+        return yield* resolvePromiseValue(runner, result, node, self);
+    }));
 };
 const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
     const exit = yield* reactionExit(promises, source);

package/dist/interpreter/runtime.js

@@ -19,6 +19,20 @@ import { uriArgument, urlMethods, urlProperties, urlSearchParamsMethods, urlWrit
 import { enumerableSource } from "../stdlib/object.js";
 import { coerceToNumber, coerceToString, compoundOperators, errorBrandName } from "../stdlib/value.js";
 import { Values } from "../values.js";
+// What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
+// Unlabelled break ends this loop; a label the loop does not carry propagates outward.
+const loopExit = (result, labels) => {
+    if (result.kind === "return")
+        return result;
+    if (result.kind === "break") {
+        if (result.label !== undefined && !labels?.has(result.label))
+            return result;
+        return { kind: "none" };
+    }
+    if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label))
+        return result;
+    return undefined;
+};
 const calleeDescription = (callee) => {
     if (callee?.type === "Identifier")
         return callee.name;
@@ -93,6 +107,53 @@ const collectPatternNames = (pattern, out = []) => {
     }
     return out;
 };
+// `var` names declared anywhere in a function body except inside nested functions, which own theirs.
+const collectVarNames = (node, out = []) => {
+    if (!node)
+        return out;
+    switch (node.type) {
+        case "VariableDeclaration":
+            if (node.kind === "var")
+                for (const declaration of node.declarations)
+                    collectPatternNames(declaration.id, out);
+            break;
+        case "BlockStatement":
+            for (const statement of node.body)
+                collectVarNames(statement, out);
+            break;
+        case "IfStatement":
+            collectVarNames(node.consequent, out);
+            collectVarNames(node.alternate, out);
+            break;
+        case "ForStatement":
+            if (node.init?.type === "VariableDeclaration")
+                collectVarNames(node.init, out);
+            collectVarNames(node.body, out);
+            break;
+        case "ForInStatement":
+        case "ForOfStatement":
+            if (node.left.type === "VariableDeclaration")
+                collectVarNames(node.left, out);
+            collectVarNames(node.body, out);
+            break;
+        case "WhileStatement":
+        case "DoWhileStatement":
+        case "LabeledStatement":
+            collectVarNames(node.body, out);
+            break;
+        case "SwitchStatement":
+            for (const item of node.cases)
+                for (const statement of item.consequent)
+                    collectVarNames(statement, out);
+            break;
+        case "TryStatement":
+            collectVarNames(node.block, out);
+            collectVarNames(node.handler?.body, out);
+            collectVarNames(node.finalizer, out);
+            break;
+    }
+    return out;
+};
 const loopDeclaration = (left, statement) => {
     if (left.type !== "VariableDeclaration")
         return undefined;
@@ -169,6 +230,7 @@ class Frame {
         return Effect.gen(function* () {
             self.predeclareLexical(program.body);
             self.hoistFunctions(program.body);
+            self.hoistVars(program.body);
             let value = undefined;
             for (const [index, statement] of program.body.entries()) {
                 if (index === program.body.length - 1 && statement.type === "ExpressionStatement") {
@@ -276,6 +338,18 @@ class Frame {
             this.scopes.declare(node.id.name, this.createFunction(node), true, node);
         }
     }
+    // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
+    // into their own scope above the parameters so closures in parameter defaults keep seeing outer names.
+    hoistVars(statements, parameters) {
+        const scope = this.scopes.current();
+        for (const statement of statements) {
+            for (const name of collectVarNames(statement)) {
+                if (scope.has(name))
+                    continue;
+                scope.set(name, { mutable: true, value: parameters?.get(name)?.value, initialized: true });
+            }
+        }
+    }
     predeclareLexical(statements) {
         for (const statement of statements) {
             if (statement.type !== "VariableDeclaration")
@@ -352,20 +426,9 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             while (yield* self.evaluateExpression(node.test)) {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "return") {
-                    return result;
-                }
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
             }
             return { kind: "none" };
         });
@@ -374,20 +437,9 @@ class Frame {
         const self = this;
         return Effect.gen(function* () {
             do {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "return") {
-                    return result;
-                }
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
             } while (yield* self.evaluateExpression(node.test));
             return { kind: "none" };
         });
@@ -422,24 +474,13 @@ class Frame {
             };
             nextIteration();
             while (testNode ? yield* self.evaluateExpression(testNode) : true) {
-                const result = yield* self.evaluateStatement(node.body);
-                if (result.kind === "return") {
-                    return result;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label))
-                    return result;
+                const exit = loopExit(yield* self.evaluateStatement(node.body), labels);
+                if (exit !== undefined)
+                    return exit;
                 nextIteration();
                 if (updateNode) {
                     yield* self.evaluateExpression(updateNode);
                 }
-                if (result.kind === "continue") {
-                    continue;
-                }
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
@@ -470,18 +511,20 @@ class Frame {
             }
             const assignment = left.type === "VariableDeclaration" ? undefined : left;
             const evaluateBody = (value) => Effect.gen(function* () {
-                if (declared) {
+                if (declared?.lexical) {
                     self.scopes.push();
-                    if (declared.lexical)
-                        self.predeclarePattern(declared.pattern, declared.mutable, left);
-                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, declared.lexical);
+                    self.predeclarePattern(declared.pattern, declared.mutable, left);
+                    yield* self.declarePattern(declared.pattern, value, declared.mutable, left, true);
+                }
+                else if (declared) {
+                    yield* self.assignPattern(declared.pattern, value, left);
                 }
                 else if (assignment) {
                     yield* self.assignPattern(assignment, value, left);
                 }
                 return yield* self.evaluateStatement(node.body);
             }).pipe(Effect.ensuring(Effect.sync(() => {
-                if (declared)
+                if (declared?.lexical)
                     self.scopes.pop();
             })));
             while (true) {
@@ -499,20 +542,10 @@ class Frame {
                     }
                     return yield* Effect.failCause(bodyExit.cause);
                 }
-                const result = bodyExit.value;
-                if (result.kind === "return") {
+                const exit = loopExit(bodyExit.value, labels);
+                if (exit !== undefined) {
                     yield* close();
-                    return result;
-                }
-                if (result.kind === "break") {
-                    yield* close();
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue" && result.label !== undefined && !labels?.has(result.label)) {
-                    yield* close();
-                    return result;
+                    return exit;
                 }
             }
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -691,33 +724,25 @@ class Frame {
             const assignmentName = left.type === "Identifier" ? left.name : undefined;
             for (const key of keys) {
                 const result = yield* Effect.gen(function* () {
-                    if (declared) {
+                    if (declared?.lexical) {
                         self.scopes.push();
-                        if (declared.lexical)
-                            self.predeclarePattern(declared.pattern, declared.mutable, left);
-                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, declared.lexical);
+                        self.predeclarePattern(declared.pattern, declared.mutable, left);
+                        yield* self.declarePattern(declared.pattern, key, declared.mutable, left, true);
+                    }
+                    else if (declared) {
+                        yield* self.assignPattern(declared.pattern, key, left);
                     }
                     else if (assignmentName) {
                         self.scopes.set(assignmentName, key, left);
                     }
                     return yield* self.evaluateStatement(node.body);
                 }).pipe(Effect.ensuring(Effect.sync(() => {
-                    if (declared)
+                    if (declared?.lexical)
                         self.scopes.pop();
                 })));
-                if (result.kind === "return") {
-                    return result;
-                }
-                if (result.kind === "break") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    return { kind: "none" };
-                }
-                if (result.kind === "continue") {
-                    if (result.label !== undefined && !labels?.has(result.label))
-                        return result;
-                    continue;
-                }
+                const exit = loopExit(result, labels);
+                if (exit !== undefined)
+                    return exit;
             }
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -798,8 +823,14 @@ class Frame {
                     throw new InterpreterRuntimeError("Unsupported variable declaration shape.", declaration);
                 }
                 const init = declaration.init;
+                // `var x` alone is a no-op: the binding was hoisted on function entry.
+                if (kind === "var") {
+                    if (init)
+                        yield* self.assignPattern(declaration.id, yield* self.evaluateExpression(init), declaration);
+                    continue;
+                }
                 const value = init ? yield* self.evaluateExpression(init) : undefined;
-                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, kind !== "var");
+                yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, true);
             }
         });
     }
@@ -1357,6 +1388,8 @@ class Frame {
                 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;
             }

package/dist/stdlib/object.js

@@ -97,13 +97,6 @@ const constructObject = (args, node) => {
         return first;
     throw new InterpreterRuntimeError(`Object(${typeof first}) wrapper objects are not supported; use the primitive value directly.`, node);
 };
-// Tool references are not data; only Object.keys(tools) reads them, for tool names.
-const rejectTools = (name, args, node) => {
-    if (!(args[0] instanceof ToolReference))
-        return;
-    throw new InterpreterRuntimeError(`Object.${name}(...) cannot read tool references: they are not plain data. Use Object.keys(tools) for names, or search({ query }) for signatures.`, node, "InvalidDataValue");
-};
-const objectStatic = (name, impl) => sync(`Object.${name}`, impl);
 // Object constructs identically with or without new, like JS. Only `keys` copies its result into the
 // program; `values`, `entries`, `assign`, and `fromEntries` hand back the program's own values.
 export const objectGlobal = (runner, toolKeys) => new HostFunction({
@@ -115,22 +108,19 @@ export const objectGlobal = (runner, toolKeys) => new HostFunction({
         keys: sync("Object.keys", (args, node) => toProgram(args[0] instanceof ToolReference
             ? [...toolKeys(args[0].path)]
             : Object.keys(enumerableSource("Object.keys(...)", args[0], node)), "Object.keys result")),
-        values: objectStatic("values", (args, node) => Object.values(enumerableSource("Object.values(...)", args[0], node))),
-        entries: objectStatic("entries", (args, node) => Object.entries(enumerableSource("Object.entries(...)", args[0], node)).map(([key, item]) => [key, item])),
-        hasOwn: objectStatic("hasOwn", (args, node) => Object.hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
-        is: objectStatic("is", (args, node) => {
+        values: sync("Object.values", (args, node) => Object.values(enumerableSource("Object.values(...)", args[0], node))),
+        entries: sync("Object.entries", (args, node) => Object.entries(enumerableSource("Object.entries(...)", args[0], node)).map(([key, item]) => [key, item])),
+        hasOwn: sync("Object.hasOwn", (args, node) => Object.hasOwn(enumerableSource("Object.hasOwn(...)", args[0], node), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]))),
+        is: sync("Object.is", (args, node) => {
             if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
                 throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
             }
             return Object.is(args[0], args[1]);
         }),
-        assign: objectStatic("assign", objectAssign),
+        assign: sync("Object.assign", objectAssign),
         fromEntries: new HostFunction({
             name: "Object.fromEntries",
-            call: (args, node) => Effect.suspend(() => {
-                rejectTools("fromEntries", args, node);
-                return objectFromEntries(runner, args[0], node);
-            }),
+            call: (args, node) => Effect.suspend(() => objectFromEntries(runner, args[0], node)),
         }),
         groupBy: groupBy(runner, "Object"),
     },

package/package.json

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