@cueframe/kernel 0.2.57 → 0.2.58

package/dist/component-runtime/template/testing.js

@@ -0,0 +1,380 @@
+import {
+  bindTemplate,
+  findReferences,
+  parseTemplateDocument
+} from "../../chunk-REST55RC.js";
+import "../../chunk-TR53N6HB.js";
+import {
+  CANVAS2D_COMPONENT_MANIFEST_V2
+} from "../../chunk-EC6VFQE6.js";
+import "../../chunk-IG3YAOUZ.js";
+import "../../chunk-PWWZTY3G.js";
+import "../../chunk-UFD4EZHM.js";
+import "../../chunk-WPZKOVYF.js";
+import "../../chunk-B7J5UUUV.js";
+import {
+  CURRENT_MATTE_BAKE_VERSION
+} from "../../chunk-7NIOFHMH.js";
+import "../../chunk-DKBFAQCW.js";
+import "../../chunk-WREYUH2E.js";
+import "../../chunk-ILO4NEZ3.js";
+import "../../chunk-AK5QBHOB.js";
+import "../../chunk-VG2ND6PX.js";
+import {
+  parseSceneShotSpecV2
+} from "../../chunk-CL5Y6V6K.js";
+import "../../chunk-2L7PYYJK.js";
+import "../../chunk-OOL7ZUG7.js";
+import "../../chunk-2ESYSVXG.js";
+
+// ../execution/component-runtime/src/template/testing/fixtures.ts
+function minimalTemplate() {
+  return {
+    v: 1,
+    slug: "warp",
+    name: "Warp",
+    composition: { v: 1, format: { aspectRatio: "16:9", fps: 30, resolution: "fhd" }, tracks: [
+      { id: "video", kind: "video", name: "Source", contents: [
+        {
+          id: "main",
+          kind: "video",
+          startTime: 0,
+          duration: 8,
+          source: { kind: "media", mediaId: "{{source}}", trim: { start: 4, end: 12 }, muted: false }
+        }
+      ] }
+    ] },
+    parameters: [{ name: "source", type: "media", kind: "video", required: true }],
+    components: {}
+  };
+}
+function withComponent(doc, opts = {}) {
+  const { slot, slotKind } = opts;
+  doc.components.c1 = {
+    source: {
+      version: 2,
+      componentId: "c1",
+      tsxSource: "export default () => null;",
+      manifest: { ...CANVAS2D_COMPONENT_MANIFEST_V2, assets: slot ? { [slot]: { kind: slotKind ?? "image", required: true } } : {} }
+    },
+    name: "C1",
+    description: "fixture component",
+    category: "text",
+    propSchema: { type: "object" }
+  };
+  doc.composition.tracks.push({ id: "comp", kind: "overlay", name: "C", contents: [{
+    id: "c",
+    kind: "overlay",
+    startTime: 0,
+    duration: 2,
+    source: { kind: "component", componentId: "c1", props: {}, ...slot ? { assets: { [slot]: `{{${slot}}}` } } : {} }
+  }] });
+  return doc;
+}
+function sceneWithImageSlot(slot) {
+  return parseSceneShotSpecV2({
+    version: 2,
+    referenceSize: { width: 1920, height: 1080 },
+    environment: { kind: "photographic-studio-v1" },
+    backdrop: { kind: "solid", color: "#000000" },
+    layers: [{
+      kind: "page",
+      id: "p",
+      transform: { position: [0, 0, 0], rotation: [0, 0, 0], scale: 1 },
+      width: 720,
+      height: 900,
+      surfaces: { content: { source: "image", assetSlot: slot } }
+    }]
+  });
+}
+var video = (durationSec = 30) => ({ mediaId: "m1", kind: "video", durationSec });
+var withTrack = (doc, track) => {
+  doc.composition.tracks.push(track);
+  return doc;
+};
+var overlay = (params) => ({ id: "t", kind: "overlay", name: "T", contents: [{
+  id: "o",
+  kind: "overlay",
+  startTime: 0,
+  duration: 2,
+  source: { kind: "overlay", primitiveId: "heroText", params }
+}] });
+var withParams = (doc, ...ps) => {
+  doc.parameters.push(...ps);
+  return doc;
+};
+var TEMPLATE_BINDING_FIXTURES = [
+  {
+    name: "minimal-video",
+    doc: minimalTemplate,
+    media: { source: video() },
+    expect: { at: [["tracks.0.contents.0.source.mediaId", "m1"]] }
+  },
+  {
+    name: "text-inline-and-whole-leaf",
+    doc: () => withTrack(
+      withParams(minimalTemplate(), { name: "title", type: "string", required: true }, { name: "size", type: "number", required: true }),
+      overlay({ text: "Hi {{title}}!", fontSizePct: "{{size}}" })
+    ),
+    values: { title: "Sam", size: 27 },
+    media: { source: video() },
+    expect: { at: [["tracks.1.contents.0.source.params", { text: "Hi Sam!", fontSizePct: 27 }]] }
+  },
+  {
+    name: "escaped-brace",
+    doc: () => withTrack(minimalTemplate(), overlay({ text: "\\{{not a ref}}" })),
+    media: { source: video() },
+    expect: { at: [["tracks.1.contents.0.source.params.text", "{{not a ref}}"]] }
+  },
+  {
+    name: "image-swap-strips-trim",
+    doc: () => {
+      const doc = minimalTemplate();
+      doc.parameters[0] = { name: "logo", type: "media", kind: "image", required: true };
+      doc.composition.tracks[0] = { id: "img", kind: "image", name: "Logo", contents: [{
+        id: "l",
+        kind: "image",
+        startTime: 0,
+        duration: 3,
+        fit: "contain",
+        source: { kind: "media", mediaId: "{{logo}}", trim: { start: 0, end: 3 }, playbackRate: 1 }
+      }] };
+      return doc;
+    },
+    media: { logo: { mediaId: "m2", kind: "image" } },
+    expect: { at: [["tracks.0.contents.0.fit", "contain"], ["tracks.0.contents.0.source.trim", void 0], ["tracks.0.contents.0.source.playbackRate", void 0]] }
+  },
+  {
+    name: "missing-required",
+    doc: minimalTemplate,
+    media: {},
+    expect: { error: { code: "template_values_invalid", fields: [{ param: "source", reason: "required" }] } }
+  },
+  {
+    name: "kind-mismatch",
+    doc: minimalTemplate,
+    media: { source: { mediaId: "m1", kind: "image" } },
+    expect: { error: { code: "template_media_kind_mismatch" } }
+  },
+  {
+    name: "short-media",
+    doc: minimalTemplate,
+    media: { source: video(10) },
+    expect: { error: { code: "template_values_invalid", fields: [{ param: "source", reason: "media is 10s, template trims to 12s" }] } }
+  },
+  {
+    name: "short-media-no-trim",
+    doc: () => {
+      const doc = minimalTemplate();
+      delete doc.composition.tracks[0].contents[0].source.trim;
+      return doc;
+    },
+    media: { source: video(5) },
+    expect: { error: { code: "template_values_invalid", fields: [{ param: "source", reason: "media is 5s, clip needs 8s" }] } }
+  },
+  {
+    name: "asset-slot-image",
+    doc: () => withParams(withComponent(minimalTemplate(), { slot: "screen", slotKind: "image" }), { name: "screen", type: "media", kind: "image", required: true }),
+    media: { source: video(), screen: { mediaId: "m9", kind: "image" } },
+    expect: { at: [["tracks.1.contents.0.source.assets", { screen: "m9" }]] }
+  },
+  {
+    name: "asset-slot-kind-mismatch",
+    doc: () => withParams(withComponent(minimalTemplate(), { slot: "screen", slotKind: "image" }), { name: "screen", type: "media", kind: "image", required: true }),
+    media: { source: video(), screen: { mediaId: "m9", kind: "video" } },
+    expect: { error: { code: "template_media_kind_mismatch" } }
+  },
+  {
+    name: "scene-shot-slot",
+    doc: () => withTrack(
+      withParams(minimalTemplate(), { name: "shot", type: "media", kind: "image", required: true }),
+      { id: "s", kind: "overlay", name: "S", contents: [{
+        id: "sc",
+        kind: "overlay",
+        startTime: 0,
+        duration: 4,
+        source: { kind: "component", componentId: "scene-x", props: { scene: sceneWithImageSlot("shot") }, assets: { shot: "{{shot}}" } }
+      }] }
+    ),
+    media: { source: video(), shot: { mediaId: "m5", kind: "image" } },
+    expect: { at: [["tracks.1.contents.0.source.assets", { shot: "m5" }]] }
+  },
+  {
+    name: "undeclared-reference",
+    doc: () => withTrack(minimalTemplate(), overlay({ text: "{{nope}}" })),
+    media: { source: video() },
+    expect: { error: { code: "template_parameter_undeclared" } }
+  },
+  {
+    name: "misplaced-reference",
+    doc: () => {
+      const doc = withParams(minimalTemplate(), { name: "len", type: "number", required: true });
+      doc.composition.tracks[0].contents[0].duration = "{{len}}";
+      return doc;
+    },
+    values: { len: 8 },
+    media: { source: video() },
+    expect: { error: { code: "template_values_invalid" } }
+  },
+  {
+    name: "preset-base-with-override",
+    doc: () => {
+      const doc = withParams(minimalTemplate(), { name: "title", type: "string", required: true }, { name: "layout", type: "enum", required: true, options: ["split", "stacked"] });
+      doc.presets = { warm: { label: "Warm", values: { title: "Warm", layout: "split" } } };
+      return withTrack(doc, overlay({ text: "{{title}}", layout: "{{layout}}" }));
+    },
+    values: { title: "Mine" },
+    preset: "warm",
+    media: { source: video() },
+    expect: { at: [["tracks.1.contents.0.source.params", { text: "Mine", layout: "split" }]] }
+  },
+  {
+    name: "unknown-preset",
+    doc: minimalTemplate,
+    preset: "nope",
+    media: { source: video() },
+    expect: { error: { code: "template_values_invalid", fields: [{ param: "preset", reason: "unknown preset nope" }] } }
+  },
+  {
+    name: "enum-outside-options",
+    doc: () => withParams(minimalTemplate(), { name: "layout", type: "enum", required: true, options: ["split"] }),
+    values: { layout: "stacked" },
+    media: { source: video() },
+    expect: { error: { code: "template_values_invalid", fields: [{ param: "layout", reason: "expected one of split" }] } }
+  },
+  {
+    name: "boolean-whole-leaf-and-inline",
+    doc: () => withTrack(withParams(minimalTemplate(), { name: "on", type: "boolean", required: true }), overlay({ show: "{{on}}", note: "on={{on}}" })),
+    values: { on: "true" },
+    media: { source: video() },
+    expect: { at: [["tracks.1.contents.0.source.params", { show: true, note: "on=true" }]] }
+  }
+];
+function readFixturePath(value, path) {
+  return path.split(".").reduce((v, key) => v == null ? void 0 : v[key], value);
+}
+
+// ../execution/component-runtime/src/template/testing/templateApplyContract.ts
+var kit = (name) => ({
+  kitId: "ignored",
+  name,
+  colors: { primary: "#111111", secondary: "#222222", accent: "#f7c948", background: "#000000", text: "#ffffff" },
+  headingFont: { fontFamily: "Inter", fontWeight: 700 },
+  bodyFont: { fontFamily: "Inter", fontWeight: 400 }
+});
+function contractDoc() {
+  const doc = minimalTemplate();
+  doc.parameters.push({ name: "title", type: "string", required: true, default: "Hello" });
+  doc.composition.tracks.push({ id: "t", kind: "overlay", name: "T", contents: [{
+    id: "o",
+    kind: "overlay",
+    startTime: 0,
+    duration: 2,
+    source: { kind: "overlay", primitiveId: "heroText", params: { text: "{{title}}" } }
+  }] });
+  doc.brandKit = kit("Document kit");
+  doc.presets = { granite: { label: "Granite", values: { title: "Granite" }, brandKit: kit("Granite kit") } };
+  return parseTemplateDocument(doc);
+}
+var source = { mediaId: "m1", kind: "video", durationSec: 30 };
+var SAMPLE_SHA = "b".repeat(64);
+var CONTRACT_MATTE_KEY = "4aa54bdd6d0d";
+function matteCase(bakeVersion, sha256) {
+  const doc = minimalTemplate();
+  doc.parameters[0] = {
+    name: "source",
+    type: "media",
+    kind: "video",
+    required: true,
+    sample: { url: "https://cdn.cueframe.ai/samples/contract.mp4", sha256: SAMPLE_SHA, mimeType: "video/mp4" },
+    prepared: { mattes: { [CONTRACT_MATTE_KEY]: { url: "https://cdn.cueframe.ai/mattes/contract.mp4", sha256: "c".repeat(64), mimeType: "video/mp4", bakeVersion } } }
+  };
+  return { doc: parseTemplateDocument(doc), values: {}, media: { source: { ...source, sha256 } } };
+}
+function logicalMedia(doc, composition) {
+  const out = structuredClone(composition);
+  const media = new Set(doc.parameters.filter((p) => p.type === "media").map((p) => p.name));
+  for (const ref of findReferences(doc)) {
+    if (!ref.wholeLeaf || !media.has(ref.name)) continue;
+    const parent = ref.path.slice(0, -1).reduce((v, k) => v?.[k], out);
+    const leaf = ref.path[ref.path.length - 1];
+    if (typeof parent?.[leaf] === "string" && parent[leaf].length > 0) parent[leaf] = `media:${ref.name}`;
+  }
+  return out;
+}
+function runTemplateApplyContract(harness) {
+  const { describe, it, expect, makeLane, kind } = harness;
+  const red = new Set(harness.knownRed ?? []);
+  const fact = (name, fn) => (red.has(name) ? it.fails : it)(name, fn);
+  describe(`template apply contract (${kind})`, () => {
+    fact("contract_apply_reads_back_bound_composition", async () => {
+      const lane = await makeLane();
+      const doc = contractDoc();
+      await lane.apply({ doc, values: { title: "Sam" }, media: { source } });
+      const stored = await lane.readBack();
+      expect(stored && logicalMedia(doc, stored.composition)).toEqual(logicalMedia(doc, bindTemplate(doc, { title: "Sam" }, { source })));
+    });
+    fact("contract_apply_preset_kit_over_document_kit", async () => {
+      const lane = await makeLane();
+      const doc = contractDoc();
+      const plain = await lane.apply({ doc, values: {}, media: { source } });
+      const granite = await lane.apply({ doc, values: {}, media: { source }, preset: "granite" });
+      expect(plain.brandKit?.name).toBe("Document kit");
+      expect(granite.brandKit?.name).toBe("Granite kit");
+      if (kind === "server" || plain.brandKit?.kitId !== void 0) expect(plain.brandKit?.kitId).toBe(`template:${doc.slug}`);
+      if (kind === "server" || granite.brandKit?.kitId !== void 0) expect(granite.brandKit?.kitId).toBe(`template:${doc.slug}:granite`);
+    });
+    fact("contract_apply_refuses_missing_media", async () => {
+      const lane = await makeLane();
+      await expect(lane.apply({ doc: contractDoc(), values: {}, media: {} })).rejects.toMatchObject({ code: "template_values_invalid" });
+    });
+    if (kind === "server") {
+      const server = async () => {
+        const lane = await makeLane();
+        if (!lane.server) throw new Error(`${lane.name}: a server lane supplies lane.server`);
+        return { lane, server: lane.server };
+      };
+      fact("contract_apply_installs_component_once", async () => {
+        const { lane, server: s } = await server();
+        const doc = parseTemplateDocument(withComponent(contractDoc()));
+        await lane.apply({ doc, values: {}, media: { source } });
+        await lane.apply({ doc, values: {}, media: { source } });
+        expect(await s.readComponentVersionCount("c1")).toBe(1);
+      });
+      fact("contract_apply_refuses_differing_component", async () => {
+        const { lane, server: s } = await server();
+        await s.seedComponent("c1", "export default () => 1;");
+        const doc = parseTemplateDocument(withComponent(contractDoc()));
+        await expect(lane.apply({ doc, values: {}, media: { source } })).rejects.toMatchObject({ code: "template_component_conflict" });
+        expect(await s.readComponentVersionCount("c1")).toBe(1);
+        expect(await lane.readBack()).toBe(null);
+      });
+      fact("contract_apply_brandKitId_over_both_kits", async () => {
+        const { lane, server: s } = await server();
+        const brandKitId = await s.seedBrandKit("Org kit");
+        const applied = await lane.apply({ doc: contractDoc(), values: {}, media: { source }, preset: "granite", brandKitId });
+        expect(applied.brandKit?.name).toBe("Org kit");
+      });
+    }
+    if (kind === "desktop") {
+      fact("contract_apply_refuses_stale_matte", async () => {
+        const lane = await makeLane();
+        await expect(lane.apply(matteCase(`stale-${CURRENT_MATTE_BAKE_VERSION}`, SAMPLE_SHA))).rejects.toThrow(/bakeVersion/);
+      });
+      fact("contract_apply_matte_only_on_its_sample", async () => {
+        const lane = await makeLane();
+        expect((await lane.apply(matteCase(CURRENT_MATTE_BAKE_VERSION, SAMPLE_SHA))).mattes).toEqual([CONTRACT_MATTE_KEY]);
+        expect((await lane.apply(matteCase(CURRENT_MATTE_BAKE_VERSION, "d".repeat(64)))).mattes ?? []).toEqual([]);
+      });
+    }
+  });
+}
+export {
+  CONTRACT_MATTE_KEY,
+  TEMPLATE_BINDING_FIXTURES,
+  minimalTemplate,
+  readFixturePath,
+  runTemplateApplyContract,
+  sceneWithImageSlot,
+  withComponent
+};

