bbcbddc | plum | pyrossh

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

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

bbcbddc — Peter John 2026-10-26T10:38:51+05:30

docs(plans): native lowercase wasm types only (i32/i64/f32/f64/bool), Bytes for packed storage

Files changed (2) hide show

docs/plans/2026-10-26-game-engine.md +20 -20
docs/plans/2026-10-26-zig-generics-and-numbers.md +44 -31

docs/plans/2026-10-26-game-engine.md CHANGED Viewed

@@ -1,7 +1,7 @@
 # Plum for games (macroquad host, sized numbers, value structs, SIMD)
 **Status:** draft. Planned only, not dispatched, because the user has more ideas to fold in first.
-**Superseded in part:** Design item 1 with T1 (sized numbers), and T4 (operator traits), now live in `2026-10-26-zig-generics-and-numbers.md`. That plan has the sized types with I32/F32 literal defaults, and no traits: operators are duck-typed methods, and enums replace trait types.
+**Superseded in part:** Design item 1 with T1 (sized numbers), and T4 (operator traits), now live in `2026-10-26-zig-generics-and-numbers.md`. That plan has the native wasm value types i32/i64/f32/f64 with i32/f32 literal defaults (lowercase; no U8/i32 — unsigned via explicit ops, packed bytes via `Bytes`), and no traits: operators are duck-typed methods, and enums replace trait types.
 **Goal:** Let Plum write game logic and rendering, running on a macroquad-based host. Natively first, then in the browser.
 **Architecture:** Plum source → checker → erased wasm-gc codegen → `plum-game`, a Rust crate built on macroquad and wasmtime that drives `init`/`update`/`draw` each frame.
 **Tech stack:** Rust, macroquad, wasmtime (GC, multi-value and SIMD enabled), wasm-encoder.
@@ -15,31 +15,31 @@ What the user decided:
 - Value types come from a new `struct` syntax.
 - Vectors and simd128.
-1. **Sized numbers.** `F32`, `I32` and `U32` are new built-in primitives (wasm `f32`/`i32`). `Byte` stays as u8, `Int` as i64 and `Float` as f64.
+1. **Sized numbers.** `f32`, `i32` and `i32` are new built-in primitives (wasm `f32`/`i32`). `Byte` stays as u8, `Int` as i64 and `Float` as f64.
-   - Ruling: `Float` is not changed to f32 (because Time millis, Json and parseFloat need f64; cost: game code writes `F32` explicitly).
+   - Ruling: `Float` is not changed to f32 (because Time millis, Json and parseFloat need f64; cost: game code writes `f32` explicitly).
-   - Arithmetic, comparisons and `toStr`/`parse*` exist per type, and explicit casts are `F32(x)`, `I32(x)` and so on.
+   - Arithmetic, comparisons and `toStr`/`parse*` exist per type, and explicit casts are `f32(x)`, `i32(x)` and so on.
    - Each type boxes at generic edges with its own typeId (8, 9 and 10).
-2. **Contextual literal typing.** A numeric literal takes its type from the expected type (annotation, param, field, operand) where that type is a sized type. So `x: F32 = 1.5`, `drawRect(10, 20, 32, 32)` and `v.x * 0.5` need no casts. With no expected type, literals default to `Int`/`Float` as today. A literal that doesn't fit the target (e.g. `I32 = 3_000_000_000`) is a compile error.
-3. **Value structs.** `struct Vec2(x: F32, y: F32)` has the same body syntax as a class, but has value semantics.
+2. **Contextual literal typing.** A numeric literal takes its type from the expected type (annotation, param, field, operand) where that type is a sized type. So `x: f32 = 1.5`, `drawRect(10, 20, 32, 32)` and `v.x * 0.5` need no casts. With no expected type, literals default to `Int`/`Float` as today. A literal that doesn't fit the target (e.g. `i32 = 3_000_000_000`) is a compile error.
+3. **Value structs.** `struct Vec2(x: f32, y: f32)` has the same body syntax as a class, but has value semantics.
    - In locals and params a struct is flattened into one wasm local/param per field, and it is returned with multi-value results.
    - Assigning copies it. A field can be assigned in place (`v.x += 1.0`), which mutates only that binding.
    - It is boxed (as a GC struct with a typeId) only when it flows into a `TParam`, trait slot, `List` element or closure capture.
    - `==` compares fields. Methods take `self` by value. Structs can't be recursive.
 4. **Operator traits.** `trait Add = add(other: Self) -> Self` (plus `Sub`, `Mul`, `Div`, `Neg` and `Eq`) maps `+ - * / -x ==` on non-primitive operands to those methods. Calls are resolved statically and are never dyn dispatched. `Mul` may also take a scalar RHS (`v * 2.0`) through an overload on the param type.
