hyperframes 0.8.62 → 0.8.64

package/dist/fontLocalizeCli.js

@@ -313,28 +313,28 @@ var init_decode = __esm({
        * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      write(input, offset2) {
+      write(input, offset3) {
         switch (this.state) {
           case EntityDecoderState.EntityStart: {
-            if (input.charCodeAt(offset2) === CharCodes.NUM) {
+            if (input.charCodeAt(offset3) === CharCodes.NUM) {
               this.state = EntityDecoderState.NumericStart;
               this.consumed += 1;
-              return this.stateNumericStart(input, offset2 + 1);
+              return this.stateNumericStart(input, offset3 + 1);
             }
             this.state = EntityDecoderState.NamedEntity;
-            return this.stateNamedEntity(input, offset2);
+            return this.stateNamedEntity(input, offset3);
           }
           case EntityDecoderState.NumericStart: {
-            return this.stateNumericStart(input, offset2);
+            return this.stateNumericStart(input, offset3);
           }
           case EntityDecoderState.NumericDecimal: {
-            return this.stateNumericDecimal(input, offset2);
+            return this.stateNumericDecimal(input, offset3);
           }
           case EntityDecoderState.NumericHex: {
-            return this.stateNumericHex(input, offset2);
+            return this.stateNumericHex(input, offset3);
           }
           case EntityDecoderState.NamedEntity: {
-            return this.stateNamedEntity(input, offset2);
+            return this.stateNamedEntity(input, offset3);
           }
         }
       }
@@ -347,17 +347,17 @@ var init_decode = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericStart(input, offset2) {
-        if (offset2 >= input.length) {
+      stateNumericStart(input, offset3) {
+        if (offset3 >= input.length) {
           return -1;
         }
-        if ((input.charCodeAt(offset2) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+        if ((input.charCodeAt(offset3) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
           this.state = EntityDecoderState.NumericHex;
           this.consumed += 1;
-          return this.stateNumericHex(input, offset2 + 1);
+          return this.stateNumericHex(input, offset3 + 1);
         }
         this.state = EntityDecoderState.NumericDecimal;
-        return this.stateNumericDecimal(input, offset2);
+        return this.stateNumericDecimal(input, offset3);
       }
       /**
        * Parses a hexadecimal numeric entity.
@@ -368,14 +368,14 @@ var init_decode = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericHex(input, offset2) {
-        while (offset2 < input.length) {
-          const char = input.charCodeAt(offset2);
+      stateNumericHex(input, offset3) {
+        while (offset3 < input.length) {
+          const char = input.charCodeAt(offset3);
           if (isNumber(char) || isHexadecimalCharacter(char)) {
             const digit = char <= CharCodes.NINE ? char - CharCodes.ZERO : (char | TO_LOWER_BIT) - CharCodes.LOWER_A + 10;
             this.result = this.result * 16 + digit;
             this.consumed++;
-            offset2++;
+            offset3++;
           } else {
             return this.emitNumericEntity(char, 3);
           }
@@ -391,13 +391,13 @@ var init_decode = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericDecimal(input, offset2) {
-        while (offset2 < input.length) {
-          const char = input.charCodeAt(offset2);
+      stateNumericDecimal(input, offset3) {
+        while (offset3 < input.length) {
+          const char = input.charCodeAt(offset3);
           if (isNumber(char)) {
             this.result = this.result * 10 + (char - CharCodes.ZERO);
             this.consumed++;
-            offset2++;
+            offset3++;
           } else {
             return this.emitNumericEntity(char, 2);
           }
@@ -446,34 +446,34 @@ var init_decode = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNamedEntity(input, offset2) {
+      stateNamedEntity(input, offset3) {
         const { decodeTree } = this;
         let current2 = decodeTree[this.treeIndex];
         let valueLength = (current2 & BinTrieFlags.VALUE_LENGTH) >> 14;
-        while (offset2 < input.length) {
+        while (offset3 < input.length) {
           if (valueLength === 0 && (current2 & BinTrieFlags.FLAG13) !== 0) {
             const runLength = (current2 & BinTrieFlags.BRANCH_LENGTH) >> 7;
             if (this.runConsumed === 0) {
               const firstChar = current2 & BinTrieFlags.JUMP_TABLE;
-              if (input.charCodeAt(offset2) !== firstChar) {
+              if (input.charCodeAt(offset3) !== firstChar) {
                 return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
               }
-              offset2++;
+              offset3++;
               this.excess++;
               this.runConsumed++;
             }
             while (this.runConsumed < runLength) {
-              if (offset2 >= input.length) {
+              if (offset3 >= input.length) {
                 return -1;
               }
               const charIndexInPacked = this.runConsumed - 1;
               const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
               const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
-              if (input.charCodeAt(offset2) !== expectedChar) {
+              if (input.charCodeAt(offset3) !== expectedChar) {
                 this.runConsumed = 0;
                 return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
               }
-              offset2++;
+              offset3++;
               this.excess++;
               this.runConsumed++;
             }
@@ -482,9 +482,9 @@ var init_decode = __esm({
             current2 = decodeTree[this.treeIndex];
             valueLength = (current2 & BinTrieFlags.VALUE_LENGTH) >> 14;
           }
-          if (offset2 >= input.length)
+          if (offset3 >= input.length)
             break;
-          const char = input.charCodeAt(offset2);
+          const char = input.charCodeAt(offset3);
           if (char === CharCodes.SEMI && valueLength !== 0 && (current2 & BinTrieFlags.FLAG13) !== 0) {
             return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
           }
@@ -507,7 +507,7 @@ var init_decode = __esm({
               this.excess = 0;
             }
           }
-          offset2++;
+          offset3++;
           this.excess++;
         }
         return -1;
@@ -856,10 +856,10 @@ var init_Tokenizer = __esm({
       isTagStartChar(c) {
         return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);
       }
-      startSpecial(sequence, offset2) {
+      startSpecial(sequence, offset3) {
         this.isSpecial = true;
         this.currentSequence = sequence;
-        this.sequenceIndex = offset2;
+        this.sequenceIndex = offset3;
         this.state = State.SpecialStartSequence;
       }
       stateBeforeTagName(c) {
@@ -1588,18 +1588,18 @@ var init_Parser = __esm({
         this.startIndex = endIndex + 1;
       }
       /** @internal */
-      oncomment(start, endIndex, offset2) {
+      oncomment(start, endIndex, offset3) {
         var _a3, _b, _c, _d;
         this.endIndex = endIndex;
-        (_b = (_a3 = this.cbs).oncomment) === null || _b === void 0 ? void 0 : _b.call(_a3, this.getSlice(start, endIndex - offset2));
+        (_b = (_a3 = this.cbs).oncomment) === null || _b === void 0 ? void 0 : _b.call(_a3, this.getSlice(start, endIndex - offset3));
         (_d = (_c = this.cbs).oncommentend) === null || _d === void 0 ? void 0 : _d.call(_c);
         this.startIndex = endIndex + 1;
       }
       /** @internal */
-      oncdata(start, endIndex, offset2) {
+      oncdata(start, endIndex, offset3) {
         var _a3, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         this.endIndex = endIndex;
-        const value = this.getSlice(start, endIndex - offset2);
+        const value = this.getSlice(start, endIndex - offset3);
         if (!this.htmlMode || this.options.recognizeCDATA) {
           (_b = (_a3 = this.cbs).oncdatastart) === null || _b === void 0 ? void 0 : _b.call(_a3);
           (_d = (_c = this.cbs).ontext) === null || _d === void 0 ? void 0 : _d.call(_c, value);
@@ -2297,21 +2297,21 @@ function getDecoder(decodeTree) {
   const decoder = new EntityDecoder2(decodeTree, (str) => ret += fromCodePoint2(str));
   return function decodeWithTrie(str, decodeMode) {
     let lastIndex = 0;
-    let offset2 = 0;
-    while ((offset2 = str.indexOf("&", offset2)) >= 0) {
-      ret += str.slice(lastIndex, offset2);
+    let offset3 = 0;
+    while ((offset3 = str.indexOf("&", offset3)) >= 0) {
+      ret += str.slice(lastIndex, offset3);
       decoder.startEntity(decodeMode);
       const len = decoder.write(
         str,
         // Skip the "&"
-        offset2 + 1
+        offset3 + 1
       );
       if (len < 0) {
-        lastIndex = offset2 + decoder.end();
+        lastIndex = offset3 + decoder.end();
         break;
       }
-      lastIndex = offset2 + len;
-      offset2 = len === 0 ? lastIndex + 1 : lastIndex;
+      lastIndex = offset3 + len;
+      offset3 = len === 0 ? lastIndex + 1 : lastIndex;
     }
     const result = ret + str.slice(lastIndex);
     ret = "";
@@ -2415,28 +2415,28 @@ var init_decode2 = __esm({
        * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      write(str, offset2) {
+      write(str, offset3) {
         switch (this.state) {
           case EntityDecoderState2.EntityStart: {
-            if (str.charCodeAt(offset2) === CharCodes3.NUM) {
+            if (str.charCodeAt(offset3) === CharCodes3.NUM) {
               this.state = EntityDecoderState2.NumericStart;
               this.consumed += 1;
-              return this.stateNumericStart(str, offset2 + 1);
+              return this.stateNumericStart(str, offset3 + 1);
             }
             this.state = EntityDecoderState2.NamedEntity;
-            return this.stateNamedEntity(str, offset2);
+            return this.stateNamedEntity(str, offset3);
           }
           case EntityDecoderState2.NumericStart: {
-            return this.stateNumericStart(str, offset2);
+            return this.stateNumericStart(str, offset3);
           }
           case EntityDecoderState2.NumericDecimal: {
-            return this.stateNumericDecimal(str, offset2);
+            return this.stateNumericDecimal(str, offset3);
           }
           case EntityDecoderState2.NumericHex: {
-            return this.stateNumericHex(str, offset2);
+            return this.stateNumericHex(str, offset3);
           }
           case EntityDecoderState2.NamedEntity: {
-            return this.stateNamedEntity(str, offset2);
+            return this.stateNamedEntity(str, offset3);
           }
         }
       }
@@ -2449,17 +2449,17 @@ var init_decode2 = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericStart(str, offset2) {
-        if (offset2 >= str.length) {
+      stateNumericStart(str, offset3) {
+        if (offset3 >= str.length) {
           return -1;
         }
-        if ((str.charCodeAt(offset2) | TO_LOWER_BIT2) === CharCodes3.LOWER_X) {
+        if ((str.charCodeAt(offset3) | TO_LOWER_BIT2) === CharCodes3.LOWER_X) {
           this.state = EntityDecoderState2.NumericHex;
           this.consumed += 1;
-          return this.stateNumericHex(str, offset2 + 1);
+          return this.stateNumericHex(str, offset3 + 1);
         }
         this.state = EntityDecoderState2.NumericDecimal;
-        return this.stateNumericDecimal(str, offset2);
+        return this.stateNumericDecimal(str, offset3);
       }
       addToNumericResult(str, start, end, base2) {
         if (start !== end) {
@@ -2477,18 +2477,18 @@ var init_decode2 = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericHex(str, offset2) {
-        const startIdx = offset2;
-        while (offset2 < str.length) {
-          const char = str.charCodeAt(offset2);
+      stateNumericHex(str, offset3) {
+        const startIdx = offset3;
+        while (offset3 < str.length) {
+          const char = str.charCodeAt(offset3);
           if (isNumber2(char) || isHexadecimalCharacter2(char)) {
-            offset2 += 1;
+            offset3 += 1;
           } else {
-            this.addToNumericResult(str, startIdx, offset2, 16);
+            this.addToNumericResult(str, startIdx, offset3, 16);
             return this.emitNumericEntity(char, 3);
           }
         }
-        this.addToNumericResult(str, startIdx, offset2, 16);
+        this.addToNumericResult(str, startIdx, offset3, 16);
         return -1;
       }
       /**
@@ -2500,18 +2500,18 @@ var init_decode2 = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNumericDecimal(str, offset2) {
-        const startIdx = offset2;
-        while (offset2 < str.length) {
-          const char = str.charCodeAt(offset2);
+      stateNumericDecimal(str, offset3) {
+        const startIdx = offset3;
+        while (offset3 < str.length) {
+          const char = str.charCodeAt(offset3);
           if (isNumber2(char)) {
-            offset2 += 1;
+            offset3 += 1;
           } else {
-            this.addToNumericResult(str, startIdx, offset2, 10);
+            this.addToNumericResult(str, startIdx, offset3, 10);
             return this.emitNumericEntity(char, 2);
           }
         }
-        this.addToNumericResult(str, startIdx, offset2, 10);
+        this.addToNumericResult(str, startIdx, offset3, 10);
         return -1;
       }
       /**
@@ -2556,12 +2556,12 @@ var init_decode2 = __esm({
        * @param offset The current offset.
        * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
        */
-      stateNamedEntity(str, offset2) {
+      stateNamedEntity(str, offset3) {
         const { decodeTree } = this;
         let current2 = decodeTree[this.treeIndex];
         let valueLength = (current2 & BinTrieFlags2.VALUE_LENGTH) >> 14;
-        for (; offset2 < str.length; offset2++, this.excess++) {
-          const char = str.charCodeAt(offset2);
+        for (; offset3 < str.length; offset3++, this.excess++) {
+          const char = str.charCodeAt(offset3);
           this.treeIndex = determineBranch2(decodeTree, current2, this.treeIndex + Math.max(1, valueLength), char);
           if (this.treeIndex < 0) {
             return this.result === 0 || // If we are parsing an attribute
@@ -5023,23 +5023,23 @@ var init_character_data = __esm({
       get length() {
         return this.data.length;
       }
-      substringData(offset2, count) {
-        return this.data.substr(offset2, count);
+      substringData(offset3, count) {
+        return this.data.substr(offset3, count);
       }
       appendData(data2) {
         this.data += data2;
       }
-      insertData(offset2, data2) {
+      insertData(offset3, data2) {
         const { data: t } = this;
-        this.data = t.slice(0, offset2) + data2 + t.slice(offset2);
+        this.data = t.slice(0, offset3) + data2 + t.slice(offset3);
       }
-      deleteData(offset2, count) {
+      deleteData(offset3, count) {
         const { data: t } = this;
-        this.data = t.slice(0, offset2) + t.slice(offset2 + count);
+        this.data = t.slice(0, offset3) + t.slice(offset3 + count);
       }
-      replaceData(offset2, count, data2) {
+      replaceData(offset3, count, data2) {
         const { data: t } = this;
-        this.data = t.slice(0, offset2) + data2 + t.slice(offset2 + count);
+        this.data = t.slice(0, offset3) + data2 + t.slice(offset3 + count);
       }
       /* c8 ignore stop */
       toJSON() {
@@ -5186,17 +5186,17 @@ function parse(selector) {
 }
 function parseSelector(subselects2, selector, selectorIndex) {
   let tokens = [];
-  function getName3(offset2) {
-    const match = selector.slice(selectorIndex + offset2).match(reName);
+  function getName3(offset3) {
+    const match = selector.slice(selectorIndex + offset3).match(reName);
     if (!match) {
       throw new Error(`Expected name, found ${selector.slice(selectorIndex)}`);
     }
     const [name] = match;
-    selectorIndex += offset2 + name.length;
+    selectorIndex += offset3 + name.length;
     return unescapeCSS(name);
   }
-  function stripWhitespace(offset2) {
-    selectorIndex += offset2;
+  function stripWhitespace(offset3) {
+    selectorIndex += offset3;
     while (selectorIndex < selector.length && isWhitespace2(selector.charCodeAt(selectorIndex))) {
       selectorIndex++;
     }
@@ -14223,9 +14223,9 @@ var require_path = __commonJS({
       };
       function emptyMoves() {
       }
-      function getMoves(path, offset2, start, end) {
+      function getMoves(path, offset3, start, end) {
         isArray3.assert(path.value);
-        if (offset2 === 0) {
+        if (offset3 === 0) {
           return emptyMoves;
         }
         var length = path.value.length;
@@ -14253,7 +14253,7 @@ var require_path = __commonJS({
             if (childPath.name !== i) {
               throw new Error("");
             }
-            var newIndex = i + offset2;
+            var newIndex = i + offset3;
             childPath.name = newIndex;
             moves[newIndex] = childPath;
             delete cache2[i];
@@ -18177,13 +18177,13 @@ var require_source_map_consumer = __commonJS({
         if (s.url) {
           throw new Error("Support for url field in sections not implemented.");
         }
-        var offset2 = util.getArg(s, "offset");
-        var offsetLine = util.getArg(offset2, "line");
-        var offsetColumn = util.getArg(offset2, "column");
+        var offset3 = util.getArg(s, "offset");
+        var offsetLine = util.getArg(offset3, "line");
+        var offsetColumn = util.getArg(offset3, "column");
         if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
           throw new Error("Section offsets must be ordered and non-overlapping.");
         }
-        lastOffset = offset2;
+        lastOffset = offset3;
         return {
           generatedOffset: {
             // The offset fields are 0-based, but we use 1-based indices when
@@ -23628,16 +23628,16 @@ var require_esprima2 = __commonJS({
                 }
                 this.errorHandler.tolerateError(this.index, this.lineNumber, this.index - this.lineStart + 1, message);
               };
-              Scanner2.prototype.skipSingleLineComment = function(offset2) {
+              Scanner2.prototype.skipSingleLineComment = function(offset3) {
                 var comments = [];
                 var start, loc;
                 if (this.trackComment) {
                   comments = [];
-                  start = this.index - offset2;
+                  start = this.index - offset3;
                   loc = {
                     start: {
                       line: this.lineNumber,
-                      column: this.index - this.lineStart - offset2
+                      column: this.index - this.lineStart - offset3
                     },
                     end: {}
                   };
@@ -23653,7 +23653,7 @@ var require_esprima2 = __commonJS({
                       };
                       var entry = {
                         multiLine: false,
-                        slice: [start + offset2, this.index - 1],
+                        slice: [start + offset3, this.index - 1],
                         range: [start, this.index - 1],
                         loc
                       };
@@ -23674,7 +23674,7 @@ var require_esprima2 = __commonJS({
                   };
                   var entry = {
                     multiLine: false,
-                    slice: [start + offset2, this.index],
+                    slice: [start + offset3, this.index],
                     range: [start, this.index],
                     loc
                   };
@@ -44193,11 +44193,11 @@ function codePointToString(code) {
   code -= 65536;
   return String.fromCharCode((code >> 10) + 55296, (code & 1023) + 56320);
 }
-function getLineInfo(input, offset2) {
+function getLineInfo(input, offset3) {
   for (var line = 1, cur = 0; ; ) {
-    var nextBreak = nextLineBreak(input, cur, offset2);
+    var nextBreak = nextLineBreak(input, cur, offset3);
     if (nextBreak < 0) {
-      return new Position(line, offset2 - cur);
+      return new Position(line, offset3 - cur);
     }
     ++line;
     cur = nextBreak;
@@ -52939,16 +52939,16 @@ function readAscii(bytes, start, length) {
   }
   return value;
 }
-function readU16LE(bytes, offset2) {
-  if (offset2 + 1 >= bytes.length)
+function readU16LE(bytes, offset3) {
+  if (offset3 + 1 >= bytes.length)
     return null;
-  return (bytes[offset2] ?? 0) | (bytes[offset2 + 1] ?? 0) << 8;
+  return (bytes[offset3] ?? 0) | (bytes[offset3 + 1] ?? 0) << 8;
 }
 function colorTableByteLength(packed) {
   return 3 * 2 ** ((packed & 7) + 1);
 }
-function skipSubBlocks(bytes, offset2) {
-  let pos = offset2;
+function skipSubBlocks(bytes, offset3) {
+  let pos = offset3;
   while (pos < bytes.length) {
     const size = bytes[pos];
     if (size === void 0)
@@ -52960,12 +52960,12 @@ function skipSubBlocks(bytes, offset2) {
   }
   return null;
 }
-function parseApplicationExtension(bytes, offset2) {
-  const blockSize = bytes[offset2];
-  if (blockSize === void 0 || offset2 + 1 + blockSize > bytes.length)
+function parseApplicationExtension(bytes, offset3) {
+  const blockSize = bytes[offset3];
+  if (blockSize === void 0 || offset3 + 1 + blockSize > bytes.length)
     return null;
-  const appId = readAscii(bytes, offset2 + 1, blockSize);
-  let pos = offset2 + 1 + blockSize;
+  const appId = readAscii(bytes, offset3 + 1, blockSize);
+  let pos = offset3 + 1 + blockSize;
   let loopCount = null;
   while (pos < bytes.length) {
     const size = bytes[pos];
@@ -54400,6 +54400,588 @@ var init_canaryRegistry = __esm({
   }
 });
 
+// ../core/dist/vfx/fractalNoise.frag.js
+var HASH_CONSTANTS, mulX, mulY, mulMix, offset2, shift1, shift2, divisor, MAX_OCTAVES, FRACTAL_NOISE_FRAG;
+var init_fractalNoise_frag = __esm({
+  "../core/dist/vfx/fractalNoise.frag.js"() {
+    "use strict";
+    HASH_CONSTANTS = {
+      /** Odd 32-bit multipliers, one per lattice axis plus one for the seed. */
+      mulX: 374761393,
+      mulY: 668265263,
+      mulMix: 1274126177,
+      /** 2^32/φ — breaks the all-zero fixed point at lattice corner (0, 0). */
+      offset: 2654435769,
+      shift1: 13,
+      shift2: 16,
+      /** 2^32: maps the mixed 32-bit word into [0, 1). */
+      divisor: 4294967296
+    };
+    ({ mulX, mulY, mulMix, offset: offset2, shift1, shift2, divisor } = HASH_CONSTANTS);
+    MAX_OCTAVES = 20;
+    FRACTAL_NOISE_FRAG = `#version 300 es
+precision highp float;
+precision highp int;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform vec2 u_size;
+uniform float u_t;
+uniform float u_fps;
+uniform float u_fractalType;
+uniform float u_noiseType;
+uniform float u_invert;
+uniform float u_contrast;
+uniform float u_brightness;
+uniform float u_scale;
+uniform float u_complexity;
+uniform float u_subInfluence;
+uniform float u_subScaling;
+uniform float u_evolution;
+uniform float u_randomSeed;
+uniform float u_opacity;
+
+float hfHashUnit(int ix, int iy, int seed) {
+  uint h = ((uint(ix) * ${mulX}u) ^ (uint(iy) * ${mulY}u) ^ (uint(seed) * ${mulMix}u)) + ${offset2}u;
+  h = h ^ (h >> ${shift1}u);
+  h = h * ${mulMix}u;
+  h = h ^ (h >> ${shift2}u);
+  return float(h) / ${divisor}.0;
+}
+
+float hfFade(float f, float noiseType) {
+  if (noiseType < 1.5) return 0.0;
+  if (noiseType < 2.5) return f;
+  if (noiseType < 3.5) return f * f * (3.0 - 2.0 * f);
+  return f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+}
+
+float hfValueNoise(vec2 p, int seed) {
+  vec2 cell = floor(p);
+  vec2 f = p - cell;
+  int ix = int(cell.x);
+  int iy = int(cell.y);
+  float sx = hfFade(f.x, u_noiseType);
+  float sy = hfFade(f.y, u_noiseType);
+  float bottom = mix(hfHashUnit(ix, iy, seed), hfHashUnit(ix + 1, iy, seed), sx);
+  float top = mix(hfHashUnit(ix, iy + 1, seed), hfHashUnit(ix + 1, iy + 1, seed), sx);
+  return mix(bottom, top, sy);
+}
+
+float hfFbm(vec2 p) {
+  float lacunarity = 100.0 / max(u_subScaling, 1.0);
+  float gain = u_subInfluence / 100.0;
+  int seed = int(u_randomSeed);
+  float amp = 1.0;
+  float freq = 1.0;
+  float sum = 0.0;
+  float norm = 0.0;
+  for (int i = 0; i < ${MAX_OCTAVES}; i++) {
+    if (float(i) >= u_complexity) break;
+    sum += amp * hfValueNoise(p * freq, seed + i);
+    norm += amp;
+    amp *= gain;
+    freq *= lacunarity;
+  }
+  return norm > 0.0 ? sum / norm : 0.0;
+}
+
+void main() {
+  vec2 px = v_uv * u_size;
+  vec2 p = px / max(u_scale, 1.0) + vec2(u_evolution, u_evolution * 0.5);
+  float v = hfFbm(p);
+  v = (v - 0.5) * (u_contrast / 100.0) + 0.5 + u_brightness / 100.0;
+  if (u_invert > 0.5) v = 1.0 - v;
+  v = clamp(v, 0.0, 1.0);
+  float a = clamp(u_opacity / 100.0, 0.0, 1.0);
+  fragColor = vec4(v * a, v * a, v * a, a);
+}
+`;
+  }
+});
+
+// ../core/dist/vfx/displacementMap.frag.js
+var DISPLACEMENT_MAP_CONSTANTS, lumaR, lumaG, lumaB, DISPLACEMENT_MAP_FRAG;
+var init_displacementMap_frag = __esm({
+  "../core/dist/vfx/displacementMap.frag.js"() {
+    "use strict";
+    DISPLACEMENT_MAP_CONSTANTS = {
+      lumaR: 0.299,
+      lumaG: 0.587,
+      lumaB: 0.114
+    };
+    ({ lumaR, lumaG, lumaB } = DISPLACEMENT_MAP_CONSTANTS);
+    DISPLACEMENT_MAP_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform vec2 u_size;
+uniform float u_t;
+uniform float u_fps;
+uniform sampler2D u_src;
+uniform float u_useH;
+uniform float u_maxH;
+uniform float u_useV;
+uniform float u_maxV;
+uniform float u_behavior;
+uniform float u_edge;
+uniform float u_expand;
+
+vec4 hfSampleSrc(vec2 uv) {
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return vec4(0.0);
+  return texture(u_src, uv);
+}
+
+// The selector's value, in [0, 1]. Half and Off both land on 0.5, which is the
+// "no displacement" midpoint the caller subtracts.
+float hfMapChannel(vec4 premultiplied, float selector) {
+  vec3 rgb = premultiplied.a > 0.0 ? premultiplied.rgb / premultiplied.a : vec3(0.0);
+  if (selector < 1.5) return rgb.r;
+  if (selector < 2.5) return rgb.g;
+  if (selector < 3.5) return rgb.b;
+  if (selector < 4.5) return premultiplied.a;
+  if (selector < 8.5) return dot(rgb, vec3(${lumaR}, ${lumaG}, ${lumaB}));
+  if (selector < 9.5) return 1.0;
+  return 0.5;
+}
+
+void main() {
+  vec4 mapTexel = texture(u_src, v_uv);
+  float h = hfMapChannel(mapTexel, u_useH);
+  float v = hfMapChannel(mapTexel, u_useV);
+  vec2 d = vec2((h - 0.5) * 2.0 * u_maxH, (v - 0.5) * 2.0 * u_maxV);
+  fragColor = hfSampleSrc(v_uv + d / u_size);
+}
+`;
+  }
+});
+
+// ../core/dist/vfx/waveWarp.frag.js
+var WAVE_WARP_CONSTANTS, tau, degreesPerTurn, WAVE_WARP_FRAG;
+var init_waveWarp_frag = __esm({
+  "../core/dist/vfx/waveWarp.frag.js"() {
+    "use strict";
+    WAVE_WARP_CONSTANTS = {
+      tau: 6.283185307179586,
+      degreesPerTurn: 360
+    };
+    ({ tau, degreesPerTurn } = WAVE_WARP_CONSTANTS);
+    WAVE_WARP_FRAG = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform vec2 u_size;
+uniform float u_t;
+uniform float u_fps;
+uniform sampler2D u_src;
+uniform float u_waveType;
+uniform float u_height;
+uniform float u_width;
+uniform float u_direction;
+uniform float u_speed;
+uniform float u_pinning;
+uniform float u_phase;
+
+// Outside the layer's own box there is nothing to warp in from, so the wave
+// carries transparency rather than a smeared edge pixel.
+vec4 hfSampleSrc(vec2 uv) {
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return vec4(0.0);
+  return texture(u_src, uv);
+}
+
+void main() {
+  vec2 px = v_uv * u_size;
+  float dir = radians(u_direction);
+  vec2 travel = vec2(sin(dir), -cos(dir));
+  vec2 swing = vec2(-travel.y, travel.x);
+  float proj = (px.x + 1.0) * travel.x + px.y * travel.y;
+  float turns = proj / max(u_width, 1.0) + u_phase / ${degreesPerTurn}.0 + u_speed * u_t;
+  float disp = u_height * sin(${tau} * turns);
+  fragColor = hfSampleSrc((px + swing * disp) / u_size);
+}
+`;
+  }
+});
+
+// ../core/dist/vfx.js
+function enabledVfxNodes(chain) {
+  return chain.nodes.filter((n) => n.enabled !== false);
+}
+function chainCapture(chain) {
+  let best = "none";
+  for (const node of enabledVfxNodes(chain)) {
+    const def = BY_ID2.get(node.type);
+    if (def && CAPTURE_RANK[def.capture] > CAPTURE_RANK[best])
+      best = def.capture;
+  }
+  return best;
+}
+function parseVfxChain(json) {
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch (err) {
+    throw new VfxChainError(`Chain file is not valid JSON: ${err.message}`);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new VfxChainError("Chain file must be a JSON object.");
+  }
+  const obj = raw;
+  if (obj.version !== HF_VFX_CHAIN_VERSION) {
+    throw new VfxChainError(`Unsupported chain version: ${String(obj.version)}`);
+  }
+  if (!Array.isArray(obj.nodes)) {
+    throw new VfxChainError("Chain file is missing a `nodes` array.");
+  }
+  const nodes = obj.nodes.map(parseVfxNode);
+  return { version: HF_VFX_CHAIN_VERSION, nodes };
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null;
+}
+function requireVfxNodeType(node, i) {
+  if (typeof node.type !== "string" || !BY_ID2.has(node.type)) {
+    throw new VfxChainError(`Node ${i} has unknown effect type: ${String(node.type)}`);
+  }
+  return node.type;
+}
+function requireVfxNodeId(node, i) {
+  if (typeof node.id !== "string" || node.id === "") {
+    throw new VfxChainError(`Node ${i} is missing an id.`);
+  }
+  return node.id;
+}
+function parseVfxNode(n, i) {
+  if (!isPlainObject(n)) {
+    throw new VfxChainError(`Node ${i} is not an object.`);
+  }
+  const node = n;
+  const type = requireVfxNodeType(node, i);
+  const id = requireVfxNodeId(node, i);
+  const params = isPlainObject(node.params) ? node.params : {};
+  return withoutUndefined2({
+    type,
+    id,
+    enabled: node.enabled === false ? false : void 0,
+    params
+  });
+}
+function withoutUndefined2(obj) {
+  for (const key2 of Object.keys(obj)) {
+    if (obj[key2] === void 0)
+      delete obj[key2];
+  }
+  return obj;
+}
+var HF_VFX_ATTR, HF_VFX_CHAIN_VERSION, DISPLACEMENT_CHANNELS, HF_VFX, BY_ID2, VfxChainError, CAPTURE_RANK;
+var init_vfx = __esm({
+  "../core/dist/vfx.js"() {
+    "use strict";
+    init_fractalNoise_frag();
+    init_displacementMap_frag();
+    init_waveWarp_frag();
+    HF_VFX_ATTR = "data-vfx-chain";
+    HF_VFX_CHAIN_VERSION = 1;
+    DISPLACEMENT_CHANNELS = [
+      { value: 1, label: "Red" },
+      { value: 2, label: "Green" },
+      { value: 3, label: "Blue" },
+      { value: 4, label: "Alpha" },
+      { value: 5, label: "Luminance" },
+      { value: 6, label: "Hue" },
+      { value: 7, label: "Lightness" },
+      { value: 8, label: "Saturation" },
+      { value: 9, label: "Full" },
+      { value: 10, label: "Half" },
+      { value: 11, label: "Off" }
+    ];
+    HF_VFX = [
+      {
+        id: "fractal-noise",
+        label: "Fractal Noise",
+        ae: "ADBE Fractal Noise",
+        capture: "none",
+        frag: FRACTAL_NOISE_FRAG,
+        params: [
+          {
+            kind: "enum",
+            key: "fractalType",
+            label: "Fractal Type",
+            options: [{ value: 1, label: "Basic" }],
+            default: 1,
+            hint: "Only Basic is implemented in v1."
+          },
+          {
+            kind: "enum",
+            key: "noiseType",
+            label: "Noise Type",
+            options: [
+              { value: 1, label: "Block" },
+              { value: 2, label: "Linear" },
+              { value: 3, label: "Soft Linear" },
+              { value: 4, label: "Spline" }
+            ],
+            default: 3
+          },
+          { kind: "bool", key: "invert", label: "Invert", default: false },
+          {
+            kind: "number",
+            key: "contrast",
+            label: "Contrast",
+            unit: "%",
+            min: 0,
+            max: 1e3,
+            step: 1,
+            default: 100
+          },
+          {
+            kind: "number",
+            key: "brightness",
+            label: "Brightness",
+            unit: "",
+            min: -1e3,
+            max: 1e3,
+            step: 1,
+            default: 0
+          },
+          {
+            kind: "number",
+            key: "scale",
+            label: "Scale",
+            unit: "%",
+            min: 6,
+            max: 1e4,
+            step: 1,
+            default: 100
+          },
+          {
+            kind: "number",
+            key: "complexity",
+            label: "Complexity",
+            unit: "",
+            min: 1,
+            max: 20,
+            step: 1,
+            default: 6
+          },
+          {
+            kind: "number",
+            key: "subInfluence",
+            label: "Sub Influence",
+            unit: "%",
+            min: 0,
+            max: 100,
+            step: 1,
+            default: 70
+          },
+          {
+            kind: "number",
+            key: "subScaling",
+            label: "Sub Scaling",
+            unit: "%",
+            min: 0,
+            max: 100,
+            step: 1,
+            default: 56
+          },
+          {
+            kind: "number",
+            key: "evolution",
+            label: "Evolution",
+            unit: "revolutions",
+            min: -1e4,
+            max: 1e4,
+            step: 0.01,
+            default: 0,
+            animatable: true
+          },
+          {
+            kind: "number",
+            key: "randomSeed",
+            label: "Random Seed",
+            unit: "",
+            min: 0,
+            max: 99999,
+            step: 1,
+            default: 0
+          },
+          {
+            kind: "number",
+            key: "opacity",
+            label: "Opacity",
+            unit: "%",
+            min: 0,
+            max: 100,
+            step: 1,
+            default: 100,
+            animatable: true
+          }
+        ]
+      },
+      {
+        id: "wave-warp",
+        label: "Wave Warp",
+        ae: "ADBE Wave Warp",
+        capture: "self",
+        frag: WAVE_WARP_FRAG,
+        params: [
+          {
+            kind: "enum",
+            key: "waveType",
+            label: "Wave Type",
+            options: [{ value: 1, label: "Sine" }],
+            default: 1,
+            hint: "Only Sine is implemented in v1; the exporter marks the others cosmetic."
+          },
+          {
+            kind: "number",
+            key: "height",
+            label: "Wave Height",
+            unit: "px",
+            min: -1e3,
+            max: 1e3,
+            step: 1,
+            default: 10,
+            animatable: true
+          },
+          {
+            kind: "number",
+            key: "width",
+            label: "Wave Width",
+            unit: "px",
+            min: 1,
+            max: 1e4,
+            step: 1,
+            default: 40,
+            animatable: true
+          },
+          {
+            kind: "number",
+            key: "direction",
+            label: "Direction",
+            unit: "deg",
+            min: -360,
+            max: 360,
+            step: 1,
+            default: 90
+          },
+          {
+            kind: "number",
+            key: "speed",
+            label: "Wave Speed",
+            unit: "waves/s",
+            min: -100,
+            max: 100,
+            step: 0.1,
+            default: 1
+          },
+          {
+            kind: "enum",
+            key: "pinning",
+            label: "Pinning",
+            options: [{ value: 1, label: "None" }],
+            default: 1,
+            hint: "Only None is implemented in v1; the exporter marks the others cosmetic."
+          },
+          {
+            kind: "number",
+            key: "phase",
+            label: "Phase",
+            unit: "deg",
+            min: -360,
+            max: 360,
+            step: 1,
+            default: 0,
+            animatable: true
+          }
+        ]
+      },
+      {
+        id: "displacement-map",
+        label: "Displacement Map",
+        ae: "ADBE Displacement Map",
+        capture: "self",
+        frag: DISPLACEMENT_MAP_FRAG,
+        params: [
+          {
+            kind: "enum",
+            key: "useH",
+            label: "Use For Horizontal Displacement",
+            options: DISPLACEMENT_CHANNELS,
+            default: 1,
+            hint: "Hue, Lightness and Saturation are read as Luminance in v1."
+          },
+          {
+            kind: "number",
+            key: "maxH",
+            label: "Max Horizontal Displacement",
+            unit: "px",
+            min: -32e3,
+            max: 32e3,
+            step: 1,
+            default: 5,
+            animatable: true
+          },
+          {
+            kind: "enum",
+            key: "useV",
+            label: "Use For Vertical Displacement",
+            options: DISPLACEMENT_CHANNELS,
+            default: 2,
+            hint: "Hue, Lightness and Saturation are read as Luminance in v1."
+          },
+          {
+            kind: "number",
+            key: "maxV",
+            label: "Max Vertical Displacement",
+            unit: "px",
+            min: -32e3,
+            max: 32e3,
+            step: 1,
+            default: 5,
+            animatable: true
+          },
+          {
+            kind: "enum",
+            key: "behavior",
+            label: "Displacement Map Behavior",
+            options: [{ value: 1, label: "Center Map" }],
+            default: 1,
+            hint: "Only Center Map is implemented in v1."
+          },
+          {
+            kind: "enum",
+            key: "edge",
+            label: "Edge Behavior",
+            options: [{ value: 0, label: "Off" }],
+            default: 0,
+            hint: "Only Off (transparent outside the layer) is implemented in v1."
+          },
+          {
+            kind: "bool",
+            key: "expand",
+            label: "Expand Output",
+            default: true
+          }
+        ]
+      }
+    ];
+    BY_ID2 = new Map(HF_VFX.map((d) => [d.id, d]));
+    VfxChainError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "VfxChainError";
+      }
+    };
+    CAPTURE_RANK = { none: 0, self: 1, backdrop: 2 };
+  }
+});
+
 // ../core/dist/index.js
 var init_dist2 = __esm({
   "../core/dist/index.js"() {
@@ -54444,6 +55026,7 @@ var init_dist2 = __esm({
     init_registry();
     init_canary();
     init_canaryRegistry();
+    init_vfx();
   }
 });
 
@@ -54645,7 +55228,7 @@ var init_vp9Options = __esm({
 // ../engine/src/config.ts
 import { tmpdir } from "os";
 import { join as join3 } from "path";
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value));
 }
 function assertEngineConfigNumber(config, field, min, integer = false) {
@@ -54714,7 +55297,7 @@ function validateEngineConfigRuntime(config) {
 }
 function validateEngineConfigHdr(config) {
   const { hdr } = config;
-  if (hdr !== false && (!isPlainObject(hdr) || Object.keys(hdr).length !== 1 || hdr.transfer !== "hlg" && hdr.transfer !== "pq")) {
+  if (hdr !== false && (!isPlainObject2(hdr) || Object.keys(hdr).length !== 1 || hdr.transfer !== "hlg" && hdr.transfer !== "pq")) {
     throw new Error("Engine config hdr must be false or an hlg/pq transfer object");
   }
 }
@@ -54738,7 +55321,7 @@ function validateOptionalEngineConfigFields(config) {
   }
 }
 function validateEngineConfigSnapshot(value) {
-  if (!isPlainObject(value)) throw new Error("Engine config snapshot must be a plain object");
+  if (!isPlainObject2(value)) throw new Error("Engine config snapshot must be a plain object");
   validateRequiredEngineConfigFields(value);
   validateEngineConfigScalars(value);
   validateEngineConfigParallelism(value);
@@ -55119,17 +55702,22 @@ var BrowserLeasePool;
 var init_browserLeasePool = __esm({
   "../engine/src/services/browserLeasePool.ts"() {
     "use strict";
-    BrowserLeasePool = class {
+    BrowserLeasePool = class _BrowserLeasePool {
       constructor(options) {
         this.options = options;
       }
       options;
+      /** Under the CLI's 3s exit watchdog, alongside the render-wait bound it races. */
+      static DRAIN_FORCE_CLOSE_MS = 1e3;
       available = /* @__PURE__ */ new Map();
       entries = /* @__PURE__ */ new Set();
       leasesByBrowser = /* @__PURE__ */ new Map();
       drainPromise = null;
+      closed = false;
       async acquire(fingerprintInput, pooled) {
+        if (this.closed) throw new Error("Browser pool is closed; no new browsers can be acquired");
         if (this.drainPromise) await this.drainPromise;
+        if (this.closed) throw new Error("Browser pool is closed; no new browsers can be acquired");
         const fingerprint = freezeFingerprint(fingerprintInput);
         const entry = this.reserveEntry(fingerprint, pooled);
         return this.issueLease(entry);
@@ -55188,17 +55776,30 @@ var init_browserLeasePool = __esm({
         if (this.drainPromise) return this.drainPromise;
         const entries2 = [...this.entries];
         for (const entry of entries2) this.requestClose(entry, false);
-        this.drainPromise = Promise.all(entries2.map((entry) => entry.closePromise)).then(() => {
+        const settle = Promise.all(entries2.map((entry) => entry.closePromise));
+        const bound = new Promise(
+          (resolve18) => setTimeout(resolve18, _BrowserLeasePool.DRAIN_FORCE_CLOSE_MS).unref()
+        );
+        this.drainPromise = Promise.race([settle, bound]).then(() => {
+          for (const entry of entries2) if (this.entries.has(entry)) this.requestClose(entry, true);
+          return settle;
+        }).then(() => {
           this.drainPromise = null;
         });
         return this.drainPromise;
       }
+      /** Terminal: drains every entry and refuses every `acquire()` after. */
+      close() {
+        this.closed = true;
+        return this.drain();
+      }
       /** Test-only state reset. Call `drain()` first when entries own real browsers. */
       reset() {
         this.available.clear();
         this.entries.clear();
         this.leasesByBrowser.clear();
         this.drainPromise = null;
+        this.closed = false;
       }
       createEntry(key2, fingerprint, pooled) {
         const entry = {
@@ -55732,6 +56333,9 @@ function forceReleaseBrowser(browser) {
 async function drainBrowserPool() {
   await browserLeasePool.drain();
 }
+async function closeBrowserPool() {
+  await browserLeasePool.close();
+}
 function probeNvidiaVramMb() {
   if (_cachedVramMb !== null) return _cachedVramMb;
   try {
@@ -56695,7 +57299,7 @@ function motionBlurSampleTimes(plan2, frameIndex, fps, samplesPerFrame) {
   const grid = fps * plan2.subFrameDivisions;
   const frameTicks = frameIndex * plan2.subFrameDivisions;
   return sampleTickOffsets(plan2, samplesPerFrame).map(
-    (offset2) => Math.max(0, frameTicks + offset2) / grid
+    (offset3) => Math.max(0, frameTicks + offset3) / grid
   );
 }
 function motionBlurProbeTimes(plan2, frameIndex, fps) {
@@ -60598,14 +61202,14 @@ async function computeStaticFrameSet(page, fps) {
     const intervals2 = [];
     let tweenCount2 = 0;
     let hasTimelineCall2 = false;
-    function walk(tl, offset2) {
+    function walk(tl, offset3) {
       if (typeof tl.getChildren !== "function") return;
       if (typeof tl.vars?.onUpdate === "function") {
         const total = typeof tl.totalDuration === "function" ? tl.totalDuration() : 0;
-        if (total > 0) intervals2.push({ start: offset2, end: offset2 + total, spatial: true });
+        if (total > 0) intervals2.push({ start: offset3, end: offset3 + total, spatial: true });
       }
       for (const child of tl.getChildren(false, true, true)) {
-        const start = offset2 + (typeof child.startTime === "function" ? child.startTime() : 0);
+        const start = offset3 + (typeof child.startTime === "function" ? child.startTime() : 0);
         const single = typeof child.duration === "function" ? child.duration() : 0;
         const total = typeof child.totalDuration === "function" ? child.totalDuration() : single;
         if (typeof child.getChildren === "function") {
@@ -61033,10 +61637,10 @@ async function computeTimelineAtRiskFrames(page, fps) {
       "maskImage",
       "mask"
     ]);
-    function walkTimeline(tl, offset2, out) {
+    function walkTimeline(tl, offset3, out) {
       if (typeof tl.getChildren !== "function") return;
       for (const child of tl.getChildren(false, true, true)) {
-        const childStart = offset2 + (typeof child.startTime === "function" ? child.startTime() : 0);
+        const childStart = offset3 + (typeof child.startTime === "function" ? child.startTime() : 0);
         const childDur = typeof child.duration === "function" ? child.duration() : 0;
         if (typeof child.getChildren === "function") {
           walkTimeline(child, childStart, out);
@@ -62372,8 +62976,8 @@ function redactFfprobeInput(stderr, filePath) {
   const inputBasename = basename2(filePath);
   if (inputBasename) redacted = redacted.split(inputBasename).join("[input]");
   if (!redacted.startsWith("[input]")) {
-    for (let offset2 = 1; offset2 < filePath.length; offset2 += 1) {
-      const suffix = filePath.slice(offset2);
+    for (let offset3 = 1; offset3 < filePath.length; offset3 += 1) {
+      const suffix = filePath.slice(offset3);
       if (suffix.length < 4 || !redacted.startsWith(suffix)) continue;
       const boundary = redacted[suffix.length];
       if (boundary !== void 0 && !/[\s:'")\]}]/.test(boundary)) continue;
@@ -62468,8 +63072,8 @@ async function hasAvifFileBrand(filePath) {
     if (boxSize < 16 || boxSize > bytes.length) return false;
     const avifBrands = /* @__PURE__ */ new Set(["avif", "avis"]);
     if (avifBrands.has(bytes.toString("ascii", 8, 12))) return true;
-    for (let offset2 = 16; offset2 + 4 <= boxSize; offset2 += 4) {
-      if (avifBrands.has(bytes.toString("ascii", offset2, offset2 + 4))) return true;
+    for (let offset3 = 16; offset3 + 4 <= boxSize; offset3 += 4) {
+      if (avifBrands.has(bytes.toString("ascii", offset3, offset3 + 4))) return true;
     }
     return false;
   } catch {
@@ -62551,20 +63155,20 @@ async function hasCompletePngStructure(filePath, signal) {
     }
     let seenHeader = false;
     let seenImageData = false;
-    let offset2 = 8;
-    while (offset2 + 12 <= fileSize) {
+    let offset3 = 8;
+    while (offset3 + 12 <= fileSize) {
       signal?.throwIfAborted();
-      const chunkHeader = await readFileRange(filePath, offset2, 8, signal);
+      const chunkHeader = await readFileRange(filePath, offset3, 8, signal);
       signal?.throwIfAborted();
       if (chunkHeader.length !== 8) return false;
       const chunkLength = chunkHeader.readUInt32BE(0);
-      const chunkEnd = offset2 + 12 + chunkLength;
+      const chunkEnd = offset3 + 12 + chunkLength;
       if (chunkEnd > fileSize) return false;
       const chunkType = chunkHeader.toString("ascii", 4, 8);
-      if (chunkType === "IHDR") seenHeader = chunkLength === 13 && offset2 === 8;
+      if (chunkType === "IHDR") seenHeader = chunkLength === 13 && offset3 === 8;
       if (chunkType === "IDAT") seenImageData = true;
       if (chunkType === "IEND") return seenHeader && seenImageData && chunkLength === 0;
-      offset2 = chunkEnd;
+      offset3 = chunkEnd;
     }
     return false;
   } catch (error) {
@@ -62755,11 +63359,19 @@ async function extractMediaMetadata(filePath) {
   });
   return probePromise;
 }
+function resolveStreamWindow(filePath, metadata) {
+  const videoStreamDurationSeconds = metadata.videoStreamDurationSeconds;
+  const candidateStart = metadata.videoStreamStartSeconds ?? 0;
+  const videoStreamStartSeconds = Number.isFinite(candidateStart) ? candidateStart : 0;
+  const cacheKey = `${filePath}\0${String(videoStreamStartSeconds)}\0${String(videoStreamDurationSeconds)}`;
+  return { videoStreamStartSeconds, videoStreamDurationSeconds, cacheKey };
+}
 async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
-  const videoDurationSeconds = metadata.videoStreamDurationSeconds;
-  const candidateStreamStart = metadata.videoStreamStartSeconds ?? 0;
-  const videoStreamStartSeconds = Number.isFinite(candidateStreamStart) ? candidateStreamStart : 0;
-  const cacheKey = `${filePath}\0${String(videoStreamStartSeconds)}\0${String(videoDurationSeconds)}`;
+  const {
+    videoStreamStartSeconds,
+    videoStreamDurationSeconds: videoDurationSeconds,
+    cacheKey
+  } = resolveStreamWindow(filePath, metadata);
   let probeCache = finalVideoFrameTimestampCache;
   if (signal) {
     probeCache = finalVideoFrameTimestampSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
@@ -62862,19 +63474,27 @@ async function extractAudioMetadata(filePath, options) {
   });
   return probePromise;
 }
-async function analyzeKeyframeIntervals(filePath) {
-  const cached2 = keyframeCache.get(filePath);
+async function analyzeKeyframeIntervals(filePath, metadata) {
+  const { videoStreamStartSeconds, videoStreamDurationSeconds, cacheKey } = resolveStreamWindow(
+    filePath,
+    metadata
+  );
+  const cached2 = keyframeCache.get(cacheKey);
   if (cached2) return cached2;
-  const promise = analyzeKeyframeIntervalsUncached(filePath);
-  keyframeCache.set(filePath, promise);
+  const promise = analyzeKeyframeIntervalsUncached(
+    filePath,
+    videoStreamStartSeconds,
+    videoStreamDurationSeconds
+  );
+  keyframeCache.set(cacheKey, promise);
   promise.catch(() => {
-    if (keyframeCache.get(filePath) === promise) {
-      keyframeCache.delete(filePath);
+    if (keyframeCache.get(cacheKey) === promise) {
+      keyframeCache.delete(cacheKey);
     }
   });
   return promise;
 }
-async function analyzeKeyframeIntervalsUncached(filePath) {
+async function analyzeKeyframeIntervalsUncached(filePath, videoStreamStartSeconds, videoStreamDurationSeconds) {
   const stdout = await runFfprobe(filePath, [
     "-select_streams",
     "v:0",
@@ -62886,14 +63506,26 @@ async function analyzeKeyframeIntervalsUncached(filePath) {
     "csv=p=0"
   ]);
   const timestamps = stdout.split("\n").map((line) => parseFloat(line.trim())).filter((t) => Number.isFinite(t));
-  if (timestamps.length < 2) {
+  if (timestamps.length === 0) {
     return {
       avgIntervalSeconds: 0,
       maxIntervalSeconds: 0,
-      keyframeCount: timestamps.length,
+      keyframeCount: 0,
       isProblematic: false
     };
   }
+  if (timestamps.length === 1) {
+    const streamEnd = videoStreamStartSeconds + videoStreamDurationSeconds;
+    const rawInterval = streamEnd - (timestamps[0] ?? videoStreamStartSeconds);
+    const singleGopInterval = Number.isFinite(rawInterval) ? Math.max(rawInterval, 0) : 0;
+    const roundedInterval = Math.round(singleGopInterval * 100) / 100;
+    return {
+      avgIntervalSeconds: roundedInterval,
+      maxIntervalSeconds: roundedInterval,
+      keyframeCount: 1,
+      isProblematic: singleGopInterval > PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS
+    };
+  }
   let maxInterval = 0;
   let totalInterval = 0;
   for (let i = 1; i < timestamps.length; i++) {
@@ -62906,10 +63538,10 @@ async function analyzeKeyframeIntervalsUncached(filePath) {
     avgIntervalSeconds: Math.round(avgInterval * 100) / 100,
     maxIntervalSeconds: Math.round(maxInterval * 100) / 100,
     keyframeCount: timestamps.length,
-    isProblematic: maxInterval > 2
+    isProblematic: maxInterval > PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS
   };
 }
-var FFPROBE_STDERR_MAX_BYTES, FFPROBE_STDOUT_MAX_CHARS, FFPROBE_ERROR_MAX_CHARS, videoMetadataCache, finalVideoFrameTimestampCache, finalVideoFrameTimestampSignalCaches, audioMetadataCache, mediaProbeOutputCache, mediaProbeOutputSignalCaches, MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES, AAC_LC_SAMPLES_PER_PACKET, STILL_IMAGE_DEMUXERS, StructurallyIncompletePngError, extractVideoMetadata, keyframeCache;
+var FFPROBE_STDERR_MAX_BYTES, FFPROBE_STDOUT_MAX_CHARS, FFPROBE_ERROR_MAX_CHARS, videoMetadataCache, finalVideoFrameTimestampCache, finalVideoFrameTimestampSignalCaches, audioMetadataCache, mediaProbeOutputCache, mediaProbeOutputSignalCaches, MEDIA_PROBE_OUTPUT_CACHE_MAX_ENTRIES, AAC_LC_SAMPLES_PER_PACKET, STILL_IMAGE_DEMUXERS, StructurallyIncompletePngError, extractVideoMetadata, keyframeCache, PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS;
 var init_ffprobe = __esm({
   "../engine/src/utils/ffprobe.ts"() {
     "use strict";
@@ -62952,6 +63584,7 @@ var init_ffprobe = __esm({
     };
     extractVideoMetadata = extractMediaMetadata;
     keyframeCache = /* @__PURE__ */ new Map();
+    PROBLEMATIC_KEYFRAME_INTERVAL_SECONDS = 2;
   }
 });
 
@@ -63644,9 +64277,9 @@ var init_chunkEncoder = __esm({
 function jpegInputError(buffer) {
   if (buffer.length === 0) return "empty frame";
   if (buffer[0] !== 255 || buffer[1] !== 216) return "missing JPEG SOI marker";
-  let offset2 = 2;
-  while (offset2 < buffer.length) {
-    const segment = readSegment(buffer, offset2);
+  let offset3 = 2;
+  while (offset3 < buffer.length) {
+    const segment = readSegment(buffer, offset3);
     if (typeof segment === "string") return segment;
     const { marker, start, end } = segment;
     if (marker === 219) {
@@ -63654,33 +64287,33 @@ function jpegInputError(buffer) {
       if (error) return error;
     }
     if (marker === 218) return void 0;
-    offset2 = end;
+    offset3 = end;
   }
   return "missing JPEG scan";
 }
-function readSegment(buffer, offset2) {
-  if (buffer[offset2++] !== 255) return "invalid JPEG marker";
-  while (buffer[offset2] === 255) offset2++;
-  const marker = buffer[offset2++];
+function readSegment(buffer, offset3) {
+  if (buffer[offset3++] !== 255) return "invalid JPEG marker";
+  while (buffer[offset3] === 255) offset3++;
+  const marker = buffer[offset3++];
   if (marker === void 0) return "truncated JPEG marker";
-  if (marker === 1) return { marker, start: offset2, end: offset2 };
-  if (offset2 + 2 > buffer.length) return "truncated JPEG segment length";
-  const length = buffer.readUInt16BE(offset2);
-  const end = offset2 + length;
+  if (marker === 1) return { marker, start: offset3, end: offset3 };
+  if (offset3 + 2 > buffer.length) return "truncated JPEG segment length";
+  const length = buffer.readUInt16BE(offset3);
+  const end = offset3 + length;
   if (length < 2 || end > buffer.length) return "invalid JPEG segment length";
-  return { marker, start: offset2 + 2, end };
+  return { marker, start: offset3 + 2, end };
 }
 function quantizationTableError(buffer, start, end) {
   if (start === end) return "empty JPEG DQT segment";
-  let offset2 = start;
-  while (offset2 < end) {
-    const descriptor = buffer[offset2++];
+  let offset3 = start;
+  while (offset3 < end) {
+    const descriptor = buffer[offset3++];
     if (descriptor === void 0) return "truncated JPEG DQT descriptor";
     const precision = descriptor >> 4;
     if (precision > 1) return `invalid JPEG DQT precision ${precision}`;
     if ((descriptor & 15) > 3) return "invalid JPEG DQT table id";
-    offset2 += precision === 0 ? 64 : 128;
-    if (offset2 > end) return "truncated JPEG DQT table";
+    offset3 += precision === 0 ? 64 : 128;
+    if (offset3 > end) return "truncated JPEG DQT table";
   }
   return void 0;
 }
@@ -64117,6 +64750,11 @@ function isUnresolvedAssetPlaceholder(rawSrc) {
 function cleanAssetUrl(url) {
   return url.trim().split(/[?#]/, 1)[0] ?? "";
 }
+function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve: resolve5, relative, isAbsolute }) {
+  const projectRoot = pathModule.resolve(projectDir);
+  const relativePath = pathModule.relative(projectRoot, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !pathModule.isAbsolute(relativePath);
+}
 function reanchoredCandidates(variant, baseDir, compiledDir) {
   const baseAbs = resolve5(baseDir);
   const joinedAbs = resolve5(join8(baseDir, variant));
@@ -68134,7 +68772,7 @@ var require_tokenize = __commonJS({
       var tokens = [];
       var css = input.css.valueOf();
       var length = css.length;
-      var offset2 = -1;
+      var offset3 = -1;
       var line = 1;
       var start = 0;
       var end = 0;
@@ -68144,13 +68782,13 @@ var require_tokenize = __commonJS({
           css += fix;
           next = css.length - 1;
         } else {
-          throw input.error("Unclosed " + what, line, start - offset2, start);
+          throw input.error("Unclosed " + what, line, start - offset3, start);
         }
       }
       while (start < length) {
         code = css.charCodeAt(start);
         if (code === t.newline) {
-          offset2 = start;
+          offset3 = start;
           line += 1;
         }
         switch (code) {
@@ -68164,13 +68802,13 @@ var require_tokenize = __commonJS({
               next += 1;
               code = css.charCodeAt(next);
               if (code === t.newline) {
-                offset2 = next;
+                offset3 = next;
                 line += 1;
               }
             } while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
             tokenType = t.space;
             endLine = line;
-            endColumn = next - offset2 - 1;
+            endColumn = next - offset3 - 1;
             end = next;
             break;
           case t.plus:
@@ -68184,7 +68822,7 @@ var require_tokenize = __commonJS({
             } while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
             tokenType = t.combinator;
             endLine = line;
-            endColumn = start - offset2;
+            endColumn = start - offset3;
             end = next;
             break;
           // Consume these characters as single tokens.
@@ -68204,7 +68842,7 @@ var require_tokenize = __commonJS({
             next = start;
             tokenType = code;
             endLine = line;
-            endColumn = start - offset2;
+            endColumn = start - offset3;
             end = next + 1;
             break;
           case t.singleQuote:
@@ -68225,7 +68863,7 @@ var require_tokenize = __commonJS({
             } while (escaped);
             tokenType = t.str;
             endLine = line;
-            endColumn = start - offset2;
+            endColumn = start - offset3;
             end = next + 1;
             break;
           default:
@@ -68242,7 +68880,7 @@ var require_tokenize = __commonJS({
                 nextOffset = next - lines[last].length;
               } else {
                 nextLine = line;
-                nextOffset = offset2;
+                nextOffset = offset3;
               }
               tokenType = t.comment;
               line = nextLine;
@@ -68252,13 +68890,13 @@ var require_tokenize = __commonJS({
               next = start;
               tokenType = code;
               endLine = line;
-              endColumn = start - offset2;
+              endColumn = start - offset3;
               end = next + 1;
             } else {
               next = consumeWord(css, start);
               tokenType = t.word;
               endLine = line;
-              endColumn = next - offset2;
+              endColumn = next - offset3;
             }
             end = next + 1;
             break;
@@ -68268,7 +68906,7 @@ var require_tokenize = __commonJS({
           // [0] Token type
           line,
           // [1] Starting line
-          start - offset2,
+          start - offset3,
           // [2] Starting column
           endLine,
           // [3] Ending line
@@ -68280,7 +68918,7 @@ var require_tokenize = __commonJS({
           // [6] End position
         ]);
         if (nextOffset) {
-          offset2 = nextOffset;
+          offset3 = nextOffset;
           nextOffset = null;
         }
         start = end;
@@ -76690,8 +77328,8 @@ ${other.raw}`)
               (tag) => tagSimpleSelectors(tag).some((token) => alreadyHidden.has(token))
             );
             if (hiddenByToken || hiddenByElement) continue;
-            const offset2 = win.propertyValues["strokeDashoffset"];
-            const hidesByOffset = numberValue(offset2) !== null && !zeroValue(offset2);
+            const offset3 = win.propertyValues["strokeDashoffset"];
+            const hidesByOffset = numberValue(offset3) !== null && !zeroValue(offset3);
             const hides = isHiddenGsapState(win.propertyValues) || zeroValue(win.propertyValues["scale"]) || hidesByOffset;
             if (!hides) continue;
             findings.push({
@@ -80168,12 +80806,12 @@ var init_mediaVolumeEnvelope = __esm({
 
 // ../engine/src/services/wavChunks.ts
 function* riffChunks(buffer) {
-  let offset2 = 12;
-  while (offset2 + 8 <= buffer.length) {
-    const id = buffer.toString("ascii", offset2, offset2 + 4);
-    const size = buffer.readUInt32LE(offset2 + 4);
-    yield { id, body: offset2 + 8, size };
-    offset2 += 8 + size + size % 2;
+  let offset3 = 12;
+  while (offset3 + 8 <= buffer.length) {
+    const id = buffer.toString("ascii", offset3, offset3 + 4);
+    const size = buffer.readUInt32LE(offset3 + 4);
+    yield { id, body: offset3 + 8, size };
+    offset3 += 8 + size + size % 2;
   }
 }
 function extensibleFormatTag(fmt) {
@@ -80583,13 +81221,13 @@ async function readPlaneFromPage(page, index, byteLength) {
   const parts = [];
   for (let at2 = 0; at2 < byteLength; at2 += TRANSFER_BYTES) {
     const b64 = await page.evaluate(
-      ([plane_index, offset2, limit]) => {
+      ([plane_index, offset3, limit]) => {
         const plane = window.__HF_FX_IO?.out[plane_index];
         if (!plane) return "";
         const u8 = new Uint8Array(
           plane.buffer,
-          plane.byteOffset + offset2,
-          Math.min(limit, plane.length * 4 - offset2)
+          plane.byteOffset + offset3,
+          Math.min(limit, plane.length * 4 - offset3)
         );
         let s = "";
         const CHUNK = 32768;
@@ -82175,11 +82813,11 @@ async function verifyDiskDrawElementSamples(session, task, streaming) {
   if (!truths || truths.size === 0) return;
   const verifyMinDb = resolveDeVerifyMinDb();
   const ext = session.options.format === "png" ? "png" : "jpg";
-  const offset2 = task.outputFrameOffset ?? 0;
+  const offset3 = task.outputFrameOffset ?? 0;
   for (const idx of selectVerifySampleIndicesForTask(truths.keys(), task)) {
     const truth = truths.get(idx);
     if (!truth) continue;
-    const framePath = join17(task.outputDir, `frame_${String(idx - offset2).padStart(6, "0")}.${ext}`);
+    const framePath = join17(task.outputDir, `frame_${String(idx - offset3).padStart(6, "0")}.${ext}`);
     const db = await psnrForDiskSample(framePath, truth, task.workerId, idx);
     if (db === null) continue;
     assertDiskSampleAboveFloor(db, verifyMinDb, idx, task.workerId);
@@ -82481,6 +83119,14 @@ function readRegularFile(filePath) {
     closeSync4(fd);
   }
 }
+function resolveContainedPaths(projectDir, compiledDir, relativePath) {
+  const projectPath = join18(projectDir, relativePath);
+  if (!isWithinProjectRoot(projectDir, projectPath)) return null;
+  if (!compiledDir) return { projectPath, compiledPath: null };
+  const compiledPath = join18(compiledDir, relativePath);
+  if (!isWithinProjectRoot(compiledDir, compiledPath)) return null;
+  return { projectPath, compiledPath };
+}
 function createFileServer(options) {
   const { projectDir, compiledDir, port = 0, stripEmbeddedRuntime = true } = options;
   const headScripts = options.headScripts ?? [];
@@ -82490,8 +83136,9 @@ function createFileServer(options) {
     let requestPath = c.req.path;
     if (requestPath === "/") requestPath = "/index.html";
     const relativePath = requestPath.replace(/^\//, "");
-    const compiledPath = compiledDir ? join18(compiledDir, relativePath) : null;
-    const content = (compiledPath ? readRegularFile(compiledPath) : null) ?? readRegularFile(join18(projectDir, relativePath));
+    const resolved = resolveContainedPaths(projectDir, compiledDir, relativePath);
+    if (!resolved) return c.text("Not found", 404);
+    const content = (resolved.compiledPath ? readRegularFile(resolved.compiledPath) : null) ?? readRegularFile(resolved.projectPath);
     if (content === null) return c.text("Not found", 404);
     const ext = extname3(relativePath).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -82522,6 +83169,7 @@ var init_fileServer = __esm({
   "../engine/src/services/fileServer.ts"() {
     "use strict";
     init_compiler();
+    init_assetResolution();
     MIME_TYPES = {
       ".html": "text/html; charset=utf-8",
       ".css": "text/css; charset=utf-8",
@@ -83675,6 +84323,7 @@ __export(src_exports, {
   classifyVideoExtractionError: () => classifyVideoExtractionError,
   cloneCaptureWarning: () => cloneCaptureWarning,
   cloneCaptureWarnings: () => cloneCaptureWarnings,
+  closeBrowserPool: () => closeBrowserPool,
   closeCaptureSession: () => closeCaptureSession,
   completeDeferredDrawElementInit: () => completeDeferredDrawElementInit,
   compositionRequiresWebGpu: () => compositionRequiresWebGpu,
@@ -90043,6 +90692,9 @@ function aggregateDrawElement(perfs, de) {
     hasLut: de.hasLut,
     rootBodyMismatch: de.rootBodyMismatch,
     rootBodyDeltaPxBucket: de.rootBodyDeltaPxBucket,
+    vfxHostCount: de.vfxHostCount,
+    vfxCapture: de.vfxCapture,
+    vfxTypes: de.vfxTypes,
     shortBand: de.shortBand,
     parallelRouter: de.parallelRouter ?? "none",
     preRouterWorkers: de.preRouterWorkers,
@@ -91976,30 +92628,32 @@ init_dist2();
 init_mediaTiming();
 init_src();
 var COMPOSITION_HOST_ATTR = "data-composition-file";
-var ROOT_WINDOW = { offset: 0, limit: Infinity, basis: "local" };
-function parseNumeric3(value) {
-  if (value == null || value === "") return null;
-  const parsed = Number.parseFloat(value);
-  return Number.isFinite(parsed) ? parsed : null;
+function resolveHostEnd(host, hostStart) {
+  return resolveAuthoredTimingWindow({
+    start: hostStart,
+    duration: host.getAttribute("data-duration"),
+    end: host.getAttribute("data-end")
+  })?.end ?? null;
 }
+var ROOT_WINDOW = { offset: 0, limit: Infinity, basis: "local" };
 function resolveHostWindow(element, document2, startCache, visiting) {
   const hosts = [];
   for (let ancestor2 = element.parentElement; ancestor2; ancestor2 = ancestor2.parentElement) {
     if (ancestor2.hasAttribute(COMPOSITION_HOST_ATTR)) hosts.push(ancestor2);
   }
   if (hosts.length === 0) return ROOT_WINDOW;
-  let offset2 = 0;
+  let offset3 = 0;
   let limit = Infinity;
   for (const host of hosts.reverse()) {
     const hostStart = resolveReferencedStart(document2, host, startCache, visiting);
-    const hostEnd = parseNumeric3(host.getAttribute("data-end"));
-    if (hostEnd != null) limit = Math.min(limit, offset2 + hostEnd);
-    offset2 += hostStart;
+    const hostEnd = resolveHostEnd(host, hostStart);
+    if (hostEnd != null) limit = Math.min(limit, offset3 + hostEnd);
+    offset3 += hostStart;
   }
   const tag = element.tagName.toLowerCase();
   const basis = tag === "video" || tag === "audio" ? readMediaStartBasis(element.getAttribute(MEDIA_START_BASIS_ATTR)) : "local";
   return {
-    offset: offset2,
+    offset: offset3,
     limit,
     basis
   };
@@ -93928,7 +94582,7 @@ function studioPositionSeekReapplyRuntime() {
 }
 
 // ../core/dist/generated/position-edits-render-inline.js
-var POSITION_EDITS_RENDER_IIFE = '"use strict";(()=>{function T(){return globalThis}function P(e,t){if(typeof window>"u")return;let o=T(),r=o.__hf?.onSwallowed;if(r)try{r({label:e,error:t})}catch(s){}(o.__hfDebug||o.__HYPERFRAMES_DEBUG)&&console.debug(`[hyperframes] ${e} swallowed:`,t)}var x=null;function R(e,t){if(x)try{x({source:"hf-preview",type:"analytics",event:e,properties:t??{}})}catch(o){P("runtime.analytics.site1",o)}}var W="http://www.w3.org/1999/xhtml";function N(e){return e!=null&&e.nodeType===1}function _(e){return N(e)&&(e.namespaceURI===W||e.namespaceURI==="http://www.w3.org/2000/svg")}var w="data-hf-edit-base-x",y="data-hf-edit-base-y",m="data-hf-edit-original-translate",k=e=>{let t=parseFloat(e??"");return Number.isFinite(t)?t:0},O=e=>{let t=[],o=0,r="";for(let s of e.trim())s==="("&&(o+=1),s===")"&&(o=Math.max(0,o-1)),/\\s/.test(s)&&o===0?(r&&t.push(r),r=""):r+=s;return r&&t.push(r),t},L=/^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)px$/,b=(e,t)=>L.test(e)&&L.test(t)?`${parseFloat(e)+parseFloat(t)}px`:`calc(${e} + ${t})`,V=(e,t,o)=>{if(!e||e==="none")return`${t} ${o}`;let[r,s,a]=O(e);if(r===void 0)return`${t} ${o}`;if(s===void 0)return`${b(r,t)} ${o}`;let i=a===void 0?"":` ${a}`;return`${b(r,t)} ${b(s,o)}${i}`},j=e=>{try{e.ownerDocument.defaultView?.gsap?.getProperty?.(e,"x")}catch{}},G=e=>{let t=e.style.getPropertyValue("translate").trim();if(t)return t==="none"?"":t;try{let o=e.ownerDocument.defaultView,r=o?o.getComputedStyle(e).getPropertyValue("translate").trim():"";return r==="none"?"":r}catch{return""}},E=new WeakMap;function B(e,t){let o=E.get(e);if(!t?.force&&o!==void 0&&e.style.getPropertyValue("translate")!==o){R("position_edit_fold_skipped",{hfId:e.getAttribute("data-hf-id")});return}let r=k(e.getAttribute("data-x"))-k(e.getAttribute(w)),s=k(e.getAttribute("data-y"))-k(e.getAttribute(y));e.hasAttribute(m)||e.setAttribute(m,G(e)),o===void 0&&j(e);let a=e.getAttribute(m)??"",i=V(a,`${r}px`,`${s}px`);e.style.setProperty("translate",i),E.set(e,e.style.getPropertyValue("translate"))}function S(e,t){let o=e.querySelectorAll(`[${m}]:not([${w}]):not([${y}])`);for(let a=0;a<o.length;a++){let i=o[a];if(i===void 0||!_(i))continue;let g=i.getAttribute(m)??"";g===""?i.style.removeProperty("translate"):i.style.setProperty("translate",g),i.removeAttribute(m),E.delete(i)}let r=e.querySelectorAll(`[${w}], [${y}]`),s=0;for(let a=0;a<r.length;a++){let i=r[a];i===void 0||!_(i)||(B(i,t),s+=1)}return s}var $="__hfPositionEditsSeekReapplyWrapped",D=new WeakSet,M=new WeakMap,F=new WeakMap;function H(e){let t=e,o=()=>{try{S(t.document)}catch{}},r=n=>typeof n=="function"&&(D.has(n)||!!n[$]),s=n=>{D.add(n);try{Object.defineProperty(n,$,{value:!0})}catch{}},a=n=>{if(typeof n!="function"||r(n))return n;let l=function(...u){let d=n.apply(this,u);return o(),d};return s(l),l},i=(n,l)=>{let u=M.get(n);if(u?.has(l))return!0;let d=Object.getOwnPropertyDescriptor(n,l);if(d?.configurable===!1){let c=n[l];return typeof c=="function"&&(n[l]=a(c),o()),!1}let p=n[l],f=d?.set;return Object.defineProperty(n,l,{configurable:!0,enumerable:d?.enumerable??!0,get:()=>p,set:c=>{p=a(c),f?.call(n,c)}}),p=a(p),u??(u=new Set),u.add(l),M.set(n,u),o(),!0},g=(n,l)=>{let u=F.get(t),d=Object.getOwnPropertyDescriptor(t,n);if(!u?.has(n)){if(d?.configurable===!1){let c=t[n];return c?i(c,l):!1}let f=t[n];Object.defineProperty(t,n,{configurable:!0,enumerable:d?.enumerable??!0,get:()=>f,set:c=>{f=c,f&&i(f,l)}}),u??(u=new Set),u.add(n),F.set(t,u)}let p=t[n];return p?i(p,l):!1},h=()=>{let n=g("__hf","seek"),l=g("__player","renderSeek");return n&&l};if(h())return;let v=120,A=t.setInterval(()=>{if(h()){t.clearInterval(A);return}v-=1,v<=0&&t.clearInterval(A)},50)}function I(){document.querySelector(`[${w}], [${y}]`)&&(S(document),H(window))}document.readyState==="loading"?document.addEventListener("DOMContentLoaded",I,{once:!0}):I();})();\n';
+var POSITION_EDITS_RENDER_IIFE = '"use strict";(()=>{function T(){return globalThis}function P(e,t){if(typeof window>"u")return;let o=T(),r=o.__hf?.onSwallowed;if(r)try{r({label:e,error:t})}catch(s){}(o.__hfDebug||o.__HYPERFRAMES_DEBUG)&&console.debug(`[hyperframes] ${e} swallowed:`,t)}var x=null;function R(e,t){if(x)try{x({source:"hf-preview",type:"analytics",event:e,properties:t??{}})}catch(o){P("runtime.analytics.site1",o)}}var W="http://www.w3.org/1999/xhtml";function N(e){return e!=null&&e.nodeType===1}function _(e){return N(e)&&(e.namespaceURI===W||e.namespaceURI==="http://www.w3.org/2000/svg")}var w="data-hf-edit-base-x",y="data-hf-edit-base-y",m="data-hf-edit-original-translate",k=e=>{let t=parseFloat(e??"");return Number.isFinite(t)?t:0},O=e=>{let t=[],o=0,r="";for(let s of e.trim())s==="("&&(o+=1),s===")"&&(o=Math.max(0,o-1)),/\\s/.test(s)&&o===0?(r&&t.push(r),r=""):r+=s;return r&&t.push(r),t},L=/^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)px$/,b=(e,t)=>L.test(e)&&L.test(t)?`${parseFloat(e)+parseFloat(t)}px`:`calc(${e} + ${t})`,V=(e,t,o)=>{if(!e||e==="none")return`${t} ${o}`;let[r,s,a]=O(e);if(r===void 0)return`${t} ${o}`;if(s===void 0)return`${b(r,t)} ${o}`;let i=a===void 0?"":` ${a}`;return`${b(r,t)} ${b(s,o)}${i}`},j=e=>{try{e.ownerDocument.defaultView?.gsap?.getProperty?.(e,"x")}catch{}},G=e=>{let t=e.style.getPropertyValue("translate").trim();if(t)return t==="none"?"":t;try{let o=e.ownerDocument.defaultView,r=o?o.getComputedStyle(e).getPropertyValue("translate").trim():"";return r==="none"?"":r}catch{return""}},E=new WeakMap;function B(e,t){let o=E.get(e);if(!t?.force&&o!==void 0&&e.style.getPropertyValue("translate")!==o){R("position_edit_fold_skipped",{hfId:e.getAttribute("data-hf-id")});return}let r=k(e.getAttribute("data-x"))-k(e.getAttribute(w)),s=k(e.getAttribute("data-y"))-k(e.getAttribute(y));e.hasAttribute(m)||e.setAttribute(m,G(e)),o===void 0&&j(e);let a=e.getAttribute(m)??"",i=V(a,`${r}px`,`${s}px`);e.style.setProperty("translate",i),E.set(e,e.style.getPropertyValue("translate"))}function S(e,t){let o=e.querySelectorAll(`[${m}]:not([${w}]):not([${y}])`);for(let a=0;a<o.length;a++){let i=o[a];if(i===void 0||!_(i))continue;let g=i.getAttribute(m)??"";g===""?i.style.removeProperty("translate"):i.style.setProperty("translate",g),i.removeAttribute(m),E.delete(i)}let r=e.querySelectorAll(`[${w}], [${y}]`),s=0;for(let a=0;a<r.length;a++){let i=r[a];i===void 0||!_(i)||(B(i,t),s+=1)}return s}var $="__hfPositionEditsSeekReapplyWrapped",D=new WeakSet,M=new WeakMap,H=new WeakMap;function F(e){let t=e,o=()=>{try{S(t.document)}catch{}},r=n=>typeof n=="function"&&(D.has(n)||!!n[$]),s=n=>{D.add(n);try{Object.defineProperty(n,$,{value:!0})}catch{}},a=n=>{if(typeof n!="function"||r(n))return n;let l=function(...u){let d=n.apply(this,u);return o(),d};return s(l),l},i=(n,l)=>{let u=M.get(n);if(u?.has(l))return!0;let d=Object.getOwnPropertyDescriptor(n,l);if(d?.configurable===!1){let c=n[l];return typeof c=="function"&&(n[l]=a(c),o()),!1}let p=n[l],f=d?.set;return Object.defineProperty(n,l,{configurable:!0,enumerable:d?.enumerable??!0,get:()=>p,set:c=>{p=a(c),f?.call(n,c)}}),p=a(p),u??(u=new Set),u.add(l),M.set(n,u),o(),!0},g=(n,l)=>{let u=H.get(t),d=Object.getOwnPropertyDescriptor(t,n);if(!u?.has(n)){if(d?.configurable===!1){let c=t[n];return c?i(c,l):!1}let f=t[n];Object.defineProperty(t,n,{configurable:!0,enumerable:d?.enumerable??!0,get:()=>f,set:c=>{f=c,f&&i(f,l)}}),u??(u=new Set),u.add(n),H.set(t,u)}let p=t[n];return p?i(p,l):!1},v=()=>{let n=g("__hf","seek"),l=g("__player","renderSeek");return n&&l};if(v())return;let h=120,A=t.setInterval(()=>{if(v()){t.clearInterval(A);return}h-=1,h<=0&&t.clearInterval(A)},50)}function I(){document.querySelector(`[${w}], [${y}]`)&&(S(document),F(window))}document.readyState==="loading"?document.addEventListener("DOMContentLoaded",I,{once:!0}):I();})();\n';
 function getPositionEditsRenderScript() {
   return POSITION_EDITS_RENDER_IIFE;
 }
@@ -95262,10 +95916,11 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
     if (isHttpUrl(video.src)) continue;
     const videoPath = resolve12(projectDir, video.src);
     const reencode = `ffmpeg -i "${video.src}" -c:v libx264 -r 30 -g 30 -keyint_min 30 -movflags +faststart -c:a copy output.mp4`;
-    Promise.all([
-      withMediaProbeSlot(() => analyzeKeyframeIntervals(videoPath)),
-      withMediaProbeSlot(() => extractMediaMetadata(videoPath))
-    ]).then(([analysis, metadata]) => {
+    (async () => {
+      const metadata = await withMediaProbeSlot(() => extractMediaMetadata(videoPath));
+      const analysis = await withMediaProbeSlot(
+        () => analyzeKeyframeIntervals(videoPath, metadata)
+      );
       if (analysis.isProblematic) {
         defaultLogger.warn(
           `[Compiler] WARNING: Video "${video.id}" has sparse keyframes (max interval: ${analysis.maxIntervalSeconds}s). This causes seek failures and frame freezing. Re-encode with: ${reencode}`
@@ -95276,7 +95931,7 @@ async function compileForRender(projectDir, htmlPath, downloadDir, options = {})
           `[Compiler] Video "${video.id}" is variable frame rate (VFR); the engine will normalize it to CFR before frame extraction. If rendering feels slow on this video, pre-encode once with: ${reencode}`
         );
       }
-    }).catch(() => {
+    })().catch(() => {
     });
   }
   const { document: document2 } = parseHTML(html);
@@ -99327,6 +99982,7 @@ function envInt(name, fallback) {
   return Number.isInteger(parsed) ? parsed : fallback;
 }
 var MAX_REPORTED_ELEMENT_TAGS = 50;
+var VFX_CAPTURE_RANK = { none: 0, self: 1, backdrop: 2 };
 var ROOT_COMPOSITION_TAG_RE = /<[a-zA-Z][-a-zA-Z0-9]*\b[^>]*\bdata-composition-id=["'][^"']*["'][^>]*>/i;
 function bucketPxDelta(delta) {
   if (delta === 0) return "0";
@@ -99381,6 +100037,25 @@ function scanElementTags(html) {
     colorGradingCount++;
     if (!hasLut) hasLut = colorGradingValueHasLut(m[1] ?? m[2] ?? "");
   }
+  let vfxHostCount = 0;
+  let vfxCapture;
+  const vfxTypeSet = /* @__PURE__ */ new Set();
+  for (const m of markup.matchAll(new RegExp(`\\b${HF_VFX_ATTR}=(?:"([^"]*)"|'([^']*)')`, "gi"))) {
+    vfxHostCount++;
+    try {
+      const chain = parseVfxChain(decodeHtmlAttrJson(m[1] ?? m[2] ?? ""));
+      for (const node of chain.nodes) {
+        if (node.enabled === false) continue;
+        vfxTypeSet.add(node.type);
+      }
+      const capture = chainCapture(chain);
+      if (vfxCapture === void 0 || VFX_CAPTURE_RANK[capture] > VFX_CAPTURE_RANK[vfxCapture]) {
+        vfxCapture = capture;
+      }
+    } catch {
+    }
+  }
+  const vfxTypes = [...vfxTypeSet].sort().join(",");
   return {
     total,
     byTag,
@@ -99392,11 +100067,17 @@ function scanElementTags(html) {
     audioGroupCount,
     colorGradingCount,
     hasLut,
+    vfxHostCount,
+    vfxCapture,
+    vfxTypes,
     ...detectRootBodySizeMismatch(html)
   };
 }
+function decodeHtmlAttrJson(rawAttributeValue) {
+  return rawAttributeValue.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
 function colorGradingValueHasLut(rawAttributeValue) {
-  const decoded = rawAttributeValue.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+  const decoded = decodeHtmlAttrJson(rawAttributeValue);
   try {
     const parsed = JSON.parse(decoded);
     if (typeof parsed !== "object" || parsed === null || !("lut" in parsed)) return false;
@@ -99437,7 +100118,10 @@ async function resolveCompositionElementCount(probeSession, html) {
     colorGradingCount: scan.colorGradingCount,
     hasLut: scan.hasLut,
     rootBodyMismatch: scan.rootBodyMismatch,
-    rootBodyDeltaPxBucket: scan.rootBodyDeltaPxBucket
+    rootBodyDeltaPxBucket: scan.rootBodyDeltaPxBucket,
+    vfxHostCount: scan.vfxHostCount,
+    vfxCapture: scan.vfxCapture,
+    vfxTypes: scan.vfxTypes
   };
 }
 var KNOWN_RUNTIME_ADAPTERS = [
@@ -100249,7 +100933,10 @@ async function executeRenderPipeline(input) {
       colorGradingCount,
       hasLut,
       rootBodyMismatch,
-      rootBodyDeltaPxBucket
+      rootBodyDeltaPxBucket,
+      vfxHostCount,
+      vfxCapture,
+      vfxTypes
     } = await resolveCompositionElementCount(probeSession, compiled.html);
     const adaptersUsed = await resolveAdaptersUsed(probeSession, compiled.html);
     const deShortBandEnabled = deShortBandMaxElements > 0;
@@ -101325,6 +102012,9 @@ async function executeRenderPipeline(input) {
         hasLut,
         rootBodyMismatch,
         rootBodyDeltaPxBucket,
+        vfxHostCount,
+        vfxCapture,
+        vfxTypes,
         shortBand: deShortBand,
         parallelRouter: deParallelRouter,
         preRouterWorkers: deParallelRouter ? preRoutingWorkerCount : void 0,
@@ -101533,14 +102223,14 @@ function describeValue(value) {
 
 // ../producer/src/renderRequest.ts
 var RENDER_REQUEST_VERSION = 1;
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
 function assertPositiveFps(options) {
   const fps = options.fps;
-  if (!isPlainObject2(fps) || typeof fps.num !== "number" || typeof fps.den !== "number" || !Number.isInteger(fps.num) || !Number.isInteger(fps.den) || fps.num <= 0 || fps.den <= 0) {
+  if (!isPlainObject3(fps) || typeof fps.num !== "number" || typeof fps.den !== "number" || !Number.isInteger(fps.num) || !Number.isInteger(fps.den) || fps.num <= 0 || fps.den <= 0) {
     throw new Error("Render request fps must be a positive rational");
   }
 }
@@ -101570,7 +102260,7 @@ function isCanvasResolution(value) {
   return typeof value === "string" && VALID_CANVAS_RESOLUTIONS.some((resolution) => resolution === value);
 }
 function assertDistributedOptions(value) {
-  if (!isPlainObject2(value)) throw new Error("Render request distributed must be an object");
+  if (!isPlainObject3(value)) throw new Error("Render request distributed must be an object");
   for (const field of ["width", "height"]) {
     if (typeof value[field] !== "number" || !Number.isInteger(value[field]) || value[field] <= 0) {
       throw new Error(`Render request distributed.${field} must be a positive integer`);
@@ -101618,13 +102308,13 @@ function assertRequestOptionScalars(options) {
 }
 function assertRequestOptionObjects(options) {
   validateEngineConfigSnapshot(options.engineConfig);
-  if (options.variables !== void 0 && !isPlainObject2(options.variables)) {
+  if (options.variables !== void 0 && !isPlainObject3(options.variables)) {
     throw new Error("Render request variables must be a JSON object");
   }
   if (options.distributed !== void 0) assertDistributedOptions(options.distributed);
 }
 function assertRequestOptions(options) {
-  if (!isPlainObject2(options)) throw new Error("Render request options must be an object");
+  if (!isPlainObject3(options)) throw new Error("Render request options must be an object");
   assertPositiveFps(options);
   if (!["draft", "standard", "high"].includes(String(options.quality))) {
     throw new Error("Render request quality is invalid");
@@ -101644,8 +102334,8 @@ function omitUndefinedProperties(value) {
   return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
 }
 function assertRenderRequest(value) {
-  if (!isPlainObject2(value) || value.version !== RENDER_REQUEST_VERSION) {
-    const version2 = isPlainObject2(value) ? value.version : void 0;
+  if (!isPlainObject3(value) || value.version !== RENDER_REQUEST_VERSION) {
+    const version2 = isPlainObject3(value) ? value.version : void 0;
     throw new Error(`Unsupported render request version: ${String(version2)}`);
   }
   assertNonEmptyPath(value.projectDir, "projectDir");
@@ -101941,7 +102631,7 @@ function extractSafeRenderErrorMetadata(error) {
     errorCode,
     errorOwner: owner === "user" || owner === "system" ? owner : void 0,
     retryable: typeof retryable === "boolean" ? retryable : void 0,
-    ...isPlainObject3(publicMetadata) ? { errorMetadata: publicMetadata } : {}
+    ...isPlainObject4(publicMetadata) ? { errorMetadata: publicMetadata } : {}
   };
 }
 function parseServerFps(value) {
@@ -102009,11 +102699,11 @@ function parseRenderOptions(body) {
     videoFrameFormat
   };
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRenderOverrides(body) {
-  const variables = isPlainObject3(body.variables) ? body.variables : void 0;
+  const variables = isPlainObject4(body.variables) ? body.variables : void 0;
   const rawOutputResolution = typeof body.outputResolution === "string" ? body.outputResolution : void 0;
   const outputResolution = rawOutputResolution ? normalizeResolutionFlag(rawOutputResolution) : void 0;
   const outputResolutionAspectAgnostic = outputResolution ? isAspectAgnosticResolutionAlias(rawOutputResolution) : void 0;
@@ -102049,7 +102739,7 @@ function resolvePreparedRenderOutput(prepared, rendersDir, log) {
   return { input, cleanupProjectDir, absoluteOutputPath };
 }
 function validateRenderOverrides(body) {
-  if (body.variables !== void 0 && !isPlainObject3(body.variables)) {
+  if (body.variables !== void 0 && !isPlainObject4(body.variables)) {
     return 'variables must be a JSON object keyed by variable id (e.g. {"title":"Hello"})';
   }
   if (body.outputDynamicRange !== void 0 && parseServerOutputDynamicRange(body.outputDynamicRange) === void 0) {
@@ -102748,8 +103438,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.62" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.62" : "0.0.0-dev";
+var VERSION = true ? "0.8.64" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.64" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {