@opencode-ai/codemode 0.0.0-next-17250

package/dist/stdlib/math.js

@@ -0,0 +1,157 @@
+import { Effect } from "effect";
+import { preserveConsumerError } from "../interpreter/iterator.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"]);
+export const mathMethods = new Set([
+    "random",
+    "max",
+    "min",
+    "abs",
+    "acos",
+    "acosh",
+    "asin",
+    "asinh",
+    "atan",
+    "atan2",
+    "atanh",
+    "floor",
+    "ceil",
+    "round",
+    "trunc",
+    "sign",
+    "sqrt",
+    "cbrt",
+    "pow",
+    "hypot",
+    "cos",
+    "cosh",
+    "sin",
+    "sinh",
+    "tan",
+    "tanh",
+    "log",
+    "log2",
+    "log10",
+    "log1p",
+    "exp",
+    "expm1",
+    "f16round",
+    "fround",
+    "clz32",
+    "imul",
+    "sumPrecise",
+]);
+export const invokeMathMethod = (name, args, node) => {
+    if (!mathMethods.has(name))
+        throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
+    if (name === "random")
+        return Math.random();
+    // Validate only the arguments the method consumes; like JS, extras are ignored
+    // (so built-ins work as callbacks receiving (element, index, array)).
+    const num = (index) => {
+        if (index >= args.length)
+            return Number.NaN;
+        const arg = args[index];
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+        return arg;
+    };
+    const nums = () => args.map((arg) => {
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node);
+        return arg;
+    });
+    const a = num(0);
+    const b = () => num(1);
+    switch (name) {
+        case "max":
+            return Math.max(...nums());
+        case "min":
+            return Math.min(...nums());
+        case "abs":
+            return Math.abs(a);
+        case "acos":
+            return Math.acos(a);
+        case "acosh":
+            return Math.acosh(a);
+        case "asin":
+            return Math.asin(a);
+        case "asinh":
+            return Math.asinh(a);
+        case "atan":
+            return Math.atan(a);
+        case "atan2":
+            return Math.atan2(a, b());
+        case "atanh":
+            return Math.atanh(a);
+        case "floor":
+            return Math.floor(a);
+        case "ceil":
+            return Math.ceil(a);
+        case "round":
+            return Math.round(a);
+        case "trunc":
+            return Math.trunc(a);
+        case "sign":
+            return Math.sign(a);
+        case "sqrt":
+            return Math.sqrt(a);
+        case "cbrt":
+            return Math.cbrt(a);
+        case "pow":
+            return Math.pow(a, b());
+        case "hypot":
+            return Math.hypot(...nums());
+        case "cos":
+            return Math.cos(a);
+        case "cosh":
+            return Math.cosh(a);
+        case "sin":
+            return Math.sin(a);
+        case "sinh":
+            return Math.sinh(a);
+        case "tan":
+            return Math.tan(a);
+        case "tanh":
+            return Math.tanh(a);
+        case "log":
+            return Math.log(a);
+        case "log2":
+            return Math.log2(a);
+        case "log10":
+            return Math.log10(a);
+        case "log1p":
+            return Math.log1p(a);
+        case "exp":
+            return Math.exp(a);
+        case "expm1":
+            return Math.expm1(a);
+        case "f16round":
+            return Math.f16round(a);
+        case "fround":
+            return Math.fround(a);
+        case "clz32":
+            return Math.clz32(a);
+        case "imul":
+            return Math.imul(a, b());
+    }
+    throw new InterpreterRuntimeError(`Math.${name} is not available.`, node);
+};
+export const invokeMathSumPrecise = (runner, source, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(source, node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError");
+    }
+    const numbers = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done)
+            return Math.sumPrecise(numbers);
+        yield* preserveConsumerError(cursor, Effect.sync(() => {
+            if (typeof step.value !== "number") {
+                throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError");
+            }
+            numbers.push(step.value);
+        }));
+    }
+});

package/dist/stdlib/number.d.ts

