@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/scripts/toolcraft-verification-impact-performance-candidates.test.mjs

@@ -1,210 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  createToolcraftFunctionalProofModel,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  resolveToolcraftChangedVerificationImpact,
-} from "./toolcraft-verification-impact.mjs";
-import {
-  toolcraftVerificationInputRootFamilies,
-} from "./toolcraft-verification-input-roles.mjs";
-
-const hash = (value) => value.repeat(64);
-const paths = Object.freeze([
-  "performance-path:%5B%22interactive-continuous%22%2C%22viewport-drag%22%2C%5B%22viewport-composite%22%5D%2C%5B%22main%22%5D%2C%5B%5D%5D",
-  "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 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",
-    }),
-    Object.freeze({
-      acceptanceId: "viewport.pans",
-      contractHash: hash("b"),
-      domainId: "viewport",
-      file: "app-viewport.spec.ts",
-      testName: "browser: viewport pans",
-    }),
-  ]),
-  performance: Object.freeze([
-    Object.freeze({
-      passIds: Object.freeze(["viewport-composite"]),
-      pathId: paths[0],
-      testName: `browser perf: toolcraft path ${paths[0]}`,
-    }),
-    Object.freeze({
-      passIds: Object.freeze(["preview-composite"]),
-      pathId: paths[1],
-      testName: `browser perf: toolcraft path ${paths[1]}`,
-    }),
-  ]),
-  version: 2,
-});
-
-function model(owners) {
-  return createToolcraftFunctionalProofModel({
-    catalog,
-    inventory: { owners, version: 3 },
-  });
-}
-
-function graph(entries, reverse = {}) {
-  return Object.freeze({
-    entries: Object.freeze(entries),
-    reverse: new Map(
-      entries.map(({ repoPath }) => [
-        repoPath,
-        Object.freeze([...(reverse[repoPath] ?? [])]),
-      ]),
-    ),
-  });
-}
-
-function roles(roleByPath) {
-  return Object.freeze({
-    impactInventoryPath: "src/app/app-verification-impact.json",
-    productResourcePaths: Object.freeze([]),
-    productTestPaths: Object.freeze([]),
-    proofModelPaths: Object.freeze([]),
-    roleByPath: Object.freeze({ ...roleByPath }),
-    rootFamily: "generated",
-    runtimeProductionPaths: Object.freeze([]),
-    semanticProofRootPaths:
-      toolcraftVerificationInputRootFamilies.generated
-        .semanticProofRootPaths,
-  });
-}
-
-function resolve({
-  changedFiles,
-  currentOwners = [],
-  entries,
-  previousOwners = currentOwners,
-  reverse,
-  roleByPath,
-}) {
-  return resolveToolcraftChangedVerificationImpact({
-    catalog,
-    changedFiles,
-    currentModel: model(currentOwners),
-    graph: graph(entries, reverse),
-    previousModel: model(previousOwners),
-    roles: roles(roleByPath),
-  });
-}
-
-function candidates(rows = catalog.performance) {
-  return {
-    passIds: [...new Set(rows.flatMap(({ passIds }) => passIds))].sort(),
-    pathIds: rows.map(({ pathId }) => pathId).sort(),
-    testNames: rows.map(({ testName }) => testName).sort(),
-  };
-}
-
-test("a performance owner selects functional proof and current pass candidates", () => {
-  const runtimePath = "src/features/output.tsx";
-  const owners = [{
-    acceptanceIds: ["output.updates"],
-    kind: "performance",
-    passIds: ["preview-composite"],
-    path: runtimePath,
-  }];
-  const result = resolve({
-    changedFiles: [runtimePath],
-    currentOwners: owners,
-    entries: [{
-      owner: "product",
-      repoPath: runtimePath,
-      role: "production",
-    }],
-    roleByPath: { [runtimePath]: "runtime-production" },
-  });
-
-  assert.deepEqual(result.acceptanceIds, ["output.updates"]);
-  assert.deepEqual(
-    result.performanceCandidates,
-    candidates([catalog.performance[1]]),
-  );
-  assert.equal(result.buildRequired, true);
-});
-
-test("the performance spec selects candidates but no functional browser proof", () => {
-  const performancePath = "e2e/app-performance.spec.ts";
-  const result = resolve({
-    changedFiles: [performancePath],
-    entries: [{
-      owner: "product",
-      repoPath: performancePath,
-      role: "test",
-    }],
-    roleByPath: { [performancePath]: "product-test" },
-  });
-
-  assert.deepEqual(result.acceptanceIds, []);
-  assert.deepEqual(result.browserTestNames, []);
-  assert.deepEqual(result.performanceCandidates, candidates());
-  assert.deepEqual(result.productTestFiles, []);
-  assert.equal(result.buildRequired, false);
-});
-
-test("a performance-only helper preserves candidates without functional widening", () => {
-  const helperPath = "e2e/test-support/performance-fixture.ts";
-  const performancePath = "e2e/app-performance.spec.ts";
-  const result = resolve({
-    changedFiles: [helperPath],
-    entries: [
-      { owner: "product", repoPath: helperPath, role: "test-support" },
-      {
-        owner: "product",
-        repoPath: performancePath,
-        role: "test",
-      },
-    ],
-    reverse: { [helperPath]: [performancePath] },
-    roleByPath: {
-      [helperPath]: "product-test",
-      [performancePath]: "product-test",
-    },
-  });
-
-  assert.deepEqual(result.browserTestNames, []);
-  assert.deepEqual(result.performanceCandidates, candidates());
-  assert.equal(result.buildRequired, false);
-});
-
-test("a performance helper still selects directly affected Vitest", () => {
-  const helperPath = "e2e/test-support/performance-fixture.ts";
-  const performancePath = "e2e/app-performance.spec.ts";
-  const unitPath = "src/features/performance-contract.test.ts";
-  const result = resolve({
-    changedFiles: [helperPath],
-    entries: [
-      { owner: "product", repoPath: helperPath, role: "test-support" },
-      {
-        owner: "product",
-        repoPath: performancePath,
-        role: "test",
-      },
-      { owner: "product", repoPath: unitPath, role: "test" },
-    ],
-    reverse: {
-      [helperPath]: [performancePath, unitPath],
-    },
-    roleByPath: {
-      [helperPath]: "product-test",
-      [performancePath]: "product-test",
-      [unitPath]: "product-test",
-    },
-  });
-
-  assert.deepEqual(result.productTestFiles, [unitPath]);
-  assert.deepEqual(result.browserTestNames, []);
-  assert.deepEqual(result.performanceCandidates, candidates());
-});

