@pixel-point/toolcraft 0.0.15 → 0.0.17

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

@@ -1,119 +1,418 @@
-import { readFileSync } from "node:fs";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+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,
+  TOOLCRAFT_FUNCTIONAL_PERFORMANCE_COVERAGE_POLICY,
+  assessToolcraftRenderPlan,
+  collectToolcraftWorkloadControls,
   collectToolcraftUnclassifiedPerformanceControls,
+  type ToolcraftEnvelopePerformanceConfig,
   validateToolcraftPerformanceCoverage,
 } from "@repo/toolcraft-runtime";
+import {
+  validateToolcraftCurrentPerformanceImpactInventory,
+} from "../../scripts/toolcraft-verification-receipt.mjs";
+import {
+  createToolcraftScriptLineBudgetPolicy,
+  getToolcraftScriptProductionEntryPaths,
+  toolcraftScriptSourceExtensions,
+} from "../../scripts/toolcraft-delivery-architecture-policy.mjs";
+import { evaluateCodeHealth } from "../../scripts/toolcraft-code-health-core.mjs";
 
 import { starterPerformance } from "./starter-performance";
 import { starterSchema } from "./starter-schema";
 import {
+  createToolcraftTypeScriptSourceAnalysis,
   e2eDir,
+  getToolcraftImportedBinding,
   playwrightConfigForbidsFocusedTests,
   projectDir,
+  toolcraftExpressionReferencesImport,
 } from "./starter-performance-test-utils";
 
-describe("Toolcraft starter performance gates", () => {
-  it("publishes separate browser acceptance and performance fallback 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;
-    const runScriptPattern = (scriptName: string) =>
-      `(?:pnpm ${scriptName}|npm run ${scriptName})`;
+async function evaluateGeneratedScriptBudgets(rootDir: string) {
+  return evaluateCodeHealth({
+    ...createToolcraftScriptLineBudgetPolicy("scripts"),
+    productionEntryPaths: getToolcraftScriptProductionEntryPaths("scripts"),
+    rootDir,
+    sourceExtensions: toolcraftScriptSourceExtensions,
+    sourceRoots: ["scripts"],
+  });
+}
 
-    expect(
-      generatedAppTestScript,
-      "Generated app tests must invoke the Toolcraft integrity checker.",
-    ).toContain("node scripts/check-toolcraft-integrity.mjs");
+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;
+    }
+    if (
+      !ts.isPropertyAssignment(property) ||
+      (!ts.isIdentifier(property.name) &&
+        !ts.isStringLiteralLike(property.name))
+    ) {
+      continue;
+    }
+    properties.set(property.name.text, property.initializer);
+  }
+  return properties;
+}
 
-    expect(
-      packageJson.scripts?.["test:browser"],
-      "Generated apps must keep full performance scenarios out of the default browser acceptance gate.",
-    ).toBe('playwright install chromium && playwright test --grep-invert "browser perf:"');
-    expect(
-      packageJson.scripts?.["test:browser:perf"],
-      "Generated apps must expose a protected sequential Playwright checkpoint for final performance proof.",
-    ).toBe("node scripts/run-browser-performance.mjs");
-    const performanceRunner = readFileSync(
-      join(projectDir, "scripts/run-browser-performance.mjs"),
-      "utf8",
-    );
-    const receiptModule = readFileSync(
-      join(projectDir, "scripts/toolcraft-verification-receipt.mjs"),
-      "utf8",
-    );
-    expect(performanceRunner).toContain('runBinary(viteBin, ["build"])');
-    expect(performanceRunner).toContain('TOOLCRAFT_BROWSER_SERVER_MODE: "preview"');
-    expect(performanceRunner).toContain('"--workers=1"');
-    expect(performanceRunner).not.toContain('"--pass-with-no-tests"');
-    expect(performanceRunner).not.toContain("process.argv.slice(2)");
-    expect(performanceRunner).toContain(
-      "assertToolcraftVerificationInputsUnchanged",
-    );
-    expect(performanceRunner).toContain("clearToolcraftPerformanceReceipt");
-    expect(performanceRunner).toContain("writeToolcraftPerformanceCheckpointReceipt");
-    expect(receiptModule).not.toContain(
-      "export async function writeToolcraftPerformanceReceipt",
-    );
-    expect(packageJson.scripts?.["verify:quick"]).toMatch(
-      new RegExp(`^${runScriptPattern("ai:check")} && ${runScriptPattern("test")}$`),
-    );
-    expect(packageJson.scripts?.["verify:ui"]).toMatch(
-      new RegExp(`^${runScriptPattern("test:browser")}$`),
-    );
-    expect(packageJson.scripts?.["verify:perf"]).toMatch(
-      new RegExp(`^${runScriptPattern("test:browser:perf")}$`),
+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);
+  }
+
+  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"),
     );
