@vanillaskyai/video 0.1.0

package/dist/chunk-ERY4S6QV.js

@@ -0,0 +1,385 @@
+import {
+  VIDEO_PROTOCOL_VERSION,
+  VIDEO_SCHEMA_VERSION
+} from "./chunk-EE6PK6XC.js";
+import {
+  validateVideoBrand
+} from "./chunk-XGRA2MUV.js";
+
+// src/protocol/warnings.ts
+var VIDEO_WARNING_CATEGORIES = {
+  scene_duration_adjusted: "readability",
+  scene_omitted_unreadable: "readability",
+  scene_omitted_for_closer: "readability",
+  scene_patch_rejected_readability: "readability",
+  chart_scale_imbalance: "readability",
+  provider_warning: "provider",
+  provider_diagnostics_unavailable: "provider"
+};
+var MAX_PUBLIC_DIAGNOSTIC_LENGTH = 160;
+var SECRET_ASSIGNMENT = /\b(?:api[_-]?key|authorization|secret|token|password)\s*[:=]\s*\S+/gi;
+var BEARER_TOKEN = /\bBearer\s+\S+/gi;
+var URL = /https?:\/\/\S+/gi;
+function safePublicDiagnostic(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const withoutControls = Array.from(value, (character) => {
+    const code = character.codePointAt(0) ?? 0;
+    return code < 32 || code === 127 ? " " : character;
+  }).join("");
+  const redacted = withoutControls.replace(SECRET_ASSIGNMENT, "[redacted]").replace(BEARER_TOKEN, "[redacted]").replace(URL, "[redacted url]").replace(/\s+/g, " ").trim();
+  if (!redacted) return fallback;
+  if (redacted.length <= MAX_PUBLIC_DIAGNOSTIC_LENGTH) return redacted;
+  return `${redacted.slice(0, MAX_PUBLIC_DIAGNOSTIC_LENGTH - 1).trimEnd()}\u2026`;
+}
+
+// src/protocol/validation.ts
+var CORE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "response.start",
+  "audio.set",
+  "scene.add",
+  "scene.patch",
+  "asset.patch",
+  "response.warning",
+  "response.complete",
+  "response.error",
+  "response.abort"
+]);
+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 publicDiagnostic(value, path) {
+  const result = string(value, path);
+  if (result.length > MAX_PUBLIC_DIAGNOSTIC_LENGTH) {
+    throw new Error(`${path} must be at most ${MAX_PUBLIC_DIAGNOSTIC_LENGTH} characters`);
+  }
+  if (Array.from(result).some((character) => {
+    const code = character.codePointAt(0) ?? 0;
+    return code < 32 || code === 127;
+  })) throw new Error(`${path} contains control characters`);
+  return result;
+}
+function finite(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`${path} must be finite`);
+  return value;
+}
+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 jsonValue(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    finite(value, path);
+    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 timing(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, [
+    "beatStart",
+    "beatEnd",
+    "startTime",
+    "endTime",
+    "fixedDuration",
+    "durationWeight"
+  ], path);
+  for (const [key, child] of Object.entries(result)) finite(child, `${path}.${key}`);
+  if (result.fixedDuration != null && Number(result.fixedDuration) <= 0) {
+    throw new Error(`${path}.fixedDuration must be positive`);
+  }
+  return result;
+}
+function scene(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, [
+    "id",
+    "templateId",
+    "variables",
+    "textArchetype",
+    "backgroundEffect",
+    "timing"
+  ], path);
+  string(result.id, `${path}.id`);
+  string(result.templateId, `${path}.templateId`);
+  record(result.variables, `${path}.variables`);
+  jsonValue(result.variables, `${path}.variables`);
+  timing(result.timing, `${path}.timing`);
+  if (result.textArchetype != null) string(result.textArchetype, `${path}.textArchetype`);
+  if (result.backgroundEffect != null) string(result.backgroundEffect, `${path}.backgroundEffect`);
+  return result;
+}
+function scenePatch(value, path) {
+  const patch = record(value, path);
+  allowedKeys(patch, [
+    "variables",
+    "textArchetype",
+    "backgroundEffect",
+    "timing"
+  ], path);
+  if (patch.variables != null) {
+    record(patch.variables, `${path}.variables`);
+    jsonValue(patch.variables, `${path}.variables`);
+  }
+  if (patch.timing != null) timing(patch.timing, `${path}.timing`);
+  if (patch.textArchetype != null) string(patch.textArchetype, `${path}.textArchetype`);
+  if (patch.backgroundEffect != null) string(patch.backgroundEffect, `${path}.backgroundEffect`);
+}
+function capabilities(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, ["templates", "extensions"], path);
+  for (const key of ["templates", "extensions"]) {
+    const entries = result[key];
+    if (entries == null) continue;
+    if (!Array.isArray(entries)) throw new Error(`${path}.${key} must be an array`);
+    entries.forEach((entry, index) => {
+      const value2 = string(entry, `${path}.${key}[${index}]`);
+      if (key === "extensions" && (!value2.startsWith("data.") || value2 === "data.")) {
+        throw new Error(`${path}.${key}[${index}] must use the data.* namespace`);
+      }
+    });
+  }
+  return result;
+}
+function style(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, [
+    "brand",
+    "preset",
+    "defaultBackgroundEffect",
+    "defaultTextArchetype",
+    "defaultTransition",
+    "density",
+    "motion"
+  ], path);
+  validateVideoBrand(result.brand, `${path}.brand`);
+  return result;
+}
+function audio(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, [
+    "trackId",
+    "audioUrl",
+    "sourceDuration",
+    "duration",
+    "beatDetection",
+    "beatMarkers",
+    "volume",
+    "fadeOutMs"
+  ], path);
+  string(result.trackId, `${path}.trackId`);
+  string(result.audioUrl, `${path}.audioUrl`);
+  if (finite(result.duration, `${path}.duration`) <= 0) throw new Error(`${path}.duration must be positive`);
+  const detection = record(result.beatDetection, `${path}.beatDetection`);
+  allowedKeys(detection, ["sensitivity", "targetBeats", "minInterval"], `${path}.beatDetection`);
+  const sensitivity = finite(detection.sensitivity, `${path}.beatDetection.sensitivity`);
+  if (sensitivity < 0 || sensitivity > 1) throw new Error(`${path}.beatDetection.sensitivity must be 0\u20131`);
+  if (detection.targetBeats != null && (!Number.isInteger(detection.targetBeats) || Number(detection.targetBeats) <= 0)) {
+    throw new Error(`${path}.beatDetection.targetBeats must be a positive integer`);
+  }
+  if (detection.minInterval != null && finite(detection.minInterval, `${path}.beatDetection.minInterval`) <= 0) {
+    throw new Error(`${path}.beatDetection.minInterval must be positive`);
+  }
+  if (!Array.isArray(result.beatMarkers)) throw new Error(`${path}.beatMarkers must be an array`);
+  result.beatMarkers.forEach((value2, index) => {
+    const marker = record(value2, `${path}.beatMarkers[${index}]`);
+    allowedKeys(marker, ["time", "manual", "energy"], `${path}.beatMarkers[${index}]`);
+    if (finite(marker.time, `${path}.beatMarkers[${index}].time`) < 0) {
+      throw new Error(`${path}.beatMarkers[${index}].time must be non-negative`);
+    }
+    if (marker.manual != null && typeof marker.manual !== "boolean") {
+      throw new Error(`${path}.beatMarkers[${index}].manual must be boolean`);
+    }
+    if (marker.energy != null && !["high", "medium", "low"].includes(String(marker.energy))) {
+      throw new Error(`${path}.beatMarkers[${index}].energy is unsupported`);
+    }
+  });
+  if (result.sourceDuration != null && finite(result.sourceDuration, `${path}.sourceDuration`) <= 0) {
+    throw new Error(`${path}.sourceDuration must be positive`);
+  }
+  if (result.volume != null) {
+    const volume = finite(result.volume, `${path}.volume`);
+    if (volume < 0 || volume > 1) throw new Error(`${path}.volume must be 0\u20131`);
+  }
+  if (result.fadeOutMs != null && finite(result.fadeOutMs, `${path}.fadeOutMs`) < 0) {
+    throw new Error(`${path}.fadeOutMs must be non-negative`);
+  }
+  return result;
+}
+function config(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, ["schemaVersion", "orientation", "audio", "scenes", "style", "meta"], path);
+  if (result.schemaVersion !== VIDEO_SCHEMA_VERSION) {
+    throw new Error(`${path}.schemaVersion must be ${VIDEO_SCHEMA_VERSION}`);
+  }
+  if (!Array.isArray(result.scenes)) throw new Error(`${path}.scenes must be an array`);
+  result.scenes.forEach((item, index) => scene(item, `${path}.scenes[${index}]`));
+  style(result.style, `${path}.style`);
+  if (result.orientation != null && result.orientation !== "portrait" && result.orientation !== "landscape") {
+    throw new Error(`${path}.orientation is unsupported`);
+  }
+  if (result.audio != null) audio(result.audio, `${path}.audio`);
+  if (result.meta != null) jsonValue(record(result.meta, `${path}.meta`), `${path}.meta`);
+  return result;
+}
+function validateCoreData(type, value) {
+  const data = record(value, "event.data");
+  if (type === "response.start") {
+    allowedKeys(data, ["requestId", "format", "style", "meta", "capabilities"], "event.data");
+    string(data.requestId, "event.data.requestId");
+    const format = record(data.format, "event.data.format");
+    allowedKeys(format, ["orientation"], "event.data.format");
+    if (format.orientation !== "portrait" && format.orientation !== "landscape") {
+      throw new Error("event.data.format.orientation is unsupported");
+    }
+    style(data.style, "event.data.style");
+    if (data.meta != null) jsonValue(record(data.meta, "event.data.meta"), "event.data.meta");
+    if (data.capabilities != null) capabilities(data.capabilities, "event.data.capabilities");
+  } else if (type === "audio.set") {
+    allowedKeys(data, ["audio"], "event.data");
+    audio(data.audio, "event.data.audio");
+  } else if (type === "scene.add") {
+    allowedKeys(data, ["scene", "position", "revision"], "event.data");
+    scene(data.scene, "event.data.scene");
+    nonNegativeInteger(data.position, "event.data.position");
+    nonNegativeInteger(data.revision, "event.data.revision");
+  } else if (type === "scene.patch") {
+    allowedKeys(data, ["sceneId", "revision", "patch"], "event.data");
+    string(data.sceneId, "event.data.sceneId");
+    nonNegativeInteger(data.revision, "event.data.revision");
+    scenePatch(data.patch, "event.data.patch");
+  } else if (type === "asset.patch") {
+    allowedKeys(data, ["sceneId", "revision", "variables"], "event.data");
+    string(data.sceneId, "event.data.sceneId");
+    nonNegativeInteger(data.revision, "event.data.revision");
+    record(data.variables, "event.data.variables");
+    jsonValue(data.variables, "event.data.variables");
+  } else if (type === "response.complete") {
+    allowedKeys(data, ["finishReason", "snapshot", "checksum"], "event.data");
+    if (!["stop", "length", "content-filter", "error", "other"].includes(String(data.finishReason))) {
+      throw new Error("event.data.finishReason is unsupported");
+    }
+    config(data.snapshot, "event.data.snapshot");
+    string(data.checksum, "event.data.checksum");
+  } else if (type === "response.warning") {
+    allowedKeys(data, ["warning"], "event.data");
+    const warning = record(data.warning, "event.data.warning");
+    allowedKeys(warning, ["code", "category", "message", "sceneId", "recoverable"], "event.data.warning");
+    if (!(String(warning.code) in VIDEO_WARNING_CATEGORIES)) {
+      throw new Error("event.data.warning.code is unsupported");
+    }
+    const expectedCategory = VIDEO_WARNING_CATEGORIES[warning.code];
+    if (warning.category !== expectedCategory) {
+      throw new Error(`event.data.warning.category must be ${expectedCategory} for ${String(warning.code)}`);
+    }
+    publicDiagnostic(warning.message, "event.data.warning.message");
+    if (warning.sceneId != null) {
+      const sceneId = string(warning.sceneId, "event.data.warning.sceneId");
+      if (sceneId.length > 128) throw new Error("event.data.warning.sceneId must be at most 128 characters");
+    }
+    if (typeof warning.recoverable !== "boolean") throw new Error("event.data.warning.recoverable must be boolean");
+  } else if (type === "response.error") {
+    allowedKeys(data, ["error", "terminal", "snapshot"], "event.data");
+    const error = record(data.error, "event.data.error");
+    allowedKeys(error, ["code", "message", "recoverable"], "event.data.error");
+    if (!["generation_failed", "invalid_generated_part"].includes(String(error.code))) {
+      throw new Error("event.data.error.code is unsupported");
+    }
+    publicDiagnostic(error.message, "event.data.error.message");
+    if (typeof error.recoverable !== "boolean") throw new Error("event.data.error.recoverable must be boolean");
+    if (typeof data.terminal !== "boolean") throw new Error("event.data.terminal must be boolean");
+    if (data.snapshot != null) config(data.snapshot, "event.data.snapshot");
+  } else if (type === "response.abort") {
+    allowedKeys(data, ["reason", "snapshot"], "event.data");
+    publicDiagnostic(data.reason, "event.data.reason");
+    if (data.snapshot != null) config(data.snapshot, "event.data.snapshot");
+  }
+}
+function parseVideoEvent(value) {
+  const event = record(value, "event");
+  allowedKeys(event, ["protocolVersion", "runId", "sequence", "eventId", "type", "data"], "event");
+  if (event.protocolVersion !== VIDEO_PROTOCOL_VERSION) {
+    throw new Error(`event.protocolVersion must be ${VIDEO_PROTOCOL_VERSION}`);
+  }
+  const runId = string(event.runId, "event.runId");
+  const sequence = nonNegativeInteger(event.sequence, "event.sequence");
+  const eventId = string(event.eventId, "event.eventId");
+  if (eventId !== `${runId}:${sequence}`) {
+    throw new Error("event.eventId must equal `${runId}:${sequence}`");
+  }
+  const type = string(event.type, "event.type");
+  if (CORE_EVENT_TYPES.has(type)) {
+    validateCoreData(type, event.data);
+  } else if (type.startsWith("data.") && type.length > "data.".length) {
+    jsonValue(event.data, "event.data");
+  } else {
+    throw new Error(`event.type ${type} is unsupported`);
+  }
+  return event;
+}
+function parseVideoPlanPart(value) {
+  const part = record(value, "plan part");
+  const type = string(part.type, "plan part.type");
+  if (type === "scene.add") {
+    allowedKeys(part, ["type", "scene"], "plan part");
+    scene(part.scene, "plan part.scene");
+  } else if (type === "scene.patch") {
+    allowedKeys(part, ["type", "sceneId", "patch"], "plan part");
+    string(part.sceneId, "plan part.sceneId");
+    scenePatch(part.patch, "plan part.patch");
+  } else if (type === "asset.patch") {
+    allowedKeys(part, ["type", "sceneId", "variables"], "plan part");
+    string(part.sceneId, "plan part.sceneId");
+    record(part.variables, "plan part.variables");
+    jsonValue(part.variables, "plan part.variables");
+  } else if (type === "plan.complete") {
+    allowedKeys(part, ["type", "finishReason"], "plan part");
+    if (part.finishReason != null && !["stop", "length", "content-filter", "other"].includes(String(part.finishReason))) {
+      throw new Error("plan part.finishReason is unsupported");
+    }
+  } else if (type === "plan.error") {
+    allowedKeys(part, ["type", "error"], "plan part");
+    const error = record(part.error, "plan part.error");
+    allowedKeys(error, ["message", "code", "recoverable"], "plan part.error");
+    string(error.message, "plan part.error.message");
+    if (error.code != null) string(error.code, "plan part.error.code");
+    if (error.recoverable != null && typeof error.recoverable !== "boolean") {
+      throw new Error("plan part.error.recoverable must be boolean");
+    }
+  } else {
+    throw new Error(`plan part.type ${type} is unsupported`);
+  }
+  return part;
+}
+
+export {
+  safePublicDiagnostic,
+  parseVideoEvent,
+  parseVideoPlanPart
+};

