nucleation 0.10.20 → 0.10.22

package/BlockPos.mjs

@@ -108,6 +108,7 @@ export class BlockPos {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("BlockPos._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/Dimensions.mjs

@@ -108,6 +108,7 @@ export class Dimensions {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("Dimensions._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/FieldRange.mjs

@@ -89,6 +89,7 @@ export class FieldRange {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("FieldRange._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/ItemScale.mjs

@@ -111,6 +111,7 @@ export class ItemScale {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("ItemScale._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/MeshBounds.mjs

@@ -153,6 +153,7 @@ export class MeshBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("MeshBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/MeshProgress.mjs

@@ -112,6 +112,7 @@ export class MeshProgress {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("MeshProgress._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/Palette.d.mts

@@ -17,6 +17,18 @@ export class Palette {
     constructor();
 
 
+    /**
+     * Opaque building blocks and full glass blocks, for material-aware imports.
+     */
+    static materials(): Palette;
+
+    /**
+     * Keep only opaque blocks (`false`) or full glass blocks (`true`).
+     * Includes/excludes remain respected. Returns an empty palette when
+     * no suitable block exists; check `len()` before matching colours.
+     */
+    forMaterial(translucent: boolean): Palette;
+
     /**
      * Every block blockpedia knows a color for (the default palette
      * brushes use when none is set).

package/Palette.d.ts

@@ -17,6 +17,18 @@ export class Palette {
     constructor();
 
 
+    /**
+     * Opaque building blocks and full glass blocks, for material-aware imports.
+     */
+    static materials(): Palette;
+
+    /**
+     * Keep only opaque blocks (`false`) or full glass blocks (`true`).
+     * Includes/excludes remain respected. Returns an empty palette when
+     * no suitable block exists; check `len()` before matching colours.
+     */
+    forMaterial(translucent: boolean): Palette;
+
     /**
      * Every block blockpedia knows a color for (the default palette
      * brushes use when none is set).

package/Palette.mjs

@@ -42,6 +42,40 @@ export class Palette {
     }
 
 
+    /**
+     * Opaque building blocks and full glass blocks, for material-aware imports.
+     */
+    static materials() {
+
+        const result = wasm.Palette_materials();
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Keep only opaque blocks (`false`) or full glass blocks (`true`).
+     * Includes/excludes remain respected. Returns an empty palette when
+     * no suitable block exists; check `len()` before matching colours.
+     */
+    forMaterial(translucent) {
+
+        const result = wasm.Palette_for_material(this.ffiValue, translucent);
+
+        try {
+            return new Palette(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
     /**
      * Every block blockpedia knows a color for (the default palette
      * brushes use when none is set).

package/RegionBounds.mjs

@@ -154,6 +154,7 @@ export class RegionBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("RegionBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/Schematic.d.mts

@@ -492,6 +492,15 @@ export class Schematic {
      */
     getChunkBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/Schematic.d.ts

@@ -492,6 +492,15 @@ export class Schematic {
      */
     getChunkBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX: number, offsetY: number, offsetZ: number, width: number, height: number, length: number): string;
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/Schematic.mjs

@@ -1929,6 +1929,36 @@ export class Schematic {
         }
     }
 
+    /**
+     * Non-air blocks inside a bounded box, retaining block-state properties.
+     * Visits only intersecting region cells, not the whole schematic. Bounds
+     * and arithmetic are checked; queries may scan at most 1,048,576 cells
+     * (including region overlaps) and emit at most 32 MiB of JSON. Renderers
+     * should request 16³ sections. Coordinates may be negative.
+     */
+    getChunkNonAirBlocksJson(offsetX, offsetY, offsetZ, width, height, length) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.Schematic_get_chunk_non_air_blocks_json(diplomatReceive.buffer, this.ffiValue, offsetX, offsetY, offsetZ, width, height, length, write.buffer);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
     /**
      * Split the schematic into chunks (default bottom-up strategy). Writes a
      * JSON array of `{"chunk_x", "chunk_y", "chunk_z", "blocks": [...]}` where

package/SdfBounds.mjs

@@ -133,6 +133,7 @@ export class SdfBounds {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("SdfBounds._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/SdfNormal.mjs

@@ -100,6 +100,7 @@ export class SdfNormal {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("SdfNormal._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/TextureInfo.mjs

@@ -125,6 +125,7 @@ export class TextureInfo {
     // This method does not attempt to handle any dependencies between lifetimes, the caller
     // should handle this when constructing edge arrays.
     static _fromFFI(internalConstructor, ptr) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
         if (internalConstructor !== diplomatRuntime.internalConstructor) {
             throw new Error("TextureInfo._fromFFI is not meant to be called externally. Please use the default constructor.");
         }

package/VoxelModel.d.mts

@@ -0,0 +1,34 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A parsed GLB/OBJ, reusable for size estimates and configured imports.
+ */
+export class VoxelModel {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Return {dimensions:[width,height,depth],volume} or {error:message}.
+     * Options: target_size, axis (longest/x/y/z), hollow, optional lighting
+     * {direction:[x,y,z],strength:0..1}, optional untextured_block.
+     * Estimates preserve proportions and run before voxel-grid allocation.
+     */
+    planJson(optionsJson: string): string;
+
+    /**
+     * Import using plan_json's options. Anchored at (0,0,0), with exact
+     * axis-based uniform scaling. Hollow uses a sparse surface raster;
+     * lighting darkens sampled texture colours before palette matching.
+     * Rejects oversized/over-complex output with InvalidArgument.
+     */
+    toSchematic(optionsJson: string, palette: Palette, name: string): Schematic;
+}

package/VoxelModel.d.ts

@@ -0,0 +1,34 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { Palette } from "./Palette.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A parsed GLB/OBJ, reusable for size estimates and configured imports.
+ */
+export class VoxelModel {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Return {dimensions:[width,height,depth],volume} or {error:message}.
+     * Options: target_size, axis (longest/x/y/z), hollow, optional lighting
+     * {direction:[x,y,z],strength:0..1}, optional untextured_block.
+     * Estimates preserve proportions and run before voxel-grid allocation.
+     */
+    planJson(optionsJson: string): string;
+
+    /**
+     * Import using plan_json's options. Anchored at (0,0,0), with exact
+     * axis-based uniform scaling. Hollow uses a sparse surface raster;
+     * lighting darkens sampled texture colours before palette matching.
+     * Rejects oversized/over-complex output with InvalidArgument.
+     */
+    toSchematic(optionsJson: string, palette: Palette, name: string): Schematic;
+}

package/VoxelModel.mjs

@@ -0,0 +1,113 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import { Palette } from "./Palette.mjs"
+import { Schematic } from "./Schematic.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const VoxelModel_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.VoxelModel_destroy(ptr);
+});
+
+/**
+ * A parsed GLB/OBJ, reusable for size estimates and configured imports.
+ */
+export class VoxelModel {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("VoxelModel is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            VoxelModel_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Return {dimensions:[width,height,depth],volume} or {error:message}.
+     * Options: target_size, axis (longest/x/y/z), hollow, optional lighting
+     * {direction:[x,y,z],strength:0..1}, optional untextured_block.
+     * Estimates preserve proportions and run before voxel-grid allocation.
+     */
+    planJson(optionsJson) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const optionsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, optionsJson)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.VoxelModel_plan_json(diplomatReceive.buffer, this.ffiValue, optionsJsonSlice.ptr, write.buffer);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    /**
+     * Import using plan_json's options. Anchored at (0,0,0), with exact
+     * axis-based uniform scaling. Hollow uses a sparse surface raster;
+     * lighting darkens sampled texture colours before palette matching.
+     * Rejects oversized/over-complex output with InvalidArgument.
+     */
+    toSchematic(optionsJson, palette, name) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const optionsJsonSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, optionsJson)));
+        const nameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, name)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.VoxelModel_to_schematic(diplomatReceive.buffer, this.ffiValue, optionsJsonSlice.ptr, palette.ffiValue, nameSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new Schematic(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/Voxelizer.d.mts

@@ -3,6 +3,7 @@ import type { NucleationError } from "./NucleationError.mjs"
 import type { Palette } from "./Palette.mjs"
 import type { Schematic } from "./Schematic.mjs"
 import type { Shape } from "./Shape.mjs"
+import type { VoxelModel } from "./VoxelModel.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 
@@ -18,6 +19,27 @@ export class Voxelizer {
     constructor();
 
 
+    /**
+     * Reason the last configured model import failed; cleared on success.
+     */
+    static lastErrorDetail(): string;
+
+    /**
+     * PHP-friendly GLB input: avoids expanding every byte into a boxed
+     * integer array before copying it over FFI.
+     */
+    static loadGlbBase64(data: string): VoxelModel;
+
+    /**
+     * Parse a GLB once for axis-based size estimates and lit voxelization.
+     */
+    static loadGlb(data: Array<number>): VoxelModel;
+
+    /**
+     * Parse an OBJ once for axis-based size estimates and lit voxelization.
+     */
+    static loadObj(text: string): VoxelModel;
+
     /**
      * Load a binary glTF (`.glb`, embedded buffers/images) and voxelize
      * it into a fillable Shape: the model is uniformly scaled so its

package/Voxelizer.d.ts

@@ -3,6 +3,7 @@ import type { NucleationError } from "./NucleationError.mjs"
 import type { Palette } from "./Palette.mjs"
 import type { Schematic } from "./Schematic.mjs"
 import type { Shape } from "./Shape.mjs"
+import type { VoxelModel } from "./VoxelModel.mjs"
 import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
 
 
@@ -18,6 +19,27 @@ export class Voxelizer {
     constructor();
 
 
+    /**
+     * Reason the last configured model import failed; cleared on success.
+     */
+    static lastErrorDetail(): string;
+
+    /**
+     * PHP-friendly GLB input: avoids expanding every byte into a boxed
+     * integer array before copying it over FFI.
+     */
+    static loadGlbBase64(data: string): VoxelModel;
+
+    /**
+     * Parse a GLB once for axis-based size estimates and lit voxelization.
+     */
+    static loadGlb(data: Array<number>): VoxelModel;
+
+    /**
+     * Parse an OBJ once for axis-based size estimates and lit voxelization.
+     */
+    static loadObj(text: string): VoxelModel;
+
     /**
      * Load a binary glTF (`.glb`, embedded buffers/images) and voxelize
      * it into a fillable Shape: the model is uniformly scaled so its

package/Voxelizer.mjs

@@ -3,6 +3,7 @@ import { NucleationError } from "./NucleationError.mjs"
 import { Palette } from "./Palette.mjs"
 import { Schematic } from "./Schematic.mjs"
 import { Shape } from "./Shape.mjs"
+import { VoxelModel } from "./VoxelModel.mjs"
 import wasm from "./diplomat-wasm.mjs";
 import * as diplomatRuntime from "./diplomat-runtime.mjs";
 
@@ -43,6 +44,109 @@ export class Voxelizer {
     }
 
 
+    /**
+     * Reason the last configured model import failed; cleared on success.
+     */
+    static lastErrorDetail() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.Voxelizer_last_error_detail(write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * PHP-friendly GLB input: avoids expanding every byte into a boxed
+     * integer array before copying it over FFI.
+     */
+    static loadGlbBase64(data) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const dataSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, data)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Voxelizer_load_glb_base64(diplomatReceive.buffer, dataSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new VoxelModel(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Parse a GLB once for axis-based size estimates and lit voxelization.
+     */
+    static loadGlb(data) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const dataSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, data, "u8")));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Voxelizer_load_glb(diplomatReceive.buffer, dataSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new VoxelModel(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Parse an OBJ once for axis-based size estimates and lit voxelization.
+     */
+    static loadObj(text) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const textSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, text)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Voxelizer_load_obj(diplomatReceive.buffer, textSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new VoxelModel(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
     /**
      * Load a binary glTF (`.glb`, embedded buffers/images) and voxelize
      * it into a fillable Shape: the model is uniformly scaled so its

package/diplomat-runtime.mjs

@@ -8,11 +8,13 @@ export const internalConstructor = Symbol("constructor");
 export const exposeConstructor = Symbol("exposeConstructor");
 
 export function readString8(wasm, ptr, len) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     const buf = new Uint8Array(wasm.memory.buffer, ptr, len);
     return (new TextDecoder("utf-8")).decode(buf)
 }
 
 export function readString16(wasm, ptr, len) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     const buf = new Uint16Array(wasm.memory.buffer, ptr, len);
     return String.fromCharCode.apply(null, buf)
 }
@@ -48,6 +50,7 @@ export function withDiplomatWrite(wasm, callback) {
  * @returns {number} The underlying pointer.
  */
 export function ptrRead(wasm, ptr) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Uint32Array(wasm.memory.buffer, ptr, 1))[0];
 }
 
@@ -55,6 +58,7 @@ export function ptrRead(wasm, ptr) {
  * Get the flag of a result type.
  */
 export function resultFlag(wasm, ptr, offset) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Uint8Array(wasm.memory.buffer, ptr + offset, 1))[0];
 }
 
@@ -62,6 +66,7 @@ export function resultFlag(wasm, ptr, offset) {
  * Get the discriminant of a Rust enum.
 */
 export function enumDiscriminant(wasm, ptr) {
+    ptr >>>= 0; // wasm32 addresses are unsigned, including above 2 GiB.
     return (new Int32Array(wasm.memory.buffer, ptr, 1))[0]
 }
 
@@ -83,7 +88,7 @@ export function maybePaddingFields(needsPaddingFields, paddingCount) {
 * (which is a `TypedArray` variant like `Uint8Array` or `Int16Array`)
 */
 export function writeToArrayBuffer(arrayBuffer, offset, value, typedArrayKind) {
-    let buffer = new typedArrayKind(arrayBuffer, offset);
+    let buffer = new typedArrayKind(arrayBuffer, offset < 0 ? offset >>> 0 : offset);
     buffer[0] = value;
 }
 
@@ -223,7 +228,7 @@ export class DiplomatBuf {
         }
     }
 
-    const ptr = wasm.diplomat_alloc(utf8Length, 1);
+    const ptr = wasm.diplomat_alloc(utf8Length, 1) >>> 0;
 
     const result = (new TextEncoder()).encodeInto(string, new Uint8Array(wasm.memory.buffer, ptr, utf8Length));
     console.assert(string.length === result.read && utf8Length === result.written, "UTF-8 write error");
@@ -233,7 +238,7 @@ export class DiplomatBuf {
 
     static str16 = (wasm, string) => {
     const byteLength = string.length * 2;
-    const ptr = wasm.diplomat_alloc(byteLength, 2);
+    const ptr = wasm.diplomat_alloc(byteLength, 2) >>> 0;
 
     const destination = new Uint16Array(wasm.memory.buffer, ptr, string.length);
     for (let i = 0; i < string.length; i++) {
@@ -244,7 +249,7 @@ export class DiplomatBuf {
     }
 
     static sliceWrapper = (wasm, buf) => {
-        const ptr = wasm.diplomat_alloc(8, 4);
+        const ptr = wasm.diplomat_alloc(8, 4) >>> 0;
         let dst = new Uint32Array(wasm.memory.buffer, ptr, 2);
 
         dst[0] = buf.ptr;
@@ -262,7 +267,7 @@ export class DiplomatBuf {
             4;
 
     const byteLength = list.length * elementSize;
-    const ptr = wasm.diplomat_alloc(byteLength, elementSize);
+    const ptr = wasm.diplomat_alloc(byteLength, elementSize) >>> 0;
 
     /**
      * Create an array view of the buffer. This gives us the `set` method which correctly handles untyped values
@@ -288,15 +293,15 @@ export class DiplomatBuf {
 
         const byteLength = strings.length * 4 * 2;
 
-        const ptr = wasm.diplomat_alloc(byteLength, 4);
+        const ptr = wasm.diplomat_alloc(byteLength, 4) >>> 0;
 
-        const destination = new Uint32Array(wasm.memory.buffer, ptr, byteLength);
 
         const stringsAlloc = [];
 
         for (let i = 0; i < strings.length; i++) {
             stringsAlloc.push(encodeStr(wasm, strings[i]));
 
+            const destination = new Uint32Array(wasm.memory.buffer, ptr, strings.length * 2);
             destination[2 * i] = stringsAlloc[i].ptr;
             destination[(2 * i) + 1] = stringsAlloc[i].size;
         }
@@ -310,7 +315,7 @@ export class DiplomatBuf {
     }
 
     static struct = (wasm, size, align) => {
-        const ptr = wasm.diplomat_alloc(size, align);
+        const ptr = wasm.diplomat_alloc(size, align) >>> 0;
 
         return new DiplomatBuf(ptr, size, () => {
             wasm.diplomat_free(ptr, size, align);
@@ -325,7 +330,7 @@ export class DiplomatBuf {
     free;
 
     constructor(ptr, size, free) {
-        this.ptr = ptr;
+        this.ptr = ptr >>> 0;
         this.size = size;
         this.free = free;
         this.leak = () => { };
@@ -357,7 +362,7 @@ export class DiplomatWriteBuf {
 
     constructor(wasm) {
         this.#wasm = wasm;
-        this.#buffer = this.#wasm.diplomat_buffer_write_create(0);
+        this.#buffer = this.#wasm.diplomat_buffer_write_create(0) >>> 0;
 
         this.leak = () => { };
     }
@@ -409,7 +414,7 @@ export class DiplomatSlice {
     constructor(wasm, buffer, bufferType, lifetimeEdges) {
         this.#wasm = wasm;
 
-        const [ptr, size] = new Uint32Array(this.#wasm.memory.buffer, buffer, 2);
+        const [ptr, size] = new Uint32Array(this.#wasm.memory.buffer, buffer >>> 0, 2);
 
         this.#buffer = new bufferType(this.#wasm.memory.buffer, ptr, size);
         this.#bufferType = bufferType;
@@ -432,7 +437,7 @@ export class DiplomatSlice {
 
 export class DiplomatSlicePrimitive extends DiplomatSlice {
     constructor(wasm, buffer, sliceType, lifetimeEdges) {
-        const [ptr, size] = new Uint32Array(wasm.memory.buffer, buffer, 2);
+        const [ptr, size] = new Uint32Array(wasm.memory.buffer, buffer >>> 0, 2);
 
         let arrayType;
         switch (sliceType) {
@@ -552,7 +557,7 @@ export class DiplomatReceiveBuf {
 
         this.#hasResult = hasResult;
 
-        this.#buffer = this.#wasm.diplomat_alloc(this.#size, this.#align);
+        this.#buffer = this.#wasm.diplomat_alloc(this.#size, this.#align) >>> 0;
 
         this.leak = () => { };
     }
@@ -736,7 +741,7 @@ export class FunctionParamAllocator {
 
         this.#capacity = capacity;
         // FunctionParamAllocator is global, so this will be freed when the webpage closes:
-        this.#ptr = wasm.diplomat_alloc(this.#capacity, 1);
+        this.#ptr = wasm.diplomat_alloc(this.#capacity, 1) >>> 0;
     }
 
     /**

package/index.d.mts

@@ -142,6 +142,8 @@ export { Store } from "./Store.mjs"
 
 export { StoreIo } from "./StoreIo.mjs"
 
+export { VoxelModel } from "./VoxelModel.mjs"
+
 export { Voxelizer } from "./Voxelizer.mjs"
 
 export { CellularSdfConfig } from "./CellularSdfConfig.mjs"

package/index.d.ts

@@ -142,6 +142,8 @@ export { Store } from "./Store.mjs"
 
 export { StoreIo } from "./StoreIo.mjs"
 
+export { VoxelModel } from "./VoxelModel.mjs"
+
 export { Voxelizer } from "./Voxelizer.mjs"
 
 export { CellularSdfConfig } from "./CellularSdfConfig.mjs"

package/index.mjs

@@ -140,6 +140,8 @@ export { Store } from "./Store.mjs"
 
 export { StoreIo } from "./StoreIo.mjs"
 
+export { VoxelModel } from "./VoxelModel.mjs"
+
 export { Voxelizer } from "./Voxelizer.mjs"
 
 export { CellularSdfConfig } from "./CellularSdfConfig.mjs"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nucleation",
-  "version": "0.10.20",
+  "version": "0.10.22",
   "description": "A high-performance Minecraft schematic parser and utility library",
   "type": "module",
   "main": "index.mjs",