@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/e2e/app-browser-shell.spec.ts

@@ -74,11 +74,19 @@ test("product observable helper catches changed and unchanged output", async ({
   `);
 
   const snapshot = await getToolcraftProductObservableSnapshot(page);
-
-  expect(
-    snapshot,
-    "The product observable helper should read marked product output.",
-  ).toContain("Before");
+  const decodedSnapshot = JSON.parse(snapshot) as {
+    height: number;
+    rasterHash: string;
+    width: number;
+  };
+
+  expect(decodedSnapshot).toMatchObject({
+    height: expect.any(Number),
+    rasterHash: expect.stringMatching(/^[a-f0-9]+$/u),
+    width: expect.any(Number),
+  });
+  expect(decodedSnapshot.height).toBeGreaterThan(0);
+  expect(decodedSnapshot.width).toBeGreaterThan(0);
 
   await expectToolcraftProductObservableToChange(page, async () => {
     await page.locator("#change-output").evaluate((button) => {

package/templates/starter/e2e/app-performance-path-adapters.ts

@@ -1,4 +1,11 @@
-import type { ToolcraftPerformancePathAdapter } from "./performance-path-adapter-contract";
+import type {
+  ToolcraftPerformanceCanvasBacking,
+  ToolcraftPerformancePathAdapter,
+} from "./performance-path-adapter-contract";
+
+export const appPerformanceCanvasBacking:
+  | ToolcraftPerformanceCanvasBacking
+  | undefined = undefined;
 
 export const appPerformancePathAdapters =
   [] as const satisfies readonly ToolcraftPerformancePathAdapter[];

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-conditional-output-evidence-helpers.ts → browser-background-output-evidence.ts}

@@ -2,20 +2,12 @@ import { expect } from "@playwright/test";
 
 import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
 import {
-  countToolcraftControlOwnersByTarget,
-  getToolcraftControlFieldByTarget,
-} from "./browser-control-target-helpers";
-import {
-  assertToolcraftBrowserActionForSession,
   assertToolcraftBrowserProofSession,
   getToolcraftBrowserActionTarget,
-  getToolcraftBrowserProofPage,
   readToolcraftBrowserObservation,
-  runToolcraftBrowserAction,
   runToolcraftBrowserValueAction,
   type ToolcraftBrowserAction,
   type ToolcraftBrowserObservation,
-  type ToolcraftBrowserProofSession,
 } from "./browser-proof-session";
 import {
   assertToolcraftProducedArtifact,
@@ -77,66 +69,6 @@ function validateBackgroundPreviewObservation(
   ).not.toBe("");
 }
 
-export async function expectToolcraftConditionalControlVisibility(
-  session: ToolcraftBrowserProofSession,
-  hideControl: ToolcraftBrowserAction,
-  showControl: ToolcraftBrowserAction,
-  {
-    requirementId,
-    target,
-    timeoutMs = 5_000,
-  }: {
-    requirementId: string;
-    target: string;
-    timeoutMs?: number;
-  },
-): Promise<void> {
-  const normalizedTarget = target.trim();
-  expect(
-    normalizedTarget,
-    "Conditional-visibility evidence requires the dependent schema target.",
-  ).not.toBe("");
-  assertToolcraftBrowserActionForSession(session, hideControl);
-  assertToolcraftBrowserActionForSession(session, showControl);
-  const hideGateTarget = requireTargetScopedAction(
-    hideControl,
-    "Conditional-visibility hide evidence requires a target-scoped gating control action.",
-  );
-  expect(
-    requireTargetScopedAction(
-      showControl,
-      "Conditional-visibility show evidence requires a target-scoped gating control action.",
-    ),
-    "Conditional-visibility hide and show actions must exercise the same gating control.",
-  ).toBe(hideGateTarget);
-
-  const page = await getToolcraftBrowserProofPage(session);
-  await getToolcraftControlFieldByTarget(page, normalizedTarget);
-  await runToolcraftBrowserAction(hideControl);
-  await expect
-    .poll(
-      () => countToolcraftControlOwnersByTarget(page, normalizedTarget),
-      {
-        message: `Conditional control "${normalizedTarget}" should be absent while its gating state is unavailable.`,
-        timeout: timeoutMs,
-      },
-    )
-    .toBe(0);
-  await attachToolcraftBrowserRuntimeEvidence({
-    evidenceType: "conditional-control-hidden",
-    requirementId,
-    target: normalizedTarget,
-  });
-
-  await runToolcraftBrowserAction(showControl);
-  await getToolcraftControlFieldByTarget(page, normalizedTarget);
-  await attachToolcraftBrowserRuntimeEvidence({
-    evidenceType: "conditional-control-visible",
-    requirementId,
-    target: normalizedTarget,
-  });
-}
-
 export async function expectToolcraftBackgroundOutputSemantics<
   TImageArtifact,
   TVideoArtifact = never,

package/templates/starter/e2e/browser-control-applicability-evidence.ts

@@ -0,0 +1,114 @@
+import { expect, type Page } from "@playwright/test";
+
+import {
+  getToolcraftApplicabilityRequirementId,
+  type ToolcraftControlApplicabilityCase,
+} from "../src/app/starter-acceptance";
+import {
+  countToolcraftControlOwnersByTarget,
+  getToolcraftControlFieldByTarget,
+} from "./browser-control-target-helpers";
+import {
+  assertToolcraftBrowserActionForSession,
+  getToolcraftBrowserActionTarget,
+  getToolcraftBrowserProofPage,
+  runToolcraftBrowserAction,
+  type ToolcraftBrowserAction,
+  type ToolcraftBrowserProofSession,
+} from "./browser-proof-session";
+import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
+
+function requireSelectorOptionLabel(
+  applicabilityCase: ToolcraftControlApplicabilityCase,
+): string {
+  if (!applicabilityCase.selectorOptionLabel) {
+    throw new Error(
+      `Applicability case for ${applicabilityCase.selectorTarget} requires a selector option label.`,
+    );
+  }
+
+  return applicabilityCase.selectorOptionLabel;
+}
+
+async function expectToolcraftApplicabilitySelectorState(
+  page: Page,
+  applicabilityCase: ToolcraftControlApplicabilityCase,
+): Promise<void> {
+  const control = await getToolcraftControlFieldByTarget(
+    page,
+    applicabilityCase.selectorTarget,
+  );
+
+  switch (applicabilityCase.selectorControlType) {
+    case "checkbox":
+    case "switch":
+      await expect(
+        control.getByRole(applicabilityCase.selectorControlType),
+      ).toHaveAttribute("aria-checked", String(applicabilityCase.selectorValue));
+      return;
+    case "imagePicker":
+    case "segmented":
+      await expect(
+        control.getByRole("button", {
+          name: requireSelectorOptionLabel(applicabilityCase),
+        }),
+      ).toHaveAttribute("aria-pressed", "true");
+      return;
+    case "select":
+      await expect(control.getByRole("combobox")).toContainText(
+        requireSelectorOptionLabel(applicabilityCase),
+      );
+      return;
+    case "slider":
+      await expect(control.getByRole("slider")).toHaveAttribute(
+        "aria-valuenow",
+        String(applicabilityCase.selectorValue),
+      );
+      return;
+    case "tabs":
+      await expect(
+        control.getByRole("tab", {
+          name: requireSelectorOptionLabel(applicabilityCase),
+        }),
+      ).toHaveAttribute("aria-selected", "true");
+  }
+}
+
+export async function expectToolcraftControlApplicabilityState(
+  session: ToolcraftBrowserProofSession,
+  selectBranch: ToolcraftBrowserAction,
+  applicabilityCase: ToolcraftControlApplicabilityCase,
+  options: { baseRequirementId: string; timeoutMs?: number },
+): Promise<void> {
+  const selectorTarget = getToolcraftBrowserActionTarget(selectBranch)?.trim();
+  expect(
+    selectorTarget,
+    "Control-applicability evidence requires a target-scoped selector action.",
+  ).toBe(applicabilityCase.selectorTarget);
+  assertToolcraftBrowserActionForSession(session, selectBranch);
+
+  const page = await getToolcraftBrowserProofPage(session);
+  await runToolcraftBrowserAction(selectBranch);
+  await expectToolcraftApplicabilitySelectorState(page, applicabilityCase);
+  await expect
+    .poll(
+      () => countToolcraftControlOwnersByTarget(page, applicabilityCase.target),
+      {
+        message: `Control "${applicabilityCase.target}" should be ${applicabilityCase.expectation} for ${applicabilityCase.selectorTarget}=${JSON.stringify(applicabilityCase.selectorValue)}.`,
+        timeout: options.timeoutMs ?? 5_000,
+      },
+    )
+    .toBe(applicabilityCase.expectation === "hidden" ? 0 : 1);
+
+  await attachToolcraftBrowserRuntimeEvidence({
+    evidenceType:
+      applicabilityCase.expectation === "hidden"
+        ? "control-applicability-hidden"
+        : "control-applicability-visible",
+    requirementId: getToolcraftApplicabilityRequirementId(
+      options.baseRequirementId,
+      applicabilityCase,
+    ),
+    target: applicabilityCase.target,
+  });
+}