@vanillaskyai/video 0.1.0

package/dist/chunk-L5BTTCZV.js

@@ -0,0 +1,97 @@
+// src/visual-system/emoji/index.tsx
+import { jsx } from "react/jsx-runtime";
+var NATIVE_EMOJI_FONT = "Apple Color Emoji,Segoe UI Emoji,Noto Color Emoji,sans-serif";
+var NATIVE_EMOJI = /\p{Emoji_Presentation}|\p{Regional_Indicator}|\u{FE0F}|\u{20E3}/u;
+function isNativeEmoji(char) {
+  return NATIVE_EMOJI.test(char);
+}
+var Emoji = ({ char, size, verticalAlign = "-0.15em", style }) => {
+  const nativeEmoji = isNativeEmoji(char);
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      role: nativeEmoji ? "img" : void 0,
+      "aria-label": nativeEmoji ? char : void 0,
+      style: {
+        ...nativeEmoji ? { fontFamily: NATIVE_EMOJI_FONT } : {},
+        fontSize: size,
+        lineHeight: 1,
+        display: "inline-block",
+        verticalAlign,
+        ...style
+      },
+      children: char
+    }
+  );
+};
+
+// src/visual-system/emoji/emoji-text.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function toGraphemes(text) {
+  const Seg = Intl.Segmenter;
+  if (Seg) {
+    const seg = new Seg(void 0, { granularity: "grapheme" });
+    const out = [];
+    for (const { segment } of seg.segment(text)) out.push(segment);
+    return out;
+  }
+  return Array.from(text);
+}
+function renderWithEmoji(text, fontSizePx, opts) {
+  if (!text) return [text];
+  if (!isNativeEmoji(text)) return [text];
+  const clusters = toGraphemes(text);
+  const nodes = [];
+  let textBuf = "";
+  let key = 0;
+  const flushText = () => {
+    if (textBuf) {
+      nodes.push(textBuf);
+      textBuf = "";
+    }
+  };
+  for (const cluster of clusters) {
+    if (isNativeEmoji(cluster)) {
+      flushText();
+      nodes.push(
+        /* @__PURE__ */ jsx2(
+          Emoji,
+          {
+            char: cluster,
+            size: fontSizePx,
+            verticalAlign: opts?.verticalAlign,
+            style: opts?.emojiStyle
+          },
+          `e${key++}`
+        )
+      );
+    } else {
+      textBuf += cluster;
+    }
+  }
+  flushText();
+  return nodes;
+}
+function planTypewriterEmoji(text) {
+  if (!text || !isNativeEmoji(text)) return null;
+  const starts = /* @__PURE__ */ new Map();
+  const covered = /* @__PURE__ */ new Set();
+  let idx = 0;
+  let found = false;
+  for (const cluster of toGraphemes(text)) {
+    const len = cluster.length;
+    if (isNativeEmoji(cluster)) {
+      found = true;
+      starts.set(idx, cluster);
+      for (let k = 1; k < len; k++) covered.add(idx + k);
+    }
+    idx += len;
+  }
+  return found ? { starts, covered } : null;
+}
+
+export {
+  Emoji,
+  renderWithEmoji,
+  planTypewriterEmoji
+};

package/dist/chunk-LMG3GHLL.js

