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

ossclip 0.1.29 → 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 (7) hide show

package/editor-dist/assets/index-C537KpNT.js +166 -0
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/cover.ts +11 -2
package/src/edit.ts +99 -0
package/src/produce.ts +156 -28
package/editor-dist/assets/index-BBJKC2Z2.js +0 -164

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-BBJKC2Z2.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.29",
+  "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.29",
-    "@ossclip/scenes": "0.1.29",
-    "@ossclip/renderer": "0.1.29"
+    "@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/cover.ts CHANGED Viewed

@@ -527,12 +527,21 @@ export function coverBannerText(args: {
  * theme, which is exactly how a regenerated cover picks up a theme change for
  * free (§corr.2). `production.json` carries neither the RESOLVED theme nor
  * the editor's edits, which is why this is the file that gets read. */
-const CoverRenderPropsSchema = z.object({
+export const CoverRenderPropsSchema = z.object({
   theme: ThemeSchema.optional(),
   settings: z.object({ width: z.number(), height: z.number() }).optional(),
   /** The take's whole-frame subject, for a re-pick's scoring — "screen"
    * zeroes the face weight (scoreCandidate's 2026-08-16 incident). */
-  face: z.object({ subject: z.enum(["face", "screen"]).optional() }).optional(),
+  // `.nullable()`, not just `.optional()` (§154): produce writes `face: null`
+  // when the detector found nobody, and null is a MEASUREMENT — core's own
+  // schema says so ("null = no face found"). `.optional()` accepts a missing
+  // key and rejects an explicit null, so every screen recording and
+  // slides-with-voiceover project could not regenerate its cover at all.
+  // Downstream reads `renderProps.face?.subject`, which is already null-safe.
+  face: z
+    .object({ subject: z.enum(["face", "screen"]).optional() })
+    .nullable()
+    .optional(),
 });
 export interface CoverRegenerateOptions {

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,
@@ -347,6 +350,61 @@ export function beatSheetCacheKey(parts: {
     .slice(0, 8);
 }
+/**
+ * The beat-sheet cache keys to TRY, in priority order (§150).
+ *
+ * §143 split the cache: reads use the provider you asked for, writes file
+ * under the one that actually answered. That is right for attribution and
+ * wrong for re-runs — while agy keeps timing out, a run that asks for
+ * antigravity reads a key nothing will ever write. It re-attempts, waits out
+ * the whole print-timeout, falls back, and rewrites the key nobody reads.
+ * Every re-render therefore re-plans, the plan differs each time, and editor
+ * edits anchored to scenes the new plan no longer has are dropped — a
+ * re-render silently rewriting an approved cut (2026-08-23: "edit for
+ * scene-11 dropped — the plan no longer has that scene").
+ *
+ * So the read tries a second key, and exactly one: the provider THIS run
+ * would fall back to anyway. Serving that sheet is not a substitution — it is
+ * what this run would produce, without paying the timeout to rediscover it.
+ * Anything looser (any provider's sheet, newest file wins) would hand a
+ * claude-cli plan to someone who asked for gemini and got gemini.
+ */
+/**
+ * The producer stamp already on disk, or undefined (§152).
+ *
+ * Read so a run that answered NOTHING can keep it. `production.json` is
+ * rewritten on every produce, cached or not, and the stamp is rebuilt from
+ * this run's usage records — which on a cached run are empty, so it fell
+ * through to the provider we ASKED for and quietly overwrote a truthful
+ * "antigravity → claude-cli" with "antigravity". Attribution belongs to the
+ * run that produced the plan, and a cached run produced nothing.
+ *
+ * Tolerant on purpose: a missing, unreadable or stamp-less file all mean "no
+ * prior attribution", which is the same answer a first run gives.
+ */
+export function existingProducerStamp(work: string): Production["producer"] | undefined {
+  try {
+    const raw = JSON.parse(readFileSync(join(work, "production.json"), "utf8")) as {
+      producer?: Production["producer"];
+    };
+    return raw.producer;
+  } catch {
+    return undefined;
+  }
+}
+export function beatCacheKeyCandidates(
+  parts: Omit<Parameters<typeof beatSheetCacheKey>[0], "providerName">,
+  providerName: string,
+  fallbackName: string | undefined,
+): string[] {
+  const keys = [beatSheetCacheKey({ ...parts, providerName })];
+  if (fallbackName && fallbackName !== providerName) {
+    keys.push(beatSheetCacheKey({ ...parts, providerName: fallbackName }));
+  }
+  return keys;
+}
 /**
  * The clip-window cache key (`clipwindow-<hash>.json`), which answers a
  * different question — WHICH ~Ns of the take to keep (R19 §93) — but asks it
@@ -1839,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 });
@@ -2347,6 +2419,19 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
   // the grounding check — uses the repaired transcript instead, so a
   // mishearing can't reach the screen twice in two different spellings.
   const providerName = opts.provider ?? defaultProviderName(process.env, binOnPath);
+  // Timeout fallback (2026-08-22, FINDINGS §143): agy hangs persistently on
+  // the real beat-sheet call, and auto-detection picks it whenever the CLI is
+  // on PATH. When the editorial call times out, ONE other provider answers
+  // instead of the run dying, announced out loud: the user must know which
+  // model planned their video.
+  //
+  // Function-scope because the beat CACHE needs it too (§150) — the key a
+  // fallback wrote is the second key a re-run has to try, and computing it
+  // twice would let the two drift into disagreeing about where the plan is.
+  const llmFallbackName =
+    providerName === "antigravity"
+      ? fallbackProviderName(providerName, process.env, binOnPath)
+      : undefined;
   let provider: LlmProvider | null = null;
   // --youtube brings its own provider (field gap, 2026-08-16): the user's
   // real command was `--youtube --llm antigravity` WITHOUT --produce, and the
@@ -2363,16 +2448,6 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     if (!opts.provider) {
       console.log(detectionLine(providerName));
     }
-    // Timeout fallback (2026-08-22, FINDINGS §143): agy hangs persistently on
-    // the real beat-sheet call — 10-minute --print-timeout expiries while
-    // claude-cli planned the same video — and auto-detection picks agy
-    // whenever the CLI is on PATH. When the editorial call times out, ONE
-    // other provider answers it instead of the run dying, announced out loud:
-    // the user must know which model planned their video.
-    const llmFallbackName =
-      providerName === "antigravity"
-        ? fallbackProviderName(providerName, process.env, binOnPath)
-        : undefined;
     provider = createTieredProvider(providerName, {
       model: opts.llmModel,
       fastModel: opts.llmFastModel ?? cfg.fastModel,
@@ -2730,11 +2805,22 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       words: transcript.words.map((w) => w.text),
       aspect: landscape ? ("16:9" as const) : ("9:16" as const),
     };
-    const cacheKey = beatSheetCacheKey({ ...beatKeyParts, providerName });
-    const sceneCache = join(work, `scenes-${cacheKey}.json`);
+    // Two keys, tried in order: the provider asked for, then the one this run
+    // would fall back to anyway (§150). Without the second, a workdir whose
+    // plan was written by a fallback can never be read again while the primary
+    // keeps failing — every re-render re-plans, and edits anchored to scenes
+    // the new plan drops go with it.
+    const cacheKeys = beatCacheKeyCandidates(beatKeyParts, providerName, llmFallbackName);
+    const cacheKey = cacheKeys[0]!;
+    const hitKey =
+      cacheKeys.find((k) => existsSync(join(work, `scenes-${k}.json`))) ?? cacheKey;
+    const sceneCache = join(work, `scenes-${hitKey}.json`);
     // The cover needs the editorial copy, which is not in the scene list — a
     // cached run must still be able to write one.
-    const beatCache = join(work, `beatsheet-${cacheKey}.json`);
+    // Same key the scenes came from — the hook and cover copy belong to THAT
+    // plan, and pairing a cached scene list with a different sheet's hook
+    // would caption the video with copy for a plan it is not showing.
+    const beatCache = join(work, `beatsheet-${hitKey}.json`);
     if (clipFresh) {
       // The selection call already planned the scenes (§93d: ONE editorial
       // call chooses the window and the beats inside it) — adopt them and
@@ -2772,7 +2858,15 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
       );
     } else if (existsSync(sceneCache)) {
       scenes = z.array(SceneSchema).parse(JSON.parse(await readFile(sceneCache, "utf8")));
-      console.log(`▸ scenes cached (${scenes.length})`);
+      // Naming the fallback is the same obligation the live fallback line has
+      // (§143: the user must know which model planned their video). A silent
+      // hit here would let a claude-cli plan read as an antigravity one purely
+      // because it came from disk this time.
+      console.log(
+        hitKey === cacheKey
+          ? `▸ scenes cached (${scenes.length})`
+          : `▸ scenes cached (${scenes.length}) — planned by ${llmFallbackName}, which ${providerName} fell back to`,
+      );
       if (existsSync(beatCache)) {
         // Pre-§118b caches carry no accounting — the report then simply
         // omits the graphics section rather than guessing one.
@@ -2903,18 +2997,29 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
     // single-provider runs stamp exactly as before.
     const answered = provider.usage.filter((r) => !r.failed);
     const providersSeen = [...new Set(answered.map((r) => r.provider))];
-    producerStamp = {
-      provider:
-        providersSeen.length > 1
-          ? providersSeen.join(" → ")
-          : providersSeen[0] ?? last.provider ?? providerName,
-      // `last.models` already excludes failed attempts' models (usage.ts,
-      // same §143 rule) — a stamp that listed the timed-out placeholder read
-      // "planned by claude-cli (antigravity-default)" after a fallback run.
-      models: last.models,
-      cached: last.cached,
-      at: last.at,
-    };
+    // A run that answered NOTHING must not restamp the artefact (§152). On a
+    // fully cached run `answered` is empty, `last.provider` is the run we just
+    // appended — whose provider is the one we ASKED for — and the stamp
+    // silently rewrote a truthful "antigravity → claude-cli" into
+    // "antigravity", crediting the plan to a provider that never produced it.
+    // The plan did not change this run, so neither does its attribution.
+    const priorStamp = existingProducerStamp(work);
+    if (answered.length === 0 && priorStamp) {
+      producerStamp = priorStamp;
+    } else {
+      producerStamp = {
+        provider:
+          providersSeen.length > 1
+            ? providersSeen.join(" → ")
+            : providersSeen[0] ?? last.provider ?? providerName,
+        // `last.models` already excludes failed attempts' models (usage.ts,
+        // same §143 rule) — a stamp that listed the timed-out placeholder read
+        // "planned by claude-cli (antigravity-default)" after a fallback run.
+        models: last.models,
+        cached: last.cached,
+        at: last.at,
+      };
+    }
   }
   // The overlay and the caption under it must spell the same word (§21).
@@ -3092,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
@@ -3350,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");
@@ -4207,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));
   }