@vanillaskyai/video 0.1.0

package/dist/reaction-QG4CYZLQ.js

@@ -0,0 +1,119 @@
+import {
+  SceneBackground
+} from "./chunk-IFOW65Z6.js";
+import {
+  TemplateText
+} from "./chunk-BCRUUJ6A.js";
+import "./chunk-L5BTTCZV.js";
+import "./chunk-ABZACD4G.js";
+import "./chunk-XTOXFMLM.js";
+import {
+  resolveTokens
+} from "./chunk-FNAEQ7QO.js";
+
+// src/visual-system/scene-templates/reaction.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var REACTION_TAGS = [
+  "launch",
+  "productLaunch",
+  "goLive",
+  "shipIt",
+  "wow",
+  "excited",
+  "happy",
+  "success",
+  "done",
+  "panic",
+  "waiting",
+  "celebration",
+  "cheers",
+  "applause",
+  "highFive",
+  "teamwork",
+  "fail",
+  "confused",
+  "thinking",
+  "thanks",
+  "letsGo",
+  "manual",
+  "office",
+  "meeting",
+  "deadline",
+  "coding",
+  "debugging",
+  "computer",
+  "startup",
+  "presentation",
+  "sales",
+  "growth",
+  "money"
+];
+var ReactionTemplate = ({
+  variables,
+  style,
+  progress,
+  motionProgress = progress,
+  beatIntensity,
+  width,
+  height,
+  textArchetype,
+  safeZone,
+  sceneDuration,
+  isPlaying = true
+}) => {
+  const { font, foreground } = resolveTokens(style);
+  const color = foreground;
+  const mediaUrl = String(variables.mediaUrl || "");
+  const hasClip = mediaUrl.trim().length > 0;
+  return /* @__PURE__ */ jsxs("div", { style: { width, height, backgroundColor: "#000", position: "relative", overflow: "hidden", fontFamily: font }, children: [
+    /* @__PURE__ */ jsx(
+      SceneBackground,
+      {
+        style,
+        progress,
+        sceneDuration,
+        width,
+        height,
+        mediaUrl,
+        mediaType: hasClip ? "video" : "gradient",
+        mediaPoster: String(variables.mediaPoster || ""),
+        backgroundEffect: "slow-zoom-in",
+        seed: String(variables.texts || ""),
+        isPlaying,
+        beatIntensity
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          background: "linear-gradient(180deg, rgba(0,0,0,.18), rgba(0,0,0,.08) 45%, rgba(0,0,0,.5))",
+          pointerEvents: "none"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      TemplateText,
+      {
+        motionProgress,
+        typeTreatment: resolveTokens(style).preset.type,
+        archetype: textArchetype || "slam",
+        text: String(variables.texts || "Still editing manually?"),
+        progress,
+        width,
+        height,
+        safeZone,
+        font,
+        color,
+        sceneDuration: sceneDuration ?? 3,
+        beatIntensity
+      }
+    )
+  ] });
+};
+export {
+  REACTION_TAGS,
+  ReactionTemplate
+};

package/dist/server.d.ts

@@ -0,0 +1,141 @@
+import { l as VideoGenerationContext, m as VideoPlanner, n as VideoRequest, j as VideoCapabilities, d as VideoInput, a as VideoAudio, o as VideoSceneValidator, p as VideoTemplatePacing, q as VideoSnapshotRetention, r as VideoResumeCursor, s as VideoSceneValidationContext, f as VideoScene } from './types-B-PZR6G_.js';
+import { b as VideoFinishReason, a as VideoWarning, V as VideoEvent } from './events-_wfjbmEp.js';
+export { c as VideoWarningCategory } from './events-_wfjbmEp.js';
+import { S as SceneTemplateMetadata } from './catalog-types-BIhSpOWK.js';
+
+interface VideoProviderUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+    /** Bounded provider-native usage. Present only with includeRawProviderData. */
+    raw?: unknown;
+}
+interface VideoGenerationSummary {
+    finishReason?: VideoFinishReason;
+    usage?: VideoProviderUsage;
+    /** Bounded provider-native metadata. Present only with includeRawProviderData. */
+    providerMetadata?: unknown;
+    requestedModelId?: string;
+    resolvedModelId?: string;
+    timeToFirstSceneMs?: number;
+    totalDurationMs: number;
+    acceptedSceneCount: number;
+    rejectedSceneCount: number;
+    /** Duration of the committed deterministic video. maxDurationSec remains a ceiling, not a target. */
+    videoDurationSec: number;
+    warnings: VideoWarning[];
+}
+
+interface TextDeltaVideoPlannerOptions {
+    /** Capture provider credentials in this server-only closure. */
+    streamText: (context: VideoGenerationContext) => AsyncIterable<string> | TextDeltaVideoSource;
+    /** Retain bounded provider-native usage and metadata on the server summary. */
+    includeRawProviderData?: boolean;
+}
+type Awaitable<T> = T | PromiseLike<T>;
+type ProviderFinishReason = string | {
+    unified?: string;
+    raw?: string;
+};
+interface TextDeltaVideoSource {
+    textStream: AsyncIterable<string>;
+    /** The provider SDK's normalized finish reason, when available. */
+    finishReason?: Awaitable<ProviderFinishReason | undefined>;
+    /** The provider's original finish reason, when available. */
+    rawFinishReason?: Awaitable<string | undefined>;
+    /** Vercel AI SDK usage. Both current and prior structural shapes are accepted. */
+    usage?: Awaitable<unknown>;
+    totalUsage?: Awaitable<unknown>;
+    providerMetadata?: Awaitable<unknown>;
+    warnings?: Awaitable<unknown>;
+    response?: Awaitable<unknown>;
+    finalStep?: Awaitable<unknown>;
+    /** Compatibility with older structural adapters. Prefer finalStep. */
+    lastStep?: Awaitable<unknown>;
+    steps?: Awaitable<unknown>;
+    /** Optional provider-neutral model hints for native adapters. */
+    requestedModelId?: Awaitable<string | undefined>;
+    resolvedModelId?: Awaitable<string | undefined>;
+    modelId?: Awaitable<string | undefined>;
+}
+
+interface VideoStreamHandlerOptions {
+    generate: VideoPlanner;
+    systemPrompt?: string | ((context: {
+        request: VideoRequest;
+        capabilities?: VideoCapabilities;
+    }) => string);
+    selectAudio?: (input: VideoInput) => VideoAudio | undefined;
+    createRunId?: (request: VideoRequest) => string;
+    /** Browser origins allowed to call this customer-owned route. Omit for same-origin use. */
+    allowedOrigins?: string[];
+    /** Authenticate before reading the prompt body, or explicitly opt out for a non-public in-process/test route. */
+    authorize: ((request: Request) => boolean | Promise<boolean>) | "none";
+    maxBodyBytes?: number;
+    heartbeatMs?: number | false;
+    /** Private full-fidelity errors. Callback failures never affect the response. */
+    onError?: (error: Error) => unknown;
+    /** Safe warnings, exactly once per generated warning. */
+    onWarning?: (warning: VideoWarning) => unknown;
+    /** Server-only summary, exactly once and only after response.complete. */
+    onComplete?: (summary: VideoGenerationSummary) => unknown;
+    /** Drop malformed generated parts by default, or preserve fail-fast behavior. */
+    invalidPartBehavior?: "drop" | "fail";
+    /** Allow credentialed cross-origin requests from explicit allowedOrigins. */
+    allowCredentials?: boolean;
+    /** Templates and extensions implemented by this customer deployment. */
+    supportedCapabilities?: VideoCapabilities;
+    /** Validate template fields and grounding before forwarding a generated scene. */
+    validateScene?: VideoSceneValidator;
+    /** Resolve trusted pacing metadata for negotiated templates. */
+    getTemplatePacing?: (templateId: string) => VideoTemplatePacing | undefined;
+    /** Explicitly retain selected bounded source metadata in completed snapshots. */
+    snapshotRetention?: VideoSnapshotRetention;
+    /** Read events after a cursor from customer-owned durable storage. */
+    replay?: (cursor: VideoResumeCursor, context: {
+        request: VideoRequest;
+        signal: AbortSignal;
+    }) => AsyncIterable<VideoEvent>;
+}
+type VideoStreamHandler = (request: Request) => Promise<Response>;
+
+interface ServerTemplateRegistry {
+    readonly capabilities: VideoCapabilities;
+    getTemplateMetadata(id: string): SceneTemplateMetadata | undefined;
+    listTemplateMetadata(): SceneTemplateMetadata[];
+}
+declare function createServerTemplateRegistry(options: {
+    templates: readonly SceneTemplateMetadata[];
+}): ServerTemplateRegistry;
+
+declare function createTemplateSceneValidator(options: {
+    kit: ServerTemplateRegistry;
+    /** Authorize an app-approved URL in addition to URLs supplied with the request. */
+    allowMediaUrl?: (url: string, context: VideoSceneValidationContext & {
+        scene: VideoScene;
+        variable: string;
+    }) => boolean;
+}): VideoSceneValidator;
+
+interface VideoHandlerOptions extends Omit<VideoStreamHandlerOptions, "generate" | "systemPrompt" | "supportedCapabilities" | "validateScene" | "getTemplatePacing"> {
+    /** Customer-owned templates that replace matching built-ins and add new IDs. */
+    templates?: ServerTemplateRegistry;
+    /** App-owned provider adapter. Choose any model per request and keep provider clients and credentials in this closure. */
+    streamText: TextDeltaVideoPlannerOptions["streamText"];
+    /** Opt in to bounded provider-native usage and metadata in onComplete. */
+    includeRawProviderData?: boolean;
+    /** Additional video-direction rules prepended to the generated trusted-template catalog. */
+    basePrompt?: string;
+    /** Authorize an app-approved media URL in addition to URLs supplied in the request. */
+    allowMediaUrl?: Parameters<typeof createTemplateSceneValidator>[0]["allowMediaUrl"];
+}
+/**
+ * Build the secure route for a template kit while leaving provider, model,
+ * credentials, authentication, and deployment ownership with the app.
+ */
+declare function createVideoHandler(options: VideoHandlerOptions): VideoStreamHandler;
+
+export { SceneTemplateMetadata as ServerTemplateMetadata, type ServerTemplateRegistry, VideoFinishReason, type VideoGenerationSummary, type VideoHandlerOptions, type VideoProviderUsage, VideoWarning, createServerTemplateRegistry, createVideoHandler };