@cueframe/kernel 0.1.1 → 0.1.2

package/dist/chunk-LJ5W4ZBU.js

@@ -0,0 +1,146 @@
+import {
+  ChatErrorView,
+  DirectorTurnContext
+} from "./chunk-ZPLJ24OV.js";
+import {
+  GenerationArtifact
+} from "./chunk-73DQTUWY.js";
+
+// ../director/src/ai-sdk/messages.ts
+import { z } from "zod";
+var CueFrameMessageMetadata = z.object({
+  createdAt: z.number().int().nonnegative(),
+  runId: z.string().optional(),
+  backend: z.enum(["cli", "ts-agent", "convex-agent", "direct"]).optional(),
+  context: DirectorTurnContext.optional()
+}).optional();
+var CueFramePhase = z.object({ phase: z.string(), detail: z.string().optional() });
+var CueFrameIteration = z.object({
+  iteration: z.number().int().nonnegative(),
+  maxIterations: z.number().int().positive(),
+  agent: z.string()
+});
+var CueFrameSuggestions = z.object({ items: z.array(z.string()) });
+var CueFramePlan = z.object({ plan: z.string() });
+var CueFrameRunOutcome = z.object({
+  outcome: z.enum(["aborted", "error"]),
+  reason: z.string().optional(),
+  wrote: z.boolean(),
+  phase: z.string().optional()
+});
+var cueFrameDataPartSchemas = {
+  phase: CueFramePhase,
+  iteration: CueFrameIteration,
+  suggestions: CueFrameSuggestions,
+  plan: CueFramePlan,
+  run: CueFrameRunOutcome,
+  generation: GenerationArtifact,
+  error: ChatErrorView
+};
+
+// ../director/src/ai-sdk/chunks.ts
+function dataChunk(name, data, id) {
+  return { type: `data-${name}`, data, ...id ? { id } : {} };
+}
+function chunksForDirectorEvent(event) {
+  switch (event.type) {
+    case "phase":
+      return [dataChunk("phase", { phase: event.phase, ...event.detail ? { detail: event.detail } : {} })];
+    case "generation":
+      return [dataChunk("generation", event.artifact, `generation:${event.artifact.generationId}`)];
+    case "error":
+      return [dataChunk("error", event.error)];
+    case "finish":
+      return [{ type: "finish", finishReason: "stop" }];
+    default:
+      return [];
+  }
+}
+
+// ../director/src/ai-sdk/context.ts
+function contentFor(message) {
+  const content = [];
+  for (const part of message.parts) {
+    if (part.type === "text" && part.text.trim()) content.push(part.text.trim());
+    if (part.type === "data-generation") {
+      const artifact = part.data;
+      content.push(
+        `[Media reference: mediaId=${artifact.mediaId}; kind=${artifact.kind}; version=${artifact.version}; status=${artifact.status}; summary=${JSON.stringify(artifact.requestSummary)}]`
+      );
+    }
+  }
+  return content.join("\n");
+}
+function projectDirectorHistory(messages, maxChars = 3e4) {
+  const projected = messages.map((message) => ({
+    role: message.role,
+    content: contentFor(message)
+  })).filter(
+    (message) => (message.role === "user" || message.role === "assistant" || message.role === "system") && message.content.length > 0
+  );
+  if (projected.length === 0) return [];
+  const latest = projected.at(-1);
+  const boundedLatest = latest.content.length <= maxChars ? latest : {
+    ...latest,
+    content: `${latest.content.slice(0, Math.max(1, maxChars - 80))}
+[Latest request truncated to the context limit.]`
+  };
+  let remaining = Math.max(0, maxChars - boundedLatest.content.length);
+  const kept = [boundedLatest];
+  for (let i = projected.length - 2; i >= 0; i -= 1) {
+    const message = projected[i];
+    if (message.content.length > remaining) continue;
+    kept.unshift(message);
+    remaining -= message.content.length;
+  }
+  return kept;
+}
+
+// ../director/src/ai-sdk/generationTool.ts
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function outputKind(generator) {
+  if (generator.includes("image") && !generator.includes("video")) return "image";
+  if (generator.includes("music") || generator.includes("speech") || generator.includes("sfx")) return "audio";
+  return "video";
+}
+function generationArtifactFromToolResult(args) {
+  if (args.toolName !== "generate_media") return null;
+  const payload = asRecord(args.output);
+  if (!payload || typeof payload.id !== "string" || payload.id.length === 0) return null;
+  const input = asRecord(args.input);
+  const body = asRecord(input?.body);
+  const generator = typeof body?.generator === "string" ? body.generator : "auto";
+  const kind = outputKind(generator);
+  const now = args.now ?? Date.now();
+  return GenerationArtifact.parse({
+    artifactVersion: 1,
+    clientRequestId: `generationRequest_${args.toolCallId}`,
+    generationId: typeof payload.workflowId === "string" && payload.workflowId.length > 0 ? payload.workflowId : `generation_${payload.id}`,
+    mediaId: payload.id,
+    generationGroupId: `generationGroup_${payload.id}`,
+    version: 1,
+    kind,
+    requestSummary: typeof body?.prompt === "string" && body.prompt.trim() ? body.prompt.trim().slice(0, 500) : `Generated ${kind}`,
+    status: "queued",
+    placementReady: false,
+    ...typeof payload.estimateUsd === "number" ? { estimateUsd: payload.estimateUsd } : {},
+    createdAt: now,
+    updatedAt: now
+  });
+}
+
+export {
+  CueFrameMessageMetadata,
+  CueFramePhase,
+  CueFrameIteration,
+  CueFrameSuggestions,
+  CueFramePlan,
+  CueFrameRunOutcome,
+  cueFrameDataPartSchemas,
+  dataChunk,
+  chunksForDirectorEvent,
+  projectDirectorHistory,
+  generationArtifactFromToolResult
+};

