nucleation 0.2.10 → 0.2.12

package/nucleation-original.js

@@ -309,6 +309,10 @@ const DefinitionRegionWrapperFinalization = (typeof FinalizationRegistry === 'un
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_definitionregionwrapper_free(ptr >>> 0, 1));
 
+const DiffWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_diffwrapper_free(ptr >>> 0, 1));
+
 const ExecutionModeWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_executionmodewrapper_free(ptr >>> 0, 1));
@@ -397,6 +401,10 @@ const StateModeConstantsFinalization = (typeof FinalizationRegistry === 'undefin
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_statemodeconstants_free(ptr >>> 0, 1));
 
+const StoreWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_storewrapper_free(ptr >>> 0, 1));
+
 const TextureAtlasWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_textureatlaswrapper_free(ptr >>> 0, 1));
@@ -1734,6 +1742,164 @@ export class DefinitionRegionWrapper {
 }
 if (Symbol.dispose) DefinitionRegionWrapper.prototype[Symbol.dispose] = DefinitionRegionWrapper.prototype.free;
 
+/**
+ * WASM wrapper for a [`Diff`] between two schematics.
+ */
+export class DiffWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DiffWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        DiffWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DiffWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_diffwrapper_free(ptr, 0);
+    }
+    /**
+     * Connected change regions as a JSON array.
+     *
+     * Each region: `{min:[x,y,z], max:[x,y,z], kind:"added|removed|changed|mixed", count}`.
+     * @returns {string}
+     */
+    regionsJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.diffwrapper_regionsJson(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);
+        }
+    }
+    /**
+     * Serialize a compact summary (counts + transform) to a JSON string.
+     * @returns {string}
+     */
+    summaryJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.diffwrapper_summaryJson(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);
+        }
+    }
+    /**
+     * Generate a colored overlay GLB on top of an already-meshed "after" GLB.
+     * @param {Uint8Array} after_glb
+     * @returns {Uint8Array}
+     */
+    toOverlayGlb(after_glb) {
+        const ptr0 = passArray8ToWasm0(after_glb, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.diffwrapper_toOverlayGlb(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Schematic containing only the added blocks.
+     * @returns {SchematicWrapper}
+     */
+    added() {
+        const ret = wasm.diffwrapper_added(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Schematic containing only the changed blocks (post-change state).
+     * @returns {SchematicWrapper}
+     */
+    changed() {
+        const ret = wasm.diffwrapper_changed(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Schematic of visualization markers for all change classes.
+     * @returns {SchematicWrapper}
+     */
+    markers() {
+        const ret = wasm.diffwrapper_markers(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Schematic containing only the removed blocks.
+     * @returns {SchematicWrapper}
+     */
+    removed() {
+        const ret = wasm.diffwrapper_removed(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Match support score (fraction of cells explained by the alignment).
+     * @returns {number}
+     */
+    get support() {
+        const ret = wasm.diffwrapper_support(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Schematic containing only the palette-swapped blocks.
+     * @returns {SchematicWrapper}
+     */
+    swapped() {
+        const ret = wasm.diffwrapper_swapped(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Serialize the full diff to a JSON string.
+     * @returns {string}
+     */
+    toJson() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.diffwrapper_toJson(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);
+        }
+    }
+    /**
+     * Total edit distance (sum of weighted add/delete/change/swap costs).
+     * @returns {number}
+     */
+    get distance() {
+        const ret = wasm.diffwrapper_distance(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Reconstruct a diff from a JSON string produced by `toJson()`.
+     * @param {string} s
+     * @returns {DiffWrapper}
+     */
+    static fromJson(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.diffwrapper_fromJson(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DiffWrapper.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) DiffWrapper.prototype[Symbol.dispose] = DiffWrapper.prototype.free;
+
 /**
  * ExecutionMode for circuit execution
  */
@@ -4027,32 +4193,94 @@ export class SchematicWrapper {
         wasm.__wbg_schematicwrapper_free(ptr, 0);
     }
     /**
-     * Creates a simulation world for this schematic with default options
+     * Compute the content fingerprint as a hex string.
      *
-     * This allows you to simulate redstone circuits and interact with them.
-     * @returns {MchprsWorldWrapper}
+     * `preset` defaults to `"exact"`. Unknown preset → Err.
+     * @param {string | null} [preset]
+     * @returns {string}
      */
-    create_simulation_world() {
-        const ret = wasm.schematicwrapper_create_simulation_world(this.__wbg_ptr);
+    fingerprint(preset) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(preset) ? 0 : passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.schematicwrapper_fingerprint(this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Whether this schematic is a duplicate of `other` under `preset`.
+     *
+     * `preset` defaults to `"exact"`. Unknown preset → Err.
+     * @param {SchematicWrapper} other
+     * @param {string | null} [preset]
+     * @returns {boolean}
+     */
+    isDuplicateOf(other, preset) {
+        _assertClass(other, SchematicWrapper);
+        var ptr0 = isLikeNone(preset) ? 0 : passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_isDuplicateOf(this.__wbg_ptr, other.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return MchprsWorldWrapper.__wrap(ret[0]);
+        return ret[0] !== 0;
     }
     /**
-     * Creates a simulation world for this schematic with custom options
+     * Footprint distance between this schematic and `other` (0.0 = identical).
      *
-     * This allows you to configure simulation behavior like wire state tracking.
-     * @param {SimulationOptionsWrapper} options
-     * @returns {MchprsWorldWrapper}
+     * `preset` defaults to `"exact"`. Unknown preset → Err.
+     * @param {SchematicWrapper} other
+     * @param {string | null} [preset]
+     * @returns {number}
      */
-    create_simulation_world_with_options(options) {
-        _assertClass(options, SimulationOptionsWrapper);
-        const ret = wasm.schematicwrapper_create_simulation_world_with_options(this.__wbg_ptr, options.__wbg_ptr);
+    footprintDistance(other, preset) {
+        _assertClass(other, SchematicWrapper);
+        var ptr0 = isLikeNone(preset) ? 0 : passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_footprintDistance(this.__wbg_ptr, other.__wbg_ptr, ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return MchprsWorldWrapper.__wrap(ret[0]);
+        return ret[0];
+    }
+    /**
+     * Compute the structural signature as a JSON string.
+     *
+     * `preset` defaults to `"exact"`. Unknown preset → Err.
+     * @param {string | null} [preset]
+     * @returns {string}
+     */
+    signature(preset) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            var ptr0 = isLikeNone(preset) ? 0 : passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len0 = WASM_VECTOR_LEN;
+            const ret = wasm.schematicwrapper_signature(this.__wbg_ptr, 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);
+        }
     }
     /**
      * Add a mobile entity to the schematic.
@@ -4384,6 +4612,22 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_remove_entity(this.__wbg_ptr, index);
         return ret !== 0;
     }
+    /**
+     * Save this schematic into a [`StoreWrapper`] at `key`. The export format is
+     * inferred from the `key`'s extension (e.g. `.litematic`, `.schem`). Works
+     * with `mem://` stores and the `Store.fromCallbacks(...)` JS-callback store.
+     * @param {StoreWrapper} store
+     * @param {string} key
+     */
+    saveToStore(store, key) {
+        _assertClass(store, StoreWrapper);
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_saveToStore(this.__wbg_ptr, store.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {string} name
      * @param {DefinitionRegionWrapper} region
@@ -4578,6 +4822,25 @@ export class SchematicWrapper {
         }
         return v1;
     }
+    /**
+     * Open a schematic directly from a [`StoreWrapper`] at `key`. The format is
+     * inferred from the stored bytes. This is the meaningful way to load from
+     * host/remote storage on the web: it works with `mem://` stores and with
+     * the JS-callback store created via `Store.fromCallbacks(...)`.
+     * @param {StoreWrapper} store
+     * @param {string} key
+     * @returns {SchematicWrapper}
+     */
+    static openFromStore(store, key) {
+        _assertClass(store, StoreWrapper);
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_openFromStore(store.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SchematicWrapper.__wrap(ret[0]);
+    }
     /**
      * @returns {string}
      */
@@ -4892,7 +5155,7 @@ export class SchematicWrapper {
      * @returns {CircuitBuilderWrapper}
      */
     createCircuitBuilder() {
-        const ret = wasm.circuitbuilderwrapper_new(this.__wbg_ptr);
+        const ret = wasm.schematicwrapper_createCircuitBuilder(this.__wbg_ptr);
         return CircuitBuilderWrapper.__wrap(ret);
     }
     /**
@@ -5388,6 +5651,55 @@ export class SchematicWrapper {
         const len0 = WASM_VECTOR_LEN;
         wasm.schematicwrapper_set_block(this.__wbg_ptr, x, y, z, ptr0, len0);
     }
+    /**
+     * Creates a simulation world for this schematic with default options
+     *
+     * This allows you to simulate redstone circuits and interact with them.
+     * @returns {MchprsWorldWrapper}
+     */
+    create_simulation_world() {
+        const ret = wasm.schematicwrapper_create_simulation_world(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MchprsWorldWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Creates a simulation world for this schematic with custom options
+     *
+     * This allows you to configure simulation behavior like wire state tracking.
+     * @param {SimulationOptionsWrapper} options
+     * @returns {MchprsWorldWrapper}
+     */
+    create_simulation_world_with_options(options) {
+        _assertClass(options, SimulationOptionsWrapper);
+        const ret = wasm.schematicwrapper_create_simulation_world_with_options(this.__wbg_ptr, options.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MchprsWorldWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Structurally diff this schematic against `other`.
+     *
+     * `preset` defaults to `"exact"`. `options` is an optional object
+     * `{cost_add?, cost_delete?, cost_change?, cost_swap?, symmetry?}`.
+     * Returns a [`DiffWrapper`]. Unknown preset/symmetry → Err.
+     * @param {SchematicWrapper} other
+     * @param {string | null | undefined} preset
+     * @param {any} options
+     * @returns {DiffWrapper}
+     */
+    diff(other, preset, options) {
+        _assertClass(other, SchematicWrapper);
+        var ptr0 = isLikeNone(preset) ? 0 : passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_diff(this.__wbg_ptr, other.__wbg_ptr, ptr0, len0, options);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DiffWrapper.__wrap(ret[0]);
+    }
     /**
      * Generate raw mesh data for custom rendering pipelines.
      * @param {ResourcePackWrapper} pack
@@ -6123,6 +6435,201 @@ export class StateModeConstants {
 }
 if (Symbol.dispose) StateModeConstants.prototype[Symbol.dispose] = StateModeConstants.prototype.free;
 
+/**
+ * A byte store keyed by `/`-delimited paths. Construct with `new Store(url)`.
+ */
+export class StoreWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StoreWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        StoreWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StoreWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_storewrapper_free(ptr, 0);
+    }
+    /**
+     * Atomically write `data` at `key` only if it does not already exist.
+     * Returns `true` if written, `false` if the key already existed.
+     * @param {string} key
+     * @param {Uint8Array} data
+     * @returns {boolean}
+     */
+    putIfAbsent(key, data) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_putIfAbsent(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Build a store backed by host-supplied JS functions ("host owns IO").
+     *
+     * `handlers` is a JS object with **synchronous** methods:
+     * `get(key) -> Uint8Array | null`, `put(key, Uint8Array)`,
+     * `has(key) -> bool`, `delete(key)`, `list(prefix) -> string[]`,
+     * `health()`. Any thrown JS error surfaces as a store error.
+     * @param {any} handlers
+     * @returns {StoreWrapper}
+     */
+    static fromCallbacks(handlers) {
+        const ret = wasm.storewrapper_fromCallbacks(handlers);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StoreWrapper.__wrap(ret[0]);
+    }
+    /**
+     * A keyset page of keys under `prefix`, sorted, starting strictly after
+     * `after` (pass `null`/`undefined` for the first page), at most `limit`.
+     * Returns `{ keys: string[], next: string | null }`; pass `next` back as
+     * `after` to continue, or stop when it is `null`.
+     * @param {string} prefix
+     * @param {string | null | undefined} after
+     * @param {number} limit
+     * @returns {any}
+     */
+    listPaginated(prefix, after, limit) {
+        const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(after) ? 0 : passStringToWasm0(after, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_listPaginated(this.__wbg_ptr, ptr0, len0, ptr1, len1, limit);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Fetch `key`, or `undefined` if absent.
+     * @param {string} key
+     * @returns {Uint8Array | undefined}
+     */
+    get(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_get(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * Open a store from a URL. On the web, use `mem://`.
+     * @param {string} url
+     */
+    constructor(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        StoreWrapperFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Store `data` at `key`, overwriting.
+     * @param {string} key
+     * @param {Uint8Array} data
+     */
+    put(key, data) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_put(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Keys under `prefix`.
+     * @param {string} prefix
+     * @returns {string[]}
+     */
+    list(prefix) {
+        const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_list(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * Open a store from a URL (canonical name, matching Python/FFI `open`).
+     * Equivalent to `new Store(url)`.
+     * @param {string} url
+     * @returns {StoreWrapper}
+     */
+    static open(url) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_open(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StoreWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Remove `key` (idempotent).
+     * @param {string} key
+     */
+    delete(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_delete(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Whether `key` exists.
+     * @param {string} key
+     * @returns {boolean}
+     */
+    has(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.storewrapper_has(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Reject if the store is not usable.
+     */
+    health() {
+        const ret = wasm.storewrapper_health(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) StoreWrapper.prototype[Symbol.dispose] = StoreWrapper.prototype.free;
+
 /**
  * Wrapper for a pre-built global texture atlas.
  *
@@ -6753,6 +7260,14 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg___wbindgen_is_falsy_7b9692021c137978 = function(arg0) {
+        const ret = !arg0;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
     imports.wbg.__wbg___wbindgen_is_null_dfda7d66506c95b5 = function(arg0) {
         const ret = arg0 === null;
         return ret;
@@ -6791,6 +7306,14 @@ function __wbg_get_imports() {
         const ret = arg0.call(arg1, arg2);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_c8baa5c5e72d274e = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = arg0.call(arg1, arg2, arg3);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
         const ret = Object.entries(arg0);
         return ret;
@@ -6831,6 +7354,16 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
+    imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+        let result;
+        try {
+            result = arg0 instanceof Uint8Array;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
         const ret = Array.isArray(arg0);
         return ret;