-5. **SIMD.** `F32x4` is a primitive (wasm `v128`) with lane-wise `+ - * /`, `F32x4.splat(x)`, `.x/.y/.z/.w` lane access, `dot`, `min`, `max` and `shuffle`. `plum-std/Math.plum` builds `Vec4`, `Quat` and `Mat4` (four `F32x4` columns) on top of it. `Vec2`/`Vec3` stay scalar structs, plus `lerp`, `clamp`, `perspective`, `lookAt` and `ortho`.
+5. **SIMD.** `f32x4` is a primitive (wasm `v128`) with lane-wise `+ - * /`, `f32x4.splat(x)`, `.x/.y/.z/.w` lane access, `dot`, `min`, `max` and `shuffle`. `plum-std/Math.plum` builds `Vec4`, `Quat` and `Mat4` (four `f32x4` columns) on top of it. `Vec2`/`Vec3` stay scalar structs, plus `lerp`, `clamp`, `perspective`, `lookAt` and `ortho`.
 6. **`plum-game` host (native).** A new crate built on macroquad and wasmtime.
-   - It loads `game.wasm`, calls the exported `init() -> Game` once, keeps the returned ref (a wasmtime `Rooted`), and every frame calls `update(g, dt: F32)` and `draw(g)`.
+   - It loads `game.wasm`, calls the exported `init() -> Game` once, keeps the returned ref (a wasmtime `Rooted`), and every frame calls `update(g, dt: f32)` and `draw(g)`.
    - Ruling: no global mutable state and no new language feature (because the state lives in the host; cost: the `Game` ref is passed on every call).
    - The extern API lives in `plum-std/Game.plum`:
-     - `clear(c: Color)`, `drawRect(x, y, w, h: F32, c: Color)`, `drawCircle`, `drawLine`, `drawText(s: Str, x, y, size: F32, c: Color)`;
+     - `clear(c: Color)`, `drawRect(x, y, w, h: f32, c: Color)`, `drawCircle`, `drawLine`, `drawText(s: Str, x, y, size: f32, c: Color)`;
-     - `loadTexture(path: Str) -> U32` (preloaded by the host before `init`), `drawTexture(t: U32, x, y: F32, c: Color)`;
+     - `loadTexture(path: Str) -> i32` (preloaded by the host before `init`), `drawTexture(t: i32, x, y: f32, c: Color)`;
      - `isKeyDown(k: Key) -> Bool`, `isKeyPressed`, `mousePos() -> Vec2`, `isMouseDown`, `screenSize() -> Vec2`;
-     - `playSound(s: U32)`, `setCamera2D(target: Vec2, zoom: F32)`.
+     - `playSound(s: i32)`, `setCamera2D(target: Vec2, zoom: f32)`.
    - Structs cross the boundary flattened, so `Color` is 4 f32 params. `Key` is a discriminant enum whose values match macroquad's `KeyCode`.
    - `plum game <file>` is a CLI subcommand that compiles the file and runs it in the host.
 7. **Custom rendering (v1).**
-   - `drawMesh(vertices: List[Vertex], indices: List[U16], texture: U32)`. The host copies the data per call.
+   - `drawMesh(vertices: List[Vertex], indices: List[i32], texture: i32)`. The host copies the data per call.
-   - `loadMaterial(vertexGlsl: Str, fragmentGlsl: Str) -> U32` and `useMaterial(m)` wrap macroquad's `Material`.
+   - `loadMaterial(vertexGlsl: Str, fragmentGlsl: Str) -> i32` and `useMaterial(m)` wrap macroquad's `Material`.
    - Zero-copy linear-memory buffers are deferred until profiling shows a need.
 8. **Browser host (later).** The JS glue instantiates Plum's wasm-gc module in the browser and forwards its imports to macroquad's own wasm32 build through JS. It is the same extern API, so game code doesn't change.
 9. **Out of scope:** WebGPU, `StructArray` flat storage, Plum→shader compilation, async and audio streaming.
