hyperframes 0.8.150 → 0.8.152

package/dist/{checkBrowser-MXBDNZJB.js → checkBrowser-MSTVEL4V.js}

@@ -8,19 +8,20 @@ import {
   auditClipDurations,
   shouldIgnoreHttpError,
   shouldIgnoreRequestFailure
-} from "./chunk-F2RLIE7P.js";
+} from "./chunk-ANS56TPS.js";
 import {
+  checkSnapshotDirectory,
   rectToBbox
-} from "./chunk-WBLXWOYK.js";
+} from "./chunk-XSEGMQYA.js";
 import {
   ambiguousIssue,
   loadBrowserScript
-} from "./chunk-FPAT5HTI.js";
+} from "./chunk-BYJYQWEX.js";
 import {
   serveStaticProjectHtml
-} from "./chunk-S5F26DUL.js";
+} from "./chunk-GQETH4PE.js";
 import "./chunk-XUHOIDKG.js";
-import "./chunk-A6ZO4BX7.js";
+import "./chunk-XEFFJRYX.js";
 import "./chunk-X7MTZ4T2.js";
 import {
   AUDIT_SEEK_OPTIONS,
@@ -33,42 +34,42 @@ import {
   resolveCliChromeGpuMode,
   seekCompositionTimeline,
   waitForPreferredSeekTarget
-} from "./chunk-UAIUVPZE.js";
+} from "./chunk-SWCSL6WS.js";
 import "./chunk-FH7WODJH.js";
-import "./chunk-AXPNVC3N.js";
-import "./chunk-423DJVX2.js";
+import "./chunk-4UMKAUZI.js";
+import "./chunk-PKO2EWO7.js";
 import "./chunk-WPNE5NEP.js";
-import "./chunk-UVVI2NJQ.js";
-import "./chunk-ZNHAJCEA.js";
-import "./chunk-FJWEYVEM.js";
-import "./chunk-XXPYZBZ3.js";
+import "./chunk-HBCRRCTX.js";
+import "./chunk-PRXAOZWZ.js";
+import "./chunk-C6TPGUWD.js";
+import "./chunk-7FYFEXD2.js";
 import {
   FfmpegUnavailableError,
   decideMediaProxyEligibility,
   proxyVariantFor,
   resolveProxies,
   scanProjectMediaCodecMap
-} from "./chunk-EL5QVJEG.js";
-import "./chunk-AIJS74LG.js";
-import "./chunk-NFQY7EIC.js";
+} from "./chunk-XINGD6MS.js";
+import "./chunk-FFDC5OWV.js";
+import "./chunk-IBYC3VUA.js";
 import "./chunk-K2FLNJVB.js";
-import "./chunk-AKYQGZLU.js";
+import "./chunk-EVTHG34H.js";
 import "./chunk-442JNXRM.js";
 import {
   resolveAutoProxy
-} from "./chunk-XQMEGSHG.js";
+} from "./chunk-D6RJXQLD.js";
 import "./chunk-XT7X6QCP.js";
 import "./chunk-4YYJOFKS.js";
 import "./chunk-HVW7ABXD.js";
-import "./chunk-BLRJKBKP.js";
-import "./chunk-M6UDJ2E7.js";
-import "./chunk-OQ7XMM3S.js";
+import "./chunk-QESSGUKX.js";
+import "./chunk-6Z4YJ5Q3.js";
+import "./chunk-3HPJM5IQ.js";
 import "./chunk-AWDFDFI3.js";
 import "./chunk-P6LJ4Y32.js";
 import "./chunk-GMECXFAN.js";
-import "./chunk-374QQGBQ.js";
-import "./chunk-3UAIVF4L.js";
-import "./chunk-6KWA3XPS.js";
+import "./chunk-5CS4T6C6.js";
+import "./chunk-H2SGM2V2.js";
+import "./chunk-KZ3L3W4Q.js";
 import "./chunk-VWG7OQKU.js";
 import "./chunk-XBSPQ52S.js";
 import "./chunk-S3S4TGEH.js";
@@ -77,37 +78,37 @@ import "./chunk-PBN6GBJE.js";
 import "./chunk-ZTZA4UWZ.js";
 import "./chunk-EOOEC32M.js";
 import "./chunk-TJSTGSAW.js";
