nucleation 0.1.156 → 0.1.166

package/nucleation-original.js

@@ -81,6 +81,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayI32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
@@ -97,6 +102,11 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -110,6 +120,14 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
 let cachedInt32ArrayMemory0 = null;
 function getInt32ArrayMemory0() {
     if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
@@ -260,6 +278,14 @@ const BrushWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_brushwrapper_free(ptr >>> 0, 1));
 
+const ChunkMeshIteratorWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkmeshiteratorwrapper_free(ptr >>> 0, 1));
+
+const ChunkMeshResultWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chunkmeshresultwrapper_free(ptr >>> 0, 1));
+
 const CircuitBuilderWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_circuitbuilderwrapper_free(ptr >>> 0, 1));
@@ -296,6 +322,18 @@ const MchprsWorldWrapperFinalization = (typeof FinalizationRegistry === 'undefin
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_mchprsworldwrapper_free(ptr >>> 0, 1));
 
+const MeshConfigWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshconfigwrapper_free(ptr >>> 0, 1));
+
+const MeshOutputWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshoutputwrapper_free(ptr >>> 0, 1));
+
+const MultiMeshResultWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multimeshresultwrapper_free(ptr >>> 0, 1));
+
 const OutputConditionWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_outputconditionwrapper_free(ptr >>> 0, 1));
@@ -304,6 +342,14 @@ const PaletteManagerFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_palettemanager_free(ptr >>> 0, 1));
 
+const RawMeshExportWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rawmeshexportwrapper_free(ptr >>> 0, 1));
+
+const ResourcePackWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_resourcepackwrapper_free(ptr >>> 0, 1));
+
 const SchematicBuilderWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_schematicbuilderwrapper_free(ptr >>> 0, 1));
@@ -328,6 +374,10 @@ const StateModeConstantsFinalization = (typeof FinalizationRegistry === 'undefin
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_statemodeconstants_free(ptr >>> 0, 1));
 
+const TextureAtlasWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_textureatlaswrapper_free(ptr >>> 0, 1));
+
 const TypedCircuitExecutorWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_typedcircuitexecutorwrapper_free(ptr >>> 0, 1));
@@ -623,6 +673,170 @@ export class BrushWrapper {
 }
 if (Symbol.dispose) BrushWrapper.prototype[Symbol.dispose] = BrushWrapper.prototype.free;
 
