fix(lang): the action drain is the program's; --check runs every check a build makes; a registry key named count is refused; name lookups are tables

- the function that calls every reducer (and the action queue) is written in the program's own
  file: in the first action's file it belonged to that module, depended on every module with a
  reducer, and joined a game's modules into one 69-module cycle (examples/actions/modules and a
  ludic deps case hold it); the state instances, the queue and the reducers make no deps edges
- ludicc --check / ludic build --check lower the program too and write nothing, so the code
  writer's refusals are in it: a bind to a function that is gone, an unknown name (and the checker
  now refuses fn <missing> itself); rejects bind_missing_fn, unknown_name, registry_count_key
- def R count is refused: its constant would be PREFIX_COUNT, the registry's size
- a file's module, package, trust and numbers-float are tables, and from the check on the lookups
  of functions, enums, records, globals and externs are too (tagged enums kept as a list): Maroon
  Lake's check-only build went from about 20 s to 7 s including lowering, its IR from about 2
  minutes to under 10 s; duplicate declarations are found by table, not a pair of loops
- threads.ludic's pool check gives each call a little work, so a busy machine cannot run them all
  on the caller before a worker wakes (it failed one run in three under load)

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

selfhost/frontend/actions.ludic

@@ -19,6 +19,7 @@ var g_red_action: []pointer = new []pointer
 var g_dsp_ids: []Node = new []Node              # each dispatch's action number, filled at the end
 var g_dsp_names: []pointer = new []pointer
 var g_dsp_at: []Node = new []Node
+var g_act_main: pointer = null                  # the program's own file, where the drain is written
 const ACTION_PASSES: int = 64
 
 # action NAME { fields } - a record
@@ -101,12 +102,11 @@ function actions_finish() -> void {
     g_dsp_ids[i].ival = k
     i += 1
   }
+  # the queue and the drain are the program's, written in its own file: in the file of the first
+  # action they would belong to its module, and it would call every module's reducers
   var file = g_parse_file