@@ -0,0 +1,6 @@
+export declare const numberMethods: Set<string>;
+export declare const numberConstants: Set<string>;
+export declare const numberStatics: Set<string>;
+export declare const invokeNumberMethod: (value: number, name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeNumberStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/number.js

@@ -0,0 +1,76 @@
+export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString", "valueOf"]);
+export const numberConstants = new Set([
+    "MAX_SAFE_INTEGER",
+    "MIN_SAFE_INTEGER",
+    "MAX_VALUE",
+    "MIN_VALUE",
+    "EPSILON",
+    "NaN",
+    "POSITIVE_INFINITY",
+    "NEGATIVE_INFINITY",
+]);
+export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"]);
+export const invokeNumberMethod = (value, name, args, node) => {
+    const optNum = (index) => {
+        const arg = args[index];
+        if (arg === undefined)
+            return undefined;
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node);
+        return arg;
+    };
+    let result;
+    switch (name) {
+        case "toFixed":
+            result = value.toFixed(optNum(0));
+            break;
+        case "toExponential":
+            result = value.toExponential(optNum(0));
+            break;
+        case "toPrecision": {
+            const digits = optNum(0);
+            result = digits === undefined ? value.toString() : value.toPrecision(digits);
+            break;
+        }
+        case "toString": {
+            const radix = optNum(0);
+            if (radix !== undefined && (radix < 2 || radix > 36)) {
+                throw new InterpreterRuntimeError("Number.toString radix must be between 2 and 36.", node);
+            }
+            result = value.toString(radix);
+            break;
+        }
+        case "valueOf":
+            result = value;
+            break;
+        default:
+            throw new InterpreterRuntimeError(`Number method '${name}' is not available.`, node);
+    }
+    return boundedData(result, `Number.${name} result`);
+};
+export const invokeNumberStatic = (name, args, node) => {
+    const value = args[0];
+    switch (name) {
+        case "isInteger":
+            return Number.isInteger(value);
+        case "isFinite":
+            return Number.isFinite(value);
+        case "isNaN":
+            return Number.isNaN(value);
+        case "isSafeInteger":
+            return Number.isSafeInteger(value);
+        case "parseInt": {
+            const radix = args[1];
+            if (radix !== undefined && typeof radix !== "number") {
+                throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node);
+            }
+            return parseInt(coerceToString(value), radix);
+        }
+        case "parseFloat":
+            return parseFloat(coerceToString(value));
+        default:
+            throw new InterpreterRuntimeError(`Number.${name} is not available.`, node);
+    }
+};
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/object.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { type AstNode } from "../interpreter/model.js";
+import { type SyncIteratorRunner } from "../interpreter/iterator.js";
+export declare const objectMethodsPreservingIdentity: Set<string>;
+export declare const objectStatics: Set<string>;
+export declare const invokeObjectMethod: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeObjectFromEntries: <R>(runner: SyncIteratorRunner<R>, source: unknown, node: AstNode) => Effect.Effect<Record<string, unknown>, unknown, R>;

package/dist/stdlib/object.js

