@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/e2e/app-browser-orientation-evidence.spec.ts

@@ -14,6 +14,81 @@ import {
   setProofState,
 } from "./browser-semantic-evidence-test-helpers";
 
+const orientationBaseline: ToolcraftOrientationBrowserObservation = {
+  outputSignature: "model-front",
+  pixelSignature: "pixels-front",
+  pose: { position: [0, 0, 5], up: [0, 1, 0] },
+  poseTarget: "view.orbit",
+  presentationCacheKey: "appearance:document-model:v2",
+  presentationDocumentId: "document-model",
+  viewportOffsetX: 0,
+  viewportOffsetY: 0,
+};
+
+const orientationDragged: ToolcraftOrientationBrowserObservation = {
+  ...orientationBaseline,
+  outputSignature: "model-dragged",
+  pixelSignature: "pixels-dragged",
+  pose: { position: [1, 1, 4.8], up: [0, 1, 0] },
+};
+
+const orientationOptions = {
+  requirementId: "model.orientation",
+  stabilityIntervalMs: 0,
+  target: "view.orbit",
+} as const;
+
+type OrientationProofUiState = Readonly<{
+  playbackActions?: readonly ("pause" | "play")[];
+  renderScales?: readonly Readonly<{
+    maximum: string;
+    value: string;
+  }>[];
+}>;
+
+async function installOrientationProofUiState(
+  page: Page,
+  state: OrientationProofUiState,
+): Promise<void> {
+  await page.locator('[data-slot="toolcraft-runtime-app"]').evaluate(
+    (root, proofState) => {
+      root.querySelector('[data-orientation-proof-state]')?.remove();
+      const fixture = document.createElement("div");
+      fixture.dataset.orientationProofState = "";
+
+      for (const action of proofState.playbackActions ?? []) {
+        const button = document.createElement("button");
+        const label = action === "play" ? "Play playback" : "Pause playback";
+        button.type = "button";
+        button.textContent = label;
+        button.setAttribute("aria-label", label);
+        fixture.append(button);
+      }
+
+      for (const [index, renderScale] of (
+        proofState.renderScales ?? []
+      ).entries()) {
+        const field = document.createElement("div");
+        field.dataset.toolcraftControlTarget = "canvas.renderScale";
+        field.dataset.orientationProofRenderScale = String(index);
+        const slider = document.createElement("div");
+        slider.dataset.slot = "slider";
+        slider.setAttribute("aria-valuemax", renderScale.maximum);
+        slider.setAttribute("aria-valuemin", "1");
+        slider.setAttribute("aria-valuenow", renderScale.value);
+        slider.setAttribute("role", "slider");
+        Object.assign(slider.style, { height: "20px", width: "120px" });
+        slider.textContent = "Render scale";
+        field.append(slider);
+        fixture.append(field);
+      }
+
+      root.append(fixture);
+    },
+    state,
+  );
+}
+
 async function installOrientationGizmoPointerProbe(
   page: Page,
   initial: ToolcraftOrientationBrowserObservation,
@@ -123,33 +198,107 @@ async function installModelOrbitPointerProbe(
   );
 }
 