@@ -52,7 +52,7 @@ Success criteria:
 ## Global constraints
 - Run `cargo test --workspace` and `cargo run -q -p plum-cli -- test plum-std plum-examples` after every task, and both must be green.
-- typeIds: Bool box 7 (from the built-in Bool work), F32 8, I32 9, U32 10, F32x4 box 11. Declared types still start at 16.
+- typeIds: Bool box 7 (from the built-in Bool work), f32 8, i32 9, i32 10, f32x4 box 11. Declared types still start at 16.
 - Enable wasmtime `wasm_simd`, `wasm_multi_value` and `wasm_gc` in every host.
 - The grammar changes (`struct` keyword, operator-trait resolution needs none) are regenerated with `tree-sitter generate --disable-optimizations`.
@@ -60,7 +60,7 @@ Success criteria:
 ```mermaid
 flowchart LR
-  S["game.plum: init/update/draw"] --> C["checker: F32/I32/U32, literal typing, struct, operator traits, F32x4"]
+  S["game.plum: init/update/draw"] --> C["checker: f32/i32/i32, literal typing, struct, operator traits, f32x4"]
   C --> G["codegen: flattened structs, multi-value, v128"]
   G -->|"game.wasm"| H["plum-game: wasmtime + macroquad loop"]
   H -->|"extern draw/input/audio"| M["macroquad"]
@@ -75,7 +75,7 @@ flowchart LR
   T2[literal typing]
   T3[struct value types]
   T4[operator traits]
-  T5[F32x4 + Math.plum]
+  T5[f32x4 + Math.plum]
   T6[plum-game host + Game.plum]
   T7[pong example + perf checks]
   T8[browser host]
@@ -91,10 +91,10 @@ flowchart LR
 ```
 ### T1 sized numbers
-Grammar unchanged, since these are type names. In checker/codegen, add F32/I32/U32 types, arithmetic and comparison per type, casts, boxing ids 8–10, and `Number.plum` methods (`toStr`, `parseF32`…). **Tests:** `f32_precision` (`F32(0.1) + F32(0.2)` prints `0.3` and its f32 bits are exact); `i32_wraps` (`I32(2147483647) + I32(1) == I32(-2147483648)`); `u32_compare_unsigned` (`U32(4000000000) > U32(1)`); `boxed_sized_roundtrip` through `List[F32]`, `Try[U32,[A]]` and `ToStr`.
+Grammar unchanged, since these are type names. In checker/codegen, add f32/i32/i32 types, arithmetic and comparison per type, casts, boxing ids 8–10, and `Number.plum` methods (`toStr`, `parseF32`…). **Tests:** `f32_precision` (`f32(0.1) + f32(0.2)` prints `0.3` and its f32 bits are exact); `i32_wraps` (`i32(2147483647) + i32(1) == i32(-2147483648)`); `u32_compare_unsigned` (`i32(4000000000) > i32(1)`); `boxed_sized_roundtrip` through `List[f32]`, `Try[i32,[A]]` and `ToStr`.
 ### T2 contextual literal typing
-In the checker, an expected sized type flows into literals. In codegen, literals are emitted at that width. **Tests:** `x: F32 = 1.5` gets no Float→F32 error; `drawRect(10, 20, 32, 32)` with F32 params; `v.x * 0.5`; overflow `I32 = 3000000000` is an error naming the type; an unannotated `1.5` is still Float.
+In the checker, an expected sized type flows into literals. In codegen, literals are emitted at that width. **Tests:** `x: f32 = 1.5` gets no Float→f32 error; `drawRect(10, 20, 32, 32)` with f32 params; `v.x * 0.5`; overflow `i32 = 3000000000` is an error naming the type; an unannotated `1.5` is still Float.
 ### T3 struct value types
 `struct` keyword in the grammar and parser (`ast::Item::Struct`). Checker: value semantics, no recursion, field assignment on bindings. Codegen: flatten to locals/params, multi-value returns, box at generic and trait edges. **Tests:** `struct_copy_semantics` (`b := a; b.x = 9.0; a.x == 1.0`); `struct_multi_value_return` (`fun mid(a, b: Vec2) -> Vec2`); `struct_in_list_boxes_roundtrip`; `struct_eq_fieldwise`; `recursive_struct_rejected`.
