aivee 0.1.0-alpha.0 → 0.1.0-dev.d34a6ba

package/src/edits/plan-shot-placements.mjs

@@ -1,105 +1,105 @@
-import { previewTimelineEdit } from '../timeline/edit.mjs';
-import { timelineFingerprint } from '../timeline/fingerprint.mjs';
-
-const MAXIMUM_PLACEMENTS = 500;
-
-/** Build a review-only clip insertion plan from explicit scene-review selections. */
-export function planSceneReviewPlacements(timeline, sceneReview, assetId, trackId, placements) {
-  if (!sceneReview || typeof sceneReview !== 'object' || Array.isArray(sceneReview)
-      || sceneReview.schemaVersion !== 2 || sceneReview.reviewRequired !== true
-      || !/^[a-f0-9]{64}$/.test(sceneReview.sourceSha256 ?? '')
-      || !Array.isArray(sceneReview.shots) || !Number.isFinite(sceneReview.durationSeconds)
-      || sceneReview.durationSeconds <= 0) {
-    throw new TypeError('Scene review must be a schemaVersion 2 review-required pack with a SHA-256 source identity, positive duration, and shots array. Regenerate older packs.');
-  }
-  if (!Array.isArray(placements) || placements.length === 0 || placements.length > MAXIMUM_PLACEMENTS) {
-    throw new TypeError(`placements must contain between 1 and ${MAXIMUM_PLACEMENTS} shot selections.`);
-  }
-  if (typeof assetId !== 'string' || !assetId.trim()) throw new TypeError('assetId must be a non-empty string.');
-  if (typeof trackId !== 'string' || !trackId.trim()) throw new TypeError('trackId must be a non-empty string.');
-
-  const asset = timeline?.assets?.find((candidate) => candidate.id === assetId);
-  if (!asset || asset.type !== 'video' || !Number.isFinite(asset.durationSeconds) || asset.durationSeconds <= 0) {
-    throw new TypeError(`B-roll asset ${assetId} must be a registered video asset with a known duration.`);
-  }
-  if (asset.sha256 !== sceneReview.sourceSha256) {
-    throw new TypeError(`B-roll asset ${assetId} does not match the source media used by this scene-review pack.`);
-  }
-  const track = timeline?.tracks?.find((candidate) => candidate.id === trackId);
-  if (!track || track.kind !== 'video') throw new TypeError(`B-roll destination ${trackId} must be an existing video track.`);
-  if (track.locked === true) throw new TypeError(`B-roll destination track ${trackId} is locked.`);
-
-  const shots = new Map();
-  for (const shot of sceneReview.shots) {
-    if (!shot || !Number.isSafeInteger(shot.index) || shot.index < 1
-        || !Number.isFinite(shot.startSeconds) || !Number.isFinite(shot.endSeconds)
-        || shot.startSeconds < 0 || shot.endSeconds <= shot.startSeconds
-        || shot.endSeconds > sceneReview.durationSeconds + 1e-6
-        || shots.has(shot.index)) {
-      throw new TypeError('Scene review contains an invalid or duplicate shot range.');
-    }
-    shots.set(shot.index, shot);
-  }
-
-  const usedClipIds = new Set();
-  const operations = placements.map((placement, index) => {
-    if (!placement || typeof placement !== 'object' || Array.isArray(placement)) {
-      throw new TypeError(`Placement ${index + 1} must be an object.`);
-    }
-    const allowedFields = new Set(['shotIndex', 'timelineStartSeconds', 'sourceOffsetSeconds', 'durationSeconds', 'clipId']);
-    if (Object.keys(placement).some((field) => !allowedFields.has(field))) {
-      throw new TypeError(`Placement ${index + 1} contains an unsupported field.`);
-    }
-    if (Object.values(placement).some((value) => value === undefined)) {
-      throw new TypeError(`Placement ${index + 1} fields must not be undefined.`);
-    }
-    const shot = shots.get(placement.shotIndex);
-    if (!shot) throw new TypeError(`Placement ${index + 1} references unknown shot ${placement.shotIndex}.`);
-    const timelineStart = placement.timelineStartSeconds;
-    const sourceOffset = placement.sourceOffsetSeconds ?? 0;
-    if (!Number.isFinite(timelineStart) || timelineStart < 0) {
-      throw new TypeError(`Placement ${index + 1} timelineStartSeconds must be non-negative.`);
-    }
-    if (!Number.isFinite(sourceOffset) || sourceOffset < 0 || sourceOffset >= shot.endSeconds - shot.startSeconds) {
-      throw new TypeError(`Placement ${index + 1} sourceOffsetSeconds must fall within shot ${shot.index}.`);
-    }
-    const sourceIn = shot.startSeconds + sourceOffset;
-    const durationSeconds = placement.durationSeconds ?? shot.endSeconds - sourceIn;
-    if (!Number.isFinite(durationSeconds) || durationSeconds <= 0
-        || sourceIn + durationSeconds > shot.endSeconds + 1e-6) {
-      throw new TypeError(`Placement ${index + 1} durationSeconds must fit within shot ${shot.index}.`);
-    }
-    if (sourceIn + durationSeconds > asset.durationSeconds + 1e-6) {
-      throw new TypeError(`Placement ${index + 1} source range exceeds B-roll asset ${assetId}.`);
-    }
-    const clipId = placement.clipId ?? `broll-shot-${String(index + 1).padStart(4, '0')}`;
-    if (!/^[a-z][a-z0-9-]*$/.test(clipId) || usedClipIds.has(clipId)) {
-      throw new TypeError(`Placement ${index + 1} clipId must be a unique kebab-case id.`);
-    }
-    usedClipIds.add(clipId);
-    return {
-      type: 'add-clip',
-      trackId,
-      clip: {
-        id: clipId,
-        assetId,
-        timelineStart,
-        sourceIn,
-        sourceOut: sourceIn + durationSeconds,
-        durationSeconds,
-      },
-    };
-  });
-
-  return {
-    schemaVersion: 1,
-    type: 'scene-review-placement-plan',
-    reviewRequired: true,
-    baseTimelineSha256: timelineFingerprint(timeline),
-    sourceSha256: sceneReview.sourceSha256,
-    assetId,
-    trackId,
-    operations,
-    preview: previewTimelineEdit(timeline, operations),
-  };
-}
+import { previewTimelineEdit } from '../timeline/edit.mjs';
+import { timelineFingerprint } from '../timeline/fingerprint.mjs';
+
+const MAXIMUM_PLACEMENTS = 500;
+
+/** Build a review-only clip insertion plan from explicit scene-review selections. */
+export function planSceneReviewPlacements(timeline, sceneReview, assetId, trackId, placements) {
+  if (!sceneReview || typeof sceneReview !== 'object' || Array.isArray(sceneReview)
+      || sceneReview.schemaVersion !== 2 || sceneReview.reviewRequired !== true
+      || !/^[a-f0-9]{64}$/.test(sceneReview.sourceSha256 ?? '')
+      || !Array.isArray(sceneReview.shots) || !Number.isFinite(sceneReview.durationSeconds)
+      || sceneReview.durationSeconds <= 0) {
+    throw new TypeError('Scene review must be a schemaVersion 2 review-required pack with a SHA-256 source identity, positive duration, and shots array. Regenerate older packs.');
+  }
+  if (!Array.isArray(placements) || placements.length === 0 || placements.length > MAXIMUM_PLACEMENTS) {
+    throw new TypeError(`placements must contain between 1 and ${MAXIMUM_PLACEMENTS} shot selections.`);
+  }
+  if (typeof assetId !== 'string' || !assetId.trim()) throw new TypeError('assetId must be a non-empty string.');
+  if (typeof trackId !== 'string' || !trackId.trim()) throw new TypeError('trackId must be a non-empty string.');
+
+  const asset = timeline?.assets?.find((candidate) => candidate.id === assetId);
+  if (!asset || asset.type !== 'video' || !Number.isFinite(asset.durationSeconds) || asset.durationSeconds <= 0) {
+    throw new TypeError(`B-roll asset ${assetId} must be a registered video asset with a known duration.`);
+  }
+  if (asset.sha256 !== sceneReview.sourceSha256) {
+    throw new TypeError(`B-roll asset ${assetId} does not match the source media used by this scene-review pack.`);
+  }
+  const track = timeline?.tracks?.find((candidate) => candidate.id === trackId);
+  if (!track || track.kind !== 'video') throw new TypeError(`B-roll destination ${trackId} must be an existing video track.`);
+  if (track.locked === true) throw new TypeError(`B-roll destination track ${trackId} is locked.`);
+
+  const shots = new Map();
+  for (const shot of sceneReview.shots) {
+    if (!shot || !Number.isSafeInteger(shot.index) || shot.index < 1
+        || !Number.isFinite(shot.startSeconds) || !Number.isFinite(shot.endSeconds)
+        || shot.startSeconds < 0 || shot.endSeconds <= shot.startSeconds
+        || shot.endSeconds > sceneReview.durationSeconds + 1e-6
+        || shots.has(shot.index)) {
+      throw new TypeError('Scene review contains an invalid or duplicate shot range.');
+    }
+    shots.set(shot.index, shot);
+  }
+
+  const usedClipIds = new Set();
+  const operations = placements.map((placement, index) => {
+    if (!placement || typeof placement !== 'object' || Array.isArray(placement)) {
+      throw new TypeError(`Placement ${index + 1} must be an object.`);
+    }
+    const allowedFields = new Set(['shotIndex', 'timelineStartSeconds', 'sourceOffsetSeconds', 'durationSeconds', 'clipId']);
+    if (Object.keys(placement).some((field) => !allowedFields.has(field))) {
+      throw new TypeError(`Placement ${index + 1} contains an unsupported field.`);
+    }
+    if (Object.values(placement).some((value) => value === undefined)) {
+      throw new TypeError(`Placement ${index + 1} fields must not be undefined.`);
+    }
+    const shot = shots.get(placement.shotIndex);
+    if (!shot) throw new TypeError(`Placement ${index + 1} references unknown shot ${placement.shotIndex}.`);
+    const timelineStart = placement.timelineStartSeconds;
+    const sourceOffset = placement.sourceOffsetSeconds ?? 0;
+    if (!Number.isFinite(timelineStart) || timelineStart < 0) {
+      throw new TypeError(`Placement ${index + 1} timelineStartSeconds must be non-negative.`);
+    }
+    if (!Number.isFinite(sourceOffset) || sourceOffset < 0 || sourceOffset >= shot.endSeconds - shot.startSeconds) {
+      throw new TypeError(`Placement ${index + 1} sourceOffsetSeconds must fall within shot ${shot.index}.`);
+    }
+    const sourceIn = shot.startSeconds + sourceOffset;
+    const durationSeconds = placement.durationSeconds ?? shot.endSeconds - sourceIn;
+    if (!Number.isFinite(durationSeconds) || durationSeconds <= 0
+        || sourceIn + durationSeconds > shot.endSeconds + 1e-6) {
+      throw new TypeError(`Placement ${index + 1} durationSeconds must fit within shot ${shot.index}.`);
+    }
+    if (sourceIn + durationSeconds > asset.durationSeconds + 1e-6) {
+      throw new TypeError(`Placement ${index + 1} source range exceeds B-roll asset ${assetId}.`);
+    }
+    const clipId = placement.clipId ?? `broll-shot-${String(index + 1).padStart(4, '0')}`;
+    if (!/^[a-z][a-z0-9-]*$/.test(clipId) || usedClipIds.has(clipId)) {
+      throw new TypeError(`Placement ${index + 1} clipId must be a unique kebab-case id.`);
+    }
+    usedClipIds.add(clipId);
+    return {
+      type: 'add-clip',
+      trackId,
+      clip: {
+        id: clipId,
+        assetId,
+        timelineStart,
+        sourceIn,
+        sourceOut: sourceIn + durationSeconds,
+        durationSeconds,
+      },
+    };
+  });
+
+  return {
+    schemaVersion: 1,
+    type: 'scene-review-placement-plan',
+    reviewRequired: true,
+    baseTimelineSha256: timelineFingerprint(timeline),
+    sourceSha256: sceneReview.sourceSha256,
+    assetId,
+    trackId,
+    operations,
+    preview: previewTimelineEdit(timeline, operations),
+  };
+}

