nucleation 0.1.129__tar.gz → 0.1.130__tar.gz

{nucleation-0.1.129 → nucleation-0.1.130}/Cargo.lock

@@ -1687,7 +1687,7 @@ dependencies = [
 
 [[package]]
 name = "nucleation"
-version = "0.1.129"
+version = "0.1.130"
 dependencies = [
  "base64",
  "bytemuck",

{nucleation-0.1.129 → nucleation-0.1.130}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nucleation"
-version = "0.1.129"
+version = "0.1.130"
 edition = "2021"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = ["Nano nano@schem.at"]

{nucleation-0.1.129 → nucleation-0.1.130}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucleation
-Version: 0.1.129
+Version: 0.1.130
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3

{nucleation-0.1.129 → nucleation-0.1.130}/docs/rust/README.md

@@ -93,6 +93,32 @@ pub struct Region {
 }
 ```
 
+### DefinitionRegion
+
+A logical region defined by multiple bounding boxes, used for defining inputs, outputs, and other logical constructs.
+
+```rust
+pub struct DefinitionRegion {
+    pub boxes: Vec<BoundingBox>,
+    pub metadata: HashMap<String, String>,
+}
+```
+
+**Methods (Fluent API):**
+- `new() -> Self` - Create empty region
+- `from_bounds(min: (i32, i32, i32), max: (i32, i32, i32)) -> Self` - Create from bounds
+- `add_bounds(&mut self, min, max) -> &mut Self` - Add a bounding box
+- `add_point(&mut self, x, y, z) -> &mut Self` - Add a single point
+- `set_color(&mut self, color: u32) -> &mut Self` - Set visualization color
+- `with_metadata(&mut self, key, value) -> &mut Self` - Add metadata
+- `filter_by_block(&mut self, schematic, block_name) -> &mut Self` - Keep only matching blocks
+- `exclude_block(&mut self, schematic, block_name) -> &mut Self` - Remove matching blocks
+- `subtract(&mut self, other) -> &mut Self` - Boolean subtraction
+- `intersect(&mut self, other) -> &mut Self` - Boolean intersection
+- `union_into(&mut self, other) -> &mut Self` - Boolean union
+
+**Note:** Methods like `filter_by_block` require a reference to the `UniversalSchematic`. Due to Rust's borrowing rules, you may need to clone the region or build it separately before inserting it into the schematic if you need to filter based on the schematic's own blocks.
+
 ## Loading and Saving
 
 ### Litematic Format

{nucleation-0.1.129 → nucleation-0.1.130}/examples/rust.md

@@ -113,3 +113,50 @@ The Rust side does **not** re-export those symbols to avoid name clashes.
 * **Deterministic randomness**—chunk loading strategy `"Random"` hashes the
   schematic name, so the order is stable across runs.
 
+---
+
+## 6 · Definition Regions & Fluent API
+
+Nucleation provides a fluent API for defining logical regions within your schematic. This is useful for marking inputs, outputs, or other significant areas.
+
+### Basic Usage
+
+You can chain methods to define a region's properties:
+
+```rust
+schematic.create_region("my_region".to_string(), (0, 0, 0), (5, 5, 5))
+    .add_bounds((10, 0, 0), (15, 5, 5)) // Add disjoint area
+    .set_color(0xFF0000)                // Set visualization color
+    .with_metadata("type", "input");    // Add custom metadata
+```
+
+### Filtering Blocks (Borrow Checker Patterns)
+
+When filtering a region based on the blocks inside it (e.g., "keep only stone blocks"), you need to access the schematic's block data. In Rust, this creates a borrow checker challenge because the region is owned by the schematic.
+
+**Pattern A: Clone, Modify, Insert**
+Safest approach. Clone the region so you can borrow the schematic immutably while modifying the region.
+
+```rust
+if let Some(region) = schematic.definition_regions.get("layout") {
+    let mut region_clone = region.clone();
+    
+    // Now safe to borrow schematic immutably
+    region_clone.filter_by_block(&schematic, "minecraft:stone");
+    
+    // Update the schematic
+    schematic.definition_regions.insert("stone_only".to_string(), region_clone);
+}
+```
+
+**Pattern B: Build Before Inserting**
+Create the region independently, modify it, and then insert it into the schematic.
+
+```rust
+use nucleation::definition_region::DefinitionRegion;
+
+let mut new_region = DefinitionRegion::from_bounds((0,0,0), (5,5,5));
+new_region.exclude_block(&schematic, "minecraft:air");
+schematic.definition_regions.insert("non_air".to_string(), new_region);
+```
+

nucleation-0.1.130/examples/rust_fluent_api.rs

@@ -0,0 +1,50 @@
+use nucleation::definition_region::DefinitionRegion;
+use nucleation::UniversalSchematic;
+
+fn main() {
+    let mut schematic = UniversalSchematic::new("FluentRust".to_string());
+
+    // Setup some blocks
+    schematic.set_block_str(0, 0, 0, "minecraft:stone");
+    schematic.set_block_str(1, 0, 0, "minecraft:dirt");
+    schematic.set_block_str(2, 0, 0, "minecraft:stone");
+
+    // 1. Basic Fluent API (No dependency on schematic content)
+    // This works perfectly because we only borrow the region mutably (via the schematic),
+    // and we don't need to borrow the schematic again for these methods.
+    schematic
+        .create_region("layout".to_string(), (0, 0, 0), (2, 0, 0))
+        .add_bounds((0, 1, 0), (2, 1, 0))
+        .set_color(0xFF0000)
+        .with_metadata("description", "Main Layout");
+
+    println!("Created region 'layout'");
+
+    // 2. Advanced Fluent API (Filtering based on schematic content)
+    // In Rust, we cannot do:
+    // schematic.get_definition_region_mut("layout").filter_by_block(&schematic, "stone");
+    // Because `get_definition_region_mut` borrows `schematic` mutably,
+    // and `filter_by_block` needs to borrow `schematic` immutably.
+
+    // Pattern A: Clone the region, modify, and update (Safe, slightly slower)
+    if let Some(region) = schematic.definition_regions.get("layout") {
+        let mut region_clone = region.clone();
+
+        // Now we can pass &schematic because region_clone is separate
+        region_clone.filter_by_block(&schematic, "minecraft:stone");
+
+        // Update the schematic
+        schematic
+            .definition_regions
+            .insert("stone_only".to_string(), region_clone);
+    }
+
+    // Pattern B: Build region separately before inserting
+    let mut new_region = DefinitionRegion::from_bounds((0, 0, 0), (5, 5, 5));
+    new_region.exclude_block(&schematic, "minecraft:air");
+    schematic
+        .definition_regions
+        .insert("non_air".to_string(), new_region);
+
+    println!("Created filtered regions 'stone_only' and 'non_air'");
+}

{nucleation-0.1.129 → nucleation-0.1.130}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "nucleation"
-version = "0.1.129"
+version = "0.1.130"
 description = "A high-performance Minecraft schematic parser and utility library"
 authors = [{ name = "Nano", email = "nano@schem.at" }]
 license = { text = "AGPL-3.0-only" }

{nucleation-0.1.129 → nucleation-0.1.130}/release-artifacts/nucleation-original.js

@@ -255,23 +255,16 @@ function passArray8ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-/**
- * Initialize WASM module with panic hook for better error messages
- */
-export function start() {
-    wasm.start();
-}
-
 /**
  * @param {SchematicWrapper} schematic
  * @returns {string}
  */
-export function debug_json_schematic(schematic) {
+export function debug_schematic(schematic) {
     let deferred1_0;
     let deferred1_1;
     try {
         _assertClass(schematic, SchematicWrapper);
-        const ret = wasm.debug_json_schematic(schematic.__wbg_ptr);
+        const ret = wasm.debug_schematic(schematic.__wbg_ptr);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -284,12 +277,12 @@ export function debug_json_schematic(schematic) {
  * @param {SchematicWrapper} schematic
  * @returns {string}
  */
-export function debug_schematic(schematic) {
+export function debug_json_schematic(schematic) {
     let deferred1_0;
     let deferred1_1;
     try {
         _assertClass(schematic, SchematicWrapper);
-        const ret = wasm.debug_schematic(schematic.__wbg_ptr);
+        const ret = wasm.debug_json_schematic(schematic.__wbg_ptr);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -298,6 +291,13 @@ export function debug_schematic(schematic) {
     }
 }
 
+/**
+ * Initialize WASM module with panic hook for better error messages
+ */
+export function start() {
+    wasm.start();
+}
+
 const BlockPositionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_blockposition_free(ptr >>> 0, 1));
@@ -796,15 +796,31 @@ export class DefinitionRegionWrapper {
         wasm.__wbg_definitionregionwrapper_free(ptr, 0);
     }
     /**
-     * @param {BlockPosition} min
-     * @param {BlockPosition} max
+     * @param {any} min
+     * @param {any} max
+     * @returns {DefinitionRegionWrapper}
      */
     addBounds(min, max) {
-        _assertClass(min, BlockPosition);
-        var ptr0 = min.__destroy_into_raw();
-        _assertClass(max, BlockPosition);
-        var ptr1 = max.__destroy_into_raw();
-        wasm.definitionregionwrapper_addBounds(this.__wbg_ptr, ptr0, ptr1);
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.definitionregionwrapper_addBounds(ptr, min, max);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DefinitionRegionWrapper.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} filter
+     * @returns {DefinitionRegionWrapper}
+     */
+    addFilter(filter) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(filter, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.definitionregionwrapper_addFilter(ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DefinitionRegionWrapper.__wrap(ret[0]);
     }
     /**
      * Get the center point of the region as f32 (for rendering)
@@ -920,6 +936,20 @@ export class DefinitionRegionWrapper {
         const ret = wasm.definitionregionwrapper_setMetadata(ptr, ptr0, len0, ptr1, len1);
         return DefinitionRegionWrapper.__wrap(ret);
     }
+    /**
+     * @param {string} block_name
+     * @returns {DefinitionRegionWrapper}
+     */
+    excludeBlock(block_name) {
+        const ptr = this.__destroy_into_raw();
+        const ptr0 = passStringToWasm0(block_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.definitionregionwrapper_excludeBlock(ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DefinitionRegionWrapper.__wrap(ret[0]);
+    }
     /**
      * Check if all points in the region are connected (6-connectivity)
      * @returns {boolean}
@@ -1218,6 +1248,15 @@ export class DefinitionRegionWrapper {
         const ret = wasm.definitionregionwrapper_positions(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {number} color
+     * @returns {DefinitionRegionWrapper}
+     */
+    setColor(color) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.definitionregionwrapper_setColor(ptr, color);
+        return DefinitionRegionWrapper.__wrap(ret);
+    }
 }
 if (Symbol.dispose) DefinitionRegionWrapper.prototype[Symbol.dispose] = DefinitionRegionWrapper.prototype.free;
 
@@ -2382,6 +2421,21 @@ export class SchematicWrapper {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * @param {string} name
+     * @param {any} min
+     * @param {any} max
+     * @returns {DefinitionRegionWrapper}
+     */
+    createRegion(name, min, max) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_createRegion(this.__wbg_ptr, ptr0, len0, min, max);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DefinitionRegionWrapper.__wrap(ret[0]);
+    }
     /**
      * Extract all sign text from the schematic
      * Returns a JavaScript array of objects: [{pos: [x,y,z], text: "..."}]
@@ -2427,6 +2481,16 @@ export class SchematicWrapper {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * @param {string} name
+     * @param {DefinitionRegionWrapper} region
+     */
+    updateRegion(name, region) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(region, DefinitionRegionWrapper);
+        wasm.schematicwrapper_addDefinitionRegion(this.__wbg_ptr, ptr0, len0, region.__wbg_ptr);
+    }
     /**
      * All blocks as palette indices - for when you need everything at once but efficiently
      * Returns array of [x, y, z, palette_index]
@@ -2436,6 +2500,17 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_blocks_indices(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {any} config
+     * @returns {TypedCircuitExecutorWrapper}
+     */
+    buildExecutor(config) {
+        const ret = wasm.schematicwrapper_buildExecutor(this.__wbg_ptr, config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TypedCircuitExecutorWrapper.__wrap(ret[0]);
+    }
     /**
      * Optimized chunks iterator that returns palette indices instead of full block data
      * Returns array of: { chunk_x, chunk_y, chunk_z, blocks: [[x,y,z,palette_index],...] }
@@ -2461,6 +2536,18 @@ export class SchematicWrapper {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @param {any} inputs
+     * @param {any} outputs
+     * @returns {TypedCircuitExecutorWrapper}
+     */
+    createCircuit(inputs, outputs) {
+        const ret = wasm.schematicwrapper_createCircuit(this.__wbg_ptr, inputs, outputs);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TypedCircuitExecutorWrapper.__wrap(ret[0]);
+    }
     /**
      * @param {Uint8Array} data
      */
@@ -2717,6 +2804,29 @@ export class SchematicWrapper {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v2;
     }
+    /**
+     * @param {string} name
+     * @param {DefinitionRegionWrapper} region
+     */
+    addDefinitionRegion(name, region) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(region, DefinitionRegionWrapper);
+        wasm.schematicwrapper_addDefinitionRegion(this.__wbg_ptr, ptr0, len0, region.__wbg_ptr);
+    }
+    /**
+     * @param {string} name
+     * @returns {DefinitionRegionWrapper}
+     */
+    getDefinitionRegion(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_getDefinitionRegion(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DefinitionRegionWrapper.__wrap(ret[0]);
+    }
     /**
      * Get optimization stats
      * @returns {any}
@@ -2725,6 +2835,13 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_optimization_info(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @returns {CircuitBuilderWrapper}
+     */
+    createCircuitBuilder() {
+        const ret = wasm.schematicwrapper_createCircuitBuilder(this.__wbg_ptr);
+        return CircuitBuilderWrapper.__wrap(ret);
+    }
     /**
      * @returns {any}
      */
@@ -2732,6 +2849,20 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_all_block_entities(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    definitionRegionShift(name, x, y, z) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_definitionRegionShift(this.__wbg_ptr, ptr0, len0, x, y, z);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @param {string} region_name
      * @returns {any}
@@ -2752,6 +2883,14 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_region_bounding_box(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {string} name
+     */
+    createDefinitionRegion(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schematicwrapper_createDefinitionRegion(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Get the allocated dimensions (full buffer size including pre-allocated space)
      * Use this if you need to know the internal buffer size
@@ -2778,6 +2917,16 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_chunk_blocks_indices(this.__wbg_ptr, offset_x, offset_y, offset_z, width, height, length);
         return ret;
     }
+    /**
+     * @param {string} name
+     * @returns {boolean}
+     */
+    removeDefinitionRegion(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_removeDefinitionRegion(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * @param {number} x
      * @param {number} y
@@ -2826,6 +2975,27 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_default_region_palette(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    definitionRegionAddPoint(name, x, y, z) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_definitionRegionAddPoint(this.__wbg_ptr, ptr0, len0, x, y, z);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    getDefinitionRegionNames() {
+        const ret = wasm.schematicwrapper_getDefinitionRegionNames(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Optimized chunks with strategy - returns palette indices
      * @param {number} chunk_width
@@ -2843,6 +3013,40 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_chunks_indices_with_strategy(this.__wbg_ptr, chunk_width, chunk_height, chunk_length, ptr0, len0, camera_x, camera_y, camera_z);
         return ret;
     }
+    /**
+     * @param {string} name
+     * @param {BlockPosition} min
+     * @param {BlockPosition} max
+     */
+    definitionRegionAddBounds(name, min, max) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(min, BlockPosition);
+        var ptr1 = min.__destroy_into_raw();
+        _assertClass(max, BlockPosition);
+        var ptr2 = max.__destroy_into_raw();
+        const ret = wasm.schematicwrapper_definitionRegionAddBounds(this.__wbg_ptr, ptr0, len0, ptr1, ptr2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {string} name
+     * @param {string} key
+     * @param {string} value
+     */
+    definitionRegionSetMetadata(name, key, value) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.schematicwrapper_definitionRegionSetMetadata(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {Array<any>}
      */
@@ -2850,6 +3054,31 @@ export class SchematicWrapper {
         const ret = wasm.schematicwrapper_get_available_schematic_versions(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    createDefinitionRegionFromPoint(name, x, y, z) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.schematicwrapper_createDefinitionRegionFromPoint(this.__wbg_ptr, ptr0, len0, x, y, z);
+    }
+    /**
+     * @param {string} name
+     * @param {BlockPosition} min
+     * @param {BlockPosition} max
+     */
+    createDefinitionRegionFromBounds(name, min, max) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(min, BlockPosition);
+        var ptr1 = min.__destroy_into_raw();
+        _assertClass(max, BlockPosition);
+        var ptr2 = max.__destroy_into_raw();
+        wasm.schematicwrapper_createDefinitionRegionFromBounds(this.__wbg_ptr, ptr0, len0, ptr1, ptr2);
+    }
     constructor() {
         const ret = wasm.schematicwrapper_new();
         this.__wbg_ptr = ret >>> 0;
@@ -3427,6 +3656,22 @@ export class TypedCircuitExecutorWrapper {
         }
         return TypedCircuitExecutorWrapper.__wrap(ret[0]);
     }
+    /**
+     * Run the circuit with simplified arguments
+     * @param {any} inputs
+     * @param {number} limit
+     * @param {string} mode
+     * @returns {any}
+     */
+    run(inputs, limit, mode) {
+        const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.typedcircuitexecutorwrapper_run(this.__wbg_ptr, inputs, limit, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * Manually advance the simulation by a specified number of ticks
      *