fix(button-light): serialize relay sends + hot-reload the lamp config

Two bugs in the button-light controller:

1. Stuck relay (random on/off). The blink fired fire-and-forget setAux every 500ms over
   UNORDERED UDP with no serialization — concurrent on/off packets reordered/overlapped,
   so the relay latched on whichever packet the device processed last. Replace with a
   desired-state + serialized worker (#pump): the blink timer only flips desiredOn; a
   single in-flight send per lamp is guaranteed, and on completion it re-converges to the
   latest desired state — so the final state is always authoritative and a lost/stale
   packet self-corrects.

2. Lamp ignored until restart. The lamp map was built once at start(); a button light
   added/changed via the UI never took effect without a server restart. #reconcile now
   re-reads the device config (at start and before each event, like DeviceMonitor),
   adding/updating/dropping lamps live — so a just-saved lamp blinks on the next radar
   edge.

Tests assert confirmedOf() (the device's latched state); +1 reconcile-after-start case.

Claude-Session: https://claude.ai/code/session_01Xcm6ikLgGoCxxHrxtjkk5V

apps/server/src/button-light.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { randomUUID } from "node:crypto";
-import { devices, type Db } from "@parking/db";
+import { eq, devices, type Db } from "@parking/db";
 import { createTestDb } from "@parking/db/testing";
 import type { AuxOutputDevice } from "@parking/devices";
 import { ButtonLightController } from "./button-light.js";
@@ -72,107 +72,130 @@ function lane(entryBusy: boolean): void {
   deviceEvents.emitLaneStatus({ entry: entryBusy, exit: false });
 }
 
+/** Flush the microtask queue so serialized setAux promises (and their re-pump on
+ *  completion) settle. The lamp worker sends ONE UDP at a time and re-pumps on resolve;
+ *  a few turns drain a burst. Needed because sends are now async (was synchronous). */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 6; i++) await Promise.resolve();
+}
+
 describe("ButtonLightController truth table", () => {
-  it("OFF at start (no radar, no car)", () => {
+  it("OFF at start (no radar, no car)", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const ctl = new ButtonLightController(db, silentLogger(), () => fakeAux(calls));
     ctl.start();
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("off");
-    // Initial apply drives the lamp off (false). It may de-dupe to no call since
-    // lastOn starts null -> false IS a change, so exactly one off write.
-    expect(calls).toEqual([{ ch: LAMP_RELAY, on: false }]);
+    // confirmedOn starts null; OFF de-dupes (null !== false → one off write), so the
+    // device is confirmed OFF and at most one call was made.
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(false);
     ctl.stop();
   });
 
-  it("radar present + lane busy -> SOLID on", () => {
+  it("radar present + lane busy -> SOLID on", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const aux = fakeAux(calls);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     ctl.start();
-    calls.length = 0;
+    await flush();
     lane(true);
     radar(true);
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("solid");
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: true });
-    // Solid = no blinking: advancing time produces no further toggles.
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true); // device latched ON
+    // Solid = no blinking: advancing time produces no further sends.
     const n = calls.length;
     vi.advanceTimersByTime(2000);
+    await flush();
     expect(calls.length).toBe(n);
     ctl.stop();
   });
 
-  it("radar present + lane free -> BLINK (toggles over time)", () => {
+  it("radar present + lane free -> BLINK (toggles the device over time)", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const aux = fakeAux(calls);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     ctl.start();
-    calls.length = 0;
+    await flush();
     radar(true); // lane still free
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("blink");
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: true }); // on now
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true); // on now
     vi.advanceTimersByTime(500);
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: false }); // toggled off
+    await flush();
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(false); // toggled off
     vi.advanceTimersByTime(500);
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: true }); // toggled on
+    await flush();
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true); // toggled on
     ctl.stop();
   });
 
-  it("blink -> solid when the camera confirms a car (lane busy)", () => {
+  it("blink -> solid when the camera confirms a car (lane busy)", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const aux = fakeAux(calls);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     ctl.start();
+    await flush();
     radar(true); // blink
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("blink");
     lane(true); // camera confirms
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("solid");
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: true });
-    // No more toggles (blink torn down).
-    const n = calls.length;
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true);
+    // No more toggles (blink torn down) — the device stays ON over time.
     vi.advanceTimersByTime(2000);
