@lazily-hub/lazily-js 0.19.0 → 0.21.0

package/BENCHMARKS.md

@@ -19,7 +19,7 @@ like-for-like single-process counterpart here and are intentionally omitted.
 
 <!-- benchmark-results:start -->
 
-Generated for package `@lazily-hub/lazily-js` version `0.6.0`.
+Generated for package `@lazily-hub/lazily-js` version `0.20.0`.
 
 Environment: Node.js `26.4.0` on `linux x64`.
 
@@ -33,16 +33,34 @@ Mean wall-clock time per iteration; 95% CI half-width from the standard error.
 
 | Group | Case | Mean | 95% CI | p75 | p99 | Samples |
 |---|---|---:|---:|---:|---:|---:|
-| cached_reads | context | 57.798 ns | ± 20.941 ns | 46.398 ns | 124.744 ns | 100 |
-| cold_first_get | context | 669.220 ns | ± 8.630 ns | 670.000 ns | 802.610 ns | 100 |
-| dependency_fan_out | context / 32 | 7.448 us | ± 824.968 ns | 6.783 us | 34.205 us | 100 |
-| dependency_fan_out | context / 256 | 43.766 us | ± 1.064 us | 43.270 us | 49.513 us | 100 |
-| set_cell_invalidation | high_fan_out / 512 | 10.737 us | ± 376.524 ns | 10.113 us | 17.141 us | 100 |
-| memo_equality_suppression | context | 2.387 us | ± 193.801 ns | 2.310 us | 2.864 us | 100 |
-| effect_flushing | context | 211.187 ns | ± 20.150 ns | 221.482 ns | 524.491 ns | 100 |
-| batch_storms | context / 64 | 30.430 us | ± 1.295 us | 30.815 us | 49.775 us | 99 |
-| typed_cache_reads | context_cell | 31.325 ns | ± 1.052 ns | 30.255 ns | 58.102 ns | 100 |
-| typed_cache_reads | context_slot | 120.262 ns | ± 4.805 ns | 118.099 ns | 220.409 ns | 100 |
+| cached_reads | context | 31.966 ns | ± 1.575 ns | 30.743 ns | 70.839 ns | 100 |
+| cold_first_get | context | 742.710 ns | ± 126.218 ns | 612.500 ns | 1.899 us | 100 |
+| dependency_fan_out | context / 32 | 6.129 us | ± 1.563 us | 5.023 us | 41.656 us | 100 |
+| dependency_fan_out | context / 256 | 48.997 us | ± 3.461 us | 47.868 us | 130.607 us | 100 |
+| set_cell_invalidation | high_fan_out / 512 | 5.482 us | ± 1.327 us | 6.410 us | 18.184 us | 100 |
+| memo_equality_suppression | context | 2.191 us | ± 356.052 ns | 3.813 us | 4.961 us | 100 |
+| effect_flushing | context | 149.841 ns | ± 15.108 ns | 148.815 ns | 452.666 ns | 100 |
+| batch_storms | context / 64 | 13.088 us | ± 281.500 ns | 13.352 us | 17.526 us | 100 |
+| typed_cache_reads | context_cell | 29.928 ns | ± 0.847 ns | 29.585 ns | 46.606 ns | 100 |
+| typed_cache_reads | context_slot | 46.437 ns | ± 5.381 ns | 39.915 ns | 179.573 ns | 100 |
+| textcrdt_insert_str | 64 | 8.939 us | ± 2.581 us | 7.678 us | 50.727 us | 100 |
+| textcrdt_insert_str | 256 | 28.383 us | ± 1.991 us | 25.568 us | 63.137 us | 100 |
+| textcrdt_insert_str | 1024 | 111.611 us | ± 6.489 us | 124.136 us | 205.387 us | 100 |
+| textcrdt_repeated_text | 64 | 40.149 us | ± 2.146 us | 36.146 us | 74.301 us | 100 |
+| textcrdt_repeated_text | 256 | 181.856 us | ± 13.068 us | 187.465 us | 331.261 us | 100 |
+| textcrdt_repeated_text | 1024 | 864.585 us | ± 45.266 us | 996.343 us | 1.519 ms | 100 |
+| textcrdt_merge | 64 | 12.103 us | ± 798.827 ns | 12.955 us | 24.361 us | 100 |
+| textcrdt_merge | 256 | 53.192 us | ± 4.002 us | 52.265 us | 143.726 us | 100 |
+| textcrdt_merge | 1024 | 270.364 us | ± 17.669 us | 268.422 us | 593.144 us | 100 |
+| textcrdt_delta_sync | 64 | 19.106 us | ± 1.372 us | 20.792 us | 29.232 us | 100 |
+| textcrdt_delta_sync | 256 | 67.860 us | ± 5.469 us | 62.273 us | 196.534 us | 100 |
+| textcrdt_delta_sync | 1024 | 262.078 us | ± 11.701 us | 257.410 us | 473.407 us | 100 |
+| seqcrdt_insert_back | 64 | 82.803 us | ± 7.276 us | 79.240 us | 226.953 us | 100 |
+| seqcrdt_insert_back | 256 | 1.561 ms | ± 57.393 us | 1.724 ms | 2.313 ms | 100 |
+| seqcrdt_insert_back | 1024 | 43.643 ms | ± 971.721 us | 44.688 ms | 50.468 ms | 20 |
+| seqcrdt_merge | 64 | 7.361 us | ± 624.875 ns | 8.053 us | 19.173 us | 100 |
+| seqcrdt_merge | 256 | 26.977 us | ± 2.251 us | 30.373 us | 73.848 us | 100 |
+| seqcrdt_merge | 1024 | 113.428 us | ± 6.981 us | 121.168 us | 252.144 us | 100 |
 
 <!-- benchmark-results:end -->
 

