@hyperframes/studio-server 0.8.82 → 0.8.84

package/dist/index.js

@@ -14,6 +14,39 @@ import {
   unwrapElementsFromHtml,
   wrapElementsInHtml
 } from "./chunk-W6TFBTP2.js";
+import {
+  isCompositionSource,
+  stampProjectHfIds
+} from "./chunk-WUHW3MWG.js";
+import {
+  DEFAULT_HISTORY_ROOT,
+  DELETED_VERSION,
+  HistoryBusyError,
+  HistoryClosedError,
+  HistoryIdError,
+  MAX_WINDOW_IDLE_MS,
+  START,
+  STUDIO_SIGNATURE_MANIFEST_PATHS,
+  UNDO_MODES,
+  affectsProjectSignature,
+  clearFileWriteReceipt,
+  consumeFileWriteReceipt,
+  createProjectSignature,
+  createWriteToken,
+  fileContentVersion,
+  historyCache,
+  identifyFileWrite,
+  listProjectHistories,
+  openProjectHistory,
+  pruneGoneProjectHistories,
+  recordFileWriteReceipt,
+  resolveProjectAndSignature,
+  resolveProjectSignature,
+  settledFileTag
+} from "./chunk-IG4DRZI2.js";
+import {
+  replaceFileAtomically
+} from "./chunk-PMXUKOC3.js";
 import {
   getElementScreenshotClip
 } from "./chunk-W2SBTCO2.js";
