findings(E-5,E-6): validation-round fixes — live e2e falsified two ported shapes

E-5: the module-identity bridge called installingModule._malloc, but this
build exposes _malloc only as a bare glue-closure export (Module._malloc is
absent) — every char/stat event entry threw TypeError, which also starved
the E-6 credit window (thrown dispatches never acked) and wedged the queued
bg-finished frame behind them. The bridge now uses the bare closure exports
(identity is still exact: the EM_JS body IS the installing module's closure;
the __ngspiceOnEvent self-disarm covers supersession).

E-6 (codex reference design corrected — its validation matrix never ran):
a FULL credit window was terminal (stopEventStream at 64 in-flight frames).
Under live e2e that killed a real simulation: bg-thread emissions proxy one
per task, so each line ships as its own frame and a normal transient outruns
a busy main thread. A full window now DEFERS into a bounded FIFO (512 events
/ 4 MiB) drained in order as acks free credit; only true overload or an
invalid ack is terminal. Retention stays bounded (8 MiB in flight + 4 MiB
deferred + 1 MiB open batch). And the service/harness mirror queue now acks
at ENQUEUE — placing a frame in the bounded pre-handler queue is taking
ownership; without that, a stream starting before the C++ handler installs
(the ngspice-probe page) starves the worker window forever.

Test updates: worker-batch reducer — new "a full credit window defers and
drains in order, never terminal" case pinning the regression; the storm case
now proves the deferred caps are the terminal edge. board-ready.ts gains the
owner-free openBoardProgrammatically (codex helper the ported occ-export
spec needs; the barrier-based waitForUiBoardReady was NOT taken).
occ-export.spec: domId is optional on this line's registry (coordinate
fallback is the supported path).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

tests/kicad/utils/board-ready.ts

@@ -1,4 +1,7 @@
 import type { Page } from '@playwright/test';
+import { waitForCanvasStable } from '../../e2e/utils/element-tracker';
+
+export type RuntimeLogger = { consoleLogs: string[]; errors: string[] };
 
 /**
  * Wait for pcbnew to finish opening a board.
@@ -69,3 +72,70 @@ export async function waitForBoardLoaded(
 
     throw new Error(`Timed out waiting for board to load after ${timeoutMs}ms`);
 }
+
+function assertExpectedBoard(expectedBoard: string): void {
+    if (!expectedBoard.trim()) {
+        throw new Error('Expected board identity must not be empty');
+    }
+}
+
+function assertNoNativeFailure(logger: RuntimeLogger | undefined, phase: string): void {
+    if (!logger) return;
+    const failure = [...logger.consoleLogs, ...logger.errors].find((line) =>
+        line.includes('Aborted(')
+        || line.includes('RuntimeError: unreachable')
+        || line.includes('memory access out of bounds')
+    );
+    if (failure) throw new Error(`WASM failed during ${phase}:\n${failure}`);
+}
+
+async function waitForBoardIdentityAndPaint(
+    page: Page,
+    expectedBoard: string,
+    timeoutMs: number,
+): Promise<void> {
+    assertExpectedBoard(expectedBoard);
+    await page.waitForFunction(
+        (expected: string) => {
+            const titleMatches = document.title.toLocaleLowerCase()
+                .includes(expected.toLocaleLowerCase());
+            const hasPcbFrame = (window.wxElementRegistry?.findAll({ visible: true }) ?? [])
+                .some((element) => element.name === 'PcbFrame');
+            return titleMatches && hasPcbFrame;
+        },
+        expectedBoard,
+        { timeout: timeoutMs },
+    );
+    await waitForCanvasStable(page, '#canvas', { timeout: timeoutMs });
+}
+
+/**
+ * Use the shell's exact owned-open Promise, then prove document identity and
+ * paint. No PcbFrame/no-dialog heuristic is involved. (Ported from the codex
+ * line; owner-free — the barrier-based waitForUiBoardReady was NOT taken.)
+ */
+export async function openBoardProgrammatically(
+    page: Page,
+    path: string,
+    expectedBoard: string,
+    logger?: RuntimeLogger,
+    timeoutMs = 60000,
+): Promise<string> {
+    assertExpectedBoard(expectedBoard);
+    const opened = await page.evaluate(async (boardPath: string) => {
+        const runtime = window as unknown as {
+            Module?: { kicadOpenFile?(path: string): Promise<boolean> | boolean };
+        };
+        if (typeof runtime.Module?.kicadOpenFile !== 'function') {
+            throw new Error('Module.kicadOpenFile is not installed');
+        }
+        return await runtime.Module.kicadOpenFile(boardPath);
+    }, path);
+    if (opened !== true) {
+        throw new Error(`Module.kicadOpenFile did not open ${path}: ${String(opened)}`);
+    }
+    assertNoNativeFailure(logger, `opening ${expectedBoard}`);
+    await waitForBoardIdentityAndPaint(page, expectedBoard, timeoutMs);
+    assertNoNativeFailure(logger, `painting ${expectedBoard}`);
+    return `opened and painted ${expectedBoard} from exact kicadOpenFile Promise`;
+}

tests/kicad/utils/ngspice-service.ts

@@ -357,8 +357,8 @@ export async function installNgspiceServiceStub(
                     const queued = evtQueue.shift()!;
                     evtQueueBytes -= queued.bytes;
                     if (queued.generation !== slot.generation) continue;
+                    // Queued frames were acked at enqueue (ownership taken then).
                     handler(queued.evt);
-                    if (!ackEvent(slot, queued)) return;
                 }
                 handler(evt);
                 ackEvent(slot, frame);
@@ -370,6 +370,10 @@ export async function installNgspiceServiceStub(
                 }
                 evtQueue.push(frame);
                 evtQueueBytes += bytes;
+                // Enqueueing IS taking ownership (mirrors the production
+                // service): release the transport credit so a pre-handler
+                // stream cannot starve the worker's window.
+                ackEvent(slot, frame);
             }
         };