@ossclip/core 0.1.16 → 0.1.18

package/package.json

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

package/src/concat.ts

@@ -20,7 +20,13 @@ import { run } from "./exec";
  * `listFolderVideos` and `concatFolder` are the only I/O.
  */
 
-const VIDEO_EXTENSIONS = ["mov", "mp4", "m4v", "mkv", "webm", "avi"] as const;
+/**
+ * The extensions a folder input may contain. Exported (§136) because the
+ * CLI's native file picker builds its dialog filters from this list: a
+ * picker that offers a file `concat` will later refuse is a trap, and the
+ * two lists silently diverging is exactly how that ships.
+ */
+export const VIDEO_EXTENSIONS = ["mov", "mp4", "m4v", "mkv", "webm", "avi"] as const;
 const VIDEO_EXTENSION_SET = new Set<string>(VIDEO_EXTENSIONS);
 
 function noVideoFilesError(folder: string): Error {

package/src/retake.ts

@@ -223,13 +223,18 @@ function silenceFraction(silences: readonly Span[], start: number, end: number):
  * sits earlier is never cut, so a spurious split ends at a report line,
  * not a shear through live audio.
  */
+/** An Instance plus whether the restart split fragmented its coarse sentence. */
+interface SentenceInstance extends Instance {
+  wasSplit: boolean;
+}
+
 function buildInstances(
   transcript: Transcript,
   analysis: Pick<Analysis, "silences" | "fillers">,
   transparentMarker?: string,
-): Instance[] {
+): { fragments: Instance[]; sentences: SentenceInstance[] } {
   const words = transcript.words;
-  if (words.length === 0) return [];
+  if (words.length === 0) return { fragments: [], sentences: [] };
   const fillerIndices = new Set(analysis.fillers.map((f) => f.wordIndex));
   const marker = transparentMarker ? normalizeToken(transparentMarker) : undefined;
 
@@ -269,6 +274,7 @@ function buildInstances(
   };
 
   const instances: Instance[] = [];
+  const sentences: SentenceInstance[] = [];
   for (const sent of coarse) {
     // A sentence that is ALREADY silence-dominated end-to-end is the
     // hallucination shape, not the restart shape: whisper sprinkles sparse
@@ -334,8 +340,17 @@ function buildInstances(
     // runs out of words mid-sentence is a trailing abandoned partial, not a
     // finished take, whatever fragment boundary it happens to land on.
     instances.push(toInstance(fragStart, sent.end, isSentenceEnd(transcript, sent.end), true));
+    // The whole coarse sentence, rejoined across its restart splits, for the
+    // §135 sentence-level pass: VO-paced delivery pauses INSIDE a sentence,
+    // so both takes of a genuine retake fragment into pieces that never
+    // match each other. `wasSplit` records whether the split actually fired —
+    // the pass only acts where fragmentation could have hidden a match.
+    sentences.push({
+      ...toInstance(sent.start, sent.end, isSentenceEnd(transcript, sent.end), true),
+      wasSplit: splitAfter.length > 0,
+    });
   }
-  return instances;
+  return { fragments: instances, sentences };
 }
 
 // ---- matching -------------------------------------------------------------
@@ -427,11 +442,21 @@ function toPublic(i: Instance): RetakeInstance {
  * a clause boundary, not an abandoned take: its own sentence continues
  * without it, so it goes to `undecided` (report-only), never `cuts`.
  */
-function buildGroup(chain: readonly Instance[], hallucinated: readonly Instance[]): RetakeGroup {
+function buildGroup(
+  chain: readonly Instance[],
+  hallucinated: readonly Instance[],
+  // The fragment pass keeps its strict bar. The §135 sentence pass gates
+  // survivors at the HALLUCINATION bar instead: a whole sentence carrying
+  // deliberate mid-sentence pauses is ordinary read-aloud delivery — the
+  // field run's kept take sat at 36% dead air, over the fragment bar by one
+  // point, and a textbook retake went report-only for it. Below the
+  // hallucination bar, a sentence-level survivor is a real take.
+  survivorBar: number = RESTART_SPLIT_MIN_SIL,
+): RetakeGroup {
   const completes = chain.filter((i) => i.complete);
   const lastComplete = completes[completes.length - 1];
   const kept =
-    lastComplete !== undefined && lastComplete.silenceFrac <= RESTART_SPLIT_MIN_SIL
+    lastComplete !== undefined && lastComplete.silenceFrac <= survivorBar
       ? lastComplete
       : undefined;
   const hallu: RetakeHallucination[] = hallucinated.map((i) => ({
@@ -511,7 +536,65 @@ export function findRetakeGroups(
   analysis: Pick<Analysis, "silences" | "fillers">,
   opts: { transparentMarker?: string } = {},
 ): RetakeGroup[] {
-  const instances = buildInstances(transcript, analysis, opts.transparentMarker);
+  const { fragments, sentences } = buildInstances(transcript, analysis, opts.transparentMarker);
+  const groups = chainGroups(fragments);
+
+  // §135 sentence-level pass — the VO field case. Deliberate mid-sentence
+  // pauses (read-aloud delivery) make the restart split shred BOTH takes of a
+  // genuine retake into fragments that never match each other, and the
+  // fragment pass above reports nothing ("takes half [3s] a second" vs
+  // "…half a millisecond" — whole-sentence similarity 0.875, zero fragment
+  // matches). This pass re-runs the SAME chain algorithm over whole coarse
+  // sentences, then keeps a group only when:
+  //   (a) some member's sentence actually WAS split — unsplit sentences were
+  //       already compared whole by the fragment pass, so acting on them here
+  //       could only second-guess a decision that pass already made; and
+  //   (b) no member's words are claimed by a fragment-pass group — including
+  //       its `undecided` members, so a cut the abandonment/cut-validation
+  //       rules (§128) deliberately DECLINED stays declined.
+  // C1-style parallel rhetoric is safe here by construction: those are
+  // different sentences, and whole-sentence similarity scores the divergence
+  // the fragment prefixes hid.
+  const claimed = new Set<number>();
+  for (const g of groups) {
+    const members = [g.kept, ...g.cuts, ...g.hallucinated, ...g.undecided];
+    for (const m of members) {
+      if (!m) continue;
+      for (let w = m.startWord; w <= m.endWord; w++) claimed.add(w);
+    }
+  }
+  const splitByStartWord = new Map(sentences.map((s) => [s.startWord, s.wasSplit]));
+  for (const g of chainGroups(sentences, HALLUCINATION_SILENCE_FRAC)) {
+    const members = [g.kept, ...g.cuts, ...g.hallucinated, ...g.undecided].filter(
+      (m): m is RetakeInstance => m !== null,
+    );
+    if (!members.some((m) => splitByStartWord.get(m.startWord))) continue;
+    let overlaps = false;
+    for (const m of members) {
+      for (let w = m.startWord; w <= m.endWord && !overlaps; w++) {
+        if (claimed.has(w)) overlaps = true;
+      }
+    }
+    if (overlaps) continue;
+    groups.push(g);
+  }
+
+  // Two passes can interleave in transcript order — the report reads in
+  // word order, whichever pass found the group.
+  groups.sort((a, b) => {
+    const first = (g: RetakeGroup): number =>
+      Math.min(
+        ...[g.kept, ...g.cuts, ...g.hallucinated, ...g.undecided]
+          .filter((m): m is RetakeInstance => m !== null)
+          .map((m) => m.startWord),
+      );
+    return first(a) - first(b);
+  });
+  return groups;
+}
+
+/** The chaining rule (doc block above), shared by both passes verbatim. */
+function chainGroups(instances: readonly Instance[], survivorBar?: number): RetakeGroup[] {
   const groups: RetakeGroup[] = [];
 
   let anchor: Instance | null = null;
@@ -520,7 +603,7 @@ export function findRetakeGroups(
 
   const finalize = (): void => {
     if (chain.length >= 2 || (chain.length >= 1 && hallucinated.length > 0)) {
-      groups.push(buildGroup(chain, hallucinated));
+      groups.push(buildGroup(chain, hallucinated, survivorBar));
     }
     chain = [];
     hallucinated = [];