videoclaw 3.0.0-alpha.1

package/src/video/assemble/pdf.ts

@@ -0,0 +1,169 @@
+/**
+ * PDF slide extraction for the assemble stage (sub-slice 3c).
+ *
+ * Source of truth: `skills/video-replicator/scripts/extract_pdf_slides.py`.
+ *
+ * The Python pipeline shells out to `pdf2image`/`pdftoppm` to rasterize each
+ * PDF page to a JPEG at a target DPI. We do the equivalent in-process with
+ * `pdfjs-dist`: open the PDF, render each page to a canvas, and encode the
+ * canvas to PNG/JPG. No external binaries; no network.
+ *
+ * pdfjs-dist must be imported from its `legacy` build in Node.js — the default
+ * (browser) build emits the "Please use the `legacy` build in Node.js
+ * environments" warning and assumes browser globals. The legacy build is the
+ * supported Node entry point.
+ *
+ * Rendering needs a canvas backend. `@napi-rs/canvas` is the canvas the
+ * pdfjs-dist Node build itself relies on (it ships as pdfjs-dist's canvas
+ * dependency), so no additional native dependency is introduced here; we just
+ * declare it directly since we import it directly.
+ */
+// eslint-disable-next-line import/no-unresolved -- legacy entry resolved at runtime
+import * as pdfjs from 'pdfjs-dist/legacy/build/pdf.mjs';
+import { createCanvas } from '@napi-rs/canvas';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { VclawError } from '../errors.js';
+
+export type SlideImageFormat = 'png' | 'jpg';
+
+export interface ExtractPdfSlidesInput {
+  /** Absolute or cwd-relative path to the source PDF. */
+  pdfPath: string;
+  /** Directory to write the rendered slide images into. */
+  outputDir: string;
+  /** Image encoding (default: 'png'). */
+  format?: SlideImageFormat;
+  /**
+   * Render scale relative to the PDF's native point size (default: 2.0).
+   *
+   * pdfjs renders at 72 DPI when scale=1. The Python default of 200 DPI maps
+   * to scale ≈ 2.78; we default to 2.0 (≈144 DPI) for a sensible balance of
+   * fidelity vs. file size, overridable per call.
+   */
+  scale?: number;
+  /** Skip rendering + file writes; return page metadata only. */
+  dryRun?: boolean;
+}
+
+export interface ExtractedPdfPage {
+  /** 1-based page index (mirrors the Python `slide_NNN` naming). */
+  index: number;
+  /** Path to the rendered image (empty string on dry-run). */
+  path: string;
+  /** Rendered pixel width (= native width × scale). */
+  width: number;
+  /** Rendered pixel height (= native height × scale). */
+  height: number;
+}
+
+export interface ExtractPdfSlidesResult {
+  pages: ExtractedPdfPage[];
+}
+
+const DEFAULT_SCALE = 2.0;
+
+/** `slide_001.png` — zero-padded to 3 digits to match the Python pipeline. */
+export function slideImageFilename(index: number, format: SlideImageFormat): string {
+  return `slide_${String(index).padStart(3, '0')}.${format}`;
+}
+
+/**
+ * Render each page of a PDF to an image. Returns per-page metadata.
+ *
+ * On `dryRun`, the PDF is still opened (so page count + dimensions are real),
+ * but no canvas is rendered and no file is written; each page's `path` is the
+ * empty string.
+ *
+ * Throws `VclawError('pdf_parse_failed', ...)` if the document cannot be
+ * parsed or a page cannot be rendered.
+ */
+export async function extractPdfSlides(
+  input: ExtractPdfSlidesInput,
+): Promise<ExtractPdfSlidesResult> {
+  const format: SlideImageFormat = input.format ?? 'png';
+  const scale = input.scale && input.scale > 0 ? input.scale : DEFAULT_SCALE;
+
+  let data: Buffer;
+  try {
+    const { readFile } = await import('node:fs/promises');
+    data = await readFile(input.pdfPath);
+  } catch (err) {
+    throw new VclawError(
+      'pdf_parse_failed',
+      `Could not read PDF at "${input.pdfPath}": ${(err as Error).message}`,
+      { pdfPath: input.pdfPath },
+    );
+  }
+
+  let doc: Awaited<ReturnType<typeof pdfjs.getDocument>['promise']>;
+  try {
+    // `isEvalSupported: false` keeps us off `eval` in Node; `useSystemFonts`
+    // lets the legacy build fall back to system fonts rather than failing.
+    doc = await pdfjs.getDocument({
+      data: new Uint8Array(data),
+      isEvalSupported: false,
+      useSystemFonts: true,
+    }).promise;
+  } catch (err) {
+    throw new VclawError(
+      'pdf_parse_failed',
+      `Failed to parse PDF "${input.pdfPath}": ${(err as Error).message}`,
+      { pdfPath: input.pdfPath },
+    );
+  }
+
+  const pageCount = doc.numPages;
+  const pages: ExtractedPdfPage[] = [];
+
+  try {
+    if (!input.dryRun) {
+      await mkdir(input.outputDir, { recursive: true });
+    }
+
+    for (let index = 1; index <= pageCount; index += 1) {
+      const page = await doc.getPage(index);
+      const viewport = page.getViewport({ scale });
+      const width = Math.ceil(viewport.width);
+      const height = Math.ceil(viewport.height);
+
+      if (input.dryRun) {
+        pages.push({ index, path: '', width, height });
+        page.cleanup();
+        continue;
+      }
+
+      const canvas = createCanvas(width, height);
+      const ctx = canvas.getContext('2d');
+      // The @napi-rs/canvas 2D context satisfies pdfjs's render contract;
+      // pdfjs ships @napi-rs/canvas as its own Node canvas backend. pdfjs types
+      // the field as the browser `CanvasRenderingContext2D`, which isn't in the
+      // Node lib set, so we widen the render params to `unknown` first.
+      const renderParams = {
+        canvasContext: ctx,
+        viewport,
+      } as unknown as Parameters<typeof page.render>[0];
+      await page.render(renderParams).promise;
+
+      const filename = slideImageFilename(index, format);
+      const path = join(input.outputDir, filename);
+      const buffer =
+        format === 'jpg' ? await canvas.encode('jpeg', 95) : await canvas.encode('png');
+      await writeFile(path, buffer);
+
+      pages.push({ index, path, width, height });
+      page.cleanup();
+    }
+  } catch (err) {
+    if (err instanceof VclawError) throw err;
+    throw new VclawError(
+      'pdf_parse_failed',
+      `Failed to render PDF "${input.pdfPath}": ${(err as Error).message}`,
+      { pdfPath: input.pdfPath },
+    );
+  } finally {
+    await doc.destroy().catch(() => undefined);
+  }
+
+  return { pages };
+}