@@ -0,0 +1,100 @@
+import { Effect } from "effect";
+import { AsyncIteratorSymbol, InterpreterRuntimeError, IteratorSymbol, IteratorSymbols, } from "../interpreter/model.js";
+import { containsOpaqueReference } from "../interpreter/references.js";
+import { isBlockedMember } from "../tool-runtime.js";
+import { isCodeModeValue, CodeModePromise } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";
+import { preserveConsumerError } from "../interpreter/iterator.js";
+export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"]);
+export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries", "groupBy"]);
+export const invokeObjectMethod = (name, args, node) => {
+    const requireObject = () => {
+        const input = args[0];
+        if (Array.isArray(input))
+            return input;
+        if (isCodeModeValue(input))
+            return {};
+        if (input instanceof CodeModePromise) {
+            throw new InterpreterRuntimeError(`Object.${name} received an un-awaited Promise; await it before inspecting the result.`, node, "InvalidDataValue");
+        }
+        if (input === null || typeof input !== "object") {
+            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+        }
+        const prototype = Object.getPrototypeOf(input);
+        if (prototype !== null && prototype !== Object.prototype) {
+            throw new InterpreterRuntimeError(`Object.${name} expects a data object or array.`, node, "InvalidDataValue");
+        }
+        return input;
+    };
+    const guardedSet = (out, key, item) => {
+        if (isBlockedMember(key))
+            throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
+        out[key] = item;
+    };
+    switch (name) {
+        case "keys":
+            return Object.keys(requireObject());
+        case "values":
+            return Object.values(requireObject());
+        case "entries":
+            return Object.entries(requireObject()).map(([key, item]) => [key, item]);
+        case "hasOwn":
+            return Object.hasOwn(requireObject(), args[1] === AsyncIteratorSymbol || args[1] === IteratorSymbol ? args[1] : String(args[1]));
+        case "is":
+            if (containsOpaqueReference(args[0]) || containsOpaqueReference(args[1])) {
+                throw new InterpreterRuntimeError("Object.is requires data values.", node, "InvalidDataValue");
+            }
+            return Object.is(args[0], args[1]);
+        case "assign": {
+            const target = args[0];
+            if (target === null || typeof target !== "object" || Array.isArray(target) || isCodeModeValue(target)) {
+                throw new InterpreterRuntimeError("Object.assign expects a data object target.", node);
+            }
+            const out = target;
+            for (const source of args.slice(1)) {
+                if (source === null || source === undefined || isCodeModeValue(source))
+                    continue;
+                if (typeof source !== "object" || Array.isArray(source)) {
+                    throw new InterpreterRuntimeError("Object.assign expects data objects.", node);
+                }
+                for (const [key, item] of Object.entries(source))
+                    guardedSet(out, key, item);
+                for (const symbol of IteratorSymbols) {
+                    if (Object.hasOwn(source, symbol))
+                        Reflect.set(out, symbol, Reflect.get(source, symbol));
+                }
+            }
+            return out;
+        }
+    }
+    throw new InterpreterRuntimeError(`Object.${name} is not available.`, node);
+};
+export const invokeObjectFromEntries = (runner, source, node) => {
+    const out = Object.create(null);
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(source, node);
+        if (cursor === undefined) {
+            throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node).as("TypeError");
+        }
+        while (true) {
+            const step = yield* cursor.next;
+            if (step.done)
+                return out;
+            yield* preserveConsumerError(cursor, Effect.sync(() => {
+                if (step.value === null ||
+                    typeof step.value !== "object" ||
+                    isCodeModeValue(step.value) ||
+                    containsOpaqueReference(step.value)) {
+                    throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as("TypeError");
+                }
+                const entry = step.value;
+                boundedData(entry[0], "Object.fromEntries key");
+                boundedData(entry[1], "Object.fromEntries value");
+                const key = coerceToString(entry[0]);
+                if (isBlockedMember(key))
+                    throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node);
+                out[key] = entry[1];
+            }));
+        }
+    });
+};

package/dist/stdlib/promise.d.ts

@@ -0,0 +1,2 @@
+import type { PromiseMethodName } from "../interpreter/model.js";
+export declare const promiseStatics: Set<PromiseMethodName>;

package/dist/stdlib/promise.js

@@ -0,0 +1 @@
+export const promiseStatics = new Set(["all", "allSettled", "race", "any", "resolve", "reject"]);

package/dist/stdlib/regexp.d.ts

@@ -0,0 +1,11 @@
+import { type AstNode } from "../interpreter/model.js";
+import { CodeModeRegExp } from "../values.js";
+export declare const regexpMethods: Set<string>;
+export declare const regexpStatics: Set<string>;
+export declare const regexpProperties: Set<string>;
+export declare const regexFailureReason: (error: unknown) => string;
+export declare const escapeRegexHint = "To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. \"\\\\(\") or test for them with String.includes instead.";
+export declare const toHostRegex: (arg: unknown, method: string, node: AstNode, extraFlags?: string) => RegExp;
+export declare const matchToValue: (match: RegExpMatchArray) => Array<unknown>;
+export declare const invokeRegExpStatic: (name: string, args: Array<unknown>, node: AstNode) => string;
+export declare const invokeRegExpMethod: (value: CodeModeRegExp, name: string, args: Array<unknown>, node: AstNode) => unknown;

package/dist/stdlib/regexp.js

