@vanillaskyai/video 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@ VanillaSky follows semantic versioning. This changelog begins with the 0.1 beta.
 
 ## Unreleased
 
+## 0.5.3
+
+- Makes `crossfade` the default for generated videos and mounts changed media
+  invisibly before every contiguous cut, including templates that own their
+  transition. This extends the existing media warm-up window so the browser can
+  decode the incoming backdrop and replace its stock poster with the real first
+  frame while still hidden, instead of flashing the gradient or visibly swapping
+  crops after the cut. Making camera motion opt-in also removes the scale reset
+  that could look like a quick pullback during the fade.
+
+## 0.5.2
+
+- Refactors composition state transitions into a deterministic, directly
+  tested session engine without changing the public API, event stream,
+  checksums, or runtime behavior.
+
 ## 0.5.1
 
 - Removes the redundant README version badge. Package registries and release

package/dist/{bg-confetti-KTHLUJPO.js → bg-confetti-572VDSYM.js}

@@ -8,7 +8,7 @@ import {
 import "./chunk-L5BTTCZV.js";
 import {
   BrandGradientOverlay
-} from "./chunk-IJM4B2ZN.js";
+} from "./chunk-MFYFZQHM.js";
 import "./chunk-XTOXFMLM.js";
 import {
   resolveTokens

package/dist/{bg-emoji-AW7374DZ.js → bg-emoji-T4IEJ6U2.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-L5BTTCZV.js";
 import {
   BrandGradientOverlay
-} from "./chunk-IJM4B2ZN.js";
+} from "./chunk-MFYFZQHM.js";
 import "./chunk-XTOXFMLM.js";
 import {
   resolveTokens

package/dist/{bg-media-KGYE6UVS.js → bg-media-VSFT5YC7.js}

@@ -1,7 +1,7 @@
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-4AODC6MS.js";
+} from "./chunk-SNVWTK63.js";
 import {
   hasSceneMedia
 } from "./chunk-35LIYILY.js";
@@ -13,7 +13,7 @@ import {
   TemplateText
 } from "./chunk-TCEHK2BW.js";
 import "./chunk-L5BTTCZV.js";
-import "./chunk-IJM4B2ZN.js";
+import "./chunk-MFYFZQHM.js";
 import "./chunk-XTOXFMLM.js";
 import {
   resolveTokens

package/dist/{brand-message-AY43ZQR2.js → brand-message-GSM2LOEP.js}

@@ -4,12 +4,12 @@ import {
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-4AODC6MS.js";
+} from "./chunk-SNVWTK63.js";
 import "./chunk-35LIYILY.js";
 import {
   renderWithEmoji
 } from "./chunk-L5BTTCZV.js";
-import "./chunk-IJM4B2ZN.js";
+import "./chunk-MFYFZQHM.js";
 import {
   interpolate
 } from "./chunk-XTOXFMLM.js";

package/dist/{chart-bar-Z42RDRQT.js → chart-bar-ZGGCV3ED.js}

@@ -1,7 +1,7 @@
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-4AODC6MS.js";
+} from "./chunk-SNVWTK63.js";
 import {
   hasSceneMedia
 } from "./chunk-35LIYILY.js";
@@ -12,7 +12,7 @@ import "./chunk-L5BTTCZV.js";
 import {
   TOP_TEXT_AREA_RATIO,
   withOpacity
-} from "./chunk-IJM4B2ZN.js";
+} from "./chunk-MFYFZQHM.js";
 import {
   SPRING_SNAPPY,
   interpolate,

package/dist/{chart-counter-X7NAOQ2C.js → chart-counter-T3MXDPP6.js}

@@ -4,7 +4,7 @@ import {
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-4AODC6MS.js";
+} from "./chunk-SNVWTK63.js";
 import {
   hasSceneMedia
 } from "./chunk-35LIYILY.js";
@@ -19,7 +19,7 @@ import "./chunk-L5BTTCZV.js";
 import {
   TOP_TEXT_AREA_RATIO,
   withOpacity
-} from "./chunk-IJM4B2ZN.js";
+} from "./chunk-MFYFZQHM.js";
 import {
   interpolate,
   spring

package/dist/{chart-progress-ring-7NSNNHL4.js → chart-progress-ring-OT5Z2LMK.js}

@@ -5,7 +5,7 @@ import {
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-4AODC6MS.js";
+} from "./chunk-SNVWTK63.js";
 import {
   hasSceneMedia
 } from "./chunk-35LIYILY.js";
@@ -16,7 +16,7 @@ import "./chunk-L5BTTCZV.js";
 import {
   TOP_TEXT_AREA_RATIO,
   withOpacity
-} from "./chunk-IJM4B2ZN.js";
+} from "./chunk-MFYFZQHM.js";
 import {
   interpolate
 } from "./chunk-XTOXFMLM.js";

