@dreamlake/dreamdb 0.3.0 → 0.4.0

package/{dreamdb_bg.js → browser/dreamdb_bg.js}

@@ -163,6 +163,35 @@ export class Space {
         const ret = wasm.space_queryHybrid(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,
+     * tombstone-suppressed, sorted ascending and deduped.
+     *
+     * This is the expansion half of a compact lexical index. A BM25 index
+     * built over a scalar field's DISTINCT values returns one representative
+     * anchor per matched value; resolving that value back to *every* record
+     * carrying it is a scalar-index lookup, not a text-index concern. Keeping
+     * the split this way is what lets the text index stay small enough to
+     * load in a browser — indexing one document per record instead produced a
+     * 406 MB object for ~1,700 distinct strings.
+     *
+     * `op` is one of `==`, `!=`, `<`, `<=`, `>`, `>=`. `value` may be a
+     * string, number, or boolean; strings match both `String` and
+     * `Categorical` scalar fields.
+     * @param {string} field
+     * @param {string} op
+     * @param {any} value
+     * @returns {Promise<Array<any>>}
+     */
+    queryScalar(field, op, value) {
+        const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.space_queryScalar(this.__wbg_ptr, ptr0, len0, ptr1, len1, value);
+        return ret;
+    }
     /**
      * Lexical BM25 text search over a text `field` (spec/0015 §3.6).
      *
@@ -274,6 +303,221 @@ export class Space {
 }
 if (Symbol.dispose) Space.prototype[Symbol.dispose] = Space.prototype.free;
 
+/**
+ * A write handle onto a ref.
+ */
+export class Writer {
+    static __wrap(ptr) {
+        const obj = Object.create(Writer.prototype);
+        obj.__wbg_ptr = ptr;
+        WriterFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WriterFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_writer_free(ptr, 0);
+    }
+    /**
+     * Append records and commit in one call.
+     *
+     * `samples` is an array of `{ anchor?: bigint|number, <field>: value }`.
+     * See `marshal::samples_from_js` for the accepted field shapes.
+     *
+     * Committing here rather than exposing a separate staged mode is
+     * deliberate for the browser surface: a staged write that is never
+     * committed leaves uploaded objects unreferenced, and a tab can close at
+     * any moment. `appendStaged` exists on the Node surface where the process
+     * lifetime is under the caller's control.
+     * @param {Array<any>} samples
+     * @returns {Promise<number>}
+     */
+    appendMany(samples) {
+        const ret = wasm.writer_appendMany(this.__wbg_ptr, samples);
+        return ret;
+    }
+    /**
+     * Flush staged entries and publish a new manifest.
+     *
+     * Fails with a CAS conflict if the ref moved underneath this writer. That
+     * is not retried automatically: an automatic retry would hide a logical
+     * conflict, and the caller is the only one who knows whether re-applying
+     * its records on top of the new head is correct.
+     * @returns {Promise<string>}
+     */
+    commit() {
+        const ret = wasm.writer_commit(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Tombstone records by anchor. Returns the new manifest hash.
+     * @param {BigUint64Array} anchors
+     * @param {string | null} [reason]
+     * @returns {Promise<string>}
+     */
+    deleteRecords(anchors, reason) {
+        const ptr0 = passArray64ToWasm0(anchors, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_deleteRecords(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * Current manifest hash, base32.
+     * @returns {string}
+     */
+    get manifestHash() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.writer_manifestHash(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Open a ref for writing.
+     *
+     * `uri` is the same `.../refs/<name>` form `Space.fromUri` takes; a
+     * `.../manifests/<hash>` URI is rejected rather than silently opening
+     * something unwritable, because a manifest hash names an immutable
+     * snapshot — there is nothing for a commit to advance.
+     *
+     * `backend` must implement `put` (Backend contract v2). Passing a
+     * read-only backend fails at the first write with a clear message rather
+     * than here, since the connector cannot know what the JS object omits
+     * until it calls it.
+     * @param {string} uri
+     * @param {any} backend
+     * @returns {Promise<Writer>}
+     */
+    static open(uri, backend) {
+        const ptr0 = passStringToWasm0(uri, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_open(ptr0, len0, backend);
+        return ret;
+    }
+    /**
+     * The ref this writer advances.
+     * @returns {string}
+     */
+    get refName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.writer_refName(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Tag the current manifest with an immutable label (`refs/<ref>@<label>`).
+     * @param {string} label
+     * @returns {Promise<string>}
+     */
+    snapshot(label) {
+        const ptr0 = passStringToWasm0(label, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.writer_snapshot(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) Writer.prototype[Symbol.dispose] = Writer.prototype.free;
+
+/**
+ * Install a panic hook that logs the panic message AND its `file:line:col`
+ * to the console before the wasm trap surfaces to JS.
+ *
+ * Without this, every Rust panic reaches JavaScript as a bare
+ * `RuntimeError: unreachable` with nothing but wasm frame offsets — and it is
+ * indistinguishable from an allocation failure, since Rust's alloc-error
+ * handler also aborts. That ambiguity cost real debugging time: a browser
+ * `unreachable` from exhausting wasm32's 32-bit address space on an oversized
+ * index was initially read as an integer-overflow panic.
+ *
+ * Zero new deps — uses the already-enabled `web-sys` `console` feature.
+ * Runs once at module init.
+ */
+export function __wasm_init() {
+    wasm.__wasm_init();
+}
+
+/**
+ * Parse an object path and re-format it. Byte-identity of the result is the
+ * actual assertion: a parser that silently drops a component still "parses".
+ * @param {string} path
+ * @returns {string}
+ */
+export function addressRoundTrip(path) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.addressRoundTrip(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * The address variant name (`Genesis`, `Manifest`, `Ref`, …) for a path.
+ *
+ * Derived from the Debug representation rather than a hand-written match.
+ * `DreamDbAddress` has seventeen variants and gains one whenever the protocol
+ * does; a match arm per variant would be a second list to keep in sync, and
+ * the vectors only ever assert the name.
+ * @param {string} path
+ * @returns {string}
+ */
+export function addressVariant(path) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.addressVariant(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Encode arbitrary bytes as lowercase RFC-4648 base32 (no padding).
  *
@@ -313,6 +557,196 @@ export function decodeCbor(bytes) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * Canonically encode a JS value as CBOR, returning the bytes.
+ *
+ * Canonical here means what spec/0002 §3.1 means: map keys sorted by their
+ * encoded bytes, shortest-form integers, no indefinite lengths. Two writers
+ * that disagree on this produce different content hashes for the same logical
+ * object, and every address derived from them diverges.
+ * @param {any} value
+ * @returns {Uint8Array}
+ */
+export function encodeCbor(value) {
+    const ret = wasm.encodeCbor(value);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+}
+
+/**
+ * Parse a modality tag into `{class, encoding, trackKind, objectKind, params,
+ * flags}`, or throw if it is invalid.
+ *
+ * `params` is a plain object of the `key=value` segments and `flags` an array
+ * of the bare ones (`bucketed`, `graph`). They are separate because the
+ * grammar treats them differently and merging them would make a flag
+ * indistinguishable from a parameter whose value happened to be empty.
+ * @param {string} tag
+ * @returns {any}
+ */
+export function modalityParse(tag) {
+    const ptr0 = passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.modalityParse(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * BLAKE3-256 multihash of `bytes`, base32 (the form used in object paths).
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function multihashBase32(bytes) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.multihashBase32(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * BLAKE3-256 multihash of `bytes` as lowercase hex (33 bytes: tag + digest).
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+export function multihashHex(bytes) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.multihashHex(ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * DreamDB's half-open `[start, end)` → an HTTP `Range` header value.
+ *
+ * The off-by-one here is worth a vector of its own: HTTP ranges are
+ * *inclusive* of the end byte. Getting it wrong reads one byte too few from
+ * every object, which corrupts decode in ways that look like anything but an
+ * off-by-one.
+ * @param {bigint} start
+ * @param {bigint} end
+ * @returns {string}
+ */
+export function rangeHeader(start, end) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.rangeHeader(start, end);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * Round-trip a spatial key through its base-2 form, per spec/0002 §6.
+ *
+ * Returns the re-encoded string, so a caller can assert byte-identity rather
+ * than merely "it parsed".
+ * @param {string} bits
+ * @returns {string}
+ */
+export function spatialKeyRoundTrip(bits) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(bits, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.spatialKeyRoundTrip(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * The 16-char hex address form → TimeAnchor. Throws on a malformed input
+ * (wrong length, uppercase) rather than coercing it.
+ * @param {string} s
+ * @returns {bigint}
+ */
+export function timeAnchorFromHex(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.timeAnchorFromHex(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BigInt.asUintN(64, ret[0]);
+}
+
+/**
+ * TimeAnchor → the 16-char hex used in addresses.
+ * @param {bigint} value
+ * @returns {string}
+ */
+export function timeAnchorHex(value) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.timeAnchorHex(value);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Which time bucket an anchor falls in, given a duration like `"1s"`/`"60s"`.
+ * @param {bigint} t_start
+ * @param {string} duration
+ * @returns {bigint}
+ */
+export function timeBucket(t_start, duration) {
+    const ptr0 = passStringToWasm0(duration, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.timeBucket(t_start, ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BigInt.asUintN(64, ret[0]);
+}
+
 /**
  * Package version — useful for consumers to confirm which build is loaded.
  * @returns {string}
@@ -351,6 +785,19 @@ export function __wbg_Error_bce6d499ff0a4aff(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return ret;
 }
+export function __wbg_String_8564e559799eccda(arg0, arg1) {
+    const ret = String(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg___wbindgen_bigint_get_as_i64_410e28c7b761ad83(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
 export function __wbg___wbindgen_boolean_get_2304fb8c853028c8(arg0) {
     const v = arg0;
     const ret = typeof(v) === 'boolean' ? v : undefined;
@@ -363,6 +810,14 @@ export function __wbg___wbindgen_debug_string_edece8177ad01481(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }
+export function __wbg___wbindgen_in_07056af4f902c445(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+}
+export function __wbg___wbindgen_is_bigint_aeae3893f30ed54e(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+}
 export function __wbg___wbindgen_is_function_5cd60d5cf78b4eef(arg0) {
     const ret = typeof(arg0) === 'function';
     return ret;
@@ -371,10 +826,23 @@ export function __wbg___wbindgen_is_null_2042690d351e14f0(arg0) {
     const ret = arg0 === null;
     return ret;
 }
+export function __wbg___wbindgen_is_object_b4593df85baada48(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
 export function __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5(arg0) {
     const ret = arg0 === undefined;
     return ret;
 }
+export function __wbg___wbindgen_jsval_eq_c0ed08b3e0f393b9(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_loose_eq_0ad77b7717db155c(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+}
 export function __wbg___wbindgen_number_get_f73a1244370fcc2c(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -399,10 +867,37 @@ export function __wbg_arrayBuffer_cb5d4748b5f3cad5() { return handleError(functi
     const ret = arg0.arrayBuffer();
     return ret;
 }, arguments); }
+export function __wbg_call_084ee3e860ee9f92() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    const ret = arg0.call(arg1, arg2, arg3, arg4);
+    return ret;
+}, arguments); }
+export function __wbg_call_13665d9f14390edc() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
 export function __wbg_call_dfde26266607c996() { return handleError(function (arg0, arg1, arg2) {
     const ret = arg0.call(arg1, arg2);
     return ret;
 }, arguments); }
+export function __wbg_done_54b8da57023b7ed2(arg0) {
+    const ret = arg0.done;
+    return ret;
+}
+export function __wbg_entries_564a7e8b1e54ede5(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+}
+export function __wbg_error_f085d7e62279b703(arg0) {
+    console.error(arg0);
+}
+export function __wbg_get_3e9a707ab7d352eb() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_98fdf51d029a75eb(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
 export function __wbg_get_dcf82ab8aad1a593() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
@@ -411,6 +906,50 @@ export function __wbg_get_unchecked_1dfe6d05ad91d9b7(arg0, arg1) {
     const ret = arg0[arg1 >>> 0];
     return ret;
 }
+export function __wbg_headers_4cfb0c75793d7a8d(arg0) {
+    const ret = arg0.headers;
+    return ret;
+}
+export function __wbg_instanceof_ArrayBuffer_53db37b06f6b9afe(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Float32Array_3cc6d04a6a12262f(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Float32Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Map_16f217b9a2a08d8c(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Object_03924e0dbda74bd8(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Object;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
 export function __wbg_instanceof_Promise_09012cfa9708520a(arg0) {
     let result;
     try {
@@ -445,6 +984,18 @@ export function __wbg_isArray_94898ed3aad6947b(arg0) {
     const ret = Array.isArray(arg0);
     return ret;
 }
+export function __wbg_isSafeInteger_01e964d144ad3a55(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+}
+export function __wbg_iterator_1441b47f341dc34f() {
+    const ret = Symbol.iterator;
+    return ret;
+}
+export function __wbg_length_13e61aa81636ec86(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
 export function __wbg_length_2591a0f4f659a55c(arg0) {
     const ret = arg0.length;
     return ret;
@@ -495,6 +1046,18 @@ export function __wbg_new_with_str_and_init_ffe9977c986ea039() { return handleEr
     const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
     return ret;
 }, arguments); }
+export function __wbg_next_2a4e19f4f5083b0f(arg0) {
+    const ret = arg0.next;
+    return ret;
+}
+export function __wbg_next_6429a146bf756f93() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments); }
+export function __wbg_now_81363d44c96dd239() {
+    const ret = Date.now();
+    return ret;
+}
 export function __wbg_ok_556a55299dd238ba(arg0) {
     const ret = arg0.ok;
     return ret;
@@ -502,6 +1065,9 @@ export function __wbg_ok_556a55299dd238ba(arg0) {
 export function __wbg_prototypesetcall_5f9bdc8d75e07276(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
 }
+export function __wbg_prototypesetcall_fe9d129a614489fa(arg0, arg1, arg2) {
+    Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
+}
 export function __wbg_push_b77c476b01548d0a(arg0, arg1) {
     const ret = arg0.push(arg1);
     return ret;
@@ -521,6 +1087,9 @@ export function __wbg_set_a0e911be3da02782() { return handleError(function (arg0
     const ret = Reflect.set(arg0, arg1, arg2);
     return ret;
 }, arguments); }
+export function __wbg_set_d57e5106f0271787() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+}, arguments); }
 export function __wbg_set_facb7a5914e0fa39(arg0, arg1, arg2) {
     const ret = arg0.set(arg1, arg2);
     return ret;
@@ -557,8 +1126,16 @@ export function __wbg_then_bd927500e8905df2(arg0, arg1, arg2) {
     const ret = arg0.then(arg1, arg2);
     return ret;
 }
+export function __wbg_value_9cc0518af87a489c(arg0) {
+    const ret = arg0.value;
+    return ret;
+}
+export function __wbg_writer_new(arg0) {
+    const ret = Writer.__wrap(arg0);
+    return ret;
+}
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 380, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    // 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`.
     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;
 }
@@ -572,11 +1149,21 @@ export function __wbindgen_cast_0000000000000003(arg0, arg1) {
     const ret = (BigInt.asUintN(64, arg0) | (arg1 << BigInt(64)));
     return ret;
 }
-export function __wbindgen_cast_0000000000000004(arg0, arg1) {
+export function __wbindgen_cast_0000000000000004(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000005(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
 }
+export function __wbindgen_cast_0000000000000006(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+}
 export function __wbindgen_init_externref_table() {
     const table = wasm.__wbindgen_externrefs;
     const offset = table.grow(4);
@@ -603,6 +1190,9 @@ const S3BackendFinalization = (typeof FinalizationRegistry === 'undefined')
 const SpaceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_space_free(ptr, 1));
+const WriterFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_writer_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -679,11 +1269,24 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+let cachedBigUint64ArrayMemory0 = null;
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64ArrayMemory0;
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -753,6 +1356,13 @@ function makeMutClosure(arg0, arg1, f) {
     return real;
 }
 
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);