package/dist/chunk-LLUW26BS.js

@@ -0,0 +1,255 @@
+// ../errors/src/registry.ts
+var ERROR_CODES = {
+  unauthorized: { stage: "auth", category: "authoring", retryable: false, httpStatus: 401 },
+  forbidden: { stage: "auth", category: "authoring", retryable: false, httpStatus: 403 },
+  not_found: { stage: "auth", category: "authoring", retryable: false, httpStatus: 404 },
+  billing_required: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  billing_unavailable: { stage: "billing", category: "transient", retryable: true, httpStatus: 503 },
+  rate_limited: { stage: "billing", category: "transient", retryable: true, httpStatus: 429 },
+  too_many_active_sessions: { stage: "billing", category: "transient", retryable: true, httpStatus: 429 },
+  payment_required: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  payment_not_accepted: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  payment_verification_failed: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  payment_invalid: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  payment_replay: { stage: "billing", category: "authoring", retryable: false, httpStatus: 409 },
+  generation_budget_exceeded: { stage: "billing", category: "authoring", retryable: false, httpStatus: 402 },
+  capability_unavailable: { stage: "auth", category: "authoring", retryable: false, httpStatus: 403 },
+  import_unsupported_media: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  import_decode_failed: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  import_source_unreachable: { stage: "import", category: "transient", retryable: true, httpStatus: 422 },
+  import_processing_failed: { stage: "import", category: "internal", retryable: false, httpStatus: 422 },
+  media_not_ready: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  source_dims_unknown: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  media_no_audio: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  media_no_transcript: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  transcript_too_long: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  media_in_use: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  media_missing: { stage: "import", category: "authoring", retryable: false, httpStatus: 422 },
+  invalid_import_url: { stage: "import", category: "authoring", retryable: false, httpStatus: 400 },
+  invalid_composition: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  validation_error: { stage: "validate", category: "authoring", retryable: false, httpStatus: 400 },
+  trim_out_of_bounds: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  timestamp_out_of_bounds: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  trim_inverted: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  reframe_coverage_gap: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  media_family_track_mismatch: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  aspect_change_requires_derive: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  delete_range_inverted: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  param_unwired: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  stale_etag: { stage: "validate", category: "authoring", retryable: false, httpStatus: 409 },
+  idempotency_conflict: { stage: "validate", category: "transient", retryable: true, httpStatus: 409 },
+  idempotency_key_mismatch: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  invalid_cursor: { stage: "validate", category: "authoring", retryable: false, httpStatus: 400 },
+  invalid_query: { stage: "validate", category: "authoring", retryable: false, httpStatus: 400 },
+  precondition_required: { stage: "validate", category: "authoring", retryable: false, httpStatus: 428 },
+  conflict: { stage: "validate", category: "authoring", retryable: false, httpStatus: 409 },
+  candidate_mismatch: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  unknown_pack_sound: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  brand_audio_unresolvable: { stage: "compose", category: "authoring", retryable: false, httpStatus: 422 },
+  suggestions_already_complete: { stage: "validate", category: "authoring", retryable: false, httpStatus: 409 },
+  suggestions_already_running: { stage: "validate", category: "authoring", retryable: false, httpStatus: 409 },
+  suggestions_require_speech: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  clip_not_found: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  source_composition_not_found: { stage: "validate", category: "authoring", retryable: false, httpStatus: 404 },
+  clip_source_track_mismatch: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  anchor_requires_behind: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  unknown_primitive: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  disabled_primitive: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  invalid_primitive_params: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  overlapping_hero_overlays: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  custom_missing_sourcecode: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  invalid_prop_schema: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  component_does_not_compile: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  component_runtime_error: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  component_source_unavailable: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  motion_preset_unknown: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  motion_preset_target_invalid: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  grid_target_invalid: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  grid_unavailable: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  shot_grid_unavailable: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  grid_cap_exceeded: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  generation_moderation_blocked: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  session_version_timeout: { stage: "render", category: "transient", retryable: true, httpStatus: 503 },
+  resource_import_in_flight: { stage: "validate", category: "transient", retryable: true, httpStatus: 503 },
+  trajectory_coverage_gap: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  trajectory_unresolved: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  subject_not_tracked: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  subject_detection_failed_on_generated: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  trajectory_internal_gap: { stage: "render", category: "internal", retryable: false, httpStatus: 422 },
+  subject_uncontainable: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  clip_trajectory_merge_conflict: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_signal_absent: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_override_conflict: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_timebase_undefined: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_group_unsynced: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_segment_out_of_media: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_speaking_double_count: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  selector_identity_detector_version_mismatch: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  variant_not_baked: { stage: "render", category: "internal", retryable: false, httpStatus: 422 },
+  behind_matte_unresolved: { stage: "render", category: "internal", retryable: false, httpStatus: 422 },
+  render_output_invalid: { stage: "render", category: "internal", retryable: false, httpStatus: 422 },
+  audio_sync_invalid: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  generation_output_invalid: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  bake_output_opaque: { stage: "render", category: "internal", retryable: false, httpStatus: 422 },
+  source_media_not_found: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  exemplar_key_not_org_owned: { stage: "validate", category: "authoring", retryable: false, httpStatus: 422 },
+  brand_kit_unresolved: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  unknown_format: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  render_not_cancellable: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  compose_not_cancellable: { stage: "system", category: "authoring", retryable: false, httpStatus: 422 },
+  job_not_cancellable: { stage: "system", category: "authoring", retryable: false, httpStatus: 422 },
+  export_not_cancellable: { stage: "export", category: "authoring", retryable: false, httpStatus: 422 },
+  render_not_complete: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  lambda_infra_failed: { stage: "render", category: "transient", retryable: true, httpStatus: 503 },
+  render_stalled: { stage: "render", category: "transient", retryable: true, httpStatus: 500 },
+  render_unknown_primitive: { stage: "render", category: "authoring", retryable: false, httpStatus: 422 },
+  session_in_use: { stage: "export", category: "authoring", retryable: false, httpStatus: 422 },
+  transcript_unavailable: { stage: "export", category: "transient", retryable: true, httpStatus: 503 },
+  service_unavailable: { stage: "system", category: "transient", retryable: true, httpStatus: 503 },
+  internal_error: { stage: "system", category: "internal", retryable: false, httpStatus: 500 }
+};
+var CueframeError = class extends Error {
+  constructor(code, message, fix, locator) {
+    super(message);
+    this.code = code;
+    this.fix = fix;
+    this.locator = locator;
+    this.name = "CueframeError";
+  }
+  code;
+  fix;
+  locator;
+  toEnvelope() {
+    const s = ERROR_CODES[this.code];
+    return {
+      code: this.code,
+      stage: s.stage,
+      category: s.category,
+      retryable: s.retryable,
+      httpStatus: s.httpStatus,
+      message: this.message,
+      fix: this.fix,
+      locator: this.locator
+    };
+  }
+};
+var CFERR_PREFIX = "CFERR::";
+function b64encode(s) {
+  return btoa(unescape(encodeURIComponent(s)));
+}
+function b64decode(s) {
+  return decodeURIComponent(escape(atob(s)));
+}
+function encodeError(e) {
+  const json = JSON.stringify({ code: e.code, message: e.message, fix: e.fix, locator: e.locator });
+  return CFERR_PREFIX + b64encode(json);
+}
+function decodeError(msg) {
+  const m = msg.match(/CFERR::([A-Za-z0-9+/=]+)/);
+  if (!m) return null;
+  try {
+    const o = JSON.parse(b64decode(m[1]));
+    if (!o || typeof o.code !== "string" || !(o.code in ERROR_CODES)) return null;
+    return new CueframeError(o.code, String(o.message ?? ""), o.fix, o.locator);
+  } catch {
+    return null;
+  }
+}
+var SENSITIVE = [
+  /https?:\/\/\S+/gi,
+  // URLs (presigned R2/S3, Lambda sites, etc.)
+  /\b[\w.-]*\.r2\.cloudflarestorage\.[\w./-]*/gi,
+  // R2 hosts/keys (scheme-less)
+  /\bremotionlambda[\w.-]*/gi,
+  // Lambda render host
+  /\bs3[.-][\w.-]*/gi,
+  // s3 host (scheme-less)
+  /\b[\w.-]*\.internal\b/gi,
+  /\/(?:Users|home|var|tmp|root)\/\S*/gi,
+  // absolute fs paths
+  /\b\d{1,3}(?:\.\d{1,3}){3}\b/g
+  // IPv4 literals
+];
+var FIX_ALLOW = [
+  "issues",
+  "uncovered",
+  "gapFrames",
+  "clipId",
+  "trackId",
+  "brandKitId",
+  "srcFrame",
+  "firstSegmentStart",
+  "mediaId",
+  "aspect",
+  "intentHash",
+  "remedies",
+  "retryAfter",
+  "compositionPath",
+  "nearest",
+  "unknownKeys",
+  "allowedKeys",
+  "typeMismatches",
+  "constraintViolations"
+];
+var LOCATOR_ALLOW = ["projectId", "renderId", "requestId", "clipId", "trackId", "compositionPath"];
+var GENERIC = {
+  transient: "A temporary error occurred; retry.",
+  internal: "An unexpected error occurred."
+};
+function scrubStr(v) {
+  if (typeof v !== "string") return v;
+  let s = v;
+  for (const r of SENSITIVE) s = s.replace(r, "(redacted)");
+  return s;
+}
+function scrubSensitive(s) {
+  return scrubStr(s);
+}
+function scrubVal(v) {
+  if (typeof v === "string") return scrubStr(v);
+  if (Array.isArray(v)) return v.map(scrubVal);
+  if (v !== null && typeof v === "object") {
+    const out = {};
+    for (const [k, val] of Object.entries(v)) out[k] = scrubVal(val);
+    return out;
+  }
+  return v;
+}
+function pickScrub(obj, allow) {
+  if (!obj) return void 0;
+  const out = {};
+  for (const k of allow) if (k in obj) out[k] = scrubVal(obj[k]);
+  return Object.keys(out).length ? out : void 0;
+}
+function scrubAll(obj) {
+  if (!obj) return void 0;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[k] = scrubVal(v);
+  return Object.keys(out).length ? out : void 0;
+}
+function toWireEnvelope(e, opts) {
+  const trusted = opts?.trusted ?? false;
+  let message;
+  let fix;
+  if (e.category === "internal") {
+    message = GENERIC.internal;
+    fix = void 0;
+  } else if (trusted) {
+    message = scrubStr(e.message);
+    fix = scrubAll(e.fix);
+  } else {
+    message = e.category === "authoring" ? scrubStr(e.message) : GENERIC[e.category];
+    fix = pickScrub(e.fix, FIX_ALLOW);
+  }
+  const locator = pickScrub(e.locator, LOCATOR_ALLOW);
+  return { ...e, message, fix, locator };
+}
+
+export {
+  ERROR_CODES,
+  CueframeError,
+  encodeError,
+  decodeError,
+  scrubSensitive,
+  toWireEnvelope
+};

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

