migration: 17 integer-brain kernels from idaptik logic-directory sweep (cluster C13)

Exhaustive sweep of the eight brain-dense logic directories (devices, player,
combat, enemies, companions, multiplayer, src/shared, utils — 159 .res files).
Extracted 17 new Int(...)->Int brains; classified the remainder as host-side
senses, FFI binding shims, float/string-input cores, or already-migrated.

New brains (all G1 compile, G2 parity all-pass vs independent JS oracle, G4
assail clean): PlayerSprite, CombatResolve, ThreatClass, GameI18nCore,
AlertPalette, PeerPort, AccessClamp, Coprocessor, Coprocessor_IO, Kernel_Crypto,
Kernel_Quantum, ResourceAccounting, UmsLevelLoader, MoletaireCoprocessors,
MoletaireHunger, LobbyManager, MultiplayerClient. ~8,450 parity cases total.

Several are residual sub-brains earlier clusters scoped out as "routing"
(ThreatClass from DualAlertBridge; the Coprocessor/Kernel/Resource set from the
shared coprocessor layer). Each new brain's exported signature matches an
existing *Coprocessor.res host bridge.

Full per-file disposition (159 files: 17 new / 43 already / 99 no-brain) recorded
in EVIDENCE-C13-logic-sweep.adoc. Brain count 62 -> 79.

https://claude.ai/code/session_01WoKhFQePiRsAj7aqnxbG8s

Author: claude

proposals/idaptik/migrated/AccessClamp/AccessClamp.affine

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
+//
+// AccessClamp -- the accessibility-preference range-clamp co-processor, the
+// pure-integer core extracted from src/app/utils/AccessibilitySettings.res
+// `setFontScale` and `setGameSpeed` (the font-scale clamp is the same bound the
+// FontScaleCoprocessor.res bridge documents as `clampScale`, 0.75..2.0). Per the
+// DESIGN-VISION ("AffineScript is the brain, JS/Pixi the senses; only primitives
+// cross the wasm boundary") the JS host keeps the cached refs, the localStorage
+// persistence and the live PixiJS multiply (px * scale); AffineScript owns only
+// the integer range-clamp arithmetic.
+//
+// The ReScript clamps a Float preference with `Math.max(lo, Math.min(hi, v))`.
+// Float cannot cross the scalar-i32 boundary, so the preference crosses in
+// MILLI-UNITS: the JS caller passes round(scale * 1000) and reads back an integer
+// milli-value it divides by 1000. The bounds become integer milli-bounds and the
+// clamp is exact (the ReScript bounds 0.75 / 2.0 / 0.25 / 1.0 are all multiples of
+// 0.001, so the milli-domain loses nothing).
+//
+//## Font-scale bound (setFontScale: Math.max(0.75, Math.min(2.0, scale)))
+//   milli range [750 .. 2000]   (0.75x .. 2.0x text size)
+//## Game-speed bound (setGameSpeed: Math.max(0.25, Math.min(1.0, speed)))
+//   milli range [250 .. 1000]   (0.25x very-slow .. 1.0x normal)
+//
+// This is a genuine CLAMP (saturating to the nearest in-band bound), not a
+// sentinel: an out-of-range preference is pinned to the lo or hi bound exactly as
+// the ReScript Math.max/Math.min does, never to a sentinel. The clamp is total
+// and idempotent over the integer milli-domain.
+
+// The font-scale lower / upper milli-bounds (0.75 / 2.0 * 1000).
+pub fn font_scale_min_milli() -> Int { 750 }
+pub fn font_scale_max_milli() -> Int { 2000 }
+
+// The game-speed lower / upper milli-bounds (0.25 / 1.0 * 1000).
+pub fn game_speed_min_milli() -> Int { 250 }
+pub fn game_speed_max_milli() -> Int { 1000 }
+
+// A generic saturating clamp of v into [lo, hi]. Mirrors Math.max(lo,
+// Math.min(hi, v)): clamp UP to lo first conceptually, but the ReScript applies
+// min(hi, v) then max(lo, ...) -- when lo <= hi the two orders agree, and the
+// preference bounds always satisfy lo <= hi, so the single form below is exact.
+fn clamp_range(v: Int, lo: Int, hi: Int) -> Int {
+  if v < lo { lo } else { if v > hi { hi } else { v } }
+}
+
+// Clamp a font-scale milli-value into [750, 2000] (AccessibilitySettings
+// setFontScale's range bound; the FontScaleCoprocessor `clampScale`).
+pub fn clamp_font_scale_milli(scale_milli: Int) -> Int {
+  clamp_range(scale_milli, 750, 2000)
+}
+
+// Clamp a game-speed milli-value into [250, 1000] (AccessibilitySettings
+// setGameSpeed's range bound).
+pub fn clamp_game_speed_milli(speed_milli: Int) -> Int {
+  clamp_range(speed_milli, 250, 1000)
+}
+
+// Whether a font-scale milli-value is already in-band (no clamp would change it).
+// 1 = in [750,2000], 0 = would be saturated. Lets the host skip a redundant
+// write when the preference is already valid.
+pub fn font_scale_in_band(scale_milli: Int) -> Int {
+  if scale_milli < 750 { 0 } else { if scale_milli > 2000 { 0 } else { 1 } }
+}
+
+// Whether a game-speed milli-value is already in-band (no clamp would change it).
+pub fn game_speed_in_band(speed_milli: Int) -> Int {
+  if speed_milli < 250 { 0 } else { if speed_milli > 1000 { 0 } else { 1 } }
+}

