@ossclip/core 0.1.7 → 0.1.10

package/src/cutlist.ts

@@ -63,10 +63,19 @@ export interface BuildCutlistArgs {
   /**
    * Spans the speaker marked as bloopers out loud (R27 §122), from
    * `findBloopSpans`. Passed in rather than detected here so this stays a pure
-   * function of its arguments — and so `--blooper-marker` is the only thing
-   * that can put a `retake` cut in the timeline.
+   * function of its arguments.
    */
   bloops?: readonly { startWord: number; endWord: number; startSec: number; endSec: number }[];
+  /**
+   * Spans `findRetakeGroups` (R27 §128) elected to cut — the deterministic
+   * "keep only the last complete take" detector for the flub the speaker did
+   * NOT mark. Also a `reason: "retake"` cut, and also passed in rather than
+   * detected here, for the same purity reason as `bloops`: `buildCutlist`
+   * still has no judgement of its own about what a bad take looks like, it
+   * just folds whichever spans two independent detectors handed it into the
+   * one partition.
+   */
+  retakes?: readonly { startWord: number; endWord: number; startSec: number; endSec: number }[];
 }
 
 export function buildCutlist({
@@ -75,11 +84,13 @@ export function buildCutlist({
   duration,
   level,
   bloops,
+  retakes,
 }: BuildCutlistArgs): Segment[] {
   const keepAll: Segment[] = [{ srcIn: 0, srcOut: duration, kind: "keep" }];
   // `exact` means exact: it is the escape hatch for "touch nothing", and a
-  // blooper cut is still a cut. --blooper-marker with --cleanup exact is a
-  // contradiction, and the flag the user typed second does not get to win.
+  // blooper or retake cut is still a cut. --blooper-marker or
+  // --collapse-retakes with --cleanup exact is a contradiction, and the flag
+  // the user typed second does not get to win.
   if (level === "exact") return keepAll;
   const policy = POLICIES[level];
   const words = transcript.words;
@@ -105,6 +116,21 @@ export function buildCutlist({
     });
   }
 
+  // Same injection, same reason, lower confidence (R27 §128): a marker is the
+  // speaker asserting "this attempt is bad" — confidence 1. A retake group is
+  // this codebase inferring it from token similarity and the hallucination
+  // guard, so it earns 0.9, not 1 — the report and any future confidence-
+  // gated behavior can tell a supplied fact from an inferred one.
+  for (const r of retakes ?? []) {
+    removals.push({
+      start: r.startSec,
+      end: r.endSec,
+      reason: "retake",
+      confidence: 0.9,
+      source: "acoustic",
+    });
+  }
+
   for (const pause of analysis.cuttable) {
     // Lead and tail are decided by the SILENCE's position in the file, not by
     // comparing it to a word stamp (R27 §127). Whisper's `-ml 1` stamps stretch
@@ -178,7 +204,23 @@ export function buildCutlist({
   // keep. Acoustic boundaries are exempt: whisper's `-ml 1` stamps stretch a
   // word's end all the way to the next word's start, so a pause *always* looks
   // like it is "inside" a word — applying this rule to them cancels every cut.
-  const protectedWords = words.filter((_, i) => !fillerIndices.has(i));
+  //
+  // Fillers are excluded here ONLY when `policy.removeFillers` says they're
+  // actually being removed (fix wave final review, findings §124's
+  // follow-up): this same `protectedWords` list also feeds
+  // `hasProtectedWordInside` below, which Task 6 widened to fold a wordless
+  // keep-gap up to `policy.pauseMin` (1.2s at light). Excluding fillers
+  // unconditionally meant a lone "um" sitting in a gap between two silence
+  // removals read as "wordless" even at `light`, where `removeFillers` is
+  // false and the filler was never scheduled for removal at all — so the
+  // fold silently ate it, cutting a word `light`'s own contract promises to
+  // keep. The transcript-boundary loop right below is unaffected: it only
+  // ever runs for `source === "transcript"` removals, which only exist when
+  // `policy.removeFillers` created them (the `if (policy.removeFillers)`
+  // block above) — so at `light`, that loop already sees zero such removals
+  // and this widened list changes nothing for it, verified by reading rather
+  // than assumed.
+  const protectedWords = words.filter((_, i) => !policy.removeFillers || !fillerIndices.has(i));
   for (const r of removals) {
     if (r.source !== "transcript") continue;
     for (const w of protectedWords) {
@@ -193,12 +235,40 @@ export function buildCutlist({
       return mid > start && mid < end;
     });
 
-  // Merge removals that overlap, or whose in-between keep is a wordless sliver.
+  // Merge removals that overlap, or whose in-between keep is a wordless
+  // sliver — folded in regardless of length, not just when it's already
+  // under MIN_KEEP. A 0.37s wordless gap between two `silence` removals
+  // shipped in a real cleanup run because the old condition ANDed the
+  // wordless check to the length check, so `hasProtectedWordInside` was only
+  // ever asked once the gap was already short — a wordless gap that cleared
+  // MIN_KEEP was never asked at all (findings §124). MIN_KEEP's own comment
+  // already says wordless fragments fold; this makes the code do it.
+  //
+  // The fold is capped at `policy.pauseMin`, not left unbounded — folds any
+  // wordless gap UP TO pauseMin, refuses anything past it. The cap isn't
+  // about protecting short gaps; it's about what a gap LONGER than pauseMin
+  // sitting between two removals implies. The interior-pause branch above
+  // already generates its own removal for every genuinely silent stretch
+  // longer than pauseMin (`pauseDur <= policy.pauseMin` is the only case it
+  // skips) — so if a wordless-per-transcript gap that long survives here
+  // as bare space between two OTHER removals, the acoustic detector looked
+  // at it and did NOT call it silence. That's a live-audio signal the
+  // transcript can't see (a breath, laughter, room action, b-roll audio)
+  // being kept safe from a rule that only knows "the transcript found no
+  // words." A gap AT OR UNDER pauseMin, by contrast, is exactly the field
+  // bug's shape (0.37s, standard's 0.7s pauseMin): debris left over once
+  // both its neighbors are already cut, not a stretch the detector had any
+  // chance to flag on its own. `Math.max` with MIN_KEEP is defensive, not
+  // load-bearing: every current pauseMin already exceeds MIN_KEEP.
   const merged: Removal[] = [];
   for (const r of removals) {
     if (r.end - r.start < 0.05) continue;
     const prev = merged[merged.length - 1];
-    if (prev && (r.start <= prev.end + 1e-6 || (r.start - prev.end < MIN_KEEP && !hasProtectedWordInside(prev.end, r.start)))) {
+    const gap = prev ? r.start - prev.end : Number.POSITIVE_INFINITY;
+    const overlapping = prev !== undefined && gap <= 1e-6;
+    const wordless = prev !== undefined && !hasProtectedWordInside(prev.end, r.start);
+    const foldableGap = wordless && gap <= Math.max(MIN_KEEP, policy.pauseMin);
+    if (prev && (overlapping || foldableGap)) {
       const prevDur = prev.end - prev.start;
       const curDur = r.end - r.start;
       prev.end = Math.max(prev.end, r.end);

package/src/index.ts

@@ -6,12 +6,15 @@ export * from "./assemble";
 export * from "./fill";
 export * from "./producer/index";
 export * from "./timemap";
+export * from "./recut";
 export * from "./ingest";
+export * from "./concat";
 export * from "./transcribe";
 export * from "./analyze";
 export * from "./cutlist";
 export * from "./clip";
 export * from "./blooper";
+export * from "./retake";
 export * from "./captions";
 export * from "./zoom";
 export * from "./grounding";

package/src/overrides.ts

@@ -23,6 +23,19 @@ export const ElementTransformSchema = z.object({
   dx: z.number().optional(),
   dy: z.number().optional(),
   scale: z.number().positive().optional(),
+  /**
+   * The element is deleted — SOFTLY (PLAN Task 2, one level down from
+   * `SceneOverrideSchema.hidden` below): `editStyle`
+   * (packages/scenes/src/editable.ts) suppresses it at the one chokepoint
+   * every component's leaf renders its edit style through, so no
+   * per-component change is needed and the remaining siblings close the
+   * gap on their own — the same delete semantics a whole SCENE gets,
+   * scoped to one of its elements. The backing array
+   * (`props.messages`/`lines`/`nodes`/`items`) is never touched — ids are
+   * positional, so hiding `message-1` can't renumber `message-2` out from
+   * under its own edits.
+   */
+  hidden: z.boolean().optional(),
 });
 export type ElementTransform = z.infer<typeof ElementTransformSchema>;
 
@@ -169,6 +182,51 @@ export const OverrideDocSchema = z.object({
    * split lands on graphic cues and takes alike.
    */
   splits: z.array(z.number().nonnegative()).default([]),
+  /**
+   * User cuts — ranges of the OUTPUT to remove, in the output seconds of the
+   * CURRENT render-props (what the user saw when they cut) (PLAN 2026-08-04
+   * Task 4). Optional-with-default like `splits` above, so an `overrides.json`
+   * written before this field existed still parses unchanged. Consumed by
+   * `produce.ts` (subtracted from the automatic cutlist's keep-spans) and by
+   * `recut.ts`'s `remapOverridesThroughRecut`, which re-anchors every OTHER
+   * absolute-output-seconds value in this doc through the resulting re-cut —
+   * see that module's docstring for why a bare "shift everything after the
+   * cut point" is not the actual rule.
+   *
+   * `src` (review fix wave, PLAN 2026-08-04 Task 4): a cut's `startSec`/
+   * `endSec` alone are meaningless without knowing WHICH render-props they
+   * were drawn against — a bare output-seconds pair has no faithful
+   * representation once its own cut has happened (Task 4b's Bug A: remapping
+   * it through the very recut it caused collapses it to a zero-width point).
+   * `src` is the cut's resolved SOURCE-time range, computed once — the first
+   * produce run that sees a `src`-less cut resolves it against the
+   * render-props the user was looking at, and the write-back records it here
+   * — and used directly, unconverted, on every run after that. `startSec`/
+   * `endSec` are left exactly as the user drew them even once `src` exists:
+   * a historical record of what render-props they were looking at, never
+   * authoritative again once `src` is present.
+   *
+   * The editor (PLAN 2026-08-04 Task 4c) MUST NEVER WRITE OR
+   * PRESERVE-AND-MODIFY `src` ITSELF — resolving it is produce's job alone.
+   * Creating a cut writes ONLY `{startSec, endSec}`; if a cut's range is
+   * ever edited/moved (not currently exposed, but the rule holds for any
+   * future gesture that would), its `src` is DELETED rather than carried
+   * forward, so the next produce re-resolves it against the render-props
+   * current at that point rather than an anchor drawn for a range that no
+   * longer means the same thing; Restore removes the WHOLE entry, `src`
+   * included — there is no "not cut" state for one array entry to hold.
+   */
+  cuts: z
+    .array(
+      z.object({
+        startSec: z.number().nonnegative(),
+        endSec: z.number().nonnegative(),
+        src: z
+          .object({ startSec: z.number().nonnegative(), endSec: z.number().nonnegative() })
+          .optional(),
+      }),
+    )
+    .default([]),
 });
 export type OverrideDoc = z.infer<typeof OverrideDocSchema>;
 
@@ -364,6 +422,33 @@ export function dropHiddenCues(cues: readonly SceneCue[], doc: OverrideDoc): Dro
   return { cues: out, hidden };
 }
 
+/**
+ * Split at the stored split points BEFORE dropping hidden cues (PLAN
+ * 2026-08-04 Task 1, bug 3).
+ *
+ * `dropHiddenCues` matches by the EXACT id the user deleted, and a split
+ * root's `hidden` is meant to apply only to "the root's own post-split
+ * segment (the half that still carries the bare id)" per `effectiveOverride`
+ * above — but `produce.ts` and the editor's live memo both called
+ * `dropHiddenCues` on the ROOT cues, before `splitCues` had run. That erased
+ * the ENTIRE pre-split window (both halves at once); the plain fill then
+ * covered it with one take, and the later `splitCues` call cut that PLAIN
+ * take into two plain pieces — killing the graphic on the half the user
+ * never asked to delete (field case: `scene-6` deleted, `scene-6@36400` died
+ * with it). Splitting first means a hidden root id only ever matches the
+ * post-split cue that kept the bare id, exactly the exception
+ * `effectiveOverride` already promises. Safe to call again after the fill's
+ * own `splitCues` pass — re-splitting at a boundary that already exists is a
+ * no-op (the split point sits exactly on the joint, so neither piece's
+ * window contains it).
+ */
+export function splitThenDropHidden(
+  cues: readonly SceneCue[],
+  doc: OverrideDoc,
+): DropHiddenResult {
+  return dropHiddenCues(splitCues(cues, doc.splits), doc);
+}
+
 export interface AppliedCaptionEdits {
   lines: CaptionLine[];
   /** Edits whose guard failed — the word at that index is not what they knew. */
@@ -434,6 +519,43 @@ export function clearElementTransform(
   return { ...doc, scenes: { ...doc.scenes, [sceneId]: { ...scene, elements: rest } } };
 }
 
+/**
+ * Un-hide ONE element: DELETE only the `hidden` key (PLAN Task 2), so a
+ * nudge/scale made before the delete survives the restore — the
+ * element-level mirror of `restoreScene`'s "delete the key, don't write a
+ * false-ish value" rule below. `clearElementTransform` above stays the FULL
+ * reset (nudges included); this is the narrower "bring it back as it was"
+ * gesture the element panel's Restore button offers.
+ */
+export function restoreElement(
+  doc: OverrideDoc,
+  sceneId: string,
+  elementId: string,
+): OverrideDoc {
+  const scene = doc.scenes[sceneId];
+  const entry = scene?.elements[elementId];
+  if (!scene || !entry?.hidden) return doc;
+  const { hidden: _dropped, ...rest } = entry;
+  // `elements` merges per ID, not per FIELD (`effectiveOverride` above:
+  // `elements: { ...base.elements, ...own.elements }` replaces a shared id
+  // WHOLESALE, unlike `video`/`pip`, which merge field by field). Review
+  // fix wave, PLAN Task 2: a half whose own entry was ONLY `{hidden:true}`
+  // would otherwise be left with the empty leftover `{}` once `hidden` is
+  // stripped — and that empty object still wins the wholesale merge,
+  // permanently shadowing whatever nudge the split ROOT had for this id,
+  // even though "restore keeps nudges" is exactly this function's promise.
+  // Dropping the key entirely once nothing but `hidden` was ever on it lets
+  // the root's own entry (if any) show through again — same "delete rather
+  // than leave an inert key" instinct as clearVideo/clearTiming.
+  const { [elementId]: _own, ...withoutEntry } = scene.elements;
+  const elements =
+    Object.keys(rest).length > 0 ? { ...scene.elements, [elementId]: rest } : withoutEntry;
+  return {
+    ...doc,
+    scenes: { ...doc.scenes, [sceneId]: { ...scene, elements } },
+  };
+}
+
 /**
  * Un-pin: DELETE the `timing` override so the scene goes back to tracking its
  * word anchors. Distinct from setting a timing that happens to match the
@@ -469,6 +591,25 @@ export interface ReclampResult {
   adjusted: string[];
 }
 
+/**
+ * The scene a cue id belongs to, stripping a split half's `@ms` suffix —
+ * same idiom `splitCues` itself uses to derive a later half's id from its
+ * root, and the same one `effectiveOverride` above inlines to find a half's
+ * root entry. Two cues sharing a root are the SAME scene, cut in two.
+ *
+ * Exported (PLAN Task 2 review fix) for the editor's own use: a hidden
+ * ELEMENT on a split half can be inherited from the root (`elements`
+ * merges per id in `effectiveOverride`, and `elements` is NOT in that
+ * function's inheritance-exclusion list the way `timing`/`hidden` are) —
+ * Inspector.tsx's per-row Restore has to know whether the `hidden` it's
+ * offering to undo lives on the half's own doc entry or the root's, and
+ * this is the same root-id derivation either side of that decision needs.
+ */
+export function splitRootId(id: string): string {
+  const at = id.indexOf("@");
+  return at === -1 ? id : id.slice(0, at);
+}
+
 /**
  * Re-clamp every PINNED cue's absolute timing against its current neighbours
  * in the array, in order.
@@ -492,8 +633,22 @@ export function reclampPinnedTiming(cues: readonly SceneCue[]): ReclampResult {
     if (!cue.pinned) continue;
     const prev = out[i - 1];
     const next = out[i + 1];
-    const lo = prev ? prev.endSec + PINNED_GAP_SEC : 0;
-    const hi = next ? next.startSec - PINNED_GAP_SEC : Number.POSITIVE_INFINITY;
+    // Two adjacent pinned cues that are split halves of the SAME scene are
+    // not independent neighbours (PLAN 2026-08-04 Task 1 follow-up, found in
+    // review): `splitThenDropHidden` now runs `splitCues` before this
+    // function, so a pinned+split scene reaches here as two entries, both
+    // still `pinned: true`, with an EXACT boundary (`left.endSec ===
+    // right.startSec`) that `splitCues` already cut. Applying the usual
+    // `PINNED_GAP_SEC` buffer between them would carve a sliver out of the
+    // seam that `fillPlainCues` then fills with a spurious plain take
+    // spliced between the two halves — bug 3 again, one layer up, even
+    // though the cue array itself looks correctly split.
+    const prevIsSibling = prev?.pinned === true && splitRootId(prev.id) === splitRootId(cue.id);
+    const nextIsSibling = next?.pinned === true && splitRootId(next.id) === splitRootId(cue.id);
+    const lo = prev ? prev.endSec + (prevIsSibling ? 0 : PINNED_GAP_SEC) : 0;
+    const hi = next
+      ? next.startSec - (nextIsSibling ? 0 : PINNED_GAP_SEC)
+      : Number.POSITIVE_INFINITY;
     let s = Math.min(Math.max(cue.startSec, lo), Math.max(lo, hi - MIN_PINNED_SCENE_SEC));
     let e = Math.max(Math.min(cue.endSec, hi), s + MIN_PINNED_SCENE_SEC);
     if (e > hi) {

package/src/phonetics.ts

@@ -69,7 +69,12 @@ function phraseKey(text: string): string {
     .join("");
 }
 
-function levenshtein(a: string, b: string): number {
+// Exported: blooper.ts reuses this directly for the marker fuzzy-match arm
+// (Task 3, editor-dogfood-fixes plan) instead of a second copy — plain edit
+// distance on the raw normalized word, not the phonetic key `soundsLike`
+// compares, because "blooper"/"looker" fails the onset test below yet is
+// exactly the mishearing the marker match needs to catch.
+export function levenshtein(a: string, b: string): number {
   if (a === b) return 0;
   if (a.length === 0) return b.length;
   if (b.length === 0) return a.length;