@cueframe/kernel 0.2.56 → 0.2.58

package/dist/chunk-IG3YAOUZ.js

@@ -0,0 +1,418 @@
+import {
+  BrandKit
+} from "./chunk-PWWZTY3G.js";
+import {
+  Composition,
+  Copy,
+  Format,
+  GraphicRole,
+  OpaqueId
+} from "./chunk-UFD4EZHM.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(),
+  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),
+  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/font.ts
+import { z as z2 } from "zod";
+var FontStatus = z2.enum([
+  "pending",
+  "uploading",
+  "analyzing",
+  "subsetting",
+  "ready",
+  "partial",
+  // common-glyphs buffer present, custom glyphs still subsetting
+  "failed"
+]);
+var FontVariant = z2.object({
+  weight: z2.number().int().min(100).max(900),
+  style: z2.enum(["normal", "italic"]),
+  storageKey: z2.string().min(1),
+  byteSize: z2.number().int().nonnegative().optional(),
+  subsetComplete: z2.boolean().optional()
+});
+var Font = z2.object({
+  id: z2.string().min(1),
+  family: z2.string().min(1),
+  status: FontStatus,
+  variants: z2.array(FontVariant).nonempty(),
+  source: z2.enum(["uploaded", "system", "web"]).optional(),
+  license: z2.object({
+    type: z2.string().min(1),
+    source: z2.string().optional(),
+    notes: z2.string().optional()
+  }).optional(),
+  createdAt: z2.number().optional(),
+  // epoch ms
+  ownerOrgId: z2.string().optional()
+});
+
+// ../composition/src/validators/render.ts
+import { z as z3 } from "zod";
+var RenderPriority = z3.enum(["interactive", "standard", "background"]);
+var RenderIntent = z3.enum(["preview", "final"]);
+var RenderMode = z3.enum(["offline", "live"]);
+var RenderCancelReason = z3.enum([
+  "user",
+  "agent",
+  "cost_limit",
+  "superseded",
+  "source_removed",
+  "timeout",
+  "error"
+]);
+var RenderStatus = z3.enum([
+  "pending",
+  "rendering",
+  "complete",
+  "error",
+  "cancelled"
+]);
+var RenderProgressPhase = z3.object({
+  phase: z3.string().min(1),
+  percent: z3.number().min(0).max(100),
+  scenesTotal: z3.number().int().positive().optional()
+});
+var RegistryPin = z3.object({
+  package: z3.string().min(1),
+  name: z3.string().min(1),
+  version: z3.string().min(1)
+});
+var MediaSourceSnapshot = z3.object({
+  mediaId: OpaqueId,
+  presignedUrl: z3.string().url(),
+  expiresAt: z3.number().optional()
+});
+var RenderSnapshot = z3.object({
+  composition: Composition,
+  brandKit: BrandKit.optional(),
+  mediaSources: z3.array(MediaSourceSnapshot),
+  registryPins: z3.array(RegistryPin),
+  capturedAt: z3.number()
+});
+var R2Destination = z3.object({
+  kind: z3.literal("r2"),
+  path: z3.string().optional()
+});
+var S3Destination = z3.object({
+  kind: z3.literal("s3"),
+  credentialId: z3.string().min(1),
+  bucket: z3.string().min(1),
+  key: z3.string().min(1),
+  region: z3.string().optional(),
+  acl: z3.string().optional()
+});
+var YoutubeDestination = z3.object({
+  kind: z3.literal("youtube"),
+  credentialId: z3.string().min(1),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  privacy: z3.enum(["public", "unlisted", "private"]),
+  tags: z3.array(z3.string()).optional()
+});
+var MuxDestination = z3.object({
+  kind: z3.literal("mux"),
+  credentialId: z3.string().min(1),
+  passthrough: z3.string().optional()
+});
+var WebhookDestination = z3.object({
+  kind: z3.literal("webhook"),
+  url: z3.string().url(),
+  signingKeyId: z3.string().optional(),
+  headers: z3.record(z3.string(), z3.string()).optional()
+});
+var Destination = z3.discriminatedUnion("kind", [
+  R2Destination,
+  S3Destination,
+  YoutubeDestination,
+  MuxDestination,
+  WebhookDestination
+]);
+var DestinationDeliveryStatus = z3.enum([
+  "pending",
+  "uploading",
+  "delivered",
+  "failed"
+]);
+var DestinationResult = z3.object({
+  destinationIndex: z3.number().int().nonnegative(),
+  status: DestinationDeliveryStatus,
+  url: z3.string().url().optional(),
+  deliveredAt: z3.number().optional(),
+  error: z3.string().optional()
+});
+var RenderJob = z3.object({
+  id: OpaqueId,
+  projectId: OpaqueId.optional(),
+  compositionId: OpaqueId,
+  compositionVersionId: z3.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: z3.string().optional(),
+  outputUrl: z3.string().url().optional(),
+  outputExpiresAt: z3.number().optional(),
+  // epoch ms
+  destinations: z3.array(Destination).optional(),
+  destinationResults: z3.array(DestinationResult).optional(),
+  cancelReason: RenderCancelReason.optional(),
+  error: z3.object({
+    code: z3.string(),
+    message: z3.string(),
+    details: z3.record(z3.string(), z3.unknown()).optional()
+  }).optional(),
+  createdAt: z3.number(),
+  updatedAt: z3.number()
+});
+var RenderProgress = z3.object({
+  jobId: OpaqueId,
+  status: RenderStatus,
+  percent: z3.number().min(0).max(100).optional(),
+  framesRendered: z3.number().int().nonnegative().optional(),
+  framesTotal: z3.number().int().positive().optional()
+});
+
+// ../composition/src/validators/registry.ts
+import { z as z4 } from "zod";
+var PrimitiveOriginClass = z4.enum([
+  "first-party",
+  "community-verified",
+  "community-unverified",
+  "user-private",
+  "sandbox",
+  "deprecated"
+]);
+var PrimitiveMode = z4.enum(["2d", "immersive", "interactive"]);
+var PrimitiveToken = z4.object({
+  path: z4.string().min(1),
+  fallback: z4.unknown()
+});
+var PrimitiveOtioMapping = z4.object({
+  effectName: z4.string().min(1),
+  metadata: z4.record(z4.string(), z4.unknown()).optional()
+});
+var PrimitiveMeta = z4.object({
+  description: z4.string().optional(),
+  use_when: z4.array(z4.string()).optional(),
+  avoid_when: z4.array(z4.string()).optional(),
+  vibe: z4.array(z4.string()).optional(),
+  formats: z4.array(z4.string()).optional(),
+  pairs_well_with: z4.array(z4.string()).optional(),
+  exemplars: z4.array(z4.string()).optional()
+});
+var PrimitiveRegistryEntry = z4.object({
+  name: z4.string().min(1),
+  package: z4.string().min(1),
+  category: z4.enum(["overlay", "text", "effect", "transition", "layout"]),
+  version: z4.string().min(1),
+  origin: PrimitiveOriginClass,
+  modes: z4.array(PrimitiveMode).optional(),
+  paramsSchema: z4.unknown(),
+  varyingParams: z4.array(z4.string()).optional(),
+  extends: z4.string().optional(),
+  tokens: z4.array(PrimitiveToken).optional(),
+  otio: PrimitiveOtioMapping.optional(),
+  meta: PrimitiveMeta.optional()
+});
+
+// ../composition/src/validators/project.ts
+import { z as z5 } from "zod";
+var Project = z5.object({
+  id: OpaqueId,
+  name: z5.string().min(1),
+  defaultFormat: Format.optional(),
+  palConformDefault: z5.union([z5.literal(24), z5.literal(30)]).optional(),
+  activeCompositionId: OpaqueId.nullable().optional(),
+  brandKitId: z5.string().optional(),
+  ownerOrgId: z5.string().optional(),
+  createdAt: z5.number(),
+  updatedAt: z5.number()
+});
+
+// ../composition/src/validators/session.ts
+import { z as z6 } from "zod";
+var SessionMediaRole = z6.enum([
+  "main",
+  "wide",
+  "facecam",
+  "screen",
+  "audio"
+]);
+var SessionMember = z6.object({
+  mediaId: OpaqueId,
+  role: SessionMediaRole,
+  label: z6.string().optional()
+  // human-readable annotation, e.g., "host's camera"
+});
+var SessionMux = z6.object({
+  videoRole: z6.enum(["main", "wide", "facecam", "screen"]),
+  audioRole: z6.literal("audio")
+});
+var Session = z6.object({
+  id: OpaqueId,
+  name: z6.string().min(1),
+  members: z6.array(SessionMember).nonempty(),
+  mux: z6.array(SessionMux).optional(),
+  ownerOrgId: z6.string().optional(),
+  createdAt: z6.number(),
+  updatedAt: z6.number()
+});
+
+// ../composition/src/validators/webhook.ts
+import { z as z7 } from "zod";
+var SubstrateWebhookEvent = z7.enum([
+  "render.completed",
+  "media.transcribed",
+  "media.completed",
+  "composition.updated"
+]);
+var WebhookDeliveryStatus = z7.enum([
+  "pending",
+  "delivering",
+  "delivered",
+  "failed",
+  "exhausted"
+  // retry budget burned through
+]);
+var Webhook = z7.object({
+  id: OpaqueId,
+  url: z7.string().url(),
+  events: z7.array(z7.string().min(1)).nonempty(),
+  signingKeyId: z7.string().optional(),
+  headers: z7.record(z7.string(), z7.string()).optional(),
+  enabled: z7.boolean().optional(),
+  ownerOrgId: z7.string().optional(),
+  createdAt: z7.number(),
+  updatedAt: z7.number()
+});
+var WebhookDelivery = z7.object({
+  id: z7.string().min(1),
+  webhookId: OpaqueId,
+  event: z7.string().min(1),
+  payload: z7.record(z7.string(), z7.unknown()),
+  status: WebhookDeliveryStatus,
+  attemptCount: z7.number().int().nonnegative(),
+  responseStatus: z7.number().int().optional(),
+  responseBody: z7.string().optional(),
+  error: z7.string().optional(),
+  createdAt: z7.number(),
+  deliveredAt: z7.number().optional()
+});
+
+export {
+  PlanSubject,
+  PlanFramingSegment,
+  PlanCut,
+  PlanAssetRequest,
+  PlanGraphicRequest,
+  PlanMarker,
+  ComposePlan,
+  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
+};

