@cueframe/kernel 0.1.0 → 0.1.2

package/dist/chunk-IEXAKOEX.js

@@ -0,0 +1,113 @@
+import {
+  EntityId,
+  ISODateTime,
+  NonEmptyString
+} from "./chunk-XELS2BGA.js";
+
+// ../data-models/account-model/src/validators/userSettings.ts
+import { z } from "zod";
+var UserSettings = z.object({
+  id: EntityId("userSettings"),
+  userId: NonEmptyString,
+  enableUnderstanding: z.boolean().optional(),
+  activeBrandKitId: EntityId("brandKits").optional()
+});
+
+// ../data-models/account-model/src/validators/conversation.ts
+import { z as z2 } from "zod";
+var ConversationProject = z2.object({
+  id: NonEmptyString,
+  home: z2.enum(["local", "cloud"])
+});
+var Conversation = z2.object({
+  id: EntityId("conversations"),
+  clientId: NonEmptyString,
+  userId: NonEmptyString,
+  title: NonEmptyString,
+  project: ConversationProject.optional(),
+  createdAt: ISODateTime,
+  updatedAt: ISODateTime,
+  messages: z2.string()
+});
+
+// ../data-models/account-model/src/validators/uploadToken.ts
+import { z as z3 } from "zod";
+var UploadTokenScope = z3.enum(["tus", "companion"]);
+var UploadToken = z3.object({
+  id: EntityId("uploadTokens"),
+  token: NonEmptyString,
+  userId: NonEmptyString,
+  projectId: EntityId("projects").optional(),
+  orgId: NonEmptyString.optional(),
+  scope: UploadTokenScope.optional(),
+  expiresAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/contextFile.ts
+import { z as z4 } from "zod";
+var ContextFile = z4.object({
+  id: EntityId("contextFiles"),
+  orgId: NonEmptyString,
+  userId: NonEmptyString,
+  filename: NonEmptyString,
+  content: z4.string(),
+  generatedFrom: z4.array(NonEmptyString),
+  version: z4.number().int().nonnegative(),
+  updatedAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/dashboardInsight.ts
+import { z as z5 } from "zod";
+var DashboardInsight = z5.object({
+  id: EntityId("dashboardInsights"),
+  orgId: NonEmptyString,
+  sourceHash: NonEmptyString,
+  heroInsight: NonEmptyString,
+  contentSuggestions: z5.array(NonEmptyString),
+  generatedAt: ISODateTime
+});
+
+// ../data-models/account-model/src/validators/sessionToken.ts
+import { z as z6 } from "zod";
+var SessionTokenScope = z6.enum(["session-read"]);
+var SessionToken = z6.object({
+  id: EntityId("sessionTokens"),
+  token: NonEmptyString,
+  sessionId: NonEmptyString,
+  projectId: EntityId("projects"),
+  orgId: NonEmptyString,
+  scope: SessionTokenScope,
+  expiresAt: ISODateTime,
+  sandboxId: NonEmptyString.optional(),
+  readyAt: z6.number().optional(),
+  scheduledCloseId: NonEmptyString.optional(),
+  scratchCompositionId: EntityId("compositions").optional(),
+  managed: z6.boolean().optional(),
+  leaseJobId: NonEmptyString.optional(),
+  leaseExpiresAt: z6.number().optional()
+});
+
+// ../data-models/account-model/src/validators/workingComposition.ts
+import { z as z7 } from "zod";
+var WorkingComposition = z7.object({
+  id: EntityId("workingCompositions"),
+  sessionId: NonEmptyString,
+  projectId: EntityId("projects"),
+  orgId: NonEmptyString,
+  composition: z7.unknown(),
+  version: z7.number(),
+  updatedAt: z7.number()
+});
+
+export {
+  UserSettings,
+  ConversationProject,
+  Conversation,
+  UploadTokenScope,
+  UploadToken,
+  ContextFile,
+  DashboardInsight,
+  SessionTokenScope,
+  SessionToken,
+  WorkingComposition
+};

package/dist/{chunk-UY4SWJVE.js → chunk-K2IUBCND.js}

@@ -189,22 +189,18 @@ export default function CinematicTitle({ durationInFrames, params }) {
   const subtext = params.subtext ?? '';
   const accentColor = params.accentColor ?? '#D4AF37';
   const barHeight = height * 0.13;
-  // Bars slide in first (frames 0-20)
   const barSlide = interpolate(frame, [0, 20], [barHeight, 0], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
-  // Title fades in after bars (frames 18-40), letter-spacing tightens
   const textFade = interpolate(frame, [18, 40], [0, 1], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
   const textSpacing = interpolate(frame, [18, 45], [20, 6], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
-  // Subtext arrives last (frames 35-55)
   const subtextFade = interpolate(frame, [35, 55], [0, 1], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
-  // Exit: fade out in final 20 frames
   const exitOpacity = interpolate(frame, [durationInFrames - 20, durationInFrames], [1, 0], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
@@ -238,14 +234,10 @@ export default function LowerThird({ durationInFrames, params }) {
   const frame = useCurrentFrame();
   const accent = params.accentColor ?? '#DB6452';
   const pos = params.position ?? 'left';
-  // Floor-assigned safe band (clear of captions + platform UI). NEVER hard-code
-  // bottom/top offsets \u2014 anchor to the region instead.
   const R = params.region ?? { x: 0, y: 0, w: 1, h: 1 };
-  // Responsive fade durations \u2014 Math.min prevents overrun on short overlays
   const fadeIn = Math.min(15, Math.floor(durationInFrames / 3));
   const fadeOut = Math.min(10, Math.floor(durationInFrames / 3));
   const slideIn = interpolate(frame, [0, fadeIn], [-100, 0], { extrapolateRight: 'clamp' });
-  // 4-point opacity: [enter, hold, hold, exit]
   const opacity = interpolate(frame,
     [0, fadeIn, Math.max(fadeIn, durationInFrames - fadeOut), durationInFrames],
     [0, 1, 1, 0],
@@ -281,20 +273,17 @@ export default function WaveText({ durationInFrames, params }) {
   const text = params.text ?? 'WAVE';
   const subtext = params.subtext ?? '';
   const accent = params.accentColor ?? '#F59E0B';
-  // Spring entrance \u2014 whole component fades/scales in
   const enterProgress = spring({ frame, fps, config: { damping: 14, stiffness: 120 } });
   const enterOpacity = interpolate(enterProgress, [0, 1], [0, 1]);
   const exitOpacity = interpolate(frame, [durationInFrames - 15, durationInFrames], [1, 0], {
     extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
   });
   const chars = text.split('');
-  // Staggered subtext spring (delayed 12 frames)
   const subtextProgress = spring({ frame: Math.max(0, frame - 12), fps, config: { damping: 16, stiffness: 100 } });
   return (
     <AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', opacity: exitOpacity }}>
       <div style={{ display: 'flex', flexDirection: 'row', opacity: enterOpacity }}>
         {chars.map((char, i) => {
-          // Per-character wave: phase offset by index, continuous sine motion
           const wave = Math.sin(frame * 0.12 - i * 0.6) * 18;
           const rotation = Math.sin(frame * 0.1 - i * 0.5) * 8;
           return (
@@ -336,7 +325,6 @@ within this band. Wrap your root in a positioned container sized to the region:
     <div style={{ position: 'absolute', left: \`\${R.x*100}%\`, top: \`\${R.y*100}%\`,
       width: \`\${R.w*100}%\`, height: \`\${R.h*100}%\`,
       display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
-      {/* your graphic */}
     </div>
   );
   \`\`\`

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
+};