@vanillaskyai/video 0.4.1 → 0.5.1

package/dist/server.d.ts

@@ -1,6 +1,6 @@
-import { n as VideoGenerationContext, o as VideoPlanner, p as VideoRequest, a as VideoCapabilities, j as VideoInput, d as VideoAudio, q as VideoSceneValidator, r as VideoTemplatePacing, s as VideoSnapshotRetention, t as VideoResumeCursor, u as VideoSceneValidationContext, e as VideoScene } from './types-Cg0Onj7l.js';
-import { b as VideoFinishReason, a as VideoWarning, V as VideoEvent } from './events-D_1F6gw5.js';
-export { c as VideoWarningCategory } from './events-D_1F6gw5.js';
+import { n as VideoGenerationContext, o as VideoPlanner, p as VideoRequest, a as VideoCapabilities, j as VideoInput, d as VideoAudio, q as VideoSceneValidator, r as VideoTemplatePacing, s as VideoSnapshotRetention, t as VideoResumeCursor, u as VideoSceneValidationContext, e as VideoScene } from './types-BV9IqExh.js';
+import { a as VideoFinishReason, V as VideoWarning, b as VideoEvent } from './events-BBP30j3c.js';
+export { c as VideoWarningCategory } from './events-BBP30j3c.js';
 import { S as SceneTemplateMetadata } from './catalog-types-BIhSpOWK.js';
 
 interface VideoProviderUsage {

package/dist/server.js

@@ -1,41 +1,46 @@
 import {
   createTextDeltaVideoPlanner
-} from "./chunk-BKF3A357.js";
+} from "./chunk-34O5BY6X.js";
 import {
   createVideo
-} from "./chunk-LHFADNWJ.js";
+} from "./chunk-3ROGEU5A.js";
 import "./chunk-E7CL7UPB.js";
 import {
   BUILTIN_SERVER_TEMPLATE_KIT,
   createServerTemplateRegistry,
   overlayServerTemplateRegistry
-} from "./chunk-I5YWVQ5R.js";
+} from "./chunk-FVTMYS6U.js";
 import {
   createTemplateSceneValidator
 } from "./chunk-LMG3GHLL.js";
 import {
   encodeVideoSseEvent,
   videoSseHeaders
-} from "./chunk-S5ZU5WUU.js";
-import "./chunk-STIFILQG.js";
+} from "./chunk-ZQQQAAKP.js";
+import "./chunk-FZHMQFG3.js";
 import {
+  allowedKeys,
+  jsonValue,
+  nonNegativeInteger,
   parseVideoEvent,
-  safePublicDiagnostic
-} from "./chunk-JW47XCRL.js";
+  record,
+  safePublicDiagnostic,
+  string
+} from "./chunk-G66Z5CWR.js";
 import {
   MAX_RETAINED_MEDIA_URL_LENGTH
-} from "./chunk-GHJEAP4O.js";
+} from "./chunk-66MNRUCR.js";
 import {
   VIDEO_PROTOCOL_VERSION
-} from "./chunk-EE6PK6XC.js";
+} from "./chunk-AOWSXU2K.js";
 import {
   createTemplateSystemPrompt,
   getStandardMediaResolverContract
-} from "./chunk-GR4I3MN2.js";
-import "./chunk-WHPZED7X.js";
+} from "./chunk-EFL34TXF.js";
+import "./chunk-PNS52FL4.js";
 import "./chunk-3O7OMMMF.js";
+import "./chunk-3RV4YKB3.js";
 import "./chunk-352ZZCET.js";