package/dist/{chunk-Z4G3VM3H.js → chunk-JN3GF36B.js}

@@ -1,7 +1,7 @@
 import {
   ChatErrorView,
   DirectorTurnContext
-} from "./chunk-N54EGUVM.js";
+} from "./chunk-3VLDQE26.js";
 import {
   GenerationArtifact
 } from "./chunk-73DQTUWY.js";

package/dist/{chunk-DV7ZFVL4.js → chunk-MFMR3LHO.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-OSMXQV5V.js";
 import {
   CueframeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-AK5QBHOB.js";
 
 // ../execution/render-harness/src/cardAssetAdmission.ts
 import parseCss from "css-tree/parser";

package/dist/{chunk-JPMVNMF3.js → chunk-MNO6AO2J.js}

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

package/dist/{chunk-VDLWT5RY.js → chunk-NVXSKKRN.js}

@@ -20,7 +20,7 @@ import {
   scoreAndRank,
   segmentShots,
   stabilizeSelectionHysteresis
-} from "./chunk-JPMVNMF3.js";
+} from "./chunk-MNO6AO2J.js";
 import {
   flattenCompoundClips,
   hasCompoundClips
@@ -31,7 +31,7 @@ import {
 } from "./chunk-VZ7TYX6Z.js";
 import {
   resolveBrandRef
-} from "./chunk-TLOYCCCI.js";
+} from "./chunk-DKBFAQCW.js";
 import {
   SHOT_SCALE_TARGET,
   shotScaleZoom
@@ -39,7 +39,7 @@ import {
 import {
   CueframeError,
   encodeError
-} from "./chunk-E63UEO5C.js";
+} from "./chunk-AK5QBHOB.js";
 import {
   SCENE_CAPTURE_IDENTITY_FIELDS_V1,
   SCENE_PRESET_TRIANGLES,
@@ -1995,7 +1995,8 @@ function referencedMediaIds(composition) {
 function assertMergedCaptionFacesDrawable(composition) {
   const captions = composition.captions;
   if (!captions?.segments.some((segment) => segment.words.length > 0)) return;
-  const brandCaption = composition.brandKit?.caption;
+  const brandKit = composition.brandKit;
+  const brandCaption = brandKit?.syncCaptions === false ? void 0 : brandKit?.caption;
   const issues = mergedCaptionFaceIssues(captions.style, brandCaption);
   for (const [index, layout] of (captions.layouts ?? []).entries()) {
     for (const issue of mergedCaptionFaceIssues({ ...captions.style, ...layout.style }, brandCaption)) {
@@ -2005,7 +2006,7 @@ function assertMergedCaptionFacesDrawable(composition) {
   if (issues.length === 0) return;
   throw renderInputError(
     "font_not_reproducible",
-    "The caption style this render draws is the brand kit's caption block over the composition's own style, and that merge names a face with no file behind it: " + issues.map((issue) => `${issue.path}: ${issue.message}`).join(" "),
+    "The caption style this render draws names a face with no file behind it: " + issues.map((issue) => `${issue.path}: ${issue.message}`).join(" "),
     {
       compositionPath: issues[0].path,
       fields: issues.map((issue) => issue.path)
@@ -2114,11 +2115,11 @@ function compositionToRenderInput(composition, srcUrls, trajectoryUrls, coViewUr
     bodyDurationInFrames,
     fps
   );
-  const cap = brandKit?.caption;
-  const brandAccent = cap?.fg ?? brandKit?.colors?.accent;
+  const cap = brandKit?.syncCaptions === false ? void 0 : brandKit?.caption;
+  const brandAccent = brandKit?.syncCaptions === false ? void 0 : cap?.fg ?? brandKit?.colors?.accent;
   const mot = brandKit?.motion;
   const ANIMATED_CAPTION_ENTRANCES = ["fade", "word-pop", "stagger-up"];
-  const captionEntrance = ANIMATED_CAPTION_ENTRANCES.includes(
+  const captionEntrance = brandKit?.syncCaptions !== false && ANIMATED_CAPTION_ENTRANCES.includes(
     mot?.entrance
   ) ? mot.entrance : void 0;
   const captionMotion = captionEntrance ? {