@hyperframes/producer 0.4.19 → 0.4.21

package/dist/index.js

@@ -7906,7 +7906,7 @@ function inertIfDisposed(target, _) {
   };
 }
 function invokeAtMostOnceForArguments(target, _) {
-  const cache = /* @__PURE__ */ new WeakMap();
+  const cache2 = /* @__PURE__ */ new WeakMap();
   let cacheDepth = -1;
   return function(...args) {
     if (cacheDepth === -1) {
@@ -7916,7 +7916,7 @@ function invokeAtMostOnceForArguments(target, _) {
       throw new Error("Memoized method was called with the wrong number of arguments");
     }
     let freshArguments = false;
-    let cacheIterator = cache;
+    let cacheIterator = cache2;
     for (const arg of args) {
       if (cacheIterator.has(arg)) {
         cacheIterator = cacheIterator.get(arg);
@@ -45139,7 +45139,7 @@ var require_websocket = __commonJS({
     var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash3 } = __require("crypto");
+    var { randomBytes, createHash: createHash4 } = __require("crypto");
     var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -45799,7 +45799,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash3("sha1").update(key2 + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key2 + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -46166,7 +46166,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter4 = __require("events");
     var http2 = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash3 } = __require("crypto");
+    var { createHash: createHash4 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -46467,7 +46467,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash3("sha1").update(key2 + GUID).digest("base64");
+        const digest = createHash4("sha1").update(key2 + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -47603,7 +47603,7 @@ var require_range = __commonJS({
       parseRange(range) {
         const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
         const memoKey = memoOpts + ":" + range;
-        const cached = cache.get(memoKey);
+        const cached = cache2.get(memoKey);
         if (cached) {
           return cached;
         }
@@ -47637,7 +47637,7 @@ var require_range = __commonJS({
           rangeMap.delete("");
         }
         const result = [...rangeMap.values()];
-        cache.set(memoKey, result);
+        cache2.set(memoKey, result);
         return result;
       }
       intersects(range, options) {
@@ -47676,7 +47676,7 @@ var require_range = __commonJS({
     };
     module.exports = Range2;
     var LRU = require_lrucache();
-    var cache = new LRU();
+    var cache2 = new LRU();
     var parseOptions = require_parse_options();
     var Comparator = require_comparator();
     var debug6 = require_debug();
@@ -54356,12 +54356,12 @@ var require_data = __commonJS({
         this.hash = hash2;
       }
     };
-    var data = async ({ href: uri }, { cache } = {}) => {
+    var data = async ({ href: uri }, { cache: cache2 } = {}) => {
       const shasum = (0, crypto_1.createHash)("sha1");
       shasum.update(uri);
       const hash2 = shasum.digest("hex");
       debug6('generated SHA1 hash for "data:" URI: %o', hash2);
-      if (cache?.hash === hash2) {
+      if (cache2?.hash === hash2) {
         debug6("got matching cache SHA1 hash: %o", hash2);
         throw new notmodified_1.default();
       } else {
@@ -54406,7 +54406,7 @@ var require_file = __commonJS({
     var debug6 = (0, debug_1.default)("get-uri:file");
     var file = async ({ href: uri }, opts = {}) => {
       const {
-        cache,
+        cache: cache2,
         flags = "r",
         mode = 438
         // =0666
@@ -54417,7 +54417,7 @@ var require_file = __commonJS({
         const fdHandle = await fs_1.promises.open(filepath, flags, mode);
         const fd = fdHandle.fd;
         const stat = await fdHandle.stat();
-        if (cache && cache.stat && stat && isNotModified(cache.stat, stat)) {
+        if (cache2 && cache2.stat && stat && isNotModified(cache2.stat, stat)) {
           await fdHandle.close();
           throw new notmodified_1.default();
         }
@@ -56437,7 +56437,7 @@ var require_ftp = __commonJS({
     var notmodified_1 = __importDefault2(require_notmodified());
     var debug6 = (0, debug_1.default)("get-uri:ftp");
     var ftp = async (url, opts = {}) => {
-      const { cache } = opts;
+      const { cache: cache2 } = opts;
       const filepath = decodeURIComponent(url.pathname);
       let lastModified;
       if (!filepath) {
@@ -56491,8 +56491,8 @@ var require_ftp = __commonJS({
         throw err;
       }
       function isNotModified() {
-        if (cache?.lastModified && lastModified) {
-          return +cache.lastModified === +lastModified;
+        if (cache2?.lastModified && lastModified) {
+          return +cache2.lastModified === +lastModified;
         }
         return false;
       }
@@ -56537,10 +56537,10 @@ var require_http = __commonJS({
     var debug6 = (0, debug_1.default)("get-uri:http");
     var http2 = async (url, opts = {}) => {
       debug6("GET %o", url.href);
-      const cache = getCache(url, opts.cache);
-      if (cache && isFresh(cache) && typeof cache.statusCode === "number") {
-        const type2 = cache.statusCode / 100 | 0;
-        if (type2 === 3 && cache.headers.location) {
+      const cache2 = getCache(url, opts.cache);
+      if (cache2 && isFresh(cache2) && typeof cache2.statusCode === "number") {
+        const type2 = cache2.statusCode / 100 | 0;
+        if (type2 === 3 && cache2.headers.location) {
           debug6("cached redirect");
           throw new Error("TODO: implement cached redirects!");
         }
@@ -56557,16 +56557,16 @@ var require_http = __commonJS({
         debug6("using `http` core module");
       }
       const options = { ...opts };
-      if (cache) {
+      if (cache2) {
         if (!options.headers) {
           options.headers = {};
         }
-        const lastModified = cache.headers["last-modified"];
+        const lastModified = cache2.headers["last-modified"];
         if (lastModified) {
           options.headers["If-Modified-Since"] = lastModified;
           debug6('added "If-Modified-Since" request header: %o', lastModified);
         }
-        const etag = cache.headers.etag;
+        const etag = cache2.headers.etag;
         if (etag) {
           options.headers["If-None-Match"] = etag;
           debug6('added "If-None-Match" request header: %o', etag);
@@ -56613,10 +56613,10 @@ var require_http = __commonJS({
       return res;
     };
     exports.http = http2;
-    function isFresh(cache) {
+    function isFresh(cache2) {
       let fresh = false;
-      let expires = parseInt(cache.headers.expires || "", 10);
-      const cacheControl = cache.headers["cache-control"];
+      let expires = parseInt(cache2.headers.expires || "", 10);
+      const cacheControl = cache2.headers["cache-control"];
       if (cacheControl) {
         debug6("Cache-Control: %o", cacheControl);
         const parts = cacheControl.split(/,\s*?\b/);
@@ -56626,7 +56626,7 @@ var require_http = __commonJS({
           const name = subparts[0];
           switch (name) {
             case "max-age":
-              expires = (cache.date || 0) + parseInt(subparts[1], 10) * 1e3;
+              expires = (cache2.date || 0) + parseInt(subparts[1], 10) * 1e3;
               fresh = Date.now() < expires;
               if (fresh) {
                 debug6('cache is "fresh" due to previous %o Cache-Control param', part);
@@ -56652,14 +56652,14 @@ var require_http = __commonJS({
       }
       return false;
     }
-    function getCache(url, cache) {
-      if (cache) {
-        if (cache.parsed && cache.parsed.href === url.href) {
-          return cache;
+    function getCache(url, cache2) {
+      if (cache2) {
+        if (cache2.parsed && cache2.parsed.href === url.href) {
+          return cache2;
         }
-        if (cache.redirects) {
-          for (let i = 0; i < cache.redirects.length; i++) {
-            const c = getCache(url, cache.redirects[i]);
+        if (cache2.redirects) {
+          for (let i = 0; i < cache2.redirects.length; i++) {
+            const c = getCache(url, cache2.redirects[i]);
             if (c) {
               return c;
             }
@@ -57894,7 +57894,7 @@ var require_util2 = __commonJS({
       return path12;
     }
     exports.normalize = normalize2;
-    function join18(aRoot, aPath) {
+    function join19(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -57926,7 +57926,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports.join = join18;
+    exports.join = join19;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -58099,7 +58099,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join18(urlGenerate(parsed), sourceURL);
+        sourceURL = join19(urlGenerate(parsed), sourceURL);
       }
       return normalize2(sourceURL);
     }
@@ -59901,7 +59901,7 @@ var require_escodegen = __commonJS({
       function noEmptySpace() {
         return space ? space : " ";
       }
-      function join18(left2, right2) {
+      function join19(left2, right2) {
         var leftSource, rightSource, leftCharCode, rightCharCode;
         leftSource = toSourceNodeWhenNeeded(left2).toString();
         if (leftSource.length === 0) {
@@ -60232,8 +60232,8 @@ var require_escodegen = __commonJS({
           } else {
             result.push(that.generateExpression(stmt.left, Precedence.Call, E_TTT));
           }
-          result = join18(result, operator);
-          result = [join18(
+          result = join19(result, operator);
+          result = [join19(
             result,
             that.generateExpression(stmt.right, Precedence.Assignment, E_TTT)
           ), ")"];
@@ -60376,11 +60376,11 @@ var require_escodegen = __commonJS({
           var result, fragment;
           result = ["class"];
           if (stmt.id) {
-            result = join18(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
+            result = join19(result, this.generateExpression(stmt.id, Precedence.Sequence, E_TTT));
           }
           if (stmt.superClass) {
-            fragment = join18("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
-            result = join18(result, fragment);
+            fragment = join19("extends", this.generateExpression(stmt.superClass, Precedence.Unary, E_TTT));
+            result = join19(result, fragment);
           }
           result.push(space);
           result.push(this.generateStatement(stmt.body, S_TFFT));
@@ -60393,9 +60393,9 @@ var require_escodegen = __commonJS({
           return escapeDirective(stmt.directive) + this.semicolon(flags);
         },
         DoWhileStatement: function(stmt, flags) {
-          var result = join18("do", this.maybeBlock(stmt.body, S_TFFF));
+          var result = join19("do", this.maybeBlock(stmt.body, S_TFFF));
           result = this.maybeBlockSuffix(stmt.body, result);
-          return join18(result, [
+          return join19(result, [
             "while" + space + "(",
             this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
             ")" + this.semicolon(flags)
@@ -60431,11 +60431,11 @@ var require_escodegen = __commonJS({
         ExportDefaultDeclaration: function(stmt, flags) {
           var result = ["export"], bodyFlags;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
-          result = join18(result, "default");
+          result = join19(result, "default");
           if (isStatement(stmt.declaration)) {
-            result = join18(result, this.generateStatement(stmt.declaration, bodyFlags));
+            result = join19(result, this.generateStatement(stmt.declaration, bodyFlags));
           } else {
-            result = join18(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
+            result = join19(result, this.generateExpression(stmt.declaration, Precedence.Assignment, E_TTT) + this.semicolon(flags));
           }
           return result;
         },
@@ -60443,15 +60443,15 @@ var require_escodegen = __commonJS({
           var result = ["export"], bodyFlags, that = this;
           bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;
           if (stmt.declaration) {
-            return join18(result, this.generateStatement(stmt.declaration, bodyFlags));
+            return join19(result, this.generateStatement(stmt.declaration, bodyFlags));
           }
           if (stmt.specifiers) {
             if (stmt.specifiers.length === 0) {
-              result = join18(result, "{" + space + "}");
+              result = join19(result, "{" + space + "}");
             } else if (stmt.specifiers[0].type === Syntax.ExportBatchSpecifier) {
-              result = join18(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
+              result = join19(result, this.generateExpression(stmt.specifiers[0], Precedence.Sequence, E_TTT));
             } else {
-              result = join18(result, "{");
+              result = join19(result, "{");
               withIndent(function(indent2) {
                 var i, iz;
                 result.push(newline);
@@ -60469,7 +60469,7 @@ var require_escodegen = __commonJS({
               result.push(base + "}");
             }
             if (stmt.source) {
-              result = join18(result, [
+              result = join19(result, [
                 "from" + space,
                 // ModuleSpecifier
                 this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -60557,7 +60557,7 @@ var require_escodegen = __commonJS({
           ];
           cursor = 0;
           if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
-            result = join18(result, [
+            result = join19(result, [
               this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
             ]);
             ++cursor;
@@ -60567,7 +60567,7 @@ var require_escodegen = __commonJS({
               result.push(",");
             }
             if (stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier) {
-              result = join18(result, [
+              result = join19(result, [
                 space,
                 this.generateExpression(stmt.specifiers[cursor], Precedence.Sequence, E_TTT)
               ]);
@@ -60596,7 +60596,7 @@ var require_escodegen = __commonJS({
               }
             }
           }
-          result = join18(result, [
+          result = join19(result, [
             "from" + space,
             // ModuleSpecifier
             this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
@@ -60650,7 +60650,7 @@ var require_escodegen = __commonJS({
           return result;
         },
         ThrowStatement: function(stmt, flags) {
-          return [join18(
+          return [join19(
             "throw",
             this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
           ), this.semicolon(flags)];
@@ -60661,7 +60661,7 @@ var require_escodegen = __commonJS({
           result = this.maybeBlockSuffix(stmt.block, result);
           if (stmt.handlers) {
             for (i = 0, iz = stmt.handlers.length; i < iz; ++i) {
-              result = join18(result, this.generateStatement(stmt.handlers[i], S_TFFF));
+              result = join19(result, this.generateStatement(stmt.handlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result = this.maybeBlockSuffix(stmt.handlers[i].body, result);
               }
@@ -60669,7 +60669,7 @@ var require_escodegen = __commonJS({
           } else {
             guardedHandlers = stmt.guardedHandlers || [];
             for (i = 0, iz = guardedHandlers.length; i < iz; ++i) {
-              result = join18(result, this.generateStatement(guardedHandlers[i], S_TFFF));
+              result = join19(result, this.generateStatement(guardedHandlers[i], S_TFFF));
               if (stmt.finalizer || i + 1 !== iz) {
                 result = this.maybeBlockSuffix(guardedHandlers[i].body, result);
               }
@@ -60677,13 +60677,13 @@ var require_escodegen = __commonJS({
             if (stmt.handler) {
               if (Array.isArray(stmt.handler)) {
                 for (i = 0, iz = stmt.handler.length; i < iz; ++i) {
-                  result = join18(result, this.generateStatement(stmt.handler[i], S_TFFF));
+                  result = join19(result, this.generateStatement(stmt.handler[i], S_TFFF));
                   if (stmt.finalizer || i + 1 !== iz) {
                     result = this.maybeBlockSuffix(stmt.handler[i].body, result);
                   }
                 }
               } else {
-                result = join18(result, this.generateStatement(stmt.handler, S_TFFF));
+                result = join19(result, this.generateStatement(stmt.handler, S_TFFF));
                 if (stmt.finalizer) {
                   result = this.maybeBlockSuffix(stmt.handler.body, result);
                 }
@@ -60691,7 +60691,7 @@ var require_escodegen = __commonJS({
             }
           }
           if (stmt.finalizer) {
-            result = join18(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
+            result = join19(result, ["finally", this.maybeBlock(stmt.finalizer, S_TFFF)]);
           }
           return result;
         },
@@ -60725,7 +60725,7 @@ var require_escodegen = __commonJS({
           withIndent(function() {
             if (stmt.test) {
               result = [
-                join18("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
+                join19("case", that.generateExpression(stmt.test, Precedence.Sequence, E_TTT)),
                 ":"
               ];
             } else {
@@ -60773,9 +60773,9 @@ var require_escodegen = __commonJS({
             result.push(this.maybeBlock(stmt.consequent, S_TFFF));
             result = this.maybeBlockSuffix(stmt.consequent, result);
             if (stmt.alternate.type === Syntax.IfStatement) {
-              result = join18(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
+              result = join19(result, ["else ", this.generateStatement(stmt.alternate, bodyFlags)]);
             } else {
-              result = join18(result, join18("else", this.maybeBlock(stmt.alternate, bodyFlags)));
+              result = join19(result, join19("else", this.maybeBlock(stmt.alternate, bodyFlags)));
             }
           } else {
             result.push(this.maybeBlock(stmt.consequent, bodyFlags));
@@ -60876,7 +60876,7 @@ var require_escodegen = __commonJS({
         },
         ReturnStatement: function(stmt, flags) {
           if (stmt.argument) {
-            return [join18(
+            return [join19(
               "return",
               this.generateExpression(stmt.argument, Precedence.Sequence, E_TTT)
             ), this.semicolon(flags)];
@@ -60965,14 +60965,14 @@ var require_escodegen = __commonJS({
           if (leftSource.charCodeAt(leftSource.length - 1) === 47 && esutils.code.isIdentifierPartES5(expr.operator.charCodeAt(0))) {
             result = [fragment, noEmptySpace(), expr.operator];
           } else {
-            result = join18(fragment, expr.operator);
+            result = join19(fragment, expr.operator);
           }
           fragment = this.generateExpression(expr.right, rightPrecedence, flags);
           if (expr.operator === "/" && fragment.toString().charAt(0) === "/" || expr.operator.slice(-1) === "<" && fragment.toString().slice(0, 3) === "!--") {
             result.push(noEmptySpace());
             result.push(fragment);
           } else {
-            result = join18(result, fragment);
+            result = join19(result, fragment);
           }
           if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
             return ["(", result, ")"];
@@ -61012,7 +61012,7 @@ var require_escodegen = __commonJS({
           var result, length, i, iz, itemFlags;
           length = expr["arguments"].length;
           itemFlags = flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0 ? E_TFT : E_TFF;
-          result = join18(
+          result = join19(
             "new",
             this.generateExpression(expr.callee, Precedence.New, itemFlags)
           );
@@ -61062,11 +61062,11 @@ var require_escodegen = __commonJS({
           var result, fragment, rightCharCode, leftSource, leftCharCode;
           fragment = this.generateExpression(expr.argument, Precedence.Unary, E_TTT);
           if (space === "") {
-            result = join18(expr.operator, fragment);
+            result = join19(expr.operator, fragment);
           } else {
             result = [expr.operator];
             if (expr.operator.length > 2) {
-              result = join18(result, fragment);
+              result = join19(result, fragment);
             } else {
               leftSource = toSourceNodeWhenNeeded(result).toString();
               leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
@@ -61089,7 +61089,7 @@ var require_escodegen = __commonJS({
             result = "yield";
           }
           if (expr.argument) {
-            result = join18(
+            result = join19(
               result,
               this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
             );
@@ -61097,7 +61097,7 @@ var require_escodegen = __commonJS({
           return parenthesize(result, Precedence.Yield, precedence);
         },
         AwaitExpression: function(expr, precedence, flags) {
-          var result = join18(
+          var result = join19(
             expr.all ? "await*" : "await",
             this.generateExpression(expr.argument, Precedence.Await, E_TTT)
           );
@@ -61180,11 +61180,11 @@ var require_escodegen = __commonJS({
           var result, fragment;
           result = ["class"];
           if (expr.id) {
-            result = join18(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
+            result = join19(result, this.generateExpression(expr.id, Precedence.Sequence, E_TTT));
           }
           if (expr.superClass) {
-            fragment = join18("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
-            result = join18(result, fragment);
+            fragment = join19("extends", this.generateExpression(expr.superClass, Precedence.Unary, E_TTT));
+            result = join19(result, fragment);
           }
           result.push(space);
           result.push(this.generateStatement(expr.body, S_TFFT));
@@ -61199,7 +61199,7 @@ var require_escodegen = __commonJS({
           }
           if (expr.kind === "get" || expr.kind === "set") {
             fragment = [
-              join18(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
+              join19(expr.kind, this.generatePropertyKey(expr.key, expr.computed)),
               this.generateFunctionBody(expr.value)
             ];
           } else {
@@ -61209,7 +61209,7 @@ var require_escodegen = __commonJS({
               this.generateFunctionBody(expr.value)
             ];
           }
-          return join18(result, fragment);
+          return join19(result, fragment);
         },
         Property: function(expr, precedence, flags) {
           if (expr.kind === "get" || expr.kind === "set") {
@@ -61404,7 +61404,7 @@ var require_escodegen = __commonJS({
               for (i = 0, iz = expr.blocks.length; i < iz; ++i) {
                 fragment = that.generateExpression(expr.blocks[i], Precedence.Sequence, E_TTT);
                 if (i > 0 || extra.moz.comprehensionExpressionStartsWithAssignment) {
-                  result = join18(result, fragment);
+                  result = join19(result, fragment);
                 } else {
                   result.push(fragment);
                 }
@@ -61412,13 +61412,13 @@ var require_escodegen = __commonJS({
             });
           }
           if (expr.filter) {
-            result = join18(result, "if" + space);
+            result = join19(result, "if" + space);
             fragment = this.generateExpression(expr.filter, Precedence.Sequence, E_TTT);
-            result = join18(result, ["(", fragment, ")"]);
+            result = join19(result, ["(", fragment, ")"]);
           }
           if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
             fragment = this.generateExpression(expr.body, Precedence.Assignment, E_TTT);
-            result = join18(result, fragment);
+            result = join19(result, fragment);
           }
           result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
           return result;
@@ -61434,8 +61434,8 @@ var require_escodegen = __commonJS({
           } else {
             fragment = this.generateExpression(expr.left, Precedence.Call, E_TTT);
           }
-          fragment = join18(fragment, expr.of ? "of" : "in");
-          fragment = join18(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
+          fragment = join19(fragment, expr.of ? "of" : "in");
+          fragment = join19(fragment, this.generateExpression(expr.right, Precedence.Sequence, E_TTT));
           return ["for" + space + "(", fragment, ")"];
         },
         SpreadElement: function(expr, precedence, flags) {
@@ -69092,12 +69092,12 @@ var require_path = __commonJS({
         return path12.__childCache || (path12.__childCache = /* @__PURE__ */ Object.create(null));
       }
       function getChildPath(path12, name) {
-        var cache = getChildCache(path12);
+        var cache2 = getChildCache(path12);
         var actualChildValue = path12.getValueProperty(name);
-        var childPath = cache[name];
-        if (!hasOwn.call(cache, name) || // Ensure consistency between cache and reality.
+        var childPath = cache2[name];
+        if (!hasOwn.call(cache2, name) || // Ensure consistency between cache and reality.
         childPath.value !== actualChildValue) {
-          childPath = cache[name] = new path12.constructor(actualChildValue, path12, name);
+          childPath = cache2[name] = new path12.constructor(actualChildValue, path12, name);
         }
         return childPath;
       }
@@ -69173,7 +69173,7 @@ var require_path = __commonJS({
         isNumber4.assert(start);
         isNumber4.assert(end);
         var moves = /* @__PURE__ */ Object.create(null);
-        var cache = getChildCache(path12);
+        var cache2 = getChildCache(path12);
         for (var i = start; i < end; ++i) {
           if (hasOwn.call(path12.value, i)) {
             var childPath = path12.get(i);
@@ -69183,17 +69183,17 @@ var require_path = __commonJS({
             var newIndex = i + offset;
             childPath.name = newIndex;
             moves[newIndex] = childPath;
-            delete cache[i];
+            delete cache2[i];
           }
         }
-        delete cache.length;
+        delete cache2.length;
         return function() {
           for (var newIndex2 in moves) {
             var childPath2 = moves[newIndex2];
             if (childPath2.name !== +newIndex2) {
               throw new Error("");
             }
-            cache[newIndex2] = childPath2;
+            cache2[newIndex2] = childPath2;
             path12.value[newIndex2] = childPath2.value;
           }
         };
@@ -69225,9 +69225,9 @@ var require_path = __commonJS({
       };
       Pp.pop = function pop() {
         isArray4.assert(this.value);
-        var cache = getChildCache(this);
-        delete cache[this.value.length - 1];
-        delete cache.length;
+        var cache2 = getChildCache(this);
+        delete cache2[this.value.length - 1];
+        delete cache2.length;
         return this.value.pop();
       };
       Pp.insertAt = function insertAt(index) {
@@ -76739,12 +76739,12 @@ var init_Cache = __esm({
       /**
        * @internal
        */
-      constructor(cache, browser, buildId, platform) {
-        this.#cache = cache;
+      constructor(cache2, browser, buildId, platform) {
+        this.#cache = cache2;
         this.browser = browser;
         this.buildId = buildId;
         this.platform = platform;
-        this.executablePath = cache.computeExecutablePath({
+        this.executablePath = cache2.computeExecutablePath({
           browser,
           buildId,
           platform
@@ -81914,8 +81914,8 @@ async function installWithProviders(options) {
   if (!options.platform) {
     throw new Error("Platform must be defined");
   }
-  const cache = new Cache(options.cacheDir);
-  const browserRoot = cache.browserRoot(options.browser);
+  const cache2 = new Cache(options.cacheDir);
+  const browserRoot = cache2.browserRoot(options.browser);
   const providers = [...options.providers || []];
   if (options.baseUrl) {
     providers.push(new DefaultProvider(options.baseUrl));
@@ -82017,8 +82017,8 @@ async function installUrl(url, options, provider) {
   }
   const fileName = decodeURIComponent(url.toString()).split("/").pop();
   assert2(fileName, `A malformed download URL was found: ${url}.`);
-  const cache = new Cache(options.cacheDir);
-  const browserRoot = cache.browserRoot(options.browser);
+  const cache2 = new Cache(options.cacheDir);
+  const browserRoot = cache2.browserRoot(options.browser);
   const archivePath = path8.join(browserRoot, `${options.buildId}-${fileName}`);
   if (!existsSync(browserRoot)) {
     await mkdir2(browserRoot, { recursive: true });
@@ -82033,16 +82033,16 @@ async function installUrl(url, options, provider) {
     debugTimeEnd("download");
     return archivePath;
   }
-  const outputPath = cache.installationDir(options.browser, options.platform, options.buildId);
+  const outputPath = cache2.installationDir(options.browser, options.platform, options.buildId);
   const relativeExecutablePath6 = await provider.getExecutablePath({
     browser: options.browser,
     buildId: options.buildId,
     platform: options.platform
   });
   debugInstall(`Using executable path from provider: ${relativeExecutablePath6}`);
-  const installedBrowser = new InstalledBrowser(cache, options.browser, options.buildId, options.platform);
+  const installedBrowser = new InstalledBrowser(cache2, options.browser, options.buildId, options.platform);
   if (!(provider instanceof DefaultProvider)) {
-    cache.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
+    cache2.writeExecutablePath(options.browser, options.platform, options.buildId, relativeExecutablePath6);
   }
   try {
     if (existsSync(outputPath)) {
@@ -87414,8 +87414,8 @@ var init_CLI = __esm({
               console.log("Cancelled.");
               return;
             }
-            const cache = new Cache(cacheDir);
-            cache.clear();
+            const cache2 = new Cache(cacheDir);
+            cache2.clear();
             console.log(`${cacheDir} cleared.`);
           });
         }).command("list", "List all installed browsers in the cache directory", (yargs2) => {
@@ -87426,8 +87426,8 @@ var init_CLI = __esm({
           return this.#definePathParameter(yargs2);
         }, async (args) => {
           const cacheDir = args.path ?? this.#cachePath;
-          const cache = new Cache(cacheDir);
-          const browsers = cache.getInstalledBrowsers();
+          const cache2 = new Cache(cacheDir);
+          const browsers = cache2.getInstalledBrowsers();
           for (const browser of browsers) {
             console.log(`${browser.browser}@${browser.buildId} (${browser.platform}) ${browser.executablePath}`);
           }
@@ -87597,9 +87597,9 @@ async function getConnectionTransport(options) {
       throw new Error("Could not detect required browser platform");
     }
     const { convertPuppeteerChannelToBrowsersChannel: convertPuppeteerChannelToBrowsersChannel2 } = await Promise.resolve().then(() => (init_LaunchOptions(), LaunchOptions_exports));
-    const { join: join18 } = await import("node:path");
+    const { join: join19 } = await import("node:path");
     const userDataDir = resolveDefaultUserDataDir3(Browser4.CHROME, platform, convertPuppeteerChannelToBrowsersChannel2(options.channel));
-    const portPath = join18(userDataDir, "DevToolsActivePort");
+    const portPath = join19(userDataDir, "DevToolsActivePort");
     try {
       const fileContent = await environment.value.fs.promises.readFile(portPath, "ascii");
       const [rawPort, rawPath] = fileContent.split("\n").map((line) => {
@@ -89417,12 +89417,13 @@ var init_puppeteer_core = __esm({
 
 // src/services/renderOrchestrator.ts
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync10,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync11,
   rmSync as rmSync3,
   readFileSync as readFileSync10,
-  readdirSync as readdirSync6,
-  writeFileSync as writeFileSync4,
+  readdirSync as readdirSync8,
+  statSync as statSync7,
+  writeFileSync as writeFileSync5,
   copyFileSync as copyFileSync2,
   appendFileSync
 } from "fs";
@@ -98747,7 +98748,8 @@ function resolveConfig(overrides) {
       DEFAULT_CONFIG.renderReadyTimeout
     ),
     verifyRuntime: env2("PRODUCER_VERIFY_HYPERFRAME_RUNTIME") !== "false",
-    runtimeManifestPath: env2("PRODUCER_HYPERFRAME_MANIFEST_PATH")
+    runtimeManifestPath: env2("PRODUCER_HYPERFRAME_MANIFEST_PATH"),
+    extractCacheDir: env2("HYPERFRAMES_EXTRACT_CACHE_DIR")
   };
   const cleanEnv = Object.fromEntries(Object.entries(fromEnv).filter(([, v]) => v !== void 0));
   return {
@@ -99903,6 +99905,7 @@ var mediaRules = [
 
 // ../core/src/lint/rules/gsap.ts
 var META_GSAP_KEYS = /* @__PURE__ */ new Set(["duration", "ease", "repeat", "yoyo", "overwrite", "delay"]);
+var SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
 function countClassUsage(tags) {
   const counts = /* @__PURE__ */ new Map();
   for (const tag of tags) {
@@ -99943,6 +99946,7 @@ function extractGsapWindows(script) {
       position: animation.position,
       end: animation.position + meta.effectiveDuration,
       properties: meta.properties.length > 0 ? meta.properties : Object.keys(animation.properties),
+      propertyValues: meta.propertyValues,
       overwriteAuto: meta.overwriteAuto,
       method: match2[1] ?? "to",
       raw: raw2
@@ -99951,8 +99955,14 @@ function extractGsapWindows(script) {
   return windows;
 }
 function parseGsapWindowMeta(method, argsStr) {
+  const emptyMeta = {
+    effectiveDuration: 0,
+    properties: [],
+    propertyValues: {},
+    overwriteAuto: false
+  };
   const selectorMatch = argsStr.match(/^\s*["']([^"']+)["']\s*,/);
-  if (!selectorMatch) return { effectiveDuration: 0, properties: [], overwriteAuto: false };
+  if (!selectorMatch) return emptyMeta;
   const afterSelector = argsStr.slice(selectorMatch[0].length);
   let properties = {};
   let fromProperties = {};
@@ -99990,6 +100000,7 @@ function parseGsapWindowMeta(method, argsStr) {
   return {
     effectiveDuration: method === "set" ? 0 : effectiveDuration,
     properties: [...propertyNames],
+    propertyValues: properties,
     overwriteAuto
   };
 }
@@ -100037,6 +100048,94 @@ function stringValue(value) {
   if (typeof value === "number") return String(value);
   return null;
 }
+function zeroValue(value) {
+  if (typeof value === "number") return value === 0;
+  if (typeof value !== "string") return false;
+  return Number(value.trim()) === 0;
+}
+function isHiddenGsapState(values) {
+  const visibility = stringValue(values.visibility)?.toLowerCase();
+  const display = stringValue(values.display)?.toLowerCase();
+  return zeroValue(values.opacity) || zeroValue(values.autoAlpha) || visibility === "hidden" || display === "none";
+}
+function isSceneBoundaryExit(win) {
+  if (win.end <= win.position) return false;
+  if (win.method !== "to" && win.method !== "fromTo") return false;
+  return isHiddenGsapState(win.propertyValues);
+}
+function isHardKillSet(win, selector, boundary) {
+  return win.method === "set" && win.targetSelector === selector && Math.abs(win.position - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS && isHiddenGsapState(win.propertyValues);
+}
+function hiddenStateLiteral(values) {
+  if (zeroValue(values.autoAlpha)) return "{ autoAlpha: 0 }";
+  if (zeroValue(values.opacity)) return "{ opacity: 0 }";
+  if (stringValue(values.visibility)?.toLowerCase() === "hidden") return '{ visibility: "hidden" }';
+  if (stringValue(values.display)?.toLowerCase() === "none") return '{ display: "none" }';
+  return "{ opacity: 0 }";
+}
+function findTagEnd(source2, tag) {
+  const escapedTagName = tag.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`<\\/?${escapedTagName}\\b[^>]*>`, "gi");
+  pattern.lastIndex = tag.index;
+  let depth = 0;
+  let match2;
+  while ((match2 = pattern.exec(source2)) !== null) {
+    const raw2 = match2[0];
+    const isClosing = /^<\s*\//.test(raw2);
+    const isSelfClosing = /\/\s*>$/.test(raw2);
+    if (!isClosing && !isSelfClosing) depth += 1;
+    if (isClosing) depth -= 1;
+    if (depth === 0) return pattern.lastIndex;
+  }
+  return source2.length;
+}
+function collectCompositionRanges(source2, tags) {
+  return tags.map((tag) => {
+    const id = readAttr(tag.raw, "data-composition-id");
+    if (!id) return null;
+    return {
+      id,
+      start: tag.index,
+      end: findTagEnd(source2, tag)
+    };
+  }).filter((range) => range !== null);
+}
+function findContainingCompositionId(tag, ranges) {
+  let match2 = null;
+  for (const range of ranges) {
+    if (tag.index < range.start || tag.index >= range.end) continue;
+    if (!match2 || range.start >= match2.start) match2 = range;
+  }
+  return match2?.id || null;
+}
+function collectClipStartBoundariesByComposition(source2, tags) {
+  const ranges = collectCompositionRanges(source2, tags);
+  const boundaries = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    const classAttr = readAttr(tag.raw, "class") || "";
+    const classes = classAttr.split(/\s+/).filter(Boolean);
+    if (!classes.includes("clip")) continue;
+    const compositionId = findContainingCompositionId(tag, ranges);
+    if (!compositionId) continue;
+    const start = numberValue(readAttr(tag.raw, "data-start") ?? void 0);
+    if (start == null || start <= 0) continue;
+    const compositionBoundaries = boundaries.get(compositionId) ?? /* @__PURE__ */ new Set();
+    compositionBoundaries.add(start);
+    boundaries.set(compositionId, compositionBoundaries);
+  }
+  return new Map(
+    [...boundaries.entries()].map(([compositionId, values]) => [
+      compositionId,
+      [...values].sort((a, b) => a - b)
+    ])
+  );
+}
+function findMatchingSceneBoundary(time, boundaries) {
+  for (const boundary of boundaries) {
+    if (Math.abs(time - boundary) <= SCENE_BOUNDARY_EPSILON_SECONDS) return boundary;
+  }
+  return null;
+}
 function isSuspiciousGlobalSelector(selector) {
   if (!selector) return false;
   if (selector.includes("[data-composition-id=")) return false;
@@ -100077,7 +100176,7 @@ function cssTransformToGsapProps(cssTransform) {
 }
 var gsapRules = [
   // overlapping_gsap_tweens + gsap_animates_clip_element + unscoped_gsap_selector
-  ({ tags, scripts, rootCompositionId }) => {
+  ({ source: source2, tags, scripts, rootCompositionId }) => {
     const findings = [];
     const clipIds = /* @__PURE__ */ new Map();
     const clipClasses = /* @__PURE__ */ new Map();
@@ -100097,9 +100196,11 @@ var gsapRules = [
       }
     }
     const classUsage = countClassUsage(tags);
+    const clipStartBoundariesByComposition = collectClipStartBoundariesByComposition(source2, tags);
     for (const script of scripts) {
       const localTimelineCompId = readRegisteredTimelineCompositionId(script.content);
       const gsapWindows = extractGsapWindows(script.content);
+      const clipStartBoundaries = clipStartBoundariesByComposition.get(localTimelineCompId || rootCompositionId || "") ?? [];
       for (let i = 0; i < gsapWindows.length; i++) {
         const left2 = gsapWindows[i];
         if (!left2) continue;
@@ -100128,6 +100229,25 @@ ${right2.raw}`)
           });
         }
       }
+      if (clipStartBoundaries.length > 0) {
+        for (const win of gsapWindows) {
+          if (!isSceneBoundaryExit(win)) continue;
+          const boundary = findMatchingSceneBoundary(win.end, clipStartBoundaries);
+          if (boundary == null) continue;
+          const hasHardKill = gsapWindows.some(
+            (candidate) => isHardKillSet(candidate, win.targetSelector, boundary)
+          );
+          if (hasHardKill) continue;
+          findings.push({
+            code: "gsap_exit_missing_hard_kill",
+            severity: "warning",
+            message: `GSAP exit on "${win.targetSelector}" ends at the ${boundary.toFixed(2)}s clip start boundary without a matching tl.set hard kill. Non-linear seeking can land after the fade and leave stale visibility state.`,
+            selector: win.targetSelector,
+            fixHint: `Add \`tl.set("${win.targetSelector}", ${hiddenStateLiteral(win.propertyValues)}, ${boundary.toFixed(2)})\` after the exit tween.`,
+            snippet: truncateSnippet(win.raw)
+          });
+        }
+      }
       for (const win of gsapWindows) {
         const sel = win.targetSelector;
         const clipInfo = clipIds.get(sel) || clipClasses.get(sel);
@@ -102442,8 +102562,8 @@ Process error: ${err.message}`;
 
 // ../engine/src/services/videoFrameExtractor.ts
 import { spawn as spawn8 } from "child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync4, rmSync } from "fs";
-import { isAbsolute as isAbsolute2, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync5, rmSync } from "fs";
+import { isAbsolute as isAbsolute2, join as join9 } from "path";
 
 // ../engine/src/utils/ffprobe.ts
 import { spawn as spawn7 } from "child_process";
@@ -102773,10 +102893,115 @@ function isHttpUrl(path12) {
   return path12.startsWith("http://") || path12.startsWith("https://");
 }
 
+// ../engine/src/utils/htmlTemplate.ts
+function parseHTMLContent(html) {
+  const trimmed = html.trimStart().toLowerCase();
+  if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html")) {
+    return parseHTML(html).document;
+  }
+  return parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`).document;
+}
+function getSingleMeaningfulChild(container) {
+  let child = null;
+  for (const node of Array.from(container.childNodes)) {
+    if (node.nodeType === 3 && !(node.textContent || "").trim()) continue;
+    if (node.nodeType === 8) continue;
+    if (node.nodeType !== 1) return null;
+    if (child) return null;
+    child = node;
+  }
+  return child;
+}
+function unwrapTemplate(html) {
+  const lowered = html.toLowerCase();
+  if (!lowered.includes("<template") || !lowered.includes("</template>")) {
+    return html;
+  }
+  const { body } = parseHTMLContent(html);
+  if (!body) return html;
+  let container = body;
+  const bodyWrapper = getSingleMeaningfulChild(container);
+  if (bodyWrapper?.tagName === "BODY") {
+    container = bodyWrapper;
+  }
+  const template = getSingleMeaningfulChild(container);
+  if (template?.tagName !== "TEMPLATE") {
+    return html;
+  }
+  return template.innerHTML ?? html;
+}
+
+// ../engine/src/services/extractionCache.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync4, statSync as statSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join8 } from "node:path";
+var FRAME_FILENAME_PREFIX = "frame_";
+var COMPLETE_SENTINEL = ".hf-complete";
+var SCHEMA_PREFIX = "hfcache-v2-";
+var KEY_HEX_CHARS = 16;
+function readKeyStat(videoPath) {
+  try {
+    const stat = statSync5(videoPath);
+    return { mtimeMs: Math.floor(stat.mtimeMs), size: stat.size };
+  } catch {
+    return null;
+  }
+}
+function canonicalKeyBlob(input2) {
+  const durationForKey = Number.isFinite(input2.duration) ? input2.duration : -1;
+  return JSON.stringify({
+    p: input2.videoPath,
+    m: input2.mtimeMs,
+    s: input2.size,
+    ms: input2.mediaStart,
+    d: durationForKey,
+    f: input2.fps,
+    fmt: input2.format
+  });
+}
+function computeCacheKey(input2) {
+  return createHash2("sha256").update(canonicalKeyBlob(input2)).digest("hex");
+}
+function cacheEntryDirName(keyHash) {
+  return SCHEMA_PREFIX + keyHash.slice(0, KEY_HEX_CHARS);
+}
+function lookupCacheEntry(rootDir, input2) {
+  const keyHash = computeCacheKey(input2);
+  const dir = join8(rootDir, cacheEntryDirName(keyHash));
+  const complete = existsSync8(join8(dir, COMPLETE_SENTINEL));
+  return { entry: { dir, keyHash }, hit: complete };
+}
+function ensureCacheEntryDir(entry) {
+  mkdirSync5(entry.dir, { recursive: true });
+}
+function markCacheEntryComplete(entry) {
+  writeFileSync3(join8(entry.dir, COMPLETE_SENTINEL), "", "utf-8");
+}
+function rehydrateCacheEntry(entry, options) {
+  const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${options.format}`;
+  const framePaths = /* @__PURE__ */ new Map();
+  const suffix = `.${options.format}`;
+  const files = readdirSync4(entry.dir).filter((f) => f.startsWith(FRAME_FILENAME_PREFIX) && f.endsWith(suffix)).sort();
+  files.forEach((file, idx) => {
+    framePaths.set(idx, join8(entry.dir, file));
+  });
+  return {
+    videoId: options.videoId,
+    srcPath: options.srcPath,
+    outputDir: entry.dir,
+    framePattern,
+    fps: options.fps,
+    totalFrames: framePaths.size,
+    metadata: options.metadata,
+    framePaths
+  };
+}
+
 // ../engine/src/services/videoFrameExtractor.ts
 function parseVideoElements(html) {
   const videos = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const videoEls = document2.querySelectorAll("video[src]");
   let autoIdCounter = 0;
   for (const el of videoEls) {
@@ -102813,7 +103038,7 @@ function parseVideoElements(html) {
 }
 function parseImageElements(html) {
   const images = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const imgEls = document2.querySelectorAll("img[src]");
   let autoIdCounter = 0;
   for (const el of imgEls) {
@@ -102839,14 +103064,14 @@ function parseImageElements(html) {
   }
   return images;
 }
-async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config2) {
+async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config2, outputDirOverride) {
   const ffmpegProcessTimeout = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { fps, outputDir, quality = 95, format: format3 = "jpg" } = options;
-  const videoOutputDir = join8(outputDir, videoId);
-  if (!existsSync8(videoOutputDir)) mkdirSync5(videoOutputDir, { recursive: true });
+  const videoOutputDir = outputDirOverride ?? join9(outputDir, videoId);
+  if (!existsSync9(videoOutputDir)) mkdirSync6(videoOutputDir, { recursive: true });
   const metadata = await extractMediaMetadata(videoPath);
-  const framePattern = `frame_%05d.${format3}`;
-  const outputPattern = join8(videoOutputDir, framePattern);
+  const framePattern = `${FRAME_FILENAME_PREFIX}%05d.${format3}`;
+  const outputPattern = join9(videoOutputDir, framePattern);
   const isHdr = isHdrColorSpace(metadata.colorSpace);
   const isMacOS = process.platform === "darwin";
   const args = [];
@@ -102894,9 +103119,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
         return;
       }
       const framePaths = /* @__PURE__ */ new Map();
-      const files = readdirSync4(videoOutputDir).filter((f) => f.startsWith("frame_") && f.endsWith(`.${format3}`)).sort();
+      const files = readdirSync5(videoOutputDir).filter((f) => f.startsWith(FRAME_FILENAME_PREFIX) && f.endsWith(`.${format3}`)).sort();
       files.forEach((file, index) => {
-        framePaths.set(index, join8(videoOutputDir, file));
+        framePaths.set(index, join9(videoOutputDir, file));
       });
       resolve14({
         videoId,
@@ -102920,12 +103145,19 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     });
   });
 }
-async function convertSdrToHdr(inputPath, outputPath, targetTransfer, signal, config2) {
+async function convertSdrToHdr(inputPath, outputPath, startTime, duration, targetTransfer, signal, config2) {
+  if (duration <= 0) {
+    throw new Error(`convertSdrToHdr: duration must be positive (got ${duration})`);
+  }
   const timeout2 = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const colorTrc = targetTransfer === "pq" ? "smpte2084" : "arib-std-b67";
   const args = [
+    "-ss",
+    String(startTime),
     "-i",
     inputPath,
+    "-t",
+    String(duration),
     "-vf",
     "colorspace=all=bt2020:iall=bt709:range=tv",
     "-color_primaries",
@@ -102952,6 +103184,11 @@ async function convertSdrToHdr(inputPath, outputPath, targetTransfer, signal, co
     );
   }
 }
+function resolveSegmentDuration(requested, mediaStart, metadata) {
+  if (Number.isFinite(requested) && requested > 0) return requested;
+  const sourceRemaining = metadata.durationSeconds - mediaStart;
+  return sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+}
 async function convertVfrToCfr(inputPath, outputPath, targetFps, startTime, duration, signal, config2) {
   const timeout2 = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const args = [
@@ -102988,21 +103225,34 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
   const extracted = [];
   const errors = [];
   let totalFramesExtracted = 0;
+  const breakdown = {
+    resolveMs: 0,
+    hdrProbeMs: 0,
+    hdrPreflightMs: 0,
+    hdrPreflightCount: 0,
+    vfrProbeMs: 0,
+    vfrPreflightMs: 0,
+    vfrPreflightCount: 0,
+    extractMs: 0,
+    cacheHits: 0,
+    cacheMisses: 0
+  };
+  const phase1Start = Date.now();
   const resolvedVideos = [];
   for (const video of videos) {
     if (signal?.aborted) break;
     try {
       let videoPath = video.src;
       if (!isAbsolute2(videoPath) && !isHttpUrl(videoPath)) {
-        const fromCompiled = compiledDir ? join8(compiledDir, videoPath) : null;
-        videoPath = fromCompiled && existsSync8(fromCompiled) ? fromCompiled : join8(baseDir, videoPath);
+        const fromCompiled = compiledDir ? join9(compiledDir, videoPath) : null;
+        videoPath = fromCompiled && existsSync9(fromCompiled) ? fromCompiled : join9(baseDir, videoPath);
       }
       if (isHttpUrl(videoPath)) {
-        const downloadDir = join8(options.outputDir, "_downloads");
-        mkdirSync5(downloadDir, { recursive: true });
+        const downloadDir = join9(options.outputDir, "_downloads");
+        mkdirSync6(downloadDir, { recursive: true });
         videoPath = await downloadToTemp(videoPath, downloadDir);
       }
-      if (!existsSync8(videoPath)) {
+      if (!existsSync9(videoPath)) {
         errors.push({ videoId: video.id, error: `Video file not found: ${videoPath}` });
         continue;
       }
@@ -103011,27 +103261,66 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       errors.push({ videoId: video.id, error: err instanceof Error ? err.message : String(err) });
     }
   }
-  const videoColorSpaces = await Promise.all(
-    resolvedVideos.map(async ({ videoPath }) => {
-      const metadata = await extractMediaMetadata(videoPath);
-      return metadata.colorSpace;
-    })
+  breakdown.resolveMs = Date.now() - phase1Start;
+  const cacheKeyInputs = resolvedVideos.map(({ video, videoPath }) => {
+    const stat = readKeyStat(videoPath);
+    if (!stat) return null;
+    return {
+      videoPath,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      mediaStart: video.mediaStart,
+      start: video.start,
+      end: video.end
+    };
+  });
+  const phase2ProbeStart = Date.now();
+  const videoMetadata = await Promise.all(
+    resolvedVideos.map(({ videoPath }) => extractMediaMetadata(videoPath))
   );
+  const videoColorSpaces = videoMetadata.map((m) => m.colorSpace);
+  breakdown.hdrProbeMs = Date.now() - phase2ProbeStart;
+  const hdrPreflightStart = Date.now();
   const hdrInfo = analyzeCompositionHdr(videoColorSpaces);
+  const hdrSkippedIndices = /* @__PURE__ */ new Set();
   if (hdrInfo.hasHdr && hdrInfo.dominantTransfer) {
     const targetTransfer = hdrInfo.dominantTransfer;
-    const convertDir = join8(options.outputDir, "_hdr_normalized");
-    mkdirSync5(convertDir, { recursive: true });
+    const convertDir = join9(options.outputDir, "_hdr_normalized");
+    mkdirSync6(convertDir, { recursive: true });
     for (let i = 0; i < resolvedVideos.length; i++) {
       if (signal?.aborted) break;
       const cs = videoColorSpaces[i] ?? null;
       if (!isHdrColorSpace(cs)) {
         const entry = resolvedVideos[i];
-        if (!entry) continue;
-        const convertedPath = join8(convertDir, `${entry.video.id}_hdr.mp4`);
+        const metadata = videoMetadata[i];
+        if (!entry || !metadata) continue;
+        if (entry.video.mediaStart >= metadata.durationSeconds) {
+          errors.push({
+            videoId: entry.video.id,
+            error: `SDR\u2192HDR conversion skipped: mediaStart (${entry.video.mediaStart}s) \u2265 source duration (${metadata.durationSeconds}s)`
+          });
+          hdrSkippedIndices.add(i);
+          continue;
+        }
+        let segDuration = entry.video.end - entry.video.start;
+        if (!Number.isFinite(segDuration) || segDuration <= 0) {
+          const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
+          segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
+        }
+        const convertedPath = join9(convertDir, `${entry.video.id}_hdr.mp4`);
         try {
-          await convertSdrToHdr(entry.videoPath, convertedPath, targetTransfer, signal, config2);
+          await convertSdrToHdr(
+            entry.videoPath,
+            convertedPath,
+            entry.video.mediaStart,
+            segDuration,
+            targetTransfer,
+            signal,
+            config2
+          );
           entry.videoPath = convertedPath;
+          entry.video = { ...entry.video, mediaStart: 0 };
+          breakdown.hdrPreflightCount += 1;
         } catch (err) {
           errors.push({
             videoId: entry.video.id,
@@ -103041,20 +103330,34 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       }
     }
   }
-  const vfrNormDir = join8(options.outputDir, "_vfr_normalized");
+  breakdown.hdrPreflightMs = Date.now() - hdrPreflightStart;
+  if (hdrSkippedIndices.size > 0) {
+    for (let i = resolvedVideos.length - 1; i >= 0; i--) {
+      if (hdrSkippedIndices.has(i)) {
+        resolvedVideos.splice(i, 1);
+        videoMetadata.splice(i, 1);
+        videoColorSpaces.splice(i, 1);
+        cacheKeyInputs.splice(i, 1);
+      }
+    }
+  }
+  const vfrPreflightStart = Date.now();
+  const vfrNormDir = join9(options.outputDir, "_vfr_normalized");
   for (let i = 0; i < resolvedVideos.length; i++) {
     if (signal?.aborted) break;
     const entry = resolvedVideos[i];
     if (!entry) continue;
+    const vfrProbeStart = Date.now();
     const metadata = await extractMediaMetadata(entry.videoPath);
+    breakdown.vfrProbeMs += Date.now() - vfrProbeStart;
     if (!metadata.isVFR) continue;
     let segDuration = entry.video.end - entry.video.start;
     if (!Number.isFinite(segDuration) || segDuration <= 0) {
       const sourceRemaining = metadata.durationSeconds - entry.video.mediaStart;
       segDuration = sourceRemaining > 0 ? sourceRemaining : metadata.durationSeconds;
     }
-    mkdirSync5(vfrNormDir, { recursive: true });
-    const normalizedPath = join8(vfrNormDir, `${entry.video.id}_cfr.mp4`);
+    mkdirSync6(vfrNormDir, { recursive: true });
+    const normalizedPath = join9(vfrNormDir, `${entry.video.id}_cfr.mp4`);
     try {
       await convertVfrToCfr(
         entry.videoPath,
@@ -103067,6 +103370,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       );
       entry.videoPath = normalizedPath;
       entry.video = { ...entry.video, mediaStart: 0 };
+      breakdown.vfrPreflightCount += 1;
     } catch (err) {
       errors.push({
         videoId: entry.video.id,
@@ -103074,19 +103378,72 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       });
     }
   }
+  breakdown.vfrPreflightMs = Date.now() - vfrPreflightStart;
+  const phase3Start = Date.now();
+  const cacheRootDir = config2?.extractCacheDir;
+  const cacheFormat = options.format ?? "jpg";
+  async function tryCachedExtract(video, videoPath, videoDuration, i) {
+    if (!cacheRootDir) return null;
+    const keyInput = cacheKeyInputs[i];
+    const probedMeta = videoMetadata[i];
+    if (!keyInput || !probedMeta) return null;
+    const keyDuration = resolveSegmentDuration(
+      keyInput.end - keyInput.start,
+      keyInput.mediaStart,
+      probedMeta
+    );
+    const lookup = lookupCacheEntry(cacheRootDir, {
+      videoPath: keyInput.videoPath,
+      mtimeMs: keyInput.mtimeMs,
+      size: keyInput.size,
+      mediaStart: keyInput.mediaStart,
+      duration: keyDuration,
+      fps: options.fps,
+      format: cacheFormat
+    });
+    if (lookup.hit) {
+      breakdown.cacheHits += 1;
+      const rehydrated = rehydrateCacheEntry(lookup.entry, {
+        videoId: video.id,
+        srcPath: keyInput.videoPath,
+        fps: options.fps,
+        format: cacheFormat,
+        metadata: probedMeta
+      });
+      return { ...rehydrated, ownedByLookup: true };
+    }
+    breakdown.cacheMisses += 1;
+    ensureCacheEntryDir(lookup.entry);
+    const result = await extractVideoFramesRange(
+      videoPath,
+      video.id,
+      video.mediaStart,
+      videoDuration,
+      options,
+      signal,
+      config2,
+      lookup.entry.dir
+    );
+    markCacheEntryComplete(lookup.entry);
+    return { ...result, ownedByLookup: true };
+  }
   const results = await Promise.all(
-    resolvedVideos.map(async ({ video, videoPath }) => {
+    resolvedVideos.map(async ({ video, videoPath }, i) => {
       if (signal?.aborted) {
         throw new Error("Video frame extraction cancelled");
       }
       try {
-        let videoDuration = video.end - video.start;
-        if (!Number.isFinite(videoDuration) || videoDuration <= 0) {
-          const metadata = await extractMediaMetadata(videoPath);
-          const sourceDuration = metadata.durationSeconds - video.mediaStart;
-          videoDuration = sourceDuration > 0 ? sourceDuration : metadata.durationSeconds;
+        const probedMeta = videoMetadata[i] ?? await extractMediaMetadata(videoPath);
+        const videoDuration = resolveSegmentDuration(
+          video.end - video.start,
+          video.mediaStart,
+          probedMeta
+        );
+        if (video.end - video.start !== videoDuration) {
           video.end = video.start + videoDuration;
         }
+        const cached = await tryCachedExtract(video, videoPath, videoDuration, i);
+        if (cached) return { result: cached };
         const result = await extractVideoFramesRange(
           videoPath,
           video.id,
@@ -103107,6 +103464,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
       }
     })
   );
+  breakdown.extractMs = Date.now() - phase3Start;
   for (const item of results) {
     if ("error" in item && item.error) {
       errors.push(item.error);
@@ -103120,7 +103478,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2,
     extracted,
     errors,
     totalFramesExtracted,
-    durationMs: Date.now() - startTime
+    durationMs: Date.now() - startTime,
+    phaseBreakdown: breakdown
   };
 }
 function getFrameAtTime(extracted, globalTime, videoStart) {
@@ -103213,7 +103572,8 @@ var FrameLookupTable = class {
   }
   cleanup() {
     for (const video of this.videos.values()) {
-      if (existsSync8(video.extracted.outputDir)) {
+      if (video.extracted.ownedByLookup) continue;
+      if (existsSync9(video.extracted.outputDir)) {
         rmSync(video.extracted.outputDir, { recursive: true, force: true });
       }
     }
@@ -103236,23 +103596,23 @@ function createFrameLookupTable(videos, extracted) {
 // ../engine/src/services/videoFrameInjector.ts
 import { promises as fs7 } from "fs";
 function createFrameDataUriCache(cacheLimit) {
-  const cache = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
   function remember(framePath, dataUri) {
-    if (cache.has(framePath)) {
-      cache.delete(framePath);
+    if (cache2.has(framePath)) {
+      cache2.delete(framePath);
     }
-    cache.set(framePath, dataUri);
-    if (cache.size > cacheLimit) {
-      const oldestKey = cache.keys().next().value;
+    cache2.set(framePath, dataUri);
+    if (cache2.size > cacheLimit) {
+      const oldestKey = cache2.keys().next().value;
       if (oldestKey) {
-        cache.delete(oldestKey);
+        cache2.delete(oldestKey);
       }
     }
     return dataUri;
   }
   async function get(framePath) {
-    const cached = cache.get(framePath);
+    const cached = cache2.get(framePath);
     if (cached) {
       remember(framePath, cached);
       return cached;
@@ -103456,11 +103816,11 @@ async function queryElementStacking(page, nativeHdrIds) {
 }
 
 // ../engine/src/services/audioMixer.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, rmSync as rmSync2 } from "fs";
-import { isAbsolute as isAbsolute3, join as join9, dirname as dirname7 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, rmSync as rmSync2 } from "fs";
+import { isAbsolute as isAbsolute3, join as join10, dirname as dirname7 } from "path";
 function parseAudioElements(html) {
   const elements = [];
-  const { document: document2 } = parseHTML(html);
+  const { document: document2 } = parseHTML(unwrapTemplate(html));
   const audioEls = document2.querySelectorAll("audio[id][src]");
   for (const el of audioEls) {
     const id = el.getAttribute("id");
@@ -103508,7 +103868,7 @@ function parseAudioElements(html) {
 async function extractAudioFromVideo(videoPath, outputPath, options, signal, config2) {
   const ffmpegProcessTimeout = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = ["-i", videoPath];
   if (options?.startTime !== void 0) args.push("-ss", String(options.startTime));
   if (options?.duration !== void 0) args.push("-t", String(options.duration));
@@ -103535,7 +103895,7 @@ async function extractAudioFromVideo(videoPath, outputPath, options, signal, con
 async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, signal, config2) {
   const ffmpegProcessTimeout = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-ss",
     String(mediaStart),
@@ -103571,7 +103931,7 @@ async function prepareAudioTrack(srcPath, outputPath, mediaStart, duration, sign
 async function generateSilence(outputPath, duration, signal, config2) {
   const ffmpegProcessTimeout = config2?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const outputDir = dirname7(outputPath);
-  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const args = [
     "-f",
     "lavfi",
@@ -103614,7 +103974,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config2
     };
   }
   const outputDir = dirname7(outputPath);
-  if (!existsSync9(outputDir)) mkdirSync6(outputDir, { recursive: true });
+  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
   const inputs = [];
   const filterParts = [];
   tracks.forEach((track, i) => {
@@ -103675,7 +104035,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
-  if (!existsSync9(workDir)) mkdirSync6(workDir, { recursive: true });
+  if (!existsSync10(workDir)) mkdirSync7(workDir, { recursive: true });
   await Promise.all(
     elements.map(async (element) => {
       if (signal?.aborted) {
@@ -103685,8 +104045,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!isAbsolute3(srcPath) && !isHttpUrl(srcPath)) {
-          const fromCompiled = compiledDir ? join9(compiledDir, srcPath) : null;
-          srcPath = fromCompiled && existsSync9(fromCompiled) ? fromCompiled : join9(baseDir, srcPath);
+          const fromCompiled = compiledDir ? join10(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync10(fromCompiled) ? fromCompiled : join10(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -103698,7 +104058,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
             return;
           }
         }
-        if (!existsSync9(srcPath)) {
+        if (!existsSync10(srcPath)) {
           errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
@@ -103709,7 +104069,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
         }
         let audioSrcPath = srcPath;
         if (element.type === "video") {
-          const extractedPath = join9(workDir, `${element.id}-extracted.wav`);
+          const extractedPath = join10(workDir, `${element.id}-extracted.wav`);
           const extractResult = await extractAudioFromVideo(
             srcPath,
             extractedPath,
@@ -103726,7 +104086,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
           audioSrcPath = extractedPath;
         } else {
-          const trimmedPath = join9(workDir, `${element.id}-trimmed.wav`);
+          const trimmedPath = join10(workDir, `${element.id}-trimmed.wav`);
           const prepResult = await prepareAudioTrack(
             srcPath,
             trimmedPath,
@@ -103769,9 +104129,9 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 
 // ../engine/src/services/parallelCoordinator.ts
 import { cpus, freemem, totalmem } from "os";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, rename as rename2 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var MEMORY_PER_WORKER_MB = 256;
 var MIN_WORKERS = 1;
 var ABSOLUTE_MAX_WORKERS = 10;
@@ -103819,7 +104179,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
       workerId: i,
       startFrame,
       endFrame,
-      outputDir: join10(workDir, `worker-${i}`)
+      outputDir: join11(workDir, `worker-${i}`)
     });
   }
   return tasks;
@@ -103827,7 +104187,7 @@ function distributeFrames(totalFrames, workerCount, workDir) {
 async function executeWorkerTask(task, serverUrl, captureOptions, createBeforeCaptureHook, signal, onFrameCaptured, onFrameBuffer, config2) {
   const startTime = Date.now();
   let framesCaptured = 0;
-  if (!existsSync10(task.outputDir)) mkdirSync7(task.outputDir, { recursive: true });
+  if (!existsSync11(task.outputDir)) mkdirSync8(task.outputDir, { recursive: true });
   let session = null;
   let perf;
   try {
@@ -103917,17 +104277,17 @@ async function executeParallelCapture(serverUrl, workDir, tasks, captureOptions,
   return results;
 }
 async function mergeWorkerFrames(workDir, tasks, outputDir) {
-  if (!existsSync10(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  if (!existsSync11(outputDir)) mkdirSync8(outputDir, { recursive: true });
   let totalFrames = 0;
   const sortedTasks = [...tasks].sort((a, b) => a.startFrame - b.startFrame);
   for (const task of sortedTasks) {
-    if (!existsSync10(task.outputDir)) {
+    if (!existsSync11(task.outputDir)) {
       continue;
     }
-    const files = readdirSync5(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
+    const files = readdirSync6(task.outputDir).filter((f) => f.startsWith("frame_") && (f.endsWith(".jpg") || f.endsWith(".png"))).sort();
     const copyTasks = files.map(async (file) => {
-      const sourcePath = join10(task.outputDir, file);
-      const targetPath = join10(outputDir, file);
+      const sourcePath = join11(task.outputDir, file);
+      const targetPath = join11(outputDir, file);
       try {
         await rename2(sourcePath, targetPath);
       } catch {
@@ -106214,14 +106574,14 @@ var Response2 = class _Response {
     }
   }
   get headers() {
-    const cache = this[cacheKey];
-    if (cache) {
-      if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(
-          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+    const cache2 = this[cacheKey];
+    if (cache2) {
+      if (!(cache2[2] instanceof Headers)) {
+        cache2[2] = new Headers(
+          cache2[2] || { "content-type": "text/plain; charset=UTF-8" }
         );
       }
-      return cache[2];
+      return cache2[2];
     }
     return this[getResponseCache]().headers;
   }
@@ -107732,18 +108092,18 @@ var ridgedBurn = (from2, to, out, w, h, p) => {
 TRANSITIONS["ridged-burn"] = ridgedBurn;
 
 // src/services/renderOrchestrator.ts
-import { join as join15, dirname as dirname10, resolve as resolve11 } from "path";
+import { join as join16, dirname as dirname10, resolve as resolve11 } from "path";
 import { randomUUID } from "crypto";
 import { freemem as freemem2 } from "os";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/services/fileServer.ts
-import { readFileSync as readFileSync7, existsSync as existsSync12, realpathSync, statSync as statSync5 } from "node:fs";
-import { join as join11, extname as extname4, resolve as resolve8, sep } from "node:path";
+import { readFileSync as readFileSync7, existsSync as existsSync13, realpathSync, statSync as statSync6 } from "node:fs";
+import { join as join12, extname as extname4, resolve as resolve8, sep } from "node:path";
 
 // src/services/hyperframeRuntimeLoader.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync6 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync12, readFileSync as readFileSync6 } from "node:fs";
 import { dirname as dirname8, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var PRODUCER_DIR = dirname8(fileURLToPath2(import.meta.url));
@@ -107770,7 +108130,7 @@ function resolveHyperframeManifestPath() {
     MODULE_RELATIVE_MANIFEST_PATH
   ];
   for (const candidate of candidates) {
-    if (existsSync11(candidate)) {
+    if (existsSync12(candidate)) {
       return candidate;
     }
   }
@@ -107781,7 +108141,7 @@ function getVerifiedHyperframeRuntimeSource() {
 }
 function resolveVerifiedHyperframeRuntime() {
   const manifestPath = resolveHyperframeManifestPath();
-  if (!existsSync11(manifestPath)) {
+  if (!existsSync12(manifestPath)) {
     throw new Error(
       `[HyperframeRuntimeLoader] Missing manifest at ${manifestPath}. Build core runtime artifacts before rendering.`
     );
@@ -107795,11 +108155,11 @@ function resolveVerifiedHyperframeRuntime() {
     );
   }
   const runtimePath = resolve7(dirname8(manifestPath), runtimeFileName);
-  if (!existsSync11(runtimePath)) {
+  if (!existsSync12(runtimePath)) {
     throw new Error(`[HyperframeRuntimeLoader] Missing runtime artifact at ${runtimePath}.`);
   }
   const runtimeSource = readFileSync6(runtimePath, "utf8");
-  const runtimeSha = createHash2("sha256").update(runtimeSource, "utf8").digest("hex");
+  const runtimeSha = createHash3("sha256").update(runtimeSource, "utf8").digest("hex");
   if (runtimeSha !== manifest.sha256) {
     throw new Error(
       `[HyperframeRuntimeLoader] Runtime checksum mismatch. expected=${manifest.sha256} actual=${runtimeSha}`
@@ -107821,8 +108181,8 @@ function isPathInside(child, parent, options = {}) {
   const separator = pathModule?.sep ?? sep;
   const resolvedChild = resolveFn(child);
   const resolvedParent = resolveFn(parent);
-  const normalizedChild = resolveSymlinks && existsSync12(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
-  const normalizedParent = resolveSymlinks && existsSync12(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
+  const normalizedChild = resolveSymlinks && existsSync13(resolvedChild) ? realpathSync.native(resolvedChild) : resolvedChild;
+  const normalizedParent = resolveSymlinks && existsSync13(resolvedParent) ? realpathSync.native(resolvedParent) : resolvedParent;
   if (normalizedChild === normalizedParent) return true;
   const parentWithSep = normalizedParent.endsWith(separator) ? normalizedParent : normalizedParent + separator;
   return normalizedChild.startsWith(parentWithSep);
@@ -108221,14 +108581,14 @@ function createFileServer2(options) {
     const relativePath = requestPath.replace(/^\//, "");
     let filePath = null;
     if (compiledDir) {
-      const candidate = join11(compiledDir, relativePath);
-      if (existsSync12(candidate) && isPathInside(candidate, compiledDir, { resolveSymlinks: true }) && statSync5(candidate).isFile()) {
+      const candidate = join12(compiledDir, relativePath);
+      if (existsSync13(candidate) && isPathInside(candidate, compiledDir, { resolveSymlinks: true }) && statSync6(candidate).isFile()) {
         filePath = candidate;
       }
     }
     if (!filePath) {
-      const candidate = join11(projectDir, relativePath);
-      if (existsSync12(candidate) && isPathInside(candidate, projectDir, { resolveSymlinks: true }) && statSync5(candidate).isFile()) {
+      const candidate = join12(projectDir, relativePath);
+      if (existsSync13(candidate) && isPathInside(candidate, projectDir, { resolveSymlinks: true }) && statSync6(candidate).isFile()) {
         filePath = candidate;
       }
     }
@@ -108277,12 +108637,12 @@ function createFileServer2(options) {
 }
 
 // src/services/htmlCompiler.ts
-import { readFileSync as readFileSync9, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
-import { join as join14, dirname as dirname9, resolve as resolve10 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15, dirname as dirname9, resolve as resolve10 } from "path";
 import postcss from "postcss";
 
 // src/utils/paths.ts
-import { resolve as resolve9, basename as basename2, join as join12, relative as relative2, isAbsolute as isAbsolute4 } from "node:path";
+import { resolve as resolve9, basename as basename2, join as join13, relative as relative2, isAbsolute as isAbsolute4 } from "node:path";
 var DEFAULT_RENDERS_DIR = process.env.PRODUCER_RENDERS_DIR ?? resolve9(new URL(import.meta.url).pathname, "../../..", "renders");
 function isPathInside2(childPath, parentPath) {
   const absChild = resolve9(childPath);
@@ -108304,15 +108664,15 @@ function toExternalAssetKey(absPath) {
 function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS_DIR) {
   const absoluteProjectDir = resolve9(projectDir);
   const projectName = basename2(absoluteProjectDir);
-  const resolvedOutputPath = outputPath ?? join12(rendersDir, `${projectName}.mp4`);
+  const resolvedOutputPath = outputPath ?? join13(rendersDir, `${projectName}.mp4`);
   const absoluteOutputPath = resolve9(resolvedOutputPath);
   return { absoluteProjectDir, absoluteOutputPath };
 }
 
 // src/services/deterministicFonts.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 
 // src/services/fontData.generated.ts
 var EMBEDDED_FONT_DATA = /* @__PURE__ */ new Map([
@@ -108590,20 +108950,20 @@ function warnUnresolvedFonts(unresolved) {
   Docs: https://hyperframes.heygen.com/docs/fonts`
   );
 }
-var GOOGLE_FONTS_CACHE_DIR = join13(homedir2(), ".cache", "hyperframes", "fonts");
+var GOOGLE_FONTS_CACHE_DIR = join14(homedir2(), ".cache", "hyperframes", "fonts");
 var WOFF2_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
 function fontSlug(familyName) {
   return familyName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 function fontCacheDir(slug) {
-  const dir = join13(GOOGLE_FONTS_CACHE_DIR, slug);
-  if (!existsSync13(dir)) {
-    mkdirSync8(dir, { recursive: true });
+  const dir = join14(GOOGLE_FONTS_CACHE_DIR, slug);
+  if (!existsSync14(dir)) {
+    mkdirSync9(dir, { recursive: true });
   }
   return dir;
 }
 function cachedWoff2Path(slug, weight, style) {
-  return join13(fontCacheDir(slug), `${weight}-${style}.woff2`);
+  return join14(fontCacheDir(slug), `${weight}-${style}.woff2`);
 }
 async function fetchGoogleFont(familyName) {
   const slug = fontSlug(familyName);
@@ -108629,12 +108989,12 @@ async function fetchGoogleFont(familyName) {
     const woff2Url = match2[3] || "";
     if (!woff2Url) continue;
     const cachePath = cachedWoff2Path(slug, weight, style);
-    if (!existsSync13(cachePath)) {
+    if (!existsSync14(cachePath)) {
       try {
         const fontRes = await fetch(woff2Url);
         if (!fontRes.ok) continue;
         const buffer = Buffer.from(await fontRes.arrayBuffer());
-        writeFileSync3(cachePath, buffer);
+        writeFileSync4(cachePath, buffer);
       } catch {
         continue;
       }
@@ -108740,16 +109100,16 @@ function detectRenderModeHints(html) {
 async function resolveMediaDuration(src, mediaStart, baseDir, downloadDir, tagName19) {
   let filePath = src;
   if (isHttpUrl(src)) {
-    if (!existsSync14(downloadDir)) mkdirSync9(downloadDir, { recursive: true });
+    if (!existsSync15(downloadDir)) mkdirSync10(downloadDir, { recursive: true });
     try {
       filePath = await downloadToTemp(src, downloadDir);
     } catch {
       return { duration: 0, resolvedPath: src };
     }
   } else if (!filePath.startsWith("/")) {
-    filePath = join14(baseDir, filePath);
+    filePath = join15(baseDir, filePath);
   }
-  if (!existsSync14(filePath)) {
+  if (!existsSync15(filePath)) {
     return { duration: 0, resolvedPath: filePath };
   }
   const metadata = tagName19 === "video" ? await extractMediaMetadata(filePath) : await extractAudioMetadata(filePath);
@@ -108818,7 +109178,7 @@ async function parseSubCompositions(html, projectDir, downloadDir, parentOffset
     if (visited.has(filePath)) {
       continue;
     }
-    if (!existsSync14(filePath)) {
+    if (!existsSync15(filePath)) {
       continue;
     }
     const rawSubHtml = readFileSync9(filePath, "utf-8");
@@ -109028,7 +109388,7 @@ function inlineSubCompositions(html, subCompositions, projectDir) {
     let compHtml = subCompositions.get(srcPath) || null;
     if (!compHtml) {
       const filePath = resolve10(projectDir, srcPath);
-      if (existsSync14(filePath)) {
+      if (existsSync15(filePath)) {
         compHtml = readFileSync9(filePath, "utf-8");
       }
     }
@@ -109256,7 +109616,7 @@ function collectExternalAssets(html, projectDir) {
     if (isPathInside2(absPath, absProjectDir)) {
       return null;
     }
-    if (!existsSync14(absPath)) return null;
+    if (!existsSync15(absPath)) return null;
     const safeKey = toExternalAssetKey(absPath);
     externalAssets.set(safeKey, absPath);
     return safeKey;
@@ -109452,9 +109812,10 @@ async function recompileWithResolutions(compiled, resolutions, projectDir, downl
   const mainVideos = parseVideoElements(html);
   const mainAudios = parseAudioElements(html);
   const mainImages = parseImageElements(html);
-  const videos = dedupeElementsById([...mainVideos, ...subVideos]);
-  const audios = dedupeElementsById([...mainAudios, ...subAudios]);
-  const images = dedupeElementsById([...mainImages, ...subImages]);
+  const hasSubMedia = subVideos.length > 0 || subAudios.length > 0 || subImages.length > 0;
+  const videos = hasSubMedia ? dedupeElementsById([...mainVideos, ...subVideos]) : compiled.videos;
+  const audios = hasSubMedia ? dedupeElementsById([...mainAudios, ...subAudios]) : compiled.audios;
+  const images = hasSubMedia ? dedupeElementsById([...mainImages, ...subImages]) : compiled.images;
   const remaining = compiled.unresolvedCompositions.filter(
     (c) => !resolutions.some((r) => r.id === c.id)
   );
@@ -109509,24 +109870,21 @@ function createConsoleLogger(level = "info") {
 }
 var defaultLogger = createConsoleLogger("info");
 
-// src/services/renderOrchestrator.ts
-async function safeCleanup(label, fn, log = defaultLogger) {
-  try {
-    await fn();
-  } catch (err) {
-    log.debug(`Cleanup failed (${label})`, {
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-var frameDirMaxIndexCache = /* @__PURE__ */ new Map();
+// src/services/frameDirCache.ts
+import { readdirSync as readdirSync7 } from "fs";
+var cache = /* @__PURE__ */ new Map();
 var FRAME_FILENAME_RE = /^frame_(\d+)\.png$/;
+var MAX_ENTRIES = 1e3;
 function getMaxFrameIndex(frameDir) {
-  const cached = frameDirMaxIndexCache.get(frameDir);
-  if (cached !== void 0) return cached;
+  const cached = cache.get(frameDir);
+  if (cached !== void 0) {
+    cache.delete(frameDir);
+    cache.set(frameDir, cached);
+    return cached;
+  }
   let max = 0;
   try {
-    for (const name of readdirSync6(frameDir)) {
+    for (const name of readdirSync7(frameDir)) {
       const m = FRAME_FILENAME_RE.exec(name);
       if (!m) continue;
       const n = Number(m[1]);
@@ -109534,9 +109892,113 @@ function getMaxFrameIndex(frameDir) {
     }
   } catch {
   }
-  frameDirMaxIndexCache.set(frameDir, max);
+  if (cache.size >= MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(frameDir, max);
   return max;
 }
+function clearMaxFrameIndex(frameDir) {
+  return cache.delete(frameDir);
+}
+
+// src/services/hdrImageTransferCache.ts
+var DEFAULT_MAX_BYTES = 200 * 1024 * 1024;
+function createHdrImageTransferCache(options = {}) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  if (!Number.isInteger(maxBytes) || maxBytes < 0) {
+    throw new Error(
+      `createHdrImageTransferCache: maxBytes must be a non-negative integer, got ${String(maxBytes)}`
+    );
+  }
+  const entries2 = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  function makeKey(imageId, targetTransfer) {
+    return `${imageId}|${targetTransfer}`;
+  }
+  function evictUntilRoom(needed) {
+    while (totalBytes + needed > maxBytes && entries2.size > 0) {
+      const lruKey = entries2.keys().next().value;
+      if (lruKey === void 0) break;
+      const evicted = entries2.get(lruKey);
+      if (evicted) totalBytes -= evicted.byteLength;
+      entries2.delete(lruKey);
+    }
+  }
+  return {
+    getConverted(imageId, sourceTransfer, targetTransfer, source2) {
+      if (sourceTransfer === targetTransfer) {
+        return source2;
+      }
+      if (maxBytes === 0) {
+        const fresh = Buffer.from(source2);
+        convertTransfer(fresh, sourceTransfer, targetTransfer);
+        return fresh;
+      }
+      const key2 = makeKey(imageId, targetTransfer);
+      const existing = entries2.get(key2);
+      if (existing) {
+        entries2.delete(key2);
+        entries2.set(key2, existing);
+        return existing;
+      }
+      const converted = Buffer.from(source2);
+      convertTransfer(converted, sourceTransfer, targetTransfer);
+      if (converted.byteLength > maxBytes) {
+        return converted;
+      }
+      evictUntilRoom(converted.byteLength);
+      entries2.set(key2, converted);
+      totalBytes += converted.byteLength;
+      return converted;
+    },
+    size() {
+      return entries2.size;
+    },
+    bytesUsed() {
+      return totalBytes;
+    }
+  };
+}
+
+// src/services/renderOrchestrator.ts
+async function safeCleanup(label, fn, log = defaultLogger) {
+  try {
+    await fn();
+  } catch (err) {
+    log.debug(`Cleanup failed (${label})`, {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function sampleDirectoryBytes(dir) {
+  let total = 0;
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let entries2 = [];
+    try {
+      entries2 = readdirSync8(current);
+    } catch {
+      continue;
+    }
+    for (const name of entries2) {
+      const full = join16(current, name);
+      try {
+        const st = statSync7(full);
+        if (st.isDirectory()) {
+          stack.push(full);
+        } else if (st.isFile()) {
+          total += st.size;
+        }
+      } catch {
+      }
+    }
+  }
+  return total;
+}
 function countNonZeroAlpha(rgba) {
   let n = 0;
   for (let p = 3; p < rgba.length; p += 4) {
@@ -109560,6 +110022,10 @@ var RenderCancelledError = class extends Error {
     this.reason = reason;
   }
 };
+var BROWSER_MEDIA_EPSILON = 1e-4;
+function projectBrowserEndToCompositionTimeline(existingStart, browserStart, browserEnd) {
+  return browserEnd + (existingStart - browserStart);
+}
 function updateJobStatus(job, status, stage, progress, onProgress) {
   job.status = status;
   job.currentStage = stage;
@@ -109603,21 +110069,21 @@ function installDebugLogger(logPath, log = defaultLogger) {
   };
 }
 function writeCompiledArtifacts(compiled, workDir, includeSummary) {
-  const compileDir = join15(workDir, "compiled");
-  mkdirSync10(compileDir, { recursive: true });
-  writeFileSync4(join15(compileDir, "index.html"), compiled.html, "utf-8");
+  const compileDir = join16(workDir, "compiled");
+  mkdirSync11(compileDir, { recursive: true });
+  writeFileSync5(join16(compileDir, "index.html"), compiled.html, "utf-8");
   for (const [srcPath, html] of compiled.subCompositions) {
-    const outPath = join15(compileDir, srcPath);
-    mkdirSync10(dirname10(outPath), { recursive: true });
-    writeFileSync4(outPath, html, "utf-8");
+    const outPath = join16(compileDir, srcPath);
+    mkdirSync11(dirname10(outPath), { recursive: true });
+    writeFileSync5(outPath, html, "utf-8");
   }
   for (const [relativePath, absolutePath] of compiled.externalAssets) {
-    const outPath = resolve11(join15(compileDir, relativePath));
+    const outPath = resolve11(join16(compileDir, relativePath));
     if (!isPathInside2(outPath, compileDir)) {
       console.warn(`[Render] Skipping external asset with unsafe path: ${relativePath}`);
       continue;
     }
-    mkdirSync10(dirname10(outPath), { recursive: true });
+    mkdirSync11(dirname10(outPath), { recursive: true });
     copyFileSync2(absolutePath, outPath);
   }
   if (includeSummary) {
@@ -109642,7 +110108,7 @@ function writeCompiledArtifacts(compiled, workDir, includeSummary) {
       subCompositions: Array.from(compiled.subCompositions.keys()),
       renderModeHints: compiled.renderModeHints
     };
-    writeFileSync4(join15(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync5(join16(compileDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
   }
 }
 function applyRenderModeHints(cfg, compiled, log = defaultLogger) {
@@ -109663,8 +110129,8 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrFrameDirs, hdrStartTimes, w
   if (videoFrameIndex < 1) return;
   const maxIndex = getMaxFrameIndex(frameDir);
   const effectiveIndex = maxIndex > 0 ? Math.min(videoFrameIndex, maxIndex) : videoFrameIndex;
-  const framePath = join15(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
-  if (!existsSync15(framePath)) {
+  const framePath = join16(frameDir, `frame_${String(effectiveIndex).padStart(4, "0")}.png`);
+  if (!existsSync16(framePath)) {
     return;
   }
   try {
@@ -109710,17 +110176,13 @@ function blitHdrVideoLayer(canvas, el, time, fps, hdrFrameDirs, hdrStartTimes, w
     }
   }
 }
-function blitHdrImageLayer(canvas, el, hdrImageBuffers, width, height, log, sourceTransfer, targetTransfer) {
+function blitHdrImageLayer(canvas, el, hdrImageBuffers, hdrImageTransferCache, width, height, log, sourceTransfer, targetTransfer) {
   const buf = hdrImageBuffers.get(el.id);
   if (!buf) {
     return;
   }
   try {
-    let hdrRgb = buf.data;
-    if (sourceTransfer && targetTransfer && sourceTransfer !== targetTransfer) {
-      hdrRgb = Buffer.from(buf.data);
-      convertTransfer(hdrRgb, sourceTransfer, targetTransfer);
-    }
+    const hdrRgb = sourceTransfer && targetTransfer ? hdrImageTransferCache.getConverted(el.id, sourceTransfer, targetTransfer, buf.data) : buf.data;
     const viewportMatrix = parseTransformMatrix(el.transform);
     const br = el.borderRadius;
     const hasBorderRadius = br[0] > 0 || br[1] > 0 || br[2] > 0 || br[3] > 0;
@@ -109770,6 +110232,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
     effectiveHdr,
     nativeHdrImageIds,
     hdrImageBuffers,
+    hdrImageTransferCache,
     hdrFrameDirs,
     hdrVideoStartTimes,
     imageTransfers,
@@ -109809,6 +110272,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           canvas,
           layer.element,
           hdrImageBuffers,
+          hdrImageTransferCache,
           width,
           height,
           log,
@@ -109849,7 +110313,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
           const startTime = hdrVideoStartTimes.get(layer.element.id) ?? 0;
           const localTime = time - startTime;
           const frameNum = Math.floor(localTime * fps) + 1;
-          const expectedFrame = frameDir ? join15(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
+          const expectedFrame = frameDir ? join16(frameDir, `frame_${String(frameNum).padStart(4, "0")}.png`) : null;
           log.info("[diag] hdr layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -109861,7 +110325,7 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
             localTime: localTime.toFixed(3),
             hdrFrameNum: frameNum,
             expectedFrame,
-            expectedFrameExists: expectedFrame ? existsSync15(expectedFrame) : false
+            expectedFrameExists: expectedFrame ? existsSync16(expectedFrame) : false
           });
         }
       }
@@ -109886,8 +110350,8 @@ async function compositeHdrFrame(ctx, canvas, time, fullStacking, elementFilter,
         if (shouldLog && debugDumpDir) {
           const after2 = countNonZeroRgb48(canvas);
           const dumpName = `frame_${String(debugFrameIndex).padStart(4, "0")}_layer_${String(layerIdx).padStart(2, "0")}_dom.png`;
-          const dumpPath = join15(debugDumpDir, dumpName);
-          writeFileSync4(dumpPath, domPng);
+          const dumpPath = join16(debugDumpDir, dumpName);
+          writeFileSync5(dumpPath, domPng);
           log.info("[diag] dom layer blit", {
             frame: debugFrameIndex,
             layerIdx,
@@ -109960,8 +110424,8 @@ function extractStandaloneEntryFromIndex(indexHtml, entryFile) {
 async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSignal) {
   const moduleDir = dirname10(fileURLToPath3(import.meta.url));
   const producerRoot = process.env.PRODUCER_RENDERS_DIR ? resolve11(process.env.PRODUCER_RENDERS_DIR, "..") : resolve11(moduleDir, "../..");
-  const debugDir = join15(producerRoot, ".debug");
-  const workDir = job.config.debug ? join15(debugDir, job.id) : join15(dirname10(outputPath), `work-${job.id}`);
+  const debugDir = join16(producerRoot, ".debug");
+  const workDir = job.config.debug ? join16(debugDir, job.id) : join16(dirname10(outputPath), `work-${job.id}`);
   const pipelineStart = Date.now();
   const log = job.config.logger ?? defaultLogger;
   let fileServer = null;
@@ -109973,7 +110437,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     videoExtractionFailures: 0,
     imageDecodeFailures: 0
   };
-  const perfOutputPath = join15(workDir, "perf-summary.json");
+  const perfOutputPath = join16(workDir, "perf-summary.json");
   const cfg = { ...job.config.producerConfig ?? resolveConfig() };
   const outputFormat = job.config.format ?? "mp4";
   const isWebm = outputFormat === "webm";
@@ -110006,22 +110470,22 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     };
     job.startedAt = /* @__PURE__ */ new Date();
     assertNotAborted();
-    if (!existsSync15(workDir)) mkdirSync10(workDir, { recursive: true });
+    if (!existsSync16(workDir)) mkdirSync11(workDir, { recursive: true });
     if (job.config.debug) {
-      const logPath = join15(workDir, "render.log");
+      const logPath = join16(workDir, "render.log");
       restoreLogger = installDebugLogger(logPath, log);
     }
     const entryFile = job.config.entryFile || "index.html";
-    let htmlPath = join15(projectDir, entryFile);
-    if (!existsSync15(htmlPath)) {
+    let htmlPath = join16(projectDir, entryFile);
+    if (!existsSync16(htmlPath)) {
       throw new Error(`Entry file not found: ${htmlPath}`);
     }
     assertNotAborted();
     const rawEntry = readFileSync10(htmlPath, "utf-8");
     if (entryFile !== "index.html" && rawEntry.trimStart().startsWith("<template")) {
-      const wrapperPath = join15(workDir, "standalone-entry.html");
-      const projectIndexPath = join15(projectDir, "index.html");
-      if (!existsSync15(projectIndexPath)) {
+      const wrapperPath = join16(workDir, "standalone-entry.html");
+      const projectIndexPath = join16(projectDir, "index.html");
+      if (!existsSync16(projectIndexPath)) {
         throw new Error(
           `Template entry file "${entryFile}" requires a project index.html to extract its render shell.`
         );
@@ -110035,7 +110499,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           `Entry file "${entryFile}" is not mounted from index.html via data-composition-src, so it cannot be rendered independently.`
         );
       }
-      writeFileSync4(wrapperPath, standaloneHtml, "utf-8");
+      writeFileSync5(wrapperPath, standaloneHtml, "utf-8");
       htmlPath = wrapperPath;
       log.info("Extracted standalone entry from index.html host context", {
         entryFile
@@ -110044,7 +110508,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const stage1Start = Date.now();
     updateJobStatus(job, "preprocessing", "Compiling composition", 5, onProgress);
     const compileStart = Date.now();
-    let compiled = await compileForRender(projectDir, htmlPath, join15(workDir, "downloads"));
+    let compiled = await compileForRender(projectDir, htmlPath, join16(workDir, "downloads"));
     assertNotAborted();
     perfStages.compileOnlyMs = Date.now() - compileStart;
     applyRenderModeHints(cfg, compiled, log);
@@ -110076,7 +110540,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         reasons.push(`${compiled.unresolvedCompositions.length} unresolved composition(s)`);
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join15(workDir, "compiled"),
+        compiledDir: join16(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
@@ -110090,7 +110554,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       };
       probeSession = await createCaptureSession(
         fileServer.url,
-        join15(workDir, "probe"),
+        join16(workDir, "probe"),
         captureOpts,
         null,
         cfg
@@ -110122,7 +110586,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             compiled,
             resolutions,
             projectDir,
-            join15(workDir, "downloads")
+            join16(workDir, "downloads")
           );
           assertNotAborted();
           composition.videos = compiled.videos;
@@ -110149,10 +110613,15 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 1e-4)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end
+                );
+                if (projectedEnd > 0 && (existing.end <= 0 || Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)) {
+                  existing.end = projectedEnd;
                 }
-                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > 1e-4)) {
+                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                   existing.mediaStart = el.mediaStart;
                 }
                 if (el.hasAudio && !existing.hasAudio) {
@@ -110177,13 +110646,18 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 if (existing.src !== src) {
                   existing.src = src;
                 }
-                if (el.end > 0 && (existing.end <= 0 || Math.abs(existing.end - el.end) > 1e-4)) {
-                  existing.end = el.end;
+                const projectedEnd = projectBrowserEndToCompositionTimeline(
+                  existing.start,
+                  el.start,
+                  el.end
+                );
+                if (projectedEnd > 0 && (existing.end <= 0 || Math.abs(existing.end - projectedEnd) > BROWSER_MEDIA_EPSILON)) {
+                  existing.end = projectedEnd;
                 }
-                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > 1e-4)) {
+                if (el.mediaStart > 0 && (existing.mediaStart <= 0 || Math.abs(existing.mediaStart - el.mediaStart) > BROWSER_MEDIA_EPSILON)) {
                   existing.mediaStart = el.mediaStart;
                 }
-                if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > 1e-4) {
+                if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON) {
                   existing.volume = el.volume;
                 }
               }
@@ -110262,7 +110736,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const stage2Start = Date.now();
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
     let frameLookup = null;
-    const compiledDir = join15(workDir, "compiled");
+    const compiledDir = join16(workDir, "compiled");
     let extractionResult = null;
     const nativeHdrVideoIds = /* @__PURE__ */ new Set();
     const videoTransfers = /* @__PURE__ */ new Map();
@@ -110271,10 +110745,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.videos.map(async (v) => {
           let videoPath = v.src;
           if (!videoPath.startsWith("/")) {
-            const fromCompiled = existsSync15(join15(compiledDir, videoPath)) ? join15(compiledDir, videoPath) : join15(projectDir, videoPath);
+            const fromCompiled = existsSync16(join16(compiledDir, videoPath)) ? join16(compiledDir, videoPath) : join16(projectDir, videoPath);
             videoPath = fromCompiled;
           }
-          if (!existsSync15(videoPath)) return;
+          if (!existsSync16(videoPath)) return;
           const meta = await extractMediaMetadata(videoPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrVideoIds.add(v.id);
@@ -110292,10 +110766,10 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         composition.images.map(async (img) => {
           let imgPath = img.src;
           if (!imgPath.startsWith("/")) {
-            const fromCompiled = existsSync15(join15(compiledDir, imgPath)) ? join15(compiledDir, imgPath) : join15(projectDir, imgPath);
+            const fromCompiled = existsSync16(join16(compiledDir, imgPath)) ? join16(compiledDir, imgPath) : join16(projectDir, imgPath);
             imgPath = fromCompiled;
           }
-          if (!existsSync15(imgPath)) return null;
+          if (!existsSync16(imgPath)) return null;
           const meta = await extractMediaMetadata(imgPath);
           if (isHdrColorSpace(meta.colorSpace)) {
             nativeHdrImageIds.add(img.id);
@@ -110311,9 +110785,9 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
-        { fps: job.config.fps, outputDir: join15(workDir, "video-frames") },
+        { fps: job.config.fps, outputDir: join16(workDir, "video-frames") },
         abortSignal,
-        void 0,
+        { extractCacheDir: cfg.extractCacheDir },
         compiledDir
       );
       assertNotAborted();
@@ -110369,13 +110843,13 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     }
     const stage3Start = Date.now();
     updateJobStatus(job, "preprocessing", "Processing audio tracks", 20, onProgress);
-    const audioOutputPath = join15(workDir, "audio.aac");
+    const audioOutputPath = join16(workDir, "audio.aac");
     let hasAudio = false;
     if (composition.audios.length > 0) {
       const audioResult = await processCompositionAudio(
         composition.audios,
         projectDir,
-        join15(workDir, "audio-work"),
+        join16(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
         abortSignal,
@@ -110393,14 +110867,14 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     if (!fileServer) {
       fileServer = await createFileServer2({
         projectDir,
-        compiledDir: join15(workDir, "compiled"),
+        compiledDir: join16(workDir, "compiled"),
         port: 0,
         preHeadScripts: [VIRTUAL_TIME_SHIM]
       });
       assertNotAborted();
     }
-    const framesDir = join15(workDir, "captured-frames");
-    if (!existsSync15(framesDir)) mkdirSync10(framesDir, { recursive: true });
+    const framesDir = join16(workDir, "captured-frames");
+    if (!existsSync16(framesDir)) mkdirSync11(framesDir, { recursive: true });
     const captureOptions = {
       width,
       height,
@@ -110415,7 +110889,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const workerCount = calculateOptimalWorkers(totalFrames, job.config.workers, cfg);
     const FORMAT_EXT = { mp4: ".mp4", webm: ".webm", mov: ".mov" };
     const videoExt = FORMAT_EXT[outputFormat] ?? ".mp4";
-    const videoOnlyPath = join15(workDir, `video-only${videoExt}`);
+    const videoOnlyPath = join16(workDir, `video-only${videoExt}`);
     const nativeHdrIds = /* @__PURE__ */ new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = effectiveHdr && nativeHdrIds.size > 0;
     const encoderHdr = hasHdrContent ? effectiveHdr : void 0;
@@ -110437,8 +110911,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         if (!hdrVideoIds.includes(v.id)) continue;
         let srcPath = v.src;
         if (!srcPath.startsWith("/")) {
-          const fromCompiled = join15(compiledDir, srcPath);
-          srcPath = existsSync15(fromCompiled) ? fromCompiled : join15(projectDir, srcPath);
+          const fromCompiled = join16(compiledDir, srcPath);
+          srcPath = existsSync16(fromCompiled) ? fromCompiled : join16(projectDir, srcPath);
         }
         hdrVideoSrcPaths.set(v.id, srcPath);
       }
@@ -110568,8 +111042,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         for (const [videoId, srcPath] of hdrVideoSrcPaths) {
           const video = composition.videos.find((v) => v.id === videoId);
           if (!video) continue;
-          const frameDir = join15(framesDir, `hdr_${videoId}`);
-          mkdirSync10(frameDir, { recursive: true });
+          const frameDir = join16(framesDir, `hdr_${videoId}`);
+          mkdirSync11(frameDir, { recursive: true });
           const duration = video.end - video.start;
           const dims = hdrExtractionDims.get(videoId) ?? { width, height };
           const ffmpegArgs = [
@@ -110588,7 +111062,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             "-c:v",
             "png",
             "-y",
-            join15(frameDir, "frame_%04d.png")
+            join16(frameDir, "frame_%04d.png")
           ];
           const result = await runFfmpeg(ffmpegArgs, { signal: abortSignal });
           if (!result.success) {
@@ -110656,15 +111130,19 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             }
           }
           const debugDumpEnabled = process.env.KEEP_TEMP === "1";
-          const debugDumpDir = debugDumpEnabled ? join15(framesDir, "debug-composite") : null;
-          if (debugDumpDir && !existsSync15(debugDumpDir)) {
-            mkdirSync10(debugDumpDir, { recursive: true });
+          const debugDumpDir = debugDumpEnabled ? join16(framesDir, "debug-composite") : null;
+          if (debugDumpDir && !existsSync16(debugDumpDir)) {
+            mkdirSync11(debugDumpDir, { recursive: true });
           }
           if (!effectiveHdr) {
             throw new Error(
               "Internal: HDR render path entered without effectiveHdr \u2014 this is a bug."
             );
           }
+          const hdrCacheMaxBytes = process.env.HDR_TRANSFER_CACHE_MAX_BYTES ? Number(process.env.HDR_TRANSFER_CACHE_MAX_BYTES) : void 0;
+          const hdrImageTransferCache = createHdrImageTransferCache(
+            hdrCacheMaxBytes !== void 0 ? { maxBytes: hdrCacheMaxBytes } : {}
+          );
           const hdrCompositeCtx = {
             log,
             domSession,
@@ -110675,6 +111153,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
             effectiveHdr,
             nativeHdrImageIds,
             hdrImageBuffers,
+            hdrImageTransferCache,
             hdrFrameDirs,
             hdrVideoStartTimes,
             imageTransfers,
@@ -110735,6 +111214,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                       sceneBuf,
                       el,
                       hdrImageBuffers,
+                      hdrImageTransferCache,
                       width,
                       height,
                       log,
@@ -110798,11 +111278,11 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                 i
               );
               if (debugDumpEnabled && debugDumpDir && i % 30 === 0) {
-                const previewPath = join15(
+                const previewPath = join16(
                   debugDumpDir,
                   `frame_${String(i).padStart(4, "0")}_final_rgb48le.bin`
                 );
-                writeFileSync4(previewPath, normalCanvas);
+                writeFileSync5(previewPath, normalCanvas);
               }
               hdrEncoder.writeFrame(normalCanvas);
             }
@@ -110822,7 +111302,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
                           error: err instanceof Error ? err.message : String(err)
                         });
                       }
-                      frameDirMaxIndexCache.delete(frameDir);
+                      clearMaxFrameIndex(frameDir);
                       hdrFrameDirs.delete(videoId);
                     }
                     cleanedUpVideos.add(videoId);
@@ -110873,7 +111353,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
           });
         }
         for (const frameDir of hdrFrameDirs.values()) {
-          frameDirMaxIndexCache.delete(frameDir);
+          clearMaxFrameIndex(frameDir);
         }
         hdrFrameDirs.clear();
       }
@@ -111145,6 +111625,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     updateJobStatus(job, "complete", "Render complete", 100, onProgress);
     const totalElapsed = Date.now() - pipelineStart;
     sampleMemory();
+    const tmpPeakBytes = existsSync16(workDir) ? sampleDirectoryBytes(workDir) : 0;
     const perfSummary = {
       renderId: job.id,
       totalElapsedMs: totalElapsed,
@@ -111159,6 +111640,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       videoCount: composition.videos.length,
       audioCount: composition.audios.length,
       stages: perfStages,
+      videoExtractBreakdown: extractionResult?.phaseBreakdown,
+      tmpPeakBytes,
       hdrDiagnostics: hdrDiagnostics.videoExtractionFailures > 0 || hdrDiagnostics.imageDecodeFailures > 0 ? { ...hdrDiagnostics } : void 0,
       captureAvgMs: totalFrames > 0 ? Math.round((perfStages.captureMs ?? 0) / totalFrames) : void 0,
       peakRssMb: Math.round(peakRssBytes / (1024 * 1024)),
@@ -111167,7 +111650,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     job.perfSummary = perfSummary;
     if (job.config.debug) {
       try {
-        writeFileSync4(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
+        writeFileSync5(perfOutputPath, JSON.stringify(perfSummary, null, 2), "utf-8");
       } catch (err) {
         log.debug("Failed to write perf summary", {
           perfOutputPath,
@@ -111176,8 +111659,8 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       }
     }
     if (job.config.debug) {
-      if (existsSync15(outputPath)) {
-        const debugOutput = join15(workDir, `output${videoExt}`);
+      if (existsSync16(outputPath)) {
+        const debugOutput = join16(workDir, `output${videoExt}`);
         copyFileSync2(outputPath, debugOutput);
       }
     } else if (process.env.KEEP_TEMP === "1") {
@@ -111263,7 +111746,7 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
       await safeCleanup(
         "remove workDir (error)",
         () => {
-          if (existsSync15(workDir)) rmSync3(workDir, { recursive: true, force: true });
+          if (existsSync16(workDir)) rmSync3(workDir, { recursive: true, force: true });
         },
         log
       );
@@ -111277,15 +111760,15 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
 
 // src/server.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync11,
-  statSync as statSync7,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync12,
+  statSync as statSync9,
   mkdtempSync,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   rmSync as rmSync4,
   createReadStream as createReadStream2
 } from "node:fs";
-import { resolve as resolve13, dirname as dirname11, join as join17 } from "node:path";
+import { resolve as resolve13, dirname as dirname11, join as join18 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 import { parseArgs } from "node:util";
 import crypto2 from "node:crypto";
@@ -111440,8 +111923,8 @@ var streamSSE = (c, cb, onError) => {
 };
 
 // src/services/hyperframeLint.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11, statSync as statSync6 } from "node:fs";
-import { resolve as resolve12, join as join16 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync11, statSync as statSync8 } from "node:fs";
+import { resolve as resolve12, join as join17 } from "node:path";
 function isStringRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -111469,7 +111952,7 @@ function pickEntryFile(files, preferredEntryFile) {
 }
 function readProjectEntryFile(projectDir, preferredEntryFile) {
   const absProjectDir = resolve12(projectDir);
-  if (!existsSync16(absProjectDir) || !statSync6(absProjectDir).isDirectory()) {
+  if (!existsSync17(absProjectDir) || !statSync8(absProjectDir).isDirectory()) {
     return { error: `Project directory not found: ${absProjectDir}` };
   }
   const entryCandidates = [preferredEntryFile, "index.html", "src/index.html"].filter(
@@ -111480,7 +111963,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     if (!absoluteEntryPath.startsWith(absProjectDir)) {
       return { error: `Entry file must stay inside project directory: ${entryFile}` };
     }
-    if (existsSync16(absoluteEntryPath) && statSync6(absoluteEntryPath).isFile()) {
+    if (existsSync17(absoluteEntryPath) && statSync8(absoluteEntryPath).isFile()) {
       return {
         entryFile,
         html: readFileSync11(absoluteEntryPath, "utf-8"),
@@ -111489,7 +111972,7 @@ function readProjectEntryFile(projectDir, preferredEntryFile) {
     }
   }
   return {
-    error: `No HTML entry file found in project directory: ${join16(absProjectDir, preferredEntryFile || "index.html")}`
+    error: `No HTML entry file found in project directory: ${join17(absProjectDir, preferredEntryFile || "index.html")}`
   };
 }
 function prepareHyperframeLintBody(body) {
@@ -111580,11 +112063,11 @@ async function prepareRenderBody(body) {
   const projectDir = typeof body.projectDir === "string" ? body.projectDir : void 0;
   if (projectDir) {
     const absProjectDir = resolve13(projectDir);
-    if (!existsSync17(absProjectDir) || !statSync7(absProjectDir).isDirectory()) {
+    if (!existsSync18(absProjectDir) || !statSync9(absProjectDir).isDirectory()) {
       return { error: `Project directory not found: ${absProjectDir}` };
     }
     const entry = options.entryFile || "index.html";
-    if (!existsSync17(resolve13(absProjectDir, entry))) {
+    if (!existsSync18(resolve13(absProjectDir, entry))) {
       return { error: `Entry file "${entry}" not found in project directory: ${absProjectDir}` };
     }
     return { prepared: { input: { projectDir: absProjectDir, ...options } } };
@@ -111609,8 +112092,8 @@ async function prepareRenderBody(body) {
     }
   }
   const tempRoot = process.env.PRODUCER_TMP_PROJECT_DIR || tmpdir2();
-  const tempProjectDir = mkdtempSync(join17(tempRoot, "producer-project-"));
-  writeFileSync5(join17(tempProjectDir, "index.html"), htmlContent, "utf-8");
+  const tempProjectDir = mkdtempSync(join18(tempRoot, "producer-project-"));
+  writeFileSync6(join18(tempProjectDir, "index.html"), htmlContent, "utf-8");
   return {
     prepared: {
       input: {
@@ -111733,7 +112216,7 @@ function createRenderHandlers(options = {}) {
       log
     );
     const outputDir = dirname11(absoluteOutputPath);
-    if (!existsSync17(outputDir)) mkdirSync11(outputDir, { recursive: true });
+    if (!existsSync18(outputDir)) mkdirSync12(outputDir, { recursive: true });
     const release = await renderSemaphore.acquire();
     log.info("render started", {
       requestId,
@@ -111760,7 +112243,7 @@ function createRenderHandlers(options = {}) {
           log.info(`render progress ${pct}%`, { requestId, stage: j.currentStage, message });
         }
       });
-      const fileSize = existsSync17(absoluteOutputPath) ? statSync7(absoluteOutputPath).size : 0;
+      const fileSize = existsSync18(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
       const durationMs = Date.now() - t0;
       const outputToken = store.register(absoluteOutputPath);
       const outputUrl = `${outputUrlPrefix}/${outputToken}`;
@@ -111844,7 +112327,7 @@ function createRenderHandlers(options = {}) {
         log
       );
       const outputDir = dirname11(absoluteOutputPath);
-      if (!existsSync17(outputDir)) mkdirSync11(outputDir, { recursive: true });
+      if (!existsSync18(outputDir)) mkdirSync12(outputDir, { recursive: true });
       log.info("render-stream started", { requestId, projectDir: input2.projectDir });
       const job = createRenderJob({
         fps: input2.fps,
@@ -111889,7 +112372,7 @@ function createRenderHandlers(options = {}) {
           },
           abortController.signal
         );
-        const fileSize = existsSync17(absoluteOutputPath) ? statSync7(absoluteOutputPath).size : 0;
+        const fileSize = existsSync18(absoluteOutputPath) ? statSync9(absoluteOutputPath).size : 0;
         const outputToken = store.register(absoluteOutputPath);
         const outputUrl = `${outputUrlPrefix}/${outputToken}`;
         log.info("render-stream completed", { requestId, fileSize, perf: job.perfSummary ?? null });
@@ -111948,11 +112431,11 @@ function createRenderHandlers(options = {}) {
     if (!artifact) {
       return c.json({ success: false, error: "Output artifact not found or expired" }, 404);
     }
-    if (!existsSync17(artifact.path)) {
+    if (!existsSync18(artifact.path)) {
       store.delete(token);
       return c.json({ success: false, error: "Output artifact file missing" }, 404);
     }
-    const stats = statSync7(artifact.path);
+    const stats = statSync9(artifact.path);
     return new Response(createReadStream2(artifact.path), {
       headers: {
         "content-type": "video/mp4",