-import "./chunk-AFRXL75S.js";
+import "./chunk-YYEYOFHW.js";
 import "./chunk-K4WIOZFP.js";
 import "./chunk-XUXGIA7H.js";
 import "./chunk-WERLJGIC.js";
 import "./chunk-ISN5GRYI.js";
-import "./chunk-I6DATIHC.js";
+import "./chunk-IZIRIDJH.js";
 import "./chunk-EOVYQ3IG.js";
 import "./chunk-AMKC3AXA.js";
-import "./chunk-5NAYNDBT.js";
-import "./chunk-WLIUULZQ.js";
+import "./chunk-EXH6L2XZ.js";
+import "./chunk-RN5I2DP5.js";
 import "./chunk-NE55C6S5.js";
 import "./chunk-JYVGYKXG.js";
-import "./chunk-PCWOSS7G.js";
-import "./chunk-CEND6BLF.js";
+import "./chunk-5ERVRJMV.js";
+import "./chunk-S3RCK56N.js";
 import "./chunk-VC76R6W2.js";
 import "./chunk-UJKQWGFF.js";
-import "./chunk-LFNQDTSH.js";
+import "./chunk-VYKPBRCB.js";
 import "./chunk-OFQWTKPW.js";
 import "./chunk-DPVXBVLL.js";
 import "./chunk-T76PLPD6.js";
 import "./chunk-FXMKHHPO.js";
 import "./chunk-RQVDTPGD.js";
 import "./chunk-TWWSYAKJ.js";
-import "./chunk-JDB65PPT.js";
+import "./chunk-YOEGUBBY.js";
 import "./chunk-IWFLMU2N.js";
-import "./chunk-APDLWWFG.js";
+import "./chunk-3VGU2SH7.js";
 import "./chunk-VAS6HQX3.js";
 import "./chunk-3RM2ETQT.js";
 import "./chunk-BSQ7XANM.js";
 import "./chunk-SDYDNHEE.js";
