hyperframes 0.8.191 → 0.8.192

package/dist/chunk-RXATE6FZ.js

@@ -0,0 +1,385 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// ../../node_modules/.bun/acorn-walk@8.3.5/node_modules/acorn-walk/dist/walk.mjs
+function simple(node, visitors, baseVisitor, state, override) {
+  if (!baseVisitor) {
+    baseVisitor = base;
+  }
+  (function c(node2, st, override2) {
+    var type = override2 || node2.type;
+    visitNode(baseVisitor, type, node2, st, c);
+    if (visitors[type]) {
+      visitors[type](node2, st);
+    }
+  })(node, state, override);
+}
+function ancestor(node, visitors, baseVisitor, state, override) {
+  var ancestors = [];
+  if (!baseVisitor) {
+    baseVisitor = base;
+  }
+  (function c(node2, st, override2) {
+    var type = override2 || node2.type;
+    var isNew = node2 !== ancestors[ancestors.length - 1];
+    if (isNew) {
+      ancestors.push(node2);
+    }
+    visitNode(baseVisitor, type, node2, st, c);
+    if (visitors[type]) {
+      visitors[type](node2, st || ancestors, ancestors);
+    }
+    if (isNew) {
+      ancestors.pop();
+    }
+  })(node, state, override);
+}
+function recursive(node, state, funcs, baseVisitor, override) {
+  var visitor = funcs ? make(funcs, baseVisitor || void 0) : baseVisitor;
+  (function c(node2, st, override2) {
+    visitor[override2 || node2.type](node2, st, c);
+  })(node, state, override);
+}
+function full(node, callback, baseVisitor, state, override) {
+  if (!baseVisitor) {
+    baseVisitor = base;
+  }
+  var last;
+  (function c(node2, st, override2) {
+    var type = override2 || node2.type;
+    visitNode(baseVisitor, type, node2, st, c);
+    if (last !== node2) {
+      callback(node2, st, type);
+      last = node2;
+    }
+  })(node, state, override);
+}
+function make(funcs, baseVisitor) {
+  var visitor = Object.create(baseVisitor || base);
+  for (var type in funcs) {
+    visitor[type] = funcs[type];
+  }
+  return visitor;
+}
+function skipThrough(node, st, c) {
+  c(node, st);
+}
+function ignore(_node, _st, _c) {
+}
+function visitNode(baseVisitor, type, node, st, c) {
+  if (baseVisitor[type] == null) {
+    throw new Error("No walker function defined for node type " + type);
+  }
+  baseVisitor[type](node, st, c);
+}
+var base = {};
+base.Program = base.BlockStatement = base.StaticBlock = function(node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1) {
+    var stmt = list[i];
+    c(stmt, st, "Statement");
+  }
+};
+base.Statement = skipThrough;
+base.EmptyStatement = ignore;
+base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression = function(node, st, c) {
+  return c(node.expression, st, "Expression");
+};
+base.IfStatement = function(node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Statement");
+  if (node.alternate) {
+    c(node.alternate, st, "Statement");
+  }
+};
+base.LabeledStatement = function(node, st, c) {
+  return c(node.body, st, "Statement");
+};
+base.BreakStatement = base.ContinueStatement = ignore;
+base.WithStatement = function(node, st, c) {
+  c(node.object, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.SwitchStatement = function(node, st, c) {
+  c(node.discriminant, st, "Expression");
+  for (var i = 0, list = node.cases; i < list.length; i += 1) {
+    var cs = list[i];
+    c(cs, st);
+  }
+};
+base.SwitchCase = function(node, st, c) {
+  if (node.test) {
+    c(node.test, st, "Expression");
+  }
+  for (var i = 0, list = node.consequent; i < list.length; i += 1) {
+    var cons = list[i];
+    c(cons, st, "Statement");
+  }
+};
+base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function(node, st, c) {
+  if (node.argument) {
+    c(node.argument, st, "Expression");
+  }
+};
+base.ThrowStatement = base.SpreadElement = function(node, st, c) {
+  return c(node.argument, st, "Expression");
+};
+base.TryStatement = function(node, st, c) {
+  c(node.block, st, "Statement");
+  if (node.handler) {
+    c(node.handler, st);
+  }
+  if (node.finalizer) {
+    c(node.finalizer, st, "Statement");
+  }
+};
+base.CatchClause = function(node, st, c) {
+  if (node.param) {
+    c(node.param, st, "Pattern");
+  }
+  c(node.body, st, "Statement");
+};
+base.WhileStatement = base.DoWhileStatement = function(node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForStatement = function(node, st, c) {
+  if (node.init) {
+    c(node.init, st, "ForInit");
+  }
+  if (node.test) {
+    c(node.test, st, "Expression");
+  }
+  if (node.update) {
+    c(node.update, st, "Expression");
+  }
+  c(node.body, st, "Statement");
+};
+base.ForInStatement = base.ForOfStatement = function(node, st, c) {
+  c(node.left, st, "ForInit");
+  c(node.right, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForInit = function(node, st, c) {
+  if (node.type === "VariableDeclaration") {
+    c(node, st);
+  } else {
+    c(node, st, "Expression");
+  }
+};
+base.DebuggerStatement = ignore;
+base.FunctionDeclaration = function(node, st, c) {
+  return c(node, st, "Function");
+};
+base.VariableDeclaration = function(node, st, c) {
+  for (var i = 0, list = node.declarations; i < list.length; i += 1) {
+    var decl = list[i];
+    c(decl, st);
+  }
+};
+base.VariableDeclarator = function(node, st, c) {
+  c(node.id, st, "Pattern");
+  if (node.init) {
+    c(node.init, st, "Expression");
+  }
+};
+base.Function = function(node, st, c) {
+  if (node.id) {
+    c(node.id, st, "Pattern");
+  }
+  for (var i = 0, list = node.params; i < list.length; i += 1) {
+    var param = list[i];
+    c(param, st, "Pattern");
+  }
+  c(node.body, st, node.expression ? "Expression" : "Statement");
+};
+base.Pattern = function(node, st, c) {
+  if (node.type === "Identifier") {
+    c(node, st, "VariablePattern");
+  } else if (node.type === "MemberExpression") {
+    c(node, st, "MemberPattern");
+  } else {
+    c(node, st);
+  }
+};
+base.VariablePattern = ignore;
+base.MemberPattern = skipThrough;
+base.RestElement = function(node, st, c) {
+  return c(node.argument, st, "Pattern");
+};
+base.ArrayPattern = function(node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+    if (elt) {
+      c(elt, st, "Pattern");
+    }
+  }
+};
+base.ObjectPattern = function(node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1) {
+    var prop = list[i];
+    if (prop.type === "Property") {
+      if (prop.computed) {
+        c(prop.key, st, "Expression");
+      }
+      c(prop.value, st, "Pattern");
+    } else if (prop.type === "RestElement") {
+      c(prop.argument, st, "Pattern");
+    }
+  }
+};
+base.Expression = skipThrough;
+base.ThisExpression = base.Super = base.MetaProperty = ignore;
+base.ArrayExpression = function(node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+    if (elt) {
+      c(elt, st, "Expression");
+    }
+  }
+};
+base.ObjectExpression = function(node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1) {
+    var prop = list[i];
+    c(prop, st);
+  }
+};
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
+base.SequenceExpression = function(node, st, c) {
+  for (var i = 0, list = node.expressions; i < list.length; i += 1) {
+    var expr = list[i];
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateLiteral = function(node, st, c) {
+  for (var i = 0, list = node.quasis; i < list.length; i += 1) {
+    var quasi = list[i];
+    c(quasi, st);
+  }
+  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1) {
+    var expr = list$1[i$1];
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateElement = ignore;
+base.UnaryExpression = base.UpdateExpression = function(node, st, c) {
+  c(node.argument, st, "Expression");
+};
+base.BinaryExpression = base.LogicalExpression = function(node, st, c) {
+  c(node.left, st, "Expression");
+  c(node.right, st, "Expression");
+};
+base.AssignmentExpression = base.AssignmentPattern = function(node, st, c) {
+  c(node.left, st, "Pattern");
+  c(node.right, st, "Expression");
+};
+base.ConditionalExpression = function(node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Expression");
+  c(node.alternate, st, "Expression");
+};
+base.NewExpression = base.CallExpression = function(node, st, c) {
+  c(node.callee, st, "Expression");
+  if (node.arguments) {
+    for (var i = 0, list = node.arguments; i < list.length; i += 1) {
+      var arg = list[i];
+      c(arg, st, "Expression");
+    }
+  }
+};
+base.MemberExpression = function(node, st, c) {
+  c(node.object, st, "Expression");
+  if (node.computed) {
+    c(node.property, st, "Expression");
+  }
+};
+base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function(node, st, c) {
+  if (node.declaration) {
+    c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression");
+  }
+  if (node.source) {
+    c(node.source, st, "Expression");
+  }
+  if (node.attributes) {
+    for (var i = 0, list = node.attributes; i < list.length; i += 1) {
+      var attr = list[i];
+      c(attr, st);
+    }
+  }
+};
+base.ExportAllDeclaration = function(node, st, c) {
+  if (node.exported) {
+    c(node.exported, st);
+  }
+  c(node.source, st, "Expression");
+  if (node.attributes) {
+    for (var i = 0, list = node.attributes; i < list.length; i += 1) {
+      var attr = list[i];
+      c(attr, st);
+    }
+  }
+};
+base.ImportAttribute = function(node, st, c) {
+  c(node.value, st, "Expression");
+};
+base.ImportDeclaration = function(node, st, c) {
+  for (var i = 0, list = node.specifiers; i < list.length; i += 1) {
+    var spec = list[i];
+    c(spec, st);
+  }
+  c(node.source, st, "Expression");
+  if (node.attributes) {
+    for (var i$1 = 0, list$1 = node.attributes; i$1 < list$1.length; i$1 += 1) {
+      var attr = list$1[i$1];
+      c(attr, st);
+    }
+  }
+};
+base.ImportExpression = function(node, st, c) {
+  c(node.source, st, "Expression");
+  if (node.options) {
+    c(node.options, st, "Expression");
+  }
+};
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
+base.TaggedTemplateExpression = function(node, st, c) {
+  c(node.tag, st, "Expression");
+  c(node.quasi, st, "Expression");
+};
+base.ClassDeclaration = base.ClassExpression = function(node, st, c) {
+  return c(node, st, "Class");
+};
+base.Class = function(node, st, c) {
+  if (node.id) {
+    c(node.id, st, "Pattern");
+  }
+  if (node.superClass) {
+    c(node.superClass, st, "Expression");
+  }
+  c(node.body, st);
+};
+base.ClassBody = function(node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1) {
+    var elt = list[i];
+    c(elt, st);
+  }
+};
+base.MethodDefinition = base.PropertyDefinition = base.Property = function(node, st, c) {
+  if (node.computed) {
+    c(node.key, st, "Expression");
+  }
+  if (node.value) {
+    c(node.value, st, "Expression");
+  }
+};
+
+export {
+  simple,
+  ancestor,
+  recursive,
+  full,
+  base
+};

package/dist/{chunk-EFCKV7MY.js → chunk-SBBQFPCJ.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   shouldTrack
-} from "./chunk-W3CS2KFV.js";
+} from "./chunk-GANST5K3.js";
 
 // src/telemetry/renderObservability.ts
 function renderObservabilityTelemetryPayload(observability) {

package/dist/{chunk-KHCTBZGJ.js → chunk-SK7TR7BL.js}

@@ -11,20 +11,20 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   EXCLUDED_TAGS,
   ensureHfIds,
   mintHfId,
   walkCompositionDescendants
-} from "./chunk-VYQYVYQ5.js";
+} from "./chunk-AEXVVABM.js";
 import {
   decodedUrlPath,
   removeElementWithGsapCascade
-} from "./chunk-B2A56S5C.js";
+} from "./chunk-2MCXIY4B.js";
 import {
   require_dist
-} from "./chunk-3NRB7YXW.js";
+} from "./chunk-2VXY3PEF.js";
 import {
   readClipTiming,
   writeClipTiming

package/dist/{chunk-KNU5COPB.js → chunk-T2EUWCJE.js}

@@ -13,7 +13,7 @@ function normalizeErrorMessage(error) {
     const msg = error.message;
     if (typeof msg === "string") return msg;
     try {
-      return JSON.stringify(error);
+      return JSON.stringify(error) ?? `{${Object.keys(error).join(", ")}}`;
     } catch {
       try {
         return `{${Object.keys(error).join(", ")}}`;

package/dist/{chunk-TRZVS6TL.js → chunk-T6O5OLN2.js}

@@ -8,20 +8,20 @@ import {
   DEFAULT_REGISTRY_URL,
   fetchItemFile,
   validRegistryItem
-} from "./chunk-LBNEH6IQ.js";
+} from "./chunk-32NB4VMH.js";
 import {
   publishRegistryFile,
   registryTargetPath
 } from "./chunk-GMECXFAN.js";
 import {
   validateVariables
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";
 import {
   isCompositionVariable
-} from "./chunk-RUOG4VB7.js";
+} from "./chunk-PKZ7RK5N.js";
 
 // src/registry/installer.ts
 import { createHash } from "crypto";

package/dist/{chunk-TFMZ4RKM.js → chunk-ULTKB5FC.js}

@@ -8,7 +8,7 @@ import {
   EncoderInterruptedError,
   encoderFailureError,
   prepareAnimatedGifInputs
-} from "./chunk-RQBB7PYT.js";
+} from "./chunk-YMQQXPD5.js";
 import {
   GENERIC_FAMILIES,
   collectFontFamilyCustomProperties,
@@ -16,7 +16,7 @@ import {
   iterateFontFamilyDeclarations,
   normalizeSystemFontPrimaryFamilies,
   resolveFontFamilyDeclarationFamilies
-} from "./chunk-LLFQA7XF.js";
+} from "./chunk-QFPBRZJD.js";
 import {
   parseEncoderOptions
 } from "./chunk-KLIKCX6Q.js";
@@ -73,6 +73,7 @@ import {
   createFrameLookupTable,
   createFrameReorderBuffer,
   createVideoFrameInjector,
+  declareContentAddressedUrl,
   decodePng,
   decodePngToRgb48le,
   deriveBeginFrameProbeTimeTicks,
@@ -156,7 +157,7 @@ import {
   validateEngineConfigSnapshot,
   verifyDiskDrawElementSamples,
   writeCapturedFrame
-} from "./chunk-NMDUSCCE.js";
+} from "./chunk-QX4TB4NH.js";
 import {
   DISTRIBUTED_FPS,
   HF_VFX_ATTR,
@@ -171,7 +172,7 @@ import {
   parseVfxChain,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-MGBUWPXX.js";
 import {
   assignBundledRuntimeCompositionIds,
   buildVariablesByCompScript,
@@ -184,7 +185,7 @@ import {
   isTemplateEntry,
   parsesAsScript,
   prepareFlattenedInnerRoot
-} from "./chunk-VYQYVYQ5.js";
+} from "./chunk-AEXVVABM.js";
 import {
   COMPOSITION_SOURCE_URL,
   HF_COLOR_GRADING_ATTR,
@@ -212,7 +213,7 @@ import {
   shouldClampResolvedMediaDuration,
   sourceTimeAt,
   styleElementsFor
-} from "./chunk-LM265QNK.js";
+} from "./chunk-B2XLXD7V.js";
 import {
   MAX_AUDIO_GAIN
 } from "./chunk-X7HBSTCZ.js";
@@ -226,7 +227,7 @@ import {
   isAspectAgnosticResolutionAlias,
   normalizeResolutionFlag,
   suggestMatchingPreset
-} from "./chunk-B2A56S5C.js";
+} from "./chunk-2MCXIY4B.js";
 import {
   TRANSITIONS,
   convertTransfer,
@@ -242,7 +243,7 @@ import {
 import {
   lintHyperframeHtml,
   resolveReferencedStart
-} from "./chunk-3NRB7YXW.js";
+} from "./chunk-2VXY3PEF.js";
 import {
   isUnresolvedAssetPlaceholder,
   readProjectFile,
@@ -6641,7 +6642,7 @@ async function readLocalFont(absPath) {
   return { kind: "inline", buffer: Buffer.concat(chunks, totalBytes) };
 }
 async function embedLocalFontFaces(html, projectDir) {
-  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-EGAAE7QL.js");
+  const { fontToDataUri: toDataUri } = await import("./deterministicFonts-RO2TCMLZ.js");
   const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
   const fontFaceRe = /@font-face\s*\{([^}]*)\}/gi;
   let result = html;
@@ -7728,6 +7729,10 @@ async function runProbeStage(input) {
                 if (el.loop && !existing.loop) {
                   existing.loop = true;
                 }
+                const audio = composition.audios.find(
+                  (audio2) => audio2.type === "video" && audio2.id === `${el.id}-audio`
+                );
+                if (audio) audio.loop = existing.loop;
               }
             } else if (!compiled.droppedMediaIds.has(el.id)) {
               composition.videos.push({
@@ -7765,6 +7770,7 @@ async function runProbeStage(input) {
                   el,
                   authoredStarts.get(el.id) ?? existing.mediaStart
                 );
+                existing.loop = el.loop;
                 if (el.volume > 0 && Math.abs((existing.volume ?? 1) - el.volume) > BROWSER_MEDIA_EPSILON) {
                   existing.volume = el.volume;
                 }
@@ -7776,6 +7782,7 @@ async function runProbeStage(input) {
                 start: el.start,
                 end: resolveBrowserMediaEnd(el.start, el.end, el.duration),
                 mediaStart: el.mediaStart,
+                loop: el.loop,
                 layer: 0,
                 volume: el.volume,
                 type: "audio"
@@ -8378,6 +8385,8 @@ function appendAutoDetectedVideoAudio(composition, extracted) {
       start: video.start,
       end: video.end,
       mediaStart: video.mediaStart,
+      playbackRate: video.playbackRate,
+      loop: video.loop,
       layer: 0,
       volume: 1,
       type: "video"
@@ -10025,6 +10034,7 @@ async function runCaptureHdrStage(input) {
         width,
         height,
         codec: preset.codec,
+        useGpu: job.config.useGpu,
         preset: preset.preset,
         quality: effectiveQuality,
         bitrate: effectiveBitrate,
@@ -15457,6 +15467,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   const needsAlpha = outputNeedsAlpha(config.format);
   const remoteFiles = Object.entries(options.remoteFiles ?? {});
   const remoteLocalPath = (rel) => join32(projectDir, ...rel.split("/"));
+  for (const [, file] of remoteFiles) declareContentAddressedUrl(file.url, file.sha256);
   const urlByAbsentLocalPath = new Map(
     remoteFiles.map(([rel, file]) => [remoteLocalPath(rel), file.url])
   );
@@ -15531,7 +15542,7 @@ async function compilePlanComposition(projectDir, config, planDir, options) {
   if (probeResult.fileServer) closeFileServerSafely(probeResult.fileServer, "plan", log);
   if (probeResult.probeSession) {
     try {
-      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-ZOXSEJCD.js");
+      const { closeCaptureSession: closeCaptureSession2 } = await import("./src-SSV66L3F.js");
       await closeCaptureSession2(probeResult.probeSession);
     } catch (err) {
       log.warn("[plan] probe session close failed", {
@@ -17182,7 +17193,7 @@ function startServer(options = {}) {
   });
   async function shutdown(signal) {
     log.info(`Received ${signal}, shutting down`);
-    const { drainBrowserPool } = await import("./src-ZOXSEJCD.js");
+    const { drainBrowserPool } = await import("./src-SSV66L3F.js");
     await drainBrowserPool().catch(() => {
     });
     const handle = await Promise.race([
@@ -18240,7 +18251,7 @@ function cfrEncodeArgs(inputArgs, encoder, fpsArg) {
     "-r",
     fpsArg
   ];
-  appendSoftwareEncoderThreadsArg(args);
+  appendSoftwareEncoderThreadsArg(args, "libx264");
   return args;
 }
 async function reencodeCfr(ctx, chunkPaths, encoder) {

package/dist/{chunk-UNR3P7IF.js → chunk-VNPADTDD.js}

@@ -9,13 +9,13 @@ import {
   markSeen,
   readSeen,
   writeRecord
-} from "./chunk-DCAI5DBR.js";
+} from "./chunk-2ST4WAFY.js";
 import {
   createProjectConfig
-} from "./chunk-JJJCFKMF.js";
+} from "./chunk-5IPKQHOL.js";
 import {
   isHyperframesProject
-} from "./chunk-GM3WIOO6.js";
+} from "./chunk-MGBUWPXX.js";
 
 // src/utils/desktopApp.ts
 import { spawn, spawnSync } from "child_process";

package/dist/{chunk-BFFLKQVB.js → chunk-VOM2HLUI.js}

@@ -16,18 +16,18 @@ import {
   pinnedPackageBesideCli,
   runNpm,
   sweepStaleStaging
-} from "./chunk-QH3T4WI2.js";
+} from "./chunk-EXAX37XR.js";
 import {
   emitWords,
   getPreparedWavDurationSeconds,
   prepareWav
-} from "./chunk-AQB5M53R.js";
+} from "./chunk-LOKCBZYF.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-RWYUK7LM.js";
+} from "./chunk-J2ASTCU6.js";
 import {
   verifies
-} from "./chunk-7LUJE3II.js";
+} from "./chunk-PFRG5P32.js";
 import {
   PARAKEET_MODEL_LABEL,
   SHERPA_ERROR_PREFIX,

package/dist/{chunk-GLG5JWLI.js → chunk-VRAXIQ6I.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   detectGpuEncoder
-} from "./chunk-NMDUSCCE.js";
+} from "./chunk-QX4TB4NH.js";
 import {
   runCancellableProcess
-} from "./chunk-DYAPHNV6.js";
+} from "./chunk-RWGASWT7.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";