@docyrus/animaguru 0.6.0

package/templates/video/scripts/install-example.mjs

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import { readFile, writeFile, mkdir, copyFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root=fileURLToPath(new URL("../",import.meta.url));
+const copy=JSON.parse(await readFile(path.join(root,"shared/locales/en/style-studies.json"),"utf8"));
+const id=process.argv[2];
+if(process.argv.length!==3 || !Object.hasOwn(copy.styles,id)) throw new Error(`Choose an installed example: npm run example -- ${Object.keys(copy.styles).join(" | ")}`);
+const film=await readFile(path.join(root,"src/film.ts"),"utf8");
+const expected=(await readFile(path.join(root,"scripts/starter-film.sha256"),"utf8")).trim();
+const digest=createHash("sha256").update(film).digest("hex");
+// Reruns also refuse edited studies; the exact last installer output is hashed.
+let previous;
+try { previous=JSON.parse(await readFile(path.join(root,"production/example-selection.json"),"utf8")); } catch(error) { if(error.code!=="ENOENT")throw error; }
+if(digest!==expected && digest!==previous?.filmSha256) throw new Error("This film has been authored. Import the study into your timeline instead; example installation refuses to replace it.");
+const backup=path.join(root,"production/example-backup");
+await mkdir(backup,{recursive:true});
+for(const file of ["src/film.ts","film.config.json","shared/locales/en/player.json"]) {
+  const destination=path.join(backup,path.basename(file));
+  try { await copyFile(path.join(root,file),destination,1); } catch(error) { if(error.code!=="EEXIST")throw error; }
+}
+const authored=`import { StyleStudyFilm, studyChapters } from "./studies/film";\nimport type { Application } from "pixi.js";\nexport const chapters = studyChapters(${JSON.stringify(id)});\nexport class Film extends StyleStudyFilm {\n  constructor(app: Application) { super(app, ${JSON.stringify(id)}); }\n}\n`;
+const config=JSON.parse(await readFile(path.join(root,"film.config.json"),"utf8"));
+Object.assign(config,{title:copy.styles[id].name,slug:id,duration:8,audio:null,language:"en"});
+const player=JSON.parse(await readFile(path.join(root,"shared/locales/en/player.json"),"utf8"));
+Object.assign(player,{template:copy.styles[id].name,starter:"Original style study · adapt to your brief"});
+await writeFile(path.join(root,"src/film.ts"),authored);
+await writeFile(path.join(root,"film.config.json"),JSON.stringify(config,null,2)+"\n");
+await writeFile(path.join(root,"shared/locales/en/player.json"),JSON.stringify(player,null,2)+"\n");
+await writeFile(path.join(root,"production/example-selection.json"),JSON.stringify({id,filmSha256:createHash("sha256").update(authored).digest("hex")},null,2)+"\n");
+console.log(`Installed ${copy.styles[id].name}. Run npm run dev. HTML5 and MP4 export use this film. Original starter files are in production/example-backup/.`);

package/templates/video/scripts/review-analysis.mjs

@@ -0,0 +1,29 @@
+/** Numerical checks complement viewing; they do not infer visual occlusion or factual truth. */
+export function analyzeReview(report, config) {
+  const problems=[],warnings=[],runs=new Map(),active=new Map();
+  const finish=(key)=>{const run=active.get(key);if(run){const previous=runs.get(key);if(!previous||run.duration>previous.duration)runs.set(key,run);active.delete(key);}};
+  for(const sample of report.samples) {
+    const seen=new Set();
+    for(const b of sample.texts) {
+      const key=`${b.id}\0${b.text}`;
+      if(!b.text.trim())continue;
+      seen.add(key);
+      const inside=[b.x,b.y,b.width,b.height].every(Number.isFinite)&&b.x>=-.5&&b.y>=-.5&&b.x+b.width<=config.width+.5&&b.y+b.height<=config.height+.5;
+      if(!inside) { finish(key);problems.push({type:"text-bounds",time:sample.time,text:b.text});continue; }
+      const run=active.get(key)??{text:b.text,start:sample.time,duration:0};
+      run.duration=sample.time-run.start+.2;active.set(key,run);
+    }
+    for(const key of active.keys())if(!seen.has(key))finish(key);
+  }
+  for(const key of active.keys())finish(key);
+  for(const run of runs.values()) {
+    const need=Math.max(.8,[...run.text].filter((c)=>! /\s/.test(c)).length/25);
+    if(run.duration<need)warnings.push({type:"reading-hold",...run,suggested:need});
+  }
+  if(!report.samples.some((s)=>s.texts.length))warnings.push({type:"text-not-checked",message:"Expose actual visible text bounds through window.animaguru.texts."});
+  if(report.seekMatches.some((s)=>!s.match))problems.push({type:"seek-determinism",samples:report.seekMatches.filter((s)=>!s.match)});
+  for(const cue of report.cues??[]) {
+    if(cue.audioTime!==undefined&&Math.abs(cue.time-cue.audioTime)>1/config.fps)problems.push({type:"cue-alignment",cue});
+  }
+  return {pass:problems.length===0,problems,warnings,readingRuns:[...runs.values()]};
+}

package/templates/video/scripts/review-audio.mjs

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import ffmpeg from "@ffmpeg-installer/ffmpeg";
+import ffprobe from "@ffprobe-installer/ffprobe";
+
+const run=promisify(execFile);
+export async function inspectAudio(root,config) {
+  if(!config.audio)return {status:"silent",message:"No soundtrack configured; audio checks are not applicable."};
+  const publicRoot=path.resolve(root,"public"),file=path.resolve(publicRoot,config.audio);
+  if(!file.startsWith(publicRoot+path.sep))throw new Error("Soundtrack must be inside public/.");
+  const {stdout}=await run(ffprobe.path,["-v","error","-show_streams","-show_format","-of","json",file]);
+  const probe=JSON.parse(stdout),stream=probe.streams.find((s)=>s.codec_type==="audio");
+  if(!stream)throw new Error("Configured soundtrack has no audio stream.");
+  const {stderr}=await run(ffmpeg.path,["-hide_banner","-nostats","-i",file,"-af","loudnorm=I=-14:TP=-1.2:print_format=json","-f","null","-"],{maxBuffer:1024*1024});
+  const json=stderr.match(/\{\s*"input_i"[\s\S]*?\}/)?.[0];
+  if(!json)throw new Error("Audio loudness could not be measured.");
+  const levels=JSON.parse(json),duration=Number(probe.format.duration);
+  return {status:"measured",duration,sampleRate:Number(stream.sample_rate),integratedLufs:levels.input_i,truePeakDb:levels.input_tp,notes:[
+    ...(Math.abs(duration-config.duration)>.15?["Soundtrack duration differs from the film; inspect padding or truncation."]:[]),
+    ...(Number.isFinite(Number(levels.input_i))&&Math.abs(Number(levels.input_i)+14)>2?["Review soundtrack loudness for the intended placement."]:[]),
+    ...(Number(levels.input_tp)>-1?["True peak is above -1 dB; inspect clipping/headroom."]:[]),
+  ]};
+}

package/templates/video/scripts/review.mjs

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createServer } from "vite";
+import { analyzeReview } from "./review-analysis.mjs";
+import { inspectAudio } from "./review-audio.mjs";
+
+const root=fileURLToPath(new URL("../",import.meta.url));
+const config=JSON.parse(await readFile(path.join(root,"film.config.json"),"utf8"));
+const token=randomUUID(),port=Number(process.env.ANIMAGURU_REVIEW_PORT??5197);
+const output=path.join(root,"production/review");
+const server=await createServer({configFile:false,root,clearScreen:false,server:{host:"127.0.0.1",port,strictPort:true},plugins:[{name:"animaguru-review",configureServer(vite){
+  vite.middlewares.use((request,response,next)=>{
+    if(request.url!=="/__review/report")return next();
+    void (async()=>{
+      if(request.method!=="POST"||request.headers["x-animaguru-review"]!==token||request.headers.origin!==`http://127.0.0.1:${port}`){response.writeHead(403).end("Wrong review session.");return;}
+      const parts=[];let length=0;
+      for await(const part of request){length+=part.length;if(length>32*1024*1024)throw new Error("Review report is too large.");parts.push(part);}
+      const report=JSON.parse(Buffer.concat(parts).toString());
+      if(!Array.isArray(report.samples)||!Array.isArray(report.frames)||!Array.isArray(report.seekMatches)||report.frames.length>10)throw new Error("Invalid review report.");
+      const analysis=analyzeReview(report,config);
+      const audio=await inspectAudio(root,config);
+      await mkdir(output,{recursive:true});
+      for(const [i,frame]of report.frames.entries()){
+        if(typeof frame.image!=="string"||!frame.image.startsWith("data:image/jpeg;base64,"))throw new Error("Expected JPEG review frame.");
+        await writeFile(path.join(output,`frame-${String(i).padStart(2,"0")}.jpg`),Buffer.from(frame.image.split(",")[1],"base64"));
+      }
+      await writeFile(path.join(output,"report.json"),JSON.stringify({config,samples:report.samples,seekMatches:report.seekMatches,cues:report.cues,analysis,audio},null,2)+"\n");
+      console.log(`${analysis.pass?"Passed":"Failed"}: seek and text-bound checks. ${analysis.warnings.length} reading/review notes. Frames and report: ${output}`);
+      console.log("Inspect the frames and moving playback with audio; numerical checks do not establish artistic quality or claim accuracy.");
+      response.writeHead(200,{"Content-Type":"application/json"}).end(JSON.stringify(analysis));
+      response.once("finish",()=>{void server.close();});process.exitCode=analysis.pass?0:1;
+    })().catch((error)=>{response.writeHead(500).end(error.message);void server.close();process.exitCode=1;});
+  });
+}}]});
+await server.listen();console.log(`Open this review page and keep it open until completion:\nhttp://127.0.0.1:${port}/?review=${token}`);

