@opencode/codemode 2.0.12 → 2.0.14

package/dist/interpreter/interpreter.js

@@ -6,14 +6,14 @@ import { checkStringLength } from "./limits.js";
 import { locate, materialize } from "./errors.js";
 import { primitivePrototype } from "./intrinsics.js";
 import { globals } from "./globals.js";
-import { assign, Callable, define, get, has, hasPrototype, keys, Native, parseArrayIndex, Arr, Bytes, DateObj, Fn, GeneratorObj, IteratorObj, MapObj, Obj, PromiseObj, SetObj, URLSearchParamsObj, HeadersObj, record, remove, set, } from "./objects.js";
+import { assign, Callable, define, get, hostCursor, IteratorObj, has, hidden, hasPrototype, keys, Native, parseArrayIndex, Arr, Fn, GeneratorObj, Obj, PromiseObj, record, remove, set, coerceToNumber, coerceToString, } from "./objects.js";
 import { preserveConsumerError } from "./callback.js";
 import { Pending, resolvePromise, resolvePromiseValue } from "./promises.js";
 import { containsOpaqueReference, describeValue, rejectCircularInsertion, typeofValue } from "./references.js";
 import { ScopeStack } from "./scope.js";
 import { constructRegExp } from "../stdlib/regexp.js";
 import { enumerableSource } from "../stdlib/object.js";