-    expect(packageJson.scripts?.["verify:perf:playwright"]).toMatch(
-      new RegExp(`^${runScriptPattern("test:browser:perf")}$`),
+    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",
+    });
+  });
+  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 () => {
+      const result = await evaluateGeneratedScriptBudgets(projectDir);
+      expect(result.lineBudgetViolations).toEqual([]);
+    },
+    15_000,
+  );
+
+  it("classifies every script extension and production-looking test by reachability", async () => {
+    const rootDir = mkdtempSync(join(tmpdir(), "toolcraft-script-gate-"));
+    try {
+      const files = {
+        "scripts/nested/fixture.spec.cjs":
+          "export const fixture = true;\n".repeat(500),
+        "scripts/nested/toolcraft-performance-worker.js":
+          "export const execute = true;\n".repeat(301),
+        "scripts/nested/types.cts": "export const type = true;\n",
+        "scripts/nested/types.mts": "export const type = true;\n",
+        "scripts/nested/worker.test.mjs":
+          "export const execute = true;\n".repeat(351),
+        "scripts/run-delivery-verification.mjs": [
+          'import "./nested/toolcraft-performance-worker.js";',
+          'import "./nested/worker.test.mjs";',
+        ].join("\n"),
+      };
+      for (const [repoPath, source] of Object.entries(files)) {
+        const absolutePath = join(rootDir, repoPath);
+        mkdirSync(join(absolutePath, ".."), { recursive: true });
+        writeFileSync(absolutePath, source);
+      }
+      const result = await evaluateGeneratedScriptBudgets(rootDir);
+      expect(result.sourceFileCount).toBe(6);
+      expect(
+        result.lineBudgetViolations.map(({ maxLines, repoPath }) => ({
+          maxLines,
+          repoPath,
+        })),
+      ).toEqual([
+        {
+          maxLines: 300,
+          repoPath: "scripts/nested/toolcraft-performance-worker.js",
+        },
+        {
+          maxLines: 350,
+          repoPath: "scripts/nested/worker.test.mjs",
+        },
+      ]);
+    } finally {
+      rmSync(rootDir, { force: true, recursive: true });
+    }
+  });
+
+  it("keeps the Playwright performance audit inside the browser perf tag", () => {
+    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");
+    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(
-      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-exemption"]).toContain(
-      "record-exemption",
+      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(packageJson.scripts?.["verify:receipt"]).toContain("validate");
-    expect(packageJson.scripts?.["verify:final"]).toMatch(
-      new RegExp(
-        `^${runScriptPattern("ai:check")} && ${runScriptPattern("test")} && ${runScriptPattern("build")} && ${runScriptPattern("test:browser")} && ${runScriptPattern("verify:receipt")}$`,
-      ),
+
+    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("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],
+  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(source).not.toContain("TOOLCRAFT_PERF_CHECK");
-    expect(testNames.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(", ")}`,
-    ).toBe(true);
+    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(
+      [],
+    );
   });
 
   it("rejects focused Playwright tests that would bypass protected browser gates", () => {
     expect(playwrightConfigForbidsFocusedTests()).toBe(true);
   });
 
-  it("declares agent browser as the preferred performance runner", () => {
-    expect(starterPerformance.browserCheckPolicy).toEqual({
-      fallbackRunner: "playwright",
-      fallbackWhen: ["agent-browser-unavailable", "ci"],
-      preferredRunner: "agent-browser",
+  it("keeps verification lifecycle authority in the runtime contract", () => {
+    expect(starterPerformance).not.toHaveProperty("browserCheckPolicy");
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE).toEqual({
+      delivery: {
+        command: "verify:delivery",
+        modes: ["functional", "performance-iteration"],
+        selectors: "automatic",
+      },
+      fullPerformance: {
+        command: "verify:perf",
+        authority: "explicit-user-request-or-accepted-offer",
+      },
+    });
+  });
+
+  it("requires structurally valid performance coverage for functional delivery", () => {
+    expect(
+      validateToolcraftPerformanceCoverage(
+        starterSchema,
+        starterPerformance,
+        TOOLCRAFT_FUNCTIONAL_PERFORMANCE_COVERAGE_POLICY,
+      ),
+    ).toEqual([]);
+  });
+
+  it("maps every product production module to current renderer pass ownership", async () => {
+    const knownPassIds = (starterPerformance.rendererPipeline?.passes ?? []).map(
+      ({ id }) => id,
+    );
+    await expect(
+      validateToolcraftCurrentPerformanceImpactInventory({
+        knownPassIds,
+        rootDir: projectDir,
+      }),
+    ).resolves.toBeDefined();
+  });
+
+  it("keeps unresolved kernel decisions pending during functional delivery", () => {
+    const performanceConfig: ToolcraftEnvelopePerformanceConfig = starterPerformance;
+    const rawAssessment = assessToolcraftRenderPlan(starterSchema, {
+      ...performanceConfig,
+      kernelBenchmarkDecisions: undefined,
     });
+
+    expect(rawAssessment.errors).toEqual([]);
+    expect(rawAssessment.requiredBenchmarks).toEqual(expect.any(Array));
   });
 
-  it("requires valid performance coverage for declared workload scenarios", () => {
-    expect(validateToolcraftPerformanceCoverage(starterSchema, starterPerformance)).toEqual([]);
+  it("starts from an explicit empty workload envelope", () => {
+    if (collectToolcraftWorkloadControls(starterSchema).length > 0) {
+      return;
+    }
+
+    expect(starterPerformance.workloadEnvelope).toEqual({ dimensions: [] });
+    expect(starterPerformance).not.toHaveProperty("rendererWorkload");
+    expect(starterPerformance).not.toHaveProperty("workloadTargets");
+    expect(starterPerformance).not.toHaveProperty("fixtureAdapters");
+    expect(collectToolcraftWorkloadControls(starterSchema)).toEqual([]);
   });
 
   it("requires every visible control to classify its performance role", () => {