npm - ossclip - Versions diffs - 0.1.18 → 0.1.19 - Mend

ossclip 0.1.18 → 0.1.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/editor-dist/assets/index-B44I-xE4.js +163 -0
package/editor-dist/assets/index-ChRVBVLj.css +1 -0
package/editor-dist/index.html +2 -2
package/package.json +4 -4
package/src/caption-report.ts +217 -0
package/src/edit.ts +38 -0
package/src/overrides-write.ts +77 -0
package/src/produce.ts +61 -36
package/editor-dist/assets/index-C8IPo60X.css +0 -1
package/editor-dist/assets/index-CdwzWN3j.js +0 -162

package/editor-dist/assets/index-ChRVBVLj.css ADDED Viewed

@@ -0,0 +1 @@

+ .ossclip-scroll-list{scrollbar-width:thin;scrollbar-color:#3a3a44 transparent}.ossclip-scroll-list::-webkit-scrollbar{width:8px}.ossclip-scroll-list::-webkit-scrollbar-track{background:transparent}.ossclip-scroll-list::-webkit-scrollbar-thumb{background:#3a3a44;border-radius:4px}.ossclip-picker-row{color:#c9c9d4;background:transparent;border:1px solid transparent}.ossclip-picker-row.is-workdir{color:#ededf2;background:#1a1a21;border-color:#2a2a33}.ossclip-picker-row:disabled{cursor:default;opacity:.5}.ossclip-picker-row:hover:not(:disabled){background:#1f1f28;border-color:#3a3a48}.ossclip-picker-row:focus{outline:none;background:#23232e;border-color:#8ab4f8}.ossclip-picker-row:active:not(:disabled){background:#2a2a36}

package/editor-dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ossclip editor</title>
-    <script type="module" crossorigin src="/assets/index-CdwzWN3j.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-C8IPo60X.css">
+    <script type="module" crossorigin src="/assets/index-B44I-xE4.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-ChRVBVLj.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Local-first CLI video producer: cuts silence and fillers, word-timed captions, face-aware framing, and LLM-planned code-rendered graphics — transcription and rendering never leave your machine",
   "type": "module",
   "license": "MIT",
@@ -36,9 +36,9 @@
     "commander": "^12.1.0",
     "tsx": "^4.19.0",
     "zod": "^3.25.76",
-    "@ossclip/core": "0.1.18",
-    "@ossclip/renderer": "0.1.18",
-    "@ossclip/scenes": "0.1.18"
+    "@ossclip/core": "0.1.19",
+    "@ossclip/renderer": "0.1.19",
+    "@ossclip/scenes": "0.1.19"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/caption-report.ts ADDED Viewed

@@ -0,0 +1,217 @@
+import {
+  applyCaptionEdits,
+  captionEditsToKeep,
+  isLegacyCaptionKey,
+  migrateCaptionKeys,
+  MIGRATION_SEARCH_RADIUS,
+} from "@ossclip/core";
+import type {
+  AppliedCaptionEdits,
+  CaptionEdit,
+  CaptionKeyMigration,
+  CaptionLine,
+  OverrideDoc,
+} from "@ossclip/core";
+/**
+ * What `produce` does with the user's retyped caption words, and what it says
+ * about the ones that did not land (§137).
+ *
+ * Pure, and in its own module rather than inline in `produce.ts`, for the
+ * house reason: this is a decision about the user's data (which edits are
+ * re-anchored, which are applied, and why the others were not) and a
+ * `produce()` run needs ffmpeg, a transcript and a workdir before it reaches
+ * any of it. `produce.ts` keeps the `console.log` and the file writes.
+ */
+/** One drop, as a console line. Three cases, and the caller must not merge them. */
+export function captionDropLine(drop: AppliedCaptionEdits["dropped"][number]): string {
+  // `found: null` used to be interpolated straight into the sentence, so a
+  // word the cut removed reported `the transcript now has "null"` — the one
+  // case §137 exists for, described as a JSON literal. The three cases carry
+  // genuinely different advice, so they get genuinely different sentences.
+  if (drop.reason === "duplicate-anchor") {
+    // NOT a stale edit: the edit almost certainly applied, to the FIRST word
+    // carrying this anchor. Two words share one source instant by design
+    // (captions.ts:44-50 — backfilled seam preimages and cut-clamped words),
+    // so this is a note about reach, not a failure.
+    return (
+      `  ⚠ caption edit "${drop.expected}" (${drop.key}): a second word shares that ` +
+      `source moment and was left as it is — only the first was retyped`
+    );
+  }
+  if (drop.found === null) {
+    // A key that is a POSITION, not a source anchor, never had a moment to
+    // lose — it is a pre-§137 doc the migration could not upgrade. Saying "the
+    // cut removed it" there sends the user to redo work that is sitting intact
+    // on screen (§137 Task 6 review, Important 2). Reachable whenever an edit
+    // reaches `applyCaptionEdits` without going through `migrateCaptionKeys`.
+    if (isLegacyCaptionKey(drop.key)) {
+      return (
+        `  ⚠ caption edit "${drop.expected}" (position ${drop.key}) not applied: it is keyed ` +
+        `by word POSITION, from a project saved before source anchors, and nothing ` +
+        `re-anchored it — open the project in the editor, or retype it there`
+      );
+    }
+    return (
+      `  ⚠ caption edit "${drop.expected}" (${drop.key}) dropped: no word starts at that ` +
+      `source moment any more — the cut removed the word it was typed over. ` +
+      `Retype it in the editor if you still want it.`
+    );
+  }
+  return (
+    `  ⚠ caption edit "${drop.expected}" (${drop.key}) dropped: the transcript now says ` +
+    `"${drop.found}" there`
+  );
+}
+/**
+ * How many stored edits actually landed.
+ *
+ * NOT `keys.length - dropped.length` (§137): `dropped` is not one entry per
+ * key. A `duplicate-anchor` entry is pushed for every EXTRA word carrying an
+ * anchor, so a single key can appear in `dropped` two or three times — and it
+ * may have applied anyway. The old subtraction therefore undercounted, and
+ * with enough duplicates went NEGATIVE, which the `> 0` guard then hid
+ * entirely: the run printed nothing at all about edits that had applied.
+ *
+ * The rule comes straight from `applyCaptionEdits`' own contract: a key is
+ * marked `seen` by the first word carrying it, and that word either applied
+ * the edit or was reported with `reason` ABSENT. So an edit landed exactly
+ * when nothing was reported for its key without a `reason`.
+ */
+export function appliedCaptionEditCount(
+  edits: Record<string, CaptionEdit>,
+  dropped: AppliedCaptionEdits["dropped"],
+): number {
+  const failed = new Set(dropped.filter((d) => d.reason === undefined).map((d) => d.key));
+  return Object.keys(edits).filter((key) => !failed.has(key)).length;
+}
+/**
+ * One console line for a legacy edit the migration would not place (§137).
+ *
+ * One sentence per CAUSE, like the editor's own notice: three of the four
+ * leave the word sitting right there in the transcript, and a single message
+ * blaming the cut would send the user hunting for it.
+ */
+export function captionMigrationLine(u: CaptionKeyMigration["unresolved"][number]): string {
+  const head = `  ⚠ caption edit "${u.was}" (${u.key}) could not be re-anchored`;
+  switch (u.reason) {
+    case "out-of-range":
+      // The word is ON SCREEN. Blaming the cut here (which the shared
+      // `not-found` sentence did until the final review) sends the user to
+      // retype something that is sitting intact in the transcript — and the
+      // edit is kept in the doc, so the next run against a different cut may
+      // place it without them doing anything at all.
+      // No promise that retyping fixes it, either: the word this found may
+      // itself be unanchorable (a pre-§137 render-props.json with nothing to
+      // backfill from), and "re-anchors it for good" would be a guarantee this
+      // line cannot make.
+      return `${head}: the word is still here, but more than ${MIGRATION_SEARCH_RADIUS} words from where the edit was stored, so it was left alone rather than applied to the wrong one — it is kept in overrides.json, so retype it in the editor if that is the word you meant`;
+    case "ambiguous":
+      return `${head}: more than one word says it here, so it was left alone rather than applied to the wrong one — retype the one you meant in the editor`;
+    case "unanchorable":
+      return `${head}: the word is here but carries no source timing to key on`;
+    case "collision":
+      return `${head}: two stored edits point at the same word — neither was applied, retype the one you meant in the editor`;
+    case "superseded":
+      return `${head}: a newer edit already covers that word — the newer one was kept`;
+    default:
+      return `${head}: no word says it any more — the cut or a re-plan removed it. Retype it in the editor if you still want it.`;
+  }
+}
+/**
+ * How many edits came out under a key they did not go in under — the ones the
+ * migration actually moved.
+ *
+ * NOT `Object.keys(migration.edits).length`, which is what the count in the log
+ * line was first written as: a MIXED doc (`{"0": …, "w6000": …}` over one word)
+ * keeps its already-source-keyed edit and retires the legacy one, so that
+ * count announced "1 caption edit re-anchored" about a key nothing had
+ * touched. A number the user can check against their own file has to be true
+ * for the same reason the drop lines do.
+ */
+export function reanchoredKeyCount(
+  before: Record<string, CaptionEdit>,
+  migration: CaptionKeyMigration,
+): number {
+  return Object.keys(migration.edits).filter((key) => !(key in before)).length;
+}
+export interface CaptionReconciliation {
+  /** The doc with its caption keys upgraded — what produce writes back. */
+  doc: OverrideDoc;
+  /** The caption lines with every edit that could be applied, applied. */
+  lines: CaptionLine[];
+  /**
+   * Whether the migration actually MOVED an edit onto a source anchor — the
+   * write-back gate, and the only thing that earns spending the `.bak`.
+   *
+   * It used to be `captionKeysMigrated`: true whenever anything was
+   * unresolved, including when nothing at all was placed. That is a write with
+   * no repair in it, and on the field workdir (`cutResult.changed` false,
+   * because the cut already carries `src`) it was a NEW write on a run that
+   * previously touched nothing — spending `overrides.json.bak`, the user's
+   * only surviving pre-cut save and the sole route back to the split half they
+   * deleted, on a copy of the already-damaged document (final review, Critical
+   * 2). A run that placed nothing has nothing to write and no business
+   * touching the `.bak`. Renamed as well as re-defined, because "keys changed"
+   * is no longer even true of it: a `superseded` retirement changes the keys
+   * and deliberately does not fire this.
+   */
+  reanchored: boolean;
+  /** Everything produce should print about this, in order. */
+  log: string[];
+}
+/**
+ * Migrate, then apply, then account for the difference — the whole caption
+ * half of a produce run, in one pure pass.
+ *
+ * MIGRATE FIRST, and against these same lines: `applyCaptionEdits` addresses
+ * words by source anchor, so a pre-§137 positional key matches nothing at all
+ * and every retype in an old project would be silently absent from the render
+ * (§137 Task 6 review, Critical 1). Nothing needs backfilling here — produce
+ * builds these lines itself, with a real `srcStart` on every word — which is
+ * exactly why this migration belongs in produce even though the same call in
+ * the edit server would be inert.
+ *
+ * WHAT IS APPLIED AND WHAT IS KEPT ARE DIFFERENT SETS, deliberately (final
+ * review, Critical 1). Only the edits the migration PLACED are applied — an
+ * unresolved key addresses no word, so handing it to `applyCaptionEdits` would
+ * buy nothing but a second, worse-worded report of the same edit. The doc
+ * written back keeps them anyway (`captionEditsToKeep`), because a run that
+ * cannot place an edit today is not a licence to delete it.
+ *
+ * The caller must hand a doc that has been through `OverrideDocSchema`
+ * (`produce.ts` parses it at the top of the run). On raw `JSON.parse` output a
+ * literal `"__proto__"` key would be assigned THROUGH rather than kept, and
+ * the migration would report nothing lost while losing it.
+ */
+export function reconcileCaptionEdits(
+  doc: OverrideDoc,
+  baseLines: readonly CaptionLine[],
+): CaptionReconciliation {
+  const log: string[] = [];
+  const migration = migrateCaptionKeys(doc.captions, baseLines);
+  // The MOVED count is both the log gate and the write gate. As a log gate:
+  // announcing "0 caption edit(s) re-anchored" above the lines saying why is
+  // noise on the one run where the user is reading carefully. As a write gate:
+  // see `CaptionReconciliation.reanchored` — a run that placed nothing must
+  // not spend the `.bak`.
+  const reanchored = reanchoredKeyCount(doc.captions, migration);
+  if (reanchored > 0) {
+    log.push(
+      `▸ ${reanchored} caption edit(s) re-anchored from word positions to source time (§137)`,
+    );
+  }
+  for (const u of migration.unresolved) log.push(captionMigrationLine(u));
+  const migrated = { ...doc, captions: captionEditsToKeep(doc.captions, migration) };
+  const { lines, dropped } = applyCaptionEdits(baseLines, migration.edits);
+  const live = appliedCaptionEditCount(migration.edits, dropped);
+  if (live > 0) log.push(`▸ ${live} caption word(s) retyped by the editor`);
+  for (const d of dropped) log.push(captionDropLine(d));
+  return { doc: migrated, lines, reanchored: reanchored > 0, log };
+}

package/src/edit.ts CHANGED Viewed

@@ -259,9 +259,29 @@ export async function startEditServer(
             return send(200, { noWorkdir: true, recent: await readRecentProjects(opts.recentDir) });
           }
           const renderProps = JSON.parse(await readFile(propsPath(), "utf8"));
+          // Parsed, never cast — and that parse is also what makes the doc
+          // safe to migrate downstream: a literal `"__proto__"` caption key
+          // survives `JSON.parse` as an own property, and any later pass that
+          // rebuilds the record would assign through it instead of keeping it.
           const overrides = existsSync(overridesPath())
             ? OverrideDocSchema.parse(JSON.parse(await readFile(overridesPath(), "utf8")))
             : emptyOverrideDoc();
+          // §137 DECISION (Task 6): the pre-§137 caption-key migration does
+          // NOT run here. It resolves a positional key by finding the word it
+          // named and taking that word's source anchor — and these render
+          // props are served exactly as they sit on disk, where a pre-§137
+          // file's caption words have no `srcStart` at all. Every word would
+          // answer "no anchor", every edit would land in `unresolved`, and the
+          // migration would report total loss while doing nothing: a call that
+          // passes its own tests and is inert in production.
+          // Anchoring them here instead would mean a second copy of the "no
+          // usable map, no repair" rule (`anchorCaptionLines`, apps/editor) in
+          // this package — the CLI cannot import the editor's source, which it
+          // only ever ships as a built `editor-dist/` — and that rule is
+          // exactly the one §137 refuses to have two of. So the EDITOR owns
+          // the repair, at the one point that holds anchored lines and the doc
+          // at the same time (App.tsx's load path), and it loses no reach:
+          // this endpoint has exactly one consumer.
           return send(200, {
             renderProps,
             overrides,
@@ -450,6 +470,24 @@ export async function startEditServer(
           for await (const c of req) chunks.push(c as Buffer);
           const parsed = OverrideDocSchema.safeParse(JSON.parse(Buffer.concat(chunks).toString()));
           if (!parsed.success) return send(400, { error: parsed.error.message });
+          // NO `.bak` HERE, and that is a decision, not an omission (final
+          // review, Important 5). This write is safe without one only because
+          // it ROUND-TRIPS: whatever the editor loaded, it saves back, plus
+          // the change the user just made. §137 briefly broke that property —
+          // `migrateLoadedDoc` stripped the caption edits the migration could
+          // not place before `edits.load` (which also clears undo), so the
+          // first save after opening a legacy project deleted them
+          // permanently. The fix is in `migrateLoadedDoc`, which now keeps
+          // them, rather than here.
+          //
+          // Adding produce's `.bak` to this handler was the other option and
+          // is actively worse: `overrides.json.bak` is single-generation and
+          // SHARED with produce's write, so a routine ⌘S would spend the one
+          // the user's pre-cut save is sitting in — which on the §137 field
+          // workdir is the only artefact their deleted split half can ever be
+          // recovered from (`legacySplitId`). That is the review's own
+          // Critical 2 reintroduced through the editor.
+          //
           // Atomic: the producer may read this file at any moment, and a
           // half-written document would be worse than a stale one.
           const tmp = `${overridesPath()}.tmp`;

package/src/overrides-write.ts ADDED Viewed

@@ -0,0 +1,77 @@
+import { readFile, rename, writeFile } from "node:fs/promises";
+import type { OverrideDoc } from "@ossclip/core";
+/**
+ * The one sanctioned `overrides.json` write (PLAN 2026-08-04 Task 4), and the
+ * rule about when it may spend the `.bak`.
+ *
+ * Lifted out of `produce.ts` so the backup rule is testable at all: nothing in
+ * the repo invokes `produce()` (it needs ffmpeg, a transcript, a workdir and a
+ * render), and "the previous copy is still on disk, byte for byte" is a claim
+ * about a FILE — there is no pure form of it. `produce.ts` keeps the decision
+ * of WHETHER to write, the ordering relative to `render-props.json`, and the
+ * `console.log`.
+ */
+/**
+ * Replace `overrides.json`, optionally refreshing `overrides.json.bak` first.
+ *
+ * REFRESHING THE BACKUP IS NOT PART OF WRITING (final review round 2, Critical
+ * 2 residual). The `.bak` is single-generation, so every refresh SPENDS
+ * whatever it held, and the two writers have very different claims on it:
+ *
+ *  - A CUT re-anchoring rewrites absolute output-second VALUES all over the
+ *    doc — split times, pins, framing — from a frame the pipeline just
+ *    recomputed. That is unreadable in a diff and irreversible by hand, so the
+ *    copy it replaces is worth keeping and this is the write the `.bak` exists
+ *    for.
+ *  - A CAPTION-KEY migration differs from the copy on disk in caption KEYS
+ *    only, every one of which the run just printed by name, and (since
+ *    `captionEditsToKeep`) it deletes nothing. There is nothing in the old
+ *    copy worth recovering — while the `.bak` it would overwrite may be the
+ *    user's last PRE-CUT save, which on the §137 field workdir is the only
+ *    artefact holding `splits: [0.6]` and so the only route back to the split
+ *    half they deleted (`legacySplitId` can no longer derive `600` from a
+ *    re-anchored `splits: [0]`).
+ *
+ * The first cut of the §137 fix refreshed unconditionally, which meant the
+ * branch's own marquee scenario — three of that user's four retypes recovered
+ * — destroyed the evidence for the other half of the same bug. Gating the
+ * WRITE on work done (`produce.ts`) only removed the zero-repair case; this is
+ * the rest of it.
+ *
+ * Atomic via tmp+rename either way, matching the edit server's own
+ * `PUT /overrides` handler: the producer or a live editor session may read
+ * this file at any moment, and a half-written document would be worse than a
+ * stale one.
+ */
+export async function writeOverrideDoc(
+  overridesPath: string,
+  doc: OverrideDoc,
+  opts: { refreshBackup: boolean },
+): Promise<void> {
+  if (opts.refreshBackup) {
+    try {
+      const raw = await readFile(overridesPath, "utf8");
+      await writeFile(`${overridesPath}.bak`, raw);
+    } catch {
+      // Nothing on disk to back up (first cut ever applied here) — fine.
+    }
+  }
+  const tmp = `${overridesPath}.tmp`;
+  await writeFile(tmp, JSON.stringify(doc, null, 2));
+  await rename(tmp, overridesPath);
+}
+/**
+ * What the run says about that write. Pure, and separate from the write for
+ * the house reason — but also because the two halves of this sentence are the
+ * two halves of the decision above, and a line that claims a backup nobody
+ * took is how a user finds out too late (final review round 2).
+ */
+export function overridesWriteLine(cutChanged: boolean): string {
+  return cutChanged
+    ? "▸ overrides.json re-anchored to the new cut and saved (previous copy kept as .bak)"
+    : "▸ overrides.json re-anchored to source-time caption keys and saved " +
+        "(overrides.json.bak left alone — it may be an older, pre-cut copy worth more than this one)";
+}

package/src/produce.ts CHANGED Viewed

@@ -15,7 +15,6 @@ import {
   applyOverrides,
   applyRepairs,
   assembleScenes,
-  applyCaptionEdits,
   buildCaptionLines,
   buildCutlist,
   buildZoomPlan,
@@ -105,6 +104,8 @@ import {
   workdirBaseName,
 } from "./stranded-overrides";
 import { editHint } from "./interactive/edit-hint";
+import { reconcileCaptionEdits } from "./caption-report";
+import { overridesWriteLine, writeOverrideDoc } from "./overrides-write";
 import { recordedProduceArgs } from "./replay-argv";
 import { renderCover, renderProduction } from "@ossclip/renderer";
 import {
@@ -1595,7 +1596,8 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     clipStarts: map.spans.map((s) => s.outIn),
   });
   // User splits (R16 §61) — after the fill so takes split like scenes, and
-  // before the final override pass so edits on the `id@ms` halves land. A
+  // before the final override pass so edits on the `id@<split id>` halves land
+  // (the suffix is the split's own minted id, §137, not its time). A
   // split whose ROOT was a graphic scene already happened once inside
   // `splitThenDropHidden` above (PLAN 2026-08-04 Task 1) — re-running it here
   // is a no-op for that scene (the split point sits exactly on the joint
@@ -1607,7 +1609,7 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   }
   const { cues: mergedCues, orphans: rawOrphans } = applyOverrides(split, overrideDoc);
   // Halves of a TAKE the user deleted after splitting: a take id only exists
-  // once the fill above runs, so its `id@ms` half couldn't have been seen by
+  // once the fill above runs, so its `id@<split id>` half couldn't have been seen by
   // `splitThenDropHidden` earlier (that pass only ever saw graphic scenes).
   // Scene halves were already caught above; this is a no-op for them. Same
   // order as the editor's live memo.
@@ -1931,22 +1933,36 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     // caption output for zero visual reason (PLAN Task A4.4).
     breakpoints: graphicCues.flatMap((c) => [c.startSec, c.endSec]),
   });
-  // The user's retyped caption words (editor, PLAN 2026-07-29 Task 7 scope
-  // (a)). Guarded per word: a stale edit — the pipeline re-derived a
-  // different word at that position — is dropped LOUDLY, never applied to
-  // the wrong word and never silently forgotten.
-  const { lines: captionLines, dropped: staleCaptionEdits } = applyCaptionEdits(
-    baseCaptionLines,
-    overrideDoc.captions,
-  );
-  const liveCaptionEdits = Object.keys(overrideDoc.captions).length - staleCaptionEdits.length;
-  if (liveCaptionEdits > 0) console.log(`▸ ${liveCaptionEdits} caption word(s) retyped by the editor`);
-  for (const d of staleCaptionEdits) {
-    console.log(
-      `  ⚠ caption edit at word ${d.index} dropped: expected "${d.expected}" there, ` +
-        `the transcript now has "${d.found}"`,
-    );
-  }
+  // §137 (Task 6 review, Critical 1): the caption half of a run — migrate the
+  // doc's keys, apply what applies, and account for the rest — is one pure
+  // pass in `caption-report.ts`, and this is its I/O.
+  //
+  // MIGRATION RUNS HERE, not only in the editor. The editor's is in memory and
+  // `edits.load` leaves the doc CLEAN, so `onRender` (which saves only when
+  // dirty) sends a user who opened an old project, saw every retype come back
+  // on screen, and clicked Render straight into this function with the
+  // untouched legacy doc — and `applyCaptionEdits` matched nothing, so the
+  // render shipped without a single retype after showing a state strictly more
+  // convincing than the truth. None of the reasoning that keeps this call out
+  // of `edit.ts` applies: `buildCaptionLines` just stamped a real `srcStart`
+  // on every word above (`captions.ts:128`), so there is nothing to backfill
+  // and no repair rule to duplicate.
+  //
+  // THE MIGRATED DOC IS WRITTEN BACK — the decision, stated: through the one
+  // sanctioned `overrides.json` write further down, with its `.bak` and atomic
+  // rename, never a second write here. A legacy key's resolvability DECAYS (it
+  // is found by the word it names, so the next re-plan that rewrites that word
+  // loses it for good), and this is the only durable repair in the product —
+  // the editor's evaporates, as Critical 1 showed. The edits it could NOT
+  // place stay in the doc regardless (`captionEditsToKeep`): they are printed
+  // by name below, and a run that cannot anchor one today is not permission to
+  // delete it — the next run, against a different cut, may place it (final
+  // review, Critical 1).
+  const captionWork = reconcileCaptionEdits(overrideDoc, baseCaptionLines);
+  overrideDoc = captionWork.doc;
+  const captionLines = captionWork.lines;
+  const captionKeysReanchored = captionWork.reanchored;
+  for (const line of captionWork.log) console.log(line);
   // Micro zoom punches (FINDINGS §15) reversing at real phrase breaks (§18).
   // Breaths are source-time; TimeMap has no span mapper, so both ends go
@@ -2185,23 +2201,32 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // next run's `priorMap` then sees drift and re-anchors again, the same
   // recovery path finding 3 already has to support — never a false "nothing
   // changed" that quietly corrupts positions.
-  if (cutResult.changed) {
-    // Keep a `.bak` of whatever was on disk first — the same safety net
-    // `saveConfigPatch` keeps for a config file it's about to replace —
-    // before overwriting the user's own data. Atomic write via tmp+rename,
-    // matching the edit server's own `PUT /overrides` handler: the producer
-    // or a live editor session may read this file at any moment, and a
-    // half-written document would be worse than a stale one.
-    try {
-      const raw = await readFile(overridesPath, "utf8");
-      await writeFile(`${overridesPath}.bak`, raw);
-    } catch {
-      // Nothing on disk to back up (first cut ever applied here) — fine.
-    }
-    const tmp = `${overridesPath}.tmp`;
-    await writeFile(tmp, JSON.stringify(overrideDoc, null, 2));
-    await rename(tmp, overridesPath);
-    console.log("▸ overrides.json re-anchored to the new cut and saved (previous copy kept as .bak)");
+  // `cutResult.changed` OR a §137 caption-key migration that actually MOVED an
+  // edit — the second is why this is no longer a bare cut check. Both are
+  // re-anchorings of the user's doc to something the pipeline just recomputed,
+  // and both go through the one sanctioned write; a separate write for the
+  // migration would be a SECOND sanctioned write, which the comment above
+  // exists to prevent.
+  //
+  // "ACTUALLY MOVED" is load-bearing and was not there at first (final review,
+  // Critical 2). Gated on "the migration reported something" instead, this
+  // fires on a run that repaired NOTHING — and since a caption migration is
+  // independent of the cut, it fires on runs where the pre-§137 gate wrote
+  // nothing at all.
+  //
+  // THEY DO NOT SHARE THE `.bak`, THOUGH, and that is the rest of the same
+  // finding (final review round 2). `refreshBackup: cutResult.changed`, never
+  // the gate: on the field workdir the caption migration re-anchors THREE
+  // edits, so the gate legitimately fires while `cutResult.changed` is false —
+  // and an unconditional refresh would then copy the already-damaged
+  // `overrides.json` over `overrides.json.bak`, which is that user's only
+  // pre-cut save and the only artefact their deleted split half can still be
+  // recovered from (`legacySplitId`). Repairing the captions would destroy the
+  // evidence for the split. `writeOverrideDoc` carries the full argument for
+  // why a caption-only write has nothing worth backing up.
+  if (cutResult.changed || captionKeysReanchored) {
+    await writeOverrideDoc(overridesPath, overrideDoc, { refreshBackup: cutResult.changed });
+    console.log(overridesWriteLine(cutResult.changed));
   }
   if (!opts.render) {

package/editor-dist/assets/index-C8IPo60X.css DELETED Viewed

	@@ -1 +0,0 @@
1	- .ossclip-scroll-list{scrollbar-width:thin;scrollbar-color:#3a3a44 transparent}.ossclip-scroll-list::-webkit-scrollbar{width:8px}.ossclip-scroll-list::-webkit-scrollbar-track{background:transparent}.ossclip-scroll-list::-webkit-scrollbar-thumb{background:#3a3a44;border-radius:4px}