nucleation 0.2.4 → 0.2.6

package/nucleation-original.js

@@ -1401,6 +1401,21 @@ export class DefinitionRegionWrapper {
         const ret = wasm.definitionregionwrapper_metadataKeys(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Fluent alias for `setMetadata` — returns the region for chaining.
+     * @param {string} key
+     * @param {string} value
+     * @returns {DefinitionRegionWrapper}
+     */
+    withMetadata(key, value) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.definitionregionwrapper_setMetadata(ptr, ptr0, len0, ptr1, len1);
+        return DefinitionRegionWrapper.__wrap(ret);
+    }
     /**
      * Create a DefinitionRegion from an array of positions
      *
@@ -3820,6 +3835,22 @@ export class SchematicBuilderWrapper {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_schematicbuilderwrapper_free(ptr, 0);
     }
+    /**
+     * Serialize the builder back into the canonical template format.
+     * @returns {string}
+     */
+    toTemplate() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.schematicbuilderwrapper_toTemplate(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);
+        }
+    }
     /**
      * Create from template string
      * @param {string} template
@@ -3834,6 +3865,34 @@ export class SchematicBuilderWrapper {
         }
         return SchematicBuilderWrapper.__wrap(ret[0]);
     }
+    /**
+     * Apply the compact palette (single-glyph redstone shapes).
+     * @returns {SchematicBuilderWrapper}
+     */
+    useCompactPalette() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_useCompactPalette(ptr);
+        return SchematicBuilderWrapper.__wrap(ret);
+    }
+    /**
+     * Apply the minimal palette (`c` and space only).
+     * @returns {SchematicBuilderWrapper}
+     */
+    useMinimalPalette() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_useMinimalPalette(ptr);
+        return SchematicBuilderWrapper.__wrap(ret);
+    }
+    /**
+     * Apply the standard palette (gray concrete, air, plus the
+     * named-direction characters used in the canonical examples).
+     * @returns {SchematicBuilderWrapper}
+     */
+    useStandardPalette() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_useStandardPalette(ptr);
+        return SchematicBuilderWrapper.__wrap(ret);
+    }
     /**
      * Map a character to a block string
      * @param {string} ch
@@ -3882,6 +3941,20 @@ export class SchematicBuilderWrapper {
         }
         return SchematicWrapper.__wrap(ret[0]);
     }
+    /**
+     * Append a single layer (`string[]` of rows). Equivalent to
+     * `layers([rows])` but doesn't require nesting for a single layer.
+     * @param {any} rows
+     * @returns {SchematicBuilderWrapper}
+     */
+    layer(rows) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_layer(ptr, rows);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SchematicBuilderWrapper.__wrap(ret[0]);
+    }
     /**
      * Add multiple layers (array of arrays of strings)
      * @param {any} layers
@@ -3895,6 +3968,43 @@ export class SchematicBuilderWrapper {
         }
         return SchematicBuilderWrapper.__wrap(ret[0]);
     }
+    /**
+     * Set the world offset of the resulting schematic.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {SchematicBuilderWrapper}
+     */
+    offset(x, y, z) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_offset(ptr, x, y, z);
+        return SchematicBuilderWrapper.__wrap(ret);
+    }
+    /**
+     * Bulk version of `map`. Pass either an `Object` literal
+     * (`{ c: "minecraft:stone", " ": "minecraft:air" }`) or an array
+     * of `[char, block]` pairs.
+     * @param {any} mappings
+     * @returns {SchematicBuilderWrapper}
+     */
+    palette(mappings) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.schematicbuilderwrapper_palette(ptr, mappings);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SchematicBuilderWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Run pre-build validation. Throws if the layered template is
+     * malformed (missing palette mapping, ragged rows, etc.).
+     */
+    validate() {
+        const ret = wasm.schematicbuilderwrapper_validate(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) SchematicBuilderWrapper.prototype[Symbol.dispose] = SchematicBuilderWrapper.prototype.free;
 
@@ -3916,6 +4026,205 @@ export class SchematicWrapper {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_schematicwrapper_free(ptr, 0);
     }
+    /**
+     * Generate raw mesh data for custom rendering pipelines.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {RawMeshExportWrapper}
+     */
+    toRawMesh(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_toRawMesh(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RawMeshExportWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Generate one mesh per 16x16x16 chunk (eager, all at once).
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {ChunkMeshResultWrapper}
+     */
+    meshByChunk(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_meshByChunk(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ChunkMeshResultWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Generate a Minecraft item model using the plane-based approach.
+     * @param {ResourcePackWrapper} pack
+     * @param {ItemModelConfigWrapper} config
+     * @returns {ItemModelResultWrapper}
+     */
+    toItemModel(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, ItemModelConfigWrapper);
+        const ret = wasm.schematicwrapper_toItemModel(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ItemModelResultWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Generate one mesh per region.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {MultiMeshResultWrapper}
+     */
+    meshByRegion(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_meshByRegion(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MultiMeshResultWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Build a single shared texture atlas from all unique block states.
+     *
+     * The atlas can be reused across all chunks via `chunkMeshIteratorWithAtlas()`,
+     * eliminating per-chunk atlas duplication for massive schematics.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {TextureAtlasWrapper}
+     */
+    buildGlobalAtlas(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_buildGlobalAtlas(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TextureAtlasWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Generate one mesh per chunk of the specified size (eager).
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @param {number} chunk_size
+     * @returns {ChunkMeshResultWrapper}
+     */
+    meshByChunkSize(pack, config, chunk_size) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_meshByChunkSize(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ChunkMeshResultWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Create a lazy chunk mesh iterator.
+     *
+     * Call `advance()` to step to the next chunk, then `current()` to get the
+     * mesh. Never loads the full world mesh into memory.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @param {number} chunk_size
+     * @returns {ChunkMeshIteratorWrapper}
+     */
+    chunkMeshIterator(pack, config, chunk_size) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_chunkMeshIterator(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size);
+        return ChunkMeshIteratorWrapper.__wrap(ret);
+    }
+    /**
+     * Register a mesh exporter with the FormatManager, enabling save_as("mesh", ...).
+     * @param {ResourcePackWrapper} pack
+     */
+    registerMeshExporter(pack) {
+        _assertClass(pack, ResourcePackWrapper);
+        const ret = wasm.schematicwrapper_registerMeshExporter(this.__wbg_ptr, pack.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Create a lazy chunk mesh iterator that uses a pre-built global atlas.
+     *
+     * The global atlas is shared across all chunks, eliminating per-chunk atlas
+     * duplication. Build the atlas first with `buildGlobalAtlas()`.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @param {number} chunk_size
+     * @param {TextureAtlasWrapper} atlas
+     * @returns {ChunkMeshIteratorWrapper}
+     */
+    chunkMeshIteratorWithAtlas(pack, config, chunk_size, atlas) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        _assertClass(atlas, TextureAtlasWrapper);
+        const ret = wasm.schematicwrapper_chunkMeshIteratorWithAtlas(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size, atlas.__wbg_ptr);
+        return ChunkMeshIteratorWrapper.__wrap(ret);
+    }
+    /**
+     * Generate a single mesh for the entire schematic.
+     *
+     * Returns a [`MeshOutputWrapper`] with per-layer typed arrays, atlas, and GLB data.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {MeshOutputWrapper}
+     */
+    toMesh(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_toMesh(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MeshOutputWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Generate a USDZ mesh for the entire schematic.
+     * @param {ResourcePackWrapper} pack
+     * @param {MeshConfigWrapper} config
+     * @returns {MeshOutputWrapper}
+     */
+    toUsdz(pack, config) {
+        _assertClass(pack, ResourcePackWrapper);
+        _assertClass(config, MeshConfigWrapper);
+        const ret = wasm.schematicwrapper_toUsdz(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MeshOutputWrapper.__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
@@ -4754,7 +5063,7 @@ export class SchematicWrapper {
      * @returns {CircuitBuilderWrapper}
      */
     createCircuitBuilder() {
-        const ret = wasm.schematicwrapper_createCircuitBuilder(this.__wbg_ptr);
+        const ret = wasm.circuitbuilderwrapper_new(this.__wbg_ptr);
         return CircuitBuilderWrapper.__wrap(ret);
     }
     /**
@@ -5250,205 +5559,6 @@ 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]);
-    }
-    /**
-     * Generate raw mesh data for custom rendering pipelines.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {RawMeshExportWrapper}
-     */
-    toRawMesh(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_toRawMesh(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return RawMeshExportWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Generate one mesh per 16x16x16 chunk (eager, all at once).
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {ChunkMeshResultWrapper}
-     */
-    meshByChunk(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_meshByChunk(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ChunkMeshResultWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Generate a Minecraft item model using the plane-based approach.
-     * @param {ResourcePackWrapper} pack
-     * @param {ItemModelConfigWrapper} config
-     * @returns {ItemModelResultWrapper}
-     */
-    toItemModel(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, ItemModelConfigWrapper);
-        const ret = wasm.schematicwrapper_toItemModel(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ItemModelResultWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Generate one mesh per region.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {MultiMeshResultWrapper}
-     */
-    meshByRegion(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_meshByRegion(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return MultiMeshResultWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Build a single shared texture atlas from all unique block states.
-     *
-     * The atlas can be reused across all chunks via `chunkMeshIteratorWithAtlas()`,
-     * eliminating per-chunk atlas duplication for massive schematics.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {TextureAtlasWrapper}
-     */
-    buildGlobalAtlas(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_buildGlobalAtlas(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return TextureAtlasWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Generate one mesh per chunk of the specified size (eager).
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @param {number} chunk_size
-     * @returns {ChunkMeshResultWrapper}
-     */
-    meshByChunkSize(pack, config, chunk_size) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_meshByChunkSize(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ChunkMeshResultWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Create a lazy chunk mesh iterator.
-     *
-     * Call `advance()` to step to the next chunk, then `current()` to get the
-     * mesh. Never loads the full world mesh into memory.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @param {number} chunk_size
-     * @returns {ChunkMeshIteratorWrapper}
-     */
-    chunkMeshIterator(pack, config, chunk_size) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_chunkMeshIterator(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size);
-        return ChunkMeshIteratorWrapper.__wrap(ret);
-    }
-    /**
-     * Register a mesh exporter with the FormatManager, enabling save_as("mesh", ...).
-     * @param {ResourcePackWrapper} pack
-     */
-    registerMeshExporter(pack) {
-        _assertClass(pack, ResourcePackWrapper);
-        const ret = wasm.schematicwrapper_registerMeshExporter(this.__wbg_ptr, pack.__wbg_ptr);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * Create a lazy chunk mesh iterator that uses a pre-built global atlas.
-     *
-     * The global atlas is shared across all chunks, eliminating per-chunk atlas
-     * duplication. Build the atlas first with `buildGlobalAtlas()`.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @param {number} chunk_size
-     * @param {TextureAtlasWrapper} atlas
-     * @returns {ChunkMeshIteratorWrapper}
-     */
-    chunkMeshIteratorWithAtlas(pack, config, chunk_size, atlas) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        _assertClass(atlas, TextureAtlasWrapper);
-        const ret = wasm.schematicwrapper_chunkMeshIteratorWithAtlas(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr, chunk_size, atlas.__wbg_ptr);
-        return ChunkMeshIteratorWrapper.__wrap(ret);
-    }
-    /**
-     * Generate a single mesh for the entire schematic.
-     *
-     * Returns a [`MeshOutputWrapper`] with per-layer typed arrays, atlas, and GLB data.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {MeshOutputWrapper}
-     */
-    toMesh(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_toMesh(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return MeshOutputWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Generate a USDZ mesh for the entire schematic.
-     * @param {ResourcePackWrapper} pack
-     * @param {MeshConfigWrapper} config
-     * @returns {MeshOutputWrapper}
-     */
-    toUsdz(pack, config) {
-        _assertClass(pack, ResourcePackWrapper);
-        _assertClass(config, MeshConfigWrapper);
-        const ret = wasm.schematicwrapper_toUsdz(this.__wbg_ptr, pack.__wbg_ptr, config.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return MeshOutputWrapper.__wrap(ret[0]);
-    }
 }
 if (Symbol.dispose) SchematicWrapper.prototype[Symbol.dispose] = SchematicWrapper.prototype.free;
 
@@ -6647,6 +6757,11 @@ function __wbg_get_imports() {
         const ret = arg0 === null;
         return ret;
     };
+    imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
     imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
         const ret = typeof(arg0) === 'string';
         return ret;