@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -11,7 +11,7 @@ import type {
   ToolcraftFunctionalProofModel,
 } from "./toolcraft-functional-proof-model.mjs";
 
-export const TOOLCRAFT_DELIVERY_RECEIPT_VERSION: 7;
+export const TOOLCRAFT_DELIVERY_RECEIPT_VERSION: 8;
 
 export type ToolcraftResolvedTestEvidence = Readonly<{
   fullTitle: string;
@@ -19,7 +19,6 @@ export type ToolcraftResolvedTestEvidence = Readonly<{
 }>;
 
 export type ToolcraftDeliveryStepEvidence =
-  | Readonly<{ kind: "dependencies"; packageManager: "npm" | "pnpm" | "yarn" | "bun" }>
   | Readonly<{ kind: "docs" }>
   | Readonly<{ kind: "code-health" }>
   | Readonly<{ kind: "product-tests"; files: readonly string[] }>
@@ -49,12 +48,12 @@ export type ToolcraftDeliveryReceipt = Readonly<{
   files: readonly ToolcraftVerificationInventoryEntry[];
   functionalProofModel: ToolcraftFunctionalProofModel;
   functionalProofModelHash: string;
-  kind: "delivery-verification";
+  kind: "delivery-verification" | "targeted-performance-verification";
   manifestHash: string;
   mode?: never;
   plan: ToolcraftDeliveryPlan;
   planHash: string;
-  planVersion: 4;
+  planVersion: 6;
   runner: "protected-delivery";
   sourceHash: string;
   status: "passed";
@@ -78,6 +77,5 @@ export function readToolcraftDeliveryReceipt(rootDir: string): Promise<{
 }>;
 
 export function validateToolcraftDeliveryReceipt(options: {
-  collectInventory?: (rootDir: string) => Promise<ToolcraftVerificationInventory>;
   rootDir: string;
 }): Promise<string[]>;

package/templates/starter/scripts/toolcraft-delivery-receipt.mjs

@@ -12,12 +12,10 @@ import {
 } from "./toolcraft-functional-proof-model.mjs";
 import { readToolcraftCheckpointBundle } from "./toolcraft-checkpoint-bundle.mjs";
 import {
-  collectToolcraftVerificationInputs,
-  getToolcraftChangedVerificationFiles,
   getToolcraftVerificationInventoryError,
 } from "./toolcraft-verification-inventory.mjs";
 
-export const TOOLCRAFT_DELIVERY_RECEIPT_VERSION = 7;
+export const TOOLCRAFT_DELIVERY_RECEIPT_VERSION = 8;
 
 const receiptKeys = Object.freeze([
   "completedAt",
@@ -57,15 +55,6 @@ function hasExactKeys(value, expected) {
   );
 }
 
-function arraysEqual(left, right) {
-  return (
-    Array.isArray(left) &&
-    Array.isArray(right) &&
-    left.length === right.length &&
-    left.every((item, index) => item === right[index])
-  );
-}
-
 function deepFreeze(value) {
   if (value && typeof value === "object" && !Object.isFrozen(value)) {
     Object.values(value).forEach(deepFreeze);
@@ -77,7 +66,10 @@ function deepFreeze(value) {
 function getCurrentReceiptCommonError(receipt) {
   if (
     !hasExactKeys(receipt, receiptKeys) ||
-    receipt.kind !== "delivery-verification" ||
+    ![
+      "delivery-verification",
+      "targeted-performance-verification",
+    ].includes(receipt.kind) ||
     receipt.runner !== "protected-delivery" ||
     receipt.status !== "passed" ||
     receipt.version !== TOOLCRAFT_DELIVERY_RECEIPT_VERSION ||
@@ -104,6 +96,12 @@ export function getToolcraftDeliveryReceiptShapeError(receipt) {
   const functionalProofModel = deepFreeze(receipt.functionalProofModel);
   const planError = getToolcraftDeliveryPlanError(plan);
   if (planError) return planError;
+  const expectedKind = plan.kind === "functional"
+    ? "delivery-verification"
+    : "targeted-performance-verification";
+  if (receipt.kind !== expectedKind) {
+    return "Toolcraft protected receipt kind does not match its plan.";
+  }
   const modelError =
     getToolcraftFunctionalProofModelError(functionalProofModel);
   if (modelError) {
@@ -125,18 +123,6 @@ export function getToolcraftDeliveryReceiptShapeError(receipt) {
   if (createToolcraftDeliveryPlanHash(plan) !== receipt.planHash) {
     return "Toolcraft delivery receipt plan hash does not match its plan.";
   }
-  if (
-    plan.basis.kind === "changed" &&
-    !arraysEqual(
-      plan.basis.changedFiles,
-      getToolcraftChangedVerificationFiles(
-        plan.basis.comparisonInventory.entries,
-        receipt.files,
-      ),
-    )
-  ) {
-    return "Toolcraft delivery receipt changed files do not exactly match its inventories.";
-  }
   return getToolcraftExecutionEvidenceError({
     evidence: receipt.evidence,
     finalInventory: {
@@ -179,7 +165,9 @@ export function createToolcraftDeliveryReceipt({
     files: result?.finalInventory?.entries,
     functionalProofModel,
     functionalProofModelHash,
-    kind: "delivery-verification",
+    kind: plan.kind === "functional"
+      ? "delivery-verification"
+      : "targeted-performance-verification",
     manifestHash: plan.manifestHash,
     plan,
     planHash,
@@ -203,14 +191,10 @@ export async function readToolcraftDeliveryReceipt(rootDir) {
 }
 
 export async function validateToolcraftDeliveryReceipt({
-  collectInventory = collectToolcraftVerificationInputs,
   rootDir,
 }) {
   const loaded = await readToolcraftDeliveryReceipt(rootDir);
   if (loaded.missing) return ["Toolcraft delivery receipt is missing."];
   if (loaded.error) return [loaded.error];
-  const inventory = await collectInventory(rootDir);
-  return loaded.receipt.sourceHash === inventory.sourceHash
-    ? []
-    : ["Toolcraft delivery receipt is stale for the current source."];
+  return [];
 }

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

@@ -24,7 +24,7 @@ function assertDeeplyFrozen(value) {
   Object.values(value).forEach(assertDeeplyFrozen);
 }
 
-test("constructs the exact deeply frozen version 7 receipt", () => {
+test("constructs the exact deeply frozen version 8 receipt", () => {
   const { functionalProofModel, plan, result } = createPlanReceiptFixture();
   const receipt = createToolcraftDeliveryReceipt({
     functionalProofModel,
@@ -32,9 +32,9 @@ test("constructs the exact deeply frozen version 7 receipt", () => {
     result,
   });
 
-  assert.equal(TOOLCRAFT_DELIVERY_RECEIPT_VERSION, 7);
-  assert.equal(receipt.planVersion, 4);
-  assert.equal(receipt.version, 7);
+  assert.equal(TOOLCRAFT_DELIVERY_RECEIPT_VERSION, 8);
+  assert.equal(receipt.planVersion, 6);
+  assert.equal(receipt.version, 8);
   assert.deepEqual(Object.keys(receipt).sort(), [
     "completedAt",
     "evidence",
@@ -74,22 +74,40 @@ test("constructs initial functional proof with exact browser evidence", () => {
   );
 });
 
-test("rejects obsolete receipt 6 and plan 3 identities", () => {
+test("receipt creation rejects an initial plan with an empty runtime selection", () => {
+  const fixture = createPlanReceiptFixture("functional-initial");
+  const plan = structuredClone(fixture.plan);
+  plan.steps.find(({ kind }) => kind === "product-tests").acceptanceIds = [];
+  const freeze = (value) => {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+      Object.values(value).forEach(freeze);
+      Object.freeze(value);
+    }
+    return value;
+  };
+
+  assert.throws(
+    () => createToolcraftDeliveryReceipt({ ...fixture, plan: freeze(plan) }),
+    /complete product-test selection/iu,
+  );
+});
+
+test("rejects obsolete receipt 7 and plan 5 identities", () => {
   const receipt = createToolcraftDeliveryReceipt(
-    createPlanReceiptFixture("functional-changed"),
+    createPlanReceiptFixture("functional-initial"),
   );
 
   assert.match(
-    getToolcraftDeliveryReceiptShapeError({ ...receipt, version: 6 }),
+    getToolcraftDeliveryReceiptShapeError({ ...receipt, version: 7 }),
     /malformed|unsupported/iu,
   );
   assert.match(
-    getToolcraftDeliveryReceiptShapeError({ ...receipt, planVersion: 3 }),
+    getToolcraftDeliveryReceiptShapeError({ ...receipt, planVersion: 5 }),
     /malformed|unsupported/iu,
   );
 });
 
-test("validates only the current receipt source and ignores full-performance state", async (t) => {
+test("validates historical initial proof without requiring later source freshness", async (t) => {
   const rootDir = await createReceiptFixture();
   t.after(() => fs.rm(rootDir, { force: true, recursive: true }));
   const { functionalProofModel, plan, result } = createPlanReceiptFixture();
@@ -106,17 +124,7 @@ test("validates only the current receipt source and ignores full-performance sta
   bundle.performanceBaseline = { malformed: true };
   await fs.writeFile(bundlePath, `${JSON.stringify(bundle)}\n`);
 
-  assert.deepEqual(await validateToolcraftDeliveryReceipt({
-    collectInventory: async () => result.finalInventory,
-    rootDir,
-  }), []);
-  assert.deepEqual(await validateToolcraftDeliveryReceipt({
-    collectInventory: async () => ({
-      ...result.finalInventory,
-      sourceHash: "0".repeat(64),
-    }),
-    rootDir,
-  }), ["Toolcraft delivery receipt is stale for the current source."]);
+  assert.deepEqual(await validateToolcraftDeliveryReceipt({ rootDir }), []);
 });
 
 test("rejects a different valid model and every model/hash tamper", () => {

package/templates/starter/scripts/toolcraft-delivery-receipt.types.test.mts

@@ -18,23 +18,12 @@ import type {
 } from "./toolcraft-functional-proof-model.mjs";
 
 const files = [{ path: "src/app/app-schema.ts", sha256: "a".repeat(64) }];
-const comparisonFiles = [
-  { path: "src/app/app-schema.ts", sha256: "b".repeat(64) },
-];
 const lifecycle: ToolcraftDeliveryLifecycleState = {
   consumedPerformanceRequestAuthorityHashes: ["e".repeat(64)],
   performanceEscalationOffered: true,
 };
 const plan: ToolcraftDeliveryPlan = {
-  basis: {
-    changedFiles: ["src/app/app-schema.ts"],
-    comparisonFunctionalProofModelHash: "f".repeat(64),
-    comparisonInventory: {
-      entries: comparisonFiles,
-      sourceHash: "b".repeat(64),
-    },
-    kind: "changed",
-  },
+  basis: { kind: "initial" },
   functionalProofModelHash: "f".repeat(64),
   kind: "functional",
   lifecycle,
@@ -53,12 +42,7 @@ const functionalProofModel: ToolcraftFunctionalProofModel = {
     file: "app-controls.spec.ts",
     testName: "browser: focused acceptance",
   }],
-  owners: [{
-    acceptanceIds: ["canvas.focused"],
-    kind: "functional",
-    path: "src/app/app-schema.ts",
-  }],
-  version: 1,
+  version: 2,
 };
 const receipt: ToolcraftDeliveryReceipt = {
   completedAt: "2026-07-24T00:00:00.000Z",
@@ -70,11 +54,11 @@ const receipt: ToolcraftDeliveryReceipt = {
   manifestHash: plan.manifestHash,
   plan,
   planHash: "d".repeat(64),
-  planVersion: 4,
+  planVersion: 6,
   runner: "protected-delivery",
   sourceHash: plan.sourceHash,
   status: "passed",
-  version: 7,
+  version: 8,
 };
 
 const withLegacyMode = { ...receipt, mode: "ordinary" as const };
@@ -88,10 +72,10 @@ const withBaseline = {
 // @ts-expect-error Current delivery receipts cannot carry baseline linkage.
 const invalidBaseline: ToolcraftDeliveryReceipt = withBaseline;
 const withOldPlanVersion = { ...receipt, planVersion: 1 as const };
-// @ts-expect-error Current delivery receipts require plan version 4.
+// @ts-expect-error Current delivery receipts require plan version 6.
 const invalidPlanVersion: ToolcraftDeliveryReceipt = withOldPlanVersion;
-const withOldReceiptVersion = { ...receipt, version: 6 as const };
-// @ts-expect-error Current delivery receipts require receipt version 7.
+const withOldReceiptVersion = { ...receipt, version: 7 as const };
+// @ts-expect-error Current delivery receipts require receipt version 8.
 const invalidReceiptVersion: ToolcraftDeliveryReceipt = withOldReceiptVersion;
 const { functionalProofModel: _model, ...withoutModel } = receipt;
 // @ts-expect-error Current delivery receipts require the canonical proof model.
@@ -114,6 +98,11 @@ const invalidFunctional: FunctionalDeliveryPlan = {
 };
 const invalidIteration: PerformanceIterationPlan = {
   ...plan,
+  basis: {
+    initialFunctionalProofModelHash: "f".repeat(64),
+    initialSourceHash: "a".repeat(64),
+    kind: "performance-request",
+  },
   kind: "performance-iteration",
   performanceComparison: { kind: "none" },
   requestAuthorityHash: "e".repeat(64),
@@ -129,14 +118,17 @@ const initialPerformanceCandidate = {
   performanceComparison: { kind: "none" as const },
   requestAuthorityHash: "e".repeat(64),
   sourceHash: "a".repeat(64),
-  steps: [{
-    kind: "browser-performance" as const,
-    passIds: ["preview"],
-    pathIds: ["path"],
-    testNames: ["browser perf: path"],
-  }] as const,
+  steps: [
+    { kind: "build" as const },
+    {
+      kind: "browser-performance" as const,
+      passIds: ["preview"],
+      pathIds: ["path"],
+      testNames: ["browser perf: path"],
+    },
+  ] as const,
 };
-// @ts-expect-error Performance iterations require a changed delivery basis.
+// @ts-expect-error Performance iterations require a performance-request basis.
 const invalidInitialIteration: PerformanceIterationPlan =
   initialPerformanceCandidate;
 // @ts-expect-error Lifecycle authority history is immutable.

package/templates/starter/scripts/toolcraft-feature-verification-plan.d.mts

@@ -0,0 +1,20 @@
+export const TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION: 1;
+
+export type ToolcraftFeatureVerificationPlan = Readonly<{
+  acceptanceIds: readonly string[];
+  testNames: readonly string[];
+  version: 1;
+}>;
+
+export type ToolcraftFeatureVerificationPlanValidation = Readonly<{
+  errors: readonly string[];
+  plan?: ToolcraftFeatureVerificationPlan;
+}>;
+
+export function validateToolcraftFeatureVerificationPlan(
+  value: unknown,
+): ToolcraftFeatureVerificationPlanValidation;
+
+export function parseToolcraftFeatureVerificationPlanOutput(
+  output: unknown,
+): ToolcraftFeatureVerificationPlan;

package/templates/starter/scripts/toolcraft-feature-verification-plan.mjs

@@ -0,0 +1,146 @@
+export const TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION = 1;
+
+const compareCodeUnits = (left, right) =>
+  left < right ? -1 : left > right ? 1 : 0;
+
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function getExactKeyErrors(value, expected, label) {
+  if (!isPlainObject(value)) return [`${label} must be a plain object.`];
+  const expectedSet = new Set(expected);
+  const ownKeys = Reflect.ownKeys(value);
+  const unknown = ownKeys
+    .filter((key) => typeof key !== "string" || !expectedSet.has(key))
+    .map(String)
+    .sort(compareCodeUnits);
+  const missing = expected.filter(
+    (key) => !Object.prototype.hasOwnProperty.call(value, key),
+  );
+  return [
+    ...(unknown.length > 0
+      ? [`${label} contains unknown fields: ${unknown.join(", ")}.`]
+      : []),
+    ...(missing.length > 0
+      ? [`${label} is missing required fields: ${missing.join(", ")}.`]
+      : []),
+  ];
+}
+
+function validateCanonicalStringArray(value, label) {
+  if (!Array.isArray(value)) {
+    return [`Toolcraft feature verification plan.${label} must be an array.`];
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    return [
+      `Toolcraft feature verification plan.${label} contains symbol fields.`,
+    ];
+  }
+  const errors = [];
+  if (value.length === 0) {
+    errors.push(
+      `Toolcraft feature verification plan.${label} must be non-empty.`,
+    );
+  }
+  if (
+    !value.every(
+      (entry) =>
+        typeof entry === "string" &&
+        entry.length > 0 &&
+        entry.trim() === entry,
+    )
+  ) {
+    errors.push(
+      `Toolcraft feature verification plan.${label} must contain trimmed non-empty strings.`,
+    );
+  }
+  if (new Set(value).size !== value.length) {
+    errors.push(
+      `Toolcraft feature verification plan.${label} must contain unique values.`,
+    );
+  }
+  if (
+    value.every((entry) => typeof entry === "string") &&
+    value.some((entry, index) => entry !== [...value].sort(compareCodeUnits)[index])
+  ) {
+    errors.push(
+      `Toolcraft feature verification plan.${label} must be sorted by code unit.`,
+    );
+  }
+  return errors;
+}
+
+export function validateToolcraftFeatureVerificationPlan(value) {
+  const errors = getExactKeyErrors(
+    value,
+    ["acceptanceIds", "testNames", "version"],
+    "Toolcraft feature verification plan",
+  );
+  if (!isPlainObject(value)) return { errors };
+
+  if (value.version !== TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION) {
+    errors.push(
+      `Toolcraft feature verification plan.version must be ${TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION}.`,
+    );
+  }
+  errors.push(
+    ...validateCanonicalStringArray(value.acceptanceIds, "acceptanceIds"),
+    ...validateCanonicalStringArray(value.testNames, "testNames"),
+  );
+  if (
+    Array.isArray(value.acceptanceIds) &&
+    Array.isArray(value.testNames) &&
+    value.acceptanceIds.length !== value.testNames.length
+  ) {
+    errors.push(
+      "Toolcraft feature verification plan must contain one test name per acceptance id.",
+    );
+  }
+  if (errors.length > 0) return { errors };
+
+  return {
+    errors,
+    plan: Object.freeze({
+      acceptanceIds: Object.freeze([...value.acceptanceIds]),
+      testNames: Object.freeze([...value.testNames]),
+      version: TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION,
+    }),
+  };
+}
+
+export function parseToolcraftFeatureVerificationPlanOutput(output) {
+  if (typeof output !== "string") {
+    throw new Error(
+      "Toolcraft feature verification reporter must emit exactly one JSON line.",
+    );
+  }
+  const lines = output.split(/\r?\n/u);
+  if (lines.at(-1) === "") lines.pop();
+  if (lines.length !== 1 || lines[0].length === 0) {
+    throw new Error(
+      "Toolcraft feature verification reporter must emit exactly one JSON line.",
+    );
+  }
+
+  let value;
+  try {
+    value = JSON.parse(lines[0]);
+  } catch (error) {
+    throw new Error(
+      "Toolcraft feature verification reporter must emit valid JSON.",
+      { cause: error },
+    );
+  }
+  const validation = validateToolcraftFeatureVerificationPlan(value);
+  if (validation.errors.length > 0) {
+    throw new Error(
+      `Invalid Toolcraft feature verification plan:\n${validation.errors.join("\n")}`,
+    );
+  }
+  return validation.plan;
+}

package/templates/starter/scripts/toolcraft-feature-verification-plan.test.mjs

@@ -0,0 +1,96 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION,
+  parseToolcraftFeatureVerificationPlanOutput,
+  validateToolcraftFeatureVerificationPlan,
+} from "./toolcraft-feature-verification-plan.mjs";
+
+const validPlan = () => ({
+  acceptanceIds: ["lighting.intensity", "material.layer"],
+  testNames: ["browser: lighting.intensity", "browser: material.layer"],
+  version: 1,
+});
+
+test("normalizes a canonical deeply frozen feature verification plan", () => {
+  const validation = validateToolcraftFeatureVerificationPlan(validPlan());
+
+  assert.deepEqual(validation.errors, []);
+  assert.deepEqual(validation.plan, validPlan());
+  assert.equal(TOOLCRAFT_FEATURE_VERIFICATION_PLAN_VERSION, 1);
+  assert.equal(Object.isFrozen(validation.plan), true);
+  assert.equal(Object.isFrozen(validation.plan.acceptanceIds), true);
+  assert.equal(Object.isFrozen(validation.plan.testNames), true);
+});
+
+test("rejects malformed top-level plan shapes", () => {
+  for (const [value, pattern] of [
+    [null, /must be a plain object/iu],
+    [Object.create({ version: 1 }), /must be a plain object/iu],
+    [{ ...validPlan(), extra: true }, /unknown fields: extra/iu],
+    [{ acceptanceIds: [], testNames: [] }, /missing required fields: version/iu],
+    [{ ...validPlan(), version: 2 }, /version must be 1/iu],
+  ]) {
+    assert.match(
+      validateToolcraftFeatureVerificationPlan(value).errors.join("\n"),
+      pattern,
+    );
+  }
+});
+
+test("rejects empty, untrimmed, duplicate, and noncanonical arrays", () => {
+  const symbolArray = ["material.layer"];
+  symbolArray[Symbol("hidden")] = true;
+  for (const [value, pattern] of [
+    [{ ...validPlan(), acceptanceIds: [] }, /acceptanceIds must be non-empty/iu],
+    [{ ...validPlan(), testNames: [] }, /testNames must be non-empty/iu],
+    [
+      { ...validPlan(), acceptanceIds: ["material.layer", "material.layer"] },
+      /acceptanceIds must contain unique/iu,
+    ],
+    [
+      { ...validPlan(), testNames: ["browser: layer", "browser: layer"] },
+      /testNames must contain unique/iu,
+    ],
+    [
+      { ...validPlan(), acceptanceIds: [" material.layer"] },
+      /acceptanceIds must contain trimmed/iu,
+    ],
+    [
+      { ...validPlan(), testNames: ["browser: layer "] },
+      /testNames must contain trimmed/iu,
+    ],
+    [
+      { ...validPlan(), acceptanceIds: ["material.layer", "lighting.intensity"] },
+      /acceptanceIds must be sorted/iu,
+    ],
+    [{ ...validPlan(), acceptanceIds: symbolArray }, /symbol fields/iu],
+  ]) {
+    assert.match(
+      validateToolcraftFeatureVerificationPlan(value).errors.join("\n"),
+      pattern,
+    );
+  }
+});
+
+test("parses exactly one JSON plan line", () => {
+  assert.deepEqual(
+    parseToolcraftFeatureVerificationPlanOutput(`${JSON.stringify(validPlan())}\n`),
+    validPlan(),
+  );
+  for (const [output, pattern] of [
+    ["", /exactly one JSON line/iu],
+    ["not-json\n", /valid JSON/iu],
+    [
+      `${JSON.stringify(validPlan())}\n${JSON.stringify(validPlan())}\n`,
+      /exactly one JSON line/iu,
+    ],
+    [JSON.stringify({ ...validPlan(), version: 2 }), /version must be 1/iu],
+  ]) {
+    assert.throws(
+      () => parseToolcraftFeatureVerificationPlanOutput(output),
+      pattern,
+    );
+  }
+});

package/templates/starter/scripts/toolcraft-functional-proof-model.d.mts

@@ -1,8 +1,6 @@
 import type {
   ToolcraftDeliveryCatalog,
-  ToolcraftVerificationImpactInventory,
-  ToolcraftVerificationImpactOwner,
-} from "./toolcraft-verification-impact-inventory.mjs";
+} from "./playwright-test-title-selection.mjs";
 
 export type ToolcraftFunctionalProofAcceptance = Readonly<{
   acceptanceId: string;
@@ -12,16 +10,12 @@ export type ToolcraftFunctionalProofAcceptance = Readonly<{
   testName: string;
 }>;
 
-export type ToolcraftFunctionalProofOwner =
-  ToolcraftVerificationImpactOwner;
-
 export type ToolcraftFunctionalProofModel = Readonly<{
   acceptance: readonly ToolcraftFunctionalProofAcceptance[];
-  owners: readonly ToolcraftFunctionalProofOwner[];
-  version: 1;
+  version: 2;
 }>;
 
-export const TOOLCRAFT_FUNCTIONAL_PROOF_MODEL_VERSION: 1;
+export const TOOLCRAFT_FUNCTIONAL_PROOF_MODEL_VERSION: 2;
 
 export {
   createToolcraftAcceptanceContractHash,
@@ -29,7 +23,6 @@ export {
 } from "./toolcraft-functional-proof-primitives.mjs";
 export function createToolcraftFunctionalProofModel(input: {
   catalog: ToolcraftDeliveryCatalog;
-  inventory: ToolcraftVerificationImpactInventory;
 }): ToolcraftFunctionalProofModel;
 export function createToolcraftFunctionalProofModelHash(
   model: ToolcraftFunctionalProofModel,
@@ -37,11 +30,3 @@ export function createToolcraftFunctionalProofModelHash(
 export function getToolcraftFunctionalProofModelError(
   value: unknown,
 ): string | undefined;
-export function diffToolcraftFunctionalProofModels(input: {
-  current: ToolcraftFunctionalProofModel;
-  previous: ToolcraftFunctionalProofModel;
-}): Readonly<{
-  acceptanceIds: readonly string[];
-  changedOwnerPaths: readonly string[];
-  removedAcceptanceIds: readonly string[];
-}>;