@pixel-point/toolcraft 0.0.16 → 0.0.18

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

@@ -6,8 +6,14 @@ import {
   assertGeneratedDeliveryArchitecture,
   deliveryArchitecturePaths,
 } from "./generate-test-delivery-architecture-assertions.mjs";
-import { listRelativeFiles, readTextFiles, repoRoot } from "./generate-test-fs-utils.mjs";
-import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+import { listRelativeFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { assertGeneratedPerformanceCanvasBoundary } from "./generate-test-performance-boundary-assertions.mjs";
+import { assertGeneratedRuntimePublicBoundary } from "./generate-test-runtime-boundary-assertions.mjs";
+
+export {
+  assertGeneratedRoutesAndStyles,
+  assertGeneratedTextIsStandalone,
+} from "./generate-test-output-assertions.mjs";
 
 function assertSignedProtectedFiles(manifest, relativePaths, responsibility) {
   for (const relativePath of relativePaths) {
@@ -38,16 +44,7 @@ export async function assertGeneratedFiles(targetDir) {
     "scripts/toolcraft-targeted-verification-selection.mjs",
   ];
 
-  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,
-        "src/toolcraft/runtime/model-import/worker/model-import.worker.bundle.js",
-      ),
-    ),
-  );
+  await assertGeneratedRuntimePublicBoundary(targetDir);
   assert.ok(await fs.stat(path.join(targetDir, "playwright.config.ts")));
   await assert.rejects(
     fs.stat(path.join(targetDir, ".toolcraft")),
@@ -55,37 +52,6 @@ export async function assertGeneratedFiles(targetDir) {
     "Fresh generated apps must not inherit starter server ports or verification receipts.",
   );
 
-  const generatedToolcraftFiles = await listRelativeFiles(
-    path.join(targetDir, "src/toolcraft"),
-  );
-  const expectedRuntimeFiles = (await listRelativeFiles(
-    path.join(repoRoot, "packages/toolcraft-runtime/src"),
-  ))
-    .filter((relativePath) => !isGeneratedTestSupportPath(relativePath))
-    .map((relativePath) => `runtime/${relativePath}`);
-  assert.deepEqual(
-    generatedToolcraftFiles.filter((relativePath) => relativePath.startsWith("runtime/")),
-    expectedRuntimeFiles,
-    "Generated standalone runtime must contain every production runtime module.",
-  );
-  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",
@@ -96,9 +62,7 @@ export async function assertGeneratedFiles(targetDir) {
     await listRelativeFiles(path.join(repoRoot, "starter/e2e")),
   );
   assert.ok(await fs.stat(path.join(targetDir, "e2e/app-controls.spec.ts")));
-  assert.ok(
-    await fs.stat(path.join(targetDir, "e2e/app-performance-path-adapters.ts")),
-  );
+  await assertGeneratedPerformanceCanvasBoundary(targetDir);
 
   const generatedAppSourceFiles = await listRelativeFiles(path.join(targetDir, "src/app"));
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-schema.ts")));
@@ -107,11 +71,35 @@ export async function assertGeneratedFiles(targetDir) {
   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")));
+  assert.ok(
+    await fs.stat(
+      path.join(
+        targetDir,
+        "src/app/acceptance/control-section-entity-cohesion.ts",
+      ),
+    ),
+  );
+  const generatedApplicabilityValidatorSource = await fs.readFile(
+    path.join(targetDir, "src/app/acceptance/control-applicability.ts"),
+    "utf8",
+  );
+  assert.match(
+    generatedApplicabilityValidatorSource,
+    /getToolcraftControlApplicabilityErrors/,
+  );
   const appAcceptanceSource = await fs.readFile(
     path.join(targetDir, "src/app/app-acceptance.ts"),
     "utf8",
   );
   assert.match(appAcceptanceSource, /from "\.\/app-acceptance-data"/);
+  const generatedValidationPipeline = await fs.readFile(
+    path.join(targetDir, "src/app/acceptance/validate-coverage.ts"),
+    "utf8",
+  );
+  assert.match(
+    generatedValidationPipeline,
+    /validate:\s*\(\{ sectionInventory \}\)\s*=>\s*getToolcraftControlSectionEntityCohesionErrors\(sectionInventory\)/,
+  );
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.ts")));
   assert.ok(
     await fs.stat(path.join(targetDir, "src/app/app-verification-impact.json")),
@@ -350,6 +338,8 @@ export async function assertGeneratedFiles(targetDir) {
     "e2e/performance-measurement-evidence.ts",
     "e2e/performance-path-adapter-contract.ts",
     "e2e/performance-path-helpers.ts",
+    "e2e/performance-canvas-quality-observer.ts",
+    "e2e/performance-canvas-quality-guard.ts",
     "e2e/performance-slider-helpers.ts",
     "scripts/toolcraft-performance-report.mjs",
     "scripts/toolcraft-kernel-benchmark-receipt.mjs",
@@ -415,75 +405,3 @@ export async function assertGeneratedFiles(targetDir) {
     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, /modelPresentation=\{appComposition\.modelPresentation\}/);
-  assert.match(routeSource, /onPanelAction=\{appComposition\.onPanelAction\}/);
-  assert.match(
-    routeSource,
-    /renderDefaultCanvasMedia=\{appComposition\.renderDefaultCanvasMedia\}/,
-  );
-  assert.match(
-    routeSource,
-    /rendererPipelineRegistration=\{appComposition\.rendererPipelineRegistration\}/,
-  );
-  assert.match(
-    routeSource,
-    /sceneBoundsProvider=\{appComposition\.sceneBoundsProvider\}/,
-  );
-  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*=/);
-  assert.match(compositionSource, /modelPresentation:\s*\{\s*mode:\s*"runtime"\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,
-    /prototype-smoke|browser-functional-smoke|performance-smoke|app-performance-smoke|toolcraft-performance-smoke-runner/,
-  );
-  assert.doesNotMatch(
-    allText,
-    /starterComposition|starter-composition|starterSchema|starter-schema|starterAcceptance|starterControlSectionInventory|starter-acceptance|starterProductReadiness|starterTransferMode|starterPerformance|starter-performance|StarterHome|Toolcraft Starter/,
-  );
-
-  const kernelReceiptDeclaration = await fs.readFile(
-    path.join(targetDir, "scripts/toolcraft-kernel-benchmark-receipt.d.mts"),
-    "utf8",
-  );
-  assert.match(
-    kernelReceiptDeclaration,
-    /from "@\/toolcraft\/runtime"/,
-  );
-}

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

@@ -0,0 +1,95 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { readTextFiles } from "./generate-test-fs-utils.mjs";
+
+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, /modelPresentation=\{appComposition\.modelPresentation\}/);
+  assert.match(routeSource, /onPanelAction=\{appComposition\.onPanelAction\}/);
+  assert.match(
+    routeSource,
+    /renderDefaultCanvasMedia=\{appComposition\.renderDefaultCanvasMedia\}/,
+  );
+  assert.match(
+    routeSource,
+    /rendererPipelineRegistration=\{appComposition\.rendererPipelineRegistration\}/,
+  );
+  assert.match(
+    routeSource,
+    /sceneBoundsProvider=\{appComposition\.sceneBoundsProvider\}/,
+  );
+  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*=/,
+  );
+  assert.match(
+    compositionSource,
+    /modelPresentation:\s*\{\s*mode:\s*"runtime"\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,
+    /prototype-smoke|browser-functional-smoke|performance-smoke|app-performance-smoke|toolcraft-performance-smoke-runner/,
+  );
+  assert.doesNotMatch(
+    allText,
+    /starterComposition|starter-composition|starterSchema|starter-schema|starterAcceptance|starterControlSectionInventory|starter-acceptance|starterProductReadiness|starterTransferMode|starterPerformance|starter-performance|StarterHome|Toolcraft Starter/,
+  );
+
+  const kernelReceiptDeclaration = await fs.readFile(
+    path.join(
+      targetDir,
+      "scripts/toolcraft-kernel-benchmark-receipt.d.mts",
+    ),
+    "utf8",
+  );
+  assert.match(kernelReceiptDeclaration, /from "@\/toolcraft\/runtime"/);
+}

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

@@ -16,6 +16,11 @@ export async function assertGeneratedPackageJson(targetDir) {
   assert.equal(packageJson.dependencies.fflate, "0.8.3");
   assert.equal(packageJson.dependencies.draco3dgltf, undefined);
   assert.equal(packageJson.dependencies.meshoptimizer, "1.2.0");
+  assert.equal(
+    packageJson.dependencies.mediabunny,
+    "1.52.2",
+    "Generated apps must pin the runtime-owned timestamped video encoder.",
+  );
   assert.equal(packageJson.dependencies["react-resizable-panels"], "^4.10.0");
   assert.equal(packageJson.dependencies.sonner, "^2.0.7");
   assert.equal(packageJson.dependencies.three, "0.185.1");
@@ -76,6 +81,7 @@ export async function assertGeneratedGitignore(targetDir) {
   assert.match(gitignoreSource, /node_modules/);
   assert.match(gitignoreSource, /dist/);
   assert.match(gitignoreSource, /playwright-report/);
+  assert.match(gitignoreSource, /^\.playwright-mcp$/mu);
   assert.match(gitignoreSource, /\.env\.\*/);
   assert.match(gitignoreSource, /\.toolcraft/);
   await assert.rejects(() => fs.stat(path.join(targetDir, "gitignore")), /ENOENT/);

package/src/generate-test-performance-boundary-assertions.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export async function assertGeneratedPerformanceCanvasBoundary(targetDir) {
+  const [
+    adaptersSource,
+    adapterContractSource,
+    guardSource,
+    helpersSource,
+  ] = await Promise.all([
+    fs.readFile(
+      path.join(targetDir, "e2e/app-performance-path-adapters.ts"),
+      "utf8",
+    ),
+    fs.readFile(
+      path.join(targetDir, "e2e/performance-path-adapter-contract.ts"),
+      "utf8",
+    ),
+    fs.readFile(
+      path.join(targetDir, "e2e/performance-canvas-quality-guard.ts"),
+      "utf8",
+    ),
+    fs.readFile(
+      path.join(targetDir, "e2e/performance-path-helpers.ts"),
+      "utf8",
+    ),
+    fs.stat(path.join(targetDir, "e2e/performance-canvas-quality-observer.ts")),
+    fs.stat(
+      path.join(targetDir, "e2e/performance-canvas-quality-guard.spec.ts"),
+    ),
+  ]);
+
+  assert.match(adaptersSource, /appPerformanceCanvasBacking/u);
+  assert.doesNotMatch(adapterContractSource, /renderScaleBacking\?:/u);
+  assert.match(helpersSource, /schema\.canvas\.renderScale\.enabled/u);
+  assert.match(
+    guardSource,
+    /from "\.\/performance-canvas-quality-observer"/u,
+  );
+  assert.match(
+    helpersSource,
+    /from "\.\/performance-canvas-quality-guard"/u,
+  );
+}

package/src/generate-test-product-fixture.mjs

@@ -38,6 +38,7 @@ export const generatedProductFixturePaths = Object.freeze([
   "e2e/product-canvas.spec.ts",
   "e2e/product-export.spec.ts",
   "e2e/product-material.spec.ts",
+  "e2e/product-media-export-fixture.ts",
   "e2e/product-runtime.spec.ts",
   "e2e/product-test-utils.ts",
   generatedProductPresentationResourcePath,

package/src/generate-test-product-fixture.test.mjs

@@ -15,6 +15,11 @@ import {
   writeGeneratedProductFixture,
 } from "./generate-test-product-fixture.mjs";
 
+const generatedProductFixtureRoot = new URL(
+  "../fixtures/generated-product/",
+  import.meta.url,
+);
+
 it("rejects unknown and missing product fixture paths", () => {
   assert.deepEqual(generatedProductAuthorityFixturePaths, [
     "docs/toolcraft/agent-worklog.md",
@@ -106,6 +111,19 @@ it("rejects unknown and missing product fixture paths", () => {
   );
 });
 
+it("keeps the vector product overlay explicit about canvas backing", async () => {
+  const adaptersSource = await fs.readFile(
+    new URL("e2e/app-performance-path-adapters.ts", generatedProductFixtureRoot),
+    "utf8",
+  );
+
+  assert.match(adaptersSource, /ToolcraftPerformanceCanvasBacking/u);
+  assert.match(
+    adaptersSource,
+    /appPerformanceCanvasBacking[\s\S]*undefined\s*=\s*undefined/u,
+  );
+});
+
 it("reads only an exact supported command from generated authority policy", async () => {
   const targetDir = await fs.mkdtemp(
     path.join(os.tmpdir(), "toolcraft-product-manager-"),

package/src/generate-test-product-iteration.mjs

@@ -21,6 +21,7 @@ export const generatedProductMaterialIterationFixturePaths = Object.freeze([
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
   "src/app/app-verification-impact.json",
+  "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",
   "src/app/material-schema.ts",

package/src/generate-test-product-iteration.test.mjs

@@ -11,6 +11,11 @@ import {
   generatedProductMaterialIterationFixturePaths,
 } from "./generate-test-product-iteration.mjs";
 
+const materialIterationFixtureRoot = new URL(
+  "../fixtures/generated-product-material-iteration/",
+  import.meta.url,
+);
+
 const expectedPaths = [
   "e2e/product-material.spec.ts",
   "public/material-chocolate.svg",
@@ -18,6 +23,7 @@ const expectedPaths = [
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
   "src/app/app-verification-impact.json",
+  "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",
   "src/app/material-schema.ts",
@@ -82,6 +88,18 @@ it("keeps the material iteration overlay exact and immutable", () => {
   );
 });
 
+it("keeps the material iteration video request explicit", async () => {
+  const acceptanceSource = await fs.readFile(
+    new URL("src/app/app-acceptance-data.ts", materialIterationFixtureRoot),
+    "utf8",
+  );
+
+  assert.match(
+    acceptanceSource,
+    /video:\s*\{\s*evidence:\s*"The generated export validation fixture explicitly requests one-second video export coverage\.",\s*mode: "user-requested",\s*\}/u,
+  );
+});
+
 it("atomically applies only the material product overlay", async () => {
   const targetDir = await fs.mkdtemp(
     path.join(os.tmpdir(), "toolcraft-material-iteration-target-"),

package/src/generate-test-runtime-boundary-assertions.mjs

@@ -0,0 +1,158 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { listRelativeFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+
+const productSafeRuntimeExportIndex = [
+  'export {',
+  '  toolcraftImageExportFormatTarget,',
+  '  toolcraftImageExportResolutionTarget,',
+  '  toolcraftVideoExportFormatTarget,',
+  '  toolcraftVideoExportResolutionTarget,',
+  '} from "./artifact-export-settings";',
+  'export type {',
+  '  ToolcraftImageExportFormat,',
+  '  ToolcraftImageExportPresetResolution,',
+  '  ToolcraftResolvedImageExportSettings,',
+  '  ToolcraftResolvedVideoExportSettings,',
+  '  ToolcraftVideoExportFormat,',
+  '  ToolcraftVideoExportPresetResolution,',
+  '} from "./artifact-export-settings";',
+  'export { shouldIncludeToolcraftPreviewBackground } from "./export-background";',
+  'export type { ToolcraftPreviewBackgroundOptions } from "./export-background";',
+  'export {',
+  '  TOOLCRAFT_MAX_EXPORT_EDGE_PX,',
+  '  TOOLCRAFT_MAX_EXPORT_PIXELS,',
+  '  validateToolcraftArtifactSize,',
+  '} from "./export-frame";',
+  'export type {',
+  '  ToolcraftArtifactSize,',
+  '  ToolcraftExportFrame,',
+  '} from "./export-frame";',
+  'export {',
+  '  getToolcraftImageExportSize,',
+  '  getToolcraftRetinaExportPixelRatio,',
+  '  getToolcraftRetinaExportSize,',
+  '  getToolcraftVideoExportSize,',
+  '} from "./export-sizing";',
+  'export type {',
+  '  ToolcraftExportSizeOptions,',
+  '  ToolcraftImageExportResolution,',
+  '  ToolcraftImageExportSizeOptions,',
+  '  ToolcraftRetinaExportSize,',
+  '  ToolcraftVideoExportResolution,',
+  '  ToolcraftVideoExportSizeOptions,',
+  '} from "./export-sizing";',
+  'export type {',
+  '  ToolcraftProductExportFrameContext,',
+  '  ToolcraftProductExportFrameRenderer,',
+  '  ToolcraftProductExportRenderer,',
+  '} from "./product-export-renderer";',
+  '',
+].join("\n");
+
+const requiredRuntimeExportImplementationPaths = [
+  "runtime/export/artifact-export-settings.ts",
+  "runtime/export/artifact-export-request.ts",
+  "runtime/export/artifact-frame-renderer.ts",
+  "runtime/export/artifact-frame-state.ts",
+  "runtime/export/artifact-scene-frame.ts",
+  "runtime/export/image-artifact-export.ts",
+  "runtime/export/product-export-renderer.ts",
+  "runtime/export/video-artifact-export.ts",
+  "runtime/export/video-encoding-backend.ts",
+  "runtime/export/video-frame-schedule.ts",
+];
+
+const generatedMediaExportEvidencePaths = [
+  "e2e/browser-media-export-evidence.ts",
+  "e2e/decoded-pixel-observation.ts",
+  "e2e/image-artifact-inspection.ts",
+  "e2e/video-artifact-inspection.ts",
+];
+
+const removedRuntimeTestHelperPaths = [
+  "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",
+];
+
+export async function assertGeneratedRuntimePublicBoundary(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")));
+
+  const generatedRuntimeRootSource = await fs.readFile(
+    path.join(targetDir, "src/toolcraft/runtime/index.ts"),
+    "utf8",
+  );
+  assert.match(generatedRuntimeRootSource, /export \* from "\.\/export";/u);
+  assert.doesNotMatch(
+    generatedRuntimeRootSource,
+    /exportToolcraft(?:Image|Video)Artifact|createToolcraftVideoEncoderBackend/u,
+  );
+
+  const generatedRuntimeExportIndexSource = await fs.readFile(
+    path.join(targetDir, "src/toolcraft/runtime/export/index.ts"),
+    "utf8",
+  );
+  assert.equal(
+    generatedRuntimeExportIndexSource,
+    productSafeRuntimeExportIndex,
+    "Generated runtime export index must expose the exact product-safe allowlist.",
+  );
+
+  assert.ok(
+    await fs.stat(
+      path.join(
+        targetDir,
+        "src/toolcraft/runtime/model-import/worker/model-import.worker.bundle.js",
+      ),
+    ),
+  );
+
+  const generatedToolcraftFiles = await listRelativeFiles(
+    path.join(targetDir, "src/toolcraft"),
+  );
+  const expectedRuntimeFiles = (await listRelativeFiles(
+    path.join(repoRoot, "packages/toolcraft-runtime/src"),
+  ))
+    .filter((relativePath) => !isGeneratedTestSupportPath(relativePath))
+    .map((relativePath) => `runtime/${relativePath}`);
+  assert.deepEqual(
+    generatedToolcraftFiles.filter((relativePath) => relativePath.startsWith("runtime/")),
+    expectedRuntimeFiles,
+    "Generated standalone runtime must contain every production runtime module.",
+  );
+
+  for (const relativePath of requiredRuntimeExportImplementationPaths) {
+    assert.ok(
+      generatedToolcraftFiles.includes(relativePath),
+      `Generated runtime must contain ${relativePath}.`,
+    );
+  }
+  assert.equal(
+    generatedToolcraftFiles.includes("runtime/export/export.ts"),
+    false,
+    "Generated runtime must not copy the removed legacy export helper.",
+  );
+
+  for (const relativePath of generatedMediaExportEvidencePaths) {
+    assert.ok(
+      await fs.stat(path.join(targetDir, relativePath)),
+      `Generated output must contain ${relativePath}.`,
+    );
+  }
+  for (const relativePath of generatedToolcraftFiles) {
+    assert.equal(
+      isGeneratedTestSupportPath(relativePath),
+      false,
+      `Generated runtime contains test support: ${relativePath}`,
+    );
+  }
+  for (const relativePath of removedRuntimeTestHelperPaths) {
+    assert.equal(generatedToolcraftFiles.includes(relativePath), false);
+  }
+}

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

@@ -87,6 +87,16 @@ export async function assertGeneratedProductStandalone({ execFileAsync, targetDi
   await writeGeneratedProductFixture(targetDir);
   await assertGeneratedProductWorklog(targetDir);
 
+  const appSchemaSource = await fs.readFile(
+    path.join(targetDir, "src/app/app-schema.ts"),
+    "utf8",
+  );
+  assert.match(
+    appSchemaSource,
+    /applicability:\s*\{\s*mode:\s*"always"\s*\}/u,
+  );
+  assert.doesNotMatch(appSchemaSource, /visibleWhen\s*:/u);
+
   const verificationImpact = JSON.parse(
     await fs.readFile(
       path.join(targetDir, "src/app/app-verification-impact.json"),

package/src/generate-test-standalone-delivery-stages.mjs

@@ -6,7 +6,7 @@ import {
   assertGeneratedExecutionLedger,
   runGeneratedDeliveryWithLedger,
 } from "./generate-test-browser-execution-ledger.mjs";
-import { runGeneratedScript } from "./generate-test-dependency-sandbox.mjs";
+import { runGeneratedExecutable } from "./generate-test-dependency-sandbox.mjs";
 
 export async function assertGeneratedRuntimeProbe({
   execFileAsync,
@@ -15,8 +15,11 @@ export async function assertGeneratedRuntimeProbe({
   const productTestPath = path.join(targetDir, "src/app/app-schema.test.ts");
   const productTestSource = await fs.readFile(productTestPath, "utf8");
   const failingSource = productTestSource.replace(
-    'it("ambient speed changes product output"',
-    'it.fails("ambient speed changes product output"',
+    'it("ambient speed changes product output", () => {',
+    [
+      'it.fails("ambient speed changes product output", () => {',
+      '    throw new Error("runtime evidence probe failure");',
+    ].join("\n"),
   );
   assert.notEqual(
     failingSource,
@@ -26,14 +29,19 @@ export async function assertGeneratedRuntimeProbe({
   await fs.writeFile(productTestPath, failingSource);
   try {
     await assert.rejects(
-      runGeneratedScript(execFileAsync, targetDir, "test"),
+      runGeneratedExecutable(execFileAsync, targetDir, "vitest", [
+        "run",
+        "src",
+        "--passWithNoTests",
+        "--reporter=default",
+        "--reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs",
+      ]),
       (error) => {
         const output = `${String(error.stdout)}\n${String(error.stderr)}`;
         assert.match(
-          output.slice(-12_000),
+          output,
           /Toolcraft automated runtime coverage failed:[\s\S]*must not use expected-failure mode/u,
         );
-        assert.match(output, /TOOLCRAFT_GENERATED_SCRIPT_TEST_EXECUTED/u);
         return true;
       },
     );