feat: WebAssembly spec conformance, component execution, GC/no_std

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "external/testsuite"]
+	path = external/testsuite
+	url = https://github.com/WebAssembly/testsuite.git

kiln-build-core/src/wast.rs

@@ -619,7 +619,7 @@ impl WastTestRunner {
     /// Handle assert_return directive
     fn handle_assert_return_directive(
         &mut self,
-        exec: &WastExecute,
+        exec: &mut WastExecute,
         results: &[WastRet],
         _file_path: &Path,
     ) -> Result<WastDirectiveInfo> {
@@ -725,7 +725,7 @@ impl WastTestRunner {
     /// Handle assert_trap directive
     fn handle_assert_trap_directive(
         &mut self,
-        exec: &WastExecute,
+        exec: &mut WastExecute,
         expected_message: &str,
         _file_path: &Path,
     ) -> Result<WastDirectiveInfo> {
@@ -821,7 +821,7 @@ impl WastTestRunner {
     /// This expects the execution to throw an uncaught exception
     fn handle_assert_exception_directive(
         &mut self,
-        exec: &WastExecute,
+        exec: &mut WastExecute,
         _file_path: &Path,
     ) -> Result<WastDirectiveInfo> {
         self.stats.assert_trap_count += 1; // Count with trap tests
@@ -1415,7 +1415,7 @@ impl WastTestRunner {
     /// Handle invoke directive (standalone function call)
     fn handle_invoke_directive(
         &mut self,
-        exec: &WastExecute,
+        exec: &mut WastExecute,
         _file_path: &Path,
     ) -> Result<WastDirectiveInfo> {
         // Execute the function using the real engine

kiln-build-core/src/wast_values.rs

@@ -141,11 +141,40 @@ pub fn convert_wast_ret_core_to_value(ret: &WastRetCore) -> Result<Value> {
                 },
             }
         },
-        WastRetCore::RefI31 => {
+        WastRetCore::RefI31 | WastRetCore::RefI31Shared => {
             // (ref.i31) - any non-null i31 reference
             // Use a sentinel value to indicate "any non-null i31ref"
             Ok(Value::I31Ref(Some(i32::MAX)))
         },
+        WastRetCore::RefStruct => {
+            // (ref.struct) - any non-null struct reference
+            // Use a sentinel StructRef with alloc_id = u32::MAX
+            let sentinel = kiln_foundation::values::StructRef::new(
+                u32::MAX,
+                kiln_foundation::traits::DefaultMemoryProvider::default(),
+            ).map_err(|e| anyhow::anyhow!("Failed to create sentinel StructRef: {}", e))?;
+            Ok(Value::StructRef(Some(sentinel)))
+        },
+        WastRetCore::RefArray => {
+            // (ref.array) - any non-null array reference
+            // Use a sentinel ArrayRef with alloc_id = u32::MAX
+            let mut sentinel = kiln_foundation::values::ArrayRef::new(
+                u32::MAX,
+                kiln_foundation::traits::DefaultMemoryProvider::default(),
+            ).map_err(|e| anyhow::anyhow!("Failed to create sentinel ArrayRef: {}", e))?;
+            sentinel.alloc_id = u32::MAX;
+            Ok(Value::ArrayRef(Some(sentinel)))
+        },
+        WastRetCore::RefEq => {
+            // (ref.eq) - any non-null eqref (i31, struct, or array)
+            // Use I31Ref sentinel with i32::MAX - values_equal handles cross-type matching
+            Ok(Value::I31Ref(Some(i32::MAX)))
+        },
+        WastRetCore::RefAny => {
+            // (ref.any) - any non-null anyref (i31, struct, array)
+            // Use I31Ref sentinel with i32::MAX - values_equal handles cross-type matching
+            Ok(Value::I31Ref(Some(i32::MAX)))
+        },
         _ => {
             // Handle other reference types with default FuncRef
             Ok(Value::FuncRef(None))
@@ -332,10 +361,22 @@ pub fn values_equal(actual: &Value, expected: &Value) -> bool {
         // GC reference type comparisons
         (Value::ExnRef(a), Value::ExnRef(b)) => a == b,
         // I31Ref: i32::MAX sentinel means "any non-null i31ref" (from (ref.i31) in WAST)
+        // Also matches eqref/anyref sentinels for cross-type GC reference matching
         (Value::I31Ref(Some(_)), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => true,
         (Value::I31Ref(None), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => false,
+        // eqref/anyref sentinel (i32::MAX) matches any non-null struct/array/i31
+        (Value::StructRef(Some(_)), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => true,
+        (Value::ArrayRef(Some(_)), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => true,
+        (Value::StructRef(None), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => false,
+        (Value::ArrayRef(None), Value::I31Ref(Some(sentinel))) if *sentinel == i32::MAX => false,
         (Value::I31Ref(a), Value::I31Ref(b)) => a == b,
+        // StructRef: type_index = u32::MAX sentinel means "any non-null structref"
+        (Value::StructRef(Some(_)), Value::StructRef(Some(sentinel))) if sentinel.type_index == u32::MAX => true,
+        (Value::StructRef(None), Value::StructRef(Some(sentinel))) if sentinel.type_index == u32::MAX => false,
         (Value::StructRef(a), Value::StructRef(b)) => a == b,
+        // ArrayRef: type_index = u32::MAX sentinel means "any non-null arrayref"
+        (Value::ArrayRef(Some(_)), Value::ArrayRef(Some(sentinel))) if sentinel.type_index == u32::MAX => true,
+        (Value::ArrayRef(None), Value::ArrayRef(Some(sentinel))) if sentinel.type_index == u32::MAX => false,
         (Value::ArrayRef(a), Value::ArrayRef(b)) => a == b,
         // Cross-type null reference comparisons for WAST testing
         // In GC spec, (ref.null) without type is polymorphic and matches any null reference

kiln-component/src/components/component.rs

@@ -640,6 +640,7 @@ impl MemoryValue {
         let core_ty = kiln_runtime::CoreMemoryType {
             limits: ty.limits,
             shared: ty.shared,
+            memory64: ty.memory64,
         };
         let memory = Memory::new(core_ty)?;
         Ok(Self {
@@ -667,6 +668,7 @@ impl MemoryValue {
         let core_ty = kiln_runtime::CoreMemoryType {
             limits: ty.limits,
             shared: ty.shared,
+            memory64: ty.memory64,
         };
         let memory = Memory::new_with_name(core_ty, name)?;
         Ok(Self {

kiln-component/src/components/component_instantiation.rs

@@ -1342,7 +1342,9 @@ impl ComponentInstance {
                         let module_idx = *module_idx as usize;
 
                         if module_idx >= module_binaries.len() {
-                            continue;
+                            return Err(kiln_error::Error::component_linking_error(
+                                "Core instance references module index out of bounds",
+                            ));
                         }
 
                         let binary = &module_binaries[module_idx];
@@ -1444,7 +1446,14 @@ impl ComponentInstance {
                                                     {
                                                         // Resolve the provider handle for this specific export
                                                         let provider_handle = if let Some(src_idx) = source_instance {
-                                                            core_instances_map.get(src_idx).copied().unwrap_or(handle)
+                                                            match core_instances_map.get(src_idx) {
+                                                                Some(&h) => h,
+                                                                None => {
+                                                                    return Err(kiln_error::Error::component_linking_error(
+                                                                        "InlineExports export references source instance which is not instantiated",
+                                                                    ));
+                                                                }
+                                                            }
                                                         } else {
                                                             handle
                                                         };
@@ -1467,10 +1476,10 @@ impl ComponentInstance {
                                                         ) {
                                                             Ok(()) => {
                                                             },
-                                                            Err(e) => println!(
-                                                                "    │  │  │  └─ Note: {:?}",
-                                                                e
-                                                            ),
+                                                            Err(_e) => {
+                                                                #[cfg(feature = "tracing")]
+                                                                trace!(error = ?_e, "Import link note");
+                                                            },
                                                         }
                                                     }
                                                     // Skip the normal single-link below since we linked everything
@@ -1686,12 +1695,19 @@ impl ComponentInstance {
                                         }
 
                                     },
-                                    Err(e) => {
-                                        // Continue with other modules
+                                    Err(_e) => {
+                                        return Err(kiln_error::Error::component_linking_error(
+                                            "Failed to instantiate core module during component instantiation",
+                                        ));
                                     },
                                 }
                             },
-                            Err(e) => {
+                            Err(_e) => {
+                                #[cfg(feature = "tracing")]
+                                tracing::error!(error = %_e, "Failed to load core module");
+                                return Err(kiln_error::Error::component_linking_error(
+                                    "Failed to load core module during component instantiation",
+                                ));
                             },
                         }
                     },
@@ -2486,7 +2502,8 @@ impl ComponentInstance {
         for (idx, canon) in canonicals.iter().enumerate() {
             use kiln_format::component::CanonOperation;
 
-            print!("  Canon[{}]: ", idx);
+            #[cfg(feature = "tracing")]
+            trace!(idx = idx, "Processing canonical operation");
 
             match &canon.operation {
                 CanonOperation::Lift {
@@ -3886,8 +3903,15 @@ impl ComponentInstance {
 
                 // Try _initialize first (important for TinyGo components)
                 match engine.execute(instance_handle, "_initialize", &[]) {
-                    Ok(_) => println!("[CALL_NATIVE] ✓ _initialize completed"),
-                    Err(e) => println!("[CALL_NATIVE] ⚠ _initialize skipped: {:?}", e),
+                    Ok(_) => {
+                        #[cfg(feature = "tracing")]
+                        trace!("_initialize completed successfully");
+                    },
+                    Err(_) => {
+                        // _initialize is optional - not all components have it
+                        #[cfg(feature = "tracing")]
+                        trace!("_initialize not found, skipping");
+                    },
                 }
 
                 // Try entry point functions in order of preference:
@@ -3910,7 +3934,7 @@ impl ComponentInstance {
 
                 for entry_point in entry_points {
                     match engine.execute(instance_handle, entry_point, &wasm_args) {
-                        Ok(results) => {
+                        Ok(_results) => {
                             return Ok(vec![]); // wasi:cli/run returns nothing on success
                         },
                         Err(e) => {
@@ -3919,27 +3943,8 @@ impl ComponentInstance {
                     }
                 }
 
-                // All entry points failed - check available exports for debugging
+                // All entry points failed
                 if let Some(e) = last_error {
-                    // Debug: check for common exports (core module exports only)
-                    let common_exports = [
-                        "_start",
-                        "_initialize",
-                        "run",
-                        "main",
-                        "memory",
-                        "__heap_base",
-                        "__data_end",
-                        "cabi_realloc",
-                        "__wasm_call_ctors",
-                    ];
-                    for name in common_exports {
-                        match engine.has_function(instance_handle, name) {
-                            Ok(true) => println!("    ✓ {} - EXISTS", name),
-                            Ok(false) => println!("    ✗ {} - not found", name),
-                            Err(_) => println!("    ? {} - error checking", name),
-                        }
-                    }
                     return Err(e);
                 }
             } else {
@@ -3987,6 +3992,9 @@ impl ComponentInstance {
                             Error::runtime_execution_error("Failed to create tables")
                         })?,
                         memories: Vec::new(),
+                        #[cfg(feature = "std")]
+                        globals: Vec::new(),
+                        #[cfg(not(feature = "std"))]
                         globals: kiln_foundation::bounded::BoundedVec::new(provider.clone()).map_err(|e| {
                             Error::runtime_execution_error("Failed to create globals")
                         })?,
@@ -4024,6 +4032,8 @@ impl ComponentInstance {
                         #[cfg(feature = "std")]
                         import_types: Vec::new(),
                         num_import_functions: 0,
+                        #[cfg(feature = "std")]
+                        gc_types: Vec::new(),
                     };
                     m.load_from_binary(&binary_clone)
                 }