@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/starter/src/app/starter-performance.gates.test.ts

@@ -1,5 +1,4 @@
 import {
-  existsSync,
   mkdirSync,
   mkdtempSync,
   readFileSync,
@@ -10,6 +9,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import ts from "typescript";
 import { describe, expect, it } from "vitest";
 import {
   TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE,
@@ -28,27 +28,19 @@ import {
   getToolcraftScriptProductionEntryPaths,
   toolcraftScriptSourceExtensions,
 } from "../../scripts/toolcraft-delivery-architecture-policy.mjs";
-import {
-  TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND,
-  TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND,
-} from "../../scripts/toolcraft-performance-authority-policy.mjs";
 import { evaluateCodeHealth } from "../../scripts/toolcraft-code-health-core.mjs";
-import { requiredPackageScriptNames } from "../../scripts/toolcraft-integrity-policy.mjs";
 
 import { starterPerformance } from "./starter-performance";
 import { starterSchema } from "./starter-schema";
 import {
+  createToolcraftTypeScriptSourceAnalysis,
   e2eDir,
+  getToolcraftImportedBinding,
   playwrightConfigForbidsFocusedTests,
   projectDir,
+  toolcraftExpressionReferencesImport,
 } from "./starter-performance-test-utils";
 
-const expectedRequiredPackageScriptNames = [
-  "ai:check", "build", "dev", "dev:restart", "docs:check", "preview",
-  "preview:restart", "test", "test:browser", "typecheck", "verify:delivery",
-  "verify:kernel", "verify:perf", "verify:receipt",
-] as const;
-
 async function evaluateGeneratedScriptBudgets(rootDir: string) {
   return evaluateCodeHealth({
     ...createToolcraftScriptLineBudgetPolicy("scripts"),
@@ -59,198 +51,102 @@ async function evaluateGeneratedScriptBudgets(rootDir: string) {
   });
 }
 
-describe("Toolcraft starter performance gates", () => {
-  it("publishes separate functional acceptance and performance gates", () => {
-    const packageJson = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8")) as {
-      scripts?: Record<string, string>;
-    };
-    const generatedAppTestScript =
-      packageJson.scripts?.["test:generated"] ?? packageJson.scripts?.test;
-
-    expect(requiredPackageScriptNames).toEqual(expectedRequiredPackageScriptNames);
-    for (const scriptName of requiredPackageScriptNames) {
-      expect(packageJson.scripts?.[scriptName]).toBeDefined();
-    }
-    for (const removed of [
-      "test:delivery", "verify:final", "verify:perf:record-iteration",
-      "verify:quick", "verify:ui",
-    ]) {
-      expect(packageJson.scripts?.[removed]).toBeUndefined();
+function collectObjectPropertyAssignments(
+  value: ts.ObjectLiteralExpression,
+): ReadonlyMap<string, ts.Expression> {
+  const properties = new Map<string, ts.Expression>();
+  for (const property of value.properties) {
+    if (ts.isShorthandPropertyAssignment(property)) {
+      properties.set(property.name.text, property.name);
+      continue;
     }
-    expect(packageJson.scripts?.["ai:check"]).toBe(
-      "node scripts/check-toolcraft-code-health.mjs",
-    );
-    const sourceTestScript =
-      "node scripts/check-toolcraft-docs.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests --reporter=default --reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs";
-    const generatedTestScript =
-      "node scripts/check-toolcraft-docs.mjs && node scripts/check-toolcraft-integrity.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests --reporter=default --reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs";
-    if (packageJson.scripts?.["test:generated"]) {
-      expect(packageJson.scripts.test).toBe(sourceTestScript);
-      expect(packageJson.scripts["test:generated"]).toBe(generatedTestScript);
-    } else {
-      expect(packageJson.scripts?.test).toBe(generatedTestScript);
+    if (
+      !ts.isPropertyAssignment(property) ||
+      (!ts.isIdentifier(property.name) &&
+        !ts.isStringLiteralLike(property.name))
+    ) {
+      continue;
     }
+    properties.set(property.name.text, property.initializer);
+  }
+  return properties;
+}
 
-    expect(
-      generatedAppTestScript,
-      "Generated app tests must invoke the Toolcraft integrity checker.",
-    ).toContain("node scripts/check-toolcraft-integrity.mjs");
+function collectPerformanceSpecFacts(source: string, fileName: string) {
+  const analysis = createToolcraftTypeScriptSourceAnalysis(source, fileName);
+  function importedBinding(
+    expression: ts.Expression | undefined,
+  ): Readonly<{ importedName: string; specifier: string }> | undefined {
+    return getToolcraftImportedBinding(analysis, expression);
+  }
 
-    expect(
-      packageJson.scripts?.["test:browser"],
-      "Generated apps must keep measured performance and kernel benchmark scenarios out of the default browser acceptance gate.",
-    ).toBe(
-      'playwright install chromium && playwright test --grep-invert "browser perf:|toolcraft kernel:"',
-    );
-    expect(packageJson.scripts?.["test:browser:perf"]).toBeUndefined();
-    const performanceRunner = readFileSync(
-      join(projectDir, "scripts/run-browser-performance.mjs"),
-      "utf8",
-    );
-    const receiptModule = readFileSync(
-      join(projectDir, "scripts/toolcraft-verification-receipt.mjs"),
-      "utf8",
-    );
-    const deliveryRunner = readFileSync(
-      join(projectDir, "scripts/run-delivery-verification.mjs"),
-      "utf8",
-    );
-    const deliveryLifecycle = readFileSync(
-      join(projectDir, "scripts/toolcraft-delivery-lifecycle.mjs"),
-      "utf8",
-    );
-    const proofProcess = readFileSync(
-      join(projectDir, "scripts/toolcraft-proof-process.mjs"),
-      "utf8",
-    );
-    const deliveryReceiptModule = readFileSync(
-      join(projectDir, "scripts/toolcraft-delivery-receipt.mjs"),
-      "utf8",
-    );
-    expect(performanceRunner).toContain(
-      "runToolcraftFullPerformanceCertification",
-    );
-    expect(performanceRunner).not.toContain("runToolcraftDeliveryVerification");
-    expect(performanceRunner).not.toContain("--reason=");
-    expect(performanceRunner).toContain("withToolcraftVerificationLock");
-    expect(performanceRunner).toContain("measureToolcraftPerformanceCheckpoint");
-    expect(performanceRunner).not.toContain("writeCheckpointFile");
-    expect(receiptModule).not.toContain(
-      "export async function writeToolcraftPerformanceReceipt",
-    );
-    expect(deliveryReceiptModule).not.toContain(
-      "export async function writeToolcraftDeliveryReceipt",
-    );
-    expect(packageJson.scripts?.["verify:delivery"]).toBe(
-      "node scripts/run-delivery-verification.mjs",
-    );
-    expect(deliveryRunner).toContain("executeToolcraftDeliveryLifecycle");
-    expect(deliveryRunner).toContain("withToolcraftVerificationLock");
-    expect(deliveryLifecycle).toContain(
-      "executeToolcraftDeliveryLifecycleCore",
-    );
-    expect(deliveryLifecycle).toContain("executeToolcraftDeliveryPlan");
-    expect(deliveryLifecycle).not.toContain(
-      "runToolcraftFullPerformanceCertification",
-    );
-    expect(deliveryLifecycle).not.toContain(
-      "measureToolcraftPerformanceCheckpoint",
-    );
-    expect(proofProcess).toContain('from "cross-spawn"');
-    expect(proofProcess).toContain("ensureToolcraftChromium");
-    const deliverySources = `${deliveryRunner}\n${deliveryLifecycle}`;
-    expect(deliverySources).not.toContain('runPackageScript(projectDir, "verify:quick")');
-    expect(deliverySources).not.toContain('runPackageScript(projectDir, "verify:final")');
-    expect(deliverySources).not.toContain('runPackageScript(projectDir, "verify:perf")');
-    expect(packageJson.scripts?.["verify:perf"]).toBe(
-      "node scripts/run-browser-performance.mjs",
-    );
-    expect(packageJson.scripts?.["verify:perf:playwright"]).toBeUndefined();
-    expect(packageJson.scripts?.["verify:perf:refresh"]).toBeUndefined();
-    expect(
-      packageJson.scripts?.["verify:perf:record-agent-browser"],
-      "A terminal-only command must not mint an agent-browser performance receipt without browser evidence.",
-    ).toBeUndefined();
-    expect(
-      packageJson.scripts?.["verify:perf:record-iteration"],
-    ).toBeUndefined();
-    expect(packageJson.scripts?.["verify:kernel"]).toBe(
-      "node scripts/run-kernel-benchmarks.mjs",
-    );
-    const deliveryExecutor = readFileSync(
-      join(projectDir, "scripts/toolcraft-delivery-executor.mjs"),
-      "utf8",
-    );
-    const targetedPerformanceExecution = readFileSync(
-      join(projectDir, "scripts/toolcraft-targeted-performance-execution.mjs"),
-      "utf8",
-    );
-    expect(
-      deliveryExecutor.match(
-        /TOOLCRAFT_PERFORMANCE_FIXTURE_SELECTOR: "development"/g,
-      ),
-    ).toBeNull();
-    expect(
-      targetedPerformanceExecution.match(
-        /TOOLCRAFT_PERFORMANCE_FIXTURE_SELECTOR: "development"/g,
-      ),
-    ).toHaveLength(1);
-    expect(packageJson.scripts?.["verify:perf:record-exemption"]).toBeUndefined();
-    expect(receiptModule).not.toContain('command === "record-iteration"');
-    expect(packageJson.scripts?.["verify:receipt"]).toContain("validate");
+  const compilerCalls = analysis.importedCalls.filter(
+    ({ target }) =>
+      target.specifier === "./performance-path-helpers" &&
+      target.importedName ===
+        "compileToolcraftPerformancePathAdapterMatrix" &&
+      target.memberPath === "",
+  );
+  const compilerBoundaries = compilerCalls.map(({ call }) => {
+    const [input] = call.arguments;
+    const properties =
+      input && ts.isObjectLiteralExpression(input)
+        ? collectObjectPropertyAssignments(input)
+        : new Map<string, ts.Expression>();
+    const paths = properties.get("paths");
+    const canvasBackingBinding = importedBinding(
+      properties.get("canvasBacking"),
+    );
+    const schemaBinding = importedBinding(properties.get("schema"));
+    return Object.freeze({
+      adaptersFromCatalog: properties.has("adapters")
+        ? toolcraftExpressionReferencesImport(
+            analysis,
+            properties.get("adapters"),
+            {
+              importedName: "appPerformancePathAdapters",
+              specifier: "./app-performance-path-adapters",
+            },
+          )
+        : false,
+      canvasBackingFromCatalog:
+        canvasBackingBinding?.importedName ===
+          "appPerformanceCanvasBacking" &&
+        canvasBackingBinding.specifier ===
+          "./app-performance-path-adapters",
+      pathShape:
+        paths && ts.isIdentifier(paths)
+          ? "catalog"
+          : paths &&
+              ts.isArrayLiteralExpression(paths) &&
+              paths.elements.length === 1 &&
+              ts.isIdentifier(paths.elements[0])
+            ? "single"
+            : "invalid",
+      propertyNames: Object.freeze([...properties.keys()].sort()),
+      schemaFromStarter:
+        schemaBinding?.importedName === "starterSchema" &&
+        schemaBinding.specifier === "../src/app/starter-schema",
+    });
   });
-
-  it("documents one automatic delivery workflow without command-shaped authority", () => {
-    const routedDocs = [
-      "AGENTS.md",
-      "docs/toolcraft/README.md",
-      "docs/toolcraft/acceptance-testing.md",
-      "docs/toolcraft/agent-worklog.md",
-      "docs/toolcraft/assembly-workflow.md",
-      "docs/toolcraft/core/performance.md",
-      "docs/toolcraft/performance.md",
-      "docs/toolcraft/workflow.md",
-    ];
-    const docSources = routedDocs.map((relativePath) => ({
-      relativePath,
-      source: readFileSync(join(projectDir, relativePath), "utf8"),
-    }));
-
-    for (const { relativePath, source } of docSources) {
-      expect(source, relativePath).toMatch(/first (?:product )?delivery/i);
-      expect(source, relativePath).toMatch(/later[^\n]{0,40}delivery/i);
-      expect(source, relativePath).toMatch(/performance complaint/i);
-      expect(source, relativePath).toMatch(/full audit/i);
-      expect(source, relativePath).toContain(
-        TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND,
-      );
-      expect(source, relativePath).toContain(
-        TOOLCRAFT_FULL_PERFORMANCE_VERIFICATION_COMMAND,
-      );
-    }
-
-    const allRoutedDocs = docSources.map(({ source }) => source).join("\n");
-    const nonAgentsDocs = docSources
-      .filter(({ relativePath }) => relativePath !== "AGENTS.md")
-      .map(({ source }) => source)
-      .join("\n");
-    expect(nonAgentsDocs).not.toMatch(/\bTier (?:N|[0-4])\b/);
-    expect(allRoutedDocs).not.toMatch(
-      /verify:quick|verify:ui|verify:final|verify:perf:record-iteration|test:delivery/,
-    );
-    expect(allRoutedDocs).not.toMatch(
-      /verify:delivery\s+--|--tier|--unit-test|--browser-test|--performance-test/,
-    );
-    expect(allRoutedDocs).not.toMatch(
-      /performance modules require protected evidence|(?:add|run)[^\n]*affected path performance checks[^\n]*when an edit changes|during development[^\n]*affected performance scenarios|targeted performance scenarios only for touched/i,
-    );
-    expect(allRoutedDocs).toMatch(
-      /only exact request authority[^\n]*measured targeted performance/i,
-    );
-    expect(allRoutedDocs).not.toMatch(/matching (?:executed )?`?Run\b`?/i);
-    expect(allRoutedDocs).not.toContain("app-performance-impact.json");
+  const staticTestNames = analysis.importedCalls.flatMap(({ call, target }) => {
+    const [name] = call.arguments;
+    return target.specifier === "@playwright/test" &&
+      target.importedName === "test" &&
+      target.memberPath === "" &&
+      name &&
+      ts.isStringLiteralLike(name)
+      ? [name.text]
+      : [];
+  });
+  return Object.freeze({
+    compilerBoundaries: Object.freeze(compilerBoundaries),
+    importedCallTargets: analysis.callTargets.importedCallTargets,
+    staticTestNames: Object.freeze(staticTestNames),
   });
+}
 
+describe("Toolcraft starter performance gates", () => {
   it(
     "keeps generated verification scripts within shared recursive budgets",
     async () => {
@@ -305,30 +201,150 @@ describe("Toolcraft starter performance gates", () => {
   });
 
   it("keeps the Playwright performance audit inside the browser perf tag", () => {
-    const source = readFileSync(join(e2eDir, "app-performance.spec.ts"), "utf8");
-    const testNames = [...source.matchAll(/test\(\s*(["'`])([^"'`]+)\1/g)].map(
-      (match) => match[2],
-    );
+    const sourcePath = join(e2eDir, "app-performance.spec.ts");
+    const source = readFileSync(sourcePath, "utf8");
+    const facts = collectPerformanceSpecFacts(source, sourcePath);
 
     expect(source).not.toContain("TOOLCRAFT_PERF_CHECK");
-    expect(source).toContain("compileToolcraftPerformancePathAdapterMatrix");
-    expect(source).toContain("deriveToolcraftPerformancePaths");
-    expect(source).toContain("appPerformancePathAdapters");
-    expect(source).toContain("runToolcraftPerformancePath");
-    expect(source).toContain(
-      'test("browser perf: toolcraft adapter catalog"',
-    );
-    expect(source).toContain("for (const path of performancePaths)");
-    expect(source).toContain(
-      "appPerformancePathAdapters.filter(",
-    );
-    expect(testNames.length).toBeGreaterThan(0);
+    for (const expected of [
+      ["@repo/toolcraft-runtime", "deriveToolcraftPerformancePaths"],
+      ["./performance-path-helpers", "getToolcraftPerformancePathTestName"],
+      ["./performance-path-helpers", "runToolcraftPerformancePath"],
+    ] as const) {
+      expect(
+        facts.importedCallTargets.some(
+          ({ importedName, memberPath, specifier }) =>
+            specifier === expected[0] &&
+            importedName === expected[1] &&
+            memberPath === "",
+        ),
+      ).toBe(true);
+    }
+    expect(facts.compilerBoundaries).toHaveLength(2);
+    for (const boundary of facts.compilerBoundaries) {
+      expect(boundary.propertyNames).toEqual([
+        "adapters",
+        "canvasBacking",
+        "paths",
+        "schema",
+      ]);
+      expect(boundary.adaptersFromCatalog).toBe(true);
+      expect(boundary.canvasBackingFromCatalog).toBe(true);
+      expect(boundary.schemaFromStarter).toBe(true);
+    }
+    expect(facts.compilerBoundaries.map(({ pathShape }) => pathShape).sort()).toEqual([
+      "catalog",
+      "single",
+    ]);
+    expect(facts.staticTestNames).toContain(
+      "browser perf: toolcraft adapter catalog",
+    );
+    expect(facts.staticTestNames.length).toBeGreaterThan(0);
     expect(
-      testNames.every((name) => name.includes("browser perf:")),
-      `app-performance.spec.ts tests must all be tagged for the dedicated perf checkpoint: ${testNames.join(", ")}`,
+      facts.staticTestNames.every((name) => name.includes("browser perf:")),
+      `app-performance.spec.ts tests must all be tagged for the dedicated perf checkpoint: ${facts.staticTestNames.join(", ")}`,
     ).toBe(true);
   });
 
+  it("accepts harmless performance catalog import aliases", () => {
+    const facts = collectPerformanceSpecFacts(
+      `
+        import { starterSchema as schema } from "../src/app/starter-schema";
+        import {
+          appPerformanceCanvasBacking as backing,
+          appPerformancePathAdapters as adapters,
+        } from "./app-performance-path-adapters";
+        import {
+          compileToolcraftPerformancePathAdapterMatrix as compile,
+        } from "./performance-path-helpers";
+
+        const paths = [];
+        const path = paths[0];
+        compile({ adapters, canvasBacking: backing, paths, schema });
+        compile({
+          adapters: adapters.filter((candidate) => candidate.pathId === path.id),
+          canvasBacking: backing,
+          paths: [path],
+          schema,
+        });
+      `,
+      "aliased-performance-spec.ts",
+    );
+
+    expect(facts.compilerBoundaries).toHaveLength(2);
+    expect(facts.compilerBoundaries).toMatchObject([
+      {
+        adaptersFromCatalog: true,
+        canvasBackingFromCatalog: true,
+        schemaFromStarter: true,
+      },
+      {
+        adaptersFromCatalog: true,
+        canvasBackingFromCatalog: true,
+        schemaFromStarter: true,
+      },
+    ]);
+    expect(facts.compilerBoundaries.map(({ pathShape }) => pathShape).sort()).toEqual([
+      "catalog",
+      "single",
+    ]);
+  });
+
+  it("rejects compiler boundaries that omit product canvas backing", () => {
+    const facts = collectPerformanceSpecFacts(
+      `
+        import { starterSchema as schema } from "../src/app/starter-schema";
+        import {
+          appPerformanceCanvasBacking as backing,
+          appPerformancePathAdapters as adapters,
+        } from "./app-performance-path-adapters";
+        import {
+          compileToolcraftPerformancePathAdapterMatrix as compile,
+        } from "./performance-path-helpers";
+
+        const paths = [];
+        compile({ adapters, paths, schema });
+      `,
+      "missing-performance-canvas-backing.ts",
+    );
+
+    expect(facts.compilerBoundaries).toHaveLength(1);
+    expect(facts.compilerBoundaries[0]).toMatchObject({
+      adaptersFromCatalog: true,
+      canvasBackingFromCatalog: false,
+      propertyNames: ["adapters", "paths", "schema"],
+      schemaFromStarter: true,
+    });
+  });
+
+  it("rejects shadowed performance compiler and adapter identifiers", () => {
+    const facts = collectPerformanceSpecFacts(
+      `
+        import { starterSchema as schema } from "../src/app/starter-schema";
+        import {
+          appPerformanceCanvasBacking as backing,
+          appPerformancePathAdapters as adapters,
+        } from "./app-performance-path-adapters";
+        import {
+          compileToolcraftPerformancePathAdapterMatrix as compile,
+        } from "./performance-path-helpers";
+
+        const paths = [];
+        function ignoredShadow(compile) {
+          compile({ adapters, canvasBacking: backing, paths, schema });
+        }
+        {
+          const adapters = [];
+          compile({ adapters, canvasBacking: backing, paths, schema });
+        }
+      `,
+      "shadowed-performance-spec.ts",
+    );
+
+    expect(facts.compilerBoundaries).toHaveLength(1);
+    expect(facts.compilerBoundaries[0]?.adaptersFromCatalog).toBe(false);
+  });
+
   it("keeps measured performance out of functional delivery", () => {
     expect(readdirSync(e2eDir).filter((name) => name.includes("-smoke"))).toEqual(
       [],
@@ -399,69 +415,6 @@ describe("Toolcraft starter performance gates", () => {
     expect(collectToolcraftWorkloadControls(starterSchema)).toEqual([]);
   });
 
-  it("keeps workload guidance structural instead of prescribing domain constants", () => {
-    const monorepoRoot = join(projectDir, "..");
-    const documentation = [
-      join(projectDir, "AGENTS.md"),
-      join(projectDir, "docs/toolcraft/core/performance.md"),
-      join(projectDir, "docs/toolcraft/performance.md"),
-      join(projectDir, "docs/toolcraft/renderer-technique.md"),
-      join(projectDir, "docs/toolcraft/assembly-workflow.md"),
-      join(projectDir, "docs/toolcraft/workflow.md"),
-      join(monorepoRoot, "apps/website/src/content/docs/toolcraft-core-performance.md"),
-      join(monorepoRoot, "apps/website/src/content/docs/toolcraft-performance.md"),
-      join(monorepoRoot, "apps/website/src/content/docs/toolcraft-renderer-technique.md"),
-      join(monorepoRoot, "apps/website/src/content/docs/toolcraft-assembly-workflow.md"),
-      join(monorepoRoot, "apps/website/src/content/docs/toolcraft-workflow.md"),
-    ]
-      .filter((filePath) => existsSync(filePath))
-      .map((filePath) => readFileSync(filePath, "utf8"))
-      .join("\n");
-
-    expect(documentation).toMatch(/reachable controls and inputs/i);
-    expect(documentation).toMatch(/workload dimensions and enforced boundaries/i);
-    expect(documentation).toMatch(
-      /render-plan assessment(?: and| with).*protected kernel benchmark/i,
-    );
-    expect(documentation).toMatch(/derived paths and combined fixtures/i);
-    expect(documentation).not.toMatch(/50_000|1_000\s+lines|1920x1080-equivalent/i);
-    expect(documentation).not.toMatch(/classif(?:y|ication)[^\n]*(?:key name|key-name|keyword)/i);
-    expect(documentation).not.toMatch(
-      /bitmap-media|halftone|per-pixel|max text length|max media size/i,
-    );
-    expect(documentation).toMatch(/exact normalized development pressure `0\.8`/i);
-    expect(documentation).toMatch(/exhaustive-discrete/i);
-    expect(documentation).toMatch(/match(?:es)? every option one-to-one/i);
-    expect(documentation).toMatch(/toolcraftDiscreteCombinationBudget/);
-    expect(documentation).toMatch(/toolcraftDiscreteDimensionBudget/);
-    expect(documentation).toMatch(/bypasses search budgets because no (?:combination )?search runs/i);
-    expect(documentation).toMatch(/planning error/i);
-    expect(documentation).toMatch(/TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE/);
-    expect(documentation).toMatch(/exactly one scenario (?:for|per) (?:every )?(?:canonical |derived )?path/i);
-    expect(documentation).toMatch(/targeted failure[^\n]*(?:not|rather than)[^\n]*full[- ]suite/i);
-    expect(documentation).toMatch(
-      /first product delivery[^\n]*full functional acceptance[^\n]*no measured performance/i,
-    );
-    expect(documentation).toMatch(
-      /later delivery[^\n]*functional-targeted/i,
-    );
-    expect(documentation).toMatch(
-      /complaint[^\n]*one-authority-targeted-performance-iteration/i,
-    );
-    expect(documentation).toMatch(/full-performance/i);
-    expect(documentation).toMatch(/needs-agent-judgment/i);
-    expect(documentation).toMatch(
-      /later[^\n]{0,40}delivery[^\n]*(?:same )?bare command[^\n]*exact ownership/i,
-    );
-    expect(documentation).not.toMatch(
-      /first stable[^\n]*(?:full performance|full checkpoint|baseline)/i,
-    );
-    expect(documentation).not.toMatch(/compatibility mode|legacy preferred|legacy-only/i);
-    expect(documentation).not.toMatch(/loadProfile|smoothTargetRatio/i);
-    expect(documentation).not.toMatch(/without exceeding development pressure/i);
-    expect(documentation).not.toMatch(/\breachableValues\b/);
-  });
-
   it("requires every visible control to classify its performance role", () => {
     const unclassifiedControls =
       collectToolcraftUnclassifiedPerformanceControls(starterSchema);