@pixel-point/toolcraft 0.0.17 → 0.0.19

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

@@ -1,358 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  createToolcraftDeliveryPlan,
-  createToolcraftDeliveryPlanHash,
-  getToolcraftDeliveryPlanError,
-  TOOLCRAFT_DELIVERY_PLAN_VERSION,
-} from "./toolcraft-delivery-plan.mjs";
-import {
-  createToolcraftFunctionalProofModel,
-  createToolcraftFunctionalProofModelHash,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftVerificationSourceHash,
-} from "./toolcraft-verification-inventory.mjs";
-
-const hash = (character) => character.repeat(64);
-const catalog = Object.freeze({
-  acceptance: Object.freeze([Object.freeze({
-    acceptanceId: "output.updates",
-    contractHash: hash("a"),
-    domainId: "output",
-    file: "app-output.spec.ts",
-    testName: "browser: output updates",
-  })]),
-  performance: Object.freeze([]),
-  version: 2,
-});
-
-function inventory(character) {
-  const entries = Object.freeze([Object.freeze({
-    path: "src/features/output.tsx",
-    sha256: hash(character),
-  })]);
-  return Object.freeze({
-    entries,
-    sourceHash: createToolcraftVerificationSourceHash(entries),
-  });
-}
-
-function model(ownerPath) {
-  return createToolcraftFunctionalProofModel({
-    catalog,
-    inventory: {
-      owners: [{
-        acceptanceIds: ["output.updates"],
-        kind: "functional",
-        path: ownerPath,
-      }],
-      version: 3,
-    },
-  });
-}
-
-function inputs({ initial = false } = {}) {
-  const currentInventory = inventory("2");
-  const currentFunctionalProofModel = model("src/features/output.tsx");
-  const previousFunctionalProofModel = initial
-    ? null
-    : model("src/features/previous-output.tsx");
-  return {
-    allProductTestFiles: ["src/features/output.test.tsx"],
-    authority: null,
-    catalog,
-    changeSet: {
-      dependencyChanged: false,
-      docsChanged: false,
-      frameworkChanged: false,
-      impact: initial ? null : {
-        acceptanceIds: ["output.updates"],
-        browserTestNames: ["browser: output updates"],
-        buildRequired: true,
-        performanceCandidates: {
-          passIds: [],
-          pathIds: [],
-          testNames: [],
-        },
-        productTestFiles: ["src/features/output.test.tsx"],
-      },
-      platformChanged: false,
-      productInputsChanged: !initial,
-    },
-    comparisonInventory: initial ? null : inventory("1"),
-    currentFunctionalProofModel,
-    currentInventory,
-    integrity: {
-      manifestHash: hash("f"),
-      sourceHash: currentInventory.sourceHash,
-    },
-    packageManager: "pnpm",
-    previousFunctionalProofModel,
-    previousLifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-    previousPerformance: { kind: "none" },
-  };
-}
-
-function deepFreeze(value) {
-  if (value && typeof value === "object" && !Object.isFrozen(value)) {
-    Object.values(value).forEach(deepFreeze);
-    Object.freeze(value);
-  }
-  return value;
-}
-
-test("plan v4 binds the current canonical functional proof model hash", () => {
-  const planningInputs = inputs({ initial: true });
-  const plan = createToolcraftDeliveryPlan(planningInputs);
-
-  assert.equal(TOOLCRAFT_DELIVERY_PLAN_VERSION, 4);
-  assert.equal(
-    plan.functionalProofModelHash,
-    createToolcraftFunctionalProofModelHash(
-      planningInputs.currentFunctionalProofModel,
-    ),
-  );
-  assert.match(plan.functionalProofModelHash, /^[a-f0-9]{64}$/u);
-});
-
-test("changed basis binds the immediate previous canonical model hash", () => {
-  const planningInputs = inputs();
-  const plan = createToolcraftDeliveryPlan(planningInputs);
-
-  assert.equal(
-    plan.basis.comparisonFunctionalProofModelHash,
-    createToolcraftFunctionalProofModelHash(
-      planningInputs.previousFunctionalProofModel,
-    ),
-  );
-  assert.match(
-    plan.basis.comparisonFunctionalProofModelHash,
-    /^[a-f0-9]{64}$/u,
-  );
-
-  const missing = deepFreeze({
-    ...plan,
-    basis: {
-      changedFiles: plan.basis.changedFiles,
-      comparisonInventory: plan.basis.comparisonInventory,
-      kind: "changed",
-    },
-  });
-  assert.match(
-    getToolcraftDeliveryPlanError(missing),
-    /basis|comparison.*functional proof model hash/iu,
-  );
-});
-
-test("later functional construction consumes impact.buildRequired directly", () => {
-  const planningInputs = inputs();
-  planningInputs.changeSet.impact = {
-    acceptanceIds: [],
-    browserTestNames: [],
-    buildRequired: true,
-    performanceCandidates: {
-      passIds: [],
-      pathIds: [],
-      testNames: [],
-    },
-    productTestFiles: ["src/features/output.test.tsx"],
-  };
-  const plan = createToolcraftDeliveryPlan(planningInputs);
-
-  assert.deepEqual(
-    plan.steps.map(({ kind }) => kind),
-    ["code-health", "product-tests", "build"],
-  );
-});
-
-test("functional model hashes contribute to the canonical plan hash", () => {
-  const plan = createToolcraftDeliveryPlan(inputs());
-  const changedCurrent = deepFreeze({
-    ...plan,
-    functionalProofModelHash: hash("b"),
-  });
-  const changedPrevious = deepFreeze({
-    ...plan,
-    basis: {
-      ...plan.basis,
-      comparisonFunctionalProofModelHash: hash("c"),
-    },
-  });
-
-  assert.notEqual(
-    createToolcraftDeliveryPlanHash(plan),
-    createToolcraftDeliveryPlanHash(changedCurrent),
-  );
-  assert.notEqual(
-    createToolcraftDeliveryPlanHash(plan),
-    createToolcraftDeliveryPlanHash(changedPrevious),
-  );
-});
-
-test("planning rejects missing, malformed, and mismatched model provenance", () => {
-  const initial = inputs({ initial: true });
-  assert.throws(
-    () => createToolcraftDeliveryPlan({
-      ...initial,
-      previousFunctionalProofModel: model("src/features/previous-output.tsx"),
-    }),
-    /initial.*previous functional proof model/iu,
-  );
-
-  const changed = inputs();
-  assert.throws(
-    () => createToolcraftDeliveryPlan({
-      ...changed,
-      previousFunctionalProofModel: null,
-    }),
-    /changed.*previous functional proof model/iu,
-  );
-  assert.throws(
-    () => createToolcraftDeliveryPlan({
-      ...changed,
-      currentFunctionalProofModel: structuredClone(
-        changed.currentFunctionalProofModel,
-      ),
-    }),
-    /current functional proof model/iu,
-  );
-  const mismatchedCatalog = {
-    ...catalog,
-    acceptance: [{
-      ...catalog.acceptance[0],
-      contractHash: hash("c"),
-    }],
-  };
-  const mismatchedModel = createToolcraftFunctionalProofModel({
-    catalog: mismatchedCatalog,
-    inventory: {
-      owners: [{
-        acceptanceIds: ["output.updates"],
-        kind: "functional",
-        path: "src/features/output.tsx",
-      }],
-      version: 3,
-    },
-  });
-  assert.throws(
-    () => createToolcraftDeliveryPlan({
-      ...changed,
-      currentFunctionalProofModel: mismatchedModel,
-    }),
-    /does not match the delivery catalog/iu,
-  );
-});
-
-test("plan validation rejects exotic objects before canonical hashing", () => {
-  const valid = createToolcraftDeliveryPlan(inputs());
-  const planSymbol = structuredClone(valid);
-  planSymbol[Symbol("hidden")] = true;
-  const basisSymbol = structuredClone(valid);
-  basisSymbol.basis[Symbol("hidden")] = true;
-  const stepSymbol = structuredClone(valid);
-  stepSymbol.steps[0][Symbol("hidden")] = true;
-  const exoticPlan = Object.assign(Object.create({ inherited: true }), valid);
-  const exoticBasis = structuredClone(valid);
-  exoticBasis.basis = Object.assign(
-    Object.create({ inherited: true }),
-    exoticBasis.basis,
-  );
-  const exoticStep = structuredClone(valid);
-  exoticStep.steps[0] = Object.assign(
-    Object.create({ inherited: true }),
-    exoticStep.steps[0],
-  );
-  const hiddenRequiredPlanKey = structuredClone(valid);
-  Object.defineProperty(
-    hiddenRequiredPlanKey,
-    "functionalProofModelHash",
-    { enumerable: false },
-  );
-
-  for (const candidate of [
-    planSymbol,
-    basisSymbol,
-    stepSymbol,
-    exoticPlan,
-    exoticBasis,
-    exoticStep,
-    hiddenRequiredPlanKey,
-  ]) {
-    const frozen = deepFreeze(candidate);
-    assert.equal(typeof getToolcraftDeliveryPlanError(frozen), "string");
-    assert.throws(() => createToolcraftDeliveryPlanHash(frozen));
-  }
-
-  const inputSymbol = inputs();
-  inputSymbol[Symbol("hidden")] = true;
-  assert.throws(
-    () => createToolcraftDeliveryPlan(inputSymbol),
-    /planning inputs are malformed/iu,
-  );
-  const exoticInput = Object.assign(
-    Object.create({ inherited: true }),
-    inputs(),
-  );
-  assert.throws(
-    () => createToolcraftDeliveryPlan(exoticInput),
-    /planning inputs are malformed/iu,
-  );
-});
-
-test("plan validation rejects sparse and augmented proof arrays", () => {
-  const valid = createToolcraftDeliveryPlan(inputs());
-  const sparseSteps = structuredClone(valid);
-  delete sparseSteps.steps[0];
-  const sparseTargets = structuredClone(valid);
-  const browser = sparseTargets.steps.find(
-    ({ kind }) => kind === "browser-functional",
-  );
-  browser.testNames = Array(1);
-  const augmentedSteps = structuredClone(valid);
-  augmentedSteps.steps.hidden = true;
-  const augmentedTargets = structuredClone(valid);
-  const augmentedBrowser = augmentedTargets.steps.find(
-    ({ kind }) => kind === "browser-functional",
-  );
-  augmentedBrowser.testNames.hidden = true;
-  const symbolTargets = structuredClone(valid);
-  const symbolBrowser = symbolTargets.steps.find(
-    ({ kind }) => kind === "browser-functional",
-  );
-  symbolBrowser.testNames[Symbol("hidden")] = true;
-
-  for (const candidate of [
-    sparseSteps,
-    sparseTargets,
-    augmentedSteps,
-    augmentedTargets,
-    symbolTargets,
-  ]) {
-    const frozen = deepFreeze(candidate);
-    assert.equal(typeof getToolcraftDeliveryPlanError(frozen), "string");
-    assert.throws(() => createToolcraftDeliveryPlanHash(frozen));
-  }
-});
-
-test("plan validation and hashing reject noncanonical lifecycle state", () => {
-  const valid = createToolcraftDeliveryPlan(inputs());
-  const symbolLifecycle = structuredClone(valid);
-  symbolLifecycle.lifecycle[Symbol("hidden")] = true;
-  const sparseLifecycle = structuredClone(valid);
-  sparseLifecycle.lifecycle.consumedPerformanceRequestAuthorityHashes =
-    Array(1);
-
-  for (const candidate of [symbolLifecycle, sparseLifecycle]) {
-    const frozen = deepFreeze(candidate);
-    assert.match(
-      getToolcraftDeliveryPlanError(frozen),
-      /lifecycle state is malformed or noncanonical/iu,
-    );
-    assert.throws(() => createToolcraftDeliveryPlanHash(frozen));
-  }
-});

