hyperframes 0.8.181 → 0.8.184

package/dist/{chunk-TO6JNTML.js → chunk-7MB2ZAQF.js}

@@ -27,7 +27,7 @@ import {
 } from "./chunk-GMECXFAN.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-LBQFLUIY.js";
+} from "./chunk-J3QM7AHP.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";
@@ -2428,8 +2428,8 @@ var require_json_schema_2020_12 = __commonJS({
         with$data(this, validation)
       ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
       return this;
-      function with$data(ajv2, sch) {
-        return $data ? ajv2.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
       }
     }
     exports.default = addMetaSchema2020;
@@ -2734,17 +2734,22 @@ var registry_item_default = {
 };
 
 // src/registry/validation.ts
-var ajv = new import__.Ajv2020({ strict: false, validateFormats: false });
-var manifestShape = ajv.compile(registry_default);
-var itemShape = ajv.compile(registry_item_default);
+function compileShapes() {
+  const ajv = new import__.Ajv2020({ strict: false, validateFormats: false });
+  return {
+    manifest: ajv.compile(registry_default),
+    item: ajv.compile(registry_item_default)
+  };
+}
+var shapesCompiledOnFirstUse;
 function validRegistryName(name) {
   return name.length <= 128 && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(name);
 }
 function validRegistryManifest(value) {
-  return manifestShape(value) && value.items.length <= 1e4 && value.items.every((item) => validRegistryName(item.name));
+  return (shapesCompiledOnFirstUse ??= compileShapes()).manifest(value) && value.items.length <= 1e4 && value.items.every((item) => validRegistryName(item.name));
 }
 function validRegistryItem(value, name, type) {
-  return itemShape(value) && value.name === name && value.type === type && validRegistryName(value.name) && value.files.length <= 1e3;
+  return (shapesCompiledOnFirstUse ??= compileShapes()).item(value) && value.name === name && value.type === type && validRegistryName(value.name) && value.files.length <= 1e3;
 }
 
 // src/registry/boundedFile.ts

package/dist/{chunk-55IG255C.js → chunk-7NRI7HYX.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   sherpaParakeetInstalled,
   sherpaUnsupportedReason
-} from "./chunk-WUUCEFL5.js";
+} from "./chunk-R2BFTECP.js";
 import {
   findParakeet
 } from "./chunk-JZIEZCQM.js";

package/dist/{chunk-VAJIPSN6.js → chunk-ABZYYUUH.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   VERSION
-} from "./chunk-XEWHUPFS.js";
+} from "./chunk-4N4P3ZWL.js";
 
 // src/utils/updateCheck.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-GK2FIKIQ.js → chunk-ADDHW2FS.js}

