nucleation 0.1.169 → 0.1.170

package/nucleation-original.js

@@ -128,6 +128,14 @@ function getFloat32ArrayMemory0() {
     return cachedFloat32ArrayMemory0;
 }
 
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
 let cachedInt32ArrayMemory0 = null;
 function getInt32ArrayMemory0() {
     if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
@@ -184,6 +192,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getFloat64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -520,7 +535,7 @@ export class BlockStateWrapper {
 if (Symbol.dispose) BlockStateWrapper.prototype[Symbol.dispose] = BlockStateWrapper.prototype.free;
 
 /**
- * A wrapper for any brush (Solid, Gradient, Shaded, etc.)
+ * A wrapper for any brush (Solid, Gradient, Shaded, CurveGradient, etc.)
  */
 export class BrushWrapper {
     static __wrap(ptr) {
@@ -540,11 +555,28 @@ export class BrushWrapper {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_brushwrapper_free(ptr, 0);
     }
+    /**
+     * Create a curve gradient brush that interpolates colors along parametric shapes.
+     * stops_flat: Flat array [pos1, r1, g1, b1, pos2, r2, g2, b2, ...]
+     * Space: 0 = RGB, 1 = Oklab
+     * @param {Float64Array} stops_flat
+     * @param {number | null} [space]
+     * @param {string[] | null} [palette_filter]
+     * @returns {BrushWrapper}
+     */
+    static curveGradient(stops_flat, space, palette_filter) {
+        const ptr0 = passArrayF64ToWasm0(stops_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(palette_filter) ? 0 : passArrayJsValueToWasm0(palette_filter, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brushwrapper_curveGradient(ptr0, len0, isLikeNone(space) ? 0xFFFFFF : space, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BrushWrapper.__wrap(ret[0]);
+    }
     /**
      * Create a point cloud gradient brush using Inverse Distance Weighting (IDW)
-     * positions: Flat array [x1, y1, z1, x2, y2, z2, ...]
-     * colors: Flat array [r1, g1, b1, r2, g2, b2, ...]
-     * falloff: Power parameter (default 2.0 if None)
      * @param {Int32Array} positions
      * @param {Uint8Array} colors
      * @param {number | null} [falloff]
@@ -625,7 +657,6 @@ export class BrushWrapper {
     }
     /**
      * Create a color brush (matches closest block to RGB color)
-     * Palette: optional list of block IDs to restrict matching to.
      * @param {number} r
      * @param {number} g
      * @param {number} b
@@ -654,7 +685,6 @@ export class BrushWrapper {
     }
     /**
      * Create a shaded brush (Lambertian shading)
-     * light_dir: [x, y, z] vector
      * @param {number} r
      * @param {number} g
      * @param {number} b
@@ -5068,7 +5098,7 @@ export class SchematicWrapper {
 if (Symbol.dispose) SchematicWrapper.prototype[Symbol.dispose] = SchematicWrapper.prototype.free;
 
 /**
- * A wrapper for any shape (Sphere, Cuboid, etc.)
+ * A wrapper for any shape (Sphere, Cuboid, Line, etc.)
  */
 export class ShapeWrapper {
     static __wrap(ptr) {
@@ -5088,6 +5118,156 @@ export class ShapeWrapper {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_shapewrapper_free(ptr, 0);
     }
+    /**
+     * Create a Difference of two shapes (a AND NOT b)
+     * @param {ShapeWrapper} a
+     * @param {ShapeWrapper} b
+     * @returns {ShapeWrapper}
+     */
+    static difference(a, b) {
+        _assertClass(a, ShapeWrapper);
+        _assertClass(b, ShapeWrapper);
+        const ret = wasm.shapewrapper_difference(a.__wbg_ptr, b.__wbg_ptr);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create an Intersection of two shapes (a AND b)
+     * @param {ShapeWrapper} a
+     * @param {ShapeWrapper} b
+     * @returns {ShapeWrapper}
+     */
+    static intersection(a, b) {
+        _assertClass(a, ShapeWrapper);
+        _assertClass(b, ShapeWrapper);
+        const ret = wasm.shapewrapper_intersection(a.__wbg_ptr, b.__wbg_ptr);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Union of two shapes (a OR b)
+     * @param {ShapeWrapper} a
+     * @param {ShapeWrapper} b
+     * @returns {ShapeWrapper}
+     */
+    static union(a, b) {
+        _assertClass(a, ShapeWrapper);
+        _assertClass(b, ShapeWrapper);
+        const ret = wasm.shapewrapper_union(a.__wbg_ptr, b.__wbg_ptr);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Cylinder between two points
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} z2
+     * @param {number} radius
+     * @returns {ShapeWrapper}
+     */
+    static cylinderBetween(x1, y1, z1, x2, y2, z2, radius) {
+        const ret = wasm.shapewrapper_cylinderBetween(x1, y1, z1, x2, y2, z2, radius);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Cone shape
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @param {number} dx
+     * @param {number} dy
+     * @param {number} dz
+     * @param {number} radius
+     * @param {number} height
+     * @returns {ShapeWrapper}
+     */
+    static cone(ax, ay, az, dx, dy, dz, radius, height) {
+        const ret = wasm.shapewrapper_cone(ax, ay, az, dx, dy, dz, radius, height);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Disk shape (flat cylinder)
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @param {number} radius
+     * @param {number} nx
+     * @param {number} ny
+     * @param {number} nz
+     * @param {number | null} [thickness]
+     * @returns {ShapeWrapper}
+     */
+    static disk(cx, cy, cz, radius, nx, ny, nz, thickness) {
+        const ret = wasm.shapewrapper_disk(cx, cy, cz, radius, nx, ny, nz, !isLikeNone(thickness), isLikeNone(thickness) ? 0 : thickness);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a 3D Line with thickness
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} z2
+     * @param {number | null} [thickness]
+     * @returns {ShapeWrapper}
+     */
+    static line(x1, y1, z1, x2, y2, z2, thickness) {
+        const ret = wasm.shapewrapper_line(x1, y1, z1, x2, y2, z2, !isLikeNone(thickness), isLikeNone(thickness) ? 0 : thickness);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a bounded Plane shape
+     * @param {number} ox
+     * @param {number} oy
+     * @param {number} oz
+     * @param {number} ux
+     * @param {number} uy
+     * @param {number} uz
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} u_ext
+     * @param {number} v_ext
+     * @param {number | null} [thickness]
+     * @returns {ShapeWrapper}
+     */
+    static plane(ox, oy, oz, ux, uy, uz, vx, vy, vz, u_ext, v_ext, thickness) {
+        const ret = wasm.shapewrapper_plane(ox, oy, oz, ux, uy, uz, vx, vy, vz, u_ext, v_ext, !isLikeNone(thickness), isLikeNone(thickness) ? 0 : thickness);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Torus shape
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @param {number} major_r
+     * @param {number} minor_r
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @returns {ShapeWrapper}
+     */
+    static torus(cx, cy, cz, major_r, minor_r, ax, ay, az) {
+        const ret = wasm.shapewrapper_torus(cx, cy, cz, major_r, minor_r, ax, ay, az);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Bezier curve with thickness
+     * @param {Float64Array} control_points_flat
+     * @param {number | null} [thickness]
+     * @param {number | null} [resolution]
+     * @returns {ShapeWrapper}
+     */
+    static bezier(control_points_flat, thickness, resolution) {
+        const ptr0 = passArrayF64ToWasm0(control_points_flat, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.shapewrapper_bezier(ptr0, len0, !isLikeNone(thickness), isLikeNone(thickness) ? 0 : thickness, isLikeNone(resolution) ? 0x100000001 : (resolution) >>> 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ShapeWrapper.__wrap(ret[0]);
+    }
     /**
      * Create a new Cuboid shape
      * @param {number} min_x
@@ -5102,6 +5282,17 @@ export class ShapeWrapper {
         const ret = wasm.shapewrapper_cuboid(min_x, min_y, min_z, max_x, max_y, max_z);
         return ShapeWrapper.__wrap(ret);
     }
+    /**
+     * Create a Hollow version of any shape
+     * @param {ShapeWrapper} shape
+     * @param {number | null} [thickness]
+     * @returns {ShapeWrapper}
+     */
+    static hollow(shape, thickness) {
+        _assertClass(shape, ShapeWrapper);
+        const ret = wasm.shapewrapper_hollow(shape.__wbg_ptr, isLikeNone(thickness) ? 0x100000001 : (thickness) >>> 0);
+        return ShapeWrapper.__wrap(ret);
+    }
     /**
      * Create a new Sphere shape
      * @param {number} cx
@@ -5114,6 +5305,71 @@ export class ShapeWrapper {
         const ret = wasm.shapewrapper_sphere(cx, cy, cz, radius);
         return ShapeWrapper.__wrap(ret);
     }
+    /**
+     * Create a Pyramid shape
+     * @param {number} bx
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} half_w
+     * @param {number} half_d
+     * @param {number} height
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @returns {ShapeWrapper}
+     */
+    static pyramid(bx, by, bz, half_w, half_d, height, ax, ay, az) {
+        const ret = wasm.shapewrapper_pyramid(bx, by, bz, half_w, half_d, height, ax, ay, az);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a Cylinder with arbitrary axis
+     * @param {number} bx
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @param {number} radius
+     * @param {number} height
+     * @returns {ShapeWrapper}
+     */
+    static cylinder(bx, by, bz, ax, ay, az, radius, height) {
+        const ret = wasm.shapewrapper_cylinder(bx, by, bz, ax, ay, az, radius, height);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create a filled Triangle shape
+     * @param {number} ax
+     * @param {number} ay
+     * @param {number} az
+     * @param {number} bx
+     * @param {number} by
+     * @param {number} bz
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @param {number | null} [thickness]
+     * @returns {ShapeWrapper}
+     */
+    static triangle(ax, ay, az, bx, by, bz, cx, cy, cz, thickness) {
+        const ret = wasm.shapewrapper_triangle(ax, ay, az, bx, by, bz, cx, cy, cz, !isLikeNone(thickness), isLikeNone(thickness) ? 0 : thickness);
+        return ShapeWrapper.__wrap(ret);
+    }
+    /**
+     * Create an Ellipsoid shape
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cz
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rz
+     * @returns {ShapeWrapper}
+     */
+    static ellipsoid(cx, cy, cz, rx, ry, rz) {
+        const ret = wasm.shapewrapper_ellipsoid(cx, cy, cz, rx, ry, rz);
+        return ShapeWrapper.__wrap(ret);
+    }
 }
 if (Symbol.dispose) ShapeWrapper.prototype[Symbol.dispose] = ShapeWrapper.prototype.free;
 
@@ -5806,6 +6062,22 @@ export class WasmBuildingTool {
         _assertClass(brush, BrushWrapper);
         wasm.wasmbuildingtool_fill(schematic.__wbg_ptr, shape.__wbg_ptr, brush.__wbg_ptr);
     }
+    /**
+     * Repeat a shape+brush fill at regular offset intervals
+     * @param {SchematicWrapper} schematic
+     * @param {ShapeWrapper} shape
+     * @param {BrushWrapper} brush
+     * @param {number} count
+     * @param {number} offset_x
+     * @param {number} offset_y
+     * @param {number} offset_z
+     */
+    static rstack(schematic, shape, brush, count, offset_x, offset_y, offset_z) {
+        _assertClass(schematic, SchematicWrapper);
+        _assertClass(shape, ShapeWrapper);
+        _assertClass(brush, BrushWrapper);
+        wasm.wasmbuildingtool_rstack(schematic.__wbg_ptr, shape.__wbg_ptr, brush.__wbg_ptr, count, offset_x, offset_y, offset_z);
+    }
 }
 if (Symbol.dispose) WasmBuildingTool.prototype[Symbol.dispose] = WasmBuildingTool.prototype.free;
 
@@ -6199,6 +6471,7 @@ function __wbg_finalize_init(instance, module) {
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedInt32ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;

package/nucleation.d.ts

@@ -23,11 +23,14 @@ export class BrushWrapper {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Create a curve gradient brush that interpolates colors along parametric shapes.
+   * stops_flat: Flat array [pos1, r1, g1, b1, pos2, r2, g2, b2, ...]
+   * Space: 0 = RGB, 1 = Oklab
+   */
+  static curveGradient(stops_flat: Float64Array, space?: number | null, palette_filter?: string[] | null): BrushWrapper;
   /**
    * Create a point cloud gradient brush using Inverse Distance Weighting (IDW)
-   * positions: Flat array [x1, y1, z1, x2, y2, z2, ...]
-   * colors: Flat array [r1, g1, b1, r2, g2, b2, ...]
-   * falloff: Power parameter (default 2.0 if None)
    */
   static point_gradient(positions: Int32Array, colors: Uint8Array, falloff?: number | null, space?: number | null, palette_filter?: string[] | null): BrushWrapper;
   /**
@@ -41,7 +44,6 @@ export class BrushWrapper {
   static bilinear_gradient(ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, r00: number, g00: number, b00: number, r10: number, g10: number, b10: number, r01: number, g01: number, b01: number, r11: number, g11: number, b11: number, space?: number | null, palette_filter?: string[] | null): BrushWrapper;
   /**
    * Create a color brush (matches closest block to RGB color)
-   * Palette: optional list of block IDs to restrict matching to.
    */
   static color(r: number, g: number, b: number, palette_filter?: string[] | null): BrushWrapper;
   /**
@@ -50,7 +52,6 @@ export class BrushWrapper {
   static solid(block_state: string): BrushWrapper;
   /**
    * Create a shaded brush (Lambertian shading)
-   * light_dir: [x, y, z] vector
    */
   static shaded(r: number, g: number, b: number, lx: number, ly: number, lz: number, palette_filter?: string[] | null): BrushWrapper;
 }
@@ -1392,14 +1393,74 @@ export class ShapeWrapper {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Create a Difference of two shapes (a AND NOT b)
+   */
+  static difference(a: ShapeWrapper, b: ShapeWrapper): ShapeWrapper;
+  /**
+   * Create an Intersection of two shapes (a AND b)
+   */
+  static intersection(a: ShapeWrapper, b: ShapeWrapper): ShapeWrapper;
+  /**
+   * Create a Union of two shapes (a OR b)
+   */
+  static union(a: ShapeWrapper, b: ShapeWrapper): ShapeWrapper;
+  /**
+   * Create a Cylinder between two points
+   */
+  static cylinderBetween(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, radius: number): ShapeWrapper;
+  /**
+   * Create a Cone shape
+   */
+  static cone(ax: number, ay: number, az: number, dx: number, dy: number, dz: number, radius: number, height: number): ShapeWrapper;
+  /**
+   * Create a Disk shape (flat cylinder)
+   */
+  static disk(cx: number, cy: number, cz: number, radius: number, nx: number, ny: number, nz: number, thickness?: number | null): ShapeWrapper;
+  /**
+   * Create a 3D Line with thickness
+   */
+  static line(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, thickness?: number | null): ShapeWrapper;
+  /**
+   * Create a bounded Plane shape
+   */
+  static plane(ox: number, oy: number, oz: number, ux: number, uy: number, uz: number, vx: number, vy: number, vz: number, u_ext: number, v_ext: number, thickness?: number | null): ShapeWrapper;
+  /**
+   * Create a Torus shape
+   */
+  static torus(cx: number, cy: number, cz: number, major_r: number, minor_r: number, ax: number, ay: number, az: number): ShapeWrapper;
+  /**
+   * Create a Bezier curve with thickness
+   */
+  static bezier(control_points_flat: Float64Array, thickness?: number | null, resolution?: number | null): ShapeWrapper;
   /**
    * Create a new Cuboid shape
    */
   static cuboid(min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number): ShapeWrapper;
+  /**
+   * Create a Hollow version of any shape
+   */
+  static hollow(shape: ShapeWrapper, thickness?: number | null): ShapeWrapper;
   /**
    * Create a new Sphere shape
    */
   static sphere(cx: number, cy: number, cz: number, radius: number): ShapeWrapper;
+  /**
+   * Create a Pyramid shape
+   */
+  static pyramid(bx: number, by: number, bz: number, half_w: number, half_d: number, height: number, ax: number, ay: number, az: number): ShapeWrapper;
+  /**
+   * Create a Cylinder with arbitrary axis
+   */
+  static cylinder(bx: number, by: number, bz: number, ax: number, ay: number, az: number, radius: number, height: number): ShapeWrapper;
+  /**
+   * Create a filled Triangle shape
+   */
+  static triangle(ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number, thickness?: number | null): ShapeWrapper;
+  /**
+   * Create an Ellipsoid shape
+   */
+  static ellipsoid(cx: number, cy: number, cz: number, rx: number, ry: number, rz: number): ShapeWrapper;
 }
 
 export class SimulationOptionsWrapper {
@@ -1654,6 +1715,10 @@ export class WasmBuildingTool {
    * Apply a brush to a shape on the given schematic
    */
   static fill(schematic: SchematicWrapper, shape: ShapeWrapper, brush: BrushWrapper): void;
+  /**
+   * Repeat a shape+brush fill at regular offset intervals
+   */
+  static rstack(schematic: SchematicWrapper, shape: ShapeWrapper, brush: BrushWrapper, count: number, offset_x: number, offset_y: number, offset_z: number): void;
 }
 
 export function debug_json_schematic(schematic: SchematicWrapper): string;
@@ -1699,6 +1764,7 @@ export interface InitOutput {
   readonly __wbg_outputconditionwrapper_free: (a: number, b: number) => void;
   readonly __wbg_rawmeshexportwrapper_free: (a: number, b: number) => void;
   readonly __wbg_resourcepackwrapper_free: (a: number, b: number) => void;
+  readonly __wbg_schematicbuilderwrapper_free: (a: number, b: number) => void;
   readonly __wbg_simulationoptionswrapper_free: (a: number, b: number) => void;
   readonly __wbg_sortstrategywrapper_free: (a: number, b: number) => void;
   readonly __wbg_statemodeconstants_free: (a: number, b: number) => void;
@@ -1910,6 +1976,12 @@ export interface InitOutput {
   readonly resourcepackwrapper_namespaces: (a: number) => any;
   readonly resourcepackwrapper_new: (a: number, b: number) => [number, number, number];
   readonly resourcepackwrapper_textureCount: (a: number) => number;
+  readonly schematicbuilderwrapper_build: (a: number) => [number, number, number];
+  readonly schematicbuilderwrapper_fromTemplate: (a: number, b: number) => [number, number, number];
+  readonly schematicbuilderwrapper_layers: (a: number, b: any) => [number, number, number];
+  readonly schematicbuilderwrapper_map: (a: number, b: number, c: number, d: number) => number;
+  readonly schematicbuilderwrapper_name: (a: number, b: number, c: number) => number;
+  readonly schematicbuilderwrapper_new: () => number;
   readonly schematicwrapper_buildGlobalAtlas: (a: number, b: number, c: number) => [number, number, number];
   readonly schematicwrapper_chunkMeshIterator: (a: number, b: number, c: number, d: number) => number;
   readonly schematicwrapper_chunkMeshIteratorWithAtlas: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -1977,18 +2049,10 @@ export interface InitOutput {
   readonly multimeshresultwrapper_meshCount: (a: number) => number;
   readonly textureatlaswrapper_height: (a: number) => number;
   readonly textureatlaswrapper_width: (a: number) => number;
-  readonly __wbg_blockposition_free: (a: number, b: number) => void;
   readonly __wbg_blockstatewrapper_free: (a: number, b: number) => void;
-  readonly __wbg_get_blockposition_x: (a: number) => number;
-  readonly __wbg_get_blockposition_y: (a: number) => number;
-  readonly __wbg_get_blockposition_z: (a: number) => number;
   readonly __wbg_lazychunkiterator_free: (a: number, b: number) => void;
-  readonly __wbg_schematicbuilderwrapper_free: (a: number, b: number) => void;
+  readonly __wbg_palettemanager_free: (a: number, b: number) => void;
   readonly __wbg_schematicwrapper_free: (a: number, b: number) => void;
-  readonly __wbg_set_blockposition_x: (a: number, b: number) => void;
-  readonly __wbg_set_blockposition_y: (a: number, b: number) => void;
-  readonly __wbg_set_blockposition_z: (a: number, b: number) => void;
-  readonly blockposition_new: (a: number, b: number, c: number) => number;
   readonly blockstatewrapper_name: (a: number) => [number, number];
   readonly blockstatewrapper_new: (a: number, b: number) => number;
   readonly blockstatewrapper_properties: (a: number) => any;
@@ -2001,12 +2065,10 @@ export interface InitOutput {
   readonly lazychunkiterator_reset: (a: number) => void;
   readonly lazychunkiterator_skip_to: (a: number, b: number) => void;
   readonly lazychunkiterator_total_chunks: (a: number) => number;
-  readonly schematicbuilderwrapper_build: (a: number) => [number, number, number];
-  readonly schematicbuilderwrapper_fromTemplate: (a: number, b: number) => [number, number, number];
-  readonly schematicbuilderwrapper_layers: (a: number, b: any) => [number, number, number];
-  readonly schematicbuilderwrapper_map: (a: number, b: number, c: number, d: number) => number;
-  readonly schematicbuilderwrapper_name: (a: number, b: number, c: number) => number;
-  readonly schematicbuilderwrapper_new: () => number;
+  readonly palettemanager_getConcreteBlocks: () => [number, number];
+  readonly palettemanager_getPaletteByKeywords: (a: number, b: number) => [number, number];
+  readonly palettemanager_getTerracottaBlocks: () => [number, number];
+  readonly palettemanager_getWoolBlocks: () => [number, number];
   readonly schematicwrapper_addDefinitionRegion: (a: number, b: number, c: number, d: number) => void;
   readonly schematicwrapper_add_entity: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
   readonly schematicwrapper_blocks: (a: number) => any;
@@ -2126,22 +2188,42 @@ export interface InitOutput {
   readonly start: () => void;
   readonly schematicwrapper_updateRegion: (a: number, b: number, c: number, d: number) => void;
   readonly __wbg_brushwrapper_free: (a: number, b: number) => void;
-  readonly __wbg_palettemanager_free: (a: number, b: number) => void;
   readonly __wbg_shapewrapper_free: (a: number, b: number) => void;
   readonly __wbg_wasmbuildingtool_free: (a: number, b: number) => void;
   readonly brushwrapper_bilinear_gradient: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number) => number;
   readonly brushwrapper_color: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly brushwrapper_curveGradient: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly brushwrapper_linear_gradient: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => number;
   readonly brushwrapper_point_gradient: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
   readonly brushwrapper_shaded: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
   readonly brushwrapper_solid: (a: number, b: number) => [number, number, number];
-  readonly palettemanager_getConcreteBlocks: () => [number, number];
-  readonly palettemanager_getPaletteByKeywords: (a: number, b: number) => [number, number];
-  readonly palettemanager_getTerracottaBlocks: () => [number, number];
-  readonly palettemanager_getWoolBlocks: () => [number, number];
+  readonly shapewrapper_bezier: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly shapewrapper_cone: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
   readonly shapewrapper_cuboid: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly shapewrapper_cylinder: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+  readonly shapewrapper_cylinderBetween: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly shapewrapper_difference: (a: number, b: number) => number;
+  readonly shapewrapper_disk: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
+  readonly shapewrapper_ellipsoid: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+  readonly shapewrapper_hollow: (a: number, b: number) => number;
+  readonly shapewrapper_intersection: (a: number, b: number) => number;
+  readonly shapewrapper_line: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+  readonly shapewrapper_plane: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => number;
+  readonly shapewrapper_pyramid: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => number;
   readonly shapewrapper_sphere: (a: number, b: number, c: number, d: number) => number;
+  readonly shapewrapper_torus: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
+  readonly shapewrapper_triangle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => number;
+  readonly shapewrapper_union: (a: number, b: number) => number;
   readonly wasmbuildingtool_fill: (a: number, b: number, c: number) => void;
+  readonly wasmbuildingtool_rstack: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly __wbg_blockposition_free: (a: number, b: number) => void;
+  readonly __wbg_get_blockposition_x: (a: number) => number;
+  readonly __wbg_get_blockposition_y: (a: number) => number;
+  readonly __wbg_get_blockposition_z: (a: number) => number;
+  readonly __wbg_set_blockposition_x: (a: number, b: number) => void;
+  readonly __wbg_set_blockposition_y: (a: number, b: number) => void;
+  readonly __wbg_set_blockposition_z: (a: number, b: number) => void;
+  readonly blockposition_new: (a: number, b: number, c: number) => number;
   readonly generate_gradient_between_blocks: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => any;
   readonly generate_gradient_between_colors: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => any;
   readonly get_all_colored_blocks: () => any;

package/package.json

@@ -5,7 +5,7 @@
     "Nano nano@schem.at"
   ],
   "description": "A high-performance Minecraft schematic parser and utility library",
-  "version": "0.1.169",
+  "version": "0.1.170",
   "license": "AGPL-3.0-only",
   "repository": {
     "type": "git",