@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/e2e/browser-runtime-evidence-requirements.ts

@@ -14,6 +14,7 @@ import {
   type ToolcraftComponentAcceptance,
   type ToolcraftControlSectionInventoryEntry,
   type ToolcraftInfinityCanvasCoverage,
+  type ToolcraftExportArtifactCoverage,
   type ToolcraftModelImportCoverage,
   type ToolcraftOrientationGizmoCoverage,
   type ToolcraftTimelinePlaybackCoverage,
@@ -35,10 +36,12 @@ type BrowserAcceptanceRequirementSource = Pick<
   | "infinityCanvasCoverage"
   | "layerCoverage"
   | "modelImportCoverage"
+  | "motionReferenceCoverage"
   | "orientationGizmoCoverage"
   | "referenceCoverage"
   | "referenceTimelineCoverage"
   | "renderScaleCoverage"
+  | "selectionScopeCoverage"
   | "target"
   | "timelineCoverage"
   | "timelinePlaybackCoverage"
@@ -112,6 +115,15 @@ const backgroundOutputCoverage = Object.keys(
   backgroundOutputEvidenceTypeByCoverage,
 ) as ToolcraftBackgroundOutputCoverage[];
 
+const exportArtifactEvidenceTypeByCoverage = {
+  "all-required-image-export-behavior": "image-export-artifact",
+  "all-required-svg-export-behavior": "svg-export-artifact",
+  "all-required-video-export-behavior": "video-export-artifact",
+} as const satisfies Record<
+  ToolcraftExportArtifactCoverage,
+  ToolcraftBrowserRuntimeRequirement["evidenceType"]
+>;
+
 const orientationEvidenceTypeByCoverage = {
   "axis-drag": "orientation-axis-drag",
   "axis-snap": "orientation-axis-snap",
@@ -132,6 +144,7 @@ const orientationGizmoCoverage = Object.keys(
 const infinityCanvasEvidenceTypeByCoverage = {
   "mode-and-restoration": "infinity-mode-restoration",
   "scene-bounds-image-export": "infinity-scene-bounds-image-export",
+  "scene-bounds-svg-export": "infinity-scene-bounds-svg-export",
   "scene-bounds-video-export": "infinity-scene-bounds-video-export",
 } as const satisfies Record<
   ToolcraftInfinityCanvasCoverage,
@@ -197,11 +210,7 @@ function deriveUnqualifiedToolcraftBrowserRuntimeRequirements(
       evidenceTypes.push(baseEvidenceType);
     }
     for (const coverage of exportArtifactCoverage) {
-      evidenceTypes.push(
-        coverage === "all-required-image-export-behavior"
-          ? "image-export-artifact"
-          : "video-export-artifact",
-      );
+      evidenceTypes.push(exportArtifactEvidenceTypeByCoverage[coverage]);
     }
 
     if (entry.canvasHandle && !hasOrientationCoverage) {
@@ -222,12 +231,19 @@ function deriveUnqualifiedToolcraftBrowserRuntimeRequirements(
     if (entry.layerCoverage) {
       evidenceTypes.push(layerEvidenceTypeByCoverage[entry.layerCoverage]);
     }
+    if (entry.selectionScopeCoverage === "two-entity-isolation") {
+      evidenceTypes.push("selection-scoped-control");
+    }
     if (entry.infinityCanvasCoverage) {
       evidenceTypes.push(
         infinityCanvasEvidenceTypeByCoverage[entry.infinityCanvasCoverage],
       );
     }
-    if (entry.referenceCoverage || entry.referenceTimelineCoverage) {
+    if (
+      entry.referenceCoverage ||
+      entry.referenceTimelineCoverage ||
+      (entry.motionReferenceCoverage?.length ?? 0) > 0
+    ) {
       evidenceTypes.push("reference-parity");
     }
     const backgroundCoverage =

package/templates/starter/e2e/browser-selection-scope-evidence.ts

@@ -0,0 +1,269 @@
+import { expect } from "@playwright/test";
+
+import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
+import {
+  resolveToolcraftProductRasterProbe,
+  type ToolcraftProductRasterProbe,
+  type ToolcraftResolvedProductRasterProbe,
+} from "./browser-product-raster-snapshot";
+import {
+  assertToolcraftBrowserActionForSession,
+  assertToolcraftBrowserProofSession,
+  getToolcraftBrowserActionSurface,
+  getToolcraftBrowserActionTarget,
+  getToolcraftBrowserProofPage,
+  readToolcraftBrowserObservation,
+  runToolcraftBrowserAction,
+  type ToolcraftBrowserAction,
+  type ToolcraftBrowserActionSurface,
+  type ToolcraftBrowserObservation,
+  type ToolcraftBrowserProofSession,
+} from "./browser-proof-session";
+import {
+  expectToolcraftPersistentOutcomeChange,
+  expectToolcraftStableOutcomeBaseline,
+} from "./stable-outcome-helpers";
+
+export type ToolcraftSelectionEntityProbe =
+  ToolcraftProductRasterProbe & Readonly<{ entityId: string }>;
+
+export type ToolcraftSelectionScopedControlOptions = Readonly<{
+  editEntityA: ToolcraftBrowserAction;
+  editEntityB: ToolcraftBrowserAction;
+  entityA: ToolcraftSelectionEntityProbe;
+  entityB: ToolcraftSelectionEntityProbe;
+  observePropertyValue: ToolcraftBrowserObservation<unknown>;
+  observeSelectedEntityId: ToolcraftBrowserObservation<string>;
+  propertySurface: ToolcraftBrowserActionSurface;
+  propertyTarget: string;
+  proofSession: ToolcraftBrowserProofSession;
+  requirementId: string;
+  selectionSurface: ToolcraftBrowserActionSurface;
+  selectionTarget: string;
+  selectEntityA: ToolcraftBrowserAction;
+  selectEntityB: ToolcraftBrowserAction;
+  stabilityIntervalMs?: number;
+  stabilitySamples?: number;
+  timeoutMs?: number;
+}>;
+
+type SelectionSnapshot = Readonly<{
+  controlValue: unknown;
+  entityA: string;
+  entityB: string;
+  selectedEntityId: string;
+}>;
+
+function regionsOverlap(
+  first: ToolcraftResolvedProductRasterProbe["bounds"],
+  second: ToolcraftResolvedProductRasterProbe["bounds"],
+): boolean {
+  return (
+    first.x < second.x + second.width &&
+    first.x + first.width > second.x &&
+    first.y < second.y + second.height &&
+    first.y + first.height > second.y
+  );
+}
+
+function requireActionTarget(
+  action: ToolcraftBrowserAction,
+  expectedTarget: string,
+  label: string,
+): void {
+  expect(
+    getToolcraftBrowserActionTarget(action),
+    `${label} must use the exact protected semantic target.`,
+  ).toBe(expectedTarget);
+}
+
+async function requireProductSceneProbe(
+  probe: ToolcraftResolvedProductRasterProbe,
+  entityId: string,
+): Promise<void> {
+  const provenance = await probe.locator.evaluate((element) => ({
+    insideProductScene: Boolean(
+      element.closest(
+        "[data-toolcraft-product-scene], [data-toolcraft-canvas-content], [data-toolcraft-product-output]",
+      ),
+    ),
+    isEditorHandle: Boolean(element.closest("[data-toolcraft-canvas-handle]")),
+  }));
+  expect(
+    provenance.insideProductScene,
+    `Selection entity "${entityId}" must probe product-scene pixels, not selection chrome.`,
+  ).toBe(true);
+  expect(
+    provenance.isEditorHandle,
+    `Selection entity "${entityId}" must not probe a canvas handle or gizmo.`,
+  ).toBe(false);
+}
+
+async function waitForSelectedEntity(
+  observation: ToolcraftBrowserObservation<string>,
+  entityId: string,
+  timeoutMs: number,
+): Promise<void> {
+  await expect
+    .poll(() => readToolcraftBrowserObservation(observation), {
+      message: `Selection must rebind the property control to "${entityId}".`,
+      timeout: timeoutMs,
+    })
+    .toBe(entityId);
+}
+
+export async function expectToolcraftSelectionScopedControl(
+  options: ToolcraftSelectionScopedControlOptions,
+): Promise<void> {
+  const {
+    editEntityA,
+    editEntityB,
+    entityA,
+    entityB,
+    observePropertyValue,
+    observeSelectedEntityId,
+    proofSession,
+    selectEntityA,
+    selectEntityB,
+  } = options;
+  const timeoutMs = options.timeoutMs ?? 5_000;
+  const stability = {
+    message: `Selection-scoped control "${options.requirementId}" must remain deterministic.`,
+    stabilityIntervalMs: options.stabilityIntervalMs ?? 50,
+    stabilitySamples: options.stabilitySamples ?? 3,
+    timeoutMs,
+  };
+
+  expect(entityA.entityId.trim()).not.toBe("");
+  expect(entityB.entityId.trim()).not.toBe("");
+  expect(entityA.entityId).not.toBe(entityB.entityId);
+  expect(options.propertyTarget.trim()).not.toBe("");
+  expect(options.selectionTarget.trim()).not.toBe("");
+
+  assertToolcraftBrowserProofSession(
+    observeSelectedEntityId,
+    selectEntityA,
+    selectEntityB,
+    editEntityA,
+    editEntityB,
+  );
+  assertToolcraftBrowserProofSession(
+    observePropertyValue,
+    selectEntityA,
+    selectEntityB,
+    editEntityA,
+    editEntityB,
+  );
+  for (const action of [
+    selectEntityA,
+    selectEntityB,
+    editEntityA,
+    editEntityB,
+  ]) {
+    assertToolcraftBrowserActionForSession(proofSession, action);
+  }
+
+  requireActionTarget(
+    selectEntityA,
+    options.selectionTarget,
+    "Entity A selection",
+  );
+  requireActionTarget(
+    selectEntityB,
+    options.selectionTarget,
+    "Entity B selection",
+  );
+  requireActionTarget(editEntityA, options.propertyTarget, "Entity A edit");
+  requireActionTarget(editEntityB, options.propertyTarget, "Entity B edit");
+  expect(getToolcraftBrowserActionSurface(selectEntityA)).toBe(
+    options.selectionSurface,
+  );
+  expect(getToolcraftBrowserActionSurface(selectEntityB)).toBe(
+    options.selectionSurface,
+  );
+  expect(getToolcraftBrowserActionSurface(editEntityA)).toBe(
+    options.propertySurface,
+  );
+  expect(getToolcraftBrowserActionSurface(editEntityB)).toBe(
+    options.propertySurface,
+  );
+
+  const page = await getToolcraftBrowserProofPage(proofSession);
+  const [probeA, probeB] = await Promise.all([
+    resolveToolcraftProductRasterProbe(page, entityA, timeoutMs),
+    resolveToolcraftProductRasterProbe(page, entityB, timeoutMs),
+  ]);
+  await Promise.all([
+    requireProductSceneProbe(probeA, entityA.entityId),
+    requireProductSceneProbe(probeB, entityB.entityId),
+  ]);
+  expect(
+    regionsOverlap(probeA.bounds, probeB.bounds),
+    "Selection entity probes must have disjoint positive-area bounds.",
+  ).toBe(false);
+
+  const capture = async (): Promise<SelectionSnapshot> => ({
+    controlValue: await readToolcraftBrowserObservation(observePropertyValue),
+    entityA: await probeA.capture(),
+    entityB: await probeB.capture(),
+    selectedEntityId: await readToolcraftBrowserObservation(
+      observeSelectedEntityId,
+    ),
+  });
+  const captureStable = async (): Promise<SelectionSnapshot> => {
+    const snapshot = await capture();
+    return expectToolcraftStableOutcomeBaseline(capture, snapshot, stability);
+  };
+
+  await runToolcraftBrowserAction(selectEntityB);
+  await waitForSelectedEntity(observeSelectedEntityId, entityB.entityId, timeoutMs);
+  const baselineB = await captureStable();
+
+  await runToolcraftBrowserAction(selectEntityA);
+  await waitForSelectedEntity(observeSelectedEntityId, entityA.entityId, timeoutMs);
+  const beforeA = await captureStable();
+  expect(beforeA.controlValue).not.toEqual(baselineB.controlValue);
+  expect(beforeA.entityA).toEqual(baselineB.entityA);
+  expect(beforeA.entityB).toEqual(baselineB.entityB);
+
+  await runToolcraftBrowserAction(editEntityA);
+  const afterA = await expectToolcraftPersistentOutcomeChange(
+    capture,
+    beforeA,
+    stability,
+  );
+  expect(afterA.selectedEntityId).toBe(entityA.entityId);
+  expect(afterA.controlValue).not.toEqual(beforeA.controlValue);
+  expect(afterA.entityA).not.toEqual(beforeA.entityA);
+  expect(afterA.entityB).toEqual(beforeA.entityB);
+
+  const beforeSelectB = await captureStable();
+  await runToolcraftBrowserAction(selectEntityB);
+  await waitForSelectedEntity(observeSelectedEntityId, entityB.entityId, timeoutMs);
+  const beforeB = await captureStable();
+  expect(beforeB.entityA).toEqual(beforeSelectB.entityA);
+  expect(beforeB.entityB).toEqual(beforeSelectB.entityB);
+  expect(beforeB.controlValue).toEqual(baselineB.controlValue);
+
+  await runToolcraftBrowserAction(editEntityB);
+  const afterB = await expectToolcraftPersistentOutcomeChange(
+    capture,
+    beforeB,
+    stability,
+  );
+  expect(afterB.selectedEntityId).toBe(entityB.entityId);
+  expect(afterB.controlValue).not.toEqual(beforeB.controlValue);
+  expect(afterB.entityB).not.toEqual(beforeB.entityB);
+  expect(afterB.entityA).toEqual(beforeB.entityA);
+
+  await attachToolcraftBrowserRuntimeEvidence({
+    evidenceType: "product-observable-change",
+    requirementId: options.requirementId,
+    target: options.propertyTarget,
+  });
+  await attachToolcraftBrowserRuntimeEvidence({
+    evidenceType: "selection-scoped-control",
+    requirementId: options.requirementId,
+    target: options.propertyTarget,
+  });
+}

package/templates/starter/e2e/browser-semantic-evidence-test-helpers.ts

@@ -4,6 +4,12 @@ import { parseToolcraftBrowserRuntimeEvidence } from "../src/app/test-evidence/b
 
 const rootSelector = '[data-slot="toolcraft-runtime-app"]';
 
+export type SyntheticSelectionSceneState = Readonly<{
+  controlValue: string;
+  fills: Readonly<Record<string, string>>;
+  selectedEntityId: string;
+}>;
+
 export function attachedEvidenceTypes(
   testInfo: TestInfo,
   startIndex: number,
@@ -80,3 +86,94 @@ export async function setSyntheticSwitchControlOwner(
     { checked, target },
   );
 }
+
+export async function mountSyntheticSelectionScene(
+  page: Page,
+  initialState: SyntheticSelectionSceneState,
+): Promise<void> {
+  await setSyntheticControlOwner(page, "selectedShape.fill", true);
+  await page.locator(rootSelector).evaluate((root, state) => {
+    const canvas = root.querySelector<HTMLElement>(
+      '[data-slot="toolcraft-runtime-canvas"]',
+    );
+    if (!canvas) {
+      throw new Error("Missing runtime canvas content for selection fixture.");
+    }
+
+    root.setAttribute("data-proof-selection-scope", JSON.stringify(state));
+    root.querySelector('[data-proof-selection-scene]')?.remove();
+    const scene = document.createElement("div");
+    scene.dataset.proofSelectionScene = "true";
+    scene.dataset.toolcraftProductOutput = "true";
+    Object.assign(scene.style, {
+      display: "flex",
+      gap: "32px",
+      padding: "16px",
+      pointerEvents: "auto",
+      position: "absolute",
+      inset: "16px auto auto 16px",
+      zIndex: "50",
+    });
+
+    for (const [entityId, fill] of Object.entries(state.fills)) {
+      const entity = document.createElement("button");
+      entity.dataset.proofEntity = entityId;
+      entity.type = "button";
+      entity.setAttribute("aria-label", `Select ${entityId}`);
+      Object.assign(entity.style, {
+        background: fill,
+        border: "0",
+        display: "block",
+        height: "48px",
+        padding: "0",
+        width: "48px",
+      });
+      entity.addEventListener("click", () => {
+        const current = JSON.parse(
+          root.getAttribute("data-proof-selection-scope") ?? "null",
+        ) as SyntheticSelectionSceneState;
+        root.setAttribute(
+          "data-proof-selection-scope",
+          JSON.stringify({
+            ...current,
+            controlValue: current.fills[entityId],
+            selectedEntityId: entityId,
+          }),
+        );
+      });
+      entity.addEventListener("pointerdown", (event) => {
+        event.stopPropagation();
+      });
+      scene.append(entity);
+    }
+
+    canvas.append(scene);
+  }, initialState);
+}
+
+export async function editSyntheticSelectedEntity(
+  page: Page,
+  fill: string,
+): Promise<void> {
+  await page.locator(rootSelector).evaluate((root, nextFill) => {
+    const current = JSON.parse(
+      root.getAttribute("data-proof-selection-scope") ?? "null",
+    ) as SyntheticSelectionSceneState;
+    const entity = root.querySelector<HTMLElement>(
+      `[data-proof-entity="${CSS.escape(current.selectedEntityId)}"]`,
+    );
+    if (!entity) {
+      throw new Error(`Missing selected entity ${current.selectedEntityId}.`);
+    }
+    const nextState = {
+      ...current,
+      controlValue: nextFill,
+      fills: { ...current.fills, [current.selectedEntityId]: nextFill },
+    };
+    entity.style.background = nextFill;
+    root.setAttribute(
+      "data-proof-selection-scope",
+      JSON.stringify(nextState),
+    );
+  }, fill);
+}

package/templates/starter/e2e/browser-svg-export-evidence.spec.ts

@@ -0,0 +1,79 @@
+import { expect, test } from "@playwright/test";
+
+import { expectToolcraftSvgExportArtifact } from "./browser-svg-export-evidence";
+import { createToolcraftSvgFixtureDownload } from "./svg-download-test-fixtures";
+
+const validSvg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="48" viewBox="0 0 64 48"><g data-toolcraft-product-scene="true"><rect data-column-track="true" x="8" y="8" width="16" height="32" fill="#52AAFF"/></g></svg>`;
+
+test("protected SVG evidence attaches only after exact product semantics pass", async ({
+  page,
+}) => {
+  await page.goto("/");
+
+  const inspected = await expectToolcraftSvgExportArtifact(
+    async () => createToolcraftSvgFixtureDownload(page, validSvg),
+    {
+      expectedElements: [
+        {
+          attributes: {
+            fill: "#52AAFF",
+            height: "32",
+            width: "16",
+          },
+          selector: 'rect[data-column-track="true"]',
+        },
+      ],
+      expectedBackgroundColor: null,
+      expectedHeight: 48,
+      expectedWidth: 64,
+      page,
+      requirementId: "fixture.svg",
+    },
+  );
+
+  expect(inspected.inspection.contentHash).not.toHaveLength(0);
+  expect(
+    test.info().attachments.some(
+      ({ name }) => name === "toolcraft.browser-runtime-evidence",
+    ),
+  ).toBe(true);
+});
+
+test("protected SVG evidence rejects empty or mismatched product expectations", async ({
+  page,
+}) => {
+  await page.goto("/");
+  await expect(
+    expectToolcraftSvgExportArtifact(
+      async () => createToolcraftSvgFixtureDownload(page, validSvg),
+      {
+        expectedElements: [],
+        expectedBackgroundColor: null,
+        expectedHeight: 48,
+        expectedWidth: 64,
+        page,
+        requirementId: "fixture.svg.empty",
+      },
+    ),
+  ).rejects.toThrow("requires product vector expectations");
+
+  await expect(
+    expectToolcraftSvgExportArtifact(
+      async () => createToolcraftSvgFixtureDownload(page, validSvg),
+      {
+        expectedElements: [
+          {
+            attributes: { fill: "#FF0000" },
+            selector: 'rect[data-column-track="true"]',
+          },
+        ],
+        expectedBackgroundColor: null,
+        expectedHeight: 48,
+        expectedWidth: 64,
+        page,
+        requirementId: "fixture.svg.color",
+      },
+    ),
+  ).rejects.toThrow("needs fill=#FF0000");
+});

package/templates/starter/e2e/browser-svg-export-evidence.ts

@@ -0,0 +1,152 @@
+import { expect, type Download, type Page } from "@playwright/test";
+import {
+  TOOLCRAFT_SVG_BACKGROUND_ATTRIBUTE,
+  TOOLCRAFT_SVG_NON_RENDERING_CONTAINERS,
+  TOOLCRAFT_SVG_PRODUCT_SCENE_ATTRIBUTE,
+  TOOLCRAFT_SVG_VECTOR_PRIMITIVES,
+} from "@repo/toolcraft-runtime";
+
+import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
+import {
+  getToolcraftBrowserActionTarget,
+  isToolcraftBrowserAction,
+  runToolcraftBrowserValueAction,
+  type ToolcraftBrowserAction,
+} from "./browser-proof-session";
+import {
+  inspectToolcraftSvgDownload,
+  type ToolcraftInspectedSvgArtifact,
+} from "./svg-artifact-inspection";
+
+export type ToolcraftSvgElementExpectation = Readonly<{
+  attributes?: Readonly<Record<string, string>>;
+  selector: string;
+  textContent?: string;
+}>;
+
+async function assertProductExpectations(
+  page: Page,
+  source: string,
+  expectations: readonly ToolcraftSvgElementExpectation[],
+): Promise<void> {
+  if (expectations.length === 0) {
+    throw new Error("SVG export evidence requires product vector expectations.");
+  }
+  await page.evaluate(
+    ({
+      backgroundAttribute,
+      expectedElements,
+      nonRenderingNames,
+      productSceneAttribute,
+      svgSource,
+      vectorPrimitiveNames,
+    }) => {
+      const parsed = new DOMParser().parseFromString(
+        svgSource,
+        "image/svg+xml",
+      );
+      const vectorNames = new Set(vectorPrimitiveNames);
+      const nonRendering = new Set(nonRenderingNames);
+      const productScene = parsed.querySelector(
+        `[${productSceneAttribute}="true"]`,
+      );
+      if (!productScene) {
+        throw new Error("SVG product expectations need a product scene.");
+      }
+      for (const expected of expectedElements) {
+        if (
+          !expected.selector.trim() ||
+          (Object.keys(expected.attributes ?? {}).length === 0 &&
+            expected.textContent === undefined)
+        ) {
+          throw new Error(
+            "Each SVG product expectation needs a selector and exact attribute or text semantics.",
+          );
+        }
+        const element = productScene.querySelector(expected.selector);
+        if (!element || !vectorNames.has(element.localName.toLowerCase())) {
+          throw new Error(
+            `SVG product expectation did not match a vector primitive: ${expected.selector}`,
+          );
+        }
+        if (element.hasAttribute(backgroundAttribute)) {
+          throw new Error("SVG product expectations cannot target runtime background.");
+        }
+        let ancestor = element.parentElement;
+        while (ancestor && !ancestor.isSameNode(productScene)) {
+          if (nonRendering.has(ancestor.localName.toLowerCase())) {
+            throw new Error(
+              `SVG product expectation targets non-rendering content: ${expected.selector}`,
+            );
+          }
+          ancestor = ancestor.parentElement;
+        }
+        for (const [name, value] of Object.entries(expected.attributes ?? {})) {
+          if (element.getAttribute(name) !== value) {
+            throw new Error(
+              `SVG product expectation ${expected.selector} needs ${name}=${value}.`,
+            );
+          }
+        }
+        if (
+          expected.textContent !== undefined &&
+          element.textContent !== expected.textContent
+        ) {
+          throw new Error(
+            `SVG product expectation ${expected.selector} has unexpected text.`,
+          );
+        }
+      }
+    },
+    {
+      backgroundAttribute: TOOLCRAFT_SVG_BACKGROUND_ATTRIBUTE,
+      expectedElements: expectations,
+      nonRenderingNames: TOOLCRAFT_SVG_NON_RENDERING_CONTAINERS,
+      productSceneAttribute: TOOLCRAFT_SVG_PRODUCT_SCENE_ATTRIBUTE,
+      svgSource: source,
+      vectorPrimitiveNames: TOOLCRAFT_SVG_VECTOR_PRIMITIVES,
+    },
+  );
+}
+
+export async function expectToolcraftSvgExportArtifact(
+  produceDownload:
+    | (() => Promise<Download>)
+    | ToolcraftBrowserAction<"interaction", Download>,
+  options: Readonly<{
+    expectedElements: readonly ToolcraftSvgElementExpectation[];
+    expectedBackgroundColor: string | null;
+    expectedHeight: number;
+    expectedWidth: number;
+    page: Page;
+    requirementId: string;
+  }>,
+): Promise<ToolcraftInspectedSvgArtifact> {
+  const target = isToolcraftBrowserAction(produceDownload)
+    ? getToolcraftBrowserActionTarget(produceDownload)
+    : undefined;
+  const download = isToolcraftBrowserAction(produceDownload)
+    ? await runToolcraftBrowserValueAction(produceDownload)
+    : await produceDownload();
+  const inspected = await inspectToolcraftSvgDownload({
+    download,
+    page: options.page,
+  });
+  expect(inspected.inspection.width).toBe(options.expectedWidth);
+  expect(inspected.inspection.height).toBe(options.expectedHeight);
+  expect(inspected.inspection.backgroundColor).toBe(
+    options.expectedBackgroundColor,
+  );
+  expect(inspected.inspection.contentHash).not.toHaveLength(0);
+  await assertProductExpectations(
+    options.page,
+    inspected.source,
+    options.expectedElements,
+  );
+  await attachToolcraftBrowserRuntimeEvidence({
+    evidenceType: "svg-export-artifact",
+    requirementId: options.requirementId,
+    target,
+  });
+  return inspected;
+}