-  var line = 1
-  if len(g_act_nodes) > 0 {
-    file = g_act_nodes[0].file
-    line = g_act_nodes[0].line
-  }
+  if g_act_main != null { file = g_act_main }
+  let line = 1
   # no actions: drain_actions() is still there (a ludic.base runner calls it), and does nothing
   if len(g_act_names) == 0 {
     vw_parse("export function drain_actions() -> void {\n}\n", file, line, 1)

selfhost/frontend/modules.ludic

@@ -128,15 +128,9 @@ function pkg_name_of(rel: pointer) -> pointer {
 function pkg_file_set(f: pointer, name: pointer) -> void {
   push(g_pk_file, f)
   push(g_pk_name, name)
+  fm_put(g_fm_pkg, f, name)
 }
-function pkg_of_file(f: pointer) -> pointer {
-  var i = len(g_pk_file) - 1
-  while i >= 0 {
-    if (g_pk_file[i] == f) { return g_pk_name[i] }
-    i -= 1
-  }
-  return ""
-}
+function pkg_of_file(f: pointer) -> pointer { return fm_get(g_fm_pkg, f) }
 # the module a declaration is in, for the uses rule: its own, else its package's
 function module_for_uses(f: pointer) -> pointer {
   let m = module_of(f)

selfhost/frontend/parse.ludic

@@ -25,36 +25,77 @@ var g_trusted_files: []pointer = new []pointer
 var g_unsafe_all: bool = false
 function unsafe_trusted(f: pointer) -> bool {
   if g_unsafe_all { return true }
+  return not (fm_get(g_fm_trusted, f) == "")
+}
+# a file's facts - its module, its package, whether it is trusted - asked of every reference the
+# checker and the emitter resolve: a table by file name, not a list walked each time (with a game's
+# nine hundred files that walk was most of a check-only build)
+const FM_SLOTS: int = 16384
+property FileMap {
+  keys: []pointer = null
+  vals: []pointer = null
+}
+function fm_new() -> FileMap {
+  let m = new FileMap
+  m.keys = new []pointer
+  m.vals = new []pointer
   var i = 0
-  while i < len(g_trusted_files) {
-    if (g_trusted_files[i] == f) { return true }
+  while i < FM_SLOTS {
+    push(m.keys, null)
+    push(m.vals, null)
     i += 1
   }
-  return false
+  return m
+}
+function fm_slot(m: FileMap, f: pointer) -> int {
+  var h = 5381
+  var i = 0
+  let n = len(f)
+  while i < n {
+    h = (h * 33 + f[i]) % 1000003
+    i += 1
+  }
+  h = h % FM_SLOTS
+  while m.keys[h] != null and not (m.keys[h] == f) { h = (h + 1) % FM_SLOTS }
+  return h
+}
+# the latest value set for f wins, as the lists' walk from the end had it
+function fm_put(m: FileMap, f: pointer, v: pointer) -> void {
+  if f == null { return }
+  let h = fm_slot(m, f)
+  m.keys[h] = f
+  m.vals[h] = v
+}
+function fm_get(m: FileMap, f: pointer) -> pointer {
+  if f == null { return "" }
+  let h = fm_slot(m, f)
+  if m.keys[h] == null { return "" }
+  return m.vals[h]
+}
+var g_fm_mod: FileMap = fm_new()
+var g_fm_pkg: FileMap = fm_new()
+var g_fm_trusted: FileMap = fm_new()
+function trust_file(f: pointer) -> void {
+  push(g_trusted_files, f)
+  fm_put(g_fm_trusted, f, "1")
 }
 var g_mod_file: []pointer = new []pointer
 var g_mod_name: []pointer = new []pointer
 var g_mod_friends: []pointer = new []pointer
-function module_of(f: pointer) -> pointer {
-  var i = len(g_mod_file) - 1
-  while i >= 0 {
-    if (g_mod_file[i] == f) { return g_mod_name[i] }
-    i -= 1
-  }
-  return ""
-}
+function module_of(f: pointer) -> pointer { return fm_get(g_fm_mod, f) }
 function module_set(f: pointer, name: pointer) -> void {
   push(g_mod_file, f)
   push(g_mod_name, name)
+  fm_put(g_fm_mod, f, name)
 }
 function is_float_file(f: pointer) -> bool {
   if (f == null) { return false }
-  var i = 0
-  while i < len(g_float_files) {
-    if (g_float_files[i] == f) { return true }
-    i += 1
-  }
-  return false
+  return not (fm_get(g_fm_float, f) == "")
+}
+var g_fm_float: FileMap = fm_new()
+function float_file_add(f: pointer) -> void {
+  push(g_float_files, f)
+  fm_put(g_fm_float, f, "1")
 }
 var g_parsing: bool = true         # false once lowering starts
 var g_err_file: pointer = ""       # the statement being lowered
@@ -952,7 +993,7 @@ function parse_one_decl() -> void {
   }
   if is_id("numbers") and (toks[pi + 1].text == "float") {
     pi += 2
-    if not is_float_file(g_parse_file) { push(g_float_files, g_parse_file) }
+    if not is_float_file(g_parse_file) { float_file_add(g_parse_file) }
     return
   }
   if is_id("import") { pi += 1
@@ -1180,11 +1221,11 @@ function do_import(rel: pointer) -> void {
   }
   if already_loaded(full) { return }
   push(loaded_paths, full)
-  if is_float_file(g_parse_file) and not is_runtime_path(rel) and not is_float_file(full) { push(g_float_files, full) }
+  if is_float_file(g_parse_file) and not is_runtime_path(rel) and not is_float_file(full) { float_file_add(full) }
   # a module reaches as far as its own files: a package found through $LUDIC_HOME or
   # ludic_modules is not beside its importer and keeps its own module (or none)
   let beside = full == join_path(cur_dir, rel)
-  if is_runtime_path(rel) or not beside or (beside and unsafe_trusted(g_parse_file)) { push(g_trusted_files, full) }
+  if is_runtime_path(rel) or not beside or (beside and unsafe_trusted(g_parse_file)) { trust_file(full) }
   if beside and not is_runtime_path(rel) and not (module_of(g_parse_file) == "") { module_set(full, module_of(g_parse_file)) }
   if not beside and not is_runtime_path(rel) { pkg_file_set(full, pkg_name_of(rel)) }            # modules.ludic
   if beside and not is_runtime_path(rel) and not (pkg_of_file(g_parse_file) == "") { pkg_file_set(full, pkg_of_file(g_parse_file)) }

selfhost/frontend/registry_finish.ludic

@@ -44,6 +44,12 @@ function reg_fill(r: int) -> void {
       j += 1
     }
     push(seen, key)
+    if (reg_upper(key) == "COUNT") {
+      g_err_file = rec.file
+      g_err_line = rec.line
+      g_parsing = false
+      perr(`def {g_rg_name[r]} {key}: its constant would be {g_rg_prefix[r]}_COUNT, which is the registry's size; give the entry another key`)
+    }
     if keyed and not reg_rec_has(rec, "key") {
       let fi = node(E_FINIT)
       fi.s = "key"

selfhost/frontend/resource.ludic

@@ -29,7 +29,7 @@ function res_read_into(reg: pointer, from: pointer, who: pointer) -> void {
   let saved_file = g_parse_file
   let saved_parsing = g_parsing
   if not (module_of(saved_file) == "") { module_set(path, module_of(saved_file)) }
-  if is_float_file(saved_file) and not is_float_file(path) { push(g_float_files, path) }
+  if is_float_file(saved_file) and not is_float_file(path) { float_file_add(path) }
   g_parse_file = path
   g_parsing = true
   g_res_mode = true