@cueframe/kernel 0.2.57 → 0.2.59-rc.0

package/dist/{chunk-VXGA7LQQ.js → chunk-IUJABAG2.js}

@@ -3,6 +3,10 @@ import {
   buildEasedZooms,
   buildPannedCenters
 } from "./chunk-QH3YI3ND.js";
+import {
+  flattenCompoundClips,
+  hasCompoundClips
+} from "./chunk-ZPJQ3TQL.js";
 import {
   DOMINANCE_WEIGHTS,
   ENTER_SEC,
@@ -20,26 +24,22 @@ import {
   scoreAndRank,
   segmentShots,
   stabilizeSelectionHysteresis
-} from "./chunk-JPMVNMF3.js";
-import {
-  flattenCompoundClips,
-  hasCompoundClips
-} from "./chunk-IMIUHG2E.js";
+} from "./chunk-3HLDIIWA.js";
 import {
   compositionHasVo,
   roleDefaultGainDb
-} from "./chunk-VZ7TYX6Z.js";
-import {
-  resolveBrandRef
-} from "./chunk-DKBFAQCW.js";
+} from "./chunk-P3EFZDM5.js";
 import {
   SHOT_SCALE_TARGET,
   shotScaleZoom
 } from "./chunk-WREYUH2E.js";
