@opencode/codemode 0.0.0-beta-19507 → 0.0.0-dev-19274

package/dist/interpreter/references.js

@@ -1,27 +1,37 @@
+import { AsyncIteratorSymbol, CodeModeFunction, CodeModeGenerator, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, GeneratorMethodReference, InterpreterRuntimeError, IntrinsicReference, IteratorSymbol, JsonMethodReference, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, PromiseNamespace, SearchFunction, SymbolNamespace, UriFunction, } from "./model.js";
 import { ToolReference } from "../tool-runtime.js";
-import { Values } from "../values.js";
-import { HostFunction, HostNamespace } from "./host.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 ProgramFunction ||
+import { isCodeModeValue, CodeModePromise } from "../values.js";
+export const isRuntimeReference = (value) => value instanceof CodeModeFunction ||
     value instanceof CodeModeGenerator ||
     value instanceof GeneratorMethodReference ||
     value instanceof ToolReference ||
     value instanceof IntrinsicReference ||
+    value instanceof GlobalNamespace ||
+    value instanceof GlobalMethodReference ||
+    value instanceof JsonMethodReference ||
+    value instanceof PromiseNamespace ||
+    value instanceof PromiseMethodReference ||
     value instanceof PromiseInstanceMethodReference ||
-    value instanceof Values.Promise ||
-    Values.isValue(value);
+    value instanceof CodeModePromise ||
+    value instanceof CoercionFunction ||
+    value instanceof UriFunction ||
+    value instanceof SearchFunction ||
+    value instanceof PromiseCapabilityFunction ||
+    value instanceof ErrorConstructorReference ||
+    value instanceof SymbolNamespace ||
+    isCodeModeValue(value);
 function* childValues(value) {
-    if (!(value instanceof ProgramObject))
-        return;
-    for (const key of ownKeys(value))
-        yield getOwn(value, key);
+    for (const key of Reflect.ownKeys(value)) {
+        if (!Object.prototype.propertyIsEnumerable.call(value, key))
+            continue;
+        if (typeof key === "symbol" && key !== AsyncIteratorSymbol && key !== IteratorSymbol)
+            continue;
+        yield Reflect.get(value, key);
+    }
 }