package/templates/video/scripts/starter-film.sha256

@@ -0,0 +1 @@
+f82f05cc73b14a023396f06cf7589e13e3bcb9e5397323e59e2f598e1d1658d8

package/templates/video/shared/locales/en/export.json

@@ -0,0 +1,10 @@
+{
+  "preparing": "Preparing MP4 export…",
+  "rendering": "Rendering MP4 · {percent}% · {frame} / {total} frames. Keep this tab open.",
+  "finishing": "Finishing the MP4 and checking its video and audio…",
+  "saved": "MP4 saved: {path}",
+  "failed": "Export stopped: {error}",
+  "requestFailed": "Capture request failed.",
+  "languageChanged": "The language changed during capture. Restart the export.",
+  "captureFailed": "Could not capture frame {frame}."
+}

package/templates/video/shared/locales/en/film.json

@@ -0,0 +1,42 @@
+{
+  "chapters": [
+    {
+      "start": 0,
+      "end": 8,
+      "label": "The spark",
+      "eyebrow": "01 / EVERY STORY STARTS SOMEWHERE",
+      "headline": "A little spark.\nA bigger story.",
+      "detail": "Turn something you believe in into something people feel.",
+      "caption": "Every great story begins with a little spark.",
+      "color": "#DCE7BC",
+      "cardLabel": "THE FIRST SPARK",
+      "cardCaption": "Small idea. Big possibilities."
+    },
+    {
+      "start": 8,
+      "end": 16,
+      "label": "The possibility",
+      "eyebrow": "02 / MAKE THE IDEA TANGIBLE",
+      "headline": "Show the wonder.\nMake it matter.",
+      "detail": "Real characters. Small discoveries. A world worth exploring.",
+      "caption": "Bring your idea to life, one meaningful moment at a time.",
+      "color": "#DCCFF0",
+      "cardLabel": "A NEW PERSPECTIVE",
+      "cardCaption": "See what comes next."
+    },
+    {
+      "start": 16,
+      "end": 24,
+      "label": "The invitation",
+      "eyebrow": "03 / GIVE THEM A NEXT STEP",
+      "headline": "Your vision.\nReady to move.",
+      "detail": "Open your coding agent. Tell it the story you want to tell.",
+      "caption": "Your next great story starts here.",
+      "color": "#F3D88D",
+      "cardLabel": "MADE TO MOVE",
+      "cardCaption": "Let's tell your story."
+    }
+  ],
+  "brand": "ANIMAGURU  /  MOTION STUDIO",
+  "tagline": "YOUR STORY, IN MOTION"
+}

