@ossclip/core 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossclip/core",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "ossclip's framework-free pipeline: schema, transcription, analysis, cutlist, captions, framing, and the LLM producer",
   "type": "module",
   "license": "MIT",

package/src/export-edl.ts

@@ -0,0 +1,99 @@
+import { basename } from "node:path";
+import { keptPauseLabel, keptPauses } from "./export-markers";
+import type { Production, RemovalReason, Segment } from "./schema";
+
+/**
+ * Resolve marker EDL export (§142). The FCPXML exporter's markers are real,
+ * but DaVinci Resolve's FCPXML import silently drops clip markers — verified
+ * in the field the day FCPXML shipped: timeline imported, 127 markers gone,
+ * marker display on. Resolve's dedicated path is `Timeline → Import →
+ * Timeline Markers from EDL`, and its format is Resolve's OWN marker-EDL
+ * dialect: a CMX3600-shaped event per marker plus a continuation line
+ * ` |C:ResolveColor<name> |M:<label> |D:<frames>`.
+ *
+ * This dialect is also where the §141 colour decision gets un-made for one
+ * consumer: FCPXML markers cannot carry colour, but |C: can — so here the
+ * cut REASON maps to a colour as well as living in the label.
+ */
+
+/**
+ * Reason → Resolve marker colour. Names must be from Resolve's fixed
+ * View → Show Markers list (verified against Resolve 20); an unknown name
+ * imports as the default colour rather than erroring, but stay exact anyway.
+ */
+const REASON_COLOURS: Record<RemovalReason, string> = {
+  silence: "Blue",
+  pause: "Sky",
+  filler: "Yellow",
+  retake: "Red",
+  user: "Green",
+  clip: "Purple",
+};
+
+/** Non-drop hh:mm:ss:ff at an integer frame rate. */
+export function framesToTimecode(frames: number, fps: number): string {
+  const ff = frames % fps;
+  const totalSec = Math.floor(frames / fps);
+  const ss = totalSec % 60;
+  const mm = Math.floor(totalSec / 60) % 60;
+  const hh = Math.floor(totalSec / 3600);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${p(hh)}:${p(mm)}:${p(ss)}:${p(ff)}`;
+}
+
+/**
+ * ASCII on purpose, unlike the report and the FCPXML labels: EDL is a
+ * fixed-width 1970s interchange format and the true minus sign (U+2212) is
+ * exactly the kind of byte that a strict parser turns into a silently
+ * skipped line. Pipes are stripped because ` |` is the field separator.
+ */
+function label(seg: Segment): string {
+  const dur = (seg.srcOut - seg.srcIn).toFixed(2);
+  const conf = seg.confidence !== undefined ? ` (conf ${seg.confidence.toFixed(2)})` : "";
+  return `${seg.reason ?? "cut"} -${dur}s${conf}`.replaceAll("|", "/");
+}
+
+export function buildResolveMarkerEdl(production: Production): string {
+  const { path, probe } = production.source;
+  const fps = Math.round(probe.fps);
+  // SPANS, not 1-frame points (§142 round 2): |D: carries the whole
+  // suggested cut in frames, so Resolve draws the marker across the region —
+  // the field editor needs where content RESUMES as much as where the cut
+  // starts. Kept pauses (export-markers.ts) join the list in Lavender, a
+  // colour no cut reason uses, so suggestion and information stay distinct.
+  const items = [
+    ...(production.cutlist ?? [])
+      .filter((s) => s.kind === "remove")
+      .map((s) => ({
+        start: s.srcIn,
+        end: s.srcOut,
+        colour: REASON_COLOURS[s.reason ?? "user"] ?? "Green",
+        label: label(s),
+      })),
+    ...keptPauses(production).map((p) => ({
+      start: p.start,
+      end: p.end,
+      colour: "Lavender",
+      label: keptPauseLabel(p).replaceAll("|", "/"),
+    })),
+  ].sort((a, b) => a.start - b.start);
+  const lines: string[] = [
+    `TITLE: ${basename(path)} — ossclip markers`,
+    "FCM: NON-DROP FRAME",
+    "",
+  ];
+  items.forEach((m, i) => {
+    const inFrames = Math.round(m.start * fps);
+    // At least one frame — a zero-length marker is invisible.
+    const durFrames = Math.max(1, Math.round(m.end * fps) - inFrames);
+    const tcIn = framesToTimecode(inFrames, fps);
+    const tcOut = framesToTimecode(inFrames + durFrames, fps);
+    // Record TC = source TC: the FCPXML timeline this rides on starts at
+    // 00:00:00:00 (tcStart 0), so the marker lands at the source position.
+    const num = String(i + 1).padStart(3, "0");
+    lines.push(`${num}  001      V     C        ${tcIn} ${tcOut} ${tcIn} ${tcOut}  `);
+    lines.push(` |C:ResolveColor${m.colour} |M:${m.label} |D:${durFrames}`);
+    lines.push("");
+  });
+  return `${lines.join("\n")}\n`;
+}

package/src/export-fcpxml.ts

@@ -1,5 +1,6 @@
 import { basename } from "node:path";
 import { pathToFileURL } from "node:url";
+import { keptPauseLabel, keptPauses } from "./export-markers";
 import type { Production, Segment } from "./schema";
 
 /**
@@ -74,12 +75,26 @@ export function buildFcpxmlMarkers(production: Production): string {
   const fd = fpsToFrameDuration(probe.fps);
   const dur = quantizeToFrame(probe.duration, fd);
   const name = basename(path);
+  // SPANS, not points (§142 round 2): the 1-frame marker was a deliberate
+  // "don't overstate the suggestion" choice, and the first real editor
+  // reversed it — she needs where the cut starts AND where content resumes,
+  // and a span's two edges are exactly that. Kept pauses ride along as their
+  // own markers (see export-markers.ts); one time-ordered list, so the
+  // NLE's marker index reads like the take.
+  const spanFrames = (startSec: number, endSec: number) => {
+    const frames = (sec: number) => Math.round((sec * fd.den) / fd.num);
+    return Math.max(1, frames(endSec) - frames(startSec));
+  };
   const removals = (production.cutlist ?? []).filter((s) => s.kind === "remove");
-  const markers = removals
+  const items = [
+    ...removals.map((s) => ({ start: s.srcIn, end: s.srcOut, label: markerName(s) })),
+    ...keptPauses(production).map((p) => ({ start: p.start, end: p.end, label: keptPauseLabel(p) })),
+  ].sort((a, b) => a.start - b.start);
+  const markers = items
     .map(
-      (s) =>
-        `            <marker start="${quantizeToFrame(s.srcIn, fd)}" ` +
-        `duration="${fd.num}/${fd.den}s" value="${esc(markerName(s))}"/>`,
+      (m) =>
+        `            <marker start="${quantizeToFrame(m.start, fd)}" ` +
+        `duration="${spanFrames(m.start, m.end) * fd.num}/${fd.den}s" value="${esc(m.label)}"/>`,
     )
     .join("\n");
   // pathToFileURL, not string concat: it percent-encodes the characters a

package/src/export-markers.ts

@@ -0,0 +1,43 @@
+import type { Production, Span } from "./schema";
+
+/**
+ * Shared derivations for the NLE marker exporters (§142 round 2).
+ *
+ * The field editor's second complaint, verified frame-by-frame against her
+ * recorded feedback: real pauses sat visibly in her waveform with no marker
+ * on them. Those are pauses the analysis DETECTED but the cut rules KEPT —
+ * below the cut bar, or sentence-snapped away. The exports read only the
+ * cutlist, so a kept pause was invisible in exactly the tool she uses to
+ * find pauses. `analysis.cuttable` is the right pool: regions with no
+ * audible speech AFTER the transcript veto — the same candidates every
+ * silence/pause cut was drawn from.
+ */
+
+/**
+ * 0.25s, not `breaths`' 120ms floor: a 30-minute take carries hundreds of
+ * sub-quarter-second breaths, and a marker per breath buries the markers the
+ * editor asked for under the ones she didn't (§142 round 2 — marker-spam
+ * floor).
+ */
+export const MIN_KEPT_PAUSE_SEC = 0.25;
+
+/**
+ * Detected pauses the cut rules kept: cuttable regions no remove segment
+ * overlaps, at or above the floor. A PARTIALLY overlapped region is excluded
+ * too — the cut already marks that neighbourhood, and a second marker there
+ * would read as a second suggestion.
+ */
+export function keptPauses(production: Production): Span[] {
+  const cuttable = production.analysis?.cuttable ?? [];
+  const removes = (production.cutlist ?? []).filter((s) => s.kind === "remove");
+  return cuttable.filter(
+    (span) =>
+      span.end - span.start >= MIN_KEPT_PAUSE_SEC &&
+      !removes.some((r) => r.srcIn < span.end && r.srcOut > span.start),
+  );
+}
+
+/** The kept-pause label, shared so all three formats say the same words. */
+export function keptPauseLabel(span: Span): string {
+  return `pause ${(span.end - span.start).toFixed(2)}s (kept)`;
+}

package/src/export-premiere-project.ts

@@ -0,0 +1,406 @@
+import { basename } from "node:path";
+import { pathToFileURL } from "node:url";
+import { keptPauseLabel, keptPauses } from "./export-markers";
+import { esc, xmemlRate, xmemlRateXml } from "./export-xmeml-util";
+import { mapFromKeptSpans, type KeptSpan } from "./timemap";
+import { zoomScaleAt, type ZoomSegment } from "./zoom";
+import type { Production } from "./schema";
+
+/**
+ * `--format premiere-project` — the produce experience delivered INSIDE
+ * Premiere, editable. The marker export (export-premiere-xml.ts) annotates an
+ * untouched take; this one applies the cutlist: an xmeml v4 sequence at the
+ * OUTPUT frame with one `<clipitem>` per kept span. xmeml trims are
+ * non-destructive — dragging a clip edge restores removed material — which is
+ * what neutralizes the original "blind cuts" objection to a pre-cut export.
+ * Each clip carries a Basic Motion filter reproducing the render's camera:
+ * cover-crop base scale × alternating punch-in × cosine-eased zoom keyframes.
+ *
+ * Same house split as every exporter: plain data in, two strings out; the CLI
+ * owns the files. Both strings are pure ASCII (§142 — decades-old consumers
+ * silently skip lines they can't decode; no U+2212 anywhere).
+ *
+ * Cover-crop parity is the FULL-BLEED framing only — VideoStage layouts
+ * differ per scene, and v1 deliberately exports the one framing every scene
+ * shares (plan 2026-08-13, known risks).
+ */
+
+/** The slice of a caption line the SRT needs — start/end are OUTPUT seconds. */
+export interface SrtLine {
+  words: readonly { text: string }[];
+  start: number;
+  end: number;
+}
+
+export interface PremiereProjectInput {
+  production: Production;
+  spans: readonly KeptSpan[];
+  captionLines: readonly SrtLine[];
+  zoomPlan: readonly ZoomSegment[];
+  /** render-props' flag: true disables BOTH motion layers (zoom AND punch). */
+  staticCamera?: boolean;
+  /** The OUTPUT frame (production.render), e.g. 1080×1920. */
+  frame: { width: number; height: number };
+}
+
+/**
+ * The render's jump-cut concealer, replicated from EdlVideo.tsx:41-51 — the
+ * alternating toggle, the srcIn−prev.srcOut gap, and the INCLUSIVE >=
+ * threshold must all match, or the exported project punches different clips
+ * than the render did. Defaults mirror EdlVideoProps; they are parameters so
+ * a drift in either place shows up as a failing hand-computed test, not a
+ * silent divergence.
+ */
+export function punchScales(
+  spans: readonly KeptSpan[],
+  punchInScale = 1.07,
+  punchThresholdSec = 0.15,
+): number[] {
+  const out: number[] = [];
+  let punched = false;
+  for (let i = 0; i < spans.length; i++) {
+    const prev = spans[i - 1];
+    const gap = prev ? spans[i]!.srcIn - prev.srcOut : 0;
+    if (i > 0 && gap >= punchThresholdSec) punched = !punched;
+    out.push(punched ? punchInScale : 1);
+  }
+  return out;
+}
+
+/**
+ * The full-bleed cover-crop as Basic Motion parameters. Premiere imports a
+ * source 1:1-pixel centered in the sequence, so the cover factor —
+ * max(frame/probe) per axis, the CSS `object-fit: cover` rule the render
+ * uses — maps directly onto the scale percent (100 = native size). The
+ * center offset re-centers the measured face point and is clamped so the
+ * scaled picture never reveals an edge: |offset| ≤ (scaledDim − frameDim)/2
+ * per axis — the same "never show the backing" guarantee cover gives the
+ * render. xmeml center units: fractions of the sequence dimension, 0 =
+ * centered. No face → centered, exactly like the render's 50% default.
+ */
+export function coverTransform(
+  probe: { width: number; height: number },
+  face: { centerXFrac: number; centerYFrac: number } | null | undefined,
+  frame: { width: number; height: number },
+): { scalePct: number; centerH: number; centerV: number } {
+  const scale = Math.max(frame.width / probe.width, frame.height / probe.height);
+  const offset = (scaledDim: number, frameDim: number, frac: number): number => {
+    const slack = (scaledDim - frameDim) / 2;
+    const want = scaledDim * (0.5 - frac);
+    return Math.max(-slack, Math.min(slack, want));
+  };
+  return {
+    scalePct: scale * 100,
+    centerH: face ? offset(probe.width * scale, frame.width, face.centerXFrac) / frame.width : 0,
+    centerV: face ? offset(probe.height * scale, frame.height, face.centerYFrac) / frame.height : 0,
+  };
+}
+
+/**
+ * Zoom samples for one clip's output window, in OUTPUT seconds: segment
+ * endpoints plus two interior points per ramp (a cosine ease through four
+ * points reads as the ease; through two it reads as linear). Only this
+ * clip's own segments are consulted — `zoomScaleAt` matches half-open, so at
+ * the clip's final instant the unfiltered plan would answer with the NEXT
+ * clip's reset instead of this clip's hold (zoom.ts's boundary note).
+ * Interior samples of a constant run are dropped; a hold keeps only its
+ * endpoints.
+ */
+export function zoomKeyframesFor(
+  span: KeptSpan,
+  zoomPlan: readonly ZoomSegment[],
+): { tSec: number; scale: number }[] {
+  const segs = zoomPlan.filter((s) => s.startSec < span.outOut && s.endSec > span.outIn);
+  const times = new Set<number>([span.outIn, span.outOut]);
+  for (const seg of segs) {
+    const a = Math.max(seg.startSec, span.outIn);
+    const b = Math.min(seg.endSec, span.outOut);
+    times.add(a);
+    times.add(b);
+    if (seg.from !== seg.to) {
+      times.add(a + (b - a) / 3);
+      times.add(a + (2 * (b - a)) / 3);
+    }
+  }
+  const samples = [...times]
+    .sort((x, y) => x - y)
+    .map((tSec) => ({ tSec, scale: zoomScaleAt(segs, tSec) }));
+  const eq = (a: number, b: number) => Math.abs(a - b) < 1e-9;
+  return samples.filter((cur, i) => {
+    const prev = samples[i - 1];
+    const next = samples[i + 1];
+    // Interior of a constant run — the run's endpoints carry the hold.
+    return !(prev && next && eq(prev.scale, cur.scale) && eq(cur.scale, next.scale));
+  });
+}
+
+/**
+ * Keyframe `<when>` domain: CLIP-RELATIVE frames — the one xmeml spec detail
+ * memory can't settle (media-time vs clip-time; the plan's stated open
+ * risk). Kept as a single function so the §142 fail-fast field smoke can
+ * flip the domain with a one-line change plus its test, not a hunt through
+ * the emitter.
+ */
+export function keyframeWhen(span: KeptSpan, tSec: number, fps: number): number {
+  return Math.round((tSec - span.outIn) * fps);
+}
+
+/** HH:MM:SS,mmm — the comma is SRT's own; everything here is ASCII (§142). */
+function srtTime(sec: number): string {
+  const ms = Math.round(sec * 1000);
+  const pad = (n: number, w: number) => String(n).padStart(w, "0");
+  return (
+    `${pad(Math.floor(ms / 3_600_000), 2)}:${pad(Math.floor(ms / 60_000) % 60, 2)}:` +
+    `${pad(Math.floor(ms / 1000) % 60, 2)},${pad(ms % 1000, 3)}`
+  );
+}
+
+/**
+ * Captions as SRT, in output (sequence) time so the file drops straight onto
+ * the exported timeline. Word-level karaoke timing does not survive SRT —
+ * the format has no word granularity — so a line is its words joined.
+ */
+export function srtFromCaptionLines(lines: readonly SrtLine[]): string {
+  return lines
+    .map(
+      (line, i) =>
+        `${i + 1}\n${srtTime(line.start)} --> ${srtTime(line.end)}\n` +
+        `${line.words.map((w) => w.text).join(" ")}\n`,
+    )
+    .join("\n");
+}
+
+/** Keyframes numeric noise-floor: 4 decimals is sub-0.001% of scale. */
+const fmt = (n: number): string => String(Number(n.toFixed(4)));
+
+export function buildPremiereProject(input: PremiereProjectInput): { xml: string; srt: string } {
+  const { production, spans, captionLines, zoomPlan, staticCamera, frame } = input;
+  const { path, probe } = production.source;
+  // The whole document runs at the SOURCE rate (the marker exporter's
+  // precedent): clip in/out and sequence start/end share one timebase, so no
+  // frame position depends on Premiere's rate conform.
+  const { timebase, ntsc } = xmemlRate(probe.fps);
+  const toFrames = (sec: number) => Math.round(sec * probe.fps);
+  const name = esc(basename(path));
+  const rateXml = (indent: string) => xmemlRateXml(indent, timebase, ntsc);
+  const outputEnd = spans.length > 0 ? spans[spans.length - 1]!.outOut : 0;
+  const durFrames = toFrames(outputEnd);
+
+  const cover = coverTransform(probe, production.source.face, frame);
+  // staticCamera kills BOTH motion drivers (produce's render-props contract:
+  // zoomPlan alone can't reach the punch) — cover-crop is all that remains.
+  const punches = staticCamera ? spans.map(() => 1) : punchScales(spans);
+
+  // Per-clip frame geometry. A sub-frame span still occupies one frame on
+  // both axes — a zero-length clipitem is undefined importer behavior, same
+  // rule as the marker exporter's zero-length span.
+  const geo = spans.map((sp) => {
+    const start = toFrames(sp.outIn);
+    const srcIn = toFrames(sp.srcIn);
+    return {
+      start,
+      end: Math.max(start + 1, toFrames(sp.outOut)),
+      in: srcIn,
+      out: Math.max(srcIn + 1, toFrames(sp.srcOut)),
+    };
+  });
+
+  const scaleParam = (sp: KeptSpan, punch: number, indent: string): string => {
+    const kfs = staticCamera ? [] : zoomKeyframesFor(sp, zoomPlan);
+    const values = kfs.map((k) => ({ when: keyframeWhen(sp, k.tSec, probe.fps), value: cover.scalePct * punch * k.scale }));
+    // A motionless clip (staticCamera, or a plan that never moves it) gets a
+    // plain static value — two identical keyframes would read as "animated"
+    // in Effect Controls for no reason.
+    const still =
+      values.length < 2 || values.every((v) => Math.abs(v.value - values[0]!.value) < 1e-9);
+    const body = still
+      ? `${indent}  <value>${fmt(values[0]?.value ?? cover.scalePct * punch)}</value>`
+      : values
+          .map(
+            (v) =>
+              `${indent}  <keyframe>\n${indent}    <when>${v.when}</when>\n` +
+              `${indent}    <value>${fmt(v.value)}</value>\n${indent}  </keyframe>`,
+          )
+          .join("\n");
+    return (
+      `${indent}<parameter>\n` +
+      `${indent}  <parameterid>scale</parameterid>\n` +
+      `${indent}  <name>Scale</name>\n` +
+      `${indent}  <valuemin>0</valuemin>\n` +
+      `${indent}  <valuemax>1000</valuemax>\n` +
+      body + "\n" +
+      `${indent}</parameter>`
+    );
+  };
+
+  const basicMotion = (sp: KeptSpan, punch: number, indent: string): string =>
+    `${indent}<filter>\n` +
+    `${indent}  <effect>\n` +
+    `${indent}    <name>Basic Motion</name>\n` +
+    `${indent}    <effectid>basic</effectid>\n` +
+    `${indent}    <effectcategory>motion</effectcategory>\n` +
+    `${indent}    <effecttype>motion</effecttype>\n` +
+    `${indent}    <mediatype>video</mediatype>\n` +
+    scaleParam(sp, punch, `${indent}    `) + "\n" +
+    `${indent}    <parameter>\n` +
+    `${indent}      <parameterid>center</parameterid>\n` +
+    `${indent}      <name>Center</name>\n` +
+    `${indent}      <value>\n` +
+    `${indent}        <horiz>${fmt(cover.centerH)}</horiz>\n` +
+    `${indent}        <vert>${fmt(cover.centerV)}</vert>\n` +
+    `${indent}      </value>\n` +
+    `${indent}    </parameter>\n` +
+    `${indent}  </effect>\n` +
+    `${indent}</filter>`;
+
+  // Both clipitems of a pair carry both links (xmeml convention, same as the
+  // marker exporter's field fix 2): this is what makes Premiere treat Vn+An
+  // as ONE linked clip instead of two strangers.
+  const links = (i: number, indent: string): string =>
+    !probe.hasAudio
+      ? ""
+      : `${indent}<link>\n` +
+        `${indent}  <linkclipref>ci-v${i}</linkclipref>\n` +
+        `${indent}  <mediatype>video</mediatype>\n` +
+        `${indent}  <trackindex>1</trackindex>\n` +
+        `${indent}  <clipindex>${i + 1}</clipindex>\n` +
+        `${indent}</link>\n` +
+        `${indent}<link>\n` +
+        `${indent}  <linkclipref>ci-a${i}</linkclipref>\n` +
+        `${indent}  <mediatype>audio</mediatype>\n` +
+        `${indent}  <trackindex>1</trackindex>\n` +
+        `${indent}  <clipindex>${i + 1}</clipindex>\n` +
+        `${indent}</link>`;
+
+  // The file is DEFINED once (first video clipitem) and referenced by id
+  // everywhere else — repeating full definitions is how importers end up
+  // with N copies of one clip in the project panel.
+  const fileXml = (first: boolean, indent: string): string =>
+    first
+      ? `${indent}<file id="f-1">\n` +
+        `${indent}  <name>${name}</name>\n` +
+        `${indent}  <pathurl>${esc(pathToFileURL(path).href)}</pathurl>\n` +
+        xmemlRateXml(`${indent}  `, timebase, ntsc) + "\n" +
+        `${indent}  <duration>${toFrames(probe.duration)}</duration>\n` +
+        `${indent}  <media>\n` +
+        `${indent}    <video>\n` +
+        `${indent}      <samplecharacteristics>\n` +
+        `${indent}        <width>${probe.width}</width>\n` +
+        `${indent}        <height>${probe.height}</height>\n` +
+        `${indent}      </samplecharacteristics>\n` +
+        `${indent}    </video>${probe.hasAudio ? `\n${indent}    <audio>\n${indent}      <channelcount>2</channelcount>\n${indent}    </audio>` : ""}\n` +
+        `${indent}  </media>\n` +
+        `${indent}</file>`
+      : `${indent}<file id="f-1"/>`;
+
+  const videoClips = spans
+    .map((sp, i) => {
+      const g = geo[i]!;
+      return (
+        `          <clipitem id="ci-v${i}">\n` +
+        `            <name>${name}</name>\n` +
+        `            <duration>${toFrames(probe.duration)}</duration>\n` +
+        rateXml("            ") + "\n" +
+        `            <start>${g.start}</start>\n` +
+        `            <end>${g.end}</end>\n` +
+        `            <in>${g.in}</in>\n` +
+        `            <out>${g.out}</out>\n` +
+        fileXml(i === 0, "            ") + "\n" +
+        basicMotion(sp, punches[i]!, "            ") + "\n" +
+        (probe.hasAudio ? links(i, "            ") + "\n" : "") +
+        `          </clipitem>`
+      );
+    })
+    .join("\n");
+
+  const audioClips = !probe.hasAudio
+    ? ""
+    : spans
+        .map((_sp, i) => {
+          const g = geo[i]!;
+          return (
+            `          <clipitem id="ci-a${i}">\n` +
+            `            <name>${name}</name>\n` +
+            `            <duration>${toFrames(probe.duration)}</duration>\n` +
+            rateXml("            ") + "\n" +
+            `            <start>${g.start}</start>\n` +
+            `            <end>${g.end}</end>\n` +
+            `            <in>${g.in}</in>\n` +
+            `            <out>${g.out}</out>\n` +
+            `            <file id="f-1"/>\n` +
+            `            <sourcetrack>\n` +
+            `              <mediatype>audio</mediatype>\n` +
+            `              <trackindex>1</trackindex>\n` +
+            `            </sourcetrack>\n` +
+            links(i, "            ") + "\n" +
+            `          </clipitem>`
+          );
+        })
+        .join("\n");
+
+  // Kept pauses still ride the sequence (§142 round 2) — they are the
+  // "detected but kept" overview the field editor asked for. The cuts
+  // themselves are APPLIED here, so no cut markers: the cut IS the edit.
+  // Pause times are source seconds; the sequence runs in output time, so
+  // they map through the spans (clamped — a pause never overlaps a remove,
+  // but its edges can graze one).
+  const map = mapFromKeptSpans(spans);
+  const markers = keptPauses(production)
+    .map((p) => ({ start: map.toOutputClamped(p.start), end: map.toOutputClamped(p.end), label: keptPauseLabel(p) }))
+    .filter((m) => m.end > m.start)
+    .map(
+      (m) =>
+        `    <marker>\n` +
+        `      <name>${esc(m.label)}</name>\n` +
+        `      <comment>ossclip detected pause - kept, below the cut bar</comment>\n` +
+        `      <in>${toFrames(m.start)}</in>\n` +
+        `      <out>${Math.max(toFrames(m.start) + 1, toFrames(m.end))}</out>\n` +
+        `    </marker>`,
+    )
+    .join("\n");
+
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE xmeml>
+<xmeml version="4">
+  <sequence id="ossclip-project">
+    <name>${name} - ossclip cut</name>
+    <duration>${durFrames}</duration>
+${rateXml("    ")}
+    <timecode>
+${rateXml("      ")}
+      <string>00:00:00:00</string>
+      <frame>0</frame>
+      <displayformat>${ntsc ? "DF" : "NDF"}</displayformat>
+    </timecode>
+    <media>
+      <video>
+        <format>
+          <samplecharacteristics>
+${rateXml("            ")}
+            <width>${frame.width}</width>
+            <height>${frame.height}</height>
+            <anamorphic>FALSE</anamorphic>
+            <pixelaspectratio>square</pixelaspectratio>
+            <fielddominance>none</fielddominance>
+          </samplecharacteristics>
+        </format>
+        <track>
+${videoClips}
+        </track>
+      </video>${
+        probe.hasAudio
+          ? `
+      <audio>
+        <track>
+${audioClips}
+        </track>
+      </audio>`
+          : ""
+      }
+    </media>
+${markers ? `${markers}\n` : ""}  </sequence>
+</xmeml>
+`;
+
+  return { xml, srt: srtFromCaptionLines(captionLines) };
+}

