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

ossclip 0.1.28 → 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 (8) 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/interactive/produce-argv.ts +14 -0
package/src/interactive/produce-wizard.ts +28 -0
package/src/produce.ts +155 -37
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.28",
+  "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.28",
-    "@ossclip/scenes": "0.1.28",
-    "@ossclip/renderer": "0.1.28"
+    "@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/interactive/produce-argv.ts CHANGED Viewed

@@ -63,6 +63,15 @@ export interface ProduceAnswers {
   graphics: boolean;
   intent?: string;
   out?: string;
+  /**
+   * Review the cut in the editor instead of rendering now (§148). A main-flow
+   * answer like `graphics`, not an extra: it decides what the run DOES, and
+   * burying it in "Anything else?" would hide it from the people the wizard
+   * exists for. The only answer whose wizard default (review) differs from
+   * the CLI's (render) — which costs nothing here, because the elision rule
+   * below keys off the CLI default, not off what the prompt preselected.
+   */
+  review?: boolean;
   extras: ProduceExtras;
 }
@@ -76,6 +85,11 @@ export function produceArgv(a: ProduceAnswers): string[] {
   if (a.aspect !== "9:16") argv.push("--aspect", a.aspect);
   if (a.cleanup !== "standard") argv.push("--cleanup", a.cleanup);
   if (a.out) argv.push("--out", a.out);
+  // Rendering is the CLI's default, so only reviewing is worth saying — the
+  // rule above is about the DEFAULT, not about which option the prompt
+  // preselected. --out still travels either way: nothing renders now, but the
+  // editor's Render button replays command.json, and that is where out lands.
+  if (a.review === true) argv.push("--review");
   if (a.graphics) {
     argv.push("--produce");

package/src/interactive/produce-wizard.ts CHANGED Viewed

@@ -505,6 +505,33 @@ export async function produceWizard(
     ) as ProduceExtras["llm"];
   }
+  // LAST, because it decides what happens after every answer above it — and
+  // asked at all because until §148 the wizard could not reach --review, so
+  // `ossclip` with no arguments, the entry point a first-time user takes,
+  // could only render first and offer the editor afterwards. That is the
+  // opposite of what --review is for: the render is the expensive step, and
+  // reviewing exists so it happens once, on a cut you already agreed with.
+  //
+  // Leaning to review is the one place a wizard default differs from the
+  // CLI's. It costs nothing: produceArgv elides against the CLI default, so
+  // choosing to render still teaches `ossclip produce <file>` and choosing to
+  // review teaches the flag that did it.
+  const review =
+    unwrap(
+      await select({
+        message: "Render now, or review the cut first?",
+        initialValue: "review",
+        options: [
+          {
+            value: "review",
+            label: "Review the cut first",
+            hint: "opens the editor; render from its button",
+          },
+          { value: "render", label: "Render now", hint: "straight to a finished file" },
+        ],
+      }),
+    ) === "review";
   return produceArgv({
     input,
     aspect,
@@ -514,6 +541,7 @@ export async function produceWizard(
     // Already `string | undefined`: pickSavePath's use-default row IS the
     // old empty answer — no --out, produce derives its own default.
     out,
+    review,
     extras,
   });
 }

package/src/produce.ts CHANGED Viewed

@@ -152,6 +152,7 @@ import {
   type LlmEffort,
   type LlmProvider,
   type LlmUsage,
+  AGY_PRINT_TIMEOUT,
   type Production,
   ossclipOutputPathFor,
   type ProviderName,
@@ -346,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
@@ -1413,6 +1469,14 @@ export function cleanupChoicesLine(vetoed: readonly Segment[], outputDuration: n
  * and even on a talking head a 7% lurch reads as the camera stumbling. Big
  * enough to break up the jump, small enough to pass as sensor noise.
  */
+/**
+ * How long a silent antigravity call runs before the spinner admits it (§149).
+ * Well clear of the 17-46s a healthy call takes, so a normal run never shows
+ * the notice, and well short of AGY_PRINT_TIMEOUT, so it lands while the wait
+ * still has somewhere to go.
+ */
+export const AGY_SLOW_NOTICE_MS = 30_000;
 export const FACE_PUNCH_SCALE = 1.015;
 /**
@@ -2338,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
@@ -2354,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,
@@ -2721,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
@@ -2763,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.
@@ -2787,17 +2873,38 @@ export async function produce(inputArg: string, opts: ProduceOptions): Promise<P
         : null;
       if (!aiAnim) console.log(`▸ producing scenes (${providerName})…`);
       if (opts.forceComponent) console.log(`▸ forcing every graphic to ${opts.forceComponent}`);
-      const result = await phases.time("llm", () =>
-        produceScenes(provider!, {
-          transcript,
-          outputDuration: map.outputDuration,
-          intent: opts.intent,
-          speaker: opts.speaker ?? cfg.speaker,
-          forceComponent: opts.forceComponent,
-          framing: framingCtx,
-          aspect: landscape ? "16:9" : "9:16",
-        }),
-      );
+      // A hung agy is indistinguishable from a working one on screen: the
+      // 2026-08-23 field run sat on this spinner for 605.9s with no hint that
+      // a budget existed or that a recovery was coming, which reads as a
+      // freeze rather than as waiting (§149). Only antigravity has a
+      // print-timeout and a fallback, so only it gets the notice — and only
+      // once the call is actually slow, so a healthy run never sees it.
+      const slowNotice =
+        aiAnim && providerName === "antigravity"
+          ? setTimeout(
+              () =>
+                // Short on purpose: StageAnimator clamps the subtitle to the
+                // terminal width and floors that at 40 columns, and the first
+                // draft lost the budget to "falling back to the n...". The
+                // number is the only part that changes what the user does
+                // (wait vs. Ctrl-C), so it has to survive the clamp.
+                aiAnim.update(`agy not replying — falling back at ${AGY_PRINT_TIMEOUT}...`),
+              AGY_SLOW_NOTICE_MS,
+            )
+          : undefined;
+      const result = await phases
+        .time("llm", () =>
+          produceScenes(provider!, {
+            transcript,
+            outputDuration: map.outputDuration,
+            intent: opts.intent,
+            speaker: opts.speaker ?? cfg.speaker,
+            forceComponent: opts.forceComponent,
+            framing: framingCtx,
+            aspect: landscape ? "16:9" : "9:16",
+          }),
+        )
+        .finally(() => clearTimeout(slowNotice));
       if (aiAnim) aiAnim.stop();
       scenes = result.scenes;
       beatSheet = { hook: result.beatSheet.hook, coverText: result.beatSheet.coverText };
@@ -2873,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).