proposals/idaptik/migrated/AccessClamp/accessclamp.config.mjs

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MPL-2.0
+// hypatia: allow cicd_rules/javascript_detected -- Deno trial component for nextgen-evangelist; production target is Rust/AffineScript (see proposals/nextgen-evangelist/README.adoc)
+//
+// affine-parity config for AccessClamp.affine (idaptik accessibility-preference
+// range clamps in milli-units; scalar i32 ABI). The oracle re-derives the
+// Math.max(lo, Math.min(hi, v)) clamps from AccessibilitySettings.res
+// INDEPENDENTLY in plain JS (milli-scaled bounds), so a codegen regression
+// surfaces as a differential mismatch.
+
+// Independent re-derivation of the ReScript Math.max(lo, Math.min(hi, v)).
+const clampRange = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+const FS_LO = 750, FS_HI = 2000, GS_LO = 250, GS_HI = 1000;
+
+export default {
+  affine: "AccessClamp.affine",
+  cases: [
+    { name: "font_scale_min_milli()", export: "font_scale_min_milli", args: [], oracle: () => 750 },
+    { name: "font_scale_max_milli()", export: "font_scale_max_milli", args: [], oracle: () => 2000 },
+    { name: "game_speed_min_milli()", export: "game_speed_min_milli", args: [], oracle: () => 250 },
+    { name: "game_speed_max_milli()", export: "game_speed_max_milli", args: [], oracle: () => 1000 },
+    {
+      // Sweep across and well past both bounds, stepping by 1 over the full
+      // [0..2500] milli-range would be 2501 cases; a coarser representative sweep
+      // over the boundary neighbourhoods plus interior is sufficient and fast.
+      name: "clamp_font_scale_milli over boundary + interior",
+      export: "clamp_font_scale_milli",
+      args: [{ values: [0, 500, 749, 750, 751, 1000, 1375, 1999, 2000, 2001, 2500, -100] }],
+      oracle: (v) => clampRange(v, FS_LO, FS_HI),
+    },
+    {
+      name: "clamp_game_speed_milli over boundary + interior",
+      export: "clamp_game_speed_milli",
+      args: [{ values: [0, 100, 249, 250, 251, 500, 750, 999, 1000, 1001, 1500, -50] }],
+      oracle: (v) => clampRange(v, GS_LO, GS_HI),
+    },
+    {
+      name: "font_scale_in_band over boundary neighbourhood",
+      export: "font_scale_in_band",
+      args: [{ values: [749, 750, 751, 1999, 2000, 2001, 0, 2500] }],
+      oracle: (v) => (v >= FS_LO && v <= FS_HI ? 1 : 0),
+    },
+    {
+      name: "game_speed_in_band over boundary neighbourhood",
+      export: "game_speed_in_band",
+      args: [{ values: [249, 250, 251, 999, 1000, 1001, 0, 1500] }],
+      oracle: (v) => (v >= GS_LO && v <= GS_HI ? 1 : 0),
+    },
+  ],
+};

