@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-performance-escalation-policy.test.mjs

@@ -2,22 +2,12 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  normalizeToolcraftDeliveryAnchor,
-} from "./toolcraft-delivery-anchor.mjs";
+  createToolcraftDeliveryLifecycleState,
+} from "./toolcraft-delivery-lifecycle-state.mjs";
 import {
   createToolcraftDeliveryReceipt,
 } from "./toolcraft-delivery-receipt.mjs";
 import {
-  createToolcraftDeliveryPlan,
-} from "./toolcraft-delivery-plan.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftFunctionalProofModel,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  createInventory,
   createPlanReceiptFixture,
 } from "./toolcraft-delivery-receipt-test-helpers.mjs";
 import {
@@ -25,369 +15,111 @@ import {
   getToolcraftPerformanceEscalationRecommendation,
 } from "./toolcraft-performance-escalation-policy.mjs";
 import {
-  createToolcraftPerformanceRequestAuthorityHash,
-  TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND,
-} from "./toolcraft-performance-authority-policy.mjs";
-import {
-  createToolcraftTargetedPerformanceReport,
+  createToolcraftTargetedPerformanceComparisonHash,
   createToolcraftTargetedPerformanceEvidenceHash,
+  createToolcraftTargetedPerformanceReport,
 } from "./toolcraft-targeted-performance-report.mjs";
-import {
-  createTargetedMeasurementFixture,
-} from "./toolcraft-verification-receipt-test-helpers.mjs";
-
-const hash = (character) => character.repeat(64);
-const pathId =
-  "performance-path:%5B%22interactive-discrete%22%2C%22control-change%22%2C%5B%22composite%22%5D%2C%5B%22main%22%5D%2C%5B%5D%5D";
-const performanceTestName = `browser perf: toolcraft path ${pathId}`;
-const functionalTestName = "browser: focused acceptance";
-const expectedRecommendation = {
-  command: TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND,
-  kind: "offer-full-performance-audit",
-  reason: "two-consecutive-compatible-performance-iterations",
-  requiresExplicitUserConsent: true,
-};
-
-function deliveryCatalog(testName = functionalTestName) {
-  return {
-    acceptance: [{
-      acceptanceId: "output.updates",
-      contractHash: hash("b"),
-      domainId: "output",
-      file: "app-controls.spec.ts",
-      testName,
-    }],
-    performance: [{
-      passIds: ["composite"],
-      pathId,
-      testName: performanceTestName,
-    }],
-    version: 2,
-  };
-}
-
-function functionalProofModel(catalog) {
-  return createToolcraftFunctionalProofModel({
-    catalog,
-    inventory: {
-      owners: [{
-        acceptanceIds: ["output.updates"],
-        kind: "performance",
-        passIds: ["composite"],
-        path: "src/app/app-schema.ts",
-      }],
-      version: 3,
-    },
-  });
-}
 
-function requestAuthority(heading, request) {
-  const source = {
-    heading,
-    pathIds: [pathId],
-    request,
-    requestEvidence: request,
-  };
-  return {
-    hash: createToolcraftPerformanceRequestAuthorityHash(source),
-    ...source,
-  };
+function freeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+  return value;
 }
 
-function createFirstPlannerReceipt() {
-  const comparisonInventory = createInventory({
-    "src/app/app-schema.ts": hash("1"),
-  });
-  const finalInventory = createInventory({
-    "src/app/app-schema.ts": hash("2"),
-  });
-  const authority = requestAuthority(
-    "Delivery 1 - Slow preview",
-    "The preview is slow.",
-  );
-  const requestAuthorityHash = authority.hash;
-  const catalog = deliveryCatalog();
-  const model = functionalProofModel(catalog);
-  const plan = createToolcraftDeliveryPlan({
-    allProductTestFiles: ["src/app/app-schema.test.ts"],
-    authority,
-    catalog,
-    changeSet: {
-      dependencyChanged: false,
-      docsChanged: false,
-      frameworkChanged: false,
-      impact: {
-        acceptanceIds: ["output.updates"],
-        browserTestNames: [functionalTestName],
-        buildRequired: true,
-        performanceCandidates: {
-          passIds: ["composite"],
-          pathIds: [pathId],
-          testNames: [performanceTestName],
-        },
-        productTestFiles: [],
-      },
-      platformChanged: false,
-      productInputsChanged: true,
-    },
-    comparisonInventory,
-    currentFunctionalProofModel: model,
-    currentInventory: finalInventory,
-    integrity: {
-      manifestHash: hash("a"),
-      sourceHash: finalInventory.sourceHash,
-    },
-    packageManager: "pnpm",
-    previousFunctionalProofModel: model,
-    previousLifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-    previousPerformance: { kind: "none" },
-  });
-  const testEvidence = [{
-    fullTitle: `app-controls.spec.ts › ${performanceTestName}`,
-    leafTitle: performanceTestName,
-  }];
+function createCompatiblePair() {
+  const firstFixture = createPlanReceiptFixture("performance-iteration");
+  const firstReceipt = createToolcraftDeliveryReceipt(firstFixture);
+  const firstEvidence = firstReceipt.evidence.at(-1);
+  const requestAuthorityHash = "e".repeat(64);
   const report = createToolcraftTargetedPerformanceReport({
-    fixtureResolutionMode: "strict-development",
-    fixtureSelector: "development",
-    measurements: createTargetedMeasurementFixture([pathId]),
-    nonce: "first-planner-receipt",
-    performancePassIds: ["composite"],
-    performancePathIds: [pathId],
+    ...firstEvidence.report,
+    nonce: "second-targeted-report",
     requestAuthorityHash,
-    sourceHash: finalInventory.sourceHash,
-    testNames: [performanceTestName],
   });
-  return createToolcraftDeliveryReceipt({
-    functionalProofModel: model,
-    plan,
-    result: {
-      evidence: plan.steps.map((step) =>
-        step.kind === "browser-performance"
-          ? {
-              ...step,
-              evidenceHash: createToolcraftTargetedPerformanceEvidenceHash({
-                report,
-                testEvidence,
-              }),
-              report,
-              testEvidence,
-            }
-          : { ...step }
+  const testEvidence = firstEvidence.testEvidence;
+  const plan = freeze({
+    ...firstReceipt.plan,
+    lifecycle: createToolcraftDeliveryLifecycleState({
+      performanceEscalationReached: true,
+      previous: firstReceipt.plan.lifecycle,
+      requestAuthorityHash,
+    }),
+    performanceComparison: {
+      comparisonHash: createToolcraftTargetedPerformanceComparisonHash(
+        firstEvidence.report,
       ),
-      finalInventory,
+      kind: "compatible-targeted-report",
+      report: firstEvidence.report,
     },
-  });
-}
-
-function createCompatibleReceipt(
-  previousReceipt,
-  requestMarker,
-  inventoryCharacter,
-) {
-  const previousAnchor =
-    normalizeToolcraftDeliveryAnchor(previousReceipt);
-  const finalInventory = createInventory({
-    "src/app/app-schema.ts": hash(inventoryCharacter),
-  });
-  const previousEvidence = previousReceipt.evidence.at(-1);
-  const previousPerformanceStep = previousReceipt.plan.steps.find(
-    ({ kind }) => kind === "browser-performance",
-  );
-  const previousFunctionalStep = previousReceipt.plan.steps.find(
-    ({ kind }) => kind === "browser-functional",
-  );
-  const authority = requestAuthority(
-    `Delivery ${requestMarker} - Slow preview`,
-    `The preview is still slow after ${requestMarker}.`,
-  );
-  const requestAuthorityHash = authority.hash;
-  const report = createToolcraftTargetedPerformanceReport({
-    ...previousEvidence.report,
     requestAuthorityHash,
-    sourceHash: finalInventory.sourceHash,
   });
-  const evidenceHash = createToolcraftTargetedPerformanceEvidenceHash({
-    report,
-    testEvidence: previousEvidence.testEvidence,
-  });
-  const catalog = deliveryCatalog(
-    previousFunctionalStep.testNames[0],
-  );
-  const model = previousReceipt.functionalProofModel;
-  const plan = createToolcraftDeliveryPlan({
-    allProductTestFiles: ["src/app/app-schema.test.ts"],
-    authority,
-    catalog,
-    changeSet: {
-      dependencyChanged: false,
-      docsChanged: false,
-      frameworkChanged: false,
-      impact: {
-        acceptanceIds: ["output.updates"],
-        browserTestNames: previousFunctionalStep.testNames,
-        buildRequired: true,
-        performanceCandidates: {
-          passIds: previousPerformanceStep.passIds,
-          pathIds: previousPerformanceStep.pathIds,
-          testNames: previousPerformanceStep.testNames,
+  const secondReceipt = createToolcraftDeliveryReceipt({
+    functionalProofModel: firstReceipt.functionalProofModel,
+    plan,
+    result: {
+      evidence: [
+        { kind: "build" },
+        {
+          ...firstEvidence,
+          evidenceHash: createToolcraftTargetedPerformanceEvidenceHash({
+            report,
+            testEvidence,
+          }),
+          report,
         },
-        productTestFiles: [],
-      },
-      platformChanged: false,
-      productInputsChanged: true,
-    },
-    comparisonInventory: {
-      entries: previousReceipt.files,
-      sourceHash: previousReceipt.sourceHash,
+      ],
+      finalInventory: firstFixture.result.finalInventory,
     },
-    currentFunctionalProofModel: model,
-    currentInventory: finalInventory,
-    integrity: {
-      manifestHash: previousReceipt.manifestHash,
-      sourceHash: finalInventory.sourceHash,
-    },
-    packageManager: "pnpm",
-    previousFunctionalProofModel:
-      previousAnchor.functionalProofModel,
-    previousLifecycle: previousAnchor.lifecycle,
-    previousPerformance: previousAnchor.performance,
   });
-  return createToolcraftDeliveryReceipt({
-    functionalProofModel: model,
-    plan,
-    result: {
-      evidence: plan.steps.map((step) =>
-        step.kind === "browser-performance"
-          ? {
-              ...step,
-              evidenceHash,
-              report,
-              testEvidence: previousEvidence.testEvidence,
-            }
-          : { ...step }
+  const previousAnchor = {
+    lifecycle: firstReceipt.plan.lifecycle,
+    performance: {
+      comparisonHash: createToolcraftTargetedPerformanceComparisonHash(
+        firstEvidence.report,
       ),
-      finalInventory,
+      kind: "performance-iteration-report",
+      report: firstEvidence.report,
+      requestAuthorityHash: firstReceipt.plan.requestAuthorityHash,
     },
-  });
-}
-
-function createCompatiblePair() {
-  const firstReceipt = createFirstPlannerReceipt();
-  const previousAnchor = normalizeToolcraftDeliveryAnchor(firstReceipt);
-  const currentReceipt = createCompatibleReceipt(
-    firstReceipt,
-    "2",
-    "3",
-  );
-  return { currentReceipt, previousAnchor };
+  };
+  return { firstReceipt, previousAnchor, secondReceipt };
 }
 
-test("does not recommend a full audit after the first performance iteration", () => {
-  const currentReceipt = createToolcraftDeliveryReceipt(
+test("first targeted performance iteration does not recommend a full audit", () => {
+  const firstReceipt = createToolcraftDeliveryReceipt(
     createPlanReceiptFixture("performance-iteration"),
   );
-  const previousAnchor = normalizeToolcraftDeliveryAnchor(
-    createToolcraftDeliveryReceipt(createPlanReceiptFixture("functional-changed")),
-  );
-  assert.equal(
-    getToolcraftPerformanceEscalationRecommendation({
-      currentReceipt,
-      previousAnchor,
-    }),
-    null,
-  );
-});
-
-test("recommends but never invokes a full audit after two compatible iterations", () => {
-  const pair = createCompatiblePair();
-  assert.deepEqual(
-    getToolcraftPerformanceEscalationRecommendation(pair),
-    expectedRecommendation,
-  );
-  const message = formatToolcraftPerformanceEscalationRecommendation(
-    expectedRecommendation,
-  );
-  assert.match(message, /offer.*complete performance audit/iu);
-  assert.match(
-    message,
-    new RegExp(
-      `do not run ${TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND.replace(
-        /[.*+?^${}()|[\]\\]/gu,
-        "\\$&",
-      )} without explicit user consent`,
-      "iu",
-    ),
-  );
-  assert.equal(
-    Object.hasOwn(expectedRecommendation, "execute"),
-    false,
-  );
-});
-
-test("three compatible iterations produce exactly one durable offer", () => {
-  const second = createCompatiblePair();
-  const thirdReceipt = createCompatibleReceipt(
-    second.currentReceipt,
-    "3",
-    "4",
-  );
-  const third = {
-    currentReceipt: thirdReceipt,
-    previousAnchor: normalizeToolcraftDeliveryAnchor(
-      second.currentReceipt,
-    ),
-  };
-
-  assert.equal(
-    second.previousAnchor.lifecycle.performanceEscalationOffered,
-    false,
-  );
-  assert.equal(
-    second.currentReceipt.plan.lifecycle.performanceEscalationOffered,
-    true,
-  );
-  assert.equal(
-    third.currentReceipt.plan.lifecycle.performanceEscalationOffered,
-    true,
-  );
-  assert.deepEqual(
-    getToolcraftPerformanceEscalationRecommendation(second),
-    expectedRecommendation,
-  );
-  assert.equal(
-    getToolcraftPerformanceEscalationRecommendation(third),
-    null,
-  );
-});
-
-test("rejects an evidence hash in place of the previous comparison hash", () => {
-  const { currentReceipt, previousAnchor } = createCompatiblePair();
-  const evidenceHash = createToolcraftTargetedPerformanceEvidenceHash({
-    report: previousAnchor.performance.report,
-    testEvidence: currentReceipt.evidence.at(-1).testEvidence,
-  });
   assert.equal(
     getToolcraftPerformanceEscalationRecommendation({
-      currentReceipt,
+      currentReceipt: firstReceipt,
       previousAnchor: {
-        ...previousAnchor,
-        performance: {
-          ...previousAnchor.performance,
-          comparisonHash: evidenceHash,
+        lifecycle: {
+          consumedPerformanceRequestAuthorityHashes: [],
+          performanceEscalationOffered: false,
         },
+        performance: { kind: "none" },
       },
     }),
     null,
   );
 });
 
-test("rejects malformed current receipts without interpreting legacy policy", () => {
-  const { previousAnchor } = createCompatiblePair();
-  assert.equal(
-    getToolcraftPerformanceEscalationRecommendation({
-      currentReceipt: { version: 4 },
-      previousAnchor,
-    }),
-    null,
+test("two compatible targeted iterations offer but never run full audit", () => {
+  const { previousAnchor, secondReceipt } = createCompatiblePair();
+  const recommendation = getToolcraftPerformanceEscalationRecommendation({
+    currentReceipt: secondReceipt,
+    previousAnchor,
+  });
+  assert.deepEqual(recommendation, {
+    command: "pnpm verify:perf",
+    kind: "offer-full-performance-audit",
+    reason: "two-consecutive-compatible-performance-iterations",
+    requiresExplicitUserConsent: true,
+  });
+  assert.match(
+    formatToolcraftPerformanceEscalationRecommendation(recommendation),
+    /do not run pnpm verify:perf without explicit user consent/iu,
   );
 });

package/templates/starter/scripts/toolcraft-performance-receipt-validation.test.mjs

@@ -125,7 +125,7 @@ test("rejects a receipt whose file inventory does not produce its source hash",
   await writeToolcraftCheckpointBundle({
     bundle: {
       ...loaded.bundle,
-      currentPerformance: { ...loaded.bundle.currentPerformance, files: [] },
+      performanceBaseline: { ...loaded.bundle.performanceBaseline, files: [] },
     },
     rootDir,
   });
@@ -177,8 +177,8 @@ test("rejects malformed and non-passed receipts", async (t) => {
   await writeToolcraftCheckpointBundle({
     bundle: {
       ...loaded.bundle,
-      currentPerformance: {
-        ...loaded.bundle.currentPerformance,
+      performanceBaseline: {
+        ...loaded.bundle.performanceBaseline,
         status: "failed",
       },
     },
@@ -189,26 +189,24 @@ test("rejects malformed and non-passed receipts", async (t) => {
   assert.match(failedErrors[0], /passed/iu);
 });
 
-test("rejects unsupported current and baseline receipt versions", async (t) => {
+test("rejects unsupported full baseline receipt versions", async (t) => {
   const rootDir = await createReceiptFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
 
-  for (const field of ["currentPerformance", "performanceBaseline"]) {
-    await writePassedCheckpointFixture(rootDir);
-    const loaded = await readToolcraftCheckpointBundle(rootDir);
-    await writeToolcraftCheckpointBundle({
-      bundle: {
-        ...loaded.bundle,
-        [field]: {
-          ...loaded.bundle[field],
-          version: 2,
-        },
+  await writePassedCheckpointFixture(rootDir);
+  const loaded = await readToolcraftCheckpointBundle(rootDir);
+  await writeToolcraftCheckpointBundle({
+    bundle: {
+      ...loaded.bundle,
+      performanceBaseline: {
+        ...loaded.bundle.performanceBaseline,
+        version: 2,
       },
-      rootDir,
-    });
-    assert.match(
-      (await validateToolcraftPerformanceReceipt({ rootDir }))[0],
-      /unsupported version/iu,
-    );
-  }
+    },
+    rootDir,
+  });
+  assert.match(
+    (await validateToolcraftPerformanceReceipt({ rootDir }))[0],
+    /unsupported version/iu,
+  );
 });

package/templates/starter/scripts/toolcraft-product-boundary-ast.mjs

@@ -59,7 +59,7 @@ function getImportViolationKind(moduleKind, importedName) {
 function getViolationMessage(kind, subject, moduleSpecifier) {
   switch (kind) {
     case "runtime-export-ownership":
-      return `Product source must not own artifact encoding, recording, or download mechanics${subject} from ${moduleSpecifier}. Declare exportRenderer and let runtime export actions encode and download the artifact.`;
+      return `Product source must not own artifact encoding, recording, or download mechanics${subject} from ${moduleSpecifier}. Declare exportRenderer for image/video or svgExportRenderer for SVG and let runtime export actions create and download the artifact.`;
     case "runtime-surface":
       return `Product source must not import or re-export host-owned runtime surface${subject} from ${moduleSpecifier}. Use ToolcraftAppComposition, schema, canvasContent, controlRenderers, onPanelAction, and runtime commands.`;
     case "runtime-model-presentation-ownership":

package/templates/starter/scripts/toolcraft-product-export-boundary.mjs

@@ -8,6 +8,7 @@ const forbiddenCanvasExportMethods = new Set([
   "toBlob",
   "toDataURL",
 ]);
+const forbiddenGlobalExportFunctions = new Set(["showSaveFilePicker"]);
 
 export function getToolcraftProductExportModuleKind(
   normalizedSpecifier,
@@ -116,12 +117,20 @@ export function createToolcraftProductExportInspector({
     return {
       ...getNodeLocation(sourceFile, node),
       kind: "runtime-export-ownership",
-      message: `Product source must not own ${subject}. Declare exportRenderer and let runtime export actions encode and download the artifact.`,
+      message: `Product source must not own ${subject}. Declare exportRenderer for image/video or svgExportRenderer for SVG and let runtime export actions create and download the artifact.`,
       repoPath,
     };
   }
 
   return (node) => {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      forbiddenGlobalExportFunctions.has(node.expression.text) &&
+      !isLexicallyDeclared(node.expression)
+    ) {
+      return [violation(node, `${node.expression.text} artifact delivery`)];
+    }
     if (
       ts.isNewExpression(node) &&
       ts.isIdentifier(node.expression) &&

package/templates/starter/scripts/toolcraft-product-export-boundary.test.mjs

@@ -23,6 +23,7 @@ test("keeps artifact encoding and download mechanics runtime-owned", async (cont
         canvas.toBlob(() => undefined);
         canvas.toDataURL();
         URL.createObjectURL(new Blob());
+        showSaveFilePicker();
         void createAliasBackend;
         void exportToolcraftImageArtifact;
         void downloadToolcraftArtifact;
@@ -41,6 +42,7 @@ test("keeps artifact encoding and download mechanics runtime-owned", async (cont
       import type {
         ToolcraftExportFrame,
         ToolcraftProductExportRenderer,
+        ToolcraftProductSvgExportRenderer,
       } from "@/toolcraft/runtime";
       export const renderFrame = ({ context }) => context.fillRect(0, 0, 1, 1);
       void Runtime;
@@ -49,6 +51,8 @@ test("keeps artifact encoding and download mechanics runtime-owned", async (cont
       void validateToolcraftArtifactSize;
       void (null as unknown as ToolcraftExportFrame);
       void (null as unknown as ToolcraftProductExportRenderer);
+      void (null as unknown as ToolcraftProductSvgExportRenderer);
+      void new XMLSerializer();
     `,
     "src/features/shadowed-globals.ts": `
       export function localNames(MediaRecorder, VideoEncoder, URL) {
@@ -61,7 +65,7 @@ test("keeps artifact encoding and download mechanics runtime-owned", async (cont
 
   const result = await evaluateToolcraftProductBoundary({ rootDir });
 
-  assert.equal(result.violations.length, 10);
+  assert.equal(result.violations.length, 11);
   assert.equal(
     result.violations.every(
       (violation) => violation.kind === "runtime-export-ownership",

package/templates/starter/scripts/toolcraft-product-observable-facade.test.mjs

@@ -20,7 +20,11 @@ async function loadProductObservableFacade(context) {
     .replaceAll('"@playwright/test"', '"./playwright.mjs"')
     .replaceAll('"./browser-runtime-evidence"', '"./evidence.mjs"')
     .replaceAll('"./browser-proof-session"', '"./proof-session.mjs"')
-    .replaceAll('"./stable-outcome-helpers"', '"./stable-outcome.mjs"');
+    .replaceAll('"./stable-outcome-helpers"', '"./stable-outcome.mjs"')
+    .replaceAll(
+      '"./browser-product-raster-snapshot"',
+      '"./raster-snapshot.mjs"',
+    );
   const { outputText } = ts.transpileModule(source, {
     compilerOptions: {
       module: ts.ModuleKind.ESNext,
@@ -91,6 +95,47 @@ async function loadProductObservableFacade(context) {
         }
       `,
     ),
+    fs.writeFile(
+      path.join(outputDir, "raster-snapshot.mjs"),
+      `
+        const warmedPages = new WeakSet();
+        const screenshotOptions = {
+          animations: "disabled",
+          caret: "hide",
+          scale: "css",
+          type: "png",
+        };
+
+        export async function resolveToolcraftProductRasterProbe(page, probe) {
+          const locator = page.locator(probe.selector);
+          const bounds = await locator.boundingBox();
+          if (
+            !bounds ||
+            bounds.width <= 0 ||
+            bounds.height <= 0 ||
+            bounds.width > 4096 ||
+            bounds.height > 4096 ||
+            bounds.width * bounds.height > 8_388_608
+          ) {
+            throw new Error(
+              'Raster probe exceeds the bounded visual proof limit.',
+            );
+          }
+          return {
+            bounds,
+            locator,
+            async capture() {
+              if (!warmedPages.has(page)) {
+                await locator.screenshot(screenshotOptions);
+                warmedPages.add(page);
+              }
+              const raster = await locator.screenshot(screenshotOptions);
+              return JSON.stringify(await page.evaluate(() => undefined, raster));
+            },
+          };
+        }
+      `,
+    ),
   ]);
 
   return import(`${pathToFileURL(outputPath).href}?test=${Date.now()}`);

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

@@ -35,7 +35,6 @@ const expectedVerificationReceiptExports = [
   "assertToolcraftVerificationInputsUnchanged",
   "collectToolcraftVerificationInputs",
   "readToolcraftDurablePerformanceBaseline",
-  "validateToolcraftCurrentPerformanceImpactInventory",
   "validateToolcraftPerformanceReceipt",
   "validateToolcraftVerificationReceipt",
 ];