circuitjson-toolkit 1.4.2 → 1.4.3

package/docs/api.md

@@ -85,11 +85,12 @@ make the common shape smaller.
 
 Validated source documents own selected extension values as one deeply
 immutable, descriptor-safe snapshot. This uses a distinct 128 MiB payload and
-4,000,000-item ceiling so large native renderer graphs do not inherit the
+8,000,000-item ceiling so large native renderer graphs do not inherit the
 compact metadata limit. The shared worker protocol applies the same ownership
 boundary after structured cloning. Canonical standalone documents retain a
-250 MB byte ceiling; exact multi-document projects use a 256 MiB aggregate
-ceiling with independent 250 MB document and project-metadata limits. Binary
+10,000,000-value and 250 MB byte ceiling; exact multi-document projects use a
+16,000,000-value and 256 MiB aggregate ceiling with independent 250 MB document
+and project-metadata limits. Binary
 values preserve their `ArrayBuffer`/typed-view shape behind defensive copy
 access, so payload bytes do not inflate into one JavaScript number per byte.
 
@@ -318,6 +319,15 @@ The parser subpath additionally exports `ParserWorkerClient`,
 `ToolkitWorkerProtocol`, and the `TOOLKIT_WORKER_PROTOCOL` version constant for
 hosts that own a custom worker lifecycle.
 
+`ParserWorkerClient.fromWorkerUrl(url)` creates a lazy module-worker client
+that privately owns its native worker and received result graphs. Native
+message provenance avoids repeated binary brand probing on ordinary records;
+all result shape, model, depth, count, and byte limits still apply. Shared and
+resizable buffers remain isolated. `new ParserWorkerClient({ createWorker })`
+continues to fully inspect custom-worker results, including genuine events
+whose payloads an earlier listener may have changed. Replacing the host Worker
+constructor also retains that defensive path.
+
 ### `ToolkitAsset.measure(asset)`
 
 Returns the exact resident payload byte length without copying. Binary lengths