-import { coerceToNumber, coerceToString, compoundOperators } from "../stdlib/value.js";
+import { compoundOperators } from "../stdlib/value.js";
 // What a loop does with its body's result: exit with a StatementResult, or undefined to keep iterating.
 // Unlabelled break ends this loop; a label the loop does not carry propagates outward.
 const loopExit = (result, labels) => {
@@ -51,6 +51,14 @@ const calleeDescription = (node) => {
     return object === undefined ? undefined : `${object}.${key}`;
 };
 // OrdinaryHasInstance: walk the left operand's chain looking for the constructor's `prototype`.
+// acorn types every literal as possibly a BigInt or RegExp; regex literals become RegExp objects before this is asked.
+const literal = (node) => {
+    if (typeof node.value === "bigint")
+        throw typeError("BigInt literals are not supported.", node);
+    if (node.value instanceof RegExp)
+        throw unsupportedSyntax("RegExpLiteral", node);
+    return node.value;
+};
 const instanceofValue = (lhs, rhs, node) => {
     if (!(rhs instanceof Callable)) {
         throw typeError("The right-hand side of 'instanceof' is not callable.", node);
@@ -180,6 +188,9 @@ export class Interpreter {
     iterate(value) {
         return this.root.iterate(value);
     }
+    iterateDirect(value) {
+        return this.root.iterateDirect(value);
+    }
     /** Runs one host tool: arguments cross as JSON and the result comes back as program values. */
     tool(run, args) {
         const ctx = this;
@@ -307,7 +318,16 @@ class Frame {
         }).pipe(Effect.ensuring(Effect.sync(() => self.scopes.pop())));
     }
     createFunction(node, name = node.type === "ArrowFunctionExpression" ? "" : (node.id?.name ?? "")) {
-        return new Fn(this.ctx.builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        const builtins = this.ctx.builtins;
+        const fn = new Fn(builtins.Function, name, node.params, node.body, this.scopes.capture(), node.async, node.generator);
+        // Each generator function gets its own prototype, so `g() instanceof g` holds as in JS.
+        if (node.generator)
+            define(fn, "prototype", new Obj(node.async ? builtins.AsyncGenerator : builtins.Generator), hidden);
+        // The body of a named function expression sees its own name, read-only.
+        if (node.type === "FunctionExpression" && node.id) {
+            fn.capturedScopes.push(new Map([[node.id.name, { mutable: false, value: fn, initialized: true }]]));
+        }
+        return fn;
     }
     // NamedEvaluation: an anonymous function definition takes the name of what it is assigned to.
     evaluateNamed(node, name) {
@@ -316,11 +336,12 @@ class Frame {
         }
         return this.evaluateExpression(node);
     }
+    // Repeated `function` declarations and `var` clashes are legal: the last declaration wins.
     hoistFunctions(statements) {
         for (const node of statements) {
             if (node.type !== "FunctionDeclaration")
                 continue;
-            this.scopes.declare(node.id.name, this.createFunction(node), true, node);
+            this.scopes.current().set(node.id.name, { mutable: true, value: this.createFunction(node), initialized: true });
         }
     }
     // Hoisted `var` bindings start undefined, or copy a same-named parameter. Function bodies hoist
@@ -484,10 +505,10 @@ class Frame {
             if (declared?.lexical)
                 self.predeclarePattern(declared.pattern, declared.mutable, left);
             const right = yield* self.evaluateExpression(node.right);
-            const cursor = self.hostCursor(right);
+            const cursor = self.builtinCursor(right);
             const iterator = cursor === undefined ? yield* self.customIterator(right, node, awaiting) : undefined;
             if (iterator === undefined && cursor === undefined) {
-                throw invalidData(`${awaiting ? "for await...of" : "for...of"} requires an array, string, Map, Set, URLSearchParams, or Headers, or custom iterator value.`, node);
+                throw invalidData(`${awaiting ? "for await...of" : "for...of"} requires an iterable value, received ${describeValue(right)}.`, node);
             }
             const close = () => iterator
                 ? self.closeIterator(iterator, node, awaiting)
@@ -525,10 +546,9 @@ class Frame {
                 const bodyExit = yield* Effect.exit(evaluateBody(step.value));
                 if (!Exit.isSuccess(bodyExit)) {
                     // Process interruption must remain prompt; user cleanup cannot extend a timeout.
-                    if (!Cause.hasInterruptsOnly(bodyExit.cause)) {
-                        yield* Effect.exit(close());
-                    }
-                    return yield* Effect.failCause(bodyExit.cause);
+                    if (Cause.hasInterruptsOnly(bodyExit.cause))
+                        return yield* Effect.failCause(bodyExit.cause);
+                    return yield* preserveConsumerError(close(), Effect.failCause(bodyExit.cause));
                 }
                 const exit = loopExit(bodyExit.value, labels);
                 if (exit !== undefined) {
@@ -557,49 +577,41 @@ class Frame {
         });
     }
     iterate(value, node) {
-        const cursor = this.hostCursor(value);
+        const cursor = this.builtinCursor(value);
         if (cursor !== undefined)
             return Effect.succeed(cursor);
-        const self = this;
-        return Effect.map(this.customIterator(value, node, false), (iterator) => iterator === undefined
-            ? undefined
-            : {
-                next: self.nextIteratorResult(iterator, node, false),
-                close: Effect.suspend(() => self.closeIterator(iterator, node, false)),
-            });
+        return Effect.map(this.customIterator(value, node, false), (iterator) => iterator === undefined ? undefined : this.customCursor(iterator, node));
+    }
+    /** GetIteratorDirect: drive an iterator by its own `next`, without asking for `[Symbol.iterator]`. */
+    iterateDirect(value, node) {
+        if (value instanceof IteratorObj)
+            return value.cursor;
+        if (!(value instanceof Obj)) {
+            throw typeError(`An iterator must be an object, received ${describeValue(value)}.`, node);
+        }
+        return this.customCursor({
+            iterator: value,
+            next: this.requireIteratorMethod(get(value, "next"), "Iterator next", node),
+            asynchronous: false,
+        }, node);
     }
-    hostCursor(value) {
-        const iterator = value instanceof Arr
-            ? value.items[Symbol.iterator]()
-            : typeof value === "string"
-                ? value[Symbol.iterator]()
-                : value instanceof MapObj
-                    ? value.map.entries()
-                    : value instanceof SetObj
-                        ? value.set.values()
-                        : value instanceof URLSearchParamsObj
-                            ? value.params.entries()
-                            : value instanceof HeadersObj
-                                ? value.headers.entries()
-                                : value instanceof Bytes
-                                    ? value.bytes.values()
-                                    : value instanceof IteratorObj
-                                        ? value.iterator
-                                        : undefined;
-        if (iterator === undefined)
-            return undefined;
-        const proto = this.ctx.builtins.Array;
+    customCursor(iterator, node) {
         return {
-            next: Effect.sync(() => {
-                const step = iterator.next();
-                return {
-                    done: Boolean(step.done),
-                    value: Array.isArray(step.value) ? new Arr(proto, step.value) : step.value,
-                };
-            }),
-            close: Effect.void,
+            next: this.nextIteratorResult(iterator, node, false),
+            close: Effect.suspend(() => this.closeIterator(iterator, node, false)),
         };
     }
+    builtinCursor(value) {
+        // Natives build their cursors without knowing R, like `lift` in native.ts.
+        if (value instanceof IteratorObj)
+            return value.cursor;
+        const iterator = typeof value === "string"
+            ? value[Symbol.iterator]()
+            : value instanceof Obj
+                ? value.iterator(this.ctx.builtins)
+                : undefined;
+        return iterator === undefined ? undefined : hostCursor(iterator);
+    }
     customIterator(value, node, allowAsync = true) {
         if (!(value instanceof Obj))
             return Effect.undefined;
@@ -941,7 +953,7 @@ class Frame {
                     return;
                 }
                 const consumed = consume(element, step.done ? undefined : step.value, pattern);
-                yield* step.done ? consumed : preserveConsumerError(cursor, consumed);
+                yield* step.done ? consumed : preserveConsumerError(cursor.close, consumed);
             }
             if (!done)
                 yield* cursor.close;
@@ -953,7 +965,7 @@ class Frame {
         }
         const keyNode = property.key;
         if (property.computed) {
-            return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value, keyNode));
+            return Effect.map(this.evaluateExpression(keyNode), (value) => this.toPropertyKey(value));
         }
         if (keyNode.type === "Identifier")
             return Effect.succeed(keyNode.name);
@@ -967,9 +979,7 @@ class Frame {
                 const regex = node.regex;
                 if (regex)
                     return Effect.sync(() => constructRegExp(this.ctx.builtins, [regex.pattern, regex.flags]));
-                if (typeof node.value === "bigint")
-                    throw typeError("BigInt literals are not supported.", node);
-                return Effect.succeed(node.value);
+                return Effect.succeed(literal(node));
             }
             case "Identifier":
                 return Effect.sync(() => this.scopes.get(node.name, node));
@@ -1069,14 +1079,9 @@ class Frame {
         if (containsOpaqueReference(lhs) || containsOpaqueReference(rhs)) {
             throw invalidData("Binary operators require data values.", node);
         }
-        // Null-prototype data needs explicit primitive coercion; identity and `in` retain raw objects.
-        // Dates use their default string hint for addition and loose equality, and epoch time elsewhere.
-        const coerceOperand = (operand) => {
-            if (operand instanceof DateObj) {
-                return operator === "+" || operator === "==" || operator === "!=" ? coerceToString(operand) : operand.time;
-            }
-            return operand !== null && typeof operand === "object" ? coerceToString(operand) : operand;
-        };
+        // Addition and loose equality use the default hint; every other operator asks for a number.
+        const hint = operator === "+" || operator === "==" || operator === "!=" ? "default" : "number";
+        const coerceOperand = (operand) => (operand instanceof Obj ? operand.toPrimitive(hint) : operand);
         const bothObjects = lhs !== null && typeof lhs === "object" && rhs !== null && typeof rhs === "object";
         const l = coerceOperand(lhs);
         const r = coerceOperand(rhs);
@@ -1161,11 +1166,7 @@ class Frame {
             if (containsOpaqueReference(value)) {
                 throw invalidData("Unary operators require data values.", node);
             }
-            const operand = value instanceof DateObj
-                ? value.time
-                : value !== null && typeof value === "object"
-                    ? coerceToString(value)
-                    : value;
+            const operand = value instanceof Obj ? value.toPrimitive("number") : value;
             let result;
             switch (operator) {
                 case "+":
@@ -1358,14 +1359,14 @@ class Frame {
             if (depth > MAX_CALL_DEPTH)
                 throw rangeError("Maximum call stack size exceeded", node);
             const invocation = new Frame(this.ctx, new ScopeStack([...fn.capturedScopes, new Map()]), depth);
-            const run = Effect.gen(function* () {
-                // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
-                const paramScope = invocation.scopes.current();
-                for (const parameter of fn.parameters) {
-                    for (const name of collectPatternNames(parameter)) {
-                        paramScope.set(name, { mutable: true, value: undefined, initialized: false });
-                    }
+            // Seed all parameters first so defaults cannot fall through to same-named outer bindings.
+            const paramScope = invocation.scopes.current();
+            for (const parameter of fn.parameters) {
+                for (const name of collectPatternNames(parameter)) {
+                    paramScope.set(name, { mutable: true, value: undefined, initialized: false });
                 }
+            }
+            const bind = Effect.gen(function* () {
                 for (const [index, parameter] of fn.parameters.entries()) {
                     if (parameter.type === "RestElement") {
                         yield* invocation.declarePattern(parameter.argument, new Arr(self.ctx.builtins.Array, args.slice(index)), true, parameter, true);
@@ -1373,6 +1374,8 @@ class Frame {
                     }
                     yield* invocation.declarePattern(parameter, args[index], true, parameter, true);
                 }
+            });
+            const body = Effect.gen(function* () {
                 if (fn.body.type === "BlockStatement") {
                     invocation.scopes.push();
                     invocation.hoistVars(fn.body.body, paramScope);
@@ -1381,14 +1384,17 @@ class Frame {
                 }
                 return yield* invocation.evaluateExpression(fn.body);
             });
+            // Generators bind parameters at the call and defer only the body to the first `next()`, as in JS.
             if (fn.generator)
-                return Effect.succeed(this.createGenerator(invocation, run, fn.async));
+                return Effect.map(bind, () => this.createGenerator(invocation, body, fn));
+            const run = Effect.andThen(bind, body);
             if (!fn.async)
                 return run;
             return this.ctx.pending.createWithSelf((self) => Effect.flatMap(run, (value) => resolvePromiseValue(invocation.ctx, value, self)));
         });
     }
-    createGenerator(invocation, run, asynchronous) {
+    createGenerator(invocation, run, fn) {
+        const asynchronous = fn.async;
         const state = { started: false, completed: false, draining: false, pending: [], pendingIndex: 0 };
         invocation.generatorState = state;
         invocation.generatorAsync = asynchronous;
@@ -1447,8 +1453,8 @@ class Frame {
             }
             return Deferred.await(request.response);
         };
-        const generator = new GeneratorObj(asynchronous ? builtins.AsyncGenerator : builtins.Generator, asynchronous, request);
-        return generator;
+        const proto = get(fn, "prototype");
+        return new GeneratorObj(proto instanceof Obj ? proto : builtins.Generator, asynchronous, request);
     }
     completeGeneratorRequests(state, asynchronous) {
         const self = this;
@@ -1524,16 +1530,8 @@ class Frame {
     delegateYield(value, node) {
         const self = this;
         return Effect.gen(function* () {
-            if (value instanceof Arr ||
-                typeof value === "string" ||
-                value instanceof MapObj ||
-                value instanceof SetObj ||
-                value instanceof URLSearchParamsObj ||
-                value instanceof HeadersObj ||
-                value instanceof Bytes) {
-                const cursor = yield* self.iterate(value, node);
-                if (!cursor)
-                    throw typeError("Built-in iterator is unavailable.", node);
+            const cursor = self.builtinCursor(value);
+            if (cursor !== undefined) {
                 while (true) {
                     const step = yield* cursor.next;
                     if (step.done)
@@ -1610,13 +1608,13 @@ class Frame {
                 const keyNode = property.key;
                 let key;
                 if (property.computed) {
-                    key = self.toPropertyKey(yield* self.evaluateExpression(keyNode), keyNode);
+                    key = self.toPropertyKey(yield* self.evaluateExpression(keyNode));
                 }
                 else if (keyNode.type === "Identifier") {
                     key = keyNode.name;
                 }
                 else if (keyNode.type === "Literal") {
-                    key = self.toPropertyKey(keyNode.value, keyNode);
+                    key = self.toPropertyKey(literal(keyNode));
                 }
                 else {
                     throw typeError("Unsupported object property key shape.", keyNode);
@@ -1707,10 +1705,10 @@ class Frame {
             if ((objectValue === null || objectValue === undefined) && node.optional)
                 return OptionalShortCircuit;
             const key = node.computed
-                ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode)
+                ? self.toPropertyKey(yield* self.evaluateExpression(propertyNode))
                 : propertyNode.type === "Identifier"
                     ? propertyNode.name
-                    : self.toPropertyKey(yield* self.evaluateExpression(propertyNode), propertyNode);
+                    : self.toPropertyKey(yield* self.evaluateExpression(propertyNode));
             if (objectValue instanceof ToolReference) {
                 if (typeof key !== "string") {
                     throw typeError("Tool paths must use string property names.", propertyNode);
@@ -1768,9 +1766,11 @@ class Frame {
     }
     evaluateDeleteExpression(argument) {
         const target = argument.type === "ChainExpression" ? argument.expression : argument;
-        if (target.type !== "MemberExpression") {
+        if (target.type === "Identifier")
             throw typeError("Only data fields may be deleted.", argument);
-        }
+        // `delete <non-reference>` evaluates the operand and is true, as in JS.
+        if (target.type !== "MemberExpression")
+            return Effect.map(this.evaluateExpression(target), () => true);
         return Effect.map(this.getMemberReference(target), (reference) => {
             if (reference === OptionalShortCircuit)
                 return true;
@@ -1816,12 +1816,10 @@ class Frame {
             throw rangeError("Invalid array length", node);
         throw typeError(`Cannot assign to read only property '${String(key)}'.`, node);
     }
-    toPropertyKey(value, node) {
-        if (typeof value === "string" || typeof value === "number") {
-            return value;
-        }
-        if (value === AsyncIteratorSymbol || value === IteratorSymbol)
+    // ToPropertyKey: anything else becomes its string form, so `counts[row.category]` works when the field is null.
+    toPropertyKey(value) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "symbol")
             return value;
-        throw typeError("Property key must be a string or number, or Symbol.asyncIterator/Symbol.iterator.", node);
+        return coerceToString(value);
     }
 }

package/dist/interpreter/intrinsics.d.ts

@@ -1,8 +1,8 @@
-import { ErrorObj, Obj } from "./objects.js";
+import { ErrorObj, Obj, type Value } from "./objects.js";
 export declare const errorTypes: readonly ["Error", "TypeError", "RangeError", "SyntaxError", "ReferenceError", "EvalError", "URIError", "AggregateError"];
 export type ErrorType = (typeof errorTypes)[number];
 export declare const isErrorType: (name: string) => name is ErrorType;
-declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "AsyncIterator", "Generator", "AsyncGenerator"];
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Headers", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "IteratorHelper", "AsyncIterator", "Generator", "AsyncGenerator"];
 /**
  * The built-in prototype objects of one runtime, allocated empty in dependency order. The globals populate them
  * and attach their constructors when the runtime is built.
@@ -10,6 +10,6 @@ declare const builtins: readonly ["Object", "Function", "Array", "String", "Numb
 export type Builtins = Readonly<Record<(typeof builtins)[number] | ErrorType, Obj>>;
 export declare const createErrorValue: (prototype: Obj, message: string | undefined) => ErrorObj;
 /** The prototype a primitive reads its methods from without being boxed; none for null, undefined, and symbols. */
-export declare const primitivePrototype: (builtins: Builtins, value: unknown) => Obj | undefined;
+export declare const primitivePrototype: (builtins: Builtins, value: Value) => Obj | undefined;
 export declare const createBuiltins: () => Builtins;
 export {};

package/dist/interpreter/intrinsics.js

@@ -30,6 +30,7 @@ const builtins = [
     "TextDecoder",
     "Promise",
     "Iterator",
+    "IteratorHelper",
     "AsyncIterator",
     "Generator",
     "AsyncGenerator",
@@ -85,6 +86,7 @@ export const createBuiltins = () => {
         TextDecoder: plain(),
         Promise: plain(),
         Iterator: iterator,
+        IteratorHelper: new Obj(iterator),
         AsyncIterator: asyncIterator,
         Generator: new Obj(iterator),
         AsyncGenerator: new Obj(asyncIterator),

package/dist/interpreter/model.d.ts

@@ -2,7 +2,7 @@ import type { Node } from "acorn";
 import { Context } from "effect";
 import type { ErrorType } from "./intrinsics.js";
 import type { DiagnosticKind } from "../codemode.js";
-import type { ErrorObj } from "./objects.js";
+import type { ErrorObj, Value } from "./objects.js";
 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
 export type AstNode = Node;
 /** The program call a built-in is running under: where to locate failures born inside it, and how deep the stack is there. */
@@ -12,14 +12,14 @@ export declare const CallSite: Context.Reference<{
 }>;
 export type Binding = {
     mutable: boolean;
-    value: unknown;
+    value: Value;
     initialized?: boolean;
 };
 export type StatementResult = {
     kind: "none";
 } | {
     kind: "return";
-    value: unknown;
+    value: Value;
 } | {
     kind: "break";
     label?: string;
@@ -32,12 +32,12 @@ export declare const AsyncIteratorSymbol: unique symbol;
 export declare const IteratorSymbol: unique symbol;
 export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
 export declare class Throw {
-    readonly value: unknown;
-    constructor(value: unknown);
+    readonly value: Value;
+    constructor(value: Value);
 }
 export declare class GeneratorReturn {
-    readonly value: unknown;
-    constructor(value: unknown);
+    readonly value: Value;
+    constructor(value: Value);
 }
 export declare const OptionalShortCircuit: unique symbol;
 /**
@@ -64,7 +64,6 @@ export declare const syntaxError: (message: string, node?: AstNode) => PendingTh
 export declare const uriError: (message: string, node?: AstNode) => PendingThrow;
 export declare const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export declare const unsupportedSyntax: (kind: string, node: AstNode) => PendingThrow;
-export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
 export declare const sourceLocation: (node: AstNode) => {
     readonly line: number;
     readonly column: number;

package/dist/interpreter/model.js

@@ -51,7 +51,6 @@ export const uriError = failure("URIError");
 // Orient the agent rather than enumerate JavaScript; interpreter-support.md is the full matrix.
 export const supportedSyntaxMessage = "This is a restricted JavaScript-like language. Supported: plain and async functions, data literals, destructuring, standard control flow, await and Promise, and built-ins such as Array, Object, Math, JSON, Date, RegExp, Map, Set, and URL. Unsupported: classes, this, getters/setters, tagged templates, BigInt, and custom Symbols. Use plain functions and data objects instead.";
 export const unsupportedSyntax = (kind, node) => new PendingThrow("SyntaxError", `Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
-export const isRecord = (value) => typeof value === "object" && value !== null;
 // Acorn lines are 1-based and its columns are 0-based. Diagnostics use 1-based columns of the submitted source.
 export const sourceLocation = (node) => ({
     line: node.loc?.start.line ?? 1,

package/dist/interpreter/native.d.ts

@@ -1,13 +1,13 @@
 import { Effect } from "effect";
 import type { Builtins } from "./intrinsics.js";
-import { type Callable, Native, type NativeOptions, Obj } from "./objects.js";
-/** A native function body: a plain value, a thrown `PendingThrow`, or an Effect. */
-export type Impl = (thisValue: unknown, args: Array<unknown>) => unknown;
+import { type Callable, Native, type NativeOptions, Obj, type Value } from "./objects.js";
+/** A native function body: a value, a thrown `PendingThrow`, or an Effect of a value. */
+export type Impl = (thisValue: Value, args: Array<Value>) => Value | Effect.Effect<Value, unknown, unknown>;
 export declare const native: <R>(builtins: Builtins, options: NativeOptions<R>) => Native<R>;
 export declare const fn: <R>(builtins: Builtins, name: string, length: number, impl: Impl) => Native<R>;
 export type Method = readonly [name: string, length: number, impl: Impl];
 export declare const methods: (builtins: Builtins, target: Obj, table: ReadonlyArray<Method>) => void;
-export declare const constants: (target: Obj, table: Record<string, unknown>) => void;
+export declare const constants: (target: Obj, table: Record<string, Value>) => void;
 /** A constructor wired to its prototype: `C.prototype === proto` and `proto.constructor === C`. */
 export declare const constructor: <R>(builtins: Builtins, proto: Obj, options: NativeOptions<R>) => Native<R>;
 /** The `call` of a constructor that JS requires to be invoked with `new`. */
@@ -15,4 +15,4 @@ export declare const requiresNew: (name: string) => () => Effect.Effect<never, u
 /** The instance prototype for `new` via `newTarget.prototype`, falling back to the built-in's own. */
 export declare const prototypeFrom: (newTarget: Callable, fallback: Obj) => Obj;
 /** Narrows a method receiver to the built-in it belongs to, or throws the TypeError JS would. */
-export declare const receiver: <T extends Obj>(cls: abstract new (...args: never) => T, thisValue: unknown, method: string) => T;
+export declare const receiver: <T extends Obj>(cls: abstract new (...args: never) => T, thisValue: Value, method: string) => T;