plum

Simpler language: modules

Docs: game docs for plain games, one scene style

Simpler language: no inheritance

plans: simpler language file patterns

Simpler language: plain games and one scene style

plans: simpler language sizes

Simpler language T1: baseline benchmark of master

plans: a simpler language, approved, on its own branch

Report type errors inside string interpolation

FBIP stage 1: pilot and verdict, and the simpler language plan

plans: FBIP stage 1 owns

fip fun: a compile-time guarantee of in-place updates

FBIP stage 1: switch, stronger proof, Array.with, and fusion fixes

plans: top-level functions with receivers, module namespaces

plans: FBIP stage 1, keep the chain

plans: FBIP stage 1, T4 example

plans: FBIP stage 1

Game engine refactor: Game struct, main as the entry, plum run

plans: FBIP review plan, game engine refactor

Move compiler/tests to tests at the top level

Compiler cleanup phase 6: tests in Plum

Compiler cleanup phase 5: file splits and type kinds

Docs: a short scene style guide, move internal notes out of the way

Simplify the README and rewrite the docs

Check a closure's self-calls in the checker

Compiler cleanup phase 4: node ids, spans and typed codegen

Move plum-tooling and scripts under compiler/

backlog: move plum-tooling and scripts under compiler/ before phase 4

plans: cleanup phase 4 (node ids, spans, typed codegen); backlog: FBIP behind a flag

Move Rust crates under compiler/, rename std and examples

Io as a built-in primitive with extern methods

AGENTS.md: use a fresh subagent once one nears 75% context; backlog order

Compiler cleanup phase 3b: pass-list driver and Diagnostic errors

Explicit function generics; single letters are plain names

Build speed: one test binary per crate, editor assets only for dist builds

Language simplification run D3: remove the old error syntax

Language simplification run D2: port std, examples and tests to Option/Result

Language simplification run D1: std Option/Result, postfix ? and ! unwrap

decisions: keep postfix ! as unwrap sugar; run D design and D1 plan

Language simplification run C: subtyping, no traits, no union enums

decisions: single inheritance (one embedded struct = base), built in run C

decisions: run D uses Option/Result with postfix ? as the only sugar

backlog: language ideas to discuss later (single inheritance, no init, one error form, Pony)

AGENTS.md: push with repo-push after every commit

AGENTS.md: commit only, no pushing

AGENTS.md: work directly on master, no worktrees

Language simplification run B: one product type, struct

docs: run B T5 owns fixtures

docs: run B T5 owns

docs: run B T4 owns ctors.rs

docs: run B T4 owns embeds/layout fixes

docs: run B T3 owns checker cleanup

docs: run B T7 owns every isValue/isRecord site

docs: run B T4 lists layout changes

docs: run B T2 owns two tests

docs: run B T2 split

docs: language simplification run B plan

docs: AGENTS.md: run cargo clean-all -y after each merged plan or phase

Language simplification run A: no generators, variadics, value enums or Seq; one loop form; list and map literals

grammar: delete fun_star corpus (generators removed; T6)

tests: delete generator-only test and fixture (T11)

docs: run A T11 owns README

docs: run A T11 owns explicit

std: delete Seq (generators removed; T4)

docs: run A T6 owns explicit

docs: run A T4 owns

docs: run A T10 owns List.plum

docs: run A T2 owns explicit

docs: run A T9 owns explicit

docs: run A T9 owns

docs: run A owns after T2/T3

docs: decide Option/Result enums replace error sets, T? and null (run D)

docs: run A: one for form, no Seq

docs: backlog: tree Map and constant map literals (later)

docs: run A keeps the range keyword

docs: run A plan split

docs: language simplification run A plan

docs: language simplification review plan

Merge branch 'superlite/compiler-cleanup-3a'

docs: backlog: decide whether traits are still needed (notes and benchmark evidence)

docs: language simplification scope (errors, =, generators, variadics, value enums, struct)

Merge master into compiler-cleanup-3a

Compiler cleanup phase 3a: per-compile state, no fusion globals

docs: decide to remove traits and union enums (records with embedding + override instead)

docs: kids' games review plan (queued last) and Balloon Pop draft

docs: phase 3a T1 split

docs: compiler cleanup phase 3a plan

Compiler cleanup phase 2b: one front end, one compile entry, no Expr::Paren

docs: phase 2b T7 owns the tests it touched

docs: backlog: move Rust crates under compiler/ after the refactor

docs: phase 2b T2 owns list

docs: phase 2b plan split

docs: compiler cleanup phase 2b plan

Merge compiler cleanup phase 2a

Compiler cleanup phase 2a: deterministic output, shared walker, generics in one place, plum-host

docs: Elm/Roc-style error reporting for the self-hosted compiler

docs: phase 2a T4 owns closure_spec_test

docs: self-hosting design and groundwork review plan

