@cueframe/kernel 0.1.2 → 0.1.4

package/dist/authoring.js

@@ -1,6 +1,6 @@
 import {
   buildDirectorContext
-} from "./chunk-DWLNPNC4.js";
+} from "./chunk-LSP4HN5N.js";
 import {
   buildFastModel,
   buildModel,
@@ -13,8 +13,6 @@ import {
   CODE_GEN_FEW_SHOT_EXAMPLES,
   COMPONENT_CONTRACT,
   DESIGN_QUALITY_RULES,
-  DESIGN_REVIEWER_PROMPT,
-  DESIGN_REVIEWER_TOOLS,
   EVALUATOR_PROMPT,
   PLANNING_INSTRUCTIONS,
   TOOLKIT_REFERENCE,
@@ -22,14 +20,14 @@ import {
   buildPlannerUserMessage,
   formatPlanSteps,
   initCodeGenPrompts
-} from "./chunk-K2IUBCND.js";
+} from "./chunk-HFC3MKXA.js";
 import {
   ZERO_USAGE,
   buildDirectorTools,
   buildPlannerTools,
   buildToolsFromSchemas,
   extractProviderError
-} from "./chunk-TPA6PYN2.js";
+} from "./chunk-ZBRPF6GV.js";
 import {
   COMPOSE_MOTION_TOOLS,
   COMPOSE_MOTION_VERIFY_TOOLS,
@@ -38,27 +36,27 @@ import {
   COMPOSE_ROLE_TOOLS,
   COMPOSE_ROLE_TOOL_NAMES,
   dispatchComposeRoleTool
-} from "./chunk-BZZTVOGG.js";
+} from "./chunk-D2EGO543.js";
 import {
   AgentFixableCaptureError,
   getExcludedTools
 } from "./chunk-JOURGVOR.js";
-import "./chunk-DCVJWGIA.js";
-import "./chunk-ICSZF37W.js";
+import "./chunk-JY26PIRP.js";
+import "./chunk-JRIPQ7DN.js";
 import "./chunk-7PA7FGLD.js";
 import "./chunk-KYRDKK2D.js";
-import "./chunk-PIURX6IZ.js";
+import "./chunk-WTT3GGCA.js";
 import {
   cssLayoutVars
 } from "./chunk-YQ7FFW3G.js";
 import "./chunk-DSMLHYJ4.js";
 import "./chunk-JF4JJAFP.js";
-import "./chunk-TFGKUWHY.js";
-import "./chunk-WZH57M53.js";
+import "./chunk-JTVFIN6H.js";
+import "./chunk-2SNY75AR.js";
 import "./chunk-WPZKOVYF.js";
 import "./chunk-2B5VJZHL.js";
 import "./chunk-WREYUH2E.js";
-import "./chunk-LLUW26BS.js";
+import "./chunk-R5BMJ2NX.js";
 import "./chunk-2ESYSVXG.js";
 
 // ../authoring/src/agent.ts