package/bench/crdt.bench.mjs

@@ -0,0 +1,129 @@
+// CRDT-plane benchmarks for lazily-js — TextCrdt and SeqCrdt hot paths.
+//
+// The reactive-core benches (`context.bench.mjs`) do not cover the CRDT plane;
+// the Phase 1 plan (#lztextordcache, #lztextinsertchain, #lzopidkeytuple,
+// #lzseqstringifyeq) needed a baseline + regression target. Mirrors the
+// `bench/harness.mjs` criterion-style API used by `context.bench.mjs` so the
+// output table is directly comparable.
+//
+// Run: `node bench/crdt.bench.mjs`
+
+import { bench, blackBox, run } from "./harness.mjs";
+import { TextCrdt } from "../src/text-crdt.js";
+import { SeqCrdt } from "../src/seq-crdt.js";
+
+const INSERT_STR_SIZES = [64, 256, 1024];
+const REPEATED_READ_ITERS = 100;
+
+// --- TextCrdt: bulk insertStr (#lztextinsertchain is the main lever) -------
+for (const size of INSERT_STR_SIZES) {
+  const payload = "a".repeat(size);
+  bench.batched(
+    "textcrdt_insert_str",
+    `${size}`,
+    () => new TextCrdt(1),
+    (crdt) => {
+      crdt.insertStr(0, payload);
+      blackBox(crdt.len());
+    },
+  );
+}
+
+// --- TextCrdt: repeated text() reads between mutations (#lztextordcache) ---
+// One mutation, then N reads. Pre-cache this should be O(N log N) per read;
+// post-cache it is O(1) per read after the first.
+for (const size of INSERT_STR_SIZES) {
+  const payload = "a".repeat(size);
+  bench.batched(
+    "textcrdt_repeated_text",
+    `${size}`,
+    () => {
+      const crdt = new TextCrdt(1);
+      crdt.insertStr(0, payload);
+      return crdt;
+    },
+    (crdt) => {
+      let last = "";
+      for (let i = 0; i < REPEATED_READ_ITERS; i++) {
+        last = crdt.text();
+      }
+      blackBox(last);
+    },
+  );
+}
+
+// --- TextCrdt: state-based merge ------------------------------------------
+// Two peers each insert N chars; merge b into a.
+for (const size of INSERT_STR_SIZES) {
+  bench.batched(
+    "textcrdt_merge",
+    `${size}`,
+    () => {
+      const a = new TextCrdt(1);
+      const b = new TextCrdt(2);
+      a.insertStr(0, "a".repeat(size));
+      b.insertStr(0, "b".repeat(size));
+      return { a, b };
+    },
+    ({ a, b }) => {
+      blackBox(a.merge(b));
+    },
+  );
+}
+
+// --- TextCrdt: delta sync round-trip --------------------------------------
+for (const size of INSERT_STR_SIZES) {
+  bench.batched(
+    "textcrdt_delta_sync",
+    `${size}`,
+    () => {
+      const a = new TextCrdt(1);
+      a.insertStr(0, "a".repeat(size));
+      const b = new TextCrdt(2);
+      return { a, b };
+    },
+    ({ a, b }) => {
+      const delta = a.deltaSince({});
+      blackBox(b.applyDelta(delta));
+    },
+  );
+}
+
+// --- SeqCrdt: bulk insertBack ---------------------------------------------
+for (const size of INSERT_STR_SIZES) {
+  bench.batched(
+    "seqcrdt_insert_back",
+    `${size}`,
+    () => new SeqCrdt(1),
+    (crdt) => {
+      for (let i = 0; i < size; i++) {
+        crdt.insertBack(`id${i}`, i, i + 1);
+      }
+      blackBox(crdt.entryCount());
+    },
+  );
+}
+
+// --- SeqCrdt: merge with primitive values (#lzseqstringifyeq) -------------
+for (const size of INSERT_STR_SIZES) {
+  bench.batched(
+    "seqcrdt_merge",
+    `${size}`,
+    () => {
+      const a = new SeqCrdt(1);
+      const b = new SeqCrdt(2);
+      for (let i = 0; i < size; i++) {
+        a.insertBack(`a${i}`, i, i + 1);
+        b.insertBack(`b${i}`, i * 10, i + 1);
+      }
+      return { a, b };
+    },
+    ({ a, b }) => {
+      blackBox(a.merge(b, Date.now() * 1000));
+    },
+  );
+}
+
+await run({
+  format: process.env.BENCH_FORMAT === "json" ? "json" : "markdown",
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazily-hub/lazily-js",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Native JavaScript port of the lazily reactive core: a full reactive graph (Cell/Slot/Signal/Effect), sync/async/thread-safe keyed reactive maps (ReactiveMap/CellMap/SlotMap), the lazily-spec IPC wire types + C-ABI FFI boundary (isomorphic channel + Node native binding), keyed cell collections + LIS reconciliation, the memoized semantic tree, the move-aware sequence CRDT, the Fugue/RGA text CRDT, manufactured text identity, full-Harel state charts, an FFI state-projection consumer, and an in-library instrumentation/benchmark API.",
   "license": "MIT",
   "repository": {

package/src/reactive.js

@@ -36,8 +36,7 @@ function defaultEqual(a, b) {
   const bKeys = Object.keys(b);
   return (
     aKeys.length === bKeys.length &&
-    aKeys.every((k) => Object.is(aKeys[k], bKeys[k])) &&
-    aKeys.every((k) => defaultEqual(a[k], b[k]))
+    aKeys.every((k) => k in b && defaultEqual(a[k], b[k]))
   );
 }
 
@@ -74,10 +73,31 @@ export class SignalHandle {
 
 // -- Context -----------------------------------------------------------------
 
+function edgeInsert(edges, id) {
+  for (let i = 0; i < edges.length; i++) {
+    if (edges[i] === id) {
+      return false;
+    }
+  }
+  edges.push(id);
+  return true;
+}
+
+function edgeRemove(edges, id) {
+  for (let i = 0; i < edges.length; i++) {
+    if (edges[i] === id) {
+      edges[i] = edges[edges.length - 1];
+      edges.pop();
+      return true;
+    }
+  }
+  return false;
+}
+
 class CellNode {
   constructor(value) {
     this.value = value;
-    this.dependents = new Set();
+    this.dependents = [];
   }
 }
 
@@ -87,8 +107,8 @@ class SlotNode {
     this.hasValue = false;
     this.memo = memo;
     this.compute = compute;
-    this.dependencies = new Set();
-    this.dependents = new Set();
+    this.dependencies = [];
+    this.dependents = [];
     this.dirty = false;
     this.forceRecompute = false;
     this.inProgress = false;
@@ -98,18 +118,19 @@ class SlotNode {
 class EffectNode {
   constructor(run) {
     this.run = run;
-    this.dependencies = new Set();
+    this.dependencies = [];
     this.cleanup = null;
     this.forceRun = false;
   }
 }
 
 export class Context {
-  #nodes = new Map();
+  #nodes = [];
   #nextId = 1;
   #freeIds = [];
   #trackingStack = [];
   #pendingEffects = [];
+  #pendingHead = 0;
   #scheduledEffects = new Set();
   #flushingEffects = false;
   #batchDepth = 0;
@@ -167,7 +188,7 @@ export class Context {
 
   #cellAny(value) {
     const id = this.#allocId();
-    this.#nodes.set(id, new CellNode(value));
+    this.#nodes[id] = new CellNode(value);
     return id;
   }
 
@@ -185,7 +206,7 @@ export class Context {
 
   #slotAny(memo, compute) {
     const id = this.#allocId();
-    this.#nodes.set(id, new SlotNode(compute, memo));
+    this.#nodes[id] = new SlotNode(compute, memo);
     return id;
   }
 
@@ -206,7 +227,7 @@ export class Context {
     const id = this.#allocId();
     const node = new EffectNode(run);
     node.forceRun = true; // force the initial run on registration
-    this.#nodes.set(id, node);
+    this.#nodes[id] = node;
     this.#scheduleEffect(id, false);
     this.#flushEffects();
     return id;
@@ -232,7 +253,7 @@ export class Context {
       this.#registerDependency(id, frame);
     }
     this.#refreshSlot(id);
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof SlotNode) || !node.hasValue) {
       throw new Error(`slot ${id} has no value`);
     }
@@ -244,7 +265,7 @@ export class Context {
     if (frame !== undefined) {
       this.#registerDependency(id, frame);
     }
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof CellNode)) {
       throw new Error(`get_cell on non-cell id ${id}`);
     }
@@ -258,7 +279,7 @@ export class Context {
   }
 
   #setCellAny(id, value) {
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof CellNode)) {
       throw new Error(`set_cell on non-cell id ${id}`);
     }
@@ -302,10 +323,20 @@ export class Context {
   }
 
   #flushBatched() {
-    const cells = [...this.#batchedCells];
-    this.#batchedCells.clear();
+    const cells = this.#batchedCells;
+    this.#batchedCells = new Set();
+    const roots = [];
     for (const id of cells) {
-      this.#invalidateCellDependentsNow(id);
+      const node = this.#nodes[id];
+      if (node instanceof CellNode) {
+        for (const d of node.dependents) {
+          roots.push(d);
+        }
+      }
+    }
+    const effects = this.#markFrontier(roots);
+    for (let i = 0; i < effects.length; i++) {
+      this.#scheduleEffect(effects[i][0], effects[i][1]);
     }
     this.#flushEffects();
   }
@@ -318,18 +349,18 @@ export class Context {
 
   disposeEffect(handle) {
     const id = handle.id;
-    const idx = this.#pendingEffects.indexOf(id);
+    const idx = this.#pendingEffects.indexOf(id, this.#pendingHead);
     if (idx !== -1) {
       this.#pendingEffects.splice(idx, 1);
     }
     this.#scheduledEffects.delete(id);
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof EffectNode)) {
       return;
     }
-    this.#nodes.delete(id);
+    this.#nodes[id] = undefined;
     this.#freeIds.push(id);
-    for (const dep of [...node.dependencies]) {
+    for (const dep of node.dependencies) {
       this.#removeDependentEdge(dep, id);
     }
     if (node.cleanup) {
@@ -338,7 +369,7 @@ export class Context {
   }
 
   isEffectActive(handle) {
-    return this.#nodes.get(handle.id) instanceof EffectNode;
+    return this.#nodes[handle.id] instanceof EffectNode;
   }
 
   disposeSignal(handle) {
@@ -350,7 +381,7 @@ export class Context {
   }
 
   isSet(handle) {
-    const node = this.#nodes.get(handle.id);
+    const node = this.#nodes[handle.id];
     if (!(node instanceof SlotNode)) {
       return false;
     }
@@ -371,36 +402,39 @@ export class Context {
   }
 
   #registerDependency(depId, parentId) {
-    const dep = this.#nodes.get(depId);
+    const dep = this.#nodes[depId];
     if (dep instanceof CellNode || dep instanceof SlotNode) {
-      if (this.#instrument && !dep.dependents.has(parentId)) {
+      const added = edgeInsert(dep.dependents, parentId);
+      if (this.#instrument && added) {
         this.#counters.dependencyEdgesAdded++;
       }
-      dep.dependents.add(parentId);
     }
-    const parent = this.#nodes.get(parentId);
+    const parent = this.#nodes[parentId];
     if (parent instanceof SlotNode || parent instanceof EffectNode) {
-      parent.dependencies.add(depId);
+      edgeInsert(parent.dependencies, depId);
     }
   }
 
   #removeDependentEdge(depId, parentId) {
-    const dep = this.#nodes.get(depId);
+    const dep = this.#nodes[depId];
     if (dep instanceof CellNode || dep instanceof SlotNode) {
-      if (this.#instrument && dep.dependents.has(parentId)) {
+      const removed = edgeRemove(dep.dependents, parentId);
+      if (this.#instrument && removed) {
         this.#counters.dependencyEdgesRemoved++;
       }
-      dep.dependents.delete(parentId);
     }
   }
 
   // -- Internals: refresh / recompute (pull-based, glitch-free) ----------
 
   #refreshSlot(id) {
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof SlotNode)) {
       return false;
     }
+    if (node.hasValue && !node.dirty && !node.forceRecompute) {
+      return false;
+    }
     if (node.inProgress) {
       throw new Error(
         `lazily: circular dependency detected at slot ${id}; a computed/memo slot depends on itself`,
@@ -409,8 +443,8 @@ export class Context {
     node.inProgress = true;
     try {
       let dependencyChanged = false;
-      for (const dep of [...node.dependencies]) {
-        if (this.#nodes.get(dep) instanceof SlotNode && this.#refreshSlot(dep)) {
+      for (const dep of node.dependencies) {
+        if (this.#nodes[dep] instanceof SlotNode && this.#refreshSlot(dep)) {
           dependencyChanged = true;
         }
       }
@@ -430,10 +464,11 @@ export class Context {
     if (this.#instrument) {
       this.#counters.slotRecomputes++;
     }
-    for (const dep of [...node.dependencies]) {
+    const oldDeps = node.dependencies;
+    node.dependencies = [];
+    for (const dep of oldDeps) {
       this.#removeDependentEdge(dep, id);
     }
-    node.dependencies.clear();
     this.#trackingStack.push(id);
     let result;
     try {
@@ -457,13 +492,7 @@ export class Context {
   }
 
   #notifySlotValueChanged(id) {
-    const node = this.#nodes.get(id);
-    if (!(node instanceof SlotNode)) {
-      return;
-    }
-    for (const d of [...node.dependents]) {
-      this.#invalidateDependentFromChangedValue(d);
-    }
+    this.#invalidateDependentsNow(id);
   }
 
   // -- Internals: invalidation propagation ------------------------------
@@ -475,58 +504,67 @@ export class Context {
    * @returns {boolean}
    */
   #invalidateCellDependentsNow(id) {
-    const node = this.#nodes.get(id);
-    if (!(node instanceof CellNode) || node.dependents.size === 0) {
-      return false;
-    }
-    let scheduled = false;
-    for (const d of [...node.dependents]) {
-      if (this.#invalidateDependentFromChangedValue(d)) {
-        scheduled = true;
-      }
-    }
-    return scheduled;
+    return this.#invalidateDependentsNow(id);
   }
 
-  /** @returns {boolean} whether an Effect was scheduled. */
-  #invalidateDependentFromChangedValue(id) {
-    if (this.#nodes.get(id) instanceof EffectNode) {
-      this.#scheduleEffect(id, true);
-      return true;
-    }
-    return this.#markSlotDirty(id, true);
-  }
-
-  /** @returns {boolean} whether an Effect was scheduled during this walk. */
-  #markSlotDirty(id, force) {
-    const node = this.#nodes.get(id);
-    if (!(node instanceof SlotNode)) {
-      return false;
-    }
-    const shouldPropagate = !node.dirty || (force && !node.forceRecompute);
-    node.dirty = true;
-    if (force) {
-      node.forceRecompute = true;
-    }
-    if (!shouldPropagate) {
+  #invalidateDependentsNow(id) {
+    const node = this.#nodes[id];
+    let roots;
+    if (node instanceof CellNode) {
+      if (node.dependents.length === 0) {
+        return false;
+      }
+      roots = node.dependents;
+    } else if (node instanceof SlotNode) {
+      if (node.dependents.length === 0) {
+        return false;
+      }
+      roots = node.dependents;
+    } else {
       return false;
     }
-    let scheduled = false;
-    for (const d of [...node.dependents]) {
-      if (this.#nodes.get(d) instanceof EffectNode) {
-        this.#scheduleEffect(d, false);
-        scheduled = true;
-      } else if (this.#markSlotDirty(d, false)) {
-        scheduled = true;
+    const effects = this.#markFrontier(roots);
+    for (let i = 0; i < effects.length; i++) {
+      this.#scheduleEffect(effects[i][0], effects[i][1]);
+    }
+    return effects.length > 0;
+  }
+
+  #markFrontier(roots) {
+    const effects = [];
+    const stack = [];
+    const forceStack = [];
+    for (const root of roots) {
+      stack.push(root);
+      forceStack.push(true);
+    }
+    while (stack.length > 0) {
+      const id = stack.pop();
+      const force = forceStack.pop();
+      const node = this.#nodes[id];
+      if (node instanceof SlotNode) {
+        const shouldPropagate = !node.dirty || (force && !node.forceRecompute);
+        node.dirty = true;
+        if (force) {
+          node.forceRecompute = true;
+        }
+        if (shouldPropagate) {
+          for (const depId of node.dependents) {
+            stack.push(depId);
+            forceStack.push(false);
+          }
+        }
+      } else if (node instanceof EffectNode) {
+        effects.push([id, force]);
       }
     }
-    return scheduled;
+    return effects;
   }
 
   // -- Internals: effect scheduling / flush ------------------------------
 
   #scheduleEffect(id, force) {
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof EffectNode)) {
       return;
     }
@@ -537,8 +575,9 @@ export class Context {
       this.#pendingEffects.push(id);
       if (this.#instrument) {
         this.#counters.effectQueuePushes++;
-        if (this.#pendingEffects.length > this.#counters.maxEffectQueueDepth) {
-          this.#counters.maxEffectQueueDepth = this.#pendingEffects.length;
+        const depth = this.#pendingEffects.length - this.#pendingHead;
+        if (depth > this.#counters.maxEffectQueueDepth) {
+          this.#counters.maxEffectQueueDepth = depth;
         }
       }
     }
@@ -551,8 +590,10 @@ export class Context {
     this.#flushingEffects = true;
     try {
       while (true) {
-        const id = this.#pendingEffects.shift();
+        const id = this.#pendingEffects[this.#pendingHead++];
         if (id === undefined) {
+          this.#pendingEffects = [];
+          this.#pendingHead = 0;
           return;
         }
         this.#scheduledEffects.delete(id);
@@ -567,12 +608,12 @@ export class Context {
     if (!this.#effectShouldRun(id)) {
       return;
     }
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof EffectNode)) {
       return;
     }
-    const oldDeps = [...node.dependencies];
-    node.dependencies.clear();
+    const oldDeps = node.dependencies;
+    node.dependencies = [];
     const cleanup = node.cleanup;
     node.cleanup = null;
     node.forceRun = false;
@@ -589,7 +630,7 @@ export class Context {
     } finally {
       this.#trackingStack.pop();
     }
-    const current = this.#nodes.get(id);
+    const current = this.#nodes[id];
     if (current instanceof EffectNode) {
       current.cleanup = typeof nextCleanup === "function" ? nextCleanup : null;
     } else if (typeof nextCleanup === "function") {
@@ -598,7 +639,7 @@ export class Context {
   }
 
   #effectShouldRun(id) {
-    const node = this.#nodes.get(id);
+    const node = this.#nodes[id];
     if (!(node instanceof EffectNode)) {
       return false;
     }
@@ -606,7 +647,7 @@ export class Context {
       return true;
     }
     for (const dep of node.dependencies) {
-      if (this.#nodes.get(dep) instanceof SlotNode && this.#refreshSlot(dep)) {
+      if (this.#nodes[dep] instanceof SlotNode && this.#refreshSlot(dep)) {
         return true;
       }
     }

package/src/seq-crdt.js

@@ -93,6 +93,13 @@ export class LwwRegister {
   }
 }
 
+// Structural deep equality (#lzseqstringifyeq): replaces JSON.stringify-based
+// comparison (one of V8's slowest paths) with a typed dispatch that handles the
+// common cases — primitives, Position, arrays, plain objects — without
+// allocating a serialized string per side per comparison. Behavior is
+// equivalent to JSON.stringify equality for plain JSON values, while skipping
+// JSON's NaN/Infinity/null coercion and toJSON dispatch (neither is exercised
+// by the values stored in SeqCrdt registers today).
 function valuesEqual(a, b) {
   if (a === b) {
     return true;
@@ -103,7 +110,32 @@ function valuesEqual(a, b) {
   if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
     return a === b;
   }
-  return JSON.stringify(a) === JSON.stringify(b);
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!valuesEqual(a[i], b[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) {
+    return false;
+  }
+  for (let i = 0; i < ka.length; i++) {
+    const k = ka[i];
+    if (!Object.prototype.hasOwnProperty.call(b, k)) {
+      return false;
+    }
+    if (!valuesEqual(a[k], b[k])) {
+      return false;
+    }
+  }
+  return true;
 }
 
 // Position: fractional-index byte key + originating peer.

package/src/text-crdt.js

@@ -12,6 +12,10 @@ export class OpId {
   constructor(counter, peer) {
     this.counter = counter;
     this.peer = peer;
+    // Cached string key — avoids per-lookup allocation across the lifetime of
+    // an OpId (#lzopidkeytuple). Set before freeze so the field is immutable
+    // alongside the rest of the instance.
+    this._key = `${counter}:${peer}`;
     Object.freeze(this);
   }
   compareTo(other) {
@@ -29,7 +33,10 @@ export class OpId {
 }
 
 class Elem {
-  constructor(ch, origin, deleted = null) {
+  // `id` is stored on the Elem so iteration over the map values can recover
+  // the OpId without re-parsing the string key (#lzopidkeytuple).
+  constructor(id, ch, origin, deleted = null) {
+    this.id = id; // OpId
     this.ch = ch;
     this.origin = origin; // OpId | null (null = document start)
     this.deleted = deleted; // OpId | null (the delete op id, or null = live)
@@ -37,9 +44,16 @@ class Elem {
 }
 
 export class TextCrdt {
-  #elems = new Map(); // OpId-keyed (serialized as "counter:peer")
+  // String-keyed map (OpId._key -> Elem). The string is cached on each OpId at
+  // construction so this is a hash lookup with zero per-op allocation.
+  #elems = new Map();
   #peer;
   #counter = 0;
+  // Cached visible orderings (#lztextordcache). Both are invalidated by every
+  // mutation; populated lazily on the next read. Repeated `text()` between
+  // mutations is O(1) instead of O(N log N).
+  #orderedLiveCache = null; // OpId[] | null (excludes tombstones)
+  #orderedAllCache = null; // OpId[] | null (includes tombstones)
 
   constructor(peer) {
     this.#peer = peer;
@@ -55,8 +69,9 @@ export class TextCrdt {
   fork(peer) {
     const copy = new TextCrdt(peer);
     copy.#counter = this.#counter;
-    for (const [key, elem] of this.#elems) {
-      copy.#elems.set(key, new Elem(elem.ch, elem.origin, elem.deleted));
+    for (const elem of this.#elems.values()) {
+      const e = new Elem(elem.id, elem.ch, elem.origin, elem.deleted);
+      copy.#elems.set(e.id._key, e);
     }
     return copy;
   }
@@ -70,22 +85,30 @@ export class TextCrdt {
     return new OpId(this.#counter, this.#peer);
   }
 
-  #key(id) {
-    return `${id.counter}:${id.peer}`;
+  #invalidateOrdered() {
+    this.#orderedLiveCache = null;
+    this.#orderedAllCache = null;
   }
 
   #orderedIds(includeDeleted) {
-    // Group by origin.
-    const children = new Map(); // originKey -> OpId[]
-    for (const [key, elem] of this.#elems) {
-      const originKey = elem.origin ? this.#key(elem.origin) : "<root>";
+    // Cache hit (#lztextordcache).
+    if (includeDeleted) {
+      if (this.#orderedAllCache !== null) return this.#orderedAllCache;
+    } else {
+      if (this.#orderedLiveCache !== null) return this.#orderedLiveCache;
+    }
+
+    // Group by origin. Keys are origin._key (or "<root>"); values are OpId[]
+    // recovered directly from Elem.id — no string parse (#lzopidkeytuple).
+    const children = new Map();
+    for (const elem of this.#elems.values()) {
+      const originKey = elem.origin ? elem.origin._key : "<root>";
       let list = children.get(originKey);
       if (!list) {
         list = [];
         children.set(originKey, list);
       }
-      // Recover the OpId from the map iteration key is not stored, so store it.
-      list.push(this.#idFromKey(key));
+      list.push(elem.id);
     }
     // Sort each sibling list DESCENDING by OpId.
     for (const list of children.values()) {
@@ -97,14 +120,14 @@ export class TextCrdt {
     const stack = [...roots].sort(OpId.desc); // highest pops first
     while (stack.length > 0) {
       const id = stack.pop();
-      const elem = this.#elems.get(this.#key(id));
+      const elem = this.#elems.get(id._key);
       if (!elem) {
         continue;
       }
       if (includeDeleted || elem.deleted === null) {
         out.push(id);
       }
-      const kids = children.get(this.#key(id));
+      const kids = children.get(id._key);
       if (kids) {
         // Push reversed so the highest-OpId child pops first.
         for (let i = kids.length - 1; i >= 0; i--) {
@@ -112,26 +135,36 @@ export class TextCrdt {
         }
       }
     }
+    if (includeDeleted) {
+      this.#orderedAllCache = out;
+    } else {
+      this.#orderedLiveCache = out;
+    }
     return out;
   }
 
-  #idFromKey(key) {
-    const [counter, peer] = key.split(":");
-    return new OpId(Number(counter), Number(peer));
-  }
-
   insert(index, ch) {
     const visible = this.#orderedIds(false);
     const origin = index === 0 ? null : visible[index - 1] ?? null;
     const id = this.#nextId();
-    this.#elems.set(this.#key(id), new Elem(ch, origin, null));
+    this.#invalidateOrdered();
+    this.#elems.set(id._key, new Elem(id, ch, origin, null));
   }
 
+  // Bulk insert with origin chaining (#lztextinsertchain): one `orderedIds()`
+  // pass + N chain appends instead of N full-tree rebuilds. Sequential chars
+  // chain naturally — char i+1's left-origin is char i's just-minted OpId —
+  // so the DFS visits them in chain order (counter strictly increases under
+  // one peer). Concurrent inserts at the same point still sort by the peer
+  // tiebreak, preserving the standard CRDT convergence contract.
   insertStr(index, str) {
-    let i = 0;
+    const visible = this.#orderedIds(false);
+    let origin = index === 0 ? null : visible[index - 1] ?? null;
+    this.#invalidateOrdered();
     for (const ch of String(str)) {
-      this.insert(index + i, ch);
-      i++;
+      const id = this.#nextId();
+      this.#elems.set(id._key, new Elem(id, ch, origin, null));
+      origin = id; // chain: next char's left-origin is this id
     }
   }
 
@@ -142,16 +175,18 @@ export class TextCrdt {
       return; // no-op if out of range
     }
     const del = this.#nextId(); // always advance the clock (matches lazily-rs)
-    const elem = this.#elems.get(this.#key(id));
+    const elem = this.#elems.get(id._key);
     if (elem && elem.deleted === null) {
+      this.#invalidateOrdered();
       elem.deleted = del;
     }
   }
 
   text() {
+    const ordered = this.#orderedIds(false);
     let out = "";
-    for (const id of this.#orderedIds(false)) {
-      out += this.#elems.get(this.#key(id)).ch;
+    for (const id of ordered) {
+      out += this.#elems.get(id._key).ch;
     }
     return out;
   }
@@ -190,26 +225,38 @@ export class TextCrdt {
   // the smaller delete id. Returns whether visible text changed.
   merge(other) {
     const before = this.text();
-    for (const [key, oe] of other.#elems) {
-      const id = other.#idFromKey(key);
-      this.#counter = Math.max(this.#counter, id.counter);
+    let anyChange = false;
+    for (const oe of other.#elems.values()) {
+      this.#counter = Math.max(this.#counter, oe.id.counter);
       if (oe.deleted) {
         this.#counter = Math.max(this.#counter, oe.deleted.counter);
       }
-      const existing = this.#elems.get(key);
+      const existing = this.#elems.get(oe.id._key);
       if (existing) {
         if (existing.deleted && oe.deleted) {
-          existing.deleted =
+          const merged =
             existing.deleted.compareTo(oe.deleted) <= 0
               ? existing.deleted
               : oe.deleted;
-        } else if (oe.deleted) {
+          if (merged !== existing.deleted) {
+            existing.deleted = merged;
+            anyChange = true;
+          }
+        } else if (oe.deleted && existing.deleted === null) {
           existing.deleted = oe.deleted;
+          anyChange = true;
         }
       } else {
-        this.#elems.set(key, new Elem(oe.ch, oe.origin, oe.deleted));
+        // Adopt the elem with its existing OpId identity so later concurrent
+        // edits merge without duplication.
+        const adopted = new Elem(oe.id, oe.ch, oe.origin, oe.deleted);
+        this.#elems.set(oe.id._key, adopted);
+        anyChange = true;
       }
     }
+    if (anyChange) {
+      this.#invalidateOrdered();
+    }
     return this.text() !== before;
   }
 
@@ -234,7 +281,7 @@ export class TextCrdt {
       const referenced = new Set();
       for (const elem of this.#elems.values()) {
         if (elem.origin) {
-          referenced.add(this.#key(elem.origin));
+          referenced.add(elem.origin._key);
         }
       }
       const collectable = [];
@@ -251,6 +298,9 @@ export class TextCrdt {
         removed++;
       }
     }
+    if (removed > 0) {
+      this.#invalidateOrdered();
+    }
     return removed;
   }
 
@@ -260,13 +310,11 @@ export class TextCrdt {
   // compact frontier a replica sends so a partner can compute the ops it lacks.
   versionVector() {
     const vv = {};
-    const bump = (id) => {
+    for (const elem of this.#elems.values()) {
+      const id = elem.id;
       vv[id.peer] = Math.max(vv[id.peer] ?? 0, id.counter);
-    };
-    for (const [key, elem] of this.#elems) {
-      bump(this.#idFromKey(key));
       if (elem.deleted) {
-        bump(elem.deleted);
+        vv[elem.deleted.peer] = Math.max(vv[elem.deleted.peer] ?? 0, elem.deleted.counter);
       }
     }
     return vv;
@@ -279,8 +327,8 @@ export class TextCrdt {
     const seen = (id) => id.counter <= (theirVv[id.peer] ?? 0);
     const wire = (id) => (id ? { counter: id.counter, peer: id.peer } : null);
     const out = [];
-    for (const [key, elem] of this.#elems) {
-      const id = this.#idFromKey(key);
+    for (const elem of this.#elems.values()) {
+      const id = elem.id;
       const insertNew = !seen(id);
       const deleteNew = elem.deleted !== null && !seen(elem.deleted);
       if (insertNew || deleteNew) {
@@ -301,6 +349,7 @@ export class TextCrdt {
   // concurrent edits merge without duplication. Returns whether text changed.
   applyDelta(ops) {
     const before = this.text();
+    let anyChange = false;
     for (const op of ops) {
       const id = new OpId(op.id.counter, op.id.peer);
       const origin = op.origin ? new OpId(op.origin.counter, op.origin.peer) : null;
@@ -309,19 +358,27 @@ export class TextCrdt {
       if (deleted) {
         this.#counter = Math.max(this.#counter, deleted.counter);
       }
-      const key = this.#key(id);
-      const existing = this.#elems.get(key);
+      const existing = this.#elems.get(id._key);
       if (existing) {
         if (existing.deleted && deleted) {
-          existing.deleted =
+          const merged =
             existing.deleted.compareTo(deleted) <= 0 ? existing.deleted : deleted;
-        } else if (deleted) {
+          if (merged !== existing.deleted) {
+            existing.deleted = merged;
+            anyChange = true;
+          }
+        } else if (deleted && existing.deleted === null) {
           existing.deleted = deleted;
+          anyChange = true;
         }
       } else {
-        this.#elems.set(key, new Elem(op.ch, origin, deleted));
+        this.#elems.set(id._key, new Elem(id, op.ch, origin, deleted));
+        anyChange = true;
       }
     }
+    if (anyChange) {
+      this.#invalidateOrdered();
+    }
     return this.text() !== before;
   }
 }