feat: libs 0009-C — footprint write round-trip e2e (footprint-write-remote.spec.ts): editor → user lib → New Footprint auto-save → PUT → backend persists fork-native .kicad_mod; green

tests/web/footprint-write-remote.spec.ts

@@ -0,0 +1,121 @@
+import { test, expect, type Page } from '@playwright/test';
+import { waitForRegistry, clickByTooltip } from '../e2e/utils/element-tracker';
+
+// Mirrors @pcbjam/shared OWNER_HEADER (tests/ doesn't depend on the shared pkg).
+const OWNER_HEADER = 'x-pcbjam-owner';
+
+/**
+ * 0009-C: the FULL remote footprint write round-trip — no in-memory spike. Boot
+ * ensures a user lib via the backend's createLib; selecting it + New Footprint
+ * auto-saves into it, routing through PCB_IO_PCBJAM_FP::FootprintSave →
+ * window.kicadLibs.request("save", …, "footprint") → remoteLibsSource.saveItemBody
+ * → PUT /api/libs/:lib/items/footprint/:name on the example backend. Verify the
+ * backend persisted a fork-native .kicad_mod.
+ *
+ * Requires the example backend (:3060) running with USER_LIBS_DIR set.
+ */
+
+const BACKEND = process.env.BACKEND_URL ?? 'http://localhost:3060';
+const SHOT = (n: string) => `test-results/fpremote-${n}.png`;
+const USER_LIB = 'my-symbols'; // slug of the boot-ensured "My Symbols" container
+
+async function focusCanvas(page: Page): Promise<void> {
+  const box = await page.locator('#canvas').boundingBox();
+  if (box) await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
+  await page.waitForTimeout(300);
+}
+
+/** Click a LIB_TREE row by label, correcting the constant dataviewitem Y offset. */
+async function clickTreeRow(page: Page, label: string): Promise<boolean> {
+  const hit = await page.evaluate((wanted) => {
+    const rd = window.wxElementRegistry.findAllRendered({});
+    const hdr = rd.find((e: any) => e.elementType === 'columnheader' && e.label === 'Item');
+    const rows = rd
+      .filter((e: any) => e.elementType === 'dataviewitem')
+      .sort((a: any, b: any) => a.centerY - b.centerY);
+    if (!hdr || rows.length === 0) return null;
+    const pitch = rows.length > 1 ? rows[1].centerY - rows[0].centerY : 17;
+    const offset = hdr.centerY + hdr.height / 2 + pitch / 2 - rows[0].centerY;
+    const row = rows.find((r: any) => r.label === wanted);
+    return row ? { x: row.centerX, y: row.centerY + offset } : null;
+  }, label);
+  if (!hit) return false;
+  await page.mouse.click(hit.x, hit.y);
+  await page.waitForTimeout(300);
+  return true;
+}
+
+test('footprint editor save persists to the backend (remote write round-trip)', async ({ page }) => {
+  const owner = `e2e-fp-${Date.now()}`;
+  const logs: string[] = [];
+  page.on('console', (m) => logs.push(`[${m.type()}] ${m.text()}`));
+  page.on('pageerror', (e) => logs.push(`[pageerror] ${e.message}`));
+
+  await page.goto(`/p/demo/footprint_editor/?libowner=${owner}`);
+  await expect(page.locator('#canvas')).toBeVisible({ timeout: 180000 });
+  await waitForRegistry(page, 180000);
+  await page.waitForFunction(
+    () => !!window.wxElementRegistry && window.wxElementRegistry.findAll({}).length > 5,
+    null,
+    { timeout: 180000 },
+  );
+  await page.waitForFunction(() => !!(window as any).kicadLibs, null, { timeout: 60000 });
+  await page.waitForTimeout(2000);
+  await page.screenshot({ path: SHOT('01-boot'), scale: 'css' });
+
+  // Boot's ensure-user-lib created the writable container for this owner.
+  const ownerHeaders = { [OWNER_HEADER]: owner };
+  const libsRes = await fetch(`${BACKEND}/api/libs?kind=footprint`, { headers: ownerHeaders });
+  const libsBody = (await libsRes.json()) as { id: string; type: string }[];
+  logs.push(`[spec] libs: ${JSON.stringify(libsBody)}`);
+  expect(libsBody.some((l) => l.type === 'user' && l.id === USER_LIB), 'user lib created at boot').toBe(true);
+
+  // Select the writable USER lib (NOT an origin — origins would mirror, which the
+  // example backend doesn't implement) so New Footprint targets it.
+  expect(await clickTreeRow(page, 'My Symbols'), 'selected the user lib row').toBe(true);
+  await page.waitForTimeout(400);
+  await page.screenshot({ path: SHOT('02-lib-selected'), scale: 'css' });
+
+  // New Footprint → auto-saves into the writable lib (tryToSaveFootprintInLibrary).
+  expect(await clickByTooltip(page, 'New Footprint'), 'New Footprint clicked').toBe(true);
+  await page.waitForTimeout(1500);
+  // Belt-and-braces explicit save.
+  await focusCanvas(page);
+  await page.keyboard.press('Control+s');
+  await page.screenshot({ path: SHOT('03-created'), scale: 'css' });
+
+  // Poll the backend until a footprint item lands.
+  let items: { kind: string; name: string }[] = [];
+  await expect
+    .poll(
+      async () => {
+        const r = await fetch(`${BACKEND}/api/libs/${USER_LIB}/items`, { headers: ownerHeaders });
+        items = r.ok ? ((await r.json()) as { kind: string; name: string }[]) : [];
+        return items.filter((i) => i.kind === 'footprint').length;
+      },
+      { timeout: 30000, intervals: [500] },
+    )
+    .toBeGreaterThan(0);
+  await page.screenshot({ path: SHOT('04-saved'), scale: 'css' });
+
+  const saved = items.find((i) => i.kind === 'footprint')!;
+  logs.push(`[spec] backend footprint item: ${JSON.stringify(saved)}`);
+
+  // The persisted body is a well-formed fork-native footprint (native version).
+  const bodyRes = await fetch(
+    `${BACKEND}/api/libs/${USER_LIB}/items/footprint/${encodeURIComponent(saved.name)}`,
+    { headers: ownerHeaders },
+  );
+  const body = await bodyRes.text();
+  logs.push(`[spec] persisted body (${body.length} bytes):\n${body}`);
+  expect(body).toContain('(footprint');
+  expect(body).toContain('(version 20251028)');
+  expect(body).toContain('(generator "pcbnew")');
+  expect(body).toContain(saved.name);
+
+  // App stayed live.
+  expect(logs.some((l) => l.includes('Aborted(')), 'no WASM abort').toBe(false);
+  expect(new URL(page.url()).searchParams.get('oomRetry'), 'no OOM respawn').toBeNull();
+
+  console.log('--- spec log ---\n' + logs.join('\n'));
+});