package/templates/video/shared/locales/en/player.json

@@ -0,0 +1,31 @@
+{
+  "studio": "Motion studio",
+  "template": "Choose category & style with your agent",
+  "play": "Play",
+  "pause": "Pause",
+  "replay": "Replay",
+  "mute": "Mute",
+  "unmute": "Unmute",
+  "noAudio": "No soundtrack yet",
+  "captions": "Captions",
+  "fullscreen": "Fullscreen",
+  "saveFrame": "Save frame",
+  "download": "Download",
+  "pngFormat": "PNG",
+  "exportHtml": "Export HTML5",
+  "htmlFormat": "ZIP",
+  "exportPreparing": "Preparing your HTML5 animation…",
+  "exportReady": "HTML5 download started. Unzip and upload the folder to embed your animation.",
+  "exportFailed": "HTML5 export failed. Check the terminal or rebuild the player, then try again.",
+  "timeline": "Video timeline",
+  "transcript": "Read the transcript",
+  "starter": "Starter preview · replace with your story",
+  "exportHint": "Ready for the big screen? Run npm run export:mp4.",
+  "loading": "Setting the stage…",
+  "failed": "The player could not load. Check the browser console and reload.",
+  "audioFailed": "Sound could not play. Check film.config.json and the local audio file.",
+  "fullscreenFailed": "Fullscreen is unavailable in this browser.",
+  "videoPlayer": "Video player",
+  "footer": "Made with AnimaGuru × PixiJS",
+  "footerTagline": "IMAGINE. CREATE. ANIMATE."
+}