package/src/video/assemble/qa-dialogue-lint.ts

@@ -0,0 +1,129 @@
+/**
+ * Dialogue / lip-sync word-count linter (pure, no I/O).
+ *
+ * Ported from `skills/video-replicator/scripts/bunty_dialogue_lint.py`.
+ *
+ * Veo I2V lip-sync clips have a FIXED 8-second duration. Above ~28 words the
+ * speech gets cut off mid-sentence (confirmed 2026-05-11). The sign-off scene
+ * (scene 21) is tighter — 15-20 words for dramatic pacing.
+ *
+ * Limits (from bunty-voice-guide.md, codified 2026-05-11):
+ *   Standard lip-sync (scenes 17, 19, 20): 24-28 words MAX (recommended <=26)
+ *   Sign-off (scene 21):                   15-20 words MAX (recommended <=18)
+ *
+ * This is ADVISORY: it returns warnings rather than throwing. It only throws a
+ * VclawError for genuinely invalid input (non-array segments). The Python
+ * file/glob/CLI wiring and ANSI emit are intentionally NOT ported (3i owns CLI).
+ *
+ * Pure module: no CLI wiring (3i).
+ */
+import { VclawError } from '../errors.js';
+
+/** Standard lip-sync word ceiling (scenes 17, 19, 20). */
+export const STANDARD_MAX_WORDS = 28;
+/** Comfortable middle for standard lip-sync. */
+export const STANDARD_RECOMMENDED_WORDS = 26;
+/** The dramatic sign-off scene index (1-based, matches Python "21"). */
+export const SIGNOFF_SCENE_INDEX = 21;
+/** Sign-off word ceiling (scene 21). */
+export const SIGNOFF_MAX_WORDS = 20;
+/** Comfortable middle for the sign-off. */
+export const SIGNOFF_RECOMMENDED_WORDS = 18;
+
+export interface DialogueSegment {
+  /** Scene index this dialogue line belongs to. */
+  sceneIndex: number;
+  /** The spoken text for this scene. */
+  text: string;
+}
+
+export interface LintDialogueInput {
+  segments: DialogueSegment[];
+  /** Override the standard (non-sign-off) max word count. Default STANDARD_MAX_WORDS. */
+  standardMaxWords?: number;
+  /** Override the standard recommended word count. Default STANDARD_RECOMMENDED_WORDS. */
+  standardRecommendedWords?: number;
+  /** Scene index treated as the tighter sign-off. Default SIGNOFF_SCENE_INDEX. */
+  signoffSceneIndex?: number;
+  /** Override the sign-off max word count. Default SIGNOFF_MAX_WORDS. */
+  signoffMaxWords?: number;
+  /** Override the sign-off recommended word count. Default SIGNOFF_RECOMMENDED_WORDS. */
+  signoffRecommendedWords?: number;
+}
+
+export interface DialogueWarning {
+  sceneIndex: number;
+  /** Stable rule id: 'over-limit' (will be cut off) or 'near-limit' (edge). */
+  rule: 'over-limit' | 'near-limit';
+  message: string;
+  /** Computed word count for the segment. */
+  wordCount: number;
+}
+
+export interface LintDialogueResult {
+  warnings: DialogueWarning[];
+  /** True when no over-limit or near-limit warnings were produced. */
+  ok: boolean;
+}
+
+/**
+ * Count tokens that look like words (have at least one letter or digit). This
+ * excludes standalone punctuation like em dashes which split on whitespace into
+ * their own token but aren't spoken. Hyphenated words count as one.
+ *
+ * Mirrors the Python `count_words` helper.
+ */
+export function countWords(text: string): number {
+  return text
+    .trim()
+    .split(/\s+/)
+    .filter((w) => /[\p{L}\p{N}]/u.test(w)).length;
+}
+
+/**
+ * Lint dialogue segments against the Veo lip-sync word ceilings. Advisory:
+ * returns warnings, never throws for content. Throws only on invalid input.
+ */
+export function lintDialogue(input: LintDialogueInput): LintDialogueResult {
+  if (!input || !Array.isArray(input.segments)) {
+    throw new VclawError(
+      'unexpected_internal_error',
+      'lintDialogue: input.segments must be an array',
+    );
+  }
+
+  const standardMax = input.standardMaxWords ?? STANDARD_MAX_WORDS;
+  const standardRec = input.standardRecommendedWords ?? STANDARD_RECOMMENDED_WORDS;
+  const signoffScene = input.signoffSceneIndex ?? SIGNOFF_SCENE_INDEX;
+  const signoffMax = input.signoffMaxWords ?? SIGNOFF_MAX_WORDS;
+  const signoffRec = input.signoffRecommendedWords ?? SIGNOFF_RECOMMENDED_WORDS;
+
+  const warnings: DialogueWarning[] = [];
+
+  for (const seg of input.segments) {
+    if (typeof seg?.text !== 'string') continue;
+    const n = countWords(seg.text);
+    const isSignoff = seg.sceneIndex === signoffScene;
+    const maxWords = isSignoff ? signoffMax : standardMax;
+    const recommended = isSignoff ? signoffRec : standardRec;
+    const label = isSignoff ? 'sign-off' : 'lip-sync';
+
+    if (n > maxWords) {
+      warnings.push({
+        sceneIndex: seg.sceneIndex,
+        rule: 'over-limit',
+        wordCount: n,
+        message: `Scene ${seg.sceneIndex} (${label}): ${n} words — OVER LIMIT (${maxWords}). Veo will cut off speech mid-sentence. Trim to <=${recommended}.`,
+      });
+    } else if (n > recommended) {
+      warnings.push({
+        sceneIndex: seg.sceneIndex,
+        rule: 'near-limit',
+        wordCount: n,
+        message: `Scene ${seg.sceneIndex} (${label}): ${n} words — at the edge (${maxWords} max). Consider trimming to <=${recommended} for safety.`,
+      });
+    }
+  }
+
+  return { warnings, ok: warnings.length === 0 };
+}

