@dreamlake/dreamdb 0.5.1 → 0.5.3

package/node/dreamdb.cjs

@@ -20,6 +20,20 @@ class Authoring {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_authoring_free(ptr, 0);
     }
+    /**
+     * Add one fixed-shape typed-array Constant.
+     *
+     * `field` is the same `{name, kind:'array', ...}` descriptor accepted by
+     * `create`, with `trackKind:'constant'` and `objectKind:'constant'`.
+     * `payload` is a raw or NPY payload matching that declaration.
+     * @param {any} field
+     * @param {Uint8Array} payload
+     * @returns {Promise<void>}
+     */
+    addArrayConstant(field, payload) {
+        const ret = wasm.authoring_addArrayConstant(this.__wbg_ptr, field, payload);
+        return ret;
+    }
     /**
      * Add an embedding column whose index artifacts already exist.
      *
@@ -43,9 +57,11 @@ class Authoring {
      * @param {boolean} rerank
      * @param {number | null | undefined} version
      * @param {Array<any>} samples
+     * @param {number | null} [bucket_max_bytes]
+     * @param {Uint8Array | null} [embed_spec]
      * @returns {Promise<void>}
      */
-    addEmbeddingLayer(name, parent_field, dim, algorithm, spatial_index, compressor, rerank, version, samples) {
+    addEmbeddingLayer(name, parent_field, dim, algorithm, spatial_index, compressor, rerank, version, samples, bucket_max_bytes, embed_spec) {
         const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(parent_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -56,7 +72,9 @@ class Authoring {
         const len3 = WASM_VECTOR_LEN;
         const ptr4 = passStringToWasm0(compressor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len4 = WASM_VECTOR_LEN;
-        const ret = wasm.authoring_addEmbeddingLayer(this.__wbg_ptr, ptr0, len0, ptr1, len1, dim, ptr2, len2, ptr3, len3, ptr4, len4, rerank, isLikeNone(version) ? Number.MAX_SAFE_INTEGER : (version) >>> 0, samples);
+        var ptr5 = isLikeNone(embed_spec) ? 0 : passArray8ToWasm0(embed_spec, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        const ret = wasm.authoring_addEmbeddingLayer(this.__wbg_ptr, ptr0, len0, ptr1, len1, dim, ptr2, len2, ptr3, len3, ptr4, len4, rerank, isLikeNone(version) ? Number.MAX_SAFE_INTEGER : (version) >>> 0, samples, isLikeNone(bucket_max_bytes) ? Number.MAX_SAFE_INTEGER : (bucket_max_bytes) >>> 0, ptr5, len5);
         return ret;
     }
     /**
@@ -109,6 +127,18 @@ class Authoring {
         const ret = wasm.authoring_addScalarLayer(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, samples);
         return ret;
     }
+    /**
+     * Append `[anchor, vector]` pairs, adopting a raw graph as Fresh Vamana.
+     * @param {string} field
+     * @param {Array<any>} samples
+     * @returns {Promise<any>}
+     */
+    appendGraphNodes(field, samples) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.authoring_appendGraphNodes(this.__wbg_ptr, ptr0, len0, samples);
+        return ret;
+    }
     /**
      * Fork the current manifest to a new ref name.
      * @param {string} new_name
@@ -120,6 +150,31 @@ class Authoring {
         const ret = wasm.authoring_branch(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Merge one or more branches into this ref. Returns the new manifest hash.
+     * Build a raw Vamana field. Samples are `[anchor, vector]` pairs; anchors
+     * use the same lossless representation as addEmbeddingLayer.
+     * @param {string} name
+     * @param {string} parent_field
+     * @param {number} dim
+     * @param {Array<any>} samples
+     * @param {number} r
+     * @param {Uint8Array} seed
+     * @param {Uint8Array | null} [embed_spec]
+     * @returns {Promise<void>}
+     */
+    buildGraphIndex(name, parent_field, dim, samples, r, seed, embed_spec) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(parent_field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(embed_spec) ? 0 : passArray8ToWasm0(embed_spec, wasm.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm.authoring_buildGraphIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1, dim, samples, r, ptr2, len2, ptr3, len3);
+        return ret;
+    }
     /**
      * Collapse per-cell fragments. Returns
      * `{cellsExamined, cellsCompacted, fragmentsCollapsed, manifest?}`.
@@ -139,6 +194,33 @@ class Authoring {
         const ret = wasm.authoring_compact(this.__wbg_ptr, ptr0, len0, threshold, max_cells);
         return ret;
     }
+    /**
+     * Compress a raw graph with canonical VectorCompressor CBOR. The raw
+     * lineage is retained; rerank selects exact scoring of the candidate pool.
+     * @param {string} field
+     * @param {Uint8Array} compressor
+     * @param {boolean} rerank
+     * @returns {Promise<void>}
+     */
+    compressGraphIndex(field, compressor, rerank) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(compressor, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.authoring_compressGraphIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1, rerank);
+        return ret;
+    }
+    /**
+     * Caller-driven region consolidation; does not erase tombstones or ids.
+     * @param {string} field
+     * @returns {Promise<any>}
+     */
+    consolidateGraph(field) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.authoring_consolidateGraph(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * Create a new dataset and publish `refs/<name>`.
      *
@@ -186,7 +268,6 @@ class Authoring {
         return ret;
     }
     /**
-     * Merge one or more branches into this ref. Returns the new manifest hash.
      * @param {string[]} branches
      * @returns {Promise<string>}
      */
@@ -247,6 +328,68 @@ class Authoring {
 if (Symbol.dispose) Authoring.prototype[Symbol.dispose] = Authoring.prototype.free;
 exports.Authoring = Authoring;
 
+class GeometryReader {
+    static __wrap(ptr) {
+        const obj = Object.create(GeometryReader.prototype);
+        obj.__wbg_ptr = ptr;
+        GeometryReaderFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeometryReaderFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_geometryreader_free(ptr, 0);
+    }
+    /**
+     * Returns only the new suffix at this total logical byte budget.
+     * @param {any} key
+     * @param {any} budget
+     * @returns {Promise<Uint8Array>}
+     */
+    extendCellPrefix(key, budget) {
+        const ret = wasm.geometryreader_extendCellPrefix(this.__wbg_ptr, key, budget);
+        return ret;
+    }
+    /**
+     * Declaration plus cells/LODs; no payload transfer. u64 values are BigInt.
+     * @returns {any}
+     */
+    metadata() {
+        const ret = wasm.geometryreader_metadata(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} level
+     * @returns {Promise<Uint8Array>}
+     */
+    readMeshLod(level) {
+        const ret = wasm.geometryreader_readMeshLod(this.__wbg_ptr, level);
+        return ret;
+    }
+    /**
+     * @param {any} min
+     * @param {any} max
+     * @returns {Array<any>}
+     */
+    selectCells(min, max) {
+        const ret = wasm.geometryreader_selectCells(this.__wbg_ptr, min, max);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) GeometryReader.prototype[Symbol.dispose] = GeometryReader.prototype.free;
+exports.GeometryReader = GeometryReader;
+
 /**
  * A `fetch`-backed backend rooted at a base URL.
  */
@@ -275,6 +418,22 @@ class S3Backend {
         const ret = wasm.s3backend_get(this.__wbg_ptr, ptr0, len0, _opts);
         return ret;
     }
+    /**
+     * Stream `path` without first aggregating the response in wasm memory.
+     *
+     * Returning the length beside the browser stream satisfies the optional
+     * `Backend.getStream` contract. Older injected backends that implement
+     * only [`Self::get`] remain compatible, but cannot claim bounded memory
+     * for historical oversized inline Track reads.
+     * @param {string} path
+     * @returns {Promise<any>}
+     */
+    getStream(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.s3backend_getStream(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * List object paths under `prefix`. Stub (returns empty); the current
      * consumer read paths don't require listing.
@@ -320,6 +479,29 @@ class Space {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_space_free(ptr, 0);
     }
+    /**
+     * Validate all referenced Items, including tombstoned payloads.
+     * @param {string} field
+     * @returns {Promise<bigint>}
+     */
+    auditArrayField(field) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_auditArrayField(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Validate all graph pages and, when declared, exact-source correspondence.
+     * The returned count is exactly representable (GraphIndex node_count is u32).
+     * @param {string} field
+     * @returns {Promise<number>}
+     */
+    auditGraphIndex(field) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_auditGraphIndex(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * The base URL objects are fetched relative to (consumers build their own
      * object URLs from this — e.g. `dreamdb-demo`'s track readers).
@@ -337,6 +519,36 @@ class Space {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The Space's human-readable description, or `undefined` when none is set.
+     *
+     * The read half of `Authoring.setDescription` (#129). It lives here rather
+     * than on `Authoring` because that type is `write-full` and so exists only
+     * in the Node build — a description is metadata a READER wants, and
+     * `Space` is the surface all three build targets share.
+     *
+     * `async` although `Dataset::description` is not: the value comes from the
+     * Dataset this Space opens lazily at the Manifest hash already pinned by
+     * this Space, so the first call may perform that open without re-resolving
+     * a source Ref.
+     *
+     * Deliberately routed through `Dataset::description` rather than read out
+     * of `self.manifest`'s registry, which would be shorter and would also
+     * serve the cached decoded Manifest. `Dataset::recover_meta` is not a prefix
+     * filter: it accepts the legacy `vortex.*` namespace as well as
+     * `dreamdb.*`, canonicalises, and drops structural keys. Matching
+     * `dreamdb.description` here would silently return nothing for a legacy
+     * Space whose description is on disk and readable from Rust — the exact
+     * defect `recover_meta`'s own comment records.
+     *
+     * `Option<String>` marshals to `string | undefined`, NOT to `""`. An unset
+     * description and an empty one stay distinguishable across the boundary.
+     * @returns {Promise<string | undefined>}
+     */
+    description() {
+        const ret = wasm.space_description(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Open a Space from a `.../refs/<name>` or `.../manifests/<hash>` URI,
      * resolving the ref (if any) and loading the manifest. If `backend` is
@@ -353,6 +565,17 @@ class Space {
         const ret = wasm.space_fromUri(ptr0, len0, backend);
         return ret;
     }
+    /**
+     * Read at this pinned Manifest. Returns null for never-created keys;
+     * deleted keys retain metadata with sample=null. Integer keys and anchors
+     * are BigInt; sample values use the Writer's tagged field shapes.
+     * @param {any} key
+     * @returns {Promise<any>}
+     */
+    getEntity(key) {
+        const ret = wasm.space_getEntity(this.__wbg_ptr, key);
+        return ret;
+    }
     /**
      * Walk the manifest DAG from HEAD, up to `max_depth` entries. Each entry:
      * `{ manifestHash, ts, writer, tracks: [{modality, address}] }`.
@@ -379,6 +602,18 @@ class Space {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Open one pinned geometry Item. Missing/deleted anchors return undefined.
+     * @param {string} field
+     * @param {any} anchor
+     * @returns {Promise<GeometryReader | undefined>}
+     */
+    openGeometryItem(field, anchor) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_openGeometryItem(this.__wbg_ptr, ptr0, len0, anchor);
+        return ret;
+    }
     /**
      * Hybrid search fusing a lexical (BM25) sub-query and a dense (vector)
      * sub-query per spec/0015 §5/§6. Returns the fused `[{ anchor, score }]`
@@ -401,8 +636,8 @@ class Space {
      * ```
      *
      * Delegates to the real (tested) `dreamdb-dataset::Dataset::query_hybrid`.
-     * (v0 does not expose the optional scalar pre/post-filter; it runs with no
-     * scalar gate.)
+     * Optional `scalarField` / `scalarOp` / `scalarValue` properties select
+     * the same scalar pre/post-filter planner used by the native API.
      * @param {Float32Array} vector
      * @param {any} opts
      * @returns {Promise<Array<any>>}
@@ -413,6 +648,21 @@ class Space {
         const ret = wasm.space_queryHybrid(this.__wbg_ptr, ptr0, len0, opts);
         return ret;
     }
+    /**
+     * Hybrid query with an observable `{hits, trace}` result. `opts` accepts
+     * `maxLatencyMs`, `costModel`, and the optional scalar triple
+     * `scalarField`/`scalarOp`/`scalarValue` in addition to `queryHybrid`'s
+     * existing properties.
+     * @param {Float32Array} vector
+     * @param {any} opts
+     * @returns {Promise<any>}
+     */
+    queryHybridPlanned(vector, opts) {
+        const ptr0 = passArrayF32ToWasm0(vector, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_queryHybridPlanned(this.__wbg_ptr, ptr0, len0, opts);
+        return ret;
+    }
     /**
      * Scalar-index lookup: every anchor whose `field` satisfies `op value`
      * (spec/0011). Returns a `BigUint64Array`-style `Array` of anchors,
@@ -486,6 +736,43 @@ class Space {
         const ret = wasm.space_queryVector(this.__wbg_ptr, ptr0, len0, ptr1, len1, opts);
         return ret;
     }
+    /**
+     * Read an Event/Unbucketed or Continuous/TimeBatch typed-array field as
+     * `Map<anchorString, {values, shape, ...}>`.
+     * @param {string} field
+     * @returns {Promise<Map<any, any>>}
+     */
+    readArrayColumn(field) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_readArrayColumn(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Read a typed-array Constant and decode it to a JS TypedArray plus its
+     * authoritative shape and semantic metadata.
+     * @param {string} field
+     * @returns {Promise<any>}
+     */
+    readArrayConstant(field) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_readArrayConstant(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Point read; full-u64 BigInt anchors are supported. Returned components
+     * are owned typed arrays (one Item's bytes), never unaligned aliases.
+     * @param {string} field
+     * @param {any} anchor
+     * @returns {Promise<any>}
+     */
+    readArrayItem(field, anchor) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_readArrayItem(this.__wbg_ptr, ptr0, len0, anchor);
+        return ret;
+    }
     /**
      * Read a scalar track as a `Map<anchorString, value>`. Single-anchor
      * entries resolve from the track index; multi-anchor entries fetch (and
@@ -498,6 +785,22 @@ class Space {
         const ret = wasm.space_readScalarColumn(this.__wbg_ptr, track, _opts);
         return ret;
     }
+    /**
+     * Fetch verified initialization and complete Fragments overlapping one
+     * item-relative half-open range. This materializes the selected bytes; it
+     * is not a streaming API.
+     * @param {string} field
+     * @param {Uint8Array} item_key
+     * @param {any} relative_start_ns
+     * @param {any} relative_end_ns
+     * @returns {Promise<any>}
+     */
+    readVideoItemRange(field, item_key, relative_start_ns, relative_end_ns) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_readVideoItemRange(this.__wbg_ptr, ptr0, len0, item_key, relative_start_ns, relative_end_ns);
+        return ret;
+    }
     /**
      * Fetch a track object and return its `object_index` (array of CBOR
      * entries). Inline indexes only — paged indexes are not resolved (matching
@@ -509,6 +812,40 @@ class Space {
         const ret = wasm.space_resolveObjectIndex(this.__wbg_ptr, track);
         return ret;
     }
+    /**
+     * Semantic-cache capacity in bytes (spec/0006 §3.6). Default 1 GiB.
+     * @returns {Promise<number>}
+     */
+    semanticCacheCapacity() {
+        const ret = wasm.space_semanticCacheCapacity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Semantic-cache occupancy as `{ entries, bytesUsed, maxBytes }`.
+     * @returns {Promise<object>}
+     */
+    semanticCacheStats() {
+        const ret = wasm.space_semanticCacheStats(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Set the semantic-cache capacity in bytes, evicting down to it before
+     * returning. Returns the bytes evicted. `0` disables the cache.
+     *
+     * An index whose accounted size exceeds the cap is not cached and is
+     * re-fetched on every query, reported honestly as a miss. The default is
+     * not raised globally to suit one corpus.
+     *
+     * Sizing is workload- and architecture-dependent, and figures measured on
+     * a 64-bit host do NOT carry over here: `usize` is 32 bits on `wasm32`, so
+     * every offset and length inside a decoded index accounts differently.
+     * @param {number} n_bytes
+     * @returns {Promise<number>}
+     */
+    setSemanticCacheCapacity(n_bytes) {
+        const ret = wasm.space_setSemanticCacheCapacity(this.__wbg_ptr, n_bytes);
+        return ret;
+    }
     /**
      * Base32 hash of the manifest's first timeline.
      * @returns {string}
@@ -540,7 +877,10 @@ class Space {
         const ptr0 = passStringToWasm0(key_or_modality, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.space_trackFor(this.__wbg_ptr, ptr0, len0);
-        return ret;
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * List resolved tracks from this manifest.
@@ -548,6 +888,35 @@ class Space {
      */
     tracks() {
         const ret = wasm.space_tracks(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Look up the logical VideoItem containing one absolute Timeline anchor
+     * without fetching media. Exact nanosecond values are returned as bigint.
+     * @param {string} field
+     * @param {any} anchor_ns
+     * @returns {Promise<any>}
+     */
+    videoItemAt(field, anchor_ns) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_videoItemAt(this.__wbg_ptr, ptr0, len0, anchor_ns);
+        return ret;
+    }
+    /**
+     * Look up one logical VideoItem by its stable opaque key without fetching
+     * initialization or Fragment bytes.
+     * @param {string} field
+     * @param {Uint8Array} item_key
+     * @returns {Promise<any>}
+     */
+    videoItemByKey(field, item_key) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.space_videoItemByKey(this.__wbg_ptr, ptr0, len0, item_key);
         return ret;
     }
 }
@@ -574,6 +943,17 @@ class Writer {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_writer_free(ptr, 0);
     }
+    /**
+     * Atomically hot-append a complete Sample batch. Embeddings retain v1;
+     * scalar/text values use v2. Identified embeddings require embeddingSpecs.
+     * @param {Array<any>} samples
+     * @param {object | null} [embedding_specs]
+     * @returns {Promise<number>}
+     */
+    appendHot(samples, embedding_specs) {
+        const ret = wasm.writer_appendHot(this.__wbg_ptr, samples, isLikeNone(embedding_specs) ? 0 : addToExternrefTable0(embedding_specs));
+        return ret;
+    }
     /**
      * Append records and commit in one call.
      *
@@ -592,6 +972,17 @@ class Writer {
         const ret = wasm.writer_appendMany(this.__wbg_ptr, samples);
         return ret;
     }
+    /**
+     * Append records with a field-to-`spec_id` map for identified embeddings.
+     * Values are full canonical base32 multihashes.
+     * @param {Array<any>} samples
+     * @param {object} embedding_specs
+     * @returns {Promise<number>}
+     */
+    appendManyWithSpecs(samples, embedding_specs) {
+        const ret = wasm.writer_appendManyWithSpecs(this.__wbg_ptr, samples, embedding_specs);
+        return ret;
+    }
     /**
      * Flush staged entries and publish a new manifest.
      *
@@ -605,6 +996,38 @@ class Writer {
         const ret = wasm.writer_commit(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Producer policy only: TTL is evaluated on append, not by a timer.
+     * @param {number} flush_threshold
+     * @param {number} ttl_seconds
+     */
+    configureHotShard(flush_threshold, ttl_seconds) {
+        const ret = wasm.writer_configureHotShard(this.__wbg_ptr, flush_threshold, ttl_seconds);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create a never-used key. Sample uses appendMany's tagged fields, no anchor.
+     * @param {any} key
+     * @param {object} sample
+     * @param {object | null} [embedding_specs]
+     * @returns {Promise<object>}
+     */
+    createEntity(key, sample, embedding_specs) {
+        const ret = wasm.writer_createEntity(this.__wbg_ptr, key, sample, isLikeNone(embedding_specs) ? 0 : addToExternrefTable0(embedding_specs));
+        return ret;
+    }
+    /**
+     * Delete exactly a live revision, retaining its key and stable identity.
+     * @param {any} key
+     * @param {Uint8Array} expected
+     * @returns {Promise<object>}
+     */
+    deleteEntity(key, expected) {
+        const ret = wasm.writer_deleteEntity(this.__wbg_ptr, key, expected);
+        return ret;
+    }
     /**
      * Tombstone records by anchor. Returns the new manifest hash.
      * @param {BigUint64Array} anchors
@@ -619,6 +1042,73 @@ class Writer {
         const ret = wasm.writer_deleteRecords(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return ret;
     }
+    /**
+     * Enable one exact typed entity namespace: string, bytes or int.
+     * @param {string} key_kind
+     * @returns {Promise<void>}
+     */
+    enableEntityKeys(key_kind) {
+        const ptr0 = passStringToWasm0(key_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_enableEntityKeys(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Explicitly fold every pending hot field into cold Tracks in one publish.
+     * @returns {Promise<void>}
+     */
+    flushHot() {
+        const ret = wasm.writer_flushHot(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Ingest a pre-fragmented CMAF (fragmented-MP4) video into a Video field
+     * as a `spec/0007` §5 media Track — the thing that makes a video Track
+     * time-seekable and MSE-playable rather than one opaque blob.
+     *
+     * ```js
+     * const out = await writer.ingestCmaf('video', initBytes, [
+     *   [frag0, 0n, 2_000_000_000n],
+     *   [frag1, 2_000_000_000n, 4_000_000_000n],
+     * ])
+     * ```
+     *
+     * - `init` is the initialization segment (`ftyp`+`moov`).
+     * - each fragment is `[Uint8Array, tStartNs, tEndNs]`, half-open, already
+     *   offset to the timeline anchor the caller wants. Pass `bigint`s:
+     *   wall-clock nanosecond anchors are far past `Number.MAX_SAFE_INTEGER`
+     *   and a rounded `tStart` writes the fragment into a 60 s bucket that
+     *   does not match the address it is indexed at.
+     *
+     * Calling it again on the SAME field APPENDS (one episode per call on a
+     * shared timeline) and reuses the track's existing init segment; a clip
+     * whose init differs — different codec, resolution, fps or audio config —
+     * is refused, because a Track carries exactly one init segment and the
+     * mismatch would produce fragments that decode against the wrong one.
+     *
+     * Returns `{field, modality, initHash, fragmentCount, coverage: [bigint,
+     * bigint], trackHash, manifestHash}`. `coverage` is `bigint` for the
+     * reason above; `fragmentCount` is the track's total after the append,
+     * not the number passed in.
+     *
+     * **Node only** (`write-full`). This takes every fragment's bytes as an
+     * argument, so peak memory is the whole clip; the native path form streams
+     * fragment-by-fragment off disk, which wasm32 cannot do because it has no
+     * filesystem. Fragmenting a multi-GB source inside a browser tab's 32-bit
+     * address space is not a workflow worth pretending to support.
+     * @param {string} field
+     * @param {Uint8Array} init
+     * @param {Array<any>} fragments
+     * @returns {Promise<any>}
+     */
+    ingestCmaf(field, init, fragments) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(init, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_ingestCmaf(this.__wbg_ptr, ptr0, len0, ptr1, len1, fragments);
+        return ret;
+    }
     /**
      * Current manifest hash, base32.
      * @returns {string}
@@ -663,6 +1153,36 @@ class Writer {
         const ret = wasm.writer_open(ptr0, len0, backend);
         return ret;
     }
+    /**
+     * Publish prequantized fixed-stride records. Coordinates is
+     * {origin:[x,y,z],step:[x,y,z],units:string}; depth is 0..16.
+     * @param {string} field
+     * @param {any} anchor
+     * @param {any} coordinates
+     * @param {any} depth
+     * @param {Uint8Array} records
+     * @returns {Promise<string>}
+     */
+    publishGeometryCells(field, anchor, coordinates, depth, records) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_publishGeometryCells(this.__wbg_ptr, ptr0, len0, anchor, coordinates, depth, records);
+        return ret;
+    }
+    /**
+     * Each level is {errorGrid,vertices,triangles,bytes:Uint8Array}.
+     * @param {string} field
+     * @param {any} anchor
+     * @param {any} coordinates
+     * @param {Array<any>} levels
+     * @returns {Promise<string>}
+     */
+    publishGeometryMesh(field, anchor, coordinates, levels) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_publishGeometryMesh(this.__wbg_ptr, ptr0, len0, anchor, coordinates, levels);
+        return ret;
+    }
     /**
      * The ref this writer advances.
      * @returns {string}
@@ -690,6 +1210,30 @@ class Writer {
         const ret = wasm.writer_snapshot(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * Replace only a live revision, atomically hiding its old physical row.
+     * @param {any} key
+     * @param {object} sample
+     * @param {Uint8Array} expected
+     * @param {object | null} [embedding_specs]
+     * @returns {Promise<object>}
+     */
+    supersedeEntity(key, sample, expected, embedding_specs) {
+        const ret = wasm.writer_supersedeEntity(this.__wbg_ptr, key, sample, expected, isLikeNone(embedding_specs) ? 0 : addToExternrefTable0(embedding_specs));
+        return ret;
+    }
+    /**
+     * Create with no expected token, or replace/restore exactly that revision.
+     * @param {any} key
+     * @param {object} sample
+     * @param {Uint8Array | null} [expected]
+     * @param {object | null} [embedding_specs]
+     * @returns {Promise<object>}
+     */
+    upsertEntity(key, sample, expected, embedding_specs) {
+        const ret = wasm.writer_upsertEntity(this.__wbg_ptr, key, sample, isLikeNone(expected) ? 0 : addToExternrefTable0(expected), isLikeNone(embedding_specs) ? 0 : addToExternrefTable0(embedding_specs));
+        return ret;
+    }
 }
 if (Symbol.dispose) Writer.prototype[Symbol.dispose] = Writer.prototype.free;
 exports.Writer = Writer;
@@ -1013,6 +1557,25 @@ function timeBucket(t_start, duration) {
 }
 exports.timeBucket = timeBucket;
 
+/**
+ * Decode one spec/0025 item using the same declaration and payload path as
+ * `Space.readArrayColumn`, without requiring storage IO. This is the SDK's
+ * pure conformance entry point for language-neutral vectors.
+ * @param {any} item_type
+ * @param {Uint8Array} payload
+ * @returns {any}
+ */
+function typedArrayDecode(item_type, payload) {
+    const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.typedArrayDecode(item_type, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+exports.typedArrayDecode = typedArrayDecode;
+
 /**
  * Package version — useful for consumers to confirm which build is loaded.
  * @returns {string}
@@ -1102,6 +1665,10 @@ function __wbg_get_imports() {
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
+        __wbg___wbindgen_is_string_dde0fd9020db4434: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -1142,6 +1709,10 @@ function __wbg_get_imports() {
             const ret = Authoring.__wrap(arg0);
             return ret;
         },
+        __wbg_body_acbb5ec9cd18657f: function(arg0) {
+            const ret = arg0.body;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
         __wbg_call_084ee3e860ee9f92: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             const ret = arg0.call(arg1, arg2, arg3, arg4);
             return ret;
@@ -1158,6 +1729,10 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2, arg3);
             return ret;
         }, arguments); },
+        __wbg_crypto_38df2bab126b63dc: function(arg0) {
+            const ret = arg0.crypto;
+            return ret;
+        },
         __wbg_done_54b8da57023b7ed2: function(arg0) {
             const ret = arg0.done;
             return ret;
@@ -1169,6 +1744,28 @@ function __wbg_get_imports() {
         __wbg_error_f085d7e62279b703: function(arg0) {
             console.error(arg0);
         },
+        __wbg_from_fa561fa561dc8031: function(arg0) {
+            const ret = Array.from(arg0);
+            return ret;
+        },
+        __wbg_geometryreader_new: function(arg0) {
+            const ret = GeometryReader.__wrap(arg0);
+            return ret;
+        },
+        __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
+            arg0.getRandomValues(arg1);
+        }, arguments); },
+        __wbg_getReader_c8a7370df46b86f6: function(arg0) {
+            const ret = arg0.getReader();
+            return ret;
+        },
+        __wbg_get_0b3f3bb74d16b7ad: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg1.get(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_get_3e9a707ab7d352eb: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
@@ -1185,6 +1782,10 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_headers_18f39f24d3837dc1: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
         __wbg_headers_4cfb0c75793d7a8d: function(arg0) {
             const ret = arg0.headers;
             return ret;
@@ -1239,6 +1840,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_ReadableStream_9a3d74fc91aa9c55: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof ReadableStream;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Response_ecfc823e8fb354e2: function(arg0) {
             let result;
             try {
@@ -1271,18 +1882,58 @@ function __wbg_get_imports() {
             const ret = Symbol.iterator;
             return ret;
         },
+        __wbg_keys_682010b680c9b1f8: function(arg0) {
+            const ret = Object.keys(arg0);
+            return ret;
+        },
+        __wbg_length_0adf2f3c5da33087: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_13e61aa81636ec86: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_length_1c094f6c75753f5f: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_2591a0f4f659a55c: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_length_3a1b902b6cde9e2c: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_56fcd3e2b7e0299d: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_length_911750a64e2f4f88: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_a4365e969857a2c9: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_c7ce929623e7a230: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_dc239675ea61db1b: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_length_efe2271ed86b56cc: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
+            const ret = arg0.msCrypto;
+            return ret;
+        },
         __wbg_new_02d162bc6cf02f60: function() {
             const ret = new Object();
             return ret;
@@ -1303,6 +1954,10 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
         },
+        __wbg_new_from_slice_7a419f18ea6472bf: function(arg0, arg1) {
+            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_new_typed_c072c4ce9a2a0cdf: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -1321,6 +1976,46 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
+        __wbg_new_with_length_1278c16a5c5b497f: function(arg0) {
+            const ret = new Float64Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_22e34f6824b87f53: function(arg0) {
+            const ret = new BigUint64Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_58dc420af34edb59: function(arg0) {
+            const ret = new Float32Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_662ce8fda8456c6c: function(arg0) {
+            const ret = new Uint16Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_6ab0b677ba8ffdc4: function(arg0) {
+            const ret = new BigInt64Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_78398b95fa59feae: function(arg0) {
+            const ret = new Int32Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_96785292f4aab914: function(arg0) {
+            const ret = new Int8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_99887c91eae4abab: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_bab0ddb25b1a2cc7: function(arg0) {
+            const ret = new Int16Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_new_with_length_f128f2c16ad4f906: function(arg0) {
+            const ret = new Uint32Array(arg0 >>> 0);
+            return ret;
+        },
         __wbg_new_with_str_and_init_ffe9977c986ea039: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
@@ -1333,6 +2028,10 @@ function __wbg_get_imports() {
             const ret = arg0.next();
             return ret;
         }, arguments); },
+        __wbg_node_84ea875411254db1: function(arg0) {
+            const ret = arg0.node;
+            return ret;
+        },
         __wbg_now_81363d44c96dd239: function() {
             const ret = Date.now();
             return ret;
@@ -1341,6 +2040,10 @@ function __wbg_get_imports() {
             const ret = arg0.ok;
             return ret;
         },
+        __wbg_process_44c7a14e11e9f69e: function(arg0) {
+            const ret = arg0.process;
+            return ret;
+        },
         __wbg_prototypesetcall_5f9bdc8d75e07276: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
@@ -1358,14 +2061,45 @@ function __wbg_get_imports() {
         __wbg_queueMicrotask_b39ea83c7f01971a: function(arg0) {
             queueMicrotask(arg0);
         },
+        __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
+            arg0.randomFillSync(arg1);
+        }, arguments); },
+        __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
+            const ret = module.require;
+            return ret;
+        }, arguments); },
         __wbg_resolve_d17db9352f5a220e: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
         },
+        __wbg_set_517261bc500078e6: function(arg0, arg1, arg2) {
+            arg0.set(getArrayI16FromWasm0(arg1, arg2));
+        },
+        __wbg_set_5bffd0c00e65c280: function(arg0, arg1, arg2) {
+            arg0.set(getArrayF64FromWasm0(arg1, arg2));
+        },
+        __wbg_set_5d860a0c0949a838: function(arg0, arg1, arg2) {
+            arg0.set(getArrayF32FromWasm0(arg1, arg2));
+        },
+        __wbg_set_8c4bf3c22a64e1df: function(arg0, arg1, arg2) {
+            arg0.set(getArrayI8FromWasm0(arg1, arg2));
+        },
+        __wbg_set_90474108ec025ba3: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU32FromWasm0(arg1, arg2));
+        },
+        __wbg_set_943e5a384dda27eb: function(arg0, arg1, arg2) {
+            arg0.set(getArrayI32FromWasm0(arg1, arg2));
+        },
         __wbg_set_a0e911be3da02782: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_set_c9acd362199fe8b8: function(arg0, arg1, arg2) {
+            arg0.set(getArrayI64FromWasm0(arg1, arg2));
+        },
+        __wbg_set_d4121491cc61da07: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU16FromWasm0(arg1, arg2));
+        },
         __wbg_set_d57e5106f0271787: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
@@ -1373,6 +2107,9 @@ function __wbg_get_imports() {
             const ret = arg0.set(arg1, arg2);
             return ret;
         },
+        __wbg_set_fb3115a057014152: function(arg0, arg1, arg2) {
+            arg0.set(getArrayU64FromWasm0(arg1, arg2));
+        },
         __wbg_space_new: function(arg0) {
             const ret = Space.__wrap(arg0);
             return ret;
@@ -1397,6 +2134,10 @@ function __wbg_get_imports() {
             const ret = arg0.status;
             return ret;
         },
+        __wbg_subarray_7c6a0da8f3b4a1ba: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
         __wbg_then_837494e384b37459: function(arg0, arg1) {
             const ret = arg0.then(arg1);
             return ret;
@@ -1409,12 +2150,16 @@ function __wbg_get_imports() {
             const ret = arg0.value;
             return ret;
         },
+        __wbg_versions_276b2795b1c6a219: function(arg0) {
+            const ret = arg0.versions;
+            return ret;
+        },
         __wbg_writer_new: function(arg0) {
             const ret = Writer.__wrap(arg0);
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 580, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 948, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_f7c54996eb9137d9___convert__closures_____invoke___wasm_bindgen_f7c54996eb9137d9___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_f7c54996eb9137d9___JsError___true_);
             return ret;
         },
@@ -1434,16 +2179,21 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+            const ret = getArrayU8FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_cast_0000000000000006: function(arg0) {
+        __wbindgen_cast_0000000000000007: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return ret;
         },
-        __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
             var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_free(arg0, arg1 * 4, 4);
             // Cast intrinsic for `Vector(NamedExternref("string")) -> Externref`.
@@ -1480,6 +2230,9 @@ function wasm_bindgen_f7c54996eb9137d9___convert__closures_____invoke___js_sys_a
 const AuthoringFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_authoring_free(ptr, 1));
+const GeometryReaderFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_geometryreader_free(ptr, 1));
 const S3BackendFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_s3backend_free(ptr, 1));
@@ -1570,6 +2323,31 @@ function getArrayF32FromWasm0(ptr, len) {
     return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
 
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayI16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayI64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigInt64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayI8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 function getArrayJsValueFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     const mem = getDataViewMemory0();
@@ -1581,11 +2359,34 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigInt64ArrayMemory0 = null;
+function getBigInt64ArrayMemory0() {
+    if (cachedBigInt64ArrayMemory0 === null || cachedBigInt64ArrayMemory0.byteLength === 0) {
+        cachedBigInt64ArrayMemory0 = new BigInt64Array(wasm.memory.buffer);
+    }
+    return cachedBigInt64ArrayMemory0;
+}
+
 let cachedBigUint64ArrayMemory0 = null;
 function getBigUint64ArrayMemory0() {
     if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
@@ -1610,10 +2411,58 @@ function getFloat32ArrayMemory0() {
     return cachedFloat32ArrayMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+let cachedInt16ArrayMemory0 = null;
+function getInt16ArrayMemory0() {
+    if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
+        cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
+    }
+    return cachedInt16ArrayMemory0;
+}
+
+let cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+
+let cachedInt8ArrayMemory0 = null;
+function getInt8ArrayMemory0() {
+    if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
+        cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
+    }
+    return cachedInt8ArrayMemory0;
+}
+
 function getStringFromWasm0(ptr, len) {
     return decodeText(ptr >>> 0, len);
 }
 
+let cachedUint16ArrayMemory0 = null;
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
     if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {