@vanillaskyai/video 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -4,6 +4,72 @@ VanillaSky follows semantic versioning. This changelog begins with the 0.1 beta.
 
 ## Unreleased
 
+## 0.8.0
+
+- The default chat silently recovers from optional failures. Non-fatal diagnostics remain available to applications without appearing in the viewer interface; actionable errors remain visible.
+
+- Adds `maxGeneratedVideos` (default five attempts per response), aligns AI-video planning with that budget, and keeps stock footage available beyond it. Failed searches can reuse matching completed footage once before falling back to a readable template.
+- Improves opening stock footage with documented Pexels video-host support and a planner-supplied broader atmospheric query. Video and photo searches share one three-second deadline; available descriptions screen obvious mismatches without an extra AI call.
+
+- Adds local, content-free playback observations for scene presentation, actual speech onset, and waits for the next scene. Measurements ignore stale callbacks and exclude deliberate pauses from stall duration.
+
+- Runs setup checks automatically after init and supports retrying interrupted
+  installation. The baseline needs one text-provider key, packaged templates,
+  and browser voice; optional speech and video packages install only through
+  `vanillasky providers add speech` or `vanillasky providers add video`.
+
+- Bounds optional video, stock, speech, and narration waits so stalled providers fall back without holding the whole answer. Completed responses no longer wait for follow-up suggestions.
+
+- Preserves playable video-chat openings and completed scenes when planning or
+  an optional provider fails. Malformed scene lines no longer discard later
+  valid scenes; generated footage can fall back to stock and safe templates.
+- Continues narration with scene text and browser voice when generated speech
+  fails, keeping non-fatal diagnostics available to applications without
+  showing recovery notices to viewers.
+- Keeps template rendering failures local to a scene, and lets stock searches
+  recover from failed lookups or malformed candidates.
+
+### Breaking changes
+
+The supported generation path is now video chat. Removes `useVideo`,
+`createVideoHandler`, `useNarration`, `createSceneTimeline`, their public types,
+and generic root input types. Chat handler options no longer expose standalone
+soundtrack selection, snapshot-retention overrides, or durable-stream replay.
+The old one-shot integration is no longer available:
+
+```tsx
+const video = useVideo({ endpoint: "/api/video" });
+await video.generate({ input: "Explain the Moon's orbit" });
+```
+
+### Adoption
+
+Use `npx @vanillaskyai/video init` for the complete app. Existing custom hosts
+mount `createVideoChatHandler` with `streamText` and `generateText`, then render
+the packaged chat:
+
+```tsx
+import { VideoChat } from "@vanillaskyai/video/react";
+import "@vanillaskyai/video/video-chat.css";
+
+export function App() {
+  return <VideoChat options={{ endpoint: "/api/video-chat" }} />;
+}
+```
+
+Use `useVideoChat` for a custom interface, `createVideoChatVoice` for a custom
+voice, and `parseVideo` plus `VideoPlayer` for saved completed responses. Pass
+custom registries to the chat handler and `VideoChat` options. Persist completed
+`chat.turns` video values instead of one-shot `generate()` results. Saved `Video`
+JSON, including existing soundtrack data, keeps its current storage contract.
+
+## 0.7.1
+
+- Keeps Full AI video responses running when a text provider repeats narration
+  beside a scene that already owns the canonical line. The redundant copy is
+  discarded before strict plan validation instead of aborting after the first
+  generated clip.
+
 ## 0.7.0
 
 - Makes blank-folder onboarding one safe scoped command:

package/PUBLIC-API.md

@@ -62,6 +62,9 @@ a request, renders React, imports a provider, or accesses browser globals.
 ### Values
 
 - `getVideoDuration(video: Video): number`
+- `getSceneDuration(scene, metadata)`
+- `getSceneDurationBounds(scene, metadata)`
+- `getSpokenDuration(text)`
 - `parseVideo(value: unknown): Video`
 - `resolveVideoBrand(input?: VideoBrandInput): VideoBrand`
 - `VideoValidationError`
@@ -72,17 +75,17 @@ a request, renders React, imports a provider, or accesses browser globals.
 - `VideoAudio`
 - `VideoBackground`
 - `VideoBrand`
-- `VideoInput`
+- `VideoBrandInput`
 - `VideoOrientation`
 - `VideoScene`
 - `VideoStyle`
 - `VideoStyleOptions`
-- `VideoSuppliedMedia`
 - `VideoStatus`
 - `VideoValidationErrorCode`
+- `SceneDurationBounds`
 
 `VideoState` remains internal protocol reducer state. Browser consumers use the
-normalized fields returned by `useVideo` instead.
+normalized fields returned by `useVideoChat` instead.
 
 ## Server
 
@@ -93,7 +96,6 @@ provider-neutral text-delta escape hatch.
 ### Values
 
 - `createVideoChatHandler(options)`
-- `createVideoHandler(options)`
 - `createServerTemplateRegistry(options)`
 
 ### Types
@@ -104,10 +106,6 @@ provider-neutral text-delta escape hatch.
 - `VideoChatMode`
 - `VideoChatWelcomeOptions`
 - `VideoChatWelcomePrompt`
-- `VideoHandlerOptions`
-- `MediaResolver`
-- `MediaResolverContext`
-- `ResolvedMedia`
 - `ServerTemplateRegistry`
 - `ServerTemplateMetadata`
 - `VideoFinishReason`
@@ -122,25 +120,36 @@ provider-neutral text-delta escape hatch.
 Mount it once and use its bounded `action` query parameter for capabilities,
 responses, opening media, narration, suggestions, speech,
 transcription, and the welcome screen. It owns the general response prompts,
-fixed visual-mode spend limits, capability fallbacks, and auxiliary response
+application-configured visual-mode attempt limits, capability fallbacks, and auxiliary response
 shapes. The application supplies provider-neutral `streamText`, `generateText`,
 `generateSpeech`, `transcribe`, `searchMedia`, and `generateVideo` callbacks.
 Only the two text callbacks are required. Missing optional callbacks remove
-their capability; templates and browser speech remain available.
+their capability; templates and browser speech remain available. During response
+creation, failed generated footage falls back to stock when available, then to
+matching completed footage and finally a safe template. The default handler skips invalid planner parts and preserves
+playable scenes on an interrupted plan, emitting non-fatal warnings. Explicit
+`invalidPartBehavior: "fail"` retains strict generation semantics.
 
 - A response accepts `prompt`, `mode`, `orientation`, optional bounded
   `conversation`, `opening`, `brand`, and `style`. `opening` is an optional
   prewritten hook from a selected suggestion. The response returns protocol
   `0.5` SSE and negotiates `data.video-chat-opening`, which carries the bounded
-  6-9 word hook and optional stock-search keyword before the first scene.
+  6-9 word hook and optional stock-search `keyword` and `fallbackKeyword` before the first scene.
 - The planner produces that opening as the first line of the same model stream
   that produces the scenes. The separate opening-media action resolves its
-  keyword through the application-owned `searchMedia` callback, so stock lookup
+  keyword through the application-owned `searchMedia` callback, with an optional
+  bounded `fallbackQuery` for broader opening atmosphere. Stock lookup
   never delays speech or planning. In `full` mode the first line also directs
   the exact first generated scene; the handler consumes that private direction
   and starts the clip while the model continues with scenes two through five.
-- `templates` and `full` map to server-owned generated-media budgets of zero
-  and five. Without `generateVideo`, only `templates` is exposed
+- `templates` never generates video. `full` uses an application-owned
+  `maxGeneratedVideos` limit (default five, nonnegative safe integer). The limit
+  counts attempts including failed attempts and the reserved first shot; it is
+  neither a currency nor duration cap. Stock lookup remains available after
+  the limit. With zero, full mode uses stock only. The planner receives this
+  budget, and the server enforces it independently. If providers fail, an
+  already completed video with the identical search query and visual look may
+  be reused once in the same response before a readable template fallback. Without `generateVideo`, only `templates` is exposed
   and forged generated-mode requests degrade to it.
 - The response planner writes narration on each scene. The narration action is
   retained as a compatibility fallback for missing lines, not used in the
@@ -148,37 +157,20 @@ their capability; templates and browser speech remain available.
 - Every action applies the same authorization, origin, request-size,
   cancellation, safe-error, and server-only-provider boundaries.
 
-`createVideoHandler` remains the lower-level video composition route:
-
-- `authorize` is required for HTTP handlers. Use `authorize: "none"` only for
-  an intentionally non-public in-process/test handler.
-- `streamText` receives the generated system prompt, grounded user prompt, and
-  the request `AbortSignal`.
-- `resolveMedia` is an optional application-owned resolver. It receives a
-  bounded semantic query only when configured, and returns an approved image
-  or video URL plus an optional poster before the scene is validated or sent
-  to the browser. Provider clients, keys, metadata, and unresolved queries
-  remain server-only.
-- `invalidPartBehavior` is `"drop" | "fail"`. A behavior selector is never
-  named like a callback.
-- `requireCloser` defaults to `true` on `createVideoHandler`. The planner marks
-  one `scene.add` with `placement: "closer"`; the runtime reserves it and emits
-  it last. Specialized deterministic or test handlers may opt out explicitly.
-- `onWarning` receives safe typed warnings.
-- `onComplete` receives one server-only `VideoGenerationSummary` after an
-  actual `response.complete`; errors and aborts do not invoke it.
-- `onError` receives the full internal server error. Client responses remain
-  redacted and typed separately.
-- Provider usage, raw usage, provider metadata, and model identifiers remain
-  server-side unless the host deliberately persists them.
-- Provider-native usage and metadata require the bounded
-  `includeRawProviderData` opt-in.
-- `snapshotRetention` opts into individually bounded source, instructions, or
-  supplied-media URL metadata; all are omitted by default.
-- Provider credentials, provider selection, authentication, rate limiting,
-  provider retries, logging, and tracing remain host-owned.
-- Request cancellation always reaches the provider through `AbortSignal`.
-- Callback failures are isolated and never alter the video response.
+The chat handler requires `authorize`; `authorize: "none"` is only for an
+intentionally non-public in-process/test handler. All provider callbacks receive
+cancellation signals. The application owns authentication, origins, request
+limits, provider credentials, deadlines, and retry budgets.
+
+`onWarning` receives safe typed diagnostics; `onComplete` receives a server-only
+`VideoGenerationSummary` after an actual `response.complete`, including recovered
+playable responses. `onError` receives private internal errors. Observer failures
+do not change playback. Provider metadata remains server-side, with raw usage
+and metadata requiring the bounded `includeRawProviderData` opt-in.
+
+The handler exposes chat-relevant policy, template, and provider options only.
+Standalone soundtrack selection, snapshot-retention overrides, and durable
+stream replay are not public chat options.
 
 ## React
 
@@ -187,7 +179,6 @@ their capability; templates and browser speech remain available.
 - `VideoChat(props)`
 - `useVideoChat(options?)`
 - `createVideoChatVoice(options?)`
-- `useVideo(options?)`
 - `VideoPlayer`
 - `VideoError`
 
@@ -208,8 +199,6 @@ their capability; templates and browser speech remain available.
 - `VideoChatVoice`
 - `VideoChatPreparedSpeech`
 - `CreateVideoChatVoiceOptions`
-- `UseVideoOptions`
-- `UseVideoResult`
 - `VideoPlaybackMode`
 - `VideoPlayerProps`
 - `VideoErrorOptions`
@@ -251,50 +240,42 @@ paces each scene to its prepared speech, and keeps pause, mute, replay, history,
 captions, and actual playback completion synchronized. The default voice tries
 the handler's generated-speech action and falls back to browser speech. Pass a
 `VideoChatVoice` to replace it without rebuilding session orchestration.
+`createVideoChatVoice({ onFallback })` optionally observes a generated-speech
+failure that selects browser speech. Observer exceptions and rejected promises
+are isolated from playback; no provider diagnostics are passed to this callback.
+
+`chat.warnings` exposes concise notices for the displayed turn, also retained
+as optional `VideoChatTurn.warnings`. The default interface recovers silently; these diagnostics are
+for application developers and are not rendered to viewers. Optional scene, narration, speech, or stream failures preserve
+playable output; an error is shown only when no playable response remains.
 `ask(prompt, { opening, openingMedia })` lets a custom interface start a
 prewritten suggestion hook immediately and reuse its image or video without
 another model or media lookup. The hook otherwise reads the opening from the
 response stream, resolves its media keyword, holds that media while it is
 spoken, and starts the planned timeline only when both speech and the first
 scene are ready. `UseVideoChatOptions.onFirstFrame` receives a
-`VideoChatFirstFrameMetric` once when a fresh response displays its first real
-scene. Each `VideoChatTurn` exposes `openingMedia` and `completed`, so
+`VideoChatFirstFrameMetric` once after its first active scene commits and reaches
+an animation-frame opportunity. This measures presentation readiness, not physical
+screen paint or media decoding. Each `VideoChatTurn` exposes `openingMedia` and `completed`, so
 custom interfaces can render the same handoff while partial or cancelled
 responses remain visible without being mistaken for conversation context.
 
-`UseVideoResult` has this conceptual shape:
-
-```ts
-interface UseVideoResult {
-  generate(input: VideoInput): Promise<Video>;
-  abort(reason?: string): void;
-  video?: Video;
-  status: VideoStatus;
-  error?: VideoError;
-  warnings: readonly VideoWarning[];
-  playerProps: VideoPlayerProps;
-}
-```
-
 `VideoPlayer` accepts either streaming player props or a completed saved video:
 
 ```tsx
-<VideoPlayer {...video.playerProps} />
+<VideoPlayer {...chat.playerProps} />
 <VideoPlayer video={savedVideo} />
 ```
 
 Built-in renderers are always available, so a streaming `VideoPlayer` does not
 require a template registry. `playerProps` is a spread-ready player binding; it
-contains the customer registry supplied to `useVideo` when one exists, but it
+contains the customer registry supplied to `useVideoChat` when one exists, but it
 does not expose the built-in planning catalog. Import `builtinTemplates` from
 `@vanillaskyai/video/templates/catalog` for labels, schemas, selection guidance,
 and other React-free metadata.
 
-Set `playbackMode="autoplay-after-interaction"` for chat feeds: the first
-soundtrack waits on a visible scene-one poster, and later streams on the same
-mounted player autoplay with sound after the first successful viewer start.
-`manual`, `muted-autoplay`, and `autoplay-with-sound` cover the other browser
-startup policies.
+The chat owns playback startup, speech, and synchronization. Custom saved-video
+players may choose a `VideoPlaybackMode` to match browser autoplay rules.
 
 Set `nativeMediaAudio={{ volume: 0.85 }}` when scene video files contain an
 embedded audio track. The active clip's audio becomes a second layer alongside
@@ -302,10 +283,6 @@ the video's continuous `audio` soundtrack. Both follow the player's master
 mute control; `nativeMediaAudio.volume` and serialized `audio.volume` set their
 independent mix levels. Incoming preroll videos remain muted until active.
 
-`VideoInput.opening` accepts custom copy, uses the deterministic fallback when
-omitted, and accepts `false` when the application owns transient loading UI and
-wants the completed video to begin with the first generated scene.
-
 Saved-video playback performs no generation request. `VideoPlayerBinding` and
 the internal reducer state are not public types.
 
@@ -430,9 +407,8 @@ from `/server` without crossing a React type boundary.
   fail before any renderer runs; they are never rendered partially.
 - Raw prompts, provider payloads, and credentials are never retained by
   default.
-- Raw source, instructions, and the supplied-media URL index are opt-in and
-  bounded. Hosts own the database, storage, tenant policy, deletion, and media
-  URL expiry.
+- Chat snapshots omit raw source, instructions, and the supplied-media URL
+  index. Hosts own storage, tenant policy, deletion, and media URL expiry.
 - Replay through `<VideoPlayer video={savedVideo} />` never calls an LLM.
 - Completion checksums detect accidental drift only; they do not provide
   authenticity, authorization, or tenancy security.
@@ -444,5 +420,33 @@ from `/server` without crossing a React type boundary.
 - Hosted persistence.
 - OpenTelemetry integration.
 - Automatic factual verification or scene repair.
-- `useVideo(initialVideo)`.
+- Standalone video generation hooks, handlers, narration, and timeline factories.
 - Undocumented API aliases.
+
+
+## Playback measurements
+
+`UseVideoChatOptions.onPlaybackMetric` receives the exported
+`VideoChatPlaybackMetric` union. Every event contains an opaque `turnId`, `mode`,
+and nonnegative `elapsedMs` since the prompt was submitted:
+
+- `first-frame`: first committed active scene at an animation-frame opportunity;
+- `first-speech`: actual speech playback onset, with `source` equal to `browser`,
+  `generated`, or `custom`;
+- `stall`: a finished wait for the next prepared scene, with `durationMs` and
+  `reason: "scene-generation"`.
+
+Metrics contain no prompt, narration, scene, URL, or provider diagnostics. There
+is no automatic network reporting. Use opaque identifiers when supplying
+`createTurnId`. Observer throws and rejected promises cannot affect playback.
+Replay and stale/cancelled callbacks do not create fresh response measurements.
+Pauses end a stall interval; paused time is excluded from stall duration.
+
+Custom `VideoChatVoice.speak` implementations can call their optional
+`onStart()` argument when audio actually begins. Without that signal, speech
+onset is unavailable, not zero. Built-in voices use browser utterance `start`
+and audio `playing` events, not request completion or preparation estimates.
+
+`VideoPlayerProps.onFramePresented` and `onStallChange` expose the underlying
+presentation and stream-starvation signals for custom players. They do not
+measure media-decoder buffering. See [Performance](docs/performance.md).

package/README.md

@@ -17,7 +17,8 @@ trusted templates, validation, streaming, voice timing, and player.
 npx @vanillaskyai/video init
 ```
 
-Add `ANTHROPIC_API_KEY` to the generated, ignored `.env.local`, then run:
+Init installs the baseline dependencies and runs doctor automatically. Add
+`ANTHROPIC_API_KEY` to the generated, ignored `.env.local`, then run:
 
 ```bash
 npx vanillasky doctor