package/src/video/assemble/qa-image-filter.ts

@@ -0,0 +1,147 @@
+/**
+ * Image content-filter risk heuristics — LOCAL checks only (pure, no I/O).
+ *
+ * Ported from `skills/video-replicator/scripts/bunty_image_filter_check.py`.
+ *
+ * The Python original predicts which deck slides will trip Veo's first-frame
+ * content filter (warriors with weapons, supernatural figures, dark
+ * industrial-noir, combat poses). It does this via a Gemini-Vision call that
+ * classifies each slide image as safe|risky|likely-blocked. That vision call
+ * needs an API key, looks at pixels, and requires a network round-trip, so it
+ * lives in the sibling `qa-image-vision.ts` (`checkImageVision`) — this module
+ * stays pure.
+ *
+ * What IS ported here: the local, text-based heuristic that scores a slide's
+ * *prompt / description* against the same known-risky keyword categories the
+ * Python prompt enumerates (weapons, combat poses, supernatural/demonic,
+ * industrial-noir). This lets the operator flag at-risk slides from their
+ * generation prompts BEFORE any image or F2V generation, cheaply and offline,
+ * and mirrors the Python verdict ladder (safe < risky < likely-blocked) that
+ * the vision sibling shares via {@link VERDICT_ORDER}.
+ *
+ * This is ADVISORY: it returns warnings rather than throwing. It only throws a
+ * VclawError for genuinely invalid input. Pure module: no CLI wiring (3i).
+ */
+import { VclawError } from '../errors.js';
+
+export type FilterVerdict = 'safe' | 'risky' | 'likely-blocked';
+
+/** Severity ordering, mirrors Python VERDICT_ORDER. */
+export const VERDICT_ORDER: Record<FilterVerdict, number> = {
+  safe: 0,
+  risky: 1,
+  'likely-blocked': 2,
+};
+
+/**
+ * Keyword categories matching the Python prompt's flagged-element list. Each
+ * category contributes to the risk score. Two distinct categories present, or a
+ * high-weight category, escalate the verdict to likely-blocked.
+ */
+export const RISK_CATEGORIES: Record<string, { weight: number; keywords: string[] }> = {
+  weapon: {
+    weight: 2,
+    keywords: ['sword', 'knife', 'gun', 'rifle', 'pistol', 'blade', 'energy weapon', 'firearm'],
+  },
+  combatPose: {
+    weight: 1,
+    keywords: ['fighting stance', 'battle pose', 'combat pose', 'warrior stance', 'fighting pose'],
+  },
+  supernatural: {
+    weight: 2,
+    keywords: ['glowing eyes', 'demonic', 'hooded figure', 'dark aura', 'glowing aura', 'energy ball', 'supernatural'],
+  },
+  industrialNoir: {
+    weight: 1,
+    keywords: ['rusted metal', 'destroyed environment', 'helmeted silhouette', 'industrial noir', 'dark silhouette'],
+  },
+};
+
+export interface ImageFilterCandidate {
+  sceneIndex: number;
+  /**
+   * The text used to generate / describe the slide image (prompt or caption).
+   * The local heuristic scans this for known-risky keyword categories.
+   */
+  prompt: string;
+}
+
+export interface CheckImageFilterInput {
+  candidates: ImageFilterCandidate[];
+  /**
+   * Flag any candidate at or above this verdict. Default 'risky'. (The Python
+   * default is 'likely-blocked', but for a text-only heuristic 'risky' is the
+   * safer advisory default; callers can raise it.)
+   */
+  threshold?: FilterVerdict;
+}
+
+export interface ImageFilterWarning {
+  sceneIndex: number;
+  rule: 'content-filter-risk';
+  verdict: FilterVerdict;
+  /** Risk categories that matched, e.g. ['weapon', 'supernatural']. */
+  categories: string[];
+  message: string;
+}
+
+export interface CheckImageFilterResult {
+  warnings: ImageFilterWarning[];
+  ok: boolean;
+}
+
+/** Classify one prompt into a verdict + matched categories (pure, local). */
+export function classifyImagePrompt(prompt: string): {
+  verdict: FilterVerdict;
+  categories: string[];
+} {
+  const hay = prompt.toLowerCase();
+  const matched: string[] = [];
+  let score = 0;
+  for (const [name, { weight, keywords }] of Object.entries(RISK_CATEGORIES)) {
+    if (keywords.some((kw) => hay.includes(kw))) {
+      matched.push(name);
+      score += weight;
+    }
+  }
+  let verdict: FilterVerdict = 'safe';
+  if (score >= 2 || matched.length >= 2) verdict = 'likely-blocked';
+  else if (score >= 1) verdict = 'risky';
+  return { verdict, categories: matched };
+}
+
+/**
+ * Run the local image-filter heuristic over candidate slide prompts. Advisory:
+ * returns warnings, never throws for content. Throws only on invalid input.
+ */
+export function checkImageFilter(input: CheckImageFilterInput): CheckImageFilterResult {
+  if (!input || !Array.isArray(input.candidates)) {
+    throw new VclawError(
+      'unexpected_internal_error',
+      'checkImageFilter: input.candidates must be an array',
+    );
+  }
+
+  const threshold = input.threshold ?? 'risky';
+  const thresholdLevel = VERDICT_ORDER[threshold];
+  const warnings: ImageFilterWarning[] = [];
+
+  for (const candidate of input.candidates) {
+    if (typeof candidate?.prompt !== 'string') continue;
+    const { verdict, categories } = classifyImagePrompt(candidate.prompt);
+    if (VERDICT_ORDER[verdict] >= thresholdLevel) {
+      warnings.push({
+        sceneIndex: candidate.sceneIndex,
+        rule: 'content-filter-risk',
+        verdict,
+        categories,
+        message:
+          verdict === 'safe'
+            ? `Scene ${candidate.sceneIndex}: clean cricket composition.`
+            : `Scene ${candidate.sceneIndex}: ${verdict} — flagged ${categories.join(', ')}. Consider softening the composition before F2V to avoid Veo content-filter rejection.`,
+      });
+    }
+  }
+
+  return { warnings, ok: warnings.length === 0 };
+}

