@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-source-inventory.d.mts

@@ -32,6 +32,11 @@ export type ToolcraftSourceInventoryOptions = {
 
 export const toolcraftSourceExtensions: ReadonlySet<string>;
 
+export function resolveToolcraftRootResourcePath(
+  resourcePath: string,
+  rootDir: string,
+): string;
+
 export function classifyToolcraftSourcePath(
   repoPath: string,
   options?: Omit<ToolcraftSourceInventoryOptions, "rootDir" | "sourceRoots">,

package/templates/starter/scripts/toolcraft-source-inventory.mjs

@@ -208,7 +208,21 @@ function pathEscapesRoot(rootPath, targetPath) {
   );
 }
 
-function resolveExplicitResourcePath(resourcePath, rootDir) {
+function resolveExistingResourceAncestor(targetPath) {
+  let candidatePath = targetPath;
+  for (;;) {
+    try {
+      return fs.realpathSync(candidatePath);
+    } catch (error) {
+      if (error?.code !== "ENOENT") throw error;
+      const parentPath = path.dirname(candidatePath);
+      if (parentPath === candidatePath) throw error;
+      candidatePath = parentPath;
+    }
+  }
+}
+
+export function resolveToolcraftRootResourcePath(resourcePath, rootDir) {
   if (
     typeof resourcePath !== "string" ||
     path.isAbsolute(resourcePath) ||
@@ -234,6 +248,15 @@ function resolveExplicitResourcePath(resourcePath, rootDir) {
       "is outside the configured root boundary",
     );
   }
+  const rootRealPath = fs.realpathSync(rootDir);
+  const resourceBoundaryPath = resolveExistingResourceAncestor(absolutePath);
+  if (pathEscapesRoot(rootRealPath, resourceBoundaryPath)) {
+    throw createResourceRootEscapeError(
+      resourcePath,
+      rootDir,
+      "resolves outside the root boundary for configured root",
+    );
+  }
   return absolutePath;
 }
 
@@ -248,11 +271,8 @@ export function createCanonicalGraphEntries({
       entry,
     ]),
   );
-  const rootRealPath =
-    explicitResourcePaths.length > 0 ? fs.realpathSync(rootDir) : undefined;
-
   for (const resourcePath of explicitResourcePaths) {
-    const absolutePath = resolveExplicitResourcePath(resourcePath, rootDir);
+    const absolutePath = resolveToolcraftRootResourcePath(resourcePath, rootDir);
     const repoPath = toPosixPath(path.relative(rootDir, absolutePath));
     if (entriesByRepoPath.has(repoPath)) continue;
 
@@ -264,15 +284,6 @@ export function createCanonicalGraphEntries({
       throw error;
     }
     if (!resourceStat.isFile() || resourceStat.isSymbolicLink()) continue;
-    const resourceRealPath = fs.realpathSync(absolutePath);
-    if (pathEscapesRoot(rootRealPath, resourceRealPath)) {
-      throw createResourceRootEscapeError(
-        resourcePath,
-        rootDir,
-        "resolves outside the root boundary for configured root",
-      );
-    }
-
     entriesByRepoPath.set(repoPath, {
       absolutePath,
       repoPath,

package/templates/starter/scripts/toolcraft-source-inventory.test.mjs

@@ -9,6 +9,7 @@ import {
   collectToolcraftSourceInventory,
   collectToolcraftSourceInventorySync,
   createCanonicalGraphEntries,
+  resolveToolcraftRootResourcePath,
 } from "./toolcraft-source-inventory.mjs";
 
 test("classifies platform, framework, product, test, and generated source", () => {
@@ -236,3 +237,50 @@ test("accepts an in-root explicit public resource", async (context) => {
     ["public/preset.bin"],
   );
 });
+
+test("resolves only root-relative resources whose real path stays in root", async (context) => {
+  const fixtureDir = await fs.mkdtemp(
+    path.join(os.tmpdir(), "toolcraft-root-resource-resolver-"),
+  );
+  context.after(() => fs.rm(fixtureDir, { force: true, recursive: true }));
+  const rootDir = path.join(fixtureDir, "app");
+  const outsideDir = path.join(fixtureDir, "outside");
+  await fs.mkdir(path.join(rootDir, "nested"), { recursive: true });
+  await fs.mkdir(outsideDir);
+  await fs.writeFile(path.join(rootDir, "nested/resource.json"), "{}\n");
+  await fs.writeFile(path.join(outsideDir, "escaped.json"), "{}\n");
+
+  assert.equal(
+    resolveToolcraftRootResourcePath("nested/resource.json", rootDir),
+    path.join(rootDir, "nested/resource.json"),
+  );
+  const missingResourcePath = path.join(rootDir, "missing/deep/resource.json");
+  assert.equal(
+    resolveToolcraftRootResourcePath("missing/deep/resource.json", rootDir),
+    missingResourcePath,
+  );
+  await assert.rejects(() => fs.lstat(missingResourcePath), { code: "ENOENT" });
+  for (const resourcePath of [
+    path.join(outsideDir, "escaped.json"),
+    "../outside/escaped.json",
+  ]) {
+    assert.throws(
+      () => resolveToolcraftRootResourcePath(resourcePath, rootDir),
+      (error) => error.code === "TOOLCRAFT_RESOURCE_ROOT_ESCAPE",
+    );
+  }
+
+  try {
+    await fs.symlink(outsideDir, path.join(rootDir, "linked"));
+  } catch (error) {
+    if (["EACCES", "ENOSYS", "EPERM"].includes(error?.code)) {
+      context.skip(`symbolic links are unavailable: ${error.code}`);
+      return;
+    }
+    throw error;
+  }
+  assert.throws(
+    () => resolveToolcraftRootResourcePath("linked/escaped.json", rootDir),
+    (error) => error.code === "TOOLCRAFT_RESOURCE_ROOT_ESCAPE",
+  );
+});

package/templates/starter/scripts/toolcraft-source-ownership.mjs

@@ -37,7 +37,6 @@ export const toolcraftProductOwnedGeneratedPaths = Object.freeze([
   "src/app/app-acceptance-data.ts",
   "src/app/app-composition.tsx",
   "src/app/app-performance.ts",
-  "src/app/app-verification-impact.json",
   "src/app/app-schema.test.ts",
   "src/app/app-schema.ts",
 ]);

package/templates/starter/scripts/toolcraft-source-ownership.test.mjs

@@ -73,16 +73,12 @@ test("collects the same ownership policy for starter-local and generated paths",
   }
 });
 
-test("keeps the signed-manifest trust root small and inside canonical ownership", async () => {
+test("keeps the signed-manifest trust root unique and inside canonical ownership", async () => {
   const generatedPaths =
     await collectToolcraftFrameworkOwnedGeneratedPaths(starterRoot);
   const generatedPathSet = new Set(generatedPaths);
 
   assert.ok(requiredProtectedTrustRootFilePaths.length > 0);
-  assert.ok(
-    requiredProtectedTrustRootFilePaths.length <= 28,
-    `The trust root must stay small; received ${requiredProtectedTrustRootFilePaths.length} paths.`,
-  );
   assert.equal(
     new Set(requiredProtectedTrustRootFilePaths).size,
     requiredProtectedTrustRootFilePaths.length,
@@ -141,3 +137,32 @@ test("keeps the signed-manifest trust root small and inside canonical ownership"
     );
   }
 });
+
+test("uses public motion-reference sentinels while signing transitive owners through canonical inventory", async () => {
+  const generatedPaths =
+    await collectToolcraftFrameworkOwnedGeneratedPaths(starterRoot);
+  const publicSentinels = [
+    "scripts/create-toolcraft-motion-reference-study.mjs",
+    "src/app/acceptance/motion-reference-evidence.d.mts",
+    "src/app/acceptance/motion-reference-evidence.mjs",
+  ];
+  const representativeTransitiveOwners = [
+    "scripts/toolcraft-motion-reference-group-inventory.mjs",
+    "scripts/toolcraft-motion-reference-publication-journal.mjs",
+  ];
+
+  assert.deepEqual(
+    requiredProtectedTrustRootFilePaths.filter((relativePath) =>
+      relativePath.includes("motion-reference"),
+    ),
+    publicSentinels,
+  );
+  for (const representativeTransitiveOwner of representativeTransitiveOwners) {
+    assert.equal(
+      requiredProtectedTrustRootFilePaths.includes(representativeTransitiveOwner),
+      false,
+      "Transitive implementation modules belong to the complete signed framework inventory, not the public sentinel list.",
+    );
+    assert.ok(generatedPaths.includes(representativeTransitiveOwner));
+  }
+});

package/templates/starter/scripts/toolcraft-verification-receipt-test-helpers.mjs

@@ -85,23 +85,6 @@ export async function createReceiptFixture() {
     path.join(rootDir, "src", "app", "app-schema.ts"),
     'export const schema = { mode: "initial" };\n',
   );
-  await fs.writeFile(
-    path.join(rootDir, "src", "app", "app-verification-impact.json"),
-    `${JSON.stringify(
-      {
-        owners: [
-          {
-            acceptanceIds: ["persistence.reload"],
-            kind: "functional",
-            path: "src/app/app-schema.ts",
-          },
-        ],
-        version: 2,
-      },
-      null,
-      2,
-    )}\n`,
-  );
   await fs.writeFile(
     path.join(rootDir, "e2e", "app-performance.spec.ts"),
     'export const scenario = "heavy";\n',
@@ -190,14 +173,6 @@ export async function writePassedCheckpointFixture(
       performance: [],
       version: 2,
     },
-    inventory: {
-      owners: [{
-        acceptanceIds: ["persistence.reload"],
-        kind: "functional",
-        path: "src/app/app-schema.ts",
-      }],
-      version: 3,
-    },
   });
   const plan = deepFreeze({
     basis: { kind: "initial" },
@@ -210,7 +185,11 @@ export async function writePassedCheckpointFixture(
     steps: [
       { kind: "docs" },
       { kind: "code-health" },
-      { files: ["src/app/app-schema.test.ts"], kind: "product-tests" },
+      {
+        acceptanceIds: null,
+        files: ["src/app/app-schema.test.ts"],
+        kind: "product-tests",
+      },
       { kind: "build" },
       {
         kind: "browser-functional",

package/templates/starter/scripts/toolcraft-verification-receipt.d.mts

@@ -1,5 +1,4 @@
 import type { ToolcraftPerformanceReportEvidence } from "./toolcraft-performance-report.mjs";
-import type { ToolcraftDeliveryCatalog } from "./toolcraft-verification-impact.mjs";
 
 export const TOOLCRAFT_PERFORMANCE_RECEIPT_VERSION: 5;
 
@@ -34,12 +33,6 @@ export function collectToolcraftVerificationInputs(rootDir: string): Promise<{
   sourceHash: string;
 }>;
 
-export function validateToolcraftCurrentPerformanceImpactInventory(options: {
-  catalog?: ToolcraftDeliveryCatalog;
-  knownPassIds?: readonly string[];
-  rootDir: string;
-}): Promise<unknown>;
-
 export function readToolcraftDurablePerformanceBaseline(
   rootDir: string,
 ): Promise<{

package/templates/starter/scripts/toolcraft-verification-receipt.mjs

@@ -18,14 +18,6 @@ import {
 import {
   TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND,
 } from "./toolcraft-performance-authority-policy.mjs";
-import {
-  createToolcraftProductVerificationContext,
-  readToolcraftVerificationImpactInventory,
-} from "./toolcraft-verification-impact.mjs";
-import {
-  collectToolcraftDeliveryCatalog,
-  validateExplicitToolcraftDeliveryCatalog,
-} from "./toolcraft-delivery-catalog-collector.mjs";
 export {
   TOOLCRAFT_PERFORMANCE_RECEIPT_VERSION,
   assertToolcraftVerificationInputsUnchanged,
@@ -57,57 +49,21 @@ export async function readToolcraftDurablePerformanceBaseline(rootDir) {
   return { receipt };
 }
 
-async function getCurrentDeliveryCatalog(rootDir, catalog) {
-  return catalog === undefined
-    ? collectToolcraftDeliveryCatalog(rootDir)
-    : validateExplicitToolcraftDeliveryCatalog(catalog);
-}
-
-export async function validateToolcraftCurrentPerformanceImpactInventory({
-  catalog,
-  knownPassIds = [],
-  rootDir,
-}) {
-  const { inputRoles } =
-    await createToolcraftProductVerificationContext(rootDir);
-  const deliveryCatalog = await getCurrentDeliveryCatalog(rootDir, catalog);
-  const catalogPassIds = new Set(
-    deliveryCatalog.performance.flatMap((row) => row.passIds),
-  );
-  for (const passId of knownPassIds) {
-    if (!catalogPassIds.has(passId)) {
-      throw new Error(
-        `Renderer pass "${passId}" is absent from the independently derived delivery catalog.`,
-      );
-    }
-  }
-  return readToolcraftVerificationImpactInventory(rootDir, {
-    catalog: deliveryCatalog,
-    inputRoles,
-  });
-}
-
 export async function validateToolcraftPerformanceReceipt({ rootDir }) {
   const loaded = await readToolcraftCheckpointBundle(rootDir);
   if (loaded.error) return [loaded.error];
-  if (loaded.missing || loaded.bundle.currentPerformance === null) {
+  if (loaded.missing || loaded.bundle.performanceBaseline === null) {
     return [
-      `Toolcraft performance receipt is missing. An operator must run ${TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND} to create a full checkpoint before targeted iteration evidence can be recorded.`,
+      `Toolcraft performance receipt is missing. An operator must run ${TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND} to create a full checkpoint.`,
     ];
   }
-  const receipt = loaded.bundle.currentPerformance;
+  const receipt = loaded.bundle.performanceBaseline;
   const shapeError = getToolcraftPerformanceReceiptShapeError(receipt);
   if (shapeError) return [shapeError];
 
   const baseline = await readToolcraftDurablePerformanceBaseline(rootDir);
   if (baseline.error) return [baseline.error];
 
-  if (receipt.sourceHash !== baseline.receipt.sourceHash) {
-    return [
-      "Toolcraft current performance checkpoint does not match the durable performance baseline.",
-    ];
-  }
-
   const inventory = await collectToolcraftVerificationInputs(rootDir);
   if (receipt.sourceHash !== inventory.sourceHash) {
     return [

package/templates/starter/scripts/toolcraft-verification-receipt.test.mjs

@@ -22,11 +22,6 @@ import {
 import {
   createToolcraftFunctionalProofModelHash,
 } from "./toolcraft-functional-proof-model.mjs";
-import {
-  createDeliveryFixture,
-  functionalTestName,
-  removeDeliveryFixture,
-} from "./run-delivery-verification-test-helpers.mjs";
 import {
   collectToolcraftVerificationInputs,
 } from "./toolcraft-verification-receipt.mjs";
@@ -87,7 +82,11 @@ function createInitialReceipt(inventory) {
     steps: [
       { kind: "docs" },
       { kind: "code-health" },
-      { files: ["src/app/app-schema.test.ts"], kind: "product-tests" },
+      {
+        acceptanceIds: null,
+        files: ["src/app/app-schema.test.ts"],
+        kind: "product-tests",
+      },
       { kind: "build" },
       {
         kind: "browser-functional",
@@ -299,86 +298,6 @@ test("does not expose a reusable passed-checkpoint writer", () => {
   assert.equal("writeToolcraftPerformanceReceipt" in receiptModule, false);
 });
 
-test("current impact validation requires every runtime module and resource owner", async (t) => {
-  const rootDir = createDeliveryFixture();
-  t.after(() => removeDeliveryFixture(rootDir));
-  const appRoot = path.join(rootDir, "src", "app");
-  await fs.writeFile(
-    path.join(appRoot, "app-composition.tsx"),
-    "import '../app.ts'; import './renderer.ts'; export const composition = true;\n",
-  );
-  await fs.writeFile(
-    path.join(appRoot, "app-schema.ts"),
-    "export { schema } from './schema.ts';\n",
-  );
-  await fs.writeFile(
-    path.join(appRoot, "app-acceptance-data.ts"),
-    "export const acceptance = true;\n",
-  );
-  await fs.writeFile(
-    path.join(appRoot, "app-performance.ts"),
-    "export const performance = true;\n",
-  );
-  await fs.mkdir(path.join(rootDir, "public"), { recursive: true });
-  await fs.writeFile(
-    path.join(rootDir, "public", "product-pulse.svg"),
-    "<svg xmlns=\"http://www.w3.org/2000/svg\"/>\n",
-  );
-  await fs.writeFile(
-    path.join(rootDir, "public", "unowned-texture.svg"),
-    "<svg xmlns=\"http://www.w3.org/2000/svg\"/>\n",
-  );
-  await fs.writeFile(
-    path.join(rootDir, "src", "app", "app-verification-impact.json"),
-    `${JSON.stringify({
-      owners: [
-        "src/app.ts",
-        "src/app/app-composition.tsx",
-        "src/app/app-schema.ts",
-        "src/app/renderer.ts",
-        "src/app/schema.ts",
-        "public/product-pulse.svg",
-        "public/unowned-texture.svg",
-      ].map((ownerPath) => ({
-        acceptanceIds: ["persistence.reload"],
-        kind: ownerPath.startsWith("public/")
-          ? "presentation"
-          : "functional",
-        path: ownerPath,
-      })),
-      version: 3,
-    })}\n`,
-  );
-  const loaded =
-    await receiptModule.validateToolcraftCurrentPerformanceImpactInventory({
-      catalog: {
-        acceptance: [{
-          acceptanceId: "persistence.reload",
-          contractHash: "a".repeat(64),
-          domainId: "persistence",
-          file: "app-controls.spec.ts",
-          testName: functionalTestName,
-        }],
-        performance: [],
-        version: 2,
-      },
-      rootDir,
-    });
-
-  assert.equal(
-    loaded.inventory.owners.some(
-      ({ path: ownerPath }) => ownerPath === "public/product-pulse.svg",
-    ),
-    true,
-  );
-  assert.equal(
-    loaded.inventory.owners.some(
-      ({ path: ownerPath }) => ownerPath === "public/unowned-texture.svg",
-    ),
-    true,
-  );
-});
-
 test("full performance recovery points only to the operator command", async (t) => {
   const rootDir = await createReceiptFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
@@ -388,7 +307,7 @@ test("full performance recovery points only to the operator command", async (t)
     missing: true,
   });
   assert.deepEqual(await receiptModule.validateToolcraftPerformanceReceipt({ rootDir }), [
-    `Toolcraft performance receipt is missing. An operator must run ${TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND} to create a full checkpoint before targeted iteration evidence can be recorded.`,
+    `Toolcraft performance receipt is missing. An operator must run ${TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND} to create a full checkpoint.`,
   ]);
 });
 

package/templates/starter/scripts/toolcraft-vitest-runtime-contract.d.mts

@@ -16,6 +16,25 @@ export const TOOLCRAFT_VITEST_RUNTIME_EVIDENCE_VERSION: 1;
 export const TOOLCRAFT_VITEST_RUNTIME_REQUIREMENTS_ANNOTATION_TYPE: string;
 export const TOOLCRAFT_VITEST_RUNTIME_MARKER_TEST_NAME: string;
 export const TOOLCRAFT_VITEST_RUNTIME_MARKER_FILE_NAMES: readonly string[];
+export const TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_ENV: string;
+
+export function getToolcraftProductTestProcessEnvironment(
+  acceptanceIds: readonly string[] | null,
+  inheritedEnvironment?: NodeJS.ProcessEnv,
+): NodeJS.ProcessEnv;
+
+export function serializeToolcraftVitestRuntimeAcceptanceSelection(
+  acceptanceIds: readonly string[],
+): string;
+
+export function parseToolcraftVitestRuntimeAcceptanceSelection(
+  serialized: string,
+): string[];
+
+export function selectToolcraftVitestRuntimeRequirements(
+  requirements: readonly ToolcraftVitestRuntimeRequirement[],
+  serializedSelection: string | undefined,
+): readonly ToolcraftVitestRuntimeRequirement[];
 
 export function serializeToolcraftVitestRuntimeRequirements(
   requirements: readonly ToolcraftVitestRuntimeRequirement[],

package/templates/starter/scripts/toolcraft-vitest-runtime-contract.mjs

@@ -7,8 +7,36 @@ export const TOOLCRAFT_VITEST_RUNTIME_MARKER_FILE_NAMES = Object.freeze([
   "starter-automated-runtime-evidence.test.ts",
   "app-automated-runtime-evidence.test.ts",
 ]);
+export const TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_ENV =
+  "TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION";
 const TOOLCRAFT_VITEST_RUNTIME_EVIDENCE_REPORTER =
   "--reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs";
+const TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_VERSION = 1;
+const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+
+function getCanonicalAcceptanceIdsError(acceptanceIds) {
+  if (
+    !Array.isArray(acceptanceIds) ||
+    Reflect.ownKeys(acceptanceIds).length !== acceptanceIds.length + 1 ||
+    !Array.from(
+      { length: acceptanceIds.length },
+      (_, index) => Object.hasOwn(acceptanceIds, index),
+    ).every(Boolean) ||
+    acceptanceIds.some(
+      (acceptanceId) =>
+        typeof acceptanceId !== "string" ||
+        acceptanceId.trim() !== acceptanceId ||
+        acceptanceId.length === 0,
+    ) ||
+    acceptanceIds.some(
+      (acceptanceId, index) =>
+        index > 0 && compare(acceptanceIds[index - 1], acceptanceId) >= 0,
+    )
+  ) {
+    return "Toolcraft runtime acceptance selection must be sorted and unique.";
+  }
+  return undefined;
+}
 
 export function getToolcraftProductTestProcessArgs(files) {
   const includesRuntimeMarker =
@@ -26,6 +54,20 @@ export function getToolcraftProductTestProcessArgs(files) {
   ];
 }
 
+export function getToolcraftProductTestProcessEnvironment(
+  acceptanceIds,
+  inheritedEnvironment = process.env,
+) {
+  const environment = { ...inheritedEnvironment };
+  if (acceptanceIds === null) {
+    delete environment[TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_ENV];
+  } else {
+    environment[TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_ENV] =
+      serializeToolcraftVitestRuntimeAcceptanceSelection(acceptanceIds);
+  }
+  return environment;
+}
+
 export function serializeToolcraftVitestRuntimeRequirements(requirements) {
   return JSON.stringify({
     requirements,
@@ -33,6 +75,71 @@ export function serializeToolcraftVitestRuntimeRequirements(requirements) {
   });
 }
 
+export function serializeToolcraftVitestRuntimeAcceptanceSelection(
+  acceptanceIds,
+) {
+  const error = getCanonicalAcceptanceIdsError(acceptanceIds);
+  if (error) throw new Error(error);
+  return JSON.stringify({
+    acceptanceIds,
+    version: TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_VERSION,
+  });
+}
+
+export function parseToolcraftVitestRuntimeAcceptanceSelection(serialized) {
+  let payload;
+  try {
+    payload = JSON.parse(serialized);
+  } catch {
+    throw new Error("Toolcraft runtime acceptance selection is malformed.");
+  }
+  if (
+    !payload ||
+    typeof payload !== "object" ||
+    Array.isArray(payload) ||
+    Object.keys(payload).length !== 2 ||
+    !Object.hasOwn(payload, "acceptanceIds") ||
+    !Object.hasOwn(payload, "version") ||
+    payload.version !== TOOLCRAFT_VITEST_RUNTIME_ACCEPTANCE_SELECTION_VERSION
+  ) {
+    throw new Error("Toolcraft runtime acceptance selection is malformed.");
+  }
+  const error = getCanonicalAcceptanceIdsError(payload.acceptanceIds);
+  if (error) throw new Error(error);
+  return payload.acceptanceIds;
+}
+
+export function selectToolcraftVitestRuntimeRequirements(
+  requirements,
+  serializedSelection,
+) {
+  if (serializedSelection === undefined) return requirements;
+
+  const acceptanceIds = parseToolcraftVitestRuntimeAcceptanceSelection(
+    serializedSelection,
+  );
+  const acceptanceRequirements = new Map();
+  for (const requirement of requirements) {
+    if (requirement.kind !== "acceptance") continue;
+    if (acceptanceRequirements.has(requirement.requirementId)) {
+      throw new Error(
+        `Duplicate Toolcraft acceptance requirement "${requirement.requirementId}".`,
+      );
+    }
+    acceptanceRequirements.set(requirement.requirementId, requirement);
+  }
+
+  return acceptanceIds.map((acceptanceId) => {
+    const requirement = acceptanceRequirements.get(acceptanceId);
+    if (!requirement) {
+      throw new Error(
+        `Toolcraft runtime selection contains unknown acceptance requirement "${acceptanceId}".`,
+      );
+    }
+    return requirement;
+  });
+}
+
 export function parseToolcraftVitestRuntimeRequirements(annotation) {
   if (
     !annotation ||