fix(runtime): linking, call_indirect, and exception handling execution failures

[avrabe]

Problem

Several categories of runtime execution failures remain, totaling ~1,500+ assertion failures.

Breakdown

Category	Assertions	Description
assert_return failures	~1,533	Various execution results don't match expected values
assert_trap failures	~310	Traps not triggered or wrong trap type
assert_unlinkable	~235	Linking validation too permissive
cross-instance call_indirect	~109	call_indirect across module instances fails
out of bounds memory access	~145	Memory access traps not properly triggered
GC instructions not implemented	~196	GC instructions (array., struct., ref_cast, etc.)
SIMD execution	~112	SIMD operations produce wrong results
Exception handling	~37	try_table/throw/throw_ref execution issues
Unknown instruction opcode	~18	Some instructions not decoded (br_on_null, call_ref, etc.)

Key areas for impact

1. cross-instance call_indirect (109 failures): Function table sharing across instances
2. assert_unlinkable (235 failures): Import/export type compatibility checking at link time
3. Memory access traps (145 failures): Bounds checking in load/store operations
4. GC instructions (196 failures): array.get, struct.get, ref.cast, etc.

Files

• kiln-runtime/src/ — execution engine
• kiln-engine/src/ — instruction dispatch
• kiln-build-core/src/wast_executor.rs — test execution harness (linking, instantiation)

[avrabe]

Progress update — WAST conformance at 99.52%

After rebuilding cargo-kiln from source and implementing several validator fixes:

Current: 65,311 / 65,624 assertions passing (99.52%)

