@panphora/clayjs 1.16.0 → 1.18.0

package/src/plugins/live.js

@@ -8,8 +8,8 @@
 import { contains, parseBy, frameSet, descendants, unionRanges, formatBy } from "../live/provenance.js";
 import { createStore } from "../live/store.js";
 import { serializeLive, stampOf, parseStamp, textHash } from "../live/ops.js";
-import { onSnapshot } from "../core/snapshot.js";
-import { onSaveAccepted, onSaveAttempt, onSaveOutcome, isSaveInProgress } from "../core/save-core.js";
+import { capturePageState, onSnapshot } from "../core/snapshot.js";
+import { onSaveAccepted, onSaveAttempt, onSaveOutcome, isSaveInProgress, saveFateIsUnknown, exitSave } from "../core/save-core.js";
 import { savePageForce, baselineSettled, isSaveConflicted, autosaveIsSuspended } from "../core/save.js";
 import { withKeepalive } from "../core/save-core.js";
 import { isEditMode } from "../core/is-edit-mode.js";
@@ -17,13 +17,13 @@ import { registerUnsavedState } from "../lib/unsaved-state.js";
 import { createCheckpoints } from "../live/checkpoint.js";
 import { parseJsonRelaxed } from "../vendor/hyper-morph-json.vendor.js";
 import * as hostMeta from "../core/host-meta.js";
-import { createFastLane } from "../live/fast-lane.js";
 import { createSaveHistoryRecovery, RECOVERY_WINDOW_MS } from "../live/save-history.js";
 import { serverTransport } from "../live/server-lane.js";
-import { localTransport, localLaneSupported } from "../live/local-lane.js";
 import { captureYValue } from "../page/ybind/parts.js";
 import { lastSeenEtag, recordEtag } from "../core/etag.js";
 
+const lanes = () => Promise.all([import("../live/fast-lane.js"), import("../live/local-lane.js")]).then(([f, l]) => ({ createFastLane: f.createFastLane, localTransport: l.localTransport, localLaneSupported: l.localLaneSupported }));
+
 const NAME = /^[A-Za-z0-9_.:-]{1,64}$/;
 const entries = new Map();
 
@@ -755,6 +755,9 @@ function seedLocalRoom() {
       if (value !== null && typeof value === "object") values.set(name, { value, ephemeral: tag.ephemeral });
     } catch {}
   }
+  for (const [name, entry] of entries) {
+    if (!entry.staged) values.set(name, { value: entry.store.authoritative, ephemeral: entry.store.ephemeral });
+  }
   return values;
 }
 