package/src/video/assemble/qa-image-vision.ts

@@ -0,0 +1,154 @@
+/**
+ * Image content-filter risk — Gemini-Vision pixel classification (the
+ * `check_image` port deferred from `qa-image-filter.ts`).
+ *
+ * Ported from `skills/video-replicator/scripts/bunty_image_filter_check.py`
+ * `check_image()`: classify each slide image against the known first-frame
+ * content-filter rejection patterns (weapon imagery, combat-pose silhouettes,
+ * supernatural/demonic figures, dark industrial-noir compositions) BEFORE any
+ * image-to-video generation runs — a rejected first frame wastes both credits
+ * and wall time on futile retries. Verdict ladder (plus `error` for API/parse
+ * failures, mirroring the Python):
+ *
+ *   safe           — clean composition, should pass the filter
+ *   risky          — one or more high-risk elements; expect partial rejections
+ *   likely-blocked — matches known rejection patterns; expect rejection
+ *
+ * `ok` is false only when a slide is at or above `threshold` (default
+ * `likely-blocked`, the Python's default) — `error` results are advisory
+ * (the Python exits 2 separately for those; here the caller can inspect
+ * `results`). The local, text-based keyword heuristic over generation
+ * *prompts* lives in the pure sibling `qa-image-filter.ts` (same
+ * {@link VERDICT_ORDER} ladder); this module is the network half that looks
+ * at actual pixels.
+ *
+ * Transport (key pool / endpoint override / injectable fetcher / the two-line
+ * `verdict:` / `reason:` reply contract) is the shared
+ * {@link classifyImageWithGemini} in `gemini-vision-classify.ts`, used by both
+ * assemble QA vision modules.
+ */
+import {
+  classifyImageWithGemini,
+  parseTwoLineVerdict,
+  resolveVisionQaEndpoint,
+  DEFAULT_GEMINI_VISION_QA_ENDPOINT,
+} from './gemini-vision-classify.js';
+import { VERDICT_ORDER, type FilterVerdict } from './qa-image-filter.js';
+import { VclawError } from '../errors.js';
+
+export const DEFAULT_QA_IMAGE_VISION_ENDPOINT = DEFAULT_GEMINI_VISION_QA_ENDPOINT;
+
+const FILTER_VERDICTS = ['safe', 'risky', 'likely-blocked'] as const;
+
+export type ImageVisionVerdict = FilterVerdict | 'error';
+
+export interface ImageVisionSlide {
+  sceneIndex: number;
+  /** Path to the slide/keyframe image that will seed image-to-video generation. */
+  imagePath: string;
+}
+
+export interface CheckImageVisionInput {
+  slides: ImageVisionSlide[];
+  /**
+   * Flag slides at or above this verdict (`ok` turns false). Default
+   * `likely-blocked` — the Python's default; pass `risky` for a stricter gate.
+   */
+  threshold?: Exclude<FilterVerdict, 'safe'>;
+  /** Override the Gemini endpoint (else VCLAW_GEMINI_API_ENDPOINT, else default). */
+  endpoint?: string;
+  /** Explicit API key — bypasses the env-backed key pool. */
+  keyOverride?: string;
+  /** Injectable fetch for offline tests. */
+  fetcher?: typeof fetch;
+}
+
+export interface ImageVisionResult {
+  sceneIndex: number;
+  verdict: ImageVisionVerdict;
+  reason: string;
+}
+
+export interface CheckImageVisionResult {
+  results: ImageVisionResult[];
+  /** Results at or above the threshold (never includes `error` results). */
+  flagged: ImageVisionResult[];
+  /** False only when at least one slide is at/above the threshold. */
+  ok: boolean;
+}
+
+/**
+ * The audit prompt, generalized from the Python original (which was worded for
+ * its cricket-recap deck). The four flagged-element categories and the EXACT
+ * two-line `verdict:` / `reason:` reply contract are unchanged.
+ */
+export function buildImageVisionPrompt(): string {
+  return [
+    'You are auditing a video deck slide. The pipeline will use this slide as a first-frame image for AI video generation (e.g. Google Veo). The generator has an image content filter that rejects images containing:',
+    '',
+    '- Weapon imagery (swords, knives, guns, glowing energy weapons, objects held like weapons)',
+    '- Combat-pose silhouettes (figures in fighting stances, dramatic battle poses)',
+    '- Supernatural or demonic figures (glowing eyes, hooded dark figures, dramatic auras around people)',
+    '- Dark industrial-noir compositions (rusted metal, dark helmeted silhouettes in destroyed environments)',
+    '',
+    'Stylised comic-book or cinematic panels sometimes lean into action-hero/warrior aesthetics that look like combat imagery to the filter even when the subject is benign.',
+    '',
+    'Classify the attached slide image. Reply in this EXACT format (no other text):',
+    'verdict: <safe|risky|likely-blocked>',
+    'reason: <one sentence noting any flagged elements; if safe, say "clean composition">',
+  ].join('\n');
+}
+
+/**
+ * Parse the two-line `verdict:` / `reason:` reply. An unrecognized verdict
+ * value falls back to `error` with the full reply text as the reason, exactly
+ * like the Python original.
+ */
+export function parseImageVisionReply(text: string): { verdict: ImageVisionVerdict; reason: string } {
+  return parseTwoLineVerdict(text, FILTER_VERDICTS);
+}
+
+/**
+ * Classify content-filter risk for every slide image, sequentially (one
+ * Gemini call per slide, matching the Python). Per-slide failures (missing
+ * image, HTTP error, unparseable reply) become `error` results rather than
+ * aborting the deck. Throws only on invalid input.
+ */
+export async function checkImageVision(
+  input: CheckImageVisionInput,
+): Promise<CheckImageVisionResult> {
+  if (!input || !Array.isArray(input.slides)) {
+    throw new VclawError(
+      'unexpected_internal_error',
+      'checkImageVision: input.slides must be an array',
+    );
+  }
+  const threshold = input.threshold ?? 'likely-blocked';
+  // Runtime guard for JS callers — the type already excludes 'safe'.
+  if (threshold !== 'risky' && threshold !== 'likely-blocked') {
+    throw new VclawError(
+      'unexpected_internal_error',
+      `checkImageVision: threshold must be 'risky' or 'likely-blocked', got '${threshold}'`,
+    );
+  }
+  const endpoint = resolveVisionQaEndpoint(input.endpoint);
+  const prompt = buildImageVisionPrompt();
+
+  const results: ImageVisionResult[] = [];
+  for (const slide of input.slides) {
+    const classified = await classifyImageWithGemini({
+      imagePath: slide.imagePath,
+      prompt,
+      allowedVerdicts: FILTER_VERDICTS,
+      endpoint,
+      keyOverride: input.keyOverride,
+      fetcher: input.fetcher,
+    });
+    results.push({ sceneIndex: slide.sceneIndex, ...classified });
+  }
+
+  const flagged = results.filter(
+    (r) => r.verdict !== 'error' && VERDICT_ORDER[r.verdict] >= VERDICT_ORDER[threshold],
+  );
+  return { results, flagged, ok: flagged.length === 0 };
+}