@cueframe/kernel 0.2.32 → 0.2.34

package/dist/{chunk-F5B6OM73.js → chunk-ANNB4VC6.js}

@@ -160,7 +160,8 @@ __export(zod_exports, {
   GetComposeJobResponse: () => GetComposeJobResponse,
   GetComposeSessionCompositionParams: () => GetComposeSessionCompositionParams,
   GetComposeSessionCompositionResponse: () => GetComposeSessionCompositionResponse,
-  GetCompositionParams: () => GetCompositionParams,
+  GetCompositionParams: () => GetCompositionParams2,
+  GetCompositionQueryParams: () => GetCompositionQueryParams,
   GetCompositionResponse: () => GetCompositionResponse,
   GetExportParams: () => GetExportParams,
   GetExportResponse: () => GetExportResponse,
@@ -429,7 +430,8 @@ __export(zod_exports, {
   getComposeJobResponse: () => GetComposeJobResponse,
   getComposeSessionCompositionParams: () => GetComposeSessionCompositionParams,
   getComposeSessionCompositionResponse: () => GetComposeSessionCompositionResponse,
-  getCompositionParams: () => GetCompositionParams,
+  getCompositionParams: () => GetCompositionParams2,
+  getCompositionQueryParams: () => GetCompositionQueryParams,
   getCompositionResponse: () => GetCompositionResponse,
   getExportParams: () => GetExportParams,
   getExportResponse: () => GetExportResponse,
@@ -1417,7 +1419,7 @@ var BriefCreateRequest = zod19.strictObject({
       "zPlane": zod19.enum(["front", "behind-subject"]).optional()
     }), zod19.strictObject({
       "kind": zod19.literal("card"),
-      "html": zod19.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod19.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod19.record(zod19.string(), zod19.string()).optional(),
       "zPlane": zod19.literal("front").optional()
     })]),
@@ -1674,7 +1676,7 @@ var BriefResponse = zod21.strictObject({
       "zPlane": zod21.enum(["front", "behind-subject"]).optional()
     }), zod21.strictObject({
       "kind": zod21.literal("card"),
-      "html": zod21.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod21.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod21.record(zod21.string(), zod21.string()).optional(),
       "zPlane": zod21.literal("front").optional()
     })]),
@@ -1920,7 +1922,7 @@ var BriefPatchRequest = zod23.strictObject({
       "zPlane": zod23.enum(["front", "behind-subject"]).optional()
     }), zod23.strictObject({
       "kind": zod23.literal("card"),
-      "html": zod23.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod23.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod23.record(zod23.string(), zod23.string()).optional(),
       "zPlane": zod23.literal("front").optional()
     })]),
@@ -2666,7 +2668,7 @@ var Composition = zod57.strictObject({
         "zPlane": zod57.enum(["front", "behind-subject"]).optional()
       }), zod57.strictObject({
         "kind": zod57.literal("card"),
-        "html": zod57.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+        "html": zod57.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
         "tokens": zod57.record(zod57.string(), zod57.string()).optional(),
         "zPlane": zod57.literal("front").optional()
       })]),
@@ -6153,7 +6155,7 @@ var CompositionOp = zod66.union([zod66.strictObject({
       "zPlane": zod66.enum(["front", "behind-subject"]).optional()
     }), zod66.strictObject({
       "kind": zod66.literal("card"),
-      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod66.record(zod66.string(), zod66.string()).optional(),
       "zPlane": zod66.literal("front").optional()
     })]),
@@ -6302,7 +6304,7 @@ var CompositionOp = zod66.union([zod66.strictObject({
       "zPlane": zod66.enum(["front", "behind-subject"]).optional()
     }), zod66.strictObject({
       "kind": zod66.literal("card"),
-      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod66.record(zod66.string(), zod66.string()).optional(),
       "zPlane": zod66.literal("front").optional()
     })]).optional(),
@@ -6447,7 +6449,7 @@ var CompositionOp = zod66.union([zod66.strictObject({
       "zPlane": zod66.enum(["front", "behind-subject"]).optional()
     }), zod66.strictObject({
       "kind": zod66.literal("card"),
-      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. Web fonts: @import inside the HTML works (the render box has network); bare font-family names fall back silently."),
+      "html": zod66.string().min(1).describe("Your card's HTML \u2014 rendered VERBATIM as the graphic (shell motion via applyMotionPreset in a FOLLOWING call). CANVAS CONTRACT: the card renders in a viewport equal to the composition format's pixel frame (1080\xD71920 at 9:16 fhd); the root is NOT auto-pinned \u2014 declare explicit width/height matching the frame (box-sizing:border-box) and anchor content with flex/grid; position:absolute;inset:0 on the root does NOT fill the frame; for edge-to-edge backgrounds add an inner absolutely-positioned layer with generous negative inset. Overlay compositing applies a ~92% safe-area inset \u2014 keep critical copy away from the extreme edges. FONTS: name a family from GET /v1/fonts (list_render_fonts) \u2014 the renderer loads those faces for the card and waits for them, so `font-family: Inter` draws Inter. `@import` and remote font files are REFUSED: the card renders with no network. A family that is not on that list has no bytes behind it and the browser falls back, so end any stack with a generic (`Inter, sans-serif`) rather than relying on a system face being present."),
       "tokens": zod66.record(zod66.string(), zod66.string()).optional(),
       "zPlane": zod66.literal("front").optional()
     })]),
