@opencode/codemode 0.0.0-dev-19530 → 2.0.0

package/dist/interpreter/model.d.ts

@@ -1,6 +1,8 @@
 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 = {
@@ -20,10 +22,39 @@ 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);
@@ -36,19 +67,11 @@ export declare const OptionalShortCircuit: unique symbol;
 export declare class InterpreterRuntimeError extends Error {
     readonly kind: DiagnosticKind;
     readonly suggestions?: ReadonlyArray<string> | undefined;
-    /** The JS error class a program sees when it catches this failure. */
-    readonly type: ErrorType;
     readonly node?: AstNode;
-    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined, 
-    /** 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;
-export declare const uriError: (message: string, node?: AstNode) => InterpreterRuntimeError;
+    errorName: string;
+    constructor(message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
+    as(errorName: string): this;
+}
 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) => InterpreterRuntimeError;
 export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/interpreter/model.js

@@ -1,6 +1,44 @@
+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) {
@@ -17,32 +55,24 @@ export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
 export class InterpreterRuntimeError extends Error {
     kind;
     suggestions;
-    type;
     node;
-    constructor(message, node, kind = "ExecutionFailure", suggestions, 
-    /** The JS error class a program sees when it catches this failure. */
-    type = "TypeError") {
+    errorName = "Error";
+    constructor(message, node, kind = "ExecutionFailure", suggestions) {
         super(message);
         this.kind = kind;
         this.suggestions = suggestions;
-        this.type = type;
         this.name = "InterpreterRuntimeError";
         if (node)
             this.node = node;
     }
+    as(errorName) {
+        this.errorName = errorName;
+        return this;
+    }
 }
