@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/e2e/browser-infinity-canvas-evidence.ts

@@ -1,21 +1,15 @@
 import { expect, type Page } from "@playwright/test";
 
 import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
-import {
-  assertToolcraftBrowserProofSession,
-  getToolcraftBrowserActionTarget,
-  readToolcraftBrowserObservation,
-  runToolcraftBrowserAction,
-  runToolcraftBrowserValueAction,
-  type ToolcraftBrowserAction,
-  type ToolcraftBrowserObservation,
-  type ToolcraftBrowserProofSession,
-} from "./browser-proof-session";
-import {
-  assertToolcraftProducedArtifact,
-  validateToolcraftExportArtifactInspection,
-  type ToolcraftExportArtifactInspection,
-} from "./export-artifact-helpers";
+
+export {
+  createToolcraftUnavailableImageResourceFixture,
+  expectToolcraftInfinityCanvasUnavailableImageExportEvidence,
+} from "./browser-infinity-canvas-unavailable-image-evidence";
+export type {
+  ToolcraftUnavailableImageResourceFixture,
+  ToolcraftUnavailableImageResourceObservation,
+} from "./browser-infinity-canvas-unavailable-image-evidence";
 
 export type InfinityCanvasObservation = Readonly<{
   artboardPresent: boolean;
@@ -24,6 +18,7 @@ export type InfinityCanvasObservation = Readonly<{
   finiteControlSize: { height: number; width: number } | null;
   finiteControlsPresent: boolean;
   overflow: string;
+  productSceneStatus: "empty" | "ready" | "unavailable" | null;
   sceneRect: { height: number; width: number; x: number; y: number } | null;
   viewportOffset: { x: number; y: number };
 }>;
@@ -97,18 +92,17 @@ export async function observeInfinityCanvasBackground(
 
 export async function observeInfinityCanvas(
   page: Page,
-  sceneSelector?: string,
 ): Promise<InfinityCanvasObservation> {
-  return page.evaluate((selector) => {
+  return page.evaluate(() => {
     const surface = document.querySelector<HTMLElement>(
       "[data-toolcraft-canvas-mode]",
     );
     const world = document.querySelector<HTMLElement>(
       "[data-toolcraft-canvas-world]",
     );
-    const scene = selector
-      ? document.querySelector<HTMLElement>(selector)
-      : null;
+    const productScene = document.querySelector<HTMLElement>(
+      "[data-toolcraft-product-scene]",
+    );
     const finiteControlsPresent = [
       "canvas.aspectRatio",
       "canvas.size.width",
@@ -144,7 +138,7 @@ export async function observeInfinityCanvas(
       const parsed = Number.parseFloat(value ?? "");
       return Number.isFinite(parsed) ? parsed : null;
     };
-    const style = scene?.style;
+    const style = productScene?.style;
     const sceneValues = style
       ? {
           height: read(style.height),
@@ -162,11 +156,11 @@ export async function observeInfinityCanvas(
             y: sceneValues.y!,
           }
         : null;
+    const productSceneStatus =
+      productScene?.dataset.toolcraftProductSceneStatus;
 
     return {
-      artboardPresent: Boolean(
-        editableCanvas,
-      ),
+      artboardPresent: Boolean(editableCanvas),
       canvasMode: surface?.getAttribute("data-toolcraft-canvas-mode") ?? null,
       finiteCanvasSize:
         canvasWidth === null || canvasHeight === null
@@ -178,13 +172,19 @@ export async function observeInfinityCanvas(
           : { height: controlHeight, width: controlWidth },
       finiteControlsPresent,
       overflow: surface ? getComputedStyle(surface).overflow : "missing",
+      productSceneStatus:
+        productSceneStatus === "ready" ||
+        productSceneStatus === "empty" ||
+        productSceneStatus === "unavailable"
+          ? productSceneStatus
+          : null,
       sceneRect,
       viewportOffset: {
         x: Number(world?.dataset.toolcraftCanvasOffsetX ?? 0),
         y: Number(world?.dataset.toolcraftCanvasOffsetY ?? 0),
       },
     };
-  }, sceneSelector);
+  });
 }
 
 export function expectInfiniteCanvasObservation(
@@ -197,7 +197,10 @@ export function expectInfiniteCanvasObservation(
   expect(observation.finiteControlSize).toEqual(null);
   expect(observation.finiteControlsPresent).toBe(false);
   expect(observation.overflow).toBe("visible");
-  if (expectedSceneRect) expect(observation.sceneRect).toEqual(expectedSceneRect);
+  if (expectedSceneRect) {
+    expect(observation.productSceneStatus).toBe("ready");
+    expect(observation.sceneRect).toEqual(expectedSceneRect);
+  }
   expect(Number.isFinite(observation.viewportOffset.x)).toBe(true);
   expect(Number.isFinite(observation.viewportOffset.y)).toBe(true);
 }
@@ -367,321 +370,6 @@ export async function expectToolcraftInfinityCanvasImageExportEvidence(
   });
 }
 
-declare const toolcraftUnavailableImageResourceFixtureBrand: unique symbol;
-
-export type ToolcraftUnavailableImageResourceObservation = Readonly<{
-  assetId?: string;
-  fileName?: string;
-  lifecycle?: "ready" | "unavailable";
-  message?: string;
-  requestId?: string;
-  resolverAvailable?: boolean;
-  status: "active" | "cleaned" | "error" | "missing";
-}>;
-
-export type ToolcraftUnavailableImageResourceFixture = Readonly<{
-  readonly [toolcraftUnavailableImageResourceFixtureBrand]: true;
-}>;
-
-type ToolcraftUnavailableImageResourceFixtureRecord = Readonly<{
-  activate: ToolcraftBrowserAction;
-  cleanup: ToolcraftBrowserAction;
-  fileName: string;
-  observe: ToolcraftBrowserObservation<ToolcraftUnavailableImageResourceObservation>;
-  requestId: string;
-  session: ToolcraftBrowserProofSession;
-  target: string;
-}>;
-
-const unavailableImageResourceFixtureRecords = new WeakMap<
-  object,
-  ToolcraftUnavailableImageResourceFixtureRecord
->();
-let unavailableImageResourceFixtureSequence = 0;
-
-function requireUnavailableImageResourceFixture(
-  fixture: ToolcraftUnavailableImageResourceFixture,
-): ToolcraftUnavailableImageResourceFixtureRecord {
-  const record =
-    typeof fixture === "object" && fixture !== null
-      ? unavailableImageResourceFixtureRecords.get(fixture)
-      : undefined;
-  if (!record) {
-    throw new Error(
-      "Unavailable-image export evidence requires the protected Toolcraft unavailable-resource fixture facade.",
-    );
-  }
-  return record;
-}
-
-function validateUnavailableImageResourceObservation(
-  observation: ToolcraftUnavailableImageResourceObservation,
-  expected: Readonly<{
-    fileName: string;
-    requestId: string;
-    status: "active" | "cleaned";
-  }>,
-): void {
-  if (observation.status === "error") {
-    throw new Error(
-      observation.message ??
-        "The Toolcraft unavailable-resource proof fixture failed.",
-    );
-  }
-  expect(
-    observation,
-    `Unavailable-resource proof "${expected.requestId}" must publish its exact typed state.`,
-  ).toMatchObject(
-    expected.status === "active"
-      ? {
-          fileName: expected.fileName,
-          lifecycle: "unavailable",
-          requestId: expected.requestId,
-          resolverAvailable: false,
-          status: "active",
-        }
-      : {
-          fileName: expected.fileName,
-          lifecycle: "ready",
-          requestId: expected.requestId,
-          resolverAvailable: true,
-          status: "cleaned",
-        },
-  );
-  expect(
-    observation.assetId?.trim(),
-    "Unavailable-resource proof must identify the exact affected runtime asset.",
-  ).toBeTruthy();
-}
-
-export function createToolcraftUnavailableImageResourceFixture(
-  session: ToolcraftBrowserProofSession,
-  {
-    fileName,
-    sourceTarget,
-    target,
-  }: Readonly<{
-    fileName: string;
-    sourceTarget?: string;
-    target: string;
-  }>,
-): ToolcraftUnavailableImageResourceFixture {
-  const normalizedFileName = fileName.trim();
-  const normalizedSourceTarget = sourceTarget?.trim();
-  const normalizedTarget = target.trim();
-  expect(
-    normalizedFileName,
-    "Unavailable-resource proof requires an exact non-empty image file name.",
-  ).not.toBe("");
-  expect(
-    normalizedTarget,
-    "Unavailable-resource proof requires an exact semantic acceptance target.",
-  ).not.toBe("");
-  if (sourceTarget !== undefined) {
-    expect(
-      normalizedSourceTarget,
-      "Unavailable-resource proof sourceTarget must be non-empty when provided.",
-    ).not.toBe("");
-  }
-
-  const requestId =
-    `unavailable-image-${++unavailableImageResourceFixtureSequence}`;
-  const request = {
-    fileName: normalizedFileName,
-    requestId,
-    ...(normalizedSourceTarget
-      ? { sourceTarget: normalizedSourceTarget }
-      : {}),
-  };
-  const runRequest = (
-    action: "activate" | "cleanup",
-    expectedStatus: "active" | "cleaned",
-  ) =>
-    session.targetAction(normalizedTarget, async (page) => {
-      await page.evaluate(
-        ({ detail, eventName }) => {
-          document.dispatchEvent(
-            new CustomEvent(eventName, {
-              detail,
-            }),
-          );
-        },
-        {
-          detail: { ...request, action },
-          eventName:
-            "toolcraft.browser-proof.unavailable-resource-request",
-        },
-      );
-      await expect
-        .poll(
-          async () => {
-            const raw = await page
-              .locator('[data-slot="toolcraft-runtime-app"]')
-              .getAttribute(
-                "data-toolcraft-unavailable-resource-evidence",
-              );
-            if (!raw) return "missing";
-            const observation = JSON.parse(
-              raw,
-            ) as ToolcraftUnavailableImageResourceObservation;
-            if (
-              observation.requestId === requestId &&
-              observation.status === "error"
-            ) {
-              throw new Error(
-                observation.message ??
-                  "The Toolcraft unavailable-resource proof fixture failed.",
-              );
-            }
-            return observation.requestId === requestId
-              ? observation.status
-              : "other-request";
-          },
-          {
-            message:
-              `Unavailable-resource proof "${requestId}" should reach ${expectedStatus}.`,
-          },
-        )
-        .toBe(expectedStatus);
-    });
-  const activate = runRequest("activate", "active");
-  const cleanup = runRequest("cleanup", "cleaned");
-  const observe = session.observe((root) => {
-    const raw = root.getAttribute(
-      "data-toolcraft-unavailable-resource-evidence",
-    );
-    if (!raw) {
-      return { status: "missing" as const };
-    }
-    try {
-      return JSON.parse(
-        raw,
-      ) as ToolcraftUnavailableImageResourceObservation;
-    } catch {
-      return {
-        message: "Unavailable-resource proof published malformed state.",
-        status: "error" as const,
-      };
-    }
-  });
-  const fixture = Object.freeze({}) as ToolcraftUnavailableImageResourceFixture;
-  unavailableImageResourceFixtureRecords.set(fixture, {
-    activate,
-    cleanup,
-    fileName: normalizedFileName,
-    observe,
-    requestId,
-    session,
-    target: normalizedTarget,
-  });
-  return fixture;
-}
-
-export async function expectToolcraftInfinityCanvasUnavailableImageExportEvidence<
-  TArtifact,
->(
-  fixture: ToolcraftUnavailableImageResourceFixture,
-  produceArtifact: ToolcraftBrowserAction<"interaction", TArtifact>,
-  inspectArtifact: (
-    artifact: TArtifact,
-  ) => Promise<ToolcraftExportArtifactInspection> | ToolcraftExportArtifactInspection,
-  {
-    expectedSize,
-    requirementId,
-  }: Readonly<{
-    expectedSize: Readonly<{ height: number; width: number }>;
-    requirementId: string;
-  }>,
-): Promise<ToolcraftExportArtifactInspection> {
-  const record = requireUnavailableImageResourceFixture(fixture);
-  assertToolcraftBrowserProofSession(
-    record.observe,
-    record.activate,
-    record.cleanup,
-    produceArtifact,
-  );
-  const exportTarget = getToolcraftBrowserActionTarget(produceArtifact)?.trim();
-  expect(
-    exportTarget,
-    "Unavailable-image export evidence requires a target-scoped artifact action.",
-  ).toBe(record.target);
-
-  let activationAttempted = false;
-  let cleanupSucceeded = false;
-  let inspection: ToolcraftExportArtifactInspection | null = null;
-  let outputVerified = false;
-  try {
-    activationAttempted = true;
-    await runToolcraftBrowserAction(record.activate);
-    validateUnavailableImageResourceObservation(
-      await readToolcraftBrowserObservation(record.observe),
-      {
-        fileName: record.fileName,
-        requestId: record.requestId,
-        status: "active",
-      },
-    );
-
-    const artifact = await runToolcraftBrowserValueAction(produceArtifact);
-    assertToolcraftProducedArtifact(artifact, requirementId);
-    inspection = await inspectArtifact(artifact);
-    validateToolcraftExportArtifactInspection(inspection, requirementId);
-    expect(
-      inspection,
-      `Unavailable-image export "${requirementId}" must decode to the expected visible scene bounds.`,
-    ).toMatchObject(expectedSize);
-    validateUnavailableImageResourceObservation(
-      await readToolcraftBrowserObservation(record.observe),
-      {
-        fileName: record.fileName,
-        requestId: record.requestId,
-        status: "active",
-      },
-    );
-    outputVerified = true;
-  } finally {
-    const current = activationAttempted
-      ? await readToolcraftBrowserObservation(record.observe)
-      : null;
-    if (
-      current?.requestId === record.requestId &&
-      current.status === "active"
-    ) {
-      await runToolcraftBrowserAction(record.cleanup);
-      validateUnavailableImageResourceObservation(
-        await readToolcraftBrowserObservation(record.observe),
-        {
-          fileName: record.fileName,
-          requestId: record.requestId,
-          status: "cleaned",
-        },
-      );
-      cleanupSucceeded = true;
-    } else if (outputVerified) {
-      throw new Error(
-        "Unavailable-image export evidence requires the exact active fixture to remain available for deterministic cleanup.",
-      );
-    }
-  }
-
-  if (!cleanupSucceeded || !inspection) {
-    throw new Error(
-      "Unavailable-image export evidence requires successful fixture cleanup before publication.",
-    );
-  }
-  await attachToolcraftBrowserRuntimeEvidence({
-    evidenceType: "exported-artifact",
-    requirementId,
-    target: exportTarget,
-  });
-  await attachToolcraftBrowserRuntimeEvidence({
-    evidenceType: "infinity-scene-bounds-image-export",
-    requirementId,
-    target: exportTarget,
-  });
-  return inspection;
-}
-
 export async function expectToolcraftInfinityCanvasVideoExportEvidence(
   artifacts: Readonly<{
     finite: Readonly<{