@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-delivery-plan-authority.test.mjs

@@ -7,336 +7,141 @@ import {
   getToolcraftDeliveryPlanError,
 } from "./toolcraft-delivery-plan.mjs";
 import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
+  createToolcraftDeliveryLifecycleState,
 } from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftFunctionalProofModel,
-  createToolcraftFunctionalProofModelHash,
-} from "./toolcraft-functional-proof-model.mjs";
 import {
   createToolcraftPerformanceRequestAuthorityHash,
 } from "./toolcraft-performance-authority-policy.mjs";
 import {
-  createToolcraftVerificationSourceHash,
-} from "./toolcraft-verification-inventory.mjs";
-
-const hash = (character) => character.repeat(64);
-const pathId =
-  "performance-path:%5B%22interactive-discrete%22%2C%22control-change%22%2C%5B%22preview-composite%22%5D%2C%5B%22main%22%5D%2C%5B%5D%5D";
-const performanceTestName = `browser perf: toolcraft path ${pathId}`;
-const authoritySource = Object.freeze({
-  heading: "Delivery 2 - Slow preview",
-  pathIds: [pathId],
-  request: "The preview is still slow.",
-  requestEvidence: "The preview is still slow.",
-});
-const authority = Object.freeze({
-  hash: createToolcraftPerformanceRequestAuthorityHash(authoritySource),
-  ...authoritySource,
-});
-const catalog = {
-  acceptance: [
-    {
-      acceptanceId: "output.updates",
-      contractHash: hash("a"),
-      domainId: "output",
-      file: "app-output.spec.ts",
-      testName: "browser: output updates",
-    },
-    {
-      acceptanceId: "settings.persist",
-      contractHash: hash("b"),
-      domainId: "settings",
-      file: "app-settings.spec.ts",
-      testName: "browser: settings persist",
-    },
-  ],
-  performance: [{
-    passIds: ["preview-composite"],
-    pathId,
-    testName: performanceTestName,
-  }],
-  version: 2,
-};
-const allProductTestFiles = ["src/features/output.test.tsx"];
-const fullFunctionalSteps = [
-  { kind: "docs" },
-  { kind: "code-health" },
-  { kind: "product-tests", files: allProductTestFiles },
-  { kind: "build" },
-  {
-    kind: "browser-functional",
-    testNames: ["browser: output updates", "browser: settings persist"],
-  },
-];
-const performanceStep = {
-  kind: "browser-performance",
-  passIds: ["preview-composite"],
-  pathIds: [pathId],
-  testNames: [performanceTestName],
-};
-
-function inventory(digit) {
-  const entries = [{
-    path: "src/features/output.tsx",
-    sha256: hash(digit),
-  }];
-  return {
-    entries,
-    sourceHash: createToolcraftVerificationSourceHash(entries),
-  };
-}
-
-function proofModel(ownerPath) {
-  return createToolcraftFunctionalProofModel({
-    catalog,
-    inventory: {
-      owners: [{
-        acceptanceIds: ["output.updates", "settings.persist"],
-        kind: "functional",
-        path: ownerPath,
-      }],
-      version: 3,
-    },
+  deepFreezeToolcraftValue,
+} from "./toolcraft-functional-proof-primitives.mjs";
+import {
+  createToolcraftTargetedPerformanceComparisonHash,
+  createToolcraftTargetedPerformanceReport,
+} from "./toolcraft-targeted-performance-report.mjs";
+import {
+  createTargetedMeasurementFixture,
+} from "./toolcraft-verification-receipt-test-helpers.mjs";
+import {
+  authoritySource,
+  pathId,
+  performanceTestName,
+  performanceSteps,
+  planningInputs,
+  requestAuthority,
+} from "./toolcraft-delivery-plan-test-helpers.mjs";
+
+function createPreviousPerformance(sourceHash) {
+  const requestAuthorityHash = "e".repeat(64);
+  const report = createToolcraftTargetedPerformanceReport({
+    fixtureResolutionMode: "strict-development",
+    fixtureSelector: "development",
+    measurements: createTargetedMeasurementFixture([pathId]),
+    nonce: "previous-targeted-report",
+    performancePassIds: ["preview-composite"],
+    performancePathIds: [pathId],
+    requestAuthorityHash,
+    sourceHash,
+    testNames: [performanceTestName],
   });
-}
-
-function inputs({ initial = false, requestAuthority = null } = {}) {
-  const comparisonInventory = initial ? null : inventory("1");
-  const currentInventory = inventory("2");
-  const currentFunctionalProofModel = proofModel(
-    "src/features/output.tsx",
-  );
-  const previousFunctionalProofModel = initial
-    ? null
-    : proofModel("src/features/previous-output.tsx");
-  const impact = initial ? null : {
-    acceptanceIds: ["output.updates"],
-    browserTestNames: ["browser: output updates"],
-    buildRequired: true,
-    performanceCandidates: {
-      passIds: ["preview-composite"],
-      pathIds: [pathId],
-      testNames: [performanceTestName],
-    },
-    productTestFiles: allProductTestFiles,
-  };
   return {
-    allProductTestFiles,
-    authority: requestAuthority,
-    catalog,
-    changeSet: {
-      dependencyChanged: false,
-      docsChanged: false,
-      frameworkChanged: false,
-      impact,
-      platformChanged: false,
-      productInputsChanged: impact !== null,
-    },
-    comparisonInventory,
-    currentFunctionalProofModel,
-    currentInventory,
-    integrity: {
-      manifestHash: hash("a"),
-      sourceHash: currentInventory.sourceHash,
-    },
-    packageManager: "pnpm",
-    previousFunctionalProofModel,
-    previousLifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-    previousPerformance: { kind: "none" },
+    previousLifecycle: createToolcraftDeliveryLifecycleState({
+      requestAuthorityHash,
+    }),
+    previousPerformance: Object.freeze({
+      comparisonHash:
+        createToolcraftTargetedPerformanceComparisonHash(report),
+      kind: "performance-iteration-report",
+      report,
+      requestAuthorityHash,
+    }),
   };
 }
 
-function deepFreeze(value) {
-  if (value && typeof value === "object" && !Object.isFrozen(value)) {
-    Object.values(value).forEach(deepFreeze);
-    Object.freeze(value);
-  }
-  return value;
-}
-
-test("creates initial and changed functional plans with one exact basis", () => {
-  const initialInputs = inputs({ initial: true });
-  const initial = createToolcraftDeliveryPlan(initialInputs);
-  assert.deepEqual(initial, {
-    basis: { kind: "initial" },
-    functionalProofModelHash: createToolcraftFunctionalProofModelHash(
-      initialInputs.currentFunctionalProofModel,
-    ),
-    kind: "functional",
-    lifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-    manifestHash: hash("a"),
-    sourceHash: initialInputs.currentInventory.sourceHash,
-    steps: fullFunctionalSteps,
-  });
-  assert.equal(getToolcraftDeliveryDiagnosticTier(initial), 4);
+test("exact request authority creates build plus selected performance paths only", () => {
+  const inputs = planningInputs();
+  const plan = createToolcraftDeliveryPlan(inputs);
 
-  const changedInputs = inputs();
-  const changed = createToolcraftDeliveryPlan(changedInputs);
-  assert.deepEqual(changed.basis, {
-    changedFiles: ["src/features/output.tsx"],
-    comparisonFunctionalProofModelHash:
-      createToolcraftFunctionalProofModelHash(
-        changedInputs.previousFunctionalProofModel,
-      ),
-    comparisonInventory: changedInputs.comparisonInventory,
-    kind: "changed",
-  });
-  assert.equal(changed.kind, "functional");
-  assert.equal(
-    changed.steps.some(({ kind }) => kind === "browser-performance"),
-    false,
-  );
-  assert.equal(getToolcraftDeliveryDiagnosticTier(changed), 2);
-});
-
-test("rejects performance authority before the first functional receipt", () => {
-  assert.throws(
-    () => createToolcraftDeliveryPlan(inputs({
-      initial: true,
-      requestAuthority: authority,
-    })),
-    /first delivery must be functional/iu,
-  );
-});
-
-test("creates a changed authorized iteration with exact affected proof", () => {
-  const planningInputs = inputs({ requestAuthority: authority });
-  const plan = createToolcraftDeliveryPlan(planningInputs);
-  const functionalPlan = createToolcraftDeliveryPlan({
-    ...planningInputs,
-    authority: null,
-  });
   assert.deepEqual(plan.basis, {
-    changedFiles: ["src/features/output.tsx"],
-    comparisonFunctionalProofModelHash:
-      createToolcraftFunctionalProofModelHash(
-        planningInputs.previousFunctionalProofModel,
-      ),
-    comparisonInventory: planningInputs.comparisonInventory,
-    kind: "changed",
+    initialFunctionalProofModelHash:
+      inputs.initialProof.functionalProofModelHash,
+    initialSourceHash: inputs.initialProof.sourceHash,
+    kind: "performance-request",
   });
   assert.equal(plan.kind, "performance-iteration");
-  assert.deepEqual(plan.steps, [
-    { kind: "code-health" },
-    { kind: "product-tests", files: allProductTestFiles },
-    { kind: "build" },
-    {
-      kind: "browser-functional",
-      testNames: ["browser: output updates"],
-    },
-    performanceStep,
-  ]);
+  assert.equal(plan.requestAuthorityHash, requestAuthority.hash);
+  assert.deepEqual(plan.steps, performanceSteps);
+  assert.equal(getToolcraftDeliveryDiagnosticTier(plan), 3);
   assert.equal(
-    plan.functionalProofModelHash,
-    functionalPlan.functionalProofModelHash,
+    plan.steps.some(({ kind }) => kind === "browser-functional"),
+    false,
   );
-  assert.deepEqual(plan.steps.slice(0, -1), functionalPlan.steps);
   assert.equal(
-    plan.steps.filter(({ kind }) => kind === "browser-performance").length,
-    1,
+    plan.steps.some(({ kind }) => kind === "product-tests"),
+    false,
   );
-  assert.equal(getToolcraftDeliveryDiagnosticTier(plan), 3);
 });
 
-test("creates an authorized iteration for a passless viewport path", () => {
-  const passlessPathId =
-    "performance-path:%5B%22interactive-continuous%22%2C%22viewport-drag%22%2C%5B%5D%2C%5B%5D%2C%5B%5D%5D";
-  const testName = `browser perf: toolcraft path ${passlessPathId}`;
+test("performance authority must select a canonical catalog path", () => {
+  const inputs = planningInputs();
+  const unknownPath = `performance-path:${encodeURIComponent(JSON.stringify([
+    "interactive-continuous",
+    "control-drag",
+    ["preview-composite"],
+    ["main"],
+    [],
+  ]))}`;
   const source = {
-    heading: "Delivery 2 - Slow viewport drag",
-    pathIds: [passlessPathId],
-    request: "The canvas is slow while panning.",
-    requestEvidence: "The canvas is slow while panning.",
-  };
-  const planningInputs = inputs({
-    requestAuthority: {
-      hash: createToolcraftPerformanceRequestAuthorityHash(source),
-      ...source,
-    },
-  });
-  planningInputs.catalog = {
-    ...catalog,
-    performance: [{ passIds: [], pathId: passlessPathId, testName }],
+    ...authoritySource,
+    pathIds: [unknownPath],
   };
-  planningInputs.changeSet.impact.performanceCandidates = {
-    passIds: [],
-    pathIds: [passlessPathId],
-    testNames: [testName],
+  inputs.authority = {
+    hash: createToolcraftPerformanceRequestAuthorityHash(source),
+    ...source,
   };
-
-  const plan = createToolcraftDeliveryPlan(planningInputs);
-
-  assert.equal(plan.kind, "performance-iteration");
-  assert.deepEqual(
-    plan.steps.find(({ kind }) => kind === "browser-performance"),
-    {
-      kind: "browser-performance",
-      passIds: [],
-      pathIds: [passlessPathId],
-      testNames: [testName],
-    },
+  assert.throws(
+    () => createToolcraftDeliveryPlan(inputs),
+    /unknown path/iu,
   );
 });
 
-test("keeps performance-adapter-only changes functional without inferred measurement", () => {
-  const planningInputs = inputs();
-  planningInputs.changeSet.impact = {
-    acceptanceIds: [],
-    browserTestNames: [],
-    buildRequired: false,
-    performanceCandidates: {
-      passIds: ["preview-composite"],
-      pathIds: [pathId],
-      testNames: [performanceTestName],
-    },
-    productTestFiles: [],
-  };
+test("reuses performance comparison only for the exact current source", () => {
+  const current = planningInputs();
+  const inputs = planningInputs(createPreviousPerformance(
+    current.currentInventory.sourceHash,
+  ));
+  const plan = createToolcraftDeliveryPlan(inputs);
 
-  const plan = createToolcraftDeliveryPlan(planningInputs);
+  assert.equal(plan.performanceComparison.kind, "compatible-targeted-report");
+  assert.equal(plan.lifecycle.performanceEscalationOffered, true);
 
-  assert.equal(plan.kind, "functional");
-  assert.deepEqual(plan.steps, [{ kind: "code-health" }]);
+  const changed = planningInputs(createPreviousPerformance("9".repeat(64)));
+  const changedPlan = createToolcraftDeliveryPlan(changed);
+  assert.deepEqual(changedPlan.performanceComparison, { kind: "none" });
+  assert.equal(changedPlan.lifecycle.performanceEscalationOffered, false);
 });
 
-test("rejects malformed basis and functional performance proof", () => {
-  const valid = createToolcraftDeliveryPlan(inputs());
-  for (const basis of [
-    { kind: "initial", changedFiles: valid.basis.changedFiles },
-    { kind: "changed", changedFiles: valid.basis.changedFiles },
-    {
-      ...valid.basis,
-      comparisonInventory: {
-        ...valid.basis.comparisonInventory,
-        sourceHash: valid.sourceHash,
-      },
+test("rejects a compatible performance comparison from another source", () => {
+  const current = planningInputs();
+  const plan = createToolcraftDeliveryPlan(planningInputs(
+    createPreviousPerformance(current.currentInventory.sourceHash),
+  ));
+  const report = createToolcraftTargetedPerformanceReport({
+    ...plan.performanceComparison.report,
+    sourceHash: "9".repeat(64),
+  });
+  const malformed = deepFreezeToolcraftValue({
+    ...plan,
+    performanceComparison: {
+      comparisonHash:
+        createToolcraftTargetedPerformanceComparisonHash(report),
+      kind: "compatible-targeted-report",
+      report,
     },
-  ]) {
-    const malformed = deepFreeze({ ...valid, basis });
-    assert.match(
-      getToolcraftDeliveryPlanError(malformed),
-      /basis|inventory|provenance/iu,
-    );
-  }
-
-  const withPerformance = deepFreeze({
-    ...valid,
-    steps: [...valid.steps, performanceStep],
   });
-  assert.match(
-    getToolcraftDeliveryPlanError(withPerformance),
-    /functional.*performance/iu,
-  );
 
-  const performance = createToolcraftDeliveryPlan(
-    inputs({ requestAuthority: authority }),
-  );
-  const initialPerformance = deepFreeze({
-    ...performance,
-    basis: { kind: "initial" },
-  });
   assert.match(
-    getToolcraftDeliveryPlanError(initialPerformance),
-    /performance iteration requires a previous successful delivery/iu,
+    getToolcraftDeliveryPlanError(malformed),
+    /malformed or incompatible/iu,
   );
 });

package/templates/starter/scripts/toolcraft-delivery-plan-construction.mjs

@@ -6,20 +6,18 @@ import {
 import {
   createToolcraftFunctionalProofModelHash,
 } from "./toolcraft-functional-proof-model.mjs";
-import {
-  getToolcraftChangedVerificationFiles,
-} from "./toolcraft-verification-inventory.mjs";
 
 const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 
-function fixedSteps(inputs, dependencies) {
+function initialSteps(inputs) {
   return [
-    ...(dependencies
-      ? [{ kind: "dependencies", packageManager: inputs.packageManager }]
-      : []),
     { kind: "docs" },
     { kind: "code-health" },
-    { kind: "product-tests", files: inputs.allProductTestFiles },
+    {
+      acceptanceIds: null,
+      files: inputs.allProductTestFiles,
+      kind: "product-tests",
+    },
     { kind: "build" },
     {
       kind: "browser-functional",
@@ -30,23 +28,13 @@ function fixedSteps(inputs, dependencies) {
   ];
 }
 
-function performanceStep(selection) {
-  return {
-    kind: "browser-performance",
-    passIds: selection.passIds,
-    pathIds: selection.pathIds,
-    testNames: selection.testNames,
-  };
-}
-
 function authorityPerformanceSelection(inputs) {
   const rows = inputs.catalog.performance.filter(({ pathId }) =>
     inputs.authority.pathIds.includes(pathId),
   );
   return {
-    passIds: [
-      ...new Set(rows.flatMap(({ passIds }) => passIds)),
-    ].sort(compare),
+    passIds: [...new Set(rows.flatMap(({ passIds }) => passIds))]
+      .sort(compare),
     pathIds: rows.map(({ pathId }) => pathId).sort(compare),
     testNames: rows.map(({ testName }) => testName).sort(compare),
   };
@@ -56,20 +44,11 @@ function performanceComparison(inputs, selection) {
   const previous = inputs.previousPerformance;
   if (
     previous.kind === "none" ||
+    previous.report.sourceHash !== inputs.currentInventory.sourceHash ||
     previous.report.fixtureResolutionMode !== "strict-development" ||
-    previous.report.sourceHash !== inputs.comparisonInventory.sourceHash ||
-    !isDeepStrictEqual(
-      previous.report.performancePathIds,
-      selection.pathIds,
-    ) ||
-    !isDeepStrictEqual(
-      previous.report.performancePassIds,
-      selection.passIds,
-    ) ||
-    !isDeepStrictEqual(
-      previous.report.testNames,
-      selection.testNames,
-    )
+    !isDeepStrictEqual(previous.report.performancePathIds, selection.pathIds) ||
+    !isDeepStrictEqual(previous.report.performancePassIds, selection.passIds) ||
+    !isDeepStrictEqual(previous.report.testNames, selection.testNames)
   ) {
     return { kind: "none" };
   }
@@ -80,87 +59,57 @@ function performanceComparison(inputs, selection) {
   };
 }
 
-function changedSteps(inputs) {
-  const steps = [];
-  const full =
-    inputs.changeSet.dependencyChanged ||
-    inputs.changeSet.platformChanged;
-  const impact = inputs.changeSet.impact;
-  if (full) {
-    return fixedSteps(inputs, inputs.changeSet.dependencyChanged);
-  }
-  if (inputs.changeSet.docsChanged) steps.push({ kind: "docs" });
-  if (inputs.changeSet.frameworkChanged || impact) {
-    steps.push({ kind: "code-health" });
-  }
-  if (impact?.productTestFiles.length) {
-    steps.push({
-      files: impact.productTestFiles,
-      kind: "product-tests",
-    });
-  }
-  if (impact?.buildRequired) {
-    steps.push({ kind: "build" });
-  }
-  if (impact?.browserTestNames.length) {
-    steps.push({
-      kind: "browser-functional",
-      testNames: impact.browserTestNames,
-    });
-  }
-  return steps;
+function performancePlan(inputs, common) {
+  const selected = authorityPerformanceSelection(inputs);
+  const comparison = performanceComparison(inputs, selected);
+  return {
+    ...common,
+    basis: {
+      initialFunctionalProofModelHash:
+        inputs.initialProof.functionalProofModelHash,
+      initialSourceHash: inputs.initialProof.sourceHash,
+      kind: "performance-request",
+    },
+    kind: "performance-iteration",
+    lifecycle: createToolcraftDeliveryPlanLifecycle({
+      kind: "performance-iteration",
+      performanceComparison: comparison,
+      previous: inputs.previousLifecycle,
+      requestAuthorityHash: inputs.authority.hash,
+    }),
+    performanceComparison: comparison,
+    requestAuthorityHash: inputs.authority.hash,
+    steps: [
+      { kind: "build" },
+      {
+        kind: "browser-performance",
+        passIds: selected.passIds,
+        pathIds: selected.pathIds,
+        testNames: selected.testNames,
+      },
+    ],
+  };
 }
 
 export function constructToolcraftDeliveryPlan(inputs) {
-  const initial = inputs.comparisonInventory === null;
-  const basis = initial
-    ? { kind: "initial" }
-    : {
-        changedFiles: getToolcraftChangedVerificationFiles(
-          inputs.comparisonInventory.entries,
-          inputs.currentInventory.entries,
-        ),
-        comparisonFunctionalProofModelHash:
-          createToolcraftFunctionalProofModelHash(
-            inputs.previousFunctionalProofModel,
-          ),
-        comparisonInventory: inputs.comparisonInventory,
-        kind: "changed",
-      };
-  const steps = initial ? fixedSteps(inputs, false) : changedSteps(inputs);
   const common = {
-    basis,
     functionalProofModelHash: createToolcraftFunctionalProofModelHash(
       inputs.currentFunctionalProofModel,
     ),
     manifestHash: inputs.integrity.manifestHash,
     sourceHash: inputs.currentInventory.sourceHash,
   };
-  if (inputs.authority === null) {
+  if (inputs.initialProof === null) {
     return {
       ...common,
+      basis: { kind: "initial" },
       kind: "functional",
       lifecycle: createToolcraftDeliveryPlanLifecycle({
         kind: "functional",
         previous: inputs.previousLifecycle,
       }),
-      steps,
+      steps: initialSteps(inputs),
     };
   }
-  const selectedPerformance = authorityPerformanceSelection(inputs);
-  steps.push(performanceStep(selectedPerformance));
-  const comparison = performanceComparison(inputs, selectedPerformance);
-  return {
-    ...common,
-    kind: "performance-iteration",
-    lifecycle: createToolcraftDeliveryPlanLifecycle({
-      kind: "performance-iteration",
-      performanceComparison: comparison,
-      previous: inputs.previousLifecycle,
-      requestAuthorityHash: inputs.authority.hash,
-    }),
-    performanceComparison: comparison,
-    requestAuthorityHash: inputs.authority.hash,
-    steps,
-  };
+  return performancePlan(inputs, common);
 }