-/** 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");
-export const syntaxError = failure("SyntaxError");
-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 InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage], "SyntaxError");
+export const unsupportedSyntax = (kind, node) => new InterpreterRuntimeError(`Syntax '${kind}' is not supported. ${supportedSyntaxMessage}`, node, "UnsupportedSyntax", [supportedSyntaxMessage]);
 export const isRecord = (value) => typeof value === "object" && value !== null;
 export const sourceLocation = (node) => ({
     line: Math.max(1, (node.loc?.start.line ?? 2) - 1),

package/dist/interpreter/objects.d.ts

@@ -1,130 +1,37 @@
 import type { BlockStatement, Expression, Pattern } from "acorn";
-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;
+import { type Binding } from "./model.js";
 /** An object owned by the program: own properties plus a prototype link. */
 export declare class ProgramObject {
     proto: ProgramObject | null;
-    readonly props: Map<string | symbol, Slot>;
-    constructor(proto: ProgramObject | null);
+    readonly props: Map<PropertyKey, unknown>;
+    constructor(proto?: ProgramObject | null);
 }
 export declare class ProgramArray extends ProgramObject {
     readonly items: Array<unknown>;
-    constructor(proto: ProgramObject, items?: Array<unknown>);
+    constructor(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 {
+    readonly errorName: string;
+    constructor(errorName: string);
 }
-export declare abstract class Callable extends ProgramObject {
-    constructor(proto: ProgramObject, name: string, length: number);
-}
-export declare class ProgramFunction extends Callable {
+export declare class ProgramFunction extends ProgramObject {
+    readonly name: string;
     readonly parameters: ReadonlyArray<Pattern>;
     readonly body: BlockStatement | Expression;
     readonly capturedScopes: ReadonlyArray<Map<string, Binding>>;
     readonly async: boolean;
     readonly 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);
+    readonly length: number;
+    constructor(name: string, parameters: ReadonlyArray<Pattern>, body: BlockStatement | Expression, capturedScopes: ReadonlyArray<Map<string, Binding>>, async: boolean, generator: boolean);
 }
-/** 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;
-/** [[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 get: (target: ProgramObject, key: PropertyKey) => 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>;
-/** 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 ownEntries: (target: ProgramObject) => Array<[string, unknown]>;
+export declare const record: (entries: Record<string, unknown>) => ProgramObject;
 export declare const assign: (target: ProgramObject, source: ProgramObject, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -1,124 +1,46 @@
 import { AsyncIteratorSymbol, IteratorSymbol } from "./model.js";
-/** Ordinary assignment: writable, enumerable, configurable. */
-export const data = { writable: true, enumerable: true, configurable: true };
-/** Built-in methods and `constructor`: writable and configurable but hidden from enumeration. */
-export const hidden = { writable: true, enumerable: false, configurable: true };
-/** Function `name` and `length`: read-only but deletable. */
-export const readonly = { writable: false, enumerable: false, configurable: true };
-/** Constants such as `Math.PI` and a constructor's `prototype`. */
-export const frozen = { writable: false, enumerable: false, configurable: false };
 /** An object owned by the program: own properties plus a prototype link. */
 export class ProgramObject {
     proto;
     props = new Map();
-    constructor(proto) {
+    constructor(proto = null) {
         this.proto = proto;
     }
 }
 export class ProgramArray extends ProgramObject {
     items;
-    constructor(proto, items = []) {
-        super(proto);
+    constructor(items = []) {
+        super();
         this.items = items;
     }
 }
-/** An object with the [[ErrorData]] slot: what `Error.prototype.toString` and the host boundary recognize as an error. */
 export class ProgramError extends ProgramObject {
-}
-export class Callable extends ProgramObject {
-    constructor(proto, name, length) {
-        super(proto);
-        define(this, "length", length, readonly);
-        define(this, "name", name, readonly);
+    errorName;
+    constructor(errorName) {
+        super();
+        this.errorName = errorName;
     }
 }
-export class ProgramFunction extends Callable {
+export class ProgramFunction extends ProgramObject {
+    name;
     parameters;
     body;
     capturedScopes;
     async;
     generator;
-    constructor(proto, name, parameters, body, capturedScopes, async, generator) {
-        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
-        super(proto, name, optional === -1 ? parameters.length : optional);
+    length;
+    constructor(name, parameters, body, capturedScopes, async, generator) {
+        super();
+        this.name = name;
         this.parameters = parameters;
         this.body = body;
         this.capturedScopes = capturedScopes;
         this.async = async;
         this.generator = generator;
+        const optional = parameters.findIndex((p) => p.type === "AssignmentPattern" || p.type === "RestElement");
+        this.length = optional === -1 ? parameters.length : optional;
     }
 }
-export class NativeFunction extends Callable {
-    call;
-    construct;
-    callback;
-    constructor(proto, options) {
-        super(proto, options.name, options.length ?? 0);
-        this.call = options.call;
-        this.construct = options.construct;
-        this.callback = options.callback ?? true;
-    }
-}
-export class ProgramPromise extends ProgramObject {
-    fiber;
-    constructor(proto, fiber) {
-        super(proto);
-        this.fiber = fiber;
-    }
-}
-export class ProgramGenerator extends ProgramObject {
-    asynchronous;
-    request;
-    constructor(proto, asynchronous, request) {
-        super(proto);
-        this.asynchronous = asynchronous;
-        this.request = request;
-    }
-}
-export class ProgramDate extends ProgramObject {
-    time;
-    constructor(proto, time) {
-        super(proto);
-        this.time = time;
-    }
-}
-export class ProgramRegExp extends ProgramObject {
-    regex;
-    constructor(proto, pattern, flags) {
-        super(proto);
-        this.regex = new RegExp(pattern, flags);
-        define(this, "lastIndex", 0, { writable: true, enumerable: false, configurable: false });
-    }
-}
-export class ProgramMap extends ProgramObject {
-    map = new Map();
-}
-export class ProgramSet extends ProgramObject {
-    set = new Set();
-}
-export class ProgramURLSearchParams extends ProgramObject {
-    params;
-    constructor(proto, params) {
-        super(proto);
-        this.params = params;
-    }
-}
-export class ProgramURL extends ProgramObject {
-    url;
-    searchParams;
-    constructor(proto, searchParamsProto, url) {
-        super(proto);
-        this.url = url;
-        this.searchParams = new ProgramURLSearchParams(searchParamsProto, url.searchParams);
-    }
-}
-/** Built-in objects that wrap a host value; data-like, but never plain data. */
-export const isWrapper = (value) => value instanceof ProgramDate ||
-    value instanceof ProgramRegExp ||
-    value instanceof ProgramMap ||
-    value instanceof ProgramSet ||
-    value instanceof ProgramURL ||
-    value instanceof ProgramURLSearchParams;
 const MAX_ARRAY_LENGTH = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
@@ -129,119 +51,72 @@ export const parseArrayIndex = (key) => {
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
 const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
-/** The own property under `key`, including an array's live indexes and `length`. */
-export const own = (target, key) => {
+// Non-enumerable built-in properties: array length, function name and length.
+const builtin = (target, name) => (name === "length" && target instanceof ProgramArray) ||
+    ((name === "name" || name === "length") && target instanceof ProgramFunction);
+export const hasOwn = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
-        const at = index(target, name);
-        if (at !== undefined) {
-            return at in target.items ? { value: target.items[at], ...data } : undefined;
-        }
-        if (name === "length")
-            return { value: target.items.length, writable: true, enumerable: false, configurable: false };
-    }
-    return target.props.get(name);
+    const at = index(target, name);
+    if (at !== undefined)
+        return at in target.items;
+    return builtin(target, name) || target.props.has(name);
 };
-const read = (slot, receiver) => "value" in slot ? slot.value : slot.get === undefined ? undefined : slot.get(receiver);
-export const hasOwn = (target, key) => own(target, key) !== undefined;
 export const getOwn = (target, key) => {
-    const slot = own(target, key);
-    return slot === undefined ? undefined : read(slot, target);
+    const name = canonical(key);
+    const at = index(target, name);
+    if (at !== undefined)
+        return target.items[at];
+    if (target instanceof ProgramArray && name === "length")
+        return target.items.length;
+    if (target instanceof ProgramFunction && name === "name")
+        return target.name;
+    if (target instanceof ProgramFunction && name === "length")
+        return target.length;
+    return target.props.get(name);
 };
-/** [[Get]]: walks the prototype chain; accessors see `receiver`, which is the primitive for wrapper prototypes. */
-export const get = (target, key, receiver = target) => {
+export const get = (target, key) => {
     for (let current = target; current !== null; current = current.proto) {
-        const slot = own(current, key);
-        if (slot !== undefined)
-            return read(slot, receiver);
+        if (hasOwn(current, key))
+            return getOwn(current, key);
     }
     return undefined;
 };
 export const has = (target, key) => {
     for (let current = target; current !== null; current = current.proto) {
-        if (own(current, key) !== undefined)
+        if (hasOwn(current, key))
             return true;
     }
     return false;
 };
-export const hasPrototype = (value, proto) => {
-    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
-        if (current === proto)
-            return true;
-    }
-    return false;
-};
-const writeArray = (target, name, value) => {
+export const set = (target, key, value) => {
+    const name = canonical(key);
     const at = index(target, name);
     if (at !== undefined) {
+        ;
         target.items[at] = value;
         return true;
     }
-    if (name !== "length")
-        return undefined;
-    const length = typeof value === "number" ? value : Number(value);
-    if (!Number.isInteger(length) || length < 0 || length > MAX_ARRAY_LENGTH)
-        return false;
-    target.items.length = length;
-    return true;
-};
-/** [[Set]]: an inherited setter or read-only property decides before an own data property is created. */
-export const set = (target, key, value) => {
-    const name = canonical(key);
-    for (let current = target; current !== null; current = current.proto) {
-        const slot = own(current, name);
-        if (slot === undefined)
-            continue;
-        if (!("value" in slot)) {
-            if (slot.set === undefined)
-                return false;
-            slot.set(target, value);
-            return true;
-        }
-        if (!slot.writable)
+    if (name === "length" && target instanceof ProgramArray) {
+        const length = typeof value === "number" ? value : Number(value);
+        if (!Number.isInteger(length) || length < 0 || length > 4_294_967_295)
             return false;
-        if (current !== target)
-            break;
-        if (target instanceof ProgramArray) {
-            const written = writeArray(target, name, value);
-            if (written !== undefined)
-                return written;
-        }
-        slot.value = value;
+        target.items.length = length;
         return true;
     }
-    if (target instanceof ProgramArray) {
-        const written = writeArray(target, name, value);
-        if (written !== undefined)
-            return written;
-    }
-    target.props.set(name, { value, ...data });
+    if (builtin(target, name))
+        return false;
+    target.props.set(name, value);
     return true;
 };
-/** [[DefineOwnProperty]] for a data property, ignoring the chain. */
-export const define = (target, key, value, attrs = data) => {
-    const name = canonical(key);
-    if (target instanceof ProgramArray && writeArray(target, name, value) !== undefined)
-        return;
-    target.props.set(name, { value, ...attrs });
-};
-export const defineAccessor = (target, key, get, set) => {
-    target.props.set(canonical(key), { get, set, enumerable: false, configurable: true });
-};
 export const remove = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
-        const at = index(target, name);
-        if (at !== undefined)
-            return delete target.items[at];
-        if (name === "length")
-            return false;
-    }
-    const slot = target.props.get(name);
-    if (slot === undefined)
-        return true;
-    if (!slot.configurable)
+    const at = index(target, name);
+    if (at !== undefined)
+        return delete target.items[at];
+    if (name === "length" && target instanceof ProgramArray)
         return false;
+    if (builtin(target, name))
+        return true;
     target.props.delete(name);
     return true;
 };
@@ -250,29 +125,27 @@ export const ownKeys = (target) => {
     const strings = [...target.props.keys()].filter((key) => typeof key === "string");
     const symbols = [...target.props.keys()].filter((key) => typeof key === "symbol");
     return [
-        ...(target instanceof ProgramArray ? [...Object.keys(target.items), "length"] : []),
+        ...(target instanceof ProgramArray ? Object.keys(target.items) : []),
         ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
         ...strings.filter((key) => parseArrayIndex(key) === undefined),
         ...symbols,
     ];
 };
-const enumerable = (target, key) => own(target, key)?.enumerable === true;
-/** Own enumerable keys, including the iterator symbols; what spread and `Object.assign` copy. */
-export const enumerableKeys = (target) => ownKeys(target).filter((key) => (typeof key === "string" || key === IteratorSymbol || key === AsyncIteratorSymbol) && enumerable(target, key));
-/** Own enumerable string keys: `Object.keys`. */
-export const keys = (target) => ownKeys(target).filter((key) => typeof key === "string" && enumerable(target, key));
-/** Own enumerable string entries: `Object.entries` and serialization. */
-export const entries = (target) => keys(target).map((key) => [key, getOwn(target, key)]);
-export const record = (proto, fields) => {
-    const target = new ProgramObject(proto);
-    for (const [key, value] of Object.entries(fields))
-        define(target, key, value);
+export const ownEntries = (target) => ownKeys(target)
+    .filter((key) => typeof key === "string")
+    .map((key) => [key, getOwn(target, key)]);
+export const record = (entries) => {
+    const target = new ProgramObject();
+    for (const [key, value] of Object.entries(entries))
+        set(target, key, value);
     return target;
 };
 export const assign = (target, source, skip) => {
-    for (const key of enumerableKeys(source)) {
+    for (const key of ownKeys(source)) {
         if (skip?.has(key))
             continue;
+        if (typeof key === "symbol" && key !== IteratorSymbol && key !== AsyncIteratorSymbol)
+            continue;
         set(target, key, getOwn(source, key));
     }
 };