@@ -102,7 +102,7 @@ In the checker, an expected sized type flows into literals. In codegen, literals
 ### T4 operator traits
 `Add/Sub/Mul/Div/Neg/Eq` traits in `plum-std/Ops.plum`. The checker maps binary/unary ops on non-primitive operands to those methods, with static dispatch, scalar-RHS overloads, and errors like `Vec2 does not implement Add`. **Tests:** `vec2_add_mul_scalar` (`(Vec2(1,2) + Vec2(3,4)) * 2.0 == Vec2(8, 12)`); `neg`; `missing_op_trait_error`.
-### T5 F32x4 + Math.plum
+### T5 f32x4 + Math.plum
 v128 primitive, lane ops, `splat`/`dot`/`shuffle`, boxing id 11. `Math.plum`: Vec2, Vec3, Vec4, Quat, Mat4 (`mul`, `transpose`, `inverse`, `perspective`, `lookAt`, `ortho`, `translate`, `rotate`, `scale`), `lerp`, `clamp`. **Tests:** `mat4_identity_mul`; `mat4_inverse_roundtrip` (within 1e-5); `quat_rotate_90deg` (within 1e-6); `simd_ops_emitted` (the wasm contains `f32x4.mul`).
 ### T6 plum-game host + Game.plum
@@ -117,5 +117,5 @@ JS glue plus macroquad's wasm32 build, the same `Game.plum` API, and `plum game
 ## Open questions to settle before running
 - Will the user's further ideas change the scope or order? This plan is still a draft.
-- Should `Float` be renamed to `F64` (with `Int` → `I64`) for consistency, now that sized types exist?
+- Should `Float` be renamed to `f64` (with `Int` → `I64`) for consistency, now that sized types exist?
 - Should struct field mutation require `var` bindings, or is every binding mutable as today?

docs/plans/2026-10-26-zig-generics-and-numbers.md CHANGED Viewed

@@ -4,7 +4,7 @@
 **Goal:**
 - Replace traits and erased generics with Zig-style duck-typed generics: no bounds, a body checked per instantiation at the use site, and one compiled copy per type.
 - Use enums for mixed-type values.
-- Replace `Int`/`Float`/`Byte`/`Number` with sized primitives, with literals defaulting to `I32`/`F32` for games.
+- Replace `Int`/`Float`/`Byte`/`Number` with the native wasm value types `i32 i64 f32 f64` (plus `bool`), with literals defaulting to `i32`/`f32` for games.
 - Move Bool's remaining methods into the compiler.
 **Architecture:** parser → checker (structural `TApp`/`TParam` kept; a generic body is re-checked per concrete instantiation) → instantiation worklist (on-demand, reachable-only) → codegen (unboxed, no `$Obj`/dyn) → hosts.
@@ -17,22 +17,25 @@
 ## Design
 What the user decided:
-- Integer literals default to `I32` and float literals to `F32`.
+- Integer literals default to `i32` and float literals to `f32`. Later: only native wasm types, lowercase, no pretend widths (no u8/u32).
 - Traits are removed in favour of Zig-style duck typing, with one copy per type ("Zig-faithful").
 - Mixed types are handled with enums only (the Zig way).
 - Comptime covers duck-typed type params only, with no compile-time execution.
 - The `[T]` syntax is kept.
 - Reference: axelmagn.com "Zig traits": traits are a convention (records of functions passed explicitly), not a language feature.
