@hyperframes/studio-server 0.8.150 → 0.8.152

package/dist/{chunk-Y7V6FJHS.js → chunk-CW5G6XXR.js}

@@ -1,25 +1,26 @@
 import {
   isSafePath,
   mkdirWithinProject,
+  pinProjectRecord,
   realFilePath
-} from "./chunk-M62HDRLX.js";
+} from "./chunk-K56J3CL7.js";
 
 // src/history/projectHistory.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { mkdir as mkdir2, readdir as readdir3, rm as rm3, rmdir, writeFile } from "fs/promises";
 import {
-  existsSync as existsSync2,
-  lstatSync as lstatSync2,
-  statSync as statSync3,
+  existsSync as existsSync3,
+  lstatSync as lstatSync3,
+  statSync as statSync4,
   mkdirSync as mkdirSync4,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync9,
   realpathSync,
   rmSync as rmSync2
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
-import { replaceFileAtomically as replaceFileAtomically3 } from "@hyperframes/core/atomic-file";
+import { dirname as dirname4, isAbsolute as isAbsolute5, join as join7, relative as relative4, resolve as resolve6, sep as sep4 } from "path";
+import { replaceFileAtomically as replaceFileAtomically5 } from "@hyperframes/core/atomic-file";
 
 // src/helpers/fileVersion.ts
 import { createHash, randomUUID } from "crypto";
@@ -99,10 +100,143 @@ function newestReceipt(absPath, expectedVersion) {
 }
 var consumeFileWriteReceipt = identifyFileWrite;
 
+// src/helpers/renderOutputs.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+import { replaceFileAtomically } from "@hyperframes/core/atomic-file";
+
+// src/history/ownerLock.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join } 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 text = readFileSync(file, "utf-8");
+    return /^\d+$/.test(text) ? Number(text) : Number.NaN;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function claim(file) {
+  const draft = `${file}-${process.pid}-${randomUUID2()}.tmp`;
+  writeFileSync(draft, String(process.pid));
+  try {
+    linkSync(draft, file);
+    return true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    return false;
+  } finally {
+    rmSync(draft, { force: true });
+  }
+}
+function releaseOwn(file) {
+  if (ownerOf(file) === process.pid) rmSync(file, { force: true });
+}
+function evictDeadOwner(file) {
+  const evictor = `${file}.evict`;
+  if (!claim(evictor)) {
+    const holder = ownerOf(evictor);
+    if (holder !== null && !alive(holder)) rmSync(evictor, { force: true });
+    return false;
+  }
+  try {
+    const pid = ownerOf(file);
+    if (pid !== null && !alive(pid)) rmSync(file, { force: true });
+    return true;
+  } finally {
+    releaseOwn(evictor);
+  }
+}
+async function takeHistoryOwnership(home, waitMs) {
+  const file = join(home, "owner.pid");
+  const deadline = Date.now() + waitMs;
+  mkdirSync(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/helpers/renderOutputs.ts
+var manifest = ".hyperframes/render-outputs.json";
+function readRenderOutputs(projectDir) {
+  const path = pinProjectRecord(projectDir, manifest);
+  if (!path) return [];
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return [];
+    throw error;
+  }
+  const value = JSON.parse(text);
+  if (value.version !== 1 || !Array.isArray(value.paths) || !value.paths.every(
+    (p) => typeof p === "string" && p !== "" && !isAbsolute(p) && !p.split(/[\\/]/).some((part) => part === ".." || part === ".")
+  ))
+    throw new Error("Invalid render output registry.");
+  return value.paths;
+}
+function readRenderOutputsOrNone(projectDir) {
+  try {
+    return readRenderOutputs(projectDir);
+  } catch {
+    return [];
+  }
+}
+function isRenderOutput(projectDir, path, outputs) {
+  const candidate = relative(resolve(projectDir), resolve(path)).split(sep).join("/");
+  return outputs.some((output) => candidate === output || candidate.startsWith(`${output}/`));
+}
+async function registerRenderOutput(projectDir, output) {
+  const path = relative(resolve(projectDir), resolve(output)).split(sep).join("/");
+  if (path === "") throw new Error("Render output cannot replace the project directory.");
+  if (isAbsolute(path) || path === ".." || path.startsWith("../")) return;
+  const registry = pinProjectRecord(projectDir, manifest);
+  const lock = pinProjectRecord(projectDir, ".hyperframes/render-outputs-lock");
+  if (!registry || !lock) throw new Error("Render output registry must stay inside the project.");
+  const release = await takeHistoryOwnership(lock, 5e3);
+  try {
+    const paths = [.../* @__PURE__ */ new Set([...readRenderOutputs(projectDir), path])].sort();
+    replaceFileAtomically(registry, JSON.stringify({ version: 1, paths }) + "\n", 420);
+  } finally {
+    release();
+  }
+}
+
 // src/helpers/projectSignature.ts
 import { createHash as createHash2 } from "crypto";
-import { lstatSync, readFileSync, readdirSync } from "fs";
-import { extname, isAbsolute, relative, resolve, sep } from "path";
+import { lstatSync, readFileSync as readFileSync3, readdirSync } from "fs";
+import { extname, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
 import { isAtomicTempPath } from "@hyperframes/core/atomic-file";
 var SIGNATURE_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".cjs",
@@ -138,25 +272,36 @@ var STUDIO_SIGNATURE_MANIFEST_PATHS = [
   ".hyperframes/studio-motion.json"
 ];
 function affectsProjectSignature(projectDir, changedPath) {
-  const relativePath = relative(resolve(projectDir), resolve(changedPath));
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath) || isAtomicTempPath(relativePath)) {
+  const relativePath = relative2(resolve2(projectDir), resolve2(changedPath));
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute2(relativePath) || isAtomicTempPath(relativePath)) {
     return false;
   }
-  const segments = relativePath.split(sep);
+  if (isRenderOutput(projectDir, changedPath, readRenderOutputsOrNone(projectDir))) return false;
+  const segments = relativePath.split(sep2);
   if (STUDIO_SIGNATURE_MANIFEST_PATHS.includes(segments.join("/"))) return true;
   return !segments.some((segment) => SIGNATURE_EXCLUDED_DIRS.has(segment));
 }
 var projectSignatureCache = /* @__PURE__ */ new Map();
 var COARSEST_FILE_TIME_TICK_MS = 2e3;
 function isPathWithin(parentDir, childPath) {
-  const childRelativePath = relative(parentDir, childPath);
-  return childRelativePath === "" || !childRelativePath.startsWith("..") && !isAbsolute(childRelativePath);
+  const childRelativePath = relative2(parentDir, childPath);
+  return childRelativePath === "" || !childRelativePath.startsWith("..") && !isAbsolute2(childRelativePath);
 }
 function isTextContentEligible(file, size) {
   return SIGNATURE_TEXT_EXTENSIONS.has(extname(file).toLowerCase()) && size <= MAX_SIGNATURE_TEXT_BYTES;
 }
 var isSkippedEntry = (entry) => SIGNATURE_EXCLUDED_DIRS.has(entry) || isAtomicTempPath(entry);
-function collectProjectSignatureFiles(projectDir, dir, files) {
+function signatureEntryStat(projectDir, entry, file, outputs) {
+  if (isSkippedEntry(entry) || !isPathWithin(projectDir, file)) return null;
+  if (isRenderOutput(projectDir, file, outputs)) return null;
+  try {
+    const stat2 = lstatSync(file);
+    return stat2.isSymbolicLink() ? null : stat2;
+  } catch {
+    return null;
+  }
+}
+function collectProjectSignatureFiles(projectDir, dir, files, outputs = readRenderOutputsOrNone(projectDir)) {
   let entries;
   try {
     entries = readdirSync(dir).sort();
@@ -164,18 +309,11 @@ function collectProjectSignatureFiles(projectDir, dir, files) {
     return;
   }
   for (const entry of entries) {
-    if (isSkippedEntry(entry)) continue;
-    const file = resolve(dir, entry);
-    if (!isPathWithin(projectDir, file)) continue;
-    let stat2;
-    try {
-      stat2 = lstatSync(file);
-    } catch {
-      continue;
-    }
-    if (stat2.isSymbolicLink()) continue;
+    const file = resolve2(dir, entry);
+    const stat2 = signatureEntryStat(projectDir, entry, file, outputs);
+    if (!stat2) continue;
     if (stat2.isDirectory()) {
-      collectProjectSignatureFiles(projectDir, file, files);
+      collectProjectSignatureFiles(projectDir, file, files, outputs);
     } else if (stat2.isFile()) {
       files.push({
         file,
@@ -190,7 +328,7 @@ function collectProjectSignatureFiles(projectDir, dir, files) {
 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);
+    const file = resolve2(projectDir, manifestPath);
     if (seen.has(file) || !isPathWithin(projectDir, file)) continue;
     let stat2;
     try {
@@ -212,7 +350,7 @@ function collectProjectSignatureManifestFiles(projectDir, files) {
 function createProjectFingerprint(projectDir, files) {
   const hash = createHash2("sha256");
   for (const entry of files) {
-    hash.update(relative(projectDir, entry.file));
+    hash.update(relative2(projectDir, entry.file));
     hash.update("\0");
     hash.update(String(entry.size));
     hash.update("\0");
@@ -232,9 +370,9 @@ function collectProjectFiles(normalizedProjectDir) {
   return collected;
 }
 function listProjectFiles(projectDir) {
-  const normalizedProjectDir = resolve(projectDir);
+  const normalizedProjectDir = resolve2(projectDir);
   return collectProjectFiles(normalizedProjectDir).map((entry) => ({
-    path: relative(normalizedProjectDir, entry.file).split(sep).join("/"),
+    path: relative2(normalizedProjectDir, entry.file).split(sep2).join("/"),
     size: entry.size,
     mtimeMs: entry.mtimeMs,
     ctimeMs: entry.ctimeMs
@@ -249,11 +387,11 @@ async function resolveProjectAndSignature(adapter, projectId) {
   return { project, signature: resolveProjectSignature(adapter, project.dir) };
 }
 function createProjectSignature(projectDir, excluding = /* @__PURE__ */ new Set()) {
-  const normalizedProjectDir = resolve(projectDir);
+  const normalizedProjectDir = resolve2(projectDir);
   const signedAt = Date.now();
   const collected = collectProjectFiles(normalizedProjectDir);
   const files = collected.filter(
-    (entry) => !excluding.has(relative(normalizedProjectDir, entry.file).split(sep).join("/"))
+    (entry) => !excluding.has(relative2(normalizedProjectDir, entry.file).split(sep2).join("/"))
   );
   files.sort((a, b) => a.file.localeCompare(b.file));
   const fingerprint = createProjectFingerprint(normalizedProjectDir, files);
@@ -262,14 +400,14 @@ function createProjectSignature(projectDir, excluding = /* @__PURE__ */ new Set(
   if (cached?.fingerprint === fingerprint) return cached.signature;
   const hash = createHash2("sha256");
   for (const entry of files) {
-    const relativePath = relative(normalizedProjectDir, entry.file);
+    const relativePath = relative2(normalizedProjectDir, entry.file);
     hash.update(relativePath);
     hash.update("\0");
     hash.update(String(entry.size));
     hash.update("\0");
     if (entry.textContentEligible) {
       try {
-        hash.update(readFileSync(entry.file));
+        hash.update(readFileSync3(entry.file));
       } catch {
         hash.update(String(entry.mtimeMs));
       }
@@ -287,15 +425,15 @@ function createProjectSignature(projectDir, excluding = /* @__PURE__ */ new Set(
 }
 
 // src/history/blobStore.ts
-import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 import { constants, createReadStream, renameSync } from "fs";
 import { copyFile, mkdir, readdir, readFile, rename, rm, stat } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 import { atomicTempPath } from "@hyperframes/core/atomic-file";
 var BLOB_HASH = /^[0-9a-f]{64}$/;
 function blobPath(dir, hash) {
   if (!BLOB_HASH.test(hash)) throw new Error("That is not a history blob.");
-  return join(dir, hash.slice(0, 2), hash);
+  return join2(dir, hash.slice(0, 2), hash);
 }
 var readBlob = (dir, hash) => readFile(blobPath(dir, hash));
 async function hashFile(path) {
@@ -319,13 +457,13 @@ 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(join(dir, shard)).catch(() => []))
-      sizes.set(hash, (await stat(join(dir, shard, hash))).size);
+    for (const hash of await readdir(join2(dir, shard)).catch(() => []))
+      sizes.set(hash, (await stat(join2(dir, shard, hash))).size);
   const pathOf = (hash) => blobPath(dir, hash);
   let total = [...sizes.values()].reduce((sum, size) => sum + size, 0);
   return {
     async put(absPath) {
-      const temp = join(dir, `incoming-${randomUUID2()}`);
+      const temp = join2(dir, `incoming-${randomUUID3()}`);
       await mkdir(dir, { recursive: true });
       await copyFile(absPath, temp, constants.COPYFILE_FICLONE);
       const hash = await hashFile(temp);
@@ -358,22 +496,22 @@ async function openBlobStore(dir) {
 
 // src/history/pruneHistories.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { readdirSync as readdirSync2, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync5, renameSync as renameSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { lstat, readdir as readdir2, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname as dirname2, join as join4 } from "path";
 
 // src/history/historyId.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync, mkdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
-import { basename, join as join2, resolve as resolve2 } from "path";
-import { replaceFileAtomically } from "@hyperframes/core/atomic-file";
-var ID_PATH = join2(".hyperframes", "history-id");
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename, join as join3, resolve as resolve3 } from "path";
+import { replaceFileAtomically as replaceFileAtomically2 } from "@hyperframes/core/atomic-file";
+var ID_PATH = join3(".hyperframes", "history-id");
 var ID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 var isHistoryId = (name) => ID_SHAPE.test(name);
 function readId(projectDir) {
   try {
-    const id = readFileSync2(join2(projectDir, ID_PATH), "utf-8").trim();
+    const id = readFileSync4(join3(projectDir, ID_PATH), "utf-8").trim();
     return ID_SHAPE.test(id) ? id : null;
   } catch {
     return null;
@@ -390,7 +528,7 @@ function isRecordedFolder(historyDir, folder) {
 }
 function readRecord(historyDir) {
   try {
-    return JSON.parse(readFileSync2(join2(historyDir, "project.json"), "utf-8"));
+    return JSON.parse(readFileSync4(join3(historyDir, "project.json"), "utf-8"));
   } catch {
     return null;
   }
@@ -405,20 +543,20 @@ function isCopyOf0878Folder(recordedDir, id, folder) {
   return !!there && !sameFolder(there, folder) && readId(recordedDir) === id;
 }
 function projectHistoryId(projectDir, historyRoot) {
-  const dir = resolve2(projectDir);
+  const dir = resolve3(projectDir);
   const folder = statSync(dir);
   let id = readId(dir);
-  if (!id && existsSync(join2(dir, ID_PATH)))
+  if (!id && existsSync(join3(dir, ID_PATH)))
     throw new HistoryIdError(
-      `${join2(dir, ID_PATH)} holds no history id this version can read; move it aside to start anew.`
+      `${join3(dir, ID_PATH)} holds no history id this version can read; move it aside to start anew.`
     );
-  if (!id || existsSync(join2(historyRoot, id)) && !isRecordedFolder(join2(historyRoot, id), folder)) {
-    id = randomUUID3();
-    mkdirWithinProject(dir, join2(dir, ".hyperframes"));
-    writeFileSync(join2(dir, ID_PATH), `${id}
+  if (!id || existsSync(join3(historyRoot, id)) && !isRecordedFolder(join3(historyRoot, id), folder)) {
+    id = randomUUID4();
+    mkdirWithinProject(dir, join3(dir, ".hyperframes"));
+    writeFileSync2(join3(dir, ID_PATH), `${id}
 `);
   }
-  recordProject(join2(historyRoot, id), dir, folder);
+  recordProject(join3(historyRoot, id), dir, folder);
   return id;
 }
 var HistoryIdError = class extends Error {
@@ -429,89 +567,8 @@ var HistoryIdError = class extends Error {
 };
 function recordProject(historyDir, dir, folder) {
   const record = { dir, ino: folder.ino, born: folder.birthtimeMs, dev: folder.dev };
-  mkdirSync(historyDir, { recursive: true });
-  replaceFileAtomically(join2(historyDir, "project.json"), JSON.stringify(record), 420);
-}
-
-// src/history/ownerLock.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { linkSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } 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 text = readFileSync3(file, "utf-8");
-    return /^\d+$/.test(text) ? Number(text) : Number.NaN;
-  } catch (error) {
-    if (error.code === "ENOENT") return null;
-    throw error;
-  }
-}
-function claim(file) {
-  const draft = `${file}-${randomUUID4()}.tmp`;
-  writeFileSync2(draft, String(process.pid));
-  try {
-    linkSync(draft, file);
-    return true;
-  } catch (error) {
-    if (error.code !== "EEXIST") throw error;
-    return false;
-  } finally {
-    rmSync(draft, { force: true });
-  }
-}
-function releaseOwn(file) {
-  if (ownerOf(file) === process.pid) rmSync(file, { force: true });
-}
-function evictDeadOwner(file) {
-  const evictor = `${file}.evict`;
-  if (!claim(evictor)) {
-    const holder = ownerOf(evictor);
-    if (holder !== null && !alive(holder)) rmSync(evictor, { force: true });
-    return false;
-  }
-  try {
-    const pid = ownerOf(file);
-    if (pid !== null && !alive(pid)) rmSync(file, { force: true });
-    return true;
-  } finally {
-    releaseOwn(evictor);
-  }
-}
-async function takeHistoryOwnership(home, waitMs) {
-  const file = join3(home, "owner.pid");
-  const deadline = Date.now() + waitMs;
-  mkdirSync2(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));
-  }
+  mkdirSync2(historyDir, { recursive: true });
+  replaceFileAtomically2(join3(historyDir, "project.json"), JSON.stringify(record), 420);
 }
 
 // src/history/pruneHistories.ts
@@ -644,7 +701,7 @@ async function bytesIn(dir) {
 }
 function prunedWithinADay(stamp, now) {
   try {
-    const last = Number(readFileSync4(stamp, "utf-8"));
+    const last = Number(readFileSync5(stamp, "utf-8"));
     return last <= now && now - last < DAY_MS;
   } catch {
     return false;
@@ -660,10 +717,357 @@ function pruneGoneProjectHistoriesDaily(historyRoot, now, { onError, budgetMs }
   });
 }
 
+// src/history/videoState.ts
+import { createHash as createHash5, randomUUID as randomUUID6 } from "crypto";
+import { createReadStream as createReadStream2, existsSync as existsSync2, readFileSync as readFileSync7, renameSync as renameSync3, statSync as statSync3 } from "fs";
+import { isAbsolute as isAbsolute4, join as join6, resolve as resolve5 } from "path";
+import { replaceFileAtomically as replaceFileAtomically3 } from "@hyperframes/core/atomic-file";
+
+// src/history/artifactCleanup.ts
+import { createHash as createHash4 } from "crypto";
+import {
+  closeSync,
+  constants as constants2,
+  fstatSync,
+  lstatSync as lstatSync2,
+  openSync,
+  readFileSync as readFileSync6,
+  unlinkSync
+} from "fs";
+import { isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
+var kinds = ["checks", "snapshots"];
+var records = (state, kind) => [
+  ...Object.values(state[kind].revisions).flat(),
+  ...state[kind].unversioned
+];
+var protectedRevisions = (state) => /* @__PURE__ */ new Set([state.currentRevision, ...state.renders?.retainedRevisions ?? []]);
+function managedPath(projectDir, path, kind) {
+  const canonicalProject = realFilePath(resolve4(projectDir));
+  const canonicalPath = realFilePath(path);
+  const root = join5(canonicalProject, ".hyperframes", "artifacts", kind);
+  const rel = relative3(root, canonicalPath);
+  return isAbsolute3(path) && rel !== "" && rel !== ".." && !rel.startsWith(`..${sep3}`) && !isAbsolute3(rel) && pinProjectRecord(canonicalProject, relative3(canonicalProject, canonicalPath)) === canonicalPath;
+}
+function updateLatest(state) {
+  for (const kind of kinds) {
+    const available = records(state, kind).filter((record) => record.status !== "cleaned");
+    if (available.some(
+      (record) => record.id === state[kind].latest?.id && record.revision === state[kind].latest?.revision
+    ))
+      continue;
+    const latest = available.sort((a, b) => b.createdAt - a.createdAt)[0];
+    state[kind].latest = latest ? { revision: latest.revision, id: latest.id } : null;
+  }
+}
+function planArtifactCleanup(projectDir, state, render) {
+  const protectedIds = protectedRevisions(state);
+  const candidates = [];
+  const keepPaths = /* @__PURE__ */ new Set();
+  const removable = (record, path, kind) => Boolean(record.revision) && !protectedIds.has(record.revision) && record.createdAt <= render.completedAt && managedPath(projectDir, path, kind);
+  for (const kind of kinds) {
+    for (const record of records(state, kind)) {
+      const path = record.image ?? record.report;
+      if (!path || record.status === "cleaned") continue;
+      if (removable(record, path, kind)) candidates.push({ kind, record, path });
+      else keepPaths.add(realFilePath(path));
+    }
+  }
+  for (const { kind, record, path } of candidates) {
+    if (!keepPaths.has(realFilePath(path))) markCleaned(state, kind, record, path, render.id);
+  }
+  updateLatest(state);
+}
+function markCleaned(state, kind, record, path, renderId) {
+  (state.pendingArtifactCleanup ??= []).push({
+    path,
+    hash: record.contentHash,
+    revision: record.revision,
+    id: record.id,
+    kind
+  });
+  delete record.image;
+  delete record.report;
+  record.status = "cleaned";
+  record.cleanedAfterRender = renderId;
+}
+function restoreCleaned(state, item) {
+  const record = state[item.kind].revisions[item.revision]?.find(
+    (candidate) => candidate.id === item.id
+  );
+  if (record?.status !== "cleaned") return;
+  if (item.kind === "checks") record.report = item.path;
+  else record.image = item.path;
+  delete record.status;
+  delete record.cleanedAfterRender;
+}
+function stillPendingAfterUnlink(item) {
+  let descriptor;
+  try {
+    descriptor = openSync(item.path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    const stat2 = fstatSync(descriptor);
+    if (!stat2.isFile() || stat2.isSymbolicLink()) return false;
+    const hash = createHash4("sha256").update(readFileSync6(descriptor)).digest("hex");
+    if (hash !== item.hash) return false;
+    const current = lstatSync2(item.path);
+    if (current.dev !== stat2.dev || current.ino !== stat2.ino) return false;
+    unlinkSync(item.path);
+    return false;
+  } catch (error) {
+    return error.code !== "ENOENT";
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function finishArtifactCleanup(projectDir, state) {
+  const protectedIds = protectedRevisions(state);
+  const referenced = new Set(
+    kinds.flatMap(
+      (kind) => records(state, kind).flatMap((record) => record.image ?? record.report ?? []).map(realFilePath)
+    )
+  );
+  state.pendingArtifactCleanup = (state.pendingArtifactCleanup ?? []).filter((item) => {
+    if (!managedPath(projectDir, item.path, item.kind)) return false;
+    const canonicalPath = realFilePath(item.path);
+    if (protectedIds.has(item.revision)) {
+      restoreCleaned(state, item);
+      return false;
+    }
+    if (state.pendingChanges) return true;
+    if (referenced.has(canonicalPath)) return false;
+    return stillPendingAfterUnlink({ ...item, path: canonicalPath });
+  });
+  updateLatest(state);
+}
+
+// src/history/videoState.ts
+function statePath(dir) {
+  const path = pinProjectRecord(dir, ".hyperframes/video-state.json");
+  if (!path) throw new Error("Video state must stay inside the project.");
+  return path;
+}
+var collection = () => ({ latest: null, revisions: {}, unversioned: [] });
+var emptyState = () => ({
+  version: 1,
+  historyId: null,
+  currentRevision: null,
+  pendingChanges: true,
+  files: {},
+  revisions: {},
+  checks: collection(),
+  snapshots: collection()
+});
+function readState(dir) {
+  if (!existsSync2(statePath(dir))) return emptyState();
+  const state = JSON.parse(readFileSync7(statePath(dir), "utf8"));
+  if (state.version !== 1 || !state.checks || !state.snapshots || !state.revisions || !state.files)
+    throw new Error("Unsupported video-state schema.");
+  return state;
+}
+async function updateState(dir, update) {
+  const lock = pinProjectRecord(dir, ".hyperframes/video-state-lock");
+  if (!lock) throw new Error("Video state lock must stay inside the project.");
+  const release = await takeHistoryOwnership(lock, 5e3);
+  try {
+    let state;
+    try {
+      state = readState(dir);
+    } catch (error) {
+      if (!(error instanceof SyntaxError)) throw error;
+      renameSync3(statePath(dir), `${statePath(dir)}.invalid-${randomUUID6()}`);
+      state = emptyState();
+    }
+    update(state);
+    replaceFileAtomically3(statePath(dir), JSON.stringify(state, null, 2) + "\n", 420);
+  } finally {
+    release();
+  }
+}
+async function writeHistoryState(projectDir, historyId, historyDirectory, entries, currentFiles, committedFiles) {
+  const blob = (hash) => hash === null ? null : resolve5(historyDirectory, "blobs", hash.slice(0, 2), hash);
+  await updateState(projectDir, (state) => {
+    if (state.historyId && state.historyId !== historyId) {
+      state.checks = collection();
+      state.snapshots = collection();
+    }
+    state.historyId = historyId;
+    state.currentRevision = entries.at(-1)?.id ?? null;
+    state.pendingChanges = currentFiles.size !== committedFiles.size || [...currentFiles].some(([path, hash]) => committedFiles.get(path) !== hash);
+    state.files = Object.fromEntries(
+      [...currentFiles].map(([path, hash]) => [path, { hash, content: blob(hash) }])
+    );
+    state.revisions = Object.fromEntries(
+      entries.map((entry) => [entry.id, revisionState(entry, blob)])
+    );
+    dropArtifactsOfGoneRevisions(state);
+  });
+}
+function revisionState(entry, blob) {
+  const targets = entry.targets?.filter(
+    (target) => entry.files.some((file) => file.path === target.file)
+  );
+  return {
+    actor: entry.who,
+    ...targets?.length && { targets },
+    label: entry.label,
+    startedAt: entry.startedAt,
+    endedAt: entry.endedAt,
+    ...entry.undoes && { undoes: entry.undoes },
+    ...entry.restoredTo && { restoredTo: entry.restoredTo },
+    files: Object.fromEntries(
+      entry.files.map((file) => [
+        file.path,
+        { before: blob(file.before), after: blob(file.after) }
+      ])
+    )
+  };
+}
+function dropArtifactsOfGoneRevisions(state) {
+  const kept = (revision) => Boolean(state.revisions[revision]) || Boolean(state.renders?.retainedRevisions?.includes(revision));
+  for (const artifacts of [state.checks, state.snapshots]) {
+    for (const revision of Object.keys(artifacts.revisions)) {
+      if (!kept(revision)) delete artifacts.revisions[revision];
+    }
+    if (artifacts.latest?.revision && !state.revisions[artifacts.latest.revision])
+      artifacts.latest = null;
+  }
+}
+async function fileHashes(dir) {
+  const files = {};
+  for (const { path } of listProjectFiles(dir).sort((a, b) => a.path.localeCompare(b.path))) {
+    const hash = createHash5("sha256");
+    for await (const chunk of createReadStream2(join6(dir, path))) hash.update(chunk);
+    files[path] = hash.digest("hex");
+  }
+  return files;
+}
+async function beginArtifactCapture(projectDir) {
+  const files = await fileHashes(projectDir);
+  const state = readState(projectDir);
+  const matches = state.historyId !== null && readId(projectDir) === state.historyId && !state.pendingChanges && Object.entries(state.files).every(([path, file]) => files[path] === file.hash) && Object.keys(files).filter((path) => !path.split("/").some((part) => part.startsWith("."))).every((path) => state.files[path]?.hash === files[path]);
+  return {
+    revision: matches ? state.currentRevision : null,
+    fingerprint: createHash5("sha256").update(JSON.stringify(files)).digest("hex")
+  };
+}
+async function recordArtifact(projectDir, capture, artifact) {
+  return recordArtifacts(projectDir, capture, [artifact]);
+}
+async function recordArtifacts(projectDir, capture, artifactsToRecord) {
+  const records2 = [];
+  const hashes = /* @__PURE__ */ new Map();
+  for (const artifact of artifactsToRecord) {
+    const path = artifact.kind === "check" ? artifact.report : artifact.image;
+    if (!path || !isAbsolute4(path)) throw new Error("Artifact needs an absolute output path.");
+    hashes.set(artifact.id, createHash5("sha256").update(readFileSync7(path)).digest("hex"));
+  }
+  const after = await beginArtifactCapture(projectDir);
+  const unchanged = after.fingerprint === capture.fingerprint;
+  await updateState(projectDir, (state) => {
+    const revision = unchanged ? knownRevision(state, capture.revision) : null;
+    const attribution = attributionOf(unchanged, revision);
+    for (const artifact of artifactsToRecord) {
+      const { kind, ...fields } = artifact;
+      const record = {
+        ...fields,
+        createdAt: Date.now(),
+        contentHash: hashes.get(artifact.id),
+        revision,
+        inputFingerprint: capture.fingerprint,
+        inputScope: "local-project-files",
+        attribution
+      };
+      const artifacts = kind === "check" ? state.checks : state.snapshots;
+      dropSupersededArtifacts(artifacts, artifact);
+      const list = revision ? artifacts.revisions[revision] ??= [] : artifacts.unversioned;
+      list.push(record);
+      records2.push(record);
+      artifacts.latest = { revision, id: record.id };
+    }
+  });
+  return records2;
+}
+function knownRevision(state, revision) {
+  return revision && state.revisions[revision] ? revision : null;
+}
+function attributionOf(unchanged, revision) {
+  if (!unchanged) return "inputs-changed";
+  return revision ? "recorded-revision" : "unversioned";
+}
+function supersedes(artifact, previous) {
+  if (previous.status !== "cleaned" && !existsSync2(previous.image ?? previous.report ?? ""))
+    return true;
+  if (previous.id === artifact.id) return true;
+  if (artifact.image && previous.image === artifact.image) return true;
+  return Boolean(artifact.report && previous.report === artifact.report);
+}
+function dropSupersededArtifacts(artifacts, artifact) {
+  for (const list of [...Object.values(artifacts.revisions), artifacts.unversioned]) {
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (supersedes(artifact, list[i])) list.splice(i, 1);
+    }
+  }
+}
+function listsOf(artifacts) {
+  return [...Object.values(artifacts.revisions), artifacts.unversioned];
+}
+async function forgetRecordedArtifacts(projectDir, paths) {
+  const gone = new Set(paths.map((path) => resolve5(path)));
+  if (gone.size === 0) return;
+  await updateState(projectDir, (state) => {
+    for (const artifacts of [state.checks, state.snapshots]) {
+      for (const list of listsOf(artifacts)) {
+        for (let i = list.length - 1; i >= 0; i--) {
+          const record = list[i];
+          const path = record.image ?? record.report;
+          if (path && gone.has(resolve5(path))) list.splice(i, 1);
+        }
+      }
+      if (artifacts.latest && !listsOf(artifacts).some(
+        (list) => list.some((record) => record.id === artifacts.latest?.id)
+      )) {
+        artifacts.latest = null;
+      }
+    }
+  });
+}
+function artifactDirectory(projectDir, kind) {
+  return join6(resolve5(projectDir), ".hyperframes", "artifacts", kind, randomUUID6());
+}
+function retainRevision(retained, revision) {
+  if (!revision) return [...retained];
+  return [revision, ...retained.filter((id) => id !== revision)].slice(0, 2);
+}
+async function recordRenderSuccess(projectDir, output, status = "completed", capture) {
+  const outputFile = statSync3(output);
+  if (!outputFile.isFile() && !outputFile.isDirectory() || outputFile.isFile() && outputFile.size === 0)
+    throw new Error("Render output is missing or empty.");
+  const after = capture ? await beginArtifactCapture(projectDir) : null;
+  const record = {
+    id: randomUUID6(),
+    completedAt: Date.now(),
+    output: resolve5(output),
+    status
+  };
+  const unchanged = Boolean(capture && after?.fingerprint === capture.fingerprint);
+  await updateState(projectDir, (state) => {
+    record.revision = unchanged ? knownRevision(state, capture?.revision) : null;
+    state.renders = {
+      latest: record,
+      retainedRevisions: retainRevision(state.renders?.retainedRevisions ?? [], record.revision)
+    };
+    if (outputFile.isFile() && record.revision && !state.pendingChanges)
+      planArtifactCleanup(projectDir, state, record);
+  });
+  await updateState(projectDir, (state) => {
+    finishArtifactCleanup(projectDir, state);
+  });
+  return record;
+}
+
 // src/history/historyLog.ts
-import { closeSync, constants as constants2, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync5, writeSync } from "fs";
+import { closeSync as closeSync2, constants as constants3, mkdirSync as mkdirSync3, openSync as openSync2, readFileSync as readFileSync8, writeSync } from "fs";
 import { dirname as dirname3 } from "path";
-import { replaceFileAtomically as replaceFileAtomically2 } from "@hyperframes/core/atomic-file";
+import { replaceFileAtomically as replaceFileAtomically4 } from "@hyperframes/core/atomic-file";
 var START = "start";
 function parseRecord(line) {
   try {
@@ -675,7 +1079,7 @@ function parseRecord(line) {
 function readLog(file, onUnreadable) {
   let text;
   try {
-    text = readFileSync5(file, "utf-8");
+    text = readFileSync8(file, "utf-8");
   } catch {
     return null;
   }
@@ -699,7 +1103,7 @@ function applyRecord(log, record) {
 function saveRecord(file, log, record) {
   let fd;
   try {
-    fd = openSync(file, constants2.O_WRONLY | constants2.O_APPEND);
+    fd = openSync2(file, constants3.O_WRONLY | constants3.O_APPEND);
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
     return writeLog(file, log);
@@ -708,7 +1112,7 @@ function saveRecord(file, log, record) {
     writeSync(fd, `${JSON.stringify(record)}
 `);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function baselineRecord(log) {
@@ -719,30 +1123,30 @@ function baselineRecord(log) {
   };
 }
 function writeLog(file, log) {
-  const records = [
+  const records2 = [
     baselineRecord(log),
     ...log.entries.map((entry) => ({ type: "entry", entry })),
     ...[...log.pins].map((id) => ({ type: "pin", id, pinned: true }))
   ];
   mkdirSync3(dirname3(file), { recursive: true });
-  replaceFileAtomically2(file, records.map((r) => `${JSON.stringify(r)}
+  replaceFileAtomically4(file, records2.map((r) => `${JSON.stringify(r)}
 `).join(""), 420);
 }
-function applyEntry(manifest, entry, side) {
+function applyEntry(manifest2, 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);
+    if (hash === null) manifest2.delete(file.path);
+    else manifest2.set(file.path, hash);
   }
 }
 function manifestAt(log, point) {
   return point === START ? new Map(log.baseline) : manifestAround(log, point, "after");
 }
 function manifestAround(log, id, side) {
-  const manifest = new Map(log.baseline);
+  const manifest2 = new Map(log.baseline);
   for (const entry of log.entries) {
-    applyEntry(manifest, entry, entry.id === id ? side : "after");
-    if (entry.id === id) return manifest;
+    applyEntry(manifest2, entry, entry.id === id ? side : "after");
+    if (entry.id === id) return manifest2;
   }
   return null;
 }
@@ -797,7 +1201,7 @@ function referencedHashes(log, current) {
 }
 
 // src/history/projectHistory.ts
-var DEFAULT_HISTORY_ROOT = join5(homedir(), ".cache", "hyperframes", "history");
+var DEFAULT_HISTORY_ROOT = join7(homedir(), ".cache", "hyperframes", "history");
 var MAX_WINDOW_IDLE_MS = 10 * 6e4;
 var UNDO_MODES = ["just-this", "back-to-before", "keep-later-edits"];
 var OUTSIDE = { kind: "outside", name: "Outside" };
@@ -810,7 +1214,7 @@ function isHistoryPath(path) {
   if (KEPT_HIDDEN_PATHS.has(path)) return true;
   return !path.split("/").some((segment) => segment.startsWith("."));
 }
-var logFileIn = (home) => join5(home, "log.jsonl");
+var logFileIn = (home) => join7(home, "log.jsonl");
 function listOf(log) {
   const undone = undoneIds(log.entries);
   return log.entries.map((entry) => ({
@@ -850,20 +1254,20 @@ async function removeEmptyFolders(dir) {
     throw error;
   }
   for (const entry of entries)
-    if (entry.isDirectory()) await removeEmptyFolders(join5(dir, entry.name));
+    if (entry.isDirectory()) await removeEmptyFolders(join7(dir, entry.name));
   await rmdir(dir);
 }
 function fileLeftIn(dir, at, deleted) {
   for (const entry of readdirSync3(dir, { withFileTypes: true })) {
     const path = `${at}/${entry.name}`;
-    const left = entry.isDirectory() ? fileLeftIn(join5(dir, entry.name), path, deleted) : deleted.has(path) ? void 0 : path;
+    const left = entry.isDirectory() ? fileLeftIn(join7(dir, entry.name), path, deleted) : deleted.has(path) ? void 0 : path;
     if (left) return left;
   }
   return void 0;
 }
 function ignoresCase(dir) {
-  const self = statSync3(join5(dir, ID_PATH), { throwIfNoEntry: false });
-  const other = statSync3(join5(dir, ID_PATH.toUpperCase()), { throwIfNoEntry: false });
+  const self = statSync4(join7(dir, ID_PATH), { throwIfNoEntry: false });
+  const other = statSync4(join7(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}/`);
@@ -886,15 +1290,24 @@ function addChange(group, path, before, after) {
   if (from === after) group.changes.delete(path);
   else group.changes.set(path, { path, before: from, after });
 }
+var targetKey = (target) => JSON.stringify([target.file, target.id, target.hfId, target.selector, target.selectorIndex]);
+function keepTargetsOfItsFiles(entry) {
+  const targets = entry.targets?.filter(
+    (target) => entry.files.some((file) => file.path === target.file)
+  );
+  if (targets?.length) entry.targets = targets;
+  else delete entry.targets;
+  return entry;
+}
 var Engine = class {
   constructor(options, projectId, blobs) {
     this.options = options;
     this.projectId = projectId;
     this.blobs = blobs;
-    this.dir = resolve3(options.projectDir);
-    this.home = join5(options.historyRoot, projectId);
+    this.dir = resolve6(options.projectDir);
+    this.home = join7(options.historyRoot, projectId);
     this.foldsCase = ignoresCase(this.dir);
-    const folder = statSync3(this.dir, { throwIfNoEntry: false });
+    const folder = statSync4(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 };
@@ -938,13 +1351,28 @@ var Engine = class {
   queue(task) {
     if (this.closed)
       return Promise.reject(new HistoryClosedError("This project's history is closed."));
-    const run = this.tail.then(task);
+    const run = this.tail.then(async () => {
+      try {
+        return await task();
+      } finally {
+        if (this.whereFolder() === "here") {
+          await writeHistoryState(
+            this.dir,
+            this.projectId,
+            this.home,
+            this.log.entries,
+            this.manifest(),
+            manifestAt(this.log, this.log.entries.at(-1)?.id ?? START) ?? /* @__PURE__ */ new Map()
+          ).catch((error) => this.options.onError?.(error));
+        }
+      }
+    });
     this.tail = run.catch(() => void 0);
     return run;
   }
   /** Another project if the folder or its id changed, or the id is gone: a recreated folder may reuse the inode. */
   whereFolder() {
-    const now = statSync3(this.dir, { throwIfNoEntry: false });
+    const now = statSync4(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";
@@ -957,7 +1385,7 @@ var Engine = class {
   persistLog(record) {
     if (record) saveRecord(this.logFile, this.log, record);
     else writeLog(this.logFile, this.log);
-    if (!existsSync2(join5(this.home, "project.json")))
+    if (!existsSync3(join7(this.home, "project.json")))
       recordProject(this.home, this.dir, this.folder);
   }
   replaced() {
@@ -996,7 +1424,7 @@ var Engine = class {
       if (!after || !affectsProjectSignature(realDir, absPath)) return;
       const replaced = hashOfVersion(fileContentVersion(bytes));
       if (!replaced || replaced === after) return;
-      const path = relative2(realDir, absPath).split(sep2).join("/");
+      const path = relative4(realDir, absPath).split(sep4).join("/");
       if (!isHistoryPath(path)) return;
       this.overwritten.set(
         path,
@@ -1008,7 +1436,7 @@ var Engine = class {
     });
   }
   async storeBytes(bytes) {
-    const staged = join5(this.home, `overwrote-${randomUUID6()}`);
+    const staged = join7(this.home, `overwrote-${randomUUID7()}`);
     await mkdir2(this.home, { recursive: true });
     await writeFile(staged, bytes);
     try {
@@ -1062,10 +1490,10 @@ var Engine = class {
     this.saveAdopting();
   }
   saveAdopting() {
-    const file = join5(this.home, "adopting.json");
+    const file = join7(this.home, "adopting.json");
     if (!this.adopting.size) return rmSync2(file, { force: true });
     mkdirSync4(this.home, { recursive: true });
-    replaceFileAtomically3(file, JSON.stringify([...this.adopting.keys()]), 420);
+    replaceFileAtomically5(file, JSON.stringify([...this.adopting.keys()]), 420);
   }
   async adopt(file, sweptAt) {
     try {
@@ -1098,7 +1526,7 @@ var Engine = class {
   }
   readStatCache() {
     try {
-      const files = JSON.parse(readFileSync6(join5(this.home, "stat.json"), "utf-8"));
+      const files = JSON.parse(readFileSync9(join7(this.home, "stat.json"), "utf-8"));
       return new Map(Object.entries(files));
     } catch {
       return /* @__PURE__ */ new Map();
@@ -1107,7 +1535,7 @@ var Engine = class {
   readAdopting() {
     try {
       return new Set(
-        JSON.parse(readFileSync6(join5(this.home, "adopting.json"), "utf-8"))
+        JSON.parse(readFileSync9(join7(this.home, "adopting.json"), "utf-8"))
       );
     } catch {
       return /* @__PURE__ */ new Set();
@@ -1116,7 +1544,7 @@ var Engine = class {
   saveStatCache() {
     const files = JSON.stringify(Object.fromEntries(this.tracked));
     mkdirSync4(this.home, { recursive: true });
-    replaceFileAtomically3(join5(this.home, "stat.json"), files, 420);
+    replaceFileAtomically5(join7(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
@@ -1158,7 +1586,7 @@ var Engine = class {
   /** 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(join5(this.dir, path));
+      return await this.blobs.put(join7(this.dir, path));
     } catch (error) {
       if (error.code === "ENOENT") return null;
       throw error;
@@ -1184,7 +1612,7 @@ var Engine = class {
     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 = {} }) {
+  async claimNow(who, label, paths, { coalesceKey, idleMs, overwrote = {}, targets = [] }) {
     await this.sweep();
     const taken = await this.takeClaimed(who, paths, overwrote);
     if (!taken.length) return this.claimNothing(coalesceKey);
@@ -1193,10 +1621,19 @@ var Engine = class {
     await this.commitPending();
     const group = held ?? this.newGroup(who, label);
     for (const change of taken) addChange(group, change.path, change.before, change.after);
+    this.addTargets(group, targets);
     if (coalesceKey) return this.holdClaim(group, coalesceKey, idleMs);
     const entry = await this.commit(group);
     return entry && { id: entry.id };
   }
+  addTargets(group, targets) {
+    const unique = new Map((group.targets ?? []).map((target) => [targetKey(target), target]));
+    for (const target of targets) {
+      const normalized = { ...target, file: this.logPath(target.file) };
+      if (group.changes.has(normalized.file)) unique.set(targetKey(normalized), normalized);
+    }
+    group.targets = [...unique.values()];
+  }
   /** A claim that took nothing still ends a held claim under another key. */
   async claimNothing(coalesceKey) {
     if (coalesceKey !== this.claimed?.key) await this.commitClaim();
@@ -1223,7 +1660,7 @@ var Engine = class {
     return group && taken.every((change) => after(change.path, change.before) === change.before) && [...group.changes.values()].every(untouched) ? group : null;
   }
   logPath(path) {
-    return relative2(this.dir, resolve3(this.dir, path)).split(sep2).join("/");
+    return relative4(this.dir, resolve6(this.dir, path)).split(sep4).join("/");
   }
   /** Takes `paths`' uncommitted changes from others, cut at what `who` overwrote. */
   async takeClaimed(who, paths, overwrote) {
@@ -1314,7 +1751,7 @@ var Engine = class {
     return this.outside;
   }
   newGroup(who, label) {
-    return { id: randomUUID6(), who, label, startedAt: this.now(), changes: /* @__PURE__ */ new Map() };
+    return { id: randomUUID7(), who, label, startedAt: this.now(), changes: /* @__PURE__ */ new Map() };
   }
   async commitOutside() {
     if (this.outside?.changes.size) await this.commitClaim();
@@ -1329,7 +1766,7 @@ var Engine = class {
     if (!group.changes.size && !undoesEmptied) return null;
     const pending = this.pendingEntry(group);
     const endedAt = Math.max(pending.endedAt, this.log.entries.at(-1)?.endedAt ?? 0);
-    const entry = { ...pending, endedAt, ...extra };
+    const entry = keepTargetsOfItsFiles({ ...pending, endedAt, ...extra });
     this.log.entries.push(entry);
     try {
       this.persistLog({ type: "entry", entry });
@@ -1384,9 +1821,9 @@ var Engine = class {
   }
   /** A watcher saw a write: one sweep per burst takes it in (a deleted folder is reported by its name alone). */
   noteChange(path) {
-    const absolute = resolve3(this.dir, path);
+    const absolute = resolve6(this.dir, path);
     if (this.notedTimer || !affectsProjectSignature(this.dir, absolute)) return;
-    if (!isHistoryPath(relative2(this.dir, absolute).split(sep2).join("/"))) return;
+    if (!isHistoryPath(relative4(this.dir, absolute).split(sep4).join("/"))) return;
     this.notedTimer = setTimeout(() => {
       this.notedTimer = null;
       this.background(() => this.sweep());
@@ -1398,9 +1835,19 @@ var Engine = class {
       if (!(error instanceof HistoryClosedError)) this.options.onError?.(error);
     });
   }
-  beginWindow(who, label, idleMs) {
+  beginWindow(who, label, idleMs, exclusive = false) {
     return this.queue(async () => {
       await this.settle();
+      const at = this.now();
+      if (exclusive) {
+        const blocking = this.windows.find(
+          (open) => !sameWho(open.who, who) && takesWrite(open, at)
+        );
+        if (blocking)
+          throw new Error(`${blocking.who.name}'s turn is open; it has to end before yours begins`);
+        for (const open of [...this.windows])
+          if (!takesWrite(open, at) || sameWho(open.who, who)) await this.endWindow(open);
+      }
       const window = { ...this.newGroup(who, label), idleMs };
       this.windows.push(window);
       this.touch(window, this.now());
@@ -1452,7 +1899,7 @@ var Engine = class {
     const parts = path.split("/");
     for (let depth = 1; depth <= parts.length; depth += 1) {
       const at = parts.slice(0, depth).join("/");
-      const stat2 = lstatSync2(join5(this.dir, at), { throwIfNoEntry: false });
+      const stat2 = lstatSync3(join7(this.dir, at), { throwIfNoEntry: false });
       if (!stat2) return void 0;
       if (at === path || !stat2.isDirectory()) return { at, stat: stat2 };
     }
@@ -1464,8 +1911,8 @@ var Engine = class {
     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(join5(this.dir, standing.at));
-    const at = relative2(realpathSync.native(this.dir), real).split(sep2).join("/");
+    const real = realpathSync.native(join7(this.dir, standing.at));
+    const at = relative4(realpathSync.native(this.dir), real).split(sep4).join("/");
     if (standing.at !== path) return deleted.has(at) ? void 0 : at;
     return fileLeftIn(real, at, deleted);
   }
@@ -1489,7 +1936,7 @@ var Engine = class {
   /** 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 = join5(this.dir, path);
+    const absPath = join7(this.dir, path);
     const { writeToken } = this;
     if (writeToken) {
       const version = hash === null ? DELETED_VERSION : hashVersion(hash);
@@ -1530,7 +1977,10 @@ var Engine = class {
     );
     return {
       ok: true,
-      entry: await this.writeAs(who, this.undoLabel(entry), target, { undoes: id })
+      entry: await this.writeAs(who, this.undoLabel(entry), target, {
+        undoes: id,
+        ...entry.targets && { targets: entry.targets }
+      })
     };
   }
   movedOn(entry) {
@@ -1554,7 +2004,15 @@ var Engine = class {
   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 };
+    return {
+      id,
+      who,
+      label,
+      startedAt,
+      endedAt: lastWriteAt ?? this.now(),
+      files,
+      ...group.targets?.length && { targets: group.targets }
+    };
   }
   conflict(entry, changed) {
     const paths = new Set(changed.map((file) => file.path));
@@ -1589,7 +2047,12 @@ var Engine = class {
   api() {
     return {
       projectId: this.projectId,
-      beginWindow: (who, label, options = {}) => this.beginWindow(who, label, options.idleMs ?? this.options.maxGroupMs ?? 3e4),
+      beginWindow: (who, label, options = {}) => this.beginWindow(
+        who,
+        label,
+        options.idleMs ?? this.options.maxGroupMs ?? 3e4,
+        options.exclusive === true
+      ),
       claim: async (who, label, paths, options = {}) => {
         await Promise.all(paths.map((path) => this.adopting.get(this.logPath(path))));
         return this.queue(() => this.claimNow(who, label, paths, options));
@@ -1616,18 +2079,18 @@ var Engine = class {
       },
       checkout: (entryId, side, emptyDir) => this.queue(async () => {
         this.entry(entryId);
-        if (!existsSync2(this.dir)) throw new Error(`The project folder is gone: ${this.dir}`);
-        const dest = resolve3(emptyDir);
+        if (!existsSync3(this.dir)) throw new Error(`The project folder is gone: ${this.dir}`);
+        const dest = resolve6(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, join5(dest, path));
+          for (const [path, hash] of files) await this.blobs.writeTo(hash, join7(dest, path));
         } catch (error) {
           for (const name of await readdir3(dest).catch(() => []))
-            await rm3(join5(dest, name), { recursive: true, force: true });
+            await rm3(join7(dest, name), { recursive: true, force: true });
           throw error;
         }
       }),
@@ -1650,6 +2113,7 @@ var Engine = class {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
       },
+      checkpoint: () => this.queue(() => this.settle()),
       flush: () => this.queue(() => this.settleAll()),
       replacedAtPath: () => this.whereFolder() === "replaced",
       close: () => this.closing ??= (async () => {
@@ -1664,10 +2128,10 @@ var Engine = class {
   }
 };
 function isWithin(dir, path) {
-  let probe = resolve3(path);
-  while (!existsSync2(probe) && dirname4(probe) !== probe) probe = dirname4(probe);
-  const rel = relative2(realpathSync.native(dir), realpathSync.native(probe));
-  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
+  let probe = resolve6(path);
+  while (!existsSync3(probe) && dirname4(probe) !== probe) probe = dirname4(probe);
+  const rel = relative4(realpathSync.native(dir), realpathSync.native(probe));
+  return rel === "" || rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute5(rel);
 }
 function missingIsEmpty(error) {
   if (error.code === "ENOENT") return [];
@@ -1680,16 +2144,17 @@ var HistoryClosedError = class extends Error {
   }
 };
 async function openProjectHistory(options) {
-  if (!existsSync2(options.projectDir))
+  if (!existsSync3(options.projectDir))
     throw new HistoryClosedError(`${options.projectDir} is gone or now another project.`);
   const projectId = projectHistoryId(options.projectDir, options.historyRoot);
   const release = await takeHistoryOwnership(
-    join5(options.historyRoot, projectId),
+    join7(options.historyRoot, projectId),
     options.ownerWaitMs ?? 5e3
   );
   try {
-    const blobs = await openBlobStore(join5(options.historyRoot, projectId, "blobs"));
-    const engine = new Engine(options, projectId, blobs);
+    const blobs = await openBlobStore(join7(options.historyRoot, projectId, "blobs"));
+    const closedWindow = options.closedWindowAfterOwnership?.() ?? options.closedWindow;
+    const engine = new Engine({ ...options, closedWindow }, projectId, blobs);
     await engine.queue(async () => {
       await engine.start();
       engine.hearWrites();
@@ -1709,9 +2174,9 @@ async function openProjectHistory(options) {
   }
 }
 function readProjectHistory(options) {
-  const dir = resolve3(options.projectDir);
+  const dir = resolve6(options.projectDir);
   const id = readId(dir);
-  const home = id && isRecordedFolder(join5(options.historyRoot, id), statSync3(dir)) ? join5(options.historyRoot, id) : null;
+  const home = id && isRecordedFolder(join7(options.historyRoot, id), statSync4(dir)) ? join7(options.historyRoot, id) : null;
   const read = home && readLog(logFileIn(home), () => {
   });
   const log = withoutHiddenPaths(read || { baseline: /* @__PURE__ */ new Map(), entries: [], pins: /* @__PURE__ */ new Set() });
@@ -1720,7 +2185,7 @@ function readProjectHistory(options) {
     peek: (point) => peekOf(log, point),
     readBlob: async (hash) => {
       if (!home) throw new Error("That is not a history blob.");
-      return readBlob(join5(home, "blobs"), hash);
+      return readBlob(join7(home, "blobs"), hash);
     }
   };
 }
@@ -1750,6 +2215,8 @@ function historyCache(open) {
 }
 
 export {
+  HistoryBusyError,
+  registerRenderOutput,
   STUDIO_SIGNATURE_MANIFEST_PATHS,
   affectsProjectSignature,
   resolveProjectSignature,
@@ -1764,9 +2231,14 @@ export {
   identifyFileWrite,
   consumeFileWriteReceipt,
   HistoryIdError,
-  HistoryBusyError,
   listProjectHistories,
   pruneGoneProjectHistories,
+  beginArtifactCapture,
+  recordArtifact,
+  recordArtifacts,
+  forgetRecordedArtifacts,
+  artifactDirectory,
+  recordRenderSuccess,
   START,
   DEFAULT_HISTORY_ROOT,
   MAX_WINDOW_IDLE_MS,