package/src/export-premiere-xml.ts

@@ -0,0 +1,177 @@
+import { basename } from "node:path";
+import { pathToFileURL } from "node:url";
+import { keptPauseLabel, keptPauses } from "./export-markers";
+import { esc, xmemlRate, xmemlRateXml } from "./export-xmeml-util";
+import type { Production, Segment } from "./schema";
+
+/**
+ * Premiere marker export — legacy FCP7 XML, "xmeml" (§142). The field test
+ * that shipped fcpxml killed its own premise within the hour: Premiere Pro
+ * does NOT import modern FCPXML ("File format not supported"); the format it
+ * lists as "Final Cut Pro XML" is the LEGACY xmeml interchange, a different
+ * document entirely. So: fcpxml serves actual Final Cut Pro, resolve-edl
+ * serves Resolve (whose fcpxml import drops markers), and THIS serves
+ * Premiere — an xmeml v4 sequence whose SEQUENCE-level markers carry the cut
+ * list onto the timeline ruler after File → Import.
+ *
+ * Same house split as the other two exporters: Production in, string out.
+ */
+
+/** ASCII hyphen like the EDL label — xmeml consumers are as old as it is. */
+function label(seg: Segment): string {
+  const dur = (seg.srcOut - seg.srcIn).toFixed(2);
+  const conf = seg.confidence !== undefined ? ` (conf ${seg.confidence.toFixed(2)})` : "";
+  return `${seg.reason ?? "cut"} -${dur}s${conf}`;
+}
+
+export function buildPremiereXmlMarkers(production: Production): string {
+  const { path, probe } = production.source;
+  const { timebase, ntsc } = xmemlRate(probe.fps);
+  const toFrames = (sec: number) => Math.round(sec * probe.fps);
+  const durFrames = toFrames(probe.duration);
+  const name = esc(basename(path));
+  const rateXml = (indent: string) => xmemlRateXml(indent, timebase, ntsc);
+  // Emitted at BOTH levels, deliberately (field feedback, first real editor,
+  // §142). SEQUENCE markers sit at fixed timecode — the moment the editor
+  // ripple-deletes their first blooper, every downstream one points at the
+  // wrong moment, which is exactly why our field editor went back to manual.
+  // CLIP markers are anchored to the clip's MEDIA time, so they ride through
+  // razor cuts and ripple deletes and stay on the words they describe. The
+  // sequence copies stay too: they are the read-only overview of the
+  // untouched take, and the two agree while nothing is edited.
+  // SPANS, not points (§142 round 2). The original -1 (point marker) was a
+  // deliberate "a span overstates the suggestion" call — the first real
+  // editor reversed it: she needs the cut's END ("the video resumes from
+  // here") as much as its start, and a span's edges are both. Kept pauses
+  // (export-markers.ts) join the same time-ordered list.
+  const markerItems = [
+    ...(production.cutlist ?? [])
+      .filter((s) => s.kind === "remove")
+      .map((s) => ({
+        start: s.srcIn,
+        end: s.srcOut,
+        label: label(s),
+        comment: "ossclip suggested cut — review before applying",
+      })),
+    ...keptPauses(production).map((p) => ({
+      start: p.start,
+      end: p.end,
+      label: keptPauseLabel(p),
+      comment: "ossclip detected pause — kept, below the cut bar",
+    })),
+  ].sort((a, b) => a.start - b.start);
+  const markerXml = (indent: string) =>
+    markerItems
+      .map(
+        (m) =>
+          `${indent}<marker>\n` +
+          `${indent}  <name>${esc(m.label)}</name>\n` +
+          `${indent}  <comment>${esc(m.comment)}</comment>\n` +
+          `${indent}  <in>${toFrames(m.start)}</in>\n` +
+          // At least one frame: a zero-length span is as invisible as the
+          // point markers this replaced.
+          `${indent}  <out>${Math.max(toFrames(m.start) + 1, toFrames(m.end))}</out>\n` +
+          `${indent}</marker>`,
+      )
+      .join("\n");
+  const markers = markerXml("    ");
+  const clipMarkers = markerXml("            ");
+  // Both clipitems carry both links (xmeml convention): this is what makes
+  // Premiere treat V1+A1 as ONE linked clip instead of two strangers —
+  // field fix 2: without an audio clipitem at all, the sequence imported
+  // silent and the editor had to add and link the audio by hand.
+  const links = (indent: string) =>
+    !probe.hasAudio
+      ? ""
+      : `${indent}<link>\n` +
+    `${indent}  <linkclipref>ci-1</linkclipref>\n` +
+    `${indent}  <mediatype>video</mediatype>\n` +
+    `${indent}  <trackindex>1</trackindex>\n` +
+    `${indent}  <clipindex>1</clipindex>\n` +
+    `${indent}</link>\n` +
+    `${indent}<link>\n` +
+    `${indent}  <linkclipref>ci-2</linkclipref>\n` +
+    `${indent}  <mediatype>audio</mediatype>\n` +
+    `${indent}  <trackindex>1</trackindex>\n` +
+    `${indent}  <clipindex>1</clipindex>\n` +
+    `${indent}</link>`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE xmeml>
+<xmeml version="4">
+  <sequence id="ossclip-markers">
+    <name>${name} — ossclip markers</name>
+    <duration>${durFrames}</duration>
+${rateXml("    ")}
+    <timecode>
+${rateXml("      ")}
+      <string>00:00:00:00</string>
+      <frame>0</frame>
+      <displayformat>${ntsc ? "DF" : "NDF"}</displayformat>
+    </timecode>
+    <media>
+      <video>
+        <format>
+          <samplecharacteristics>
+${rateXml("            ")}
+            <width>${probe.width}</width>
+            <height>${probe.height}</height>
+            <anamorphic>FALSE</anamorphic>
+            <pixelaspectratio>square</pixelaspectratio>
+            <fielddominance>none</fielddominance>
+          </samplecharacteristics>
+        </format>
+        <track>
+          <clipitem id="ci-1">
+            <name>${name}</name>
+            <duration>${durFrames}</duration>
+${rateXml("            ")}
+            <start>0</start>
+            <end>${durFrames}</end>
+            <in>0</in>
+            <out>${durFrames}</out>
+            <file id="f-1">
+              <name>${name}</name>
+              <pathurl>${esc(pathToFileURL(path).href)}</pathurl>
+${rateXml("              ")}
+              <duration>${durFrames}</duration>
+              <media>
+                <video>
+                  <samplecharacteristics>
+                    <width>${probe.width}</width>
+                    <height>${probe.height}</height>
+                  </samplecharacteristics>
+                </video>${probe.hasAudio ? "\n                <audio>\n                  <channelcount>2</channelcount>\n                </audio>" : ""}
+              </media>
+            </file>
+${clipMarkers ? `${clipMarkers}\n` : ""}${links("            ")}
+          </clipitem>
+        </track>
+      </video>${
+        probe.hasAudio
+          ? `
+      <audio>
+        <track>
+          <clipitem id="ci-2">
+            <name>${name}</name>
+            <duration>${durFrames}</duration>
+${rateXml("            ")}
+            <start>0</start>
+            <end>${durFrames}</end>
+            <in>0</in>
+            <out>${durFrames}</out>
+            <file id="f-1"/>
+            <sourcetrack>
+              <mediatype>audio</mediatype>
+              <trackindex>1</trackindex>
+            </sourcetrack>
+${links("            ")}
+          </clipitem>
+        </track>
+      </audio>`
+          : ""
+      }
+    </media>
+${markers ? `${markers}\n` : ""}  </sequence>
+</xmeml>
+`;
+}

package/src/export-xmeml-util.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared xmeml plumbing (§142): the marker export (export-premiere-xml.ts)
+ * and the pre-cut project export (export-premiere-project.ts) both emit the
+ * legacy FCP7 dialect, and its rate mapping and escaping rules must not be
+ * allowed to drift apart — a "30 TRUE" that one exporter renders as "29.97"
+ * would import a sequence that slips a frame a minute.
+ */
+
+/**
+ * xmeml has no rational time: a rate is an integer `timebase` plus an `ntsc`
+ * flag, and every position is a frame count at that timebase. 29.97 is
+ * "30 TRUE" — the flag, not the number, is where the 1001 lives.
+ */
+export function xmemlRate(fps: number): { timebase: number; ntsc: boolean } {
+  const rounded = Math.round(fps);
+  // The NTSC family sits ~0.1% under its integer; a probe float lands close
+  // to the exact rational, never on the integer itself.
+  const ntsc = Math.abs(fps - rounded) > 0.001;
+  return { timebase: ntsc ? Math.ceil(fps) : rounded, ntsc };
+}
+
+/** The `<rate>` block both exporters emit, at the caller's indentation. */
+export function xmemlRateXml(indent: string, timebase: number, ntsc: boolean): string {
+  return (
+    `${indent}<rate>\n` +
+    `${indent}  <timebase>${timebase}</timebase>\n` +
+    `${indent}  <ntsc>${ntsc ? "TRUE" : "FALSE"}</ntsc>\n` +
+    `${indent}</rate>`
+  );
+}
+
+export function esc(s: string): string {
+  return s
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}

package/src/index.ts

@@ -27,6 +27,11 @@ export * from "./face";
 export * from "./cover";
 export * from "./source-text";
 export * from "./report";
+export * from "./export-markers";
 export * from "./export-fcpxml";
+export * from "./export-edl";
+export * from "./export-premiere-xml";
+export * from "./export-premiere-project";
+export * from "./export-xmeml-util";
 export * from "./config";
 export { run } from "./exec";

package/src/producer/gemini.ts

@@ -2,7 +2,7 @@ import { z } from "zod/v4";
 import type { LlmProvider } from "./provider";
 import { estimateTokens, type LlmUsage } from "./usage";
 
-export const DEFAULT_GEMINI_MODEL = "gemini-3.6-flash";
+export const DEFAULT_GEMINI_MODEL = "gemini-3.7-flash";
 
 /**
  * Convert a zod-derived JSON Schema into Gemini's `responseSchema` dialect

package/src/producer/index.ts

@@ -64,11 +64,11 @@ export const DEFAULT_FAST_MODEL: Partial<Record<ProviderName, string>> = {
   claude: "claude-haiku-4-5-20251001",
   "claude-cli": "claude-haiku-4-5-20251001",
   gemini: "gemini-3.5-flash-lite",
-  // Substring-matches the `gemini-3.6-flash` pricing family, so mechanical
+  // Substring-matches the `gemini-3.7-flash` pricing family, so mechanical
   // calls price from the existing table with no changes; the editorial tier
   // (agy's own default, reported as "antigravity-default") matches nothing and
   // reports "cost unknown" — the house honesty rule, not an oversight.
-  antigravity: "gemini-3.6-flash-low",
+  antigravity: "gemini-3.7-flash-low",
 };
 
 export interface TieringOptions {

package/src/producer/usage.ts

@@ -69,6 +69,9 @@ export const DEFAULT_PRICING: Record<string, ModelPrice> = {
   haiku: { inputPerMTok: 1, outputPerMTok: 5 },
   "gemini-2.5-pro": { inputPerMTok: 1.25, outputPerMTok: 10 },
   "gemini-2.5-flash": { inputPerMTok: 0.3, outputPerMTok: 2.5 },
+  // Gemini 3.7 Flash: $0.75 in / $3.75 out per 1M tokens (active rate)
+  "gemini-3.7-flash": { inputPerMTok: 0.75, outputPerMTok: 3.75 },
+  "gemini-3.7-flash-lite": { inputPerMTok: 0.3, outputPerMTok: 2.5 },
   "gemini-3.6-flash": { inputPerMTok: 1.5, outputPerMTok: 7.5 },
   "gemini-3.5-flash-lite": { inputPerMTok: 0.3, outputPerMTok: 2.5 },
 };