docs: plan for Io as a built-in primitive with extern methods

docs: phase 2a T16 owns host lockfiles

docs: phase 2a plan split (rename, generics, host tasks)

docs: compiler cleanup phase 2a plan

Compiler cleanup phase 1: dead code out, small duplicates merged, shared test-support crate

docs: compiler cleanup phase 1 plan; explicit function generics queued after phase 2

docs(plans): compiler cleanup plan re-verified on 217e404 (written by another session)

format: blank line after the module line

Input step 3: typed messages for the functional scene; TRMC typing fix

Input steps 1 and 2: shared Input with keys, onInput on actors

Game scenes: methods on types instead of free functions; scene styles doc

format: one argument per line for multi-line calls and field lists

docs: backlog of planned and open items

Language restrictions: Io capability, per-field mut, pattern casing, own removed

docs(plans): compiler cleanup and architecture review plan (written by another session)

examples: consolidate 39 files into 25 topical ones (tests unchanged: 408); assets and tools move under games/

Remove own: ownership checker, own-only tests and corpus; own_inplace tests become unique_inplace

docs: plan example consolidation and games/assets move (T25)

examples: mutable games move to games/imperative (T16), io-style entry points (T13)

docs: after FBIP, record merges into an immutable struct with compiler-chosen boxing

docs: queue native inline variants before FBIP; FBIP waits for a benchmark

docs: update/render component names; std imperative folder task

docs: component-style functional game in restrictions T14; decision record updated

docs(plans): restrictions T11 benchmarks the three scene implementations against the own-era numbers

docs: record the November 2026 language and scene decisions

docs(plans): language restrictions: per-field mut instead of mut record; FBIP is the next plan

docs(plans): language restrictions: Io capability instead of io fun

plum: --no-fusion and --explain-fusion flags replace the env vars

Supercompiler: fusion of pure producer/consumer pairs, uniqueness and cell reuse

docs(plans): language restrictions review plan (immutable records + mut record, io effects, pattern casing, fusion before lowering, expression-bodied candidates)

Functional scenes at feature parity: Anim, Ui, tagged hit-testing

empty_record_embed e2e test: use xs.at(i) so the embedded source parses

Move the pure and functional scene styles into their own folders

codegen_tests: account for closure specialisation copies

Pure scene graph on enums: Node record + Kind enum, Custom(actor: Actor)

docs(plans): state/view parity review plan; pure-scene-enums plan notes

docs(plans): supercompiler: uniqueness inference stage to test whether own is needed

docs(plans): pure scene enums: Custom(actor: Actor), no Msg; ownership fix task

docs(plans): pure scene enums: game kinds stay records in a union enum

docs(plans): pure scene graph on enums review plan

hosts: start the wasmtime GC heap at 64 MiB

docs(plans): supercompiler review plan

Closure specialisation; allocation-free actions; direct scene traversal

trmc_test: guard that std List.map stays within 3x of a build with a presized GC heap

trmc_test: count struct.new in specialised copies too

Unboxed variants, enum init, List -> Slice, std cons List

forms: regression test for for-range over a type with fun* items

Tail calls round 2: closure and error-union tail calls, single-pass TRMC, fast dev GC

docs(plans): tail calls round 2 plans; post-tail-call benchmark rows

Tail calls: self tail calls as loops, return_call, tail modulo cons; break depth fix

codegen: regression tests for break/continue inside match arms in loops

tail calls: wire trmc::rewrite into typedSource; plum-core test dev-deps

tail calls: plan; default FnCall.tail at construction sites; run markTailCalls in typedSource

Recursive state/view; fix param reassignment codegen; own record docs

own record: ownership checker, in-place spread codegen, scene on own; state/view Orb Run

own: carry isOwn through trait and embed lowering

own: default isOwn/ownSelf at AST construction sites

docs(plans): own record phase B review and machine plan

Pure scene graph, phase A (std/game PureScene, Actions, SceneTree, SceneInput)

Functional-style gaps: typed closures, fn return types, tail calls

docs(plans): functional-style gaps review plan

examples: functional.plum operations as enum methods; loops section

refresh-editors: install native binaries as new files

docs(plans): remove outdated and unbuilt plans; fix stale status lines

docs(plans): delete shelved enum/union split plan

Inline record variants and = match bodies

docs(plans): inline variants + = match plans; enum/union split shelved

Record embedding and override

examples: Orb Run World functions become World methods

docs(plans): enum/union split review plan (parked)

Record constructors from the header and init; field defaults removed

Field defaults on struct, record and trait fields

std/Json: encode/decode via toJson/fromJson; static calls on type parameters

docs(plans): Orb Run scene review plan

game_scene: keep animating at game over

examples: Orb Run on the scene graph (game_scene.plum); README immediate vs scene

docs(plans): traits machine plan and run log

