refactor(packages): 0.R5 - a question no longer starts its state - 64 lazy starts ('if st.x == null { st.x = ... }' inside a getter) are the state's defaults, gear__ensure is gone, and ludic migrate state --tighten took mut off 208 package parameters: things_all, thing_find, gear_charge, gear_level, jobs_state and the rest read

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

packages/ludic.effects/queries.ludic

@@ -2,20 +2,20 @@
 function ef_live(e: Effect) -> bool { return e.delay < 0.01 }
 
 # what the rules should add for a kind right now (a delayed one counts only once it begins)
-export function effects_sum(effects_st: mut EffectsState, kind: int) -> float {
+export function effects_sum(effects_st: EffectsState, kind: int) -> float {
   let all = ef_all(effects_st)
   var t = 0.0
   for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { t = t + all[i].mag } }
   return t
 }
 
-export function effects_has(effects_st: mut EffectsState, kind: int) -> bool {
+export function effects_has(effects_st: EffectsState, kind: int) -> bool {
   let all = ef_all(effects_st)
   for i in 0 .. len(all) { if all[i].kind == kind and ef_live(all[i]) { return true } }
   return false
 }
 
-export function effects_bonus_count(effects_st: mut EffectsState) -> int {
+export function effects_bonus_count(effects_st: EffectsState) -> int {
   let all = ef_all(effects_st)
   var n = 0
   for i in 0 .. len(all) { if all[i].bonus { n += 1 } }
@@ -23,10 +23,10 @@ export function effects_bonus_count(effects_st: mut EffectsState) -> int {
 }
 
 # everything held, delayed or not, in the order added
-export function effects_count(effects_st: mut EffectsState) -> int { return len(ef_all(effects_st)) }
+export function effects_count(effects_st: EffectsState) -> int { return len(ef_all(effects_st)) }
 
 # a copy, so a reader cannot change the ring
-export function effects_at(effects_st: mut EffectsState, i: int) -> Effect {
+export function effects_at(effects_st: EffectsState, i: int) -> Effect {
   let src = ef_all(effects_st)[i]
   let e = new Effect
   e.kind = src.kind
@@ -39,7 +39,7 @@ export function effects_at(effects_st: mut EffectsState, i: int) -> Effect {
 }
 
 # the indices of the ones that have begun, for a read-out
-export function effects_live(effects_st: mut EffectsState) -> []int {
+export function effects_live(effects_st: EffectsState) -> []int {
   let out = new []int
   let all = ef_all(effects_st)
   for i in 0 .. len(all) { if ef_live(all[i]) { push(out, i) } }

packages/ludic.effects/state.ludic

@@ -21,20 +21,18 @@ export property EffectEnded {
 }
 
 export state EffectsState {
-  ef_list: []Effect = null
+  ef_list: []Effect = new []Effect
   ef_max: int = 8
   ef_bonus_max: int = 3
-  ef_ended: Queue<EffectEnded> = null
+  ef_ended: Queue<EffectEnded> = ef_ended__new()
 }
 
-function ef_all(effects_st: mut EffectsState) -> []Effect {
-  if effects_st.ef_list == null { effects_st.ef_list = new []Effect }
+function ef_all(effects_st: EffectsState) -> []Effect {
   return effects_st.ef_list
 }
 
 # the facts: what ended and why, oldest first; the game drains it
-export function effects_ended(effects_st: mut EffectsState) -> Queue<EffectEnded> {
-  if effects_st.ef_ended == null { effects_st.ef_ended = queue_new("effects.ended") }
+export function effects_ended(effects_st: EffectsState) -> Queue<EffectEnded> {
   return effects_st.ef_ended
 }
 
@@ -46,3 +44,4 @@ export function effects_config(effects_st: mut EffectsState, max: int, bonus_max
 
 export function effects_capacity(effects_st: EffectsState) -> int { return effects_st.ef_max }
 export function effects_bonus_capacity(effects_st: EffectsState) -> int { return effects_st.ef_bonus_max }
+function ef_ended__new() -> Queue<EffectEnded> { return queue_new("effects.ended") }

packages/ludic.effects/system.ludic

@@ -6,7 +6,7 @@ export function effects_reset(effects_st: mut EffectsState) -> void {
 
 function effects_tick(effects_st: mut EffectsState, t: Tick) -> void { effects_run(effects_st, t.hours * 60.0) }
 
-export function effects_save(effects_st: mut EffectsState) -> Val {
+export function effects_save(effects_st: EffectsState) -> Val {
   let l = Value.list()
   let all = ef_all(effects_st)
   for i in 0 .. len(all) {

packages/ludic.effects/tests/effects_test.ludic

@@ -13,8 +13,8 @@ program EffectsTest {
     effects_reset(effects_st)
   }
 
-  function ended(effects_st: mut EffectsState) -> []EffectEnded { return q_drain(effects_ended(effects_st)) }
-  function waiting(effects_st: mut EffectsState) -> int { return q_len(effects_ended(effects_st)) }
+  function ended(effects_st: EffectsState) -> []EffectEnded { return q_drain(effects_ended(effects_st)) }
+  function waiting(effects_st: EffectsState) -> int { return q_len(effects_ended(effects_st)) }
 
   function tick_minutes(m: float) -> void {
     let s = effects_system()

packages/ludic.effects/verbs.ludic

@@ -19,7 +19,7 @@ function ef_drop(effects_st: mut EffectsState, i: int) -> void {
 }
 
 # the one with the least time left (of the bonuses only, when asked); -1 when there is none
-function ef_nearest_end(effects_st: mut EffectsState, bonus_only: bool) -> int {
+function ef_nearest_end(effects_st: EffectsState, bonus_only: bool) -> int {
   let all = ef_all(effects_st)
   var at = -1
   for i in 0 .. len(all) {