package/templates/video/shared/locales/en/style-studies.json

@@ -0,0 +1,168 @@
+{
+  "brand": "ANIMAGURU / ORIGINAL MOTION STUDIES",
+  "resourceArt": "Study artwork",
+  "resourceMaterial": "Material & background",
+  "resourceText": "Study typography",
+  "styles": {
+    "dark-tech-stage": {
+      "name": "Dark Tech Stage",
+      "lines": [
+        "Bring the signal forward.",
+        "Concept stage",
+        "One clear focus"
+      ]
+    },
+    "studio-product-reveal": {
+      "name": "Studio Product Reveal",
+      "lines": [
+        "Form. Material. Detail.",
+        "Illustrative product",
+        "Light reveals the shape"
+      ]
+    },
+    "risograph-print": {
+      "name": "Risograph Print",
+      "lines": [
+        "Two inks. More possibilities.",
+        "Separate plates",
+        "Meet in the overprint"
+      ]
+    },
+    "halftone-editorial": {
+      "name": "Halftone Editorial",
+      "lines": [
+        "Give the idea a headline.",
+        "An original print study",
+        "Make the point readable"
+      ]
+    },
+    "silkscreen-poster": {
+      "name": "Silkscreen Poster",
+      "lines": [
+        "One ink. One impression.",
+        "Print the composition",
+        "Hold the finished image"
+      ]
+    },
+    "art-deco-motion": {
+      "name": "Art Deco Motion",
+      "lines": [
+        "Geometry catches the light.",
+        "Open from the center",
+        "A measured reveal"
+      ]
+    },
+    "blueprint-drafting": {
+      "name": "Blueprint Drafting",
+      "lines": [
+        "See how the parts connect.",
+        "Illustrative drawing",
+        "Assemble the relationship"
+      ]
+    },
+    "holographic-scan": {
+      "name": "Holographic Scan",
+      "lines": [
+        "Scan. Focus. Understand.",
+        "Illustrative part model",
+        "Follow the detail"
+      ]
+    },
+    "paper-popup": {
+      "name": "Paper Pop-up",
+      "lines": [
+        "A flat page gains a world.",
+        "An original paper mechanism",
+        "Fold. Open. Discover."
+      ]
+    },
+    "shadow-theatre": {
+      "name": "Shadow Theatre",
+      "lines": [
+        "A silhouette tells a thousand things.",
+        "Light and carved shape",
+        "Move with the material"
+      ]
+    },
+    "engraved-relief-print": {
+      "name": "Engraved & Relief Print",
+      "lines": [
+        "Every mark has a direction.",
+        "Carve the form",
+        "Pull the impression"
+      ]
+    },
+    "ascii-crt": {
+      "name": "ASCII & CRT",
+      "lines": [
+        "A picture made of characters.",
+        "Signal on the grid",
+        "Pixels become language"
+      ]
+    },
+    "analog-film-tape": {
+      "name": "Analog Film & Tape",
+      "lines": [
+        "A different kind of time.",
+        "Original scene / film variant",
+        "Texture follows the medium"
+      ]
+    },
+    "glass-mosaic": {
+      "name": "Glass Mosaic",
+      "lines": [
+        "Pieces become a picture.",
+        "Original glass-like mosaic",
+        "Light passes through"
+      ]
+    },
+    "portal-zoom": {
+      "name": "Portal Zoom",
+      "lines": [
+        "Every frame opens another.",
+        "An original nested world",
+        "Keep the journey continuous"
+      ]
+    },
+    "photo-footage-editorial": {
+      "name": "Photo & Footage Editorial",
+      "lines": [
+        "Give every image its place.",
+        "Original illustrated media cards",
+        "Frame the detail"
+      ]
+    },
+    "stop-motion-objects": {
+      "name": "Stop Motion Objects",
+      "lines": [
+        "Build it one piece at a time.",
+        "Illustrative tactile objects",
+        "Deliberate held poses"
+      ]
+    },
+    "miniature-diorama": {
+      "name": "Miniature Diorama",
+      "lines": [
+        "A small world, carefully built.",
+        "An original 2.5D miniature",
+        "Let scale guide the view"
+      ]
+    },
+    "sand-drawing": {
+      "name": "Sand Drawing",
+      "lines": [
+        "A shape emerges from grains.",
+        "Original procedural sand study",
+        "Reveal the silhouette"
+      ]
+    },
+    "generative-light-signal": {
+      "name": "Generative Light & Signal",
+      "lines": [
+        "Turn a signal into movement.",
+        "Original analytic field",
+        "Follow the rhythm"
+      ]
+    }
+  }
+}