vscode grammar: highlight trait

T8: docs and examples

T7: editor support

T10: box-free trait layout (wasm-gc subtyping)

T10: box-free trait layout (wasm-gc subtyping)

T9: Scene on trait Actor

T8: docs and examples

T5: field access through a trait

T4: checker trait rules

T6: codegen and run tests

T4: checker trait rules

T5: field access through a trait

T7: editor support

T2: trait lowering

T2: trait lowering

T3: formatter and highlighting

T1: grammar and parser

checker: infer field-assignment statements in closure bodies

docs(plans): closure field-assignment fix review plan

checker test: cover plum-std/game in the unresolved-infer-vars sweep

Move the game-engine std modules (Game, Scene, Color, Vec2) to plum-std/game; LSP std index is recursive

README: Scene z-index, sortChildren, culling and the layer recipe

web-test: stress_world fixture (20k y-sorted sprites, culling) and benchmark results

scene demo: y-sorted, culled crowd of walkers with toFront on click

std/Scene: z-index, toFront/toBack, stable in-place sortChildren, and Scene2D-style culling areas

docs(plans): scene z-index, sortChildren and culling review plan

Game bridge: instantiate plum.wasm without WebAssembly.Module.imports (Safari); web-test --browser webkit, --expect-unsupported-webgpu, --no-module-introspection

plum_bridge: render-target textures are premultiplied (unpremultiply on sample, premultiplied clear), bound the bind-group cache; rendertarget fixture covers a translucent target

README, benchmark and docs/game.png for the renderer features

Orb Run: additive orb glow; scene demo: minimap rendered into a texture

textureCreate, renderTarget, blendMode (Blend) in std/Game, the bridge and the headless runner; rendertarget fixture; web-test --expect-pixel

plum_bridge: SDF glyph atlas text through the normal batch; text_sizes fixture

plum_bridge: HiDPI backing store and GPU device-loss recovery; web-test --dpr and --lose-device

plum_bridge: 16 texture slots per draw call (per-vertex slot, switch over 16 bindings)

web-test: report GPU draw calls per frame (draws); interleave fixture with 8 generated textures

docs(plans): renderer features review plan

README: browser-only games flow, std/Scene guidance, headless runner, browser check

web-test: always the own renderer, --assets passthrough; benchmark outcome note; regenerate docs/game.png

plum game: serve the web build on 127.0.0.1 and open the browser; -o writes a static build

plum-game: drop macroquad, Pixi and the command buffer; headless wasmtime runner, canonical gpu bridge

web-test README: document phase split

Add per-frame phase split to web measurement; rewrite renderer benchmark with gpu/cmd/scene matrix

Add std/Scene (Plum scene graph), SceneCmd, scene example and stress fixtures

Add the gpu web renderer: own WebGPU batcher with a command-buffer decoder

Merge branch 'superlite/render-mem' into superlite/render-experiments

Add Mem linear-memory primitive and GameCmd command-buffer game API

docs(plans): record browser-only/WebGPU-only rulings

plum-game: command-buffer decoder, native cmd mode, PLUM_GAME_MEASURE timing

docs(plans): render experiments spec (batcher, command buffer, Plum scene graph)

Add a PixiJS web renderer (plum game --web --renderer pixi) and a benchmark

Report an unclosed delimiter at its opener; hint suggests a bare return body

Report parse errors at the offending token with a hint for `()`, in the loader and LSP

docs(README): playwright-rs browser check

style: cargo fmt

Add plum-game/web-test: playwright-rs browser check for web game builds

Game host: sound (load/play/loop/stop/volume), example music and effects, quick start docs

Move sprite generator out of the asset dir, reject symlinks escaping the asset root, discard-target test

Add Orb Run example game with generated sprite sheet; generic Games docs

Game host: generic texture/file/circle API, remove KaM decoders and viewer

Discarding a non-Unit call result is a compile error; add '_ := expr' discard

docs(plans): game host milestone 1 plan, progress and incidents

T7: incidental files

T4: native host: Backend, wasmtime binding, macroquad, recorder

T7: incidental files

T5: web bridge + `plum game` + README

T5: web bridge + `plum game` + README

T4: native host: Backend, wasmtime binding, macroquad, recorder

T7: incidental files

T5: web bridge + `plum game` + README

fix(kam): size the minimap colours up front; Array.push returns a new array

T4: native host: Backend, wasmtime binding, macroquad, recorder

T4: native host: Backend, wasmtime binding, macroquad, recorder

T6: KaM map viewer (P1)

T7: incidental files

T1: export fun + Str bridge

T2: std Game API + import stubs

T3: plum-game crate + KaM asset decoders

style: cargo fmt --all

tooling: editor refresh copies queries/syntaxes; rebuild LSP on core/checker changes