package/templates/starter/scripts/toolcraft-verification-impact-resolution.mjs

@@ -1,344 +0,0 @@
-import path from "node:path";
-
-import {
-  diffToolcraftFunctionalProofModels,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  serializeToolcraftCanonicalJson,
-} from "./toolcraft-functional-proof-primitives.mjs";
-import {
-  getToolcraftAffectedTestFiles,
-} from "./toolcraft-local-dependency-graph.mjs";
-import {
-  validateToolcraftDeliveryCatalog,
-} from "./playwright-test-title-selection.mjs";
-import {
-  selectToolcraftCurrentBrowserImpact,
-} from "./toolcraft-browser-impact-selection.mjs";
-const performanceSpecPath = "e2e/app-performance.spec.ts";
-const testFilePattern = /(?:^|\/)[^/]+\.(?:test|spec)\.[cm]?[jt]sx?$/u;
-const testSupportPattern =
-  /(?:^|\/)(?:test-evidence|test-support)(?:\/|$)|(?:^|\/)[^/]*(?:fixtures|test-utils)\.[cm]?[jt]sx?$/u;
-
-const compareCodeUnits = (left, right) =>
-  left < right ? -1 : left > right ? 1 : 0;
-const uniqueSorted = (values) =>
-  [...new Set(values)].sort(compareCodeUnits);
-const toRepoTestFile = (file) =>
-  file.startsWith("e2e/") ? file : `e2e/${file}`;
-
-function normalizeChangedPath(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(
-      `Changed verification input "${value}" is not a canonical relative path.`,
-    );
-  }
-  const normalized = value.replaceAll("\\", "/").replace(/^\.\//u, "");
-  if (
-    normalized.startsWith("/") ||
-    normalized.startsWith("../") ||
-    normalized !== path.posix.normalize(normalized)
-  ) {
-    throw new Error(
-      `Changed verification input "${value}" is not a canonical relative path.`,
-    );
-  }
-  return normalized;
-}
-
-function createPerformanceCandidates(rows) {
-  return Object.freeze({
-    passIds: Object.freeze(
-      uniqueSorted(rows.flatMap(({ passIds }) => passIds)),
-    ),
-    pathIds: Object.freeze(
-      uniqueSorted(rows.map(({ pathId }) => pathId)),
-    ),
-    testNames: Object.freeze(
-      uniqueSorted(rows.map(({ testName }) => testName)),
-    ),
-  });
-}
-
-function createResolvedImpact({
-  acceptanceIds,
-  buildRequired,
-  catalog,
-  performanceRows,
-  productTestFiles,
-}) {
-  const currentAcceptanceIds = new Set(
-    catalog.acceptance.map(({ acceptanceId }) => acceptanceId),
-  );
-  const selectedIds = uniqueSorted(
-    acceptanceIds.filter((acceptanceId) =>
-      currentAcceptanceIds.has(acceptanceId),
-    ),
-  );
-  const selectedIdSet = new Set(selectedIds);
-  return Object.freeze({
-    acceptanceIds: Object.freeze(selectedIds),
-    browserTestNames: Object.freeze(
-      uniqueSorted(
-        catalog.acceptance
-          .filter(({ acceptanceId }) => selectedIdSet.has(acceptanceId))
-          .map(({ testName }) => testName),
-      ),
-    ),
-    buildRequired: buildRequired || selectedIds.length > 0,
-    performanceCandidates: createPerformanceCandidates(performanceRows),
-    productTestFiles: Object.freeze(uniqueSorted(productTestFiles)),
-  });
-}
-
-function createProofIndex(model) {
-  return Object.freeze({
-    acceptanceFiles: new Set(
-      model.acceptance.map(({ file }) => toRepoTestFile(file)),
-    ),
-    ownersByPath: new Map(
-      model.owners.map((owner) => [owner.path, owner]),
-    ),
-  });
-}
-
-function addOwnerAcceptance(owner, acceptanceIds) {
-  owner?.acceptanceIds.forEach((id) => acceptanceIds.add(id));
-}
-
-function addPerformancePasses(owner, passIds) {
-  if (owner?.kind !== "performance") return;
-  owner.passIds.forEach((id) => passIds.add(id));
-}
-
-function assertCurrentCatalogMatchesModel(catalog, currentModel) {
-  const validation = validateToolcraftDeliveryCatalog(catalog);
-  if (validation.errors.length > 0) {
-    throw new Error(
-      `Invalid current delivery catalog: ${validation.errors.join("\n")}`,
-    );
-  }
-  if (
-    serializeToolcraftCanonicalJson(validation.catalog.acceptance) !==
-    serializeToolcraftCanonicalJson(currentModel.acceptance)
-  ) {
-    throw new Error(
-      "Current catalog acceptance does not match the current functional proof model.",
-    );
-  }
-  return validation.catalog;
-}
-
-function createTestClassifier({ catalog, graph, roles }) {
-  const entriesByPath = new Map(
-    graph.entries.map((entry) => [entry.repoPath, entry]),
-  );
-  const currentBrowserFiles = new Set(
-    catalog.acceptance.map(({ file }) => toRepoTestFile(file)),
-  );
-  return Object.freeze({
-    isBrowserTest(repoPath) {
-      const entry = entriesByPath.get(repoPath);
-      return (
-        entry?.role === "test" &&
-        repoPath.startsWith("e2e/") &&
-        testFilePattern.test(repoPath)
-      );
-    },
-    isCurrentBrowserFile(repoPath) {
-      return currentBrowserFiles.has(repoPath);
-    },
-    isPerformanceSpec(repoPath) {
-      return repoPath === performanceSpecPath;
-    },
-    isTestSupport(repoPath) {
-      const entry = entriesByPath.get(repoPath);
-      return (
-        entry?.role === "test-support" ||
-        (
-          roles.roleByPath[repoPath] === "product-test" &&
-          entry?.role !== "test"
-        ) ||
-        (
-          !entry &&
-          (
-            testSupportPattern.test(repoPath) ||
-            (repoPath.startsWith("e2e/") && !testFilePattern.test(repoPath))
-          )
-        )
-      );
-    },
-    isVitestTest(repoPath) {
-      const entry = entriesByPath.get(repoPath);
-      return (
-        entry?.role === "test" &&
-        repoPath.startsWith("src/") &&
-        !repoPath.startsWith("src/toolcraft/") &&
-        testFilePattern.test(repoPath)
-      );
-    },
-  });
-}
-
-function throwUnrecognized(repoPath) {
-  throw new Error(
-    `Unrecognized changed verification input "${repoPath}" cannot select protected proof.`,
-  );
-}
-
-export function resolveToolcraftChangedVerificationImpact({
-  catalog,
-  changedFiles,
-  currentModel,
-  graph,
-  previousModel,
-  roles,
-}) {
-  const changed = uniqueSorted(changedFiles.map(normalizeChangedPath));
-  const semanticDelta = diffToolcraftFunctionalProofModels({
-    current: currentModel,
-    previous: previousModel,
-  });
-  const currentCatalog = assertCurrentCatalogMatchesModel(
-    catalog,
-    currentModel,
-  );
-  const current = createProofIndex(currentModel);
-  const previous = createProofIndex(previousModel);
-  const classifier = createTestClassifier({
-    catalog: currentCatalog,
-    graph,
-    roles,
-  });
-  const acceptanceIds = new Set(semanticDelta.acceptanceIds);
-  const semanticAcceptanceIds = new Set(semanticDelta.acceptanceIds);
-  const performancePassIds = new Set();
-  const browserDomains = new Set();
-  let buildRequired = false;
-  let allPerformanceCandidates = false;
-
-  for (const ownerPath of semanticDelta.changedOwnerPaths) {
-    addPerformancePasses(
-      current.ownersByPath.get(ownerPath),
-      performancePassIds,
-    );
-  }
-
-  for (const changedPath of changed) {
-    const role = roles.roleByPath[changedPath];
-    const currentOwner = current.ownersByPath.get(changedPath);
-    const previousOwner = previous.ownersByPath.get(changedPath);
-    const directRuntime =
-      role === "runtime-production" || role === "product-resource";
-    if (directRuntime) {
-      if (!currentOwner) {
-        throw new Error(
-          `Changed runtime or resource "${changedPath}" has no current verification impact owner.`,
-        );
-      }
-      addOwnerAcceptance(previousOwner, acceptanceIds);
-      addOwnerAcceptance(currentOwner, acceptanceIds);
-      addPerformancePasses(currentOwner, performancePassIds);
-      buildRequired = true;
-      continue;
-    }
-    if (previousOwner) {
-      addOwnerAcceptance(previousOwner, acceptanceIds);
-      addOwnerAcceptance(currentOwner, acceptanceIds);
-      addPerformancePasses(currentOwner, performancePassIds);
-      buildRequired = true;
-      continue;
-    }
-    if (role === "proof-model") continue;
-
-    const affectedTests =
-      getToolcraftAffectedTestFiles(graph, [changedPath]);
-    if (classifier.isTestSupport(changedPath)) {
-      const executable = affectedTests.filter(
-        (repoPath) =>
-          classifier.isVitestTest(repoPath) ||
-          classifier.isBrowserTest(repoPath),
-      );
-      if (executable.length === 0) {
-        throw new Error(
-          `Changed test support "${changedPath}" reaches no executable Vitest or Playwright importer.`,
-        );
-      }
-      const impact = selectToolcraftCurrentBrowserImpact({
-        files: executable,
-        model: currentModel,
-        semanticAcceptanceIds,
-      });
-      impact.acceptanceIds.forEach((id) => acceptanceIds.add(id));
-      impact.domainIds.forEach((id) => browserDomains.add(id));
-      if (executable.some(classifier.isPerformanceSpec)) {
-        allPerformanceCandidates = true;
-      }
-      continue;
-    }
-    if (classifier.isPerformanceSpec(changedPath)) {
-      allPerformanceCandidates = true;
-      continue;
-    }
-    if (classifier.isCurrentBrowserFile(changedPath)) {
-      const impact = selectToolcraftCurrentBrowserImpact({
-        files: [changedPath],
-        model: currentModel,
-        semanticAcceptanceIds,
-      });
-      impact.acceptanceIds.forEach((id) => acceptanceIds.add(id));
-      impact.domainIds.forEach((id) => browserDomains.add(id));
-      continue;
-    }
-    if (previous.acceptanceFiles.has(changedPath)) {
-      for (const row of previousModel.acceptance) {
-        if (toRepoTestFile(row.file) === changedPath) {
-          browserDomains.add(row.domainId);
-        }
-      }
-      continue;
-    }
-    if (
-      classifier.isVitestTest(changedPath) ||
-      classifier.isBrowserTest(changedPath)
-    ) {
-      if (classifier.isBrowserTest(changedPath)) {
-        throwUnrecognized(changedPath);
-      }
-      continue;
-    }
-    if (changedPath !== "docs/toolcraft/agent-worklog.md") {
-      throwUnrecognized(changedPath);
-    }
-  }
-
-  for (const row of currentModel.acceptance) {
-    if (browserDomains.has(row.domainId)) {
-      acceptanceIds.add(row.acceptanceId);
-    }
-  }
-  const hasSemanticProofDelta =
-    semanticDelta.acceptanceIds.length > 0 ||
-    semanticDelta.changedOwnerPaths.length > 0;
-  const affectedTestSeeds = hasSemanticProofDelta
-    ? changed.filter(
-        (repoPath) =>
-          !roles.semanticProofRootPaths.includes(repoPath),
-      )
-    : changed;
-  const affectedTests =
-    getToolcraftAffectedTestFiles(graph, affectedTestSeeds);
-  const productTestFiles = affectedTests.filter(classifier.isVitestTest);
-  const performanceRows = allPerformanceCandidates
-    ? currentCatalog.performance
-    : currentCatalog.performance.filter(({ passIds }) =>
-        passIds.some((passId) => performancePassIds.has(passId)),
-      );
-  return createResolvedImpact({
-    acceptanceIds: [...acceptanceIds],
-    buildRequired,
-    catalog: currentCatalog,
-    performanceRows,
-    productTestFiles,
-  });
-}