@@ -769,13 +772,22 @@ function ensureLane() {
       if (request !== laneRequest) return;
       serverLane = supported;
       provenanceHost = provenance;
+      const lane = await lanes().catch(() => null);
+      if (request !== laneRequest) return;
+      if (!lane) {
+        settleLane?.(null);
+        settleWriter?.(null);
+        return;
+      }
       if (supported) {
-        fast = createFastLane(laneOptions(serverTransport()));
-      } else if (localLaneSupported()) {
+        fast = lane.createFastLane(laneOptions(serverTransport()));
+      } else if (lane.localLaneSupported()) {
         // The document's own floor picks the channel scope: a floor-1 document
-        // never shares the lane a tab that cannot read it is on.
-        local = localTransport({ seed: seedLocalRoom, floor: document.querySelector('meta[name="clay-page-format"]')?.getAttribute("content") });
-        fast = createFastLane(laneOptions(local));
+        // never shares the lane a tab that cannot read it is on. The room scope
+        // puts this tab's sequencer in the host-mode room, which a tab of the lane
+        // before it never joins.
+        local = lane.localTransport({ seed: seedLocalRoom, rooms: true, floor: document.querySelector('meta[name="clay-page-format"]')?.getAttribute("content") });
+        fast = lane.createFastLane(laneOptions(local));
       } else {
         settleLane?.(null);
         settleWriter?.(null);
@@ -878,7 +890,9 @@ function receive(entry, text, source, dropIds) {
   } catch {
     return;
   }
-  if (entry.store.rebase(value, { source, ...(dropIds?.length && { dropIds }) })) entry.framesSince = true;
+  if (!entry.store.rebase(value, { source, ...(dropIds?.length && { dropIds }) })) return false;
+  entry.framesSince = true;
+  return true;
 }
 
 // One open store and what the plugin follows about it. A staged store has no lane.
@@ -934,11 +948,12 @@ export function live(name) {
 
 // A page whose file carries no state of its own yet: the seed in memory, no tag in
 // the document, no request, until its first genuine op is written by the ordinary
-// save. Only an accepted write opens its room.
-export function stageStore(name, { value, represented = null, signal = null } = {}) {
+// save. A value already stored by this tab or a peer can open its room.
+export function stageStore(name, { value, represented = null, signal = null, persisted = false } = {}) {
   const existing = entries.get(name);
   if (existing && !existing.staged) throw new Error(`clay.live("${name}"): the store is open in a room`);
   const entry = existing ?? openEntry(name, createStore({ name, value, ephemeral: false }), { staged: { represented, signal } });
+  if (persisted) activateStaged(entry);
   return {
     handle: entry.store.handle,
     isPending: () => !!entry.staged && entry.store.pending.length > 0,
@@ -1235,11 +1250,47 @@ onSaveOutcome(({ captureId, result, attempts, sent }) => {
   if (plan) startHistoryRecovery(plan, { result, attempts, startedAt: Date.now() });
 });
 
+// The recovery integration's turn at an accepted save, when one journals this page.
+// Registered by page code once it holds a `page.yjs` channel, so a page that journals
+// nothing loads neither the proof builder nor the conditional client, and pays one null
+// check per save.
+let pageCheckpoints = null;
+
+/**
+ * Hand every accepted save to a page checkpoint integration, or null to stop.
+ *
+ * The integration builds the proof from the capture's pinned page state and the bytes
+ * the host took; nothing here decides what is covered. Its answer is not awaited: a save
+ * that succeeded is saved whether or not a journal can be retired, and a failure there
+ * must never reach the save's own outcome.
+ *
+ * @param {?Function} install - ({capture, state, article, etag}) => unknown
+ */
+export function registerPageCheckpoints(install) {
+  pageCheckpoints = install;
+}
+
+function offerCheckpoint(captureId, html) {
+  if (!pageCheckpoints) return;
+  // Read synchronously, before this capture is released: the value is the one its page
+  // tag carried, and the edits that followed it are not in these bytes.
+  const state = capturePageState(captureId);
+  if (!state) return;
+  let article = null;
+  try { article = parseHtml(html).querySelector("article[data-page]")?.innerHTML ?? null; }
+  catch (_) { article = null; }
+  const etag = lastSeenEtag();
+  Promise.resolve()
+    .then(() => pageCheckpoints({ capture: String(captureId), state, article, etag }))
+    .catch(() => {});
+}
+
 // An accepted body confirms the ops of the capture that sent it, and only those.
 // A null context (a raw save) cannot consume a captured pin.
 function handleAccepted(html, context) {
   const captureId = context?.captureId;
   if (captureId === null || captureId === undefined) return;
+  offerCheckpoint(captureId, html);
   const pin = capturePins.get(captureId);
   if (!pin) return;
   dropCapture(captureId);
@@ -1323,9 +1374,7 @@ export function receiveFrame(html, seq = null) {
       else if (pageTag.getAttribute("live-by") !== by) pageTag.setAttribute("live-by", by);
     }
     if (entry && !entry.store.ephemeral) {
-      // An old seed is never merged into a newer article before its first write.
-      if (entry.staged) continue;
-      if (entry.store.handle.status.mode === "file") receive(entry, text, "remote", dropIds);
+      if (entry.store.handle.status.mode === "file" && receive(entry, text, "remote", dropIds)) activateStaged(entry);
       continue;
     }
     if (pageTag && pageTag.textContent !== text) pageTag.textContent = text;
@@ -1378,12 +1427,74 @@ export function fastLane() {
   return fast;
 }
 
+// The local lane's transport, for the format gate: a floor-1 document shares a
+// channel scope no tab below that floor is on, and moving this tab there is the
+// gate's call (page/format-gate.js). Null until this tab has such a lane, and a
+// gate asks again on its next retry.
+// Whether any live store of this tab holds ops the room has not confirmed. A tab with
+// none has nothing a scope switch could strand, so it may move without a receipt.
+export function lanePending() {
+  return sessionStores().some((entry) => entry.store.pending.length > 0);
+}
+
+export function localLane() {
+  return local;
+}
+
 // The page editor's pause save: checkpoint within ms of now. Only the room's
 // writer saves, so in other tabs this changes nothing.
 export function checkpointWithin(ms) {
   checkpoints.within(ms);
 }
 
+// The exit's own checkpoint: this tab's page input, saved once, under the permit the
+// exit minted and inside its deadline. It is not the background checkpoint: no timer is
+// armed and writer election is untouched, because a leave is an explicit save of this
+// tab's work, like the force save behind Cmd+S.
+//
+// One attempt per exit. A caller whose page input is still unconfirmed gets the answer
+// that names it, never a second write: an expired exit must not send anything later.
+export async function requestExitCheckpoint({ name, needsSave, permit, deadline, signal = null, keepalive = false }) {
+  const over = () => signal?.aborted || Date.now() >= deadline;
+  // Abortable, and it clears its own timer, so nothing is left waiting after the exit.
+  const pause = () => new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, 5);
+    signal?.addEventListener("abort", done, { once: true });
+  });
+  const failed = (code) => ({ ok: false, code });
+  for (;;) {
+    if (over()) return failed("timeout");
+    if (!needsSave()) return { ok: true };
+    if (isSaveConflicted()) return failed("conflict");
+    if (saveFateIsUnknown() || historyPending()) return failed("save-unknown");
+    const entry = entries.get(name);
+    if (!entry) return failed("disposed");
+    if (!baselineSettled() || isSaveInProgress()) {
+      await pause();
+      continue;
+    }
+    // A fast capture holds the room's value, so this tab's own ops have to reach the
+    // room before the capture is taken.
+    if (entry.store.handle.status.mode === "fast" && entry.store.pending.length) {
+      fast?.release(name);
+      await pause();
+      continue;
+    }
+    if (over()) return failed("timeout");
+    const save = exitSave();
+    if (!save) return failed("checkpoint-failed");
+    const result = await withKeepalive(keepalive, () => save(permit));
+    if (over()) return failed("timeout");
+    if (!result?.ok) return failed(result?.code ?? "checkpoint-failed");
+    return needsSave() ? failed("page-not-checkpointed") : { ok: true };
+  }
+}
+
 // Resolves { ok: true } once the file holds every live change this tab knows
 // of now, or { ok: false, code: "timeout" }. The writer saves as soon as it
 // can; another tab waits for the writer's save to land.

package/src/plugins/menu/actions.js

@@ -0,0 +1,196 @@
+// The menu's editing items: Undo and Redo, Ask AI, and Download a copy. Each one calls
+// the service that already does the job and keeps no second copy of its state.
+import { modeRefusalText } from "../../core/mode-refusal.js";
+import { downloadHtml, documentName } from "../../core/download.js";
+import { keys, revealLabel } from "./preferences.js";
+
+const RESUME_KEY = "menu-resume";
+const READY_MS = 5000;
+
+const clay = () => window.clay || {};
+const session = () => clay().storage && clay().storage.session;
+const pageWants = (name) => {
+  const names = clay().editPlugins;
+  return Array.isArray(names) && names.includes(name);
+};
+
+// An edit-only plugin attaches after the mode change commits, so the item waits for it
+// briefly instead of reporting it missing.
+function whenPresent(get, ms = READY_MS) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      const value = get();
+      if (value || Date.now() - start >= ms) resolve(value || null);
+      else setTimeout(tick, 50);
+    };
+    tick();
+  });
+}
+
+export function attachActions({ addItem, note, currentMode }) {
+  const resumers = new Map();
+
+  // Runs `run` in edit mode, entering it first when the page is in view. A reload entry
+  // leaves a one-shot receipt in session storage so the action runs once the page is
+  // back; a refused entry says why and runs nothing.
+  async function inEditMode(action, run) {
+    if (currentMode() === "edit") return run();
+    const storage = session();
+    if (storage) storage.set(RESUME_KEY, action);
+    let result;
+    try {
+      result = await clay().setMode?.("edit");
+    } catch (err) {
+      result = { ok: false, message: err && err.message };
+    }
+    if (result && result.ok !== false && result.reloading) return;
+    if (storage) storage.remove(RESUME_KEY);
+    if (!result || result.ok === false) {
+      const text = result ? modeRefusalText(result) : "Couldn't switch modes.";
+      if (text) note(text);
+      return;
+    }
+    return run();
+  }
+
+  function resumable(action, run) {
+    resumers.set(action, run);
+    return () => inEditMode(action, run);
+  }
+
+  let history = { canUndo: false, canRedo: false };
+  let heard = false;
+
+  function renderUndo() {
+    if (!pageWants("undo")) return;
+    const live = currentMode() === "edit" && clay().undo;
+    // The menu loads late, so edits made before it are read from the service itself.
+    if (!heard && live && typeof live.canUndo === "boolean") history = { canUndo: live.canUndo, canRedo: !!live.canRedo };
+    addItem({
+      id: "clay.undo",
+      pair: [
+        {
+          id: "clay.undo.undo",
+          label: "Undo",
+          keys: keys("⌘Z", "Ctrl+Z"),
+          disabled: !(live && history.canUndo),
+          run: () => clay().undo?.undo(),
+        },
+        {
+          id: "clay.undo.redo",
+          label: "Redo",
+          keys: keys("⌘⇧Z", "Ctrl+Shift+Z"),
+          disabled: !(live && history.canRedo),
+          run: () => clay().undo?.redo(),
+        },
+      ],
+    });
+  }
+
+  document.addEventListener("clay:undo-change", (event) => {
+    const detail = event.detail || {};
+    heard = true;
+    history = { canUndo: !!detail.canUndo, canRedo: !!detail.canRedo };
+    renderUndo();
+  });
+  document.addEventListener("clay:modechange", renderUndo);
+  renderUndo();
+
+  if (pageWants("ai-edit")) {
+    addItem({
+      id: "clay.ai",
+      label: "Ask AI…",
+      keys: keys("⌘J", "Ctrl+J"),
+      run: resumable("ai", async () => {
+        const ai = await whenPresent(() => clay().aiEdit);
+        const opened = ai ? await ai.open(document.body) : false;
+        if (!opened) note("Ask AI isn't available on this page right now.");
+      }),
+    });
+  }
+
+  if (pageWants("cms") && clay().cms?.hasRules?.(document)) {
+    addItem({
+      id: "clay.cms",
+      label: "Open the CMS (Edit content)",
+      run: resumable("cms", async () => {
+        const cms = await whenPresent(() => clay().cms);
+        let result = null;
+        try {
+          result = cms ? await cms.open() : { ok: false };
+        } catch {
+          result = { ok: false };
+        }
+        if (result && result.ok === false) note("Couldn't open the CMS. Try again.");
+      }),
+    });
+  }
+
+  // The copy is what a save would send now, unsaved edits included. A reader has no
+  // unsaved edits, so the saved file is the same document.
+  addItem({
+    id: "clay.download",
+    label: "Download a copy",
+    run: async () => {
+      let html = null;
+      try {
+        if (typeof clay().getHTML === "function") {
+          html = clay().getHTML();
+        } else {
+          const response = await fetch(location.href, { cache: "no-store", credentials: "same-origin" });
+          if (response.ok) html = await response.text();
+        }
+      } catch {}
+      // Upload paths only resolve on this host, so the copy names them in full.
+      if (typeof html === "string" && /^https?:$/.test(location.protocol)) {
+        html = html.replace(/(^|[^\w./:-])\/_\/uploads\//g, `$1${location.origin}/_/uploads/`);
+      }
+      if (typeof html !== "string" || !downloadHtml({ html, name: `${documentName()}.html` })) {
+        note("Couldn't build the download. Try again.");
+      }
+    },
+  });
+
+  // What the host offers for this document. A page opens in a new tab so this one keeps
+  // whatever is unsaved; anything else the host does itself when asked, and may answer
+  // with a page to open (a duplicate) or a reason it could not.
+  async function askHost(url) {
+    let body = null;
+    try {
+      const response = await fetch(url, { method: "POST", credentials: "same-origin", headers: { "Document-URL": location.href } });
+      body = await response.json().catch(() => null);
+      if (response.ok && body?.ok !== false) {
+        if (typeof body?.href === "string") window.open(body.href, "_blank", "noopener");
+        return;
+      }
+    } catch {}
+    note(typeof body?.message === "string" && body.message ? body.message : "Couldn't do that. Try again.");
+  }
+
+  const hostItem = (id, label, action) => {
+    if (action?.href) addItem({ id, label, href: action.href });
+    else if (action?.post) addItem({ id, label, run: () => askHost(action.post) });
+  };
+
+  import("../../core/host-meta.js")
+    .then(({ hostActions }) => hostActions())
+    .then((host) => {
+      hostItem("clay.code", "Open the code editor", host.codeEditor);
+      hostItem("clay.duplicate", "Duplicate as a new page", host.duplicate);
+      hostItem("clay.export", "Export as zip", host.export);
+      hostItem("clay.reveal", revealLabel(), host.reveal);
+      hostItem("clay.versions", "Version history…", host.versions);
+    })
+    .catch(() => {});
+
+  const storage = session();
+  const pending = storage && storage.get(RESUME_KEY);
+  if (pending) {
+    storage.remove(RESUME_KEY);
+    const run = resumers.get(pending);
+    if (run && currentMode() === "edit") run();
+  }
+
+  return { inEditMode, resumable, refresh: renderUndo };
+}