package/src/edits/plan-silence-cuts.mjs

@@ -1,49 +1,49 @@
-import { validateTranscript } from '../transcript/validate.mjs';
-import { validateEdl } from './retime-transcript.mjs';
-
-export function planSilenceCuts(transcript, options = {}) {
-  validateTranscript(transcript);
-  const { minGap = 0.55, headPad = 0.22, tailPad = 0.34 } = options;
-  for (const [name, value] of Object.entries({ minGap, headPad, tailPad })) {
-    if (!Number.isFinite(value) || value < 0 || (name === 'minGap' && value === 0)) {
-      throw new TypeError(`${name} must be ${name === 'minGap' ? 'positive' : 'non-negative'}.`);
-    }
-  }
-  if (transcript.words.length === 0) throw new TypeError('Cannot plan silence cuts without timed words.');
-
-  const words = transcript.words;
-  const cuts = [];
-  const headEnd = words[0].start - headPad;
-  if (headEnd > 0) cuts.push({ sourceStart: 0, sourceEnd: headEnd, reason: 'head silence' });
-
-  for (let index = 1; index < words.length; index++) {
-    const previous = words[index - 1];
-    const next = words[index];
-    const gap = next.start - previous.end;
-    if (gap < minGap) continue;
-
-    const keep = gap >= 2 ? 0.24 : /[.!?]$/.test(previous.text) ? 0.2 : 0.14;
-    const sourceStart = previous.end + keep * 0.55;
-    const sourceEnd = next.start - keep * 0.45;
-    if (sourceEnd > sourceStart) {
-      cuts.push({
-        sourceStart: round(sourceStart),
-        sourceEnd: round(sourceEnd),
-        reason: `pause ${gap.toFixed(2)}s shortened to ${keep.toFixed(2)}s`,
-      });
-    }
-  }
-
-  const tailStart = words.at(-1).end + tailPad;
-  if (tailStart < transcript.durationSeconds) {
-    cuts.push({ sourceStart: tailStart, sourceEnd: transcript.durationSeconds, reason: 'tail silence' });
-  }
-
-  const edl = { schemaVersion: 1, sourceDurationSeconds: transcript.durationSeconds, cuts };
-  validateEdl(edl, transcript.durationSeconds);
-  return edl;
-}
-
-function round(value) {
-  return Number(value.toFixed(3));
-}
+import { validateTranscript } from '../transcript/validate.mjs';
+import { validateEdl } from './retime-transcript.mjs';
+
+export function planSilenceCuts(transcript, options = {}) {
+  validateTranscript(transcript);
+  const { minGap = 0.55, headPad = 0.22, tailPad = 0.34 } = options;
+  for (const [name, value] of Object.entries({ minGap, headPad, tailPad })) {
+    if (!Number.isFinite(value) || value < 0 || (name === 'minGap' && value === 0)) {
+      throw new TypeError(`${name} must be ${name === 'minGap' ? 'positive' : 'non-negative'}.`);
+    }
+  }
+  if (transcript.words.length === 0) throw new TypeError('Cannot plan silence cuts without timed words.');
+
+  const words = transcript.words;
+  const cuts = [];
+  const headEnd = words[0].start - headPad;
+  if (headEnd > 0) cuts.push({ sourceStart: 0, sourceEnd: headEnd, reason: 'head silence' });
+
+  for (let index = 1; index < words.length; index++) {
+    const previous = words[index - 1];
+    const next = words[index];
+    const gap = next.start - previous.end;
+    if (gap < minGap) continue;
+
+    const keep = gap >= 2 ? 0.24 : /[.!?]$/.test(previous.text) ? 0.2 : 0.14;
+    const sourceStart = previous.end + keep * 0.55;
+    const sourceEnd = next.start - keep * 0.45;
+    if (sourceEnd > sourceStart) {
+      cuts.push({
+        sourceStart: round(sourceStart),
+        sourceEnd: round(sourceEnd),
+        reason: `pause ${gap.toFixed(2)}s shortened to ${keep.toFixed(2)}s`,
+      });
+    }
+  }
+
+  const tailStart = words.at(-1).end + tailPad;
+  if (tailStart < transcript.durationSeconds) {
+    cuts.push({ sourceStart: tailStart, sourceEnd: transcript.durationSeconds, reason: 'tail silence' });
+  }
+
+  const edl = { schemaVersion: 1, sourceDurationSeconds: transcript.durationSeconds, cuts };
+  validateEdl(edl, transcript.durationSeconds);
+  return edl;
+}
+
+function round(value) {
+  return Number(value.toFixed(3));
+}