package/templates/starter/scripts/toolcraft-functional-proof-regression-fixtures.mjs

@@ -1,298 +0,0 @@
-import {
-  validateToolcraftDeliveryCatalog,
-} from "./playwright-test-title-selection.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftFunctionalProofModel,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  toolcraftVerificationInputRootFamilies,
-} from "./toolcraft-verification-input-roles.mjs";
-import {
-  createToolcraftVerificationSourceHash,
-} from "./toolcraft-verification-inventory.mjs";
-
-const compareCodeUnits = (left, right) =>
-  left < right ? -1 : left > right ? 1 : 0;
-const hash = (character) => character.repeat(64);
-
-const materialRows = Object.freeze([
-  ["material.bake", "browser: material bake changes rendered output"],
-  ["material.color", "browser: material color changes rendered output"],
-  [
-    "material.exportedAppearance",
-    "browser: material exported appearance matches preview",
-  ],
-  [
-    "material.roughness",
-    "browser: material roughness changes rendered output",
-  ],
-  ["material.shape", "browser: material shape changes rendered output"],
-  ["material.texture", "browser: material texture changes rendered output"],
-  ["material.topping", "browser: material topping changes rendered output"],
-]);
-
-const unrelatedRows = Object.freeze([
-  [
-    "canvas.infinity",
-    "app-canvas.spec.ts",
-    "browser: infinity canvas changes viewport",
-  ],
-  [
-    "export.background",
-    "app-export.spec.ts",
-    "browser: export background changes rendered output",
-  ],
-  [
-    "export.imageFormat",
-    "app-export.spec.ts",
-    "browser: export image format changes output",
-  ],
-  [
-    "export.resolution",
-    "app-export.spec.ts",
-    "browser: export resolution changes output",
-  ],
-  [
-    "persistence.reload",
-    "app-persistence.spec.ts",
-    "browser: persistence restores workspace",
-  ],
-  [
-    "runtime.settingsTransfer",
-    "app-runtime.spec.ts",
-    "browser: runtime settings transfer preserves values",
-  ],
-  [
-    "scene.orientation",
-    "app-scene.spec.ts",
-    "browser: scene orientation changes rendered output",
-  ],
-]);
-
-const materialAcceptanceIds = Object.freeze(
-  materialRows.map(([acceptanceId]) => acceptanceId),
-);
-const materialProductTestFiles = Object.freeze([
-  "src/features/material/material-controls.test.ts",
-  "src/features/material/material-export.test.ts",
-  "src/features/material/material-renderer.test.ts",
-]);
-const changedFiles = Object.freeze([
-  "e2e/app-material.spec.ts",
-  "public/material-texture-a.png",
-  "public/material-texture-b.png",
-  "public/material-texture-c.png",
-  "src/app/app-acceptance-data.ts",
-  "src/app/app-performance.ts",
-  "src/app/app-verification-impact.json",
-  "src/features/material/material-runtime.ts",
-]);
-const performancePathId =
-  "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";
-
-function acceptanceRow([acceptanceId, file, testName], index) {
-  return {
-    acceptanceId,
-    contractHash: hash((index + 1).toString(16)),
-    domainId: acceptanceId.split(".")[0],
-    file,
-    testName,
-  };
-}
-
-function catalog(includeMaterial) {
-  const rows = [
-    ...unrelatedRows.map(acceptanceRow),
-    ...(includeMaterial
-      ? materialRows.map(([acceptanceId, testName], index) =>
-          acceptanceRow(
-            [acceptanceId, "app-material.spec.ts", testName],
-            unrelatedRows.length + index,
-          ),
-        )
-      : []),
-  ];
-  const validation = validateToolcraftDeliveryCatalog({
-    acceptance: rows,
-    performance: [{
-      passIds: ["preview-composite"],
-      pathId: performancePathId,
-      testName: `browser perf: toolcraft path ${performancePathId}`,
-    }],
-    version: 2,
-  });
-  if (validation.errors.length > 0) {
-    throw new Error(validation.errors.join("\n"));
-  }
-  return validation.catalog;
-}
-
-function currentOwners() {
-  const textureAcceptance = [
-    "material.exportedAppearance",
-    "material.texture",
-  ];
-  return [
-    {
-      acceptanceIds: textureAcceptance,
-      kind: "functional",
-      path: "public/material-texture-a.png",
-    },
-    {
-      acceptanceIds: textureAcceptance,
-      kind: "functional",
-      path: "public/material-texture-b.png",
-    },
-    {
-      acceptanceIds: textureAcceptance,
-      kind: "functional",
-      path: "public/material-texture-c.png",
-    },
-    {
-      acceptanceIds: materialAcceptanceIds,
-      kind: "performance",
-      passIds: ["preview-composite"],
-      path: "src/features/material/material-runtime.ts",
-    },
-  ];
-}
-
-function proofModel(deliveryCatalog, owners) {
-  return createToolcraftFunctionalProofModel({
-    catalog: deliveryCatalog,
-    inventory: { owners, version: 3 },
-  });
-}
-
-function inventory(characterOffset) {
-  const entries = changedFiles.map((filePath, index) => ({
-    path: filePath,
-    sha256: hash((characterOffset + index).toString(16)),
-  }));
-  return Object.freeze({
-    entries: Object.freeze(entries.map(Object.freeze)),
-    sourceHash: createToolcraftVerificationSourceHash(entries),
-  });
-}
-
-function createGraph() {
-  const runtimePath = "src/features/material/material-runtime.ts";
-  const entries = [
-    ...changedFiles.map((repoPath) => ({
-      owner: "product",
-      repoPath,
-      role: repoPath.endsWith(".spec.ts") ? "test" : "production",
-    })),
-    ...materialProductTestFiles.map((repoPath) => ({
-      owner: "product",
-      repoPath,
-      role: "test",
-    })),
-  ].sort((left, right) => compareCodeUnits(left.repoPath, right.repoPath));
-  const reverse = new Map(
-    entries.map(({ repoPath }) => [repoPath, Object.freeze([])]),
-  );
-  reverse.set(runtimePath, materialProductTestFiles);
-  for (const texturePath of changedFiles.filter((repoPath) =>
-    repoPath.startsWith("public/"))) {
-    reverse.set(texturePath, Object.freeze([
-      "src/features/material/material-export.test.ts",
-      "src/features/material/material-renderer.test.ts",
-    ]));
-  }
-  return Object.freeze({
-    entries: Object.freeze(entries.map(Object.freeze)),
-    reverse,
-  });
-}
-
-function createRoles() {
-  const resourcePaths = changedFiles.filter((repoPath) =>
-    repoPath.startsWith("public/"));
-  const proofModelPaths = [
-    "src/app/app-acceptance-data.ts",
-    "src/app/app-performance.ts",
-    "src/app/app-verification-impact.json",
-  ];
-  const roleByPath = Object.fromEntries([
-    ...resourcePaths.map((repoPath) => [repoPath, "product-resource"]),
-    ...proofModelPaths.map((repoPath) => [repoPath, "proof-model"]),
-    ...materialProductTestFiles.map((repoPath) => [repoPath, "product-test"]),
-    ["e2e/app-material.spec.ts", "product-test"],
-    [
-      "src/features/material/material-runtime.ts",
-      "runtime-production",
-    ],
-  ]);
-  return Object.freeze({
-    impactInventoryPath: "src/app/app-verification-impact.json",
-    productResourcePaths: Object.freeze(resourcePaths),
-    productTestPaths: Object.freeze([
-      "e2e/app-material.spec.ts",
-      ...materialProductTestFiles,
-    ]),
-    proofModelPaths: Object.freeze(proofModelPaths),
-    roleByPath: Object.freeze(roleByPath),
-    rootFamily: "generated",
-    runtimeProductionPaths: Object.freeze([
-      "src/features/material/material-runtime.ts",
-    ]),
-    semanticProofRootPaths:
-      toolcraftVerificationInputRootFamilies.generated
-        .semanticProofRootPaths,
-  });
-}
-
-export function createToolcraftFunctionalProofRegressionFixture() {
-  const previousCatalog = catalog(false);
-  const currentCatalog = catalog(true);
-  const previousFunctionalProofModel = proofModel(previousCatalog, []);
-  const currentFunctionalProofModel = proofModel(
-    currentCatalog,
-    currentOwners(),
-  );
-  const comparisonInventory = inventory(0);
-  const currentInventory = inventory(8);
-  const resolutionInputs = Object.freeze({
-    catalog: currentCatalog,
-    changedFiles,
-    currentModel: currentFunctionalProofModel,
-    graph: createGraph(),
-    previousModel: previousFunctionalProofModel,
-    roles: createRoles(),
-  });
-
-  return Object.freeze({
-    changedFiles,
-    createPlanningInputs: (impact) => ({
-      allProductTestFiles: materialProductTestFiles,
-      authority: null,
-      catalog: currentCatalog,
-      changeSet: {
-        dependencyChanged: false,
-        docsChanged: false,
-        frameworkChanged: false,
-        impact,
-        platformChanged: false,
-        productInputsChanged: true,
-      },
-      comparisonInventory,
-      currentFunctionalProofModel,
-      currentInventory,
-      integrity: {
-        manifestHash: hash("f"),
-        sourceHash: currentInventory.sourceHash,
-      },
-      packageManager: "pnpm",
-      previousFunctionalProofModel,
-      previousLifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-      previousPerformance: { kind: "none" },
-    }),
-    materialAcceptanceIds,
-    materialProductTestFiles,
-    resolutionInputs,
-  });
-}

