@opencode-ai/codemode 0.0.0-beta-17492

package/dist/interpreter/model.d.ts

@@ -0,0 +1,151 @@
+import type { Effect } from "effect";
+import type { SafeObject } from "../tool-runtime.js";
+import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js";
+export type SourcePosition = {
+    line: number;
+    column: number;
+};
+export type SourceLocation = {
+    start: SourcePosition;
+    end: SourcePosition;
+};
+export type AstNode = {
+    type: string;
+    loc?: SourceLocation;
+    [key: string]: unknown;
+};
+export type ProgramNode = AstNode & {
+    type: "Program";
+    body: Array<AstNode>;
+};
+export type Binding = {
+    mutable: boolean;
+    value: unknown;
+    initialized?: boolean;
+};
+export type StatementResult = {
+    kind: "none";
+} | {
+    kind: "return";
+    value: unknown;
+} | {
+    kind: "break";
+    label?: string;
+} | {
+    kind: "continue";
+    label?: string;
+};
+export type MemberReference = {
+    target: SafeObject | Array<unknown> | CodeModeRegExp | CodeModeURL;
+    key: PropertyKey;
+};
+export declare class CodeModeFunction {
+    readonly parameters: ReadonlyArray<AstNode>;
+    readonly body: AstNode;
+    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
+    readonly async: boolean;
+    readonly generator: boolean;
+    constructor(parameters: ReadonlyArray<AstNode>, body: AstNode, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+}
+export type GeneratorRequestKind = "next" | "return" | "throw";
+export declare class CodeModeGenerator {
+    readonly asynchronous: boolean;
+    readonly request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
+    constructor(asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
+}
+export declare class GeneratorMethodReference {
+    readonly generator: CodeModeGenerator;
+    readonly kind: GeneratorRequestKind | "iterator";
+    constructor(generator: CodeModeGenerator, kind: GeneratorRequestKind | "iterator");
+}
+export declare class IntrinsicReference {
+    readonly receiver: unknown;
+    readonly name: string;
+    constructor(receiver: unknown, name: string);
+}
+export declare class ComputedValue {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare class PromiseNamespace {
+}
+export declare class SymbolNamespace {
+}
+export declare const AsyncIteratorSymbol: unique symbol;
+export declare const IteratorSymbol: unique symbol;
+export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
+export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject";
+export declare class PromiseMethodReference {
+    readonly name: PromiseMethodName;
+    constructor(name: PromiseMethodName);
+}
+export type PromiseInstanceMethodName = "then" | "catch" | "finally";
+export declare class PromiseInstanceMethodReference {
+    readonly promise: CodeModePromise;
+    readonly name: PromiseInstanceMethodName;
+    constructor(promise: CodeModePromise, name: PromiseInstanceMethodName);
+}
+export declare class PromiseCapabilityFunction {
+    readonly settle: (value: unknown) => void;
+    constructor(settle: (value: unknown) => void);
+}
+export type GlobalNamespaceName = "Object" | "Math" | "JSON" | "Array" | "console" | "Date" | "RegExp" | "Map" | "Set" | "URL" | "URLSearchParams";
+export declare class GlobalNamespace {
+    readonly name: GlobalNamespaceName;
+    constructor(name: GlobalNamespaceName);
+}
+export declare class GlobalMethodReference {
+    readonly namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String";
+    readonly name: string;
+    constructor(namespace: Exclude<GlobalNamespaceName, "JSON"> | "Number" | "String", name: string);
+}
+export declare class JsonMethodReference {
+    readonly name: "parse" | "stringify";
+    constructor(name: "parse" | "stringify");
+}
+export declare class CoercionFunction {
+    readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+    constructor(name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN");
+}
+export declare class UriFunction {
+    readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
+    constructor(name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent");
+}
+export declare class SearchFunction {
+}
+export declare class ProgramThrow {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare class GeneratorReturn {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export declare class ErrorConstructorReference {
+    readonly name: string;
+    constructor(name: string);
+}
+export type DiagnosticKind = "ParseError" | "UnsupportedSyntax" | "UnknownTool" | "InvalidToolInput" | "InvalidToolOutput" | "InvalidDataValue" | "ToolCallLimitExceeded" | "TimeoutExceeded" | "ToolFailure" | "ExecutionFailure";
+export declare const OptionalShortCircuit: unique symbol;
+export declare const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
+export declare class InterpreterRuntimeError extends Error {
+    readonly kind: DiagnosticKind;
+    readonly suggestions?: ReadonlyArray<string> | undefined;
+    readonly node?: AstNode;
+    errorName: string;
+    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
+    as(errorName: string): this;
+}
+export declare const unsupportedSyntax: (kind: string, node: AstNode) => InterpreterRuntimeError;
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const asNode: (value: unknown, context: string) => AstNode;
+export declare const getArray: (node: AstNode, key: string) => Array<unknown>;
+export declare const getString: (node: AstNode, key: string) => string;
+export declare const getBoolean: (node: AstNode, key: string) => boolean;
+export declare const getOptionalNode: (node: AstNode, key: string) => AstNode | undefined;
+export declare const getNode: (node: AstNode, key: string) => AstNode;
+export declare const sourceLocation: (node: AstNode) => {
+    readonly line: number;
+    readonly column: number;
+};
+export declare const formatLocation: (node?: AstNode) => string;

package/dist/interpreter/model.js

@@ -0,0 +1,186 @@
+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;
+    constructor(asynchronous, request) {
+        this.asynchronous = asynchronous;
+        this.request = request;
+    }
+}
+export class GeneratorMethodReference {
+    generator;
+    kind;
+    constructor(generator, kind) {
+        this.generator = generator;
+        this.kind = kind;
+    }
+}
+export class IntrinsicReference {
+    receiver;
+    name;
+    constructor(receiver, name) {
+        this.receiver = receiver;
+        this.name = name;
+    }
+}
+export class ComputedValue {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class PromiseNamespace {
+}
+export class SymbolNamespace {
+}
+export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
+export const IteratorSymbol = Symbol("codemode.iterator");
+export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
+export class PromiseMethodReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class PromiseInstanceMethodReference {
+    promise;
+    name;
+    constructor(promise, name) {
+        this.promise = promise;
+        this.name = name;
+    }
+}
+export class PromiseCapabilityFunction {
+    settle;
+    constructor(settle) {
+        this.settle = settle;
+    }
+}
+export class GlobalNamespace {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class GlobalMethodReference {
+    namespace;
+    name;
+    constructor(namespace, name) {
+        this.namespace = namespace;
+        this.name = name;
+    }
+}
+export class JsonMethodReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class CoercionFunction {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class UriFunction {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export class SearchFunction {
+}
+export class ProgramThrow {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class GeneratorReturn {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+export class ErrorConstructorReference {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+}
+export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
+export const supportedSyntaxMessage = "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction.";
+export class InterpreterRuntimeError extends Error {
+    kind;
+    suggestions;
+    node;
+    errorName = "Error";
+    constructor(message, node, kind = "ExecutionFailure", suggestions) {
+        super(message);
+        this.kind = kind;
+        this.suggestions = suggestions;
+        this.name = "InterpreterRuntimeError";
+        if (node)
+            this.node = node;
+    }
+    as(errorName) {
+        this.errorName = errorName;
+        return this;
+    }
+}
+export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
+export const isRecord = (value) => typeof value === "object" && value !== null;
+export const asNode = (value, context) => {
+    if (!isRecord(value) || typeof value.type !== "string") {
+        throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`);
+    }
+    return value;
+};
+export const getArray = (node, key) => {
+    const value = node[key];
+    if (!Array.isArray(value))
+        throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node);
+    return value;
+};
+export const getString = (node, key) => {
+    const value = node[key];
+    if (typeof value !== "string")
+        throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node);
+    return value;
+};
+export const getBoolean = (node, key) => {
+    const value = node[key];
+    if (typeof value !== "boolean")
+        throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node);
+    return value;
+};
+export const getOptionalNode = (node, key) => {
+    const value = node[key];
+    if (value === undefined || value === null)
+        return undefined;
+    return asNode(value, key);
+};
+export const getNode = (node, key) => asNode(node[key], key);
+export const sourceLocation = (node) => ({
+    line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
+    column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
+});
+export const formatLocation = (node) => {
+    if (!node?.loc)
+        return "";
+    const location = sourceLocation(node);
+    return ` (line ${location.line}, col ${location.column})`;
+};

package/dist/interpreter/promises.d.ts

@@ -0,0 +1,29 @@
+import { Effect, Exit, Scope } from "effect";
+import type { Diagnostic } from "../codemode.js";
+import { type AstNode, InterpreterRuntimeError, PromiseInstanceMethodReference, PromiseMethodReference } from "./model.js";
+import { type CallbackRunner } from "./methods.js";
+import { CodeModePromise } from "../values.js";
+import type { SyncIteratorRunner } from "./iterator.js";
+export declare class PromiseRuntime<R> {
+    private readonly scope;
+    private readonly active;
+    private readonly ids;
+    private readonly observed;
+    private readonly failures;
+    private nextID;
+    constructor(scope: Scope.Scope);
+    create(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<CodeModePromise, never, R>;
+    markObserved(promise: CodeModePromise): void;
+    await(promise: CodeModePromise): Effect.Effect<Exit.Exit<unknown, unknown>>;
+    fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R>;
+    diagnostics(): Array<Diagnostic>;
+    interrupt(): Effect.Effect<Array<Diagnostic>>;
+}
+export declare const selfResolutionError: (node?: AstNode) => InterpreterRuntimeError;
+export declare const resolvePromiseValue: <R>(runner: CallbackRunner<R>, value: unknown, node: AstNode, own?: {
+    promise?: CodeModePromise;
+}) => Effect.Effect<unknown, unknown, R>;
+export declare const resolvePromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, value: unknown, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
+export declare const invokePromiseMethod: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, promises: PromiseRuntime<R>, ref: PromiseMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokePromiseInstanceMethod: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, ref: PromiseInstanceMethodReference, args: Array<unknown>, node: AstNode) => Effect.Effect<CodeModePromise, never, R>;
+export declare const constructPromise: <R>(runner: CallbackRunner<R>, promises: PromiseRuntime<R>, executor: unknown, node: AstNode) => Effect.Effect<CodeModePromise, unknown, R>;

package/dist/interpreter/promises.js

@@ -0,0 +1,253 @@
+import { Cause, Deferred, Effect, Exit, Fiber, Scope } from "effect";
+import { CodeModeFunction, InterpreterRuntimeError, ProgramThrow, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, } from "./model.js";
+import { caughtErrorValue, normalizeError } from "./errors.js";
+import { applyCollectionCallback, isSupportedCallback } from "./methods.js";
+import { typeofValue } from "./references.js";
+import { createAggregateErrorValue } from "../stdlib/value.js";
+import { CodeModePromise } from "../values.js";
+// Observation only controls rejection reporting; program completion interrupts all promise work.
+export class PromiseRuntime {
+    scope;
+    active = new Set();
+    ids = new WeakMap();
+    observed = new WeakSet();
+    failures = new Map();
+    nextID = 0;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    create(effect) {
+        return Effect.suspend(() => {
+            // Allocate before forking so reruns get distinct IDs and diagnostics retain creation order.
+            const id = this.nextID++;
+            return Effect.map(Effect.forkIn(effect, this.scope, { startImmediately: true }), (fiber) => {
+                const promise = new CodeModePromise(fiber);
+                this.active.add(promise);
+                this.ids.set(promise, id);
+                fiber.addObserver((exit) => {
+                    this.active.delete(promise);
+                    if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || this.observed.has(promise)) {
+                        this.ids.delete(promise);
+                        return;
+                    }
+                    const failure = normalizeError(Cause.squash(exit.cause));
+                    this.failures.set(id, {
+                        ...failure,
+                        message: `Unhandled rejection from an un-awaited promise: ${failure.message}`,
+                    });
+                });
+                return promise;
+            });
+        });
+    }
+    // Observation must be recorded when responsibility transfers, before the consumer fiber runs.
+    markObserved(promise) {
+        this.observed.add(promise);
+        const id = this.ids.get(promise);
+        this.ids.delete(promise);
+        if (id !== undefined)
+            this.failures.delete(id);
+    }
+    await(promise) {
+        return Fiber.await(promise.fiber);
+    }
+    fork(effect) {
+        return Effect.asVoid(Effect.forkIn(effect, this.scope, { startImmediately: true }));
+    }
+    diagnostics() {
+        return [...this.failures].sort(([left], [right]) => left - right).map(([, failure]) => failure);
+    }
+    // Re-check because a straggler can create promises before its interruption lands.
+    interrupt() {
+        const self = this;
+        return Effect.gen(function* () {
+            while (self.active.size > 0) {
+                yield* Fiber.interruptAll([...self.active].map((promise) => promise.fiber));
+            }
+            return self.diagnostics();
+        });
+    }
+}
+export const selfResolutionError = (node) => new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node).as("TypeError");
+export const resolvePromiseValue = (runner, value, node, own) => {
+    if (own?.promise !== undefined && value === own.promise)
+        return Effect.fail(selfResolutionError(node));
+    if (value instanceof CodeModePromise)
+        return runner.settlePromise(value);
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then"))
+        return Effect.succeed(value);
+    const then = value.then;
+    if (typeofValue(then) !== "function")
+        return Effect.succeed(value);
+    return Effect.gen(function* () {
+        // Promise resolution invokes a thenable's method in a later job.
+        yield* Effect.yieldNow;
+        const deferred = Deferred.makeUnsafe();
+        const resolve = new PromiseCapabilityFunction((result) => {
+            Deferred.doneUnsafe(deferred, Exit.succeed(result));
+        });
+        const reject = new PromiseCapabilityFunction((reason) => {
+            Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason)));
+        });
+        const executed = yield* Effect.exit(runner.invokeCallable(then, [resolve, reject], node));
+        if (!Exit.isSuccess(executed)) {
+            if (Cause.hasInterruptsOnly(executed.cause))
+                return yield* Effect.failCause(executed.cause);
+            Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
+        }
+        return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), node, own);
+    });
+};
+export const resolvePromise = (runner, promises, value, node) => {
+    if (value instanceof CodeModePromise)
+        return Effect.succeed(value);
+    const box = {};
+    return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
+        box.promise = promise;
+        return promise;
+    });
+};
+export const invokePromiseMethod = (runner, promises, ref, args, node) => {
+    if (ref.name === "resolve") {
+        return resolvePromise(runner, promises, args[0], node);
+    }
+    if (ref.name === "reject") {
+        return promises.create(Effect.fail(new ProgramThrow(args[0])));
+    }
+    return promises.create(Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(args[0], node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError(`Promise.${ref.name} expects an array or other synchronous iterable.`, node).as("TypeError");
+        }
+        const items = [];
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                break;
+            const item = yield* resolvePromise(runner, promises, step.value, node);
+            promises.markObserved(item);
+            items.push(item);
+        }
+        if (ref.name === "all") {
+            return yield* settleAfterTurn(Effect.all(items.map((item) => Effect.flatten(promises.await(item))), { concurrency: "unbounded" }));
+        }
+        if (ref.name === "allSettled") {
+            const outcomes = [];
+            for (const item of items) {
+                const exit = yield* promises.await(item);
+                if (Exit.isSuccess(exit)) {
+                    outcomes.push(Object.assign(Object.create(null), { status: "fulfilled", value: exit.value }));
+                    continue;
+                }
+                if (Cause.hasInterruptsOnly(exit.cause))
+                    return yield* Effect.failCause(exit.cause);
+                outcomes.push(Object.assign(Object.create(null), {
+                    status: "rejected",
+                    reason: caughtErrorValue(Cause.squash(exit.cause)),
+                }));
+            }
+            yield* Effect.yieldNow;
+            return outcomes;
+        }
+        if (ref.name === "race") {
+            if (items.length === 0) {
+                throw new InterpreterRuntimeError("Promise.race([]) would never settle; provide at least one promise or value.", node);
+            }
+            return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))));
+        }
+        const flipped = items.map((item) => Effect.flatMap(promises.await(item), (exit) => {
+            if (Exit.isSuccess(exit))
+                return Effect.fail(new PromiseAnyFulfilled(exit.value));
+            if (Cause.hasInterruptsOnly(exit.cause))
+                return Effect.failCause(exit.cause);
+            return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)));
+        }));
+        return yield* settleAfterTurn(Effect.all(flipped, { concurrency: "unbounded" }).pipe(Effect.flatMap((reasons) => Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected")))), Effect.catch((error) => error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error))));
+    }));
+};
+export const invokePromiseInstanceMethod = (runner, promises, ref, args, node) => {
+    const method = `Promise.prototype.${ref.name}`;
+    promises.markObserved(ref.promise);
+    if (ref.name === "finally") {
+        return chainFinally(runner, promises, ref.promise, reactionHandler(args[0], method, node), method, node);
+    }
+    const onFulfilled = ref.name === "then" ? reactionHandler(args[0], method, node) : undefined;
+    const onRejected = reactionHandler(ref.name === "then" ? args[1] : args[0], method, node);
+    return chainReaction(runner, promises, ref.promise, onFulfilled, onRejected, method, node);
+};
+export const constructPromise = (runner, promises, executor, node) => {
+    if (!(executor instanceof CodeModeFunction)) {
+        throw new InterpreterRuntimeError("new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).", node).as("TypeError");
+    }
+    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 resolve = new PromiseCapabilityFunction((value) => {
+            Deferred.doneUnsafe(deferred, Exit.succeed(value));
+        });
+        const reject = new PromiseCapabilityFunction((value) => {
+            Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value)));
+        });
+        const executed = yield* Effect.exit(runner.invokeFunction(executor, [resolve, reject]));
+        if (!Exit.isSuccess(executed)) {
+            if (Cause.hasInterruptsOnly(executed.cause))
+                return yield* Effect.failCause(executed.cause);
+            Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)));
+        }
+        return promise;
+    });
+};
+// Settle one reaction turn after the deciding member, after its existing reactions.
+const settleAfterTurn = (body) => Effect.flatMap(Effect.exit(body), (exit) => Effect.andThen(Effect.yieldNow, exit));
+class PromiseAnyFulfilled {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+const reactionHandler = (value, method, node) => {
+    if (isSupportedCallback(value))
+        return value;
+    if (typeofValue(value) === "function") {
+        throw new InterpreterRuntimeError(`${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node);
+    }
+    return undefined;
+};
+// Teardown bypasses handlers; settled reactions yield once so handlers never run inline.
+const reactionExit = (promises, source) => Effect.gen(function* () {
+    const exit = yield* promises.await(source);
+    if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause))
+        return yield* Effect.failCause(exit.cause);
+    yield* Effect.yieldNow;
+    return exit;
+});
+const chainReaction = (runner, promises, source, onFulfilled, onRejected, method, node) => {
+    const box = {};
+    const body = 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;
+    });
+};
+const chainFinally = (runner, promises, source, cleanup, method, node) => promises.create(Effect.gen(function* () {
+    const exit = yield* reactionExit(promises, source);
+    if (cleanup !== undefined) {
+        const result = yield* applyCollectionCallback(runner, cleanup, method, node)([]);
+        const intermediate = yield* promises.create(Effect.gen(function* () {
+            yield* runner.settlePromise(yield* resolvePromise(runner, promises, result, node));
+            return yield* exit;
+        }));
+        return yield* runner.settlePromise(intermediate);
+    }
+    return yield* exit;
+}));

package/dist/interpreter/references.d.ts

@@ -0,0 +1,6 @@
+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) => void;
+export declare const typeofValue: (value: unknown) => string;