@git-stunts/git-warp 12.2.0 → 12.3.0

package/src/domain/services/JoinReducer.js

@@ -9,14 +9,16 @@
  * }
  */
 
-import { createORSet, orsetAdd, orsetRemove, orsetJoin, orsetContains } from '../crdt/ORSet.js';
+import { createORSet, orsetAdd, orsetRemove, orsetJoin, orsetContains, orsetClone } from '../crdt/ORSet.js';
 import { createVersionVector, vvMerge, vvClone, vvDeserialize } from '../crdt/VersionVector.js';
 import { lwwSet, lwwMax } from '../crdt/LWW.js';
 import { createEventId, compareEventIds } from '../utils/EventId.js';
 import { createTickReceipt, OP_TYPES } from '../types/TickReceipt.js';
 import { encodeDot } from '../crdt/Dot.js';
-import { encodeEdgeKey, decodeEdgeKey, encodePropKey } from './KeyCodec.js';
+import { encodeEdgeKey, decodeEdgeKey, encodePropKey, encodeEdgePropKey, EDGE_PROP_PREFIX } from './KeyCodec.js';
+import { normalizeRawOp } from './OpNormalizer.js';
 import { createEmptyDiff, mergeDiffs } from '../types/PatchDiff.js';
+import PatchError from '../errors/PatchError.js';
 
 // Re-export key codec functions for backward compatibility
 export {
@@ -26,13 +28,20 @@ export {
   encodeEdgePropKey, isEdgePropKey, decodeEdgePropKey,
 } from './KeyCodec.js';
 
+// Re-export op normalization for consumers that operate on raw patches
+export { normalizeRawOp, lowerCanonicalOp } from './OpNormalizer.js';
+
 /**
  * @typedef {Object} WarpStateV5
  * @property {import('../crdt/ORSet.js').ORSet} nodeAlive - ORSet of alive nodes
  * @property {import('../crdt/ORSet.js').ORSet} edgeAlive - ORSet of alive edges
  * @property {Map<string, import('../crdt/LWW.js').LWWRegister<unknown>>} prop - Properties with LWW
  * @property {import('../crdt/VersionVector.js').VersionVector} observedFrontier - Observed version vector
- * @property {Map<string, import('../utils/EventId.js').EventId>} edgeBirthEvent - EdgeKey → EventId of most recent EdgeAdd (for clean-slate prop visibility)
+ * @property {Map<string, import('../utils/EventId.js').EventId>} edgeBirthEvent - EdgeKey → EventId of most recent EdgeAdd (for clean-slate prop visibility).
+ *   Always present at runtime (initialized to empty Map by createEmptyStateV5 and
+ *   deserializeFullStateV5). Edge birth events were introduced in a later schema
+ *   version; older checkpoints serialize without this field, but the deserializer
+ *   always produces an empty Map for them.
  */
 
 /**
@@ -87,19 +96,173 @@ export function createEmptyStateV5() {
  * @returns {void}
  */
 /**
- * Known V2 operation types. Used for forward-compatibility validation.
+ * Known raw (wire-format) V2 operation types. These are the 6 types that
+ * appear in persisted patches and on the sync wire.
  * @type {ReadonlySet<string>}
  */
-const KNOWN_OPS = new Set(['NodeAdd', 'NodeRemove', 'EdgeAdd', 'EdgeRemove', 'PropSet', 'BlobValue']);
+export const RAW_KNOWN_OPS = new Set([
+  'NodeAdd', 'NodeRemove', 'EdgeAdd', 'EdgeRemove',
+  'PropSet', 'BlobValue',
+]);
+
+/**
+ * Known canonical (internal) V2 operation types. Includes the 6 raw types
+ * plus the ADR 1 canonical split types `NodePropSet` and `EdgePropSet`.
+ * @type {ReadonlySet<string>}
+ */
+export const CANONICAL_KNOWN_OPS = new Set([
+  'NodeAdd', 'NodeRemove', 'EdgeAdd', 'EdgeRemove',
+  'PropSet', 'NodePropSet', 'EdgePropSet', 'BlobValue',
+]);
+
+/**
+ * Validates that an operation has a known raw (wire-format) type.
+ * Use this at sync/wire boundaries to fail-close on unknown or
+ * canonical-only types arriving over the wire.
+ *
+ * @param {{ type: string }} op
+ * @returns {boolean} True if the op type is in RAW_KNOWN_OPS
+ */
+export function isKnownRawOp(op) {
+  return Boolean(op && typeof op.type === 'string' && RAW_KNOWN_OPS.has(op.type));
+}
+
+/**
+ * Validates that an operation has a known canonical (internal) type.
+ * Use this for internal guards after normalization.
+ *
+ * @param {{ type: string }} op
+ * @returns {boolean} True if the op type is in CANONICAL_KNOWN_OPS
+ */
+export function isKnownCanonicalOp(op) {
+  return Boolean(op && typeof op.type === 'string' && CANONICAL_KNOWN_OPS.has(op.type));
+}
 
 /**
  * Validates that an operation has a known type.
  *
+ * @deprecated Use {@link isKnownRawOp} for wire validation or
+ * {@link isKnownCanonicalOp} for internal guards.
  * @param {{ type: string }} op
- * @returns {boolean} True if the op type is in KNOWN_OPS
+ * @returns {boolean} True if the op type is a known raw wire type
  */
 export function isKnownOp(op) {
-  return op && typeof op.type === 'string' && KNOWN_OPS.has(op.type);
+  return isKnownRawOp(op);
+}
+
+/**
+ * Asserts that `op[field]` is a string. Throws PatchError if not.
+ * @param {Record<string, unknown>} op
+ * @param {string} field
+ */
+function requireString(op, field) {
+  if (typeof op[field] !== 'string') {
+    throw new PatchError(
+      `${op.type} op requires '${field}' to be a string, got ${typeof op[field]}`,
+      { context: { opType: op.type, field, actual: typeof op[field] } },
+    );
+  }
+}
+
+/**
+ * Asserts that `op[field]` is iterable (Array, Set, or any Symbol.iterator).
+ * @param {Record<string, unknown>} op
+ * @param {string} field
+ */
+function requireIterable(op, field) {
+  const val = op[field];
+  if (
+    val === null ||
+    val === undefined ||
+    typeof val !== 'object' ||
+    typeof /** @type {Iterable<unknown>} */ (val)[Symbol.iterator] !== 'function'
+  ) {
+    throw new PatchError(
+      `${op.type} op requires '${field}' to be iterable, got ${typeof val}`,
+      { context: { opType: op.type, field, actual: typeof val } },
+    );
+  }
+}
+
+/**
+ * Asserts that `op.dot` is an object with writerId (string) and counter (number).
+ * @param {Record<string, unknown>} op
+ */
+function requireDot(op) {
+  const { dot } = op;
+  if (!dot || typeof dot !== 'object') {
+    throw new PatchError(
+      `${op.type} op requires 'dot' to be an object, got ${typeof dot}`,
+      { context: { opType: op.type, field: 'dot', actual: typeof dot } },
+    );
+  }
+  const d = /** @type {Record<string, unknown>} */ (dot);
+  if (typeof d.writerId !== 'string') {
+    throw new PatchError(
+      `${op.type} op requires 'dot.writerId' to be a string, got ${typeof d.writerId}`,
+      { context: { opType: op.type, field: 'dot.writerId', actual: typeof d.writerId } },
+    );
+  }
+  if (typeof d.counter !== 'number') {
+    throw new PatchError(
+      `${op.type} op requires 'dot.counter' to be a number, got ${typeof d.counter}`,
+      { context: { opType: op.type, field: 'dot.counter', actual: typeof d.counter } },
+    );
+  }
+}
+
+/**
+ * Validates that an operation has the required fields for its type.
+ * Throws PatchError for malformed ops. Unknown/BlobValue types pass through
+ * for forward compatibility.
+ *
+ * @param {Record<string, unknown>} op
+ */
+function validateOp(op) {
+  if (!op || typeof op.type !== 'string') {
+    throw new PatchError(
+      `Invalid op: expected object with string 'type', got ${op === null || op === undefined ? String(op) : typeof op.type}`,
+      { context: { actual: op === null || op === undefined ? String(op) : typeof op.type } },
+    );
+  }
+
+  switch (op.type) {
+    case 'NodeAdd':
+      requireString(op, 'node');
+      requireDot(op);
+      break;
+    case 'NodeRemove':
+      // node is optional (informational for receipts); observedDots is required for mutation
+      requireIterable(op, 'observedDots');
+      break;
+    case 'EdgeAdd':
+      requireString(op, 'from');
+      requireString(op, 'to');
+      requireString(op, 'label');
+      requireDot(op);
+      break;
+    case 'EdgeRemove':
+      // from/to/label are optional (informational for receipts); observedDots is required for mutation
+      requireIterable(op, 'observedDots');
+      break;
+    case 'PropSet':
+      requireString(op, 'node');
+      requireString(op, 'key');
+      break;
+    case 'NodePropSet':
+      requireString(op, 'node');
+      requireString(op, 'key');
+      break;
+    case 'EdgePropSet':
+      requireString(op, 'from');
+      requireString(op, 'to');
+      requireString(op, 'label');
+      requireString(op, 'key');
+      break;
+    default:
+      // BlobValue and unknown types: no validation (forward-compat)
+      break;
+  }
 }
 
 /**
@@ -110,6 +273,7 @@ export function isKnownOp(op) {
  * @param {import('../utils/EventId.js').EventId} eventId - The event ID for LWW ordering
  */
 export function applyOpV2(state, op, eventId) {
+  validateOp(/** @type {Record<string, unknown>} */ (op));
   switch (op.type) {
     case 'NodeAdd':
       orsetAdd(state.nodeAlive, /** @type {string} */ (op.node), /** @type {import('../crdt/Dot.js').Dot} */ (op.dot));
@@ -134,8 +298,34 @@ export function applyOpV2(state, op, eventId) {
     case 'EdgeRemove':
       orsetRemove(state.edgeAlive, /** @type {Set<string>} */ (/** @type {unknown} */ (op.observedDots)));
       break;
+    case 'NodePropSet': {
+      const key = encodePropKey(/** @type {string} */ (op.node), /** @type {string} */ (op.key));
+      const current = state.prop.get(key);
+      state.prop.set(key, /** @type {import('../crdt/LWW.js').LWWRegister<unknown>} */ (lwwMax(current, lwwSet(eventId, op.value))));
+      break;
+    }
+    case 'EdgePropSet': {
+      const key = encodeEdgePropKey(
+        /** @type {string} */ (op.from),
+        /** @type {string} */ (op.to),
+        /** @type {string} */ (op.label),
+        /** @type {string} */ (op.key),
+      );
+      const current = state.prop.get(key);
+      state.prop.set(key, /** @type {import('../crdt/LWW.js').LWWRegister<unknown>} */ (lwwMax(current, lwwSet(eventId, op.value))));
+      break;
+    }
     case 'PropSet': {
-      // Uses EventId-based LWW, same as v4
+      // Legacy raw PropSet — must NOT carry edge-property encoding at this point.
+      // If it does, normalization was skipped.
+      if (typeof op.node === 'string' && op.node[0] === EDGE_PROP_PREFIX) {
+        throw new PatchError(
+          'Unnormalized legacy edge-property PropSet reached canonical apply path. ' +
+          'Call normalizeRawOp() at the decode boundary.',
+          { context: { opType: 'PropSet', node: op.node } },
+        );
+      }
+      // Plain node property (backward-compat for callers that bypass normalization)
       const key = encodePropKey(/** @type {string} */ (op.node), /** @type {string} */ (op.key));
       const current = state.prop.get(key);
       state.prop.set(key, /** @type {import('../crdt/LWW.js').LWWRegister<unknown>} */ (lwwMax(current, lwwSet(eventId, op.value))));
@@ -167,6 +357,8 @@ const RECEIPT_OP_TYPE = {
   EdgeAdd: 'EdgeAdd',
   EdgeRemove: 'EdgeTombstone',
   PropSet: 'PropSet',
+  NodePropSet: 'NodePropSet',
+  EdgePropSet: 'EdgePropSet',
   BlobValue: 'BlobValue',
 };
 
@@ -213,21 +405,18 @@ function nodeAddOutcome(orset, op) {
  * @returns {{target: string, result: 'applied'|'redundant'}} Outcome with node ID (or '*') as target
  */
 function nodeRemoveOutcome(orset, op) {
-  // Check if any of the observed dots are currently non-tombstoned
+  // Build a reverse index (dot → elementId) for the observed dots to avoid
+  // O(|observedDots| × |entries|) scanning. Same pattern as buildDotToElement.
+  const targetDots = op.observedDots instanceof Set
+    ? op.observedDots
+    : new Set(op.observedDots);
+  const dotToElement = buildDotToElement(orset, targetDots);
+
   let effective = false;
-  for (const encodedDot of op.observedDots) {
-    if (!orset.tombstones.has(encodedDot)) {
-      // This dot exists and is not yet tombstoned, so the remove is effective
-      // Check if any entry actually has this dot
-      for (const dots of orset.entries.values()) {
-        if (dots.has(encodedDot)) {
-          effective = true;
-          break;
-        }
-      }
-      if (effective) {
-        break;
-      }
+  for (const encodedDot of targetDots) {
+    if (!orset.tombstones.has(encodedDot) && dotToElement.has(encodedDot)) {
+      effective = true;
+      break;
     }
   }
   const target = op.node || '*';
@@ -279,18 +468,18 @@ function edgeAddOutcome(orset, op, edgeKey) {
  * @returns {{target: string, result: 'applied'|'redundant'}} Outcome with encoded edge key (or '*') as target
  */
 function edgeRemoveOutcome(orset, op) {
+  // Build a reverse index (dot → elementId) for the observed dots to avoid
+  // O(|observedDots| × |entries|) scanning. Same pattern as buildDotToElement.
+  const targetDots = op.observedDots instanceof Set
+    ? op.observedDots
+    : new Set(op.observedDots);
+  const dotToElement = buildDotToElement(orset, targetDots);
+
   let effective = false;
-  for (const encodedDot of op.observedDots) {
-    if (!orset.tombstones.has(encodedDot)) {
-      for (const dots of orset.entries.values()) {
-        if (dots.has(encodedDot)) {
-          effective = true;
-          break;
-        }
-      }
-      if (effective) {
-        break;
-      }
+  for (const encodedDot of targetDots) {
+    if (!orset.tombstones.has(encodedDot) && dotToElement.has(encodedDot)) {
+      effective = true;
+      break;
     }
   }
   // Construct target from op fields if available
@@ -301,7 +490,7 @@ function edgeRemoveOutcome(orset, op) {
 }
 
 /**
- * Determines the receipt outcome for a PropSet operation.
+ * Determines the receipt outcome for a property operation given a pre-computed key.
  *
  * Uses LWW (Last-Write-Wins) semantics to determine whether the incoming property
  * value wins over any existing value. The comparison is based on EventId ordering:
@@ -315,41 +504,61 @@ function edgeRemoveOutcome(orset, op) {
  * - `redundant`: Exact same write (identical EventId)
  *
  * @param {Map<string, import('../crdt/LWW.js').LWWRegister<unknown>>} propMap - The properties map keyed by encoded prop keys
- * @param {Object} op - The PropSet operation
- * @param {string} op.node - Node ID owning the property
- * @param {string} op.key - Property key/name
- * @param {unknown} op.value - Property value to set
+ * @param {string} key - Pre-encoded property key (node or edge)
  * @param {import('../utils/EventId.js').EventId} eventId - The event ID for this operation, used for LWW comparison
  * @returns {{target: string, result: 'applied'|'superseded'|'redundant', reason?: string}}
  *          Outcome with encoded prop key as target; includes reason when superseded
  */
-function propSetOutcome(propMap, op, eventId) {
-  const key = encodePropKey(op.node, op.key);
+function propOutcomeForKey(propMap, key, eventId) {
   const current = propMap.get(key);
-  const target = key;
 
   if (!current) {
-    // No existing value -- this write wins
-    return { target, result: 'applied' };
+    return { target: key, result: 'applied' };
   }
 
-  // Compare the incoming EventId with the existing register's EventId
   const cmp = compareEventIds(eventId, current.eventId);
   if (cmp > 0) {
-    // Incoming write wins
-    return { target, result: 'applied' };
+    return { target: key, result: 'applied' };
   }
   if (cmp < 0) {
-    // Existing write wins
     const winner = current.eventId;
     return {
-      target,
+      target: key,
       result: 'superseded',
       reason: `LWW: writer ${winner.writerId} at lamport ${winner.lamport} wins`,
     };
   }
-  // Same EventId -- redundant (exact same write)
-  return { target, result: 'redundant' };
+  return { target: key, result: 'redundant' };
+}
+
+/**
+ * Determines the receipt outcome for a PropSet/NodePropSet operation.
+ *
+ * @param {Map<string, import('../crdt/LWW.js').LWWRegister<unknown>>} propMap
+ * @param {Object} op
+ * @param {string} op.node - Node ID owning the property
+ * @param {string} op.key - Property key/name
+ * @param {import('../utils/EventId.js').EventId} eventId
+ * @returns {{target: string, result: 'applied'|'superseded'|'redundant', reason?: string}}
+ */
+function propSetOutcome(propMap, op, eventId) {
+  return propOutcomeForKey(propMap, encodePropKey(op.node, op.key), eventId);
+}
+
+/**
+ * Determines the receipt outcome for an EdgePropSet operation.
+ *
+ * @param {Map<string, import('../crdt/LWW.js').LWWRegister<unknown>>} propMap
+ * @param {Object} op
+ * @param {string} op.from
+ * @param {string} op.to
+ * @param {string} op.label
+ * @param {string} op.key
+ * @param {import('../utils/EventId.js').EventId} eventId
+ * @returns {{target: string, result: 'applied'|'superseded'|'redundant', reason?: string}}
+ */
+function edgePropSetOutcome(propMap, op, eventId) {
+  return propOutcomeForKey(propMap, encodeEdgePropKey(op.from, op.to, op.label, op.key), eventId);
 }
 
 /**
@@ -396,7 +605,7 @@ function updateFrontierFromPatch(state, patch) {
 export function applyFast(state, patch, patchSha) {
   for (let i = 0; i < patch.ops.length; i++) {
     const eventId = createEventId(patch.lamport, patch.writer, patchSha, i);
-    applyOpV2(state, patch.ops[i], eventId);
+    applyOpV2(state, normalizeRawOp(patch.ops[i]), eventId);
   }
   updateFrontierFromPatch(state, patch);
   return state;
@@ -491,11 +700,17 @@ function snapshotBeforeOp(state, op) {
       const aliveBeforeEdges = aliveElementsForDots(state.edgeAlive, edgeDots);
       return { aliveBeforeEdges };
     }
-    case 'PropSet': {
+    case 'PropSet':
+    case 'NodePropSet': {
       const pk = encodePropKey(op.node, op.key);
       const reg = state.prop.get(pk);
       return { prevPropValue: reg ? reg.value : undefined, propKey: pk };
     }
+    case 'EdgePropSet': {
+      const epk = encodeEdgePropKey(op.from, op.to, op.label, op.key);
+      const ereg = state.prop.get(epk);
+      return { prevPropValue: ereg ? ereg.value : undefined, propKey: epk };
+    }
     default:
       return {};
   }
@@ -532,7 +747,8 @@ function accumulateOpDiff(diff, state, op, before) {
       collectEdgeRemovals(diff, state, before);
       break;
     }
-    case 'PropSet': {
+    case 'PropSet':
+    case 'NodePropSet': {
       const reg = state.prop.get(/** @type {string} */ (before.propKey));
       const newVal = reg ? reg.value : undefined;
       if (newVal !== before.prevPropValue) {
@@ -545,6 +761,19 @@ function accumulateOpDiff(diff, state, op, before) {
       }
       break;
     }
+    case 'EdgePropSet': {
+      const ereg = state.prop.get(/** @type {string} */ (before.propKey));
+      const eNewVal = ereg ? ereg.value : undefined;
+      if (eNewVal !== before.prevPropValue) {
+        diff.propsChanged.push({
+          nodeId: encodeEdgeKey(op.from, op.to, op.label),
+          key: op.key,
+          value: eNewVal,
+          prevValue: before.prevPropValue,
+        });
+      }
+      break;
+    }
     default:
       break;
   }
@@ -593,7 +822,7 @@ function collectEdgeRemovals(diff, state, before) {
  * @param {Object} patch - The patch to apply
  * @param {string} patch.writer
  * @param {number} patch.lamport
- * @param {Array<Object>} patch.ops
+ * @param {Array<import('../types/WarpTypesV2.js').OpV2 | {type: string}>} patch.ops
  * @param {Map<string, number>|{[x: string]: number}} patch.context
  * @param {string} patchSha - Git SHA of the patch commit
  * @returns {{state: WarpStateV5, diff: import('../types/PatchDiff.js').PatchDiff}}
@@ -602,12 +831,12 @@ export function applyWithDiff(state, patch, patchSha) {
   const diff = createEmptyDiff();
 
   for (let i = 0; i < patch.ops.length; i++) {
-    const op = patch.ops[i];
+    const canonOp = /** @type {import('../types/WarpTypesV2.js').CanonicalOpV2} */ (normalizeRawOp(patch.ops[i]));
+    validateOp(/** @type {Record<string, unknown>} */ (canonOp));
     const eventId = createEventId(patch.lamport, patch.writer, patchSha, i);
-    const typedOp = /** @type {import('../types/WarpTypesV2.js').OpV2} */ (op);
-    const before = snapshotBeforeOp(state, typedOp);
-    applyOpV2(state, typedOp, eventId);
-    accumulateOpDiff(diff, state, typedOp, before);
+    const before = snapshotBeforeOp(state, canonOp);
+    applyOpV2(state, canonOp, eventId);
+    accumulateOpDiff(diff, state, canonOp, before);
   }
 
   updateFrontierFromPatch(state, patch);
@@ -630,40 +859,47 @@ export function applyWithReceipt(state, patch, patchSha) {
   /** @type {import('../types/TickReceipt.js').OpOutcome[]} */
   const opResults = [];
   for (let i = 0; i < patch.ops.length; i++) {
-    const op = patch.ops[i];
+    const canonOp = /** @type {import('../types/WarpTypesV2.js').OpV2} */ (normalizeRawOp(patch.ops[i]));
+    validateOp(/** @type {Record<string, unknown>} */ (canonOp));
     const eventId = createEventId(patch.lamport, patch.writer, patchSha, i);
 
     // Determine outcome BEFORE applying the op (state is pre-op)
     /** @type {{target: string, result: string, reason?: string}} */
     let outcome;
-    switch (op.type) {
+    switch (canonOp.type) {
       case 'NodeAdd':
-        outcome = nodeAddOutcome(state.nodeAlive, /** @type {{node: string, dot: import('../crdt/Dot.js').Dot}} */ (op));
+        outcome = nodeAddOutcome(state.nodeAlive, /** @type {{node: string, dot: import('../crdt/Dot.js').Dot}} */ (canonOp));
         break;
       case 'NodeRemove':
-        outcome = nodeRemoveOutcome(state.nodeAlive, /** @type {{node?: string, observedDots: string[]}} */ (op));
+        outcome = nodeRemoveOutcome(state.nodeAlive, /** @type {{node?: string, observedDots: string[]}} */ (canonOp));
         break;
       case 'EdgeAdd': {
-        const edgeKey = encodeEdgeKey(/** @type {string} */ (op.from), /** @type {string} */ (op.to), /** @type {string} */ (op.label));
-        outcome = edgeAddOutcome(state.edgeAlive, /** @type {{from: string, to: string, label: string, dot: import('../crdt/Dot.js').Dot}} */ (op), edgeKey);
+        const edgeKey = encodeEdgeKey(canonOp.from, canonOp.to, canonOp.label);
+        outcome = edgeAddOutcome(state.edgeAlive, /** @type {{from: string, to: string, label: string, dot: import('../crdt/Dot.js').Dot}} */ (canonOp), edgeKey);
         break;
       }
       case 'EdgeRemove':
-        outcome = edgeRemoveOutcome(state.edgeAlive, /** @type {{from?: string, to?: string, label?: string, observedDots: string[]}} */ (op));
+        outcome = edgeRemoveOutcome(state.edgeAlive, /** @type {{from?: string, to?: string, label?: string, observedDots: string[]}} */ (canonOp));
         break;
       case 'PropSet':
-        outcome = propSetOutcome(state.prop, /** @type {{node: string, key: string, value: *}} */ (op), eventId);
+      case 'NodePropSet':
+        outcome = propSetOutcome(state.prop, /** @type {{node: string, key: string, value: *}} */ (canonOp), eventId);
+        break;
+      case 'EdgePropSet':
+        outcome = edgePropSetOutcome(state.prop, /** @type {{from: string, to: string, label: string, key: string, value: *}} */ (canonOp), eventId);
         break;
-      default:
+      default: {
         // Unknown or BlobValue — always applied
-        outcome = { target: op.node || op.oid || '*', result: 'applied' };
+        const anyOp = /** @type {Record<string, string>} */ (canonOp);
+        outcome = { target: anyOp.node || anyOp.oid || '*', result: 'applied' };
         break;
+      }
     }
 
     // Apply the op (mutates state)
-    applyOpV2(state, op, eventId);
+    applyOpV2(state, canonOp, eventId);
 
-    const receiptOp = /** @type {Record<string, string>} */ (RECEIPT_OP_TYPE)[op.type] || op.type;
+    const receiptOp = /** @type {Record<string, string>} */ (RECEIPT_OP_TYPE)[canonOp.type] || canonOp.type;
     // Skip unknown/forward-compatible op types that aren't valid receipt ops
     if (!VALID_RECEIPT_OPS.has(receiptOp)) {
       continue;
@@ -868,16 +1104,16 @@ export function reduceV5(patches, initialState, options) {
  * - Creating a branch point for speculative execution
  * - Ensuring immutability when passing state across API boundaries
  *
- * **Implementation Note**: OR-Sets are cloned by joining with an empty set,
- * which creates new data structures with identical contents.
+ * **Implementation Note**: OR-Sets are cloned via `orsetClone()` which
+ * directly copies entries and tombstones without merge logic overhead.
  *
  * @param {WarpStateV5} state - The state to clone
  * @returns {WarpStateV5} A new state with identical contents but independent data structures
  */
 export function cloneStateV5(state) {
   return {
-    nodeAlive: orsetJoin(state.nodeAlive, createORSet()),
-    edgeAlive: orsetJoin(state.edgeAlive, createORSet()),
+    nodeAlive: orsetClone(state.nodeAlive),
+    edgeAlive: orsetClone(state.edgeAlive),
     prop: new Map(state.prop),
     observedFrontier: vvClone(state.observedFrontier),
     edgeBirthEvent: new Map(state.edgeBirthEvent || []),

package/src/domain/services/KeyCodec.js

@@ -91,6 +91,54 @@ export function encodeEdgePropKey(from, to, label, propKey) {
   return `${EDGE_PROP_PREFIX}${from}\0${to}\0${label}\0${propKey}`;
 }
 
+// -------------------------------------------------------------------------
+// Legacy edge-property node encoding (raw PropSet ↔ canonical EdgePropSet)
+// -------------------------------------------------------------------------
+
+/**
+ * Encodes edge identity as the legacy `node` field value for raw PropSet ops.
+ *
+ * Format: `\x01from\0to\0label`
+ *
+ * @param {string} from - Source node ID
+ * @param {string} to - Target node ID
+ * @param {string} label - Edge label
+ * @returns {string}
+ */
+export function encodeLegacyEdgePropNode(from, to, label) {
+  return `${EDGE_PROP_PREFIX}${from}\0${to}\0${label}`;
+}
+
+/**
+ * Returns true if a raw PropSet `node` field encodes an edge identity.
+ * @param {string} node - The `node` field from a raw PropSet op
+ * @returns {boolean}
+ */
+export function isLegacyEdgePropNode(node) {
+  return typeof node === 'string' && node.length > 0 && node[0] === EDGE_PROP_PREFIX;
+}
+
+/**
+ * Decodes a legacy edge-property `node` field back to its components.
+ * @param {string} node - The `node` field (must start with \x01)
+ * @returns {{from: string, to: string, label: string}}
+ * @throws {Error} If the node field is not a valid legacy edge-property encoding
+ */
+export function decodeLegacyEdgePropNode(node) {
+  if (!isLegacyEdgePropNode(node)) {
+    throw new Error('Invalid legacy edge-property node: missing \\x01 prefix');
+  }
+  const parts = node.slice(1).split('\0');
+  if (parts.length !== 3) {
+    throw new Error(`Invalid legacy edge-property node: expected 3 segments, got ${parts.length}`);
+  }
+  const [from, to, label] = parts;
+  if (!from || !to || !label) {
+    throw new Error('Invalid legacy edge-property node: empty segment in decoded parts');
+  }
+  return { from, to, label };
+}
+
 /**
  * Returns true if the encoded key is an edge property key.
  * @param {string} key - Encoded property key