@opencode/codemode 2.0.1 → 2.0.2

package/dist/interpreter/intrinsics.js

@@ -1,4 +1,5 @@
-import { ProgramError, ProgramObject, set } from "./objects.js";
+import { Effect } from "effect";
+import { define, hidden, NativeFunction, ProgramArray, ProgramError, ProgramObject } from "./objects.js";
 export const errorTypes = [
     "Error",
     "TypeError",
@@ -10,32 +11,72 @@ export const errorTypes = [
     "AggregateError",
 ];
 export const isErrorType = (name) => errorTypes.includes(name);
+const builtins = [
+    "Object",
+    "Function",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Date",
+    "RegExp",
+    "Map",
+    "Set",
+    "URL",
+    "URLSearchParams",
+    "Promise",
+    "Iterator",
+    "AsyncIterator",
+    "Generator",
+    "AsyncGenerator",
+];
 export const createErrorValue = (prototype, message) => {
     const value = new ProgramError(prototype);
     if (message !== undefined)
-        set(value, "message", message);
+        define(value, "message", message, hidden);
     return value;
 };
-export const createIntrinsics = () => {
-    const error = new ProgramObject();
-    set(error, "name", "Error");
-    set(error, "message", "");
+export const createPrototypes = () => {
+    const object = new ProgramObject(null);
+    // Function.prototype is itself callable and returns undefined.
+    const fn = new NativeFunction(object, { name: "", call: () => Effect.undefined });
+    const plain = () => new ProgramObject(object);
+    const error = plain();
+    define(error, "name", "Error", hidden);
+    define(error, "message", "", hidden);
     const derived = (type) => {
         const proto = new ProgramObject(error);
-        set(proto, "name", type);
-        set(proto, "message", "");
+        define(proto, "name", type, hidden);
+        define(proto, "message", "", hidden);
         return proto;
     };
+    const iterator = plain();
+    const asyncIterator = plain();
     return {
-        errors: {
-            Error: error,
-            TypeError: derived("TypeError"),
-            RangeError: derived("RangeError"),
-            SyntaxError: derived("SyntaxError"),
-            ReferenceError: derived("ReferenceError"),
-            EvalError: derived("EvalError"),
-            URIError: derived("URIError"),
-            AggregateError: derived("AggregateError"),
-        },
+        Object: object,
+        Function: fn,
+        Array: new ProgramArray(object),
+        String: plain(),
+        Number: plain(),
+        Boolean: plain(),
+        Date: plain(),
+        RegExp: plain(),
+        Map: plain(),
+        Set: plain(),
+        URL: plain(),
+        URLSearchParams: plain(),
+        Promise: plain(),
+        Iterator: iterator,
+        AsyncIterator: asyncIterator,
+        Generator: new ProgramObject(iterator),
+        AsyncGenerator: new ProgramObject(asyncIterator),
+        Error: error,
+        TypeError: derived("TypeError"),
+        RangeError: derived("RangeError"),
+        SyntaxError: derived("SyntaxError"),
+        ReferenceError: derived("ReferenceError"),
+        EvalError: derived("EvalError"),
+        URIError: derived("URIError"),
+        AggregateError: derived("AggregateError"),
     };
 };

package/dist/interpreter/model.d.ts

@@ -1,9 +1,6 @@
 import type { Node } from "acorn";
 import type { ErrorType } from "./intrinsics.js";
-import type { Effect } from "effect";
 import type { DiagnosticKind } from "../codemode.js";
-import type { ProgramObject } from "./objects.js";
-import type { Values } from "../values.js";
 /** Any parsed node; the interpreter narrows on `type` and reads `loc` for diagnostics. */
 export type AstNode = Node;
 export type Binding = {
@@ -23,39 +20,10 @@ export type StatementResult = {
     kind: "continue";
     label?: string;
 };
-export type MemberReference = {
-    target: ProgramObject | Values.RegExp | Values.URL;
-    key: PropertyKey;
-};
 export type GeneratorRequestKind = "next" | "return" | "throw";
-export declare class CodeModeGenerator {
-    readonly asynchronous: boolean;
-    readonly request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
-    constructor(asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
-}
-export declare class GeneratorMethodReference {
-    readonly generator: CodeModeGenerator;
-    readonly kind: GeneratorRequestKind | "iterator";
-    constructor(generator: CodeModeGenerator, kind: GeneratorRequestKind | "iterator");
-}
-export declare class IntrinsicReference {
-    readonly receiver: unknown;
-    readonly name: string;
-    constructor(receiver: unknown, name: string);
-}
-export declare class ComputedValue {
-    readonly value: unknown;
-    constructor(value: unknown);
-}
 export declare const AsyncIteratorSymbol: unique symbol;
 export declare const IteratorSymbol: unique symbol;
 export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
-export type PromiseInstanceMethodName = "then" | "catch" | "finally";
-export declare class PromiseInstanceMethodReference {
-    readonly promise: Values.Promise;
-    readonly name: PromiseInstanceMethodName;
-    constructor(promise: Values.Promise, name: PromiseInstanceMethodName);
-}
 export declare class ProgramThrow {
     readonly value: unknown;
     constructor(value: unknown);
@@ -75,6 +43,8 @@ export declare class InterpreterRuntimeError extends Error {
     /** The JS error class a program sees when it catches this failure. */
     type?: ErrorType);
 }
+/** Attaches a source location to a failure raised where none was known, such as inside a property accessor. */
+export declare const locate: (error: unknown, node: AstNode) => unknown;
 export declare const rangeError: (message: string, node?: AstNode) => InterpreterRuntimeError;
 export declare const referenceError: (message: string, node?: AstNode) => InterpreterRuntimeError;
 export declare const syntaxError: (message: string, node?: AstNode) => InterpreterRuntimeError;

package/dist/interpreter/model.js

@@ -1,44 +1,6 @@
-export class CodeModeGenerator {
-    asynchronous;
-    request;
-    constructor(asynchronous, request) {
-        this.asynchronous = asynchronous;
-        this.request = request;
-    }
-}
-export class GeneratorMethodReference {
-    generator;
-    kind;
-    constructor(generator, kind) {
-        this.generator = generator;
-        this.kind = kind;
-    }
-}
-export class IntrinsicReference {
-    receiver;
-    name;
-    constructor(receiver, name) {
-        this.receiver = receiver;
-        this.name = name;
-    }
-}
-export class ComputedValue {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-}
 export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
 export const IteratorSymbol = Symbol("codemode.iterator");
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
-export class PromiseInstanceMethodReference {
-    promise;
-    name;
-    constructor(promise, name) {
-        this.promise = promise;
-        this.name = name;
-    }
-}
 export class ProgramThrow {
     value;
     constructor(value) {
@@ -69,6 +31,10 @@ export class InterpreterRuntimeError extends Error {
             this.node = node;
     }
 }
+/** Attaches a source location to a failure raised where none was known, such as inside a property accessor. */
+export const locate = (error, node) => error instanceof InterpreterRuntimeError && error.node === undefined
+    ? new InterpreterRuntimeError(error.message, node, error.kind, error.suggestions, error.type)
+    : error;
 const failure = (type) => (message, node) => new InterpreterRuntimeError(message, node, "ExecutionFailure", undefined, type);
 export const rangeError = failure("RangeError");
 export const referenceError = failure("ReferenceError");

package/dist/interpreter/native.d.ts

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

package/dist/interpreter/native.js

@@ -0,0 +1,40 @@
+import { Effect } from "effect";
+import { InterpreterRuntimeError } from "./model.js";
+import { define, frozen, hidden, NativeFunction, ProgramObject } from "./objects.js";
+import { describeValue } from "./references.js";
+const lift = (impl) => (thisValue, args, node) => Effect.suspend(() => {
+    const result = impl(thisValue, args, node);
+    return Effect.isEffect(result) ? result : Effect.succeed(result);
+});
+export const native = (protos, options) => new NativeFunction(protos.Function, options);
+export const fn = (protos, name, length, impl) => native(protos, { name, length, call: lift(impl) });
+export const methods = (protos, target, table) => {
+    for (const [name, length, impl] of table)
+        define(target, name, fn(protos, name, length, impl), hidden);
+};
+export const constants = (target, table) => {
+    for (const [name, value] of Object.entries(table))
+        define(target, name, value, frozen);
+};
+/** A constructor wired to its prototype: `C.prototype === proto` and `proto.constructor === C`. */
+export const constructor = (protos, proto, options) => {
+    const ctor = native(protos, options);
+    define(ctor, "prototype", proto, frozen);
+    define(proto, "constructor", ctor, hidden);
+    return ctor;
+};
+/** The `call` of a constructor that JS requires to be invoked with `new`. */
+export const requiresNew = (name) => (_, __, node) => Effect.sync(() => {
+    throw new InterpreterRuntimeError(`Constructor ${name} requires 'new'.`, node);
+});
+/** The instance prototype for `new` via `newTarget.prototype`, falling back to the built-in's own. */
+export const prototypeFrom = (newTarget, fallback) => {
+    const proto = newTarget.props.get("prototype");
+    return proto !== undefined && "value" in proto && proto.value instanceof ProgramObject ? proto.value : fallback;
+};
+/** Narrows a method receiver to the built-in it belongs to, or throws the TypeError JS would. */
+export const receiver = (cls, thisValue, method, node) => {
+    if (thisValue instanceof cls)
+        return thisValue;
+    throw new InterpreterRuntimeError(`${method} called on incompatible receiver ${describeValue(thisValue)}.`, node);
+};

package/dist/interpreter/objects.d.ts

@@ -1,37 +1,130 @@
 import type { BlockStatement, Expression, Pattern } from "acorn";
-import { type Binding } from "./model.js";
+import type { Effect, Fiber } from "effect";
+import { type AstNode, type Binding, type GeneratorRequestKind } from "./model.js";
+/** Property attributes, as in a JS property descriptor. */
+export type Attributes = {
+    readonly writable: boolean;
+    readonly enumerable: boolean;
+    readonly configurable: boolean;
+};
+export type Getter = (receiver: unknown) => unknown;
+export type Setter = (receiver: unknown, value: unknown) => void;
+/** One own property: a data slot or a native accessor pair. */
+export type Slot = {
+    value: unknown;
+    writable: boolean;
+    enumerable: boolean;
+    configurable: boolean;
+} | {
+    get: Getter | undefined;
+    set: Setter | undefined;
+    enumerable: boolean;
+    configurable: boolean;
+};
+/** Ordinary assignment: writable, enumerable, configurable. */
+export declare const data: Attributes;
+/** Built-in methods and `constructor`: writable and configurable but hidden from enumeration. */
+export declare const hidden: Attributes;
+/** Function `name` and `length`: read-only but deletable. */
+export declare const readonly: Attributes;
+/** Constants such as `Math.PI` and a constructor's `prototype`. */
+export declare const frozen: Attributes;
 /** An object owned by the program: own properties plus a prototype link. */
 export declare class ProgramObject {
     proto: ProgramObject | null;
-    readonly props: Map<PropertyKey, unknown>;
-    constructor(proto?: ProgramObject | null);
+    readonly props: Map<string | symbol, Slot>;
+    constructor(proto: ProgramObject | null);
 }
 export declare class ProgramArray extends ProgramObject {
     readonly items: Array<unknown>;
-    constructor(items?: Array<unknown>);
+    constructor(proto: ProgramObject, items?: Array<unknown>);
 }
 /** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export declare class ProgramError extends ProgramObject {
 }
-export declare class ProgramFunction extends ProgramObject {
-    readonly name: string;
+export declare abstract class Callable extends ProgramObject {
+    constructor(proto: ProgramObject, name: string, length: number);
+}
+export declare class ProgramFunction extends Callable {
     readonly parameters: ReadonlyArray<Pattern>;
     readonly body: BlockStatement | Expression;
     readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
     readonly async: boolean;
     readonly generator: boolean;
-    readonly length: number;
-    constructor(name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+    constructor(proto: ProgramObject, name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
+}
+export type NativeCall<R> = (thisValue: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export type NativeConstruct<R> = (args: Array<unknown>, newTarget: Callable, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export type NativeOptions<R> = {
+    readonly name: string;
+    readonly length?: number;
+    readonly call: NativeCall<R>;
+    /** `new name(...)`; without it the function is not a constructor. */
+    readonly construct?: NativeConstruct<R>;
+    /** Whether callback sites (array methods, replacers, promise reactions) admit this function. Defaults to true. */
+    readonly callback?: boolean;
+};
+export declare class NativeFunction<R = never> extends Callable {
+    readonly call: NativeCall<R>;
+    readonly construct: NativeConstruct<R> | undefined;
+    readonly callback: boolean;
+    constructor(proto: ProgramObject, options: NativeOptions<R>);
+}
+export declare class ProgramPromise extends ProgramObject {
+    readonly fiber: Fiber.Fiber<unknown, unknown>;
+    constructor(proto: ProgramObject, fiber: Fiber.Fiber<unknown, unknown>);
+}
+export declare class ProgramGenerator extends ProgramObject {
+    readonly asynchronous: boolean;
+    readonly request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
+    constructor(proto: ProgramObject, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
+}
+export declare class ProgramDate extends ProgramObject {
+    time: number;
+    constructor(proto: ProgramObject, time: number);
 }
+export declare class ProgramRegExp extends ProgramObject {
+    readonly regex: RegExp;
+    constructor(proto: ProgramObject, pattern: string, flags: string);
+}
+export declare class ProgramMap extends ProgramObject {
+    readonly map: Map<unknown, unknown>;
+}
+export declare class ProgramSet extends ProgramObject {
+    readonly set: Set<unknown>;
+}
+export declare class ProgramURLSearchParams extends ProgramObject {
+    readonly params: URLSearchParams;
+    constructor(proto: ProgramObject, params: URLSearchParams);
+}
+export declare class ProgramURL extends ProgramObject {
+    readonly url: URL;
+    readonly searchParams: ProgramURLSearchParams;
+    constructor(proto: ProgramObject, searchParamsProto: ProgramObject, url: URL);
+}
+/** Built-in objects that wrap a host value; data-like, but never plain data. */
+export declare const isWrapper: (value: unknown) => value is ProgramDate | ProgramRegExp | ProgramMap | ProgramSet | ProgramURL | ProgramURLSearchParams;
 export declare const parseArrayIndex: (key: string | number) => number | undefined;
+/** The own property under `key`, including an array's live indexes and `length`. */
+export declare const own: (target: ProgramObject, key: PropertyKey) => Slot | undefined;
 export declare const hasOwn: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const getOwn: (target: ProgramObject, key: PropertyKey) => unknown;
-export declare const get: (target: ProgramObject, key: PropertyKey) => unknown;
-export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boolean;
+/** [[Get]]: walks the prototype chain; accessors see `receiver`, which is the primitive for wrapper prototypes. */
+export declare const get: (target: ProgramObject, key: PropertyKey, receiver?: unknown) => unknown;
 export declare const has: (target: ProgramObject, key: PropertyKey) => boolean;
+export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boolean;
+/** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
 export declare const set: (target: ProgramObject, key: PropertyKey, value: unknown) => boolean;
+/** [[DefineOwnProperty]] for a data property, ignoring the chain. */
+export declare const define: (target: ProgramObject, key: PropertyKey, value: unknown, attrs?: Attributes) => void;
+export declare const defineAccessor: (target: ProgramObject, key: PropertyKey, get: Getter, set?: Setter) => void;
 export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
 export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
-export declare const ownEntries: (target: ProgramObject) => Array<[string, unknown]>;
-export declare const record: (entries: Record<string, unknown>) => ProgramObject;
+/** Own enumerable keys, including the iterator symbols; what spread and `Object.assign` copy. */
+export declare const enumerableKeys: (target: ProgramObject) => Array<string | symbol>;
+/** Own enumerable string keys: `Object.keys`. */
+export declare const keys: (target: ProgramObject) => Array<string>;
+/** Own enumerable string entries: `Object.entries` and serialization. */
+export declare const entries: (target: ProgramObject) => Array<[string, unknown]>;
+export declare const record: (proto: ProgramObject, fields: Record<string, unknown>) => ProgramObject;
 export declare const assign: (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>) => void;