package/dist/check-runtime.js

@@ -1,6 +1,6 @@
 import {
   VideoFrame
-} from "./chunk-K6YVQODK.js";
+} from "./chunk-65MRKELL.js";
 import "./chunk-XWWLKRNU.js";
 import "./chunk-SPVTJH3F.js";
 import {

package/dist/{chunk-3ROGEU5A.js → chunk-3OU7HIEB.js}

@@ -223,8 +223,9 @@ function buildInitialComposition(input, audio, snapshotRetention, closerReserveS
         brand: resolveVideoBrand(input.brand),
         density: input.style?.density ?? "normal",
         motion: input.style?.motion ?? "normal",
-        defaultBackgroundEffect: input.style?.backgroundEffect ?? "slow-zoom-in",
-        defaultTextArchetype: input.style?.textArchetype ?? "subtle"
+        defaultBackgroundEffect: input.style?.backgroundEffect ?? "static",
+        defaultTextArchetype: input.style?.textArchetype ?? "subtle",
+        defaultTransition: "crossfade"
       },
       meta
     },
@@ -349,6 +350,193 @@ function createSceneQualityWarnings(scene) {
   }];
 }
 
+// src/server/composition-session.ts
+var warningActions = (warnings) => warnings.map((warning) => ({ type: "response.warning", warning }));
+function createCompositionSession() {
+  return {
+    acceptedSceneCount: 0,
+    rejectedSceneCount: 0,
+    planCompleted: false,
+    runtimeDurationLimited: false,
+    deferredForCloser: [],
+    closerCommitted: false,
+    plannerReportedLength: false,
+    finishReason: "stop"
+  };
+}
+function pace(scene, video, options, closerReserveSec) {
+  return paceScene(scene, {
+    previousScenes: video.scenes,
+    audio: video.audio,
+    maxDurationSec: options.maxDurationSec,
+    closerReserveSec,
+    getTemplatePacing: options.getTemplatePacing
+  });
+}
+function commitScene(session, result, includeQualityWarnings) {
+  return {
+    session: {
+      ...session,
+      acceptedSceneCount: session.acceptedSceneCount + 1
+    },
+    actions: [
+      ...warningActions(result.warnings),
+      ...includeQualityWarnings ? warningActions(createSceneQualityWarnings(result.scene)) : [],
+      { type: "scene.add", scene: result.scene }
+    ]
+  };
+}
+function completePlan(session, reportedFinishReason, requireCloser) {
+  const missingCloser = requireCloser && !session.closerCommitted;
+  const finishReason = session.runtimeDurationLimited ? "length" : reportedFinishReason != null && reportedFinishReason !== "stop" ? reportedFinishReason : missingCloser ? "other" : "stop";
+  return {
+    session: {
+      ...session,
+      planCompleted: true,
+      plannerReportedLength: reportedFinishReason === "length",
+      finishReason
+    },
+    actions: missingCloser ? [{ type: "response.warning", warning: createMissingCloserWarning() }] : []
+  };
+}
+function advanceComposition(session, part, video, options) {
+  if (session.planCompleted) {
+    throw new Error(part.type === "plan.complete" ? "The planner emitted plan.complete more than once" : "The planner emitted content after plan.complete");
+  }
+  if (part.type === "plan.complete") {
+    if (!session.pendingCloser) {
+      let next2 = { ...session, deferredForCloser: [] };
+      let currentVideo = video;
+      const actions2 = [];
+      for (const deferred of session.deferredForCloser) {
+        const recovered = pace(deferred, currentVideo, options, 0);
+        if (!recovered.scene) {
+          next2 = {
+            ...next2,
+            rejectedSceneCount: next2.rejectedSceneCount + 1,
+            runtimeDurationLimited: true
+          };
+          actions2.push(...warningActions(recovered.warnings));
+          continue;
+        }
+        const committed2 = commitScene(next2, { ...recovered, scene: recovered.scene }, true);
+        next2 = committed2.session;
+        actions2.push(...committed2.actions);
+        currentVideo = { ...currentVideo, scenes: [...currentVideo.scenes, recovered.scene] };
+      }
+      const completed2 = completePlan(next2, part.finishReason, options.requireCloser);
+      return {
+        session: completed2.session,
+        actions: [...actions2, ...completed2.actions]
+      };
+    }
+    let next = {
+      ...session,
+      rejectedSceneCount: session.rejectedSceneCount + session.deferredForCloser.length,
+      runtimeDurationLimited: session.runtimeDurationLimited || session.deferredForCloser.length > 0,
+      deferredForCloser: []
+    };
+    const actions = session.deferredForCloser.map((scene) => ({
+      type: "response.warning",
+      warning: createOmittedForCloserWarning(scene.id)
+    }));
+    const closer = pace(session.pendingCloser, video, options, 0);
+    if (!closer.scene) {
+      next = {
+        ...next,
+        rejectedSceneCount: next.rejectedSceneCount + 1,
+        runtimeDurationLimited: true
+      };
+      actions.push(...warningActions(closer.warnings));
+      const completed2 = completePlan(next, part.finishReason, options.requireCloser);
+      return {
+        session: completed2.session,
+        actions: [...actions, ...completed2.actions]
+      };
+    }
+    const committed = commitScene(next, { ...closer, scene: closer.scene }, false);
+    next = { ...committed.session, closerCommitted: true };
+    const completed = completePlan(next, part.finishReason, options.requireCloser);
+    return {
+      session: completed.session,
+      actions: [...actions, ...committed.actions, ...completed.actions]
+    };
+  }
+  const metadata = options.getTemplatePacing?.(part.scene.templateId);
+  const isAsk = metadata?.jobs?.includes("ask") === true;
+  const isPayoff = metadata?.jobs?.includes("payoff") === true;
+  if (part.placement === "closer" && metadata && !isAsk && !isPayoff) {
+    throw new Error(`Scene template ${part.scene.templateId} cannot be used as a closer`);
+  }
+  if (part.placement === "closer" || isAsk) {
+    if (session.pendingCloser) {
+      return {
+        session: {
+          ...session,
+          rejectedSceneCount: session.rejectedSceneCount + 1
+        },
+        actions: [{
+          type: "response.warning",
+          warning: createDuplicateCloserWarning()
+        }]
+      };
+    }
+    return { session: { ...session, pendingCloser: part.scene }, actions: [] };
+  }
+  if (session.deferredForCloser.length > 0) {
+    return {
+      session: { ...session, deferredForCloser: [...session.deferredForCloser, part.scene] },
+      actions: []
+    };
+  }
+  const paced = pace(
+    part.scene,
+    video,
+    options,
+    session.pendingCloser ? pendingCloserReserve(session.pendingCloser, options.getTemplatePacing) : options.closerReserveSec
+  );
+  if (!paced.scene) {
+    if (paced.warnings.some(({ code }) => code === "scene_omitted_for_closer")) {
+      return {
+        session: { ...session, deferredForCloser: [...session.deferredForCloser, part.scene] },
+        actions: []
+      };
+    }
+    return {
+      session: {
+        ...session,
+        rejectedSceneCount: session.rejectedSceneCount + 1,
+        runtimeDurationLimited: true
+      },
+      actions: warningActions(paced.warnings)
+    };
+  }
+  return commitScene(session, { ...paced, scene: paced.scene }, true);
+}
+function rejectCompositionScene(session) {
+  return {
+    ...session,
+    rejectedSceneCount: session.rejectedSceneCount + 1
+  };
+}
+function recoverComposition(session, video, options) {
+  if (!session.pendingCloser || session.closerCommitted || video.scenes.length === 0) {
+    return { session, actions: [] };
+  }
+  const closer = pace(session.pendingCloser, video, options, 0);
+  if (!closer.scene) {
+    return {
+      session,
+      actions: warningActions(closer.warnings)
+    };
+  }
+  const committed = commitScene(session, { ...closer, scene: closer.scene }, false);
+  return {
+    session: { ...committed.session, closerCommitted: true },
+    actions: committed.actions
+  };
+}
+
 // src/server/composition-runtime.ts
 function invokeIsolated(callback, value) {
   if (!callback) return;
@@ -422,8 +610,6 @@ function createVideo(rawInput, options) {
     rejectResult = reject;
   });
   const startedAt = monotonicNow();