@@ -0,0 +1,106 @@
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { isBlockedMember } from "../tool-runtime.js";
+import { CodeModeRegExp } from "../values.js";
+import { coerceToNumber, coerceToString } from "./value.js";
+export const regexpMethods = new Set(["test", "exec", "toString"]);
+export const regexpStatics = new Set(["escape"]);
+export const regexpProperties = new Set([
+    "source",
+    "flags",
+    "lastIndex",
+    "hasIndices",
+    "global",
+    "ignoreCase",
+    "multiline",
+    "sticky",
+    "unicode",
+    "unicodeSets",
+    "dotAll",
+]);
+export const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
+export const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
+export const toHostRegex = (arg, method, node, extraFlags = "") => {
+    // Native parity: an undefined pattern behaves as an empty pattern.
+    if (arg === undefined)
+        return new RegExp("", extraFlags);
+    if (arg instanceof CodeModeRegExp)
+        return arg.regex;
+    if (typeof arg === "string") {
+        try {
+            return new RegExp(arg, extraFlags);
+        }
+        catch (error) {
+            throw new InterpreterRuntimeError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node).as("SyntaxError");
+        }
+    }
+    throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
+};
+export const matchToValue = (match) => {
+    const result = Array.from(match, (group) => group);
+    if (match.index !== undefined)
+        result.index = match.index;
+    if (match.groups) {
+        const groups = Object.create(null);
+        for (const [key, group] of Object.entries(match.groups)) {
+            if (!isBlockedMember(key))
+                groups[key] = group;
+        }
+        result.groups = groups;
+    }
+    if (match.indices)
+        result.indices = indicesToValue(match.indices);
+    return result;
+};
+export const invokeRegExpStatic = (name, args, node) => {
+    if (name !== "escape")
+        throw new InterpreterRuntimeError(`RegExp.${name} is not available.`, node);
+    if (typeof args[0] !== "string") {
+        throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
+    }
+    return RegExp.escape(args[0]);
+};
+export const invokeRegExpMethod = (value, name, args, node) => {
+    switch (name) {
+        case "test":
+        case "exec": {
+            const input = coerceToString(args[0]);
+            const lastIndex = value.lastIndex;
+            const stateful = value.regex.global || value.regex.sticky;
+            value.regex.lastIndex = toLength(lastIndex);
+            if (name === "test") {
+                const matched = value.regex.test(input);
+                if (!stateful)
+                    value.lastIndex = lastIndex;
+                return matched;
+            }
+            const matched = value.regex.exec(input);
+            if (!stateful)
+                value.lastIndex = lastIndex;
+            return matched === null ? null : matchToValue(matched);
+        }
+        case "toString":
+            return coerceToString(value);
+        default:
+            throw new InterpreterRuntimeError(`RegExp method '${name}' is not available.`, node);
+    }
+};
+const toLength = (value) => {
+    const number = coerceToNumber(value);
+    if (Number.isNaN(number) || number <= 0)
+        return 0;
+    return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
+};
+const indicesToValue = (indices) => {
+    const result = Array.from(indices, (range) => (range === undefined ? undefined : [...range]));
+    if (indices.groups) {
+        const groups = Object.create(null);
+        for (const [key, range] of Object.entries(indices.groups)) {
+            if (!isBlockedMember(key))
+                groups[key] = range === undefined ? undefined : [...range];
+        }
+        result.groups = groups;
+        return result;
+    }
+    result.groups = undefined;
+    return result;
+};

package/dist/stdlib/string.d.ts

@@ -0,0 +1,4 @@
+export declare const stringMethods: Set<string>;
+export declare const stringStatics: Set<string>;
+export declare const invokeStringStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode } from "../interpreter/model.js";

package/dist/stdlib/string.js

@@ -0,0 +1,48 @@
+export const stringMethods = new Set([
+    "toLowerCase",
+    "toUpperCase",
+    "trim",
+    "trimStart",
+    "trimEnd",
+    "split",
+    "slice",
+    "substring",
+    "includes",
+    "startsWith",
+    "endsWith",
+    "indexOf",
+    "lastIndexOf",
+    "replace",
+    "replaceAll",
+    "repeat",
+    "padStart",
+    "padEnd",
+    "charAt",
+    "charCodeAt",
+    "codePointAt",
+    "at",
+    "concat",
+    "toString",
+    "match",
+    "matchAll",
+    "search",
+    "localeCompare",
+    "normalize",
+]);
+export const stringStatics = new Set(["fromCharCode", "fromCodePoint"]);
+export const invokeStringStatic = (name, args, node) => {
+    const codes = args.map((arg) => {
+        if (typeof arg !== "number")
+            throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+        return arg;
+    });
+    switch (name) {
+        case "fromCharCode":
+            return String.fromCharCode(...codes);
+        case "fromCodePoint":
+            return String.fromCodePoint(...codes);
+        default:
+            throw new InterpreterRuntimeError(`String.${name} is not available.`, node);
+    }
+};
+import { InterpreterRuntimeError } from "../interpreter/model.js";