@@ -711,3 +721,9 @@ circuitjson-toolkit/testing
 circuitjson-toolkit/workers/parser.worker.mjs
 circuitjson-toolkit/styles/renderers.css
 ```
+
+Worker payload preparation uses captured array/view brand checks before raw
+buffer probes. Short strings are counted directly in UTF-8, including surrogate
+pairs and replacement characters, without allocating encoded byte buffers.
+Cross-realm buffers, changed prototypes, and bounded binary ownership retain
+the same validation rules.

package/docs/model-format.md

@@ -102,12 +102,12 @@ must not duplicate the CircuitJSON model or keep a renamed renderer model.
 Default parsing excludes raw/base64/full-payload graphs.
 
 When a caller explicitly selects a native extension, the toolkit captures and
-freezes that graph once under a distinct ceiling of 4,000,000 structured items
+freezes that graph once under a distinct ceiling of 8,000,000 structured items
 and 128 MiB of string or binary content. The ceiling is shared across the
 selected namespace and applies equally after worker transfer. Canonical
-standalone documents allow the extension plus envelope overhead within five
-million result values and 250 MB. Exact project envelopes allow eight million
-aggregate values and 256 MiB, while each document stays within five million
+standalone documents allow the extension plus envelope overhead within ten
+million result values and 250 MB. Exact project envelopes allow sixteen million
+aggregate values and 256 MiB, while each document stays within ten million
 values and 250 MB and non-document project metadata stays within two million
 values and 250 MB. Reused graphs are charged independently to each local scope,
 and repeated accounting work is itself bounded by the aggregate project

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitjson-toolkit",
-    "version": "1.4.2",
+    "version": "1.4.3",
     "description": "Canonical CircuitJSON parsing, project, rendering, query, manufacturing, simulation, and scene contracts",
     "keywords": [
         "circuitjson",

package/src/core/SelfAdjustingComputation.mjs

@@ -17,15 +17,9 @@ export class SelfAdjustingComputation {
     /** @type {Set<string> | null} */
     #affectedComputations
 
-    /** @type {(value: object, path: PropertyKey[]) => boolean} */
+    /** @type {((value: object, path: PropertyKey[]) => boolean) | null} */
     #isAtomic
 
-    /** @type {Map<symbol, number>} */
-    #symbolIds
-
-    /** @type {number} */
-    #nextSymbolId
-
     /**
      * @param {{ isAtomic?: (value: object, path: PropertyKey[]) => boolean }} [options] Dependency-tracking options.
      */
@@ -36,11 +30,7 @@ export class SelfAdjustingComputation {
         this.#propagationInput = null
         this.#affectedComputations = null
         this.#isAtomic =
-            typeof options.isAtomic === 'function'
-                ? options.isAtomic
-                : () => false
-        this.#symbolIds = new Map()
-        this.#nextSymbolId = 1
+            typeof options.isAtomic === 'function' ? options.isAtomic : null
     }
 
     /**
@@ -264,16 +254,14 @@ export class SelfAdjustingComputation {
      * @returns {{ dependencies: object[], value: any }} Successful trace.
      */
     #trace(input, computation) {
-        const dependencies = new Map()
+        const dependencies = []
         const proxyCache = new WeakMap()
         const proxyMetadata = new WeakMap()
-        const trackedInput = this.#createProxy({
-            target: input,
-            path: [],
-            dependencies,
-            proxyCache,
-            proxyMetadata
-        })
+        const trackedInput = this.#createProxy(
+            { dependencies, proxyCache, proxyMetadata },
+            input,
+            { path: [], children: null, observations: null }
+        )
         const trackedValue = computation(trackedInput)
         if (SelfAdjustingComputation.#isPromiseLike(trackedValue)) {
             throw new TypeError(
@@ -287,39 +275,44 @@ export class SelfAdjustingComputation {
                 ? proxyMetadata.get(trackedValue)
                 : null
         if (metadata) {
-            this.#record(dependencies, {
-                type: 'value',
-                path: metadata.path,
-                expected: metadata.target
-            })
+            this.#record(
+                dependencies,
+                metadata.pathNode,
+                'value',
+                metadata.target
+            )
         }
 
         return {
-            dependencies: [...dependencies.values()],
+            // Later reads of a returned container must not rewrite this trace.
+            dependencies: dependencies.map((dependency) => ({ ...dependency })),
             value: metadata?.target ?? trackedValue
         }
     }
 
     /**
      * Creates a read-tracking proxy for one traversable input container.
-     * @param {{ target: object, path: PropertyKey[], dependencies: Map<string, object>, proxyCache: WeakMap<object, Map<string, object>>, proxyMetadata: WeakMap<object, { target: object, path: PropertyKey[] }> }} context Tracking context.
+     * @param {{ dependencies: object[], proxyCache: WeakMap<object, Map<object, object>>, proxyMetadata: WeakMap<object, { target: object, pathNode: object }> }} context Shared trace context.
+     * @param {object} target Traversable raw input container.
+     * @param {object} pathNode Interned input path in this trace.
      * @returns {object} Read-tracking proxy.
      */
-    #createProxy(context) {
-        const pathKey = this.#pathKey(context.path)
-        const cachedByPath = context.proxyCache.get(context.target)
-        if (cachedByPath?.has(pathKey)) {
-            return cachedByPath.get(pathKey)
+    #createProxy(context, target, pathNode) {
+        const cachedByPath = context.proxyCache.get(target)
+        const cached = cachedByPath?.get(pathNode)
+        if (cached) {
+            return cached
         }
 
-        const proxy = new Proxy(context.target, {
+        const proxyContext = { ...context, pathNode }
+        const proxy = new Proxy(target, {
             get: (target, property) =>
-                this.#readProperty(context, target, property),
+                this.#readProperty(proxyContext, target, property),
             has: (target, property) =>
-                this.#readPresence(context, target, property),
-            ownKeys: (target) => this.#readKeys(context, target),
+                this.#readPresence(proxyContext, target, property),
+            ownKeys: (target) => this.#readKeys(proxyContext, target),
             getOwnPropertyDescriptor: (target, property) =>
-                this.#readDescriptor(context, target, property),
+                this.#readDescriptor(proxyContext, target, property),
             set: () => this.#rejectWrite(),
             defineProperty: () => this.#rejectWrite(),
             deleteProperty: () => this.#rejectWrite(),
@@ -327,13 +320,13 @@ export class SelfAdjustingComputation {
             preventExtensions: () => this.#rejectWrite()
         })
         const nextCachedByPath = cachedByPath || new Map()
-        nextCachedByPath.set(pathKey, proxy)
+        nextCachedByPath.set(pathNode, proxy)
         if (!cachedByPath) {
-            context.proxyCache.set(context.target, nextCachedByPath)
+            context.proxyCache.set(target, nextCachedByPath)
         }
         context.proxyMetadata.set(proxy, {
-            target: context.target,
-            path: [...context.path]
+            target,
+            pathNode
         })
         return proxy
     }
@@ -347,21 +340,18 @@ export class SelfAdjustingComputation {
      */
     #readProperty(context, target, property) {
         const value = Reflect.get(target, property, target)
-        const path = [...context.path, property]
-        if (this.#isTraversable(value, path)) {
-            this.#record(context.dependencies, {
-                type: 'kind',
-                path,
-                expected: SelfAdjustingComputation.#valueKind(value)
-            })
-            return this.#createProxy({ ...context, target: value, path })
+        const pathNode = this.#childPath(context.pathNode, property)
+        if (this.#isTraversable(value, pathNode.path)) {
+            this.#record(
+                context.dependencies,
+                pathNode,
+                'kind',
+                SelfAdjustingComputation.#valueKind(value)
+            )
+            return this.#createProxy(context, value, pathNode)
         }
 
-        this.#record(context.dependencies, {
-            type: 'value',
-            path,
-            expected: value
-        })
+        this.#record(context.dependencies, pathNode, 'value', value)
         return value
     }
 
@@ -373,13 +363,9 @@ export class SelfAdjustingComputation {
      * @returns {boolean} Whether the property exists.
      */
     #readPresence(context, target, property) {
-        const path = [...context.path, property]
+        const pathNode = this.#childPath(context.pathNode, property)
         const expected = Reflect.has(target, property)
-        this.#record(context.dependencies, {
-            type: 'has',
-            path,
-            expected
-        })
+        this.#record(context.dependencies, pathNode, 'has', expected)
         return expected
     }
 
@@ -391,11 +377,7 @@ export class SelfAdjustingComputation {
      */
     #readKeys(context, target) {
         const expected = Reflect.ownKeys(target)
-        this.#record(context.dependencies, {
-            type: 'keys',
-            path: [...context.path],
-            expected
-        })
+        this.#record(context.dependencies, context.pathNode, 'keys', expected)
         return expected
     }
 
@@ -408,11 +390,12 @@ export class SelfAdjustingComputation {
      */
     #readDescriptor(context, target, property) {
         const descriptor = Reflect.getOwnPropertyDescriptor(target, property)
-        this.#record(context.dependencies, {
-            type: 'descriptor',
-            path: [...context.path, property],
-            expected: SelfAdjustingComputation.#descriptorState(descriptor)
-        })
+        this.#record(
+            context.dependencies,
+            this.#childPath(context.pathNode, property),
+            'descriptor',
+            SelfAdjustingComputation.#descriptorState(descriptor)
+        )
         return descriptor
     }
 
@@ -424,23 +407,50 @@ export class SelfAdjustingComputation {
      */
     #isTraversable(value, path) {
         if (!value || typeof value !== 'object') return false
-        if (this.#isAtomic(value, [...path])) return false
+        if (this.#isAtomic?.(value, [...path])) return false
         if (Array.isArray(value)) return true
         const prototype = Reflect.getPrototypeOf(value)
         return prototype === Object.prototype || prototype === null
     }
 
     /**
-     * Stores or replaces one dependency by type and input path.
-     * @param {Map<string, object>} dependencies Dependency registry.
-     * @param {{ type: string, path: PropertyKey[], expected: any }} dependency Dependency record.
+     * Interns one child path using property identity without encoding its ancestors.
+     * Path and proxy caches belong to one trace and are never reused by a later snapshot.
+     * @param {object} parent Parent path node.
+     * @param {PropertyKey} property Observed property key.
+     * @returns {object} Canonical child path node for this trace.
+     */
+    #childPath(parent, property) {
+        const previous = parent.children?.get(property)
+        if (previous) return previous
+        const child = {
+            path: [...parent.path, property],
+            children: null,
+            observations: null
+        }
+        parent.children ??= new Map()
+        parent.children.set(property, child)
+        return child
+    }
+
+    /**
+     * Stores the last observation of each dependency type at an interned path.
+     * @param {object[]} dependencies Dependency registry in first-observed order.
+     * @param {object} pathNode Interned path node.
+     * @param {string} type Dependency comparison category.
+     * @param {any} expected Most recently observed value or structural state.
      * @returns {void}
      */
-    #record(dependencies, dependency) {
-        dependencies.set(
-            dependency.type + ':' + this.#pathKey(dependency.path),
-            dependency
-        )
+    #record(dependencies, pathNode, type, expected) {
+        const previous = pathNode.observations?.get(type)
+        if (previous) {
+            previous.expected = expected
+            return
+        }
+        const dependency = { type, path: pathNode.path, expected }
+        pathNode.observations ??= new Map()
+        pathNode.observations.set(type, dependency)
+        dependencies.push(dependency)
     }
 
     /**
@@ -530,27 +540,6 @@ export class SelfAdjustingComputation {
         return { found: true, value }
     }
 
-    /**
-     * Creates a collision-free string key for a property path.
-     * @param {PropertyKey[]} path Input path.
-     * @returns {string} Registry key.
-     */
-    #pathKey(path) {
-        return path
-            .map((property) => {
-                if (typeof property === 'symbol') {
-                    if (!this.#symbolIds.has(property)) {
-                        this.#symbolIds.set(property, this.#nextSymbolId)
-                        this.#nextSymbolId += 1
-                    }
-                    return 'y' + this.#symbolIds.get(property)
-                }
-                const text = String(property)
-                return 's' + text.length + ':' + text
-            })
-            .join('|')
-    }
-
     /**
      * Rejects mutation through a tracked snapshot.
      * @returns {never}

package/src/core/context/CircuitJsonExtensionBoundary.mjs

@@ -6,7 +6,7 @@ const OWNED_EXTENSION_ROOTS = new WeakSet()
 const EXTENSION_METADATA_LIMITS = Object.freeze({
     label: 'Canonical extension data',
     maxBytes: 128 * 1024 * 1024,
-    maxItems: 4_000_000,
+    maxItems: 8_000_000,
     preserveBinary: true
 })
 

package/src/core/context/StructuredCloneTextAccounting.mjs

@@ -1,4 +1,5 @@
 const TEXT_ACCOUNTING_CHUNK_CHARACTERS = 64 * 1_024
+const SHORT_TEXT_CHARACTERS = 256
 const STRING_CHAR_CODE_AT = String.prototype.charCodeAt
 const STRING_SLICE = String.prototype.slice
 const TEXT_ENCODER = new TextEncoder()
@@ -17,6 +18,14 @@ export class StructuredCloneTextAccounting {
      */
     static *reserve(value, state, operations) {
         if (state.maxBytes === Number.MAX_SAFE_INTEGER) return
+        if (value.length <= SHORT_TEXT_CHARACTERS) {
+            const length = StructuredCloneTextAccounting.#shortByteLength(value)
+            if (state.bytes + length > state.maxBytes) {
+                throw new TypeError(`${state.label} is too large.`)
+            }
+            operations.reserve(length)
+            return
+        }
         let length = 0
         let offset = 0
         while (offset < value.length) {
@@ -49,6 +58,35 @@ export class StructuredCloneTextAccounting {
         }
         operations.reserve(length)
     }
+
+    /**
+     * Counts bounded short text without allocating an encoded byte buffer.
+     * Lone surrogates consume the three UTF-8 bytes of a replacement character.
+     * @param {string} value Short immutable text.
+     * @returns {number} UTF-8 byte length.
+     */
+    static #shortByteLength(value) {
+        let length = 0
+        for (let index = 0; index < value.length; index += 1) {
+            const code = STRING_CHAR_CODE_AT.call(value, index)
+            if (code <= 0x7f) {
+                length += 1
+            } else if (code <= 0x7ff) {
+                length += 2
+            } else if (code >= 0xd800 && code <= 0xdbff) {
+                const next = STRING_CHAR_CODE_AT.call(value, index + 1)
+                if (next >= 0xdc00 && next <= 0xdfff) {
+                    length += 4
+                    index += 1
+                } else {
+                    length += 3
+                }
+            } else {
+                length += 3
+            }
+        }
+        return length
+    }
 }
 
 Object.freeze(StructuredCloneTextAccounting.prototype)

package/src/core/worker/NativeParserWorkerTransport.mjs

@@ -0,0 +1,201 @@
+import { TOOLKIT_WORKER_PROTOCOL } from './ToolkitWorkerProtocol.mjs'
+
+const REFLECT_APPLY = Reflect.apply
+const REFLECT_CONSTRUCT = Reflect.construct
+const REFLECT_OWN_KEYS = Reflect.ownKeys
+const GET_PROTOTYPE = Object.getPrototypeOf
+const GET_DESCRIPTORS = Object.getOwnPropertyDescriptors
+const HAS_OWN = Object.hasOwn
+const OBJECT_PROTOTYPE = Object.prototype
+const WEAK_MAP_GET = WeakMap.prototype.get
+const WEAK_MAP_SET = WeakMap.prototype.set
+const WEAK_MAP_DELETE = WeakMap.prototype.delete
+const WORKER_CONSTRUCTOR = globalThis.Worker
+const WORKER_POST = WORKER_CONSTRUCTOR?.prototype?.postMessage
+const WORKER_TERMINATE = WORKER_CONSTRUCTOR?.prototype?.terminate
+const ADD_EVENT_LISTENER = EventTarget.prototype.addEventListener
+const REMOVE_EVENT_LISTENER = EventTarget.prototype.removeEventListener
+const MESSAGE_DATA = Object.getOwnPropertyDescriptor(
+    MessageEvent.prototype,
+    'data'
+)?.get
+const EVENT_CURRENT_TARGET = Object.getOwnPropertyDescriptor(
+    Event.prototype,
+    'currentTarget'
+)?.get
+const EVENT_TRUSTED =
+    Object.getOwnPropertyDescriptor(new Event('message'), 'isTrusted')?.get ||
+    Object.getOwnPropertyDescriptor(Event.prototype, 'isTrusted')?.get
+const ERROR_DATA =
+    typeof ErrorEvent === 'function'
+        ? Object.getOwnPropertyDescriptor(ErrorEvent.prototype, 'error')?.get
+        : null
+const RECEIVED_RESULTS = new WeakMap()
+
+/**
+ * Keeps native workers and their unexposed structured-clone results private.
+ * A custom factory cannot mint the one-use result capabilities created here.
+ */
+export class NativeParserWorkerTransport {
+    #worker
+    #listeners = new Map()
+    #nativeListeners = new Map()
+
+    /**
+     * Constructs an isolated transport using the captured native constructor.
+     * @param {string | URL} url Worker module URL.
+     */
+    constructor(url) {
+        this.#worker = REFLECT_CONSTRUCT(WORKER_CONSTRUCTOR, [
+            url,
+            { type: 'module' }
+        ])
+        for (const type of ['message', 'error', 'messageerror']) {
+            const listener = (event) => this.#receive(type, event)
+            this.#nativeListeners.set(type, listener)
+            REFLECT_APPLY(ADD_EVENT_LISTENER, this.#worker, [type, listener])
+        }
+    }
+
+    /**
+     * Uses private native transport only while the captured host is unchanged.
+     * Replaced or emulated Worker constructors retain generic validation.
+     * @param {string | URL} url Worker module URL.
+     * @returns {object} Browser-compatible worker transport.
+     */
+    static create(url) {
+        const Constructor = globalThis.Worker
+        if (
+            Constructor !== WORKER_CONSTRUCTOR ||
+            typeof WORKER_POST !== 'function' ||
+            typeof WORKER_TERMINATE !== 'function' ||
+            !MESSAGE_DATA ||
+            !EVENT_CURRENT_TARGET ||
+            !EVENT_TRUSTED
+        ) {
+            return REFLECT_CONSTRUCT(Constructor, [url, { type: 'module' }])
+        }
+        return new NativeParserWorkerTransport(url)
+    }
+
+    /**
+     * Consumes an opaque result exactly once. The returned data has never been
+     * exposed outside this transport; exposing it here destroys its capability.
+     * @param {unknown} token Result candidate.
+     * @returns {{ value: unknown } | null} Privately received data, if proven.
+     */
+    static consumeResult(token) {
+        const received = REFLECT_APPLY(WEAK_MAP_GET, RECEIVED_RESULTS, [token])
+        if (!received) return null
+        REFLECT_APPLY(WEAK_MAP_DELETE, RECEIVED_RESULTS, [token])
+        return received
+    }
+
+    /** @param {string} type Event type. @param {Function} listener Listener. @returns {void} */
+    addEventListener(type, listener) {
+        if (!this.#listeners.has(type)) this.#listeners.set(type, new Set())
+        this.#listeners.get(type).add(listener)
+    }
+
+    /** @param {string} type Event type. @param {Function} listener Listener. @returns {void} */
+    removeEventListener(type, listener) {
+        this.#listeners.get(type)?.delete(listener)
+    }
+
+    /** @param {unknown} message Request. @param {Transferable[]} [transfer] Transfer list. @returns {void} */
+    postMessage(message, transfer = []) {
+        REFLECT_APPLY(WORKER_POST, this.#worker, [message, transfer])
+    }
+
+    /** Detaches native listeners and terminates the private worker. @returns {void} */
+    terminate() {
+        for (const [type, listener] of this.#nativeListeners) {
+            REFLECT_APPLY(REMOVE_EVENT_LISTENER, this.#worker, [type, listener])
+        }
+        this.#nativeListeners.clear()
+        this.#listeners.clear()
+        REFLECT_APPLY(WORKER_TERMINATE, this.#worker, [])
+    }
+
+    /**
+     * Hides the native target and result graph before invoking any consumer.
+     * Synthetic events and invalid envelopes never receive a capability.
+     * @param {string} type Event type.
+     * @param {Event} event Native event.
+     * @returns {void}
+     */
+    #receive(type, event) {
+        let forwarded = {}
+        if (type === 'message') {
+            const data = REFLECT_APPLY(MESSAGE_DATA, event, [])
+            forwarded = { data }
+            if (
+                REFLECT_APPLY(EVENT_TRUSTED, event, []) === true &&
+                REFLECT_APPLY(EVENT_CURRENT_TARGET, event, []) === this.#worker
+            ) {
+                try {
+                    const message =
+                        NativeParserWorkerTransport.#resultMessage(data)
+                    if (message) {
+                        const token = Object.freeze(Object.create(null))
+                        REFLECT_APPLY(WEAK_MAP_SET, RECEIVED_RESULTS, [
+                            token,
+                            { value: message.value }
+                        ])
+                        message.value = token
+                        forwarded = { data: message }
+                    }
+                } catch {
+                    // The ordinary client boundary reports malformed envelopes.
+                }
+            }
+        } else if (type === 'error') {
+            forwarded = {
+                error: ERROR_DATA ? REFLECT_APPLY(ERROR_DATA, event, []) : null
+            }
+        }
+        for (const listener of this.#listeners.get(type) || []) {
+            REFLECT_APPLY(listener, undefined, [forwarded])
+        }
+    }
+
+    /**
+     * Captures only exact native result headers without calling replaceable
+     * exported helpers that could introduce caller-owned values into the graph.
+     * @param {unknown} data Privately received native event data.
+     * @returns {object | null} Result envelope safe to hide behind a capability.
+     */
+    static #resultMessage(data) {
+        if (!data || typeof data !== 'object') return null
+        const prototype = GET_PROTOTYPE(data)
+        if (prototype !== OBJECT_PROTOTYPE && prototype !== null) return null
+        const descriptors = GET_DESCRIPTORS(data)
+        if (REFLECT_OWN_KEYS(descriptors).length !== 4) return null
+        for (const key of ['protocol', 'type', 'requestId', 'value']) {
+            const descriptor = descriptors[key]
+            if (
+                !descriptor ||
+                !HAS_OWN(descriptor, 'value') ||
+                descriptor.enumerable !== true
+            ) {
+                return null
+            }
+        }
+        const protocol = descriptors.protocol.value
+        const type = descriptors.type.value
+        const requestId = descriptors.requestId.value
+        if (
+            protocol !== TOOLKIT_WORKER_PROTOCOL ||
+            type !== 'result' ||
+            typeof requestId !== 'string' ||
+            !requestId ||
+            requestId.length > 256
+        ) {
+            return null
+        }
+        return { protocol, type, requestId, value: descriptors.value.value }
+    }
+}
+
+Object.freeze(NativeParserWorkerTransport.prototype)
+Object.freeze(NativeParserWorkerTransport)

package/src/core/worker/ParserWorkerClient.mjs

@@ -3,6 +3,7 @@ import { RuntimeProxyBoundary } from '../contracts/RuntimeProxyBoundary.mjs'
 import { TOOLKIT_WORKER_PROTOCOL } from './ToolkitWorkerProtocol.mjs'
 import { WorkerRequestData } from './WorkerRequestData.mjs'
 import { WorkerResponseData } from './WorkerResponseData.mjs'
+import { NativeParserWorkerTransport } from './NativeParserWorkerTransport.mjs'
 
 const ABORTED_GETTER = Object.getOwnPropertyDescriptor(
     AbortSignal.prototype,
@@ -73,14 +74,22 @@ export class ParserWorkerClient {
         }
     }
 
-    /**
-     * Returns the process-local default client, creating it lazily.
-     * @returns {ParserWorkerClient} Default worker client.
-     */
+    /** @returns {ParserWorkerClient} Lazily-created process-local default client. */
     static defaultClient() {
         return ParserWorkerClient.#defaultClientFor(null)
     }
 
+    /**
+     * Creates a client whose native worker and received graphs remain private.
+     * @param {string | URL} workerUrl Worker module URL.
+     * @returns {ParserWorkerClient} Client using native clone provenance.
+     */
+    static fromWorkerUrl(workerUrl) {
+        return new ParserWorkerClient({
+            createWorker: () => NativeParserWorkerTransport.create(workerUrl)
+        })
+    }
+
     /**
      * Returns the process-local default client for one internal attempt.
      * @param {object | null} attemptToken Internal attempt identity.
@@ -91,26 +100,15 @@ export class ParserWorkerClient {
             throw ParserWorkerClient.#unavailableError(attemptToken)
         }
         if (!ParserWorkerClient.#defaultClient) {
-            ParserWorkerClient.#defaultClient = new ParserWorkerClient({
-                createWorker: () => {
-                    const WorkerConstructor = globalThis.Worker
-                    return Reflect.construct(WorkerConstructor, [
-                        new URL(
-                            '../../workers/parser.worker.mjs',
-                            import.meta.url
-                        ),
-                        { type: 'module' }
-                    ])
-                }
-            })
+            ParserWorkerClient.#defaultClient =
+                ParserWorkerClient.fromWorkerUrl(
+                    new URL('../../workers/parser.worker.mjs', import.meta.url)
+                )
         }
         return ParserWorkerClient.#defaultClient
     }
 
-    /**
-     * Disposes the process-local default worker client when one exists.
-     * @returns {void}
-     */
+    /** Disposes the process-local default worker client. @returns {void} */
     static disposeDefault() {
         ParserWorkerClient.#defaultClient?.dispose()
         ParserWorkerClient.#defaultClient = null

package/src/core/worker/WorkerBinaryData.mjs

@@ -0,0 +1,201 @@
+const ARRAY_BUFFER_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
+    ArrayBuffer.prototype,
+    'byteLength'
+)?.get
+const ARRAY_BUFFER_RESIZABLE_GETTER = Object.getOwnPropertyDescriptor(
+    ArrayBuffer.prototype,
+    'resizable'
+)?.get
+const SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER =
+    typeof SharedArrayBuffer === 'function'
+        ? Object.getOwnPropertyDescriptor(
+              SharedArrayBuffer.prototype,
+              'byteLength'
+          )?.get
+        : null
+const TYPED_ARRAY_PROTOTYPE = Object.getPrototypeOf(Uint8Array.prototype)
+const TYPED_ARRAY_BUFFER_GETTER = Object.getOwnPropertyDescriptor(
+    TYPED_ARRAY_PROTOTYPE,
+    'buffer'
+)?.get
+const TYPED_ARRAY_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
+    TYPED_ARRAY_PROTOTYPE,
+    'byteLength'
+)?.get
+const TYPED_ARRAY_BYTE_OFFSET_GETTER = Object.getOwnPropertyDescriptor(
+    TYPED_ARRAY_PROTOTYPE,
+    'byteOffset'
+)?.get
+const TYPED_ARRAY_TAG_GETTER = Object.getOwnPropertyDescriptor(
+    TYPED_ARRAY_PROTOTYPE,
+    Symbol.toStringTag
+)?.get
+const DATA_VIEW_BUFFER_GETTER = Object.getOwnPropertyDescriptor(
+    DataView.prototype,
+    'buffer'
+)?.get
+const DATA_VIEW_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
+    DataView.prototype,
+    'byteLength'
+)?.get
+const DATA_VIEW_BYTE_OFFSET_GETTER = Object.getOwnPropertyDescriptor(
+    DataView.prototype,
+    'byteOffset'
+)?.get
+const DATA_VIEW_CONSTRUCTOR = DataView
+const UINT8_ARRAY_CONSTRUCTOR = Uint8Array
+const UINT8_ARRAY_SET = Uint8Array.prototype.set
+const ARRAY_BUFFER_IS_VIEW = ArrayBuffer.isView
+const OBJECT_GET_PROTOTYPE_OF = Object.getPrototypeOf
+const OBJECT_PROTOTYPE = Object.prototype
+const TYPED_ARRAYS = new Map(
+    [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        Float32Array,
+        Float64Array,
+        typeof BigInt64Array === 'function' ? BigInt64Array : null,
+        typeof BigUint64Array === 'function' ? BigUint64Array : null
+    ]
+        .filter(Boolean)
+        .map((Constructor) => [Constructor.name, Constructor])
+)
+
+/**
+ * Inspects and isolates worker binary data through captured intrinsic slots.
+ */
+export class WorkerBinaryData {
+    /**
+     * Classifies records only in a privately received native clone graph.
+     * Generic inputs must still use exact brands, even with these prototypes.
+     * @param {object} value Proven native-clone value.
+     * @returns {boolean} Whether it has a normalized plain-record prototype.
+     */
+    static isStandardRecord(value) {
+        const prototype = OBJECT_GET_PROTOTYPE_OF(value)
+        return prototype === OBJECT_PROTOTYPE || prototype === null
+    }
+
+    /**
+     * Recreates one intrinsic view on an exact isolated backing buffer.
+     * @param {{ byteLength: number, tag: string }} view View fields.
+     * @param {ArrayBuffer} buffer Exact copied buffer.
+     * @returns {ArrayBufferView} Recreated view.
+     */
+    static recreateView(view, buffer) {
+        if (view.tag === 'DataView') return new DATA_VIEW_CONSTRUCTOR(buffer)
+        const Constructor = TYPED_ARRAYS.get(view.tag)
+        if (!Constructor || view.byteLength % Constructor.BYTES_PER_ELEMENT) {
+            throw new TypeError('Worker request binary view is unsupported.')
+        }
+        return new Constructor(
+            buffer,
+            0,
+            view.byteLength / Constructor.BYTES_PER_ELEMENT
+        )
+    }
+
+    /**
+     * Reads genuine typed-array or DataView internal slots.
+     * @param {unknown} value View candidate.
+     * @returns {{ buffer: ArrayBufferLike, byteOffset: number, byteLength: number, tag: string } | null} Intrinsic view fields.
+     */
+    static view(value) {
+        if (!ARRAY_BUFFER_IS_VIEW(value)) return null
+        try {
+            const tag = TYPED_ARRAY_TAG_GETTER?.call(value)
+            if (TYPED_ARRAYS.has(tag)) {
+                return {
+                    buffer: TYPED_ARRAY_BUFFER_GETTER.call(value),
+                    byteOffset: TYPED_ARRAY_BYTE_OFFSET_GETTER.call(value),
+                    byteLength: TYPED_ARRAY_BYTE_LENGTH_GETTER.call(value),
+                    tag
+                }
+            }
+            if (
+                DATA_VIEW_BUFFER_GETTER &&
+                DATA_VIEW_BYTE_OFFSET_GETTER &&
+                DATA_VIEW_BYTE_LENGTH_GETTER
+            ) {
+                const buffer = DATA_VIEW_BUFFER_GETTER.call(value)
+                return {
+                    buffer,
+                    byteOffset: DATA_VIEW_BYTE_OFFSET_GETTER.call(value),
+                    byteLength: DATA_VIEW_BYTE_LENGTH_GETTER.call(value),
+                    tag: 'DataView'
+                }
+            }
+        } catch {
+            return null
+        }
+        return null
+    }
+
+    /** @param {unknown} value Candidate. @returns {number | null} Byte length. */
+    static bufferLength(value) {
+        if (!ARRAY_BUFFER_BYTE_LENGTH_GETTER) return null
+        try {
+            return ARRAY_BUFFER_BYTE_LENGTH_GETTER.call(value)
+        } catch {
+            return null
+        }
+    }
+
+    /** @param {unknown} value Candidate. @returns {number | null} Byte length. */
+    static sharedBufferLength(value) {
+        if (!SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER) return null
+        try {
+            return SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER.call(value)
+        } catch {
+            return null
+        }
+    }
+
+    /**
+     * Returns whether a genuine ArrayBuffer can change size after accounting.
+     * @param {unknown} value Buffer candidate.
+     * @returns {boolean} Whether the buffer is resizable.
+     */
+    static isResizableBuffer(value) {
+        if (!ARRAY_BUFFER_RESIZABLE_GETTER) return false
+        try {
+            return ARRAY_BUFFER_RESIZABLE_GETTER.call(value) === true
+        } catch {
+            return false
+        }
+    }
+
+    /**
+     * Copies one already-accounted intrinsic byte range into a fixed buffer.
+     * The explicit range prevents a growable backing store from widening the
+     * copy between its limit check and snapshot.
+     * @param {ArrayBufferLike} buffer Source buffer.
+     * @param {number} byteOffset Captured byte offset.
+     * @param {number} byteLength Captured byte length.
+     * @returns {ArrayBuffer} Fixed owned snapshot.
+     */
+    static copyBuffer(buffer, byteOffset, byteLength) {
+        try {
+            const source = new UINT8_ARRAY_CONSTRUCTOR(
+                buffer,
+                byteOffset,
+                byteLength
+            )
+            const copy = new UINT8_ARRAY_CONSTRUCTOR(byteLength)
+            UINT8_ARRAY_SET.call(copy, source)
+            return TYPED_ARRAY_BUFFER_GETTER.call(copy)
+        } catch {
+            throw new TypeError(
+                'Worker request binary data changed while it was copied.'
+            )
+        }
+    }
+}
+
+Object.freeze(WorkerBinaryData.prototype)
+Object.freeze(WorkerBinaryData)

package/src/core/worker/WorkerRequestData.mjs

@@ -3,82 +3,21 @@ import { CircuitJsonReadOnlyDocument } from '../context/CircuitJsonReadOnlyDocum
 import { ProtectedExtensionBinaryBoundary } from '../context/ProtectedExtensionBinaryBoundary.mjs'
 import { RuntimeProxyBoundary } from '../contracts/RuntimeProxyBoundary.mjs'
 import { WorkerResultShape } from './WorkerResultShape.mjs'
+import { WorkerBinaryData } from './WorkerBinaryData.mjs'
+import { NativeParserWorkerTransport } from './NativeParserWorkerTransport.mjs'
 
-const ARRAY_BUFFER_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
-    ArrayBuffer.prototype,
-    'byteLength'
-)?.get
-const ARRAY_BUFFER_RESIZABLE_GETTER = Object.getOwnPropertyDescriptor(
-    ArrayBuffer.prototype,
-    'resizable'
-)?.get
-const SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER =
-    typeof SharedArrayBuffer === 'function'
-        ? Object.getOwnPropertyDescriptor(
-              SharedArrayBuffer.prototype,
-              'byteLength'
-          )?.get
-        : null
-const TYPED_ARRAY_PROTOTYPE = Object.getPrototypeOf(Uint8Array.prototype)
-const TYPED_ARRAY_BUFFER_GETTER = Object.getOwnPropertyDescriptor(
-    TYPED_ARRAY_PROTOTYPE,
-    'buffer'
-)?.get
-const TYPED_ARRAY_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
-    TYPED_ARRAY_PROTOTYPE,
-    'byteLength'
-)?.get
-const TYPED_ARRAY_BYTE_OFFSET_GETTER = Object.getOwnPropertyDescriptor(
-    TYPED_ARRAY_PROTOTYPE,
-    'byteOffset'
-)?.get
-const TYPED_ARRAY_TAG_GETTER = Object.getOwnPropertyDescriptor(
-    TYPED_ARRAY_PROTOTYPE,
-    Symbol.toStringTag
-)?.get
-const DATA_VIEW_BUFFER_GETTER = Object.getOwnPropertyDescriptor(
-    DataView.prototype,
-    'buffer'
-)?.get
-const DATA_VIEW_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
-    DataView.prototype,
-    'byteLength'
-)?.get
-const DATA_VIEW_BYTE_OFFSET_GETTER = Object.getOwnPropertyDescriptor(
-    DataView.prototype,
-    'byteOffset'
-)?.get
-const DATA_VIEW_CONSTRUCTOR = DataView
-const UINT8_ARRAY_CONSTRUCTOR = Uint8Array
-const UINT8_ARRAY_SET = Uint8Array.prototype.set
+const ARRAY_IS_ARRAY = Array.isArray
 const STRUCTURED_CLONE = globalThis.structuredClone
 const MAX_REQUEST_BYTES = 100_000_000
 const MAX_REQUEST_DEPTH = 256
 const MAX_REQUEST_VALUES = 100_000
 const MAX_RESULT_BYTES = 250_000_000
 const MAX_RESULT_VALUES = 2_000_000
-const MAX_DOCUMENT_RESULT_VALUES = 5_000_000
+const MAX_DOCUMENT_RESULT_VALUES = 10_000_000
 // Project documents retain the single-result ceiling independently while this
 // aggregate ceiling bounds total worker traversal regardless of document count.
-const MAX_PROJECT_RESULT_VALUES = 8_000_000
+const MAX_PROJECT_RESULT_VALUES = 16_000_000
 const MAX_PROJECT_RESULT_BYTES = 256 * 1024 * 1024
-const TYPED_ARRAYS = new Map(
-    [
-        Int8Array,
-        Uint8Array,
-        Uint8ClampedArray,
-        Int16Array,
-        Uint16Array,
-        Int32Array,
-        Uint32Array,
-        Float32Array,
-        Float64Array,
-        typeof BigInt64Array === 'function' ? BigInt64Array : null,
-        typeof BigUint64Array === 'function' ? BigUint64Array : null
-    ]
-        .filter(Boolean)
-        .map((Constructor) => [Constructor.name, Constructor])
-)
 
 /**
  * Validates and prepares bounded structured-clone worker request data.
@@ -151,10 +90,12 @@ export class WorkerRequestData {
      * @returns {unknown} Owned clone-safe result data.
      */
     static prepareResponse(value) {
-        return WorkerRequestData.#prepare(value, {
+        const received = NativeParserWorkerTransport.consumeResult(value)
+        return WorkerRequestData.#prepare(received ? received.value : value, {
             bytes: MAX_RESULT_BYTES,
-            copyBinary: true,
+            copyBinary: !received,
             output: true,
+            standardBuiltins: Boolean(received),
             strictDescriptors: true,
             transferInput: false,
             trustProof: false,
@@ -165,7 +106,7 @@ export class WorkerRequestData {
     /**
      * Runs the shared bounded structured-data preparation pass.
      * @param {unknown} value Data candidate.
-     * @param {{ bytes: number, copyBinary: boolean, output: boolean, strictDescriptors: boolean, transferInput: boolean, trustProof: boolean, values: number }} limits Preparation limits.
+     * @param {{ bytes: number, copyBinary: boolean, output: boolean, standardBuiltins?: boolean, strictDescriptors: boolean, transferInput: boolean, trustProof: boolean, values: number }} limits Preparation limits.
      * @returns {{ value: unknown, transfer: Transferable[] }} Prepared data.
      */
     static #prepare(value, limits) {
@@ -187,6 +128,7 @@ export class WorkerRequestData {
             projectResult: false,
             reaccountValues: 0,
             strictDescriptors: limits.strictDescriptors,
+            standardBuiltins: limits.standardBuiltins === true,
             transfer: { items: [], seen: new Set() },
             transferInput: limits.transferInput,
             trustProof: limits.trustProof,
@@ -265,14 +207,36 @@ export class WorkerRequestData {
         WorkerRequestData.#accountedScope(state)?.add(value)
         state.visiting.add(value)
         try {
-            const bufferLength = WorkerRequestData.#bufferLength(value)
+            // Array and view brands are disjoint from raw buffers, including
+            // cross-realm values and values with replaced prototypes.
+            if (ARRAY_IS_ARRAY(value)) {
+                return WorkerRequestData.#prepareContainer(value, state, depth)
+            }
+            if (
+                state.standardBuiltins &&
+                WorkerBinaryData.isStandardRecord(value)
+            ) {
+                return WorkerRequestData.#prepareContainer(value, state, depth)
+            }
+            const view = WorkerBinaryData.view(value)
+            if (view) {
+                WorkerRequestData.#reserveBytes(state, view.byteLength)
+                const prepared = WorkerRequestData.#prepareView(
+                    value,
+                    view,
+                    state
+                )
+                state.prepared.set(value, prepared)
+                return prepared
+            }
+            const bufferLength = WorkerBinaryData.bufferLength(value)
             if (bufferLength !== null) {
                 WorkerRequestData.#reserveBytes(state, bufferLength)
                 const isolate =
                     state.copyBinary ||
-                    WorkerRequestData.#isResizableBuffer(value)
+                    WorkerBinaryData.isResizableBuffer(value)
                 const prepared = isolate
-                    ? WorkerRequestData.#copyBuffer(value, 0, bufferLength)
+                    ? WorkerBinaryData.copyBuffer(value, 0, bufferLength)
                     : value
                 state.prepared.set(value, prepared)
                 if (state.transferInput) {
@@ -280,10 +244,10 @@ export class WorkerRequestData {
                 }
                 return prepared
             }
-            const sharedLength = WorkerRequestData.#sharedBufferLength(value)
+            const sharedLength = WorkerBinaryData.sharedBufferLength(value)
             if (sharedLength !== null) {
                 WorkerRequestData.#reserveBytes(state, sharedLength)
-                const copied = WorkerRequestData.#copyBuffer(
+                const copied = WorkerBinaryData.copyBuffer(
                     value,
                     0,
                     sharedLength
@@ -294,17 +258,6 @@ export class WorkerRequestData {
                 }
                 return copied
             }
-            const view = WorkerRequestData.#view(value)
-            if (view) {
-                WorkerRequestData.#reserveBytes(state, view.byteLength)
-                const prepared = WorkerRequestData.#prepareView(
-                    value,
-                    view,
-                    state
-                )
-                state.prepared.set(value, prepared)
-                return prepared
-            }
             return WorkerRequestData.#prepareContainer(value, state, depth)
         } finally {
             state.visiting.delete(value)
@@ -598,21 +551,32 @@ export class WorkerRequestData {
         if (accounted.has(value)) return
         accounted.add(value)
         WorkerRequestData.#reserveAccountedValues(state, 1)
-        const bufferLength = WorkerRequestData.#bufferLength(value)
-        if (bufferLength !== null) {
-            WorkerRequestData.#reserveAccountedBytes(state, bufferLength)
+        if (ARRAY_IS_ARRAY(value)) {
+            WorkerRequestData.#accountPreparedContainer(value, state, depth)
             return
         }
-        const sharedLength = WorkerRequestData.#sharedBufferLength(value)
-        if (sharedLength !== null) {
-            WorkerRequestData.#reserveAccountedBytes(state, sharedLength)
+        if (
+            state.standardBuiltins &&
+            WorkerBinaryData.isStandardRecord(value)
+        ) {
+            WorkerRequestData.#accountPreparedContainer(value, state, depth)
             return
         }
-        const view = WorkerRequestData.#view(value)
+        const view = WorkerBinaryData.view(value)
         if (view) {
             WorkerRequestData.#reserveAccountedBytes(state, view.byteLength)
             return
         }
+        const bufferLength = WorkerBinaryData.bufferLength(value)
+        if (bufferLength !== null) {
+            WorkerRequestData.#reserveAccountedBytes(state, bufferLength)
+            return
+        }
+        const sharedLength = WorkerBinaryData.sharedBufferLength(value)
+        if (sharedLength !== null) {
+            WorkerRequestData.#reserveAccountedBytes(state, sharedLength)
+            return
+        }
         WorkerRequestData.#accountPreparedContainer(value, state, depth)
     }
 
@@ -708,8 +672,11 @@ export class WorkerRequestData {
      * @returns {ArrayBufferView} Prepared exact view.
      */
     static #prepareView(original, view, state) {
-        const backingLength = WorkerRequestData.#bufferLength(view.buffer)
-        const sharedLength = WorkerRequestData.#sharedBufferLength(view.buffer)
+        const backingLength = WorkerBinaryData.bufferLength(view.buffer)
+        const sharedLength =
+            backingLength === null
+                ? WorkerBinaryData.sharedBufferLength(view.buffer)
+                : null
         const exactArrayBuffer =
             backingLength !== null &&
             view.byteOffset === 0 &&
@@ -717,7 +684,7 @@ export class WorkerRequestData {
         if (
             exactArrayBuffer &&
             !state.copyBinary &&
-            !WorkerRequestData.#isResizableBuffer(view.buffer)
+            !WorkerBinaryData.isResizableBuffer(view.buffer)
         ) {
             if (state.transferInput) {
                 WorkerRequestData.#addTransfer(state.transfer, view.buffer)
@@ -727,134 +694,18 @@ export class WorkerRequestData {
         if (backingLength === null && sharedLength === null) {
             throw new TypeError('Worker request binary view is invalid.')
         }
-        const copy = WorkerRequestData.#copyBuffer(
+        const copy = WorkerBinaryData.copyBuffer(
             view.buffer,
             view.byteOffset,
             view.byteLength
         )
-        const prepared = WorkerRequestData.#recreateView(view, copy)
+        const prepared = WorkerBinaryData.recreateView(view, copy)
         if (state.transferInput) {
             WorkerRequestData.#addTransfer(state.transfer, copy)
         }
         return prepared
     }
 
-    /**
-     * Recreates one intrinsic view on an exact isolated backing buffer.
-     * @param {{ byteLength: number, tag: string }} view View fields.
-     * @param {ArrayBuffer} buffer Exact copied buffer.
-     * @returns {ArrayBufferView} Recreated view.
-     */
-    static #recreateView(view, buffer) {
-        if (view.tag === 'DataView') return new DATA_VIEW_CONSTRUCTOR(buffer)
-        const Constructor = TYPED_ARRAYS.get(view.tag)
-        if (!Constructor || view.byteLength % Constructor.BYTES_PER_ELEMENT) {
-            throw new TypeError('Worker request binary view is unsupported.')
-        }
-        return new Constructor(
-            buffer,
-            0,
-            view.byteLength / Constructor.BYTES_PER_ELEMENT
-        )
-    }
-
-    /**
-     * Reads genuine typed-array or DataView internal slots.
-     * @param {unknown} value View candidate.
-     * @returns {{ buffer: ArrayBufferLike, byteOffset: number, byteLength: number, tag: string } | null} Intrinsic view fields.
-     */
-    static #view(value) {
-        try {
-            if (
-                DATA_VIEW_BUFFER_GETTER &&
-                DATA_VIEW_BYTE_OFFSET_GETTER &&
-                DATA_VIEW_BYTE_LENGTH_GETTER
-            ) {
-                const buffer = DATA_VIEW_BUFFER_GETTER.call(value)
-                return {
-                    buffer,
-                    byteOffset: DATA_VIEW_BYTE_OFFSET_GETTER.call(value),
-                    byteLength: DATA_VIEW_BYTE_LENGTH_GETTER.call(value),
-                    tag: 'DataView'
-                }
-            }
-        } catch {
-            // The typed-array intrinsic check below is independent.
-        }
-        try {
-            const tag = TYPED_ARRAY_TAG_GETTER?.call(value)
-            if (!TYPED_ARRAYS.has(tag)) return null
-            return {
-                buffer: TYPED_ARRAY_BUFFER_GETTER.call(value),
-                byteOffset: TYPED_ARRAY_BYTE_OFFSET_GETTER.call(value),
-                byteLength: TYPED_ARRAY_BYTE_LENGTH_GETTER.call(value),
-                tag
-            }
-        } catch {
-            return null
-        }
-    }
-
-    /** @param {unknown} value Candidate. @returns {number | null} Byte length. */
-    static #bufferLength(value) {
-        if (!ARRAY_BUFFER_BYTE_LENGTH_GETTER) return null
-        try {
-            return ARRAY_BUFFER_BYTE_LENGTH_GETTER.call(value)
-        } catch {
-            return null
-        }
-    }
-
-    /** @param {unknown} value Candidate. @returns {number | null} Byte length. */
-    static #sharedBufferLength(value) {
-        if (!SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER) return null
-        try {
-            return SHARED_ARRAY_BUFFER_BYTE_LENGTH_GETTER.call(value)
-        } catch {
-            return null
-        }
-    }
-
-    /**
-     * Returns whether a genuine ArrayBuffer can change size after accounting.
-     * @param {unknown} value Buffer candidate.
-     * @returns {boolean} Whether the buffer is resizable.
-     */
-    static #isResizableBuffer(value) {
-        if (!ARRAY_BUFFER_RESIZABLE_GETTER) return false
-        try {
-            return ARRAY_BUFFER_RESIZABLE_GETTER.call(value) === true
-        } catch {
-            return false
-        }
-    }
-
-    /**
-     * Copies one already-accounted intrinsic byte range into a fixed buffer.
-     * The explicit range prevents a growable backing store from widening the
-     * copy between its limit check and snapshot.
-     * @param {ArrayBufferLike} buffer Source buffer.
-     * @param {number} byteOffset Captured byte offset.
-     * @param {number} byteLength Captured byte length.
-     * @returns {ArrayBuffer} Fixed owned snapshot.
-     */
-    static #copyBuffer(buffer, byteOffset, byteLength) {
-        try {
-            const source = new UINT8_ARRAY_CONSTRUCTOR(
-                buffer,
-                byteOffset,
-                byteLength
-            )
-            const copy = new UINT8_ARRAY_CONSTRUCTOR(byteLength)
-            UINT8_ARRAY_SET.call(copy, source)
-            return TYPED_ARRAY_BUFFER_GETTER.call(copy)
-        } catch {
-            throw new TypeError(
-                'Worker request binary data changed while it was copied.'
-            )
-        }
-    }
-
     /** @param {PropertyDescriptor | undefined} descriptor Descriptor. @returns {unknown} Data value. */
     static #dataValue(descriptor) {
         return descriptor && Object.hasOwn(descriptor, 'value')

package/src/core/worker/WorkerResponseData.mjs

@@ -5,6 +5,9 @@ import { CircuitJsonValidationProof } from '../context/CircuitJsonValidationProo
 import { TOOLKIT_WORKER_PROTOCOL } from './ToolkitWorkerProtocol.mjs'
 import { WorkerRequestData } from './WorkerRequestData.mjs'
 
+const PREPARE_RESPONSE = WorkerRequestData.prepareResponse
+const VALIDATE_AND_ATTACH = CircuitJsonValidationProof.validateAndAttach
+
 const ARRAY_BUFFER_BYTE_LENGTH_GETTER = Object.getOwnPropertyDescriptor(
     ArrayBuffer.prototype,
     'byteLength'
@@ -154,7 +157,7 @@ export class WorkerResponseData {
      * @returns {object} Original validated result.
      */
     static result(operation, value) {
-        const prepared = WorkerRequestData.prepareResponse(value)
+        const prepared = PREPARE_RESPONSE(value)
         const fields = WorkerResponseData.#record(
             prepared,
             'Toolkit worker result'
@@ -330,7 +333,11 @@ export class WorkerResponseData {
             'statistics'
         ])
         try {
-            CircuitJsonValidationProof.validateAndAttach(document)
+            // Preparation allocated every container and normalized every binary
+            // built-in without exposing the owned graph to caller callbacks.
+            VALIDATE_AND_ATTACH(document, {
+                standardBuiltins: true
+            })
         } catch (error) {
             throw WorkerResponseData.#error(
                 'Toolkit worker document model is invalid.',

package/src/core/worker/WorkerResultShape.mjs

@@ -1,5 +1,7 @@
 import { RuntimeProxyBoundary } from '../contracts/RuntimeProxyBoundary.mjs'
 
+const ARRAY_IS_ARRAY = Array.isArray
+
 const DOCUMENT_FIELDS = Object.freeze([
     'schema',
     'id',
@@ -64,7 +66,10 @@ export class WorkerResultShape {
                   )
                 : keys
         if (
-            prototype !== Array.prototype ||
+            // A foreign intrinsic Array.prototype has the same array brand.
+            // Only the receiver's own descriptors are used below; inherited
+            // properties are never read or copied into the normalized array.
+            (prototype !== Array.prototype && !ARRAY_IS_ARRAY(prototype)) ||
             !Number.isSafeInteger(length) ||
             length < 0 ||
             (output && !strictDescriptors