proposals/idaptik/migrated/AlertPalette/AlertPalette.affine

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// SPDX-FileCopyrightText: 2025-2026 hyperpolymath
+//
+// AlertPalette -- the accessibility alert-colour lookup co-processor, the
+// pure-integer core extracted from src/app/utils/ColorPalette.res `alertColor`.
+// The existing ColorPalette co-processor (colorpalette.wasm, bound by
+// ColorPaletteCoprocessor.res) deliberately captured only the RGB-channel and
+// WCAG luminance/contrast KERNELS and left the accessibility palette LOOKUP
+// TABLES on the ReScript side (FeaturePacks documents this: "the live HUD
+// call-sites alertColor/deviceColor are accessibility palette lookup tables with
+// no corresponding kernel"). This brain captures exactly that residual: the
+// alert-level colour table, which is wholly pure-integer (enum bands in, a 24-bit
+// RGB integer out) with no host delegation -- unlike deviceColor/securityColor
+// whose Normal arm delegates to DeviceTypes host getters.
+//
+// Per the DESIGN-VISION the JS host keeps the AccessibilitySettings refs (the
+// high-contrast flag and colour-blind mode); AffineScript owns only the integer
+// table: given the high-contrast flag, the colour-blind mode and the alert level
+// it returns the packed colour.
+//
+//## Alert level encoding (levelInt, the header contract for the JS host)
+//   0 = Clear   1 = Noticed   2 = Caution   3 = Alert   4 = Danger
+// The ReScript switch has explicit arms for 0..4 and a `_` catch-all that takes
+// the Danger-row's "max" colour; we reproduce that fold (level >= 4 OR level < 0
+// uses the catch-all row), so the table is total over all Int and matches the
+// ReScript exactly.
+//
+//## Colour-blind mode encoding (mode, mirrors AccessibilitySettings.colorBlindMode)
+//   0 = Normal       3 = Tritanopia
+//   1 = Protanopia   4 = Achromatopsia
+//   2 = Deuteranopia
+// Protanopia and Deuteranopia share one table (the ReScript `Protanopia |
+// Deuteranopia =>` combined arm). An out-of-band mode folds onto Normal (0),
+// matching AccessibilitySettings.colorBlindModeFromString's `_ => Normal`.
+//
+// high_contrast is a host boolean crossed as 0 (off) or 1 (on); any non-zero is
+// treated as on. When on, the mode is ignored (the ReScript tests high contrast
+// first), so the high-contrast table is returned regardless of mode.
+//
+// All outputs are 24-bit RGB integers (0..0xFFFFFF = 16777215), well inside i32;
+// no value collides with another row at the same level, and -1 is never emitted,
+// so this is a pure total lookup (assail stays clean: no sentinel collapse).
+
+// Fold an arbitrary colour-blind mode index onto the valid 0..4 band; unknown ->
+// Normal (0). Mirrors colorBlindModeFromString's `_ => Normal`.
+pub fn clamp_mode(mode: Int) -> Int {
+  if mode < 0 { 0 } else { if mode > 4 { 0 } else { mode } }
+}
+
+// The catch-all alert row index used for level < 0 or level > 4: the ReScript
+// `_` arm coincides with the Danger row visually but uses a DISTINCT "max"
+// colour, so it is modelled as its own row index 5.
+fn alert_row(level: Int) -> Int {
+  if level < 0 { 5 } else { if level > 4 { 5 } else { level } }
+}
+
+//## High-contrast alert table (isHighContrastEnabled() == true)
+//   row 0 0x00ff00  1 0xffff00  2 0xffaa00  3 0xff4400  4 0xff0000  _ 0xff0000
+fn high_contrast_colour(level: Int) -> Int {
+  let r = alert_row(level);
+  if r == 0 { 65280 } else {
+  if r == 1 { 16776960 } else {
+  if r == 2 { 16755200 } else {
+  if r == 3 { 16729088 } else {
+  16711680 } } } }
+}
+
+//## Normal-mode alert table
+//   0 0x00ff00  1 0x88ff00  2 0xffff00  3 0xff8800  4 0xff4400  _ 0xff0000
+fn normal_colour(level: Int) -> Int {
+  let r = alert_row(level);
+  if r == 0 { 65280 } else {
+  if r == 1 { 8978176 } else {
+  if r == 2 { 16776960 } else {
+  if r == 3 { 16746496 } else {
+  if r == 4 { 16729088 } else {
+  16711680 } } } } }
+}
+
+//## Protanopia/Deuteranopia alert table (shared arm)
+//   0 0x0088ff  1 0x44aaff  2 0xffdd44  3 0xffaa00  4 0xff8800  _ 0xff6600
+fn protan_deuter_colour(level: Int) -> Int {
+  let r = alert_row(level);
+  if r == 0 { 35071 } else {
+  if r == 1 { 4500223 } else {
+  if r == 2 { 16768324 } else {
+  if r == 3 { 16755200 } else {
+  if r == 4 { 16746496 } else {
+  16737792 } } } } }
+}
+
+//## Tritanopia alert table
+//   0 0x00ee88  1 0x66dd66  2 0xdddd00  3 0xee6688  4 0xdd2266  _ 0xcc0044
+fn tritan_colour(level: Int) -> Int {
+  let r = alert_row(level);
+  if r == 0 { 61064 } else {
+  if r == 1 { 6741350 } else {
+  if r == 2 { 14540032 } else {
+  if r == 3 { 15623816 } else {
+  if r == 4 { 14492262 } else {
+  13369412 } } } } }
+}
+
+//## Achromatopsia alert table (brightness-only)
+//   0 0xffffff  1 0xcccccc  2 0x999999  3 0x777777  4 0x444444  _ 0x222222
+fn achroma_colour(level: Int) -> Int {
+  let r = alert_row(level);
+  if r == 0 { 16777215 } else {
+  if r == 1 { 13421772 } else {
+  if r == 2 { 10066329 } else {
+  if r == 3 { 7829367 } else {
+  if r == 4 { 4473924 } else {
+  2236962 } } } } }
+}
+
+// The packed RGB alert colour for a high-contrast flag, a colour-blind mode and
+// an alert level. High contrast wins first (mode ignored); otherwise the mode
+// selects the table. This is the full ColorPalette.res `alertColor` decision.
+pub fn alert_colour(high_contrast: Int, mode: Int, level: Int) -> Int {
+  if high_contrast != 0 { high_contrast_colour(level) } else {
+    let m = clamp_mode(mode);
+    if m == 0 { normal_colour(level) } else {
+    if m == 1 { protan_deuter_colour(level) } else {
+    if m == 2 { protan_deuter_colour(level) } else {
+    if m == 3 { tritan_colour(level) } else {
+    achroma_colour(level) } } } }
+  }
+}