Fixes landed (PR #190):

• GC bottom types: none, noextern, noexn now distinct from their top types
• call_ref/return_call_ref: typed funcref operand validation
• Immutability enforcement: struct.set, array.set/fill/copy/init_data/init_elem
• array.init_data: numeric element type check
• array.copy: element type compatibility check

Remaining 313 failures — breakdown:

Category	Count	Notes
GC runtime (cast/branch)	~120	br_on_cast, ref_test, ref_cast, i31, struct/array ops
Instance/linking	~50	Module registration, import type checking for GC refs
Validator (type mismatch)	61	GC instruction validation rules (br_on_cast, table types, elem types)
Table/elem runtime	~30	Element initialization, table operations
Scattered runtime	~50	Data segments, uninitialized elements, bounded conversion
Assert_malformed	7	Decoder edge cases
Validator (other)	9	Uninitialized locals (4), multiple memories/tables (4), constant expr (1)

The remaining work is increasingly runtime-heavy — each GC instruction needs both validator rules and execution implementation.

[avrabe]

Update — WAST conformance at 99.66%

Current: 65,408 / 65,633 (99.66%) — 225 remaining

Latest fixes (PR #192):

• br_on_cast/br_on_cast_fail: rt2 <: rt1 subtype validation (+6)
• VxWorks cross-compilation fixes (PLATFORM_UNSUPPORTED code, as_ptr, type mismatch)

Remaining 225 failures — architecture-limited:

~40 failures are blocked by BoundedVec table serialization: tables serialize/deserialize GC ref values, losing Arc identity and field data. This causes:

• ref.eq identity comparison failures
• struct/array field access after table round-trip
• i31 values not surviving table storage

Fix requires: storing Arc references directly in table slots instead of going through BoundedVec byte serialization.

~50 are validator gaps requiring full br_on_cast type difference computation and table/elem type checking rules.

~135 are scattered runtime issues: each is a separate code path (wrong trap type, stack underflow, element init, cross-instance linking).

[avrabe]

Update — WAST conformance at 99.76%

65,477 / 65,633 (99.76%) — 156 remaining

Session progress: started at 65,293 (99.50%), now at 65,477 (+184 assertions fixed across 9 PRs).

Key architectural fixes this session:

• Table storage: BoundedVec → Vec (GC ref identity)
• GC bottom types: NoneRef, NoExternRef, NoExnRef in ValueType
• Table init expression evaluation
• Extended const expr evaluation (i32.add/sub/mul)
• BrOnCast/BrOnCastFail/BrOnNonNull branch resolution
• FuncRef concrete subtype checking in ref_test
• Cross-module import type compatibility with GC subtyping
• Packed field sign/zero extension for struct/array
• Uninitialized local validation

Remaining 156 failures:

~60% are GC cast/branch runtime issues needing deeper per-test investigation. The rest are scattered across linking, element segments, exception handling, and validator gaps.

[avrabe]

Significant progress in PR #220:

• call_indirect now uses canonical type IDs with subtype chain walking (fixes indirect call type mismatch failures)
• Import type subtyping with PreciseTypeInfo, rec-group matching, finality checking (12 of 13 assert_unlinkable fixed)
• Cross-module struct field type index relativization for rec-group comparison
• br_on_non_null multi-value branch preservation

Remaining: 2 cross-instance call_indirect target-instance-not-found failures in linking.wast.

[avrabe]

Backlog-triage sweep — verified current status (2026-06-13). Re-ran the full suite (cargo-kiln testsuite --run-wast --wast-dir external/testsuite) to ground this in a live number rather than commit messages:

Files: 280 total, 206 passed, 74 failed
Assertions: 65310 passed, 332 failed

~99.5% (65310/65642), 332 failures remain. Note: this is higher than the "156 remaining" from April because the external/testsuite submodule advanced (now @7e0b83a, the 2026-03-04 auto-update), pulling in newer proposal tests — so some recent commit messages quoting near-zero failures were against an older, smaller test set.

Failures by cluster (top files):

• GC type system / subtyping (the dominant cluster): type-subtyping (27), br_on_cast+br_on_cast_fail (17+17, plus 16+16 in the custom-descriptors proposal), i31 (12), ref_test (8), struct (7), array* (9+7+4+3+3), type-rec/type-equivalence/ref_eq (4 each), ref_cast (3)
• Linking / imports: instance (18), imports1/2/4 (5+5+8), imports (3), linking (4)
• Tables / elem: elem (16), table (14) [note: CLAUDE.md flags kiln-runtime/src/table.rs as fragile], table_grow (5)
• Exception handling: try_table (3), throw_ref (3), tag (2)
• Memory / data: memory64-imports (8), data* (4+2), store1 (2)

Still actionable, kept open. This is a large multi-area conformance effort, GC-subtyping-dominated, and historically regression-prone (a naive fix here once caused ~400 regressions), so it needs careful per-cluster TDD with full-suite regression gating, not a blanket pass. The stale "~1,500 failures" note in rivet AC-WAST has been corrected to the verified 332 (PR incoming).

[avrabe]

Track-2 diagnosis (2026-06-14, post-v0.3.2). Ran the biggest cluster alone (--wast-filter type-subtyping.wast, 0.30s): 90 pass / 27 fail. The 27 trace to a single root cause — the GC reference-type subtyping relation is wrong in BOTH directions, and it underlies the other GC clusters too (br_on_cast ×4 files, ref_test, ref_cast, i31, struct/array, type-rec, type-equivalence).

Categories:

• Too permissive (16): 7 assert_unlinkable "incompatible import type" but linking succeeded; 4 assert_invalid "sub type" but validation succeeded; 5 ref.cast "expected cast failure but function succeeded"; 4 assert_trap "indirect call type mismatch" not triggered.
• Too strict (4): 1 assert_return run fails with a spurious "indirect call type mismatch"; 3 ref.test return 1 where 0 is expected.
• (Plus cascades: a module that wrongly fails to instantiate → "run not exported".)

Where the fix lives — two implementations that must agree and both match the spec GC lattice:

• Runtime (kiln-build-core/src/wast_execution.rs): precise_ref_type_is_subtype (2150), is_heap_type_subtype (2214), is_value_type_subtype[_cross_module] (2259/2303), is_type_idx_subtype_cross_module (2410) — drives ref.cast/ref.test/call_indirect/import-linking.
• Validator (kiln-build-core/src/wast_validator.rs): is_subtype_of_in_module (6242), is_concrete_subtype (6206), validate_subtype_declarations (6348), are_subtypes_structurally_equal (6025).

Plan: a focused multi-pass effort on the subtyping relation (GC lattice: none/nofunc/noextern bottoms, any/eq/func/extern tops, struct/array/i31, concrete rec-group types with final/non-final), aligning both implementations, regression-gating each change against the full 65k-assertion suite (single-file iteration is 0.3s; full-suite confirm is the gate). Not attempted as a quick fix — this is the area that historically caused ~400 regressions when touched naively.