@opencode/codemode 0.0.0-reserved → 2.0.1

package/dist/interpreter/references.d.ts

@@ -0,0 +1,7 @@
+import { type AstNode } from "./model.js";
+export declare const isRuntimeReference: (value: unknown) => boolean;
+export declare const containsRuntimeReference: (value: unknown) => boolean;
+export declare const containsOpaqueReference: (value: unknown) => boolean;
+export declare const rejectCircularInsertion: (container: object, value: unknown, label: string, node: AstNode, seen?: Set<object>) => void;
+export declare const describeValue: (value: unknown) => string;
+export declare const typeofValue: (value: unknown) => string;

package/dist/interpreter/references.js

@@ -0,0 +1,93 @@
+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 ||
+    value instanceof CodeModeGenerator ||
+    value instanceof GeneratorMethodReference ||
+    value instanceof ToolReference ||
+    value instanceof IntrinsicReference ||
+    value instanceof PromiseInstanceMethodReference ||
+    value instanceof Values.Promise ||
+    Values.isValue(value);
+function* childValues(value) {
+    if (!(value instanceof ProgramObject))
+        return;
+    for (const key of ownKeys(value))
+        yield getOwn(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) => {
+    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 (match(current))
+            return true;
+        if (current === null || typeof current !== "object" || skip(current) || 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());
+// 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");
+    }
+};
+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 ||
+        value instanceof GeneratorMethodReference ||
+        value instanceof IntrinsicReference ||
+        value instanceof PromiseInstanceMethodReference) {
+        return "function";
+    }
+    if (value instanceof HostNamespace)
+        return "object";
+    if (value instanceof ToolReference)
+        return value.path.length > 0 ? "function" : "object";
+    return typeof value;
+};

package/dist/interpreter/runner.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { Values } from "../values.js";
+import { HostFunction } from "./host.js";
+import { type AstNode, IntrinsicReference } from "./model.js";
+import type { Intrinsics } from "./intrinsics.js";
+import { ProgramFunction } from "./objects.js";
+export type IteratorCursor<R> = {
+    readonly next: Effect.Effect<{
+        readonly done: boolean;
+        readonly value: unknown;
+    }, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+/** Everything a host function needs from the realm: calling back into the program and its intrinsic objects. */
+export type Runner<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>;
+    readonly intrinsics: Intrinsics;
+};
+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 = 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

@@ -0,0 +1,45 @@
+import { Effect, Exit } from "effect";
+import { Values } from "../values.js";
+import { coerceToString } from "../stdlib/value.js";
+import { HostFunction } from "./host.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)
+    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));
+export const toPrimitive = (runner, value, hint, node) => {
+    if (value === null || typeof value !== "object")
+        return Effect.succeed(value);
+    if (Values.isValue(value)) {
+        return Effect.succeed(value instanceof Values.Date && hint === "number" ? value.time : coerceToString(value));
+    }
+    if (!(value instanceof ProgramObject))
+        return Effect.succeed(value);
+    const order = hint === "number" ? ["valueOf", "toString"] : ["toString", "valueOf"];
+    return Effect.gen(function* () {
+        for (const method of order) {
+            if (method === "toString" && !has(value, "toString"))
+                return coerceToString(value);
+            const callable = get(value, method);
+            if (typeofValue(callable) !== "function")
+                continue;
+            const result = yield* runner.invokeCallable(callable, [], node);
+            if (result === null || (typeof result !== "object" && typeof result !== "function"))
+                return result;
+        }
+        throw new InterpreterRuntimeError("Cannot convert object to primitive value.", node);
+    });
+};
+export const isSupportedCallback = (value) => value instanceof ProgramFunction ||
+    (value instanceof HostFunction && value.callback) ||
+    value instanceof IntrinsicReference;
+export const applyCollectionCallback = (runner, callback, name, node) => {
+    if (!isSupportedCallback(callback)) {
+        if (typeofValue(callback) === "function") {
+            throw new InterpreterRuntimeError(`${name} cannot use this callable as a callback; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
+        }
+        throw new InterpreterRuntimeError(`${name} expects a function callback.`, node);
+    }
+    return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node);
+};

package/dist/interpreter/runtime.d.ts

@@ -0,0 +1,19 @@
+import type { Program } from "acorn";
+import { Effect } from "effect";
+import { type Host } from "./globals.js";
+import { type Runner } from "./runner.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>;
+}