package/dist/component-runtime/template.d.ts

@@ -0,0 +1 @@
+export * from "../_members/component-runtime/template/index.js";

package/dist/component-runtime/template.js

@@ -0,0 +1,99 @@
+import {
+  MATTE_KEY,
+  PRESET_NAME,
+  TEMPLATE_MAX_BYTES,
+  TemplateDocumentSchema,
+  TemplateError,
+  TemplateParameterSchema,
+  bindTemplate,
+  checkReferences,
+  coerceParameterValue,
+  findReferences,
+  parseTemplateDocument
+} from "../chunk-REST55RC.js";
+import "../chunk-TR53N6HB.js";
+import "../chunk-EC6VFQE6.js";
+import "../chunk-IG3YAOUZ.js";
+import "../chunk-PWWZTY3G.js";
+import "../chunk-UFD4EZHM.js";
+import "../chunk-WPZKOVYF.js";
+import "../chunk-B7J5UUUV.js";
+import {
+  CURRENT_MATTE_BAKE_VERSION
+} from "../chunk-7NIOFHMH.js";
+import "../chunk-DKBFAQCW.js";
+import "../chunk-WREYUH2E.js";
+import "../chunk-ILO4NEZ3.js";
+import "../chunk-AK5QBHOB.js";
+import "../chunk-VG2ND6PX.js";
+import "../chunk-CL5Y6V6K.js";
+import "../chunk-2L7PYYJK.js";
+import "../chunk-OOL7ZUG7.js";
+import "../chunk-2ESYSVXG.js";
+
+// ../execution/component-runtime/src/template/extract.ts
+function extractTemplate(args) {
+  const escape = (v) => typeof v === "string" ? v.replaceAll("{{", "\\{{") : Array.isArray(v) ? v.map(escape) : v && typeof v === "object" ? Object.fromEntries(Object.entries(v).map(([k, x]) => [k, escape(x)])) : v;
+  const composition = escape(args.composition);
+  const clips = /* @__PURE__ */ new Map();
+  for (const track of composition.tracks) for (const clip2 of track.contents) clips.set(clip2.id, clip2);
+  const clip = (id) => {
+    const found = clips.get(id);
+    if (!found) throw new Error(`clip ${id} is not in the composition`);
+    return found;
+  };
+  const parameters = [];
+  for (const m of args.mediaParams) {
+    const source = clip(m.clipId).source;
+    const holder = m.slot === void 0 ? source : source?.assets;
+    const key = m.slot ?? "mediaId";
+    if (typeof holder?.[key] !== "string" || holder[key].length === 0) {
+      throw new Error(`clip ${m.clipId} has no media at source.${m.slot === void 0 ? "mediaId" : `assets.${m.slot}`}`);
+    }
+    parameters.push({ name: m.name, type: "media", kind: m.kind, required: true, default: holder[key], ...m.label ? { label: m.label } : {} });
+    holder[key] = `{{${m.name}}}`;
+  }
+  for (const t of args.textParams) {
+    const parent = t.leafPath.slice(0, -1).reduce((v, k) => v?.[k], clip(t.clipId));
+    const leaf = t.leafPath[t.leafPath.length - 1];
+    if (parent == null || !(leaf in parent)) throw new Error(`clip ${t.clipId} has no leaf ${t.leafPath.join(".")}`);
+    parameters.push({
+      name: t.name,
+      type: t.type,
+      required: t.required,
+      default: t.default ?? parent[leaf],
+      ...t.options ? { options: t.options } : {},
+      ...t.label ? { label: t.label } : {}
+    });
+    parent[leaf] = `{{${t.name}}}`;
+  }
+  const doc = parseTemplateDocument({
+    v: 1,
+    slug: args.slug,
+    name: args.name,
+    ...args.description ? { description: args.description } : {},
+    composition,
+    parameters,
+    components: args.components
+  });
+  const { misplaced, mediaSiteErrors } = checkReferences(doc);
+  if (misplaced.length || mediaSiteErrors.length) {
+    throw new TemplateError("template_values_invalid", [...misplaced.map((m) => `reference outside a string leaf: ${m}`), ...mediaSiteErrors].join("; "));
+  }
+  return doc;
+}
+export {
+  CURRENT_MATTE_BAKE_VERSION,
+  MATTE_KEY,
+  PRESET_NAME,
+  TEMPLATE_MAX_BYTES,
+  TemplateDocumentSchema,
+  TemplateError,
+  TemplateParameterSchema,
+  bindTemplate,
+  checkReferences,
+  coerceParameterValue,
+  extractTemplate,
+  findReferences,
+  parseTemplateDocument
+};

