@mmstack/primitives 20.16.0 → 20.17.0

package/fesm2022/mmstack-primitives.mjs

@@ -5619,6 +5619,13 @@ function createConvergingApply(opt) {
     // below the captured seq. Side-mapped so the public sibling/checkpoint shapes stay unchanged.
     let ingestSeq = 0;
     const seqs = new Map();
+    // per-origin highest HLC applied: the observation vector (survives reset — knowledge, not state)
+    const applied = new Map();
+    const observeApplied = (origin, hlc) => {
+        const cur = applied.get(origin);
+        if (!cur || compareHlc(hlc, cur) > 0)
+            applied.set(origin, hlc);
+    };
     const setSeq = (key, origin, seq) => {
         let sm = seqs.get(key);
         if (!sm)
@@ -5873,6 +5880,7 @@ function createConvergingApply(opt) {
         ingest: (env, o) => {
             const touched = new Map();
             const seq = ++ingestSeq;
+            observeApplied(env.origin, env.hlc);
             for (const op of env.ops) {
                 if (o?.frontier && compareHlc(env.hlc, o.frontier) <= 0)
                     continue;
@@ -5960,10 +5968,22 @@ function createConvergingApply(opt) {
             return out;
         },
         captureFrontier: () => ({ seq: ingestSeq }),
+        appliedFrontier: () => Object.fromEntries(applied),
         liveAt: (path) => {
             const reg = registers.get(keyOf$1(path));
             return reg ? liveOf(reg) : [];
         },
+        liveUnder: (path) => {
+            const key = keyOf$1(path);
+            const out = [];
+            const at = registers.get(key);
+            for (const reg of at ? [at, ...descendantsOf(key)] : descendantsOf(key)) {
+                const siblings = liveOf(reg);
+                if (siblings.length)
+                    out.push({ path: reg.path, siblings });
+            }
+            return out;
+        },
         materialize: () => {
             const root = registers.get('');
             const res = root?.result;
@@ -5997,6 +6017,7 @@ function createConvergingApply(opt) {
                 const reg = regAt(r.path);
                 const key = keyOf$1(r.path);
                 for (const s of r.siblings) {
+                    observeApplied(s.origin, s.hlc);
                     const cur = reg.siblings.get(s.origin);
                     if (!cur || compareHlc(s.hlc, cur.hlc) > 0) {
                         reg.siblings.set(s.origin, s);
@@ -6004,6 +6025,7 @@ function createConvergingApply(opt) {
                     }
                 }
                 for (const [o, h] of Object.entries(r.water)) {
+                    observeApplied(o, h); // a cited write was applied by the room this state came from
                     const cur = reg.water.get(o);
                     if (!cur || compareHlc(h, cur) > 0)
                         reg.water.set(o, h);
@@ -6275,6 +6297,9 @@ function opSync(source, opt) {
             log.flush(); // fold pending base writes in first, so they count as observed
             return conv.captureFrontier();
         },
+        liveUnder: (path) => conv.liveUnder(path),
+        liveAt: (path) => conv.liveAt(path),
+        appliedFrontier: () => conv.appliedFrontier(),
         commitScope: (frontier, fn) => {
             log.flush(); // earlier pending writes emit against the live frontier, not this one
             scopeFrontier = frontier;