proposals/idaptik/migrated/AlertPalette/alertpalette.config.mjs

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MPL-2.0
+// hypatia: allow cicd_rules/javascript_detected -- Deno trial component for nextgen-evangelist; production target is Rust/AffineScript (see proposals/nextgen-evangelist/README.adoc)
+//
+// affine-parity config for AlertPalette.affine (idaptik accessibility alert
+// colour lookup; scalar i32 ABI). The oracle re-derives the alertColor decision
+// tables from ColorPalette.res INDEPENDENTLY in plain JS (hex literals, mirroring
+// the ReScript source rather than the .affine's decimal encoding), so a codegen
+// regression or a transcription error in the .affine surfaces as a differential
+// mismatch.
+
+// The catch-all row for level < 0 or > 4 (the ReScript `_` arm), modelled as row 5.
+const row = (lvl) => (lvl < 0 || lvl > 4 ? 5 : lvl);
+
+const HC = [0x00ff00, 0xffff00, 0xffaa00, 0xff4400, 0xff0000, 0xff0000];
+const NORMAL = [0x00ff00, 0x88ff00, 0xffff00, 0xff8800, 0xff4400, 0xff0000];
+const PROTDEUT = [0x0088ff, 0x44aaff, 0xffdd44, 0xffaa00, 0xff8800, 0xff6600];
+const TRITAN = [0x00ee88, 0x66dd66, 0xdddd00, 0xee6688, 0xdd2266, 0xcc0044];
+const ACHROMA = [0xffffff, 0xcccccc, 0x999999, 0x777777, 0x444444, 0x222222];
+
+const clampMode = (m) => (m < 0 || m > 4 ? 0 : m);
+
+const alertColour = (hc, mode, level) => {
+  const r = row(level);
+  if (hc !== 0) return HC[r];
+  const m = clampMode(mode);
+  if (m === 0) return NORMAL[r];
+  if (m === 1 || m === 2) return PROTDEUT[r];
+  if (m === 3) return TRITAN[r];
+  return ACHROMA[r];
+};
+
+export default {
+  affine: "AlertPalette.affine",
+  cases: [
+    {
+      name: "clamp_mode over [-3..8]",
+      export: "clamp_mode",
+      args: [[-3, 8]],
+      oracle: (m) => clampMode(m),
+    },
+    {
+      // Full cartesian over the high-contrast path: hc=1, every mode, every level
+      // (incl. out-of-band level to exercise the `_` row).
+      name: "alert_colour high-contrast path (hc=1) over modes x levels",
+      export: "alert_colour",
+      args: [{ values: [1, 2, 7] }, [0, 4], [-2, 6]],
+      oracle: (hc, mode, level) => alertColour(hc, mode, level),
+    },
+    {
+      // Full cartesian over the normal-path: hc=0, every mode 0..4 (+ out-of-band),
+      // every level -2..6.
+      name: "alert_colour mode-selected path (hc=0) over modes x levels",
+      export: "alert_colour",
+      args: [0, [-1, 6], [-2, 6]],
+      oracle: (hc, mode, level) => alertColour(hc, mode, level),
+    },
+  ],
+};