json-patch-to-crdt 0.0.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Samuel Laycock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,416 @@
+# json-patch-to-crdt
+
+Convert JSON Patch (RFC 6902) operations into a CRDT-friendly data structure and back to JSON.
+
+This package is for applications that need to:
+
+- Apply JSON Patch operations locally.
+- Maintain a CRDT-compatible document model for sync.
+- Merge divergent document states from multiple peers.
+- Serialize and restore CRDT state safely.
+- Generate JSON Patch deltas using explicit base snapshots.
+
+It models JSON with:
+
+- LWW registers for primitives.
+- An RGA sequence for arrays.
+- A map with delete-wins semantics for objects.
+
+## Install
+
+```bash
+bun add json-patch-to-crdt
+```
+
+```bash
+npm install json-patch-to-crdt
+```
+
+## Runtime Requirements
+
+- Node.js `>= 18` (for package consumers).
+- TypeScript `^5` when type-checking in your project.
+- Bun is optional (used for this repo's own build/test scripts).
+
+## Quick Start (Recommended API)
+
+```ts
+import { applyPatch, createState, toJson, type JsonPatchOp } from "json-patch-to-crdt";
+
+const state = createState({ list: ["a", "b"], meta: { ok: true } }, { actor: "A" });
+
+const patch: JsonPatchOp[] = [
+  { op: "add", path: "/list/-", value: "c" },
+  { op: "replace", path: "/meta/ok", value: false },
+];
+
+try {
+  const next = applyPatch(state, patch);
+  console.log(toJson(next));
+} catch (err) {
+  // PatchError has a `.code` you can inspect if needed.
+  throw err;
+}
+```
+
+## Multi-Peer Sync
+
+Two peers can start from a shared state, apply patches independently, and merge:
+
+```ts
+import {
+  applyPatch,
+  cloneDoc,
+  createClock,
+  createState,
+  mergeState,
+  toJson,
+  type CrdtState,
+} from "json-patch-to-crdt";
+
+// Both peers start from the same origin state.
+const origin = createState({ count: 0, items: ["a"] }, { actor: "origin" });
+
+// Each peer gets a clone of the document with its own clock.
+const peerA: CrdtState = {
+  doc: cloneDoc(origin.doc),
+  clock: createClock("A", origin.clock.ctr),
+};
+const peerB: CrdtState = {
+  doc: cloneDoc(origin.doc),
+  clock: createClock("B", origin.clock.ctr),
+};
+
+// Peers diverge with independent edits.
+const a1 = applyPatch(peerA, [
+  { op: "replace", path: "/count", value: 1 },
+  { op: "add", path: "/items/-", value: "b" },
+]);
+
+const b1 = applyPatch(peerB, [
+  { op: "replace", path: "/count", value: 2 },
+  { op: "add", path: "/items/-", value: "c" },
+]);
+
+// Each peer merges while preserving its own actor identity.
+const mergedAtA = mergeState(a1, b1, { actor: "A" });
+const mergedAtB = mergeState(b1, a1, { actor: "B" });
+
+console.log(toJson(mergedAtA));
+// { count: 2, items: ["a", "c", "b"] }
+// (both appends preserved; sibling order follows dot ordering)
+
+// Both peers can continue editing safely.
+const a2 = applyPatch(mergedAtA, [{ op: "replace", path: "/count", value: 3 }]);
+const b2 = applyPatch(mergedAtB, [{ op: "add", path: "/items/-", value: "d" }]);
+
+// Merge again to converge.
+const converged = mergeState(a2, b2, { actor: "A" });
+console.log(toJson(converged));
+// { count: 3, items: ["a", "c", "b", "d"] }
+```
+
+## Concepts
+
+- **Doc**: CRDT document node graph.
+- **State**: `{ doc, clock }`, where `clock` yields new dots.
+- **Base snapshot**: explicit JSON or CRDT doc used to interpret array indices and compute deltas.
+
+## Ordered Event Log Server Pattern
+
+If your service contract is "JSON Patch in / JSON Patch out", and your backend keeps CRDT metadata internally:
+
+- Keep one authoritative CRDT head per document.
+- Keep a version vector keyed by actor ID.
+- On each incoming JSON Patch, call `applyPatchAsActor(headDoc, vv, actor, patch, { base })`.
+- Append the accepted event to your ordered log.
+- For downstream clients, emit `crdtToJsonPatch(clientBaseDoc, currentHeadDoc)`.
+
+Minimal shape:
+
+```ts
+import {
+  applyPatchAsActor,
+  PatchError,
+  crdtToJsonPatch,
+  createState,
+  type Doc,
+  type JsonPatchOp,
+  type VersionVector,
+} from "json-patch-to-crdt";
+
+let head: Doc = createState({ list: [] }, { actor: "server" }).doc;
+let vv: VersionVector = {};
+
+function applyIncomingPatch(
+  actor: string,
+  base: Doc,
+  patch: JsonPatchOp[],
+): { ok: true; outPatch: JsonPatchOp[] } | { ok: false; code: number; message: string } {
+  try {
+    const applied = applyPatchAsActor(head, vv, actor, patch, { base });
+    head = applied.state.doc;
+    vv = applied.vv;
+
+    // Persist incoming event and/or outPatch in your append-only ordered log.
+    const outPatch = crdtToJsonPatch(base, head);
+    return { ok: true, outPatch };
+  } catch (error) {
+    if (error instanceof PatchError) {
+      return { ok: false, code: error.code, message: error.message };
+    }
+
+    throw error;
+  }
+}
+```
+
+If you prefer a non-throwing low-level compile+apply path, use `jsonPatchToCrdtSafe`.
+
+## Patch Semantics
+
+- Patches are interpreted relative to a base snapshot.
+- `applyPatch` defaults to a safe snapshot of the current state as its base.
+- You can pass an explicit base doc via `applyPatch(state, patch, { base })`.
+- Patch semantics are configurable: `semantics: "base"` (default) or `"sequential"`.
+- In `sequential` mode with an explicit `base`, operations are interpreted against a rolling base snapshot while being applied step-by-step to the evolving head.
+- Array indexes are mapped to element IDs based on the base snapshot.
+- `"-"` is treated as append for array inserts.
+- Missing arrays in the base snapshot only allow inserts at index `0` or `"-"`; other indexes throw a `PatchError` with code `409`.
+- `test` operations can be evaluated against `head` or `base` using the `testAgainst` option.
+
+### Semantics Modes
+
+- `semantics: "base"` (default): interprets the full patch relative to one fixed snapshot.
+- `semantics: "sequential"`: applies operations one-by-one against the evolving head (closest to RFC 6902 execution style).
+
+#### Which Mode Should You Use?
+
+| If you need...                                                            | Use                       |
+| ------------------------------------------------------------------------- | ------------------------- |
+| Deterministic CRDT-style replay against a known snapshot                  | `semantics: "base"`       |
+| JSON Patch behavior that feels closest to RFC 6902 step-by-step execution | `semantics: "sequential"` |
+| Step-by-step replay from an explicit historical base                      | `semantics: "sequential"` |
+
+Example:
+
+```ts
+const baseMode = applyPatch(state, [{ op: "add", path: "/list/0", value: "x" }], {
+  semantics: "base",
+});
+
+const sequentialMode = applyPatch(state, [{ op: "add", path: "/list/0", value: "x" }], {
+  semantics: "sequential",
+});
+```
+
+## Delta Patches (First-Class)
+
+If you want a JSON Patch delta, you must provide a base snapshot. This is a first-class API:
+
+```ts
+import { crdtToJsonPatch } from "json-patch-to-crdt";
+
+const delta = crdtToJsonPatch(baseDoc, headDoc);
+```
+
+You can also diff JSON directly:
+
+```ts
+import { diffJsonPatch } from "json-patch-to-crdt";
+
+const delta = diffJsonPatch(baseJson, nextJson);
+```
+
+If you need a full-state root `replace` patch (no delta), use `crdtToFullReplace`:
+
+```ts
+import { crdtToFullReplace } from "json-patch-to-crdt";
+
+const fullPatch = crdtToFullReplace(doc);
+// [{ op: "replace", path: "", value: { ... } }]
+```
+
+### Array Delta Strategy
+
+By default, arrays are diffed with deterministic LCS edits.
+
+If you want atomic array replacement, pass `{ arrayStrategy: "atomic" }`:
+
+```ts
+const delta = crdtToJsonPatch(baseDoc, headDoc, { arrayStrategy: "atomic" });
+```
+
+Notes:
+
+- LCS diffs are deterministic but not necessarily minimal.
+- Reorders are expressed as remove/add pairs.
+
+## Merging
+
+Merge two divergent CRDT documents or states:
+
+```ts
+import { mergeDoc, mergeState } from "json-patch-to-crdt";
+
+// Merge documents (low-level):
+const mergedDoc = mergeDoc(docA, docB);
+
+// Merge full states (preserve local actor identity):
+const mergedState = mergeState(stateA, stateB, { actor: "A" });
+```
+
+By default, merge checks that non-empty arrays share lineage (common element IDs).
+If you intentionally need best-effort merging of unrelated array histories, disable this guard:
+
+```ts
+const mergedDoc = mergeDoc(docA, docB, { requireSharedOrigin: false });
+```
+
+Resolution rules:
+
+- **LWW registers**: the register with the higher dot wins.
+- **Objects**: entries merge key-by-key; delete-wins semantics apply.
+- **RGA arrays**: elements union by ID; tombstones propagate (delete wins).
+- **Kind mismatch**: the node with the higher representative dot wins.
+
+`mergeDoc` is commutative (`merge(a, b)` equals `merge(b, a)`) and idempotent.
+For `mergeState`, pass the local actor explicitly (or as the first argument) so each peer keeps a stable actor ID.
+
+## Serialization
+
+```ts
+import {
+  createState,
+  serializeState,
+  deserializeState,
+  applyPatch,
+  toJson,
+} from "json-patch-to-crdt";
+
+const state = createState({ a: 1 }, { actor: "A" });
+const payload = serializeState(state);
+
+const restored = deserializeState(payload);
+const next = applyPatch(restored, [{ op: "replace", path: "/a", value: 2 }]);
+
+console.log(toJson(next));
+```
+
+## Supported JSON Patch Ops
+
+- `add`, `remove`, `replace`, `move`, `copy`, `test`.
+- `move` and `copy` are compiled to `add` + optional `remove` using the base snapshot.
+- Object operations follow strict parent/target checks (no implicit object path creation).
+
+## Error Handling
+
+High-level `applyPatch` throws `PatchError` on failure and returns a new state:
+
+```ts
+import { applyPatch, PatchError } from "json-patch-to-crdt";
+
+try {
+  const next = applyPatch(state, patch);
+} catch (err) {
+  if (err instanceof PatchError) {
+    console.error(err.code, err.message);
+  }
+}
+```
+
+Low-level APIs (`applyIntentsToCrdt`, `jsonPatchToCrdt`) return `{ ok: false, code: 409, message }` for apply-time conflicts.
+Compile-time patch issues (invalid pointers, missing object parents/targets) throw errors unless you use `jsonPatchToCrdtSafe`.
+
+## API Summary
+
+### State helpers
+
+- `createState(initial, { actor, start? })` - Create a new CRDT state from JSON.
+- `applyPatch(state, patch, options?)` - Apply a patch immutably, returning a new state (`semantics: "base"` by default).
+- `applyPatchInPlace(state, patch, options?)` - Apply a patch by mutating state in place (atomic by default, `atomic: false` for legacy behavior).
+- `applyPatchAsActor(doc, vv, actor, patch, options?)` - Apply a patch for a server-tracked actor and return updated `{ state, vv }`.
+- `toJson(docOrState)` - Materialize a JSON value from a doc or state.
+- `PatchError` - Error class thrown for failed patches (code `409`).
+
+### Clock helpers
+
+- `createClock(actor, start?)` - Create a new clock for dot generation.
+- `cloneClock(clock)` - Clone a clock independently.
+- `nextDotForActor(vv, actor)` - Generate a dot for any actor from a shared version-vector map.
+- `observeDot(vv, dot)` - Record observed dots into that map.
+
+### Document helpers
+
+- `docFromJson(value, nextDot)` - Create a CRDT doc using fresh dots per node.
+- `cloneDoc(doc)` - Deep-clone a document.
+- `materialize(node)` - Convert a CRDT node to a JSON value.
+
+### Merge helpers
+
+- `mergeDoc(a, b, options?)` - Merge two CRDT documents (`options.requireSharedOrigin` defaults to `true`).
+- `mergeState(a, b, options?)` - Merge two CRDT states (doc + clock), preserving actor identity (`options.actor`) and optional shared-origin checks.
+
+### Patch helpers
+
+- `compileJsonPatchToIntent(baseJson, patch)` - Compile JSON Patch to intent operations.
+- `applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst?, bumpCounterAbove?)` - Apply intents to a document.
+- `jsonPatchToCrdt(base, head, patch, newDot, evalTestAgainst?, bumpCounterAbove?)` - Compile and apply in one step.
+- `jsonPatchToCrdtSafe(base, head, patch, newDot, evalTestAgainst?, bumpCounterAbove?)` - Safe compile+apply wrapper that returns `409` results instead of throwing on compile-time patch issues.
+- `diffJsonPatch(baseJson, nextJson, options?)` - Compute a JSON Patch delta between two JSON values.
+- `crdtToJsonPatch(baseDoc, headDoc, options?)` - Compute a JSON Patch delta between two CRDT docs.
+- `crdtToFullReplace(doc)` - Emit a full-state root `replace` patch.
+
+### Serialization
+
+- `serializeDoc(doc)` / `deserializeDoc(payload)` - Serialize/restore a document.
+- `serializeState(state)` / `deserializeState(payload)` - Serialize/restore a full state.
+
+### Internals (`json-patch-to-crdt/internals`)
+
+Low-level helpers are available via a separate entry point for advanced use:
+
+```ts
+import { compareDot, rgaInsertAfter, objSet, HEAD } from "json-patch-to-crdt/internals";
+```
+
+This includes: `compareDot`, `vvHasDot`, `vvMerge`, `dotToElemId`, `newObj`, `newSeq`, `newReg`, `lwwSet`, `objSet`, `objRemove`, `HEAD`, `rgaInsertAfter`, `rgaDelete`, `rgaLinearizeIds`, `rgaPrevForInsertAtIndex`, `rgaIdAtIndex`, `docFromJsonWithDot`.
+
+## Determinism
+
+- Object key ordering in deltas is stable (sorted keys).
+- LCS array diffs are deterministic.
+- Repeated runs for identical inputs yield identical patches.
+
+## FAQ / Troubleshooting
+
+**Why did I get `PatchError` with code `409`?**
+This typically means the patch could not be applied against the base snapshot. Common causes:
+
+- Array index out of bounds relative to the base snapshot.
+- `test` op failed (value mismatch).
+- Base array missing for a non-append insert.
+
+**How do I avoid `409` for arrays?**
+Always pass a base snapshot that matches the array you are patching. If the array may be missing, only insert at index `0` or `"-"` (append) to allow auto-creation.
+
+**How do I get a full-state patch instead of a delta?**
+Use `crdtToFullReplace(doc)` which emits a single root `replace` patch.
+
+**Why do array deltas look bigger than expected?**
+LCS diffs are deterministic, not minimal. If you prefer one-op array replacement, use `{ arrayStrategy: "atomic" }`.
+
+**Does LCS guarantee the smallest patch?**
+No. It is deterministic and usually compact, but not guaranteed to be minimal.
+
+**How do I merge states from two peers?**
+Use `mergeState(local, remote, { actor: localActorId })`. Both peers should start from a shared origin state (same document, different clocks), and each peer should keep its own unique actor ID across merges. See the [Multi-Peer Sync](#multi-peer-sync) example above.
+
+**Why can my local counter jump after a merge?**
+Array inserts that target an existing predecessor may need to outrank sibling insert dots for deterministic ordering. The library can fast-forward the local counter in constant time to avoid expensive loops, but the resulting counter value may still jump upward when merging with peers that already have high counters.
+
+## Limitations
+
+- The array materialization and insert mapping depend on a base snapshot; concurrent inserts resolve by dot order.
+- Under highly skewed peer counters, local counters may jump upward after merges to preserve deterministic insert ordering.
+- Merge requires both peers to have started from the same origin document so that shared elements have matching IDs.

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { $ as PatchSemantics, A as createState, B as Dot, C as createClock, D as applyPatch, E as PatchError, F as ApplyResult, G as JsonPrimitive, H as IntentOp, I as Clock, J as MergeDocOptions, K as JsonValue, L as CrdtState, M as ActorId, N as ApplyPatchAsActorResult, O as applyPatchAsActor, P as ApplyPatchOptions, Q as ObjNode, R as DiffOptions, S as cloneClock, T as observeDot, U as JsonPatch, V as ElemId, W as JsonPatchOp, X as Node, Y as MergeStateOptions, Z as ObjEntry, _ as crdtToJsonPatch, a as deserializeState, at as SerializedState, b as jsonPatchToCrdt, c as compileJsonPatchToIntent, d as jsonEquals, f as parseJsonPointer, g as crdtToFullReplace, h as cloneDoc, i as deserializeDoc, it as SerializedNode, j as toJson, k as applyPatchInPlace, l as diffJsonPatch, m as applyIntentsToCrdt, n as mergeState, nt as RgaSeq, o as serializeDoc, ot as VersionVector, p as stringifyJsonPointer, q as LwwReg, r as materialize, rt as SerializedDoc, s as serializeState, t as mergeDoc, tt as RgaElem, u as getAtJson, v as docFromJson, w as nextDotForActor, x as jsonPatchToCrdtSafe, z as Doc } from "./merge-BpAUNaPe.mjs";
+export { type ActorId, type ApplyPatchAsActorResult, type ApplyPatchOptions, type ApplyResult, type Clock, type CrdtState, type DiffOptions, type Doc, type Dot, type ElemId, type IntentOp, type JsonPatch, type JsonPatchOp, type JsonPrimitive, type JsonValue, type LwwReg, type MergeDocOptions, type MergeStateOptions, type Node, type ObjEntry, type ObjNode, PatchError, type PatchSemantics, type RgaElem, type RgaSeq, type SerializedDoc, type SerializedNode, type SerializedState, type VersionVector, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, materialize, mergeDoc, mergeState, nextDotForActor, observeDot, parseJsonPointer, serializeDoc, serializeState, stringifyJsonPointer, toJson };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { $ as PatchSemantics, A as createState, B as Dot, C as createClock, D as applyPatch, E as PatchError, F as ApplyResult, G as JsonPrimitive, H as IntentOp, I as Clock, J as MergeDocOptions, K as JsonValue, L as CrdtState, M as ActorId, N as ApplyPatchAsActorResult, O as applyPatchAsActor, P as ApplyPatchOptions, Q as ObjNode, R as DiffOptions, S as cloneClock, T as observeDot, U as JsonPatch, V as ElemId, W as JsonPatchOp, X as Node, Y as MergeStateOptions, Z as ObjEntry, _ as crdtToJsonPatch, a as deserializeState, at as SerializedState, b as jsonPatchToCrdt, c as compileJsonPatchToIntent, d as jsonEquals, f as parseJsonPointer, g as crdtToFullReplace, h as cloneDoc, i as deserializeDoc, it as SerializedNode, j as toJson, k as applyPatchInPlace, l as diffJsonPatch, m as applyIntentsToCrdt, n as mergeState, nt as RgaSeq, o as serializeDoc, ot as VersionVector, p as stringifyJsonPointer, q as LwwReg, r as materialize, rt as SerializedDoc, s as serializeState, t as mergeDoc, tt as RgaElem, u as getAtJson, v as docFromJson, w as nextDotForActor, x as jsonPatchToCrdtSafe, z as Doc } from "./merge-QmPXxE6_.js";
+export { type ActorId, type ApplyPatchAsActorResult, type ApplyPatchOptions, type ApplyResult, type Clock, type CrdtState, type DiffOptions, type Doc, type Dot, type ElemId, type IntentOp, type JsonPatch, type JsonPatchOp, type JsonPrimitive, type JsonValue, type LwwReg, type MergeDocOptions, type MergeStateOptions, type Node, type ObjEntry, type ObjNode, PatchError, type PatchSemantics, type RgaElem, type RgaSeq, type SerializedDoc, type SerializedNode, type SerializedState, type VersionVector, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, materialize, mergeDoc, mergeState, nextDotForActor, observeDot, parseJsonPointer, serializeDoc, serializeState, stringifyJsonPointer, toJson };

package/dist/index.js

@@ -0,0 +1,33 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_merge = require('./merge-B1BFMhJJ.js');
+
+exports.PatchError = require_merge.PatchError;
+exports.applyIntentsToCrdt = require_merge.applyIntentsToCrdt;
+exports.applyPatch = require_merge.applyPatch;
+exports.applyPatchAsActor = require_merge.applyPatchAsActor;
+exports.applyPatchInPlace = require_merge.applyPatchInPlace;
+exports.cloneClock = require_merge.cloneClock;
+exports.cloneDoc = require_merge.cloneDoc;
+exports.compileJsonPatchToIntent = require_merge.compileJsonPatchToIntent;
+exports.crdtToFullReplace = require_merge.crdtToFullReplace;
+exports.crdtToJsonPatch = require_merge.crdtToJsonPatch;
+exports.createClock = require_merge.createClock;
+exports.createState = require_merge.createState;
+exports.deserializeDoc = require_merge.deserializeDoc;
+exports.deserializeState = require_merge.deserializeState;
+exports.diffJsonPatch = require_merge.diffJsonPatch;
+exports.docFromJson = require_merge.docFromJson;
+exports.getAtJson = require_merge.getAtJson;
+exports.jsonEquals = require_merge.jsonEquals;
+exports.jsonPatchToCrdt = require_merge.jsonPatchToCrdt;
+exports.jsonPatchToCrdtSafe = require_merge.jsonPatchToCrdtSafe;
+exports.materialize = require_merge.materialize;
+exports.mergeDoc = require_merge.mergeDoc;
+exports.mergeState = require_merge.mergeState;
+exports.nextDotForActor = require_merge.nextDotForActor;
+exports.observeDot = require_merge.observeDot;
+exports.parseJsonPointer = require_merge.parseJsonPointer;
+exports.serializeDoc = require_merge.serializeDoc;
+exports.serializeState = require_merge.serializeState;
+exports.stringifyJsonPointer = require_merge.stringifyJsonPointer;
+exports.toJson = require_merge.toJson;

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { C as getAtJson, E as stringifyJsonPointer, G as cloneClock, J as observeDot, K as createClock, P as materialize, S as diffJsonPatch, T as parseJsonPointer, _ as docFromJson, a as serializeDoc, b as jsonPatchToCrdtSafe, c as applyPatch, d as createState, f as toJson, g as crdtToJsonPatch, h as crdtToFullReplace, i as deserializeState, l as applyPatchAsActor, m as cloneDoc, n as mergeState, o as serializeState, p as applyIntentsToCrdt, q as nextDotForActor, r as deserializeDoc, s as PatchError, t as mergeDoc, u as applyPatchInPlace, w as jsonEquals, x as compileJsonPatchToIntent, y as jsonPatchToCrdt } from "./merge-DikOFBWc.mjs";
+
+export { PatchError, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, materialize, mergeDoc, mergeState, nextDotForActor, observeDot, parseJsonPointer, serializeDoc, serializeState, stringifyJsonPointer, toJson };

package/dist/internals.d.mts

@@ -0,0 +1,25 @@
+import { $ as PatchSemantics, A as createState, B as Dot, C as createClock, D as applyPatch, E as PatchError, F as ApplyResult, G as JsonPrimitive, H as IntentOp, I as Clock, J as MergeDocOptions, K as JsonValue, L as CrdtState, M as ActorId, N as ApplyPatchAsActorResult, O as applyPatchAsActor, P as ApplyPatchOptions, Q as ObjNode, R as DiffOptions, S as cloneClock, T as observeDot, U as JsonPatch, V as ElemId, W as JsonPatchOp, X as Node, Y as MergeStateOptions, Z as ObjEntry, _ as crdtToJsonPatch, a as deserializeState, at as SerializedState, b as jsonPatchToCrdt, c as compileJsonPatchToIntent, d as jsonEquals, et as ROOT_KEY, f as parseJsonPointer, g as crdtToFullReplace, h as cloneDoc, i as deserializeDoc, it as SerializedNode, j as toJson, k as applyPatchInPlace, l as diffJsonPatch, m as applyIntentsToCrdt, n as mergeState, nt as RgaSeq, o as serializeDoc, ot as VersionVector, p as stringifyJsonPointer, q as LwwReg, r as materialize, rt as SerializedDoc, s as serializeState, t as mergeDoc, tt as RgaElem, u as getAtJson, v as docFromJson, w as nextDotForActor, x as jsonPatchToCrdtSafe, y as docFromJsonWithDot, z as Doc } from "./merge-BpAUNaPe.mjs";
+
+//#region src/dot.d.ts
+declare function compareDot(a: Dot, b: Dot): number;
+declare function vvHasDot(vv: VersionVector, d: Dot): boolean;
+declare function vvMerge(a: VersionVector, b: VersionVector): VersionVector;
+declare function dotToElemId(d: Dot): ElemId;
+//#endregion
+//#region src/nodes.d.ts
+declare function newObj(): ObjNode;
+declare function newSeq(): RgaSeq;
+declare function newReg(value: JsonValue, dot: Dot): LwwReg;
+declare function lwwSet(reg: LwwReg, value: JsonValue, dot: Dot): void;
+declare function objSet(obj: ObjNode, key: string, node: Node, dot: Dot): void;
+declare function objRemove(obj: ObjNode, key: string, dot: Dot): void;
+//#endregion
+//#region src/rga.d.ts
+declare const HEAD: ElemId;
+declare function rgaLinearizeIds(seq: RgaSeq): ElemId[];
+declare function rgaInsertAfter(seq: RgaSeq, prev: ElemId, id: ElemId, insDot: Dot, value: Node): void;
+declare function rgaDelete(seq: RgaSeq, id: ElemId): void;
+declare function rgaIdAtIndex(seq: RgaSeq, index: number): ElemId | undefined;
+declare function rgaPrevForInsertAtIndex(seq: RgaSeq, index: number): ElemId;
+//#endregion
+export { ActorId, ApplyPatchAsActorResult, ApplyPatchOptions, ApplyResult, Clock, CrdtState, DiffOptions, Doc, Dot, ElemId, HEAD, IntentOp, JsonPatch, JsonPatchOp, JsonPrimitive, JsonValue, LwwReg, MergeDocOptions, MergeStateOptions, Node, ObjEntry, ObjNode, PatchError, PatchSemantics, ROOT_KEY, RgaElem, RgaSeq, SerializedDoc, SerializedNode, SerializedState, VersionVector, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compareDot, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, docFromJsonWithDot, dotToElemId, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, lwwSet, materialize, mergeDoc, mergeState, newObj, newReg, newSeq, nextDotForActor, objRemove, objSet, observeDot, parseJsonPointer, rgaDelete, rgaIdAtIndex, rgaInsertAfter, rgaLinearizeIds, rgaPrevForInsertAtIndex, serializeDoc, serializeState, stringifyJsonPointer, toJson, vvHasDot, vvMerge };

package/dist/internals.d.ts

@@ -0,0 +1,25 @@
+import { $ as PatchSemantics, A as createState, B as Dot, C as createClock, D as applyPatch, E as PatchError, F as ApplyResult, G as JsonPrimitive, H as IntentOp, I as Clock, J as MergeDocOptions, K as JsonValue, L as CrdtState, M as ActorId, N as ApplyPatchAsActorResult, O as applyPatchAsActor, P as ApplyPatchOptions, Q as ObjNode, R as DiffOptions, S as cloneClock, T as observeDot, U as JsonPatch, V as ElemId, W as JsonPatchOp, X as Node, Y as MergeStateOptions, Z as ObjEntry, _ as crdtToJsonPatch, a as deserializeState, at as SerializedState, b as jsonPatchToCrdt, c as compileJsonPatchToIntent, d as jsonEquals, et as ROOT_KEY, f as parseJsonPointer, g as crdtToFullReplace, h as cloneDoc, i as deserializeDoc, it as SerializedNode, j as toJson, k as applyPatchInPlace, l as diffJsonPatch, m as applyIntentsToCrdt, n as mergeState, nt as RgaSeq, o as serializeDoc, ot as VersionVector, p as stringifyJsonPointer, q as LwwReg, r as materialize, rt as SerializedDoc, s as serializeState, t as mergeDoc, tt as RgaElem, u as getAtJson, v as docFromJson, w as nextDotForActor, x as jsonPatchToCrdtSafe, y as docFromJsonWithDot, z as Doc } from "./merge-QmPXxE6_.js";
+
+//#region src/dot.d.ts
+declare function compareDot(a: Dot, b: Dot): number;
+declare function vvHasDot(vv: VersionVector, d: Dot): boolean;
+declare function vvMerge(a: VersionVector, b: VersionVector): VersionVector;
+declare function dotToElemId(d: Dot): ElemId;
+//#endregion
+//#region src/nodes.d.ts
+declare function newObj(): ObjNode;
+declare function newSeq(): RgaSeq;
+declare function newReg(value: JsonValue, dot: Dot): LwwReg;
+declare function lwwSet(reg: LwwReg, value: JsonValue, dot: Dot): void;
+declare function objSet(obj: ObjNode, key: string, node: Node, dot: Dot): void;
+declare function objRemove(obj: ObjNode, key: string, dot: Dot): void;
+//#endregion
+//#region src/rga.d.ts
+declare const HEAD: ElemId;
+declare function rgaLinearizeIds(seq: RgaSeq): ElemId[];
+declare function rgaInsertAfter(seq: RgaSeq, prev: ElemId, id: ElemId, insDot: Dot, value: Node): void;
+declare function rgaDelete(seq: RgaSeq, id: ElemId): void;
+declare function rgaIdAtIndex(seq: RgaSeq, index: number): ElemId | undefined;
+declare function rgaPrevForInsertAtIndex(seq: RgaSeq, index: number): ElemId;
+//#endregion
+export { ActorId, ApplyPatchAsActorResult, ApplyPatchOptions, ApplyResult, Clock, CrdtState, DiffOptions, Doc, Dot, ElemId, HEAD, IntentOp, JsonPatch, JsonPatchOp, JsonPrimitive, JsonValue, LwwReg, MergeDocOptions, MergeStateOptions, Node, ObjEntry, ObjNode, PatchError, PatchSemantics, ROOT_KEY, RgaElem, RgaSeq, SerializedDoc, SerializedNode, SerializedState, VersionVector, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compareDot, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, docFromJsonWithDot, dotToElemId, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, lwwSet, materialize, mergeDoc, mergeState, newObj, newReg, newSeq, nextDotForActor, objRemove, objSet, observeDot, parseJsonPointer, rgaDelete, rgaIdAtIndex, rgaInsertAfter, rgaLinearizeIds, rgaPrevForInsertAtIndex, serializeDoc, serializeState, stringifyJsonPointer, toJson, vvHasDot, vvMerge };

package/dist/internals.js

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_merge = require('./merge-B1BFMhJJ.js');
+
+exports.HEAD = require_merge.HEAD;
+exports.PatchError = require_merge.PatchError;
+exports.ROOT_KEY = require_merge.ROOT_KEY;
+exports.applyIntentsToCrdt = require_merge.applyIntentsToCrdt;
+exports.applyPatch = require_merge.applyPatch;
+exports.applyPatchAsActor = require_merge.applyPatchAsActor;
+exports.applyPatchInPlace = require_merge.applyPatchInPlace;
+exports.cloneClock = require_merge.cloneClock;
+exports.cloneDoc = require_merge.cloneDoc;
+exports.compareDot = require_merge.compareDot;
+exports.compileJsonPatchToIntent = require_merge.compileJsonPatchToIntent;
+exports.crdtToFullReplace = require_merge.crdtToFullReplace;
+exports.crdtToJsonPatch = require_merge.crdtToJsonPatch;
+exports.createClock = require_merge.createClock;
+exports.createState = require_merge.createState;
+exports.deserializeDoc = require_merge.deserializeDoc;
+exports.deserializeState = require_merge.deserializeState;
+exports.diffJsonPatch = require_merge.diffJsonPatch;
+exports.docFromJson = require_merge.docFromJson;
+exports.docFromJsonWithDot = require_merge.docFromJsonWithDot;
+exports.dotToElemId = require_merge.dotToElemId;
+exports.getAtJson = require_merge.getAtJson;
+exports.jsonEquals = require_merge.jsonEquals;
+exports.jsonPatchToCrdt = require_merge.jsonPatchToCrdt;
+exports.jsonPatchToCrdtSafe = require_merge.jsonPatchToCrdtSafe;
+exports.lwwSet = require_merge.lwwSet;
+exports.materialize = require_merge.materialize;
+exports.mergeDoc = require_merge.mergeDoc;
+exports.mergeState = require_merge.mergeState;
+exports.newObj = require_merge.newObj;
+exports.newReg = require_merge.newReg;
+exports.newSeq = require_merge.newSeq;
+exports.nextDotForActor = require_merge.nextDotForActor;
+exports.objRemove = require_merge.objRemove;
+exports.objSet = require_merge.objSet;
+exports.observeDot = require_merge.observeDot;
+exports.parseJsonPointer = require_merge.parseJsonPointer;
+exports.rgaDelete = require_merge.rgaDelete;
+exports.rgaIdAtIndex = require_merge.rgaIdAtIndex;
+exports.rgaInsertAfter = require_merge.rgaInsertAfter;
+exports.rgaLinearizeIds = require_merge.rgaLinearizeIds;
+exports.rgaPrevForInsertAtIndex = require_merge.rgaPrevForInsertAtIndex;
+exports.serializeDoc = require_merge.serializeDoc;
+exports.serializeState = require_merge.serializeState;
+exports.stringifyJsonPointer = require_merge.stringifyJsonPointer;
+exports.toJson = require_merge.toJson;
+exports.vvHasDot = require_merge.vvHasDot;
+exports.vvMerge = require_merge.vvMerge;

package/dist/internals.mjs

@@ -0,0 +1,3 @@
+import { A as newReg, B as rgaPrevForInsertAtIndex, C as getAtJson, D as ROOT_KEY, E as stringifyJsonPointer, F as HEAD, G as cloneClock, H as dotToElemId, I as rgaDelete, J as observeDot, K as createClock, L as rgaIdAtIndex, M as objRemove, N as objSet, O as lwwSet, P as materialize, R as rgaInsertAfter, S as diffJsonPatch, T as parseJsonPointer, U as vvHasDot, V as compareDot, W as vvMerge, _ as docFromJson, a as serializeDoc, b as jsonPatchToCrdtSafe, c as applyPatch, d as createState, f as toJson, g as crdtToJsonPatch, h as crdtToFullReplace, i as deserializeState, j as newSeq, k as newObj, l as applyPatchAsActor, m as cloneDoc, n as mergeState, o as serializeState, p as applyIntentsToCrdt, q as nextDotForActor, r as deserializeDoc, s as PatchError, t as mergeDoc, u as applyPatchInPlace, v as docFromJsonWithDot, w as jsonEquals, x as compileJsonPatchToIntent, y as jsonPatchToCrdt, z as rgaLinearizeIds } from "./merge-DikOFBWc.mjs";
+
+export { HEAD, PatchError, ROOT_KEY, applyIntentsToCrdt, applyPatch, applyPatchAsActor, applyPatchInPlace, cloneClock, cloneDoc, compareDot, compileJsonPatchToIntent, crdtToFullReplace, crdtToJsonPatch, createClock, createState, deserializeDoc, deserializeState, diffJsonPatch, docFromJson, docFromJsonWithDot, dotToElemId, getAtJson, jsonEquals, jsonPatchToCrdt, jsonPatchToCrdtSafe, lwwSet, materialize, mergeDoc, mergeState, newObj, newReg, newSeq, nextDotForActor, objRemove, objSet, observeDot, parseJsonPointer, rgaDelete, rgaIdAtIndex, rgaInsertAfter, rgaLinearizeIds, rgaPrevForInsertAtIndex, serializeDoc, serializeState, stringifyJsonPointer, toJson, vvHasDot, vvMerge };