From ea89a2f6198e71d98153f6191e22ab13ef827029 Mon Sep 17 00:00:00 2001 From: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Date: Tue, 14 Jul 2026 15:25:39 -0500 Subject: [PATCH] feat(codemode): unify callback acceptance and support built-in references (#36771) --- packages/codemode/interpreter-support.md | 51 +++- packages/codemode/src/interpreter/methods.ts | 183 ++++++++----- packages/codemode/src/interpreter/promises.ts | 25 +- packages/codemode/src/interpreter/runtime.ts | 69 ++++- packages/codemode/src/stdlib/json.ts | 18 +- packages/codemode/src/stdlib/math.ts | 28 +- packages/codemode/src/stdlib/value.ts | 11 + packages/codemode/src/tool-runtime.ts | 3 +- packages/codemode/test/callbacks.test.ts | 258 ++++++++++++++++++ .../codemode/test/promise-test262.test.ts | 3 +- packages/codemode/test/promise.test.ts | 5 +- 11 files changed, 530 insertions(+), 124 deletions(-) create mode 100644 packages/codemode/test/callbacks.test.ts diff --git a/packages/codemode/interpreter-support.md b/packages/codemode/interpreter-support.md index 692e5d03e2..f32f6c258e 100644 --- a/packages/codemode/interpreter-support.md +++ b/packages/codemode/interpreter-support.md @@ -77,16 +77,28 @@ ultimate source of truth. - [x] Synchronous and `async` functions. - [x] Closures, recursion, default parameters, rest parameters, and destructured parameters. - [x] Expression and block function bodies. -- [x] User callbacks for the supported Array, Map, Set, URLSearchParams, sort, and string-replacement APIs. -- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, and URI helpers as callbacks where applicable. +- [x] User callbacks for the supported Array, Map, Set, URLSearchParams, sort, string-replacement, and `Array.from` + mapper APIs, with one shared acceptance rule everywhere including promise reactions. +- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, and URI helpers as callbacks. +- [x] Built-in method references as callbacks, such as `values.map(Math.abs)`, `records.map(JSON.stringify)`, + `items.forEach(console.log)`, and `Promise.resolve(-1).then(Math.abs)`. Extra callback arguments a built-in + does not consume are ignored, like JS; consumed arguments stay strictly validated (`Math.floor` still rejects a + string). Intrinsic references keep their receiver (`"abc".includes` works as a predicate), unlike detached JS + methods, which lose `this`. +- [x] Constructors work as callbacks with JS call semantics: `Error` types construct (`messages.map(Error)`), + and new-requiring constructors (`Map`, `Set`, `URL`, `URLSearchParams`, `Promise`) throw a `TypeError`, + like JS. +- [x] Tool references and detached `Promise` statics are rejected as callbacks with a hint to wrap them in an + arrow function. - [x] Async string replacement callbacks; replacements are evaluated sequentially. -- [ ] `this`, `super`, constructor functions, or function prototype methods such as `call`, `apply`, and `bind`. +- [x] The optional `thisArg` of iteration methods is accepted and ignored: CodeMode functions have no `this`, so + ignoring it matches JS arrow-function semantics exactly. +- [ ] `this`, `super`, user-defined constructor functions, or function prototype methods such as `call`, `apply`, + and `bind`. - [ ] Classes and private fields. - [ ] Generator functions and `yield`. - [ ] Async predicates, reducers, and comparators with automatic awaiting. Async mapping can be joined explicitly with `Promise.all`, but a promise is not a meaningful predicate or sort result. -- [ ] General built-in callable references as callbacks, such as `values.map(Math.abs)` or - `records.map(JSON.stringify)`. ## Expressions and operators @@ -137,14 +149,17 @@ ultimate source of truth. - [x] `new Promise((resolve, reject) => ...)`: the executor runs synchronously and receives first-class resolve/reject callables that settle the promise exactly once (they may escape the executor and settle later); an executor throw rejects unless the promise already settled, resolving with a promise adopts it, and resolving with the - promise itself rejects with a `TypeError`. Resolver callables work as `.then`/`.catch` handlers and collection - callbacks but remain opaque references that cannot cross the data boundary. + promise itself rejects with a `TypeError`. Resolver callables work anywhere callbacks are accepted, including + `.then`/`.catch` handlers and collection callbacks, but remain opaque references that cannot cross the data + boundary. - [ ] Thenable assimilation (objects with a `then` method are plain data, not promises). - [ ] Async iterables, host streams, and stream consumption. ## Objects and properties - [x] Own-field reads and writes on plain data objects. +- [x] `Object()` and `new Object()` return `{}` for nullish arguments and pass objects through unchanged; + primitive wrapper objects (`Object(1)`) are rejected explicitly. - [x] Computed property names and object spread. - [x] `Object.keys`, `Object.values`, `Object.entries`, `Object.hasOwn`, `Object.assign`, and `Object.fromEntries`. - [x] `Object.keys` over arrays and tool references. @@ -157,7 +172,12 @@ ultimate source of truth. ## Arrays -- [x] Static methods: `Array.isArray`, `Array.of`, and `Array.from`. +- [x] The `Array` constructor with or without `new`: `Array(a, b)` collects arguments, `Array(n)` creates a + sparse array of that length (invalid lengths throw a `RangeError`). Holes behave like JS in iteration, + spread, join, and JSON; `sort` densifies holes into trailing `undefined`, and results returned to the + host normalize holes to `null`. +- [x] Static methods: `Array.isArray`, `Array.of`, and `Array.from`, including the `Array.from` mapper form with + `(value, index)` arguments. - [x] Iteration/transformation: `map`, `filter`, `flatMap`, and `forEach`. - [x] Searching/tests: `find`, `findIndex`, `findLast`, `findLastIndex`, `some`, `every`, `includes`, `indexOf`, and `lastIndexOf`. @@ -167,7 +187,7 @@ ultimate source of truth. - [x] Mutation: `push`, `pop`, `shift`, `unshift`, `splice`, `fill`, and `copyWithin`. - [x] Materialized iteration helpers: `keys`, `values`, and `entries` return arrays rather than iterators. - [x] `length`, numeric indexing, index assignment, spread, and `for...of`. -- [ ] The mapper and `thisArg` forms of `Array.from`. +- [x] The `thisArg` argument of `Array.from` is accepted and ignored, like JS arrows. - [ ] `Array.prototype.toSpliced`. - [ ] Canonical index handling: a key such as `"01"` must not alias index `1`. - [ ] Complete sparse-array parity. Promise combinators do consume holes as `undefined` members, as in JS. @@ -219,6 +239,8 @@ ultimate source of truth. - [x] `Date.now`, `Date.parse`, and `Date.UTC`. - [x] `new Date()` from the current time, epoch milliseconds, a date string, another Date, or local components. +- [x] `Date()` without `new` returns the current time as a string, like JS, but in deterministic ISO format + rather than the host's locale/timezone string. - [x] `getTime`, `valueOf`, `toISOString`, `toJSON`, and deterministic ISO `toString`. - [x] Local getters: `getFullYear`, `getMonth`, `getDate`, `getDay`, `getHours`, `getMinutes`, `getSeconds`, and `getMilliseconds`. @@ -234,7 +256,7 @@ ultimate source of truth. ## Regular expressions -- [x] Literal and `new RegExp(pattern, flags)` construction. +- [x] Literal and `RegExp(pattern, flags)` construction, with or without `new`. - [x] `test`, `exec`, and `toString`. - [x] Readable `source`, `flags`, `lastIndex`, `global`, `ignoreCase`, `multiline`, `sticky`, `unicode`, and `dotAll`. - [x] Captures, named groups, match indexes, and stateful global matching. @@ -295,8 +317,13 @@ These are actionable implementation items. Check them off only when behavior and `null` in render-only or OpenAPI tool calls. - [ ] Make regular-expression execution genuinely timeout-safe, or narrow the timeout guarantee explicitly. - [ ] Complete lexical declaration and destructuring semantics listed above. -- [ ] Make callback acceptance and async callback behavior consistent across built-ins. -- [ ] Reject every unsupported callback argument explicitly rather than silently ignoring it. +- [x] Make callback acceptance consistent across built-ins: collections, sort, string replacers, `Array.from` + mappers, and promise reactions share one acceptance rule. +- [x] Reject every unsupported callable callback argument explicitly rather than silently ignoring it + (`JSON.stringify` replacers and `JSON.parse` revivers fail loudly). The iteration-method `thisArg` is + accepted and ignored: CodeMode functions have no `this`, so ignoring it matches JS arrow semantics. +- [ ] Make async callback behavior consistent across built-ins; only string replacers settle async callback results + today. - [ ] Resolve the built-in correctness gaps listed in the Array, String, Number, Date, and RegExp sections. - [ ] Make tool search tokenization Unicode-aware. - [ ] Design explicit tagged representations and size limits before adding binary values or streams. diff --git a/packages/codemode/src/interpreter/methods.ts b/packages/codemode/src/interpreter/methods.ts index 4757dd55df..21d66ea3c5 100644 --- a/packages/codemode/src/interpreter/methods.ts +++ b/packages/codemode/src/interpreter/methods.ts @@ -3,14 +3,16 @@ import { type AstNode, CodeModeFunction, CoercionFunction, + ErrorConstructorReference, GlobalMethodReference, + GlobalNamespace, IntrinsicReference, InterpreterRuntimeError, PromiseCapabilityFunction, - supportedSyntaxMessage, + PromiseNamespace, UriFunction, } from "./model.js" -import { rejectCircularInsertion } from "./references.js" +import { rejectCircularInsertion, typeofValue } from "./references.js" import { isBlockedMember, type SafeObject } from "../tool-runtime.js" import { CodeModeDate, @@ -28,14 +30,47 @@ import { invokeNumberMethod, invokeNumberStatic } from "../stdlib/number.js" import { invokeObjectMethod } from "../stdlib/object.js" import { invokeRegExpMethod, matchToValue, toHostRegex } from "../stdlib/regexp.js" import { invokeStringStatic } from "../stdlib/string.js" -import { invokeUriFunction, invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js" -import { boundedData, coerceToNumber, coerceToString, invokeCoercion } from "../stdlib/value.js" +import { invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js" +import { boundedData, coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js" export type CallbackRunner = { readonly invokeFunction: (fn: CodeModeFunction, args: Array) => Effect.Effect + readonly invokeCallable: ( + callable: unknown, + args: Array, + node: AstNode, + ) => Effect.Effect readonly settlePromise: (promise: CodeModePromise) => Effect.Effect } +// The single acceptance list for callbacks: collections, sort, string replacers, +// Array.from mappers, and promise reactions all admit exactly these callables. +// Admission means dispatchable, not necessarily invocable: new-requiring +// constructors pass the gate and throw a TypeError on call, like JS. +export type SupportedCallback = + | CodeModeFunction + | CoercionFunction + | UriFunction + | PromiseCapabilityFunction + | GlobalMethodReference + | IntrinsicReference + | ErrorConstructorReference + | GlobalNamespace + | PromiseNamespace + +export const isSupportedCallback = (value: unknown): value is SupportedCallback => + value instanceof CodeModeFunction || + value instanceof CoercionFunction || + value instanceof UriFunction || + value instanceof PromiseCapabilityFunction || + value instanceof GlobalMethodReference || + value instanceof IntrinsicReference || + value instanceof ErrorConstructorReference || + // Callable namespaces dispatch like JS: Array/Object/Date/RegExp construct, + // new-requiring constructors throw a TypeError. Math/JSON/console stay non-callable. + (value instanceof GlobalNamespace && typeofValue(value) === "function") || + value instanceof PromiseNamespace + export const invokeIntrinsic = ( runner: CallbackRunner, ref: IntrinsicReference, @@ -43,11 +78,14 @@ export const invokeIntrinsic = ( node: AstNode, ): Effect.Effect => { if (typeof ref.receiver === "string") { - if ( - (ref.name === "replace" || ref.name === "replaceAll") && - (args[1] instanceof CodeModeFunction || args[1] instanceof CoercionFunction || args[1] instanceof UriFunction) - ) { - return invokeStringReplacer(runner, ref.receiver, ref.name, args, node) + if (ref.name === "replace" || ref.name === "replaceAll") { + if (isSupportedCallback(args[1])) return invokeStringReplacer(runner, ref.receiver, ref.name, args, node) + if (typeofValue(args[1]) === "function") { + throw new InterpreterRuntimeError( + `String.${ref.name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`, + node, + ) + } } return Effect.succeed(invokeStringMethod(ref.receiver, ref.name, args, node)) } @@ -269,49 +307,60 @@ const invokeArrayStatic = (name: string, args: Array, node: AstNode): u return Array.isArray(args[0]) case "of": return [...args] - case "from": { - if (args.length > 1) { - throw new InterpreterRuntimeError( - "Array.from(...) does not support a map function in CodeMode; call .map() on the result instead.", - node, - "UnsupportedSyntax", - [supportedSyntaxMessage], - ) - } - if (args[0] instanceof CodeModeMap) return Array.from(args[0].map.entries(), ([key, item]) => [key, item]) - if (args[0] instanceof CodeModeSet) return Array.from(args[0].set.values()) - if (args[0] instanceof CodeModeURLSearchParams) { - return Array.from(args[0].params.entries(), ([key, value]) => [key, value]) - } - const source = args[0] - if (source instanceof CodeModePromise) { - throw new InterpreterRuntimeError( - "Array.from received an un-awaited Promise; await it before creating the array.", - node, - "InvalidDataValue", - ) - } - if (typeof source === "string") return Array.from(source) - if (Array.isArray(source)) return [...source] - if ( - source !== null && - typeof source === "object" && - (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) && - typeof (source as { length?: unknown }).length === "number" - ) { - return Array.from(source as ArrayLike) - } - throw new InterpreterRuntimeError( - "Array.from expects an array, string, Map, Set, or array-like value.", - node, - "InvalidDataValue", - ) - } + case "from": + return arrayFromItems(args[0], node) default: throw new InterpreterRuntimeError(`Array.${name} is not available in CodeMode.`, node) } } +const arrayFromItems = (source: unknown, node: AstNode): Array => { + if (source instanceof CodeModeMap) return Array.from(source.map.entries(), ([key, item]) => [key, item]) + if (source instanceof CodeModeSet) return Array.from(source.set.values()) + if (source instanceof CodeModeURLSearchParams) { + return Array.from(source.params.entries(), ([key, value]) => [key, value]) + } + if (source instanceof CodeModePromise) { + throw new InterpreterRuntimeError( + "Array.from received an un-awaited Promise; await it before creating the array.", + node, + "InvalidDataValue", + ) + } + if (typeof source === "string") return Array.from(source) + if (Array.isArray(source)) return [...source] + if ( + source !== null && + typeof source === "object" && + (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) && + typeof (source as { length?: unknown }).length === "number" + ) { + return Array.from(source as ArrayLike) + } + throw new InterpreterRuntimeError( + "Array.from expects an array, string, Map, Set, or array-like value.", + node, + "InvalidDataValue", + ) +} + +export const invokeArrayFrom = ( + runner: CallbackRunner, + args: Array, + node: AstNode, +): Effect.Effect => { + const items = arrayFromItems(args[0], node) + if (args.length < 2 || args[1] === undefined) return Effect.succeed(items) + const apply = applyCollectionCallback(runner, args[1], "Array.from", node) + return Effect.gen(function* () { + const values: Array = [] + for (let index = 0; index < items.length; index += 1) { + values.push(yield* apply([items[index], index])) + } + return values + }) +} + const invokeStringReplacer = ( runner: CallbackRunner, value: string, @@ -367,9 +416,12 @@ const invokeStringReplacer = ( args[1] instanceof CodeModeFunction && args[1].async && replacement instanceof CodeModePromise ? yield* runner.settlePromise(replacement) : replacement + // Error values are branded plain objects; boundedData would strip the brand before coercion. output.push( value.slice(end, match.offset), - coerceToString(boundedData(resolved, `String.${name} replacer result`)), + errorBrandName(resolved) + ? coerceToString(resolved) + : coerceToString(boundedData(resolved, `String.${name} replacer result`)), ) end = match.offset + match.match.length } @@ -384,22 +436,16 @@ export const applyCollectionCallback = ( name: string, node: AstNode, ): ((args: Array) => Effect.Effect) => { - if ( - !(callback instanceof CodeModeFunction) && - !(callback instanceof CoercionFunction) && - !(callback instanceof UriFunction) && - !(callback instanceof PromiseCapabilityFunction) - ) { + 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) => - callback instanceof CoercionFunction - ? Effect.succeed(invokeCoercion(callback, callbackArgs, node)) - : callback instanceof UriFunction - ? Effect.succeed(invokeUriFunction(callback, callbackArgs, node)) - : callback instanceof PromiseCapabilityFunction - ? Effect.sync(() => callback.settle(callbackArgs[0])) - : runner.invokeFunction(callback, callbackArgs) + return (callbackArgs) => runner.invokeCallable(callback, callbackArgs, node) } const invokeMapMethod = ( @@ -603,12 +649,12 @@ const invokeArrayMethod = ( case "reverse": return Effect.succeed(target.reverse()) case "sort": - return Effect.map(sortArray(runner, target, args[0], node), (sorted) => { + return Effect.map(sortArray(runner, target, args[0], "Array.sort", node), (sorted) => { target.splice(0, target.length, ...sorted) return target }) case "toSorted": - return sortArray(runner, target, args[0], node) + return sortArray(runner, target, args[0], "Array.toSorted", node) case "toReversed": return Effect.succeed([...target].reverse()) case "with": { @@ -782,12 +828,10 @@ const sortArray = ( runner: CallbackRunner, target: Array, comparator: unknown, + name: string, node: AstNode, ): Effect.Effect, unknown, R> => { - if (comparator !== undefined && !(comparator instanceof CodeModeFunction)) { - throw new InterpreterRuntimeError("Array.sort expects an arrow function comparator.", node) - } - if (!(comparator instanceof CodeModeFunction)) { + if (comparator === undefined) { return Effect.sync(() => [...target].sort((a, b) => { const left = coerceToString(a) @@ -796,6 +840,7 @@ const sortArray = ( }), ) } + const apply = applyCollectionCallback(runner, comparator, name, node) const mergeSort = (items: Array): Effect.Effect, unknown, R> => { if (items.length <= 1) return Effect.succeed(items) const midpoint = Math.floor(items.length / 2) @@ -807,7 +852,7 @@ const sortArray = ( let rightIndex = 0 while (leftIndex < left.length && rightIndex < right.length) { // Treat a NaN comparator result as equal to preserve stable ordering. - const order = coerceToNumber(yield* runner.invokeFunction(comparator, [left[leftIndex], right[rightIndex]])) + const order = coerceToNumber(yield* apply([left[leftIndex], right[rightIndex]])) if (Number.isNaN(order) || order <= 0) merged.push(left[leftIndex++]) else merged.push(right[rightIndex++]) } diff --git a/packages/codemode/src/interpreter/promises.ts b/packages/codemode/src/interpreter/promises.ts index 2bf1b1ea30..6f7c07c5b8 100644 --- a/packages/codemode/src/interpreter/promises.ts +++ b/packages/codemode/src/interpreter/promises.ts @@ -4,16 +4,14 @@ import type { SafeObject } from "../tool-runtime.js" import { type AstNode, CodeModeFunction, - CoercionFunction, InterpreterRuntimeError, ProgramThrow, PromiseCapabilityFunction, PromiseInstanceMethodReference, PromiseMethodReference, - UriFunction, } from "./model.js" import { caughtErrorValue, normalizeError } from "./errors.js" -import { applyCollectionCallback, type CallbackRunner } from "./methods.js" +import { applyCollectionCallback, isSupportedCallback, type CallbackRunner, type SupportedCallback } from "./methods.js" import { typeofValue } from "./references.js" import { spreadItems } from "../stdlib/collections.js" import { createAggregateErrorValue } from "../stdlib/value.js" @@ -258,20 +256,11 @@ class PromiseAnyFulfilled { constructor(readonly value: unknown) {} } -type ReactionHandler = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction - -const reactionHandler = (value: unknown, method: string, node: AstNode): ReactionHandler | undefined => { - if ( - value instanceof CodeModeFunction || - value instanceof CoercionFunction || - value instanceof UriFunction || - value instanceof PromiseCapabilityFunction - ) { - return value - } +const reactionHandler = (value: unknown, method: string, node: AstNode): SupportedCallback | undefined => { + if (isSupportedCallback(value)) return value if (typeofValue(value) === "function") { throw new InterpreterRuntimeError( - `${method} handlers must be plain functions; wrap other callables in an arrow function, e.g. (value) => tools.ns.tool(value).`, + `${method} cannot use this callable as a handler; wrap it in an arrow function, e.g. (value) => tools.ns.tool(value).`, node, ) } @@ -294,8 +283,8 @@ const chainReaction = ( runner: CallbackRunner, promises: PromiseRuntime, source: CodeModePromise, - onFulfilled: ReactionHandler | undefined, - onRejected: ReactionHandler | undefined, + onFulfilled: SupportedCallback | undefined, + onRejected: SupportedCallback | undefined, method: string, node: AstNode, ): Effect.Effect => { @@ -320,7 +309,7 @@ const chainFinally = ( runner: CallbackRunner, promises: PromiseRuntime, source: CodeModePromise, - cleanup: ReactionHandler | undefined, + cleanup: SupportedCallback | undefined, method: string, node: AstNode, ): Effect.Effect => diff --git a/packages/codemode/src/interpreter/runtime.ts b/packages/codemode/src/interpreter/runtime.ts index 3dfc9c5cb9..68fa83aa1b 100644 --- a/packages/codemode/src/interpreter/runtime.ts +++ b/packages/codemode/src/interpreter/runtime.ts @@ -34,7 +34,7 @@ import { UriFunction, } from "./model.js" import { caughtErrorValue, constructErrorValue } from "./errors.js" -import { type CallbackRunner, invokeGlobalMethod, invokeIntrinsic } from "./methods.js" +import { type CallbackRunner, invokeArrayFrom, invokeGlobalMethod, invokeIntrinsic } from "./methods.js" import { constructPromise, invokePromiseInstanceMethod, @@ -153,6 +153,7 @@ export class Interpreter { private readonly promises: PromiseRuntime private readonly runner: CallbackRunner = { invokeFunction: (fn, args) => this.invokeFunction(fn, args), + invokeCallable: (callable, args, node) => this.invokeCallable(callable, args, node), settlePromise: (promise) => this.settlePromise(promise), } @@ -997,6 +998,13 @@ export class Interpreter { if (errorConstructors.has(name)) { return Effect.map(this.evaluateCallArguments(argNodes), (args) => constructErrorValue(name, args, node)) } + // Array and Object construct identically with or without new, like JS. + if (name === "Array") { + return Effect.map(this.evaluateCallArguments(argNodes), (args) => self.constructArray(args, node)) + } + if (name === "Object") { + return Effect.map(this.evaluateCallArguments(argNodes), (args) => self.constructObject(args, node)) + } if (valueConstructors.has(name)) { return Effect.gen(function* () { const args = yield* self.evaluateCallArguments(argNodes) @@ -1019,6 +1027,27 @@ export class Interpreter { throw unsupportedSyntax("NewExpression", node) } + private constructArray(args: Array, node: AstNode): Array { + if (args.length !== 1) return [...args] + const first = args[0] + if (typeof first !== "number") return [first] + if (!Number.isInteger(first) || first < 0 || first > 4294967295) { + throw new InterpreterRuntimeError("Invalid array length.", node).as("RangeError") + } + // Sparse like JS: Array(3) has holes, and combinator loops already skip them. + return new Array(first) + } + + private constructObject(args: Array, node: AstNode): unknown { + const first = args[0] + if (first === null || first === undefined) return {} + if (typeof first === "object") return first + throw new InterpreterRuntimeError( + `Object(${typeof first}) wrapper objects are not supported in CodeMode; use the primitive value directly.`, + node, + ) + } + private constructDate(args: Array): CodeModeDate { if (args.length === 0) return new CodeModeDate(Date.now()) if (args.length === 1) { @@ -1041,7 +1070,7 @@ export class Interpreter { throw new InterpreterRuntimeError( `RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node, - ) + ).as("SyntaxError") } const flags = flagsArg ?? (first instanceof CodeModeRegExp ? first.regex.flags : "") try { @@ -1401,7 +1430,19 @@ export class Interpreter { if ((callable === null || callable === undefined) && node.optional === true) return OptionalShortCircuit const args = yield* self.evaluateCallArguments(argNodes) + return yield* self.invokeCallable(callable, args, node, callee) + }) + } + // The single dispatch for every invocation: call expressions and callbacks share it. + private invokeCallable( + callable: unknown, + args: Array, + node: AstNode, + callee: AstNode = node, + ): Effect.Effect { + const self = this + return Effect.gen(function* () { if (callable instanceof ToolReference) { if (callable.path.length === 0) throw new InterpreterRuntimeError("The tools root is not callable.", callee) return yield* self.createToolCallPromise(callable.path, args) @@ -1426,7 +1467,10 @@ export class Interpreter { if (callable.namespace === "Object" && objectMethodsPreservingIdentity.has(callable.name)) { return invokeGlobalMethod(callable, args, node) } - if (callable.namespace === "Array" && (callable.name === "from" || callable.name === "of")) { + if (callable.namespace === "Array" && callable.name === "from") { + return yield* invokeArrayFrom(self.runner, args, node) + } + if (callable.namespace === "Array" && callable.name === "of") { return invokeGlobalMethod(callable, args, node) } return boundedData(invokeGlobalMethod(callable, args, node), `${callable.namespace}.${callable.name} result`) @@ -1443,6 +1487,22 @@ export class Interpreter { if (callable instanceof ErrorConstructorReference) { return constructErrorValue(callable.name, args, node) } + if (callable instanceof GlobalNamespace) { + // Real JS permits calling Array, Object, Date, and RegExp without new. + if (callable.name === "Array") return self.constructArray(args, node) + if (callable.name === "Object") return self.constructObject(args, node) + // ISO instead of the host's locale string: CodeMode date strings are + // deterministic and must not leak the host timezone. + if (callable.name === "Date") return new Date().toISOString() + if (callable.name === "RegExp") return self.constructRegExp(args, node) + if (typeofValue(callable) === "function") { + throw new InterpreterRuntimeError(`Constructor ${callable.name} requires 'new'.`, node).as("TypeError") + } + throw new InterpreterRuntimeError(`${callable.name} is not a function.`, node).as("TypeError") + } + if (callable instanceof PromiseNamespace) { + throw new InterpreterRuntimeError("Constructor Promise requires 'new'.", node).as("TypeError") + } if (callable instanceof PromiseCapabilityFunction) { callable.settle(args[0]) return undefined @@ -1604,7 +1664,8 @@ export class Interpreter { return Effect.gen(function* () { for (const elementValue of elements) { if (elementValue === null) { - values.push(undefined) + // A literal elision is a real hole, like JS: extend length without an own index. + values.length += 1 continue } const element = asNode(elementValue, "elements") diff --git a/packages/codemode/src/stdlib/json.ts b/packages/codemode/src/stdlib/json.ts index a7cc13629e..d65da7fe20 100644 --- a/packages/codemode/src/stdlib/json.ts +++ b/packages/codemode/src/stdlib/json.ts @@ -1,16 +1,12 @@ -import { - type AstNode, - CodeModeFunction, - InterpreterRuntimeError, - supportedSyntaxMessage, -} from "../interpreter/model.js" +import { type AstNode, InterpreterRuntimeError, supportedSyntaxMessage } from "../interpreter/model.js" +import { typeofValue } from "../interpreter/references.js" import { copyIn, copyOut } from "../tool-runtime.js" export const invokeJsonMethod = (name: string, args: Array, node: AstNode): unknown => { switch (name) { case "stringify": { const replacer = args[1] - if (Array.isArray(replacer) || replacer instanceof CodeModeFunction) { + if (Array.isArray(replacer) || typeofValue(replacer) === "function") { throw new InterpreterRuntimeError( "JSON.stringify replacers are not supported in CodeMode.", node, @@ -25,6 +21,14 @@ export const invokeJsonMethod = (name: string, args: Array, node: AstNo case "parse": { const text = args[0] if (typeof text !== "string") throw new InterpreterRuntimeError("JSON.parse expects a string.", node) + if (typeofValue(args[1]) === "function") { + throw new InterpreterRuntimeError( + "JSON.parse revivers are not supported in CodeMode.", + node, + "UnsupportedSyntax", + [supportedSyntaxMessage], + ) + } try { return copyIn(JSON.parse(text), "JSON.parse result") } catch (error) { diff --git a/packages/codemode/src/stdlib/math.ts b/packages/codemode/src/stdlib/math.ts index 7720f69775..54fa3be91b 100644 --- a/packages/codemode/src/stdlib/math.ts +++ b/packages/codemode/src/stdlib/math.ts @@ -42,16 +42,26 @@ export const mathMethods = new Set([ export const invokeMathMethod = (name: string, args: Array, node: AstNode): number => { if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node) if (name === "random") return Math.random() - const nums = args.map((arg) => { + // 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: number): number => { + 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 [a = Number.NaN, b = Number.NaN] = nums + } + 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) + return Math.max(...nums()) case "min": - return Math.min(...nums) + return Math.min(...nums()) case "abs": return Math.abs(a) case "acos": @@ -65,7 +75,7 @@ export const invokeMathMethod = (name: string, args: Array, node: AstNo case "atan": return Math.atan(a) case "atan2": - return Math.atan2(a, b) + return Math.atan2(a, b()) case "atanh": return Math.atanh(a) case "floor": @@ -83,9 +93,9 @@ export const invokeMathMethod = (name: string, args: Array, node: AstNo case "cbrt": return Math.cbrt(a) case "pow": - return Math.pow(a, b) + return Math.pow(a, b()) case "hypot": - return Math.hypot(...nums) + return Math.hypot(...nums()) case "cos": return Math.cos(a) case "cosh": @@ -117,7 +127,7 @@ export const invokeMathMethod = (name: string, args: Array, node: AstNo case "clz32": return Math.clz32(a) case "imul": - return Math.imul(a, b) + return Math.imul(a, b()) } throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node) } diff --git a/packages/codemode/src/stdlib/value.ts b/packages/codemode/src/stdlib/value.ts index 9a47285da5..2b5ff00f48 100644 --- a/packages/codemode/src/stdlib/value.ts +++ b/packages/codemode/src/stdlib/value.ts @@ -41,6 +41,15 @@ export const coerceToString = (value: unknown): string => { if (value instanceof CodeModeSet) return "[object Set]" if (value instanceof CodeModeURL) return value.url.href if (value instanceof CodeModeURLSearchParams) return value.params.toString() + if (errorBrandName(value) !== undefined) { + // Match Error.prototype.toString: "name: message", or just one when the other is empty. + const error = value as { name?: unknown; message?: unknown } + const name = typeof error.name === "string" ? error.name : "Error" + const message = typeof error.message === "string" ? error.message : "" + if (message === "") return name + if (name === "") return message + return `${name}: ${message}` + } if (typeof value === "object") { return Array.isArray(value) ? value.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",") @@ -57,6 +66,8 @@ export const coerceToNumber = (value: unknown): number => { export const invokeCoercion = (ref: CoercionFunction, args: Array, node: AstNode): unknown => { const raw = args[0] + // Error values are plain SafeObjects; the boundedData path below would strip their brand. + if (ref.name === "String" && errorBrandName(raw) !== undefined) return coerceToString(raw) if (isCodeModeValue(raw)) { if (ref.name === "Boolean") return true if (ref.name === "Number") return coerceToNumber(raw) diff --git a/packages/codemode/src/tool-runtime.ts b/packages/codemode/src/tool-runtime.ts index 90c3b2de60..09cea8b53d 100644 --- a/packages/codemode/src/tool-runtime.ts +++ b/packages/codemode/src/tool-runtime.ts @@ -270,7 +270,8 @@ export const copyOut = (value: unknown, undefinedAsNull = false): unknown => { return null } if (Array.isArray(value)) { - return value.map((item) => copyOut(item, undefinedAsNull)) + // Array.from densifies holes so sparse arrays normalize at the boundary like JSON does. + return Array.from(value, (item) => copyOut(item, undefinedAsNull)) } if (value !== null && typeof value === "object" && !(value instanceof ToolReference)) { diff --git a/packages/codemode/test/callbacks.test.ts b/packages/codemode/test/callbacks.test.ts new file mode 100644 index 0000000000..6391448a70 --- /dev/null +++ b/packages/codemode/test/callbacks.test.ts @@ -0,0 +1,258 @@ +import { describe, expect, test } from "bun:test" +import { Effect, Schema } from "effect" +import { CodeMode, Tool } from "../src/index.js" + +// Callback acceptance is one gate shared by array methods, sort, string replacers, +// Array.from mappers, Map/Set/URLSearchParams forEach, and promise reactions: +// interpreter functions, coercion/URI builtins, resolver capabilities, and built-in +// method references are callable; tools and other opaque callables get a wrap hint. +const run = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} })) +const value = async (code: string) => { + const result = await run(code) + if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`) + return result.value +} +const error = async (code: string) => { + const result = await run(code) + if (result.ok) throw new Error(`expected failure, got value ${JSON.stringify(result.value)}`) + return result.error +} +const logsOf = async (code: string) => { + const result = await run(code) + if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`) + return result.logs ?? [] +} + +const echo = Tool.make({ + description: "Echo the input", + input: Schema.Struct({ id: Schema.Number }), + output: Schema.Number, + run: (input: { id: number }) => Effect.succeed(input.id), +}) +const withTool = (code: string) => Effect.runPromise(CodeMode.make({ tools: { host: { echo } } }).execute(code)) +const toolError = async (code: string) => { + const result = await withTool(code) + if (result.ok) throw new Error(`expected failure, got value ${JSON.stringify(result.value)}`) + return result.error +} + +describe("built-in method references as callbacks", () => { + test("map accepts Math methods", async () => { + expect(await value(`return [-1, 2, -3].map(Math.abs)`)).toEqual([1, 2, 3]) + expect(await value(`return [1.5, 2.7].map(Math.floor)`)).toEqual([1, 2]) + }) + + test("map(JSON.stringify) matches JS: the index replacer and array space are ignored", async () => { + expect(await value(`return [{ a: 1 }, [2]].map(JSON.stringify)`)).toEqual(['{"a":1}', "[2]"]) + }) + + test("map(Number.parseInt) reproduces the JS radix footgun", async () => { + // parseInt("2", 1) is NaN in real JS; NaN serializes to null at the result boundary. + expect(await value(`return ["1", "2"].map(Number.parseInt)`)).toEqual([1, null]) + }) + + test("filter and find accept built-in predicates", async () => { + expect(await value(`return [0, 1, NaN, 2].filter(Number.isInteger)`)).toEqual([0, 1, 2]) + expect(await value(`return [1.5, 3, 2.5].find(Number.isInteger)`)).toBe(3) + }) + + test("forEach(console.log) captures one log line per element", async () => { + const logs = await logsOf(`["a", "b"].forEach(console.log); return null`) + expect(logs).toHaveLength(2) + expect(logs[0]).toContain("a") + expect(logs[1]).toContain("b") + }) + + test("intrinsic method references keep their receiver, unlike detached JS methods", async () => { + expect(await value(`return ["a", "z"].filter("abc".includes)`)).toEqual(["a"]) + }) + + test("promise reactions accept built-in references", async () => { + expect(await value(`return await Promise.resolve(-5).then(Math.abs)`)).toBe(5) + const logs = await logsOf(`await Promise.resolve("done").then(console.log); return null`) + expect(logs).toHaveLength(1) + expect(logs[0]).toContain("done") + }) +}) + +describe("constructors callable without new, like JS", () => { + test("Error constructors work as callbacks and direct calls", async () => { + expect(await value(`return ["boom"].map(Error)[0].message`)).toBe("boom") + expect(await value(`return TypeError("bad").name`)).toBe("TypeError") + }) + + test("error values stringify like JS Error.prototype.toString", async () => { + expect(await value(`return String(TypeError("bad"))`)).toBe("TypeError: bad") + expect(await value(`return String(Error(""))`)).toBe("Error") + expect(await value(`return "x" + RangeError("oops")`)).toBe("xRangeError: oops") + expect(await value(`return "a1b2".replace(/\\d/, Error)`)).toBe("aError: 1b2") + }) + + test("literal elisions are real holes, like JS", async () => { + expect(await value(`return (0 in [, 1])`)).toBe(false) + expect(await value(`return Object.keys([, 1, ,])`)).toEqual(["1"]) + expect(await value(`return [, 1, ,].filter(() => true).length`)).toBe(1) + expect(await value(`return [, ,].every((x) => false)`)).toBe(true) + }) + + test("Array constructs from arguments or a length", async () => { + expect(await value(`return Array(1, 2, 3)`)).toEqual([1, 2, 3]) + expect(await value(`return Array("3")`)).toEqual(["3"]) + expect(await value(`return Array(3).length`)).toBe(3) + expect(await value(`return new Array(2).length`)).toBe(2) + // Holes stay holes, like JS: map skips them (length preserved, normalized to + // null at the host boundary), spread materializes undefined. + expect(await value(`return Array(3).map((x) => 1)`)).toEqual([null, null, null]) + expect(await value(`return Array(3).map((x) => 1).length`)).toBe(3) + expect(await value(`return [...Array(3)].map((_, i) => i)`)).toEqual([0, 1, 2]) + expect((await error(`return Array(-1)`)).message).toContain("Invalid array length") + expect((await error(`return Array(1.5)`)).message).toContain("Invalid array length") + }) + + test("Object returns objects unchanged and rejects primitive wrappers", async () => { + expect(await value(`return Object()`)).toEqual({}) + expect(await value(`const o = { a: 1 }; return Object(o) === o`)).toBe(true) + expect((await error(`return Object(1)`)).message).toContain("wrapper objects are not supported") + }) + + test("Date() without new returns a deterministic ISO string and ignores arguments", async () => { + expect(await value(`return /^\\d{4}-\\d{2}-\\d{2}T.*Z$/.test(Date(1000))`)).toBe(true) + expect(await value(`return "abc".replace(RegExp("b"), "x")`)).toBe("axc") + }) + + test("map(Array) matches the JS 3-argument call", async () => { + expect(await value(`return [7].map(Array)`)).toEqual([[7, 0, [7]]]) + }) + + test("array length boundaries match JS", async () => { + expect(await value(`return Array(4294967295).length`)).toBe(4294967295) + const diagnostic = await error(`return Array(4294967296)`) + expect(diagnostic.message).toContain("Invalid array length") + expect((await error(`try { Array(-1) } catch (e) { throw Error(e.name) }`)).message).toContain("RangeError") + }) + + test("sort densifies trailing holes into undefined (documented divergence)", async () => { + expect(await value(`return Array(2).sort().map(() => 1)`)).toEqual([1, 1]) + }) + + test("returned sparse arrays normalize holes to null at the host boundary", async () => { + expect(await value(`return Array(3)`)).toEqual([null, null, null]) + }) + + test("RegExp with non-string flags throws a SyntaxError, like JS", async () => { + expect((await error(`try { RegExp("a", 0) } catch (e) { throw Error(e.name) }`)).message).toContain("SyntaxError") + }) + + test("new-requiring constructors throw a TypeError when called", async () => { + expect((await error(`return Map()`)).message).toContain("Constructor Map requires 'new'") + expect((await error(`return [1].map(Set)`)).message).toContain("Constructor Set requires 'new'") + expect((await error(`return Promise(() => 1)`)).message).toContain("Constructor Promise requires 'new'") + // As a reaction handler the TypeError rejects the derived promise catchably, like JS. + expect(await value(`return await Promise.resolve(1).then(Map).catch((e) => e.name)`)).toBe("TypeError") + }) +}) + +describe("sort accepts the unified callback set", () => { + test("sort and toSorted take built-in comparators", async () => { + expect(await value(`return [0, 1, 0].sort(Boolean)`)).toEqual([0, 0, 1]) + expect(await value(`return [0, 1, 0].toSorted(Boolean)`)).toEqual([0, 0, 1]) + }) + + test("a non-callable comparator is rejected", async () => { + expect((await error(`return [2, 1].sort(42)`)).message).toContain("Array.sort expects a function callback") + expect((await error(`return [2, 1].toSorted(42)`)).message).toContain("Array.toSorted expects a function callback") + }) +}) + +describe("Array.from mapper", () => { + test("maps with (value, index) over arrays, strings, and Sets", async () => { + expect(await value(`return Array.from([1, 2, 3], (x) => x * 2)`)).toEqual([2, 4, 6]) + expect(await value(`return Array.from("ab", (c, i) => c + i)`)).toEqual(["a0", "b1"]) + expect(await value(`return Array.from(new Set([1, 2]), (x) => x * 10)`)).toEqual([10, 20]) + }) + + test("accepts coercion builtins and an explicit undefined mapper", async () => { + expect(await value(`return Array.from(["5", "7"], Number)`)).toEqual([5, 7]) + expect(await value(`return Array.from([1, 2], undefined)`)).toEqual([1, 2]) + }) + + test("rejects a non-callable mapper", async () => { + expect((await error(`return Array.from([1], 42)`)).message).toContain("Array.from expects a function callback") + }) +}) + +describe("thisArg is accepted and ignored, like JS arrows", () => { + // CodeMode functions have no `this`, so a thisArg can never change behavior — + // exactly like passing one alongside an arrow function in real JS. + test("iteration methods and Array.from ignore a thisArg", async () => { + expect(await value(`return [1, 2].map((x) => x * 2, {})`)).toEqual([2, 4]) + expect(await value(`return [1, 2].map((x) => x, undefined)`)).toEqual([1, 2]) + expect(await value(`return Array.from([1], (x) => x + 1, {})`)).toEqual([2]) + }) + + test("Map, Set, and URLSearchParams forEach ignore a thisArg", async () => { + expect(await value(`const o = []; new Map([["a", 1]]).forEach((v, k) => o.push(k), {}); return o`)).toEqual(["a"]) + expect(await value(`const o = []; new Set([1]).forEach((v) => o.push(v), "self"); return o`)).toEqual([1]) + expect(await value(`const o = []; new URLSearchParams("a=1").forEach((v) => o.push(v), 0); return o`)).toEqual([ + "1", + ]) + }) +}) + +describe("still-rejected callables get the wrap hint", () => { + test("tool references as callbacks suggest an arrow wrapper", async () => { + const diagnostic = await toolError(`return [1, 2].map(tools.host.echo)`) + expect(diagnostic.message).toContain("wrap it in an arrow function") + expect(await withTool(`return await Promise.all([1, 2].map((id) => tools.host.echo({ id })))`)).toMatchObject({ + ok: true, + value: [1, 2], + }) + }) + + test("detached Promise statics as callbacks suggest an arrow wrapper", async () => { + expect((await error(`return [1].map(Promise.resolve)`)).message).toContain("wrap it in an arrow function") + }) + + test("string replacers reject opaque callables with the wrap hint, not a type error", async () => { + const diagnostic = await toolError(`return "abc".replace(/b/, tools.host.echo)`) + expect(diagnostic.message).toContain("wrap it in an arrow function") + expect(diagnostic.message).not.toContain("argument 2") + }) + + test("built-in references work as replacers", async () => { + // Like real JS: JSON.stringify(match, offset, string) quotes the match. + expect(await value(`return "abc".replace(/b/, JSON.stringify)`)).toBe('a"b"c') + // Math methods stay strict about consumed arguments: a match string is not coerced. + expect((await error(`return "3.7".replace(/\\d\\.\\d/, Math.floor)`)).message).toContain( + "Math.floor expects number arguments", + ) + }) + + test("non-callables still get the plain callback error", async () => { + expect((await error(`return [1].map(42)`)).message).toContain("Array.map expects a function callback") + }) + + test("promise handlers reject opaque callables with the wrap hint", async () => { + const diagnostic = await toolError(`return await Promise.resolve(1).then(tools.host.echo)`) + expect(diagnostic.message).toContain("Promise.prototype.then cannot use this callable as a handler") + expect(diagnostic.message).toContain("wrap it in an arrow function") + }) + + test("callable JSON.stringify replacers are rejected, never silently ignored", async () => { + expect((await error(`return JSON.stringify({ a: 1 }, Math.abs)`)).message).toContain( + "JSON.stringify replacers are not supported", + ) + expect((await toolError(`return JSON.stringify({ a: 1 }, tools.host.echo)`)).message).toContain( + "JSON.stringify replacers are not supported", + ) + }) + + test("callable JSON.parse revivers are rejected, never silently ignored", async () => { + expect((await error(`return JSON.parse('{"a":1}', (key, v) => 99)`)).message).toContain( + "JSON.parse revivers are not supported", + ) + expect(await value(`return JSON.parse('{"a":1}', undefined)`)).toEqual({ a: 1 }) + // A non-callable reviver is silently ignored, matching JS's IsCallable check. + expect(await value(`return JSON.parse('{"a":1}', 42)`)).toEqual({ a: 1 }) + }) +}) diff --git a/packages/codemode/test/promise-test262.test.ts b/packages/codemode/test/promise-test262.test.ts index 2ba3a3aa14..0dc57e7b75 100644 --- a/packages/codemode/test/promise-test262.test.ts +++ b/packages/codemode/test/promise-test262.test.ts @@ -1406,9 +1406,8 @@ describe("Test262 Promise constructor", () => { ).toEqual(["before", "executor", "after"]) }) - test.failing("calling Promise without new throws TypeError", async () => { + test("calling Promise without new throws TypeError", async () => { // Source: test/built-ins/Promise/undefined-newtarget.js - // CodeMode currently reports a generic Error ("Only tools are callable in CodeMode."). expect( await value(` try { diff --git a/packages/codemode/test/promise.test.ts b/packages/codemode/test/promise.test.ts index e7141a61fc..f5b52eeefd 100644 --- a/packages/codemode/test/promise.test.ts +++ b/packages/codemode/test/promise.test.ts @@ -1083,9 +1083,10 @@ describe("promise chaining", () => { expect(result.warnings).toBeUndefined() }) - test("non-plain-function handlers fail loudly instead of being ignored", async () => { + test("unsupported callable handlers fail loudly with a wrap hint", async () => { const diagnostic = await error(`return await tools.host.echo({ id: 1 }).then(tools.host.completed)`) - expect(diagnostic.message).toContain("Promise.prototype.then handlers must be plain functions") + expect(diagnostic.message).toContain("Promise.prototype.then cannot use this callable as a handler") + expect(diagnostic.message).toContain("wrap it in an arrow function") }) test("chaining methods are opaque references until called", async () => {