@@ -2,11 +2,11 @@ import {
   activeFaceKeepOutSeries,
   boundingBox,
   resolveBrandRefsDeep
-} from "./chunk-FYZVH3MC.js";
+} from "./chunk-YQ7FFW3G.js";
 import {
   CueframeError,
   encodeError
-} from "./chunk-OCFDUCF4.js";
+} from "./chunk-LLUW26BS.js";
 
 // ../composition/src/projection/cardTokens.ts
 var CARD_MOTION_VAR_NAMES = [
@@ -217,6 +217,70 @@ async function behindReadinessForTarget(target, mattes) {
   }
   return { state: "subject-present", target };
 }
+function clipOverlapsBehind(clipStartSec, clipDurationSec, windows) {
+  const start = clipStartSec * 1e3;
+  const end = (clipStartSec + clipDurationSec) * 1e3;
+  return windows.some((w) => start < w.endMs && end > w.startMs);
+}
+function matteWindowsByMediaId(composition, behindWindows) {
+  const out = /* @__PURE__ */ new Map();
+  if (behindWindows.length === 0) return out;
+  for (const track of tracksOf(composition)) {
+    const kind = track.kind;
+    if (kind !== "video" && kind !== "audio" && kind !== "image") continue;
+    for (const clip of clipsOf(track)) {
+      if (clip.source?.kind !== "media") continue;
+      const mediaId = clip.source.mediaId;
+      if (typeof mediaId !== "string" || !mediaId) continue;
+      if (!clipOverlapsBehind(clip.startTime, clip.duration, behindWindows)) continue;
+      const trim = clip.source.trim;
+      const startSec = typeof trim?.start === "number" ? trim.start : 0;
+      const endSec = typeof trim?.end === "number" ? trim.end : startSec + clip.duration;
+      if (endSec <= startSec) continue;
+      if (!out.has(mediaId)) out.set(mediaId, { startSec, endSec });
+    }
+  }
+  return out;
+}
+function behindWindowsOf(composition) {
+  const out = [];
+  for (const track of tracksOf(composition)) {
+    for (const clip of clipsOf(track)) {
+      const src = clip.source;
+      const kind = src?.kind;
+      if (kind !== "overlay" && kind !== "alpha-layer") continue;
+      if (src?.zPlane !== "behind-subject") continue;
+      if (clip.duration <= 0) continue;
+      out.push({
+        startMs: clip.startTime * 1e3,
+        endMs: (clip.startTime + clip.duration) * 1e3
+      });
+    }
+  }
+  out.push(...captionBehindWindowsOf(composition));
+  return out;
+}
+function captionBehindWindowsOf(composition) {
+  const out = [];
+  const captions = composition?.captions;
+  if (captions?.zPlane === "behind-subject" && Array.isArray(captions.segments)) {
+    for (const seg of captions.segments) {
+      const words = seg?.words;
+      if (!Array.isArray(words) || words.length === 0) continue;
+      let startMs = Infinity;
+      let endMs = -Infinity;
+      for (const w of words) {
+        const s = w.startMs;
+        const e = w.endMs;
+        if (typeof s !== "number" || typeof e !== "number") continue;
+        if (s < startMs) startMs = s;
+        if (e > endMs) endMs = e;
+      }
+      if (Number.isFinite(startMs) && endMs > startMs) out.push({ startMs, endMs });
+    }
+  }
+  return out;
+}
 
 // ../composition/src/projection/reframe-readiness.ts
 async function sourceWindowKey(window) {
@@ -527,6 +591,10 @@ export {
   primaryClipForOverlay,
   behindReadinessForOverlay,
   behindReadinessForTarget,
+  clipOverlapsBehind,
+  matteWindowsByMediaId,
+  behindWindowsOf,
+  captionBehindWindowsOf,
   sourceWindowKey,
   reframeNeedsDetection,
   reframeTargets,

package/dist/{chunk-MMEJ3Y7E.js → chunk-QETYXKQQ.js}

@@ -5,7 +5,7 @@ import {
   isOk,
   opById,
   safeParse
-} from "./chunk-SIGGQRY2.js";
+} from "./chunk-W3SIWT7J.js";
 
 // ../mcp/src/wait.ts
 var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -93,11 +93,6 @@ Download URL: ${url}`);
     }
   },
   consult: {
-    // A consult job IS a composeJob (routes/consult.ts returns consultJobId =
-    // composeJobId) — same detail op, different terminal: the advisory envelope
-    // (assessment / proposals / principles / plan), never the compose kind's
-    // "winner — render it" text. Before this kind existed, consult was a
-    // DEAD-END: its advisoryResult was unreachable over the curated surface.
     operationId: "getComposeJob",
     mapArg: (p, id, projectId) => p === "composeJobId" ? id : projectId,
     terminal: (j) => {
@@ -187,8 +182,6 @@ ${lines.join("\n\n")}${tail}`
     }
   },
   verify: {
-    // The generic jobs resource (GET /v1/jobs/{id}) — verify is its first
-    // tenant; future job kinds reuse this parser instead of adding adapters.
     operationId: "getJob",
     mapArg: (_p, id) => id,
     terminal: (j) => {
@@ -231,7 +224,6 @@ Worst-first critique: ${r.critique}`);
     }
   },
   preview: {
-    // Generic jobs resource — preview job (single-component still).
     operationId: "getJob",
     mapArg: (_p, id) => id,
     terminal: (j) => {
@@ -254,7 +246,6 @@ Inspect it, fix the component via create_component if needed, and re-preview.` :
     }
   },
   brand_kit_extract: {
-    // Generic jobs resource — brand-token extraction job.
     operationId: "getJob",
     mapArg: (_p, id) => id,
     terminal: (j) => {

package/dist/{chunk-YX2GSJK7.js → chunk-RP4SXXLJ.js}

@@ -1,6 +1,6 @@
 import {
   FitText
-} from "./chunk-AYVJXDLB.js";
+} from "./chunk-XHGZ2E77.js";
 import {
   ACCENT,
   BG,

package/dist/{chunk-P727GZVO.js → chunk-SAMQUUO5.js}

@@ -4,15 +4,15 @@ import {
 import {
   resolveContrast
 } from "./chunk-EMGFZ3PR.js";
+import {
+  resolveFitFontSize
+} from "./chunk-XHGZ2E77.js";
 import {
   fadeProgress,
   resolveEasing,
   staggerUp,
   wordPop
 } from "./chunk-ZFEXATWN.js";
-import {
-  resolveFitFontSize
-} from "./chunk-AYVJXDLB.js";
 
 // ../execution/primitives/src/hero-text/HeroText.tsx
 import { useCurrentFrame, useVideoConfig } from "remotion";
@@ -92,8 +92,6 @@ function HeroText({
         fontSize,
         fontWeight: fontWeight ?? 800,
         letterSpacing: "-0.02em",
-        // behind-subject host: a real off-white color, NO contrast shadow — the
-        // subject silhouette biting the letters supplies the depth.
         color: textColor ?? resolveContrast({ behindSubject: true }).textColor,
         fontFamily: fontFamily ?? resolveTypeface("display")
       }

package/dist/{chunk-RF7U3SCL.js → chunk-TD347SSX.js}

@@ -1,6 +1,6 @@
 import {
   waitForJob
-} from "./chunk-MMEJ3Y7E.js";
+} from "./chunk-QETYXKQQ.js";
 import {
   GENERATED_OPERATIONS,
   apiErrorFrom,
@@ -17,10 +17,10 @@ import {
   sniffImageMediaType,
   text,
   withMedia
-} from "./chunk-SIGGQRY2.js";
+} from "./chunk-W3SIWT7J.js";
 import {
   CURATED_TOOLS
-} from "./chunk-HI4UTTPS.js";
+} from "./chunk-AO744WIK.js";
 
 // ../mcp/src/prompts.ts
 var skillListCache = null;
@@ -476,9 +476,6 @@ function registerPreviewCard(server, ex, onEvent) {
         tokens: z.record(z.string()).optional().describe("Token substitutions the html references (e.g. brand colours, fonts). Same shape as the clip source `tokens`."),
         aspectRatio: z.enum(["16:9", "9:16", "1:1", "4:5"]).optional().describe("Frame to size the card into. Default 9:16 \u2014 a card that fits 16:9 often overflows vertical.")
       },
-      // Renders inline and persists nothing — the read-only stance curation.ts
-      // already takes for preview_frame. Stated in full: an omitted hint is not
-      // neutral (destructiveHint/openWorldHint default TRUE in the schema).
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
     },
     async (args, extra) => timed(onEvent, "preview_card", async (report) => {
@@ -531,8 +528,6 @@ function registerWaitJob(server, ex, waitCapMs, onEvent) {
     "wait_job",
     {
       title: "Wait for Job",
-      // Polls status; changes nothing. Idempotent by construction — the whole
-      // continuation contract is "call again with the same arguments".
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
       description: "Wait for a long-running job and return the resolved result \u2014 a BOUNDED long-poll. Polls the job status (render / compose / consult / clip-suggestions / verify) and blocks up to the transport window (30s on the hosted transport); if the job is still running at the window it returns a `Still running` continuation \u2014 call wait_job again with the same arguments to keep waiting (the job keeps executing server-side; nothing is lost between calls). Call this right after compose / create_render / consult / suggest_briefs / score_composition / preview_component. For event-driven fan-out, create_webhook delivers the terminal instead.",
       inputSchema: {
@@ -583,9 +578,6 @@ function registerBurnedTombstones(server, onEvent) {
       {
         title: `${titleCase(b.name)} (retired)`,
         description: `RETIRED (2026-07 verb cutover) \u2014 use ${b.replacement}. ${b.reason}`,
-        // A tombstone only ever throws. Announcing it as read-only and
-        // closed-world keeps a stale agent from being made to confirm a
-        // "destructive" call that does nothing (schema defaults both to true).
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
       },
       async () => timed(onEvent, b.name, async () => errText(burnedNameError(b)))