@dreamlake/dreamdb 0.5.0 → 0.5.2

package/web/dreamdb.js

@@ -28,6 +28,22 @@ export 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.
@@ -89,6 +105,36 @@ export 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
@@ -238,6 +284,30 @@ export 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;
+    }
     /**
      * Read a scalar track as a `Map<anchorString, value>`. Single-anchor
      * entries resolve from the track index; multi-anchor entries fetch (and
@@ -250,6 +320,22 @@ export 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
@@ -261,6 +347,40 @@ export 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}
@@ -292,7 +412,10 @@ export 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.
@@ -300,6 +423,35 @@ export 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;
     }
 }
@@ -749,6 +901,24 @@ export function timeBucket(t_start, duration) {
     return BigInt.asUintN(64, ret[0]);
 }
 
+/**
+ * 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}
+ */
+export 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]);
+}
+
 /**
  * Package version — useful for consumers to confirm which build is loaded.
  * @returns {string}
@@ -872,6 +1042,10 @@ function __wbg_get_imports() {
             const ret = arg0.arrayBuffer();
             return ret;
         }, arguments); },
+        __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;
@@ -884,6 +1058,10 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_call_faa0a261f288f846: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
         __wbg_done_54b8da57023b7ed2: function(arg0) {
             const ret = arg0.done;
             return ret;
@@ -895,6 +1073,17 @@ function __wbg_get_imports() {
         __wbg_error_f085d7e62279b703: function(arg0) {
             console.error(arg0);
         },
+        __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;
@@ -911,6 +1100,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;
@@ -965,6 +1158,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 {
@@ -997,18 +1200,50 @@ function __wbg_get_imports() {
             const ret = Symbol.iterator;
             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_new_02d162bc6cf02f60: function() {
             const ret = new Object();
             return ret;
@@ -1047,6 +1282,42 @@ 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_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;
@@ -1088,10 +1359,34 @@ function __wbg_get_imports() {
             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); },
@@ -1099,6 +1394,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;
@@ -1140,7 +1438,7 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 488, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 683, 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;
         },
@@ -1286,11 +1584,59 @@ 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 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) {
@@ -1315,10 +1661,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) {
@@ -1466,9 +1860,16 @@ function __wbg_finalize_init(instance, module) {
     wasmInstance = instance;
     wasm = instance.exports;
     wasmModule = module;
+    cachedBigInt64ArrayMemory0 = null;
     cachedBigUint64ArrayMemory0 = null;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedInt16ArrayMemory0 = null;
+    cachedInt32ArrayMemory0 = null;
+    cachedInt8ArrayMemory0 = null;
+    cachedUint16ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
     wasm.__wbindgen_start();
     return wasm;

package/web/dreamdb_bg.wasm.d.ts

@@ -14,9 +14,11 @@ export const multihashBase32: (a: number, b: number) => [number, number];
 export const multihashHex: (a: number, b: number) => [number, number];
 export const rangeHeader: (a: bigint, b: bigint) => [number, number, number, number];
 export const s3backend_get: (a: number, b: number, c: number, d: any) => any;
+export const s3backend_getStream: (a: number, b: number, c: number) => any;
 export const s3backend_list: (a: number, b: number, c: number) => any;
 export const s3backend_new: (a: number, b: number) => number;
 export const space_connectorBase: (a: number) => [number, number];
+export const space_description: (a: number) => any;
 export const space_fromUri: (a: number, b: number, c: any) => any;
 export const space_history: (a: number, b: number) => any;
 export const space_manifestHash: (a: number) => [number, number];
@@ -24,15 +26,24 @@ export const space_queryHybrid: (a: number, b: number, c: number, d: any) => any
 export const space_queryScalar: (a: number, b: number, c: number, d: number, e: number, f: any) => any;
 export const space_queryText: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
 export const space_queryVector: (a: number, b: number, c: number, d: number, e: number, f: any) => any;
+export const space_readArrayColumn: (a: number, b: number, c: number) => any;
+export const space_readArrayConstant: (a: number, b: number, c: number) => any;
 export const space_readScalarColumn: (a: number, b: any, c: any) => any;
+export const space_readVideoItemRange: (a: number, b: number, c: number, d: any, e: any, f: any) => any;
 export const space_resolveObjectIndex: (a: number, b: any) => any;
+export const space_semanticCacheCapacity: (a: number) => any;
+export const space_semanticCacheStats: (a: number) => any;
+export const space_setSemanticCacheCapacity: (a: number, b: number) => any;
 export const space_timelineId: (a: number) => [number, number, number, number];
-export const space_trackFor: (a: number, b: number, c: number) => any;
-export const space_tracks: (a: number) => any;
+export const space_trackFor: (a: number, b: number, c: number) => [number, number, number];
+export const space_tracks: (a: number) => [number, number, number];
+export const space_videoItemAt: (a: number, b: number, c: number, d: any) => any;
+export const space_videoItemByKey: (a: number, b: number, c: number, d: any) => any;
 export const spatialKeyRoundTrip: (a: number, b: number) => [number, number, number, number];
 export const timeAnchorFromHex: (a: number, b: number) => [bigint, number, number];
 export const timeAnchorHex: (a: bigint) => [number, number];
 export const timeBucket: (a: bigint, b: number, c: number) => [bigint, number, number];
+export const typedArrayDecode: (a: any, b: number, c: number) => [number, number, number];
 export const version: () => [number, number];
 export const writer_appendMany: (a: number, b: any) => any;
 export const writer_commit: (a: number) => any;

package/web.mjs

@@ -9,6 +9,11 @@ import init from './web/dreamdb.js'
 export * from './web/dreamdb.js'
 export { ZERO_SPATIAL_KEY, PresignedBackend, Authoring } from './browser-extras.mjs'
 
+// See browser.mjs — same `write` feature set, same missing method.
+import { Writer as _W } from './web/dreamdb.js'
+import { installIngestCmafStub as _stub } from './browser-extras.mjs'
+_stub(_W)
+
 let started
 /** Fetch and instantiate the wasm. Idempotent; await before anything else. */
 export default function ready(input) {