@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/starter/e2e/video-artifact-inspection.ts

@@ -0,0 +1,281 @@
+import fs from "node:fs/promises";
+
+import type { Download, Page } from "@playwright/test";
+import {
+  ALL_FORMATS,
+  BlobSource,
+  EncodedPacketSink,
+  Input,
+} from "mediabunny";
+
+import {
+  observeToolcraftDecodedPixels,
+  type ToolcraftDecodedPixelObservation,
+} from "./decoded-pixel-observation";
+import type {
+  ToolcraftVideoArtifactInspection,
+  ToolcraftVideoPacketTiming,
+} from "./export-artifact-helpers";
+
+export type ToolcraftScheduledVideoFrame = Readonly<{
+  durationSeconds: number;
+  index: number;
+  timeSeconds: number;
+}>;
+
+export function assertToolcraftVideoPacketSchedule({
+  packetTimings,
+  schedule,
+  timeResolution,
+}: Readonly<{
+  packetTimings: readonly ToolcraftVideoPacketTiming[];
+  schedule: readonly ToolcraftScheduledVideoFrame[];
+  timeResolution: number;
+}>): void {
+  if (!Number.isFinite(timeResolution) || timeResolution <= 0) {
+    throw new Error("Video packet proof requires a positive time resolution.");
+  }
+  if (packetTimings.length !== schedule.length) {
+    throw new Error(
+      `Encoded video contains ${packetTimings.length} packets; runtime scheduled ${schedule.length}.`,
+    );
+  }
+
+  const toleranceSeconds = 1 / timeResolution;
+  for (const [index, actual] of packetTimings.entries()) {
+    const expected = schedule[index];
+    if (!expected) {
+      throw new Error(`Runtime schedule is missing frame ${index}.`);
+    }
+    if (
+      !Number.isFinite(actual.timeSeconds) ||
+      actual.timeSeconds < 0 ||
+      !Number.isFinite(actual.durationSeconds) ||
+      actual.durationSeconds <= 0
+    ) {
+      throw new Error(`Encoded packet ${index} has invalid timing metadata.`);
+    }
+    if (
+      Math.abs(actual.timeSeconds - expected.timeSeconds) > toleranceSeconds
+    ) {
+      throw new Error(
+        `Encoded packet ${index} timestamp does not match the runtime schedule.`,
+      );
+    }
+    if (
+      Math.abs(actual.durationSeconds - expected.durationSeconds) >
+      toleranceSeconds
+    ) {
+      throw new Error(
+        `Encoded packet ${index} duration does not match the runtime schedule.`,
+      );
+    }
+  }
+}
+
+export type ToolcraftInspectedVideoArtifact = Readonly<{
+  inspection: ToolcraftVideoArtifactInspection;
+  observations: readonly ToolcraftDecodedPixelObservation[];
+  sampleTimes: readonly number[];
+  timeResolution: number;
+}>;
+
+function detectVideoMediaType(bytes: Uint8Array): "video/mp4" | "video/webm" {
+  if (
+    bytes.length >= 8 &&
+    String.fromCharCode(...bytes.subarray(4, 8)) === "ftyp"
+  ) {
+    return "video/mp4";
+  }
+  if (
+    bytes.length >= 4 &&
+    bytes[0] === 0x1a &&
+    bytes[1] === 0x45 &&
+    bytes[2] === 0xdf &&
+    bytes[3] === 0xa3
+  ) {
+    return "video/webm";
+  }
+  throw new Error("Downloaded artifact is not a supported MP4 or WebM video.");
+}
+
+function getSampleTimes(
+  schedule: readonly ToolcraftScheduledVideoFrame[],
+): readonly number[] {
+  if (schedule.length === 0) {
+    throw new Error("Video inspection requires a non-empty runtime frame schedule.");
+  }
+  const indices = [...new Set([0, Math.floor(schedule.length / 2), schedule.length - 1])];
+  return Object.freeze(indices.map((index) => schedule[index]!.timeSeconds));
+}
+
+async function decodeSamplesInPage({
+  bytes,
+  mediaType,
+  page,
+  sampleTimes,
+}: Readonly<{
+  bytes: Uint8Array;
+  mediaType: "video/mp4" | "video/webm";
+  page: Page;
+  sampleTimes: readonly number[];
+}>): Promise<readonly Uint8ClampedArray[]> {
+  const samples = await page.evaluate(
+    async ({ base64, mediaType: decodedMediaType, times }) => {
+      const binary = atob(base64);
+      const data = Uint8Array.from(binary, (character) =>
+        character.charCodeAt(0),
+      );
+      const video = document.createElement("video");
+      video.muted = true;
+      video.playsInline = true;
+      video.preload = "auto";
+      const objectUrl = URL.createObjectURL(
+        new Blob([data], { type: decodedMediaType }),
+      );
+      video.src = objectUrl;
+      try {
+        await new Promise<void>((resolve, reject) => {
+          video.addEventListener("loadeddata", () => resolve(), { once: true });
+          video.addEventListener(
+            "error",
+            () => reject(new Error("Browser could not decode exported video.")),
+            { once: true },
+          );
+          video.load();
+        });
+        const canvas = document.createElement("canvas");
+        canvas.width = 64;
+        canvas.height = 64;
+        const context = canvas.getContext("2d", { willReadFrequently: true });
+        if (!context) throw new Error("Unable to inspect exported video pixels.");
+        const decodedSamples: number[][] = [];
+        for (const timeSeconds of times) {
+          if (Math.abs(video.currentTime - timeSeconds) > 1e-6) {
+            await new Promise<void>((resolve, reject) => {
+              video.addEventListener("seeked", () => resolve(), { once: true });
+              video.addEventListener(
+                "error",
+                () => reject(new Error("Browser could not seek exported video.")),
+                { once: true },
+              );
+              video.currentTime = timeSeconds;
+            });
+          }
+          context.clearRect(0, 0, 64, 64);
+          context.drawImage(video, 0, 0, 64, 64);
+          decodedSamples.push(
+            Array.from(context.getImageData(0, 0, 64, 64).data),
+          );
+        }
+        return decodedSamples;
+      } finally {
+        video.removeAttribute("src");
+        video.load();
+        URL.revokeObjectURL(objectUrl);
+      }
+    },
+    {
+      base64: Buffer.from(bytes).toString("base64"),
+      mediaType,
+      times: sampleTimes,
+    },
+  );
+  return Object.freeze(samples.map((sample) => Uint8ClampedArray.from(sample)));
+}
+
+export async function inspectToolcraftVideoDownload({
+  backgroundRgba,
+  download,
+  page,
+  schedule,
+}: Readonly<{
+  backgroundRgba: readonly [number, number, number, number];
+  download: Download;
+  page: Page;
+  schedule: readonly ToolcraftScheduledVideoFrame[];
+}>): Promise<ToolcraftInspectedVideoArtifact> {
+  const downloadPath = await download.path();
+  if (!downloadPath) {
+    throw new Error("Playwright did not expose the downloaded video path.");
+  }
+  const bytes = await fs.readFile(downloadPath);
+  if (bytes.byteLength === 0) {
+    throw new Error("Downloaded video artifact is empty.");
+  }
+  const mediaType = detectVideoMediaType(bytes);
+  const input = new Input({
+    formats: ALL_FORMATS,
+    source: new BlobSource(new Blob([bytes], { type: mediaType })),
+  });
+
+  let durationSeconds: number;
+  let height: number;
+  let packetTimings: ToolcraftVideoPacketTiming[];
+  let timeResolution: number;
+  let width: number;
+  try {
+    const tracks = await input.getVideoTracks();
+    const track = tracks[0];
+    if (!track) throw new Error("Exported video does not contain a video track.");
+    [durationSeconds, height, timeResolution, width] = await Promise.all([
+      input.computeDuration([track]),
+      track.getCodedHeight(),
+      track.getTimeResolution(),
+      track.getCodedWidth(),
+    ]);
+    packetTimings = [];
+    const sink = new EncodedPacketSink(track);
+    for await (const packet of sink.packets(undefined, undefined, {
+      metadataOnly: true,
+    })) {
+      packetTimings.push(
+        Object.freeze({
+          durationSeconds: packet.duration,
+          timeSeconds: packet.timestamp,
+        }),
+      );
+    }
+  } finally {
+    input.dispose();
+  }
+  packetTimings.sort((left, right) => left.timeSeconds - right.timeSeconds);
+
+  const sampleTimes = getSampleTimes(schedule);
+  const decodedSamples = await decodeSamplesInPage({
+    bytes,
+    mediaType,
+    page,
+    sampleTimes,
+  });
+  const observations = await Promise.all(
+    decodedSamples.map((pixels) =>
+      observeToolcraftDecodedPixels({
+        backgroundRgba,
+        pixels,
+        sourceHeight: 64,
+        sourceWidth: 64,
+      }),
+    ),
+  );
+  const inspection: ToolcraftVideoArtifactInspection = Object.freeze({
+    byteLength: bytes.byteLength,
+    durationMs: durationSeconds * 1000,
+    frameCount: packetTimings.length,
+    height,
+    kind: "video",
+    mediaType,
+    packetTimings: Object.freeze(packetTimings),
+    samplePixelHashes: Object.freeze(
+      observations.map(({ decodedPixelHash }) => decodedPixelHash),
+    ),
+    width,
+  });
+
+  return Object.freeze({
+    inspection,
+    observations: Object.freeze(observations),
+    sampleTimes,
+    timeResolution,
+  });
+}

