@opencode/codemode 0.0.0-dev-19631 → 0.0.0-dev-19633

package/dist/interpreter/intrinsics.d.ts

@@ -1,13 +1,13 @@
-import { ProgramError, ProgramObject } from "./objects.js";
+import { ErrorObj, Obj } 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", "Promise", "Iterator", "AsyncIterator", "Generator", "AsyncGenerator"];
+declare const builtins: readonly ["Object", "Function", "Array", "String", "Number", "Boolean", "Date", "RegExp", "Map", "Set", "URL", "URLSearchParams", "Uint8Array", "TextEncoder", "TextDecoder", "Promise", "Iterator", "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.
  */
-export type Prototypes = Readonly<Record<(typeof builtins)[number] | ErrorType, ProgramObject>>;
-export declare const createErrorValue: (prototype: ProgramObject, message: string | undefined) => ProgramError;
-export declare const createPrototypes: () => Prototypes;
+export type Builtins = Readonly<Record<(typeof builtins)[number] | ErrorType, Obj>>;
+export declare const createErrorValue: (prototype: Obj, message: string | undefined) => ErrorObj;
+export declare const createBuiltins: () => Builtins;
 export {};

package/dist/interpreter/intrinsics.js

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { define, hidden, NativeFunction, ProgramArray, ProgramError, ProgramObject } from "./objects.js";
+import { define, hidden, Native, Arr, ErrorObj, Obj } from "./objects.js";
 export const errorTypes = [
     "Error",
     "TypeError",
@@ -24,6 +24,9 @@ const builtins = [
     "Set",
     "URL",
     "URLSearchParams",
+    "Uint8Array",
+    "TextEncoder",
+    "TextDecoder",
     "Promise",
     "Iterator",
     "AsyncIterator",
@@ -31,21 +34,21 @@ const builtins = [
     "AsyncGenerator",
 ];
 export const createErrorValue = (prototype, message) => {
-    const value = new ProgramError(prototype);
+    const value = new ErrorObj(prototype);
     if (message !== undefined)
         define(value, "message", message, hidden);
     return value;
 };
-export const createPrototypes = () => {
-    const object = new ProgramObject(null);
+export const createBuiltins = () => {
+    const object = new Obj(null);
     // Function.prototype is itself callable and returns undefined.
-    const fn = new NativeFunction(object, { name: "", call: () => Effect.undefined });
-    const plain = () => new ProgramObject(object);
+    const fn = new Native(object, { name: "", call: () => Effect.undefined });
+    const plain = () => new Obj(object);
     const error = plain();
     define(error, "name", "Error", hidden);
     define(error, "message", "", hidden);
     const derived = (type) => {
-        const proto = new ProgramObject(error);
+        const proto = new Obj(error);
         define(proto, "name", type, hidden);
         define(proto, "message", "", hidden);
         return proto;
@@ -55,7 +58,7 @@ export const createPrototypes = () => {
     return {
         Object: object,
         Function: fn,
-        Array: new ProgramArray(object),
+        Array: new Arr(object),
         String: plain(),
         Number: plain(),
         Boolean: plain(),
@@ -65,11 +68,14 @@ export const createPrototypes = () => {
         Set: plain(),
         URL: plain(),
         URLSearchParams: plain(),
+        Uint8Array: plain(),
+        TextEncoder: plain(),
+        TextDecoder: plain(),
         Promise: plain(),
         Iterator: iterator,
         AsyncIterator: asyncIterator,
-        Generator: new ProgramObject(iterator),
-        AsyncGenerator: new ProgramObject(asyncIterator),
+        Generator: new Obj(iterator),
+        AsyncGenerator: new Obj(asyncIterator),
         Error: error,
         TypeError: derived("TypeError"),
         RangeError: derived("RangeError"),

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 { ProgramError } from "./objects.js";
+import type { ErrorObj } 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. */
@@ -31,7 +31,7 @@ export type GeneratorRequestKind = "next" | "return" | "throw";
 export declare const AsyncIteratorSymbol: unique symbol;
 export declare const IteratorSymbol: unique symbol;
 export declare const IteratorSymbols: readonly [typeof AsyncIteratorSymbol, typeof IteratorSymbol];
-export declare class ProgramThrow {
+export declare class Throw {
     readonly value: unknown;
     constructor(value: unknown);
 }
@@ -51,7 +51,7 @@ export declare class PendingThrow {
     readonly kind: DiagnosticKind;
     readonly suggestions?: ReadonlyArray<string> | undefined;
     node?: AstNode;
-    value?: ProgramError;
+    value?: ErrorObj;
     constructor(
     /** The JS error class a program sees when it catches this failure. */
     type: ErrorType, message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);

package/dist/interpreter/model.js

@@ -6,7 +6,7 @@ export const CallSite = Context.Reference("codemode/CallSite", {
 export const AsyncIteratorSymbol = Symbol("codemode.async-iterator");
 export const IteratorSymbol = Symbol("codemode.iterator");
 export const IteratorSymbols = [AsyncIteratorSymbol, IteratorSymbol];
-export class ProgramThrow {
+export class Throw {
     value;
     constructor(value) {
         this.value = value;

package/dist/interpreter/native.d.ts

@@ -1,18 +1,18 @@
 import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
-import { type Callable, NativeFunction, type NativeOptions, ProgramObject } from "./objects.js";
+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;
-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 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: (protos: Prototypes, target: ProgramObject, table: ReadonlyArray<Method>) => void;
-export declare const constants: (target: ProgramObject, table: Record<string, unknown>) => void;
+export declare const methods: (builtins: Builtins, target: Obj, table: ReadonlyArray<Method>) => void;
+export declare const constants: (target: Obj, 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>;
+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`. */
 export declare const requiresNew: (name: string) => () => 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;
+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 ProgramObject>(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: unknown, method: string) => T;

package/dist/interpreter/native.js

@@ -1,25 +1,25 @@
 import { Effect } from "effect";
 import { typeError } from "./model.js";
-import { define, frozen, hidden, NativeFunction, ProgramObject } from "./objects.js";
+import { define, frozen, hidden, Native, Obj } from "./objects.js";
 import { describeValue } from "./references.js";
-// The dispatch in `Frame.invokeCallable` suspends every native call, so a synchronous throw here is a defect.
+// The dispatch in `Frame.call` suspends every native call, so a synchronous throw here is a defect.
 const lift = (impl) => (thisValue, args) => {
     const result = impl(thisValue, args);
     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) => {
+export const native = (builtins, options) => new Native(builtins.Function, options);
+export const fn = (builtins, name, length, impl) => native(builtins, { name, length, call: lift(impl) });
+export const methods = (builtins, target, table) => {
     for (const [name, length, impl] of table)
-        define(target, name, fn(protos, name, length, impl), hidden);
+        define(target, name, fn(builtins, 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);
+export const constructor = (builtins, proto, options) => {
+    const ctor = native(builtins, options);
     define(ctor, "prototype", proto, frozen);
     define(proto, "constructor", ctor, hidden);
     return ctor;
@@ -31,7 +31,7 @@ export const requiresNew = (name) => () => Effect.sync(() => {
 /** 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;
+    return proto !== undefined && "value" in proto && proto.value instanceof Obj ? 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) => {

package/dist/interpreter/objects.d.ts

@@ -30,30 +30,30 @@ 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;
+export declare class Obj {
+    proto: Obj | null;
     readonly props: Map<string | symbol, Slot>;
-    constructor(proto: ProgramObject | null);
+    constructor(proto: Obj | null);
 }
-export declare class ProgramArray extends ProgramObject {
+export declare class Arr extends Obj {
     readonly items: Array<unknown>;
-    constructor(proto: ProgramObject, items?: Array<unknown>);
+    constructor(proto: Obj, 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 ErrorObj extends Obj {
     /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
     host?: PendingThrow;
 }
-export declare abstract class Callable extends ProgramObject {
-    constructor(proto: ProgramObject, name: string, length: number);
+export declare abstract class Callable extends Obj {
+    constructor(proto: Obj, name: string, length: number);
 }
-export declare class ProgramFunction extends Callable {
+export declare class Fn extends Callable {
     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);
+    constructor(proto: Obj, 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>) => Effect.Effect<unknown, unknown, R>;
 export type NativeConstruct<R> = (args: Array<unknown>, newTarget: Callable) => Effect.Effect<unknown, unknown, R>;
@@ -66,72 +66,77 @@ export type NativeOptions<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 {
+export declare class Native<R = never> extends Callable {
     readonly call: NativeCall<R>;
     readonly construct: NativeConstruct<R> | undefined;
     readonly callback: boolean;
-    constructor(proto: ProgramObject, options: NativeOptions<R>);
+    constructor(proto: Obj, options: NativeOptions<R>);
 }
-export declare class ProgramPromise extends ProgramObject {
+export declare class PromiseObj extends Obj {
     readonly fiber: Fiber.Fiber<unknown, unknown>;
-    constructor(proto: ProgramObject, fiber: Fiber.Fiber<unknown, unknown>);
+    constructor(proto: Obj, fiber: Fiber.Fiber<unknown, unknown>);
 }
-export declare class ProgramGenerator extends ProgramObject {
+export declare class GeneratorObj extends Obj {
     readonly asynchronous: boolean;
     readonly request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>;
-    constructor(proto: ProgramObject, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>);
+    constructor(proto: Obj, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown) => Effect.Effect<unknown, unknown, unknown>);
 }
-export declare class ProgramDate extends ProgramObject {
+export declare class DateObj extends Obj {
     time: number;
-    constructor(proto: ProgramObject, time: number);
+    constructor(proto: Obj, time: number);
 }
-export declare class ProgramRegExp extends ProgramObject {
+export declare class RegExpObj extends Obj {
     readonly regex: RegExp;
-    constructor(proto: ProgramObject, pattern: string, flags: string);
+    constructor(proto: Obj, pattern: string, flags: string);
 }
-export declare class ProgramMap extends ProgramObject {
+export declare class MapObj extends Obj {
     readonly map: Map<unknown, unknown>;
 }
-export declare class ProgramSet extends ProgramObject {
+export declare class SetObj extends Obj {
     readonly set: Set<unknown>;
 }
-export declare class ProgramURLSearchParams extends ProgramObject {
+export declare class URLSearchParamsObj extends Obj {
     readonly params: URLSearchParams;
-    constructor(proto: ProgramObject, params: URLSearchParams);
+    constructor(proto: Obj, params: URLSearchParams);
 }
-export declare class ProgramURL extends ProgramObject {
+export declare class URLObj extends Obj {
     readonly url: URL;
-    readonly searchParams: ProgramURLSearchParams;
-    constructor(proto: ProgramObject, searchParamsProto: ProgramObject, url: URL);
+    readonly searchParams: URLSearchParamsObj;
+    constructor(proto: Obj, searchParamsProto: Obj, url: URL);
+}
+/** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
+export declare class Bytes extends Obj {
+    readonly bytes: Uint8Array;
+    constructor(proto: Obj, bytes: Uint8Array);
 }
 /** An instance of an extension class: the host object lives in a field no property path reaches. */
-export declare class ProgramHandle extends ProgramObject {
+export declare class Handle extends Obj {
     readonly instance: object;
-    constructor(proto: ProgramObject, instance: object);
+    constructor(proto: Obj, instance: object);
 }
 /** 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 isWrapper: (value: unknown) => value is DateObj | RegExpObj | MapObj | SetObj | URLObj | URLSearchParamsObj | Bytes;
 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 own: (target: Obj, key: PropertyKey) => Slot | undefined;
+export declare const hasOwn: (target: Obj, key: PropertyKey) => boolean;
+export declare const getOwn: (target: Obj, 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 has: (target: ProgramObject, key: PropertyKey) => boolean;
-export declare const hasPrototype: (value: unknown, proto: ProgramObject) => boolean;
+export declare const get: (target: Obj, key: PropertyKey, receiver?: unknown) => unknown;
+export declare const has: (target: Obj, key: PropertyKey) => boolean;
+export declare const hasPrototype: (value: unknown, proto: Obj) => 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;
+export declare const set: (target: Obj, 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 | undefined, set?: Setter) => void;
-export declare const remove: (target: ProgramObject, key: PropertyKey) => boolean;
-export declare const ownKeys: (target: ProgramObject) => Array<string | symbol>;
+export declare const define: (target: Obj, key: PropertyKey, value: unknown, attrs?: Attributes) => void;
+export declare const defineAccessor: (target: Obj, key: PropertyKey, get: Getter | undefined, set?: Setter) => void;
+export declare const remove: (target: Obj, key: PropertyKey) => boolean;
+export declare const ownKeys: (target: Obj) => 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>;
+export declare const enumerableKeys: (target: Obj) => Array<string | symbol>;
 /** Own enumerable string keys: `Object.keys`. */
-export declare const keys: (target: ProgramObject) => Array<string>;
+export declare const keys: (target: Obj) => 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;
+export declare const entries: (target: Obj) => Array<[string, unknown]>;
+export declare const record: (proto: Obj, fields: Record<string, unknown>) => Obj;
+export declare const assign: (target: Obj, source: Obj, skip?: ReadonlySet<PropertyKey>) => void;

package/dist/interpreter/objects.js

@@ -9,14 +9,14 @@ 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 {
+export class Obj {
     proto;
     props = new Map();
     constructor(proto) {
         this.proto = proto;
     }
 }
-export class ProgramArray extends ProgramObject {
+export class Arr extends Obj {
     items;
     constructor(proto, items = []) {
         super(proto);
@@ -24,18 +24,18 @@ export class ProgramArray extends ProgramObject {
     }
 }
 /** 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 ErrorObj extends Obj {
     /** The interpreter failure this error materialized from, so rethrowing it keeps the diagnostic kind and location. */
     host;
 }
-export class Callable extends ProgramObject {
+export class Callable extends Obj {
     constructor(proto, name, length) {
         super(proto);
         define(this, "length", length, readonly);
         define(this, "name", name, readonly);
     }
 }
-export class ProgramFunction extends Callable {
+export class Fn extends Callable {
     parameters;
     body;
     capturedScopes;
@@ -51,7 +51,7 @@ export class ProgramFunction extends Callable {
         this.generator = generator;
     }
 }
-export class NativeFunction extends Callable {
+export class Native extends Callable {
     call;
     construct;
     callback;
@@ -62,14 +62,14 @@ export class NativeFunction extends Callable {
         this.callback = options.callback ?? true;
     }
 }
-export class ProgramPromise extends ProgramObject {
+export class PromiseObj extends Obj {
     fiber;
     constructor(proto, fiber) {
         super(proto);
         this.fiber = fiber;
     }
 }
-export class ProgramGenerator extends ProgramObject {
+export class GeneratorObj extends Obj {
     asynchronous;
     request;
     constructor(proto, asynchronous, request) {
@@ -78,14 +78,14 @@ export class ProgramGenerator extends ProgramObject {
         this.request = request;
     }
 }
-export class ProgramDate extends ProgramObject {
+export class DateObj extends Obj {
     time;
     constructor(proto, time) {
         super(proto);
         this.time = time;
     }
 }
-export class ProgramRegExp extends ProgramObject {
+export class RegExpObj extends Obj {
     regex;
     constructor(proto, pattern, flags) {
         super(proto);
@@ -93,30 +93,38 @@ export class ProgramRegExp extends ProgramObject {
         define(this, "lastIndex", 0, { writable: true, enumerable: false, configurable: false });
     }
 }
-export class ProgramMap extends ProgramObject {
+export class MapObj extends Obj {
     map = new Map();
 }
-export class ProgramSet extends ProgramObject {
+export class SetObj extends Obj {
     set = new Set();
 }
-export class ProgramURLSearchParams extends ProgramObject {
+export class URLSearchParamsObj extends Obj {
     params;
     constructor(proto, params) {
         super(proto);
         this.params = params;
     }
 }
-export class ProgramURL extends ProgramObject {
+export class URLObj extends Obj {
     url;
     searchParams;
     constructor(proto, searchParamsProto, url) {
         super(proto);
         this.url = url;
-        this.searchParams = new ProgramURLSearchParams(searchParamsProto, url.searchParams);
+        this.searchParams = new URLSearchParamsObj(searchParamsProto, url.searchParams);
+    }
+}
+/** A `Uint8Array`: the host array does the byte clamping and ignores out-of-range writes, as JS does. */
+export class Bytes extends Obj {
+    bytes;
+    constructor(proto, bytes) {
+        super(proto);
+        this.bytes = bytes;
     }
 }
 /** An instance of an extension class: the host object lives in a field no property path reaches. */
-export class ProgramHandle extends ProgramObject {
+export class Handle extends Obj {
     instance;
     constructor(proto, instance) {
         super(proto);
@@ -124,12 +132,13 @@ export class ProgramHandle extends ProgramObject {
     }
 }
 /** 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;
+export const isWrapper = (value) => value instanceof DateObj ||
+    value instanceof RegExpObj ||
+    value instanceof MapObj ||
+    value instanceof SetObj ||
+    value instanceof URLObj ||
+    value instanceof URLSearchParamsObj ||
+    value instanceof Bytes;
 const MAX_ARRAY_INDEX = 4_294_967_295;
 export const parseArrayIndex = (key) => {
     const property = String(key);
@@ -139,17 +148,21 @@ export const parseArrayIndex = (key) => {
     return index < MAX_ARRAY_INDEX ? index : undefined;
 };
 const canonical = (key) => (typeof key === "symbol" ? key : String(key));
-const index = (target, key) => target instanceof ProgramArray && typeof key === "string" ? parseArrayIndex(key) : undefined;
+const isIndexed = (target) => target instanceof Arr || target instanceof Bytes;
+const elements = (target) => (target instanceof Arr ? target.items : target.bytes);
+const index = (target, key) => isIndexed(target) && typeof key === "string" ? parseArrayIndex(key) : undefined;
 /** The own property under `key`, including an array's live indexes and `length`. */
 export const own = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
+    if (isIndexed(target)) {
         const at = index(target, name);
         if (at !== undefined) {
-            return at in target.items ? { value: target.items[at], ...data } : undefined;
+            const items = elements(target);
+            return at in items ? { value: items[at], ...data } : undefined;
         }
-        if (name === "length")
+        if (target instanceof Arr && name === "length") {
             return { value: target.items.length, writable: true, enumerable: false, configurable: false };
+        }
     }
     return target.props.get(name);
 };
@@ -176,19 +189,22 @@ export const has = (target, key) => {
     return false;
 };
 export const hasPrototype = (value, proto) => {
-    for (let current = value instanceof ProgramObject ? value.proto : null; current !== null; current = current.proto) {
+    for (let current = value instanceof Obj ? value.proto : null; current !== null; current = current.proto) {
         if (current === proto)
             return true;
     }
     return false;
 };
-const writeArray = (target, name, value) => {
+const writeElement = (target, name, value) => {
     const at = index(target, name);
     if (at !== undefined) {
-        target.items[at] = value;
+        if (target instanceof Bytes)
+            target.bytes[at] = typeof value === "number" ? value : Number(value);
+        else
+            target.items[at] = value;
         return true;
     }
-    if (name !== "length")
+    if (!(target instanceof Arr) || name !== "length")
         return undefined;
     const length = typeof value === "number" ? value : Number(value);
     if (!Number.isInteger(length) || length < 0)
@@ -214,16 +230,16 @@ export const set = (target, key, value) => {
             return false;
         if (current !== target)
             break;
-        if (target instanceof ProgramArray) {
-            const written = writeArray(target, name, value);
+        if (isIndexed(target)) {
+            const written = writeElement(target, name, value);
             if (written !== undefined)
                 return written;
         }
         slot.value = value;
         return true;
     }
-    if (target instanceof ProgramArray) {
-        const written = writeArray(target, name, value);
+    if (isIndexed(target)) {
+        const written = writeElement(target, name, value);
         if (written !== undefined)
             return written;
     }
@@ -233,7 +249,7 @@ export const set = (target, key, value) => {
 /** [[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)
+    if (isIndexed(target) && writeElement(target, name, value) !== undefined)
         return;
     target.props.set(name, { value, ...attrs });
 };
@@ -242,11 +258,11 @@ export const defineAccessor = (target, key, get, set) => {
 };
 export const remove = (target, key) => {
     const name = canonical(key);
-    if (target instanceof ProgramArray) {
+    if (isIndexed(target)) {
         const at = index(target, name);
         if (at !== undefined)
-            return delete target.items[at];
-        if (name === "length")
+            return target instanceof Bytes ? !(at in target.bytes) : delete target.items[at];
+        if (target instanceof Arr && name === "length")
             return false;
     }
     const slot = target.props.get(name);
@@ -262,7 +278,8 @@ 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"] : []),
+        ...(isIndexed(target) ? Object.keys(elements(target)) : []),
+        ...(target instanceof Arr ? ["length"] : []),
         ...strings.filter((key) => parseArrayIndex(key) !== undefined).sort((a, b) => Number(a) - Number(b)),
         ...strings.filter((key) => parseArrayIndex(key) === undefined),
         ...symbols,
@@ -276,7 +293,7 @@ export const keys = (target) => ownKeys(target).filter((key) => typeof 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);
+    const target = new Obj(proto);
     for (const [key, value] of Object.entries(fields))
         define(target, key, value);
     return target;