pascal-case-consts: PascalCase constants, always Type.Name

tooling: indent after an unfinished if/else/while/for/match/test or = header

tooling: LSP offers and auto-imports std namespaces; queries cover struct/record/match

docs(README): planned performance work

docs: Buffer stays as the string builder

feat: zero-copy Str views; remove ByteSlice and []Byte

feat: packed Array[Byte]; List views via slice(i, j)

docs: simplify slices design to List views + zero-copy Str

docs: slices + List design (Option B, copying sub-slice append, error-union get)

refactor(std): no free functions; every std function is a static

feat: a fun without self is a static; Type.f() and x.f() are checked

fix: bare generic type name inside its own methods compiles (applyOwnGenerics pre-pass)

test: restore coverage for 8 behaviors found uncovered after dedupe

test: dedupe checker Rust tests (246 -> 61), rejection cases as table tests (146 rows)

test: dedupe codegen Rust tests (152 -> 82); drop unused greetForInterpolationTest

test: dedupe core/cli Rust tests (144 -> 106), table-driven formatter/loader cases

examples: one file per concept, visitors removed, game_loop added; duplicate Plum tests removed (434 -> 375)

fix: reject == on functions and Unit

feat: Byte struct fields; assert report falls back without toStr; plum test runs only the named files' tests; MapPoint test moved out of std

perf: Map is an insertion-ordered open-addressing hash table (dense entries + probe index), grows at 75%

test: struct-of-arrays probe tests from review

perf: Array[struct] stored as struct-of-arrays (one native array per leaf), no per-element boxing

docs: README restructure - one owner per example/rule, types sections reordered

docs: merge duplicated README passages

docs/test: Array[T] value arrays are unboxed (i64/f64/i32); stale anyref comment fixed

refactor: remove PlumType::TStr; Str is an ordinary named type

perf: bytesEqual intrinsic for Str.eq

refactor: Str + and == are ordinary Plum methods; concat/eq wasm helpers removed

refactor: byteToStr in Plum; Int interpolation via Int.toStr; int_to_string wasm helper removed

refactor: Bool.parse and Bool.toStr live in primitive Bool; builtin Bool.toStr removed

docs(plans): progress log through Str/Json/Array follow-ups

test: Str edge cases from final review

perf: Str wraps an exact-length []Byte directly (was Str{Buffer{arr,len}})

perf: Str methods linear loops; plain-string replace/replaceAll/search/deburr; drop regex stubs

perf: Json parser/escaper loops instead of per-char recursion; parseString returns Str

refactor: real CheckCtx field for primitive generics

feat: annotated local declarations (name: Type := value)

feat: Array[T] is a generic primitive, not a fake single-variant enum; legacy exemption removed

docs(plans): union enums Phase B done

fix: member values fall back to their enum's methods

docs: dop_visitor header describes record members

T9: drop Json legacy exemption

T9: Json + README

fix: exhaustiveness through union member sub-patterns

T8: migrate inline payload variants to record members; legacy syntax errors on

T7 review: Bool is a builtin union member; unions + try/for/test regression tests

T7: checker unions.rs (restorePlan, optional/err member wrap)

T7: pipeline wiring + e2e

T5 coerce test + T6 review fixes: narrowing pending scoped per && operand and per item, for-clause bind shadows

T5: checker auto-dispatch

fix: parser union tests use raw parse

T4/T6/T3-review: granted-file follow-ups (checker fixture, union_lower mod, review tests)

T6: applyPlan rewrite

T4: checker patterns + narrowing

T3: checker coercions

T2: parseSource resolves union members

T2: resolve + plan recorder

T1: grammar + parser

docs(plans): union enums Phase B machine plan

docs(plans): struct/record Phase A done

T1: core syntax + lowering

T3: record migration

fix: lsp keywords and README snippet for struct/record

T2: tooling queries

T1: core syntax + lowering

T4: README

docs(plans): struct/record + union enums review plan, Phase A machine plan

docs(plans): review residuals done

fix: recovered call failures don't reposition errors; const-shaped patterns on non-enums rejected

fix: digit type and variant names (E1, A1) parse

fix: checker errors point at the failing call, not the fn header

fix: checker reports unknown methods on static consts

fix: name the file in positioned type errors

fix: positioned integer-literal overflow error

docs(plans): map literal done — progress, rulings, incidents

T1: review — assert desugared Pair call carries the pair's position

T3: Map("a" => 1) examples + README

T1: pair syntax + desugar — `k => v` is sugar for Pair(k, v), any key expression

T2: review — negative Int keys + duplicates regression test

T2: Map.init variadic

docs(plans): map literal constructor plan

docs(plans): review residuals plan (approved)

fix: optional reassign/field-store coercion, reject optional==value, keep literal-overflow errors through the loader merge

feat: pattern if (if/else if/while/inline with Pattern := expr, guards)