+import {
+  resolveBrandRef
+} from "./chunk-DKBFAQCW.js";
 import {
   CueframeError,
   encodeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-XQGQ5EFS.js";
 import {
   SCENE_CAPTURE_IDENTITY_FIELDS_V1,
   SCENE_PRESET_TRIANGLES,
@@ -2212,6 +2212,8 @@ async function assemblePreparedRenderInput(composition, resolved, dependencies)
 }
 
 // ../execution/core/src/render/exportSettings.ts
+var EXPORT_QUALITIES = ["maximum", "social", "web", "potato", "source"];
+var EXPORT_RESOLUTIONS = ["source", "1080p", "1440p", "4k"];
 var DEFAULT_FPS = 30;
 var DEFAULT_WIDTH = 1920;
 var DEFAULT_HEIGHT = 1080;
@@ -3222,6 +3224,8 @@ export {
   compositionToRenderInput,
   assembleRenderInput,
   assemblePreparedRenderInput,
+  EXPORT_QUALITIES,
+  EXPORT_RESOLUTIONS,
   DEFAULT_FPS,
   DEFAULT_WIDTH,
   DEFAULT_HEIGHT,

package/dist/{chunk-MZB4ZXYW.js → chunk-IVFMOHAC.js}

@@ -6,7 +6,7 @@ import {
 import {
   CueframeError,
   encodeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-XQGQ5EFS.js";
 
 // ../composition/src/projection/cardTokens.ts
 var CARD_MOTION_VAR_NAMES = [
@@ -206,13 +206,6 @@ function primaryClipForOverlay(composition, overlayId) {
   }
   return null;
 }
-async function behindReadinessForOverlay(input) {
-  const target = primaryClipForOverlay(input.composition, input.overlayId);
-  return behindReadinessForTarget(
-    target,
-    target ? input.mattesByMediaId[target.mediaId] : void 0
-  );
-}
 async function behindReadinessForTarget(target, mattes) {
   if (!target) return { state: "no-clip" };
   const key = await matteIntentKey({ ...target.window, subjectClass: "person" });
@@ -605,7 +598,6 @@ export {
   isCurrentMatteBakeVersion,
   matteIntentKey,
   primaryClipForOverlay,
-  behindReadinessForOverlay,
   behindReadinessForTarget,
   clipOverlapsBehind,
   matteWindowsByMediaId,

package/dist/{chunk-UKDBU7HM.js → chunk-JNBNDHEF.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-QGAWDLYX.js";
 import {
   DashboardPopulate
-} from "./chunk-S5H6GH6M.js";
+} from "./chunk-3Z7CN54H.js";
 import {
   useFrameScale
 } from "./chunk-QAGGJHAF.js";
@@ -35,7 +35,7 @@ import {
   TEXT_MUTED,
   VIOLET,
   WARNING
-} from "./chunk-W2245F6G.js";
+} from "./chunk-WTQRLFR2.js";
 import {
   CAMERA_PRESETS,
   DEFAULT_CAMERA,
@@ -43,7 +43,7 @@ import {
   makeDefaultScreenTexture,
   resolveCamera,
   useImageTexture
-} from "./chunk-FHMTAZD4.js";
+} from "./chunk-RWJHZCOR.js";
 import {
   DEVICE_GLASS_OPACITY_ENCODED,
   DeviceMesh,

package/dist/{chunk-JWMWVP64.js → chunk-KC4LNZL5.js}

@@ -1,7 +1,10 @@
 import {
   ComponentHostAttestationV2,
   ComponentRuntimeError
-} from "./chunk-EC6VFQE6.js";
+} from "./chunk-BZVOCVQV.js";
+import {
+  canonicalJson
+} from "./chunk-XHMKPTHV.js";
 import {
   STUDIO_SHADOW_MAP_BUDGET
 } from "./chunk-CL5Y6V6K.js";
@@ -46,14 +49,6 @@ async function readGpuAttestation(browser) {
     }).filter(([, value]) => value !== void 0 && value !== null && value !== "")
   );
   const hasDeviceOrDriverIdentity = Array.isArray(gpu?.devices) && gpu.devices.length > 0 || typeof aux.driverVendor === "string" && aux.driverVendor.length > 0 || typeof aux.driverVersion === "string" && aux.driverVersion.length > 0;
-  const canonicalJson = (value) => {
-    if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-    if (value !== null && typeof value === "object") {
-      const object = value;
-      return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(object[key])}`).join(",")}}`;
-    }
-    return JSON.stringify(value);
-  };
   return {
     renderer: typeof aux.glRenderer === "string" ? aux.glRenderer : "",
     featureStatus: gpu?.featureStatus ?? {},

package/dist/{chunk-GCQ7Z7S7.js → chunk-KKATUGRU.js}

@@ -1,11 +1,6 @@
-// ../authoring/src/models/defaultModels.ts
-var DEFAULT_MODEL_IDS = {
-  anthropic: "claude-opus-5",
-  openai: "gpt-4.1",
-  ollama: "llama3.1",
-  /** Cheaper model used for fast-mode / low-effort turns. */
-  fast: "claude-haiku-4-5"
-};
+import {
+  DEFAULT_MODEL_IDS
+} from "./chunk-CIOUDOGN.js";
 
 // ../authoring/src/models/modelFactory.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
@@ -106,7 +101,6 @@ function buildFastModel(settings, langfuse) {
 }
 
 export {
-  DEFAULT_MODEL_IDS,
   withRequestTimeout,
   makeLangfuseFetch,
   buildModel,

package/dist/{chunk-Q5P5UFOP.js → chunk-KLQ53NX3.js}

@@ -60,10 +60,22 @@ var PREVIEW_FRAME_CASES = [
 function isKnownRed(c, lane) {
   return c.knownRed?.includes(lane) ?? false;
 }
+function meetsExpectation(c, answer) {
+  return answer.status === c.expect.status && (c.expect.code === void 0 || answer.code === c.expect.code);
+}
+function conformanceVerdict(c, lane, answer) {
+  const meets = meetsExpectation(c, answer);
+  if (isKnownRed(c, lane)) {
+    return meets ? { ok: false, reason: `"${c.name}" conforms on ${lane} now: remove "${lane}" from its knownRed.` } : { ok: true };
+  }
+  return meets ? { ok: true } : { ok: false, reason: `${c.name}: ${lane} answered ${answer.status} ${answer.code ?? ""}, expected ${c.expect.status} ${c.expect.code ?? ""}. ${c.why}` };
+}
 
 export {
   CONFORMANCE_COMPOSITION,
   CONFORMANCE_DURATION_SEC,
   PREVIEW_FRAME_CASES,
-  isKnownRed
+  isKnownRed,
+  meetsExpectation,
+  conformanceVerdict
 };

package/dist/{chunk-UMXES6ED.js → chunk-LVMWPFV4.js}

@@ -2,7 +2,7 @@ import {
   selectAllClips,
   selectAllOverlays,
   selectSceneMarkers
-} from "./chunk-LBJ5LI5V.js";
+} from "./chunk-2K2GBFLU.js";
 
 // ../authoring/src/context/transcript.ts
 var MAX_TRANSCRIPT_CHARS = 6e4;

package/dist/chunk-NECN7TT4.js

@@ -0,0 +1,367 @@
+import {
+  BrandKitBodySchema
+} from "./chunk-CEO47DIE.js";
+import {
+  ComponentSourceV2
+} from "./chunk-BZVOCVQV.js";
+import {
+  Composition
+} from "./chunk-AFUITAH6.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(),
+    loop: z.boolean().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
+};