nucleation 0.1.132__tar.gz → 0.1.133__tar.gz

{nucleation-0.1.132 → nucleation-0.1.133}/Cargo.lock

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

{nucleation-0.1.132 → nucleation-0.1.133}/Cargo.toml

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

{nucleation-0.1.132 → nucleation-0.1.133}/PKG-INFO

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

{nucleation-0.1.132 → nucleation-0.1.133}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "nucleation"
-version = "0.1.132"
+version = "0.1.133"
 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.132 → nucleation-0.1.133}/release-artifacts/nucleation-original.js

@@ -255,13 +255,6 @@ 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}
@@ -280,6 +273,13 @@ export function debug_schematic(schematic) {
     }
 }
 
+/**
+ * Initialize WASM module with panic hook for better error messages
+ */
+export function start() {
+    wasm.start();
+}
+
 /**
  * @param {SchematicWrapper} schematic
  * @returns {string}
@@ -1089,7 +1089,7 @@ export class DefinitionRegionWrapper {
      * @returns {DefinitionRegionWrapper}
      */
     copy() {
-        const ret = wasm.definitionregionwrapper_clone(this.__wbg_ptr);
+        const ret = wasm.definitionregionwrapper_copy(this.__wbg_ptr);
         return DefinitionRegionWrapper.__wrap(ret);
     }
     /**

{nucleation-0.1.132 → nucleation-0.1.133}/release-artifacts/package.json

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

{nucleation-0.1.132 → nucleation-0.1.133}/src/simulation/typed_executor/mod.rs

@@ -120,7 +120,7 @@ mod io_layout_builder;
 mod io_mapping;
 mod io_type;
 mod layout_function;
-mod sort_strategy;
+pub mod sort_strategy;
 mod value;
 
 #[cfg(test)]

{nucleation-0.1.132 → nucleation-0.1.133}/src/simulation/typed_executor/sort_strategy.rs

@@ -68,6 +68,23 @@ pub enum SortStrategy {
 
     /// Reverse of whatever order positions were added
     Reverse,
+
+    /// Custom sort order defined by a list of axes and directions
+    /// Example: [ (Y, Descending), (X, Ascending), (Z, Ascending) ]
+    Custom(Vec<(Axis, Direction)>),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Axis {
+    X,
+    Y,
+    Z,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Direction {
+    Ascending,
+    Descending,
 }
 
 impl Default for SortStrategy {
@@ -96,6 +113,32 @@ impl SortStrategy {
                         .then_with(|| a.2.cmp(&b.2))
                 });
             }
+            SortStrategy::Custom(orders) => {
+                positions.sort_by(|a, b| {
+                    for (axis, direction) in orders {
+                        let val_a = match axis {
+                            Axis::X => a.0,
+                            Axis::Y => a.1,
+                            Axis::Z => a.2,
+                        };
+                        let val_b = match axis {
+                            Axis::X => b.0,
+                            Axis::Y => b.1,
+                            Axis::Z => b.2,
+                        };
+
+                        let cmp = match direction {
+                            Direction::Ascending => val_a.cmp(&val_b),
+                            Direction::Descending => val_b.cmp(&val_a),
+                        };
+
+                        if cmp != std::cmp::Ordering::Equal {
+                            return cmp;
+                        }
+                    }
+                    std::cmp::Ordering::Equal
+                });
+            }
             SortStrategy::XYZ => {
                 positions.sort_by(|a, b| {
                     a.0.cmp(&b.0)
@@ -226,6 +269,7 @@ impl SortStrategy {
             SortStrategy::DistanceFromDesc { .. } => "distance_from_desc",
             SortStrategy::Preserve => "preserve",
             SortStrategy::Reverse => "reverse",
+            SortStrategy::Custom(_) => "custom",
         }
     }
 }

{nucleation-0.1.132 → nucleation-0.1.133}/src/wasm/definition_region.rs

@@ -153,7 +153,6 @@ impl DefinitionRegionWrapper {
             schematic_ptr: std::ptr::null_mut(),
             name: None,
         }
-    
     }
 
     // ========================================================================
@@ -390,7 +389,6 @@ impl DefinitionRegionWrapper {
         self
     }
 
-
     // ========================================================================
     // Box Access (for Rendering)
     // ========================================================================

{nucleation-0.1.132 → nucleation-0.1.133}/src/wasm/schematic.rs

@@ -22,11 +22,11 @@ use web_sys::console;
 use super::definition_region::DefinitionRegionWrapper;
 
 #[cfg(feature = "simulation")]
-use super::circuit_builder::CircuitBuilderWrapper;
+use super::circuit_builder::{CircuitBuilderWrapper, SortStrategyWrapper};
 #[cfg(feature = "simulation")]
 use super::typed_executor::TypedCircuitExecutorWrapper;
 #[cfg(feature = "simulation")]
-use crate::simulation::typed_executor::IoType;
+use crate::simulation::typed_executor::{IoType, SortStrategy};
 
 #[wasm_bindgen]
 pub struct LazyChunkIterator {
@@ -1431,8 +1431,8 @@ impl SchematicWrapper {
         // Parse config object
         // Expected format:
         // {
-        //   inputs: [ { name: "a", bits: 8, region: "a" }, ... ],
-        //   outputs: [ { name: "out", bits: 9, region: "c" }, ... ]
+        //   inputs: [ { name: "a", type: "uint", bits: 8, region: "a" }, ... ],
+        //   outputs: [ { name: "out", type: "matrix", rows: 4, cols: 4, element: "boolean", region: "c" }, ... ]
         // }
 
         let inputs = Reflect::get(&config, &JsValue::from_str("inputs"))?;
@@ -1444,10 +1444,6 @@ impl SchematicWrapper {
                     .as_string()
                     .ok_or_else(|| JsValue::from_str("Input name missing or not a string"))?;
 
-                let bits = Reflect::get(&input, &JsValue::from_str("bits"))?
-                    .as_f64()
-                    .unwrap_or(1.0) as u32;
-
                 let region_name = Reflect::get(&input, &JsValue::from_str("region"))?
                     .as_string()
                     .ok_or_else(|| {
@@ -1457,14 +1453,27 @@ impl SchematicWrapper {
                 // Get region wrapper
                 let region = self.get_definition_region(region_name.clone())?;
 
-                // Create IO Type (defaulting to unsigned int for now)
-                // TODO: Add support for signed/other types via config
-                let io_type = crate::simulation::typed_executor::IoType::UnsignedInt {
-                    bits: bits as usize,
-                };
+                // Create IO Type
+                let io_type = parse_js_io_type(&input)?;
                 let io_type_wrapper = crate::IoTypeWrapper { inner: io_type };
 
-                builder = builder.with_input_auto(name, &io_type_wrapper, &region)?;
+                // Parse sort strategy
+                let sort_str = Reflect::get(&input, &JsValue::from_str("sort"))?.as_string();
+
+                let sort_wrapper = if let Some(s) = sort_str {
+                    Some(SortStrategyWrapper {
+                        inner: parse_sort_string(&s),
+                    })
+                } else {
+                    None
+                };
+
+                if let Some(sort) = sort_wrapper {
+                    builder =
+                        builder.with_input_auto_sorted(name, &io_type_wrapper, &region, &sort)?;
+                } else {
+                    builder = builder.with_input_auto(name, &io_type_wrapper, &region)?;
+                }
             }
         }
 
@@ -1477,10 +1486,6 @@ impl SchematicWrapper {
                     .as_string()
                     .ok_or_else(|| JsValue::from_str("Output name missing or not a string"))?;
 
-                let bits = Reflect::get(&output, &JsValue::from_str("bits"))?
-                    .as_f64()
-                    .unwrap_or(1.0) as u32;
-
                 let region_name = Reflect::get(&output, &JsValue::from_str("region"))?
                     .as_string()
                     .ok_or_else(|| {
@@ -1491,12 +1496,26 @@ impl SchematicWrapper {
                 let region = self.get_definition_region(region_name.clone())?;
 
                 // Create IO Type
-                let io_type = crate::simulation::typed_executor::IoType::UnsignedInt {
-                    bits: bits as usize,
-                };
+                let io_type = parse_js_io_type(&output)?;
                 let io_type_wrapper = crate::IoTypeWrapper { inner: io_type };
 
-                builder = builder.with_output_auto(name, &io_type_wrapper, &region)?;
+                // Parse sort strategy
+                let sort_str = Reflect::get(&output, &JsValue::from_str("sort"))?.as_string();
+
+                let sort_wrapper = if let Some(s) = sort_str {
+                    Some(SortStrategyWrapper {
+                        inner: parse_sort_string(&s),
+                    })
+                } else {
+                    None
+                };
+
+                if let Some(sort) = sort_wrapper {
+                    builder =
+                        builder.with_output_auto_sorted(name, &io_type_wrapper, &region, &sort)?;
+                } else {
+                    builder = builder.with_output_auto(name, &io_type_wrapper, &region)?;
+                }
             }
         }
 
@@ -1680,3 +1699,126 @@ impl SchematicWrapper {
             .map_err(|e| JsValue::from_str(&format!("JSON serialization error: {}", e)))
     }
 }
+
+#[cfg(feature = "simulation")]
+fn parse_sort_string(sort_str: &str) -> SortStrategy {
+    use crate::simulation::typed_executor::sort_strategy::{Axis, Direction};
+
+    // Handle standard presets
+    match sort_str {
+        "yxz" => return SortStrategy::YXZ,
+        "xyz" => return SortStrategy::XYZ,
+        "zyx" => return SortStrategy::ZYX,
+        "yDescXZ" => return SortStrategy::YDescXZ,
+        "xDescYZ" => return SortStrategy::XDescYZ,
+        "zDescYX" => return SortStrategy::ZDescYX,
+        "descending" => return SortStrategy::YXZDesc,
+        _ => {}
+    }
+
+    // Parse custom string like "-y+x-z" or "yxz"
+    let mut orders = Vec::new();
+    let mut chars = sort_str.chars().peekable();
+
+    while let Some(&c) = chars.peek() {
+        let direction = if c == '-' {
+            chars.next();
+            Direction::Descending
+        } else if c == '+' {
+            chars.next();
+            Direction::Ascending
+        } else {
+            Direction::Ascending // Default to ascending if no sign
+        };
+
+        if let Some(axis_char) = chars.next() {
+            let axis = match axis_char.to_ascii_lowercase() {
+                'x' => Axis::X,
+                'y' => Axis::Y,
+                'z' => Axis::Z,
+                _ => continue, // Skip invalid chars
+            };
+            orders.push((axis, direction));
+        }
+    }
+
+    if orders.is_empty() {
+        SortStrategy::YXZ // Fallback
+    } else {
+        SortStrategy::Custom(orders)
+    }
+}
+
+#[cfg(feature = "simulation")]
+fn parse_js_io_type(config: &JsValue) -> Result<IoType, JsValue> {
+    if config.is_string() {
+        let type_str = config.as_string().unwrap();
+        return match type_str.as_str() {
+            "boolean" => Ok(IoType::Boolean),
+            "float" => Ok(IoType::Float32),
+            "uint" => Ok(IoType::UnsignedInt { bits: 1 }),
+            "int" => Ok(IoType::SignedInt { bits: 1 }),
+            "hex" => Ok(IoType::UnsignedInt { bits: 4 }),
+            _ => Err(JsValue::from_str(&format!(
+                "Unknown simple IO type: {}",
+                type_str
+            ))),
+        };
+    }
+
+    let type_str = Reflect::get(config, &"type".into())?
+        .as_string()
+        .unwrap_or_else(|| "uint".to_string());
+
+    match type_str.as_str() {
+        "uint" => {
+            let bits = Reflect::get(config, &"bits".into())?
+                .as_f64()
+                .unwrap_or(1.0) as usize;
+            Ok(IoType::UnsignedInt { bits })
+        }
+        "int" => {
+            let bits = Reflect::get(config, &"bits".into())?
+                .as_f64()
+                .unwrap_or(1.0) as usize;
+            Ok(IoType::SignedInt { bits })
+        }
+        "float" => Ok(IoType::Float32),
+        "boolean" => Ok(IoType::Boolean),
+        "hex" => Ok(IoType::UnsignedInt { bits: 4 }),
+        "array" => {
+            let length = Reflect::get(config, &"length".into())?
+                .as_f64()
+                .ok_or_else(|| JsValue::from_str("Array type requires 'length'"))?
+                as usize;
+
+            let element_val = Reflect::get(config, &"element".into())?;
+            let element_type = parse_js_io_type(&element_val)?;
+
+            Ok(IoType::Array {
+                element_type: Box::new(element_type),
+                length,
+            })
+        }
+        "matrix" => {
+            let rows = Reflect::get(config, &"rows".into())?
+                .as_f64()
+                .ok_or_else(|| JsValue::from_str("Matrix type requires 'rows'"))?
+                as usize;
+            let cols = Reflect::get(config, &"cols".into())?
+                .as_f64()
+                .ok_or_else(|| JsValue::from_str("Matrix type requires 'cols'"))?
+                as usize;
+
+            let element_val = Reflect::get(config, &"element".into())?;
+            let element_type = parse_js_io_type(&element_val)?;
+
+            Ok(IoType::Matrix {
+                element_type: Box::new(element_type),
+                rows,
+                cols,
+            })
+        }
+        _ => Err(JsValue::from_str(&format!("Unknown IO type: {}", type_str))),
+    }
+}

nucleation-0.1.133/tests/executor_config_test.js

@@ -0,0 +1,228 @@
+
+const fs = require('fs');
+const path = require('path');
+
+// Adjust path to where your built WASM is located
+const wasmPath = path.join(__dirname, '../pkg/nucleation.js');
+
+async function runTests() {
+    let nucleation;
+
+    try {
+        nucleation = require(wasmPath);
+        if (nucleation.default && typeof nucleation.default === 'function') {
+            await nucleation.default();
+        }
+        console.log('✅ WASM module loaded successfully');
+    } catch (error) {
+        console.error('❌ Failed to load WASM module:', error);
+        console.log('Make sure to build the WASM package first with: ./build-wasm.sh');
+        process.exit(1);
+    }
+
+    const { SchematicWrapper } = nucleation;
+
+    function createDummySchematic() {
+        const schematic = new SchematicWrapper();
+        // Create a small platform to define regions on
+        for (let x = 0; x < 10; x++) {
+            for (let z = 0; z < 10; z++) {
+                schematic.set_block(x, 0, z, "minecraft:stone");
+            }
+        }
+        return schematic;
+    }
+
+    function testMatrixConfig() {
+        console.log('Testing Matrix Configuration...');
+        const schem = createDummySchematic();
+        
+        // Define regions
+        schem.createRegion("matrix_in", {x: 0, y: 1, z: 0}, {x: 5, y: 1, z: 6}); // 6x7 area
+        schem.createRegion("matrix_out", {x: 0, y: 2, z: 0}, {x: 5, y: 2, z: 6});
+
+        try {
+            const executor = schem.buildExecutor({
+                inputs: [
+                    { 
+                        name: "grid_in", 
+                        region: "matrix_in",
+                        type: "matrix", 
+                        rows: 6, 
+                        cols: 7, 
+                        element: "boolean",
+                        sort: "yxz"
+                    }
+                ],
+                outputs: [
+                    { 
+                        name: "grid_out", 
+                        region: "matrix_out",
+                        type: "matrix", 
+                        rows: 6, 
+                        cols: 7, 
+                        element: "boolean"
+                    }
+                ]
+            });
+            console.log('✅ Matrix config built successfully');
+        } catch (e) {
+            console.error('❌ Matrix config failed:', e);
+            throw e;
+        }
+    }
+
+    function testArrayConfig() {
+        console.log('Testing Array Configuration...');
+        const schem = createDummySchematic();
+        
+        // Define regions
+        schem.createRegion("array_in", {x: 0, y: 1, z: 0}, {x: 7, y: 1, z: 0}); // 8 blocks
+        schem.createRegion("array_out", {x: 0, y: 2, z: 0}, {x: 7, y: 2, z: 0});
+
+        try {
+            const executor = schem.buildExecutor({
+                inputs: [
+                    { 
+                        name: "bytes_in", 
+                        region: "array_in",
+                        type: "array", 
+                        length: 8, 
+                        element: "boolean" // 8 booleans
+                    }
+                ],
+                outputs: [
+                    { 
+                        name: "bytes_out", 
+                        region: "array_out",
+                        type: "array", 
+                        length: 2, 
+                        element: { type: "uint", bits: 4 } // 2 nibbles (4 bits each) = 8 bits total
+                    }
+                ]
+            });
+            console.log('✅ Array config built successfully');
+        } catch (e) {
+            console.error('❌ Array config failed:', e);
+            throw e;
+        }
+    }
+
+    function testHexConfig() {
+        console.log('Testing Hex Configuration...');
+        const schem = createDummySchematic();
+        
+        schem.createRegion("hex_in", {x: 0, y: 1, z: 0}, {x: 3, y: 1, z: 0}); // 4 blocks
+
+        try {
+            const executor = schem.buildExecutor({
+                inputs: [
+                    { 
+                        name: "hex_val", 
+                        region: "hex_in",
+                        type: "hex" // Should map to uint bits: 4
+                    }
+                ],
+                outputs: []
+            });
+            console.log('✅ Hex config built successfully');
+        } catch (e) {
+            console.error('❌ Hex config failed:', e);
+            throw e;
+        }
+    }
+
+    function testCustomSort() {
+        console.log('Testing Custom Sort...');
+        const schem = createDummySchematic();
+        
+        schem.createRegion("sorted_region", {x: 0, y: 1, z: 0}, {x: 2, y: 2, z: 2}); // 3x2x3 = 18 blocks
+
+        const sortStrings = [
+            "yxz",
+            "-y+x-z",
+            "zDescYX",
+            "+x-z+y"
+        ];
+
+        for (const sortStr of sortStrings) {
+            try {
+                schem.buildExecutor({
+                    inputs: [
+                        { 
+                            name: `sorted_${sortStr}`, 
+                            region: "sorted_region",
+                            type: "uint",
+                            bits: 18,
+                            sort: sortStr
+                        }
+                    ],
+                    outputs: []
+                });
+                console.log(`✅ Sort '${sortStr}' built successfully`);
+            } catch (e) {
+                console.error(`❌ Sort '${sortStr}' failed:`, e);
+                throw e;
+            }
+        }
+    }
+
+    function testComplexMixed() {
+        console.log('Testing Complex Mixed Configuration...');
+        const schem = createDummySchematic();
+        
+        schem.createRegion("p1", {x: 0, y: 1, z: 0}, {x: 5, y: 1, z: 6}); // 42 blocks
+        schem.createRegion("p2", {x: 10, y: 1, z: 0}, {x: 15, y: 1, z: 6}); // 42 blocks
+        schem.createRegion("out", {x: 20, y: 1, z: 0}, {x: 26, y: 1, z: 0}); // 7 blocks
+
+        try {
+            const executor = schem.buildExecutor({
+                inputs: [
+                    { 
+                        name: "player_a", 
+                        region: "p1",
+                        type: "matrix", 
+                        rows: 6, 
+                        cols: 7, 
+                        element: "boolean",
+                        sort: "-y+x+z"
+                    },
+                    { 
+                        name: "player_b", 
+                        region: "p2",
+                        type: "array", 
+                        length: 7, 
+                        element: { type: "uint", bits: 6 } // 7 * 6 = 42 bits
+                    }
+                ],
+                outputs: [
+                    { 
+                        name: "result", 
+                        region: "out",
+                        type: "array", 
+                        length: 7, 
+                        element: "boolean"
+                    }
+                ]
+            });
+            console.log('✅ Complex mixed config built successfully');
+        } catch (e) {
+            console.error('❌ Complex mixed config failed:', e);
+            throw e;
+        }
+    }
+
+    try {
+        testMatrixConfig();
+        testArrayConfig();
+        testHexConfig();
+        testCustomSort();
+        testComplexMixed();
+        console.log('\n🎉 All tests passed!');
+    } catch (e) {
+        console.error('\n💥 Some tests failed');
+        process.exit(1);
+    }
+}
+
+runTests();