0e39618 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

0e39618 — Peter John 2026-08-10T12:51:35+05:30

feat(plum-wasm-codegen): migrate structs, enums, strings, and closures to wasm-gc

Files changed (5) hide show

Cargo.lock +350 -400
docs/superpowers/plans/2026-07-25-wasm-gc-migration.md +38 -38
plum-wasm-codegen/Cargo.toml +1 -1
plum-wasm-codegen/src/lib.rs +650 -649
plum-wasm-codegen/tests/codegen_tests.rs +23 -13

Cargo.lock CHANGED Viewed

@@ -4,20 +4,20 @@ version = 4
 [[package]]
 name = "addr2line"
-version = "0.24.2"
+version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
 dependencies = [
- "gimli 0.31.1",
+ "gimli 0.32.3",
 ]
 [[package]]
 name = "addr2line"
-version = "0.25.1"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
 dependencies = [
- "gimli 0.32.3",
+ "gimli 0.33.0",
 ]
 [[package]]
@@ -89,7 +89,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -100,7 +100,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -109,15 +109,6 @@ version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
-[[package]]
-name = "ar_archive_writer"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348"
-dependencies = [
- "object 0.37.3",
-]
 [[package]]
 name = "arbitrary"
 version = "1.4.2"
@@ -161,9 +152,9 @@ dependencies = [
 [[package]]
 name = "base64"
-version = "0.21.7"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 [[package]]
 name = "bitflags"
@@ -189,12 +180,6 @@ dependencies = [
  "allocator-api2",
 ]
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "cc"
 version = "1.3.0"
@@ -270,9 +255,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 [[package]]
 name = "cpp_demangle"
-version = "0.4.5"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2bb79cb74d735044c972aae58ed0aaa9a837e85b01106a54c39e42e97f62253"
+checksum = "0667304c32ea56cb4cd6d2d7c0cfe9a2f8041229db8c033af7f8d69492429def"
 dependencies = [
  "cfg-if",
 ]
@@ -286,32 +271,53 @@ dependencies = [
  "libc",
 ]
+[[package]]
+name = "cranelift-assembler-x64"
+version = "0.134.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d552bd33b7a56dc70aeb1e1c960e51a218fa0db50f23873b500a310379450b2d"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+]
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.134.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "078e80e4c222279e3330f6aa1a256ca77ddf156d4453166a9f09defedc4594dd"
+dependencies = [
+ "cranelift-srcgen",
+]
 [[package]]
 name = "cranelift-bforest"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88c1d02b72b6c411c0a2e92b25ed791ad5d071184193c08a34aa0fdcdf000b72"
+checksum = "820ce15d4ad3562d613c31a67b6d0434d403e7091a68d1349903842f7d31737e"
 dependencies = [
  "cranelift-entity",
+ "wasmtime-internal-core",
 ]
 [[package]]
 name = "cranelift-bitset"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "720b93bd86ebbb23ebfb2db1ed44d54b2ecbdbb2d034d485bc64aa605ee787ab"
+checksum = "61bca563d4b86d285928d9e27f97f27039bb33a0fc524fa130d7d0c106bf8ab3"
 dependencies = [
  "serde",
  "serde_derive",
+ "wasmtime-internal-core",
 ]
 [[package]]
 name = "cranelift-codegen"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aed3d2d9914d30b460eedd7fd507720203023997bef71452ce84873f9c93537c"
