@cueframe/kernel 0.0.1

package/dist/chunk-TULRCY6U.js

@@ -0,0 +1,729 @@
+import {
+  Composition,
+  Copy,
+  Format,
+  GraphicRole
+} from "./chunk-ATAF24QG.js";
+
+// ../composition/src/validators/composePlan.ts
+import { z } from "zod";
+var PlanSubject = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("face"), faceId: z.string().min(1) }),
+  z.object({ kind: z.literal("all-faces") }),
+  z.object({ kind: z.literal("frame-center") }),
+  z.object({ kind: z.literal("active-speaker") }),
+  z.object({
+    kind: z.literal("point"),
+    x: z.number().min(0).max(1),
+    y: z.number().min(0).max(1)
+  })
+]);
+var PlanFramingSegment = z.object({
+  startSec: z.number().nonnegative(),
+  endSec: z.number().positive(),
+  action: z.enum(["frame", "keep", "trim"]).describe(
+    "'frame' = SHOW this span cropped/tracked per `subject`. 'keep' = SHOW this span as-is, no reframe (footage with nothing to track). 'trim' = DELETE this span from the output entirely \u2014 trimmed footage never appears."
+  ),
+  subject: PlanSubject.optional(),
+  shotScale: z.enum(["close", "standard", "wide"]).optional(),
+  zoomScale: z.number().min(0.4).max(1).optional(),
+  verticalBias: z.number().min(-0.3).max(0.3).optional(),
+  /** Optional in the plan; the assembler defaults it to 0 on set_crop_intents. */
+  lateralBias: z.number().min(-0.3).max(0.3).optional(),
+  intent: z.string().optional()
+}).refine((s) => s.action !== "frame" || s.subject !== void 0, {
+  message: "frame segment requires a subject \u2014 for footage with no trackable subject use action:'keep' (shown as-is); do NOT trim spans you want shown"
+}).refine((s) => s.action !== "keep" || s.subject === void 0, {
+  message: "keep segment shows footage as-is \u2014 it takes no subject (use action:'frame' to track one)"
+}).refine((s) => s.shotScale === void 0 || s.zoomScale === void 0, {
+  message: "framing segment takes EITHER shotScale (editorial scale \u2014 the bake calibrates the zoom to the detected face) OR zoomScale (an explicit fraction of the frame), never both: shotScale wins and the zoomScale would be silently discarded",
+  path: ["zoomScale"]
+});
+var PlanCut = z.object({
+  startSec: z.number().nonnegative(),
+  endSec: z.number().positive(),
+  reason: z.string().min(1)
+});
+var PlanAssetRequest = z.object({
+  id: z.string().min(1),
+  atSec: z.number().nonnegative(),
+  durSec: z.number().positive(),
+  kind: z.enum(["broll", "audio", "sfx", "music", "ambience", "gif", "image"]),
+  source: z.enum(["find", "generate"]),
+  intent: z.string().min(1),
+  /** Phase 1: the planner resolves `find` requests against the pool at plan
+   *  time (it has search_library) and records the pick here. Unresolved find
+   *  requests are stripped by the validator (degrade, not error). */
+  resolvedMediaId: z.string().optional()
+});
+var PlanGraphicRequest = z.object({
+  id: z.string().min(1),
+  atSec: z.number().nonnegative(),
+  durSec: z.number().positive(),
+  role: GraphicRole,
+  copy: Copy,
+  intent: z.string().min(1)
+});
+var PlanMarker = z.object({
+  startSec: z.number().nonnegative(),
+  endSec: z.number().nonnegative().optional(),
+  kind: z.string().min(1),
+  name: z.string().optional()
+});
+var ComposePlan = z.object({
+  framing: z.array(PlanFramingSegment).min(1),
+  cuts: z.array(PlanCut).optional(),
+  captions: z.object({ styleIntent: z.string().optional() }).optional(),
+  assets: z.array(PlanAssetRequest).optional(),
+  graphics: z.array(PlanGraphicRequest).optional(),
+  markers: z.array(PlanMarker).optional()
+});
+
+// ../composition/src/validators/brandKit.ts
+import { z as z2 } from "zod";
+import { zid } from "convex-helpers/server/zod3";
+var EasingValue = z2.union([
+  z2.enum(["linear", "ease", "ease-in", "ease-out", "ease-in-out"]),
+  z2.object({
+    kind: z2.literal("cubic-bezier"),
+    x1: z2.number().min(0).max(1),
+    y1: z2.number(),
+    x2: z2.number().min(0).max(1),
+    y2: z2.number()
+  })
+]);
+var AudioPaletteRef = z2.string().min(1);
+var FontRef = z2.union([
+  z2.object({
+    kind: z2.literal("system"),
+    family: z2.string().min(1)
+  }),
+  z2.object({
+    kind: z2.literal("web"),
+    family: z2.string().min(1),
+    url: z2.string().url().optional()
+  }),
+  z2.object({
+    kind: z2.literal("uploaded"),
+    fontId: zid("fonts"),
+    family: z2.string().optional()
+  })
+]);
+var Colors = z2.object({
+  primary: z2.string().min(1),
+  secondary: z2.string().optional(),
+  accent: z2.string().min(1),
+  background: z2.string().min(1),
+  text: z2.string().min(1),
+  textMuted: z2.string().optional(),
+  border: z2.string().optional(),
+  // Tier-2 core — author overrides for the derived fills + paired foregrounds.
+  surface: z2.string().optional(),
+  card: z2.string().optional(),
+  gridLine: z2.string().optional(),
+  accentMuted: z2.string().optional(),
+  textOnAccent: z2.string().optional(),
+  textOnSurface: z2.string().optional()
+});
+var Fonts = z2.object({
+  heading: FontRef,
+  body: FontRef.optional(),
+  caption: FontRef.optional()
+});
+var Spacing = z2.object({
+  base: z2.number().positive().optional(),
+  lg: z2.number().positive().optional(),
+  sm: z2.number().positive().optional()
+});
+var Sizing = z2.object({
+  fontSizeHeading: z2.number().positive().optional(),
+  fontSizeBody: z2.number().positive().optional(),
+  fontSizeLabel: z2.number().positive().optional(),
+  borderRadius: z2.number().nonnegative().optional()
+});
+var Motion = z2.object({
+  duration: z2.number().positive().optional(),
+  easing: EasingValue.optional(),
+  // Editorial motion identity — surfaces read these via `$brand:motion.*`
+  // (resolved at projection time). Mirrors the primitive `TextMotion` vocabulary.
+  entrance: z2.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+  staggerMs: z2.number().nonnegative().optional(),
+  exitMs: z2.number().nonnegative().optional()
+});
+var Placement = z2.enum(["tl", "tr", "bl", "br"]);
+var Logo = z2.object({
+  src: z2.string().min(1),
+  alt: z2.string().optional(),
+  placement: Placement.optional(),
+  // Percentage of the composition width. Must be positive — a non-positive
+  // logo is a footgun, not an intent, so reject at the boundary.
+  sizePct: z2.number().positive().optional()
+});
+var IntroOutro = z2.object({
+  kind: z2.enum(["card", "video"]),
+  src: z2.string().min(1).optional(),
+  title: z2.string().optional(),
+  subtitle: z2.string().optional(),
+  durationMs: z2.number().positive().optional()
+});
+var Watermark = z2.object({
+  src: z2.string().min(1),
+  // Alpha in [0,1]; anything outside is a malformed kit, not a clamp target.
+  opacity: z2.number().min(0).max(1).optional(),
+  placement: Placement.optional()
+});
+var MotifBody = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("card"),
+    html: z2.string().min(1),
+    tokens: z2.record(z2.string(), z2.string()).optional()
+  }),
+  z2.object({
+    kind: z2.literal("overlay"),
+    primitiveId: z2.string().min(1),
+    params: z2.record(z2.string(), z2.unknown()).optional()
+  }),
+  z2.object({
+    kind: z2.literal("component"),
+    componentId: z2.string().min(1),
+    props: z2.record(z2.string(), z2.unknown()).optional()
+  })
+]);
+var MotifMotionPreset = z2.enum([
+  "fade-up",
+  "slide-in-left",
+  "slide-in-right",
+  "scale-pop",
+  "stagger-reveal"
+]);
+var Motif = z2.object({
+  id: z2.string().min(1).max(40),
+  observed: z2.string().min(1).max(500),
+  body: MotifBody,
+  motion: z2.object({
+    preset: MotifMotionPreset,
+    enterMs: z2.number().int().min(0).max(5e3).optional(),
+    exitMs: z2.number().int().min(0).max(5e3).optional(),
+    staggerMs: z2.number().int().min(0).max(2e3).optional(),
+    confidence: z2.enum(["high", "low"]).optional()
+  }).optional(),
+  // Pinned to the closed graphics-plan GraphicRole vocabulary — the steering
+  // matcher (designBrief.ts) is exact-equality against a plan role, so an
+  // off-vocabulary role would synthesize a judge and then silently never steer
+  // (the half-applied-conditioning failure D1-R exists to kill). Storage stays
+  // an open string (matches the motion.preset pattern).
+  role: GraphicRole,
+  zone: z2.object({ x: z2.number(), y: z2.number(), w: z2.number(), h: z2.number() }).optional(),
+  evidence: z2.array(z2.number().int().min(0)).max(24).optional(),
+  diffScore: z2.number().min(0).max(1).optional(),
+  coverage: z2.enum(["reproduced", "approximated", "skipped"]),
+  skipReason: z2.string().max(300).optional()
+});
+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 BrandKit = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  colors: Colors,
+  fonts: Fonts,
+  spacing: Spacing.optional(),
+  sizing: Sizing.optional(),
+  motion: Motion.optional(),
+  // Per-creator caption IDENTITY collected by the dashboard / derived from a
+  // creator's references. Consumed by resolveBrandKit's caption derivation:
+  // emphasisColor → caption.fg, base/highlight color (clamped to the APCA body
+  // floor over the scrim), the backdrop `plate` treatment, per-word `entrance`
+  // motion + timing, and the emphasis treatment (base face + serif/scale/weight/
+  // italic/transform/letter-spacing + emphasis-run plate) → caption identity
+  // that the render binding applies onto the Captions primitive. The kit now
+  // owns the caption LOOK (including plate + entrance). Base GEOMETRY (caption
+  // size, screen position, safe-area, maxWidth) is NOT here — that is calibrated
+  // craft owned by the primitive's default. The kit selects the LOOK; the
+  // primitive owns the legible realization.
+  captionProfile: z2.object({
+    // Base caption text color + spoken-word highlight — clamped to the APCA
+    // body floor over the scrim at projection (same guard as emphasisColor→fg).
+    color: z2.string().optional(),
+    highlightColor: z2.string().optional(),
+    emphasisColor: z2.string().optional(),
+    // Caption backdrop plate — the whole-block legibility treatment.
+    plate: z2.enum(["glass", "solid", "none"]).optional(),
+    // Per-word entrance motion + timing (the shared TextMotion vocabulary).
+    entrance: z2.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+    entranceMs: z2.number().optional(),
+    entranceStaggerMs: z2.number().optional(),
+    exitMs: z2.number().optional(),
+    // Base caption face (the carrier-word font). Defaults to fonts.caption.
+    fontFamily: z2.string().optional(),
+    // Emphasis-word treatment — the qualitative identity signal.
+    emphasisFontFamily: z2.string().optional(),
+    emphasisScale: z2.number().positive().optional(),
+    emphasisFontWeight: z2.number().optional(),
+    emphasisFontStyle: z2.enum(["normal", "italic"]).optional(),
+    emphasisTextTransform: z2.enum(["none", "uppercase"]).optional(),
+    emphasisLetterSpacing: z2.number().optional(),
+    // Emphasis-run highlighter plate (editorial caption look).
+    emphasisPlate: z2.boolean().optional(),
+    emphasisPlateColor: z2.string().optional(),
+    emphasisPlateTextColor: z2.string().optional()
+  }).optional(),
+  // ── Language payload (built FROM INSPIRATION) ─────────────────────────────
+  // Carried untransformed onto the wire kit so the projection (resolveBrandKit)
+  // can surface it as `ResolvedBrandKit.language`. Not a `$brand:` token root —
+  // these are exemplar/motif references the maker + judge condition on, not
+  // bindable design tokens.
+  exemplarKeys: z2.array(z2.string().min(1)).max(24).optional(),
+  contactSheetKey: z2.string().min(1).optional(),
+  motifs: z2.array(Motif).max(24).optional(),
+  styleRubric: z2.string().max(4e3).optional(),
+  density: z2.object({
+    graphicsPerMin: z2.number().min(0).max(60),
+    maxSimultaneous: z2.number().int().min(1).max(6)
+  }).optional(),
+  inspiration: z2.object({
+    sources: z2.array(z2.string()).min(1).max(24),
+    extractedAt: z2.number(),
+    extractionVersion: z2.string().min(1).max(60)
+  }).optional(),
+  logo: Logo.optional(),
+  intro: IntroOutro.optional(),
+  outro: IntroOutro.optional(),
+  watermark: Watermark.optional(),
+  /** Brand audio identity (audio design spec 2026-07-20): default SFX intensity
+   *  + music-bed defaults. Brief `audio` wins when present (caption-identity
+   *  precedence: brand default beats brief absence; brief beats brand).
+   *
+   *  Brand SOUND kit (audio-substrate Phase 5) — identity over TIME. All four
+   *  fields are OPTIONAL; a kit that sets none behaves byte-identically to a kit
+   *  with no audio block. Refs are palette references (P2 AudioPaletteEntry.ref:
+   *  a pack soundId | music-pack bedId | org mediaId — an opaque string handle). */
+  audio: z2.object({
+    sfxIntensity: z2.enum(["off", "light", "standard", "dense"]).optional(),
+    musicEnabled: z2.boolean().optional(),
+    musicMood: z2.string().max(300).optional(),
+    /** SONIC LOGO — a brand audio signature bound to the intro/outro bookend at
+     *  compose time (an sfx-role clip at the body edge adjacent to the render
+     *  bookend). `ref` = a palette reference; `placement` = which bookend(s);
+     *  `offsetMs` shifts within. Bound only when the corresponding bumper
+     *  (kit.intro / kit.outro) exists — else a non-blocking advisory. */
+    sonicLogo: z2.object({
+      ref: AudioPaletteRef,
+      placement: z2.enum(["intro", "outro", "both"]),
+      offsetMs: z2.number().int().min(0).max(1e4).optional()
+    }).optional(),
+    /** UI SOUND SET — per-family palette overrides consumed by the sfxCompile
+     *  org-first draw as the HIGHEST-priority tier (brand > org palette > pack
+     *  default), mirroring how a brand FONT sits above org defaults. Keys are the
+     *  closed SfxFamily vocabulary; values are palette refs. */
+    uiSoundSet: z2.object({
+      tick: AudioPaletteRef.optional(),
+      pop: AudioPaletteRef.optional(),
+      impact: AudioPaletteRef.optional(),
+      confirm: AudioPaletteRef.optional(),
+      error: AudioPaletteRef.optional(),
+      whoosh: AudioPaletteRef.optional(),
+      riser: AudioPaletteRef.optional()
+    }).optional(),
+    /** BED STYLE — a preferred pack bed (`bedId`) or a style hint (`genre` /
+     *  `bpmRange`). SURFACED-ONLY today (compose does not auto-select a pack bed
+     *  — it uses a client-pinned bed or generates from mood); the field resolves
+     *  through the kit + surfaces via get_profile / brand-kit reads so driving
+     *  agents honor it when pinning / generating a bed. */
+    bedStyle: z2.object({
+      bedId: AudioPaletteRef.optional(),
+      genre: z2.string().max(120).optional(),
+      bpmRange: z2.object({ min: z2.number(), max: z2.number() }).optional()
+    }).optional(),
+    /** AMBIENCE PREFERENCE — a preferred ambience bed (`{ref}`) or explicit
+     *  `null` (opt-out). SURFACED-ONLY (compose has no ambience auto-placement);
+     *  resolves + surfaces for driving agents. */
+    ambiencePreference: z2.object({ ref: AudioPaletteRef }).nullable().optional()
+  }).optional(),
+  license: LicenseDeclaration.optional(),
+  licenseVerification: z2.enum([
+    "attested",
+    "cueframe-verified",
+    "third-party-verified"
+  ]).optional(),
+  ownerOrgId: z2.string().optional(),
+  acl: AccessControl.optional()
+});
+
+// ../composition/src/validators/font.ts
+import { z as z3 } from "zod";
+var FontStatus = z3.enum([
+  "pending",
+  "uploading",
+  "analyzing",
+  "subsetting",
+  "ready",
+  "partial",
+  // common-glyphs buffer present, custom glyphs still subsetting
+  "failed"
+]);
+var FontVariant = z3.object({
+  weight: z3.number().int().min(100).max(900),
+  style: z3.enum(["normal", "italic"]),
+  storageKey: z3.string().min(1),
+  byteSize: z3.number().int().nonnegative().optional(),
+  subsetComplete: z3.boolean().optional()
+});
+var Font = z3.object({
+  id: z3.string().min(1),
+  family: z3.string().min(1),
+  status: FontStatus,
+  variants: z3.array(FontVariant).nonempty(),
+  source: z3.enum(["uploaded", "system", "web"]).optional(),
+  license: z3.object({
+    type: z3.string().min(1),
+    source: z3.string().optional(),
+    notes: z3.string().optional()
+  }).optional(),
+  createdAt: z3.number().optional(),
+  // epoch ms
+  ownerOrgId: z3.string().optional()
+});
+
+// ../composition/src/validators/render.ts
+import { z as z4 } from "zod";
+import { zid as zid2 } from "convex-helpers/server/zod3";
+var RenderPriority = z4.enum(["interactive", "standard", "background"]);
+var RenderIntent = z4.enum(["preview", "final"]);
+var RenderMode = z4.enum(["offline", "live"]);
+var RenderCancelReason = z4.enum([
+  "user",
+  "agent",
+  "cost_limit",
+  "superseded",
+  "source_removed",
+  "timeout",
+  "error"
+]);
+var RenderStatus = z4.enum([
+  "pending",
+  "rendering",
+  "complete",
+  "error",
+  "cancelled"
+]);
+var RenderProgressPhase = z4.object({
+  phase: z4.string().min(1),
+  percent: z4.number().min(0).max(100),
+  scenesTotal: z4.number().int().positive().optional()
+});
+var RegistryPin = z4.object({
+  package: z4.string().min(1),
+  name: z4.string().min(1),
+  version: z4.string().min(1)
+});
+var MediaSourceSnapshot = z4.object({
+  mediaId: zid2("mediaItems"),
+  presignedUrl: z4.string().url(),
+  expiresAt: z4.number().optional()
+});
+var RenderSnapshot = z4.object({
+  composition: Composition,
+  brandKit: BrandKit.optional(),
+  mediaSources: z4.array(MediaSourceSnapshot),
+  registryPins: z4.array(RegistryPin),
+  capturedAt: z4.number()
+});
+var R2Destination = z4.object({
+  kind: z4.literal("r2"),
+  path: z4.string().optional()
+});
+var S3Destination = z4.object({
+  kind: z4.literal("s3"),
+  credentialId: z4.string().min(1),
+  bucket: z4.string().min(1),
+  key: z4.string().min(1),
+  region: z4.string().optional(),
+  acl: z4.string().optional()
+});
+var YoutubeDestination = z4.object({
+  kind: z4.literal("youtube"),
+  credentialId: z4.string().min(1),
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  privacy: z4.enum(["public", "unlisted", "private"]),
+  tags: z4.array(z4.string()).optional()
+});
+var MuxDestination = z4.object({
+  kind: z4.literal("mux"),
+  credentialId: z4.string().min(1),
+  passthrough: z4.string().optional()
+});
+var WebhookDestination = z4.object({
+  kind: z4.literal("webhook"),
+  url: z4.string().url(),
+  signingKeyId: z4.string().optional(),
+  headers: z4.record(z4.string(), z4.string()).optional()
+});
+var Destination = z4.discriminatedUnion("kind", [
+  R2Destination,
+  S3Destination,
+  YoutubeDestination,
+  MuxDestination,
+  WebhookDestination
+]);
+var DestinationDeliveryStatus = z4.enum([
+  "pending",
+  "uploading",
+  "delivered",
+  "failed"
+]);
+var DestinationResult = z4.object({
+  destinationIndex: z4.number().int().nonnegative(),
+  status: DestinationDeliveryStatus,
+  url: z4.string().url().optional(),
+  deliveredAt: z4.number().optional(),
+  error: z4.string().optional()
+});
+var RenderJob = z4.object({
+  id: zid2("renderJobs"),
+  projectId: zid2("projects").optional(),
+  compositionId: zid2("compositions"),
+  compositionVersionId: z4.string().min(1),
+  status: RenderStatus,
+  progress: RenderProgressPhase.optional(),
+  mode: RenderMode.optional(),
+  priority: RenderPriority,
+  // required per data-model.md § Render priority
+  intent: RenderIntent.optional(),
+  snapshot: RenderSnapshot.optional(),
+  snapshotRef: z4.string().optional(),
+  outputUrl: z4.string().url().optional(),
+  outputExpiresAt: z4.number().optional(),
+  // epoch ms
+  destinations: z4.array(Destination).optional(),
+  destinationResults: z4.array(DestinationResult).optional(),
+  cancelReason: RenderCancelReason.optional(),
+  // `error` is structured (richer than the doc's plain-string spec) so the worker
+  // can surface a stable code, a human message, and operator-visible details.
+  // See CONVEX_ADAPTATIONS.md for the rationale on richer-than-doc shapes.
+  error: z4.object({
+    code: z4.string(),
+    message: z4.string(),
+    details: z4.record(z4.string(), z4.unknown()).optional()
+  }).optional(),
+  createdAt: z4.number(),
+  updatedAt: z4.number()
+});
+var RenderProgress = z4.object({
+  jobId: zid2("renderJobs"),
+  status: RenderStatus,
+  percent: z4.number().min(0).max(100).optional(),
+  framesRendered: z4.number().int().nonnegative().optional(),
+  framesTotal: z4.number().int().positive().optional()
+});
+
+// ../composition/src/validators/registry.ts
+import { z as z5 } from "zod";
+var PrimitiveOriginClass = z5.enum([
+  "first-party",
+  "community-verified",
+  "community-unverified",
+  "user-private",
+  "sandbox",
+  "deprecated"
+]);
+var PrimitiveMode = z5.enum(["2d", "immersive", "interactive"]);
+var PrimitiveToken = z5.object({
+  path: z5.string().min(1),
+  fallback: z5.unknown()
+});
+var PrimitiveOtioMapping = z5.object({
+  effectName: z5.string().min(1),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+});
+var PrimitiveMeta = z5.object({
+  description: z5.string().optional(),
+  use_when: z5.array(z5.string()).optional(),
+  avoid_when: z5.array(z5.string()).optional(),
+  vibe: z5.array(z5.string()).optional(),
+  formats: z5.array(z5.string()).optional(),
+  pairs_well_with: z5.array(z5.string()).optional(),
+  exemplars: z5.array(z5.string()).optional()
+});
+var PrimitiveRegistryEntry = z5.object({
+  name: z5.string().min(1),
+  package: z5.string().min(1),
+  category: z5.enum(["overlay", "text", "effect", "transition", "layout"]),
+  version: z5.string().min(1),
+  origin: PrimitiveOriginClass,
+  modes: z5.array(PrimitiveMode).optional(),
+  paramsSchema: z5.unknown(),
+  varyingParams: z5.array(z5.string()).optional(),
+  extends: z5.string().optional(),
+  tokens: z5.array(PrimitiveToken).optional(),
+  otio: PrimitiveOtioMapping.optional(),
+  meta: PrimitiveMeta.optional()
+});
+
+// ../composition/src/validators/project.ts
+import { z as z6 } from "zod";
+import { zid as zid3 } from "convex-helpers/server/zod3";
+var Project = z6.object({
+  id: zid3("projects"),
+  name: z6.string().min(1),
+  // Default format applied to new Compositions created under this Project.
+  // Each Composition still carries its own Format — this is just the seed.
+  defaultFormat: Format.optional(),
+  // PAL-region fps conform default. See data-model.md § MediaItem for the table.
+  // 'palConformDefault: 24' makes 25fps PAL footage conform to 24 instead of 30.
+  palConformDefault: z6.union([z6.literal(24), z6.literal(30)]).optional(),
+  // Pointer to the currently-active Composition for this Project. Edits land
+  // on a new CompositionVersion each PUT; this pointer advances to the new
+  // version's id. Nullable when the Project has no active Composition (e.g.,
+  // immediately after creation, or after the active composition was hard-deleted).
+  activeCompositionId: zid3("compositions").nullable().optional(),
+  // Stable external `kitId` STRING (the v1 brand-kits API id), not a strict
+  // `zid("brandKits")`. Resolved org-scoped at render by either kitId or the
+  // legacy convex `_id`. Keeps the brand reference consistent end-to-end (#33).
+  brandKitId: z6.string().optional(),
+  ownerOrgId: z6.string().optional(),
+  createdAt: z6.number(),
+  updatedAt: z6.number()
+});
+
+// ../composition/src/validators/session.ts
+import { z as z7 } from "zod";
+import { zid as zid4 } from "convex-helpers/server/zod3";
+var SessionMediaRole = z7.enum([
+  "main",
+  "wide",
+  "facecam",
+  "screen",
+  "audio"
+]);
+var SessionMember = z7.object({
+  mediaId: zid4("mediaItems"),
+  role: SessionMediaRole,
+  label: z7.string().optional()
+  // human-readable annotation, e.g., "host's camera"
+});
+var SessionMux = z7.object({
+  videoRole: z7.enum(["main", "wide", "facecam", "screen"]),
+  audioRole: z7.literal("audio")
+});
+var Session = z7.object({
+  id: zid4("sessions"),
+  name: z7.string().min(1),
+  members: z7.array(SessionMember).nonempty(),
+  mux: z7.array(SessionMux).optional(),
+  ownerOrgId: z7.string().optional(),
+  createdAt: z7.number(),
+  updatedAt: z7.number()
+});
+
+// ../composition/src/validators/webhook.ts
+import { z as z8 } from "zod";
+import { zid as zid5 } from "convex-helpers/server/zod3";
+var SubstrateWebhookEvent = z8.enum([
+  // Render lifecycle — A3 terminal family (plan 2026-07-10-flow-checkpoint):
+  // ONE terminal event per kind, `status` INSIDE the payload.
+  "render.completed",
+  // MediaItem lifecycle
+  "media.transcribed",
+  "media.completed",
+  // Composition lifecycle
+  "composition.updated"
+]);
+var WebhookDeliveryStatus = z8.enum([
+  "pending",
+  "delivering",
+  "delivered",
+  "failed",
+  "exhausted"
+  // retry budget burned through
+]);
+var Webhook = z8.object({
+  id: zid5("webhooks"),
+  url: z8.string().url(),
+  // Open string array — substrate event names live in SubstrateWebhookEvent;
+  // domain packages export their own event enums and consumers compose them.
+  events: z8.array(z8.string().min(1)).nonempty(),
+  // Standard Webhooks signing key reference; the signing secret itself is
+  // stored server-side and never round-tripped through the API surface.
+  signingKeyId: z8.string().optional(),
+  // Optional headers the subscriber wants on every delivery.
+  headers: z8.record(z8.string(), z8.string()).optional(),
+  enabled: z8.boolean().optional(),
+  ownerOrgId: z8.string().optional(),
+  createdAt: z8.number(),
+  updatedAt: z8.number()
+});
+var WebhookDelivery = z8.object({
+  id: z8.string().min(1),
+  webhookId: zid5("webhooks"),
+  // Open string — could be any substrate or domain event name.
+  event: z8.string().min(1),
+  payload: z8.record(z8.string(), z8.unknown()),
+  status: WebhookDeliveryStatus,
+  attemptCount: z8.number().int().nonnegative(),
+  responseStatus: z8.number().int().optional(),
+  responseBody: z8.string().optional(),
+  error: z8.string().optional(),
+  createdAt: z8.number(),
+  deliveredAt: z8.number().optional()
+});
+
+export {
+  PlanSubject,
+  PlanFramingSegment,
+  PlanCut,
+  PlanAssetRequest,
+  PlanGraphicRequest,
+  PlanMarker,
+  ComposePlan,
+  EasingValue,
+  AudioPaletteRef,
+  FontRef,
+  Motif,
+  BrandKit,
+  FontStatus,
+  FontVariant,
+  Font,
+  RenderPriority,
+  RenderIntent,
+  RenderMode,
+  RenderCancelReason,
+  RenderStatus,
+  RenderProgressPhase,
+  RegistryPin,
+  MediaSourceSnapshot,
+  RenderSnapshot,
+  R2Destination,
+  S3Destination,
+  YoutubeDestination,
+  MuxDestination,
+  WebhookDestination,
+  Destination,
+  DestinationDeliveryStatus,
+  DestinationResult,
+  RenderJob,
+  RenderProgress,
+  PrimitiveOriginClass,
+  PrimitiveMode,
+  PrimitiveToken,
+  PrimitiveOtioMapping,
+  PrimitiveMeta,
+  PrimitiveRegistryEntry,
+  Project,
+  SessionMediaRole,
+  SessionMember,
+  SessionMux,
+  Session,
+  SubstrateWebhookEvent,
+  WebhookDeliveryStatus,
+  Webhook,
+  WebhookDelivery
+};