videoclaw 3.0.0-alpha.1

package/src/video/prompt-quality.ts

@@ -0,0 +1,635 @@
+export type PromptQualitySeverity = 'warn' | 'error';
+
+export type PromptQualityIssueCode =
+  | 'prompt-quality-adjective-soup'
+  | 'prompt-quality-multiple-actions'
+  | 'prompt-quality-multiple-camera-moves'
+  | 'prompt-quality-style-word-overload'
+  | 'prompt-quality-literary-emotion'
+  | 'prompt-quality-overlong'
+  | 'negative-direction'
+  | 'multi-shot-timecode-parse'
+  | 'multi-shot-timecode-start'
+  | 'multi-shot-timecode-gap'
+  | 'multi-shot-timecode-total'
+  | 'multi-shot-shot-duration'
+  | 'multi-shot-shot-count-out-of-range'
+  | 'multi-shot-overlong'
+  | 'multi-shot-repeated-parameter'
+  | 'multi-shot-missing-metadata';
+
+export interface PromptQualityIssue {
+  code: PromptQualityIssueCode;
+  severity: PromptQualitySeverity;
+  message: string;
+}
+
+export interface PromptQualityIssueExplanation {
+  code: PromptQualityIssueCode;
+  summary: string;
+  suggestedFix: string;
+}
+
+const MULTI_SHOT_ISSUE_EXPLANATIONS: Record<
+  Extract<PromptQualityIssueCode, `multi-shot-${string}`>,
+  PromptQualityIssueExplanation
+> = {
+  'multi-shot-timecode-parse': {
+    code: 'multi-shot-timecode-parse',
+    summary: 'No valid multi-shot timecode lines were found.',
+    suggestedFix: 'Start each shot paragraph with a bracketed range like [00:00 - 00:04].',
+  },
+  'multi-shot-timecode-start': {
+    code: 'multi-shot-timecode-start',
+    summary: 'The first shot does not begin at the start of the clip.',
+    suggestedFix: 'Change the first shot start time to 00:00 and adjust following ranges contiguously.',
+  },
+  'multi-shot-timecode-gap': {
+    code: 'multi-shot-timecode-gap',
+    summary: 'The shot ranges have a gap or overlap.',
+    suggestedFix: 'Make every shot start exactly where the previous shot ends.',
+  },
+  'multi-shot-timecode-total': {
+    code: 'multi-shot-timecode-total',
+    summary: 'The final shot does not end at the preset clip duration.',
+    suggestedFix: 'Adjust shot durations so the sequence total exactly matches the selected preset.',
+  },
+  'multi-shot-shot-duration': {
+    code: 'multi-shot-shot-duration',
+    summary: 'At least one shot is outside the preset per-shot duration bounds.',
+    suggestedFix: 'Resize that shot to fit the preset minimum and maximum duration, then rebalance adjacent shots.',
+  },
+  'multi-shot-shot-count-out-of-range': {
+    code: 'multi-shot-shot-count-out-of-range',
+    summary: 'The number of shots is outside the selected preset window.',
+    suggestedFix: 'Add or remove shot paragraphs until the count is inside the preset min/max shot range.',
+  },
+  'multi-shot-overlong': {
+    code: 'multi-shot-overlong',
+    summary: 'The prompt exceeds the selected preset character budget.',
+    suggestedFix: 'Shorten adjectives first, then compress repeated subject references and shared location details.',
+  },
+  'multi-shot-repeated-parameter': {
+    code: 'multi-shot-repeated-parameter',
+    summary: 'Two consecutive shots repeat a camera parameter.',
+    suggestedFix: 'Vary the repeated shot size, lens, angle, or movement in one of the adjacent shots.',
+  },
+  'multi-shot-missing-metadata': {
+    code: 'multi-shot-missing-metadata',
+    summary: 'The required Location, Style, or Audio metadata block is incomplete.',
+    suggestedFix: 'End the prompt with Location:, Style:, and Audio: lines after the final shot paragraph.',
+  },
+};
+
+export function explainPromptQualityIssue(
+  code: PromptQualityIssueCode,
+): PromptQualityIssueExplanation | undefined {
+  if (code.startsWith('multi-shot-')) {
+    return MULTI_SHOT_ISSUE_EXPLANATIONS[code as Extract<PromptQualityIssueCode, `multi-shot-${string}`>];
+  }
+  return undefined;
+}
+
+export function explainPromptQualityIssues(
+  issues: readonly PromptQualityIssue[],
+): PromptQualityIssueExplanation[] {
+  const seen = new Set<PromptQualityIssueCode>();
+  const out: PromptQualityIssueExplanation[] = [];
+  for (const issue of issues) {
+    if (seen.has(issue.code)) continue;
+    seen.add(issue.code);
+    const explanation = explainPromptQualityIssue(issue.code);
+    if (explanation) out.push(explanation);
+  }
+  return out;
+}
+
+export function listMultiShotIssueExplanations(): PromptQualityIssueExplanation[] {
+  return Object.values(MULTI_SHOT_ISSUE_EXPLANATIONS);
+}
+
+export const ADJECTIVE_SOUP_THRESHOLD = 4;
+export const STYLE_WORDS_THRESHOLD = 3;
+export const OVERLONG_WORDS_THRESHOLD = 120;
+
+export const CAMERA_MOVE_VOCABULARY = [
+  'push-in',
+  'pull-out',
+  'tracking',
+  'orbit',
+  'static',
+  'locked-off',
+  'crane reveal',
+  'crane',
+  'dolly',
+  'pan',
+  'tilt',
+  'zoom',
+  'handheld',
+  'steadicam',
+] as const;
+
+export const SHOT_TYPE_VOCABULARY = [
+  'establishing shot',
+  'close-up',
+  'wide shot',
+  'medium shot',
+] as const;
+
+// Canonical multi-shot camera-grid parameter vocabularies. These live here
+// (alongside CAMERA_MOVE_VOCABULARY) so both multi-shot-prompt.ts (which builds
+// plans) and runMultiShotChecks (which validates them) share one source of
+// truth and cannot silently diverge. multi-shot-prompt.ts imports these.
+export const SHOT_SIZE_VOCABULARY = [
+  'wide',
+  'medium',
+  'medium close-up',
+  'close-up',
+  'macro',
+] as const;
+
+export const LENS_VOCABULARY = ['24mm', '35mm', '50mm', '85mm'] as const;
+
+export const ANGLE_VOCABULARY = [
+  'low angle',
+  'high angle',
+  'eye-level',
+  'over-the-shoulder',
+  'Dutch angle',
+] as const;
+
+export const STYLE_VOCABULARY = [
+  'cinematic',
+  'epic',
+  'atmospheric',
+  'ethereal',
+  'hyperrealistic',
+  'photorealistic',
+  'surreal',
+  'dramatic',
+  'moody',
+  'vibrant',
+  'nostalgic',
+  'gritty',
+  'dreamy',
+  'stylized',
+] as const;
+
+export const EMOTION_LANGUAGE_PATTERNS: RegExp[] = [
+  /\b(feels|seems|appears|evokes|conveys)\s+\w+/gi,
+  /\b(profound|deep|overwhelming|ethereal)\s+(sadness|joy|longing|feeling)\b/gi,
+];
+
+function currentSeverity(): PromptQualitySeverity {
+  return process.env.DIRECTOR_STRICT_PROMPT_QUALITY === '1' ? 'error' : 'warn';
+}
+
+const ADJECTIVE_SUFFIX_PATTERN = /(?:y|ed|ing|ous|ful|less|ish|ive|ant|ent|ic|al)$/i;
+
+const ADJECTIVE_WHITELIST = new Set([
+  'tall', 'short', 'big', 'small', 'old', 'young', 'new', 'hot', 'cold',
+  'warm', 'cool', 'fast', 'slow', 'soft', 'hard', 'dark', 'light', 'pale',
+  'bright', 'dim', 'quiet', 'loud', 'stoic', 'calm', 'tense', 'sharp',
+]);
+
+function countAdjectives(clause: string): number {
+  // Comma-separated modifier tokens in one clause.
+  const parts = clause.split(',').map((piece) => piece.trim()).filter(Boolean);
+  if (parts.length < 2) {
+    return 0;
+  }
+  // All comma-separated pieces except the final one are modifier positions.
+  // The last piece typically contains the noun and verb.
+  const modifiers = parts.slice(0, -1);
+  let count = 0;
+  for (const raw of modifiers) {
+    // Use the last word of the modifier segment as the candidate adjective.
+    const tokens = raw.split(/\s+/);
+    const candidate = (tokens[tokens.length - 1] ?? '').toLowerCase().replace(/[^a-z-]/g, '');
+    if (!candidate) continue;
+    if (ADJECTIVE_WHITELIST.has(candidate) || ADJECTIVE_SUFFIX_PATTERN.test(candidate) || candidate.includes('-')) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function checkOverlongPrompt(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  const words = prompt.trim().split(/\s+/).filter(Boolean);
+  if (words.length > OVERLONG_WORDS_THRESHOLD) {
+    return {
+      code: 'prompt-quality-overlong',
+      severity,
+      message: `prompt is ${words.length} words (threshold: ${OVERLONG_WORDS_THRESHOLD}); tighten to one shot`,
+    };
+  }
+  return null;
+}
+
+function checkLiteraryEmotion(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  for (const raw of EMOTION_LANGUAGE_PATTERNS) {
+    const pattern = new RegExp(raw.source, raw.flags);
+    const match = pattern.exec(prompt);
+    if (match) {
+      return {
+        code: 'prompt-quality-literary-emotion',
+        severity,
+        message: `prompt uses literary/inner-state language ("${match[0]}"); describe visible behavior instead`,
+      };
+    }
+  }
+  return null;
+}
+
+function checkStyleWordOverload(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  const matches: string[] = [];
+  for (const term of STYLE_VOCABULARY) {
+    const pattern = new RegExp(`\\b${term}\\b`, 'gi');
+    const found = prompt.match(pattern);
+    if (found && found.length > 0) {
+      matches.push(term);
+    }
+  }
+  if (matches.length > STYLE_WORDS_THRESHOLD) {
+    return {
+      code: 'prompt-quality-style-word-overload',
+      severity,
+      message: `prompt stacks ${matches.length} style words (threshold: ${STYLE_WORDS_THRESHOLD}): ${matches.join(', ')}`,
+    };
+  }
+  return null;
+}
+
+interface CameraMovePattern {
+  canonical: string;
+  label: string;
+  pattern: RegExp;
+}
+
+const CAMERA_MOVE_PATTERNS: CameraMovePattern[] = [
+  {
+    canonical: 'push-in',
+    label: 'push-in',
+    pattern: /\b(?:push(?:es|ed|ing)?[-\s]?in|doll(?:y|ies|ied|ying)\s+in)\b/gi,
+  },
+  {
+    canonical: 'pull-out',
+    label: 'pull-out',
+    pattern: /\b(?:pull(?:s|ed|ing)?[-\s]?out|doll(?:y|ies|ied|ying)\s+out)\b/gi,
+  },
+  {
+    canonical: 'tracking',
+    label: 'tracking',
+    pattern: /\btrack(?:s|ed|ing)?\b/gi,
+  },
+  {
+    canonical: 'orbit',
+    label: 'orbit',
+    pattern: /\borbit(?:s|ed|ing)?\b/gi,
+  },
+  {
+    canonical: 'static',
+    label: 'static/locked-off',
+    pattern: /\b(?:static(?:\s+camera)?|locked[-\s]?off)\b/gi,
+  },
+  {
+    canonical: 'crane reveal',
+    label: 'crane reveal',
+    pattern: /\bcrane(?:s|d|ing)?(?:\s+reveal)?\b/gi,
+  },
+  {
+    canonical: 'dolly',
+    label: 'dolly',
+    pattern: /\bdoll(?:y|ies|ied|ying)\b(?!\s+(?:in|out)\b)/gi,
+  },
+  {
+    canonical: 'pan',
+    label: 'pan',
+    pattern: /\bpan(?:s|ned|ning)?\b/gi,
+  },
+  {
+    canonical: 'tilt',
+    label: 'tilt',
+    pattern: /\btilt(?:s|ed|ing)?\b/gi,
+  },
+  {
+    canonical: 'zoom',
+    label: 'zoom',
+    pattern: /\bzoom(?:s|ed|ing)?\b/gi,
+  },
+  {
+    canonical: 'handheld',
+    label: 'handheld',
+    pattern: /\bhandheld\b/gi,
+  },
+  {
+    canonical: 'steadicam',
+    label: 'steadicam',
+    pattern: /\bsteadicam\b/gi,
+  },
+];
+
+function checkMultipleCameraMoves(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  const matches = new Map<string, string>();
+  const counts = new Map<string, number>();
+  for (const move of CAMERA_MOVE_PATTERNS) {
+    const pattern = new RegExp(move.pattern.source, move.pattern.flags);
+    const found = prompt.match(pattern);
+    if (found && found.length > 0) {
+      matches.set(move.canonical, move.label);
+      counts.set(move.canonical, (counts.get(move.canonical) ?? 0) + found.length);
+    }
+  }
+  const repeatsSameMove = [...counts].some(([canonical, count]) => canonical !== 'static' && count > 1);
+  if (matches.size > 1 || repeatsSameMove) {
+    return {
+      code: 'prompt-quality-multiple-camera-moves',
+      severity,
+      message: `prompt references multiple camera moves (${[...matches.values()].join(', ')}); pick one per shot`,
+    };
+  }
+  return null;
+}
+
+const COMMON_ACTION_VERBS = new Set([
+  'walks', 'runs', 'sits', 'stands', 'opens', 'closes', 'picks', 'places',
+  'turns', 'orders', 'checks', 'lifts', 'sets', 'grabs', 'pushes', 'pulls',
+  'enters', 'leaves', 'drops', 'catches', 'throws', 'holds', 'reaches',
+]);
+
+function checkMultipleActions(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  const clauses = prompt.split(/[.;]/);
+  for (const clause of clauses) {
+    const tokens = clause.toLowerCase().match(/\b[a-z]+\b/g) ?? [];
+    let actionCount = 0;
+    for (const token of tokens) {
+      if (COMMON_ACTION_VERBS.has(token)) {
+        actionCount += 1;
+      } else if (token.length > 3 && token.endsWith('s') && !token.endsWith('ss')) {
+        // Heuristic: present-tense third-person verb ending in -s.
+        // Require a trailing comma or conjunction context to avoid plural nouns.
+        // We use a regex check below instead.
+      }
+    }
+    // Additional heuristic: count action-style "<verb>s" tokens that sit
+    // immediately before a comma — a reliable signal of serial actions.
+    const commaPrecededVerbs = clause.match(/\b[a-z]+s(?=\s*,)/gi) ?? [];
+    for (const raw of commaPrecededVerbs) {
+      const token = raw.toLowerCase();
+      if (COMMON_ACTION_VERBS.has(token)) continue; // already counted
+      if (token.length > 3 && !token.endsWith('ss') && !token.endsWith('is') && !token.endsWith('us')) {
+        actionCount += 1;
+      }
+    }
+    if (actionCount > 1) {
+      return {
+        code: 'prompt-quality-multiple-actions',
+        severity,
+        message: `clause has ${actionCount} dominant actions (threshold: 1): "${clause.trim()}"`,
+      };
+    }
+  }
+  return null;
+}
+
+function checkAdjectiveSoup(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  const clauses = prompt.split(/[.;]/);
+  for (const clause of clauses) {
+    const adjectives = countAdjectives(clause);
+    if (adjectives > ADJECTIVE_SOUP_THRESHOLD) {
+      return {
+        code: 'prompt-quality-adjective-soup',
+        severity,
+        message: `clause has ${adjectives} adjectives (threshold: ${ADJECTIVE_SOUP_THRESHOLD}): "${clause.trim()}"`,
+      };
+    }
+  }
+  return null;
+}
+
+const SANCTIONED_NEGATIONS = [
+  /no on-?screen text/i, /no captions?/i, /no signage/i, /no rendered text/i,
+  /specular[^.]*removed/i, /no .*shine/i, /no oily/i, /never .*plastic/i, /no acne|no blemish/i,
+];
+const NEGATIVE_DIRECTION = /\b(no|dont|don't|avoid|without|never)\b[^.]*\b(slow[- ]?motion|blur|fast|motion|movement|camera shake|zoom)\b/i;
+
+function checkNegativeDirection(
+  prompt: string,
+  severity: PromptQualitySeverity,
+): PromptQualityIssue | null {
+  for (const s of prompt.split(/(?<=[.!?])\s+/)) {
+    if (NEGATIVE_DIRECTION.test(s) && !SANCTIONED_NEGATIONS.some((re) => re.test(s))) {
+      return {
+        code: 'negative-direction',
+        severity,
+        message: `negative direction ("${s.trim().slice(0, 60)}") — these models ignore negated motion/tempo; rephrase as positive ("smooth controlled push-in", "crisp focus"). Negatives are only sanctioned for on-screen text, specular kill, and anti-plastic.`,
+      };
+    }
+  }
+  return null;
+}
+
+export function runPromptQualityChecks(prompt: string): PromptQualityIssue[] {
+  const severity = currentSeverity();
+  const issues: PromptQualityIssue[] = [];
+  const adjectiveSoup = checkAdjectiveSoup(prompt, severity);
+  if (adjectiveSoup) issues.push(adjectiveSoup);
+  const multipleActions = checkMultipleActions(prompt, severity);
+  if (multipleActions) issues.push(multipleActions);
+  const multipleMoves = checkMultipleCameraMoves(prompt, severity);
+  if (multipleMoves) issues.push(multipleMoves);
+  const styleOverload = checkStyleWordOverload(prompt, severity);
+  if (styleOverload) issues.push(styleOverload);
+  const literary = checkLiteraryEmotion(prompt, severity);
+  if (literary) issues.push(literary);
+  const overlong = checkOverlongPrompt(prompt, severity);
+  if (overlong) issues.push(overlong);
+  const negativeDirection = checkNegativeDirection(prompt, severity);
+  if (negativeDirection) issues.push(negativeDirection);
+  return issues;
+}
+
+// ---------------------------------------------------------------------------
+// Multi-shot validator
+// ---------------------------------------------------------------------------
+// NOTE: `multi-shot-prompt.ts` imports CAMERA_MOVE_VOCABULARY FROM this file.
+// We import only the TYPE `MultiShotPreset` here so the import is erased at
+// compile time — no runtime cycle.
+import type { MultiShotPreset } from './multi-shot-prompt.js';
+
+// Derived from the canonical vocab constants above so the validator's match
+// lists can't drift from what multi-shot-prompt.ts uses to build plans.
+const MULTI_SHOT_SHOT_SIZES = SHOT_SIZE_VOCABULARY.map((s) => s.toLowerCase());
+const MULTI_SHOT_LENSES = LENS_VOCABULARY.map((s) => s.toLowerCase());
+const MULTI_SHOT_ANGLES = ANGLE_VOCABULARY.map((s) => s.toLowerCase());
+
+const TIMECODE_RE = /\[(\d{2}):(\d{2})\s*-\s*(\d{2}):(\d{2})\]/g;
+
+function toSeconds(mm: string, ss: string): number {
+  return Number(mm) * 60 + Number(ss);
+}
+
+function firstMatch(haystack: string, pool: string[]): string | undefined {
+  // Normalise both sides: lowercase + replace hyphens with spaces so that
+  // hand-authored "push in" matches vocab term "push-in", "close up" matches
+  // "close-up", "eye level" matches "eye-level", etc.  The canonical term
+  // returned is the original (pre-normalisation) pool entry so downstream
+  // equality comparisons (consecutive-repeat detection) remain stable.
+  const normHaystack = haystack.toLowerCase().replace(/-/g, ' ');
+  // Longest-first so "medium close-up" wins over "medium".
+  for (const term of [...pool].sort((a, b) => b.length - a.length)) {
+    const normTerm = term.toLowerCase().replace(/-/g, ' ');
+    if (normHaystack.includes(normTerm)) return term;
+  }
+  return undefined;
+}
+
+export function runMultiShotChecks(
+  prompt: string,
+  preset: MultiShotPreset,
+): PromptQualityIssue[] {
+  // Multi-shot issues are structural (timecode contiguity, durations, metadata),
+  // so they are always errors — unlike the stylistic runPromptQualityChecks,
+  // which downgrades to warnings unless DIRECTOR_STRICT_PROMPT_QUALITY=1.
+  const severity: PromptQualitySeverity = 'error';
+  const issues: PromptQualityIssue[] = [];
+
+  // Character budget.
+  if (prompt.length > preset.maxChars) {
+    issues.push({
+      code: 'multi-shot-overlong',
+      severity,
+      message: `prompt is ${prompt.length} chars (max ${preset.maxChars})`,
+    });
+  }
+
+  // Metadata block.
+  const hasLocation = /^Location:\s*\S/m.test(prompt);
+  const hasStyle = /^Style:\s*\S/m.test(prompt);
+  const hasAudio = /^Audio:\s*\S/m.test(prompt);
+  if (!hasLocation || !hasStyle || !hasAudio) {
+    issues.push({
+      code: 'multi-shot-missing-metadata',
+      severity,
+      message: `missing metadata line(s): ${[!hasLocation && 'Location', !hasStyle && 'Style', !hasAudio && 'Audio'].filter(Boolean).join(', ')}`,
+    });
+  }
+
+  // Parse timecodes and per-shot lines.
+  const shots: Array<{ start: number; end: number; line: string }> = [];
+  const lines = prompt.split('\n').filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    TIMECODE_RE.lastIndex = 0;
+    const m = TIMECODE_RE.exec(line);
+    if (m) {
+      shots.push({ start: toSeconds(m[1], m[2]), end: toSeconds(m[3], m[4]), line });
+    }
+  }
+
+  if (shots.length === 0) {
+    issues.push({
+      code: 'multi-shot-timecode-parse',
+      severity,
+      message: 'no parseable timecode stamps found',
+    });
+    return issues;
+  }
+
+  if (shots[0].start !== 0) {
+    issues.push({
+      code: 'multi-shot-timecode-start',
+      severity,
+      message: `first shot starts at ${shots[0].start}s (must start at 0)`,
+    });
+  }
+
+  for (let i = 0; i < shots.length; i += 1) {
+    const dur = shots[i].end - shots[i].start;
+    if (dur < preset.minShotSeconds || dur > preset.maxShotSeconds) {
+      issues.push({
+        code: 'multi-shot-shot-duration',
+        severity,
+        message: `shot ${i + 1} is ${dur}s (allowed ${preset.minShotSeconds}-${preset.maxShotSeconds}s)`,
+      });
+    }
+    if (i > 0 && shots[i].start !== shots[i - 1].end) {
+      issues.push({
+        code: 'multi-shot-timecode-gap',
+        severity,
+        message: shots[i].start < shots[i - 1].end
+          ? `shot ${i + 1} overlaps: starts at ${shots[i].start}s but previous ends at ${shots[i - 1].end}s`
+          : `shot ${i + 1} has a gap: starts at ${shots[i].start}s but previous ends at ${shots[i - 1].end}s`,
+      });
+    }
+  }
+
+  const total = shots[shots.length - 1].end - shots[0].start;
+  if (total !== preset.totalSeconds) {
+    issues.push({
+      code: 'multi-shot-timecode-total',
+      severity,
+      message: `sequence totals ${total}s (must be exactly ${preset.totalSeconds}s)`,
+    });
+  }
+
+  // Shot-count window check. Branched message so operators see direction.
+  if (shots.length < preset.minShots) {
+    issues.push({
+      code: 'multi-shot-shot-count-out-of-range',
+      severity,
+      message: `too few shots: ${shots.length} < preset.minShots=${preset.minShots} (preset "${preset.name}")`,
+    });
+  } else if (shots.length > preset.maxShots) {
+    issues.push({
+      code: 'multi-shot-shot-count-out-of-range',
+      severity,
+      message: `too many shots: ${shots.length} > preset.maxShots=${preset.maxShots} (preset "${preset.name}")`,
+    });
+  }
+
+  // Consecutive-parameter repetition (size, lens, angle, movement).
+  let prev: { size?: string; lens?: string; angle?: string; move?: string } = {};
+  for (let i = 0; i < shots.length; i += 1) {
+    const size = firstMatch(shots[i].line, MULTI_SHOT_SHOT_SIZES);
+    const lens = firstMatch(shots[i].line, MULTI_SHOT_LENSES);
+    const angle = firstMatch(shots[i].line, MULTI_SHOT_ANGLES);
+    const move = firstMatch(shots[i].line, [...CAMERA_MOVE_VOCABULARY]);
+    if (i > 0) {
+      for (const [label, cur, was] of [
+        ['shot size', size, prev.size],
+        ['lens', lens, prev.lens],
+        ['angle', angle, prev.angle],
+        ['movement', move, prev.move],
+      ] as const) {
+        if (cur && was && cur === was) {
+          issues.push({
+            code: 'multi-shot-repeated-parameter',
+            severity,
+            message: `shot ${i + 1} repeats ${label} "${cur}" from the previous shot`,
+          });
+        }
+      }
+    }
+    prev = { size, lens, angle, move };
+  }
+
+  return issues;
+}