circuitjson-toolkit 1.2.0 → 1.3.0

package/README.md

@@ -55,6 +55,20 @@ metadata ownership traversals now support deeply nested, valid ECAD documents
 up to 256 levels. See the
 [1.2.0 release notes](docs/release-notes-v1.2.0.md).
 
+Version 1.2.1 keeps large canonical documents and multi-document projects
+inside explicit worker budgets. Selected extensions may contain up to four
+million structured items, while exact project envelopes receive independent
+per-document, project-metadata, aggregate-byte, and repeated-work limits. See
+the [1.2.1 release notes](docs/release-notes-v1.2.1.md).
+
+Version 1.3.0 adds an explicit fast preparation path for documents received
+through platform structured clone. Large native extension graphs can be owned
+without exception-driven binary probing of every ordinary record, while the
+general preparation path remains prototype-independent for arbitrary caller
+input. Cross-realm and altered-prototype buffers, typed views, byte limits,
+defensive copies, and all existing return shapes remain supported.
+See the [1.3.0 release notes](docs/release-notes-v1.3.0.md).
+
 Before 1.1.0:
 
 ```js
@@ -100,7 +114,7 @@ const model = document.model
 - Strict `ecad-toolkit.worker.v1` parsing/project protocol with progress,
   cancellation, and controlled buffer transfer
 - One-pass ownership for selected source extensions, with a separate 128 MiB /
-  2,000,000-item bound and exact direct/worker result parity
+  4,000,000-item bound and exact direct/worker result parity
 - Machine-readable capability inventory and packed downstream conformance
   harness
 - Explicit `/extensions` surface retaining every previous specialized API
@@ -201,11 +215,14 @@ falls back to direct execution only when worker construction is unavailable;
 explicit worker and runtime failures remain visible.
 
 Selected source-native extensions are captured once into an immutable owned
-snapshot. Their separate 128 MiB payload and 2,000,000-item ceilings permit
-realistic renderer/model graphs without weakening the worker protocol's 250 MB
-total-result ceiling; an over-limit extension fails visibly instead of being
-silently truncated. Binary extension values remain byte-backed and return
-defensive copies instead of expanding into JavaScript number arrays.
+snapshot. Their separate 128 MiB payload and 4,000,000-item ceilings permit
+realistic renderer/model graphs. Canonical standalone documents remain within
+a 250 MB result ceiling, while exact multi-document project envelopes use a
+256 MiB aggregate ceiling plus independent 250 MB per-document and metadata
+ceilings. Item and repeated-alias work budgets remain separately bounded; an
+over-limit extension or result fails visibly instead of being silently
+truncated. Binary extension values remain byte-backed and return defensive
+copies instead of expanding into JavaScript number arrays.
 When extensions are disabled, native documents and projects return the exact
 empty map `{}`. Bounded ZIP consumers can preflight local/central filenames and
 CRC32/size metadata with
@@ -319,6 +336,8 @@ copy while keeping sync, direct async, and worker results mutation-isolated.
 - [1.1.1 release notes](docs/release-notes-v1.1.1.md)
 - [1.1.2 release notes](docs/release-notes-v1.1.2.md)
 - [1.2.0 release notes](docs/release-notes-v1.2.0.md)
+- [1.2.1 release notes](docs/release-notes-v1.2.1.md)
+- [1.3.0 release notes](docs/release-notes-v1.3.0.md)
 - [Library scope](spec/library-scope.md)
 
 ## Package scope

package/docs/api.md

@@ -53,12 +53,13 @@ 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
-2,000,000-item ceiling so large native renderer graphs do not inherit the
+4,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 and retains its 250 MB whole-result ceiling.
-Binary values preserve their `ArrayBuffer`/typed-view shape behind defensive
-copy access, so payload bytes do not inflate into one JavaScript number per
-byte.
+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
+values preserve their `ArrayBuffer`/typed-view shape behind defensive copy
+access, so payload bytes do not inflate into one JavaScript number per byte.
 
 ### Errors
 
@@ -108,6 +109,28 @@ Validation, indexes, render primitives, and other derived values are cached by
 the context. Public outputs remain detached or immutable; a caller cannot
 mutate later results through a returned object.
 
+Hosts that receive a document from the platform structured-clone algorithm may
+use the explicit provenance-aware entry point:
+
+```js
+const context = CircuitJsonDocumentContext.prepareStructuredClone(
+    message.data,
+    {
+        indexes: ['elements', 'relations']
+    }
+)
+```
+
+`prepareStructuredClone()` has the same options, return type, validation,
+ownership, limits, and derived-cache behavior as `prepare()`. It avoids
+exception-driven raw-buffer brand checks for ordinary objects by relying on the
+standard local prototypes guaranteed by a completed platform structured clone.
+Use it only for the exact structured-cloned result (or a graph created entirely
+by the toolkit after that boundary). Use `prepare()` for arbitrary caller-owned,
+cross-realm, proxy-backed, or prototype-modified input. The general path keeps
+intrinsic binary slots authoritative and preserves altered-prototype
+`ArrayBuffer`, `SharedArrayBuffer`, typed-array, and `DataView` values.
+
 ## Root entrypoint
 
 `circuitjson-toolkit` has an exact 17-class root. The 14 canonical classes are:

package/docs/model-format.md

@@ -102,15 +102,19 @@ 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 2,000,000 structured items
+freezes that graph once under a distinct ceiling of 4,000,000 structured items
 and 128 MiB of string or binary content. The ceiling is shared across the
-selected namespace, applies equally after worker transfer, and remains below
-the worker's 250 MB whole-result limit. General document metadata keeps its
-smaller budget, so a large native projection cannot consume the canonical
-metadata allowance. Oversized graphs are rejected; they are never truncated or
-partially retained. Binary extension values remain byte-backed with their
-common buffer/view type and are exposed as defensive copies, preserving
-mutation isolation without expanding bytes into plain numeric arrays.
+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
+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
+budget. Oversized graphs are rejected; they are never truncated or partially
+retained. Binary extension values remain byte-backed with their common
+buffer/view type and are exposed as defensive copies, preserving mutation
+isolation without expanding bytes into plain numeric arrays.
 
 Supported pre-union CircuitJSON aliases may be projected through
 `CircuitJsonDocument.normalizeModel()`. The copy-on-write form preserves exact

package/docs/release-notes-v1.2.1.md

@@ -0,0 +1,26 @@
+# circuitjson-toolkit 1.2.1
+
+## Large canonical worker results
+
+This patch release keeps valid high-fidelity documents and multi-document
+projects inside explicit, format-neutral worker limits:
+
+- Selected native extensions may contain up to 4,000,000 structured items and
+  128 MiB of string or binary content.
+- A canonical standalone document may contain up to 5,000,000 result values
+  within the existing 250 MB byte ceiling.
+- An exact canonical project may contain up to 8,000,000 aggregate values and
+  256 MiB, while every document retains its own 5,000,000-value and 250 MB
+  limits.
+- Non-document project metadata retains the generic 2,000,000-value and 250 MB
+  limits.
+
+Elevated budgets require the complete canonical document or project envelope;
+a schema string alone does not change generic result limits. Reused object
+graphs are charged independently to document and project-metadata scopes in a
+property-order-independent way. Repeated alias-accounting work is also capped
+by the project aggregate budget, keeping transport time bounded.
+
+No public class, method, package subpath, parameter, or result field is removed
+or renamed. Oversized results continue to fail visibly rather than being
+truncated.

package/docs/release-notes-v1.3.0.md

@@ -0,0 +1,45 @@
+# circuitjson-toolkit 1.3.0
+
+## Faster canonical extension ownership
+
+This minor release adds an explicit fast ownership path for large native
+extension graphs received through the platform structured-clone algorithm.
+Ordinary records, arrays, and standard local data containers are classified
+without deliberately invoking incompatible intrinsic getters, while genuine
+buffers and views still use captured platform slots as the final authority.
+
+The new `CircuitJsonDocumentContext.prepareStructuredClone(document, options?)`
+method has the same options and return shape as `prepare()`. It is intended for
+the exact result of a completed platform structured clone, or for a graph
+created entirely by the toolkit after that boundary. Hosts must continue to use
+`prepare()` for arbitrary caller-owned, cross-realm, proxy-backed, or
+prototype-modified input. The optimization is source-format-neutral and
+requires no example-specific handling.
+
+Measured on the deterministic standard-built-in metadata workload used during
+development, capturing 50,000 populated records fell from about 3.7 seconds to
+about 0.16 seconds. Browser timing for the combined library and ECAD Forge
+release is documented by the application release because network transfer,
+application interaction preparation, and SVG mounting are outside this
+library's ownership boundary.
+
+## Compatibility and API changes
+
+- No public class, package subpath, parameter, or return field is removed or
+  renamed.
+- `CircuitJsonDocumentContext.prepareStructuredClone(document, options?)` is a
+  new opt-in method for the explicit structured-clone provenance contract.
+- Parser, project, renderer, worker, and extension result shapes are unchanged.
+- The existing `prepare()` path remains exact and prototype-independent.
+  Cross-realm and altered-prototype `ArrayBuffer`, `SharedArrayBuffer`, typed
+  array, and `DataView` values, resizable buffers, byte ceilings, and
+  defensive-copy behavior are retained.
+- Proven standard plain-data graphs no longer generate caught exceptions merely
+  to prove that each ordinary node is not binary data.
+
+The new regression coverage pauses on every thrown exception in an isolated
+runtime, proving that a representative proven-standard metadata graph completes
+with zero binary-probe exceptions. Exact-path regressions cover altered and
+cross-realm binary objects plus proxy prototype traps. Existing adversarial and
+full-suite contracts continue to cover hostile accessors, worker parity,
+mutation isolation, and bounded extension ownership.

package/docs/testing.md

@@ -21,6 +21,13 @@ checked-in artifacts. Check mode is read-only. It also preserves upstream
 transform rejection boundaries, including malformed SI-unit strings that the
 upstream schema rejects by throwing instead of returning a failed parse.
 
+`npm test` first runs the benchmark contract in an uncontended process, then
+runs the functional test modules with normal Node test concurrency, and finally
+runs the remaining elapsed-time modules in isolated phases. This preserves
+complete test coverage while preventing unrelated CPU-heavy suites from
+contaminating timing comparisons. `npm test -- <node-test-arguments>` still
+forwards focused arguments directly to the Node test runner.
+
 The schema differential suite samples every upstream union leaf, compares
 required-field failures, exercises transform-owned resistor, capacitor,
 inductor, current-source, and crystal fields, and verifies that a fresh compile
@@ -92,6 +99,13 @@ round-trip behavior, and visible rejection beyond the separate 128 MiB
 extension payload ceiling. A 3 MiB binary regression additionally requires
 byte-backed `Uint8Array` shape, defensive-copy mutation isolation, direct and
 worker parity, bounded elapsed time, and bounded JavaScript heap growth.
+An isolated inspector regression pauses on all thrown exceptions and requires
+ordinary populated records and arrays in an explicitly proven standard-built-in
+graph to complete ownership without exception-driven binary probing. Separate
+exact-path regressions require cross-realm buffers, altered-prototype
+`ArrayBuffer` and `SharedArrayBuffer` values, altered view prototypes, and
+proxy-backed non-binary candidates to retain the prior prototype-independent
+behavior.
 
 Variant-geometry tests also lock rotation-local polygon-plated pad extents and
 pill drill dimensions, independent outer/drill rotations, and every legal

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitjson-toolkit",
-    "version": "1.2.0",
+    "version": "1.3.0",
     "description": "Canonical CircuitJSON parsing, project, rendering, query, manufacturing, simulation, and scene contracts",
     "keywords": [
         "circuitjson",
@@ -54,6 +54,8 @@
         "docs/release-notes-v1.1.1.md",
         "docs/release-notes-v1.1.2.md",
         "docs/release-notes-v1.2.0.md",
+        "docs/release-notes-v1.2.1.md",
+        "docs/release-notes-v1.3.0.md",
         "docs/testing.md",
         "spec",
         "LICENSE",
@@ -66,7 +68,7 @@
         "REUSE.toml"
     ],
     "scripts": {
-        "test": "node --test",
+        "test": "node scripts/run-tests.mjs",
         "format": "prettier --write .",
         "check:format": "prettier --check .",
         "sync:schema": "node scripts/sync-circuit-json-schema.mjs",

package/src/core/context/BinaryDataSnapshot.mjs

@@ -22,6 +22,10 @@ const TYPED_ARRAY_LENGTH = Object.getOwnPropertyDescriptor(
     TYPED_ARRAY_PROTOTYPE,
     'byteLength'
 )?.get
+const TYPED_ARRAY_TAG = Object.getOwnPropertyDescriptor(
+    TYPED_ARRAY_PROTOTYPE,
+    Symbol.toStringTag
+)?.get
 const DATA_VIEW_BUFFER = Object.getOwnPropertyDescriptor(
     DataView.prototype,
     'buffer'
@@ -34,7 +38,40 @@ const DATA_VIEW_LENGTH = Object.getOwnPropertyDescriptor(
     DataView.prototype,
     'byteLength'
 )?.get
+const ARRAY_BUFFER_IS_VIEW = ArrayBuffer.isView
+const ARRAY_IS_ARRAY = Array.isArray
+const OBJECT_GET_PROTOTYPE_OF = Object.getPrototypeOf
+const REFLECT_APPLY = Reflect.apply
+const ARRAY_BUFFER_PROTOTYPE = ArrayBuffer.prototype
+const SHARED_ARRAY_BUFFER_PROTOTYPE =
+    typeof SharedArrayBuffer === 'function' ? SharedArrayBuffer.prototype : null
+const ARRAY_PROTOTYPE = Array.prototype
+const OBJECT_PROTOTYPE = Object.prototype
+const DATE_PROTOTYPE = Date.prototype
+const REGEXP_PROTOTYPE = RegExp.prototype
+const MAP_PROTOTYPE = Map.prototype
+const SET_PROTOTYPE = Set.prototype
 const UINT8_ARRAY_SET = Uint8Array.prototype.set
+const TYPED_ARRAY_CONSTRUCTORS = new Map([
+    ['Int8Array', Int8Array],
+    ['Uint8Array', Uint8Array],
+    ['Uint8ClampedArray', Uint8ClampedArray],
+    ['Int16Array', Int16Array],
+    ['Uint16Array', Uint16Array],
+    ['Int32Array', Int32Array],
+    ['Uint32Array', Uint32Array],
+    ...(typeof globalThis.Float16Array === 'function'
+        ? [['Float16Array', globalThis.Float16Array]]
+        : []),
+    ['Float32Array', Float32Array],
+    ['Float64Array', Float64Array],
+    ...(typeof BigInt64Array === 'function'
+        ? [
+              ['BigInt64Array', BigInt64Array],
+              ['BigUint64Array', BigUint64Array]
+          ]
+        : [])
+])
 
 /**
  * Reads and copies binary platform objects through captured intrinsic slots.
@@ -46,6 +83,104 @@ export class BinaryDataSnapshot {
      * @returns {{ buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, byteLength: number, kind: 'buffer' | 'typed-array' | 'data-view' } | null} Intrinsic binary range.
      */
     static describe(value) {
+        return BinaryDataSnapshot.#describe(value, false)
+    }
+
+    /**
+     * Describes binary data in a graph whose platform built-ins are proven to
+     * have their standard local prototypes.
+     * @param {unknown} value Binary candidate from a normalized graph.
+     * @returns {{ buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, byteLength: number, kind: 'buffer' | 'typed-array' | 'data-view' } | null} Intrinsic binary range.
+     */
+    static describeStandard(value) {
+        return BinaryDataSnapshot.#describe(value, true)
+    }
+
+    /**
+     * Classifies one binary candidate with either exact or proven-standard
+     * raw-buffer handling.
+     * @param {unknown} value Binary candidate.
+     * @param {boolean} standardBuiltins Whether local prototype identity is proven.
+     * @returns {{ buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, byteLength: number, kind: 'buffer' | 'typed-array' | 'data-view' } | null} Intrinsic binary range.
+     */
+    static #describe(value, standardBuiltins) {
+        if (value === null || typeof value !== 'object') return null
+
+        if (BinaryDataSnapshot.#isView(value)) {
+            const typed = BinaryDataSnapshot.#view(
+                value,
+                TYPED_ARRAY_BUFFER,
+                TYPED_ARRAY_OFFSET,
+                TYPED_ARRAY_LENGTH,
+                'typed-array'
+            )
+            if (typed) return typed
+            return BinaryDataSnapshot.#view(
+                value,
+                DATA_VIEW_BUFFER,
+                DATA_VIEW_OFFSET,
+                DATA_VIEW_LENGTH,
+                'data-view'
+            )
+        }
+
+        if (!standardBuiltins) {
+            return BinaryDataSnapshot.#rawBuffer(value)
+        }
+
+        let prototype
+        try {
+            prototype = OBJECT_GET_PROTOTYPE_OF(value)
+        } catch {
+            return null
+        }
+
+        if (prototype === ARRAY_BUFFER_PROTOTYPE) {
+            const byteLength = BinaryDataSnapshot.#callLength(
+                ARRAY_BUFFER_LENGTH,
+                value
+            )
+            return byteLength === null
+                ? null
+                : {
+                      buffer: value,
+                      byteOffset: 0,
+                      byteLength,
+                      kind: 'buffer'
+                  }
+        }
+        if (
+            SHARED_ARRAY_BUFFER_PROTOTYPE &&
+            prototype === SHARED_ARRAY_BUFFER_PROTOTYPE
+        ) {
+            const byteLength = BinaryDataSnapshot.#callLength(
+                SHARED_ARRAY_BUFFER_LENGTH,
+                value
+            )
+            return byteLength === null
+                ? null
+                : {
+                      buffer: value,
+                      byteOffset: 0,
+                      byteLength,
+                      kind: 'buffer'
+                  }
+        }
+        if (BinaryDataSnapshot.#isKnownNonBinary(value, prototype)) {
+            return null
+        }
+
+        // Unknown prototypes can represent genuine buffers from another realm.
+        // Keep intrinsic brand checks as the authority for that uncommon path.
+        return BinaryDataSnapshot.#rawBuffer(value)
+    }
+
+    /**
+     * Applies exact raw ArrayBuffer and SharedArrayBuffer brand getters.
+     * @param {object} value Raw-buffer candidate.
+     * @returns {{ buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: 0, byteLength: number, kind: 'buffer' } | null} Raw buffer range.
+     */
+    static #rawBuffer(value) {
         const arrayBufferLength = BinaryDataSnapshot.#callLength(
             ARRAY_BUFFER_LENGTH,
             value
@@ -71,21 +206,7 @@ export class BinaryDataSnapshot {
             }
         }
 
-        const typed = BinaryDataSnapshot.#view(
-            value,
-            TYPED_ARRAY_BUFFER,
-            TYPED_ARRAY_OFFSET,
-            TYPED_ARRAY_LENGTH,
-            'typed-array'
-        )
-        if (typed) return typed
-        return BinaryDataSnapshot.#view(
-            value,
-            DATA_VIEW_BUFFER,
-            DATA_VIEW_OFFSET,
-            DATA_VIEW_LENGTH,
-            'data-view'
-        )
+        return null
     }
 
     /**
@@ -133,8 +254,7 @@ export class BinaryDataSnapshot {
         if (range.kind === 'buffer') return bytes.buffer
         if (range.kind === 'data-view') return new DataView(bytes.buffer)
 
-        const prototype = Object.getPrototypeOf(value)
-        const Constructor = BinaryDataSnapshot.#typedArrayConstructor(prototype)
+        const Constructor = BinaryDataSnapshot.#typedArrayConstructor(value)
         if (!Constructor || Constructor === Uint8Array) return bytes
         const bytesPerElement = Constructor.BYTES_PER_ELEMENT
         if (bytes.byteLength % bytesPerElement !== 0) return bytes
@@ -150,12 +270,44 @@ export class BinaryDataSnapshot {
     static #callLength(getter, value) {
         if (typeof getter !== 'function') return null
         try {
-            return getter.call(value)
+            return REFLECT_APPLY(getter, value, [])
         } catch {
             return null
         }
     }
 
+    /**
+     * Uses the platform's side-effect-free view brand classifier.
+     * @param {unknown} value Candidate value.
+     * @returns {boolean} Whether the value has ArrayBuffer view slots.
+     */
+    static #isView(value) {
+        try {
+            return REFLECT_APPLY(ARRAY_BUFFER_IS_VIEW, ArrayBuffer, [value])
+        } catch {
+            return false
+        }
+    }
+
+    /**
+     * Returns true for common local containers that cannot be binary objects.
+     * @param {object} value Candidate object.
+     * @param {object | null} prototype Captured prototype.
+     * @returns {boolean} Whether intrinsic buffer probing can be skipped.
+     */
+    static #isKnownNonBinary(value, prototype) {
+        return (
+            ARRAY_IS_ARRAY(value) ||
+            prototype === ARRAY_PROTOTYPE ||
+            prototype === OBJECT_PROTOTYPE ||
+            prototype === null ||
+            prototype === DATE_PROTOTYPE ||
+            prototype === REGEXP_PROTOTYPE ||
+            prototype === MAP_PROTOTYPE ||
+            prototype === SET_PROTOTYPE
+        )
+    }
+
     /**
      * Reads captured intrinsic view slots without ordinary property access.
      * @param {unknown} value View candidate.
@@ -175,9 +327,9 @@ export class BinaryDataSnapshot {
         }
         try {
             return {
-                buffer: bufferGetter.call(value),
-                byteOffset: offsetGetter.call(value),
-                byteLength: lengthGetter.call(value),
+                buffer: REFLECT_APPLY(bufferGetter, value, []),
+                byteOffset: REFLECT_APPLY(offsetGetter, value, []),
+                byteLength: REFLECT_APPLY(lengthGetter, value, []),
                 kind
             }
         } catch {
@@ -186,30 +338,18 @@ export class BinaryDataSnapshot {
     }
 
     /**
-     * Maps a genuine typed-array prototype to its platform constructor.
-     * @param {object | null} prototype Candidate prototype.
+     * Maps a genuine typed array's intrinsic tag to a local constructor.
+     * @param {unknown} value Genuine typed-array value.
      * @returns {Function | null} Matching typed-array constructor.
      */
-    static #typedArrayConstructor(prototype) {
-        const constructors = [
-            Int8Array,
-            Uint8Array,
-            Uint8ClampedArray,
-            Int16Array,
-            Uint16Array,
-            Int32Array,
-            Uint32Array,
-            Float32Array,
-            Float64Array,
-            ...(typeof BigInt64Array === 'function'
-                ? [BigInt64Array, BigUint64Array]
-                : [])
-        ]
-        return (
-            constructors.find(
-                (Constructor) => Constructor.prototype === prototype
-            ) || null
-        )
+    static #typedArrayConstructor(value) {
+        if (typeof TYPED_ARRAY_TAG !== 'function') return null
+        try {
+            const tag = REFLECT_APPLY(TYPED_ARRAY_TAG, value, [])
+            return TYPED_ARRAY_CONSTRUCTORS.get(tag) || null
+        } catch {
+            return null
+        }
     }
 }
 

package/src/core/context/CircuitJsonDocumentContext.mjs

@@ -74,9 +74,31 @@ export class CircuitJsonDocumentContext {
      * @returns {CircuitJsonDocumentContext} Prepared request-scoped context.
      */
     static prepare(input, options = {}) {
+        return CircuitJsonDocumentContext.#prepare(input, options, false)
+    }
+
+    /**
+     * Prepares a document whose platform built-ins were normalized by the
+     * structured-clone algorithm.
+     * @param {unknown} input Structured-cloned document result or existing context.
+     * @param {{ indexes?: unknown }} [options] Requested context options.
+     * @returns {CircuitJsonDocumentContext} Prepared request-scoped context.
+     */
+    static prepareStructuredClone(input, options = {}) {
+        return CircuitJsonDocumentContext.#prepare(input, options, true)
+    }
+
+    /**
+     * Prepares one context with explicit metadata provenance.
+     * @param {unknown} input Document result, CircuitJSON model, or context.
+     * @param {{ indexes?: unknown }} options Requested context options.
+     * @param {boolean} standardBuiltins Whether metadata built-ins have standard local prototypes.
+     * @returns {CircuitJsonDocumentContext} Prepared request-scoped context.
+     */
+    static #prepare(input, options, standardBuiltins) {
         const context = CircuitJsonDocumentContext.#isContext(input)
             ? input
-            : CircuitJsonDocumentContext.#fromInput(input)
+            : CircuitJsonDocumentContext.#fromInput(input, standardBuiltins)
         context.#indexes.ensure(options?.indexes || [])
         return context
     }
@@ -181,15 +203,20 @@ export class CircuitJsonDocumentContext {
     /**
      * Creates one context and establishes a matching immutable model proof.
      * @param {unknown} input Document result or CircuitJSON model.
+     * @param {boolean} standardBuiltins Whether metadata built-ins have standard local prototypes.
      * @returns {CircuitJsonDocumentContext} New context.
      */
-    static #fromInput(input) {
+    static #fromInput(input, standardBuiltins) {
         const document = CircuitJsonDocumentContext.#normalizeDocument(input)
         const validationPasses = CircuitJsonValidationProof.has(document)
             ? 0
             : 1
-        const readonlyDocument =
-            CircuitJsonValidationProof.validateAndAttach(document)
+        const readonlyDocument = CircuitJsonValidationProof.validateAndAttach(
+            document,
+            {
+                standardBuiltins
+            }
+        )
         const model = CircuitJsonDocumentContext.#ownData(
             readonlyDocument,
             'model'