create-aura3d 1.0.5

package/templates/prompt-cartoon-channel/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",
+      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/prompt-cartoon-channel/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"
+  }
+];

package/templates/prompt-cartoon-channel/tests/route-health.spec.ts

@@ -0,0 +1,7 @@
+import { expect, test } from "@playwright/test";
+
+test("cartoon channel route loads", async ({ page }) => {
+  await page.goto("/");
+  await expect(page.locator("#app")).toBeVisible();
+});
+

package/templates/prompt-cartoon-channel/tests/storyboard-playback.spec.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "@playwright/test";
+
+test("cartoon channel storyboard caption renders", async ({ page }) => {
+  await page.goto("/");
+  await expect(page.getByText(/Aura3D cartoon channel|moon|robot/i)).toBeVisible();
+});
+
+test("storyboard playback, character performance, caption timing, cuts, and nonblank cartoon frames are sourced", async ({
+  page
+}) => {
+  await page.goto("/");
+
+  const routeProof = (await page.evaluate(() => {
+    const template = (window as unknown as {
+      __AURA3D_CARTOON_TEMPLATE__?: {
+        shotIds: readonly string[];
+        captionIds: readonly string[];
+        storyBible?: unknown;
+        playbackProbeSamples: readonly unknown[];
+        sampleAt(time: number): unknown;
+      };
+    }).__AURA3D_CARTOON_TEMPLATE__;
+    return {
+      shotIds: template?.shotIds ?? [],
+      captionIds: template?.captionIds ?? [],
+      storyBible: template?.storyBible,
+      samples: [1, 21, 43].map((time) => template?.sampleAt(time)),
+      playbackProbeSamples: template?.playbackProbeSamples ?? [],
+      bodyShotCount: document.body.dataset.cartoonShotCount,
+      bodyCaptionCount: document.body.dataset.cartoonCaptionCount
+    };
+  })) as {
+    shotIds: string[];
+    captionIds: string[];
+    storyBible?: {
+      props?: unknown[];
+      styleGuide?: { visualStyle?: string };
+      shotList?: unknown[];
+    };
+    samples: Array<{
+      shotId?: string;
+      captionId?: string;
+      captionText?: string;
+      cameraMove?: string;
+      transitionOut?: string;
+      nodeUpdates?: Array<{ characterId?: string; action?: string; emotion?: string }>;
+    }>;
+    playbackProbeSamples: unknown[];
+    bodyShotCount?: string;
+    bodyCaptionCount?: string;
+  };
+
+  expect(routeProof.shotIds).toEqual([
+    "shot-moon-garden-open",
+    "shot-glow-stone-teamwork",
+    "shot-moon-garden-finish"
+  ]);
+  expect(new Set(routeProof.samples.map((sample) => sample.shotId)).size).toBe(3);
+  expect(routeProof.captionIds).toHaveLength(6);
+  expect(routeProof.samples.every((sample) => sample.captionId && sample.captionText)).toBe(true);
+  expect(routeProof.samples.some((sample) => sample.cameraMove === "push-in" || sample.transitionOut === "cut")).toBe(true);
+  expect(routeProof.samples.flatMap((sample) => sample.nodeUpdates ?? []).some((update) => update.action === "speak")).toBe(true);
+  expect(routeProof.samples.flatMap((sample) => sample.nodeUpdates ?? []).some((update) => update.characterId === "miko")).toBe(true);
+  expect(routeProof.samples.flatMap((sample) => sample.nodeUpdates ?? []).some((update) => update.characterId === "luma")).toBe(true);
+  expect(routeProof.storyBible?.props?.length).toBeGreaterThanOrEqual(3);
+  expect(routeProof.storyBible?.styleGuide?.visualStyle).toMatch(/cartoon/i);
+  expect(routeProof.storyBible?.shotList).toHaveLength(3);
+  expect(routeProof.playbackProbeSamples).toHaveLength(3);
+  expect(routeProof.bodyShotCount).toBe("3");
+  expect(routeProof.bodyCaptionCount).toBe("6");
+
+  const screenshot = await page.screenshot();
+  expect(screenshot.byteLength).toBeGreaterThan(2048);
+});

package/templates/prompt-cartoon-channel/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "jsx": "react-jsx",
+    "types": ["vite/client"]
+  },
+  "include": ["src"]
+}
+