package/templates/starter/gitignore

@@ -14,6 +14,7 @@ dist-ssr
 coverage
 test-results
 playwright-report
+.playwright-mcp
 
 # Local environment
 .env

package/templates/starter/index.html

@@ -4,6 +4,14 @@
     <meta charset="UTF-8" />
     <meta name="toolcraft-app-title" content="Toolcraft Starter" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta property="og:image" content="https://toolcraft.sh/social-previews/og-toolcraft-v2.jpg" />
+    <meta property="og:image:type" content="image/jpeg" />
+    <meta property="og:image:width" content="1200" />
+    <meta property="og:image:height" content="630" />
+    <meta property="og:image:alt" content="Toolcraft — build powerful design tools with AI" />
+    <meta name="twitter:card" content="summary_large_image" />
+    <meta name="twitter:image" content="https://toolcraft.sh/social-previews/og-toolcraft-v2.jpg" />
+    <meta name="twitter:image:alt" content="Toolcraft — build powerful design tools with AI" />
     <title>Toolcraft Starter</title>
   </head>
   <body>

package/templates/starter/package.json

@@ -4,7 +4,7 @@
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "ai:check": "node scripts/check-toolcraft-code-health.mjs && node scripts/toolcraft-product-boundary.mjs --allow-missing-compiler && node scripts/check-ai-skills.mjs",
+    "ai:check": "node scripts/check-toolcraft-code-health.mjs",
     "dev": "node scripts/run-vite-on-free-port.mjs dev",
     "dev:restart": "node scripts/run-vite-on-free-port.mjs dev --toolcraft-restart",
     "build": "tsc -p tsconfig.json --noEmit && vite build",