-import "./chunk-2PSPARWP.js";
+import "./chunk-TYXH3EKP.js";
 import "./chunk-IXLUTE6N.js";
 import {
   normalizeErrorMessage
@@ -118,6 +119,118 @@ import "./chunk-M2WBOQ2Q.js";
 // src/utils/checkBrowser.ts
 import { mkdirSync, writeFileSync } from "fs";
 import { join, resolve } from "path";
+
+// src/utils/gsapTweenTails.ts
+var TWEEN_TAIL_WINDOW = 0.25;
+function findTweenTails(records) {
+  return records.flatMap(
+    (earlier) => records.flatMap((later) => {
+      const tail = tailBetween(earlier, later);
+      return tail ? [tail] : [];
+    })
+  );
+}
+function tailBetween(earlier, later) {
+  if (later.target !== earlier.target || later.timeline !== earlier.timeline) return null;
+  const overlaps = earlier.start < later.start && later.start < earlier.end;
+  const tail = earlier.end - later.end;
+  if (!overlaps || tail <= 0 || tail > TWEEN_TAIL_WINDOW) return null;
+  const properties = earlier.properties.filter((name) => later.properties.includes(name));
+  if (properties.length === 0) return null;
+  return {
+    timeline: earlier.timeline,
+    label: earlier.label,
+    properties,
+    earlier: { start: earlier.start, end: earlier.end },
+    later: { start: later.start, end: later.end }
+  };
+}
+function tweenTailMessage(tail) {
+  const props = tail.properties.join(", ");
+  const seconds = (value) => `${value.toFixed(3)} s`;
+  return `In timeline "${tail.timeline}", a tween on ${props} of ${tail.label} ends at ${seconds(tail.earlier.end)}, ${(tail.earlier.end - tail.later.end).toFixed(3)} s after a later tween on ${props} ends at ${seconds(tail.later.end)}. For that tail the earlier tween takes ${props} back and leaves its own end value on screen, so the later tween's end never shows. End the earlier tween by ${seconds(tail.later.start)}, or add overwrite: "auto" to the later tween.`;
+}
+function collectTweenRecords() {
+  const NOT_PROPERTIES = /* @__PURE__ */ new Set([
+    "duration",
+    "delay",
+    "ease",
+    "repeat",
+    "repeatDelay",
+    "repeatRefresh",
+    "yoyo",
+    "yoyoEase",
+    "stagger",
+    "overwrite",
+    "immediateRender",
+    "lazy",
+    "paused",
+    "reversed",
+    "runBackwards",
+    "startAt",
+    "keyframes",
+    "inherit",
+    "data",
+    "id",
+    "callbackScope",
+    "onStart",
+    "onStartParams",
+    "onUpdate",
+    "onUpdateParams",
+    "onComplete",
+    "onCompleteParams",
+    "onRepeat",
+    "onRepeatParams",
+    "onReverseComplete",
+    "onReverseCompleteParams",
+    "parent",
+    "onInterrupt",
+    "autoRevert",
+    "smoothChildTiming"
+  ]);
+  const registered = window.__timelines ?? {};
+  const names = /* @__PURE__ */ new Map();
+  for (const [name, timeline] of Object.entries(registered)) {
+    if (typeof timeline?.getChildren === "function") names.set(timeline, name);
+  }
+  const ids = /* @__PURE__ */ new Map();
+  function nestedInAnother(timeline) {
+    for (let parent = timeline.parent; parent; parent = parent.parent) {
+      if (names.has(parent)) return true;
+    }
+    return false;
+  }
+  function plainProperties(tween) {
+    const vars = tween.vars ?? {};
+    const plain = !vars.repeat && !vars.yoyo && !vars.keyframes && !vars.overwrite;
+    return plain ? Object.keys(vars).filter((key) => !NOT_PROPERTIES.has(key)) : [];
+  }
+  function labelOf(target) {
+    if (!(target instanceof Element)) return "an object";
+    if (target.id) return `#${target.id}`;
+    return [target.tagName.toLowerCase(), ...target.classList].join(".");
+  }
+  function recordsOf(timeline, name) {
+    const origin = timeline.globalTime(0);
+    return (timeline.getChildren?.(true, true, false) ?? []).flatMap((tween) => {
+      const duration = tween.totalDuration();
+      const properties = plainProperties(tween);
+      if (!(duration > 0) || properties.length === 0) return [];
+      const start = tween.globalTime(0) - origin;
+      const end = tween.globalTime(duration) - origin;
+      return tween.targets().map((target) => {
+        if (!ids.has(target)) ids.set(target, ids.size);
+        const id = ids.get(target) ?? -1;
+        return { timeline: name, target: id, label: labelOf(target), properties, start, end };
+      });
+    });
+  }
+  return [...names].flatMap(
+    ([timeline, name]) => nestedInAnother(timeline) ? [] : recordsOf(timeline, name)
+  );
+}
+
+// src/utils/checkBrowser.ts
 async function preResolveHostileMediaProxies(projectDir, html, autoProxyOverride) {
   const none = { findings: [], failedPaths: /* @__PURE__ */ new Set() };
   if (!resolveAutoProxy(projectDir, autoProxyOverride)) return none;
@@ -172,7 +285,7 @@ function proxyFailedDraft(message) {
   return { code: "media_proxy_failed", severity: "warning", message, time: 0 };
 }
 async function runBrowserCheck(project, options, motion, runGrid) {
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-I4CWOXLK.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-76DMCRIW.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   const { findings: drafts, failedPaths } = await preResolveHostileMediaProxies(
     project.dir,
@@ -202,10 +315,14 @@ async function runBrowserCheck(project, options, motion, runGrid) {
     await waitForPreferredSeekTarget(page);
     const rootAnchor = await resolveRootAnchor(page);
     const launchSettleMs = Date.now() - launchSettleStart;
-    const { analyzeClipMediaFit } = await import("./src-7V6LBC56.js");
+    const { analyzeClipMediaFit } = await import("./src-AVQBAECC.js");
     for (const entry of await auditClipDurations(page, analyzeClipMediaFit, options.timeout)) {
       drafts.push({ code: "clip_media_fit", severity: entry.level, message: entry.text, time: 0 });
     }
+    for (const tail of findTweenTails(await page.evaluate(collectTweenRecords) ?? [])) {
+      const message = tweenTailMessage(tail);
+      drafts.push({ code: "gsap_tween_tail", severity: "warning", message, time: tail.later.end });
+    }
     const driver = createPageDriver(page, (time) => {
       currentTime = time;
     });
@@ -226,7 +343,7 @@ async function runBrowserCheck(project, options, motion, runGrid) {
 }
 async function captureFindingCrops(project, options, requests) {
   if (requests.length === 0) return [];
-  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-I4CWOXLK.js");
+  const { bundleWithLocalizedFonts } = await import("./bundleWithLocalizedFonts-76DMCRIW.js");
   const html = await bundleWithLocalizedFonts(project.dir);
   const server = await serveStaticProjectHtml(
     project.dir,
@@ -247,7 +364,7 @@ async function captureFindingCrops(project, options, requests) {
     chromeBrowser = session.browser;
     const page = session.page;
     await waitForPreferredSeekTarget(page);
-    const snapshotDir = join(project.dir, "snapshots");
+    const snapshotDir = checkSnapshotDirectory(project.dir);
     mkdirSync(snapshotDir, { recursive: true });
     for (const request of requests) {
       await seekCompositionTimeline(page, request.time, AUDIT_SEEK_OPTIONS);
@@ -258,7 +375,7 @@ async function captureFindingCrops(project, options, requests) {
       const region = padCropRegion(request.bbox, canvas, DEFAULT_ZOOM_PADDING_PX);
       const buffer = await captureRegionCrop(page, region, DEFAULT_ZOOM_SCALE);
       writeFileSync(join(snapshotDir, request.filename), buffer);
-      written.push(join("snapshots", request.filename));
+      written.push(join(snapshotDir, request.filename));
     }
     return written;
   } finally {
@@ -438,6 +555,7 @@ function wireNetworkListeners(page, drafts, currentTime) {
 function createPageDriver(page, setTime) {
   return {
     initialize: (contrast) => injectAuditScripts(page, contrast),
+    matchComponents: (components, findings) => page.evaluate(matchComponentFindings, { components, findings }),
     getDuration: () => getCompositionDuration(page),
     hasNoTimelineDeclaration: () => hasNoTimelineDeclaration(page),
     getTransitionBoundaries: () => collectTweenBoundaries(page),
@@ -1174,12 +1292,37 @@ function urlPath(url) {
     return url;
   }
 }
+function matchComponentFindings({
+  components,
+  findings
+}) {
+  const roots = components.flatMap((selector) => {
+    const matches = [...document.querySelectorAll(selector)];
+    if (!matches.length) throw new Error(`Component selector matched nothing: ${selector}`);
+    return matches;
+  });
+  function matchesSelector(selector) {
+    try {
+      const elements = [...document.querySelectorAll(selector)];
+      if (!elements.length) return null;
+      return elements.some((el) => roots.some((root) => root.contains(el)));
+    } catch {
+      return null;
+    }
+  }
+  return findings.map((finding) => {
+    if (!finding.selector || finding.selector === "[data-composition-id]") return true;
+    const container = Reflect.get(finding, "containerSelector");
+    return matchesSelector(finding.selector) !== false || typeof container === "string" && matchesSelector(container) !== false;
+  });
+}
 export {
   captureFindingCrops,
   captureOverviewShot,
   collectSeekClock,
   dropFailedProxyEchoes,
   keepBrokenImageAborts,
+  matchComponentFindings,
   preResolveHostileMediaProxies,
   runBrowserCheck
 };

package/dist/{chunk-73RBX2E7.js → chunk-3DZBQ7MH.js}

@@ -7,14 +7,14 @@ var __dirname = __hf_dirname(__filename);
 import {
   trackLintReport,
   trackLintRuleStreak
-} from "./chunk-3UAIVF4L.js";
+} from "./chunk-H2SGM2V2.js";
 import {
   shouldTrack
-} from "./chunk-6KWA3XPS.js";
+} from "./chunk-KZ3L3W4Q.js";
 import {
   LINT_RULE_COUNT,
   LINT_RULE_GROUP_COUNTS
-} from "./chunk-JDB65PPT.js";
+} from "./chunk-YOEGUBBY.js";
 
 // src/telemetry/lintStreaks.ts
 import { createHash } from "crypto";

package/dist/{chunk-6QB7F2II.js → chunk-3E4OCOC5.js}

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

package/dist/{chunk-OQ7XMM3S.js → chunk-3HPJM5IQ.js}

@@ -27,7 +27,7 @@ import {
 } from "./chunk-GMECXFAN.js";
 import {
   ITEM_TYPE_DIRS
-} from "./chunk-PCWOSS7G.js";
+} from "./chunk-5ERVRJMV.js";
 import {
   realProjectRoot
 } from "./chunk-OFQWTKPW.js";

package/dist/{chunk-UJB7356Y.js → chunk-3LO7BBJX.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-3UAIVF4L.js";
+} from "./chunk-H2SGM2V2.js";
 import {
   shouldTrack
-} from "./chunk-6KWA3XPS.js";
+} from "./chunk-KZ3L3W4Q.js";
 import {
   detectAgentRuntime
 } from "./chunk-XBSPQ52S.js";
@@ -84,7 +84,7 @@ async function getDoctorSummary() {
   try {
     const [{ getSystemMeta }, { findFFmpeg }] = await Promise.all([
       import("./system-OXRG57F2.js"),
-      import("./ffmpeg-TZB5WAYE.js")
+      import("./ffmpeg-MJFMBBSF.js")
     ]);
     const sys = getSystemMeta();
     const parts = [

package/dist/{chunk-APDLWWFG.js → chunk-3VGU2SH7.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   parse,
   simple
-} from "./chunk-2PSPARWP.js";
+} from "./chunk-TYXH3EKP.js";
 
 // ../parsers/dist/composition.js
 var CANVAS_DIMENSIONS = {

package/dist/{chunk-DUUFDLC4.js → chunk-4MLYMDQ4.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-AMKC3AXA.js";
 import {
   runCancellableProcess
-} from "./chunk-XPQSL5VS.js";
+} from "./chunk-54DMWFQZ.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";

package/dist/{chunk-AXPNVC3N.js → chunk-4UMKAUZI.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-AKYQGZLU.js";
+} from "./chunk-EVTHG34H.js";
 import {
   requestCliExit
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-XPQSL5VS.js → chunk-54DMWFQZ.js}

@@ -218,13 +218,20 @@ function renderSetupError(error) {
   const reason = failure?.reason ?? error.stderr.trim();
   return reason ? new Error(reason, { cause: error }) : error;
 }
+function tsxLoaderFromCliInstall() {
+  try {
+    return import.meta.resolve("tsx");
+  } catch {
+    return "tsx";
+  }
+}
 async function runRenderSetupWorker(mode, input, options) {
   const sourceMode = import.meta.url.endsWith(".ts");
   const workerUrl = new URL(
     sourceMode ? "../renderSetupWorker.ts" : "./renderSetupWorker.js",
     import.meta.url
   );
-  const execArgv = sourceMode ? ["--import", "tsx"] : [];
+  const execArgv = sourceMode && !process.versions.bun ? ["--import", tsxLoaderFromCliInstall()] : [];
   let result;
   try {
     result = await runCancellableProcess(

package/dist/chunk-57GN6KWT.js

@@ -0,0 +1,179 @@
+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/pngDimensions.ts
+import { readFileSync } from "fs";
+function pngDimensions(path) {
+  try {
+    const png = readFileSync(path);
+    if (png.length < 24) return {};
+    return { width: png.readUInt32BE(16), height: png.readUInt32BE(20) };
+  } catch {
+    return {};
+  }
+}
+
+// src/utils/toolContext.ts
+import { appendFileSync } from "fs";
+import { extname, isAbsolute, resolve } from "path";
+var TOOL_CONTEXT_VERSION = 1;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseEvents(value) {
+  if (!isRecord(value) || !isRecord(value.transport)) return void 0;
+  const { type, path } = value.transport;
+  if (type !== "ndjson-file" || typeof path !== "string" || !isAbsolute(path)) return void 0;
+  return { path };
+}
+function parseProjectLock(value) {
+  if (!isRecord(value)) return void 0;
+  const { waitMs } = value;
+  if (typeof waitMs !== "number" || !Number.isFinite(waitMs) || waitMs < 0) return void 0;
+  return { waitMs };
+}
+function readToolContext(raw = process.env.HF_TOOL_CONTEXT) {
+  if (!raw) return {};
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  if (!isRecord(value) || value.version !== TOOL_CONTEXT_VERSION || !isRecord(value.capabilities))
+    return {};
+  const events = parseEvents(value.capabilities.events);
+  const projectLock = parseProjectLock(value.capabilities["project-lock"]);
+  return { ...events && { events }, ...projectLock && { projectLock } };
+}
+var MEDIA_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".json": "application/json"
+};
+function reportArtifacts(command, role, paths, context = readToolContext()) {
+  if (!context.events || paths.length === 0) return;
+  const lines = paths.map((path) => {
+    const absolute = resolve(path);
+    const event = {
+      version: TOOL_CONTEXT_VERSION,
+      type: "artifact.created",
+      command,
+      artifact: {
+        role,
+        path: absolute,
+        mediaType: MEDIA_TYPES[extname(absolute).toLowerCase()] ?? "application/octet-stream"
+      }
+    };
+    return JSON.stringify(event) + "\n";
+  });
+  try {
+    appendFileSync(context.events.path, lines.join(""));
+  } catch (error) {
+    console.error(`HF_TOOL_CONTEXT events could not be written: ${error.message}`);
+  }
+}
+
+// src/utils/projectLock.ts
+import { linkSync, mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { setTimeout as sleep } from "timers/promises";
+var ProjectLockTimeout = class extends Error {
+};
+var POLL_MS = 250;
+var projectLockPath = (projectDir) => join(projectDir, ".hyperframes", "project.lock");
+function readHolder(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var sameHolder = (a, b) => a?.pid === b.pid && a.startedAt === b.startedAt && a.command === b.command;
+function breakStaleHolder(path, current, holder) {
+  const breakPath = `${path}.break`;
+  const breakDraft = `${breakPath}.${holder.pid}.${holder.startedAt}`;
+  let acquired = false;
+  writeFileSync(breakDraft, JSON.stringify(holder), { flag: "wx" });
+  try {
+    try {
+      linkSync(breakDraft, breakPath);
+    } catch (error) {
+      if (error.code === "EEXIST") return false;
+      throw error;
+    }
+    if (sameHolder(readHolder(path), current)) {
+      try {
+        unlinkSync(path);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    acquired = tryAcquire(path, holder);
+  } finally {
+    unlinkSync(breakDraft);
+    if (sameHolder(readHolder(breakPath), holder)) unlinkSync(breakPath);
+  }
+  return acquired;
+}
+function tryAcquire(path, holder) {
+  const draft = `${path}.${holder.pid}.${holder.startedAt}`;
+  writeFileSync(draft, JSON.stringify(holder), { flag: "wx" });
+  try {
+    linkSync(draft, path);
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  } finally {
+    unlinkSync(draft);
+  }
+  const current = readHolder(path);
+  if (current && !alive(current.pid)) return breakStaleHolder(path, current, holder);
+  return false;
+}
+async function withProjectLock(projectDir, command, run, context = readToolContext()) {
+  if (!context.projectLock) return run();
+  const path = projectLockPath(projectDir);
+  mkdirSync(dirname(path), { recursive: true });
+  const holder = { pid: process.pid, command, startedAt: Date.now() };
+  const deadline = holder.startedAt + context.projectLock.waitMs;
+  while (!tryAcquire(path, holder)) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      const current = readHolder(path);
+      const breakPath = `${path}.break`;
+      const breaker = readHolder(breakPath);
+      if ((!current || !alive(current.pid)) && breaker && !alive(breaker.pid)) {
+        throw new ProjectLockTimeout(
+          `hyperframes left ${breakPath} (pid ${breaker.pid}); delete it to continue`
+        );
+      }
+      throw new ProjectLockTimeout(
+        `hyperframes ${current?.command ?? "another command"} (pid ${current?.pid ?? "unknown"}) is still using this project after ${Math.round(context.projectLock.waitMs / 1e3)}s`
+      );
+    }
+    await sleep(Math.min(POLL_MS, remaining));
+  }
+  try {
+    return await run();
+  } finally {
+    if (sameHolder(readHolder(path), holder)) unlinkSync(path);
+  }
+}
+
+export {
+  pngDimensions,
+  reportArtifacts,
+  withProjectLock
+};