@@ -6666,7 +6668,7 @@ var CompositionOp = zod66.union([zod66.strictObject({
   "kind": zod66.enum(["video", "audio", "image", "overlay", "effect"]),
   "name": zod66.string().optional(),
   "id": zod66.string().optional()
-}).describe("Add an EMPTY track of a given family (video|audio|image|overlay|effect). Optional pinned `id`."), zod66.strictObject({
+}).describe("Add an EMPTY track of a given family (video|audio|image|overlay|effect). Optional pinned `id`. The new track is appended, so it starts at the BACK: index 0 is the top layer and higher indices are further back (see `reorderTracks`). Track order only ranks clips on the same plane \u2014 every overlay draws above the video lane unless its `zPlane` is `behind-subject`, whatever its track index."), zod66.strictObject({
   "type": zod66.literal("removeTrack"),
   "trackId": zod66.string()
 }).describe("Remove a track AND all its clips by id."), zod66.strictObject({
@@ -6680,7 +6682,7 @@ var CompositionOp = zod66.union([zod66.strictObject({
   "type": zod66.literal("reorderTracks"),
   "fromIndex": zod66.number(),
   "toIndex": zod66.number()
-}).describe("Move a track from one index to another (changes layer/compositing order)."), zod66.strictObject({
+}).describe('Move a track from one index to another. ORDER: index 0 is the TOP layer, not the bottom \u2014 moving a backdrop to index 0 puts it in FRONT of everything and hides the composition. Higher index = further back. PRECEDENCE: track order decides compositing only among clips on the same plane. Overlays are composited in a lane ABOVE the video lane whatever their track index; the one exception is `zPlane:"behind-subject"`, which moves the overlay inside its host clip, behind the segmented foreground. So if reordering tracks does not change what you see, the plane split already decided it.'), zod66.strictObject({
   "type": zod66.literal("moveClipToTrack"),
   "clipId": zod66.string(),
   "targetTrackId": zod66.string(),
@@ -6714,6 +6716,7 @@ var CompositionApplyRequest = zod67.strictObject({
   "ops": zod67.array(CompositionOp).min(1),
   "if_match": zod67.string().optional().describe('Optional OCC precondition \u2014 the strong etag (`"<hex>"`) the caller last saw. On mismatch the batch is rejected (409 stale_etag) before any op applies.'),
   "dry_run": zod67.boolean().optional().describe("When true, validate the batch (apply + projection accept/reject guards) WITHOUT persisting. Returns `{ valid, errors }` instead of applying."),
+  "composition_id": zod67.string().optional().describe("Target a SPECIFIC composition instead of the project's active one. Omit it and the project's active composition is edited, which is the default and the common case. `preview_frame` and `create_render` already accept a compositionId; this closes the gap so a second composition minted with `new_composition` can actually be authored into \u2014 build variant A, mint B, edit B, preview both. Mutually exclusive with `session_id`, which targets the session's scratch."),
   "session_id": zod67.string().optional().describe("Optional compose-session id. When present, the ops target the session's SCRATCH composition (a derived sibling) instead of the project's active composition \u2014 the server never mutates active until commit.")
 }).describe("POST /projects/:id/composition/apply body \u2014 a batch of CompositionOps.");
 
@@ -7048,533 +7051,539 @@ var GetComposeSessionComposition200 = zod99.strictObject({
   "composition": zod99.unknown()
 });
 
-// ../sdk/src/generated/zod/models/getMediaTranscriptParams.zod.ts
+// ../sdk/src/generated/zod/models/getCompositionParams.zod.ts
 import * as zod100 from "zod";
+var GetCompositionParams = zod100.strictObject({
+  "compositionId": zod100.string().optional()
+});
+
+// ../sdk/src/generated/zod/models/getMediaTranscriptParams.zod.ts
+import * as zod101 from "zod";
 var getMediaTranscriptParamsAfterMin = 0;
 var getMediaTranscriptParamsBeforeMin = 0;
 var getMediaTranscriptParamsLimitDefault = 20;
 var getMediaTranscriptParamsLimitMax = 100;
-var GetMediaTranscriptParams = zod100.strictObject({
-  "after": zod100.int().min(getMediaTranscriptParamsAfterMin).optional(),
-  "before": zod100.int().min(getMediaTranscriptParamsBeforeMin).optional(),
-  "limit": zod100.int().min(1).max(getMediaTranscriptParamsLimitMax).default(getMediaTranscriptParamsLimitDefault)
+var GetMediaTranscriptParams = zod101.strictObject({
+  "after": zod101.int().min(getMediaTranscriptParamsAfterMin).optional(),
+  "before": zod101.int().min(getMediaTranscriptParamsBeforeMin).optional(),
+  "limit": zod101.int().min(1).max(getMediaTranscriptParamsLimitMax).default(getMediaTranscriptParamsLimitDefault)
 });
 
 // ../sdk/src/generated/zod/models/getOpenAPISpec200.zod.ts
-import * as zod101 from "zod";
-var GetOpenAPISpec200 = zod101.looseObject({});
+import * as zod102 from "zod";
+var GetOpenAPISpec200 = zod102.looseObject({});
 
 // ../sdk/src/generated/zod/models/getUsageParams.zod.ts
-import * as zod102 from "zod";
+import * as zod103 from "zod";
 var getUsageParamsLimitMax = 100;
 var getUsageParamsFromMin = -9007199254740991;
 var getUsageParamsFromMax = 9007199254740991;
 var getUsageParamsToMin = -9007199254740991;
 var getUsageParamsToMax = 9007199254740991;
-var GetUsageParams = zod102.strictObject({
-  "limit": zod102.int().min(1).max(getUsageParamsLimitMax).optional(),
-  "after": zod102.string().optional(),
-  "projectId": zod102.string().optional(),
-  "jobId": zod102.string().optional(),
-  "from": zod102.int().min(getUsageParamsFromMin).max(getUsageParamsFromMax).optional(),
-  "to": zod102.int().min(getUsageParamsToMin).max(getUsageParamsToMax).optional()
+var GetUsageParams = zod103.strictObject({
+  "limit": zod103.int().min(1).max(getUsageParamsLimitMax).optional(),
+  "after": zod103.string().optional(),
+  "projectId": zod103.string().optional(),
+  "jobId": zod103.string().optional(),
+  "from": zod103.int().min(getUsageParamsFromMin).max(getUsageParamsFromMax).optional(),
+  "to": zod103.int().min(getUsageParamsToMin).max(getUsageParamsToMax).optional()
 });
 
 // ../sdk/src/generated/zod/models/healthParams.zod.ts
-import * as zod103 from "zod";
-var HealthParams = zod103.strictObject({
-  "deep": zod103.literal("1").optional()
+import * as zod104 from "zod";
+var HealthParams = zod104.strictObject({
+  "deep": zod104.literal("1").optional()
 });
 
 // ../sdk/src/generated/zod/models/healthResponse.zod.ts
-import * as zod104 from "zod";
-var HealthResponse = zod104.strictObject({
-  "status": zod104.enum(["ok", "degraded"]),
-  "version": zod104.string(),
-  "checks": zod104.record(zod104.string(), zod104.strictObject({
-    "ok": zod104.boolean(),
-    "detail": zod104.string().optional()
+import * as zod105 from "zod";
+var HealthResponse = zod105.strictObject({
+  "status": zod105.enum(["ok", "degraded"]),
+  "version": zod105.string(),
+  "checks": zod105.record(zod105.string(), zod105.strictObject({
+    "ok": zod105.boolean(),
+    "detail": zod105.string().optional()
   })).optional()
 }).describe("Health probe response.");
 
 // ../sdk/src/generated/zod/models/jobEnqueueResponse.zod.ts
-import * as zod105 from "zod";
-var JobEnqueueResponse = zod105.strictObject({
-  "jobId": zod105.string().describe("Poll GET /v1/jobs/{jobId} / wait_job until terminal."),
-  "jobKey": zod105.string().describe("Deterministic identity of the work (content hash of every input the result depends on). Re-enqueueing the same key returns the same job while it runs; a failed key revives as a fresh attempt."),
-  "kind": zod105.string().describe("Job family, e.g. `verify` | `preview` | `brand_kit_extract`."),
-  "status": zod105.enum(["running", "succeeded", "cancelled"]).describe("running on a fresh/deduped enqueue; succeeded when an identical request already completed. Cancelled is part of the shared status vocabulary; identical cancelled work revives to running.")
+import * as zod106 from "zod";
+var JobEnqueueResponse = zod106.strictObject({
+  "jobId": zod106.string().describe("Poll GET /v1/jobs/{jobId} / wait_job until terminal."),
+  "jobKey": zod106.string().describe("Deterministic identity of the work (content hash of every input the result depends on). Re-enqueueing the same key returns the same job while it runs; a failed key revives as a fresh attempt."),
+  "kind": zod106.string().describe("Job family, e.g. `verify` | `preview` | `brand_kit_extract`."),
+  "status": zod106.enum(["running", "succeeded", "cancelled"]).describe("running on a fresh/deduped enqueue; succeeded when an identical request already completed. Cancelled is part of the shared status vocabulary; identical cancelled work revives to running.")
 });
 
 // ../sdk/src/generated/zod/models/jobResponse.zod.ts
-import * as zod108 from "zod";
+import * as zod109 from "zod";
 
 // ../sdk/src/generated/zod/models/previewFrameJobResult.zod.ts
-import * as zod106 from "zod";
+import * as zod107 from "zod";
 var previewFrameJobResultArtifactsItemBytesExclusiveMin = 0;
 var previewFrameJobResultArtifactsItemBytesMax = 9007199254740991;
 var previewFrameJobResultArtifactsItemLayersOverlaysMin = 0;
 var previewFrameJobResultArtifactsItemLayersOverlaysMax = 9007199254740991;
-var PreviewFrameJobResult = zod106.strictObject({
-  "geometry": zod106.strictObject({
-    "scale": zod106.number(),
-    "compositionWidth": zod106.number().optional(),
-    "compositionHeight": zod106.number().optional(),
-    "width": zod106.number().optional(),
-    "height": zod106.number().optional()
+var PreviewFrameJobResult = zod107.strictObject({
+  "geometry": zod107.strictObject({
+    "scale": zod107.number(),
+    "compositionWidth": zod107.number().optional(),
+    "compositionHeight": zod107.number().optional(),
+    "width": zod107.number().optional(),
+    "height": zod107.number().optional()
   }),
-  "warnings": zod106.array(zod106.record(zod106.string(), zod106.unknown())).optional(),
-  "previewed": zod106.strictObject({
-    "source": zod106.enum(["inline", "scratch", "persisted"]),
-    "compositionId": zod106.string().optional(),
-    "etag": zod106.string().optional()
+  "warnings": zod107.array(zod107.record(zod107.string(), zod107.unknown())).optional(),
+  "previewed": zod107.strictObject({
+    "source": zod107.enum(["inline", "scratch", "persisted"]),
+    "compositionId": zod107.string().optional(),
+    "etag": zod107.string().optional()
   }),
-  "listUsd": zod106.number().optional().describe("List price charged for this delivered capture."),
-  "artifacts": zod106.array(zod106.strictObject({
-    "id": zod106.string(),
-    "beatSec": zod106.number(),
-    "bytes": zod106.int().gt(previewFrameJobResultArtifactsItemBytesExclusiveMin).max(previewFrameJobResultArtifactsItemBytesMax),
-    "contentType": zod106.enum(["image/png", "image/jpeg"]),
-    "layers": zod106.strictObject({
-      "video": zod106.string().nullable(),
-      "overlays": zod106.int().min(previewFrameJobResultArtifactsItemLayersOverlaysMin).max(previewFrameJobResultArtifactsItemLayersOverlaysMax)
+  "listUsd": zod107.number().optional().describe("List price charged for this delivered capture."),
+  "artifacts": zod107.array(zod107.strictObject({
+    "id": zod107.string(),
+    "beatSec": zod107.number(),
+    "bytes": zod107.int().gt(previewFrameJobResultArtifactsItemBytesExclusiveMin).max(previewFrameJobResultArtifactsItemBytesMax),
+    "contentType": zod107.enum(["image/png", "image/jpeg"]),
+    "layers": zod107.strictObject({
+      "video": zod107.string().nullable(),
+      "overlays": zod107.int().min(previewFrameJobResultArtifactsItemLayersOverlaysMin).max(previewFrameJobResultArtifactsItemLayersOverlaysMax)
     }),
-    "url": zod106.url(),
-    "urlExpiresAt": zod106.string()
+    "url": zod107.url(),
+    "urlExpiresAt": zod107.string()
   }))
 });
 
 // ../sdk/src/generated/zod/models/verifyJobResult.zod.ts
-import * as zod107 from "zod";
-var VerifyJobResult = zod107.strictObject({
-  "perCriterion": zod107.unknown(),
-  "composite": zod107.number(),
-  "critique": zod107.string(),
-  "checkpointId": zod107.string(),
-  "beats": zod107.unknown().optional(),
-  "clientScores": zod107.array(zod107.unknown()).optional(),
-  "listUsd": zod107.number().optional().describe("List price charged for this delivered evaluation.")
+import * as zod108 from "zod";
+var VerifyJobResult = zod108.strictObject({
+  "perCriterion": zod108.unknown(),
+  "composite": zod108.number(),
+  "critique": zod108.string(),
+  "checkpointId": zod108.string(),
+  "beats": zod108.unknown().optional(),
+  "clientScores": zod108.array(zod108.unknown()).optional(),
+  "listUsd": zod108.number().optional().describe("List price charged for this delivered evaluation.")
 });
 
 // ../sdk/src/generated/zod/models/jobResponse.zod.ts
-var JobResponse = zod108.strictObject({
-  "id": zod108.string().describe("Job id \u2014 pass to GET /v1/jobs/{id} / wait_job."),
-  "jobKey": zod108.string().describe("Deterministic identity of the work (idempotency key, e.g. `verify-<sessionId>-<contentHash>` \u2014 the hash covers the composition AND grading inputs). Re-enqueueing the same key returns the same job while it runs."),
-  "kind": zod108.string().describe("Job family, e.g. `verify`."),
-  "status": zod108.enum(["running", "succeeded", "failed", "cancelled"]).describe("Poll until terminal (`succeeded` | `failed` | `cancelled`)."),
-  "progress": zod108.union([zod108.strictObject({
-    "phase": zod108.string(),
-    "percent": zod108.number().optional(),
-    "message": zod108.string().optional()
-  }), zod108.null()]).describe("Executor heartbeat while running; null when none reported."),
-  "result": zod108.union([zod108.union([PreviewFrameJobResult, ComponentPreviewJobResult, VerifyJobResult, ExtractBrandKitResponse]), zod108.null()]).describe("Kind-specific payload when status is `succeeded`; null otherwise."),
-  "error": zod108.union([zod108.strictObject({
-    "code": zod108.string(),
-    "message": zod108.string()
-  }), zod108.null()]).describe("Stable failure code + human message when status is `failed`; null otherwise. `job_timeout` = the executor died mid-run and the stall sweep reaped the job \u2014 re-enqueue to retry."),
-  "createdAt": zod108.string(),
-  "updatedAt": zod108.string(),
-  "completedAt": zod108.string().nullable()
+var JobResponse = zod109.strictObject({
+  "id": zod109.string().describe("Job id \u2014 pass to GET /v1/jobs/{id} / wait_job."),
+  "jobKey": zod109.string().describe("Deterministic identity of the work (idempotency key, e.g. `verify-<sessionId>-<contentHash>` \u2014 the hash covers the composition AND grading inputs). Re-enqueueing the same key returns the same job while it runs."),
+  "kind": zod109.string().describe("Job family, e.g. `verify`."),
+  "status": zod109.enum(["running", "succeeded", "failed", "cancelled"]).describe("Poll until terminal (`succeeded` | `failed` | `cancelled`)."),
+  "progress": zod109.union([zod109.strictObject({
+    "phase": zod109.string(),
+    "percent": zod109.number().optional(),
+    "message": zod109.string().optional()
+  }), zod109.null()]).describe("Executor heartbeat while running; null when none reported."),
+  "result": zod109.union([zod109.union([PreviewFrameJobResult, ComponentPreviewJobResult, VerifyJobResult, ExtractBrandKitResponse]), zod109.null()]).describe("Kind-specific payload when status is `succeeded`; null otherwise."),
+  "error": zod109.union([zod109.strictObject({
+    "code": zod109.string(),
+    "message": zod109.string()
+  }), zod109.null()]).describe("Stable failure code + human message when status is `failed`; null otherwise. `job_timeout` = the executor died mid-run and the stall sweep reaped the job \u2014 re-enqueue to retry."),
+  "createdAt": zod109.string(),
+  "updatedAt": zod109.string(),
+  "completedAt": zod109.string().nullable()
 });
 
 // ../sdk/src/generated/zod/models/librarySearchResponse.zod.ts
-import * as zod110 from "zod";
+import * as zod111 from "zod";
 
 // ../sdk/src/generated/zod/models/librarySearchResult.zod.ts
-import * as zod109 from "zod";
-var LibrarySearchResult = zod109.strictObject({
-  "mediaId": zod109.string().describe("The media item this moment belongs to \u2014 feed it to apply_composition as a clip source, or GET /v1/media/{id}/context for its faces/beat/word grids."),
-  "name": zod109.string().describe("The media item's name, so a result is readable without a second call."),
-  "score": zod109.number().describe("Cosine similarity between the query text and the chunk's frame, in [-1, 1]. Higher is closer. Compare scores WITHIN one response; absolute values are not calibrated across queries."),
-  "startSec": zod109.number().describe("Moment start, SECONDS from the media item's start."),
-  "endSec": zod109.number().describe("Moment end, SECONDS from the media item's start."),
-  "thumbUrl": zod109.string().nullable().describe("Presigned URL for the media item's thumbnail, or null when it has none. This is the ITEM's thumbnail, not a still of this moment \u2014 render a still of the exact range with preview_frame.")
+import * as zod110 from "zod";
+var LibrarySearchResult = zod110.strictObject({
+  "mediaId": zod110.string().describe("The media item this moment belongs to \u2014 feed it to apply_composition as a clip source, or GET /v1/media/{id}/context for its faces/beat/word grids."),
+  "name": zod110.string().describe("The media item's name, so a result is readable without a second call."),
+  "score": zod110.number().describe("Cosine similarity between the query text and the chunk's frame, in [-1, 1]. Higher is closer. Compare scores WITHIN one response; absolute values are not calibrated across queries."),
+  "startSec": zod110.number().describe("Moment start, SECONDS from the media item's start."),
+  "endSec": zod110.number().describe("Moment end, SECONDS from the media item's start."),
+  "thumbUrl": zod110.string().nullable().describe("Presigned URL for the media item's thumbnail, or null when it has none. This is the ITEM's thumbnail, not a still of this moment \u2014 render a still of the exact range with preview_frame.")
 });
 
 // ../sdk/src/generated/zod/models/librarySearchResponse.zod.ts
-var LibrarySearchResponse = zod110.strictObject({
-  "results": zod110.array(LibrarySearchResult).describe("Matching moments, best first. Empty means nothing matched (when `indexing` is false) \u2014 the library was searched and came back empty-handed."),
-  "indexing": zod110.boolean().describe('TRUE when some of the org\'s footage is NOT in the visual index yet \u2014 media that predates it, or is still processing. This is COVERAGE, not emptiness: it can be true ALONGSIDE results, and then it means "these are the best moments among what we have looked at so far", not "these are the best moments". An empty `results` with `indexing: true` means "not looked at yet", NOT "no match" \u2014 re-run the media through processing (reprocess) to index it, then search again. FALSE with empty `results` is a real miss: the library was searched and nothing matched.')
+var LibrarySearchResponse = zod111.strictObject({
+  "results": zod111.array(LibrarySearchResult).describe("Matching moments, best first. Empty means nothing matched (when `indexing` is false) \u2014 the library was searched and came back empty-handed."),
+  "indexing": zod111.boolean().describe('TRUE when some of the org\'s footage is NOT in the visual index yet \u2014 media that predates it, or is still processing. This is COVERAGE, not emptiness: it can be true ALONGSIDE results, and then it means "these are the best moments among what we have looked at so far", not "these are the best moments". An empty `results` with `indexing: true` means "not looked at yet", NOT "no match" \u2014 re-run the media through processing (reprocess) to index it, then search again. FALSE with empty `results` is a real miss: the library was searched and nothing matched.')
 }).describe(`Semantic search over the org's OWN footage. The query is embedded with the same CLIP model that embedded every indexed frame, so a description of what you want to SEE ("wide shot of the speaker at a whiteboard") finds the moment even when nobody says those words.`);
 
 // ../sdk/src/generated/zod/models/listBrandKitsParams.zod.ts
-import * as zod111 from "zod";
+import * as zod112 from "zod";
 var listBrandKitsParamsLimitMax = 100;
-var ListBrandKitsParams = zod111.strictObject({
-  "limit": zod111.int().min(1).max(listBrandKitsParamsLimitMax).optional(),
-  "after": zod111.string().optional()
+var ListBrandKitsParams = zod112.strictObject({
+  "limit": zod112.int().min(1).max(listBrandKitsParamsLimitMax).optional(),
+  "after": zod112.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listBriefsParams.zod.ts
-import * as zod112 from "zod";
+import * as zod113 from "zod";
 var listBriefsParamsLimitMax = 100;
-var ListBriefsParams = zod112.strictObject({
-  "limit": zod112.int().min(1).max(listBriefsParamsLimitMax).optional(),
-  "after": zod112.string().optional(),
-  "projectId": zod112.string().optional(),
-  "kind": zod112.enum(["authored", "clip", "all"]).optional()
+var ListBriefsParams = zod113.strictObject({
+  "limit": zod113.int().min(1).max(listBriefsParamsLimitMax).optional(),
+  "after": zod113.string().optional(),
+  "projectId": zod113.string().optional(),
+  "kind": zod113.enum(["authored", "clip", "all"]).optional()
 });
 
 // ../sdk/src/generated/zod/models/listCatalogParams.zod.ts
-import * as zod113 from "zod";
+import * as zod114 from "zod";
 var listCatalogParamsLimitMax = 100;
-var ListCatalogParams = zod113.strictObject({
-  "category": zod113.enum(["text", "effects", "transitions", "layouts", "backgrounds", "ui-blocks", "scenes"]).optional(),
-  "kind": zod113.enum(["component", "transition", "scene"]).optional(),
-  "tier": zod113.enum(["recommended", "standard", "niche"]).optional(),
-  "useCase": zod113.enum(["intro", "outro", "full-scene", "title-over-footage", "transition", "background", "grade", "emphasis", "explainer", "social-cut"]).optional(),
-  "mood": zod113.string().optional(),
-  "q": zod113.string().optional(),
-  "intent": zod113.string().optional(),
-  "limit": zod113.int().min(1).max(listCatalogParamsLimitMax).optional(),
-  "after": zod113.string().optional()
+var ListCatalogParams = zod114.strictObject({
+  "category": zod114.enum(["text", "effects", "transitions", "layouts", "backgrounds", "ui-blocks", "scenes"]).optional(),
+  "kind": zod114.enum(["component", "transition", "scene"]).optional(),
+  "tier": zod114.enum(["recommended", "standard", "niche"]).optional(),
+  "useCase": zod114.enum(["intro", "outro", "full-scene", "title-over-footage", "transition", "background", "grade", "emphasis", "explainer", "social-cut"]).optional(),
+  "mood": zod114.string().optional(),
+  "q": zod114.string().optional(),
+  "intent": zod114.string().optional(),
+  "limit": zod114.int().min(1).max(listCatalogParamsLimitMax).optional(),
+  "after": zod114.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listCheckpointsParams.zod.ts
-import * as zod114 from "zod";
+import * as zod115 from "zod";
 var listCheckpointsParamsLimitMax = 100;
-var ListCheckpointsParams = zod114.strictObject({
-  "limit": zod114.int().min(1).max(listCheckpointsParamsLimitMax).optional(),
-  "after": zod114.string().optional(),
-  "composeJobId": zod114.string().optional(),
-  "projectId": zod114.string().optional()
+var ListCheckpointsParams = zod115.strictObject({
+  "limit": zod115.int().min(1).max(listCheckpointsParamsLimitMax).optional(),
+  "after": zod115.string().optional(),
+  "composeJobId": zod115.string().optional(),
+  "projectId": zod115.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listMediaFactsParams.zod.ts
-import * as zod115 from "zod";
-var ListMediaFactsParams = zod115.strictObject({
-  "kind": zod115.enum(["subjectTrack", "matte"]).optional(),
-  "startSec": zod115.number().optional(),
-  "endSec": zod115.number().optional()
+import * as zod116 from "zod";
+var ListMediaFactsParams = zod116.strictObject({
+  "kind": zod116.enum(["subjectTrack", "matte"]).optional(),
+  "startSec": zod116.number().optional(),
+  "endSec": zod116.number().optional()
 });
 
 // ../sdk/src/generated/zod/models/listMediaParams.zod.ts
-import * as zod116 from "zod";
+import * as zod117 from "zod";
 var listMediaParamsLimitMax = 100;
-var ListMediaParams = zod116.strictObject({
-  "limit": zod116.int().min(1).max(listMediaParamsLimitMax).optional(),
-  "after": zod116.string().optional(),
-  "kind": zod116.enum(["video", "audio", "image", "gif", "asset", "source", "stock"]).optional(),
-  "source": zod116.enum(["upload", "generated", "import-url", "stock"]).optional(),
-  "tag": zod116.string().optional()
+var ListMediaParams = zod117.strictObject({
+  "limit": zod117.int().min(1).max(listMediaParamsLimitMax).optional(),
+  "after": zod117.string().optional(),
+  "kind": zod117.enum(["video", "audio", "image", "gif", "asset", "source", "stock"]).optional(),
+  "source": zod117.enum(["upload", "generated", "import-url", "stock"]).optional(),
+  "tag": zod117.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listMediaSuggestionsParams.zod.ts
-import * as zod117 from "zod";
+import * as zod118 from "zod";
 var listMediaSuggestionsParamsLimitMax = 100;
-var ListMediaSuggestionsParams = zod117.strictObject({
-  "limit": zod117.int().min(1).max(listMediaSuggestionsParamsLimitMax).optional(),
-  "after": zod117.string().optional(),
-  "platform": zod117.string().optional(),
-  "format": zod117.string().optional(),
-  "topic": zod117.string().optional()
+var ListMediaSuggestionsParams = zod118.strictObject({
+  "limit": zod118.int().min(1).max(listMediaSuggestionsParamsLimitMax).optional(),
+  "after": zod118.string().optional(),
+  "platform": zod118.string().optional(),
+  "format": zod118.string().optional(),
+  "topic": zod118.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listProjectRendersParams.zod.ts
-import * as zod118 from "zod";
+import * as zod119 from "zod";
 var listProjectRendersParamsLimitMax = 100;
-var ListProjectRendersParams = zod118.strictObject({
-  "limit": zod118.int().min(1).max(listProjectRendersParamsLimitMax).optional(),
-  "after": zod118.string().optional(),
-  "status": zod118.string().optional()
+var ListProjectRendersParams = zod119.strictObject({
+  "limit": zod119.int().min(1).max(listProjectRendersParamsLimitMax).optional(),
+  "after": zod119.string().optional(),
+  "status": zod119.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listProjectsParams.zod.ts
-import * as zod119 from "zod";
+import * as zod120 from "zod";
 var listProjectsParamsLimitMax = 100;
-var ListProjectsParams = zod119.strictObject({
-  "limit": zod119.int().min(1).max(listProjectsParamsLimitMax).optional(),
-  "after": zod119.string().optional()
+var ListProjectsParams = zod120.strictObject({
+  "limit": zod120.int().min(1).max(listProjectsParamsLimitMax).optional(),
+  "after": zod120.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listSelectorCandidatesParams.zod.ts
-import * as zod120 from "zod";
-var ListSelectorCandidatesParams = zod120.strictObject({
-  "groupId": zod120.string().min(1)
+import * as zod121 from "zod";
+var ListSelectorCandidatesParams = zod121.strictObject({
+  "groupId": zod121.string().min(1)
 });
 
 // ../sdk/src/generated/zod/models/listSessionsParams.zod.ts
-import * as zod121 from "zod";
+import * as zod122 from "zod";
 var listSessionsParamsLimitMax = 100;
-var ListSessionsParams = zod121.strictObject({
-  "limit": zod121.int().min(1).max(listSessionsParamsLimitMax).optional(),
-  "after": zod121.string().optional()
+var ListSessionsParams = zod122.strictObject({
+  "limit": zod122.int().min(1).max(listSessionsParamsLimitMax).optional(),
+  "after": zod122.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/listWebhooksParams.zod.ts
-import * as zod122 from "zod";
+import * as zod123 from "zod";
 var listWebhooksParamsLimitMax = 100;
-var ListWebhooksParams = zod122.strictObject({
-  "limit": zod122.int().min(1).max(listWebhooksParamsLimitMax).optional(),
-  "after": zod122.string().optional()
+var ListWebhooksParams = zod123.strictObject({
+  "limit": zod123.int().min(1).max(listWebhooksParamsLimitMax).optional(),
+  "after": zod123.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/matteBakeRequest.zod.ts
-import * as zod123 from "zod";
+import * as zod124 from "zod";
 var matteBakeRequestStartSecMin = 0;
 var matteBakeRequestEndSecExclusiveMin = 0;
-var MatteBakeRequest = zod123.strictObject({
-  "startSec": zod123.number().min(matteBakeRequestStartSecMin).describe("Source-in of the window to matte, in seconds into the underlying source."),
-  "endSec": zod123.number().gt(matteBakeRequestEndSecExclusiveMin).describe("Source-out of the window to matte, in seconds into the underlying source.")
+var MatteBakeRequest = zod124.strictObject({
+  "startSec": zod124.number().min(matteBakeRequestStartSecMin).describe("Source-in of the window to matte, in seconds into the underlying source."),
+  "endSec": zod124.number().gt(matteBakeRequestEndSecExclusiveMin).describe("Source-out of the window to matte, in seconds into the underlying source.")
 }).describe("POST /media/:id/matte body. The window is REQUIRED and is the clip's SOURCE trim, not timeline time: a matte's cost scales with its duration, so there is no whole-source default to fall back on.");
 
 // ../sdk/src/generated/zod/models/matteBakeTriggerResponse.zod.ts
-import * as zod124 from "zod";
-var MatteBakeTriggerResponse = zod124.strictObject({
-  "factId": zod124.string(),
-  "status": zod124.enum(["pending", "ready", "failed"]),
-  "quotedUsd": zod124.number().describe("The server's price for this matte, in USD, quoted from the window duration."),
-  "alreadyExisted": zod124.boolean().describe("True when a matte for this exact window was already pending or ready. Nothing was dispatched and nothing will be charged.")
+import * as zod125 from "zod";
+var MatteBakeTriggerResponse = zod125.strictObject({
+  "factId": zod125.string(),
+  "status": zod125.enum(["pending", "ready", "failed"]),
+  "quotedUsd": zod125.number().describe("The server's price for this matte, in USD, quoted from the window duration."),
+  "alreadyExisted": zod125.boolean().describe("True when a matte for this exact window was already pending or ready. Nothing was dispatched and nothing will be charged.")
 }).describe("POST /media/:id/matte response \u2014 the claimed matte fact.");
 
 // ../sdk/src/generated/zod/models/mediaContextResponse.zod.ts
-import * as zod126 from "zod";
+import * as zod127 from "zod";
 
 // ../sdk/src/generated/zod/models/transcriptResponse.zod.ts
-import * as zod125 from "zod";
-var TranscriptResponse = zod125.strictObject({
-  "mediaItemId": zod125.string(),
-  "language": zod125.string().nullable(),
-  "fullText": zod125.string(),
-  "utterances": zod125.array(zod125.record(zod125.string(), zod125.unknown())),
-  "data": zod125.array(zod125.record(zod125.string(), zod125.unknown())).optional(),
+import * as zod126 from "zod";
+var TranscriptResponse = zod126.strictObject({
+  "mediaItemId": zod126.string(),
+  "language": zod126.string().nullable(),
+  "fullText": zod126.string(),
+  "utterances": zod126.array(zod126.record(zod126.string(), zod126.unknown())),
+  "data": zod126.array(zod126.record(zod126.string(), zod126.unknown())).optional(),
   "pagination": PaginationMeta.optional()
 }).describe("Transcript response.");
 
 // ../sdk/src/generated/zod/models/mediaContextResponse.zod.ts
-var MediaContextResponse = zod126.strictObject({
-  "mediaId": zod126.string(),
-  "durationSec": zod126.number().nullable(),
-  "width": zod126.number().nullable(),
-  "height": zod126.number().nullable(),
-  "thumbnail": zod126.union([zod126.strictObject({
-    "url": zod126.string()
-  }), zod126.null()]).describe("Presigned processing thumbnail (~1 week) \u2014 the footage at a glance. For stills at chosen timestamps, use preview_frame with a one-clip composition over this media."),
-  "faces": zod126.strictObject({
-    "status": zod126.enum(["ready", "not_detected"]),
-    "windows": zod126.array(ContextSubjectWindow)
+var MediaContextResponse = zod127.strictObject({
+  "mediaId": zod127.string(),
+  "durationSec": zod127.number().nullable(),
+  "width": zod127.number().nullable(),
+  "height": zod127.number().nullable(),
+  "thumbnail": zod127.union([zod127.strictObject({
+    "url": zod127.string()
+  }), zod127.null()]).describe("Presigned processing thumbnail (~1 week) \u2014 the footage at a glance. For stills at chosen timestamps, use preview_frame with a one-clip composition over this media."),
+  "faces": zod127.strictObject({
+    "status": zod127.enum(["ready", "not_detected"]),
+    "windows": zod127.array(ContextSubjectWindow)
   }),
-  "transcript": zod126.strictObject({
-    "status": zod126.enum(["ready", "not_transcribed", "unavailable"]),
-    "data": zod126.union([TranscriptResponse, zod126.null()])
+  "transcript": zod127.strictObject({
+    "status": zod127.enum(["ready", "not_transcribed", "unavailable"]),
+    "data": zod127.union([TranscriptResponse, zod127.null()])
   }),
-  "beatGrid": zod126.union([zod126.strictObject({
-    "bpm": zod126.number(),
-    "beatTimesMs": zod126.array(zod126.number()).describe("Beat onset times in MILLISECONDS \u2014 divide by 1000 for timeline startTime (composition timeline fields are seconds)."),
-    "confidence": zod126.number().describe("Rhythmic-periodicity strength (0\u20131). Trust the grid for cutting when high; a beatless bed reports low."),
-    "method": zod126.enum(["requested-anchored", "detected"]).describe("`requested-anchored` = phase-locked to a requested BPM (a generated bed whose prompt named a tempo); `detected` = full beat tracking (import/upload).")
-  }), zod126.null()]).describe("The MUSIC-role rhythm grid (audio-substrate MVP). Present only for a music bed that carries a computed beat grid; null otherwise. For a music-driven film, cut on these beats (transition midpoints on beats, risers resolving on downbeats)."),
-  "wordGrid": zod126.union([zod126.strictObject({
-    "wordTimesMs": zod126.array(zod126.number()).describe("Word onset times in MILLISECONDS, in order \u2014 divide by 1000 for timeline startTime (composition timeline fields are seconds).")
-  }), zod126.null()]).describe("The VO-role rhythm grid: word onsets surfaced from the transcript (pure exposure). Present only when a transcript exists; null otherwise. For a VO-driven (narration) film, cut every beat boundary to the voice \u2014 the film-spine rule."),
-  "audioRole": zod126.union([zod126.enum(["vo", "music", "sfx", "ambience"]), zod126.null()]).describe("DECLARED audio role of this asset (audio-substrate P0): 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks). Author the clip source's `audioRole` from this. Null for footage/images or an undeclared audio asset."),
-  "envelope": zod126.union([zod126.strictObject({
-    "envelopeClass": zod126.enum(["transient", "sweep", "ambient"]).describe("Coarse temporal shape: 'transient' (a sharp one-shot), 'sweep' (a bounded rise/fall over ~0.5\u20132s), 'ambient' (an unbounded bed)."),
-    "attackMs": zod126.number().optional(),
-    "spectralCentroidHz": zod126.number().optional(),
-    "meanVolumeDb": zod126.number().optional(),
-    "maxVolumeDb": zod126.number().optional()
-  }), zod126.null()]).describe("Envelope evidence (audio-substrate P0). `envelopeClass` is always present when an envelope exists (the SFX pack carries it); the numeric probe stats are present only when an audio probe has run. Null when no envelope is stored."),
-  "facts": zod126.array(MediaFact).describe("Derived facts about this source (subject tracks, mattes): what has been computed, its status, and what it was billed. Same shape as GET /media/{id}/facts."),
-  "offers": zod126.array(MediaFactOffer).describe("Enhancements this source does not have yet, with a server quote. Same shape as GET /media/{id}/facts. Mattes are quoted per-window via POST /media/{id}/matte, never here.")
+  "beatGrid": zod127.union([zod127.strictObject({
+    "bpm": zod127.number(),
+    "beatTimesMs": zod127.array(zod127.number()).describe("Beat onset times in MILLISECONDS \u2014 divide by 1000 for timeline startTime (composition timeline fields are seconds)."),
+    "confidence": zod127.number().describe("Rhythmic-periodicity strength (0\u20131). Trust the grid for cutting when high; a beatless bed reports low."),
+    "method": zod127.enum(["requested-anchored", "detected"]).describe("`requested-anchored` = phase-locked to a requested BPM (a generated bed whose prompt named a tempo); `detected` = full beat tracking (import/upload).")
+  }), zod127.null()]).describe("The MUSIC-role rhythm grid (audio-substrate MVP). Present only for a music bed that carries a computed beat grid; null otherwise. For a music-driven film, cut on these beats (transition midpoints on beats, risers resolving on downbeats)."),
+  "wordGrid": zod127.union([zod127.strictObject({
+    "wordTimesMs": zod127.array(zod127.number()).describe("Word onset times in MILLISECONDS, in order \u2014 divide by 1000 for timeline startTime (composition timeline fields are seconds).")
+  }), zod127.null()]).describe("The VO-role rhythm grid: word onsets surfaced from the transcript (pure exposure). Present only when a transcript exists; null otherwise. For a VO-driven (narration) film, cut every beat boundary to the voice \u2014 the film-spine rule."),
+  "audioRole": zod127.union([zod127.enum(["vo", "music", "sfx", "ambience"]), zod127.null()]).describe("DECLARED audio role of this asset (audio-substrate P0): 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks). Author the clip source's `audioRole` from this. Null for footage/images or an undeclared audio asset."),
+  "envelope": zod127.union([zod127.strictObject({
+    "envelopeClass": zod127.enum(["transient", "sweep", "ambient"]).describe("Coarse temporal shape: 'transient' (a sharp one-shot), 'sweep' (a bounded rise/fall over ~0.5\u20132s), 'ambient' (an unbounded bed)."),
+    "attackMs": zod127.number().optional(),
+    "spectralCentroidHz": zod127.number().optional(),
+    "meanVolumeDb": zod127.number().optional(),
+    "maxVolumeDb": zod127.number().optional()
+  }), zod127.null()]).describe("Envelope evidence (audio-substrate P0). `envelopeClass` is always present when an envelope exists (the SFX pack carries it); the numeric probe stats are present only when an audio probe has run. Null when no envelope is stored."),
+  "facts": zod127.array(MediaFact).describe("Derived facts about this source (subject tracks, mattes): what has been computed, its status, and what it was billed. Same shape as GET /media/{id}/facts."),
+  "offers": zod127.array(MediaFactOffer).describe("Enhancements this source does not have yet, with a server quote. Same shape as GET /media/{id}/facts. Mattes are quoted per-window via POST /media/{id}/matte, never here.")
 }).describe("Read-only authoring context for a source media item: detected face roster + transcript + the temporal grids (beat / word) an agent cuts to, the DECLARED audioRole + envelope of an audio asset, and the paid-enhancement block (facts already computed + offers for what is missing).");
 
 // ../sdk/src/generated/zod/models/mediaDirectUploadResponse.zod.ts
-import * as zod127 from "zod";
-var MediaDirectUploadResponse = zod127.strictObject({
-  "id": zod127.string(),
-  "uploadUrl": zod127.url(),
-  "expiresAt": zod127.string()
+import * as zod128 from "zod";
+var MediaDirectUploadResponse = zod128.strictObject({
+  "id": zod128.string(),
+  "uploadUrl": zod128.url(),
+  "expiresAt": zod128.string()
 }).describe("POST /media response: reserved media id + a presigned PUT URL. PUT the raw bytes to uploadUrl (\u2264 ~5 GiB), then POST /media/:id/finalize.");
 
 // ../sdk/src/generated/zod/models/mediaFactPurchaseRequest.zod.ts
-import * as zod128 from "zod";
+import * as zod129 from "zod";
 var mediaFactPurchaseRequestIntentStartSecMin = 0;
 var mediaFactPurchaseRequestIntentEndSecExclusiveMin = 0;
-var MediaFactPurchaseRequest = zod128.strictObject({
-  "kind": zod128.enum(["subjectTrack", "matte"]).describe("Which enhancement to buy. `transcript` is NOT purchasable here \u2014 it is delivered by the transcription pipeline."),
-  "intent": zod128.strictObject({
-    "startSec": zod128.number().min(mediaFactPurchaseRequestIntentStartSecMin),
-    "endSec": zod128.number().gt(mediaFactPurchaseRequestIntentEndSecExclusiveMin)
+var MediaFactPurchaseRequest = zod129.strictObject({
+  "kind": zod129.enum(["subjectTrack", "matte"]).describe("Which enhancement to buy. `transcript` is NOT purchasable here \u2014 it is delivered by the transcription pipeline."),
+  "intent": zod129.strictObject({
+    "startSec": zod129.number().min(mediaFactPurchaseRequestIntentStartSecMin),
+    "endSec": zod129.number().gt(mediaFactPurchaseRequestIntentEndSecExclusiveMin)
   }).optional().describe("The SOURCE window. REQUIRED for `matte` (its cost scales with duration). OPTIONAL for `subjectTrack`: give a clip's source window to buy the track the render looks up for THAT clip, and pay only for its duration; omit it to detect the whole source.")
 }).describe("POST /media/:id/facts body.");
 
 // ../sdk/src/generated/zod/models/mediaFactPurchaseResponse.zod.ts
-import * as zod129 from "zod";
-var MediaFactPurchaseResponse = zod129.strictObject({
-  "factId": zod129.string(),
-  "status": zod129.enum(["pending", "ready", "failed"]),
-  "quotedUsd": zod129.number(),
-  "alreadyExisted": zod129.boolean().describe("True when this exact fact was already pending or ready. Nothing was dispatched and nothing will be charged.")
+import * as zod130 from "zod";
+var MediaFactPurchaseResponse = zod130.strictObject({
+  "factId": zod130.string(),
+  "status": zod130.enum(["pending", "ready", "failed"]),
+  "quotedUsd": zod130.number(),
+  "alreadyExisted": zod130.boolean().describe("True when this exact fact was already pending or ready. Nothing was dispatched and nothing will be charged.")
 }).describe("POST /media/:id/facts response.");
 
 // ../sdk/src/generated/zod/models/mediaFactsResponse.zod.ts
-import * as zod130 from "zod";
-var MediaFactsResponse = zod130.strictObject({
-  "facts": zod130.array(MediaFact),
-  "offers": zod130.array(MediaFactOffer).describe("What is NOT yet present and could be bought. A `matte` offer appears ONLY when the request carried `startSec`+`endSec` (the clip's SOURCE window) \u2014 a matte's price is a function of its duration, so there is no honest whole-source matte quote. `transcript` is never offered: it is produced by the ingest pipeline, not bought here."),
+import * as zod131 from "zod";
+var MediaFactsResponse = zod131.strictObject({
+  "facts": zod131.array(MediaFact),
+  "offers": zod131.array(MediaFactOffer).describe("What is NOT yet present and could be bought. A `matte` offer appears ONLY when the request carried `startSec`+`endSec` (the clip's SOURCE window) \u2014 a matte's price is a function of its duration, so there is no honest whole-source matte quote. `transcript` is never offered: it is produced by the ingest pipeline, not bought here."),
   "exact": ExactMediaFactResolution.optional()
 }).describe("Facts and offers for a media item, plus an exact-window resolution when requested.");
 
 // ../sdk/src/generated/zod/models/mediaFinalizeRequest.zod.ts
-import * as zod131 from "zod";
-var MediaFinalizeRequest = zod131.strictObject({
-  "audioRole": zod131.enum(["vo", "music", "sfx", "ambience"]).optional().describe("Declared audio role: 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks).")
+import * as zod132 from "zod";
+var MediaFinalizeRequest = zod132.strictObject({
+  "audioRole": zod132.enum(["vo", "music", "sfx", "ambience"]).optional().describe("Declared audio role: 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks).")
 }).describe("POST /media/:id/finalize body \u2014 optional declared audioRole.");
 
 // ../sdk/src/generated/zod/models/mediaFinalizeResponse.zod.ts
-import * as zod132 from "zod";
-var MediaFinalizeResponse = zod132.strictObject({
-  "id": zod132.string(),
-  "status": zod132.enum(["processing", "complete"]),
-  "processingPhase": zod132.string()
+import * as zod133 from "zod";
+var MediaFinalizeResponse = zod133.strictObject({
+  "id": zod133.string(),
+  "status": zod133.enum(["processing", "complete"]),
+  "processingPhase": zod133.string()
 }).describe("POST /media/:id/finalize response: ingest triggered (audio/video \u2192 processing) or the item is immediately ready (image/asset \u2192 complete).");
 
 // ../sdk/src/generated/zod/models/mediaGenerateRequest.zod.ts
-import * as zod133 from "zod";
+import * as zod134 from "zod";
 var mediaGenerateRequestPromptMax = 1e4;
-var MediaGenerateRequest = zod133.strictObject({
-  "generator": zod133.enum(["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]),
-  "prompt": zod133.string().min(1).max(mediaGenerateRequestPromptMax),
-  "style": zod133.record(zod133.string(), zod133.unknown()).optional().describe("Free-form generation parameters, read per generator. All generators honor `aspect` (string) + `durationSec` (number) where applicable. text-to-speech honors `voice` (string; default voice when omitted), `speed` (number 0.7-1.2), `stability` (number 0-1), and `styleExaggeration` (number 0-1 \u2192 the endpoint's style exaggeration). Provider and model selection are server-owned and cannot be overridden."),
-  "refs": zod133.strictObject({
-    "firstFrameMediaId": zod133.string().optional(),
-    "lastFrameMediaId": zod133.string().optional(),
-    "imageMediaIds": zod133.array(zod133.string()).optional()
+var MediaGenerateRequest = zod134.strictObject({
+  "generator": zod134.enum(["text-to-video", "text-to-image", "image-to-video", "text-to-music", "text-to-speech", "text-to-sfx", "auto"]),
+  "prompt": zod134.string().min(1).max(mediaGenerateRequestPromptMax),
+  "style": zod134.record(zod134.string(), zod134.unknown()).optional().describe("Free-form generation parameters, read per generator. All generators honor `aspect` (string) + `durationSec` (number) where applicable. text-to-speech honors `voice` (string; default voice when omitted), `speed` (number 0.7-1.2), `stability` (number 0-1), and `styleExaggeration` (number 0-1 \u2192 the endpoint's style exaggeration). Provider and model selection are server-owned and cannot be overridden."),
+  "refs": zod134.strictObject({
+    "firstFrameMediaId": zod134.string().optional(),
+    "lastFrameMediaId": zod134.string().optional(),
+    "imageMediaIds": zod134.array(zod134.string()).optional()
   }).optional()
 }).describe("POST /media/generate body.");
 
 // ../sdk/src/generated/zod/models/mediaGenerateResponse.zod.ts
-import * as zod134 from "zod";
-var MediaGenerateResponse = zod134.strictObject({
-  "id": zod134.string(),
-  "status": zod134.literal("generating"),
-  "estimateUsd": zod134.number().optional()
+import * as zod135 from "zod";
+var MediaGenerateResponse = zod135.strictObject({
+  "id": zod135.string(),
+  "status": zod135.literal("generating"),
+  "estimateUsd": zod135.number().optional()
 }).describe("POST /media/generate response.");
 
 // ../sdk/src/generated/zod/models/mediaImportRequest.zod.ts
-import * as zod135 from "zod";
+import * as zod136 from "zod";
 var mediaImportRequestUrlMax = 2048;
 var mediaImportRequestFilenameMax = 500;
 var mediaImportRequestSizeExclusiveMin = 0;
 var mediaImportRequestSizeMax = 10737418240;
-var MediaImportRequest = zod135.strictObject({
-  "url": zod135.url().max(mediaImportRequestUrlMax),
-  "filename": zod135.string().min(1).max(mediaImportRequestFilenameMax),
-  "contentType": zod135.enum(["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"]),
-  "size": zod135.int().gt(mediaImportRequestSizeExclusiveMin).max(mediaImportRequestSizeMax).optional(),
-  "audioRole": zod135.enum(["vo", "music", "sfx", "ambience"]).optional().describe("Declared audio role: 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks).")
+var MediaImportRequest = zod136.strictObject({
+  "url": zod136.url().max(mediaImportRequestUrlMax),
+  "filename": zod136.string().min(1).max(mediaImportRequestFilenameMax),
+  "contentType": zod136.enum(["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"]),
+  "size": zod136.int().gt(mediaImportRequestSizeExclusiveMin).max(mediaImportRequestSizeMax).optional(),
+  "audioRole": zod136.enum(["vo", "music", "sfx", "ambience"]).optional().describe("Declared audio role: 'vo' (narration), 'music' (bed that ducks under speech), 'sfx' (one-shot hit), 'ambience' (a bed that HOLDS under VO \u2014 never ducks).")
 }).describe("POST /media/import body.");
 
 // ../sdk/src/generated/zod/models/mediaImportResponse.zod.ts
-import * as zod136 from "zod";
-var MediaImportResponse = zod136.strictObject({
-  "id": zod136.string(),
-  "status": zod136.literal("importing")
+import * as zod137 from "zod";
+var MediaImportResponse = zod137.strictObject({
+  "id": zod137.string(),
+  "status": zod137.literal("importing")
 }).describe("POST /media/import response.");
 
 // ../sdk/src/generated/zod/models/mediaListResponse.zod.ts
-import * as zod139 from "zod";
+import * as zod140 from "zod";
 
 // ../sdk/src/generated/zod/models/mediaResponse.zod.ts
-import * as zod138 from "zod";
+import * as zod139 from "zod";
 
 // ../sdk/src/generated/zod/models/mediaProcessingStatus.zod.ts
-import * as zod137 from "zod";
-var MediaProcessingStatus = zod137.strictObject({
-  "phase": zod137.enum(["idle", "pending_import", "pending_upload", "uploading", "extracting", "loading_model", "transcribing", "proxy", "embedding", "analyzing", "indexing", "generating", "rendering", "processing", "complete", "error", "cancelled"]),
-  "percent": zod137.number().nullish(),
-  "message": zod137.string().nullish(),
-  "error": zod137.string().nullish()
+import * as zod138 from "zod";
+var MediaProcessingStatus = zod138.strictObject({
+  "phase": zod138.enum(["idle", "pending_import", "pending_upload", "uploading", "extracting", "loading_model", "transcribing", "proxy", "embedding", "analyzing", "indexing", "generating", "rendering", "processing", "complete", "error", "cancelled"]),
+  "percent": zod138.number().nullish(),
+  "message": zod138.string().nullish(),
+  "error": zod138.string().nullish()
 }).describe("Processing status stored on mediaItems rows.");
 
 // ../sdk/src/generated/zod/models/mediaResponse.zod.ts
-var MediaResponse = zod138.strictObject({
-  "id": zod138.string(),
-  "status": zod138.string(),
-  "source": zod138.enum(["upload", "generated", "stock"]),
-  "name": zod138.string(),
-  "mimeType": zod138.string(),
-  "fileSize": zod138.number(),
-  "duration": zod138.number().nullable(),
-  "width": zod138.number().nullable(),
-  "height": zod138.number().nullable(),
-  "frameRate": zod138.number().nullable(),
-  "progress": zod138.union([zod138.strictObject({
-    "phase": zod138.string(),
-    "percent": zod138.number().nullable()
-  }), zod138.null()]),
-  "analysis": zod138.union([zod138.record(zod138.string(), zod138.unknown()), zod138.null()]),
-  "listUsd": zod138.number().optional().describe("A2 money stamp \u2014 GENERATED media only: the generate meter's LIST price (USD) at the success terminal. A plan allowance may zero the invoice line. Absent for uploads/imports, failures, x402 (on-chain receipts)."),
-  "thumbnailUrl": zod138.string().nullable().describe("Presigned GET URL for the item's thumbnail (an uploaded image is its own thumbnail), valid ~7 days \u2014 fetch it directly, no auth header. null when no thumbnail exists yet (still processing, stock imports, audio)."),
-  "kind": zod138.string().nullable(),
-  "tags": zod138.union([zod138.array(zod138.string()), zod138.null()]),
-  "attribution": zod138.union([zod138.strictObject({
-    "provider": zod138.enum(["pexels", "pixabay", "freesound", "klipy"]),
-    "externalId": zod138.string().nullable(),
-    "assetUrl": zod138.string().nullable(),
-    "license": zod138.string().nullable()
-  }), zod138.null()]),
-  "processingStatus": zod138.union([MediaProcessingStatus, zod138.null()]),
-  "createdAt": zod138.string(),
-  "updatedAt": zod138.string()
+var MediaResponse = zod139.strictObject({
+  "id": zod139.string(),
+  "status": zod139.string(),
+  "source": zod139.enum(["upload", "generated", "stock"]),
+  "name": zod139.string(),
+  "mimeType": zod139.string(),
+  "fileSize": zod139.number(),
+  "duration": zod139.number().nullable(),
+  "width": zod139.number().nullable(),
+  "height": zod139.number().nullable(),
+  "frameRate": zod139.number().nullable(),
+  "progress": zod139.union([zod139.strictObject({
+    "phase": zod139.string(),
+    "percent": zod139.number().nullable()
+  }), zod139.null()]),
+  "analysis": zod139.union([zod139.record(zod139.string(), zod139.unknown()), zod139.null()]),
+  "listUsd": zod139.number().optional().describe("A2 money stamp \u2014 GENERATED media only: the generate meter's LIST price (USD) at the success terminal. A plan allowance may zero the invoice line. Absent for uploads/imports, failures, x402 (on-chain receipts)."),
+  "thumbnailUrl": zod139.string().nullable().describe("Presigned GET URL for the item's thumbnail (an uploaded image is its own thumbnail), valid ~7 days \u2014 fetch it directly, no auth header. null when no thumbnail exists yet (still processing, stock imports, audio)."),
+  "kind": zod139.string().nullable(),
+  "tags": zod139.union([zod139.array(zod139.string()), zod139.null()]),
+  "attribution": zod139.union([zod139.strictObject({
+    "provider": zod139.enum(["pexels", "pixabay", "freesound", "klipy"]),
+    "externalId": zod139.string().nullable(),
+    "assetUrl": zod139.string().nullable(),
+    "license": zod139.string().nullable()
+  }), zod139.null()]),
+  "processingStatus": zod139.union([MediaProcessingStatus, zod139.null()]),
+  "createdAt": zod139.string(),
+  "updatedAt": zod139.string()
 }).describe("Media item response per \xA7Media.");
 
 // ../sdk/src/generated/zod/models/mediaListResponse.zod.ts
-var MediaListResponse = zod139.strictObject({
-  "data": zod139.array(MediaResponse),
+var MediaListResponse = zod140.strictObject({
+  "data": zod140.array(MediaResponse),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/mediaUploadRequest.zod.ts
-import * as zod140 from "zod";
+import * as zod141 from "zod";
 var mediaUploadRequestFilenameMax = 500;
 var mediaUploadRequestSizeExclusiveMin = 0;
 var mediaUploadRequestSizeMax = 10737418240;
-var MediaUploadRequest = zod140.strictObject({
-  "filename": zod140.string().min(1).max(mediaUploadRequestFilenameMax),
-  "contentType": zod140.enum(["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"]),
-  "size": zod140.int().gt(mediaUploadRequestSizeExclusiveMin).max(mediaUploadRequestSizeMax),
-  "projectId": zod140.string().min(1).optional()
+var MediaUploadRequest = zod141.strictObject({
+  "filename": zod141.string().min(1).max(mediaUploadRequestFilenameMax),
+  "contentType": zod141.enum(["video/mp4", "video/quicktime", "video/x-matroska", "video/webm", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/mp4", "audio/aac", "image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml", "application/json", "font/ttf", "font/otf", "font/woff", "font/woff2"]),
+  "size": zod141.int().gt(mediaUploadRequestSizeExclusiveMin).max(mediaUploadRequestSizeMax),
+  "projectId": zod141.string().min(1).optional()
 }).describe("POST /media upload initiation body.");
 
 // ../sdk/src/generated/zod/models/muxJobResponse.zod.ts
-import * as zod141 from "zod";
-var MuxJobResponse = zod141.strictObject({
-  "jobId": zod141.string(),
-  "status": zod141.string(),
-  "muxedItems": zod141.union([zod141.record(zod141.string(), zod141.string()), zod141.null()]).optional(),
-  "error": zod141.string().nullish(),
-  "startedAt": zod141.string().nullish(),
-  "completedAt": zod141.string().nullish()
+import * as zod142 from "zod";
+var MuxJobResponse = zod142.strictObject({
+  "jobId": zod142.string(),
+  "status": zod142.string(),
+  "muxedItems": zod142.union([zod142.record(zod142.string(), zod142.string()), zod142.null()]).optional(),
+  "error": zod142.string().nullish(),
+  "startedAt": zod142.string().nullish(),
+  "completedAt": zod142.string().nullish()
 }).describe("Mux job response.");
 
 // ../sdk/src/generated/zod/models/openComposeSession200.zod.ts
-import * as zod142 from "zod";
-var OpenComposeSession200 = zod142.strictObject({
-  "sessionId": zod142.string()
+import * as zod143 from "zod";
+var OpenComposeSession200 = zod143.strictObject({
+  "sessionId": zod143.string()
 });
 
 // ../sdk/src/generated/zod/models/openComposeSessionBody.zod.ts
-import * as zod143 from "zod";
+import * as zod144 from "zod";
 var openComposeSessionBodyLeaseJobIdMax = 64;
-var OpenComposeSessionBody = zod143.strictObject({
-  "seedComposition": zod143.unknown().optional(),
-  "leaseJobId": zod143.string().min(1).max(openComposeSessionBodyLeaseJobIdMax).optional()
+var OpenComposeSessionBody = zod144.strictObject({
+  "seedComposition": zod144.unknown().optional(),
+  "leaseJobId": zod144.string().min(1).max(openComposeSessionBodyLeaseJobIdMax).optional()
 });
 
 // ../sdk/src/generated/zod/models/previewClipRequest.zod.ts
-import * as zod144 from "zod";
+import * as zod145 from "zod";
 var previewClipRequestFromSecMin = 0;
 var previewClipRequestToSecExclusiveMin = 0;
-var PreviewClipRequest = zod144.strictObject({
-  "fromSec": zod144.number().min(previewClipRequestFromSecMin).describe("Window start, seconds into the composition."),
-  "toSec": zod144.number().gt(previewClipRequestToSecExclusiveMin).describe("Window end (exclusive), seconds."),
-  "compositionId": zod144.string().min(1).optional().describe("Target a specific composition; defaults to the project's active composition.")
+var PreviewClipRequest = zod145.strictObject({
+  "fromSec": zod145.number().min(previewClipRequestFromSecMin).describe("Window start, seconds into the composition."),
+  "toSec": zod145.number().gt(previewClipRequestToSecExclusiveMin).describe("Window end (exclusive), seconds."),
+  "compositionId": zod145.string().min(1).optional().describe("Target a specific composition; defaults to the project's active composition.")
 }).describe("POST /projects/:id/preview-clip body.");
 
 // ../sdk/src/generated/zod/models/previewComponentBody.zod.ts
-import * as zod145 from "zod";
+import * as zod146 from "zod";
 var previewComponentBodyWidthExclusiveMin = 0;
 var previewComponentBodyWidthMax = 9007199254740991;
 var previewComponentBodyHeightExclusiveMin = 0;
@@ -7582,325 +7591,325 @@ var previewComponentBodyHeightMax = 9007199254740991;
 var previewComponentBodyFpsExclusiveMin = 0;
 var previewComponentBodyFpsMax = 120;
 var previewComponentBodyDurationInFramesMax = 3600;
-var PreviewComponentBody = zod145.strictObject({
-  "componentId": zod145.string().min(1),
-  "params": zod145.record(zod145.string(), zod145.unknown()).optional(),
-  "assets": zod145.record(zod145.string(), zod145.string().min(1)).optional().describe("Component asset-slot name to org mediaId. Every required manifest slot must be bound."),
-  "width": zod145.int().gt(previewComponentBodyWidthExclusiveMin).max(previewComponentBodyWidthMax).optional(),
-  "height": zod145.int().gt(previewComponentBodyHeightExclusiveMin).max(previewComponentBodyHeightMax).optional(),
-  "fps": zod145.number().gt(previewComponentBodyFpsExclusiveMin).max(previewComponentBodyFpsMax).optional().describe("Preview frame rate. When omitted, uses the project's format."),
-  "durationInFrames": zod145.int().min(1).max(previewComponentBodyDurationInFramesMax).optional().describe("Preview frame count. When omitted, uses the component's declared duration; required if the component has none.")
+var PreviewComponentBody = zod146.strictObject({
+  "componentId": zod146.string().min(1),
+  "params": zod146.record(zod146.string(), zod146.unknown()).optional(),
+  "assets": zod146.record(zod146.string(), zod146.string().min(1)).optional().describe("Component asset-slot name to org mediaId. Every required manifest slot must be bound."),
+  "width": zod146.int().gt(previewComponentBodyWidthExclusiveMin).max(previewComponentBodyWidthMax).optional(),
+  "height": zod146.int().gt(previewComponentBodyHeightExclusiveMin).max(previewComponentBodyHeightMax).optional(),
+  "fps": zod146.number().gt(previewComponentBodyFpsExclusiveMin).max(previewComponentBodyFpsMax).optional().describe("Preview frame rate. When omitted, uses the project's format."),
+  "durationInFrames": zod146.int().min(1).max(previewComponentBodyDurationInFramesMax).optional().describe("Preview frame count. When omitted, uses the component's declared duration; required if the component has none.")
 });
 
 // ../sdk/src/generated/zod/models/previewFrameJobBody.zod.ts
-import * as zod146 from "zod";
+import * as zod147 from "zod";
 var previewFrameJobBodyScaleMin = 0.1;
 var previewFrameJobBodyScaleMax = 1;
 var previewFrameJobBodyJpegQualityMax = 100;
-var PreviewFrameJobBody = zod146.strictObject({
-  "composition": zod146.unknown().optional().describe("The composition to render. Absent \u21D2 the project's ACTIVE composition \u2014 what create_render will encode. The response's `previewed.source` names what was rendered."),
-  "compositionId": zod146.string().optional().describe("Preview a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
-  "session_id": zod146.string().optional().describe("Compose-session id: render that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
-  "timestamps": zod146.array(zod146.number()).min(1),
-  "imageFormat": zod146.enum(["png", "jpeg"]).optional().describe("Still format. Default jpeg \u2014 these pixels go to a vision model, where jpeg is equivalent and png costs multiples in bytes to store and move. Pass png only when you need full fidelity."),
-  "scale": zod146.number().min(previewFrameJobBodyScaleMin).max(previewFrameJobBodyScaleMax).optional().describe("Render scale 0.1\u20131. Default 0.5, which is what this schema has always recommended for vision-bound looks. Pass 1 when judging fine detail \u2014 it costs ~4x the vision tokens."),
-  "jpegQuality": zod146.int().min(1).max(previewFrameJobBodyJpegQualityMax).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
+var PreviewFrameJobBody = zod147.strictObject({
+  "composition": zod147.unknown().optional().describe("The composition to render. Absent \u21D2 the project's ACTIVE composition \u2014 what create_render will encode. The response's `previewed.source` names what was rendered."),
+  "compositionId": zod147.string().optional().describe("Preview a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
+  "session_id": zod147.string().optional().describe("Compose-session id: render that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
+  "timestamps": zod147.array(zod147.number()).min(1),
+  "imageFormat": zod147.enum(["png", "jpeg"]).optional().describe("Still format. Default jpeg \u2014 these pixels go to a vision model, where jpeg is equivalent and png costs multiples in bytes to store and move. Pass png only when you need full fidelity."),
+  "scale": zod147.number().min(previewFrameJobBodyScaleMin).max(previewFrameJobBodyScaleMax).optional().describe("Render scale 0.1\u20131. Default 0.5, which is what this schema has always recommended for vision-bound looks. Pass 1 when judging fine detail \u2014 it costs ~4x the vision tokens."),
+  "jpegQuality": zod147.int().min(1).max(previewFrameJobBodyJpegQualityMax).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
 });
 
 // ../sdk/src/generated/zod/models/profileResponse.zod.ts
-import * as zod147 from "zod";
+import * as zod148 from "zod";
 var profileResponseBrandKitsItemAudioMusicMoodMax = 300;
 var profileResponseBrandKitsItemAudioSonicLogoOffsetMsMin = 0;
 var profileResponseBrandKitsItemAudioSonicLogoOffsetMsMax = 1e4;
 var profileResponseBrandKitsItemAudioBedStyleGenreMax = 120;
-var ProfileResponse = zod147.strictObject({
-  "brandKits": zod147.array(zod147.strictObject({
-    "id": zod147.string(),
-    "name": zod147.string(),
-    "audio": zod147.strictObject({
-      "sfxIntensity": zod147.enum(["off", "light", "standard", "dense"]).optional(),
-      "musicEnabled": zod147.boolean().optional(),
-      "musicMood": zod147.string().max(profileResponseBrandKitsItemAudioMusicMoodMax).optional(),
-      "sonicLogo": zod147.strictObject({
-        "ref": zod147.string().min(1),
-        "placement": zod147.enum(["intro", "outro", "both"]),
-        "offsetMs": zod147.int().min(profileResponseBrandKitsItemAudioSonicLogoOffsetMsMin).max(profileResponseBrandKitsItemAudioSonicLogoOffsetMsMax).optional()
+var ProfileResponse = zod148.strictObject({
+  "brandKits": zod148.array(zod148.strictObject({
+    "id": zod148.string(),
+    "name": zod148.string(),
+    "audio": zod148.strictObject({
+      "sfxIntensity": zod148.enum(["off", "light", "standard", "dense"]).optional(),
+      "musicEnabled": zod148.boolean().optional(),
+      "musicMood": zod148.string().max(profileResponseBrandKitsItemAudioMusicMoodMax).optional(),
+      "sonicLogo": zod148.strictObject({
+        "ref": zod148.string().min(1),
+        "placement": zod148.enum(["intro", "outro", "both"]),
+        "offsetMs": zod148.int().min(profileResponseBrandKitsItemAudioSonicLogoOffsetMsMin).max(profileResponseBrandKitsItemAudioSonicLogoOffsetMsMax).optional()
       }).optional().describe("A brand sound signature bound to the intro/outro bookend. `ref` = a palette reference; bound only when the kit carries the matching bumper (intro/outro), else a non-blocking advisory."),
-      "uiSoundSet": zod147.strictObject({
-        "tick": zod147.string().min(1).optional(),
-        "pop": zod147.string().min(1).optional(),
-        "impact": zod147.string().min(1).optional(),
-        "confirm": zod147.string().min(1).optional(),
-        "error": zod147.string().min(1).optional(),
-        "whoosh": zod147.string().min(1).optional(),
-        "riser": zod147.string().min(1).optional()
+      "uiSoundSet": zod148.strictObject({
+        "tick": zod148.string().min(1).optional(),
+        "pop": zod148.string().min(1).optional(),
+        "impact": zod148.string().min(1).optional(),
+        "confirm": zod148.string().min(1).optional(),
+        "error": zod148.string().min(1).optional(),
+        "whoosh": zod148.string().min(1).optional(),
+        "riser": zod148.string().min(1).optional()
       }).optional().describe("Per-family SFX overrides (the brand's own tick/pop/\u2026). Highest-priority tier over the org palette + pack default in the compose SFX draw."),
-      "bedStyle": zod147.strictObject({
-        "bedId": zod147.string().min(1).optional(),
-        "genre": zod147.string().max(profileResponseBrandKitsItemAudioBedStyleGenreMax).optional(),
-        "bpmRange": zod147.strictObject({
-          "min": zod147.number(),
-          "max": zod147.number()
+      "bedStyle": zod148.strictObject({
+        "bedId": zod148.string().min(1).optional(),
+        "genre": zod148.string().max(profileResponseBrandKitsItemAudioBedStyleGenreMax).optional(),
+        "bpmRange": zod148.strictObject({
+          "min": zod148.number(),
+          "max": zod148.number()
         }).optional()
       }).optional().describe("Preferred music bed (`bedId`) or a style hint (`genre` / `bpmRange`). Surfaced for driving agents; compose does not auto-select a pack bed."),
-      "ambiencePreference": zod147.union([zod147.strictObject({
-        "ref": zod147.string().min(1)
-      }), zod147.null()]).optional().describe("Preferred ambience bed (`{ref}`) or explicit null (opt-out). Surfaced for driving agents; compose has no ambience auto-placement.")
+      "ambiencePreference": zod148.union([zod148.strictObject({
+        "ref": zod148.string().min(1)
+      }), zod148.null()]).optional().describe("Preferred ambience bed (`{ref}`) or explicit null (opt-out). Surfaced for driving agents; compose has no ambience auto-placement.")
     }).optional()
   })).describe("The org's brand kits (bind one to a project via update_project). `audio` carries the brand sound kit when set."),
-  "critics": zod147.array(CriticSummary).describe("Registered critics \u2014 run in the Director's gates AND score_composition."),
-  "references": zod147.array(zod147.strictObject({
-    "mediaId": zod147.string(),
-    "name": zod147.string().optional(),
-    "thumbnailUrl": zod147.string().optional().describe("Presigned reference thumbnail (~1 week).")
+  "critics": zod148.array(CriticSummary).describe("Registered critics \u2014 run in the Director's gates AND score_composition."),
+  "references": zod148.array(zod148.strictObject({
+    "mediaId": zod148.string(),
+    "name": zod148.string().optional(),
+    "thumbnailUrl": zod148.string().optional().describe("Presigned reference thumbnail (~1 week).")
   })).describe("The union of critic reference media \u2014 the org's visual standard, with provenance."),
-  "recentDecisions": zod147.array(zod147.strictObject({
-    "checkpointId": zod147.string(),
-    "projectId": zod147.string(),
-    "kind": zod147.enum(["gate", "score"]),
-    "stage": zod147.enum(["content", "layout", "motion"]).optional(),
-    "decision": zod147.string(),
-    "decidedAt": zod147.number()
+  "recentDecisions": zod148.array(zod148.strictObject({
+    "checkpointId": zod148.string(),
+    "projectId": zod148.string(),
+    "kind": zod148.enum(["gate", "score"]),
+    "stage": zod148.enum(["content", "layout", "motion"]).optional(),
+    "decision": zod148.string(),
+    "decidedAt": zod148.number()
   })).describe("The last recorded checkpoint decisions \u2014 the raw taste log phase 2 will distill.")
 }).describe("The org's legible taste: brand + critics + references + decision log.");
 
 // ../sdk/src/generated/zod/models/projectCompositionSummary.zod.ts
-import * as zod148 from "zod";
+import * as zod149 from "zod";
 var projectCompositionSummarySceneCountMin = 0;
 var projectCompositionSummarySceneCountMax = 9007199254740991;
-var ProjectCompositionSummary = zod148.strictObject({
-  "hasComposition": zod148.boolean(),
-  "sceneCount": zod148.int().min(projectCompositionSummarySceneCountMin).max(projectCompositionSummarySceneCountMax),
-  "duration": zod148.number().nullable(),
-  "updatedAt": zod148.string().nullable()
+var ProjectCompositionSummary = zod149.strictObject({
+  "hasComposition": zod149.boolean(),
+  "sceneCount": zod149.int().min(projectCompositionSummarySceneCountMin).max(projectCompositionSummarySceneCountMax),
+  "duration": zod149.number().nullable(),
+  "updatedAt": zod149.string().nullable()
 }).describe("Summary of a project's stored composition.");
 
 // ../sdk/src/generated/zod/models/projectContextMedia.zod.ts
-import * as zod149 from "zod";
-var ProjectContextMedia = zod149.strictObject({
-  "id": zod149.string(),
-  "name": zod149.string(),
-  "kind": zod149.string().nullable(),
-  "durationSec": zod149.number().nullable().describe("Seconds. Uses the media duration when known; audio without one falls back to its transcript's measured duration (same rule as get_media_context)."),
-  "hasTranscript": zod149.boolean().describe("A cached transcript EXISTS for this item. The bodies are never inlined here \u2014 fetch one with GET /v1/media/{id}/transcript (or get_media_context for faces + grids too).")
+import * as zod150 from "zod";
+var ProjectContextMedia = zod150.strictObject({
+  "id": zod150.string(),
+  "name": zod150.string(),
+  "kind": zod150.string().nullable(),
+  "durationSec": zod150.number().nullable().describe("Seconds. Uses the media duration when known; audio without one falls back to its transcript's measured duration (same rule as get_media_context)."),
+  "hasTranscript": zod150.boolean().describe("A cached transcript EXISTS for this item. The bodies are never inlined here \u2014 fetch one with GET /v1/media/{id}/transcript (or get_media_context for faces + grids too).")
 }).describe("One media item as the project context lists it: identity + duration + whether a transcript exists.");
 
 // ../sdk/src/generated/zod/models/projectContextResponse.zod.ts
-import * as zod151 from "zod";
+import * as zod152 from "zod";
 
 // ../sdk/src/generated/zod/models/projectContextTranscript.zod.ts
-import * as zod150 from "zod";
-var ProjectContextTranscript = zod150.union([zod150.strictObject({
-  "status": zod150.literal("ready"),
-  "mediaId": zod150.string(),
-  "words": zod150.array(zod150.strictObject({
-    "text": zod150.string(),
-    "start": zod150.number().describe("Word onset (SECONDS from source start)."),
-    "end": zod150.number().describe("Word end (SECONDS from source start).")
+import * as zod151 from "zod";
+var ProjectContextTranscript = zod151.union([zod151.strictObject({
+  "status": zod151.literal("ready"),
+  "mediaId": zod151.string(),
+  "words": zod151.array(zod151.strictObject({
+    "text": zod151.string(),
+    "start": zod151.number().describe("Word onset (SECONDS from source start)."),
+    "end": zod151.number().describe("Word end (SECONDS from source start).")
   }))
-}), zod150.strictObject({
-  "status": zod150.literal("unavailable"),
-  "mediaId": zod150.string()
+}), zod151.strictObject({
+  "status": zod151.literal("unavailable"),
+  "mediaId": zod151.string()
 })]);
 
 // ../sdk/src/generated/zod/models/projectContextResponse.zod.ts
 var projectContextResponseMarkersItemStartTimeMin = 0;
 var projectContextResponseMarkersItemEndTimeMin = 0;
-var ProjectContextResponse = zod151.strictObject({
-  "composition": zod151.union([Composition, zod151.null()]).describe("The project's ACTIVE composition wire shape \u2014 identical to GET /v1/projects/{id}/composition. NULL when the project has no composition yet (a freshly created project): mint one with new_composition, or let the first apply_composition create it."),
-  "format": zod151.union([zod151.strictObject({
-    "aspectRatio": zod151.enum(["16:9", "9:16", "1:1", "4:5"]),
-    "fps": zod151.union([zod151.literal(24), zod151.literal(25), zod151.literal(30), zod151.literal(60)]).optional(),
-    "resolution": zod151.enum(["hd", "fhd", "4k"]).optional(),
-    "platform": zod151.string().optional()
-  }), zod151.null()]).describe("The composition's format, hoisted \u2014 the pixel frame every card/graphic must be authored against. Null whenever `composition` is null."),
-  "media": zod151.array(ProjectContextMedia).describe("The org's media library (most recent first, capped) \u2014 the pool this project can draw clips from."),
-  "transcript": zod151.union([ProjectContextTranscript, zod151.null()]).describe('The FIRST transcribed media item\'s word-timed transcript, flattened \u2014 the spine a VO-driven film cuts to. `status:"ready"` carries the words; `status:"unavailable"` means the transcript exists but its body could not be fetched (retry); null means nothing in `media` is transcribed. For any OTHER transcribed item (see each entry\'s `hasTranscript`), read GET /v1/media/{id}/transcript.'),
-  "brandKit": zod151.union([BrandKitResponse, zod151.null()]).describe("The kit BOUND to this project (`projects.brandKitId` is the brand SSOT \u2014 bind one via update_project). Null when the project has no kit bound; enumerate the org's kits with GET /v1/brand-kits."),
-  "markers": zod151.array(zod151.strictObject({
-    "id": zod151.string().min(1),
-    "startTime": zod151.number().min(projectContextResponseMarkersItemStartTimeMin),
-    "endTime": zod151.number().min(projectContextResponseMarkersItemEndTimeMin).optional(),
-    "kind": zod151.string().min(1),
-    "name": zod151.string().optional(),
-    "metadata": zod151.record(zod151.string(), zod151.unknown()).optional()
+var ProjectContextResponse = zod152.strictObject({
+  "composition": zod152.union([Composition, zod152.null()]).describe("The project's ACTIVE composition wire shape \u2014 identical to GET /v1/projects/{id}/composition. NULL when the project has no composition yet (a freshly created project): mint one with new_composition, or let the first apply_composition create it."),
+  "format": zod152.union([zod152.strictObject({
+    "aspectRatio": zod152.enum(["16:9", "9:16", "1:1", "4:5"]),
+    "fps": zod152.union([zod152.literal(24), zod152.literal(25), zod152.literal(30), zod152.literal(60)]).optional(),
+    "resolution": zod152.enum(["hd", "fhd", "4k"]).optional(),
+    "platform": zod152.string().optional()
+  }), zod152.null()]).describe("The composition's format, hoisted \u2014 the pixel frame every card/graphic must be authored against. Null whenever `composition` is null."),
+  "media": zod152.array(ProjectContextMedia).describe("The org's media library (most recent first, capped) \u2014 the pool this project can draw clips from."),
+  "transcript": zod152.union([ProjectContextTranscript, zod152.null()]).describe('The FIRST transcribed media item\'s word-timed transcript, flattened \u2014 the spine a VO-driven film cuts to. `status:"ready"` carries the words; `status:"unavailable"` means the transcript exists but its body could not be fetched (retry); null means nothing in `media` is transcribed. For any OTHER transcribed item (see each entry\'s `hasTranscript`), read GET /v1/media/{id}/transcript.'),
+  "brandKit": zod152.union([BrandKitResponse, zod152.null()]).describe("The kit BOUND to this project (`projects.brandKitId` is the brand SSOT \u2014 bind one via update_project). Null when the project has no kit bound; enumerate the org's kits with GET /v1/brand-kits."),
+  "markers": zod152.array(zod152.strictObject({
+    "id": zod152.string().min(1),
+    "startTime": zod152.number().min(projectContextResponseMarkersItemStartTimeMin),
+    "endTime": zod152.number().min(projectContextResponseMarkersItemEndTimeMin).optional(),
+    "kind": zod152.string().min(1),
+    "name": zod152.string().optional(),
+    "metadata": zod152.record(zod152.string(), zod152.unknown()).optional()
   })).describe("The composition's markers \u2014 hoisted alongside `format`. Empty when the composition carries none AND when there is no composition yet.")
 }).describe("One-call agent context for a project: composition + format + media pool + the lead transcript + the bound brand kit + markers. Replaces get_composition + get_media_context + get_profile at the start of an authoring session. A 404 means the project doesn't exist for your org \u2014 never that it is empty.");
 
 // ../sdk/src/generated/zod/models/projectCreateRequest.zod.ts
-import * as zod152 from "zod";
+import * as zod153 from "zod";
 var projectCreateRequestNameMax = 200;
 var projectCreateRequestWidthExclusiveMin = 0;
 var projectCreateRequestHeightExclusiveMin = 0;
-var ProjectCreateRequest = zod152.strictObject({
-  "name": zod152.string().min(1).max(projectCreateRequestNameMax),
-  "description": zod152.string().optional(),
+var ProjectCreateRequest = zod153.strictObject({
+  "name": zod153.string().min(1).max(projectCreateRequestNameMax),
+  "description": zod153.string().optional(),
   "format": FormatSpec.optional(),
-  "brandKitId": zod152.string().min(1).optional(),
-  "width": zod152.number().gt(projectCreateRequestWidthExclusiveMin).optional(),
-  "height": zod152.number().gt(projectCreateRequestHeightExclusiveMin).optional()
+  "brandKitId": zod153.string().min(1).optional(),
+  "width": zod153.number().gt(projectCreateRequestWidthExclusiveMin).optional(),
+  "height": zod153.number().gt(projectCreateRequestHeightExclusiveMin).optional()
 }).describe("POST /projects body.");
 
 // ../sdk/src/generated/zod/models/projectLastRender.zod.ts
-import * as zod153 from "zod";
-var ProjectLastRender = zod153.union([zod153.strictObject({
-  "id": zod153.string(),
-  "status": zod153.string(),
-  "createdAt": zod153.string(),
-  "outputUrl": zod153.string().nullable(),
-  "outputExpiresAt": zod153.string().nullable()
-}), zod153.null()]).describe("Most recent render for a project, if any.");
+import * as zod154 from "zod";
+var ProjectLastRender = zod154.union([zod154.strictObject({
+  "id": zod154.string(),
+  "status": zod154.string(),
+  "createdAt": zod154.string(),
+  "outputUrl": zod154.string().nullable(),
+  "outputExpiresAt": zod154.string().nullable()
+}), zod154.null()]).describe("Most recent render for a project, if any.");
 
 // ../sdk/src/generated/zod/models/projectListResponse.zod.ts
-import * as zod155 from "zod";
+import * as zod156 from "zod";
 
 // ../sdk/src/generated/zod/models/projectResponse.zod.ts
-import * as zod154 from "zod";
-var ProjectResponse = zod154.strictObject({
-  "id": zod154.string(),
-  "name": zod154.string(),
-  "description": zod154.string().nullable(),
-  "format": zod154.union([FormatSpec, zod154.null()]),
-  "brandKitId": zod154.string().nullable(),
-  "activeCompositionId": zod154.string().nullable(),
+import * as zod155 from "zod";
+var ProjectResponse = zod155.strictObject({
+  "id": zod155.string(),
+  "name": zod155.string(),
+  "description": zod155.string().nullable(),
+  "format": zod155.union([FormatSpec, zod155.null()]),
+  "brandKitId": zod155.string().nullable(),
+  "activeCompositionId": zod155.string().nullable(),
   "composition": ProjectCompositionSummary,
   "lastRender": ProjectLastRender,
-  "webUrl": zod154.string().nullable().describe("A browser URL that opens THIS project, or null when CueFrame exposes no web view for a project. Null today: the console serves account surfaces (keys, usage, billing) and has no per-project page, so there is no link to give. Do NOT synthesise one \u2014 a guessed console path 404s. Show the user rendered output (create_render \u2192 outputUrl) or a preview still instead. This field becoming non-null is the signal that a real project view exists."),
-  "createdAt": zod154.string()
+  "webUrl": zod155.string().nullable().describe("A browser URL that opens THIS project, or null when CueFrame exposes no web view for a project. Null today: the console serves account surfaces (keys, usage, billing) and has no per-project page, so there is no link to give. Do NOT synthesise one \u2014 a guessed console path 404s. Show the user rendered output (create_render \u2192 outputUrl) or a preview still instead. This field becoming non-null is the signal that a real project view exists."),
+  "createdAt": zod155.string()
 }).describe("Project response per \xA7Projects.");
 
 // ../sdk/src/generated/zod/models/projectListResponse.zod.ts
-var ProjectListResponse = zod155.strictObject({
-  "data": zod155.array(ProjectResponse),
+var ProjectListResponse = zod156.strictObject({
+  "data": zod156.array(ProjectResponse),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/projectPatchRequest.zod.ts
-import * as zod156 from "zod";
+import * as zod157 from "zod";
 var projectPatchRequestNameMax = 200;
-var ProjectPatchRequest = zod156.strictObject({
-  "name": zod156.string().min(1).max(projectPatchRequestNameMax).optional(),
-  "description": zod156.string().optional(),
+var ProjectPatchRequest = zod157.strictObject({
+  "name": zod157.string().min(1).max(projectPatchRequestNameMax).optional(),
+  "description": zod157.string().optional(),
   "format": FormatSpec.optional(),
-  "brandKitId": zod156.string().min(1).optional()
+  "brandKitId": zod157.string().min(1).optional()
 }).describe("PATCH /projects/:id body.");
 
 // ../sdk/src/generated/zod/models/renderCreateRequest.zod.ts
-import * as zod157 from "zod";
-var RenderCreateRequest = zod157.strictObject({
-  "clipSuggestionId": zod157.string().min(1).optional(),
-  "compositionId": zod157.string().min(1).optional().describe("Target a specific composition in the project; defaults to the project's active composition."),
+import * as zod158 from "zod";
+var RenderCreateRequest = zod158.strictObject({
+  "clipSuggestionId": zod158.string().min(1).optional(),
+  "compositionId": zod158.string().min(1).optional().describe("Target a specific composition in the project; defaults to the project's active composition."),
   "format": FormatSpec.optional(),
-  "priority": zod157.enum(["interactive", "standard", "background"]).optional(),
-  "intent": zod157.enum(["preview", "final"]).optional(),
-  "brandKitId": zod157.union([zod157.string().min(1), zod157.null()]).optional()
+  "priority": zod158.enum(["interactive", "standard", "background"]).optional(),
+  "intent": zod158.enum(["preview", "final"]).optional(),
+  "brandKitId": zod158.union([zod158.string().min(1), zod158.null()]).optional()
 }).describe("POST /projects/:id/renders body.");
 
 // ../sdk/src/generated/zod/models/renderFontsResponse.zod.ts
-import * as zod158 from "zod";
-var RenderFontsResponse = zod158.strictObject({
-  "manifestVersion": zod158.string().describe("Identifies this exact face table. Derived from the table's own content, so it moves when and only when the admitted set moves. Record it beside a composition to state which face table a font choice was validated against."),
-  "families": zod158.array(zod158.strictObject({
-    "family": zod158.string().describe("The family name authoring accepts VERBATIM \u2014 card, caption and scene text alike."),
-    "weights": zod158.array(zod158.strictObject({
-      "min": zod158.number(),
-      "max": zod158.number()
+import * as zod159 from "zod";
+var RenderFontsResponse = zod159.strictObject({
+  "manifestVersion": zod159.string().describe("Identifies this exact face table. Derived from the table's own content, so it moves when and only when the admitted set moves. Record it beside a composition to state which face table a font choice was validated against."),
+  "families": zod159.array(zod159.strictObject({
+    "family": zod159.string().describe("The family name authoring accepts VERBATIM \u2014 card, caption and scene text alike."),
+    "weights": zod159.array(zod159.strictObject({
+      "min": zod159.number(),
+      "max": zod159.number()
     })).describe("The weights a shipped file declares. A static face has min === max; a variable face gives its declared wght axis range. Any weight inside a range renders; anything outside every range is REFUSED, never synthesised."),
-    "styles": zod158.array(zod158.enum(["normal"])).describe("The styles bytes exist for. Always ['normal']: no bundled or aliased family ships an italic file, so fontStyle:'italic' over one is refused rather than slanted. Real italics come only from a brand-kit font asset."),
-    "captionDefaults": zod158.strictObject({
-      "base": zod158.number(),
-      "emphasis": zod158.number()
+    "styles": zod159.array(zod159.enum(["normal"])).describe("The styles bytes exist for. Always ['normal']: no bundled or aliased family ships an italic file, so fontStyle:'italic' over one is refused rather than slanted. Real italics come only from a brand-kit font asset."),
+    "captionDefaults": zod159.strictObject({
+      "base": zod159.number(),
+      "emphasis": zod159.number()
     }).describe("The weights a caption is drawn at when the style names none."),
-    "origin": zod158.enum(["bundled", "aliased"]).describe("'bundled' = bytes ship in the render bundle. 'aliased' = a metric-compatible binary stands in for the named family.")
+    "origin": zod159.enum(["bundled", "aliased"]).describe("'bundled' = bytes ship in the render bundle. 'aliased' = a metric-compatible binary stands in for the named family.")
   }))
 }).describe("GET /fonts response \u2014 the renderer's admitted font set. Derived from the same table the font gate refuses by, so any family/weight/style here passes validation by construction. Covers the BUNDLED set only: a brand kit's sealed faces are per-org and per-render.");
 
 // ../sdk/src/generated/zod/models/renderListResponse.zod.ts
-import * as zod161 from "zod";
+import * as zod162 from "zod";
 
 // ../sdk/src/generated/zod/models/renderResponse.zod.ts
-import * as zod160 from "zod";
+import * as zod161 from "zod";
 
 // ../sdk/src/generated/zod/models/renderProgress.zod.ts
-import * as zod159 from "zod";
+import * as zod160 from "zod";
 var renderProgressScenesCompletedMin = 0;
 var renderProgressScenesCompletedMax = 9007199254740991;
 var renderProgressScenesTotalMin = 0;
 var renderProgressScenesTotalMax = 9007199254740991;
-var RenderProgress = zod159.strictObject({
-  "phase": zod159.enum(["queued", "validating", "presigning", "collecting-artifacts", "resolving", "detecting", "baking-matte", "translating", "spawning", "encoding", "uploading"]),
-  "percent": zod159.number(),
-  "scenesCompleted": zod159.int().min(renderProgressScenesCompletedMin).max(renderProgressScenesCompletedMax).optional(),
-  "scenesTotal": zod159.int().min(renderProgressScenesTotalMin).max(renderProgressScenesTotalMax).optional()
+var RenderProgress = zod160.strictObject({
+  "phase": zod160.enum(["queued", "validating", "presigning", "collecting-artifacts", "resolving", "detecting", "baking-matte", "translating", "spawning", "encoding", "uploading"]),
+  "percent": zod160.number(),
+  "scenesCompleted": zod160.int().min(renderProgressScenesCompletedMin).max(renderProgressScenesCompletedMax).optional(),
+  "scenesTotal": zod160.int().min(renderProgressScenesTotalMin).max(renderProgressScenesTotalMax).optional()
 }).describe("Non-terminal render progress; phase is one of the worker's emitted stages.");
 
 // ../sdk/src/generated/zod/models/renderResponse.zod.ts
-var RenderResponse = zod160.strictObject({
-  "id": zod160.string(),
-  "status": zod160.enum(["queued", "pending", "rendering", "complete", "error", "cancelled"]),
+var RenderResponse = zod161.strictObject({
+  "id": zod161.string(),
+  "status": zod161.enum(["queued", "pending", "rendering", "complete", "error", "cancelled"]),
   "progress": RenderProgress.optional(),
-  "outputUrl": zod160.string().nullable(),
-  "outputExpiresAt": zod160.string().nullable(),
-  "error": zod160.string().nullable().describe("Human-readable failure message. Pair with `errorCode` for a stable, machine-readable code an agent runner can branch on."),
-  "errorCode": zod160.string().nullable().describe("Stable, machine-readable error code (e.g. `render_pipeline_unavailable`, `render_route_missing`, `render_pipeline_failed`). Null when status is not `error` or unavailable for an older render."),
-  "errorDetails": zod160.union([zod160.record(zod160.string(), zod160.unknown()), zod160.null()]).describe("Structured failure context \u2014 `{ targetUrl?, upstreamStatus?, upstreamCode?, attemptedAt? }`. Surfaced so agent runners can distinguish operator-config issues from upstream-down vs route-missing without parsing `error`."),
-  "category": zod160.union([zod160.enum(["authoring", "transient", "internal"]), zod160.null()]).describe("Failure taxonomy when status is `error`; null otherwise. `authoring` = deterministic defect in YOUR composition/request \u2014 fix it, retrying is futile; `transient` = temporary pipeline/infra failure \u2014 safe to retry_render; `internal` = unexpected server fault \u2014 retry once then escalate. Mirrors the render.failed webhook's `category`."),
-  "retryable": zod160.boolean().nullable().describe("Whether re-attempting the SAME render can succeed (status `error`); null otherwise. true \u2192 call retry_render. false \u2192 deterministic (category authoring/internal); fix the composition first \u2014 retry_render alone reproduces it. Mirrors the render.failed webhook's `retryable`."),
-  "createdAt": zod160.string(),
-  "updatedAt": zod160.string().describe("ISO-8601 timestamp of the render's most recent progress update. Compute staleness = now \u2212 updatedAt to distinguish a wedged render from a slow one and decide whether to wait, cancel, or retry."),
-  "listUsd": zod160.number().optional().describe("A2 money stamp: the metered event's LIST price (USD), stamped at the success terminal (exports for deliverable renders, compose_capture for A8 previews). A plan allowance may zero the actual invoice line \u2014 this is the list price, never a Stripe charge. Absent while running, on failure, and for x402 orgs (on-chain receipts). Mirrors the get_usage ledger."),
-  "warnings": zod160.array(zod160.string()).optional().describe("Non-fatal advisories surfaced at render-CREATE (omitted when none, and on GET \u2014 create-time only).")
+  "outputUrl": zod161.string().nullable(),
+  "outputExpiresAt": zod161.string().nullable(),
+  "error": zod161.string().nullable().describe("Human-readable failure message. Pair with `errorCode` for a stable, machine-readable code an agent runner can branch on."),
+  "errorCode": zod161.string().nullable().describe("Stable, machine-readable error code (e.g. `render_pipeline_unavailable`, `render_route_missing`, `render_pipeline_failed`). Null when status is not `error` or unavailable for an older render."),
+  "errorDetails": zod161.union([zod161.record(zod161.string(), zod161.unknown()), zod161.null()]).describe("Structured failure context \u2014 `{ targetUrl?, upstreamStatus?, upstreamCode?, attemptedAt? }`. Surfaced so agent runners can distinguish operator-config issues from upstream-down vs route-missing without parsing `error`."),
+  "category": zod161.union([zod161.enum(["authoring", "transient", "internal"]), zod161.null()]).describe("Failure taxonomy when status is `error`; null otherwise. `authoring` = deterministic defect in YOUR composition/request \u2014 fix it, retrying is futile; `transient` = temporary pipeline/infra failure \u2014 safe to retry_render; `internal` = unexpected server fault \u2014 retry once then escalate. Mirrors the render.failed webhook's `category`."),
+  "retryable": zod161.boolean().nullable().describe("Whether re-attempting the SAME render can succeed (status `error`); null otherwise. true \u2192 call retry_render. false \u2192 deterministic (category authoring/internal); fix the composition first \u2014 retry_render alone reproduces it. Mirrors the render.failed webhook's `retryable`."),
+  "createdAt": zod161.string(),
+  "updatedAt": zod161.string().describe("ISO-8601 timestamp of the render's most recent progress update. Compute staleness = now \u2212 updatedAt to distinguish a wedged render from a slow one and decide whether to wait, cancel, or retry."),
+  "listUsd": zod161.number().optional().describe("A2 money stamp: the metered event's LIST price (USD), stamped at the success terminal (exports for deliverable renders, compose_capture for A8 previews). A plan allowance may zero the actual invoice line \u2014 this is the list price, never a Stripe charge. Absent while running, on failure, and for x402 orgs (on-chain receipts). Mirrors the get_usage ledger."),
+  "warnings": zod161.array(zod161.string()).optional().describe("Non-fatal advisories surfaced at render-CREATE (omitted when none, and on GET \u2014 create-time only).")
 }).describe("Render job response per \xA7Renders.");
 
 // ../sdk/src/generated/zod/models/renderListResponse.zod.ts
-var RenderListResponse = zod161.strictObject({
-  "data": zod161.array(RenderResponse),
+var RenderListResponse = zod162.strictObject({
+  "data": zod162.array(RenderResponse),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/renderRefreshUrlResponse.zod.ts
-import * as zod162 from "zod";
-var RenderRefreshUrlResponse = zod162.strictObject({
-  "outputUrl": zod162.string(),
-  "outputExpiresAt": zod162.string()
+import * as zod163 from "zod";
+var RenderRefreshUrlResponse = zod163.strictObject({
+  "outputUrl": zod163.string(),
+  "outputExpiresAt": zod163.string()
 }).describe("POST /refresh-url response.");
 
 // ../sdk/src/generated/zod/models/resourceCandidate.zod.ts
-import * as zod163 from "zod";
-var ResourceCandidate = zod163.strictObject({
-  "candidateId": zod163.string(),
-  "provider": zod163.enum(["pexels", "pixabay", "freesound", "klipy"]),
-  "kind": zod163.enum(["video", "photo", "sfx", "gif"]),
-  "thumbnail": zod163.string(),
-  "previewUrl": zod163.string(),
-  "downloadUrl": zod163.string().optional(),
-  "duration": zod163.number().optional(),
-  "width": zod163.number().optional(),
-  "height": zod163.number().optional(),
-  "author": zod163.string(),
-  "authorUrl": zod163.string().optional(),
-  "assetUrl": zod163.string().optional(),
-  "license": zod163.string().optional()
+import * as zod164 from "zod";
+var ResourceCandidate = zod164.strictObject({
+  "candidateId": zod164.string(),
+  "provider": zod164.enum(["pexels", "pixabay", "freesound", "klipy"]),
+  "kind": zod164.enum(["video", "photo", "sfx", "gif"]),
+  "thumbnail": zod164.string(),
+  "previewUrl": zod164.string(),
+  "downloadUrl": zod164.string().optional(),
+  "duration": zod164.number().optional(),
+  "width": zod164.number().optional(),
+  "height": zod164.number().optional(),
+  "author": zod164.string(),
+  "authorUrl": zod164.string().optional(),
+  "assetUrl": zod164.string().optional(),
+  "license": zod164.string().optional()
 }).describe("A stock resource search candidate.");
 
 // ../sdk/src/generated/zod/models/resourceImportRequest.zod.ts
-import * as zod164 from "zod";
-var ResourceImportRequest = zod164.strictObject({
-  "kind": zod164.enum(["sfx-pack", "music-pack"]).optional(),
-  "id": zod164.string().min(1).optional(),
-  "projectId": zod164.string().min(1).optional(),
-  "candidateId": zod164.string().min(1).optional()
+import * as zod165 from "zod";
+var ResourceImportRequest = zod165.strictObject({
+  "kind": zod165.enum(["sfx-pack", "music-pack"]).optional(),
+  "id": zod165.string().min(1).optional(),
+  "projectId": zod165.string().min(1).optional(),
+  "candidateId": zod165.string().min(1).optional()
 }).describe('POST /resources/import body \u2014 stock candidate lane { projectId, candidateId } OR curated pack lane { kind:"sfx-pack"|"music-pack", id }.');
 
 // ../sdk/src/generated/zod/models/resourceImportResponse.zod.ts
-import * as zod165 from "zod";
-var ResourceImportResponse = zod165.strictObject({
-  "id": zod165.string(),
-  "status": zod165.enum(["importing", "ready"])
+import * as zod166 from "zod";
+var ResourceImportResponse = zod166.strictObject({
+  "id": zod166.string(),
+  "status": zod166.enum(["importing", "ready"])
 }).describe("POST /resources/import response.");
 
 // ../sdk/src/generated/zod/models/resourceSearchRequest.zod.ts
-import * as zod166 from "zod";
+import * as zod167 from "zod";
 var resourceSearchRequestQueryMax = 200;
 var resourceSearchRequestQueriesItemMax = 200;
 var resourceSearchRequestQueriesMax = 10;
@@ -7912,342 +7921,342 @@ var resourceSearchRequestMinHeightExclusiveMin = 0;
 var resourceSearchRequestMinHeightMax = 9007199254740991;
 var resourceSearchRequestDurationSecMinMin = 0;
 var resourceSearchRequestDurationSecMaxExclusiveMin = 0;
-var ResourceSearchRequest = zod166.strictObject({
-  "query": zod166.string().min(1).max(resourceSearchRequestQueryMax).optional(),
-  "queries": zod166.array(zod166.string().min(1).max(resourceSearchRequestQueriesItemMax)).min(1).max(resourceSearchRequestQueriesMax).optional(),
-  "kind": zod166.enum(["video", "photo", "sfx", "gif"]).optional(),
-  "provider": zod166.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
-  "limit": zod166.int().gt(resourceSearchRequestLimitExclusiveMin).max(resourceSearchRequestLimitMax).optional(),
-  "minWidth": zod166.int().gt(resourceSearchRequestMinWidthExclusiveMin).max(resourceSearchRequestMinWidthMax).optional().describe("Video-only minimum selected-rendition width in pixels; smaller results are excluded."),
-  "minHeight": zod166.int().gt(resourceSearchRequestMinHeightExclusiveMin).max(resourceSearchRequestMinHeightMax).optional().describe("Video-only minimum selected-rendition height in pixels; smaller results are excluded."),
-  "durationSec": zod166.strictObject({
-    "min": zod166.number().min(resourceSearchRequestDurationSecMinMin).optional(),
-    "max": zod166.number().gt(resourceSearchRequestDurationSecMaxExclusiveMin).optional()
+var ResourceSearchRequest = zod167.strictObject({
+  "query": zod167.string().min(1).max(resourceSearchRequestQueryMax).optional(),
+  "queries": zod167.array(zod167.string().min(1).max(resourceSearchRequestQueriesItemMax)).min(1).max(resourceSearchRequestQueriesMax).optional(),
+  "kind": zod167.enum(["video", "photo", "sfx", "gif"]).optional(),
+  "provider": zod167.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
+  "limit": zod167.int().gt(resourceSearchRequestLimitExclusiveMin).max(resourceSearchRequestLimitMax).optional(),
+  "minWidth": zod167.int().gt(resourceSearchRequestMinWidthExclusiveMin).max(resourceSearchRequestMinWidthMax).optional().describe("Video-only minimum selected-rendition width in pixels; smaller results are excluded."),
+  "minHeight": zod167.int().gt(resourceSearchRequestMinHeightExclusiveMin).max(resourceSearchRequestMinHeightMax).optional().describe("Video-only minimum selected-rendition height in pixels; smaller results are excluded."),
+  "durationSec": zod167.strictObject({
+    "min": zod167.number().min(resourceSearchRequestDurationSecMinMin).optional(),
+    "max": zod167.number().gt(resourceSearchRequestDurationSecMaxExclusiveMin).optional()
   }).optional().describe("sfx-only clip-length bound in seconds \u2192 Freesound native filter.")
 }).describe("POST /resources/search body \u2014 one `query`, or a batch of `queries[]`.");
 
 // ../sdk/src/generated/zod/models/resourceSearchResponse.zod.ts
-import * as zod168 from "zod";
+import * as zod169 from "zod";
 
 // ../sdk/src/generated/zod/models/resourceSearchResult.zod.ts
-import * as zod167 from "zod";
-var ResourceSearchResult = zod167.strictObject({
-  "query": zod167.string(),
-  "provider": zod167.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
-  "kind": zod167.enum(["video", "photo", "sfx", "gif"]).optional(),
-  "candidates": zod167.array(ResourceCandidate),
-  "error": zod167.string().optional()
+import * as zod168 from "zod";
+var ResourceSearchResult = zod168.strictObject({
+  "query": zod168.string(),
+  "provider": zod168.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
+  "kind": zod168.enum(["video", "photo", "sfx", "gif"]).optional(),
+  "candidates": zod168.array(ResourceCandidate),
+  "error": zod168.string().optional()
 }).describe("One query's candidates within a batch search.");
 
 // ../sdk/src/generated/zod/models/resourceSearchResponse.zod.ts
-var ResourceSearchResponse = zod168.strictObject({
-  "provider": zod168.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
-  "kind": zod168.enum(["video", "photo", "sfx", "gif"]).optional(),
-  "candidates": zod168.array(ResourceCandidate).optional(),
-  "results": zod168.array(ResourceSearchResult).optional()
+var ResourceSearchResponse = zod169.strictObject({
+  "provider": zod169.enum(["pexels", "pixabay", "freesound", "klipy"]).optional(),
+  "kind": zod169.enum(["video", "photo", "sfx", "gif"]).optional(),
+  "candidates": zod169.array(ResourceCandidate).optional(),
+  "results": zod169.array(ResourceSearchResult).optional()
 }).describe("POST /resources/search response \u2014 `candidates` for one query, `results[]` for a batch.");
 
 // ../sdk/src/generated/zod/models/reviewDecisionResponse.zod.ts
-import * as zod169 from "zod";
+import * as zod170 from "zod";
 var reviewDecisionResponseVersionMin = -9007199254740991;
 var reviewDecisionResponseVersionMax = 9007199254740991;
-var ReviewDecisionResponse = zod169.strictObject({
-  "ok": zod169.literal(true),
-  "stage": zod169.enum(["content", "layout", "motion"]).optional(),
-  "version": zod169.int().min(reviewDecisionResponseVersionMin).max(reviewDecisionResponseVersionMax).optional(),
-  "composeJobId": zod169.string().optional()
+var ReviewDecisionResponse = zod170.strictObject({
+  "ok": zod170.literal(true),
+  "stage": zod170.enum(["content", "layout", "motion"]).optional(),
+  "version": zod170.int().min(reviewDecisionResponseVersionMin).max(reviewDecisionResponseVersionMax).optional(),
+  "composeJobId": zod170.string().optional()
 }).describe("Decision recorded; the run resumes (the SAME rail as POST /checkpoints/{id}/resume).");
 
 // ../sdk/src/generated/zod/models/reviewPacketResponse.zod.ts
-import * as zod170 from "zod";
+import * as zod171 from "zod";
 var reviewPacketResponseVersionMin = -9007199254740991;
 var reviewPacketResponseVersionMax = 9007199254740991;
 var reviewPacketResponseRevisionCycleMin = -9007199254740991;
 var reviewPacketResponseRevisionCycleMax = 9007199254740991;
 var reviewPacketResponseVersionStackItemVersionMin = -9007199254740991;
 var reviewPacketResponseVersionStackItemVersionMax = 9007199254740991;
-var ReviewPacketResponse = zod170.strictObject({
-  "id": zod170.string(),
-  "projectId": zod170.string(),
-  "composeJobId": zod170.string().optional(),
-  "briefId": zod170.string().optional(),
-  "kind": zod170.enum(["gate", "score"]),
+var ReviewPacketResponse = zod171.strictObject({
+  "id": zod171.string(),
+  "projectId": zod171.string(),
+  "composeJobId": zod171.string().optional(),
+  "briefId": zod171.string().optional(),
+  "kind": zod171.enum(["gate", "score"]),
   "stage": CheckpointStage.optional(),
-  "version": zod170.int().min(reviewPacketResponseVersionMin).max(reviewPacketResponseVersionMax),
-  "status": zod170.enum(["awaiting", "approved", "revised", "abandoned", "expired", "superseded"]),
-  "artifact": zod170.unknown().describe("The stage artifact under review: the locked ComposePlan at content; the composition wire shape at layout/motion; the judged composition snapshot on kind:'score'."),
-  "stillUrls": zod170.array(zod170.string()).optional().describe("Presigned storyboard/eval stills \u2014 the packet's visual evidence (may be GC'd by the retention sweep after the job goes terminal; the decision record is immortal)."),
-  "criticVerdicts": zod170.unknown().optional().describe("Per-criterion scores + critique from the design loop / judge, incl. lock_violation entries."),
+  "version": zod171.int().min(reviewPacketResponseVersionMin).max(reviewPacketResponseVersionMax),
+  "status": zod171.enum(["awaiting", "approved", "revised", "abandoned", "expired", "superseded"]),
+  "artifact": zod171.unknown().describe("The stage artifact under review: the locked ComposePlan at content; the composition wire shape at layout/motion; the judged composition snapshot on kind:'score'."),
+  "stillUrls": zod171.array(zod171.string()).optional().describe("Presigned storyboard/eval stills \u2014 the packet's visual evidence (may be GC'd by the retention sweep after the job goes terminal; the decision record is immortal)."),
+  "criticVerdicts": zod171.unknown().optional().describe("Per-criterion scores + critique from the design loop / judge, incl. lock_violation entries."),
   "quote": CheckpointQuote.optional(),
-  "revisionCycle": zod170.int().min(reviewPacketResponseRevisionCycleMin).max(reviewPacketResponseRevisionCycleMax).describe("Revise cycles this gate has consumed. The brief quote states the included count (revisionCyclesIncluded); beyond it, resume(revise) is refused with a typed error."),
-  "decision": zod170.unknown().optional().describe("The recorded decision {decision, comments?, globalNote?, decidedAt} once resolved."),
-  "reviewMode": zod170.enum(["agent", "hosted"]).optional().describe("How this packet is decided (from the Brief's gates). 'hosted' = the review PAGE captures the decision; absent/'agent' = the decision flows back through the driving agent."),
-  "createdAt": zod170.number(),
-  "updatedAt": zod170.number(),
-  "versionStack": zod170.array(zod170.strictObject({
-    "id": zod170.string(),
-    "version": zod170.int().min(reviewPacketResponseVersionStackItemVersionMin).max(reviewPacketResponseVersionStackItemVersionMax),
-    "stage": zod170.enum(["content", "layout", "motion"]).optional(),
-    "status": zod170.string(),
-    "decision": zod170.string().optional(),
-    "createdAt": zod170.number()
+  "revisionCycle": zod171.int().min(reviewPacketResponseRevisionCycleMin).max(reviewPacketResponseRevisionCycleMax).describe("Revise cycles this gate has consumed. The brief quote states the included count (revisionCyclesIncluded); beyond it, resume(revise) is refused with a typed error."),
+  "decision": zod171.unknown().optional().describe("The recorded decision {decision, comments?, globalNote?, decidedAt} once resolved."),
+  "reviewMode": zod171.enum(["agent", "hosted"]).optional().describe("How this packet is decided (from the Brief's gates). 'hosted' = the review PAGE captures the decision; absent/'agent' = the decision flows back through the driving agent."),
+  "createdAt": zod171.number(),
+  "updatedAt": zod171.number(),
+  "versionStack": zod171.array(zod171.strictObject({
+    "id": zod171.string(),
+    "version": zod171.int().min(reviewPacketResponseVersionStackItemVersionMin).max(reviewPacketResponseVersionStackItemVersionMax),
+    "stage": zod171.enum(["content", "layout", "motion"]).optional(),
+    "status": zod171.string(),
+    "decision": zod171.string().optional(),
+    "createdAt": zod171.number()
   })).describe("The run's v1\u2192vN gate history \u2014 per-version status + decision summaries.")
 });
 
 // ../sdk/src/generated/zod/models/scoreCompositionBody.zod.ts
-import * as zod171 from "zod";
-var ScoreCompositionBody = zod171.strictObject({
-  "composition": zod171.unknown().optional().describe("The composition to judge. Absent \u21D2 the project's ACTIVE composition."),
-  "compositionId": zod171.string().optional().describe("Judge a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
-  "session_id": zod171.string().optional().describe("Compose-session id: judge that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
-  "editorialIntent": zod171.string().optional(),
-  "brandContext": zod171.string().optional()
+import * as zod172 from "zod";
+var ScoreCompositionBody = zod172.strictObject({
+  "composition": zod172.unknown().optional().describe("The composition to judge. Absent \u21D2 the project's ACTIVE composition."),
+  "compositionId": zod172.string().optional().describe("Judge a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
+  "session_id": zod172.string().optional().describe("Compose-session id: judge that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
+  "editorialIntent": zod172.string().optional(),
+  "brandContext": zod172.string().optional()
 });
 
 // ../sdk/src/generated/zod/models/searchLibraryParams.zod.ts
-import * as zod172 from "zod";
+import * as zod173 from "zod";
 var searchLibraryParamsLimitDefault = 10;
 var searchLibraryParamsLimitMax = 25;
-var SearchLibraryParams = zod172.strictObject({
-  "q": zod172.string().min(1),
-  "limit": zod172.int().min(1).max(searchLibraryParamsLimitMax).default(searchLibraryParamsLimitDefault)
+var SearchLibraryParams = zod173.strictObject({
+  "q": zod173.string().min(1),
+  "limit": zod173.int().min(1).max(searchLibraryParamsLimitMax).default(searchLibraryParamsLimitDefault)
 });
 
 // ../sdk/src/generated/zod/models/selectorAudioSpan.zod.ts
-import * as zod173 from "zod";
-var SelectorAudioSpan = zod173.strictObject({
-  "startSec": zod173.number(),
-  "endSec": zod173.number(),
-  "candidateId": zod173.string().describe("The chosen audio source (the clearest mic) for this span \u2192 programAudioSourceId."),
-  "reasons": zod173.array(zod173.string())
+import * as zod174 from "zod";
+var SelectorAudioSpan = zod174.strictObject({
+  "startSec": zod174.number(),
+  "endSec": zod174.number(),
+  "candidateId": zod174.string().describe("The chosen audio source (the clearest mic) for this span \u2192 programAudioSourceId."),
+  "reasons": zod174.array(zod174.string())
 });
 
 // ../sdk/src/generated/zod/models/selectorCandidatesResponse.zod.ts
-import * as zod177 from "zod";
+import * as zod178 from "zod";
 
 // ../sdk/src/generated/zod/models/selectorCutSpan.zod.ts
-import * as zod174 from "zod";
-var SelectorCutSpan = zod174.strictObject({
-  "startSec": zod174.number(),
-  "endSec": zod174.number(),
-  "candidateId": zod174.string(),
-  "sourceInSec": zod174.number().describe("Chosen source window start (declared-offset resolved)."),
-  "sourceOutSec": zod174.number(),
-  "reasons": zod174.array(zod174.string())
+import * as zod175 from "zod";
+var SelectorCutSpan = zod175.strictObject({
+  "startSec": zod175.number(),
+  "endSec": zod175.number(),
+  "candidateId": zod175.string(),
+  "sourceInSec": zod175.number().describe("Chosen source window start (declared-offset resolved)."),
+  "sourceOutSec": zod175.number(),
+  "reasons": zod175.array(zod175.string())
 });
 
 // ../sdk/src/generated/zod/models/selectorMomentGroup.zod.ts
-import * as zod176 from "zod";
+import * as zod177 from "zod";
 
 // ../sdk/src/generated/zod/models/selectorScoredCandidate.zod.ts
-import * as zod175 from "zod";
-var SelectorScoredCandidate = zod175.strictObject({
-  "candidateId": zod175.string().describe("Stable angle/source id. An unknown id is rejected, never remapped."),
-  "role": zod175.string().nullish().describe('Agent-declared semantic tag (e.g. "wide", "webcam").'),
-  "score": zod175.number().describe("The weighted prominence score (\u03A3 weights\xB7signal)."),
-  "contributions": zod175.record(zod175.string(), zod175.number()).describe("signalKey \u2192 weighted contribution (the agent reweights from this)."),
-  "reasons": zod175.array(zod175.string())
+import * as zod176 from "zod";
+var SelectorScoredCandidate = zod176.strictObject({
+  "candidateId": zod176.string().describe("Stable angle/source id. An unknown id is rejected, never remapped."),
+  "role": zod176.string().nullish().describe('Agent-declared semantic tag (e.g. "wide", "webcam").'),
+  "score": zod176.number().describe("The weighted prominence score (\u03A3 weights\xB7signal)."),
+  "contributions": zod176.record(zod176.string(), zod176.number()).describe("signalKey \u2192 weighted contribution (the agent reweights from this)."),
+  "reasons": zod176.array(zod176.string())
 });
 
 // ../sdk/src/generated/zod/models/selectorMomentGroup.zod.ts
-var SelectorMomentGroup = zod176.strictObject({
-  "startSec": zod176.number().describe("Span start (output seconds)."),
-  "endSec": zod176.number().describe("Span end (output seconds)."),
-  "chosen": zod176.string().describe('The recommended candidateId, or "__hold__" (abstain).'),
-  "pacingNote": zod176.string().nullish().describe("Which mechanism produced the pick (argmax / hysteresis / override / hold \u2026)."),
-  "candidates": zod176.array(SelectorScoredCandidate)
+var SelectorMomentGroup = zod177.strictObject({
+  "startSec": zod177.number().describe("Span start (output seconds)."),
+  "endSec": zod177.number().describe("Span end (output seconds)."),
+  "chosen": zod177.string().describe('The recommended candidateId, or "__hold__" (abstain).'),
+  "pacingNote": zod177.string().nullish().describe("Which mechanism produced the pick (argmax / hysteresis / override / hold \u2026)."),
+  "candidates": zod177.array(SelectorScoredCandidate)
 });
 
 // ../sdk/src/generated/zod/models/selectorCandidatesResponse.zod.ts
-var SelectorCandidatesResponse = zod177.strictObject({
-  "projectId": zod177.string(),
-  "groupId": zod177.string(),
-  "selectorVersion": zod177.string(),
-  "signalVersions": zod177.record(zod177.string(), zod177.string()),
-  "moments": zod177.array(SelectorMomentGroup),
-  "recommendation": zod177.strictObject({
-    "cutSchedule": zod177.array(SelectorCutSpan),
-    "audioBed": zod177.array(SelectorAudioSpan).describe("Best-audio bed (instance #3): the clearest mic per span."),
-    "suppressedSwitches": zod177.array(zod177.strictObject({
-      "atSec": zod177.number(),
-      "wouldHaveBeenCandidateId": zod177.string(),
-      "byScore": zod177.number(),
-      "blockedBy": zod177.string(),
-      "releaseAtSec": zod177.number().nullable()
+var SelectorCandidatesResponse = zod178.strictObject({
+  "projectId": zod178.string(),
+  "groupId": zod178.string(),
+  "selectorVersion": zod178.string(),
+  "signalVersions": zod178.record(zod178.string(), zod178.string()),
+  "moments": zod178.array(SelectorMomentGroup),
+  "recommendation": zod178.strictObject({
+    "cutSchedule": zod178.array(SelectorCutSpan),
+    "audioBed": zod178.array(SelectorAudioSpan).describe("Best-audio bed (instance #3): the clearest mic per span."),
+    "suppressedSwitches": zod178.array(zod178.strictObject({
+      "atSec": zod178.number(),
+      "wouldHaveBeenCandidateId": zod178.string(),
+      "byScore": zod178.number(),
+      "blockedBy": zod178.string(),
+      "releaseAtSec": zod178.number().nullable()
     })).describe("Switches the stabilizer suppressed (the anti-ping-pong audit).")
   }),
-  "divergesFromComposition": zod177.boolean().optional()
+  "divergesFromComposition": zod178.boolean().optional()
 }).describe("Selector (switch) candidates + recommendation for a synced-angle group. Every candidate carries score + contributions + reasons so the agent reweights from evidence; the recommendation is the lowered cut schedule + best-audio bed.");
 
 // ../sdk/src/generated/zod/models/selectorPreviewRequest.zod.ts
-import * as zod178 from "zod";
+import * as zod179 from "zod";
 var selectorPreviewRequestMinHoldSecExclusiveMin = 0;
 var selectorPreviewRequestEnterSecMin = 0;
 var selectorPreviewRequestSwitchMarginMin = 0;
 var selectorPreviewRequestCooldownSecMin = 0;
 var selectorPreviewRequestMaxHoldSecExclusiveMin = 0;
-var SelectorPreviewRequest = zod178.strictObject({
-  "groupId": zod178.string().min(1),
-  "weights": zod178.record(zod178.string(), zod178.number()).optional().describe("Sparse prominence weights (the taste knob, non-negative). Default = DOMINANCE_WEIGHTS."),
-  "minHoldSec": zod178.number().gt(selectorPreviewRequestMinHoldSecExclusiveMin).optional(),
-  "enterSec": zod178.number().min(selectorPreviewRequestEnterSecMin).optional(),
-  "switchMargin": zod178.number().min(selectorPreviewRequestSwitchMarginMin).optional(),
-  "cooldownSec": zod178.number().min(selectorPreviewRequestCooldownSecMin).optional(),
-  "maxHoldSec": zod178.number().gt(selectorPreviewRequestMaxHoldSecExclusiveMin).optional(),
-  "lockSourceId": zod178.string().optional().describe("Pin a camera/angle for the whole timeline."),
-  "overrides": zod178.array(zod178.strictObject({
-    "startSec": zod178.number(),
-    "endSec": zod178.number(),
-    "candidateId": zod178.string()
+var SelectorPreviewRequest = zod179.strictObject({
+  "groupId": zod179.string().min(1),
+  "weights": zod179.record(zod179.string(), zod179.number()).optional().describe("Sparse prominence weights (the taste knob, non-negative). Default = DOMINANCE_WEIGHTS."),
+  "minHoldSec": zod179.number().gt(selectorPreviewRequestMinHoldSecExclusiveMin).optional(),
+  "enterSec": zod179.number().min(selectorPreviewRequestEnterSecMin).optional(),
+  "switchMargin": zod179.number().min(selectorPreviewRequestSwitchMarginMin).optional(),
+  "cooldownSec": zod179.number().min(selectorPreviewRequestCooldownSecMin).optional(),
+  "maxHoldSec": zod179.number().gt(selectorPreviewRequestMaxHoldSecExclusiveMin).optional(),
+  "lockSourceId": zod179.string().optional().describe("Pin a camera/angle for the whole timeline."),
+  "overrides": zod179.array(zod179.strictObject({
+    "startSec": zod179.number(),
+    "endSec": zod179.number(),
+    "candidateId": zod179.string()
   })).optional()
 });
 
 // ../sdk/src/generated/zod/models/sessionCreateRequest.zod.ts
-import * as zod179 from "zod";
+import * as zod180 from "zod";
 var sessionCreateRequestNameMax = 200;
 var sessionCreateRequestFilesItemRoleMax = 50;
 var sessionCreateRequestFilesMax = 20;
-var SessionCreateRequest = zod179.strictObject({
-  "name": zod179.string().min(1).max(sessionCreateRequestNameMax),
-  "files": zod179.array(zod179.strictObject({
-    "mediaId": zod179.string().min(1),
-    "role": zod179.string().min(1).max(sessionCreateRequestFilesItemRoleMax)
+var SessionCreateRequest = zod180.strictObject({
+  "name": zod180.string().min(1).max(sessionCreateRequestNameMax),
+  "files": zod180.array(zod180.strictObject({
+    "mediaId": zod180.string().min(1),
+    "role": zod180.string().min(1).max(sessionCreateRequestFilesItemRoleMax)
   })).min(1).max(sessionCreateRequestFilesMax)
 }).describe("POST /sessions body.");
 
 // ../sdk/src/generated/zod/models/sessionFileEntry.zod.ts
-import * as zod180 from "zod";
-var SessionFileEntry = zod180.strictObject({
-  "mediaId": zod180.string(),
-  "role": zod180.string(),
-  "status": zod180.string().nullable()
+import * as zod181 from "zod";
+var SessionFileEntry = zod181.strictObject({
+  "mediaId": zod181.string(),
+  "role": zod181.string(),
+  "status": zod181.string().nullable()
 }).describe("One file member of a session, with optional role + status.");
 
 // ../sdk/src/generated/zod/models/sessionListResponse.zod.ts
-import * as zod182 from "zod";
+import * as zod183 from "zod";
 
 // ../sdk/src/generated/zod/models/sessionSummary.zod.ts
-import * as zod181 from "zod";
+import * as zod182 from "zod";
 var sessionSummaryFileCountMin = 0;
 var sessionSummaryFileCountMax = 9007199254740991;
-var SessionSummary = zod181.strictObject({
-  "id": zod181.string(),
-  "name": zod181.string(),
-  "fileCount": zod181.int().min(sessionSummaryFileCountMin).max(sessionSummaryFileCountMax),
-  "muxStatus": zod181.string().nullable(),
-  "createdAt": zod181.string()
+var SessionSummary = zod182.strictObject({
+  "id": zod182.string(),
+  "name": zod182.string(),
+  "fileCount": zod182.int().min(sessionSummaryFileCountMin).max(sessionSummaryFileCountMax),
+  "muxStatus": zod182.string().nullable(),
+  "createdAt": zod182.string()
 }).describe("Session list summary (per list endpoint).");
 
 // ../sdk/src/generated/zod/models/sessionListResponse.zod.ts
-var SessionListResponse = zod182.strictObject({
-  "data": zod182.array(SessionSummary),
+var SessionListResponse = zod183.strictObject({
+  "data": zod183.array(SessionSummary),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/sessionResponse.zod.ts
-import * as zod183 from "zod";
-var SessionResponse = zod183.strictObject({
-  "id": zod183.string(),
-  "name": zod183.string(),
-  "files": zod183.array(SessionFileEntry),
-  "mux": zod183.strictObject({
-    "status": zod183.string().nullable(),
-    "jobId": zod183.string().nullable(),
-    "muxedItems": zod183.union([zod183.record(zod183.string(), zod183.string()), zod183.null()]),
-    "error": zod183.string().nullable(),
-    "startedAt": zod183.string().nullable(),
-    "completedAt": zod183.string().nullable()
+import * as zod184 from "zod";
+var SessionResponse = zod184.strictObject({
+  "id": zod184.string(),
+  "name": zod184.string(),
+  "files": zod184.array(SessionFileEntry),
+  "mux": zod184.strictObject({
+    "status": zod184.string().nullable(),
+    "jobId": zod184.string().nullable(),
+    "muxedItems": zod184.union([zod184.record(zod184.string(), zod184.string()), zod184.null()]),
+    "error": zod184.string().nullable(),
+    "startedAt": zod184.string().nullable(),
+    "completedAt": zod184.string().nullable()
   }),
-  "createdAt": zod183.string()
+  "createdAt": zod184.string()
 }).describe("Session response per \xA7Sessions.");
 
 // ../sdk/src/generated/zod/models/skillListResponse.zod.ts
-import * as zod185 from "zod";
+import * as zod186 from "zod";
 
 // ../sdk/src/generated/zod/models/skillSummary.zod.ts
-import * as zod184 from "zod";
-var SkillSummary = zod184.strictObject({
-  "name": zod184.string(),
-  "title": zod184.string(),
-  "description": zod184.string()
+import * as zod185 from "zod";
+var SkillSummary = zod185.strictObject({
+  "name": zod185.string(),
+  "title": zod185.string(),
+  "description": zod185.string()
 }).describe("A CueFrame agent skill (metadata).");
 
 // ../sdk/src/generated/zod/models/skillListResponse.zod.ts
-var SkillListResponse = zod185.strictObject({
-  "skills": zod185.array(SkillSummary)
+var SkillListResponse = zod186.strictObject({
+  "skills": zod186.array(SkillSummary)
 }).describe("GET /skills response \u2014 the available agent skills.");
 
 // ../sdk/src/generated/zod/models/subjectDetectionTriggerResponse.zod.ts
-import * as zod186 from "zod";
-var SubjectDetectionTriggerResponse = zod186.strictObject({
-  "factId": zod186.string().describe("Opaque identifier for the derived fact."),
-  "status": zod186.enum(["pending", "ready", "failed"]).describe("State of the fact right now. `ready` with `alreadyExisted` means the detection was already computed and is available immediately."),
-  "quotedUsd": zod186.number().describe("The server's price for this detection, in USD, quoted from the source duration. Zero is charged when `alreadyExisted` is true."),
-  "alreadyExisted": zod186.boolean().describe("True when this exact detection was already pending or ready. Nothing was dispatched and nothing will be charged \u2014 the same fact is served twice for one price.")
+import * as zod187 from "zod";
+var SubjectDetectionTriggerResponse = zod187.strictObject({
+  "factId": zod187.string().describe("Opaque identifier for the derived fact."),
+  "status": zod187.enum(["pending", "ready", "failed"]).describe("State of the fact right now. `ready` with `alreadyExisted` means the detection was already computed and is available immediately."),
+  "quotedUsd": zod187.number().describe("The server's price for this detection, in USD, quoted from the source duration. Zero is charged when `alreadyExisted` is true."),
+  "alreadyExisted": zod187.boolean().describe("True when this exact detection was already pending or ready. Nothing was dispatched and nothing will be charged \u2014 the same fact is served twice for one price.")
 }).describe("POST /media/:id/detect-subjects response \u2014 the claimed perception fact.");
 
 // ../sdk/src/generated/zod/models/suggestion.zod.ts
-import * as zod187 from "zod";
+import * as zod188 from "zod";
 var suggestionRankExclusiveMin = 0;
 var suggestionRankMax = 9007199254740991;
-var Suggestion = zod187.strictObject({
-  "id": zod187.string(),
-  "briefId": zod187.string().nullable(),
-  "rank": zod187.int().gt(suggestionRankExclusiveMin).max(suggestionRankMax),
-  "trim": zod187.strictObject({
-    "start": zod187.number(),
-    "end": zod187.number()
+var Suggestion = zod188.strictObject({
+  "id": zod188.string(),
+  "briefId": zod188.string().nullable(),
+  "rank": zod188.int().gt(suggestionRankExclusiveMin).max(suggestionRankMax),
+  "trim": zod188.strictObject({
+    "start": zod188.number(),
+    "end": zod188.number()
   }),
-  "score": zod187.number(),
-  "title": zod187.string(),
-  "reason": zod187.string(),
-  "topic": zod187.string(),
-  "hook": zod187.string(),
-  "platforms": zod187.array(zod187.string()),
-  "format": zod187.string(),
-  "caption": zod187.string(),
-  "hashtags": zod187.array(zod187.string()),
-  "textOverlays": zod187.array(zod187.string()),
-  "editingNotes": zod187.string(),
-  "motionStyle": zod187.strictObject({
-    "textAnimation": zod187.string(),
-    "transitions": zod187.string(),
-    "colorMood": zod187.string(),
-    "captionStyle": zod187.string()
+  "score": zod188.number(),
+  "title": zod188.string(),
+  "reason": zod188.string(),
+  "topic": zod188.string(),
+  "hook": zod188.string(),
+  "platforms": zod188.array(zod188.string()),
+  "format": zod188.string(),
+  "caption": zod188.string(),
+  "hashtags": zod188.array(zod188.string()),
+  "textOverlays": zod188.array(zod188.string()),
+  "editingNotes": zod188.string(),
+  "motionStyle": zod188.strictObject({
+    "textAnimation": zod188.string(),
+    "transitions": zod188.string(),
+    "colorMood": zod188.string(),
+    "captionStyle": zod188.string()
   }),
-  "visualTreatment": zod187.array(zod187.strictObject({
-    "time": zod187.union([zod187.number(), zod187.string()]),
-    "visual": zod187.string()
+  "visualTreatment": zod188.array(zod188.strictObject({
+    "time": zod188.union([zod188.number(), zod188.string()]),
+    "visual": zod188.string()
   })),
-  "brollSuggestions": zod187.array(zod187.strictObject({
-    "moment": zod187.string(),
-    "searchTerms": zod187.array(zod187.string()),
-    "rationale": zod187.string()
+  "brollSuggestions": zod188.array(zod188.strictObject({
+    "moment": zod188.string(),
+    "searchTerms": zod188.array(zod188.string()),
+    "rationale": zod188.string()
   })),
-  "thumbnailConcept": zod187.string()
+  "thumbnailConcept": zod188.string()
 }).describe("Single ranked clip suggestion.");
 
 // ../sdk/src/generated/zod/models/suggestionsEnvelope.zod.ts
-import * as zod188 from "zod";
-var SuggestionsEnvelope = zod188.strictObject({
-  "status": zod188.enum(["idle", "generating", "completed", "failed"]),
-  "createdAt": zod188.string().nullable(),
-  "analyzedAt": zod188.string().nullable(),
-  "jobId": zod188.string().nullable(),
-  "topics": zod188.array(zod188.string()),
-  "suggestions": zod188.array(Suggestion),
+import * as zod189 from "zod";
+var SuggestionsEnvelope = zod189.strictObject({
+  "status": zod189.enum(["idle", "generating", "completed", "failed"]),
+  "createdAt": zod189.string().nullable(),
+  "analyzedAt": zod189.string().nullable(),
+  "jobId": zod189.string().nullable(),
+  "topics": zod189.array(zod189.string()),
+  "suggestions": zod189.array(Suggestion),
   "pagination": PaginationMeta
 }).describe("GET /media/:id/suggestions envelope.");
 
 // ../sdk/src/generated/zod/models/suggestionsTriggerResponse.zod.ts
-import * as zod189 from "zod";
-var SuggestionsTriggerResponse = zod189.strictObject({
-  "status": zod189.enum(["queued", "running", "complete", "failed"]),
-  "alreadyRunning": zod189.boolean().optional()
+import * as zod190 from "zod";
+var SuggestionsTriggerResponse = zod190.strictObject({
+  "status": zod190.enum(["queued", "running", "complete", "failed"]),
+  "alreadyRunning": zod190.boolean().optional()
 }).describe("POST /media/:id/suggestions response.");
 
 // ../sdk/src/generated/zod/models/timelineAnalysisRequest.zod.ts
-import * as zod190 from "zod";
+import * as zod191 from "zod";
 var timelineAnalysisRequestWordsItemTextMax = 1e3;
 var timelineAnalysisRequestWordsItemTimelineStartMin = 0;
 var timelineAnalysisRequestWordsItemTimelineEndMin = 0;
@@ -8257,258 +8266,258 @@ var timelineAnalysisRequestWordsItemSourceStartMin = 0;
 var timelineAnalysisRequestWordsItemSourceEndMin = 0;
 var timelineAnalysisRequestWordsItemSpeakerIdOneMax = 256;
 var timelineAnalysisRequestWordsMax = 12e3;
-var TimelineAnalysisRequest = zod190.strictObject({
-  "words": zod190.array(zod190.strictObject({
-    "text": zod190.string().min(1).max(timelineAnalysisRequestWordsItemTextMax),
-    "timelineStart": zod190.number().min(timelineAnalysisRequestWordsItemTimelineStartMin),
-    "timelineEnd": zod190.number().min(timelineAnalysisRequestWordsItemTimelineEndMin),
-    "clipId": zod190.string().min(1).max(timelineAnalysisRequestWordsItemClipIdMax),
-    "poolItemId": zod190.string().min(1).max(timelineAnalysisRequestWordsItemPoolItemIdMax),
-    "sourceStart": zod190.number().min(timelineAnalysisRequestWordsItemSourceStartMin),
-    "sourceEnd": zod190.number().min(timelineAnalysisRequestWordsItemSourceEndMin),
-    "speakerId": zod190.union([zod190.string().max(timelineAnalysisRequestWordsItemSpeakerIdOneMax), zod190.null()])
+var TimelineAnalysisRequest = zod191.strictObject({
+  "words": zod191.array(zod191.strictObject({
+    "text": zod191.string().min(1).max(timelineAnalysisRequestWordsItemTextMax),
+    "timelineStart": zod191.number().min(timelineAnalysisRequestWordsItemTimelineStartMin),
+    "timelineEnd": zod191.number().min(timelineAnalysisRequestWordsItemTimelineEndMin),
+    "clipId": zod191.string().min(1).max(timelineAnalysisRequestWordsItemClipIdMax),
+    "poolItemId": zod191.string().min(1).max(timelineAnalysisRequestWordsItemPoolItemIdMax),
+    "sourceStart": zod191.number().min(timelineAnalysisRequestWordsItemSourceStartMin),
+    "sourceEnd": zod191.number().min(timelineAnalysisRequestWordsItemSourceEndMin),
+    "speakerId": zod191.union([zod191.string().max(timelineAnalysisRequestWordsItemSpeakerIdOneMax), zod191.null()])
   })).min(1).max(timelineAnalysisRequestWordsMax)
 }).describe("A bounded merged timeline transcript for CueFrame edit analysis. The server selects the model; clients cannot provide a provider, API key, or model override.");
 
 // ../sdk/src/generated/zod/models/timelineAnalysisResponse.zod.ts
-import * as zod191 from "zod";
+import * as zod192 from "zod";
 var timelineAnalysisResponseFillersItemMin = 0;
 var timelineAnalysisResponseFillersItemMax = 9007199254740991;
 var timelineAnalysisResponseSilenceGapsItemMin = 0;
 var timelineAnalysisResponseSilenceGapsItemMax = 9007199254740991;
 var timelineAnalysisResponseEmphasisItemMin = 0;
 var timelineAnalysisResponseEmphasisItemMax = 9007199254740991;
-var TimelineAnalysisResponse = zod191.strictObject({
-  "fillers": zod191.array(zod191.int().min(timelineAnalysisResponseFillersItemMin).max(timelineAnalysisResponseFillersItemMax)),
-  "silenceGaps": zod191.array(zod191.int().min(timelineAnalysisResponseSilenceGapsItemMin).max(timelineAnalysisResponseSilenceGapsItemMax)),
-  "emphasis": zod191.array(zod191.int().min(timelineAnalysisResponseEmphasisItemMin).max(timelineAnalysisResponseEmphasisItemMax))
+var TimelineAnalysisResponse = zod192.strictObject({
+  "fillers": zod192.array(zod192.int().min(timelineAnalysisResponseFillersItemMin).max(timelineAnalysisResponseFillersItemMax)),
+  "silenceGaps": zod192.array(zod192.int().min(timelineAnalysisResponseSilenceGapsItemMin).max(timelineAnalysisResponseSilenceGapsItemMax)),
+  "emphasis": zod192.array(zod192.int().min(timelineAnalysisResponseEmphasisItemMin).max(timelineAnalysisResponseEmphasisItemMax))
 }).describe("CueFrame-model analysis of timeline word indices. Every returned index refers to the request's words array.");
 
 // ../sdk/src/generated/zod/models/traceScoresRequest.zod.ts
-import * as zod192 from "zod";
+import * as zod193 from "zod";
 var traceScoresRequestScoresItemNameMax = 64;
 var traceScoresRequestScoresItemNameRegExp = new RegExp("^[a-z][a-z0-9_]*$");
 var traceScoresRequestScoresItemValueMin = 0;
 var traceScoresRequestScoresItemValueMax = 1;
 var traceScoresRequestScoresItemCommentMax = 500;
 var traceScoresRequestScoresMax = 10;
-var TraceScoresRequest = zod192.strictObject({
-  "scores": zod192.array(zod192.strictObject({
-    "name": zod192.string().min(1).max(traceScoresRequestScoresItemNameMax).regex(traceScoresRequestScoresItemNameRegExp),
-    "value": zod192.number().min(traceScoresRequestScoresItemValueMin).max(traceScoresRequestScoresItemValueMax),
-    "comment": zod192.string().max(traceScoresRequestScoresItemCommentMax).optional()
+var TraceScoresRequest = zod193.strictObject({
+  "scores": zod193.array(zod193.strictObject({
+    "name": zod193.string().min(1).max(traceScoresRequestScoresItemNameMax).regex(traceScoresRequestScoresItemNameRegExp),
+    "value": zod193.number().min(traceScoresRequestScoresItemValueMin).max(traceScoresRequestScoresItemValueMax),
+    "comment": zod193.string().max(traceScoresRequestScoresItemCommentMax).optional()
   })).min(1).max(traceScoresRequestScoresMax)
 }).describe("POST /traces/:traceId/scores body.");
 
 // ../sdk/src/generated/zod/models/traceScoresResponse.zod.ts
-import * as zod193 from "zod";
+import * as zod194 from "zod";
 var traceScoresResponseAcceptedMin = -9007199254740991;
 var traceScoresResponseAcceptedMax = 9007199254740991;
-var TraceScoresResponse = zod193.strictObject({
-  "accepted": zod193.int().min(traceScoresResponseAcceptedMin).max(traceScoresResponseAcceptedMax)
+var TraceScoresResponse = zod194.strictObject({
+  "accepted": zod194.int().min(traceScoresResponseAcceptedMin).max(traceScoresResponseAcceptedMax)
 }).describe("POST /traces/:traceId/scores response.");
 
 // ../sdk/src/generated/zod/models/transcriptAnalyzeRequest.zod.ts
-import * as zod194 from "zod";
+import * as zod195 from "zod";
 var transcriptAnalyzeRequestWindowStartSecMin = 0;
 var transcriptAnalyzeRequestWindowEndSecMin = 0;
-var TranscriptAnalyzeRequest = zod194.strictObject({
-  "task": zod194.enum(["summary", "chapters", "highlights"]).describe("What to ask of the transcript. `summary` \u2014 prose: the argument plus the concrete takeaways as bullets. `chapters` \u2014 one line per subject change, `[h:mm:ss] Title \u2014 description`. `highlights` \u2014 up to 8 standalone moments, strongest first, one line each as `[h:mm:ss]-[h:mm:ss] Title \u2014 why it lands` plus the line that carries it. Every timestamp is ABSOLUTE seconds from the start of the media, including when you pass a `window`, and every one is verified against the transcript before you see it \u2014 but they are LINE-START markers about 15s apart, so treat a span as APPROXIMATE (up to 15s early) and refine it against the word timings from GET /v1/media/{id}/context before you cut."),
-  "window": zod194.strictObject({
-    "startSec": zod194.number().min(transcriptAnalyzeRequestWindowStartSecMin).describe("Window start, SECONDS from the start of the media."),
-    "endSec": zod194.number().min(transcriptAnalyzeRequestWindowEndSecMin).describe("Window end, SECONDS from the start of the media.")
+var TranscriptAnalyzeRequest = zod195.strictObject({
+  "task": zod195.enum(["summary", "chapters", "highlights"]).describe("What to ask of the transcript. `summary` \u2014 prose: the argument plus the concrete takeaways as bullets. `chapters` \u2014 one line per subject change, `[h:mm:ss] Title \u2014 description`. `highlights` \u2014 up to 8 standalone moments, strongest first, one line each as `[h:mm:ss]-[h:mm:ss] Title \u2014 why it lands` plus the line that carries it. Every timestamp is ABSOLUTE seconds from the start of the media, including when you pass a `window`, and every one is verified against the transcript before you see it \u2014 but they are LINE-START markers about 15s apart, so treat a span as APPROXIMATE (up to 15s early) and refine it against the word timings from GET /v1/media/{id}/context before you cut."),
+  "window": zod195.strictObject({
+    "startSec": zod195.number().min(transcriptAnalyzeRequestWindowStartSecMin).describe("Window start, SECONDS from the start of the media."),
+    "endSec": zod195.number().min(transcriptAnalyzeRequestWindowEndSecMin).describe("Window end, SECONDS from the start of the media.")
   }).optional().describe("Analyse only this slice of the transcript. Omit to analyse all of it. Words are windowed exactly as captions.fromTranscript windows them (a word straddling an edge is clamped, a word wholly outside is dropped). Use this when a long recording is rejected with `transcript_too_long`, and to chapter a single segment of a podcast without paying for the whole thing.")
 }).describe("One editorial question about a media item's transcript.");
 
 // ../sdk/src/generated/zod/models/transcriptAnalyzeResponse.zod.ts
-import * as zod195 from "zod";
-var TranscriptAnalyzeResponse = zod195.strictObject({
-  "task": zod195.enum(["summary", "chapters", "highlights"]).describe("Echo of the requested task \u2014 so a batched caller can pair answers to asks."),
-  "result": zod195.string().describe("The answer, as text. `summary` is prose; `chapters` and `highlights` are one record per LINE in the shape documented on the request's `task` field \u2014 split on newlines to parse them. Timestamps are absolute seconds from the start of the media and every one is CHECKED against the transcript before the response is returned (a fabricated timestamp fails the call rather than shipping), but they are line-start markers about 15s apart \u2014 a boundary can sit up to 15s BEFORE the moment you want. Use them to locate, not to cut: refine against the word timings in GET /v1/media/{id}/context.")
+import * as zod196 from "zod";
+var TranscriptAnalyzeResponse = zod196.strictObject({
+  "task": zod196.enum(["summary", "chapters", "highlights"]).describe("Echo of the requested task \u2014 so a batched caller can pair answers to asks."),
+  "result": zod196.string().describe("The answer, as text. `summary` is prose; `chapters` and `highlights` are one record per LINE in the shape documented on the request's `task` field \u2014 split on newlines to parse them. Timestamps are absolute seconds from the start of the media and every one is CHECKED against the transcript before the response is returned (a fabricated timestamp fails the call rather than shipping), but they are line-start markers about 15s apart \u2014 a boundary can sit up to 15s BEFORE the moment you want. Use them to locate, not to cut: refine against the word timings in GET /v1/media/{id}/context.")
 }).describe("The analysis of one media item's transcript. Metered: this is a real LLM call, billed on measured token spend, so it is not a read to poll.");
 
 // ../sdk/src/generated/zod/models/triggerSubjectDetectionParams.zod.ts
-import * as zod196 from "zod";
-var TriggerSubjectDetectionParams = zod196.strictObject({
-  "detector": zod196.enum(["face", "person"]).optional()
+import * as zod197 from "zod";
+var TriggerSubjectDetectionParams = zod197.strictObject({
+  "detector": zod197.enum(["face", "person"]).optional()
 });
 
 // ../sdk/src/generated/zod/models/uploadTokenResponse.zod.ts
-import * as zod197 from "zod";
+import * as zod198 from "zod";
 var uploadTokenResponseExpiresAtMin = -9007199254740991;
 var uploadTokenResponseExpiresAtMax = 9007199254740991;
-var UploadTokenResponse = zod197.strictObject({
-  "token": zod197.string(),
-  "expiresAt": zod197.int().min(uploadTokenResponseExpiresAtMin).max(uploadTokenResponseExpiresAtMax).describe("Expiry, ms since epoch (~30 min TTL).")
+var UploadTokenResponse = zod198.strictObject({
+  "token": zod198.string(),
+  "expiresAt": zod198.int().min(uploadTokenResponseExpiresAtMin).max(uploadTokenResponseExpiresAtMax).describe("Expiry, ms since epoch (~30 min TTL).")
 }).describe("POST /uploads/token response: a short-lived token for the signed upload lane (the upload-signing worker's `uppy-auth-token` header). The org is derived from the session server-side and stamped into the token.");
 
 // ../sdk/src/generated/zod/models/usageEventResponse.zod.ts
-import * as zod198 from "zod";
-var UsageEventResponse = zod198.strictObject({
-  "featureId": zod198.string().describe("The metered plan feature (exports, compose, compose_verify, \u2026)."),
-  "value": zod198.number().optional().describe("Metered amount, in the feature's own unit (exports = render-minutes, storage = GB). Absent for a discrete single use, AND deliberately absent on the cost-plus lines (compose, generate, ai_tokens, compose_verify) whose internal metered unit is not a quantity \u2014 read `listUsd` for what those events cost you."),
-  "projectId": zod198.string().optional(),
-  "jobId": zod198.string().optional().describe("The job that produced the meter: a render/compose/preview job id, a media id (transcription, generate), or a clip-suggestion run id (jobKind `suggestions` \u2014 see `mediaItemId` for the media it analyzed)."),
-  "jobKind": zod198.string().optional().describe("render | compose | consult_* | verify | preview | generate | suggestions | session_uptime | \u2026"),
-  "mediaItemId": zod198.string().optional().describe("The media item the job ran over, when it ran over one (suggestions, transcription). Resolve it with GET /v1/media/{id}."),
-  "listUsd": zod198.number().optional().describe("LIST price of this metered event, USD. Honest naming: the invoice may zero it inside a plan allowance \u2014 this is the event's list price, not a Stripe line item."),
-  "createdAt": zod198.number().describe("Epoch-ms when the meter landed.")
+import * as zod199 from "zod";
+var UsageEventResponse = zod199.strictObject({
+  "featureId": zod199.string().describe("The metered plan feature (exports, compose, compose_verify, \u2026)."),
+  "value": zod199.number().optional().describe("Metered amount, in the feature's own unit (exports = render-minutes, storage = GB). Absent for a discrete single use, AND deliberately absent on the cost-plus lines (compose, generate, ai_tokens, compose_verify) whose internal metered unit is not a quantity \u2014 read `listUsd` for what those events cost you."),
+  "projectId": zod199.string().optional(),
+  "jobId": zod199.string().optional().describe("The job that produced the meter: a render/compose/preview job id, a media id (transcription, generate), or a clip-suggestion run id (jobKind `suggestions` \u2014 see `mediaItemId` for the media it analyzed)."),
+  "jobKind": zod199.string().optional().describe("render | compose | consult_* | verify | preview | generate | suggestions | session_uptime | \u2026"),
+  "mediaItemId": zod199.string().optional().describe("The media item the job ran over, when it ran over one (suggestions, transcription). Resolve it with GET /v1/media/{id}."),
+  "listUsd": zod199.number().optional().describe("LIST price of this metered event, USD. Honest naming: the invoice may zero it inside a plan allowance \u2014 this is the event's list price, not a Stripe line item."),
+  "createdAt": zod199.number().describe("Epoch-ms when the meter landed.")
 });
 
 // ../sdk/src/generated/zod/models/usageListResponse.zod.ts
-import * as zod199 from "zod";
-var UsageListResponse = zod199.strictObject({
-  "data": zod199.array(UsageEventResponse),
+import * as zod200 from "zod";
+var UsageListResponse = zod200.strictObject({
+  "data": zod200.array(UsageEventResponse),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/validateComposition200.zod.ts
-import * as zod200 from "zod";
-var ValidateComposition200 = zod200.strictObject({
-  "valid": zod200.boolean(),
-  "errors": zod200.array(zod200.strictObject({
-    "code": zod200.string(),
-    "stage": zod200.string(),
-    "category": zod200.string(),
-    "retryable": zod200.boolean(),
-    "message": zod200.string(),
-    "fix": zod200.record(zod200.string(), zod200.unknown()).optional()
+import * as zod201 from "zod";
+var ValidateComposition200 = zod201.strictObject({
+  "valid": zod201.boolean(),
+  "errors": zod201.array(zod201.strictObject({
+    "code": zod201.string(),
+    "stage": zod201.string(),
+    "category": zod201.string(),
+    "retryable": zod201.boolean(),
+    "message": zod201.string(),
+    "fix": zod201.record(zod201.string(), zod201.unknown()).optional()
   })),
-  "advisories": zod200.array(zod200.strictObject({
-    "rule": zod200.string(),
-    "criterion": zod200.string(),
-    "clipId": zod200.string().optional(),
-    "detail": zod200.string(),
-    "fix": zod200.string()
+  "advisories": zod201.array(zod201.strictObject({
+    "rule": zod201.string(),
+    "criterion": zod201.string(),
+    "clipId": zod201.string().optional(),
+    "detail": zod201.string(),
+    "fix": zod201.string()
   })).describe("Deterministic, render-free QUALITY floors (the SAME named defects the Director's in-loop verify and score_composition surface: static-hold, caption-spine, sfx-density, sfx-speech-collision, bed-coverage, audio-role). NON-blocking \u2014 they never flip `valid` (an editorially-weak composition still renders); fix them for quality, not to save. Empty when the composition is clean or the wire shape failed (they need a parsed composition)."),
-  "warnings": zod200.array(zod200.string()).optional().describe("Non-blocking render-fidelity warnings detected before enqueue, including unavailable font families."),
-  "quote": zod200.strictObject({
-    "thisStepUsd": zod200.number(),
-    "jobSpendSoFarUsd": zod200.number(),
-    "estimatedJourneyTotalUsd": zod200.number()
+  "warnings": zod201.array(zod201.string()).optional().describe("Non-blocking render-fidelity warnings detected before enqueue, including unavailable font families."),
+  "quote": zod201.strictObject({
+    "thisStepUsd": zod201.number(),
+    "jobSpendSoFarUsd": zod201.number(),
+    "estimatedJourneyTotalUsd": zod201.number()
   }).describe("The A2 money triple for the commodity lane: validate is free; estimatedJourneyTotalUsd is the render price to finish from a valid composition \u2014 relay it BEFORE create_render.")
 });
 
 // ../sdk/src/generated/zod/models/webhookCreateRequest.zod.ts
-import * as zod202 from "zod";
+import * as zod203 from "zod";
 
 // ../sdk/src/generated/zod/models/webhookEvent.zod.ts
-import * as zod201 from "zod";
-var WebhookEvent = zod201.enum(["media.transcribed", "media.completed", "suggest.completed", "session.mux.complete", "session.mux.failed", "render.completed", "compose.completed", "checkpoint.ready", "project.updated", "composition.updated", "webhook.test"]);
+import * as zod202 from "zod";
+var WebhookEvent = zod202.enum(["media.transcribed", "media.completed", "suggest.completed", "session.mux.complete", "session.mux.failed", "render.completed", "compose.completed", "checkpoint.ready", "project.updated", "composition.updated", "webhook.test"]);
 
 // ../sdk/src/generated/zod/models/webhookCreateRequest.zod.ts
 var webhookCreateRequestSettleMsMin = 0;
 var webhookCreateRequestSettleMsMax = 6e4;
-var WebhookCreateRequest = zod202.strictObject({
-  "url": zod202.string().min(1),
-  "events": zod202.array(WebhookEvent).min(1),
-  "settleMs": zod202.int().min(webhookCreateRequestSettleMsMin).max(webhookCreateRequestSettleMsMax).optional()
+var WebhookCreateRequest = zod203.strictObject({
+  "url": zod203.string().min(1),
+  "events": zod203.array(WebhookEvent).min(1),
+  "settleMs": zod203.int().min(webhookCreateRequestSettleMsMin).max(webhookCreateRequestSettleMsMax).optional()
 }).describe("POST /webhooks body.");
 
 // ../sdk/src/generated/zod/models/webhookCreateResponse.zod.ts
-import * as zod203 from "zod";
+import * as zod204 from "zod";
 var webhookCreateResponseSettleMsMin = 0;
 var webhookCreateResponseSettleMsMax = 9007199254740991;
-var WebhookCreateResponse = zod203.strictObject({
-  "id": zod203.string(),
-  "url": zod203.url(),
-  "events": zod203.array(WebhookEvent),
-  "settleMs": zod203.int().min(webhookCreateResponseSettleMsMin).max(webhookCreateResponseSettleMsMax),
-  "enabled": zod203.boolean(),
-  "status": zod203.enum(["active", "pending"]).describe("active = ownership verified + receiving events; pending = challenge not echoed, inactive."),
-  "secret": zod203.string().describe("Standard Webhooks signing secret, format `whsec_<base64>`. Returned ONCE at create; rotate = delete + recreate. Every delivery carries `webhook-id`, `webhook-timestamp` (unix seconds), and `webhook-signature: v1,<base64>` (HMAC-SHA256 over `{id}.{timestamp}.{rawBody}`). Verify with any Standard-Webhooks library (`standardwebhooks` / `svix`): `new Webhook(secret).verify(rawBody, headers)`."),
-  "verification": zod203.strictObject({
-    "status": zod203.literal("pending"),
-    "reason": zod203.string()
+var WebhookCreateResponse = zod204.strictObject({
+  "id": zod204.string(),
+  "url": zod204.url(),
+  "events": zod204.array(WebhookEvent),
+  "settleMs": zod204.int().min(webhookCreateResponseSettleMsMin).max(webhookCreateResponseSettleMsMax),
+  "enabled": zod204.boolean(),
+  "status": zod204.enum(["active", "pending"]).describe("active = ownership verified + receiving events; pending = challenge not echoed, inactive."),
+  "secret": zod204.string().describe("Standard Webhooks signing secret, format `whsec_<base64>`. Returned ONCE at create; rotate = delete + recreate. Every delivery carries `webhook-id`, `webhook-timestamp` (unix seconds), and `webhook-signature: v1,<base64>` (HMAC-SHA256 over `{id}.{timestamp}.{rawBody}`). Verify with any Standard-Webhooks library (`standardwebhooks` / `svix`): `new Webhook(secret).verify(rawBody, headers)`."),
+  "verification": zod204.strictObject({
+    "status": zod204.literal("pending"),
+    "reason": zod204.string()
   }).optional().describe('Present ONLY when ownership verification did not complete (status:"pending"). CueFrame POSTs a signed `webhook.verify` challenge whose `data.token` your endpoint must echo in a 2xx to activate; `reason` is one of token_not_echoed | non_2xx_<code> | unreachable | ssrf_blocked. A pending webhook receives no events \u2014 fix the receiver and POST /webhooks/:id/verify (no delete/recreate needed). See GET /webhooks/events for the full contract.')
 }).describe("POST /webhooks response (secret present exactly once).");
 
 // ../sdk/src/generated/zod/models/webhookEventCatalogResponse.zod.ts
-import * as zod204 from "zod";
-var WebhookEventCatalogResponse = zod204.strictObject({
-  "delivery": zod204.record(zod204.string(), zod204.unknown()).describe("The shared HTTP envelope + headers + retry semantics."),
-  "signing": zod204.record(zod204.string(), zod204.unknown()).describe("Standard Webhooks signing: secret format, signed content, how to verify."),
-  "ownershipVerification": zod204.record(zod204.string(), zod204.unknown()).describe("The synchronous echo-the-token activation handshake + recovery."),
-  "events": zod204.array(zod204.strictObject({
+import * as zod205 from "zod";
+var WebhookEventCatalogResponse = zod205.strictObject({
+  "delivery": zod205.record(zod205.string(), zod205.unknown()).describe("The shared HTTP envelope + headers + retry semantics."),
+  "signing": zod205.record(zod205.string(), zod205.unknown()).describe("Standard Webhooks signing: secret format, signed content, how to verify."),
+  "ownershipVerification": zod205.record(zod205.string(), zod205.unknown()).describe("The synchronous echo-the-token activation handshake + recovery."),
+  "events": zod205.array(zod205.strictObject({
     "event": WebhookEvent,
-    "when": zod204.string(),
-    "data": zod204.record(zod204.string(), zod204.string())
+    "when": zod205.string(),
+    "data": zod205.record(zod205.string(), zod205.string())
   })).describe("Every subscribable event with its exact delivery `data` fields."),
-  "sample": zod204.record(zod204.string(), zod204.unknown()).describe("A fully-worked example delivery (headers + body).")
+  "sample": zod205.record(zod205.string(), zod205.unknown()).describe("A fully-worked example delivery (headers + body).")
 }).describe("The webhook delivery/signing/verification contract, as data. Read this before building a receiver.");
 
 // ../sdk/src/generated/zod/models/webhookListResponse.zod.ts
-import * as zod206 from "zod";
+import * as zod207 from "zod";
 
 // ../sdk/src/generated/zod/models/webhookResponse.zod.ts
-import * as zod205 from "zod";
+import * as zod206 from "zod";
 var webhookResponseSettleMsMin = 0;
 var webhookResponseSettleMsMax = 9007199254740991;
 var webhookResponseConsecutiveFailuresMin = 0;
 var webhookResponseConsecutiveFailuresMax = 9007199254740991;
-var WebhookResponse = zod205.strictObject({
-  "id": zod205.string(),
-  "url": zod205.url(),
-  "events": zod205.array(WebhookEvent),
-  "settleMs": zod205.int().min(webhookResponseSettleMsMin).max(webhookResponseSettleMsMax),
-  "enabled": zod205.boolean(),
-  "verificationStatus": zod205.enum(["pending", "verified"]).describe("pending = callback URL has not echoed the ownership challenge (receives no events); verified = ownership proven."),
-  "createdAt": zod205.string(),
-  "lastDeliveredAt": zod205.string().nullable(),
-  "lastFailedAt": zod205.string().nullable(),
-  "consecutiveFailures": zod205.int().min(webhookResponseConsecutiveFailuresMin).max(webhookResponseConsecutiveFailuresMax)
+var WebhookResponse = zod206.strictObject({
+  "id": zod206.string(),
+  "url": zod206.url(),
+  "events": zod206.array(WebhookEvent),
+  "settleMs": zod206.int().min(webhookResponseSettleMsMin).max(webhookResponseSettleMsMax),
+  "enabled": zod206.boolean(),
+  "verificationStatus": zod206.enum(["pending", "verified"]).describe("pending = callback URL has not echoed the ownership challenge (receives no events); verified = ownership proven."),
+  "createdAt": zod206.string(),
+  "lastDeliveredAt": zod206.string().nullable(),
+  "lastFailedAt": zod206.string().nullable(),
+  "consecutiveFailures": zod206.int().min(webhookResponseConsecutiveFailuresMin).max(webhookResponseConsecutiveFailuresMax)
 }).describe("Webhook endpoint record (secret omitted after create).");
 
 // ../sdk/src/generated/zod/models/webhookListResponse.zod.ts
-var WebhookListResponse = zod206.strictObject({
-  "data": zod206.array(WebhookResponse),
+var WebhookListResponse = zod207.strictObject({
+  "data": zod207.array(WebhookResponse),
   "pagination": PaginationMeta
 });
 
 // ../sdk/src/generated/zod/models/webhookPatchRequest.zod.ts
-import * as zod207 from "zod";
+import * as zod208 from "zod";
 var webhookPatchRequestSettleMsMin = 0;
 var webhookPatchRequestSettleMsMax = 6e4;
-var WebhookPatchRequest = zod207.strictObject({
-  "url": zod207.string().min(1).optional(),
-  "events": zod207.array(WebhookEvent).min(1).optional(),
-  "settleMs": zod207.int().min(webhookPatchRequestSettleMsMin).max(webhookPatchRequestSettleMsMax).optional(),
-  "enabled": zod207.boolean().optional()
+var WebhookPatchRequest = zod208.strictObject({
+  "url": zod208.string().min(1).optional(),
+  "events": zod208.array(WebhookEvent).min(1).optional(),
+  "settleMs": zod208.int().min(webhookPatchRequestSettleMsMin).max(webhookPatchRequestSettleMsMax).optional(),
+  "enabled": zod208.boolean().optional()
 }).describe("PATCH /webhooks/:id body.");
 
 // ../sdk/src/generated/zod/models/webhookTestResponse.zod.ts
-import * as zod208 from "zod";
-var WebhookTestResponse = zod208.strictObject({
-  "deliveryId": zod208.string(),
-  "status": zod208.literal("queued")
+import * as zod209 from "zod";
+var WebhookTestResponse = zod209.strictObject({
+  "deliveryId": zod209.string(),
+  "status": zod209.literal("queued")
 }).describe("POST /webhooks/:id/test response.");
 
 // ../sdk/src/generated/zod/models/webhookVerifyResponse.zod.ts
-import * as zod209 from "zod";
-var WebhookVerifyResponse = zod209.strictObject({
-  "id": zod209.string(),
-  "status": zod209.enum(["active", "pending"]).describe("active = ownership verified + receiving events; pending = challenge not echoed."),
-  "verification": zod209.strictObject({
-    "status": zod209.literal("pending"),
-    "reason": zod209.string()
+import * as zod210 from "zod";
+var WebhookVerifyResponse = zod210.strictObject({
+  "id": zod210.string(),
+  "status": zod210.enum(["active", "pending"]).describe("active = ownership verified + receiving events; pending = challenge not echoed."),
+  "verification": zod210.strictObject({
+    "status": zod210.literal("pending"),
+    "reason": zod210.string()
   }).optional().describe("Present only when the re-challenge did not verify; `reason` names why (see WebhookCreateResponse.verification).")
 }).describe("POST /webhooks/:id/verify response.");
 
 // ../sdk/src/generated/zod/models/whoamiResponse.zod.ts
-import * as zod210 from "zod";
-var WhoamiResponse = zod210.strictObject({
-  "orgId": zod210.string(),
-  "permissions": zod210.record(zod210.string(), zod210.array(zod210.string())),
-  "keyId": zod210.string(),
-  "keyName": zod210.string()
+import * as zod211 from "zod";
+var WhoamiResponse = zod211.strictObject({
+  "orgId": zod211.string(),
+  "permissions": zod211.record(zod211.string(), zod211.array(zod211.string())),
+  "keyId": zod211.string(),
+  "keyName": zod211.string()
 }).describe("Whoami response.");
 
 // ../sdk/src/generated/zod/models/x402PaymentRequired.zod.ts
-import * as zod211 from "zod";
-var X402PaymentRequired = zod211.strictObject({
-  "x402Version": zod211.literal(2),
-  "accepts": zod211.array(zod211.looseObject({})).describe("Accepted payment requirements. Read `accepts[0]` for scheme (`exact` for a fixed price, `upto` for a measured one), network (CAIP-2), asset, amount and payTo."),
-  "error": zod211.string().optional().describe("Human-readable reason.")
+import * as zod212 from "zod";
+var X402PaymentRequired = zod212.strictObject({
+  "x402Version": zod212.literal(2),
+  "accepts": zod212.array(zod212.looseObject({})).describe("Accepted payment requirements. Read `accepts[0]` for scheme (`exact` for a fixed price, `upto` for a measured one), network (CAIP-2), asset, amount and payTo."),
+  "error": zod212.string().optional().describe("Human-readable reason.")
 }).describe("x402 v2 PaymentRequired challenge \u2014 the body of a 402 on a priced operation.");
 
 // ../sdk/src/generated/zod/account/account.ts
@@ -8520,19 +8529,19 @@ var CreateApiKeyBody = ApiKeyCreateRequest;
 var CreateApiKeyResponse = ApiKeyResponse;
 
 // ../sdk/src/generated/zod/billing/billing.ts
-import * as zod212 from "zod";
+import * as zod213 from "zod";
 var getUsageQueryLimitMax = 100;
 var getUsageQueryFromMin = -9007199254740991;
 var getUsageQueryFromMax = 9007199254740991;
 var getUsageQueryToMin = -9007199254740991;
 var getUsageQueryToMax = 9007199254740991;
-var GetUsageQueryParams = zod212.object({
-  "limit": zod212.int().min(1).max(getUsageQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod212.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "projectId": zod212.string().optional().describe("Only events attributed to this project."),
-  "jobId": zod212.string().optional().describe('Only events produced by this job \u2014 how to answer "did my failed render post a charge?" for one run.'),
-  "from": zod212.int().min(getUsageQueryFromMin).max(getUsageQueryFromMax).optional().describe("Period start, epoch milliseconds, INCLUSIVE."),
-  "to": zod212.int().min(getUsageQueryToMin).max(getUsageQueryToMax).optional().describe("Period end, epoch milliseconds, EXCLUSIVE.")
+var GetUsageQueryParams = zod213.object({
+  "limit": zod213.int().min(1).max(getUsageQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod213.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "projectId": zod213.string().optional().describe("Only events attributed to this project."),
+  "jobId": zod213.string().optional().describe('Only events produced by this job \u2014 how to answer "did my failed render post a charge?" for one run.'),
+  "from": zod213.int().min(getUsageQueryFromMin).max(getUsageQueryFromMax).optional().describe("Period start, epoch milliseconds, INCLUSIVE."),
+  "to": zod213.int().min(getUsageQueryToMin).max(getUsageQueryToMax).optional().describe("Period end, epoch milliseconds, EXCLUSIVE.")
 });
 var GetUsageResponse = UsageListResponse;
 var GetBillingPlansResponse = BillingPlansResponse;
@@ -8540,23 +8549,23 @@ var CreateCheckoutBody = CheckoutRequest;
 var CreateCheckoutResponse = CheckoutResponse;
 
 // ../sdk/src/generated/zod/brand-kits/brand-kits.ts
-import * as zod213 from "zod";
+import * as zod214 from "zod";
 var listBrandKitsQueryLimitMax = 100;
-var ListBrandKitsQueryParams = zod213.object({
-  "limit": zod213.int().min(1).max(listBrandKitsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod213.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
+var ListBrandKitsQueryParams = zod214.object({
+  "limit": zod214.int().min(1).max(listBrandKitsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod214.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
 });
 var ListBrandKitsResponse = BrandKitListResponse;
 var CreateBrandKitBody = BrandKitCreateRequest;
 var CreateBrandKitResponse = BrandKitResponse;
 var ExtractBrandKitBody = ExtractBrandKitRequest;
 var ExtractBrandKitResponse2 = JobEnqueueResponse;
-var GetBrandKitParams = zod213.object({
-  "id": zod213.string()
+var GetBrandKitParams = zod214.object({
+  "id": zod214.string()
 });
 var GetBrandKitResponse = BrandKitResponse;
-var GetBrandKitExemplarsParams = zod213.object({
-  "id": zod213.string()
+var GetBrandKitExemplarsParams = zod214.object({
+  "id": zod214.string()
 });
 var GetBrandKitExemplarsBody = BrandKitExemplarsRequest;
 var GetBrandKitExemplarsResponse = BrandKitExemplarsResponse;
@@ -8564,309 +8573,312 @@ var CreateExemplarUploadsBody = ExemplarUploadsRequest;
 var CreateExemplarUploadsResponse = ExemplarUploadsResponse;
 
 // ../sdk/src/generated/zod/briefs/briefs.ts
-import * as zod214 from "zod";
+import * as zod215 from "zod";
 var CreateBriefBody = BriefCreateRequest;
 var CreateBriefResponse = BriefResponse;
 var listBriefsQueryLimitMax = 100;
-var ListBriefsQueryParams = zod214.object({
-  "limit": zod214.int().min(1).max(listBriefsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod214.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "projectId": zod214.string().optional().describe("Scope to one project. Omit for every brief in the org."),
-  "kind": zod214.enum(["authored", "clip", "all"]).optional().describe("Which briefs to list. `authored` (default) = human-authored only; `clip` = the machine-minted clip briefs from suggest_briefs; `all` = both.")
+var ListBriefsQueryParams = zod215.object({
+  "limit": zod215.int().min(1).max(listBriefsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod215.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "projectId": zod215.string().optional().describe("Scope to one project. Omit for every brief in the org."),
+  "kind": zod215.enum(["authored", "clip", "all"]).optional().describe("Which briefs to list. `authored` (default) = human-authored only; `clip` = the machine-minted clip briefs from suggest_briefs; `all` = both.")
 });
 var ListBriefsResponse = BriefListResponse;
-var GetBriefParams = zod214.object({
-  "id": zod214.string()
+var GetBriefParams = zod215.object({
+  "id": zod215.string()
 });
 var GetBriefResponse = BriefResponse;
-var UpdateBriefParams = zod214.object({
-  "id": zod214.string()
+var UpdateBriefParams = zod215.object({
+  "id": zod215.string()
 });
 var UpdateBriefBody = BriefPatchRequest;
 var UpdateBriefResponse = BriefResponse;
-var DeleteBriefParams = zod214.object({
-  "id": zod214.string()
+var DeleteBriefParams = zod215.object({
+  "id": zod215.string()
 });
-var DeleteBriefResponse = zod214.void();
+var DeleteBriefResponse = zod215.void();
 
 // ../sdk/src/generated/zod/checkpoints/checkpoints.ts
-import * as zod215 from "zod";
-var GetReviewPacketParams = zod215.object({
-  "id": zod215.string()
+import * as zod216 from "zod";
+var GetReviewPacketParams = zod216.object({
+  "id": zod216.string()
 });
 var GetReviewPacketResponse = ReviewPacketResponse;
-var RecordReviewDecisionParams = zod215.object({
-  "id": zod215.string()
+var RecordReviewDecisionParams = zod216.object({
+  "id": zod216.string()
 });
 var RecordReviewDecisionResponse = ReviewDecisionResponse;
 var listCheckpointsQueryLimitMax = 100;
-var ListCheckpointsQueryParams = zod215.object({
-  "limit": zod215.int().min(1).max(listCheckpointsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod215.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "composeJobId": zod215.string().optional().describe("Scope to ONE compose run \u2014 its v1\u2192vN gate history with per-version status and decisions."),
-  "projectId": zod215.string().optional().describe("Scope to everything reviewable in one project.")
+var ListCheckpointsQueryParams = zod216.object({
+  "limit": zod216.int().min(1).max(listCheckpointsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod216.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "composeJobId": zod216.string().optional().describe("Scope to ONE compose run \u2014 its v1\u2192vN gate history with per-version status and decisions."),
+  "projectId": zod216.string().optional().describe("Scope to everything reviewable in one project.")
 });
 var ListCheckpointsResponse = CheckpointListResponse;
-var GetCheckpointParams = zod215.object({
-  "id": zod215.string()
+var GetCheckpointParams = zod216.object({
+  "id": zod216.string()
 });
 var GetCheckpointResponse = CheckpointResponse;
-var ResumeCheckpointParams = zod215.object({
-  "id": zod215.string()
+var ResumeCheckpointParams = zod216.object({
+  "id": zod216.string()
 });
 var ResumeCheckpointBody = CheckpointResumeRequest;
 var ResumeCheckpointResponse = CheckpointResumeResponse;
 
 // ../sdk/src/generated/zod/clips/clips.ts
-import * as zod216 from "zod";
-var ComposeFromSuggestionParams = zod216.object({
-  "id": zod216.string()
+import * as zod217 from "zod";
+var ComposeFromSuggestionParams = zod217.object({
+  "id": zod217.string()
 });
-var ComposeFromSuggestionBody2 = zod216.strictObject({
-  "suggestionId": zod216.string().min(1),
-  "format": zod216.strictObject({
-    "aspectRatio": zod216.enum(["16:9", "9:16", "1:1", "4:5"]),
-    "fps": zod216.union([zod216.literal(24), zod216.literal(25), zod216.literal(30), zod216.literal(60)]).optional(),
-    "resolution": zod216.enum(["hd", "fhd", "4k"]).optional(),
-    "platform": zod216.string().optional()
+var ComposeFromSuggestionBody2 = zod217.strictObject({
+  "suggestionId": zod217.string().min(1),
+  "format": zod217.strictObject({
+    "aspectRatio": zod217.enum(["16:9", "9:16", "1:1", "4:5"]),
+    "fps": zod217.union([zod217.literal(24), zod217.literal(25), zod217.literal(30), zod217.literal(60)]).optional(),
+    "resolution": zod217.enum(["hd", "fhd", "4k"]).optional(),
+    "platform": zod217.string().optional()
   }).optional()
 });
-var ComposeFromSuggestionResponse = zod216.unknown();
-var ListMediaSuggestionsParams2 = zod216.object({
-  "id": zod216.string()
+var ComposeFromSuggestionResponse = zod217.unknown();
+var ListMediaSuggestionsParams2 = zod217.object({
+  "id": zod217.string()
 });
 var listMediaSuggestionsQueryLimitMax = 100;
-var ListMediaSuggestionsQueryParams = zod216.object({
-  "limit": zod216.int().min(1).max(listMediaSuggestionsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod216.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "platform": zod216.string().optional().describe("Only suggestions cut for this delivery platform."),
-  "format": zod216.string().optional().describe("Only suggestions in this output format."),
-  "topic": zod216.string().optional().describe("Only suggestions matching this topic label.")
+var ListMediaSuggestionsQueryParams = zod217.object({
+  "limit": zod217.int().min(1).max(listMediaSuggestionsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod217.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "platform": zod217.string().optional().describe("Only suggestions cut for this delivery platform."),
+  "format": zod217.string().optional().describe("Only suggestions in this output format."),
+  "topic": zod217.string().optional().describe("Only suggestions matching this topic label.")
 });
 var ListMediaSuggestionsResponse = SuggestionsEnvelope;
-var SuggestBriefsParams = zod216.object({
-  "id": zod216.string()
+var SuggestBriefsParams = zod217.object({
+  "id": zod217.string()
 });
 var SuggestBriefsResponse = SuggestionsTriggerResponse;
-var ResetMediaSuggestionsParams = zod216.object({
-  "id": zod216.string()
+var ResetMediaSuggestionsParams = zod217.object({
+  "id": zod217.string()
 });
-var ResetMediaSuggestionsResponse = zod216.unknown();
+var ResetMediaSuggestionsResponse = zod217.unknown();
 
 // ../sdk/src/generated/zod/components/components.ts
-import * as zod217 from "zod";
+import * as zod218 from "zod";
 var listCatalogQueryLimitMax = 100;
-var ListCatalogQueryParams = zod217.object({
-  "category": zod217.enum(["text", "effects", "transitions", "layouts", "backgrounds", "ui-blocks", "scenes"]).optional().describe("Filter to one category bucket (text|effects|transitions|layouts|backgrounds|ui-blocks|scenes)."),
-  "kind": zod217.enum(["component", "transition", "scene"]).optional().describe("Filter by render kind (component|transition|scene)."),
-  "tier": zod217.enum(["recommended", "standard", "niche"]).optional().describe("Filter by curation tier (recommended|standard|niche)."),
-  "useCase": zod217.enum(["intro", "outro", "full-scene", "title-over-footage", "transition", "background", "grade", "emphasis", "explainer", "social-cut"]).optional().describe("Filter to entries whose useCase includes this edit role (e.g. intro, title-over-footage, grade)."),
-  "mood": zod217.string().optional().describe("Filter to entries whose mood tags include this value (e.g. cinematic, minimal)."),
-  "q": zod217.string().optional().describe("Free-text match across id/name/description/intent/useWhen/tags/mood. Recommend-orders results."),
-  "intent": zod217.string().optional().describe("Alias of `q` framed as recommend-by-intent (e.g. intent=intro). Recommend-orders results."),
-  "limit": zod217.int().min(1).max(listCatalogQueryLimitMax).optional().describe("Page size (1..100). Omit to return the whole filtered catalog in one page."),
-  "after": zod217.string().optional().describe("Opaque cursor from a previous page's nextCursor (forward-only).")
+var ListCatalogQueryParams = zod218.object({
+  "category": zod218.enum(["text", "effects", "transitions", "layouts", "backgrounds", "ui-blocks", "scenes"]).optional().describe("Filter to one category bucket (text|effects|transitions|layouts|backgrounds|ui-blocks|scenes)."),
+  "kind": zod218.enum(["component", "transition", "scene"]).optional().describe("Filter by render kind (component|transition|scene)."),
+  "tier": zod218.enum(["recommended", "standard", "niche"]).optional().describe("Filter by curation tier (recommended|standard|niche)."),
+  "useCase": zod218.enum(["intro", "outro", "full-scene", "title-over-footage", "transition", "background", "grade", "emphasis", "explainer", "social-cut"]).optional().describe("Filter to entries whose useCase includes this edit role (e.g. intro, title-over-footage, grade)."),
+  "mood": zod218.string().optional().describe("Filter to entries whose mood tags include this value (e.g. cinematic, minimal)."),
+  "q": zod218.string().optional().describe("Free-text match across id/name/description/intent/useWhen/tags/mood. Recommend-orders results."),
+  "intent": zod218.string().optional().describe("Alias of `q` framed as recommend-by-intent (e.g. intent=intro). Recommend-orders results."),
+  "limit": zod218.int().min(1).max(listCatalogQueryLimitMax).optional().describe("Page size (1..100). Omit to return the whole filtered catalog in one page."),
+  "after": zod218.string().optional().describe("Opaque cursor from a previous page's nextCursor (forward-only).")
 });
 var ListCatalogResponse = ComponentListResponse;
 var CreateComponentBody = ComponentCreateRequest;
 var CreateComponentResponse = ComponentResponse;
-var UpdateComponentParams = zod217.object({
-  "id": zod217.string()
+var UpdateComponentParams = zod218.object({
+  "id": zod218.string()
 });
 var UpdateComponentBody = ComponentUpdateRequest;
 var UpdateComponentResponse = ComponentResponse;
-var GetComponentParams = zod217.object({
-  "id": zod217.string()
+var GetComponentParams = zod218.object({
+  "id": zod218.string()
 });
 var GetComponentResponse = ComponentResponse;
-var GetComponentSourceParams = zod217.object({
-  "id": zod217.string()
+var GetComponentSourceParams = zod218.object({
+  "id": zod218.string()
 });
 var GetComponentSourceResponse = ComponentSourceResponse;
 
 // ../sdk/src/generated/zod/compose/compose.ts
-import * as zod218 from "zod";
-var ComposeParams = zod218.object({
-  "id": zod218.string()
+import * as zod219 from "zod";
+var ComposeParams = zod219.object({
+  "id": zod219.string()
 });
 var ComposeBody = ComposeCreateRequest;
 var ComposeResponse = ComposeCreateResponse;
-var StreamComposeParams = zod218.object({
-  "id": zod218.string(),
-  "composeJobId": zod218.string()
+var StreamComposeParams = zod219.object({
+  "id": zod219.string(),
+  "composeJobId": zod219.string()
 });
-var StreamComposeResponse = zod218.unknown();
-var SelectComposeCandidateParams = zod218.object({
-  "id": zod218.string(),
-  "composeJobId": zod218.string()
+var StreamComposeResponse = zod219.unknown();
+var SelectComposeCandidateParams = zod219.object({
+  "id": zod219.string(),
+  "composeJobId": zod219.string()
 });
 var SelectComposeCandidateBody = ComposeSelectRequest;
 var SelectComposeCandidateResponse = ComposeSelectResponse;
-var CancelComposeParams = zod218.object({
-  "id": zod218.string(),
-  "composeJobId": zod218.string()
+var CancelComposeParams = zod219.object({
+  "id": zod219.string(),
+  "composeJobId": zod219.string()
 });
 var CancelComposeResponse = ComposeJobDetailResponse;
-var ListComposeJobsParams = zod218.object({
-  "id": zod218.string()
+var ListComposeJobsParams = zod219.object({
+  "id": zod219.string()
 });
 var ListComposeJobsResponse = ComposeJobListResponse;
-var GetComposeJobParams = zod218.object({
-  "id": zod218.string(),
-  "composeJobId": zod218.string()
+var GetComposeJobParams = zod219.object({
+  "id": zod219.string(),
+  "composeJobId": zod219.string()
 });
 var GetComposeJobResponse = ComposeJobDetailResponse;
 
 // ../sdk/src/generated/zod/compose-session/compose-session.ts
-import * as zod219 from "zod";
-var OpenComposeSessionParams = zod219.object({
-  "id": zod219.string()
+import * as zod220 from "zod";
+var OpenComposeSessionParams = zod220.object({
+  "id": zod220.string()
 });
 var openComposeSessionBodyLeaseJobIdMax2 = 64;
-var OpenComposeSessionBody2 = zod219.strictObject({
-  "seedComposition": zod219.unknown().optional(),
-  "leaseJobId": zod219.string().min(1).max(openComposeSessionBodyLeaseJobIdMax2).optional()
+var OpenComposeSessionBody2 = zod220.strictObject({
+  "seedComposition": zod220.unknown().optional(),
+  "leaseJobId": zod220.string().min(1).max(openComposeSessionBodyLeaseJobIdMax2).optional()
 });
-var OpenComposeSessionResponse = zod219.object({
-  "sessionId": zod219.string()
+var OpenComposeSessionResponse = zod220.object({
+  "sessionId": zod220.string()
 });
-var GetComposeSessionCompositionParams = zod219.object({
-  "id": zod219.string(),
-  "sessionId": zod219.string()
+var GetComposeSessionCompositionParams = zod220.object({
+  "id": zod220.string(),
+  "sessionId": zod220.string()
 });
-var GetComposeSessionCompositionResponse = zod219.object({
-  "composition": zod219.unknown()
+var GetComposeSessionCompositionResponse = zod220.object({
+  "composition": zod220.unknown()
 });
-var CloseComposeSessionParams = zod219.object({
-  "id": zod219.string(),
-  "sessionId": zod219.string()
+var CloseComposeSessionParams = zod220.object({
+  "id": zod220.string(),
+  "sessionId": zod220.string()
 });
-var CloseComposeSessionResponse = zod219.object({
-  "ok": zod219.boolean()
+var CloseComposeSessionResponse = zod220.object({
+  "ok": zod220.boolean()
 });
-var CommitComposeSessionParams = zod219.object({
-  "id": zod219.string(),
-  "sessionId": zod219.string()
+var CommitComposeSessionParams = zod220.object({
+  "id": zod220.string(),
+  "sessionId": zod220.string()
 });
-var CommitComposeSessionResponse = zod219.object({
-  "etag": zod219.string()
+var CommitComposeSessionResponse = zod220.object({
+  "etag": zod220.string()
 });
 
 // ../sdk/src/generated/zod/compositions/compositions.ts
-import * as zod220 from "zod";
-var GetCompositionParams = zod220.object({
-  "id": zod220.string()
+import * as zod221 from "zod";
+var GetCompositionParams2 = zod221.object({
+  "id": zod221.string()
+});
+var GetCompositionQueryParams = zod221.object({
+  "compositionId": zod221.string().optional().describe("Read a SPECIFIC composition instead of the project's active one. Omit it and the active composition is returned. Pairs with `composition_id` on the apply op: an edit you can make to a second composition is one you can read back.")
 });
 var GetCompositionResponse = Composition;
-var PutCompositionParams = zod220.object({
-  "id": zod220.string()
+var PutCompositionParams = zod221.object({
+  "id": zod221.string()
 });
 var PutCompositionBody = Composition;
-var PutCompositionResponse = zod220.unknown();
-var NewCompositionParams = zod220.object({
-  "id": zod220.string()
+var PutCompositionResponse = zod221.unknown();
+var NewCompositionParams = zod221.object({
+  "id": zod221.string()
 });
 var NewCompositionBody = CompositionCreateRequest;
-var NewCompositionResponse = zod220.void();
-var ListCompositionsParams = zod220.object({
-  "id": zod220.string()
+var NewCompositionResponse = zod221.void();
+var ListCompositionsParams = zod221.object({
+  "id": zod221.string()
 });
 var ListCompositionsResponse = CompositionListResponse;
-var ApplyCompositionOpParams = zod220.object({
-  "id": zod220.string()
+var ApplyCompositionOpParams = zod221.object({
+  "id": zod221.string()
 });
 var ApplyCompositionOpBody = CompositionOp;
-var ApplyCompositionOpResponse = zod220.unknown();
-var ApplyCompositionParams = zod220.object({
-  "id": zod220.string()
+var ApplyCompositionOpResponse = zod221.unknown();
+var ApplyCompositionParams = zod221.object({
+  "id": zod221.string()
 });
 var ApplyCompositionBody = CompositionApplyRequest;
-var ApplyCompositionResponse = zod220.unknown();
-var DeriveCompositionParams = zod220.object({
-  "id": zod220.string()
+var ApplyCompositionResponse = zod221.unknown();
+var DeriveCompositionParams = zod221.object({
+  "id": zod221.string()
 });
 var DeriveCompositionBody = DeriveCompositionRequest;
 var DeriveCompositionResponseSchema = DeriveCompositionResponse;
 var ValidateCompositionBody = Composition;
-var ValidateCompositionResponse = zod220.object({
-  "valid": zod220.boolean(),
-  "errors": zod220.array(zod220.object({
-    "code": zod220.string(),
-    "stage": zod220.string(),
-    "category": zod220.string(),
-    "retryable": zod220.boolean(),
-    "message": zod220.string(),
-    "fix": zod220.record(zod220.string(), zod220.unknown()).optional()
+var ValidateCompositionResponse = zod221.object({
+  "valid": zod221.boolean(),
+  "errors": zod221.array(zod221.object({
+    "code": zod221.string(),
+    "stage": zod221.string(),
+    "category": zod221.string(),
+    "retryable": zod221.boolean(),
+    "message": zod221.string(),
+    "fix": zod221.record(zod221.string(), zod221.unknown()).optional()
   })),
-  "advisories": zod220.array(zod220.object({
-    "rule": zod220.string(),
-    "criterion": zod220.string(),
-    "clipId": zod220.string().optional(),
-    "detail": zod220.string(),
-    "fix": zod220.string()
+  "advisories": zod221.array(zod221.object({
+    "rule": zod221.string(),
+    "criterion": zod221.string(),
+    "clipId": zod221.string().optional(),
+    "detail": zod221.string(),
+    "fix": zod221.string()
   })).describe("Deterministic, render-free QUALITY floors (the SAME named defects the Director's in-loop verify and score_composition surface: static-hold, caption-spine, sfx-density, sfx-speech-collision, bed-coverage, audio-role). NON-blocking \u2014 they never flip `valid` (an editorially-weak composition still renders); fix them for quality, not to save. Empty when the composition is clean or the wire shape failed (they need a parsed composition)."),
-  "warnings": zod220.array(zod220.string()).optional().describe("Non-blocking render-fidelity warnings detected before enqueue, including unavailable font families."),
-  "quote": zod220.object({
-    "thisStepUsd": zod220.number(),
-    "jobSpendSoFarUsd": zod220.number(),
-    "estimatedJourneyTotalUsd": zod220.number()
+  "warnings": zod221.array(zod221.string()).optional().describe("Non-blocking render-fidelity warnings detected before enqueue, including unavailable font families."),
+  "quote": zod221.object({
+    "thisStepUsd": zod221.number(),
+    "jobSpendSoFarUsd": zod221.number(),
+    "estimatedJourneyTotalUsd": zod221.number()
   }).describe("The A2 money triple for the commodity lane: validate is free; estimatedJourneyTotalUsd is the render price to finish from a valid composition \u2014 relay it BEFORE create_render.")
 });
-var DeleteCompositionParams = zod220.object({
-  "id": zod220.string(),
-  "compositionId": zod220.string()
+var DeleteCompositionParams = zod221.object({
+  "id": zod221.string(),
+  "compositionId": zod221.string()
 });
-var DeleteCompositionResponse = zod220.void();
+var DeleteCompositionResponse = zod221.void();
 
 // ../sdk/src/generated/zod/consult/consult.ts
-import * as zod221 from "zod";
-var ConsultParams = zod221.object({
-  "id": zod221.string()
+import * as zod222 from "zod";
+var ConsultParams = zod222.object({
+  "id": zod222.string()
 });
 var ConsultBody = ConsultRequest;
 var ConsultResponseSchema = ConsultResponse;
 
 // ../sdk/src/generated/zod/critics/critics.ts
-import * as zod222 from "zod";
+import * as zod223 from "zod";
 var CreateCriticBody = CriticCreateRequest;
 var CreateCriticResponse = CriticResponse;
 var ListCriticsResponse = CriticListResponse;
-var DeleteCriticParams = zod222.object({
-  "criticId": zod222.string()
+var DeleteCriticParams = zod223.object({
+  "criticId": zod223.string()
 });
-var DeleteCriticResponse = zod222.void();
+var DeleteCriticResponse = zod223.void();
 
 // ../sdk/src/generated/zod/evidence/evidence.ts
-import * as zod223 from "zod";
-var ScoreCompositionParams = zod223.object({
-  "id": zod223.string()
+import * as zod224 from "zod";
+var ScoreCompositionParams = zod224.object({
+  "id": zod224.string()
 });
-var ScoreCompositionBody2 = zod223.strictObject({
-  "composition": zod223.unknown().optional().describe("The composition to judge. Absent \u21D2 the project's ACTIVE composition."),
-  "compositionId": zod223.string().optional().describe("Judge a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
-  "session_id": zod223.string().optional().describe("Compose-session id: judge that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
-  "editorialIntent": zod223.string().optional(),
-  "brandContext": zod223.string().optional()
+var ScoreCompositionBody2 = zod224.strictObject({
+  "composition": zod224.unknown().optional().describe("The composition to judge. Absent \u21D2 the project's ACTIVE composition."),
+  "compositionId": zod224.string().optional().describe("Judge a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
+  "session_id": zod224.string().optional().describe("Compose-session id: judge that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
+  "editorialIntent": zod224.string().optional(),
+  "brandContext": zod224.string().optional()
 });
 var ScoreCompositionResponse = JobEnqueueResponse;
-var PreviewFrameJobParams = zod223.object({
-  "id": zod223.string()
+var PreviewFrameJobParams = zod224.object({
+  "id": zod224.string()
 });
 var previewFrameJobBodyScaleMin2 = 0.1;
 var previewFrameJobBodyScaleMax2 = 1;
 var previewFrameJobBodyJpegQualityMax2 = 100;
-var PreviewFrameJobBody2 = zod223.strictObject({
-  "composition": zod223.unknown().optional().describe("The composition to render. Absent \u21D2 the project's ACTIVE composition \u2014 what create_render will encode. The response's `previewed.source` names what was rendered."),
-  "compositionId": zod223.string().optional().describe("Preview a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
-  "session_id": zod223.string().optional().describe("Compose-session id: render that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
-  "timestamps": zod223.array(zod223.number()).min(1),
-  "imageFormat": zod223.enum(["png", "jpeg"]).optional().describe("Still format. Default jpeg \u2014 these pixels go to a vision model, where jpeg is equivalent and png costs multiples in bytes to store and move. Pass png only when you need full fidelity."),
-  "scale": zod223.number().min(previewFrameJobBodyScaleMin2).max(previewFrameJobBodyScaleMax2).optional().describe("Render scale 0.1\u20131. Default 0.5, which is what this schema has always recommended for vision-bound looks. Pass 1 when judging fine detail \u2014 it costs ~4x the vision tokens."),
-  "jpegQuality": zod223.int().min(1).max(previewFrameJobBodyJpegQualityMax2).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
+var PreviewFrameJobBody2 = zod224.strictObject({
+  "composition": zod224.unknown().optional().describe("The composition to render. Absent \u21D2 the project's ACTIVE composition \u2014 what create_render will encode. The response's `previewed.source` names what was rendered."),
+  "compositionId": zod224.string().optional().describe("Preview a SPECIFIC persisted composition of this project (create_render parity). Absent \u21D2 the active one. A stale/foreign id is a 404 \u2014 never a silent fall-through."),
+  "session_id": zod224.string().optional().describe("Compose-session id: render that session's SCRATCH composition (what the session has been editing) instead of the active row. Ignored when `composition` is passed."),
+  "timestamps": zod224.array(zod224.number()).min(1),
+  "imageFormat": zod224.enum(["png", "jpeg"]).optional().describe("Still format. Default jpeg \u2014 these pixels go to a vision model, where jpeg is equivalent and png costs multiples in bytes to store and move. Pass png only when you need full fidelity."),
+  "scale": zod224.number().min(previewFrameJobBodyScaleMin2).max(previewFrameJobBodyScaleMax2).optional().describe("Render scale 0.1\u20131. Default 0.5, which is what this schema has always recommended for vision-bound looks. Pass 1 when judging fine detail \u2014 it costs ~4x the vision tokens."),
+  "jpegQuality": zod224.int().min(1).max(previewFrameJobBodyJpegQualityMax2).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
 });
 var PreviewFrameJobResponse = JobEnqueueResponse;
-var PreviewComponentParams = zod223.object({
-  "id": zod223.string()
+var PreviewComponentParams = zod224.object({
+  "id": zod224.string()
 });
 var previewComponentBodyWidthExclusiveMin2 = 0;
 var previewComponentBodyWidthMax2 = 9007199254740991;
@@ -8875,37 +8887,37 @@ var previewComponentBodyHeightMax2 = 9007199254740991;
 var previewComponentBodyFpsExclusiveMin2 = 0;
 var previewComponentBodyFpsMax2 = 120;
 var previewComponentBodyDurationInFramesMax2 = 3600;
-var PreviewComponentBody2 = zod223.strictObject({
-  "componentId": zod223.string().min(1),
-  "params": zod223.record(zod223.string(), zod223.unknown()).optional(),
-  "assets": zod223.record(zod223.string(), zod223.string().min(1)).optional().describe("Component asset-slot name to org mediaId. Every required manifest slot must be bound."),
-  "width": zod223.int().gt(previewComponentBodyWidthExclusiveMin2).max(previewComponentBodyWidthMax2).optional(),
-  "height": zod223.int().gt(previewComponentBodyHeightExclusiveMin2).max(previewComponentBodyHeightMax2).optional(),
-  "fps": zod223.number().gt(previewComponentBodyFpsExclusiveMin2).max(previewComponentBodyFpsMax2).optional().describe("Preview frame rate. When omitted, uses the project's format."),
-  "durationInFrames": zod223.int().min(1).max(previewComponentBodyDurationInFramesMax2).optional().describe("Preview frame count. When omitted, uses the component's declared duration; required if the component has none.")
+var PreviewComponentBody2 = zod224.strictObject({
+  "componentId": zod224.string().min(1),
+  "params": zod224.record(zod224.string(), zod224.unknown()).optional(),
+  "assets": zod224.record(zod224.string(), zod224.string().min(1)).optional().describe("Component asset-slot name to org mediaId. Every required manifest slot must be bound."),
+  "width": zod224.int().gt(previewComponentBodyWidthExclusiveMin2).max(previewComponentBodyWidthMax2).optional(),
+  "height": zod224.int().gt(previewComponentBodyHeightExclusiveMin2).max(previewComponentBodyHeightMax2).optional(),
+  "fps": zod224.number().gt(previewComponentBodyFpsExclusiveMin2).max(previewComponentBodyFpsMax2).optional().describe("Preview frame rate. When omitted, uses the project's format."),
+  "durationInFrames": zod224.int().min(1).max(previewComponentBodyDurationInFramesMax2).optional().describe("Preview frame count. When omitted, uses the component's declared duration; required if the component has none.")
 });
 var PreviewComponentResponse = JobEnqueueResponse;
 
 // ../sdk/src/generated/zod/exports/exports.ts
-import * as zod224 from "zod";
-var CreateFcpxmlExportParams = zod224.object({
-  "id": zod224.string()
+import * as zod225 from "zod";
+var CreateFcpxmlExportParams = zod225.object({
+  "id": zod225.string()
 });
 var CreateFcpxmlExportBody = ExportCreateRequest;
 var CreateFcpxmlExportResponse = ExportResponse;
-var CreatePremiereExportParams = zod224.object({
-  "id": zod224.string()
+var CreatePremiereExportParams = zod225.object({
+  "id": zod225.string()
 });
 var CreatePremiereExportBody = ExportCreateRequest;
 var CreatePremiereExportResponse = ExportResponse;
-var GetExportParams = zod224.object({
-  "id": zod224.string(),
-  "exportId": zod224.string()
+var GetExportParams = zod225.object({
+  "id": zod225.string(),
+  "exportId": zod225.string()
 });
 var GetExportResponse = ExportResponse;
-var CancelExportParams = zod224.object({
-  "id": zod224.string(),
-  "exportId": zod224.string()
+var CancelExportParams = zod225.object({
+  "id": zod225.string(),
+  "exportId": zod225.string()
 });
 var CancelExportResponse = ExportResponse;
 
@@ -8915,51 +8927,51 @@ var SearchFontsResponse = FontSearchResponse;
 var ListRenderFontsResponse = RenderFontsResponse;
 
 // ../sdk/src/generated/zod/health/health.ts
-import * as zod225 from "zod";
-var HealthQueryParams = zod225.object({
-  "deep": zod225.literal("1").optional().describe("Pass `1` to run the deep dependency checks instead of the shallow liveness probe.")
+import * as zod226 from "zod";
+var HealthQueryParams = zod226.object({
+  "deep": zod226.literal("1").optional().describe("Pass `1` to run the deep dependency checks instead of the shallow liveness probe.")
 });
 var HealthResponseSchema = HealthResponse;
 var WhoamiResponseSchema = WhoamiResponse;
-var GetOpenAPISpecResponse = zod225.looseObject({});
+var GetOpenAPISpecResponse = zod226.looseObject({});
 
 // ../sdk/src/generated/zod/jobs/jobs.ts
-import * as zod226 from "zod";
-var GetJobParams = zod226.object({
-  "jobId": zod226.string()
+import * as zod227 from "zod";
+var GetJobParams = zod227.object({
+  "jobId": zod227.string()
 });
 var GetJobResponse = JobResponse;
-var CancelJobParams = zod226.object({
-  "jobId": zod226.string()
+var CancelJobParams = zod227.object({
+  "jobId": zod227.string()
 });
 var CancelJobResponse = JobResponse;
 
 // ../sdk/src/generated/zod/media/media.ts
-import * as zod227 from "zod";
+import * as zod228 from "zod";
 var searchLibraryQueryLimitDefault = 10;
 var searchLibraryQueryLimitMax = 25;
-var SearchLibraryQueryParams = zod227.object({
-  "q": zod227.string().min(1).describe("What the moment should look like, in plain language. Describe the IMAGE, not the words spoken."),
-  "limit": zod227.int().min(1).max(searchLibraryQueryLimitMax).default(searchLibraryQueryLimitDefault).describe("Maximum moments to return. Default 10, maximum 25.")
+var SearchLibraryQueryParams = zod228.object({
+  "q": zod228.string().min(1).describe("What the moment should look like, in plain language. Describe the IMAGE, not the words spoken."),
+  "limit": zod228.int().min(1).max(searchLibraryQueryLimitMax).default(searchLibraryQueryLimitDefault).describe("Maximum moments to return. Default 10, maximum 25.")
 });
 var SearchLibraryResponse = LibrarySearchResponse;
-var CreateUploadTokenBody2 = zod227.strictObject({
-  "projectId": zod227.string().optional().describe("Optional project to scope the token to; omitted = org library.")
+var CreateUploadTokenBody2 = zod228.strictObject({
+  "projectId": zod228.string().optional().describe("Optional project to scope the token to; omitted = org library.")
 });
 var CreateUploadTokenResponse = UploadTokenResponse;
 var CreateMediaUploadBody = MediaUploadRequest;
 var CreateMediaUploadResponse = MediaDirectUploadResponse;
 var listMediaQueryLimitMax = 100;
-var ListMediaQueryParams = zod227.object({
-  "limit": zod227.int().min(1).max(listMediaQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod227.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "kind": zod227.enum(["video", "audio", "image", "gif", "asset", "source", "stock"]).optional().describe("Filter to one media kind."),
-  "source": zod227.enum(["upload", "generated", "import-url", "stock"]).optional().describe("Filter by how the item entered the library."),
-  "tag": zod227.string().optional().describe("Filter to items carrying this EXACT tag (not a prefix or substring match).")
+var ListMediaQueryParams = zod228.object({
+  "limit": zod228.int().min(1).max(listMediaQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod228.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "kind": zod228.enum(["video", "audio", "image", "gif", "asset", "source", "stock"]).optional().describe("Filter to one media kind."),
+  "source": zod228.enum(["upload", "generated", "import-url", "stock"]).optional().describe("Filter by how the item entered the library."),
+  "tag": zod228.string().optional().describe("Filter to items carrying this EXACT tag (not a prefix or substring match).")
 });
 var ListMediaResponse = MediaListResponse;
-var FinalizeMediaParams = zod227.object({
-  "id": zod227.string()
+var FinalizeMediaParams = zod228.object({
+  "id": zod228.string()
 });
 var FinalizeMediaBody = MediaFinalizeRequest;
 var FinalizeMediaResponse = MediaFinalizeResponse;
@@ -8967,59 +8979,59 @@ var GenerateMediaBody = MediaGenerateRequest;
 var GenerateMediaResponse = MediaGenerateResponse;
 var ImportMediaBody = MediaImportRequest;
 var ImportMediaResponse = MediaImportResponse;
-var DeleteMediaParams = zod227.object({
-  "id": zod227.string()
+var DeleteMediaParams = zod228.object({
+  "id": zod228.string()
 });
-var DeleteMediaResponse = zod227.void();
-var GetMediaParams = zod227.object({
-  "id": zod227.string()
+var DeleteMediaResponse = zod228.void();
+var GetMediaParams = zod228.object({
+  "id": zod228.string()
 });
 var GetMediaResponse = MediaResponse;
-var GetMediaTranscriptParams2 = zod227.object({
-  "id": zod227.string()
+var GetMediaTranscriptParams2 = zod228.object({
+  "id": zod228.string()
 });
 var getMediaTranscriptQueryAfterMin = 0;
 var getMediaTranscriptQueryBeforeMin = 0;
 var getMediaTranscriptQueryLimitDefault = 20;
 var getMediaTranscriptQueryLimitMax = 100;
-var GetMediaTranscriptQueryParams = zod227.object({
-  "after": zod227.int().min(getMediaTranscriptQueryAfterMin).optional().describe("Zero-based utterance cursor returned as pagination.nextCursor."),
-  "before": zod227.int().min(getMediaTranscriptQueryBeforeMin).optional().describe("Zero-based utterance cursor for a backward page. Do not combine with after."),
-  "limit": zod227.int().min(1).max(getMediaTranscriptQueryLimitMax).default(getMediaTranscriptQueryLimitDefault).describe("Utterances per page.")
+var GetMediaTranscriptQueryParams = zod228.object({
+  "after": zod228.int().min(getMediaTranscriptQueryAfterMin).optional().describe("Zero-based utterance cursor returned as pagination.nextCursor."),
+  "before": zod228.int().min(getMediaTranscriptQueryBeforeMin).optional().describe("Zero-based utterance cursor for a backward page. Do not combine with after."),
+  "limit": zod228.int().min(1).max(getMediaTranscriptQueryLimitMax).default(getMediaTranscriptQueryLimitDefault).describe("Utterances per page.")
 });
 var GetMediaTranscriptResponse = TranscriptResponse;
-var GetMediaContextParams = zod227.object({
-  "id": zod227.string()
+var GetMediaContextParams = zod228.object({
+  "id": zod228.string()
 });
 var GetMediaContextResponse = MediaContextResponse;
-var TriggerSubjectDetectionParams2 = zod227.object({
-  "id": zod227.string()
+var TriggerSubjectDetectionParams2 = zod228.object({
+  "id": zod228.string()
 });
-var TriggerSubjectDetectionQueryParams = zod227.object({
-  "detector": zod227.enum(["face", "person"]).optional().describe("Which detector to run. Defaults to `face`; an unknown value is refused, never defaulted.")
+var TriggerSubjectDetectionQueryParams = zod228.object({
+  "detector": zod228.enum(["face", "person"]).optional().describe("Which detector to run. Defaults to `face`; an unknown value is refused, never defaulted.")
 });
 var TriggerSubjectDetectionResponse = SubjectDetectionTriggerResponse;
-var TriggerMatteBakeParams = zod227.object({
-  "id": zod227.string()
+var TriggerMatteBakeParams = zod228.object({
+  "id": zod228.string()
 });
 var TriggerMatteBakeBody = MatteBakeRequest;
 var TriggerMatteBakeResponse = MatteBakeTriggerResponse;
-var ListMediaFactsParams2 = zod227.object({
-  "id": zod227.string()
+var ListMediaFactsParams2 = zod228.object({
+  "id": zod228.string()
 });
-var ListMediaFactsQueryParams = zod227.object({
-  "kind": zod227.enum(["subjectTrack", "matte"]).optional().describe("Resolve one exact editor prerequisite. Requires startSec and endSec; the response includes the server-selected `exact` result."),
-  "startSec": zod227.number().optional().describe("Source-in of the clip's trim, in seconds. Must be sent WITH endSec \u2014 one without the other is a 400, never a silent whole-source default."),
-  "endSec": zod227.number().optional().describe("Source-out of the clip's trim, in seconds. Must be sent WITH startSec.")
+var ListMediaFactsQueryParams = zod228.object({
+  "kind": zod228.enum(["subjectTrack", "matte"]).optional().describe("Resolve one exact editor prerequisite. Requires startSec and endSec; the response includes the server-selected `exact` result."),
+  "startSec": zod228.number().optional().describe("Source-in of the clip's trim, in seconds. Must be sent WITH endSec \u2014 one without the other is a 400, never a silent whole-source default."),
+  "endSec": zod228.number().optional().describe("Source-out of the clip's trim, in seconds. Must be sent WITH startSec.")
 });
 var ListMediaFactsResponse = MediaFactsResponse;
-var PurchaseMediaFactParams = zod227.object({
-  "id": zod227.string()
+var PurchaseMediaFactParams = zod228.object({
+  "id": zod228.string()
 });
 var PurchaseMediaFactBody = MediaFactPurchaseRequest;
 var PurchaseMediaFactResponse = MediaFactPurchaseResponse;
-var AnalyzeTranscriptParams = zod227.object({
-  "id": zod227.string()
+var AnalyzeTranscriptParams = zod228.object({
+  "id": zod228.string()
 });
 var AnalyzeTranscriptBody = TranscriptAnalyzeRequest;
 var AnalyzeTranscriptResponse = TranscriptAnalyzeResponse;
@@ -9027,80 +9039,80 @@ var AnalyzeTimelineBody = TimelineAnalysisRequest;
 var AnalyzeTimelineResponse = TimelineAnalysisResponse;
 
 // ../sdk/src/generated/zod/projects/projects.ts
-import * as zod228 from "zod";
+import * as zod229 from "zod";
 var listProjectsQueryLimitMax = 100;
-var ListProjectsQueryParams = zod228.object({
-  "limit": zod228.int().min(1).max(listProjectsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod228.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
+var ListProjectsQueryParams = zod229.object({
+  "limit": zod229.int().min(1).max(listProjectsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod229.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
 });
 var ListProjectsResponse = ProjectListResponse;
 var CreateProjectBody = ProjectCreateRequest;
 var CreateProjectResponse = ProjectResponse;
-var GetProjectParams = zod228.object({
-  "id": zod228.string()
+var GetProjectParams = zod229.object({
+  "id": zod229.string()
 });
 var GetProjectResponse = ProjectResponse;
-var PatchProjectParams = zod228.object({
-  "id": zod228.string()
+var PatchProjectParams = zod229.object({
+  "id": zod229.string()
 });
 var PatchProjectBody = ProjectPatchRequest;
 var PatchProjectResponse = ProjectResponse;
-var DeleteProjectParams = zod228.object({
-  "id": zod228.string()
+var DeleteProjectParams = zod229.object({
+  "id": zod229.string()
 });
-var DeleteProjectResponse = zod228.void();
-var GetProjectContextParams = zod228.object({
-  "id": zod228.string()
+var DeleteProjectResponse = zod229.void();
+var GetProjectContextParams = zod229.object({
+  "id": zod229.string()
 });
 var GetProjectContextResponse = ProjectContextResponse;
 
 // ../sdk/src/generated/zod/renders/renders.ts
-import * as zod229 from "zod";
-var CreateRenderParams = zod229.object({
-  "id": zod229.string()
+import * as zod230 from "zod";
+var CreateRenderParams = zod230.object({
+  "id": zod230.string()
 });
 var CreateRenderBody = RenderCreateRequest;
 var CreateRenderResponse = RenderResponse;
-var ListProjectRendersParams2 = zod229.object({
-  "id": zod229.string()
+var ListProjectRendersParams2 = zod230.object({
+  "id": zod230.string()
 });
 var listProjectRendersQueryLimitMax = 100;
-var ListProjectRendersQueryParams = zod229.object({
-  "limit": zod229.int().min(1).max(listProjectRendersQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod229.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
-  "status": zod229.string().optional().describe("Comma-separated render statuses to include (e.g. `error,cancelled`). Omit for every status.")
+var ListProjectRendersQueryParams = zod230.object({
+  "limit": zod230.int().min(1).max(listProjectRendersQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod230.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only."),
+  "status": zod230.string().optional().describe("Comma-separated render statuses to include (e.g. `error,cancelled`). Omit for every status.")
 });
 var ListProjectRendersResponse = RenderListResponse;
-var PreviewClipParams = zod229.object({
-  "id": zod229.string()
+var PreviewClipParams = zod230.object({
+  "id": zod230.string()
 });
 var PreviewClipBody = PreviewClipRequest;
 var PreviewClipResponse = RenderResponse;
-var GetRenderParams = zod229.object({
-  "id": zod229.string(),
-  "renderId": zod229.string()
+var GetRenderParams = zod230.object({
+  "id": zod230.string(),
+  "renderId": zod230.string()
 });
 var GetRenderResponse = RenderResponse;
-var CancelRenderParams = zod229.object({
-  "id": zod229.string(),
-  "renderId": zod229.string()
+var CancelRenderParams = zod230.object({
+  "id": zod230.string(),
+  "renderId": zod230.string()
 });
 var CancelRenderResponse = RenderResponse;
-var RetryRenderParams = zod229.object({
-  "id": zod229.string(),
-  "renderId": zod229.string()
+var RetryRenderParams = zod230.object({
+  "id": zod230.string(),
+  "renderId": zod230.string()
 });
 var RetryRenderResponse = RenderResponse;
-var RefreshRenderUrlParams = zod229.object({
-  "id": zod229.string(),
-  "renderId": zod229.string()
+var RefreshRenderUrlParams = zod230.object({
+  "id": zod230.string(),
+  "renderId": zod230.string()
 });
 var RefreshRenderUrlResponse = RenderRefreshUrlResponse;
-var StreamRenderParams = zod229.object({
-  "id": zod229.string(),
-  "renderId": zod229.string()
+var StreamRenderParams = zod230.object({
+  "id": zod230.string(),
+  "renderId": zod230.string()
 });
-var StreamRenderResponse = zod229.unknown();
+var StreamRenderResponse = zod230.unknown();
 
 // ../sdk/src/generated/zod/resources/resources.ts
 var SearchResourcesBody = ResourceSearchRequest;
@@ -9109,106 +9121,106 @@ var ImportResourceBody = ResourceImportRequest;
 var ImportResourceResponse = ResourceImportResponse;
 
 // ../sdk/src/generated/zod/selector/selector.ts
-import * as zod230 from "zod";
-var ListSelectorCandidatesParams2 = zod230.object({
-  "id": zod230.string()
+import * as zod231 from "zod";
+var ListSelectorCandidatesParams2 = zod231.object({
+  "id": zod231.string()
 });
-var ListSelectorCandidatesQueryParams = zod230.object({
-  "groupId": zod230.string().min(1).describe("The synced-angle group to score.")
+var ListSelectorCandidatesQueryParams = zod231.object({
+  "groupId": zod231.string().min(1).describe("The synced-angle group to score.")
 });
 var ListSelectorCandidatesResponse = SelectorCandidatesResponse;
-var PreviewSelectorParams = zod230.object({
-  "id": zod230.string()
+var PreviewSelectorParams = zod231.object({
+  "id": zod231.string()
 });
 var PreviewSelectorBody = SelectorPreviewRequest;
 var PreviewSelectorResponse = SelectorCandidatesResponse;
 
 // ../sdk/src/generated/zod/sessions/sessions.ts
-import * as zod231 from "zod";
+import * as zod232 from "zod";
 var listSessionsQueryLimitMax = 100;
-var ListSessionsQueryParams = zod231.object({
-  "limit": zod231.int().min(1).max(listSessionsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod231.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
+var ListSessionsQueryParams = zod232.object({
+  "limit": zod232.int().min(1).max(listSessionsQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod232.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
 });
 var ListSessionsResponse = SessionListResponse;
 var CreateSessionBody = SessionCreateRequest;
 var CreateSessionResponse = SessionResponse;
-var GetSessionParams = zod231.object({
-  "id": zod231.string()
+var GetSessionParams = zod232.object({
+  "id": zod232.string()
 });
 var GetSessionResponse = SessionResponse;
-var DeleteSessionParams = zod231.object({
-  "id": zod231.string()
+var DeleteSessionParams = zod232.object({
+  "id": zod232.string()
 });
-var DeleteSessionResponse = zod231.void();
-var TriggerMuxJobParams = zod231.object({
-  "id": zod231.string()
+var DeleteSessionResponse = zod232.void();
+var TriggerMuxJobParams = zod232.object({
+  "id": zod232.string()
 });
 var TriggerMuxJobResponse = MuxJobResponse;
-var GetMuxJobParams = zod231.object({
-  "id": zod231.string()
+var GetMuxJobParams = zod232.object({
+  "id": zod232.string()
 });
 var GetMuxJobResponse = MuxJobResponse;
 
 // ../sdk/src/generated/zod/skills/skills.ts
-import * as zod232 from "zod";
+import * as zod233 from "zod";
 var ListSkillsResponse = SkillListResponse;
-var GetSkillParams = zod232.object({
-  "name": zod232.string()
+var GetSkillParams = zod233.object({
+  "name": zod233.string()
 });
-var GetSkillResponse = zod232.unknown();
+var GetSkillResponse = zod233.unknown();
 
 // ../sdk/src/generated/zod/traces/traces.ts
-import * as zod233 from "zod";
-var ScoreTraceParams = zod233.object({
-  "traceId": zod233.string()
+import * as zod234 from "zod";
+var ScoreTraceParams = zod234.object({
+  "traceId": zod234.string()
 });
 var ScoreTraceBody = TraceScoresRequest;
 var ScoreTraceResponse = TraceScoresResponse;
 
 // ../sdk/src/generated/zod/webhooks/webhooks.ts
-import * as zod234 from "zod";
+import * as zod235 from "zod";
 var listWebhooksQueryLimitMax = 100;
-var ListWebhooksQueryParams = zod234.object({
-  "limit": zod234.int().min(1).max(listWebhooksQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
-  "after": zod234.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
+var ListWebhooksQueryParams = zod235.object({
+  "limit": zod235.int().min(1).max(listWebhooksQueryLimitMax).optional().describe("Page size (1..100), default 20. Out-of-range or unparseable clamps into the range."),
+  "after": zod235.string().optional().describe("Opaque cursor from the previous page's `pagination.nextCursor`. Forward-only.")
 });
 var ListWebhooksResponse = WebhookListResponse;
 var CreateWebhookBody = WebhookCreateRequest;
 var CreateWebhookResponse = WebhookCreateResponse;
 var GetWebhookEventsResponse = WebhookEventCatalogResponse;
-var GetWebhookParams = zod234.object({
-  "id": zod234.string()
+var GetWebhookParams = zod235.object({
+  "id": zod235.string()
 });
 var GetWebhookResponse = WebhookResponse;
-var PatchWebhookParams = zod234.object({
-  "id": zod234.string()
+var PatchWebhookParams = zod235.object({
+  "id": zod235.string()
 });
 var PatchWebhookBody = WebhookPatchRequest;
 var PatchWebhookResponse = WebhookResponse;
-var DeleteWebhookParams = zod234.object({
-  "id": zod234.string()
+var DeleteWebhookParams = zod235.object({
+  "id": zod235.string()
 });
-var DeleteWebhookResponse = zod234.void();
-var TestWebhookParams = zod234.object({
-  "id": zod234.string()
+var DeleteWebhookResponse = zod235.void();
+var TestWebhookParams = zod235.object({
+  "id": zod235.string()
 });
 var TestWebhookResponse = WebhookTestResponse;
-var VerifyWebhookParams = zod234.object({
-  "id": zod234.string()
+var VerifyWebhookParams = zod235.object({
+  "id": zod235.string()
 });
 var VerifyWebhookResponse = WebhookVerifyResponse;
 
 // ../sdk/src/generated/zod/workspace/workspace.ts
-import * as zod235 from "zod";
+import * as zod236 from "zod";
 var createWorkspaceBodyVideoUrlMax2 = 2048;
-var CreateWorkspaceBody2 = zod235.strictObject({
-  "videoUrl": zod235.url().max(createWorkspaceBodyVideoUrlMax2),
+var CreateWorkspaceBody2 = zod236.strictObject({
+  "videoUrl": zod236.url().max(createWorkspaceBodyVideoUrlMax2),
   "format": FormatSpec.optional()
 });
-var CreateWorkspaceResponse = zod235.object({
-  "projectId": zod235.string(),
-  "mediaId": zod235.string()
+var CreateWorkspaceResponse = zod236.object({
+  "projectId": zod236.string(),
+  "mediaId": zod236.string()
 });
 
 // ../mcp/src/generated/operations.ts
@@ -9263,7 +9275,7 @@ var GENERATED_OPERATIONS = [
   { operationId: "getComponentSource", toolName: "cueframe_api_getComponentSource", title: "Get Component Source", method: "GET", pathTemplate: "/v1/components/{id}/source", pathParams: ["id"], queryParams: [], bodyKey: null, description: "Get a component's source \u2014 Required permission: projects:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "id": { "type": "string" }, "name": { "type": "string" }, "description": { "type": "string" }, "source": { "type": "string", "enum": ["default", "installed"] }, "tsxSource": { "type": "string" }, "propSchema": { "type": "object" }, "origin": { "type": "string", "enum": ["customer-owned", "server-native"] }, "ejectedFrom": { "type": "string" }, "tokens": { "type": "object" }, "examples": { "type": "array" }, "durationInFrames": { "type": "number" }, "manifest": { "type": "object" } }, "additionalProperties": true } },
   { operationId: "getComposeJob", toolName: "cueframe_api_getComposeJob", title: "Get Compose Job", method: "GET", pathTemplate: "/v1/projects/{id}/compose/jobs/{composeJobId}", pathParams: ["id", "composeJobId"], queryParams: [], bodyKey: null, description: "Fetch a compose job's full ensemble state \u2014 Required permission: projects:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "composeJobId": { "type": "string" }, "projectId": { "type": "string" }, "status": { "type": "string", "enum": ["queued", "running", "awaiting_input", "complete", "failed", "cancelled"] }, "error": { "type": ["string", "null"] }, "request": { "type": "object" }, "candidates": { "type": "array" }, "winner": {}, "listUsd": { "type": "number" }, "startedAt": { "type": "number" }, "completedAt": { "type": ["number", "null"] }, "advisoryResult": { "type": "object", "description": "The advisory envelope returned by a completed consult job (on ComposeJobDetailResponse.advisoryResult)." }, "checkpoint": { "type": "object" } }, "additionalProperties": true } },
   { operationId: "getComposeSessionComposition", toolName: "cueframe_api_getComposeSessionComposition", title: "Get Compose Session Composition", method: "GET", pathTemplate: "/v1/projects/{id}/compose-session/{sessionId}/composition", pathParams: ["id", "sessionId"], queryParams: [], bodyKey: null, description: "Read the session's scratch composition \u2014 Pure read: returns the composition currently held in the session's SCRATCH (what the author LLM has been editing over this session), NOT the project's active composition. The Director ensemble reads this back per candidate and returns it as the authored composition \u2014 the winner is saved downstream, so a candidate never commits its scratch to active. 404 when the session is unknown/foreign or has never written a scratch. \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "composition": {} }, "additionalProperties": true } },
-  { operationId: "getComposition", toolName: "cueframe_api_getComposition", title: "Get Composition", method: "GET", pathTemplate: "/v1/projects/{id}/composition", pathParams: ["id"], queryParams: [], bodyKey: null, description: "Get a project's composition \u2014 Required permission: projects:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "v": { "type": "number" }, "format": { "type": "object" }, "tracks": { "type": "array" }, "markers": { "type": "array" }, "captions": { "type": "object" }, "license": { "type": "object" }, "accessibility": { "type": "object" } }, "additionalProperties": true } },
+  { operationId: "getComposition", toolName: "cueframe_api_getComposition", title: "Get Composition", method: "GET", pathTemplate: "/v1/projects/{id}/composition", pathParams: ["id"], queryParams: [{ "name": "compositionId", "required": false, "description": "Read a SPECIFIC composition instead of the project's active one. Omit it and the active composition is returned. Pairs with `composition_id` on the apply op: an edit you can make to a second composition is one you can read back.", "style": "form", "explode": true, "allowReserved": false, "schema": { "type": "string" } }], bodyKey: null, description: "Get a project's composition \u2014 Required permission: projects:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "v": { "type": "number" }, "format": { "type": "object" }, "tracks": { "type": "array" }, "markers": { "type": "array" }, "captions": { "type": "object" }, "license": { "type": "object" }, "accessibility": { "type": "object" } }, "additionalProperties": true } },
   { operationId: "getExport", toolName: "cueframe_api_getExport", title: "Get Export", method: "GET", pathTemplate: "/v1/projects/{id}/exports/{exportId}", pathParams: ["id", "exportId"], queryParams: [], bodyKey: null, description: "Get an export job \u2014 Required permission: renders:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "id": { "type": "string" }, "format": { "type": "string", "enum": ["fcpxml", "premiere"] }, "status": { "type": "string", "enum": ["queued", "trimming", "building", "uploading", "complete", "error", "cancelled"] }, "progress": { "type": "number", "description": "Fractional progress 0..1 across the trim/build/upload pipeline. Reaches 1 only on `complete`." }, "outputUrl": { "type": ["string", "null"] }, "outputExpiresAt": { "type": ["string", "null"] }, "outputSizeBytes": { "type": ["number", "null"] }, "outputDurationSec": { "type": ["number", "null"] }, "error": { "description": "Set when status is `error`; null otherwise. The phase field localizes the failure to trim / build / upload / trigger." }, "trimCacheHit": { "type": ["boolean", "null"] }, "clipSuggestionId": { "type": ["string", "null"] }, "createdAt": { "type": "string" }, "updatedAt": { "type": "string" } }, "additionalProperties": true } },
   { operationId: "getJob", toolName: "cueframe_api_getJob", title: "Get Job", method: "GET", pathTemplate: "/v1/jobs/{jobId}", pathParams: ["jobId"], queryParams: [], bodyKey: null, description: "Get an async job's status and result \u2014 Read one async job \u2014 the uniform status/result resource behind every long-running operation. Poll until `status` is terminal (`succeeded` | `failed` | `cancelled`), then read `result` (kind-specific payload) or `error` (stable code + message). `job_timeout` means the executor died mid-run and the stall sweep reaped the job \u2014 re-enqueue the operation to retry. \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "id": { "type": "string", "description": "Job id \u2014 pass to GET /v1/jobs/{id} / wait_job." }, "jobKey": { "type": "string", "description": "Deterministic identity of the work (idempotency key, e.g. `verify-<sessionId>-<contentHash>` \u2014 the hash covers the composition AND grading inputs). Re-enqueueing the same key returns the same job while it runs." }, "kind": { "type": "string", "description": "Job family, e.g. `verify`." }, "status": { "type": "string", "description": "Poll until terminal (`succeeded` | `failed` | `cancelled`).", "enum": ["running", "succeeded", "failed", "cancelled"] }, "progress": { "description": "Executor heartbeat while running; null when none reported." }, "result": { "description": "Kind-specific payload when status is `succeeded`; null otherwise." }, "error": { "description": "Stable failure code + human message when status is `failed`; null otherwise. `job_timeout` = the executor died mid-run and the stall sweep reaped the job \u2014 re-enqueue to retry." }, "createdAt": { "type": "string" }, "updatedAt": { "type": "string" }, "completedAt": { "type": ["string", "null"] } }, "additionalProperties": true } },
   { operationId: "getMedia", toolName: "cueframe_api_getMedia", title: "Get Media", method: "GET", pathTemplate: "/v1/media/{id}", pathParams: ["id"], queryParams: [], bodyKey: null, description: "Get a media item by id \u2014 Required permission: media:read \u2014 Advanced (expert layer) \u2014 prefer the curated high-level tools (compose, apply_composition, create_render, wait_job, get_media_context) when they fit your task.", annotations: { "readOnlyHint": true, "openWorldHint": false }, outputSchema: { "type": "object", "properties": { "id": { "type": "string" }, "status": { "type": "string" }, "source": { "type": "string", "enum": ["upload", "generated", "stock"] }, "name": { "type": "string" }, "mimeType": { "type": "string" }, "fileSize": { "type": "number" }, "duration": { "type": ["number", "null"] }, "width": { "type": ["number", "null"] }, "height": { "type": ["number", "null"] }, "frameRate": { "type": ["number", "null"] }, "progress": {}, "analysis": {}, "listUsd": { "type": "number", "description": "A2 money stamp \u2014 GENERATED media only: the generate meter's LIST price (USD) at the success terminal. A plan allowance may zero the invoice line. Absent for uploads/imports, failures, x402 (on-chain receipts)." }, "thumbnailUrl": { "type": ["string", "null"], "description": "Presigned GET URL for the item's thumbnail (an uploaded image is its own thumbnail), valid ~7 days \u2014 fetch it directly, no auth header. null when no thumbnail exists yet (still processing, stock imports, audio)." }, "kind": { "type": ["string", "null"] }, "tags": {}, "attribution": {}, "processingStatus": {}, "createdAt": { "type": "string" }, "updatedAt": { "type": "string" } }, "additionalProperties": true } },