@cueframe/kernel 0.1.0 → 0.1.2

package/dist/{chunk-W35ZMOXB.js → chunk-WPZKOVYF.js}

@@ -7,11 +7,6 @@ var GRAPHIC_ROLE_CANONICAL_KIND = {
   "pull-quote": "overlay",
   hero: "overlay",
   "logo-tag": "overlay",
-  // The ARGUMENT roles default to `overlay` too: the catalog's argument-carrying components
-  // (reasoning-trace, tool-call-stack, benchmark-bars, metric-gauge, eval-scorecard) are all
-  // overlay primitives placed by `primitiveId`. A designer that ESCALATES to a custom .tsx
-  // authors a `component` clip, and the exclusions check runs against the clip it actually
-  // wrote — this map only supplies the plan-time default.
   enumeration: "overlay",
   sequence: "overlay",
   comparison: "overlay"

package/dist/chunk-WZH57M53.js

@@ -0,0 +1,494 @@
+import {
+  Reframe
+} from "./chunk-2B5VJZHL.js";
+
+// ../composition/src/validators/composition.ts
+import { z } from "zod";
+import { zid } from "convex-helpers/server/zod3";
+var Format = z.object({
+  aspectRatio: z.enum(["16:9", "9:16", "1:1", "4:5"]),
+  fps: z.union([z.literal(24), z.literal(30), z.literal(60)]).optional(),
+  resolution: z.enum(["hd", "fhd", "4k"]).optional(),
+  platform: z.string().optional()
+});
+var Trim = z.object({
+  start: z.number().nonnegative(),
+  end: z.number().nonnegative()
+});
+var ExcludedRange = z.object({
+  start: z.number().nonnegative(),
+  end: z.number().nonnegative(),
+  reason: z.string().optional()
+});
+var MediaClipSource = z.object({
+  kind: z.literal("media"),
+  mediaId: zid("mediaItems"),
+  trim: Trim.optional(),
+  excludedRanges: z.array(ExcludedRange).optional(),
+  volume: z.number().min(0).max(4).optional(),
+  muted: z.boolean().optional(),
+  playbackRate: z.number().positive().optional(),
+  sync: z.enum(["video", "independent"]).optional(),
+  kenBurns: z.enum(["in", "out", "pan-l", "pan-r", "none"]).optional(),
+  volumeDb: z.number().optional(),
+  fadeInMs: z.number().nonnegative().optional(),
+  fadeOutMs: z.number().nonnegative().optional(),
+  loop: z.boolean().optional(),
+  audioRole: z.enum(["sfx", "music", "vo", "ambience"]).optional(),
+  duck: z.object({
+    duckDb: z.number().max(0),
+    attackMs: z.number().nonnegative(),
+    releaseMs: z.number().nonnegative(),
+    windows: z.array(z.object({ startMs: z.number(), endMs: z.number() })).optional()
+  }).optional(),
+  anchor: z.object({
+    clipId: z.string().min(1),
+    offsetMs: z.number()
+  }).optional(),
+  reframe: Reframe.optional()
+});
+var ComponentClipSource = z.object({
+  kind: z.literal("component"),
+  componentId: z.string().min(1),
+  props: z.record(z.string(), z.unknown()),
+  zPlane: z.enum(["front", "behind-subject"]).optional()
+});
+var OverlayClipSource = z.object({
+  kind: z.literal("overlay"),
+  primitiveId: z.string().min(1),
+  params: z.record(z.string(), z.unknown()),
+  zPlane: z.enum(["front", "behind-subject"]).optional(),
+  anchor: z.object({ space: z.literal("scene"), x: z.number().min(0).max(1), y: z.number().min(0).max(1) }).optional(),
+  parallax: z.number().min(-0.3).max(0.3).optional()
+});
+var EffectClipSource = z.object({
+  kind: z.literal("effect"),
+  primitiveId: z.string().min(1),
+  params: z.record(z.string(), z.unknown()).optional()
+});
+var AlphaLayerClipSource = z.object({
+  kind: z.literal("alpha-layer"),
+  componentId: z.string().min(1),
+  props: z.record(z.string(), z.unknown()),
+  zPlane: z.enum(["front", "behind-subject"]).optional()
+});
+var CardClipSource = z.object({
+  kind: z.literal("card"),
+  html: z.string().min(1),
+  tokens: z.record(z.string(), z.string()).optional(),
+  zPlane: z.literal("front").optional()
+});
+var CompositionClipSource = z.object({
+  kind: z.literal("composition"),
+  compositionId: z.string().min(1),
+  trim: Trim.optional()
+}).strict();
+var ClipSource = z.discriminatedUnion("kind", [
+  MediaClipSource,
+  ComponentClipSource,
+  OverlayClipSource,
+  EffectClipSource,
+  AlphaLayerClipSource,
+  CardClipSource,
+  CompositionClipSource
+]);
+var Transition = z.object({
+  type: z.string().min(1),
+  duration: z.number().positive()
+});
+var Position = z.object({
+  x: z.number(),
+  y: z.number()
+});
+var Region = z.object({
+  x: z.number().min(0).max(1),
+  y: z.number().min(0).max(1),
+  w: z.number().positive().max(1),
+  h: z.number().positive().max(1)
+});
+var ClipFit = z.enum(["cover", "contain"]);
+var PerClipEffect = z.object({
+  primitiveId: z.string().min(1),
+  params: z.record(z.string(), z.unknown()).optional()
+});
+var KeyframeEasing = z.union([
+  z.enum(["linear", "ease", "easeIn", "easeOut", "easeInOut"]),
+  z.object({ cubicBezier: z.tuple([z.number(), z.number(), z.number(), z.number()]) }).strict()
+]);
+var Keyframe = z.object({
+  time: z.number().nonnegative(),
+  value: z.number(),
+  easing: KeyframeEasing.optional()
+}).strict();
+var KeyframeChannel = z.array(Keyframe).min(2);
+var ANIMATABLE_PARAMS = [
+  "opacity",
+  "scale",
+  "rotation",
+  "position.x",
+  "position.y",
+  "volume"
+];
+var TimelineClip = z.object({
+  id: z.string().min(1),
+  startTime: z.number().nonnegative(),
+  duration: z.number().positive(),
+  source: ClipSource,
+  kind: z.enum(["video", "audio", "image", "overlay", "effect"]).optional(),
+  opacity: z.number().min(0).max(1).optional(),
+  scale: z.number().positive().optional(),
+  rotation: z.number().optional(),
+  position: Position.optional(),
+  region: Region.optional(),
+  fit: ClipFit.optional(),
+  effects: z.array(PerClipEffect).optional(),
+  transitionIn: Transition.optional(),
+  linkGroupId: z.string().min(1).optional(),
+  animate: z.record(z.string(), KeyframeChannel).superRefine((channels, ctx) => {
+    for (const key of Object.keys(channels)) {
+      if (!ANIMATABLE_PARAMS.includes(key)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: [key],
+          message: `"${key}" is not an animatable param (${ANIMATABLE_PARAMS.join(", ")})`
+        });
+      }
+    }
+  }).optional()
+}).strict();
+var Gap = z.object({
+  id: z.string().min(1),
+  startTime: z.number().nonnegative(),
+  duration: z.number().positive()
+}).strict();
+var TrackContent = z.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 z.NEVER;
+  }
+  return res.data;
+});
+var Track = z.object({
+  id: z.string().min(1),
+  kind: z.enum(["video", "audio", "image", "overlay", "effect"]),
+  name: z.string().optional(),
+  enabled: z.boolean().optional(),
+  volume: z.number().min(0).max(4).optional(),
+  contents: z.array(TrackContent)
+}).strict();
+var Marker = z.object({
+  id: z.string().min(1),
+  startTime: z.number().nonnegative(),
+  endTime: z.number().nonnegative().optional(),
+  kind: z.string().min(1),
+  name: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).strict();
+var AccessControl = z.object({
+  public: z.boolean().optional(),
+  readerOrgIds: z.array(z.string()).optional(),
+  writerOrgIds: z.array(z.string()).optional()
+});
+var LicenseDeclaration = z.object({
+  type: z.string().min(1),
+  source: z.string().optional(),
+  notes: z.string().optional()
+});
+var CompositionAccessibility = z.object({
+  audioDescriptionTrackId: z.string().optional(),
+  captionsTrackId: z.string().optional(),
+  signLanguageTrackId: z.string().optional(),
+  notes: z.string().optional()
+});
+var CaptionWord = z.object({
+  text: z.string().min(1),
+  startMs: z.number().nonnegative(),
+  endMs: z.number().nonnegative(),
+  emphasis: z.boolean().optional(),
+  annotate: z.enum(["circle", "underline"]).optional()
+});
+var CaptionStyle = z.object({
+  fontFamily: z.string().min(1).optional(),
+  fontSize: z.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: z.number().int().min(100).max(900).optional(),
+  color: z.string().min(1).optional(),
+  highlightColor: z.string().min(1).optional(),
+  backgroundColor: z.string().optional(),
+  plate: z.enum(["glass", "solid", "none"]).optional(),
+  position: z.enum(["top", "center", "bottom"]).optional(),
+  textTransform: z.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisColor: z.string().optional(),
+  emphasisGradient: z.string().optional(),
+  emphasisScale: z.number().positive().optional(),
+  emphasisFontFamily: z.string().optional(),
+  emphasisFontWeight: z.number().int().min(100).max(900).optional(),
+  emphasisTextTransform: z.enum(["none", "uppercase", "capitalize"]).optional(),
+  emphasisLetterSpacing: z.number().optional(),
+  emphasisFontStyle: z.enum(["normal", "italic"]).optional(),
+  entrance: z.enum(["none", "fade", "word-pop", "stagger-up"]).optional(),
+  entranceMs: z.number().nonnegative().optional(),
+  entranceStaggerMs: z.number().nonnegative().optional(),
+  exitMs: z.number().nonnegative().optional(),
+  emphasisPlate: z.boolean().optional(),
+  emphasisPlateColor: z.string().optional(),
+  emphasisPlateTextColor: z.string().optional(),
+  emphasisPlateAltColor: z.string().optional(),
+  emphasisPlateAltTextColor: z.string().optional(),
+  emphasisPlateRadius: z.number().nonnegative().optional(),
+  emphasisPlatePadX: z.number().optional(),
+  emphasisPlatePadY: z.number().optional(),
+  annotationColor: z.string().optional(),
+  maxWidthPercent: z.number().positive().max(100, "captions style.maxWidthPercent is % of composition width (max 100)").optional()
+});
+var CaptionSegment = z.object({
+  words: z.array(CaptionWord)
+});
+var CaptionDepth = z.enum(["front", "behind-subject"]).optional();
+var CompositionCaptions = z.discriminatedUnion("source", [
+  z.object({
+    source: z.literal("derived"),
+    from: z.object({ clipId: z.string() }),
+    segments: z.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  }),
+  z.object({
+    source: z.literal("authored"),
+    segments: z.array(CaptionSegment),
+    style: CaptionStyle.optional(),
+    zPlane: CaptionDepth
+  })
+]);
+function captionsAreBehindSubject(captions) {
+  return captions?.zPlane === "behind-subject";
+}
+function captionWords(c) {
+  return c.segments.flatMap((s) => s.words);
+}
+var Composition = z.object({
+  v: z.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: z.array(Track),
+  markers: z.array(Marker).optional(),
+  captions: CompositionCaptions.optional(),
+  sourceSuggestionId: z.string().optional(),
+  license: LicenseDeclaration.optional(),
+  licenseVerification: z.enum([
+    "attested",
+    "cueframe-verified",
+    "third-party-verified"
+  ]).optional(),
+  accessibility: CompositionAccessibility.optional(),
+  ownerOrgId: z.string().optional(),
+  acl: AccessControl.optional()
+}).strict();
+var CompositionAuthorKind = z.enum(["user", "agent", "import"]);
+var CompositionVersion = z.object({
+  id: z.string().min(1),
+  compositionId: zid("compositions"),
+  predecessorId: z.string().optional(),
+  createdAt: z.number(),
+  // epoch ms — see CONVEX_ADAPTATIONS.md
+  etag: z.string().min(1),
+  authorKind: CompositionAuthorKind,
+  // load-bearing for multi-agent lineage
+  authorId: z.string().optional(),
+  // userId for 'user', agentId for 'agent', source for 'import'
+  composition: Composition
+});
+
+// ../composition/src/graphics-plan/schemas.ts
+import { z as z2 } from "zod";
+var GRAPHICS_PLAN_VERSION = "gp-1";
+var Version = z2.literal(GRAPHICS_PLAN_VERSION);
+var PlanRect = Region;
+var GraphicRole = z2.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 = z2.object({
+  headline: z2.string().max(120).optional(),
+  sub: z2.string().max(200).optional(),
+  value: z2.string().max(40).optional(),
+  label: z2.string().max(80).optional(),
+  items: z2.array(z2.string().max(80)).max(8).optional(),
+  series: z2.array(z2.object({ label: z2.string().max(40), value: z2.string().max(16) })).max(8).optional()
+}).strict();
+var ContentBeat = z2.object({
+  id: z2.string().min(1),
+  atSec: z2.number().min(0),
+  durSec: z2.number().positive(),
+  role: GraphicRole,
+  copy: Copy,
+  intent: z2.string().min(1).max(400),
+  priority: z2.number().int().min(0).max(10).default(5)
+}).strict();
+var ContentPlan = z2.object({
+  version: Version,
+  beats: z2.array(ContentBeat)
+}).strict();
+var ElementRole = z2.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 = z2.enum([
+  "heading",
+  "body",
+  "accent",
+  "surface",
+  "on-accent",
+  "on-surface"
+]);
+var ZPlane = z2.enum(["front", "behind-subject"]);
+var LayoutElement = z2.object({
+  elId: z2.string().min(1),
+  role: ElementRole,
+  box: PlanRect,
+  styleRole: StyleRole,
+  z: ZPlane.default("front"),
+  text: z2.string().max(200).optional(),
+  typeScaleStep: z2.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 = z2.object({
+  version: Version,
+  beatId: z2.string().min(1),
+  frame: z2.object({ w: z2.number().positive(), h: z2.number().positive() }).strict(),
+  keepOut: z2.array(PlanRect),
+  safe: z2.object({
+    titleSafe: z2.number().min(0).max(1),
+    actionSafe: z2.number().min(0).max(1)
+  }).strict(),
+  elements: z2.array(LayoutElement),
+  dropped: z2.object({ reason: z2.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: z2.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: z2.ZodIssueCode.custom, message: `element ${el.elId} overlaps a face keep-out (text on the speaker)`, path: ["elements"] });
+      }
+    }
+  }
+});
+var EnterType = z2.enum(["reveal", "fade", "rise", "count-up", "wipe"]);
+var EmphasisType = z2.enum(["pulse", "underline", "color-shift"]);
+var ExitType = z2.enum(["fade", "fall", "wipe", "cut"]);
+var Ease = z2.enum(["spring", "ease-out", "ease-in-out", "linear"]);
+var EnterMotion = z2.object({
+  type: EnterType,
+  atMs: z2.number().min(0),
+  durMs: z2.number().positive(),
+  ease: Ease.default("spring"),
+  stagger: z2.number().min(0).optional()
+}).strict();
+var EmphasisMotion = z2.object({ type: EmphasisType, atMs: z2.number().min(0), durMs: z2.number().positive() }).strict();
+var ExitMotion = z2.object({ type: ExitType, atMs: z2.number().min(0), durMs: z2.number().positive() }).strict();
+var MotionElement = z2.object({
+  elId: z2.string().min(1),
+  enter: EnterMotion,
+  emphasis: EmphasisMotion.optional(),
+  exit: ExitMotion.optional()
+}).strict();
+var MotionPlan = z2.object({
+  version: Version,
+  beatId: z2.string().min(1),
+  elements: z2.array(MotionElement)
+}).strict();
+var GraphicsPlan = z2.object({
+  version: Version,
+  content: ContentPlan,
+  layouts: z2.array(LayoutPlan),
+  motions: z2.array(MotionPlan)
+}).strict();
+
+export {
+  Format,
+  MediaClipSource,
+  ComponentClipSource,
+  OverlayClipSource,
+  EffectClipSource,
+  AlphaLayerClipSource,
+  CardClipSource,
+  CompositionClipSource,
+  ClipSource,
+  Transition,
+  Region,
+  ClipFit,
+  PerClipEffect,
+  KeyframeEasing,
+  Keyframe,
+  KeyframeChannel,
+  ANIMATABLE_PARAMS,
+  TimelineClip,
+  Gap,
+  TrackContent,
+  Track,
+  Marker,
+  CaptionWord,
+  CaptionStyle,
+  CaptionSegment,
+  CompositionCaptions,
+  captionsAreBehindSubject,
+  captionWords,
+  Composition,
+  CompositionAuthorKind,
+  CompositionVersion,
+  GRAPHICS_PLAN_VERSION,
+  PlanRect,
+  GraphicRole,
+  Copy,
+  ContentBeat,
+  ContentPlan,
+  ElementRole,
+  StyleRole,
+  ZPlane,
+  LayoutElement,
+  LayoutPlan,
+  EnterType,
+  EmphasisType,
+  ExitType,
+  Ease,
+  EnterMotion,
+  EmphasisMotion,
+  ExitMotion,
+  MotionElement,
+  MotionPlan,
+  GraphicsPlan
+};

package/dist/{chunk-AYVJXDLB.js → chunk-XHGZ2E77.js}

@@ -58,8 +58,6 @@ var FitText = ({
         letterSpacing,
         textTransform,
         maxWidth,
-        // Clamp to maxLines with an ellipsis for the extreme case (text still too long
-        // at the floor). For maxLines===1 this also keeps it single-line.
         display: "-webkit-box",
         WebkitBoxOrient: "vertical",
         WebkitLineClamp: maxLines,

package/dist/{chunk-JRQVPFLF.js → chunk-XQ72DZKJ.js}

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

package/dist/{chunk-7DHP4ESU.js → chunk-YLDMAZZE.js}

@@ -33,21 +33,11 @@ var FROZEN_CORE_PATHS = [
   "fonts.heading",
   "fonts.body",
   "fonts.caption",
-  // Motion identity (ResolvedBrandKit.motion, extended 2026-06-14; full block
-  // 2026-06-28). Surfaces bind their entrance treatment + timing to the brand's
-  // motion so it's brand-driven, not hardcoded. The whole motion block is now
-  // bindable: duration/easing/entrance govern the entrance, staggerMs/exitMs the
-  // per-element cadence and exit.
   "motion.duration",
   "motion.easing",
   "motion.entrance",
   "motion.staggerMs",
   "motion.exitMs",
-  // Spacing + sizing (ResolvedBrandKit.spacing / .sizing, width-anchored,
-  // bindable 2026-06-28). Surfaces bind their rhythm (padding/gaps) and type
-  // scale (heading/body/label) + corner radius to the brand so layout geometry
-  // is brand-driven, not hardcoded. Each path maps 1:1 onto a materialized
-  // ResolvedBrandKit field.
   "spacing.base",
   "spacing.lg",
   "spacing.sm",

package/dist/{chunk-FYZVH3MC.js → chunk-YQ7FFW3G.js}

@@ -37,14 +37,9 @@ function resolveBrandKit(kit, compositionWidth) {
     accent: kit.colors.accent,
     background: safe.background,
     text: safe.text,
-    // De-emphasis mix faded toward background, RE-CLAMPED to the non-body floor:
-    // for a hostile (near-floor) brand the 40% fade can drop below Lc60, so the
-    // clamp forward-corrects it back up to legibility. For a legible brand the
-    // mix already clears the floor and the clamp is a no-op.
     textMuted: kit.colors.textMuted ?? clampToFloor(colorMix(safe.text, safe.background, 0.4), safe.background, FLOORS.nonBody),
     border: kit.colors.border ?? colorMix(safe.text, safe.background, 0.15),
     textOnMedia: safe.captionFg,
-    // Tier-2 core: author override wins, else the contrast-safe derived value.
     surface: kit.colors.surface ?? safe.surface,
     card: kit.colors.card ?? safe.card,
     gridLine: kit.colors.gridLine ?? safe.gridLine,
@@ -80,9 +75,6 @@ function resolveBrandKit(kit, compositionWidth) {
   const caption = {
     fg: cp?.emphasisColor ? clampToFloor(cp.emphasisColor, safe.captionScrim, FLOORS.body) : safe.captionFg,
     scrim: safe.captionScrim,
-    // Base + highlight color are forward-corrected to the body floor over the
-    // scrim, same guard as emphasisColor→fg (an authored accent that fails APCA
-    // is clamped UP to legibility, never rendered below the floor).
     ...cp?.color ? { color: clampToFloor(cp.color, safe.captionScrim, FLOORS.body) } : {},
     ...cp?.highlightColor ? { highlightColor: clampToFloor(cp.highlightColor, safe.captionScrim, FLOORS.body) } : {},
     ...cp?.plate ? { plate: cp.plate } : {},
@@ -278,9 +270,6 @@ function componentBrandPalette(kit) {
     textOnMedia: kit.colors.textOnMedia,
     textOnAccent: kit.colors.textOnAccent,
     textOnSurface: kit.colors.textOnSurface,
-    // A FontRef family can be undefined (unresolved) — hand the component an empty
-    // string so `fontFamily: props.brand.heading` falls to the browser default,
-    // never the literal "undefined". Mirrors cssLayoutVars dropping unresolved refs.
     heading: kit.fonts.heading.family ?? "",
     body: kit.fonts.body.family ?? "",
     caption: kit.fonts.caption.family ?? ""

package/dist/chunk-ZPLJ24OV.js

@@ -0,0 +1,93 @@
+import {
+  GenerationArtifact,
+  MediaId,
+  ProjectHome
+} from "./chunk-73DQTUWY.js";
+import {
+  EntityId
+} from "./chunk-XELS2BGA.js";
+import {
+  decodeError,
+  scrubSensitive
+} from "./chunk-LLUW26BS.js";
+
+// ../director/src/domain/chat.ts
+import { z } from "zod";
+var ConversationId = EntityId("conversation");
+var DirectorRunId = EntityId("directorRun");
+var ProjectRef = z.object({
+  id: z.string().min(1),
+  home: ProjectHome
+});
+var DirectorTurnContext = z.object({
+  location: z.string().min(1),
+  project: ProjectRef.nullable().default(null),
+  selectedMediaIds: z.array(MediaId).default([]),
+  fastMode: z.boolean().default(false)
+});
+var DirectorTurnEnvelope = z.object({
+  version: z.literal(1),
+  context: DirectorTurnContext
+});
+var ChatErrorView = z.object({
+  code: z.string().min(1),
+  title: z.string().min(1),
+  recovery: z.string().optional(),
+  retryable: z.boolean(),
+  source: z.enum(["provider", "generation", "materialisation", "agent", "transport"]).optional(),
+  correlationId: z.string().optional(),
+  details: z.string().max(4e3).optional()
+});
+function recoveryFor(code) {
+  if (code === "rate_limited" || code === "service_unavailable") return "Wait a moment, then retry.";
+  if (code === "unauthorized") return "Sign in again, then retry.";
+  if (code === "billing_required" || code === "payment_required") return "Check billing, then retry.";
+  if (code === "generation_budget_exceeded") return "Reduce the generation request or raise its spending limit.";
+  return void 0;
+}
+function chatErrorViewFromEnvelope(envelope, source = "agent") {
+  return {
+    code: envelope.code,
+    title: envelope.message.length <= 120 ? envelope.message : "The Director couldn\u2019t finish this request.",
+    retryable: envelope.retryable,
+    source,
+    ...recoveryFor(envelope.code) ? { recovery: recoveryFor(envelope.code) } : {},
+    details: scrubSensitive(envelope.message).slice(0, 4e3)
+  };
+}
+function chatErrorViewFromUnknown(error, source = "agent") {
+  const raw = error instanceof Error ? error.message : String(error ?? "");
+  const decoded = decodeError(raw);
+  if (decoded) return chatErrorViewFromEnvelope(decoded.toEnvelope(), source);
+  const details = scrubSensitive(raw).slice(0, 4e3);
+  const lower = raw.toLowerCase();
+  const retryable = /timeout|network|temporar|rate limit|unavailable|fetch/.test(lower);
+  return {
+    code: retryable ? "service_unavailable" : "director_failed",
+    title: retryable ? "The Director is temporarily unavailable." : "The Director couldn\u2019t finish this request.",
+    retryable,
+    source,
+    ...retryable ? { recovery: "Wait a moment, then retry." } : { recovery: "Review the request and try again." },
+    ...details ? { details } : {}
+  };
+}
+var DirectorEvent = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("text-delta"), text: z.string() }),
+  z.object({ type: z.literal("reasoning-delta"), text: z.string() }),
+  z.object({ type: z.literal("phase"), phase: z.string(), detail: z.string().optional() }),
+  z.object({ type: z.literal("generation"), artifact: GenerationArtifact }),
+  z.object({ type: z.literal("error"), error: ChatErrorView }),
+  z.object({ type: z.literal("finish") })
+]);
+
+export {
+  ConversationId,
+  DirectorRunId,
+  ProjectRef,
+  DirectorTurnContext,
+  DirectorTurnEnvelope,
+  ChatErrorView,
+  chatErrorViewFromEnvelope,
+  chatErrorViewFromUnknown,
+  DirectorEvent
+};

package/dist/cloud-import/multipart.js

@@ -1,6 +1,6 @@
 import {
   multipartUpload
-} from "../chunk-HCCBDJLW.js";
+} from "../chunk-EP2Y6M2J.js";
 import "../chunk-6IU2UQI5.js";
 import "../chunk-2ESYSVXG.js";
 export {