package/templates/video/shared/locales/en/timeline.json

@@ -0,0 +1,33 @@
+{
+  "title": "RESOURCE TIMELINE",
+  "trackCount": "{tracks} rows · {clips} clips",
+  "resources": "Resources",
+  "playhead": "Timeline playhead",
+  "zoomIn": "Zoom in",
+  "zoomOut": "Zoom out",
+  "fit": "Fit",
+  "fitTitle": "Fit the whole film",
+  "hint": "Select a clip to inspect it. Drag the ruler to scrub.",
+  "selection": "{kind} · {start} — {end} · {duration}s",
+  "seekTo": "{label}, {start} to {end}. Seek to this clip.",
+  "source": "Source: {source}",
+  "seekFailed": "Could not seek to that frame. Check the media and try again.",
+  "hidden": "Hidden",
+  "muted": "Muted",
+  "graphics": "Graphics",
+  "image": "Image",
+  "video": "Video",
+  "text": "Text",
+  "captions": "Captions",
+  "audio": "Audio",
+  "paper": "Paper backdrop",
+  "branding": "Studio wordmark",
+  "tagline": "Film tagline",
+  "artwork": "{scene} artwork",
+  "headlines": "Headlines",
+  "details": "Supporting copy",
+  "eyebrows": "Scene labels",
+  "cardLabels": "Card labels",
+  "cardCaptions": "Card descriptions",
+  "soundtrack": "Soundtrack"
+}

