@vanillaskyai/video 0.1.0

package/dist/chunk-IXCUY3B3.js

@@ -0,0 +1,786 @@
+import {
+  attachGenerationLifecycleSink
+} from "./chunk-E7CL7UPB.js";
+import {
+  applyVideoEvent,
+  checksumVideo,
+  createVideoState
+} from "./chunk-ABPKM4GK.js";
+import {
+  parseVideoPlanPart,
+  safePublicDiagnostic
+} from "./chunk-ERY4S6QV.js";
+import {
+  MAX_RETAINED_INSTRUCTIONS_LENGTH,
+  MAX_RETAINED_MEDIA_URLS,
+  MAX_RETAINED_MEDIA_URL_LENGTH,
+  MAX_RETAINED_SOURCE_LENGTH,
+  parseVideo
+} from "./chunk-GHJEAP4O.js";
+import {
+  VIDEO_PROTOCOL_VERSION,
+  VIDEO_SCHEMA_VERSION,
+  createVideoRequest
+} from "./chunk-EE6PK6XC.js";
+import {
+  getCloserReserve,
+  getReadableSceneDuration,
+  paceScene
+} from "./chunk-EVG2ZYIY.js";
+import {
+  resolveVideoBrand
+} from "./chunk-XGRA2MUV.js";
+
+// src/protocol/events.ts
+function createVideoEventFactory(options) {
+  let sequence = options.initialSequence ?? 0;
+  return {
+    create(type, data) {
+      const currentSequence = sequence;
+      sequence += 1;
+      return {
+        protocolVersion: VIDEO_PROTOCOL_VERSION,
+        runId: options.runId,
+        sequence: currentSequence,
+        eventId: `${options.runId}:${currentSequence}`,
+        type,
+        data
+      };
+    }
+  };
+}
+
+// src/server/prompts/user-prompt.ts
+var SUPPLIED_MEDIA_REFERENCE_BASE = "https://vanillasky.invalid/supplied/";
+function suppliedMediaReferences(input) {
+  return (input.suppliedMedia ?? []).map((media, index) => ({
+    reference: `${SUPPLIED_MEDIA_REFERENCE_BASE}media-${index + 1}`,
+    ...media.posterUrl ? { posterReference: `${SUPPLIED_MEDIA_REFERENCE_BASE}poster-${index + 1}` } : {},
+    type: media.type,
+    ...media.description ? { description: media.description } : {},
+    ...media.mimeType ? { mimeType: media.mimeType } : {},
+    ...media.focalPoint ? { focalPoint: media.focalPoint } : {},
+    ...media.treatment ? { treatment: media.treatment } : {},
+    ...media.role ? { role: media.role } : {}
+  }));
+}
+function mediaReferenceMap(input) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [index, media] of (input.suppliedMedia ?? []).entries()) {
+    result.set(`${SUPPLIED_MEDIA_REFERENCE_BASE}media-${index + 1}`, media.url);
+    if (media.posterUrl) result.set(`${SUPPLIED_MEDIA_REFERENCE_BASE}poster-${index + 1}`, media.posterUrl);
+  }
+  return result;
+}
+function resolveReferences(value, references) {
+  if (typeof value === "string") return references.get(value) ?? value;
+  if (Array.isArray(value)) return value.map((item) => resolveReferences(item, references));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, resolveReferences(child, references)]));
+}
+function resolveSuppliedMediaPlanPart(part, input) {
+  const references = mediaReferenceMap(input);
+  if (references.size === 0) return part;
+  if (part.type === "scene.add") {
+    return { ...part, scene: { ...part.scene, variables: resolveReferences(part.scene.variables, references) } };
+  }
+  if (part.type === "scene.patch" && part.patch.variables) {
+    return { ...part, patch: { ...part.patch, variables: resolveReferences(part.patch.variables, references) } };
+  }
+  if (part.type === "asset.patch") {
+    return { ...part, variables: resolveReferences(part.variables, references) };
+  }
+  return part;
+}
+function buildVideoUserPrompt(input, openingDurationSec = 0) {
+  return [
+    "Compose a video response from the structured customer input below.",
+    `Maximum duration: ${input.maxDurationSec ?? 30} seconds, including the supplied opening.`,
+    input.opening?.trim() ? `The host has already added the opening scene, which consumes ${openingDurationSec} seconds. Continue after it and do not repeat or rewrite it.` : "Add the first grounded scene as soon as it is complete.",
+    "The first generated body scene must be fully playable without external media. Use a content-fit text, data, comparison, list, or device-free template with no media URL or keyword.",
+    "Never use media, ctaMedia, or reaction as the first generated body template, even with mediaType=gradient. Choose a non-media template first.",
+    "Add that scene before resolving any stock or supplied asset. Media belongs on later body scenes and must arrive without blocking scene additions.",
+    "The raw input is the complete factual boundary. Do not add outside claims.",
+    "Select the most decision-relevant grounded takeaways that fit the duration; represent each selected takeaway once before completing the response.",
+    "For a long source, summarize instead of attempting to represent every fact, unless the creative instructions explicitly request complete fact coverage that fits the duration.",
+    "Preserve exact wording and numbers for the takeaways you select. Preserve qualifiers, units, denominators, ranges, and comparison direction; for example, do not shorten 4.8 out of 5 to 4.8.",
+    "Choose the scene count from the distinct grounded material and the duration budget. Use fewer scenes for sparse input; continue beyond five when rich input warrants it and timing allows.",
+    "Use a different suitable template for each body scene when the catalog supports it.",
+    "Never add filler to satisfy a count or diversity target.",
+    input.suppliedMedia?.length ? "Select zero or more relevant opaque supplied-media references for visible later scenes. Never invent or transform a reference, and never emit mediaKeyword without a resolved mediaUrl." : "Use asset-free templates. No media URL has been supplied or resolved. Never emit mediaKeyword without a resolved mediaUrl.",
+    "",
+    "RAW INPUT",
+    input.input.trim(),
+    "",
+    "CREATIVE INSTRUCTIONS",
+    input.instructions?.trim() || "None supplied.",
+    "",
+    "PERSONALIZATION",
+    JSON.stringify(input.personalization ?? {}),
+    "",
+    "SUPPLIED MEDIA",
+    JSON.stringify(suppliedMediaReferences(input)),
+    "",
+    "BRAND",
+    JSON.stringify({
+      ...input.brand?.name?.trim() ? { name: input.brand.name.trim() } : {},
+      hasLogo: Boolean(input.brand?.logoUrl?.trim())
+    })
+  ].join("\n");
+}
+
+// src/server/compose-video.ts
+function invokeIsolated(callback, value) {
+  if (!callback) return;
+  try {
+    void Promise.resolve(callback(value)).catch(() => void 0);
+  } catch {
+  }
+}
+function cloneWarning(warning) {
+  return {
+    code: warning.code,
+    category: warning.category,
+    message: warning.message,
+    ...warning.sceneId != null ? { sceneId: warning.sceneId } : {},
+    recoverable: warning.recoverable
+  };
+}
+function now() {
+  return globalThis.performance?.now?.() ?? Date.now();
+}
+function safeAbortReason(value) {
+  if (value instanceof DOMException && value.name === "TimeoutError") return "Request timed out";
+  if (value instanceof Error && value.name === "TimeoutError") return "Request timed out";
+  return safePublicDiagnostic(value instanceof Error ? value.message : value, "Request aborted");
+}
+function buildInitialConfig(input, audio, snapshotRetention, closerReserveSec, getTemplatePacing) {
+  const openingText = input.opening?.trim();
+  const rawScenes = openingText ? [{
+    id: "supplied-opening",
+    templateId: "notification",
+    variables: {
+      appName: input.brand?.name ?? "",
+      message: openingText
+    },
+    timing: { fixedDuration: 5 }
+  }] : [];
+  const scenes = [];
+  const warnings = [];
+  for (const scene of rawScenes) {
+    const maxDurationSec = input.maxDurationSec ?? 30;
+    const readableMinimum = getReadableSceneDuration(scene, getTemplatePacing?.(scene.templateId));
+    if (maxDurationSec < readableMinimum) {
+      throw new Error("Video response maximum duration cannot fit the supplied opening readably");
+    }
+    const paced = paceScene(scene, {
+      previousScenes: scenes,
+      audio,
+      maxDurationSec,
+      closerReserveSec: Math.min(closerReserveSec, maxDurationSec - readableMinimum),
+      getTemplatePacing
+    });
+    if (!paced.scene) throw new Error("Video response maximum duration cannot fit the supplied opening readably");
+    scenes.push(paced.scene);
+    warnings.push(...paced.warnings);
+  }
+  const meta = {
+    name: input.brand?.name?.trim() || "Video response"
+  };
+  if (snapshotRetention?.source) {
+    meta.source = input.input.trim().slice(0, MAX_RETAINED_SOURCE_LENGTH);
+  }
+  if (snapshotRetention?.instructions && input.instructions?.trim()) {
+    meta.prompt = input.instructions.trim().slice(0, MAX_RETAINED_INSTRUCTIONS_LENGTH);
+  }
+  if (snapshotRetention?.suppliedMediaUrls && input.suppliedMedia?.length) {
+    meta.uploadedMediaUrls = input.suppliedMedia.slice(0, MAX_RETAINED_MEDIA_URLS).map((item) => item.url);
+  }
+  return { config: {
+    schemaVersion: VIDEO_SCHEMA_VERSION,
+    orientation: input.orientation ?? "portrait",
+    scenes,
+    ...audio ? { audio } : {},
+    style: {
+      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"
+    },
+    meta
+  }, warnings };
+}
+function validateInput(input) {
+  if (!input.input.trim()) throw new Error("Video response input is required");
+  if (input.maxDurationSec != null && (!Number.isFinite(input.maxDurationSec) || input.maxDurationSec < 5 || input.maxDurationSec > 120)) {
+    throw new Error("Video response maximum duration must be between 5 and 120 seconds");
+  }
+  if (input.opening != null && !input.opening.trim()) {
+    throw new Error("Video response opening must be a non-empty string");
+  }
+  if (input.audio && !input.audio.src.trim()) {
+    throw new Error("Video response audio src must be a non-empty string");
+  }
+  if (input.audio && input.audio.src.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
+    throw new Error(`Video response audio src must be at most ${MAX_RETAINED_MEDIA_URL_LENGTH} characters`);
+  }
+  for (const [index, media] of (input.suppliedMedia ?? []).entries()) {
+    if (media.url.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
+      throw new Error(`Video response supplied media ${index} URL must be at most ${MAX_RETAINED_MEDIA_URL_LENGTH} characters`);
+    }
+    if (media.posterUrl && media.posterUrl.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
+      throw new Error(`Video response supplied media ${index} poster URL must be at most ${MAX_RETAINED_MEDIA_URL_LENGTH} characters`);
+    }
+  }
+  resolveVideoBrand(input.brand);
+}
+function createId(prefix) {
+  const randomId = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  return `${prefix}-${randomId}`;
+}
+function createPatchReadabilityWarning(sceneId) {
+  return {
+    code: "scene_patch_rejected_readability",
+    category: "readability",
+    message: "Scene update was omitted because it would make the timeline unreadable.",
+    sceneId,
+    recoverable: true
+  };
+}
+function createOmittedForCloserWarning(sceneId) {
+  return {
+    code: "scene_omitted_for_closer",
+    category: "readability",
+    message: "Scene was omitted because the final action must remain the last scene.",
+    sceneId,
+    recoverable: true
+  };
+}
+function sceneSlotDuration(scene) {
+  return Math.max(0, (scene.timing.endTime ?? 0) - (scene.timing.startTime ?? 0));
+}
+function createSceneQualityWarnings(scene) {
+  if (scene.templateId !== "barChart" || !Array.isArray(scene.variables.bars)) return [];
+  const values = scene.variables.bars.flatMap((bar) => {
+    if (!bar || typeof bar !== "object") return [];
+    const value = bar.value;
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? [value] : [];
+  });
+  if (values.length < 2 || Math.max(...values) / Math.min(...values) <= 20) return [];
+  return [{
+    code: "chart_scale_imbalance",
+    category: "readability",
+    message: "Chart values span more than 20\xD7; verify that they use comparable units.",
+    sceneId: scene.id,
+    recoverable: true
+  }];
+}
+function createVideo(input, options) {
+  validateInput(input);
+  if (input.opening?.trim() && options.capabilities?.templates != null && !options.capabilities.templates.includes("notification")) {
+    throw new Error("Scene template notification was not negotiated");
+  }
+  const requestId = options.requestId ?? createId("request");
+  const runId = options.runId ?? createId("run");
+  const request = createVideoRequest(input, {
+    requestId,
+    capabilities: options.capabilities
+  });
+  const initialAudio = input.audio === false ? void 0 : input.audio ? {
+    trackId: "soundtrack",
+    audioUrl: input.audio.src,
+    duration: input.maxDurationSec ?? 30,
+    beatDetection: { sensitivity: 0.5 },
+    beatMarkers: [],
+    volume: 1,
+    fadeOutMs: 3e3
+  } : options.selectAudio?.(input);
+  const closerReserveSec = getCloserReserve(
+    options.capabilities?.templates,
+    options.getTemplatePacing
+  );
+  const initial = buildInitialConfig(
+    input,
+    initialAudio,
+    options.snapshotRetention,
+    closerReserveSec,
+    options.getTemplatePacing
+  );
+  const initialConfig = initial.config;
+  for (let position = 0; position < initialConfig.scenes.length; position += 1) {
+    options.validateScene?.(initialConfig.scenes[position], {
+      input,
+      previousScenes: initialConfig.scenes.slice(0, position)
+    });
+  }
+  const userPrompt = buildVideoUserPrompt(
+    input,
+    initialConfig.scenes.at(-1)?.timing.endTime ?? 0
+  );
+  const events = createVideoEventFactory({ runId });
+  const controller = new AbortController();
+  let abortReason = "Request aborted";
+  const forwardAbort = () => {
+    abortReason = safeAbortReason(options.signal?.reason);
+    controller.abort(options.signal?.reason);
+  };
+  if (options.signal?.aborted) forwardAbort();
+  else options.signal?.addEventListener("abort", forwardAbort, { once: true });
+  let resolveResult;
+  let rejectResult;
+  let settled = false;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  const startedAt = now();
+  let acceptedSceneCount = 0;
+  let rejectedSceneCount = 0;
+  let timeToFirstSceneMs;
+  const providerResults = [];
+  const lifecycle = {
+    registerProviderResult(providerResult) {
+      providerResults.push(providerResult);
+    }
+  };
+  const reportedErrors = /* @__PURE__ */ new WeakSet();
+  const reportError = (error) => {
+    if (reportedErrors.has(error)) return;
+    reportedErrors.add(error);
+    invokeIsolated(options.onError, error);
+  };
+  const settleProviderLifecycle = async () => {
+    const results = await Promise.all(providerResults);
+    const warnings = results.flatMap((result2) => result2.warnings);
+    const uniqueWarnings = [...new Map(warnings.map((warning) => [
+      `${warning.code}\0${warning.category}\0${warning.message}\0${warning.sceneId ?? ""}`,
+      warning
+    ])).values()];
+    return results.reduce((summary, result2) => ({
+      ...summary,
+      ...result2,
+      warnings: uniqueWarnings
+    }), { warnings: uniqueWarnings });
+  };
+  const eventSource = (async function* () {
+    let state = createVideoState();
+    const emit = (event) => {
+      state = applyVideoEvent(state, event);
+      if (event.type === "response.warning") {
+        invokeIsolated(options.onWarning, cloneWarning(event.data.warning));
+      }
+      options.onEvent?.(event);
+      return event;
+    };
+    const finish = (finalState) => {
+      if (!settled) {
+        settled = true;
+        resolveResult(finalState);
+      }
+    };
+    try {
+      yield emit(events.create("response.start", {
+        requestId,
+        format: { orientation: initialConfig.orientation ?? "portrait" },
+        style: initialConfig.style,
+        meta: initialConfig.meta,
+        capabilities: options.capabilities
+      }));
+      if (initialConfig.audio) yield emit(events.create("audio.set", { audio: initialConfig.audio }));
+      for (const warning of initial.warnings) {
+        yield emit(events.create("response.warning", { warning }));
+      }
+      for (let position = 0; position < initialConfig.scenes.length; position += 1) {
+        yield emit(events.create("scene.add", {
+          scene: initialConfig.scenes[position],
+          position,
+          revision: 0
+        }));
+      }
+      let planCompleted = false;
+      let generatedSceneCount = 0;
+      let runtimeDurationLimited = false;
+      let askAccepted = false;
+      const deferredForCloser = [];
+      let plannerReportedLength = false;
+      let finishReason = "stop";
+      const systemPrompt = options.systemPrompt ?? (await import("./system-prompt-A6UXNTPK.js")).DEFAULT_VIDEO_SYSTEM_PROMPT;
+      const context = { request, systemPrompt, userPrompt, initialConfig, signal: controller.signal };
+      attachGenerationLifecycleSink(context, lifecycle);
+      for await (const untrustedPart of options.generate(context)) {
+        let attemptedScene = false;
+        try {
+          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 (part.type === "scene.add") {
+            if (options.capabilities?.templates != null && !options.capabilities.templates.includes(part.scene.templateId)) {
+              throw new Error(`Scene template ${part.scene.templateId} was not negotiated`);
+            }
+            if (askAccepted) {
+              runtimeDurationLimited = true;
+              rejectedSceneCount += 1;
+              yield emit(events.create("response.warning", {
+                warning: createOmittedForCloserWarning(part.scene.id)
+              }));
+              continue;
+            }
+            options.validateScene?.(part.scene, {
+              input,
+              previousScenes: state.config?.scenes ?? []
+            });
+            const templatePacing = options.getTemplatePacing?.(part.scene.templateId);
+            const isAskCandidate = templatePacing?.jobs?.includes("ask") === true;
+            if (deferredForCloser.length && !isAskCandidate) {
+              deferredForCloser.push(part.scene);
+              continue;
+            }
+            const paced = paceScene(part.scene, {
+              previousScenes: state.config?.scenes ?? [],
+              audio: state.config?.audio,
+              maxDurationSec: input.maxDurationSec ?? 30,
+              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;
+            const isAsk = isAskCandidate;
+            if (isAsk && deferredForCloser.length) {
+              runtimeDurationLimited = true;
+              for (const deferred of deferredForCloser.splice(0)) {
+                rejectedSceneCount += 1;
+                yield emit(events.create("response.warning", {
+                  warning: createOmittedForCloserWarning(deferred.id)
+                }));
+              }
+            }
+            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,
+              revision: 0
+            }));
+            if (isAsk) {
+              askAccepted = true;
+            }
+            generatedSceneCount += 1;
+            acceptedSceneCount += 1;
+            timeToFirstSceneMs ??= Math.max(0, now() - startedAt);
+          } else if (part.type === "scene.patch") {
+            const scenes = state.config?.scenes ?? [];
+            const sceneIndex = scenes.findIndex((scene) => scene.id === part.sceneId);
+            if (sceneIndex < 0) throw new Error(`Scene ${part.sceneId} does not exist`);
+            if (part.patch.timing && sceneIndex < scenes.length - 1) {
+              yield emit(events.create("response.warning", {
+                warning: createPatchReadabilityWarning(part.sceneId)
+              }));
+              continue;
+            }
+            const currentScene = scenes[sceneIndex];
+            if (part.patch.timing?.startTime != null && Math.abs(part.patch.timing.startTime - (currentScene.timing.startTime ?? 0)) > 1e-6) {
+              yield emit(events.create("response.warning", {
+                warning: createPatchReadabilityWarning(part.sceneId)
+              }));
+              continue;
+            }
+            let timing;
+            if (part.patch.timing) {
+              const requestedTiming = { ...currentScene.timing, ...part.patch.timing };
+              if (part.patch.timing.startTime != null && part.patch.timing.endTime == null) {
+                delete requestedTiming.endTime;
+              }
+              if (part.patch.timing.fixedDuration != null && part.patch.timing.endTime == null) {
+                delete requestedTiming.endTime;
+              }
+              const pacedPatch = paceScene({
+                ...currentScene,
+                ...part.patch,
+                variables: part.patch.variables ? { ...currentScene.variables, ...part.patch.variables } : currentScene.variables,
+                timing: requestedTiming
+              }, {
+                previousScenes: scenes.slice(0, sceneIndex),
+                audio: state.config?.audio,
+                maxDurationSec: input.maxDurationSec ?? 30,
+                closerReserveSec,
+                getTemplatePacing: options.getTemplatePacing
+              });
+              if (!pacedPatch.scene) {
+                yield emit(events.create("response.warning", {
+                  warning: createPatchReadabilityWarning(part.sceneId)
+                }));
+                continue;
+              }
+              for (const warning of pacedPatch.warnings) {
+                yield emit(events.create("response.warning", { warning }));
+              }
+              timing = pacedPatch.scene.timing;
+            }
+            const patch = {
+              ...part.patch,
+              ...timing ? { timing } : {}
+            };
+            const nextScene = {
+              ...currentScene,
+              ...patch,
+              variables: patch.variables ? { ...currentScene.variables, ...patch.variables } : currentScene.variables,
+              timing: patch.timing ? { ...currentScene.timing, ...patch.timing } : currentScene.timing
+            };
+            options.validateScene?.(nextScene, { input, previousScenes: scenes });
+            if (getReadableSceneDuration(
+              nextScene,
+              options.getTemplatePacing?.(nextScene.templateId)
+            ) > sceneSlotDuration(nextScene) + 1e-6) {
+              yield emit(events.create("response.warning", {
+                warning: createPatchReadabilityWarning(part.sceneId)
+              }));
+              continue;
+            }
+            yield emit(events.create("scene.patch", {
+              sceneId: part.sceneId,
+              revision: (state.sceneRevisions[part.sceneId] ?? -1) + 1,
+              patch
+            }));
+          } else if (part.type === "asset.patch") {
+            const scenes = state.config?.scenes ?? [];
+            const scene = scenes.find((item) => item.id === part.sceneId);
+            if (!scene) throw new Error(`Scene ${part.sceneId} does not exist`);
+            const nextScene = {
+              ...scene,
+              variables: { ...scene.variables, ...part.variables }
+            };
+            options.validateScene?.(nextScene, { input, previousScenes: scenes });
+            if (getReadableSceneDuration(
+              nextScene,
+              options.getTemplatePacing?.(nextScene.templateId)
+            ) > sceneSlotDuration(nextScene) + 1e-6) {
+              yield emit(events.create("response.warning", {
+                warning: createPatchReadabilityWarning(part.sceneId)
+              }));
+              continue;
+            }
+            yield emit(events.create("asset.patch", {
+              sceneId: part.sceneId,
+              revision: (state.sceneRevisions[part.sceneId] ?? -1) + 1,
+              variables: part.variables
+            }));
+          } else if (part.type === "plan.error") {
+            const internalError = new Error(part.error.message);
+            reportError(internalError);
+            const terminal = !(part.error.recoverable ?? false);
+            const errorEvent = emit(events.create("response.error", {
+              error: {
+                code: "generation_failed",
+                message: "Video response generation failed",
+                recoverable: part.error.recoverable ?? false
+              },
+              terminal,
+              ...terminal && state.config ? { snapshot: state.config } : {}
+            }));
+            if (terminal) {
+              finish(state);
+              yield errorEvent;
+              return;
+            }
+            yield errorEvent;
+          } else if (part.type === "plan.complete") {
+            if (planCompleted) throw new Error("The planner emitted plan.complete more than once");
+            if (!askAccepted && 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,
+                  revision: 0
+                }));
+                generatedSceneCount += 1;
+                acceptedSceneCount += 1;
+                timeToFirstSceneMs ??= Math.max(0, now() - startedAt);
+              }
+            }
+            planCompleted = true;
+            finishReason = runtimeDurationLimited ? "length" : part.finishReason ?? "stop";
+            plannerReportedLength = part.finishReason === "length";
+            continue;
+          }
+        } 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;
+          reportError(error);
+          if ((options.invalidPartBehavior ?? "fail") === "fail") throw error;
+          yield emit(events.create("response.error", {
+            error: {
+              code: "invalid_generated_part",
+              message: "Generated content was skipped",
+              recoverable: true
+            },
+            terminal: false
+          }));
+        }
+      }
+      if (controller.signal.aborted) {
+        throw controller.signal.reason ?? new Error(abortReason);
+      }
+      const provider = await settleProviderLifecycle();
+      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) {
+        throw new Error("The planner was truncated before adding a generated scene");
+      }
+      if (!state.config?.scenes.length) throw new Error("The planner completed without adding a scene");
+      const snapshot = parseVideo(state.config);
+      const completeEvent = emit(events.create("response.complete", {
+        finishReason,
+        snapshot,
+        checksum: checksumVideo(snapshot)
+      }));
+      finish(state);
+      const summary = {
+        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, now() - startedAt),
+        acceptedSceneCount,
+        rejectedSceneCount,
+        videoDurationSec: snapshot.scenes.at(-1)?.timing.endTime ?? 0,
+        warnings: state.warnings.map(cloneWarning)
+      };
+      invokeIsolated(options.onComplete, summary);
+      yield completeEvent;
+    } catch (cause) {
+      if (controller.signal.aborted) {
+        const abortEvent = emit(events.create("response.abort", {
+          reason: abortReason,
+          ...state.config ? { snapshot: state.config } : {}
+        }));
+        finish(state);
+        yield abortEvent;
+        return;
+      }
+      try {
+        const provider = await settleProviderLifecycle();
+        for (const warning of provider.warnings) {
+          if (!state.warnings.some((existing) => existing.code === warning.code && existing.message === warning.message)) {
+            yield emit(events.create("response.warning", { warning }));
+          }
+        }
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        reportError(error);
+        const emptyResult = error.message === "The planner completed without adding a scene";
+        const errorEvent = emit(events.create("response.error", {
+          error: {
+            code: "generation_failed",
+            message: emptyResult ? "No valid scenes were generated; inspect recoverable errors and warnings, then retry with a more capable model." : "Video response generation failed",
+            recoverable: false
+          },
+          terminal: true,
+          ...state.config ? { snapshot: state.config } : {}
+        }));
+        finish(state);
+        yield errorEvent;
+      } catch (terminalCause) {
+        if (!settled) {
+          settled = true;
+          rejectResult(terminalCause);
+        }
+        throw terminalCause;
+      }
+    } finally {
+      options.signal?.removeEventListener("abort", forwardAbort);
+    }
+  })();
+  const buffered = [];
+  const waiters = /* @__PURE__ */ new Set();
+  let streamDone = false;
+  let streamError;
+  const notify = () => {
+    for (const waiter of waiters) waiter();
+    waiters.clear();
+  };
+  void (async () => {
+    try {
+      for await (const event of eventSource) {
+        buffered.push(event);
+        notify();
+      }
+    } catch (cause) {
+      streamError = cause;
+      if (!settled) {
+        settled = true;
+        rejectResult(cause);
+      }
+    } finally {
+      streamDone = true;
+      notify();
+    }
+  })();
+  const stream = {
+    async *[Symbol.asyncIterator]() {
+      let index = 0;
+      while (true) {
+        while (index < buffered.length) yield buffered[index++];
+        if (streamDone) {
+          if (streamError) throw streamError;
+          return;
+        }
+        await new Promise((resolve) => waiters.add(resolve));
+      }
+    }
+  };
+  return {
+    request,
+    initialConfig,
+    initialStyle: initialConfig.style,
+    stream,
+    result,
+    abort(reason = "user cancelled") {
+      abortReason = safePublicDiagnostic(reason, "User cancelled");
+      controller.abort(new Error(reason));
+    }
+  };
+}
+
+export {
+  createVideo
+};