-  let acceptedSceneCount = 0;
-  let rejectedSceneCount = 0;
   let timeToFirstSceneMs;
   const { sink: lifecycle, settle: settleProviderLifecycle } = createProviderLifecycle();
   const reportedErrors = /* @__PURE__ */ new WeakSet();
@@ -434,6 +620,13 @@ function createVideo(rawInput, options) {
   };
   const eventSource = (async function* () {
     let state = createVideoState();
+    let composition = createCompositionSession();
+    const compositionOptions = {
+      maxDurationSec: input.maxDurationSec ?? 30,
+      closerReserveSec,
+      requireCloser: options.requireCloser ?? false,
+      getTemplatePacing: options.getTemplatePacing
+    };
     const emit = (event) => {
       state = applyVideoEvent(state, event);
       if (event.type === "response.warning") {
@@ -442,21 +635,23 @@ function createVideo(rawInput, options) {
       options.onEvent?.(event);
       return event;
     };
+    const emitCompositionAction = (action) => {
+      if (action.type === "response.warning") {
+        return emit(events.create("response.warning", { warning: action.warning }));
+      }
+      const event = emit(events.create("scene.add", {
+        scene: action.scene,
+        position: state.config?.scenes.length ?? 0
+      }));
+      timeToFirstSceneMs ??= Math.max(0, monotonicNow() - startedAt);
+      return event;
+    };
     const finish = (finalState) => {
       if (!settled) {
         settled = true;
         resolveResult(finalState);
       }
     };
-    let planCompleted = false;
-    let generatedSceneCount = 0;
-    let runtimeDurationLimited = false;
-    let pendingCloser;
-    const deferredForCloser = [];
-    let plannerReportedLength = false;
-    let closerCommitted = false;
-    let missingCloser = false;
-    let finishReason = "stop";
     try {
       yield emit(events.create("response.start", {
         requestId,
@@ -484,8 +679,8 @@ function createVideo(rawInput, options) {
           const part = resolveSuppliedMediaPlanPart(parseVideoPlanPart(untrustedPart), input);
           attemptedScene = part.type === "scene.add";
           if (controller.signal.aborted) throw controller.signal.reason ?? new Error(abortReason);
-          if (planCompleted && part.type !== "plan.complete") {
-            throw new Error("The planner emitted content after plan.complete");
+          if (composition.planCompleted) {
+            throw new Error(part.type === "plan.complete" ? "The planner emitted plan.complete more than once" : "The planner emitted content after plan.complete");
           }
           if (part.type === "scene.add") {
             if (options.capabilities?.templates != null && !options.capabilities.templates.includes(part.scene.templateId)) {
@@ -495,138 +690,16 @@ function createVideo(rawInput, options) {
               input,
               previousScenes: state.config?.scenes ?? []
             });
-            const templatePacing = options.getTemplatePacing?.(part.scene.templateId);
-            const isAskCandidate = templatePacing?.jobs?.includes("ask") === true;
-            const isPayoffCandidate = templatePacing?.jobs?.includes("payoff") === true;
-            if (part.placement === "closer" && templatePacing && !isAskCandidate && !isPayoffCandidate) {
-              throw new Error(`Scene template ${part.scene.templateId} cannot be used as a closer`);
-            }
-            const isCloserCandidate = part.placement === "closer" || isAskCandidate;
-            if (isCloserCandidate) {
-              if (pendingCloser) {
-                rejectedSceneCount += 1;
-                yield emit(events.create("response.warning", {
-                  warning: createDuplicateCloserWarning()
-                }));
-              } else {
-                pendingCloser = part.scene;
-              }
-              continue;
-            }
-            if (deferredForCloser.length) {
-              deferredForCloser.push(part.scene);
-              continue;
-            }
-            const paced = paceScene(part.scene, {
-              previousScenes: state.config?.scenes ?? [],
-              audio: state.config?.audio,
-              maxDurationSec: input.maxDurationSec ?? 30,
-              closerReserveSec: pendingCloser ? pendingCloserReserve(pendingCloser, options.getTemplatePacing) : closerReserveSec,
-              getTemplatePacing: options.getTemplatePacing
-            });
-            if (!paced.scene) {
-              if (paced.warnings.some(({ code }) => code === "scene_omitted_for_closer")) {
-                deferredForCloser.push(part.scene);
-                continue;
-              }
-              for (const warning of paced.warnings) {
-                yield emit(events.create("response.warning", { warning }));
-              }
-              runtimeDurationLimited = true;
-              rejectedSceneCount += 1;
-              continue;
-            }
-            const scene = paced.scene;
-            for (const warning of paced.warnings) {
-              yield emit(events.create("response.warning", { warning }));
-            }
-            for (const warning of createSceneQualityWarnings(scene)) {
-              yield emit(events.create("response.warning", { warning }));
-            }
-            yield emit(events.create("scene.add", {
-              scene,
-              position: state.config?.scenes.length ?? 0
-            }));
-            generatedSceneCount += 1;
-            acceptedSceneCount += 1;
-            timeToFirstSceneMs ??= Math.max(0, monotonicNow() - startedAt);
-          } else if (part.type === "plan.complete") {
-            if (planCompleted) throw new Error("The planner emitted plan.complete more than once");
-            if (pendingCloser) {
-              if (deferredForCloser.length) runtimeDurationLimited = true;
-              for (const deferred of deferredForCloser.splice(0)) {
-                rejectedSceneCount += 1;
-                yield emit(events.create("response.warning", {
-                  warning: createOmittedForCloserWarning(deferred.id)
-                }));
-              }
-              const pacedCloser = paceScene(pendingCloser, {
-                previousScenes: state.config?.scenes ?? [],
-                audio: state.config?.audio,
-                maxDurationSec: input.maxDurationSec ?? 30,
-                closerReserveSec: 0,
-                getTemplatePacing: options.getTemplatePacing
-              });
-              for (const warning of pacedCloser.warnings) {
-                yield emit(events.create("response.warning", { warning }));
-              }
-              if (pacedCloser.scene) {
-                yield emit(events.create("scene.add", {
-                  scene: pacedCloser.scene,
-                  position: state.config?.scenes.length ?? 0
-                }));
-                generatedSceneCount += 1;
-                acceptedSceneCount += 1;
-                timeToFirstSceneMs ??= Math.max(0, monotonicNow() - startedAt);
-                closerCommitted = true;
-              } else {
-                runtimeDurationLimited = true;
-                rejectedSceneCount += 1;
-              }
-            } else if (deferredForCloser.length) {
-              for (const deferred of deferredForCloser.splice(0)) {
-                const recovered = paceScene(deferred, {
-                  previousScenes: state.config?.scenes ?? [],
-                  audio: state.config?.audio,
-                  maxDurationSec: input.maxDurationSec ?? 30,
-                  closerReserveSec: 0,
-                  getTemplatePacing: options.getTemplatePacing
-                });
-                for (const warning of recovered.warnings) {
-                  yield emit(events.create("response.warning", { warning }));
-                }
-                if (!recovered.scene) {
-                  runtimeDurationLimited = true;
-                  rejectedSceneCount += 1;
-                  continue;
-                }
-                for (const warning of createSceneQualityWarnings(recovered.scene)) {
-                  yield emit(events.create("response.warning", { warning }));
-                }
-                yield emit(events.create("scene.add", {
-                  scene: recovered.scene,
-                  position: state.config?.scenes.length ?? 0
-                }));
-                generatedSceneCount += 1;
-                acceptedSceneCount += 1;
-                timeToFirstSceneMs ??= Math.max(0, monotonicNow() - startedAt);
-              }
-            }
-            if (options.requireCloser && !closerCommitted) {
-              missingCloser = true;
-              yield emit(events.create("response.warning", {
-                warning: createMissingCloserWarning()
-              }));
-            }
-            planCompleted = true;
-            const reportedFinishReason = part.finishReason ?? "stop";
-            finishReason = runtimeDurationLimited ? "length" : reportedFinishReason !== "stop" ? reportedFinishReason : missingCloser ? "other" : "stop";
-            plannerReportedLength = part.finishReason === "length";
-            continue;
           }
+          if (!state.config) throw new Error("response.start did not initialize composition state");
+          const transition = advanceComposition(composition, part, state.config, compositionOptions);
+          for (const action of transition.actions) yield emitCompositionAction(action);
+          composition = transition.session;
         } catch (cause) {
           const error = cause instanceof Error ? cause : new Error(String(cause));
-          if (attemptedScene || untrustedPart != null && typeof untrustedPart === "object" && untrustedPart.type === "scene.add") rejectedSceneCount += 1;
+          if (attemptedScene || untrustedPart != null && typeof untrustedPart === "object" && untrustedPart.type === "scene.add") {
+            composition = rejectCompositionScene(composition);
+          }
           reportError(error);
           if ((options.invalidPartBehavior ?? "fail") === "fail") throw error;
           yield emit(events.create("response.error", {
@@ -646,35 +719,35 @@ function createVideo(rawInput, options) {
       for (const warning of provider.warnings) {
         yield emit(events.create("response.warning", { warning }));
       }
-      if (!planCompleted) throw new Error("The planner stream ended before plan.complete");
-      if (plannerReportedLength && generatedSceneCount === 0) {
+      if (!composition.planCompleted) throw new Error("The planner stream ended before plan.complete");
+      if (composition.plannerReportedLength && composition.acceptedSceneCount === 0) {
         throw new Error("The planner was truncated before adding a generated scene");
       }
-      if (plannerReportedLength) {
+      if (composition.plannerReportedLength) {
         yield emit(events.create("response.warning", {
           warning: createIncompletePlanWarning()
         }));
       }
-      if (generatedSceneCount === 0 && requiresGeneratedScene) {
+      if (composition.acceptedSceneCount === 0 && requiresGeneratedScene) {
         throw new Error("The planner completed without adding a scene");
       }
       const snapshot = parseVideo(state.config);
       const completeEvent = emit(events.create("response.complete", {
-        finishReason,
+        finishReason: composition.finishReason,
         snapshot,
         checksum: checksumVideo(snapshot)
       }));
       finish(state);
       const summary = {
-        finishReason,
+        finishReason: composition.finishReason,
         ...provider.usage ? { usage: provider.usage } : {},
         ...provider.providerMetadata !== void 0 ? { providerMetadata: provider.providerMetadata } : {},
         ...provider.requestedModelId ? { requestedModelId: provider.requestedModelId } : {},
         ...provider.resolvedModelId ? { resolvedModelId: provider.resolvedModelId } : {},
         ...timeToFirstSceneMs != null ? { timeToFirstSceneMs } : {},
         totalDurationMs: Math.max(0, monotonicNow() - startedAt),
-        acceptedSceneCount,
-        rejectedSceneCount,
+        acceptedSceneCount: composition.acceptedSceneCount,
+        rejectedSceneCount: composition.rejectedSceneCount,
         videoDurationSec: snapshot.scenes.at(-1)?.timing.endTime ?? 0,
         warnings: state.warnings.map(cloneWarning)
       };
@@ -691,30 +764,16 @@ function createVideo(rawInput, options) {
         return;
       }
       try {
-        if (pendingCloser && !closerCommitted && state.config?.scenes.length) {
-          const pacedCloser = paceScene(pendingCloser, {
-            previousScenes: state.config.scenes,
-            audio: state.config.audio,
-            maxDurationSec: input.maxDurationSec ?? 30,
-            closerReserveSec: 0,
-            getTemplatePacing: options.getTemplatePacing
-          });
-          for (const warning of pacedCloser.warnings) {
-            yield emit(events.create("response.warning", { warning }));
-          }
-          if (pacedCloser.scene) {
-            yield emit(events.create("scene.add", {
-              scene: pacedCloser.scene,
-              position: state.config.scenes.length
-            }));
-            generatedSceneCount += 1;
-            acceptedSceneCount += 1;
-            closerCommitted = true;
-          }
+        if (state.config) {
+          const recovery = recoverComposition(composition, state.config, compositionOptions);
+          for (const action of recovery.actions) yield emitCompositionAction(action);
+          composition = recovery.session;
         }
         const provider = await settleProviderLifecycle();
         for (const warning of provider.warnings) {
-          if (!state.warnings.some((existing) => existing.code === warning.code && existing.message === warning.message)) {
+          if (!state.warnings.some(
+            (existing) => existing.code === warning.code && existing.message === warning.message
+          )) {
             yield emit(events.create("response.warning", { warning }));
           }
         }
@@ -752,7 +811,6 @@ function createVideo(rawInput, options) {
   return {
     request,
     initialConfig,
-    initialStyle: initialConfig.style,
     stream,
     result,
     abort(reason = "user cancelled") {

package/dist/{chunk-K6YVQODK.js → chunk-65MRKELL.js}

@@ -173,11 +173,12 @@ function VideoFrame({
   const next = activeIndex < timeline.length - 1 ? timeline[activeIndex + 1] : void 0;
   const activeTemplate = kit.getTemplate(active.scene.templateId);
   const nextTemplate = next ? kit.getTemplate(next.scene.templateId) : void 0;
-  const contiguousNext = next && rangesAreContiguous(active, next) && activeTemplate.usesGlobalTransition && activeTemplate.transitionTiming && nextTemplate?.usesGlobalTransition && nextTemplate.transitionTiming ? next : void 0;
+  const contiguousNext = next && rangesAreContiguous(active, next) ? next : void 0;
+  const transitionableNext = contiguousNext && activeTemplate.usesGlobalTransition && activeTemplate.transitionTiming && nextTemplate?.usesGlobalTransition && nextTemplate.transitionTiming ? contiguousNext : void 0;
   const activeTiming = activeTemplate.transitionTiming;
   const nextTiming = nextTemplate?.transitionTiming;
   const eligibleNextTransition = Boolean(
-    transitionEnabled && contiguousNext && activeTiming && nextTiming && sceneBackgroundChanges(active, contiguousNext)
+    transitionEnabled && transitionableNext && activeTiming && nextTiming && sceneBackgroundChanges(active, transitionableNext)
   );
   const blendDuration = Math.min(
     SCENE_TRANSITION_SECONDS,

package/dist/{chunk-IJM4B2ZN.js → chunk-MFYFZQHM.js}

@@ -147,7 +147,7 @@ function getDriftTransform(progress, direction) {
 }
 function getBackgroundTransform(effect, progress, beatIntensity = 0, sceneIndex = 0) {
   const dir = DIRECTIONS[sceneIndex % DIRECTIONS.length];
-  const resolved = effect ?? "slow-zoom-in";
+  const resolved = effect ?? "static";
   switch (resolved) {
     case "slow-zoom-in":
       return {