@@ -0,0 +1,107 @@
+import {
+  validateTemplateSchemaValue
+} from "./chunk-352ZZCET.js";
+import {
+  getTemplateSchemaGates,
+  isMeaningfullyPresentTemplateValue
+} from "./chunk-73NTSFFI.js";
+
+// src/visual-system/catalog/validate.ts
+function* walkSchemaValue(property, value, path) {
+  yield { property, value, path };
+  if (property.type === "array" && property.items && Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      yield* walkSchemaValue(property.items, item, `${path}.${index}`);
+    }
+  }
+  if (property.type === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    for (const [name, child] of Object.entries(property.properties ?? {})) {
+      if (Object.hasOwn(value, name)) {
+        yield* walkSchemaValue(child, value[name], `${path}.${name}`);
+      }
+    }
+  }
+}
+function schemaValues(schema, variables) {
+  const values = [];
+  for (const [name, property] of Object.entries(schema.properties)) {
+    if (Object.hasOwn(variables, name)) values.push(...walkSchemaValue(property, variables[name], name));
+  }
+  return values;
+}
+function validateSchema(schema, value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Template variable variables must be object");
+  }
+  const object = value;
+  const requiredFields = new Set(schema.required ?? []);
+  for (const required of schema.required ?? []) {
+    if (!Object.hasOwn(object, required)) throw new Error(`Template variable ${required} is required`);
+  }
+  if (schema.additionalProperties === false) {
+    for (const name of Object.keys(object)) {
+      if (!Object.hasOwn(schema.properties, name)) throw new Error(`Template variable ${name} is not declared`);
+    }
+  }
+  for (const [name, property] of Object.entries(schema.properties)) {
+    if (Object.hasOwn(object, name)) validateTemplateSchemaValue(property, object[name], name, {
+      errorPrefix: "Template variable ",
+      includeTypeArticle: true,
+      allowEmptyOptionalMedia: property.default === "",
+      optional: !requiredFields.has(name)
+    });
+  }
+}
+function validateConditionalPresence(templateId, groups, variables) {
+  for (const group of groups) {
+    if (group.some((field) => Object.hasOwn(variables, field) && isMeaningfullyPresentTemplateValue(variables[field]))) continue;
+    throw new Error(`Template ${templateId} requires a non-empty value for ${group.join(" or ")}`);
+  }
+}
+function suppliedUrls(input) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const media of input.suppliedMedia ?? []) {
+    urls.add(media.url);
+    if (media.posterUrl) urls.add(media.posterUrl);
+  }
+  return urls;
+}
+function createTemplateSceneValidator(options) {
+  return (scene, context) => {
+    const template = options.kit.getTemplateMetadata(scene.templateId);
+    if (!template) throw new Error(`Template ${scene.templateId} is not installed`);
+    const schema = template.schema;
+    const gates = getTemplateSchemaGates(schema);
+    validateConditionalPresence(scene.templateId, gates.requiredAnyOf, scene.variables);
+    validateSchema(schema, scene.variables);
+    const values = schemaValues(schema, scene.variables);
+    const allowedUrls = suppliedUrls(context.input);
+    const suppliedImageUrls = new Set((context.input.suppliedMedia ?? []).filter(({ type }) => type === "image").map(({ url }) => url));
+    if (gates.requiresScreenshot) {
+      const screenshots = values.filter(({ property }) => property.format === "supplied-image").map(({ value }) => value).filter((value) => typeof value === "string" && Boolean(value.trim()));
+      if (!screenshots.length || screenshots.some((url) => !suppliedImageUrls.has(url))) {
+        throw new Error(`Template ${scene.templateId} requires a supplied screenshot image`);
+      }
+    }
+    for (const { path, property, value } of values) {
+      const isMedia = property.format === "uri" || property.format === "supplied-image";
+      if (!isMedia || typeof value !== "string" || !value.trim()) continue;
+      const permitted = allowedUrls.has(value) || options.allowMediaUrl?.(value, {
+        ...context,
+        scene,
+        variable: path
+      });
+      if (!permitted) throw new Error(`Template variable ${path} must use supplied media`);
+    }
+    if (gates.requiresQuote) {
+      const quoteValues = values.filter(({ property, value }) => property.format === "grounded-quote" && typeof value === "string" && value.trim()).map(({ value }) => String(value).trim());
+      if (!quoteValues.length || quoteValues.some((quote) => !context.input.input.includes(quote))) {
+        throw new Error(`Template ${scene.templateId} requires an exact quote from the raw input`);
+      }
+    }
+  };
+}
+
+export {
+  createTemplateSceneValidator
+};

package/dist/chunk-OOPIETLW.js

@@ -0,0 +1,101 @@
+import {
+  parseVideoEvent
+} from "./chunk-ERY4S6QV.js";
+import {
+  VIDEO_PROTOCOL_VERSION
+} from "./chunk-EE6PK6XC.js";
+
+// src/protocol/sse.ts
+var VIDEO_STREAM_HEADER = "x-vanillasky-video-stream";
+var VIDEO_STREAM_CONTENT_TYPE = "text/event-stream; charset=utf-8";
+function encodeVideoSseEvent(event) {
+  const valid = parseVideoEvent(event);
+  return `id: ${valid.eventId}
+event: video
+data: ${JSON.stringify(valid)}
+
+`;
+}
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+async function* decodeVideoSse(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let doneMarker = false;
+  const parseBlock = (block) => {
+    const lines = block.split("\n");
+    if (lines.every((line) => !line || line.startsWith(":"))) return void 0;
+    let id;
+    let eventName;
+    const data = [];
+    for (const line of lines) {
+      if (!line || line.startsWith(":")) continue;
+      const separator = line.indexOf(":");
+      const field = separator < 0 ? line : line.slice(0, separator);
+      const value = separator < 0 ? "" : line.slice(separator + 1).replace(/^ /, "");
+      if (field === "id") id = value;
+      else if (field === "event") eventName = value;
+      else if (field === "data") data.push(value);
+    }
+    const payload = data.join("\n");
+    if (payload === "[DONE]") {
+      doneMarker = true;
+      return void 0;
+    }
+    if (!payload) return void 0;
+    if (doneMarker) throw new Error("Video response received an event after [DONE]");
+    if (eventName && eventName !== "video") {
+      throw new Error(`Unsupported SSE event ${eventName}`);
+    }
+    const event = parseVideoEvent(JSON.parse(payload));
+    if (id && id !== event.eventId) throw new Error("SSE id does not match event.eventId");
+    return event;
+  };
+  try {
+    while (true) {
+      const result = await reader.read();
+      buffer += normalizeNewlines(decoder.decode(result.value, { stream: !result.done }));
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary >= 0) {
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const event = parseBlock(block);
+        if (event) yield event;
+        boundary = buffer.indexOf("\n\n");
+      }
+      if (result.done) break;
+    }
+    if (buffer.trim()) {
+      const event = parseBlock(buffer.trim());
+      if (event) yield event;
+    }
+    if (!doneMarker) throw new Error("Video response SSE stream ended without [DONE]");
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function videoSseHeaders(headers) {
+  const result = new Headers(headers);
+  result.set("Content-Type", VIDEO_STREAM_CONTENT_TYPE);
+  result.set(VIDEO_STREAM_HEADER, VIDEO_PROTOCOL_VERSION);
+  result.set("Cache-Control", "no-cache, no-transform");
+  result.set("X-Accel-Buffering", "no");
+  result.set("X-Content-Type-Options", "nosniff");
+  const exposed = result.get("Access-Control-Expose-Headers");
+  if (!exposed) result.set("Access-Control-Expose-Headers", VIDEO_STREAM_HEADER);
+  else if (!exposed.toLowerCase().split(",").map((value) => value.trim()).includes(VIDEO_STREAM_HEADER)) {
+    result.set("Access-Control-Expose-Headers", `${exposed}, ${VIDEO_STREAM_HEADER}`);
+  }
+  return result;
+}
+
+export {
+  VIDEO_STREAM_HEADER,
+  VIDEO_STREAM_CONTENT_TYPE,
+  encodeVideoSseEvent,
+  decodeVideoSse,
+  videoSseHeaders
+};

package/dist/chunk-P22HHFDK.js

@@ -0,0 +1,43 @@
+// src/visual-system/parse-list.ts
+function parseList(value, max) {
+  if (value === null || value === void 0) return [];
+  let arr;
+  if (Array.isArray(value)) {
+    arr = value;
+  } else if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        arr = Array.isArray(parsed) ? parsed : [trimmed];
+      } catch {
+        arr = trimmed.split(",");
+      }
+    } else {
+      arr = trimmed.split(",");
+    }
+  } else if (typeof value === "number" || typeof value === "boolean") {
+    arr = [value];
+  } else if (typeof value === "object") {
+    arr = [value];
+  } else {
+    return [];
+  }
+  const out = arr.map((item) => {
+    if (item === null || item === void 0) return "";
+    if (typeof item === "string") return item.trim();
+    if (typeof item === "number" || typeof item === "boolean") return String(item);
+    if (typeof item === "object") {
+      const o = item;
+      const picked = o.label ?? o.name ?? o.text ?? o.title ?? o.description ?? o.value;
+      return picked !== void 0 ? String(picked).trim() : "";
+    }
+    return String(item).trim();
+  }).filter((s) => s.length > 0);
+  return typeof max === "number" ? out.slice(0, max) : out;
+}
+
+export {
+  parseList
+};

