@vanillaskyai/video 0.1.0

package/dist/chunk-GRMUV7QY.js

@@ -0,0 +1,262 @@
+import {
+  boundProviderValue,
+  getGenerationLifecycleSink,
+  normalizeModelId,
+  normalizeProviderUsage
+} from "./chunk-E7CL7UPB.js";
+import {
+  parseVideoPlanPart
+} from "./chunk-ERY4S6QV.js";
+
+// src/server/model/truncated-json.ts
+function isConfidentlyTruncatedJson(source) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (const character of source) {
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') inString = false;
+      continue;
+    }
+    if (character === '"') inString = true;
+    else if (character === "{" || character === "[") stack.push(character);
+    else if (character === "}" || character === "]") {
+      const expected = character === "}" ? "{" : "[";
+      if (stack.pop() !== expected) return false;
+    }
+  }
+  if (!inString && stack.length === 0) return false;
+  let completed = source;
+  if (inString && !escaped) completed += '"';
+  else if (inString && escaped) return false;
+  completed += stack.reverse().map((open) => open === "{" ? "}" : "]").join("");
+  try {
+    JSON.parse(completed);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/server/model/text-stream.ts
+var PROVIDER_CODE_FENCE = /^```(?:json|ndjson)?$/i;
+function parsePlanLine(line) {
+  if (!line || PROVIDER_CODE_FENCE.test(line) || !line.startsWith("{")) return void 0;
+  const value = JSON.parse(line);
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const object = value;
+    const scene = object.scene;
+    if (object.type === "scene.add" && object.timing != null && scene && typeof scene === "object" && !Array.isArray(scene) && !("timing" in scene)) {
+      const { timing, ...planPart } = object;
+      return parseVideoPlanPart({
+        ...planPart,
+        scene: { ...scene, timing }
+      });
+    }
+  }
+  return parseVideoPlanPart(value);
+}
+function isEnrichedSource(source) {
+  return typeof source === "object" && source != null && "textStream" in source;
+}
+function normalizeFinishReason(reason) {
+  if (!reason) return void 0;
+  const normalized = reason.toLowerCase().replaceAll("_", "-");
+  if (["stop", "end-turn", "end", "completed"].includes(normalized)) return "stop";
+  if (["length", "max-tokens", "max-output-tokens", "token-limit"].includes(normalized)) return "length";
+  if (["content-filter", "content-filtered", "safety"].includes(normalized)) return "content-filter";
+  if (["error", "failed", "failure"].includes(normalized)) return "provider-error";
+  if (["tool-calls", "tool-call", "tool-use", "tool-uses"].includes(normalized)) return "tool-calls";
+  return "other";
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function valueAt(value, path) {
+  let current = value;
+  for (const key of path) {
+    current = record(current)?.[key];
+  }
+  return current;
+}
+function modelFromResponse(value) {
+  return normalizeModelId(valueAt(value, ["modelId"]) ?? valueAt(value, ["model"]));
+}
+function modelFromStep(value) {
+  return modelFromResponse(valueAt(value, ["response"])) ?? normalizeModelId(valueAt(value, ["modelId"]));
+}
+function requestedModelFromStep(value) {
+  return normalizeModelId(valueAt(value, ["model", "modelId"]));
+}
+function providerWarning(code, message) {
+  return { code, category: "provider", message, recoverable: true };
+}
+var PROVIDER_RESULT_ABORTED = /* @__PURE__ */ Symbol("provider-result-aborted");
+function settle(value) {
+  return Promise.resolve(value).then(
+    (resolved) => ({ value: resolved, rejected: false }),
+    () => ({ rejected: true })
+  );
+}
+function providerResultOrAbort(result, signal) {
+  return new Promise((resolve, reject) => {
+    let completed = false;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      if (completed) return;
+      completed = true;
+      cleanup();
+      resolve(PROVIDER_RESULT_ABORTED);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void result.then(
+      (value) => {
+        if (completed) return;
+        completed = true;
+        cleanup();
+        resolve(value);
+      },
+      (cause) => {
+        if (completed) return;
+        completed = true;
+        cleanup();
+        reject(cause);
+      }
+    );
+    if (signal.aborted) onAbort();
+  });
+}
+function inspectProviderSource(source, includeRawProviderData) {
+  const finish = settle(source.finishReason);
+  const rawFinish = settle(source.rawFinishReason);
+  const usage = settle(source.totalUsage ?? source.usage);
+  const metadata = settle(source.providerMetadata);
+  const warnings = settle(source.warnings);
+  const response = settle(source.response);
+  const finalStep = settle(source.finalStep ?? source.lastStep);
+  const steps = settle(source.steps);
+  const requestedModel = settle(source.requestedModelId ?? source.modelId);
+  const resolvedModel = settle(source.resolvedModelId);
+  return Promise.all([
+    finish,
+    rawFinish,
+    usage,
+    metadata,
+    warnings,
+    response,
+    finalStep,
+    steps,
+    requestedModel,
+    resolvedModel
+  ]).then(([
+    finishResult,
+    rawFinishResult,
+    usageResult,
+    metadataResult,
+    warningResult,
+    responseResult,
+    finalStepResult,
+    stepsResult,
+    requestedResult,
+    resolvedResult
+  ]) => {
+    const finishObject = record(finishResult.value);
+    const finishReason = typeof finishResult.value === "string" ? finishResult.value : typeof finishObject?.unified === "string" ? finishObject.unified : void 0;
+    const rawReason = typeof rawFinishResult.value === "string" ? rawFinishResult.value : typeof finishObject?.raw === "string" ? finishObject.raw : void 0;
+    const providerWarnings = [];
+    if (Array.isArray(warningResult.value) && warningResult.value.length > 0) {
+      providerWarnings.push(providerWarning("provider_warning", "The model provider reported a warning."));
+    }
+    if ([
+      finishResult,
+      rawFinishResult,
+      usageResult,
+      metadataResult,
+      warningResult,
+      responseResult,
+      finalStepResult,
+      stepsResult,
+      requestedResult,
+      resolvedResult
+    ].some(({ rejected }) => rejected)) {
+      providerWarnings.push(providerWarning(
+        "provider_diagnostics_unavailable",
+        "Some provider diagnostics were unavailable."
+      ));
+    }
+    const stepList = Array.isArray(stepsResult.value) ? stepsResult.value : void 0;
+    const finalStepValue = finalStepResult.value ?? stepList?.at(-1);
+    const normalizedUsage = normalizeProviderUsage(usageResult.value, includeRawProviderData);
+    const requestedModelId = requestedModelFromStep(finalStepValue) ?? normalizeModelId(requestedResult.value);
+    const resolvedModelId = modelFromResponse(responseResult.value) ?? modelFromStep(finalStepValue) ?? normalizeModelId(resolvedResult.value);
+    return {
+      ...finishReason ? { finishReason } : {},
+      ...rawReason ? { rawFinishReason: rawReason } : {},
+      ...normalizedUsage ? { usage: normalizedUsage } : {},
+      ...includeRawProviderData && metadataResult.value !== void 0 ? { providerMetadata: boundProviderValue(metadataResult.value) } : {},
+      ...requestedModelId ? { requestedModelId } : {},
+      ...resolvedModelId ? { resolvedModelId } : {},
+      warnings: providerWarnings
+    };
+  });
+}
+function createTextDeltaVideoPlanner(options) {
+  return async function* plan(context) {
+    const source = options.streamText(context);
+    const enriched = isEnrichedSource(source) ? source : void 0;
+    const providerResult = enriched ? inspectProviderSource(enriched, options.includeRawProviderData ?? false) : void 0;
+    if (providerResult) getGenerationLifecycleSink(context)?.registerProviderResult(providerResult);
+    const textStream = enriched?.textStream ?? source;
+    let buffer = "";
+    let explicitlyCompleted = false;
+    for await (const delta of textStream) {
+      if (typeof delta !== "string") throw new Error("The LLM adapter returned a non-text delta");
+      buffer += delta;
+      let newline = buffer.indexOf("\n");
+      while (newline >= 0) {
+        const line = buffer.slice(0, newline).trim();
+        buffer = buffer.slice(newline + 1);
+        const part = parsePlanLine(line);
+        if (part) {
+          if (part.type === "plan.complete") explicitlyCompleted = true;
+          yield part;
+        }
+        newline = buffer.indexOf("\n");
+      }
+    }
+    const tail = buffer.trim();
+    try {
+      const part = parsePlanLine(tail);
+      if (part) {
+        if (part.type === "plan.complete") explicitlyCompleted = true;
+        yield part;
+      }
+    } catch (error) {
+      if (!tail.startsWith("{") || !isConfidentlyTruncatedJson(tail)) throw error;
+      yield { type: "plan.complete", finishReason: "length" };
+      explicitlyCompleted = true;
+    }
+    if (enriched) {
+      const provider = await providerResultOrAbort(providerResult, context.signal);
+      if (provider === PROVIDER_RESULT_ABORTED) return;
+      const standardReason = normalizeFinishReason(provider.finishReason);
+      const rawReason = normalizeFinishReason(provider.rawFinishReason);
+      const providerReason = standardReason && standardReason !== "other" ? standardReason : rawReason ?? standardReason;
+      if (providerReason === "provider-error") {
+        throw new Error("The model provider finished with an error");
+      }
+      if (providerReason === "tool-calls") {
+        throw new Error("The model provider requested unsupported tool calls");
+      }
+      if (!explicitlyCompleted && (providerReason === "length" || providerReason === "content-filter" || providerReason === "other")) {
+        yield { type: "plan.complete", finishReason: providerReason };
+      }
+    }
+  };
+}
+
+export {
+  createTextDeltaVideoPlanner
+};

package/dist/chunk-IFOW65Z6.js

@@ -0,0 +1,205 @@
+import {
+  BrandGradientOverlay,
+  getBackgroundTransform
+} from "./chunk-ABZACD4G.js";
+
+// src/visual-system/scene-templates/scene-background.tsx
+import { useEffect, useRef } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var VIDEO_EXTENSIONS = [".mp4", ".webm", ".mov", ".m4v", ".avi"];
+function isVideoUrl(url) {
+  try {
+    const pathname = new URL(url).pathname.toLowerCase();
+    return VIDEO_EXTENSIONS.some((ext) => pathname.endsWith(ext));
+  } catch {
+    const lower = url.toLowerCase();
+    return VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
+  }
+}
+var MEDIA_POSITIONS = {
+  center: "center center",
+  top: "center top",
+  bottom: "center bottom",
+  left: "left center",
+  right: "right center"
+};
+function resolveMediaPosition(value) {
+  return MEDIA_POSITIONS[value] ?? MEDIA_POSITIONS.center;
+}
+function resolveMediaTreatment(value) {
+  return value === "subtle" || value === "text-safe" ? value : "cinematic";
+}
+function getMediaTreatmentLayers(value) {
+  const treatment = resolveMediaTreatment(value);
+  const vignette = {
+    id: "vignette",
+    background: treatment === "subtle" ? "radial-gradient(ellipse at center, transparent 45%, rgba(0,0,0,0.28) 100%)" : "radial-gradient(ellipse at center, transparent 30%, rgba(0,0,0,0.55) 80%, rgba(0,0,0,0.75) 100%)"
+  };
+  if (treatment === "subtle") return [vignette];
+  const cinematic = [
+    vignette,
+    {
+      id: "center-scrim",
+      background: treatment === "text-safe" ? "radial-gradient(ellipse 90% 56% at 50% 50%, rgba(0,0,0,0.36) 0%, rgba(0,0,0,0.18) 55%, transparent 84%)" : "radial-gradient(ellipse 85% 50% at 50% 50%, rgba(0,0,0,0.22) 0%, rgba(0,0,0,0.10) 50%, transparent 80%)"
+    },
+    {
+      id: "bottom-scrim",
+      background: treatment === "text-safe" ? "linear-gradient(to top, rgba(0,0,0,0.68) 0%, transparent 100%)" : "linear-gradient(to top, rgba(0,0,0,0.5) 0%, transparent 100%)",
+      style: { top: "55%" }
+    }
+  ];
+  if (treatment === "text-safe") {
+    cinematic.splice(1, 0, {
+      id: "full-wash",
+      background: "rgba(0,0,0,0.30)"
+    });
+  }
+  return cinematic;
+}
+function resolveMediaType(mediaType, mediaUrl) {
+  if (mediaType === "gradient") return "gradient";
+  if (mediaType === "video") return "video";
+  if (mediaType === "photo") return "photo";
+  return mediaUrl && isVideoUrl(mediaUrl) ? "video" : "photo";
+}
+function getMediaBackgroundProps(variables) {
+  return {
+    mediaUrl: String(variables.mediaUrl || ""),
+    mediaType: String(variables.mediaType || "auto"),
+    mediaPoster: String(variables.mediaPoster || ""),
+    mediaPosition: String(variables.mediaPosition || "center"),
+    mediaTreatment: String(variables.mediaTreatment || "cinematic")
+  };
+}
+var SceneBackground = ({
+  style,
+  progress,
+  sceneDuration,
+  width: _width,
+  // accepted for symmetry; not currently used in render
+  height: _height,
+  mediaUrl = "",
+  mediaType = "auto",
+  mediaPoster,
+  mediaPosition = "center",
+  mediaTreatment = "cinematic",
+  backgroundEffect,
+  seed,
+  isPlaying = true,
+  beatIntensity = 0
+}) => {
+  void _width;
+  void _height;
+  const resolved = resolveMediaType(mediaType, mediaUrl);
+  const showMedia = resolved !== "gradient" && !!mediaUrl;
+  const resolvedPosition = resolveMediaPosition(mediaPosition);
+  const resolvedTreatment = resolveMediaTreatment(mediaTreatment);
+  const treatmentLayers = getMediaTreatmentLayers(resolvedTreatment);
+  const gradSeed = typeof seed === "number" ? seed : typeof seed === "string" ? seed.split("").reduce((acc, c) => acc + c.charCodeAt(0), 0) : 0;
+  const bgTransform = getBackgroundTransform(
+    backgroundEffect,
+    progress,
+    beatIntensity
+  );
+  const videoRef = useRef(null);
+  const lastProgress = useRef(progress);
+  const videoStarted = useRef(false);
+  useEffect(() => {
+    const vid = videoRef.current;
+    if (!vid) return;
+    if (!isPlaying) {
+      vid.pause();
+      videoStarted.current = false;
+      return;
+    }
+    const progressChanged = Math.abs(progress - lastProgress.current) > 1e-3;
+    lastProgress.current = progress;
+    if (progressChanged && !videoStarted.current) {
+      vid.playbackRate = 1;
+      vid.currentTime = 0;
+      vid.play().catch(() => {
+      });
+      videoStarted.current = true;
+    } else if (!progressChanged && videoStarted.current) {
+      vid.pause();
+      videoStarted.current = false;
+    }
+  }, [progress, isPlaying]);
+  useEffect(() => {
+    const vid = videoRef.current;
+    return () => {
+      if (!vid) return;
+      vid.pause();
+      vid.removeAttribute("src");
+      vid.load();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      BrandGradientOverlay,
+      {
+        style,
+        progress,
+        sceneDuration,
+        seed: gradSeed
+      }
+    ),
+    showMedia && (resolved === "video" ? /* @__PURE__ */ jsx(
+      "video",
+      {
+        ref: videoRef,
+        src: mediaUrl,
+        poster: mediaPoster || void 0,
+        muted: true,
+        loop: true,
+        playsInline: true,
+        preload: "auto",
+        "data-media-position": mediaPosition,
+        style: {
+          position: "absolute",
+          inset: 0,
+          width: "100%",
+          height: "100%",
+          objectFit: "cover",
+          objectPosition: resolvedPosition,
+          transform: bgTransform.transform,
+          transformOrigin: bgTransform.transformOrigin
+        }
+      }
+    ) : /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-media-position": mediaPosition,
+        style: {
+          position: "absolute",
+          inset: 0,
+          transform: bgTransform.transform,
+          transformOrigin: bgTransform.transformOrigin,
+          backgroundImage: `url(${mediaUrl})`,
+          backgroundSize: "cover",
+          backgroundPosition: resolvedPosition
+        }
+      }
+    )),
+    showMedia && treatmentLayers.map((layer) => /* @__PURE__ */ jsx(
+      "div",
+      {
+        "data-media-treatment": resolvedTreatment,
+        "data-media-overlay": layer.id,
+        style: {
+          position: "absolute",
+          inset: 0,
+          background: layer.background,
+          pointerEvents: "none",
+          ...layer.style
+        }
+      },
+      layer.id
+    ))
+  ] });
+};
+
+export {
+  getMediaBackgroundProps,
+  SceneBackground
+};