docs(plans): pattern if

chore: remove .recall session history

docs: refresh README, plans and example descriptions for current language

feat!: optionals (null, ?:, if/while binding), try prefix replaces postfix ?, literal overflow error

docs(plans): optionals (null, ?:, if/while binding), try prefix, literal overflow fix

feat!: primitive namespaces and built-in APIs, associated consts and statics, Number removed

docs(plans): primitive namespaces/built-in APIs, associated consts, Number removed

chore: audit docs, comments and editor support against the current language

fix: catch return error.X instead of a special catch-default rule; unique catch binders

feat!: error.Name values, error sets (error X = A | B, X!T), fail removed

docs(plans): error-sets plan approved

docs(plans): Zig error values/sets — error.Name, return, error X = A | B, X!T

feat!: inline if expression replaces the ternary; postfix ? binds tight

fix: error sets don't split GC types; match arms must be in the error set

fix(errors): fail Missing is the absent value in a T? slot; nested error unions as success values

feat!: Zig-style errors, step E4: migrate std/examples/docs/tests, delete Try/tag unions/payload tags/??/? |e|; T? is !T [Missing]; fail/? file path in AST

feat(codegen): Zig-style error unions: !T multi-value lowering, fail/?/!/catch/?., boxed heap slots, nullable interop

feat(checker): Zig-style error unions: !T sets, fail/catch/?/!, error-set inference; unambiguous pinned-set syntax

feat!: lowercase true/false bool literals; True/False removed

feat(syntax): Zig-style errors grammar: !T, postfix !, catch, fail; remove legacy syntax hints

docs(plans): task B — lowercase true/false literals

docs(plans): no hints for obsolete syntax; migrate everything in E4

feat!: every for is 'for x := range src'; Int.until/to/downTo replace global range

docs(plans): pre-task R uses Go-style for x := range src

docs(editors): iteration cheat sheet, value enum docs; highlight/LSP for for/extend/Seq

docs(plans): pre-task R — n.times()/a.until(b)/to/downTo replace range

docs(plans): Zig-style errors — ?, !, catch, fail; no tag unions or Try

feat!: typed for lowering, fun* methods, entries(), extend, Seq[T]

refactor(std): drop closure iteration methods from List and Map

refactor: move range into std/Iter, delete std/Range

fix: stateful host RNG; evaluate assert operands once in test blocks

fix(editors): highlight value/extern in VS Code; complete value in LSP

docs(plans): zig-generics build log

feat!: fun* iterators with *T and yield; closure-free chaining; range in std

docs(plans): T9 addendum — *T sequence params and closure-free chaining

docs(plans): T9 fun* iterators with *T and yield; range moves to std

fix: branch review fixes for generics, forms and auto-wrap

fix(lsp): handle block param types in local var inference

feat: inline fun for-forms with block params; std Iter forms; guard fix

feat: for <binders> := <source>, <clauses> with plain iteration

test(loader): fix duplicate const fixtures

feat(loader): clear error for duplicate top-level constants with both locations

fix: fn-field nested call args, heap-valued consts, value-enum nested patterns and field assign through heap fields

docs(plans): T8 = for x := form(...) iteration forms + inline user forms

feat: value enum — single-constructor, copy-semantics value types

docs(plans): T8 on hold pending user approval

feat(std): Array.filled, Grid, Set, Deque, Heap, seeded Random; typed consts

feat: T ! [A, B] error sugar, T? nullable sugar, auto Ok/Err wrapping

docs(plans): queue T8 near-free closures (inline non-escaping literals)

feat: fn-typed enum fields (record of functions); closures capture called fn params

docs(plans): T7 adds T ! [A, B] error sugar with auto Ok/Err wrapping

docs(plans): queue T7 nullable sugar T? = Try[T, [Missing]]

feat: duck-typed operators; README for Zig-style generics; results

docs(plans): value types are a single-constructor value enum, not a struct keyword

feat!: remove traits, generic bounds and the boxed/typeId runtime

fix(checker): strict missing methods on builtin receivers; exact call sites

feat(codegen)!: one compiled copy per generic instantiation, unboxed

feat(checker): duck-typed generics checked per instantiation

feat: narrow Int to i32 at extern boundaries; remove Bool.plum

docs(plans): zig-generics plan approved to run

docs(plans): fix wasm i32 wording in game plan

docs(plans): keep Int/Float as i64/f64; narrow Int to i32 at extern boundaries

docs(plans): game plan becomes browser-first simplified KaM port

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

docs(plans): mark game plan T1/T4 superseded

docs(plans): draft Zig-style generics + sized numbers plan; link from game plan

docs(plans): draft game engine plan (macroquad host, sized numbers, structs, SIMD)

feat!: Bool is a built-in i32 primitive

docs(plans): erased-generics build log

