@cueframe/kernel 0.2.57 → 0.2.58

package/dist/chunk-PWWZTY3G.js

@@ -0,0 +1,254 @@
+import {
+  GraphicRole,
+  OpaqueId
+} from "./chunk-UFD4EZHM.js";
+import {
+  brandKitCaptionFaceIssues
+} from "./chunk-OOL7ZUG7.js";
+
+// ../composition/src/validators/brandKit.ts
+import { z } from "zod";
+var EasingValue = z.union([
+  z.enum(["linear", "ease", "ease-in", "ease-out", "ease-in-out"]),
+  z.object({
+    kind: z.literal("cubic-bezier"),
+    x1: z.number().min(0).max(1),
+    y1: z.number(),
+    x2: z.number().min(0).max(1),
+    y2: z.number()
+  })
+]);
+var AudioPaletteRef = z.string().min(1);
+var FontRef = z.union([
+  z.object({
+    kind: z.literal("system"),
+    family: z.string().min(1),
+    weight: z.number().int().min(1).max(1e3).optional(),
+    style: z.enum(["normal", "italic"]).optional()
+  }),
+  z.object({
+    kind: z.literal("web"),
+    family: z.string().min(1),
+    url: z.string().url().optional(),
+    weight: z.number().int().min(1).max(1e3).optional(),
+    style: z.enum(["normal", "italic"]).optional()
+  }),
+  z.object({
+    kind: z.literal("uploaded"),
+    fontId: OpaqueId,
+    family: z.string().optional(),
+    weight: z.number().int().min(1).max(1e3).optional(),
+    style: z.enum(["normal", "italic"]).optional()
+  })
+]);
+var Colors = z.object({
+  primary: z.string().min(1),
+  secondary: z.string().optional(),
+  accent: z.string().min(1),
+  background: z.string().min(1),
+  text: z.string().min(1),
+  textMuted: z.string().optional(),
+  border: z.string().optional(),
+  surface: z.string().optional(),
+  card: z.string().optional(),
+  gridLine: z.string().optional(),
+  accentMuted: z.string().optional(),
+  textOnAccent: z.string().optional(),
+  textOnSurface: z.string().optional()
+});
+var Fonts = z.object({
+  heading: FontRef,
+  body: FontRef.optional(),
+  caption: FontRef.optional()
+});
+var Spacing = z.object({
+  base: z.number().positive().optional(),
+  lg: z.number().positive().optional(),
+  sm: z.number().positive().optional()
+});
+var Sizing = z.object({
+  fontSizeHeading: z.number().positive().optional(),
+  fontSizeBody: z.number().positive().optional(),
+  fontSizeLabel: z.number().positive().optional(),
+  borderRadius: z.number().nonnegative().optional()
+});
+var Motion = z.object({
+  duration: z.number().positive().optional(),
+  easing: EasingValue.optional(),
+  entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+  staggerMs: z.number().nonnegative().optional(),
+  exitMs: z.number().nonnegative().optional()
+});
+var Placement = z.enum(["tl", "tr", "bl", "br"]);
+var Logo = z.object({
+  src: z.string().min(1),
+  alt: z.string().optional(),
+  placement: Placement.optional(),
+  sizePct: z.number().positive().optional()
+});
+var IntroOutro = z.object({
+  kind: z.enum(["card", "video"]),
+  src: z.string().min(1).optional(),
+  title: z.string().optional(),
+  subtitle: z.string().optional(),
+  durationMs: z.number().positive().optional()
+});
+var Watermark = z.object({
+  src: z.string().min(1),
+  opacity: z.number().min(0).max(1).optional(),
+  placement: Placement.optional()
+});
+var MotifBody = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("card"),
+    html: z.string().min(1),
+    tokens: z.record(z.string(), z.string()).optional()
+  }),
+  z.object({
+    kind: z.literal("overlay"),
+    primitiveId: z.string().min(1),
+    params: z.record(z.string(), z.unknown()).optional()
+  }),
+  z.object({
+    kind: z.literal("component"),
+    componentId: z.string().min(1),
+    props: z.record(z.string(), z.unknown()).optional()
+  })
+]);
+var MotifMotionPreset = z.enum([
+  "fade-up",
+  "slide-in-left",
+  "slide-in-right",
+  "scale-pop",
+  "stagger-reveal"
+]);
+var Motif = z.object({
+  id: z.string().min(1).max(40),
+  observed: z.string().min(1).max(500),
+  body: MotifBody,
+  motion: z.object({
+    preset: MotifMotionPreset,
+    enterMs: z.number().int().min(0).max(5e3).optional(),
+    exitMs: z.number().int().min(0).max(5e3).optional(),
+    staggerMs: z.number().int().min(0).max(2e3).optional(),
+    confidence: z.enum(["high", "low"]).optional()
+  }).optional(),
+  role: GraphicRole,
+  zone: z.object({ x: z.number(), y: z.number(), w: z.number(), h: z.number() }).optional(),
+  evidence: z.array(z.number().int().min(0)).max(24).optional(),
+  diffScore: z.number().min(0).max(1).optional(),
+  coverage: z.enum(["reproduced", "approximated", "skipped"]),
+  skipReason: z.string().max(300).optional()
+});
+var AccessControl = z.object({
+  public: z.boolean().optional(),
+  readerOrgIds: z.array(z.string()).optional(),
+  writerOrgIds: z.array(z.string()).optional()
+});
+var LicenseDeclaration = z.object({
+  type: z.string().min(1),
+  source: z.string().optional(),
+  notes: z.string().optional()
+});
+var BrandKit = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  colors: Colors,
+  fonts: Fonts,
+  syncCaptions: z.boolean().optional(),
+  spacing: Spacing.optional(),
+  sizing: Sizing.optional(),
+  motion: Motion.optional(),
+  captionProfile: z.object({
+    color: z.string().optional(),
+    highlightColor: z.string().optional(),
+    emphasisColor: z.string().optional(),
+    plate: z.enum(["glass", "solid", "none"]).optional(),
+    entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+    entranceMs: z.number().optional(),
+    entranceStaggerMs: z.number().optional(),
+    exitMs: z.number().optional(),
+    fontFamily: z.string().optional(),
+    // The ordinary run's weight. The profile could name a caption family but never how heavy it
+    // was drawn, so the only answer to "that weight has no file behind it" was to change the
+    // family. A family that does not declare this weight is still refused here — but now at a
+    // field the author can set, and a family that ships it needs no setting at all: every
+    // bundled family declares a base and an emphasis weight it has bytes for.
+    fontWeight: z.number().int().min(100).max(900).multipleOf(100).optional(),
+    emphasisFontFamily: z.string().optional(),
+    emphasisScale: z.number().positive().optional(),
+    // A CSS weight, and the profile is projected straight onto the caption style, so it is held
+    // to the same range the composition holds `emphasisFontWeight` to. An unbounded number here
+    // was a hole: 0 or 1500 named no face at all.
+    emphasisFontWeight: z.number().int().min(100).max(900).optional(),
+    emphasisFontStyle: z.enum(["normal", "italic"]).optional(),
+    emphasisTextTransform: z.enum(["none", "uppercase"]).optional(),
+    emphasisLetterSpacing: z.number().optional(),
+    emphasisPlate: z.boolean().optional(),
+    emphasisPlateColor: z.string().optional(),
+    emphasisPlateTextColor: z.string().optional()
+  }).optional(),
+  exemplarKeys: z.array(z.string().min(1)).max(24).optional(),
+  contactSheetKey: z.string().min(1).optional(),
+  motifs: z.array(Motif).max(24).optional(),
+  styleRubric: z.string().max(4e3).optional(),
+  density: z.object({
+    graphicsPerMin: z.number().min(0).max(60),
+    maxSimultaneous: z.number().int().min(1).max(6)
+  }).optional(),
+  inspiration: z.object({
+    sources: z.array(z.string()).min(1).max(24),
+    extractedAt: z.number(),
+    extractionVersion: z.string().min(1).max(60)
+  }).optional(),
+  logo: Logo.optional(),
+  intro: IntroOutro.optional(),
+  outro: IntroOutro.optional(),
+  watermark: Watermark.optional(),
+  audio: z.object({
+    sfxIntensity: z.enum(["off", "light", "standard", "dense"]).optional(),
+    musicEnabled: z.boolean().optional(),
+    musicMood: z.string().max(300).optional(),
+    sonicLogo: z.object({
+      ref: AudioPaletteRef,
+      placement: z.enum(["intro", "outro", "both"]),
+      offsetMs: z.number().int().min(0).max(1e4).optional()
+    }).optional(),
+    uiSoundSet: z.object({
+      tick: AudioPaletteRef.optional(),
+      pop: AudioPaletteRef.optional(),
+      impact: AudioPaletteRef.optional(),
+      confirm: AudioPaletteRef.optional(),
+      error: AudioPaletteRef.optional(),
+      whoosh: AudioPaletteRef.optional(),
+      riser: AudioPaletteRef.optional()
+    }).optional(),
+    bedStyle: z.object({
+      bedId: AudioPaletteRef.optional(),
+      genre: z.string().max(120).optional(),
+      bpmRange: z.object({ min: z.number(), max: z.number() }).optional()
+    }).optional(),
+    ambiencePreference: z.object({ ref: AudioPaletteRef }).nullable().optional()
+  }).optional(),
+  license: LicenseDeclaration.optional(),
+  licenseVerification: z.enum([
+    "attested",
+    "cueframe-verified",
+    "third-party-verified"
+  ]).optional(),
+  ownerOrgId: z.string().optional(),
+  acl: AccessControl.optional()
+}).superRefine((kit, ctx) => {
+  for (const issue of brandKitCaptionFaceIssues(kit)) {
+    ctx.addIssue({ code: "custom", path: issue.path.split("."), message: issue.message });
+  }
+});
+
+export {
+  EasingValue,
+  AudioPaletteRef,
+  FontRef,
+  MotifMotionPreset,
+  Motif,
+  BrandKit
+};

