@pixel-point/toolcraft 0.0.17 → 0.0.18

package/package.json

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

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

@@ -2,6 +2,21 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import path from "node:path";
 
+import {
+  assertGeneratedExportIntentDocsDoNotInferVideo,
+  collectGeneratedAgentFacingDocs,
+  getMissingGeneratedPerformanceLifecycleMarkers,
+  getStaleAgentPerformanceWorkflowFailures,
+} from "./generate-test-doc-policy-assertions.mjs";
+
+export {
+  assertGeneratedExportIntentDocsDoNotInferVideo,
+  collectGeneratedAgentFacingDocs,
+  getMissingGeneratedPerformanceLifecycleMarkers,
+  getStaleAgentPerformanceWorkflowFailures,
+  staleAnimationDerivedVideoPattern,
+} from "./generate-test-doc-policy-assertions.mjs";
+
 const generatedDocPaths = [
   "README.md",
   "workflow.md",
@@ -23,70 +38,6 @@ const generatedDocPaths = [
   "core/reference-study.md",
 ];
 
-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 });
-  const markdownPaths = [];
-
-  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
-    const relativePath = path.join(relativeDir, entry.name);
-    if (entry.isDirectory()) {
-      markdownPaths.push(...(await collectMarkdownPaths(rootDir, relativePath)));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      markdownPaths.push(relativePath);
-    }
-  }
-
-  return markdownPaths;
-}
-
-export async function collectGeneratedAgentFacingDocs(targetDir) {
-  const docsRoot = path.join(targetDir, "docs/toolcraft");
-  const docPaths = await collectMarkdownPaths(docsRoot);
-  const docs = await Promise.all(
-    docPaths.map(async (docPath) => ({
-      docPath: path.posix.join("docs/toolcraft", docPath.split(path.sep).join("/")),
-      source: await fs.readFile(path.join(docsRoot, docPath), "utf8"),
-    })),
-  );
-
-  return [
-    {
-      docPath: "AGENTS.md",
-      source: await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8"),
-    },
-    ...docs,
-  ];
-}
-
-export function getStaleAgentPerformanceWorkflowFailures(sources) {
-  return sources.flatMap(({ docPath, source }) =>
-    staleAgentPerformanceWorkflowPattern.test(source)
-      ? [`${docPath} contains removed performance workflow guidance`]
-      : [],
-  );
-}
-
 export async function assertGeneratedDocs(targetDir) {
   await Promise.all(
     generatedDocPaths.map((docPath) => fs.stat(path.join(targetDir, "docs/toolcraft", docPath))),
@@ -96,8 +47,9 @@ export async function assertGeneratedDocs(targetDir) {
   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");
+  const generatedAgentFacingDocs = await collectGeneratedAgentFacingDocs(targetDir);
   const staleWorkflowFailures = getStaleAgentPerformanceWorkflowFailures(
-    await collectGeneratedAgentFacingDocs(targetDir),
+    generatedAgentFacingDocs,
   );
 
   assert.match(noticeSource, /Mediabunny/u);
@@ -109,6 +61,7 @@ export async function assertGeneratedDocs(targetDir) {
     [],
     `Generated agent-facing docs contain stale performance workflow guidance:\n${staleWorkflowFailures.join("\n")}`,
   );
+  assertGeneratedExportIntentDocsDoNotInferVideo(generatedAgentFacingDocs);
 
   assert.match(agentsSource, /Quick Entry Contract/);
   assert.match(agentsSource, /Local Reference Docs/);
@@ -240,12 +193,44 @@ export async function assertGeneratedDocs(targetDir) {
   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/);
-  assert.match(coreSetupExportSource, /Every product exposes `Export PNG`/);
+  assert.match(coreSetupExportSource, /productReadiness\.exportIntent/);
   assert.match(
     coreSetupExportSource,
-    /Products whose requested delivery includes animation also expose `Export Video`/,
+    /image[^\n]*`toolcraft-default`[^\n]*`user-requested`[^\n]*`user-removed`/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /video[^\n]*`not-requested`[^\n]*`user-requested`/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /image[^\n]*`user-requested`[^\n]*non-empty[^\n]*evidence/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /image[^\n]*`user-removed`[^\n]*non-empty[^\n]*evidence/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /video[^\n]*`user-requested`[^\n]*non-empty[^\n]*evidence/i,
+  );
+  for (const decisionStep of [
+    "Start every product with image export.",
+    "Add video export only when the user explicitly requests video delivery.",
+    "Do not infer video from animation, playback, keyframes, or timeline.",
+    "Keep image with video unless the user explicitly requests removal.",
+    "Record in `productReadiness.exportIntent`.",
+  ]) {
+    assert.equal(
+      coreSetupExportSource.split(decisionStep).length - 1,
+      1,
+      `Canonical export-intent step must appear exactly once: ${decisionStep}`,
+    );
+  }
+  assert.match(
+    coreSetupExportSource,
+    /Clipboard copy may be an additional product action, but it never changes or substitutes for the recorded artifact intent/,
   );
-  assert.match(coreSetupExportSource, /Clipboard copy is optional and never replaces export/);
   assert.match(coreSetupExportSource, /renderScaleCoverage/);
   assert.match(coreSetupExportSource, /selected-backing-pixels/);
   assert.match(coreSetupExportSource, /canvas-render-scale-backing/);
@@ -271,6 +256,10 @@ export async function assertGeneratedDocs(targetDir) {
   );
   assert.match(assemblyDocsSource, /@\/toolcraft\/runtime/);
   assert.match(assemblyDocsSource, /ToolcraftAppComposition/);
+  assert.match(
+    assemblyDocsSource,
+    /Every product declaration requires `productReadiness\.exportIntent`/,
+  );
   assert.match(assemblyDocsSource, /protected route/);
   assert.match(assemblyDocsSource, /transferMode: "reference-runtime-clone"/);
   assert.match(assemblyDocsSource, /`canvasContent` must not contain app UI/);
@@ -284,6 +273,7 @@ export async function assertGeneratedDocs(targetDir) {
   assert.match(acceptanceDocsSource, /automatedTestName/);
   assert.match(acceptanceDocsSource, /browserTestName/);
   assert.match(acceptanceDocsSource, /app-acceptance-data\.ts/);
+  assert.match(acceptanceDocsSource, /productReadiness\.exportIntent/);
   assert.match(
     acceptanceDocsSource,
     /Contract docs are signed except product-owned `agent-worklog\.md` and optional `workflow-observation\.md`; only the observation stays outside `sourceHash`/,

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

@@ -5,11 +5,54 @@ import path from "node:path";
 import test from "node:test";
 
 import {
+  assertGeneratedExportIntentDocsDoNotInferVideo,
   collectGeneratedAgentFacingDocs,
   getMissingGeneratedPerformanceLifecycleMarkers,
   getStaleAgentPerformanceWorkflowFailures,
 } from "./generate-test-doc-assertions.mjs";
 
+test("rejects animation-derived video rules without rejecting explicit authority", () => {
+  for (const source of [
+    [
+      "Products whose requested delivery includes",
+      "animation also expose",
+      "`Export Video`.",
+    ].join(" "),
+    ["Animated apps automatically show", "Export Video."].join(" "),
+    ["Animation also", "requires", "Export Video."].join(" "),
+    "Timeline playback enables Export Video.",
+    "Animated apps automatically expose video export.",
+    "Timeline playback enables video export.",
+    "Animation implies video delivery.",
+  ]) {
+    assert.throws(
+      () =>
+        assertGeneratedExportIntentDocsDoNotInferVideo([
+          { docPath: "docs/toolcraft/stale.md", source },
+        ]),
+      /docs\/toolcraft\/stale\.md contains animation-derived video export guidance/,
+    );
+  }
+
+  assert.doesNotThrow(() =>
+    assertGeneratedExportIntentDocsDoNotInferVideo([
+      {
+        docPath: "docs/toolcraft/allowed.md",
+        source: [
+          "Do not infer video from animation, playback, keyframes, or timeline.",
+          "Animation, playback, keyframes, and timeline presence never add Export Video.",
+          "Animated apps do not automatically expose video export.",
+          "Timeline playback never enables video export.",
+          "Animation does not imply video delivery.",
+          "An animated app includes Export Video because the user explicitly requested video delivery.",
+          "An animated app exposes video export because the user explicitly requested video delivery.",
+          "Any app with Export Video must enable the top Toolcraft timeline.",
+        ].join("\n"),
+      },
+    ]),
+  );
+});
+
 test("scans every generated agent-facing Markdown source independently", async (t) => {
   const targetDir = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-doc-scan-"));
   t.after(() => fs.rm(targetDir, { force: true, recursive: true }));

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

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+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 exportIntentSentencePatternSource = String.raw`[^\n.!?]`;
+const videoArtifactTargetPatternSource = String.raw`(?:Export Video|video\s+(?:export|delivery))`;
+const explicitVideoAuthorityPatternSource = String.raw`(?:explicit(?:ly)?\s+(?:(?:user[- ]?)?request(?:ed|s)?\s+)?${videoArtifactTargetPatternSource}|user\s+explicitly\s+request(?:ed|s)?\s+${videoArtifactTargetPatternSource}|user[- ]request(?:ed|s)?\s+${videoArtifactTargetPatternSource})`;
+const animationInferenceVerbPatternSource = String.raw`(?:exposes?|includes?|shows?|adds?|enables?|implies?|has|needs?|requires?|produces?|proves?)`;
+const staleAnimationInferencePatternSource = [
+  String.raw`products?\s+whose\s+requested\s+delivery\s+includes\s+animation`,
+  String.raw`animated\s+apps?\b(?!${exportIntentSentencePatternSource}{0,100}\b(?:do(?:es)?\s+not|never)\b)${exportIntentSentencePatternSource}{0,100}\b${animationInferenceVerbPatternSource}\b${exportIntentSentencePatternSource}{0,60}\b${videoArtifactTargetPatternSource}\b`,
+  String.raw`(?:animation|playback|keyframes?|timeline(?:\s+playback)?)\b\s+(?:also\s+)?${animationInferenceVerbPatternSource}\b${exportIntentSentencePatternSource}{0,60}\b${videoArtifactTargetPatternSource}\b`,
+].join("|");
+
+export const staleAnimationDerivedVideoPattern = new RegExp(
+  String.raw`(?:^|[\n.!?]\s*)(?!${exportIntentSentencePatternSource}{0,240}\b${explicitVideoAuthorityPatternSource}\b)${exportIntentSentencePatternSource}{0,240}(?:${staleAnimationInferencePatternSource})`,
+  "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 });
+  const markdownPaths = [];
+
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const relativePath = path.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      markdownPaths.push(...(await collectMarkdownPaths(rootDir, relativePath)));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      markdownPaths.push(relativePath);
+    }
+  }
+
+  return markdownPaths;
+}
+
+export async function collectGeneratedAgentFacingDocs(targetDir) {
+  const docsRoot = path.join(targetDir, "docs/toolcraft");
+  const docPaths = await collectMarkdownPaths(docsRoot);
+  const docs = await Promise.all(
+    docPaths.map(async (docPath) => ({
+      docPath: path.posix.join("docs/toolcraft", docPath.split(path.sep).join("/")),
+      source: await fs.readFile(path.join(docsRoot, docPath), "utf8"),
+    })),
+  );
+
+  return [
+    {
+      docPath: "AGENTS.md",
+      source: await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8"),
+    },
+    ...docs,
+  ];
+}
+
+export function getStaleAgentPerformanceWorkflowFailures(sources) {
+  return sources.flatMap(({ docPath, source }) =>
+    staleAgentPerformanceWorkflowPattern.test(source)
+      ? [`${docPath} contains removed performance workflow guidance`]
+      : [],
+  );
+}
+
+export function assertGeneratedExportIntentDocsDoNotInferVideo(sources) {
+  for (const { docPath, source } of sources) {
+    assert.doesNotMatch(
+      source,
+      staleAnimationDerivedVideoPattern,
+      `${docPath} contains animation-derived video export guidance`,
+    );
+  }
+}

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

@@ -8,7 +8,7 @@ import {
 } from "./generate-test-delivery-architecture-assertions.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";
+import { assertGeneratedRuntimePublicBoundary } from "./generate-test-runtime-boundary-assertions.mjs";
 
 export {
   assertGeneratedRoutesAndStyles,
@@ -44,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")),
@@ -61,70 +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 [
-    "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),
-      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",
@@ -144,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")),

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",
@@ -83,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"),