@vanillaskyai/video 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -4,6 +4,17 @@ VanillaSky follows semantic versioning. This changelog begins with the 0.1 beta.
 
 ## Unreleased
 
+## 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
+  pages remain the authoritative source for the current version.
+
 ## 0.5.0
 
 ### Breaking changes

package/README.md

@@ -1,7 +1,5 @@
 # Give your AI a video output
 
-![npm version](https://img.shields.io/npm/v/@vanillaskyai/video?label=version)
-
 **VanillaSky is the open-source video response layer.** Turn text, structured
 data, and live application context into personalized video responses that start
 playing while your LLM composes them.

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

@@ -349,6 +349,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 +609,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 +619,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 +634,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 +678,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 +689,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 +718,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 +763,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 +810,6 @@ function createVideo(rawInput, options) {
   return {
     request,
     initialConfig,
-    initialStyle: initialConfig.style,
     stream,
     result,
     abort(reason = "user cancelled") {

package/dist/{compose-video-QJHKTOQ7.js → compose-video-KMQEDOI7.js}

@@ -1,6 +1,6 @@
 import {
   createVideo
-} from "./chunk-3ROGEU5A.js";
+} from "./chunk-D6I2UQ5W.js";
 import "./chunk-E7CL7UPB.js";
 import "./chunk-FZHMQFG3.js";
 import "./chunk-G66Z5CWR.js";

package/dist/server.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-34O5BY6X.js";
 import {
   createVideo
-} from "./chunk-3ROGEU5A.js";
+} from "./chunk-D6I2UQ5W.js";
 import "./chunk-E7CL7UPB.js";
 import {
   BUILTIN_SERVER_TEMPLATE_KIT,

package/dist/test.js

@@ -233,7 +233,7 @@ async function* simulateVideoStream(parts, options = {}) {
   if (timeoutMs != null && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
     throw new Error("Simulation timeoutMs must be a non-negative finite number");
   }
-  const { createVideo } = await import("./compose-video-QJHKTOQ7.js");
+  const { createVideo } = await import("./compose-video-KMQEDOI7.js");
   const { createTextDeltaVideoPlanner } = await import("./text-stream-J6EDDJP4.js");
   const { BUILTIN_SERVER_TEMPLATE_KIT } = await import("./builtin-server-YHEZ2JRF.js");
   const { createTemplateSceneValidator } = await import("./validate-T7GBU2YF.js");

package/examples/nextjs-quickstart/package.json

@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^4.0.41",
-    "@vanillaskyai/video": "0.5.0",
+    "@vanillaskyai/video": "0.5.2",
     "ai": "^7.0.77",
     "next": "16.3.2",
     "react": "19.2.8",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanillaskyai/video",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Open-source video response SDK for personalized AI applications.",
   "keywords": [
     "generative-video",