@pixel-point/toolcraft 0.0.16 → 0.0.17

package/templates/starter/e2e/app-performance.spec.ts

@@ -4,7 +4,10 @@ import { deriveToolcraftPerformancePaths } from "@repo/toolcraft-runtime";
 
 import { starterPerformance } from "../src/app/starter-performance";
 import { starterSchema } from "../src/app/starter-schema";
-import { appPerformancePathAdapters } from "./app-performance-path-adapters";
+import {
+  appPerformanceCanvasBacking,
+  appPerformancePathAdapters,
+} from "./app-performance-path-adapters";
 import {
   compileToolcraftPerformancePathAdapterMatrix,
   getToolcraftPerformancePathTestName,
@@ -25,20 +28,24 @@ test("browser perf: toolcraft environment", async ({ page }) => {
 });
 
 test("browser perf: toolcraft adapter catalog", () => {
-  compileToolcraftPerformancePathAdapterMatrix(
-    performancePaths,
-    appPerformancePathAdapters,
-  );
+  compileToolcraftPerformancePathAdapterMatrix({
+    adapters: appPerformancePathAdapters,
+    canvasBacking: appPerformanceCanvasBacking,
+    paths: performancePaths,
+    schema: starterSchema,
+  });
 });
 
 for (const path of performancePaths) {
   test(getToolcraftPerformancePathTestName(path), async ({ page }) => {
-    const [entry] = compileToolcraftPerformancePathAdapterMatrix(
-      [path],
-      appPerformancePathAdapters.filter(
+    const [entry] = compileToolcraftPerformancePathAdapterMatrix({
+      adapters: appPerformancePathAdapters.filter(
         (adapter) => adapter.pathId === path.id,
       ),
-    );
+      canvasBacking: appPerformanceCanvasBacking,
+      paths: [path],
+      schema: starterSchema,
+    });
     if (!entry) {
       throw new Error(`Missing compiled performance path "${path.id}".`);
     }

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;
@@ -367,321 +361,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<{