@pixel-point/toolcraft 0.0.17 → 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,
+  );
 });