@cueframe/kernel 0.1.2 → 0.1.3

package/dist/{chunk-W3SIWT7J.js → chunk-DL7WYISQ.js}

@@ -45,6 +45,20 @@ function adviseError(err) {
 // ../sdk/src/zod.ts
 var zod_exports = {};
 __export(zod_exports, {
+  analyzeTimelineBody: () => analyzeTimelineBody,
+  analyzeTimelineBodyWordsItemClipIdMax: () => analyzeTimelineBodyWordsItemClipIdMax,
+  analyzeTimelineBodyWordsItemPoolItemIdMax: () => analyzeTimelineBodyWordsItemPoolItemIdMax,
+  analyzeTimelineBodyWordsItemSourceEndMin: () => analyzeTimelineBodyWordsItemSourceEndMin,
+  analyzeTimelineBodyWordsItemSourceStartMin: () => analyzeTimelineBodyWordsItemSourceStartMin,
+  analyzeTimelineBodyWordsItemSpeakerIdMax: () => analyzeTimelineBodyWordsItemSpeakerIdMax,
+  analyzeTimelineBodyWordsItemTextMax: () => analyzeTimelineBodyWordsItemTextMax,
+  analyzeTimelineBodyWordsItemTimelineEndMin: () => analyzeTimelineBodyWordsItemTimelineEndMin,
+  analyzeTimelineBodyWordsItemTimelineStartMin: () => analyzeTimelineBodyWordsItemTimelineStartMin,
+  analyzeTimelineBodyWordsMax: () => analyzeTimelineBodyWordsMax,
+  analyzeTimelineResponse: () => analyzeTimelineResponse,
+  analyzeTimelineResponseEmphasisItemMin: () => analyzeTimelineResponseEmphasisItemMin,
+  analyzeTimelineResponseFillersItemMin: () => analyzeTimelineResponseFillersItemMin,
+  analyzeTimelineResponseSilenceGapsItemMin: () => analyzeTimelineResponseSilenceGapsItemMin,
   analyzeTranscriptBody: () => analyzeTranscriptBody,
   analyzeTranscriptBodyWindowEndSecMin: () => analyzeTranscriptBodyWindowEndSecMin,
   analyzeTranscriptBodyWindowStartSecMin: () => analyzeTranscriptBodyWindowStartSecMin,
@@ -396,6 +410,7 @@ __export(zod_exports, {
   cancelExportResponseProgressMin: () => cancelExportResponseProgressMin,
   cancelJobParams: () => cancelJobParams,
   cancelJobResponse: () => cancelJobResponse,
+  cancelJobResponseResultArtifactsItemLayersOverlaysMin: () => cancelJobResponseResultArtifactsItemLayersOverlaysMin,
   cancelRenderParams: () => cancelRenderParams,
   cancelRenderResponse: () => cancelRenderResponse,
   cancelRenderResponseProgressScenesCompletedMin: () => cancelRenderResponseProgressScenesCompletedMin,
@@ -757,6 +772,7 @@ __export(zod_exports, {
   getExportResponseProgressMin: () => getExportResponseProgressMin,
   getJobParams: () => getJobParams,
   getJobResponse: () => getJobResponse,
+  getJobResponseResultArtifactsItemLayersOverlaysMin: () => getJobResponseResultArtifactsItemLayersOverlaysMin,
   getMediaContextParams: () => getMediaContextParams,
   getMediaContextResponse: () => getMediaContextResponse,
   getMediaParams: () => getMediaParams,
@@ -1043,8 +1059,12 @@ __export(zod_exports, {
   previewFrameBodyJpegQualityMax: () => previewFrameBodyJpegQualityMax,
   previewFrameBodyScaleMax: () => previewFrameBodyScaleMax,
   previewFrameBodyScaleMin: () => previewFrameBodyScaleMin,
+  previewFrameJobBody: () => previewFrameJobBody,
+  previewFrameJobBodyJpegQualityMax: () => previewFrameJobBodyJpegQualityMax,
+  previewFrameJobBodyScaleMax: () => previewFrameJobBodyScaleMax,
+  previewFrameJobBodyScaleMin: () => previewFrameJobBodyScaleMin,
+  previewFrameJobParams: () => previewFrameJobParams,
   previewFrameParams: () => previewFrameParams,
-  previewFrameResponse: () => previewFrameResponse,
   previewSelectorBody: () => previewSelectorBody,
   previewSelectorBodyCooldownSecMin: () => previewSelectorBodyCooldownSecMin,
   previewSelectorBodyEnterSecMin: () => previewSelectorBodyEnterSecMin,
@@ -2342,6 +2362,11 @@ var createBriefBody = zod5.object({
       "kind": zod5.literal("effect"),
       "primitiveId": zod5.string().min(1),
       "params": zod5.record(zod5.string(), zod5.unknown()).optional()
+    }).strict(), zod5.object({
+      "kind": zod5.literal("alpha-layer"),
+      "componentId": zod5.string().min(1),
+      "props": zod5.record(zod5.string(), zod5.unknown()),
+      "zPlane": zod5.enum(["front", "behind-subject"]).optional()
     }).strict(), zod5.object({
       "kind": zod5.literal("card"),
       "html": zod5.string().min(1),
@@ -2601,6 +2626,11 @@ var listBriefsResponse = zod5.object({
         "kind": zod5.literal("effect"),
         "primitiveId": zod5.string().min(1),
         "params": zod5.record(zod5.string(), zod5.unknown()).optional()
+      }), zod5.object({
+        "kind": zod5.literal("alpha-layer"),
+        "componentId": zod5.string().min(1),
+        "props": zod5.record(zod5.string(), zod5.unknown()),
+        "zPlane": zod5.enum(["front", "behind-subject"]).optional()
       }), zod5.object({
         "kind": zod5.literal("card"),
         "html": zod5.string().min(1),
@@ -2876,6 +2906,11 @@ var getBriefResponse = zod5.object({
       "kind": zod5.literal("effect"),
       "primitiveId": zod5.string().min(1),
       "params": zod5.record(zod5.string(), zod5.unknown()).optional()
+    }), zod5.object({
+      "kind": zod5.literal("alpha-layer"),
+      "componentId": zod5.string().min(1),
+      "props": zod5.record(zod5.string(), zod5.unknown()),
+      "zPlane": zod5.enum(["front", "behind-subject"]).optional()
     }), zod5.object({
       "kind": zod5.literal("card"),
       "html": zod5.string().min(1),
@@ -3141,6 +3176,11 @@ var updateBriefBody = zod5.object({
       "kind": zod5.literal("effect"),
       "primitiveId": zod5.string().min(1),
       "params": zod5.record(zod5.string(), zod5.unknown()).optional()
+    }).strict(), zod5.object({
+      "kind": zod5.literal("alpha-layer"),
+      "componentId": zod5.string().min(1),
+      "props": zod5.record(zod5.string(), zod5.unknown()),
+      "zPlane": zod5.enum(["front", "behind-subject"]).optional()
     }).strict(), zod5.object({
       "kind": zod5.literal("card"),
       "html": zod5.string().min(1),
@@ -3399,6 +3439,11 @@ var updateBriefResponse = zod5.object({
       "kind": zod5.literal("effect"),
       "primitiveId": zod5.string().min(1),
       "params": zod5.record(zod5.string(), zod5.unknown()).optional()
+    }), zod5.object({
+      "kind": zod5.literal("alpha-layer"),
+      "componentId": zod5.string().min(1),
+      "props": zod5.record(zod5.string(), zod5.unknown()),
+      "zPlane": zod5.enum(["front", "behind-subject"]).optional()
     }), zod5.object({
       "kind": zod5.literal("card"),
       "html": zod5.string().min(1),
@@ -4360,6 +4405,11 @@ var getCompositionResponse = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -4699,6 +4749,11 @@ var putCompositionBody = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }).strict(), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }).strict(), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -5150,6 +5205,11 @@ var applyCompositionOpBody = zod11.union([zod11.object({
       "kind": zod11.literal("effect"),
       "primitiveId": zod11.string().min(1),
       "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+    }).strict(), zod11.object({
+      "kind": zod11.literal("alpha-layer"),
+      "componentId": zod11.string().min(1),
+      "props": zod11.record(zod11.string(), zod11.unknown()),
+      "zPlane": zod11.enum(["front", "behind-subject"]).optional()
     }).strict(), zod11.object({
       "kind": zod11.literal("card"),
       "html": zod11.string().min(1),
@@ -5292,6 +5352,11 @@ var applyCompositionOpBody = zod11.union([zod11.object({
       "kind": zod11.literal("effect"),
       "primitiveId": zod11.string().min(1),
       "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+    }).strict(), zod11.object({
+      "kind": zod11.literal("alpha-layer"),
+      "componentId": zod11.string().min(1),
+      "props": zod11.record(zod11.string(), zod11.unknown()),
+      "zPlane": zod11.enum(["front", "behind-subject"]).optional()
     }).strict(), zod11.object({
       "kind": zod11.literal("card"),
       "html": zod11.string().min(1),
@@ -5430,6 +5495,11 @@ var applyCompositionOpBody = zod11.union([zod11.object({
       "kind": zod11.literal("effect"),
       "primitiveId": zod11.string().min(1),
       "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+    }).strict(), zod11.object({
+      "kind": zod11.literal("alpha-layer"),
+      "componentId": zod11.string().min(1),
+      "props": zod11.record(zod11.string(), zod11.unknown()),
+      "zPlane": zod11.enum(["front", "behind-subject"]).optional()
     }).strict(), zod11.object({
       "kind": zod11.literal("card"),
       "html": zod11.string().min(1),
@@ -5572,6 +5642,9 @@ var applyCompositionOpBody = zod11.union([zod11.object({
     "maxWidthPercent": zod11.number().max(applyCompositionOpBodyStyleMaxWidthPercentMax).optional()
   }).strict()
 }).strict().describe("Merge style overrides (font/color/position/emphasis) onto the composition's caption layer. Partial \u2014 omitted fields keep their current value; creates the caption container if absent."), zod11.object({
+  "type": zod11.literal("setCaptionDepth"),
+  "zPlane": zod11.enum(["front", "behind-subject"])
+}).strict().describe("Set the caption compositing plane. Use `behind-subject` to place captions behind the segmented foreground subject; use `front` for conventional captions above all video layers."), zod11.object({
   "type": zod11.literal("setCaptions"),
   "segments": zod11.array(zod11.object({
     "words": zod11.array(zod11.object({
@@ -5950,6 +6023,11 @@ var applyCompositionBody = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }).strict(), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }).strict(), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -6092,6 +6170,11 @@ var applyCompositionBody = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }).strict(), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }).strict(), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -6230,6 +6313,11 @@ var applyCompositionBody = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }).strict(), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }).strict(), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -6372,6 +6460,9 @@ var applyCompositionBody = zod11.object({
       "maxWidthPercent": zod11.number().max(applyCompositionBodyOpsItemStyleMaxWidthPercentMax).optional()
     }).strict()
   }).strict().describe("Merge style overrides (font/color/position/emphasis) onto the composition's caption layer. Partial \u2014 omitted fields keep their current value; creates the caption container if absent."), zod11.object({
+    "type": zod11.literal("setCaptionDepth"),
+    "zPlane": zod11.enum(["front", "behind-subject"])
+  }).strict().describe("Set the caption compositing plane. Use `behind-subject` to place captions behind the segmented foreground subject; use `front` for conventional captions above all video layers."), zod11.object({
     "type": zod11.literal("setCaptions"),
     "segments": zod11.array(zod11.object({
       "words": zod11.array(zod11.object({
@@ -6682,6 +6773,11 @@ var validateCompositionBody = zod11.object({
         "kind": zod11.literal("effect"),
         "primitiveId": zod11.string().min(1),
         "params": zod11.record(zod11.string(), zod11.unknown()).optional()
+      }).strict(), zod11.object({
+        "kind": zod11.literal("alpha-layer"),
+        "componentId": zod11.string().min(1),
+        "props": zod11.record(zod11.string(), zod11.unknown()),
+        "zPlane": zod11.enum(["front", "behind-subject"]).optional()
       }).strict(), zod11.object({
         "kind": zod11.literal("card"),
         "html": zod11.string().min(1),
@@ -6942,7 +7038,21 @@ var previewFrameBody = zod14.object({
   "scale": zod14.number().min(previewFrameBodyScaleMin).max(previewFrameBodyScaleMax).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": zod14.number().min(1).max(previewFrameBodyJpegQualityMax).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
 }).strict();
-var previewFrameResponse = zod14.unknown();
+var previewFrameJobParams = zod14.object({
+  "id": zod14.string()
+});
+var previewFrameJobBodyScaleMin = 0.1;
+var previewFrameJobBodyScaleMax = 1;
+var previewFrameJobBodyJpegQualityMax = 100;
+var previewFrameJobBody = zod14.object({
+  "composition": zod14.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": zod14.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": zod14.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": zod14.array(zod14.number()).min(1),
+  "imageFormat": zod14.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": zod14.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": zod14.number().min(1).max(previewFrameJobBodyJpegQualityMax).optional().describe("JPEG quality (jpeg only). Default 70 \u2014 the quality the eval panel grades at.")
+}).strict();
 var previewComponentParams = zod14.object({
   "id": zod14.string()
 });
@@ -7061,17 +7171,70 @@ import * as zod18 from "zod";
 var getJobParams = zod18.object({
   "jobId": zod18.string()
 });
+var getJobResponseResultArtifactsItemLayersOverlaysMin = 0;
 var getJobResponse = zod18.object({
   "id": zod18.string().describe("Job id \u2014 pass to GET /v1/jobs/{id} / wait_job."),
   "jobKey": zod18.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": zod18.string().describe("Job family, e.g. `verify`."),
-  "status": zod18.enum(["running", "succeeded", "failed"]).describe("Poll until terminal (`succeeded` | `failed`)."),
+  "status": zod18.enum(["running", "succeeded", "failed", "cancelled"]).describe("Poll until terminal (`succeeded` | `failed` | `cancelled`)."),
   "progress": zod18.object({
     "phase": zod18.string(),
     "percent": zod18.number().optional(),
     "message": zod18.string().optional()
   }).nullable().describe("Executor heartbeat while running; null when none reported."),
-  "result": zod18.null().optional().describe("Kind-specific payload when status is `succeeded`; null otherwise."),
+  "result": zod18.union([zod18.object({
+    "artifacts": zod18.array(zod18.object({
+      "id": zod18.string(),
+      "beatSec": zod18.number(),
+      "r2Key": zod18.string().describe("Durable private artifact identity; use the materialized url to fetch."),
+      "bytes": zod18.number(),
+      "contentType": zod18.enum(["image/png", "image/jpeg"]),
+      "layers": zod18.object({
+        "video": zod18.string().nullable(),
+        "overlays": zod18.number().min(getJobResponseResultArtifactsItemLayersOverlaysMin)
+      }),
+      "url": zod18.string().optional(),
+      "urlExpiresAt": zod18.string().optional()
+    })),
+    "geometry": zod18.object({
+      "scale": zod18.number(),
+      "compositionWidth": zod18.number().optional(),
+      "compositionHeight": zod18.number().optional(),
+      "width": zod18.number().optional(),
+      "height": zod18.number().optional()
+    }),
+    "warnings": zod18.array(zod18.record(zod18.string(), zod18.unknown())).optional(),
+    "previewed": zod18.object({
+      "source": zod18.enum(["inline", "scratch", "persisted"]),
+      "compositionId": zod18.string().optional(),
+      "etag": zod18.string().optional()
+    }),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered capture.")
+  }), zod18.union([zod18.object({
+    "artifactKind": zod18.literal("image"),
+    "contentType": zod18.enum(["image/png", "image/jpeg"]),
+    "outputR2Key": zod18.string(),
+    "cached": zod18.boolean(),
+    "url": zod18.string().optional(),
+    "urlExpiresAt": zod18.string().optional(),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered preview.")
+  }), zod18.object({
+    "artifactKind": zod18.literal("motion"),
+    "contentType": zod18.literal("video/webm"),
+    "outputR2Key": zod18.string(),
+    "cached": zod18.boolean(),
+    "url": zod18.string().optional(),
+    "urlExpiresAt": zod18.string().optional(),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered preview.")
+  })]), zod18.object({
+    "perCriterion": zod18.unknown().optional(),
+    "composite": zod18.number(),
+    "critique": zod18.string(),
+    "checkpointId": zod18.string(),
+    "stillR2Keys": zod18.array(zod18.string()),
+    "clientScores": zod18.array(zod18.unknown()).optional(),
+    "evalCostUsd": zod18.number().optional()
+  }), zod18.record(zod18.string(), zod18.unknown()), zod18.null()]).describe("Kind-specific payload when status is `succeeded`; null otherwise."),
   "error": zod18.object({
     "code": zod18.string(),
     "message": zod18.string()
@@ -7083,17 +7246,70 @@ var getJobResponse = zod18.object({
 var cancelJobParams = zod18.object({
   "jobId": zod18.string()
 });
+var cancelJobResponseResultArtifactsItemLayersOverlaysMin = 0;
 var cancelJobResponse = zod18.object({
   "id": zod18.string().describe("Job id \u2014 pass to GET /v1/jobs/{id} / wait_job."),
   "jobKey": zod18.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": zod18.string().describe("Job family, e.g. `verify`."),
-  "status": zod18.enum(["running", "succeeded", "failed"]).describe("Poll until terminal (`succeeded` | `failed`)."),
+  "status": zod18.enum(["running", "succeeded", "failed", "cancelled"]).describe("Poll until terminal (`succeeded` | `failed` | `cancelled`)."),
   "progress": zod18.object({
     "phase": zod18.string(),
     "percent": zod18.number().optional(),
     "message": zod18.string().optional()
   }).nullable().describe("Executor heartbeat while running; null when none reported."),
-  "result": zod18.null().optional().describe("Kind-specific payload when status is `succeeded`; null otherwise."),
+  "result": zod18.union([zod18.object({
+    "artifacts": zod18.array(zod18.object({
+      "id": zod18.string(),
+      "beatSec": zod18.number(),
+      "r2Key": zod18.string().describe("Durable private artifact identity; use the materialized url to fetch."),
+      "bytes": zod18.number(),
+      "contentType": zod18.enum(["image/png", "image/jpeg"]),
+      "layers": zod18.object({
+        "video": zod18.string().nullable(),
+        "overlays": zod18.number().min(cancelJobResponseResultArtifactsItemLayersOverlaysMin)
+      }),
+      "url": zod18.string().optional(),
+      "urlExpiresAt": zod18.string().optional()
+    })),
+    "geometry": zod18.object({
+      "scale": zod18.number(),
+      "compositionWidth": zod18.number().optional(),
+      "compositionHeight": zod18.number().optional(),
+      "width": zod18.number().optional(),
+      "height": zod18.number().optional()
+    }),
+    "warnings": zod18.array(zod18.record(zod18.string(), zod18.unknown())).optional(),
+    "previewed": zod18.object({
+      "source": zod18.enum(["inline", "scratch", "persisted"]),
+      "compositionId": zod18.string().optional(),
+      "etag": zod18.string().optional()
+    }),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered capture.")
+  }), zod18.union([zod18.object({
+    "artifactKind": zod18.literal("image"),
+    "contentType": zod18.enum(["image/png", "image/jpeg"]),
+    "outputR2Key": zod18.string(),
+    "cached": zod18.boolean(),
+    "url": zod18.string().optional(),
+    "urlExpiresAt": zod18.string().optional(),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered preview.")
+  }), zod18.object({
+    "artifactKind": zod18.literal("motion"),
+    "contentType": zod18.literal("video/webm"),
+    "outputR2Key": zod18.string(),
+    "cached": zod18.boolean(),
+    "url": zod18.string().optional(),
+    "urlExpiresAt": zod18.string().optional(),
+    "listUsd": zod18.number().optional().describe("List price charged for this delivered preview.")
+  })]), zod18.object({
+    "perCriterion": zod18.unknown().optional(),
+    "composite": zod18.number(),
+    "critique": zod18.string(),
+    "checkpointId": zod18.string(),
+    "stillR2Keys": zod18.array(zod18.string()),
+    "clientScores": zod18.array(zod18.unknown()).optional(),
+    "evalCostUsd": zod18.number().optional()
+  }), zod18.record(zod18.string(), zod18.unknown()), zod18.null()]).describe("Kind-specific payload when status is `succeeded`; null otherwise."),
   "error": zod18.object({
     "code": zod18.string(),
     "message": zod18.string()
@@ -7130,7 +7346,8 @@ var createMediaUploadBodySizeMax = 10737418240;
 var createMediaUploadBody = zod19.object({
   "filename": zod19.string().min(1).max(createMediaUploadBodyFilenameMax),
   "contentType": zod19.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": zod19.number().max(createMediaUploadBodySizeMax)
+  "size": zod19.number().max(createMediaUploadBodySizeMax),
+  "projectId": zod19.string().min(1).optional()
 }).strict().describe("POST /media upload initiation body.");
 var listMediaResponse = zod19.object({
   "data": zod19.array(zod19.object({
@@ -7524,6 +7741,36 @@ var analyzeTranscriptResponse = zod19.object({
   "result": zod19.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."),
   "model": zod19.string().describe("The model that produced this answer (e.g. `claude-sonnet-4-6`). Recorded on the response because the same task on the same transcript is not stable across models \u2014 if you cache or compare answers, key on this.")
 }).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.");
+var analyzeTimelineBodyWordsItemTextMax = 1e3;
+var analyzeTimelineBodyWordsItemTimelineStartMin = 0;
+var analyzeTimelineBodyWordsItemTimelineEndMin = 0;
+var analyzeTimelineBodyWordsItemClipIdMax = 256;
+var analyzeTimelineBodyWordsItemPoolItemIdMax = 256;
+var analyzeTimelineBodyWordsItemSourceStartMin = 0;
+var analyzeTimelineBodyWordsItemSourceEndMin = 0;
+var analyzeTimelineBodyWordsItemSpeakerIdMax = 256;
+var analyzeTimelineBodyWordsMax = 12e3;
+var analyzeTimelineBody = zod19.object({
+  "words": zod19.array(zod19.object({
+    "text": zod19.string().min(1).max(analyzeTimelineBodyWordsItemTextMax),
+    "timelineStart": zod19.number().min(analyzeTimelineBodyWordsItemTimelineStartMin),
+    "timelineEnd": zod19.number().min(analyzeTimelineBodyWordsItemTimelineEndMin),
+    "clipId": zod19.string().min(1).max(analyzeTimelineBodyWordsItemClipIdMax),
+    "poolItemId": zod19.string().min(1).max(analyzeTimelineBodyWordsItemPoolItemIdMax),
+    "sourceStart": zod19.number().min(analyzeTimelineBodyWordsItemSourceStartMin),
+    "sourceEnd": zod19.number().min(analyzeTimelineBodyWordsItemSourceEndMin),
+    "speakerId": zod19.string().max(analyzeTimelineBodyWordsItemSpeakerIdMax).nullable()
+  }).strict()).min(1).max(analyzeTimelineBodyWordsMax)
+}).strict().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.");
+var analyzeTimelineResponseFillersItemMin = 0;
+var analyzeTimelineResponseSilenceGapsItemMin = 0;
+var analyzeTimelineResponseEmphasisItemMin = 0;
+var analyzeTimelineResponse = zod19.object({
+  "fillers": zod19.array(zod19.number().min(analyzeTimelineResponseFillersItemMin)),
+  "silenceGaps": zod19.array(zod19.number().min(analyzeTimelineResponseSilenceGapsItemMin)),
+  "emphasis": zod19.array(zod19.number().min(analyzeTimelineResponseEmphasisItemMin)),
+  "model": zod19.string()
+}).describe("CueFrame-model analysis of timeline word indices. Every returned index refers to the request's words array.");
 
 // ../sdk/src/generated/zod/projects/projects.ts
 import * as zod20 from "zod";
@@ -7853,6 +8100,11 @@ var getProjectContextResponse = zod20.object({
           "kind": zod20.literal("effect"),
           "primitiveId": zod20.string().min(1),
           "params": zod20.record(zod20.string(), zod20.unknown()).optional()
+        }), zod20.object({
+          "kind": zod20.literal("alpha-layer"),
+          "componentId": zod20.string().min(1),
+          "props": zod20.record(zod20.string(), zod20.unknown()),
+          "zPlane": zod20.enum(["front", "behind-subject"]).optional()
         }), zod20.object({
           "kind": zod20.literal("card"),
           "html": zod20.string().min(1),
@@ -8726,12 +8978,13 @@ var createWorkspaceBody = zod28.object({
 
 // ../mcp/src/generated/operations.ts
 var GENERATED_OPERATIONS = [
+  { operationId: "analyzeTimeline", toolName: "cueframe_api_analyzeTimeline", title: "Analyze Timeline", method: "POST", pathTemplate: "/v1/timeline-analysis", pathParams: [], bodyKey: "analyzeTimelineBody", description: "Analyze a timeline transcript for edit decisions \u2014 Returns filler, silence-gap, and emphasis word indices for an editor timeline. CueFrame selects and runs the model server-side; provider, API key, and model overrides are not accepted. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "analyzeTranscript", toolName: "cueframe_api_analyzeTranscript", title: "Analyze Transcript", method: "POST", pathTemplate: "/v1/media/{id}/transcript/analyze", pathParams: ["id"], bodyKey: "analyzeTranscriptBody", description: "Analyse a media item's transcript \u2014 Ask ONE editorial question of a transcript and get the answer as text: `summary` (what is actually said, plus the takeaways), `chapters` (where the subject changes), or `highlights` (the moments that stand alone as a short). PRECISION: timestamps are ABSOLUTE seconds from the start of the media and every one is verified against the transcript before you see it (a fabricated timestamp fails the call rather than shipping) \u2014 but they are LINE-START markers roughly 15s apart, so a boundary can sit up to 15s BEFORE the moment you asked for. Treat every span as APPROXIMATE: use it to LOCATE the moment, then refine the in/out against the word timings from GET /v1/media/{id}/context before you cut. Feeding a raw span straight into a clip trim will start it mid-sentence. Pass `window` to analyse one slice; omit it for the whole thing. This is a METERED LLM call, not a read: it bills on measured token spend, and a recording too long to analyse in one pass is rejected with 422 `transcript_too_long` (over ~100k characters, roughly two hours of speech) rather than silently summarising only its first half \u2014 narrow it with `window`. 422 `media_no_transcript` means the item has no speech on file (or none inside your window); GET /v1/media/{id}/context shows transcript state, and GET /v1/media/{id}/transcript returns the raw words. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "applyComposition", toolName: "cueframe_api_applyComposition", title: "Apply Composition", method: "POST", pathTemplate: "/v1/projects/{id}/composition/apply", pathParams: ["id"], bodyKey: "applyCompositionBody", description: "Apply a batch of operations to a project's composition (or dry-run validate) \u2014 Atomically applies an array of CompositionOps. All ops succeed or none do (transactional). Pass `if_match` for optimistic-concurrency control (409 stale_etag on mismatch). Pass `dry_run: true` to validate the batch \u2014 runs the same apply + projection accept/reject guards WITHOUT persisting, returning `{ valid, errors }` with `locator.op_index` on the first failing op. Both modes may carry `warnings[]` \u2014 non-fatal authoring advisories (e.g. a card whose html reads a CSS custom property no token defines). Warnings never block. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "applyCompositionOp", toolName: "cueframe_api_applyCompositionOp", title: "Apply Composition Op", method: "POST", pathTemplate: "/v1/projects/{id}/composition/ops", pathParams: ["id"], bodyKey: "applyCompositionOpBody", description: "Apply one operation to a project's composition \u2014 Required permission: projects:write \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "cancelCompose", toolName: "cueframe_api_cancelCompose", title: "Cancel Compose", method: "POST", pathTemplate: "/v1/projects/{id}/compose/jobs/{composeJobId}/cancel", pathParams: ["id", "composeJobId"], bodyKey: null, description: "Cancel an in-flight compose job \u2014 Cancel a running compose so an agent (or a cost guard) can abort a mis-priced or runaway ensemble without waiting out its budget or TTL. The director-worker cancel is confirmed BEFORE the row flips; the terminal seam fires compose.cancelled and releases any linked charge. Already-terminal jobs are rejected (422 compose_not_cancellable). \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "cancelExport", toolName: "cueframe_api_cancelExport", title: "Cancel Export", method: "POST", pathTemplate: "/v1/projects/{id}/exports/{exportId}/cancel", pathParams: ["id", "exportId"], bodyKey: null, description: "Cancel an in-flight export \u2014 Required permission: renders:write \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
-  { operationId: "cancelJob", toolName: "cueframe_api_cancelJob", title: "Cancel Job", method: "POST", pathTemplate: "/v1/jobs/{jobId}/cancel", pathParams: ["jobId"], bodyKey: null, description: "Cancel an async job \u2014 Cancel a running async job so an agent can abort a mis-priced/runaway operation without waiting out its TTL. For box-backed kinds (verify, preview) the warm box is reaped best-effort. Cancel never meters. Already-terminal jobs are rejected (422 job_not_cancellable). \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
+  { operationId: "cancelJob", toolName: "cueframe_api_cancelJob", title: "Cancel Job", method: "POST", pathTemplate: "/v1/jobs/{jobId}/cancel", pathParams: ["jobId"], bodyKey: null, description: "Cancel an async job \u2014 Cancel a running async job so an agent can abort a mis-priced/runaway operation without waiting out its TTL. Durable workflows are cancelled from the persisted execution receipt; legacy warm boxes are reaped when present. Cancel never meters. Already-terminal jobs are rejected (422 job_not_cancellable). \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "cancelRender", toolName: "cueframe_api_cancelRender", title: "Cancel Render", method: "POST", pathTemplate: "/v1/projects/{id}/renders/{renderId}/cancel", pathParams: ["id", "renderId"], bodyKey: null, description: "Cancel a render \u2014 Required permission: renders:write \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "closeComposeSession", toolName: "cueframe_api_closeComposeSession", title: "Close Compose Session", method: "DELETE", pathTemplate: "/v1/projects/{id}/compose-session/{sessionId}", pathParams: ["id", "sessionId"], bodyKey: null, description: "Close a compose session \u2014 Required permission: projects:write \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": false, "destructiveHint": true, "idempotentHint": true, "openWorldHint": false } },
   { operationId: "commitComposeSession", toolName: "cueframe_api_commitComposeSession", title: "Commit Compose Session", method: "POST", pathTemplate: "/v1/projects/{id}/compose-session/{sessionId}/commit", pathParams: ["id", "sessionId"], bodyKey: null, description: "Commit the session scratch onto the project's active composition \u2014 Required permission: projects:write \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
@@ -8777,7 +9030,7 @@ var GENERATED_OPERATIONS = [
   { operationId: "getComposeSessionComposition", toolName: "cueframe_api_getComposeSessionComposition", title: "Get Compose Session Composition", method: "GET", pathTemplate: "/v1/projects/{id}/compose-session/{sessionId}/composition", pathParams: ["id", "sessionId"], 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 } },
   { operationId: "getComposition", toolName: "cueframe_api_getComposition", title: "Get Composition", method: "GET", pathTemplate: "/v1/projects/{id}/composition", pathParams: ["id"], 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 } },
   { operationId: "getExport", toolName: "cueframe_api_getExport", title: "Get Export", method: "GET", pathTemplate: "/v1/projects/{id}/exports/{exportId}", pathParams: ["id", "exportId"], 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 } },
-  { operationId: "getJob", toolName: "cueframe_api_getJob", title: "Get Job", method: "GET", pathTemplate: "/v1/jobs/{jobId}", pathParams: ["jobId"], 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`), 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 } },
+  { operationId: "getJob", toolName: "cueframe_api_getJob", title: "Get Job", method: "GET", pathTemplate: "/v1/jobs/{jobId}", pathParams: ["jobId"], 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 } },
   { operationId: "getMedia", toolName: "cueframe_api_getMedia", title: "Get Media", method: "GET", pathTemplate: "/v1/media/{id}", pathParams: ["id"], 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 } },
   { operationId: "getMediaContext", toolName: "cueframe_api_getMediaContext", title: "Get Media Context", method: "GET", pathTemplate: "/v1/media/{id}/context", pathParams: ["id"], bodyKey: null, description: "Get authoring context for a media item (faces + transcript + beat/word grids) \u2014 The read-only context an agent needs to author a composition over this source: the detected face/subject roster (face-0 = primary speaker, with normalized bbox + active-speaker share), the transcript, the temporal grids \u2014 `beatGrid` (a MUSIC bed's rhythm: bpm, beatTimesMs in milliseconds, confidence, method) and `wordGrid` (VO word-onset timings in milliseconds, from the transcript) \u2014 and a presigned `thumbnail` (~the footage at a glance). For stills at CHOSEN timestamps, call preview_frame with a one-clip composition over this media. Call this before authoring crop intents (reframe) and overlay/caption timing. Faces are lazily detected \u2014 `faces.status` is `not_detected` until a compose/detect pass has run over the source, never a faked empty roster. `beatGrid` is null until beat analysis has run: generated music beds are analyzed automatically at delivery; an uploaded/imported bed may not carry a grid yet (on-demand analysis is not client-triggerable today). `audioRole` is the DECLARED role of an audio asset (vo | music | sfx | ambience) \u2014 author the clip source's `audioRole` from it; `envelope` carries the coarse `envelopeClass` (transient | sweep | ambient) plus any probed attack/centroid/volume stats. Both are null for footage/images or an undeclared audio asset. \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 } },
   { operationId: "getMediaPerformance", toolName: "cueframe_api_getMediaPerformance", title: "Get Media Performance", method: "GET", pathTemplate: "/v1/media/{id}/performance", pathParams: ["id"], bodyKey: null, description: "Per-media performance breakdown (Axiom workflow + activity spans) \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 } },
@@ -8815,12 +9068,13 @@ var GENERATED_OPERATIONS = [
   { operationId: "listSkills", toolName: "cueframe_api_listSkills", title: "List Skills", method: "GET", pathTemplate: "/v1/skills", pathParams: [], bodyKey: null, description: "List available CueFrame agent skills \u2014 Returns the agent skills CueFrame publishes (e.g. `cueframe-cli`). Metadata only \u2014 fetch the markdown body from GET /skills/{name}. Unauthenticated, like /openapi.json. \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 } },
   { operationId: "listWebhooks", toolName: "cueframe_api_listWebhooks", title: "List Webhooks", method: "GET", pathTemplate: "/v1/webhooks", pathParams: [], bodyKey: null, description: "List webhook endpoints \u2014 Required permission: webhooks: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 } },
   { operationId: "newComposition", toolName: "cueframe_api_newComposition", title: "New Composition", method: "POST", pathTemplate: "/v1/projects/{id}/compositions", pathParams: ["id"], bodyKey: "newCompositionBody", description: "Create a new composition (video) in a project \u2014 Required permission: projects:write \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
-  { operationId: "openComposeSession", toolName: "cueframe_api_openComposeSession", title: "Open Compose Session", method: "POST", pathTemplate: "/v1/projects/{id}/compose-session", pathParams: ["id"], bodyKey: "openComposeSessionBody", description: "Open a live compose session \u2014 Boot a warm reactive render session for the project. Render frames on demand via the session's /render endpoint; closed automatically after idle TTL or explicitly via DELETE. Optionally seed the session scratch FROM a supplied composition (seedComposition) instead of the project's active \u2014 the body is optional (a bodyless open derives from active). \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
+  { operationId: "openComposeSession", toolName: "cueframe_api_openComposeSession", title: "Open Compose Session", method: "POST", pathTemplate: "/v1/projects/{id}/compose-session", pathParams: ["id"], bodyKey: "openComposeSessionBody", description: "Open an isolated scratch composition \u2014 Mint isolated scratch state for project authoring. This returns immediately and starts no sandbox or render provider; use /preview-frame-jobs and /score-composition for durable preview and verification work. The scratch closes automatically after its idle TTL or explicitly via DELETE. Optionally seed it from a supplied composition (seedComposition); a bodyless open derives from the project's active composition. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "patchProject", toolName: "cueframe_api_patchProject", title: "Patch Project", method: "PATCH", pathTemplate: "/v1/projects/{id}", pathParams: ["id"], bodyKey: "patchProjectBody", description: "Update a project \u2014 Required permission: projects:write \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": false, "destructiveHint": true, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "patchWebhook", toolName: "cueframe_api_patchWebhook", title: "Patch Webhook", method: "PATCH", pathTemplate: "/v1/webhooks/{id}", pathParams: ["id"], bodyKey: "patchWebhookBody", description: "Update a webhook endpoint \u2014 Required permission: webhooks:write \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": false, "destructiveHint": true, "idempotentHint": false, "openWorldHint": true } },
   { operationId: "previewClip", toolName: "cueframe_api_previewClip", title: "Preview Clip", method: "POST", pathTemplate: "/v1/projects/{id}/preview-clip", pathParams: ["id"], bodyKey: "previewClipBody", description: "Render a scoped motion preview of the composition \u2014 A cheap, watchable MP4 of ONLY [fromSec, toSec) of the composition at preview quality (capped resolution, lighter encode). The way to judge motion \u2014 a cut, a transition, a component's animation \u2014 with real fidelity BEFORE paying for a full render. Async: returns a render job; wait_job(kind='render') or webhook render.completed for the URL. Meters the capture feature, never an exports credit. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
-  { operationId: "previewComponent", toolName: "cueframe_api_previewComponent", title: "Preview Component", method: "POST", pathTemplate: "/v1/projects/{id}/component-preview", pathParams: ["id"], bodyKey: "previewComponentBody", description: "Render one component's motion-clip preview \u2014 Queue a MOTION-clip render of ONE org-installed component (VP9-alpha webm). It is the SAME content-addressed bake the production render composites \u2014 so what you preview is literally the object that ships, and previewing an unchanged component is free. Returns a jobId \u2014 wait_job(kind='preview') for the clip. Compile/runtime failures land on the job terminal with the sanitized author-fixable message. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
+  { operationId: "previewComponent", toolName: "cueframe_api_previewComponent", title: "Preview Component", method: "POST", pathTemplate: "/v1/projects/{id}/component-preview", pathParams: ["id"], bodyKey: "previewComponentBody", description: "Render one component preview \u2014 Queue a preview of ONE org-installed component. Baked components return the SAME content-addressed VP9-alpha motion clip the production render composites; live components return a still captured through the live JS lane without silently baking. Returns a jobId \u2014 wait_job(kind='preview') for the artifact. Compile/runtime failures land on the job terminal with the sanitized author-fixable message. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "previewFrame", toolName: "cueframe_api_previewFrame", title: "Preview Frame", method: "POST", pathTemplate: "/v1/projects/{id}/preview-frame", pathParams: ["id"], bodyKey: "previewFrameBody", description: "Render still frame(s) of a composition \u2014 Render presigned still(s) of the composition at the given timestamps \u2014 the live preview for layout/copy judgment (a still cannot show motion: judge motion with preview_clip or preview_component). Stateless: nothing to open, warm, or close, and concurrent previews no longer contend. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
+  { operationId: "previewFrameJob", toolName: "cueframe_api_previewFrameJob", title: "Preview Frame Job", method: "POST", pathTemplate: "/v1/projects/{id}/preview-frame-jobs", pathParams: ["id"], bodyKey: "previewFrameJobBody", description: "Queue still-frame evidence for a composition \u2014 Resolve and freeze the exact authored target, then queue durable still capture. Returns immediately; poll the generic job with wait_job(kind='preview_frame'). One successful request is one compose_capture operation regardless of timestamp count. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "previewSelector", toolName: "cueframe_api_previewSelector", title: "Preview Selector", method: "POST", pathTemplate: "/v1/projects/{id}/selector/preview", pathParams: ["id"], bodyKey: "previewSelectorBody", description: "Re-resolve a switch advisory under a hand-supplied policy (A/B taste; not persisted) \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "purchaseMediaFact", toolName: "cueframe_api_purchaseMediaFact", title: "Purchase Media Fact", method: "POST", pathTemplate: "/v1/media/{id}/facts", pathParams: ["id"], bodyKey: "purchaseMediaFactBody", description: "Buy a derived fact (subject track or behind-subject matte) \u2014 Purchases one enhancement for this source. `matte` REQUIRES `intent:{startSec,endSec}` \u2014 the clip's SOURCE window \u2014 because a matte's cost scales with its duration. For `subjectTrack` the same `intent` is OPTIONAL: give the clip's source window to buy the track the render will look up for THAT clip (and pay only for its duration); omit it for the whole source. If the fact already exists (pending or ready) this returns it with `alreadyExisted:true` and charges nothing. Charging happens on DELIVERY, never here: a job that never lands is never billed. \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": false, "destructiveHint": false, "idempotentHint": false, "openWorldHint": false } },
   { operationId: "putComposition", toolName: "cueframe_api_putComposition", title: "Put Composition", method: "PUT", pathTemplate: "/v1/projects/{id}/composition", pathParams: ["id"], bodyKey: "putCompositionBody", description: "Replace a project's composition \u2014 Required permission: projects:write \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": false, "destructiveHint": true, "idempotentHint": true, "openWorldHint": false } },
@@ -9066,10 +9320,10 @@ function paymentRequiredResult(paymentRequired) {
     structuredContent: paymentRequired
   };
 }
-async function dispatchOp(ex, op, mapArg, body, extra, label, formatOk) {
+async function dispatchOp(ex, op, mapArg, body, extra, label, formatOk, query) {
   const paymentObj = extractPaymentFromMeta(extra?._meta);
   const payment = paymentObj ? encodePaymentSignature(paymentObj) : void 0;
-  const res = await invokeOp(ex, op, mapArg, body, payment);
+  const res = await invokeOp(ex, op, mapArg, body, payment, query);
   if (res.status === MCP_PAYMENT_REQUIRED_CODE) {
     const parsed = safeParse(res.text);
     if (isX402PaymentRequired(parsed)) return paymentRequiredResult(parsed);

package/dist/{chunk-PIURX6IZ.js → chunk-GIA2SVVB.js}

@@ -6,7 +6,7 @@ import {
 import {
   CueframeError,
   encodeError
-} from "./chunk-LLUW26BS.js";
+} from "./chunk-AW57IWNW.js";
 
 // ../composition/src/projection/cardTokens.ts
 var CARD_MOTION_VAR_NAMES = [

package/dist/{chunk-CAJQ7H5A.js → chunk-HBVAZXYO.js}

@@ -35,7 +35,7 @@ import {
 import {
   CueframeError,
   encodeError
-} from "./chunk-LLUW26BS.js";
+} from "./chunk-AW57IWNW.js";
 
 // ../execution/compose/src/primitiveRegistry.ts
 var allCatalogs = [