poe-code 14.0.6 → 14.0.8

package/packages/safe-js/dist/interp/globals/object.js

@@ -0,0 +1,153 @@
+import { assertSandboxDataDepth } from "../../graph-depth.js";
+import { isSandboxDate } from "../date.js";
+import { isSandboxErrorConstructorInstance } from "../exceptions.js";
+import { isFloat32Array } from "../float32.js";
+import { hasHostObjectMember, isGuestHostObject } from "../host-capabilities.js";
+import { getSandboxPrototype, installObjectPrototype, isGuestClosure, markDescriptorObject, materializeFunctionProperties } from "../object-model.js";
+import { sandboxString } from "../string-coercion.js";
+import { createSandboxClosure, isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "../values.js";
+export function createObjectGlobal(methods, budget) {
+    const construct = ([value]) => {
+        if (value === null || value === undefined) {
+            budget.chargeDataUsage(1);
+            return Object.create(null);
+        }
+        if (typeof value !== "object")
+            throw new TypeError("Object primitive boxing is not supported.");
+        return value;
+    };
+    const constructor = createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "Object",
+        length: 1,
+        call: construct,
+        construct
+    });
+    const properties = materializeFunctionProperties(constructor);
+    const prototype = properties.prototype;
+    Object.defineProperty(properties, "prototype", { writable: false });
+    for (const [name, method] of Object.entries(methods)) {
+        Object.defineProperty(properties, name, { value: method, writable: true, configurable: true });
+    }
+    const prototypeMethods = {
+        toString: createSandboxClosure({
+            sandbox: true,
+            name: "toString",
+            length: 0,
+            call: (_args, context) => budget.allocateString(`[object ${typeTag(context?.thisValue)}]`)
+        }),
+        valueOf: createSandboxClosure({
+            sandbox: true,
+            name: "valueOf",
+            length: 0,
+            call: (_args, context) => {
+                const value = requireReceiver(context?.thisValue);
+                if (typeof value !== "object")
+                    throw new TypeError("Object primitive boxing is not supported.");
+                return value;
+            }
+        }),
+        hasOwnProperty: createSandboxClosure({
+            sandbox: true,
+            name: "hasOwnProperty",
+            length: 1,
+            call: async ([key], context) => hasOwnSandboxProperty(requireReceiver(context?.thisValue), await sandboxString(key, budget, context), false)
+        }),
+        propertyIsEnumerable: createSandboxClosure({
+            sandbox: true,
+            name: "propertyIsEnumerable",
+            length: 1,
+            call: async ([key], context) => hasOwnSandboxProperty(requireReceiver(context?.thisValue), await sandboxString(key, budget, context), true)
+        }),
+        isPrototypeOf: createSandboxClosure({
+            sandbox: true,
+            name: "isPrototypeOf",
+            length: 1,
+            call: ([value], context) => {
+                if (typeof value !== "object" || value === null)
+                    return false;
+                const receiver = requireReceiver(context?.thisValue);
+                let depth = 0;
+                for (let current = getSandboxPrototype(value, budget); current !== null; current = getSandboxPrototype(current, budget)) {
+                    budget.visitNode();
+                    assertSandboxDataDepth(depth++);
+                    if (current === receiver)
+                        return true;
+                }
+                return false;
+            }
+        })
+    };
+    for (const [name, method] of Object.entries(prototypeMethods)) {
+        Object.defineProperty(prototype, name, { value: method, writable: true, configurable: true });
+    }
+    markDescriptorObject(prototype);
+    installObjectPrototype(budget, prototype, constructor);
+    return constructor;
+}
+function requireReceiver(value) {
+    if (value === null || value === undefined)
+        throw new TypeError("Object method requires a non-null receiver.");
+    return value;
+}
+export function hasOwnSandboxProperty(value, key, enumerable) {
+    requireReceiver(value);
+    if (isGuestHostObject(value))
+        return hasHostObjectMember(value, key, enumerable);
+    let properties;
+    if (isGuestClosure(value))
+        properties = materializeFunctionProperties(value);
+    else if (isSandboxClosure(value)) {
+        if (key === "length" || key === "name")
+            return !enumerable;
+        properties = value.properties ?? Object.create(null);
+    }
+    else if (isSandboxMap(value) ||
+        isSandboxSet(value) ||
+        isSandboxPromise(value) ||
+        isSandboxGenerator(value))
+        return false;
+    else if (isSandboxRegex(value))
+        return key === "lastIndex" && !enumerable;
+    else
+        properties = Object(value);
+    const descriptor = Object.getOwnPropertyDescriptor(properties, key);
+    return descriptor !== undefined && (!enumerable || descriptor.enumerable === true);
+}
+function typeTag(value) {
+    if (value === undefined)
+        return "Undefined";
+    if (value === null)
+        return "Null";
+    if (typeof value === "string")
+        return "String";
+    if (typeof value === "number")
+        return "Number";
+    if (typeof value === "boolean")
+        return "Boolean";
+    if (isSandboxClosure(value)) {
+        while (value.boundTarget !== undefined)
+            value = value.boundTarget;
+        return value.generator ? "GeneratorFunction" : value.async ? "AsyncFunction" : "Function";
+    }
+    if (Array.isArray(value))
+        return "Array";
+    if (isSandboxDate(value))
+        return "Date";
+    if (isSandboxErrorConstructorInstance(value, "Error"))
+        return "Error";
+    if (isSandboxRegex(value))
+        return "RegExp";
+    if (isSandboxMap(value))
+        return "Map";
+    if (isSandboxSet(value))
+        return "Set";
+    if (isSandboxPromise(value))
+        return "Promise";
+    if (isSandboxGenerator(value))
+        return "Generator";
+    if (isFloat32Array(value))
+        return "Float32Array";
+    return "Object";
+}

