npm - ossclip - Versions diffs - 0.1.30 → 0.1.31 - Mend

ossclip 0.1.30 → 0.1.31

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

package/editor-dist/assets/{index-DfTreNoE.js → index-C537KpNT.js} +38 -38
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/edit.ts +99 -0
package/src/produce.ts +42 -2

package/editor-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <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-DfTreNoE.js"></script>
+    <script type="module" crossorigin src="/assets/index-C537KpNT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-Bx2VQLP8.css">
   </head>
   <body>

package/package.json CHANGED Viewed

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

package/src/edit.ts CHANGED Viewed

@@ -369,6 +369,11 @@ export async function startEditServer(
    * file behind this URL). */
   const coverImageUrl = (image: string | null): string | null =>
     image === null ? null : `/api/cover/image?ts=${Math.round(statSync(image).mtimeMs)}`;
+  /** Where the Preview button's one-off render lands (handoff-cover-panel
+   * §3): a fixed name IN the workdir — never a client-named path, and never
+   * the canonical `.cover.jpg` a real Apply owns. Each preview overwrites the
+   * last; the file is scratch, like the frame-sampler's cache. */
+  const coverPreviewPath = (): string => join(workdir!, "cover-preview.jpg");
   // ---- Portrait override (editor face swap, 2026-08-17) -------------------
   // A per-project `portrait-override.<ext>` in the workdir that outranks the