package/templates/video/src/assets.ts

@@ -0,0 +1,4 @@
+/** Public-relative media paths remain portable when an HTML5 export is embedded in a subfolder. */
+export function publicAsset(path: string) {
+  return `${import.meta.env.BASE_URL}${path.replace(/^\/+/, "")}`;
+}

package/templates/video/src/download.ts

@@ -0,0 +1,27 @@
+import config from "../film.config.json";
+import { publicAsset } from "./assets";
+
+export function downloadUrl(url: string, filename: string) {
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.append(link);
+  link.click();
+  link.remove();
+}
+
+export async function downloadHtml() {
+  const filename = `${config.slug}-html5.zip`;
+  if (!import.meta.env.DEV) {
+    // npm run build prepares this alongside the static player. No server API is needed.
+    downloadUrl(publicAsset(`downloads/${filename}`), filename);
+    return;
+  }
+  const response = await fetch("/__animaguru/html", {
+    method: "POST", headers: { "X-AnimaGuru-Export": "html5" }, signal: AbortSignal.timeout(180000),
+  });
+  if (!response.ok) throw new Error(await response.text());
+  const url = URL.createObjectURL(await response.blob());
+  downloadUrl(url, filename);
+  setTimeout(() => URL.revokeObjectURL(url), 60000);
+}

package/templates/video/src/exporter.ts

@@ -0,0 +1,70 @@
+import copy from "../shared/locales/en/export.json";
+
+const message = (key: keyof typeof copy, values: Record<string, string | number> = {}) =>
+  copy[key].replace(/\{(\w+)\}/g, (_, name: string) => String(values[name] ?? `{${name}}`));
+
+type CaptureApi = {
+  duration: number;
+  width: number;
+  height: number;
+  canvas: HTMLCanvasElement;
+  fps: number;
+  language: string;
+  renderFrame(frame: number, fps: number): Promise<void>;
+  setCaptions(enabled: boolean): void;
+  pause(): void;
+};
+
+export async function exportMp4(api: CaptureApi, token: string) {
+  const state = { frame: 0, total: Math.round(api.duration * api.fps), status: "starting", error: "", path: "" };
+  Object.assign(window, { animaguruExport: state });
+  const status = document.createElement("div");
+  status.setAttribute("role", "status");
+  status.style.cssText = "position:fixed;z-index:100;left:24px;bottom:24px;padding:16px 22px;border-radius:12px;background:#162224ed;color:white;font:15px Arial,sans-serif;box-shadow:0 8px 30px #0002;max-width:calc(100vw - 48px)";
+  status.textContent = copy.preparing;
+  document.body.append(status);
+  const request = async (route: string, body?: BodyInit, type = "application/json") => {
+    const attempts = route.startsWith("frame?") ? 3 : 1;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      try {
+        const response = await fetch(`/__export/${route}`, { method: "POST", headers: { "Content-Type": type, "X-AnimaGuru-Export": token }, body, signal: AbortSignal.timeout(route === "finish" ? 180000 : 45000) });
+        if (!response.ok) throw new Error(await response.text());
+        return await response.json();
+      } catch (error) {
+        const transient = error instanceof TypeError || error instanceof SyntaxError || (error instanceof DOMException && error.name === "TimeoutError");
+        if (!transient || attempt + 1 === attempts) throw error;
+        await new Promise((resolve) => window.setTimeout(resolve, 250 * (attempt + 1)));
+      }
+    }
+    throw new Error(copy.requestFailed);
+  };
+  try {
+    api.pause();
+    api.setCaptions(true);
+    const language = api.language;
+    const settings = await request("start", JSON.stringify({ width: api.width, height: api.height, duration: api.duration, fps: api.fps, language }));
+    state.total = settings.frames;
+    state.status = "rendering";
+    for (let frame = 0; frame < settings.frames; frame++) {
+      if (api.language !== language) throw new Error(copy.languageChanged);
+      await api.renderFrame(frame, settings.fps);
+      const image = await new Promise<Blob | null>((resolve) => api.canvas.toBlob(resolve, "image/jpeg", 0.98));
+      if (!image) throw new Error(message("captureFailed", { frame }));
+      await request(`frame?index=${frame}`, image, "image/jpeg");
+      state.frame = frame + 1;
+      status.textContent = message("rendering", { percent: Math.round(state.frame / state.total * 100), frame: state.frame.toLocaleString(), total: state.total.toLocaleString() });
+    }
+    state.status = "encoding";
+    status.textContent = copy.finishing;
+    const result = await request("finish", "{}");
+    state.status = "complete";
+    state.path = result.path;
+    status.textContent = message("saved", { path: result.path });
+  } catch (error) {
+    state.status = "failed";
+    state.error = error instanceof Error ? error.message : String(error);
+    status.textContent = message("failed", { error: state.error });
+    await request("abort", JSON.stringify({ error: state.error })).catch(() => {});
+    console.error(error);
+  }
+}

