Phase 6a: rename core vocabulary (game/main/component/archetype/system)

game/module -> program, main -> entry, component -> property,
archetype -> model, system -> handler. Done via a transitional self-hosting
bootstrap: parser accepts both -> reseed -> compiler source moved to new
keywords + parser tightened to new-only -> reseed (fixpoint holds). Old keywords
now rejected.

Token-safe corpus migration (tools/ludic-tools/rename_kw.c) leaves the LLVM
@main/entry: labels in emit strings untouched; goldens byte-identical. Editor
vocab (header/JetBrains/TextMate/emacs), check-docs wrapper, and doc fences
updated; error string 'unknown component' -> 'unknown property'. test.sh 14/14,
test-tools 28/0, check-vocabulary green. (Doc prose pass to follow.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

examples/chronorift.ludic

@@ -7,7 +7,7 @@
 # chronorift/, pulled in with `import`. Paths resolve relative to this file, and
 # each import is include-guarded so re-imports are free.
 # ============================================================================
-game ChronoRift {
+program ChronoRift {
   import "chronorift/world.ludic"      # components, entity archetypes, constants
   import "chronorift/rules.ludic"      # pure rules + map data (functions)
   import "chronorift/overworld.ludic"  # boot, movement, encounters, shop

examples/chronorift/combat.ludic

@@ -8,7 +8,7 @@
 enum KnightAct { Attack, Guard, Item, Flee }
 enum MageAct   { Attack, Heal, Guard }
 
-system Battle phase Update {
+handler Battle phase Update {
   if reg(R_MODE) == 1 {
     let k = key()
     for (e) in query [Stats, {Enemy}] {
@@ -144,7 +144,7 @@ system Battle phase Update {
   }
 }
 
-system CleanBattle phase LateUpdate {
+handler CleanBattle phase LateUpdate {
   if reg(R_MODE) != 1 {
     for (e) in query [Stats, {Enemy}] {
       despawn self()
@@ -152,7 +152,7 @@ system CleanBattle phase LateUpdate {
   }
 }
 
-system Meta phase Update {
+handler Meta phase Update {
   let k = key()
   if reg(R_MODE) == 2 {
     if k == 0 { setreg(R_ACK, 1) }

examples/chronorift/draw.ludic

@@ -1,6 +1,6 @@
 # draw.ludic — the Render system (overworld, battle, and overlay screens).
 
-system Draw phase Render {
+handler Draw phase Render {
   let m = reg(R_MODE)
   clear(0x101018)
 

examples/chronorift/overworld.ludic

@@ -1,6 +1,6 @@
 # overworld.ludic — boot, movement/encounter input, and the shop system.
 
-system Boot phase Start {
+handler Boot phase Start {
   load_png("assets/kenney/tiny-town/Tiles/tile_0000.png")      # 0 grass
   load_png("assets/kenney/tiny-town/Tiles/tile_0004.png")      # 1 tree
   load_png("assets/kenney/tiny-town/Tiles/tile_0025.png")      # 2 path
@@ -33,7 +33,7 @@ system Boot phase Start {
   setreg(R_POTION, 2)
 }
 
-system Control phase Input {
+handler Control phase Input {
   if reg(R_MODE) == 0 {
     for (p) in query [Pos, {Player}] {
       let k = key()
@@ -122,7 +122,7 @@ system Control phase Input {
 }
 
 # shop (at the house 'h' tile): buy potions with gold
-system Shop phase Update {
+handler Shop phase Update {
   if reg(R_MODE) == 4 {
     let k = key()
     if k == 'w' { setreg(R_CUR, max(0, reg(R_CUR) - 1)) }

examples/chronorift/world.ludic

@@ -1,17 +1,17 @@
 # world.ludic — the data model: components, entity archetypes, constants.
 # Imported by examples/chronorift.ludic. No `game` wrapper (this is a fragment).
 
-component Pos    { x: int = 0, y: int = 0 }
-component Actor  { kind: int = 0 }
-component Stats  { hp: int = 1, maxhp: int = 1, mp: int = 0, maxmp: int = 0,
+property Pos    { x: int = 0, y: int = 0 }
+property Actor  { kind: int = 0 }
+property Stats  { hp: int = 1, maxhp: int = 1, mp: int = 0, maxmp: int = 0,
                    atk: int = 1, def: int = 0, lvl: int = 1, xp: int = 0, guard: int = 0 }
-component Party  { slot: int = 0 }
+property Party  { slot: int = 0 }
 
 # Entity KINDS. Identity is stored as one integer per entity (L_kind), not as
 # an empty marker component. Query membership with {Player} / {Enemy}.
-archetype Player { Pos, Actor, Party, Stats }   # the controllable knight
-archetype Ally   { Party, Stats }               # backline mage (no overworld body)
-archetype Enemy  { Actor, Stats }               # battle foe
+model Player { Pos, Actor, Party, Stats }   # the controllable knight
+model Ally   { Party, Stats }               # backline mage (no overworld body)
+model Enemy  { Actor, Stats }               # battle foe
 
 const MW: int = 40
 const MH: int = 18

examples/hello.ludic

@@ -1,10 +1,10 @@
 # hello.ludic — smallest program that exercises the ECS pipeline
-game Hello {
+program Hello {
 
-  component Pos { x: int = 0, y: int = 0 }
-  component Vel { dx: int = 0, dy: int = 0 }
+  property Pos { x: int = 0, y: int = 0 }
+  property Vel { dx: int = 0, dy: int = 0 }
 
-  system Boot phase Start {
+  handler Boot phase Start {
     spawn Mob {
       Pos { x: 3, y: 4 }
       Vel { dx: 1, dy: 0 }
@@ -17,14 +17,14 @@ game Hello {
 
   # a system can declare the entities it operates on: the body then runs once
   # per match, with the components bound and self() giving that entity.
-  system Move phase FixedUpdate
+  handler Move phase FixedUpdate
     query (p, v) [Pos, Vel]
   {
     p.x = p.x + v.dx
     p.y = p.y + v.dy
   }
 
-  system Report phase Update {
+  handler Report phase Update {
     for (p) in query [Pos] {
       print_int(p.x)
       print_int(p.y)

examples/lib/arena.ludic

@@ -9,20 +9,20 @@
 # that: the same declaration binds a C, Rust or Zig library just as well. This
 # is how Ludic reaches the outside world without a C shim.
 # ============================================================================
-game Arena {
+program Arena {
 
   extern fn damage(attack: int, armour: int, roll: int) -> int = "damage"
   extern fn hits_to_kill(hp: int, attack: int, armour: int) -> int = "hits_to_kill"
   extern fn xp_for(level: int, kills: int) -> int = "xp_for"
 
-  component Fighter { hp: int = 30, attack: int = 9, armour: int = 2 }
+  property Fighter { hp: int = 30, attack: int = 9, armour: int = 2 }
 
-  system Boot phase Start {
+  handler Boot phase Start {
     spawn Hero { Fighter { hp: 40, attack: 12, armour: 3 } }
     spawn Orc  { Fighter { hp: 24, attack: 7,  armour: 1 } }
   }
 
-  system Fight phase Update {
+  handler Fight phase Update {
     for (f) in query [Fighter] {
       print_int(damage(f.attack, f.armour, 0))
       print_int(damage(f.attack, f.armour, 20))

examples/lib/combat.ludic

@@ -11,7 +11,7 @@
 # engine, a test harness, a scripting host. Non-exported functions stay private
 # to the library.
 # ============================================================================
-module Combat {
+program Combat {
 
   const CRIT_MULT: int = 2
 

examples/menu.ludic

@@ -2,7 +2,7 @@
 # block); the engine lays it out (stacked panel, padding/gap/alignment), draws
 # it (background, TrueType labels, focusable buttons), and routes keyboard focus
 # and activation. The game only loads a font, opens the UI, and reads clicks.
-game Menu {
+program Menu {
 
   const R_FONT: int = 0
   const R_MSG:  int = 1
@@ -19,13 +19,13 @@ game Menu {
     }
   }
 
-  system Boot phase Start {
+  handler Boot phase Start {
     setreg(R_FONT, font_load("/System/Library/Fonts/Supplemental/Arial.ttf"))
     ui_build()
     ui_open(UI_MainMenu)
   }
 
-  system Nav phase Update {
+  handler Nav phase Update {
     ui_tick(key())
     if ui_clicked(UI_NewGame)  { ui_set_text(UI_NewGame, "Starting...") }
     if ui_clicked(UI_Continue) { ui_set_text(UI_Continue, "No save") }
@@ -33,7 +33,7 @@ game Menu {
     if ui_clicked(UI_Quit)     { quit() }
   }
 
-  system Draw phase Render {
+  handler Draw phase Render {
     clear(0x0e0e16)
     ui_render()
     present()

examples/qdecl.ludic

@@ -9,29 +9,29 @@
 # the whole body — the loop header just moves into the declaration. The body runs
 # once per matching entity, and self() is that entity.
 # ============================================================================
-game QueryDecl {
-  component Battle { hp: int = 0, side: int = 0 }
-  component Pos { x: int = 0, y: int = 0 }
-  archetype Foe { Battle, Pos }
+program QueryDecl {
+  property Battle { hp: int = 0, side: int = 0 }
+  property Pos { x: int = 0, y: int = 0 }
+  model Foe { Battle, Pos }
 
-  system Seed phase Start {
+  handler Seed phase Start {
     spawn Foe { Battle { hp: 3, side: 1 } }
     spawn Foe { Battle { hp: 0, side: 1 } }
     spawn Foe { Battle { hp: -2, side: 0 } }
   }
 
-  system CleanBattle phase LateUpdate
+  handler CleanBattle phase LateUpdate
     query (b, p) [Battle, Pos, {Foe}] where b.hp <= 0 and b.side == 1
   {
     print_int(p.x)
     despawn self()
   }
 
-  system Census phase Render
+  handler Census phase Render
     query (b) [Battle]
   {
     print_int(b.hp)
   }
 
-  system Bye phase Render { quit() }
+  handler Bye phase Render { quit() }
 }

examples/scenes.ludic

@@ -4,16 +4,16 @@
 # LANGUAGE.md §"Scenes & layers"). It is deliberately excluded from test.sh.
 # Games that need scene-like states use a mode register + `machine` today, as
 # examples/chronorift does.
-game SceneDemo {
+program SceneDemo {
   const R_N: int = 0
 
-  system Boot phase Start { setreg(R_N, 0);  print_int(1000) }
+  handler Boot phase Start { setreg(R_N, 0);  print_int(1000) }
 
   scene Title start {
     on enter { print_int(1) }
     on exit  { print_int(2) }
     layer Main {
-      system Tick phase Update {
+      handler Tick phase Update {
         setreg(R_N, reg(R_N) + 1)
         print_int(100 + reg(R_N))
         if reg(R_N) >= 2 { enter Play }
@@ -25,14 +25,14 @@ game SceneDemo {
     on enter { print_int(3);  setreg(R_N, 0) }
     on exit  { print_int(4) }
     layer World {
-      system Step phase Update {
+      handler Step phase Update {
         setreg(R_N, reg(R_N) + 1)
         print_int(200 + reg(R_N))
         if reg(R_N) >= 2 { quit() }
       }
     }
     layer Hud {
-      system Draw phase Render { print_int(900) }
+      handler Draw phase Render { print_int(900) }
     }
   }
 }

examples/snake.ludic

@@ -3,10 +3,10 @@
 # general: compiled by the SAME unmodified ludicc + runtime as the JRPG.
 # No sprites/assets — pure primitives. Build: ./build.sh examples/snake.ludic
 # ============================================================================
-game Snake {
+program Snake {
 
-  component Pos { x: int = 0, y: int = 0 }
-  component Seg { order: int = 0 }
+  property Pos { x: int = 0, y: int = 0 }
+  property Seg { order: int = 0 }
 
   const GW: int = 20
   const GH: int = 15
@@ -39,9 +39,9 @@ game Snake {
     return 0
   }
 
-  system Boot phase Start { reset(0) }
+  handler Boot phase Start { reset(0) }
 
-  system Input phase Input {
+  handler Input phase Input {
     let k = key()
     if reg(R_MODE) == 0 {
       if k == 'w' { if reg(R_DIR) != 1 { setreg(R_DIR, 0) } }
@@ -55,7 +55,7 @@ game Snake {
     }
   }
 
-  system Move phase Update {
+  handler Move phase Update {
     if reg(R_MODE) == 0 {
       setreg(R_TICK, reg(R_TICK) + 1)
       if reg(R_TICK) >= 6 {
@@ -110,7 +110,7 @@ game Snake {
     }
   }
 
-  system Draw phase Render {
+  handler Draw phase Render {
     clear(0x0d1020)
     for gy in 0 .. GH {
       for gx in 0 .. GW {