@vfrey/vfrey 0.0.1 → 1.0.0-beta.1

package/vendor/framey/dist/chunk-WN4XZC5F.js

@@ -0,0 +1,504 @@
+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);
+import {
+  printDeprecationNotice,
+  withMeta
+} from "./chunk-O4YRB27L.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import {
+  installPageFunctionGuard,
+  launchManagedBrowser,
+  resolveCliChromeGpuMode,
+  resolveManagedGpuMode,
+  seekCompositionTimeline,
+  waitForRuntimeReady
+} from "./chunk-SZNTYTIV.js";
+import {
+  pageNavigationTimeoutMs
+} from "./chunk-YOR4CTCE.js";
+import {
+  resolveCompositionViewportFromHtml
+} from "./chunk-LEKZNRKI.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand,
+  setCommandExitCode
+} from "./chunk-JVBRJMOP.js";
+import {
+  resolveNaturalMediaTimelineDuration
+} from "./chunk-UJZREAV6.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import {
+  decodeWellFormedEscapes
+} from "./chunk-BSQ7XANM.js";
+
+// src/commands/validate.ts
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var CONTRAST_SAMPLES = 5;
+var SEEK_SETTLE_MS = 150;
+var PREFERRED_SEEK_TARGET_WAIT_MS = 500;
+var MEDIA_EXTENSIONS = /\.(aac|flac|m4a|mov|mp3|mp4|oga|ogg|wav|webm)$/i;
+function navigationTimeoutHint(err, navTimeoutMs) {
+  const msg = err instanceof Error ? err.message : String(err);
+  if (!/navigation timeout/i.test(msg)) return null;
+  return new Error(
+    `Page navigation timed out after ${navTimeoutMs}ms. A blocking external <script> (e.g. GSAP loaded from a CDN) can delay page load past this budget, which render shares. Vendor the script locally (recommended for deterministic renders), or re-run with a longer --timeout or PRODUCER_PAGE_NAVIGATION_TIMEOUT_MS.`
+  );
+}
+function shouldIgnoreRequestFailure(url, errorText, resourceType) {
+  if (errorText === "net::ERR_ABORTED" && isOptionalCaptionOverridesRequest(url)) return true;
+  if (errorText !== "net::ERR_ABORTED") return false;
+  if (resourceType === "media") return true;
+  try {
+    return MEDIA_EXTENSIONS.test(new URL(url).pathname);
+  } catch {
+    return false;
+  }
+}
+function projectPathOfUrl(url) {
+  return decodeWellFormedEscapes(new URL(url).pathname).replace(/^\//, "");
+}
+function shouldIgnoreHttpError(url, status) {
+  return status === 404 && isOptionalCaptionOverridesRequest(url);
+}
+function isOptionalCaptionOverridesRequest(url) {
+  try {
+    return new URL(url).pathname === "/caption-overrides.json";
+  } catch {
+    return false;
+  }
+}
+async function getCompositionDuration(page) {
+  return page.evaluate(() => {
+    if (window.__hf?.duration && window.__hf.duration > 0) return window.__hf.duration;
+    const root = document.querySelector("[data-composition-id][data-duration]");
+    return root ? parseFloat(root.getAttribute("data-duration") ?? "0") : 0;
+  });
+}
+function raceMediaReady(el, deadlineMs) {
+  if (Number.isFinite(el.duration) && el.duration > 0) return Promise.resolve();
+  return new Promise((resolve) => {
+    const onReady = () => {
+      el.removeEventListener("loadedmetadata", onReady);
+      el.removeEventListener("error", onReady);
+      clearTimeout(timer);
+      resolve();
+    };
+    el.addEventListener("loadedmetadata", onReady, { once: true });
+    el.addEventListener("error", onReady, { once: true });
+    const timer = setTimeout(onReady, Math.max(0, deadlineMs - Date.now()));
+  });
+}
+async function auditClipDurations(page, analyzeClipMediaFit, extraWaitMs) {
+  const clips = await page.evaluate(async (maxWaitMs) => {
+    const nodes = Array.from(
+      document.querySelectorAll("audio[data-duration]")
+    );
+    const deadline = Date.now() + maxWaitMs;
+    const reads = /* @__PURE__ */ new Map();
+    await Promise.all(
+      nodes.map((el) => {
+        if (Number.isFinite(el.duration) && el.duration > 0) return Promise.resolve();
+        const probe = new Audio();
+        probe.preload = "metadata";
+        probe.src = el.currentSrc || el.src || el.querySelector("source")?.src || "";
+        reads.set(el, probe);
+        return new Promise((resolve) => {
+          const cleanup = () => {
+            for (const target of [el, probe]) {
+              target.removeEventListener("loadedmetadata", onReady);
+              target.removeEventListener("error", onReady);
+            }
+            clearTimeout(timer);
+          };
+          const onReady = () => {
+            cleanup();
+            resolve();
+          };
+          for (const target of [el, probe]) {
+            target.addEventListener("loadedmetadata", onReady, { once: true });
+            target.addEventListener("error", onReady, { once: true });
+          }
+          const timer = setTimeout(onReady, Math.max(0, deadline - Date.now()));
+        });
+      })
+    );
+    const rows = [];
+    for (const el of nodes) {
+      const slot = parseFloat(el.getAttribute("data-duration") ?? "");
+      if (!(slot > 0)) continue;
+      rows.push({
+        id: el.id || el.getAttribute("src") || `(${el.tagName.toLowerCase()})`,
+        kind: el.tagName === "AUDIO" ? "Audio" : "Video",
+        slot,
+        attributes: {
+          "data-media-start": el.getAttribute("data-media-start"),
+          "data-playback-start": el.getAttribute("data-playback-start"),
+          "data-playback-rate": el.getAttribute("data-playback-rate"),
+          "data-automation": el.getAttribute("data-automation")
+        },
+        duration: Number.isFinite(el.duration) ? el.duration : reads.get(el)?.duration ?? Number.NaN,
+        loop: el.loop || el.getAttribute("data-loop") === "true"
+      });
+    }
+    return rows;
+  }, extraWaitMs);
+  const warnings = [];
+  const unreadable = [];
+  for (const clip of clips) {
+    if (!Number.isFinite(clip.duration) || clip.duration <= 0) {
+      unreadable.push(clip.id);
+      continue;
+    }
+    const mediaSeconds = resolveNaturalMediaTimelineDuration(
+      { getAttribute: (name) => clip.attributes[name] ?? null },
+      clip.duration
+    );
+    if (mediaSeconds === null) continue;
+    const fit = analyzeClipMediaFit({ slotSeconds: clip.slot, mediaSeconds, loop: clip.loop });
+    if (!fit) continue;
+    warnings.push({
+      level: "warning",
+      text: `${clip.kind} "${clip.id}" is ${mediaSeconds.toFixed(2)}s but its slot (data-duration) is ${clip.slot.toFixed(2)}s \u2014 the slot is shortened to the media length when rendered. Set data-duration to ~${mediaSeconds.toFixed(2)}s if that isn't intended.`
+    });
+  }
+  if (unreadable.length > 0) {
+    warnings.push({
+      level: "warning",
+      text: `Could not read the duration of ${unreadable.length} media element(s) within the validate timeout (${unreadable.join(", ")}); their slot vs. source fit was not checked. Re-run with a longer --timeout if the source is slow to load.`
+    });
+  }
+  return warnings;
+}
+async function runContrastAudit(page) {
+  const duration = await getCompositionDuration(page);
+  if (duration <= 0) return [];
+  await page.addScriptTag({ content: loadContrastAuditScript() });
+  const results = [];
+  for (let i = 0; i < CONTRAST_SAMPLES; i++) {
+    const t = +((i + 0.5) / CONTRAST_SAMPLES * duration).toFixed(3);
+    await seekCompositionTimeline(page, t, {
+      fallbackToBridgeAndTimelines: true,
+      waitForPreferredSeekTargetMs: PREFERRED_SEEK_TARGET_WAIT_MS,
+      animationFrameSettle: "none",
+      settleMs: SEEK_SETTLE_MS
+    });
+    try {
+      const candidates = await page.evaluate(
+        () => typeof window.__contrastAuditPrepare === "function" ? window.__contrastAuditPrepare() : []
+      );
+      const screenshot = await page.screenshot({
+        encoding: "base64",
+        type: "png",
+        omitBackground: true
+      });
+      const entries = await page.evaluate(
+        (b64, time, cands) => typeof window.__contrastAuditFinish === "function" ? window.__contrastAuditFinish(
+          b64,
+          time,
+          cands
+        ) : [],
+        screenshot,
+        t,
+        candidates
+      );
+      results.push(...entries);
+    } finally {
+      await page.evaluate(() => {
+        const restore = window.__contrastAuditRestoreIfPending;
+        if (typeof restore === "function") restore();
+      });
+    }
+  }
+  return results;
+}
+function loadContrastAuditScript() {
+  const candidates = [
+    join(__dirname, "contrast-audit.browser.js"),
+    join(__dirname, "commands", "contrast-audit.browser.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return readFileSync(candidate, "utf-8");
+  }
+  throw new Error("Missing contrast audit browser script");
+}
+function extractCompositionErrorsFromLint(lintResult) {
+  return lintResult.results.flatMap((r) => r.result.findings).filter((f) => f.code === "missing_or_empty_sub_composition" && f.severity === "error").map((f) => ({ level: "error", text: f.message }));
+}
+async function localizeRemoteAssets(html) {
+  let dir;
+  try {
+    const { loadProducer } = await import("./producer-SKU5EV3J.js");
+    const { localizeRemoteMediaSources, localizeRemoteImageSources, localizeRemoteFontFaces } = await loadProducer();
+    dir = mkdtempSync(join(tmpdir(), "hf-validate-assets-"));
+    const assetDir = dir;
+    const media = await localizeRemoteMediaSources(html, assetDir);
+    const images = await localizeRemoteImageSources(media.html, assetDir);
+    const fonts = await localizeRemoteFontFaces(images.html, assetDir);
+    const count = media.remoteMediaAssets.size + images.remoteMediaAssets.size + fonts.remoteMediaAssets.size;
+    return {
+      html: fonts.html,
+      assetRoots: count > 0 ? [assetDir] : [],
+      cleanup: () => rmSync(assetDir, { recursive: true, force: true })
+    };
+  } catch {
+    if (dir) rmSync(dir, { recursive: true, force: true });
+    return { html, assetRoots: [], cleanup: () => {
+    } };
+  }
+}
+async function validateInBrowser(project, opts) {
+  const projectDir = project.dir;
+  const { bundleToSingleHtml } = await import("./compiler-TM3W6GYF.js");
+  const { ensureBrowser } = await import("./manager-CD6LJ7ZN.js");
+  const { serveStaticProjectHtml } = await import("./staticProjectServer-DFVZOUGI.js");
+  const { lintProject } = await import("./lintProject-PDB3UN72.js");
+  const lintResult = await lintProject(projectDir);
+  const compositionErrors = extractCompositionErrorsFromLint(lintResult);
+  const html = await bundleToSingleHtml(projectDir);
+  const localized = await localizeRemoteAssets(html);
+  const server = await serveStaticProjectHtml(
+    projectDir,
+    localized.html,
+    void 0,
+    localized.assetRoots
+  ).catch((err) => {
+    localized.cleanup();
+    throw err;
+  });
+  const errors = [...compositionErrors];
+  const warnings = [];
+  let contrast;
+  const viewport = resolveCompositionViewportFromHtml(html);
+  try {
+    const browser = await ensureBrowser();
+    const puppeteer = await import("puppeteer-core");
+    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-Z5PGEMXB.js");
+    const requestedGpuMode = resolveCliChromeGpuMode();
+    const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu, resolveLocalWebGpu } = await import("./gpuPolicy-XLEXORZY.js");
+    const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath);
+    const requiresWebGpu = compositionRequiresWebGpu(html);
+    const { gpuConfig, softwareWebGpu } = resolveLocalWebGpu(resolvedGpuMode, requiresWebGpu);
+    const chromeBrowser = await launchManagedBrowser(puppeteer.default, {
+      headless: true,
+      executablePath: browser.executablePath,
+      args: buildChromeArgs({ ...viewport, captureMode: "screenshot", requiresWebGpu }, gpuConfig)
+    });
+    try {
+      const page = await chromeBrowser.newPage();
+      await installPageFunctionGuard(page);
+      await page.setViewport(viewport);
+      page.on("console", (msg) => {
+        const type = msg.type();
+        const loc = msg.location();
+        const text = msg.text();
+        if (type === "error") {
+          if (text.startsWith("Failed to load resource")) return;
+          errors.push({ level: "error", text, url: loc.url, line: loc.lineNumber });
+        } else if (type === "warn") {
+          warnings.push({ level: "warning", text, url: loc.url, line: loc.lineNumber });
+        }
+      });
+      page.on("pageerror", (err) => {
+        const text = normalizeErrorMessage(err);
+        if (text.includes("Unexpected token '<'") || text.includes("Unexpected token '&lt;'"))
+          return;
+        errors.push({ level: "error", text });
+      });
+      page.on("requestfailed", (req) => {
+        const url = req.url();
+        if (url.includes("favicon") || url.startsWith("data:")) return;
+        const failureText = req.failure()?.errorText;
+        if (shouldIgnoreRequestFailure(url, failureText, req.resourceType())) return;
+        const path = projectPathOfUrl(url);
+        errors.push({
+          level: "error",
+          text: `Failed to load ${path}: ${failureText ?? "net::ERR_FAILED"}`,
+          url
+        });
+      });
+      page.on("response", (res) => {
+        if (res.status() >= 400) {
+          const url = res.url();
+          if (url.includes("favicon")) return;
+          if (shouldIgnoreHttpError(url, res.status())) return;
+          const path = projectPathOfUrl(url);
+          errors.push({ level: "error", text: `${res.status()} loading ${path}`, url });
+        }
+      });
+      const navTimeoutMs = pageNavigationTimeoutMs(opts.timeout);
+      try {
+        await page.goto(server.url, { waitUntil: "domcontentloaded", timeout: navTimeoutMs });
+      } catch (err) {
+        const hinted = navigationTimeoutHint(err, navTimeoutMs);
+        if (hinted) throw hinted;
+        throw err;
+      }
+      await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
+      await waitForRuntimeReady(page, opts.timeout ?? 3e3);
+      await new Promise((r) => setTimeout(r, opts.timeout ?? 3e3));
+      for (const w of await auditClipDurations(page, analyzeClipMediaFit, opts.timeout ?? 3e3)) {
+        warnings.push(w);
+      }
+      if (opts.contrast) {
+        contrast = await runContrastAudit(page);
+      }
+    } finally {
+      await chromeBrowser.close().catch(() => {
+      });
+    }
+  } finally {
+    await server.close();
+    localized.cleanup();
+  }
+  return { errors, warnings, contrast };
+}
+function printContrastFailures(failures) {
+  console.log();
+  console.log(`  ${c.warn("\u26A0")} WCAG AA contrast warnings (${failures.length}):`);
+  for (const cf of failures) {
+    const threshold = cf.large ? "3" : "4.5";
+    console.log(
+      `    ${c.warn("\xB7")} ${cf.selector} ${c.dim(`"${cf.text}"`)} \u2014 ${c.warn(cf.ratio + ":1")} ${c.dim(`(need ${threshold}:1, t=${cf.time}s)`)}`
+    );
+  }
+}
+function emitJsonReport(errors, warnings, contrast, contrastFailures) {
+  console.log(
+    JSON.stringify(
+      withMeta(
+        {
+          ok: errors.length === 0,
+          errors,
+          warnings,
+          contrast,
+          contrastFailures: contrastFailures.length
+        },
+        { deprecated: true }
+      ),
+      null,
+      2
+    )
+  );
+}
+function formatConsoleEntry(prefix, e) {
+  return `  ${prefix} ${e.text}${e.line ? c.dim(` (line ${e.line})`) : ""}`;
+}
+function formatTotals(errors, warnings, contrastFailures) {
+  const parts = [`${errors.length} error(s)`, `${warnings.length} warning(s)`];
+  if (contrastFailures.length > 0) parts.push(`${contrastFailures.length} contrast warning(s)`);
+  return parts.join(", ");
+}
+function emitTextReport(errors, warnings, contrastFailures, contrastPassed) {
+  const hasIssues = errors.length > 0 || warnings.length > 0 || contrastFailures.length > 0;
+  if (!hasIssues) {
+    const suffix = contrastPassed.length > 0 ? ` \xB7 ${contrastPassed.length} text elements pass WCAG AA` : "";
+    console.log(`${c.success("\u25C7")}  No console errors${suffix}`);
+    return;
+  }
+  console.log();
+  for (const e of errors) console.log(formatConsoleEntry(c.error("\u2717"), e));
+  for (const w of warnings) console.log(formatConsoleEntry(c.warn("\u26A0"), w));
+  if (contrastFailures.length > 0) printContrastFailures(contrastFailures);
+  console.log();
+  console.log(`${c.accent("\u25C7")}  ${formatTotals(errors, warnings, contrastFailures)}`);
+}
+function emitFailureReport(message, asJson) {
+  if (asJson) {
+    console.log(
+      JSON.stringify(
+        withMeta({ ok: false, error: message, errors: [], warnings: [] }, { deprecated: true }),
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.error(`${c.error("\u2717")} ${message}`);
+}
+var validate_default = defineCommand({
+  meta: {
+    name: "validate",
+    description: `Load a composition in headless Chrome and report console errors (deprecated, use check)
+
+Examples:
+  framey validate
+  framey validate ./my-project
+  framey validate --json
+  framey validate --timeout 5000`
+  },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    json: { type: "boolean", description: "Output as JSON", default: false },
+    contrast: {
+      type: "boolean",
+      description: "WCAG contrast audit (enabled by default)",
+      default: true
+    },
+    timeout: {
+      type: "string",
+      description: "Ms to wait for scripts to settle and media to load (default: 3000). Also raises the page-navigation budget above its 10s floor when a slow external <script> needs longer.",
+      default: "3000"
+    }
+  },
+  async run({ args }) {
+    printDeprecationNotice("validate");
+    const project = resolveProject(args.dir);
+    const timeout = parseInt(args.timeout, 10) || 3e3;
+    const useContrast = args.contrast ?? true;
+    const asJson = Boolean(args.json);
+    if (!asJson) {
+      console.log(`${c.accent("\u25C6")}  Validating ${c.accent(project.name)} in headless Chrome`);
+    }
+    try {
+      const result = await validateInBrowser(project, { timeout, contrast: useContrast });
+      const exitCode = printValidationResult(result, asJson);
+      setCommandExitCode(exitCode);
+      return;
+    } catch (err) {
+      const message = normalizeErrorMessage(err);
+      emitFailureReport(message, asJson);
+      failCommand();
+    }
+  }
+});
+function printValidationResult(result, asJson) {
+  const { errors, warnings, contrast } = result;
+  const contrastFailures = (contrast ?? []).filter((e) => !e.wcagAA);
+  const contrastPassed = (contrast ?? []).filter((e) => e.wcagAA);
+  if (asJson) {
+    emitJsonReport(errors, warnings, contrast, contrastFailures);
+  } else {
+    emitTextReport(errors, warnings, contrastFailures, contrastPassed);
+  }
+  return errors.length > 0 ? 1 : 0;
+}
+
+export {
+  navigationTimeoutHint,
+  shouldIgnoreRequestFailure,
+  projectPathOfUrl,
+  shouldIgnoreHttpError,
+  raceMediaReady,
+  auditClipDurations,
+  extractCompositionErrorsFromLint,
+  validate_default
+};

package/vendor/framey/dist/chunk-WQ6ZXHFQ.js

@@ -0,0 +1,133 @@
+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);
+
+// src/utils/download.ts
+import { randomUUID } from "crypto";
+import { createWriteStream, renameSync, unlinkSync } from "fs";
+import { get as httpsGet } from "https";
+import { Transform } from "stream";
+import { pipeline } from "stream/promises";
+var DEFAULT_DOWNLOAD_TIMEOUT_MS = 3e4;
+var REDIRECT_CODES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function redirectTarget(location, from) {
+  return new URL(location, from).toString();
+}
+var MAX_REDIRECTS = 10;
+function removePartialFile(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+function measureDownload(options, contentLength) {
+  const length = Number(contentLength);
+  const totalBytes = Number.isSafeInteger(length) && length >= 0 ? length : null;
+  let receivedBytes = 0;
+  let reportedAt = Date.now();
+  options.onProgress?.(0, totalBytes);
+  const stream = new Transform({
+    transform(chunk, _encoding, callback) {
+      receivedBytes += chunk.byteLength;
+      if (options.maxBytes !== void 0 && receivedBytes > options.maxBytes) {
+        callback(new Error(`Download exceeded ${options.maxBytes} bytes`));
+        return;
+      }
+      const now = Date.now();
+      if (now - reportedAt >= 100) {
+        options.onProgress?.(receivedBytes, totalBytes);
+        reportedAt = now;
+      }
+      callback(null, chunk);
+    }
+  });
+  return { stream, complete: () => options.onProgress?.(receivedBytes, totalBytes) };
+}
+function getUrl(url, signal, onResponse) {
+  return signal ? httpsGet(url, { signal }, onResponse) : httpsGet(url, onResponse);
+}
+function downloadFile(url, dest, options = {}) {
+  const tmp = `${dest}.${process.pid}.${randomUUID()}.tmp`;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    const follow = (u, hops = 0) => {
+      let activeResponse;
+      let responseDiscarded = false;
+      let responsePipelineStarted = false;
+      let requestError;
+      let request;
+      try {
+        request = getUrl(u, options.signal, (res) => {
+          activeResponse = res;
+          if (res.statusCode && REDIRECT_CODES.has(res.statusCode)) {
+            const location = res.headers.location;
+            if (location) {
+              responseDiscarded = true;
+              res.destroy();
+              if (hops >= MAX_REDIRECTS) {
+                removePartialFile(tmp);
+                reject(
+                  new Error(
+                    `Download failed: more than ${MAX_REDIRECTS} redirects from ${url.split("?")[0]}`
+                  )
+                );
+                return;
+              }
+              try {
+                follow(redirectTarget(location, u), hops + 1);
+              } catch (error) {
+                removePartialFile(tmp);
+                reject(error);
+              }
+              return;
+            }
+          }
+          if (res.statusCode !== 200) {
+            responseDiscarded = true;
+            res.destroy();
+            removePartialFile(tmp);
+            reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+            return;
+          }
+          const meter = measureDownload(options, res.headers["content-length"]);
+          const file = createWriteStream(tmp);
+          responsePipelineStarted = true;
+          const transfer = pipeline(res, meter.stream, file);
+          transfer.then(() => {
+            renameSync(tmp, dest);
+            meter.complete();
+            resolve();
+          }).catch((err) => {
+            removePartialFile(tmp);
+            reject(requestError ?? err);
+          });
+        });
+      } catch (error) {
+        removePartialFile(tmp);
+        reject(error);
+        return;
+      }
+      request.setTimeout(timeoutMs, () => {
+        request.destroy(new Error(`Download timed out after ${timeoutMs}ms`));
+      });
+      request.on("error", (err) => {
+        if (responseDiscarded) return;
+        if (responsePipelineStarted) {
+          requestError = err;
+          activeResponse?.destroy(err);
+          return;
+        }
+        removePartialFile(tmp);
+        reject(err);
+      });
+    };
+    follow(url);
+  });
+}
+
+export {
+  downloadFile
+};