package/dist/chunk-EVG2ZYIY.js

@@ -0,0 +1,125 @@
+// src/server/pacing.ts
+var DEFAULT_SCENE_DURATION_SEC = 5;
+var MINIMUM_CLOSER_RESERVE_SEC = 3;
+var PACING_PLANNER_RULES = [
+  "Use each template's preferredDuration when no explicit duration is needed, and never request less than minDuration.",
+  "Track the cumulative duration budget before emitting every scene; the runtime omits scenes that cannot remain readable.",
+  `Reserve at least ${MINIMUM_CLOSER_RESERVE_SEC} seconds for a final ask when the catalog includes jobs:[ask], and emit that ask last.`
+];
+var WORDS_PER_SECOND = 4.5;
+var CHARACTERS_PER_SECOND = 12.5;
+var ITEM_BASE_SECONDS = 2;
+var SECONDS_PER_ITEM = 1;
+var DURATION_QUANTUM_SEC = 0.25;
+function roundDuration(value) {
+  return Math.ceil(value / DURATION_QUANTUM_SEC) * DURATION_QUANTUM_SEC;
+}
+function mergeSchemaDefaults(variables, metadata) {
+  const merged = { ...variables };
+  for (const [name, property] of Object.entries(metadata?.schema?.properties ?? {})) {
+    if (merged[name] === void 0 && property.default !== void 0) merged[name] = property.default;
+  }
+  return merged;
+}
+function fieldValue(value, path) {
+  return path.split(".").reduce((current, segment) => {
+    if (!current || typeof current !== "object" || Array.isArray(current)) return void 0;
+    return current[segment];
+  }, value);
+}
+function stringsIn(value) {
+  if (typeof value === "string") return value.trim() ? [value.trim()] : [];
+  if (Array.isArray(value)) return value.flatMap(stringsIn);
+  if (value && typeof value === "object") return Object.values(value).flatMap(stringsIn);
+  return [];
+}
+function itemCount(value) {
+  if (Array.isArray(value)) return value.length;
+  if (value && typeof value === "object") return Object.keys(value).length;
+  return value == null || value === "" ? 0 : 1;
+}
+function getReadableSceneDuration(scene, metadata) {
+  const minimum = Math.max(1e-3, metadata?.minDuration ?? 1);
+  const timing = metadata?.timing;
+  if (!timing) return roundDuration(minimum);
+  const variables = mergeSchemaDefaults(scene.variables, metadata);
+  const values = timing.contentFields.map((field) => fieldValue(variables, field));
+  let estimate;
+  if (timing.contentUnit === "items") {
+    estimate = ITEM_BASE_SECONDS + values.reduce(
+      (total, value) => total + itemCount(value),
+      0
+    ) * SECONDS_PER_ITEM;
+  } else {
+    const content = values.flatMap(stringsIn);
+    const units = timing.contentUnit === "words" ? content.reduce((total, value) => total + (value.match(/\S+/gu)?.length ?? 0), 0) : content.reduce((total, value) => total + [...value].length, 0);
+    estimate = 1 + units / (timing.contentUnit === "words" ? WORDS_PER_SECOND : CHARACTERS_PER_SECOND);
+  }
+  return roundDuration(Math.max(minimum, estimate));
+}
+function getCloserReserve(templateIds, getTemplatePacing) {
+  if (!templateIds || !getTemplatePacing) return 0;
+  const askDurations = templateIds.map((id) => getTemplatePacing(id)).filter((metadata) => metadata?.jobs?.includes("ask")).map((metadata) => Math.max(
+    metadata?.minDuration ?? MINIMUM_CLOSER_RESERVE_SEC,
+    metadata?.preferredDuration ?? 0
+  ));
+  return askDurations.length === 0 ? 0 : Math.max(MINIMUM_CLOSER_RESERVE_SEC, ...askDurations);
+}
+function requestedStart(scene, audio, priorEnd) {
+  const beatStart = scene.timing.beatStart == null ? void 0 : audio?.beatMarkers[scene.timing.beatStart]?.time;
+  return scene.timing.startTime ?? beatStart ?? priorEnd;
+}
+function requestedDuration(scene, metadata, audio, priorEnd) {
+  const beatEnd = scene.timing.beatEnd == null ? void 0 : audio?.beatMarkers[scene.timing.beatEnd]?.time;
+  const statedStart = requestedStart(scene, audio, priorEnd);
+  const statedEnd = scene.timing.endTime ?? beatEnd;
+  if (statedEnd != null) return Math.max(1e-3, statedEnd - statedStart);
+  return Math.max(1e-3, scene.timing.fixedDuration ?? metadata?.preferredDuration ?? DEFAULT_SCENE_DURATION_SEC);
+}
+function warning(code, message, sceneId) {
+  return { code, category: "readability", message, sceneId, recoverable: true };
+}
+function paceScene(scene, options) {
+  const metadata = options.getTemplatePacing?.(scene.templateId);
+  const isAsk = metadata?.jobs?.includes("ask") === true;
+  const priorEnd = options.previousScenes.at(-1)?.timing.endTime ?? 0;
+  const ceiling = isAsk ? options.maxDurationSec : Math.max(0, options.maxDurationSec - options.closerReserveSec);
+  const remaining = Math.max(0, ceiling - priorEnd);
+  const readableMinimum = getReadableSceneDuration(scene, metadata);
+  if (remaining < readableMinimum) {
+    const reservedForCloser = !isAsk && options.closerReserveSec > 0 && options.maxDurationSec - priorEnd >= readableMinimum;
+    return {
+      warnings: [warning(
+        reservedForCloser ? "scene_omitted_for_closer" : "scene_omitted_unreadable",
+        reservedForCloser ? "Scene was omitted to preserve room for a readable final action." : "Scene was omitted because it could not fit at a readable duration.",
+        scene.id
+      )]
+    };
+  }
+  const requested = requestedDuration(scene, metadata, options.audio, priorEnd);
+  const duration = Math.min(Math.max(requested, readableMinimum), remaining);
+  const adjusted = Math.abs(duration - requested) > 1e-6 || Math.abs(requestedStart(scene, options.audio, priorEnd) - priorEnd) > 1e-6;
+  return {
+    scene: {
+      ...scene,
+      timing: {
+        ...scene.timing,
+        startTime: priorEnd,
+        endTime: priorEnd + duration,
+        ...scene.timing.fixedDuration != null ? { fixedDuration: duration } : {}
+      }
+    },
+    warnings: adjusted ? [warning(
+      "scene_duration_adjusted",
+      "Scene duration was adjusted to preserve readable pacing.",
+      scene.id
+    )] : []
+  };
+}
+
+export {
+  PACING_PLANNER_RULES,
+  getReadableSceneDuration,
+  getCloserReserve,
+  paceScene
+};