+checksum = "709f4b7c0fb57d952658d5b5c07fbdc4149acd7b7f0de9678ae754b9c981949a"
 dependencies = [
  "bumpalo",
+ "cranelift-assembler-x64",
  "cranelift-bforest",
  "cranelift-bitset",
  "cranelift-codegen-meta",
@@ -319,58 +325,70 @@ dependencies = [
  "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
- "gimli 0.31.1",
+ "gimli 0.33.0",
- "hashbrown 0.14.5",
+ "hashbrown 0.17.1",
+ "libm",
  "log",
+ "postcard",
+ "pulley-interpreter",
  "regalloc2",
  "rustc-hash",
  "serde",
+ "serde_derive",
+ "sha2",
  "smallvec",
  "target-lexicon",
+ "wasmtime-internal-core",
 ]
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "888c188d32263ec9e048873ff0b68c700933600d553f4412417916828be25f8e"
+checksum = "903dc8915af62aad1d9d0f39a5968d33fa80b9aa899ed6f56e47f40ca4512e1e"
 dependencies = [
+ "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck",
+ "pulley-interpreter",
 ]
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ddd5f4114d04ce7e073dd74e2ad16541fc61970726fcc8b2d5644a154ee4127"
+checksum = "0522d74c227e49f3fd49ab055311486ae4f09083262b66705bed676952491469"
 [[package]]
 name = "cranelift-control"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92cc4c98d6a4256a1600d93ccd3536f3e77da9b4ca2c279de786ac22876e67d6"
+checksum = "66560ea1c5cef72e170b18e46d263dba2d3169c9d39e8cafdab2173c6362cc1a"
 dependencies = [
  "arbitrary",
 ]
 [[package]]
 name = "cranelift-entity"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "760af4b5e051b5f82097a27274b917e3751736369fa73660513488248d27f23d"
+checksum = "b62ef5b17cc814d27e96b66a5b46da0e4ce2b8ac55a6d478048bb99d04b05526"
 dependencies = [
  "cranelift-bitset",
  "serde",
  "serde_derive",
+ "wasmtime-internal-core",
 ]
 [[package]]
 name = "cranelift-frontend"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0bf77ec0f470621655ec7539860b5c620d4f91326654ab21b075b83900f8831"
+checksum = "a87e0aaa39dbf70693b348a221e45904111704ee8f9fef140498471005f9842d"
 dependencies = [
  "cranelift-codegen",
+ "hashbrown 0.17.1",
  "log",
  "smallvec",
  "target-lexicon",
@@ -378,21 +396,27 @@ dependencies = [
 [[package]]
 name = "cranelift-isle"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b665d0a6932c421620be184f9fc7f7adaf1b0bc2fa77bb7ac5177c49abf645b"
+checksum = "cf79003ebfa1eed5e87f3b84446ad5236f540268289960e14f387dc9b28e40b7"
 [[package]]
 name = "cranelift-native"
-version = "0.115.1"
+version = "0.134.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2e75d1bd43dfec10924798f15e6474f1dbf63b0024506551aa19394dbe72ab"
+checksum = "05bf4f235743c81e67ee4db617c5a4a0b65d58d3f0cfc575ee0f1a4e0cd58273"
 dependencies = [
  "cranelift-codegen",
  "libc",
  "target-lexicon",
 ]
+[[package]]
+name = "cranelift-srcgen"
+version = "0.134.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6977c2a71ab1e0d1e62f966b411a498aa04c4dce47d93d52f8a360a06058922"
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -523,15 +547,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
-[[package]]
-name = "fallible-iterator"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 [[package]]
 name = "fastrand"
 version = "2.5.0"
@@ -544,11 +562,23 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 [[package]]
 name = "foldhash"
-version = "0.1.5"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 [[package]]
 name = "futures"
@@ -638,25 +668,17 @@ dependencies = [
  "slab",
 ]
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
 [[package]]
 name = "fxprof-processed-profile"
-version = "0.6.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27d12c0aed7f1e24276a241aadc4cb8ea9f83000f34bc062b7cc2d51e3b0fabd"
+checksum = "25234f20a3ec0a962a61770cfe39ecf03cb529a6e474ad8cff025ed497eda557"
 dependencies = [
  "bitflags",
  "debugid",
- "fxhash",
+ "rustc-hash",
  "serde",
+ "serde_derive",
  "serde_json",
 ]
@@ -694,20 +716,21 @@ dependencies = [
 [[package]]
 name = "gimli"
-version = "0.31.1"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
-dependencies = [
- "fallible-iterator",
- "indexmap",
- "stable_deref_trait",
-]
 [[package]]
 name = "gimli"
-version = "0.32.3"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+checksum = "0bf7f043f89559805f8c7cacc432749b2fa0d0a0a9ee46ce47164ed5ba7f126c"
+dependencies = [
+ "fnv",
+ "hashbrown 0.16.1",
+ "indexmap",
+ "stable_deref_trait",
+]
 [[package]]
 name = "hashbrown"
@@ -721,19 +744,20 @@ dependencies = [
 [[package]]
 name = "hashbrown"
-version = "0.15.5"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
-dependencies = [
- "foldhash",
- "serde",
-]
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "foldhash",
+ "serde",
+ "serde_core",
+]
 [[package]]
 name = "heck"
@@ -782,9 +806,9 @@ dependencies = [
 [[package]]
 name = "itertools"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
 dependencies = [
  "either",
 ]
@@ -868,12 +892,6 @@ dependencies = [
  "libc",
 ]
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -888,12 +906,9 @@ checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
 [[package]]
 name = "mach2"
-version = "0.4.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
+checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
-dependencies = [
- "libc",
-]
 [[package]]
 name = "memchr"
@@ -907,7 +922,7 @@ version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad38eb12aea514a0466ea40a80fd8cc83637065948eb4a426e4aa46261175227"
 dependencies = [
- "rustix 1.1.4",
+ "rustix",
 ]
 [[package]]
@@ -951,22 +966,22 @@ dependencies = [
 [[package]]
 name = "object"
-version = "0.36.7"
+version = "0.37.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
- "crc32fast",
- "hashbrown 0.15.5",
- "indexmap",
  "memchr",
 ]
 [[package]]
 name = "object"
-version = "0.37.3"
+version = "0.39.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+checksum = "2e5a6c098c7a3b6547378093f5cc30bc54fd361ce711e05293a5cc589562739b"
 dependencies = [
+ "crc32fast",
+ "hashbrown 0.17.1",
+ "indexmap",
  "memchr",
 ]
@@ -989,10 +1004,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
 [[package]]
-name = "paste"
+name = "petgraph"
-version = "1.0.15"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
 [[package]]
 name = "pin-project-lite"
@@ -1094,24 +1113,26 @@ dependencies = [
 ]
 [[package]]
-name = "psm"
+name = "pulley-interpreter"
-version = "0.1.31"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea"
+checksum = "bc5c8c21ea032e4efbdf2d067dc45171779dbe0c8ecf20ef4a57efa7474f2b0a"
 dependencies = [
- "ar_archive_writer",
+ "cranelift-bitset",
- "cc",
+ "log",
+ "pulley-macros",
+ "wasmtime-internal-core",
 ]
 [[package]]
-name = "pulley-interpreter"
+name = "pulley-macros"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8324e531de91a3c25021a30fb7862d39cc516b61fbb801176acb5ff279ea887b"
+checksum = "9f10925455d5dde962e3604eade797ba5488644c8ee14a44191e2f2b58980574"
 dependencies = [
- "cranelift-bitset",
- "log",
+ "proc-macro2",
- "sptr",
+ "quote",
+ "syn 2.0.119",
 ]
 [[package]]
@@ -1162,15 +1183,16 @@ dependencies = [
 [[package]]
 name = "regalloc2"
-version = "0.11.2"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a"
+checksum = "757712e8e61590d6d4f5d563483755538b5aa13467837a3b41cd9832509a7f85"
 dependencies = [
  "allocator-api2",
  "bumpalo",
- "hashbrown 0.15.5",
+ "hashbrown 0.17.1",
  "log",
  "rustc-hash",
+ "serde",
  "smallvec",
 ]
@@ -1215,19 +1237,6 @@ version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
-[[package]]
-name = "rustix"
-version = "0.38.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
-]
 [[package]]
 name = "rustix"
 version = "1.1.4"
@@ -1237,8 +1246,8 @@ dependencies = [
  "bitflags",
  "errno",
  "libc",
- "linux-raw-sys 0.12.1",
+ "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -1303,11 +1312,11 @@ dependencies = [
 [[package]]
 name = "serde_spanned"
-version = "0.6.9"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 [[package]]
@@ -1342,12 +1351,6 @@ dependencies = [
  "serde",
 ]
-[[package]]
-name = "sptr"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a"
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -1411,9 +1414,9 @@ dependencies = [
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 [[package]]
 name = "tempfile"
@@ -1424,8 +1427,8 @@ dependencies = [
  "fastrand",
  "getrandom 0.4.3",
  "once_cell",
- "rustix 1.1.4",
+ "rustix",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -1443,8 +1446,8 @@ version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874"
 dependencies = [
- "rustix 1.1.4",
+ "rustix",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -1520,14 +1523,17 @@ dependencies = [
 [[package]]
 name = "toml"
-version = "0.8.23"
+version = "0.9.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 dependencies = [
+ "indexmap",
- "serde",
+ "serde_core",
  "serde_spanned",
+ "toml_datetime 0.7.5+spec-1.1.0",
- "toml_datetime",
+ "toml_parser",
- "toml_edit",
+ "toml_writer",
+ "winnow 0.7.15",
 ]
 [[package]]
@@ -1535,8 +1541,14 @@ name = "toml_datetime"
 version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 [[package]]
@@ -1546,11 +1558,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
  "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
+ "toml_datetime 0.6.11",
  "toml_write",
+ "winnow 0.7.15",
+]
+[[package]]
+name = "toml_parser"
+version = "1.1.3+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56"
+dependencies = [
- "winnow",
+ "winnow 1.0.4",
 ]
 [[package]]
@@ -1559,6 +1578,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+[[package]]
+name = "toml_writer"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2"
 [[package]]
 name = "topiary-core"
 version = "0.7.3"
@@ -1668,12 +1693,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
-[[package]]
-name = "unicode-xid"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -1773,6 +1792,23 @@ dependencies = [
  "unicode-ident",
 ]
+[[package]]
+name = "wasm-compose"
+version = "0.252.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59b710751a35d54732a63851cdfacbfb2266b7160ce174faf269d3f4e84e31b"
+dependencies = [
+ "anyhow",
+ "heck",
+ "indexmap",
+ "log",
+ "petgraph",
+ "smallvec",
+ "wasm-encoder 0.252.0",
+ "wasmparser 0.252.0",
+ "wat",
+]
 [[package]]
 name = "wasm-encoder"
 version = "0.220.1"
@@ -1785,12 +1821,12 @@ dependencies = [
 [[package]]
 name = "wasm-encoder"
-version = "0.221.3"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5"
+checksum = "8185ae345fa5687c054626ff9a50e7089797a343d9904d1dc9820eb4c4d3196f"
 dependencies = [
- "leb128",
+ "leb128fmt",
- "wasmparser 0.221.3",
+ "wasmparser 0.252.0",
 ]
 [[package]]
@@ -1819,12 +1855,12 @@ dependencies = [
 [[package]]
 name = "wasmparser"
-version = "0.221.3"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
+checksum = "d3eb099dcadcde5be9eef55e3a337128efd4e44b4c93122487e4d2e4e1c6627c"
 dependencies = [
  "bitflags",
- "hashbrown 0.15.5",
+ "hashbrown 0.17.1",
  "indexmap",
  "semver",
  "serde",
@@ -1843,223 +1879,236 @@ dependencies = [
 [[package]]
 name = "wasmprinter"
-version = "0.221.3"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7343c42a97f2926c7819ff81b64012092ae954c5d83ddd30c9fcdefd97d0b283"
+checksum = "7142797de29b35ab8dbf15c00f55fda75d409da4c423a8ab8bd6b667a785824b"
 dependencies = [
  "anyhow",
  "termcolor",
- "wasmparser 0.221.3",
+ "wasmparser 0.252.0",
 ]
 [[package]]
 name = "wasmtime"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd30973c65eceb0f37dfcc430d83abd5eb24015fdfcab6912f52949287e04f0"
+checksum = "c80ca6098e0d4d06886d91d7f2cc3cb6623eb583c4c0ab3c89cbfb6098c8586c"
 dependencies = [
- "addr2line 0.24.2",
+ "addr2line 0.26.1",
- "anyhow",
  "async-trait",
  "bitflags",
  "bumpalo",
  "cc",
  "cfg-if",
  "encoding_rs",
+ "futures",
  "fxprof-processed-profile",
- "gimli 0.31.1",
+ "gimli 0.33.0",
- "hashbrown 0.14.5",
- "indexmap",
  "ittapi",
  "libc",
- "libm",
  "log",
  "mach2",
  "memfd",
- "object 0.36.7",
+ "object 0.39.1",
  "once_cell",
- "paste",
  "postcard",
- "psm",
  "pulley-interpreter",
  "rayon",
- "rustix 0.38.44",
+ "rustix",
  "semver",
  "serde",
  "serde_derive",
  "serde_json",
  "smallvec",
- "sptr",
  "target-lexicon",
+ "tempfile",
+ "wasm-compose",
- "wasm-encoder 0.221.3",
+ "wasm-encoder 0.252.0",
- "wasmparser 0.221.3",
+ "wasmparser 0.252.0",
- "wasmtime-asm-macros",
- "wasmtime-cache",
- "wasmtime-component-macro",
- "wasmtime-component-util",
- "wasmtime-cranelift",
  "wasmtime-environ",
+ "wasmtime-internal-cache",
+ "wasmtime-internal-component-macro",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
+ "wasmtime-internal-cranelift",
- "wasmtime-fiber",
+ "wasmtime-internal-fiber",
- "wasmtime-jit-debug",
+ "wasmtime-internal-jit-debug",
- "wasmtime-jit-icache-coherence",
+ "wasmtime-internal-jit-icache-coherence",
- "wasmtime-slab",
+ "wasmtime-internal-unwinder",
- "wasmtime-versioned-export-macros",
+ "wasmtime-internal-versioned-export-macros",
- "wasmtime-winch",
  "wat",
- "windows-sys 0.59.0",
+ "windows-sys",
+ "wit-parser",
 ]
 [[package]]
-name = "wasmtime-asm-macros"
+name = "wasmtime-environ"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6c21dd30d1f3f93ee390ac1a7ec304ecdbfdab6390e1add41a1f52727b0992b"
+checksum = "134f9d136d29c76f6c1b4c9b468e97a2efc38c7d49fd188e39b64870b2fea701"
 dependencies = [
+ "anyhow",
+ "cpp_demangle",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli 0.33.0",
+ "hashbrown 0.17.1",
+ "indexmap",
- "cfg-if",
+ "log",
+ "object 0.39.1",
+ "postcard",
+ "rustc-demangle",
+ "semver",
+ "serde",
+ "serde_derive",
+ "sha2",
+ "smallvec",
+ "target-lexicon",
+ "wasm-encoder 0.252.0",
+ "wasmparser 0.252.0",
+ "wasmprinter",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
 ]
 [[package]]
-name = "wasmtime-cache"
+name = "wasmtime-internal-cache"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cabd563cfbfe75c5bf514081f624ca8d18391a37520d8c794abce702474e688c"
+checksum = "65db2eb1bfc5371a3b4107dbf539d0b93d05016fc29625b1648146b47db02071"
 dependencies = [
- "anyhow",
  "base64",
  "directories-next",
  "log",
  "postcard",
- "rustix 0.38.44",
+ "rustix",
  "serde",
  "serde_derive",
  "sha2",
  "toml",
+ "wasmtime-environ",
- "windows-sys 0.59.0",
+ "windows-sys",
  "zstd",
 ]
 [[package]]
-name = "wasmtime-component-macro"
+name = "wasmtime-internal-component-macro"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f948a6ef3119d52c9f12936970de28ddf3f9bea04bc65571f4a92d2e5ab38f4"
+checksum = "2bf7b91fed3fc34781d57f9c6654ea2513bf0a99f7b0b0523c00de1e6efebe1c"
 dependencies = [
  "anyhow",
  "proc-macro2",
  "quote",
  "syn 2.0.119",
- "wasmtime-component-util",
+ "wasmtime-internal-component-util",
- "wasmtime-wit-bindgen",
+ "wasmtime-internal-wit-bindgen",
  "wit-parser",
 ]
 [[package]]
-name = "wasmtime-component-util"
+name = "wasmtime-internal-component-util"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9275aa01ceaaa2fa6c0ecaa5267518d80b9d6e9ae7c7ea42f4c6e073e6a69ef"
+checksum = "fc8a678149885cae00289f806fbe74c7863084cf74cace0b8dc73602279400e1"
 [[package]]
-name = "wasmtime-cranelift"
+name = "wasmtime-internal-core"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0701a44a323267aae4499672dae422b266cee3135a23b640972ec8c0e10a44a2"
+checksum = "8a0092c4b9d070ac5e278b6d0db10f5e71214190f0347ca57502b4692f796321"
 dependencies = [
  "anyhow",
+ "hashbrown 0.17.1",
+ "libm",
+ "serde",
+]
+[[package]]
+name = "wasmtime-internal-cranelift"
+version = "47.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6851ebc9e03cab23d9821d2b2505d380bdfe38f35ccec945247b05274d85c98b"
+dependencies = [
  "cfg-if",
  "cranelift-codegen",
  "cranelift-control",
  "cranelift-entity",
  "cranelift-frontend",
  "cranelift-native",
- "gimli 0.31.1",
+ "gimli 0.33.0",
- "itertools 0.12.1",
+ "itertools 0.14.0",
  "log",
- "object 0.36.7",
+ "object 0.39.1",
+ "pulley-interpreter",
  "smallvec",
  "target-lexicon",
- "thiserror 1.0.69",
+ "thiserror 2.0.19",
- "wasmparser 0.221.3",
+ "wasmparser 0.252.0",
  "wasmtime-environ",
+ "wasmtime-internal-core",
+ "wasmtime-internal-unwinder",
- "wasmtime-versioned-export-macros",
+ "wasmtime-internal-versioned-export-macros",
-]
-[[package]]
-name = "wasmtime-environ"
-version = "28.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "264c968c1b81d340355ece2be0bc31a10f567ccb6ce08512c3b7d10e26f3cbe5"
-dependencies = [
- "anyhow",
- "cpp_demangle",
- "cranelift-bitset",
- "cranelift-entity",
- "gimli 0.31.1",
- "indexmap",
- "log",
- "object 0.36.7",
- "postcard",
- "rustc-demangle",
- "semver",
- "serde",
- "serde_derive",
- "smallvec",
- "target-lexicon",
- "wasm-encoder 0.221.3",
- "wasmparser 0.221.3",
- "wasmprinter",
- "wasmtime-component-util",
 ]
 [[package]]
-name = "wasmtime-fiber"
+name = "wasmtime-internal-fiber"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78505221fd5bd7b07b4e1fa2804edea49dc231e626ad6861adc8f531812973e6"
+checksum = "9b26da6d5f60d4c438da70bba3553fe810a840533a64156be287dca2081c6991"
 dependencies = [
- "anyhow",
  "cc",
  "cfg-if",
+ "libc",
- "rustix 0.38.44",
+ "rustix",
- "wasmtime-asm-macros",
+ "wasmtime-environ",
- "wasmtime-versioned-export-macros",
+ "wasmtime-internal-versioned-export-macros",
- "windows-sys 0.59.0",
+ "windows-sys",
 ]
 [[package]]
-name = "wasmtime-jit-debug"
+name = "wasmtime-internal-jit-debug"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cec0a8e5620ae71bfcaaec78e3076be5b6ebf869f4e6191925d73242224a915"
+checksum = "ed621ba25d7bf78b7edd7b4749abbb27c2e5cdba836c9504a424ee74b6c23149"
 dependencies = [
+ "cc",
- "object 0.36.7",
+ "object 0.39.1",
- "rustix 0.38.44",
+ "rustix",
- "wasmtime-versioned-export-macros",
+ "wasmtime-internal-versioned-export-macros",
 ]
 [[package]]
-name = "wasmtime-jit-icache-coherence"
+name = "wasmtime-internal-jit-icache-coherence"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bedb677ca1b549d98f95e9e1f9251b460090d99a2c196a0614228c064bf2e59"
+checksum = "5684ba160951baad06a725696f3c590e2fb0e8067c2aebee27bf7f9259058e85"
 dependencies = [
- "anyhow",
  "cfg-if",
  "libc",
+ "wasmtime-internal-core",
- "windows-sys 0.59.0",
+ "windows-sys",
 ]
 [[package]]
-name = "wasmtime-slab"
+name = "wasmtime-internal-unwinder"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "564905638c132c275d365c1fa074f0b499790568f43148d29de84ccecfb5cb31"
+checksum = "112eead527bffa8ff0646a11fb4339a9d52ddd1da2b9a6fce4aff84c815dd94f"
+dependencies = [
+ "cfg-if",
+ "cranelift-codegen",
+ "log",
+ "object 0.39.1",
+ "wasmtime-environ",
+]
 [[package]]
-name = "wasmtime-versioned-export-macros"
+name = "wasmtime-internal-versioned-export-macros"
-version = "28.0.1"
+version = "47.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e91092e6cf77390eeccee273846a9327f3e8f91c3c6280f60f37809f0e62d29"
+checksum = "153592e0bed824fc13c6696203fa1bd7bd20eb355316475e39a55f081ef80eca"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2067,29 +2116,13 @@ dependencies = [
 ]
 [[package]]
-name = "wasmtime-winch"
+name = "wasmtime-internal-wit-bindgen"
-version = "28.0.1"
+version = "47.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b111d909dc604c741bd8ac2f4af373eaa5c68c34b5717271bcb687688212cef8"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
- "gimli 0.31.1",
- "object 0.36.7",
- "target-lexicon",
- "wasmparser 0.221.3",
- "wasmtime-cranelift",
- "wasmtime-environ",
- "winch-codegen",
-]
-[[package]]
-name = "wasmtime-wit-bindgen"
-version = "28.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f38f7a5eb2f06f53fe943e7fb8bf4197f7cf279f1bc52c0ce56e9d3ffd750a4"
+checksum = "c456ad6e81e0f46abfeca43687d18ea15e289c395b262ea6e0023e2682e088be"
 dependencies = [
  "anyhow",
+ "bitflags",
  "heck",
  "indexmap",
  "wit-parser",
@@ -2149,7 +2182,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 [[package]]
@@ -2158,38 +2191,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-[[package]]
-name = "winch-codegen"
-version = "28.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6232f40a795be2ce10fc761ed3b403825126a60d12491ac556ea104a932fd18a"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
- "gimli 0.31.1",
- "regalloc2",
- "smallvec",
- "target-lexicon",
- "wasmparser 0.221.3",
- "wasmtime-cranelift",
- "wasmtime-environ",
-]
 [[package]]
 name = "windows-link"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets",
-]
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -2199,70 +2206,6 @@ dependencies = [
  "windows-link",
 ]
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 [[package]]
 name = "winnow"
 version = "0.7.15"
@@ -2272,13 +2215,20 @@ dependencies = [
  "memchr",
 ]
+[[package]]
+name = "winnow"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81"
 [[package]]
 name = "wit-parser"
-version = "0.221.3"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "896112579ed56b4a538b07a3d16e562d101ff6265c46b515ce0c701eef16b2ac"
+checksum = "4266bea110371c620ccf3201c5023676046bc4556e5c7cfb5d500bda5ebc162d"
 dependencies = [
  "anyhow",
+ "hashbrown 0.17.1",
  "id-arena",
  "indexmap",
  "log",
@@ -2286,8 +2236,8 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "unicode-xid",
+ "unicode-ident",
- "wasmparser 0.221.3",
+ "wasmparser 0.252.0",
 ]
 [[package]]

docs/superpowers/plans/2026-07-25-wasm-gc-migration.md CHANGED Viewed

@@ -36,31 +36,31 @@
 - Consumes: nothing (bottom of this plan's dependency chain).
 - Produces: every `wasmtime::Engine`/`Config` used in tests has the GC proposal enabled; a new type-section emitter that, given the checker's monomorphized `Source`, emits one wasm-gc `struct` per concrete class, one abstract-supertype-plus-per-variant-subtype set per enum (Bool included, built in exactly like the existing hardcoded `True`/`False` `EnumVariantInfo` registration), and one `array<i8>` type for `Str` — **wired up but not yet consumed by any real codegen path**, so all EXISTING tests (still running through the untouched bump-allocator codegen) stay green. This task is purely additive.
-- [ ] **Step 1: Confirm wasmtime's GC `Config` actually works empirically, first**
+- [x] **Step 1: Confirm wasmtime's GC `Config` actually works empirically, first**
 Before writing any type-emitter code, write a throwaway test (in `codegen_tests.rs`, can be deleted/replaced by Task 2) that: builds a `wasmtime::Config`, calls `.wasm_gc(true)` (and `.wasm_function_references(true)` — check by reading `wasmtime-28.0.1`'s `config.rs`, vendored at `~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wasmtime-28.0.1/src/config.rs`, whether GC has an undeclared dependency on function-references that isn't auto-enabled), constructs an `Engine` from it, and hand-encodes (via `wasm_encoder` directly, no plum involved) the smallest possible module with one GC struct type, one function that does `struct.new_default` + returns it typed as `(ref null $T)`, and confirms it validates AND instantiates+runs under that `Engine`. If this fails or exhibits a real engine limitation, that finding drives every subsequent step — report it before proceeding, don't route around it silently.
-- [ ] **Step 2: Update the test harness's `Engine`/`Config` construction**
+- [x] **Step 2: Update the test harness's `Engine`/`Config` construction**
 Read the current `Engine::default()` (or equivalent) call sites in `codegen_tests.rs` and `examples_test.rs` (search `wasmtime::Engine`) and replace with the `Config` confirmed working in Step 1. Every test in both files must still pass unchanged (they're still exercising the untouched bump-allocator codegen at this point) — this step is purely "can a GC-enabled engine still run today's non-GC output," which it should, since enabling a feature doesn't retroactively require using it.
-- [ ] **Step 3: Read the current type-registration surface before extending it**
+- [x] **Step 3: Read the current type-registration surface before extending it**
 Read `plum-checker`'s `ClassEnv`/`EnumVariants`/`EnumVariantInfo` definitions (`plum-checker/src/lib.rs`) and `plum-wasm-codegen`'s `CompileCtx`/`LocalCtx` (`plum-wasm-codegen/src/lib.rs`) exact current fields — this plan's earlier research read them as of the enum-discriminant-values plan's completion, but re-verify, since intervening work may have touched them.
-- [ ] **Step 4: Add a GC type registry, populated but unconsumed**
+- [x] **Step 4: Add a GC type registry, populated but unconsumed**
 Add a new struct (e.g. `GcTypeRegistry`) that, given the monomorphized `ast::Source` plus the existing `ClassEnv`/`EnumVariants` tables, assigns and records a wasm type-section index for: every concrete class name, every enum's abstract supertype, every enum variant's concrete subtype, and one shared `array<i8>` index for `Str`. Emit these into a real `TypeSection` via `CoreTypeEncoder::struct_`/`array`/`subtype` (structs need `SubType { is_final: false, supertype_idx: None, ... }` for a class since it needs no subtyping, but an enum's supertype needs `is_final: false` so variants CAN subtype it, and each variant subtype needs `SubType { supertype_idx: Some(super_idx), ... }`) — group the whole enum's supertype+variants in one `rec` group (`CoreTypeEncoder::rec`) since wasm-gc subtyping requires supertype and subtype to be declared in the same recursive group or supertype declared earlier in an earlier group; read `wasm-encoder`'s `rec`/`subtype` doc comments (`~/.cargo/registry/.../wasm-encoder-0.220.1/src/core/types.rs`) to get the ordering constraint exactly right. Thread the resulting index tables through `CompileCtx` as new fields (e.g. `class_type_idx: HashMap<String, u32>`, `enum_super_type_idx: HashMap<String, u32>`, `variant_type_idx: HashMap<String, u32>`, `str_type_idx: u32`), populated in `compileSource` but not read by anything else yet.
-- [ ] **Step 5: Add a corresponding Rust test proving the type section is well-formed**
+- [x] **Step 5: Add a corresponding Rust test proving the type section is well-formed**
 Add a test that compiles a small source (one class, one enum with a payload variant and a payload-free variant) through `compileSource`, and asserts the resulting bytes validate via `wasmparser::validate` under the GC-enabled config from Step 1 — this proves the new type section alone (still unused by real codegen) is well-formed, before Task 2 starts depending on it.
-- [ ] **Step 6: Run full verification**
+- [x] **Step 6: Run full verification**
 `cargo build --workspace --all-targets` then `cargo test --workspace`. Expected: 100% pass, identical results to before this task — nothing behavioral changed yet.
-- [ ] **Step 7: Commit**
+- [x] **Step 7: Commit**
 ```bash
 git add plum-wasm-codegen/src/lib.rs plum-wasm-codegen/tests/codegen_tests.rs plum-wasm-codegen/tests/examples_test.rs plum-wasm-codegen/Cargo.toml
@@ -81,105 +81,105 @@ This task is large enough that its steps are grouped by concern. Within each con
 #### 2a. Bool/enum singletons and control-flow conversion (do this first — nearly everything else depends on being able to produce/consume a Bool)
-- [ ] **Step 1: Read `compileSource`'s current initialization sequence, `compileStmt`'s `If`/`While` arms, `boolean_operator`/comparison codegen, and `assert` codegen**
+- [x] **Step 1: Read `compileSource`'s current initialization sequence, `compileStmt`'s `If`/`While` arms, `boolean_operator`/comparison codegen, and `assert` codegen**
 These are all in `plum-wasm-codegen/src/lib.rs` — find them by searching `ast::Stmt::If`, `ast::Stmt::While`, `ast::Expr::Bool(`, `ast::Expr::Compare(`, `ast::Stmt::Assert`.
-- [ ] **Step 2: Emit one global per payload-free variant across the whole program (including `True`/`False`)**
+- [x] **Step 2: Emit one global per payload-free variant across the whole program (including `True`/`False`)**
 In `compileSource`, after the type registry (Task 1) is built, walk every enum's variants (plus the built-in `Bool`) and for each payload-free one, emit a `global` (mutable: false is ideal but wasm-gc struct globals may need an initializer expression capable of `struct.new` — read `wasm_encoder`'s `ConstExpr`/`GlobalSection` to confirm whether a GC `struct.new` is legal inside a global's constant-initializer expression under this wasm-gc revision; if not, fall back to a `start` function that runs once and stores each singleton into a mutable global before `main`/any export can run). Record `variant_name -> global_index` in a new `CompileCtx` field.
-- [ ] **Step 3: Rewrite conditional control flow to convert Bool refs to i32 via `ref.test`**
+- [x] **Step 3: Rewrite conditional control flow to convert Bool refs to i32 via `ref.test`**
 Wherever a `Bool`-typed value currently feeds `Instruction::If`/`BrIf` unchanged (it's already an i32 today), insert `Instruction::RefTestNonNull(HeapType::Concrete(true_variant_type_idx))` immediately before it. This applies to at least: `if`/`else if` conditions, `while` conditions, `assert`, and short-circuit `&&`/`||` (which currently, per existing codegen, likely already lower to nested `If` blocks for short-circuiting — read the current `boolean_operator` codegen to confirm the exact shape before changing it).
-- [ ] **Step 4: Rewrite comparison operators to produce a Bool ref from a native i32 predicate**
+- [x] **Step 4: Rewrite comparison operators to produce a Bool ref from a native i32 predicate**
 Currently a comparison (`==`, `<`, etc.) directly leaves an i32 on the stack as the Bool result. Change it to: compute the native i32 predicate as today, then `Instruction::If(BlockType::Result(bool_ref_type))` / push `GlobalGet(true_singleton)` / `Else` / `GlobalGet(false_singleton)` / `End`, so the result is a proper `Bool` ref matching every other Bool-producing expression.
-- [ ] **Step 5: Update every OTHER payload-free bare-variant construction site to use its singleton global instead of allocating**
+- [x] **Step 5: Update every OTHER payload-free bare-variant construction site to use its singleton global instead of allocating**
 Search for the current handling of `ast::Expr::TypeName(n)` where `info.field_types.is_empty()` (bare tag construction) — this currently does `Instruction::I32Const(info.tag)`; change it to `Instruction::GlobalGet(singleton_idx)`.
-- [ ] **Step 6: Build and run affected tests only, iterating**
+- [x] **Step 6: Build and run affected tests only, iterating**
 `cargo build -p plum-wasm-codegen` first (fast compile-only check — expect many errors from downstream code still assuming i32 Bool/tags, which is fine, that's 2b/2c/2d's job). Do not attempt `cargo test` yet — the crate won't fully compile again until struct/enum construction (2b) and match dispatch (2d) also land, since they're mutually dependent on the same representation.
 #### 2b. Struct/class construction and field access
-- [ ] **Step 1: Read the current `ast::Expr::ClassCall` construction arm and the `Attribute`/`Field` read/write codegen**
+- [x] **Step 1: Read the current `ast::Expr::ClassCall` construction arm and the `Attribute`/`Field` read/write codegen**
 Search `ast::Expr::ClassCall`, `ast::AttrKind::Field`, `ast::AssignTarget::Field`.
-- [ ] **Step 2: Rewrite construction to `struct.new`**
+- [x] **Step 2: Rewrite construction to `struct.new`**
 For each `ClassCall`, look up the class's declared field order (not `call.fields`'s written order — construction must push values in DECLARATION order for `struct.new`). For each declared field, find the matching `call.fields` entry by name and `compileExpr` its value onto the stack; once every field's value is pushed, emit `Instruction::StructNew(class_type_idx)`. The `classcall_scratch` local is very likely no longer needed for this case (no bump-pointer bookkeeping requires holding an intermediate address — verify by reading whether anything else in the current code relies on that scratch slot for `ClassCall` specifically before deleting its allocation for this case).
-- [ ] **Step 3: Rewrite field reads to `struct.get`**
+- [x] **Step 3: Rewrite field reads to `struct.get`**
 Replace the current class-field-read arm's `emitLoad` at a byte offset with `compileExpr` (pushes the object ref) followed by `Instruction::StructGet { struct_type_index: class_type_idx, field_index }`.
-- [ ] **Step 4: Rewrite field writes (`self.x = ...`, chained `a.b.c = ...`) to `struct.set`**
+- [x] **Step 4: Rewrite field writes (`self.x = ...`, chained `a.b.c = ...`) to `struct.set`**
 Same shape: compile the object ref, compile the new value, `Instruction::StructSet { struct_type_index, field_index }`. `StructSet`'s stack order — verify from `wasm-encoder`'s encode impl or the wasm-gc spec whether it expects `(struct_ref, value)` or `(value, struct_ref)` push order; get this from the actual instruction encoding, not assumption, since getting it backwards produces a type-valid-looking-in-isolation-but-wrong-at-runtime bug that validation may not always catch depending on other stack contents.
-- [ ] **Step 5: Rewrite discriminant-enum field access (`self.n` on an `enum Foo(n: Int)`)** analogously, through `ctx.enum_params`, using `StructGet`/`StructSet` against the enum's own struct layout with the `field_idx + 1` tag-slot offset convention preserved conceptually (though the "+1 for tag" byte-offset trick is a linear-memory artifact — under wasm-gc each variant subtype simply has its own explicit field list starting at field index 0 for the first real field, no tag slot needed at all, since the tag IS the type itself now, discoverable via `ref.test`, not a stored value read at a fixed offset).
+- [x] **Step 5: Rewrite discriminant-enum field access (`self.n` on an `enum Foo(n: Int)`)** analogously, through `ctx.enum_params`, using `StructGet`/`StructSet` against the enum's own struct layout with the `field_idx + 1` tag-slot offset convention preserved conceptually (though the "+1 for tag" byte-offset trick is a linear-memory artifact — under wasm-gc each variant subtype simply has its own explicit field list starting at field index 0 for the first real field, no tag slot needed at all, since the tag IS the type itself now, discoverable via `ref.test`, not a stored value read at a fixed offset).
 #### 2c. String migration to `array<i8>`
-- [ ] **Step 1: Read the current string literal encoding, `registerStringConcatHelper`, `registerIntToStringHelper`, and string interpolation codegen**
+- [x] **Step 1: Read the current string literal encoding, `registerStringConcatHelper`, `registerIntToStringHelper`, and string interpolation codegen**
 Search `compile_static_string` (or equivalent), `registerStringConcatHelper`, `registerIntToStringHelper`.
-- [ ] **Step 2: Static string literals become passive-data-segment `array.new_data`**
+- [x] **Step 2: Static string literals become passive-data-segment `array.new_data`**
 Each string literal's bytes go into one passive `DataSection::passive(bytes)` segment (no active memory offset — confirm `wasm_encoder`'s `DataSection::passive` doesn't require a preceding memory section to exist at all, per this plan's Decision 4). At the literal's use site, emit `Instruction::ArrayNewData { array_type_index: str_type_idx, array_data_index }`.
-- [ ] **Step 3: Rewrite `registerStringConcatHelper` against `array.new`/`array.copy`**
+- [x] **Step 3: Rewrite `registerStringConcatHelper` against `array.new`/`array.copy`**
 Read the exact current helper body first. The new version needs the combined length (`array.len` on both inputs, or track lengths already known from a length-prefix design if you keep one — decide whether `Str`'s `array<i8>` needs an explicit stored length or relies on `array.len`, and note that GC arrays DO track their own length natively, so a manual length prefix is no longer needed at all, simplifying this over the current length-prefixed-blob design), allocates a new array of that combined size (`array.new_default` sized dynamically — check whether `array.new_default` accepts a non-constant size operand; it does, per the wasm-gc spec, size is a runtime i32 operand), then two `Instruction::ArrayCopy { array_type_index_dst, array_type_index_src }` calls to copy each source's bytes into the destination at the right offset.
-- [ ] **Step 4: Rewrite `registerIntToStringHelper` similarly** — read its current byte-writing loop and adapt each byte store to `array.set` (or build into a fixed-size scratch and `array.new_data`-style copy, whichever the current algorithm's shape most directly maps to).
+- [x] **Step 4: Rewrite `registerIntToStringHelper` similarly** — read its current byte-writing loop and adapt each byte store to `array.set` (or build into a fixed-size scratch and `array.new_data`-style copy, whichever the current algorithm's shape most directly maps to).
-- [ ] **Step 5: Update string interpolation codegen** to call the rewritten helpers; verify `Str`-typed class/enum fields (now `ref null $StrArray` instead of i32) round-trip correctly through 2b/2d's `struct.get`/`struct.set` and `ref.test`/variant-subtype field lists.
+- [x] **Step 5: Update string interpolation codegen** to call the rewritten helpers; verify `Str`-typed class/enum fields (now `ref null $StrArray` instead of i32) round-trip correctly through 2b/2d's `struct.get`/`struct.set` and `ref.test`/variant-subtype field lists.
 #### 2d. Match dispatch via `ref.test`/`br_on_cast`
-- [ ] **Step 1: Read `compileMatch`, `compileMatchArmsMulti`, `compileCasePositions`, `compileVariantEqArm` (or its current name — it may have been renamed during the camelCase pass), `compileVariantConstructorArm`, and `compileFieldPatterns` in full before changing any of them** — this is the most intricate part of the existing codegen (recursive multi-subject, multi-position, nested-constructor-pattern dispatch) and the part most likely to have subtle behavioral requirements not obvious from a partial read.
+- [x] **Step 1: Read `compileMatch`, `compileMatchArmsMulti`, `compileCasePositions`, `compileVariantEqArm` (or its current name — it may have been renamed during the camelCase pass), `compileVariantConstructorArm`, and `compileFieldPatterns` in full before changing any of them** — this is the most intricate part of the existing codegen (recursive multi-subject, multi-position, nested-constructor-pattern dispatch) and the part most likely to have subtle behavioral requirements not obvious from a partial read.
-- [ ] **Step 2: Replace the `HEAP_BASE` range-check + tag-load-and-compare pattern with `ref.test`**
+- [x] **Step 2: Replace the `HEAP_BASE` range-check + tag-load-and-compare pattern with `ref.test`**
 Every place that currently does "range-check against `HEAP_BASE`, then conditionally load+compare a tag" (both the top-level bare-Name/Class-pattern arms and the nested `compileFieldPatterns` equivalents) becomes a single `Instruction::RefTestNonNull(HeapType::Concrete(variant_type_idx))` (or `RefTestNullable` if the value can legitimately be null in context — decide per call site) directly on the subject ref, producing the same "did this match" i32 the existing `If`/`Else` structure around it already expects — the surrounding control-flow shape (fall through to `compileMatchArmsMulti(rest, ...)` on mismatch) doesn't need to change, only how the boolean test itself is computed.
-- [ ] **Step 3: Replace payload-field extraction with `ref.cast` + `struct.get`**
+- [x] **Step 3: Replace payload-field extraction with `ref.cast` + `struct.get`**
 Where a matched constructor pattern currently loads a field via `emitLoad(field_vt, offset)` from the raw pointer, first `Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))` (narrowing the statically-typed-as-supertype subject to its concrete variant subtype — the match arm's binding scope is exactly where this narrowing is valid) then `Instruction::StructGet { struct_type_index: variant_type_idx, field_index }`.
-- [ ] **Step 4: Consider (but don't require) using `br_on_cast` for the top-level dispatch chain** — the spec's Components section suggests `ref.test`/`br_on_cast` as the replacement mechanism; a straightforward `ref.test` + `if/else` chain (mirroring today's control-flow shape exactly, per Step 2) is very likely simpler to get right than restructuring into `br_on_cast`'s branch-table-like shape, and is equally correct. Only reach for `br_on_cast` if the `if/else` chain form turns out to hit a real wasm-gc validation or structural limitation — don't restructure working control flow for its own sake.
+- [x] **Step 4: Consider (but don't require) using `br_on_cast` for the top-level dispatch chain** — the spec's Components section suggests `ref.test`/`br_on_cast` as the replacement mechanism; a straightforward `ref.test` + `if/else` chain (mirroring today's control-flow shape exactly, per Step 2) is very likely simpler to get right than restructuring into `br_on_cast`'s branch-table-like shape, and is equally correct. Only reach for `br_on_cast` if the `if/else` chain form turns out to hit a real wasm-gc validation or structural limitation — don't restructure working control flow for its own sake.
 #### 2e. Closures
-- [ ] **Step 1: Read `compileClosureLiteral`, `compileClosureCall`, `compileClosureBody`, and the `Collector`'s closure-discovery pass in full.**
+- [x] **Step 1: Read `compileClosureLiteral`, `compileClosureCall`, `compileClosureBody`, and the `Collector`'s closure-discovery pass in full.**
-- [ ] **Step 2: Give every closure literal its own env `struct` type**, one field per captured variable in `free_vars` order, field types matching each captured variable's own type (which may itself now be a `ref` type post-2b/2c). Register these in the type registry alongside classes/enums.
+- [x] **Step 2: Give every closure literal its own env `struct` type**, one field per captured variable in `free_vars` order, field types matching each captured variable's own type (which may itself now be a `ref` type post-2b/2c). Register these in the type registry alongside classes/enums.
-- [ ] **Step 3: Rewrite `compileClosureLiteral`**: build the env via `struct.new` (pushing each captured local's current value, per Decision 3 — snapshot-by-value semantics are unchanged, only the allocation mechanism changes), then build the 2-field closure struct `{i32 table_index, anyref env}` via `struct.new`, casting/widening the concrete env ref to `anyref` for storage (a supertype widening — confirm whether `wasm-encoder`/wasm-gc requires an explicit instruction for this or whether it's implicit at the type-checking level when a subtype value is used where a supertype/`anyref` is expected; if implicit, no extra instruction is needed).
+- [x] **Step 3: Rewrite `compileClosureLiteral`**: build the env via `struct.new` (pushing each captured local's current value, per Decision 3 — snapshot-by-value semantics are unchanged, only the allocation mechanism changes), then build the 2-field closure struct `{i32 table_index, anyref env}` via `struct.new`, casting/widening the concrete env ref to `anyref` for storage (a supertype widening — confirm whether `wasm-encoder`/wasm-gc requires an explicit instruction for this or whether it's implicit at the type-checking level when a subtype value is used where a supertype/`anyref` is expected; if implicit, no extra instruction is needed).
-- [ ] **Step 4: Rewrite `compileClosureBody`**: its first instructions must `RefCastNonNull` (or the nullable variant, matching the declared param type) the incoming `anyref` env parameter down to `(ref $ThisClosuresEnvType)` before any captured-field reads, then use `struct.get` for each.
+- [x] **Step 4: Rewrite `compileClosureBody`**: its first instructions must `RefCastNonNull` (or the nullable variant, matching the declared param type) the incoming `anyref` env parameter down to `(ref $ThisClosuresEnvType)` before any captured-field reads, then use `struct.get` for each.
-- [ ] **Step 5: Update the shared `call_indirect` function-type signatures** (`fnParamTypeToWasmSig`/`ClosureSigKey` and wherever `call_indirect` types are registered/deduped) so the env-pointer parameter position is `ValType::Ref(RefType::ANYREF)` instead of `ValType::I32`, everywhere this shape is constructed.
+- [x] **Step 5: Update the shared `call_indirect` function-type signatures** (`fnParamTypeToWasmSig`/`ClosureSigKey` and wherever `call_indirect` types are registered/deduped) so the env-pointer parameter position is `ValType::Ref(RefType::ANYREF)` instead of `ValType::I32`, everywhere this shape is constructed.
 #### 2f. Retire the bump allocator entirely
-- [ ] **Step 1: Remove `HEAP_BASE`, `STRING_BASE`, `bump_global` (the field, its threading through `CompileCtx`/`LocalCtx`, and its initialization in `compileSource`), and the `addMemory`/memory-section code in `WasmModule::finish`** once `cargo build -p plum-wasm-codegen` shows nothing references them anymore. If anything still does, that's a sign an earlier 2a–2e step was missed or incomplete — go back, don't leave a partial bump-allocator fallback path.
-- [ ] **Step 2: Remove now-dead scratch-slot bookkeeping** (`classcall_scratch` etc., in `Collector` and `LocalCtx`) for any use case fully replaced by direct stack-order `struct.new` construction (per 2b Step 2) — but only what's actually provably dead; `match`'s subject-holding scratch locals are still needed (now typed as `ref null` instead of `i32`), don't remove those.
+- [x] **Step 1: Remove `HEAP_BASE`, `STRING_BASE`, `bump_global` (the field, its threading through `CompileCtx`/`LocalCtx`, and its initialization in `compileSource`), and the `addMemory`/memory-section code in `WasmModule::finish`** once `cargo build -p plum-wasm-codegen` shows nothing references them anymore. If anything still does, that's a sign an earlier 2a–2e step was missed or incomplete — go back, don't leave a partial bump-allocator fallback path.
+- [x] **Step 2: Remove now-dead scratch-slot bookkeeping** (`classcall_scratch` etc., in `Collector` and `LocalCtx`) for any use case fully replaced by direct stack-order `struct.new` construction (per 2b Step 2) — but only what's actually provably dead; `match`'s subject-holding scratch locals are still needed (now typed as `ref null` instead of `i32`), don't remove those.
 #### 2g. Full verification for Task 2
-- [ ] **Step 1: `cargo build --workspace --all-targets`** — iterate until clean.
-- [ ] **Step 2: Update every existing `codegen_tests.rs`/`examples_test.rs` test that encoded assumptions about the old representation** (e.g. anything asserting raw byte layout, or relying on `HEAP_BASE`-adjacent behavior) — re-verify each still asserts the right OBSERVABLE behavior (a program's computed result), not the old mechanism.
-- [ ] **Step 3: `cargo test --workspace`** — expected: 100% pass. This is the real gate for this entire task; do not commit Task 2 before this is green.
-- [ ] **Step 4: Commit**
+- [x] **Step 1: `cargo build --workspace --all-targets`** — iterate until clean.
+- [x] **Step 2: Update every existing `codegen_tests.rs`/`examples_test.rs` test that encoded assumptions about the old representation** (e.g. anything asserting raw byte layout, or relying on `HEAP_BASE`-adjacent behavior) — re-verify each still asserts the right OBSERVABLE behavior (a program's computed result), not the old mechanism.
+- [x] **Step 3: `cargo test --workspace`** — expected: 100% pass. This is the real gate for this entire task; do not commit Task 2 before this is green.
+- [x] **Step 4: Commit**
 ```bash
 git add plum-wasm-codegen/src plum-wasm-codegen/tests

plum-wasm-codegen/Cargo.toml CHANGED Viewed

@@ -12,4 +12,4 @@ plum-checker = { path = "../plum-checker" }
 wasmparser = "0.220"
 tree-sitter = "0.26"
 tree-sitter-plum = { path = "../tooling/tree-sitter-plum" }
-wasmtime = "28"
+wasmtime = "47"

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -9,12 +9,6 @@ use plum_core::ast;
 use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
 use plum_checker::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo, EnumParams};
-/// Bump-allocated heap for class instances starts at the second 64KiB page so it can
-/// never collide with the (small, compile-time-sized) string literal data area below it.
-const HEAP_BASE: u32 = 65536;
-/// String literal data (length-prefixed UTF-8 blobs) is laid out from here upward.
-const STRING_BASE: u32 = 8;
 /// One entry in the module's type section. Wasm's type section is a SINGLE shared
 /// index space for function types AND (once wasm-gc is in play) composite
 /// struct/array types — `Rec` entries occupy as many consecutive indices as they
@@ -28,6 +22,14 @@ enum TypeEntry {
     Rec(Vec<SubType>),
 }
+/// One entry in the module's data section. Like the type section, data segments
+/// share ONE index space regardless of kind — a `Passive` segment's index (needed by
+/// `array.new_data`) is its position among ALL segments, active or passive.
+enum DataSegmentEntry {
+    Active(u32, Vec<u8>),
+    Passive(Vec<u8>),
+}
 pub struct WasmModule {
     types: Vec<TypeEntry>,
     /// Running count of type-section INDICES assigned so far — NOT the same as
@@ -37,15 +39,15 @@ pub struct WasmModule {
     imports: Vec<(String, String, u32)>,
     functions: Vec<(u32, Vec<u8>)>,
     exports: Vec<(String, ExportKind, u32)>,
-    memories: Vec<MemoryType>,
     globals: Vec<(ValType, bool, Vec<u8>)>,
-    data_segments: Vec<(u32, Vec<u8>)>,
+    data_segments: Vec<DataSegmentEntry>,
     /// Function indices, in table order — the single funcref table used for
     /// closure `call_indirect` dispatch. Index into this vec IS the table index.
     table_elements: Vec<u32>,
     pub func_import_count: u32,
     pub func_count: u32,
     global_count: u32,
+    start_function: Option<u32>,
 }
 impl WasmModule {
@@ -56,13 +58,13 @@ impl WasmModule {
             imports: Vec::new(),
             functions: Vec::new(),
             exports: Vec::new(),
-            memories: Vec::new(),
             globals: Vec::new(),
             data_segments: Vec::new(),
             table_elements: Vec::new(),
             func_import_count: 0,
             func_count: 0,
             global_count: 0,
+            start_function: None,
         }
     }
@@ -105,18 +107,6 @@ impl WasmModule {
         self.exports.push((name.to_string(), kind, idx));
     }
-    pub fn addMemory(&mut self, min: u64, max: Option<u64>) -> u32 {
-        let idx = self.memories.len() as u32;
-        self.memories.push(MemoryType {
-            minimum: min,
-            maximum: max,
-            memory64: false,
-            shared: false,
-            page_size_log2: None,
-        });
-        idx
-    }
     pub fn addGlobal(&mut self, val_type: ValType, mutable: bool, init: &[u8]) -> u32 {
         let idx = self.global_count;
         self.globals.push((val_type, mutable, init.to_vec()));
@@ -125,7 +115,27 @@ impl WasmModule {
     }
     pub fn addDataSegment(&mut self, offset: u32, data: &[u8]) {
-        self.data_segments.push((offset, data.to_vec()));
+        self.data_segments.push(DataSegmentEntry::Active(offset, data.to_vec()));
+    }
+    /// Adds a passive segment (no implicit memory-init offset) and returns its index
+    /// in the shared active/passive data-segment index space — the index `array.new_data`
+    /// needs to reference it. Passive segments require a `DataCountSection` (see `finish`).
+    pub fn addPassiveDataSegment(&mut self, data: &[u8]) -> u32 {
+        let idx = self.data_segments.len() as u32;
+        self.data_segments.push(DataSegmentEntry::Passive(data.to_vec()));
+        idx
+    }
+    /// Registers `func_idx` to run once automatically at instantiation, before any
+    /// export is callable — needed because `struct.new` (and therefore constructing
+    /// any GC singleton, like the pre-allocated payload-free enum variants) is not
+    /// allowed inside a `global`'s own const-expr initializer (confirmed empirically
+    /// in Task 1 — `wasmtimeGcConfigAllowsStructNewInGlobalConstExpr` fails), so those
+    /// globals are declared `mutable` with a `ref.null` initial value and populated
+    /// here instead.
+    pub fn setStartFunction(&mut self, func_idx: u32) {
+        self.start_function = Some(func_idx);
     }
     /// Registers `func_idx` as the next slot in the single funcref table used for
@@ -184,15 +194,6 @@ impl WasmModule {
             module.section(&tables);
         }
-        // Memory section
-        if !self.memories.is_empty() {
-            let mut mem = MemorySection::new();
-            for mt in &self.memories {
-                mem.memory(*mt);
-            }
-            module.section(&mem);
-        }
         // Global section
         if !self.globals.is_empty() {
             let mut globals = GlobalSection::new();
@@ -215,6 +216,11 @@ impl WasmModule {
             module.section(&exports);
         }
+        // Start section
+        if let Some(func_idx) = self.start_function {
+            module.section(&StartSection { function_index: func_idx });
+        }
         // Element section
         if !self.table_elements.is_empty() {
             let mut elements = ElementSection::new();
@@ -223,6 +229,13 @@ impl WasmModule {
             module.section(&elements);
         }
+        // DataCount section — required whenever `array.new_data`/`data.drop` reference
+        // a passive segment, and must appear before the code section.
+        let has_passive = self.data_segments.iter().any(|e| matches!(e, DataSegmentEntry::Passive(_)));
+        if has_passive {
+            module.section(&DataCountSection { count: self.data_segments.len() as u32 });
+        }
         // Code section
         if !self.functions.is_empty() {
             let mut code = CodeSection::new();
@@ -235,9 +248,16 @@ impl WasmModule {
         // Data section
         if !self.data_segments.is_empty() {
             let mut data = DataSection::new();
-            for (offset, bytes) in &self.data_segments {
+            for entry in &self.data_segments {
+                match entry {
+                    DataSegmentEntry::Active(offset, bytes) => {
-                let offset_expr = ConstExpr::i32_const(*offset as i32);
+                        let offset_expr = ConstExpr::i32_const(*offset as i32);
-                data.active(0, &offset_expr, bytes.iter().copied());
+                        data.active(0, &offset_expr, bytes.iter().copied());
+                    }
+                    DataSegmentEntry::Passive(bytes) => {
+                        data.passive(bytes.iter().copied());
+                    }
+                }
             }
             module.section(&data);
         }
@@ -260,15 +280,20 @@ pub struct FuncSig {
 /// Everything codegen needs to know about one closure *literal* found in the program.
 /// wasm has no native closures: each literal `|v| body` becomes its own real wasm
-/// function (registered in the funcref table), and a closure *value* is a single i32
+/// function (registered in the funcref table), and a closure *value* is a `ref` to
-/// pointer to a heap pair `{table_index: i32 @0, env_pointer: i32 @8}`. The env is a
+/// the shared `{table_idx: i32, env: anyref}` struct (`GcTypeRegistry::closure_type_idx`).
+/// `env` is a `ref.cast` of this closure literal's OWN env struct type
-/// separate heap allocation: one 8-byte slot per captured (free) variable, in
+/// (`env_type_idx`), one field per captured (free) variable in `free_vars` order.
-/// `free_vars` order.
 pub struct ClosureInfo {
     /// Reserved wasm function index for this closure's compiled body.
     pub func_idx: u32,
-    /// Index of `func_idx` in the funcref table (the `i32` stored at struct offset 0).
+    /// Index of `func_idx` in the funcref table (the `i32` stored in the closure
+    /// struct's `table_idx` field).
     pub table_idx: u32,
+    /// This closure literal's own env struct type index (fields = `free_vars`, in
+    /// order) — assigned once all closures are discovered, alongside every other
+    /// closure's env type and the shared closure-value struct, in one `rec` group.
+    pub env_type_idx: u32,
     /// Closure param val types (NOT including the implicit leading env pointer).
     pub param_vts: Vec<ValType>,
     /// Closure param plum types (for the closure body's own type env).
@@ -276,7 +301,7 @@ pub struct ClosureInfo {
     /// Closure return val type (`None` for a `Unit`-returning closure).
     pub ret_vt: Option<ValType>,
     /// Free variables captured by value, in a stable (first-appearance) order; the
-    /// index into this vec IS the variable's env-struct slot (offset = idx * 8).
+    /// index into this vec IS the variable's field index in the env struct.
     pub free_vars: Vec<(String, PlumType)>,
 }
@@ -293,7 +318,6 @@ pub struct CompileCtx<'a> {
     pub enum_variants: EnumVariants,
     pub enum_params: EnumParams,
     pub global_env: TypeEnv,
-    pub bump_global: u32,
     /// Closure literal (keyed by `&Expr::Closure` pointer identity) -> its `ClosureInfo`.
     pub closures: HashMap<usize, ClosureInfo>,
     /// The AST of each discovered closure literal, keyed the same way, so its body can
@@ -301,48 +325,42 @@ pub struct CompileCtx<'a> {
     pub closure_asts: HashMap<usize, &'a ast::Closure>,
     /// Closure wasm signature -> function-type index, for `call_indirect` at call sites.
     pub closure_call_types: HashMap<ClosureSigKey, u32>,
-    /// Top-level function name -> static data offset of its zero-capture "trampoline"
+    /// Top-level function name -> global index holding its zero-capture "trampoline"
-    /// closure struct `{table_idx, env_ptr=0}`, for using a plain named function
+    /// closure struct `{table_idx, env=null}`, for using a plain named function
     /// wherever a `fn(...)`-typed value is expected (e.g. `each(double)`). Since the
-    /// struct has no captures it never changes, so it's baked into a data segment
+    /// struct has no captures it never changes, so it's built once by the shared
-    /// once at compile time instead of being bump-allocated per reference.
+    /// `start` function instead of being reconstructed per reference.
     pub named_fn_values: HashMap<String, u32>,
-    /// Shared runtime helper `(a: i32, b: i32) -> i32`: bump-allocates a new
+    /// Shared runtime helper `(a: ref Str, b: ref Str) -> ref Str`: allocates a new
-    /// length-prefixed string exactly long enough to hold `a`'s bytes followed by
+    /// `array<i8>` exactly long enough to hold `a`'s bytes followed by `b`'s, for
-    /// `b`'s, for lowering string interpolation (`"{expr}"`).
+    /// lowering string interpolation (`"{expr}"`).
     pub string_concat_func: u32,
-    /// Shared runtime helper `(n: i64) -> i32`: bump-allocates a new length-prefixed
+    /// Shared runtime helper `(n: i64) -> ref Str`: allocates a new `array<i8>`
-    /// string holding `n`'s decimal representation, for interpolating an `Int`.
+    /// holding `n`'s decimal representation, for interpolating an `Int`.
     pub int_to_string_func: u32,
-    /// wasm-gc type-section indices for this program's classes/enums/Str (Task 1 of
+    /// wasm-gc type-section indices for this program's classes/enums/Str/closures —
-    /// docs/superpowers/plans/2026-07-25-wasm-gc-migration.md) — populated but not
+    /// every value's real representation (see `docs/superpowers/plans/2026-07-25-wasm-gc-migration.md`).
-    /// yet consumed by any codegen below; the bump allocator remains the real
-    /// representation until Task 2 lands.
     pub gc_types: GcTypeRegistry,
+    /// Payload-free variant name (True/False/None/...) -> the global index holding
+    /// its one pre-allocated instance (see this migration plan's Decision 2).
+    pub singleton_globals: HashMap<String, u32>,
 }
-/// Per-module state that accumulates as function bodies are compiled: the running
+/// Per-module state that accumulates as function bodies are compiled: every static
+/// string literal's bytes, staged here (rather than added straight to `WasmModule`)
+/// so `compileStaticString` can know a segment's final passive-data-section index —
-/// offset for placing string literal bytes, and the resulting data segments.
+/// its position among ALL staged segments — before that section is actually
+/// assembled at the end of `compileSource`.
 struct ModuleState {
-    next_string_offset: u32,
-    data_segments: Vec<(u32, Vec<u8>)>,
+    passive_segments: Vec<Vec<u8>>,
 }
 struct LocalCtx<'a> {
     locals: HashMap<String, u32>,
-    /// First local index reserved for `ClassCall` scratch temporaries.
-    classcall_scratch_base: u32,
-    /// `ClassCall` expr identity (pointer address) -> scratch slot offset.
-    classcall_scratch: HashMap<usize, u32>,
     /// First local index reserved for `match` subject scratch temporaries.
     match_scratch_base: u32,
     /// `Match` stmt identity (pointer address) -> scratch slot offset.
     match_scratch_index: HashMap<usize, u32>,
-    /// First local index reserved for closure-construction scratch temporaries; each
-    /// closure literal uses two consecutive slots (env struct ptr, closure struct ptr).
-    closure_scratch_base: u32,
-    /// `Closure` expr identity (pointer address) -> offset of its first (of two) slots.
-    closure_scratch: HashMap<usize, u32>,
     /// First local index reserved for nested-constructor-pattern scratch temporaries
     /// (`Some(Some(v))`'s inner `Some(v)`); the outermost pattern uses a
     /// `match_scratch` slot instead, so this only covers depth >= 1.
@@ -366,6 +384,8 @@ struct LocalCtx<'a> {
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
+    gc_types: &'a GcTypeRegistry,
+    singleton_globals: &'a HashMap<String, u32>,
     /// Tracks each binding's inferred type as compilation proceeds through
     /// statements in order, mirroring `plum-checker`'s own env evolution — needed
     /// to resolve `Attribute`/`ClassCall` targets and pick the right load/store width.
@@ -379,7 +399,6 @@ struct LocalCtx<'a> {
     /// and would fall back to its old TVar-defaults-to-Int behavior, disagreeing
     /// with the (now correct) signature the closure's body was actually compiled with.
     closure_local_sigs: RefCell<HashMap<String, ClosureSigKey>>,
-    bump_global: u32,
 }
 fn fnKey(f: &ast::Fn) -> String {
@@ -399,36 +418,77 @@ fn paramTypeName(pt: &ast::ParamType) -> &str {
     }
 }
+thread_local! {
+    /// The current `compileSource` call's wasm-gc type registry. `compileSource` is
+    /// the sole entry point and is never re-entrant/concurrent within one thread, so
+    /// a thread-local avoids threading an explicit `&GcTypeRegistry` parameter through
+    /// every one of `plumTypeToValtype`/`astTypeToWasm`'s ~25 call sites (many several
+    /// functions removed from anywhere a `CompileCtx`/`LocalCtx` is in scope, e.g.
+    /// function-signature registration that runs before any `LocalCtx` exists). Set
+    /// once near the top of `compileSource`, before anything below reads it.
+    static CURRENT_GC_TYPES: RefCell<Option<GcTypeRegistry>> = const { RefCell::new(None) };
+}
+fn withGcTypes<R>(f: impl FnOnce(&GcTypeRegistry) -> R) -> R {
+    CURRENT_GC_TYPES.with(|c| {
+        let borrow = c.borrow();
+        let registry = borrow.as_ref().expect("internal codegen error: GC type registry read before compileSource initialized it");
+        f(registry)
+    })
+}
+/// Resolves an `ast::Type`/`ast::ParamType`'s bare name (e.g. from a function
+/// signature, before any `PlumType`/checker involvement) to its wasm-gc `ValType`.
 fn astTypeToWasm(name: &str) -> Option<ValType> {
     match name {
         "Int" => Some(ValType::I64),
         "Float" => Some(ValType::F64),
-        "Bool" => Some(ValType::I32),
-        "Str" => Some(ValType::I32),
         "Unit" => None,
+        "Bool" => Some(plumTypeToValtype(&PlumType::TBool)),
+        "Str" => Some(plumTypeToValtype(&PlumType::TStr)),
-        _ => Some(ValType::I32), // class instance / unmodeled type: pointer
+        other => Some(plumTypeToValtype(&PlumType::TNamed(other.to_string()))),
     }
 }
+/// A `ref null $Ty` — every heap value (class instance, enum/Bool variant, Str
+/// array, closure struct) is nullable-by-convention, matching how a bump-allocator
+/// i32 pointer could be "null" (0) too; nothing in this codegen currently relies on
+/// non-nullable refs for an optimization, so nullable everywhere keeps this simple.
+fn gcRef(idx: u32) -> ValType {
+    ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(idx) })
+}
 fn plumTypeToValtype(t: &PlumType) -> ValType {
     match t {
         PlumType::TInt => ValType::I64,
         PlumType::TFloat => ValType::F64,
+        PlumType::TBool => withGcTypes(|r| gcRef(*r.enum_super_type_idx.get("Bool").expect("Bool must be registered"))),
+        PlumType::TStr => withGcTypes(|r| gcRef(r.str_type_idx)),
+        PlumType::TNamed(name) => withGcTypes(|r| {
+            match r.class_type_idx.get(name).or_else(|| r.enum_super_type_idx.get(name)) {
+                Some(idx) => gcRef(*idx),
+                // Genuinely unmodeled type name (not a real class/enum) — permissive
+                // fallback, matching this function's pre-wasm-gc "unmodeled type:
+                // pointer" behavior; codegen sites that actually need a concrete
+                // struct type still resolve it themselves and error clearly if absent.
+                None => ValType::Ref(RefType::ANYREF),
+            }
+        }),
-        // A closure value is a single i32 pointer to its heap-allocated
+        // A closure value is a 2-field `{table_index: i32, env: anyref}` struct —
+        // its OWN concrete GC type, registered per Task 2e (closures), not through
-        // `{table_index, env_pointer}` pair, so `TFun` is an i32 like every other
+        // this general resolver; `anyref` here is a safe placeholder used only
+        // where a closure's exact struct type isn't being constructed/destructured
+        // directly (e.g. deciding a local's storage class), matching `TVariadic`'s
-        // heap reference (`TBool`/`TStr`/`TNamed`).
+        // existing "not modeled as a concrete shape here" treatment.
-        PlumType::TBool | PlumType::TStr | PlumType::TNamed(_) | PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::I32,
+        PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
         PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
     }
 }
 /// Type-section indices for every wasm-gc composite type this program's monomorphized
 /// classes/enums/`Str` need. Populated once in `compileSource` from the checker's
-/// global tables. Per Task 1 of docs/superpowers/plans/2026-07-25-wasm-gc-migration.md,
-/// this is currently populated but NOT YET consumed by construction/field-access/match
-/// codegen (that's Task 2) — its job right now is only to prove the type section itself
-/// is well-formed under the new representation, alongside the still-untouched
-/// bump-allocator codegen path.
+/// global tables.
+#[derive(Clone)]
 pub struct GcTypeRegistry {
     /// Concrete class/struct name -> its one wasm-gc `struct` type index.
     pub class_type_idx: HashMap<String, u32>,
@@ -442,6 +502,16 @@ pub struct GcTypeRegistry {
     pub variant_type_idx: HashMap<String, u32>,
     /// The single shared `array<i8>` type index every `Str` value uses.
     pub str_type_idx: u32,
+    /// The single shared closure-value struct type index — `{table_idx: i32, env:
+    /// anyref}` — every closure (and zero-capture "trampoline") uses regardless of
+    /// its own captures; only assigned once closures are discovered (see
+    /// `compileSource`), so `0` until then (nothing reads it earlier).
+    pub closure_type_idx: u32,
+    /// Wasm value type -> the shared `array<T>` type index used to pass a `...T`
+    /// variadic argument pack as one GC array (replacing the old bump-allocated
+    /// `[count][elem...]` blob — `array.len` replaces the explicit count). Populated
+    /// alongside `closure_type_idx`, from every `ParamType::Variadic` in the program.
+    pub variadic_array_type_idx: HashMap<ValType, u32>,
 }
 /// Resolves a plum type to the wasm-gc `ValType` its values are represented as, given
@@ -484,11 +554,12 @@ fn buildGcTypeRegistry(
     source: &ast::Source,
     classes: &ClassEnv,
     enum_variants: &EnumVariants,
+    enum_params: &EnumParams,
 ) -> GcTypeRegistry {
     enum Slot {
         Str,
         Class(String),
-        EnumSuper,
+        EnumSuper(String),
         Variant(String),
     }
@@ -519,7 +590,7 @@ fn buildGcTypeRegistry(
     }
     for (enum_name, variant_names) in &enum_decls {
         enum_super_type_idx.insert(enum_name.clone(), slots.len() as u32);
-        slots.push(Slot::EnumSuper);
+        slots.push(Slot::EnumSuper(enum_name.clone()));
         for vname in variant_names {
             variant_type_idx.insert(vname.clone(), slots.len() as u32);
             slots.push(Slot::Variant(vname.clone()));
@@ -534,6 +605,8 @@ fn buildGcTypeRegistry(
         enum_super_type_idx,
         variant_type_idx,
         str_type_idx: 0,
+        closure_type_idx: 0,
+        variadic_array_type_idx: HashMap::new(),
     };
     // Pass 2: build the real SubType for every slot, now that every cross-reference
@@ -559,16 +632,36 @@ fn buildGcTypeRegistry(
                 composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: field_types.into() }), shared: false },
             }
         }
+        // An ORDINARY enum's supertype declares zero fields (each variant adds its
+        // own distinct payload fields below it). A DISCRIMINANT enum (`enum
+        // Foo(n: Int) = ...`) is different: every variant shares the EXACT SAME
+        // field list (`plum-checker::buildGlobalTables` already gives every variant
+        // of such an enum identical `field_types`, equal to the shared params), so
+        // the supertype declares those fields directly — this is what lets `self.n`
+        // field access work on the plain supertype-typed reference with a
+        // `struct.get`, no `ref.cast` to one arbitrary variant required (which would
+        // trap at runtime whenever `self` isn't actually THAT variant).
-        Slot::EnumSuper => SubType {
+        Slot::EnumSuper(enum_name) => {
+            let params = enum_params.get(enum_name).cloned().unwrap_or_default();
+            let field_types: Vec<FieldType> = params.iter().map(|(_, ty)| FieldType {
+                element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
+                mutable: false,
+            }).collect();
+            SubType {
-            is_final: false,
+                is_final: false,
-            supertype_idx: None,
+                supertype_idx: None,
-            composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: Vec::new().into() }), shared: false },
+                composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: field_types.into() }), shared: false },
-        },
+            }
+        }
         Slot::Variant(vname) => {
             let info = enum_variants.get(vname)
                 .unwrap_or_else(|| panic!("internal codegen error: variant '{}' missing from EnumVariants", vname));
             let super_idx = *registry.enum_super_type_idx.get(&info.enum_name)
                 .unwrap_or_else(|| panic!("internal codegen error: enum '{}' missing its supertype slot", info.enum_name));
+            // For a discriminant enum, `info.field_types` is ALREADY identical to the
+            // supertype's own fields (see the `EnumSuper` arm above) — a variant with
+            // zero ADDED fields beyond its supertype is still valid wasm-gc
+            // subtyping, so no special-casing is needed here.
             let field_types: Vec<FieldType> = info.field_types.iter().map(|ty| FieldType {
                 element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
                 mutable: false,
@@ -587,10 +680,10 @@ fn buildGcTypeRegistry(
 }
 /// Maps an `ast::ParamType::Fn(params, ret)` to the wasm signature of the *closure
-/// function* it compiles to: an implicit leading `env_ptr: I32`, then one param per
+/// function* it compiles to: an implicit leading `env: anyref`, then one param per
 /// declared param type, returning `ret`'s val type (or nothing for `Unit`).
 fn fnParamTypeToWasmSig(params: &[ast::Type], ret: &Option<Box<ast::Type>>) -> (Vec<ValType>, Option<ValType>) {
-    let mut vts = vec![ValType::I32]; // env pointer
+    let mut vts = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
     for p in params {
         vts.push(astTypeToWasm(&p.name).unwrap_or(ValType::I32));
     }
@@ -641,17 +734,71 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
     let (global_env, classes, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let mut module = WasmModule::new();
+    let mut gc_types = buildGcTypeRegistry(&mut module, source, &classes, &enum_variants, &enum_params);
+    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    // Register one shared `array<T>` GC type per distinct wasm value type used by a
+    // `...T` variadic parameter anywhere in the program (almost always just one, e.g.
+    // `Int...`) — replaces the old bump-allocated `[count][elem...]` blob (`array.len`
+    // replaces the explicit count word). Must happen before function signatures are
+    // registered below, since a variadic param's wasm type is this array's `ref`.
+    let mut variadic_elem_vts: Vec<ValType> = Vec::new();
+    for item in &source.items {
+        if let ast::Item::Fn(f) = item {
+            for p in &f.params {
+                if let ast::ParamType::Variadic(t) = &p.ty {
+                    let vt = astTypeToWasm(&t.name).unwrap_or(ValType::I64);
+                    if !variadic_elem_vts.contains(&vt) {
+                        variadic_elem_vts.push(vt);
+                    }
+                }
+            }
+        }
+    }
+    let variadic_array_subtypes: Vec<SubType> = variadic_elem_vts.iter().map(|vt| SubType {
+        is_final: true,
-    module.addMemory(2, None);
+        supertype_idx: None,
+        composite_type: CompositeType {
+            inner: CompositeInnerType::Array(ArrayType(FieldType { element_type: StorageType::Val(*vt), mutable: false })),
+            shared: false,
+        },
+    }).collect();
+    if !variadic_array_subtypes.is_empty() {
+        let indices = module.addGcTypes(variadic_array_subtypes);
+        for (vt, idx) in variadic_elem_vts.iter().zip(indices) {
+            gc_types.variadic_array_type_idx.insert(*vt, idx);
+        }
-    module.addExport("memory", ExportKind::Memory, 0);
+        CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
+    }
+    // Pre-allocate one instance of every payload-free variant (True/False/None/...)
+    // as a global, populated once by a `start` function rather than reconstructed on
+    // every reference — see this migration plan's Decision 2. `struct.new` isn't
+    // allowed inside a global's own const-expr initializer (confirmed empirically in
+    // Task 1), so each global starts `ref.null` and a `start` function fills it in
+    // before any export is callable. The zero-capture "trampoline" closures
+    // registered below (once closures are discovered) append to this SAME start
+    // function, so its body isn't finalized/patched into the module until then.
+    let mut singleton_globals: HashMap<String, u32> = HashMap::new();
+    let mut start_body = Vec::new();
+    for (name, info) in &enum_variants {
+        if !info.field_types.is_empty() {
+            continue;
+        }
+        let variant_idx = *gc_types.variant_type_idx.get(name)
+            .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' missing from GC type registry", name));
-    let mut bump_init = Vec::new();
+        let mut init = Vec::new();
-    Instruction::I32Const(HEAP_BASE as i32).encode(&mut bump_init);
+        Instruction::RefNull(HeapType::Concrete(variant_idx)).encode(&mut init);
-    let bump_global = module.addGlobal(ValType::I32, true, &bump_init);
+        let global_idx = module.addGlobal(gcRef(variant_idx), true, &init);
+        singleton_globals.insert(name.clone(), global_idx);
-    // Task 1 of the wasm-gc migration: declare the wasm-gc type section entries for
+        Instruction::StructNewDefault(variant_idx).encode(&mut start_body);
-    // every class/enum/Str up front. Purely additive right now — nothing below reads
-    // `gc_types` yet, so the bump-allocator codegen this function still emits is
+        Instruction::GlobalSet(global_idx).encode(&mut start_body);
-    // completely unaffected; this only proves the new type section is well-formed.
+    }
-    let gc_types = buildGcTypeRegistry(&mut module, source, &classes, &enum_variants);
+    let start_type_idx = module.addType(&[], &[]);
+    let start_func_idx = module.addFunction(start_type_idx, &[]);
+    module.setStartFunction(start_func_idx);
     let mut func_ids: HashMap<String, u32> = HashMap::new();
     let mut func_sigs: HashMap<String, FuncSig> = HashMap::new();
@@ -664,12 +811,17 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
             let mut param_types: Vec<ValType> = Vec::new();
-            if f.type_param.is_some() {
+            if let Some(recv) = &f.type_param {
-                param_types.push(ValType::I32);
+                param_types.push(astTypeToWasm(recv).unwrap_or(ValType::I32));
             }
             for p in &f.params {
                 let vt = match &p.ty {
-                    ast::ParamType::Variadic(_) => ValType::I32,
+                    ast::ParamType::Variadic(t) => {
+                        let elem_vt = astTypeToWasm(&t.name).unwrap_or(ValType::I64);
+                        let arr_idx = *gc_types.variadic_array_type_idx.get(&elem_vt)
+                            .expect("internal codegen error: variadic array type must be pre-registered for every elem type in the program");
+                        gcRef(arr_idx)
+                    }
                     other => astTypeToWasm(paramTypeName(other)).unwrap_or(ValType::I32),
                 };
                 param_types.push(vt);
@@ -737,10 +889,43 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
         named_fn_refs.extend(walker.named_fn_refs);
     }
+    // Register every closure literal's own env struct type, plus the ONE shared
+    // closure-value struct `{table_idx: i32, env: anyref}` every closure (and
+    // trampoline, below) wraps its env in — declared together as a single `rec`
+    // group now that every closure's free-variable types are known. The shared
+    // struct is always slot 0; closure `i`'s env type is slot `i + 1`.
+    let mut closure_subtypes: Vec<SubType> = vec![SubType {
+        is_final: true,
+        supertype_idx: None,
+        composite_type: CompositeType {
+            inner: CompositeInnerType::Struct(StructType {
+                fields: vec![
+                    FieldType { element_type: StorageType::Val(ValType::I32), mutable: false },
+                    FieldType { element_type: StorageType::Val(ValType::Ref(RefType::ANYREF)), mutable: false },
+                ].into(),
+            }),
+            shared: false,
+        },
+    }];
+    for rc in &raw_closures {
+        let field_types: Vec<FieldType> = rc.free_vars.iter().map(|(_, ty)| FieldType {
+            element_type: StorageType::Val(plumTypeToValtype(ty)),
+            mutable: false,
+        }).collect();
+        closure_subtypes.push(SubType {
+            is_final: true,
+            supertype_idx: None,
+            composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: field_types.into() }), shared: false },
+        });
+    }
+    let closure_type_indices = module.addGcTypes(closure_subtypes);
+    gc_types.closure_type_idx = closure_type_indices[0];
+    CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     let mut closures: HashMap<usize, ClosureInfo> = HashMap::new();
     let mut closure_asts: HashMap<usize, &ast::Closure> = HashMap::new();
-    for rc in &raw_closures {
+    for (i, rc) in raw_closures.iter().enumerate() {
-        let mut sig_params = vec![ValType::I32]; // env pointer
+        let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
         sig_params.extend(rc.param_vts.iter().copied());
         let sig_key: ClosureSigKey = (sig_params.clone(), rc.ret_vt);
         let type_idx = match closure_call_types.get(&sig_key) {
@@ -757,6 +942,7 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
         closures.insert(rc.ptr, ClosureInfo {
             func_idx,
             table_idx,
+            env_type_idx: closure_type_indices[i + 1],
             param_vts: rc.param_vts.clone(),
             param_ptypes: rc.param_ptypes.clone(),
             ret_vt: rc.ret_vt,
@@ -767,19 +953,17 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
     // Register a zero-capture "trampoline" closure for every top-level function
     // referenced as a bare value (e.g. `each(double)`): a real wasm function with the
-    // closure calling convention `(env_ptr, ...real_params) -> ret` that ignores its
+    // closure calling convention `(env, ...real_params) -> ret` that ignores its env
-    // env pointer and forwards straight to the real function, plus a funcref-table
+    // and forwards straight to the real function, plus a funcref-table entry for it.
-    // entry for it. Since it never captures anything, its `{table_idx, env_ptr=0}`
+    // Since it never captures anything, its `{table_idx, env=null}` closure struct is
-    // closure struct is a compile-time constant — baked into a data segment once
+    // a compile-time constant — like every payload-free enum variant, built once by
-    // rather than bump-allocated at every reference site.
+    // the shared `start` function and stored in its own global.
     let mut named_fn_values: HashMap<String, u32> = HashMap::new();
-    let mut named_fn_data_segments: Vec<(u32, Vec<u8>)> = Vec::new();
-    let mut next_static_offset = STRING_BASE;
     for name in &named_fn_refs {
         let sig = func_sigs.get(name).expect("named fn ref must be a registered top-level function");
         let real_func_idx = *func_ids.get(name).expect("named fn ref must be a registered top-level function");
-        let mut sig_params = vec![ValType::I32]; // env pointer
+        let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
         sig_params.extend(sig.params.iter().copied());
         let sig_key: ClosureSigKey = (sig_params.clone(), sig.ret);
         let type_idx = match closure_call_types.get(&sig_key) {
@@ -795,34 +979,47 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
         let mut tbody = Vec::new();
         tbody.push(0u8); // no locals beyond the params already in the signature
         for i in 0..sig.params.len() {
-            Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env_ptr, ignored
+            Instruction::LocalGet((i + 1) as u32).encode(&mut tbody); // local 0 is env, ignored
         }
         Instruction::Call(real_func_idx).encode(&mut tbody);
         Instruction::End.encode(&mut tbody);
         let func_idx = module.addFunction(type_idx, &tbody);
         let table_idx = module.addTableElement(func_idx);
-        let offset = next_static_offset;
-        next_static_offset += 8;
-        let mut bytes = Vec::with_capacity(8);
+        let mut init = Vec::new();
+        Instruction::RefNull(HeapType::Concrete(gc_types.closure_type_idx)).encode(&mut init);
-        bytes.extend_from_slice(&(table_idx as i32).to_le_bytes());
+        let global_idx = module.addGlobal(gcRef(gc_types.closure_type_idx), true, &init);
-        bytes.extend_from_slice(&0i32.to_le_bytes());
-        named_fn_data_segments.push((offset, bytes));
-        named_fn_values.insert(name.clone(), offset);
+        named_fn_values.insert(name.clone(), global_idx);
+        Instruction::I32Const(table_idx as i32).encode(&mut start_body);
+        Instruction::RefNull(HeapType::ANY).encode(&mut start_body);
+        Instruction::StructNew(gc_types.closure_type_idx).encode(&mut start_body);
+        Instruction::GlobalSet(global_idx).encode(&mut start_body);
     }
+    // The `start` function is now complete — every payload-free variant singleton
+    // (above) and every trampoline closure (above) has appended its own init code.
+    // It declares no locals of its own, but a function body's raw bytes must still
+    // start with the (empty) locals-declaration vector — a single `0x00` — before
+    // the instruction stream, exactly like every other compiled function body below.
+    Instruction::End.encode(&mut start_body);
+    let mut final_start_body = vec![0u8];
+    final_start_body.extend(start_body);
+    let start_slot = (start_func_idx - module.func_import_count) as usize;
+    module.functions[start_slot].1 = final_start_body;
     // Runtime helpers backing string interpolation (`"{expr}"`): always registered
     // (unconditionally, for simplicity) since they're cheap and self-contained.
-    let string_concat_func = registerStringConcatHelper(&mut module, bump_global);
+    let string_concat_func = registerStringConcatHelper(&mut module, gc_types.str_type_idx);
-    let int_to_string_func = registerIntToStringHelper(&mut module, bump_global);
+    let int_to_string_func = registerIntToStringHelper(&mut module, gc_types.str_type_idx);
     let ctx = CompileCtx {
-        func_ids, func_sigs, classes, methods, enum_variants, enum_params, global_env, bump_global,
+        func_ids, func_sigs, classes, methods, enum_variants, enum_params, global_env,
         closures, closure_asts, closure_call_types, named_fn_values,
-        string_concat_func, int_to_string_func, gc_types,
+        string_concat_func, int_to_string_func, gc_types, singleton_globals,
     };
-    let mut state = ModuleState { next_string_offset: next_static_offset, data_segments: named_fn_data_segments };
+    let mut state = ModuleState { passive_segments: Vec::new() };
     let mut compiled_bodies: Vec<(String, Vec<u8>)> = Vec::new();
     for f in &fns {
@@ -849,8 +1046,12 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
         module.functions[slot].1 = body.clone();
     }
+    // Flush every staged string literal into the module in the SAME order they were
+    // staged — `compileStaticString` already baked each one's index (its position in
+    // `state.passive_segments` at staging time) into an `array.new_data` instruction,
+    // so that order must be preserved exactly for those indices to still be correct.
-    for (offset, bytes) in &state.data_segments {
+    for bytes in &state.passive_segments {
-        module.addDataSegment(*offset, bytes);
+        module.addPassiveDataSegment(bytes);
     }
     if let Some(&main_idx) = ctx.func_ids.get("main") {
@@ -860,110 +1061,59 @@ pub fn compileSource(source: &ast::Source) -> Result<Vec<u8>, String> {
     Ok(module.finish())
 }
-/// Registers `__string_concat(a: i32, b: i32) -> i32`, a hand-written runtime
+/// Registers `__string_concat(a: ref Str, b: ref Str) -> ref Str`, a hand-written
-/// helper backing string interpolation: bump-allocates a new length-prefixed
+/// runtime helper backing string interpolation. `Str` is a wasm-gc `array<i8>`,
-/// string (`[len: u32][bytes]`, matching a literal string's own layout) exactly
-/// long enough for `a`'s bytes followed by `b`'s, and copies them in. There's no
+/// which tracks its own length (`array.len`) — building the concatenation is:
-/// bulk-memory `memory.copy` assumed available, so each byte is copied by an
+/// allocate a new array sized `len(a) + len(b)`, then two `array.copy`s (a
-/// explicit loop.
+/// whole-array-in-one-instruction bulk copy).
-fn registerStringConcatHelper(module: &mut WasmModule, bump_global: u32) -> u32 {
+fn registerStringConcatHelper(module: &mut WasmModule, str_type_idx: u32) -> u32 {
+    let str_ref = gcRef(str_type_idx);
-    let type_idx = module.addType(&[ValType::I32, ValType::I32], &[ValType::I32]);
+    let type_idx = module.addType(&[str_ref, str_ref], &[str_ref]);
-    // locals: 0=a (param), 1=b (param), 2=len_a, 3=len_b, 4=result, 5=i
+    // locals: 0=a (param), 1=b (param), 2=len_a, 3=len_b, 4=result
     const A: u32 = 0;
     const B: u32 = 1;
     const LEN_A: u32 = 2;
     const LEN_B: u32 = 3;
     const RESULT: u32 = 4;
-    const I: u32 = 5;
     let mut body = Vec::new();
-    body.extend(encodeLeb128U32(1)); // one locals group
+    body.extend(encodeLeb128U32(2)); // two locals groups
-    body.extend(encodeLeb128U32(4)); // 4 locals (len_a, len_b, result, i)
+    body.extend(encodeLeb128U32(2)); // len_a, len_b: i32
     ValType::I32.encode(&mut body);
+    body.extend(encodeLeb128U32(1)); // result: ref
+    str_ref.encode(&mut body);
-    // len_a = load(a); len_b = load(b)
+    // len_a = array.len(a); len_b = array.len(b)
     Instruction::LocalGet(A).encode(&mut body);
-    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    Instruction::ArrayLen.encode(&mut body);
     Instruction::LocalSet(LEN_A).encode(&mut body);
     Instruction::LocalGet(B).encode(&mut body);
-    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    Instruction::ArrayLen.encode(&mut body);
     Instruction::LocalSet(LEN_B).encode(&mut body);
-    // result = bump; bump += 4 + len_a + len_b
+    // result = array.new_default(str_type_idx, len_a + len_b)
-    Instruction::GlobalGet(bump_global).encode(&mut body);
-    Instruction::LocalSet(RESULT).encode(&mut body);
-    Instruction::GlobalGet(bump_global).encode(&mut body);
     Instruction::LocalGet(LEN_A).encode(&mut body);
     Instruction::LocalGet(LEN_B).encode(&mut body);
     Instruction::I32Add.encode(&mut body);
-    Instruction::I32Const(4).encode(&mut body);
+    Instruction::ArrayNewDefault(str_type_idx).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::GlobalSet(bump_global).encode(&mut body);
+    Instruction::LocalSet(RESULT).encode(&mut body);
-    // store combined length at result+0
+    // array.copy(dst: result, dst_offset: 0, src: a, src_offset: 0, len: len_a)
     Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::LocalGet(LEN_B).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
-    // for (i = 0; i < len_a; i++) result[4+i] = a[4+i]
     Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
-    Instruction::Block(BlockType::Empty).encode(&mut body);
-    Instruction::Loop(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::I32GeU.encode(&mut body);
-    Instruction::BrIf(1).encode(&mut body);
-    // address = result + i
-    Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    // value = load8u(a + i, offset 4)
     Instruction::LocalGet(A).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::I32Load8U(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
-    Instruction::I32Store8(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Const(1).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
-    Instruction::Br(0).encode(&mut body);
-    Instruction::End.encode(&mut body);
-    Instruction::End.encode(&mut body);
-    // for (i = 0; i < len_b; i++) result[4+len_a+i] = b[4+i]
     Instruction::I32Const(0).encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
-    Instruction::Block(BlockType::Empty).encode(&mut body);
-    Instruction::Loop(BlockType::Empty).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::LocalGet(LEN_B).encode(&mut body);
+    Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::I32GeU.encode(&mut body);
-    Instruction::BrIf(1).encode(&mut body);
+    Instruction::ArrayCopy { array_type_index_dst: str_type_idx, array_type_index_src: str_type_idx }.encode(&mut body);
-    // address = result + len_a + i
+    // array.copy(dst: result, dst_offset: len_a, src: b, src_offset: 0, len: len_b)
     Instruction::LocalGet(RESULT).encode(&mut body);
     Instruction::LocalGet(LEN_A).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    // value = load8u(b + i, offset 4)
     Instruction::LocalGet(B).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::I32Load8U(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
-    Instruction::I32Store8(MemArg { offset: 4, align: 0, memory_index: 0 }).encode(&mut body);
-    Instruction::LocalGet(I).encode(&mut body);
-    Instruction::I32Const(1).encode(&mut body);
+    Instruction::I32Const(0).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::LocalSet(I).encode(&mut body);
+    Instruction::LocalGet(LEN_B).encode(&mut body);
-    Instruction::Br(0).encode(&mut body);
+    Instruction::ArrayCopy { array_type_index_dst: str_type_idx, array_type_index_src: str_type_idx }.encode(&mut body);
-    Instruction::End.encode(&mut body);
-    Instruction::End.encode(&mut body);
     Instruction::LocalGet(RESULT).encode(&mut body);
     Instruction::End.encode(&mut body);
@@ -971,31 +1121,34 @@ fn registerStringConcatHelper(module: &mut WasmModule, bump_global: u32) -> u32
     module.addFunction(type_idx, &body)
 }
-/// Registers `__int_to_string(n: i64) -> i32`, a hand-written runtime helper
+/// Registers `__int_to_string(n: i64) -> ref Str`, a hand-written runtime helper
-/// backing string interpolation: bump-allocates a new length-prefixed string
+/// backing string interpolation: allocates a new `array<i8>` holding `n`'s decimal
-/// holding `n`'s decimal representation (handling a leading `-` for negatives, and
+/// representation (handling a leading `-` for negatives, and `0` correctly via a
-/// `0` correctly via a do-while digit count that always runs at least once).
+/// do-while digit count that always runs at least once).
-fn registerIntToStringHelper(module: &mut WasmModule, bump_global: u32) -> u32 {
+fn registerIntToStringHelper(module: &mut WasmModule, str_type_idx: u32) -> u32 {
+    let str_ref = gcRef(str_type_idx);
-    let type_idx = module.addType(&[ValType::I64], &[ValType::I32]);
+    let type_idx = module.addType(&[ValType::I64], &[str_ref]);
-    // locals: 0=n (param, i64), 1=is_neg (i32), 2=abs_n (i64), 3=count (i32),
+    // locals: 0=n (param, i64), 1=is_neg (i32), 2=count (i32), 3=total_len (i32),
-    // 4=total_len (i32), 5=result (i32), 6=pos (i32), 7=temp (i64)
+    // 4=pos (i32), 5=result (ref), 6=abs_n (i64), 7=temp (i64)
-    // Locals are declared as one group of 5 `i32`s followed by one group of 2
+    // Locals are declared as one group of 4 `i32`s, one group of 1 `ref`, then one
-    // `i64`s (see below), so indices must stay grouped by type in that same order —
+    // group of 2 `i64`s (see below), so indices must stay grouped by type in that
-    // NOT in whatever order reads best logically.
+    // same order — NOT in whatever order reads best logically.
     const N: u32 = 0;
     const IS_NEG: u32 = 1;
     const COUNT: u32 = 2;
     const TOTAL_LEN: u32 = 3;
+    const POS: u32 = 4;
-    const RESULT: u32 = 4;
+    const RESULT: u32 = 5;
-    const POS: u32 = 5;
     const ABS_N: u32 = 6;
     const TEMP: u32 = 7;
     let mut body = Vec::new();
-    body.extend(encodeLeb128U32(2)); // two locals groups
+    body.extend(encodeLeb128U32(3)); // three locals groups
-    body.extend(encodeLeb128U32(5)); // is_neg, count, total_len, result, pos: i32
+    body.extend(encodeLeb128U32(4)); // is_neg, count, total_len, pos: i32
     ValType::I32.encode(&mut body);
+    body.extend(encodeLeb128U32(1)); // result: ref
+    str_ref.encode(&mut body);
     body.extend(encodeLeb128U32(2)); // abs_n, temp: i64
     ValType::I64.encode(&mut body);
@@ -1042,39 +1195,27 @@ fn registerIntToStringHelper(module: &mut WasmModule, bump_global: u32) -> u32 {
     Instruction::I32Add.encode(&mut body);
     Instruction::LocalSet(TOTAL_LEN).encode(&mut body);
+    // result = array.new_default(str_type_idx, total_len) — no length prefix needed,
-    // result = bump; bump += 4 + total_len
+    // `array.len` reads it back natively.
-    Instruction::GlobalGet(bump_global).encode(&mut body);
-    Instruction::LocalSet(RESULT).encode(&mut body);
-    Instruction::GlobalGet(bump_global).encode(&mut body);
-    Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::I32Const(4).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
-    Instruction::GlobalSet(bump_global).encode(&mut body);
-    // store total_len at result+0
-    Instruction::LocalGet(RESULT).encode(&mut body);
     Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(&mut body);
+    Instruction::ArrayNewDefault(str_type_idx).encode(&mut body);
+    Instruction::LocalSet(RESULT).encode(&mut body);
-    // pos = 4 + total_len; temp = abs_n
+    // pos = total_len; temp = abs_n
-    Instruction::I32Const(4).encode(&mut body);
     Instruction::LocalGet(TOTAL_LEN).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
     Instruction::LocalSet(POS).encode(&mut body);
     Instruction::LocalGet(ABS_N).encode(&mut body);
     Instruction::LocalSet(TEMP).encode(&mut body);
-    // do { pos--; result[pos] = '0' + temp % 10; temp /= 10 } while (pos > 4 + is_neg)
+    // do { pos--; result[pos] = '0' + temp % 10; temp /= 10 } while (pos > is_neg)
     Instruction::Loop(BlockType::Empty).encode(&mut body);
     Instruction::LocalGet(POS).encode(&mut body);
     Instruction::I32Const(1).encode(&mut body);
     Instruction::I32Sub.encode(&mut body);
     Instruction::LocalSet(POS).encode(&mut body);
-    // address = result + pos
+    // array.set(result, pos, value) — stack order [array_ref, index, value]
     Instruction::LocalGet(RESULT).encode(&mut body);
     Instruction::LocalGet(POS).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
     // value = '0' + (temp % 10)
     Instruction::LocalGet(TEMP).encode(&mut body);
     Instruction::I64Const(10).encode(&mut body);
@@ -1082,29 +1223,26 @@ fn registerIntToStringHelper(module: &mut WasmModule, bump_global: u32) -> u32 {
     Instruction::I64Const(48).encode(&mut body);
     Instruction::I64Add.encode(&mut body);
     Instruction::I32WrapI64.encode(&mut body);
-    Instruction::I32Store8(MemArg { offset: 0, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::ArraySet(str_type_idx).encode(&mut body);
     // temp /= 10
     Instruction::LocalGet(TEMP).encode(&mut body);
     Instruction::I64Const(10).encode(&mut body);
     Instruction::I64DivS.encode(&mut body);
     Instruction::LocalSet(TEMP).encode(&mut body);
-    // while (pos > 4 + is_neg)
+    // while (pos > is_neg)
     Instruction::LocalGet(POS).encode(&mut body);
-    Instruction::I32Const(4).encode(&mut body);
     Instruction::LocalGet(IS_NEG).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
     Instruction::I32GtU.encode(&mut body);
     Instruction::BrIf(0).encode(&mut body);
     Instruction::End.encode(&mut body);
-    // if (is_neg) result[4] = '-'
+    // if (is_neg) result[0] = '-'
     Instruction::LocalGet(IS_NEG).encode(&mut body);
     Instruction::If(BlockType::Empty).encode(&mut body);
     Instruction::LocalGet(RESULT).encode(&mut body);
-    Instruction::I32Const(4).encode(&mut body);
+    Instruction::I32Const(0).encode(&mut body);
-    Instruction::I32Add.encode(&mut body);
     Instruction::I32Const(45).encode(&mut body); // '-'
-    Instruction::I32Store8(MemArg { offset: 0, align: 0, memory_index: 0 }).encode(&mut body);
+    Instruction::ArraySet(str_type_idx).encode(&mut body);
     Instruction::End.encode(&mut body);
     Instruction::LocalGet(RESULT).encode(&mut body);
@@ -1757,18 +1895,22 @@ struct Collector<'a> {
     cctx: plum_checker::CheckCtx<'a>,
     named: Vec<(String, PlumType)>,
     named_set: std::collections::HashSet<String>,
-    classcall_scratch: HashMap<usize, u32>,
     /// One scratch-local type per subject (usually one, more for `match a, b, ...`).
     match_scratch: HashMap<usize, Vec<PlumType>>,
-    next_classcall_slot: u32,
-    /// `Closure` expr identity -> offset of its first (of two) construction scratch slots.
-    closure_scratch: HashMap<usize, u32>,
-    next_closure_slot: u32,
-    /// `CasePattern::Class` identity -> its scratch local, for a constructor pattern
+    /// `CasePattern::Class` identity -> its scratch local. Covers EVERY constructor
+    /// pattern, including top-level ones — under wasm-gc, matching `Some(v)` needs a
+    /// `ref.cast` from the subject's static supertype down to the concrete variant
+    /// type before any `struct.get` on it validates, and that narrowed value needs
+    /// its OWN local (declared with the concrete variant's ref type) distinct from
+    /// the original wide-typed subject local, which stays declared at the
+    /// supertype's type for the whole function. (Before wasm-gc, this only covered
-    /// *nested* inside another constructor pattern's fields (`Some(Some(v))`) — the
+    /// patterns nested inside another constructor pattern's fields, depth >= 1,
-    /// outermost, per-subject pattern already has a scratch local via `match_scratch`
+    /// since a plain i32 pointer needed no per-pattern static type at all.)
-    /// / `all_subjects`, so this only covers depth >= 1.
     nested_class_scratch: HashMap<usize, u32>,
+    /// Slot number (the `u32` values in `nested_class_scratch`) -> the variant name
+    /// it narrows to, so its scratch local can be declared with that variant's exact
+    /// concrete ref type instead of a uniform placeholder type.
+    nested_class_scratch_types: Vec<String>,
     next_nested_class_slot: u32,
     /// `For` stmt identity (pointer address) -> a slot number; each slot reserves 2
     /// consecutive `i32` scratch locals for variadic iteration (`for v in nums`):
@@ -1791,7 +1933,7 @@ impl<'a> Collector<'a> {
     /// its correct field type, and reserves a scratch local for every `Class`
     /// sub-pattern found *nested* inside another constructor pattern's fields (the
     /// outermost, per-subject pattern doesn't need one — see `nested_class_scratch`).
-    fn collectPattern(&mut self, pat: &ast::CasePattern, ty: &PlumType, top_level: bool) {
+    fn collectPattern(&mut self, pat: &ast::CasePattern, ty: &PlumType) {
         match pat {
             ast::CasePattern::Name(n) => {
                 let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
@@ -1801,16 +1943,15 @@ impl<'a> Collector<'a> {
                 }
             }
             ast::CasePattern::Class { name, fields } => {
-                if !top_level {
-                    let key = pat as *const ast::CasePattern as usize;
+                let key = pat as *const ast::CasePattern as usize;
-                    let slot = self.next_nested_class_slot;
+                let slot = self.next_nested_class_slot;
-                    self.next_nested_class_slot += 1;
+                self.next_nested_class_slot += 1;
-                    self.nested_class_scratch.insert(key, slot);
+                self.nested_class_scratch.insert(key, slot);
-                }
+                self.nested_class_scratch_types.push(name.clone());
                 if let Some(info) = self.cctx.enum_variants.get(name) {
                     let field_types = info.field_types.clone();
                     for (f, fty) in fields.iter().zip(field_types.iter()) {
-                        self.collectPattern(f, fty, false);
+                        self.collectPattern(f, fty);
                     }
                 }
             }
@@ -1900,7 +2041,7 @@ impl<'a> Collector<'a> {
                 for case in &m.cases {
                     let saved = self.env.clone();
                     for (pat, subject_ty) in case.patterns.iter().zip(subject_types.iter()) {
-                        self.collectPattern(pat, subject_ty, true);
+                        self.collectPattern(pat, subject_ty);
                     }
                     self.walkBlock(&case.body);
                     self.env = saved;
@@ -1913,9 +2054,6 @@ impl<'a> Collector<'a> {
     fn walkExpr(&mut self, expr: &ast::Expr) {
         match expr {
             ast::Expr::ClassCall(call) => {
-                let idx = self.next_classcall_slot;
-                self.next_classcall_slot += 1;
-                self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
                 for fa in &call.fields {
                     self.walkExpr(&fa.value);
                 }
@@ -1941,18 +2079,6 @@ impl<'a> Collector<'a> {
                 self.walkExpr(&t.else_);
             }
             ast::Expr::FnCall(call) => {
-                let carries_payload = self.cctx.enum_variants.get(&call.name)
-                    .map(|info| !info.field_types.is_empty())
-                    .unwrap_or(false);
-                let is_variadic_call = matches!(
-                    plum_checker::lookup(&self.env, &call.name),
-                    Ok(PlumType::TFun(params, _)) if matches!(params.last(), Some(PlumType::TVariadic(_)))
-                );
-                if carries_payload || is_variadic_call {
-                    let idx = self.next_classcall_slot;
-                    self.next_classcall_slot += 1;
-                    self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
-                }
                 for arg in &call.args {
                     self.walkArg(arg);
                 }
@@ -1965,34 +2091,15 @@ impl<'a> Collector<'a> {
                     }
                 }
             }
-            ast::Expr::TypeName(n) => {
+            ast::Expr::TypeName(_) => {}
-                // A bare discriminant-variant reference (e.g. `READ_MIN_OCCURANCES`) heap-
-                // allocates via the SAME `compileVariantConstruction` path a payload-carrying
-                // `FnCall` variant construction uses (see the `Expr::TypeName` arm in
-                // `compileExpr`), so it needs the same scratch slot registered here.
-                let carries_baked_in_payload = self.cctx.enum_variants.get(n)
-                    .map(|info| !info.values.is_empty())
-                    .unwrap_or(false);
-                if carries_baked_in_payload {
-                    let idx = self.next_classcall_slot;
-                    self.next_classcall_slot += 1;
-                    self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
-                }
-            }
             ast::Expr::Int(_)
             | ast::Expr::Float(_)
             | ast::Expr::String(_)
             | ast::Expr::Self_
             | ast::Expr::Var(_) => {}
-            // A closure literal needs two construction scratch slots in the *enclosing*
+            // A closure literal's body has its own locals, belonging to the separate
-            // function (env struct ptr, closure struct ptr). Its body's own locals are
-            // NOT this function's — they belong to the separate closure function — so we
+            // closure function it compiles to — nothing to recurse into here.
-            // don't recurse into the body here.
-            ast::Expr::Closure(cl) => {
+            ast::Expr::Closure(_) => {}
-                let base = self.next_closure_slot;
-                self.next_closure_slot += 2;
-                self.closure_scratch.insert(cl.as_ref() as *const ast::Closure as usize, base);
-            }
         }
     }
@@ -2030,12 +2137,9 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
         cctx: checkCtxOf(&ctx.classes, &ctx.methods, &ctx.enum_variants, &ctx.enum_params),
         named: Vec::new(),
         named_set: Default::default(),
-        classcall_scratch: HashMap::new(),
         match_scratch: HashMap::new(),
-        next_classcall_slot: 0,
-        closure_scratch: HashMap::new(),
-        next_closure_slot: 0,
         nested_class_scratch: HashMap::new(),
+        nested_class_scratch_types: Vec::new(),
         next_nested_class_slot: 0,
         variadic_for_scratch: HashMap::new(),
         next_variadic_for_slot: 0,
@@ -2067,13 +2171,6 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
         idx += 1;
     }
-    let classcall_scratch_base = idx;
-    let classcall_count = collector.classcall_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
-    for _ in 0..classcall_count {
-        groups.push(ValType::I32);
-        idx += 1;
-    }
     let match_scratch_base = idx;
     let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
     for (ptr, types) in collector.match_scratch.iter() {
@@ -2085,9 +2182,14 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
     }
     let nested_class_scratch_base = idx;
+    // Each slot is declared with its OWN concrete variant ref type (not a uniform
+    // placeholder) — `struct.get` on a constructor-pattern match requires the local
-    let nested_class_scratch_count = collector.nested_class_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    // holding the narrowed (`ref.cast`) value to be statically typed as that exact
+    // variant, and different slots very likely narrow to different variants.
-    for _ in 0..nested_class_scratch_count {
+    for vname in &collector.nested_class_scratch_types {
+        let variant_idx = withGcTypes(|r| *r.variant_type_idx.get(vname)
+            .unwrap_or_else(|| panic!("internal codegen error: variant '{}' missing from the GC type registry", vname)));
-        groups.push(ValType::I32);
+        groups.push(gcRef(variant_idx));
         idx += 1;
     }
@@ -2099,12 +2201,6 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
         idx += 2;
     }
-    let closure_scratch_base = idx;
-    let closure_scratch_count = collector.closure_scratch.values().copied().max().map(|m| m + 2).unwrap_or(0);
-    for _ in 0..closure_scratch_count {
-        groups.push(ValType::I32);
-    }
     if groups.is_empty() {
         body.push(0);
     } else {
@@ -2117,12 +2213,8 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
     let local_ctx = LocalCtx {
         locals,
-        classcall_scratch_base,
-        classcall_scratch: collector.classcall_scratch,
         match_scratch_base,
         match_scratch_index,
-        closure_scratch_base,
-        closure_scratch: collector.closure_scratch,
         nested_class_scratch_base,
         nested_class_scratch: collector.nested_class_scratch,
         variadic_for_scratch_base,
@@ -2138,9 +2230,10 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
+        gc_types: &ctx.gc_types,
+        singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
         closure_local_sigs: RefCell::new(HashMap::new()),
-        bump_global: ctx.bump_global,
     };
     let result_vt = retTypeToWasm(f.returns.as_ref());
@@ -2228,6 +2321,35 @@ fn compileStmtInValuePosition(
 /// (each branch is `BlockType::Empty`, nothing left on the stack) or `Some(vt)` when this
 /// `if` is in value position — every branch must then leave a `vt` value on the stack, which
 /// requires an `else` (a value can't be produced on a path that doesn't exist).
+/// Compiles a `Bool`-typed expression, then a `ref.test` against the `True` variant's
+/// concrete type, leaving a plain `i32` (1/0) on the stack. Every place a `Bool` value
+/// drives wasm's OWN native control flow (`if`/`br_if`, which require a raw `i32`
+/// condition, not a `ref`) goes through this — see this migration plan's Decision 1
+/// (Bool is a full wasm-gc struct, no special-casing).
+fn compileBoolConditionAsI32(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut ModuleState) -> Result<(), String> {
+    compileExpr(expr, body, ctx, state)?;
+    let true_idx = *ctx.gc_types.variant_type_idx.get("True")
+        .expect("internal codegen error: True must be registered in the GC type registry");
+    Instruction::RefTestNonNull(HeapType::Concrete(true_idx)).encode(body);
+    Ok(())
+}
+/// Given an `i32` boolean (1/0) already on the stack, converts it into a `Bool` ref by
+/// selecting the pre-allocated `True`/`False` singleton (this migration plan's
+/// Decision 2) — the reverse of `compileBoolConditionAsI32`. Used wherever a native
+/// wasm comparison/logical-op instruction just left a raw `i32` predicate on the
+/// stack that needs to become a proper `Bool` value.
+fn pushBoolRefFromI32Flag(body: &mut Vec<u8>, ctx: &LocalCtx) {
+    let bool_ref_ty = plumTypeToValtype(&PlumType::TBool);
+    let true_global = *ctx.singleton_globals.get("True").expect("internal codegen error: True singleton global missing");
+    let false_global = *ctx.singleton_globals.get("False").expect("internal codegen error: False singleton global missing");
+    Instruction::If(BlockType::Result(bool_ref_ty)).encode(body);
+    Instruction::GlobalGet(true_global).encode(body);
+    Instruction::Else.encode(body);
+    Instruction::GlobalGet(false_global).encode(body);
+    Instruction::End.encode(body);
+}
 fn compileIf(
     if_: &ast::If,
     result_vt: Option<ValType>,
@@ -2241,13 +2363,13 @@ fn compileIf(
         );
     }
     let bt = blockTypeFor(result_vt);
-    compileExpr(&if_.condition, body, ctx, state)?;
+    compileBoolConditionAsI32(&if_.condition, body, ctx, state)?;
     Instruction::If(bt).encode(body);
     compileCaseBody(&if_.body, result_vt, body, ctx, state)?;
     if !if_.else_ifs.is_empty() || if_.else_.is_some() {
         Instruction::Else.encode(body);
         for ei in &if_.else_ifs {
-            compileExpr(&ei.condition, body, ctx, state)?;
+            compileBoolConditionAsI32(&ei.condition, body, ctx, state)?;
             Instruction::If(bt).encode(body);
             compileCaseBody(&ei.body, result_vt, body, ctx, state)?;
             Instruction::Else.encode(body);
@@ -2309,7 +2431,7 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         if let ast::Expr::Closure(cl) = value {
                             let key = cl.as_ref() as *const ast::Closure as usize;
                             if let Some(info) = ctx.closures.get(&key) {
-                                let mut sig_params = vec![ValType::I32];
+                                let mut sig_params = vec![ValType::Ref(RefType::ANYREF)];
                                 sig_params.extend(info.param_vts.iter().copied());
                                 ctx.closure_local_sigs.borrow_mut().insert(name.clone(), (sig_params, info.ret_vt));
                             }
@@ -2325,19 +2447,18 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                             .classes
                             .get(&class_name)
                             .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
-                        let (field_idx, field_ty) = fields
+                        let field_idx = fields
                             .iter()
                             .position(|(n, _)| n == field_name)
-                            .map(|i| (i, fields[i].1.clone()))
                             .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                        let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
+                            .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
+                        // struct.set expects [(ref null $t) value] on the stack (ref
+                        // pushed first/deeper, value second/on top) — same push order
+                        // this already used for the old memory store.
                         compileExpr(object, body, ctx, state)?;
                         compileExpr(value, body, ctx, state)?;
-                        let offset = (field_idx as u64) * 8;
-                        match plumTypeToValtype(&field_ty) {
-                            ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                            ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                            _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                        Instruction::StructSet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
-                        };
                     }
                 }
             }
@@ -2355,7 +2476,7 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
         ast::Stmt::While(w) => {
             Instruction::Block(BlockType::Empty).encode(body);
             Instruction::Loop(BlockType::Empty).encode(body);
-            compileExpr(&w.condition, body, ctx, state)?;
+            compileBoolConditionAsI32(&w.condition, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
             Instruction::BrIf(1).encode(body);
             compileBlock(&w.body, body, ctx, state)?;
@@ -2412,11 +2533,15 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                 let count_local = ctx.variadic_for_scratch_base + slot * 2;
                 let index_local = count_local + 1;
                 let elem_vt = plumTypeToValtype(&elem_ty);
+                let array_type_idx = *ctx
+                    .gc_types
+                    .variadic_array_type_idx
+                    .get(&elem_vt)
+                    .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
-                // count_local = i32.wrap_i64(load_i64([nums + 0]))
+                // count_local = array.len(iter)
                 compileExpr(&f.iter, body, ctx, state)?;
-                Instruction::I64Load(MemArg { offset: 0, align: 3, memory_index: 0 }).encode(body);
-                Instruction::I32WrapI64.encode(body);
+                Instruction::ArrayLen.encode(body);
                 Instruction::LocalSet(count_local).encode(body);
                 // index_local = 0
@@ -2430,15 +2555,10 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                 Instruction::I32GeS.encode(body);
                 Instruction::BrIf(1).encode(body);
-                // var = load_elem([nums + 8 + index * 8])
+                // var = array.get(iter, index)
                 compileExpr(&f.iter, body, ctx, state)?;
-                Instruction::I32Const(8).encode(body);
-                Instruction::I32Add.encode(body);
                 Instruction::LocalGet(index_local).encode(body);
-                Instruction::I32Const(8).encode(body);
+                Instruction::ArrayGet(array_type_idx).encode(body);
-                Instruction::I32Mul.encode(body);
-                Instruction::I32Add.encode(body);
-                emitLoad(elem_vt, 0, body);
                 Instruction::LocalSet(var_idx).encode(body);
                 compileBlock(&f.body, body, ctx, state)?;
@@ -2472,7 +2592,7 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             compileMatch(m, body, ctx, state, None)?;
         }
         ast::Stmt::Assert(e) => {
-            compileExpr(e, body, ctx, state)?;
+            compileBoolConditionAsI32(e, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
             Instruction::If(BlockType::Empty).encode(body);
             Instruction::Unreachable.encode(body);
@@ -2531,7 +2651,7 @@ fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
 /// for `match a, b, ...` it's the full cross product (e.g. `Bool, Bool` needs all
 /// 4 combinations named, matching `libs/std/bool.plum`'s `and`/`or`).
 fn matchCoversEveryEnumVariant(cases: &[ast::Case], subject_vts: &[ValType], ctx: &LocalCtx) -> bool {
-    if subject_vts.is_empty() || subject_vts.iter().any(|vt| *vt != ValType::I32) {
+    if subject_vts.is_empty() || subject_vts.iter().any(|vt| !matches!(vt, ValType::Ref(_))) {
         return false;
     }
     let n = subject_vts.len();
@@ -2727,7 +2847,7 @@ fn compileCasePositions(
         ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
         ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
         ast::CasePattern::Class { name, fields } => {
-            compileVariantConstructorArm(name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
+            compileVariantConstructorArm(pat, name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
         }
     }
 }
@@ -2747,23 +2867,19 @@ fn compileVariantEqArm(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    let info = ctx
-        .enum_variants
+    ctx.enum_variants
         .get(name)
         .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
-    if subject_vt != ValType::I32 {
+    if !matches!(subject_vt, ValType::Ref(_)) {
         return Err(format!("codegen: enum tag pattern '{}' against a non-enum subject", name));
     }
-    let tag = info.tag;
+    let variant_idx = *ctx.gc_types.variant_type_idx.get(name)
+        .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", name))?;
+    // A single ref.test against the variant's exact concrete type replaces the old
+    // "range-check against HEAP_BASE, then conditionally load+compare a tag" dance —
+    // there's no tag to load at all anymore, the type itself IS the discriminant.
     Instruction::LocalGet(scratch_local).encode(body);
-    if !info.field_types.is_empty() {
-        // A payload-carrying variant's scratch local holds a heap pointer, not the
-        // tag itself (unlike a payload-free variant, which stores the tag directly
-        // as its runtime value) — dereference slot 0 to compare against the tag.
-        emitLoad(ValType::I32, 0, body);
-    }
-    Instruction::I32Const(tag).encode(body);
+    Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
-    Instruction::I32Eq.encode(body);
     Instruction::If(blockTypeFor(result_vt)).encode(body);
     compileCasePositions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)?;
     Instruction::Else.encode(body);
@@ -2772,8 +2888,10 @@ fn compileVariantEqArm(
     Ok(())
 }
+#[allow(clippy::too_many_arguments)]
 #[allow(clippy::too_many_arguments)]
 fn compileVariantConstructorArm(
+    pat: &ast::CasePattern,
     name: &str,
     fields: &[ast::CasePattern],
     subject_vt: ValType,
@@ -2792,7 +2910,7 @@ fn compileVariantConstructorArm(
         .enum_variants
         .get(name)
         .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
-    if subject_vt != ValType::I32 {
+    if !matches!(subject_vt, ValType::Ref(_)) {
         return Err(format!("codegen: constructor pattern '{}' against a non-enum subject", name));
     }
     if fields.len() != info.field_types.len() {
@@ -2801,28 +2919,33 @@ fn compileVariantConstructorArm(
             name, info.field_types.len(), fields.len()
         ));
     }
-    let tag = info.tag;
+    let variant_idx = *ctx.gc_types.variant_type_idx.get(name)
+        .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", name))?;
     let field_types = info.field_types.clone();
-    // A constructor pattern can only match if the runtime subject is actually
+    // This pattern's own narrowly-typed scratch local (declared with variant's exact
-    // a heap pointer (payload variants are always >= HEAP_BASE); a
-    // payload-free sibling variant is a small int tag, and loading i32 from
+    // concrete ref type — see `nested_class_scratch_types`), distinct from
+    // `scratch_local` (which stays declared at the subject's wide supertype type for
-    // that address would read unrelated/zeroed memory instead of a real tag.
+    // the whole function). `struct.get` on the fields below requires this narrowed
+    // static type; the old bump-allocator version needed no such narrowing since
-    // Guard with a range check before doing the I32Load.
+    // every heap reference was a uniformly-typed, untyped-at-the-wasm-level i32.
+    let narrow_key = pat as *const ast::CasePattern as usize;
-    Instruction::LocalGet(scratch_local).encode(body);
+    let narrow_slot = *ctx.nested_class_scratch.get(&narrow_key)
-    Instruction::I32Const(HEAP_BASE as i32).encode(body);
+        .ok_or_else(|| "internal codegen error: missing constructor-pattern scratch slot".to_string())?;
-    Instruction::I32GeU.encode(body);
-    Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+    let narrow_local = ctx.nested_class_scratch_base + narrow_slot;
+    // A single ref.test against the variant's exact concrete type replaces the old
+    // "range-check against HEAP_BASE, then conditionally load+compare a tag" dance.
     Instruction::LocalGet(scratch_local).encode(body);
-    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
+    Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
-    Instruction::I32Const(tag).encode(body);
-    Instruction::I32Eq.encode(body);
-    Instruction::Else.encode(body);
-    Instruction::I32Const(0).encode(body);
-    Instruction::End.encode(body);
     Instruction::If(blockTypeFor(result_vt)).encode(body);
+    // Narrow the subject down to this variant's concrete type before destructuring
+    // its fields — valid here specifically because the ref.test just above proved it.
+    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::RefCastNonNull(HeapType::Concrete(variant_idx)).encode(body);
+    Instruction::LocalSet(narrow_local).encode(body);
     compileFieldPatterns(
-        fields, &field_types, 0, scratch_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state,
+        fields, &field_types, 0, narrow_local, variant_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state,
         &mut |body, state| compileCasePositions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state),
     )?;
     Instruction::Else.encode(body);
@@ -2838,11 +2961,13 @@ fn compileVariantConstructorArm(
 /// position). A mismatch at any field — at any nesting depth — falls through to
 /// `compileMatchArmsMulti(rest, ...)`, exactly like a top-level pattern mismatch.
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::too_many_arguments)]
 fn compileFieldPatterns(
     fields: &[ast::CasePattern],
     field_types: &[PlumType],
     fpos: usize,
     container_local: u32,
+    container_type_idx: u32,
     rest: &[ast::Case],
     all_subjects: &[(ValType, u32)],
     result_vt: Option<ValType>,
@@ -2857,12 +2982,10 @@ fn compileFieldPatterns(
     }
     let pat = &fields[fpos];
     let field_ty = &field_types[fpos];
-    let field_vt = plumTypeToValtype(field_ty);
-    let offset = ((fpos + 1) as u64) * 8;
     match pat {
         ast::CasePattern::Wildcard => {
-            compileFieldPatterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+            compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
         }
         ast::CasePattern::Name(n) if !(n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) && ctx.enum_variants.contains_key(n)) => {
             // A plain binding always matches this field; load it straight into its
@@ -2873,47 +2996,42 @@ fn compileFieldPatterns(
                 .copied()
                 .ok_or_else(|| format!("internal codegen error: missing binding local '{}'", n))?;
             Instruction::LocalGet(container_local).encode(body);
-            emitLoad(field_vt, offset, body);
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
             Instruction::LocalSet(idx).encode(body);
             ctx.type_env.borrow_mut().insert(n.to_string(), TypeScheme::mono(field_ty.clone()));
-            compileFieldPatterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+            compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
         }
         ast::CasePattern::Name(n) => {
             // An uppercase, payload-free variant name used as a field pattern (e.g.
             // matching a nested `None` rather than binding a name to it).
-            let info = ctx
-                .enum_variants
+            ctx.enum_variants
                 .get(n)
                 .ok_or_else(|| format!("codegen: unknown enum variant '{}'", n))?;
-            if field_vt != ValType::I32 {
+            if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
                 return Err(format!("codegen: enum tag pattern '{}' against a non-enum field", n));
             }
+            let variant_idx = *ctx.gc_types.variant_type_idx.get(n)
+                .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", n))?;
             Instruction::LocalGet(container_local).encode(body);
-            emitLoad(field_vt, offset, body);
-            if !info.field_types.is_empty() {
-                // Payload-carrying nested variant: the just-loaded field is a heap
-                // pointer, not the tag — dereference slot 0 to compare against it.
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
-                emitLoad(ValType::I32, 0, body);
-            }
-            Instruction::I32Const(info.tag).encode(body);
+            Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
-            Instruction::I32Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
-            compileFieldPatterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
+            compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
             Instruction::Else.encode(body);
             compileMatchArmsMulti(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
             Instruction::End.encode(body);
             Ok(())
         }
         ast::CasePattern::Int(n) => {
-            if field_vt != ValType::I64 {
+            if plumTypeToValtype(field_ty) != ValType::I64 {
                 return Err("codegen: integer match pattern against a non-Int field".to_string());
             }
             Instruction::LocalGet(container_local).encode(body);
-            emitLoad(field_vt, offset, body);
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
-            compileFieldPatterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
+            compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)?;
             Instruction::Else.encode(body);
             compileMatchArmsMulti(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
             Instruction::End.encode(body);
@@ -2926,7 +3044,7 @@ fn compileFieldPatterns(
                 .enum_variants
                 .get(name)
                 .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
-            if field_vt != ValType::I32 {
+            if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
                 return Err(format!("codegen: constructor pattern '{}' against a non-enum field", name));
             }
             if inner_fields.len() != info.field_types.len() {
@@ -2935,35 +3053,27 @@ fn compileFieldPatterns(
                     name, info.field_types.len(), inner_fields.len()
                 ));
             }
+            let inner_variant_idx = *ctx.gc_types.variant_type_idx.get(name)
+                .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", name))?;
             let key = pat as *const ast::CasePattern as usize;
             let slot = *ctx
                 .nested_class_scratch
                 .get(&key)
                 .ok_or_else(|| "internal codegen error: missing nested constructor pattern scratch slot".to_string())?;
             let nested_local = ctx.nested_class_scratch_base + slot;
-            let tag = info.tag;
             let inner_field_types = info.field_types.clone();
             Instruction::LocalGet(container_local).encode(body);
-            emitLoad(field_vt, offset, body);
-            Instruction::LocalSet(nested_local).encode(body);
-            // Same heap-pointer guard as the top-level constructor check: a
-            // payload-free sibling variant is a small int tag, not a pointer.
-            Instruction::LocalGet(nested_local).encode(body);
-            Instruction::I32Const(HEAP_BASE as i32).encode(body);
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
-            Instruction::I32GeU.encode(body);
-            Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+            Instruction::RefTestNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
-            Instruction::LocalGet(nested_local).encode(body);
-            Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
-            Instruction::I32Const(tag).encode(body);
-            Instruction::I32Eq.encode(body);
-            Instruction::Else.encode(body);
-            Instruction::I32Const(0).encode(body);
-            Instruction::End.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
+            // Narrow into `nested_local` now that ref.test just above proved it's safe.
+            Instruction::LocalGet(container_local).encode(body);
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
+            Instruction::RefCastNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
+            Instruction::LocalSet(nested_local).encode(body);
-            compileFieldPatterns(inner_fields, &inner_field_types, 0, nested_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, &mut |body, state| {
+            compileFieldPatterns(inner_fields, &inner_field_types, 0, nested_local, inner_variant_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, &mut |body, state| {
-                compileFieldPatterns(fields, field_types, fpos + 1, container_local, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+                compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
             })?;
             Instruction::Else.encode(body);
             compileMatchArmsMulti(rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state)?;
@@ -2994,13 +3104,13 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                 Some(idx) => Instruction::LocalGet(*idx).encode(body),
                 // Not a local: a bare reference to a top-level function used as a
                 // value (e.g. `each(double)`) — push its zero-capture trampoline
-                // closure's (compile-time-constant) struct pointer.
+                // closure's (pre-built by the `start` function) global.
                 None => {
-                    let offset = *ctx
+                    let global_idx = *ctx
                         .named_fn_values
                         .get(name.as_str())
                         .ok_or_else(|| format!("undeclared variable '{}'", name))?;
-                    Instruction::I32Const(offset as i32).encode(body);
+                    Instruction::GlobalGet(global_idx).encode(body);
                 }
             }
         }
@@ -3044,16 +3154,18 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             }
         }
         ast::Expr::Bool(b) => {
-            compileExpr(&b.left, body, ctx, state)?;
+            compileBoolConditionAsI32(&b.left, body, ctx, state)?;
-            compileExpr(&b.right, body, ctx, state)?;
+            compileBoolConditionAsI32(&b.right, body, ctx, state)?;
             match b.op {
                 ast::BoolOp::And => Instruction::I32And.encode(body),
                 ast::BoolOp::Or => Instruction::I32Or.encode(body),
-            }
+            };
+            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Not(inner) => {
-            compileExpr(inner, body, ctx, state)?;
+            compileBoolConditionAsI32(inner, body, ctx, state)?;
             Instruction::I32Eqz.encode(body);
+            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Compare(c) => {
             let is_float = matches!(inferLocalType(&c.left, ctx), PlumType::TFloat);
@@ -3080,10 +3192,11 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                 }
                 .encode(body);
             }
+            pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Ternary(t) => {
             let result_vt = plumTypeToValtype(&inferLocalType(&t.then, ctx));
-            compileExpr(&t.condition, body, ctx, state)?;
+            compileBoolConditionAsI32(&t.condition, body, ctx, state)?;
             Instruction::If(BlockType::Result(result_vt)).encode(body);
             compileExpr(&t.then, body, ctx, state)?;
             Instruction::Else.encode(body);
@@ -3121,34 +3234,16 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                             compileExpr(argExprOf(arg), body, ctx, state)?;
                         }
                         let trailing: Vec<&ast::Expr> = call.args.iter().skip(fixed_count).map(argExprOf).collect();
-                        let count = trailing.len() as i32;
-                        let size = 8 * (count + 1);
-                        let scratch_key = expr as *const ast::Expr as usize;
-                        let scratch_idx = *ctx
-                            .classcall_scratch
-                            .get(&scratch_key)
-                            .ok_or_else(|| "internal codegen error: missing variadic-call scratch slot".to_string())?;
-                        let scratch_local = ctx.classcall_scratch_base + scratch_idx;
-                        Instruction::GlobalGet(ctx.bump_global).encode(body);
-                        Instruction::LocalSet(scratch_local).encode(body);
-                        Instruction::GlobalGet(ctx.bump_global).encode(body);
-                        Instruction::I32Const(size).encode(body);
-                        Instruction::I32Add.encode(body);
-                        Instruction::GlobalSet(ctx.bump_global).encode(body);
-                        Instruction::LocalGet(scratch_local).encode(body);
-                        Instruction::I64Const(count as i64).encode(body);
-                        emitStore(ValType::I64, 0, body);
                         let elem_vt = plumTypeToValtype(&elem_ty);
+                        let array_type_idx = *ctx
+                            .gc_types
+                            .variadic_array_type_idx
+                            .get(&elem_vt)
+                            .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
-                        for (i, arg_expr) in trailing.iter().enumerate() {
+                        for arg_expr in &trailing {
-                            Instruction::LocalGet(scratch_local).encode(body);
                             compileExpr(arg_expr, body, ctx, state)?;
-                            emitStore(elem_vt, 8 * (i as u64 + 1), body);
                         }
-                        Instruction::LocalGet(scratch_local).encode(body);
+                        Instruction::ArrayNewFixed { array_type_index: array_type_idx, array_size: trailing.len() as u32 }.encode(body);
                         let func_idx = ctx
                             .func_ids
@@ -3179,7 +3274,9 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
         }
         ast::Expr::TypeName(n) => match ctx.enum_variants.get(n) {
             Some(info) if info.field_types.is_empty() => {
+                let global_idx = *ctx.singleton_globals.get(n)
+                    .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' has no singleton global", n));
-                Instruction::I32Const(info.tag).encode(body);
+                Instruction::GlobalGet(global_idx).encode(body);
             }
             Some(info) if !info.values.is_empty() => {
                 // A discriminant variant's own declared literal values ARE its
@@ -3195,45 +3292,24 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             None => return Err(format!("codegen: type name '{}' is not yet supported as a value", n)),
         },
         ast::Expr::ClassCall(call) => {
+            // struct.new needs every field value pushed in DECLARATION order (not
+            // `call.fields`'s written order) immediately before the single
+            // construction instruction — no intermediate scratch pointer needed at
+            // all, unlike the old bump-pointer-then-store approach.
             let fields = ctx
                 .classes
                 .get(&call.type_name)
                 .ok_or_else(|| format!("codegen: unknown class '{}'", call.type_name))?
                 .clone();
-            let size = (fields.len() as i32) * 8;
-            let scratch_key = expr as *const ast::Expr as usize;
+            let class_type_idx = *ctx.gc_types.class_type_idx.get(&call.type_name)
-            let scratch_idx = *ctx
-                .classcall_scratch
-                .get(&scratch_key)
-                .ok_or_else(|| "internal codegen error: missing classcall scratch slot".to_string())?;
+                .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", call.type_name))?;
-            let scratch_local = ctx.classcall_scratch_base + scratch_idx;
-            // base = bump_global; bump_global += size (runtime bump allocation, so every
-            // call — even inside a loop — gets a fresh, non-overlapping region).
-            Instruction::GlobalGet(ctx.bump_global).encode(body);
-            Instruction::LocalSet(scratch_local).encode(body);
-            Instruction::GlobalGet(ctx.bump_global).encode(body);
-            Instruction::I32Const(size).encode(body);
-            Instruction::I32Add.encode(body);
-            Instruction::GlobalSet(ctx.bump_global).encode(body);
-            for fa in &call.fields {
+            for (field_name, _) in &fields {
-                let (field_idx, field_ty) = fields
+                let fa = call.fields.iter().find(|fa| &fa.name == field_name)
-                    .iter()
-                    .position(|(n, _)| n == &fa.name)
-                    .map(|i| (i, fields[i].1.clone()))
-                    .ok_or_else(|| format!("codegen: unknown field '{}' on class '{}'", fa.name, call.type_name))?;
+                    .ok_or_else(|| format!("codegen: class '{}' missing field '{}'", call.type_name, field_name))?;
-                Instruction::LocalGet(scratch_local).encode(body);
                 compileExpr(&fa.value, body, ctx, state)?;
-                let offset = (field_idx as u64) * 8;
-                match plumTypeToValtype(&field_ty) {
-                    ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                    ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                    _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
-                };
             }
-            Instruction::LocalGet(scratch_local).encode(body);
+            Instruction::StructNew(class_type_idx).encode(body);
         }
         ast::Expr::Attribute(attr) => {
             let obj_ty = inferLocalType(&attr.object, ctx);
@@ -3245,39 +3321,33 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                     };
                     match ctx.classes.get(&class_name) {
                         Some(fields) => {
-                            let (field_idx, field_ty) = fields
+                            let field_idx = fields
                                 .iter()
                                 .position(|(n, _)| n == field_name)
-                                .map(|i| (i, fields[i].1.clone()))
                                 .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                            let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
+                                .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
                             compileExpr(&attr.object, body, ctx, state)?;
-                            let offset = (field_idx as u64) * 8;
-                            match plumTypeToValtype(&field_ty) {
-                                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                            Instruction::StructGet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
-                                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
-                            };
                         }
-                        // Not a class: fall back to a discriminant enum's shared params.
+                        // Not a class: fall back to a discriminant enum's shared params,
+                        // declared directly on the enum's SUPERTYPE (see
+                        // `buildGcTypeRegistry`'s `EnumSuper` arm) — no `ref.cast` to any
-                        // Slot 0 is always the variant's tag, so field N lives at slot N+1 —
+                        // particular variant needed, since every variant has the exact
-                        // NOT the same offset a class field of the same index would use.
+                        // same field list as the supertype itself.
                         None => {
                             let params = ctx
                                 .enum_params
                                 .get(&class_name)
                                 .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
-                            let (field_idx, field_ty) = params
+                            let field_idx = params
                                 .iter()
                                 .position(|(n, _)| n == field_name)
-                                .map(|i| (i, params[i].1.clone()))
                                 .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+                            let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
+                                .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
                             compileExpr(&attr.object, body, ctx, state)?;
-                            let offset = ((field_idx + 1) as u64) * 8;
-                            match plumTypeToValtype(&field_ty) {
-                                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                            Instruction::StructGet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
-                                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
-                            };
                         }
                     }
                 }
@@ -3328,13 +3398,13 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
 }
 /// Compiles a variant-construction call. A payload-free variant (`None`, called as
-/// `None()` rather than used bare) is just its tag. A payload variant bump-allocates
+/// `None()` rather than used bare) is its pre-allocated singleton global. A payload
-/// `[tag: i32][field0][field1]...` (8-byte stride per slot, matching class field
+/// variant pushes its field values in order and does `struct.new` into its own
-/// layout) and leaves the base pointer on the stack.
+/// concrete variant type.
 fn compileVariantConstruction(
     info: &EnumVariantInfo,
     call: &ast::FnCall,
-    expr: &ast::Expr,
+    _expr: &ast::Expr,
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
@@ -3345,78 +3415,45 @@ fn compileVariantConstruction(
             call.name, info.field_types.len(), call.args.len()
         ));
     }
+    let variant_type_idx = *ctx.gc_types.variant_type_idx.get(&call.name)
+        .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", call.name))?;
     if info.field_types.is_empty() {
+        // Pre-allocated singleton (this migration plan's Decision 2) — not a fresh
+        // struct.new per reference.
+        let global_idx = *ctx.singleton_globals.get(&call.name)
+            .ok_or_else(|| format!("codegen: payload-free variant '{}' has no singleton global", call.name))?;
-        Instruction::I32Const(info.tag).encode(body);
+        Instruction::GlobalGet(global_idx).encode(body);
         return Ok(());
     }
+    // struct.new needs every field value pushed, in order, immediately before the
-    let size = (1 + info.field_types.len() as i32) * 8;
+    // single construction instruction — positional args already match field
-    let scratch_key = expr as *const ast::Expr as usize;
+    // declaration order (unlike named class-field construction), so no reordering
-    let scratch_idx = *ctx
+    // is needed here.
-        .classcall_scratch
-        .get(&scratch_key)
+    for arg in &call.args {
-        .ok_or_else(|| "internal codegen error: missing variant-call scratch slot".to_string())?;
-    let scratch_local = ctx.classcall_scratch_base + scratch_idx;
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
-    Instruction::LocalSet(scratch_local).encode(body);
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
-    Instruction::I32Const(size).encode(body);
-    Instruction::I32Add.encode(body);
-    Instruction::GlobalSet(ctx.bump_global).encode(body);
-    Instruction::LocalGet(scratch_local).encode(body);
-    Instruction::I32Const(info.tag).encode(body);
-    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
-    for (i, (arg, field_ty)) in call.args.iter().zip(info.field_types.iter()).enumerate() {
         let arg_expr = match arg {
             ast::Arg::Positional(e) => e,
             ast::Arg::Keyword { value, .. } => value,
             ast::Arg::Pair { value, .. } => value,
         };
-        Instruction::LocalGet(scratch_local).encode(body);
         compileExpr(arg_expr, body, ctx, state)?;
-        let offset = ((i + 1) as u64) * 8;
-        match plumTypeToValtype(field_ty) {
-            ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-            ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-            _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
-        };
     }
-    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::StructNew(variant_type_idx).encode(body);
     Ok(())
 }
-/// Emits a width-appropriate store for a heap slot: `[addr, value]` -> memory.
-fn emitStore(vt: ValType, offset: u64, body: &mut Vec<u8>) {
-    match vt {
-        ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }),
-        ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }),
-        _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }),
-    }.encode(body);
-}
-/// Emits a width-appropriate load for a heap slot: `[addr]` -> value.
-fn emitLoad(vt: ValType, offset: u64, body: &mut Vec<u8>) {
-    match vt {
-        ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }),
-        ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }),
-        _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }),
-    }.encode(body);
-}
-/// Emits a static (compile-time-known) length-prefixed string as a fresh data
+/// Emits a static (compile-time-known) string literal as a fresh passive data
-/// segment, pushing its address.
+/// segment, pushing a `Str` array built from it via `array.new_data`. `Str`'s wasm-gc
+/// representation is a plain `array<i8>` (see Decision 4 of the wasm-gc migration
+/// plan) — no length prefix needed, unlike the old bump-allocator layout.
 fn compileStaticString(text: &str, body: &mut Vec<u8>, state: &mut ModuleState) {
     let bytes = text.as_bytes();
-    let offset = state.next_string_offset;
-    let mut data = Vec::with_capacity(4 + bytes.len());
-    data.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
-    data.extend_from_slice(bytes);
-    state.next_string_offset += data.len() as u32;
+    let data_index = state.passive_segments.len() as u32;
-    state.data_segments.push((offset, data));
+    state.passive_segments.push(bytes.to_vec());
+    let str_type_idx = withGcTypes(|r| r.str_type_idx);
+    Instruction::I32Const(0).encode(body);
-    Instruction::I32Const(offset as i32).encode(body);
+    Instruction::I32Const(bytes.len() as i32).encode(body);
+    Instruction::ArrayNewData { array_type_index: str_type_idx, array_data_index: data_index }.encode(body);
 }
 /// Lowers a string literal that contains at least one `{expr}` interpolation.
@@ -3447,8 +3484,9 @@ fn compileInterpolatedString(
                         Instruction::Call(ctx.int_to_string_func).encode(body);
                     }
                     PlumType::TBool => {
+                        let str_ref = withGcTypes(|r| gcRef(r.str_type_idx));
-                        compileExpr(expr, body, ctx, state)?;
+                        compileBoolConditionAsI32(expr, body, ctx, state)?;
-                        Instruction::If(BlockType::Result(ValType::I32)).encode(body);
+                        Instruction::If(BlockType::Result(str_ref)).encode(body);
                         compileStaticString("True", body, state);
                         Instruction::Else.encode(body);
                         compileStaticString("False", body, state);
@@ -3474,9 +3512,10 @@ fn compileInterpolatedString(
     Ok(())
 }
-/// Compiles a closure *literal* at its construction site. Snapshots each captured free
+/// Compiles a closure *literal* at its construction site. Snapshots each captured
-/// variable's CURRENT value into a fresh heap env struct, then builds the 2-word closure
+/// free variable's CURRENT value into a fresh env struct (`struct.new`), then wraps
+/// it with the closure's table index into the shared `{table_idx, env}` closure
-/// struct `{table_index @0, env_pointer @8}` and leaves its pointer on the stack.
+/// struct and leaves its ref on the stack.
 fn compileClosureLiteral(
     cl: &ast::Closure,
     body: &mut Vec<u8>,
@@ -3488,58 +3527,29 @@ fn compileClosureLiteral(
         .closures
         .get(&key)
         .ok_or_else(|| "internal codegen error: closure literal was not discovered by the discovery pre-pass".to_string())?;
-    let scratch_off = *ctx
-        .closure_scratch
-        .get(&key)
-        .ok_or_else(|| "internal codegen error: missing closure scratch slot".to_string())?;
-    let env_scratch = ctx.closure_scratch_base + scratch_off;
-    let closure_scratch = env_scratch + 1;
-    // Bump-allocate the env struct: one 8-byte slot per captured variable.
+    // Build the closure struct directly on the stack: push table_idx, then build the
-    let env_size = (info.free_vars.len() as i32) * 8;
+    // env struct (snapshotting each captured free variable's current value from the
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
+    // enclosing function's local), then wrap both into the shared closure struct.
-    Instruction::LocalSet(env_scratch).encode(body);
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
-    Instruction::I32Const(env_size).encode(body);
+    Instruction::I32Const(info.table_idx as i32).encode(body);
-    Instruction::I32Add.encode(body);
-    Instruction::GlobalSet(ctx.bump_global).encode(body);
-    // Snapshot each free variable's current value from the enclosing function's local.
-    for (i, (name, ty)) in info.free_vars.iter().enumerate() {
+    for (name, _) in &info.free_vars {
         let local_idx = *ctx
             .locals
             .get(name)
             .ok_or_else(|| format!("codegen: captured variable '{}' is not a local in the enclosing scope", name))?;
-        Instruction::LocalGet(env_scratch).encode(body);
         Instruction::LocalGet(local_idx).encode(body);
-        emitStore(plumTypeToValtype(ty), (i as u64) * 8, body);
     }
-    // Bump-allocate the 2-word closure struct.
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
-    Instruction::LocalSet(closure_scratch).encode(body);
-    Instruction::GlobalGet(ctx.bump_global).encode(body);
-    Instruction::I32Const(16).encode(body);
-    Instruction::I32Add.encode(body);
-    Instruction::GlobalSet(ctx.bump_global).encode(body);
-    // table_index @ offset 0
-    Instruction::LocalGet(closure_scratch).encode(body);
-    Instruction::I32Const(info.table_idx as i32).encode(body);
+    Instruction::StructNew(info.env_type_idx).encode(body);
-    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
-    // env_pointer @ offset 8
-    Instruction::LocalGet(closure_scratch).encode(body);
+    Instruction::StructNew(ctx.gc_types.closure_type_idx).encode(body);
-    Instruction::LocalGet(env_scratch).encode(body);
-    Instruction::I32Store(MemArg { offset: 8, align: 2, memory_index: 0 }).encode(body);
-    // The closure value is its struct pointer.
-    Instruction::LocalGet(closure_scratch).encode(body);
     Ok(())
 }
-/// Compiles a call to a closure-typed local via `call_indirect`. Stack order matches the
+/// Compiles a call to a closure-typed local via `call_indirect`. The local is
+/// statically typed `anyref` (closures share that placeholder type — see
+/// `plumTypeToValtype`), so every read of its fields `ref.cast`s down to the shared
+/// concrete closure struct type first. Stack order matches the closure function's
-/// closure function's signature `(env_ptr, ...args)`: push the env pointer, then each
+/// signature `(env, ...args)`: push the env, then each argument, then the table
-/// argument, then the table index (the `call_indirect` operand).
+/// index (the `call_indirect` operand).
 fn compileClosureCall(
     call: &ast::FnCall,
     body: &mut Vec<u8>,
@@ -3550,6 +3560,7 @@ fn compileClosureCall(
         .locals
         .get(&call.name)
         .ok_or_else(|| format!("codegen: closure '{}' is not a local", call.name))?;
+    let closure_type_idx = ctx.gc_types.closure_type_idx;
     // Prefer the exact signature recorded when this local was assigned a closure
     // *literal* (see `closure_local_sigs`) — it's already correct. Otherwise (e.g.
@@ -3562,7 +3573,7 @@ fn compileClosureCall(
                 PlumType::TFun(p, r) => (p, *r),
                 other => return Err(format!("codegen: '{}' is not callable (type {:?})", call.name, other)),
             };
-            let mut sig_params = vec![ValType::I32]; // env pointer
+            let mut sig_params = vec![ValType::Ref(RefType::ANYREF)]; // env pointer
             for p in &param_ptypes {
                 sig_params.push(plumTypeToValtype(p));
             }
@@ -3578,16 +3589,18 @@ fn compileClosureCall(
         .get(&sig_key)
         .ok_or_else(|| format!("internal codegen error: no call_indirect type for closure '{}'", call.name))?;
-    // env pointer (struct offset 8)
+    // env (closure struct field 1)
     Instruction::LocalGet(closure_local).encode(body);
+    Instruction::RefCastNonNull(HeapType::Concrete(closure_type_idx)).encode(body);
-    Instruction::I32Load(MemArg { offset: 8, align: 2, memory_index: 0 }).encode(body);
+    Instruction::StructGet { struct_type_index: closure_type_idx, field_index: 1 }.encode(body);
     // real arguments
     for arg in &call.args {
         compileExpr(argExprOf(arg), body, ctx, state)?;
     }
-    // table index (struct offset 0) — the call_indirect operand
+    // table index (closure struct field 0) — the call_indirect operand
     Instruction::LocalGet(closure_local).encode(body);
+    Instruction::RefCastNonNull(HeapType::Concrete(closure_type_idx)).encode(body);
-    Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
+    Instruction::StructGet { struct_type_index: closure_type_idx, field_index: 0 }.encode(body);
     Instruction::CallIndirect { type_index, table_index: 0 }.encode(body);
     Ok(())
 }
@@ -3617,12 +3630,9 @@ fn compileClosureBody(
         cctx: checkCtxOf(&ctx.classes, &ctx.methods, &ctx.enum_variants, &ctx.enum_params),
         named: Vec::new(),
         named_set: Default::default(),
-        classcall_scratch: HashMap::new(),
         match_scratch: HashMap::new(),
-        next_classcall_slot: 0,
-        closure_scratch: HashMap::new(),
-        next_closure_slot: 0,
         nested_class_scratch: HashMap::new(),
+        nested_class_scratch_types: Vec::new(),
         next_nested_class_slot: 0,
         variadic_for_scratch: HashMap::new(),
         next_variadic_for_slot: 0,
@@ -3654,13 +3664,6 @@ fn compileClosureBody(
         idx += 1;
     }
-    let classcall_scratch_base = idx;
-    let classcall_count = collector.classcall_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
-    for _ in 0..classcall_count {
-        groups.push(ValType::I32);
-        idx += 1;
-    }
     let match_scratch_base = idx;
     let mut match_scratch_index: HashMap<usize, u32> = HashMap::new();
     for (ptr, types) in collector.match_scratch.iter() {
@@ -3672,9 +3675,14 @@ fn compileClosureBody(
     }
     let nested_class_scratch_base = idx;
+    // Each slot is declared with its OWN concrete variant ref type (not a uniform
+    // placeholder) — `struct.get` on a constructor-pattern match requires the local
-    let nested_class_scratch_count = collector.nested_class_scratch.values().copied().max().map(|m| m + 1).unwrap_or(0);
+    // holding the narrowed (`ref.cast`) value to be statically typed as that exact
+    // variant, and different slots very likely narrow to different variants.
-    for _ in 0..nested_class_scratch_count {
+    for vname in &collector.nested_class_scratch_types {
+        let variant_idx = withGcTypes(|r| *r.variant_type_idx.get(vname)
+            .unwrap_or_else(|| panic!("internal codegen error: variant '{}' missing from the GC type registry", vname)));
-        groups.push(ValType::I32);
+        groups.push(gcRef(variant_idx));
         idx += 1;
     }
@@ -3686,12 +3694,6 @@ fn compileClosureBody(
         idx += 2;
     }
-    let closure_scratch_base = idx;
-    let closure_scratch_count = collector.closure_scratch.values().copied().max().map(|m| m + 2).unwrap_or(0);
-    for _ in 0..closure_scratch_count {
-        groups.push(ValType::I32);
-    }
     if groups.is_empty() {
         body.push(0);
     } else {
@@ -3702,22 +3704,20 @@ fn compileClosureBody(
         }
     }
-    // Restore each captured free variable from the env struct (local 0) at entry.
+    // Restore each captured free variable from the env struct (local 0, statically
+    // `anyref` — `ref.cast` down to THIS closure's own concrete env type) at entry.
-    for (i, (name, ty)) in info.free_vars.iter().enumerate() {
+    for (i, (name, _)) in info.free_vars.iter().enumerate() {
         let local_idx = *locals.get(name).expect("free var local was assigned above");
         Instruction::LocalGet(0).encode(&mut body); // env pointer
-        emitLoad(plumTypeToValtype(ty), (i as u64) * 8, &mut body);
+        Instruction::RefCastNonNull(HeapType::Concrete(info.env_type_idx)).encode(&mut body);
+        Instruction::StructGet { struct_type_index: info.env_type_idx, field_index: i as u32 }.encode(&mut body);
         Instruction::LocalSet(local_idx).encode(&mut body);
     }
     let local_ctx = LocalCtx {
         locals,
-        classcall_scratch_base,
-        classcall_scratch: collector.classcall_scratch,
         match_scratch_base,
         match_scratch_index,
-        closure_scratch_base,
-        closure_scratch: collector.closure_scratch,
         nested_class_scratch_base,
         nested_class_scratch: collector.nested_class_scratch,
         variadic_for_scratch_base,
@@ -3733,9 +3733,10 @@ fn compileClosureBody(
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
+        gc_types: &ctx.gc_types,
+        singleton_globals: &ctx.singleton_globals,
         type_env: RefCell::new(base_env),
         closure_local_sigs: RefCell::new(HashMap::new()),
-        bump_global: ctx.bump_global,
     };
     compileBlockAsFnBody(&cl.body, &mut body, &local_ctx, state, info.ret_vt)?;

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -362,24 +362,34 @@ fn runMainF64(bytes: &[u8]) -> f64 {
     main.call(&mut store, ()).expect("main should not trap")
 }
-/// Runs a `() -> Str`-returning `main`, reading the length-prefixed
+/// Runs a `() -> Str`-returning `main`, reading the returned `array<i8>` GC value
+/// back out byte-by-byte via wasmtime's host-side GC ref API (`Str` has no length
+/// prefix of its own now — `array.len` is native, see Decision 4 of the wasm-gc
+/// migration plan) — untyped `Func::call` is used because `main`'s wasm return type
-/// `[len: u32][utf8 bytes]` string back out of the module's exported memory.
+/// is a concrete `(ref $Str)`, not one `get_typed_func` can name directly.
 fn runMainStr(bytes: &[u8]) -> String {
     let engine = gcEngine();
     let module = wasmtime::Module::new(&engine, bytes).expect("module should be loadable");
     let mut store = wasmtime::Store::new(&engine, ());
     let instance = wasmtime::Instance::new(&mut store, &module, &[]).expect("module should instantiate");
-    let main = instance
-        .get_typed_func::<(), i32>(&mut store, "main")
-        .expect("main should have signature () -> i32");
-    let ptr = main.call(&mut store, ()).expect("main should not trap") as u32 as usize;
-    let memory = instance.get_memory(&mut store, "memory").expect("module should export memory");
+    let main = instance.get_func(&mut store, "main").expect("module should export main");
-    let mut len_bytes = [0u8; 4];
+    let mut results = [wasmtime::Val::null_any_ref()];
-    memory.read(&store, ptr, &mut len_bytes).expect("string length read should be in bounds");
+    main.call(&mut store, &[], &mut results).expect("main should not trap");
+    let any_ref = match &results[0] {
+        wasmtime::Val::AnyRef(Some(r)) => *r,
+        other => panic!("main should return a non-null anyref (Str), got {:?}", other),
+    };
+    let array = any_ref.unwrap_array(&store).expect("Str's returned anyref should be a GC array");
+    let len = array.len(&store).expect("array.len should succeed");
-    let len = u32::from_le_bytes(len_bytes) as usize;
+    let mut bytes_out = Vec::with_capacity(len as usize);
-    let mut str_bytes = vec![0u8; len];
+    for i in 0..len {
-    memory.read(&store, ptr + 4, &mut str_bytes).expect("string bytes read should be in bounds");
+        let byte = match array.get(&mut store, i).expect("array.get should succeed") {
+            wasmtime::Val::I32(b) => b as u8,
+            other => panic!("Str array element should be i32, got {:?}", other),
+        };
+        bytes_out.push(byte);
+    }
-    String::from_utf8(str_bytes).expect("string bytes should be valid utf8")
+    String::from_utf8(bytes_out).expect("string bytes should be valid utf8")
 }
 #[test]