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

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;
@@ -352,20 +366,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 +377,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 +414,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())));
@@ -499,20 +480,10 @@ class Frame {
                     }
                     return yield* Effect.failCause(bodyExit.cause);
                 }
-                const result = bodyExit.value;
-                if (result.kind === "return") {
-                    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)) {
+                const exit = loopExit(bodyExit.value, labels);
+                if (exit !== undefined) {
                     yield* close();
-                    return result;
+                    return exit;
                 }
             }
         }).pipe(Effect.ensuring(Effect.sync(() => {
@@ -705,19 +676,9 @@ class Frame {
                     if (declared)
                         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(() => {

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-19437",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",