@ossclip/scenes 0.1.36 → 0.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossclip/scenes",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "ossclip's scene library and stage geometry — React components shared by preview and render",
   "type": "module",
   "license": "MIT",
@@ -19,7 +19,7 @@
   ],
   "dependencies": {
     "zod": "^3.25.0",
-    "@ossclip/core": "0.1.36"
+    "@ossclip/core": "0.1.38"
   },
   "peerDependencies": {
     "react": ">=18",

package/src/SfxTrack.tsx

@@ -14,10 +14,15 @@ import { visibleSfxCues, type SfxCueProps } from "./sfx-track";
  * overlay would have meant (and would have needed its own gain staging to
  * avoid clipping the take it lands on).
  *
- * No duration on the Sequences: an effect plays for its own length. That is
- * also why cues can overlap the composition's own end — Remotion truncates the
- * tail at the last frame, and a whoosh clipped by the end of the video is the
- * same thing an editor would do by hand.
+ * BOUNDED Sequences (2026-09-18). These carried no duration at all — "an
+ * effect plays for its own length" — which is true of the SOUND and false of
+ * the tag: an unbounded Sequence keeps its `<Audio>` mounted to the end of the
+ * composition, so the mounted count climbed with the playhead until the
+ * editor's Player ran out of shared audio tags and the error boundary ate the
+ * whole stage (`SFX_FALLBACK_DURATION_SEC` has the field report). The length
+ * comes from the pack's `durationSec`, and cues still overlap the
+ * composition's end — `visibleSfxCues` clamps there, the same truncation
+ * Remotion would have done at the last frame.
  *
  * Deliberately invisible to the editor, the Watermark/CoverInVideo rule: no
  * `data-edit-id`, nothing to hit-test, nothing rendered at all. Placement
@@ -34,6 +39,7 @@ export const SfxTrack: React.FC<{ cues: readonly SfxCueProps[] }> = ({ cues }) =
           // key, and React would remount one of them on any list change.
           key={`${cue.from}-${i}`}
           from={cue.from}
+          durationInFrames={cue.durationInFrames}
           layout="none"
         >
           <Audio

package/src/sfx-track.ts

@@ -13,8 +13,34 @@ export interface SfxCueProps {
   soundFile: string;
   atSec: number;
   gain: number;
+  /**
+   * The sound's own length, when the pack declared one. Present so the
+   * renderer can BOUND the cue's Sequence — see `SFX_FALLBACK_DURATION_SEC`
+   * for why an unbounded one took the editor's preview down (2026-09-18).
+   */
+  durationSec?: number;
 }
 
+/**
+ * How long a cue's Sequence lasts when the pack declared no `durationSec`.
+ *
+ * There has to be a bound. An unbounded Sequence keeps its `<Audio>` MOUNTED
+ * for the rest of the composition, so the mounted-audio count only ever grew
+ * with the playhead — and the editor's `<Player>` mounts its audio through a
+ * fixed pool of shared tags. The sixth cue of this project's thirteen threw
+ * "Tried to simultaneously mount 6 <Html5Audio /> tags", Remotion's error
+ * boundary replaced the whole stage with a warning triangle, and NOTHING
+ * played again — not even the takes before the cue — until a reload (field
+ * report 2026-09-18, ".ossclip/CAA ship karachi After"). The render never saw
+ * it: an ffmpeg render mounts no shared tags.
+ *
+ * Generous on purpose: longer than any sound in the bundled packs, so a cue
+ * with no declared length is bounded without being TRUNCATED. A sound that
+ * really does run past it is cut off at ten seconds, which is the trade a
+ * pack author fixes by declaring `durationSec`.
+ */
+export const SFX_FALLBACK_DURATION_SEC = 10;
+
 /**
  * The loudest a cue may play. `HTMLMediaElement.volume` THROWS an
  * IndexSizeError above 1, so an un-clamped gain would take the editor's
@@ -39,17 +65,30 @@ export function sfxCuesFor(value: unknown): SfxCueProps[] {
   const cues: SfxCueProps[] = [];
   for (const entry of value) {
     if (typeof entry !== "object" || entry === null) continue;
-    const v = entry as { soundFile?: unknown; atSec?: unknown; gain?: unknown };
+    const v = entry as {
+      soundFile?: unknown;
+      atSec?: unknown;
+      gain?: unknown;
+      durationSec?: unknown;
+    };
     if (typeof v.soundFile !== "string" || v.soundFile.length === 0) continue;
     if (typeof v.atSec !== "number" || !Number.isFinite(v.atSec) || v.atSec < 0) continue;
     // An absent gain is 1 (play it as recorded); a mangled one is refused
     // rather than defaulted, because a wrong LEVEL is audible and silent
     // about being wrong.
     if (v.gain !== undefined && (typeof v.gain !== "number" || !Number.isFinite(v.gain))) continue;
+    // A mangled length is DROPPED, not the cue: the sound still has a fallback
+    // bound to fall back on, and silencing a whoosh over a number nobody hears
+    // would be a worse trade than the rest of this parser's drops.
+    const durationSec =
+      typeof v.durationSec === "number" && Number.isFinite(v.durationSec) && v.durationSec > 0
+        ? v.durationSec
+        : undefined;
     cues.push({
       soundFile: v.soundFile,
       atSec: v.atSec,
       gain: Math.min(SFX_MAX_VOLUME, Math.max(0, v.gain ?? 1)),
+      ...(durationSec === undefined ? {} : { durationSec }),
     });
   }
   return cues;
@@ -64,17 +103,24 @@ export function sfxCuesFor(value: unknown): SfxCueProps[] {
  * than clamped to it: a whoosh planned for a moment the render no longer
  * reaches must not pile onto the final frame with everything else that fell
  * off the end.
+ *
+ * `durationInFrames` per cue is the LENGTH the Sequence gets (2026-09-18): the
+ * declared `durationSec`, or `SFX_FALLBACK_DURATION_SEC`, clamped so a cue
+ * near the end never asks for frames the composition does not have — Remotion
+ * truncates the tail anyway, and a Sequence that ends WITH the composition is
+ * the same mounted-forever tag this bound exists to retire.
  */
 export function visibleSfxCues(
   cues: readonly SfxCueProps[],
   fps: number,
   durationInFrames: number,
-): Array<SfxCueProps & { from: number }> {
-  const out: Array<SfxCueProps & { from: number }> = [];
+): Array<SfxCueProps & { from: number; durationInFrames: number }> {
+  const out: Array<SfxCueProps & { from: number; durationInFrames: number }> = [];
   for (const cue of cues) {
     const from = Math.round(cue.atSec * fps);
     if (from < 0 || from >= durationInFrames) continue;
-    out.push({ ...cue, from });
+    const want = Math.ceil((cue.durationSec ?? SFX_FALLBACK_DURATION_SEC) * fps);
+    out.push({ ...cue, from, durationInFrames: Math.max(1, Math.min(want, durationInFrames - from)) });
   }
   return out;
 }