npm - ossclip - Versions diffs - 0.1.25 → 0.1.26 - Mend

ossclip 0.1.25 → 0.1.26

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 (11) hide show

package/editor-dist/assets/index-Bx2VQLP8.css +1 -0
package/editor-dist/assets/index-DVI51_2u.js +163 -0
package/editor-dist/index.html +2 -2
package/package.json +4 -4
package/src/caption-report.ts +141 -3
package/src/edit.ts +84 -8
package/src/open.ts +38 -0
package/src/produce.ts +382 -46
package/src/program.ts +38 -0
package/editor-dist/assets/index-C9n6EfII.js +0 -163
package/editor-dist/assets/index-ChRVBVLj.css +0 -1

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-C9n6EfII.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-ChRVBVLj.css">
+    <script type="module" crossorigin src="/assets/index-DVI51_2u.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bx2VQLP8.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "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.25",
-    "@ossclip/renderer": "0.1.25",
-    "@ossclip/scenes": "0.1.25"
+    "@ossclip/renderer": "0.1.26",
+    "@ossclip/core": "0.1.26",
+    "@ossclip/scenes": "0.1.26"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/caption-report.ts CHANGED Viewed

@@ -1,5 +1,8 @@
 import {
   applyCaptionEdits,
+  applyCaptionRangeEdits,
+  applyCaptionWordHides,
+  applyCaptionLineTiming,
   captionEditsToKeep,
   isLegacyCaptionKey,
   migrateCaptionKeys,
@@ -65,6 +68,95 @@ export function captionDropLine(drop: AppliedCaptionEdits["dropped"][number]): s
   );
 }