+/**
+ * Lazy chunk mesh iterator for WASM.
+ *
+ * Pull-based: call `advance()` to step to the next chunk, then
+ * `current()` to get the [`MeshOutputWrapper`].
+ */
+export class ChunkMeshIteratorWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChunkMeshIteratorWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkMeshIteratorWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkMeshIteratorWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkmeshiteratorwrapper_free(ptr, 0);
+    }
+    /**
+     * Total number of chunks in the iterator.
+     * @returns {number}
+     */
+    chunkCount() {
+        const ret = wasm.chunkmeshiteratorwrapper_chunkCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the shared atlas (if any). Returns null if no shared atlas was set.
+     * @returns {TextureAtlasWrapper | undefined}
+     */
+    sharedAtlas() {
+        const ret = wasm.chunkmeshiteratorwrapper_sharedAtlas(this.__wbg_ptr);
+        return ret === 0 ? undefined : TextureAtlasWrapper.__wrap(ret);
+    }
+    /**
+     * Get the chunk coordinate of the current mesh as [cx, cy, cz].
+     * @returns {any}
+     */
+    currentCoord() {
+        const ret = wasm.chunkmeshiteratorwrapper_currentCoord(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether this iterator uses a shared global atlas.
+     * @returns {boolean}
+     */
+    get hasSharedAtlas() {
+        const ret = wasm.chunkmeshiteratorwrapper_hasSharedAtlas(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Set a progress callback invoked after each chunk is meshed.
+     *
+     * The callback receives a JS object with fields:
+     * `{ phase: string, chunksDone: number, chunksTotal: number, verticesSoFar: number, trianglesSoFar: number }`
+     * @param {Function} callback
+     */
+    setProgressCallback(callback) {
+        wasm.chunkmeshiteratorwrapper_setProgressCallback(this.__wbg_ptr, callback);
+    }
+    /**
+     * Advance to the next chunk. Returns `true` if a chunk is available.
+     * @returns {boolean}
+     */
+    advance() {
+        const ret = wasm.chunkmeshiteratorwrapper_advance(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Get the current chunk mesh (after a successful `advance()`).
+     * Returns null if no current mesh.
+     * @returns {MeshOutputWrapper | undefined}
+     */
+    current() {
+        const ret = wasm.chunkmeshiteratorwrapper_current(this.__wbg_ptr);
+        return ret === 0 ? undefined : MeshOutputWrapper.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ChunkMeshIteratorWrapper.prototype[Symbol.dispose] = ChunkMeshIteratorWrapper.prototype.free;
+
+/**
+ * Result of chunk-based mesh generation (eager, all at once).
+ */
+export class ChunkMeshResultWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChunkMeshResultWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        ChunkMeshResultWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChunkMeshResultWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chunkmeshresultwrapper_free(ptr, 0);
+    }
+    /**
+     * Get the number of chunks.
+     * @returns {number}
+     */
+    get chunkCount() {
+        const ret = wasm.chunkmeshresultwrapper_chunkCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the total vertex count.
+     * @returns {number}
+     */
+    get totalVertexCount() {
+        const ret = wasm.chunkmeshresultwrapper_totalVertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the total triangle count.
+     * @returns {number}
+     */
+    get totalTriangleCount() {
+        const ret = wasm.chunkmeshresultwrapper_totalTriangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the chunk coordinates as an array of [x, y, z] arrays.
+     * @returns {Array<any>}
+     */
+    getChunkCoordinates() {
+        const ret = wasm.chunkmeshresultwrapper_getChunkCoordinates(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Serialize all chunks to NUCM binary cache format as Uint8Array.
+     * @returns {Uint8Array}
+     */
+    toNucm() {
+        const ret = wasm.chunkmeshresultwrapper_toNucm(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the mesh for a specific chunk.
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @returns {MeshOutputWrapper | undefined}
+     */
+    getMesh(cx, cy, cz) {
+        const ret = wasm.chunkmeshresultwrapper_getMesh(this.__wbg_ptr, cx, cy, cz);
+        return ret === 0 ? undefined : MeshOutputWrapper.__wrap(ret);
+    }
+}
+if (Symbol.dispose) ChunkMeshResultWrapper.prototype[Symbol.dispose] = ChunkMeshResultWrapper.prototype.free;
+
 /**
  * CircuitBuilder wrapper for JavaScript
  * Provides a fluent API for creating TypedCircuitExecutor instances
@@ -2288,135 +2502,956 @@ export class MchprsWorldWrapper {
 if (Symbol.dispose) MchprsWorldWrapper.prototype[Symbol.dispose] = MchprsWorldWrapper.prototype.free;
 
 /**
- * OutputCondition for conditional execution
+ * Configuration for mesh generation.
  */
-export class OutputConditionWrapper {
+export class MeshConfigWrapper {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MeshConfigWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshconfigwrapper_free(ptr, 0);
+    }
+    /**
+     * Get the AO intensity.
+     * @returns {number}
+     */
+    get aoIntensity() {
+        const ret = wasm.meshconfigwrapper_aoIntensity(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the maximum atlas size.
+     * @returns {number}
+     */
+    get atlasMaxSize() {
+        const ret = wasm.chunkmeshresultwrapper_chunkCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get whether greedy meshing is enabled.
+     * @returns {boolean}
+     */
+    get greedyMeshing() {
+        const ret = wasm.meshconfigwrapper_greedyMeshing(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Set the AO intensity (0.0 = no darkening, 1.0 = full darkening).
+     * @param {number} intensity
+     */
+    setAoIntensity(intensity) {
+        wasm.meshconfigwrapper_setAoIntensity(this.__wbg_ptr, intensity);
+    }
+    /**
+     * Get whether ambient occlusion is enabled.
+     * @returns {boolean}
+     */
+    get ambientOcclusion() {
+        const ret = wasm.meshconfigwrapper_ambientOcclusion(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get whether face culling is enabled.
+     * @returns {boolean}
+     */
+    get cullHiddenFaces() {
+        const ret = wasm.meshconfigwrapper_cullHiddenFaces(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Set the maximum atlas texture size.
+     * @param {number} size
+     */
+    setAtlasMaxSize(size) {
+        wasm.meshconfigwrapper_setAtlasMaxSize(this.__wbg_ptr, size);
+    }
+    /**
+     * Enable or disable greedy meshing.
+     * @param {boolean} enabled
+     */
+    setGreedyMeshing(enabled) {
+        wasm.meshconfigwrapper_setGreedyMeshing(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Get whether occluded block culling is enabled.
+     * @returns {boolean}
+     */
+    get cullOccludedBlocks() {
+        const ret = wasm.meshconfigwrapper_cullOccludedBlocks(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Enable or disable ambient occlusion.
+     * @param {boolean} enabled
+     */
+    setAmbientOcclusion(enabled) {
+        wasm.meshconfigwrapper_setAmbientOcclusion(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Enable or disable face culling between adjacent blocks.
+     * @param {boolean} enabled
+     */
+    setCullHiddenFaces(enabled) {
+        wasm.meshconfigwrapper_setCullHiddenFaces(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Enable or disable occluded block culling.
+     * @param {boolean} enabled
+     */
+    setCullOccludedBlocks(enabled) {
+        wasm.meshconfigwrapper_setCullOccludedBlocks(this.__wbg_ptr, enabled);
+    }
+    /**
+     * Create a new MeshConfig with default settings.
+     */
+    constructor() {
+        const ret = wasm.meshconfigwrapper_new();
+        this.__wbg_ptr = ret >>> 0;
+        MeshConfigWrapperFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the biome name.
+     * @returns {string | undefined}
+     */
+    get biome() {
+        const ret = wasm.meshconfigwrapper_biome(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Set the biome for tinting (e.g., "plains", "swamp").
+     * @param {string} biome
+     */
+    setBiome(biome) {
+        const ptr0 = passStringToWasm0(biome, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.meshconfigwrapper_setBiome(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) MeshConfigWrapper.prototype[Symbol.dispose] = MeshConfigWrapper.prototype.free;
+
+/**
+ * WASM wrapper for [`MeshOutput`].
+ *
+ * Exposes per-layer typed arrays (opaque, cutout, transparent), shared atlas,
+ * export helpers, and metadata. This is the primary return type for all
+ * meshing methods.
+ */
+export class MeshOutputWrapper {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(OutputConditionWrapper.prototype);
+        const obj = Object.create(MeshOutputWrapper.prototype);
         obj.__wbg_ptr = ptr;
-        OutputConditionWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        MeshOutputWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        OutputConditionWrapperFinalization.unregister(this);
+        MeshOutputWrapperFinalization.unregister(this);
         return ptr;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_outputconditionwrapper_free(ptr, 0);
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_meshoutputwrapper_free(ptr, 0);
+    }
+    /**
+     * Shared texture atlas RGBA pixel data as Uint8Array.
+     * @returns {Uint8Array}
+     */
+    atlasRgba() {
+        const ret = wasm.meshoutputwrapper_atlasRgba(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Cutout layer texture coordinates as Float32Array.
+     * @returns {Float32Array}
+     */
+    cutoutUvs() {
+        const ret = wasm.meshoutputwrapper_cutoutUvs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Opaque layer texture coordinates as Float32Array (u,v per vertex).
+     * @returns {Float32Array}
+     */
+    opaqueUvs() {
+        const ret = wasm.meshoutputwrapper_opaqueUvs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Atlas width in pixels.
+     * @returns {number}
+     */
+    get atlasWidth() {
+        const ret = wasm.meshoutputwrapper_atlasWidth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Chunk coordinate as [cx, cy, cz] or null if not a chunk mesh.
+     * @returns {any}
+     */
+    chunkCoord() {
+        const ret = wasm.meshoutputwrapper_chunkCoord(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Atlas height in pixels.
+     * @returns {number}
+     */
+    get atlasHeight() {
+        const ret = wasm.meshoutputwrapper_atlasHeight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the vertex count (backward-compat).
+     * @returns {number}
+     */
+    get vertexCount() {
+        const ret = wasm.meshoutputwrapper_totalVertices(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Cutout layer vertex colors as Float32Array.
+     * @returns {Float32Array}
+     */
+    cutoutColors() {
+        const ret = wasm.meshoutputwrapper_cutoutColors(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Opaque layer vertex colors as Float32Array (r,g,b,a per vertex).
+     * @returns {Float32Array}
+     */
+    opaqueColors() {
+        const ret = wasm.meshoutputwrapper_opaqueColors(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Cutout layer triangle indices as Uint32Array.
+     * @returns {Uint32Array}
+     */
+    cutoutIndices() {
+        const ret = wasm.meshoutputwrapper_cutoutIndices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Cutout layer vertex normals as Float32Array.
+     * @returns {Float32Array}
+     */
+    cutoutNormals() {
+        const ret = wasm.meshoutputwrapper_cutoutNormals(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Opaque layer triangle indices as Uint32Array.
+     * @returns {Uint32Array}
+     */
+    opaqueIndices() {
+        const ret = wasm.meshoutputwrapper_opaqueIndices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Opaque layer vertex normals as Float32Array.
+     * @returns {Float32Array}
+     */
+    opaqueNormals() {
+        const ret = wasm.meshoutputwrapper_opaqueNormals(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Total vertex count across all layers.
+     * @returns {number}
+     */
+    get totalVertices() {
+        const ret = wasm.meshoutputwrapper_totalVertices(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the triangle count (backward-compat).
+     * @returns {number}
+     */
+    get triangleCount() {
+        const ret = wasm.meshoutputwrapper_totalTriangles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Total triangle count across all layers.
+     * @returns {number}
+     */
+    get totalTriangles() {
+        const ret = wasm.meshoutputwrapper_totalTriangles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Transparent layer texture coordinates as Float32Array.
+     * @returns {Float32Array}
+     */
+    transparentUvs() {
+        const ret = wasm.meshoutputwrapper_transparentUvs(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Cutout layer vertex positions as Float32Array.
+     * @returns {Float32Array}
+     */
+    cutoutPositions() {
+        const ret = wasm.meshoutputwrapper_cutoutPositions(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Whether the mesh has transparent geometry.
+     * @returns {boolean}
+     */
+    get hasTransparency() {
+        const ret = wasm.meshoutputwrapper_hasTransparency(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Opaque layer vertex positions as Float32Array (x,y,z per vertex).
+     * @returns {Float32Array}
+     */
+    opaquePositions() {
+        const ret = wasm.meshoutputwrapper_opaquePositions(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Transparent layer vertex colors as Float32Array.
+     * @returns {Float32Array}
+     */
+    transparentColors() {
+        const ret = wasm.meshoutputwrapper_transparentColors(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Transparent layer triangle indices as Uint32Array.
+     * @returns {Uint32Array}
+     */
+    transparentIndices() {
+        const ret = wasm.meshoutputwrapper_transparentIndices(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Transparent layer vertex normals as Float32Array.
+     * @returns {Float32Array}
+     */
+    transparentNormals() {
+        const ret = wasm.meshoutputwrapper_transparentNormals(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Transparent layer vertex positions as Float32Array.
+     * @returns {Float32Array}
+     */
+    transparentPositions() {
+        const ret = wasm.meshoutputwrapper_transparentPositions(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
+     * @returns {Array<any>}
+     */
+    get bounds() {
+        const ret = wasm.meshoutputwrapper_bounds(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get GLB binary data as Uint8Array.
+     * @returns {Uint8Array}
+     */
+    toGlb() {
+        const ret = wasm.meshoutputwrapper_toGlb(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get NUCM binary cache data as Uint8Array.
+     *
+     * Serializes this single mesh chunk to the `.nucm` binary format.
+     * @returns {Uint8Array}
+     */
+    toNucm() {
+        const ret = wasm.meshoutputwrapper_toNucm(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get USDZ binary data as Uint8Array.
+     * @returns {Uint8Array}
+     */
+    toUsdz() {
+        const ret = wasm.meshoutputwrapper_toUsdz(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Get the GLB binary data (backward-compat getter).
+     * @returns {Uint8Array}
+     */
+    get glbData() {
+        const ret = wasm.meshoutputwrapper_glbData(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * Whether all layers are empty.
+     * @returns {boolean}
+     */
+    get isEmpty() {
+        const ret = wasm.meshoutputwrapper_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get mesh statistics as a JS object.
+     * @returns {object}
+     */
+    getStats() {
+        const ret = wasm.meshoutputwrapper_getStats(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * LOD level (0 = full detail).
+     * @returns {number}
+     */
+    get lodLevel() {
+        const ret = wasm.meshoutputwrapper_lodLevel(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) MeshOutputWrapper.prototype[Symbol.dispose] = MeshOutputWrapper.prototype.free;
+
+/**
+ * Result of per-region mesh generation.
+ *
+ * Wraps a `HashMap<String, MeshOutput>` for WASM consumption.
+ */
+export class MultiMeshResultWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MultiMeshResultWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        MultiMeshResultWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MultiMeshResultWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_multimeshresultwrapper_free(ptr, 0);
+    }
+    /**
+     * Get the number of meshes.
+     * @returns {number}
+     */
+    get meshCount() {
+        const ret = wasm.chunkmeshresultwrapper_chunkCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the region names.
+     * @returns {Array<any>}
+     */
+    getRegionNames() {
+        const ret = wasm.multimeshresultwrapper_getRegionNames(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get the total vertex count across all regions.
+     * @returns {number}
+     */
+    get totalVertexCount() {
+        const ret = wasm.multimeshresultwrapper_totalVertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the total triangle count across all regions.
+     * @returns {number}
+     */
+    get totalTriangleCount() {
+        const ret = wasm.multimeshresultwrapper_totalTriangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the mesh for a specific region.
+     * @param {string} region_name
+     * @returns {MeshOutputWrapper | undefined}
+     */
+    getMesh(region_name) {
+        const ptr0 = passStringToWasm0(region_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.multimeshresultwrapper_getMesh(this.__wbg_ptr, ptr0, len0);
+        return ret === 0 ? undefined : MeshOutputWrapper.__wrap(ret);
+    }
+}
+if (Symbol.dispose) MultiMeshResultWrapper.prototype[Symbol.dispose] = MultiMeshResultWrapper.prototype.free;
+
+/**
+ * OutputCondition for conditional execution
+ */
+export class OutputConditionWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OutputConditionWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        OutputConditionWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OutputConditionWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_outputconditionwrapper_free(ptr, 0);
+    }
+    /**
+     * Output not equals a value
+     * @param {ValueWrapper} value
+     * @returns {OutputConditionWrapper}
+     */
+    static notEquals(value) {
+        _assertClass(value, ValueWrapper);
+        const ret = wasm.outputconditionwrapper_notEquals(value.__wbg_ptr);
+        return OutputConditionWrapper.__wrap(ret);
+    }
+    /**
+     * Bitwise AND with mask
+     * @param {number} mask
+     * @returns {OutputConditionWrapper}
+     */
+    static bitwiseAnd(mask) {
+        const ret = wasm.outputconditionwrapper_bitwiseAnd(mask);
+        return OutputConditionWrapper.__wrap(ret);
+    }
+    /**
+     * Output greater than a value
+     * @param {ValueWrapper} value
+     * @returns {OutputConditionWrapper}
+     */
+    static greaterThan(value) {
+        _assertClass(value, ValueWrapper);
+        const ret = wasm.outputconditionwrapper_greaterThan(value.__wbg_ptr);
+        return OutputConditionWrapper.__wrap(ret);
+    }
+    /**
+     * Output equals a value
+     * @param {ValueWrapper} value
+     * @returns {OutputConditionWrapper}
+     */
+    static equals(value) {
+        _assertClass(value, ValueWrapper);
+        const ret = wasm.outputconditionwrapper_equals(value.__wbg_ptr);
+        return OutputConditionWrapper.__wrap(ret);
+    }
+    /**
+     * Output less than a value
+     * @param {ValueWrapper} value
+     * @returns {OutputConditionWrapper}
+     */
+    static lessThan(value) {
+        _assertClass(value, ValueWrapper);
+        const ret = wasm.outputconditionwrapper_lessThan(value.__wbg_ptr);
+        return OutputConditionWrapper.__wrap(ret);
+    }
+}
+if (Symbol.dispose) OutputConditionWrapper.prototype[Symbol.dispose] = OutputConditionWrapper.prototype.free;
+
+export class PaletteManager {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PaletteManagerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_palettemanager_free(ptr, 0);
+    }
+    /**
+     * Get all wool blocks
+     * @returns {string[]}
+     */
+    static getWoolBlocks() {
+        const ret = wasm.palettemanager_getWoolBlocks();
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get all concrete blocks
+     * @returns {string[]}
+     */
+    static getConcreteBlocks() {
+        const ret = wasm.palettemanager_getConcreteBlocks();
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get all terracotta blocks
+     * @returns {string[]}
+     */
+    static getTerracottaBlocks() {
+        const ret = wasm.palettemanager_getTerracottaBlocks();
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get a palette containing blocks matching ANY of the provided keywords
+     * Example: `["wool", "obsidian"]` gets all wool blocks AND obsidian
+     * @param {string[]} keywords
+     * @returns {string[]}
+     */
+    static getPaletteByKeywords(keywords) {
+        const ptr0 = passArrayJsValueToWasm0(keywords, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.palettemanager_getPaletteByKeywords(ptr0, len0);
+        var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+}
+if (Symbol.dispose) PaletteManager.prototype[Symbol.dispose] = PaletteManager.prototype.free;
+
+/**
+ * Result of raw mesh export for custom rendering.
+ */
+export class RawMeshExportWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RawMeshExportWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        RawMeshExportWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RawMeshExportWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rawmeshexportwrapper_free(ptr, 0);
+    }
+    /**
+     * Get vertex colors as a flat Float32Array.
+     * @returns {Float32Array}
+     */
+    colorsFlat() {
+        const ret = wasm.rawmeshexportwrapper_colorsFlat(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get vertex normals as a flat Float32Array.
+     * @returns {Float32Array}
+     */
+    normalsFlat() {
+        const ret = wasm.rawmeshexportwrapper_normalsFlat(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get texture atlas RGBA pixel data.
+     * @returns {Uint8Array}
+     */
+    textureRgba() {
+        const ret = wasm.rawmeshexportwrapper_textureRgba(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Get the vertex count.
+     * @returns {number}
+     */
+    get vertexCount() {
+        const ret = wasm.rawmeshexportwrapper_vertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get texture atlas width.
+     * @returns {number}
+     */
+    get textureWidth() {
+        const ret = wasm.rawmeshexportwrapper_textureWidth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get vertex positions as a flat Float32Array.
+     * @returns {Float32Array}
+     */
+    positionsFlat() {
+        const ret = wasm.rawmeshexportwrapper_positionsFlat(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get texture atlas height.
+     * @returns {number}
+     */
+    get textureHeight() {
+        const ret = wasm.rawmeshexportwrapper_textureHeight(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the triangle count.
+     * @returns {number}
+     */
+    get triangleCount() {
+        const ret = wasm.rawmeshexportwrapper_triangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get triangle indices.
+     * @returns {Uint32Array}
+     */
+    indices() {
+        const ret = wasm.rawmeshexportwrapper_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Get texture coordinates as a flat Float32Array.
+     * @returns {Float32Array}
+     */
+    uvsFlat() {
+        const ret = wasm.rawmeshexportwrapper_uvsFlat(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+if (Symbol.dispose) RawMeshExportWrapper.prototype[Symbol.dispose] = RawMeshExportWrapper.prototype.free;
+
+/**
+ * Wrapper for a Minecraft resource pack.
+ */
+export class ResourcePackWrapper {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ResourcePackWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_resourcepackwrapper_free(ptr, 0);
+    }
+    /**
+     * Get the namespaces in the resource pack.
+     * @returns {Array<any>}
+     */
+    get namespaces() {
+        const ret = wasm.resourcepackwrapper_namespaces(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Add a texture from raw RGBA8 pixel data.
+     * @param {string} name
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} pixels
+     */
+    addTexture(name, width, height, pixels) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(pixels, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_addTexture(this.__wbg_ptr, ptr0, len0, width, height, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * List all model names.
+     * @returns {Array<any>}
+     */
+    listModels() {
+        const ret = wasm.resourcepackwrapper_listModels(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Output not equals a value
-     * @param {ValueWrapper} value
-     * @returns {OutputConditionWrapper}
+     * Get the number of models in the resource pack.
+     * @returns {number}
      */
-    static notEquals(value) {
-        _assertClass(value, ValueWrapper);
-        const ret = wasm.outputconditionwrapper_notEquals(value.__wbg_ptr);
-        return OutputConditionWrapper.__wrap(ret);
+    get modelCount() {
+        const ret = wasm.resourcepackwrapper_modelCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Bitwise AND with mask
-     * @param {number} mask
-     * @returns {OutputConditionWrapper}
+     * List all texture names.
+     * @returns {Array<any>}
      */
-    static bitwiseAnd(mask) {
-        const ret = wasm.outputconditionwrapper_bitwiseAnd(mask);
-        return OutputConditionWrapper.__wrap(ret);
+    listTextures() {
+        const ret = wasm.resourcepackwrapper_listTextures(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Output greater than a value
-     * @param {ValueWrapper} value
-     * @returns {OutputConditionWrapper}
+     * Get the number of textures in the resource pack.
+     * @returns {number}
      */
-    static greaterThan(value) {
-        _assertClass(value, ValueWrapper);
-        const ret = wasm.outputconditionwrapper_greaterThan(value.__wbg_ptr);
-        return OutputConditionWrapper.__wrap(ret);
+    get textureCount() {
+        const ret = wasm.resourcepackwrapper_textureCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Output equals a value
-     * @param {ValueWrapper} value
-     * @returns {OutputConditionWrapper}
+     * Add a block model from a JSON string.
+     * @param {string} name
+     * @param {string} json
      */
-    static equals(value) {
-        _assertClass(value, ValueWrapper);
-        const ret = wasm.outputconditionwrapper_equals(value.__wbg_ptr);
-        return OutputConditionWrapper.__wrap(ret);
+    addModelJson(name, json) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_addModelJson(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Output less than a value
-     * @param {ValueWrapper} value
-     * @returns {OutputConditionWrapper}
+     * Get a block model as a JSON string. Returns null if not found.
+     * @param {string} name
+     * @returns {string | undefined}
      */
-    static lessThan(value) {
-        _assertClass(value, ValueWrapper);
-        const ret = wasm.outputconditionwrapper_lessThan(value.__wbg_ptr);
-        return OutputConditionWrapper.__wrap(ret);
+    getModelJson(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_getModelJson(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
     }
-}
-if (Symbol.dispose) OutputConditionWrapper.prototype[Symbol.dispose] = OutputConditionWrapper.prototype.free;
-
-export class PaletteManager {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        PaletteManagerFinalization.unregister(this);
-        return ptr;
+    /**
+     * Get the number of blockstates in the resource pack.
+     * @returns {number}
+     */
+    get blockstateCount() {
+        const ret = wasm.resourcepackwrapper_blockstateCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_palettemanager_free(ptr, 0);
+    /**
+     * Get texture info as a JS object with width, height, isAnimated, frameCount.
+     * Returns null if not found.
+     * @param {string} name
+     * @returns {any}
+     */
+    getTextureInfo(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_getTextureInfo(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
     /**
-     * Get all wool blocks
-     * @returns {string[]}
+     * List all blockstate names.
+     * @returns {Array<any>}
      */
-    static getWoolBlocks() {
-        const ret = wasm.palettemanager_getWoolBlocks();
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    listBlockstates() {
+        const ret = wasm.resourcepackwrapper_listBlockstates(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Get all concrete blocks
-     * @returns {string[]}
+     * Get raw RGBA8 pixel data for a texture. Returns null if not found.
+     * @param {string} name
+     * @returns {Uint8Array | undefined}
      */
-    static getConcreteBlocks() {
-        const ret = wasm.palettemanager_getConcreteBlocks();
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    getTexturePixels(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_getTexturePixels(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
     }
     /**
-     * Get all terracotta blocks
-     * @returns {string[]}
+     * Add a blockstate definition from a JSON string.
+     * @param {string} name
+     * @param {string} json
      */
-    static getTerracottaBlocks() {
-        const ret = wasm.palettemanager_getTerracottaBlocks();
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    addBlockstateJson(name, json) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_addBlockstateJson(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Get a palette containing blocks matching ANY of the provided keywords
-     * Example: `["wool", "obsidian"]` gets all wool blocks AND obsidian
-     * @param {string[]} keywords
-     * @returns {string[]}
+     * Get a blockstate definition as a JSON string. Returns null if not found.
+     * @param {string} name
+     * @returns {string | undefined}
      */
-    static getPaletteByKeywords(keywords) {
-        const ptr0 = passArrayJsValueToWasm0(keywords, wasm.__wbindgen_malloc);
+    getBlockstateJson(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.palettemanager_getPaletteByKeywords(ptr0, len0);
-        var v2 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        const ret = wasm.resourcepackwrapper_getBlockstateJson(this.__wbg_ptr, ptr0, len0);
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
         return v2;
     }
+    /**
+     * Load a resource pack from bytes (ZIP file contents).
+     * @param {Uint8Array} data
+     */
+    constructor(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.resourcepackwrapper_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ResourcePackWrapperFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get statistics about the resource pack as a JS object.
+     * @returns {object}
+     */
+    getStats() {
+        const ret = wasm.resourcepackwrapper_getStats(this.__wbg_ptr);
+        return ret;
+    }
 }
-if (Symbol.dispose) PaletteManager.prototype[Symbol.dispose] = PaletteManager.prototype.free;
+if (Symbol.dispose) ResourcePackWrapper.prototype[Symbol.dispose] = ResourcePackWrapper.prototype.free;
 
 /**
  * SchematicBuilder for creating schematics from ASCII art
@@ -2563,6 +3598,162 @@ export class SchematicWrapper {
         }
         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 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]);
+    }
     /**
      * Add a mobile entity to the schematic.
      * @param {string} id
@@ -4186,6 +5377,57 @@ export class StateModeConstants {
 }
 if (Symbol.dispose) StateModeConstants.prototype[Symbol.dispose] = StateModeConstants.prototype.free;
 
+/**
+ * Wrapper for a pre-built global texture atlas.
+ *
+ * Build one atlas with `buildGlobalAtlas()` and pass it to
+ * `chunkMeshIteratorWithAtlas()` so every chunk shares the same texture sheet.
+ */
+export class TextureAtlasWrapper {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TextureAtlasWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        TextureAtlasWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TextureAtlasWrapperFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_textureatlaswrapper_free(ptr, 0);
+    }
+    /**
+     * Atlas width in pixels.
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.chunkmeshresultwrapper_totalVertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Atlas height in pixels.
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.chunkmeshresultwrapper_totalTriangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * RGBA pixel data as Uint8Array.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.textureatlaswrapper_toBytes(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) TextureAtlasWrapper.prototype[Symbol.dispose] = TextureAtlasWrapper.prototype.free;
+
 /**
  * TypedCircuitExecutor wrapper for JavaScript
  */
@@ -4760,6 +6002,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
+    imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_entries_83c79938054e065f = function(arg0) {
         const ret = Object.entries(arg0);
         return ret;
@@ -4831,6 +6077,14 @@ function __wbg_get_imports() {
         const ret = new Map();
         return ret;
     };
+    imports.wbg.__wbg_new_from_slice_41e2764a343e3cb1 = function(arg0, arg1) {
+        const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_from_slice_db0691b69e9d3891 = function(arg0, arg1) {
+        const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+        return ret;
+    };
     imports.wbg.__wbg_new_from_slice_e6bd3cfb5a35313d = function(arg0, arg1) {
         const ret = new Int32Array(getArrayI32FromWasm0(arg0, arg1));
         return ret;
@@ -4919,6 +6173,7 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
     cachedInt32ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;