nucleation 0.2.13 → 0.2.15

package/nucleation-original.js

@@ -373,6 +373,10 @@ const RawMeshExportWrapperFinalization = (typeof FinalizationRegistry === 'undef
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rawmeshexportwrapper_free(ptr >>> 0, 1));
 
+const RedstoneGraphWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_redstonegraphwrapper_free(ptr >>> 0, 1));
+
 const ResourcePackWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_resourcepackwrapper_free(ptr >>> 0, 1));
@@ -421,6 +425,18 @@ const WasmBuildingToolFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmbuildingtool_free(ptr >>> 0, 1));
 
+const WorldChunkIterWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_worldchunkiterwrapper_free(ptr >>> 0, 1));
+
+const WorldChunkViewWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_worldchunkviewwrapper_free(ptr >>> 0, 1));
+
+const WorldSourceWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_worldsourcewrapper_free(ptr >>> 0, 1));
+
 export class BlockPosition {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -1766,7 +1782,7 @@ export class DiffWrapper {
     /**
      * Connected change regions as a JSON array.
      *
-     * Each region: `{min:[x,y,z], max:[x,y,z], kind:"added|removed|changed|mixed", count}`.
+     * Each region: `{min:[x,y,z], max:[x,y,z], kind:"added|removed|changed|swapped|mixed", count}`.
      * @returns {string}
      */
     regionsJson() {
@@ -1877,11 +1893,14 @@ export class DiffWrapper {
     }
     /**
      * Total edit distance (sum of weighted add/delete/change/swap costs).
+     *
+     * Surfaced as a JS `number` (f64). Edit distances stay well within f64's
+     * exact-integer range; the core value is `u64`.
      * @returns {number}
      */
     get distance() {
         const ret = wasm.diffwrapper_distance(this.__wbg_ptr);
-        return ret >>> 0;
+        return ret;
     }
     /**
      * Reconstruct a diff from a JSON string produced by `toJson()`.
@@ -2830,6 +2849,17 @@ export class MchprsWorldWrapper {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_mchprsworldwrapper_free(ptr, 0);
     }
+    /**
+     * Extract the compiled redstone logic graph for this world.
+     * @returns {RedstoneGraphWrapper}
+     */
+    exportGraph() {
+        const ret = wasm.mchprsworldwrapper_exportGraph(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RedstoneGraphWrapper.__wrap(ret[0]);
+    }
     /**
      * Simulates a right-click on a block (typically a lever)
      * @param {number} x
@@ -2966,6 +2996,17 @@ export class MchprsWorldWrapper {
     clearCustomIoChanges() {
         wasm.mchprsworldwrapper_clearCustomIoChanges(this.__wbg_ptr);
     }
+    /**
+     * Extract the structural (pre-fold, as-built) redstone logic graph.
+     * @returns {RedstoneGraphWrapper}
+     */
+    exportGraphStructural() {
+        const ret = wasm.mchprsworldwrapper_exportGraphStructural(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RedstoneGraphWrapper.__wrap(ret[0]);
+    }
     /**
      * @param {SchematicWrapper} schematic
      */
@@ -3755,6 +3796,164 @@ export class RawMeshExportWrapper {
 }
 if (Symbol.dispose) RawMeshExportWrapper.prototype[Symbol.dispose] = RawMeshExportWrapper.prototype.free;
 
+/**
+ * A wrapper around an extracted [`RedstoneGraph`] for JS consumers.
+ */
+export class RedstoneGraphWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RedstoneGraphWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        RedstoneGraphWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RedstoneGraphWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_redstonegraphwrapper_free(ptr, 0);
+    }
+    /**
+     * Total number of directed edges in the graph.
+     * @returns {number}
+     */
+    get edgeCount() {
+        const ret = wasm.redstonegraphwrapper_edgeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of nodes in the graph.
+     * @returns {number}
+     */
+    get nodeCount() {
+        const ret = wasm.redstonegraphwrapper_nodeCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Compute the structural/functional/exact fingerprint as a hex string.
+     *
+     * `preset` defaults to `"structural"`; throws for an unknown preset.
+     * @param {string | null} [preset]
+     * @returns {string}
+     */
+    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.redstonegraphwrapper_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);
+        }
+    }
+    /**
+     * The computed graph features serialized as a JSON string.
+     * @returns {string}
+     */
+    featuresJson() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.redstonegraphwrapper_featuresJson(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);
+        }
+    }
+    /**
+     * The directed edges as an array of `{source, target, kind, strength}`.
+     * @returns {any}
+     */
+    get edges() {
+        const ret = wasm.redstonegraphwrapper_edges(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * The nodes as an array of plain objects (kind-specific fields inlined).
+     * @returns {any}
+     */
+    get nodes() {
+        const ret = wasm.redstonegraphwrapper_nodes(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Serialize the graph to JSON.
+     * @returns {string}
+     */
+    toJson() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.redstonegraphwrapper_toJson(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);
+        }
+    }
+    /**
+     * Computed graph features as a plain object.
+     * @returns {any}
+     */
+    features() {
+        const ret = wasm.redstonegraphwrapper_features(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Deserialize a graph from JSON.
+     * @param {string} s
+     * @returns {RedstoneGraphWrapper}
+     */
+    static fromJson(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.redstonegraphwrapper_fromJson(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RedstoneGraphWrapper.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) RedstoneGraphWrapper.prototype[Symbol.dispose] = RedstoneGraphWrapper.prototype.free;
+
 /**
  * Wrapper for a Minecraft resource pack.
  */
@@ -4301,6 +4500,55 @@ export class SchematicWrapper {
             wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
         }
     }
+    /**
+     * Structurally diff this schematic against `other`.
+     *
+     * `preset` defaults to `"exact"`. `options` is an optional object
+     * `{cost_add?, cost_delete?, cost_change?, cost_swap?, swap_dominance_pct?,
+     * 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]);
+    }
+    /**
+     * 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]);
+    }
     /**
      * Add a mobile entity to the schematic.
      * @param {string} id
@@ -4960,6 +5208,11 @@ export class SchematicWrapper {
         return ret;
     }
     /**
+     * Get the structured block entity at a position as `{id, position, nbt}`,
+     * or NULL if there is none. Returns *every* block-entity type (chests,
+     * signs, furnaces, banners, spawners, …) — not just chests — so the editor
+     * can read all the NBT nucleation preserves. (For a precision-faithful
+     * representation of `Long`/`LongArray` fields, see `getBlockEntitySnbt`.)
      * @param {number} x
      * @param {number} y
      * @param {number} z
@@ -5014,6 +5267,69 @@ export class SchematicWrapper {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * Set (or replace) a block entity at a position from an SNBT string. This is
+     * the faithful, fully-typed write path the editor uses to persist
+     * container contents, sign text, banner patterns, item components, etc.
+     * SNBT preserves every NBT tag type with no precision loss.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {string} id
+     * @param {string} snbt
+     */
+    setBlockEntity(x, y, z, id, snbt) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(snbt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_setBlockEntity(this.__wbg_ptr, x, y, z, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Detect repeating structures (by region coverage). Returns an array of
+     * objects: `{ mode, vectors, coverage, region_min, region_max, cell_min,
+     * cell_max, label }`.
+     * @returns {any}
+     */
+    detectStructures() {
+        const ret = wasm.schematicwrapper_detectStructures(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Faithful, precision-safe read of every mobile entity as an SNBT string
+     * (the full entity compound incl. `id`/`Pos`, typed). Mirrors
+     * `getBlockEntitySnbt` so the editor can carry entity NBT verbatim.
+     * @returns {Array<any>}
+     */
+    getEntitiesSnbt() {
+        const ret = wasm.schematicwrapper_getEntitiesSnbt(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Convert to `target_data_version` using the schematic's *captured* source
+     * version (`source_data_version`, else `mc_version`, else canonical) as the
+     * origin, updating the metadata version to the target. Returns the JSON loss
+     * report (empty `[]` when lossless). This is the ergonomic save/load entry:
+     * `convertToVersion(CANONICAL)` on load, `convertToVersion(target)` before
+     * exporting for an older version.
+     * @param {number} target_data_version
+     * @returns {string}
+     */
+    convertToVersion(target_data_version) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.schematicwrapper_convertToVersion(this.__wbg_ptr, target_data_version);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * @param {number} x
      * @param {number} y
@@ -5029,6 +5345,41 @@ export class SchematicWrapper {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Resize a 1D / diagonal periodic structure along its period vector,
+     * producing `units` repeating cells.
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} units
+     * @returns {SchematicWrapper}
+     */
+    autostackResize1d(vx, vy, vz, units) {
+        const ret = wasm.schematicwrapper_autostackResize1d(this.__wbg_ptr, vx, vy, vz, units);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SchematicWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Resize a 2D periodic structure to `n1`×`n2` cells along the two vectors.
+     * @param {number} v1x
+     * @param {number} v1y
+     * @param {number} v1z
+     * @param {number} v2x
+     * @param {number} v2y
+     * @param {number} v2z
+     * @param {number} n1
+     * @param {number} n2
+     * @returns {SchematicWrapper}
+     */
+    autostackResize2d(v1x, v1y, v1z, v2x, v2y, v2z, n1, n2) {
+        const ret = wasm.schematicwrapper_autostackResize2d(this.__wbg_ptr, v1x, v1y, v1z, v2x, v2y, v2z, n1, n2);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SchematicWrapper.__wrap(ret[0]);
+    }
     /**
      * @param {string} format
      * @returns {Array<any>}
@@ -5039,6 +5390,17 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_format_versions(ptr0, len0);
         return ret;
     }
+    /**
+     * Remove the block entity at a position. Returns true if one was removed.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {boolean}
+     */
+    removeBlockEntity(x, y, z) {
+        const ret = wasm.schematicwrapper_removeBlockEntity(this.__wbg_ptr, x, y, z);
+        return ret !== 0;
+    }
     /**
      * @param {string} region_name
      * @param {number} x
@@ -5055,6 +5417,20 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_set_block_in_region(this.__wbg_ptr, ptr0, len0, x, y, z, ptr1, len1);
         return ret !== 0;
     }
+    /**
+     * Add a mobile entity from a full SNBT entity compound (must contain `id`
+     * and `Pos`). The faithful, fully-typed entity write path — mirrors
+     * `setBlockEntity` for block entities.
+     * @param {string} snbt
+     */
+    addEntityFromSnbt(snbt) {
+        const ptr0 = passStringToWasm0(snbt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_addEntityFromSnbt(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {number} chunk_width
      * @param {number} chunk_height
@@ -5135,6 +5511,21 @@ export class SchematicWrapper {
         _assertClass(region, DefinitionRegionWrapper);
         wasm.schematicwrapper_addDefinitionRegion(this.__wbg_ptr, ptr0, len0, region.__wbg_ptr);
     }
+    /**
+     * Faithful, precision-safe block-entity read: the block entity's NBT as an
+     * SNBT string (typed — `123L`, `1b`, etc.), or NULL if none. Unlike the
+     * structured `nbt` object (which collapses `Long` to a JS double), SNBT
+     * round-trips losslessly through `setBlockEntity`, so the editor can carry
+     * untouched block entities verbatim.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {any}
+     */
+    getBlockEntitySnbt(x, y, z) {
+        const ret = wasm.schematicwrapper_getBlockEntitySnbt(this.__wbg_ptr, x, y, z);
+        return ret;
+    }
     /**
      * @param {string} name
      * @returns {DefinitionRegionWrapper}
@@ -5171,10 +5562,18 @@ export class SchematicWrapper {
         }
     }
     /**
-     * @returns {CircuitBuilderWrapper}
+     * The canonical in-memory data version (the forward-conversion target).
+     * @returns {number}
+     */
+    static canonicalDataVersion() {
+        const ret = wasm.schematicwrapper_canonicalDataVersion();
+        return ret;
+    }
+    /**
+     * @returns {CircuitBuilderWrapper}
      */
     createCircuitBuilder() {
-        const ret = wasm.schematicwrapper_createCircuitBuilder(this.__wbg_ptr);
+        const ret = wasm.circuitbuilderwrapper_new(this.__wbg_ptr);
         return CircuitBuilderWrapper.__wrap(ret);
     }
     /**
@@ -5201,6 +5600,33 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_all_block_entities(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Convert this schematic's block states / block entities / items between
+     * Minecraft data versions, in place, returning a JSON array describing any
+     * data loss (empty `[]` when lossless).
+     *
+     * Forward (target >= source) is faithful and lossless — the report is always
+     * `[]`. Reverse (target < source, used to save for an older version) can be
+     * lossy (the 1.13 Flattening, 1.20.5 components, item `Damage`, …); each
+     * approximation/drop is reported as `{version, kind, severity, path, detail}`
+     * so the tool can warn the user before saving. Conversion is never silent
+     * about loss.
+     * @param {number} target_data_version
+     * @param {number} source_data_version
+     * @returns {string}
+     */
+    convertToDataVersion(target_data_version, source_data_version) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.schematicwrapper_convertToDataVersion(this.__wbg_ptr, target_data_version, source_data_version);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * @param {string} name
      * @param {number} x
@@ -5215,6 +5641,17 @@ export class SchematicWrapper {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Graph-based detection: recovers **diagonal** lattice periods (e.g. a
+     * diagonal carry-chain adder) that the pure-voxel `detectStructures` misses,
+     * by extracting the redstone logic graph. Returns the same object shape.
+     * Requires the `simulation` feature; returns `[]` for non-redstone builds.
+     * @returns {any}
+     */
+    detectStructuresGraph() {
+        const ret = wasm.schematicwrapper_detectStructuresGraph(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @param {string} region_name
      * @returns {any}
@@ -5235,6 +5672,24 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_region_bounding_box(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * The Minecraft data version of the file this schematic was loaded from
+     * (captured by importers), or `None` for versionless/freshly-built schematics.
+     * @returns {number | undefined}
+     */
+    getSourceDataVersion() {
+        const ret = wasm.schematicwrapper_getSourceDataVersion(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * Override the source data version — for formats that carry no Java data
+     * version (classic `.schematic` ≈ 1343, raw imports), so the caller can tell
+     * the converter what to convert *from*.
+     * @param {number} version
+     */
+    setSourceDataVersion(version) {
+        wasm.schematicwrapper_setSourceDataVersion(this.__wbg_ptr, version);
+    }
     /**
      * @param {string} name
      */
@@ -5279,6 +5734,23 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_removeDefinitionRegion(this.__wbg_ptr, ptr0, len0);
         return ret !== 0;
     }
+    /**
+     * Serialize a `.litematic` targeting a specific Minecraft data version: a COPY
+     * of the schematic's content is converted to `target_data_version` and the
+     * matching schematic Version header (4=1.12 / 5=1.13–1.17 / 6=1.18–1.20.4 /
+     * 7=1.20.5+) is written. Returns `{ bytes: Uint8Array, loss: <json> }`; `loss`
+     * is the data-loss report from any down-conversion (empty `{}` when lossless),
+     * so the UI can warn the user. The schematic itself is left unchanged.
+     * @param {number} target_data_version
+     * @returns {any}
+     */
+    toLitematicForVersion(target_data_version) {
+        const ret = wasm.schematicwrapper_toLitematicForVersion(this.__wbg_ptr, target_data_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {number} x
      * @param {number} y
@@ -5388,6 +5860,18 @@ export class SchematicWrapper {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Every block entity as `{id, position:[x,y,z], snbt}` — the batch,
+     * precision-faithful read the editor bridge uses on load to attach each
+     * block entity's full NBT (as a typed SNBT string) to its block. The `snbt`
+     * is the block entity's inner data only (no `Id`/`Pos`); pair it with `id`
+     * and the position when writing back via `setBlockEntity`.
+     * @returns {Array<any>}
+     */
+    getAllBlockEntitiesSnbt() {
+        const ret = wasm.schematicwrapper_getAllBlockEntitiesSnbt(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * @returns {Array<any>}
      */
@@ -5670,55 +6154,6 @@ export class SchematicWrapper {
         const len0 = WASM_VECTOR_LEN;
         wasm.schematicwrapper_set_block(this.__wbg_ptr, x, y, z, ptr0, len0);
     }
-    /**
-     * 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]);
-    }
-    /**
-     * 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]);
-    }
     /**
      * Generate raw mesh data for custom rendering pipelines.
      * @param {ResourcePackWrapper} pack
@@ -7072,6 +7507,243 @@ export class WasmBuildingTool {
 }
 if (Symbol.dispose) WasmBuildingTool.prototype[Symbol.dispose] = WasmBuildingTool.prototype.free;
 
+export class WorldChunkIterWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WorldChunkIterWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        WorldChunkIterWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorldChunkIterWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_worldchunkiterwrapper_free(ptr, 0);
+    }
+    /**
+     * Returns the next chunk, or `null`/`undefined` at the end of the stream.
+     * Throws if the chunk is corrupt or unreadable.
+     * @returns {WorldChunkViewWrapper | undefined}
+     */
+    next() {
+        const ret = wasm.worldchunkiterwrapper_next(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : WorldChunkViewWrapper.__wrap(ret[0]);
+    }
+    /**
+     * @returns {boolean}
+     */
+    has_next() {
+        const ret = wasm.worldchunkiterwrapper_has_next(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) WorldChunkIterWrapper.prototype[Symbol.dispose] = WorldChunkIterWrapper.prototype.free;
+
+export class WorldChunkViewWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WorldChunkViewWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        WorldChunkViewWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorldChunkViewWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_worldchunkviewwrapper_free(ptr, 0);
+    }
+    /**
+     * @returns {SchematicWrapper}
+     */
+    to_schematic() {
+        const ret = wasm.worldchunkviewwrapper_to_schematic(this.__wbg_ptr);
+        return SchematicWrapper.__wrap(ret);
+    }
+    /**
+     * Deduped union of all sections' biome palette entries, in order of
+     * first appearance. Empty if no section carries biome data.
+     * @returns {string[]}
+     */
+    biome_palette() {
+        const ret = wasm.worldchunkviewwrapper_biome_palette(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    cx() {
+        const ret = wasm.worldchunkviewwrapper_cx(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    cz() {
+        const ret = wasm.worldchunkviewwrapper_cz(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Create an empty chunk at the given chunk coordinates — the starting
+     * point for generating chunks from scratch. Sections are created on
+     * demand by `set_block`. In WASM there is no `WorldSink` (no filesystem),
+     * so fabricated chunks are used via `to_schematic()` or direct inspection
+     * (`get_block`, `y_range`, ...).
+     * @param {number} cx
+     * @param {number} cz
+     */
+    constructor(cx, cz) {
+        const ret = wasm.worldchunkviewwrapper_new(cx, cz);
+        this.__wbg_ptr = ret >>> 0;
+        WorldChunkViewWrapperFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Returns `[min_y, max_y]` (inclusive on both ends).
+     * @returns {Int32Array}
+     */
+    y_range() {
+        const ret = wasm.worldchunkviewwrapper_y_range(this.__wbg_ptr);
+        var v1 = getArrayI32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Returns the block name at world coordinates (e.g. `"minecraft:air"` for air cells),
+     * or `undefined`/`null` if the coordinates fall outside the chunk's loaded sections.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {string | undefined}
+     */
+    get_block(x, y, z) {
+        const ret = wasm.worldchunkviewwrapper_get_block(this.__wbg_ptr, x, y, z);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Overwrite the biome of every currently-present section with
+     * `biome_name` (e.g. `"minecraft:desert"`). Sections are created lazily
+     * by `set_block`, so call this AFTER placing blocks. Coarse chunk-level
+     * control; existing multi-biome data round-trips losslessly if you
+     * don't call this.
+     * @param {string} biome_name
+     */
+    set_biome(biome_name) {
+        const ptr0 = passStringToWasm0(biome_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.worldchunkviewwrapper_set_biome(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Set the block at world coordinates `(x, y, z)` by name. Returns `true`
+     * on success, `false` if `(x, z)` falls outside this chunk. Creates the
+     * section if the Y level has none.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {string} block_name
+     * @returns {boolean}
+     */
+    set_block(x, y, z, block_name) {
+        const ptr0 = passStringToWasm0(block_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worldchunkviewwrapper_set_block(this.__wbg_ptr, x, y, z, ptr0, len0);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) WorldChunkViewWrapper.prototype[Symbol.dispose] = WorldChunkViewWrapper.prototype.free;
+
+export class WorldSourceWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WorldSourceWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        WorldSourceWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WorldSourceWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_worldsourcewrapper_free(ptr, 0);
+    }
+    /**
+     * @param {number} min_x
+     * @param {number} min_y
+     * @param {number} min_z
+     * @param {number} max_x
+     * @param {number} max_y
+     * @param {number} max_z
+     * @returns {WorldChunkIterWrapper}
+     */
+    chunks_bounded(min_x, min_y, min_z, max_x, max_y, max_z) {
+        const ret = wasm.worldsourcewrapper_chunks_bounded(this.__wbg_ptr, min_x, min_y, min_z, max_x, max_y, max_z);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorldChunkIterWrapper.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {WorldSourceWrapper}
+     */
+    static from_mca_bytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worldsourcewrapper_from_mca_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorldSourceWrapper.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} data
+     * @returns {WorldSourceWrapper}
+     */
+    static from_zip_bytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.worldsourcewrapper_from_zip_bytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorldSourceWrapper.__wrap(ret[0]);
+    }
+    /**
+     * @returns {WorldChunkIterWrapper}
+     */
+    chunks() {
+        const ret = wasm.worldsourcewrapper_chunks(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return WorldChunkIterWrapper.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) WorldSourceWrapper.prototype[Symbol.dispose] = WorldSourceWrapper.prototype.free;
+
 /**
  * Build a resource pack ZIP from multiple item model results.
  *
@@ -7333,6 +8005,10 @@ function __wbg_get_imports() {
         const ret = arg0.call(arg1, arg2, arg3);
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+        const ret = arg0.crypto;
+        return ret;
+    };
     imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
         const ret = Object.entries(arg0);
         return ret;
@@ -7355,6 +8031,9 @@ function __wbg_get_imports() {
         const ret = Array.from(arg0);
         return ret;
     };
+    imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
+        arg0.getRandomValues(arg1);
+    }, arguments) };
     imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
         const ret = arg0[arg1 >>> 0];
         return ret;
@@ -7406,6 +8085,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_log_1d990106d99dacb7 = function(arg0) {
         console.log(arg0);
     };
+    imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+        const ret = arg0.msCrypto;
+        return ret;
+    };
     imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
         const ret = new Object();
         return ret;
@@ -7442,6 +8125,10 @@ function __wbg_get_imports() {
         const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
         return ret;
     };
+    imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_new_with_length_12c6de4fac33117a = function(arg0) {
         const ret = new Array(arg0 >>> 0);
         return ret;
@@ -7450,6 +8137,10 @@ function __wbg_get_imports() {
         const ret = new Uint8Array(arg0 >>> 0);
         return ret;
     };
+    imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
+        const ret = arg0.node;
+        return ret;
+    };
     imports.wbg.__wbg_now_69d776cd24f5215b = function() {
         const ret = Date.now();
         return ret;
@@ -7458,6 +8149,14 @@ function __wbg_get_imports() {
         const ret = Array.of(arg0, arg1, arg2);
         return ret;
     };
+    imports.wbg.__wbg_parse_a09a54cf72639456 = function() { return handleError(function (arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+        const ret = arg0.process;
+        return ret;
+    };
     imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -7465,6 +8164,13 @@ function __wbg_get_imports() {
         const ret = arg0.push(arg1);
         return ret;
     };
+    imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
+        arg0.randomFillSync(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
+        const ret = module.require;
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_set_169e13b608078b7b = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
@@ -7492,6 +8198,30 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
+    imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_subarray_845f2f5bce7d061a = function(arg0, arg1, arg2) {
+        const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+        const ret = arg0.versions;
+        return ret;
+    };
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(arg0);
     };
@@ -7510,6 +8240,11 @@ function __wbg_get_imports() {
         const ret = arg0;
         return ret;
     };
+    imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+        const ret = getArrayU8FromWasm0(arg0, arg1);
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
         // Cast intrinsic for `F64 -> Externref`.
         const ret = arg0;