package/dist/chunk-FNAEQ7QO.js

@@ -0,0 +1,155 @@
+// src/visual-system/scene-templates/tokens.ts
+var TOKEN_DEFAULTS = {
+  /** Primary brand colour — CTA, highlights. */
+  primary: "#00E5A0",
+  /** Deepest background surface. */
+  surface: "#0A0A14",
+  /** Elevated card / panel surface. */
+  surfaceElevated: "#14152A",
+  /** Primary text color. */
+  foreground: "#FFFFFF",
+  /** Muted text — labels, footers, supporting copy. */
+  muted: "#A7A6B0",
+  /** Primary sans font family (first name of the stack). */
+  font: "Inter",
+  /** Script accent font family for handwritten callouts. */
+  scriptFont: "Caveat"
+};
+function fontStack(styleFont) {
+  return `${(styleFont || "").split(",")[0].trim() || TOKEN_DEFAULTS.font}, -apple-system, BlinkMacSystemFont, "Helvetica Neue", Helvetica, Arial, sans-serif`;
+}
+var STYLE_PRESETS = {
+  bold: {
+    id: "bold",
+    useWhen: "The default. Drifting two-color brand mesh, heavy tight headlines at the top. Launches, hype, product moments \u2014 the loudest of the three.",
+    background: "mesh",
+    titlePlacement: "title-top",
+    type: { weightDelta: 0, trackingDeltaEm: 0, sizeScale: 1 }
+  },
+  editorial: {
+    id: "editorial",
+    useWhen: "Calm vertical wash, lighter and wider-tracked headlines, centered. Reviews, thoughtful updates, premium or B2B brands \u2014 when the copy should feel considered rather than shouted.",
+    background: "wash",
+    titlePlacement: "title-center",
+    type: { weightDelta: -200, trackingDeltaEm: 0.01, sizeScale: 1.08 }
+  },
+  stark: {
+    id: "stark",
+    useWhen: "Single hard spotlight on near-black, uppercase and tightly tracked. Dev tools, technical claims, high-contrast statements \u2014 maximum weight on very few words.",
+    background: "spotlight",
+    titlePlacement: "title-top",
+    type: { weightDelta: 100, trackingDeltaEm: -0.01, sizeScale: 1, transform: "uppercase" }
+  }
+};
+var DEFAULT_PRESET_ID = "bold";
+var PRESET_IDS = Object.keys(STYLE_PRESETS);
+function resolvePreset(id) {
+  return id && STYLE_PRESETS[id] || STYLE_PRESETS[DEFAULT_PRESET_ID];
+}
+var DENSITY_SCALES = {
+  airy: {
+    id: "airy",
+    useWhen: "Smaller headlines held further off the frame edges. Premium, considered, editorial \u2014 when the copy should have room to breathe.",
+    typeScale: 0.92,
+    safeZoneScale: 1.3
+  },
+  normal: {
+    id: "normal",
+    useWhen: "The default. No change to type size or frame padding.",
+    typeScale: 1,
+    safeZoneScale: 1
+  },
+  packed: {
+    id: "packed",
+    useWhen: "Bigger headlines pushed closer to the edges. Dense, urgent, information-heavy \u2014 when the frame should feel full.",
+    typeScale: 1.08,
+    safeZoneScale: 0.8
+  }
+};
+var MOTION_SCALES = {
+  calm: {
+    id: "calm",
+    useWhen: "Slower entrances and exits \u2014 text eases in rather than arriving. Founder stories, sober data, anything reflective.",
+    phaseScale: 1.4
+  },
+  normal: {
+    id: "normal",
+    useWhen: "The default. Archetype timings as authored.",
+    phaseScale: 1
+  },
+  punchy: {
+    id: "punchy",
+    useWhen: "Snappier entrances and exits \u2014 text lands fast and clears fast. Hype, launches, hot takes.",
+    phaseScale: 0.7
+  }
+};
+var DEFAULT_DENSITY_ID = "normal";
+var DEFAULT_MOTION_ID = "normal";
+var DENSITY_IDS = Object.keys(DENSITY_SCALES);
+var MOTION_IDS = Object.keys(MOTION_SCALES);
+function resolveDensity(id) {
+  return id && DENSITY_SCALES[id] || DENSITY_SCALES[DEFAULT_DENSITY_ID];
+}
+function resolveMotion(id) {
+  return id && MOTION_SCALES[id] || MOTION_SCALES[DEFAULT_MOTION_ID];
+}
+function resolveTokens(style) {
+  const brand = style.brand;
+  const preset = resolvePreset(style.preset);
+  const density = resolveDensity(style.density);
+  const motion = resolveMotion(style.motion);
+  const composedPreset = {
+    ...preset,
+    type: {
+      ...preset.type,
+      sizeScale: preset.type.sizeScale * density.typeScale,
+      phaseScale: motion.phaseScale
+    }
+  };
+  return {
+    primary: brand.colors.primary,
+    secondary: brand.colors.secondary,
+    background: brand.background,
+    surface: brand.colors.surface,
+    surfaceElevated: brand.colors.surfaceElevated,
+    foreground: brand.colors.foreground,
+    muted: brand.colors.muted,
+    font: fontStack(brand.font),
+    scriptFont: brand.scriptFont,
+    logoUrl: brand.logoUrl,
+    name: brand.name,
+    preset: composedPreset,
+    density,
+    motion
+  };
+}
+function darken(hex, factor) {
+  if (!hex.startsWith("#") || hex.length !== 4 && hex.length !== 7) {
+    return hex;
+  }
+  const full = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
+  const ch = (i) => Math.max(0, Math.round(parseInt(full.slice(i, i + 2), 16) * (1 - factor))).toString(16).padStart(2, "0");
+  return `#${ch(1)}${ch(3)}${ch(5)}`;
+}
+function lighten(hex, factor) {
+  if (!hex.startsWith("#") || hex.length !== 4 && hex.length !== 7) {
+    return hex;
+  }
+  const full = hex.length === 4 ? `#${hex[1]}${hex[1]}${hex[2]}${hex[2]}${hex[3]}${hex[3]}` : hex;
+  const r = parseInt(full.slice(1, 3), 16);
+  const g = parseInt(full.slice(3, 5), 16);
+  const b = parseInt(full.slice(5, 7), 16);
+  const lr = Math.min(255, Math.round(r + (255 - r) * factor));
+  const lg = Math.min(255, Math.round(g + (255 - g) * factor));
+  const lb = Math.min(255, Math.round(b + (255 - b) * factor));
+  return `#${lr.toString(16).padStart(2, "0")}${lg.toString(16).padStart(2, "0")}${lb.toString(16).padStart(2, "0")}`;
+}
+
+export {
+  TOKEN_DEFAULTS,
+  fontStack,
+  resolveDensity,
+  resolveTokens,
+  darken,
+  lighten
+};