package/templates/video/src/film-resources.ts

@@ -0,0 +1,29 @@
+import copy from "../shared/locales/en/timeline.json";
+import type { ResourceKind, ResourceTrack } from "./timeline-model";
+
+type Chapter = { start: number; end: number; label: string; headline: string; detail: string; eyebrow: string; cardLabel: string; cardCaption: string; caption: string };
+
+/** Mirrors the resources in Film. Add a track/clip here when adding an image, video, or audio stem. */
+export function filmResources(story: { chapters: Chapter[]; brand: string; tagline: string }, config: { duration: number; audio: string | null }) {
+  const tracks: ResourceTrack[] = story.chapters.map((chapter, index) => ({
+    id: `artwork-${index}`, label: copy.artwork.replace("{scene}", chapter.label), kind: "graphics",
+    clips: [{ id: `art-${index}`, label: chapter.cardLabel, start: chapter.start, end: chapter.end }],
+  }));
+  for (const [field, label, kind] of [
+    ["headline", copy.headlines, "text"], ["detail", copy.details, "text"],
+    ["eyebrow", copy.eyebrows, "text"], ["cardLabel", copy.cardLabels, "text"],
+    ["cardCaption", copy.cardCaptions, "text"], ["caption", copy.captions, "captions"],
+  ] as const) {
+    tracks.push({ id: field, label, kind, clips: story.chapters.map((chapter, index) => ({
+      id: `${field}-${index}`, label: chapter[field], start: chapter.start, end: chapter.end,
+    })) });
+  }
+  const continuous = (id: string, label: string, kind: ResourceKind, content: string, source?: string) => {
+    tracks.push({ id, label, kind, clips: [{ id, label: content, start: 0, end: config.duration, ...(source ? { source } : {}) }] });
+  };
+  continuous("branding", copy.branding, "text", story.brand);
+  continuous("tagline", copy.tagline, "text", story.tagline);
+  continuous("paper", copy.paper, "graphics", copy.paper);
+  if (config.audio) continuous("soundtrack", copy.soundtrack, "audio", config.audio.split(/[\\/]/).pop()!, config.audio);
+  return tracks;
+}