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

ossclip 0.1.29 → 0.1.30

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

package/editor-dist/assets/index-DfTreNoE.js +166 -0
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/cover.ts +11 -2
package/src/produce.ts +114 -26
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-DfTreNoE.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.30",
   "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.30",
+    "@ossclip/renderer": "0.1.30",
+    "@ossclip/scenes": "0.1.30"
   },
   "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/produce.ts CHANGED Viewed

@@ -347,6 +347,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
@@ -2347,6 +2402,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 +2431,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 +2788,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 +2841,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 +2980,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).