@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-delivery-executor.test.mjs

@@ -45,9 +45,6 @@ function deferred() {
 }
 
 function createScheduledPlan() {
-  const comparisonInventory = createInventory({
-    "src/app/app-schema.ts": hash("1"),
-  });
   const finalInventory = createInventory({
     "src/app/app-schema.ts": hash("2"),
   });
@@ -57,12 +54,7 @@ function createScheduledPlan() {
   return {
     finalInventory,
     plan: freeze({
-      basis: {
-        changedFiles: ["src/app/app-schema.ts"],
-        comparisonFunctionalProofModelHash: functionalProofModelHash,
-        comparisonInventory,
-        kind: "changed",
-      },
+      basis: { kind: "initial" },
       functionalProofModelHash,
       kind: "functional",
       lifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
@@ -72,6 +64,7 @@ function createScheduledPlan() {
         { kind: "docs" },
         { kind: "code-health" },
         {
+          acceptanceIds: null,
           files: ["src/app/app-schema.test.ts"],
           kind: "product-tests",
         },
@@ -334,7 +327,7 @@ test("parallel failure waits for every sibling and reports canonical step order"
 });
 
 test("requires a deeply frozen plan and explicit frozen operations", async () => {
-  const { plan, result } = createPlanReceiptFixture("functional-changed");
+  const { plan, result } = createPlanReceiptFixture("functional-initial");
   await assert.rejects(
     executeToolcraftDeliveryPlanCore({
       operations: {},
@@ -357,7 +350,7 @@ test("requires a deeply frozen plan and explicit frozen operations", async () =>
 
 test("same-process authority reserves one exact receipt", async () => {
   const { functionalProofModel, plan, result } =
-    createPlanReceiptFixture("functional-changed");
+    createPlanReceiptFixture("functional-initial");
   const projectDir = path.resolve("/workspace/app");
   const registry = createToolcraftPlanExecutionAuthorityRegistry(async () =>
     freeze(structuredClone(result)),
@@ -397,7 +390,7 @@ test("same-process authority reserves one exact receipt", async () => {
 
 test("same-process authority rejects forged, cross-project, and released bindings", async () => {
   const { functionalProofModel, plan, result } =
-    createPlanReceiptFixture("functional-changed");
+    createPlanReceiptFixture("functional-initial");
   const projectDir = path.resolve("/workspace/app");
   const registry = createToolcraftPlanExecutionAuthorityRegistry(async () =>
     freeze(structuredClone(result)),

package/templates/starter/scripts/toolcraft-delivery-functional-context.d.mts

@@ -3,40 +3,11 @@ import type {
 } from "./toolcraft-functional-proof-model.mjs";
 import type {
   ToolcraftDeliveryCatalog,
-  ToolcraftVerificationImpactInventory,
-} from "./toolcraft-verification-impact-inventory.mjs";
-import type {
-  ToolcraftVerificationInputRoles,
-} from "./toolcraft-verification-input-roles.mjs";
+} from "./playwright-test-title-selection.mjs";
 
 export type ToolcraftDeliveryFunctionalContext = Readonly<{
   catalog: ToolcraftDeliveryCatalog;
   currentFunctionalProofModel: ToolcraftFunctionalProofModel;
-  frameworkOwnedPaths: readonly string[];
-  graph: Readonly<{
-    entries: readonly Readonly<{
-      absolutePath: string;
-      owner: "framework" | "platform" | "product";
-      repoPath: string;
-      role: "generated" | "production" | "test" | "test-support";
-    }>[];
-    forward: ReadonlyMap<string, readonly string[]>;
-    reverse: ReadonlyMap<string, readonly string[]>;
-  }>;
-  inputRoles: ToolcraftVerificationInputRoles;
-  sourceInventory: Readonly<{
-    entries: readonly Readonly<{
-      absolutePath: string;
-      owner: "framework" | "platform" | "product";
-      repoPath: string;
-      role: "generated" | "production" | "test" | "test-support";
-    }>[];
-    filesystemViolations: readonly Readonly<{
-      reason: string;
-      repoPath: string;
-    }>[];
-  }>;
-  verificationImpactInventory: ToolcraftVerificationImpactInventory;
 }>;
 
 export function collectToolcraftDeliveryFunctionalContextCore(options: {
@@ -44,25 +15,7 @@ export function collectToolcraftDeliveryFunctionalContextCore(options: {
     collectCatalog(rootDir: string): Promise<ToolcraftDeliveryCatalog>;
     createFunctionalProofModel(input: {
       catalog: ToolcraftDeliveryCatalog;
-      inventory: ToolcraftVerificationImpactInventory;
     }): ToolcraftFunctionalProofModel;
-    createVerificationContext(rootDir: string): Promise<Readonly<{
-      frameworkOwnedPaths:
-        ToolcraftDeliveryFunctionalContext["frameworkOwnedPaths"];
-      graph: ToolcraftDeliveryFunctionalContext["graph"];
-      inputRoles: ToolcraftVerificationInputRoles;
-      sourceInventory: ToolcraftDeliveryFunctionalContext["sourceInventory"];
-    }>>;
-    readImpactInventory(
-      rootDir: string,
-      options: {
-        catalog: ToolcraftDeliveryCatalog;
-        inputRoles: ToolcraftVerificationInputRoles;
-      },
-    ): Promise<Readonly<{
-      inventory: ToolcraftVerificationImpactInventory;
-      path: string;
-    }>>;
   }>;
   projectDir: string;
 }): Promise<ToolcraftDeliveryFunctionalContext>;

package/templates/starter/scripts/toolcraft-delivery-functional-context.mjs

@@ -4,16 +4,10 @@ import {
 import {
   createToolcraftFunctionalProofModel,
 } from "./toolcraft-functional-proof-model.mjs";
-import {
-  createToolcraftProductVerificationContext,
-  readToolcraftVerificationImpactInventory,
-} from "./toolcraft-verification-impact.mjs";
 
 const defaultDependencies = Object.freeze({
   collectCatalog: collectToolcraftDeliveryCatalog,
   createFunctionalProofModel: createToolcraftFunctionalProofModel,
-  createVerificationContext: createToolcraftProductVerificationContext,
-  readImpactInventory: readToolcraftVerificationImpactInventory,
 });
 
 export async function collectToolcraftDeliveryFunctionalContextCore({
@@ -21,31 +15,9 @@ export async function collectToolcraftDeliveryFunctionalContextCore({
   projectDir,
 }) {
   const catalog = await dependencies.collectCatalog(projectDir);
-  const {
-    frameworkOwnedPaths,
-    graph,
-    inputRoles,
-    sourceInventory,
-  } = await dependencies.createVerificationContext(projectDir);
-  const { inventory: verificationImpactInventory } =
-    await dependencies.readImpactInventory(projectDir, {
-      catalog,
-      inputRoles,
-    });
   const currentFunctionalProofModel =
-    dependencies.createFunctionalProofModel({
-      catalog,
-      inventory: verificationImpactInventory,
-    });
-  return Object.freeze({
-    catalog,
-    currentFunctionalProofModel,
-    frameworkOwnedPaths,
-    graph,
-    inputRoles,
-    sourceInventory,
-    verificationImpactInventory,
-  });
+    dependencies.createFunctionalProofModel({ catalog });
+  return Object.freeze({ catalog, currentFunctionalProofModel });
 }
 
 export function collectToolcraftDeliveryFunctionalContext(projectDir) {

package/templates/starter/scripts/toolcraft-delivery-functional-context.test.mjs

@@ -6,70 +6,23 @@ import {
   collectToolcraftDeliveryFunctionalContextCore,
 } from "./toolcraft-delivery-functional-context.mjs";
 import {
-  createToolcraftFunctionalProofModelHash,
   getToolcraftFunctionalProofModelError,
 } from "./toolcraft-functional-proof-model.mjs";
-import {
-  loadToolcraftDeliveryPlanningInputs,
-} from "./toolcraft-delivery-lifecycle.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftVerificationSourceHash,
-} from "./toolcraft-verification-inventory.mjs";
-import {
-  toolcraftVerificationInputRootFamilies,
-} from "./toolcraft-verification-input-roles.mjs";
 import {
   createDeliveryFixture,
   removeDeliveryFixture,
 } from "./run-delivery-verification-test-helpers.mjs";
 
-test("functional context collects each changed-state authority exactly once", async () => {
-  const calls = {
-    catalog: 0,
-    context: 0,
-    inventory: 0,
-    model: 0,
-  };
+test("functional context collects the canonical catalog once", async () => {
+  const calls = { catalog: 0, model: 0 };
   const catalog = Object.freeze({
     acceptance: Object.freeze([]),
     performance: Object.freeze([]),
     version: 2,
   });
-  const graph = Object.freeze({
-    entries: Object.freeze([]),
-    forward: new Map(),
-    reverse: new Map(),
-  });
-  const frameworkOwnedPaths = Object.freeze([
-    "src/toolcraft/runtime.ts",
-  ]);
-  const inputRoles = Object.freeze({
-    impactInventoryPath: "src/app/app-verification-impact.json",
-    productResourcePaths: Object.freeze([]),
-    productTestPaths: Object.freeze([]),
-    proofModelPaths: Object.freeze([]),
-    roleByPath: Object.freeze({}),
-    rootFamily: "generated",
-    runtimeProductionPaths: Object.freeze([]),
-    semanticProofRootPaths:
-      toolcraftVerificationInputRootFamilies.generated
-        .semanticProofRootPaths,
-  });
-  const sourceInventory = Object.freeze({
-    entries: Object.freeze([]),
-    filesystemViolations: Object.freeze([]),
-  });
-  const inventory = Object.freeze({
-    owners: Object.freeze([]),
-    version: 3,
-  });
   const currentFunctionalProofModel = Object.freeze({
     acceptance: Object.freeze([]),
-    owners: Object.freeze([]),
-    version: 1,
+    version: 2,
   });
 
   const context = await collectToolcraftDeliveryFunctionalContextCore({
@@ -81,50 +34,19 @@ test("functional context collects each changed-state authority exactly once", as
       createFunctionalProofModel: (input) => {
         calls.model += 1;
         assert.equal(input.catalog, catalog);
-        assert.equal(input.inventory, inventory);
         return currentFunctionalProofModel;
       },
-      createVerificationContext: async () => {
-        calls.context += 1;
-        return {
-          frameworkOwnedPaths,
-          graph,
-          inputRoles,
-          sourceInventory,
-        };
-      },
-      readImpactInventory: async (_projectDir, options) => {
-        calls.inventory += 1;
-        assert.equal(options.catalog, catalog);
-        assert.equal(options.inputRoles, inputRoles);
-        return { inventory, path: "/tmp/app-verification-impact.json" };
-      },
     }),
     projectDir: "/tmp/toolcraft-functional-context",
   });
 
-  assert.deepEqual(calls, {
-    catalog: 1,
-    context: 1,
-    inventory: 1,
-    model: 1,
-  });
+  assert.deepEqual(calls, { catalog: 1, model: 1 });
   assert.deepEqual(Object.keys(context), [
     "catalog",
     "currentFunctionalProofModel",
-    "frameworkOwnedPaths",
-    "graph",
-    "inputRoles",
-    "sourceInventory",
-    "verificationImpactInventory",
   ]);
   assert.equal(context.catalog, catalog);
   assert.equal(context.currentFunctionalProofModel, currentFunctionalProofModel);
-  assert.equal(context.frameworkOwnedPaths, frameworkOwnedPaths);
-  assert.equal(context.graph, graph);
-  assert.equal(context.inputRoles, inputRoles);
-  assert.equal(context.sourceInventory, sourceInventory);
-  assert.equal(context.verificationImpactInventory, inventory);
   assert.equal(Object.isFrozen(context), true);
 });
 
@@ -144,88 +66,4 @@ test("public functional context builds one valid canonical model", async (t) =>
     context.currentFunctionalProofModel.acceptance,
     context.catalog.acceptance,
   );
-  assert.equal(context.verificationImpactInventory.version, 3);
-  assert.equal(context.inputRoles.rootFamily, "generated");
-  assert.equal(
-    context.sourceInventory.entries.length,
-    context.graph.entries.length,
-  );
-});
-
-test("changed-file classification reuses the immutable context ownership snapshot", async (t) => {
-  const rootDir = createDeliveryFixture();
-  t.after(() => removeDeliveryFixture(rootDir));
-  const frameworkOwnedPaths = Object.freeze([
-    "src/app/framework-owned.ts",
-  ]);
-  const model = Object.freeze({
-    acceptance: Object.freeze([]),
-    owners: Object.freeze([]),
-    version: 1,
-  });
-  const catalog = Object.freeze({
-    acceptance: Object.freeze([]),
-    performance: Object.freeze([]),
-    version: 2,
-  });
-  const previousEntries = Object.freeze([Object.freeze({
-    path: frameworkOwnedPaths[0],
-    sha256: "1".repeat(64),
-  })]);
-  const currentEntries = Object.freeze([Object.freeze({
-    path: frameworkOwnedPaths[0],
-    sha256: "2".repeat(64),
-  })]);
-  const currentInventory = Object.freeze({
-    entries: currentEntries,
-    sourceHash: createToolcraftVerificationSourceHash(currentEntries),
-  });
-  const functionalContext = Object.freeze({
-    catalog,
-    currentFunctionalProofModel: model,
-    frameworkOwnedPaths,
-    graph: Object.freeze({
-      entries: Object.freeze([]),
-      forward: new Map(),
-      reverse: new Map(),
-    }),
-    inputRoles: Object.freeze({
-      roleByPath: Object.freeze({}),
-    }),
-  });
-
-  const inputs = await loadToolcraftDeliveryPlanningInputs({
-    currentInventory,
-    functionalContext,
-    integrity: Object.freeze({
-      manifestHash: "a".repeat(64),
-      sourceHash: currentInventory.sourceHash,
-    }),
-    previous: {
-      anchor: {
-        files: previousEntries,
-        functionalProofModel: model,
-        functionalProofModelHash:
-          createToolcraftFunctionalProofModelHash(model),
-        lifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-        performance: { kind: "none" },
-        sourceHash:
-          createToolcraftVerificationSourceHash(previousEntries),
-      },
-      receipt: { version: 7 },
-    },
-    projectDir: rootDir,
-  });
-
-  assert.equal(
-    functionalContext.frameworkOwnedPaths,
-    frameworkOwnedPaths,
-  );
-  assert.equal(inputs.changeSet.frameworkChanged, true);
-  assert.equal(inputs.changeSet.platformChanged, false);
-  assert.equal(inputs.changeSet.productInputsChanged, false);
-  assert.throws(
-    () => frameworkOwnedPaths.push("src/app/forged.ts"),
-    /read only|readonly|extensible|frozen/iu,
-  );
 });

package/templates/starter/scripts/toolcraft-delivery-functional-initial.test.mjs

@@ -35,14 +35,6 @@ const catalog = Object.freeze({
 
 const functionalProofModel = createToolcraftFunctionalProofModel({
   catalog,
-  inventory: {
-    owners: [{
-      acceptanceIds: ["output.updates"],
-      kind: "functional",
-      path: "src/app/schema.test.ts",
-    }],
-    version: 3,
-  },
 });
 
 function inventory(contents = "1") {
@@ -65,23 +57,14 @@ function initialInputs(currentInventory) {
     ]),
     authority: null,
     catalog,
-    changeSet: Object.freeze({
-      dependencyChanged: false,
-      docsChanged: false,
-      frameworkChanged: false,
-      impact: null,
-      platformChanged: false,
-      productInputsChanged: false,
-    }),
-    comparisonInventory: null,
     currentFunctionalProofModel: functionalProofModel,
     currentInventory,
+    initialProof: null,
     integrity: Object.freeze({
       manifestHash: hash("a"),
       sourceHash: currentInventory.sourceHash,
     }),
     packageManager: "pnpm",
-    previousFunctionalProofModel: null,
     previousLifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
     previousPerformance: Object.freeze({ kind: "none" }),
   });
@@ -114,7 +97,7 @@ function dependencies({
   return Object.freeze({
     collectInventory: async () => currentInventory,
     collectFunctionalContext: async () =>
-      Object.freeze({ currentFunctionalProofModel: functionalProofModel }),
+      Object.freeze({ catalog, currentFunctionalProofModel: functionalProofModel }),
     commit: async (value) => onCommit(value),
     createPlan: createToolcraftDeliveryPlan,
     createReceipt: createToolcraftDeliveryReceipt,
@@ -125,6 +108,7 @@ function dependencies({
     getEscalationRecommendation: () => null,
     loadPlanningInputs: async () => initialInputs(currentInventory),
     readDeliveryAnchor: async () => ({ missing: true }),
+    readPerformanceAuthority: async () => null,
   });
 }
 
@@ -144,7 +128,7 @@ test("first delivery creates one complete functional receipt", async () => {
     projectDir: "/tmp/toolcraft-functional-initial",
   });
 
-  assert.equal(receipt.version, 7);
+  assert.equal(receipt.version, 8);
   assert.equal(receipt.plan.kind, "functional");
   assert.deepEqual(receipt.plan.basis, { kind: "initial" });
   assert.deepEqual(