package/dist/chunk-QAAO7OAY.js

@@ -0,0 +1,19 @@
+// src/visual-system/scene-templates/celebration-particle-timing.ts
+var SECOND_WAVE_INTERVAL = 4;
+var SECOND_WAVE_START = 0.33;
+var SECOND_WAVE_DURATION = 1;
+var EXIT_FADE_START = 0.76;
+var EXIT_FADE_END = 0.85;
+function getCelebrationParticleTiming(sceneProgress, particleIndex, durationFactor) {
+  if (sceneProgress >= EXIT_FADE_END) return null;
+  const isSecondWave = particleIndex % SECOND_WAVE_INTERVAL === 0;
+  if (isSecondWave && sceneProgress <= SECOND_WAVE_START) return null;
+  const waveProgress = isSecondWave ? (sceneProgress - SECOND_WAVE_START) / SECOND_WAVE_DURATION : sceneProgress;
+  const progress = Math.min(1, Math.max(0, waveProgress / durationFactor));
+  const opacity = sceneProgress <= EXIT_FADE_START ? 1 : (EXIT_FADE_END - sceneProgress) / (EXIT_FADE_END - EXIT_FADE_START);
+  return { progress, opacity };
+}
+
+export {
+  getCelebrationParticleTiming
+};

package/dist/chunk-S7HFLYNN.js

@@ -0,0 +1,35 @@
+// src/visual-system/scene-templates/text-utils.ts
+function stripPipe(text) {
+  const idx = text.indexOf("|");
+  return idx === -1 ? text : text.slice(0, idx);
+}
+function getResponsiveFontSize(text, width, role = "headline", height) {
+  const s = height ? Math.min(width, height) / 1080 : width / 1080;
+  const words = text.split(/\s+/).filter(Boolean).length;
+  const chars = text.length;
+  if (role === "subtitle") {
+    if (chars > 60) return 24 * s;
+    if (chars > 30) return 28 * s;
+    return 32 * s;
+  }
+  if (words <= 2 && chars <= 12) return Math.max(36 * s, 96 * s);
+  if (words <= 3 && chars <= 20) return Math.max(36 * s, 80 * s);
+  if (words <= 5 && chars <= 35) return Math.max(36 * s, 64 * s);
+  if (words <= 8 && chars <= 60) return Math.max(36 * s, 48 * s);
+  return 36 * s;
+}
+function fitTextSize(text, baseFontSize, maxWidth, opts) {
+  if (!text) return baseFontSize;
+  const minScale = opts?.minScale ?? 0.5;
+  const charWidthRatio = opts?.charWidthRatio ?? 0.55;
+  const estWidth = text.length * baseFontSize * charWidthRatio;
+  if (estWidth <= maxWidth) return baseFontSize;
+  const scaled = maxWidth / estWidth * baseFontSize;
+  return Math.max(scaled, baseFontSize * minScale);
+}
+
+export {
+  stripPipe,
+  getResponsiveFontSize,
+  fitTextSize
+};

package/dist/chunk-SPVTJH3F.js

@@ -0,0 +1,24 @@
+// src/protocol/timeline.ts
+function resolveVideoTimeline(config) {
+  const ranges = [];
+  let cursor = 0;
+  for (const scene of config.scenes) {
+    const timing = scene.timing ?? {};
+    const beatStart = timing.beatStart == null ? void 0 : config.audio?.beatMarkers[timing.beatStart]?.time;
+    const beatEnd = timing.beatEnd == null ? void 0 : config.audio?.beatMarkers[timing.beatEnd]?.time;
+    const start = timing.startTime ?? beatStart ?? cursor;
+    const duration = Math.max(1e-3, timing.fixedDuration ?? 5);
+    const end = Math.max(start + 1e-3, timing.endTime ?? beatEnd ?? start + duration);
+    ranges.push({ scene, start, end });
+    cursor = end;
+  }
+  return ranges;
+}
+function getVideoDuration(config) {
+  return resolveVideoTimeline(config).at(-1)?.end ?? 0;
+}
+
+export {
+  resolveVideoTimeline,
+  getVideoDuration
+};