storyforge 0.18.0 → 0.18.1

package/dist/{bridge-poller-WSSTXFPC.js → bridge-poller-67VQZZ3U.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import {
+  log
+} from "./chunk-GJQ45C5W.js";
 import {
   concatScenes,
   muxAudio,
   probeDuration,
   renderPlaceholderShot,
   runCmd
-} from "./chunk-NSB32ZRA.js";
-import {
-  log
-} from "./chunk-GJQ45C5W.js";
+} from "./chunk-ZHECC3YI.js";
 import {
   __commonJS,
   __export,
@@ -92,18 +92,18 @@ var require_p_limit = __commonJS({
           queue.dequeue()();
         }
       };
-      const run = async (fn, resolve3, ...args) => {
+      const run = async (fn, resolve5, ...args) => {
         activeCount++;
         const result = (async () => fn(...args))();
-        resolve3(result);
+        resolve5(result);
         try {
           await result;
         } catch {
         }
         next();
       };
-      const enqueue = (fn, resolve3, ...args) => {
-        queue.enqueue(run.bind(null, fn, resolve3, ...args));
+      const enqueue = (fn, resolve5, ...args) => {
+        queue.enqueue(run.bind(null, fn, resolve5, ...args));
         (async () => {
           await Promise.resolve();
           if (activeCount < concurrency && queue.size > 0) {
@@ -111,8 +111,8 @@ var require_p_limit = __commonJS({
           }
         })();
       };
-      const generator = (fn, ...args) => new Promise((resolve3) => {
-        enqueue(fn, resolve3, ...args);
+      const generator = (fn, ...args) => new Promise((resolve5) => {
+        enqueue(fn, resolve5, ...args);
       });
       Object.defineProperties(generator, {
         activeCount: {
@@ -134,13 +134,13 @@ var require_p_limit = __commonJS({
 });
 
 // src/bridge-poller.ts
-import { spawn as spawn2, spawnSync } from "child_process";
-import * as crypto from "crypto";
-import * as fs18 from "fs";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import * as crypto2 from "crypto";
+import * as fs26 from "fs";
 
 // ../pipeline/src/clip-render/render-chunk.ts
-import * as fs16 from "fs";
-import * as path14 from "path";
+import * as fs21 from "fs";
+import * as path17 from "path";
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -620,8 +620,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path17, errorMaps, issueData } = params;
-  const fullPath = [...path17, ...issueData.path || []];
+  const { data, path: path23, errorMaps, issueData } = params;
+  const fullPath = [...path23, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -737,11 +737,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path17, key) {
+  constructor(parent, value, path23, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path17;
+    this._path = path23;
     this._key = key;
   }
   get path() {
@@ -4511,6 +4511,10 @@ var costProviderSchema = external_exports.enum([
   "elevenlabs",
   "claude",
   "pexels",
+  "lambda",
+  // Remotion Lambda clip render (billed per render)
+  "runpod",
+  // RunPod CPU final-stitch (per-job cost may be unavailable)
   "unknown"
 ]);
 var costRequestKindSchema = external_exports.enum([
@@ -5261,6 +5265,133 @@ var TONE_PRESETS = {
   }
 };
 
+// ../shared/src/craft-jobs.ts
+var AUTHOR_SECTION_KIND = "author-section";
+var AuthorSectionResumeSchema = external_exports.object({
+  /** absolute path of the surviving worktree from the failed attempt */
+  worktreePath: external_exports.string().min(1),
+  /** plain-language recap of where the previous attempt stopped */
+  recap: external_exports.string().min(1)
+});
+var AuthorSectionPayloadSchema = external_exports.object({
+  __forgeJobKind: external_exports.literal(AUTHOR_SECTION_KIND),
+  projectId: external_exports.string().uuid(),
+  sectionKey: external_exports.string().min(1),
+  // 's6c'
+  /** markdown creative brief (from the round design doc / verdict) */
+  brief: external_exports.string().min(1),
+  /** versioned craft-laws pack id: '<contract-name>-v<version>' (e.g. 'bright-editorial-v1'),
+   *  resolved from the channel's craft_contracts row; legacy 'v15-r20' also valid */
+  lawsPackVersion: external_exports.string().min(1),
+  /** the contract's laws_md, embedded verbatim so the (independently published)
+   *  CLI worker never needs DB access; absent → the CLI's built-in v15-r20 laws */
+  lawsMd: external_exports.string().optional(),
+  /** repo-relative path to the section's word-timings JSON (the anchor source) */
+  wordsJsonRef: external_exports.string().min(1),
+  /** resolved beat windows for the section (kv-v15-resolved shape, verbatim) */
+  beats: external_exports.array(external_exports.unknown()).default([]),
+  /** EXACT frame count the component must render (CLK.END) */
+  framesExact: external_exports.number().int().positive(),
+  /** bespoke component ids to study before authoring (style callbacks) */
+  callbackRefs: external_exports.array(external_exports.string()).default([]),
+  /** the section's home world ('gears', 'napkin', …) */
+  worldAssignment: external_exports.string().min(1),
+  /** the 3 biggest payoff words — lane extracts frames AT their timestamps (LAW 4.4) */
+  avSyncPayoffWords: external_exports.array(external_exports.string()).length(3),
+  /** pinned base commit for the worktree */
+  baseSha: external_exports.string().min(7),
+  roundId: external_exports.string().uuid().optional(),
+  /** set on re-entry after a failure — reuse the surviving worktree */
+  resume: AuthorSectionResumeSchema.optional()
+});
+var AuthorSectionGateResultSchema = external_exports.object({
+  /** real exit code, checked directly — never inferred through a pipe */
+  exit: external_exports.number().int(),
+  summary: external_exports.string().default("")
+});
+var AuthorSectionReportSchema = external_exports.object({
+  kind: external_exports.literal(AUTHOR_SECTION_KIND),
+  sectionKey: external_exports.string().min(1),
+  projectId: external_exports.string().uuid(),
+  /** commit on the worktree branch holding the authored section */
+  commitSha: external_exports.string().min(7),
+  /** surviving worktree (kept until integration; enables resume) */
+  worktreePath: external_exports.string().min(1),
+  componentRef: external_exports.string().min(1),
+  // exported *Film component name
+  frames: external_exports.number().int().positive(),
+  gates: external_exports.object({
+    tsc: AuthorSectionGateResultSchema,
+    typeLint: AuthorSectionGateResultSchema
+  }),
+  /** frames the lane extracted to verify itself (payoff words + peak) */
+  evidenceFrames: external_exports.array(external_exports.object({ frame: external_exports.number().int(), path: external_exports.string(), storjKey: external_exports.string().optional(), label: external_exports.string().optional() })).default([]),
+  craftPeak: external_exports.object({ frame: external_exports.number().int().nullable(), label: external_exports.string().min(1) }),
+  /** one-line lane report for the monitor row */
+  summary: external_exports.string().default(""),
+  /** token/cost telemetry when the CLI surfaces it; null = honestly unknown */
+  costUsd: external_exports.number().nullable().default(null),
+  roundId: external_exports.string().uuid().optional()
+});
+var AUTHOR_SHORT_KIND = "author-short";
+var VERTICAL_SAFE_ZONES = Object.freeze({
+  top: 170,
+  bottom: 370,
+  left: 40,
+  right: 150,
+  captionY: 450
+});
+var AuthorShortPayloadSchema = external_exports.object({
+  __forgeJobKind: external_exports.literal(AUTHOR_SHORT_KIND),
+  projectId: external_exports.string().uuid(),
+  /** the shorts row this lane authors into (created at launch, status 'draft') */
+  shortId: external_exports.string().uuid(),
+  /** source section + peak (provenance) */
+  sectionKey: external_exports.string().min(1),
+  peakLabel: external_exports.string().min(1),
+  peakFrame: external_exports.number().int().nullable().default(null),
+  /** markdown creative brief for the vertical re-stage */
+  brief: external_exports.string().min(1),
+  lawsPackVersion: external_exports.string().min(1),
+  lawsMd: external_exports.string().optional(),
+  /** the section's words JSON (anchor source) + the peak beat's VO window */
+  wordsJsonRef: external_exports.string().min(1),
+  voWindow: external_exports.object({ startSec: external_exports.number().min(0), endSec: external_exports.number().positive() }).refine((w) => w.endSec > w.startSec, { message: "voWindow.endSec must be after startSec" }).refine((w) => w.endSec - w.startSec <= 60, { message: "voWindow must be \u226460s (a short)" }),
+  /** hard cap: ≤60s at 30fps */
+  framesMax: external_exports.number().int().positive().max(1800).default(1800),
+  aspect: external_exports.literal("9:16").default("9:16"),
+  safeZones: external_exports.object({
+    top: external_exports.number().int().nonnegative(),
+    bottom: external_exports.number().int().nonnegative(),
+    left: external_exports.number().int().nonnegative(),
+    right: external_exports.number().int().nonnegative(),
+    captionY: external_exports.number().int().nonnegative()
+  }).default({ ...VERTICAL_SAFE_ZONES }),
+  /** the source section's component (study it; re-stage, never crop) */
+  callbackRefs: external_exports.array(external_exports.string()).default([]),
+  baseSha: external_exports.string().min(7),
+  resume: AuthorSectionResumeSchema.optional()
+});
+var AuthorShortReportSchema = external_exports.object({
+  kind: external_exports.literal(AUTHOR_SHORT_KIND),
+  shortId: external_exports.string().uuid(),
+  projectId: external_exports.string().uuid(),
+  sectionKey: external_exports.string().min(1),
+  componentRef: external_exports.string().min(1),
+  frames: external_exports.number().int().positive().max(1800),
+  commitSha: external_exports.string().min(7),
+  worktreePath: external_exports.string().min(1),
+  gates: external_exports.object({
+    tsc: AuthorSectionGateResultSchema,
+    typeLint: AuthorSectionGateResultSchema
+  }),
+  evidenceFrames: external_exports.array(external_exports.object({ frame: external_exports.number().int(), path: external_exports.string(), storjKey: external_exports.string().optional(), label: external_exports.string().optional() })).default([]),
+  /** optional hook line the lane proposes for the short */
+  hookText: external_exports.string().optional(),
+  summary: external_exports.string().default(""),
+  costUsd: external_exports.number().nullable().default(null)
+});
+
 // ../shared/src/script-blueprint.ts
 var SCRIPT_BLUEPRINT_SCHEMA_VERSION = 1;
 var HookFrameTypeEnum = external_exports.enum([
@@ -5307,6 +5438,14 @@ var SectionBlueprintSchema = external_exports.object({
   estimatedRuntimeSec: external_exports.number().int().min(60).max(300),
   citesAllowed: external_exports.number().int().min(1).max(15)
 });
+var MotifSchema = external_exports.object({
+  /** Short name for the recurring thread, e.g. "the shrinking cache meter". */
+  name: external_exports.string().min(3).max(80),
+  /** One line: what the motif IS and how it evolves as the film progresses. */
+  description: external_exports.string().min(20),
+  /** sectionIds where the motif recurs (act seams + the finale callback). */
+  touchpoints: external_exports.array(external_exports.string()).default([])
+});
 var ScriptBlueprintSchema = external_exports.object({
   schemaVersion: external_exports.literal(SCRIPT_BLUEPRINT_SCHEMA_VERSION),
   hookFrame: HookFrameTypeEnum,
@@ -5317,6 +5456,8 @@ var ScriptBlueprintSchema = external_exports.object({
   }).optional(),
   sections: external_exports.array(SectionBlueprintSchema).min(4).max(7),
   climaxSectionId: external_exports.string(),
+  // Optional recurring motif — additive; legacy blueprints omit it.
+  motif: MotifSchema.optional(),
   seriesContext: external_exports.object({
     isPartOfSeries: external_exports.boolean(),
     previousVideoTopic: external_exports.string().optional(),
@@ -5353,13 +5494,294 @@ var ENGINE_FALLBACK_CHAIN = {
   // an AI-rendered photo of the same topic is the next-best fit.
   "web-article+remotion": "gemini+remotion",
   "x-post+remotion": "gemini+remotion",
-  "youtube-clip+remotion": "gemini+remotion"
+  "youtube-clip+remotion": "gemini+remotion",
+  // Series engines fall back to the legacy photo path: spec.shots stays
+  // fully populated alongside seriesPlan, so the gemini+remotion per-shot
+  // render still has everything it needs.
+  "motion": "gemini+remotion",
+  "cinematic": "gemini+remotion"
 };
 function nextFallback(engine) {
   return ENGINE_FALLBACK_CHAIN[engine] ?? null;
 }
 var DEFAULT_RENDER_CONCURRENCY = 4;
 
+// ../shared/src/clip-registry.ts
+var manim = (file) => ({
+  src: `clip-render-cache/manim/${file}`,
+  storjKey: `registry/manim/${file}`
+});
+var MANIM_CLIPS = {
+  // The hero concept (Phase-1/2 reference render — lives under proof/).
+  "kv-cache-reveal": {
+    src: "clip-render-cache/proof/clip4.mp4",
+    storjKey: "registry/manim/kv-cache-reveal.mp4",
+    durationFrames: 648,
+    label: "KV cache reveal",
+    keywords: ["kv cache", "key value cache", "cache stores", "cache reveal", "store the keys"]
+  },
+  // Phase-3 batch: 8 cinematic LaTeX-free cache scenes at 1080p60.
+  "clip-1-autoregressive": {
+    ...manim("clip-1-autoregressive.mp4"),
+    durationFrames: 395,
+    label: "Autoregressive decoding",
+    keywords: ["autoregressive", "token by token", "one token at a time", "next token", "token at a time"]
+  },
+  "clip-2-attention-math": {
+    ...manim("clip-2-attention-math.mp4"),
+    durationFrames: 517,
+    label: "Attention math (QK\u1D40/\u221Ad\u2096)",
+    keywords: ["attention score", "query", "queries and keys", "dot product", "softmax", "attention math"]
+  },
+  "clip-3-naive-cost": {
+    ...manim("clip-3-naive-cost.mp4"),
+    durationFrames: 584,
+    label: "Naive recompute cost",
+    keywords: ["recompute", "recomputes", "redundant", "wasteful", "from scratch", "naive"]
+  },
+  "clip-5-savings": {
+    ...manim("clip-5-savings.mp4"),
+    durationFrames: 278,
+    label: "O(N\xB2)\u2192O(N) savings",
+    keywords: ["quadratic", "linear", "speedup", "savings", "n squared", "much faster"]
+  },
+  "clip-6-causal-mask": {
+    ...manim("clip-6-causal-mask.mp4"),
+    durationFrames: 483,
+    label: "Causal mask",
+    keywords: ["causal mask", "causal", "future tokens", "mask", "cannot see the future"]
+  },
+  "clip-7-decoding-stream": {
+    ...manim("clip-7-decoding-stream.mp4"),
+    durationFrames: 362,
+    label: "Decoding stream",
+    keywords: ["decoding", "generation loop", "token stream", "streams out", "generates"]
+  },
+  "clip-8-gpu-memory": {
+    ...manim("clip-8-gpu-memory.mp4"),
+    durationFrames: 326,
+    label: "GPU memory (HBM)",
+    keywords: ["gpu memory", "hbm", "vram", "memory bandwidth", "memory cost", "fits in memory"]
+  },
+  "clip-9-multi-head": {
+    ...manim("clip-9-multi-head.mp4"),
+    durationFrames: 349,
+    label: "Multi-head cache",
+    keywords: ["multi-head", "multi head", "attention heads", "every head", "heads in parallel"]
+  }
+};
+var broll = (file) => ({
+  src: `clip-render-cache/broll/${file}`,
+  storjKey: `registry/broll/${file}`
+});
+var BROLL_CLIPS = {
+  "vintage-mainframe": {
+    ...broll("broll-mainframe.mp4"),
+    durationFrames: 1576,
+    label: "Vintage mainframe room",
+    keywords: ["mainframe", "1960s", "1965", "ibm system", "vintage computer", "punch card", "early computers"]
+  },
+  "datacenter": {
+    ...broll("broll-datacenter.mp4"),
+    durationFrames: 947,
+    label: "Data center server racks",
+    keywords: ["data center", "datacenter", "server racks", "cloud infrastructure", "at scale", "millions of users"]
+  },
+  "gpu": {
+    ...broll("broll-gpu.mp4"),
+    durationFrames: 454,
+    label: "GPU close-up",
+    keywords: ["gpu", "graphics card", "nvidia", "silicon", "chip", "hardware"]
+  },
+  "circuit": {
+    ...broll("broll-circuit.mp4"),
+    durationFrames: 274,
+    label: "Circuit board macro",
+    keywords: ["circuit", "transistor", "electronics", "circuit board"]
+  },
+  "serverroom": {
+    ...broll("broll-serverroom.mp4"),
+    durationFrames: 947,
+    label: "Server room",
+    keywords: ["server room", "servers hum", "racks of servers"]
+  },
+  "fiber": {
+    ...broll("broll-fiber.mp4"),
+    durationFrames: 627,
+    label: "Fiber optic data",
+    keywords: ["fiber", "network traffic", "bandwidth", "data flows", "data flowing"]
+  }
+};
+function manimClip(id) {
+  return MANIM_CLIPS[id];
+}
+function brollClip(id) {
+  return BROLL_CLIPS[id];
+}
+
+// ../shared/src/motion.ts
+function motionPlanDuration(plan) {
+  return plan.shots.reduce((n, s) => n + s.durationInFrames, 0);
+}
+
+// ../shared/src/scene-spec.ts
+var archetypeSchema = external_exports.enum([
+  "caption-card",
+  "image-beat",
+  "video-inset",
+  "video-cinematic",
+  "paper-cite",
+  "paper-figure",
+  "head-diagram",
+  "config-title",
+  "hero-stat",
+  "comparison-bars",
+  "article-card",
+  "x-post",
+  "youtube-clip",
+  "mechanism-custom"
+]);
+var rendererSchema = external_exports.enum(["remotion-kit", "hyperframes", "manim"]);
+var assetRoleSchema = external_exports.enum(["hero", "background", "figure", "logo"]);
+var assetKindSchema = external_exports.enum(["image", "video"]);
+var sceneAssetSchema = external_exports.object({
+  src: external_exports.string(),
+  role: assetRoleSchema,
+  kind: assetKindSchema,
+  /**
+   * TO-MATERIALIZE placeholder: a generation prompt for an asset that has not been
+   * rendered yet. An asset carrying `genPrompt` and no usable `src` is a placeholder the
+   * materializer (R4) will turn into a real file; renderers SKIP src-less placeholders
+   * gracefully (they never crash on a missing bed/figure/logo). Additive — existing specs
+   * with only `src` are unaffected.
+   */
+  genPrompt: external_exports.string().optional(),
+  /** Optional style hint for the materializer (e.g. 'photoreal', 'diagram', 'bright-vector'). */
+  genStyle: external_exports.string().optional()
+});
+var wordAnchorSchema = external_exports.object({
+  phrase: external_exports.string(),
+  startSec: external_exports.number().nonnegative()
+});
+var motifTouchSchema = external_exports.object({
+  meterValueGB: external_exports.number()
+});
+var transitionInSchema = external_exports.enum(["cut", "match-cut", "act-seam"]);
+var sceneSpecSchema = external_exports.object({
+  /** Stable per-scene id (unique within its section). */
+  id: external_exports.string().min(1),
+  /** Which section of the film this scene belongs to. */
+  sectionId: external_exports.string().min(1),
+  /** One line: what this beat teaches. */
+  purpose: external_exports.string().min(1),
+  /** Kit-backed visual archetype. */
+  archetype: archetypeSchema,
+  /** Which lane renders it. */
+  renderer: rendererSchema,
+  /** Scene runtime in seconds. */
+  durationSec: external_exports.number().positive(),
+  /** Optional master-clock link to a VO phrase. */
+  wordAnchor: wordAnchorSchema.optional(),
+  /** Optional assets (hero / background / figure / logo). */
+  assets: external_exports.array(sceneAssetSchema).optional(),
+  /**
+   * Optional archetype payload: numbers, labels, bar-values, curve-points.
+   *
+   * REAL-MEDIA payloads live here too (kept untyped so the record stays flexible and the
+   * ≤15-field ceiling holds):
+   *   • article-card carries the PRE-EXTRACTED readability fields —
+   *     `{ title, siteName, byline, leadImage, excerpt, highlightText, sourceUrl }`.
+   *   • x-post carries the PRE-FETCHED `getTweet()` payload as `{ tweet }`.
+   *   • youtube-clip (a `video-cinematic` / `video-inset` scene) carries
+   *     `{ citation: { channel, title, url } }` — the citation pill the video archetypes ALWAYS
+   *     render bottom-left when present (the ported yt-dlp drawtext contract, in React chrome).
+   */
+  data: external_exports.record(external_exports.unknown()).optional(),
+  /** Optional motif touch — advances the shrinking-cache meter. */
+  motifTouch: motifTouchSchema.optional(),
+  /** Optional on-screen caption text. */
+  caption: external_exports.string().optional(),
+  /** Optional entrance transition. */
+  transitionIn: transitionInSchema.optional()
+}).strict();
+var sceneSectionSchema = external_exports.object({
+  sectionId: external_exports.string().min(1),
+  scenes: external_exports.array(sceneSpecSchema)
+});
+var sceneMapSchema = external_exports.array(sceneSectionSchema);
+
+// ../shared/src/bespoke-contracts.ts
+var weightedItem = external_exports.object({
+  key: external_exports.string().min(1),
+  weight: external_exports.number().min(0).max(100)
+}).strict();
+var candidate = external_exports.object({
+  word: external_exports.string().min(1),
+  p: external_exports.number().min(0).max(1)
+}).strict();
+var matchShapeSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var receiptConcessionSchema = external_exports.object({
+  title: external_exports.string().optional(),
+  eyebrow: external_exports.string().optional(),
+  // legacy header field (fallback)
+  items: external_exports.array(weightedItem).min(1).optional(),
+  footnote: external_exports.string().optional()
+}).strict();
+var heroHundredXSchema = external_exports.object({
+  value: external_exports.string().optional(),
+  unit: external_exports.string().optional(),
+  label: external_exports.string().optional(),
+  sub: external_exports.string().optional(),
+  accent: external_exports.enum(["red", "amber", "green", "blue"]).optional()
+}).strict();
+var heroReceiptLawSchema = external_exports.object({
+  header: external_exports.string().optional()
+}).strict();
+var kvSection2Schema = external_exports.object({
+  window: external_exports.tuple([external_exports.number(), external_exports.number()]).optional(),
+  windowDur: external_exports.number().positive().optional(),
+  cap2A: external_exports.string().optional(),
+  cap2B: external_exports.string().optional(),
+  cap2C: external_exports.string().optional(),
+  cap2D: external_exports.string().optional(),
+  cap2E: external_exports.string().optional(),
+  cap2F: external_exports.string().optional(),
+  cap2G: external_exports.string().optional(),
+  cap2H: external_exports.string().optional(),
+  cap2I: external_exports.string().optional(),
+  cap2J: external_exports.string().optional()
+}).strict().refine((d) => !d.window || d.window[1] > d.window[0], {
+  message: "kv-section-2 window must be [from, to] with to > from",
+  path: ["window"]
+});
+var guessBarsSchema = external_exports.object({
+  form: external_exports.enum(["certainty", "fork"]).optional(),
+  motif: external_exports.string().optional(),
+  prompt: external_exports.string().optional(),
+  node: external_exports.string().optional(),
+  candidates: external_exports.array(candidate).min(1).optional()
+}).strict();
+var scaleRowSchema = external_exports.object({
+  nearWords: external_exports.array(external_exports.string()).optional(),
+  eyebrow: external_exports.string().optional(),
+  horizon: external_exports.string().optional()
+}).strict();
+var readHeadSchema = external_exports.object({
+  words: external_exports.array(external_exports.string()).optional(),
+  eyebrow: external_exports.string().optional()
+}).strict();
+var wordsStepSchema = external_exports.object({
+  words: external_exports.array(external_exports.string()).optional(),
+  eyebrow: external_exports.string().optional(),
+  step: external_exports.string().optional()
+}).strict();
+var napkinSchema = external_exports.object({
+  block: external_exports.enum(["buys", "contrast", "zoomout"]).optional()
+}).strict();
+var attnPaperSchema = external_exports.object({
+  cap: external_exports.string().optional()
+}).strict();
+
 // ../pipeline/src/clip-render/engines/gemini-manim-remotion.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
@@ -5379,10 +5801,10 @@ function findRemotionRoot(startDir = process.cwd()) {
   }
   let cur = path.resolve(startDir);
   for (let i = 0; i <= MAX_PARENTS; i++) {
-    const candidate = path.join(cur, "packages", "remotion", "src", "Root.tsx");
-    if (fs.existsSync(candidate)) {
-      const cwd = path.dirname(path.dirname(candidate));
-      return { cwd, entry: candidate, source: "monorepo-walk" };
+    const candidate2 = path.join(cur, "packages", "remotion", "src", "Root.tsx");
+    if (fs.existsSync(candidate2)) {
+      const cwd = path.dirname(path.dirname(candidate2));
+      return { cwd, entry: candidate2, source: "monorepo-walk" };
     }
     const parent = path.dirname(cur);
     if (parent === cur) break;
@@ -5390,10 +5812,10 @@ function findRemotionRoot(startDir = process.cwd()) {
   }
   cur = path.resolve(startDir);
   for (let i = 0; i <= MAX_PARENTS; i++) {
-    const candidate = path.join(cur, "node_modules", "@forge", "remotion", "dist", "Root.js");
-    if (fs.existsSync(candidate)) {
-      const cwd = path.dirname(path.dirname(candidate));
-      return { cwd, entry: candidate, source: "node_modules" };
+    const candidate2 = path.join(cur, "node_modules", "@forge", "remotion", "dist", "Root.js");
+    if (fs.existsSync(candidate2)) {
+      const cwd = path.dirname(path.dirname(candidate2));
+      return { cwd, entry: candidate2, source: "node_modules" };
     }
     const parent = path.dirname(cur);
     if (parent === cur) break;
@@ -5674,7 +6096,9 @@ var renderGeminiRemotion = async (shot, ctx) => {
   const TEMPLATE_COMP_IDS = {
     "hero-number": { h: "HeroNumber", v: "HeroNumberVertical" },
     "bar-comparison": { h: "BarComparison", v: "BarComparisonVertical" },
-    "stat-row": { h: "StatRow", v: "StatRowVertical" }
+    "stat-row": { h: "StatRow", v: "StatRowVertical" },
+    "cache-mechanism": { h: "CacheMechanism", v: "CacheMechanismVertical" },
+    "technical-mechanism": { h: "CacheMechanism", v: "CacheMechanismVertical" }
   };
   const templateComp = shot.template ? TEMPLATE_COMP_IDS[shot.template.slug] : null;
   const compId = templateComp ? ctx.aspect === "9:16" ? templateComp.v : templateComp.h : ctx.aspect === "9:16" ? "ForgeShotVertical" : "ForgeShot";
@@ -5866,10 +6290,10 @@ var HyperFramesNotInstalledError = class extends Error {
   }
 };
 async function defaultHyperframesAvailable() {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     const proc = spawn("which", ["hyperframes"], { stdio: ["ignore", "pipe", "pipe"] });
-    proc.on("close", (code) => resolve3(code === 0));
-    proc.on("error", () => resolve3(false));
+    proc.on("close", (code) => resolve5(code === 0));
+    proc.on("error", () => resolve5(false));
   });
 }
 async function defaultRunHyperframes(htmlPath, outputMp4, fps, onStdoutLine) {
@@ -5877,7 +6301,7 @@ async function defaultRunHyperframes(htmlPath, outputMp4, fps, onStdoutLine) {
   await runProcess("npx", args, onStdoutLine);
 }
 function runProcess(cmd, args, onLine) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve5, reject) => {
     let proc;
     try {
       proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -5902,7 +6326,7 @@ function runProcess(cmd, args, onLine) {
     });
     proc.on("error", reject);
     proc.on("close", (code) => {
-      if (code === 0) resolve3();
+      if (code === 0) resolve5();
       else reject(new Error(`${cmd} ${args.join(" ")} exited ${code}
 ${stderrTail}`));
     });
@@ -6959,10 +7383,302 @@ var renderYouTubeClipRemotion = async (shot, ctx) => {
   });
 };
 
-// ../pipeline/src/clip-render/engines/cloud/lambda.ts
+// ../pipeline/src/clip-render/engines/motion-series.ts
+import * as fs13 from "fs";
+import * as path13 from "path";
+
+// ../pipeline/src/clip-render/engines/cloud/series-lambda.ts
 import * as fs12 from "fs";
 var DEFAULT_REGION = "us-east-1";
+var POLL_INTERVAL_MS = 2e3;
 function readLambdaCfg() {
+  const functionName = process.env.REMOTION_LAMBDA_FUNCTION_NAME;
+  const serveUrl = process.env.REMOTION_LAMBDA_SERVE_URL;
+  if (!functionName) throw new Error("REMOTION_LAMBDA_FUNCTION_NAME not set");
+  if (!serveUrl) throw new Error("REMOTION_LAMBDA_SERVE_URL not set");
+  const region = process.env.REMOTION_LAMBDA_REGION ?? process.env.AWS_REGION ?? DEFAULT_REGION;
+  return { functionName, serveUrl, region };
+}
+async function renderSeriesCompositionLambda(args) {
+  const { compId, inputProps, totalFrames, outPath, tracker, signal } = args;
+  if (signal?.aborted) throw new Error("aborted");
+  const cfg = readLambdaCfg();
+  const deadlineMs = Math.max(10 * 6e4, Math.round(args.durationSec * 6e3));
+  let renderMediaOnLambda;
+  let getRenderProgress;
+  try {
+    const mod = await import("./client-5FQUWSRI.js");
+    renderMediaOnLambda = mod.renderMediaOnLambda;
+    getRenderProgress = mod.getRenderProgress;
+  } catch (err) {
+    throw new Error(`@remotion/lambda is not installed for pipeline cloud render: ${err.message}`);
+  }
+  tracker.emit({ phase: "rendering", percent: 15, framesRendered: 0, totalFrames });
+  const startedAt = Date.now();
+  const { renderId, bucketName } = await renderMediaOnLambda({
+    region: cfg.region,
+    functionName: cfg.functionName,
+    serveUrl: cfg.serveUrl,
+    composition: compId,
+    inputProps,
+    codec: "h264",
+    imageFormat: "jpeg",
+    crf: 18,
+    privacy: "public",
+    maxRetries: 1
+  });
+  let lastFramesRendered = 0;
+  let outKey = null;
+  let totalCost = 0;
+  while (Date.now() - startedAt < deadlineMs) {
+    if (signal?.aborted) throw new Error("aborted");
+    await new Promise((resolve5) => setTimeout(resolve5, POLL_INTERVAL_MS));
+    const progress = await getRenderProgress({
+      renderId,
+      bucketName,
+      functionName: cfg.functionName,
+      region: cfg.region
+    });
+    if (progress.fatalErrorEncountered) {
+      const errMsg = progress.errors?.[0]?.message ?? "fatal error";
+      throw new Error(`${compId} Lambda failed: ${errMsg}`);
+    }
+    if (typeof progress.framesRendered === "number" && progress.framesRendered > lastFramesRendered) {
+      lastFramesRendered = progress.framesRendered;
+      tracker.emit({
+        phase: "rendering",
+        percent: Math.min(80, 15 + Math.round(lastFramesRendered / totalFrames * 65)),
+        framesRendered: lastFramesRendered,
+        totalFrames
+      });
+    }
+    if (typeof progress.costs?.accruedSoFar === "number") {
+      totalCost = progress.costs.accruedSoFar;
+    }
+    if (progress.done) {
+      outKey = progress.outKey ?? null;
+      break;
+    }
+  }
+  if (!outKey) {
+    throw new Error(`${compId} Lambda timed out after ${Math.round(deadlineMs / 1e3)}s`);
+  }
+  const s3Url = `https://s3.${cfg.region}.amazonaws.com/${bucketName}/${outKey}`;
+  const resp = await fetch(s3Url, { signal });
+  if (!resp.ok) {
+    throw new Error(`failed to fetch Lambda MP4 (${resp.status}): ${s3Url}`);
+  }
+  fs12.writeFileSync(outPath, Buffer.from(await resp.arrayBuffer()));
+  tracker.emit({
+    phase: "compositing",
+    percent: 85,
+    warnings: totalCost > 0 ? [`lambda cost: $${totalCost.toFixed(4)}`] : void 0
+  });
+}
+
+// ../pipeline/src/clip-render/engines/motion-series.ts
+var isHttp = (s) => !!s && /^https?:\/\//i.test(s);
+function resolveShotSrcs(plan) {
+  return plan.shots.map((s) => {
+    if (s.source === "photo-kenburns") return { shotId: s.id, src: s.photoSrc, kind: "photo" };
+    if (s.source === "manim") return { shotId: s.id, src: s.clipSrc ?? (s.clipId ? manimClip(s.clipId)?.src : void 0), kind: "manim" };
+    if (s.source === "video-broll") return { shotId: s.id, src: s.clipSrc ?? (s.clipId ? brollClip(s.clipId)?.src : void 0), kind: "broll" };
+    return { shotId: s.id, src: void 0, kind: "mg" };
+  });
+}
+function assertLocalAssetsExist(plan, publicDir) {
+  const missing = [];
+  for (const { shotId, src, kind } of resolveShotSrcs(plan)) {
+    if (kind === "mg" || !src || isHttp(src)) continue;
+    if (!fs13.existsSync(path13.join(publicDir, src))) {
+      missing.push(`${shotId}: ${src}`);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `motion series: ${missing.length} local asset(s) missing under ${publicDir} \u2014 ${missing.join("; ").slice(0, 400)}`
+    );
+  }
+}
+function getMotionPlan(spec) {
+  if (spec.seriesPlan?.kind !== "motion") {
+    throw new Error(`engine 'motion' requires spec.seriesPlan.kind='motion' (got ${spec.seriesPlan?.kind ?? "none"})`);
+  }
+  const { audioSrc: _dropped, ...rest } = spec.seriesPlan.plan;
+  return rest;
+}
+async function renderMotionSeries(spec, paths, outPath, fps, tracker, opts) {
+  const plan = getMotionPlan(spec);
+  const planFps = plan.fps ?? fps;
+  const totalFrames = Math.max(1, motionPlanDuration(plan));
+  if (spec.provider === "cloud") {
+    const nonHttp = resolveShotSrcs(plan).filter((r2) => r2.kind !== "mg" && r2.src && !isHttp(r2.src));
+    if (nonHttp.length === 0) {
+      try {
+        tracker.emit({ phase: "preparing", percent: 8, warnings: ["trying Remotion Lambda MotionSeries render"] });
+        await renderSeriesCompositionLambda({
+          compId: "MotionSeries",
+          inputProps: { plan },
+          totalFrames,
+          durationSec: spec.durationSec,
+          outPath,
+          tracker,
+          signal: opts.signal
+        });
+        return;
+      } catch (err) {
+        const detail = (err instanceof Error ? err.message : String(err)).slice(0, 220);
+        tracker.emit({
+          phase: "preparing",
+          percent: 9,
+          warnings: [`Remotion Lambda MotionSeries unavailable: ${detail} \u2014 falling back to local Remotion`]
+        });
+      }
+    } else {
+      tracker.emit({
+        phase: "preparing",
+        percent: 8,
+        warnings: [`cloud render requested but ${nonHttp.length} asset(s) are not http URLs \u2014 rendering locally`]
+      });
+    }
+  }
+  const remotion = requireRemotionRoot();
+  const publicDir = path13.join(remotion.cwd, "public");
+  assertLocalAssetsExist(plan, publicDir);
+  const propsPath = path13.join(paths.remotionDir, `${spec.chunkId}_motion_props.json`);
+  fs13.mkdirSync(path13.dirname(propsPath), { recursive: true });
+  fs13.writeFileSync(propsPath, JSON.stringify({ plan }, null, 2));
+  tracker.emit({ phase: "rendering", percent: 15, framesRendered: 0, totalFrames });
+  const timeoutMs = Math.max(6e5, Math.round(spec.durationSec * 12e3));
+  const r = await runCmd(
+    "npx",
+    [
+      "remotion",
+      "render",
+      remotion.entry,
+      "MotionSeries",
+      "--props",
+      propsPath,
+      "--output",
+      outPath,
+      "--concurrency",
+      "4"
+    ],
+    { timeoutMs, signal: opts.signal, cwd: remotion.cwd }
+  );
+  if (r.code !== 0) {
+    const tail = r.stderr.split("\n").slice(-8).join(" ").slice(0, 400);
+    throw new Error(`motion series render failed (code ${r.code}): ${tail}`);
+  }
+  tracker.emit({ phase: "rendering", percent: 80, framesRendered: totalFrames, totalFrames });
+  void planFps;
+}
+var renderMotionShotStub = async (shot) => {
+  throw new Error(
+    `engine 'motion' is chunk-level (seriesPlan) \u2014 no per-shot adapter (shot ${shot.id}). Spec likely lost its seriesPlan; falling back via the engine chain.`
+  );
+};
+
+// ../pipeline/src/clip-render/engines/cinematic-series.ts
+import * as fs14 from "fs";
+import * as path14 from "path";
+var isHttp2 = (s) => /^https?:\/\//i.test(s);
+function getCinematicPlan(spec) {
+  if (spec.seriesPlan?.kind !== "cinematic") {
+    throw new Error(`engine 'cinematic' requires spec.seriesPlan.kind='cinematic' (got ${spec.seriesPlan?.kind ?? "none"})`);
+  }
+  const { audioSrc: _dropped, ...rest } = spec.seriesPlan.plan;
+  return rest;
+}
+function localAssetSrcs(plan) {
+  const out = [];
+  for (const shot of plan.shots) {
+    for (const asset of shot.assets ?? []) {
+      if (!isHttp2(asset.src)) out.push({ shotId: shot.id, src: asset.src });
+    }
+  }
+  return out;
+}
+async function renderCinematicSeries(spec, paths, outPath, fps, tracker, opts) {
+  const plan = getCinematicPlan(spec);
+  const planFps = plan.fps ?? fps;
+  const totalFrames = Math.max(1, Math.round(plan.durationSec * planFps));
+  const localAssets = localAssetSrcs(plan);
+  if (spec.provider === "cloud") {
+    if (localAssets.length === 0) {
+      try {
+        tracker.emit({ phase: "preparing", percent: 8, warnings: ["trying Remotion Lambda CinematicSceneSeries render"] });
+        await renderSeriesCompositionLambda({
+          compId: "CinematicSceneSeries",
+          inputProps: { plan },
+          totalFrames,
+          durationSec: spec.durationSec,
+          outPath,
+          tracker,
+          signal: opts.signal
+        });
+        return;
+      } catch (err) {
+        const detail = (err instanceof Error ? err.message : String(err)).slice(0, 220);
+        tracker.emit({
+          phase: "preparing",
+          percent: 9,
+          warnings: [`Remotion Lambda CinematicSceneSeries unavailable: ${detail} \u2014 falling back to local Remotion`]
+        });
+      }
+    } else {
+      tracker.emit({
+        phase: "preparing",
+        percent: 8,
+        warnings: [`cloud render requested but ${localAssets.length} asset(s) are not http URLs \u2014 rendering locally`]
+      });
+    }
+  }
+  const remotion = requireRemotionRoot();
+  const publicDir = path14.join(remotion.cwd, "public");
+  const missing = localAssets.filter(({ src }) => !fs14.existsSync(path14.join(publicDir, src)));
+  if (missing.length > 0) {
+    throw new Error(
+      `cinematic series: ${missing.length} local asset(s) missing under ${publicDir} \u2014 ` + missing.map((m) => `${m.shotId}: ${m.src}`).join("; ").slice(0, 400)
+    );
+  }
+  const propsPath = path14.join(paths.remotionDir, `${spec.chunkId}_cinematic_props.json`);
+  fs14.mkdirSync(path14.dirname(propsPath), { recursive: true });
+  fs14.writeFileSync(propsPath, JSON.stringify({ plan }, null, 2));
+  tracker.emit({ phase: "rendering", percent: 15, framesRendered: 0, totalFrames });
+  const timeoutMs = Math.max(6e5, Math.round(spec.durationSec * 12e3));
+  const r = await runCmd(
+    "npx",
+    [
+      "remotion",
+      "render",
+      remotion.entry,
+      "CinematicSceneSeries",
+      "--props",
+      propsPath,
+      "--output",
+      outPath,
+      "--concurrency",
+      "4"
+    ],
+    { timeoutMs, signal: opts.signal, cwd: remotion.cwd }
+  );
+  if (r.code !== 0) {
+    const tail = r.stderr.split("\n").slice(-8).join(" ").slice(0, 400);
+    throw new Error(`cinematic series render failed (code ${r.code}): ${tail}`);
+  }
+  tracker.emit({ phase: "rendering", percent: 80, framesRendered: totalFrames, totalFrames });
+}
+var renderCinematicShotStub = async (shot) => {
+  throw new Error(
+    `engine 'cinematic' is chunk-level (seriesPlan) \u2014 no per-shot adapter (shot ${shot.id}). Spec likely lost its seriesPlan; falling back via the engine chain.`
+  );
+};
+
+// ../pipeline/src/clip-render/engines/cloud/lambda.ts
+import * as fs15 from "fs";
+var DEFAULT_REGION2 = "us-east-1";
+function readLambdaCfg2() {
   const functionName = process.env.REMOTION_LAMBDA_FUNCTION_NAME;
   const serveUrl = process.env.REMOTION_LAMBDA_SERVE_URL;
   if (!functionName) {
@@ -6975,7 +7691,7 @@ function readLambdaCfg() {
       "lambda engine: REMOTION_LAMBDA_SERVE_URL not set. Deploy via `npx remotion lambda sites create`."
     );
   }
-  const region = process.env.REMOTION_LAMBDA_REGION ?? process.env.AWS_REGION ?? DEFAULT_REGION;
+  const region = process.env.REMOTION_LAMBDA_REGION ?? process.env.AWS_REGION ?? DEFAULT_REGION2;
   return { functionName, serveUrl, region };
 }
 var renderDocumentaryV2Lambda = async (shot, ctx) => {
@@ -6987,7 +7703,7 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
   }
   let cfg;
   try {
-    cfg = readLambdaCfg();
+    cfg = readLambdaCfg2();
   } catch (err) {
     ctx.progress.emit({
       phase: "preparing",
@@ -7001,10 +7717,10 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
   if (shot.prompt.trimStart().startsWith("{")) {
     data = JSON.parse(shot.prompt);
   } else {
-    if (!fs12.existsSync(shot.prompt)) {
+    if (!fs15.existsSync(shot.prompt)) {
       throw new Error(`lambda: CompositionV2Data file not found: ${shot.prompt}`);
     }
-    data = JSON.parse(fs12.readFileSync(shot.prompt, "utf8"));
+    data = JSON.parse(fs15.readFileSync(shot.prompt, "utf8"));
   }
   let renderMediaOnLambda;
   let getRenderProgress;
@@ -7038,14 +7754,14 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
     maxRetries: 1
     // framesPerLambda omitted — Remotion auto-tunes for cost vs speed
   });
-  const HARD_DEADLINE_MS = 10 * 6e4;
-  const POLL_INTERVAL_MS2 = 2e3;
+  const HARD_DEADLINE_MS2 = 10 * 6e4;
+  const POLL_INTERVAL_MS4 = 2e3;
   let lastFramesRendered = 0;
   let outKey = null;
   let totalCost = 0;
-  while (Date.now() - startedAt < HARD_DEADLINE_MS) {
+  while (Date.now() - startedAt < HARD_DEADLINE_MS2) {
     if (ctx.signal?.aborted) throw new Error("aborted");
-    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS2));
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS4));
     const progress = await getRenderProgress({
       renderId,
       bucketName,
@@ -7075,7 +7791,7 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
     }
   }
   if (!outKey) {
-    throw new Error(`lambda render timed out after ${HARD_DEADLINE_MS / 1e3}s`);
+    throw new Error(`lambda render timed out after ${HARD_DEADLINE_MS2 / 1e3}s`);
   }
   ctx.progress.emit({ phase: "compositing", shotId: shot.id, percent: 90 });
   const s3Url = `https://s3.${cfg.region}.amazonaws.com/${bucketName}/${outKey}`;
@@ -7084,7 +7800,7 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
     throw new Error(`lambda: failed to fetch rendered MP4 from S3 (${resp.status}): ${s3Url}`);
   }
   const buf = Buffer.from(await resp.arrayBuffer());
-  fs12.writeFileSync(ctx.sceneOutPath, buf);
+  fs15.writeFileSync(ctx.sceneOutPath, buf);
   if (totalCost > 0) {
     ctx.progress.emit({
       phase: "compositing",
@@ -7096,7 +7812,7 @@ var renderDocumentaryV2Lambda = async (shot, ctx) => {
 };
 
 // ../pipeline/src/clip-render/engines/cloud/runpod-manim.ts
-import * as fs13 from "fs";
+import * as fs16 from "fs";
 
 // ../pipeline/src/clip-render/engines/cloud/runpod-client.ts
 var RUNPOD_BASE = "https://api.runpod.ai/v2";
@@ -7265,7 +7981,7 @@ var renderManimRunPod = async (shot, ctx) => {
     });
     return localFallback(shot, ctx);
   }
-  fs13.writeFileSync(ctx.sceneOutPath, buf);
+  fs16.writeFileSync(ctx.sceneOutPath, buf);
   if (status.executionTime) {
     const cost = status.executionTime / 1e3 * 19e-5;
     ctx.progress.emit({
@@ -7278,7 +7994,7 @@ var renderManimRunPod = async (shot, ctx) => {
 };
 
 // ../pipeline/src/clip-render/engines/cloud/runpod-hyperframes.ts
-import * as fs14 from "fs";
+import * as fs17 from "fs";
 var renderHyperframesRunPod = async (shot, ctx) => {
   if (ctx.signal?.aborted) throw new Error("aborted");
   if (!shot.hyperframesHtml || shot.hyperframesHtml.trim().length === 0) {
@@ -7333,7 +8049,7 @@ var renderHyperframesRunPod = async (shot, ctx) => {
   );
   ctx.progress.emit({ phase: "compositing", shotId: shot.id, percent: 90 });
   const buf = decodeBase64Mp4(status.output);
-  fs14.writeFileSync(ctx.sceneOutPath, buf);
+  fs17.writeFileSync(ctx.sceneOutPath, buf);
   if (status.executionTime) {
     const cost = status.executionTime / 1e3 * 19e-5;
     ctx.progress.emit({
@@ -7358,7 +8074,12 @@ var ENGINE_ADAPTERS = {
   "documentary-v2": renderDocumentaryV2,
   "web-article+remotion": renderWebArticleRemotion,
   "x-post+remotion": renderXPostRemotion,
-  "youtube-clip+remotion": renderYouTubeClipRemotion
+  "youtube-clip+remotion": renderYouTubeClipRemotion,
+  // Series engines are chunk-level (render-chunk routes them through the
+  // series path); these stubs keep the Record total and bubble a clear
+  // error into the fallback chain if a spec ever loses its seriesPlan.
+  "motion": renderMotionShotStub,
+  "cinematic": renderCinematicShotStub
 };
 var CLOUD_ENGINE_ADAPTERS = {
   "documentary-v2": renderDocumentaryV2Lambda,
@@ -7387,56 +8108,382 @@ function isManimEngine(engine) {
   return MANIM_ENGINES.has(engine);
 }
 
-// ../pipeline/src/clip-render/fs-layout.ts
-import * as fs15 from "fs";
-import * as path13 from "path";
-function resolveProjectRoot(projectSlug, callerOutputDir) {
-  if (callerOutputDir && callerOutputDir.length > 0) {
-    if (!path13.isAbsolute(callerOutputDir)) {
-      throw new Error(
-        `clip-render: spec.outputDir must be absolute, got "${callerOutputDir}"`
-      );
-    }
-    return callerOutputDir;
+// ../pipeline/src/clip-render/engines/gemini-remotion-series.ts
+import * as fs19 from "fs";
+import * as path15 from "path";
+
+// ../pipeline/src/clip-render/engines/cloud/remotion-series-lambda.ts
+import * as fs18 from "fs";
+var DEFAULT_REGION3 = "us-east-1";
+var HARD_DEADLINE_MS = 10 * 6e4;
+var POLL_INTERVAL_MS2 = 2e3;
+function readLambdaCfg3() {
+  const functionName = process.env.REMOTION_LAMBDA_FUNCTION_NAME;
+  const serveUrl = process.env.REMOTION_LAMBDA_SERVE_URL;
+  if (!functionName) {
+    throw new Error("REMOTION_LAMBDA_FUNCTION_NAME not set");
   }
-  if (!projectSlug || /[/\\]/.test(projectSlug)) {
-    throw new Error(`clip-render: invalid projectSlug "${projectSlug}"`);
+  if (!serveUrl) {
+    throw new Error("REMOTION_LAMBDA_SERVE_URL not set");
   }
-  return path13.resolve(process.cwd(), "forge-renders", projectSlug);
+  const region = process.env.REMOTION_LAMBDA_REGION ?? process.env.AWS_REGION ?? DEFAULT_REGION3;
+  return { functionName, serveUrl, region };
 }
-function chunkPaths(projectSlug, chunkId, callerOutputDir) {
-  if (!chunkId || /[/\\]/.test(chunkId)) {
-    throw new Error(`clip-render: invalid chunkId "${chunkId}"`);
-  }
-  const root = resolveProjectRoot(projectSlug, callerOutputDir);
-  const tmpDir = path13.join(root, ".tmp", chunkId);
-  return {
-    root,
-    finalClipPath: path13.join(root, "clips", `${chunkId}.mp4`),
-    tmpDir,
-    scenesDir: path13.join(tmpDir, "scenes"),
-    manimDir: path13.join(tmpDir, "manim"),
-    remotionDir: path13.join(tmpDir, "remotion"),
-    hyperframesDir: path13.join(tmpDir, "hyperframes"),
-    progressLogPath: path13.join(root, "progress.json")
-  };
+function isHttpUrl(value) {
+  return !!value && /^https?:\/\//i.test(value);
 }
-function ensureChunkDirs(paths) {
-  for (const dir of [
-    path13.dirname(paths.finalClipPath),
-    paths.tmpDir,
+function assertLambdaAccessibleAssets(shots) {
+  for (const shot of shots) {
+    const paths = [
+      shot.imagePath,
+      shot.comparisonImage?.imagePath,
+      typeof shot.template?.props.backdropImage === "string" ? shot.template.props.backdropImage : void 0
+    ].filter(Boolean);
+    const templateAssets = shot.template?.props.assets;
+    if (Array.isArray(templateAssets)) {
+      for (const asset of templateAssets) {
+        if (!asset || typeof asset !== "object") continue;
+        const src = asset.src;
+        if (typeof src === "string") {
+          paths.push(src);
+        }
+      }
+    }
+    for (const source of paths) {
+      if (!isHttpUrl(source)) {
+        throw new Error(
+          `ChunkSceneSeries Lambda requires public http(s) asset URLs; shot ${shot.id} has "${source}"`
+        );
+      }
+    }
+  }
+}
+async function renderChunkSceneSeriesLambda(spec, outPath, fps, tracker, signal) {
+  if (signal?.aborted) throw new Error("aborted");
+  const cfg = readLambdaCfg3();
+  assertLambdaAccessibleAssets(spec.shots);
+  let renderMediaOnLambda;
+  let getRenderProgress;
+  try {
+    const mod = await import("./client-5FQUWSRI.js");
+    renderMediaOnLambda = mod.renderMediaOnLambda;
+    getRenderProgress = mod.getRenderProgress;
+  } catch (err) {
+    throw new Error(
+      `@remotion/lambda is not installed for pipeline cloud render: ${err.message}`
+    );
+  }
+  const compId = spec.aspect === "9:16" ? "ChunkSceneSeriesVertical" : "ChunkSceneSeries";
+  const totalFrames = Math.max(
+    1,
+    spec.shots.reduce((sum, shot) => sum + Math.max(1, Math.round(shot.durationSec * fps)), 0)
+  );
+  tracker.emit({
+    phase: "rendering",
+    percent: 15,
+    framesRendered: 0,
+    totalFrames
+  });
+  const startedAt = Date.now();
+  const { renderId, bucketName } = await renderMediaOnLambda({
+    region: cfg.region,
+    functionName: cfg.functionName,
+    serveUrl: cfg.serveUrl,
+    composition: compId,
+    inputProps: {
+      shots: spec.shots,
+      fxPlan: spec.fxPlan,
+      aspect: spec.aspect
+    },
+    codec: "h264",
+    imageFormat: "jpeg",
+    crf: 18,
+    privacy: "public",
+    maxRetries: 1
+  });
+  let lastFramesRendered = 0;
+  let outKey = null;
+  let totalCost = 0;
+  while (Date.now() - startedAt < HARD_DEADLINE_MS) {
+    if (signal?.aborted) throw new Error("aborted");
+    await new Promise((resolve5) => setTimeout(resolve5, POLL_INTERVAL_MS2));
+    const progress = await getRenderProgress({
+      renderId,
+      bucketName,
+      functionName: cfg.functionName,
+      region: cfg.region
+    });
+    if (progress.fatalErrorEncountered) {
+      const errMsg = progress.errors?.[0]?.message ?? "fatal error";
+      throw new Error(`ChunkSceneSeries Lambda failed: ${errMsg}`);
+    }
+    if (typeof progress.framesRendered === "number" && progress.framesRendered > lastFramesRendered) {
+      lastFramesRendered = progress.framesRendered;
+      tracker.emit({
+        phase: "rendering",
+        percent: Math.min(80, 15 + Math.round(lastFramesRendered / totalFrames * 65)),
+        framesRendered: lastFramesRendered,
+        totalFrames
+      });
+    }
+    if (typeof progress.costs?.accruedSoFar === "number") {
+      totalCost = progress.costs.accruedSoFar;
+    }
+    if (progress.done) {
+      outKey = progress.outKey ?? null;
+      break;
+    }
+  }
+  if (!outKey) {
+    throw new Error(`ChunkSceneSeries Lambda timed out after ${HARD_DEADLINE_MS / 1e3}s`);
+  }
+  const s3Url = `https://s3.${cfg.region}.amazonaws.com/${bucketName}/${outKey}`;
+  const resp = await fetch(s3Url, { signal });
+  if (!resp.ok) {
+    throw new Error(`failed to fetch Lambda MP4 (${resp.status}): ${s3Url}`);
+  }
+  fs18.writeFileSync(outPath, Buffer.from(await resp.arrayBuffer()));
+  tracker.emit({
+    phase: "compositing",
+    percent: 85,
+    warnings: totalCost > 0 ? [`lambda cost: $${totalCost.toFixed(4)}`] : void 0
+  });
+}
+
+// ../pipeline/src/clip-render/engines/gemini-remotion-series.ts
+function safeId(id) {
+  return id.replace(/[^a-z0-9_-]/gi, "_");
+}
+function extensionForSource(source) {
+  try {
+    if (/^https?:\/\//i.test(source)) {
+      return path15.extname(new URL(source).pathname) || ".png";
+    }
+  } catch {
+    return ".png";
+  }
+  return path15.extname(source) || ".png";
+}
+async function stageAssetToPublic(source, publicRel, publicAbs, signal) {
+  if (/^https?:\/\//i.test(source)) {
+    const resp = await fetch(source, { signal });
+    if (!resp.ok) {
+      throw new Error(`series: asset fetch failed ${resp.status} for ${source}`);
+    }
+    fs19.mkdirSync(path15.dirname(publicAbs), { recursive: true });
+    fs19.writeFileSync(publicAbs, Buffer.from(await resp.arrayBuffer()));
+    return publicRel;
+  }
+  if (path15.isAbsolute(source) && fs19.existsSync(source)) {
+    fs19.mkdirSync(path15.dirname(publicAbs), { recursive: true });
+    fs19.copyFileSync(source, publicAbs);
+    return publicRel;
+  }
+  const cwdRelative = path15.resolve(source);
+  if (fs19.existsSync(cwdRelative)) {
+    fs19.mkdirSync(path15.dirname(publicAbs), { recursive: true });
+    fs19.copyFileSync(cwdRelative, publicAbs);
+    return publicRel;
+  }
+  return source;
+}
+async function stageTemplateAssets(shot, staged, cacheRel, cacheAbs, signal) {
+  const assets = staged.template?.props.assets;
+  if (!Array.isArray(assets)) return;
+  staged.template.props.assets = await Promise.all(
+    assets.map(async (asset, i) => {
+      if (!asset || typeof asset !== "object") return asset;
+      const src = asset.src;
+      if (typeof src !== "string") return asset;
+      const ext = extensionForSource(src);
+      const rel = path15.posix.join(cacheRel, `${safeId(shot.id)}_asset_${i}${ext}`);
+      const abs = path15.join(cacheAbs, `${safeId(shot.id)}_asset_${i}${ext}`);
+      return {
+        ...asset,
+        src: await stageAssetToPublic(src, rel, abs, signal)
+      };
+    })
+  );
+}
+function hasUnsupportedShotEngine(shot) {
+  return Boolean(shot.engine && shot.engine !== "gemini+remotion");
+}
+function canRenderGeminiRemotionSeries(spec) {
+  if (spec.engine !== "gemini+remotion") return false;
+  if (spec.shots.length <= 1 && !spec.shots.some((shot) => Boolean(shot.template))) return false;
+  return spec.shots.every((shot) => !hasUnsupportedShotEngine(shot));
+}
+async function stageShot(shot, chunkId, remotionPublicDir, signal) {
+  const staged = {
+    ...shot,
+    comparisonImage: shot.comparisonImage ? { ...shot.comparisonImage } : void 0,
+    template: shot.template ? { slug: shot.template.slug, props: { ...shot.template.props } } : void 0
+  };
+  const cacheRel = path15.posix.join("clip-render-cache", chunkId);
+  const cacheAbs = path15.join(remotionPublicDir, cacheRel);
+  if (shot.imagePath) {
+    const ext = extensionForSource(shot.imagePath);
+    const rel = path15.posix.join(cacheRel, `${safeId(shot.id)}${ext}`);
+    const abs = path15.join(cacheAbs, `${safeId(shot.id)}${ext}`);
+    staged.imagePath = await stageAssetToPublic(shot.imagePath, rel, abs, signal);
+  }
+  if (shot.comparisonImage?.imagePath) {
+    const ext = extensionForSource(shot.comparisonImage.imagePath);
+    const rel = path15.posix.join(cacheRel, `${safeId(shot.id)}_comparison${ext}`);
+    const abs = path15.join(cacheAbs, `${safeId(shot.id)}_comparison${ext}`);
+    staged.comparisonImage = {
+      ...shot.comparisonImage,
+      imagePath: await stageAssetToPublic(shot.comparisonImage.imagePath, rel, abs, signal)
+    };
+  }
+  const backdropImage = staged.template?.props.backdropImage;
+  if (typeof backdropImage === "string") {
+    const ext = extensionForSource(backdropImage);
+    const rel = path15.posix.join(cacheRel, `${safeId(shot.id)}_template_backdrop${ext}`);
+    const abs = path15.join(cacheAbs, `${safeId(shot.id)}_template_backdrop${ext}`);
+    staged.template.props.backdropImage = await stageAssetToPublic(
+      backdropImage,
+      rel,
+      abs,
+      signal
+    );
+  }
+  await stageTemplateAssets(shot, staged, cacheRel, cacheAbs, signal);
+  return staged;
+}
+async function renderGeminiRemotionSeries(spec, paths, outPath, fps, tracker, opts) {
+  const remotion = requireRemotionRoot();
+  const publicDir = path15.join(remotion.cwd, "public");
+  if (spec.provider === "cloud") {
+    try {
+      tracker.emit({
+        phase: "preparing",
+        percent: 8,
+        warnings: ["trying Remotion Lambda ChunkSceneSeries render"]
+      });
+      await renderChunkSceneSeriesLambda(spec, outPath, fps, tracker, opts.signal);
+      return;
+    } catch (err) {
+      const detail = (err instanceof Error ? err.message : String(err)).slice(0, 220);
+      tracker.emit({
+        phase: "preparing",
+        percent: 9,
+        warnings: [`Remotion Lambda ChunkSceneSeries unavailable: ${detail} \u2014 falling back to local Remotion`]
+      });
+    }
+  }
+  tracker.emit({
+    phase: "preparing",
+    percent: 8
+  });
+  const shots = [];
+  for (const shot of spec.shots) {
+    if (opts.signal?.aborted) throw new Error("aborted");
+    shots.push(await stageShot(shot, spec.chunkId, publicDir, opts.signal));
+  }
+  const propsPath = path15.join(paths.remotionDir, `${spec.chunkId}_series_props.json`);
+  fs19.mkdirSync(path15.dirname(propsPath), { recursive: true });
+  fs19.writeFileSync(
+    propsPath,
+    JSON.stringify(
+      {
+        shots,
+        fxPlan: spec.fxPlan,
+        aspect: spec.aspect
+      },
+      null,
+      2
+    )
+  );
+  const totalFrames = Math.max(
+    1,
+    shots.reduce((sum, shot) => sum + Math.max(1, Math.round(shot.durationSec * fps)), 0)
+  );
+  tracker.emit({
+    phase: "rendering",
+    percent: 15,
+    framesRendered: 0,
+    totalFrames
+  });
+  const compId = spec.aspect === "9:16" ? "ChunkSceneSeriesVertical" : "ChunkSceneSeries";
+  const r = await runCmd(
+    "npx",
+    [
+      "remotion",
+      "render",
+      remotion.entry,
+      compId,
+      "--props",
+      propsPath,
+      "--output",
+      outPath,
+      "--concurrency",
+      "4"
+    ],
+    { timeoutMs: 6e5, signal: opts.signal, cwd: remotion.cwd }
+  );
+  if (r.code !== 0) {
+    const tail = r.stderr.split("\n").slice(-8).join(" ").slice(0, 400);
+    throw new Error(`gemini+remotion series render failed (code ${r.code}): ${tail}`);
+  }
+  tracker.emit({
+    phase: "rendering",
+    percent: 80,
+    framesRendered: totalFrames,
+    totalFrames
+  });
+}
+
+// ../pipeline/src/clip-render/fs-layout.ts
+import * as fs20 from "fs";
+import * as path16 from "path";
+function resolveProjectRoot(projectSlug, callerOutputDir) {
+  if (callerOutputDir && callerOutputDir.length > 0) {
+    if (!path16.isAbsolute(callerOutputDir)) {
+      throw new Error(
+        `clip-render: spec.outputDir must be absolute, got "${callerOutputDir}"`
+      );
+    }
+    return callerOutputDir;
+  }
+  if (!projectSlug || /[/\\]/.test(projectSlug)) {
+    throw new Error(`clip-render: invalid projectSlug "${projectSlug}"`);
+  }
+  return path16.resolve(process.cwd(), "forge-renders", projectSlug);
+}
+function chunkPaths(projectSlug, chunkId, callerOutputDir) {
+  if (!chunkId || /[/\\]/.test(chunkId)) {
+    throw new Error(`clip-render: invalid chunkId "${chunkId}"`);
+  }
+  const root = resolveProjectRoot(projectSlug, callerOutputDir);
+  const tmpDir = path16.join(root, ".tmp", chunkId);
+  return {
+    root,
+    finalClipPath: path16.join(root, "clips", `${chunkId}.mp4`),
+    tmpDir,
+    scenesDir: path16.join(tmpDir, "scenes"),
+    manimDir: path16.join(tmpDir, "manim"),
+    remotionDir: path16.join(tmpDir, "remotion"),
+    hyperframesDir: path16.join(tmpDir, "hyperframes"),
+    progressLogPath: path16.join(root, "progress.json")
+  };
+}
+function ensureChunkDirs(paths) {
+  for (const dir of [
+    path16.dirname(paths.finalClipPath),
+    paths.tmpDir,
     paths.scenesDir,
     paths.manimDir,
     paths.remotionDir,
     paths.hyperframesDir
   ]) {
-    fs15.mkdirSync(dir, { recursive: true });
+    fs20.mkdirSync(dir, { recursive: true });
   }
 }
 function appendProgress(progressLogPath, event) {
   try {
-    fs15.mkdirSync(path13.dirname(progressLogPath), { recursive: true });
-    fs15.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
+    fs20.mkdirSync(path16.dirname(progressLogPath), { recursive: true });
+    fs20.appendFileSync(progressLogPath, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -7536,13 +8583,38 @@ async function renderChunk(spec, opts = {}) {
     });
     tracker.emit({ phase: "queued", percent: 0 });
     try {
-      await renderWithEngine(spec, engine, paths, fps, tracker, opts);
+      const concatTarget = path17.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
+      const seriesKind = engine === spec.engine && spec.seriesPlan?.kind === engine ? spec.seriesPlan.kind : null;
+      const canRenderSeries = engine === spec.engine && canRenderGeminiRemotionSeries(spec);
+      if (seriesKind === "motion") {
+        await renderMotionSeries(spec, paths, concatTarget, fps, tracker, opts);
+      } else if (seriesKind === "cinematic") {
+        await renderCinematicSeries(spec, paths, concatTarget, fps, tracker, opts);
+      } else if (canRenderSeries) {
+        try {
+          await renderGeminiRemotionSeries(spec, paths, concatTarget, fps, tracker, opts);
+        } catch (err) {
+          const detail = (err instanceof Error ? err.message : String(err)).slice(0, 200);
+          warnings.push(`gemini+remotion series render failed: ${detail} \u2014 falling back to per-shot render`);
+          tracker.emit({
+            phase: "rendering",
+            percent: 10,
+            warnings: [warnings[warnings.length - 1]]
+          });
+          await renderWithEngine(spec, engine, paths, fps, tracker, opts);
+          tracker.emit({ phase: "compositing", percent: 85 });
+          const scenePaths = spec.shots.map((s) => sceneOutPath(paths, s));
+          await concatScenes(scenePaths, concatTarget, { signal: opts.signal });
+        }
+      } else {
+        await renderWithEngine(spec, engine, paths, fps, tracker, opts);
+        tracker.emit({ phase: "compositing", percent: 85 });
+        const scenePaths = spec.shots.map((s) => sceneOutPath(paths, s));
+        await concatScenes(scenePaths, concatTarget, { signal: opts.signal });
+      }
       tracker.emit({ phase: "compositing", percent: 85 });
-      const scenePaths = spec.shots.map((s) => sceneOutPath(paths, s));
-      const concatTarget = path14.join(paths.tmpDir, `${spec.chunkId}_video.mp4`);
-      await concatScenes(scenePaths, concatTarget, { signal: opts.signal });
       if (opts.signal?.aborted) throw new Error("aborted");
-      const audioAvailable = !!spec.audioPath && fs16.existsSync(spec.audioPath);
+      const audioAvailable = !!spec.audioPath && fs21.existsSync(spec.audioPath);
       if (audioAvailable) {
         tracker.emit({ phase: "muxing", percent: 95 });
         await muxAudio(concatTarget, spec.audioPath, paths.finalClipPath, {
@@ -7554,7 +8626,7 @@ async function renderChunk(spec, opts = {}) {
         } else {
           warnings.push("no audioPath in spec \u2014 wrote silent clip");
         }
-        fs16.copyFileSync(concatTarget, paths.finalClipPath);
+        fs21.copyFileSync(concatTarget, paths.finalClipPath);
       }
       tracker.emit({ phase: "done", percent: 100 });
       const renderTimeMs2 = (opts.now ?? Date.now)() - startedAt;
@@ -7593,7 +8665,7 @@ async function renderChunk(spec, opts = {}) {
   };
 }
 function sceneOutPath(paths, shot) {
-  return path14.join(paths.scenesDir, `${shot.id}.mp4`);
+  return path17.join(paths.scenesDir, `${shot.id}.mp4`);
 }
 function abortedResult(spec, engine, fallbackDepth, startedAt, now) {
   return {
@@ -7637,7 +8709,7 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
       progress: tracker,
       resolvedEngine: shotEngine
     };
-    fs16.mkdirSync(path14.dirname(ctx.sceneOutPath), { recursive: true });
+    fs21.mkdirSync(path17.dirname(ctx.sceneOutPath), { recursive: true });
     const release = opts.acquireManimSlot ? await opts.acquireManimSlot() : void 0;
     try {
       tracker.emit({
@@ -7664,186 +8736,1713 @@ async function renderWithEngine(spec, engine, paths, fps, tracker, opts) {
     } finally {
       release?.();
     }
-    if (!fs16.existsSync(ctx.sceneOutPath)) {
+    if (!fs21.existsSync(ctx.sceneOutPath)) {
       throw new Error(
         `engine ${shotEngine} produced no output at ${ctx.sceneOutPath} for shot ${shot.id}`
       );
     }
   }
-  tracker.emit({ phase: "rendering", percent: 80 });
+  tracker.emit({ phase: "rendering", percent: 80 });
+}
+function implicitShot(spec) {
+  return {
+    id: "shot0",
+    startSec: 0,
+    durationSec: spec.durationSec
+  };
+}
+
+// ../pipeline/src/clip-render/orchestrator.ts
+var import_p_limit = __toESM(require_p_limit());
+import * as os from "os";
+
+// ../pipeline/src/clip-render/manifest.ts
+import * as fs22 from "fs";
+import * as path18 from "path";
+function buildLocalManifestStub(specs, results, now = () => /* @__PURE__ */ new Date()) {
+  const specByChunk = new Map(specs.map((s) => [s.chunkId, s]));
+  const entries = [];
+  for (const r of results) {
+    if (!r.ok || !r.outputPath) continue;
+    const spec = specByChunk.get(r.chunkId);
+    if (!spec) continue;
+    let size = 0;
+    try {
+      const stat = fs22.statSync(r.outputPath);
+      if (stat.isFile()) size = stat.size;
+    } catch {
+      continue;
+    }
+    if (size === 0) continue;
+    entries.push({
+      kind: "clips",
+      chunkId: r.chunkId,
+      ext: "mp4",
+      size,
+      localPath: r.outputPath,
+      aspect: spec.aspect
+    });
+  }
+  return { writtenAt: now().toISOString(), version: 1, entries };
+}
+function localManifestStubPath(root) {
+  return path18.join(root, "manifest.local.json");
+}
+function writeLocalManifestStub(root, stub) {
+  fs22.mkdirSync(root, { recursive: true });
+  const target = localManifestStubPath(root);
+  const tmp = `${target}.tmp-${process.pid}`;
+  fs22.writeFileSync(tmp, JSON.stringify(stub, null, 2));
+  fs22.renameSync(tmp, target);
+  return target;
+}
+
+// ../pipeline/src/clip-render/orchestrator.ts
+function resolveConcurrency(requested) {
+  if (typeof requested === "number" && requested > 0) {
+    return Math.max(1, Math.floor(requested));
+  }
+  const cores = os.cpus().length;
+  return Math.max(1, Math.min(DEFAULT_RENDER_CONCURRENCY, cores - 2));
+}
+async function renderChunksParallel(specs, options = {}) {
+  const concurrency = resolveConcurrency(options.concurrency);
+  const outer = (0, import_p_limit.default)(concurrency);
+  const manimInner = (0, import_p_limit.default)(2);
+  const startedAt = Date.now();
+  const results = new Array(specs.length);
+  let observedPeakConcurrency = 0;
+  let inFlight = 0;
+  const internalAbort = new AbortController();
+  const onCallerAbort = () => internalAbort.abort();
+  if (options.signal) {
+    if (options.signal.aborted) internalAbort.abort();
+    else options.signal.addEventListener("abort", onCallerAbort, { once: true });
+  }
+  const passThroughProgress = (event) => {
+    try {
+      options.onProgress?.(event);
+    } catch {
+    }
+  };
+  try {
+    await Promise.all(
+      specs.map(
+        (spec, idx) => outer(async () => {
+          if (internalAbort.signal.aborted) {
+            results[idx] = abortedSkeleton(spec);
+            return;
+          }
+          inFlight += 1;
+          if (inFlight > observedPeakConcurrency) observedPeakConcurrency = inFlight;
+          try {
+            const acquireManimSlot = isManimEngine(spec.engine) ? async () => {
+              let resolveAcquired;
+              const acquired = new Promise((r) => {
+                resolveAcquired = r;
+              });
+              let release;
+              const released = new Promise((r) => {
+                release = r;
+              });
+              void manimInner(async () => {
+                resolveAcquired();
+                await released;
+              });
+              await acquired;
+              return release;
+            } : void 0;
+            const result = await renderChunk(spec, {
+              onProgress: passThroughProgress,
+              signal: internalAbort.signal,
+              acquireManimSlot
+            });
+            results[idx] = result;
+            if (!result.ok && options.failFast) {
+              internalAbort.abort();
+            }
+          } catch (err) {
+            results[idx] = {
+              ok: false,
+              chunkId: spec.chunkId,
+              engine: spec.engine,
+              outputPath: "",
+              durationSec: spec.durationSec,
+              renderTimeMs: 0,
+              fallbackDepth: 0,
+              error: err instanceof Error ? err.message : String(err)
+            };
+            if (options.failFast) internalAbort.abort();
+          } finally {
+            inFlight -= 1;
+          }
+        })
+      )
+    );
+  } finally {
+    if (options.signal) options.signal.removeEventListener("abort", onCallerAbort);
+  }
+  const totalRenderTimeMs = Date.now() - startedAt;
+  const ok = results.every((r) => r?.ok);
+  if (specs.length > 0) {
+    const stub = buildLocalManifestStub(specs, results);
+    if (stub.entries.length > 0) {
+      try {
+        const root = resolveProjectRoot(specs[0].projectSlug, specs[0].outputDir);
+        writeLocalManifestStub(root, stub);
+      } catch {
+      }
+    }
+  }
+  return { ok, results, totalRenderTimeMs, observedPeakConcurrency };
+}
+function abortedSkeleton(spec) {
+  return {
+    ok: false,
+    chunkId: spec.chunkId,
+    engine: spec.engine,
+    outputPath: "",
+    durationSec: spec.durationSec,
+    renderTimeMs: 0,
+    fallbackDepth: 0,
+    error: "aborted"
+  };
+}
+
+// ../pipeline/src/qa/run-series-qa.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// ../pipeline/src/qa/types.ts
+function toGateResult(gate, findings) {
+  return { gate, passed: !findings.some((f) => f.severity === "error"), findings };
+}
+
+// ../pipeline/src/cinematic-converter/palettes.ts
+var GRADE_FLOORS = {
+  contrastMin: 1.08,
+  brightnessMin: 0.42,
+  brightnessMax: 0.82,
+  saturateDarkMin: 0.75,
+  saturateWarmMin: 1,
+  saturateMonoMin: 0.6
+};
+var PALETTE_GRADES = {
+  // ── original 6 (mirror renderer exactly; grandfathered for floors) ──
+  "poster-ink-gold": { bg: "#071C1D", contrast: 1.05, brightness: 0.58, saturate: 0.82, tone: "dark" },
+  "warm-archive-cyan": { bg: "#1D130C", contrast: 1.08, brightness: 0.7, saturate: 0.86, tone: "dark" },
+  "browser-cream-blue": { bg: "#24170D", contrast: 1.1, brightness: 0.78, saturate: 1.14, tone: "warm" },
+  "blueprint-gold": { bg: "#071724", contrast: 1.12, brightness: 0.52, saturate: 1.04, tone: "warm" },
+  "rulebook-cream-green": { bg: "#E8E3D2", contrast: 1.1, brightness: 0.82, saturate: 1.02, tone: "warm" },
+  "monochrome-accent": { bg: "#05080D", contrast: 1.14, brightness: 0.56, saturate: 0.72, tone: "mono" },
+  // ── Track-C variety palettes (floor-checked as errors) ──
+  "frost-crisis": { bg: "#0A1622", contrast: 1.14, brightness: 0.5, saturate: 0.8, tone: "dark", isNew: true },
+  "cyan-insight": { bg: "#06181E", contrast: 1.12, brightness: 0.62, saturate: 1.06, tone: "dark", isNew: true },
+  "warm-innovation": { bg: "#1C1208", contrast: 1.1, brightness: 0.66, saturate: 1.1, tone: "warm", isNew: true },
+  "triumph-gold": { bg: "#1A1405", contrast: 1.12, brightness: 0.7, saturate: 1.12, tone: "warm", isNew: true }
+};
+var ALL_PALETTES = Object.keys(PALETTE_GRADES);
+
+// ../pipeline/src/cinematic-converter/validate-grade.ts
+function saturateFloor(tone) {
+  if (tone === "warm") return GRADE_FLOORS.saturateWarmMin;
+  if (tone === "mono") return GRADE_FLOORS.saturateMonoMin;
+  return GRADE_FLOORS.saturateDarkMin;
+}
+function checkGrade(palette, g) {
+  const msgs = [];
+  if (g.contrast < GRADE_FLOORS.contrastMin) {
+    msgs.push(`contrast ${g.contrast} < ${GRADE_FLOORS.contrastMin}`);
+  }
+  if (g.brightness < GRADE_FLOORS.brightnessMin || g.brightness > GRADE_FLOORS.brightnessMax) {
+    msgs.push(`brightness ${g.brightness} outside [${GRADE_FLOORS.brightnessMin}, ${GRADE_FLOORS.brightnessMax}]`);
+  }
+  const satFloor = saturateFloor(g.tone);
+  if (g.saturate < satFloor) {
+    msgs.push(`saturate ${g.saturate} < ${satFloor} (${g.tone} floor)`);
+  }
+  return msgs;
+}
+function validatePaletteGrades(grades = PALETTE_GRADES) {
+  const violations = [];
+  for (const [palette, grade] of Object.entries(grades)) {
+    const msgs = checkGrade(palette, grade);
+    for (const message of msgs) {
+      violations.push({
+        palette,
+        // New palettes must pass; originals are grandfathered to warnings.
+        severity: grade.isNew ? "error" : "warning",
+        message
+      });
+    }
+  }
+  return { ok: !violations.some((v) => v.severity === "error"), violations };
+}
+
+// ../pipeline/src/qa/grade-floor.ts
+function gradeFloorGate(grades = PALETTE_GRADES) {
+  const { violations } = validatePaletteGrades(grades);
+  return violations.map((v) => ({
+    gate: "grade-floor",
+    severity: v.severity,
+    message: `palette ${v.palette}: ${v.message}`
+  }));
+}
+
+// ../pipeline/src/qa/motion-coverage.ts
+var GATE = "motion-asset-coverage";
+function motionAssetCoverageGate(plan) {
+  const findings = [];
+  for (const shot of plan.shots) {
+    switch (shot.source) {
+      case "photo-kenburns": {
+        if (!shot.photoSrc) {
+          findings.push({ gate: GATE, severity: "error", shotId: shot.id, message: "photo-kenburns shot has no photoSrc" });
+        }
+        break;
+      }
+      case "remotion-mg": {
+        if (!shot.mgKind) {
+          findings.push({ gate: GATE, severity: "error", shotId: shot.id, message: "remotion-mg shot has no mgKind" });
+        }
+        break;
+      }
+      case "manim":
+      case "video-broll": {
+        const clip = shot.clipId ? shot.source === "manim" ? manimClip(shot.clipId) : brollClip(shot.clipId) : void 0;
+        if (!shot.clipSrc && !clip) {
+          findings.push({
+            gate: GATE,
+            severity: "error",
+            shotId: shot.id,
+            message: shot.clipId ? `${shot.source} clipId "${shot.clipId}" not in registry` : `${shot.source} shot has neither clipSrc nor clipId`
+          });
+        } else if (clip && shot.durationInFrames > clip.durationFrames) {
+          findings.push({
+            gate: GATE,
+            severity: "warning",
+            shotId: shot.id,
+            message: `shot window ${shot.durationInFrames}f exceeds clip ${shot.clipId} (${clip.durationFrames}f) \u2014 tail freezes`
+          });
+        }
+        break;
+      }
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/luma-band.ts
+var DEFAULT_BAND = { min: 0.08, max: 0.82 };
+function lumaBandGate(samples, band = DEFAULT_BAND) {
+  const findings = [];
+  for (const sample of samples) {
+    if (sample.meanLuma < band.min) {
+      findings.push({
+        gate: "luma-band",
+        severity: "warning",
+        shotId: sample.shotId,
+        message: `near-black: shot ${sample.shotId} frame ${sample.frame} mean luma ${sample.meanLuma.toFixed(3)} < ${band.min}`
+      });
+    } else if (sample.meanLuma > band.max) {
+      findings.push({
+        gate: "luma-band",
+        severity: "warning",
+        shotId: sample.shotId,
+        message: `blown highlights: shot ${sample.shotId} frame ${sample.frame} mean luma ${sample.meanLuma.toFixed(3)} > ${band.max}`
+      });
+    }
+    if (sample.minLuma !== void 0 && sample.minLuma < 0.02) {
+      findings.push({
+        gate: "luma-band",
+        severity: "info",
+        shotId: sample.shotId,
+        message: `crushed-blacks: shot ${sample.shotId} frame ${sample.frame} min luma ${sample.minLuma.toFixed(3)} < 0.02`
+      });
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/asset-coverage.ts
+var GATE2 = "asset-coverage";
+var DOMINANT_ROLES = ["hero", "background", "cutout", "diagram"];
+function assetCoverageGate(plan) {
+  const findings = [];
+  for (const shot of plan.shots) {
+    if (shot.director?.density === "breather") continue;
+    const allowFlat = shot.director?.allowFlatStage === true;
+    const hasDominant = shot.assets?.some((a) => DOMINANT_ROLES.includes(a.role)) ?? false;
+    if (!allowFlat && shot.durationSec >= 3 && !hasDominant) {
+      findings.push({
+        gate: GATE2,
+        severity: "error",
+        shotId: shot.id,
+        message: `shot ${shot.id} (${shot.durationSec}s non-breather) has no dominant asset and is not allowFlatStage`
+      });
+    }
+    if (allowFlat && shot.durationSec > 2.5) {
+      findings.push({
+        gate: GATE2,
+        severity: "warning",
+        shotId: shot.id,
+        message: "flat stage longer than 2.5s"
+      });
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/text-contrast.ts
+var CREAM = "#FFF4D6";
+var DARK = "#071018";
+var AMBER = "#FFB547";
+var BLUEPRINT = "#F2D063";
+var FAMILY_TEXT_COLOR = {
+  "kinetic-thesis": CREAM,
+  "archive-collage": CREAM,
+  "mechanism-cutaway": CREAM,
+  "ui-system": CREAM,
+  "atlas-network": CREAM,
+  "rulebook-stamp": DARK,
+  // cream plate → dark stamp text
+  "cinematic-atmosphere": CREAM,
+  "data-payoff": AMBER
+  // amber hero, blueprint-gold variant resolved below
+};
+function relativeLuminance(hex) {
+  const m = hex.replace("#", "");
+  const r = parseInt(m.slice(0, 2), 16) / 255;
+  const g = parseInt(m.slice(2, 4), 16) / 255;
+  const b = parseInt(m.slice(4, 6), 16) / 255;
+  const lin = (c) => c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * lin(r) + 0.7152 * lin(g) + 0.0722 * lin(b);
+}
+function contrastRatio(hexA, hexB) {
+  const la = relativeLuminance(hexA);
+  const lb = relativeLuminance(hexB);
+  const lighter = Math.max(la, lb);
+  const darker = Math.min(la, lb);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function displayTextColor(shot) {
+  if (shot.family === "data-payoff" && shot.palette === "blueprint-gold") return BLUEPRINT;
+  return FAMILY_TEXT_COLOR[shot.family];
+}
+var LARGE_TEXT_MIN = 3;
+function textContrastGate(plan) {
+  const findings = [];
+  for (const shot of plan.shots) {
+    if (shot.family === "ui-system") continue;
+    const textColor = displayTextColor(shot);
+    const bg = PALETTE_GRADES[shot.palette].bg;
+    const ratio = contrastRatio(textColor, bg);
+    if (ratio < LARGE_TEXT_MIN) {
+      findings.push({
+        gate: "text-contrast",
+        severity: "error",
+        shotId: shot.id,
+        message: `display text ${textColor} on ${shot.palette} bg is ${ratio.toFixed(2)}:1 (< 3.0 WCAG large)`
+      });
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/anti-glow-lint.ts
+var GATE3 = "anti-glow-lint";
+var MAX_GLOW_BLUR = 24;
+var MAX_DROP_SHADOW_BLUR = 32;
+var SHADOW_DECL_RE = /(box-shadow|text-shadow|boxShadow|textShadow)\s*[:=]\s*(?:(['"`])([\s\S]*?)\2|([^;,\n}]+))/g;
+var CENTERED_GLOW_RE = /(?:^|,)\s*0(?:px)?\s+0(?:px)?\s+(\d+(?:\.\d+)?)px/g;
+var DROP_SHADOW_RE = /drop-shadow\(\s*([^)]*)\)/gi;
+function lineAt(content, index) {
+  return content.slice(0, index).split("\n").length;
+}
+function parseDropShadow(inner) {
+  const lengths = inner.trim().split(/\s+/).filter((t) => /^-?\d+(?:\.\d+)?(?:px)?$/.test(t)).slice(0, 3);
+  if (lengths.length < 3) return null;
+  return { x: parseFloat(lengths[0]), y: parseFloat(lengths[1]), blur: parseFloat(lengths[2]) };
+}
+function antiGlowLintGate(sources) {
+  const findings = [];
+  for (const { file, content } of sources) {
+    for (const decl of content.matchAll(SHADOW_DECL_RE)) {
+      const value = decl[3] ?? decl[4] ?? "";
+      for (const layer of value.matchAll(CENTERED_GLOW_RE)) {
+        const blur = Number(layer[1]);
+        if (blur > MAX_GLOW_BLUR) {
+          findings.push({
+            gate: GATE3,
+            severity: "error",
+            message: `${file}:${lineAt(content, decl.index)} \u2014 ${decl[1]} glow "0 0 ${layer[1]}px" exceeds max blur ${MAX_GLOW_BLUR}px (use a directional shadow)`
+          });
+        }
+      }
+    }
+    for (const ds of content.matchAll(DROP_SHADOW_RE)) {
+      const parsed = parseDropShadow(ds[1]);
+      if (!parsed) continue;
+      const centered = parsed.x === 0 && parsed.y === 0;
+      if (centered && parsed.blur > MAX_GLOW_BLUR) {
+        findings.push({
+          gate: GATE3,
+          severity: "error",
+          message: `${file}:${lineAt(content, ds.index)} \u2014 centered drop-shadow glow blur ${parsed.blur}px exceeds max ${MAX_GLOW_BLUR}px`
+        });
+      } else if (!centered && parsed.blur > MAX_DROP_SHADOW_BLUR) {
+        findings.push({
+          gate: GATE3,
+          severity: "error",
+          message: `${file}:${lineAt(content, ds.index)} \u2014 drop-shadow blur ${parsed.blur}px exceeds max ${MAX_DROP_SHADOW_BLUR}px`
+        });
+      }
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/report.ts
+var clamp = (lo, hi, v) => Math.max(lo, Math.min(hi, v));
+function buildChunkQAReport(input) {
+  const { plan, sources, lumaSamples } = input;
+  const gates = [
+    toGateResult("grade-floor", gradeFloorGate()),
+    toGateResult("asset-coverage", assetCoverageGate(plan)),
+    toGateResult("text-contrast", textContrastGate(plan))
+  ];
+  if (sources) gates.push(toGateResult("anti-glow-lint", antiGlowLintGate(sources)));
+  if (lumaSamples) gates.push(toGateResult("luma-band", lumaBandGate(lumaSamples)));
+  const findings = gates.flatMap((g) => g.findings);
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  const passed = gates.every((g) => g.passed);
+  const score = clamp(0, 100, 100 - 14 * errors - 6 * warnings - 2 * infos);
+  return { passed, score, gates, findings };
+}
+
+// ../pipeline/src/qa/guardrails-gate.ts
+var GUARDRAIL_SCORE_CAP = 50;
+var EMOJI_RE = /[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}\u{2B00}-\u{2BFF}\u{FE00}-\u{FE0F}\u{1F1E6}-\u{1F1FF}]/u;
+function cinematicShotTexts(plan) {
+  const out = [];
+  for (const s of plan.shots) {
+    const push = (t) => {
+      if (t && t.trim()) out.push({ shotId: s.id, text: t });
+    };
+    push(s.title);
+    push(s.subtitle);
+    for (const d of s.data ?? []) {
+      push(d.label);
+      push(d.value);
+    }
+    for (const w of s.wordTokens ?? []) push(w.word);
+    for (const a of s.assets ?? []) push(a.label);
+  }
+  return out;
+}
+function motionShotTexts(plan) {
+  const out = [];
+  for (const s of plan.shots) {
+    const push = (t) => {
+      if (t && t.trim()) out.push({ shotId: s.id, text: t });
+    };
+    push(s.eyebrow);
+    push(s.title);
+  }
+  return out;
+}
+function cinematicShotIsBare(plan) {
+  return plan.shots.filter((s) => {
+    const hasAsset = (s.assets?.length ?? 0) > 0;
+    const hasData = (s.data?.length ?? 0) > 0;
+    return !hasAsset && !hasData;
+  }).map((s) => s.id);
+}
+function motionShotIsBare(plan) {
+  return plan.shots.filter((s) => !s.photoSrc && !s.clipSrc && !s.clipId && !s.mgKind && !s.eyebrow?.trim() && !s.title?.trim()).map((s) => s.id);
+}
+function bansEmoji(guardrails) {
+  return guardrails.forbidden_visuals.some((v) => v.toLowerCase().includes("emoji"));
+}
+function requiresLayerFloor(guardrails) {
+  return guardrails.required.some((r) => /\blayers?\b/i.test(r));
+}
+function textMatchableForbidden(guardrails) {
+  return guardrails.forbidden_visuals.filter((v) => !v.toLowerCase().includes("emoji")).filter((v) => v.trim().split(/\s+/).length <= 4);
+}
+function guardrailsGate(seriesPlan, guardrails = dnaAiGuardrailsSchema.parse({})) {
+  const findings = [];
+  const texts = seriesPlan.kind === "cinematic" ? cinematicShotTexts(seriesPlan.plan) : motionShotTexts(seriesPlan.plan);
+  if (bansEmoji(guardrails)) {
+    for (const t of texts) {
+      if (EMOJI_RE.test(t.text)) {
+        findings.push({
+          gate: "dna-guardrails",
+          severity: "error",
+          shotId: t.shotId,
+          message: `on-screen text "${t.text.slice(0, 48)}" contains an emoji \u2014 DNA forbidden_visuals bans "emoji"; visual score capped at ${GUARDRAIL_SCORE_CAP / 10}/10`
+        });
+      }
+    }
+  }
+  const phrases = textMatchableForbidden(guardrails);
+  for (const t of texts) {
+    const lower = t.text.toLowerCase();
+    for (const phrase of phrases) {
+      if (lower.includes(phrase.toLowerCase())) {
+        findings.push({
+          gate: "dna-guardrails",
+          severity: "error",
+          shotId: t.shotId,
+          message: `on-screen text "${t.text.slice(0, 48)}" matches DNA forbidden_visuals "${phrase}"; visual score capped at ${GUARDRAIL_SCORE_CAP / 10}/10`
+        });
+      }
+    }
+  }
+  if (requiresLayerFloor(guardrails)) {
+    const bare = seriesPlan.kind === "cinematic" ? cinematicShotIsBare(seriesPlan.plan) : motionShotIsBare(seriesPlan.plan);
+    for (const shotId of bare) {
+      findings.push({
+        gate: "dna-guardrails",
+        severity: "error",
+        shotId,
+        message: `shot has no backing asset, data, or display text \u2014 cannot meet DNA required "3+ composition layers per frame"; visual score capped at ${GUARDRAIL_SCORE_CAP / 10}/10`
+      });
+    }
+  }
+  return findings;
+}
+
+// ../pipeline/src/qa/run-series-qa.ts
+var execFileP = promisify(execFile);
+var YMAX_FLOOR = 0.18;
+var DARK_SOURCES = /* @__PURE__ */ new Set(["manim", "remotion-mg"]);
+var LUMA_BAND = { min: 0.08, max: 0.82 };
+async function videoDurationSec(videoPath) {
+  try {
+    const { stdout } = await execFileP("ffprobe", [
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      videoPath
+    ]);
+    const dur = Number(stdout.trim());
+    return Number.isFinite(dur) && dur > 0 ? dur : null;
+  } catch {
+    return null;
+  }
+}
+async function frameStats(videoPath, atSec) {
+  try {
+    const { stderr, stdout } = await execFileP("ffmpeg", [
+      "-ss",
+      atSec.toFixed(2),
+      "-i",
+      videoPath,
+      "-frames:v",
+      "1",
+      "-vf",
+      "signalstats,metadata=print:file=-",
+      "-f",
+      "null",
+      "-"
+    ]);
+    const out = `${stdout}
+${stderr}`;
+    const avg = out.match(/lavfi\.signalstats\.YAVG=([\d.]+)/);
+    const max = out.match(/lavfi\.signalstats\.YMAX=([\d.]+)/);
+    if (!avg) return null;
+    return { yavg: Number(avg[1]) / 255, ymax: max ? Number(max[1]) / 255 : 1 };
+  } catch {
+    return null;
+  }
+}
+function motionWindows(plan) {
+  let cursor = 0;
+  return plan.shots.map((s) => {
+    const w = { shotId: s.id, source: s.source, startFrame: cursor, durationFrames: s.durationInFrames };
+    cursor += s.durationInFrames;
+    return w;
+  });
+}
+function cinematicWindows(plan, fps) {
+  return plan.shots.map((s) => ({
+    shotId: s.id,
+    source: "cinematic",
+    startFrame: Math.round(s.startSec * fps),
+    durationFrames: Math.max(1, Math.round(s.durationSec * fps))
+  }));
+}
+async function sampleShots(windows, videoPath, fps) {
+  const samples = [];
+  const litLuma = [];
+  const findings = [];
+  const videoDur = await videoDurationSec(videoPath);
+  for (const w of windows) {
+    const midFrame = w.startFrame + Math.max(0, Math.min(w.durationFrames * 0.5, w.durationFrames - 4));
+    let atSec = midFrame / fps;
+    if (videoDur !== null) atSec = Math.min(atSec, Math.max(0, videoDur - 0.2));
+    const frame = Math.round(atSec * fps);
+    const st = await frameStats(videoPath, atSec);
+    samples.push({ shotId: w.shotId, frame, source: w.source, yavg: st?.yavg ?? null, ymax: st?.ymax ?? null });
+    if (!st) {
+      findings.push({ gate: "luma-band", severity: "warning", shotId: w.shotId, message: `could not sample luma for ${w.shotId} (ffmpeg/parse failure)` });
+    } else if (DARK_SOURCES.has(w.source)) {
+      if (st.ymax < YMAX_FLOOR) {
+        findings.push({ gate: "luma-band", severity: "error", shotId: w.shotId, message: `dark shot ${w.shotId} YMAX ${st.ymax.toFixed(3)} < ${YMAX_FLOOR} \u2014 appears black/broken` });
+      }
+    } else {
+      litLuma.push({ shotId: w.shotId, frame, meanLuma: st.yavg });
+    }
+  }
+  if (windows.length > 0 && samples.every((s) => s.yavg === null)) {
+    findings.push({
+      gate: "luma-band",
+      severity: "error",
+      message: `no frames could be sampled from the rendered video (${windows.length} shots) \u2014 video undecodable or ffmpeg missing; failing closed`
+    });
+  }
+  return { samples, litLuma, findings };
+}
+var clamp2 = (lo, hi, v) => Math.max(lo, Math.min(hi, v));
+function scoreGates(gates) {
+  const findings = gates.flatMap((g) => g.findings);
+  const errors = findings.filter((f) => f.severity === "error").length;
+  const warnings = findings.filter((f) => f.severity === "warning").length;
+  const infos = findings.filter((f) => f.severity === "info").length;
+  let score = clamp2(0, 100, 100 - 14 * errors - 6 * warnings - 2 * infos);
+  const guardrailBreach = findings.some((f) => f.gate === "dna-guardrails" && f.severity === "error");
+  if (guardrailBreach) score = Math.min(score, GUARDRAIL_SCORE_CAP);
+  return { passed: gates.every((g) => g.passed), score, findings };
+}
+async function runSeriesQA(args) {
+  const { seriesPlan, videoPath } = args;
+  const guardrails = args.guardrails ?? dnaAiGuardrailsSchema.parse({});
+  try {
+    if (seriesPlan.kind === "motion") {
+      const plan2 = seriesPlan.plan;
+      const fps2 = plan2.fps ?? 30;
+      const { samples: samples2, litLuma: litLuma2, findings: lumaExtra2 } = await sampleShots(motionWindows(plan2), videoPath, fps2);
+      const gates2 = [
+        toGateResult("motion-asset-coverage", motionAssetCoverageGate(plan2)),
+        toGateResult("grade-floor", gradeFloorGate()),
+        toGateResult("luma-band", [...lumaBandGate(litLuma2, LUMA_BAND), ...lumaExtra2]),
+        toGateResult("dna-guardrails", guardrailsGate(seriesPlan, guardrails))
+      ];
+      const { passed: passed2, score: score2, findings: findings2 } = scoreGates(gates2);
+      return { passed: passed2, score: score2, gates: gates2, findings: findings2, samples: samples2 };
+    }
+    const plan = seriesPlan.plan;
+    const fps = plan.fps ?? 30;
+    const { samples, litLuma, findings: lumaExtra } = await sampleShots(cinematicWindows(plan, fps), videoPath, fps);
+    const base = buildChunkQAReport({ plan, lumaSamples: litLuma });
+    const gates = [
+      ...base.gates,
+      toGateResult("dna-guardrails", guardrailsGate(seriesPlan, guardrails))
+    ];
+    if (lumaExtra.length > 0) {
+      gates.push(toGateResult("luma-band-sampling", lumaExtra));
+    }
+    const { passed, score, findings } = scoreGates(gates);
+    return { passed, score, gates, findings, samples };
+  } catch (err) {
+    const finding = {
+      gate: "qa-runtime",
+      severity: "error",
+      message: `series QA crashed: ${err.message?.slice(0, 200)}`
+    };
+    return {
+      passed: false,
+      score: clamp2(0, 100, 100 - 14),
+      gates: [toGateResult("qa-runtime", [finding])],
+      findings: [finding],
+      samples: []
+    };
+  }
+}
+
+// src/author-section/payload.ts
+var AUTHOR_SECTION_KIND2 = "author-section";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function isPositiveInt(v) {
+  return typeof v === "number" && Number.isInteger(v) && v > 0;
+}
+function parseResume(v) {
+  if (v === void 0) return void 0;
+  if (typeof v !== "object" || v === null) return null;
+  const r = v;
+  if (!isNonEmptyString(r.worktreePath) || !isNonEmptyString(r.recap)) return null;
+  return { worktreePath: r.worktreePath, recap: r.recap };
+}
+function parseAuthorSectionPayload(promptText) {
+  if (typeof promptText !== "string" || !promptText.includes(`"${AUTHOR_SECTION_KIND2}"`)) {
+    return null;
+  }
+  let parsed;
+  try {
+    const raw = JSON.parse(promptText);
+    if (typeof raw !== "object" || raw === null) return null;
+    parsed = raw;
+  } catch {
+    return null;
+  }
+  if (parsed.__forgeJobKind !== AUTHOR_SECTION_KIND2) return null;
+  if (!isNonEmptyString(parsed.projectId) || !UUID_RE.test(parsed.projectId)) return null;
+  if (!isNonEmptyString(parsed.sectionKey)) return null;
+  if (!isNonEmptyString(parsed.brief)) return null;
+  if (!isNonEmptyString(parsed.lawsPackVersion)) return null;
+  if (!isNonEmptyString(parsed.wordsJsonRef)) return null;
+  if (!isPositiveInt(parsed.framesExact)) return null;
+  if (!isNonEmptyString(parsed.worldAssignment)) return null;
+  if (!isNonEmptyString(parsed.baseSha) || parsed.baseSha.length < 7) return null;
+  if (!Array.isArray(parsed.avSyncPayoffWords) || parsed.avSyncPayoffWords.length !== 3 || !parsed.avSyncPayoffWords.every((w) => typeof w === "string")) {
+    return null;
+  }
+  const payoff = parsed.avSyncPayoffWords;
+  let beats = [];
+  if (parsed.beats !== void 0) {
+    if (!Array.isArray(parsed.beats)) return null;
+    beats = parsed.beats;
+  }
+  let callbackRefs = [];
+  if (parsed.callbackRefs !== void 0) {
+    if (!Array.isArray(parsed.callbackRefs) || !parsed.callbackRefs.every((c) => typeof c === "string")) {
+      return null;
+    }
+    callbackRefs = parsed.callbackRefs;
+  }
+  if (parsed.lawsMd !== void 0 && typeof parsed.lawsMd !== "string") return null;
+  if (parsed.roundId !== void 0 && (!isNonEmptyString(parsed.roundId) || !UUID_RE.test(parsed.roundId))) {
+    return null;
+  }
+  const resume = parseResume(parsed.resume);
+  if (resume === null) return null;
+  return {
+    __forgeJobKind: AUTHOR_SECTION_KIND2,
+    projectId: parsed.projectId,
+    sectionKey: parsed.sectionKey,
+    brief: parsed.brief,
+    lawsPackVersion: parsed.lawsPackVersion,
+    ...parsed.lawsMd !== void 0 ? { lawsMd: parsed.lawsMd } : {},
+    wordsJsonRef: parsed.wordsJsonRef,
+    beats,
+    framesExact: parsed.framesExact,
+    callbackRefs,
+    worldAssignment: parsed.worldAssignment,
+    avSyncPayoffWords: payoff,
+    baseSha: parsed.baseSha,
+    ...parsed.roundId !== void 0 ? { roundId: parsed.roundId } : {},
+    ...resume ? { resume } : {}
+  };
+}
+
+// src/author-section/worker.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import * as fs24 from "fs";
+import * as path20 from "path";
+
+// src/author-section/prompt-template.ts
+var FPS = 30;
+function suggestedComponentBase(sectionKey) {
+  const cleaned = sectionKey.replace(/[^A-Za-z0-9]+/g, " ").trim();
+  const pascal = cleaned.split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+  return `Kv${pascal || "Section"}`;
+}
+function renderLawsSection(opts) {
+  const { lawsPackVersion, lawsMd, worldAssignment } = opts;
+  if (lawsMd && lawsMd.trim()) {
+    const parts = [`## THE LAWS (laws pack ${lawsPackVersion})`, "", lawsMd, ""];
+    if (worldAssignment) {
+      parts.push(`Home world for THIS section: ${worldAssignment}.`, "");
+    }
+    return parts;
+  }
+  const world = worldAssignment ?? "inherited from the source section";
+  return [
+    `## THE LAWS (laws pack ${lawsPackVersion})`,
+    "",
+    `1. FRAME RATION \u2014 \u226435% of beats may use ANY framed container (card, browser, chat window, terminal, receipt, floating panel). Everything else is full-bleed mechanism drawn directly on the bed, or camera-space (dolly/zoom-through/push-in). Consecutive same-scene-type \u22642 beats; use \u22654 distinct scene types. One framed-artifact beat is the budget (only when the frame IS the evidence \u2014 a real paper/pricing page).`,
+    `2. TEACH-FIRST \u2014 ONE continuous animated mechanism that EVOLVES across the whole section. The camera moves into details; states MORPH; nothing resets to a fresh card. Concrete subjects, never abstract boxes labeled "K/V".`,
+    `3. ZERO-OVERSHOOT MOTION \u2014 \u22643 concurrent events/sec, all eased: morphs between diagram states, draw-on paths, traveling dots along arcs, masked wipes, block stacking/merging, counting meters, page turns, camera dolly/push. NO springs, NO pops.`,
+    `4. AV-SYNC LAW \u2014 visuals may LEAD the spoken word by \u22641s and NEVER LAG it. Every spoken number/name/object is on screen within 15 frames of its word; if a caption window opens before the visual's natural entrance, pull the visual EARLIER. No beat opens on an empty stage: \u22651 meaningful subject within 12 frames of every beat boundary (a carry-over element counts). Captions render only inside their resolved windows, as verbatim scrim pills.`,
+    `5. ONE CRAFT PEAK \u2014 the section contains ONE moment worth screenshotting; name it in the report. No two consecutive sections share a home world; if a device already appeared earlier in the film, EVOLVE it (bigger, recontextualized, or inverted).`,
+    `6. WORLD + SLOP \u2014 home world = ${world}. No photoreal beds outside proven subject classes (chip die / datacenter aisle / HBM tower \u2014 subject-full-bleed only); the dead "detective door" class stays dead. No emoji, no glow text, no gradient badges. ALL type via the kit's T.* roles (type-lint enforces \u2014 never a bare fontSize/letterSpacing literal).`,
+    ""
+  ];
+}
+function buildAuthorSectionPrompt(payload) {
+  const {
+    sectionKey,
+    lawsPackVersion,
+    worldAssignment,
+    framesExact,
+    wordsJsonRef,
+    brief,
+    beats,
+    callbackRefs,
+    avSyncPayoffWords
+  } = payload;
+  const suggested = suggestedComponentBase(sectionKey);
+  const callbackList = callbackRefs.length ? callbackRefs.join(", ") : "(none provided)";
+  const beatsJson = JSON.stringify(beats, null, 2);
+  const [p0, p1, p2] = avSyncPayoffWords;
+  const parts = [];
+  if (payload.resume) {
+    parts.push(
+      `RESUME: a previous attempt stopped here \u2014 ${payload.resume.recap}. The worktree already contains that attempt's state; continue, do not start over.`,
+      ""
+    );
+  }
+  parts.push(
+    `# Author ONE bespoke film section: ${sectionKey}`,
+    "",
+    `You are authoring ONE bespoke film section (${sectionKey}) as a Remotion component in THIS git worktree. This is the productized version of the manual v15 craft loop: one section, authored (not assembled from templates), self-verified, committed. Work only inside this worktree; never push.`,
+    ""
+  );
+  parts.push(...renderLawsSection({ lawsPackVersion, lawsMd: payload.lawsMd, worldAssignment }));
+  parts.push(
+    `## THE SECTION`,
+    "",
+    `EXACT LENGTH: ${framesExact} frames at ${FPS} fps. Export a frames constant that EQUALS ${framesExact} (e.g. \`export const <NAME>_FRAMES = ${framesExact};\`). The section must render exactly this many frames \u2014 not one more, not one fewer.`,
+    "",
+    `WORDS (the anchor source \u2014 every visual phase change is triggered by these narration timings): ${wordsJsonRef}`,
+    "",
+    `STYLE CALLBACKS \u2014 study these already-authored bespoke components FIRST, to inherit the grammar and evolve (never copy) their devices: ${callbackList}`,
+    "",
+    `BRIEF (verbatim):`,
+    "",
+    brief,
+    "",
+    `RESOLVED BEATS (verbatim \u2014 caption windows + modes; these are your beat boundaries):`,
+    "",
+    "```json",
+    beatsJson,
+    "```",
+    ""
+  );
+  parts.push(
+    `## MECHANICS`,
+    "",
+    `- Author \`packages/remotion/src/bespoke/v15/<ComponentName>.tsx\`. Choose a descriptive PascalCase ComponentName for this section (suggested: \`${suggested}\`).`,
+    `- Import ONLY from '../../kit' (tokens, T.* roles, primitives). Never touch the dark '../../toolkit' effects; never import the frozen oracle (KvOpening.tsx).`,
+    `- Self-register the mechanism scene via \`registerBespokeScene(<id>, <Component>)\` (see packages/remotion/src/kit/bespoke-registry.tsx).`,
+    `- Export the \`<ComponentName>Film\` wrapper component AND the frames constant (= ${framesExact}).`,
+    `- Add the side-effect import for your new file to packages/remotion/src/kit/index.ts (one \`import '../bespoke/v15/<ComponentName>';\` line in the registration manifest).`,
+    `- Do NOT touch any Root*.tsx BESPOKE table (the orchestrator integrates that). Do NOT touch other sections. Do NOT install dependencies. Never push.`,
+    ""
+  );
+  parts.push(
+    `## SELF-VERIFY (LAW 4.4 \u2014 prove the sync, don't assume it)`,
+    "",
+    `Render verification stills at each beat boundary AND at the timestamps of the 3 payoff words below. For each payoff word, read its start time from the words JSON (${wordsJsonRef}) and compute frame = round(wordStartSeconds \xD7 ${FPS}), SECTION-RELATIVE (the section starts at frame 0). Study docs/loop/v15/render/ for the still-render tooling. Confirm the payoff visual is PRESENT in those exact frames; if it lags its word, pull the visual earlier and re-render. Iterate until every payoff visual lands on time.`,
+    "",
+    `PAYOFF WORDS (biggest 3): "${p0}", "${p1}", "${p2}".`,
+    ""
+  );
+  parts.push(
+    `## GATES (both must exit 0 \u2014 check the real exit codes, never a piped tail)`,
+    "",
+    `1. \`cd packages/remotion && npx tsc --noEmit\` \u2192 exit 0.`,
+    `2. \`node scripts/type-lint.mjs\` from the worktree ROOT \u2192 exit 0.`,
+    "Fix every error until both gates are green.",
+    ""
+  );
+  parts.push(
+    `## COMMIT + REPORT`,
+    "",
+    `Commit EVERYTHING you authored as ONE conventional commit (e.g. \`feat(section): author ${sectionKey}\`). Do NOT add any attribution / Co-Authored-By / "generated with" lines.`,
+    "",
+    `Then write the lane report to \`<worktree>/.forge-lane-report.json\` (worktree root). It MUST be valid JSON with EXACTLY these fields:`,
+    "",
+    "```json",
+    JSON.stringify(
+      {
+        kind: "author-section",
+        sectionKey,
+        projectId: payload.projectId,
+        commitSha: "<full sha of your single commit>",
+        worktreePath: "<absolute path of this worktree>",
+        componentRef: "<exported *Film component name>",
+        frames: framesExact,
+        gates: {
+          tsc: { exit: 0, summary: "<one line>" },
+          typeLint: { exit: 0, summary: "<one line>" }
+        },
+        evidenceFrames: [{ frame: 0, path: "<abs path to still>", label: "<optional>" }],
+        craftPeak: { frame: 0, label: "<name the screenshot-worthy moment>" },
+        summary: "<one-line lane report>",
+        costUsd: null,
+        ...payload.roundId ? { roundId: payload.roundId } : {}
+      },
+      null,
+      2
+    ),
+    "```",
+    "",
+    `evidenceFrames must include the payoff-word frames you verified (and the craft-peak frame). craftPeak.frame is the frame number of your ONE craft peak (or null if you cannot pin one); craftPeak.label names it. costUsd: report the real token cost if you can honestly measure it; otherwise leave it null and the worker fills a wall-time estimate.`
+  );
+  return parts.join("\n");
+}
+
+// src/author-section/report.ts
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function str(v) {
+  return typeof v === "string" && v.length > 0;
+}
+function int(v) {
+  return typeof v === "number" && Number.isInteger(v);
+}
+function parseGate(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const g = v;
+  if (!int(g.exit)) return null;
+  const summary = g.summary === void 0 ? "" : g.summary;
+  if (typeof summary !== "string") return null;
+  return { exit: g.exit, summary };
+}
+function parseEvidenceFrames(v) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v)) return null;
+  const out = [];
+  for (const el of v) {
+    if (typeof el !== "object" || el === null) return null;
+    const e = el;
+    if (!int(e.frame) || !str(e.path)) return null;
+    const frame = { frame: e.frame, path: e.path };
+    if (e.storjKey !== void 0) {
+      if (typeof e.storjKey !== "string") return null;
+      frame.storjKey = e.storjKey;
+    }
+    if (e.label !== void 0) {
+      if (typeof e.label !== "string") return null;
+      frame.label = e.label;
+    }
+    out.push(frame);
+  }
+  return out;
+}
+function parseAuthorSectionReportFile(text) {
+  let raw;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    raw = parsed;
+  } catch {
+    return null;
+  }
+  if (raw.kind !== "author-section") return null;
+  if (!str(raw.sectionKey)) return null;
+  if (!str(raw.projectId) || !UUID_RE2.test(raw.projectId)) return null;
+  if (!str(raw.commitSha) || raw.commitSha.length < 7) return null;
+  if (!str(raw.worktreePath)) return null;
+  if (!str(raw.componentRef)) return null;
+  if (typeof raw.frames !== "number" || !Number.isInteger(raw.frames) || raw.frames <= 0) return null;
+  if (typeof raw.gates !== "object" || raw.gates === null) return null;
+  const gatesObj = raw.gates;
+  const tsc = parseGate(gatesObj.tsc);
+  const typeLint = parseGate(gatesObj.typeLint);
+  if (!tsc || !typeLint) return null;
+  if (typeof raw.craftPeak !== "object" || raw.craftPeak === null) return null;
+  const cp = raw.craftPeak;
+  const cpFrame = cp.frame === null ? null : int(cp.frame) ? cp.frame : void 0;
+  if (cpFrame === void 0) return null;
+  if (!str(cp.label)) return null;
+  const evidenceFrames = parseEvidenceFrames(raw.evidenceFrames);
+  if (evidenceFrames === null) return null;
+  const summary = raw.summary === void 0 ? "" : raw.summary;
+  if (typeof summary !== "string") return null;
+  let costUsd = null;
+  if (raw.costUsd !== void 0) {
+    if (raw.costUsd !== null && typeof raw.costUsd !== "number") return null;
+    costUsd = raw.costUsd;
+  }
+  if (raw.roundId !== void 0 && (!str(raw.roundId) || !UUID_RE2.test(raw.roundId))) return null;
+  return {
+    kind: "author-section",
+    sectionKey: raw.sectionKey,
+    projectId: raw.projectId,
+    commitSha: raw.commitSha,
+    worktreePath: raw.worktreePath,
+    componentRef: raw.componentRef,
+    frames: raw.frames,
+    gates: { tsc, typeLint },
+    evidenceFrames,
+    craftPeak: { frame: cpFrame, label: cp.label },
+    summary,
+    costUsd,
+    ...raw.roundId !== void 0 ? { roundId: raw.roundId } : {}
+  };
+}
+
+// src/author-section/worktree.ts
+import { spawnSync } from "child_process";
+import * as crypto from "crypto";
+import * as fs23 from "fs";
+import * as path19 from "path";
+function resolveRepoRoot() {
+  const explicit = process.env.FORGE_REPO_ROOT?.trim();
+  if (explicit) {
+    if (!isGitWorkTree(explicit)) {
+      throw new Error(`FORGE_REPO_ROOT=${explicit} is not a git work tree`);
+    }
+    return path19.resolve(explicit);
+  }
+  const cwd = process.cwd();
+  if (!isGitWorkTree(cwd)) {
+    throw new Error(
+      `author-section: no repo root \u2014 cwd (${cwd}) is not a git work tree and FORGE_REPO_ROOT is unset`
+    );
+  }
+  return path19.resolve(cwd);
+}
+function isGitWorkTree(dir) {
+  const r = spawnSync("git", ["-C", dir, "rev-parse", "--is-inside-work-tree"], {
+    encoding: "utf-8",
+    timeout: 5e3
+  });
+  return r.status === 0 && (r.stdout ?? "").trim() === "true";
+}
+var SYMLINK_CANDIDATES = [
+  "node_modules",
+  "packages/remotion/node_modules",
+  "packages/pipeline/node_modules",
+  ".env",
+  ".env.local",
+  "apps/web/.env.local",
+  "assets",
+  "packages/remotion/public",
+  "apps/web/public"
+];
+function createLaneWorktree(args, resume) {
+  if (resume) {
+    const wt = path19.resolve(resume.worktreePath);
+    const lanesRoot = path19.resolve(args.repoRoot, ".forge-lanes") + path19.sep;
+    if (!wt.startsWith(lanesRoot)) {
+      throw new Error(
+        `resume worktree ${wt} is outside ${lanesRoot} \u2014 refusing to run a lane in an uncontained path`
+      );
+    }
+    if (!fs23.existsSync(wt)) {
+      throw new Error(`resume worktree gone: ${wt} \u2014 cannot re-enter a failed lane whose worktree was deleted`);
+    }
+    log.info(`[author-section] resuming in surviving worktree ${wt}`);
+    return { worktreePath: wt, reused: true };
+  }
+  const shortId = crypto.randomBytes(3).toString("hex");
+  const safeKey = args.sectionKey.replace(/[^A-Za-z0-9._-]/g, "_");
+  const worktreePath = path19.join(args.repoRoot, ".forge-lanes", `${safeKey}-${shortId}`);
+  fs23.mkdirSync(path19.dirname(worktreePath), { recursive: true });
+  const add = spawnSync(
+    "git",
+    ["-C", args.repoRoot, "worktree", "add", worktreePath, args.baseSha],
+    { encoding: "utf-8", timeout: 12e4 }
+  );
+  if (add.status !== 0) {
+    throw new Error(
+      `git worktree add failed (exit ${add.status}): ${(add.stderr ?? add.stdout ?? "").trim().slice(-400)}`
+    );
+  }
+  let linked = 0;
+  for (const rel of SYMLINK_CANDIDATES) {
+    linked += linkMissing(args.repoRoot, worktreePath, rel);
+  }
+  log.info(`[author-section] worktree ${worktreePath} ready (${linked} symlink(s))`);
+  return { worktreePath, reused: false };
+}
+function linkMissing(repoRoot, worktreeRoot, rel, depth = 0) {
+  const target = path19.join(repoRoot, rel);
+  const dest = path19.join(worktreeRoot, rel);
+  let targetStat;
+  try {
+    targetStat = fs23.statSync(target);
+  } catch {
+    return 0;
+  }
+  if (!fs23.existsSync(dest)) {
+    try {
+      fs23.mkdirSync(path19.dirname(dest), { recursive: true });
+      fs23.symlinkSync(target, dest, targetStat.isDirectory() ? "dir" : "file");
+      return 1;
+    } catch (err) {
+      log.warn(`[author-section] symlink ${rel} failed: ${err.message}`);
+      return 0;
+    }
+  }
+  const destLstat = fs23.lstatSync(dest);
+  if (destLstat.isSymbolicLink() || !targetStat.isDirectory() || !destLstat.isDirectory()) {
+    return 0;
+  }
+  if (path19.basename(rel) === "node_modules" || depth >= 6) return 0;
+  let count = 0;
+  let children;
+  try {
+    children = fs23.readdirSync(target);
+  } catch {
+    return 0;
+  }
+  for (const child of children) {
+    count += linkMissing(repoRoot, worktreeRoot, path19.join(rel, child), depth + 1);
+  }
+  return count;
+}
+
+// src/author-section/cost.ts
+var FLOOR_USD = 0.01;
+var LANE_USD_PER_HOUR = {
+  opus: 9,
+  sonnet: 3,
+  haiku: 0.9
+};
+function ratePerHour(model) {
+  const m = (model || "").toLowerCase();
+  if (m.includes("haiku")) return LANE_USD_PER_HOUR.haiku;
+  if (m.includes("sonnet")) return LANE_USD_PER_HOUR.sonnet;
+  return LANE_USD_PER_HOUR.opus;
+}
+function roundCents(usd) {
+  return Math.round(usd * 100) / 100;
+}
+function parseCostSignal(output) {
+  if (!output) return null;
+  const field = output.match(/"?total_cost_usd"?\s*[:=]\s*(\d+(?:\.\d+)?)/i);
+  if (field) {
+    const n = Number(field[1]);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const labelled = output.match(/(?:total\s+)?cost\s*[:=]?\s*\$\s*(\d+(?:\.\d+)?)/i);
+  if (labelled) {
+    const n = Number(labelled[1]);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return null;
+}
+function estimateLaneCostUsd(args) {
+  const signal = parseCostSignal(args.capturedOutput);
+  if (signal !== null) {
+    return Math.max(FLOOR_USD, roundCents(signal));
+  }
+  const elapsedMs = Math.max(0, args.endMs - args.startMs);
+  const hours = elapsedMs / 36e5;
+  const raw = hours * ratePerHour(args.model);
+  return Math.max(FLOOR_USD, roundCents(raw));
+}
+function fillReportCostUsd(reportText, costUsd) {
+  try {
+    const obj = JSON.parse(reportText);
+    obj.costUsd = costUsd;
+    return JSON.stringify(obj, null, 2);
+  } catch {
+    return reportText;
+  }
+}
+
+// src/author-section/worker.ts
+var REPORT_FILENAME = ".forge-lane-report.json";
+var LANE_TAIL_KEEP = 4e3;
+var MODEL_RE = /^[a-z0-9.\-]+$/i;
+var cachedPermissionArgs = null;
+function resolveClaudePermissionArgs() {
+  if (cachedPermissionArgs) return cachedPermissionArgs;
+  let help = "";
+  try {
+    const r = spawnSync2("claude", ["--help"], { encoding: "utf-8", timeout: 1e4 });
+    help = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+  } catch {
+    help = "";
+  }
+  if (help.includes("--dangerously-skip-permissions")) {
+    cachedPermissionArgs = ["--dangerously-skip-permissions"];
+  } else if (help.includes("--permission-mode")) {
+    cachedPermissionArgs = ["--permission-mode", "bypassPermissions"];
+  } else {
+    cachedPermissionArgs = ["--dangerously-skip-permissions"];
+  }
+  return cachedPermissionArgs;
+}
+async function postJobProgress(ctx, step, note, tag = "author-section") {
+  try {
+    const resp = await fetch(`${ctx.baseUrl}/api/cli-bridge/job-progress`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${ctx.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ jobId: ctx.jobId, step, ...note ? { note } : {} }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!resp.ok && resp.status !== 404) {
+      log.warn(`[${tag}] job-progress '${step}' HTTP ${resp.status}`);
+    }
+  } catch {
+  }
+}
+async function invokeAuthorSection(payload, ctx) {
+  let worktreePath;
+  try {
+    const repoRoot = resolveRepoRoot();
+    const wt = createLaneWorktree(
+      { repoRoot, baseSha: payload.baseSha, sectionKey: payload.sectionKey },
+      payload.resume
+    );
+    worktreePath = wt.worktreePath;
+  } catch (err) {
+    return { error: `author-section worktree setup failed: ${err.message}` };
+  }
+  await postJobProgress(ctx, "brief", `worktree ready: ${worktreePath}`);
+  const prompt = buildAuthorSectionPrompt(payload);
+  const model = ctx.model && MODEL_RE.test(ctx.model) ? ctx.model : "opus";
+  const args = [
+    "-p",
+    "--model",
+    model,
+    "--no-session-persistence",
+    ...resolveClaudePermissionArgs()
+  ];
+  let laneTail = "";
+  const capture = (buf) => {
+    laneTail = (laneTail + buf.toString("utf-8")).slice(-LANE_TAIL_KEEP);
+  };
+  const onSpawn = (child) => {
+    ctx.registerChild(child);
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+  };
+  await postJobProgress(ctx, "authoring", `spawning claude:${model} in worktree`);
+  log.info(`[author-section] authoring ${payload.sectionKey} \xB7 claude:${model} \xB7 ${worktreePath}`);
+  const laneStartMs = Date.now();
+  let laneError = "";
+  try {
+    await ctx.runSpawn("claude", args, prompt, ctx.timeoutMs, onSpawn, worktreePath);
+  } catch (err) {
+    laneError = err.message;
+  }
+  const laneEndMs = Date.now();
+  await postJobProgress(ctx, "gates", "reading lane report");
+  const reportPath = path20.join(worktreePath, REPORT_FILENAME);
+  let reportText = "";
+  try {
+    reportText = fs24.readFileSync(reportPath, "utf-8");
+  } catch {
+    return {
+      error: authorSectionFailureText(worktreePath, laneError, laneTail, `no report at ${reportPath}`)
+    };
+  }
+  const report = parseAuthorSectionReportFile(reportText);
+  if (!report) {
+    return {
+      error: authorSectionFailureText(worktreePath, laneError, laneTail, `report at ${reportPath} is invalid`)
+    };
+  }
+  let resultText = reportText;
+  if (report.costUsd === null) {
+    const costUsd = estimateLaneCostUsd({
+      startMs: laneStartMs,
+      endMs: laneEndMs,
+      cli: "claude",
+      model,
+      capturedOutput: laneTail
+    });
+    resultText = fillReportCostUsd(reportText, costUsd);
+  }
+  await postJobProgress(ctx, "committed", report.summary || `authored ${payload.sectionKey}`);
+  log.success(`[author-section] ${payload.sectionKey} authored \xB7 ${report.componentRef} \xB7 ${report.commitSha.slice(0, 8)}`);
+  return { text: resultText, modelUsed: `claude-lane:${model}` };
 }
-function implicitShot(spec) {
+function authorSectionFailureText(worktreePath, laneError, laneTail, reason, label = "author-section") {
+  const tail = laneTail.slice(-2e3);
+  return [
+    `${label} lane failed: ${reason}.`,
+    `worktreePath=${worktreePath}`,
+    laneError ? `laneExit=${laneError}` : "",
+    "--- last lane output (tail) ---",
+    tail || "(no output captured)"
+  ].filter(Boolean).join("\n");
+}
+
+// src/author-short/payload.ts
+var AUTHOR_SHORT_KIND2 = "author-short";
+var FRAMES_MAX_CAP = 1800;
+var VERTICAL_SAFE_ZONES2 = Object.freeze({
+  top: 170,
+  bottom: 370,
+  left: 40,
+  right: 150,
+  captionY: 450
+});
+function isNonNegInt(v) {
+  return typeof v === "number" && Number.isInteger(v) && v >= 0;
+}
+function isNonNegNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 0;
+}
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function parseVoWindow(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const w = v;
+  if (!isNonNegNumber(w.startSec)) return null;
+  if (!isPositiveNumber(w.endSec)) return null;
+  if (!(w.startSec < w.endSec)) return null;
+  return { startSec: w.startSec, endSec: w.endSec };
+}
+function parseSafeZones(v) {
+  if (v === void 0) return { ...VERTICAL_SAFE_ZONES2 };
+  if (typeof v !== "object" || v === null) return null;
+  const s = v;
+  const keys = ["top", "bottom", "left", "right", "captionY"];
+  for (const k of keys) {
+    if (!isNonNegInt(s[k])) return null;
+  }
   return {
-    id: "shot0",
-    startSec: 0,
-    durationSec: spec.durationSec
+    top: s.top,
+    bottom: s.bottom,
+    left: s.left,
+    right: s.right,
+    captionY: s.captionY
+  };
+}
+function parseAuthorShortPayload(promptText) {
+  if (typeof promptText !== "string" || !promptText.includes(`"${AUTHOR_SHORT_KIND2}"`)) {
+    return null;
+  }
+  let parsed;
+  try {
+    const raw = JSON.parse(promptText);
+    if (typeof raw !== "object" || raw === null) return null;
+    parsed = raw;
+  } catch {
+    return null;
+  }
+  if (parsed.__forgeJobKind !== AUTHOR_SHORT_KIND2) return null;
+  if (!isNonEmptyString(parsed.projectId) || !UUID_RE.test(parsed.projectId)) return null;
+  if (!isNonEmptyString(parsed.shortId) || !UUID_RE.test(parsed.shortId)) return null;
+  if (!isNonEmptyString(parsed.sectionKey)) return null;
+  if (!isNonEmptyString(parsed.peakLabel)) return null;
+  if (!isNonEmptyString(parsed.brief)) return null;
+  if (!isNonEmptyString(parsed.lawsPackVersion)) return null;
+  if (!isNonEmptyString(parsed.wordsJsonRef)) return null;
+  if (!isNonEmptyString(parsed.baseSha) || parsed.baseSha.length < 7) return null;
+  let peakFrame = null;
+  if (parsed.peakFrame !== void 0 && parsed.peakFrame !== null) {
+    if (typeof parsed.peakFrame !== "number" || !Number.isInteger(parsed.peakFrame)) return null;
+    peakFrame = parsed.peakFrame;
+  }
+  const voWindow = parseVoWindow(parsed.voWindow);
+  if (!voWindow) return null;
+  let framesMax = FRAMES_MAX_CAP;
+  if (parsed.framesMax !== void 0) {
+    if (!isPositiveInt(parsed.framesMax) || parsed.framesMax > FRAMES_MAX_CAP) return null;
+    framesMax = parsed.framesMax;
+  }
+  if (parsed.aspect !== void 0 && parsed.aspect !== "9:16") return null;
+  const safeZones = parseSafeZones(parsed.safeZones);
+  if (!safeZones) return null;
+  let callbackRefs = [];
+  if (parsed.callbackRefs !== void 0) {
+    if (!Array.isArray(parsed.callbackRefs) || !parsed.callbackRefs.every((c) => typeof c === "string")) {
+      return null;
+    }
+    callbackRefs = parsed.callbackRefs;
+  }
+  if (parsed.lawsMd !== void 0 && typeof parsed.lawsMd !== "string") return null;
+  const resume = parseResume(parsed.resume);
+  if (resume === null) return null;
+  return {
+    __forgeJobKind: AUTHOR_SHORT_KIND2,
+    projectId: parsed.projectId,
+    shortId: parsed.shortId,
+    sectionKey: parsed.sectionKey,
+    peakLabel: parsed.peakLabel,
+    peakFrame,
+    brief: parsed.brief,
+    lawsPackVersion: parsed.lawsPackVersion,
+    ...parsed.lawsMd !== void 0 ? { lawsMd: parsed.lawsMd } : {},
+    wordsJsonRef: parsed.wordsJsonRef,
+    voWindow,
+    framesMax,
+    aspect: "9:16",
+    safeZones,
+    callbackRefs,
+    baseSha: parsed.baseSha,
+    ...resume ? { resume } : {}
   };
 }
 
-// ../pipeline/src/clip-render/orchestrator.ts
-var import_p_limit = __toESM(require_p_limit());
-import * as os from "os";
+// src/author-short/worker.ts
+import * as fs25 from "fs";
+import * as path21 from "path";
 
-// ../pipeline/src/clip-render/manifest.ts
-import * as fs17 from "fs";
-import * as path15 from "path";
-function buildLocalManifestStub(specs, results, now = () => /* @__PURE__ */ new Date()) {
-  const specByChunk = new Map(specs.map((s) => [s.chunkId, s]));
-  const entries = [];
-  for (const r of results) {
-    if (!r.ok || !r.outputPath) continue;
-    const spec = specByChunk.get(r.chunkId);
-    if (!spec) continue;
-    let size = 0;
-    try {
-      const stat = fs17.statSync(r.outputPath);
-      if (stat.isFile()) size = stat.size;
-    } catch {
-      continue;
-    }
-    if (size === 0) continue;
-    entries.push({
-      kind: "clips",
-      chunkId: r.chunkId,
-      ext: "mp4",
-      size,
-      localPath: r.outputPath,
-      aspect: spec.aspect
-    });
+// src/author-short/prompt-template.ts
+var FPS2 = 30;
+var WIDTH = 1080;
+var HEIGHT = 1920;
+function buildAuthorShortPrompt(payload) {
+  const {
+    sectionKey,
+    peakLabel,
+    peakFrame,
+    lawsPackVersion,
+    lawsMd,
+    framesMax,
+    wordsJsonRef,
+    brief,
+    callbackRefs,
+    voWindow,
+    safeZones
+  } = payload;
+  const { top, bottom, left, right, captionY } = safeZones;
+  const maxSeconds = Math.round(framesMax / FPS2 * 10) / 10;
+  const suggested = `${suggestedComponentBase(sectionKey)}Short`;
+  const callbackList = callbackRefs.length ? callbackRefs.join(", ") : "(none provided)";
+  const peakFrameNote = peakFrame === null ? "frame not pinned" : `source frame ${peakFrame}`;
+  const parts = [];
+  if (payload.resume) {
+    parts.push(
+      `RESUME: a previous attempt stopped here \u2014 ${payload.resume.recap}. The worktree already contains that attempt's state; continue, do not start over.`,
+      ""
+    );
   }
-  return { writtenAt: now().toISOString(), version: 1, entries };
-}
-function localManifestStubPath(root) {
-  return path15.join(root, "manifest.local.json");
-}
-function writeLocalManifestStub(root, stub) {
-  fs17.mkdirSync(root, { recursive: true });
-  const target = localManifestStubPath(root);
-  const tmp = `${target}.tmp-${process.pid}`;
-  fs17.writeFileSync(tmp, JSON.stringify(stub, null, 2));
-  fs17.renameSync(tmp, target);
-  return target;
+  parts.push(
+    `# Author ONE vertical short: re-stage the ${sectionKey} craft peak`,
+    "",
+    `You are authoring ONE bespoke VERTICAL short (${WIDTH}\xD7${HEIGHT}, 9:16, ${FPS2} fps) as a Remotion component in THIS git worktree. It RE-STAGES the section's craft peak \u2014 "${peakLabel}" from ${sectionKey} (${peakFrameNote}) \u2014 as its OWN composition: a portrait-native regeneration, NOT a reframing of the 16:9 section. Work only inside this worktree; never push.`,
+    ""
+  );
+  parts.push(...renderLawsSection({ lawsPackVersion, lawsMd }));
+  parts.push(
+    `## VERTICAL LAWS (portrait re-stage \u2014 these ALWAYS apply, on top of the craft laws)`,
+    "",
+    `- HARD SAFE ZONES (px at ${WIDTH}\xD7${HEIGHT}): every meaningful element stays inside a frame inset of top ${top}, bottom ${bottom}, left ${left}, right ${right}. Nothing that carries meaning may enter those edge bands. Captions are anchored at y \u2265 ${captionY} from the bottom (inside the caption zone) \u2014 never above it.`,
+    `- LENGTH: \u226460s (\u2264${framesMax} frames at ${FPS2} fps, \u2248${maxSeconds}s). Export a frames constant EQUAL to the short's ACTUAL length (\u2264 ${framesMax}) \u2014 do NOT pad to the cap.`,
+    `- REGEN-NATIVE (the \xA710 shorts law \u2014 "NEVER crop horizontal. Regenerate natively."): study the source component (${callbackList}) and RE-STAGE its mechanism for a portrait composition. NEVER letterbox, NEVER crop, NEVER scale the 16:9 layout into 9:16. Re-lay the mechanism for the tall frame: stack what was side-by-side, enlarge the hero, drop secondary beats, re-time to shorts pacing.`,
+    `- OWN CAPTION STYLE: the short owns its caption treatment \u2014 BIGGER scrim pills than the long-form, still the VERBATIM spoken words, rendered ONLY inside the caption zone (y \u2265 ${captionY}).`,
+    `- OPEN ON ACTION: a short has no runway \u2014 \u22651 meaningful subject is already in motion within 12 frames of frame 0. No cold open on an empty stage.`,
+    ""
+  );
+  parts.push(
+    `## THE MOMENT`,
+    "",
+    `WORDS (the anchor source \u2014 the word-anchor law still holds; every spoken number/name/object is on screen within 15 frames of its word): ${wordsJsonRef}`,
+    "",
+    `VO WINDOW: the peak's spoken line runs ${voWindow.startSec}s\u2013${voWindow.endSec}s in ${wordsJsonRef}. Read the words inside that window \u2014 those are the short's captions and its sync anchors. Frames are SHORT-RELATIVE (the short starts at frame 0): frame = round((wordStartSeconds \u2212 ${voWindow.startSec}) \xD7 ${FPS2}).`,
+    "",
+    `STYLE CALLBACKS \u2014 study these already-authored bespoke components FIRST, then RE-STAGE (never copy, never crop) their device for the portrait frame: ${callbackList}`,
+    "",
+    `BRIEF (verbatim):`,
+    "",
+    brief,
+    ""
+  );
+  parts.push(
+    `## MECHANICS`,
+    "",
+    `- Author \`packages/remotion/src/bespoke/v15/shorts/<ComponentName>.tsx\`. Choose a descriptive PascalCase ComponentName for this short (suggested: \`${suggested}\`).`,
+    `- Import ONLY from '../../../kit' (tokens, T.* roles, primitives) \u2014 the shorts dir is one level deeper than the sections. Never touch the dark '../../../toolkit' effects; never import the frozen oracle (KvOpening.tsx).`,
+    `- Self-register the mechanism scene via \`registerBespokeScene(<id>, <Component>)\` (see packages/remotion/src/kit/bespoke-registry.tsx).`,
+    `- Export the \`<ComponentName>Film\` wrapper component AND the frames constant (= the short's actual length, \u2264 ${framesMax}).`,
+    `- Add the side-effect import for your new file to packages/remotion/src/kit/index.ts (one \`import '../bespoke/v15/shorts/<ComponentName>';\` line in the registration manifest).`,
+    `- Do NOT touch any Root*.tsx BESPOKE table (the orchestrator integrates that). Do NOT touch the source section or other shorts. Do NOT install dependencies. Never push.`,
+    ""
+  );
+  parts.push(
+    `## SELF-VERIFY (prove the sync AND the safe zones \u2014 don't assume them)`,
+    "",
+    `Render verification stills at THREE frames: the OPEN (first meaningful action), the PEAK ("${peakLabel}"), and the CLOSE (final frame). Study docs/loop/v15/render/ for the still-render tooling.`,
+    `1. SYNC \u2014 for every payoff word inside the VO window, confirm its visual is PRESENT at round((wordStart \u2212 ${voWindow.startSec}) \xD7 ${FPS2}); if it lags its word, pull the visual earlier and re-render.`,
+    `2. SAFE ZONES \u2014 run the edge-band check (overflow-scan's doctrine: scan the outer band on all four edges for content that departs the bright base). Confirm NO meaningful element intrudes into the top ${top}px / bottom ${bottom}px / left ${left}px / right ${right}px bands, and that every caption sits at y \u2265 ${captionY} from the bottom. Fix any overflow and re-render.`,
+    "Iterate until both the sync and the safe-zone checks pass on all three stills.",
+    ""
+  );
+  parts.push(
+    `## GATES (both must exit 0 \u2014 check the real exit codes, never a piped tail)`,
+    "",
+    `1. \`cd packages/remotion && npx tsc --noEmit\` \u2192 exit 0.`,
+    `2. \`node scripts/type-lint.mjs\` from the worktree ROOT \u2192 exit 0.`,
+    "Fix every error until both gates are green.",
+    ""
+  );
+  parts.push(
+    `## COMMIT + REPORT`,
+    "",
+    `Commit EVERYTHING you authored as ONE conventional commit (e.g. \`feat(short): author ${sectionKey} vertical peak\`). Do NOT add any attribution / Co-Authored-By / "generated with" lines.`,
+    "",
+    `Then write the lane report to \`<worktree>/.forge-lane-report.json\` (worktree root). It MUST be valid JSON with EXACTLY these fields:`,
+    "",
+    "```json",
+    JSON.stringify(
+      {
+        kind: "author-short",
+        shortId: payload.shortId,
+        projectId: payload.projectId,
+        sectionKey,
+        componentRef: "<exported *Film component name>",
+        frames: framesMax,
+        commitSha: "<full sha of your single commit>",
+        worktreePath: "<absolute path of this worktree>",
+        gates: {
+          tsc: { exit: 0, summary: "<one line>" },
+          typeLint: { exit: 0, summary: "<one line>" }
+        },
+        evidenceFrames: [{ frame: 0, path: "<abs path to still>", label: "open|peak|close" }],
+        hookText: "<optional: the on-screen hook line you propose for this short>",
+        summary: "<one-line lane report>",
+        costUsd: null
+      },
+      null,
+      2
+    ),
+    "```",
+    "",
+    `frames is the short's ACTUAL rendered length (\u2264 ${framesMax}), equal to the exported frames constant \u2014 do NOT pad to the cap. evidenceFrames must include the open/peak/close stills you verified. hookText is optional \u2014 omit it or propose the short's on-screen hook. costUsd: report the real token cost if you can honestly measure it; otherwise leave it null and the worker fills a wall-time estimate.`
+  );
+  return parts.join("\n");
 }
 
-// ../pipeline/src/clip-render/orchestrator.ts
-function resolveConcurrency(requested) {
-  if (typeof requested === "number" && requested > 0) {
-    return Math.max(1, Math.floor(requested));
+// src/author-short/report.ts
+var FRAMES_MAX_CAP2 = 1800;
+function parseAuthorShortReportFile(text) {
+  let raw;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    raw = parsed;
+  } catch {
+    return null;
   }
-  const cores = os.cpus().length;
-  return Math.max(1, Math.min(DEFAULT_RENDER_CONCURRENCY, cores - 2));
-}
-async function renderChunksParallel(specs, options = {}) {
-  const concurrency = resolveConcurrency(options.concurrency);
-  const outer = (0, import_p_limit.default)(concurrency);
-  const manimInner = (0, import_p_limit.default)(2);
-  const startedAt = Date.now();
-  const results = new Array(specs.length);
-  let observedPeakConcurrency = 0;
-  let inFlight = 0;
-  const internalAbort = new AbortController();
-  const onCallerAbort = () => internalAbort.abort();
-  if (options.signal) {
-    if (options.signal.aborted) internalAbort.abort();
-    else options.signal.addEventListener("abort", onCallerAbort, { once: true });
+  if (raw.kind !== "author-short") return null;
+  if (!str(raw.shortId) || !UUID_RE2.test(raw.shortId)) return null;
+  if (!str(raw.projectId) || !UUID_RE2.test(raw.projectId)) return null;
+  if (!str(raw.sectionKey)) return null;
+  if (!str(raw.componentRef)) return null;
+  if (!int(raw.frames) || raw.frames <= 0 || raw.frames > FRAMES_MAX_CAP2) return null;
+  if (!str(raw.commitSha) || raw.commitSha.length < 7) return null;
+  if (!str(raw.worktreePath)) return null;
+  if (typeof raw.gates !== "object" || raw.gates === null) return null;
+  const gatesObj = raw.gates;
+  const tsc = parseGate(gatesObj.tsc);
+  const typeLint = parseGate(gatesObj.typeLint);
+  if (!tsc || !typeLint) return null;
+  const evidenceFrames = parseEvidenceFrames(raw.evidenceFrames);
+  if (evidenceFrames === null) return null;
+  if (raw.hookText !== void 0 && typeof raw.hookText !== "string") return null;
+  const summary = raw.summary === void 0 ? "" : raw.summary;
+  if (typeof summary !== "string") return null;
+  let costUsd = null;
+  if (raw.costUsd !== void 0) {
+    if (raw.costUsd !== null && typeof raw.costUsd !== "number") return null;
+    costUsd = raw.costUsd;
   }
-  const passThroughProgress = (event) => {
-    try {
-      options.onProgress?.(event);
-    } catch {
-    }
+  return {
+    kind: "author-short",
+    shortId: raw.shortId,
+    projectId: raw.projectId,
+    sectionKey: raw.sectionKey,
+    componentRef: raw.componentRef,
+    frames: raw.frames,
+    commitSha: raw.commitSha,
+    worktreePath: raw.worktreePath,
+    gates: { tsc, typeLint },
+    evidenceFrames,
+    ...raw.hookText !== void 0 ? { hookText: raw.hookText } : {},
+    summary,
+    costUsd
   };
+}
+
+// src/author-short/worker.ts
+var TAG = "author-short";
+async function invokeAuthorShort(payload, ctx) {
+  let worktreePath;
   try {
-    await Promise.all(
-      specs.map(
-        (spec, idx) => outer(async () => {
-          if (internalAbort.signal.aborted) {
-            results[idx] = abortedSkeleton(spec);
-            return;
-          }
-          inFlight += 1;
-          if (inFlight > observedPeakConcurrency) observedPeakConcurrency = inFlight;
-          try {
-            const acquireManimSlot = isManimEngine(spec.engine) ? async () => {
-              let resolveAcquired;
-              const acquired = new Promise((r) => {
-                resolveAcquired = r;
-              });
-              let release;
-              const released = new Promise((r) => {
-                release = r;
-              });
-              void manimInner(async () => {
-                resolveAcquired();
-                await released;
-              });
-              await acquired;
-              return release;
-            } : void 0;
-            const result = await renderChunk(spec, {
-              onProgress: passThroughProgress,
-              signal: internalAbort.signal,
-              acquireManimSlot
-            });
-            results[idx] = result;
-            if (!result.ok && options.failFast) {
-              internalAbort.abort();
-            }
-          } catch (err) {
-            results[idx] = {
-              ok: false,
-              chunkId: spec.chunkId,
-              engine: spec.engine,
-              outputPath: "",
-              durationSec: spec.durationSec,
-              renderTimeMs: 0,
-              fallbackDepth: 0,
-              error: err instanceof Error ? err.message : String(err)
-            };
-            if (options.failFast) internalAbort.abort();
-          } finally {
-            inFlight -= 1;
-          }
-        })
-      )
+    const repoRoot = resolveRepoRoot();
+    const wt = createLaneWorktree(
+      // `short-` prefix keeps a short's worktree distinct from its source
+      // section's (same createLaneWorktree, which sanitizes the key).
+      { repoRoot, baseSha: payload.baseSha, sectionKey: `short-${payload.sectionKey}` },
+      payload.resume
     );
-  } finally {
-    if (options.signal) options.signal.removeEventListener("abort", onCallerAbort);
+    worktreePath = wt.worktreePath;
+  } catch (err) {
+    return { error: `author-short worktree setup failed: ${err.message}` };
+  }
+  await postJobProgress(ctx, "brief", `worktree ready: ${worktreePath}`, TAG);
+  const prompt = buildAuthorShortPrompt(payload);
+  const model = ctx.model && MODEL_RE.test(ctx.model) ? ctx.model : "opus";
+  const args = [
+    "-p",
+    "--model",
+    model,
+    "--no-session-persistence",
+    ...resolveClaudePermissionArgs()
+  ];
+  let laneTail = "";
+  const capture = (buf) => {
+    laneTail = (laneTail + buf.toString("utf-8")).slice(-LANE_TAIL_KEEP);
+  };
+  const onSpawn = (child) => {
+    ctx.registerChild(child);
+    child.stdout?.on("data", capture);
+    child.stderr?.on("data", capture);
+  };
+  await postJobProgress(ctx, "authoring", `spawning claude:${model} in worktree`, TAG);
+  log.info(`[author-short] authoring ${payload.sectionKey} peak \xB7 claude:${model} \xB7 ${worktreePath}`);
+  const laneStartMs = Date.now();
+  let laneError = "";
+  try {
+    await ctx.runSpawn("claude", args, prompt, ctx.timeoutMs, onSpawn, worktreePath);
+  } catch (err) {
+    laneError = err.message;
   }
-  const totalRenderTimeMs = Date.now() - startedAt;
-  const ok = results.every((r) => r?.ok);
-  if (specs.length > 0) {
-    const stub = buildLocalManifestStub(specs, results);
-    if (stub.entries.length > 0) {
-      try {
-        const root = resolveProjectRoot(specs[0].projectSlug, specs[0].outputDir);
-        writeLocalManifestStub(root, stub);
-      } catch {
-      }
-    }
+  const laneEndMs = Date.now();
+  await postJobProgress(ctx, "gates", "reading lane report", TAG);
+  const reportPath = path21.join(worktreePath, REPORT_FILENAME);
+  let reportText = "";
+  try {
+    reportText = fs25.readFileSync(reportPath, "utf-8");
+  } catch {
+    return {
+      error: authorSectionFailureText(worktreePath, laneError, laneTail, `no report at ${reportPath}`, TAG)
+    };
   }
-  return { ok, results, totalRenderTimeMs, observedPeakConcurrency };
-}
-function abortedSkeleton(spec) {
-  return {
-    ok: false,
-    chunkId: spec.chunkId,
-    engine: spec.engine,
-    outputPath: "",
-    durationSec: spec.durationSec,
-    renderTimeMs: 0,
-    fallbackDepth: 0,
-    error: "aborted"
-  };
+  const report = parseAuthorShortReportFile(reportText);
+  if (!report) {
+    return {
+      error: authorSectionFailureText(worktreePath, laneError, laneTail, `report at ${reportPath} is invalid`, TAG)
+    };
+  }
+  let resultText = reportText;
+  if (report.costUsd === null) {
+    const costUsd = estimateLaneCostUsd({
+      startMs: laneStartMs,
+      endMs: laneEndMs,
+      cli: "claude",
+      model,
+      capturedOutput: laneTail
+    });
+    resultText = fillReportCostUsd(reportText, costUsd);
+  }
+  await postJobProgress(ctx, "committed", report.summary || `authored ${payload.sectionKey} short`, TAG);
+  log.success(`[author-short] ${payload.sectionKey} short authored \xB7 ${report.componentRef} \xB7 ${report.commitSha.slice(0, 8)}`);
+  return { text: resultText, modelUsed: `claude-lane:${model}` };
 }
 
 // src/bridge-poller.ts
-import * as path16 from "path";
+import * as path22 from "path";
 var HEARTBEAT_INTERVAL_MS = 6e4;
-var POLL_INTERVAL_MS = 8e3;
+var POLL_INTERVAL_MS3 = 8e3;
 var CANCEL_POLL_INTERVAL_MS = 5e3;
 var CLI_TIMEOUT_MS = Number(process.env.SCRIPT_GEN_TIMEOUT_MS) || 20 * 60 * 1e3;
 var IMAGE_GEN_TIMEOUT_MS = Number(process.env.CODEX_IMAGE_GEN_TIMEOUT_MS) || Number(process.env.IMAGE_GEN_TIMEOUT_MS) || 8 * 60 * 1e3;
+var AUTHOR_SECTION_TIMEOUT_MS = Number(process.env.FORGE_AUTHOR_SECTION_TIMEOUT_MS) || 120 * 60 * 1e3;
 var MAX_IN_FLIGHT_JOBS = Math.max(1, Math.min(6, Number(process.env.FORGE_BRIDGE_MAX_IN_FLIGHT) || 4));
 var CODEX_IMAGEGEN_AGENT_MODELS = ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini"];
 var CODEX_AGENT_MODEL_RE = /^gpt-5(?:$|[.\-])/i;
@@ -7869,11 +10468,13 @@ var BridgePoller = class {
    */
   renderCancelControllers = /* @__PURE__ */ new Map();
   stopped = false;
+  /** When rate-limited (429), pause polling until this epoch-ms. */
+  rateLimitBackoffUntilMs = 0;
   constructor(opts) {
     this.baseUrl = opts.baseUrl.replace(/\/$/, "");
     this.token = opts.token;
     this.clientVersion = opts.clientVersion;
-    this.instanceId = `${process.pid}-${crypto.randomBytes(2).toString("hex")}-${Date.now()}`;
+    this.instanceId = `${process.pid}-${crypto2.randomBytes(2).toString("hex")}-${Date.now()}`;
   }
   start() {
     if (this.heartbeatTimer || this.pollTimer) return;
@@ -7884,7 +10485,7 @@ var BridgePoller = class {
     }, HEARTBEAT_INTERVAL_MS);
     this.pollTimer = setInterval(() => {
       void this.poll();
-    }, POLL_INTERVAL_MS);
+    }, POLL_INTERVAL_MS3);
     this.cancelPollTimer = setInterval(() => {
       void this.checkCancels();
     }, CANCEL_POLL_INTERVAL_MS);
@@ -7900,10 +10501,10 @@ var BridgePoller = class {
   }
   probeBinary(name) {
     if (!/^[a-z][a-z0-9-]*$/i.test(name)) return { available: false, path: null };
-    const r = spawnSync("which", [name], { encoding: "utf-8", timeout: 2e3 });
+    const r = spawnSync3("which", [name], { encoding: "utf-8", timeout: 2e3 });
     if (r.status !== 0) return { available: false, path: null };
-    const path17 = (r.stdout ?? "").trim();
-    return { available: !!path17, path: path17 || null };
+    const path23 = (r.stdout ?? "").trim();
+    return { available: !!path23, path: path23 || null };
   }
   async heartbeat() {
     if (this.stopped) return;
@@ -8000,6 +10601,7 @@ var BridgePoller = class {
   }
   async poll() {
     if (this.stopped) return;
+    if (Date.now() < this.rateLimitBackoffUntilMs) return;
     const availableSlots = MAX_IN_FLIGHT_JOBS - this.inFlight.size;
     if (availableSlots <= 0) return;
     let jobs = [];
@@ -8015,10 +10617,16 @@ var BridgePoller = class {
       });
       if (!resp.ok) {
         if (resp.status === 401) {
-          log.warn("[bridge] 401 \u2014 bridge token rejected. Stopping poller. Set BRIDGE_TOKEN to the value Vercel has and restart.");
+          log.warn("[bridge][ALERT] 401 \u2014 bridge token rejected. Stopping poller. Rotate/set BRIDGE_TOKEN to the value Vercel has and restart. Runbook: docs/runbooks/bridge-auth.md");
           await this.stop();
           return;
         }
+        if (resp.status === 429) {
+          const retryAfter = Number(resp.headers.get("retry-after")) || 30;
+          this.rateLimitBackoffUntilMs = Date.now() + retryAfter * 1e3;
+          log.warn(`[bridge][ALERT] 429 \u2014 rate limited by the bridge API; backing off ${retryAfter}s. Repeated 429s \u2192 check Vercel function quota. Runbook: docs/runbooks/bridge-auth.md`);
+          return;
+        }
         const text = await resp.text().catch(() => "");
         log.warn(`[bridge] claim HTTP ${resp.status}: ${text.slice(0, 120)}`);
         return;
@@ -8091,6 +10699,22 @@ var BridgePoller = class {
     if (stitchPayload) {
       return this.invokeStitchFinal(job.id, stitchPayload);
     }
+    const authorSectionPayload = parseAuthorSectionPayload(job.prompt);
+    if (authorSectionPayload) {
+      if (job.cli !== "claude") return { error: "author-section jobs require claude CLI" };
+      return this.invokeAuthorSection(job, authorSectionPayload, onSpawn);
+    }
+    const authorShortPayload = parseAuthorShortPayload(job.prompt);
+    if (authorShortPayload) {
+      if (job.cli !== "claude") return { error: "author-short jobs require claude CLI" };
+      return this.invokeAuthorShort(job, authorShortPayload, onSpawn);
+    }
+    if (/"__forgeJobKind"\s*:\s*"author-section"/.test(job.prompt)) {
+      return { error: "malformed author-section payload \u2014 failed validation, refusing generic execution" };
+    }
+    if (/"__forgeJobKind"\s*:\s*"author-short"/.test(job.prompt)) {
+      return { error: "malformed author-short payload \u2014 failed validation, refusing generic execution" };
+    }
     const claudePromptEnvelope = parseClaudePromptEnvelope(job.prompt);
     if (claudePromptEnvelope) {
       if (job.cli !== "claude") return { error: `${claudePromptEnvelope.__forgeJobKind} envelope requires claude CLI` };
@@ -8119,19 +10743,19 @@ var BridgePoller = class {
     };
     try {
       const os2 = await import("os");
-      const audioStageDir = path16.join(os2.tmpdir(), "forge-audio");
-      await fs18.promises.mkdir(audioStageDir, { recursive: true });
+      const audioStageDir = path22.join(os2.tmpdir(), "forge-audio");
+      await fs26.promises.mkdir(audioStageDir, { recursive: true });
       await Promise.all(
         payload.specs.map(async (spec) => {
           if (spec.audioPath) return;
           const url = spec.audioStorjUrl;
           if (!url) return;
-          const localPath = path16.join(audioStageDir, `${spec.chunkId}.mp3`);
+          const localPath = path22.join(audioStageDir, `${spec.chunkId}.mp3`);
           try {
             const resp = await fetch(url);
             if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
             const buf = Buffer.from(await resp.arrayBuffer());
-            await fs18.promises.writeFile(localPath, buf);
+            await fs26.promises.writeFile(localPath, buf);
             spec.audioPath = localPath;
           } catch (err) {
             log.info(`[bridge] audio download failed for chunk ${spec.chunkId}: ${err.message} \u2014 rendering silent clip`);
@@ -8145,6 +10769,7 @@ var BridgePoller = class {
         signal: cancelController.signal
       });
       const specByChunk = new Map(payload.specs.map((s) => [s.chunkId, s]));
+      const qaGuardrails = guardrailsFromRenderClipsPayload(payload);
       const uploadOutcomes = [];
       for (const r of result.results) {
         if (!r.ok || !r.outputPath) continue;
@@ -8152,6 +10777,28 @@ var BridgePoller = class {
         if (!spec) continue;
         const upload = await this.uploadClipToStorj(jobId, payload.projectId, spec, r);
         uploadOutcomes.push({ chunkId: r.chunkId, ...upload });
+        let qaWarning;
+        if (upload.ok && spec.seriesPlan && r.engine === spec.seriesPlan.kind) {
+          try {
+            const qa = await runSeriesQA({
+              seriesPlan: spec.seriesPlan,
+              videoPath: r.outputPath,
+              ...qaGuardrails ? { guardrails: qaGuardrails } : {}
+            });
+            let reported = await this.reportSeriesQA(jobId, r.chunkId, upload.clipId, qa);
+            if (!reported) {
+              await new Promise((res) => setTimeout(res, 3e3));
+              reported = await this.reportSeriesQA(jobId, r.chunkId, upload.clipId, qa);
+            }
+            if (!reported) {
+              qaWarning = `QA ran (score=${qa.score}, passed=${qa.passed}) but report POST failed twice \u2014 chunk stays unjudged; re-render or report manually`;
+            }
+            log.info(`[bridge] qa ${r.chunkId.slice(0, 8)} score=${qa.score} passed=${qa.passed}${reported ? "" : " (report POST FAILED)"}`);
+          } catch (err) {
+            qaWarning = `series QA crashed: ${err.message?.slice(0, 160)}`;
+            log.info(`[bridge] qa failed for ${r.chunkId.slice(0, 8)}: ${err.message}`);
+          }
+        }
         void this.postRenderProgress(jobId, payload.projectId, {
           chunkId: r.chunkId,
           phase: upload.ok ? "done" : "error",
@@ -8160,6 +10807,7 @@ var BridgePoller = class {
           resolvedEngine: r.engine,
           storjKey: upload.storjKey,
           outputPath: r.outputPath,
+          warnings: qaWarning ? [qaWarning] : void 0,
           error: upload.ok ? void 0 : `upload failed: ${upload.error ?? "unknown"}`,
           ts: (/* @__PURE__ */ new Date()).toISOString()
         });
@@ -8237,8 +10885,8 @@ var BridgePoller = class {
    */
   async uploadClipToStorj(bridgeJobId, projectId, spec, result) {
     try {
-      const fs19 = await import("fs/promises");
-      const stat = await fs19.stat(result.outputPath);
+      const fs27 = await import("fs/promises");
+      const stat = await fs27.stat(result.outputPath);
       if (!stat.isFile() || stat.size === 0) {
         return { ok: false, error: `local clip empty or missing at ${result.outputPath}` };
       }
@@ -8262,7 +10910,7 @@ var BridgePoller = class {
         return { ok: false, error: `mint HTTP ${mintResp.status}: ${mintText.slice(0, 300)}` };
       }
       const mint = JSON.parse(mintText);
-      const buf = await fs19.readFile(result.outputPath);
+      const buf = await fs27.readFile(result.outputPath);
       const putResp = await fetch(mint.signedUrl, {
         method: "PUT",
         headers: { "Content-Type": "video/mp4" },
@@ -8296,13 +10944,39 @@ var BridgePoller = class {
       if (!finResp.ok) {
         return { ok: false, storjKey: mint.storjKey, error: `finalize HTTP ${finResp.status}: ${finText.slice(0, 300)}` };
       }
+      let clipId;
+      try {
+        clipId = JSON.parse(finText).clipId;
+      } catch {
+      }
       log.info(`[bridge] uploaded ${result.chunkId.slice(0, 8)} -> ${mint.storjKey} (v${mint.version}, ${(stat.size / 1024 / 1024).toFixed(1)}M)`);
       void projectId;
-      return { ok: true, storjKey: mint.storjKey };
+      return { ok: true, storjKey: mint.storjKey, clipId };
     } catch (err) {
       return { ok: false, error: err.message };
     }
   }
+  /**
+   * POST a series-chunk QA report to /api/cli-bridge/report-qa. The web
+   * writes quality_scores (visual/overall from the composite, sync NULL)
+   * + the full report jsonb, and flips the chunk to 'judged'.
+   */
+  async reportSeriesQA(bridgeJobId, chunkId, clipId, qa) {
+    try {
+      const resp = await fetch(`${this.baseUrl}/api/cli-bridge/report-qa`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ bridgeJobId, chunkId, clipId, report: qa }),
+        signal: AbortSignal.timeout(6e4)
+      });
+      return resp.ok;
+    } catch {
+      return false;
+    }
+  }
   /**
    * POST the assembled ProjectManifest to /api/cli-bridge/upload-manifest.
    * Called once per render-clips batch after every clip uploads. The
@@ -8361,16 +11035,16 @@ var BridgePoller = class {
   async invokeStitchFinal(jobId, payload) {
     let stitchFinalVideo;
     try {
-      const mod = await import("./stitch-P3P6SK6M.js");
+      const mod = await import("./stitch-5AG5JLZZ.js");
       stitchFinalVideo = mod.stitchFinalVideo;
     } catch (err) {
       return {
         error: `stitch-final job requires @forge/pipeline/stitch (not installed): ${err.message}`
       };
     }
-    const path17 = await import("path");
-    const projectRoot = path17.resolve(process.cwd(), "forge-renders", payload.projectSlug);
-    const clipsDir = path17.join(projectRoot, "clips");
+    const path23 = await import("path");
+    const projectRoot = path23.resolve(process.cwd(), "forge-renders", payload.projectSlug);
+    const clipsDir = path23.join(projectRoot, "clips");
     const publish = async (phase, eventPayload) => {
       try {
         await fetch(`${this.baseUrl}/api/cli-bridge/stitch-event`, {
@@ -8396,7 +11070,7 @@ var BridgePoller = class {
         projectSlug: payload.projectSlug,
         clipsDir,
         chunkOrder: payload.chunkOrder ?? [],
-        masterAudioPath: path17.isAbsolute(masterAudioRel) ? masterAudioRel : path17.join(projectRoot, masterAudioRel),
+        masterAudioPath: path23.isAbsolute(masterAudioRel) ? masterAudioRel : path23.join(projectRoot, masterAudioRel),
         outputDir: projectRoot,
         aspect: payload.aspect,
         skipTransitions: payload.skipTransitions,
@@ -8432,6 +11106,41 @@ var BridgePoller = class {
       return { error: `stitch-final crash: ${msg}` };
     }
   }
+  /**
+   * Run an author-section lane (craft platform §2.2). Delegates the
+   * worktree/spawn/report orchestration to ./author-section/worker, injecting
+   * the poller's runSpawn (so timeout + cancel SIGTERM keep working) and the
+   * onSpawn that registers the child for the cancel path. The worktree is never
+   * deleted — it survives for integration and for resume re-entry.
+   */
+  async invokeAuthorSection(job, payload, onSpawn) {
+    return invokeAuthorSection(payload, {
+      jobId: job.id,
+      model: job.model,
+      baseUrl: this.baseUrl,
+      token: this.token,
+      timeoutMs: AUTHOR_SECTION_TIMEOUT_MS,
+      runSpawn,
+      registerChild: onSpawn
+    });
+  }
+  /**
+   * Run an author-short lane (craft platform §2.6) — the 9:16 re-author variant.
+   * Same injection as invokeAuthorSection (runSpawn for timeout+cancel, onSpawn
+   * to register the child); the surviving worktree enables resume re-entry. The
+   * lane's raw report JSON is handed back for the /respond route to re-parse.
+   */
+  async invokeAuthorShort(job, payload, onSpawn) {
+    return invokeAuthorShort(payload, {
+      jobId: job.id,
+      model: job.model,
+      baseUrl: this.baseUrl,
+      token: this.token,
+      timeoutMs: AUTHOR_SECTION_TIMEOUT_MS,
+      runSpawn,
+      registerChild: onSpawn
+    });
+  }
   /**
    * Run a Claude prompt envelope. Web tools are gated by envelope.webTools:
    *   ['WebSearch','WebFetch'] for fact-pack-build (research stage)
@@ -8552,6 +11261,11 @@ function parseRenderClipsPayload(prompt) {
   }
   return null;
 }
+function guardrailsFromRenderClipsPayload(payload) {
+  if (payload.aiGuardrails == null) return void 0;
+  const parsed = dnaAiGuardrailsSchema.safeParse(payload.aiGuardrails);
+  return parsed.success ? parsed.data : void 0;
+}
 var CLAUDE_JOB_KINDS = [
   "fact-pack-build",
   "script-from-pack",
@@ -8580,10 +11294,10 @@ function collectImagesFromCodexStdout(stdout, maxCount) {
   for (const p of paths) {
     if (images.length >= maxCount) break;
     try {
-      const stat = fs18.statSync(p);
+      const stat = fs26.statSync(p);
       if (!stat.isFile() || stat.size <= 0) continue;
       images.push({
-        base64: fs18.readFileSync(p).toString("base64"),
+        base64: fs26.readFileSync(p).toString("base64"),
         mimeType: mimeTypeForPath(p),
         model: "codex-cli:imagegen"
       });
@@ -8597,9 +11311,9 @@ function parseImagePathsFromJson(stdout) {
   const candidates = [trimmed];
   const objectMatch = trimmed.match(/\{[\s\S]*\}/);
   if (objectMatch) candidates.push(objectMatch[0]);
-  for (const candidate of candidates) {
+  for (const candidate2 of candidates) {
     try {
-      const parsed = JSON.parse(candidate);
+      const parsed = JSON.parse(candidate2);
       if (Array.isArray(parsed.images)) {
         return parsed.images.map((img) => img.path).filter((p) => typeof p === "string");
       }
@@ -8614,9 +11328,9 @@ function mimeTypeForPath(p) {
   if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
   return "image/png";
 }
-function runSpawn(cmd, args, stdin, timeoutMs, onSpawn) {
-  return new Promise((resolve3, reject) => {
-    const proc = spawn2(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
+function runSpawn(cmd, args, stdin, timeoutMs, onSpawn, cwd) {
+  return new Promise((resolve5, reject) => {
+    const proc = spawn2(cmd, args, { stdio: ["pipe", "pipe", "pipe"], ...cwd ? { cwd } : {} });
     if (onSpawn) {
       try {
         onSpawn(proc);
@@ -8649,11 +11363,12 @@ function runSpawn(cmd, args, stdin, timeoutMs, onSpawn) {
         return;
       }
       if (code !== 0) reject(new Error(`${cmd} exit ${code}: ${stderr.slice(-300)}`));
-      else resolve3(stdout);
+      else resolve5(stdout);
     });
     proc.stdin.end(stdin);
   });
 }
 export {
-  BridgePoller
+  BridgePoller,
+  guardrailsFromRenderClipsPayload
 };