+test("orientation axis drag validates paused maximum-quality proof state", async ({
+  page,
+}, testInfo) => {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  const attachmentCount = testInfo.attachments.length;
+  const observation = session.observe((root) =>
+    JSON.parse(root.getAttribute("data-proof-orientation") ?? "null"),
+  );
+  const invalidStateCases: readonly Readonly<{
+    expectedError: RegExp;
+    state: OrientationProofUiState;
+  }>[] = [
+    {
+      expectedError: /must be paused.*Play playback/iu,
+      state: {
+        playbackActions: ["pause"],
+        renderScales: [{ maximum: "2", value: "2" }],
+      },
+    },
+    {
+      expectedError: /exactly one standard playback action/iu,
+      state: { playbackActions: ["play", "pause"] },
+    },
+    {
+      expectedError: /canvas\.renderScale.*maximum/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "2", value: "1" }],
+      },
+    },
+    {
+      expectedError: /exactly one canvas\.renderScale owner/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [
+          { maximum: "2", value: "2" },
+          { maximum: "2", value: "2" },
+        ],
+      },
+    },
+    {
+      expectedError: /finite aria-valuenow/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "2", value: "" }],
+      },
+    },
+    {
+      expectedError: /finite aria-valuemax/iu,
+      state: {
+        playbackActions: ["play"],
+        renderScales: [{ maximum: "invalid", value: "2" }],
+      },
+    },
+  ];
+
+  for (const { expectedError, state } of invalidStateCases) {
+    await setProofState(page, "orientation", orientationBaseline);
+    await installOrientationGizmoPointerProbe(page, orientationBaseline, {
+      outcomes: { drag: orientationDragged },
+    });
+    await installOrientationProofUiState(page, state);
+    await expect(
+      expectToolcraftOrientationAxisDrag(observation, session, {
+        ...orientationOptions,
+        dragDelta: { x: 18, y: 12 },
+      }),
+    ).rejects.toThrow(expectedError);
+    expect(testInfo.attachments).toHaveLength(attachmentCount);
+  }
+});
+
+test("orientation axis drag retains proof for products without optional playback or render scale", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  await setProofState(page, "orientation", orientationBaseline);
+  const observation = session.observe((root) =>
+    JSON.parse(root.getAttribute("data-proof-orientation") ?? "null"),
+  );
+  await installOrientationGizmoPointerProbe(page, orientationBaseline, {
+    outcomes: { drag: orientationDragged },
+  });
+
+  await expectToolcraftOrientationAxisDrag(observation, session, {
+    ...orientationOptions,
+    dragDelta: { x: 18, y: 12 },
+  });
+});
+
 test("orientation recipes require shared pose/output changes and correct canvas ownership", async ({
   page,
 }, testInfo) => {
   await page.goto("/");
   const session = await createToolcraftBrowserProofSession(page);
   const attachmentCount = testInfo.attachments.length;
-  const baseline: ToolcraftOrientationBrowserObservation = {
-    outputSignature: "model-front",
-    pixelSignature: "pixels-front",
-    pose: { position: [0, 0, 5], up: [0, 1, 0] },
-    poseTarget: "view.orbit",
-    presentationCacheKey: "appearance:document-model:v2",
-    presentationDocumentId: "document-model",
-    viewportOffsetX: 0,
-    viewportOffsetY: 0,
-  };
-  const dragged: ToolcraftOrientationBrowserObservation = {
-    ...baseline,
-    outputSignature: "model-dragged",
-    pixelSignature: "pixels-dragged",
-    pose: { position: [1, 1, 4.8], up: [0, 1, 0] },
-  };
-  const options = {
-    requirementId: "model.orientation",
-    stabilityIntervalMs: 0,
-    target: "view.orbit",
-  } as const;
+  const baseline = orientationBaseline;
+  const dragged = orientationDragged;
+  const options = orientationOptions;
 
   await setProofState(page, "orientation", baseline);
   const observation = session.observe((root) =>
@@ -175,6 +324,10 @@ test("orientation recipes require shared pose/output changes and correct canvas
   expect(testInfo.attachments).toHaveLength(attachmentCount);
 
   await setProofState(page, "orientation", baseline);
+  await installOrientationProofUiState(page, {
+    playbackActions: ["play"],
+    renderScales: [{ maximum: "2", value: "2" }],
+  });
   await installOrientationGizmoPointerProbe(page, baseline, {
     dragCommit: "pointerup",
     outcomes: { drag: dragged },

package/templates/starter/e2e/app-browser-render-scale-evidence.spec.ts

@@ -1,5 +1,8 @@
 import { expect, test, type Page, type TestInfo } from "@playwright/test";
 
+import {
+  parseToolcraftBrowserRuntimeEvidence,
+} from "../src/app/test-evidence/browser-runtime-contract";
 import { attachedEvidenceTypes } from "./browser-semantic-evidence-test-helpers";
 import {
   expectToolcraftCanvasRenderScaleEvidence,
@@ -89,6 +92,24 @@ test("selected 2x rejects a 1x backing store and attaches no evidence", async ({
   expect(testInfo.attachments).toHaveLength(attachmentCount);
 });
 
+test("selected 2x rejects a 3x backing store and attaches no evidence", async ({
+  page,
+}, testInfo: TestInfo) => {
+  await installCanvas(page, 3);
+  const attachmentCount = testInfo.attachments.length;
+
+  await expect(
+    expectToolcraftCanvasRenderScaleEvidence(page, {
+      canvasSelector,
+      requirementId: "canvas.render-scale",
+      selectedScale: 2,
+      stateTransitions: [transition("steady", () => setBackingScale(page, 3))],
+      target: "canvas.renderScale",
+    }),
+  ).rejects.toThrow(/backing width.*one physical pixel/iu);
+  expect(testInfo.attachments).toHaveLength(attachmentCount);
+});
+
 test("a backing clamp introduced by a state transition fails the whole recipe", async ({
   page,
 }, testInfo: TestInfo) => {
@@ -164,15 +185,23 @@ test("performance render-scale evidence attaches only after real backing proof",
   const attachmentCount = testInfo.attachments.length;
 
   await expectToolcraftPerformanceRenderScaleBackingEvidence(page, {
+    baselineCssSize: { height: 80, width: 120 },
     canvasSelector,
+    cssSizePolicy: "fixed",
     pathId: "performance-path:render-scale",
-    selectedScale: 2,
+    phase: "cold",
     target: "canvas.renderScale",
   });
 
-  expect(attachedEvidenceTypes(testInfo, attachmentCount)).toEqual([
-    "performance-render-scale",
-  ]);
+  const [qualityEvidence] = testInfo.attachments
+    .slice(attachmentCount)
+    .map(parseToolcraftBrowserRuntimeEvidence)
+    .filter(
+      (evidence) => evidence?.evidenceType === "performance-render-scale",
+    );
+  expect(qualityEvidence?.requirementId).toBe(
+    "performance-path:render-scale#cold",
+  );
 });
 
 test("performance render-scale evidence rejects a quality clamp without attaching", async ({
@@ -183,11 +212,36 @@ test("performance render-scale evidence rejects a quality clamp without attachin
 
   await expect(
     expectToolcraftPerformanceRenderScaleBackingEvidence(page, {
+      baselineCssSize: { height: 80, width: 120 },
       canvasSelector,
+      cssSizePolicy: "fixed",
       pathId: "performance-path:render-scale",
-      selectedScale: 2,
+      phase: "warm",
       target: "canvas.renderScale",
     }),
-  ).rejects.toThrow(/backing width.*Resolution scale 2/iu);
+  ).rejects.toThrow(/warm.*backing width/iu);
+  expect(testInfo.attachments).toHaveLength(attachmentCount);
+});
+
+test("performance render-scale evidence rejects a changed CSS baseline", async ({
+  page,
+}, testInfo: TestInfo) => {
+  await installCanvas(page, 2);
+  const attachmentCount = testInfo.attachments.length;
+  await page.locator(canvasSelector).evaluate((canvas) => {
+    canvas.setAttribute("style", "display:block;width:60px;height:40px");
+  });
+  await setBackingScale(page, 2);
+
+  await expect(
+    expectToolcraftPerformanceRenderScaleBackingEvidence(page, {
+      baselineCssSize: { height: 80, width: 120 },
+      canvasSelector,
+      cssSizePolicy: "fixed",
+      pathId: "performance-path:render-scale",
+      phase: "sustained",
+      target: "canvas.renderScale",
+    }),
+  ).rejects.toThrow(/sustained.*preserve.*CSS width/iu);
   expect(testInfo.attachments).toHaveLength(attachmentCount);
 });

package/templates/starter/e2e/app-browser-render-scale-requirements.spec.ts

@@ -1,7 +1,14 @@
 import { expect, test } from "@playwright/test";
+import {
+  defineToolcraft,
+  type ToolcraftPerformancePath,
+} from "@repo/toolcraft-runtime";
 
 import type { ToolcraftComponentAcceptance } from "../src/app/starter-acceptance";
-import { deriveToolcraftBrowserRuntimeRequirements } from "./browser-runtime-evidence-requirements";
+import {
+  deriveToolcraftBrowserRuntimeRequirements,
+  deriveToolcraftPerformancePathRuntimeRequirements,
+} from "./browser-runtime-evidence-requirements";
 
 function renderScaleAcceptance(
   states: readonly ("interaction" | "playback" | "steady")[],
@@ -57,6 +64,20 @@ test("render-scale coverage derives one exact functional requirement per state",
   ]);
 });
 
+test("render-scale backing replaces generic visual-change evidence", () => {
+  const requirements = deriveToolcraftBrowserRuntimeRequirements([
+    renderScaleAcceptance(["interaction", "steady"]),
+  ]);
+
+  expect(requirements.map(({ evidenceType }) => evidenceType)).not.toContain(
+    "product-observable-change",
+  );
+  expect(requirements.map(({ evidenceType }) => evidenceType)).toEqual([
+    "canvas-render-scale-backing",
+    "canvas-render-scale-backing",
+  ]);
+});
+
 test("render-scale functional requirements remain separate from performance evidence", () => {
   const requirements = deriveToolcraftBrowserRuntimeRequirements([
     renderScaleAcceptance(["interaction", "steady"]),
@@ -69,3 +90,58 @@ test("render-scale functional requirements remain separate from performance evid
     "performance-render-scale",
   );
 });
+
+const unrelatedPerformancePaths = [
+  {
+    id: "performance-path:color",
+    interaction: "control-drag",
+    invalidates: ["composite"],
+    profile: "live-interaction",
+    runsOn: ["main"],
+    targets: ["appearance.color"],
+    workloadDimensions: [],
+  },
+  {
+    id: "performance-path:viewport",
+    interaction: "viewport-drag",
+    invalidates: ["composite"],
+    profile: "frame-budget",
+    runsOn: ["main"],
+    targets: [],
+    workloadDimensions: [],
+  },
+] as const satisfies readonly ToolcraftPerformancePath[];
+
+test("every raster performance path derives cold, warm, and sustained 2x requirements", () => {
+  const requirements = deriveToolcraftPerformancePathRuntimeRequirements(
+    unrelatedPerformancePaths,
+    defineToolcraft({
+      canvas: { enabled: true, renderScale: true },
+      panels: {},
+    }),
+  ).filter(({ evidenceType }) => evidenceType === "performance-render-scale");
+
+  expect(requirements).toEqual([
+    expect.objectContaining({ requirementId: "performance-path:color#cold" }),
+    expect.objectContaining({ requirementId: "performance-path:color#warm" }),
+    expect.objectContaining({
+      requirementId: "performance-path:color#sustained",
+    }),
+    expect.objectContaining({ requirementId: "performance-path:viewport#cold" }),
+    expect.objectContaining({ requirementId: "performance-path:viewport#warm" }),
+    expect.objectContaining({
+      requirementId: "performance-path:viewport#sustained",
+    }),
+  ]);
+});
+
+test("vector performance paths derive no raster quality requirements", () => {
+  const requirements = deriveToolcraftPerformancePathRuntimeRequirements(
+    unrelatedPerformancePaths,
+    defineToolcraft({ canvas: { enabled: true }, panels: {} }),
+  );
+
+  expect(requirements.map(({ evidenceType }) => evidenceType)).not.toContain(
+    "performance-render-scale",
+  );
+});

package/templates/starter/e2e/app-browser-runtime-provenance.spec.ts

@@ -23,6 +23,13 @@ test("protected observable evidence is attached only after its assertion succeed
     const output = document.createElement("div");
     output.dataset.toolcraftProductOutput = "";
     output.dataset.toolcraftProofProductOutput = "";
+    output.style.backgroundColor = "#000000";
+    output.style.height = "24px";
+    output.style.left = "0";
+    output.style.position = "fixed";
+    output.style.top = "0";
+    output.style.width = "24px";
+    output.style.zIndex = "100";
     output.textContent = "Before";
     const button = document.createElement("button");
     button.id = "change-output";
@@ -46,6 +53,7 @@ test("protected observable evidence is attached only after its assertion succeed
         button.dataset.activated = "true";
       });
       await currentPage.locator('[data-toolcraft-proof-product-output]').evaluate((output) => {
+        (output as HTMLElement).style.backgroundColor = "#FFFFFF";
         output.textContent = "After";
       });
     }),

package/templates/starter/e2e/app-browser-runtime-reporter.spec.ts

@@ -135,6 +135,41 @@ test("performance marker requires every derived scenario evidence type", () => {
   expect(errors).toContainEqual(expect.stringContaining("performance-budget"));
 });
 
+test("performance reporter rejects missing warm and sustained raster quality evidence", () => {
+  const testName = "browser perf: toolcraft path performance-path:color";
+  const requirements: ToolcraftBrowserRuntimeRequirement[] = [
+    "cold",
+    "warm",
+    "sustained",
+  ].map((phase) => ({
+    evidenceType: "performance-render-scale",
+    requirementId: `performance-path:color#${phase}`,
+    target: "appearance.color",
+    testName,
+  }));
+  const marker = fakeTestCase({
+    file: "/product/e2e/app-browser-runtime-evidence.spec.ts",
+    title: TOOLCRAFT_BROWSER_PERFORMANCE_MARKER_TEST_NAME,
+  });
+  const scenarioTest = fakeTestCase({
+    results: [passedResultWithEvidence(requirements[0]!)],
+    title: testName,
+  });
+  const errors: string[] = [];
+  const reporter = new ToolcraftBrowserRuntimeEvidenceReporter({
+    acceptanceRequirements: [],
+    performanceRequirements: requirements,
+    reportError: (error) => errors.push(error),
+  });
+
+  reporter.onBegin?.({} as never, fakeSuite([marker, scenarioTest]));
+  expect(reporter.onEnd?.({ status: "passed" } as never)).toEqual({
+    status: "failed",
+  });
+  expect(errors).toContainEqual(expect.stringContaining("#warm"));
+  expect(errors).toContainEqual(expect.stringContaining("#sustained"));
+});
+
 test("runtime evidence reporter requires render-scale proof for every covered state", () => {
   const testName = "browser: canvas render scale backing pixels";
   const requirements: ToolcraftBrowserRuntimeRequirement[] = [

package/templates/starter/e2e/app-browser-runtime-requirements.spec.ts

@@ -35,7 +35,10 @@ test("derived paths own one canonical browser evidence requirement set", () => {
     },
   ] as const;
 
-  const requirements = deriveToolcraftPerformancePathRuntimeRequirements([path]);
+  const requirements = deriveToolcraftPerformancePathRuntimeRequirements(
+    [path],
+    defineToolcraft({ canvas: { enabled: true }, panels: {} }),
+  );
 
   expect(requirements.map(({ evidenceType }) => evidenceType)).toEqual([
     "performance-measurement",
@@ -130,7 +133,7 @@ test("control schema derives segmented and discrete runtime evidence", () => {
   );
 });
 
-test("typed visibility and background coverage derive dedicated semantic evidence", () => {
+test("typed background coverage derives dedicated semantic evidence", () => {
   const schema = defineToolcraft({
     canvas: { enabled: true },
     panels: {
@@ -138,19 +141,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
         sections: [
           {
             controls: {
-              conditional: {
-                defaultValue: 1,
-                label: "Conditional",
-                target: "feature.conditional",
-                type: "slider",
-                visibleWhen: { equals: true, target: "feature.enabled" },
-              },
-              enabled: {
-                defaultValue: false,
-                label: "Enabled",
-                target: "feature.enabled",
-                type: "switch",
-              },
               includeBackground: {
                 defaultValue: true,
                 label: "Include",
@@ -178,14 +168,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
   });
   const requirements = deriveToolcraftBrowserRuntimeRequirements(
     [
-      {
-        browser: true,
-        browserTestName: "browser: conditional visibility",
-        evidence: "product-output",
-        id: "feature.conditional",
-        target: "feature.conditional",
-        visibilityCoverage: ["hidden", "visible"],
-      },
       {
         backgroundOutputCoverage: [
           "preview-hidden-when-excluded",
@@ -202,17 +184,6 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
     ],
     schema,
   );
-
-  expect(
-    requirements
-      .filter((requirement) => requirement.requirementId === "feature.conditional")
-      .map((requirement) => requirement.evidenceType),
-  ).toEqual(
-    expect.arrayContaining([
-      "conditional-control-hidden",
-      "conditional-control-visible",
-    ]),
-  );
   expect(
     requirements
       .filter((requirement) => requirement.requirementId === "export.includeBackground")

package/templates/starter/e2e/app-browser-semantic-evidence.spec.ts

@@ -1,8 +1,6 @@
 import { expect, test } from "@playwright/test";
-import {
-  expectToolcraftBackgroundOutputSemantics,
-  expectToolcraftConditionalControlVisibility,
-} from "./browser-conditional-output-evidence-helpers";
+import { expectToolcraftBackgroundOutputSemantics } from "./browser-background-output-evidence";
+import { expectToolcraftControlApplicabilityState } from "./browser-control-applicability-evidence";
 import {
   expectToolcraftLayerReorder,
   expectToolcraftLayerSelection,
@@ -12,6 +10,7 @@ import {
   attachedEvidenceTypes,
   setProofState,
   setSyntheticControlOwner,
+  setSyntheticSwitchControlOwner,
 } from "./browser-semantic-evidence-test-helpers";
 import {
   expectToolcraftMediaLifecycle,
@@ -169,7 +168,6 @@ test("layer recipes reject collection substitution and prove exact reorder", asy
   expect(attachedEvidenceTypes(testInfo, attachmentCount)).toEqual([
     "product-observable-change",
     "layer-reorder",
-    "product-observable-change",
     "layer-selection",
   ]);
 });
@@ -316,34 +314,81 @@ test("timeline recipes bind duration to renderer, keyframes to output, and loops
   ]);
 });
 
-test("conditional visibility recipe proves target absence and restoration through the gating control", async ({
+test("control applicability recipe proves exact target absence and presence", async ({
   page,
 }, testInfo) => {
   await page.goto("/");
   const session = await createToolcraftBrowserProofSession(page);
   const attachmentCount = testInfo.attachments.length;
-  await setSyntheticControlOwner(page, "feature.enabled", true);
+  await setSyntheticSwitchControlOwner(page, "feature.enabled", false);
   await setSyntheticControlOwner(page, "feature.conditional", true);
 
-  await expectToolcraftConditionalControlVisibility(
+  const hiddenCase = {
+    expectation: "hidden" as const,
+    selectorControlType: "switch" as const,
+    selectorLabel: "feature.enabled",
+    selectorTarget: "feature.enabled",
+    selectorValue: false,
+    target: "feature.conditional",
+  };
+  const visibleCase = {
+    ...hiddenCase,
+    expectation: "visible" as const,
+    selectorValue: true,
+  };
+  const mismatchedAction = session.controlAction(
+    "feature.other",
+    () => undefined,
+  );
+
+  await expect(
+    expectToolcraftControlApplicabilityState(
+      session,
+      mismatchedAction,
+      hiddenCase,
+      { baseRequirementId: "feature.conditional", timeoutMs: 50 },
+    ),
+  ).rejects.toThrow(/target-scoped selector action/);
+  expect(testInfo.attachments).toHaveLength(attachmentCount);
+
+  await expect(
+    expectToolcraftControlApplicabilityState(
+      session,
+      session.controlAction("feature.enabled", () => undefined),
+      hiddenCase,
+      { baseRequirementId: "feature.conditional", timeoutMs: 50 },
+    ),
+  ).rejects.toThrow(/should be hidden/);
+  expect(testInfo.attachments).toHaveLength(attachmentCount);
+
+  await expectToolcraftControlApplicabilityState(
     session,
     session.controlAction("feature.enabled", (control, currentPage) => {
       expect(control).toBeTruthy();
-      return setSyntheticControlOwner(currentPage, "feature.conditional", false);
+      return Promise.all([
+        setSyntheticSwitchControlOwner(currentPage, "feature.enabled", false),
+        setSyntheticControlOwner(currentPage, "feature.conditional", false),
+      ]).then(() => undefined);
     }),
+    hiddenCase,
+    { baseRequirementId: "feature.conditional" },
+  );
+  await expectToolcraftControlApplicabilityState(
+    session,
     session.controlAction("feature.enabled", (control, currentPage) => {
       expect(control).toBeTruthy();
-      return setSyntheticControlOwner(currentPage, "feature.conditional", true);
+      return Promise.all([
+        setSyntheticSwitchControlOwner(currentPage, "feature.enabled", true),
+        setSyntheticControlOwner(currentPage, "feature.conditional", true),
+      ]).then(() => undefined);
     }),
-    {
-      requirementId: "feature.conditional",
-      target: "feature.conditional",
-    },
+    visibleCase,
+    { baseRequirementId: "feature.conditional" },
   );
 
   expect(attachedEvidenceTypes(testInfo, attachmentCount)).toEqual([
-    "conditional-control-hidden",
-    "conditional-control-visible",
+    "control-applicability-hidden",
+    "control-applicability-visible",
   ]);
 });