test: permanent erased-generics probes; drop stale monomorphization comments

docs: how generics compile (erasure, boxing at edges, dyn traits); results

refactor!: delete the monomorphizer; List on Array; reject bare generic types

feat(codegen)!: compile erased generics; stop monomorphizing

feat: trait names as types with typeId-header dyn dispatch

fix(checker): reject generic T returned as a concrete type; resolve typedSource vars

feat(checker): check generics structurally on the original source; add typedSource

feat(checker): structural TApp/TParam types with substitute/instantiate

fix(checker): enforce enum variant exhaustiveness in match (recursive through payloads)

docs(readme): handling errors with match, crashing and safe navigation sections

fix(checker): enforce tag exhaustiveness inside variant payloads (Err(Tag) arms)

docs(examples): multi-branch match error handling in error_propagation

docs(examples): replace Option-like example enums with Parcel/Reading

docs(plans): Roc-style error handling design, plan and build log

fix(codegen): Try/?? wording in error messages; add numeric/deep/state probes

chore: drop stale Option/Result references from comments and tests

fix(checker): resolve Ok/Err args from the expected type; tags win over same-named variants

docs(examples): migrate examples, LSP, editor syntax and README to Try + tags

fix(monomorphize): resolve a closure's own generic from cb's declared return

fix(syntax): elvis binds tighter than comparison; accept _ closure params

feat(std)!: replace Option/Result with Try and structural error tags

feat(hosts): link plum::crash host import (prints to stderr, then traps)

fix(codegen): crash import detection ignores string literals; add tag probe tests

feat(codegen): $Tag runtime representation, tag patterns, ? rewrap, crash import

fix(checker): refutable payload patterns don't cover a tag in exhaustiveness

feat(checker): structural tag-union types and Roc-style ? checking

feat(syntax): tag-union types, ?? default, crash stmt, ? |e| error mapping

build: add release binary tooling (cross, R2 upload, versioned README links)

feat: add plum-lsp language server with diagnostics and completion

docs(examples): drop unnecessary braces from numeric literal method calls

feat: add Groovy/Kotlin-style safe navigation operator (?.)

feat(cli): fix stale Helix grammar path and embed a precompiled grammar .so

docs: add plum CLI install instructions to README

docs(editor): update README and VSCode syntax for type removal + new operators

feat(lang): add elvis `?:` operator

feat(lang): add postfix `?` error-propagation operator

feat(lang): remove type/class entirely, enum is the only declaration form

fix(http): rebuild emptyHeaders on Map's real init(), not its old fields

feat(class/enum): mutable fields + Gleam-style spread update

fix: repair binary literals corrupted in plum-examples/basics.plum

rename folders

feat(number): add Number enum, migrate Int/Float methods, fix Float interpolation

improve enum

refactor(stdlib): move libs/std to top-level plum-std, gate Int/Float/Str imports

docs: trim README to a concise language feature tour

fix(format): preserve blank lines in class/enum bodies, closure body spacing

feat(plum): reserve brackets for generics, enum variant payloads use parens

docs: reformat README code blocks to match real plum format output

docs: update README for Bool/Str import-gating and stdlib additions

chore: fix stale Bool/Str doc comments and test fixture breakage

remove website

remove test

remove docs

feat(plum): make Bool an ordinary import-gated enum, no hardcoded prelude

refactor(libs/std): rename files to match their primary class name

feat(plum): make Str a real class instead of a special-cased primitive

feat(plum): add generic Array[T] primitive, rewrite Map as a real hash table

feat(plum-core): enforce imports-first, tests-grouped-last file ordering

feat(examples): convert dop_visitor to enum syntax, add OOP trait counterpart

feat(plum-cli): colored test output, actual/expected values on failure

feat(plum): remove expect, unify on assert, Spock-style test tree output

feat(plum): named enum variant fields, self-methods on enums/classes, inline match formatting

feat(plum): let match destructure a plain class like an enum variant

refactor(libs/std): move Duration's unit constructors to static methods

feat(plum): trait conformance checking, Stringable->ToStr, finish str.plum

feat(plum): class init() constructors, bare-variant enum sugar, match guards

fix(tree-sitter-plum): a ternary as a closure's inline body now parses correctly

fix(plum-checker): substitute a generic method's own extra generics in its body; ship Map.map

feat(libs/std): ship List.chunk/partition; add List.toStr; root-cause the last self-nesting bug

fix(plum-checker): stop the self-nesting generic-method stack overflow

test(libs/std): add Map test coverage; document two new compiler gaps found attempting Map.map

feat(libs/std): complete os/time/uuid, add Option/Result generics; fix several monomorphization/parser bugs

improvements

improvements

docs: update README known-gaps and close out wasm-gc migration plan

feat(libs/std): implement List's add/set/removeAt/remove/clear/reverse on wasm-gc

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

