Add optional Playwright fuzz smoke test scaffold.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: veillette

package-lock.json

@@ -37,7 +37,9 @@
     "clean": "rm -rf dist",
     "generate-svg-icon": "tsx scripts/opticsToSVG.ts",
     "icons": "npm run generate-svg-icon && tsx scripts/generate-icons.ts",
-    "prepare": "git rev-parse --is-inside-work-tree >/dev/null 2>&1 && git config core.hooksPath .githooks || true"
+    "prepare": "git rev-parse --is-inside-work-tree >/dev/null 2>&1 && git config core.hooksPath .githooks || true",
+    "test:fuzz": "playwright test --project=chromium",
+    "test:fuzz:quick": "FUZZ_DURATION=10 playwright test --project=chromium"
   },
   "dependencies": {
     "scenerystack": "^3.0.0"
@@ -54,7 +56,9 @@
     "typescript": "^7.0.2",
     "vite": "^8.1.5",
     "vite-plugin-pwa": "^1.3.0",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "@playwright/test": "^1.61.1",
+    "playwright": "^1.61.1"
   },
   "engines": {
     "node": ">=22.0.0"

package.json

@@ -0,0 +1,38 @@
+/**
+ * Playwright configuration for optional fuzz testing (OpticsLab smoke).
+ */
+
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  testDir: "./tests/fuzz",
+  timeout: 5 * 60 * 1000,
+  expect: {
+    timeout: 10_000,
+  },
+  fullyParallel: false,
+  forbidOnly: !!process.env.CI,
+  retries: 0,
+  workers: 1,
+  reporter: [["list"], ["html", { open: "never" }]],
+  use: {
+    baseURL: "http://localhost:5173",
+    trace: "retain-on-failure",
+    video: "retain-on-failure",
+    screenshot: "only-on-failure",
+  },
+  webServer: {
+    command: "npm run start",
+    url: "http://localhost:5173",
+    reuseExistingServer: !process.env.CI,
+    timeout: 120_000,
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: {
+        browserName: "chromium",
+      },
+    },
+  ],
+});

playwright.config.ts

@@ -0,0 +1,78 @@
+/**
+ * Optional Playwright fuzz smoke for the OpticsLab simulation.
+ *
+ * Usage:
+ *   npm run test:fuzz
+ *   npm run test:fuzz:quick
+ *   FUZZ_SEED=12345 npm run test:fuzz
+ */
+
+import { expect, test } from "@playwright/test";
+
+const FUZZ_DURATION = parseInt(process.env["FUZZ_DURATION"] || "15", 10) * 1000;
+const FUZZ_SEED = process.env["FUZZ_SEED"] || Math.floor(Math.random() * 1_000_000).toString();
+const FUZZ_RATE = process.env["FUZZ_RATE"] || "100";
+const FUZZ_POINTERS = process.env["FUZZ_POINTERS"] || "1";
+
+interface ConsoleMessage {
+  type: string;
+  text: string;
+  location: string;
+  timestamp: number;
+}
+
+test.describe("Fuzz Testing", () => {
+  test("should run without console errors", async ({ page }) => {
+    const errors: ConsoleMessage[] = [];
+    const assertions: ConsoleMessage[] = [];
+    const startTime = Date.now();
+
+    const fuzzUrl = `/?fuzz&randomSeed=${FUZZ_SEED}&fuzzRate=${FUZZ_RATE}&fuzzPointers=${FUZZ_POINTERS}`;
+
+    page.on("console", (msg) => {
+      const type = msg.type();
+      const text = msg.text();
+      const location = msg.location();
+      const timestamp = Date.now() - startTime;
+      const message: ConsoleMessage = {
+        type,
+        text,
+        location: `${location.url}:${location.lineNumber}:${location.columnNumber}`,
+        timestamp,
+      };
+      if (type === "error") {
+        errors.push(message);
+      } else if (text.includes("Assertion failed") || text.includes("AssertionError")) {
+        assertions.push(message);
+      }
+    });
+
+    page.on("pageerror", (error) => {
+      errors.push({
+        type: "pageerror",
+        text: error.message,
+        location: error.stack || "unknown",
+        timestamp: Date.now() - startTime,
+      });
+    });
+
+    await page.goto(fuzzUrl);
+    await page.waitForSelector("#sim", { timeout: 30_000 });
+
+    const checkInterval = 2000;
+    let elapsed = 0;
+    while (elapsed < FUZZ_DURATION) {
+      const waitTime = Math.min(checkInterval, FUZZ_DURATION - elapsed);
+      await page.waitForTimeout(waitTime);
+      elapsed += waitTime;
+      try {
+        await page.evaluate(() => window.document.hasFocus);
+      } catch {
+        break;
+      }
+    }
+
+    expect(errors.length, `Found ${errors.length} console errors`).toBe(0);
+    expect(assertions.length, `Found ${assertions.length} assertion failures`).toBe(0);
+  });
+});