@@ -13,16 +13,12 @@
     "docs:check": "node scripts/check-toolcraft-docs.mjs",
     "test": "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",
     "test:generated": "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",
-    "test:browser": "playwright install chromium && playwright test --grep-invert \"browser perf:\"",
-    "test:browser:perf": "node scripts/run-browser-performance.mjs",
+    "test:browser": "playwright install chromium && playwright test --grep-invert \"browser perf:|toolcraft kernel:\"",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "verify:quick": "pnpm ai:check && pnpm test",
-    "verify:ui": "pnpm test:browser",
-    "verify:perf": "pnpm test:browser:perf",
-    "verify:perf:playwright": "pnpm test:browser:perf",
-    "verify:perf:record-exemption": "node scripts/toolcraft-verification-receipt.mjs record-exemption",
-    "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
-    "verify:final": "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser && pnpm verify:receipt"
+    "verify:delivery": "node scripts/run-delivery-verification.mjs",
+    "verify:perf": "node scripts/run-browser-performance.mjs",
+    "verify:kernel": "node scripts/run-kernel-benchmarks.mjs",
+    "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate"
   },
   "dependencies": {
     "@base-ui/react": "^1.4.1",
@@ -30,6 +26,8 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@fontsource-variable/inter": "^5.2.8",
+    "@gltf-transform/core": "4.4.1",
+    "@gltf-transform/extensions": "4.4.1",
     "@phosphor-icons/react": "^2.1.10",
     "@repo/toolcraft-runtime": "workspace:*",
     "@repo/ui": "workspace:*",
@@ -38,13 +36,17 @@
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "cross-spawn": "^7.0.6",
+    "fflate": "0.8.3",
     "lucide-react": "^0.511.0",
+    "mediabunny": "1.52.2",
+    "meshoptimizer": "1.2.0",
     "motion": "^11.16.3",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-resizable-panels": "^4.10.0",
     "sonner": "^2.0.7",
-    "tailwind-merge": "^3.5.0"
+    "tailwind-merge": "^3.5.0",
+    "three": "0.185.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.51.1",
@@ -54,7 +56,9 @@
     "@types/node": "22.19.19",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
+    "@types/three": "0.185.0",
     "@vitejs/plugin-react": "^6.0.1",
+    "fake-indexeddb": "6.2.5",
     "tailwindcss": "^4.1.18",
     "tw-animate-css": "^1.4.0",
     "typescript": "^6.0.3",

package/templates/starter/playwright.config.ts

@@ -17,10 +17,118 @@ const testPort =
 const testBaseUrl = `http://localhost:${testPort}`;
 const browserServerMode =
   process.env.TOOLCRAFT_BROWSER_SERVER_MODE === "preview" ? "preview" : "dev";
+const browserExecutionLedgerValues = {
+  directory: process.env.TOOLCRAFT_BROWSER_EXECUTION_LEDGER_DIRECTORY,
+  nonce: process.env.TOOLCRAFT_BROWSER_EXECUTION_LEDGER_NONCE,
+};
+const hasAnyBrowserExecutionLedgerValue =
+  Object.values(browserExecutionLedgerValues).some(Boolean);
+const hasAllBrowserExecutionLedgerValues =
+  Object.values(browserExecutionLedgerValues).every(Boolean);
+if (
+  hasAnyBrowserExecutionLedgerValue &&
+  !hasAllBrowserExecutionLedgerValues
+) {
+  throw new Error(
+    "Toolcraft browser execution ledger requires nonce and directory together.",
+  );
+}
+const browserExecutionLedger = hasAllBrowserExecutionLedgerValues
+  ? {
+      nonce: browserExecutionLedgerValues.nonce!,
+      directory: browserExecutionLedgerValues.directory!,
+    }
+  : undefined;
+const performanceReportValues = {
+  nonce: process.env.TOOLCRAFT_PERFORMANCE_REPORT_NONCE,
+  path: process.env.TOOLCRAFT_PERFORMANCE_REPORT_PATH,
+  sourceHash: process.env.TOOLCRAFT_PERFORMANCE_REPORT_SOURCE_HASH,
+};
+const hasAnyPerformanceReportValue = Object.values(performanceReportValues).some(Boolean);
+const hasAllPerformanceReportValues = Object.values(performanceReportValues).every(Boolean);
+if (hasAnyPerformanceReportValue && !hasAllPerformanceReportValues) {
+  throw new Error(
+    "Toolcraft protected performance reporting requires nonce, path, and source hash together.",
+  );
+}
+const checkpointReport = hasAllPerformanceReportValues
+  ? {
+      nonce: performanceReportValues.nonce!,
+      path: performanceReportValues.path!,
+      sourceHash: performanceReportValues.sourceHash!,
+    }
+  : undefined;
+const targetedPerformanceReportValues = {
+  fixtureResolutionMode:
+    process.env.TOOLCRAFT_PERFORMANCE_FIXTURE_RESOLUTION_MODE,
+  fixtureSelector: process.env.TOOLCRAFT_PERFORMANCE_FIXTURE_SELECTOR,
+  nonce: process.env.TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_NONCE,
+  passIds: process.env.TOOLCRAFT_TARGETED_PERFORMANCE_PASS_IDS,
+  path: process.env.TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_PATH,
+  pathIds: process.env.TOOLCRAFT_TARGETED_PERFORMANCE_PATH_IDS,
+  requestAuthorityHash:
+    process.env.TOOLCRAFT_PERFORMANCE_REQUEST_AUTHORITY_HASH,
+  sourceHash: process.env.TOOLCRAFT_TARGETED_PERFORMANCE_REPORT_SOURCE_HASH,
+};
+const targetedPerformanceAuthorityValues = [
+  targetedPerformanceReportValues.nonce,
+  targetedPerformanceReportValues.passIds,
+  targetedPerformanceReportValues.path,
+  targetedPerformanceReportValues.pathIds,
+  targetedPerformanceReportValues.requestAuthorityHash,
+  targetedPerformanceReportValues.sourceHash,
+];
+const hasAnyTargetedPerformanceReportValue =
+  targetedPerformanceReportValues.fixtureResolutionMode ===
+    "strict-development" ||
+  targetedPerformanceReportValues.fixtureSelector === "development" ||
+  targetedPerformanceAuthorityValues.some(Boolean);
+const hasAllTargetedPerformanceReportValues = Object.values(
+  targetedPerformanceReportValues,
+).every(Boolean);
+if (
+  hasAnyTargetedPerformanceReportValue &&
+  !hasAllTargetedPerformanceReportValues
+) {
+  throw new Error(
+    "Toolcraft targeted performance reporting requires fixture selector, fixture resolution mode, nonce, pass ids, path ids, path, request authority hash, and source hash together.",
+  );
+}
+if (
+  hasAllTargetedPerformanceReportValues &&
+  (
+    targetedPerformanceReportValues.fixtureResolutionMode !==
+      "strict-development" ||
+    targetedPerformanceReportValues.fixtureSelector !== "development" ||
+    !/^[a-f0-9]{64}$/u.test(
+      targetedPerformanceReportValues.requestAuthorityHash!,
+    )
+  )
+) {
+  throw new Error(
+    "Toolcraft targeted performance reporting requires strict development fixtures and canonical request authority.",
+  );
+}
+const targetedPerformanceReport = hasAllTargetedPerformanceReportValues
+  ? {
+      nonce: targetedPerformanceReportValues.nonce!,
+      fixtureResolutionMode:
+        targetedPerformanceReportValues.fixtureResolutionMode!,
+      fixtureSelector: targetedPerformanceReportValues.fixtureSelector!,
+      passIds: JSON.parse(targetedPerformanceReportValues.passIds!) as string[],
+      path: targetedPerformanceReportValues.path!,
+      pathIds: JSON.parse(targetedPerformanceReportValues.pathIds!) as string[],
+      requestAuthorityHash:
+        targetedPerformanceReportValues.requestAuthorityHash!,
+      sourceHash: targetedPerformanceReportValues.sourceHash!,
+    }
+  : undefined;
 process.env[resolvedTestPortEnvName] = String(testPort);
 
 if (!resolvedTestPort && testPort !== preferredTestPort) {
-  console.log(`[toolcraft] Browser test port ${preferredTestPort} is busy; using ${testPort} instead.`);
+  console.error(
+    `[toolcraft] Browser test port ${preferredTestPort} is busy; using ${testPort} instead.`,
+  );
 }
 
 export default defineConfig({
@@ -31,14 +139,28 @@ export default defineConfig({
     timeout: 5_000,
   },
   fullyParallel: false,
-  reporter: [["list"], ["./e2e/browser-runtime-evidence-reporter.ts"]],
+  reporter: [
+    ["list"],
+    [
+      "./e2e/browser-runtime-evidence-reporter.ts",
+      {
+        browserExecutionLedger,
+        checkpointReport,
+        targetedPerformanceReport,
+      },
+    ],
+  ],
   use: {
     ...devices["Desktop Chrome"],
     baseURL: testBaseUrl,
+    viewport: { height: 720, width: 1280 },
     trace: "retain-on-failure",
   },
   webServer: {
     command: `pnpm exec vite ${browserServerMode} --host 127.0.0.1 --port ${testPort} --strictPort`,
+    env: {
+      VITE_TOOLCRAFT_BROWSER_PROOF_FIXTURES: "unavailable-resource",
+    },
     reuseExistingServer: false,
     timeout: 60_000,
     url: testBaseUrl,

package/templates/starter/scripts/check-toolcraft-code-health.mjs

@@ -4,17 +4,17 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { isToolcraftTypeScriptCompilerAvailable } from "./toolcraft-typescript-source-evidence.mjs";
 import {
-  codeHealthPassed,
-  evaluateCodeHealth,
-  printCodeHealthResult,
-} from "./toolcraft-code-health-core.mjs";
-import { loadToolcraftLocalModuleAliases } from "./toolcraft-product-dependency-graph.mjs";
-import { collectToolcraftFrameworkOwnedLocalPaths } from "./toolcraft-source-ownership.mjs";
+  createToolcraftScriptLineBudgetPolicy,
+  getToolcraftScriptProductionEntryPaths,
+} from "./toolcraft-delivery-architecture-policy.mjs";
 
 const scriptPath = fileURLToPath(import.meta.url);
 const appRoot = path.resolve(path.dirname(scriptPath), "..");
 
+const scriptLineBudgetPolicy =
+  createToolcraftScriptLineBudgetPolicy("scripts");
 const generatedCodeHealthPolicy = {
   globalLineBudget: {
     maxLines: 1000,
@@ -47,43 +47,90 @@ const generatedCodeHealthPolicy = {
       prefix: "e2e/",
       reason: "Generated browser tests should stay split by behavior and evidence role.",
     },
-    {
-      maxLines: 350,
-      prefix: "scripts/",
-      reason: "Generated operational scripts should stay focused and independently testable.",
-    },
+    ...scriptLineBudgetPolicy.scopedLineBudgets,
   ],
   sourceRoots: ["src", "e2e", "scripts"],
-  testLineBudget: {
-    maxLines: 500,
-    reason: "Generated test/spec files should stay focused instead of becoming behavior dumps.",
-  },
+  testFilePatterns: scriptLineBudgetPolicy.testFilePatterns,
+  testLineBudget: scriptLineBudgetPolicy.testLineBudget,
 };
 
 export async function evaluateGeneratedCodeHealth(rootDir = appRoot) {
-  const [dependencyCycleAliases, frameworkOwnedLocalPaths] = await Promise.all([
-    loadToolcraftLocalModuleAliases({
+  const [
+    { evaluateCodeHealth },
+    { createToolcraftLocalDependencyGraph },
+    { evaluateToolcraftProductBoundary },
+    dependencyResolution,
+    { collectToolcraftSourceInventory },
+    { collectToolcraftFrameworkOwnedLocalPaths },
+  ] = await Promise.all([
+    import("./toolcraft-code-health-core.mjs"),
+    import("./toolcraft-local-dependency-graph.mjs"),
+    import("./toolcraft-product-boundary.mjs"),
+    import("./toolcraft-product-dependency-resolution.mjs"),
+    import("./toolcraft-source-inventory.mjs"),
+    import("./toolcraft-source-ownership.mjs"),
+  ]);
+  const [configuredAliases, frameworkOwnedLocalPaths] = await Promise.all([
+    dependencyResolution.loadToolcraftLocalModuleAliases({
       rootDir,
       tsconfigPaths: ["tsconfig.json"],
     }),
     collectToolcraftFrameworkOwnedLocalPaths(rootDir),
   ]);
-  return evaluateCodeHealth({
+  const dependencyCycleAliases = [
+    ...configuredAliases,
+    ...dependencyResolution.createToolcraftDefaultSourceAliases(rootDir),
+  ];
+  const inventory = await collectToolcraftSourceInventory({
+    frameworkPathPrefixes: ["src/toolcraft/"],
+    includeResourceFiles: true,
+    protectedFilePaths: frameworkOwnedLocalPaths,
+    rootDir,
+    sourceRoots: generatedCodeHealthPolicy.sourceRoots,
+  });
+  const localDependencyGraph = await createToolcraftLocalDependencyGraph({
+    aliases: dependencyCycleAliases,
+    entries: inventory.entries,
+    rootDir,
+  });
+  const codeHealth = await evaluateCodeHealth({
     ...generatedCodeHealthPolicy,
     dependencyCycleAliases,
     dependencyCycleIncludedFilePatterns: [/^src\//u],
     frameworkPathPrefixes: ["src/toolcraft/"],
+    inventory,
+    localDependencyGraph,
+    productionEntryPaths: getToolcraftScriptProductionEntryPaths("scripts"),
     protectedFilePaths: frameworkOwnedLocalPaths,
     rootDir,
   });
+  return {
+    ...codeHealth,
+    productBoundary: await evaluateToolcraftProductBoundary({
+      aliases: dependencyCycleAliases,
+      inventory,
+      localDependencyGraph,
+      protectedFilePaths: frameworkOwnedLocalPaths,
+      rootDir,
+    }),
+  };
 }
 
 export async function runGeneratedCodeHealth({
   logger = console,
   rootDir = appRoot,
 } = {}) {
-  const result = await evaluateGeneratedCodeHealth(rootDir);
+  if (!isToolcraftTypeScriptCompilerAvailable()) {
+    logger.log(
+      "Toolcraft code health check passed (dependency-backed graph and AST checks are deferred until dependencies are installed).",
+    );
+    return true;
+  }
 
+  const result = await evaluateGeneratedCodeHealth(rootDir);
+  const { codeHealthPassed, printCodeHealthResult } = await import(
+    "./toolcraft-code-health-core.mjs"
+  );
   printCodeHealthResult(result, logger);
   if (!codeHealthPassed(result)) {
     logger.error(