package/src/edits/retime-transcript.mjs

@@ -1,105 +1,105 @@
-import { validateTranscript } from '../transcript/validate.mjs';
-
-export function retimeTranscript(transcript, edl) {
-  validateTranscript(transcript);
-  validateEdl(edl, transcript.durationSeconds);
-  assertEdlApproved(edl);
-
-  const words = transcript.words.flatMap((word) => {
-    const containingCut = edl.cuts.find(
-      (cut) => cut.sourceStart <= word.start && cut.sourceEnd >= word.end
-    );
-    if (containingCut) return [];
-
-    const partialCut = edl.cuts.find(
-      (cut) => cut.sourceStart < word.end && cut.sourceEnd > word.start
-    );
-    if (partialCut) {
-      throw new TypeError(`EDL cut ${partialCut.sourceStart}-${partialCut.sourceEnd} splits transcript word "${word.text}".`);
-    }
-
-    const removedBefore = edl.cuts
-      .filter((cut) => cut.sourceEnd <= word.start)
-      .reduce((total, cut) => total + cut.sourceEnd - cut.sourceStart, 0);
-    return [{ ...word, start: word.start - removedBefore, end: word.end - removedBefore }];
-  });
-
-  const removedDuration = edl.cuts.reduce(
-    (total, cut) => total + cut.sourceEnd - cut.sourceStart,
-    0
-  );
-  if (removedDuration >= transcript.durationSeconds) {
-    throw new TypeError('EDL must leave a positive output duration.');
-  }
-  return {
-    schemaVersion: 1,
-    durationSeconds: transcript.durationSeconds - removedDuration,
-    ...(transcript.granularity ? { granularity: transcript.granularity } : {}),
-    words,
-  };
-}
-
-export function validateEdl(edl, sourceDurationSeconds) {
-  if (!edl || typeof edl !== 'object' || Array.isArray(edl)) {
-    throw new TypeError('EDL must be a JSON object.');
-  }
-  if (edl.schemaVersion !== 1) {
-    throw new TypeError('EDL schemaVersion must be 1.');
-  }
-  if (!Number.isFinite(edl.sourceDurationSeconds) || edl.sourceDurationSeconds <= 0) {
-    throw new TypeError('EDL sourceDurationSeconds must be a positive number.');
-  }
-  if (Math.abs(edl.sourceDurationSeconds - sourceDurationSeconds) > 1e-6) {
-    throw new TypeError('EDL sourceDurationSeconds must match the transcript duration.');
-  }
-  if (edl.reviewStatus !== undefined && !['needs-review', 'approved'].includes(edl.reviewStatus)) {
-    throw new TypeError('EDL reviewStatus must be needs-review or approved.');
-  }
-  if (!Array.isArray(edl.cuts)) {
-    throw new TypeError('EDL cuts must be an array.');
-  }
-
-  let previousEnd = 0;
-  for (const [index, cut] of edl.cuts.entries()) {
-    const label = `EDL cut ${index + 1}`;
-    if (!cut || typeof cut !== 'object' || Array.isArray(cut)) {
-      throw new TypeError(`${label} must be an object.`);
-    }
-    if (!Number.isFinite(cut.sourceStart) || !Number.isFinite(cut.sourceEnd) || cut.sourceStart < 0 || cut.sourceEnd <= cut.sourceStart) {
-      throw new TypeError(`${label} must have finite times with 0 <= sourceStart < sourceEnd.`);
-    }
-    if (cut.sourceEnd > sourceDurationSeconds) {
-      throw new TypeError(`${label} ends after the source duration.`);
-    }
-    if (cut.sourceStart < previousEnd) {
-      throw new TypeError(`${label} overlaps or is out of order.`);
-    }
-    if (typeof cut.reason !== 'string' || !cut.reason.trim()) {
-      throw new TypeError(`${label} reason must be a non-empty string.`);
-    }
-    previousEnd = cut.sourceEnd;
-  }
-  const removedDuration = edl.cuts.reduce(
-    (total, cut) => total + cut.sourceEnd - cut.sourceStart,
-    0
-  );
-  if (removedDuration >= sourceDurationSeconds) {
-    throw new TypeError('EDL must leave a positive output duration.');
-  }
-  return edl;
-}
-
-export function approveEdl(edl) {
-  validateEdl(edl, edl?.sourceDurationSeconds);
-  if (edl.reviewStatus !== 'needs-review') throw new TypeError('Only an EDL marked needs-review can be approved.');
-  const approved = structuredClone(edl);
-  approved.reviewStatus = 'approved';
-  return approved;
-}
-
-export function assertEdlApproved(edl) {
-  if (edl?.reviewStatus === 'needs-review') {
-    throw new TypeError('EDL contains unapproved edit suggestions; review and approve it before editing.');
-  }
-  return edl;
-}
+import { validateTranscript } from '../transcript/validate.mjs';
+
+export function retimeTranscript(transcript, edl) {
+  validateTranscript(transcript);
+  validateEdl(edl, transcript.durationSeconds);
+  assertEdlApproved(edl);
+
+  const words = transcript.words.flatMap((word) => {
+    const containingCut = edl.cuts.find(
+      (cut) => cut.sourceStart <= word.start && cut.sourceEnd >= word.end
+    );
+    if (containingCut) return [];
+
+    const partialCut = edl.cuts.find(
+      (cut) => cut.sourceStart < word.end && cut.sourceEnd > word.start
+    );
+    if (partialCut) {
+      throw new TypeError(`EDL cut ${partialCut.sourceStart}-${partialCut.sourceEnd} splits transcript word "${word.text}".`);
+    }
+
+    const removedBefore = edl.cuts
+      .filter((cut) => cut.sourceEnd <= word.start)
+      .reduce((total, cut) => total + cut.sourceEnd - cut.sourceStart, 0);
+    return [{ ...word, start: word.start - removedBefore, end: word.end - removedBefore }];
+  });
+
+  const removedDuration = edl.cuts.reduce(
+    (total, cut) => total + cut.sourceEnd - cut.sourceStart,
+    0
+  );
+  if (removedDuration >= transcript.durationSeconds) {
+    throw new TypeError('EDL must leave a positive output duration.');
+  }
+  return {
+    schemaVersion: 1,
+    durationSeconds: transcript.durationSeconds - removedDuration,
+    ...(transcript.granularity ? { granularity: transcript.granularity } : {}),
+    words,
+  };
+}
+
+export function validateEdl(edl, sourceDurationSeconds) {
+  if (!edl || typeof edl !== 'object' || Array.isArray(edl)) {
+    throw new TypeError('EDL must be a JSON object.');
+  }
+  if (edl.schemaVersion !== 1) {
+    throw new TypeError('EDL schemaVersion must be 1.');
+  }
+  if (!Number.isFinite(edl.sourceDurationSeconds) || edl.sourceDurationSeconds <= 0) {
+    throw new TypeError('EDL sourceDurationSeconds must be a positive number.');
+  }
+  if (Math.abs(edl.sourceDurationSeconds - sourceDurationSeconds) > 1e-6) {
+    throw new TypeError('EDL sourceDurationSeconds must match the transcript duration.');
+  }
+  if (edl.reviewStatus !== undefined && !['needs-review', 'approved'].includes(edl.reviewStatus)) {
+    throw new TypeError('EDL reviewStatus must be needs-review or approved.');
+  }
+  if (!Array.isArray(edl.cuts)) {
+    throw new TypeError('EDL cuts must be an array.');
+  }
+
+  let previousEnd = 0;
+  for (const [index, cut] of edl.cuts.entries()) {
+    const label = `EDL cut ${index + 1}`;
+    if (!cut || typeof cut !== 'object' || Array.isArray(cut)) {
+      throw new TypeError(`${label} must be an object.`);
+    }
+    if (!Number.isFinite(cut.sourceStart) || !Number.isFinite(cut.sourceEnd) || cut.sourceStart < 0 || cut.sourceEnd <= cut.sourceStart) {
+      throw new TypeError(`${label} must have finite times with 0 <= sourceStart < sourceEnd.`);
+    }
+    if (cut.sourceEnd > sourceDurationSeconds) {
+      throw new TypeError(`${label} ends after the source duration.`);
+    }
+    if (cut.sourceStart < previousEnd) {
+      throw new TypeError(`${label} overlaps or is out of order.`);
+    }
+    if (typeof cut.reason !== 'string' || !cut.reason.trim()) {
+      throw new TypeError(`${label} reason must be a non-empty string.`);
+    }
+    previousEnd = cut.sourceEnd;
+  }
+  const removedDuration = edl.cuts.reduce(
+    (total, cut) => total + cut.sourceEnd - cut.sourceStart,
+    0
+  );
+  if (removedDuration >= sourceDurationSeconds) {
+    throw new TypeError('EDL must leave a positive output duration.');
+  }
+  return edl;
+}
+
+export function approveEdl(edl) {
+  validateEdl(edl, edl?.sourceDurationSeconds);
+  if (edl.reviewStatus !== 'needs-review') throw new TypeError('Only an EDL marked needs-review can be approved.');
+  const approved = structuredClone(edl);
+  approved.reviewStatus = 'approved';
+  return approved;
+}
+
+export function assertEdlApproved(edl) {
+  if (edl?.reviewStatus === 'needs-review') {
+    throw new TypeError('EDL contains unapproved edit suggestions; review and approve it before editing.');
+  }
+  return edl;
+}