@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/e2e/app-browser-proof-session.spec.ts

@@ -2,6 +2,7 @@ import { expect, test } from "@playwright/test";
 
 import {
   createToolcraftBrowserProofSession,
+  getToolcraftBrowserActionSurface,
   getToolcraftBrowserActionTarget,
   runToolcraftBrowserAction,
   runToolcraftBrowserValueAction,
@@ -133,6 +134,7 @@ test("target-scoped actions resolve the exact field inside a grouped control", a
   });
 
   expect(getToolcraftBrowserActionTarget(action)).toBe("appearance.stroke");
+  expect(getToolcraftBrowserActionSurface(action)).toBe("panel");
   await runToolcraftBrowserAction(action);
   await expect(
     page.locator('button[data-target="appearance.stroke"]'),
@@ -170,6 +172,89 @@ test("target-scoped actions resolve the exact field inside a grouped control", a
   );
 });
 
+test("surface actions verify Canvas and Panel locator provenance", async ({
+  page,
+}) => {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  await page.locator(TOOLCRAFT_APP_ROOT_SELECTOR).evaluate((root) => {
+    const canvas = root.querySelector('[data-slot="toolcraft-runtime-canvas"]');
+    const panel = root.querySelector("[data-toolcraft-controls-panel-shell]");
+    if (!canvas || !panel) {
+      throw new Error("Missing runtime surfaces for proof-session fixture.");
+    }
+    for (const [owner, id] of [
+      [canvas, "surface-canvas"],
+      [panel, "surface-panel"],
+    ] as const) {
+      const button = document.createElement("button");
+      button.id = id;
+      button.type = "button";
+      button.textContent = id;
+      if (id === "surface-canvas") {
+        Object.assign(button.style, {
+          left: "16px",
+          position: "absolute",
+          top: "16px",
+          zIndex: "50",
+        });
+      }
+      button.addEventListener("click", () => {
+        button.dataset.clicked = "true";
+      });
+      button.addEventListener("pointerdown", (event) => {
+        event.stopPropagation();
+      });
+      owner.append(button);
+    }
+  });
+
+  const canvasAction = session.surfaceAction("selection.active", {
+    selector: "#surface-canvas",
+    surface: "canvas",
+  });
+  const panelAction = session.surfaceAction("selection.active", {
+    selector: "#surface-panel",
+    surface: "panel",
+  });
+  expect(getToolcraftBrowserActionSurface(canvasAction)).toBe("canvas");
+  expect(getToolcraftBrowserActionSurface(panelAction)).toBe("panel");
+  await runToolcraftBrowserAction(canvasAction);
+  await runToolcraftBrowserAction(panelAction);
+  await expect(page.locator("#surface-canvas")).toHaveAttribute(
+    "data-clicked",
+    "true",
+  );
+  await expect(page.locator("#surface-panel")).toHaveAttribute(
+    "data-clicked",
+    "true",
+  );
+
+  await expect(
+    runToolcraftBrowserAction(
+      session.surfaceAction("selection.active", {
+        selector: "#surface-panel",
+        surface: "canvas",
+      }),
+    ),
+  ).rejects.toThrow(/declared canvas runtime surface/u);
+  await expect(
+    runToolcraftBrowserAction(
+      session.surfaceAction("selection.active", {
+        selector: "#missing-surface",
+        surface: "canvas",
+      }),
+    ),
+  ).rejects.toThrow(/resolve exactly once/u);
+  expect(() =>
+    session.surfaceAction("selection.active", {
+      position: { x: -1, y: 0 },
+      selector: "#surface-canvas",
+      surface: "canvas",
+    }),
+  ).toThrow(/finite nonnegative coordinates/u);
+});
+
 test("proof sessions reject pages without the Toolcraft app identity", async ({ page }) => {
   await page.setContent('<main data-slot="toolcraft-runtime-app"></main>');
 

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

@@ -133,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: {
@@ -141,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",
@@ -181,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",
@@ -205,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")
@@ -230,6 +198,56 @@ test("typed visibility and background coverage derive dedicated semantic evidenc
   );
 });
 
+test("typed SVG coverage derives only protected SVG artifact evidence", () => {
+  const requirements = deriveToolcraftBrowserRuntimeRequirements([
+    {
+      browser: true,
+      browserTestName: "browser: SVG export",
+      evidence: "exported-bytes",
+      exportArtifactCoverage: "all-required-svg-export-behavior",
+      id: "actions.svg",
+      target: "actions.output",
+    },
+  ]);
+
+  expect(requirements).toEqual([
+    {
+      evidenceType: "svg-export-artifact",
+      requirementId: "actions.svg",
+      target: "actions.output",
+      testName: "browser: SVG export",
+    },
+  ]);
+});
+
+test("selected-entity coverage adds protected selection isolation evidence", () => {
+  const requirements = deriveToolcraftBrowserRuntimeRequirements([
+    {
+      browser: true,
+      browserTestName: "browser: selected shape fill",
+      evidence: "product-output",
+      id: "shape.selected-fill",
+      selectionScopeCoverage: "two-entity-isolation",
+      target: "selectedShape.fill",
+    },
+  ]);
+
+  expect(requirements).toEqual([
+    {
+      evidenceType: "product-observable-change",
+      requirementId: "shape.selected-fill",
+      target: "selectedShape.fill",
+      testName: "browser: selected shape fill",
+    },
+    {
+      evidenceType: "selection-scoped-control",
+      requirementId: "shape.selected-fill",
+      target: "selectedShape.fill",
+      testName: "browser: selected shape fill",
+    },
+  ]);
+});
+
 test("typed Infinity canvas coverage derives dedicated semantic evidence", () => {
   const requirements = deriveToolcraftBrowserRuntimeRequirements([
     {
@@ -248,6 +266,14 @@ test("typed Infinity canvas coverage derives dedicated semantic evidence", () =>
       infinityCanvasCoverage: "scene-bounds-image-export",
       target: "actions.output",
     },
+    {
+      browser: true,
+      browserTestName: "browser: Infinity canvas SVG export",
+      evidence: "exported-bytes",
+      id: "canvas.infinity.svgExport",
+      infinityCanvasCoverage: "scene-bounds-svg-export",
+      target: "actions.output",
+    },
   ]);
 
   expect(
@@ -265,6 +291,10 @@ test("typed Infinity canvas coverage derives dedicated semantic evidence", () =>
         evidenceType: "infinity-scene-bounds-image-export",
         requirementId: "canvas.infinity.imageExport",
       },
+      {
+        evidenceType: "infinity-scene-bounds-svg-export",
+        requirementId: "canvas.infinity.svgExport",
+      },
     ]),
   );
 });

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