-    expect(calls.length).toBe(n);
+    await flush();
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true);
     ctl.stop();
   });
 
-  it("radar clears -> OFF", () => {
+  it("radar clears -> OFF", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const aux = fakeAux(calls);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     ctl.start();
+    await flush();
     lane(true);
     radar(true); // solid
-    calls.length = 0;
+    await flush();
     radar(false); // car gone
+    await flush();
     expect(ctl.stateOf(CONTROLLER)).toBe("off");
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: false });
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(false); // device latched OFF
     ctl.stop();
   });
 
-  it("de-dupes redundant writes (no spam on repeat events)", () => {
+  it("de-dupes redundant writes (no spam on repeat events)", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const aux = fakeAux(calls);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     ctl.start();
+    await flush();
     lane(true);
     radar(true); // solid, on
+    await flush();
     const n = calls.length;
     radar(true); // same state — no new edge (present unchanged)
     lane(true); // same lane — no change
+    await flush();
     expect(calls.length).toBe(n);
     ctl.stop();
   });
 
-  it("fails OFF: a setAux error does not throw or escalate", () => {
+  it("fails OFF: a setAux error does not throw or escalate", async () => {
     const calls: Array<{ ch: number; on: boolean }> = [];
     const throwOnce = { v: true };
     const aux = fakeAux(calls, throwOnce);
     const ctl = new ButtonLightController(db, silentLogger(), () => aux);
     // First write (initial off) throws — must be swallowed.
     expect(() => ctl.start()).not.toThrow();
-    // Subsequent writes work; driving to solid still succeeds.
+    await flush();
+    // Subsequent writes work; driving to solid still converges to ON.
     lane(true);
     radar(true);
-    expect(calls.at(-1)).toEqual({ ch: LAMP_RELAY, on: true });
+    await flush();
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true);
     ctl.stop();
   });
 
@@ -191,4 +214,49 @@ describe("ButtonLightController truth table", () => {
     expect(ctl.stateOf("ctl-2")).toBeNull();
     ctl.stop();
   });
+
+  it("picks up a button light ADDED after start() (no restart needed)", async () => {
+    // Fresh controller with a radar input but NO buttonLight yet.
+    const calls: Array<{ ch: number; on: boolean }> = [];
+    const aux = fakeAux(calls);
+    const ctl = new ButtonLightController(db, silentLogger(), () => aux);
+    // Replace the seeded controller with one that has the radar but no lamp.
+    db.update(devices)
+      .set({
+        config: {
+          host: "10.0.0.5",
+          relays: [{ relay: 1, direction: "entry", presenceInput: RADAR_INPUT, presenceKind: "radar" }],
+        },
+      })
+      .where(eq(devices.id, CONTROLLER))
+      .run();
+    ctl.start();
+    await flush();
+    // No lamp configured → an input does nothing.
+    radar(true);
+    await flush();
+    expect(ctl.stateOf(CONTROLLER)).toBeNull();
+    expect(calls.length).toBe(0);
+    radar(false);
+    await flush();
+
+    // Admin saves a button light (relay 3) — without restarting the server.
+    db.update(devices)
+      .set({
+        config: {
+          host: "10.0.0.5",
+          relays: [{ relay: 1, direction: "entry", presenceInput: RADAR_INPUT, presenceKind: "radar" }],
+          buttonLight: { relay: LAMP_RELAY, blinkOnMs: 500, blinkOffMs: 500 },
+        },
+      })
+      .where(eq(devices.id, CONTROLLER))
+      .run();
+
+    // The very next radar edge reconciles + blinks (lane still free).
+    radar(true);
+    await flush();
+    expect(ctl.stateOf(CONTROLLER)).toBe("blink");
+    expect(ctl.confirmedOf(CONTROLLER)).toBe(true);
+    ctl.stop();
+  });
 });