@hyperframes/studio-server 0.8.74 → 0.8.75

package/dist/helpers/mediaProxyPreview.d.ts

@@ -1,4 +1,4 @@
-export { P as PreviewApiAdapter, m as injectMediaCodecMap, n as injectMediaCodecMapIntoHtml, p as isAutoProxyEnabled, q as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-BXtfHq7G.js';
+export { P as PreviewApiAdapter, m as injectMediaCodecMap, n as injectMediaCodecMapIntoHtml, p as isAutoProxyEnabled, q as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-FxDAeURd.js';
 import './mediaCodecMap.js';
 import '@hyperframes/core';
 import '@hyperframes/parsers';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
-import { S as StudioApiAdapter, M as MediaProcessingJobState } from './mediaProxyPreview-BXtfHq7G.js';
-export { a as HISTORY_START, H as HistoryEntry, b as HistoryFileChange, c as HistoryListItem, d as HistoryResult, e as HistoryWho, f as HistoryWindow, L as LintResult, P as PreviewApiAdapter, g as ProjectHistory, h as ProjectHistoryOptions, R as RenderJobState, i as ResolvedProject, j as StudioSelectionResponse, k as StudioSelectionSnapshot, l as StudioSelectionTextField, o as openProjectHistory } from './mediaProxyPreview-BXtfHq7G.js';
+import { S as StudioApiAdapter, M as MediaProcessingJobState } from './mediaProxyPreview-FxDAeURd.js';
+export { a as HISTORY_START, H as HistoryEntry, b as HistoryFileChange, c as HistoryListItem, d as HistoryResult, e as HistoryWho, f as HistoryWindow, L as LintResult, P as PreviewApiAdapter, g as ProjectHistory, h as ProjectHistoryOptions, R as RenderJobState, i as ResolvedProject, j as StudioSelectionResponse, k as StudioSelectionSnapshot, l as StudioSelectionTextField, o as openProjectHistory } from './mediaProxyPreview-FxDAeURd.js';
 import { SourceMutationTarget } from './helpers/sourceMutation.js';
 export { PatchOperation, dedupeClonedCompositionId, findTargetElement, parseSourceDocument, patchElementInHtml, removeElementFromHtml, splitElementInHtml } from './helpers/sourceMutation.js';
 export { ScreenshotClip, getElementScreenshotClip } from './helpers/screenshotClip.js';

package/dist/index.js

@@ -5106,8 +5106,120 @@ function registerGlobalAssetRoutes(api) {
   api.get("/assets/global", (c) => c.json({ assets: readGlobalAssets().map(toPublicAsset) }));
 }
 
+// src/history/historyLog.ts
+import { closeSync as closeSync5, constants as constants3, mkdirSync as mkdirSync7, openSync as openSync5, readFileSync as readFileSync15, writeSync as writeSync2 } from "fs";
+import { dirname as dirname5 } from "path";
+var START = "start";
+function parseRecord(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function readLog(file, onUnreadable) {
+  let text2;
+  try {
+    text2 = readFileSync15(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, constants3.O_WRONLY | constants3.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 }))
+  ];
+  mkdirSync7(dirname5(file), { recursive: true });
+  replaceFileAtomically(file, records.map((r) => `${JSON.stringify(r)}
+`).join(""), 420);
+}
+function applyEntry(manifest, entry) {
+  for (const file of entry.files)
+    if (file.after === null) manifest.delete(file.path);
+    else manifest.set(file.path, file.after);
+}
+function manifestAt(log, point) {
+  const manifest = new Map(log.baseline);
+  if (point === START) return manifest;
+  for (const entry of log.entries) {
+    applyEntry(manifest, entry);
+    if (entry.id === point) 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) {
+  const undone = undoneIds(entries);
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    const isChange = !entry.undoes;
+    if (direction === "back" && isChange && !undone.has(entry.id)) return entry;
+    if (direction !== "forward") continue;
+    if (isChange) return void 0;
+    const target = byId.get(entry.undoes);
+    if (!undone.has(entry.id) && target && !target.undoes) return entry;
+  }
+  return void 0;
+}
+function foldOldest(log) {
+  const oldest = log.entries[0];
+  if (!oldest || log.pins.has(oldest.id)) return false;
+  applyEntry(log.baseline, oldest);
+  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/routes/history.ts
 var YOU = { kind: "person", name: "You" };
+var MAX_WINDOW_IDLE_MS = 10 * 6e4;
 async function historyOf(adapter, c) {
   const project = await adapter.resolveProject(c.req.param("id") ?? "");
   return project ? await adapter.history?.(project) ?? null : null;
@@ -5117,6 +5229,16 @@ async function bodyOf(c) {
   return body && typeof body === "object" ? body : {};
 }
 var text = (value) => typeof value === "string" && value ? value : null;
+function idleOf(body) {
+  const idleMs = body.idleMs;
+  return typeof idleMs === "number" && idleMs > 0 ? Math.min(idleMs, MAX_WINDOW_IDLE_MS) : void 0;
+}
+function nextStep(entries, direction) {
+  const target = stepTarget(entries, direction);
+  if (!target) return null;
+  const paths = target.files.map((file) => file.path);
+  return { id: target.id, label: target.label, endedAt: target.endedAt, paths };
+}
 async function withHistory(adapter, c, task) {
   const history = await historyOf(adapter, c);
   if (!history) return c.json({ error: "This project has no history here." }, 404);
@@ -5129,7 +5251,13 @@ async function withHistory(adapter, c, task) {
 function registerHistoryRoutes(api, adapter) {
   const windows = /* @__PURE__ */ new Map();
   const base = "/projects/:id/history";
-  api.get(base, (c) => withHistory(adapter, c, (history) => ({ entries: history.list() })));
+  api.get(
+    base,
+    (c) => withHistory(adapter, c, (history) => {
+      const entries = history.list();
+      return { entries, back: nextStep(entries, "back"), forward: nextStep(entries, "forward") };
+    })
+  );
   api.post(
     `${base}/step`,
     (c) => withHistory(
@@ -5160,10 +5288,28 @@ function registerHistoryRoutes(api, adapter) {
       return { ok: true };
     })
   );
+  api.post(
+    `${base}/claim`,
+    (c) => withHistory(adapter, c, async (history, body) => {
+      const paths = Array.isArray(body.paths) ? body.paths.filter((path) => text(path)) : [];
+      const coalesceKey = text(body.coalesceKey) ?? void 0;
+      const idleMs = idleOf(body);
+      const claimed = await history.claim(YOU, text(body.label) ?? "Edited in Studio", paths, {
+        ...coalesceKey && { coalesceKey },
+        ...idleMs && { idleMs }
+      });
+      return { claimed };
+    })
+  );
   api.post(
     `${base}/window`,
     (c) => withHistory(adapter, c, async (history, body) => {
-      const window = await history.beginWindow(YOU, text(body.label) ?? "Edited in Studio");
+      const idleMs = idleOf(body);
+      const window = await history.beginWindow(
+        YOU,
+        text(body.label) ?? "Edited in Studio",
+        idleMs ? { idleMs } : void 0
+      );
       windows.set(window.id, { history, window });
       return { windowId: window.id };
     })
@@ -5203,23 +5349,23 @@ function createStudioApi(adapter) {
 import { randomUUID as randomUUID7 } from "crypto";
 import { rm as rm2 } from "fs/promises";
 import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync17 } from "fs";
-import { join as join17, resolve as resolve7 } from "path";
+import { join as join17, relative as relative4, resolve as resolve7, sep as sep3 } from "path";
 
 // src/history/blobStore.ts
 import { createHash as createHash5, randomUUID as randomUUID5 } from "crypto";
-import { constants as constants3, createReadStream as createReadStream2 } from "fs";
+import { constants as constants4, createReadStream as createReadStream2 } from "fs";
 import { copyFile, mkdir, readdir, readFile as readFile2, rename, rm, stat } from "fs/promises";
-import { dirname as dirname5, join as join15 } from "path";
+import { dirname as dirname6, join as join15 } from "path";
 async function hashFile(path) {
   const hash = createHash5("sha256");
   for await (const chunk of createReadStream2(path)) hash.update(chunk);
   return hash.digest("hex");
 }
 async function cloneOrCopy(from, to) {
-  await mkdir(dirname5(to), { recursive: true });
+  await mkdir(dirname6(to), { recursive: true });
   const temp = `${to}.${randomUUID5()}.tmp`;
   try {
-    await copyFile(from, temp, constants3.COPYFILE_FICLONE);
+    await copyFile(from, temp, constants4.COPYFILE_FICLONE);
     await rename(temp, to);
   } catch (error) {
     await rm(temp, { force: true });
@@ -5238,13 +5384,13 @@ async function openBlobStore(dir) {
     async put(absPath) {
       const temp = join15(dir, `incoming-${randomUUID5()}`);
       await mkdir(dir, { recursive: true });
-      await copyFile(absPath, temp, constants3.COPYFILE_FICLONE);
+      await copyFile(absPath, temp, constants4.COPYFILE_FICLONE);
       const hash = await hashFile(temp);
       if (sizes.has(hash)) {
         await rm(temp, { force: true });
         return hash;
       }
-      await mkdir(dirname5(pathOf(hash)), { recursive: true });
+      await mkdir(dirname6(pathOf(hash)), { recursive: true });
       const size = (await stat(temp)).size;
       await rename(temp, pathOf(hash));
       sizes.set(hash, size);
@@ -5268,13 +5414,13 @@ async function openBlobStore(dir) {
 
 // src/history/historyId.ts
 import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
 import { join as join16, resolve as resolve6 } from "path";
 var ID_PATH = join16(".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}$/;
 function readId(projectDir) {
   try {
-    const id = readFileSync15(join16(projectDir, ID_PATH), "utf-8").trim();
+    const id = readFileSync16(join16(projectDir, ID_PATH), "utf-8").trim();
     return ID_SHAPE.test(id) ? id : null;
   } catch {
     return null;
@@ -5282,7 +5428,7 @@ function readId(projectDir) {
 }
 function recordedDir(historyDir) {
   try {
-    return JSON.parse(readFileSync15(join16(historyDir, "project.json"), "utf-8")).dir ?? null;
+    return JSON.parse(readFileSync16(join16(historyDir, "project.json"), "utf-8")).dir ?? null;
   } catch {
     return null;
   }
@@ -5293,131 +5439,26 @@ function projectHistoryId(projectDir, historyRoot) {
   const was = id && recordedDir(join16(historyRoot, id));
   if (!id || was && was !== dir && existsSync11(was) && readId(was) === id) {
     id = randomUUID6();
-    mkdirSync7(join16(dir, ".hyperframes"), { recursive: true });
+    mkdirSync8(join16(dir, ".hyperframes"), { recursive: true });
     writeFileSync6(join16(dir, ID_PATH), `${id}
 `);
   }
-  mkdirSync7(join16(historyRoot, id), { recursive: true });
+  mkdirSync8(join16(historyRoot, id), { recursive: true });
   writeFileSync6(join16(historyRoot, id, "project.json"), JSON.stringify({ dir }));
   return id;
 }
 
-// src/history/historyLog.ts
-import { closeSync as closeSync5, constants as constants4, mkdirSync as mkdirSync8, openSync as openSync5, readFileSync as readFileSync16, writeSync as writeSync2 } from "fs";
-import { dirname as dirname6 } from "path";
-var START = "start";
-function parseRecord(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-function readLog(file, onUnreadable) {
-  let text2;
-  try {
-    text2 = readFileSync16(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 }))
-  ];
-  mkdirSync8(dirname6(file), { recursive: true });
-  replaceFileAtomically(file, records.map((r) => `${JSON.stringify(r)}
-`).join(""), 420);
-}
-function applyEntry(manifest, entry) {
-  for (const file of entry.files)
-    if (file.after === null) manifest.delete(file.path);
-    else manifest.set(file.path, file.after);
-}
-function manifestAt(log, point) {
-  const manifest = new Map(log.baseline);
-  if (point === START) return manifest;
-  for (const entry of log.entries) {
-    applyEntry(manifest, entry);
-    if (entry.id === point) 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) {
-  const undone = undoneIds(entries);
-  const byId = new Map(entries.map((entry) => [entry.id, entry]));
-  for (let i = entries.length - 1; i >= 0; i -= 1) {
-    const entry = entries[i];
-    const isChange = !entry.undoes;
-    if (direction === "back" && isChange && !undone.has(entry.id)) return entry;
-    if (direction !== "forward") continue;
-    if (isChange) return void 0;
-    const target = byId.get(entry.undoes);
-    if (!undone.has(entry.id) && target && !target.undoes) return entry;
-  }
-  return void 0;
-}
-function foldOldest(log) {
-  const oldest = log.entries[0];
-  if (!oldest || log.pins.has(oldest.id)) return false;
-  applyEntry(log.baseline, oldest);
-  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 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}`;
+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;
@@ -5435,6 +5476,8 @@ var Engine = class {
   tracked = /* @__PURE__ */ new Map();
   windows = [];
   outside = null;
+  /** A coalescing claim, open until another key, its idle timer, or an operation commits it. */
+  claimed = null;
   quietTimer;
   maxTimer;
   notedTimer = null;
@@ -5538,11 +5581,53 @@ var Engine = class {
   record(path, before, after) {
     const window = this.windows.at(-1);
     if (window) this.touch(window);
-    const group = window ?? this.outsideGroup();
-    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 });
+    addChange(window ?? this.outsideGroup(), path, before, after);
+  }
+  /**
+   * ponytail: a claim takes every uncommitted outside change to its paths, so another writer's write to the same file
+   * between Studio's write and its claim (milliseconds) folds into Studio's entry. Per-write tokens would split them.
+   * A write filed to another writer's open window stays that window's.
+   */
+  async claimNow(who, label, paths, { coalesceKey, idleMs }) {
+    await this.sweep();
+    const taken = this.takeOutside(paths);
+    if (!taken.length) return null;
+    const group = await this.claimGroup(who, label, coalesceKey);
+    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 };
+  }
+  /** The held claim when the key matches; otherwise it is committed and a new group starts. */
+  async claimGroup(who, label, key) {
+    if (key && this.claimed?.key === key) return this.claimed.group;
+    await this.commitClaim();
+    return this.newGroup(who, label);
+  }
+  /** Removes and returns the uncommitted outside changes to `paths` (project-relative or absolute). */
+  takeOutside(paths) {
+    const outside = this.outside;
+    if (!outside) return [];
+    const wanted = new Set(
+      paths.map((path) => relative4(this.dir, resolve7(this.dir, path)).split(sep3).join("/"))
+    );
+    const taken = [...outside.changes.values()].filter((change) => wanted.has(change.path));
+    for (const change of taken) outside.changes.delete(change.path);
+    return taken;
+  }
+  holdClaim(group, key, idleMs = this.options.quietMs ?? 2e3) {
+    clearTimeout(this.claimed?.timer);
+    const timer = setTimeout(() => this.background(() => this.commitClaim()), idleMs);
+    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;
@@ -5604,6 +5689,7 @@ var Engine = class {
   /** Before an operation: every write so far is filed, and the outside group is closed so it sorts first. */
   async settle() {
     await this.sweep();
+    await this.commitClaim();
     await this.commitOutside();
   }
   /** A watcher saw a write: one sweep per burst takes it in (a deleted folder is reported by its name alone). */
@@ -5652,6 +5738,7 @@ var Engine = class {
   /** 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();
   }
@@ -5723,6 +5810,7 @@ var Engine = class {
     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) => this.noteChange(path),
       list: () => {
         const undone = undoneIds(this.log.entries);