nucleation 0.1.126 → 0.1.128

package/nucleation-original.js

@@ -470,6 +470,9 @@ export class CircuitBuilderWrapper {
     }
     /**
      * Add an input with full control
+     *
+     * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+     * For custom ordering, use `withInputSorted`.
      * @param {string} name
      * @param {IoTypeWrapper} io_type
      * @param {LayoutFunctionWrapper} layout
@@ -522,6 +525,9 @@ export class CircuitBuilderWrapper {
     }
     /**
      * Add an output with full control
+     *
+     * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+     * For custom ordering, use `withOutputSorted`.
      * @param {string} name
      * @param {IoTypeWrapper} io_type
      * @param {LayoutFunctionWrapper} layout
@@ -584,6 +590,9 @@ export class CircuitBuilderWrapper {
     }
     /**
      * Add an input with automatic layout inference
+     *
+     * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+     * For custom ordering, use `withInputAutoSorted`.
      * @param {string} name
      * @param {IoTypeWrapper} io_type
      * @param {DefinitionRegionWrapper} region
@@ -618,6 +627,9 @@ export class CircuitBuilderWrapper {
     }
     /**
      * Add an output with automatic layout inference
+     *
+     * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+     * For custom ordering, use `withOutputAutoSorted`.
      * @param {string} name
      * @param {IoTypeWrapper} io_type
      * @param {DefinitionRegionWrapper} region
@@ -635,6 +647,94 @@ export class CircuitBuilderWrapper {
         }
         return CircuitBuilderWrapper.__wrap(ret[0]);
     }
+    /**
+     * Add an input with full control and custom sort strategy
+     * @param {string} name
+     * @param {IoTypeWrapper} io_type
+     * @param {LayoutFunctionWrapper} layout
+     * @param {DefinitionRegionWrapper} region
+     * @param {SortStrategyWrapper} sort
+     * @returns {CircuitBuilderWrapper}
+     */
+    withInputSorted(name, io_type, layout, region, sort) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(io_type, IoTypeWrapper);
+        _assertClass(layout, LayoutFunctionWrapper);
+        _assertClass(region, DefinitionRegionWrapper);
+        _assertClass(sort, SortStrategyWrapper);
+        const ret = wasm.circuitbuilderwrapper_withInputSorted(ptr, ptr0, len0, io_type.__wbg_ptr, layout.__wbg_ptr, region.__wbg_ptr, sort.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CircuitBuilderWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Add an output with full control and custom sort strategy
+     * @param {string} name
+     * @param {IoTypeWrapper} io_type
+     * @param {LayoutFunctionWrapper} layout
+     * @param {DefinitionRegionWrapper} region
+     * @param {SortStrategyWrapper} sort
+     * @returns {CircuitBuilderWrapper}
+     */
+    withOutputSorted(name, io_type, layout, region, sort) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(io_type, IoTypeWrapper);
+        _assertClass(layout, LayoutFunctionWrapper);
+        _assertClass(region, DefinitionRegionWrapper);
+        _assertClass(sort, SortStrategyWrapper);
+        const ret = wasm.circuitbuilderwrapper_withOutputSorted(ptr, ptr0, len0, io_type.__wbg_ptr, layout.__wbg_ptr, region.__wbg_ptr, sort.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CircuitBuilderWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Add an input with automatic layout inference and custom sort strategy
+     * @param {string} name
+     * @param {IoTypeWrapper} io_type
+     * @param {DefinitionRegionWrapper} region
+     * @param {SortStrategyWrapper} sort
+     * @returns {CircuitBuilderWrapper}
+     */
+    withInputAutoSorted(name, io_type, region, sort) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(io_type, IoTypeWrapper);
+        _assertClass(region, DefinitionRegionWrapper);
+        _assertClass(sort, SortStrategyWrapper);
+        const ret = wasm.circuitbuilderwrapper_withInputAutoSorted(ptr, ptr0, len0, io_type.__wbg_ptr, region.__wbg_ptr, sort.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CircuitBuilderWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Add an output with automatic layout inference and custom sort strategy
+     * @param {string} name
+     * @param {IoTypeWrapper} io_type
+     * @param {DefinitionRegionWrapper} region
+     * @param {SortStrategyWrapper} sort
+     * @returns {CircuitBuilderWrapper}
+     */
+    withOutputAutoSorted(name, io_type, region, sort) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(io_type, IoTypeWrapper);
+        _assertClass(region, DefinitionRegionWrapper);
+        _assertClass(sort, SortStrategyWrapper);
+        const ret = wasm.circuitbuilderwrapper_withOutputAutoSorted(ptr, ptr0, len0, io_type.__wbg_ptr, region.__wbg_ptr, sort.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CircuitBuilderWrapper.__wrap(ret[0]);
+    }
     /**
      * Create a new CircuitBuilder from a schematic
      * @param {SchematicWrapper} schematic
@@ -2922,6 +3022,171 @@ export class SimulationOptionsWrapper {
 }
 if (Symbol.dispose) SimulationOptionsWrapper.prototype[Symbol.dispose] = SimulationOptionsWrapper.prototype.free;
 
+const SortStrategyWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_sortstrategywrapper_free(ptr >>> 0, 1));
+/**
+ * Sort strategy for ordering positions in IO layouts
+ *
+ * Controls how positions are ordered when assigned to bits.
+ * Position 0 corresponds to bit 0 (LSB), position 1 to bit 1, etc.
+ */
+export class SortStrategyWrapper {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SortStrategyWrapper.prototype);
+        obj.__wbg_ptr = ptr;
+        SortStrategyWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SortStrategyWrapperFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_sortstrategywrapper_free(ptr, 0);
+    }
+    /**
+     * Sort by Y descending, then X descending, then Z descending
+     * @returns {SortStrategyWrapper}
+     */
+    static descending() {
+        const ret = wasm.sortstrategywrapper_descending();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Parse sort strategy from string
+     *
+     * Accepts: "yxz", "xyz", "zyx", "y_desc", "x_desc", "z_desc",
+     *          "descending", "preserve", "reverse"
+     * @param {string} s
+     * @returns {SortStrategyWrapper}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.sortstrategywrapper_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return SortStrategyWrapper.__wrap(ret[0]);
+    }
+    /**
+     * Sort by Euclidean distance from a reference point (ascending)
+     * Closest positions first. Useful for radial layouts.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {SortStrategyWrapper}
+     */
+    static distanceFrom(x, y, z) {
+        const ret = wasm.sortstrategywrapper_distanceFrom(x, y, z);
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by Euclidean distance from a reference point (descending)
+     * Farthest positions first.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {SortStrategyWrapper}
+     */
+    static distanceFromDesc(x, y, z) {
+        const ret = wasm.sortstrategywrapper_distanceFromDesc(x, y, z);
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by X first (ascending), then Y, then Z
+     * @returns {SortStrategyWrapper}
+     */
+    static xyz() {
+        const ret = wasm.sortstrategywrapper_xyz();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by Y first (ascending), then X, then Z
+     * Standard Minecraft layer-based ordering. This is the default.
+     * @returns {SortStrategyWrapper}
+     */
+    static yxz() {
+        const ret = wasm.sortstrategywrapper_yxz();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by Z first (ascending), then Y, then X
+     * @returns {SortStrategyWrapper}
+     */
+    static zyx() {
+        const ret = wasm.iotypewrapper_float32();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Get the name of this strategy
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.sortstrategywrapper_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Reverse of whatever order positions were added
+     * @returns {SortStrategyWrapper}
+     */
+    static reverse() {
+        const ret = wasm.sortstrategywrapper_reverse();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Preserve the order positions were added (no sorting)
+     * Useful when you've manually ordered positions or are using `fromBoundingBoxes`
+     * where box order matters.
+     * @returns {SortStrategyWrapper}
+     */
+    static preserve() {
+        const ret = wasm.sortstrategywrapper_preserve();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by X first (descending), then Y ascending, then Z ascending
+     * @returns {SortStrategyWrapper}
+     */
+    static xDescYZ() {
+        const ret = wasm.sortstrategywrapper_xDescYZ();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by Y first (descending), then X ascending, then Z ascending
+     * @returns {SortStrategyWrapper}
+     */
+    static yDescXZ() {
+        const ret = wasm.iotypewrapper_boolean();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+    /**
+     * Sort by Z first (descending), then Y ascending, then X ascending
+     * @returns {SortStrategyWrapper}
+     */
+    static zDescYX() {
+        const ret = wasm.sortstrategywrapper_zDescYX();
+        return SortStrategyWrapper.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SortStrategyWrapper.prototype[Symbol.dispose] = SortStrategyWrapper.prototype.free;
+
 const StateModeConstantsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_statemodeconstants_free(ptr >>> 0, 1));

package/nucleation.d.ts

@@ -31,6 +31,9 @@ export class CircuitBuilderWrapper {
   [Symbol.dispose](): void;
   /**
    * Add an input with full control
+   *
+   * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+   * For custom ordering, use `withInputSorted`.
    */
   withInput(name: string, io_type: IoTypeWrapper, layout: LayoutFunctionWrapper, region: DefinitionRegionWrapper): CircuitBuilderWrapper;
   /**
@@ -47,6 +50,9 @@ export class CircuitBuilderWrapper {
   inputNames(): string[];
   /**
    * Add an output with full control
+   *
+   * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+   * For custom ordering, use `withOutputSorted`.
    */
   withOutput(name: string, io_type: IoTypeWrapper, layout: LayoutFunctionWrapper, region: DefinitionRegionWrapper): CircuitBuilderWrapper;
   /**
@@ -67,6 +73,9 @@ export class CircuitBuilderWrapper {
   buildValidated(): TypedCircuitExecutorWrapper;
   /**
    * Add an input with automatic layout inference
+   *
+   * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+   * For custom ordering, use `withInputAutoSorted`.
    */
   withInputAuto(name: string, io_type: IoTypeWrapper, region: DefinitionRegionWrapper): CircuitBuilderWrapper;
   /**
@@ -75,8 +84,27 @@ export class CircuitBuilderWrapper {
   withStateMode(mode: string): CircuitBuilderWrapper;
   /**
    * Add an output with automatic layout inference
+   *
+   * Uses the default sort strategy (YXZ - Y first, then X, then Z).
+   * For custom ordering, use `withOutputAutoSorted`.
    */
   withOutputAuto(name: string, io_type: IoTypeWrapper, region: DefinitionRegionWrapper): CircuitBuilderWrapper;
+  /**
+   * Add an input with full control and custom sort strategy
+   */
+  withInputSorted(name: string, io_type: IoTypeWrapper, layout: LayoutFunctionWrapper, region: DefinitionRegionWrapper, sort: SortStrategyWrapper): CircuitBuilderWrapper;
+  /**
+   * Add an output with full control and custom sort strategy
+   */
+  withOutputSorted(name: string, io_type: IoTypeWrapper, layout: LayoutFunctionWrapper, region: DefinitionRegionWrapper, sort: SortStrategyWrapper): CircuitBuilderWrapper;
+  /**
+   * Add an input with automatic layout inference and custom sort strategy
+   */
+  withInputAutoSorted(name: string, io_type: IoTypeWrapper, region: DefinitionRegionWrapper, sort: SortStrategyWrapper): CircuitBuilderWrapper;
+  /**
+   * Add an output with automatic layout inference and custom sort strategy
+   */
+  withOutputAutoSorted(name: string, io_type: IoTypeWrapper, region: DefinitionRegionWrapper, sort: SortStrategyWrapper): CircuitBuilderWrapper;
   /**
    * Create a new CircuitBuilder from a schematic
    */
@@ -769,6 +797,77 @@ export class SimulationOptionsWrapper {
   io_only: boolean;
   optimize: boolean;
 }
+/**
+ * Sort strategy for ordering positions in IO layouts
+ *
+ * Controls how positions are ordered when assigned to bits.
+ * Position 0 corresponds to bit 0 (LSB), position 1 to bit 1, etc.
+ */
+export class SortStrategyWrapper {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Sort by Y descending, then X descending, then Z descending
+   */
+  static descending(): SortStrategyWrapper;
+  /**
+   * Parse sort strategy from string
+   *
+   * Accepts: "yxz", "xyz", "zyx", "y_desc", "x_desc", "z_desc",
+   *          "descending", "preserve", "reverse"
+   */
+  static fromString(s: string): SortStrategyWrapper;
+  /**
+   * Sort by Euclidean distance from a reference point (ascending)
+   * Closest positions first. Useful for radial layouts.
+   */
+  static distanceFrom(x: number, y: number, z: number): SortStrategyWrapper;
+  /**
+   * Sort by Euclidean distance from a reference point (descending)
+   * Farthest positions first.
+   */
+  static distanceFromDesc(x: number, y: number, z: number): SortStrategyWrapper;
+  /**
+   * Sort by X first (ascending), then Y, then Z
+   */
+  static xyz(): SortStrategyWrapper;
+  /**
+   * Sort by Y first (ascending), then X, then Z
+   * Standard Minecraft layer-based ordering. This is the default.
+   */
+  static yxz(): SortStrategyWrapper;
+  /**
+   * Sort by Z first (ascending), then Y, then X
+   */
+  static zyx(): SortStrategyWrapper;
+  /**
+   * Reverse of whatever order positions were added
+   */
+  static reverse(): SortStrategyWrapper;
+  /**
+   * Preserve the order positions were added (no sorting)
+   * Useful when you've manually ordered positions or are using `fromBoundingBoxes`
+   * where box order matters.
+   */
+  static preserve(): SortStrategyWrapper;
+  /**
+   * Sort by X first (descending), then Y ascending, then Z ascending
+   */
+  static xDescYZ(): SortStrategyWrapper;
+  /**
+   * Sort by Y first (descending), then X ascending, then Z ascending
+   */
+  static yDescXZ(): SortStrategyWrapper;
+  /**
+   * Sort by Z first (descending), then Y ascending, then X ascending
+   */
+  static zDescYX(): SortStrategyWrapper;
+  /**
+   * Get the name of this strategy
+   */
+  readonly name: string;
+}
 /**
  * State mode constants for JavaScript
  */
@@ -918,13 +1017,16 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly __wbg_circuitbuilderwrapper_free: (a: number, b: number) => void;
+  readonly __wbg_definitionregionwrapper_free: (a: number, b: number) => void;
   readonly __wbg_executionmodewrapper_free: (a: number, b: number) => void;
   readonly __wbg_iolayoutbuilderwrapper_free: (a: number, b: number) => void;
+  readonly __wbg_iolayoutwrapper_free: (a: number, b: number) => void;
   readonly __wbg_iotypewrapper_free: (a: number, b: number) => void;
   readonly __wbg_layoutfunctionwrapper_free: (a: number, b: number) => void;
   readonly __wbg_mchprsworldwrapper_free: (a: number, b: number) => void;
   readonly __wbg_outputconditionwrapper_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;
   readonly __wbg_typedcircuitexecutorwrapper_free: (a: number, b: number) => void;
   readonly __wbg_valuewrapper_free: (a: number, b: number) => void;
@@ -939,10 +1041,56 @@ export interface InitOutput {
   readonly circuitbuilderwrapper_validate: (a: number) => [number, number];
   readonly circuitbuilderwrapper_withInput: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly circuitbuilderwrapper_withInputAuto: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly circuitbuilderwrapper_withInputAutoSorted: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly circuitbuilderwrapper_withInputSorted: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
   readonly circuitbuilderwrapper_withOptions: (a: number, b: number) => number;
   readonly circuitbuilderwrapper_withOutput: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
   readonly circuitbuilderwrapper_withOutputAuto: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly circuitbuilderwrapper_withOutputAutoSorted: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+  readonly circuitbuilderwrapper_withOutputSorted: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number, number];
   readonly circuitbuilderwrapper_withStateMode: (a: number, b: number, c: number) => [number, number, number];
+  readonly definitionregionwrapper_addBounds: (a: number, b: number, c: number) => void;
+  readonly definitionregionwrapper_addPoint: (a: number, b: number, c: number, d: number) => void;
+  readonly definitionregionwrapper_boxCount: (a: number) => number;
+  readonly definitionregionwrapper_center: (a: number) => any;
+  readonly definitionregionwrapper_centerF32: (a: number) => any;
+  readonly definitionregionwrapper_clone: (a: number) => number;
+  readonly definitionregionwrapper_connectedComponents: (a: number) => number;
+  readonly definitionregionwrapper_contains: (a: number, b: number, c: number, d: number) => number;
+  readonly definitionregionwrapper_contract: (a: number, b: number) => void;
+  readonly definitionregionwrapper_contracted: (a: number, b: number) => number;
+  readonly definitionregionwrapper_dimensions: (a: number) => any;
+  readonly definitionregionwrapper_expand: (a: number, b: number, c: number, d: number) => void;
+  readonly definitionregionwrapper_expanded: (a: number, b: number, c: number, d: number) => number;
+  readonly definitionregionwrapper_filterByBlock: (a: number, b: number, c: number, d: number) => number;
+  readonly definitionregionwrapper_filterByProperties: (a: number, b: number, c: any) => [number, number, number];
+  readonly definitionregionwrapper_fromBoundingBoxes: (a: any) => [number, number, number];
+  readonly definitionregionwrapper_fromBounds: (a: number, b: number) => number;
+  readonly definitionregionwrapper_fromPositions: (a: any) => [number, number, number];
+  readonly definitionregionwrapper_getAllMetadata: (a: number) => any;
+  readonly definitionregionwrapper_getBounds: (a: number) => any;
+  readonly definitionregionwrapper_getBox: (a: number, b: number) => any;
+  readonly definitionregionwrapper_getBoxes: (a: number) => any;
+  readonly definitionregionwrapper_getMetadata: (a: number, b: number, c: number) => any;
+  readonly definitionregionwrapper_intersect: (a: number, b: number) => void;
+  readonly definitionregionwrapper_intersected: (a: number, b: number) => number;
+  readonly definitionregionwrapper_intersectsBounds: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly definitionregionwrapper_isContiguous: (a: number) => number;
+  readonly definitionregionwrapper_isEmpty: (a: number) => number;
+  readonly definitionregionwrapper_merge: (a: number, b: number) => void;
+  readonly definitionregionwrapper_metadataKeys: (a: number) => any;
+  readonly definitionregionwrapper_new: () => number;
+  readonly definitionregionwrapper_positions: (a: number) => any;
+  readonly definitionregionwrapper_positionsSorted: (a: number) => any;
+  readonly definitionregionwrapper_setMetadata: (a: number, b: number, c: number, d: number, e: number) => number;
+  readonly definitionregionwrapper_shift: (a: number, b: number, c: number, d: number) => void;
+  readonly definitionregionwrapper_shifted: (a: number, b: number, c: number, d: number) => number;
+  readonly definitionregionwrapper_simplify: (a: number) => void;
+  readonly definitionregionwrapper_subtract: (a: number, b: number) => void;
+  readonly definitionregionwrapper_subtracted: (a: number, b: number) => number;
+  readonly definitionregionwrapper_union: (a: number, b: number) => number;
+  readonly definitionregionwrapper_unionInto: (a: number, b: number) => void;
+  readonly definitionregionwrapper_volume: (a: number) => number;
   readonly executionmodewrapper_fixedTicks: (a: number) => number;
   readonly executionmodewrapper_untilChange: (a: number, b: number) => number;
   readonly executionmodewrapper_untilCondition: (a: number, b: number, c: number, d: number, e: number) => number;
@@ -1004,6 +1152,17 @@ export interface InitOutput {
   readonly simulationoptionswrapper_optimize: (a: number) => number;
   readonly simulationoptionswrapper_set_io_only: (a: number, b: number) => void;
   readonly simulationoptionswrapper_set_optimize: (a: number, b: number) => void;
+  readonly sortstrategywrapper_descending: () => number;
+  readonly sortstrategywrapper_distanceFrom: (a: number, b: number, c: number) => number;
+  readonly sortstrategywrapper_distanceFromDesc: (a: number, b: number, c: number) => number;
+  readonly sortstrategywrapper_fromString: (a: number, b: number) => [number, number, number];
+  readonly sortstrategywrapper_name: (a: number) => [number, number];
+  readonly sortstrategywrapper_preserve: () => number;
+  readonly sortstrategywrapper_reverse: () => number;
+  readonly sortstrategywrapper_xDescYZ: () => number;
+  readonly sortstrategywrapper_xyz: () => number;
+  readonly sortstrategywrapper_yxz: () => number;
+  readonly sortstrategywrapper_zDescYX: () => number;
   readonly statemodeconstants_manual: () => [number, number];
   readonly statemodeconstants_stateful: () => [number, number];
   readonly statemodeconstants_stateless: () => [number, number];
@@ -1029,53 +1188,11 @@ export interface InitOutput {
   readonly valuewrapper_fromU32: (a: number) => number;
   readonly valuewrapper_toJs: (a: number) => any;
   readonly valuewrapper_typeName: (a: number) => [number, number];
+  readonly definitionregionwrapper_copy: (a: number) => number;
   readonly schematicwrapper_create_simulation_world_with_options: (a: number, b: number) => [number, number, number];
+  readonly sortstrategywrapper_yDescXZ: () => number;
+  readonly sortstrategywrapper_zyx: () => number;
   readonly schematicwrapper_create_simulation_world: (a: number) => [number, number, number];
-  readonly __wbg_iolayoutwrapper_free: (a: number, b: number) => void;
-  readonly __wbg_definitionregionwrapper_free: (a: number, b: number) => void;
-  readonly definitionregionwrapper_addBounds: (a: number, b: number, c: number) => void;
-  readonly definitionregionwrapper_addPoint: (a: number, b: number, c: number, d: number) => void;
-  readonly definitionregionwrapper_boxCount: (a: number) => number;
-  readonly definitionregionwrapper_center: (a: number) => any;
-  readonly definitionregionwrapper_centerF32: (a: number) => any;
-  readonly definitionregionwrapper_clone: (a: number) => number;
-  readonly definitionregionwrapper_connectedComponents: (a: number) => number;
-  readonly definitionregionwrapper_contains: (a: number, b: number, c: number, d: number) => number;
-  readonly definitionregionwrapper_contract: (a: number, b: number) => void;
-  readonly definitionregionwrapper_contracted: (a: number, b: number) => number;
-  readonly definitionregionwrapper_dimensions: (a: number) => any;
-  readonly definitionregionwrapper_expand: (a: number, b: number, c: number, d: number) => void;
-  readonly definitionregionwrapper_expanded: (a: number, b: number, c: number, d: number) => number;
-  readonly definitionregionwrapper_filterByBlock: (a: number, b: number, c: number, d: number) => number;
-  readonly definitionregionwrapper_filterByProperties: (a: number, b: number, c: any) => [number, number, number];
-  readonly definitionregionwrapper_fromBoundingBoxes: (a: any) => [number, number, number];
-  readonly definitionregionwrapper_fromBounds: (a: number, b: number) => number;
-  readonly definitionregionwrapper_fromPositions: (a: any) => [number, number, number];
-  readonly definitionregionwrapper_getAllMetadata: (a: number) => any;
-  readonly definitionregionwrapper_getBounds: (a: number) => any;
-  readonly definitionregionwrapper_getBox: (a: number, b: number) => any;
-  readonly definitionregionwrapper_getBoxes: (a: number) => any;
-  readonly definitionregionwrapper_getMetadata: (a: number, b: number, c: number) => any;
-  readonly definitionregionwrapper_intersect: (a: number, b: number) => void;
-  readonly definitionregionwrapper_intersected: (a: number, b: number) => number;
-  readonly definitionregionwrapper_intersectsBounds: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly definitionregionwrapper_isContiguous: (a: number) => number;
-  readonly definitionregionwrapper_isEmpty: (a: number) => number;
-  readonly definitionregionwrapper_merge: (a: number, b: number) => void;
-  readonly definitionregionwrapper_metadataKeys: (a: number) => any;
-  readonly definitionregionwrapper_new: () => number;
-  readonly definitionregionwrapper_positions: (a: number) => any;
-  readonly definitionregionwrapper_positionsSorted: (a: number) => any;
-  readonly definitionregionwrapper_setMetadata: (a: number, b: number, c: number, d: number, e: number) => number;
-  readonly definitionregionwrapper_shift: (a: number, b: number, c: number, d: number) => void;
-  readonly definitionregionwrapper_shifted: (a: number, b: number, c: number, d: number) => number;
-  readonly definitionregionwrapper_simplify: (a: number) => void;
-  readonly definitionregionwrapper_subtract: (a: number, b: number) => void;
-  readonly definitionregionwrapper_subtracted: (a: number, b: number) => number;
-  readonly definitionregionwrapper_union: (a: number, b: number) => number;
-  readonly definitionregionwrapper_unionInto: (a: number, b: number) => void;
-  readonly definitionregionwrapper_volume: (a: number) => number;
-  readonly definitionregionwrapper_copy: (a: number) => number;
   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;

package/package.json

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