@opencode/codemode 2.0.2 → 2.0.4

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/limits.d.ts

@@ -0,0 +1,10 @@
+/** Longest string a built-in or operator may produce. */
+export declare const MAX_STRING_LENGTH: number;
+/** Longest array a built-in may create or grow to. */
+export declare const MAX_ARRAY_LENGTH = 10000000;
+/** Most promises that may be pending at once. */
+export declare const MAX_PENDING_PROMISES = 10000;
+/** Deepest nesting a value may have when it crosses to or from the host. */
+export declare const MAX_VALUE_DEPTH = 32;
+export declare const checkStringLength: (length: number) => void;
+export declare const checkArrayLength: (length: number) => void;

package/dist/interpreter/limits.js

@@ -0,0 +1,19 @@
+import { rangeError } from "./model.js";
+// The timeout only fires between interpreter steps, so a single built-in must not be able to materialize an
+// unbounded value. These bound what one call may build; programs cannot reach such sizes any other way.
+/** Longest string a built-in or operator may produce. */
+export const MAX_STRING_LENGTH = 1 << 24;
+/** Longest array a built-in may create or grow to. */
+export const MAX_ARRAY_LENGTH = 10_000_000;
+/** Most promises that may be pending at once. */
+export const MAX_PENDING_PROMISES = 10_000;
+/** Deepest nesting a value may have when it crosses to or from the host. */
+export const MAX_VALUE_DEPTH = 32;
+export const checkStringLength = (length) => {
+    if (length > MAX_STRING_LENGTH)
+        throw rangeError("Invalid string length");
+};
+export const checkArrayLength = (length) => {
+    if (length > MAX_ARRAY_LENGTH)
+        throw rangeError("Invalid array length");
+};

package/dist/interpreter/model.d.ts

@@ -1,8 +1,15 @@
 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";
 /** 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. */
+export declare const CallSite: Context.Reference<{
+    readonly node?: AstNode;
+    readonly depth: number;
+}>;
 export type Binding = {
     mutable: boolean;
     value: unknown;
@@ -24,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);
 }
@@ -33,24 +40,30 @@ export declare class GeneratorReturn {
     constructor(value: unknown);
 }
 export declare const OptionalShortCircuit: unique symbol;
-export declare class InterpreterRuntimeError extends Error {
-    readonly kind: DiagnosticKind;
-    readonly suggestions?: ReadonlyArray<string> | undefined;
+/**
+ * A failure raised by the interpreter or a built-in. It travels as a defect and becomes one program Error object
+ * the first time a handler observes it, so every observer of the same failure sees the same value.
+ */
+export declare class PendingThrow {
     /** 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, 
+    readonly message: string;
+    readonly kind: DiagnosticKind;
+    readonly suggestions?: ReadonlyArray<string> | undefined;
+    node?: AstNode;
+    value?: ErrorObj;
+    constructor(
     /** The JS error class a program sees when it catches this failure. */
-    type?: ErrorType);
+    type: ErrorType, message: string, node?: AstNode, kind?: DiagnosticKind, suggestions?: ReadonlyArray<string> | undefined);
 }
-/** 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;
+export declare const typeError: (message: string, node?: AstNode) => PendingThrow;
+export declare const invalidData: (message: string, node?: AstNode) => PendingThrow;
+export declare const rangeError: (message: string, node?: AstNode) => PendingThrow;
+export declare const referenceError: (message: string, node?: AstNode) => PendingThrow;
+export declare const syntaxError: (message: string, node?: AstNode) => PendingThrow;
+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) => InterpreterRuntimeError;
+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;

package/dist/interpreter/model.js

@@ -1,7 +1,12 @@
+import { Context } from "effect";
+/** The program call a built-in is running under: where to locate failures born inside it, and how deep the stack is there. */
+export const CallSite = Context.Reference("codemode/CallSite", {
+    defaultValue: () => ({ depth: 0 }),
+});
 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;
@@ -14,35 +19,38 @@ export class GeneratorReturn {
     }
 }
 export const OptionalShortCircuit = Symbol("codemode.optional-short-circuit");
-export class InterpreterRuntimeError extends Error {
+/**
+ * A failure raised by the interpreter or a built-in. It travels as a defect and becomes one program Error object
+ * the first time a handler observes it, so every observer of the same failure sees the same value.
+ */
+export class PendingThrow {
+    type;
+    message;
     kind;
     suggestions;
-    type;
     node;
-    constructor(message, node, kind = "ExecutionFailure", suggestions, 
+    value;
+    constructor(
     /** The JS error class a program sees when it catches this failure. */
-    type = "TypeError") {
-        super(message);
+    type, message, node, kind = "ExecutionFailure", suggestions) {
+        this.type = type;
+        this.message = message;
         this.kind = kind;
         this.suggestions = suggestions;
-        this.type = type;
-        this.name = "InterpreterRuntimeError";
         if (node)
             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);
+const failure = (type, kind) => (message, node) => new PendingThrow(type, message, node, kind);
+export const typeError = failure("TypeError");
+export const invalidData = failure("TypeError", "InvalidDataValue");
 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 PendingThrow("SyntaxError", `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/native.d.ts

@@ -1,19 +1,18 @@
 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>;
+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>(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) => (_: unknown, __: Array<unknown>, node: AstNode) => Effect.Effect<never, unknown, never>;
+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, node?: AstNode) => 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,40 +1,41 @@
 import { Effect } from "effect";
-import { InterpreterRuntimeError } from "./model.js";
-import { define, frozen, hidden, NativeFunction, ProgramObject } from "./objects.js";
+import { typeError } from "./model.js";
+import { define, frozen, hidden, Native, Obj } from "./objects.js";
 import { describeValue } from "./references.js";
-const lift = (impl) => (thisValue, args, node) => Effect.suspend(() => {
-    const result = impl(thisValue, args, node);
+// 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;
 };
 /** 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);
+export const requiresNew = (name) => () => Effect.sync(() => {
+    throw typeError(`Constructor ${name} requires 'new'.`);
 });
 /** 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, node) => {
+export const receiver = (cls, thisValue, method) => {
     if (thisValue instanceof cls)
         return thisValue;
-    throw new InterpreterRuntimeError(`${method} called on incompatible receiver ${describeValue(thisValue)}.`, node);
+    throw typeError(`${method} called on incompatible receiver ${describeValue(thisValue)}.`);
 };

package/dist/interpreter/objects.d.ts

@@ -1,6 +1,6 @@
 import type { BlockStatement, Expression, Pattern } from "acorn";
 import type { Effect, Fiber } from "effect";
-import { type AstNode, type Binding, type GeneratorRequestKind } from "./model.js";
+import { type Binding, type GeneratorRequestKind, type PendingThrow } from "./model.js";
 /** Property attributes, as in a JS property descriptor. */
 export type Attributes = {
     readonly writable: boolean;
@@ -30,31 +30,33 @@ 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>, 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 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>;
 export type NativeOptions<R> = {
     readonly name: string;
     readonly length?: number;
@@ -64,67 +66,72 @@ 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, node: AstNode) => Effect.Effect<unknown, unknown, unknown>;
-    constructor(proto: ProgramObject, asynchronous: boolean, request: (kind: GeneratorRequestKind, value: unknown, node: AstNode) => Effect.Effect<unknown, unknown, unknown>);
+    readonly 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);
 }
 /** 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, 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;