-// Depth-first search over a value tree. `match` stops the walk; `skip` prunes a subtree without matching it.
-const find = (value, match, skip, seen) => {
+export const containsRuntimeReference = (value) => {
     const pending = [[value].values()];
+    const seen = new Set();
     while (pending.length > 0) {
         const next = pending.at(-1).next();
         if (next.done) {
@@ -29,65 +39,75 @@ const find = (value, match, skip, seen) => {
             continue;
         }
         const current = next.value;
-        if (match(current))
+        if (isRuntimeReference(current))
             return true;
-        if (current === null || typeof current !== "object" || skip(current) || seen.has(current))
+        if (current === null || typeof current !== "object" || seen.has(current))
             continue;
         seen.add(current);
         pending.push(childValues(current));
     }
     return false;
 };
-const never = () => false;
-export const containsRuntimeReference = (value) => find(value, isRuntimeReference, never, new Set());
 // CodeMode values are data here, not opaque interpreter references.
-export const containsOpaqueReference = (value) => find(value, (current) => !Values.isValue(current) && isRuntimeReference(current), Values.isValue, new Set());
+export const containsOpaqueReference = (value) => {
+    const pending = [[value].values()];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const next = pending.at(-1).next();
+        if (next.done) {
+            pending.pop();
+            continue;
+        }
+        const current = next.value;
+        if (isCodeModeValue(current))
+            continue;
+        if (isRuntimeReference(current))
+            return true;
+        if (current === null || typeof current !== "object" || seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(childValues(current));
+    }
+    return false;
+};
 // Reject cycles before mutation so later boundary walks remain safe.
 export const rejectCircularInsertion = (container, value, label, node, seen = new Set()) => {
-    if (find(value, (current) => current === container, isRuntimeReference, seen)) {
-        throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
+    const pending = [[value].values()];
+    while (pending.length > 0) {
+        const next = pending.at(-1).next();
+        if (next.done) {
+            pending.pop();
+            continue;
+        }
+        const current = next.value;
+        if (current === container)
+            throw new InterpreterRuntimeError(`${label} contains a circular value.`, node, "InvalidDataValue");
+        if (current === null || typeof current !== "object" || isRuntimeReference(current) || seen.has(current))
+            continue;
+        seen.add(current);
+        pending.push(childValues(current));
     }
 };
-export const describeValue = (value) => {
-    if (value === null)
-        return "null";
-    if (value instanceof ProgramArray)
-        return "an array";
-    if (value instanceof Values.Promise)
-        return "an un-awaited Promise";
-    if (value instanceof ToolReference)
-        return "a tool reference";
-    if (value instanceof Values.Date)
-        return "a Date";
-    if (value instanceof Values.RegExp)
-        return "a RegExp";
-    if (value instanceof Values.Map)
-        return "a Map";
-    if (value instanceof Values.Set)
-        return "a Set";
-    if (value instanceof Values.URL)
-        return "a URL";
-    if (value instanceof Values.URLSearchParams)
-        return "a URLSearchParams";
-    if (value instanceof CodeModeGenerator)
-        return "a generator";
-    if (isRuntimeReference(value))
-        return "a function";
-    if (typeof value === "object")
-        return "a data object";
-    return `a ${typeof value}`;
-};
 export const typeofValue = (value) => {
-    if (value instanceof HostFunction ||
-        value instanceof ProgramFunction ||
+    if (value instanceof CodeModeFunction ||
         value instanceof GeneratorMethodReference ||
+        value instanceof CoercionFunction ||
         value instanceof IntrinsicReference ||
-        value instanceof PromiseInstanceMethodReference) {
+        value instanceof GlobalMethodReference ||
+        value instanceof JsonMethodReference ||
+        value instanceof PromiseMethodReference ||
+        value instanceof PromiseInstanceMethodReference ||
+        value instanceof PromiseNamespace ||
+        value instanceof PromiseCapabilityFunction ||
+        value instanceof ErrorConstructorReference ||
+        value instanceof SymbolNamespace)
+        return "function";
+    if (value instanceof UriFunction || value instanceof SearchFunction)
         return "function";
-    }
-    if (value instanceof HostNamespace)
-        return "object";
     if (value instanceof ToolReference)
         return value.path.length > 0 ? "function" : "object";
+    if (value instanceof GlobalNamespace) {
+        return value.name === "Math" || value.name === "JSON" || value.name === "console" ? "object" : "function";
+    }
     return typeof value;
 };

package/dist/interpreter/runtime.d.ts

@@ -1,19 +1,98 @@
-import type { Program } from "acorn";
 import { Effect } from "effect";
-import { type Host } from "./globals.js";
-import { type Runner } from "./runner.js";
+import { type ProgramNode } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
-/** 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>;
-    /** Built-in globals by name, unaffected by program shadowing. */
-    readonly builtins: ReadonlyMap<string, unknown>;
-    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>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
-    run(program: Program): Effect.Effect<unknown, unknown, R>;
+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>);
+    run(program: ProgramNode): 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 constructArray;
+    private constructObject;
+    private constructDate;
+    private toDatePrimitive;
+    private constructRegExp;
+    private constructMap;
+    private constructSet;
+    private constructURL;
+    private constructURLSearchParams;
+    private readURLSearchParamsPair;
+    private evaluateBinaryExpression;
+    private applyBinaryOperator;
+    private evaluateLogicalExpression;
+    private evaluateUnaryExpression;
+    private evaluateAssignmentExpression;
+    private evaluateLogicalAssignment;
+    private evaluateUpdateExpression;
+    private evaluateCallExpression;
+    private invokeCallable;
+    private invokeObjectMethodOnTools;
+    private invokeConsole;
+    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;
 }