@pixel-point/toolcraft 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixel-point/toolcraft",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "bin": {

package/src/generate-performance-iteration-execution.test.mjs

@@ -99,7 +99,7 @@ test("generated standalone app preserves authority-bound performance iteration l
   }
   const output = `${stdout}\n${stderr}`;
   assert.doesNotMatch(output, /ERR_MODULE_NOT_FOUND/u);
-  assert.match(output, /^# tests 9$/mu);
-  assert.match(output, /^# pass 9$/mu);
+  assert.match(output, /^# tests 11$/mu);
+  assert.match(output, /^# pass 11$/mu);
   assert.match(output, /^# fail 0$/mu);
 });

package/src/generate-test-demand-only-lifecycle.mjs

@@ -31,10 +31,20 @@ const materialBrowserTestNames = Object.freeze([
   "browser: frosting color changes material output",
   "browser: gloss changes material output",
   "browser: layer mode changes material output",
-  "browser: material appearance reaches exported pixels",
+  "browser: material appearance reaches decoded exported pixels",
   "browser: sprinkle color changes material output",
   "browser: sprinkles visibility changes material output",
 ]);
+const materialDeliveryBrowserTestNames = Object.freeze([
+  "browser: ambient speed changes product output",
+  ...materialBrowserTestNames,
+  "browser: timeline playback drives product output",
+]);
+const materialDeliveryAcceptanceIds = Object.freeze([
+  "animation.speed",
+  ...materialAcceptanceIds,
+  "runtime.timeline",
+]);
 const materialProductTestFiles = Object.freeze([
   "src/app/acceptance/validation-pipeline.test.ts",
   "src/app/app-acceptance.base-coverage.test.ts",
@@ -44,6 +54,7 @@ const materialProductTestFiles = Object.freeze([
   "src/app/app-automated-runtime-evidence.test.ts",
   "src/app/app-performance.fixture-helper.test.ts",
   "src/app/app-performance.gates.test.ts",
+  "src/app/app-performance.lifecycle.test.ts",
   "src/app/app-schema.test.ts",
   "src/app/material-output.test.tsx",
 ]);
@@ -294,8 +305,8 @@ export async function assertGeneratedFreshDemandOnlyLifecycle({
     browserEnv,
     checkpointPath,
     execFileAsync,
-    expectedAcceptanceIds: materialAcceptanceIds,
-    expectedBrowserTestNames: materialBrowserTestNames,
+    expectedAcceptanceIds: materialDeliveryAcceptanceIds,
+    expectedBrowserTestNames: materialDeliveryBrowserTestNames,
     expectedChangedFiles: generatedProductMaterialIterationFixturePaths,
     expectedProductTestFiles: materialProductTestFiles,
     targetDir,

package/src/generate-test-dependency-sandbox.mjs

@@ -115,15 +115,13 @@ function createGeneratedCommandEnvironment(packageManager, overrides = {}) {
   return childEnv;
 }
 
-export async function runGeneratedCommand(
+async function executeGeneratedPackageManager(
   execFileAsync,
   targetDir,
-  args,
+  packageManager,
+  packageManagerArgs,
   { env = {} } = {},
 ) {
-  const { packageManager } = await readGeneratedPackageManager(targetDir);
-  const packageManagerArgs =
-    packageManager === "npm" ? ["run", ...args] : args;
   try {
     return await execFileAsync(packageManager, packageManagerArgs, {
       cwd: targetDir,
@@ -143,6 +141,45 @@ export async function runGeneratedCommand(
   }
 }
 
+export async function runGeneratedCommand(
+  execFileAsync,
+  targetDir,
+  args,
+  options,
+) {
+  const { packageManager } = await readGeneratedPackageManager(targetDir);
+  const packageManagerArgs =
+    packageManager === "npm" ? ["run", ...args] : args;
+  return executeGeneratedPackageManager(
+    execFileAsync,
+    targetDir,
+    packageManager,
+    packageManagerArgs,
+    options,
+  );
+}
+
+export async function runGeneratedExecutable(
+  execFileAsync,
+  targetDir,
+  executableName,
+  args,
+  options,
+) {
+  const { packageManager } = await readGeneratedPackageManager(targetDir);
+  const packageManagerArgs =
+    packageManager === "npm"
+      ? ["exec", "--", executableName, ...args]
+      : ["exec", executableName, ...args];
+  return executeGeneratedPackageManager(
+    execFileAsync,
+    targetDir,
+    packageManager,
+    packageManagerArgs,
+    options,
+  );
+}
+
 export function runGeneratedScript(
   execFileAsync,
   targetDir,

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

@@ -26,6 +26,23 @@ const generatedDocPaths = [
 const staleAgentPerformanceWorkflowPattern =
   /app-performance-impact|explicit-performance-work|test:browser:perf|verify:(?:final|quick|ui)|verify:perf:(?:playwright|record-iteration|refresh)|--reason=performance-iteration|--performance-test/iu;
 
+const generatedPerformanceLifecycleMarkers = [
+  "<!-- toolcraft-performance-lifecycle: first-delivery=functional; later-delivery=functional-targeted; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
+  "<!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->",
+  "<!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->",
+  "<!-- toolcraft-performance-routing: localized=agent-targeted; ambiguous=one-user-facing-choice; broad=offer-targeted-or-full; full=explicit-only -->",
+];
+
+export function getMissingGeneratedPerformanceLifecycleMarkers(sources) {
+  return sources.flatMap(({ docPath, source }) =>
+    generatedPerformanceLifecycleMarkers.flatMap((marker) =>
+      source.includes(marker)
+        ? []
+        : [`docs/toolcraft/${docPath} must include canonical marker: ${marker}`],
+    ),
+  );
+}
+
 async function collectMarkdownPaths(rootDir, relativeDir = "") {
   const currentDir = path.join(rootDir, relativeDir);
   const entries = await fs.readdir(currentDir, { withFileTypes: true });
@@ -83,6 +100,10 @@ export async function assertGeneratedDocs(targetDir) {
     await collectGeneratedAgentFacingDocs(targetDir),
   );
 
+  assert.match(noticeSource, /Mediabunny/u);
+  assert.match(noticeSource, /MPL-2\.0/u);
+  assert.match(noticeSource, /https:\/\/github\.com\/Vanilagy\/mediabunny/u);
+
   assert.deepEqual(
     staleWorkflowFailures,
     [],
@@ -139,6 +160,7 @@ export async function assertGeneratedDocs(targetDir) {
   assert.match(agentsSource, /defineToolcraft/);
   assert.match(agentsSource, /ToolcraftApp/);
   assert.match(agentsSource, /canvasContent/);
+  assert.match(agentsSource, /exportRenderer/);
   assert.match(agentsSource, /renderDefaultCanvasMedia=\{false\}/);
   assert.match(agentsSource, /onPanelAction/);
   assert.match(agentsSource, /MIT License/);
@@ -213,6 +235,8 @@ export async function assertGeneratedDocs(targetDir) {
   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(coreRuntimeBoundarySource, /modelPresentation/);
+  assert.match(coreRuntimeBoundarySource, /exportRenderer/);
+  assert.match(coreRuntimeBoundarySource, /runtime owns typed image\/video actions end to end/i);
   assert.match(coreRuntimeBoundarySource, /does not suppress runtime model layers/);
   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/);
@@ -225,6 +249,17 @@ export async function assertGeneratedDocs(targetDir) {
   assert.match(coreSetupExportSource, /renderScaleCoverage/);
   assert.match(coreSetupExportSource, /selected-backing-pixels/);
   assert.match(coreSetupExportSource, /canvas-render-scale-backing/);
+  assert.match(coreSetupExportSource, /Mediabunny/);
+  assert.match(coreSetupExportSource, /fixed 30 FPS offline schedule/);
+  assert.match(coreSetupExportSource, /Product code must not instantiate `MediaRecorder` or `VideoEncoder`/);
+  assert.doesNotMatch(
+    coreSetupExportSource,
+    /createToolcraftPngExportCanvas|renderRuntimeSceneToCanvas|renderModelsToCanvas/,
+  );
+  assert.doesNotMatch(
+    coreMediaUploadSource,
+    /createToolcraftPngExportCanvas|renderRuntimeSceneToCanvas|renderModelsToCanvas/,
+  );
   assert.match(
     coreSetupExportSource,
     /interaction[\s\S]*steady[\s\S]*playback[\s\S]*timeline/i,
@@ -269,6 +304,8 @@ export async function assertGeneratedDocs(targetDir) {
     acceptanceDocsSource,
     /export-content proof is distinct from export mechanics/i,
   );
+  assert.match(acceptanceDocsSource, /actual encoded packet metadata/i);
+  assert.match(acceptanceDocsSource, /distinct decoded frame hashes/i);
   assert.match(
     acceptanceDocsSource,
     /Each browser file owns one acceptance domain/i,
@@ -312,24 +349,14 @@ export async function assertGeneratedDocs(targetDir) {
     path.join(targetDir, "docs/toolcraft/core/performance.md"),
     "utf8",
   );
-  const performanceLifecycleMarkers = [
-    "<!-- toolcraft-performance-lifecycle: first-delivery=functional; later-delivery=functional-targeted; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
-    "<!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->",
-    "<!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->",
-  ];
-  for (const [docPath, source] of [
-    ["workflow.md", workflowDocsSource],
-    ["performance.md", performanceDocsSource],
-    ["core/performance.md", corePerformanceDocsSource],
-  ]) {
-    for (const marker of performanceLifecycleMarkers) {
-      assert.equal(
-        source.includes(marker),
-        true,
-        `docs/toolcraft/${docPath} must include canonical marker: ${marker}`,
-      );
-    }
-  }
+  assert.deepEqual(
+    getMissingGeneratedPerformanceLifecycleMarkers([
+      { docPath: "workflow.md", source: workflowDocsSource },
+      { docPath: "performance.md", source: performanceDocsSource },
+      { docPath: "core/performance.md", source: corePerformanceDocsSource },
+    ]),
+    [],
+  );
   assert.match(rendererDocsSource, /rendererTechnique/);
   assert.match(rendererDocsSource, /sourceRepresentation/);
   assert.match(rendererDocsSource, /whyNotAlternativeStrategies/);
@@ -339,6 +366,7 @@ export async function assertGeneratedDocs(targetDir) {
   assert.match(rendererDocsSource, /canonical paths/i);
   assert.match(rendererDocsSource, /combined fixtures/i);
   assert.match(rendererDocsSource, /modelPresentation/);
+  assert.match(rendererDocsSource, /ToolcraftAppComposition\.exportRenderer/);
   assert.match(rendererDocsSource, /useToolcraftModelPresentationConsumer/);
   assert.match(rendererDocsSource, /acquirePresentation/);
   assert.match(rendererDocsSource, /lease\.release/);
@@ -367,12 +395,34 @@ export async function assertGeneratedDocs(targetDir) {
     corePerformanceDocsSource,
     /functional failure[\s\S]*without measured performance/i,
   );
+  assert.match(corePerformanceDocsSource, /exact 30 FPS packet cadence[\s\S]*functional correctness/i);
+  assert.match(performanceDocsSource, /exact 30 FPS packet cadence[\s\S]*functional proof/i);
   assert.match(performanceDocsSource, /coherent (?:user-visible )?delivery batch/i);
   assert.match(performanceDocsSource, /verify:delivery/);
   assert.match(performanceDocsSource, /immediately previous successful delivery/i);
   assert.match(performanceDocsSource, /performance-iteration/);
   assert.match(performanceDocsSource, /renderScaleCoverage/);
   assert.match(performanceDocsSource, /canvas-render-scale-backing/);
+  assert.match(
+    performanceDocsSource,
+    /localized complaint[^\n]*without (?:a |asking the user)/iu,
+  );
+  assert.match(
+    performanceDocsSource,
+    /ambiguous complaint[\s\S]*one user-facing/iu,
+  );
+  assert.match(
+    performanceDocsSource,
+    /targeted diagnosis[\s\S]*complete (?:performance )?review/iu,
+  );
+  assert.match(
+    performanceDocsSource,
+    /every measured path[\s\S]*devicePixelRatio × 2/iu,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /product code may customize only the slider step/iu,
+  );
   assert.match(performanceDocsSource, /Use bare `npm run verify:delivery` once/i);
   assert.match(
     workflowDocsSource,

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

@@ -6,6 +6,7 @@ import test from "node:test";
 
 import {
   collectGeneratedAgentFacingDocs,
+  getMissingGeneratedPerformanceLifecycleMarkers,
   getStaleAgentPerformanceWorkflowFailures,
 } from "./generate-test-doc-assertions.mjs";
 
@@ -41,3 +42,24 @@ test("scans every generated agent-facing Markdown source independently", async (
     "docs/toolcraft/core/performance.md contains removed performance workflow guidance",
   ]);
 });
+
+test("requires adaptive routing in every generated performance lifecycle document", () => {
+  const routingMarker =
+    "<!-- toolcraft-performance-routing: localized=agent-targeted; ambiguous=one-user-facing-choice; broad=offer-targeted-or-full; full=explicit-only -->";
+  const existingMarkers = [
+    "<!-- toolcraft-performance-lifecycle: first-delivery=functional; later-delivery=functional-targeted; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
+    "<!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->",
+    "<!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->",
+  ].join("\n");
+
+  assert.deepEqual(
+    getMissingGeneratedPerformanceLifecycleMarkers([
+      { docPath: "workflow.md", source: `${existingMarkers}\n${routingMarker}` },
+      { docPath: "performance.md", source: existingMarkers },
+      { docPath: "core/performance.md", source: `${existingMarkers}\n${routingMarker}` },
+    ]),
+    [
+      `docs/toolcraft/performance.md must include canonical marker: ${routingMarker}`,
+    ],
+  );
+});

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

@@ -6,9 +6,15 @@ import {
   assertGeneratedDeliveryArchitecture,
   deliveryArchitecturePaths,
 } from "./generate-test-delivery-architecture-assertions.mjs";
-import { listRelativeFiles, readTextFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { listRelativeFiles, repoRoot } from "./generate-test-fs-utils.mjs";
+import { assertGeneratedPerformanceCanvasBoundary } from "./generate-test-performance-boundary-assertions.mjs";
 import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
 
+export {
+  assertGeneratedRoutesAndStyles,
+  assertGeneratedTextIsStandalone,
+} from "./generate-test-output-assertions.mjs";
+
 function assertSignedProtectedFiles(manifest, relativePaths, responsibility) {
   for (const relativePath of relativePaths) {
     assert.ok(
@@ -68,6 +74,39 @@ export async function assertGeneratedFiles(targetDir) {
     expectedRuntimeFiles,
     "Generated standalone runtime must contain every production runtime module.",
   );
+  for (const relativePath of [
+    "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",
+  ]) {
+    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 [
+    "e2e/browser-media-export-evidence.ts",
+    "e2e/decoded-pixel-observation.ts",
+    "e2e/image-artifact-inspection.ts",
+    "e2e/video-artifact-inspection.ts",
+  ]) {
+    assert.ok(
+      await fs.stat(path.join(targetDir, relativePath)),
+      `Generated output must contain ${relativePath}.`,
+    );
+  }
   for (const relativePath of generatedToolcraftFiles) {
     assert.equal(
       isGeneratedTestSupportPath(relativePath),
@@ -96,9 +135,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")));
@@ -350,6 +387,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 +454,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-"),