@opencode/codemode 0.0.0-dev-19488 → 0.0.0-dev-19498

package/dist/data.js

@@ -1,5 +1,5 @@
 export * as Data from "./data.js";
-import { ownEntries, parseArrayIndex, ProgramArray, ProgramObject, set } from "./interpreter/objects.js";
+import { ownEntries, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, set, } from "./interpreter/objects.js";
 import { Values } from "./values.js";
 const MAX_VALUE_DEPTH = 32;
 export class ToolRuntimeError extends Error {
@@ -46,6 +46,9 @@ const copy = (value, label, mode, depth, seen) => {
     if (value instanceof Values.Promise) {
         throw new ToolRuntimeError("InvalidDataValue", `${label} contains an un-awaited Promise; await tool calls (e.g. \`const result = await tools.ns.tool(...)\`) before using their results.`);
     }
+    if (value instanceof ProgramFunction && mode !== "program") {
+        throw new ToolRuntimeError("InvalidDataValue", `${label} must contain data only.`);
+    }
     const plain = mode === "program" || mode === "data";
     if (mode === "program") {
         if (value instanceof ProgramObject || Values.isValue(value))

package/dist/interpreter/model.d.ts

@@ -1,4 +1,4 @@
-import type { BlockStatement, Expression, Node, Pattern } from "acorn";
+import type { Node } from "acorn";
 import type { Effect } from "effect";
 import type { DiagnosticKind } from "../codemode.js";
 import type { ProgramObject } from "./objects.js";
@@ -26,14 +26,6 @@ export type MemberReference = {
     target: ProgramObject | Values.RegExp | Values.URL;
     key: PropertyKey;
 };
-export declare class CodeModeFunction {
-    readonly parameters: ReadonlyArray<Pattern>;
-    readonly body: BlockStatement | Expression;
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
-    readonly async: boolean;
-    readonly generator: boolean;
-    constructor(parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
-}
 export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare class CodeModeGenerator {
     readonly asynchronous: boolean;

package/dist/interpreter/model.js

@@ -1,17 +1,3 @@
-export class CodeModeFunction {
-    parameters;
-    body;
-    capturedScopes;
-    async;
-    generator;
-    constructor(parameters, body, capturedScopes, async, generator) {
-        this.parameters = parameters;
-        this.body = body;
-        this.capturedScopes = capturedScopes;
-        this.async = async;
-        this.generator = generator;
-    }
-}
 export class CodeModeGenerator {
     asynchronous;
     request;

package/dist/interpreter/objects.d.ts

@@ -1,3 +1,5 @@
+import type { BlockStatement, Expression, Pattern } from "acorn";
+import { type Binding } from "./model.js";
 /** An object owned by the program: own properties plus a prototype link. */
 export declare class ProgramObject {
     proto: ProgramObject | null;
@@ -12,6 +14,16 @@ export declare class ProgramError extends ProgramObject {
     readonly errorName: string;
     constructor(errorName: string);
 }
+export declare class ProgramFunction extends ProgramObject {
+    readonly name: string;
+    readonly parameters: ReadonlyArray<Pattern>;
+    readonly body: BlockStatement | Expression;
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly async: boolean;
+    readonly generator: boolean;
+    readonly length: number;
+    constructor(name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+}
 export declare const parseArrayIndex: (key: string | number) => number | undefined;
 export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;

package/dist/interpreter/objects.js

@@ -21,6 +21,26 @@ export class ProgramError extends ProgramObject {
         this.errorName = errorName;
     }
 }
+export class ProgramFunction extends ProgramObject {
+    name;
+    parameters;
+    body;
+    capturedScopes;
+    async;
+    generator;
+    length;
+    constructor(name, parameters, body, capturedScopes, async, generator) {
+        super();
+        this.name = name;
+        this.parameters = parameters;
+        this.body = body;
+        this.capturedScopes = capturedScopes;
+        this.async = async;
+        this.generator = generator;
+        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
+        this.length = optional === -1 ? parameters.length : optional;
+    }
+}
 const MAX_ARRAY_LENGTH = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
@@ -31,22 +51,27 @@ export const parseArrayIndex = (key) => {
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
 const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
+// Non-enumerable built-in properties: array length, function name and length.
+const builtin = (target, name) => (name === "length" && target instanceof ProgramArray) ||
+    ((name === "name" || name === "length") && target instanceof ProgramFunction);
 export const hasOwn = (target, key) => {
     const name = canonical(key);
     const at = index(target, name);
     if (at !== undefined)
         return at in target.items;
-    if (name === "length" && target instanceof ProgramArray)
-        return true;
-    return target.props.has(name);
+    return builtin(target, name) || target.props.has(name);
 };
 export const getOwn = (target, key) => {
     const name = canonical(key);
     const at = index(target, name);
     if (at !== undefined)
         return target.items[at];
-    if (name === "length" && target instanceof ProgramArray)
+    if (target instanceof ProgramArray && name === "length")
         return target.items.length;
+    if (target instanceof ProgramFunction && name === "name")
+        return target.name;
+    if (target instanceof ProgramFunction && name === "length")
+        return target.length;
     return target.props.get(name);
 };
 export const get = (target, key) => {
@@ -78,6 +103,8 @@ export const set = (target, key, value) => {
         target.items.length = length;
         return true;
     }
+    if (builtin(target, name))
+        return false;
     target.props.set(name, value);
     return true;
 };
@@ -88,6 +115,8 @@ export const remove = (target, key) => {
         return delete target.items[at];
     if (name === "length" && target instanceof ProgramArray)
         return false;
+    if (builtin(target, name))
+        return true;
     target.props.delete(name);
     return true;
 };

package/dist/interpreter/promises.js

@@ -1,6 +1,6 @@
 import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
-import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference, } from "./model.js";
-import { get, ProgramArray, ProgramObject, record } from "./objects.js";
+import { InterpreterRuntimeError, ProgramThrow, PromiseInstanceMethodReference } from "./model.js";
+import { get, ProgramArray, ProgramFunction, ProgramObject, record } from "./objects.js";
 import { HostFunction, requiresNew, sync } from "./host.js";
 import { caughtErrorValue, normalizeError } from "./errors.js";
 import { typeofValue } from "./references.js";
@@ -181,7 +181,7 @@ export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) =
     return chainReaction(runner, promises, ref.promise, onFulfilled, onRejected, method, node);
 };
 const constructPromise = (runner, promises, executor, node) => {
-    if (!(executor instanceof CodeModeFunction)) {
+    if (!(executor instanceof ProgramFunction)) {
         throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node).as("TypeError");
     }
     return Effect.gen(function* () {

package/dist/interpreter/references.js

@@ -1,11 +1,11 @@
 import { ToolReference } from "../tool-runtime.js";
 import { Values } from "../values.js";
 import { HostFunction, HostNamespace } from "./host.js";
-import { CodeModeFunction, CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, PromiseInstanceMethodReference, } from "./model.js";
-import { getOwn, ownKeys, ProgramArray, ProgramObject } from "./objects.js";
+import { CodeModeGenerator, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, PromiseInstanceMethodReference, } from "./model.js";
+import { getOwn, ownKeys, ProgramArray, ProgramFunction, ProgramObject } from "./objects.js";
 export const isRuntimeReference = (value) => value instanceof HostFunction ||
     value instanceof HostNamespace ||
-    value instanceof CodeModeFunction ||
+    value instanceof ProgramFunction ||
     value instanceof CodeModeGenerator ||
     value instanceof GeneratorMethodReference ||
     value instanceof ToolReference ||
@@ -79,7 +79,7 @@ export const describeValue = (value) => {
 };
 export const typeofValue = (value) => {
     if (value instanceof HostFunction ||
-        value instanceof CodeModeFunction ||
+        value instanceof ProgramFunction ||
         value instanceof GeneratorMethodReference ||
         value instanceof IntrinsicReference ||
         value instanceof PromiseInstanceMethodReference) {

package/dist/interpreter/runner.d.ts

@@ -1,7 +1,8 @@
 import { Effect } from "effect";
 import { Values } from "../values.js";
 import { HostFunction } from "./host.js";
-import { type AstNode, CodeModeFunction, IntrinsicReference } from "./model.js";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import { ProgramFunction } from "./objects.js";
 export type IteratorCursor<R> = {
     readonly next: Effect.Effect<{
         readonly done: boolean;
@@ -11,13 +12,13 @@ export type IteratorCursor<R> = {
 };
 /** Everything a host function needs to call back into the program. */
 export type Runner<R> = {
-    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly invokeFunction: (fn: ProgramFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
     readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
     readonly settlePromise: (promise: Values.Promise) => Effect.Effect<unknown, unknown, never>;
     readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
 };
 export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
 export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string", node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export type SupportedCallback = CodeModeFunction | HostFunction<unknown> | IntrinsicReference;
+export type SupportedCallback = ProgramFunction | HostFunction<unknown> | IntrinsicReference;
 export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
 export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/runner.js

@@ -2,8 +2,8 @@ import { Effect, Exit } from "effect";
 import { Values } from "../values.js";
 import { coerceToString } from "../stdlib/value.js";
 import { HostFunction } from "./host.js";
-import { CodeModeFunction, InterpreterRuntimeError, IntrinsicReference } from "./model.js";
-import { get, has, ProgramObject } from "./objects.js";
+import { InterpreterRuntimeError, IntrinsicReference } from "./model.js";
+import { get, has, ProgramFunction, ProgramObject } from "./objects.js";
 import { typeofValue } from "./references.js";
 export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
     ? Effect.succeed(exit.value)
@@ -31,7 +31,7 @@ export const toPrimitive = (runner, value, hint, node) => {
         throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node).as("TypeError");
     });
 };
-export const isSupportedCallback = (value) => value instanceof CodeModeFunction ||
+export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
     (value instanceof HostFunction && value.callback) ||
     value instanceof IntrinsicReference;
 export const applyCollectionCallback = (runner, callback, name, node) => {

package/dist/interpreter/runtime.js

@@ -1,12 +1,12 @@
 import { Cause, Deferred, Effect, Exit } from "effect";
 import { ToolRuntimeError, toProgram } from "../data.js";
 import { ToolReference } from "../tool-runtime.js";
-import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
+import { AsyncIteratorSymbol, CodeModeGenerator, ComputedValue, GeneratorMethodReference, GeneratorReturn, IntrinsicReference, InterpreterRuntimeError, IteratorSymbol, OptionalShortCircuit, PromiseInstanceMethodReference, ProgramThrow, unsupportedSyntax, } from "./model.js";
 import { caughtErrorValue } from "./errors.js";
 import { globals } from "./globals.js";
 import { HostFunction, HostNamespace } from "./host.js";
 import { invokeIntrinsic } from "./methods.js";
-import { assign, get, has, ownKeys, parseArrayIndex, ProgramArray, ProgramObject, record, remove, set, } from "./objects.js";
+import { assign, get, has, ownKeys, parseArrayIndex, ProgramArray, ProgramFunction, ProgramObject, record, remove, set, } from "./objects.js";
 import { preserveConsumerError } from "./runner.js";
 import { invokePromiseInstanceMethod, PromiseRuntime, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, isRuntimeReference, rejectCircularInsertion, typeofValue, } from "./references.js";
@@ -73,7 +73,7 @@ const constructorName = (value) => {
         return "URLSearchParams";
     if (value instanceof Values.Promise)
         return "Promise";
-    if (!(value instanceof ProgramObject))
+    if (!(value instanceof ProgramObject) || value instanceof ProgramFunction)
         return undefined;
     return errorBrandName(value) ?? "Object";
 };
@@ -324,8 +324,15 @@ class Frame {
             return { kind: "none" };
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
-    createFunction(node) {
-        return new CodeModeFunction(node.params, node.body, this.scopes.capture(), node.async, node.generator);
+    createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
+        return new ProgramFunction(name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+    }
+    // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
+    evaluateNamed(node, name) {
+        if (node.type === "ArrowFunctionExpression" || (node.type === "FunctionExpression" && !node.id)) {
+            return Effect.sync(() => this.createFunction(node, name));
+        }
+        return this.evaluateExpression(node);
     }
     hoistFunctions(statements) {
         for (const node of statements) {
@@ -826,12 +833,14 @@ class Frame {
                 }
                 const init = declaration.init;
                 // `var x` alone is a no-op: the binding was hoisted on function entry.
+                const id = declaration.id;
+                const evaluate = (init) => id.type === "Identifier" ? self.evaluateNamed(init, id.name) : self.evaluateExpression(init);
                 if (kind === "var") {
                     if (init)
-                        yield* self.assignPattern(declaration.id, yield* self.evaluateExpression(init), declaration);
+                        yield* self.assignPattern(id, yield* evaluate(init), declaration);
                     continue;
                 }
-                const value = init ? yield* self.evaluateExpression(init) : undefined;
+                const value = init ? yield* evaluate(init) : undefined;
                 yield* self.declarePattern(declaration.id, value, kind !== "const", declaration, true);
             }
         });
@@ -848,7 +857,7 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
                 yield* self.declarePattern(pattern.left, resolved, mutable, node, initialize);
                 return;
             }
@@ -888,7 +897,7 @@ class Frame {
                 return;
             }
             if (pattern.type === "AssignmentPattern") {
-                const resolved = value === undefined ? yield* self.evaluateExpression(pattern.right) : value;
+                const resolved = value === undefined ? yield* self.evaluateDefault(pattern) : value;
                 yield* self.assignPattern(pattern.left, resolved, node);
                 return;
             }
@@ -916,6 +925,11 @@ class Frame {
             throw new InterpreterRuntimeError(`Unsupported assignment pattern '${pattern.type}'.`, node);
         });
     }
+    evaluateDefault(pattern) {
+        return pattern.left.type === "Identifier"
+            ? this.evaluateNamed(pattern.right, pattern.left.name)
+            : this.evaluateExpression(pattern.right);
+    }
     destructureArrayPattern(pattern, value, consume) {
         const self = this;
         return Effect.gen(function* () {
@@ -1050,7 +1064,7 @@ class Frame {
                 // unsupported syntax. Built-ins like Number are real constructors in JS, so do not claim
                 // otherwise; say `new` is unsupported for them and point at the plain call.
                 const name = calleeDescription(node.callee);
-                const message = callee instanceof CodeModeFunction
+                const message = callee instanceof ProgramFunction
                     ? `${name} cannot be constructed: user-defined constructors and classes are not supported. Call it as a function that returns a plain object instead.`
                     : callee instanceof HostFunction
                         ? `new ${name}(...) is not supported; call ${name}(...) without new instead.`
@@ -1080,6 +1094,9 @@ class Frame {
             return lhs === rhs;
         if (operator === "!==")
             return lhs !== rhs;
+        if (operator === "in" && rhs instanceof ProgramObject && !containsOpaqueReference(lhs)) {
+            return has(rhs, lhs !== null && typeof lhs === "object" ? coerceToString(lhs) : lhs);
+        }
         if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
             throw new InterpreterRuntimeError("Binary operators require data values.", node, "InvalidDataValue");
         }
@@ -1214,7 +1231,7 @@ class Frame {
                     const next = toProgram(self.applyCompoundAssignment(operator, current, rightValue, node), "Assignment result");
                     return self.scopes.set(name, next, left);
                 }
-                const rightValue = yield* self.evaluateExpression(node.right);
+                const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
             }
             if (left.type === "MemberExpression") {
@@ -1237,7 +1254,7 @@ class Frame {
                 const current = self.scopes.get(name, left);
                 if (!shouldAssign(current))
                     return current;
-                const rightValue = yield* self.evaluateExpression(node.right);
+                const rightValue = yield* self.evaluateNamed(node.right, name);
                 return self.scopes.set(name, rightValue, left);
             });
         }
@@ -1311,7 +1328,7 @@ class Frame {
                 }
                 return yield* self.createToolCallPromise(callable.path, args);
             }
-            if (callable instanceof CodeModeFunction) {
+            if (callable instanceof ProgramFunction) {
                 return yield* self.invokeFunction(callable, args);
             }
             if (callable instanceof GeneratorMethodReference) {
@@ -1621,7 +1638,12 @@ class Frame {
                 else {
                     throw new InterpreterRuntimeError("Unsupported object property key shape.", keyNode);
                 }
-                set(objectValue, key, yield* self.evaluateExpression(property.value));
+                const name = key === IteratorSymbol
+                    ? "[Symbol.iterator]"
+                    : key === AsyncIteratorSymbol
+                        ? "[Symbol.asyncIterator]"
+                        : String(key);
+                set(objectValue, key, yield* self.evaluateNamed(property.value, name));
             }
             return objectValue;
         });
@@ -1801,13 +1823,12 @@ class Frame {
                 }
                 return new ComputedValue(undefined);
             }
+            if (objectValue instanceof ProgramObject)
+                return { target: objectValue, key };
             if (isRuntimeReference(objectValue)) {
                 throw new InterpreterRuntimeError(`Cannot read properties of ${describeValue(objectValue)}; only data values expose properties.`, objectNode, "InvalidDataValue");
             }
-            if (!(objectValue instanceof ProgramObject)) {
-                throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
-            }
-            return { target: objectValue, key };
+            throw new InterpreterRuntimeError("Cannot access a property on a non-object value.", objectNode);
         });
     }
     readMember(node) {
@@ -1902,8 +1923,11 @@ class Frame {
         }
         const target = reference.target;
         rejectCircularInsertion(target, next, target instanceof ProgramArray ? "Array assignment result" : "Object assignment result", node);
-        if (!set(target, key, next))
+        if (set(target, key, next))
+            return;
+        if (target instanceof ProgramArray)
             throw new InterpreterRuntimeError("Invalid array length", node).as("RangeError");
+        throw new InterpreterRuntimeError(`Cannot assign to read only property '${String(key)}'.`, node).as("TypeError");
     }
     toPropertyKey(value, node) {
         if (typeof value === "string" || typeof value === "number") {

package/dist/tool-runtime.d.ts

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 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 | 0 | -1;
+export declare const compareText: (left: string, right: string) => 1 | -1 | 0;
 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-19488",
+  "version": "0.0.0-dev-19498",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",