@@ -1137,20 +1135,38 @@ var isMotionPresetOp = (op) => !!op && typeof op === "object" && op.type === "ap
 var hasMotionPresetOp = (ops) => ops.some(isMotionPresetOp);
 async function materializeMotionPresetOpsCore(composition, ops, opts, deps) {
   const out = [];
+  let current = composition;
   for (let i = 0; i < ops.length; i++) {
     const op = ops[i];
     if (!isMotionPresetOp(op)) {
       out.push(op);
+      if (deps.apply) current = deps.apply(current, op);
       continue;
     }
     let card;
     try {
-      card = resolveMotionPresetCard(composition, { clipId: op.clipId, preset: op.preset });
+      card = resolveMotionPresetCard(current, { clipId: op.clipId, preset: op.preset });
     } catch (err) {
       if (err instanceof MotionPresetError) err.opIndex = i;
       throw err;
     }
-    if (opts.dryRun) continue;
+    const componentId = `motion-shell-${op.clipId}`;
+    const projectedUpdate = {
+      type: "clip.update",
+      clipId: op.clipId,
+      patch: {
+        source: {
+          kind: "component",
+          componentId,
+          props: {},
+          ...card.zPlane !== void 0 ? { zPlane: card.zPlane } : {}
+        }
+      }
+    };
+    if (opts.dryRun) {
+      if (deps.apply) current = deps.apply(current, projectedUpdate);
+      continue;
+    }
     const tsxSource = generateMotionShell(card.cardHtml, {
       preset: op.preset,
       ...op.params?.enterMs !== void 0 ? { enterMs: op.params.enterMs } : {},
@@ -1158,18 +1174,17 @@ async function materializeMotionPresetOpsCore(composition, ops, opts, deps) {
       ...op.params?.staggerMs !== void 0 ? { staggerMs: op.params.staggerMs } : {},
       ...card.tokens !== void 0 ? { tokens: card.tokens } : {}
     });
-    const componentId = `motion-shell-${op.clipId}`;
     const { jsSource } = await deps.transpile(componentId, tsxSource);
-    out.push(
-      await deps.sink({
-        componentId,
-        clipId: op.clipId,
-        preset: op.preset,
-        tsxSource,
-        jsSource,
-        ...card.zPlane !== void 0 ? { zPlane: card.zPlane } : {}
-      })
-    );
+    const materialized = await deps.sink({
+      componentId,
+      clipId: op.clipId,
+      preset: op.preset,
+      tsxSource,
+      jsSource,
+      ...card.zPlane !== void 0 ? { zPlane: card.zPlane } : {}
+    });
+    out.push(materialized);
+    if (deps.apply) current = deps.apply(current, materialized);
   }
   return out;
 }
@@ -1186,8 +1201,6 @@ export {
   COMPOSE_ROLE_TOOLS,
   COMPOSE_ROLE_TOOL_NAMES,
   DESIGN_QUALITY_RULES,
-  DESIGN_REVIEWER_PROMPT,
-  DESIGN_REVIEWER_TOOLS,
   EVALUATOR_PROMPT,
   MOTION_PRESETS,
   MotionPresetError,

package/dist/chunk-2SNY75AR.js

@@ -0,0 +1,498 @@
+import {
+  Reframe
+} from "./chunk-2B5VJZHL.js";
+
+// ../composition/src/validators/opaqueId.ts
+import { z } from "zod";
+var OpaqueId = z.string();
+
+// ../composition/src/validators/composition.ts
+import { z as z2 } from "zod";
+var Format = z2.object({
+  aspectRatio: z2.enum(["16:9", "9:16", "1:1", "4:5"]),
+  fps: z2.union([z2.literal(24), z2.literal(25), z2.literal(30), z2.literal(60)]).optional(),
+  resolution: z2.enum(["hd", "fhd", "4k"]).optional(),
+  platform: z2.string().optional()
+});
+var Trim = z2.object({
+  start: z2.number().nonnegative(),
+  end: z2.number().nonnegative()
+});
+var ExcludedRange = z2.object({
+  start: z2.number().nonnegative(),
+  end: z2.number().nonnegative(),
+  reason: z2.string().optional()
+});
+var MediaClipSource = z2.object({
+  kind: z2.literal("media"),
+  mediaId: OpaqueId,
+  trim: Trim.optional(),
+  excludedRanges: z2.array(ExcludedRange).optional(),
+  volume: z2.number().min(0).max(4).optional(),
+  muted: z2.boolean().optional(),
+  playbackRate: z2.number().positive().optional(),
+  sync: z2.enum(["video", "independent"]).optional(),
+  kenBurns: z2.enum(["in", "out", "pan-l", "pan-r", "none"]).optional(),
+  volumeDb: z2.number().optional(),
+  fadeInMs: z2.number().nonnegative().optional(),
+  fadeOutMs: z2.number().nonnegative().optional(),
+  loop: z2.boolean().optional(),
+  audioRole: z2.enum(["sfx", "music", "vo", "ambience"]).optional(),
+  duck: z2.object({
+    duckDb: z2.number().max(0),
+    attackMs: z2.number().nonnegative(),
+    releaseMs: z2.number().nonnegative(),
+    windows: z2.array(z2.object({ startMs: z2.number(), endMs: z2.number() })).optional()
+  }).optional(),
+  anchor: z2.object({
+    clipId: z2.string().min(1),
+    offsetMs: z2.number()
+  }).optional(),
+  reframe: Reframe.optional()
+});
+var ComponentClipSource = z2.object({
+  kind: z2.literal("component"),
+  componentId: z2.string().min(1),
+  props: z2.record(z2.string(), z2.unknown()),
+  zPlane: z2.enum(["front", "behind-subject"]).optional()
+});
+var OverlayClipSource = z2.object({
+  kind: z2.literal("overlay"),
+  primitiveId: z2.string().min(1),
+  params: z2.record(z2.string(), z2.unknown()),
+  zPlane: z2.enum(["front", "behind-subject"]).optional(),
+  anchor: z2.object({ space: z2.literal("scene"), x: z2.number().min(0).max(1), y: z2.number().min(0).max(1) }).optional(),
+  parallax: z2.number().min(-0.3).max(0.3).optional()
+});
+var EffectClipSource = z2.object({
+  kind: z2.literal("effect"),
+  primitiveId: z2.string().min(1),
+  params: z2.record(z2.string(), z2.unknown()).optional()
+});
+var AlphaLayerClipSource = z2.object({
+  kind: z2.literal("alpha-layer"),
+  componentId: z2.string().min(1),
+  props: z2.record(z2.string(), z2.unknown()),
+  zPlane: z2.enum(["front", "behind-subject"]).optional()
+});
+var CardClipSource = z2.object({
+  kind: z2.literal("card"),
+  html: z2.string().min(1),
+  tokens: z2.record(z2.string(), z2.string()).optional(),
+  zPlane: z2.literal("front").optional()
+});
+var CompositionClipSource = z2.object({
+  kind: z2.literal("composition"),
+  compositionId: z2.string().min(1),
+  trim: Trim.optional()
+}).strict();
+var ClipSource = z2.discriminatedUnion("kind", [
+  MediaClipSource,
+  ComponentClipSource,
+  OverlayClipSource,
+  EffectClipSource,
+  AlphaLayerClipSource,
+  CardClipSource,
+  CompositionClipSource
+]);
+var Transition = z2.object({
+  type: z2.string().min(1),
+  duration: z2.number().positive()
+});
+var Position = z2.object({
+  x: z2.number(),
+  y: z2.number()
+});
+var Region = z2.object({
+  x: z2.number().min(0).max(1),
+  y: z2.number().min(0).max(1),
+  w: z2.number().positive().max(1),
+  h: z2.number().positive().max(1)
+});
+var ClipFit = z2.enum(["cover", "contain"]);
+var PerClipEffect = z2.object({
+  primitiveId: z2.string().min(1),
+  params: z2.record(z2.string(), z2.unknown()).optional()
+});
+var KeyframeEasing = z2.union([
+  z2.enum(["linear", "ease", "easeIn", "easeOut", "easeInOut"]),
+  z2.object({ cubicBezier: z2.tuple([z2.number(), z2.number(), z2.number(), z2.number()]) }).strict()
+]);
+var Keyframe = z2.object({
+  time: z2.number().nonnegative(),
+  value: z2.number(),
+  easing: KeyframeEasing.optional()
+}).strict();
+var KeyframeChannel = z2.array(Keyframe).min(2);
+var ANIMATABLE_PARAMS = [
+  "opacity",
+  "scale",
+  "rotation",
+  "position.x",
+  "position.y",
+  "volume"
+];
+var TimelineClip = z2.object({
+  id: z2.string().min(1),
+  startTime: z2.number().nonnegative(),
+  duration: z2.number().positive(),
+  source: ClipSource,
+  kind: z2.enum(["video", "audio", "image", "overlay", "effect"]).optional(),
+  opacity: z2.number().min(0).max(1).optional(),
+  scale: z2.number().positive().optional(),
+  rotation: z2.number().optional(),
+  position: Position.optional(),
+  region: Region.optional(),
+  fit: ClipFit.optional(),
+  effects: z2.array(PerClipEffect).optional(),
+  transitionIn: Transition.optional(),
+  linkGroupId: z2.string().min(1).optional(),
+  animate: z2.record(z2.string(), KeyframeChannel).superRefine((channels, ctx) => {
+    for (const key of Object.keys(channels)) {
+      if (!ANIMATABLE_PARAMS.includes(key)) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: [key],
+          message: `"${key}" is not an animatable param (${ANIMATABLE_PARAMS.join(", ")})`
+        });
+      }
+    }
+  }).optional()
+}).strict();
+var Gap = z2.object({
+  id: z2.string().min(1),
+  startTime: z2.number().nonnegative(),
+  duration: z2.number().positive()
+}).strict();
+var TrackContent = z2.unknown().transform((val, ctx) => {
+  const hasSource = !!val && typeof val === "object" && "source" in val;
+  const res = (hasSource ? TimelineClip : Gap).safeParse(val);
+  if (!res.success) {
+    for (const issue of res.error.issues) ctx.addIssue(issue);
+    return z2.NEVER;
+  }
+  return res.data;
+});
+var Track = z2.object({
+  id: z2.string().min(1),
+  kind: z2.enum(["video", "audio", "image", "overlay", "effect"]),
+  name: z2.string().optional(),
+  enabled: z2.boolean().optional(),
+  volume: z2.number().min(0).max(4).optional(),
+  contents: z2.array(TrackContent)
+}).strict();
+var Marker = z2.object({
+  id: z2.string().min(1),
+  startTime: z2.number().nonnegative(),
+  endTime: z2.number().nonnegative().optional(),
+  kind: z2.string().min(1),
+  name: z2.string().optional(),
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+}).strict();
+var AccessControl = z2.object({
+  public: z2.boolean().optional(),
+  readerOrgIds: z2.array(z2.string()).optional(),
+  writerOrgIds: z2.array(z2.string()).optional()
+});
+var LicenseDeclaration = z2.object({
+  type: z2.string().min(1),
+  source: z2.string().optional(),
+  notes: z2.string().optional()
+});
+var CompositionAccessibility = z2.object({
+  audioDescriptionTrackId: z2.string().optional(),
+  captionsTrackId: z2.string().optional(),
+  signLanguageTrackId: z2.string().optional(),
+  notes: z2.string().optional()
+});
+var CaptionWord = z2.object({
+  text: z2.string().min(1),
+  startMs: z2.number().nonnegative().describe("Word start on the composition timeline, in milliseconds."),
+  endMs: z2.number().nonnegative().describe("Word end on the composition timeline, in milliseconds."),
+  emphasis: z2.boolean().optional(),
+  annotate: z2.enum(["circle", "underline"]).optional()
+});
+var CaptionStyle = z2.object({
+  fontFamily: z2.string().min(1).optional(),
+  fontSize: z2.number().min(1, "captions style.fontSize is PERCENT of composition height (1-15, default 5) \u2014 px values are not accepted").max(15, "captions style.fontSize is PERCENT of composition height (1-15, default 5) \u2014 px values are not accepted").optional().describe("Font size as % of composition height (1-15, default 5). NOT px."),
+  fontWeight: z2.number().int().min(100).max(900).optional(),
+  color: z2.string().min(1).optional(),
+  highlightColor: z2.string().min(1).optional(),
+  backgroundColor: z2.string().optional(),
+  plate: z2.enum(["glass", "solid", "none"]).optional(),
+  position: z2.enum(["top", "center", "bottom"]).optional(),
+  textTransform: z2.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisColor: z2.string().optional(),
+  emphasisGradient: z2.string().optional(),
+  emphasisScale: z2.number().positive().optional(),
+  emphasisFontFamily: z2.string().optional(),
+  emphasisFontWeight: z2.number().int().min(100).max(900).optional(),
+  emphasisTextTransform: z2.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisLetterSpacing: z2.number().optional(),
+  emphasisFontStyle: z2.enum(["normal", "italic"]).optional(),
+  entrance: z2.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+  entranceMs: z2.number().nonnegative().optional(),
+  entranceStaggerMs: z2.number().nonnegative().optional(),
+  exitMs: z2.number().nonnegative().optional(),
+  emphasisPlate: z2.boolean().optional(),
+  emphasisPlateColor: z2.string().optional(),
+  emphasisPlateTextColor: z2.string().optional(),
+  emphasisPlateAltColor: z2.string().optional(),
+  emphasisPlateAltTextColor: z2.string().optional(),
+  emphasisPlateRadius: z2.number().nonnegative().optional(),
+  emphasisPlatePadX: z2.number().optional(),
+  emphasisPlatePadY: z2.number().optional(),
+  annotationColor: z2.string().optional(),
+  maxWidthPercent: z2.number().positive().max(100, "captions style.maxWidthPercent is % of composition width (max 100)").optional()
+});
+var CaptionSegment = z2.object({
+  words: z2.array(CaptionWord)
+});
+var CaptionDepth = z2.enum(["front", "behind-subject"]).optional();
+var CompositionCaptions = z2.discriminatedUnion("source", [
+  z2.object({
+    source: z2.literal("derived"),
+    from: z2.object({ clipId: z2.string() }),
+    segments: z2.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  }),
+  z2.object({
+    source: z2.literal("authored"),
+    segments: z2.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  })
+]);
+function captionsAreBehindSubject(captions) {
+  return captions?.zPlane === "behind-subject";
+}
+function captionWords(c) {
+  return c.segments.flatMap((s) => s.words);
+}
+var Composition = z2.object({
+  v: z2.literal(1, {
+    errorMap: (_issue, ctx) => ctx.data === void 0 ? { message: 'Missing version envelope: add top-level "v": 1 to the composition.' } : { message: `Invalid version envelope: top-level "v" must be the literal 1 (got ${JSON.stringify(ctx.data)}).` }
+  }),
+  format: Format,
+  tracks: z2.array(Track),
+  markers: z2.array(Marker).optional(),
+  captions: CompositionCaptions.optional(),
+  sourceSuggestionId: z2.string().optional(),
+  license: LicenseDeclaration.optional(),
+  licenseVerification: z2.enum([
+    "attested",
+    "cueframe-verified",
+    "third-party-verified"
+  ]).optional(),
+  accessibility: CompositionAccessibility.optional(),
+  ownerOrgId: z2.string().optional(),
+  acl: AccessControl.optional()
+}).strict();
+var CompositionAuthorKind = z2.enum(["user", "agent", "import"]);
+var CompositionVersion = z2.object({
+  id: z2.string().min(1),
+  compositionId: OpaqueId,
+  predecessorId: z2.string().optional(),
+  createdAt: z2.number(),
+  // epoch ms — see CONVEX_ADAPTATIONS.md
+  etag: z2.string().min(1),
+  authorKind: CompositionAuthorKind,
+  // load-bearing for multi-agent lineage
+  authorId: z2.string().optional(),
+  // userId for 'user', agentId for 'agent', source for 'import'
+  composition: Composition
+});
+
+// ../composition/src/graphics-plan/schemas.ts
+import { z as z3 } from "zod";
+var GRAPHICS_PLAN_VERSION = "gp-1";
+var Version = z3.literal(GRAPHICS_PLAN_VERSION);
+var PlanRect = Region;
+var GraphicRole = z3.enum([
+  "title-card",
+  // topic-setter / opener card
+  "stat",
+  // a single headline number + label
+  "lower-third",
+  // name/title tag over the speaker
+  "pull-quote",
+  // a short quoted line
+  "hero",
+  // big behind-subject phrase (zPlane: behind-subject)
+  "logo-tag",
+  // small brand mark / watermark beat
+  "enumeration",
+  "sequence",
+  // an ordered chain of steps — often the POINT is that it is too long
+  "comparison"
+  // labelled values set against each other (a benchmark, a before/after)
+]);
+var Copy = z3.object({
+  headline: z3.string().max(120).optional(),
+  sub: z3.string().max(200).optional(),
+  value: z3.string().max(40).optional(),
+  label: z3.string().max(80).optional(),
+  items: z3.array(z3.string().max(80)).max(8).optional(),
+  series: z3.array(z3.object({ label: z3.string().max(40), value: z3.string().max(16) })).max(8).optional()
+}).strict();
+var ContentBeat = z3.object({
+  id: z3.string().min(1),
+  atSec: z3.number().min(0),
+  durSec: z3.number().positive(),
+  role: GraphicRole,
+  copy: Copy,
+  intent: z3.string().min(1).max(400),
+  priority: z3.number().int().min(0).max(10).default(5)
+}).strict();
+var ContentPlan = z3.object({
+  version: Version,
+  beats: z3.array(ContentBeat)
+}).strict();
+var ElementRole = z3.enum([
+  "headline",
+  // primary large text
+  "value",
+  // the stat number / the one word to remember
+  "label",
+  // supporting text
+  "sublabel",
+  // secondary supporting text
+  "logo",
+  // brand mark
+  "accent-shape",
+  // decorative block/line/underline
+  "backdrop"
+  // solid fill (takeover cards only)
+]);
+var StyleRole = z3.enum([
+  "heading",
+  "body",
+  "accent",
+  "surface",
+  "on-accent",
+  "on-surface"
+]);
+var ZPlane = z3.enum(["front", "behind-subject"]);
+var LayoutElement = z3.object({
+  elId: z3.string().min(1),
+  role: ElementRole,
+  box: PlanRect,
+  styleRole: StyleRole,
+  z: ZPlane.default("front"),
+  text: z3.string().max(200).optional(),
+  typeScaleStep: z3.number().int().min(0).max(8).optional()
+}).strict();
+var EPS = 1e-6;
+var rectsOverlapEps = (a, b) => a.x < b.x + b.w - EPS && a.x + a.w > b.x + EPS && a.y < b.y + b.h - EPS && a.y + a.h > b.y + EPS;
+var LayoutPlan = z3.object({
+  version: Version,
+  beatId: z3.string().min(1),
+  frame: z3.object({ w: z3.number().positive(), h: z3.number().positive() }).strict(),
+  keepOut: z3.array(PlanRect),
+  safe: z3.object({
+    titleSafe: z3.number().min(0).max(1),
+    actionSafe: z3.number().min(0).max(1)
+  }).strict(),
+  elements: z3.array(LayoutElement),
+  dropped: z3.object({ reason: z3.string().min(1) }).strict().optional()
+}).strict().superRefine((plan, ctx) => {
+  for (const el of plan.elements) {
+    if (el.z === "behind-subject") continue;
+    const b = el.box;
+    if (b.x + b.w > 1 + EPS || b.y + b.h > 1 + EPS) {
+      ctx.addIssue({ code: z3.ZodIssueCode.custom, message: `element ${el.elId} box spills past the frame`, path: ["elements"] });
+    }
+    for (const ko of plan.keepOut) {
+      if (rectsOverlapEps(b, ko)) {
+        ctx.addIssue({ code: z3.ZodIssueCode.custom, message: `element ${el.elId} overlaps a face keep-out (text on the speaker)`, path: ["elements"] });
+      }
+    }
+  }
+});
+var EnterType = z3.enum(["reveal", "fade", "rise", "count-up", "wipe"]);
+var EmphasisType = z3.enum(["pulse", "underline", "color-shift"]);
+var ExitType = z3.enum(["fade", "fall", "wipe", "cut"]);
+var Ease = z3.enum(["spring", "ease-out", "ease-in-out", "linear"]);
+var EnterMotion = z3.object({
+  type: EnterType,
+  atMs: z3.number().min(0),
+  durMs: z3.number().positive(),
+  ease: Ease.default("spring"),
+  stagger: z3.number().min(0).optional()
+}).strict();
+var EmphasisMotion = z3.object({ type: EmphasisType, atMs: z3.number().min(0), durMs: z3.number().positive() }).strict();
+var ExitMotion = z3.object({ type: ExitType, atMs: z3.number().min(0), durMs: z3.number().positive() }).strict();
+var MotionElement = z3.object({
+  elId: z3.string().min(1),
+  enter: EnterMotion,
+  emphasis: EmphasisMotion.optional(),
+  exit: ExitMotion.optional()
+}).strict();
+var MotionPlan = z3.object({
+  version: Version,
+  beatId: z3.string().min(1),
+  elements: z3.array(MotionElement)
+}).strict();
+var GraphicsPlan = z3.object({
+  version: Version,
+  content: ContentPlan,
+  layouts: z3.array(LayoutPlan),
+  motions: z3.array(MotionPlan)
+}).strict();
+
+export {
+  OpaqueId,
+  Format,
+  MediaClipSource,
+  ComponentClipSource,
+  OverlayClipSource,
+  EffectClipSource,
+  AlphaLayerClipSource,
+  CardClipSource,
+  CompositionClipSource,
+  ClipSource,
+  Transition,
+  Region,
+  ClipFit,
+  PerClipEffect,
+  KeyframeEasing,
+  Keyframe,
+  KeyframeChannel,
+  ANIMATABLE_PARAMS,
+  TimelineClip,
+  Gap,
+  TrackContent,
+  Track,
+  Marker,
+  CaptionWord,
+  CaptionStyle,
+  CaptionSegment,
+  CompositionCaptions,
+  captionsAreBehindSubject,
+  captionWords,
+  Composition,
+  CompositionAuthorKind,
+  CompositionVersion,
+  GRAPHICS_PLAN_VERSION,
+  PlanRect,
+  GraphicRole,
+  Copy,
+  ContentBeat,
+  ContentPlan,
+  ElementRole,
+  StyleRole,
+  ZPlane,
+  LayoutElement,
+  LayoutPlan,
+  EnterType,
+  EmphasisType,
+  ExitType,
+  Ease,
+  EnterMotion,
+  EmphasisMotion,
+  ExitMotion,
+  MotionElement,
+  MotionPlan,
+  GraphicsPlan
+};

package/dist/{chunk-XQ72DZKJ.js → chunk-7TQCR7AB.js}

@@ -1,7 +1,7 @@
 import {
   CueframeError,
   encodeError
-} from "./chunk-LLUW26BS.js";
+} from "./chunk-R5BMJ2NX.js";
 
 // ../execution/core/src/render/vcam/constants.ts
 var P_MIN = 0.5;