@shotstack/shotstack-canvas 1.9.6 → 2.0.0

package/dist/entry.node.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,25 +30,370 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/core/video/web-encoder.ts
+var web_encoder_exports = {};
+__export(web_encoder_exports, {
+  WebCodecsEncoder: () => WebCodecsEncoder,
+  createWebCodecsEncoder: () => createWebCodecsEncoder
+});
+function getH264CodecCandidates(profile) {
+  switch (profile) {
+    case "baseline":
+      return ["avc1.42E028", "avc1.42001F", "avc1.42001E"];
+    case "main":
+      return ["avc1.4D0028", "avc1.4D001F", "avc1.4D001E"];
+    case "high":
+    default:
+      return ["avc1.640028", "avc1.640029", "avc1.64001F", "avc1.64001E"];
+  }
+}
+async function createWebCodecsEncoder(config) {
+  const encoder = new WebCodecsEncoder();
+  await encoder.configure(config);
+  return encoder;
+}
+var WebCodecsEncoder;
+var init_web_encoder = __esm({
+  "src/core/video/web-encoder.ts"() {
+    "use strict";
+    WebCodecsEncoder = class {
+      encoder = null;
+      muxer = null;
+      config = null;
+      frameCount = 0;
+      totalFrames = 0;
+      startTime = 0;
+      fps = 30;
+      keyframeInterval = 150;
+      encoderError = null;
+      onProgress;
+      async configure(config) {
+        if (typeof VideoEncoder === "undefined") {
+          throw new Error("WebCodecs API not supported in this browser.");
+        }
+        this.config = config;
+        this.fps = config.fps;
+        this.totalFrames = Math.max(2, Math.round(config.duration * config.fps) + 1);
+        this.frameCount = 0;
+        this.startTime = Date.now();
+        this.keyframeInterval = Math.round(config.fps * 10);
+        this.encoderError = null;
+        const { Muxer, ArrayBufferTarget } = await import("mp4-muxer");
+        this.muxer = new Muxer({
+          target: new ArrayBufferTarget(),
+          video: {
+            codec: "avc",
+            width: config.width,
+            height: config.height
+          },
+          fastStart: "in-memory"
+        });
+        const candidates = getH264CodecCandidates(config.profile || "high");
+        let encoderConfig = null;
+        for (const codec of candidates) {
+          const candidate = {
+            codec,
+            width: config.width,
+            height: config.height,
+            bitrate: config.bitrate ?? 8e6,
+            framerate: config.fps,
+            hardwareAcceleration: config.hardwareAcceleration ?? "prefer-hardware",
+            latencyMode: "quality"
+          };
+          const support = await VideoEncoder.isConfigSupported(candidate);
+          if (support.supported) {
+            encoderConfig = candidate;
+            break;
+          }
+        }
+        if (!encoderConfig) {
+          throw new Error("H.264 encoding not supported. Tried codecs: " + candidates.join(", "));
+        }
+        this.encoder = new VideoEncoder({
+          output: (chunk, metadata) => {
+            this.muxer.addVideoChunk(chunk, metadata);
+          },
+          error: (e) => {
+            this.encoderError = e;
+          }
+        });
+        this.encoder.configure(encoderConfig);
+      }
+      async encodeFrame(frameData, frameIndex) {
+        if (this.encoderError) {
+          throw this.encoderError;
+        }
+        if (!this.encoder || !this.config) {
+          throw new Error("Encoder not configured. Call configure() first.");
+        }
+        const { width, height } = this.config;
+        const timestamp = Math.round(frameIndex * 1e6 / this.fps);
+        const pixelData = frameData instanceof ArrayBuffer ? new Uint8ClampedArray(frameData) : frameData;
+        const imageData = new ImageData(pixelData, width, height);
+        const videoFrame = new VideoFrame(imageData, { timestamp });
+        const isKeyFrame = frameIndex % this.keyframeInterval === 0;
+        this.encoder.encode(videoFrame, { keyFrame: isKeyFrame });
+        videoFrame.close();
+        this.frameCount++;
+        this.reportProgress();
+      }
+      async encodeCanvas(canvas, frameIndex) {
+        if (this.encoderError) {
+          throw this.encoderError;
+        }
+        if (!this.encoder || !this.config) {
+          throw new Error("Encoder not configured. Call configure() first.");
+        }
+        const timestamp = Math.round(frameIndex * 1e6 / this.fps);
+        const videoFrame = new VideoFrame(canvas, { timestamp });
+        const isKeyFrame = frameIndex % this.keyframeInterval === 0;
+        this.encoder.encode(videoFrame, { keyFrame: isKeyFrame });
+        videoFrame.close();
+        this.frameCount++;
+        this.reportProgress();
+      }
+      async encodeCanvasRepeat(canvas, startFrameIndex, repeatCount) {
+        if (this.encoderError) {
+          throw this.encoderError;
+        }
+        if (!this.encoder || !this.config) {
+          throw new Error("Encoder not configured. Call configure() first.");
+        }
+        for (let i = 0; i < repeatCount; i++) {
+          const actualFrameIndex = startFrameIndex + i;
+          const timestamp = Math.round(actualFrameIndex * 1e6 / this.fps);
+          const videoFrame = new VideoFrame(canvas, { timestamp });
+          const isKeyFrame = actualFrameIndex % this.keyframeInterval === 0;
+          this.encoder.encode(videoFrame, { keyFrame: isKeyFrame });
+          videoFrame.close();
+          this.frameCount++;
+        }
+        this.reportProgress();
+      }
+      async flush() {
+        if (this.encoderError) {
+          throw this.encoderError;
+        }
+        if (!this.encoder || !this.muxer) {
+          throw new Error("Encoder not configured.");
+        }
+        await this.encoder.flush();
+        this.muxer.finalize();
+        const buffer = this.muxer.target.buffer;
+        return new Blob([buffer], { type: "video/mp4" });
+      }
+      close() {
+        if (this.encoder && this.encoder.state !== "closed") {
+          this.encoder.close();
+        }
+        this.encoder = null;
+        this.muxer = null;
+      }
+      reportProgress() {
+        if (!this.onProgress) return;
+        const elapsedMs = Date.now() - this.startTime;
+        if (elapsedMs === 0) return;
+        const framesPerSecond = this.frameCount / (elapsedMs / 1e3);
+        const remainingFrames = this.totalFrames - this.frameCount;
+        const estimatedRemainingMs = remainingFrames / framesPerSecond * 1e3;
+        this.onProgress({
+          framesEncoded: this.frameCount,
+          totalFrames: this.totalFrames,
+          percentage: this.frameCount / this.totalFrames * 100,
+          elapsedMs,
+          estimatedRemainingMs: Math.round(estimatedRemainingMs),
+          currentFps: Math.round(framesPerSecond * 10) / 10
+        });
+      }
+    };
+  }
+});
+
+// src/core/video/mediarecorder-fallback.ts
+var mediarecorder_fallback_exports = {};
+__export(mediarecorder_fallback_exports, {
+  MediaRecorderFallback: () => MediaRecorderFallback,
+  createMediaRecorderFallback: () => createMediaRecorderFallback,
+  isMediaRecorderSupported: () => isMediaRecorderSupported
+});
+function getPreferredMimeType() {
+  const mimeTypes = [
+    "video/webm;codecs=vp9",
+    "video/webm;codecs=vp8",
+    "video/webm",
+    "video/mp4"
+  ];
+  for (const mimeType of mimeTypes) {
+    if (MediaRecorder.isTypeSupported(mimeType)) {
+      return mimeType;
+    }
+  }
+  return "video/webm";
+}
+function isMediaRecorderSupported() {
+  return typeof MediaRecorder !== "undefined" && typeof HTMLCanvasElement !== "undefined" && typeof HTMLCanvasElement.prototype.captureStream === "function";
+}
+async function createMediaRecorderFallback(config, canvas) {
+  const encoder = new MediaRecorderFallback();
+  await encoder.configure(config, canvas);
+  return encoder;
+}
+var MediaRecorderFallback;
+var init_mediarecorder_fallback = __esm({
+  "src/core/video/mediarecorder-fallback.ts"() {
+    "use strict";
+    MediaRecorderFallback = class {
+      mediaRecorder = null;
+      canvas = null;
+      config = null;
+      chunks = [];
+      frameCount = 0;
+      totalFrames = 0;
+      startTime = 0;
+      ctx = null;
+      onProgress;
+      async configure(config, canvas) {
+        this.config = config;
+        this.totalFrames = Math.max(2, Math.round(config.duration * config.fps) + 1);
+        this.frameCount = 0;
+        this.startTime = Date.now();
+        this.chunks = [];
+        if (canvas) {
+          this.canvas = canvas;
+        } else {
+          if (typeof OffscreenCanvas !== "undefined") {
+            this.canvas = new OffscreenCanvas(config.width, config.height);
+          } else if (typeof document !== "undefined") {
+            this.canvas = document.createElement("canvas");
+            this.canvas.width = config.width;
+            this.canvas.height = config.height;
+          } else {
+            throw new Error("No canvas available for MediaRecorder fallback");
+          }
+        }
+        this.ctx = this.canvas.getContext("2d");
+        if (!this.ctx) {
+          throw new Error("Failed to get 2D context");
+        }
+        const stream = this.canvas.captureStream?.(config.fps);
+        if (!stream) {
+          throw new Error("captureStream not supported on this canvas type");
+        }
+        const mimeType = getPreferredMimeType();
+        this.mediaRecorder = new MediaRecorder(stream, {
+          mimeType,
+          videoBitsPerSecond: config.bitrate ?? 8e6
+        });
+        this.mediaRecorder.ondataavailable = (event) => {
+          if (event.data.size > 0) {
+            this.chunks.push(event.data);
+          }
+        };
+        this.mediaRecorder.start(100);
+      }
+      async encodeFrame(frameData, _frameIndex) {
+        if (!this.ctx || !this.config) {
+          throw new Error("Encoder not configured. Call configure() first.");
+        }
+        const { width, height } = this.config;
+        const pixelData = frameData instanceof ArrayBuffer ? new Uint8ClampedArray(frameData) : frameData;
+        const imageData = new ImageData(pixelData, width, height);
+        this.ctx.putImageData(imageData, 0, 0);
+        this.frameCount++;
+        if (this.onProgress) {
+          const elapsedMs = Date.now() - this.startTime;
+          if (elapsedMs > 0) {
+            const framesPerSecond = this.frameCount / (elapsedMs / 1e3);
+            const remainingFrames = this.totalFrames - this.frameCount;
+            const estimatedRemainingMs = remainingFrames / framesPerSecond * 1e3;
+            this.onProgress({
+              framesEncoded: this.frameCount,
+              totalFrames: this.totalFrames,
+              percentage: this.frameCount / this.totalFrames * 100,
+              elapsedMs,
+              estimatedRemainingMs: Math.round(estimatedRemainingMs),
+              currentFps: Math.round(framesPerSecond * 10) / 10
+            });
+          }
+        }
+        const frameInterval = 1e3 / this.config.fps;
+        await new Promise((resolve) => setTimeout(resolve, frameInterval));
+      }
+      async flush() {
+        if (!this.mediaRecorder) {
+          throw new Error("MediaRecorder not configured.");
+        }
+        return new Promise((resolve, reject) => {
+          this.mediaRecorder.onstop = () => {
+            const blob = new Blob(this.chunks, { type: this.mediaRecorder.mimeType });
+            resolve(blob);
+          };
+          this.mediaRecorder.onerror = (event) => {
+            reject(new Error(`MediaRecorder error: ${event}`));
+          };
+          this.mediaRecorder.stop();
+        });
+      }
+      close() {
+        if (this.mediaRecorder && this.mediaRecorder.state !== "inactive") {
+          this.mediaRecorder.stop();
+        }
+        this.mediaRecorder = null;
+        this.canvas = null;
+        this.ctx = null;
+        this.chunks = [];
+      }
+      getOutputMimeType() {
+        return this.mediaRecorder?.mimeType || "video/webm";
+      }
+    };
+  }
+});
+
 // src/env/entry.node.ts
 var entry_node_exports = {};
 __export(entry_node_exports, {
+  CanvasRichCaptionAssetSchema: () => CanvasRichCaptionAssetSchema,
   CanvasRichTextAssetSchema: () => CanvasRichTextAssetSchema,
   CanvasSvgAssetSchema: () => CanvasSvgAssetSchema,
+  CaptionLayoutEngine: () => CaptionLayoutEngine,
+  FontRegistry: () => FontRegistry,
+  NodeRawEncoder: () => NodeRawEncoder,
+  RichCaptionRenderer: () => RichCaptionRenderer,
+  WordTimingStore: () => WordTimingStore,
   arcToCubicBeziers: () => arcToCubicBeziers,
+  calculateAnimationStatesForGroup: () => calculateAnimationStatesForGroup,
   commandsToPathString: () => commandsToPathString,
   computeSimplePathBounds: () => computeSimplePathBounds,
+  createDefaultGeneratorConfig: () => createDefaultGeneratorConfig,
+  createFrameSchedule: () => createFrameSchedule,
   createNodePainter: () => createNodePainter,
+  createNodeRawEncoder: () => createNodeRawEncoder,
+  createRichCaptionRenderer: () => createRichCaptionRenderer,
   createTextEngine: () => createTextEngine,
+  createVideoEncoder: () => createVideoEncoder,
+  detectPlatform: () => detectPlatform,
+  detectSubtitleFormat: () => detectSubtitleFormat,
+  findWordAtTime: () => findWordAtTime,
+  generateRichCaptionDrawOps: () => generateRichCaptionDrawOps,
+  generateRichCaptionFrame: () => generateRichCaptionFrame,
   generateShapePathData: () => generateShapePathData,
-  isGlyphFill: () => isGlyphFill2,
-  isShadowFill: () => isShadowFill2,
+  getDefaultAnimationConfig: () => getDefaultAnimationConfig,
+  getDrawCaptionWordOps: () => getDrawCaptionWordOps,
+  getEncoderCapabilities: () => getEncoderCapabilities,
+  getEncoderWarning: () => getEncoderWarning,
+  groupWordsByPause: () => groupWordsByPause,
+  isDrawCaptionWordOp: () => isDrawCaptionWordOp,
+  isRTLText: () => isRTLText,
+  isWebCodecsH264Supported: () => isWebCodecsH264Supported,
   normalizePath: () => normalizePath,
   normalizePathString: () => normalizePathString,
+  parseSubtitleToWords: () => parseSubtitleToWords,
   parseSvgPath: () => parseSvgPath,
   quadraticToCubic: () => quadraticToCubic,
   renderSvgAssetToPng: () => renderSvgAssetToPng,
   renderSvgToPng: () => renderSvgToPng,
+  richCaptionAssetSchema: () => richCaptionAssetSchema,
   shapeToSvgString: () => shapeToSvgString,
   svgAssetSchema: () => import_zod2.svgAssetSchema,
   svgGradientStopSchema: () => import_zod2.svgGradientStopSchema,
@@ -71,7 +419,7 @@ var CANVAS_CONFIG = {
     pixelRatio: 2,
     fontFamily: "Roboto",
     fontSize: 48,
-    color: "#000000",
+    color: "#ffffff",
     textAlign: "center"
   },
   LIMITS: {
@@ -217,6 +565,71 @@ var CanvasRichTextAssetSchema = import_zod2.richTextAssetSchema.extend({
   customFonts: import_zod.z.array(customFontSchema).optional()
 }).strict();
 var CanvasSvgAssetSchema = import_zod2.svgAssetSchema;
+var wordTimingSchema = import_zod2.wordTimingSchema.extend({
+  text: import_zod.z.string().min(1),
+  start: import_zod.z.number().min(0),
+  end: import_zod.z.number().min(0),
+  confidence: import_zod.z.number().min(0).max(1).optional()
+});
+var richCaptionFontSchema = import_zod.z.object({
+  family: import_zod.z.string().default("Open Sans"),
+  size: import_zod.z.number().int().min(1).max(500).default(24),
+  weight: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).default("400"),
+  color: import_zod.z.string().regex(HEX6).default("#ffffff"),
+  opacity: import_zod.z.number().min(0).max(1).default(1),
+  background: import_zod.z.string().regex(HEX6).optional()
+});
+var richCaptionActiveSchema = import_zod2.richCaptionActiveSchema.extend({
+  font: import_zod.z.object({
+    color: import_zod.z.string().regex(HEX6).default("#ffff00"),
+    background: import_zod.z.string().regex(HEX6).optional(),
+    opacity: import_zod.z.number().min(0).max(1).default(1)
+  }).optional(),
+  stroke: import_zod.z.object({
+    width: import_zod.z.number().min(0).optional(),
+    color: import_zod.z.string().regex(HEX6).optional(),
+    opacity: import_zod.z.number().min(0).max(1).optional()
+  }).optional(),
+  scale: import_zod.z.number().min(0.5).max(2).default(1)
+});
+var richCaptionWordAnimationSchema = import_zod2.richCaptionWordAnimationSchema.extend({
+  style: import_zod.z.enum(["karaoke", "highlight", "pop", "fade", "slide", "bounce", "typewriter", "none"]).default("highlight"),
+  speed: import_zod.z.number().min(0.5).max(2).default(1),
+  direction: import_zod.z.enum(["left", "right", "up", "down"]).default("up")
+});
+var richCaptionAssetSchema = import_zod.z.object({
+  type: import_zod.z.literal("rich-caption"),
+  src: import_zod.z.string().min(1).optional(),
+  words: import_zod.z.array(wordTimingSchema).max(1e5).optional(),
+  font: richCaptionFontSchema.optional(),
+  style: canvasStyleSchema.optional(),
+  stroke: canvasStrokeSchema.optional(),
+  shadow: canvasShadowSchema.optional(),
+  background: canvasBackgroundSchema.optional(),
+  padding: paddingSchema.optional(),
+  align: canvasAlignmentSchema.optional(),
+  active: richCaptionActiveSchema.optional(),
+  wordAnimation: richCaptionWordAnimationSchema.optional(),
+  position: import_zod.z.enum(["top", "center", "bottom"]).default("bottom"),
+  maxWidth: import_zod.z.number().min(0.1).max(1).default(0.9),
+  maxLines: import_zod.z.number().int().min(1).max(10).default(2)
+}).superRefine((data, ctx) => {
+  if (data.src && data.words) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "src and words are mutually exclusive",
+      path: ["src"]
+    });
+  }
+  if (!data.src && !data.words) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "Either src or words must be provided",
+      path: ["words"]
+    });
+  }
+});
+var CanvasRichCaptionAssetSchema = richCaptionAssetSchema;
 
 // src/wasm/hb-loader.ts
 var import_meta = {};