-1. **Sized numbers.**
-   - Primitives: `I8 I16 I32 I64 U8 U16 U32 U64 F32 F64`. `Int`, `Float`, `Byte` and the `Number` enum are removed, with no aliases.
-   - Literals: an integer literal is `I32` and a float literal is `F32` unless the expected type says otherwise. Contextual typing (game plan item 2) is folded in here. A literal that doesn't fit its type is a compile error.
-   - Mixed widths never convert implicitly, so `I32 + I64` is an error. Casts are written `I64(x)`, `F32(x)`, etc.
-   - 8- and 16-bit types are stored as i32 and masked after arithmetic.
-   - Unsigned types use wasm's unsigned compare/div/rem/shift and `convert_u`.
-   - Ruling: std uses `I64`/`F64` explicitly where precision matters: `Time` millis, `Json` numbers, `parseI64`/`parseF64`, `Uuid`, `Random`. The cost is that std signatures change, but it avoids silent overflow (i32 millis wrap after about 24 days).
-   - Per-type `parse*`/`toStr` move to `Str` (`s.parseI32()`, …) and to compiler intrinsics. `Number.plum` is deleted.
-2. **Bool fully built in.** `toStr` becomes a compiler intrinsic, `parse` becomes `Str.parseBool() -> Try[Bool, [BadBoolStr]]`, and `and`/`or` are dropped. `Bool.plum` is deleted.
+1. **Native wasm value types only.** The user decided: no pretend-width types, lowercase names, and only what wasm has.
+   - Primitives are exactly the wasm value types `i32 i64 f32 f64`, plus `bool` (wasm i32 0/1).
+   - `Int`, `Float`, `Byte`, `Number`, `Bool`/`True`/`False` and every capitalized numeric name are removed, with no aliases.
+   - Rule: **lowercase = native wasm value type, Capitalized = heap/GC type** (`Str`, `List`, `Try`, user types).
+   - Literals: integers default to `i32` and floats to `f32` unless the expected type says otherwise. A literal that doesn't fit its type is a compile error. `true`/`false` are the bool literals.
+   - Widths never mix implicitly, so `i32 + i64` is an error. Casts are written `i64(x)`, `f32(x)`, `i32(x)` and so on. Truncation/wrap rules are wasm's own: `wrap`, `extend_s`, `trunc_sat_s` and `demote`/`promote`.
+   - **No unsigned types.** Unsigned operations are explicit methods that map 1:1 to wasm ops: `a.divU(b)`, `remU`, `ltU`/`gtU`/`leU`/`geU`, `shrU`, `toF32U`/`toF64U`, and `i64.fromU32(x)` (`extend_u`). Ruling: this matches the wasm instruction set exactly, so nothing claims a width it doesn't have. The cost is wordier unsigned code.
+   - **Bytes:** wasm-gc arrays do store packed 8-bit elements, so `Bytes` replaces `[]Byte`/`ByteSlice`. It is a built-in heap type backed by `array (mut i8)` that really is 1 byte per element. `b.get(i) -> i32` (`array.get_u`), `b.getS(i) -> i32` (`array.get_s`) and `b.set(i, v: i32)` (stores the low 8 bits). `Str`/`Buffer` use it. Ruling: the byte width shows up only where storage is really packed, never as a scalar type.
+   - Ruling: std uses `i64`/`f64` explicitly where precision matters: `Time` millis, `Json` numbers, `Uuid`, `Random`. i32 millis would wrap after about 24 days.
+   - `parse`/`toStr`: `toStr` and interpolation of primitives are compiler intrinsics. Parsing is `Str.parseI32/parseI64/parseF32/parseF64/parseBool() -> Try[…, [BadNumStr]|[BadBoolStr]]`. `Number.plum`, `Byte.plum` and `ByteSlice.plum` are deleted.
+   - Grammar: `i32`, `i64`, `f32`, `f64`, `bool`, `true` and `false` become reserved keywords. A type position accepts `primitive_type`. A cast like `i64(x)` parses as a call whose callee is a primitive type. They can no longer be used as identifiers.
+2. **Bool fully built in.** `bool` is a primitive and `Bool.plum` is deleted. `toStr` is an intrinsic, and `and`/`or` are dropped in favour of `&&`/`||`.
 3. **Duck-typed generics.**
    - Generic params carry no bounds (`[T]` only). Bound syntax and the `trait` item are removed from the grammar, and existing `trait`/`implements` source becomes a parse error with a migration hint.
    - A generic body is type-checked once per concrete instantiation, with `TParam`s substituted, at the point the instantiation is first needed.
@@ -41,12 +44,12 @@ What the user decided:
 4. **Instantiation (copy per type), on demand.**
    - The worklist starts at `main`, exported fns and tests. Each call site with concrete type args enqueues `(fn, [types])`.
    - Each key is checked and compiled once, and memoized.
-   - Generic types (`List[I32]`, `Try[Str, [A]]`) get one GC struct per distinct instantiation, keyed by the structural type, never by mangled strings.
+   - Generic types (`List[i32]`, `Try[Str, [A]]`) get one GC struct per distinct instantiation, keyed by the structural type, never by mangled strings.
    - Only reachable instantiations are produced, which avoids the old "every method for every specialization" problem.
