@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

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

@@ -0,0 +1,2748 @@
+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 {
+  pinProjectRecord,
+  realFilePath
+} from "./chunk-7JQFJ6JJ.js";
+import {
+  atomicTempPath,
+  isAtomicTempPath,
+  replaceFileAtomically
+} from "./chunk-EOVYQ3IG.js";
+import {
+  isProjectIgnoredDir
+} from "./chunk-EVMY7IPL.js";
+import {
+  isSafePath,
+  mkdirWithinProject
+} from "./chunk-OFQWTKPW.js";
+
+// ../studio-server/dist/chunk-TNYZG57Q.js
+import { randomUUID as randomUUID7 } from "crypto";
+import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, stat as stat2, writeFile } from "fs/promises";
+import {
+  existsSync as existsSync3,
+  lstatSync as lstatSync4,
+  statSync as statSync5,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync10,
+  realpathSync,
+  rmSync as rmSync3
+} from "fs";
+import { homedir } from "os";
+import { dirname as dirname5, isAbsolute as isAbsolute5, join as join8, relative as relative5, resolve as resolve7, sep as sep5 } from "path";
+import { createHash, randomUUID } from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { createHash as createHash2 } from "crypto";
+import { lstatSync, readFileSync as readFileSync3, readdirSync } from "fs";
+import { extname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { constants, createReadStream, createWriteStream, renameSync as renameSync2 } from "fs";
+import { copyFile, mkdir, readdir, readFile, rename, rm, stat } from "fs/promises";
+import { dirname, join as join2 } from "path";
+import { pipeline } from "stream/promises";
+import { extname as extname2 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { lstat, readdir as readdir2, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join3, resolve as resolve3 } from "path";
+import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
+import { createReadStream as createReadStream2, existsSync as existsSync2, readFileSync as readFileSync8, renameSync as renameSync4, statSync as statSync4 } from "fs";
+import { isAbsolute as isAbsolute4, join as join7, resolve as resolve6 } from "path";
+import { createHash as createHash4 } from "crypto";
+import {
+  closeSync,
+  constants as constants2,
+  fstatSync,
+  lstatSync as lstatSync2,
+  openSync,
+  readFileSync as readFileSync6,
+  unlinkSync
+} from "fs";
+import { isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+import {
+  closeSync as closeSync2,
+  constants as constants3,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync3,
+  openSync as openSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync7,
+  readdirSync as readdirSync3,
+  rmSync as rmSync2,
+  ftruncateSync,
+  writeSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { dirname as dirname3, join as join6, relative as relative4, resolve as resolve5, sep as sep4 } from "path";
+import { closeSync as closeSync3, constants as constants4, mkdirSync as mkdirSync4, openSync as openSync3, readFileSync as readFileSync9, writeSync as writeSync2 } from "fs";
+import { dirname as dirname4 } from "path";
+import { readdirSync as readdirSync5 } from "fs";
+import { rm as rm4, stat as stat3 } from "fs/promises";
+import { join as join9 } from "path";
+var RECEIPT_TTL_MS = 1e4;
+var receipts = /* @__PURE__ */ new Map();
+var overwriteListeners = /* @__PURE__ */ new Set();
+function fileContentVersion(content) {
+  return hashVersion(createHash("sha256").update(content).digest("hex"));
+}
+var DELETED_VERSION = '"deleted"';
+function hashVersion(hex) {
+  return `"sha256:${hex}"`;
+}
+function hashOfVersion(version) {
+  return /^"sha256:([0-9a-f]{64})"$/.exec(version)?.[1];
+}
+function settledFileTag(stat4, now = Date.now()) {
+  if (now - stat4.ctimeMs < 3e3) return null;
+  return [stat4.ino, stat4.ctimeMs, stat4.size].map((n) => n.toString(36)).join("-");
+}
+function createWriteToken(requestToken) {
+  const token = requestToken?.trim();
+  return token && token.length <= 200 ? token : randomUUID();
+}
+function onFileOverwritten(listener) {
+  overwriteListeners.add(listener);
+  return () => overwriteListeners.delete(listener);
+}
+function recordFileWriteReceipt(filePath, {
+  overwrote,
+  path,
+  version,
+  writeToken
+}) {
+  const receipt = { path, version, writeToken };
+  const absPath = realFilePath(filePath);
+  if (overwrote !== void 0)
+    for (const listener of overwriteListeners) listener(absPath, receipt.version, overwrote);
+  const now = Date.now();
+  for (const [path2, list] of receipts) {
+    const live = list.filter((entry) => now - entry.recordedAt < RECEIPT_TTL_MS);
+    if (live.length > 0) receipts.set(path2, live);
+    else receipts.delete(path2);
+  }
+  const from = overwrote === void 0 ? void 0 : fileContentVersion(overwrote);
+  receipts.set(absPath, [
+    ...receipts.get(absPath) ?? [],
+    { ...receipt, ...from && { from }, recordedAt: now }
+  ]);
+}
+function clearFileWriteReceipt(filePath, version, writeToken) {
+  const absPath = realFilePath(filePath);
+  const current = (receipts.get(absPath) ?? []).filter(
+    (entry) => entry.version !== version || entry.writeToken !== writeToken
+  );
+  if (current.length > 0) receipts.set(absPath, current);
+  else receipts.delete(absPath);
+}
+function identifyFileWrite(filePath, expectedVersion) {
+  const receipt = newestReceipt(realFilePath(filePath), expectedVersion);
+  if (!receipt) return null;
+  const { path, version, writeToken, from } = receipt;
+  return { path, version, writeToken, ...from && { from } };
+}
+function newestReceipt(absPath, expectedVersion) {
+  const now = Date.now();
+  const current = (receipts.get(absPath) ?? []).filter(
+    (entry) => now - entry.recordedAt < RECEIPT_TTL_MS
+  );
+  if (current.length > 0) receipts.set(absPath, current);
+  else receipts.delete(absPath);
+  let receipt;
+  for (let i = current.length - 1; i >= 0 && !receipt; i -= 1) {
+    if (current[i]?.version === expectedVersion) receipt = current[i];
+  }
+  return receipt;
+}
+var consumeFileWriteReceipt = identifyFileWrite;
+var HistoryBusyError = class extends Error {
+  constructor(pid, url) {
+    super(`This project's history is open in another process (pid ${pid}).`);
+    this.pid = pid;
+    this.url = url;
+    this.name = "HistoryBusyError";
+  }
+  pid;
+  url;
+};
+var WINDOWS_BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
+var NO_HARD_LINKS = /* @__PURE__ */ new Set(["ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EPERM"]);
+var TAKING_MS = 2e3;
+function busyOnWindows(error) {
+  return process.platform === "win32" && WINDOWS_BUSY.has(error.code ?? "");
+}
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function ownerOf(file) {
+  try {
+    const text = readFileSync(file, "utf-8");
+    return /^\d+$/.test(text) ? Number(text) : Number.NaN;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function beingTaken(file) {
+  try {
+    const { size, mtimeMs } = statSync(file);
+    return size === 0 && Date.now() - mtimeMs < TAKING_MS;
+  } catch {
+    return false;
+  }
+}
+function deadHolder(file, pid) {
+  return !alive(pid) && !beingTaken(file);
+}
+function claim(file) {
+  const draft = `${file}-${process.pid}-${randomUUID2()}.tmp`;
+  writeFileSync(draft, String(process.pid));
+  try {
+    linkSync(draft, file);
+    return true;
+  } catch (error) {
+    const code = error.code ?? "";
+    if (code === "EEXIST") return false;
+    if (!NO_HARD_LINKS.has(code)) throw error;
+    return createExclusively(file);
+  } finally {
+    rmSync(draft, { force: true });
+  }
+}
+function createExclusively(file) {
+  try {
+    writeFileSync(file, String(process.pid), { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return false;
+  }
+}
+function releaseOwn(file) {
+  if (ownerOf(file) === process.pid) rmSync(file, { force: true });
+}
+function evictDeadOwner(file) {
+  const evictor = `${file}.evict`;
+  if (!claim(evictor)) {
+    const holder = ownerOf(evictor);
+    if (holder !== null && deadHolder(evictor, holder)) rmSync(evictor, { force: true });
+    return false;
+  }
+  try {
+    const pid = ownerOf(file);
+    if (pid !== null && deadHolder(file, pid)) rmSync(file, { force: true });
+    return true;
+  } finally {
+    releaseOwn(evictor);
+  }
+}
+function advertise(urlFile, url) {
+  if (!url) return rmSync(urlFile, { force: true });
+  const draft = `${urlFile}-${process.pid}-${randomUUID2()}.tmp`;
+  writeFileSync(draft, JSON.stringify({ pid: process.pid, url }));
+  renameSync(draft, urlFile);
+}
+function servedBy(file, urlFile, pid) {
+  try {
+    const said = JSON.parse(readFileSync(urlFile, "utf-8"));
+    const live = said.pid === pid && alive(pid) && ownerOf(file) === pid;
+    return live && typeof said.url === "string" ? said.url : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function attemptClaim(file, urlFile, deadline) {
+  if (claim(file)) return "claimed";
+  const pid = ownerOf(file);
+  if (pid === null) return "retry";
+  if (deadHolder(file, pid) && evictDeadOwner(file)) return "retry";
+  if (Date.now() >= deadline) throw new HistoryBusyError(pid, servedBy(file, urlFile, pid));
+  return "wait";
+}
+async function takeHistoryOwnership(home, waitMs, url) {
+  const file = join(home, "owner.pid");
+  const urlFile = join(home, "owner-url.json");
+  const deadline = Date.now() + waitMs;
+  mkdirSync(home, { recursive: true });
+  for (; ; ) {
+    let next = "wait";
+    try {
+      next = attemptClaim(file, urlFile, deadline);
+    } catch (error) {
+      if (!busyOnWindows(error) || Date.now() >= deadline) throw error;
+    }
+    if (next === "claimed") break;
+    if (next === "wait") await new Promise((settle) => setTimeout(settle, 50));
+  }
+  advertise(urlFile, url);
+  let held = true;
+  return () => {
+    if (held && servedBy(file, urlFile, process.pid)) rmSync(urlFile, { force: true });
+    if (held) releaseOwn(file);
+    held = false;
+  };
+}
+var manifest = ".hyperframes/render-outputs.json";
+function readRenderOutputs(projectDir) {
+  const path = pinProjectRecord(projectDir, manifest);
+  if (!path) return [];
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw error;
+  }
+  const value = JSON.parse(text);
+  if (value.version !== 1 || !Array.isArray(value.paths) || !value.paths.every(
+    (p) => typeof p === "string" && p !== "" && !isAbsolute(p) && !p.split(/[\\/]/).some((part) => part === ".." || part === ".")
+  ))
+    throw new Error("Invalid render output registry.");
+  return value.paths;
+}
+function readRenderOutputsOrNone(projectDir) {
+  try {
+    return readRenderOutputs(projectDir);
+  } catch {
+    return [];
+  }
+}
+function isRenderOutput(projectDir, path, outputs) {
+  const candidate = relative(resolve(projectDir), resolve(path)).split(sep).join("/");
+  return outputs.some((output) => candidate === output || candidate.startsWith(`${output}/`));
+}
+async function registerRenderOutput(projectDir, output) {
+  const path = relative(resolve(projectDir), resolve(output)).split(sep).join("/");
+  if (path === "") throw new Error("Render output cannot replace the project directory.");
+  if (isAbsolute(path) || path === ".." || path.startsWith("../")) return;
+  const registry = pinProjectRecord(projectDir, manifest);
+  const lock = pinProjectRecord(projectDir, ".hyperframes/render-outputs-lock");
+  if (!registry || !lock) throw new Error("Render output registry must stay inside the project.");
+  const release = await takeHistoryOwnership(lock, 5e3);
+  try {
+    const paths = [.../* @__PURE__ */ new Set([...readRenderOutputs(projectDir), path])].sort();
+    replaceFileAtomically(registry, JSON.stringify({ version: 1, paths }) + "\n", 420);
+  } finally {
+    release();
+  }
+}
+var SIGNATURE_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".cjs",
+  ".css",
+  ".html",
+  ".js",
+  ".json",
+  ".jsx",
+  ".mjs",
+  ".svg",
+  ".ts",
+  ".tsx"
+]);
+var MAX_SIGNATURE_TEXT_BYTES = 2e6;
+var STUDIO_SIGNATURE_MANIFEST_PATHS = [
+  ".hyperframes/studio-manual-edits.json",
+  ".hyperframes/studio-motion.json"
+];
+function affectsProjectSignature(projectDir, changedPath) {
+  const relativePath = relative2(resolve2(projectDir), resolve2(changedPath));
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute2(relativePath) || isAtomicTempPath(relativePath)) {
+    return false;
+  }
+  if (isRenderOutput(projectDir, changedPath, readRenderOutputsOrNone(projectDir))) return false;
+  const segments = relativePath.split(sep2);
+  if (STUDIO_SIGNATURE_MANIFEST_PATHS.includes(segments.join("/"))) return true;
+  return !segments.some(isProjectIgnoredDir);
+}
+var projectSignatureCache = /* @__PURE__ */ new Map();
+var COARSEST_FILE_TIME_TICK_MS = 2e3;
+function isPathWithin(parentDir, childPath) {
+  const childRelativePath = relative2(parentDir, childPath);
+  return childRelativePath === "" || !childRelativePath.startsWith("..") && !isAbsolute2(childRelativePath);
+}
+function isTextContentEligible(file, size) {
+  return SIGNATURE_TEXT_EXTENSIONS.has(extname(file).toLowerCase()) && size <= MAX_SIGNATURE_TEXT_BYTES;
+}
+var isSkippedEntry = (entry) => isProjectIgnoredDir(entry) || isAtomicTempPath(entry);
+function signatureEntryStat(projectDir, entry, file, outputs) {
+  if (isSkippedEntry(entry) || !isPathWithin(projectDir, file)) return null;
+  if (isRenderOutput(projectDir, file, outputs)) return null;
+  try {
+    const stat4 = lstatSync(file);
+    return stat4.isSymbolicLink() ? null : stat4;
+  } catch {
+    return null;
+  }
+}
+function collectProjectSignatureFiles(projectDir, dir, files, outputs = readRenderOutputsOrNone(projectDir)) {
+  let entries;
+  try {
+    entries = readdirSync(dir).sort();
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const file = resolve2(dir, entry);
+    const stat4 = signatureEntryStat(projectDir, entry, file, outputs);
+    if (!stat4) continue;
+    if (stat4.isDirectory()) {
+      collectProjectSignatureFiles(projectDir, file, files, outputs);
+    } else if (stat4.isFile()) {
+      files.push({
+        file,
+        mtimeMs: stat4.mtimeMs,
+        ctimeMs: stat4.ctimeMs,
+        size: stat4.size,
+        textContentEligible: isTextContentEligible(file, stat4.size)
+      });
+    }
+  }
+}
+function collectProjectSignatureManifestFiles(projectDir, files) {
+  const seen = new Set(files.map((entry) => entry.file));
+  for (const manifestPath of STUDIO_SIGNATURE_MANIFEST_PATHS) {
+    const file = resolve2(projectDir, manifestPath);
+    if (seen.has(file) || !isPathWithin(projectDir, file)) continue;
+    let stat4;
+    try {
+      stat4 = lstatSync(file);
+    } catch {
+      continue;
+    }
+    if (stat4.isSymbolicLink() || !stat4.isFile()) continue;
+    files.push({
+      file,
+      mtimeMs: stat4.mtimeMs,
+      ctimeMs: stat4.ctimeMs,
+      size: stat4.size,
+      textContentEligible: isTextContentEligible(file, stat4.size)
+    });
+    seen.add(file);
+  }
+}
+function createProjectFingerprint(projectDir, files) {
+  const hash = createHash2("sha256");
+  for (const entry of files) {
+    hash.update(relative2(projectDir, entry.file));
+    hash.update("\0");
+    hash.update(String(entry.size));
+    hash.update("\0");
+    hash.update(String(entry.mtimeMs));
+    hash.update("\0");
+    hash.update(String(entry.ctimeMs));
+    hash.update("\0");
+    hash.update(entry.textContentEligible ? "text" : "binary");
+    hash.update("\0");
+  }
+  return hash.digest("hex").slice(0, 24);
+}
+function collectProjectFiles(normalizedProjectDir) {
+  const collected = [];
+  collectProjectSignatureFiles(normalizedProjectDir, normalizedProjectDir, collected);
+  collectProjectSignatureManifestFiles(normalizedProjectDir, collected);
+  return collected;
+}
+function listProjectFiles(projectDir) {
+  const normalizedProjectDir = resolve2(projectDir);
+  return collectProjectFiles(normalizedProjectDir).map((entry) => ({
+    path: relative2(normalizedProjectDir, entry.file).split(sep2).join("/"),
+    size: entry.size,
+    mtimeMs: entry.mtimeMs,
+    ctimeMs: entry.ctimeMs
+  }));
+}
+function resolveProjectSignature(adapter, projectDir) {
+  return adapter.getProjectSignature?.(projectDir) ?? createProjectSignature(projectDir);
+}
+async function resolveProjectAndSignature(adapter, projectId) {
+  const project = await adapter.resolveProject(projectId);
+  if (!project) return null;
+  return { project, signature: resolveProjectSignature(adapter, project.dir) };
+}
+function createProjectSignature(projectDir, excluding = /* @__PURE__ */ new Set()) {
+  const normalizedProjectDir = resolve2(projectDir);
+  const signedAt = Date.now();
+  const collected = collectProjectFiles(normalizedProjectDir);
+  const files = collected.filter(
+    (entry) => !excluding.has(relative2(normalizedProjectDir, entry.file).split(sep2).join("/"))
+  );
+  files.sort((a, b) => a.file.localeCompare(b.file));
+  const fingerprint = createProjectFingerprint(normalizedProjectDir, files);
+  const cacheKey = excluding.size ? `${normalizedProjectDir}\0${createHash2("sha256").update([...excluding].sort().join("\0")).digest("hex")}` : normalizedProjectDir;
+  const cached = projectSignatureCache.get(cacheKey);
+  if (cached?.fingerprint === fingerprint) return cached.signature;
+  const hash = createHash2("sha256");
+  for (const entry of files) {
+    const relativePath = relative2(normalizedProjectDir, entry.file);
+    hash.update(relativePath);
+    hash.update("\0");
+    hash.update(String(entry.size));
+    hash.update("\0");
+    if (entry.textContentEligible) {
+      try {
+        hash.update(readFileSync3(entry.file));
+      } catch {
+        hash.update(String(entry.mtimeMs));
+      }
+    } else {
+      hash.update(String(entry.mtimeMs));
+    }
+    hash.update("\0");
+  }
+  const signature = hash.digest("hex").slice(0, 24);
+  const settledATickBeforeSigning = files.every(
+    (entry) => Math.max(entry.mtimeMs, entry.ctimeMs) < signedAt - COARSEST_FILE_TIME_TICK_MS
+  );
+  if (settledATickBeforeSigning) projectSignatureCache.set(cacheKey, { fingerprint, signature });
+  return signature;
+}
+var BLOB_HASH = /^[0-9a-f]{64}$/;
+function blobPath(dir, hash) {
+  if (!BLOB_HASH.test(hash)) throw new Error("That is not a history blob.");
+  return join2(dir, hash.slice(0, 2), hash);
+}
+var readBlob = (dir, hash) => readFile(blobPath(dir, hash));
+async function hashFile(path) {
+  const hash = createHash3("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function cloneOrStream(from, to) {
+  try {
+    await copyFile(from, to, constants.COPYFILE_FICLONE_FORCE);
+  } catch {
+    const { mode } = await stat(from);
+    await pipeline(createReadStream(from), createWriteStream(to, { mode }));
+  }
+}
+async function cloneOrCopy(from, to, beforeReplace) {
+  await mkdir(dirname(to), { recursive: true });
+  const temp = atomicTempPath(to);
+  try {
+    await copyFile(from, temp, constants.COPYFILE_FICLONE);
+    beforeReplace?.();
+    renameSync2(temp, to);
+  } catch (error) {
+    await rm(temp, { force: true });
+    throw error;
+  }
+}
+var listDir = (path) => readdir(path, { withFileTypes: true }).catch((error) => {
+  if (error.code === "ENOENT") return [];
+  throw error;
+});
+async function openBlobStore(dir) {
+  const sizes = /* @__PURE__ */ new Map();
+  const asideDir = join2(dirname(dir), "aside");
+  const asideSizes = /* @__PURE__ */ new Map();
+  const holds = /* @__PURE__ */ new Map();
+  await mkdir(dir, { recursive: true });
+  for (const [root, found] of [
+    [dir, sizes],
+    [asideDir, asideSizes]
+  ])
+    for (const shard of await listDir(root)) {
+      if (!shard.isDirectory()) {
+        if (shard.name.startsWith("incoming-")) await rm(join2(root, shard.name), { force: true });
+        continue;
+      }
+      for (const hash of await listDir(join2(root, shard.name)))
+        found.set(hash.name, (await stat(join2(root, shard.name, hash.name))).size);
+    }
+  for (const hash of asideSizes.keys()) holds.set(hash, /* @__PURE__ */ new Set(["*"]));
+  const pathOf = (hash) => blobPath(sizes.has(hash) ? dir : asideDir, hash);
+  let total = [...sizes.values()].reduce((sum, size) => sum + size, 0);
+  const forget = async (hash) => {
+    await rm(blobPath(dir, hash), { force: true });
+    total -= sizes.get(hash) ?? 0;
+    sizes.delete(hash);
+  };
+  const forgetAside = async (hash) => {
+    await rm(blobPath(asideDir, hash), { force: true });
+    asideSizes.delete(hash);
+    holds.delete(hash);
+  };
+  return {
+    async put(absPath) {
+      const temp = join2(dir, `incoming-${randomUUID3()}`);
+      await mkdir(dir, { recursive: true });
+      await cloneOrStream(absPath, temp).catch(async (error) => {
+        await rm(temp, { force: true });
+        throw error;
+      });
+      const hash = await hashFile(temp);
+      if (sizes.has(hash)) {
+        await rm(temp, { force: true });
+        return hash;
+      }
+      await mkdir(dirname(blobPath(dir, hash)), { recursive: true });
+      const size = (await stat(temp)).size;
+      await rename(temp, blobPath(dir, hash));
+      sizes.set(hash, size);
+      total += size;
+      return hash;
+    },
+    reference: (absPath) => hashFile(absPath),
+    has: (hash) => sizes.has(hash) || asideSizes.has(hash),
+    read: (hash) => readFile(pathOf(hash)),
+    writeTo: async (hash, absPath, beforeReplace) => cloneOrCopy(pathOf(hash), absPath, beforeReplace),
+    async release(held) {
+      for (const [hash, path] of held) {
+        holds.get(hash)?.delete(path);
+        if (holds.get(hash)?.size === 0) await forgetAside(hash);
+      }
+    },
+    async keep(path, absPath, remove) {
+      const hash = await hashFile(absPath);
+      if (sizes.has(hash)) return;
+      if (asideSizes.has(hash)) {
+        holds.get(hash).add(path);
+        return;
+      }
+      const to = blobPath(asideDir, hash);
+      await mkdir(dirname(to), { recursive: true });
+      const moved = remove && await rename(absPath, to).then(
+        () => true,
+        () => false
+      );
+      if (!moved) {
+        const temp = join2(asideDir, `incoming-${randomUUID3()}`);
+        await cloneOrStream(absPath, temp).catch(async (error) => {
+          await rm(temp, { force: true });
+          throw error;
+        });
+        await rename(temp, to);
+      }
+      asideSizes.set(hash, (await stat(to)).size);
+      holds.set(hash, /* @__PURE__ */ new Set([path]));
+    },
+    bytes: () => total,
+    size: (hash) => sizes.get(hash) ?? 0,
+    async drop(hashes) {
+      for (const hash of hashes) if (sizes.has(hash)) await forget(hash);
+    },
+    async prune(keep) {
+      for (const hash of [...sizes.keys()]) if (!keep.has(hash)) await forget(hash);
+      for (const hash of [...asideSizes.keys()]) if (!keep.has(hash)) await forgetAside(hash);
+    }
+  };
+}
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".mov",
+  ".m4v",
+  ".webm",
+  ".mkv",
+  ".avi",
+  ".mxf",
+  ".m2ts",
+  ".mp3",
+  ".wav",
+  ".aac",
+  ".m4a",
+  ".flac",
+  ".ogg",
+  ".opus"
+]);
+var COPY_NOTHING_ABOVE_BYTES = 64 * 1024 ** 2;
+var isUncopied = (path, size) => size > COPY_NOTHING_ABOVE_BYTES || MEDIA_EXTENSIONS.has(extname2(path).toLowerCase());
+function uncopiedOnlyHashes(log, sizeOf) {
+  const copied = /* @__PURE__ */ new Set();
+  const uncopied = /* @__PURE__ */ new Set();
+  const note = (path, hash) => {
+    if (hash) (isUncopied(path, sizeOf(hash)) ? uncopied : copied).add(hash);
+  };
+  for (const [path, hash] of log.baseline) note(path, hash);
+  for (const entry of log.entries)
+    for (const file of entry.files) {
+      note(file.path, file.before);
+      note(file.path, file.after);
+    }
+  return [...uncopied].filter((hash) => !copied.has(hash));
+}
+var ID_PATH = join3(".hyperframes", "history-id");
+var ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var isHistoryId = (name) => ID_SHAPE.test(name);
+function readId(projectDir) {
+  try {
+    const id = readFileSync4(join3(projectDir, ID_PATH), "utf-8").trim();
+    return ID_SHAPE.test(id) ? id : null;
+  } catch {
+    return null;
+  }
+}
+var sameFolder = (a, b) => a.ino === b.ino && a.birthtimeMs === b.birthtimeMs;
+function isRecordedFolder(historyDir, folder) {
+  const was = readRecord(historyDir);
+  if (typeof was?.ino === "number")
+    return sameFolder({ ino: was.ino, birthtimeMs: was.born ?? NaN }, folder);
+  const unreadableSo0878KeptTheId = typeof was?.dir !== "string";
+  if (unreadableSo0878KeptTheId) return true;
+  return !isCopyOf0878Folder(was.dir, basename(historyDir), folder);
+}
+function readRecord(historyDir) {
+  try {
+    return JSON.parse(readFileSync4(join3(historyDir, "project.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isCopyOf0878Folder(recordedDir, id, folder) {
+  let there;
+  try {
+    there = statSync2(recordedDir, { throwIfNoEntry: false });
+  } catch {
+    return false;
+  }
+  return !!there && !sameFolder(there, folder) && readId(recordedDir) === id;
+}
+function projectHistoryId(projectDir, historyRoot) {
+  const dir = resolve3(projectDir);
+  const folder = statSync2(dir);
+  let id = readId(dir);
+  if (!id && existsSync(join3(dir, ID_PATH)))
+    throw new HistoryIdError(
+      `${join3(dir, ID_PATH)} holds no history id this version can read; move it aside to start anew.`
+    );
+  if (!id || existsSync(join3(historyRoot, id)) && !isRecordedFolder(join3(historyRoot, id), folder)) {
+    id = randomUUID4();
+    mkdirWithinProject(dir, join3(dir, ".hyperframes"));
+    writeFileSync2(join3(dir, ID_PATH), `${id}
+`);
+  }
+  recordProject(join3(historyRoot, id), dir, folder);
+  return id;
+}
+var HistoryIdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryIdError";
+  }
+};
+function recordProject(historyDir, dir, folder) {
+  const record = { dir, ino: folder.ino, born: folder.birthtimeMs, dev: folder.dev };
+  mkdirSync2(historyDir, { recursive: true });
+  replaceFileAtomically(join3(historyDir, "project.json"), JSON.stringify(record), 420);
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var KEEP_GONE_PROJECT_HISTORY_MS = 14 * DAY_MS;
+var PRUNED_PREFIX = ".pruned-";
+var LAST_PRUNE_FILE = ".last-prune";
+function listProjectHistories(historyRoot) {
+  return namesIn(historyRoot).filter(isHistoryId).flatMap((id) => {
+    const home = join4(historyRoot, id);
+    const projectDir = readRecord(home)?.dir;
+    if (typeof projectDir !== "string" || readId(projectDir) !== id) return [];
+    return [{ id, projectDir, lastUsedMs: lastUsed(home) }];
+  });
+}
+function namesIn(historyRoot) {
+  try {
+    return readdirSync2(historyRoot);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function pruneGoneProjectHistories(historyRoot, options = {}) {
+  return (await pruneWithin(historyRoot, options)).pruned;
+}
+async function pruneWithin(historyRoot, {
+  now = Date.now(),
+  dryRun = false,
+  tempDir = tmpdir(),
+  onError = (error) => console.warn("[history] could not prune a history:", error),
+  budgetMs = Infinity,
+  measure = true
+}) {
+  const started = performance.now();
+  const names = namesIn(historyRoot);
+  const pruned = [];
+  for (const name of names) {
+    if (performance.now() - started >= budgetMs) return { pruned, finished: false };
+    try {
+      const gone = await pruneEntry(historyRoot, name, { now, dryRun, tempDir, measure });
+      if (gone) pruned.push(gone);
+    } catch (error) {
+      onError(error);
+    }
+  }
+  return { pruned, finished: true };
+}
+async function pruneEntry(historyRoot, name, run) {
+  if (name.startsWith(PRUNED_PREFIX)) {
+    if (!run.dryRun) await rm2(join4(historyRoot, name), { recursive: true, force: true });
+    return null;
+  }
+  return isHistoryId(name) ? pruneOne(historyRoot, name, run) : null;
+}
+async function pruneOne(historyRoot, id, run) {
+  const home = join4(historyRoot, id);
+  if (abandonedProject(home, id, run.now, run.tempDir) === null) return null;
+  const release = await takeUnlessBusy(home);
+  if (!release) return null;
+  let taken;
+  try {
+    taken = recheckAndMoveAway(historyRoot, id, run);
+  } catch (error) {
+    release();
+    throw error;
+  }
+  if (!taken?.trash) release();
+  if (!taken) return null;
+  const bytes = await clearAway(taken.trash, home, run.measure);
+  return { id, projectDir: taken.projectDir, bytes };
+}
+async function clearAway(trash, home, measure) {
+  const bytes = measure ? await bytesIn(trash ?? home) : 0;
+  if (trash) await rm2(trash, { recursive: true, force: true });
+  return bytes;
+}
+async function takeUnlessBusy(home) {
+  try {
+    return await takeHistoryOwnership(home, 0);
+  } catch (error) {
+    if (error instanceof HistoryBusyError) return null;
+    throw error;
+  }
+}
+function recheckAndMoveAway(historyRoot, id, { now, dryRun, tempDir }) {
+  const home = join4(historyRoot, id);
+  const projectDir = abandonedProject(home, id, now, tempDir);
+  if (projectDir === null) return null;
+  if (dryRun) return { projectDir, trash: null };
+  const trash = join4(historyRoot, `${PRUNED_PREFIX}${id}-${randomUUID5()}`);
+  renameSync3(home, trash);
+  return { projectDir, trash };
+}
+function abandonedProject(home, id, now, tempDir) {
+  const record = readRecord(home);
+  const dir = record?.dir;
+  if (typeof dir !== "string") return null;
+  if (now - lastUsed(home) < KEEP_GONE_PROJECT_HISTORY_MS && !isSafePath(tempDir, dir)) return null;
+  return projectGone(dir, id, record?.dev, tempDir) ? dir : null;
+}
+function projectGone(dir, id, dev, tempDir) {
+  if (!statSync3(join4(dir, ID_PATH), { throwIfNoEntry: false }))
+    return diskStillHere(dir, dev, tempDir);
+  const there = readId(dir);
+  return there !== null && there !== id;
+}
+function diskStillHere(dir, dev, tempDir) {
+  let at = dir;
+  let stat4 = statSync3(at, { throwIfNoEntry: false });
+  while (!stat4) {
+    if (dirname2(at) === at) return false;
+    at = dirname2(at);
+    stat4 = statSync3(at, { throwIfNoEntry: false });
+  }
+  if (typeof dev === "number") return stat4.dev === dev;
+  return at === dir || isSafePath(tempDir, at);
+}
+function lastUsed(home) {
+  const mtime = (file) => statSync3(join4(home, file), { throwIfNoEntry: false })?.mtimeMs ?? 0;
+  return Math.max(mtime("project.json"), mtime("log.jsonl"));
+}
+async function bytesIn(dir) {
+  let total = 0;
+  for (const entry of await readdir2(dir, { withFileTypes: true })) {
+    const path = join4(dir, entry.name);
+    total += entry.isDirectory() ? await bytesIn(path) : (await lstat(path)).size;
+  }
+  return total;
+}
+function prunedWithinADay(stamp, now) {
+  try {
+    const last = Number(readFileSync5(stamp, "utf-8"));
+    return last <= now && now - last < DAY_MS;
+  } catch {
+    return false;
+  }
+}
+var pruning = /* @__PURE__ */ new Set();
+function pruneGoneProjectHistoriesDaily(historyRoot, now, { onError, budgetMs } = {}) {
+  const stamp = join4(historyRoot, LAST_PRUNE_FILE);
+  if (pruning.has(historyRoot) || prunedWithinADay(stamp, now)) return;
+  pruning.add(historyRoot);
+  setImmediate(() => {
+    pruneWithin(historyRoot, { now, onError, budgetMs, measure: false }).then(({ finished }) => finished && writeFileSync3(stamp, String(now))).catch((error) => onError?.(error)).finally(() => pruning.delete(historyRoot));
+  });
+}
+var kinds = ["checks", "snapshots"];
+var records = (state, kind) => [
+  ...Object.values(state[kind].revisions).flat(),
+  ...state[kind].unversioned
+];
+var protectedRevisions = (state) => /* @__PURE__ */ new Set([state.currentRevision, ...state.renders?.retainedRevisions ?? []]);
+function managedPath(projectDir, path, kind) {
+  const canonicalProject = realFilePath(resolve4(projectDir));
+  const canonicalPath = realFilePath(path);
+  const root = join5(canonicalProject, ".hyperframes", "artifacts", kind);
+  const rel = relative3(root, canonicalPath);
+  return isAbsolute3(path) && rel !== "" && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute3(rel) && pinProjectRecord(canonicalProject, relative3(canonicalProject, canonicalPath)) === canonicalPath;
+}
+function updateLatest(state) {
+  for (const kind of kinds) {
+    const available = records(state, kind).filter((record) => record.status !== "cleaned");
+    if (available.some(
+      (record) => record.id === state[kind].latest?.id && record.revision === state[kind].latest?.revision
+    ))
+      continue;
+    const latest = available.sort((a, b) => b.createdAt - a.createdAt)[0];
+    state[kind].latest = latest ? { revision: latest.revision, id: latest.id } : null;
+  }
+}
+function planArtifactCleanup(projectDir, state, render) {
+  const protectedIds = protectedRevisions(state);
+  const candidates = [];
+  const keepPaths = /* @__PURE__ */ new Set();
+  const removable = (record, path, kind) => Boolean(record.revision) && !protectedIds.has(record.revision) && record.createdAt <= render.completedAt && managedPath(projectDir, path, kind);
+  for (const kind of kinds) {
+    for (const record of records(state, kind)) {
+      const path = record.image ?? record.report;
+      if (!path || record.status === "cleaned") continue;
+      if (removable(record, path, kind)) candidates.push({ kind, record, path });
+      else keepPaths.add(realFilePath(path));
+    }
+  }
+  for (const { kind, record, path } of candidates) {
+    if (!keepPaths.has(realFilePath(path))) markCleaned(state, kind, record, path, render.id);
+  }
+  updateLatest(state);
+}
+function markCleaned(state, kind, record, path, renderId) {
+  (state.pendingArtifactCleanup ??= []).push({
+    path,
+    hash: record.contentHash,
+    revision: record.revision,
+    id: record.id,
+    kind
+  });
+  delete record.image;
+  delete record.report;
+  record.status = "cleaned";
+  record.cleanedAfterRender = renderId;
+}
+function restoreCleaned(state, item) {
+  const record = state[item.kind].revisions[item.revision]?.find(
+    (candidate) => candidate.id === item.id
+  );
+  if (record?.status !== "cleaned") return;
+  if (item.kind === "checks") record.report = item.path;
+  else record.image = item.path;
+  delete record.status;
+  delete record.cleanedAfterRender;
+}
+function stillPendingAfterUnlink(item) {
+  let descriptor;
+  try {
+    descriptor = openSync(item.path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    const stat4 = fstatSync(descriptor);
+    if (!stat4.isFile() || stat4.isSymbolicLink()) return false;
+    const hash = createHash4("sha256").update(readFileSync6(descriptor)).digest("hex");
+    if (hash !== item.hash) return false;
+    const current = lstatSync2(item.path);
+    if (current.dev !== stat4.dev || current.ino !== stat4.ino) return false;
+    unlinkSync(item.path);
+    return false;
+  } catch (error) {
+    return error.code !== "ENOENT";
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function finishArtifactCleanup(projectDir, state) {
+  const protectedIds = protectedRevisions(state);
+  const referenced = new Set(
+    kinds.flatMap(
+      (kind) => records(state, kind).flatMap((record) => record.image ?? record.report ?? []).map(realFilePath)
+    )
+  );
+  state.pendingArtifactCleanup = (state.pendingArtifactCleanup ?? []).filter((item) => {
+    if (!managedPath(projectDir, item.path, item.kind)) return false;
+    const canonicalPath = realFilePath(item.path);
+    if (protectedIds.has(item.revision)) {
+      restoreCleaned(state, item);
+      return false;
+    }
+    if (state.pendingChanges) return true;
+    if (referenced.has(canonicalPath)) return false;
+    return stillPendingAfterUnlink({ ...item, path: canonicalPath });
+  });
+  updateLatest(state);
+}
+var SNAPSHOT_RUNS_TO_KEEP = 10;
+var SNAPSHOT_GRACE_MS = 24 * 60 * 60 * 1e3;
+var OWNER = ".capture-owner.json";
+var ownedMarkers = /* @__PURE__ */ new Map();
+var UUID = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
+var rootOf = (project) => join6(resolve5(project), ".hyperframes", "artifacts", "snapshots");
+function ordinaryPath(project, path) {
+  const root = resolve5(project);
+  const rel = relative4(root, path);
+  if (rel === ".." || rel.startsWith(`..${sep4}`)) return false;
+  let current = root;
+  for (const part of rel.split(sep4).filter(Boolean)) {
+    current = join6(current, part);
+    try {
+      if (lstatSync3(current).isSymbolicLink()) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function createSnapshotParents(project, path) {
+  let parent = resolve5(project);
+  for (const part of relative4(parent, path).split(sep4).filter(Boolean)) {
+    parent = join6(parent, part);
+    try {
+      mkdirSync3(parent);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+    }
+    if (!ordinaryPath(project, parent)) throw new Error("Snapshot storage must not use symlinks.");
+  }
+}
+function ownSnapshotRun(project, path) {
+  const root = rootOf(project);
+  if (dirname3(path) !== root || !UUID.test(path.slice(root.length + 1))) return;
+  createSnapshotParents(project, root);
+  mkdirSync3(path);
+  const marker = join6(path, OWNER);
+  const fd = openSync2(marker, "wx");
+  try {
+    writeFileSync4(fd, JSON.stringify({ version: 1, pid: process.pid }));
+    ownedMarkers.set(marker, fstatSync2(fd));
+  } finally {
+    closeSync2(fd);
+  }
+}
+function missingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function retainedOutput(path) {
+  try {
+    lstatSync3(join6(path, ".user-output"));
+    return true;
+  } catch (error) {
+    return !missingFile(error);
+  }
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+  }
+}
+function ownerPid(owner) {
+  if (!owner || typeof owner !== "object" || !("pid" in owner)) return null;
+  const pid = owner.pid;
+  return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function ordinaryOwner(stat4) {
+  return stat4.isFile() && stat4.nlink === 1;
+}
+function sameOwnerFile(before, current) {
+  return current.dev === before.dev && current.ino === before.ino;
+}
+function openOwner(marker, access) {
+  const fd = openSync2(marker, access | (constants3.O_NOFOLLOW ?? 0) | (constants3.O_NONBLOCK ?? 0));
+  try {
+    const current = fstatSync2(fd);
+    const named = lstatSync3(marker);
+    if (!ordinaryOwner(current) || !ordinaryOwner(named) || !sameOwnerFile(named, current))
+      throw new Error("Snapshot owner changed while opening.");
+    return fd;
+  } catch (error) {
+    closeSync2(fd);
+    throw error;
+  }
+}
+function readOwner(marker) {
+  const fd = openOwner(marker, constants3.O_RDONLY);
+  try {
+    return JSON.parse(readFileSync7(fd, "utf8"));
+  } finally {
+    closeSync2(fd);
+  }
+}
+function releasedOwner(owner) {
+  return !!owner && typeof owner === "object" && "released" in owner && owner.released === true && ownerPid(owner) !== null;
+}
+function liveOwner(path) {
+  if (retainedOutput(path)) return true;
+  try {
+    const marker = join6(path, OWNER);
+    const owner = readOwner(marker);
+    if (releasedOwner(owner)) return false;
+    const pid = ownerPid(owner);
+    return pid === null || processIsAlive(pid);
+  } catch (error) {
+    return !missingFile(error);
+  }
+}
+function recordsOf(state) {
+  return [...Object.values(state.snapshots.revisions).flat(), ...state.snapshots.unversioned];
+}
+function containingRun(root, path) {
+  if (!path) return null;
+  const name = relative4(root, resolve5(path)).split(sep4)[0];
+  return name && UUID.test(name) ? join6(root, name) : null;
+}
+function keepContainingRun(keep, root, path) {
+  const run = containingRun(root, path);
+  if (run) keep.add(run);
+}
+function protectedRuns(root, state, records2) {
+  const keep = /* @__PURE__ */ new Set();
+  for (const revision of [state.currentRevision, ...state.renders?.retainedRevisions ?? []]) {
+    const latest2 = records2.filter((record) => record.revision === revision && record.status !== "cleaned").sort((a, b) => b.createdAt - a.createdAt)[0];
+    keepContainingRun(keep, root, latest2?.image);
+  }
+  const latest = records2.find((record) => record.id === state.snapshots.latest?.id);
+  keepContainingRun(keep, root, latest?.image);
+  for (const item of state.pendingArtifactCleanup ?? []) keepContainingRun(keep, root, item.path);
+  return keep;
+}
+function runsOnDisk(root) {
+  let entries;
+  try {
+    entries = readdirSync3(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory() && UUID.test(entry.name)).flatMap((entry) => {
+    const path = join6(root, entry.name);
+    try {
+      const stat4 = lstatSync3(path);
+      return [{ path, stat: stat4 }];
+    } catch {
+      return [];
+    }
+  }).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs || a.path.localeCompare(b.path));
+}
+function planSnapshotCleanup(project, state, now = Date.now()) {
+  const root = rootOf(project);
+  if (!ordinaryPath(project, root)) return [];
+  const records2 = recordsOf(state);
+  const keep = protectedRuns(root, state, records2);
+  const runs = runsOnDisk(root);
+  for (const run of runs.slice(0, SNAPSHOT_RUNS_TO_KEEP)) keep.add(run.path);
+  const pending = [];
+  for (const { path, stat: stat4 } of runs) {
+    if (keep.has(path) || now - stat4.mtimeMs < SNAPSHOT_GRACE_MS || liveOwner(path)) continue;
+    try {
+      const run = { path, dev: stat4.dev, ino: stat4.ino, mtimeMs: stat4.mtimeMs };
+      if (!unchangedRun(project, run)) continue;
+      pending.push(run);
+      retireReferences(records2, root, path);
+    } catch {
+    }
+  }
+  return pending;
+}
+function retireReferences(records2, root, path) {
+  for (const record of records2) {
+    if (containingRun(root, record.image) !== path) continue;
+    delete record.image;
+    record.status = "cleaned";
+  }
+}
+function unchangedRun(project, run) {
+  if (!ordinaryPath(project, run.path)) return false;
+  const current = lstatSync3(run.path);
+  return current.isDirectory() && current.dev === run.dev && current.ino === run.ino && current.mtimeMs === run.mtimeMs;
+}
+function finishSnapshotCleanup(project, runs) {
+  for (const run of runs) {
+    try {
+      if (!unchangedRun(project, run) || liveOwner(run.path)) continue;
+      rmSync2(run.path, { recursive: true });
+    } catch {
+    }
+  }
+}
+function releaseSnapshotRun(project, path) {
+  const marker = join6(path, OWNER);
+  const expected = ownedMarkers.get(marker);
+  if (!expected) return;
+  try {
+    if (dirname3(path) !== rootOf(project) || !ordinaryPath(project, path)) return;
+    const fd = openOwner(marker, constants3.O_RDWR);
+    try {
+      if (!sameOwnerFile(expected, fstatSync2(fd))) return;
+      const owner = JSON.parse(readFileSync7(fd, "utf8"));
+      if (ownerPid(owner) !== process.pid) return;
+      ftruncateSync(fd, 0);
+      writeSync(fd, JSON.stringify({ version: 1, pid: process.pid, released: true }), 0, "utf8");
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+  } finally {
+    ownedMarkers.delete(marker);
+  }
+}
+function retainSnapshotOutput(project, path) {
+  const root = rootOf(project);
+  const run = containingRun(root, path);
+  if (!run) return;
+  createSnapshotParents(project, resolve5(path));
+  try {
+    writeFileSync4(
+      join6(run, ".user-output"),
+      "Explicit --output; retained until manual cleanup.\n",
+      { flag: "wx" }
+    );
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+  }
+}
+function statePath(dir) {
+  const path = pinProjectRecord(dir, ".hyperframes/video-state.json");
+  if (!path) throw new Error("Video state must stay inside the project.");
+  return path;
+}
+var collection = () => ({ latest: null, revisions: {}, unversioned: [] });
+var emptyState = () => ({
+  version: 1,
+  historyId: null,
+  currentRevision: null,
+  pendingChanges: true,
+  files: {},
+  revisions: {},
+  checks: collection(),
+  snapshots: collection()
+});
+function readState(dir) {
+  if (!existsSync2(statePath(dir))) return emptyState();
+  const state = JSON.parse(readFileSync8(statePath(dir), "utf8"));
+  if (state.version !== 1 || !state.checks || !state.snapshots || !state.revisions || !state.files)
+    throw new Error("Unsupported video-state schema.");
+  return state;
+}
+async function updateState(dir, update) {
+  const lock = pinProjectRecord(dir, ".hyperframes/video-state-lock");
+  if (!lock) throw new Error("Video state lock must stay inside the project.");
+  const release = await takeHistoryOwnership(lock, 5e3);
+  try {
+    let state;
+    try {
+      state = readState(dir);
+    } catch (error) {
+      if (!(error instanceof SyntaxError)) throw error;
+      renameSync4(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
+      state = emptyState();
+    }
+    update(state);
+    replaceFileAtomically(statePath(dir), JSON.stringify(state, null, 2) + "\n", 420);
+  } finally {
+    release();
+  }
+}
+async function writeHistoryState(projectDir, historyId, historyDirectory, entries, currentFiles, committedFiles) {
+  const blob = (hash) => hash === null ? null : resolve6(historyDirectory, "blobs", hash.slice(0, 2), hash);
+  await updateState(projectDir, (state) => {
+    if (state.historyId && state.historyId !== historyId) {
+      state.checks = collection();
+      state.snapshots = collection();
+    }
+    state.historyId = historyId;
+    state.currentRevision = entries.at(-1)?.id ?? null;
+    state.pendingChanges = currentFiles.size !== committedFiles.size || [...currentFiles].some(([path, hash]) => committedFiles.get(path) !== hash);
+    state.files = Object.fromEntries(
+      [...currentFiles].map(([path, hash]) => [path, { hash, content: blob(hash) }])
+    );
+    state.revisions = Object.fromEntries(
+      entries.map((entry) => [entry.id, revisionState(entry, blob)])
+    );
+    dropArtifactsOfGoneRevisions(state);
+  });
+}
+function revisionState(entry, blob) {
+  const targets = entry.targets?.filter(
+    (target) => entry.files.some((file) => file.path === target.file)
+  );
+  return {
+    actor: entry.who,
+    ...targets?.length && { targets },
+    label: entry.label,
+    startedAt: entry.startedAt,
+    endedAt: entry.endedAt,
+    ...entry.undoes && { undoes: entry.undoes },
+    ...entry.restoredTo && { restoredTo: entry.restoredTo },
+    files: Object.fromEntries(
+      entry.files.map((file) => [
+        file.path,
+        { before: blob(file.before), after: blob(file.after) }
+      ])
+    )
+  };
+}
+function dropArtifactsOfGoneRevisions(state) {
+  const kept = (revision) => Boolean(state.revisions[revision]) || Boolean(state.renders?.retainedRevisions?.includes(revision));
+  for (const artifacts of [state.checks, state.snapshots]) {
+    for (const revision of Object.keys(artifacts.revisions)) {
+      if (!kept(revision)) delete artifacts.revisions[revision];
+    }
+    if (artifacts.latest?.revision && !state.revisions[artifacts.latest.revision])
+      artifacts.latest = null;
+  }
+}
+async function fileHashes(dir) {
+  const files = {};
+  for (const { path } of listProjectFiles(dir).sort((a, b) => a.path.localeCompare(b.path))) {
+    const hash = createHash5("sha256");
+    for await (const chunk of createReadStream2(join7(dir, path))) hash.update(chunk);
+    files[path] = hash.digest("hex");
+  }
+  return files;
+}
+async function beginArtifactCapture(projectDir) {
+  const files = await fileHashes(projectDir);
+  const state = readState(projectDir);
+  const matches = state.historyId !== null && readId(projectDir) === state.historyId && !state.pendingChanges && Object.entries(state.files).every(([path, file]) => files[path] === file.hash) && Object.keys(files).filter((path) => !path.split("/").some((part) => part.startsWith("."))).every((path) => state.files[path]?.hash === files[path]);
+  return {
+    revision: matches ? state.currentRevision : null,
+    fingerprint: createHash5("sha256").update(JSON.stringify(files)).digest("hex")
+  };
+}
+async function recordArtifact(projectDir, capture, artifact) {
+  return recordArtifacts(projectDir, capture, [artifact]);
+}
+async function recordArtifacts(projectDir, capture, artifactsToRecord) {
+  const records2 = [];
+  const hashes = /* @__PURE__ */ new Map();
+  for (const artifact of artifactsToRecord) {
+    const path = artifact.kind === "check" ? artifact.report : artifact.image;
+    if (!path || !isAbsolute4(path)) throw new Error("Artifact needs an absolute output path.");
+    hashes.set(artifact.id, createHash5("sha256").update(readFileSync8(path)).digest("hex"));
+  }
+  const after = await beginArtifactCapture(projectDir);
+  const unchanged = after.fingerprint === capture.fingerprint;
+  let cleanup = [];
+  await updateState(projectDir, (state) => {
+    const revision = unchanged ? knownRevision(state, capture.revision) : null;
+    const attribution = attributionOf(unchanged, revision);
+    for (const artifact of artifactsToRecord) {
+      const { kind, ...fields } = artifact;
+      const record = {
+        ...fields,
+        createdAt: Date.now(),
+        contentHash: hashes.get(artifact.id),
+        revision,
+        inputFingerprint: capture.fingerprint,
+        inputScope: "local-project-files",
+        attribution
+      };
+      const artifacts = kind === "check" ? state.checks : state.snapshots;
+      dropSupersededArtifacts(artifacts, artifact);
+      const list = revision ? artifacts.revisions[revision] ??= [] : artifacts.unversioned;
+      list.push(record);
+      records2.push(record);
+      artifacts.latest = { revision, id: record.id };
+    }
+    cleanup = planSnapshotCleanup(projectDir, state);
+  });
+  finishSnapshotCleanup(projectDir, cleanup);
+  return records2;
+}
+function knownRevision(state, revision) {
+  return revision && state.revisions[revision] ? revision : null;
+}
+function attributionOf(unchanged, revision) {
+  if (!unchanged) return "inputs-changed";
+  return revision ? "recorded-revision" : "unversioned";
+}
+function supersedes(artifact, previous) {
+  if (previous.status !== "cleaned" && !existsSync2(previous.image ?? previous.report ?? ""))
+    return true;
+  if (previous.id === artifact.id) return true;
+  if (artifact.image && previous.image === artifact.image) return true;
+  return Boolean(artifact.report && previous.report === artifact.report);
+}
+function dropSupersededArtifacts(artifacts, artifact) {
+  for (const list of [...Object.values(artifacts.revisions), artifacts.unversioned]) {
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (supersedes(artifact, list[i])) list.splice(i, 1);
+    }
+  }
+}
+function listsOf(artifacts) {
+  return [...Object.values(artifacts.revisions), artifacts.unversioned];
+}
+async function forgetRecordedArtifacts(projectDir, paths) {
+  const gone = new Set(paths.map((path) => resolve6(path)));
+  if (gone.size === 0) return;
+  await updateState(projectDir, (state) => {
+    for (const artifacts of [state.checks, state.snapshots]) {
+      for (const list of listsOf(artifacts)) {
+        for (let i = list.length - 1; i >= 0; i--) {
+          const record = list[i];
+          const path = record.image ?? record.report;
+          if (path && gone.has(resolve6(path))) list.splice(i, 1);
+        }
+      }
+      if (artifacts.latest && !listsOf(artifacts).some(
+        (list) => list.some((record) => record.id === artifacts.latest?.id)
+      )) {
+        artifacts.latest = null;
+      }
+    }
+  });
+}
+function artifactDirectory(projectDir, kind) {
+  const path = join7(resolve6(projectDir), ".hyperframes", "artifacts", kind, randomUUID6());
+  if (kind === "snapshots") ownSnapshotRun(projectDir, path);
+  return path;
+}
+function retainRevision(retained, revision) {
+  if (!revision) return [...retained];
+  return [revision, ...retained.filter((id) => id !== revision)].slice(0, 2);
+}
+async function recordRenderSuccess(projectDir, output, status = "completed", capture) {
+  const outputFile = statSync4(output);
+  if (!outputFile.isFile() && !outputFile.isDirectory() || outputFile.isFile() && outputFile.size === 0)
+    throw new Error("Render output is missing or empty.");
+  const after = capture ? await beginArtifactCapture(projectDir) : null;
+  const record = {
+    id: randomUUID6(),
+    completedAt: Date.now(),
+    output: resolve6(output),
+    status
+  };
+  const unchanged = Boolean(capture && after?.fingerprint === capture.fingerprint);
+  await updateState(projectDir, (state) => {
+    record.revision = unchanged ? knownRevision(state, capture?.revision) : null;
+    state.renders = {
+      latest: record,
+      retainedRevisions: retainRevision(state.renders?.retainedRevisions ?? [], record.revision)
+    };
+    if (outputFile.isFile() && record.revision && !state.pendingChanges)
+      planArtifactCleanup(projectDir, state, record);
+  });
+  await updateState(projectDir, (state) => {
+    finishArtifactCleanup(projectDir, state);
+  });
+  return record;
+}
+async function finishSnapshotRun(projectDir, path) {
+  releaseSnapshotRun(projectDir, path);
+  let cleanup = [];
+  await updateState(projectDir, (state) => {
+    cleanup = planSnapshotCleanup(projectDir, state);
+  });
+  finishSnapshotCleanup(projectDir, cleanup);
+}
+var START = "start";
+function parseRecord(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function readLog(file, onUnreadable) {
+  let text;
+  try {
+    text = readFileSync9(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const log = { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() };
+  const lines = text.split("\n");
+  lines.forEach((line, index) => {
+    const record = line ? parseRecord(line) : null;
+    if (record) applyRecord(log, record);
+    else if (line && index < lines.length - 1) onUnreadable(index + 1);
+  });
+  return log;
+}
+function applyRecord(log, record) {
+  if (record.type === "baseline") {
+    log.baseline = new Map(Object.entries(record.files));
+    log.keepsLedger = record.keepsLedger === true;
+  } else if (record.type === "entry") log.entries.push(record.entry);
+  else if (record.pinned) log.pins.add(record.id);
+  else log.pins.delete(record.id);
+}
+function saveRecord(file, log, record) {
+  let fd;
+  try {
+    fd = openSync3(file, constants4.O_WRONLY | constants4.O_APPEND);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    return writeLog(file, log);
+  }
+  try {
+    writeSync2(fd, `${JSON.stringify(record)}
+`);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function baselineRecord(log) {
+  return {
+    type: "baseline",
+    files: Object.fromEntries(log.baseline),
+    ...log.keepsLedger && { keepsLedger: true }
+  };
+}
+function writeLog(file, log) {
+  const records2 = [
+    baselineRecord(log),
+    ...log.entries.map((entry) => ({ type: "entry", entry })),
+    ...[...log.pins].map((id) => ({ type: "pin", id, pinned: true }))
+  ];
+  mkdirSync4(dirname4(file), { recursive: true });
+  replaceFileAtomically(file, records2.map((r) => `${JSON.stringify(r)}
+`).join(""), 420);
+}
+function applyEntry(manifest2, entry, side) {
+  for (const file of entry.files) {
+    const hash = file[side];
+    if (hash === null) manifest2.delete(file.path);
+    else manifest2.set(file.path, hash);
+  }
+}
+function manifestAt(log, point) {
+  return point === START ? new Map(log.baseline) : manifestAround(log, point, "after");
+}
+function manifestAround(log, id, side) {
+  const manifest2 = new Map(log.baseline);
+  for (const entry of log.entries) {
+    applyEntry(manifest2, entry, entry.id === id ? side : "after");
+    if (entry.id === id) return manifest2;
+  }
+  return null;
+}
+function undoneIds(entries) {
+  const undone = /* @__PURE__ */ new Set();
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry.undoes && !undone.has(entry.id)) undone.add(entry.undoes);
+  }
+  return undone;
+}
+function stepTarget(entries, direction, mine) {
+  const undone = undoneIds(entries);
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  const owns = ownerOf2(entries, byId, mine);
+  const newestFirst = [...entries].reverse();
+  if (direction === "back")
+    return newestFirst.find((entry) => !entry.undoes && !undone.has(entry.id) && owns(entry));
+  for (const entry of newestFirst) {
+    if (!entry.undoes) {
+      if (owns(entry)) return void 0;
+      continue;
+    }
+    const target = byId.get(entry.undoes);
+    if (mine(entry) && !undone.has(entry.id) && target && !target.undoes) return entry;
+  }
+  return void 0;
+}
+function ownerOf2(entries, byId, mine) {
+  const redoneBy = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const target = entry.undoes ? byId.get(entry.undoes) : void 0;
+    if (target?.undoes) redoneBy.set(target.undoes, entry);
+  }
+  return (entry) => mine(entry) || mine(redoneBy.get(entry.id) ?? entry);
+}
+function foldOldest(log) {
+  const oldest = log.entries[0];
+  if (!oldest || log.pins.has(oldest.id)) return false;
+  applyEntry(log.baseline, oldest, "after");
+  log.entries.shift();
+  return true;
+}
+function referencedHashes(log, current) {
+  const keep = /* @__PURE__ */ new Set([...log.baseline.values(), ...current.values()]);
+  for (const entry of log.entries)
+    for (const file of entry.files) {
+      if (file.before) keep.add(file.before);
+      if (file.after) keep.add(file.after);
+    }
+  return keep;
+}
+var DEFAULT_HISTORY_ROOT = join8(homedir(), ".cache", "hyperframes", "history");
+var MAX_WINDOW_IDLE_MS = 10 * 6e4;
+var UNDO_MODES = ["just-this", "back-to-before", "keep-later-edits"];
+var OUTSIDE = { kind: "outside", name: "Outside" };
+var OUTSIDE_LABEL = "Changed outside the app";
+var RACY_MS = 2e3;
+var statKey = (file, sweptAt) => sweptAt - Math.max(file.mtimeMs, file.ctimeMs) < RACY_MS ? "" : `${file.size}:${file.mtimeMs}:${file.ctimeMs}`;
+var MEDIA_LEDGER = ".media/manifest.jsonl";
+var KEPT_HIDDEN_PATHS = /* @__PURE__ */ new Set([...STUDIO_SIGNATURE_MANIFEST_PATHS, MEDIA_LEDGER]);
+function isHistoryPath(path) {
+  if (KEPT_HIDDEN_PATHS.has(path)) return true;
+  return !path.split("/").some((segment) => segment.startsWith("."));
+}
+var logFileIn = (home) => join8(home, "log.jsonl");
+function listOf(log) {
+  const undone = undoneIds(log.entries);
+  return log.entries.map((entry) => ({
+    ...entry,
+    pinned: log.pins.has(entry.id),
+    undone: undone.has(entry.id)
+  }));
+}
+function peekOf(log, point) {
+  const files = manifestAt(log, point);
+  return files && Object.fromEntries(files);
+}
+function withoutHiddenPaths(log) {
+  for (const path of log.baseline.keys()) if (!isHistoryPath(path)) log.baseline.delete(path);
+  for (const entry of log.entries)
+    entry.files = entry.files.filter((file) => isHistoryPath(file.path));
+  return log;
+}
+var historyFiles = (dir) => listProjectFiles(dir).filter((file) => isHistoryPath(file.path));
+var COPY_LATER_ABOVE_BYTES = 1024 ** 2;
+var sameWho = (a, b) => a.kind === b.kind && a.name === b.name;
+function splitAt(change, at, kept) {
+  if (at === change.after) return [change, null];
+  if (!at || at === change.before || !kept) return [null, change];
+  return [
+    { ...change, after: at },
+    { ...change, before: at }
+  ];
+}
+var isMissingFolder = (error) => ["ENOENT", "ENOTDIR"].includes(error.code ?? "");
+async function removeEmptyFolders(dir) {
+  let entries;
+  try {
+    entries = await readdir3(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingFolder(error)) return;
+    throw error;
+  }
+  for (const entry of entries)
+    if (entry.isDirectory()) await removeEmptyFolders(join8(dir, entry.name));
+  await rmdir(dir);
+}
+function fileLeftIn(dir, at, deleted) {
+  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    const path = `${at}/${entry.name}`;
+    const left = entry.isDirectory() ? fileLeftIn(join8(dir, entry.name), path, deleted) : deleted.has(path) ? void 0 : path;
+    if (left) return left;
+  }
+  return void 0;
+}
+function ignoresCase(dir) {
+  const self = statSync5(join8(dir, ID_PATH), { throwIfNoEntry: false });
+  const other = statSync5(join8(dir, ID_PATH.toUpperCase()), { throwIfNoEntry: false });
+  return self !== void 0 && other?.ino === self.ino && other.dev === self.dev;
+}
+var blocks = (removed, added) => added.startsWith(`${removed}/`) || removed.startsWith(`${added}/`);
+var MAX_TIMER_MS = 2 ** 31 - 1;
+var takesWrite = (window, at) => window.idleMs === void 0 || at - (window.lastWriteAt ?? at) <= window.idleMs;
+function chainBackFrom(byAfter, hash) {
+  const chain = /* @__PURE__ */ new Map();
+  let at = hash;
+  let prior = byAfter?.get(at);
+  while (prior !== void 0 && !chain.has(at)) {
+    chain.set(at, prior);
+    at = prior;
+    prior = byAfter?.get(at);
+  }
+  return chain;
+}
+function addChange(group, path, before, after) {
+  const earlier = group.changes.get(path);
+  const from = earlier ? earlier.before : before;
+  if (from === after) group.changes.delete(path);
+  else group.changes.set(path, { path, before: from, after });
+}
+var targetKey = (target) => JSON.stringify([target.file, target.id, target.hfId, target.selector, target.selectorIndex]);
+function keepTargetsOfItsFiles(entry) {
+  const targets = entry.targets?.filter(
+    (target) => entry.files.some((file) => file.path === target.file)
+  );
+  if (targets?.length) entry.targets = targets;
+  else delete entry.targets;
+  return entry;
+}
+var Engine = class {
+  constructor(options, projectId, blobs) {
+    this.options = options;
+    this.projectId = projectId;
+    this.blobs = blobs;
+    this.dir = resolve7(options.projectDir);
+    this.home = join8(options.historyRoot, projectId);
+    this.foldsCase = ignoresCase(this.dir);
+    const folder = statSync5(this.dir, { throwIfNoEntry: false });
+    if (!folder || readId(this.dir) !== projectId || !isRecordedFolder(this.home, folder))
+      throw this.replaced();
+    this.folder = { dev: folder.dev, ino: folder.ino, birthtimeMs: folder.birthtimeMs };
+  }
+  options;
+  projectId;
+  blobs;
+  dir;
+  foldsCase;
+  folder;
+  home;
+  log = { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() };
+  tracked = /* @__PURE__ */ new Map();
+  windows = [];
+  outside = null;
+  /** A coalescing claim, open until another key, its idle timer, an operation, a window, or another write. */
+  claimed = null;
+  adopting = /* @__PURE__ */ new Map();
+  /** Per path and hash an API write left, the hash of the bytes it replaced, until walked or written past. */
+  overwritten = /* @__PURE__ */ new Map();
+  stopHearing;
+  writeToken;
+  quietTimer;
+  maxTimer;
+  notedTimer = null;
+  listeners = /* @__PURE__ */ new Set();
+  tail = Promise.resolve();
+  closed = false;
+  closing;
+  /** A path as the project's disk compares names: folded where `A` and `a` are one name. */
+  nameKey(path) {
+    return this.foldsCase ? path.toLowerCase() : path;
+  }
+  get logFile() {
+    return logFileIn(this.home);
+  }
+  now() {
+    return (this.options.now ?? Date.now)();
+  }
+  /** One operation at a time, in order: sweeps, windows and undos never interleave. */
+  queue(task) {
+    if (this.closed)
+      return Promise.reject(new HistoryClosedError("This project's history is closed."));
+    const run = this.tail.then(async () => {
+      try {
+        return await task();
+      } finally {
+        if (this.whereFolder() === "here") {
+          await writeHistoryState(
+            this.dir,
+            this.projectId,
+            this.home,
+            this.log.entries,
+            this.manifest(),
+            manifestAt(this.log, this.log.entries.at(-1)?.id ?? START) ?? /* @__PURE__ */ new Map()
+          ).catch((error) => this.options.onError?.(error));
+        }
+      }
+    });
+    this.tail = run.catch(() => void 0);
+    return run;
+  }
+  /** Another project if the folder or its id changed, or the id is gone: a recreated folder may reuse the inode. */
+  whereFolder() {
+    const now = statSync5(this.dir, { throwIfNoEntry: false });
+    if (!now) return "gone";
+    const same = now.dev === this.folder.dev && sameFolder(now, this.folder);
+    return same && readId(this.dir) === this.projectId ? "here" : "replaced";
+  }
+  assertWritable() {
+    const folder = this.whereFolder();
+    if (folder === "gone") throw new Error(`The project folder is gone: ${this.dir}`);
+    if (folder === "replaced") throw this.replaced();
+  }
+  persistLog(record) {
+    if (record) saveRecord(this.logFile, this.log, record);
+    else writeLog(this.logFile, this.log);
+    if (!existsSync3(join8(this.home, "project.json")))
+      recordProject(this.home, this.dir, this.folder);
+  }
+  replaced() {
+    return new HistoryClosedError(`${this.dir} is now another project.`);
+  }
+  assertOpen() {
+    if (this.closed) throw new HistoryClosedError("This project's history is closed.");
+    if (this.whereFolder() === "replaced") throw this.replaced();
+  }
+  async start() {
+    const log = readLog(
+      this.logFile,
+      (line) => this.options.onError?.(
+        new Error(`History log line ${line} could not be read and was skipped.`)
+      )
+    );
+    if (!log) return this.firstOpen();
+    this.log = withoutHiddenPaths(log);
+    await this.reclaimUncopied();
+    if (!this.log.keepsLedger) await this.takeInUnnamedLedger();
+    const cache = this.readStatCache();
+    const last = this.log.entries.at(-1)?.id ?? START;
+    for (const [path, hash] of manifestAt(this.log, last) ?? []) {
+      const cached = cache.get(path);
+      this.tracked.set(path, { hash, stat: cached?.hash === hash ? cached.stat : "" });
+    }
+    const left = this.readAdopting();
+    const unadopted = (file) => left.has(file.path) && !this.tracked.has(file.path);
+    this.adoptMediaInBackground(historyFiles(this.dir).filter(unadopted), this.now());
+    this.reopenClosedWindow();
+    await this.settleAll();
+  }
+  /** Copies an older version took of files that are no longer copied; text and small files are never touched. */
+  async reclaimUncopied() {
+    await this.blobs.drop(uncopiedOnlyHashes(this.log, (hash) => this.blobs.size(hash)));
+  }
+  hearWrites() {
+    const realDir = realFilePath(this.dir);
+    this.stopHearing = onFileOverwritten((absPath, version, bytes) => {
+      const after = hashOfVersion(version);
+      if (!after || !affectsProjectSignature(realDir, absPath)) return;
+      const replaced = hashOfVersion(fileContentVersion(bytes));
+      if (!replaced || replaced === after) return;
+      const path = relative5(realDir, absPath).split(sep5).join("/");
+      if (!isHistoryPath(path)) return;
+      this.overwritten.set(
+        path,
+        chainBackFrom(this.overwritten.get(path), replaced).set(after, replaced)
+      );
+      this.queue(async () => {
+        if (!this.blobs.has(replaced) && !isUncopied(path, bytes.length))
+          await this.storeBytes(bytes);
+      }).catch((error) => this.options.onError?.(error));
+    });
+  }
+  async storeBytes(bytes) {
+    const staged = join8(this.home, `overwrote-${randomUUID7()}`);
+    await mkdir2(this.home, { recursive: true });
+    await writeFile(staged, bytes);
+    try {
+      await this.blobs.put(staged);
+    } finally {
+      await rm3(staged, { force: true });
+    }
+  }
+  /** Read at a state no API write left, with no write heard since `heard`: no walk passes it, so forget the rest. */
+  forgetWritesBefore(path, hash, heard) {
+    if (this.overwritten.get(path) === heard && !(hash && heard?.has(hash)))
+      this.overwritten.delete(path);
+  }
+  reopenClosedWindow() {
+    const closed = this.options.closedWindow;
+    if (!closed || this.log.entries.some((entry) => entry.id === closed.id)) return;
+    const { id, who, label, startedAt, lastWriteAt, idleMs } = closed;
+    this.windows.push({ id, who, label, startedAt, lastWriteAt, idleMs, changes: /* @__PURE__ */ new Map() });
+  }
+  async takeInUnnamedLedger() {
+    const named = (path) => this.log.entries.some((entry) => entry.files.some((file) => file.path === path));
+    const listed = () => historyFiles(this.dir).some((file) => file.path === MEDIA_LEDGER);
+    const hash = this.log.baseline.has(MEDIA_LEDGER) || named(MEDIA_LEDGER) || !listed() ? null : await this.storeIfPresent(MEDIA_LEDGER);
+    if (hash !== null) this.log.baseline.set(MEDIA_LEDGER, hash);
+    this.log.keepsLedger = true;
+    this.persistLog();
+  }
+  async firstOpen() {
+    const sweptAt = this.now();
+    const files = historyFiles(this.dir);
+    for (const file of files.filter((file2) => file2.size <= COPY_LATER_ABOVE_BYTES)) {
+      const hash = await this.storeIfPresent(file.path);
+      if (this.whereFolder() !== "here") throw this.replaced();
+      if (hash !== null) this.tracked.set(file.path, { hash, stat: statKey(file, sweptAt) });
+    }
+    this.log.baseline = this.manifest();
+    this.log.keepsLedger = true;
+    this.persistLog();
+    this.saveStatCache();
+    this.adoptMediaInBackground(
+      files.filter((file) => file.size > COPY_LATER_ABOVE_BYTES),
+      sweptAt
+    );
+  }
+  adoptMediaInBackground(files, sweptAt) {
+    let copied = Promise.resolve();
+    for (const file of files) {
+      copied = copied.then(() => this.adopt(file, sweptAt));
+      this.adopting.set(file.path, copied);
+    }
+    this.saveAdopting();
+  }
+  saveAdopting() {
+    const file = join8(this.home, "adopting.json");
+    if (!this.adopting.size) return rmSync3(file, { force: true });
+    mkdirSync5(this.home, { recursive: true });
+    replaceFileAtomically(file, JSON.stringify([...this.adopting.keys()]), 420);
+  }
+  async adopt(file, sweptAt) {
+    try {
+      if (this.whereFolder() !== "here") return;
+      const stored = await this.storeIfPresent(file.path);
+      await this.queue(async () => {
+        await this.recordAdopted(file, sweptAt, stored);
+        this.adopting.delete(file.path);
+        this.saveAdopting();
+      });
+    } catch (error) {
+      if (!(error instanceof HistoryClosedError)) this.options.onError?.(error);
+    }
+  }
+  async recordAdopted(file, sweptAt, stored) {
+    if (stored === null || this.whereFolder() !== "here") return;
+    const kept = this.blobs.has(stored) || isUncopied(file.path, file.size);
+    const hash = kept ? stored : await this.storeIfPresent(file.path);
+    if (hash === null) return;
+    const change = { path: file.path, before: null, after: hash };
+    const found = this.overwrittenBy(change, void 0, /* @__PURE__ */ new Set());
+    const start = found && this.blobs.has(found) ? found : hash;
+    this.tracked.set(file.path, { hash, stat: statKey(file, sweptAt) });
+    this.log.baseline.set(file.path, start);
+    if (start !== hash) addChange(this.outsideGroup(), file.path, start, hash);
+    this.persistLog(baselineRecord(this.log));
+    this.saveStatCache();
+  }
+  manifest() {
+    return new Map([...this.tracked].map(([path, file]) => [path, file.hash]));
+  }
+  readStatCache() {
+    try {
+      const files = JSON.parse(readFileSync10(join8(this.home, "stat.json"), "utf-8"));
+      return new Map(Object.entries(files));
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  readAdopting() {
+    try {
+      return new Set(
+        JSON.parse(readFileSync10(join8(this.home, "adopting.json"), "utf-8"))
+      );
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  saveStatCache() {
+    const files = JSON.stringify(Object.fromEntries(this.tracked));
+    mkdirSync5(this.home, { recursive: true });
+    replaceFileAtomically(join8(this.home, "stat.json"), files, 420);
+  }
+  /**
+   * Takes in every write since the last sweep and files each change to its writer. ponytail: always the whole
+   * project (a stat per file, a hash only when the stat moved); per-path sweeps if projects reach tens of thousands.
+   */
+  async sweep() {
+    if (this.whereFolder() !== "here") return;
+    const sweptAt = this.now();
+    const changedAt = (file) => Math.min(sweptAt, Math.max(file.mtimeMs, file.ctimeMs));
+    const seen = historyFiles(this.dir).filter((file) => !this.adopting.has(file.path));
+    const heard = new Map(this.overwritten);
+    const present = new Set(seen.map((file) => file.path));
+    const removed = [...this.tracked.keys()].filter((path) => !present.has(path)).map((path) => {
+      const standing = this.standingAt(path);
+      return { at: standing ? changedAt(standing.stat) : sweptAt, path, file: null };
+    });
+    const appearedAt = (file) => Math.max(
+      changedAt(file),
+      ...removed.filter((gone) => blocks(this.nameKey(gone.path), this.nameKey(file.path))).map((gone) => gone.at)
+    );
+    const events = [
+      ...removed,
+      ...seen.map((file) => ({ at: appearedAt(file), path: file.path, file }))
+    ].sort((a, b) => a.at - b.at);
+    let changed = false;
+    for (const { at, path, file } of events) {
+      if (file) {
+        changed = await this.observe(path, statKey(file, sweptAt), at) || changed;
+        continue;
+      }
+      const known = this.tracked.get(path);
+      this.tracked.delete(path);
+      this.forgetWritesBefore(path, null, heard.get(path));
+      await this.record(path, known.hash, null, at);
+      changed = true;
+    }
+    if (changed) this.saveStatCache();
+  }
+  /** The file's hash once copied in; null when it was removed before the copy (the next sweep records that). */
+  async storeIfPresent(path) {
+    try {
+      const abs = join8(this.dir, path);
+      const { size } = await stat2(abs);
+      return await (isUncopied(path, size) ? this.blobs.reference(abs) : this.blobs.put(abs));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  async observe(path, stat4, at) {
+    const known = this.tracked.get(path) ?? { hash: null, stat: null };
+    if (stat4 && known.stat === stat4) return false;
+    const heard = this.overwritten.get(path);
+    const hash = await this.storeIfPresent(path);
+    if (hash === null || this.whereFolder() !== "here") return false;
+    this.tracked.set(path, { hash, stat: stat4 });
+    this.forgetWritesBefore(path, hash, heard);
+    if (known.hash !== hash) await this.record(path, known.hash, hash, at);
+    return known.hash !== hash || known.stat !== stat4;
+  }
+  async record(path, before, after, at) {
+    const endedBeforeThisWrite = this.windows.filter((open) => !takesWrite(open, at));
+    if (endedBeforeThisWrite.length) await this.commitOutside();
+    for (const window2 of endedBeforeThisWrite) await this.endWindow(window2);
+    const window = this.windows.at(-1);
+    if (window) this.touch(window, at);
+    addChange(window ?? this.outsideGroup(), path, before, after);
+  }
+  /** ponytail: another's write between Studio's write and its sweep folds into Studio's entry (per-write tokens). */
+  async claimNow(who, label, paths, { coalesceKey, idleMs, overwrote = {}, targets = [] }) {
+    await this.sweep();
+    const taken = await this.takeClaimed(who, paths, overwrote);
+    if (!taken.length) return this.claimNothing(coalesceKey);
+    const held = this.heldFor(coalesceKey, taken);
+    if (!held) await this.commitClaim();
+    await this.commitPending();
+    const group = held ?? this.newGroup(who, label);
+    for (const change of taken) addChange(group, change.path, change.before, change.after);
+    this.addTargets(group, targets);
+    if (coalesceKey) return this.holdClaim(group, coalesceKey, idleMs);
+    const entry = await this.commit(group);
+    return entry && { id: entry.id };
+  }
+  addTargets(group, targets) {
+    const unique = new Map((group.targets ?? []).map((target) => [targetKey(target), target]));
+    for (const target of targets) {
+      const normalized = { ...target, file: this.logPath(target.file) };
+      if (group.changes.has(normalized.file)) unique.set(targetKey(normalized), normalized);
+    }
+    group.targets = [...unique.values()];
+  }
+  /** A claim that took nothing still ends a held claim under another key. */
+  async claimNothing(coalesceKey) {
+    if (coalesceKey !== this.claimed?.key) await this.commitClaim();
+    return null;
+  }
+  /** Commits every other writer's pending changes, oldest first; open windows stay open. */
+  async commitPending() {
+    await this.commitOutside();
+    for (const window of [...this.windows])
+      if (window.changes.size) await this.commitCut(window, [...window.changes.keys()]);
+  }
+  pendingElsewhere() {
+    return Boolean(this.outside?.changes.size) || this.windows.some((open) => open.changes.size > 0);
+  }
+  /** The held claim `taken` continues: same key, each file from its own last change, no held file changed since. */
+  heldFor(key, taken) {
+    const group = key && this.claimed?.key === key && !this.pendingElsewhere() ? this.claimed.group : null;
+    const after = (path, before) => {
+      const own = group?.changes.get(path);
+      return own ? own.after : before;
+    };
+    const takenPaths = new Set(taken.map((change) => change.path));
+    const untouched = (change) => takenPaths.has(change.path) || (this.tracked.get(change.path)?.hash ?? null) === change.after;
+    return group && taken.every((change) => after(change.path, change.before) === change.before) && [...group.changes.values()].every(untouched) ? group : null;
+  }
+  logPath(path) {
+    return relative5(this.dir, resolve7(this.dir, path)).split(sep5).join("/");
+  }
+  /** Takes `paths`' uncommitted changes from others, cut at what `who` overwrote. */
+  async takeClaimed(who, paths, overwrote) {
+    const wanted = new Set(paths.map((path) => this.logPath(path)));
+    const at = new Map(
+      Object.entries(overwrote).map(([path, version]) => [
+        this.logPath(path),
+        hashOfVersion(version)
+      ])
+    );
+    const others = this.windows.filter((open) => !sameWho(open.who, who));
+    const groups = this.outside ? [this.outside, ...others] : others;
+    const hits = groups.flatMap(
+      (group) => [...group.changes.values()].filter((change) => wanted.has(change.path)).map((change) => ({ group, change }))
+    );
+    const cuts = [];
+    const walked = hits.map(() => /* @__PURE__ */ new Set());
+    for (const [i, { change }] of hits.entries()) {
+      const told = at.get(change.path);
+      cuts.push(this.overwrittenBy(change, told, walked[i]) ?? told);
+    }
+    hits.forEach(({ change }, i) => this.forgetOverwritten(change.path, walked[i]));
+    return hits.flatMap(({ group, change }, i) => this.cutOut(group, change, cuts[i]) ?? []);
+  }
+  /** Walks the server's writes back from `change.after` to the stored bytes they replaced. */
+  overwrittenBy(change, told, seen) {
+    let found;
+    for (let hash = change.after; hash; ) {
+      if (seen.has(hash)) return void 0;
+      seen.add(hash);
+      const replaced = this.overwritten.get(change.path)?.get(hash);
+      if (replaced === void 0) break;
+      found = hash = replaced;
+      if (hash === change.before || hash === told) return hash;
+    }
+    return found;
+  }
+  forgetOverwritten(path, hashes) {
+    const byAfter = this.overwritten.get(path);
+    for (const hash of hashes) byAfter?.delete(hash);
+    if (byAfter?.size === 0) this.overwritten.delete(path);
+  }
+  cutOut(group, change, cut) {
+    const [kept, claimed] = splitAt(change, cut, cut !== void 0 && this.blobs.has(cut));
+    group.changes.delete(change.path);
+    if (kept) group.changes.set(kept.path, kept);
+    return claimed;
+  }
+  /** Commits the window's cut `paths` as their own entry, other files staying: a window holds one change per file,
+   * so the writer's next write to a cut file would otherwise span the claimer's edit. */
+  async commitCut(window, paths) {
+    const part = { ...this.newGroup(window.who, window.label), startedAt: window.startedAt };
+    for (const path of paths) {
+      part.changes.set(path, window.changes.get(path));
+      window.changes.delete(path);
+    }
+    (window.parts ??= /* @__PURE__ */ new Set()).add(part.id);
+    window.entry = await this.commit(part);
+  }
+  holdClaim(group, key, idleMs = this.options.quietMs ?? 2e3) {
+    clearTimeout(this.claimed?.timer);
+    const timer = Number.isFinite(idleMs) ? setTimeout(() => this.background(() => this.commitClaim()), idleMs) : void 0;
+    timer?.unref?.();
+    group.lastWriteAt = this.now();
+    this.claimed = { group, key, timer };
+    return group.changes.size ? { id: group.id } : null;
+  }
+  async commitClaim() {
+    const held = this.claimed;
+    this.claimed = null;
+    if (!held) return;
+    clearTimeout(held.timer);
+    await this.commit(held.group);
+  }
+  outsideGroup() {
+    const { quietMs = 2e3, maxGroupMs = 3e4 } = this.options;
+    const closeIn = (ms) => {
+      const timer = setTimeout(() => this.background(() => this.commitOutside()), ms);
+      timer.unref?.();
+      return timer;
+    };
+    if (!this.outside) {
+      this.outside = this.newGroup(OUTSIDE, OUTSIDE_LABEL);
+      this.maxTimer = closeIn(maxGroupMs);
+    }
+    clearTimeout(this.quietTimer);
+    this.quietTimer = closeIn(quietMs);
+    return this.outside;
+  }
+  newGroup(who, label) {
+    return { id: randomUUID7(), who, label, startedAt: this.now(), changes: /* @__PURE__ */ new Map() };
+  }
+  async commitOutside() {
+    if (this.outside?.changes.size) await this.commitClaim();
+    clearTimeout(this.quietTimer);
+    clearTimeout(this.maxTimer);
+    const group = this.outside;
+    this.outside = null;
+    if (group) await this.commit(group);
+  }
+  async commit(group, extra = {}) {
+    const undoesEmptied = this.log.entries.find((entry2) => entry2.id === extra.undoes)?.files.length === 0;
+    if (!group.changes.size && !undoesEmptied) return null;
+    const pending = this.pendingEntry(group);
+    const endedAt = Math.max(pending.endedAt, this.log.entries.at(-1)?.endedAt ?? 0);
+    const entry = keepTargetsOfItsFiles({ ...pending, endedAt, ...extra });
+    this.log.entries.push(entry);
+    try {
+      this.persistLog({ type: "entry", entry });
+    } catch (error) {
+      this.log.entries.pop();
+      throw error;
+    }
+    for (const listener of this.listeners) listener(entry);
+    for (const change of group.changes.values()) {
+      const walked = /* @__PURE__ */ new Set();
+      this.overwrittenBy(change, void 0, walked);
+      this.forgetOverwritten(change.path, walked);
+    }
+    await this.keepWithinBudget();
+    return entry;
+  }
+  /** Stored bytes beyond what the current files need: a project larger than the budget still keeps its history. */
+  historyBytes() {
+    let current = 0;
+    for (const hash of new Set([...this.tracked.values()].map((file) => file.hash)))
+      current += this.blobs.size(hash);
+    return this.blobs.bytes() - current;
+  }
+  async keepWithinBudget() {
+    const budget = this.options.budgetBytes ?? 2 * 1024 ** 3;
+    let folded = false;
+    while (this.historyBytes() > budget) {
+      await this.blobs.prune(
+        /* @__PURE__ */ new Set([
+          ...referencedHashes(this.log, this.manifest()),
+          ...this.pendingHashes(),
+          ...[...this.overwritten.values()].flatMap((byAfter) => [...byAfter.values()])
+        ])
+      );
+      if (this.historyBytes() <= budget || !foldOldest(this.log)) break;
+      folded = true;
+    }
+    if (folded) this.persistLog();
+  }
+  /** Hashes only pending changes point at yet, such as a claim's stored cut. */
+  pendingHashes() {
+    const changes = [...this.windows, this.outside, this.claimed?.group].flatMap((group) => [
+      ...group?.changes.values() ?? []
+    ]);
+    return changes.flatMap((change) => [change.before, change.after]).filter((hash) => hash !== null);
+  }
+  /** Before an operation or a window: every write is filed and every pending change committed, in write order. */
+  async settle() {
+    await this.sweep();
+    await this.commitClaim();
+    await this.commitPending();
+  }
+  /** A watcher saw a write: one sweep per burst takes it in (a deleted folder is reported by its name alone). */
+  noteChange(path) {
+    const absolute = resolve7(this.dir, path);
+    if (this.notedTimer || !affectsProjectSignature(this.dir, absolute)) return;
+    if (!isHistoryPath(relative5(this.dir, absolute).split(sep5).join("/"))) return;
+    this.notedTimer = setTimeout(() => {
+      this.notedTimer = null;
+      this.background(() => this.sweep());
+    }, 20);
+    this.notedTimer.unref?.();
+  }
+  background(task) {
+    this.queue(task).catch((error) => {
+      if (!(error instanceof HistoryClosedError)) this.options.onError?.(error);
+    });
+  }
+  beginWindow(who, label, idleMs, exclusive = false) {
+    return this.queue(async () => {
+      await this.settle();
+      const at = this.now();
+      if (exclusive) {
+        const blocking = this.windows.find(
+          (open) => !sameWho(open.who, who) && takesWrite(open, at)
+        );
+        if (blocking)
+          throw new Error(`${blocking.who.name}'s turn is open; it has to end before yours begins`);
+        for (const open of [...this.windows])
+          if (!takesWrite(open, at) || sameWho(open.who, who)) await this.endWindow(open);
+      }
+      const window = { ...this.newGroup(who, label), idleMs };
+      this.windows.push(window);
+      this.touch(window, this.now());
+      const close = () => this.queue(() => this.sweepAndEnd(window));
+      return { id: window.id, startedAt: window.startedAt, close };
+    });
+  }
+  /** A window with no write for its idleMs ends, so a close that never comes cannot hold every later write. */
+  touch(window, at) {
+    window.lastWriteAt = Math.max(window.lastWriteAt ?? at, at);
+    this.endWhenIdle(window, window.idleMs);
+  }
+  endWhenIdle(window, delay) {
+    clearTimeout(window.idleTimer);
+    if (window.idleMs === void 0 || !Number.isFinite(window.idleMs) || delay === void 0)
+      return;
+    window.idleTimer = setTimeout(
+      () => {
+        const left = window.idleMs - (this.now() - (window.lastWriteAt ?? this.now()));
+        if (left > 0) this.endWhenIdle(window, left);
+        else this.background(() => this.sweepAndEnd(window));
+      },
+      Math.min(delay, MAX_TIMER_MS)
+    );
+    window.idleTimer.unref?.();
+  }
+  async sweepAndEnd(window) {
+    await this.sweep();
+    return this.endWindow(window);
+  }
+  /** Commits an open window once; ending it again returns the entry it became. */
+  async endWindow(window) {
+    if (!this.windows.includes(window)) return window.entry ?? null;
+    clearTimeout(window.idleTimer);
+    await this.commitClaim();
+    this.windows = this.windows.filter((open) => open !== window);
+    window.entry = await this.commit(window) ?? window.entry ?? null;
+    return window.entry;
+  }
+  /** Every pending write, open window and outside group, committed: for flush and close. */
+  async settleAll() {
+    await this.sweep();
+    await this.commitClaim();
+    for (const window of [...this.windows]) await this.endWindow(window);
+    await this.commitOutside();
+  }
+  /** What took a removed path's place, dating its removal: an entry at the path, or a file at a folder above it. */
+  standingAt(path) {
+    const parts = path.split("/");
+    for (let depth = 1; depth <= parts.length; depth += 1) {
+      const at = parts.slice(0, depth).join("/");
+      const stat4 = lstatSync4(join8(this.dir, at), { throwIfNoEntry: false });
+      if (!stat4) return void 0;
+      if (at === path || !stat4.isDirectory()) return { at, stat: stat4 };
+    }
+    return void 0;
+  }
+  /** What a write of `path` would have to delete: a file or link at or above it, or a file in a folder at it. */
+  inTheWay(path, deleted) {
+    const standing = this.standingAt(path);
+    if (!standing) return void 0;
+    if (standing.stat.isSymbolicLink()) return standing.at;
+    if (standing.at === path && !standing.stat.isDirectory()) return void 0;
+    const real = realpathSync.native(join8(this.dir, standing.at));
+    const at = relative5(realpathSync.native(this.dir), real).split(sep5).join("/");
+    if (standing.at !== path) return deleted.has(at) ? void 0 : at;
+    return fileLeftIn(real, at, deleted);
+  }
+  /** Writes `target` (path to hash, null deletes) as one entry of `who`'s. */
+  async writeAs(who, label, target, extra) {
+    this.assertWritable();
+    const changes = [...target].filter(([path, hash]) => (this.tracked.get(path)?.hash ?? null) !== hash).sort(([, a], [, b]) => Number(a !== null) - Number(b !== null));
+    const setAsideByDeletesFirst = new Set(
+      changes.filter(([, hash]) => hash === null).map(([path]) => this.tracked.get(path)?.hash)
+    );
+    const gone = changes.find(
+      ([, hash]) => hash !== null && !this.blobs.has(hash) && !setAsideByDeletesFirst.has(hash)
+    );
+    if (gone)
+      throw new Error(
+        `An earlier version of ${gone[0]} is not kept, so this cannot be brought back.`
+      );
+    const deleted = new Set(changes.filter(([, hash]) => hash === null).map(([path]) => path));
+    const blocked = changes.filter(([, hash]) => hash !== null).map(([path]) => this.inTheWay(path, deleted)).find(Boolean);
+    if (blocked) throw new Error(`${blocked} is in the way; move or delete it, then try again.`);
+    const group = this.newGroup(who, label);
+    this.windows.push(group);
+    try {
+      for (const [path, hash] of changes) await this.writeProjectFile(path, hash);
+      await this.blobs.release(
+        changes.flatMap(([path, hash]) => hash ? [[hash, path]] : [])
+      );
+      await this.sweep();
+    } finally {
+      this.windows = this.windows.filter((open) => open !== group);
+    }
+    return this.commit(group, extra);
+  }
+  /** Writes one project file (null deletes it), first leaving the running operation's receipt for its echo. */
+  async writeProjectFile(path, hash) {
+    this.assertWritable();
+    const absPath = join8(this.dir, path);
+    const { writeToken } = this;
+    if (writeToken) {
+      const version = hash === null ? DELETED_VERSION : hashVersion(hash);
+      recordFileWriteReceipt(absPath, { path, version, writeToken });
+    }
+    const standing = lstatSync4(absPath, { throwIfNoEntry: false });
+    if (standing?.isFile() && isUncopied(path, standing.size))
+      await this.blobs.keep(path, absPath, hash === null);
+    if (hash === null) {
+      this.assertWritable();
+      rmSync3(absPath, { force: true });
+    } else {
+      await removeEmptyFolders(absPath);
+      await this.blobs.writeTo(hash, absPath, () => this.assertWritable());
+    }
+  }
+  entry(id) {
+    const entry = this.log.entries.find((candidate) => candidate.id === id);
+    if (!entry) throw new Error("That change is no longer kept in this project's history.");
+    return entry;
+  }
+  undoLabel(entry) {
+    if (!entry.undoes) return `Undid: ${entry.label}`;
+    const original = this.log.entries.find((candidate) => candidate.id === entry.undoes);
+    return `Redid: ${original?.label ?? entry.label}`;
+  }
+  async undoNow(id, who, mode) {
+    const entry = this.entry(id);
+    const changed = this.movedOn(entry);
+    if (changed.length && !mode) return { ok: false, conflict: this.conflict(entry, changed) };
+    if (mode === "back-to-before") {
+      const index = this.log.entries.indexOf(entry);
+      const point = index > 0 ? this.log.entries[index - 1].id : START;
+      return {
+        ok: true,
+        entry: await this.restoreNow(point, who, `Went back to before: ${entry.label}`)
+      };
+    }
+    const target = new Map(
+      entry.files.filter((file) => mode !== "keep-later-edits" || !changed.includes(file)).map((file) => [file.path, file.before])
+    );
+    return {
+      ok: true,
+      entry: await this.writeAs(who, this.undoLabel(entry), target, {
+        undoes: id,
+        ...entry.targets && { targets: entry.targets }
+      })
+    };
+  }
+  movedOn(entry) {
+    return entry.files.filter((file) => (this.tracked.get(file.path)?.hash ?? null) !== file.after);
+  }
+  next(direction, who) {
+    const mine = (author) => sameWho(author, who) || sameWho(author, OUTSIDE);
+    const pending = [...[...this.windows].reverse(), this.outside, this.claimed?.group].find(
+      (group) => group?.changes.size && mine(group.who)
+    );
+    if (pending) return direction === "back" ? this.pendingEntry(pending) : void 0;
+    const everyone = this.options.undoScope === "everyone";
+    const ofOpenTurn = (entry) => this.windows.some((open) => open.parts?.has(entry.id));
+    return stepTarget(
+      this.log.entries,
+      direction,
+      (entry) => entry.files.length > 0 && (mine(entry.who) || everyone && !ofOpenTurn(entry))
+    );
+  }
+  /** A pending group as the entry it becomes once committed (a window's part gets a fresh id). */
+  pendingEntry(group) {
+    const files = [...group.changes.values()].sort((a, b) => a.path.localeCompare(b.path));
+    const { id, who, label, startedAt, lastWriteAt } = group;
+    return {
+      id,
+      who,
+      label,
+      startedAt,
+      endedAt: lastWriteAt ?? this.now(),
+      files,
+      ...group.targets?.length && { targets: group.targets }
+    };
+  }
+  conflict(entry, changed) {
+    const paths = new Set(changed.map((file) => file.path));
+    const after = this.log.entries.slice(this.log.entries.indexOf(entry) + 1);
+    const newer = after.filter((later) => later.files.some((file) => paths.has(file.path)));
+    return { files: [...paths], newer: newer.map((later) => later.id) };
+  }
+  async restoreNow(point, who, label) {
+    const files = manifestAt(this.log, point);
+    if (!files) throw new Error("That point is no longer kept in this project's history.");
+    const target = new Map(
+      [...this.tracked.keys()].map((path) => [path, null])
+    );
+    for (const [path, hash] of files) target.set(path, hash);
+    if (point === START && this.adopting.size > 0) {
+      throw new HistoryRefusedError(
+        "The project's starting copy is still being saved; try again in a moment. Nothing was changed."
+      );
+    }
+    const isProjectFile = (path) => !KEPT_HIDDEN_PATHS.has(path);
+    const keepsAny = [...target].some(([path, hash]) => hash !== null && isProjectFile(path));
+    if ([...this.tracked.keys()].some(isProjectFile) && !keepsAny) {
+      throw new HistoryRefusedError(
+        "Restoring this point would remove every file in this project, so nothing was changed."
+      );
+    }
+    return this.writeAs(who, label, target, { restoredTo: point });
+  }
+  /** Settles, then runs `task` with its writes labelled `writeToken`. */
+  operation(writeToken, task) {
+    return this.queue(async () => {
+      await this.settle();
+      this.writeToken = writeToken;
+      try {
+        return await task();
+      } finally {
+        this.writeToken = void 0;
+      }
+    });
+  }
+  pointLabel(point) {
+    return point === START ? "the start" : this.entry(point).label;
+  }
+  api() {
+    return {
+      projectId: this.projectId,
+      beginWindow: (who, label, options = {}) => this.beginWindow(
+        who,
+        label,
+        options.idleMs ?? this.options.maxGroupMs ?? 3e4,
+        options.exclusive === true
+      ),
+      claim: async (who, label, paths, options = {}) => {
+        await Promise.all(paths.map((path) => this.adopting.get(this.logPath(path))));
+        return this.queue(() => this.claimNow(who, label, paths, options));
+      },
+      noteChange: (path) => {
+        if (!this.closed) this.noteChange(path);
+      },
+      list: () => {
+        this.assertOpen();
+        return listOf(this.log);
+      },
+      step: (direction, who, { writeToken } = {}) => this.operation(writeToken, async () => {
+        const target = this.next(direction, who);
+        return target ? this.undoNow(target.id, who) : { ok: true, entry: null };
+      }),
+      undo: (id, { who, mode, writeToken }) => this.operation(writeToken, () => this.undoNow(id, who, mode)),
+      restore: (point, who, { writeToken } = {}) => this.operation(
+        writeToken,
+        () => this.restoreNow(point, who, `Restored: ${this.pointLabel(point)}`)
+      ),
+      peek: (point) => {
+        this.assertOpen();
+        return peekOf(this.log, point);
+      },
+      checkout: (entryId, side, emptyDir) => this.queue(async () => {
+        this.entry(entryId);
+        if (!existsSync3(this.dir)) throw new Error(`The project folder is gone: ${this.dir}`);
+        const dest = resolve7(emptyDir);
+        if (isWithin(this.dir, dest))
+          throw new Error(`Checkout writes outside the project only: ${dest}`);
+        if ((await readdir3(dest).catch(missingIsEmpty)).length > 0)
+          throw new Error(`Checkout writes into an empty folder only: ${dest}`);
+        const files = manifestAround(this.log, entryId, side);
+        for (const [path, hash] of files)
+          if (!this.blobs.has(hash))
+            throw new Error(`The version of ${path} from then is not kept.`);
+        try {
+          for (const [path, hash] of files) await this.blobs.writeTo(hash, join8(dest, path));
+        } catch (error) {
+          for (const name of await readdir3(dest).catch(() => []))
+            await rm3(join8(dest, name), { recursive: true, force: true });
+          throw error;
+        }
+      }),
+      next: (direction, who) => {
+        this.assertOpen();
+        return this.next(direction, who);
+      },
+      readBlob: async (hash) => {
+        this.assertOpen();
+        return this.blobs.read(hash);
+      },
+      pin: (id, pinned) => {
+        this.assertOpen();
+        this.entry(id);
+        if (pinned) this.log.pins.add(id);
+        else this.log.pins.delete(id);
+        this.persistLog({ type: "pin", id, pinned });
+      },
+      onEntry: (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      },
+      checkpoint: () => this.queue(() => this.settle()),
+      flush: () => this.queue(() => this.settleAll()),
+      replacedAtPath: () => this.whereFolder() === "replaced",
+      close: () => this.closing ??= (async () => {
+        await Promise.all(this.adopting.values());
+        if (this.notedTimer) clearTimeout(this.notedTimer);
+        this.stopHearing?.();
+        const settled = this.queue(() => this.settleAll());
+        this.closed = true;
+        await settled;
+      })()
+    };
+  }
+};
+function isWithin(dir, path) {
+  let probe = resolve7(path);
+  while (!existsSync3(probe) && dirname5(probe) !== probe) probe = dirname5(probe);
+  const rel = relative5(realpathSync.native(dir), realpathSync.native(probe));
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep5}`) && !isAbsolute5(rel);
+}
+function missingIsEmpty(error) {
+  if (error.code === "ENOENT") return [];
+  throw error;
+}
+var HistoryClosedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryClosedError";
+  }
+};
+var HistoryRefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryRefusedError";
+  }
+};
+async function openProjectHistory(options) {
+  if (!existsSync3(options.projectDir))
+    throw new HistoryClosedError(`${options.projectDir} is gone or now another project.`);
+  const projectId = projectHistoryId(options.projectDir, options.historyRoot);
+  const release = await takeHistoryOwnership(
+    join8(options.historyRoot, projectId),
+    options.ownerWaitMs ?? 5e3,
+    options.ownerUrl
+  );
+  try {
+    const blobs = await openBlobStore(join8(options.historyRoot, projectId, "blobs"));
+    const closedWindow = options.closedWindowAfterOwnership?.() ?? options.closedWindow;
+    const engine = new Engine({ ...options, closedWindow }, projectId, blobs);
+    await engine.queue(async () => {
+      await engine.start();
+      engine.hearWrites();
+    });
+    pruneGoneProjectHistoriesDaily(options.historyRoot, engine.now(), {
+      onError: options.onError,
+      budgetMs: options.pruneGoneProjectsBudgetMs
+    });
+    const api = engine.api();
+    return {
+      ...api,
+      close: () => api.close().finally(release)
+    };
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+function readProjectHistory(options) {
+  const dir = resolve7(options.projectDir);
+  const id = readId(dir);
+  const home = id && isRecordedFolder(join8(options.historyRoot, id), statSync5(dir)) ? join8(options.historyRoot, id) : null;
+  const read = home && readLog(logFileIn(home), () => {
+  });
+  const log = withoutHiddenPaths(read || { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() });
+  return {
+    list: () => listOf(log),
+    peek: (point) => peekOf(log, point),
+    readBlob: async (hash) => {
+      if (!home) throw new Error("That is not a history blob.");
+      return readBlob(join8(home, "blobs"), hash);
+    }
+  };
+}
+function historyIds(historyRoot) {
+  try {
+    return readdirSync5(historyRoot).filter(isHistoryId);
+  } catch {
+    return [];
+  }
+}
+function namedHashes(log) {
+  const hashes = new Set(log.baseline.values());
+  for (const entry of log.entries) {
+    for (const file of entry.files) {
+      if (file.before) hashes.add(file.before);
+      if (file.after) hashes.add(file.after);
+    }
+  }
+  return hashes;
+}
+async function blobSizes(blobs, hashes) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const hash of hashes)
+    sizes.set(hash, (await stat3(blobPath(blobs, hash)).catch(() => null))?.size ?? 0);
+  return sizes;
+}
+async function reclaimOne(home, dryRun) {
+  const log = readLog(join9(home, "log.jsonl"), () => {
+  });
+  if (!log) return 0;
+  const blobs = join9(home, "blobs");
+  const sizes = await blobSizes(blobs, namedHashes(log));
+  let bytes = 0;
+  for (const hash of uncopiedOnlyHashes(log, (known) => sizes.get(known) ?? 0)) {
+    const size = sizes.get(hash) ?? 0;
+    if (size === 0) continue;
+    bytes += size;
+    if (!dryRun) await rm4(blobPath(blobs, hash), { force: true });
+  }
+  return bytes;
+}
+async function reclaimUncopiedBlobs(historyRoot, { dryRun = false, onError } = {}) {
+  const reclaimed = [];
+  for (const id of historyIds(historyRoot)) {
+    const home = join9(historyRoot, id);
+    let release;
+    try {
+      release = await takeHistoryOwnership(home, 0);
+      const bytes = await reclaimOne(home, dryRun);
+      if (bytes > 0) reclaimed.push({ id, bytes });
+    } catch (error) {
+      if (!(error instanceof HistoryBusyError)) onError?.(error);
+    } finally {
+      release?.();
+    }
+  }
+  return reclaimed;
+}
+function historyCache(open) {
+  const histories = /* @__PURE__ */ new Map();
+  const get = async (projectDir) => {
+    let cached = histories.get(projectDir);
+    if (!cached) histories.set(projectDir, cached = open(projectDir));
+    const opened = await cached;
+    if (!opened?.replacedAtPath()) return opened;
+    const reopen = () => open(projectDir);
+    if (histories.get(projectDir) === cached)
+      histories.set(projectDir, opened.close().then(reopen, reopen));
+    return get(projectDir);
+  };
+  return {
+    get,
+    /** The history if one was opened, without opening it. */
+    peek: (projectDir) => histories.get(projectDir),
+    forget: (projectDir) => histories.delete(projectDir),
+    closeAll: () => Promise.all(
+      [...histories.values()].map((opened) => opened.then((history) => history?.close()))
+    )
+  };
+}
+
+export {
+  fileContentVersion,
+  DELETED_VERSION,
+  settledFileTag,
+  createWriteToken,
+  recordFileWriteReceipt,
+  clearFileWriteReceipt,
+  identifyFileWrite,
+  consumeFileWriteReceipt,
+  HistoryBusyError,
+  registerRenderOutput,
+  STUDIO_SIGNATURE_MANIFEST_PATHS,
+  affectsProjectSignature,
+  resolveProjectSignature,
+  resolveProjectAndSignature,
+  createProjectSignature,
+  HistoryIdError,
+  listProjectHistories,
+  pruneGoneProjectHistories,
+  retainSnapshotOutput,
+  beginArtifactCapture,
+  recordArtifact,
+  recordArtifacts,
+  forgetRecordedArtifacts,
+  artifactDirectory,
+  recordRenderSuccess,
+  finishSnapshotRun,
+  START,
+  DEFAULT_HISTORY_ROOT,
+  MAX_WINDOW_IDLE_MS,
+  UNDO_MODES,
+  HistoryClosedError,
+  HistoryRefusedError,
+  openProjectHistory,
+  readProjectHistory,
+  reclaimUncopiedBlobs,
+  historyCache
+};