package/dist/compose.js

@@ -5,39 +5,39 @@ import {
   isContrastCritical
 } from "./chunk-QDBVYZSF.js";
 import "./chunk-GULDS3VE.js";
-import {
-  catalog as catalog4
-} from "./chunk-PTVTWQ4T.js";
-import {
-  catalog as catalog7
-} from "./chunk-UKDBU7HM.js";
-import {
-  catalog
-} from "./chunk-RBWS5XHE.js";
-import "./chunk-DLF4WVSE.js";
-import "./chunk-U4V4FZGE.js";
 import {
   catalog as catalog3
 } from "./chunk-FVDFPJHT.js";
-import "./chunk-QGAWDLYX.js";
 import {
   catalog as catalog6
 } from "./chunk-VLJOIUHL.js";
-import "./chunk-S5H6GH6M.js";
-import "./chunk-QAGGJHAF.js";
-import {
-  catalog as catalog5
-} from "./chunk-RAXHCRVV.js";
 import {
   catalog as catalog2
 } from "./chunk-TKFLSGAS.js";
-import "./chunk-MFHXCHRI.js";
 import {
   catalog as catalog8
 } from "./chunk-RL5SO653.js";
+import {
+  catalog as catalog4
+} from "./chunk-PTVTWQ4T.js";
+import {
+  catalog as catalog7
+} from "./chunk-UKDBU7HM.js";
+import "./chunk-QGAWDLYX.js";
+import "./chunk-S5H6GH6M.js";
+import "./chunk-QAGGJHAF.js";
+import "./chunk-MFHXCHRI.js";
+import {
+  catalog
+} from "./chunk-RBWS5XHE.js";
+import "./chunk-DLF4WVSE.js";
+import "./chunk-U4V4FZGE.js";
 import "./chunk-LT4PWSR2.js";
 import "./chunk-FWSJLHSV.js";
 import "./chunk-ZFEXATWN.js";