package/templates/starter/scripts/toolcraft-verification-impact-inventory.d.mts

@@ -1,62 +0,0 @@
-export type ToolcraftVerificationImpactFunctionalOwner = Readonly<{
-  acceptanceIds: readonly string[];
-  kind: "functional" | "presentation";
-  path: string;
-}>;
-
-export type ToolcraftVerificationImpactPerformanceOwner = Readonly<{
-  acceptanceIds: readonly string[];
-  kind: "performance";
-  passIds: readonly string[];
-  path: string;
-}>;
-
-export type ToolcraftVerificationImpactOwner =
-  | ToolcraftVerificationImpactFunctionalOwner
-  | ToolcraftVerificationImpactPerformanceOwner;
-
-export type ToolcraftVerificationImpactInventory = Readonly<{
-  owners: readonly ToolcraftVerificationImpactOwner[];
-  version: 3;
-}>;
-
-export type ToolcraftDeliveryCatalog = Readonly<{
-  acceptance: readonly Readonly<{
-    acceptanceId: string;
-    contractHash: string;
-    domainId: string;
-    file: string;
-    testName: string;
-  }>[];
-  performance: readonly Readonly<{
-    passIds: readonly string[];
-    pathId: string;
-    testName: string;
-  }>[];
-  version: 2;
-}>;
-
-export const TOOLCRAFT_VERIFICATION_IMPACT_VERSION: 3;
-
-export function normalizeToolcraftVerificationImpactOwners(
-  value: unknown,
-  options?: {
-    acceptanceIds?: readonly string[];
-    passIds?: readonly string[];
-    requireCanonical?: boolean;
-  },
-): {
-  errors: string[];
-  owners: readonly ToolcraftVerificationImpactOwner[];
-};
-
-export function validateToolcraftVerificationImpactInventory(
-  value: unknown,
-  options: {
-    catalog: ToolcraftDeliveryCatalog;
-    requiredOwnerPaths: readonly string[];
-  },
-): {
-  errors: string[];
-  inventory?: ToolcraftVerificationImpactInventory;
-};