@git-stunts/git-warp 11.5.1 → 12.1.0

package/src/domain/services/PropertyIndexBuilder.js

@@ -0,0 +1,64 @@
+/**
+ * Builds property index shards from node properties.
+ *
+ * Produces `props_XX.cbor` shards keyed by shard key, where each
+ * shard maps nodeId → { key: value, ... }.
+ *
+ * @module domain/services/PropertyIndexBuilder
+ */
+
+import defaultCodec from '../utils/defaultCodec.js';
+import computeShardKey from '../utils/shardKey.js';
+
+export default class PropertyIndexBuilder {
+  /**
+   * @param {Object} [options]
+   * @param {import('../../ports/CodecPort.js').default} [options.codec]
+   */
+  constructor({ codec } = {}) {
+    this._codec = codec || defaultCodec;
+    /** @type {Map<string, Map<string, Record<string, unknown>>>} shardKey → (nodeId → props) */
+    this._shards = new Map();
+  }
+
+  /**
+   * Adds a property for a node.
+   *
+   * @param {string} nodeId
+   * @param {string} key
+   * @param {unknown} value
+   */
+  addProperty(nodeId, key, value) {
+    const shardKey = computeShardKey(nodeId);
+    let shard = this._shards.get(shardKey);
+    if (!shard) {
+      shard = new Map();
+      this._shards.set(shardKey, shard);
+    }
+    let nodeProps = shard.get(nodeId);
+    if (!nodeProps) {
+      nodeProps = /** @type {Record<string, unknown>} */ (Object.create(null));
+      shard.set(nodeId, nodeProps);
+    }
+    /** @type {Record<string, unknown>} */ (nodeProps)[key] = value;
+  }
+
+  /**
+   * Serializes all property shards.
+   *
+   * @returns {Record<string, Uint8Array>}
+   */
+  serialize() {
+    /** @type {Record<string, Uint8Array>} */
+    const tree = {};
+    for (const [shardKey, shard] of this._shards) {
+      // Encode as array of [nodeId, props] pairs to avoid __proto__ key issues
+      // when CBOR decodes into plain objects. Sorted by nodeId for determinism.
+      const entries = [...shard.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([nodeId, props]) => [nodeId, props]);
+      tree[`props_${shardKey}.cbor`] = this._codec.encode(entries).slice();
+    }
+    return tree;
+  }
+}

package/src/domain/services/PropertyIndexReader.js