+import {
+  catalog as catalog5
+} from "./chunk-RAXHCRVV.js";
 import "./chunk-XHGZ2E77.js";
 import "./chunk-W2245F6G.js";
 import "./chunk-FHMTAZD4.js";
@@ -47,11 +47,11 @@ import {
   getPrimitiveText,
   getPrimitiveTextParam,
   listPrimitivesByCategory
-} from "./chunk-7AZLFN26.js";
+} from "./chunk-4NIJWK45.js";
 import {
   CueframeError,
   encodeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-AK5QBHOB.js";
 import "./chunk-7PA7FGLD.js";
 import {
   NEUTRAL_RAMP

package/dist/composition/floors.js

@@ -1,6 +1,6 @@
 import {
   getPrimitiveCatalogMeta
-} from "../chunk-7AZLFN26.js";
+} from "../chunk-4NIJWK45.js";
 import "../chunk-7PA7FGLD.js";
 import "../chunk-2ESYSVXG.js";
 

package/dist/composition/ops.js

@@ -21,7 +21,8 @@ import {
   selectSceneMarkers,
   selectTracksByKind
 } from "../chunk-LBJ5LI5V.js";
-import "../chunk-AXRSCHQX.js";
+import "../chunk-IG3YAOUZ.js";
+import "../chunk-PWWZTY3G.js";
 import "../chunk-UFD4EZHM.js";
 import "../chunk-WPZKOVYF.js";
 import "../chunk-B7J5UUUV.js";

package/dist/composition/primitive-catalog.js

@@ -7,6 +7,7 @@ import {
   CatalogFilterError,
   DISABLED_PRIMITIVE_IDS,
   PRIMITIVE_META,
+  PRIMITIVE_USE_CASES,
   decodeCatalogCursor,
   derivePlacement,
   encodeCatalogCursor,
@@ -26,7 +27,7 @@ import {
   validateCatalogFilters,
   validateParamsAgainstSchema,
   validatePrimitiveParams
-} from "../chunk-7AZLFN26.js";
+} from "../chunk-4NIJWK45.js";
 import "../chunk-7PA7FGLD.js";
 import "../chunk-2ESYSVXG.js";
 export {
@@ -38,6 +39,7 @@ export {
   CatalogFilterError,
   DISABLED_PRIMITIVE_IDS,
   PRIMITIVE_META,
+  PRIMITIVE_USE_CASES,
   decodeCatalogCursor,
   derivePlacement,
   encodeCatalogCursor,

package/dist/composition/projection.js

@@ -32,7 +32,7 @@ import {
   silhouetteKeepOutForWindow,
   sourceRectToOutput,
   sourceWindowKey
-} from "../chunk-MZB4ZXYW.js";
+} from "../chunk-7NIOFHMH.js";
 import {
   BRAND_TOKEN_REFS,
   BRAND_TOKEN_ROOT_KEYS,
@@ -73,7 +73,7 @@ import {
 import {
   contrastRatio
 } from "../chunk-ILO4NEZ3.js";
-import "../chunk-E63UEO5C.js";
+import "../chunk-AK5QBHOB.js";
 import "../chunk-VG2ND6PX.js";
 import "../chunk-OOL7ZUG7.js";
 import "../chunk-2ESYSVXG.js";

package/dist/composition/validators/brand-kit-body.d.ts

@@ -0,0 +1 @@
+export * from "../../_members/composition/validators/brandKitBody.js";

package/dist/composition/validators/brand-kit-body.js

@@ -0,0 +1,17 @@
+import {
+  BrandAudioSchema,
+  BrandKitBodySchema,
+  BrandKitBodyShape
+} from "../../chunk-TR53N6HB.js";
+import "../../chunk-PWWZTY3G.js";
+import "../../chunk-UFD4EZHM.js";
+import "../../chunk-WPZKOVYF.js";
+import "../../chunk-B7J5UUUV.js";
+import "../../chunk-WREYUH2E.js";
+import "../../chunk-OOL7ZUG7.js";
+import "../../chunk-2ESYSVXG.js";
+export {
+  BrandAudioSchema,
+  BrandKitBodySchema,
+  BrandKitBodyShape
+};

package/dist/composition/validators.js

@@ -1,17 +1,12 @@
 import {
-  AudioPaletteRef,
-  BrandKit,
   ComposePlan,
   Destination,
   DestinationDeliveryStatus,
   DestinationResult,
-  EasingValue,
   Font,
-  FontRef,
   FontStatus,
   FontVariant,
   MediaSourceSnapshot,
-  Motif,
   MuxDestination,
   PlanAssetRequest,
   PlanCut,
@@ -48,7 +43,15 @@ import {
   WebhookDeliveryStatus,
   WebhookDestination,
   YoutubeDestination
-} from "../chunk-AXRSCHQX.js";
+} from "../chunk-IG3YAOUZ.js";
+import {
+  AudioPaletteRef,
+  BrandKit,
+  EasingValue,
+  FontRef,
+  Motif,
+  MotifMotionPreset
+} from "../chunk-PWWZTY3G.js";
 import {
   ANIMATABLE_PARAMS,
   ANIMATABLE_VALUE,
@@ -150,6 +153,7 @@ export {
   MediaClipSource,
   MediaSourceSnapshot,
   Motif,
+  MotifMotionPreset,
   MuxDestination,
   OpaqueId,
   OverlayClipSource,