feat(plum-wasm-codegen): add wasm-gc type-section emitter (unconsumed) and GC-enabled test Engine

test: add scripts/test-examples.sh, an end-to-end examples smoke test

fix(tooling): update VSCode TextMate grammar for fun keyword, drop dead <Receiver> pattern

fix(examples): remove basics.plum's unused, nonexistent 'std/io' import

style: rename all Rust function/method names from snake_case to camelCase

style(libs/std): rename camelCase params to snake_case (os.plum, http.plum)

test(plum-checker): fix remaining <Receiver>-syntax test fixtures missed in the sweep

docs: update methods section for nested-only method declaration syntax

feat(libs/std): migrate remaining stdlib methods off <Receiver> syntax

test: migrate plum-checker/plum-wasm-codegen fixtures off <Receiver> syntax

refactor(plum-core): drop dead receiver-vs-return-type disambiguation from parse_fn

feat(grammar): remove top-level <Receiver> method annotation syntax

feat(plum-wasm-codegen): compile enum discriminant-value construction and field access

feat(plum-checker): validate enum discriminant values, enable field access on them

feat(plum-core): parse enum discriminant-value declarations

feat(grammar): add enum discriminant-value declarations

test: confirm nested type/enum methods behave identically to top-level ones

feat(plum-core): lift nested type/enum methods into top-level Fn items

feat(grammar): allow methods nested inside type/enum bodies

test: migrate embedded plum fixtures to `fun` keyword syntax

feat(libs/std,examples,test): migrate to `fun`-prefixed function syntax

feat(grammar): add `fun` keyword to function/method declarations

docs: add design spec for wasm-gc migration in codegen

remove stuff

feat(grammar): add subject-less guard-clause match arms

docs: add implementation plan for nested method declarations

docs: add implementation plan for enum discriminant values

docs: add implementation plan for guard-clause match arms

docs: add design specs for enum discriminant values and nested methods

docs: add design spec for guard-clause match arms

feat(examples): migrate types.plum, functions.plum, match.plum generics to bracket syntax

feat(libs/std): migrate stdlib generics to bracket syntax

test(plum-wasm-codegen): migrate test fixtures to bracket generics syntax

test(plum-checker): migrate test fixtures to bracket generics syntax

feat(plum-checker,plum-wasm-codegen): recognize uppercase generic params, use Type instead of ReturnType

fix(plum-core): derive trait method return type from type-kind child, not the wrong 'returns' field

fix(plum-core): stop return type from being mistaken for method receiver

feat(plum-core): parse bracket generics, drop ReturnType in favor of Type

feat(grammar): migrate generics to bracket syntax with uppercase letters

docs: add implementation plan for bracket generics syntax migration

docs: add design spec for bracket generics syntax migration

docs: add implementation plan for wiring up List's methods

docs: note List() explicit-fields fix in list-methods spec

docs: add design spec for wiring up List's remaining methods

docs: cross-file import resolution is no longer a known gap

fix(libs/std): list.plum imports std/option instead of relying on unresolved cross-file references

feat(plum-cli): resolve import via --lib-path using the new loader

feat(plum-core): add load_and_merge cross-file import loader

docs: correct cross-file-imports spec scope; add implementation plan

docs: add design spec for cross-file import resolution

docs: variadic parameters are no longer a known gap

feat(plum-wasm-codegen): compile for-v-in-variadic-param iteration

feat(plum-wasm-codegen): compile variadic call sites into a length-prefixed buffer

feat(plum-checker): type-check variadic call arity and for-in-variadic iteration

feat(plum-checker,plum-wasm-codegen): add PlumType::TVariadic representation

docs: add implementation plan for variadic parameters

docs: add design spec for variadic parameters

docs: field/attribute assignment is no longer a known gap

feat(plum-wasm-codegen): compile obj.field = value assignment targets

feat(plum-checker): type-check obj.field assignment targets

feat(plum-core): parse obj.field assignment targets into AssignTarget::Field

feat(tree-sitter-plum): add field_target rule for obj.field = value assignment

docs: add implementation plan for field/attribute assignment targets

docs: add design spec for field/attribute assignment targets

feat: close closures/match/interpolation known gaps in codegen

fix editor

fix editor

fix

docs: note nested-closure limitation in Known Gaps

docs+test: closures complete; add example and update README

feat(plum-wasm-codegen): compile closure literals and closure calls via a function table

feat(plum-wasm-codegen): add wasm function table + element section support

feat(plum-checker): infer closure literal types; type-check fn(...)-typed params

feat(plum-core): parse closure literals and fn(...) type annotations

feat(tree-sitter-plum): wire closure literals into expression position; add fn(...) type syntax

docs: add implementation plan for closures

docs: scope closures spec to ordinary-argument call syntax, not trailing-closure

