create-aura3d 1.0.8 → 1.0.10

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

@@ -0,0 +1,265 @@
+import {
+  camera,
+  captionCueAtTime,
+  createAuraApp,
+  createShotPlaybackPlan,
+  effects,
+  game,
+  installShotPlayback,
+  labels,
+  lights,
+  material,
+  model,
+  primitives,
+  sampleAuraVoiceBridgeAtTime,
+  sampleShotPlaybackPlan,
+  scene,
+  type AuraAssetRef
+} from "@aura3d/engine";
+import { assets } from "./aura-assets";
+import {
+  episode,
+  episodeContractId,
+  missingCartoonCharacterAssets,
+  publicCartoonAssetInstructions,
+  requiredCartoonCharacterAssets,
+  typedCartoonAssetSummary,
+  type CartoonAssetKey
+} from "./episode";
+import {
+  accessibilityProofMetadata,
+  auraVoicePackage,
+  bridgeIssues,
+  bridgeSampleAtThumbnail,
+  captionFrameSyncSourceProof,
+  captionTimingProof,
+  deterministicScreenshotFixtures,
+  glbVisemeRuntimeExample,
+  promptAnimationEvidence,
+  primitiveMouthRuntimeExample,
+  phonemeVisemeDubSyncSourceProof,
+  publishReadiness,
+  renderOutputPackage,
+  renderPlan,
+  sampleRenderSourceWorkflow,
+  visemeFrameSyncSourceProof,
+  visemeTrack
+} from "./render-plan";
+import { cartoonStudioSupport, installCartoonStudioPanel } from "./studio";
+
+declare global {
+  interface Window {
+    __AURA3D_CARTOON_TEMPLATE__?: {
+      readonly contractId: string;
+      readonly template: string;
+      readonly storyBible: unknown;
+      readonly shotIds: readonly string[];
+      readonly captionIds: readonly string[];
+      readonly playbackProbeTimes: readonly number[];
+      readonly playbackProbeSamples: readonly unknown[];
+      readonly renderQueueItems: number;
+      readonly typedAssets: unknown;
+      readonly requiredTypedAssets: readonly string[];
+      readonly missingTypedAssets: readonly string[];
+      readonly assetCommands: readonly string[];
+      readonly bridgeIssues: readonly unknown[];
+      readonly promptAnimationEvidence: unknown;
+      readonly publishReadiness: unknown;
+      readonly studio: unknown;
+      readonly sourceProofs: unknown;
+      readonly sampleRenderSourceWorkflow: unknown;
+      sampleAt(time: number): unknown;
+    };
+  }
+}
+
+const firstStoryboardShot = episode.storyboard.scenes[0]?.shots[0];
+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 captionOverlay = document.createElement("div");
+captionOverlay.id = "caption-overlay";
+captionOverlay.textContent = firstCaption?.text ?? firstStoryboardShot?.storyBeat ?? "Aura3D cartoon studio";
+captionOverlay.style.cssText = [
+  "position:fixed",
+  "left:50%",
+  "bottom:28px",
+  "transform:translateX(-50%)",
+  "max-width:min(840px,calc(100vw - 32px))",
+  "padding:12px 18px",
+  "border-radius:14px",
+  "background:rgba(3,12,20,0.88)",
+  "color:#f8fff2",
+  "font:700 18px/1.35 ui-rounded, Trebuchet MS, sans-serif",
+  "letter-spacing:0.01em",
+  "text-align:center",
+  "box-shadow:0 10px 30px rgba(0,0,0,0.28)",
+  "z-index:10"
+].join(";");
+document.body.appendChild(captionOverlay);
+
+const shotPlaybackPlan = createShotPlaybackPlan({
+  timeline: episode.shotTimeline,
+  performance: episode.performance,
+  captions: episode.captionTrack,
+  visemes: visemeTrack,
+  runtimeNodeByCharacterId: {
+    miko: "miko",
+    luma: "luma"
+  },
+  loop: true
+});
+
+const playbackProbeTimes = [1, 21, 43] as const;
+const playbackProbeSamples = playbackProbeTimes.map((time) => sampleCartoonRouteAt(time));
+captionOverlay.dataset.shotId = playbackProbeSamples[0]?.shotId ?? "";
+captionOverlay.dataset.captionId = playbackProbeSamples[0]?.captionId ?? firstCaption?.captionId ?? "";
+document.body.dataset.cartoonShotCount = String(episode.shotTimeline.shots.length);
+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);
+
+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(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(createMouthCard("luma:mouth", "Luma", [0.8, 0.77, 0.32], "#40ffbf"))
+    .add(
+      primitives
+        .box({ name: "moon garden path", material: material.pbr({ color: "#182d3f", roughness: 0.78 }) })
+        .position(0, 0.05, 0)
+        .scale([2.8, 0.04, 0.8])
+    )
+    .add(
+      primitives
+        .sphere({ name: "glow stones primitive fallback", material: material.emissive({ color: "#ffe18e", emissive: "#ffe18e", emissiveIntensity: 0.42 }) })
+        .position(0.18, 0.16, 0.28)
+        .scale([0.16, 0.08, 0.16])
+    )
+    .add(
+      primitives
+        .box({ name: "moon lilies primitive fallback", material: material.pbr({ color: "#f8fff2", roughness: 0.5 }) })
+        .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(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
+});
+
+window.__AURA3D_CARTOON_TEMPLATE__ = {
+  contractId: episodeContractId,
+  template: "cartoon-studio",
+  storyBible,
+  shotIds: episode.shotTimeline.shots.map((shot) => shot.shotId),
+  captionIds: episode.captionTrack.cues.map((caption) => caption.captionId),
+  playbackProbeTimes,
+  playbackProbeSamples,
+  renderQueueItems: renderPlan.items.length,
+  typedAssets: typedCartoonAssetSummary,
+  requiredTypedAssets: requiredCartoonCharacterAssets,
+  missingTypedAssets: missingCartoonCharacterAssets,
+  assetCommands: publicCartoonAssetInstructions,
+  bridgeIssues,
+  promptAnimationEvidence,
+  publishReadiness,
+  studio: cartoonStudioSupport,
+  sourceProofs: {
+    captionFrameSyncSourceProof,
+    visemeFrameSyncSourceProof,
+    phonemeVisemeDubSyncSourceProof
+  },
+  sampleRenderSourceWorkflow,
+  sampleAt(time: number) {
+    return sampleCartoonRouteAt(time);
+  }
+};
+
+installShotPlayback(app, shotPlaybackPlan, {
+  primitiveMouthNodeByCharacterId: {
+    miko: "miko:mouth",
+    luma: "luma:mouth"
+  },
+  onCaption(caption, framePlan) {
+    captionOverlay.textContent = caption?.text ?? firstCaption?.text ?? "";
+    captionOverlay.dataset.shotId = framePlan.shotId ?? "";
+    captionOverlay.dataset.captionId = caption?.captionId ?? "";
+  }
+});
+
+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({
+      name: `${name} primitive mouth card`,
+      material: material.emissive({ color, emissive: color, emissiveIntensity: 0.32 })
+    })
+    .position(position[0], position[1], position[2])
+    .scale([0.22, 0.035, 0.025])
+    .runtime(game.runtimeNode(id, { tags: ["mouth", "primitive", name.toLowerCase()] }));
+}
+
+function sampleCartoonRouteAt(time: number) {
+  const bridgeSample = sampleAuraVoiceBridgeAtTime(auraVoicePackage, time);
+  const playbackSample = sampleShotPlaybackPlan(shotPlaybackPlan, time);
+  const caption = captionCueAtTime(episode.captionTrack, time);
+  const speakingCharacterId = bridgeSample.dialogue?.speakerId;
+  return {
+    time,
+    frame: bridgeSample.frame,
+    shotId: bridgeSample.shot?.shotId,
+    sceneId: bridgeSample.shot?.sceneId,
+    captionId: caption?.captionId,
+    captionText: caption?.text,
+    cameraMove: bridgeSample.shot?.camera.move,
+    transitionOut: bridgeSample.shot?.transitionOut,
+    dialogueLineId: bridgeSample.dialogue?.lineId,
+    visemeId: bridgeSample.viseme?.primaryVisemeId,
+    nodeUpdates: playbackSample.nodeUpdates.map((update) => ({
+      characterId: update.characterId,
+      action: speakingCharacterId === update.characterId ? "speak" : update.action,
+      emotion: update.emotion,
+      position: update.position
+    })),
+    sourceShotCharacters: (bridgeSample.shot?.characters ?? []).map((character) => ({
+      characterId: character.characterId,
+      action: speakingCharacterId === character.characterId ? "speak" : character.action,
+      emotion: character.emotion,
+      position: character.position
+    }))
+  };
+}

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