@@ -0,0 +1,137 @@
+import { expect, test } from "@playwright/test";
+
+import { createToolcraftBrowserProofSession } from "./browser-proof-session";
+import { expectToolcraftSelectionScopedControl } from "./browser-selection-scope-evidence";
+import {
+  attachedEvidenceTypes,
+  editSyntheticSelectedEntity,
+  mountSyntheticSelectionScene,
+} from "./browser-semantic-evidence-test-helpers";
+
+const propertyTarget = "selectedShape.fill";
+const selectionTarget = "selection.activeShape";
+const entityA = {
+  entityId: "shape-a",
+  selector: '[data-proof-entity="shape-a"]',
+} as const;
+const entityB = {
+  entityId: "shape-b",
+  selector: '[data-proof-entity="shape-b"]',
+} as const;
+
+async function createSelectionProofFixture(
+  page: Parameters<typeof createToolcraftBrowserProofSession>[0],
+) {
+  await page.goto("/");
+  const session = await createToolcraftBrowserProofSession(page);
+  await mountSyntheticSelectionScene(page, {
+    controlValue: "#371C4D",
+    fills: { "shape-a": "#A65F15", "shape-b": "#371C4D" },
+    selectedEntityId: "shape-b",
+  });
+
+  return {
+    observePropertyValue: session.observe((root) =>
+      JSON.parse(root.getAttribute("data-proof-selection-scope") ?? "null")
+        .controlValue,
+    ),
+    observeSelectedEntityId: session.observe((root) =>
+      String(
+        JSON.parse(root.getAttribute("data-proof-selection-scope") ?? "null")
+          .selectedEntityId,
+      ),
+    ),
+    proofSession: session,
+  };
+}
+
+function createSelectionActions(
+  session: Awaited<
+    ReturnType<typeof createSelectionProofFixture>
+  >["proofSession"],
+) {
+  return {
+    selectEntityA: session.surfaceAction(selectionTarget, {
+      selector: entityA.selector,
+      surface: "canvas",
+    }),
+    selectEntityB: session.surfaceAction(selectionTarget, {
+      selector: entityB.selector,
+      surface: "canvas",
+    }),
+  };
+}
+
+test("selection-scoped control proves two-direction entity isolation", async ({
+  page,
+}, testInfo) => {
+  const fixture = await createSelectionProofFixture(page);
+  const attachmentCount = testInfo.attachments.length;
+
+  await expectToolcraftSelectionScopedControl({
+    ...fixture,
+    ...createSelectionActions(fixture.proofSession),
+    editEntityA: fixture.proofSession.controlAction(
+      propertyTarget,
+      (_control, currentPage) =>
+        editSyntheticSelectedEntity(currentPage, "#00AAFF"),
+    ),
+    editEntityB: fixture.proofSession.controlAction(
+      propertyTarget,
+      (_control, currentPage) =>
+        editSyntheticSelectedEntity(currentPage, "#FF44AA"),
+    ),
+    entityA,
+    entityB,
+    propertySurface: "panel",
+    propertyTarget,
+    requirementId: "shape.selected-fill",
+    selectionSurface: "canvas",
+    selectionTarget,
+    stabilityIntervalMs: 0,
+  });
+
+  expect(attachedEvidenceTypes(testInfo, attachmentCount)).toEqual([
+    "product-observable-change",
+    "selection-scoped-control",
+  ]);
+});
+
+test("selection-scoped control rejects cross-entity mutation without evidence", async ({
+  page,
+}, testInfo) => {
+  const fixture = await createSelectionProofFixture(page);
+  const attachmentCount = testInfo.attachments.length;
+
+  await expect(
+    expectToolcraftSelectionScopedControl({
+      ...fixture,
+      ...createSelectionActions(fixture.proofSession),
+      editEntityA: fixture.proofSession.controlAction(
+        propertyTarget,
+        async (_control, currentPage) => {
+          await editSyntheticSelectedEntity(currentPage, "#00AAFF");
+          await currentPage
+            .locator(entityB.selector)
+            .evaluate((entity) => {
+              (entity as HTMLElement).style.background = "#FFFFFF";
+            });
+        },
+      ),
+      editEntityB: fixture.proofSession.controlAction(
+        propertyTarget,
+        (_control, currentPage) =>
+          editSyntheticSelectedEntity(currentPage, "#FF44AA"),
+      ),
+      entityA,
+      entityB,
+      propertySurface: "panel",
+      propertyTarget,
+      requirementId: "shape.cross-entity-fill",
+      selectionSurface: "canvas",
+      selectionTarget,
+      stabilityIntervalMs: 0,
+    }),
+  ).rejects.toThrow();
+  expect(testInfo.attachments).toHaveLength(attachmentCount);
+});

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,
@@ -315,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",
   ]);
 });
 

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,
+  });
+}