create-aura3d 1.0.10 → 1.1.0

package/templates/cartoon-studio/src/main.ts

@@ -5,6 +5,7 @@ import {
   createShotPlaybackPlan,
   effects,
   game,
+  group,
   installShotPlayback,
   labels,
   lights,
@@ -13,8 +14,7 @@ import {
   primitives,
   sampleAuraVoiceBridgeAtTime,
   sampleShotPlaybackPlan,
-  scene,
-  type AuraAssetRef
+  scene
 } from "@aura3d/engine";
 import { assets } from "./aura-assets";
 import {
@@ -23,8 +23,7 @@ import {
   missingCartoonCharacterAssets,
   publicCartoonAssetInstructions,
   requiredCartoonCharacterAssets,
-  typedCartoonAssetSummary,
-  type CartoonAssetKey
+  typedCartoonAssetSummary
 } from "./episode";
 import {
   accessibilityProofMetadata,
@@ -49,15 +48,31 @@ import { cartoonStudioSupport, installCartoonStudioPanel } from "./studio";
 
 declare global {
   interface Window {
-    __AURA3D_CARTOON_TEMPLATE__?: {
+    __AURA3D_CARTOON_EPISODE_SEEK__?: (time: number) => void;
+    __AURA3D_CARTOON_EPISODE_PROOF__?: CartoonEpisodeRouteProof;
+    __AURA3D_CARTOON_TEMPLATE__?: CartoonEpisodeRouteProof;
+  }
+}
+
+interface CartoonEpisodeRouteProof {
+      readonly proofKind: "aura3d-cartoon-episode-proof";
       readonly contractId: string;
       readonly template: string;
       readonly storyBible: unknown;
+      readonly shots: readonly unknown[];
+      readonly captions: readonly unknown[];
+      readonly visemes: readonly unknown[];
+      readonly gestures: readonly unknown[];
+      readonly assets: unknown;
+      readonly renderStatus: unknown;
+      readonly errors: readonly string[];
+      readonly sourceOnlyAcceptedAsPublishProof: false;
       readonly shotIds: readonly string[];
       readonly captionIds: readonly string[];
       readonly playbackProbeTimes: readonly number[];
       readonly playbackProbeSamples: readonly unknown[];
       readonly renderQueueItems: number;
+      readonly renderPreset: unknown;
       readonly typedAssets: unknown;
       readonly requiredTypedAssets: readonly string[];
       readonly missingTypedAssets: readonly string[];
@@ -69,8 +84,6 @@ declare global {
       readonly sourceProofs: unknown;
       readonly sampleRenderSourceWorkflow: unknown;
       sampleAt(time: number): unknown;
-    };
-  }
 }
 
 const firstStoryboardShot = episode.storyboard.scenes[0]?.shots[0];
@@ -78,13 +91,21 @@ const firstCaption = episode.captionTrack.cues[0];
 const thumbnailCapture = renderOutputPackage.thumbnailCapture;
 const thumbnailCaption = captionCueAtTime(episode.captionTrack, thumbnailCapture.time);
 const storyBible = episode.storyBible;
-const typedCartoonAssets = assets as Partial<Record<CartoonAssetKey, AuraAssetRef<"model">>>;
+const captureMode = new URLSearchParams(window.location.search).get("capture") === "thumbnail";
+const cartoonRenderPreset = createCartoonStudioRouteRenderPreset({
+  name: "moon-garden-cartoon-studio",
+  resolution: episode.episodePlan.runtime.resolution,
+  materialStyle: { treatment: "cel" },
+  reducedMotion: episode.episodePlan.runtime.reducedMotion,
+  reducedFlash: true
+});
 
 const captionOverlay = document.createElement("div");
 captionOverlay.id = "caption-overlay";
 captionOverlay.textContent = firstCaption?.text ?? firstStoryboardShot?.storyBeat ?? "Aura3D cartoon studio";
 captionOverlay.style.cssText = [
   "position:fixed",
+  captureMode ? "display:none" : "",
   "left:50%",
   "bottom:28px",
   "transform:translateX(-50%)",
@@ -121,14 +142,30 @@ document.body.dataset.cartoonShotCount = String(episode.shotTimeline.shots.lengt
 document.body.dataset.cartoonCaptionCount = String(episode.captionTrack.cues.length);
 document.body.dataset.cartoonStoryBibleProps = String(storyBible.props.length);
 document.body.dataset.cartoonStudioPanels = cartoonStudioSupport.panels.join(",");
-installCartoonStudioPanel(document.body);
+if (!captureMode) installCartoonStudioPanel(document.body);
 
 const app = createAuraApp("#app", {
   scene: scene()
     .background("#081b2a")
-    .add(createCharacterBody("miko", "Miko", "miko", [-0.8, 0.75, 0], [0.32, 0.42, 0.32], 0.72, "#7de2ff"))
+    .add(
+      model(assets.moonGarden, { name: "Moon Garden typed set asset" })
+        .position(0, 0, -0.02)
+        .scale(1)
+        .runtime(game.runtimeNode("moonGarden", { tags: ["set", "typed-asset", "moon-garden"] }))
+    )
+    .add(
+      model(assets.miko, { name: "Miko typed cartoon character" })
+        .position(-0.8, 0.75, 0)
+        .scale(0.72)
+        .runtime(game.runtimeNode("miko", { tags: ["character", "miko", "typed-asset"] }))
+    )
     .add(createMouthCard("miko:mouth", "Miko", [-0.8, 0.8, 0.32], "#f8fff2"))
-    .add(createCharacterBody("luma", "Luma", "luma", [0.8, 0.72, 0], [0.3, 0.38, 0.3], 0.68, "#ffe18e"))
+    .add(
+      model(assets.luma, { name: "Luma typed cartoon character" })
+        .position(0.8, 0.72, 0)
+        .scale(0.68)
+        .runtime(game.runtimeNode("luma", { tags: ["character", "luma", "typed-asset"] }))
+    )
     .add(createMouthCard("luma:mouth", "Luma", [0.8, 0.77, 0.32], "#40ffbf"))
     .add(
       primitives
@@ -148,22 +185,40 @@ const app = createAuraApp("#app", {
         .position(-0.38, 0.2, 0.18)
         .scale([0.12, 0.24, 0.04])
     )
-    .add(labels.hud(firstCaption?.text ?? firstStoryboardShot?.storyBeat ?? "Aura3D cartoon studio"))
+    .add(captureMode ? group("thumbnail capture label placeholder") : labels.hud(firstCaption?.text ?? firstStoryboardShot?.storyBeat ?? "Aura3D cartoon studio"))
     .add(lights.studio({ intensity: 1.2 }))
     .add(effects.bloom({ intensity: 0.18, color: "#7de2ff" }))
     .camera(camera.perspective({ position: [0, 1.4, 4.2], target: [0, 0.7, 0], fov: 42 })),
-  diagnostics: true
+  diagnostics: !captureMode
 });
 
-window.__AURA3D_CARTOON_TEMPLATE__ = {
+const cartoonEpisodeProof: CartoonEpisodeRouteProof = {
+  proofKind: "aura3d-cartoon-episode-proof",
   contractId: episodeContractId,
   template: "cartoon-studio",
   storyBible,
+  shots: episode.shotTimeline.shots,
+  captions: episode.captionTrack.cues,
+  visemes: visemeTrack.cues,
+  gestures: episode.performance.cues,
+  assets: typedCartoonAssetSummary,
+  renderStatus: {
+    route: renderPlan.route,
+    renderQueueItems: renderPlan.items.length,
+    outputs: renderPlan.outputs.map((output) => output.kind),
+    preset: cartoonRenderPreset,
+    sourceOnlyAcceptedAsPublishProof: false,
+    publishReadyFromCurrentEvidence: publishReadiness.ready,
+    issueCount: publishReadiness.issues.length
+  },
+  errors: bridgeIssues.map((issue) => String((issue as { message?: unknown }).message ?? issue)),
+  sourceOnlyAcceptedAsPublishProof: false,
   shotIds: episode.shotTimeline.shots.map((shot) => shot.shotId),
   captionIds: episode.captionTrack.cues.map((caption) => caption.captionId),
   playbackProbeTimes,
   playbackProbeSamples,
   renderQueueItems: renderPlan.items.length,
+  renderPreset: cartoonRenderPreset,
   typedAssets: typedCartoonAssetSummary,
   requiredTypedAssets: requiredCartoonCharacterAssets,
   missingTypedAssets: missingCartoonCharacterAssets,
@@ -182,6 +237,14 @@ window.__AURA3D_CARTOON_TEMPLATE__ = {
     return sampleCartoonRouteAt(time);
   }
 };
+window.__AURA3D_CARTOON_EPISODE_PROOF__ = cartoonEpisodeProof;
+window.__AURA3D_CARTOON_TEMPLATE__ = cartoonEpisodeProof;
+window.__AURA3D_CARTOON_EPISODE_SEEK__ = (time: number) => {
+  const sample = sampleCartoonRouteAt(time);
+  captionOverlay.textContent = sample.captionText ?? firstCaption?.text ?? "";
+  captionOverlay.dataset.shotId = sample.shotId ?? "";
+  captionOverlay.dataset.captionId = sample.captionId ?? "";
+};
 
 installShotPlayback(app, shotPlaybackPlan, {
   primitiveMouthNodeByCharacterId: {
@@ -195,33 +258,6 @@ installShotPlayback(app, shotPlaybackPlan, {
   }
 });
 
-function createCharacterBody(
-  id: "miko" | "luma",
-  name: string,
-  assetKey: CartoonAssetKey,
-  position: readonly [number, number, number],
-  fallbackScale: readonly [number, number, number],
-  modelScale: number,
-  color: string
-) {
-  const asset = typedCartoonAssets[assetKey];
-  const runtime = game.runtimeNode(id, { tags: ["character", id, asset ? "typed-asset" : "primitive-fallback"] });
-  if (asset) {
-    return model(asset, { name: `${name} typed character asset` })
-      .position(position[0], position[1], position[2])
-      .scale(modelScale)
-      .runtime(runtime);
-  }
-  return primitives
-    .sphere({
-      name: `${name} primitive fallback body - add ${assetKey} with the Aura3D CLI`,
-      material: material.pbr({ color, roughness: 0.54 })
-    })
-    .position(position[0], position[1], position[2])
-    .scale(fallbackScale)
-    .runtime(runtime);
-}
-
 function createMouthCard(id: "miko:mouth" | "luma:mouth", name: string, position: readonly [number, number, number], color: string) {
   return primitives
     .box({
@@ -233,6 +269,38 @@ function createMouthCard(id: "miko:mouth" | "luma:mouth", name: string, position
     .runtime(game.runtimeNode(id, { tags: ["mouth", "primitive", name.toLowerCase()] }));
 }
 
+function createCartoonStudioRouteRenderPreset(input: {
+  readonly name: string;
+  readonly resolution: { readonly width: number; readonly height: number };
+  readonly materialStyle: { readonly treatment: "cel" | "preserve-pbr" };
+  readonly reducedMotion?: boolean | undefined;
+  readonly reducedFlash?: boolean | undefined;
+}) {
+  return {
+    kind: "cartoon-render-preset-evidence",
+    name: input.name,
+    resolution: input.resolution,
+    lights: ["soft-key", "cool-rim", "set-fill", "emissive-practicals"],
+    shadows: { soft: true, contact: true },
+    postprocess: {
+      bloom: input.reducedFlash ? 0.08 : 0.18,
+      colorGrade: "storybook-night",
+      fogDepthCue: true
+    },
+    materialStyle: {
+      treatment: input.materialStyle.treatment,
+      outline: input.materialStyle.treatment === "cel",
+      rampSteps: input.materialStyle.treatment === "cel" ? 4 : 7,
+      saturation: 1.08,
+      blackLineWeight: input.materialStyle.treatment === "cel" ? 0.9 : 0
+    },
+    frameBudgetMs: 16.7,
+    debugOverlaysAllowedInExport: false,
+    reducedMotion: input.reducedMotion ?? false,
+    reducedFlash: input.reducedFlash ?? false
+  } as const;
+}
+
 function sampleCartoonRouteAt(time: number) {
   const bridgeSample = sampleAuraVoiceBridgeAtTime(auraVoicePackage, time);
   const playbackSample = sampleShotPlaybackPlan(shotPlaybackPlan, time);

package/templates/cartoon-studio/src/render-plan.ts

@@ -221,6 +221,87 @@ export const spanishDubMap = defineDubMap({
   generatedAt: episode.episodePlan.generatedAt
 });
 
+const spanishLineTextBySourceText = new Map<string, string>([
+  ["Luma, the moon lilies are losing their sparkle.", "Luma, los lirios lunares estan perdiendo su brillo."],
+  ["Then we sweep softly and wake the glow stones.", "Entonces barremos con suavidad y despertamos las piedras brillantes."],
+  ["I will polish the blue stones one tiny circle at a time.", "Pulire las piedras azules con circulos pequenitos."],
+  ["And I will hum the garden's sleepy cleanup song.", "Y yo tarareare la cancion tranquila del jardin."],
+  ["The moon lilies are twinkling again.", "Los lirios lunares vuelven a centellear."],
+  ["Goodnight, little garden. Keep glowing.", "Buenas noches, jardin pequeno. Sigue brillando."]
+]);
+
+function spanishTextForLine(text: string): string {
+  return spanishLineTextBySourceText.get(text) ?? text;
+}
+
+export const spanishDubCaptionMetadata = {
+  artifact: "alternate-language-caption-metadata",
+  schema: "aura3d-cartoon-studio-alternate-language-captions/v1",
+  contractId: renderContractId,
+  episodeId: episode.episodePlan.episodeId,
+  sourceLanguage: episode.dialogueTrack.language,
+  targetLanguage: spanishDubMap.targetLanguage,
+  cues: episode.captionTrack.cues.map((cue) => {
+    const sourceLine = episode.dialogueTrack.lines.find((line) => line.lineId === cue.lineId);
+    return {
+      captionId: cue.captionId,
+      lineId: cue.lineId,
+      shotId: cue.shotId,
+      sceneId: cue.sceneId,
+      speakerId: cue.speakerId,
+      sourceText: cue.text,
+      text: spanishTextForLine(sourceLine?.text ?? cue.text),
+      language: "es",
+      startTime: cue.startTime,
+      endTime: cue.endTime,
+      lineSafe: cue.lineSafe
+    };
+  }),
+  generatedAt: episode.episodePlan.generatedAt
+} as const;
+
+export const alternateLanguageDubMetadata = {
+  artifact: "cartoon-alternate-language-dub-proof",
+  schema: "aura3d-cartoon-studio-alternate-language-dub-proof/v1",
+  contractId: renderContractId,
+  episodeId: episode.episodePlan.episodeId,
+  sourceLanguage: episode.dialogueTrack.language,
+  alternateLanguageCount: 1,
+  alternateLanguages: [
+    {
+      language: spanishDubMap.targetLanguage,
+      label: "Spanish",
+      title: "Limpieza del Jardin Lunar",
+      dubMapArtifact: spanishDubMap.artifact,
+      lineCount: spanishDubMap.entries.length,
+      captionCueCount: spanishDubCaptionMetadata.cues.length,
+      captionMetadata: spanishDubCaptionMetadata,
+      audioStemSlots: episode.dialogueTrack.lines.map((line) => ({
+        id: `dub-slot:es:${line.lineId}`,
+        lineId: line.lineId,
+        speakerId: line.speakerId,
+        language: "es",
+        assetRequiredBeforePublish: true
+      })),
+      stableIds: {
+        shotIds: spanishDubMap.entries.every((entry) => entry.originalShotId === entry.dubbedShotId),
+        storyboardIds: spanishDubMap.entries.every((entry) => entry.originalStoryboardId === entry.dubbedStoryboardId),
+        sceneIds: spanishDubMap.entries.every((entry) => entry.originalSceneId === entry.dubbedSceneId),
+        lineIds: spanishDubMap.entries.every((entry) => entry.originalLineId === entry.dubbedLineId),
+        captionIds: spanishDubMap.entries.every((entry) => entry.originalCaptionId === entry.dubbedCaptionId),
+        characterIds: spanishDubMap.entries.every((entry) => entry.originalCharacterId === entry.dubbedCharacterId)
+      },
+      publishBoundary: "Metadata-only alternate-language proof. Add licensed/typed Spanish dialogue stems before claiming a rendered Spanish dub."
+    }
+  ],
+  assetPolicy: {
+    inventsAudioAssets: false,
+    inventsModelAssets: false,
+    typedAssetSource: "./src/aura-assets"
+  },
+  generatedAt: episode.episodePlan.generatedAt
+} as const;
+
 export const phonemeVisemeDubSyncSourceProof = {
   contractId: renderContractId,
   sourceOnly: true,
@@ -255,6 +336,59 @@ export const phonemeVisemeDubSyncSourceProof = {
   executionBoundary: "Source harness only; actual phoneme, viseme, and dub playback proof requires rendered frame/video evidence."
 } as const;
 
+export const cartoonStudioShowBibleBatchRenderPlan = {
+  artifact: "cartoon-show-bible-batch-render-plan",
+  schema: "aura3d-cartoon-studio-show-bible-batch-render-plan/v1",
+  contractId: renderContractId,
+  sourceStoryBible: {
+    episodeId: episode.storyBible.episodeId,
+    title: episode.storyBible.title,
+    characterIds: episode.storyBible.characters.map((character) => character.id),
+    locationIds: episode.storyBible.locations.map((location) => location.id),
+    propIds: episode.storyBible.props.map((prop) => prop.id),
+    continuityRules: episode.storyBible.continuityRules ?? []
+  },
+  renderJobs: [
+    {
+      id: "batch:moon-garden-cleanup-001",
+      episodeId: episode.episodePlan.episodeId,
+      title: episode.episodePlan.title,
+      sourceStoryBibleEpisodeId: episode.storyBible.episodeId,
+      route: renderPlan.route,
+      outputDirectory: "dist/episodes/moon-garden-001",
+      language: episode.episodePlan.language,
+      shotIds: episode.shotTimeline.shots.map((shot) => shot.shotId),
+      requiredTypedAssetKeys: typedCartoonAssetSummary.requiredCharacterAssets,
+      command: "npm run episode:render -- --episode moon-garden-cleanup-001"
+    },
+    {
+      id: "batch:moon-garden-glow-check-002",
+      episodeId: "moon-garden-glow-check-002",
+      title: "Moon Garden Glow Check",
+      sourceStoryBibleEpisodeId: episode.storyBible.episodeId,
+      route: renderPlan.route,
+      outputDirectory: "dist/episodes/moon-garden-002",
+      language: episode.episodePlan.language,
+      reusedCharacterIds: episode.storyBible.characters.map((character) => character.id),
+      reusedLocationIds: episode.storyBible.locations.map((location) => location.id),
+      reusedPropIds: episode.storyBible.props.map((prop) => prop.id),
+      requiredTypedAssetKeys: typedCartoonAssetSummary.requiredCharacterAssets,
+      command: "npm run episode:render -- --episode moon-garden-glow-check-002",
+      metadataOnly: true,
+      publishBoundary: "Second episode job reuses the same show bible and asset slots; rendered media is produced only when the template runner is executed with real typed assets."
+    }
+  ],
+  guarantees: {
+    oneShowBible: true,
+    multipleEpisodes: true,
+    noInventedAssets: true,
+    stableCharacterIds: true,
+    stableLocationIds: true,
+    stablePropIds: true
+  },
+  generatedAt: episode.episodePlan.generatedAt
+} as const;
+
 export const performanceCoverage = createCartoonPerformanceCoverage(episode.performance, episode.dialogueTrack);
 
 export const reviewPackagePaths = renderOutputPackage.reviewPackagePaths;
@@ -365,6 +499,34 @@ export const sampleRenderSourceWorkflow = {
   ]
 } as const;
 
+export const templateEpisodePackageWorkflow = {
+  contractId: renderContractId,
+  sourceOnly: false,
+  status: "template-package-runner-ready",
+  packageDirectory: "dist/episodes/moon-garden-001",
+  commands: [
+    "npm run episode:plan",
+    "npm run episode:preview",
+    "npm run episode:render",
+    "npm run episode:package",
+    "npm run episode:review",
+    "npm run episode:verify"
+  ],
+  requiredArtifacts: [
+    "thumbnail.png",
+    "captions.vtt",
+    "captions.srt",
+    "metadata.json",
+    "route-proof.json",
+    "asset-provenance.json",
+    "render-manifest.json",
+    "visual-acceptance.json",
+    "review-package.md"
+  ],
+  renderOutputMode: "episode.webm-or-png-sequence-fallback-marker",
+  publishBoundary: "PNG sequence fallback proves template packaging only; publish-ready claims require a real encoded WebM or MP4 plus human review."
+} as const;
+
 export const auraVoicePackage = createAuraVoiceBridgePackage({
   episodePlan: episode.episodePlan,
   storyboard: episode.storyboard,

package/templates/cartoon-studio/src/review.ts

@@ -0,0 +1,99 @@
+import { captionTimingProof, renderOutputPackage, visemeFrameSyncSourceProof } from "./render-plan";
+import { episode, missingCartoonCharacterAssets, publicCartoonAssetInstructions, typedCartoonAssetSummary, youtubeDraftMetadata } from "./episode";
+
+export const cartoonEpisodePackageDirectory = "dist/episodes/moon-garden-001" as const;
+
+export const requiredCartoonEpisodePackageFiles = [
+  "episode.webm",
+  "thumbnail.png",
+  "captions.vtt",
+  "captions.srt",
+  "metadata.json",
+  "prompt-animation-evidence.json",
+  "route-proof.json",
+  "asset-provenance.json",
+  "render-manifest.json",
+  "dub-metadata.json",
+  "batch-render-plan.json",
+  "motion-quality.json",
+  "visual-acceptance.json",
+  "review-package.md"
+] as const;
+
+export const optionalCartoonEpisodePackageFiles = [
+  "episode.mp4",
+  "episode.png-sequence-fallback.json"
+] as const;
+
+export interface CartoonEpisodeReviewInput {
+  readonly packageDirectory?: string;
+  readonly hasWebm: boolean;
+  readonly hasPngSequenceFallback: boolean;
+  readonly generatedAt: string;
+}
+
+export function createCartoonEpisodeReviewPackage(input: CartoonEpisodeReviewInput): string {
+  const packageDirectory = input.packageDirectory ?? cartoonEpisodePackageDirectory;
+  const outputMode = input.hasWebm ? "encoded-webm" : input.hasPngSequenceFallback ? "png-sequence-fallback" : "missing-render-output";
+  const typedAssetStatus = missingCartoonCharacterAssets.length === 0 ? "typed character assets present" : "starter fallback mode";
+  const reviewStatus = input.hasWebm && missingCartoonCharacterAssets.length === 0 ? "ready-for-human-review" : "needs-render-upgrade-before-publish";
+
+  return [
+    "# Moon Garden 001 Review Package",
+    "",
+    `Generated: ${input.generatedAt}`,
+    `Episode: ${episode.episodePlan.title}`,
+    `Package: \`${packageDirectory}\``,
+    `Output mode: \`${outputMode}\``,
+    `Review status: \`${reviewStatus}\``,
+    "",
+    "## Required Files",
+    "",
+    ...requiredCartoonEpisodePackageFiles.map((file) => `- [x] \`${file}\``),
+    input.hasPngSequenceFallback ? "- [x] `episode.png-sequence-fallback.json`" : "- [ ] `episode.png-sequence-fallback.json`",
+    "",
+    "## Episode Summary",
+    "",
+    `- Runtime: ${episode.episodePlan.runtime.duration}s at ${episode.episodePlan.runtime.frameRate}fps`,
+    `- Resolution: ${episode.episodePlan.runtime.resolution.width}x${episode.episodePlan.runtime.resolution.height}`,
+    `- Shots: ${episode.shotTimeline.shots.length}`,
+    `- Captions: ${episode.captionTrack.cues.length}`,
+    `- Characters: ${episode.episodePlan.characters.map((character) => character.name).join(", ")}`,
+    `- YouTube draft title: ${youtubeDraftMetadata.title}`,
+    "",
+    "## Asset Status",
+    "",
+    `- Status: ${typedAssetStatus}`,
+    `- Required typed assets: ${typedCartoonAssetSummary.requiredCharacterAssets.join(", ")}`,
+    `- Missing typed assets: ${missingCartoonCharacterAssets.length ? missingCartoonCharacterAssets.join(", ") : "none"}`,
+    "",
+    "Typed asset commands:",
+    "",
+    "```bash",
+    ...publicCartoonAssetInstructions,
+    "```",
+    "",
+    "## Timing Proof",
+    "",
+    `- Caption timing: ${captionTimingProof.status}`,
+    `- Max caption drift frames: ${captionTimingProof.maxDriftFrames}`,
+    `- Mouth source sync: ${visemeFrameSyncSourceProof.mouthMovementWithinOneFrame ? "pass" : "fail"}`,
+    "",
+    "## Human Review Checklist",
+    "",
+    "- [ ] Both characters are readable in representative frames.",
+    "- [ ] Captions do not cover important action.",
+    "- [ ] Mouth movement is visible during dialogue in the browser route.",
+    "- [ ] Character body motion is more than still-image wobble.",
+    "- [ ] No route chrome, proof panels, or debug overlays appear in encoded output.",
+    "- [ ] Reviewer name and approval date are recorded before publish-ready claims.",
+    "",
+    "## Boundary",
+    "",
+    input.hasWebm
+      ? "This package includes an encoded WebM output. Human review and asset readiness are still required before public publish-ready claims."
+      : "This package uses the PNG-sequence fallback marker because no real browser video encoder was attached. It is useful for package workflow proof, but it is not publish-ready video evidence.",
+    "",
+    `Render package metadata source: \`${renderOutputPackage.packageId}\``
+  ].join("\n");
+}

package/templates/cartoon-studio/test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}

package/templates/cartoon-studio/tests/episode-render.spec.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "@playwright/test";
+import {
+  createCartoonEpisodePackage,
+  createCartoonRenderManifestArtifact,
+  createRenderedPromptAnimationEvidenceArtifact
+} from "../src/episode-renderer";
+import { requiredCartoonEpisodePackageFiles } from "../src/review";
+
+test("episode renderer package declares encoded video and required package files", () => {
+  const pkg = createCartoonEpisodePackage("package");
+  const filePaths = new Set(pkg.files.map((file) => file.path));
+  const manifest = createCartoonRenderManifestArtifact();
+  const evidence = createRenderedPromptAnimationEvidenceArtifact();
+
+  expect(pkg.packageDirectory).toBe("dist/episodes/moon-garden-001");
+  expect(pkg.hasWebm).toBe(true);
+  expect(pkg.hasPngSequenceFallback).toBe(false);
+  expect(pkg.requiredFiles).toEqual([...requiredCartoonEpisodePackageFiles]);
+  expect([...requiredCartoonEpisodePackageFiles]
+    .filter((file) => file !== "episode.webm" && file !== "thumbnail.png")
+    .every((file) => filePaths.has(file))).toBe(true);
+  expect(filePaths.has("episode.webm")).toBe(false);
+  expect(filePaths.has("thumbnail.png")).toBe(false);
+  expect(pkg.files.filter((file) => /^frames\/frame-\d+\.svg$/.test(file.path)).length).toBeGreaterThan(20);
+
+  expect(manifest).toMatchObject({
+    artifact: "cartoon-render-manifest",
+    outputMode: "encoded-webm",
+    hasEncodedVideo: true,
+    encodedVideo: {
+      path: "episode.webm",
+      codec: "vp9"
+    }
+  });
+  expect(evidence).toMatchObject({
+    artifact: "prompt-animation-evidence",
+    ok: true,
+    renderOutput: {
+      mode: "encoded-webm",
+      encodedVideoPresent: true,
+      pngSequenceFallbackPresent: false
+    }
+  });
+});

package/templates/cartoon-studio/tests/motion-quality.spec.ts

@@ -0,0 +1,45 @@
+import { expect, test } from "@playwright/test";
+import { createCartoonMotionQualityArtifact, createCartoonVisualAcceptanceArtifact } from "../src/episode-renderer";
+
+test("motion quality rejects still-image wobble and requires regional character motion", () => {
+  const motion = createCartoonMotionQualityArtifact();
+
+  expect(motion).toMatchObject({
+    artifact: "cartoon-motion-quality",
+    videoPath: "episode.webm",
+    globalOnlyMotion: false,
+    flatLayerMotion: false,
+    cameraMotionDeclared: true,
+    rejectedEvidence: {
+      stillImageWobbleAccepted: false,
+      subtitleOverStillAccepted: false,
+      sourceOnlyAccepted: false
+    }
+  });
+  expect(motion.independentRegionMotionSegments).toBeGreaterThanOrEqual(2);
+  expect(motion.characterRegionMotionSegments).toBeGreaterThanOrEqual(2);
+  expect(motion.bodyRegionMotionSegments).toBeGreaterThanOrEqual(2);
+  expect(motion.mouthMotionSegments).toBeGreaterThanOrEqual(2);
+  expect(motion.regions.some((region) => region.kind === "mouth" && region.movesDuringDialogue)).toBe(true);
+  expect(motion.regions.some((region) => region.kind === "limb" && region.movesDuringAction)).toBe(true);
+});
+
+test("visual acceptance requires both characters and refuses source-only publish evidence", () => {
+  const visual = createCartoonVisualAcceptanceArtifact();
+
+  expect(visual).toMatchObject({
+    artifact: "cartoon-visual-acceptance",
+    ok: true,
+    visualOk: true,
+    encodedVideoPresent: true,
+    notTrue3DAccepted: false,
+    sourceOnlyAcceptedAsPublishProof: false,
+    requiredHumanReview: true,
+    visibleCharacterCount: 2,
+    globalOnlyMotion: false,
+    flatLayerMotion: false,
+    reviewerRequiredBeforePublish: true
+  });
+  expect(visual.frameHashChanges).toBeGreaterThan(1);
+  expect(visual.motionSegments.every((segment) => segment.independentRegionMotion)).toBe(true);
+});