fix(load): close the dispatch-interlock hole at open + open gerbers from a project route

- kicadOpenFile now holds wxWasmDispatchGuard (open_gate.h). It enters through
  embind, so the interlock read "nothing parked" for the whole load and wx timers
  dispatched into the half-built board — the residual prod "index out of bounds"
  that survived the settle gate.
- new wasm/bindings/gerbview_embind.cpp (the bundle had no embind surface at all):
  kicadOpenFile / kicadOpenFiles / kicadOpenFileBusy. Clicking one gerber opens the
  whole fabrication set in its folder, since a lone layer is not a useful view.
- cross-app presence rejoins in the boot fan-out (network-only; the wasm-bound half
  still waits for the open to settle) — it had been pushed behind the board load.
- tests: gerber-set selection units + a gerbview multi-file open e2e.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0137pGo8W7asomGUTRMB7RzM

tests/kicad/gerbview.spec.ts

@@ -13,8 +13,30 @@ import { waitForEditorReady, stableShot } from '../e2e/utils/element-tracker';
  *
  * Determinism: no waitForTimeout, no wizard click-through loop, screenshots via
  * stableShot (stabilizes before comparing).
+ *
+ * The embind file-open surface (wasm/bindings/gerbview_embind.cpp) IS in scope:
+ * the project page deep-links a gerber here, and the shell opens the whole
+ * fabrication set through `kicadOpenFiles`.
  */
 
+/** Minimal valid RS-274X gerber drawing one trace, so a layer really loads. */
+function gerber(xEndMm: number): string {
+    return [
+        '%FSLAX46Y46*%',
+        '%MOMM*%',
+        '%ADD10C,0.200000*%',
+        'D10*',
+        'X10000000Y10000000D02*',
+        `X${xEndMm * 1_000_000}Y10000000D01*`,
+        'M02*',
+        '',
+    ].join('\n');
+}
+
+/** Minimal Excellon drill file — GerbView routes .drl to its own loader. */
+const DRILL = ['M48', 'FMAT,2', 'METRIC', 'T1C0.800', '%', 'G90', 'G05', 'T1',
+    'X20.0Y20.0', 'T0', 'M30', ''].join('\n');
+
 function hasAbort(testLogger: { consoleLogs: string[]; errors: string[] }): boolean {
     return [...testLogger.consoleLogs, ...testLogger.errors].some(line => line.includes('Aborted('));
 }
@@ -62,4 +84,64 @@ test.describe('gerbview WASM', () => {
         expect(metrics.glCanvasOk, 'GL canvas has nonzero dimensions').toBe(true);
         expect(hasAbort(testLogger)).toBe(false);
     });
+
+    /**
+     * kicadOpenFiles: the whole-set entry the project page's gerber links use.
+     * A fabrication set is a stack, so opening one layer alone is not the job —
+     * this asserts a multi-file open lands every layer (and the drill file) in
+     * one call, which is what GERBVIEW_FRAME::OpenProjectFiles gives us.
+     */
+    test('kicadOpenFiles opens a whole fabrication set in one call', async ({ page, testLogger }) => {
+        await waitForEditorReady(page);
+
+        const opened = await page.evaluate(({ gerbers, drill }) => {
+            const w = window as unknown as {
+                FS: { mkdirTree(p: string): void; writeFile(p: string, d: string): void };
+                Module: { kicadOpenFiles?: (json: string) => boolean };
+            };
+            const dir = '/home/kicad/documents/fab';
+            w.FS.mkdirTree(dir);
+            const paths: string[] = [];
+            for (const [name, content] of Object.entries(gerbers)) {
+                const p = `${dir}/${name}`;
+                w.FS.writeFile(p, content as string);
+                paths.push(p);
+            }
+            const drillPath = `${dir}/board-PTH.drl`;
+            w.FS.writeFile(drillPath, drill);
+            paths.push(drillPath);
+            const registryBefore = window.wxElementRegistry!.findAll({ visible: true }).length;
+            if (typeof w.Module.kicadOpenFiles !== 'function') return { hook: false, registryBefore };
+            w.Module.kicadOpenFiles(JSON.stringify(paths));
+            return { hook: true, registryBefore };
+        }, {
+            gerbers: {
+                'board-F_Cu.gbr': gerber(30),
+                'board-B_Cu.gbr': gerber(40),
+                'board-Edge_Cuts.gbr': gerber(50),
+            },
+            drill: DRILL,
+        });
+
+        expect(opened.hook, 'gerbview exposes kicadOpenFiles (gerbview_embind.cpp)').toBe(true);
+        // NOT the return value: OpenProjectFiles parks under Asyncify, so the
+        // embind call unwinds and hands back a falsy placeholder long before the
+        // load finishes (same reason open-flow.ts ignores kicadOpenFile's bool).
+        // The truthful completion signal is the open-gate probe.
+        await expect.poll(
+            async () => page.evaluate(() => {
+                const w = window as unknown as { Module: { kicadOpenFileBusy?: () => boolean } };
+                return w.Module.kicadOpenFileBusy?.() ?? true;
+            }),
+            { timeout: 30000, intervals: [250] },
+        ).toBe(false);
+
+        // Each file became its own draw layer, so the UI gained rows/entries.
+        expect(
+            await page.evaluate(() => window.wxElementRegistry!.findAll({ visible: true }).length),
+            'the layers UI grew once the set loaded',
+        ).toBeGreaterThan(opened.registryBefore);
+
+        expect(hasAbort(testLogger), 'no WASM abort during the multi-file open').toBe(false);
+    });
 });