@@ -25,20 +26,21 @@ npm run dev
 ```
 
 Open the reported localhost URL. One text key gives you the complete chat with
-packaged templates and browser voice. No template setup is required.
+packaged templates and browser voice. No template setup or optional provider
+packages are required. If installation is interrupted, rerun the init command.
 
-Optional server-only keys progressively add capabilities without changing the
-client:
+Optional upgrades keep the same client:
 
-| Key | Adds |
-| --- | --- |
-| `XAI_API_KEY` | Generated speech |
-| `FAL_KEY` | Generated video and voice transcription |
-| `PEXELS_API_KEY` | Stock media, including opening backgrounds |
+| Add | Setup command | Server-only key |
+| --- | --- | --- |
+| Generated speech | `npx vanillasky providers add speech` | `XAI_API_KEY` |
+| Generated video and voice transcription | `npx vanillasky providers add video` | `FAL_KEY` |
+| Stock media, including opening backgrounds | No install needed | `PEXELS_API_KEY` |
 
-`npx vanillasky doctor` reports readiness by key name and never prints values.
-Provider SDKs remain dependencies of the generated application, not the core
-package.
+Run the selected command, add its key to `.env.local`, and restart the server.
+Only selected provider packages are installed. `npx vanillasky doctor` reports
+readiness by key name and never prints values. Provider SDKs remain application
+dependencies, outside the core package.
 
 For coding agents:
 
@@ -104,9 +106,8 @@ MP4/WebM export remains application-owned.
 | Change or add providers | [Provider integration](docs/provider-integration.md) |
 | Customize the interface | [Customization](docs/customization.md) |
 | Understand prompts and grounding | [Prompt and input](docs/prompt-and-input.md) |
-| Add brand or viewer context | [Branding and personalization](docs/branding-and-personalization.md) |
-| Add media or soundtrack audio | [Media and soundtrack audio](docs/media-and-audio.md) |
-| Persist and replay results | [Persistence and replay](docs/persistence.md) |
+| Add media or voice | [Media and voice](docs/media-and-audio.md) |
+| Persist and replay results | [Performance measurements](docs/performance.md) · [Persistence and replay](docs/persistence.md) |
 | Test routes and streams | [Test integrations](docs/testing.md) |
 | Deploy securely | [Production](docs/production.md) · [Security](docs/security.md) |
 | Inspect the API contract | [Public API](PUBLIC-API.md) · [Protocol](docs/reference/protocol.md) |

package/dist/{builtin-server-KB7FKF6A.js → builtin-server-CUYPIDE7.js}

@@ -1,7 +1,7 @@
 import {
   BUILTIN_SERVER_TEMPLATE_KIT
-} from "./chunk-RGF452LL.js";
-import "./chunk-JNN3EYVP.js";
+} from "./chunk-OWBT45EN.js";
+import "./chunk-4UNKZEAT.js";
 import "./chunk-2E6T633S.js";
 export {
   BUILTIN_SERVER_TEMPLATE_KIT

package/dist/check-runtime.js

@@ -1,6 +1,6 @@
 import {
   VideoFrame
-} from "./chunk-K746NUIP.js";
+} from "./chunk-2USVB3CY.js";
 import "./chunk-224QNWRA.js";
 import "./chunk-5CDAM24P.js";
 import "./chunk-XWWLKRNU.js";

package/dist/{chunk-2PYO6VAC.js → chunk-2DOLF4QN.js}

@@ -1,5 +1,4 @@
 import {
-  VIDEO_PROTOCOL_VERSION,
   VIDEO_SCHEMA_VERSION
 } from "./chunk-AOWSXU2K.js";
 import {
@@ -501,52 +500,11 @@ function parseVideo(value) {
   }
 }
 
-// src/protocol/stable-json.ts
-function stableJson(value) {
-  if (value == null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  const entries = Object.entries(value).filter(([, child]) => child !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
-}
-
-// src/protocol/checksum.ts
-function checksumVideo(config) {
-  const input = stableJson(config);
-  let hash = 2166136261;
-  for (let index = 0; index < input.length; index += 1) {
-    hash ^= input.charCodeAt(index);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return `fnv1a32:${hash.toString(16).padStart(8, "0")}`;
-}
-
-// 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
-      };
-    }
-  };
-}
-
 export {
   MAX_RETAINED_SOURCE_LENGTH,
   MAX_RETAINED_INSTRUCTIONS_LENGTH,
   MAX_RETAINED_MEDIA_URLS,
   MAX_RETAINED_MEDIA_URL_LENGTH,
   VideoValidationError,
-  parseVideo,
-  stableJson,
-  checksumVideo,
-  createVideoEventFactory
+  parseVideo
 };

package/dist/{chunk-GAIOHGNR.js → chunk-2OKB27TG.js}

@@ -2,13 +2,48 @@ import {
   parseVideoEvent
 } from "./chunk-MMUXVA47.js";
 import {
-  checksumVideo,
-  stableJson
-} from "./chunk-2PYO6VAC.js";
-import {
+  VIDEO_PROTOCOL_VERSION,
   VIDEO_SCHEMA_VERSION
 } from "./chunk-AOWSXU2K.js";
 
+// src/protocol/stable-json.ts
+function stableJson(value) {
+  if (value == null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, child]) => child !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
+}
+
+// src/protocol/checksum.ts
+function checksumVideo(config) {
+  const input = stableJson(config);
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return `fnv1a32:${hash.toString(16).padStart(8, "0")}`;
+}
+
+// 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/protocol/state.ts
 function createVideoState() {
   return {
@@ -133,47 +168,9 @@ function applyVideoEvent(state, untrustedEvent) {
   throw new Error(`Reducer does not yet support ${event.type}`);
 }
 
-// src/replayable-stream.ts
-function createReplayableStream(source, onError) {
-  const buffered = [];
-  const waiters = /* @__PURE__ */ new Set();
-  let done = false;
-  let streamError;
-  const notify = () => {
-    for (const waiter of waiters) waiter();
-    waiters.clear();
-  };
-  void (async () => {
-    try {
-      for await (const item of source) {
-        buffered.push(item);
-        notify();
-      }
-    } catch (cause) {
-      streamError = cause;
-      onError(cause);
-    } finally {
-      done = true;
-      notify();
-    }
-  })();
-  return {
-    async *[Symbol.asyncIterator]() {
-      let index = 0;
-      while (true) {
-        while (index < buffered.length) yield buffered[index++];
-        if (done) {
-          if (streamError) throw streamError;
-          return;
-        }
-        await new Promise((resolve) => waiters.add(resolve));
-      }
-    }
-  };
-}
-
 export {
+  checksumVideo,
+  createVideoEventFactory,
   createVideoState,
-  applyVideoEvent,
-  createReplayableStream
+  applyVideoEvent
 };