package/packages/safe-js/dist/interp/globals.d.ts

@@ -1,6 +1,8 @@
 import { createConsoleJsonGlobals } from "./globals/console-json.js";
+import type { RunClock } from "../run.js";
 export declare function createBuiltinBindings(options: Parameters<typeof createConsoleJsonGlobals>[0] & {
     random?: () => number;
+    clock?: RunClock;
 }): {
     RegExp: import("./values.js").SandboxClosure;
     Promise: import("./values.js").SandboxClosure;
@@ -9,7 +11,7 @@ export declare function createBuiltinBindings(options: Parameters<typeof createC
     parseFloat: import("./values.js").SandboxClosure;
     isNaN: import("./values.js").SandboxClosure;
     isFinite: import("./values.js").SandboxClosure;
-    Object: import("./values.js").SandboxObject;
+    Object: import("./values.js").SandboxClosure;
     Array: import("./values.js").SandboxClosure;
     String: import("./values.js").SandboxClosure;
     Number: import("./values.js").SandboxClosure;
@@ -24,6 +26,7 @@ export declare function createBuiltinBindings(options: Parameters<typeof createC
     SyntaxError: import("./values.js").SandboxClosure;
     AggregateError: import("./values.js").SandboxClosure;
     Float32Array: import("./values.js").SandboxClosure;
+    Date: import("./values.js").SandboxClosure;
     Map: import("./values.js").SandboxClosure;
     Set: import("./values.js").SandboxClosure;
     JSON: import("./values.js").SandboxObject;

package/packages/safe-js/dist/interp/globals.js

@@ -7,11 +7,13 @@ import { createRegexGlobals } from "./globals/regex.js";
 import { createMiscGlobals } from "./globals/misc.js";
 import { createObjectArrayGlobals } from "./globals/object-array.js";
 import { createPromiseGlobals } from "./promise.js";
+import { createDateGlobal } from "./globals/date.js";
 export function createBuiltinBindings(options) {
     return {
         ...createConsoleJsonGlobals(options),
         ...createCollectionGlobals(options),
         Float32Array: createFloat32ArrayGlobal(options.budget),
+        Date: createDateGlobal(options),
         ...createErrorGlobals(options),
         ...createMathGlobals({ random: options.random }),
         ...createObjectArrayGlobals(options),

package/packages/safe-js/dist/interp/host-bridge.d.ts

@@ -12,6 +12,10 @@ export type RealmBridge = {
     wrapCallback(closure: SandboxClosure): (...args: readonly unknown[]) => Promise<unknown>;
     invoke(operation: CallerInjectedFunction, call: () => unknown): unknown;
     awaitResult(operation: CallerInjectedFunction): boolean;
+    captureArguments(operation: CallerInjectedFunction, args: readonly SandboxValue[], copy: (values: readonly SandboxValue[]) => unknown[]): {
+        args: unknown[];
+        rollback(): void;
+    };
 };
 export type HostBridgeOptions = {
     realm?: RealmBridge;

package/packages/safe-js/dist/interp/host-bridge.js

@@ -1,4 +1,5 @@
 import { normalizeClosureResult } from "./async.js";
+import { copyNativeDate } from "./date.js";
 import { exportHostCapability, importHostCapability, isLiveCapability } from "./host-capabilities.js";
 import { attachErrorSpan, replaceErrorStack } from "../error/shape.js";
 import { SandboxError } from "./budget.js";
@@ -77,11 +78,13 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     seen: new WeakMap(),
                     restored: []
                 };
-                const hostArgs = deepCopyFromSandbox([...args], {
+                const copyArguments = (values) => deepCopyFromSandbox([...values], {
                     compilation,
                     unwrapHostObject: options.realm === undefined ? undefined : object => exportHostCapability(object, options.realm.owner),
                     wrapClosure: (closure) => options.realm?.wrapCallback(closure) ?? wrapSandboxClosureForHost(closure, stackFrames, options.budget, operationLease.owner, callbacks)
                 });
+                const captured = options.realm?.captureArguments(callable, args, copyArguments);
+                const hostArgs = captured?.args ?? copyArguments(args);
                 const hostCalls = options.hostCalls;
                 const operation = options.operation ?? bindingName;
                 const moduleId = options.moduleId ?? "<bindings>";
@@ -90,7 +93,14 @@ function wrapCallerInjectedFunction(name, value, options, state) {
                     "re-issue";
                 if (hostCalls === undefined) {
                     if (options.realm !== undefined) {
-                        const result = options.realm.invoke(callable, () => Reflect.apply(callable, undefined, hostArgs));
+                        let result;
+                        try {
+                            result = options.realm.invoke(callable, () => Reflect.apply(callable, undefined, hostArgs));
+                        }
+                        catch (error) {
+                            captured.rollback();
+                            throw error;
+                        }
                         if (options.realm.awaitResult(callable)) {
                             return Promise.resolve(result).then(value => copyHostResultToSandbox(value, stackFrames, options));
                         }
@@ -658,6 +668,15 @@ export function copyHostValueToSandbox(value, stackFrames, options, state, path)
                 : path
         }, state);
     }
+    const date = copyNativeDate(value);
+    if (date !== undefined) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        budget.chargeDataUsage(9);
+        state.seen.set(value, date);
+        return date;
+    }
     if (isFloat32Array(value)) {
         const existing = state.seen.get(value);
         if (existing !== undefined)

package/packages/safe-js/dist/interp/host-call.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { float32DataProperties, float32Storage, isFloat32Array } from "./float32.js";
+import { copyNativeDate, serializedDateTime } from "./date.js";
 import { cloneSandboxValue, createSandboxClosure, defineOwnDataProperty, isArrayIndexKey, measureSandboxData } from "./values.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import { decodeReplayData, encodeReplayData } from "../snapshot/replay-data.js";
@@ -581,6 +582,9 @@ function normalize(value, seen) {
         throw new TypeError("Host call arguments cannot contain cycles.");
     seen.add(value);
     try {
+        const date = copyNativeDate(value);
+        if (date !== undefined)
+            return Object.assign(Object.create(null), { $type: "date", time: serializedDateTime(date) });
         if (isFloat32Array(value)) {
             const storage = float32Storage(value);
             const properties = Object.create(null);

package/packages/safe-js/dist/interp/host-capabilities.d.ts

@@ -1,6 +1,8 @@
 import { type HostOperation } from "../extensions.js";
 import type { SandboxClosure, SandboxObject, SandboxValue } from "./values.js";
+import type { SandboxIterator } from "./iteration.js";
 declare const hostObjectBrand: unique symbol;
+declare const guestReferenceBrand: unique symbol;
 declare const sandboxHostObjectBrand: unique symbol;
 type SandboxHostObject = SandboxObject & {
     readonly [sandboxHostObjectBrand]: true;
@@ -8,18 +10,37 @@ type SandboxHostObject = SandboxObject & {
 export type HostObject = Readonly<Record<string, never>> & {
     readonly [hostObjectBrand]: true;
 };
+export type GuestReference = Readonly<Record<string, never>> & {
+    readonly [guestReferenceBrand]: true;
+};
+export type HostObjectIndexedDefinition = {
+    length(): number;
+    get(index: number): unknown;
+    maxLength: number;
+};
 export type HostObjectDefinition = {
+    indexed?: HostObjectIndexedDefinition;
+    named?: HostObjectNamedDefinition;
     properties?: Record<string, {
         get?: () => unknown;
         set?: (value: unknown) => void;
     }>;
     methods?: Record<string, HostOperation>;
 };
+export type HostObjectNamedDefinition = {
+    keys(): readonly string[];
+    get(name: string): unknown;
+    maxKeys: number;
+    maxKeyCodeUnits: number;
+    enumerable?: boolean;
+};
 export type HostObjectController = {
     owner: object;
     assertActive(): void;
     chargeWork(units?: number): void;
-    read(operation: () => unknown): SandboxValue;
+    checkLength(length: number): void;
+    checkTemporaryDataSize(size: number): void;
+    read(operation: () => unknown, validate?: (value: unknown) => unknown): SandboxValue;
     write(operation: (value: unknown) => void, value: SandboxValue): void;
     method(operation: HostOperation): SandboxClosure;
 };
@@ -28,6 +49,9 @@ type GuestCallbackState = {
     closure?: SandboxClosure;
     assertActive(): void;
 };
+export declare function createGuestReference(root: [SandboxValue], owner: object, assertActive: () => void): GuestReference;
+export declare function readGuestReference(reference: unknown, owner: object): SandboxValue;
+export declare function revokeGuestReference(reference: GuestReference, owner: object): void;
 export declare function createLiveHostObject(definition: HostObjectDefinition, controller: HostObjectController): HostObject;
 export declare function isGuestHostObject(value: unknown): value is SandboxHostObject;
 export declare function isLiveCapability(value: unknown): boolean;
@@ -40,4 +64,7 @@ export declare function revokeHostObject(value: HostObject, owner: object): void
 export declare function getHostObjectMember(value: SandboxObject, key: string): SandboxValue;
 export declare function setHostObjectMember(value: SandboxObject, key: string, entry: SandboxValue): void;
 export declare function getHostObjectKeys(value: SandboxObject): string[];
+export declare function hasHostObjectMember(value: SandboxObject, key: string, enumerableOnly?: boolean): boolean;
+export declare function measureHostObjectData(value: SandboxObject): number;
+export declare function getHostObjectIterator(value: SandboxObject): SandboxIterator | undefined;
 export {};

package/packages/safe-js/dist/interp/host-capabilities.js

@@ -1,11 +1,83 @@
 import { readDataRecord } from "../extensions.js";
+import { types } from "node:util";
+const MAX_INDEXED_LENGTH = 65_536;
+const MAX_NAMED_KEYS = 65_536;
+const MAX_NAMED_KEY_CODE_UNITS = 1_048_576;
 const hostObjects = new WeakMap();
 const guestObjects = new WeakMap();
 const guestCallbacks = new WeakMap();
+const guestReferences = new WeakMap();
+export function createGuestReference(root, owner, assertActive) {
+    const reference = Object.freeze(Object.create(null));
+    guestReferences.set(reference, { root, owner, assertActive });
+    return reference;
+}
+export function readGuestReference(reference, owner) {
+    const state = typeof reference === "object" && reference !== null
+        ? guestReferences.get(reference)
+        : undefined;
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign or invalid guest reference.");
+    state.assertActive();
+    if (state.root === undefined)
+        throw new TypeError("Guest reference is revoked.");
+    return state.root[0];
+}
+export function revokeGuestReference(reference, owner) {
+    const state = guestReferences.get(reference);
+    if (state === undefined || state.owner !== owner)
+        throw new TypeError("Foreign guest reference.");
+    state.root = undefined;
+}
 export function createLiveHostObject(definition, controller) {
     const input = readDataRecord(definition, "Host object definition");
-    if (Object.keys(input).some((key) => key !== "properties" && key !== "methods"))
+    if (Object.keys(input).some((key) => !["properties", "methods", "indexed", "named"].includes(key)))
         throw new TypeError("Unknown host object definition field.");
+    let indexed;
+    if (input.indexed !== undefined) {
+        const data = readDataRecord(input.indexed, "Indexed host capability");
+        if (Object.keys(data).some((key) => !["length", "get", "maxLength"].includes(key)))
+            throw new TypeError("Unknown indexed host capability field.");
+        if (typeof data.length !== "function" || typeof data.get !== "function")
+            throw new TypeError("Indexed length and get must be synchronous functions.");
+        if (typeof data.maxLength !== "number" ||
+            !Number.isInteger(data.maxLength) ||
+            data.maxLength < 1 ||
+            data.maxLength > MAX_INDEXED_LENGTH)
+            throw new RangeError(`Indexed maxLength must be an integer from 1 to ${MAX_INDEXED_LENGTH}.`);
+        indexed = {
+            length: data.length,
+            get: data.get,
+            maxLength: data.maxLength
+        };
+    }
+    let named;
+    if (input.named !== undefined) {
+        const data = readDataRecord(input.named, "Named host capability");
+        if (Object.keys(data).some((key) => !["keys", "get", "maxKeys", "maxKeyCodeUnits", "enumerable"].includes(key)))
+            throw new TypeError("Unknown named host capability field.");
+        if (typeof data.keys !== "function" || typeof data.get !== "function")
+            throw new TypeError("Named keys and get must be synchronous functions.");
+        if (typeof data.maxKeys !== "number" ||
+            !Number.isInteger(data.maxKeys) ||
+            data.maxKeys < 1 ||
+            data.maxKeys > MAX_NAMED_KEYS)
+            throw new RangeError(`Named maxKeys must be an integer from 1 to ${MAX_NAMED_KEYS}.`);
+        if (typeof data.maxKeyCodeUnits !== "number" ||
+            !Number.isInteger(data.maxKeyCodeUnits) ||
+            data.maxKeyCodeUnits < 1 ||
+            data.maxKeyCodeUnits > MAX_NAMED_KEY_CODE_UNITS)
+            throw new RangeError(`Named maxKeyCodeUnits must be an integer from 1 to ${MAX_NAMED_KEY_CODE_UNITS}.`);
+        if (data.enumerable !== undefined && typeof data.enumerable !== "boolean")
+            throw new TypeError("Named enumerable must be a boolean.");
+        named = {
+            keys: data.keys,
+            get: data.get,
+            maxKeys: data.maxKeys,
+            maxKeyCodeUnits: data.maxKeyCodeUnits,
+            enumerable: data.enumerable
+        };
+    }
     const properties = new Map();
     for (const [name, inputProperty] of Object.entries(readDataRecord(input.properties ?? {}, "Host properties"))) {
         const property = readDataRecord(inputProperty, `Host property '${name}'`);
@@ -26,6 +98,8 @@ export function createLiveHostObject(definition, controller) {
     for (const name of [...properties.keys(), ...Object.keys(operations)]) {
         if (["constructor", "prototype", "__proto__"].includes(name))
             throw new TypeError(`Reserved host member '${name}'.`);
+        if (indexed !== undefined && (name === "length" || canonicalIndex(name) !== undefined))
+            throw new TypeError(`Conflicting indexed host member '${name}'.`);
     }
     controller.assertActive();
     controller.chargeWork(properties.size + Object.keys(operations).length + 1);
@@ -35,7 +109,7 @@ export function createLiveHostObject(definition, controller) {
         name,
         controller.method(operation)
     ]));
-    const state = { host, guest, controller, properties, methods };
+    const state = { host, guest, controller, properties, methods, indexed, named };
     hostObjects.set(host, state);
     guestObjects.set(guest, state);
     return host;
@@ -45,9 +119,14 @@ export function isGuestHostObject(value) {
 }
 export function isLiveCapability(value) {
     return (((typeof value === "object" && value !== null) || typeof value === "function") &&
-        (hostObjects.has(value) || guestObjects.has(value) || guestCallbacks.has(value)));
+        (hostObjects.has(value) ||
+            guestObjects.has(value) ||
+            guestCallbacks.has(value) ||
+            guestReferences.has(value)));
 }
 export function importHostCapability(value, owner) {
+    if (guestReferences.has(value))
+        return readGuestReference(value, owner);
     const object = hostObjects.get(value);
     if (object !== undefined) {
         if (object.controller.owner !== owner)
@@ -97,15 +176,32 @@ export function revokeHostObject(value, owner) {
         throw new TypeError("Foreign host object.");
     state.properties.clear();
     state.methods.clear();
+    state.indexed = undefined;
+    state.named = undefined;
 }
 export function getHostObjectMember(value, key) {
     const state = guestObjects.get(value);
     state.controller.assertActive();
     state.controller.chargeWork();
+    if (state.indexed !== undefined) {
+        if (key === "length")
+            return indexedLength(state);
+        const index = canonicalIndex(key);
+        if (index !== undefined) {
+            if (index >= state.indexed.maxLength || index >= indexedLength(state))
+                return undefined;
+            return state.controller.read(() => state.indexed.get(index));
+        }
+    }
     const property = state.properties.get(key);
     if (property !== undefined)
         return property.get === undefined ? undefined : state.controller.read(property.get);
-    return state.methods.get(key);
+    const method = state.methods.get(key);
+    if (method !== undefined)
+        return method;
+    if (state.named !== undefined && namedKeys(state).includes(key))
+        return state.controller.read(() => state.named.get(key));
+    return undefined;
 }
 export function setHostObjectMember(value, key, entry) {
     const state = guestObjects.get(value);
@@ -119,5 +215,124 @@ export function setHostObjectMember(value, key, entry) {
 export function getHostObjectKeys(value) {
     const state = guestObjects.get(value);
     state.controller.assertActive();
-    return [...state.properties.keys(), ...state.methods.keys()];
+    const length = state.indexed === undefined ? 0 : indexedLength(state);
+    const names = state.named === undefined || state.named.enumerable === false
+        ? []
+        : namedKeys(state).filter((key) => !state.properties.has(key) &&
+            !state.methods.has(key) &&
+            !(state.indexed !== undefined &&
+                (key === "length" || canonicalIndex(key) !== undefined)));
+    const size = length + state.properties.size + state.methods.size + names.length;
+    state.controller.checkLength(size);
+    state.controller.chargeWork(size + 1);
+    return [
+        ...Array.from({ length }, (_entry, index) => String(index)),
+        ...state.properties.keys(),
+        ...state.methods.keys(),
+        ...names
+    ];
+}
+export function hasHostObjectMember(value, key, enumerableOnly = false) {
+    const state = guestObjects.get(value);
+    state.controller.assertActive();
+    state.controller.chargeWork();
+    if (state.indexed !== undefined) {
+        if (key === "length")
+            return !enumerableOnly;
+        const index = canonicalIndex(key);
+        if (index !== undefined)
+            return index < state.indexed.maxLength && index < indexedLength(state);
+    }
+    if (state.properties.has(key) || state.methods.has(key))
+        return true;
+    return (state.named !== undefined &&
+        !(enumerableOnly && state.named.enumerable === false) &&
+        namedKeys(state).includes(key));
+}
+export function measureHostObjectData(value) {
+    const state = guestObjects.get(value);
+    let size = state.indexed === undefined ? 0 : 16;
+    if (state.named !== undefined)
+        size += 24;
+    for (const key of state.properties.keys())
+        size += key.length + 1;
+    for (const key of state.methods.keys())
+        size += key.length + 1;
+    return size;
+}
+export function getHostObjectIterator(value) {
+    const state = guestObjects.get(value);
+    state.controller.assertActive();
+    if (state.indexed === undefined)
+        return undefined;
+    let index = 0;
+    let exhausted = false;
+    return {
+        next: () => {
+            state.controller.assertActive();
+            state.controller.chargeWork();
+            if (exhausted)
+                return { done: true, value: undefined };
+            if (index >= indexedLength(state)) {
+                exhausted = true;
+                return { done: true, value: undefined };
+            }
+            const position = index++;
+            return { done: false, value: state.controller.read(() => state.indexed.get(position)) };
+        }
+    };
+}
+function indexedLength(state) {
+    state.controller.chargeWork();
+    const length = state.controller.read(state.indexed.length);
+    if (typeof length !== "number" ||
+        !Number.isInteger(length) ||
+        length < 0 ||
+        length > state.indexed.maxLength)
+        throw new RangeError("Indexed length must be a non-negative integer within maxLength.");
+    state.controller.checkLength(length);
+    return length;
+}
+function canonicalIndex(key) {
+    const index = Number(key);
+    return Number.isInteger(index) && index >= 0 && index < 0xffffffff && String(index) === key
+        ? index
+        : undefined;
+}
+function namedKeys(state) {
+    const named = state.named;
+    return state.controller.read(named.keys, (value) => {
+        if (!Array.isArray(value) || types.isProxy(value))
+            throw new TypeError("Named keys must be a dense own-data array of strings, not a proxy.");
+        const length = Object.getOwnPropertyDescriptor(value, "length").value;
+        if (length > named.maxKeys)
+            throw new RangeError("Named keys exceed maxKeys.");
+        state.controller.checkLength(length);
+        state.controller.chargeWork(length + 1);
+        if (Reflect.ownKeys(value).length !== length + 1)
+            throw new TypeError("Named keys must contain only dense own-data indices and length.");
+        const result = [];
+        const seen = new Set();
+        let units = 0;
+        for (let index = 0; index < length; index++) {
+            const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+            if (descriptor === undefined ||
+                !("value" in descriptor) ||
+                typeof descriptor.value !== "string")
+                throw new TypeError("Named keys require dense own string data, not accessors or sparse arrays.");
+            const key = descriptor.value;
+            units += key.length;
+            if (units > named.maxKeyCodeUnits)
+                throw new RangeError("Named keys exceed maximum UTF-16 code units.");
+            state.controller.chargeWork(key.length);
+            if (seen.has(key))
+                throw new TypeError("Named keys must be distinct.");
+            if (["constructor", "prototype", "__proto__"].includes(key))
+                throw new TypeError(`Reserved named host member '${key}'.`);
+            seen.add(key);
+            result.push(key);
+        }
+        state.controller.checkTemporaryDataSize(1 + length + units);
+        return result;
+    });
 }