@@ -0,0 +1,111 @@
+/**
+ * Reads property index shards lazily with LRU caching.
+ *
+ * Loads `props_XX.cbor` shards on demand via IndexStoragePort.readBlob.
+ *
+ * @module domain/services/PropertyIndexReader
+ */
+
+import defaultCodec from '../utils/defaultCodec.js';
+import computeShardKey from '../utils/shardKey.js';
+import LRUCache from '../utils/LRUCache.js';
+
+export default class PropertyIndexReader {
+  /**
+   * @param {Object} [options]
+   * @param {import('../../ports/IndexStoragePort.js').default} [options.storage]
+   * @param {import('../../ports/CodecPort.js').default} [options.codec]
+   * @param {number} [options.maxCachedShards=64]
+   */
+  constructor({ storage, codec, maxCachedShards = 64 } = /** @type {{ storage?: import('../../ports/IndexStoragePort.js').default, codec?: import('../../ports/CodecPort.js').default, maxCachedShards?: number }} */ ({})) {
+    this._storage = storage;
+    this._codec = codec || defaultCodec;
+    /** @type {Map<string, string>} path → oid */
+    this._shardOids = new Map();
+    /** @type {LRUCache<string, Record<string, Record<string, unknown>>>} */
+    this._cache = new LRUCache(maxCachedShards);
+  }
+
+  /**
+   * Configures OID mappings for lazy loading.
+   *
+   * @param {Record<string, string>} shardOids - path → blob OID
+   */
+  setup(shardOids) {
+    this._shardOids = new Map(Object.entries(shardOids));
+    this._cache.clear();
+  }
+
+  /**
+   * Returns all properties for a node, or null if not found.
+   *
+   * @param {string} nodeId
+   * @returns {Promise<Record<string, unknown>|null>}
+   */
+  async getNodeProps(nodeId) {
+    const shard = await this._loadShard(nodeId);
+    if (!shard) {
+      return null;
+    }
+    return shard[nodeId] ?? null;
+  }
+
+  /**
+   * Returns a single property value, or undefined.
+   *
+   * @param {string} nodeId
+   * @param {string} key
+   * @returns {Promise<unknown|undefined>}
+   */
+  async getProperty(nodeId, key) {
+    const props = await this.getNodeProps(nodeId);
+    if (!props) {
+      return undefined;
+    }
+    return props[key];
+  }
+
+  /**
+   * @param {string} nodeId
+   * @returns {Promise<Record<string, Record<string, unknown>>|null>}
+   * @private
+   */
+  async _loadShard(nodeId) {
+    const shardKey = computeShardKey(nodeId);
+    const path = `props_${shardKey}.cbor`;
+
+    const cached = this._cache.get(path);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const oid = this._shardOids.get(path);
+    if (!oid) {
+      return null;
+    }
+
+    if (!this._storage) {
+      return null;
+    }
+
+    const buffer = await /** @type {{ readBlob(oid: string): Promise<Buffer|Uint8Array|undefined|null> }} */ (this._storage).readBlob(oid);
+    if (buffer === null || buffer === undefined) {
+      throw new Error(`PropertyIndexReader: missing blob for OID '${oid}' (${path})`);
+    }
+    const decoded = this._codec.decode(buffer);
+
+    // Shards are stored as array of [nodeId, props] pairs (proto-safe)
+    if (!Array.isArray(decoded)) {
+      const shape = decoded === null ? 'null' : typeof decoded;
+      throw new Error(`PropertyIndexReader: invalid shard format for '${path}' (expected array, got ${shape})`);
+    }
+
+    /** @type {Record<string, Record<string, unknown>>} */
+    const data = Object.create(null);
+    for (const [nid, props] of /** @type {Array<[string, Record<string, unknown>]>} */ (decoded)) {
+      data[nid] = props;
+    }
+    this._cache.set(path, data);
+    return data;
+  }
+}

package/src/domain/services/QueryBuilder.js

@@ -5,6 +5,7 @@
  */
 
 import QueryError from '../errors/QueryError.js';
+import { matchGlob } from '../utils/matchGlob.js';
 
 const DEFAULT_PATTERN = '*';
 