@@ -22,28 +55,37 @@ import {
   isAutoProxyEnabled,
   proxyEtagSalt,
   resolvePreviewMediaCodecProbeCache
-} from "./chunk-FTDTO3QP.js";
+} from "./chunk-YUPEBATT.js";
 import {
+  PROXY_PENDING_RETRY_AFTER_SECONDS,
   ProxyCapacityError,
   ProxyTranscodeError,
-  resolveProxy
-} from "./chunk-G6IIFKXY.js";
+  ProxyWaitTimeoutError,
+  proxyActivityMark,
+  resolveProxy,
+  waitForProxy
+} from "./chunk-2YEGCDJW.js";
 import {
   PROXY_VARIANT_CONFIG,
   decideMediaProxyEligibility,
-  isInHiddenOrVendorDir,
   isProxyVariantRequest,
-  isSafePath,
-  pinWithinProject,
   probeAssetCodec,
   probeMediaMetadata,
+  recordProxyRequest,
+  resolveProxyVariantRequest
+} from "./chunk-I3DRHG52.js";
+import {
+  folderGone,
+  isInHiddenOrVendorDir,
+  isProjectRootMissing,
+  isSafePath,
+  mkdirWithinProject,
+  pinWithinProject,
   realFilePath,
   realpath,
-  recordProxyRequest,
-  resolveProxyVariantRequest,
   resolveWithinProject,
   walkDir
-} from "./chunk-TJQ76IEA.js";
+} from "./chunk-TTWLTYSQ.js";
 import {
   STUDIO_MANUAL_EDITS_PATH,
   createStudioManualEditsRenderBodyScript,
@@ -59,308 +101,13 @@ import { Hono } from "hono";
 
 // src/routes/projects.ts
 import { readFile } from "fs/promises";
-import { join as join2 } from "path";
-
-// src/helpers/hfIdPersist.ts
-import { ensureHfIds } from "@hyperframes/parsers/hf-ids";
-import { createHash } from "crypto";
-import {
-  closeSync,
-  constants,
-  fstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  writeFileSync
-} from "fs";
-import { dirname, join } from "path";
-
-// src/helpers/atomicFile.ts
-import * as fs from "fs";
-import { randomUUID } from "crypto";
-function replaceFileAtomically(filePath, content, mode, operations = fs) {
-  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    operations.writeFileSync(tempPath, content, { encoding: "utf-8", mode });
-    operations.chmodSync(tempPath, mode);
-    operations.renameSync(tempPath, filePath);
-  } catch (error) {
-    try {
-      operations.unlinkSync(tempPath);
-    } catch {
-    }
-    throw error;
-  }
-}
-
-// src/helpers/hfIdPersist.ts
-var isCompositionSource = (html) => /data-composition-id\s*=/.test(html);
-var STAMP_RECORD = join(".hyperframes", "hf-ids-stamped.json");
-var contentHash = (text2) => createHash("sha1").update(text2).digest("base64url");
-function stampProjectHfIds(projectDir) {
-  const recordPath = join(projectDir, STAMP_RECORD);
-  let last = {};
-  try {
-    last = JSON.parse(readFileSync(recordPath, "utf-8"));
-  } catch {
-  }
-  const next = {};
-  for (const file of walkDir(projectDir)) {
-    if (!file.endsWith(".html") || isInHiddenOrVendorDir(file)) continue;
-    const absPath = join(projectDir, file);
-    let html;
-    try {
-      html = readFileSync(absPath, "utf-8");
-    } catch {
-      continue;
-    }
-    let hash = contentHash(html);
-    if (last[file] !== hash && isCompositionSource(html)) {
-      const stamped = stampFileHfIds(absPath);
-      if (stamped === null) continue;
-      hash = contentHash(stamped);
-    }
-    next[file] = hash;
-  }
-  try {
-    mkdirSync(dirname(recordPath), { recursive: true });
-    writeFileSync(recordPath, JSON.stringify(next));
-  } catch {
-  }
-}
-function openNoFollow(filePath, flags) {
-  const noFollow = constants.O_NOFOLLOW ?? 0;
-  try {
-    return openSync(filePath, flags | noFollow);
-  } catch {
-    return null;
-  }
-}
-function isUnchanged(filePath, expected) {
-  const fd = openNoFollow(filePath, constants.O_RDONLY);
-  if (fd === null) return false;
-  try {
-    return readFileSync(fd, "utf-8") === expected;
-  } finally {
-    closeSync(fd);
-  }
-}
-function stampFileHfIds(filePath) {
-  let fd = openNoFollow(filePath, constants.O_RDWR);
-  let writable = true;
-  if (fd === null) {
-    fd = openNoFollow(filePath, constants.O_RDONLY);
-    writable = false;
-  }
-  if (fd === null) return null;
-  try {
-    if (!fstatSync(fd).isFile()) return null;
-    const html = readFileSync(fd, "utf-8");
-    const normalized = ensureHfIds(html);
-    const idsBefore = (html.match(/\bdata-hf-id=/g) ?? []).length;
-    const idsAfter = (normalized.match(/\bdata-hf-id=/g) ?? []).length;
-    if (writable && idsAfter > idsBefore) {
-      const mode = fstatSync(fd).mode;
-      closeSync(fd);
-      fd = null;
-      if (isUnchanged(filePath, html)) replaceFileAtomically(filePath, normalized, mode);
-    }
-    return normalized;
-  } catch (err) {
-    console.warn("[hyperframes] stampFileHfIds: failed to stamp ids:", err);
-    return null;
-  } finally {
-    if (fd !== null) closeSync(fd);
-  }
-}
-
-// src/helpers/projectSignature.ts
-import { createHash as createHash2 } from "crypto";
-import { lstatSync, readFileSync as readFileSync2, readdirSync } from "fs";
-import { extname, isAbsolute, relative, resolve, sep } from "path";
-var SIGNATURE_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".cjs",
-  ".css",
-  ".html",
-  ".js",
-  ".json",
-  ".jsx",
-  ".mjs",
-  ".svg",
-  ".ts",
-  ".tsx"
-]);
-var SIGNATURE_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
-  ".cache",
-  ".git",
-  ".hyperframes",
-  ".next",
-  ".thumbnails",
-  ".transcode-cache",
-  ".vite",
-  ".waveform-cache",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules",
-  "outputs",
-  "renders"
-]);
-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 = relative(resolve(projectDir), resolve(changedPath));
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) {
-    return false;
-  }
-  const segments = relativePath.split(sep);
-  if (STUDIO_SIGNATURE_MANIFEST_PATHS.includes(segments.join("/"))) return true;
-  return !segments.some((segment) => SIGNATURE_EXCLUDED_DIRS.has(segment));
-}
-var projectSignatureCache = /* @__PURE__ */ new Map();
-function isPathWithin(parentDir, childPath) {
-  const childRelativePath = relative(parentDir, childPath);
-  return childRelativePath === "" || !childRelativePath.startsWith("..") && !isAbsolute(childRelativePath);
-}
-function isTextContentEligible(file, size) {
-  return SIGNATURE_TEXT_EXTENSIONS.has(extname(file).toLowerCase()) && size <= MAX_SIGNATURE_TEXT_BYTES;
-}
-function collectProjectSignatureFiles(projectDir, dir, files) {
-  let entries;
-  try {
-    entries = readdirSync(dir).sort();
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (SIGNATURE_EXCLUDED_DIRS.has(entry)) continue;
-    const file = resolve(dir, entry);
-    if (!isPathWithin(projectDir, file)) continue;
-    let stat3;
-    try {
-      stat3 = lstatSync(file);
-    } catch {
-      continue;
-    }
-    if (stat3.isSymbolicLink()) continue;
-    if (stat3.isDirectory()) {
-      collectProjectSignatureFiles(projectDir, file, files);
-    } else if (stat3.isFile()) {
-      files.push({
-        file,
-        mtimeMs: stat3.mtimeMs,
-        ctimeMs: stat3.ctimeMs,
-        size: stat3.size,
-        textContentEligible: isTextContentEligible(file, stat3.size)
-      });
-    }
-  }
-}
-function collectProjectSignatureManifestFiles(projectDir, files) {
-  const seen = new Set(files.map((entry) => entry.file));
-  for (const manifestPath of STUDIO_SIGNATURE_MANIFEST_PATHS) {
-    const file = resolve(projectDir, manifestPath);
-    if (seen.has(file) || !isPathWithin(projectDir, file)) continue;
-    let stat3;
-    try {
-      stat3 = lstatSync(file);
-    } catch {
-      continue;
-    }
-    if (stat3.isSymbolicLink() || !stat3.isFile()) continue;
-    files.push({
-      file,
-      mtimeMs: stat3.mtimeMs,
-      ctimeMs: stat3.ctimeMs,
-      size: stat3.size,
-      textContentEligible: isTextContentEligible(file, stat3.size)
-    });
-    seen.add(file);
-  }
-}
-function createProjectFingerprint(projectDir, files) {
-  const hash = createHash2("sha256");
-  for (const entry of files) {
-    hash.update(relative(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 = resolve(projectDir);
-  return collectProjectFiles(normalizedProjectDir).map((entry) => ({
-    path: relative(normalizedProjectDir, entry.file).split(sep).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 = resolve(projectDir);
-  const collected = collectProjectFiles(normalizedProjectDir);
-  const files = collected.filter(
-    (entry) => !excluding.has(relative(normalizedProjectDir, entry.file).split(sep).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 = relative(normalizedProjectDir, entry.file);
-    hash.update(relativePath);
-    hash.update("\0");
-    hash.update(String(entry.size));
-    hash.update("\0");
-    if (entry.textContentEligible) {
-      try {
-        hash.update(readFileSync2(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);
-  projectSignatureCache.set(cacheKey, { fingerprint, signature });
-  return signature;
-}
-
-// src/routes/projects.ts
+import { join } from "path";
 async function filterCompositionFiles(projectDir, files) {
   const htmlFiles = files.filter((f) => f.endsWith(".html") && !isInHiddenOrVendorDir(f));
   const checks = await Promise.all(
     htmlFiles.map(async (f) => {
       try {
-        const content = await readFile(join2(projectDir, f), "utf-8");
+        const content = await readFile(join(projectDir, f), "utf-8");
         return isCompositionSource(content);
       } catch {
         return false;
@@ -400,23 +147,22 @@ function registerProjectRoutes(api, adapter) {
 // src/routes/files.ts
 import { bodyLimit } from "hono/body-limit";
 import {
-  closeSync as closeSync2,
+  closeSync,
   existsSync as existsSync3,
-  lstatSync as lstatSync3,
-  openSync as openSync2,
-  readFileSync as readFileSync6,
+  lstatSync as lstatSync2,
+  openSync,
+  readFileSync as readFileSync4,
   readlinkSync,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync4,
   writeSync,
-  mkdirSync as mkdirSync4,
   unlinkSync as unlinkSync2,
   rmSync as rmSync3,
   statSync as statSync3,
-  fstatSync as fstatSync2,
+  fstatSync,
   renameSync as renameSync2,
-  readdirSync as readdirSync3
+  readdirSync as readdirSync2
 } from "fs";
-import { resolve as resolve3, dirname as dirname4, join as join6 } from "path";
+import { resolve as resolve2, dirname as dirname3, join as join5 } from "path";
 
 // src/helpers/mime.ts
 var MIME_TYPES = {
@@ -468,15 +214,15 @@ function isAudioFile(name) {
 import { spawn } from "child_process";
 import {
   existsSync,
-  writeFileSync as writeFileSync2,
-  mkdirSync as mkdirSync2,
-  lstatSync as lstatSync2,
+  writeFileSync,
+  mkdirSync,
+  lstatSync,
   mkdtempSync,
   renameSync,
   rmSync,
   statSync
 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname, join as join2 } from "path";
 import { findFfBinary } from "@hyperframes/parsers/ff-binaries";
 var SAMPLE_RATE = 4e3;
 var PEAK_COUNT = 4e3;
@@ -543,32 +289,32 @@ function decodeAudioPeaks(audioPath) {
   });
 }
 async function generateWaveformCache(projectDir, assetPath) {
-  const audioPath = join3(projectDir, assetPath);
+  const audioPath = join2(projectDir, assetPath);
   if (!existsSync(audioPath)) return;
   const stats = statSync(audioPath);
-  const cacheDir = join3(projectDir, ".waveform-cache");
-  const cachePath = join3(cacheDir, buildWaveformCacheKey(assetPath, stats));
+  const cacheDir = join2(projectDir, ".waveform-cache");
+  const cachePath = join2(cacheDir, buildWaveformCacheKey(assetPath, stats));
   if (isWaveformCacheDirectory(cacheDir) && existsSync(cachePath)) return;
   const peaks = await decodeAudioPeaks(audioPath);
   writeWaveformCache(cachePath, peaks);
 }
 function isWaveformCacheDirectory(cacheDir) {
-  return lstatSync2(cacheDir, { throwIfNoEntry: false })?.isDirectory() ?? false;
+  return lstatSync(cacheDir, { throwIfNoEntry: false })?.isDirectory() ?? false;
 }
 function writeWaveformCache(cachePath, peaks) {
-  const cacheDir = dirname2(cachePath);
+  const cacheDir = dirname(cachePath);
   try {
-    mkdirSync2(cacheDir, { mode: 448 });
+    mkdirSync(cacheDir, { mode: 448 });
   } catch (error) {
     if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
   }
   if (!isWaveformCacheDirectory(cacheDir)) {
     throw new Error("Waveform cache must be a directory, not a symlink");
   }
-  const stagingDir = mkdtempSync(join3(cacheDir, ".waveform-"));
+  const stagingDir = mkdtempSync(join2(cacheDir, ".waveform-"));
   try {
-    const stagingPath = join3(stagingDir, "peaks.json");
-    writeFileSync2(stagingPath, JSON.stringify(peaks), { flag: "wx" });
+    const stagingPath = join2(stagingDir, "peaks.json");
+    writeFileSync(stagingPath, JSON.stringify(peaks), { flag: "wx" });
     renameSync(stagingPath, cachePath);
   } finally {
     try {
@@ -580,12 +326,12 @@ function writeWaveformCache(cachePath, peaks) {
 
 // src/helpers/mediaValidation.ts
 import { spawnSync } from "child_process";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join4 } from "path";
+import { basename, join as join3 } from "path";
 import { FFPROBE_PATH_ENV, findFfBinary as findFfBinary2 } from "@hyperframes/parsers/ff-binaries";
 var VIDEO_EXT = /\.(mp4|webm|mov|mkv|avi|m4v|mxf|mts|m2ts|ts)$/i;
-var AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac)$/i;
+var AUDIO_EXT = /\.(mp3|wav|ogg|m4a|aac|flac)$/i;
 var defaultRunner = spawnSync;
 var FFPROBE_MISSING = "not checked: ffprobe was not found. Install FFmpeg or set HYPERFRAMES_FFPROBE_PATH.";
 function validateUploadedMedia(filePath, runner = defaultRunner) {
@@ -633,10 +379,10 @@ function checkStreams(stdout, isVideo, isAudio) {
   }
 }
 function validateUploadedMediaBuffer(fileName, buffer, runner = defaultRunner) {
-  const tempDir = mkdtempSync2(join4(tmpdir(), "hyperframes-upload-"));
-  const tempPath = join4(tempDir, basename(fileName));
+  const tempDir = mkdtempSync2(join3(tmpdir(), "hyperframes-upload-"));
+  const tempPath = join3(tempDir, basename(fileName));
   try {
-    writeFileSync3(tempPath, buffer);
+    writeFileSync2(tempPath, buffer);
     return validateUploadedMedia(tempPath, runner);
   } finally {
     rmSync2(tempDir, { recursive: true, force: true });
@@ -644,9 +390,9 @@ function validateUploadedMediaBuffer(fileName, buffer, runner = defaultRunner) {
 }
 
 // src/helpers/backupJournal.ts
-import { mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
+import { readdirSync, readFileSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { Buffer as Buffer2 } from "buffer";
-import { join as join5, relative as relative2 } from "path";
+import { join as join4, relative } from "path";
 var DEFAULT_KEEP_PER_FILE = 10;
 function backupKeyForPath(path) {
   return Buffer2.from(path, "utf-8").toString("base64url");
@@ -656,23 +402,24 @@ function timestampPrefix() {
 }
 function backupPathForResponse(projectDir, backupPath) {
   if (!backupPath) return null;
-  const rel = relative2(projectDir, backupPath);
+  const rel = relative(projectDir, backupPath);
   if (!rel || rel.startsWith("..")) return null;
   return rel.split("\\").join("/");
 }
 function snapshotBeforeWrite(projectDir, absPath, options = {}) {
   if (!isSafePath(projectDir, absPath)) return { backupPath: null };
   try {
-    const content = readFileSync3(absPath);
-    const relativePath = relative2(projectDir, absPath);
-    const backupDir = join5(projectDir, ".hyperframes", "backup");
-    mkdirSync3(backupDir, { recursive: true });
+    const content = readFileSync(absPath);
+    const relativePath = relative(projectDir, absPath);
+    const backupDir = join4(projectDir, ".hyperframes", "backup");
+    mkdirWithinProject(projectDir, backupDir);
     const backupKey = backupKeyForPath(relativePath);
     const backupPath = nextBackupPath(backupDir, backupKey);
-    writeFileSync4(backupPath, content);
+    writeFileSync3(backupPath, content);
     pruneBackups(backupDir, backupKey, options.keepPerFile ?? DEFAULT_KEEP_PER_FILE);
     return { backupPath };
   } catch (error) {
+    if (isProjectRootMissing(error)) throw error;
     if (error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) {
       return { backupPath: null };
     }
@@ -681,18 +428,18 @@ function snapshotBeforeWrite(projectDir, absPath, options = {}) {
 }
 function nextBackupPath(backupDir, backupKey) {
   const base = `${timestampPrefix()}-${backupKey}`;
-  let candidate = join5(backupDir, base);
+  let candidate = join4(backupDir, base);
   let counter = 2;
   while (true) {
     try {
-      readFileSync3(candidate);
+      readFileSync(candidate);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
         return candidate;
       }
       throw error;
     }
-    candidate = join5(backupDir, `${base}-${counter}`);
+    candidate = join4(backupDir, `${base}-${counter}`);
     counter += 1;
   }
 }
@@ -700,7 +447,7 @@ function pruneBackups(backupDir, backupKey, keepPerFile) {
   const keep = Math.max(1, Math.floor(keepPerFile));
   const suffix = `-${backupKey}`;
   const numberedSuffix = new RegExp(`-${backupKey}-\\d+$`);
-  const matches = readdirSync2(backupDir).filter((name) => name.endsWith(suffix) || numberedSuffix.test(name)).map((name) => join5(backupDir, name)).sort((a, b) => {
+  const matches = readdirSync(backupDir).filter((name) => name.endsWith(suffix) || numberedSuffix.test(name)).map((name) => join4(backupDir, name)).sort((a, b) => {
     return b.localeCompare(a);
   });
   for (const file of matches.slice(keep)) {
@@ -711,96 +458,37 @@ function pruneBackups(backupDir, backupKey, keepPerFile) {
   }
 }
 
-// src/helpers/fileVersion.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
-var RECEIPT_TTL_MS = 1e4;
-var receipts = /* @__PURE__ */ new Map();
-function fileContentVersion(content) {
-  return hashVersion(createHash3("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(stat3, now = Date.now()) {
-  if (now - stat3.ctimeMs < 3e3) return null;
-  return [stat3.ino, stat3.ctimeMs, stat3.size].map((n) => n.toString(36)).join("-");
-}
-function createWriteToken(requestToken) {
-  const token = requestToken?.trim();
-  return token && token.length <= 200 ? token : randomUUID2();
-}
-function recordFileWriteReceipt(filePath, receipt) {
-  const absPath = realFilePath(filePath);
-  const now = Date.now();
-  for (const [path, list] of receipts) {
-    const live = list.filter((entry) => now - entry.recordedAt < RECEIPT_TTL_MS);
-    if (live.length > 0) receipts.set(path, live);
-    else receipts.delete(path);
-  }
-  receipts.set(absPath, [...receipts.get(absPath) ?? [], { ...receipt, 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 } = receipt;
-  return { path, version, writeToken };
-}
-function bytesOverwrittenBy(filePath, version) {
-  return newestReceipt(realFilePath(filePath), version)?.overwrote;
-}
-function forgetOverwrittenBytes(filePath, versions) {
-  for (const receipt of receipts.get(realFilePath(filePath)) ?? [])
-    if (versions.has(receipt.version)) delete receipt.overwrote;
-}
-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;
+// src/helpers/projectDirMissing.ts
+var PROJECT_DIR_MISSING = { error: "not found", why: "project_dir_missing" };
+var projectDirMissing = (c) => c.json(PROJECT_DIR_MISSING, 404);
+function replaceWithProjectDirMissing(c, hostHeaders) {
+  hostHeaders.delete("content-type");
+  c.res = void 0;
+  c.res = Response.json(PROJECT_DIR_MISSING, { status: 404, headers: hostHeaders });
 }
-var consumeFileWriteReceipt = identifyFileWrite;
 
 // src/helpers/applyFileMutations.ts
-import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-function applyFileMutations(projectDir, mutations, requestToken, writeFile2 = (path, content) => replaceFileAtomically(path, content, statSync2(path).mode)) {
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+function applyFileMutations(projectDir, mutations, requestToken, writeFile = (path, content) => replaceFileAtomically(path, content, statSync2(path).mode)) {
   const prepared = mutations.map((mutation) => ({
     ...mutation,
-    before: mutation.before ?? readFileSync4(mutation.absPath, "utf-8")
+    before: mutation.before ?? readFileSync2(mutation.absPath, "utf-8")
   }));
   const results = [];
   const attempted = [];
   for (const mutation of prepared)
-    assertExpectedVersion(mutation, readFileSync4(mutation.absPath, "utf-8"));
+    assertExpectedVersion(mutation, readFileSync2(mutation.absPath, "utf-8"));
   try {
     for (const mutation of prepared) {
-      results.push(applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted));
+      results.push(applyOneMutation(projectDir, mutation, requestToken, writeFile, attempted));
     }
     return results;
   } catch (error) {
     const rollbackErrors = [];
     for (const mutation of attempted.reverse()) {
       try {
-        if (!mutation.written || readFileSync4(mutation.absPath, "utf-8") === mutation.after)
-          writeFile2(mutation.absPath, mutation.before, "utf-8");
+        if (!mutation.written || readFileSync2(mutation.absPath, "utf-8") === mutation.after)
+          writeFile(mutation.absPath, mutation.before, "utf-8");
         clearFileWriteReceipt(mutation.absPath, mutation.version, mutation.writeToken);
       } catch (rollbackError) {
         rollbackErrors.push(rollbackError);
@@ -815,8 +503,8 @@ function applyFileMutations(projectDir, mutations, requestToken, writeFile2 = (p
     throw error;
   }
 }
-function applyOneMutation(projectDir, mutation, requestToken, writeFile2, attempted) {
-  const current = readFileSync4(mutation.absPath, "utf-8");
+function applyOneMutation(projectDir, mutation, requestToken, writeFile, attempted) {
+  const current = readFileSync2(mutation.absPath, "utf-8");
   assertExpectedVersion(mutation, current);
   if (mutation.after === mutation.before) {
     return {
@@ -830,13 +518,13 @@ function applyOneMutation(projectDir, mutation, requestToken, writeFile2, attemp
   }
   const backup = snapshotBeforeWrite(projectDir, mutation.absPath);
   if (backup.error) throw new Error(`backup failed: ${backup.error}`);
-  assertExpectedVersion(mutation, readFileSync4(mutation.absPath, "utf-8"));
+  assertExpectedVersion(mutation, readFileSync2(mutation.absPath, "utf-8"));
   const before = current;
   const version = fileContentVersion(mutation.after);
   const writeToken = createWriteToken(requestToken);
   const attempt = { ...mutation, before, version, writeToken, written: false };
   attempted.push(attempt);
-  writeFile2(mutation.absPath, mutation.after, "utf-8");
+  writeFile(mutation.absPath, mutation.after, "utf-8");
   attempt.written = true;
   recordFileWriteReceipt(mutation.absPath, {
     path: mutation.sourceFile,
@@ -898,13 +586,14 @@ import {
   syncPositionHoldsBeforeKeyframes
 } from "@hyperframes/parsers/gsap-writer-acorn";
 import { parseHTML as parseHTML2 } from "linkedom";
-import { ensureHfIds as ensureHfIds2 } from "@hyperframes/parsers/hf-ids";
+import { ensureHfIds } from "@hyperframes/parsers/hf-ids";
 
 // src/helpers/compositionInsertion.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
-import { dirname as dirname3, relative as relative3, resolve as resolve2, sep as sep2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { randomUUID } from "crypto";
+import { dirname as dirname2, relative as relative2, resolve, sep } from "path";
 import { parseHTML } from "linkedom";
+import { ProjectRootMissingError } from "@hyperframes/core";
 var CompositionInsertionError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -934,6 +623,7 @@ function positiveAttribute(root, ...names) {
 }
 function canonicalProjectPath(projectDir, candidate) {
   if (!candidate) {
+    if (folderGone(projectDir)) throw new ProjectRootMissingError(projectDir);
     throw new CompositionInsertionError("Composition source escapes the project", 400);
   }
   if (!existsSync2(candidate)) {
@@ -958,7 +648,7 @@ function canonicalDependency(projectDir, ownerAbs, sourcePath) {
   validateSourcePath(sourcePath);
   return canonicalProjectPath(
     projectDir,
-    resolveWithinProject(projectDir, relative3(projectDir, resolve2(dirname3(ownerAbs), sourcePath)))
+    resolveWithinProject(projectDir, relative2(projectDir, resolve(dirname2(ownerAbs), sourcePath)))
   );
 }
 function validateDependencyGraph(projectDir, targetAbs, sourceAbs) {
@@ -973,7 +663,7 @@ function validateDependencyGraph(projectDir, targetAbs, sourceAbs) {
     }
     if (visited.has(file)) return;
     visiting.add(file);
-    const source = readFileSync5(file, "utf-8");
+    const source = readFileSync3(file, "utf-8");
     const { document } = compositionRoot(source);
     for (const host of descendants(document, "[data-composition-src]")) {
       const dependency = host.getAttribute("data-composition-src");
@@ -1031,13 +721,13 @@ function uniqueHostId(root, base) {
   return `${base}_${suffix}`;
 }
 function relativeSourcePath(targetAbs, sourceAbs) {
-  return relative3(dirname3(targetAbs), sourceAbs).split(sep2).join("/");
+  return relative2(dirname2(targetAbs), sourceAbs).split(sep).join("/");
 }
 function insertCompositionIntoSource(input) {
   const targetAbs = canonicalProjectFile(input.projectDir, input.targetPath);
   const sourceAbs = canonicalProjectFile(input.projectDir, input.sourcePath);
   validateDependencyGraph(input.projectDir, targetAbs, sourceAbs);
-  const source = readFileSync5(sourceAbs, "utf-8");
+  const source = readFileSync3(sourceAbs, "utf-8");
   const sourceComposition = compositionRoot(source).root;
   const duration = positiveAttribute(
     sourceComposition,
@@ -1066,7 +756,7 @@ function insertCompositionIntoSource(input) {
   const host = document.createElement("div");
   host.id = hostId;
   host.className = "clip";
-  host.setAttribute("data-hf-id", `hf-${randomUUID3()}`);
+  host.setAttribute("data-hf-id", `hf-${randomUUID()}`);
   host.setAttribute("data-composition-id", hostId);
   host.setAttribute("data-composition-src", relativeSourcePath(targetAbs, sourceAbs));
   host.setAttribute("data-start", String(Math.round(input.start * 100) / 100));
@@ -1163,15 +853,15 @@ async function loadGsapParser() {
   return import("@hyperframes/parsers/gsap-parser-recast");
 }
 function isDanglingSymlinkInProject(projectDir, lexicalPath) {
-  if (!isSafePath(projectDir, dirname4(lexicalPath))) return false;
+  if (!isSafePath(projectDir, dirname3(lexicalPath))) return false;
   let stats;
   try {
-    stats = lstatSync3(lexicalPath);
+    stats = lstatSync2(lexicalPath);
   } catch {
     return false;
   }
   if (!stats.isSymbolicLink()) return false;
-  const target = resolve3(dirname4(lexicalPath), readlinkSync(lexicalPath));
+  const target = resolve2(dirname3(lexicalPath), readlinkSync(lexicalPath));
   if (!isSafePath(projectDir, target)) return false;
   try {
     statSync3(lexicalPath);
@@ -1186,10 +876,8 @@ async function resolveProjectPath(c, adapter, route, opts) {
   if (!project) {
     return { error: c.json({ error: "not found" }, 404) };
   }
-  if (!existsSync3(project.dir)) {
-    return {
-      error: c.json({ error: "not found", why: "project_dir_missing" }, 404)
-    };
+  if (folderGone(project.dir)) {
+    return { error: projectDirMissing(c) };
   }
   const filePath = requestSubPath(c.req.url, `projects/:id/${route}`);
   if (filePath.includes("\0")) {
@@ -1197,7 +885,7 @@ async function resolveProjectPath(c, adapter, route, opts) {
   }
   const absPath = (opts?.pin ? pinWithinProject : resolveWithinProject)(project.dir, filePath);
   if (!absPath) {
-    if (isDanglingSymlinkInProject(project.dir, resolve3(project.dir, filePath))) {
+    if (isDanglingSymlinkInProject(project.dir, resolve2(project.dir, filePath))) {
       return { error: c.json({ error: "not found", why: "dangling_symlink" }, 404) };
     }
     return { error: c.json({ error: "forbidden", why: "outside_project" }, 403) };
@@ -1261,10 +949,10 @@ function foldElementPatches(originalContent, patches) {
   return { content, matched };
 }
 var PATCH_CONFLICT_ATTEMPTS = 3;
-function commitElementPatchBatches(projectDir, batches, writeFile2 = (path, content) => replaceFileAtomically(path, content, statSync3(path).mode), requestToken) {
+function commitElementPatchBatches(projectDir, batches, writeFile = (path, content) => replaceFileAtomically(path, content, statSync3(path).mode), requestToken) {
   for (let attempt = 1; ; attempt += 1) {
     try {
-      return foldAndCommitElementPatchBatches(projectDir, batches, writeFile2, requestToken);
+      return foldAndCommitElementPatchBatches(projectDir, batches, writeFile, requestToken);
     } catch (error) {
       if (!(error instanceof FileChangedError)) throw error;
       if (attempt === PATCH_CONFLICT_ATTEMPTS)
@@ -1272,7 +960,7 @@ function commitElementPatchBatches(projectDir, batches, writeFile2 = (path, cont
     }
   }
 }
-function foldAndCommitElementPatchBatches(projectDir, batches, writeFile2, requestToken) {
+function foldAndCommitElementPatchBatches(projectDir, batches, writeFile, requestToken) {
   const resolvedPaths = /* @__PURE__ */ new Set();
   const prepared = [];
   for (const batch of batches) {
@@ -1282,7 +970,7 @@ function foldAndCommitElementPatchBatches(projectDir, batches, writeFile2, reque
     resolvedPaths.add(absPath);
     let before;
     try {
-      before = readFileSync6(absPath, "utf-8");
+      before = readFileSync4(absPath, "utf-8");
     } catch {
       return { error: "not-found", sourceFile: batch.sourceFile };
     }
@@ -1317,7 +1005,7 @@ function foldAndCommitElementPatchBatches(projectDir, batches, writeFile2, reque
       after
     })),
     requestToken,
-    writeFile2
+    writeFile
   );
   const files = applied.map((file, index) => ({
     sourceFile: file.sourceFile,
@@ -1338,7 +1026,7 @@ function commitElementPatchBatchesWithReceipts(c, projectDir, batches) {
   );
 }
 function writeFileWithReceipt(c, filePath, absPath, html) {
-  const overwrote = readFileSync6(absPath);
+  const overwrote = readFileSync4(absPath);
   replaceFileAtomically(absPath, html, statSync3(absPath).mode);
   const version = fileContentVersion(html);
   const writeToken = createWriteToken(c.req.header("X-Hyperframes-Write-Token"));
@@ -1348,7 +1036,7 @@ function writeFileWithReceipt(c, filePath, absPath, html) {
 function writeMutationResult(c, projectDir, filePath, absPath, html, original) {
   const backup = snapshotBeforeWrite(projectDir, absPath);
   if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-  if (readFileSync6(absPath, "utf-8") !== original) {
+  if (readFileSync4(absPath, "utf-8") !== original) {
     return c.json({ error: "file changed", conflict: true, path: filePath }, 409);
   }
   const { version } = writeFileWithReceipt(c, filePath, absPath, html);
@@ -1393,9 +1081,8 @@ async function parseMutationBody(c) {
   }
   return { target: body.target, body };
 }
-function ensureDir(filePath) {
-  const dir = dirname4(filePath);
-  if (!existsSync3(dir)) mkdirSync4(dir, { recursive: true });
+function ensureDir(projectDir, filePath) {
+  mkdirWithinProject(projectDir, dirname3(filePath));
 }
 function generateCopyPath(projectDir, originalPath) {
   const ext = originalPath.includes(".") ? "." + originalPath.split(".").pop() : "";
@@ -1404,7 +1091,7 @@ function generateCopyPath(projectDir, originalPath) {
   const cleanBase = copyMatch ? base.slice(0, -copyMatch[0].length) : base;
   let num = copyMatch ? copyMatch[1] ? parseInt(copyMatch[1]) + 1 : 2 : 1;
   let candidate = num === 1 ? `${cleanBase} (copy)${ext}` : `${cleanBase} (copy ${num})${ext}`;
-  while (existsSync3(resolve3(projectDir, candidate))) {
+  while (existsSync3(resolve2(projectDir, candidate))) {
     num++;
     candidate = `${cleanBase} (copy ${num})${ext}`;
   }
@@ -1412,8 +1099,8 @@ function generateCopyPath(projectDir, originalPath) {
 }
 function walkFiles(dir, filter) {
   const results = [];
-  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
-    const full = join6(dir, entry.name);
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const full = join5(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === ".thumbnails" || entry.name === "renders" || entry.name === ".transcode-cache")
         continue;
@@ -1432,7 +1119,7 @@ function updateReferences(projectDir, oldPath, newPath) {
   let updatedCount = 0;
   for (const file of textFiles) {
     if (!isSafePath(projectDir, file)) continue;
-    const content = readFileSync6(file, "utf-8");
+    const content = readFileSync4(file, "utf-8");
     if (!content.includes(oldPath)) continue;
     const updated = content.split(oldPath).join(newPath);
     if (updated !== content) {
@@ -1443,7 +1130,7 @@ function updateReferences(projectDir, oldPath, newPath) {
   return updatedCount;
 }
 function extractGsapScriptBlock(html) {
-  const { document } = parseHTML2(ensureHfIds2(html));
+  const { document } = parseHTML2(ensureHfIds(html));
   const scripts = [
     ...document.querySelectorAll("script:not([src])"),
     ...Array.from(document.querySelectorAll("template")).flatMap(
@@ -1706,7 +1393,7 @@ function containsRawGsapExpression(value) {
   return Object.values(value).some(containsRawGsapExpression);
 }
 async function prepareGsapMutationScript(c, res, firstMutation) {
-  const beforeHtml = readFileSync6(res.absPath, "utf-8");
+  const beforeHtml = readFileSync4(res.absPath, "utf-8");
   let html = beforeHtml;
   let block = extractGsapScriptBlock(html);
   if (!block && (firstMutation.type === "add" || firstMutation.type === "add-with-keyframes")) {
@@ -1773,7 +1460,7 @@ async function applyGsapMutations(c, res, mutations) {
   const changed = block.scriptText !== initialScript;
   const newHtml = changed ? block.replaceScript(block.scriptText) : html;
   let backupPath = null;
-  if (readFileSync6(res.absPath, "utf-8") !== beforeHtml) {
+  if (readFileSync4(res.absPath, "utf-8") !== beforeHtml) {
     return c.json({ error: "file changed during GSAP mutation", conflict: true }, 409);
   }
   if (changed) {
@@ -2527,7 +2214,7 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
       skipped.push(name);
       continue;
     }
-    const destPath = resolve3(targetDir, name);
+    const destPath = resolve2(targetDir, name);
     if (!isSafePath(projectDir, destPath)) continue;
     let finalPath = destPath;
     let finalName = name;
@@ -2538,13 +2225,13 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
     let n = 1;
     if (existsSync3(finalPath)) {
       n = 2;
-      while (n < MAX_COPY_INDEX && existsSync3(resolve3(targetDir, `${base} (${n})${ext}`))) n++;
+      while (n < MAX_COPY_INDEX && existsSync3(resolve2(targetDir, `${base} (${n})${ext}`))) n++;
       if (n >= MAX_COPY_INDEX) {
         skipped.push(name);
         continue;
       }
       finalName = `${base} (${n})${ext}`;
-      finalPath = resolve3(targetDir, finalName);
+      finalPath = resolve2(targetDir, finalName);
     }
     if (!isSafePath(projectDir, finalPath)) continue;
     const buffer = Buffer.from(await value.arrayBuffer());
@@ -2556,11 +2243,11 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
     let written = false;
     while (n < MAX_COPY_INDEX && isSafePath(projectDir, finalPath)) {
       try {
-        const fd = openSync2(finalPath, "wx");
+        const fd = openSync(finalPath, "wx");
         try {
-          writeFileSync5(fd, buffer);
+          writeFileSync4(fd, buffer);
         } finally {
-          closeSync2(fd);
+          closeSync(fd);
         }
         written = true;
         break;
@@ -2570,14 +2257,14 @@ async function processUploadedFiles(formData, targetDir, projectDir) {
         }
         n++;
         finalName = `${base} (${n})${ext}`;
-        finalPath = resolve3(targetDir, finalName);
+        finalPath = resolve2(targetDir, finalName);
       }
     }
     if (!written) {
       if (n >= MAX_COPY_INDEX) skipped.push(name);
       continue;
     }
-    const relativePath = subDir ? join6(subDir, finalName) : finalName;
+    const relativePath = subDir ? join5(subDir, finalName) : finalName;
     uploaded.push(relativePath);
     if (validation.unchecked) unchecked.push({ name: finalName, reason: validation.unchecked });
     if (isAudioFile(finalName)) {
@@ -2593,7 +2280,7 @@ function registerFileRoutes(api, adapter) {
     if ("error" in res) return res.error;
     let fd;
     try {
-      fd = openSync2(res.absPath, "r");
+      fd = openSync(res.absPath, "r");
     } catch {
       if (c.req.query("optional") === "1") {
         return c.json({ filename: res.filePath, content: "", missing: true });
@@ -2601,10 +2288,10 @@ function registerFileRoutes(api, adapter) {
       return c.json({ error: "not found" }, 404);
     }
     try {
-      if (!fstatSync2(fd).isFile()) {
+      if (!fstatSync(fd).isFile()) {
         return c.json({ error: "not found", why: "not_a_file" }, 404);
       }
-      const content = readFileSync6(fd);
+      const content = readFileSync4(fd);
       const version = fileContentVersion(content);
       c.header("ETag", version);
       return c.json({
@@ -2614,7 +2301,7 @@ function registerFileRoutes(api, adapter) {
         missing: false
       });
     } finally {
-      closeSync2(fd);
+      closeSync(fd);
     }
   });
   api.put("/projects/:id/files/*", async (c) => {
@@ -2626,7 +2313,7 @@ function registerFileRoutes(api, adapter) {
     if (expectedVersion === null && !createOnly) {
       let currentContent = null;
       try {
-        currentContent = readFileSync6(res.absPath);
+        currentContent = readFileSync4(res.absPath);
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
           throw error;
@@ -2645,15 +2332,15 @@ function registerFileRoutes(api, adapter) {
     let backup = { backupPath: null };
     let overwrote;
     if (createOnly) {
-      ensureDir(res.absPath);
+      ensureDir(res.project.dir, res.absPath);
       let fd;
       try {
-        fd = openSync2(res.absPath, "wx");
+        fd = openSync(res.absPath, "wx");
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
           throw error;
         }
-        const currentContent = readFileSync6(res.absPath);
+        const currentContent = readFileSync4(res.absPath);
         return c.json(
           {
             error: "file conflict",
@@ -2667,12 +2354,12 @@ function registerFileRoutes(api, adapter) {
       try {
         writeSync(fd, body, 0, body.length, 0);
       } finally {
-        closeSync2(fd);
+        closeSync(fd);
       }
     } else {
       let fd;
       try {
-        fd = openSync2(res.absPath, "r+");
+        fd = openSync(res.absPath, "r+");
       } catch (error) {
         if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
           throw error;
@@ -2688,7 +2375,7 @@ function registerFileRoutes(api, adapter) {
         );
       }
       try {
-        const currentContent = readFileSync6(fd);
+        const currentContent = readFileSync4(fd);
         overwrote = currentContent;
         const currentVersion = fileContentVersion(currentContent);
         if (expectedVersion !== currentVersion) {
@@ -2704,12 +2391,12 @@ function registerFileRoutes(api, adapter) {
         }
         backup = snapshotBeforeWrite(res.project.dir, res.absPath);
         if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-        const mode = fstatSync2(fd).mode;
-        closeSync2(fd);
+        const mode = fstatSync(fd).mode;
+        closeSync(fd);
         fd = null;
         replaceFileAtomically(res.absPath, body, mode);
       } finally {
-        if (fd !== null) closeSync2(fd);
+        if (fd !== null) closeSync(fd);
       }
     }
     const version = fileContentVersion(body);
@@ -2727,10 +2414,10 @@ function registerFileRoutes(api, adapter) {
   api.post("/projects/:id/files/*", async (c) => {
     const res = await resolveProjectFile(c, adapter);
     if ("error" in res) return res.error;
-    ensureDir(res.absPath);
+    ensureDir(res.project.dir, res.absPath);
     const body = Buffer.from(await c.req.arrayBuffer());
     try {
-      writeFileSync5(res.absPath, body, { flag: "wx" });
+      writeFileSync4(res.absPath, body, { flag: "wx" });
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
         throw error;
@@ -2742,10 +2429,10 @@ function registerFileRoutes(api, adapter) {
   api.delete("/projects/:id/files/*", async (c) => {
     const res = await resolveProjectFile(c, adapter, { mustExist: true });
     if ("error" in res) return res.error;
-    const stat3 = statSync3(res.absPath);
+    const stat2 = statSync3(res.absPath);
     const backup = snapshotBeforeWrite(res.project.dir, res.absPath);
     if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-    if (stat3.isDirectory()) {
+    if (stat2.isDirectory()) {
       rmSync3(res.absPath, { recursive: true });
     } else {
       unlinkSync2(res.absPath);
@@ -2764,7 +2451,7 @@ function registerFileRoutes(api, adapter) {
     }
     let before;
     try {
-      before = readFileSync6(ctx.absPath, "utf-8");
+      before = readFileSync4(ctx.absPath, "utf-8");
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
         throw error;
@@ -2793,7 +2480,7 @@ function registerFileRoutes(api, adapter) {
     }
     const backup = snapshotBeforeWrite(ctx.project.dir, ctx.absPath);
     if (backup.error) return c.json({ error: `backup failed: ${backup.error}` }, 500);
-    const current = readFileSync6(ctx.absPath, "utf-8");
+    const current = readFileSync4(ctx.absPath, "utf-8");
     if (current !== before) {
       const currentVersion2 = fileContentVersion(current);
       return c.json({ error: "file conflict", currentVersion: currentVersion2, currentContent: current }, 409);
@@ -2826,7 +2513,7 @@ function registerFileRoutes(api, adapter) {
     }
     const parsed = await parseMutationBody(c);
     if ("error" in parsed) return parsed.error;
-    const originalContent = readFileSync6(ctx.absPath, "utf-8");
+    const originalContent = readFileSync4(ctx.absPath, "utf-8");
     return writeIfChanged(
       c,
       ctx.project.dir,
@@ -2847,7 +2534,7 @@ function registerFileRoutes(api, adapter) {
     if (!Array.isArray(targets) || targets.length === 0) {
       return c.json({ error: "targets required" }, 400);
     }
-    const originalContent = readFileSync6(ctx.absPath, "utf-8");
+    const originalContent = readFileSync4(ctx.absPath, "utf-8");
     let next = originalContent;
     for (const target of targets) {
       next = removeElementFromHtml(next, target);
@@ -2880,7 +2567,7 @@ function registerFileRoutes(api, adapter) {
         seen.add(absPath);
         let before;
         try {
-          before = readFileSync6(absPath, "utf-8");
+          before = readFileSync4(absPath, "utf-8");
         } catch {
           return c.json({ error: `not found: ${file.path}` }, 404);
         }
@@ -2907,7 +2594,7 @@ function registerFileRoutes(api, adapter) {
         prepared.push(folded);
       }
       for (const file of prepared) {
-        const current = readFileSync6(file.absPath, "utf-8");
+        const current = readFileSync4(file.absPath, "utf-8");
         if (current !== file.before) {
           return c.json(
             {
@@ -2950,7 +2637,7 @@ function registerFileRoutes(api, adapter) {
         const conflicts = [];
         for (const file of written.reverse()) {
           try {
-            const current = readFileSync6(file.absPath, "utf-8");
+            const current = readFileSync4(file.absPath, "utf-8");
             if (current !== file.after) {
               conflicts.push(file.path);
               continue;
@@ -2998,7 +2685,7 @@ function registerFileRoutes(api, adapter) {
     const fallbackTiming = typeof parsed.body.elementStart === "number" && typeof parsed.body.elementDuration === "number" ? { start: parsed.body.elementStart, duration: parsed.body.elementDuration } : void 0;
     let originalContent;
     try {
-      originalContent = readFileSync6(ctx.absPath, "utf-8");
+      originalContent = readFileSync4(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -3056,7 +2743,7 @@ function registerFileRoutes(api, adapter) {
     for (let attempt = 1; ; attempt += 1) {
       let originalContent;
       try {
-        originalContent = readFileSync6(ctx.absPath, "utf-8");
+        originalContent = readFileSync4(ctx.absPath, "utf-8");
       } catch {
         return c.json({ error: "not found" }, 404);
       }
@@ -3162,7 +2849,7 @@ function registerFileRoutes(api, adapter) {
     }
     let originalContent;
     try {
-      originalContent = readFileSync6(ctx.absPath, "utf-8");
+      originalContent = readFileSync4(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -3218,7 +2905,7 @@ function registerFileRoutes(api, adapter) {
     ).map((entry) => ({ target: entry.target, track: entry.track }));
     let originalContent;
     try {
-      originalContent = readFileSync6(ctx.absPath, "utf-8");
+      originalContent = readFileSync4(ctx.absPath, "utf-8");
     } catch {
       return c.json({ error: "not found" }, 404);
     }
@@ -3247,7 +2934,7 @@ function registerFileRoutes(api, adapter) {
     if ("error" in parsed) return parsed.error;
     let content;
     try {
-      content = readFileSync6(ctx.absPath, "utf-8");
+      content = readFileSync4(ctx.absPath, "utf-8");
     } catch {
       return c.json({ exists: false });
     }
@@ -3268,7 +2955,7 @@ function registerFileRoutes(api, adapter) {
     if (existsSync3(newAbs)) {
       return c.json({ error: "already exists" }, 409);
     }
-    ensureDir(newAbs);
+    ensureDir(res.project.dir, newAbs);
     renameSync2(res.absPath, newAbs);
     const updatedFiles = updateReferences(res.project.dir, res.filePath, body.newPath);
     return c.json({ ok: true, path: body.newPath, updatedReferences: updatedFiles });
@@ -3289,9 +2976,9 @@ function registerFileRoutes(api, adapter) {
     if (!destAbs) {
       return c.json({ error: "forbidden" }, 403);
     }
-    ensureDir(destAbs);
+    ensureDir(project.dir, destAbs);
     try {
-      writeFileSync5(destAbs, readFileSync6(srcAbs), { flag: "wx" });
+      writeFileSync4(destAbs, readFileSync4(srcAbs), { flag: "wx" });
     } catch (error) {
       if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
         throw error;
@@ -3310,12 +2997,14 @@ function registerFileRoutes(api, adapter) {
     async (c) => {
       const project = await adapter.resolveProject(c.req.param("id"));
       if (!project) return c.json({ error: "not found" }, 404);
+      if (folderGone(project.dir)) return projectDirMissing(c);
       const subDir = c.req.query("dir") ?? "";
       const targetDir = subDir ? resolveWithinProject(project.dir, subDir) : project.dir;
       if (!targetDir) return c.json({ error: "forbidden" }, 403);
-      if (subDir && !existsSync3(targetDir)) mkdirSync4(targetDir, { recursive: true });
       const formData = await c.req.formData();
+      mkdirWithinProject(project.dir, targetDir);
       const result = await processUploadedFiles(formData, targetDir, project.dir);
+      if (folderGone(project.dir)) return projectDirMissing(c);
       return c.json(
         {
           ok: true,
@@ -3333,7 +3022,7 @@ function registerFileRoutes(api, adapter) {
       mustExist: true
     });
     if ("error" in res) return res.error;
-    const html = readFileSync6(res.absPath, "utf-8");
+    const html = readFileSync4(res.absPath, "utf-8");
     const block = extractGsapScriptBlock(html);
     if (!block) {
       return c.json({
@@ -3389,7 +3078,7 @@ function registerFileRoutes(api, adapter) {
     if (!body || typeof body.expected !== "string" || typeof body.restore !== "string") {
       return c.json({ error: "expected and restore contents required" }, 400);
     }
-    const current = readFileSync6(res.absPath, "utf-8");
+    const current = readFileSync4(res.absPath, "utf-8");
     if (current !== body.expected) {
       return c.json({ ok: true, restored: false, conflict: true });
     }
@@ -3399,10 +3088,10 @@ function registerFileRoutes(api, adapter) {
 }
 
 // src/routes/preview.ts
-import { createReadStream, existsSync as existsSync5, readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { createReadStream, existsSync as existsSync5, readFileSync as readFileSync6, statSync as statSync4 } from "fs";
 import { Readable } from "stream";
-import { join as join9, resolve as resolve5 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { join as join8, resolve as resolve4 } from "path";
+import { createHash } from "crypto";
 import {
   addScenePartsManifest,
   injectScriptsIntoHtml,
@@ -3414,8 +3103,8 @@ import { injectTagsAtHeadStart } from "@hyperframes/core/compiler/html-document"
 import { isWithinProjectRoot } from "@hyperframes/parsers/asset-resolution";
 
 // src/helpers/subComposition.ts
-import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join6 } from "path";
 import { parseHTML as parseHTML3 } from "linkedom";
 import {
   rewriteAssetPaths,
@@ -3425,7 +3114,7 @@ import {
 import { stripEmbeddedRuntimeScripts } from "@hyperframes/core/compiler";
 import { isFullHtmlDocument } from "@hyperframes/core/compiler/html-document";
 function rewriteRelativePaths(root, compPath, projectDir) {
-  const assetExists = (path) => existsSync4(join7(projectDir, path));
+  const assetExists = (path) => existsSync4(join6(projectDir, path));
   rewriteAssetPaths(
     root.querySelectorAll("[src], [href]"),
     compPath,
@@ -3522,9 +3211,9 @@ function tagRootCompositionFile(bodyHtml, compPath) {
   return bodyHtml.slice(0, tagEnd) + ` data-composition-file="${compPath}"` + bodyHtml.slice(tagEnd);
 }
 function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, rawOverride) {
-  const compFile = join7(projectDir, compPath);
+  const compFile = join6(projectDir, compPath);
   if (!existsSync4(compFile)) return null;
-  const rawComp = rawOverride ?? readFileSync7(compFile, "utf-8");
+  const rawComp = rawOverride ?? readFileSync5(compFile, "utf-8");
   let compHeadContent = "";
   let rewrittenContent;
   let htmlAttrs = "";
@@ -3554,10 +3243,10 @@ function buildSubCompositionHtml(projectDir, compPath, runtimeUrl, baseHref, raw
   }
   rewrittenContent = stripEmbeddedRuntimeScripts(rewrittenContent);
   rewrittenContent = tagRootCompositionFile(rewrittenContent, compPath);
-  const indexPath = join7(projectDir, "index.html");
+  const indexPath = join6(projectDir, "index.html");
   let headContent = "";
   if (existsSync4(indexPath)) {
-    const indexHtml = readFileSync7(indexPath, "utf-8");
+    const indexHtml = readFileSync5(indexPath, "utf-8");
     const headMatch = indexHtml.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
     headContent = headMatch?.[1] ?? "";
   }
@@ -3594,18 +3283,18 @@ function hasBaseElement(html) {
 }
 
 // src/routes/preview.ts
-import { ensureHfIds as ensureHfIds3 } from "@hyperframes/parsers/hf-ids";
+import { ensureHfIds as ensureHfIds2 } from "@hyperframes/parsers/hf-ids";
 
 // src/helpers/previewReads.ts
 import { readlinkSync as readlinkSync2 } from "fs";
-import { dirname as dirname5, join as join8, parse, relative as relative4, resolve as resolve4 } from "path";
+import { dirname as dirname4, join as join7, parse, relative as relative3, resolve as resolve3 } from "path";
 var ALWAYS_AFFECTS = ["hyperframes.json", ...STUDIO_SIGNATURE_MANIFEST_PATHS];
 var REFERENCE = /\b(?:src|href|poster|data-composition-src)\s*=\s*(?:"([^"\n]*)"|'([^'\n]*)')|url\(\s*(?:"([^"\n]*)"|'([^'\n]*)'|([^"'\s)]+))/gi;
-var pathKey = process.platform === "darwin" || process.platform === "win32" ? (path) => resolve4(path).toLowerCase() : (path) => resolve4(path);
+var pathKey = process.platform === "darwin" || process.platform === "win32" ? (path) => resolve3(path).toLowerCase() : (path) => resolve3(path);
 var readsByProject = /* @__PURE__ */ new Map();
 var builtProjects = /* @__PURE__ */ new Set();
-var projectKey = (projectDir) => pathKey(realFilePath(resolve4(projectDir)));
-var inRealProject = (projectDir, path) => join8(realFilePath(resolve4(projectDir)), relative4(resolve4(projectDir), resolve4(projectDir, path)));
+var projectKey = (projectDir) => pathKey(realFilePath(resolve3(projectDir)));
+var inRealProject = (projectDir, path) => join7(realFilePath(resolve3(projectDir)), relative3(resolve3(projectDir), resolve3(projectDir, path)));
 var readLink = (path) => {
   try {
     return readlinkSync2(path);
@@ -3621,10 +3310,10 @@ function linksOnTheWay(path) {
     const part = rest.shift();
     if (!part || part === ".") continue;
     if (part === "..") {
-      at = dirname5(at);
+      at = dirname4(at);
       continue;
     }
-    const next = join8(at, part);
+    const next = join7(at, part);
     const target = hops < 40 ? readLink(next) : null;
     if (target === null) {
       at = next;
@@ -3645,7 +3334,7 @@ function recordPreviewRead(projectDir, filePath) {
   if (!reads) readsByProject.set(key, reads = /* @__PURE__ */ new Set());
   const read = inRealProject(projectDir, filePath);
   for (const found of [read, ...linksOnTheWay(read)]) {
-    for (let path = pathKey(found); !reads.has(path); path = dirname5(path)) reads.add(path);
+    for (let path = pathKey(found); !reads.has(path); path = dirname4(path)) reads.add(path);
   }
 }
 function recordPreviewReferences(projectDir, html) {
@@ -3742,10 +3431,10 @@ function injectProjectSignature(html, signature) {
 ${html}`;
 }
 function readStudioMotionManifestContent(projectDir) {
-  const manifestPath = join9(projectDir, STUDIO_MOTION_PATH);
+  const manifestPath = join8(projectDir, STUDIO_MOTION_PATH);
   if (!existsSync5(manifestPath)) return "";
   try {
-    return readFileSync8(manifestPath, "utf-8");
+    return readFileSync6(manifestPath, "utf-8");
   } catch {
     return "";
   }
@@ -3856,7 +3545,7 @@ function parsePreviewVariablesParam(raw) {
 }
 function variablesEtagSalt(raw) {
   if (!raw) return "";
-  return `:vars:${createHash4("sha1").update(raw).digest("hex").slice(0, 12)}`;
+  return `:vars:${createHash("sha1").update(raw).digest("hex").slice(0, 12)}`;
 }
 function previewVariablesFromRequest(rawVariables) {
   const parse2 = parsePreviewVariablesParam(rawVariables);
@@ -3890,19 +3579,19 @@ async function transformPreviewHtml(html, adapter, project, activeCompositionPat
   }
 }
 function resolveProjectMainHtml(projectDir, projectId) {
-  const indexPath = join9(projectDir, "index.html");
-  const blockHtmlPath = join9(projectDir, `${projectId}.html`);
+  const indexPath = join8(projectDir, "index.html");
+  const blockHtmlPath = join8(projectDir, `${projectId}.html`);
   recordPreviewRead(projectDir, indexPath);
   recordPreviewRead(projectDir, blockHtmlPath);
   if (existsSync5(indexPath)) {
     return {
-      html: readFileSync8(indexPath, "utf-8"),
+      html: readFileSync6(indexPath, "utf-8"),
       compositionPath: "index.html"
     };
   }
   if (existsSync5(blockHtmlPath)) {
     return {
-      html: readFileSync8(blockHtmlPath, "utf-8"),
+      html: readFileSync6(blockHtmlPath, "utf-8"),
       compositionPath: `${projectId}.html`
     };
   }
@@ -3929,7 +3618,7 @@ function registerPreviewRoutes(api, adapter) {
   const previewBuilds = /* @__PURE__ */ new Map();
   async function buildPreview(project, previewVariables, builtKey, capture) {
     const diskMain = resolveProjectMainHtml(project.dir, project.id);
-    const normalizedDisk = diskMain ? ensureHfIds3(diskMain.html) : null;
+    const normalizedDisk = diskMain ? ensureHfIds2(diskMain.html) : null;
     try {
       let bundled = await adapter.bundle(project.dir, {
         stampHfIds: true,
@@ -3954,7 +3643,7 @@ ${runtimeTag}`;
         bundled = bundled.replace(/<head>/i, `<head><base href="${baseHref}">`);
       }
       bundled = injectStudioPreviewAugmentations(
-        ensureHfIds3(await transformPreviewHtml(bundled, adapter, project, mainCompositionPath)),
+        ensureHfIds2(await transformPreviewHtml(bundled, adapter, project, mainCompositionPath)),
         adapter,
         project.dir,
         mainCompositionPath,
@@ -3975,7 +3664,7 @@ ${runtimeTag}`;
     } catch {
       const fallback = resolveProjectMainHtml(project.dir, project.id);
       if (fallback) {
-        const fallbackHtml = ensureHfIds3(fallback.html);
+        const fallbackHtml = ensureHfIds2(fallback.html);
         let fallbackAugmented = injectStudioPreviewAugmentations(
           await transformPreviewHtml(fallbackHtml, adapter, project, fallback.compositionPath),
           adapter,
@@ -4035,7 +3724,7 @@ ${etag}`;
   function pinSubCompHfIds(compFile, compPath) {
     if (!/\.html?$/i.test(compPath)) return void 0;
     try {
-      return ensureHfIds3(readFileSync8(compFile, "utf-8"));
+      return ensureHfIds2(readFileSync6(compFile, "utf-8"));
     } catch {
       return null;
     }
@@ -4054,7 +3743,7 @@ ${etag}`;
     if (!compFile || !existsSync5(compFile) || !statSync4(compFile).isFile()) {
       return c.text("not found", 404);
     }
-    const compPathHash = createHash4("sha1").update(compPath).digest("hex");
+    const compPathHash = createHash("sha1").update(compPath).digest("hex");
     const capture = c.req.query(PREVIEW_CAPTURE_PARAM) !== void 0;
     const etag = `"comp:v2:${compPathHash}:${signature}${variablesEtagSalt(vars.raw)}${capture ? ":capture" : ""}"`;
     const ifNoneMatch = c.req.header("If-None-Match");
@@ -4076,7 +3765,7 @@ ${etag}`;
     );
     if (!html) return c.text("not found", 404);
     recordPreviewReferences(project.dir, html);
-    html = ensureHfIds3(await transformPreviewHtml(html, adapter, project, compPath));
+    html = ensureHfIds2(await transformPreviewHtml(html, adapter, project, compPath));
     html = injectStudioPreviewAugmentations(html, adapter, project.dir, compPath, capture);
     if (previewVariables) html = injectPreviewVariables(html, previewVariables);
     html = await injectMediaCodecMap(html, adapter, project.dir, compPath, mediaCodecProbeCache);
@@ -4086,14 +3775,14 @@ ${etag}`;
     const project = await adapter.resolveProject(c.req.param("id"));
     if (!project) return c.json({ error: "not found" }, 404);
     const subPath = requestSubPath(c.req.url, "projects/:id/preview");
-    const candidate = resolve5(project.dir, subPath);
+    const candidate = resolve4(project.dir, subPath);
     const file = isWithinProjectRoot(project.dir, candidate) ? candidate : null;
     if (!file) {
       return c.text("not found", 404);
     }
     recordPreviewRead(project.dir, file);
-    const stat3 = existsSync5(file) ? statSync4(file) : null;
-    if (!stat3?.isFile()) {
+    const stat2 = existsSync5(file) ? statSync4(file) : null;
+    if (!stat2?.isFile()) {
       return c.text("not found", 404);
     }
     const contentType = getMimeType(subPath);
@@ -4115,7 +3804,7 @@ ${etag}`;
         return c.text("media proxy variant does not match asset", 422);
       }
     }
-    const tag = settledFileTag(stat3);
+    const tag = settledFileTag(stat2);
     const etag = tag && `"${tag}${proxyEtagSalt(proxyVariant)}"`;
     const cacheHeaders = isText ? { "Cache-Control": "no-store" } : { "Cache-Control": "private, no-cache", ...etag && { ETag: etag } };
     if (!isText && etag) {
@@ -4127,19 +3816,26 @@ ${etag}`;
     let servedPath = file;
     let servedContentType = contentType;
     if (proxyVariant !== void 0) {
-      recordProxyRequest();
       try {
-        servedPath = await resolveProxy(project.dir, file, proxyVariant);
+        servedPath = await waitForProxy(resolveProxy(project.dir, file, proxyVariant), 0);
       } catch (err) {
+        if (err instanceof ProxyWaitTimeoutError) {
+          return c.text("media proxy is being made", 202, {
+            "Retry-After": String(PROXY_PENDING_RETRY_AFTER_SECONDS),
+            "Cache-Control": "no-store"
+          });
+        }
         if (err instanceof ProxyCapacityError) {
           return c.text(err.message, 503, { "Retry-After": "5" });
         }
+        if (isProjectRootMissing(err)) throw err;
         const message = err instanceof ProxyTranscodeError ? err.message : "proxy transcode failed";
         return c.text(message, 502);
       }
+      recordProxyRequest();
       servedContentType = PROXY_VARIANT_CONFIG[proxyVariant].contentType;
     }
-    const textBuffer = isText ? Buffer.from(readFileSync8(file, "utf-8"), "utf-8") : null;
+    const textBuffer = isText ? Buffer.from(readFileSync6(file, "utf-8"), "utf-8") : null;
     const totalSize = textBuffer ? textBuffer.length : statSync4(servedPath).size;
     const bodyFor = (start, end) => textBuffer ? new Uint8Array(textBuffer.subarray(start, end + 1)) : (
       // Node's web stream type and the DOM one do not overlap for tsc on
@@ -4183,8 +3879,8 @@ ${etag}`;
 }
 
 // src/routes/lint.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join9 } from "path";
 async function collectProjectFindings(adapter, projectDir) {
   const findings = [];
   const coveredFiles = /* @__PURE__ */ new Set();
@@ -4202,7 +3898,7 @@ async function lintUncoveredHtml(adapter, projectDir, htmlFiles, coveredFiles) {
   const findings = [];
   for (const file of htmlFiles) {
     if (coveredFiles.has(file)) continue;
-    const content = readFileSync9(join10(projectDir, file), "utf-8");
+    const content = readFileSync7(join9(projectDir, file), "utf-8");
     const result = await adapter.lint(content, { filePath: file, isSubComposition: true });
     for (const finding of result?.findings ?? []) {
       findings.push({ ...finding, file });
@@ -4235,8 +3931,8 @@ function registerLintRoutes(api, adapter) {
 
 // src/routes/render.ts
 import { streamSSE } from "hono/streaming";
-import { existsSync as existsSync6, readFileSync as readFileSync10, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync8, unlinkSync as unlinkSync3, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
+import { join as join10 } from "path";
 import { VALID_CANVAS_RESOLUTIONS } from "@hyperframes/parsers";
 import { formatRenderOutputTimestamp, parseFps } from "@hyperframes/core";
 var VALID_RESOLUTIONS = new Set(VALID_CANVAS_RESOLUTIONS);
@@ -4288,6 +3984,7 @@ function registerRenderRoutes(api, adapter) {
     let composition;
     if (typeof body.composition === "string" && body.composition.length > 0) {
       if (!resolveWithinProject(project.dir, body.composition)) {
+        if (folderGone(project.dir)) return projectDirMissing(c);
         return c.json({ error: "composition path must be within the project directory" }, 400);
       }
       composition = body.composition;
@@ -4302,9 +3999,9 @@ function registerRenderRoutes(api, adapter) {
     const now = /* @__PURE__ */ new Date();
     const jobId = `${project.id}_${formatRenderOutputTimestamp(now)}`;
     const rendersDir = adapter.rendersDir(project);
-    if (!existsSync6(rendersDir)) mkdirSync5(rendersDir, { recursive: true });
+    mkdirWithinProject(project.dir, rendersDir);
     const ext = FORMAT_EXT[format] ?? ".mp4";
-    const outputPath = join11(rendersDir, `${jobId}${ext}`);
+    const outputPath = join10(rendersDir, `${jobId}${ext}`);
     const jobState = adapter.startRender({
       project,
       outputPath,
@@ -4373,7 +4070,7 @@ function registerRenderRoutes(api, adapter) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync10(job.outputPath);
+    const content = readFileSync8(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -4391,7 +4088,7 @@ function registerRenderRoutes(api, adapter) {
     }
     const contentType = renderContentType(job.outputPath);
     const filename = job.outputPath.split("/").pop() ?? `render.mp4`;
-    const content = readFileSync10(job.outputPath);
+    const content = readFileSync8(job.outputPath);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -4405,7 +4102,7 @@ function registerRenderRoutes(api, adapter) {
       if (state.id === jobId && state.outputPath) {
         const dir = state.outputPath.replace(/\/[^/]+$/, "");
         for (const ext of [".mp4", ".webm", ".mov", ".meta.json"]) {
-          const fp = join11(dir, `${jobId}${ext}`);
+          const fp = join10(dir, `${jobId}${ext}`);
           if (existsSync6(fp)) unlinkSync3(fp);
         }
         break;
@@ -4424,7 +4121,7 @@ function registerRenderRoutes(api, adapter) {
     if (!fp) return c.json({ error: "forbidden" }, 403);
     if (!existsSync6(fp)) return c.json({ error: "not found" }, 404);
     const contentType = renderContentType(fp);
-    const content = readFileSync10(fp);
+    const content = readFileSync8(fp);
     return new Response(content, {
       headers: {
         "Content-Type": contentType,
@@ -4439,16 +4136,16 @@ function registerRenderRoutes(api, adapter) {
     if (!project) return c.json({ error: "not found" }, 404);
     const rendersDir = adapter.rendersDir(project);
     if (!existsSync6(rendersDir)) return c.json({ renders: [] });
-    const files = readdirSync4(rendersDir).filter((f) => f.endsWith(".mp4") || f.endsWith(".webm") || f.endsWith(".mov")).map((f) => {
-      const fp = join11(rendersDir, f);
-      const stat3 = statSync5(fp);
+    const files = readdirSync3(rendersDir).filter((f) => f.endsWith(".mp4") || f.endsWith(".webm") || f.endsWith(".mov")).map((f) => {
+      const fp = join10(rendersDir, f);
+      const stat2 = statSync5(fp);
       const rid = f.replace(/\.(mp4|webm|mov)$/, "");
-      const metaPath = join11(rendersDir, `${rid}.meta.json`);
+      const metaPath = join10(rendersDir, `${rid}.meta.json`);
       let status = "complete";
       let durationMs;
       if (existsSync6(metaPath)) {
         try {
-          const meta = JSON.parse(readFileSync10(metaPath, "utf-8"));
+          const meta = JSON.parse(readFileSync8(metaPath, "utf-8"));
           if (meta.status === "failed" && !existsSync6(fp)) status = "failed";
           if (meta.durationMs) durationMs = meta.durationMs;
         } catch {
@@ -4457,8 +4154,8 @@ function registerRenderRoutes(api, adapter) {
       return {
         id: rid,
         filename: f,
-        size: stat3.size,
-        createdAt: stat3.mtimeMs,
+        size: stat2.size,
+        createdAt: stat2.mtimeMs,
         status,
         durationMs
       };
@@ -4469,7 +4166,7 @@ function registerRenderRoutes(api, adapter) {
           id: file.id,
           status: file.status,
           progress: 100,
-          outputPath: join11(rendersDir, file.filename),
+          outputPath: join10(rendersDir, file.filename),
           createdAt: file.createdAt
         });
       }
@@ -4481,7 +4178,7 @@ function registerRenderRoutes(api, adapter) {
 // src/routes/imageThumbnail.ts
 import { HTTPException } from "hono/http-exception";
 import { open, stat } from "fs/promises";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import sharp from "sharp";
 
 // src/routes/thumbnailGenerationCoordinator.ts
@@ -4501,10 +4198,10 @@ var ThumbnailGenerationCoordinator = class {
     if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
     let entry = this.entries.get(key);
     if (!entry) {
-      let resolve9;
+      let resolve6;
       let reject;
       const promise = new Promise((resolvePromise, rejectPromise) => {
-        resolve9 = resolvePromise;
+        resolve6 = resolvePromise;
         reject = rejectPromise;
       });
       entry = {
@@ -4514,7 +4211,7 @@ var ThumbnailGenerationCoordinator = class {
         state: "queued",
         work,
         promise,
-        resolve: resolve9,
+        resolve: resolve6,
         reject
       };
       this.entries.set(key, entry);
@@ -4528,7 +4225,7 @@ var ThumbnailGenerationCoordinator = class {
     return /* @__PURE__ */ new Set([...this.entries.keys(), ...[...this.activeEntries].map((entry) => entry.key)]);
   }
   lease(entry, signal) {
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve6, reject) => {
       let released = false;
       const release = () => {
         if (released) return;
@@ -4552,7 +4249,7 @@ var ThumbnailGenerationCoordinator = class {
       entry.promise.then(
         (value) => {
           release();
-          resolve9(value);
+          resolve6(value);
         },
         (reason) => {
           release();
@@ -4617,14 +4314,14 @@ async function generateThumbnail(path, signal) {
 async function resolveSource(adapter, id, url) {
   const project = await adapter.resolveProject(id);
   if (!project) throw new HTTPException(404);
-  let relative6;
+  let relative4;
   try {
-    relative6 = requestSubPath(url, "projects/:id/image-thumbnail");
+    relative4 = requestSubPath(url, "projects/:id/image-thumbnail");
   } catch {
     throw new HTTPException(400);
   }
-  if (!/\.jpe?g$/i.test(relative6)) throw new HTTPException(415);
-  const path = pinWithinProject(project.dir, relative6);
+  if (!/\.jpe?g$/i.test(relative4)) throw new HTTPException(415);
+  const path = pinWithinProject(project.dir, relative4);
   if (!path) throw new HTTPException(404);
   const info = await stat(path).catch(() => {
     throw new HTTPException(404);
@@ -4652,7 +4349,7 @@ function registerImageThumbnailRoutes(api, adapter) {
   api.get("/projects/:id/image-thumbnail/*", async (c) => {
     try {
       const { path, info } = await resolveSource(adapter, c.req.param("id"), c.req.url);
-      const key = createHash5("sha256").update(JSON.stringify([path, info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs])).digest("hex");
+      const key = createHash2("sha256").update(JSON.stringify([path, info.dev, info.ino, info.size, info.mtimeMs, info.ctimeMs])).digest("hex");
       const etag = `"${key}"`;
       c.header("ETag", etag);
       c.header("Cache-Control", "private, no-cache");
@@ -4680,23 +4377,22 @@ function registerImageThumbnailRoutes(api, adapter) {
 
 // src/routes/thumbnail.ts
 import {
-  closeSync as closeSync3,
-  fstatSync as fstatSync3,
-  openSync as openSync3,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync12,
-  readdirSync as readdirSync5,
+  closeSync as closeSync2,
+  fstatSync as fstatSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync4,
   renameSync as renameSync3,
   rmSync as rmSync4,
   statSync as statSync6,
   unlinkSync as unlinkSync4,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync5
 } from "fs";
-import { join as join12 } from "path";
-import { createHash as createHash6, randomUUID as randomUUID4 } from "crypto";
+import { join as join11 } from "path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
 
 // src/helpers/compositionInputs.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 var ROOT_COMPOSITION = "index.html";
 var COMPOSITION_SRC = /\bdata-composition-src\s*=\s*(["'])(.*?)\1/g;
 function projectReader(projectDir) {
@@ -4706,7 +4402,7 @@ function projectReader(projectDir) {
       const file = resolveWithinProject(projectDir, compPath);
       let source = null;
       try {
-        source = file ? readFileSync11(file, "utf-8") : null;
+        source = file ? readFileSync9(file, "utf-8") : null;
       } catch {
       }
       sources.set(compPath, source);
@@ -4762,14 +4458,14 @@ var prunedCacheDirs = /* @__PURE__ */ new Set();
 function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
   let entries;
   try {
-    entries = readdirSync5(cacheDir, { withFileTypes: true });
+    entries = readdirSync4(cacheDir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
   }
   const files = entries.flatMap((entry) => {
     if (!entry.isFile()) return [];
-    const path = join12(cacheDir, entry.name);
+    const path = join11(cacheDir, entry.name);
     try {
       const stats = statSync6(path);
       return [{ path, bytes: stats.size, mtimeMs: stats.mtimeMs }];
@@ -4797,9 +4493,9 @@ function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
   }
 }
 function writeThumbnailAtomically(path, buffer) {
-  const temporaryPath = `${path}.${process.pid}.${randomUUID4()}.tmp`;
+  const temporaryPath = `${path}.${process.pid}.${randomUUID2()}.tmp`;
   try {
-    writeFileSync6(temporaryPath, buffer, { flag: "wx" });
+    writeFileSync5(temporaryPath, buffer, { flag: "wx" });
     renameSync3(temporaryPath, path);
   } finally {
     rmSync4(temporaryPath, { force: true });
@@ -4808,7 +4504,7 @@ function writeThumbnailAtomically(path, buffer) {
 function readFileOnce(file) {
   let fd;
   try {
-    fd = openSync3(file, "r");
+    fd = openSync2(file, "r");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") return "missing";
@@ -4816,17 +4512,17 @@ function readFileOnce(file) {
     throw err;
   }
   try {
-    const stat3 = fstatSync3(fd);
-    if (!stat3.isFile()) return "not-a-file";
-    return { data: readFileSync12(fd), mtimeMs: stat3.mtimeMs };
+    const stat2 = fstatSync2(fd);
+    if (!stat2.isFile()) return "not-a-file";
+    return { data: readFileSync10(fd), mtimeMs: stat2.mtimeMs };
   } finally {
-    closeSync3(fd);
+    closeSync2(fd);
   }
 }
 function manifestKey(file) {
   const manifest = readFileOnce(file);
   if (typeof manifest === "string") return { key: "", mtimeMs: -Infinity };
-  const hash = createHash6("sha1").update(manifest.data).digest("hex").slice(0, 16);
+  const hash = createHash3("sha1").update(manifest.data).digest("hex").slice(0, 16);
   return { key: `_${hash}`, mtimeMs: Math.round(manifest.mtimeMs) };
 }
 function registerThumbnailRoutes(api, adapter) {
@@ -4863,7 +4559,7 @@ function registerThumbnailRoutes(api, adapter) {
     let sourceKey = "";
     if (source !== "missing") {
       const html = source.data.toString("utf-8");
-      sourceKey = `_${createHash6("sha1").update(html).digest("hex").slice(0, 16)}`;
+      sourceKey = `_${createHash3("sha1").update(html).digest("hex").slice(0, 16)}`;
       sourceMtime = Math.round(source.mtimeMs);
       if (!vpWidth) {
         const wMatch = html.match(/data-width=["'](\d+)["']/);
@@ -4872,21 +4568,21 @@ function registerThumbnailRoutes(api, adapter) {
         if (hMatch?.[1]) compH = parseInt(hMatch[1]);
       }
     }
-    const manualEdits = manifestKey(join12(project.dir, STUDIO_MANUAL_EDITS_PATH));
-    const motion = manifestKey(join12(project.dir, STUDIO_MOTION_PATH));
+    const manualEdits = manifestKey(join11(project.dir, STUDIO_MANUAL_EDITS_PATH));
+    const motion = manifestKey(join11(project.dir, STUDIO_MOTION_PATH));
     sourceMtime = Math.max(sourceMtime, manualEdits.mtimeMs, motion.mtimeMs);
     const projectUrl = `http://${c.req.header("host")}/api/projects/${encodeURIComponent(project.id)}`;
     const previewPath = compPath === "index.html" ? `${projectUrl}/preview` : `${projectUrl}/preview/comp/${compPath.split("/").map(encodeURIComponent).join("/")}`;
     const previewUrl = `${previewPath}?${PREVIEW_CAPTURE_PARAM}=1`;
-    const cacheDir = join12(project.dir, ".thumbnails");
+    const cacheDir = join11(project.dir, ".thumbnails");
     const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}_${selectorIndex ?? 0}` : "";
     const urlVersionKey = urlVersion ? `_${urlVersion.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 32)}` : "";
-    const inputSignatureKey = `_${createHash6("sha1").update(inputSignature).digest("hex").slice(0, 16)}`;
+    const inputSignatureKey = `_${createHash3("sha1").update(inputSignature).digest("hex").slice(0, 16)}`;
     const outputScale = outputMode === "source" ? 1 : Math.min(1, THUMBNAIL_MAX_OUTPUT_WIDTH / compW, THUMBNAIL_MAX_OUTPUT_HEIGHT / compH);
     const outputWidth = Math.max(1, Math.round(compW * outputScale));
     const outputHeight = Math.max(1, Math.round(compH * outputScale));
     const cacheKey = `${THUMBNAIL_CACHE_VERSION}${urlVersionKey}${inputSignatureKey}${manualEdits.key}${motion.key}${sourceKey}_${format}_${outputMode}_${compPath.replace(/\//g, "_")}_${compW}x${compH}_${outputWidth}x${outputHeight}_${sourceMtime}_${seekTime.toFixed(2)}${selectorKey}.${format === "png" ? "png" : "jpg"}`;
-    const cachePath = join12(cacheDir, cacheKey);
+    const cachePath = join11(cacheDir, cacheKey);
     if (!prunedCacheDirs.has(cacheDir)) {
       prunedCacheDirs.add(cacheDir);
       pruneThumbnailCache(
@@ -4900,12 +4596,14 @@ function registerThumbnailRoutes(api, adapter) {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
       });
     }
-    if (url.searchParams.get("cached") === "1") return c.body(null, 404);
+    if (url.searchParams.get("cached") === "1")
+      return c.body(null, 204, { "Cache-Control": "no-cache" });
     try {
       const buffer = await thumbnailGenerationCoordinator.acquire(
         cachePath,
         c.req.raw.signal,
         async (signal) => {
+          const previewCopiesAtStart = proxyActivityMark(project.dir);
           const generated = await adapter.generateThumbnail({
             project,
             compPath,
@@ -4921,12 +4619,13 @@ function registerThumbnailRoutes(api, adapter) {
             signal
           });
           if (!generated) return null;
+          const previewCopiesAtEnd = proxyActivityMark(project.dir);
           const afterGeneration = await resolveProjectAndSignature(adapter, project.id);
           const inputsUnchanged = (signature) => compositionInputSignature(project.dir, compPath, signature) === inputSignature;
-          if (afterGeneration?.project.dir !== project.dir || !inputsUnchanged(afterGeneration.signature) || !inputsUnchanged(createProjectSignature(project.dir))) {
+          if (previewCopiesAtStart === null || previewCopiesAtEnd !== previewCopiesAtStart || afterGeneration?.project.dir !== project.dir || !inputsUnchanged(afterGeneration.signature) || !inputsUnchanged(createProjectSignature(project.dir))) {
             return generated;
           }
-          mkdirSync6(cacheDir, { recursive: true });
+          mkdirWithinProject(project.dir, cacheDir);
           writeThumbnailAtomically(cachePath, generated);
           return generated;
         }
@@ -4945,6 +4644,7 @@ function registerThumbnailRoutes(api, adapter) {
       if (err instanceof DOMException && err.name === "AbortError") {
         return new Response(null, { status: 499 });
       }
+      if (isProjectRootMissing(err)) throw err;
       const msg = err instanceof Error ? err.message : String(err);
       return c.json({ error: `Thumbnail generation failed: ${msg}` }, 500);
     }
@@ -4952,25 +4652,25 @@ function registerThumbnailRoutes(api, adapter) {
 }
 
 // src/routes/waveform.ts
-import { existsSync as existsSync7, readFileSync as readFileSync13, statSync as statSync7 } from "fs";
-import { join as join13, resolve as resolve6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
+import { join as join12, resolve as resolve5 } from "path";
 import { isWithinProjectRoot as isWithinProjectRoot2 } from "@hyperframes/parsers/asset-resolution";
 function registerWaveformRoutes(api, adapter) {
   api.get("/projects/:id/waveform/*", async (c) => {
     const project = await adapter.resolveProject(c.req.param("id"));
     if (!project) return c.json({ error: "not found" }, 404);
     const assetPath = requestSubPath(c.req.url, "projects/:id/waveform");
-    const audioPath = resolve6(project.dir, assetPath);
+    const audioPath = resolve5(project.dir, assetPath);
     if (!isWithinProjectRoot2(project.dir, audioPath)) {
       return c.json({ error: "file not found" }, 404);
     }
     const stats = statSync7(audioPath, { throwIfNoEntry: false });
     if (!stats) return c.json({ error: "file not found" }, 404);
-    const cacheDir = join13(project.dir, ".waveform-cache");
-    const cachePath = join13(cacheDir, buildWaveformCacheKey(assetPath, stats));
+    const cacheDir = join12(project.dir, ".waveform-cache");
+    const cachePath = join12(cacheDir, buildWaveformCacheKey(assetPath, stats));
     try {
       if (isWaveformCacheDirectory(cacheDir) && existsSync7(cachePath)) {
-        const peaks2 = JSON.parse(readFileSync13(cachePath, "utf-8"));
+        const peaks2 = JSON.parse(readFileSync11(cachePath, "utf-8"));
         return c.json({ peaks: peaks2 });
       }
     } catch {
@@ -4990,7 +4690,7 @@ function registerWaveformRoutes(api, adapter) {
 }
 
 // src/routes/fonts.ts
-import { closeSync as closeSync4, constants as constants2, fstatSync as fstatSync4, openSync as openSync4, readSync } from "fs";
+import { closeSync as closeSync3, constants, fstatSync as fstatSync3, openSync as openSync3, readSync } from "fs";
 import {
   collectFontFileEntries,
   fontDirectories,
@@ -5097,17 +4797,17 @@ function registerFontRoutes(api) {
     if (!located) return c.json({ error: "font not found" }, 404);
     let fd;
     try {
-      fd = openSync4(located.path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+      fd = openSync3(located.path, constants.O_RDONLY | constants.O_NOFOLLOW);
     } catch {
       return c.json({ error: "font file not accessible" }, 404);
     }
     try {
-      const stat3 = fstatSync4(fd);
-      if (stat3.size > SYSTEM_FONT_SIZE_LIMIT) {
+      const stat2 = fstatSync3(fd);
+      if (stat2.size > SYSTEM_FONT_SIZE_LIMIT) {
         return c.json({ error: "font file too large" }, 413);
       }
-      const buffer = Buffer.alloc(stat3.size);
-      readSync(fd, buffer, 0, stat3.size, 0);
+      const buffer = Buffer.alloc(stat2.size);
+      readSync(fd, buffer, 0, stat2.size, 0);
       const mimeType = located.format === "otf" ? "font/otf" : located.format === "woff2" ? "font/woff2" : located.format === "woff" ? "font/woff" : located.format === "ttc" ? "font/collection" : "font/ttf";
       const fileName = `${family.replace(/[^a-zA-Z0-9 -]/g, "")}.${located.format}`;
       return new Response(buffer, {
@@ -5119,7 +4819,7 @@ function registerFontRoutes(api) {
     } catch {
       return c.json({ error: "failed to read font file" }, 500);
     } finally {
-      closeSync4(fd);
+      closeSync3(fd);
     }
   });
 }
@@ -5139,6 +4839,7 @@ function registerRegistryRoutes(api, adapter) {
     }
     const project = await adapter.resolveProject(c.req.param("id"));
     if (!project) return c.json({ error: "Project not found" }, 404);
+    if (folderGone(project.dir)) return projectDirMissing(c);
     const body = await c.req.json().catch(() => null);
     if (!body?.blockName) {
       return c.json({ error: "blockName is required" }, 400);
@@ -5147,6 +4848,7 @@ function registerRegistryRoutes(api, adapter) {
       const result = await adapter.installRegistryBlock({ project, blockName: body.blockName });
       return c.json(result);
     } catch (err) {
+      if (isProjectRootMissing(err)) return projectDirMissing(c);
       const message = err instanceof Error ? err.message : "Install failed";
       return c.json({ error: message }, 500);
     }
@@ -5253,8 +4955,8 @@ function registerSelectionRoutes(api, adapter) {
 
 // src/routes/media.ts
 import { streamSSE as streamSSE2 } from "hono/streaming";
-import { existsSync as existsSync8, mkdirSync as mkdirSync7 } from "fs";
-import { basename as basename2, dirname as dirname6, extname as extname2, join as join14, posix } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { basename as basename2, dirname as dirname5, extname, join as join13, posix } from "path";
 var VIDEO_EXTENSIONS = /* @__PURE__ */ new Set([
   ".mp4",
   ".mov",
@@ -5272,10 +4974,10 @@ var VIDEO_OUTPUT_EXTENSIONS = /* @__PURE__ */ new Set([".webm", ".mov"]);
 var QUALITIES = /* @__PURE__ */ new Set(["fast", "balanced", "best"]);
 var DEVICES = /* @__PURE__ */ new Set(["auto", "cpu", "coreml", "cuda"]);
 function isVideoPath(path) {
-  return VIDEO_EXTENSIONS.has(extname2(path).toLowerCase());
+  return VIDEO_EXTENSIONS.has(extname(path).toLowerCase());
 }
 function isImagePath(path) {
-  return IMAGE_EXTENSIONS.has(extname2(path).toLowerCase());
+  return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
 }
 function normalizeProjectAssetPath(path) {
   return path.trim().replace(/^[.]\//, "").replace(/[?#].*$/, "");
@@ -5284,14 +4986,14 @@ function containsNullByte(path) {
   return path.includes("\0");
 }
 function slugFileBase(path) {
-  const name = basename2(path, extname2(path)).replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  const name = basename2(path, extname(path)).replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return name || "media";
 }
 function uniqueAssetPath(projectDir, assetPath, taken) {
-  const ext = extname2(assetPath);
+  const ext = extname(assetPath);
   const withoutExt = assetPath.slice(0, -ext.length);
   let candidate = assetPath;
-  for (let index = 2; taken.has(candidate) || existsSync8(join14(projectDir, candidate)); index++) {
+  for (let index = 2; taken.has(candidate) || existsSync8(join13(projectDir, candidate)); index++) {
     candidate = `${withoutExt}-${index}${ext}`;
   }
   return candidate;
@@ -5391,10 +5093,10 @@ function registerMediaRoutes(api, adapter, options = {}) {
       const outputAssetPath = requestedOutput ? uniqueAssetPath(project.dir, requestedOutput, taken) : defaultOutputPath(project.dir, inputAssetPath, taken);
       const outputPath = pinWithinProject(project.dir, outputAssetPath);
       if (!outputPath) return c.json({ error: "forbidden" }, 403);
-      if (inputIsVideo && !VIDEO_OUTPUT_EXTENSIONS.has(extname2(outputAssetPath).toLowerCase())) {
+      if (inputIsVideo && !VIDEO_OUTPUT_EXTENSIONS.has(extname(outputAssetPath).toLowerCase())) {
         return c.json({ error: "video background removal output must be .webm or .mov" }, 400);
       }
-      if (inputIsImage && extname2(outputAssetPath).toLowerCase() !== ".png") {
+      if (inputIsImage && extname(outputAssetPath).toLowerCase() !== ".png") {
         return c.json({ error: "image background removal output must be .png" }, 400);
       }
       let backgroundOutputAssetPath;
@@ -5410,8 +5112,8 @@ function registerMediaRoutes(api, adapter, options = {}) {
           return c.json({ error: "forbidden" }, 403);
         }
       }
-      mkdirSync7(dirname6(outputPath), { recursive: true });
-      if (backgroundOutputPath) mkdirSync7(dirname6(backgroundOutputPath), { recursive: true });
+      mkdirWithinProject(project.dir, dirname5(outputPath));
+      if (backgroundOutputPath) mkdirWithinProject(project.dir, dirname5(backgroundOutputPath));
       const jobId = makeJobId(project.id, mediaJobs);
       const state = adapter.startBackgroundRemoval({
         project,
@@ -5468,14 +5170,14 @@ function registerMediaRoutes(api, adapter, options = {}) {
 }
 
 // src/routes/globalAssets.ts
-import { existsSync as existsSync9, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
 import { homedir } from "os";
-import { join as join15 } from "path";
+import { join as join14 } from "path";
 function readGlobalAssets(home = homedir()) {
-  const manifestPath = join15(home, ".media", "manifest.jsonl");
+  const manifestPath = join14(home, ".media", "manifest.jsonl");
   if (!existsSync9(manifestPath)) return [];
   const out = [];
-  for (const line of readFileSync14(manifestPath, "utf8").split("\n")) {
+  for (const line of readFileSync12(manifestPath, "utf8").split("\n")) {
     if (!line.trim()) continue;
     try {
       const rec = JSON.parse(line);
@@ -5492,1259 +5194,6 @@ function registerGlobalAssetRoutes(api) {
   api.get("/assets/global", (c) => c.json({ assets: readGlobalAssets().map(toPublicAsset) }));
 }
 
-// src/history/projectHistory.ts
-import { randomUUID as randomUUID9 } from "crypto";
-import { readdir as readdir3, rm as rm3, rmdir, writeFile } from "fs/promises";
-import {
-  existsSync as existsSync11,
-  lstatSync as lstatSync4,
-  statSync as statSync10,
-  mkdirSync as mkdirSync11,
-  readdirSync as readdirSync7,
-  readFileSync as readFileSync19,
-  realpathSync,
-  rmSync as rmSync6
-} from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join20, relative as relative5, resolve as resolve8, sep as sep3 } from "path";
-
-// src/history/blobStore.ts
-import { createHash as createHash7, randomUUID as randomUUID5 } from "crypto";
-import { constants as constants3, createReadStream as createReadStream2, renameSync as renameSync4 } from "fs";
-import { copyFile, mkdir, readdir, readFile as readFile2, rename, rm, stat as stat2 } from "fs/promises";
-import { dirname as dirname7, join as join16 } from "path";
-var BLOB_HASH = /^[0-9a-f]{64}$/;
-async function hashFile(path) {
-  const hash = createHash7("sha256");
-  for await (const chunk of createReadStream2(path)) hash.update(chunk);
-  return hash.digest("hex");
-}
-async function cloneOrCopy(from, to, beforeReplace) {
-  await mkdir(dirname7(to), { recursive: true });
-  const temp = `${to}.${randomUUID5()}.tmp`;
-  try {
-    await copyFile(from, temp, constants3.COPYFILE_FICLONE);
-    beforeReplace?.();
-    renameSync4(temp, to);
-  } catch (error) {
-    await rm(temp, { force: true });
-    throw error;
-  }
-}
-async function openBlobStore(dir) {
-  const sizes = /* @__PURE__ */ new Map();
-  await mkdir(dir, { recursive: true });
-  for (const shard of await readdir(dir))
-    for (const hash of await readdir(join16(dir, shard)).catch(() => []))
-      sizes.set(hash, (await stat2(join16(dir, shard, hash))).size);
-  const pathOf = (hash) => {
-    if (!BLOB_HASH.test(hash)) throw new Error("That is not a history blob.");
-    return join16(dir, hash.slice(0, 2), hash);
-  };
-  let total = [...sizes.values()].reduce((sum, size) => sum + size, 0);
-  return {
-    async put(absPath) {
-      const temp = join16(dir, `incoming-${randomUUID5()}`);
-      await mkdir(dir, { recursive: true });
-      await copyFile(absPath, temp, constants3.COPYFILE_FICLONE);
-      const hash = await hashFile(temp);
-      if (sizes.has(hash)) {
-        await rm(temp, { force: true });
-        return hash;
-      }
-      await mkdir(dirname7(pathOf(hash)), { recursive: true });
-      const size = (await stat2(temp)).size;
-      await rename(temp, pathOf(hash));
-      sizes.set(hash, size);
-      total += size;
-      return hash;
-    },
-    has: (hash) => sizes.has(hash),
-    read: async (hash) => readFile2(pathOf(hash)),
-    writeTo: async (hash, absPath, beforeReplace) => cloneOrCopy(pathOf(hash), absPath, beforeReplace),
-    bytes: () => total,
-    size: (hash) => sizes.get(hash) ?? 0,
-    async prune(keep) {
-      for (const [hash, size] of sizes) {
-        if (keep.has(hash)) continue;
-        await rm(pathOf(hash), { force: true });
-        sizes.delete(hash);
-        total -= size;
-      }
-    }
-  };
-}
-
-// src/history/pruneHistories.ts
-import { randomUUID as randomUUID8 } from "crypto";
-import { readdirSync as readdirSync6, readFileSync as readFileSync17, renameSync as renameSync5, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
-import { lstat, readdir as readdir2, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname8, join as join19 } from "path";
-
-// src/history/historyId.ts
-import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync15, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename3, join as join17, resolve as resolve7 } from "path";
-var ID_PATH = join17(".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 = readFileSync15(join17(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, basename3(historyDir), folder);
-}
-function readRecord(historyDir) {
-  try {
-    return JSON.parse(readFileSync15(join17(historyDir, "project.json"), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function isCopyOf0878Folder(recordedDir, id, folder) {
-  let there;
-  try {
-    there = statSync8(recordedDir, { throwIfNoEntry: false });
-  } catch {
-    return false;
-  }
-  return !!there && !sameFolder(there, folder) && readId(recordedDir) === id;
-}
-function projectHistoryId(projectDir, historyRoot) {
-  const dir = resolve7(projectDir);
-  const folder = statSync8(dir);
-  let id = readId(dir);
-  if (!id && existsSync10(join17(dir, ID_PATH)))
-    throw new HistoryIdError(
-      `${join17(dir, ID_PATH)} holds no history id this version can read; move it aside to start anew.`
-    );
-  if (!id || existsSync10(join17(historyRoot, id)) && !isRecordedFolder(join17(historyRoot, id), folder)) {
-    id = randomUUID6();
-    mkdirSync8(join17(dir, ".hyperframes"), { recursive: true });
-    writeFileSync7(join17(dir, ID_PATH), `${id}
-`);
-  }
-  recordProject(join17(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 };
-  mkdirSync8(historyDir, { recursive: true });
-  replaceFileAtomically(join17(historyDir, "project.json"), JSON.stringify(record), 420);
-}
-
-// src/history/ownerLock.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { linkSync, mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync5, writeFileSync as writeFileSync8 } from "fs";
-import { join as join18 } from "path";
-var HistoryBusyError = class extends Error {
-  constructor(pid) {
-    super(`This project's history is open in another process (pid ${pid}).`);
-    this.pid = pid;
-    this.name = "HistoryBusyError";
-  }
-  pid;
-};
-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 text2 = readFileSync16(file, "utf-8");
-    return /^\d+$/.test(text2) ? Number(text2) : Number.NaN;
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-function claim(file) {
-  const draft = `${file}-${randomUUID7()}.tmp`;
-  writeFileSync8(draft, String(process.pid));
-  try {
-    linkSync(draft, file);
-    return true;
-  } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    return false;
-  } finally {
-    rmSync5(draft, { force: true });
-  }
-}
-function releaseOwn(file) {
-  if (ownerOf(file) === process.pid) rmSync5(file, { force: true });
-}
-function evictDeadOwner(file) {
-  const evictor = `${file}.evict`;
-  if (!claim(evictor)) {
-    const holder = ownerOf(evictor);
-    if (holder !== null && !alive(holder)) rmSync5(evictor, { force: true });
-    return false;
-  }
-  try {
-    const pid = ownerOf(file);
-    if (pid !== null && !alive(pid)) rmSync5(file, { force: true });
-    return true;
-  } finally {
-    releaseOwn(evictor);
-  }
-}
-async function takeHistoryOwnership(home, waitMs) {
-  const file = join18(home, "owner.pid");
-  const deadline = Date.now() + waitMs;
-  mkdirSync9(home, { recursive: true });
-  for (; ; ) {
-    if (claim(file)) {
-      let held = true;
-      return () => {
-        if (held) releaseOwn(file);
-        held = false;
-      };
-    }
-    const pid = ownerOf(file);
-    if (pid === null) continue;
-    if (!alive(pid) && evictDeadOwner(file)) continue;
-    if (Date.now() >= deadline) throw new HistoryBusyError(pid);
-    await new Promise((settle) => setTimeout(settle, 50));
-  }
-}
-
-// src/history/pruneHistories.ts
-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";
-async function pruneGoneProjectHistories(historyRoot, options = {}) {
-  return (await pruneWithin(historyRoot, options)).pruned;
-}
-async function pruneWithin(historyRoot, {
-  now = Date.now(),
-  dryRun = false,
-  tempDir = tmpdir2(),
-  onError = (error) => console.warn("[history] could not prune a history:", error),
-  budgetMs = Infinity,
-  measure = true
-}) {
-  const started = performance.now();
-  let names;
-  try {
-    names = readdirSync6(historyRoot);
-  } catch (error) {
-    if (error.code === "ENOENT") return { pruned: [], finished: true };
-    throw error;
-  }
-  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(join19(historyRoot, name), { recursive: true, force: true });
-    return null;
-  }
-  return isHistoryId(name) ? pruneOne(historyRoot, name, run) : null;
-}
-async function pruneOne(historyRoot, id, run) {
-  const home = join19(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 = join19(historyRoot, id);
-  const projectDir = abandonedProject(home, id, now, tempDir);
-  if (projectDir === null) return null;
-  if (dryRun) return { projectDir, trash: null };
-  const trash = join19(historyRoot, `${PRUNED_PREFIX}${id}-${randomUUID8()}`);
-  renameSync5(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 (!statSync9(join19(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 stat3 = statSync9(at, { throwIfNoEntry: false });
-  while (!stat3) {
-    if (dirname8(at) === at) return false;
-    at = dirname8(at);
-    stat3 = statSync9(at, { throwIfNoEntry: false });
-  }
-  if (typeof dev === "number") return stat3.dev === dev;
-  return at === dir || isSafePath(tempDir, at);
-}
-function lastUsed(home) {
-  const mtime = (file) => statSync9(join19(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 = join19(dir, entry.name);
-    total += entry.isDirectory() ? await bytesIn(path) : (await lstat(path)).size;
-  }
-  return total;
-}
-function prunedWithinADay(stamp, now) {
-  try {
-    const last = Number(readFileSync17(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 = join19(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 && writeFileSync9(stamp, String(now))).catch((error) => onError?.(error)).finally(() => pruning.delete(historyRoot));
-  });
-}
-
-// src/history/historyLog.ts
-import { closeSync as closeSync5, constants as constants4, mkdirSync as mkdirSync10, openSync as openSync5, readFileSync as readFileSync18, writeSync as writeSync2 } from "fs";
-import { dirname as dirname9 } from "path";
-var START = "start";
-function parseRecord(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function readLog(file, onUnreadable) {
-  let text2;
-  try {
-    text2 = readFileSync18(file, "utf-8");
-  } catch {
-    return null;
-  }
-  const log = { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() };
-  const lines = text2.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));
-  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 = openSync5(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 {
-    closeSync5(fd);
-  }
-}
-function writeLog(file, log) {
-  const records = [
-    { type: "baseline", files: Object.fromEntries(log.baseline) },
-    ...log.entries.map((entry) => ({ type: "entry", entry })),
-    ...[...log.pins].map((id) => ({ type: "pin", id, pinned: true }))
-  ];
-  mkdirSync10(dirname9(file), { recursive: true });
-  replaceFileAtomically(file, records.map((r) => `${JSON.stringify(r)}
-`).join(""), 420);
-}
-function applyEntry(manifest, entry, side) {
-  for (const file of entry.files) {
-    const hash = file[side];
-    if (hash === null) manifest.delete(file.path);
-    else manifest.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 manifest = new Map(log.baseline);
-  for (const entry of log.entries) {
-    applyEntry(manifest, entry, entry.id === id ? side : "after");
-    if (entry.id === id) return manifest;
-  }
-  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;
-}
-
-// src/history/projectHistory.ts
-var DEFAULT_HISTORY_ROOT = join20(homedir2(), ".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 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(join20(dir, entry.name));
-  await rmdir(dir);
-}
-function fileLeftIn(dir, at, deleted) {
-  for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-    const path = `${at}/${entry.name}`;
-    const left = entry.isDirectory() ? fileLeftIn(join20(dir, entry.name), path, deleted) : deleted.has(path) ? void 0 : path;
-    if (left) return left;
-  }
-  return void 0;
-}
-function ignoresCase(dir) {
-  const self = statSync10(join20(dir, ID_PATH), { throwIfNoEntry: false });
-  const other = statSync10(join20(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 takesWrite = (window, at) => window.idleMs === void 0 || at - (window.lastWriteAt ?? at) <= window.idleMs;
-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 Engine = class {
-  constructor(options, projectId, blobs) {
-    this.options = options;
-    this.projectId = projectId;
-    this.blobs = blobs;
-    this.dir = resolve8(options.projectDir);
-    this.home = join20(options.historyRoot, projectId);
-    this.foldsCase = ignoresCase(this.dir);
-    const folder = statSync10(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;
-  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 join20(this.home, "log.jsonl");
-  }
-  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(task);
-    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 = statSync10(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 (!existsSync11(join20(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 = log;
-    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 : "" });
-    }
-    this.reopenClosedWindow();
-    await this.settleAll();
-  }
-  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 firstOpen() {
-    const sweptAt = Date.now();
-    for (const file of listProjectFiles(this.dir)) {
-      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.persistLog();
-    this.saveStatCache();
-  }
-  manifest() {
-    return new Map([...this.tracked].map(([path, file]) => [path, file.hash]));
-  }
-  readStatCache() {
-    try {
-      const files = JSON.parse(readFileSync19(join20(this.home, "stat.json"), "utf-8"));
-      return new Map(Object.entries(files));
-    } catch {
-      return /* @__PURE__ */ new Map();
-    }
-  }
-  saveStatCache() {
-    const files = JSON.stringify(Object.fromEntries(this.tracked));
-    mkdirSync11(this.home, { recursive: true });
-    replaceFileAtomically(join20(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 = Date.now();
-    const changedAt = (file) => Math.min(sweptAt, Math.max(file.mtimeMs, file.ctimeMs));
-    const seen = listProjectFiles(this.dir);
-    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);
-      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 {
-      return await this.blobs.put(join20(this.dir, path));
-    } catch (error) {
-      if (error.code === "ENOENT") return null;
-      throw error;
-    }
-  }
-  async observe(path, stat3, at) {
-    const known = this.tracked.get(path) ?? { hash: null, stat: null };
-    if (stat3 && known.stat === stat3) return false;
-    const hash = await this.storeIfPresent(path);
-    if (hash === null || this.whereFolder() !== "here") return false;
-    this.tracked.set(path, { hash, stat: stat3 });
-    if (known.hash !== hash) await this.record(path, known.hash, hash, at);
-    return known.hash !== hash || known.stat !== stat3;
-  }
-  async record(path, before, after, at) {
-    const endedBeforeThisWrite = this.windows.filter((open2) => !takesWrite(open2, 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 = {} }) {
-    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);
-    if (coalesceKey) return this.holdClaim(group, coalesceKey, idleMs);
-    const entry = await this.commit(group);
-    return entry && { id: entry.id };
-  }
-  /** 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((open2) => open2.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, resolve8(this.dir, path)).split(sep3).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((open2) => !sameWho(open2.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(await this.overwrittenBy(change, told, walked[i]) ?? told);
-    }
-    hits.forEach(
-      ({ change }, i) => forgetOverwrittenBytes(
-        join20(this.dir, change.path),
-        new Set([...walked[i]].map(hashVersion))
-      )
-    );
-    return hits.flatMap(({ group, change }, i) => this.cutOut(group, change, cuts[i]) ?? []);
-  }
-  /** Walks the server's writes back from `change.after` to the bytes they replaced, stored so an undo restores them. */
-  async overwrittenBy(change, told, seen) {
-    const absPath = join20(this.dir, change.path);
-    let bytes;
-    for (let hash = change.after; hash; ) {
-      if (seen.has(hash)) return void 0;
-      seen.add(hash);
-      const replaced = bytesOverwrittenBy(absPath, hashVersion(hash));
-      if (replaced === void 0) break;
-      bytes = replaced;
-      hash = hashOfVersion(fileContentVersion(replaced));
-      if (hash === change.before || hash === told) return hash;
-    }
-    if (bytes === void 0) return void 0;
-    const staged = join20(this.home, `overwrote-${randomUUID9()}`);
-    await writeFile(staged, bytes);
-    try {
-      return await this.blobs.put(staged);
-    } finally {
-      await rm3(staged, { force: true });
-    }
-  }
-  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?.();
-    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: randomUUID9(), 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 = {}) {
-    if (!group.changes.size) return null;
-    const pending = this.pendingEntry(group);
-    const endedAt = Math.max(pending.endedAt, this.log.entries.at(-1)?.endedAt ?? 0);
-    const entry = { ...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);
-    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 && foldOldest(this.log)) {
-      folded = true;
-      await this.blobs.prune(
-        /* @__PURE__ */ new Set([...referencedHashes(this.log, this.manifest()), ...this.pendingHashes()])
-      );
-    }
-    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) {
-    if (this.notedTimer || !affectsProjectSignature(this.dir, resolve8(this.dir, path))) 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) {
-    return this.queue(async () => {
-      await this.settle();
-      const window = { ...this.newGroup(who, label), idleMs };
-      this.windows.push(window);
-      this.touch(window, Date.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);
-    clearTimeout(window.idleTimer);
-    if (window.idleMs === void 0 || !Number.isFinite(window.idleMs)) return;
-    window.idleTimer = setTimeout(
-      () => this.background(() => this.sweepAndEnd(window)),
-      window.idleMs
-    );
-    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((open2) => open2 !== 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 stat3 = lstatSync4(join20(this.dir, at), { throwIfNoEntry: false });
-      if (!stat3) return void 0;
-      if (at === path || !stat3.isDirectory()) return { at, stat: stat3 };
-    }
-    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(join20(this.dir, standing.at));
-    const at = relative5(realpathSync.native(this.dir), real).split(sep3).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 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.sweep();
-    } finally {
-      this.windows = this.windows.filter((open2) => open2 !== 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 = join20(this.dir, path);
-    const { writeToken } = this;
-    if (writeToken) {
-      const version = hash === null ? DELETED_VERSION : hashVersion(hash);
-      recordFileWriteReceipt(absPath, { path, version, writeToken });
-    }
-    if (hash === null) {
-      this.assertWritable();
-      rmSync6(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 })
-    };
-  }
-  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((open2) => open2.parts?.has(entry.id));
-    return stepTarget(
-      this.log.entries,
-      direction,
-      (entry) => 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 };
-  }
-  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);
-    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),
-      claim: (who, label, paths, options = {}) => this.queue(() => this.claimNow(who, label, paths, options)),
-      noteChange: (path) => {
-        if (!this.closed) this.noteChange(path);
-      },
-      list: () => {
-        this.assertOpen();
-        const undone = undoneIds(this.log.entries);
-        return this.log.entries.map((entry) => ({
-          ...entry,
-          pinned: this.log.pins.has(entry.id),
-          undone: undone.has(entry.id)
-        }));
-      },
-      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();
-        const files = manifestAt(this.log, point);
-        return files && Object.fromEntries(files);
-      },
-      checkout: (entryId, side, emptyDir) => this.queue(async () => {
-        this.entry(entryId);
-        if (!existsSync11(this.dir)) throw new Error(`The project folder is gone: ${this.dir}`);
-        const dest = resolve8(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);
-        try {
-          for (const [path, hash] of files) await this.blobs.writeTo(hash, join20(dest, path));
-        } catch (error) {
-          for (const name of await readdir3(dest).catch(() => []))
-            await rm3(join20(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);
-      },
-      flush: () => this.queue(() => this.settleAll()),
-      replacedAtPath: () => this.whereFolder() === "replaced",
-      close: () => this.closing ??= (async () => {
-        if (this.notedTimer) clearTimeout(this.notedTimer);
-        const settled = this.queue(() => this.settleAll());
-        this.closed = true;
-        await settled;
-      })()
-    };
-  }
-};
-function isWithin(dir, path) {
-  let probe = resolve8(path);
-  while (!existsSync11(probe) && dirname10(probe) !== probe) probe = dirname10(probe);
-  const rel = relative5(realpathSync.native(dir), realpathSync.native(probe));
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute2(rel);
-}
-function missingIsEmpty(error) {
-  if (error.code === "ENOENT") return [];
-  throw error;
-}
-var HistoryClosedError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "HistoryClosedError";
-  }
-};
-async function openProjectHistory(options) {
-  if (!existsSync11(options.projectDir))
-    throw new HistoryClosedError(`${options.projectDir} is gone or now another project.`);
-  const projectId = projectHistoryId(options.projectDir, options.historyRoot);
-  const release = await takeHistoryOwnership(
-    join20(options.historyRoot, projectId),
-    options.ownerWaitMs ?? 5e3
-  );
-  try {
-    const blobs = await openBlobStore(join20(options.historyRoot, projectId, "blobs"));
-    const engine = new Engine(options, projectId, blobs);
-    await engine.queue(() => engine.start());
-    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;
-  }
-}
-
 // src/routes/history.ts
 var YOU = { kind: "person", name: "You" };
 async function historyOf(adapter, c) {
@@ -6884,6 +5333,21 @@ function registerHistoryRoutes(api, adapter) {
 // src/createStudioApi.ts
 function createStudioApi(adapter) {
   const api = new Hono();
+  api.use(async function answerProjectDirMissingAfterErrorHandlers(c, next) {
+    const hostHeaders = new Headers(c.res.headers);
+    await next();
+    if (isProjectRootMissing(c.error)) replaceWithProjectDirMissing(c, hostHeaders);
+  });
+  api.use("/projects/:id/*", async function answerProjectDirMissingForVanishedFolder(c, next) {
+    const hostHeaders = new Headers(c.res.headers);
+    const dirBeforeRoute = await Promise.resolve().then(() => adapter.resolveProject(c.req.param("id"))).then(
+      (project) => project?.dir,
+      () => void 0
+    );
+    await next();
+    if (c.res.status >= 403 && dirBeforeRoute && folderGone(dirBeforeRoute))
+      replaceWithProjectDirMissing(c, hostHeaders);
+  });
   registerProjectRoutes(api, adapter);
   registerFileRoutes(api, adapter);
   registerPreviewRoutes(api, adapter);
@@ -6901,33 +5365,9 @@ function createStudioApi(adapter) {
   return api;
 }
 
-// src/history/historyCache.ts
-function historyCache(open2) {
-  const histories = /* @__PURE__ */ new Map();
-  const get = async (projectDir) => {
-    let cached = histories.get(projectDir);
-    if (!cached) histories.set(projectDir, cached = open2(projectDir));
-    const opened = await cached;
-    if (!opened?.replacedAtPath()) return opened;
-    const reopen = () => open2(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()))
-    )
-  };
-}
-
 // src/helpers/duplicateElement.ts
 import { sameInstant } from "@hyperframes/core/clip-facts";
-import { ensureHfIds as ensureHfIds4 } from "@hyperframes/parsers/hf-ids";
+import { ensureHfIds as ensureHfIds3 } from "@hyperframes/parsers/hf-ids";
 function duplicateElementInHtml(source, target, newId, at) {
   const { document, wrappedFragment } = parseSourceDocument(source);
   const element = findTargetElement(document, target);
@@ -6947,7 +5387,7 @@ function duplicateElementInHtml(source, target, newId, at) {
   clone.setAttribute("data-start", String(at));
   element.parentElement.insertBefore(clone, element.nextSibling);
   const html = wrappedFragment ? document.body.innerHTML || "" : document.toString();
-  return { html: ensureHfIds4(html), matched: true, newId: uniqueId };
+  return { html: ensureHfIds3(html), matched: true, newId: uniqueId };
 }
 function nextUniqueId(document, newId) {
   let uniqueId = newId;
@@ -6979,27 +5419,28 @@ function numericAttribute(element, name) {
 }
 
 // src/helpers/previewDocumentStore.ts
-import { createHash as createHash8 } from "crypto";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync8, rmSync as rmSync7 } from "fs";
-import { join as join21 } from "path";
-function createPreviewDocumentStore(dir, salt) {
-  const fileFor = (key) => join21(dir, `${createHash8("sha256").update(`${salt}
+import { createHash as createHash4 } from "crypto";
+import { readFileSync as readFileSync13, readdirSync as readdirSync5, rmSync as rmSync5 } from "fs";
+import { join as join15 } from "path";
+function createPreviewDocumentStore(projectDir, salt) {
+  const dir = join15(projectDir, ".hyperframes", "preview");
+  const fileFor = (key) => join15(dir, `${createHash4("sha256").update(`${salt}
 ${key}`).digest("hex").slice(0, 32)}.html`);
   return {
     read(key) {
       try {
-        return readFileSync20(fileFor(key), "utf-8");
+        return readFileSync13(fileFor(key), "utf-8");
       } catch {
         return null;
       }
     },
     write(key, html) {
       try {
-        mkdirSync12(dir, { recursive: true });
+        mkdirWithinProject(projectDir, dir);
         const file = fileFor(key);
         replaceFileAtomically(file, html, 420);
-        for (const name of readdirSync8(dir)) {
-          if (join21(dir, name) !== file) rmSync7(join21(dir, name), { force: true });
+        for (const name of readdirSync5(dir)) {
+          if (join15(dir, name) !== file) rmSync5(join15(dir, name), { force: true });
         }
       } catch {
       }
@@ -7109,6 +5550,7 @@ export {
   historyCache,
   identifyFileWrite,
   isSafePath,
+  listProjectHistories,
   openProjectHistory,
   parseSourceDocument,
   patchElementInHtml,