feat(base): 0.R4 - a queue keeps its own count, so every package verb takes only its own state; ludic migrate state --prune

ludic.base's Queue<T> carries a QueueTag (its name and pending count): queue_new(name), q_push(q, v),
q_drain(q), q_clear(q) take no BaseState, and core_undrained(tags) names the given queues still holding
facts. A reducer on a package's state can now call that package's verbs (wallet_earn(wallet_st, n)).

ludic migrate state --prune (ludicc --migrate-prune) takes out each state parameter a function no
longer uses, nor anything it calls, and the argument that fills it - including an argument for a
parameter the callee has dropped, which is taken out before the call is checked, so a generic's T is
told by the argument that says it. A reducer keeps its state. --dry-run now counts the edits it would
make. Every package was moved with it: 608 base_st parameters and their arguments, 1889 edits.

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

packages/ludic.settings/file.ludic

@@ -42,13 +42,13 @@ function sg_read(settings_st: mut SettingsState, v: Val, id: int) -> void {
 
 # one setting from a JSON value in the file's own form (a row in a settings screen hands these):
 # a change is a fact
-export function settings_set_value(base_st: mut BaseState, settings_st: mut SettingsState, id: int, x: Val) -> void {
+export function settings_set_value(settings_st: mut SettingsState, id: int, x: Val) -> void {
   let d = settings_st.sg_defs[id]
   if d.kind == SETTING_TEXT {
-    if Value.kind(x) == 4 { settings_set_text(base_st, settings_st, id, Value.as_str(x)) }
+    if Value.kind(x) == 4 { settings_set_text(settings_st, id, Value.as_str(x)) }
   } else if d.kind == SETTING_FLOAT {
-    settings_set_float(base_st, settings_st, id, float(Value.as_int(x)) / 1000.0)
+    settings_set_float(settings_st, id, float(Value.as_int(x)) / 1000.0)
   } else {
-    settings_set_int(base_st, settings_st, id, Value.as_int(x))
+    settings_set_int(settings_st, id, Value.as_int(x))
   }
 }

packages/ludic.settings/store.ludic

@@ -14,17 +14,17 @@ function sg_init(settings_st: mut SettingsState) -> void {
   settings_st.sg_text = new []string
 }
 
-export function settings_changes(base_st: mut BaseState, settings_st: mut SettingsState) -> Queue<SettingChanged> {
-  if settings_st.sg_changes == null { settings_st.sg_changes = queue_new(base_st, "settings.changes") }
+export function settings_changes(settings_st: mut SettingsState) -> Queue<SettingChanged> {
+  if settings_st.sg_changes == null { settings_st.sg_changes = queue_new("settings.changes") }
   return settings_st.sg_changes
 }
 
 # forget every setting (a test, or a game that declares its table again)
-export function settings_clear(base_st: mut BaseState, settings_st: mut SettingsState) -> void {
+export function settings_clear(settings_st: mut SettingsState) -> void {
   settings_st.sg_defs = new []SettingDef
   settings_st.sg_num = new []float
   settings_st.sg_text = new []string
-  q_clear(base_st, settings_changes(base_st, settings_st))
+  q_clear(settings_changes(settings_st))
 }
 
 # a setting, at its default; its id is its place in the order added
@@ -55,31 +55,31 @@ export function settings_get_int(settings_st: SettingsState, id: int) -> int { r
 export function settings_get_bool(settings_st: SettingsState, id: int) -> bool { return settings_st.sg_num[id] != 0.0 }
 export function settings_get_text(settings_st: SettingsState, id: int) -> string { return settings_st.sg_text[id] }
 
-function sg_changed(base_st: mut BaseState, settings_st: mut SettingsState, id: int) -> void {
+function sg_changed(settings_st: mut SettingsState, id: int) -> void {
   let c = new SettingChanged
   c.id = id
   c.key = settings_st.sg_defs[id].key
-  q_push(base_st, settings_changes(base_st, settings_st), c)
+  q_push(settings_changes(settings_st), c)
 }
 
 # a value outside the setting's range is its default: a damaged file never reaches the game
-export function settings_set_float(base_st: mut BaseState, settings_st: mut SettingsState, id: int, v: float) -> void {
+export function settings_set_float(settings_st: mut SettingsState, id: int, v: float) -> void {
   let h = settings_held(settings_st, id, v)
   if h == settings_st.sg_num[id] { return }
   settings_st.sg_num[id] = h
-  sg_changed(base_st, settings_st, id)
+  sg_changed(settings_st, id)
 }
 
-export function settings_set_int(base_st: mut BaseState, settings_st: mut SettingsState, id: int, v: int) -> void { settings_set_float(base_st, settings_st, id, float(v)) }
+export function settings_set_int(settings_st: mut SettingsState, id: int, v: int) -> void { settings_set_float(settings_st, id, float(v)) }
 
-export function settings_set_bool(base_st: mut BaseState, settings_st: mut SettingsState, id: int, v: bool) -> void {
-  if v { settings_set_float(base_st, settings_st, id, 1.0) } else { settings_set_float(base_st, settings_st, id, 0.0) }
+export function settings_set_bool(settings_st: mut SettingsState, id: int, v: bool) -> void {
+  if v { settings_set_float(settings_st, id, 1.0) } else { settings_set_float(settings_st, id, 0.0) }
 }
 
-export function settings_set_text(base_st: mut BaseState, settings_st: mut SettingsState, id: int, v: string) -> void {
+export function settings_set_text(settings_st: mut SettingsState, id: int, v: string) -> void {
   if v == settings_st.sg_text[id] { return }
   settings_st.sg_text[id] = v
-  sg_changed(base_st, settings_st, id)
+  sg_changed(settings_st, id)
 }
 
 # `v` held to the setting's range: outside it, the default

packages/ludic.settings/tests/settings_test.ludic

@@ -6,15 +6,15 @@ program SettingsTest {
   numbers float
   registry Toy of SettingDef as TOY from "packages/ludic.settings/tests/toy.lres"
 
-  function declare(base_st: mut BaseState, settings_st: mut SettingsState) -> void {
-    settings_clear(base_st, settings_st)
+  function declare(settings_st: mut SettingsState) -> void {
+    settings_clear(settings_st)
     for i in 0 .. TOY_COUNT { settings_add(settings_st, Toy[i]) }
   }
 
-  function facts(base_st: mut BaseState, settings_st: mut SettingsState) -> []SettingChanged { return q_drain(base_st, settings_changes(base_st, settings_st)) }
+  function facts(settings_st: mut SettingsState) -> []SettingChanged { return q_drain(settings_changes(settings_st)) }
 
-  test "a registry declares the store, each at its default" (base_st: mut BaseState, settings_st: mut SettingsState) {
-    declare(base_st, settings_st)
+  test "a registry declares the store, each at its default" (settings_st: mut SettingsState) {
+    declare(settings_st)
     expect_eq(settings_count(settings_st), 5)
     expect(settings_get_bool(settings_st, TOY_BLOOM))
     expect_eq(settings_get_int(settings_st, TOY_SHADOW_Q), 2)
@@ -24,43 +24,43 @@ program SettingsTest {
     expect_eq(settings_id_of(settings_st, "nothing"), -1)
   }
 
-  test "a change is a fact, and setting what is there is none" (base_st: mut BaseState, settings_st: mut SettingsState) {
-    declare(base_st, settings_st)
-    settings_set_int(base_st, settings_st, TOY_SHADOW_Q, 3)
-    settings_set_int(base_st, settings_st, TOY_SHADOW_Q, 3)
-    settings_set_text(base_st, settings_st, TOY_LANG, "tr")
-    let fs = facts(base_st, settings_st)
+  test "a change is a fact, and setting what is there is none" (settings_st: mut SettingsState) {
+    declare(settings_st)
+    settings_set_int(settings_st, TOY_SHADOW_Q, 3)
+    settings_set_int(settings_st, TOY_SHADOW_Q, 3)
+    settings_set_text(settings_st, TOY_LANG, "tr")
+    let fs = facts(settings_st)
     expect_eq(len(fs), 2)
     expect(fs[0].key == "shadow_q")
     expect_eq(fs[1].id, TOY_LANG)
   }
 
-  test "a value out of range is the default" (base_st: mut BaseState, settings_st: mut SettingsState) {
-    declare(base_st, settings_st)
-    settings_set_int(base_st, settings_st, TOY_SHADOW_Q, 9)
+  test "a value out of range is the default" (settings_st: mut SettingsState) {
+    declare(settings_st)
+    settings_set_int(settings_st, TOY_SHADOW_Q, 9)
     expect_eq(settings_get_int(settings_st, TOY_SHADOW_Q), 2)
-    settings_set_float(base_st, settings_st, TOY_RSCALE, 0.2)
+    settings_set_float(settings_st, TOY_RSCALE, 0.2)
     expect(settings_get_float(settings_st, TOY_RSCALE) > 0.77)
   }
 
-  test "a rescue puts back only what it lists" (base_st: mut BaseState, settings_st: mut SettingsState) {
-    declare(base_st, settings_st)
-    settings_set_int(base_st, settings_st, TOY_SHADOW_Q, 0)
-    settings_set_bool(base_st, settings_st, TOY_BLOOM, false)
+  test "a rescue puts back only what it lists" (settings_st: mut SettingsState) {
+    declare(settings_st)
+    settings_set_int(settings_st, TOY_SHADOW_Q, 0)
+    settings_set_bool(settings_st, TOY_BLOOM, false)
     expect(not settings_is_safe(settings_st, TOY_SHADOW_Q))
     settings_rescue(settings_st)
     expect_eq(settings_get_int(settings_st, TOY_SHADOW_Q), 2)
     expect(not settings_get_bool(settings_st, TOY_BLOOM))
   }
 
-  test "the file is by key, and what it lacks or cannot hold keeps the store's" (base_st: mut BaseState, settings_st: mut SettingsState) {
-    declare(base_st, settings_st)
-    settings_set_float(base_st, settings_st, TOY_RSCALE, 0.9)
-    settings_set_text(base_st, settings_st, TOY_LANG, "tr")
-    settings_set_bool(base_st, settings_st, TOY_HELD, true)
+  test "the file is by key, and what it lacks or cannot hold keeps the store's" (settings_st: mut SettingsState) {
+    declare(settings_st)
+    settings_set_float(settings_st, TOY_RSCALE, 0.9)
+    settings_set_text(settings_st, TOY_LANG, "tr")
+    settings_set_bool(settings_st, TOY_HELD, true)
     let text = Json.encode(settings_to_json(settings_st))
-    declare(base_st, settings_st)
-    settings_set_bool(base_st, settings_st, TOY_BLOOM, false)
+    declare(settings_st)
+    settings_set_bool(settings_st, TOY_BLOOM, false)
     let v = Json.parse(text)
     Value.put(v, "shadow_q", Value.int(7))
     Value.put(v, "stranger", Value.int(1))