package/dist/stdlib/url.d.ts

@@ -0,0 +1,12 @@
+export declare const urlProperties: Set<string>;
+export declare const urlWritableProperties: Set<string>;
+export declare const urlMethods: Set<string>;
+export declare const urlStatics: Set<string>;
+export declare const urlSearchParamsMethods: Set<string>;
+export declare const uriArgument: (value: unknown, label: string) => string;
+export declare const invokeUriFunction: (ref: UriFunction, args: Array<unknown>, node: AstNode) => string;
+export declare const urlArgument: (value: unknown, label: string) => string;
+export declare const invokeURLStatic: (name: string, args: Array<unknown>, node: AstNode) => unknown;
+export declare const invokeURLMethod: (value: CodeModeURL, name: string, node: AstNode) => string;
+import { type AstNode, UriFunction } from "../interpreter/model.js";
+import { CodeModeURL } from "../values.js";

package/dist/stdlib/url.js

@@ -0,0 +1,84 @@
+export const urlProperties = new Set([
+    "href",
+    "origin",
+    "protocol",
+    "username",
+    "password",
+    "host",
+    "hostname",
+    "port",
+    "pathname",
+    "search",
+    "hash",
+]);
+export const urlWritableProperties = new Set([
+    "href",
+    "protocol",
+    "username",
+    "password",
+    "host",
+    "hostname",
+    "port",
+    "pathname",
+    "search",
+    "hash",
+]);
+export const urlMethods = new Set(["toString", "toJSON"]);
+export const urlStatics = new Set(["canParse", "parse"]);
+export const urlSearchParamsMethods = new Set([
+    "append",
+    "delete",
+    "get",
+    "getAll",
+    "has",
+    "set",
+    "sort",
+    "forEach",
+    "keys",
+    "values",
+    "entries",
+    "toString",
+]);
+export const uriArgument = (value, label) => coerceToString(boundedData(value, label));
+export const invokeUriFunction = (ref, args, node) => {
+    const value = uriArgument(args[0], `${ref.name} input`);
+    try {
+        switch (ref.name) {
+            case "encodeURI":
+                return encodeURI(value);
+            case "encodeURIComponent":
+                return encodeURIComponent(value);
+            case "decodeURI":
+                return decodeURI(value);
+            case "decodeURIComponent":
+                return decodeURIComponent(value);
+        }
+    }
+    catch (error) {
+        throw new InterpreterRuntimeError(`${ref.name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+    }
+};
+export const urlArgument = (value, label) => value instanceof CodeModeURL ? value.url.href : uriArgument(value, label);
+export const invokeURLStatic = (name, args, node) => {
+    if (!urlStatics.has(name))
+        throw new InterpreterRuntimeError(`URL.${name} is not available.`, node);
+    if (args.length === 0)
+        throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError");
+    const input = urlArgument(args[0], `URL.${name} input`);
+    const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
+    try {
+        const url = new URL(input, base);
+        return name === "canParse" ? true : new CodeModeURL(url);
+    }
+    catch {
+        return name === "canParse" ? false : null;
+    }
+};
+export const invokeURLMethod = (value, name, node) => {
+    if (name === "toString" || name === "toJSON")
+        return value.url.href;
+    throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
+};
+import { InterpreterRuntimeError, UriFunction } from "../interpreter/model.js";
+import { CodeModeURL } from "../values.js";
+import { boundedData, coerceToString } from "./value.js";

package/dist/stdlib/value.d.ts

@@ -0,0 +1,12 @@
+export declare const errorConstructors: Set<string>;
+export declare const valueConstructors: Set<string>;
+export declare const compoundOperators: Set<string>;
+export declare const createErrorValue: (name: string, message: string) => SafeObject;
+export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => SafeObject;
+export declare const errorBrandName: (value: unknown) => string | undefined;
+export declare const boundedData: (value: unknown, label: string) => unknown;
+export declare const coerceToString: (value: unknown) => string;
+export declare const coerceToNumber: (value: unknown) => number;
+export declare const invokeCoercion: (ref: CoercionFunction, args: Array<unknown>, node: AstNode) => unknown;
+import { type AstNode, CoercionFunction } from "../interpreter/model.js";
+import { type SafeObject } from "../tool-runtime.js";