package/dist/chunk-REST55RC.js

@@ -0,0 +1,366 @@
+import {
+  BrandKitBodySchema
+} from "./chunk-TR53N6HB.js";
+import {
+  ComponentSourceV2
+} from "./chunk-EC6VFQE6.js";
+import {
+  Composition
+} from "./chunk-UFD4EZHM.js";
+import {
+  SceneShotSpecV2,
+  sceneShotImageSlots,
+  sceneShotVideoSlots
+} from "./chunk-CL5Y6V6K.js";
+
+// ../execution/component-runtime/src/template/schema.ts
+import { z } from "zod";
+var TEMPLATE_MAX_BYTES = 1048576;
+var MATTE_KEY = /^[a-f0-9]{12}$/;
+var name = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var slug = z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be kebab-case").max(80);
+var preparedMatte = z.object({
+  url: z.string().url(),
+  sha256: z.string().regex(/^[a-f0-9]{64}$/),
+  mimeType: z.literal("video/mp4"),
+  bakeVersion: z.string().min(1),
+  presenceFraction: z.number().min(0).max(1).optional()
+}).strict();
+var base = { name, required: z.boolean(), label: z.string().max(120).optional() };
+var TemplateParameterSchema = z.discriminatedUnion("type", [
+  z.object({ ...base, type: z.literal("string"), default: z.string().optional(), maxLength: z.number().int().positive().optional() }).strict(),
+  z.object({ ...base, type: z.literal("number"), default: z.number().optional(), min: z.number().optional(), max: z.number().optional() }).strict(),
+  z.object({ ...base, type: z.literal("color"), default: z.string().optional() }).strict(),
+  z.object({ ...base, type: z.literal("url"), default: z.string().optional() }).strict(),
+  z.object({ ...base, type: z.literal("enum"), options: z.array(z.string().min(1)).min(1), default: z.string().optional() }).strict().superRefine((p, ctx) => {
+    if (p.default !== void 0 && !p.options.includes(p.default)) {
+      ctx.addIssue({ code: "custom", path: ["default"], message: `${p.name}: enum default must be one of options` });
+    }
+  }),
+  z.object({ ...base, type: z.literal("boolean"), default: z.boolean().optional() }).strict(),
+  z.object({
+    ...base,
+    type: z.literal("media"),
+    kind: z.enum(["video", "image", "audio"]),
+    default: z.string().optional(),
+    prepared: z.object({ mattes: z.record(z.string().regex(MATTE_KEY, "mattes keys are 12 lowercase hex chars"), preparedMatte).optional() }).strict().optional(),
+    sample: z.object({
+      url: z.string().url().startsWith("https://"),
+      sha256: z.string().regex(/^[a-f0-9]{64}$/, "sample sha256 is 64 hex chars"),
+      mimeType: z.string().min(1),
+      durationSec: z.number().positive().optional()
+    }).strict().optional()
+  }).strict()
+]);
+var PRESET_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function coerceParameterValue(param, raw) {
+  switch (param.type) {
+    case "string": {
+      if (typeof raw !== "string") return { ok: false, reason: "expected a string" };
+      if (param.maxLength !== void 0 && raw.length > param.maxLength) return { ok: false, reason: `longer than ${param.maxLength}` };
+      return { ok: true, value: raw };
+    }
+    case "number": {
+      const n = typeof raw === "string" && raw.trim() !== "" ? Number(raw) : raw;
+      if (typeof n !== "number" || Number.isNaN(n)) return { ok: false, reason: "expected a number" };
+      if (param.min !== void 0 && n < param.min) return { ok: false, reason: `below ${param.min}` };
+      if (param.max !== void 0 && n > param.max) return { ok: false, reason: `above ${param.max}` };
+      return { ok: true, value: n };
+    }
+    case "color":
+      return typeof raw === "string" && /^#[0-9a-fA-F]{6}([0-9a-fA-F]{2})?$/.test(raw) ? { ok: true, value: raw } : { ok: false, reason: "expected #rrggbb" };
+    case "url": {
+      try {
+        const { protocol } = new URL(String(raw));
+        if (protocol === "https:" || protocol === "http:") return { ok: true, value: String(raw) };
+      } catch {
+      }
+      return { ok: false, reason: "expected an http(s) URL" };
+    }
+    case "enum":
+      return typeof raw === "string" && param.options.includes(raw) ? { ok: true, value: raw } : { ok: false, reason: `expected one of ${param.options.join(", ")}` };
+    case "boolean": {
+      if (typeof raw === "boolean") return { ok: true, value: raw };
+      if (raw === "true" || raw === "false") return { ok: true, value: raw === "true" };
+      return { ok: false, reason: "expected true or false" };
+    }
+    case "media":
+      return typeof raw === "string" && raw.length > 0 ? { ok: true, value: raw } : { ok: false, reason: "expected a media id" };
+  }
+}
+var TemplateBrandKitSchema = BrandKitBodySchema.superRefine((kit, ctx) => {
+  const sources = { logo: kit.logo?.src, watermark: kit.watermark?.src, intro: kit.intro?.src, outro: kit.outro?.src };
+  for (const [field, src] of Object.entries(sources)) {
+    if (src !== void 0 && !src.startsWith("https://")) {
+      ctx.addIssue({ code: "custom", path: [field, "src"], message: `${field}.src must be an https URL; a template kit never names a storage key` });
+    }
+  }
+});
+var TemplatePresetSchema = z.object({
+  label: z.string().min(1).max(120),
+  values: z.record(z.string(), z.unknown()),
+  brandKit: TemplateBrandKitSchema.optional(),
+  gallery: z.object({ poster: z.string().url().optional(), render: z.string().url().optional(), description: z.string().max(2e3).optional() }).strict().optional()
+}).strict();
+var TemplateComponentSchema = z.object({
+  source: ComponentSourceV2,
+  name: z.string().min(1).max(120),
+  description: z.string().min(1).max(2e3),
+  category: z.enum(["text", "effects", "transitions", "layouts", "backgrounds", "ui-blocks", "scenes"]),
+  propSchema: z.record(z.string(), z.unknown())
+}).strict();
+var TemplateDocumentSchema = z.object({
+  v: z.literal(1),
+  slug,
+  name: z.string().min(1).max(120),
+  description: z.string().max(2e3).optional(),
+  composition: Composition,
+  parameters: z.array(TemplateParameterSchema).superRefine((ps, ctx) => {
+    const seen = /* @__PURE__ */ new Set();
+    ps.forEach((p, i) => {
+      const issue = (message) => ctx.addIssue({ code: "custom", path: [i], message: `${p.name}: ${message}` });
+      if (seen.has(p.name)) issue("duplicate parameter");
+      seen.add(p.name);
+      if (p.type === "number" && p.min !== void 0 && p.max !== void 0 && p.min > p.max) issue("min is above max");
+      if (p.type === "enum") for (const o of new Set(p.options.filter((o2, j) => p.options.indexOf(o2) !== j))) issue(`duplicate option ${o}`);
+      if (p.default !== void 0 && p.type !== "media" && p.type !== "enum") {
+        const r = coerceParameterValue(p, p.default);
+        if (!r.ok) issue(`default ${r.reason}`);
+      }
+    });
+  }),
+  components: z.record(z.string(), TemplateComponentSchema),
+  brandKit: TemplateBrandKitSchema.optional(),
+  rubric: z.string().optional(),
+  provenance: z.object({ label: z.string(), href: z.string().url().optional(), notes: z.string().optional() }).strict().optional(),
+  gallery: z.object({
+    status: z.enum(["published", "draft"]),
+    category: z.string().optional(),
+    format: z.string().optional(),
+    duration: z.string().optional(),
+    render: z.string().url().optional(),
+    poster: z.string().url().optional(),
+    prompt: z.string().optional(),
+    details: z.array(z.string()).optional(),
+    transcriptExcerpt: z.string().nullable().optional()
+  }).strict().optional(),
+  presets: z.record(z.string().regex(PRESET_NAME, "preset names are kebab-case"), TemplatePresetSchema).optional()
+}).strict().superRefine((doc, ctx) => {
+  const byName = new Map(doc.parameters.map((p) => [p.name, p]));
+  for (const [presetName, preset] of Object.entries(doc.presets ?? {})) {
+    for (const [key, raw] of Object.entries(preset.values)) {
+      const param = byName.get(key);
+      if (!param) {
+        ctx.addIssue({ code: "custom", path: ["presets", presetName, "values", key], message: `preset ${presetName} names undeclared parameter ${key}` });
+        continue;
+      }
+      if (param.type === "media") {
+        ctx.addIssue({ code: "custom", path: ["presets", presetName, "values", key], message: `preset ${presetName}: ${key} is a media parameter; presets never carry media` });
+        continue;
+      }
+      const r = coerceParameterValue(param, raw);
+      if (!r.ok) ctx.addIssue({ code: "custom", path: ["presets", presetName, "values", key], message: `preset ${presetName}: ${key} ${r.reason}` });
+    }
+  }
+});
+var TemplateError = class extends Error {
+  constructor(code, message, fields = []) {
+    super(message);
+    this.code = code;
+    this.fields = fields;
+  }
+  code;
+  fields;
+};
+function parseTemplateDocument(raw) {
+  const bytes = new TextEncoder().encode(JSON.stringify(raw)).byteLength;
+  if (bytes > TEMPLATE_MAX_BYTES) throw new TemplateError("payload_too_large", `template document exceeds 1 MiB (${bytes} bytes)`);
+  const r = TemplateDocumentSchema.safeParse(raw);
+  if (!r.success) throw new TemplateError("template_values_invalid", r.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
+  return r.data;
+}
+
+// ../execution/component-runtime/src/template/bind.ts
+var REF = /^\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
+var INLINE = /\\\{\{|\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}/g;
+var STRING_LEAF_ROOTS = ["source.props", "source.params", "source.html", "source.tokens", "source.mediaId", "source.assets", "metadata", "text"];
+var TYPED_VALUE_SITE = /^(tracks\.\d+\.contents\.\d+\.(source\.props|source\.params|metadata)|markers\.\d+\.metadata)(\.|$)/;
+var HTML_SITE = /^tracks\.\d+\.contents\.\d+\.source\.html$/;
+var MEDIA_SITE = /^tracks\.\d+\.contents\.\d+\.source\.(mediaId|assets\.[^.]+)$/;
+var OMIT = /* @__PURE__ */ Symbol("omit");
+function referenceAllowed(path) {
+  const p = path.join(".");
+  if (/^captions\./.test(p) && /\.text$/.test(p)) return true;
+  if (/^markers\.\d+\.metadata\b/.test(p)) return true;
+  const m = p.match(/^tracks\.\d+\.contents\.\d+\.(.*)$/);
+  return !!m && STRING_LEAF_ROOTS.some((root) => m[1] === root || m[1].startsWith(root + "."));
+}
+function findReferences(doc) {
+  const out = [];
+  const walk = (v, path) => {
+    if (typeof v === "string") {
+      const whole = v.match(REF);
+      if (whole) {
+        out.push({ path, name: whole[1], wholeLeaf: true });
+        return;
+      }
+      for (const m of v.matchAll(INLINE)) if (m[1] !== void 0) out.push({ path, name: m[1], wholeLeaf: false });
+    } else if (Array.isArray(v)) v.forEach((x, i) => walk(x, [...path, String(i)]));
+    else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) walk(x, [...path, k]);
+  };
+  walk(doc.composition, []);
+  return out;
+}
+function slotKind(doc, clip, slot) {
+  const component = doc.components[clip.source?.componentId];
+  if (component) return { kind: component.source.manifest.assets[slot]?.kind };
+  const scene = clip.source?.props?.scene;
+  if (scene === void 0) return {};
+  const parsed = SceneShotSpecV2.safeParse(scene);
+  if (!parsed.success) return { error: `clip ${clip.id} props.scene is not a scene-shot spec` };
+  return { kind: sceneShotImageSlots(parsed.data).includes(slot) ? "image" : sceneShotVideoSlots(parsed.data).includes(slot) ? "video" : void 0 };
+}
+function checkReferences(doc) {
+  const declared = new Map(doc.parameters.map((p) => [p.name, p]));
+  const refs = findReferences(doc);
+  const used = new Set(refs.map((r) => r.name));
+  const mediaSiteErrors = [];
+  for (const r of refs) {
+    const p = declared.get(r.name);
+    if (!p) continue;
+    const at = r.path.join(".");
+    const site = at.match(MEDIA_SITE);
+    if (p.type !== "media") {
+      if (site) mediaSiteErrors.push(`${r.name}: ${at} takes a media parameter`);
+      continue;
+    }
+    if (!site || !r.wholeLeaf) {
+      mediaSiteErrors.push(`${r.name}: media parameters bind only as a whole-leaf mediaId or asset slot`);
+      continue;
+    }
+    const clip = doc.composition.tracks[Number(r.path[1])].contents[Number(r.path[3])];
+    if (site[1] === "mediaId") {
+      if (!p.required) mediaSiteErrors.push(`${r.name}: a clip's mediaId needs a required media parameter`);
+      else if (clip.kind !== p.kind) mediaSiteErrors.push(`${r.name}: clip ${clip.id} is ${clip.kind}, parameter is ${p.kind}`);
+      continue;
+    }
+    const slot = r.path[r.path.length - 1];
+    const k = slotKind(doc, clip, slot);
+    if (k.error) mediaSiteErrors.push(`${r.name}: ${k.error}`);
+    else if (k.kind !== p.kind) mediaSiteErrors.push(`${r.name}: slot ${slot} of ${clip.source.componentId} is ${k.kind ?? "undeclared"}, parameter is ${p.kind}`);
+  }
+  return {
+    undeclared: [...new Set(refs.filter((r) => !declared.has(r.name)).map((r) => r.name))],
+    unused: doc.parameters.filter((p) => !used.has(p.name)).map((p) => p.name),
+    misplaced: refs.filter((r) => !referenceAllowed(r.path)).map((r) => r.path.join(".")),
+    mediaSiteErrors
+  };
+}
+var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+function bindTemplate(doc, values, media, opts = {}) {
+  const { undeclared, misplaced, mediaSiteErrors } = checkReferences(doc);
+  if (undeclared.length) throw new TemplateError("template_parameter_undeclared", `undeclared: ${undeclared.join(", ")}`);
+  if (misplaced.length || mediaSiteErrors.length) throw new TemplateError("template_values_invalid", [...misplaced.map((m) => `reference outside a string leaf: ${m}`), ...mediaSiteErrors].join("; "));
+  const byName = new Map(doc.parameters.map((p) => [p.name, p]));
+  const stray = [
+    ...Object.keys(values).filter((k) => byName.get(k) === void 0 || byName.get(k).type === "media"),
+    ...Object.keys(media).filter((k) => byName.get(k)?.type !== "media")
+  ];
+  if (stray.length) throw new TemplateError("template_parameter_undeclared", `not declared by this template: ${stray.join(", ")}`, stray.map((param) => ({ param, reason: "not declared" })));
+  let base2 = {};
+  if (opts.preset !== void 0) {
+    const preset = doc.presets?.[opts.preset];
+    if (!preset) throw new TemplateError("template_values_invalid", `unknown preset ${opts.preset}`, [{ param: "preset", reason: `unknown preset ${opts.preset}` }]);
+    base2 = preset.values;
+  }
+  const merged = { ...base2, ...values };
+  const fields = [];
+  const resolved = /* @__PURE__ */ new Map();
+  const swapped = /* @__PURE__ */ new Map();
+  for (const p of doc.parameters) {
+    if (p.type === "media") {
+      const m = media[p.name];
+      if (!m) {
+        if (p.required) fields.push({ param: p.name, reason: "required" });
+        continue;
+      }
+      if (m.kind !== p.kind) throw new TemplateError("template_media_kind_mismatch", `${p.name}: expected ${p.kind}, got ${m.kind}`, [{ param: p.name, reason: `expected ${p.kind}` }]);
+      resolved.set(p.name, m.mediaId);
+      swapped.set(m.mediaId, m);
+      continue;
+    }
+    const raw = merged[p.name];
+    if (raw === void 0) {
+      if (p.default !== void 0) resolved.set(p.name, p.default);
+      else if (p.required) fields.push({ param: p.name, reason: "required" });
+      continue;
+    }
+    const r = coerceParameterValue(p, raw);
+    if (r.ok) resolved.set(p.name, r.value);
+    else fields.push({ param: p.name, reason: r.reason });
+  }
+  for (const track of doc.composition.tracks) for (const clip of track.contents) {
+    const src = clip.source;
+    const ref = typeof src?.mediaId === "string" ? src.mediaId.match(REF)?.[1] : void 0;
+    const m = ref ? media[ref] : void 0;
+    if (m?.durationSec === void 0 || m.kind === "image" || src.loop) continue;
+    const excluded = (src.excludedRanges ?? []).reduce((sum, r) => sum + Math.max(0, r.end - r.start), 0);
+    const needs = src.trim ? src.trim.end : clip.duration * (src.playbackRate ?? 1) + excluded;
+    if (needs <= m.durationSec) continue;
+    fields.push({ param: ref, reason: src.trim ? `media is ${m.durationSec}s, template trims to ${src.trim.end}s` : `media is ${m.durationSec}s, clip needs ${needs}s` });
+  }
+  if (fields.length) throw new TemplateError("template_values_invalid", fields.map((f) => `${f.param}: ${f.reason}`).join("; "), fields);
+  const sub = (v, path) => {
+    if (typeof v === "string") {
+      const at = path.join(".");
+      const text = (x) => HTML_SITE.test(at) ? escapeHtml(String(x)) : String(x);
+      const whole = v.match(REF);
+      if (whole) {
+        const value = resolved.get(whole[1]);
+        if (value === void 0) return OMIT;
+        return TYPED_VALUE_SITE.test(at) ? value : text(value);
+      }
+      return v.replace(INLINE, (_, name2) => name2 === void 0 ? "{{" : text(resolved.get(name2) ?? ""));
+    }
+    if (Array.isArray(v)) {
+      return v.map((x, i) => {
+        const out2 = sub(x, [...path, String(i)]);
+        if (out2 === OMIT) fields.push({ param: String(x).match(REF)[1], reason: "required: it fills an array element" });
+        return out2;
+      });
+    }
+    if (v && typeof v === "object") {
+      return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, sub(x, [...path, k])]).filter(([, x]) => x !== OMIT));
+    }
+    return v;
+  };
+  const out = sub(doc.composition, []);
+  if (fields.length) throw new TemplateError("template_values_invalid", fields.map((f) => `${f.param}: ${f.reason}`).join("; "), fields);
+  for (const track of out.tracks) for (const clip of track.contents) {
+    if (swapped.get(clip.source?.mediaId)?.kind === "image") {
+      delete clip.source.trim;
+      delete clip.source.excludedRanges;
+      delete clip.source.playbackRate;
+      delete clip.source.reframe;
+    }
+  }
+  const valid = Composition.safeParse(out);
+  if (!valid.success) {
+    throw new TemplateError("template_values_invalid", `bound composition is invalid: ${valid.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+  }
+  return out;
+}
+
+export {
+  TEMPLATE_MAX_BYTES,
+  MATTE_KEY,
+  TemplateParameterSchema,
+  PRESET_NAME,
+  coerceParameterValue,
+  TemplateDocumentSchema,
+  TemplateError,
+  parseTemplateDocument,
+  findReferences,
+  checkReferences,
+  bindTemplate
+};