+/**
+ * One console line for a HIDE that did not land (§59b, revisited 2026-08-18).
+ * Same three cases as `captionDropLine` — `applyCaptionWordHides` reports in
+ * the identical shape — but its own function rather than a flag on that one:
+ * "hidden word" has to lead every sentence (the user's gesture was a delete,
+ * not a retype, and the fix is to re-select and hide, not to retype), and no
+ * legacy-key branch exists here because `captionWordsHidden` never had a
+ * positional-key era (`OverrideDocSchema`'s own note).
+ */
+export function captionHideDropLine(drop: AppliedCaptionEdits["dropped"][number]): string {
+  if (drop.reason === "duplicate-anchor") {
+    // A note about reach, not a failure — the hide applied, to the FIRST word
+    // carrying this anchor (two words share one source instant by design,
+    // captions.ts:44-50).
+    return (
+      `  ⚠ hidden word "${drop.expected}" (${drop.key}): a second word shares that ` +
+      `source moment and was left visible — only the first was hidden`
+    );
+  }
+  if (drop.found === null) {
+    return (
+      `  ⚠ hidden word "${drop.expected}" (${drop.key}) dropped: no word starts at that ` +
+      `source moment any more — the cut removed the word it hid, so there is ` +
+      `nothing left to hide`
+    );
+  }
+  return (
+    `  ⚠ hidden word "${drop.expected}" (${drop.key}) dropped: the transcript now says ` +
+    `"${drop.found}" there — it was left visible rather than hiding a different word`
+  );
+}
+/**
+ * One console line for a RANGE rewrite that did not land (2026-08-18). Its
+ * own function for the captionHideDropLine reason: the gesture was a
+ * free-text rewrite and the fix is to re-select and Edit; `expected` is the
+ * WHOLE run's joined `was` (the layer's whole-run guard drops the entire
+ * entry rather than guessing at part of it), and `key` is the composite
+ * `${fromKey}..${toKey}` pair. No legacy-key branch: `captionRangeEdits`
+ * postdates §137, so a positional-key era never existed for it.
+ */
+export function captionRangeDropLine(drop: AppliedCaptionEdits["dropped"][number]): string {
+  if (drop.reason === "duplicate-anchor") {
+    return (
+      `  ⚠ range edit "${drop.expected}" (${drop.key}): an earlier range edit already ` +
+      `rewrote the word it starts on — only the first applied`
+    );
+  }
+  if (drop.found === null) {
+    return (
+      `  ⚠ range edit "${drop.expected}" (${drop.key}) dropped: its words no longer sit at ` +
+      `those source moments — a cut or re-plan removed the run it rewrote. Re-select and ` +
+      `Edit in the editor if you still want it.`
+    );
+  }
+  return (
+    `  ⚠ range edit "${drop.expected}" (${drop.key}) dropped: the transcript now says ` +
+    `"${drop.found}" there — the whole rewrite was left unapplied rather than guessing at part of it`
+  );
+}
+/**
+ * One console line for a LINE TIMING nudge that did not land (2026-08-18).
+ * Its own function for the captionHideDropLine reason: the gesture was a
+ * re-time of when a caption appears and the fix is to re-make the nudge, not
+ * retype. Only TWO cases — `applyCaptionLineTiming` carries no `was` guard
+ * (timing is text-orthogonal, its own doc comment), so the "transcript says
+ * something else" sentence has no counterpart here, and `expected` is always
+ * `""`, which is why these lines name the moment by key rather than quoting a
+ * word. The key is the LINE's first word's source anchor, so the sentences
+ * say "caption timing", not "word". No legacy-key branch:
+ * `captionLineTiming` postdates §137.
+ */
+export function captionTimingDropLine(drop: AppliedCaptionEdits["dropped"][number]): string {
+  if (drop.reason === "duplicate-anchor") {
+    // A note about reach, not a failure — the nudge applied, to the FIRST
+    // line starting on this anchor (two words share one source instant by
+    // design, captions.ts:44-50).
+    return (
+      `  ⚠ caption timing (${drop.key}): a second caption starts on that source moment and ` +
+      `kept its window — only the first was re-timed`
+    );
+  }
+  return (
+    `  ⚠ caption timing (${drop.key}) dropped: no caption starts at that source moment any ` +
+    `more — the cut removed the caption whose timing was nudged`
+  );
+}
 /**
  * How many stored edits actually landed.
  *
@@ -79,9 +171,14 @@ export function captionDropLine(drop: AppliedCaptionEdits["dropped"][number]): s
  * 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`.
+ *
+ * `applyCaptionWordHides` and `applyCaptionLineTiming` are built to the same
+ * contract (first claimant applies, extras get `duplicate-anchor`, unmatched
+ * keys get a reason-less drop), so this counts for those layers too — hence
+ * the record's value type is unconstrained: only the KEYS are read.
  */
 export function appliedCaptionEditCount(
-  edits: Record<string, CaptionEdit>,
+  edits: Readonly<Record<string, unknown>>,
   dropped: AppliedCaptionEdits["dropped"],
 ): number {
   const failed = new Set(dropped.filter((d) => d.reason === undefined).map((d) => d.key));
@@ -143,7 +240,9 @@ export function reanchoredKeyCount(
 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. */
+  /** The caption lines with every edit, range rewrite, hide AND line-timing
+   * nudge that could apply, applied — post-timing, exactly what the render
+   * should show. */
   lines: CaptionLine[];
   /**
    * Whether the migration actually MOVED an edit onto a source anchor — the
@@ -213,5 +312,44 @@ export function reconcileCaptionEdits(
   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 };
+  // Range rewrites BETWEEN retypes and hides — `applyCaptionLayers`' one
+  // authoritative order, still composed manually here because this path's
+  // edits layer is the MIGRATED set (see the hides comment below). No key
+  // migration for ranges either: `captionRangeEdits` postdates §137, and the
+  // write-back above spreads it through untouched. The applied count is a
+  // plain subtraction — unlike the per-word layers, `applyCaptionRangeEdits`
+  // reports each entry at most once (its own doc comment), so the
+  // `appliedCaptionEditCount` machinery is not needed.
+  const ranges = applyCaptionRangeEdits(lines, doc.captionRangeEdits);
+  const rewritten = doc.captionRangeEdits.length - ranges.dropped.length;
+  if (rewritten > 0) log.push(`▸ ${rewritten} caption range(s) rewritten by the editor`);
+  for (const d of ranges.dropped) log.push(captionRangeDropLine(d));
+  // Hides AFTER retypes and range rewrites — `applyCaptionLayers`' one
+  // authoritative order (a hide's `was` is the LIVE post-retype text),
+  // composed manually here rather than through the composer because this
+  // path's edits layer is the MIGRATED set, not `doc.captions` — the
+  // composer takes a doc whole and would re-apply the unresolved legacy keys
+  // the migration just set aside. No key migration for hides:
+  // `captionWordsHidden` never had a positional-key era (`OverrideDocSchema`'s
+  // own note), and the write-back above spreads it through untouched.
+  const hides = applyCaptionWordHides(ranges.lines, doc.captionWordsHidden);
+  for (const d of hides.dropped) log.push(captionHideDropLine(d));
+  // LINE timing LAST — `applyCaptionLayers`' one authoritative order: nudges
+  // move the seams between SURVIVING lines, so they run on the post-hide
+  // lines. No key migration here either: `captionLineTiming` postdates §137,
+  // and the write-back above spreads it through untouched.
+  //
+  // Counted with `appliedCaptionEditCount`, NOT by subtracting drops (§137's
+  // lesson, re-learned in the 2026-08-19 review): `applyCaptionLineTiming`
+  // pushes a `duplicate-anchor` drop per EXTRA line claiming the anchor
+  // (overrides.ts), so one key with two claimants subtracted to `1 - 1 = 0`
+  // and with three to `-1` — and the `> 0` gate below then erased the line
+  // ENTIRELY for a nudge that had in fact applied to its first claimant. The
+  // range layer's plain subtraction stays, because that layer reports each
+  // entry at most once; this one does not.
+  const timed = applyCaptionLineTiming(hides.lines, doc.captionLineTiming);
+  const nudged = appliedCaptionEditCount(doc.captionLineTiming, timed.dropped);
+  if (nudged > 0) log.push(`▸ ${nudged} caption timing nudge(s) applied`);
+  for (const d of timed.dropped) log.push(captionTimingDropLine(d));
+  return { doc: migrated, lines: timed.lines, reanchored: reanchored > 0, log };
 }

package/src/edit.ts CHANGED Viewed

@@ -25,6 +25,8 @@ import {
   // only when a regenerate actually runs.
   generateThumbnailImage,
   loadConfig,
+  outInsideInputFolderMessage,
+  outPathInsideInput,
   PORTRAIT_MIME_TYPES,
   portraitMimeType,
   thumbnailImageCacheName,
@@ -32,6 +34,11 @@ import {
   type ThumbnailConcept,
   type ThumbnailConceptApproved,
 } from "@ossclip/core";
+// Static, unlike the picker's `await import` above its call site: the picker
+// drags in @ossclip/core's process runner and llm-detect, worth deferring off
+// server startup — open.ts is node:child_process + node:path and pure command
+// building, with nothing to defer.
+import { revealInFileManager } from "./open";
 import { artifactPath, expandHome } from "./paths";
 import {
   PORTRAIT_OVERRIDE_BASENAME,
@@ -140,6 +147,12 @@ const MIME: Record<string, string> = {
   ".css": "text/css",
   ".json": "application/json",
   ".mp4": "video/mp4",
+  // The caption timing editor's waveform fetches `/media/audio.wav` (produce
+  // writes it into every workdir). `fetch` + `decodeAudioData` would accept
+  // the octet-stream fallback, but a future `<audio>` element would not, so
+  // the type is stated while the change is one line rather than a debugging
+  // session.
+  ".wav": "audio/wav",
 };
 /**
@@ -237,6 +250,10 @@ export async function startEditServer(
      * run never reads the runner's real ~/.ossclip/config.json (the
      * `recentDir` rule applied to reads). */
     loadCfg?: () => { youtube?: unknown; portrait?: unknown; thumbnailModel?: unknown };
+    /** File-manager reveal seam (the `generateThumbnail` pattern) — tests
+     * observe the revealed path instead of popping a real Finder/Explorer
+     * window on the runner. */
+    reveal?: (path: string) => void;
   } = {},
 ): Promise<EditServer> {
   // MUTABLE since R17 §83: the server can start with no project (the page
@@ -286,17 +303,25 @@ export async function startEditServer(
       return null;
     }
   };