package/vendor/framey/dist/chunk-X7HBSTCZ.js

@@ -0,0 +1,53 @@
+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);
+
+// ../core/dist/audibleVideo.js
+var AUDIBLE_VIDEO_QUALIFIER = ':not([muted]):is(:not([data-has-audio]),[data-has-audio="true"])';
+var AUDIBLE_MEDIA_SELECTOR = `audio[data-start], video[data-start]${AUDIBLE_VIDEO_QUALIFIER}`;
+function isAudibleVideoElement(el) {
+  if (el.tagName.toLowerCase() !== "video" || el.hasAttribute("muted"))
+    return false;
+  const declared = el.getAttribute("data-has-audio");
+  return declared === null || declared === "true";
+}
+function audibleVideoNeedsWebAudio(fields) {
+  return (fields.volume ?? 1) > 1 || Boolean(fields.fxChain || fields.automation || fields.audioGroup || fields.masterChain);
+}
+
+// ../core/dist/audioGain.js
+var MAX_AUDIO_GAIN_DB = 12;
+function audioDbToGain(db) {
+  return 10 ** (db / 20);
+}
+var MAX_AUDIO_GAIN = audioDbToGain(MAX_AUDIO_GAIN_DB);
+function clampAudioGain(value) {
+  if (!Number.isFinite(value))
+    return 1;
+  return Math.max(0, Math.min(MAX_AUDIO_GAIN, value));
+}
+function gainTimesLane(gain, lane) {
+  return clampAudioGain(gain * lane);
+}
+function clipGain(volume, tweened) {
+  return tweened ? 1 : clampAudioGain(volume);
+}
+function formatAudioGain(gain) {
+  return clampAudioGain(gain).toFixed(6).replace(/\.?0+$/, "");
+}
+
+export {
+  MAX_AUDIO_GAIN_DB,
+  MAX_AUDIO_GAIN,
+  clampAudioGain,
+  gainTimesLane,
+  clipGain,
+  formatAudioGain,
+  AUDIBLE_VIDEO_QUALIFIER,
+  AUDIBLE_MEDIA_SELECTOR,
+  isAudibleVideoElement,
+  audibleVideoNeedsWebAudio
+};

package/vendor/framey/dist/chunk-X7MTZ4T2.js

@@ -0,0 +1,6 @@
+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);