-import "./chunk-XAMUOSX7.js";
 import "./chunk-2E6T633S.js";
 import {
   validateBrandInput
@@ -43,23 +48,6 @@ import {
 import "./chunk-73NTSFFI.js";
 
 // src/server/request-validation.ts
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function record(value, path) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${path} must be an object`);
-  }
-  return value;
-}
-function allowedKeys(value, allowed, path) {
-  const permitted = new Set(allowed);
-  for (const key of Object.keys(value)) {
-    if (!permitted.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
-  }
-}
-function string(value, path) {
-  if (typeof value !== "string" || !value.trim()) throw new Error(`${path} must be a non-empty string`);
-  return value;
-}
 function boundedString(value, path) {
   const result = string(value, path);
   if (result.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
@@ -67,12 +55,6 @@ function boundedString(value, path) {
   }
   return result;
 }
-function nonNegativeInteger(value, path) {
-  if (!Number.isInteger(value) || Number(value) < 0) {
-    throw new Error(`${path} must be a non-negative integer`);
-  }
-  return Number(value);
-}
 function numberBetween(value, minimum, maximum, path) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
     throw new Error(`${path} must be a number between ${minimum} and ${maximum}`);
@@ -85,24 +67,6 @@ function enumValue(value, allowed, description, path) {
   }
   return value;
 }
-function jsonValue(value, path, seen = /* @__PURE__ */ new Set()) {
-  if (value == null || typeof value === "string" || typeof value === "boolean") return;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new Error(`${path} must be finite`);
-    return;
-  }
-  if (typeof value !== "object" || seen.has(value)) throw new Error(`${path} must be JSON-serializable`);
-  seen.add(value);
-  if (Array.isArray(value)) {
-    value.forEach((item, index) => jsonValue(item, `${path}[${index}]`, seen));
-  } else {
-    for (const [key, child] of Object.entries(value)) {
-      if (DANGEROUS_KEYS.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
-      jsonValue(child, `${path}.${key}`, seen);
-    }
-  }
-  seen.delete(value);
-}
 function capabilities(value, path) {
   const result = record(value, path);
   allowedKeys(result, ["templates", "extensions"], path);
@@ -553,12 +517,6 @@ function sanitizeUnknownTemplatePart(part) {
   if (part.type === "scene.add") {
     return { ...part, scene: { ...part.scene, variables: withoutKeyword(part.scene.variables) } };
   }
-  if (part.type === "scene.patch" && part.patch.variables) {
-    return { ...part, patch: { ...part.patch, variables: withoutKeyword(part.patch.variables) } };
-  }
-  if (part.type === "asset.patch") {
-    return { ...part, variables: withoutKeyword(part.variables) };
-  }
   return part;
 }
 async function resolvePartVariables(options) {
@@ -579,33 +537,14 @@ async function resolvePartVariables(options) {
     });
     return { ...options.part, scene: { ...options.part.scene, variables } };
   }
-  if (options.part.type === "scene.patch" && options.part.patch.variables) {
-    const variables = await resolveVariables({
-      ...shared,
-      variables: options.part.patch.variables
-    });
-    return { ...options.part, patch: { ...options.part.patch, variables } };
-  }
-  if (options.part.type === "asset.patch") {
-    const variables = await resolveVariables({
-      ...shared,
-      variables: options.part.variables
-    });
-    return { ...options.part, variables };
-  }
   return options.part;
 }
 function createMediaResolvingPlanner(options) {
   return async function* resolveMediaPlan(context) {
-    const sceneTemplates = /* @__PURE__ */ new Map();
     for await (const part of options.planner(context)) {
-      const templateId = part.type === "scene.add" ? part.scene.templateId : part.type === "scene.patch" || part.type === "asset.patch" ? sceneTemplates.get(part.sceneId) : void 0;
-      if (part.type === "scene.add") {
-        sceneTemplates.set(part.scene.id, part.scene.templateId);
-      }
       yield await resolvePartVariables({
         part,
-        templateId,
+        templateId: part.type === "scene.add" ? part.scene.templateId : void 0,
         input: context.request.input,
         signal: context.signal,
         templates: options.templates,

package/dist/{system-prompt-NMYHLAMJ.js → system-prompt-4I6Z5HK3.js}

@@ -2,7 +2,7 @@ import {
   DEFAULT_VIDEO_SYSTEM_PROMPT,
   VIDEO_PLAN_INSTRUCTION,
   createVideoSystemPrompt
-} from "./chunk-WHPZED7X.js";
+} from "./chunk-PNS52FL4.js";
 export {
   DEFAULT_VIDEO_SYSTEM_PROMPT,
   VIDEO_PLAN_INSTRUCTION,

package/dist/template-catalog.js

@@ -1,6 +1,6 @@
 import {
   BUILTIN_TEMPLATE_MANIFEST
-} from "./chunk-RBQN3VSY.js";
+} from "./chunk-HVCPEAQF.js";
 export {
   BUILTIN_TEMPLATE_MANIFEST as builtinTemplates
 };

package/dist/templates.d.ts

@@ -1,9 +1,9 @@
-import { I as InferTemplateJsonSchema, S as SceneTemplateProps, a as SceneTemplate } from './kit-DLeCr3d0.js';
-export { T as TemplateRegistry, c as createTemplateRegistry } from './kit-DLeCr3d0.js';
+import { I as InferTemplateJsonSchema, S as SceneTemplateProps, a as SceneTemplate } from './kit-DEG3fcaL.js';
+export { T as TemplateRegistry, c as createTemplateRegistry } from './kit-DEG3fcaL.js';
 import { ComponentType } from 'react';
 import { d as TemplateJsonSchema, S as SceneTemplateMetadata } from './catalog-types-BIhSpOWK.js';
 export { T as TemplateFamily, c as TemplateTimingMetadata, e as TemplateTransitionTiming } from './catalog-types-BIhSpOWK.js';
-import './types-Cg0Onj7l.js';
+import './types-BV9IqExh.js';
 
 interface TemplateExample<Variables extends Record<string, unknown> = Record<string, unknown>> {
     name: string;

package/dist/templates.js

@@ -1,8 +1,91 @@
 import {
-  createTemplateRegistry,
-  defineTemplate
-} from "./chunk-CR7FE7BW.js";
-import "./chunk-2E6T633S.js";
+  assertTemplateTransitionMetadata
+} from "./chunk-2E6T633S.js";
+
+// src/visual-system/catalog/kit.ts
+function toMetadata(template) {
+  return {
+    id: template.id,
+    label: template.label,
+    description: template.description,
+    category: template.category,
+    family: template.family,
+    usesGlobalTextEffect: template.usesGlobalTextEffect,
+    usesGlobalTransition: template.usesGlobalTransition,
+    transitionTiming: template.transitionTiming,
+    usesGlobalBackgroundEffect: template.usesGlobalBackgroundEffect,
+    textCanvas: template.textCanvas,
+    jobs: template.jobs,
+    register: template.register,
+    useWhen: template.useWhen,
+    avoidWhen: template.avoidWhen,
+    schema: template.schema,
+    minDuration: template.minDuration,
+    preferredDuration: template.preferredDuration,
+    timing: template.timing
+  };
+}
+function isTemplateJsonSchema(value) {
+  if (typeof value !== "object" || value == null) return false;
+  const schema = value;
+  return schema.type === "object" && typeof schema.properties === "object" && schema.properties != null;
+}
+function defineTemplate(definition) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(definition.id)) {
+    throw new Error(`Invalid template id: ${definition.id}`);
+  }
+  const suppliedSchema = "schema" in definition ? definition.schema : void 0;
+  const standard = suppliedSchema && "~standard" in suppliedSchema ? suppliedSchema["~standard"] : void 0;
+  const convertedSchema = standard?.jsonSchema ? standard.jsonSchema.input({ target: "draft-07" }) : suppliedSchema && !("~standard" in suppliedSchema) ? suppliedSchema : void 0;
+  if (standard && !standard.jsonSchema) {
+    throw new Error("Template schemas must expose Standard JSON Schema so the server registry can be generated safely");
+  }
+  if (!convertedSchema || !isTemplateJsonSchema(convertedSchema)) {
+    throw new Error("Template schema must describe a JSON object");
+  }
+  const schema = { ...convertedSchema, additionalProperties: convertedSchema.additionalProperties ?? false };
+  const transitionMetadata = {
+    id: definition.id,
+    usesGlobalTransition: definition.usesGlobalTransition ?? false,
+    transitionTiming: definition.transitionTiming
+  };
+  assertTemplateTransitionMetadata(transitionMetadata);
+  const { schema: _runtimeSchema, duration, ...definitionWithoutSchema } = definition;
+  return Object.freeze({
+    label: definition.id,
+    description: "",
+    usesGlobalTextEffect: false,
+    usesGlobalTransition: false,
+    usesGlobalBackgroundEffect: false,
+    ...definitionWithoutSchema,
+    schema,
+    ...duration == null ? {} : { preferredDuration: duration }
+  });
+}
+function createRenderTemplateRegistry(options) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const template of options.templates) {
+    assertTemplateTransitionMetadata(template);
+    if (byId.has(template.id)) throw new Error(`Duplicate template id: ${template.id}`);
+    byId.set(template.id, template);
+  }
+  const templates = Object.freeze([...options.templates]);
+  if (options.metadata && options.metadata.map(({ id }) => id).join("\0") !== templates.map(({ id }) => id).join("\0")) {
+    throw new Error("Template metadata does not match render templates");
+  }
+  const metadata = new Map((options.metadata ?? templates.map(toMetadata)).map((template) => [template.id, template]));
+  const capabilities = { templates: templates.map(({ id }) => id) };
+  return Object.freeze({
+    templates,
+    capabilities,
+    getTemplate: (id) => byId.get(id),
+    getTemplateMetadata: (id) => metadata.get(id),
+    listTemplateMetadata: () => [...metadata.values()]
+  });
+}
+function createTemplateRegistry(options) {
+  return createRenderTemplateRegistry({ templates: options.definitions });
+}
 
 // src/templates.ts
 function defineTemplate2(definition) {

package/dist/test.d.ts

@@ -1,28 +1,13 @@
-import { e as VideoScene, b as VideoOrientation, V as VideoStyle, c as Video, d as VideoAudio, j as VideoInput } from './types-Cg0Onj7l.js';
-import { a as VideoWarning, b as VideoFinishReason } from './events-D_1F6gw5.js';
+import { e as VideoScene, b as VideoOrientation, V as VideoStyle, c as Video, d as VideoAudio, j as VideoInput } from './types-BV9IqExh.js';
+import { V as VideoWarning, a as VideoFinishReason } from './events-BBP30j3c.js';
 
 type MockVideoStreamPart = {
     type: "scene.add";
     placement?: "closer";
     scene: VideoScene;
-} | {
-    type: "scene.patch";
-    sceneId: string;
-    patch: Partial<Omit<VideoScene, "id" | "templateId">>;
-} | {
-    type: "asset.patch";
-    sceneId: string;
-    variables: Record<string, unknown>;
 } | {
     type: "plan.complete";
     finishReason?: "stop" | "length" | "content-filter" | "other";
-} | {
-    type: "plan.error";
-    error: {
-        message: string;
-        code?: string;
-        recoverable?: boolean;
-    };
 } | {
     type: "mock.delay";
     durationMs: number;
@@ -50,7 +35,7 @@ interface MockProviderTextStream {
     finishReason: Promise<"stop" | "length" | "content-filter">;
 }
 type SimulatedEventEnvelope<TType extends string, TData> = {
-    protocolVersion: "0.4";
+    protocolVersion: "0.5";
     runId: string;
     sequence: number;
     eventId: string;
@@ -73,15 +58,6 @@ type SimulatedVideoEvent = SimulatedEventEnvelope<"response.start", {
 }> | SimulatedEventEnvelope<"scene.add", {
     scene: VideoScene;
     position: number;
-    revision: number;
-}> | SimulatedEventEnvelope<"scene.patch", {
-    sceneId: string;
-    revision: number;
-    patch: Partial<Omit<VideoScene, "id" | "templateId">>;
-}> | SimulatedEventEnvelope<"asset.patch", {
-    sceneId: string;
-    revision: number;
-    variables: Record<string, unknown>;
 }> | SimulatedEventEnvelope<"response.warning", {
     warning: VideoWarning;
 }> | SimulatedEventEnvelope<"response.complete", {

package/dist/test.js

@@ -233,9 +233,9 @@ 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-6UQ33DOO.js");
-  const { createTextDeltaVideoPlanner } = await import("./text-stream-UPGUD2TD.js");
-  const { BUILTIN_SERVER_TEMPLATE_KIT } = await import("./builtin-server-BRTZN4Q7.js");
+  const { createVideo } = await import("./compose-video-QJHKTOQ7.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");
   const controller = new AbortController();
   const forwardAbort = () => controller.abort(options.signal?.reason);

package/dist/{text-stream-UPGUD2TD.js → text-stream-J6EDDJP4.js}

@@ -1,9 +1,9 @@
 import {
   createTextDeltaVideoPlanner
-} from "./chunk-BKF3A357.js";
+} from "./chunk-34O5BY6X.js";
 import "./chunk-E7CL7UPB.js";
-import "./chunk-JW47XCRL.js";
-import "./chunk-EE6PK6XC.js";
+import "./chunk-G66Z5CWR.js";
+import "./chunk-AOWSXU2K.js";
 import "./chunk-XGRA2MUV.js";
 export {
   createTextDeltaVideoPlanner

package/dist/{types-Cg0Onj7l.d.ts → types-BV9IqExh.d.ts}

@@ -1,4 +1,4 @@
-declare const VIDEO_PROTOCOL_VERSION: "0.4";
+declare const VIDEO_PROTOCOL_VERSION: "0.5";
 declare const VIDEO_SCHEMA_VERSION: "0.1";
 type VideoOrientation = "portrait" | "landscape";
 type VideoKnowledgeMode = "input-only" | "general";
@@ -164,24 +164,9 @@ type VideoPlanPart = {
     type: "scene.add";
     placement?: "closer";
     scene: VideoScene;
-} | {
-    type: "scene.patch";
-    sceneId: string;
-    patch: Partial<Omit<VideoScene, "id" | "templateId">>;
-} | {
-    type: "asset.patch";
-    sceneId: string;
-    variables: Record<string, unknown>;
 } | {
     type: "plan.complete";
     finishReason?: "stop" | "length" | "content-filter" | "other";
-} | {
-    type: "plan.error";
-    error: {
-        message: string;
-        code?: string;
-        recoverable?: boolean;
-    };
 };
 type VideoPlanner = (context: VideoGenerationContext) => AsyncIterable<VideoPlanPart>;
 interface VideoSceneValidationContext {

package/docs/agent-integration.md

@@ -11,9 +11,10 @@ npx skills add VanillaSkyAi/video@vanillasky
 
 ## Build the first response
 
-1. Install `@vanillaskyai/video`, `ai`, and one model provider.
-2. Put the provider key in an ignored `.env.local` file.
-3. Connect the application's LLM with `createVideoHandler` in an authenticated
+1. Install `@vanillaskyai/video`.
+2. Choose and configure a current model separately; put its provider key in an
+   ignored `.env.local` file.
+3. Connect that app-owned model with `createVideoHandler` in an authenticated
    server route.
 4. Pass grounded text or structured data as `input`.
 5. Call `useVideo()` and render `VideoPlayer` in React.

package/docs/concepts.md

@@ -50,12 +50,12 @@ The planner cannot legitimately select a template outside the active kit.
 
 ## Planner
 
-The server-side planner turns the input into small plan parts such as
-`scene.add`, `scene.patch`, `asset.patch`, and `plan.complete`. A planner may be
+The server-side planner turns the input into complete `scene.add` parts followed
+by `plan.complete`. A planner may be
 recorded, deterministic, backed by OpenAI or Anthropic, or implemented with
 another streaming text model.
 
-The planner does not create public event IDs, checksums, revisions, or final
+The planner does not create public event IDs, checksums, or final
 snapshots. The runtime owns those guarantees.
 
 `createVideoHandler` asks the planner to emit one early
@@ -113,5 +113,5 @@ complete storage contract.
 checksum. Persist the snapshot when you need replay, resume, export, analytics,
 or an editing handoff. The event log can also be persisted and revalidated.
 
-Read the complete [Protocol 0.4](reference/protocol.md) and the separate
+Read the complete [Protocol 0.5](reference/protocol.md) and the separate
 [persisted Video 0.1 contract](persistence.md).

package/docs/custom-templates.md

@@ -213,9 +213,9 @@ selection, and validator. Import it in the route that connects your model:
 
 ```ts
 // src/video-route.ts
-import { openai } from "@ai-sdk/openai";
 import { streamText } from "ai";
 import { createVideoHandler } from "@vanillaskyai/video/server";
+import { videoModel } from "./video-model";
 import { templates } from "../vanillasky/server";
 
 export const handleVideo = createVideoHandler({
@@ -226,7 +226,7 @@ export const handleVideo = createVideoHandler({
     return hostname === "localhost" || hostname === "127.0.0.1";
   },
   streamText: ({ systemPrompt, userPrompt, signal }) => streamText({
-    model: openai(process.env.OPENAI_MODEL ?? "gpt-4.1"),
+    model: videoModel,
     system: systemPrompt,
     prompt: userPrompt,
     abortSignal: signal,

package/docs/getting-started.md

@@ -5,26 +5,22 @@
 Install VanillaSky:
 
 ```bash
-npm install @vanillaskyai/video@0.4.1 ai @ai-sdk/openai
+npm install @vanillaskyai/video
 ```
 
-Set your provider key in `.env.local` (never commit it):
+VanillaSky does not select a provider or model during installation. Configure
+that separately on the server. The route below assumes your application exports
+an AI SDK `LanguageModel` as `videoModel`; if it does not, follow
+[Provider integration](provider-integration.md) first.
 
-```bash
-OPENAI_API_KEY=your-key
-OPENAI_MODEL=gpt-4.1
-```
-
-Create one authenticated server route with `createVideoHandler`. Connect your
-provider through `streamText`; keep the model, credentials, authentication, rate
+Create one authenticated server route with `createVideoHandler`. Connect the
+app-owned model through `streamText`; keep credentials, authentication, rate
 limits, and media policy on the server:
 
 ```ts
-import { openai } from "@ai-sdk/openai";
 import { streamText } from "ai";
 import { createVideoHandler } from "@vanillaskyai/video/server";
-
-const model = openai(process.env.OPENAI_MODEL ?? "gpt-4.1");
+import { videoModel } from "@/lib/video-model";
 
 const handle = createVideoHandler({
   // Local development only. Replace with your session check before deploying.
@@ -34,7 +30,7 @@ const handle = createVideoHandler({
     return hostname === "localhost" || hostname === "127.0.0.1";
   },
   streamText: ({ systemPrompt, userPrompt, signal }) => streamText({
-    model,
+    model: videoModel,
     system: systemPrompt,
     prompt: userPrompt,
     abortSignal: signal,
@@ -49,12 +45,11 @@ The local bypass is intentionally fail-closed: the packaged development command
 sets its marker only for `next dev`, and it accepts only localhost. Every
 production request is denied. Replace it with your real session validation
 before deploying. For literal files and commands,
-use the tested
-[`examples/nextjs-quickstart` directory](https://github.com/VanillaSkyAi/video/tree/v0.4.1/examples/nextjs-quickstart).
+use the tested [`examples/nextjs-quickstart` directory](../examples/nextjs-quickstart).
 
-`model` can come from any AI SDK provider, registry, gateway, compatible API,
-or custom implementation. The application can choose a cheaper or faster model
-per request without changing VanillaSky.
+`videoModel` can come from any AI SDK provider, registry, gateway, compatible
+API, or custom implementation. The application can choose a cheaper, faster,
+or higher-quality model per request without changing VanillaSky.
 
 Call that route from React and render the player:
 

package/docs/integrate-nextjs.md

@@ -2,27 +2,31 @@
 
 # Next.js integration
 
-Install VanillaSky and one AI SDK provider:
+After installing VanillaSky, choose the provider and model for your server. This
+complete example uses Anthropic and asks you to select a current Claude Sonnet
+model explicitly instead of baking a model ID into the SDK docs:
 
 ```bash
-npm install @vanillaskyai/video@0.4.1 ai @ai-sdk/openai
+npm install @vanillaskyai/video ai @ai-sdk/anthropic
 ```
 
 Create an ignored `.env.local`:
 
 ```bash
-OPENAI_API_KEY=your-key
-OPENAI_MODEL=gpt-4.1
+ANTHROPIC_API_KEY=your-key
+ANTHROPIC_MODEL=your-current-sonnet-model
 ```
 
 Create `app/api/video/route.ts`:
 
 ```ts
-import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
 import { streamText } from "ai";
 import { createVideoHandler } from "@vanillaskyai/video/server";
 
-const model = openai(process.env.OPENAI_MODEL ?? "gpt-4.1");
+const modelId = process.env.ANTHROPIC_MODEL;
+if (!modelId) throw new Error("Set ANTHROPIC_MODEL in the server environment");
+const model = anthropic(modelId);
 
 const handle = createVideoHandler({
   // Local development only. Replace with your session check before deploying.
@@ -74,9 +78,9 @@ requests; replace it with your application's session validation before
 deploying.
 
 The copy-and-run app is in the
-[`examples/nextjs-quickstart` directory](https://github.com/VanillaSkyAi/video/tree/v0.4.1/examples/nextjs-quickstart).
+[`examples/nextjs-quickstart` directory](../examples/nextjs-quickstart).
 
-For another LLM, replace `openai(...)` with the matching AI SDK model. The route
+For another LLM, replace `anthropic(...)` with the matching AI SDK model. The route
 shape and React code stay the same. See [Provider integration](provider-integration.md)
 for adapters, authentication, diagnostics, and production controls. Add media,
 audio, persistence, or custom templates only after the default path works.

package/docs/persistence.md

@@ -8,7 +8,7 @@ does not provide a database or hosted media store. Save the value returned by
 no SDK serializer.
 
 Every stored video has `schemaVersion: "0.1"`. This storage version is separate
-from streaming protocol `0.4`. The 0.1 policy supports the current storage
+from streaming protocol `0.5`. The 0.1 policy supports the current storage
 schema only: there are no compatibility aliases or implicit coercions.
 
 ## Load at the storage boundary

package/docs/prompt-and-input.md

@@ -95,8 +95,8 @@ Your provider streams text deltas. VanillaSky decodes them into typed planner
 parts, validates each complete scene, and emits deterministic protocol events.
 The model never returns React, HTML, CSS, or executable JavaScript.
 
-Generated `scene.add`, `scene.patch`, and `asset.patch` operations all pass
-through the same merged-scene validation before the player sees them.
+Every generated `scene.add` is complete and passes validation before the player
+sees it. Emitted scenes are immutable.
 
 The standard planner contract requires one `scene.add` with
 `placement: "closer"` immediately after the first playable body scene. The