docs: add design spec for closures

test(plum-wasm-codegen): cover same bare-generic-enum-param function at multiple instantiations

feat(plum-checker): support multiple concrete instantiations of the same generic enum

docs: revise generic-enum plan with bare-generic-typed-param fix as Task 1

docs: amend generic-enum spec with bare-generic-typed-param fix

docs: add implementation plan for generic-enum multi-instantiation

docs: add design spec for generic-enum multi-instantiation support

test(plum-checker): mark slow recursion-guard test as ignored by default

test+docs: generics monomorphization complete; extend examples, update known gaps

fix(plum-checker): stop masking type errors in specializations; resolve generic enum instantiation

feat(plum-checker): monomorphize generic classes/functions/methods/enums before checking and codegen

feat(plum-checker): core generics specialization primitives

docs: add implementation plan for generics monomorphization

docs: extend generics monomorphization spec to cover generic enums

docs: add design spec for generics monomorphization

docs: add implementation plan for tail-position and grammar gap fixes

docs+test: restore examples/match.plum to idiomatic bare-tail style; tail-position gap fixed

fix(plum-wasm-codegen): propagate a value through tail-position match/if without explicit return

fix(tree-sitter-plum): allow a full expression as a body's trailing statement

docs: add design spec for grammar trailing-statement and tail-position gaps

fix(plum-checker): reject a name declared as both a class and an enum variant

fix(plum-wasm-codegen): guard constructor-pattern match against payload-free sibling values

docs: note tail-position match/if return-value gap in Known Gaps

docs+test: general enum support is complete; update known gaps and example

feat(plum-wasm-codegen): compile general enum match patterns (tags + constructors)

feat(plum-wasm-codegen): compile general enum variant construction

fix(plum-checker): rewrite bare_enum_tag test to avoid unrelated grammar limitation

feat(plum-checker): general enum variant tags, field types, and construction checks

fix(tree-sitter-plum): document fn_argument_list/class_argument_list conflict rationale

feat(tree-sitter-plum): allow positional variant-construction calls

docs: add implementation plan for general enum support

docs: add design spec for general enum support in checker/codegen

fix(tree-sitter-plum): remove Nil/try/except, allow inline match bodies

docs: document the currently-implemented language syntax in README

test: add example programs covering the language's current syntax

fix(plum-wasm-codegen): assert/todo trap, tail-position If also diverges

feat(plum-wasm-codegen): class/method codegen, strings, match lowering

feat(plum-checker): class/method/self/match type checking

fix(tree-sitter-plum): fix match/generics/identifier/attribute grammar bugs

fix: address code review findings — bool literals, export policy, test hardening

feat(plum-cli): add compile subcommand wiring checker and codegen

test(plum-wasm-codegen): add factorial and give42 codegen tests

feat(plum-wasm-codegen): implement WasmModule, CompileCtx and compile_source

test(plum-checker): add error-case tests for type checker

fix(plum-checker): use plum_type_from_ast for return type in first pass

feat(plum-checker): implement type checker with unification

feat(plum-checker): add type definitions

chore: scaffold plum-checker and plum-wasm-codegen crates

docs: add wasm codegen + type checker implementation plan

docs: add wasm codegen + type checker design spec

fix: restore | operator spacing, add format_source_with_opts, reject --stdin --check

chore: remove old root src/ after workspace migration

feat: add plum-cli binary with format subcommand

test: add integration tests for format_source

feat: implement format_source wrapping topiary-core

fix: use body-anchored indent annotations instead of per-construct = tokens

fix: correct node names and indentation annotations in format.scm

feat: add Topiary format.scm formatting rules for Plum

refactor: restructure as Cargo workspace, add plum-core skeleton

docs: add CLI formatter implementation plan

docs: add CLI and formatter design spec

add cmake

more stuff

add cargo pkg

finish syntax

fix traits

fix tests

fix assign

fix tests

improve highlights

add helix

cleanup

improve string

improve

improve lang

improce code

get string working

add better syntax

changes

fix README.md

fix README

fix LICENSE

some changes

new rules

fix parser

improve syntax

new syntax

new syntax

more syntax

improve grammar

improve grammar

improve grammar

assign works

update tree-sitter and grammar

update readme

add vscode/treesitter

Update readme.md

updates

improve

add docs

update readme

updates

update

update

improve readme

update

add more code

improve syn

update

improve

add naming convention

lang changes

docs

docs

docs

docs

docs

docs

docs

docs

cleanup

add static functions on records

increment spec

add methods

new syn

spec

improve fn example

improve syn

langium

update

update readme

update

Fix pipes

fix tests

add const expressions

get more expressions working

Add functions

new spec

Add bindings and queries

update grammar

remove windows support

make fns work

new grammar

add menu example

improve grammar

remove indentation

split class tests

update names

add enums

intitial commit