@pixel-point/toolcraft 0.0.14 → 0.0.15

package/src/generate-test-doc-assertions.mjs

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const generatedDocPaths = [
+  "README.md",
+  "workflow.md",
+  "assembly-workflow.md",
+  "decision-contract.md",
+  "schema-reference.md",
+  "acceptance-testing.md",
+  "performance.md",
+  "renderer-technique.md",
+  "custom-controls.md",
+  "component-rules.md",
+  "core/runtime-boundary.md",
+  "core/setup-export.md",
+  "core/control-selection.md",
+  "core/layout.md",
+  "core/media-upload.md",
+  "core/timeline-animation.md",
+  "core/performance.md",
+  "core/reference-study.md",
+];
+
+export async function assertGeneratedDocs(targetDir) {
+  await Promise.all(
+    generatedDocPaths.map((docPath) => fs.stat(path.join(targetDir, "docs/toolcraft", docPath))),
+  );
+
+  const agentsSource = await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8");
+  const licenseSource = await fs.readFile(path.join(targetDir, "LICENSE.md"), "utf8");
+  const noticeSource = await fs.readFile(path.join(targetDir, "NOTICE.md"), "utf8");
+  const localDocPaths = generatedDocPaths.filter((docPath) => docPath !== "README.md");
+
+  assert.match(agentsSource, /Quick Entry Contract/);
+  assert.match(agentsSource, /Local Reference Docs/);
+  assert.match(agentsSource, /src\/app\/app-schema\.ts/);
+  assert.match(agentsSource, /src\/app\/app-composition\.tsx/);
+  assert.match(agentsSource, /src\/app\/app-acceptance\.ts/);
+  assert.match(agentsSource, /src\/app\/app-acceptance-data\.ts/);
+  assert.match(agentsSource, /framework-owned files covered by the signed integrity manifest/);
+  assert.match(agentsSource, /src\/app\/app-performance\.ts/);
+  assert.match(agentsSource, /Do not edit `src\/toolcraft`/);
+  assert.match(agentsSource, /immutable signed copy of the shared Toolcraft runtime/);
+  assert.match(agentsSource, /AI Workflow Skills And Local Fallback/);
+  assert.match(agentsSource, /Verification Tier Classifier/);
+  assert.match(agentsSource, /Verification tier: Tier N/);
+  assert.match(agentsSource, /npm run verify:quick/);
+  assert.match(agentsSource, /npm run verify:final/);
+  assert.match(agentsSource, /node scripts\/check-toolcraft-integrity\.mjs/);
+  assert.match(agentsSource, /do not rely only on a package script/i);
+  assert.match(agentsSource, /npm run ai:check/);
+  assert.match(agentsSource, /use `brainstorming`/);
+  assert.match(agentsSource, /use `writing-plans`/);
+  assert.match(agentsSource, /use `systematic-debugging`/);
+  assert.match(agentsSource, /browser` workflow/);
+  assert.match(agentsSource, /npm run test:browser/);
+  assert.match(agentsSource, /signed local `AGENTS\.md` and `docs\/toolcraft\/\*` files are the mandatory workflow authority/i);
+  assert.match(agentsSource, /generated with `--no-skills`, continue through the equivalent signed local workflow/i);
+  assert.match(agentsSource, /Do not silently ignore a missing workflow capability/);
+  assert.doesNotMatch(agentsSource, /stop before implementation/);
+  assert.match(agentsSource, /Toolcraft app contract overrides generic brainstorming approval/);
+  assert.match(agentsSource, /Do not ask the user to confirm decisions already covered/);
+  assert.match(agentsSource, /Do not ask whether to enable a browser companion/);
+  assert.match(agentsSource, /not git repositories, save spec\/plan files without asking/);
+  assert.match(agentsSource, /defineToolcraft/);
+  assert.match(agentsSource, /ToolcraftApp/);
+  assert.match(agentsSource, /canvasContent/);
+  assert.match(agentsSource, /renderDefaultCanvasMedia=\{false\}/);
+  assert.match(agentsSource, /onPanelAction/);
+  assert.match(agentsSource, /MIT License/);
+  assert.match(agentsSource, /LICENSE\.md/);
+  assert.match(agentsSource, /NOTICE\.md/);
+  assert.match(licenseSource, /Permission is hereby granted, free of charge/);
+  assert.match(licenseSource, /THE SOFTWARE IS PROVIDED "AS IS"/);
+  assert.match(noticeSource, /generated with Toolcraft/);
+  assert.match(noticeSource, /governed by the MIT License in `LICENSE\.md`/);
+
+  for (const localDocPath of localDocPaths) {
+    assert.match(agentsSource, new RegExp(`docs/toolcraft/${localDocPath.replace(".", "\\.")}`));
+  }
+
+  const componentRulesSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/component-rules.md"),
+    "utf8",
+  );
+  const coreControlSelectionSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/control-selection.md"),
+    "utf8",
+  );
+  const coreLayoutSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/layout.md"),
+    "utf8",
+  );
+  const coreMediaUploadSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/media-upload.md"),
+    "utf8",
+  );
+  const coreRuntimeBoundarySource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/runtime-boundary.md"),
+    "utf8",
+  );
+  const coreSetupExportSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/setup-export.md"),
+    "utf8",
+  );
+  const coreTimelineSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/core/timeline-animation.md"),
+    "utf8",
+  );
+
+  assert.match(componentRulesSource, /Slider `step` means numeric snapping only/);
+  assert.match(componentRulesSource, /variant: "discrete"/);
+  assert.match(componentRulesSource, /Keep large or precision stepped ranges visually continuous/);
+  assert.match(componentRulesSource, /Segmented Controls/);
+  assert.match(coreLayoutSource, /Bad titles: `Controls`, `Settings`, `Options`, `Sliders`, `Inputs`, `Buttons`, `Color`, `Colors`/);
+  assert.match(coreMediaUploadSource, /Use `fileDrop` for source material uploads/);
+  assert.match(coreControlSelectionSource, /Use `fileDrop` for source material uploads/);
+  assert.match(coreRuntimeBoundarySource, /appSchema\.assembly/);
+  assert.match(coreRuntimeBoundarySource, /app-composition\.tsx/);
+  assert.match(coreRuntimeBoundarySource, /signed framework bootstrap/);
+  assert.match(coreRuntimeBoundarySource, /immutable signed copy of the shared runtime/);
+  assert.match(coreRuntimeBoundarySource, /copied runtime tree or its signed integrity manifest is missing/);
+  assert.match(componentRulesSource, /Do not show Layers for a single-layer app/);
+  assert.match(coreTimelineSource, /Any app with `Export Video` must enable the top Toolcraft timeline/);
+  assert.match(coreSetupExportSource, /Still products expose `Export PNG`/);
+  assert.match(coreSetupExportSource, /Animated products expose `Export Video` plus `Export PNG`/);
+  assert.match(coreSetupExportSource, /Clipboard copy is optional and never replaces export/);
+
+  const assemblyDocsSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/assembly-workflow.md"),
+    "utf8",
+  );
+  assert.match(assemblyDocsSource, /@\/toolcraft\/runtime/);
+  assert.match(assemblyDocsSource, /ToolcraftAppComposition/);
+  assert.match(assemblyDocsSource, /protected route/);
+  assert.match(assemblyDocsSource, /transferMode: "reference-runtime-clone"/);
+  assert.match(assemblyDocsSource, /`canvasContent` must not contain app UI/);
+  assert.doesNotMatch(assemblyDocsSource, /@repo\/toolcraft-runtime/);
+
+  const acceptanceDocsSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/acceptance-testing.md"),
+    "utf8",
+  );
+  assert.match(acceptanceDocsSource, /Every visible product entity must prove it works/);
+  assert.match(acceptanceDocsSource, /automatedTestName/);
+  assert.match(acceptanceDocsSource, /browserTestName/);
+  assert.match(acceptanceDocsSource, /app-acceptance-data\.ts/);
+  assert.match(acceptanceDocsSource, /framework-owned and covered by the signed integrity manifest/);
+  assert.match(acceptanceDocsSource, /Framework meta-tests are product-invariant/);
+  assert.match(acceptanceDocsSource, /protected neutral contract fixtures/);
+  assert.match(acceptanceDocsSource, /do not edit supplied `app-performance\.\*` meta-tests/);
+
+  const rendererDocsSource = await fs.readFile(
+    path.join(targetDir, "docs/toolcraft/renderer-technique.md"),
+    "utf8",
+  );
+  assert.match(rendererDocsSource, /rendererTechnique/);
+  assert.match(rendererDocsSource, /sourceRepresentation/);
+  assert.match(rendererDocsSource, /whyNotAlternativeStrategies/);
+}

package/src/generate-test-file-assertions.mjs

@@ -0,0 +1,251 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { listRelativeFiles, readTextFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+
+export async function assertGeneratedFiles(targetDir) {
+  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/ui/index.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/runtime/react/index.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "playwright.config.ts")));
+
+  const generatedToolcraftFiles = await listRelativeFiles(
+    path.join(targetDir, "src/toolcraft"),
+  );
+  for (const relativePath of generatedToolcraftFiles) {
+    assert.equal(
+      isGeneratedTestSupportPath(relativePath),
+      false,
+      `Generated runtime contains test support: ${relativePath}`,
+    );
+  }
+
+  const removedRuntimeTestHelpers = [
+    "runtime/react/canvas/canvas-shell-test-utils.tsx",
+    "runtime/react/controls-panel/testing/controls-panel-test-utils.tsx",
+    "runtime/react/layers/layers-panel-test-utils.tsx",
+    "runtime/react/timeline/timeline-panel-test-utils.tsx",
+  ];
+  for (const relativePath of removedRuntimeTestHelpers) {
+    assert.equal(generatedToolcraftFiles.includes(relativePath), false);
+  }
+
+  const playwrightConfigSource = await fs.readFile(
+    path.join(targetDir, "playwright.config.ts"),
+    "utf8",
+  );
+  assert.match(playwrightConfigSource, /reuseExistingServer:\s*false/);
+  assert.deepEqual(
+    await listRelativeFiles(path.join(targetDir, "e2e")),
+    await listRelativeFiles(path.join(repoRoot, "starter/e2e")),
+  );
+  assert.ok(await fs.stat(path.join(targetDir, "e2e/app-controls.spec.ts")));
+
+  const generatedAppSourceFiles = await listRelativeFiles(path.join(targetDir, "src/app"));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-schema.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-schema.test.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance-data.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-composition.tsx")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance.base-coverage.test.ts")));
+  const appAcceptanceSource = await fs.readFile(
+    path.join(targetDir, "src/app/app-acceptance.ts"),
+    "utf8",
+  );
+  assert.match(appAcceptanceSource, /from "\.\/app-acceptance-data"/);
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.gates.test.ts")));
+  assert.equal(
+    generatedAppSourceFiles.some((file) => path.basename(file).startsWith("starter-")),
+    false,
+  );
+
+  assert.ok(await fs.stat(path.join(targetDir, "e2e/app-performance.spec.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "e2e/performance-helpers.ts")));
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/run-browser-performance.mjs")),
+  );
+  assert.ok(await fs.stat(path.join(targetDir, "e2e/product-observable-helpers.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "e2e/canvas-handle-helpers.ts")));
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/check-ai-skills.mjs")));
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/check-toolcraft-code-health.mjs")),
+  );
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/toolcraft-code-health-core.mjs")),
+  );
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/toolcraft-integrity-policy.mjs")),
+  );
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/toolcraft-contract-manifest.json")),
+  );
+  assert.ok(
+    await fs.stat(path.join(targetDir, "scripts/toolcraft-contract-manifest.mjs")),
+  );
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/toolcraft-port.mjs")));
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/toolcraft-port.test.mjs")));
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/check-toolcraft-docs.mjs")));
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/check-toolcraft-integrity.mjs")));
+  assert.ok(await fs.stat(path.join(targetDir, "scripts/run-vite-on-free-port.mjs")));
+  const runViteSource = await fs.readFile(
+    path.join(targetDir, "scripts/run-vite-on-free-port.mjs"),
+    "utf8",
+  );
+  assert.match(runViteSource, /node_modules/);
+  assert.match(runViteSource, /\.bin/);
+  assert.match(runViteSource, /vite\.cmd/);
+  assert.match(runViteSource, /from "cross-spawn"/);
+  assert.doesNotMatch(runViteSource, /pnpmCommand|pnpm\.cmd|pnpm",/);
+  assert.ok(await fs.stat(path.join(targetDir, "LICENSE.md")));
+  assert.ok(await fs.stat(path.join(targetDir, "NOTICE.md")));
+  const manifestPath = path.join(
+    targetDir,
+    "src/toolcraft/.toolcraft-manifest.json",
+  );
+  assert.ok(await fs.stat(manifestPath));
+
+  const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  const generatedPackageJson = JSON.parse(
+    await fs.readFile(path.join(targetDir, "package.json"), "utf8"),
+  );
+  assert.equal(manifest.version, 3);
+  assert.match(manifest.signature, /^[A-Za-z0-9+/]+={0,2}$/);
+  assert.deepEqual(
+    manifest.packageScripts,
+    Object.fromEntries(Object.entries(generatedPackageJson.scripts).sort()),
+  );
+  assert.equal(
+    manifest.packageScripts.test,
+    "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",
+  );
+  assert.ok(manifest.packageScripts["verify:final"]);
+  assert.ok(manifest.protectedFiles["AGENTS.md"]);
+  for (const relativePath of [
+    "index.html",
+    "src/main.tsx",
+    "src/router.tsx",
+    "src/routes/index.tsx",
+    "src/routes/root.tsx",
+    "src/styles.css",
+  ]) {
+    assert.ok(
+      manifest.protectedFiles[relativePath],
+      `${relativePath} must be signed as framework bootstrap.`,
+    );
+  }
+  assert.ok(
+    manifest.protectedFiles["scripts/check-toolcraft-integrity.mjs"],
+  );
+  assert.ok(
+    manifest.protectedFiles["scripts/toolcraft-integrity-manifest.mjs"],
+  );
+  assert.ok(
+    manifest.protectedFiles["scripts/toolcraft-contract-manifest.json"],
+  );
+  assert.ok(
+    manifest.protectedFiles["scripts/toolcraft-contract-manifest.mjs"],
+  );
+  assert.ok(manifest.protectedFiles["playwright.config.ts"]);
+  assert.ok(manifest.protectedFiles["tsconfig.json"]);
+  assert.ok(manifest.protectedFiles["vite.config.ts"]);
+  assert.ok(manifest.protectedFiles["src/app/app-acceptance.ts"]);
+  assert.ok(
+    manifest.protectedFiles["src/app/acceptance/validation-pipeline.ts"],
+  );
+  assert.ok(
+    manifest.protectedFiles[
+      "src/app/app-acceptance.base-coverage.test.ts"
+    ],
+  );
+  assert.ok(
+    manifest.protectedFiles[
+      "scripts/toolcraft-vitest-runtime-evidence-reporter.mjs"
+    ],
+  );
+  assert.ok(manifest.protectedFiles["e2e/browser-runtime-evidence-reporter.ts"]);
+  assert.ok(manifest.protectedFiles["e2e/browser-runtime-evidence.ts"]);
+  for (const relativePath of [
+    "e2e/performance-control-layout-helpers.ts",
+    "e2e/performance-frame-probe.ts",
+    "e2e/performance-interaction-measurement.ts",
+    "e2e/performance-render-scale-helpers.ts",
+    "e2e/performance-slider-helpers.ts",
+  ]) {
+    assert.ok(
+      manifest.protectedFiles[relativePath],
+      `${relativePath} must be signed as performance evidence infrastructure.`,
+    );
+  }
+  assert.ok(
+    manifest.protectedFiles[
+      "src/app/app-automated-runtime-evidence.test.ts"
+    ],
+  );
+  assert.ok(
+    manifest.protectedFiles["scripts/toolcraft-vitest-runtime-contract.mjs"],
+  );
+  assert.ok(manifest.protectedFiles["scripts/toolcraft-workflow-routes.mjs"]);
+  assert.ok(
+    manifest.protectedFiles["e2e/app-browser-control-coverage.spec.ts"],
+  );
+  assert.equal(
+    manifest.protectedFiles["src/app/app-acceptance-data.ts"],
+    undefined,
+  );
+  assert.equal(
+    manifest.protectedFiles["src/app/app-composition.tsx"],
+    undefined,
+  );
+  assert.equal(manifest.protectedFiles["e2e/app-controls.spec.ts"], undefined);
+}
+
+export async function assertGeneratedRoutesAndStyles(targetDir) {
+  await assert.rejects(
+    () => fs.stat(path.join(targetDir, "src/toolcraft/runtime/react/canvas-shell.test.tsx")),
+    /ENOENT/,
+  );
+
+  const routeSource = await fs.readFile(path.join(targetDir, "src/routes/index.tsx"), "utf8");
+  assert.match(routeSource, /@\/toolcraft\/runtime\/react/);
+  assert.match(routeSource, /\.\.\/app\/app-composition/);
+  assert.match(routeSource, /canvasContent=\{appComposition\.canvasContent\}/);
+  assert.match(routeSource, /controlRenderers=\{appComposition\.controlRenderers\}/);
+  assert.match(routeSource, /onPanelAction=\{appComposition\.onPanelAction\}/);
+  assert.match(
+    routeSource,
+    /renderDefaultCanvasMedia=\{appComposition\.renderDefaultCanvasMedia\}/,
+  );
+  assert.match(routeSource, /schema=\{appComposition\.schema\}/);
+  assert.match(routeSource, /className="h-dvh min-h-dvh"/);
+  assert.doesNotMatch(routeSource, /\{\.\.\.appComposition\}/);
+  assert.doesNotMatch(routeSource, /appSchema|ProductCanvas/);
+
+  const compositionSource = await fs.readFile(
+    path.join(targetDir, "src/app/app-composition.tsx"),
+    "utf8",
+  );
+  assert.match(
+    compositionSource,
+    /import type \{ ToolcraftAppComposition \} from "@\/toolcraft\/runtime\/react"/,
+  );
+  assert.match(compositionSource, /export const appComposition/);
+  assert.match(compositionSource, /appComposition\s*:\s*ToolcraftAppComposition\s*=/);
+
+  const stylesSource = await fs.readFile(path.join(targetDir, "src/styles.css"), "utf8");
+  assert.match(stylesSource, /@source "\.\/toolcraft\/ui";/);
+  assert.match(stylesSource, /@import "@\/toolcraft\/ui\/styles\.css";/);
+}
+
+export async function assertGeneratedTextIsStandalone(targetDir) {
+  const allText = await readTextFiles(targetDir);
+  assert.doesNotMatch(allText, /BEGIN PRIVATE KEY/);
+  assert.doesNotMatch(allText, /@repo\/ui|@repo\/toolcraft-runtime|workspace:/);
+  assert.doesNotMatch(allText, new RegExp("template" + "-runtime"));
+  assert.doesNotMatch(allText, /packages\/typescript-config/);
+  assert.doesNotMatch(
+    allText,
+    /starterComposition|starter-composition|starterSchema|starter-schema|starterAcceptance|starterControlSectionInventory|starter-acceptance|starterProductReadiness|starterTransferMode|starterPerformance|starter-performance|StarterHome|Toolcraft Starter/,
+  );
+}

package/src/generate-test-fs-utils.mjs

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const repoRoot = path.resolve(fileURLToPath(new URL("../..", import.meta.url)));
+
+export async function readTextFiles(rootDir) {
+  const files = [];
+
+  async function visit(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const filePath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        if (!["dist", "node_modules"].includes(entry.name)) {
+          await visit(filePath);
+        }
+        continue;
+      }
+
+      if (entry.name === "check-toolcraft-docs.mjs") {
+        continue;
+      }
+
+      if (entry.isFile() && /\.(css|html|json|md|mjs|ts|tsx)$/.test(entry.name)) {
+        files.push(await fs.readFile(filePath, "utf8"));
+      }
+    }
+  }
+
+  await visit(rootDir);
+  return files.join("\n");
+}
+
+export async function listRelativeFiles(rootDir) {
+  const files = [];
+
+  async function visit(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const filePath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        await visit(filePath);
+        continue;
+      }
+
+      if (entry.isFile()) {
+        files.push(path.relative(rootDir, filePath).split(path.sep).join("/"));
+      }
+    }
+  }
+
+  await visit(rootDir);
+  return files.sort();
+}

package/src/generate-test-integrity-assertions.mjs

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { assertGeneratedFrameworkProtection } from "./generate-test-integrity-framework-assertions.mjs";
+import { assertGeneratedManifestIntegrity } from "./generate-test-integrity-manifest-assertions.mjs";
+import { assertGeneratedOwnershipBoundaries } from "./generate-test-integrity-ownership-assertions.mjs";
+import { createGeneratedIntegrityTestContext } from "./generate-test-integrity-test-utils.mjs";
+
+export async function assertGeneratedAppPerformance(targetDir) {
+  const appPerformanceSource = await fs.readFile(
+    path.join(targetDir, "src/app/app-performance.ts"),
+    "utf8",
+  );
+  assert.match(appPerformanceSource, /defineToolcraftPerformance/);
+  assert.match(appPerformanceSource, /preferredRunner:\s*"agent-browser"/);
+  assert.match(appPerformanceSource, /fallbackRunner:\s*"playwright"/);
+  assert.match(appPerformanceSource, /agent-browser-unavailable/);
+  assert.doesNotMatch(appPerformanceSource, /function\s+validateToolcraftPerformanceCoverage/);
+  assert.doesNotMatch(appPerformanceSource, /function\s+collectToolcraftPerformanceSensitiveControls/);
+  assert.doesNotMatch(appPerformanceSource, /maxPerformanceBudgetCaps/);
+}
+
+export async function assertGeneratedIntegrityChecks(targetDir, execFileAsync) {
+  const context = createGeneratedIntegrityTestContext(targetDir, execFileAsync);
+
+  await assertGeneratedManifestIntegrity(context);
+  await assertGeneratedFrameworkProtection(context);
+  await assertGeneratedOwnershipBoundaries(context);
+}