@@ -4,6 +4,9 @@ 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 {
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
 import {
   cleanAssetUrl,
   collectSubCompositionSrcs,
@@ -16,9 +19,6 @@ import {
   resolveLocalAssetCandidates,
   resolveProjectRelativeSrc
 } from "./chunk-6BNTGNGD.js";
-import {
-  findFfBinary
-} from "./chunk-VAS6HQX3.js";
 import {
   COMPOSITION_VARIABLE_TYPES,
   FONT_ALIAS_KEYS,
@@ -32,12 +32,16 @@ import {
 import {
   COLOR_GRADING_SOURCE_TAGS,
   COMPOSITION_ATTRIBUTES,
+  MEDIA_START_BASIS_ATTR,
   checkSubCompositionUsability,
+  compositionOriginSeconds,
+  cutToHostSlots,
   parseNumeric,
   readClipTiming,
+  resolveMediaStartSeconds,
   spansOverlap,
   validateColorGradingContract
-} from "./chunk-32GKETR7.js";
+} from "./chunk-MMQ52NIZ.js";
 import {
   readAuthoredDurationSeconds,
   readDataDurationSeconds,
@@ -48,16 +52,16 @@ import {
   Parser,
   parseHTML
 } from "./chunk-SDYDNHEE.js";
-import {
-  parse,
-  parseExpressionAt,
-  simple
-} from "./chunk-TYXH3EKP.js";
 import {
   isSceneLikeCompositionId,
   parseSlideshowManifest,
   resolveSlideshow
 } from "./chunk-IXLUTE6N.js";
+import {
+  parse,
+  parseExpressionAt,
+  simple
+} from "./chunk-TYXH3EKP.js";
 import {
   __commonJS,
   __require,
@@ -3767,6 +3771,128 @@ function trackKindOf(node) {
 import { createHash } from "crypto";
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
 import { dirname as dirname2, extname, join as join3, relative as relative2, resolve } from "path";
+
+// ../parsers/dist/referenceResolver.js
+var COMPOSITION_ATTRIBUTES2 = Object.freeze({
+  start: "data-start",
+  duration: "data-duration",
+  trackIndex: "data-track-index",
+  derivedEnd: "data-end",
+  legacyTrack: "data-layer"
+});
+var CANONICAL_AUTHORED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.start,
+  COMPOSITION_ATTRIBUTES2.duration,
+  COMPOSITION_ATTRIBUTES2.trackIndex
+]);
+var DERIVED_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.derivedEnd
+]);
+var LEGACY_TIMING_ATTRIBUTES = Object.freeze([
+  COMPOSITION_ATTRIBUTES2.derivedEnd,
+  COMPOSITION_ATTRIBUTES2.legacyTrack
+]);
+function parseNumeric2(value) {
+  if (value == null || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+var REFERENCE_ID_PATTERN = /^[A-Za-z0-9_.:-]+$/;
+function isAsciiDigitAt(value, index) {
+  const code = value.charCodeAt(index);
+  return code >= 48 && code <= 57;
+}
+function skipDigitsLeft(value, start) {
+  let cursor = start;
+  while (cursor >= 0 && isAsciiDigitAt(value, cursor)) cursor--;
+  return cursor;
+}
+function skipWhitespaceLeft(value, start) {
+  let cursor = start;
+  while (cursor >= 0 && (value[cursor] ?? "").trim() === "") cursor--;
+  return cursor;
+}
+function findMagnitudeStart(value) {
+  const last = value.length - 1;
+  if (!isAsciiDigitAt(value, last)) return null;
+  let cursor = skipDigitsLeft(value, last);
+  if (value[cursor] === ".") cursor = skipDigitsLeft(value, cursor - 1);
+  return cursor + 1;
+}
+function parseReferenceOffset(value) {
+  const magnitudeStart = findMagnitudeStart(value);
+  if (magnitudeStart == null) return null;
+  const operatorIndex = skipWhitespaceLeft(value, magnitudeStart - 1);
+  const operator = value[operatorIndex];
+  if (operator !== "+" && operator !== "-") return null;
+  const refId = value.slice(0, operatorIndex).trim();
+  if (!REFERENCE_ID_PATTERN.test(refId)) return null;
+  const magnitude = Number(value.slice(magnitudeStart));
+  if (!Number.isFinite(magnitude)) return null;
+  return { refId, operator, magnitude };
+}
+function parseStartExpression(raw) {
+  const normalized2 = (raw ?? "").trim();
+  if (!normalized2) return null;
+  const absolute = parseNumeric2(normalized2);
+  if (absolute != null) return { kind: "absolute", value: absolute };
+  if (REFERENCE_ID_PATTERN.test(normalized2)) {
+    return { kind: "reference", refId: normalized2, offset: 0 };
+  }
+  const reference = parseReferenceOffset(normalized2);
+  if (!reference) return null;
+  return {
+    kind: "reference",
+    refId: reference.refId,
+    offset: reference.operator === "-" ? -reference.magnitude : reference.magnitude
+  };
+}
+function findReferenceTargetEl(doc, refId) {
+  return doc.getElementById(refId) ?? doc.querySelector(`[data-composition-id="${refId}"]`);
+}
+function resolveReferencedStart(doc, el, startCache, visiting) {
+  const cached = startCache.get(el);
+  if (cached !== void 0) return cached;
+  if (visiting.has(el)) return 0;
+  visiting.add(el);
+  try {
+    const expression = parseStartExpression(el.getAttribute("data-start"));
+    if (!expression) {
+      startCache.set(el, 0);
+      return 0;
+    }
+    if (expression.kind === "absolute") {
+      const value = Math.max(0, expression.value);
+      startCache.set(el, value);
+      return value;
+    }
+    const target = findReferenceTargetEl(doc, expression.refId);
+    if (!target) {
+      startCache.set(el, 0);
+      return 0;
+    }
+    const targetStart = resolveReferencedStart(doc, target, startCache, visiting);
+    const targetDuration = resolveReferencedDuration(doc, target, startCache, visiting);
+    const resolved = targetDuration != null && targetDuration > 0 ? Math.max(0, targetStart + targetDuration + expression.offset) : Math.max(0, targetStart + expression.offset);
+    startCache.set(el, resolved);
+    return resolved;
+  } finally {
+    visiting.delete(el);
+  }
+}
+function resolveReferencedDuration(doc, el, startCache, visiting) {
+  const durationAttr = parseNumeric2(el.getAttribute("data-duration"));
+  if (durationAttr != null && durationAttr > 0) return durationAttr;
+  const endAttr = parseNumeric2(el.getAttribute("data-end"));
+  if (endAttr != null) {
+    const start = resolveReferencedStart(doc, el, startCache, visiting);
+    const delta = endAttr - start;
+    if (Number.isFinite(delta) && delta > 0) return delta;
+  }
+  return null;
+}
+
+// ../lint/dist/index.js
 import { execFile } from "child_process";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -3883,11 +4009,13 @@ function readAttr(tagSource, attr) {
 function hasAttrName(tagSource, attr) {
   return readDecodedAttr(tagSource, attr) !== null;
 }
+function isAudibleVideo(attr) {
+  if (attr("muted") !== null) return false;
+  const declared = attr("data-has-audio");
+  return declared === null || declared === "true";
+}
 function isAudibleVideoTag(tagSource) {
-  if (hasAttrName(tagSource, "muted")) return false;
-  if (!hasAttrName(tagSource, "data-has-audio")) return true;
-  const declared = readAttr(tagSource, "data-has-audio");
-  return declared === "true";
+  return isAudibleVideo((name) => readDecodedAttr(tagSource, name));
 }
 function mediaTimeWindow(tagSource) {
   const start = Number(readAttr(tagSource, "data-start"));
@@ -10752,7 +10880,7 @@ async function lintProject(projectDir, entryFile, hostOptions = {}) {
     ...lintTextureMaskAssetNotFound(projectDir, allHtmlSources),
     ...!entryFile ? lintMultipleRootCompositions(projectDir) : [],
     ...!entryFile ? lintBlankRootWithStandaloneComposition(rootHtml, allHtmlSources) : [],
-    ...lintDuplicateAudioTracks(allHtmlSources),
+    ...lintDuplicateAudioTracks(projectDir, rootHtml),
     ...lintMissingOrEmptySubComposition(projectDir, rootHtml),
     ...await lintVideoMediaStartPastEof(projectDir, allHtmlSources),
     ...await lintHevcPreviewCodec(collectLocalVideoCandidates(projectDir, allHtmlSources))
@@ -10961,30 +11089,77 @@ function lintMultipleRootCompositions(projectDir) {
   }
   return findings;
 }
-function lintDuplicateAudioTracks(htmlSources) {
-  const findings = [];
-  const tracks = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const { html } of htmlSources) {
-    const soundTagRe = /<(?:audio|video)\b[^>]*>/gi;
-    let match;
-    while ((match = soundTagRe.exec(html)) !== null) {
-      const tag = match[0];
-      if (/^<video/i.test(tag) && !isAudibleVideoTag(tag)) continue;
-      const trackStr = readAttr(tag, "data-track-index");
-      const startStr = readAttr(tag, "data-start");
-      const durStr = readAttr(tag, "data-duration");
-      const src = readDecodedAttr(tag, "src") || "unknown";
-      if (!trackStr || !startStr) continue;
-      const trackIndex = parseInt(trackStr, 10);
-      const start = parseFloat(startStr);
-      const duration = durStr ? parseFloat(durStr) : Infinity;
-      const key = `${src}:${start}:${duration}:${trackIndex}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      tracks.push({ trackIndex, start, end: start + duration, src });
+var timingFile = (doc) => ({ doc, starts: /* @__PURE__ */ new Map() });
+var localStart = (file, el) => resolveReferencedStart(file.doc, el, file.starts, /* @__PURE__ */ new Set());
+var localDuration = (file, el) => resolveReferencedDuration(file.doc, el, file.starts, /* @__PURE__ */ new Set());
+function collectMainTimelineAudio(projectDir, rootHtml) {
+  const spans = [];
+  const mount = (html, at) => {
+    const { document: document2 } = parseHTML(html);
+    const root = querySelectorAllIncludingTemplates(document2, "[data-composition-id]")[0];
+    if (root) visit(root, { ...at, file: timingFile(document2) });
+  };
+  const visit = (parent, at) => {
+    for (const el of parent.children) {
+      if (el.tagName === "TEMPLATE") {
+        visit(el.content, at);
+        continue;
+      }
+      const span = audioSpanOf(el, at.file, at.origin, at.slots);
+      if (span) spans.push(span);
+      const scope = nestedScopeOf(el, at.file, at.origin, at.slots);
+      if (!scope) {
+        visit(el, at);
+        continue;
+      }
+      const inner = { ...at, ...scope };
+      const src = el.getAttribute("data-composition-src")?.trim();
+      const file = src && !isUnresolvedAssetPlaceholder(src) && !isRemoteOrInlineUrl(src);
+      const filePath = file ? resolve(projectDir, src) : null;
+      if (filePath && !at.mounting.includes(filePath)) {
+        const read = readProjectFile(filePath);
+        if (read.kind === "file")
+          mount(read.text, { ...inner, mounting: [...at.mounting, filePath] });
+      }
+      visit(el, inner);
     }
+  };
+  const { document } = parseHTML(rootHtml);
+  visit(document, { file: timingFile(document), origin: 0, slots: [], mounting: [] });
+  return spans;
+}
+function nestedScopeOf(el, file, origin, slots) {
+  if (!el.hasAttribute("data-composition-id") && !el.hasAttribute("data-composition-src")) {
+    return null;
   }
+  const start = origin + localStart(file, el);
+  const duration = localDuration(file, el);
+  const window = duration === null ? [] : [{ start, end: start + duration }];
+  return { origin: compositionOriginSeconds(start, el), slots: [...slots, ...window] };
+}
+function audioSpanOf(el, file, origin, slots) {
+  const tag = el.tagName.toLowerCase();
+  if (tag !== "audio" && !(tag === "video" && isAudibleVideo((name) => el.getAttribute(name)))) {
+    return null;
+  }
+  const trackStr = el.getAttribute("data-track-index");
+  if (!trackStr || !el.hasAttribute("data-start")) return null;
+  const start = resolveMediaStartSeconds({
+    authoredStart: parseNumeric(el.getAttribute("data-start")),
+    hostStart: origin,
+    hasAutoStart: el.hasAttribute("data-hf-auto-start"),
+    basis: el.getAttribute(MEDIA_START_BASIS_ATTR),
+    ordinaryStart: () => origin + localStart(file, el)
+  });
+  const duration = parseNumeric(el.getAttribute("data-duration")) ?? localDuration(file, el);
+  const kept = cutToHostSlots({ start, end: start + (duration ?? Infinity) }, slots);
+  if (kept.end <= kept.start) return null;
+  return { trackIndex: parseInt(trackStr, 10), ...kept, src: el.getAttribute("src") || "unknown" };
+}
+var formatSeconds = (t) => Number.isFinite(t) ? String(Number(t.toFixed(2))) : "end";
+function lintDuplicateAudioTracks(projectDir, rootHtml) {
+  const findings = [];
+  const tracks = collectMainTimelineAudio(projectDir, rootHtml);
   for (let i = 0; i < tracks.length; i++) {
     for (let j = i + 1; j < tracks.length; j++) {
       const a = tracks[i];
@@ -10994,7 +11169,7 @@ function lintDuplicateAudioTracks(htmlSources) {
         findings.push({
           code: "duplicate_audio_track",
           severity: "warning",
-          message: `Multiple audible <audio>/<video> elements on track ${a.trackIndex} overlap (${a.src} at ${a.start}-${Number.isFinite(a.end) ? a.end.toFixed(1) : "end"}s, ${b.src} at ${b.start}-${Number.isFinite(b.end) ? b.end.toFixed(1) : "end"}s). This causes layered audio playback.`,
+          message: `Multiple audible <audio>/<video> elements on track ${a.trackIndex} overlap (${a.src} at ${formatSeconds(a.start)}-${formatSeconds(a.end)}s, ${b.src} at ${formatSeconds(b.start)}-${formatSeconds(b.end)}s). This causes layered audio playback.`,
           fixHint: "Use non-overlapping time windows or different track indices."
         });
       }
@@ -11060,6 +11235,8 @@ function isSnippetFragment(html) {
 }
 
 export {
+  resolveReferencedStart,
+  resolveReferencedDuration,
   require_dist,
   resolveCompositionDuration,
   LINT_RULE_COUNT,

package/dist/{chunk-ZUOSILUE.js → chunk-BCHSTE7U.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-S7NVL5VF.js");
+  return await import("./src-6MSC62U2.js");
 }
 
 export {

package/dist/{chunk-AOWDVB2T.js → chunk-CXABAXB3.js}

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

package/dist/{chunk-E24HSMZV.js → chunk-CYBXXSC4.js}

@@ -5,12 +5,17 @@ var require = __hf_createRequire(import.meta.url);
 var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
+  runCancellableProcess,
   runRenderSetupWorker
-} from "./chunk-D3ZWBHZP.js";
+} from "./chunk-DYAPHNV6.js";
 import {
+  getFreeDiskMb
+} from "./chunk-T6AGUTZJ.js";
+import {
+  browserPathFromEnv,
   managedChromeVersion,
   pickSharedShell
-} from "./chunk-537IYAEE.js";
+} from "./chunk-4UMPIPCQ.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -31,7 +36,33 @@ import {
 } from "fs";
 import { homedir } from "os";
 import { debuglog } from "util";
-import { basename, dirname, join, relative } from "path";
+import { basename, dirname as dirname2, join, relative } from "path";
+
+// src/browser/unzipArchive.ts
+import { mkdir } from "fs/promises";
+import { dirname } from "path";
+var UNZIP_DISK_FULL_STATUS = 50;
+async function unzipArchive(archivePath, folderPath) {
+  await mkdir(dirname(folderPath), { recursive: true });
+  try {
+    await runCancellableProcess("unzip", ["-q", "-o", archivePath, "-d", folderPath], {
+      detached: false
+    });
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    if (err.status === UNZIP_DISK_FULL_STATUS) {
+      throw new Error(
+        "Extraction failed: the disk filled up while unpacking Chrome. Free disk space, then retry.",
+        { cause: err }
+      );
+    }
+    const said = err.stderr?.trim();
+    throw new Error(`Extraction failed: ${said || err.message}`, { cause: err });
+  }
+}
+
+// src/browser/manager.ts
 async function loadPuppeteerBrowsers() {
   try {
     return await import("@puppeteer/browsers");
@@ -45,6 +76,7 @@ Fix: run \`npm install\` or \`bun install\` to restore missing packages, then re
 }
 var CACHE_ROOT_DIR = join(homedir(), ".cache", "hyperframes");
 var CACHE_DIR = join(homedir(), ".cache", "hyperframes", "chrome");
+var ARCHIVE_PLUS_UNPACKED_SHELL_MB = 512;
 var PUPPETEER_CACHE_DIR = join(homedir(), ".cache", "puppeteer", "chrome-headless-shell");
 var INSTALL_LOCK_DIR = join(CACHE_ROOT_DIR, ".chrome.install.lock");
 var INSTALL_RECLAIM_LOCK_DIR = join(CACHE_ROOT_DIR, ".chrome.install.reclaim.lock");
@@ -206,7 +238,7 @@ function whichBinary(name) {
   }
 }
 function findFromEnv() {
-  const envPath = process.env["HYPERFRAMES_BROWSER_PATH"] ?? process.env["PRODUCER_HEADLESS_SHELL_PATH"];
+  const envPath = browserPathFromEnv()?.path;
   if (envPath && existsSync(envPath)) {
     return { executablePath: envPath, source: "env" };
   }
@@ -458,21 +490,28 @@ async function downloadBrowser(options) {
   if (isLinuxArm()) {
     return ensureLinuxArmBrowser(options);
   }
-  const { Browser, detectBrowserPlatform, install } = await loadPuppeteerBrowsers();
+  removeInstallLeftovers();
+  const freeMb = getFreeDiskMb(CACHE_ROOT_DIR);
+  if (freeMb !== null && freeMb < ARCHIVE_PLUS_UNPACKED_SHELL_MB) {
+    throw new Error(
+      `Low disk space: Chrome Headless Shell needs about ${ARCHIVE_PLUS_UNPACKED_SHELL_MB} MB to download, ${freeMb} MB free at ${CACHE_ROOT_DIR}. Free disk space, then retry.`
+    );
+  }
+  const { Browser, Cache, detectBrowserPlatform, install } = await loadPuppeteerBrowsers();
   const platform = detectBrowserPlatform();
   if (!platform) {
     throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`);
   }
-  removeInstallLeftovers();
   const stagingDir = join(CACHE_ROOT_DIR, `${STAGING_PREFIX}${randomUUID()}`);
   const clearStaging = () => rmSync(stagingDir, { recursive: true, force: true });
   let unzipLog = [];
-  const runInstall = () => {
+  const buildId = managedChromeVersion();
+  const runInstall = async () => {
     unzipLog = [];
-    return install({
+    const installOptions = {
       cacheDir: stagingDir,
       browser: Browser.CHROMEHEADLESSSHELL,
-      buildId: managedChromeVersion(),
+      buildId,
       platform,
       downloadProgressCallback: options?.onProgress,
       logger: (prefix) => {
@@ -485,7 +524,14 @@ async function downloadBrowser(options) {
           if (debug.enabled) debug(line);
         };
       }
-    });
+    };
+    const unzipMayAskOnInput = process.platform !== "win32";
+    if (unzipMayAskOnInput) {
+      const archive = await install({ ...installOptions, unpack: false });
+      const into = new Cache(stagingDir).installationDir(installOptions.browser, platform, buildId);
+      await unzipArchive(archive, into);
+    }
+    return install(installOptions);
   };
   try {
     const staged = await installWithCorruptArchiveRecovery(
@@ -527,7 +573,7 @@ function assertExecutableUnpacked(stagingDir, executablePath) {
 function moveStagedInstallIntoCache(stagingDir, staged) {
   const target = join(CACHE_DIR, relative(stagingDir, staged.path));
   const aside = join(CACHE_ROOT_DIR, `${REPLACED_PREFIX}${randomUUID()}`);
-  mkdirSync(dirname(target), { recursive: true });
+  mkdirSync(dirname2(target), { recursive: true });
   let replaced = false;
   try {
     renameSync(target, aside);
@@ -546,6 +592,7 @@ function moveStagedInstallIntoCache(stagingDir, staged) {
 }
 var STAGING_PREFIX = ".chrome-staging-";
 var REPLACED_PREFIX = ".chrome-replaced-";
+var isInstallLeftover = (name) => name.startsWith(STAGING_PREFIX) || name.startsWith(REPLACED_PREFIX);
 function removeInstallLeftovers() {
   let names;
   try {
@@ -554,13 +601,16 @@ function removeInstallLeftovers() {
     if (isErrno(err, "ENOENT")) return false;
     throw err;
   }
-  const leftovers = names.filter(
-    (name) => name.startsWith(STAGING_PREFIX) || name.startsWith(REPLACED_PREFIX)
-  );
+  const leftovers = names.filter(isInstallLeftover);
   for (const name of leftovers)
     rmSync(join(CACHE_ROOT_DIR, name), { recursive: true, force: true });
   return leftovers.length > 0;
 }
+async function sweepKilledInstalls() {
+  const names = existsSync(CACHE_ROOT_DIR) ? readdirSync(CACHE_ROOT_DIR) : [];
+  if (!names.some(isInstallLeftover)) return;
+  await withInstallLock(async () => removeInstallLeftovers());
+}
 function clearBrowser() {
   const removedLeftovers = removeInstallLeftovers();
   if (!existsSync(CACHE_DIR)) return removedLeftovers;
@@ -581,6 +631,7 @@ export {
   ensureBrowser,
   isCorruptArchiveError,
   installWithCorruptArchiveRecovery,
+  sweepKilledInstalls,
   clearBrowser,
   isLinuxArm
 };

package/dist/{chunk-NZZYJOMJ.js → chunk-CZUAX3BV.js}

@@ -18,10 +18,11 @@ var CONNECTIONS = 8;
 var RETRIES = 3;
 async function downloadToFile(url, destPath, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
+  const partBytes = options.partBytes ?? PART_BYTES;
   const failFast = new AbortController();
   const signal = options.signal ? AbortSignal.any([options.signal, failFast.signal]) : failFast.signal;
   const get = async (range) => fetchImpl(url, { signal, headers: range ? { range } : {} });
-  let first = await get(`bytes=0-${PART_BYTES - 1}`);
+  let first = await get(`bytes=0-${partBytes - 1}`);
   if (first.status === 416 || first.status === 206 && contentRangeTotal(first) === void 0) {
     await first.body?.cancel();
     first = await get();
@@ -74,10 +75,10 @@ async function downloadToFile(url, destPath, options = {}) {
     };
     const parts = [];
     if (ranged && total !== void 0) {
-      parts.push(fetchRange(0, Math.min(PART_BYTES, total) - 1, first));
-      const rest = total - PART_BYTES;
-      const size = Math.ceil(rest / Math.min(CONNECTIONS - 1, Math.ceil(rest / PART_BYTES)));
-      for (let start = PART_BYTES; start < total; start += size) {
+      parts.push(fetchRange(0, Math.min(partBytes, total) - 1, first));
+      const rest = total - partBytes;
+      const size = Math.ceil(rest / Math.min(CONNECTIONS - 1, Math.ceil(rest / partBytes)));
+      for (let start = partBytes; start < total; start += size) {
         parts.push(fetchRange(start, Math.min(start + size, total) - 1));
       }
     } else {

package/dist/{chunk-GV5R5B7Q.js → chunk-DGECWPTL.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-K2FLNJVB.js";
 import {
   failUsage
-} from "./chunk-PBN6GBJE.js";
+} from "./chunk-JVBRJMOP.js";
 
 // src/cloud/parsing.ts
 var INTEGER_RE = /^-?\d+$/;

package/dist/{chunk-BRHI7EIA.js → chunk-DKPNNYBZ.js}

@@ -12,6 +12,9 @@ var CPU_COMPOSITING = "--disable-gpu-compositing";
 function machServiceDenied(errorMessage) {
   return MACH_SERVICE_DENIED.test(errorMessage);
 }
+function pipeLaunchClosedOnMac(error, platform = process.platform) {
+  return platform === "darwin" && error instanceof Error && error.name === "TargetCloseError";
+}
 function inAgentSandbox(env = process.env, platform = process.platform) {
   return platform === "darwin" && env.CODEX_SANDBOX === "seatbelt";
 }
@@ -33,6 +36,7 @@ function sandboxDeniedRemediation(errorMessage) {
 
 export {
   machServiceDenied,
+  pipeLaunchClosedOnMac,
   inAgentSandbox,
   oneProcessOverPipe,
   isOneProcessOverPipe,

package/dist/{chunk-UIDZRCBG.js → chunk-DWUGKEHR.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-XEWHUPFS.js";
+} from "./chunk-4N4P3ZWL.js";
 
 // src/registry/compatibility.ts
 import { compareVersions } from "compare-versions";