-  /** `<out><ext>` from the recorded out (the top-level `out` when recorded,
-   * else the argv's -o/--out resolved against the recorded cwd — the
-   * replay's own resolution), or null when no out was ever recorded. Shared
-   * by the thumbnail dest and the youtube markdown — one spelling of the
-   * out-resolution rule, not two. */
+  /** The recorded out as an absolute path (the top-level `out` when
+   * recorded, else the argv's -o/--out resolved against the recorded cwd —
+   * the replay's own resolution), or null when no out was ever recorded.
+   * ONE spelling of the out-resolution rule: the artifact paths below and
+   * the reveal endpoint both derive from it, so they can never disagree
+   * about which file a replay writes. */
+  const recordedOutPath = (cmd: z.infer<typeof CommandSchema>): string | null => {
+    const out = cmd.out ?? lastFlagValue(cmd.args, ["-o", "--out"]);
+    if (out === undefined) return null;
+    return resolve(cmd.cwd, expandHome(out));
+  };
+  /** `<out><ext>` from the recorded out, or null when no out was ever
+   * recorded. Shared by the thumbnail dest and the youtube markdown. */
   const recordedArtifactPath = async (ext: string): Promise<string | null> => {
     const cmd = await readCommandRecord();
     if (!cmd) return null;
-    const out = cmd.out ?? lastFlagValue(cmd.args, ["-o", "--out"]);
-    if (out === undefined) return null;
-    return artifactPath(resolve(cmd.cwd, expandHome(out)), ext);
+    const out = recordedOutPath(cmd);
+    if (out === null) return null;
+    return artifactPath(out, ext);
   };
   const thumbnailDestPath = (): Promise<string | null> => recordedArtifactPath(".thumbnail.png");
   /** Newest workdir file passing `test`, by mtime — the cache fallbacks. */
@@ -638,6 +663,28 @@ export async function startEditServer(
           // directly-typed `ossclip produce …` — already starts with it and
           // is untouched.
           let args = cmd.args[0] === "produce" ? [...cmd.args] : ["produce", ...cmd.args];
+          // 2026-08-18 field cascade: mirror produce's own inside-the-input
+          // refusal at this boundary, so the failure is a 400 the page can
+          // show instead of a spawned child dying in the log tail. The input
+          // is derived from the RECORDED command only — the security stance
+          // above: beyond the out path it already controls, nothing the
+          // client sent may steer what this endpoint checks or touches.
+          // args[1] after the §129 heal is the recorded input positional;
+          // when a record put flags before the input, or the input no longer
+          // stats, the gate stays open and produce's own refusal still
+          // protects the replay.
+          if (customOut !== undefined && args[1] !== undefined) {
+            const inputAbs = resolve(cmd.cwd, expandHome(args[1]));
+            let inputIsFolder = false;
+            try {
+              inputIsFolder = statSync(inputAbs).isDirectory();
+            } catch {
+              // input gone/unreadable — the replay will fail on its own terms
+            }
+            if (inputIsFolder && outPathInsideInput(resolve(cmd.cwd, expandHome(customOut)), inputAbs)) {
+              return send(400, { error: outInsideInputFolderMessage(inputAbs) });
+            }
+          }
           if (customOut) {
             const filteredArgs: string[] = [];
             for (let i = 0; i < args.length; i++) {
@@ -657,6 +704,12 @@ export async function startEditServer(
           const child = spawn(cmd.execPath, [...cmd.execArgv, cmd.script, ...args], {
             cwd: cmd.cwd,
             stdio: ["ignore", "pipe", "pipe"],
+            // Which workdir's command.json this replay came from (2026-08-18
+            // field cascade, part 3): a re-keyed folder input makes produce
+            // derive a DIFFERENT workdir, silently abandoning the overrides
+            // saved here — produce compares against this and prints a loud ⚠
+            // into the log tail (replayWorkdirWarning, produce.ts).
+            env: { ...process.env, OSSCLIP_REPLAY_WORKDIR: workdir! },
           });
           renderChild = child;
           child.stdout?.on("data", pushLines);
@@ -693,6 +746,29 @@ export async function startEditServer(
           });
         }
+        if (url.pathname === "/api/reveal-output" && req.method === "POST") {
+          // Show the finished render in the file manager (2026-08-18). The
+          // path comes from command.json's recorded out and NOWHERE else —
+          // the request body is deliberately never read. The security stance
+          // at the top of this file: this server binds locally, but an
+          // endpoint that reveals (and one day might do more to) a
+          // client-named path is the same door as spawning a client-supplied
+          // command.
+          if (!workdir) return send(409, { error: "no workdir open" });
+          const cmd = await readCommandRecord();
+          const out = cmd === null ? null : recordedOutPath(cmd);
+          if (out === null) {
+            return send(412, { error: "no recorded output path in this workdir" });
+          }
+          if (!existsSync(out)) {
+            // Recorded but not rendered yet (or moved since) — a 404 the
+            // page treats as "nothing to show", not a failure.
+            return send(404, { error: `no output at ${out} yet` });
+          }
+          (opts.reveal ?? revealInFileManager)(out);
+          return send(200, { ok: true, path: out });
+        }
         if (url.pathname === "/api/overrides" && req.method === "PUT") {
           if (!workdir) return send(409, { error: "no workdir open" });
           const chunks: Buffer[] = [];

package/src/open.ts CHANGED Viewed

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { dirname } from "node:path";
 /**
  * Open a target — URL or file path, every platform's opener treats them
@@ -46,3 +47,40 @@ export function openInViewer(path: string, platform: NodeJS.Platform = process.p
     console.log(`▸ could not open viewer — ${path}`);
   });
 }
+/**
+ * REVEAL a file in the platform's file manager — select it, don't launch it.
+ * openCommand on a finished render would start PLAYING the video; the ask
+ * here is "show me where it landed". Syntax verified 2026-08-18, not guessed
+ * (the picker matrix's convention):
+ * - darwin: `open -R <file>` selects it in a Finder window.
+ * - win32: `explorer /select,<file>` — the switch and the path are ONE
+ *   comma-joined, unquoted argument. explorer.exe does its own command-line
+ *   parsing; passed as two arguments (or with the path quoted) it ignores
+ *   the switch and opens the default folder instead of selecting.
+ * - else: no cross-file-manager "select" verb exists on Linux, so open the
+ *   CONTAINING directory via xdg-open — the file is at least on screen.
+ */
+export function revealCommand(
+  file: string,
+  platform: NodeJS.Platform,
+): { bin: string; args: string[] } {
+  if (platform === "darwin") return { bin: "open", args: ["-R", file] };
+  if (platform === "win32") return { bin: "explorer", args: ["/select," + file] };
+  return { bin: "xdg-open", args: [dirname(file)] };
+}
+/** Same failure posture as openInBrowser (the 0.1.4 lesson: an unhandled
+ * 'error' event on a missing opener took the whole edit server down):
+ * swallow the spawn error and print the path — reveal is a courtesy, and a
+ * headless box without a file manager is a normal place to run this. */
+export function revealInFileManager(
+  file: string,
+  platform: NodeJS.Platform = process.platform,
+): void {
+  const { bin, args } = revealCommand(file, platform);
+  const child = spawn(bin, args, { stdio: "ignore", detached: false });
+  child.on("error", () => {
+    console.log(`▸ couldn't open a file manager here — the output is at ${file}`);
+  });
+}