@cueframe/studio-contracts 0.1.0

package/dist/index.js

@@ -0,0 +1,1932 @@
+// src/commands.ts
+import { z as z7 } from "zod";
+
+// ../kernel/dist/chunk-2B5VJZHL.js
+import { z } from "zod";
+var Focus = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("frame-center") }),
+  z.object({ mode: z.literal("point"), x: z.number().min(0).max(1), y: z.number().min(0).max(1) }),
+  z.object({
+    mode: z.literal("face"),
+    faceId: z.string().min(1),
+    shotScale: z.enum(["close", "standard", "wide"]).optional()
+  }),
+  z.object({ mode: z.literal("all-faces") }),
+  z.object({ mode: z.literal("active-speaker") })
+]);
+var ReframeSegmentFields = z.object({
+  startSec: z.number().nonnegative().describe(
+    "Segment START in seconds, clip-relative. Segments tile the clip's duration in order."
+  ),
+  endSec: z.number().positive().describe(
+    "Segment END in seconds, clip-relative. The span (endSec \u2212 startSec) is this segment's duration \u2014 the window `ease` ramps over."
+  ),
+  focus: Focus.describe(
+    "WHO/WHAT the camera tracks this segment (the reframe center), selected by `mode`: `frame-center` = no tracking, hold the geometric center (static/graphic footage, or a pure zoom); `point` = lock to a fixed source-normalized {x,y} (a non-moving on-screen element); `face` = track a detected face by `faceId` (from get_media_context), with optional `shotScale` close|standard|wide for tightness; `all-faces` = frame the bounding box of every detected face (group/ensemble shots); `active-speaker` = follow whoever is speaking (diarized talking-head / podcast). Pick by what the beat is about; pair with `zoom` for how tight."
+  ),
+  intent: z.string().optional().describe(
+    "Optional editorial LABEL for diff/log readability (e.g. 'speaker-tight', 'wide-context'). Cosmetic \u2014 NOT honored by the derive math and excluded from the variant cache key."
+  ),
+  zoom: z.number().min(0.1).max(1).optional().describe(
+    "How TIGHT the framing is \u2014 the fraction of the source the output viewport shows. <1 punches IN (a smaller source fraction, magnified to fill the frame); 1 = the full frame (no crop). ~0.6\u20130.8 is a moderate push-in, ~0.5 a tight close-up, 0.1 the maximum zoom. There is NO zoom-OUT past the full frame (max 1). Omit for the full frame. MUTUALLY EXCLUSIVE with `focus.shotScale`: a face-tracked shot is sized EITHER by the editorial scale (shotScale, calibrated to the detected face) OR by an explicit zoom \u2014 never both."
+  ),
+  ease: z.object({
+    in: z.number().nonnegative().describe("Ease-IN ramp DURATION in seconds at the segment START."),
+    out: z.number().nonnegative().describe("Ease-OUT ramp DURATION in seconds at the segment END.")
+  }).optional().describe(
+    "Zoom/center ramp DURATIONS in SECONDS at this segment's edges \u2014 NOT a unitless 0\u20131 curve. ~0.3\u20130.6s reads as a snappy push; >1s reads sluggish. Keep `in` + `out` \u2264 the segment's duration (endSec \u2212 startSec): the two edges share the span, so to ramp across the WHOLE segment set one edge to the full duration and the other to 0. Omit for an instant cut to this framing."
+  ),
+  bias: z.object({
+    x: z.number().min(-0.3).max(0.3).describe("Horizontal nudge, source-normalized (+ = right)."),
+    y: z.number().min(-0.3).max(0.3).describe("Vertical nudge, source-normalized (+ = down).")
+  }).optional().describe(
+    "Optional FINE framing nudge off the focus center, source-normalized in [\u22120.3, 0.3]. A small correction (headroom, rule-of-thirds), NOT a reframe \u2014 use `focus`/`zoom` for the actual shot. Omit (treated as 0) to sit dead-center on the focus."
+  )
+});
+var ReframeSegment = ReframeSegmentFields.refine(
+  (s) => !(s.focus.mode === "face" && s.focus.shotScale !== void 0 && s.zoom !== void 0),
+  {
+    message: "a face segment takes EITHER focus.shotScale (editorial scale, calibrated to the detected face) OR an explicit zoom \u2014 never both; shotScale wins at bake time and the zoom would be silently discarded",
+    path: ["zoom"]
+  }
+);
+var Reframe = z.object({ segments: z.array(ReframeSegment).min(1) });
+
+// ../kernel/dist/chunk-AEGHEOO3.js
+import { z as z2 } from "zod";
+import { z as z22 } from "zod";
+import { z as z3 } from "zod";
+var OpaqueId = z2.string();
+var Format = z22.object({
+  aspectRatio: z22.enum(["16:9", "9:16", "1:1", "4:5"]),
+  fps: z22.union([z22.literal(24), z22.literal(30), z22.literal(60)]).optional(),
+  resolution: z22.enum(["hd", "fhd", "4k"]).optional(),
+  platform: z22.string().optional()
+});
+var Trim = z22.object({
+  start: z22.number().nonnegative(),
+  end: z22.number().nonnegative()
+});
+var ExcludedRange = z22.object({
+  start: z22.number().nonnegative(),
+  end: z22.number().nonnegative(),
+  reason: z22.string().optional()
+});
+var MediaClipSource = z22.object({
+  kind: z22.literal("media"),
+  mediaId: OpaqueId,
+  trim: Trim.optional(),
+  excludedRanges: z22.array(ExcludedRange).optional(),
+  volume: z22.number().min(0).max(4).optional(),
+  muted: z22.boolean().optional(),
+  playbackRate: z22.number().positive().optional(),
+  sync: z22.enum(["video", "independent"]).optional(),
+  kenBurns: z22.enum(["in", "out", "pan-l", "pan-r", "none"]).optional(),
+  volumeDb: z22.number().optional(),
+  fadeInMs: z22.number().nonnegative().optional(),
+  fadeOutMs: z22.number().nonnegative().optional(),
+  loop: z22.boolean().optional(),
+  audioRole: z22.enum(["sfx", "music", "vo", "ambience"]).optional(),
+  duck: z22.object({
+    duckDb: z22.number().max(0),
+    attackMs: z22.number().nonnegative(),
+    releaseMs: z22.number().nonnegative(),
+    windows: z22.array(z22.object({ startMs: z22.number(), endMs: z22.number() })).optional()
+  }).optional(),
+  anchor: z22.object({
+    clipId: z22.string().min(1),
+    offsetMs: z22.number()
+  }).optional(),
+  reframe: Reframe.optional()
+});
+var ComponentClipSource = z22.object({
+  kind: z22.literal("component"),
+  componentId: z22.string().min(1),
+  props: z22.record(z22.string(), z22.unknown()),
+  zPlane: z22.enum(["front", "behind-subject"]).optional()
+});
+var OverlayClipSource = z22.object({
+  kind: z22.literal("overlay"),
+  primitiveId: z22.string().min(1),
+  params: z22.record(z22.string(), z22.unknown()),
+  zPlane: z22.enum(["front", "behind-subject"]).optional(),
+  anchor: z22.object({ space: z22.literal("scene"), x: z22.number().min(0).max(1), y: z22.number().min(0).max(1) }).optional(),
+  parallax: z22.number().min(-0.3).max(0.3).optional()
+});
+var EffectClipSource = z22.object({
+  kind: z22.literal("effect"),
+  primitiveId: z22.string().min(1),
+  params: z22.record(z22.string(), z22.unknown()).optional()
+});
+var AlphaLayerClipSource = z22.object({
+  kind: z22.literal("alpha-layer"),
+  componentId: z22.string().min(1),
+  props: z22.record(z22.string(), z22.unknown()),
+  zPlane: z22.enum(["front", "behind-subject"]).optional()
+});
+var CardClipSource = z22.object({
+  kind: z22.literal("card"),
+  html: z22.string().min(1),
+  tokens: z22.record(z22.string(), z22.string()).optional(),
+  zPlane: z22.literal("front").optional()
+});
+var CompositionClipSource = z22.object({
+  kind: z22.literal("composition"),
+  compositionId: z22.string().min(1),
+  trim: Trim.optional()
+}).strict();
+var ClipSource = z22.discriminatedUnion("kind", [
+  MediaClipSource,
+  ComponentClipSource,
+  OverlayClipSource,
+  EffectClipSource,
+  AlphaLayerClipSource,
+  CardClipSource,
+  CompositionClipSource
+]);
+var Transition = z22.object({
+  type: z22.string().min(1),
+  duration: z22.number().positive()
+});
+var Position = z22.object({
+  x: z22.number(),
+  y: z22.number()
+});
+var Region = z22.object({
+  x: z22.number().min(0).max(1),
+  y: z22.number().min(0).max(1),
+  w: z22.number().positive().max(1),
+  h: z22.number().positive().max(1)
+});
+var ClipFit = z22.enum(["cover", "contain"]);
+var PerClipEffect = z22.object({
+  primitiveId: z22.string().min(1),
+  params: z22.record(z22.string(), z22.unknown()).optional()
+});
+var KeyframeEasing = z22.union([
+  z22.enum(["linear", "ease", "easeIn", "easeOut", "easeInOut"]),
+  z22.object({ cubicBezier: z22.tuple([z22.number(), z22.number(), z22.number(), z22.number()]) }).strict()
+]);
+var Keyframe = z22.object({
+  time: z22.number().nonnegative(),
+  value: z22.number(),
+  easing: KeyframeEasing.optional()
+}).strict();
+var KeyframeChannel = z22.array(Keyframe).min(2);
+var ANIMATABLE_PARAMS = [
+  "opacity",
+  "scale",
+  "rotation",
+  "position.x",
+  "position.y",
+  "volume"
+];
+var TimelineClip = z22.object({
+  id: z22.string().min(1),
+  startTime: z22.number().nonnegative(),
+  duration: z22.number().positive(),
+  source: ClipSource,
+  kind: z22.enum(["video", "audio", "image", "overlay", "effect"]).optional(),
+  opacity: z22.number().min(0).max(1).optional(),
+  scale: z22.number().positive().optional(),
+  rotation: z22.number().optional(),
+  position: Position.optional(),
+  region: Region.optional(),
+  fit: ClipFit.optional(),
+  effects: z22.array(PerClipEffect).optional(),
+  transitionIn: Transition.optional(),
+  linkGroupId: z22.string().min(1).optional(),
+  animate: z22.record(z22.string(), KeyframeChannel).superRefine((channels, ctx) => {
+    for (const key of Object.keys(channels)) {
+      if (!ANIMATABLE_PARAMS.includes(key)) {
+        ctx.addIssue({
+          code: z22.ZodIssueCode.custom,
+          path: [key],
+          message: `"${key}" is not an animatable param (${ANIMATABLE_PARAMS.join(", ")})`
+        });
+      }
+    }
+  }).optional()
+}).strict();
+var Gap = z22.object({
+  id: z22.string().min(1),
+  startTime: z22.number().nonnegative(),
+  duration: z22.number().positive()
+}).strict();
+var TrackContent = z22.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 z22.NEVER;
+  }
+  return res.data;
+});
+var Track = z22.object({
+  id: z22.string().min(1),
+  kind: z22.enum(["video", "audio", "image", "overlay", "effect"]),
+  name: z22.string().optional(),
+  enabled: z22.boolean().optional(),
+  volume: z22.number().min(0).max(4).optional(),
+  contents: z22.array(TrackContent)
+}).strict();
+var Marker = z22.object({
+  id: z22.string().min(1),
+  startTime: z22.number().nonnegative(),
+  endTime: z22.number().nonnegative().optional(),
+  kind: z22.string().min(1),
+  name: z22.string().optional(),
+  metadata: z22.record(z22.string(), z22.unknown()).optional()
+}).strict();
+var AccessControl = z22.object({
+  public: z22.boolean().optional(),
+  readerOrgIds: z22.array(z22.string()).optional(),
+  writerOrgIds: z22.array(z22.string()).optional()
+});
+var LicenseDeclaration = z22.object({
+  type: z22.string().min(1),
+  source: z22.string().optional(),
+  notes: z22.string().optional()
+});
+var CompositionAccessibility = z22.object({
+  audioDescriptionTrackId: z22.string().optional(),
+  captionsTrackId: z22.string().optional(),
+  signLanguageTrackId: z22.string().optional(),
+  notes: z22.string().optional()
+});
+var CaptionWord = z22.object({
+  text: z22.string().min(1),
+  startMs: z22.number().nonnegative(),
+  endMs: z22.number().nonnegative(),
+  emphasis: z22.boolean().optional(),
+  annotate: z22.enum(["circle", "underline"]).optional()
+});
+var CaptionStyle = z22.object({
+  fontFamily: z22.string().min(1).optional(),
+  fontSize: z22.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: z22.number().int().min(100).max(900).optional(),
+  color: z22.string().min(1).optional(),
+  highlightColor: z22.string().min(1).optional(),
+  backgroundColor: z22.string().optional(),
+  plate: z22.enum(["glass", "solid", "none"]).optional(),
+  position: z22.enum(["top", "center", "bottom"]).optional(),
+  textTransform: z22.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisColor: z22.string().optional(),
+  emphasisGradient: z22.string().optional(),
+  emphasisScale: z22.number().positive().optional(),
+  emphasisFontFamily: z22.string().optional(),
+  emphasisFontWeight: z22.number().int().min(100).max(900).optional(),
+  emphasisTextTransform: z22.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisLetterSpacing: z22.number().optional(),
+  emphasisFontStyle: z22.enum(["normal", "italic"]).optional(),
+  entrance: z22.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+  entranceMs: z22.number().nonnegative().optional(),
+  entranceStaggerMs: z22.number().nonnegative().optional(),
+  exitMs: z22.number().nonnegative().optional(),
+  emphasisPlate: z22.boolean().optional(),
+  emphasisPlateColor: z22.string().optional(),
+  emphasisPlateTextColor: z22.string().optional(),
+  emphasisPlateAltColor: z22.string().optional(),
+  emphasisPlateAltTextColor: z22.string().optional(),
+  emphasisPlateRadius: z22.number().nonnegative().optional(),
+  emphasisPlatePadX: z22.number().optional(),
+  emphasisPlatePadY: z22.number().optional(),
+  annotationColor: z22.string().optional(),
+  maxWidthPercent: z22.number().positive().max(100, "captions style.maxWidthPercent is % of composition width (max 100)").optional()
+});
+var CaptionSegment = z22.object({
+  words: z22.array(CaptionWord)
+});
+var CaptionDepth = z22.enum(["front", "behind-subject"]).optional();
+var CompositionCaptions = z22.discriminatedUnion("source", [
+  z22.object({
+    source: z22.literal("derived"),
+    from: z22.object({ clipId: z22.string() }),
+    segments: z22.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  }),
+  z22.object({
+    source: z22.literal("authored"),
+    segments: z22.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  })
+]);
+var Composition = z22.object({
+  v: z22.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: z22.array(Track),
+  markers: z22.array(Marker).optional(),
+  captions: CompositionCaptions.optional(),
+  sourceSuggestionId: z22.string().optional(),
+  license: LicenseDeclaration.optional(),
+  licenseVerification: z22.enum([
+    "attested",
+    "cueframe-verified",
+    "third-party-verified"
+  ]).optional(),
+  accessibility: CompositionAccessibility.optional(),
+  ownerOrgId: z22.string().optional(),
+  acl: AccessControl.optional()
+}).strict();
+var CompositionAuthorKind = z22.enum(["user", "agent", "import"]);
+var CompositionVersion = z22.object({
+  id: z22.string().min(1),
+  compositionId: OpaqueId,
+  predecessorId: z22.string().optional(),
+  createdAt: z22.number(),
+  // epoch ms — see CONVEX_ADAPTATIONS.md
+  etag: z22.string().min(1),
+  authorKind: CompositionAuthorKind,
+  // load-bearing for multi-agent lineage
+  authorId: z22.string().optional(),
+  // userId for 'user', agentId for 'agent', source for 'import'
+  composition: Composition
+});
+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();
+
+// ../kernel/dist/composition-ops.js
+import { z as z4 } from "zod";
+var CompositionOp = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("clip.add"), clip: TimelineClip, trackId: z4.string().optional(), newTrack: z4.boolean().optional(), newTrackId: z4.string().optional() }).strict(),
+  z4.object({ type: z4.literal("clip.remove"), clipId: z4.string() }).strict(),
+  z4.object({ type: z4.literal("clip.update"), clipId: z4.string(), patch: TimelineClip.partial() }).strict(),
+  z4.object({ type: z4.literal("removeClipsByMediaId"), mediaId: z4.string() }).strict(),
+  z4.object({ type: z4.literal("loadOverlays"), clips: z4.array(TimelineClip) }).strict(),
+  z4.object({ type: z4.literal("addMarker"), marker: Marker }).strict(),
+  z4.object({ type: z4.literal("removeMarker"), markerId: z4.string() }).strict(),
+  z4.object({ type: z4.literal("updateMarker"), markerId: z4.string(), updates: Marker.partial() }).strict(),
+  z4.object({ type: z4.literal("setCropIntents"), clipId: z4.string(), segments: z4.array(ReframeSegment).nullable() }).strict(),
+  z4.object({ type: z4.literal("setEffects"), clipId: z4.string(), effects: z4.array(PerClipEffect) }).strict(),
+  z4.object({ type: z4.literal("setCaptionStyle"), style: CaptionStyle.partial() }).strict(),
+  z4.object({ type: z4.literal("setCaptionDepth"), zPlane: z4.enum(["front", "behind-subject"]) }).strict(),
+  z4.object({ type: z4.literal("setCaptions"), segments: z4.array(CaptionSegment), style: CaptionStyle.partial().optional() }).strict(),
+  z4.object({ type: z4.literal("applyMotionPreset"), clipId: z4.string(), preset: z4.string(), params: z4.object({ enterMs: z4.number().optional(), exitMs: z4.number().optional(), staggerMs: z4.number().optional() }).strict().optional() }).strict(),
+  z4.object({ type: z4.literal("materializeGrid"), clipId: z4.string(), grid: z4.enum(["beat", "word", "shot"]), maxMarkers: z4.number().int().positive().max(2e3).optional() }).strict(),
+  z4.object({
+    type: z4.literal("captions.fromTranscript"),
+    mediaId: z4.string().min(1),
+    window: z4.object({ startSec: z4.number().min(0), endSec: z4.number().positive() }).strict().optional()
+  }).strict(),
+  z4.object({ type: z4.literal("setFormat"), format: Format.pick({ aspectRatio: true, fps: true, resolution: true }) }).strict(),
+  z4.object({ type: z4.literal("addTrack"), kind: Track.shape.kind, name: z4.string().optional(), id: z4.string().optional() }).strict(),
+  z4.object({ type: z4.literal("removeTrack"), trackId: z4.string() }).strict(),
+  z4.object({ type: z4.literal("updateTrack"), trackId: z4.string(), updates: Track.pick({ name: true, enabled: true, volume: true }).partial() }).strict(),
+  z4.object({ type: z4.literal("reorderTracks"), fromIndex: z4.number(), toIndex: z4.number() }).strict(),
+  z4.object({ type: z4.literal("moveClipToTrack"), clipId: z4.string(), targetTrackId: z4.string(), newStartTime: z4.number().optional() }).strict(),
+  z4.object({ type: z4.literal("duplicateClip"), clipId: z4.string(), newClipId: z4.string().optional() }).strict(),
+  z4.object({ type: z4.literal("cutAndRipple"), start: z4.number(), end: z4.number() }).strict(),
+  z4.object({ type: z4.literal("ripple"), time: z4.number(), amount: z4.number() }).strict(),
+  z4.object({ type: z4.literal("addExcludedRange"), clipId: z4.string(), sourceStart: z4.number(), sourceEnd: z4.number(), reason: z4.string().optional() }).strict(),
+  z4.object({ type: z4.literal("removeExcludedRange"), clipId: z4.string(), rangeIdx: z4.number() }).strict()
+]);
+
+// src/revisions.ts
+import { z as z5 } from "zod";
+var AggregateRevision = z5.number().int().nonnegative();
+
+// src/ids.ts
+import { z as z6 } from "zod";
+
+// src/bounds.ts
+var STUDIO_LIMITS = {
+  id: 128,
+  name: 255,
+  title: 200,
+  description: 1e4,
+  query: 500,
+  cursor: 4096,
+  version: 128,
+  shortText: 1e3,
+  longText: 1e5,
+  conversationMessages: 1e6,
+  componentBundle: 1e6,
+  collection: 1e3,
+  componentIds: 100,
+  timelineWords: 2e4,
+  commandOperations: 500,
+  commandPayloadBytes: 2e6,
+  jsonDepth: 8,
+  jsonCollection: 100,
+  pathSegment: 255,
+  contentType: 255,
+  templateContent: 1e6,
+  uploadBytes: 10 * 1024 * 1024 * 1024
+};
+
+// src/ids.ts
+var OpaqueId2 = z6.string().min(1).max(STUDIO_LIMITS.id);
+var ProjectId = OpaqueId2;
+var CompositionId = OpaqueId2;
+var CommandId = z6.string().min(1).max(128);
+var OperationId = z6.string().min(1).max(128);
+var JournalClientId = z6.string().min(1).max(128).regex(/^[^:]+$/);
+var JournalSequence = z6.number().int().positive().safe();
+
+// src/commands.ts
+var DurableCommandFields = {
+  commandId: CommandId,
+  expectedRevision: AggregateRevision
+};
+var DurableCommand = z7.object(DurableCommandFields).strict();
+var DurableOperation = z7.object({
+  operationId: OperationId,
+  operation: CompositionOp
+}).strict();
+var JournalCommandFields = {
+  ...DurableCommandFields,
+  clientId: JournalClientId,
+  sequence: JournalSequence
+};
+function isStructuredJournalCommand(value) {
+  return value.commandId === `${value.clientId}:${value.sequence}`;
+}
+function boundedPayload(schema) {
+  return z7.preprocess((value) => {
+    try {
+      return new TextEncoder().encode(JSON.stringify(value)).byteLength <= STUDIO_LIMITS.commandPayloadBytes ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }, schema);
+}
+var ApplyCompositionInput = z7.object({
+  projectId: ProjectId,
+  ...JournalCommandFields,
+  operations: boundedPayload(z7.array(DurableOperation).min(1).max(STUDIO_LIMITS.commandOperations))
+}).strict().refine(isStructuredJournalCommand, "commandId must equal clientId:sequence");
+var ReplaceCompositionInput = z7.object({
+  projectId: ProjectId,
+  ...JournalCommandFields,
+  operationId: OperationId,
+  composition: boundedPayload(Composition)
+}).strict().refine(isStructuredJournalCommand, "commandId must equal clientId:sequence");
+var CompositionCommitProjection = z7.object({
+  commandId: CommandId,
+  projectId: ProjectId,
+  compositionId: CompositionId,
+  revision: AggregateRevision,
+  acknowledgedOperationIds: z7.array(OperationId).max(STUDIO_LIMITS.commandOperations)
+});
+var ProjectSettings = z7.object({ width: z7.number().positive(), height: z7.number().positive() }).strict();
+var CreateProjectInput = z7.object({
+  commandId: CommandId,
+  name: z7.string().min(1).max(STUDIO_LIMITS.name),
+  description: z7.string().max(STUDIO_LIMITS.description).optional(),
+  settings: ProjectSettings.optional()
+}).strict();
+var UpdateProjectInput = z7.object({
+  projectId: ProjectId,
+  ...DurableCommandFields,
+  name: z7.string().min(1).max(STUDIO_LIMITS.name).optional(),
+  description: z7.string().max(STUDIO_LIMITS.description).optional(),
+  settings: ProjectSettings.optional()
+}).strict().refine(
+  (value) => value.name !== void 0 || value.description !== void 0 || value.settings !== void 0,
+  "at least one project field is required"
+);
+var RemoveProjectInput = z7.object({
+  projectId: ProjectId,
+  ...DurableCommandFields
+}).strict();
+
+// src/assistant.ts
+import { z as z8 } from "zod";
+var AssistantId = z8.string().min(1).max(512);
+var AssistantResolveThreadInput = z8.object({
+  conversationKey: AssistantId
+}).strict();
+var AssistantThreadProjection = z8.object({
+  threadId: AssistantId
+});
+var AssistantForgetConversationInput = AssistantResolveThreadInput;
+var AssistantForgetConversationProjection = z8.object({
+  deleted: z8.boolean()
+});
+var AssistantSendInput = z8.object({
+  threadId: AssistantId,
+  prompt: z8.string().min(1).max(32e3),
+  scope: z8.string().min(1).max(128),
+  projectId: ProjectId.optional()
+}).strict();
+var AssistantSendProjection = AssistantThreadProjection;
+var AssistantMessagesInput = z8.object({
+  threadId: AssistantId
+}).strict();
+var AssistantMessageProjection = z8.object({
+  id: AssistantId,
+  role: z8.enum(["user", "assistant", "system", "tool"]),
+  parts: z8.array(z8.record(z8.unknown())).max(512),
+  text: z8.string().max(1e6).optional(),
+  status: z8.string().min(1).max(64),
+  createdAt: z8.number()
+});
+var AssistantMessagesProjection = z8.object({
+  messages: z8.array(AssistantMessageProjection).max(1e4)
+});
+
+// src/compatibility.ts
+import { z as z9 } from "zod";
+var STUDIO_CONTRACT_VERSION = 1;
+var CompatibilityInput = z9.object({
+  clientVersion: z9.string().min(1).max(STUDIO_LIMITS.version),
+  contractVersion: z9.literal(STUDIO_CONTRACT_VERSION)
+}).strict();
+var CompatibilityProjection = z9.object({
+  compatible: z9.boolean(),
+  contractVersion: z9.literal(STUDIO_CONTRACT_VERSION),
+  minimumClientVersion: z9.string().min(1).max(STUDIO_LIMITS.version)
+});
+
+// src/errors.ts
+import { z as z12 } from "zod";
+
+// src/library.ts
+import { z as z11 } from "zod";
+
+// src/pagination.ts
+import { z as z10 } from "zod";
+var STUDIO_PAGE_MAX = 100;
+var PageInput = z10.object({
+  cursor: z10.string().min(1).max(STUDIO_LIMITS.cursor).optional(),
+  limit: z10.number().int().positive().max(STUDIO_PAGE_MAX)
+}).strict();
+var pageResult = (item) => z10.object({
+  items: z10.array(item).max(STUDIO_PAGE_MAX),
+  nextCursor: z10.string().max(STUDIO_LIMITS.cursor).nullable(),
+  done: z10.boolean()
+});
+
+// src/library.ts
+var ShortText = z11.string().max(STUDIO_LIMITS.shortText);
+var LongText = z11.string().max(STUDIO_LIMITS.longText);
+var Name = z11.string().min(1).max(STUDIO_LIMITS.name);
+var PathSegment = z11.string().min(1).max(STUDIO_LIMITS.pathSegment).regex(/^[^/\\\0]+$/);
+var ContentType = z11.string().min(1).max(STUDIO_LIMITS.contentType);
+var UploadSize = z11.number().int().nonnegative().max(STUDIO_LIMITS.uploadBytes);
+var boundedRecord = (value, maxEntries = 100) => z11.record(z11.string().min(1).max(STUDIO_LIMITS.pathSegment), value).refine((record) => Object.keys(record).length <= maxEntries, `must contain at most ${maxEntries} entries`);
+var JsonPrimitive = z11.union([
+  LongText,
+  z11.number().finite(),
+  z11.boolean(),
+  z11.null()
+]);
+function jsonValueAtDepth(depth) {
+  if (depth === 0) return JsonPrimitive;
+  const child = jsonValueAtDepth(depth - 1);
+  return z11.union([
+    JsonPrimitive,
+    z11.array(child).max(STUDIO_LIMITS.jsonCollection),
+    boundedRecord(child, STUDIO_LIMITS.jsonCollection)
+  ]);
+}
+var JsonValue = jsonValueAtDepth(STUDIO_LIMITS.jsonDepth);
+var EmptyInput = z11.object({}).strict();
+var MediaMetadataProjection = z11.object({
+  duration: z11.number().optional(),
+  width: z11.number(),
+  height: z11.number(),
+  codec: ShortText,
+  frameRate: z11.number(),
+  fileSize: z11.number(),
+  audioOffset: z11.number()
+});
+var MediaProcessingStatusProjection = z11.object({
+  phase: ShortText,
+  percent: z11.number().nullable(),
+  message: LongText.nullable(),
+  error: LongText.nullable()
+});
+var PublicMatteEntryProjection = z11.object({
+  status: z11.enum(["pending", "ready", "failed"]),
+  geometryUrl: z11.string().url().max(8192).optional(),
+  matteUrl: z11.string().url().max(8192).optional(),
+  bakeVersion: ShortText.optional(),
+  presenceFraction: z11.number().min(0).max(1).optional(),
+  window: z11.object({ startSec: z11.number(), endSec: z11.number() }).optional()
+});
+var PublicSubjectTrackEntryProjection = z11.object({
+  status: z11.enum(["pending", "ready", "failed"]),
+  trackUrl: z11.string().url().max(8192).optional(),
+  detectorVersion: ShortText.optional(),
+  window: z11.object({ startSec: z11.number(), endSec: z11.number() }).optional(),
+  faces: z11.array(z11.object({
+    faceId: OpaqueId2,
+    bbox: z11.object({ x: z11.number(), y: z11.number(), width: z11.number(), height: z11.number() }),
+    speakingShare: z11.number().optional()
+  })).max(STUDIO_LIMITS.collection).optional()
+});
+var MediaItemProjection = z11.object({
+  id: OpaqueId2,
+  name: Name,
+  kind: z11.enum(["video", "audio", "image"]),
+  assetUrl: z11.string().max(8192),
+  metadata: MediaMetadataProjection.nullable(),
+  processingStatus: MediaProcessingStatusProjection,
+  createdAt: z11.number(),
+  proxyUrl: z11.string().max(8192).nullable(),
+  proxyStatus: z11.enum(["none", "generating", "ready", "failed"]),
+  mediaSource: ShortText.optional(),
+  mattes: boundedRecord(PublicMatteEntryProjection).optional(),
+  subjectTracks: boundedRecord(PublicSubjectTrackEntryProjection).optional()
+});
+var MediaListInput = PageInput;
+var MediaListProjection = pageResult(MediaItemProjection);
+var MediaIdInput = z11.object({ mediaId: OpaqueId2 }).strict();
+var MediaCommandInput = z11.object({ mediaId: OpaqueId2, commandId: CommandId }).strict();
+var MediaMutationProjection = z11.object({ mediaId: OpaqueId2, commandId: CommandId });
+var MediaUnderstandingProjection = z11.object({
+  mediaId: OpaqueId2,
+  summary: LongText,
+  scenes: z11.array(z11.object({
+    startTime: z11.number(),
+    endTime: z11.number(),
+    description: ShortText
+  })).max(STUDIO_LIMITS.collection),
+  tags: z11.array(ShortText).max(STUDIO_LIMITS.collection)
+});
+var MediaUnderstandingListInput = PageInput;
+var MediaUnderstandingListProjection = pageResult(MediaUnderstandingProjection);
+var TranscriptProjection = z11.object({
+  id: OpaqueId2,
+  mediaItemId: OpaqueId2,
+  downloadVersion: ShortText.nullable(),
+  model: ShortText.nullable(),
+  language: z11.string().max(64).nullable(),
+  createdAt: z11.number()
+});
+var TranscriptListInput = PageInput.extend({ projectId: ProjectId.optional() }).strict();
+var TranscriptListProjection = pageResult(TranscriptProjection);
+var TranscriptDownloadInput = MediaIdInput;
+var TranscriptDownloadProjection = z11.object({
+  transcriptId: OpaqueId2,
+  presignedUrl: z11.string().url().max(8192).nullable(),
+  model: ShortText.nullable(),
+  language: z11.string().max(64).nullable(),
+  version: ShortText
+});
+var TranscriptSearchInput = z11.object({
+  query: z11.string().min(1).max(STUDIO_LIMITS.query),
+  limit: z11.number().int().positive().max(200)
+}).strict();
+var TranscriptSearchProjection = z11.object({
+  candidates: z11.array(TranscriptProjection).max(200)
+});
+var CorrectionProjection = z11.object({ key: z11.string().min(1).max(256), text: LongText });
+var CorrectionListInput = PageInput.extend({ projectId: ProjectId }).strict();
+var CorrectionListProjection = pageResult(CorrectionProjection);
+var SaveCorrectionInput = z11.object({
+  projectId: ProjectId,
+  commandId: CommandId,
+  key: z11.string().min(1).max(256),
+  text: LongText
+}).strict();
+var RemoveCorrectionInput = z11.object({
+  projectId: ProjectId,
+  commandId: CommandId,
+  key: z11.string().min(1).max(256)
+}).strict();
+var CorrectionMutationProjection = z11.object({ commandId: CommandId, key: z11.string().max(256) });
+var UserSettingsProjection = z11.object({
+  activeBrandKitId: OpaqueId2.nullable(),
+  enableUnderstanding: z11.boolean()
+});
+var UpdateProcessingSettingsInput = z11.object({
+  commandId: CommandId,
+  activeBrandKitId: OpaqueId2.nullable().optional(),
+  enableUnderstanding: z11.boolean().optional()
+}).strict().refine(
+  (value) => value.activeBrandKitId !== void 0 || value.enableUnderstanding !== void 0,
+  "at least one processing setting is required"
+);
+var UserSettingsMutationProjection = UserSettingsProjection.extend({ commandId: CommandId });
+var BrandKitProjection = z11.object({
+  id: OpaqueId2,
+  name: Name,
+  description: z11.string().max(STUDIO_LIMITS.description).optional(),
+  tagline: ShortText.optional(),
+  secondaryTagline: ShortText.optional(),
+  colors: z11.object({
+    primary: z11.string().max(128),
+    secondary: z11.string().max(128),
+    accent: z11.string().max(128),
+    background: z11.string().max(128),
+    text: z11.string().max(128)
+  }),
+  extraColors: z11.array(z11.object({
+    hex: z11.string().max(128),
+    label: z11.string().max(128),
+    usage: ShortText.optional()
+  })).max(64),
+  headingFont: z11.object({ fontFamily: z11.string().max(255), fontWeight: z11.number().int().min(1).max(1e3) }),
+  bodyFont: z11.object({ fontFamily: z11.string().max(255), fontWeight: z11.number().int().min(1).max(1e3) }),
+  voiceGuidelines: LongText,
+  syncCaptions: z11.boolean(),
+  captionProfile: boundedRecord(JsonValue, 64).optional(),
+  createdAt: z11.number(),
+  modifiedAt: z11.number()
+});
+var BrandKitListInput = PageInput;
+var BrandKitListProjection = pageResult(BrandKitProjection);
+var UpsertBrandKitInput = z11.object({
+  commandId: CommandId,
+  brandKit: BrandKitProjection
+}).strict();
+var BrandKitMutationProjection = z11.object({ commandId: CommandId, brandKit: BrandKitProjection });
+var ComponentProjection = z11.object({
+  id: OpaqueId2,
+  name: Name,
+  category: ShortText,
+  bundleVersion: z11.string().min(1).max(128),
+  integritySha256: z11.string().regex(/^sha256:[a-f0-9]{64}$/)
+});
+var ComponentListInput = PageInput;
+var ComponentListProjection = pageResult(ComponentProjection);
+var ComponentBundlesInput = z11.object({
+  componentIds: z11.array(OpaqueId2).min(1).max(STUDIO_LIMITS.componentIds)
+}).strict();
+var ComponentBundleProjection = z11.object({
+  componentId: OpaqueId2,
+  version: z11.string().min(1).max(128),
+  integritySha256: z11.string().regex(/^sha256:[a-f0-9]{64}$/),
+  source: z11.string().max(STUDIO_LIMITS.componentBundle)
+});
+var ComponentBundlesProjection = z11.object({
+  bundles: z11.array(ComponentBundleProjection).max(STUDIO_LIMITS.componentIds)
+});
+var ProjectRefProjection = z11.object({ id: OpaqueId2, home: z11.enum(["local", "cloud"]) });
+var ConversationProjection = z11.object({
+  id: OpaqueId2,
+  title: z11.string().max(STUDIO_LIMITS.title),
+  project: ProjectRefProjection.nullable(),
+  createdAt: z11.number(),
+  updatedAt: z11.number(),
+  messages: z11.string().max(STUDIO_LIMITS.conversationMessages)
+});
+var ConversationListInput = PageInput.extend({ project: ProjectRefProjection.nullable() }).strict();
+var ConversationListProjection = pageResult(ConversationProjection.omit({ messages: true }));
+var ConversationGetInput = z11.object({
+  conversationId: OpaqueId2,
+  project: ProjectRefProjection.nullable()
+}).strict();
+var ConversationGetProjection = z11.object({ conversation: ConversationProjection.nullable() });
+var SaveConversationInput = z11.object({
+  commandId: CommandId,
+  conversation: ConversationProjection
+}).strict();
+var RemoveConversationInput = z11.object({ commandId: CommandId, conversationId: OpaqueId2 }).strict();
+var ConversationMutationProjection = z11.object({ commandId: CommandId, conversationId: OpaqueId2 });
+var RestorePointProjection = z11.object({
+  id: OpaqueId2,
+  conversationId: OpaqueId2,
+  project: ProjectRefProjection,
+  label: z11.string().max(STUDIO_LIMITS.title),
+  createdAt: z11.number()
+});
+var RestorePointListInput = PageInput.extend({ conversationId: OpaqueId2 }).strict();
+var RestorePointListProjection = pageResult(RestorePointProjection);
+var ForgetRestorePointsInput = z11.object({ commandId: CommandId, conversationId: OpaqueId2 }).strict();
+var RestoreToPointInput = z11.object({
+  commandId: CommandId,
+  projectId: ProjectId,
+  expectedRevision: z11.number().int().nonnegative(),
+  conversationId: OpaqueId2,
+  restorePointId: OpaqueId2
+}).strict();
+var RestorePointMutationProjection = z11.object({ commandId: CommandId, conversationId: OpaqueId2 });
+var RestorePointCommitProjection = z11.object({
+  commandId: CommandId,
+  conversationId: OpaqueId2,
+  restorePointId: OpaqueId2,
+  projectId: ProjectId,
+  compositionId: OpaqueId2,
+  revision: z11.number().int().nonnegative()
+});
+var RenderJobProjection = z11.object({
+  id: OpaqueId2,
+  status: ShortText,
+  progress: z11.number(),
+  hasOutput: z11.boolean(),
+  error: LongText.nullable(),
+  createdAt: z11.number()
+});
+var RenderListInput = PageInput.extend({ projectId: ProjectId }).strict();
+var RenderListProjection = pageResult(RenderJobProjection);
+var RenderPresignInput = z11.object({ renderId: OpaqueId2 }).strict();
+var RenderPresignProjection = z11.object({ url: z11.string().url().max(8192).nullable() });
+var CreateRenderInput = z11.object({
+  projectId: ProjectId,
+  commandId: CommandId,
+  expectedRevision: z11.number().int().nonnegative(),
+  format: z11.object({
+    aspectRatio: z11.string().max(64),
+    resolution: z11.enum(["fhd", "4k"])
+  }).optional()
+}).strict();
+var CreateRenderProjection = z11.object({
+  commandId: CommandId,
+  renderId: OpaqueId2,
+  revision: z11.number().int().nonnegative()
+});
+var CancelRenderInput = z11.object({
+  projectId: ProjectId,
+  renderId: OpaqueId2,
+  commandId: CommandId
+}).strict();
+var CancelRenderProjection = z11.object({ commandId: CommandId, renderId: OpaqueId2 });
+var MediaSearchInput = z11.object({
+  query: z11.string().min(1).max(STUDIO_LIMITS.query),
+  limit: z11.number().int().positive().max(25)
+}).strict();
+var MediaSearchHitProjection = z11.object({
+  mediaId: OpaqueId2,
+  name: Name,
+  score: z11.number(),
+  startSec: z11.number(),
+  endSec: z11.number()
+});
+var MediaSearchProjection = z11.object({
+  results: z11.array(MediaSearchHitProjection).max(25),
+  indexing: z11.boolean()
+});
+var TimelineWordInput = z11.object({
+  text: ShortText,
+  timelineStart: z11.number(),
+  timelineEnd: z11.number(),
+  clipId: OpaqueId2,
+  poolItemId: OpaqueId2,
+  sourceStart: z11.number(),
+  sourceEnd: z11.number(),
+  speakerId: OpaqueId2.nullable()
+});
+var AnalyzeTimelineInput = z11.object({
+  words: z11.array(TimelineWordInput).max(STUDIO_LIMITS.timelineWords)
+}).strict();
+var AnalyzeTimelineProjection = z11.object({
+  fillers: z11.array(z11.number()).max(STUDIO_LIMITS.timelineWords),
+  silenceGaps: z11.array(z11.number()).max(STUDIO_LIMITS.timelineWords),
+  emphasis: z11.array(z11.number()).max(STUDIO_LIMITS.timelineWords),
+  model: ShortText
+});
+var SourceWindow = z11.object({
+  startSec: z11.number().nonnegative(),
+  endSec: z11.number().positive()
+}).refine((window) => window.endSec > window.startSec, "endSec must be greater than startSec");
+var MediaFactKind = z11.enum(["subjectTrack", "matte"]);
+var MediaFactInput = z11.object({
+  mediaId: OpaqueId2,
+  kind: MediaFactKind,
+  window: SourceWindow
+}).strict();
+var MediaFactResolutionProjection = z11.object({
+  kind: MediaFactKind,
+  scope: SourceWindow,
+  state: z11.enum(["pending", "ready", "failed", "available", "unavailable"]),
+  fact: z11.object({
+    status: z11.enum(["pending", "ready", "failed"]),
+    summary: boundedRecord(z11.number(), 100).optional(),
+    readyAt: z11.number().optional(),
+    error: z11.object({
+      code: ShortText,
+      message: LongText
+    }).optional()
+  }).optional(),
+  offer: z11.object({ quotedUsd: z11.number(), available: z11.boolean(), reason: ShortText.optional() }).optional()
+});
+var PurchaseMediaFactInput = MediaFactInput.extend({ commandId: CommandId });
+var MediaFactPurchaseProjection = z11.object({
+  commandId: CommandId,
+  factId: OpaqueId2,
+  status: z11.enum(["pending", "ready", "failed"]),
+  quotedUsd: z11.number()
+});
+var ResourceSearchInput = z11.object({
+  query: z11.string().max(STUDIO_LIMITS.query),
+  kind: z11.enum(["video", "photo", "gif", "sfx"]),
+  limit: z11.number().int().positive().max(50)
+}).strict();
+var ResourceCandidateProjection = z11.object({
+  id: OpaqueId2,
+  provider: ShortText,
+  kind: ShortText,
+  thumbnail: z11.string().max(8192),
+  previewUrl: z11.string().max(8192),
+  downloadUrl: z11.string().max(8192).optional(),
+  duration: z11.number().optional(),
+  width: z11.number().optional(),
+  height: z11.number().optional(),
+  author: ShortText,
+  authorUrl: z11.string().max(8192).optional(),
+  license: ShortText.optional()
+});
+var ResourceSearchProjection = z11.object({ candidates: z11.array(ResourceCandidateProjection).max(50) });
+var DropboxResolveInput = z11.object({
+  url: z11.string().url().max(8192),
+  path: z11.string().max(1024).optional()
+}).strict();
+var DropboxEntryProjection = z11.object({
+  type: z11.enum(["file", "folder"]),
+  name: PathSegment,
+  size: UploadSize,
+  path: z11.string().max(1024)
+});
+var DropboxResolveProjection = z11.discriminatedUnion("type", [
+  z11.object({ type: z11.literal("file"), name: PathSegment, size: UploadSize, downloadUrl: z11.string().url().max(8192) }),
+  z11.object({ type: z11.literal("folder"), name: PathSegment, entries: z11.array(DropboxEntryProjection).max(STUDIO_LIMITS.collection) })
+]);
+var DropboxImportFileInput = z11.object({
+  commandId: CommandId,
+  filename: PathSegment,
+  size: UploadSize,
+  contentType: ContentType,
+  source: z11.discriminatedUnion("kind", [
+    z11.object({ kind: z11.literal("url"), url: z11.string().url().max(8192) }),
+    z11.object({ kind: z11.literal("dropbox"), shareUrl: z11.string().url().max(8192), path: z11.string().max(1024) })
+  ])
+}).strict();
+var DropboxImportFileProjection = z11.object({ commandId: CommandId, mediaId: OpaqueId2 });
+var UploadHeaders = boundedRecord(z11.string().max(8192), 32);
+var UploadPlan = z11.discriminatedUnion("kind", [
+  z11.object({ kind: z11.literal("single"), uploadUrl: z11.string().url().max(8192) }),
+  z11.object({
+    kind: z11.literal("multipart"),
+    partSize: z11.number().int().positive(),
+    minimumPartSize: z11.number().int().positive(),
+    maximumParts: z11.number().int().positive().max(1e4),
+    resumable: z11.boolean(),
+    partUrls: z11.array(z11.object({
+      partNumber: z11.number().int().positive(),
+      uploadUrl: z11.string().url().max(8192)
+    })).min(1).max(1e4)
+  })
+]);
+var UploadBeginInput = z11.object({
+  commandId: CommandId,
+  uploadRequestId: OpaqueId2,
+  filename: PathSegment,
+  contentType: ContentType,
+  size: UploadSize,
+  projectId: ProjectId.optional()
+}).strict();
+var UploadBeginProjection = z11.object({
+  commandId: CommandId,
+  uploadRequestId: OpaqueId2,
+  mediaId: OpaqueId2,
+  expiresAt: z11.number(),
+  requiredHeaders: UploadHeaders,
+  plan: UploadPlan
+});
+var UploadFinalizeInput = z11.object({
+  commandId: CommandId,
+  uploadRequestId: OpaqueId2,
+  mediaId: OpaqueId2
+}).strict();
+var UploadFinalizeProjection = z11.object({
+  commandId: CommandId,
+  uploadRequestId: OpaqueId2,
+  mediaId: OpaqueId2
+});
+var TemplateProjection = z11.object({
+  id: OpaqueId2,
+  content: z11.string().max(STUDIO_LIMITS.templateContent),
+  updatedAt: z11.number()
+});
+var TemplateListInput = PageInput;
+var TemplateListProjection = pageResult(TemplateProjection);
+var TemplateGetInput = z11.object({ templateId: OpaqueId2 }).strict();
+var TemplateGetProjection = z11.object({ template: TemplateProjection.nullable() });
+var TemplateSaveInput = z11.object({
+  commandId: CommandId,
+  template: TemplateProjection.omit({ updatedAt: true })
+}).strict();
+var TemplateRemoveInput = z11.object({ commandId: CommandId, templateId: OpaqueId2 }).strict();
+var TemplateMutationProjection = z11.object({ commandId: CommandId, templateId: OpaqueId2 });
+var ProjectResourceIdentity = {
+  projectId: ProjectId,
+  resourceId: OpaqueId2
+};
+var ProjectResourceBeginUploadInput = z11.object({
+  commandId: CommandId,
+  ...ProjectResourceIdentity,
+  name: PathSegment,
+  contentType: ContentType,
+  size: UploadSize
+}).strict();
+var ProjectResourceBeginUploadProjection = z11.object({
+  commandId: CommandId,
+  ...ProjectResourceIdentity,
+  expiresAt: z11.number(),
+  requiredHeaders: UploadHeaders,
+  plan: UploadPlan
+});
+var ProjectResourceCommandInput = z11.object({
+  commandId: CommandId,
+  ...ProjectResourceIdentity
+}).strict();
+var ProjectResourceFinalizeUploadInput = ProjectResourceCommandInput;
+var ProjectResourceMutationProjection = z11.object({
+  commandId: CommandId,
+  ...ProjectResourceIdentity
+});
+var ProjectResourceDeliveryInput = z11.object(ProjectResourceIdentity).strict();
+var ProjectResourceDeliveryProjection = z11.object({
+  url: z11.string().url().max(8192),
+  expiresAt: z11.number()
+});
+
+// src/errors.ts
+var StudioErrorCode = z12.enum([
+  "unauthenticated",
+  "forbidden",
+  "not_found",
+  "validation_failed",
+  "stale_revision",
+  "conflict",
+  "idempotency_conflict",
+  "rate_limited",
+  "unavailable",
+  "internal"
+]);
+var StudioError = z12.object({
+  code: StudioErrorCode,
+  message: z12.string().min(1).max(STUDIO_LIMITS.longText),
+  retryable: z12.boolean(),
+  details: z12.record(z12.string().min(1).max(STUDIO_LIMITS.pathSegment), JsonValue).refine((record) => Object.keys(record).length <= STUDIO_LIMITS.jsonCollection).optional()
+});
+var StudioErrorEnvelope = z12.object({ error: StudioError });
+
+// src/fixtures.ts
+function fixtures(validInput, invalidInput, validResult, invalidResult) {
+  return Object.freeze({
+    validInputs: Object.freeze([validInput]),
+    invalidInputs: Object.freeze([invalidInput]),
+    // Public result projections are additive. Every positive fixture proves it.
+    validResults: Object.freeze([{ ...validResult, additiveFixtureField: "accepted" }]),
+    invalidResults: Object.freeze([invalidResult])
+  });
+}
+var pageInput = { limit: 10 };
+var invalidPageInput = { limit: 0 };
+var emptyPage = { items: [], nextCursor: null, done: true };
+var invalidPage = { items: "not-an-array", nextCursor: null, done: true };
+var composition = { v: 1, format: { aspectRatio: "16:9" }, tracks: [] };
+var project = { id: "project", name: "Project", createdAt: 1, updatedAt: 2, revision: 3 };
+var compositionCommit = {
+  commandId: "client:1",
+  projectId: "project",
+  compositionId: "composition",
+  revision: 3,
+  acknowledgedOperationIds: ["operation"]
+};
+var media = {
+  id: "media",
+  name: "Clip",
+  kind: "video",
+  assetUrl: "https://media.example.test/clip.mp4",
+  metadata: null,
+  processingStatus: { phase: "complete", percent: 100, message: null, error: null },
+  createdAt: 1,
+  proxyUrl: null,
+  proxyStatus: "none"
+};
+var transcript = {
+  id: "transcript",
+  mediaItemId: "media",
+  downloadVersion: "v1",
+  model: "model",
+  language: "en",
+  createdAt: 1
+};
+var brandKit = {
+  id: "brand",
+  name: "Brand",
+  colors: { primary: "#111111", secondary: "#222222", accent: "#333333", background: "#ffffff", text: "#000000" },
+  extraColors: [],
+  headingFont: { fontFamily: "Inter", fontWeight: 700 },
+  bodyFont: { fontFamily: "Inter", fontWeight: 400 },
+  voiceGuidelines: "Clear and direct.",
+  syncCaptions: true,
+  createdAt: 1,
+  modifiedAt: 2
+};
+var conversation = {
+  id: "conversation",
+  title: "Edit",
+  project: { id: "project", home: "cloud" },
+  createdAt: 1,
+  updatedAt: 2,
+  messages: "[]"
+};
+var integrity = `sha256:${"a".repeat(64)}`;
+var singleUploadPlan = { kind: "single", uploadUrl: "https://upload.example.test/object" };
+var STUDIO_OPERATION_FIXTURES = Object.freeze({
+  compatibility: fixtures(
+    { clientVersion: "1.0.0", contractVersion: 1 },
+    { clientVersion: "1.0.0", contractVersion: 2 },
+    { compatible: true, contractVersion: 1, minimumClientVersion: "1.0.0" },
+    { compatible: true, contractVersion: 2, minimumClientVersion: "1.0.0" }
+  ),
+  sessionCurrent: fixtures(
+    {},
+    { unexpectedField: true },
+    { user: null, activeOrg: null },
+    { user: "not-a-user", activeOrg: null }
+  ),
+  assistantResolveThread: fixtures(
+    { conversationKey: "conversation" },
+    { conversationKey: "" },
+    { threadId: "thread" },
+    { threadId: "" }
+  ),
+  assistantForgetConversation: fixtures(
+    { conversationKey: "conversation" },
+    { conversationKey: "" },
+    { deleted: true },
+    { deleted: "yes" }
+  ),
+  assistantSend: fixtures(
+    { threadId: "thread", prompt: "Tighten the opening.", scope: "editor", projectId: "project" },
+    { threadId: "thread", prompt: "", scope: "editor" },
+    { threadId: "thread" },
+    { threadId: "" }
+  ),
+  assistantMessages: fixtures(
+    { threadId: "thread" },
+    { threadId: "" },
+    {
+      messages: [{
+        id: "message",
+        role: "assistant",
+        parts: [{ type: "text", text: "Done." }],
+        text: "Done.",
+        status: "complete",
+        createdAt: 1
+      }]
+    },
+    { messages: [{ id: "message", role: "assistant", parts: [], status: "complete" }] }
+  ),
+  projectsList: fixtures(
+    pageInput,
+    invalidPageInput,
+    emptyPage,
+    invalidPage
+  ),
+  projectsSnapshot: fixtures(
+    { projectId: "project" },
+    { projectId: "" },
+    { project, activeComposition: { id: "composition", composition }, revision: 3 },
+    { project, activeComposition: null, revision: -1 }
+  ),
+  projectsCreate: fixtures(
+    { commandId: "project:create", name: "Project" },
+    { commandId: "project:create", name: "" },
+    { commandId: "project:create", project, revision: 3 },
+    { commandId: "project:create", project, revision: -1 }
+  ),
+  projectsUpdate: fixtures(
+    { commandId: "project:update", projectId: "project", expectedRevision: 2, name: "Renamed" },
+    { commandId: "project:update", projectId: "project", expectedRevision: 2 },
+    { commandId: "project:update", project, revision: 3 },
+    { commandId: "project:update", project, revision: -1 }
+  ),
+  projectsRemove: fixtures(
+    { commandId: "project:remove", projectId: "project", expectedRevision: 3 },
+    { commandId: "project:remove", projectId: "project", expectedRevision: -1 },
+    { commandId: "project:remove", projectId: "project", revision: 4 },
+    { commandId: "project:remove", projectId: "project", revision: -1 }
+  ),
+  compositionsApply: fixtures(
+    {
+      projectId: "project",
+      commandId: "client:1",
+      clientId: "client",
+      sequence: 1,
+      expectedRevision: 2,
+      operations: [{ operationId: "operation", operation: { type: "clip.remove", clipId: "clip" } }]
+    },
+    {
+      projectId: "project",
+      commandId: "different:1",
+      clientId: "client",
+      sequence: 1,
+      expectedRevision: 2,
+      operations: [{ operationId: "operation", operation: { type: "clip.remove", clipId: "clip" } }]
+    },
+    compositionCommit,
+    { ...compositionCommit, revision: -1 }
+  ),
+  compositionsReplace: fixtures(
+    {
+      projectId: "project",
+      commandId: "client:2",
+      clientId: "client",
+      sequence: 2,
+      expectedRevision: 2,
+      operationId: "replacement",
+      composition
+    },
+    {
+      projectId: "project",
+      commandId: "client:2",
+      clientId: "client",
+      sequence: 0,
+      expectedRevision: 2,
+      operationId: "replacement",
+      composition
+    },
+    { ...compositionCommit, commandId: "client:2", acknowledgedOperationIds: ["replacement"] },
+    { ...compositionCommit, commandId: "client:2", acknowledgedOperationIds: [1] }
+  ),
+  mediaList: fixtures(
+    pageInput,
+    invalidPageInput,
+    { ...emptyPage, items: [media] },
+    invalidPage
+  ),
+  mediaRemove: fixtures(
+    { mediaId: "media", commandId: "media:remove" },
+    { mediaId: "", commandId: "media:remove" },
+    { mediaId: "media", commandId: "media:remove" },
+    { mediaId: "media" }
+  ),
+  mediaCancelProcessing: fixtures(
+    { mediaId: "media", commandId: "media:cancel" },
+    { mediaId: "media" },
+    { mediaId: "media", commandId: "media:cancel" },
+    { commandId: "media:cancel" }
+  ),
+  mediaReprocess: fixtures(
+    { mediaId: "media", commandId: "media:reprocess" },
+    { mediaId: "", commandId: "media:reprocess" },
+    { mediaId: "media", commandId: "media:reprocess" },
+    { mediaId: "media", commandId: "" }
+  ),
+  mediaListUnderstanding: fixtures(
+    pageInput,
+    invalidPageInput,
+    { ...emptyPage, items: [{ mediaId: "media", summary: "A speaker.", scenes: [], tags: ["speaker"] }] },
+    invalidPage
+  ),
+  mediaSearch: fixtures(
+    { query: "speaker at desk", limit: 25 },
+    { query: "speaker at desk", limit: 26 },
+    { results: [{ mediaId: "media", name: "Clip", score: 0.9, startSec: 0, endSec: 2 }], indexing: false },
+    { results: [], indexing: "no" }
+  ),
+  mediaAnalyzeTimeline: fixtures(
+    { words: [{ text: "Hello", timelineStart: 0, timelineEnd: 1, clipId: "clip", poolItemId: "media", sourceStart: 0, sourceEnd: 1, speakerId: null }] },
+    { words: "not-an-array" },
+    { fillers: [], silenceGaps: [], emphasis: [0], model: "analysis-v1" },
+    { fillers: [], silenceGaps: [], emphasis: [], model: 1 }
+  ),
+  mediaFacts: fixtures(
+    { mediaId: "media", kind: "matte", window: { startSec: 0, endSec: 2 } },
+    { mediaId: "media", kind: "matte", window: { startSec: 2, endSec: 1 } },
+    { kind: "matte", scope: { startSec: 0, endSec: 2 }, state: "ready", fact: { status: "ready", readyAt: 2 } },
+    { kind: "matte", scope: { startSec: 0, endSec: 2 }, state: "unknown" }
+  ),
+  mediaPurchaseFact: fixtures(
+    { commandId: "fact:purchase", mediaId: "media", kind: "subjectTrack", window: { startSec: 0, endSec: 2 } },
+    { commandId: "fact:purchase", mediaId: "media", kind: "subjectTrack", window: { startSec: -1, endSec: 2 } },
+    { commandId: "fact:purchase", factId: "fact", status: "pending", quotedUsd: 0.01 },
+    { commandId: "fact:purchase", factId: "fact", status: "unknown", quotedUsd: 0.01 }
+  ),
+  transcriptsList: fixtures(
+    { projectId: "project", limit: 10 },
+    { projectId: "project", limit: 0 },
+    { ...emptyPage, items: [transcript] },
+    invalidPage
+  ),
+  transcriptsGetDownload: fixtures(
+    { mediaId: "media" },
+    { mediaId: "" },
+    { transcriptId: "transcript", presignedUrl: "https://media.example.test/transcript.json", model: "model", language: "en", version: "v1" },
+    { transcriptId: "", presignedUrl: null, model: null, language: null, version: "v1" }
+  ),
+  transcriptsSearch: fixtures(
+    { query: "launch date", limit: 10 },
+    { query: "", limit: 10 },
+    { candidates: [transcript] },
+    { candidates: "not-an-array" }
+  ),
+  correctionsList: fixtures(
+    { projectId: "project", limit: 10 },
+    { projectId: "", limit: 10 },
+    { ...emptyPage, items: [{ key: "Acme", text: "ACME" }] },
+    invalidPage
+  ),
+  correctionsSave: fixtures(
+    { projectId: "project", commandId: "correction:save", key: "Acme", text: "ACME" },
+    { projectId: "project", commandId: "correction:save", key: "", text: "ACME" },
+    { commandId: "correction:save", key: "Acme" },
+    { commandId: "correction:save" }
+  ),
+  correctionsRemove: fixtures(
+    { projectId: "project", commandId: "correction:remove", key: "Acme" },
+    { projectId: "project", commandId: "correction:remove", key: "" },
+    { commandId: "correction:remove", key: "Acme" },
+    { commandId: "correction:remove", key: 1 }
+  ),
+  settingsGetUser: fixtures(
+    {},
+    { unexpectedField: true },
+    { activeBrandKitId: null, enableUnderstanding: true },
+    { activeBrandKitId: null }
+  ),
+  settingsUpdateProcessing: fixtures(
+    { commandId: "settings:update", enableUnderstanding: true },
+    { commandId: "settings:update" },
+    { commandId: "settings:update", activeBrandKitId: null, enableUnderstanding: true },
+    { commandId: "settings:update", activeBrandKitId: null }
+  ),
+  brandKitsList: fixtures(
+    pageInput,
+    invalidPageInput,
+    { ...emptyPage, items: [brandKit] },
+    invalidPage
+  ),
+  brandKitsUpsert: fixtures(
+    { commandId: "brand:upsert", brandKit },
+    { commandId: "brand:upsert", brandKit: { ...brandKit, name: "" } },
+    { commandId: "brand:upsert", brandKit },
+    { commandId: "brand:upsert" }
+  ),
+  componentsList: fixtures(
+    pageInput,
+    invalidPageInput,
+    { ...emptyPage, items: [{ id: "component", name: "Card", category: "overlay", bundleVersion: "v1", integritySha256: integrity }] },
+    invalidPage
+  ),
+  componentsGetBundles: fixtures(
+    { componentIds: ["component"] },
+    { componentIds: [] },
+    { bundles: [{ componentId: "component", version: "v1", integritySha256: integrity, source: "export default {}" }] },
+    { bundles: [{ componentId: "component", version: "v1", integritySha256: "sha256:bad", source: "export default {}" }] }
+  ),
+  conversationsList: fixtures(
+    { project: { id: "project", home: "cloud" }, limit: 10 },
+    { project: { id: "project", home: "remote" }, limit: 10 },
+    { ...emptyPage, items: [{ id: "conversation", title: "Edit", project: { id: "project", home: "cloud" }, createdAt: 1, updatedAt: 2 }] },
+    invalidPage
+  ),
+  conversationsGet: fixtures(
+    { conversationId: "conversation", project: { id: "project", home: "cloud" } },
+    { conversationId: "", project: { id: "project", home: "cloud" } },
+    { conversation },
+    { conversation: { ...conversation, id: "" } }
+  ),
+  conversationsSave: fixtures(
+    { commandId: "conversation:save", conversation },
+    { commandId: "conversation:save", conversation: { ...conversation, id: "" } },
+    { commandId: "conversation:save", conversationId: "conversation" },
+    { commandId: "conversation:save" }
+  ),
+  conversationsAdopt: fixtures(
+    { commandId: "conversation:adopt", conversation },
+    { commandId: "conversation:adopt", conversation: { ...conversation, project: { id: "project", home: "remote" } } },
+    { commandId: "conversation:adopt", conversationId: "conversation" },
+    { conversationId: "conversation" }
+  ),
+  conversationsRemove: fixtures(
+    { commandId: "conversation:remove", conversationId: "conversation" },
+    { commandId: "conversation:remove", conversationId: "" },
+    { commandId: "conversation:remove", conversationId: "conversation" },
+    { commandId: "conversation:remove" }
+  ),
+  restorePointsList: fixtures(
+    { conversationId: "conversation", limit: 10 },
+    { conversationId: "", limit: 10 },
+    { ...emptyPage, items: [{ id: "restore", conversationId: "conversation", project: { id: "project", home: "cloud" }, label: "Before edit", createdAt: 1 }] },
+    invalidPage
+  ),
+  restorePointsForget: fixtures(
+    { commandId: "restore:forget", conversationId: "conversation" },
+    { commandId: "restore:forget", conversationId: "" },
+    { commandId: "restore:forget", conversationId: "conversation" },
+    { conversationId: "conversation" }
+  ),
+  restorePointsRestore: fixtures(
+    { commandId: "restore:apply", projectId: "project", expectedRevision: 3, conversationId: "conversation", restorePointId: "restore" },
+    { commandId: "restore:apply", projectId: "project", expectedRevision: -1, conversationId: "conversation", restorePointId: "restore" },
+    { commandId: "restore:apply", conversationId: "conversation", restorePointId: "restore", projectId: "project", compositionId: "composition", revision: 4 },
+    { commandId: "restore:apply", conversationId: "conversation", restorePointId: "restore", projectId: "project", compositionId: "composition", revision: -1 }
+  ),
+  rendersList: fixtures(
+    { projectId: "project", limit: 10 },
+    { projectId: "", limit: 10 },
+    { ...emptyPage, items: [{ id: "render", status: "complete", progress: 1, hasOutput: true, error: null, createdAt: 1 }] },
+    invalidPage
+  ),
+  rendersPresignOutput: fixtures(
+    { renderId: "render" },
+    { renderId: "" },
+    { url: "https://media.example.test/render.mp4" },
+    { url: "not-a-url" }
+  ),
+  rendersCreate: fixtures(
+    { projectId: "project", commandId: "render:create", expectedRevision: 3, format: { aspectRatio: "16:9", resolution: "fhd" } },
+    { projectId: "project", commandId: "render:create", expectedRevision: -1 },
+    { commandId: "render:create", renderId: "render", revision: 4 },
+    { commandId: "render:create", renderId: "render", revision: -1 }
+  ),
+  rendersCancel: fixtures(
+    { projectId: "project", renderId: "render", commandId: "render:cancel" },
+    { projectId: "project", renderId: "", commandId: "render:cancel" },
+    { commandId: "render:cancel", renderId: "render" },
+    { commandId: "render:cancel", renderId: "" }
+  ),
+  uploadsBegin: fixtures(
+    { commandId: "upload:begin", uploadRequestId: "request", filename: "clip.mp4", contentType: "video/mp4", size: 1024 },
+    { commandId: "upload:begin", uploadRequestId: "request", filename: "../clip.mp4", contentType: "video/mp4", size: 1024 },
+    { commandId: "upload:begin", uploadRequestId: "request", mediaId: "media", expiresAt: 10, requiredHeaders: { "content-type": "video/mp4" }, plan: singleUploadPlan },
+    { commandId: "upload:begin", uploadRequestId: "request", mediaId: "media", expiresAt: 10, requiredHeaders: {}, plan: { kind: "single", uploadUrl: "not-a-url" } }
+  ),
+  uploadsFinalize: fixtures(
+    { commandId: "upload:finalize", uploadRequestId: "request", mediaId: "media" },
+    { commandId: "upload:finalize", uploadRequestId: "request", mediaId: "media", unexpectedField: true },
+    { commandId: "upload:finalize", uploadRequestId: "request", mediaId: "media" },
+    { commandId: "upload:finalize", uploadRequestId: "request" }
+  ),
+  templatesList: fixtures(
+    pageInput,
+    invalidPageInput,
+    { ...emptyPage, items: [{ id: "template", content: '{"v":1}', updatedAt: 1 }] },
+    invalidPage
+  ),
+  templatesGet: fixtures(
+    { templateId: "template" },
+    { templateId: "" },
+    { template: { id: "template", content: '{"v":1}', updatedAt: 1 } },
+    { template: { id: "", content: "{}", updatedAt: 1 } }
+  ),
+  templatesSave: fixtures(
+    { commandId: "template:save", template: { id: "template", content: '{"v":1}' } },
+    { commandId: "template:save", template: { id: "", content: '{"v":1}' } },
+    { commandId: "template:save", templateId: "template" },
+    { commandId: "template:save" }
+  ),
+  templatesRemove: fixtures(
+    { commandId: "template:remove", templateId: "template" },
+    { commandId: "template:remove", templateId: "" },
+    { commandId: "template:remove", templateId: "template" },
+    { templateId: "template" }
+  ),
+  projectResourcesBeginUpload: fixtures(
+    { commandId: "resource:begin", projectId: "project", resourceId: "resource", name: "font.woff2", contentType: "font/woff2", size: 1024 },
+    { commandId: "resource:begin", projectId: "project", resourceId: "resource", name: "../font.woff2", contentType: "font/woff2", size: 1024 },
+    { commandId: "resource:begin", projectId: "project", resourceId: "resource", expiresAt: 10, requiredHeaders: {}, plan: singleUploadPlan },
+    { commandId: "resource:begin", projectId: "project", resourceId: "resource", expiresAt: 10, requiredHeaders: {}, plan: { kind: "single", uploadUrl: "not-a-url" } }
+  ),
+  projectResourcesFinalizeUpload: fixtures(
+    { commandId: "resource:finalize", projectId: "project", resourceId: "resource" },
+    { commandId: "resource:finalize", projectId: "project", resourceId: "resource", unexpectedField: true },
+    { commandId: "resource:finalize", projectId: "project", resourceId: "resource" },
+    { commandId: "resource:finalize", projectId: "project" }
+  ),
+  projectResourcesRemove: fixtures(
+    { commandId: "resource:remove", projectId: "project", resourceId: "resource" },
+    { commandId: "resource:remove", projectId: "", resourceId: "resource" },
+    { commandId: "resource:remove", projectId: "project", resourceId: "resource" },
+    { commandId: "resource:remove", projectId: "project" }
+  ),
+  projectResourcesGetDelivery: fixtures(
+    { projectId: "project", resourceId: "resource" },
+    { projectId: "project", resourceId: "" },
+    { url: "https://media.example.test/resource", expiresAt: 10 },
+    { url: "not-a-url", expiresAt: 10 }
+  ),
+  resourcesSearch: fixtures(
+    { query: "cinematic", kind: "video", limit: 50 },
+    { query: "cinematic", kind: "video", limit: 51 },
+    { candidates: [{ id: "candidate", provider: "catalog", kind: "video", thumbnail: "https://media.example.test/thumb.jpg", previewUrl: "https://media.example.test/preview.mp4", author: "Creator" }] },
+    { candidates: "not-an-array" }
+  ),
+  importsResolveDropbox: fixtures(
+    { url: "https://dropbox.com/scl/fi/example/clip.mp4" },
+    { url: "not-a-url" },
+    { type: "file", name: "clip.mp4", size: 1024, downloadUrl: "https://media.example.test/clip.mp4" },
+    { type: "file", name: "../clip.mp4", size: 1024, downloadUrl: "https://media.example.test/clip.mp4" }
+  ),
+  importsDropboxFile: fixtures(
+    { commandId: "dropbox:import", filename: "clip.mp4", size: 1024, contentType: "video/mp4", source: { kind: "dropbox", shareUrl: "https://dropbox.com/scl/fo/example", path: "/clip.mp4" } },
+    { commandId: "dropbox:import", filename: "clip.mp4", size: -1, contentType: "video/mp4", source: { kind: "dropbox", shareUrl: "https://dropbox.com/scl/fo/example", path: "/clip.mp4" } },
+    { commandId: "dropbox:import", mediaId: "media" },
+    { commandId: "dropbox:import" }
+  )
+});
+
+// src/projections.ts
+import { z as z13 } from "zod";
+var ProjectProjection = z13.object({
+  id: ProjectId,
+  name: z13.string().min(1).max(STUDIO_LIMITS.name),
+  createdAt: z13.number(),
+  updatedAt: z13.number()
+});
+var ProjectSummary = ProjectProjection.extend({
+  revision: AggregateRevision
+});
+var ActiveCompositionProjection = z13.object({
+  id: CompositionId,
+  composition: Composition
+});
+var ProjectSnapshotProjection = z13.object({
+  project: ProjectProjection,
+  activeComposition: ActiveCompositionProjection.nullable(),
+  revision: AggregateRevision
+});
+var ProjectListInput = PageInput;
+var ProjectListProjection = pageResult(ProjectSummary);
+var ProjectSnapshotInput = z13.object({ projectId: ProjectId }).strict();
+var ProjectMutationProjection = z13.object({
+  commandId: CommandId,
+  project: ProjectSummary,
+  revision: AggregateRevision
+});
+var ProjectRemovalProjection = z13.object({
+  commandId: CommandId,
+  projectId: ProjectId,
+  revision: AggregateRevision
+});
+
+// src/session.ts
+import { z as z14 } from "zod";
+var SessionInput = z14.object({}).strict();
+var StudioUserProjection = z14.object({
+  id: OpaqueId2,
+  name: z14.string().max(STUDIO_LIMITS.name).nullable(),
+  email: z14.string().max(STUDIO_LIMITS.shortText).nullable(),
+  image: z14.string().max(8192).nullable()
+});
+var StudioOrganizationProjection = z14.object({
+  id: OpaqueId2,
+  name: z14.string().max(STUDIO_LIMITS.name).nullable().optional()
+});
+var SessionProjection = z14.object({
+  user: StudioUserProjection.nullable(),
+  activeOrg: StudioOrganizationProjection.nullable()
+});
+
+// src/operations.ts
+var defineOperations = (value) => Object.fromEntries(Object.entries(value).map(([id, operation]) => [
+  id,
+  { revisionPolicy: "none", ...operation }
+]));
+var STUDIO_OPERATIONS = defineOperations({
+  compatibility: { kind: "query", input: CompatibilityInput, result: CompatibilityProjection, durable: false, aggregate: "none" },
+  sessionCurrent: { kind: "query", input: SessionInput, result: SessionProjection, durable: false, aggregate: "none" },
+  assistantResolveThread: { kind: "mutation", input: AssistantResolveThreadInput, result: AssistantThreadProjection, durable: false, aggregate: "none" },
+  assistantForgetConversation: { kind: "mutation", input: AssistantForgetConversationInput, result: AssistantForgetConversationProjection, durable: false, aggregate: "none" },
+  assistantSend: { kind: "action", input: AssistantSendInput, result: AssistantSendProjection, durable: false, aggregate: "none" },
+  assistantMessages: { kind: "query", input: AssistantMessagesInput, result: AssistantMessagesProjection, durable: false, aggregate: "none" },
+  projectsList: { kind: "query", input: ProjectListInput, result: ProjectListProjection, durable: false, aggregate: "none", paginated: true },
+  projectsSnapshot: { kind: "query", input: ProjectSnapshotInput, result: ProjectSnapshotProjection, durable: false, aggregate: "project", revisionPolicy: "returns-project-revision" },
+  projectsCreate: { kind: "mutation", input: CreateProjectInput, result: ProjectMutationProjection, durable: true, aggregate: "project", revisionPolicy: "returns-project-revision" },
+  projectsUpdate: { kind: "mutation", input: UpdateProjectInput, result: ProjectMutationProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  projectsRemove: { kind: "mutation", input: RemoveProjectInput, result: ProjectRemovalProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  compositionsApply: { kind: "mutation", input: ApplyCompositionInput, result: CompositionCommitProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  compositionsReplace: { kind: "mutation", input: ReplaceCompositionInput, result: CompositionCommitProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  mediaList: { kind: "query", input: MediaListInput, result: MediaListProjection, durable: false, aggregate: "none", paginated: true },
+  mediaRemove: { kind: "mutation", input: MediaCommandInput, result: MediaMutationProjection, durable: true, aggregate: "none" },
+  mediaCancelProcessing: { kind: "mutation", input: MediaCommandInput, result: MediaMutationProjection, durable: true, aggregate: "none" },
+  mediaReprocess: { kind: "action", input: MediaCommandInput, result: MediaMutationProjection, durable: true, aggregate: "none" },
+  mediaListUnderstanding: { kind: "query", input: MediaUnderstandingListInput, result: MediaUnderstandingListProjection, durable: false, aggregate: "none", paginated: true },
+  mediaSearch: { kind: "action", input: MediaSearchInput, result: MediaSearchProjection, durable: false, aggregate: "none" },
+  mediaAnalyzeTimeline: { kind: "action", input: AnalyzeTimelineInput, result: AnalyzeTimelineProjection, durable: false, aggregate: "none" },
+  mediaFacts: { kind: "query", input: MediaFactInput, result: MediaFactResolutionProjection, durable: false, aggregate: "none" },
+  mediaPurchaseFact: { kind: "action", input: PurchaseMediaFactInput, result: MediaFactPurchaseProjection, durable: true, aggregate: "none" },
+  transcriptsList: { kind: "query", input: TranscriptListInput, result: TranscriptListProjection, durable: false, aggregate: "none", paginated: true },
+  transcriptsGetDownload: { kind: "query", input: TranscriptDownloadInput, result: TranscriptDownloadProjection, durable: false, aggregate: "none" },
+  transcriptsSearch: { kind: "query", input: TranscriptSearchInput, result: TranscriptSearchProjection, durable: false, aggregate: "none" },
+  correctionsList: { kind: "query", input: CorrectionListInput, result: CorrectionListProjection, durable: false, aggregate: "none", paginated: true },
+  correctionsSave: { kind: "mutation", input: SaveCorrectionInput, result: CorrectionMutationProjection, durable: true, aggregate: "none" },
+  correctionsRemove: { kind: "mutation", input: RemoveCorrectionInput, result: CorrectionMutationProjection, durable: true, aggregate: "none" },
+  settingsGetUser: { kind: "query", input: EmptyInput, result: UserSettingsProjection, durable: false, aggregate: "none" },
+  settingsUpdateProcessing: { kind: "mutation", input: UpdateProcessingSettingsInput, result: UserSettingsMutationProjection, durable: true, aggregate: "none" },
+  brandKitsList: { kind: "query", input: BrandKitListInput, result: BrandKitListProjection, durable: false, aggregate: "none", paginated: true },
+  brandKitsUpsert: { kind: "mutation", input: UpsertBrandKitInput, result: BrandKitMutationProjection, durable: true, aggregate: "none" },
+  componentsList: { kind: "query", input: ComponentListInput, result: ComponentListProjection, durable: false, aggregate: "none", paginated: true },
+  componentsGetBundles: { kind: "query", input: ComponentBundlesInput, result: ComponentBundlesProjection, durable: false, aggregate: "none" },
+  conversationsList: { kind: "query", input: ConversationListInput, result: ConversationListProjection, durable: false, aggregate: "none", paginated: true },
+  conversationsGet: { kind: "query", input: ConversationGetInput, result: ConversationGetProjection, durable: false, aggregate: "none" },
+  conversationsSave: { kind: "mutation", input: SaveConversationInput, result: ConversationMutationProjection, durable: true, aggregate: "none" },
+  conversationsAdopt: { kind: "mutation", input: SaveConversationInput, result: ConversationMutationProjection, durable: true, aggregate: "none" },
+  conversationsRemove: { kind: "mutation", input: RemoveConversationInput, result: ConversationMutationProjection, durable: true, aggregate: "none" },
+  restorePointsList: { kind: "query", input: RestorePointListInput, result: RestorePointListProjection, durable: false, aggregate: "none", paginated: true },
+  restorePointsForget: { kind: "mutation", input: ForgetRestorePointsInput, result: RestorePointMutationProjection, durable: true, aggregate: "none" },
+  restorePointsRestore: { kind: "mutation", input: RestoreToPointInput, result: RestorePointCommitProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  rendersList: { kind: "query", input: RenderListInput, result: RenderListProjection, durable: false, aggregate: "project", paginated: true },
+  rendersPresignOutput: { kind: "action", input: RenderPresignInput, result: RenderPresignProjection, durable: false, aggregate: "none" },
+  rendersCreate: { kind: "action", input: CreateRenderInput, result: CreateRenderProjection, durable: true, aggregate: "project", revisionPolicy: "requires-expected-project-revision" },
+  rendersCancel: { kind: "mutation", input: CancelRenderInput, result: CancelRenderProjection, durable: true, aggregate: "none" },
+  uploadsBegin: { kind: "action", input: UploadBeginInput, result: UploadBeginProjection, durable: true, aggregate: "none" },
+  uploadsFinalize: { kind: "action", input: UploadFinalizeInput, result: UploadFinalizeProjection, durable: true, aggregate: "none" },
+  templatesList: { kind: "query", input: TemplateListInput, result: TemplateListProjection, durable: false, aggregate: "none", paginated: true },
+  templatesGet: { kind: "query", input: TemplateGetInput, result: TemplateGetProjection, durable: false, aggregate: "none" },
+  templatesSave: { kind: "mutation", input: TemplateSaveInput, result: TemplateMutationProjection, durable: true, aggregate: "none" },
+  templatesRemove: { kind: "mutation", input: TemplateRemoveInput, result: TemplateMutationProjection, durable: true, aggregate: "none" },
+  projectResourcesBeginUpload: { kind: "action", input: ProjectResourceBeginUploadInput, result: ProjectResourceBeginUploadProjection, durable: true, aggregate: "none" },
+  projectResourcesFinalizeUpload: { kind: "action", input: ProjectResourceFinalizeUploadInput, result: ProjectResourceMutationProjection, durable: true, aggregate: "none" },
+  projectResourcesRemove: { kind: "mutation", input: ProjectResourceCommandInput, result: ProjectResourceMutationProjection, durable: true, aggregate: "none" },
+  projectResourcesGetDelivery: { kind: "action", input: ProjectResourceDeliveryInput, result: ProjectResourceDeliveryProjection, durable: false, aggregate: "none" },
+  resourcesSearch: { kind: "action", input: ResourceSearchInput, result: ResourceSearchProjection, durable: false, aggregate: "none" },
+  importsResolveDropbox: { kind: "action", input: DropboxResolveInput, result: DropboxResolveProjection, durable: false, aggregate: "none" },
+  importsDropboxFile: { kind: "action", input: DropboxImportFileInput, result: DropboxImportFileProjection, durable: true, aggregate: "none" }
+});
+export {
+  ActiveCompositionProjection,
+  AggregateRevision,
+  AnalyzeTimelineInput,
+  AnalyzeTimelineProjection,
+  ApplyCompositionInput,
+  AssistantForgetConversationInput,
+  AssistantForgetConversationProjection,
+  AssistantMessageProjection,
+  AssistantMessagesInput,
+  AssistantMessagesProjection,
+  AssistantResolveThreadInput,
+  AssistantSendInput,
+  AssistantSendProjection,
+  AssistantThreadProjection,
+  BrandKitListInput,
+  BrandKitListProjection,
+  BrandKitMutationProjection,
+  BrandKitProjection,
+  CancelRenderInput,
+  CancelRenderProjection,
+  CommandId,
+  CompatibilityInput,
+  CompatibilityProjection,
+  ComponentBundleProjection,
+  ComponentBundlesInput,
+  ComponentBundlesProjection,
+  ComponentListInput,
+  ComponentListProjection,
+  ComponentProjection,
+  CompositionCommitProjection,
+  CompositionId,
+  ConversationGetInput,
+  ConversationGetProjection,
+  ConversationListInput,
+  ConversationListProjection,
+  ConversationMutationProjection,
+  ConversationProjection,
+  CorrectionListInput,
+  CorrectionListProjection,
+  CorrectionMutationProjection,
+  CorrectionProjection,
+  CreateProjectInput,
+  CreateRenderInput,
+  CreateRenderProjection,
+  DropboxEntryProjection,
+  DropboxImportFileInput,
+  DropboxImportFileProjection,
+  DropboxResolveInput,
+  DropboxResolveProjection,
+  DurableCommand,
+  DurableCommandFields,
+  DurableOperation,
+  EmptyInput,
+  ForgetRestorePointsInput,
+  JournalClientId,
+  JournalSequence,
+  JsonValue,
+  MediaCommandInput,
+  MediaFactInput,
+  MediaFactKind,
+  MediaFactPurchaseProjection,
+  MediaFactResolutionProjection,
+  MediaIdInput,
+  MediaItemProjection,
+  MediaListInput,
+  MediaListProjection,
+  MediaMetadataProjection,
+  MediaMutationProjection,
+  MediaProcessingStatusProjection,
+  MediaSearchHitProjection,
+  MediaSearchInput,
+  MediaSearchProjection,
+  MediaUnderstandingListInput,
+  MediaUnderstandingListProjection,
+  MediaUnderstandingProjection,
+  OpaqueId2 as OpaqueId,
+  OperationId,
+  PageInput,
+  ProjectId,
+  ProjectListInput,
+  ProjectListProjection,
+  ProjectMutationProjection,
+  ProjectProjection,
+  ProjectRefProjection,
+  ProjectRemovalProjection,
+  ProjectResourceBeginUploadInput,
+  ProjectResourceBeginUploadProjection,
+  ProjectResourceCommandInput,
+  ProjectResourceDeliveryInput,
+  ProjectResourceDeliveryProjection,
+  ProjectResourceFinalizeUploadInput,
+  ProjectResourceMutationProjection,
+  ProjectSnapshotInput,
+  ProjectSnapshotProjection,
+  ProjectSummary,
+  PublicMatteEntryProjection,
+  PublicSubjectTrackEntryProjection,
+  PurchaseMediaFactInput,
+  RemoveConversationInput,
+  RemoveCorrectionInput,
+  RemoveProjectInput,
+  RenderJobProjection,
+  RenderListInput,
+  RenderListProjection,
+  RenderPresignInput,
+  RenderPresignProjection,
+  ReplaceCompositionInput,
+  ResourceCandidateProjection,
+  ResourceSearchInput,
+  ResourceSearchProjection,
+  RestorePointCommitProjection,
+  RestorePointListInput,
+  RestorePointListProjection,
+  RestorePointMutationProjection,
+  RestorePointProjection,
+  RestoreToPointInput,
+  STUDIO_CONTRACT_VERSION,
+  STUDIO_LIMITS,
+  STUDIO_OPERATIONS,
+  STUDIO_OPERATION_FIXTURES,
+  STUDIO_PAGE_MAX,
+  SaveConversationInput,
+  SaveCorrectionInput,
+  SessionInput,
+  SessionProjection,
+  SourceWindow,
+  StudioError,
+  StudioErrorCode,
+  StudioErrorEnvelope,
+  StudioOrganizationProjection,
+  StudioUserProjection,
+  TemplateGetInput,
+  TemplateGetProjection,
+  TemplateListInput,
+  TemplateListProjection,
+  TemplateMutationProjection,
+  TemplateProjection,
+  TemplateRemoveInput,
+  TemplateSaveInput,
+  TimelineWordInput,
+  TranscriptDownloadInput,
+  TranscriptDownloadProjection,
+  TranscriptListInput,
+  TranscriptListProjection,
+  TranscriptProjection,
+  TranscriptSearchInput,
+  TranscriptSearchProjection,
+  UpdateProcessingSettingsInput,
+  UpdateProjectInput,
+  UploadBeginInput,
+  UploadBeginProjection,
+  UploadFinalizeInput,
+  UploadFinalizeProjection,
+  UploadHeaders,
+  UploadPlan,
+  UpsertBrandKitInput,
+  UserSettingsMutationProjection,
+  UserSettingsProjection,
+  pageResult
+};