@@ -48,15 +49,18 @@ const DEFAULT_PATTERN = '*';
  */
 
 /**
- * Asserts that a match pattern is a string.
+ * Asserts that a match pattern is a string or array of strings.
  *
  * @param {unknown} pattern - The pattern to validate
- * @throws {QueryError} If pattern is not a string (code: E_QUERY_MATCH_TYPE)
+ * @throws {QueryError} If pattern is not a string or array of strings (code: E_QUERY_MATCH_TYPE)
  * @private
  */
 function assertMatchPattern(pattern) {
-  if (typeof pattern !== 'string') {
-    throw new QueryError('match() expects a string pattern', {
+  const isString = typeof pattern === 'string';
+  const isStringArray = Array.isArray(pattern) && pattern.every((p) => typeof p === 'string');
+
+  if (!isString && !isStringArray) {
+    throw new QueryError('match() expects a string pattern or array of string patterns', {
       code: 'E_QUERY_MATCH_TYPE',
       context: { receivedType: typeof pattern },
     });
@@ -165,41 +169,6 @@ function sortIds(ids) {
   return [...ids].sort();
 }
 
-/**
- * Escapes special regex characters in a string so it can be used as a literal match.
- *
- * @param {string} value - The string to escape
- * @returns {string} The escaped string safe for use in a RegExp
- * @private
- */
-function escapeRegex(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-/**
- * Tests whether a node ID matches a glob-style pattern.
- *
- * Supports:
- * - `*` as the default pattern, matching all node IDs
- * - Wildcard `*` anywhere in the pattern, matching zero or more characters
- * - Literal match when pattern contains no wildcards
- *
- * @param {string} nodeId - The node ID to test
- * @param {string} pattern - The glob pattern (e.g., "user:*", "*:admin", "*")
- * @returns {boolean} True if the node ID matches the pattern
- * @private
- */
-function matchesPattern(nodeId, pattern) {
-  if (pattern === DEFAULT_PATTERN) {
-    return true;
-  }
-  if (pattern.includes('*')) {
-    const regex = new RegExp(`^${escapeRegex(pattern).replace(/\\\*/g, '.*')}$`);
-    return regex.test(nodeId);
-  }
-  return nodeId === pattern;
-}
-
 /**
  * Recursively freezes an object and all nested objects/arrays.
  *
@@ -494,7 +463,7 @@ export default class QueryBuilder {
    */
   constructor(graph) {
     this._graph = graph;
-    /** @type {string|null} */
+    /** @type {string|string[]|null} */
     this._pattern = null;
     /** @type {Array<{type: string, fn?: (node: QueryNodeSnapshot) => boolean, label?: string, depth?: [number, number]}>} */
     this._operations = [];
@@ -505,19 +474,21 @@ export default class QueryBuilder {
   }
 
   /**
-   * Sets the match pattern for filtering nodes by ID.
+   * Sets the match pattern(s) for filtering nodes by ID.
    *
    * Supports glob-style patterns:
    * - `*` matches all nodes
    * - `user:*` matches all nodes starting with "user:"
    * - `*:admin` matches all nodes ending with ":admin"
+   * - Array of patterns: `['campaign:*', 'milestone:*']` (OR semantics)
    *
-   * @param {string} pattern - Glob pattern to match node IDs against
+   * @param {string|string[]} pattern - Glob pattern or array of patterns to match node IDs against
    * @returns {QueryBuilder} This builder for chaining
-   * @throws {QueryError} If pattern is not a string (code: E_QUERY_MATCH_TYPE)
+   * @throws {QueryError} If pattern is not a string or array of strings (code: E_QUERY_MATCH_TYPE)
    */
   match(pattern) {
     assertMatchPattern(pattern);
+    /** @type {string|string[]|null} */
     this._pattern = pattern;
     return this;
   }
@@ -682,7 +653,7 @@ export default class QueryBuilder {
     const pattern = this._pattern ?? DEFAULT_PATTERN;
 
     let workingSet;
-    workingSet = allNodes.filter((nodeId) => matchesPattern(nodeId, pattern));
+    workingSet = allNodes.filter((nodeId) => matchGlob(pattern, nodeId));
 
     for (const op of this._operations) {
       if (op.type === 'where') {

package/src/domain/services/TemporalQuery.js

@@ -26,7 +26,7 @@
  * @see Paper IV - Echo and the WARP Core (CTL* temporal logic on histories)
  */
 
-import { createEmptyStateV5, join as joinPatch } from './JoinReducer.js';
+import { createEmptyStateV5, cloneStateV5, join as joinPatch } from './JoinReducer.js';
 import { decodePropKey } from './KeyCodec.js';
 import { orsetContains } from '../crdt/ORSet.js';
 
@@ -83,6 +83,64 @@ function extractNodeSnapshot(state, nodeId) {
   return { id: nodeId, exists, props };
 }
 
+/**
+ * Evaluates checkpoint boundary semantics for `always()`.
+ *
+ * @param {Object} params
+ * @param {import('./JoinReducer.js').WarpStateV5} params.state
+ * @param {string} params.nodeId
+ * @param {Function} params.predicate
+ * @param {number|null} params.checkpointMaxLamport
+ * @param {number} params.since
+ * @returns {{ nodeEverExisted: boolean, shouldReturn: boolean, returnValue: boolean }}
+ * @private
+ */
+function evaluateAlwaysCheckpointBoundary({
+  state,
+  nodeId,
+  predicate,
+  checkpointMaxLamport,
+  since,
+}) {
+  if (checkpointMaxLamport !== since) {
+    return { nodeEverExisted: false, shouldReturn: false, returnValue: false };
+  }
+  const snapshot = extractNodeSnapshot(state, nodeId);
+  if (!snapshot.exists) {
+    return { nodeEverExisted: false, shouldReturn: false, returnValue: false };
+  }
+  if (!predicate(snapshot)) {
+    return { nodeEverExisted: true, shouldReturn: true, returnValue: false };
+  }
+  return { nodeEverExisted: true, shouldReturn: false, returnValue: false };
+}
+
+/**
+ * Evaluates checkpoint boundary semantics for `eventually()`.
+ *
+ * @param {Object} params
+ * @param {import('./JoinReducer.js').WarpStateV5} params.state
+ * @param {string} params.nodeId
+ * @param {Function} params.predicate
+ * @param {number|null} params.checkpointMaxLamport
+ * @param {number} params.since
+ * @returns {boolean}
+ * @private
+ */
+function evaluateEventuallyCheckpointBoundary({
+  state,
+  nodeId,
+  predicate,
+  checkpointMaxLamport,
+  since,
+}) {
+  if (checkpointMaxLamport !== since) {
+    return false;
+  }
+  const snapshot = extractNodeSnapshot(state, nodeId);
+  return snapshot.exists && predicate(snapshot);
+}
+
 /**
  * TemporalQuery provides temporal logic operators over graph history.
  *
@@ -94,10 +152,14 @@ export class TemporalQuery {
    * @param {Object} options
    * @param {Function} options.loadAllPatches - Async function that returns
    *   all patches as Array<{ patch, sha }> in causal order.
+   * @param {Function} [options.loadCheckpoint] - Async function returning
+   *   { state: WarpStateV5, maxLamport: number } or null.
    */
-  constructor({ loadAllPatches }) {
+  constructor({ loadAllPatches, loadCheckpoint }) {
     /** @type {Function} */
     this._loadAllPatches = loadAllPatches;
+    /** @type {Function|null} */
+    this._loadCheckpoint = loadCheckpoint || null;
   }
 
   /**
@@ -128,19 +190,27 @@ export class TemporalQuery {
     const since = options.since ?? 0;
     const allPatches = await this._loadAllPatches();
 
-    const state = createEmptyStateV5();
-    let nodeEverExisted = false;
+    const { state, startIdx, checkpointMaxLamport } = await this._resolveStart(allPatches, since);
+    const boundary = evaluateAlwaysCheckpointBoundary({
+      state,
+      nodeId,
+      predicate,
+      checkpointMaxLamport,
+      since,
+    });
+    if (boundary.shouldReturn) {
+      return boundary.returnValue;
+    }
+    let { nodeEverExisted } = boundary;
 
-    for (const { patch, sha } of allPatches) {
-      // Apply the patch to state
+    for (let i = startIdx; i < allPatches.length; i++) {
+      const { patch, sha } = allPatches[i];
       joinPatch(state, patch, sha);
 
-      // Skip patches before the `since` threshold
       if (patch.lamport < since) {
         continue;
       }
 
-      // Extract node snapshot at this tick
       const snapshot = extractNodeSnapshot(state, nodeId);
 
       if (snapshot.exists) {
@@ -151,7 +221,6 @@ export class TemporalQuery {
       }
     }
 
-    // If the node never existed in the range, return false
     return nodeEverExisted;
   }
 
@@ -181,18 +250,26 @@ export class TemporalQuery {
     const since = options.since ?? 0;
     const allPatches = await this._loadAllPatches();
 
-    const state = createEmptyStateV5();
+    const { state, startIdx, checkpointMaxLamport } = await this._resolveStart(allPatches, since);
 
-    for (const { patch, sha } of allPatches) {
-      // Apply the patch to state
+    if (evaluateEventuallyCheckpointBoundary({
+      state,
+      nodeId,
+      predicate,
+      checkpointMaxLamport,
+      since,
+    })) {
+      return true;
+    }
+
+    for (let i = startIdx; i < allPatches.length; i++) {
+      const { patch, sha } = allPatches[i];
       joinPatch(state, patch, sha);
 
-      // Skip patches before the `since` threshold
       if (patch.lamport < since) {
         continue;
       }
 
-      // Extract node snapshot at this tick
       const snapshot = extractNodeSnapshot(state, nodeId);
 
       if (snapshot.exists && predicate(snapshot)) {
@@ -202,4 +279,41 @@ export class TemporalQuery {
 
     return false;
   }
+
+  /**
+   * Resolves the initial state and start index for temporal replay.
+   *
+   * When `since > 0` and a checkpoint is available with
+   * `maxLamport <= since`, uses the checkpoint state and skips
+   * patches already covered by it. Otherwise falls back to an
+   * empty state starting from index 0.
+   *
+   * **Checkpoint `maxLamport` invariant**: The checkpoint's `maxLamport` value
+   * MUST represent a fully-closed Lamport tick — i.e. ALL patches with
+   * `lamport <= maxLamport` are included in the checkpoint state. The
+   * `findIndex` below uses strict `>` to locate the first patch *after* the
+   * checkpoint boundary. If a checkpoint were created mid-tick (some but not
+   * all patches at a given Lamport value included), this would silently skip
+   * the remaining same-tick patches. Checkpoint creators MUST guarantee the
+   * all-or-nothing inclusion property for any given Lamport tick.
+   *
+   * @param {Array<{patch: {lamport: number, [k: string]: unknown}, sha: string}>} allPatches
+   * @param {number} since - Minimum Lamport tick
+   * @returns {Promise<{state: import('./JoinReducer.js').WarpStateV5, startIdx: number, checkpointMaxLamport: number|null}>}
+   * @private
+   */
+  async _resolveStart(allPatches, since) {
+    if (since > 0 && this._loadCheckpoint) {
+      const ck = /** @type {{ state: import('./JoinReducer.js').WarpStateV5, maxLamport: number } | null} */ (await this._loadCheckpoint());
+      if (ck && ck.state && ck.maxLamport <= since) {
+        const idx = allPatches.findIndex(
+          ({ patch }) => patch.lamport > ck.maxLamport,
+        );
+        const startIdx = idx < 0 ? allPatches.length : idx;
+        // Replay mutates state in-place; isolate checkpoint provider caches from query runs.
+        return { state: cloneStateV5(ck.state), startIdx, checkpointMaxLamport: ck.maxLamport };
+      }
+    }
+    return { state: createEmptyStateV5(), startIdx: 0, checkpointMaxLamport: null };
+  }
 }

package/src/domain/services/TranslationCost.js

@@ -15,28 +15,10 @@
 
 import { orsetElements, orsetContains } from '../crdt/ORSet.js';
 import { decodeEdgeKey, decodePropKey, isEdgePropKey } from './KeyCodec.js';
+import { matchGlob } from '../utils/matchGlob.js';
 
 /** @typedef {import('./JoinReducer.js').WarpStateV5} WarpStateV5 */
 
-/**
- * Tests whether a string matches a glob-style pattern.
- *
- * @param {string} pattern - Glob pattern (e.g. 'user:*', '*:admin', '*')
- * @param {string} str - The string to test
- * @returns {boolean} True if the string matches the pattern
- */
-function matchGlob(pattern, str) {
-  if (pattern === '*') {
-    return true;
-  }
-  if (!pattern.includes('*')) {
-    return pattern === str;
-  }
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-  const regex = new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
-  return regex.test(str);
-}
-
 /**
  * Computes the set of property keys visible under an observer config.
  *
@@ -188,20 +170,22 @@ function computePropLoss(state, { nodesA, nodesBSet, configA, configB }) {
  * A's view to B's view. It is asymmetric: cost(A->B) != cost(B->A) in general.
  *
  * @param {Object} configA - Observer configuration for A
- * @param {string} configA.match - Glob pattern for visible nodes
+ * @param {string|string[]} configA.match - Glob pattern(s) for visible nodes
  * @param {string[]} [configA.expose] - Property keys to include
  * @param {string[]} [configA.redact] - Property keys to exclude
  * @param {Object} configB - Observer configuration for B
- * @param {string} configB.match - Glob pattern for visible nodes
+ * @param {string|string[]} configB.match - Glob pattern(s) for visible nodes
  * @param {string[]} [configB.expose] - Property keys to include
  * @param {string[]} [configB.redact] - Property keys to exclude
  * @param {WarpStateV5} state - WarpStateV5 materialized state
  * @returns {{ cost: number, breakdown: { nodeLoss: number, edgeLoss: number, propLoss: number } }}
  */
 export function computeTranslationCost(configA, configB, state) {
-  if (!configA || typeof configA.match !== 'string' ||
-      !configB || typeof configB.match !== 'string') {
-    throw new Error('configA.match and configB.match must be strings');
+  /** @param {unknown} m */
+  const isValidMatch = (m) => typeof m === 'string' || (Array.isArray(m) && m.every(/** @param {unknown} i */ i => typeof i === 'string'));
+  if (!configA || !isValidMatch(configA.match) ||
+      !configB || !isValidMatch(configB.match)) {
+    throw new Error('configA.match and configB.match must be strings or arrays of strings');
   }
   const allNodes = [...orsetElements(state.nodeAlive)];
   const nodesA = allNodes.filter((id) => matchGlob(configA.match, id));

package/src/domain/types/PatchDiff.js

@@ -0,0 +1,90 @@
+/**
+ * PatchDiff — captures alive-ness transitions during patch application.
+ *
+ * A diff entry is produced only when the alive-ness state of a node or edge
+ * actually changes, or when an LWW property winner changes. Redundant ops
+ * (e.g. NodeAdd on an already-alive node) produce no diff entries.
+ *
+ * @module domain/types/PatchDiff
+ */
+
+/**
+ * @typedef {Object} EdgeDiffEntry
+ * @property {string} from  - Source node ID
+ * @property {string} to    - Target node ID
+ * @property {string} label - Edge label
+ */
+
+/**
+ * @typedef {Object} PropDiffEntry
+ * @property {string} nodeId   - Node (or edge-prop owner) ID
+ * @property {string} key      - Property key
+ * @property {unknown} value   - New LWW winner value
+ * @property {unknown} prevValue - Previous LWW winner value (undefined if none)
+ */
+
+/**
+ * @typedef {Object} PatchDiff
+ * @property {string[]} nodesAdded           - Nodes that transitioned not-alive → alive
+ * @property {string[]} nodesRemoved         - Nodes that transitioned alive → not-alive
+ * @property {EdgeDiffEntry[]} edgesAdded    - Edges that transitioned not-alive → alive
+ * @property {EdgeDiffEntry[]} edgesRemoved  - Edges that transitioned alive → not-alive
+ * @property {PropDiffEntry[]} propsChanged  - Properties whose LWW winner actually changed
+ */
+
+/**
+ * Creates an empty PatchDiff.
+ *
+ * @returns {PatchDiff}
+ */
+export function createEmptyDiff() {
+  return {
+    nodesAdded: [],
+    nodesRemoved: [],
+    edgesAdded: [],
+    edgesRemoved: [],
+    propsChanged: [],
+  };
+}
+
+/**
+ * Merges two PatchDiff objects into a net diff by cancelling out
+ * contradictory add/remove pairs.
+ *
+ * - A node that appears in `a.nodesAdded` and `b.nodesRemoved` (or vice-versa)
+ *   is dropped from both lists (the transitions cancel out).
+ * - Same logic applies to edges (keyed by `from\0to\0label`).
+ * - For `propsChanged`, only the last entry per `(nodeId, key)` is kept.
+ *
+ * @param {PatchDiff} a
+ * @param {PatchDiff} b
+ * @returns {PatchDiff}
+ */
+export function mergeDiffs(a, b) {
+  const allAdded = a.nodesAdded.concat(b.nodesAdded);
+  const allRemoved = a.nodesRemoved.concat(b.nodesRemoved);
+  const removedSet = new Set(allRemoved);
+  const addedSet = new Set(allAdded);
+  const nodesAdded = allAdded.filter((id) => !removedSet.has(id));
+  const nodesRemoved = allRemoved.filter((id) => !addedSet.has(id));
+
+  /** @param {EdgeDiffEntry} e */
+  const edgeKey = (e) => `${e.from}\0${e.to}\0${e.label}`;
+  const allEdgesAdded = a.edgesAdded.concat(b.edgesAdded);
+  const allEdgesRemoved = a.edgesRemoved.concat(b.edgesRemoved);
+  const edgeRemovedSet = new Set(allEdgesRemoved.map(edgeKey));
+  const edgeAddedSet = new Set(allEdgesAdded.map(edgeKey));
+  const edgesAdded = allEdgesAdded.filter((e) => !edgeRemovedSet.has(edgeKey(e)));
+  const edgesRemoved = allEdgesRemoved.filter((e) => !edgeAddedSet.has(edgeKey(e)));
+
+  // For props, deduplicate by keeping the last entry per (nodeId, key).
+  const allProps = a.propsChanged.concat(b.propsChanged);
+  /** @type {Map<string, PropDiffEntry>} */
+  const propMap = new Map();
+  for (const entry of allProps) {
+    propMap.set(`${entry.nodeId}\0${entry.key}`, entry);
+  }
+  const propsChanged = [...propMap.values()];
+
+  return { nodesAdded, nodesRemoved, edgesAdded, edgesRemoved, propsChanged };
+}

package/src/domain/types/WarpTypesV2.js

@@ -50,7 +50,7 @@
  * @typedef {Object} OpV2NodeRemove
  * @property {'NodeRemove'} type - Operation type discriminator
  * @property {NodeId} node - Node ID to remove
- * @property {Dot[]} observedDots - Dots being removed (add events observed)
+ * @property {string[]} observedDots - Encoded dot strings being removed (add events observed)
  */
 
 /**
@@ -70,7 +70,7 @@
  * @property {NodeId} from - Source node ID
  * @property {NodeId} to - Target node ID
  * @property {string} label - Edge label/type
- * @property {Dot[]} observedDots - Dots being removed (add events observed)
+ * @property {string[]} observedDots - Encoded dot strings being removed (add events observed)
  */
 
 /**
@@ -121,7 +121,7 @@ export function createNodeAddV2(node, dot) {
 /**
  * Creates a NodeRemove operation with observed dots
  * @param {NodeId} node - Node ID to remove
- * @param {Dot[]} observedDots - Dots being removed
+ * @param {string[]} observedDots - Encoded dot strings being removed
  * @returns {OpV2NodeRemove} NodeRemove operation
  */
 export function createNodeRemoveV2(node, observedDots) {
@@ -145,7 +145,7 @@ export function createEdgeAddV2(from, to, label, dot) {
  * @param {NodeId} from - Source node ID
  * @param {NodeId} to - Target node ID
  * @param {string} label - Edge label
- * @param {Dot[]} observedDots - Dots being removed
+ * @param {string[]} observedDots - Encoded dot strings being removed
  * @returns {OpV2EdgeRemove} EdgeRemove operation
  */
 export function createEdgeRemoveV2(from, to, label, observedDots) {