-   - Names in wasm are only for debugging (`List[I32].map`).
+   - Names in wasm are only for debugging (`List[i32].map`).
    - Ruling: tag-union payload types now go through this structurally (because unions stop being name strings, generic tag payloads become possible; cost: TTags keys move into the instantiation key).
 5. **Unboxed runtime.** `$Obj`, `typeId` headers, `$Box*` and `$dyn$…` dispatchers are removed. Enum variants keep their exact GC subtypes for `match`. The closure ABI is typed per signature again, with no anyref boxing.
-6. **Mixed types via enums.** `List[Shape]` becomes `enum Shape = | Circle(r: F32) | Rect(w: F32, h: F32)` with methods that `match self`. `plum-examples/traits.plum` becomes `shapes.plum` written this way.
+6. **Mixed types via enums.** `List[Shape]` becomes `enum Shape = | Circle(r: f32) | Rect(w: f32, h: f32)` with methods that `match self`. `plum-examples/traits.plum` becomes `shapes.plum` written this way.
 7. **Operators are duck-typed.** `a + b` on non-primitive operands calls `a.add(b)` if that method exists for the instantiated type; likewise `sub`, `mul`, `div`, `neg`, `eq` (for `==`) and `lt` (for `<`). Calls are resolved statically per instantiation.
 8. **Explicit "trait values"** (the article's pattern) need no feature: a record of fn fields (`type Num[T](add: fn(T, T) -> T, zero: T)`) passed as an argument. When the argument is a top-level constant, the copy-per-type codegen calls its fns directly and they can be inlined. Document the pattern in the README.
 9. **Out of scope:** comptime execution (`comptime` blocks, reflection), separate compilation, and any global cap on instantiation count. A warning is printed above 200 instantiations of one generic.
@@ -54,13 +57,13 @@ What the user decided:
 Success criteria:
 - `plum test plum-std plum-examples` and `cargo test --workspace` are green.
 - A typical compile is ≤ 60 ms, against today's 20–25 ms erased. That's the agreed cost of copying per type.
-- `List[I32].map` in the wasm touches no boxes.
+- `List[i32].map` in the wasm touches no boxes.
 - A generic called with a type lacking a method fails with the use-site chain message.
 ## Global constraints
 - Both suites are green after every task. Regenerate the grammar only with `--disable-optimizations`.
-- Error wording: `in <fn>[<types>] (called at <file>:<line>): <Type> has no method '<m>'`; `cannot mix I32 and I64 without a cast`; `literal 3000000000 does not fit in I32`.
+- Error wording: `in <fn>[<types>] (called at <file>:<line>): <Type> has no method '<m>'`; `cannot mix i32 and i64 without a cast`; `literal 3000000000 does not fit in i32`.
 - No `$` name mangling anywhere. The instantiation key is `(item path, Vec<PlumType>)`.
 ## Tasks (sequential)
@@ -83,18 +86,23 @@ flowchart LR
   T6 --> T7
 ```
-### T1 sized numbers + literal typing
-Checker and codegen for the 10 primitives, unsigned ops, masking, casts, contextual literals (default I32/F32), and the mixing error. Tests:
-- `u8_wraps`: `U8(255) + U8(1) == U8(0)`.
-- `u32_unsigned_div`: `U32(4000000000) / U32(2) == U32(2000000000)`.
-- `i32_overflow_wraps`.
+### T1 native value types + literal typing
+Grammar: `i32 i64 f32 f64 bool true false` become reserved keywords and `primitive_type` is added to `type`; regenerate with `--disable-optimizations`. Parser, checker and codegen get the four numeric types, `bool` and the cast calls. Contextual literals default to i32/f32. Add the mixing error and the explicit unsigned methods. Tests:
+- `i32_overflow_wraps`: `i32(2147483647) + 1 == -2147483648`.
+- `unsigned_div_method`: `i32(-2).divU(2) == 2147483647`.
 - `f32_exact_bits` for `0.1`.
-- `literal_defaults`: `x := 5` is I32, `y := 1.5` is F32.
-- `mix_error`: `I32 + I64` is rejected.
-- `literal_overflow_error`.
-### T2 Bool/Number std removal
-Delete Bool.plum and Number.plum. Add intrinsic `toStr`, `Str.parseBool/parseI32/parseI64/parseF32/parseF64`, and move every `Int`→`I32`/`I64` and `Float`→`F32`/`F64` in plum-std (Time/Json/Uuid/Random get the 64-bit types). Tests: the existing std suites, plus `time_millis_no_wrap` (`nowMillis() > 2^31`).
+- `literal_defaults`: `x := 5` is i32, `y := 1.5` is f32.
+- `mix_error`: `i32 + i64` is rejected.
+- `literal_overflow_error`: `x: i32 = 3000000000`.
+- `keyword_not_identifier`: `i32 := 1` is a parse error.
+- `cast_trunc_sat`: `i32(f32(1e10)) == 2147483647`.
+### T2 Bytes + std migration off Int/Float/Byte/Bool
+Add the built-in `Bytes` (packed `array (mut i8)`, `get`/`getS`/`set`/`len`). `Str`/`Buffer` move to it. Delete Bool.plum, Number.plum, Byte.plum and ByteSlice.plum. Add intrinsic `toStr`/interpolation for primitives and `Str.parse*`. Rewrite every `Int`/`Float`/`Byte`/`Bool`/`True`/`False` in plum-std, choosing the width per use (i64/f64 for Time/Json/Uuid/Random). Tests:
+- the existing std suites;
+- `bytes_one_byte_per_elem`: the wasm declares `array (mut i8)`;
+- `bytes_get_u_vs_s`: storing 200 gives `get == 200` and `getS == -56`;
+- `time_millis_no_wrap`: `nowMillis() > 2147483647`.
 ### T3 per-instantiation checking
 Re-check generic bodies per concrete instantiation and produce the use-site chain errors. Bounds are removed from the checker. Tests:
@@ -105,10 +113,10 @@ Re-check generic bodies per concrete instantiation and produce the use-site chai
 ### T4 on-demand instantiation codegen
 Worklist from roots, one wasm fn/struct per `(item, types)`, structural keys, unboxed values, typed closures. Tests:
-- `one_copy_per_distinct_type`: List[I32] and List[Str] give 2 `map`s, and List[I32] used twice still gives 1.
+- `one_copy_per_distinct_type`: List[i32] and List[Str] give 2 `map`s, and List[i32] used twice still gives 1.
 - `unreachable_generic_not_emitted`.
 - `no_boxes_in_list_i32_map` (wasm inspection).
-- `generic_tag_payload`: `Try[I32, [Bad(T)]]` works.
+- `generic_tag_payload`: `Try[i32, [Bad(T)]]` works.
 ### T5 remove traits, dyn, boxing
 Remove the grammar's `trait`/`implements`/bounds, the checker's trait tables and coercion, and codegen's `$Obj`/typeId/`$Box*`/`$dyn` and erased paths. Tests: `trait_syntax_rejected_with_hint`. Workspace and plum suites green. Report the LOC delta.
@@ -123,8 +131,13 @@ Remove the grammar's `trait`/`implements`/bounds, the checker's trait tables and
 ### T7 migration, docs, bench
 Migrate every example, test and README snippet to sized types and no traits. Update the README sections "How generics compile" (now per-type copies, Zig-style) and "Numbers". Rebuild the scratchpad bench and record compile times and wasm sizes against the erased baseline (typical 20–25 ms, Bool.wasm 19 KB). Update the game-engine plan's T1/T4 to point here.
+## Rulings (user said "you decide")
+- Ruling: the instantiation warning stays at 200 copies of one generic. It is only a warning, never an error.
+- Ruling: `"{x}"` on a type with no `toStr` is a duck-typed compile error at the use site. Primitives, `Str`, `bool` and tag unions format through compiler intrinsics.
+- Ruling: `Str` stays capitalized, because it's a GC heap type, following "lowercase = wasm value type".
+- Ruling: comptime performance means copies per type (Design item 4) and unboxed native values everywhere. That's why the generic boxing paths are removed in T5.
 ## Open questions
 - Will the user's further ideas change scope or order? This is still a draft.
-- What should happen when `List[I32]` and `List[I64]` are both used? That's two copies, which is fine, but should there be a per-generic instantiation-count warning threshold other than 200?
-- Should string interpolation `"{x}"` on a type without `toStr` be an error at the use site (duck-typed) or fall back to a default representation?