fix(image-pipeline): preserve worker errors and skip aborted histograms

tests/worker-client.test.ts

@@ -0,0 +1,188 @@
+// @vitest-environment jsdom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { emptyHistogram } from "@/lib/image-pipeline/histogram";
+import type { RenderFullResult } from "@/lib/image-pipeline/render-types";
+
+const previewRendererMocks = vi.hoisted(() => ({
+  renderPreview: vi.fn(),
+}));
+
+const bridgeMocks = vi.hoisted(() => ({
+  renderFull: vi.fn(),
+}));
+
+vi.mock("@/lib/image-pipeline/preview-renderer", () => ({
+  renderPreview: previewRendererMocks.renderPreview,
+}));
+
+vi.mock("@/lib/image-pipeline/bridge", () => ({
+  renderFull: bridgeMocks.renderFull,
+}));
+
+function createFullResult(): RenderFullResult {
+  return {
+    blob: new Blob(["rendered"]),
+    width: 32,
+    height: 32,
+    mimeType: "image/png",
+    format: "png",
+    quality: null,
+    sizeBytes: 8,
+    sourceWidth: 32,
+    sourceHeight: 32,
+    wasSizeClamped: false,
+  };
+}
+
+type WorkerMessage =
+  | {
+      kind: "preview" | "full";
+      requestId: number;
+    }
+  | {
+      kind: "cancel";
+      requestId: number;
+    };
+
+type FakeWorkerBehavior = (worker: FakeWorker, message: WorkerMessage) => void;
+
+class FakeWorker {
+  static behavior: FakeWorkerBehavior = () => {};
+
+  onmessage: ((event: MessageEvent) => void) | null = null;
+  onerror: (() => void) | null = null;
+  onmessageerror: (() => void) | null = null;
+  terminated = false;
+
+  postMessage(message: WorkerMessage): void {
+    FakeWorker.behavior(this, message);
+  }
+
+  terminate(): void {
+    this.terminated = true;
+  }
+}
+
+describe("worker-client fallbacks", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    previewRendererMocks.renderPreview.mockReset();
+    bridgeMocks.renderFull.mockReset();
+    previewRendererMocks.renderPreview.mockResolvedValue({
+      width: 16,
+      height: 16,
+      imageData: { data: new Uint8ClampedArray(16 * 16 * 4) },
+      histogram: emptyHistogram(),
+    });
+    bridgeMocks.renderFull.mockResolvedValue(createFullResult());
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("does not fall back to main-thread preview rendering for deterministic worker errors", async () => {
+    FakeWorker.behavior = (worker, message) => {
+      if (message.kind === "cancel") {
+        return;
+      }
+
+      queueMicrotask(() => {
+        worker.onmessage?.({
+          data: {
+            kind: "error",
+            requestId: message.requestId,
+            payload: {
+              name: "RenderPipelineError",
+              message: "Deterministic worker preview failure",
+            },
+          },
+        } as MessageEvent);
+      });
+    };
+    vi.stubGlobal("Worker", FakeWorker as unknown as typeof Worker);
+
+    const { renderPreviewWithWorkerFallback } = await import("@/lib/image-pipeline/worker-client");
+
+    await expect(
+      renderPreviewWithWorkerFallback({
+        sourceUrl: "https://cdn.example.com/source.png",
+        steps: [],
+        previewWidth: 128,
+      }),
+    ).rejects.toMatchObject({
+      name: "RenderPipelineError",
+      message: "Deterministic worker preview failure",
+    });
+
+    expect(previewRendererMocks.renderPreview).not.toHaveBeenCalled();
+  });
+
+  it("does not fall back to main-thread full rendering for deterministic worker errors", async () => {
+    FakeWorker.behavior = (worker, message) => {
+      if (message.kind === "cancel") {
+        return;
+      }
+
+      queueMicrotask(() => {
+        worker.onmessage?.({
+          data: {
+            kind: "error",
+            requestId: message.requestId,
+            payload: {
+              name: "RenderPipelineError",
+              message: "Deterministic worker full render failure",
+            },
+          },
+        } as MessageEvent);
+      });
+    };
+    vi.stubGlobal("Worker", FakeWorker as unknown as typeof Worker);
+
+    const { renderFullWithWorkerFallback } = await import("@/lib/image-pipeline/worker-client");
+
+    await expect(
+      renderFullWithWorkerFallback({
+        sourceUrl: "https://cdn.example.com/source.png",
+        steps: [],
+        render: {
+          resolution: "original",
+          format: "png",
+        },
+      }),
+    ).rejects.toMatchObject({
+      name: "RenderPipelineError",
+      message: "Deterministic worker full render failure",
+    });
+
+    expect(bridgeMocks.renderFull).not.toHaveBeenCalled();
+  });
+
+  it("still falls back to the main thread when the Worker API is unavailable", async () => {
+    vi.stubGlobal("Worker", undefined);
+
+    const workerClient = await import("@/lib/image-pipeline/worker-client");
+
+    const previewResult = await workerClient.renderPreviewWithWorkerFallback({
+      sourceUrl: "https://cdn.example.com/source.png",
+      steps: [],
+      previewWidth: 128,
+    });
+    const fullResult = await workerClient.renderFullWithWorkerFallback({
+      sourceUrl: "https://cdn.example.com/source.png",
+      steps: [],
+      render: {
+        resolution: "original",
+        format: "png",
+      },
+    });
+
+    expect(previewRendererMocks.renderPreview).toHaveBeenCalledTimes(1);
+    expect(bridgeMocks.renderFull).toHaveBeenCalledTimes(1);
+    expect(previewResult.width).toBe(16);
+    expect(fullResult.format).toBe("png");
+  });
+});