@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -0,0 +1,125 @@
+import {
+  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
+} from "./toolcraft-delivery-lifecycle-state.mjs";
+import {
+  createToolcraftFunctionalProofModel,
+} from "./toolcraft-functional-proof-model.mjs";
+import {
+  createToolcraftPerformanceRequestAuthorityHash,
+} from "./toolcraft-performance-authority-policy.mjs";
+import {
+  createToolcraftVerificationSourceHash,
+} from "./toolcraft-verification-inventory.mjs";
+
+export const hash = (character) => character.repeat(64);
+export 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";
+export const performanceTestName = `browser perf: toolcraft path ${pathId}`;
+export const allProductTestFiles = [
+  "src/features/output.test.tsx",
+  "src/features/settings.test.tsx",
+];
+export const catalog = Object.freeze({
+  acceptance: Object.freeze([
+    Object.freeze({
+      acceptanceId: "output.updates",
+      contractHash: hash("b"),
+      domainId: "output",
+      file: "app-output.spec.ts",
+      testName: "browser: output updates",
+    }),
+    Object.freeze({
+      acceptanceId: "settings.persist",
+      contractHash: hash("c"),
+      domainId: "settings",
+      file: "app-settings.spec.ts",
+      testName: "browser: settings persist",
+    }),
+  ]),
+  performance: Object.freeze([Object.freeze({
+    passIds: Object.freeze(["preview-composite"]),
+    pathId,
+    testName: performanceTestName,
+  })]),
+  version: 2,
+});
+
+export const authoritySource = Object.freeze({
+  heading: "Delivery 2 - Slow preview",
+  pathIds: Object.freeze([pathId]),
+  request: "The preview is still slow.",
+  requestEvidence: "The preview is still slow.",
+});
+export const requestAuthority = Object.freeze({
+  hash: createToolcraftPerformanceRequestAuthorityHash(authoritySource),
+  ...authoritySource,
+});
+
+function inventory(digit) {
+  const entries = Object.freeze([Object.freeze({
+    path: "src/features/output.tsx",
+    sha256: hash(digit),
+  })]);
+  return Object.freeze({
+    entries,
+    sourceHash: createToolcraftVerificationSourceHash(entries),
+  });
+}
+
+export function planningInputs({
+  initial = false,
+  authority = initial ? null : requestAuthority,
+  previousLifecycle = EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
+  previousPerformance = Object.freeze({ kind: "none" }),
+} = {}) {
+  const currentInventory = inventory("2");
+  return {
+    allProductTestFiles,
+    authority,
+    catalog,
+    currentFunctionalProofModel:
+      createToolcraftFunctionalProofModel({ catalog }),
+    currentInventory,
+    initialProof: initial
+      ? null
+      : Object.freeze({
+          functionalProofModelHash: hash("d"),
+          sourceHash: inventory("1").sourceHash,
+        }),
+    integrity: {
+      manifestHash: hash("a"),
+      sourceHash: currentInventory.sourceHash,
+    },
+    packageManager: "pnpm",
+    previousLifecycle,
+    previousPerformance,
+  };
+}
+
+export const initialSteps = Object.freeze([
+  Object.freeze({ kind: "docs" }),
+  Object.freeze({ kind: "code-health" }),
+  Object.freeze({
+    acceptanceIds: null,
+    files: Object.freeze(allProductTestFiles),
+    kind: "product-tests",
+  }),
+  Object.freeze({ kind: "build" }),
+  Object.freeze({
+    kind: "browser-functional",
+    testNames: Object.freeze([
+      "browser: output updates",
+      "browser: settings persist",
+    ]),
+  }),
+]);
+
+export const performanceSteps = Object.freeze([
+  Object.freeze({ kind: "build" }),
+  Object.freeze({
+    kind: "browser-performance",
+    passIds: Object.freeze(["preview-composite"]),
+    pathIds: Object.freeze([pathId]),
+    testNames: Object.freeze([performanceTestName]),
+  }),
+]);

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

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createToolcraftDeliveryPlan,
+  getToolcraftDeliveryPlanError,
+} from "./toolcraft-delivery-plan.mjs";
+import {
+  planningInputs,
+} from "./toolcraft-delivery-plan-test-helpers.mjs";
+
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.values(value).forEach(deepFreeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+test("plan validation rejects mutable, incomplete, and expanded proof", () => {
+  const initial = createToolcraftDeliveryPlan(planningInputs({ initial: true }));
+  assert.match(getToolcraftDeliveryPlanError({ ...initial }), /immutable/iu);
+  assert.match(
+    getToolcraftDeliveryPlanError(deepFreeze({
+      ...initial,
+      steps: initial.steps.filter(({ kind }) => kind !== "build"),
+    })),
+    /preceding build/iu,
+  );
+
+  const performance = createToolcraftDeliveryPlan(planningInputs());
+  assert.match(
+    getToolcraftDeliveryPlanError(deepFreeze({
+      ...performance,
+      steps: [
+        { kind: "code-health" },
+        ...performance.steps,
+      ],
+    })),
+    /expands beyond exact performance work/iu,
+  );
+});
+
+test("planning input validation is exact and phase-aware", () => {
+  const extra = planningInputs({ initial: true });
+  extra.changeSet = {};
+  assert.throws(
+    () => createToolcraftDeliveryPlan(extra),
+    /planning inputs are malformed/iu,
+  );
+
+  const malformedProof = planningInputs();
+  malformedProof.initialProof = { sourceHash: "bad" };
+  assert.throws(
+    () => createToolcraftDeliveryPlan(malformedProof),
+    /initial product proof identity/iu,
+  );
+});

package/templates/starter/scripts/toolcraft-delivery-plan.d.mts

@@ -1,7 +1,6 @@
 import type {
   ToolcraftDeliveryCatalog,
-  ToolcraftVerificationImpact,
-} from "./toolcraft-verification-impact.d.mts";
+} from "./playwright-test-title-selection.mjs";
 import type {
   ToolcraftTargetedPerformanceComparisonHash,
   ToolcraftTargetedPerformanceReport,
@@ -31,13 +30,13 @@ export type ToolcraftDeliveryLifecycleState = Readonly<{
 }>;
 
 export type ToolcraftFunctionalProofStep =
-  | Readonly<{
-      kind: "dependencies";
-      packageManager: ToolcraftPackageManager;
-    }>
   | Readonly<{ kind: "docs" }>
   | Readonly<{ kind: "code-health" }>
-  | Readonly<{ kind: "product-tests"; files: readonly string[] }>
+  | Readonly<{
+      acceptanceIds: null;
+      files: readonly string[];
+      kind: "product-tests";
+    }>
   | Readonly<{ kind: "build" }>
   | Readonly<{
       kind: "browser-functional";
@@ -67,19 +66,14 @@ export type ToolcraftInitialDeliveryBasis = Readonly<{
   kind: "initial";
 }>;
 
-export type ToolcraftChangedDeliveryBasis = Readonly<{
-  kind: "changed";
-  comparisonFunctionalProofModelHash: string;
-  comparisonInventory: ToolcraftVerificationInventory;
-  changedFiles: readonly string[];
+export type ToolcraftPerformanceRequestBasis = Readonly<{
+  initialFunctionalProofModelHash: string;
+  initialSourceHash: string;
+  kind: "performance-request";
 }>;
 
-export type ToolcraftDeliveryBasis =
-  | ToolcraftInitialDeliveryBasis
-  | ToolcraftChangedDeliveryBasis;
-
 export type FunctionalDeliveryPlan = Readonly<{
-  basis: ToolcraftDeliveryBasis;
+  basis: ToolcraftInitialDeliveryBasis;
   functionalProofModelHash: string;
   kind: "functional";
   lifecycle: ToolcraftDeliveryLifecycleState;
@@ -89,7 +83,7 @@ export type FunctionalDeliveryPlan = Readonly<{
 }>;
 
 export type PerformanceIterationPlan = Readonly<{
-  basis: ToolcraftChangedDeliveryBasis;
+  basis: ToolcraftPerformanceRequestBasis;
   functionalProofModelHash: string;
   kind: "performance-iteration";
   lifecycle: ToolcraftDeliveryLifecycleState;
@@ -98,7 +92,7 @@ export type PerformanceIterationPlan = Readonly<{
   requestAuthorityHash: string;
   performanceComparison: ToolcraftDeliveryPerformanceComparison;
   steps: readonly [
-    ...ToolcraftFunctionalProofStep[],
+    Readonly<{ kind: "build" }>,
     ToolcraftBrowserPerformanceProofStep,
   ];
 }>;
@@ -111,20 +105,14 @@ export type ToolcraftDeliveryPlanningInputs = Readonly<{
   allProductTestFiles: readonly string[];
   authority: ToolcraftPerformanceRequestAuthority | null;
   catalog: ToolcraftDeliveryCatalog;
-  changeSet: Readonly<{
-    dependencyChanged: boolean;
-    docsChanged: boolean;
-    frameworkChanged: boolean;
-    impact: ToolcraftVerificationImpact | null;
-    platformChanged: boolean;
-    productInputsChanged: boolean;
-  }>;
-  comparisonInventory: ToolcraftVerificationInventory | null;
   currentFunctionalProofModel: ToolcraftFunctionalProofModel;
   currentInventory: ToolcraftVerificationInventory;
+  initialProof: Readonly<{
+    functionalProofModelHash: string;
+    sourceHash: string;
+  }> | null;
   integrity: Readonly<{ manifestHash: string; sourceHash: string }>;
   packageManager: ToolcraftPackageManager;
-  previousFunctionalProofModel: ToolcraftFunctionalProofModel | null;
   previousLifecycle: ToolcraftDeliveryLifecycleState;
   previousPerformance:
     | Readonly<{ kind: "none" }>
@@ -136,7 +124,7 @@ export type ToolcraftDeliveryPlanningInputs = Readonly<{
       }>;
 }>;
 
-export const TOOLCRAFT_DELIVERY_PLAN_VERSION: 4;
+export const TOOLCRAFT_DELIVERY_PLAN_VERSION: 6;
 
 export function createToolcraftDeliveryPlan(
   inputs: ToolcraftDeliveryPlanningInputs,
@@ -152,4 +140,4 @@ export function createToolcraftDeliveryPlanHash(
 
 export function getToolcraftDeliveryDiagnosticTier(
   plan: ToolcraftDeliveryPlan,
-): 0 | 1 | 2 | 3 | 4;
+): 3 | 4;