@@ -1969,12 +2382,14 @@ async function createNodePainter(opts) {
   if (!ctx) throw new Error("2D context unavailable in Node (canvas).");
   const offscreenCanvas = createCanvas(canvas.width, canvas.height);
   const offscreenCtx = offscreenCanvas.getContext("2d");
+  const GRADIENT_CACHE_MAX = 500;
   const gradientCache = /* @__PURE__ */ new Map();
   const api = {
     async render(ops) {
       const globalBox = computeGlobalTextBounds(ops);
       let needsAlphaExtraction = false;
-      for (const op of ops) {
+      for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
         if (op.op === "BeginFrame") {
           const dpr = op.pixelRatio ?? opts.pixelRatio;
           const wantW = Math.floor(op.width);
@@ -1986,7 +2401,9 @@ async function createNodePainter(opts) {
             offscreenCanvas.height = wantH;
           }
           ctx.setTransform(1, 0, 0, 1, 0, 0);
+          ctx.globalAlpha = 1;
           offscreenCtx.setTransform(1, 0, 0, 1, 0, 0);
+          offscreenCtx.globalAlpha = 1;
           const hasBackground = !!(op.bg && op.bg.color);
           const hasRoundedBackground = hasBackground && op.bg && op.bg.radius && op.bg.radius > 0;
           needsAlphaExtraction = !!hasRoundedBackground;
@@ -2119,7 +2536,7 @@ async function createNodePainter(opts) {
             context.save();
             const c = parseHex6(op.stroke.color, op.stroke.opacity);
             context.strokeStyle = `rgba(${c.r},${c.g},${c.b},${c.a})`;
-            context.lineWidth = op.stroke.width;
+            context.lineWidth = op.stroke.width * 2;
             if (op.borderRadius && op.borderRadius > 0) {
               context.beginPath();
               roundRectPath(context, op.x, op.y, op.width, op.height, op.borderRadius);
@@ -2222,6 +2639,140 @@ async function createNodePainter(opts) {
           });
           continue;
         }
+        if (op.op === "DrawCaptionBackground") {
+          renderToBoth((context) => {
+            context.save();
+            const bgC = parseHex6(op.color, op.opacity);
+            context.fillStyle = `rgba(${bgC.r},${bgC.g},${bgC.b},${bgC.a})`;
+            context.beginPath();
+            roundRectPath(context, op.x, op.y, op.width, op.height, op.borderRadius);
+            context.fill();
+            context.restore();
+          });
+          continue;
+        }
+        if (op.op === "DrawCaptionWord") {
+          const captionWordOps = [op];
+          while (i + 1 < ops.length) {
+            const nextOp = ops[i + 1];
+            if (nextOp.op !== "DrawCaptionWord") break;
+            captionWordOps.push(nextOp);
+            i++;
+          }
+          renderToBoth((context) => {
+            for (const wordOp of captionWordOps) {
+              if (!wordOp.background) continue;
+              const wordDisplayText = wordOp.visibleCharacters >= 0 && wordOp.visibleCharacters < wordOp.text.length ? wordOp.text.slice(0, wordOp.visibleCharacters) : wordOp.text;
+              if (wordDisplayText.length === 0) continue;
+              context.save();
+              const bgTx = Math.round(wordOp.x + wordOp.transform.translateX);
+              const bgTy = Math.round(wordOp.y + wordOp.transform.translateY);
+              context.translate(bgTx, bgTy);
+              if (wordOp.transform.scale !== 1) {
+                const halfWidth = wordOp.width / 2;
+                context.translate(halfWidth, 0);
+                context.scale(wordOp.transform.scale, wordOp.transform.scale);
+                context.translate(-halfWidth, 0);
+              }
+              context.globalAlpha = wordOp.transform.opacity;
+              context.font = `${wordOp.fontWeight} ${wordOp.fontSize}px "${wordOp.fontFamily}"`;
+              context.textBaseline = "alphabetic";
+              if (wordOp.letterSpacing) {
+                context.letterSpacing = `${wordOp.letterSpacing}px`;
+              }
+              const bgMetrics = context.measureText(wordDisplayText);
+              const bgTextWidth = bgMetrics.width;
+              const bgAscent = wordOp.fontSize * 0.8;
+              const bgDescent = wordOp.fontSize * 0.2;
+              const bgTextHeight = bgAscent + bgDescent;
+              const bgX = -wordOp.background.padding;
+              const bgY = -bgAscent - wordOp.background.padding;
+              const bgW = bgTextWidth + wordOp.background.padding * 2;
+              const bgH = bgTextHeight + wordOp.background.padding * 2;
+              const bgC = parseHex6(wordOp.background.color, wordOp.background.opacity);
+              context.fillStyle = `rgba(${bgC.r},${bgC.g},${bgC.b},${bgC.a})`;
+              context.beginPath();
+              roundRectPath(context, bgX, bgY, bgW, bgH, wordOp.background.borderRadius);
+              context.fill();
+              context.restore();
+            }
+            for (const wordOp of captionWordOps) {
+              const displayText = wordOp.visibleCharacters >= 0 && wordOp.visibleCharacters < wordOp.text.length ? wordOp.text.slice(0, wordOp.visibleCharacters) : wordOp.text;
+              if (displayText.length === 0) continue;
+              context.save();
+              const tx = Math.round(wordOp.x + wordOp.transform.translateX);
+              const ty = Math.round(wordOp.y + wordOp.transform.translateY);
+              context.translate(tx, ty);
+              if (wordOp.transform.scale !== 1) {
+                const halfWidth = wordOp.width / 2;
+                context.translate(halfWidth, 0);
+                context.scale(wordOp.transform.scale, wordOp.transform.scale);
+                context.translate(-halfWidth, 0);
+              }
+              context.globalAlpha = wordOp.transform.opacity;
+              context.font = `${wordOp.fontWeight} ${wordOp.fontSize}px "${wordOp.fontFamily}"`;
+              context.textBaseline = "alphabetic";
+              if (wordOp.letterSpacing) {
+                context.letterSpacing = `${wordOp.letterSpacing}px`;
+              }
+              const metrics = context.measureText(displayText);
+              const textWidth = metrics.width;
+              const ascent = metrics.actualBoundingBoxAscent ?? wordOp.fontSize * 0.8;
+              const descent = metrics.actualBoundingBoxDescent ?? wordOp.fontSize * 0.2;
+              const textHeight = ascent + descent;
+              if (wordOp.shadow) {
+                const shadowC = parseHex6(wordOp.shadow.color, wordOp.shadow.opacity);
+                context.fillStyle = `rgba(${shadowC.r},${shadowC.g},${shadowC.b},${shadowC.a})`;
+                context.shadowColor = `rgba(${shadowC.r},${shadowC.g},${shadowC.b},${shadowC.a})`;
+                context.shadowOffsetX = wordOp.shadow.offsetX;
+                context.shadowOffsetY = wordOp.shadow.offsetY;
+                context.shadowBlur = wordOp.shadow.blur;
+                context.fillText(displayText, 0, 0);
+                context.shadowColor = "transparent";
+                context.shadowOffsetX = 0;
+                context.shadowOffsetY = 0;
+                context.shadowBlur = 0;
+              }
+              if (wordOp.stroke && wordOp.stroke.width > 0) {
+                const strokeC = parseHex6(wordOp.stroke.color, wordOp.stroke.opacity);
+                context.strokeStyle = `rgba(${strokeC.r},${strokeC.g},${strokeC.b},${strokeC.a})`;
+                context.lineWidth = wordOp.stroke.width * 2;
+                context.lineJoin = "round";
+                context.lineCap = "round";
+                context.strokeText(displayText, 0, 0);
+              }
+              if (wordOp.fillProgress <= 0) {
+                const baseC = parseHex6(wordOp.baseColor, wordOp.baseOpacity);
+                context.fillStyle = `rgba(${baseC.r},${baseC.g},${baseC.b},${baseC.a})`;
+                context.fillText(displayText, 0, 0);
+              } else if (wordOp.fillProgress >= 1) {
+                const activeC = parseHex6(wordOp.activeColor, wordOp.activeOpacity);
+                context.fillStyle = `rgba(${activeC.r},${activeC.g},${activeC.b},${activeC.a})`;
+                context.fillText(displayText, 0, 0);
+              } else {
+                const baseC = parseHex6(wordOp.baseColor, wordOp.baseOpacity);
+                context.fillStyle = `rgba(${baseC.r},${baseC.g},${baseC.b},${baseC.a})`;
+                context.fillText(displayText, 0, 0);
+                context.save();
+                context.beginPath();
+                const clipWidth = textWidth * wordOp.fillProgress;
+                if (wordOp.isRTL) {
+                  const clipX = textWidth - clipWidth;
+                  context.rect(clipX, -ascent - 5, clipWidth + 5, textHeight + 10);
+                } else {
+                  context.rect(-5, -ascent - 5, clipWidth + 5, textHeight + 10);
+                }
+                context.clip();
+                const activeC = parseHex6(wordOp.activeColor, wordOp.activeOpacity);
+                context.fillStyle = `rgba(${activeC.r},${activeC.g},${activeC.b},${activeC.a})`;
+                context.fillText(displayText, 0, 0);
+                context.restore();
+              }
+              context.restore();
+            }
+          });
+          continue;
+        }
       }
       if (needsAlphaExtraction) {
         const whiteData = ctx.getImageData(0, 0, canvas.width, canvas.height);
@@ -2259,6 +2810,17 @@ async function createNodePainter(opts) {
     },
     async toPNG() {
       return canvas.toBuffer("image/png");
+    },
+    toRawRGBA() {
+      const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+      return {
+        data: new Uint8ClampedArray(imageData.data),
+        width: canvas.width,
+        height: canvas.height
+      };
+    },
+    getCanvasSize() {
+      return { width: canvas.width, height: canvas.height };
     }
   };
   return api;
@@ -2721,14 +3283,6 @@ var VideoGenerator = class {
   }
 };
 
-// src/types.ts
-var isShadowFill2 = (op) => {
-  return op.op === "FillPath" && op.isShadow === true;
-};
-var isGlyphFill2 = (op) => {
-  return op.op === "FillPath" && op.isShadow !== true;
-};
-
 // src/core/svg-path-utils.ts
 var TAU = Math.PI * 2;
 var PATH_COMMAND_REGEX = /([MmLlHhVvCcSsQqTtAaZz])([^MmLlHhVvCcSsQqTtAaZz]*)/g;
@@ -3673,6 +4227,1987 @@ function extractSvgDimensions(svgString) {
   return { width, height };
 }
 
+// src/core/rich-caption-layout.ts
+var import_lru_cache = require("lru-cache");
+var RTL_RANGES = /[\u0590-\u05FF\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]/;
+function isRTLText(text) {
+  return RTL_RANGES.test(text);
+}
+var WordTimingStore = class {
+  startTimes;
+  endTimes;
+  xPositions;
+  yPositions;
+  widths;
+  words;
+  length;
+  constructor(words) {
+    this.length = words.length;
+    this.startTimes = new Uint32Array(this.length);
+    this.endTimes = new Uint32Array(this.length);
+    this.xPositions = new Float32Array(this.length);
+    this.yPositions = new Float32Array(this.length);
+    this.widths = new Float32Array(this.length);
+    this.words = new Array(this.length);
+    for (let i = 0; i < this.length; i++) {
+      this.startTimes[i] = Math.floor(words[i].start);
+      this.endTimes[i] = Math.floor(words[i].end);
+      this.words[i] = words[i].text;
+    }
+  }
+};
+function findWordAtTime(store, timeMs) {
+  let left = 0;
+  let right = store.length - 1;
+  while (left <= right) {
+    const mid = left + right >>> 1;
+    const start = store.startTimes[mid];
+    const end = store.endTimes[mid];
+    if (timeMs >= start && timeMs < end) {
+      return mid;
+    }
+    if (timeMs < start) {
+      right = mid - 1;
+    } else {
+      left = mid + 1;
+    }
+  }
+  return -1;
+}
+function groupWordsByPause(store, pauseThreshold = 500) {
+  if (store.length === 0) {
+    return [];
+  }
+  const groups = [];
+  let currentGroup = [];
+  for (let i = 0; i < store.length; i++) {
+    if (currentGroup.length === 0) {
+      currentGroup.push(i);
+      continue;
+    }
+    const prevEnd = store.endTimes[currentGroup[currentGroup.length - 1]];
+    const currStart = store.startTimes[i];
+    const gap = currStart - prevEnd;
+    const prevText = store.words[currentGroup[currentGroup.length - 1]];
+    const endsWithPunctuation = /[.!?]$/.test(prevText);
+    if (gap >= pauseThreshold || endsWithPunctuation) {
+      groups.push(currentGroup);
+      currentGroup = [i];
+    } else {
+      currentGroup.push(i);
+    }
+  }
+  if (currentGroup.length > 0) {
+    groups.push(currentGroup);
+  }
+  return groups;
+}
+function breakIntoLines(wordWidths, maxWidth, maxLines, spaceWidth) {
+  const lines = [];
+  let currentLine = [];
+  let currentWidth = 0;
+  for (let i = 0; i < wordWidths.length; i++) {
+    const wordWidth = wordWidths[i];
+    const spaceNeeded = currentLine.length > 0 ? spaceWidth : 0;
+    if (currentWidth + spaceNeeded + wordWidth <= maxWidth) {
+      currentLine.push(i);
+      currentWidth += spaceNeeded + wordWidth;
+    } else {
+      if (currentLine.length > 0) {
+        lines.push(currentLine);
+        if (lines.length >= maxLines) {
+          return lines;
+        }
+      }
+      currentLine = [i];
+      currentWidth = wordWidth;
+    }
+  }
+  if (currentLine.length > 0 && lines.length < maxLines) {
+    lines.push(currentLine);
+  }
+  return lines;
+}
+var GLYPH_SIZE_ESTIMATE = 64;
+function createShapedWordCache() {
+  return new import_lru_cache.LRUCache({
+    max: 5e4,
+    maxSize: 50 * 1024 * 1024,
+    maxEntrySize: 100 * 1024,
+    sizeCalculation: (value, key) => {
+      const keySize = key.length * 2;
+      const glyphsSize = value.glyphs.length * GLYPH_SIZE_ESTIMATE;
+      return keySize + glyphsSize + 100;
+    }
+  });
+}
+function makeShapingKey(text, fontFamily, fontSize, fontWeight, letterSpacing = 0) {
+  return `${text}\0${fontFamily}\0${fontSize}\0${fontWeight}\0${letterSpacing}`;
+}
+function transformText(text, transform) {
+  switch (transform) {
+    case "uppercase":
+      return text.toUpperCase();
+    case "lowercase":
+      return text.toLowerCase();
+    case "capitalize":
+      return text.replace(/\b\w/g, (c) => c.toUpperCase());
+    default:
+      return text;
+  }
+}
+var CaptionLayoutEngine = class {
+  fontRegistry;
+  cache;
+  layoutEngine;
+  constructor(fontRegistry) {
+    this.fontRegistry = fontRegistry;
+    this.cache = createShapedWordCache();
+    this.layoutEngine = new LayoutEngine(fontRegistry);
+  }
+  async measureWord(text, config) {
+    const transformedText = transformText(text, config.textTransform);
+    const cacheKey = makeShapingKey(
+      transformedText,
+      config.fontFamily,
+      config.fontSize,
+      config.fontWeight,
+      config.letterSpacing
+    );
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+    const lines = await this.layoutEngine.layout({
+      text: transformedText,
+      width: 1e5,
+      letterSpacing: config.letterSpacing,
+      fontSize: config.fontSize,
+      lineHeight: 1,
+      desc: { family: config.fontFamily, weight: config.fontWeight },
+      textTransform: "none"
+    });
+    const width = lines[0]?.width ?? 0;
+    const glyphs = lines[0]?.glyphs ?? [];
+    const isRTL = isRTLText(transformedText);
+    const shaped = {
+      text: transformedText,
+      width,
+      glyphs: glyphs.map((g) => ({
+        id: g.id,
+        xAdvance: g.xAdvance,
+        xOffset: g.xOffset,
+        yOffset: g.yOffset,
+        cluster: g.cluster
+      })),
+      isRTL
+    };
+    this.cache.set(cacheKey, shaped);
+    return shaped;
+  }
+  async layoutCaption(words, config) {
+    const store = new WordTimingStore(words);
+    const measurementConfig = {
+      fontFamily: config.fontFamily,
+      fontSize: config.fontSize,
+      fontWeight: config.fontWeight,
+      letterSpacing: config.letterSpacing,
+      textTransform: config.textTransform
+    };
+    const shapedWords = await Promise.all(
+      words.map((w) => this.measureWord(w.text, measurementConfig))
+    );
+    if (config.measureTextWidth) {
+      const fontString = `${config.fontWeight} ${config.fontSize}px "${config.fontFamily}"`;
+      for (let i = 0; i < shapedWords.length; i++) {
+        store.widths[i] = config.measureTextWidth(shapedWords[i].text, fontString);
+      }
+    } else {
+      for (let i = 0; i < shapedWords.length; i++) {
+        store.widths[i] = shapedWords[i].width;
+      }
+    }
+    if (config.textTransform !== "none") {
+      for (let i = 0; i < shapedWords.length; i++) {
+        store.words[i] = shapedWords[i].text;
+      }
+    }
+    const wordGroups = groupWordsByPause(store, config.pauseThreshold);
+    const pixelMaxWidth = config.frameWidth * config.maxWidth;
+    let spaceWidth;
+    if (config.measureTextWidth) {
+      const fontString = `${config.fontWeight} ${config.fontSize}px "${config.fontFamily}"`;
+      spaceWidth = config.measureTextWidth(" ", fontString) + config.wordSpacing;
+    } else {
+      const spaceWord = await this.measureWord(" ", measurementConfig);
+      spaceWidth = spaceWord.width + config.wordSpacing;
+    }
+    const groups = wordGroups.map((indices) => {
+      const groupWidths = indices.map((i) => store.widths[i]);
+      const lineIndices = breakIntoLines(
+        groupWidths,
+        pixelMaxWidth,
+        config.maxLines,
+        spaceWidth
+      );
+      const lines = lineIndices.map((lineWordIndices, lineIndex) => {
+        const actualIndices = lineWordIndices.map((i) => indices[i]);
+        const lineWidth = actualIndices.reduce((sum, idx) => sum + store.widths[idx], 0) + (actualIndices.length - 1) * spaceWidth;
+        return {
+          wordIndices: actualIndices,
+          x: 0,
+          y: lineIndex * config.fontSize * config.lineHeight,
+          width: lineWidth,
+          height: config.fontSize
+        };
+      });
+      return {
+        wordIndices: lines.flatMap((l) => l.wordIndices),
+        startTime: store.startTimes[indices[0]],
+        endTime: store.endTimes[indices[indices.length - 1]],
+        lines
+      };
+    });
+    const calculateGroupY = (group) => {
+      const totalHeight = group.lines.length * config.fontSize * config.lineHeight;
+      switch (config.position) {
+        case "top":
+          return config.fontSize * 1.5;
+        case "bottom":
+          return config.frameHeight - totalHeight - config.fontSize * 0.5;
+        case "center":
+        default:
+          return (config.frameHeight - totalHeight) / 2 + config.fontSize;
+      }
+    };
+    for (const group of groups) {
+      const baseY = calculateGroupY(group);
+      for (let lineIdx = 0; lineIdx < group.lines.length; lineIdx++) {
+        const line = group.lines[lineIdx];
+        line.x = (config.frameWidth - line.width) / 2;
+        line.y = baseY + lineIdx * config.fontSize * config.lineHeight;
+        let xCursor = line.x;
+        for (const wordIdx of line.wordIndices) {
+          store.xPositions[wordIdx] = xCursor;
+          store.yPositions[wordIdx] = line.y;
+          xCursor += store.widths[wordIdx] + spaceWidth;
+        }
+      }
+    }
+    return {
+      store,
+      groups,
+      shapedWords
+    };
+  }
+  getVisibleWordsAtTime(layout, timeMs) {
+    const activeGroup = layout.groups.find(
+      (g) => timeMs >= g.startTime && timeMs <= g.endTime
+    );
+    if (!activeGroup) {
+      return [];
+    }
+    return activeGroup.wordIndices.map((idx) => ({
+      wordIndex: idx,
+      text: layout.store.words[idx],
+      x: layout.store.xPositions[idx],
+      y: layout.store.yPositions[idx],
+      width: layout.store.widths[idx],
+      startTime: layout.store.startTimes[idx],
+      endTime: layout.store.endTimes[idx],
+      isRTL: layout.shapedWords[idx].isRTL
+    }));
+  }
+  getActiveWordAtTime(layout, timeMs) {
+    const wordIndex = findWordAtTime(layout.store, timeMs);
+    if (wordIndex === -1) {
+      return null;
+    }
+    return {
+      wordIndex,
+      text: layout.store.words[wordIndex],
+      x: layout.store.xPositions[wordIndex],
+      y: layout.store.yPositions[wordIndex],
+      width: layout.store.widths[wordIndex],
+      startTime: layout.store.startTimes[wordIndex],
+      endTime: layout.store.endTimes[wordIndex],
+      isRTL: layout.shapedWords[wordIndex].isRTL
+    };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      calculatedSize: this.cache.calculatedSize
+    };
+  }
+};
+
+// src/core/rich-caption-animator.ts
+var ANIMATION_DURATIONS = {
+  karaoke: 0,
+  highlight: 0,
+  pop: 200,
+  fade: 150,
+  slide: 250,
+  bounce: 400,
+  typewriter: 0,
+  none: 0
+};
+var DEFAULT_ANIMATION_STATE = {
+  opacity: 1,
+  scale: 1,
+  translateX: 0,
+  translateY: 0,
+  fillProgress: 1,
+  isActive: false,
+  visibleCharacters: -1
+};
+function easeOutQuad2(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+}
+function easeOutBack(t) {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+}
+function easeOutCirc(t) {
+  return Math.sqrt(1 - Math.pow(t - 1, 2));
+}
+function easeOutBounce(t) {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (t < 1 / d1) {
+    return n1 * t * t;
+  }
+  if (t < 2 / d1) {
+    return n1 * (t -= 1.5 / d1) * t + 0.75;
+  }
+  if (t < 2.5 / d1) {
+    return n1 * (t -= 2.25 / d1) * t + 0.9375;
+  }
+  return n1 * (t -= 2.625 / d1) * t + 0.984375;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function calculateAnimationProgress(ctx) {
+  if (ctx.animationDuration <= 0) {
+    return ctx.currentTime >= ctx.wordStart ? 1 : 0;
+  }
+  const elapsed = ctx.currentTime - ctx.wordStart;
+  return clamp(elapsed / ctx.animationDuration, 0, 1);
+}
+function calculateWordProgress(ctx) {
+  const duration = ctx.wordEnd - ctx.wordStart;
+  if (duration <= 0) {
+    return ctx.currentTime >= ctx.wordStart ? 1 : 0;
+  }
+  const elapsed = ctx.currentTime - ctx.wordStart;
+  return clamp(elapsed / duration, 0, 1);
+}
+function isWordActive(ctx) {
+  return ctx.currentTime >= ctx.wordStart && ctx.currentTime < ctx.wordEnd;
+}
+function calculateKaraokeState(ctx, speed) {
+  const isActive = isWordActive(ctx);
+  const wordDuration = ctx.wordEnd - ctx.wordStart;
+  const adjustedDuration = wordDuration / speed;
+  const adjustedEnd = ctx.wordStart + adjustedDuration;
+  const adjustedCtx = { ...ctx, wordEnd: adjustedEnd };
+  if (ctx.currentTime < ctx.wordStart) {
+    return {
+      fillProgress: 0,
+      isActive: false,
+      opacity: 1
+    };
+  }
+  if (ctx.currentTime >= adjustedEnd) {
+    return {
+      fillProgress: 1,
+      isActive: false,
+      opacity: 1
+    };
+  }
+  return {
+    fillProgress: calculateWordProgress(adjustedCtx),
+    isActive,
+    opacity: 1
+  };
+}
+function calculateHighlightState(ctx) {
+  const isActive = isWordActive(ctx);
+  return {
+    isActive,
+    fillProgress: isActive ? 1 : 0,
+    opacity: 1
+  };
+}
+function calculatePopState(ctx, activeScale, speed) {
+  if (ctx.currentTime < ctx.wordStart) {
+    return {
+      scale: 0.5,
+      opacity: 0,
+      isActive: false
+    };
+  }
+  const adjustedDuration = ctx.animationDuration / speed;
+  const adjustedCtx = { ...ctx, animationDuration: adjustedDuration };
+  const progress = calculateAnimationProgress(adjustedCtx);
+  const easedProgress = easeOutBack(progress);
+  const startScale = 0.5;
+  const endScale = isWordActive(ctx) ? activeScale : 1;
+  const scale = startScale + (endScale - startScale) * easedProgress;
+  return {
+    scale: Math.min(scale, activeScale),
+    opacity: easedProgress,
+    isActive: isWordActive(ctx)
+  };
+}
+function calculateFadeState(ctx, speed) {
+  if (ctx.currentTime < ctx.wordStart) {
+    return {
+      opacity: 0,
+      isActive: false
+    };
+  }
+  const adjustedDuration = ctx.animationDuration / speed;
+  const adjustedCtx = { ...ctx, animationDuration: adjustedDuration };
+  const progress = calculateAnimationProgress(adjustedCtx);
+  const easedProgress = easeInOutQuad(progress);
+  return {
+    opacity: easedProgress,
+    isActive: isWordActive(ctx)
+  };
+}
+function calculateSlideState(ctx, direction, speed, fontSize) {
+  const slideDistance = fontSize * 1.5;
+  if (ctx.currentTime < ctx.wordStart) {
+    const offset2 = getDirectionOffset(direction, slideDistance);
+    return {
+      translateX: offset2.x,
+      translateY: offset2.y,
+      opacity: 0,
+      isActive: false
+    };
+  }
+  const adjustedDuration = ctx.animationDuration / speed;
+  const adjustedCtx = { ...ctx, animationDuration: adjustedDuration };
+  const progress = calculateAnimationProgress(adjustedCtx);
+  const easedProgress = easeOutCirc(progress);
+  const offset = getDirectionOffset(direction, slideDistance);
+  const translateX = offset.x * (1 - easedProgress);
+  const translateY = offset.y * (1 - easedProgress);
+  return {
+    translateX,
+    translateY,
+    opacity: easeOutQuad2(progress),
+    isActive: isWordActive(ctx)
+  };
+}
+function getDirectionOffset(direction, distance) {
+  switch (direction) {
+    case "left":
+      return { x: -distance, y: 0 };
+    case "right":
+      return { x: distance, y: 0 };
+    case "up":
+      return { x: 0, y: -distance };
+    case "down":
+      return { x: 0, y: distance };
+  }
+}
+function calculateBounceState(ctx, speed, fontSize) {
+  const bounceDistance = fontSize * 0.8;
+  if (ctx.currentTime < ctx.wordStart) {
+    return {
+      translateY: -bounceDistance,
+      opacity: 0,
+      isActive: false
+    };
+  }
+  const adjustedDuration = ctx.animationDuration / speed;
+  const adjustedCtx = { ...ctx, animationDuration: adjustedDuration };
+  const progress = calculateAnimationProgress(adjustedCtx);
+  const easedProgress = easeOutBounce(progress);
+  return {
+    translateY: -bounceDistance * (1 - easedProgress),
+    opacity: easeOutQuad2(progress),
+    isActive: isWordActive(ctx)
+  };
+}
+function calculateTypewriterState(ctx, charCount, speed) {
+  const wordDuration = ctx.wordEnd - ctx.wordStart;
+  const adjustedDuration = wordDuration / speed;
+  const adjustedEnd = ctx.wordStart + adjustedDuration;
+  const adjustedCtx = { ...ctx, wordEnd: adjustedEnd };
+  if (ctx.currentTime < ctx.wordStart) {
+    return {
+      visibleCharacters: 0,
+      opacity: 1,
+      isActive: false
+    };
+  }
+  if (ctx.currentTime >= adjustedEnd) {
+    return {
+      visibleCharacters: charCount,
+      opacity: 1,
+      isActive: false
+    };
+  }
+  const progress = calculateWordProgress(adjustedCtx);
+  const visibleCharacters = Math.ceil(progress * charCount);
+  return {
+    visibleCharacters: clamp(visibleCharacters, 0, charCount),
+    opacity: 1,
+    isActive: isWordActive(ctx)
+  };
+}
+function calculateNoneState(ctx) {
+  return {
+    opacity: 1,
+    isActive: isWordActive(ctx)
+  };
+}
+function calculateWordAnimationState(wordStart, wordEnd, currentTime, config, activeScale = 1, charCount = 0, fontSize = 48) {
+  const ctx = {
+    wordStart,
+    wordEnd,
+    currentTime,
+    animationDuration: ANIMATION_DURATIONS[config.style]
+  };
+  const baseState = { ...DEFAULT_ANIMATION_STATE };
+  let partialState;
+  switch (config.style) {
+    case "karaoke":
+      partialState = calculateKaraokeState(ctx, config.speed);
+      break;
+    case "highlight":
+      partialState = calculateHighlightState(ctx);
+      break;
+    case "pop":
+      partialState = calculatePopState(ctx, activeScale, config.speed);
+      break;
+    case "fade":
+      partialState = calculateFadeState(ctx, config.speed);
+      break;
+    case "slide":
+      partialState = calculateSlideState(ctx, config.direction, config.speed, fontSize);
+      break;
+    case "bounce":
+      partialState = calculateBounceState(ctx, config.speed, fontSize);
+      break;
+    case "typewriter":
+      partialState = calculateTypewriterState(ctx, charCount, config.speed);
+      break;
+    case "none":
+    default:
+      partialState = calculateNoneState(ctx);
+      break;
+  }
+  return { ...baseState, ...partialState };
+}
+function calculateAnimationStatesForGroup(words, currentTime, config, activeScale = 1, fontSize = 48) {
+  const states = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    const state = calculateWordAnimationState(
+      word.startTime,
+      word.endTime,
+      currentTime,
+      config,
+      activeScale,
+      word.text.length,
+      fontSize
+    );
+    states.set(word.wordIndex, state);
+  }
+  return states;
+}
+function getDefaultAnimationConfig() {
+  return {
+    style: "highlight",
+    speed: 1,
+    direction: "up"
+  };
+}
+
+// src/core/rich-caption-generator.ts
+function extractFontConfig(asset) {
+  const font = asset.font;
+  const active = asset.active?.font;
+  return {
+    family: font?.family ?? "Open Sans",
+    size: font?.size ?? 24,
+    weight: String(font?.weight ?? "400"),
+    baseColor: font?.color ?? "#ffffff",
+    activeColor: active?.color ?? "#ffff00",
+    baseOpacity: font?.opacity ?? 1,
+    activeOpacity: active?.opacity ?? 1,
+    letterSpacing: asset.style?.letterSpacing ?? 0
+  };
+}
+function extractStrokeConfig(asset, isActive) {
+  const baseStroke = asset.stroke;
+  const activeStroke = asset.active?.stroke;
+  if (!baseStroke && !activeStroke) {
+    return void 0;
+  }
+  if (isActive && activeStroke) {
+    return {
+      width: activeStroke.width ?? baseStroke?.width ?? 0,
+      color: activeStroke.color ?? baseStroke?.color ?? "#000000",
+      opacity: activeStroke.opacity ?? baseStroke?.opacity ?? 1
+    };
+  }
+  if (baseStroke) {
+    return {
+      width: baseStroke.width ?? 0,
+      color: baseStroke.color ?? "#000000",
+      opacity: baseStroke.opacity ?? 1
+    };
+  }
+  return void 0;
+}
+function extractShadowConfig(asset) {
+  const shadow = asset.shadow;
+  if (!shadow) {
+    return void 0;
+  }
+  return {
+    offsetX: shadow.offsetX ?? 0,
+    offsetY: shadow.offsetY ?? 0,
+    blur: shadow.blur ?? 0,
+    color: shadow.color ?? "#000000",
+    opacity: shadow.opacity ?? 0.5
+  };
+}
+function extractBackgroundConfig(asset, isActive) {
+  const fontBackground = asset.font?.background;
+  const activeBackground = asset.active?.font?.background;
+  const bgColor = isActive && activeBackground ? activeBackground : fontBackground;
+  if (!bgColor) {
+    return void 0;
+  }
+  const paddingValues = extractCaptionPadding(asset);
+  const paddingValue = Math.max(paddingValues.top, paddingValues.right, paddingValues.bottom, paddingValues.left);
+  return {
+    color: bgColor,
+    opacity: 1,
+    borderRadius: 4,
+    padding: paddingValue
+  };
+}
+function extractCaptionPadding(asset) {
+  const padding = asset.padding;
+  if (!padding) {
+    return { top: 0, right: 0, bottom: 0, left: 0 };
+  }
+  if (typeof padding === "number") {
+    return { top: padding, right: padding, bottom: padding, left: padding };
+  }
+  return {
+    top: padding.top ?? 0,
+    right: padding.right ?? 0,
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0
+  };
+}
+function extractCaptionBackground(asset) {
+  const bg = asset.background;
+  if (!bg || !bg.color) {
+    return void 0;
+  }
+  return {
+    color: bg.color,
+    opacity: bg.opacity ?? 1
+  };
+}
+function extractAnimationConfig(asset) {
+  const wordAnim = asset.wordAnimation;
+  if (!wordAnim) {
+    return getDefaultAnimationConfig();
+  }
+  return {
+    style: wordAnim.style ?? "highlight",
+    speed: wordAnim.speed ?? 1,
+    direction: wordAnim.direction ?? "up"
+  };
+}
+function extractActiveScale(asset) {
+  return asset.active?.scale ?? 1;
+}
+function createDrawCaptionWordOp(word, animState, asset, fontConfig) {
+  const isActive = animState.isActive;
+  const displayText = animState.visibleCharacters >= 0 && animState.visibleCharacters < word.text.length ? word.text.slice(0, animState.visibleCharacters) : word.text;
+  return {
+    op: "DrawCaptionWord",
+    text: displayText,
+    x: word.x,
+    y: word.y,
+    width: word.width,
+    fontSize: fontConfig.size,
+    fontFamily: fontConfig.family,
+    fontWeight: fontConfig.weight,
+    baseColor: fontConfig.baseColor,
+    activeColor: fontConfig.activeColor,
+    baseOpacity: fontConfig.baseOpacity,
+    activeOpacity: fontConfig.activeOpacity,
+    fillProgress: animState.fillProgress,
+    transform: {
+      scale: animState.scale,
+      translateX: animState.translateX,
+      translateY: animState.translateY,
+      opacity: animState.opacity
+    },
+    isRTL: word.isRTL,
+    visibleCharacters: animState.visibleCharacters,
+    letterSpacing: fontConfig.letterSpacing > 0 ? fontConfig.letterSpacing : void 0,
+    stroke: extractStrokeConfig(asset, isActive),
+    shadow: extractShadowConfig(asset),
+    background: extractBackgroundConfig(asset, isActive)
+  };
+}
+function generateRichCaptionDrawOps(asset, layout, frameTimeMs, layoutEngine, _config) {
+  if (layout.store.length === 0) {
+    return [];
+  }
+  const visibleWords = layoutEngine.getVisibleWordsAtTime(layout, frameTimeMs);
+  if (visibleWords.length === 0) {
+    return [];
+  }
+  const animConfig = extractAnimationConfig(asset);
+  const activeScale = extractActiveScale(asset);
+  const fontConfig = extractFontConfig(asset);
+  const animationStates = calculateAnimationStatesForGroup(
+    visibleWords,
+    frameTimeMs,
+    animConfig,
+    activeScale,
+    fontConfig.size
+  );
+  const ops = [];
+  const captionBg = extractCaptionBackground(asset);
+  if (captionBg) {
+    const activeGroup = layout.groups.find(
+      (g) => frameTimeMs >= g.startTime && frameTimeMs <= g.endTime
+    );
+    if (activeGroup && activeGroup.lines.length > 0) {
+      const padding = extractCaptionPadding(asset);
+      let minX = Infinity;
+      let maxX = -Infinity;
+      let minY = Infinity;
+      let maxY = -Infinity;
+      for (const line of activeGroup.lines) {
+        const lineX = line.x;
+        const lineRight = line.x + line.width;
+        const lineY = line.y - line.height * 0.8;
+        const lineBottom = line.y + line.height * 0.2;
+        if (lineX < minX) minX = lineX;
+        if (lineRight > maxX) maxX = lineRight;
+        if (lineY < minY) minY = lineY;
+        if (lineBottom > maxY) maxY = lineBottom;
+      }
+      ops.push({
+        op: "DrawCaptionBackground",
+        x: minX - padding.left,
+        y: minY - padding.top,
+        width: maxX - minX + padding.left + padding.right,
+        height: maxY - minY + padding.top + padding.bottom,
+        color: captionBg.color,
+        opacity: captionBg.opacity,
+        borderRadius: 8
+      });
+    }
+  }
+  for (const word of visibleWords) {
+    const animState = animationStates.get(word.wordIndex);
+    if (!animState) {
+      continue;
+    }
+    if (animState.opacity <= 0) {
+      continue;
+    }
+    const drawOp = createDrawCaptionWordOp(word, animState, asset, fontConfig);
+    ops.push(drawOp);
+  }
+  return ops;
+}
+function generateRichCaptionFrame(asset, layout, frameTimeMs, layoutEngine, config) {
+  const ops = generateRichCaptionDrawOps(
+    asset,
+    layout,
+    frameTimeMs,
+    layoutEngine,
+    config
+  );
+  const activeWord = layoutEngine.getActiveWordAtTime(layout, frameTimeMs);
+  return {
+    ops,
+    visibleWordCount: ops.length,
+    activeWordIndex: activeWord?.wordIndex ?? -1
+  };
+}
+function createDefaultGeneratorConfig(frameWidth = 1920, frameHeight = 1080, pixelRatio = 1) {
+  return {
+    frameWidth,
+    frameHeight,
+    pixelRatio
+  };
+}
+function isDrawCaptionWordOp(op) {
+  return op.op === "DrawCaptionWord";
+}
+function getDrawCaptionWordOps(ops) {
+  return ops.filter(isDrawCaptionWordOp);
+}
+
+// src/core/canvas-text-measurer.ts
+async function createCanvasTextMeasurer() {
+  const canvasMod = await import("canvas");
+  const canvas = canvasMod.createCanvas(1, 1);
+  const ctx = canvas.getContext("2d");
+  ctx.textBaseline = "alphabetic";
+  let lastFont = "";
+  return (text, font) => {
+    if (font !== lastFont) {
+      ctx.font = font;
+      lastFont = font;
+    }
+    return ctx.measureText(text).width;
+  };
+}
+
+// src/core/subtitle-parser.ts
+function detectSubtitleFormat(content) {
+  const firstNewline = content.indexOf("\n");
+  const firstLine = (firstNewline === -1 ? content : content.substring(0, firstNewline)).trim();
+  return firstLine.startsWith("WEBVTT") ? "vtt" : "srt";
+}
+function parseSubtitleToWords(content) {
+  const normalized = normalizeContent(content);
+  if (normalized.length === 0) {
+    return [];
+  }
+  const format = detectSubtitleFormat(normalized);
+  const cues = format === "vtt" ? parseVTTCues(normalized) : parseSRTCues(normalized);
+  const words = [];
+  for (let i = 0; i < cues.length; i++) {
+    const cueWords = distributeCueToWords(cues[i]);
+    for (let j = 0; j < cueWords.length; j++) {
+      words.push(cueWords[j]);
+    }
+  }
+  return words;
+}
+function normalizeContent(content) {
+  let start = 0;
+  if (content.charCodeAt(0) === 65279) {
+    start = 1;
+  }
+  let result = start > 0 ? content.substring(start) : content;
+  result = result.replace(/\r\n?/g, "\n");
+  return result.trim();
+}
+function parseVTTCues(content) {
+  const cues = [];
+  let pos = 0;
+  const len = content.length;
+  const firstNewline = content.indexOf("\n", pos);
+  if (firstNewline === -1) {
+    return cues;
+  }
+  pos = firstNewline + 1;
+  while (pos < len) {
+    pos = skipWhitespaceAndNewlines(content, pos);
+    if (pos >= len) break;
+    const lineEnd = findLineEnd(content, pos);
+    const line = content.substring(pos, lineEnd);
+    if (line.startsWith("NOTE") || line.startsWith("STYLE") || line.startsWith("REGION")) {
+      pos = skipBlock(content, lineEnd + 1);
+      continue;
+    }
+    const arrowIdx = line.indexOf("-->");
+    let timeLine;
+    if (arrowIdx !== -1) {
+      timeLine = line;
+      pos = lineEnd + 1;
+    } else {
+      pos = lineEnd + 1;
+      if (pos >= len) break;
+      const nextLineEnd = findLineEnd(content, pos);
+      const nextLine = content.substring(pos, nextLineEnd);
+      if (nextLine.indexOf("-->") === -1) {
+        pos = skipBlock(content, nextLineEnd + 1);
+        continue;
+      }
+      timeLine = nextLine;
+      pos = nextLineEnd + 1;
+    }
+    const timestamps = parseTimeLineVTT(timeLine);
+    if (!timestamps) {
+      pos = skipBlock(content, pos);
+      continue;
+    }
+    let textLines = [];
+    while (pos < len) {
+      const tLineEnd = findLineEnd(content, pos);
+      const tLine = content.substring(pos, tLineEnd);
+      pos = tLineEnd + 1;
+      if (tLine.length === 0) break;
+      textLines.push(tLine);
+    }
+    if (textLines.length === 0) continue;
+    const rawText = textLines.join(" ");
+    const { cleanText, timestamps: inlineTs } = extractInlineTimestamps(rawText);
+    const strippedText = stripMarkupTags(cleanText).trim();
+    if (strippedText.length === 0) continue;
+    if (timestamps.endMs <= timestamps.startMs) continue;
+    cues.push({
+      startMs: timestamps.startMs,
+      endMs: timestamps.endMs,
+      text: strippedText,
+      inlineTimestamps: inlineTs
+    });
+  }
+  return cues;
+}
+function parseSRTCues(content) {
+  const cues = [];
+  let pos = 0;
+  const len = content.length;
+  while (pos < len) {
+    pos = skipWhitespaceAndNewlines(content, pos);
+    if (pos >= len) break;
+    let lineEnd = findLineEnd(content, pos);
+    let line = content.substring(pos, lineEnd);
+    pos = lineEnd + 1;
+    if (line.indexOf("-->") === -1) {
+      if (pos >= len) break;
+      lineEnd = findLineEnd(content, pos);
+      line = content.substring(pos, lineEnd);
+      pos = lineEnd + 1;
+    }
+    if (line.indexOf("-->") === -1) {
+      continue;
+    }
+    const timestamps = parseTimeLineSRT(line);
+    if (!timestamps) continue;
+    let textLines = [];
+    while (pos < len) {
+      const tLineEnd = findLineEnd(content, pos);
+      const tLine = content.substring(pos, tLineEnd);
+      pos = tLineEnd + 1;
+      if (tLine.length === 0) break;
+      textLines.push(tLine);
+    }
+    if (textLines.length === 0) continue;
+    const rawText = textLines.join(" ");
+    const strippedText = stripMarkupTags(rawText).trim();
+    if (strippedText.length === 0) continue;
+    if (timestamps.endMs <= timestamps.startMs) continue;
+    cues.push({
+      startMs: timestamps.startMs,
+      endMs: timestamps.endMs,
+      text: strippedText,
+      inlineTimestamps: []
+    });
+  }
+  return cues;
+}
+function parseTimeLineVTT(line) {
+  const arrowIdx = line.indexOf("-->");
+  if (arrowIdx === -1) return null;
+  const startRaw = line.substring(0, arrowIdx).trim();
+  const afterArrow = line.substring(arrowIdx + 3).trim();
+  const spaceIdx = afterArrow.indexOf(" ");
+  const endRaw = spaceIdx === -1 ? afterArrow : afterArrow.substring(0, spaceIdx);
+  const startMs = parseTimestampVTT(startRaw);
+  const endMs = parseTimestampVTT(endRaw);
+  if (startMs < 0 || endMs < 0) return null;
+  return { startMs, endMs };
+}
+function parseTimeLineSRT(line) {
+  const arrowIdx = line.indexOf("-->");
+  if (arrowIdx === -1) return null;
+  const startRaw = line.substring(0, arrowIdx).trim();
+  const endRaw = line.substring(arrowIdx + 3).trim();
+  const startMs = parseTimestampSRT(startRaw);
+  const endMs = parseTimestampSRT(endRaw);
+  if (startMs < 0 || endMs < 0) return null;
+  return { startMs, endMs };
+}
+function parseTimestampVTT(raw) {
+  const dotIdx = raw.lastIndexOf(".");
+  if (dotIdx === -1) return -1;
+  const msStr = raw.substring(dotIdx + 1);
+  const ms = parseIntFast(msStr);
+  if (ms < 0) return -1;
+  const beforeDot = raw.substring(0, dotIdx);
+  const parts = beforeDot.split(":");
+  if (parts.length === 2) {
+    const minutes = parseIntFast(parts[0]);
+    const seconds = parseIntFast(parts[1]);
+    if (minutes < 0 || seconds < 0) return -1;
+    return minutes * 6e4 + seconds * 1e3 + ms;
+  }
+  if (parts.length === 3) {
+    const hours = parseIntFast(parts[0]);
+    const minutes = parseIntFast(parts[1]);
+    const seconds = parseIntFast(parts[2]);
+    if (hours < 0 || minutes < 0 || seconds < 0) return -1;
+    return hours * 36e5 + minutes * 6e4 + seconds * 1e3 + ms;
+  }
+  return -1;
+}
+function parseTimestampSRT(raw) {
+  const commaIdx = raw.lastIndexOf(",");
+  if (commaIdx === -1) return -1;
+  const msStr = raw.substring(commaIdx + 1);
+  const ms = parseIntFast(msStr);
+  if (ms < 0) return -1;
+  const beforeComma = raw.substring(0, commaIdx);
+  const parts = beforeComma.split(":");
+  if (parts.length !== 3) return -1;
+  const hours = parseIntFast(parts[0]);
+  const minutes = parseIntFast(parts[1]);
+  const seconds = parseIntFast(parts[2]);
+  if (hours < 0 || minutes < 0 || seconds < 0) return -1;
+  return hours * 36e5 + minutes * 6e4 + seconds * 1e3 + ms;
+}
+function parseIntFast(str) {
+  let result = 0;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code < 48 || code > 57) return -1;
+    result = result * 10 + (code - 48);
+  }
+  return result;
+}
+var MARKUP_TAG_REGEX = /<[^>]+>/g;
+function stripMarkupTags(text) {
+  return text.replace(MARKUP_TAG_REGEX, "");
+}
+var INLINE_TIMESTAMP_REGEX = /<(\d{2}:)?(\d{2}):(\d{2}\.\d{3})>/g;
+function extractInlineTimestamps(text) {
+  const timestamps = [];
+  let cleanText = "";
+  let lastIndex = 0;
+  let match;
+  INLINE_TIMESTAMP_REGEX.lastIndex = 0;
+  while ((match = INLINE_TIMESTAMP_REGEX.exec(text)) !== null) {
+    cleanText += text.substring(lastIndex, match.index);
+    const position = cleanText.length;
+    const hoursStr = match[1] ? match[1].substring(0, match[1].length - 1) : "00";
+    const minutesStr = match[2];
+    const secondsAndMs = match[3];
+    const dotIdx = secondsAndMs.indexOf(".");
+    const secondsStr = secondsAndMs.substring(0, dotIdx);
+    const msStr = secondsAndMs.substring(dotIdx + 1);
+    const hours = parseIntFast(hoursStr);
+    const minutes = parseIntFast(minutesStr);
+    const seconds = parseIntFast(secondsStr);
+    const ms = parseIntFast(msStr);
+    if (hours >= 0 && minutes >= 0 && seconds >= 0 && ms >= 0) {
+      const timeMs = hours * 36e5 + minutes * 6e4 + seconds * 1e3 + ms;
+      timestamps.push({ timeMs, position });
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  cleanText += text.substring(lastIndex);
+  return { cleanText, timestamps };
+}
+function distributeCueToWords(cue) {
+  const wordTexts = cue.text.split(/\s+/).filter((w) => w.length > 0);
+  if (wordTexts.length === 0) return [];
+  if (wordTexts.length === 1) {
+    return [{ text: wordTexts[0], start: cue.startMs, end: cue.endMs }];
+  }
+  if (cue.inlineTimestamps.length > 0) {
+    return distributeWithInlineTimestamps(wordTexts, cue);
+  }
+  return distributeByCharacterProportion(wordTexts, cue.startMs, cue.endMs);
+}
+function distributeWithInlineTimestamps(wordTexts, cue) {
+  const wordPositions = [];
+  let charPos = 0;
+  for (let i = 0; i < wordTexts.length; i++) {
+    wordPositions.push(charPos);
+    charPos += wordTexts[i].length + 1;
+  }
+  const sortedTimestamps = [...cue.inlineTimestamps].sort((a, b) => a.position - b.position);
+  const wordStartTimes = new Array(wordTexts.length);
+  wordStartTimes[0] = cue.startMs;
+  for (let i = 1; i < wordTexts.length; i++) {
+    const wp = wordPositions[i];
+    let bestTs = -1;
+    for (let t = 0; t < sortedTimestamps.length; t++) {
+      if (sortedTimestamps[t].position <= wp) {
+        bestTs = t;
+      }
+    }
+    if (bestTs >= 0) {
+      wordStartTimes[i] = sortedTimestamps[bestTs].timeMs;
+    } else {
+      wordStartTimes[i] = wordStartTimes[i - 1];
+    }
+  }
+  const words = [];
+  for (let i = 0; i < wordTexts.length; i++) {
+    const start = wordStartTimes[i];
+    const end = i < wordTexts.length - 1 ? wordStartTimes[i + 1] : cue.endMs;
+    words.push({ text: wordTexts[i], start, end: Math.max(end, start) });
+  }
+  return words;
+}
+function distributeByCharacterProportion(wordTexts, startMs, endMs) {
+  const totalChars = wordTexts.reduce((sum, w) => sum + w.length, 0);
+  const duration = endMs - startMs;
+  const words = [];
+  let cursor = startMs;
+  for (let i = 0; i < wordTexts.length; i++) {
+    const wordStart = cursor;
+    if (i === wordTexts.length - 1) {
+      words.push({ text: wordTexts[i], start: wordStart, end: endMs });
+    } else {
+      const proportion = wordTexts[i].length / totalChars;
+      const wordDuration = Math.round(proportion * duration);
+      cursor = wordStart + wordDuration;
+      words.push({ text: wordTexts[i], start: wordStart, end: cursor });
+    }
+  }
+  return words;
+}
+function findLineEnd(content, pos) {
+  const idx = content.indexOf("\n", pos);
+  return idx === -1 ? content.length : idx;
+}
+function skipWhitespaceAndNewlines(content, pos) {
+  while (pos < content.length) {
+    const ch = content.charCodeAt(pos);
+    if (ch === 10 || ch === 13 || ch === 32 || ch === 9) {
+      pos++;
+    } else {
+      break;
+    }
+  }
+  return pos;
+}
+function skipBlock(content, pos) {
+  while (pos < content.length) {
+    const lineEnd = findLineEnd(content, pos);
+    const line = content.substring(pos, lineEnd);
+    pos = lineEnd + 1;
+    if (line.length === 0) break;
+  }
+  return pos;
+}
+
+// src/core/video/frame-scheduler.ts
+var PER_FRAME_ANIMATION_STYLES = /* @__PURE__ */ new Set([
+  "karaoke",
+  "typewriter"
+]);
+var TRANSITION_ANIMATION_STYLES = /* @__PURE__ */ new Set([
+  "pop",
+  "fade",
+  "slide",
+  "bounce"
+]);
+var ANIMATION_DURATION_MS = {
+  pop: 200,
+  fade: 150,
+  slide: 250,
+  bounce: 400
+};
+function findGroupIndexAtTime(groups, timeMs) {
+  for (let i = 0; i < groups.length; i++) {
+    if (timeMs >= groups[i].startTime && timeMs <= groups[i].endTime) {
+      return i;
+    }
+  }
+  return -1;
+}
+function findActiveWordIndex(store, groupWordIndices, timeMs) {
+  for (const idx of groupWordIndices) {
+    if (timeMs >= store.startTimes[idx] && timeMs < store.endTimes[idx]) {
+      return idx;
+    }
+  }
+  return -1;
+}
+function getAnimationPhase(store, groupWordIndices, timeMs, animationStyle, speed) {
+  if (groupWordIndices.length === 0) {
+    return "idle";
+  }
+  const activeWordIdx = findActiveWordIndex(store, groupWordIndices, timeMs);
+  if (PER_FRAME_ANIMATION_STYLES.has(animationStyle)) {
+    if (activeWordIdx !== -1) {
+      return "animating";
+    }
+    for (const idx of groupWordIndices) {
+      if (timeMs < store.startTimes[idx]) {
+        return "before";
+      }
+    }
+    return "after";
+  }
+  if (TRANSITION_ANIMATION_STYLES.has(animationStyle)) {
+    const transitionDurationMs = (ANIMATION_DURATION_MS[animationStyle] ?? 200) / speed;
+    for (const idx of groupWordIndices) {
+      const wordStart = store.startTimes[idx];
+      if (timeMs >= wordStart && timeMs < wordStart + transitionDurationMs) {
+        return "animating";
+      }
+    }
+    if (activeWordIdx !== -1) {
+      return "active";
+    }
+    for (const idx of groupWordIndices) {
+      if (timeMs < store.startTimes[idx]) {
+        return "before";
+      }
+    }
+    return "after";
+  }
+  if (activeWordIdx !== -1) {
+    return "active";
+  }
+  return "before";
+}
+function computeStateSignature(layout, timeMs, animationStyle, speed) {
+  const groupIndex = findGroupIndexAtTime(layout.groups, timeMs);
+  if (groupIndex === -1) {
+    return { groupIndex: -1, activeWordIndex: -1, animationPhase: "idle" };
+  }
+  const group = layout.groups[groupIndex];
+  const activeWordIndex = findActiveWordIndex(layout.store, group.wordIndices, timeMs);
+  const animationPhase = getAnimationPhase(
+    layout.store,
+    group.wordIndices,
+    timeMs,
+    animationStyle,
+    speed
+  );
+  return { groupIndex, activeWordIndex, animationPhase };
+}
+function signaturesMatch(a, b) {
+  return a.groupIndex === b.groupIndex && a.activeWordIndex === b.activeWordIndex && a.animationPhase === b.animationPhase;
+}
+function createFrameSchedule(layout, durationMs, fps, animationStyle = "highlight", speed = 1) {
+  const totalFrames = Math.max(2, Math.round(durationMs / 1e3 * fps) + 1);
+  const renderFrames = [];
+  let previousSignature = null;
+  for (let frame = 0; frame < totalFrames; frame++) {
+    const timeMs = frame / (totalFrames - 1) * durationMs;
+    const signature = computeStateSignature(layout, timeMs, animationStyle, speed);
+    const isAnimating = signature.animationPhase === "animating";
+    if (isAnimating || previousSignature === null || !signaturesMatch(signature, previousSignature)) {
+      renderFrames.push({
+        frameIndex: frame,
+        repeatCount: 1,
+        timeMs
+      });
+    } else {
+      renderFrames[renderFrames.length - 1].repeatCount++;
+    }
+    previousSignature = signature;
+  }
+  const uniqueFrameCount = renderFrames.length;
+  const skipRatio = 1 - uniqueFrameCount / totalFrames;
+  return {
+    renderFrames,
+    totalFrames,
+    uniqueFrameCount,
+    skipRatio
+  };
+}
+
+// src/core/video/node-raw-encoder.ts
+var import_child_process2 = require("child_process");
+var import_node_fs2 = __toESM(require("fs"), 1);
+var NodeRawEncoder = class _NodeRawEncoder {
+  ffmpegPath = null;
+  ffmpegProcess = null;
+  config = null;
+  outputPath = "";
+  frameCount = 0;
+  totalFrames = 0;
+  startTime = 0;
+  chunks = [];
+  outputToMemory = false;
+  ffmpegError = null;
+  static DRAIN_TIMEOUT_MS = 3e4;
+  onProgress;
+  trySetPath(p) {
+    if (p && import_node_fs2.default.existsSync(p)) {
+      this.ffmpegPath = p;
+      return true;
+    }
+    return false;
+  }
+  async initFFmpeg(ffmpegPath) {
+    if (this.trySetPath(ffmpegPath)) return;
+    if (this.trySetPath(process.env.FFMPEG_PATH)) return;
+    if (this.trySetPath(process.env.FFMPEG_BIN)) return;
+    if (this.trySetPath("/opt/bin/ffmpeg")) return;
+    try {
+      const ffmpegStatic = await import("ffmpeg-static");
+      const p = ffmpegStatic.default;
+      if (this.trySetPath(p)) return;
+    } catch {
+    }
+    throw new Error("FFmpeg not available. Please install ffmpeg-static or provide FFMPEG_PATH.");
+  }
+  async configure(config, options) {
+    this.config = config;
+    this.outputPath = options?.outputPath || "";
+    this.outputToMemory = !this.outputPath;
+    this.totalFrames = Math.max(2, Math.round(config.duration * config.fps) + 1);
+    this.frameCount = 0;
+    this.startTime = Date.now();
+    this.chunks = [];
+    this.ffmpegError = null;
+    await this.initFFmpeg(options?.ffmpegPath);
+    const {
+      width,
+      height,
+      fps,
+      crf = 17,
+      preset = "ultrafast",
+      profile = "high"
+    } = config;
+    const args = [
+      "-y",
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      "rgba",
+      "-s",
+      `${width}x${height}`,
+      "-r",
+      String(fps),
+      "-thread_queue_size",
+      "512",
+      "-i",
+      "pipe:0",
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-tune",
+      "stillimage",
+      "-crf",
+      String(crf),
+      "-profile:v",
+      profile,
+      "-g",
+      "300",
+      "-bf",
+      "2",
+      "-threads",
+      "0",
+      "-pix_fmt",
+      "yuv420p",
+      "-r",
+      String(fps),
+      "-movflags",
+      "+faststart"
+    ];
+    if (this.outputToMemory) {
+      args.push("-f", "mp4", "pipe:1");
+    } else {
+      args.push(this.outputPath);
+    }
+    this.ffmpegProcess = (0, import_child_process2.spawn)(this.ffmpegPath, args, {
+      stdio: ["pipe", this.outputToMemory ? "pipe" : "inherit", "pipe"]
+    });
+    if (this.outputToMemory && this.ffmpegProcess.stdout) {
+      this.ffmpegProcess.stdout.on("data", (chunk) => {
+        this.chunks.push(chunk);
+      });
+    }
+    this.ffmpegProcess.on("error", (err) => {
+      this.ffmpegError = err;
+    });
+    this.ffmpegProcess.stderr?.on("data", () => {
+    });
+  }
+  async encodeFrame(frameData, _frameIndex) {
+    if (this.ffmpegError) {
+      throw this.ffmpegError;
+    }
+    if (!this.ffmpegProcess || !this.ffmpegProcess.stdin) {
+      throw new Error("FFmpeg process not initialized. Call configure() first.");
+    }
+    const buffer = this.toBuffer(frameData);
+    const ok = this.ffmpegProcess.stdin.write(buffer);
+    if (!ok) {
+      await this.waitForDrain();
+    }
+    this.frameCount++;
+    this.reportProgress();
+  }
+  async encodeFrameRepeat(frameData, repeatCount) {
+    if (this.ffmpegError) {
+      throw this.ffmpegError;
+    }
+    if (!this.ffmpegProcess || !this.ffmpegProcess.stdin) {
+      throw new Error("FFmpeg process not initialized. Call configure() first.");
+    }
+    const buffer = this.toBuffer(frameData);
+    for (let i = 0; i < repeatCount; i++) {
+      const ok = this.ffmpegProcess.stdin.write(buffer);
+      if (!ok) {
+        await this.waitForDrain();
+      }
+      this.frameCount++;
+    }
+    this.reportProgress();
+  }
+  async flush() {
+    if (!this.ffmpegProcess) {
+      throw new Error("FFmpeg process not initialized.");
+    }
+    return new Promise((resolve, reject) => {
+      this.ffmpegProcess.on("close", (code) => {
+        if (code === 0) {
+          if (this.outputToMemory) {
+            const result = Buffer.concat(this.chunks);
+            resolve(new Uint8Array(result));
+          } else {
+            const fileBuffer = import_node_fs2.default.readFileSync(this.outputPath);
+            resolve(new Uint8Array(fileBuffer));
+          }
+        } else {
+          reject(new Error(`FFmpeg exited with code ${code}`));
+        }
+      });
+      this.ffmpegProcess.on("error", (err) => {
+        reject(err);
+      });
+      this.ffmpegProcess.stdin?.end();
+    });
+  }
+  close() {
+    if (this.ffmpegProcess) {
+      this.ffmpegProcess.kill("SIGTERM");
+      this.ffmpegProcess = null;
+    }
+    this.chunks = [];
+  }
+  waitForDrain() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error("FFmpeg stdin drain timeout"));
+      }, _NodeRawEncoder.DRAIN_TIMEOUT_MS);
+      const onError = (err) => {
+        clearTimeout(timer);
+        reject(err);
+      };
+      this.ffmpegProcess.once("error", onError);
+      this.ffmpegProcess.stdin.once("drain", () => {
+        clearTimeout(timer);
+        this.ffmpegProcess?.removeListener("error", onError);
+        resolve();
+      });
+    });
+  }
+  toBuffer(frameData) {
+    if (frameData instanceof ArrayBuffer) {
+      return Buffer.from(frameData);
+    }
+    return Buffer.from(frameData.buffer, frameData.byteOffset, frameData.byteLength);
+  }
+  reportProgress() {
+    if (!this.onProgress) return;
+    const elapsedMs = Date.now() - this.startTime;
+    if (elapsedMs === 0) return;
+    const framesPerSecond = this.frameCount / (elapsedMs / 1e3);
+    const remainingFrames = this.totalFrames - this.frameCount;
+    const estimatedRemainingMs = remainingFrames / framesPerSecond * 1e3;
+    this.onProgress({
+      framesEncoded: this.frameCount,
+      totalFrames: this.totalFrames,
+      percentage: this.frameCount / this.totalFrames * 100,
+      elapsedMs,
+      estimatedRemainingMs: Math.round(estimatedRemainingMs),
+      currentFps: Math.round(framesPerSecond * 10) / 10
+    });
+  }
+};
+async function createNodeRawEncoder(config, options) {
+  const encoder = new NodeRawEncoder();
+  await encoder.configure(config, options);
+  return encoder;
+}
+
+// src/core/rich-caption-renderer.ts
+var ROBOTO_FONT_URLS = {
+  "100": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWubEbGmT.ttf",
+  "300": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWuaabWmT.ttf",
+  "400": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWubEbWmT.ttf",
+  "500": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWub2bWmT.ttf",
+  "600": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWuYaammT.ttf",
+  "700": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWuYjammT.ttf",
+  "800": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWuZEammT.ttf",
+  "900": "https://fonts.gstatic.com/s/roboto/v50/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWuZtammT.ttf"
+};
+var RichCaptionRenderer = class {
+  width;
+  height;
+  pixelRatio;
+  fps;
+  wasmBaseURL;
+  fetchFile;
+  fontRegistry = null;
+  layoutEngine = null;
+  currentAsset = null;
+  currentLayout = null;
+  generatorConfig;
+  frameCount = 0;
+  totalRenderTimeMs = 0;
+  peakMemoryMB = 0;
+  lastMemoryCheckFrame = 0;
+  constructor(options) {
+    this.width = options.width;
+    this.height = options.height;
+    this.pixelRatio = options.pixelRatio ?? 1;
+    this.fps = options.fps ?? 30;
+    this.wasmBaseURL = options.wasmBaseURL;
+    this.fetchFile = options.fetchFile ?? loadFileOrHttpToArrayBuffer;
+    this.generatorConfig = createDefaultGeneratorConfig(this.width, this.height, this.pixelRatio);
+  }
+  async initialize() {
+    this.fontRegistry = await FontRegistry.getSharedInstance(this.wasmBaseURL);
+    this.layoutEngine = new CaptionLayoutEngine(this.fontRegistry);
+    const weightsToLoad = Object.keys(ROBOTO_FONT_URLS);
+    const loadPromises = weightsToLoad.map(async (weight) => {
+      const existingFace = await this.fontRegistry.getFace({ family: "Roboto", weight });
+      if (!existingFace) {
+        const bytes = await loadFileOrHttpToArrayBuffer(ROBOTO_FONT_URLS[weight]);
+        await this.fontRegistry.registerFromBytes(bytes, { family: "Roboto", weight });
+      }
+    });
+    await Promise.all(loadPromises);
+  }
+  async registerFont(source, desc) {
+    if (!this.fontRegistry) {
+      throw new Error("Renderer not initialized. Call initialize() first.");
+    }
+    const bytes = await loadFileOrHttpToArrayBuffer(source);
+    await this.fontRegistry.registerFromBytes(bytes, desc);
+  }
+  async loadAsset(asset) {
+    if (!this.layoutEngine || !this.fontRegistry) {
+      throw new Error("Renderer not initialized. Call initialize() first.");
+    }
+    this.currentAsset = asset;
+    let words;
+    if (asset.src) {
+      const bytes = await this.fetchFile(asset.src);
+      const text = new TextDecoder().decode(bytes);
+      words = parseSubtitleToWords(text);
+    } else {
+      words = (asset.words ?? []).map((w) => ({
+        text: w.text,
+        start: w.start,
+        end: w.end,
+        confidence: w.confidence
+      }));
+    }
+    if (words.length === 0) {
+      this.currentLayout = null;
+      return;
+    }
+    const font = asset.font;
+    const style = asset.style;
+    const measureTextWidth = await createCanvasTextMeasurer();
+    const layoutConfig = {
+      frameWidth: this.width,
+      frameHeight: this.height,
+      maxWidth: asset.maxWidth ?? 0.9,
+      maxLines: asset.maxLines ?? 2,
+      position: asset.position ?? "bottom",
+      fontSize: font?.size ?? 24,
+      fontFamily: font?.family ?? "Roboto",
+      fontWeight: String(font?.weight ?? "400"),
+      letterSpacing: style?.letterSpacing ?? 0,
+      wordSpacing: typeof style?.wordSpacing === "number" ? style.wordSpacing : 0,
+      lineHeight: style?.lineHeight ?? 1.2,
+      textTransform: style?.textTransform ?? "none",
+      pauseThreshold: 500,
+      measureTextWidth
+    };
+    this.currentLayout = await this.layoutEngine.layoutCaption(words, layoutConfig);
+  }
+  renderFrame(timeMs) {
+    if (!this.currentAsset || !this.currentLayout || !this.layoutEngine) {
+      return [];
+    }
+    const startTime = performance.now();
+    const ops = generateRichCaptionDrawOps(
+      this.currentAsset,
+      this.currentLayout,
+      timeMs,
+      this.layoutEngine,
+      this.generatorConfig
+    );
+    const endTime = performance.now();
+    this.totalRenderTimeMs += endTime - startTime;
+    this.frameCount++;
+    if (this.frameCount - this.lastMemoryCheckFrame >= 1e3) {
+      this.checkMemoryUsage();
+      this.lastMemoryCheckFrame = this.frameCount;
+    }
+    return ops;
+  }
+  async generateVideo(outputPath, duration, options) {
+    if (!this.currentAsset || !this.currentLayout) {
+      throw new Error("No asset loaded. Call loadAsset() first.");
+    }
+    const animationStyle = this.extractAnimationStyle();
+    const animationSpeed = this.extractAnimationSpeed();
+    const durationMs = duration * 1e3;
+    const schedule = createFrameSchedule(
+      this.currentLayout,
+      durationMs,
+      this.fps,
+      animationStyle,
+      animationSpeed
+    );
+    const encoder = new NodeRawEncoder();
+    await encoder.configure(
+      {
+        width: this.width * this.pixelRatio,
+        height: this.height * this.pixelRatio,
+        fps: this.fps,
+        duration,
+        crf: options?.crf ?? 23,
+        preset: options?.preset ?? "ultrafast",
+        profile: options?.profile ?? "high"
+      },
+      {
+        outputPath,
+        ffmpegPath: options?.ffmpegPath
+      }
+    );
+    const painter = await createNodePainter({
+      width: this.width,
+      height: this.height,
+      pixelRatio: this.pixelRatio
+    });
+    const bgColor = options?.bgColor ?? "#000000";
+    const totalStart = performance.now();
+    let framesProcessed = 0;
+    let lastPct = -1;
+    try {
+      for (let i = 0; i < schedule.renderFrames.length; i++) {
+        const renderFrame = schedule.renderFrames[i];
+        const captionOps = this.renderFrame(renderFrame.timeMs);
+        const beginOp = {
+          op: "BeginFrame",
+          width: this.width * this.pixelRatio,
+          height: this.height * this.pixelRatio,
+          pixelRatio: this.pixelRatio,
+          clear: true,
+          bg: { color: bgColor, opacity: 1, radius: 0 }
+        };
+        await painter.render([beginOp, ...captionOps]);
+        const rawResult = painter.toRawRGBA();
+        await encoder.encodeFrameRepeat(rawResult.data, renderFrame.repeatCount);
+        framesProcessed += renderFrame.repeatCount;
+        const pct = Math.floor(framesProcessed / schedule.totalFrames * 100);
+        if (pct % 5 === 0 && pct !== lastPct) {
+          lastPct = pct;
+          const elapsed = performance.now() - totalStart;
+          const fps = framesProcessed / (elapsed / 1e3);
+          const eta = (schedule.totalFrames - framesProcessed) / fps * 1e3;
+          this.logProgress(pct, framesProcessed, schedule.totalFrames, i + 1, schedule.uniqueFrameCount, fps, eta);
+        }
+        if (i % 500 === 0 && i > 0) {
+          this.checkMemoryUsage();
+          if (typeof global !== "undefined" && global.gc) {
+            global.gc();
+          }
+        }
+      }
+      await encoder.flush();
+      const totalTimeMs = performance.now() - totalStart;
+      const realtimeMultiplier = duration / (totalTimeMs / 1e3);
+      this.logCompletion(totalTimeMs, realtimeMultiplier);
+      return outputPath;
+    } catch (error) {
+      encoder.close();
+      throw error;
+    }
+  }
+  async generateVideoLegacy(outputPath, duration, options) {
+    if (!this.currentAsset || !this.currentLayout) {
+      throw new Error("No asset loaded. Call loadAsset() first.");
+    }
+    const videoGenerator = new VideoGenerator();
+    const frameGenerator = async (timeSeconds) => {
+      const timeMs = timeSeconds * 1e3;
+      const ops = this.renderFrame(timeMs);
+      const beginFrameOp = {
+        op: "BeginFrame",
+        width: this.width * this.pixelRatio,
+        height: this.height * this.pixelRatio,
+        pixelRatio: this.pixelRatio,
+        clear: true,
+        bg: {
+          color: options?.bgColor ?? "#000000",
+          opacity: 1,
+          radius: 0
+        }
+      };
+      return [beginFrameOp, ...ops];
+    };
+    const videoOptions = {
+      width: this.width,
+      height: this.height,
+      fps: this.fps,
+      duration,
+      outputPath,
+      pixelRatio: this.pixelRatio,
+      hasAlpha: false,
+      ...options
+    };
+    return videoGenerator.generateVideo(frameGenerator, videoOptions);
+  }
+  async generateVideoWithChunking(outputPath, duration, options) {
+    if (!this.currentAsset || !this.currentLayout) {
+      throw new Error("No asset loaded. Call loadAsset() first.");
+    }
+    const videoGenerator = new VideoGenerator();
+    const chunkSize = 1e3;
+    let processedFrames = 0;
+    const frameGenerator = async (timeSeconds) => {
+      const timeMs = timeSeconds * 1e3;
+      const ops = this.renderFrame(timeMs);
+      processedFrames++;
+      if (processedFrames % chunkSize === 0) {
+        this.checkMemoryUsage();
+        if (typeof global !== "undefined" && global.gc) {
+          global.gc();
+        }
+      }
+      const beginFrameOp = {
+        op: "BeginFrame",
+        width: this.width * this.pixelRatio,
+        height: this.height * this.pixelRatio,
+        pixelRatio: this.pixelRatio,
+        clear: true,
+        bg: {
+          color: options?.bgColor ?? "#000000",
+          opacity: 1,
+          radius: 0
+        }
+      };
+      return [beginFrameOp, ...ops];
+    };
+    const videoOptions = {
+      width: this.width,
+      height: this.height,
+      fps: this.fps,
+      duration,
+      outputPath,
+      pixelRatio: this.pixelRatio,
+      hasAlpha: false,
+      ...options
+    };
+    return videoGenerator.generateVideo(frameGenerator, videoOptions);
+  }
+  getFrameSchedule(duration) {
+    if (!this.currentLayout) {
+      throw new Error("No asset loaded. Call loadAsset() first.");
+    }
+    const animationStyle = this.extractAnimationStyle();
+    const animationSpeed = this.extractAnimationSpeed();
+    return createFrameSchedule(
+      this.currentLayout,
+      duration * 1e3,
+      this.fps,
+      animationStyle,
+      animationSpeed
+    );
+  }
+  getStats() {
+    const cacheStats = this.layoutEngine?.getCacheStats() ?? { size: 0, calculatedSize: 0 };
+    return {
+      frameCount: this.frameCount,
+      totalRenderTimeMs: this.totalRenderTimeMs,
+      averageFrameTimeMs: this.frameCount > 0 ? this.totalRenderTimeMs / this.frameCount : 0,
+      peakMemoryMB: this.peakMemoryMB,
+      cacheHitRate: cacheStats.size > 0 ? 0.95 : 0
+    };
+  }
+  resetStats() {
+    this.frameCount = 0;
+    this.totalRenderTimeMs = 0;
+    this.peakMemoryMB = 0;
+    this.lastMemoryCheckFrame = 0;
+  }
+  clearCache() {
+    this.layoutEngine?.clearCache();
+  }
+  extractAnimationStyle() {
+    const wordAnim = this.currentAsset?.wordAnimation;
+    return wordAnim?.style ?? "highlight";
+  }
+  extractAnimationSpeed() {
+    const wordAnim = this.currentAsset?.wordAnimation;
+    return wordAnim?.speed ?? 1;
+  }
+  logProgress(pct, framesProcessed, totalFrames, uniqueProcessed, uniqueTotal, fps, eta) {
+    if (typeof process !== "undefined" && process.stderr) {
+      process.stderr.write(
+        `  [${String(pct).padStart(3)}%] Frame ${framesProcessed}/${totalFrames} (${uniqueProcessed}/${uniqueTotal} unique) | ${fps.toFixed(1)} fps | ETA: ${formatMs(eta)}
+`
+      );
+    }
+  }
+  logCompletion(totalTimeMs, realtimeMultiplier) {
+    if (typeof process !== "undefined" && process.stderr) {
+      process.stderr.write(
+        `  Done: ${formatMs(totalTimeMs)} (${realtimeMultiplier.toFixed(1)}x realtime)
+`
+      );
+    }
+  }
+  checkMemoryUsage() {
+    if (typeof process !== "undefined" && process.memoryUsage) {
+      const usage = process.memoryUsage();
+      const heapUsedMB = usage.heapUsed / (1024 * 1024);
+      if (heapUsedMB > this.peakMemoryMB) {
+        this.peakMemoryMB = heapUsedMB;
+      }
+      if (usage.heapUsed > 1500 * 1024 * 1024) {
+        if (typeof global !== "undefined" && global.gc) {
+          global.gc();
+        }
+      }
+    }
+  }
+  destroy() {
+    this.currentAsset = null;
+    this.currentLayout = null;
+    this.layoutEngine?.clearCache();
+    if (this.fontRegistry) {
+      this.fontRegistry.release();
+      this.fontRegistry = null;
+    }
+    this.layoutEngine = null;
+  }
+};
+function formatMs(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(0)}s`;
+}
+async function createRichCaptionRenderer(options) {
+  const renderer = new RichCaptionRenderer(options);
+  await renderer.initialize();
+  return renderer;
+}
+
+// src/core/video/encoder-factory.ts
+async function createVideoEncoder(config, options) {
+  const platform = options?.platform ?? detectPlatform();
+  if (platform === "node") {
+    throw new Error("Use createNodeRawEncoder from node-raw-encoder module for Node.js encoding");
+  }
+  if (options?.preferredEncoder === "mediarecorder") {
+    return createMediaRecorderEncoder(config, options?.canvas);
+  }
+  const webCodecsSupported = await isWebCodecsH264Supported();
+  if (webCodecsSupported) {
+    try {
+      const { WebCodecsEncoder: WebCodecsEncoder2 } = await Promise.resolve().then(() => (init_web_encoder(), web_encoder_exports));
+      const encoder = new WebCodecsEncoder2();
+      await encoder.configure(config);
+      return encoder;
+    } catch (error) {
+      console.warn("WebCodecs encoder failed to initialize, falling back to MediaRecorder:", error);
+    }
+  }
+  return createMediaRecorderEncoder(config, options?.canvas);
+}
+async function createMediaRecorderEncoder(config, canvas) {
+  const { MediaRecorderFallback: MediaRecorderFallback2 } = await Promise.resolve().then(() => (init_mediarecorder_fallback(), mediarecorder_fallback_exports));
+  const encoder = new MediaRecorderFallback2();
+  await encoder.configure(config, canvas);
+  return encoder;
+}
+async function isWebCodecsH264Supported() {
+  if (typeof globalThis === "undefined") return false;
+  const VideoEncoder2 = globalThis.VideoEncoder;
+  if (!VideoEncoder2 || typeof VideoEncoder2.isConfigSupported !== "function") {
+    return false;
+  }
+  try {
+    const config = {
+      codec: "avc1.42001E",
+      width: 1920,
+      height: 1080,
+      bitrate: 8e6,
+      framerate: 30
+    };
+    const support = await VideoEncoder2.isConfigSupported(config);
+    return support.supported === true;
+  } catch {
+    return false;
+  }
+}
+async function getEncoderCapabilities() {
+  const platform = detectPlatform();
+  if (platform === "node") {
+    return {
+      encoder: "node-raw",
+      codec: "h264",
+      hardwareAccelerated: false,
+      supportsH264: true
+    };
+  }
+  const webCodecsSupported = await isWebCodecsH264Supported();
+  if (webCodecsSupported) {
+    return {
+      encoder: "webcodecs",
+      codec: "h264",
+      hardwareAccelerated: true,
+      supportsH264: true
+    };
+  }
+  return {
+    encoder: "mediarecorder",
+    codec: "vp9",
+    hardwareAccelerated: false,
+    supportsH264: false
+  };
+}
+function detectPlatform() {
+  if (typeof window === "undefined" && typeof process !== "undefined" && process.versions?.node) {
+    return "node";
+  }
+  return "web";
+}
+function getEncoderWarning() {
+  const platform = detectPlatform();
+  if (platform === "node") return null;
+  if (typeof globalThis !== "undefined") {
+    const VideoEncoder2 = globalThis.VideoEncoder;
+    if (!VideoEncoder2) {
+      return "Your browser doesn't support fast H.264 encoding (WebCodecs). Using real-time recording with WebM format instead. For best performance, use Chrome 94+, Edge 94+, or Safari 16.4+.";
+    }
+  }
+  return null;
+}
+
 // src/env/entry.node.ts
 var registeredGlobalFonts = /* @__PURE__ */ new Set();
 async function registerColorEmojiWithCanvas(family, bytes) {
@@ -3992,22 +6527,47 @@ async function createTextEngine(opts = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CanvasRichCaptionAssetSchema,
   CanvasRichTextAssetSchema,
   CanvasSvgAssetSchema,
+  CaptionLayoutEngine,
+  FontRegistry,
+  NodeRawEncoder,
+  RichCaptionRenderer,
+  WordTimingStore,
   arcToCubicBeziers,
+  calculateAnimationStatesForGroup,
   commandsToPathString,
   computeSimplePathBounds,
+  createDefaultGeneratorConfig,
+  createFrameSchedule,
   createNodePainter,
+  createNodeRawEncoder,
+  createRichCaptionRenderer,
   createTextEngine,
+  createVideoEncoder,
+  detectPlatform,
+  detectSubtitleFormat,
+  findWordAtTime,
+  generateRichCaptionDrawOps,
+  generateRichCaptionFrame,
   generateShapePathData,
-  isGlyphFill,
-  isShadowFill,
+  getDefaultAnimationConfig,
+  getDrawCaptionWordOps,
+  getEncoderCapabilities,
+  getEncoderWarning,
+  groupWordsByPause,
+  isDrawCaptionWordOp,
+  isRTLText,
+  isWebCodecsH264Supported,
   normalizePath,
   normalizePathString,
+  parseSubtitleToWords,
   parseSvgPath,
   quadraticToCubic,
   renderSvgAssetToPng,
   renderSvgToPng,
+  richCaptionAssetSchema,
   shapeToSvgString,
   svgAssetSchema,
   svgGradientStopSchema,