@panphora/clayjs 1.12.2 → 1.13.0

package/src/live/local-lane.js

@@ -20,6 +20,7 @@
 
 import { applyOps, applyOp, checkOp, cloneJson, validateOp, serializeLive, textHash, diffOps } from "./ops.js";
 import { HyperMorph } from "../vendor/hyper-morph.vendor.js";
+import { movesSince } from "./moves.js";
 
 const VERSION = 4;
 export const REQUEST_MS = 2000;
@@ -118,14 +119,20 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
 
   const landedIn = (m) => (m.behind || m.landed === null ? -1 : m.landed);
 
-  function roomState() {
+  function roomState(since = null) {
     const stores = {};
     const meta = {};
     for (const [name, m] of mirror.stores) {
       stores[name] = { value: cloneJson(m.value), ephemeral: m.ephemeral, seen: receiptsFor(name), last: m.last, landed: landedIn(m) };
       meta[name] = { log: m.log, last: m.last, landed: m.landed, floor: m.floor, behind: m.behind, file: m.file, inFile: m.inFile };
     }
-    return { epoch: room.epoch, seq: room.seq, writer: clientId, stores, mirror: { seen: [...mirror.seen], stores: meta } };
+    const state = { epoch: room.epoch, seq: room.seq, writer: clientId, stores, mirror: { seen: [...mirror.seen], stores: meta } };
+    if (since && since.epoch === mirror.epoch) {
+      const moves = {};
+      for (const [name, m] of mirror.stores) moves[name] = movesSince(m, since);
+      state.moves = moves;
+    }
+    return state;
   }
 
   function alreadyMerged(m, frame) {
@@ -507,7 +514,7 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
     } else if (room && m.type === "post") {
       if (m.epoch === room.epoch) post({ type: "answer", to: m.from, rid: m.rid, result: roomApply(m.from, m.frame) });
     } else if (room && m.type === "state-request") {
-      post({ type: "answer", to: m.from, rid: m.rid, result: roomState() });
+      post({ type: "answer", to: m.from, rid: m.rid, result: roomState(m.since) });
     }
   }
 
@@ -554,11 +561,11 @@ export function localTransport({ seed, key = "clay-live:" + window.location.path
     // The sequencer's state, installed into the mirror first. An answer to a
     // request made before the mirror changed (another state, or this tab
     // starting a room) is dropped: the lane asks again or already has it.
-    async fetchState() {
-      if (room) return roomState();
+    async fetchState(_clientId, since = null) {
+      if (room) return roomState(since);
       const asked = gen;
-      const state = await request({ type: "state-request" });
-      if (room) return roomState();
+      const state = await request({ type: "state-request", since });
+      if (room) return roomState(since);
       if (asked !== gen || !install(state)) return null;
       return state;
     },

package/src/live/moves.js

@@ -0,0 +1,11 @@
+// The moves a store's log holds after `since` ({ epoch, seq }), for a tab that
+// already applied everything through since.seq. [] when nothing is newer; null
+// when the log no longer reaches back that far (its floor is past since.seq),
+// so the tab cannot replay and takes the value as it is. A log may start above
+// since.seq + 1 with nothing missing: the seqs between went to other stores.
+export function movesSince(store, since) {
+  if (!since || !Number.isInteger(since.seq)) return null;
+  if (since.seq >= (store.last ?? 0)) return [];
+  if (since.seq < (store.floor ?? 0)) return null;
+  return store.log.filter((entry) => entry.seq > since.seq).map((entry) => ({ seq: entry.seq, ops: entry.ops }));
+}

package/src/live/server-lane.js

@@ -39,9 +39,10 @@ export async function relayData(clientId, frame) {
  * The room's { epoch, seq, writer, stores }; { status } when the host refused;
  * null when the request never got an answer. clientId marks this tab as taking part.
  */
-export async function fetchLiveState(clientId) {
+export async function fetchLiveState(clientId, since = null) {
   const url = dataUrl();
   if (clientId) url.searchParams.set("client-id", clientId);
+  if (since && typeof since.epoch === "string" && Number.isInteger(since.seq)) url.searchParams.set("since", `${since.epoch}:${since.seq}`);
   try {
     const response = await fetch(url.href, {
       credentials: "same-origin",

package/src/live/store.js

@@ -47,6 +47,8 @@ export function createStore({ name, value, ephemeral = false }) {
   let mode = "file";
   const listeners = new Set();
   const sinks = new Set();
+  const rebases = new Set();
+  const deliveries = new Set();
   const views = new WeakMap();
 
   function emit(source, ops) {
@@ -275,17 +277,46 @@ export function createStore({ name, value, ephemeral = false }) {
     // `confirmed` pending ops, or every op up to the mark `through`. The rest
     // replay over it; a pending op that no longer applies is dropped too.
     // Listeners hear about it only when the value page code sees changed.
-    rebase(next, { source = "remote", confirmed = 0, through } = {}) {
+    rebase(next, { source = "remote", confirmed = 0, through, frame = null, room = null, cause = null } = {}) {
       if (!isContainer(next) || kind(next) !== kind(state)) {
         console.warn(`clay.live("${name}"): ignored an incoming value that is not ${kind(state)}`);
         return false;
       }
       const before = serializeLive(state);
+      const prev = authoritative;
       authoritative = cloneJson(next);
       pending = through === undefined ? pending.slice(confirmed) : pending.filter((entry) => entry.id > through);
       rebuild();
+      for (const fn of [...rebases]) {
+        try {
+          fn({ source, frame, room, cause, prev, next: authoritative });
+        } catch (err) {
+          console.error(`clay.live("${name}"): a rebase listener threw`, err);
+        }
+      }
       if (serializeLive(state) !== before) emit(source, null);
       return true;
     },
+    // Every rebase, whether or not the value page code sees changed, with what
+    // caused it: the frame the room applied, the state read, or the lane's own
+    // settling. For the page editor; never on the handle.
+    onRebase(fn) {
+      rebases.add(fn);
+      return () => rebases.delete(fn);
+    },
+    // What became of this tab's frames: { phase, code, n, seq, through, retryAfter }.
+    onDelivery(fn) {
+      deliveries.add(fn);
+      return () => deliveries.delete(fn);
+    },
+    deliver(event) {
+      for (const fn of [...deliveries]) {
+        try {
+          fn(event);
+        } catch (err) {
+          console.error(`clay.live("${name}"): a delivery listener threw`, err);
+        }
+      }
+    },
   };
 }