wip(0.S3): packages and examples migrated again from their pre-0.S sources in one run

ludic migrate state packages <every example program> packages/ludic.lab/example/plate.ludic
  1804 vars into 126 states, 64 into lets; 23498 edits in 460 files

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

examples/events/answer.ludic

@@ -5,20 +5,22 @@
 # Running it prints:  10 20 0
 program Answer {
   event cancellable Ask { kind: int }
-  var answer: int = 0
+  state AnswerState {
+    answer: int = 0
+  }
 
-  @On(Ask) handler One { if kind != 1 { return };  answer = 10;  cancel }
-  @On(Ask) handler Two { if kind != 2 { return };  answer = 20;  cancel }
+  @On(Ask) handler One(answer_st: mut AnswerState) { if kind != 1 { return };  answer_st.answer = 10;  cancel }
+  @On(Ask) handler Two(answer_st: mut AnswerState) { if kind != 2 { return };  answer_st.answer = 20;  cancel }
 
-  function ask(k: int) -> int {
-    answer = 0
-    if emit Ask(kind: k) != 0 { return answer }
+  function ask(answer_st: mut AnswerState, k: int) -> int {
+    answer_st.answer = 0
+    if emit Ask(kind: k) != 0 { return answer_st.answer }
     return 0
   }
 
-  entry {
-    print(ask(1))
-    print(ask(2))
-    print(ask(3))
+  entry (answer_st: mut AnswerState) {
+    print(ask(answer_st, 1))
+    print(ask(answer_st, 2))
+    print(ask(answer_st, 3))
   }
 }

examples/events/layer_events.ludic

@@ -6,7 +6,9 @@
 #
 # Running it prints:  50 2 1 50
 program LayerEvents {
-  var step: int = 0
+  state LayerEventsState {
+    step: int = 0
+  }
 
   @On(layer_Hud_show) handler Shown  { print(1) }   # a mod reacts when the HUD returns
   @On(layer_Hud_hide) handler Hidden { print(2) }   # ...and when it's hidden
@@ -16,11 +18,11 @@ program LayerEvents {
       handler Draw phase Update { print(50) }        # only runs while Hud is enabled
     }
     layer Ctrl {
-      handler Drive phase LateUpdate {
-        step += 1
-        if step == 1 { disable layer Hud }           # frame 1: hide -> Hidden 2, Draw stops
-        if step == 2 { enable layer Hud }            # frame 2: show -> Shown 1, Draw resumes
-        if step == 3 { quit() }                      # frame 3: after Draw ran again
+      handler Drive(layer_events_st: mut LayerEventsState) phase LateUpdate {
+        layer_events_st.step += 1
+        if layer_events_st.step == 1 { disable layer Hud }           # frame 1: hide -> Hidden 2, Draw stops
+        if layer_events_st.step == 2 { enable layer Hud }            # frame 2: show -> Shown 1, Draw resumes
+        if layer_events_st.step == 3 { quit() }                      # frame 3: after Draw ran again
       }
     }
   }

examples/events/mod_events.ludic

@@ -3,14 +3,16 @@
 # `Damage` has two @On listeners: one prints the amount, one accumulates a total.
 # Emitting it twice runs both listeners each time. Prints 10 / 32 / 42.
 program ModEvents {
-  var total: int = 0
+  state ModEventsState {
+    total: int = 0
+  }
   event Damage { amount: int = 0 }
   @On(Damage) handler Native { print(amount) }        # prints each hit
-  @On(Damage) handler Accum  { total += amount }   # sums them
+  @On(Damage) handler Accum(mod_events_st: mut ModEventsState)  { mod_events_st.total += amount }   # sums them
 
-  entry {
+  entry (mod_events_st: ModEventsState) {
     emit Damage(amount: 10)     # Native prints 10
     emit Damage(amount: 32)     # Native prints 32
-    print(total)                # 42
+    print(mod_events_st.total)                # 42
   }
 }

examples/events/recurse.ludic

@@ -6,16 +6,18 @@
 #
 # Running it prints:  16   (the cycle bottoms out at the depth cap, deterministically)
 program Recurse {
-  var n: int = 0
+  state RecurseState {
+    n: int = 0
+  }
 
   event Ping { }
   event Pong { }
 
-  @On(Ping) handler A { n += 1; emit Pong() }   # each Ping deepens by one Pong
+  @On(Ping) handler A(recurse_st: mut RecurseState) { recurse_st.n += 1; emit Pong() }   # each Ping deepens by one Pong
   @On(Pong) handler B { emit Ping() }              # ...and each Pong by one Ping
 
-  entry {
+  entry (recurse_st: RecurseState) {
     emit Ping()
-    print(n)
+    print(recurse_st.n)
   }
 }

examples/events/scoped.ludic

@@ -6,16 +6,18 @@
 program Scoped {
   property Health { hp: int = 0 }
   model Unit { Health }
-  var fires: int = 0
+  state ScopedState {
+    fires: int = 0
+  }
   event Tick { }
-  @On(Tick) handler OnTick { for (Health) in query [Health, {Unit}] { fires += 1 } }
+  @On(Tick) handler OnTick(scoped_st: mut ScopedState) { for (Health) in query [Health, {Unit}] { scoped_st.fires += 1 } }
 
-  entry {
+  entry (scoped_st: ScopedState) {
     spawn Unit { Health { hp: 1 } }
     emit Tick()     # 1 live Unit -> fires = 1
     emit Tick()     # fires = 2
     for (Health) in query [Health, {Unit}] { despawn self() }   # kill the Unit
     emit Tick()     # no live Units -> fires stays 2
-    print(fires)    # 2
+    print(scoped_st.fires)    # 2
   }
 }