@@ -1193,6 +1198,27 @@ export async function startEditServer(
           // throw for want of a destination, and the panel says so up front
           // rather than after a click.
           const outPath = provenance?.out ?? (await recordedArtifactPath(".cover.jpg"));
+          // The finished mp4's OWN span set — the RESOLVED cutlist, never the
+          // proposal /api/cleanup serves: the panel converts the playhead
+          // between the output clock and the source clock
+          // (handoff-cover-panel §1), and a proposal the user's vetoes already
+          // changed is the wrong ruler. Lenient per-span parse, [] on a
+          // missing or corrupt production.json — a cover panel that cannot
+          // convert must still open.
+          let coverCutlist: Segment[] = [];
+          try {
+            const production = JSON.parse(
+              await readFile(join(workdir, "production.json"), "utf8"),
+            ) as { cutlist?: unknown };
+            if (Array.isArray(production.cutlist)) {
+              coverCutlist = production.cutlist.flatMap((s) => {
+                const p = SegmentSchema.safeParse(s);
+                return p.success ? [p.data] : [];
+              });
+            }
+          } catch {
+            // degrade — same as /api/cleanup
+          }
           return send(200, {
             status: outPath === null ? "unavailable" : "ready",
             ...(outPath === null
@@ -1203,6 +1229,7 @@ export async function startEditServer(
             provenance,
             outPath,
             imageUrl: coverImageUrl(image),
+            cutlist: coverCutlist,
           });
         }
@@ -1283,6 +1310,78 @@ export async function startEditServer(
           }
         }
+        if (url.pathname === "/api/cover/preview-image" && req.method === "GET") {
+          if (!workdir) return send(409, { error: "no workdir open" });
+          const image = coverPreviewPath();
+          if (!existsSync(image)) return send(404, { error: "no preview image" });
+          // /api/cover/image's exact posture, for its exact reason: every
+          // preview REPLACES the file behind a URL the panel busts with ?ts,
+          // and a cached 200 would show the old preview against the new ts.
+          const bytes = await readFile(image);
+          res.writeHead(200, {
+            "content-type": "image/jpeg",
+            "cache-control": "no-store",
+            "content-length": String(bytes.length),
+          });
+          res.end(bytes);
+          return;
+        }
+        if (url.pathname === "/api/cover/preview" && req.method === "POST") {
+          // The regenerate handler above, verbatim, up to the outPath: a
+          // preview is a full cover render — it boots the same headless
+          // browser (hence the same coverBusy gate), takes the same three
+          // steerable values and nothing else, and fails with the same
+          // 200-with-ok:false verbatim-message posture.
+          if (!workdir) return send(409, { error: "no workdir open" });
+          if (coverBusy) return send(409, { error: "a cover regeneration is already running" });
+          const chunks: Buffer[] = [];
+          for await (const c of req) chunks.push(c as Buffer);
+          const parsed = z
+            .object({
+              text: z.string().optional(),
+              atSec: CoverAtSecondsSchema.optional(),
+              from: CoverFromSchema.optional(),
+            })
+            .safeParse(JSON.parse(Buffer.concat(chunks).toString() || "{}"));
+          if (!parsed.success) return send(400, { error: parsed.error.message });
+          coverBusy = true;
+          try {
+            const notes: string[] = [];
+            await regenerateCover(
+              workdir,
+              {
+                text: parsed.data.text,
+                atSec: parsed.data.atSec,
+                from: parsed.data.from,
+                // The ONE-OFF path, derived HERE and never from the body (the
+                // regenerate handler's comment owns why). Same machinery as
+                // `ossclip cover --out` (handoff-cover-panel §3): the
+                // canonical cover is untouched, provenance updates to
+                // describe the previewed frame — which is what makes a
+                // follow-up blank-field Apply adopt it via the cheap path,
+                // and the one-off note riding back is the panel's disclosure
+                // of exactly that.
+                outPath: coverPreviewPath(),
+              },
+              { renderCover: opts.renderCover, log: (line) => notes.push(line) },
+            );
+            return send(200, {
+              ok: true,
+              notes,
+              // coverImageUrl's mtime rule, aimed at the preview file: the
+              // URL changes exactly when the file does.
+              previewImageUrl: `/api/cover/preview-image?ts=${Math.round(
+                statSync(coverPreviewPath()).mtimeMs,
+              )}`,
+            });
+          } catch (err) {
+            return send(200, { ok: false, error: err instanceof Error ? err.message : String(err) });
+          } finally {
+            coverBusy = false;
+          }
+        }
         if (url.pathname.startsWith("/media/")) {
           if (!workdir) return send(409, { error: "no workdir open" });
           const file = join(workdir, decodeURIComponent(url.pathname.slice("/media/".length)));

package/src/produce.ts CHANGED Viewed

@@ -23,6 +23,9 @@ import {
   analyze,
   applyOverrides,
   applyRepairs,
+  isParkedOverrideKey,
+  parkedOverrideBaseKey,
+  remapSceneOverrides,
   assembleScenes,
   buildCaptionLines,
   buildCutlist,
@@ -1894,6 +1897,20 @@ export function layoutSlotAspects(frame: {
   });
 }
+/**
+ * One orphaned scene edit, one honest sentence. A parked key (`…#orphaned`,
+ * handoff-edit-anchoring) matches no cue BY DESIGN, so it surfaces in
+ * `applyOverrides`' orphan list on every run — and "dropped" would tell the
+ * user an edit is gone while the doc still holds it, anchor intact, waiting
+ * for a plan that has its words again. Pure so both sentences are testable
+ * without a produce run.
+ */
+export function orphanEditLine(id: string): string {
+  return isParkedOverrideKey(id)
+    ? `  ⚠ edit for ${parkedOverrideBaseKey(id)} is parked — its words are not in this plan`
+    : `  ⚠ edit for ${id} dropped — the plan no longer has that scene`;
+}
 async function preflight(bin: string, hint: string): Promise<void> {
   try {
     await run(bin, ["-version"], { allowNonZero: true });
@@ -3180,6 +3197,24 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   const { cues: assembled, dropped } = assembleScenes(scenes, transcript, map);
   for (const d of dropped) console.log(`  ⚠ scene ${d.id} dropped: ${d.reason}`);
+  // Re-key scene edits whose positional id no longer means the moment they
+  // were made on (handoff-edit-anchoring; §137 is the caption precedent — in
+  // the field, scene-4 was a TerminalMock in one plan and a FlowDiagram in
+  // the next, and the user's edit landed on the impostor). Placed HERE,
+  // before ANY consumer of `overrideDoc.scenes`: the first `applyOverrides`
+  // pass, `splitThenDropHidden` and the pinned-timing reclamp all join by id,
+  // and a stale key at any of them bakes the misapply this plan exists to
+  // kill — a `hidden` on a renumbered scene would hide the impostor, not the
+  // moved moment. `assembled` is enough for the match: the remap reads only
+  // anchored graphic cues, and take ids (which don't exist until the fill)
+  // carry no anchors and are left untouched by design. Notes are non-empty
+  // exactly when the doc changed, which is what earns the write-back its
+  // turn at the sanctioned write below.
+  const sceneRemap = remapSceneOverrides(overrideDoc, assembled);
+  overrideDoc = sceneRemap.doc;
+  for (const n of sceneRemap.notes) console.log(`  ▸ ${n}`);
+  const sceneKeysRemapped = sceneRemap.notes.length > 0;
   // ---- Framing plan → props (2026-08-16 incident) --------------------------
   // The plan used to be BAKED here: every window cropped, scaled and
   // re-encoded into a content-<hash>.mp4 that replaced the source for the
@@ -3438,7 +3473,7 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     console.log(`▸ applied your edits to ${editedCount - orphans.length - hiddenIds.length} scene(s)`);
   }
   for (const id of orphans) {
-    console.log(`  ⚠ edit for ${id} dropped — the plan no longer has that scene`);
+    console.log(orphanEditLine(id));
   }
   const graphicCues = sceneCues.filter((c) => c.kind !== "plain");
@@ -4295,7 +4330,12 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // re-report "the cut removed it" on every later run. It does NOT spend the
   // `.bak` — retiring a redundant key is not the cut re-anchoring the backup
   // exists to survive.
-  if (cutResult.changed || captionKeysReanchored || hidesPruned) {
+  // `sceneKeysRemapped` joins for the caption-migration reason: a scene edit
+  // that followed its anchor to a new id (handoff-edit-anchoring) is keyed
+  // right in memory but wrong on disk, and every re-keyed entry was just
+  // printed by name. It does NOT spend the `.bak` — the remap moves keys, it
+  // rewrites no values a user would need to recover.
+  if (cutResult.changed || captionKeysReanchored || hidesPruned || sceneKeysRemapped) {
     await writeOverrideDoc(overridesPath, overrideDoc, { refreshBackup: cutResult.changed });
     console.log(overridesWriteLine(cutResult.changed));
   }