@@ -0,0 +1,405 @@
+import {
+  collectPromptAnimationEvidence,
+  createAudioStemManifest,
+  createAuraVoiceBridgePackage,
+  createAuraVoiceVisemeTrack,
+  createCaptionTimingProof,
+  createGlbBlendshapeVisemeCue,
+  createCartoonPerformanceCoverage,
+  createCartoonRenderOutputPackageMetadata,
+  createPrimitiveMouthVisemeCues,
+  createPromptAnimationDeterministicScreenshotFixtureMetadata,
+  evaluatePromptAnimationPublishReadiness,
+  defineDubMap,
+  glbVisemeBlendshapeExample,
+  primitiveMouthVisemeExample,
+  sampleAuraVoiceBridgeAtTime,
+  sampleVisemeTrack,
+  validateAuraVoiceBridgePackage
+} from "@aura3d/engine";
+import {
+  episode,
+  episodeAudioCues,
+  episodeContractId,
+  missingCartoonCharacterAssets,
+  publicCartoonAssetInstructions,
+  requiredCartoonCharacterAssets,
+  typedCartoonAssetSummary,
+  youtubeDraftMetadata
+} from "./episode";
+
+const frameRate = episode.episodePlan.runtime.frameRate;
+
+export const renderContractId = episodeContractId;
+
+export const renderPlan = episode.renderQueue;
+
+export const renderOutputPackage = createCartoonRenderOutputPackageMetadata({
+  episodePlan: episode.episodePlan,
+  shotTimeline: episode.shotTimeline,
+  renderQueue: renderPlan,
+  youtube: youtubeDraftMetadata,
+  generatedAt: episode.episodePlan.generatedAt
+});
+
+export const audioStemManifest = createAudioStemManifest({
+  episodeId: episode.episodePlan.episodeId,
+  duration: episode.dialogueTrack.duration,
+  stems: [
+    ...episode.dialogueTrack.lines.map((line) => ({
+      id: `audio:${line.lineId}`,
+      role: "dialogue" as const,
+      path: line.audioFile ?? `assets/audio/en/${line.lineId}.wav`,
+      startTime: line.startTime,
+      duration: line.endTime - line.startTime,
+      language: line.language
+    })),
+    ...episodeAudioCues
+  ],
+  generatedAt: episode.episodePlan.generatedAt
+});
+
+export const visemeTrack = createAuraVoiceVisemeTrack({
+  episodeId: episode.episodePlan.episodeId,
+  language: episode.episodePlan.language,
+  frameRate,
+  cues: episode.dialogueTrack.lines.flatMap((line) =>
+    createPrimitiveMouthVisemeCues({
+      characterId: line.speakerId,
+      speakerId: line.speakerId,
+      lineId: line.lineId,
+      startTime: line.startTime,
+      endTime: line.endTime
+    }).map((cue, cueIndex) => {
+      const words = line.text.split(/\s+/).filter(Boolean);
+      const wordIndex = Math.min(cueIndex, Math.max(0, words.length - 1));
+      return createGlbBlendshapeVisemeCue({
+        ...cue,
+        phoneme: cue.visemeId === "m" ? "M" : "AH",
+        phonemeId: `${line.lineId}:phoneme-${cueIndex + 1}`,
+        word: words[wordIndex] ?? line.text,
+        wordIndex,
+        wordStartTime: cue.startTime,
+        wordEndTime: cue.endTime
+      });
+    })
+  ),
+  generatedAt: episode.episodePlan.generatedAt
+});
+
+export const primitiveMouthRuntimeExample = {
+  ...primitiveMouthVisemeExample,
+  runtimeNodes: {
+    miko: "miko:mouth",
+    luma: "luma:mouth"
+  }
+} as const;
+
+export const glbVisemeRuntimeExample = {
+  ...glbVisemeBlendshapeExample,
+  typedAssetExample: "import { assets } from './aura-assets'; model(assets.character)",
+  sampleBlendshapeNames: Object.values(glbVisemeBlendshapeExample.blendshapeMap).slice(0, 6)
+} as const;
+
+export const captionTimingProof = createCaptionTimingProof(episode.dialogueTrack, episode.captionTrack, {
+  frameRate,
+  maxAllowedDriftFrames: 1
+});
+
+function frameDriftFrames(actual: number, expected: number) {
+  return Math.round(Math.abs(actual - expected) * frameRate);
+}
+
+const visemeLineSyncChecks = episode.dialogueTrack.lines.map((line) => {
+  const cues = visemeTrack.cues.filter((cue) => cue.lineId === line.lineId && cue.speakerId === line.speakerId);
+  const firstCue = cues[0];
+  const lastCue = cues[cues.length - 1];
+  const startDriftFrames = firstCue ? frameDriftFrames(firstCue.startTime, line.startTime) : 999;
+  const endDriftFrames = lastCue ? frameDriftFrames(lastCue.endTime, line.endTime) : 999;
+  const sampleTime = Math.min(line.endTime - 1 / frameRate, line.startTime + 1 / frameRate);
+  const sampledMouth = sampleVisemeTrack(visemeTrack, sampleTime, line.speakerId);
+  return {
+    lineId: line.lineId,
+    speakerId: line.speakerId,
+    characterId: line.speakerId,
+    cueCount: cues.length,
+    startDriftFrames,
+    endDriftFrames,
+    maxDriftFrames: Math.max(startDriftFrames, endDriftFrames),
+    sampledMouthState: {
+      time: sampleTime,
+      frame: Math.round(sampleTime * frameRate),
+      visemeId: sampledMouth.visemeId,
+      mouthOpenness: sampledMouth.mouthOpenness,
+      primitiveMouthCard: sampledMouth.primitiveMouthCard,
+      blendshapeWeights: sampledMouth.blendshapeWeights
+    }
+  };
+});
+
+const maxVisemeLineDriftFrames = Math.max(0, ...visemeLineSyncChecks.map((check) => check.maxDriftFrames));
+const missingVisemeLineIds = visemeLineSyncChecks
+  .filter((check) => check.cueCount === 0 || check.maxDriftFrames > 1)
+  .map((check) => check.lineId);
+
+export const captionFrameSyncSourceProof = {
+  contractId: renderContractId,
+  sourceOnly: true,
+  proofType: "caption-display-one-frame-source-harness",
+  frameRate,
+  allowedDriftFrames: 1,
+  allowedFrameDurationSeconds: 1 / frameRate,
+  captionDisplayWithinOneFrame: captionTimingProof.status === "pass" && captionTimingProof.maxDriftFrames <= 1,
+  maxObservedDriftFrames: captionTimingProof.maxDriftFrames,
+  coveredLineIds: captionTimingProof.coveredLineIds,
+  missingLineIds: captionTimingProof.missingLineIds,
+  sampledCaptionCues: captionTimingProof.lines.map((line) => ({
+    lineId: line.lineId,
+    captionCueId: line.captionId,
+    startDriftFrames: line.startDriftFrames,
+    endDriftFrames: line.endDriftFrames,
+    maxDriftFrames: line.maxDriftFrames
+  })),
+  executionBoundary: "Source harness only; actual caption display proof requires rendered frame/video evidence."
+} as const;
+
+export const visemeFrameSyncSourceProof = {
+  contractId: renderContractId,
+  sourceOnly: true,
+  proofType: "mouth-movement-one-frame-source-harness",
+  frameRate,
+  allowedDriftFrames: 1,
+  allowedFrameDurationSeconds: 1 / frameRate,
+  mouthMovementWithinOneFrame: missingVisemeLineIds.length === 0 && maxVisemeLineDriftFrames <= 1,
+  maxObservedDriftFrames: maxVisemeLineDriftFrames,
+  coveredLineIds: visemeLineSyncChecks.filter((check) => check.cueCount > 0).map((check) => check.lineId),
+  missingLineIds: missingVisemeLineIds,
+  sampledMouthStates: visemeLineSyncChecks.map((check) => ({
+    lineId: check.lineId,
+    speakerId: check.speakerId,
+    characterId: check.characterId,
+    ...check.sampledMouthState
+  })),
+  primitiveMouthRuntimeNodeIds: primitiveMouthRuntimeExample.runtimeNodes,
+  glbBlendshapeNames: glbVisemeRuntimeExample.sampleBlendshapeNames,
+  executionBoundary: "Source harness only; actual mouth movement proof requires rendered frame/video evidence."
+} as const;
+
+function shotForLine(lineId: string) {
+  return episode.shotTimeline.shots.find((shot) => lineId.startsWith(`${shot.shotId}:line-`));
+}
+
+export const spanishDubMap = defineDubMap({
+  artifact: "dub-map",
+  contractId: episode.dialogueTrack.contractId,
+  episodeId: episode.episodePlan.episodeId,
+  sourceLanguage: "en",
+  targetLanguage: "es",
+  entries: episode.dialogueTrack.lines.map((line) => {
+    const shot = shotForLine(line.lineId);
+    return {
+      originalStoryboardId: shot?.sceneId,
+      dubbedStoryboardId: shot?.sceneId,
+      originalStoryboardSceneId: shot?.sceneId,
+      dubbedStoryboardSceneId: shot?.sceneId,
+      originalLineId: line.lineId,
+      dubbedLineId: line.lineId,
+      originalCaptionId: `${line.lineId}:caption`,
+      dubbedCaptionId: `${line.lineId}:caption`,
+      originalCharacterId: line.speakerId,
+      dubbedCharacterId: line.speakerId,
+      originalSpeakerId: line.speakerId,
+      dubbedSpeakerId: line.speakerId,
+      originalLanguage: line.language,
+      dubbedLanguage: "es",
+      originalShotId: shot?.shotId,
+      dubbedShotId: shot?.shotId,
+      originalSceneId: shot?.sceneId,
+      dubbedSceneId: shot?.sceneId
+    };
+  }),
+  generatedAt: episode.episodePlan.generatedAt
+});
+
+export const phonemeVisemeDubSyncSourceProof = {
+  contractId: renderContractId,
+  sourceOnly: true,
+  proofType: "phoneme-viseme-dub-sync-source-harness",
+  visemeFormat: visemeTrack.format,
+  frameRate,
+  allowedDriftFrames: 1,
+  phonemeFields: ["phoneme", "phonemeId", "word", "wordIndex", "wordStartTime", "wordEndTime"],
+  sampledPhonemeVisemeCues: visemeTrack.cues.slice(0, 8).map((cue) => ({
+    cueId: cue.id,
+    lineId: cue.lineId,
+    speakerId: cue.speakerId,
+    characterId: cue.characterId,
+    visemeId: cue.visemeId,
+    phoneme: cue.phoneme,
+    phonemeId: cue.phonemeId,
+    word: cue.word,
+    wordIndex: cue.wordIndex,
+    wordStartTime: cue.wordStartTime,
+    wordEndTime: cue.wordEndTime,
+    startTime: cue.startTime,
+    endTime: cue.endTime
+  })),
+  dubContinuity: {
+    sourceLanguage: spanishDubMap.sourceLanguage,
+    targetLanguage: spanishDubMap.targetLanguage,
+    stableShotIds: spanishDubMap.entries.every((entry) => entry.originalShotId === entry.dubbedShotId),
+    stableStoryboardIds: spanishDubMap.entries.every((entry) => entry.originalStoryboardId === entry.dubbedStoryboardId),
+    stableCaptionIds: spanishDubMap.entries.every((entry) => entry.originalCaptionId === entry.dubbedCaptionId),
+    stableLineIds: spanishDubMap.entries.every((entry) => entry.originalLineId === entry.dubbedLineId)
+  },
+  executionBoundary: "Source harness only; actual phoneme, viseme, and dub playback proof requires rendered frame/video evidence."
+} as const;
+
+export const performanceCoverage = createCartoonPerformanceCoverage(episode.performance, episode.dialogueTrack);
+
+export const reviewPackagePaths = renderOutputPackage.reviewPackagePaths;
+
+export const thumbnailCapture = renderOutputPackage.thumbnailCapture;
+
+export const plannedDeterministicCaptureSources = renderPlan.items.map((item) => ({
+  renderQueueItemId: item.id,
+  time: item.time,
+  frame: item.frame,
+  ...(item.shotId ? { shotId: item.shotId } : {}),
+  sourceSceneStateId: item.sourceSceneState?.sceneStateId,
+  auraVoiceTimestamp: item.sourceSceneState?.auraVoiceTimestamp ?? item.time,
+  deterministicSeed: item.sourceSceneState?.deterministicSeed
+}));
+
+export const sampleRenderSourceWorkflow = {
+  contractId: renderContractId,
+  sourceOnly: true,
+  status: "source-workflow-ready",
+  promptToAudioToAura3DAnimation: true,
+  sampleEpisodeId: episode.episodePlan.episodeId,
+  runtimeSeconds: episode.episodePlan.runtime.duration,
+  minimumRuntimeSeconds: 60,
+  frameRate,
+  resolution: episode.episodePlan.runtime.resolution,
+  shotCount: episode.shotTimeline.shots.length,
+  speakingCharacterIds: Array.from(new Set(episode.dialogueTrack.lines.map((line) => line.speakerId))),
+  requiredTypedAssets: requiredCartoonCharacterAssets,
+  typedAssetSummary: typedCartoonAssetSummary,
+  missingTypedCharacterAssets: missingCartoonCharacterAssets,
+  assetCommands: publicCartoonAssetInstructions,
+  audioStemRoles: audioStemManifest.stems.map((stem) => stem.role),
+  requiresNoManualTimingEdits: true,
+  doesNotClaimRenderedArtifacts: true,
+  humanReviewRequired: true,
+  captionFrameSyncSourceProof,
+  visemeFrameSyncSourceProof,
+  phonemeVisemeDubSyncSourceProof,
+  artifactManifestExpectations: {
+    video: {
+      required: true,
+      outputId: renderOutputPackage.outputs.mp4?.id,
+      path: renderOutputPackage.outputs.mp4?.path,
+      evidenceJsonFields: ["path", "sha256", "byteSize", "duration", "frameRate", "resolution", "renderQueueId"]
+    },
+    thumbnail: {
+      required: true,
+      outputId: renderOutputPackage.outputs.thumbnail?.id,
+      path: renderOutputPackage.outputs.thumbnail?.path,
+      sourceSceneStateId: renderOutputPackage.thumbnailCapture.sourceSceneStateId,
+      evidenceJsonFields: ["path", "sha256", "byteSize", "width", "height", "captureTime", "shotId", "sourceSceneStateId"]
+    },
+    captions: {
+      required: true,
+      outputIds: renderOutputPackage.outputs.captions.map((output) => output.id),
+      paths: renderOutputPackage.outputs.captions.map((output) => output.path),
+      evidenceJsonFields: ["path", "sha256", "byteSize", "language", "cueCount", "captionTrackId"]
+    },
+    timeline: {
+      required: true,
+      outputId: renderOutputPackage.outputs.timelineJson?.id,
+      path: renderOutputPackage.outputs.timelineJson?.path,
+      evidenceJsonFields: ["path", "sha256", "byteSize", "shotTimelineId", "frameRate", "duration"]
+    },
+    audioStems: {
+      required: true,
+      artifact: audioStemManifest.artifact,
+      path: "dist/render/audio-stems.json",
+      stemCount: audioStemManifest.stems.length,
+      evidenceJsonFields: ["path", "sha256", "byteSize", "stemCount", "dialogueStemCount", "sfxStemCount"]
+    },
+    evidenceJson: {
+      required: true,
+      outputId: renderOutputPackage.outputs.evidenceJson?.id,
+      path: renderOutputPackage.outputs.evidenceJson?.path,
+      evidenceJsonFields: ["path", "sha256", "byteSize", "schema", "ok", "gates", "proofs"]
+    },
+    youtubeDraftMetadata: {
+      required: true,
+      outputId: renderOutputPackage.outputs.youtubeMetadata?.id,
+      path: renderOutputPackage.outputs.youtubeMetadata?.path,
+      evidenceJsonFields: ["title", "description", "language", "videoPath", "thumbnailPath", "captionsPath"]
+    }
+  },
+  requiredEvidenceJsonFields: [
+    "artifacts.video",
+    "artifacts.thumbnail",
+    "artifacts.captions",
+    "artifacts.timeline",
+    "artifacts.audioStems",
+    "artifacts.evidenceJson",
+    "captionFrameSyncSourceProof.captionDisplayWithinOneFrame",
+    "visemeFrameSyncSourceProof.mouthMovementWithinOneFrame",
+    "phonemeVisemeDubSyncSourceProof.sampledPhonemeVisemeCues",
+    "phonemeVisemeDubSyncSourceProof.dubContinuity.stableShotIds",
+    "humanReview.status"
+  ],
+  remainingProofGates: [
+    "Fresh scaffold npm run build output",
+    "Browser route health and storyboard playback output",
+    "Typed character GLBs added through src/aura-assets.ts",
+    "npx @aura3d/cli@latest assets validate-cartoon output",
+    "Actual 60-second MP4/WebM render artifact",
+    "Actual thumbnail artifact captured from the same Aura3D scene state",
+    "Actual captions/timeline/audio-stems/evidence JSON files with hashes",
+    "Human visual review approval"
+  ]
+} as const;
+
+export const auraVoicePackage = createAuraVoiceBridgePackage({
+  episodePlan: episode.episodePlan,
+  storyboard: episode.storyboard,
+  shotTimeline: episode.shotTimeline,
+  dialogueTrack: episode.dialogueTrack,
+  captionTrack: episode.captionTrack,
+  visemes: visemeTrack,
+  audioStems: audioStemManifest,
+  dubMap: spanishDubMap,
+  renderQueue: renderPlan,
+  renderOutputPackage
+}, {
+  route: "/",
+  frameRate,
+  maxTimingDriftFrames: 1,
+  youtube: youtubeDraftMetadata
+});
+
+export const deterministicScreenshotFixtures = createPromptAnimationDeterministicScreenshotFixtureMetadata({
+  bridgePackage: auraVoicePackage,
+  count: 3,
+  pathPrefix: "artifacts/screenshots/moon-garden"
+});
+
+export const accessibilityProofMetadata = auraVoicePackage.artifacts.episodePlan.accessibilityProof;
+
+export const bridgeIssues = validateAuraVoiceBridgePackage(auraVoicePackage);
+
+export const bridgeSampleAtThumbnail = sampleAuraVoiceBridgeAtTime(auraVoicePackage, renderOutputPackage.thumbnailCapture.time);
+
+export const promptAnimationEvidence = collectPromptAnimationEvidence({
+  bridgePackage: auraVoicePackage,
+  performanceCoverage,
+  routeHealth: { status: "missing" },
+  generatedAt: episode.episodePlan.generatedAt
+});
+
+export const publishReadiness = evaluatePromptAnimationPublishReadiness(promptAnimationEvidence);

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

@@ -0,0 +1,14 @@
+import { AURAVOICE_AURA3D_PROMPT_ANIMATION_CONTRACT_ID } from "./contract";
+
+export const setContractId = AURAVOICE_AURA3D_PROMPT_ANIMATION_CONTRACT_ID;
+
+export const sets = [
+  {
+    id: "moon-garden",
+    name: "Moon Garden",
+    layers: ["foreground flowers", "midground robot path", "background planet skyline"],
+    primitiveFallbackProps: ["glow-broom", "glow-stones", "moon-lilies"],
+    optionalTypedAssetKeys: ["glowBroom", "glowStones", "moonLilies"],
+    safety: "soft colors, readable captions, reduced flash by default"
+  }
+];