@storacha/md-merge 0.2.1 → 0.3.0

package/dist/codec.d.ts

@@ -1,29 +1,18 @@
 /**
  * DAG-CBOR serialization for RGATree and RGAChangeSet.
  *
- * Converts RGA class instances (with Maps, nested RGAs) to plain
- * CBOR-friendly objects and back.
+ * Tree-specific serialization wraps the generic RGA codec from crdt/codec.ts,
+ * adding recursive handling of nested RGA children in tree nodes.
  */
 import { type RGAEvent, type EventComparator } from './crdt/rga.js';
 import type { RGATreeRoot, RGATreeNode } from './types.js';
 import type { RGAChangeSet } from './types.js';
-/**
- * Encode an RGATree as a DAG-CBOR block.
- */
+export { encodeRGA, decodeRGA } from './crdt/codec.js';
 export declare function encodeTree<E extends RGAEvent>(root: RGATreeRoot<E>): Promise<import("multiformats").BlockView<unknown, 113, 18, 1>>;
-/**
- * Decode an RGATree from a DAG-CBOR block.
- */
 export declare function decodeTree<E extends RGAEvent>(block: {
     bytes: Uint8Array;
 }, parseEvent: (s: string) => E, fingerprintFn: (value: RGATreeNode<E>) => string, compareEvents: EventComparator<E>): Promise<RGATreeRoot<E>>;
-/**
- * Encode an RGAChangeSet as a DAG-CBOR block.
- */
 export declare function encodeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): Promise<import("multiformats").BlockView<unknown, 113, 18, 1>>;
-/**
- * Decode an RGAChangeSet from a DAG-CBOR block.
- */
 export declare function decodeChangeSet<E extends RGAEvent>(block: {
     bytes: Uint8Array;
 }, parseEvent: (s: string) => E): Promise<RGAChangeSet<E>>;

package/dist/codec.js

@@ -1,36 +1,17 @@
 /**
  * DAG-CBOR serialization for RGATree and RGAChangeSet.
  *
- * Converts RGA class instances (with Maps, nested RGAs) to plain
- * CBOR-friendly objects and back.
+ * Tree-specific serialization wraps the generic RGA codec from crdt/codec.ts,
+ * adding recursive handling of nested RGA children in tree nodes.
  */
 import { encode, decode } from 'multiformats/block';
 import { sha256 } from 'multiformats/hashes/sha2';
 import * as cbor from '@ipld/dag-cbor';
 import { RGA } from './crdt/rga.js';
-/** Recursively strip `undefined` values (not IPLD-compatible). */
-function stripUndefined(obj) {
-    if (obj === null || obj === undefined)
-        return null;
-    if (Array.isArray(obj))
-        return obj.map(stripUndefined);
-    if (typeof obj === 'object') {
-        const clean = {};
-        for (const [k, v] of Object.entries(obj)) {
-            if (v !== undefined)
-                clean[k] = stripUndefined(v);
-        }
-        return clean;
-    }
-    return obj;
-}
-// ---- Helpers ----
-function serializeNodeId(id) {
-    return { uuid: id.uuid, event: id.event.toString() };
-}
-function deserializeNodeId(raw, parseEvent) {
-    return { uuid: raw.uuid, event: parseEvent(raw.event) };
-}
+import { stripUndefined, serializeNodeId, deserializeNodeId, serializeRGA, deserializeRGA, } from './crdt/codec.js';
+// Re-export plain RGA codec
+export { encodeRGA, decodeRGA } from './crdt/codec.js';
+// ---- Tree-specific helpers ----
 function isRGAParentSerialized(node) {
     return (node != null &&
         typeof node === 'object' &&
@@ -43,59 +24,38 @@ function isRGAParentNode(node) {
     return 'children' in node && node.children instanceof RGA;
 }
 // ---- RGATree serialization ----
-function serializeRGA(rga) {
-    const nodes = [];
-    for (const node of rga.nodes.values()) {
-        nodes.push({
-            id: serializeNodeId(node.id),
-            value: serializeTreeNodeValue(node.value),
-            afterId: node.afterId ? serializeNodeId(node.afterId) : null,
-            tombstone: node.tombstone,
-        });
-    }
-    return { nodes };
-}
 function serializeTreeNodeValue(node) {
     if (isRGAParentNode(node)) {
         const { children, ...rest } = node;
-        return { ...rest, children: serializeRGA(children) };
+        return { ...rest, children: serializeRGA(children, (n) => serializeTreeNodeValue(n)) };
     }
     return node;
 }
 function serializeTree(root) {
     return {
         type: 'root',
-        children: serializeRGA(root.children),
+        children: serializeRGA(root.children, (n) => serializeTreeNodeValue(n)),
     };
 }
-function deserializeRGA(raw, parseEvent, fingerprintFn, compareEvents) {
-    const rga = new RGA(fingerprintFn, compareEvents);
-    for (const rawNode of raw.nodes) {
-        const id = deserializeNodeId(rawNode.id, parseEvent);
-        const afterId = rawNode.afterId ? deserializeNodeId(rawNode.afterId, parseEvent) : undefined;
-        const value = deserializeTreeNodeValue(rawNode.value, parseEvent, fingerprintFn, compareEvents);
-        const key = `${id.uuid}:${id.event.toString()}`;
-        rga.nodes.set(key, { id, value, afterId, tombstone: rawNode.tombstone });
-    }
-    return rga;
-}
 function deserializeTreeNodeValue(raw, parseEvent, fingerprintFn, compareEvents) {
     if (isRGAParentSerialized(raw)) {
         const { children, ...rest } = raw;
         return {
             ...rest,
-            children: deserializeRGA(children, parseEvent, fingerprintFn, compareEvents),
+            children: deserializeTreeRGA(children, parseEvent, fingerprintFn, compareEvents),
         };
     }
     return raw;
 }
+function deserializeTreeRGA(raw, parseEvent, fingerprintFn, compareEvents) {
+    return deserializeRGA(raw, parseEvent, (v) => deserializeTreeNodeValue(v, parseEvent, fingerprintFn, compareEvents), fingerprintFn, compareEvents);
+}
 function deserializeTree(raw, parseEvent, fingerprintFn, compareEvents) {
     return {
         type: 'root',
-        children: deserializeRGA(raw.children, parseEvent, fingerprintFn, compareEvents),
+        children: deserializeTreeRGA(raw.children, parseEvent, fingerprintFn, compareEvents),
     };
 }
-// ---- RGAChangeSet serialization ----
 function serializeChangeSet(cs) {
     return {
         event: cs.event.toString(),
@@ -130,30 +90,18 @@ function deserializeChangeSet(raw, parseEvent) {
     };
 }
 // ---- Public API: encode/decode to DAG-CBOR blocks ----
-/**
- * Encode an RGATree as a DAG-CBOR block.
- */
 export async function encodeTree(root) {
     const value = stripUndefined(serializeTree(root));
     return encode({ value, codec: cbor, hasher: sha256 });
 }
-/**
- * Decode an RGATree from a DAG-CBOR block.
- */
 export async function decodeTree(block, parseEvent, fingerprintFn, compareEvents) {
     const decoded = await decode({ bytes: block.bytes, codec: cbor, hasher: sha256 });
     return deserializeTree(decoded.value, parseEvent, fingerprintFn, compareEvents);
 }
-/**
- * Encode an RGAChangeSet as a DAG-CBOR block.
- */
 export async function encodeChangeSet(cs) {
     const value = stripUndefined(serializeChangeSet(cs));
     return encode({ value, codec: cbor, hasher: sha256 });
 }
-/**
- * Decode an RGAChangeSet from a DAG-CBOR block.
- */
 export async function decodeChangeSet(block, parseEvent) {
     const decoded = await decode({ bytes: block.bytes, codec: cbor, hasher: sha256 });
     return deserializeChangeSet(decoded.value, parseEvent);

package/dist/crdt/codec.d.ts

@@ -0,0 +1,33 @@
+/**
+ * DAG-CBOR serialization for plain RGA instances.
+ */
+import { RGA, type RGANodeId, type RGAEvent, type EventComparator } from './rga.js';
+/** Recursively strip `undefined` values (not IPLD-compatible). */
+export declare function stripUndefined(obj: unknown): unknown;
+export interface SerializedNodeId {
+    uuid: string;
+    event: string;
+}
+export interface SerializedRGANode<V = unknown> {
+    id: SerializedNodeId;
+    value: V;
+    afterId: SerializedNodeId | null;
+    tombstone: boolean;
+}
+export interface SerializedRGA<V = unknown> {
+    nodes: SerializedRGANode<V>[];
+}
+export declare function serializeNodeId<E extends RGAEvent>(id: RGANodeId<E>): SerializedNodeId;
+export declare function deserializeNodeId<E extends RGAEvent>(raw: SerializedNodeId, parseEvent: (s: string) => E): RGANodeId<E>;
+export declare function serializeRGA<T, E extends RGAEvent>(rga: RGA<T, E>, serializeValue?: (v: T) => unknown): SerializedRGA;
+export declare function deserializeRGA<T, E extends RGAEvent>(raw: SerializedRGA, parseEvent: (s: string) => E, deserializeValue: (v: unknown) => T, fingerprintFn: (value: T) => string, compareEvents: EventComparator<E>): RGA<T, E>;
+/**
+ * Encode a plain RGA as a DAG-CBOR block.
+ */
+export declare function encodeRGA<T, E extends RGAEvent>(rga: RGA<T, E>, serializeValue?: (v: T) => unknown): Promise<import("multiformats").BlockView<unknown, 113, 18, 1>>;
+/**
+ * Decode a plain RGA from a DAG-CBOR block.
+ */
+export declare function decodeRGA<T, E extends RGAEvent>(block: {
+    bytes: Uint8Array;
+}, parseEvent: (s: string) => E, deserializeValue: (v: unknown) => T, fingerprintFn: (value: T) => string, compareEvents: EventComparator<E>): Promise<RGA<T, E>>;

package/dist/crdt/codec.js

@@ -0,0 +1,69 @@
+/**
+ * DAG-CBOR serialization for plain RGA instances.
+ */
+import { encode, decode } from 'multiformats/block';
+import { sha256 } from 'multiformats/hashes/sha2';
+import * as cbor from '@ipld/dag-cbor';
+import { RGA } from './rga.js';
+/** Recursively strip `undefined` values (not IPLD-compatible). */
+export function stripUndefined(obj) {
+    if (obj === null || obj === undefined)
+        return null;
+    if (Array.isArray(obj))
+        return obj.map(stripUndefined);
+    if (typeof obj === 'object') {
+        const clean = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (v !== undefined)
+                clean[k] = stripUndefined(v);
+        }
+        return clean;
+    }
+    return obj;
+}
+// ---- Helpers ----
+export function serializeNodeId(id) {
+    return { uuid: id.uuid, event: id.event.toString() };
+}
+export function deserializeNodeId(raw, parseEvent) {
+    return { uuid: raw.uuid, event: parseEvent(raw.event) };
+}
+// ---- Serialize / Deserialize ----
+export function serializeRGA(rga, serializeValue = (v) => v) {
+    const nodes = [];
+    for (const node of rga.nodes.values()) {
+        nodes.push({
+            id: serializeNodeId(node.id),
+            value: serializeValue(node.value),
+            afterId: node.afterId ? serializeNodeId(node.afterId) : null,
+            tombstone: node.tombstone,
+        });
+    }
+    return { nodes };
+}
+export function deserializeRGA(raw, parseEvent, deserializeValue, fingerprintFn, compareEvents) {
+    const rga = new RGA(fingerprintFn, compareEvents);
+    for (const rawNode of raw.nodes) {
+        const id = deserializeNodeId(rawNode.id, parseEvent);
+        const afterId = rawNode.afterId ? deserializeNodeId(rawNode.afterId, parseEvent) : undefined;
+        const value = deserializeValue(rawNode.value);
+        const key = `${id.uuid}:${id.event.toString()}`;
+        rga.nodes.set(key, { id, value, afterId, tombstone: rawNode.tombstone });
+    }
+    return rga;
+}
+// ---- Public API: encode/decode to DAG-CBOR blocks ----
+/**
+ * Encode a plain RGA as a DAG-CBOR block.
+ */
+export async function encodeRGA(rga, serializeValue = (v) => v) {
+    const value = stripUndefined(serializeRGA(rga, serializeValue));
+    return encode({ value, codec: cbor, hasher: sha256 });
+}
+/**
+ * Decode a plain RGA from a DAG-CBOR block.
+ */
+export async function decodeRGA(block, parseEvent, deserializeValue, fingerprintFn, compareEvents) {
+    const decoded = await decode({ bytes: block.bytes, codec: cbor, hasher: sha256 });
+    return deserializeRGA(decoded.value, parseEvent, deserializeValue, fingerprintFn, compareEvents);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storacha/md-merge",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/codec.ts

@@ -1,76 +1,30 @@
 /**
  * DAG-CBOR serialization for RGATree and RGAChangeSet.
  *
- * Converts RGA class instances (with Maps, nested RGAs) to plain
- * CBOR-friendly objects and back.
+ * Tree-specific serialization wraps the generic RGA codec from crdt/codec.ts,
+ * adding recursive handling of nested RGA children in tree nodes.
  */
 
 import { encode, decode } from 'multiformats/block'
 import { sha256 } from 'multiformats/hashes/sha2'
 import * as cbor from '@ipld/dag-cbor'
-import { RGA, type RGANodeId, type RGANode, type RGAEvent, type EventComparator } from './crdt/rga.js'
+import { RGA, type RGAEvent, type EventComparator } from './crdt/rga.js'
+import {
+  stripUndefined,
+  serializeNodeId,
+  deserializeNodeId,
+  serializeRGA,
+  deserializeRGA,
+  type SerializedRGA,
+  type SerializedNodeId,
+} from './crdt/codec.js'
 import type { RGATreeRoot, RGATreeNode, RGAParentNode } from './types.js'
 import type { RGAChangeSet, RGAChange } from './types.js'
 
+// Re-export plain RGA codec
+export { encodeRGA, decodeRGA } from './crdt/codec.js'
 
-/** Recursively strip `undefined` values (not IPLD-compatible). */
-function stripUndefined(obj: unknown): unknown {
-  if (obj === null || obj === undefined) return null
-  if (Array.isArray(obj)) return obj.map(stripUndefined)
-  if (typeof obj === 'object') {
-    const clean: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
-      if (v !== undefined) clean[k] = stripUndefined(v)
-    }
-    return clean
-  }
-  return obj
-}
-
-// ---- Serializable shapes (plain objects, no class instances) ----
-
-interface SerializedRGANode {
-  id: { uuid: string; event: string }
-  value: unknown
-  afterId: { uuid: string; event: string } | null
-  tombstone: boolean
-}
-
-interface SerializedRGA {
-  nodes: SerializedRGANode[]
-}
-
-interface SerializedRGATreeRoot {
-  type: 'root'
-  children: SerializedRGA
-}
-
-interface SerializedRGAChangeSet {
-  event: string
-  changes: SerializedRGAChange[]
-}
-
-interface SerializedRGAChange {
-  type: 'insert' | 'delete' | 'modify'
-  parentPath: Array<{ uuid: string; event: string }>
-  targetId?: { uuid: string; event: string } | null
-  afterId?: { uuid: string; event: string } | null
-  nodes?: unknown[]
-  before?: unknown[]
-}
-
-// ---- Helpers ----
-
-function serializeNodeId<E extends RGAEvent>(id: RGANodeId<E>): { uuid: string; event: string } {
-  return { uuid: id.uuid, event: id.event.toString() }
-}
-
-function deserializeNodeId<E extends RGAEvent>(
-  raw: { uuid: string; event: string },
-  parseEvent: (s: string) => E,
-): RGANodeId<E> {
-  return { uuid: raw.uuid, event: parseEvent(raw.event) }
-}
+// ---- Tree-specific helpers ----
 
 function isRGAParentSerialized(node: unknown): node is { type: string; children: SerializedRGA } {
   return (
@@ -89,49 +43,19 @@ function isRGAParentNode<E extends RGAEvent>(node: RGATreeNode<E>): node is RGAP
 
 // ---- RGATree serialization ----
 
-function serializeRGA<E extends RGAEvent>(rga: RGA<RGATreeNode<E>, E>): SerializedRGA {
-  const nodes: SerializedRGANode[] = []
-  for (const node of rga.nodes.values()) {
-    nodes.push({
-      id: serializeNodeId(node.id),
-      value: serializeTreeNodeValue(node.value),
-      afterId: node.afterId ? serializeNodeId(node.afterId) : null,
-      tombstone: node.tombstone,
-    })
-  }
-  return { nodes }
-}
-
 function serializeTreeNodeValue<E extends RGAEvent>(node: RGATreeNode<E>): unknown {
   if (isRGAParentNode(node)) {
     const { children, ...rest } = node
-    return { ...rest, children: serializeRGA(children) }
+    return { ...rest, children: serializeRGA(children, (n: RGATreeNode<E>) => serializeTreeNodeValue(n)) }
   }
   return node
 }
 
-function serializeTree<E extends RGAEvent>(root: RGATreeRoot<E>): SerializedRGATreeRoot {
+function serializeTree<E extends RGAEvent>(root: RGATreeRoot<E>): unknown {
   return {
     type: 'root',
-    children: serializeRGA(root.children),
-  }
-}
-
-function deserializeRGA<E extends RGAEvent>(
-  raw: SerializedRGA,
-  parseEvent: (s: string) => E,
-  fingerprintFn: (value: RGATreeNode<E>) => string,
-  compareEvents: EventComparator<E>,
-): RGA<RGATreeNode<E>, E> {
-  const rga = new RGA<RGATreeNode<E>, E>(fingerprintFn, compareEvents)
-  for (const rawNode of raw.nodes) {
-    const id = deserializeNodeId(rawNode.id, parseEvent)
-    const afterId = rawNode.afterId ? deserializeNodeId(rawNode.afterId, parseEvent) : undefined
-    const value = deserializeTreeNodeValue(rawNode.value, parseEvent, fingerprintFn, compareEvents)
-    const key = `${id.uuid}:${id.event.toString()}`
-    rga.nodes.set(key, { id, value, afterId, tombstone: rawNode.tombstone })
+    children: serializeRGA(root.children, (n: RGATreeNode<E>) => serializeTreeNodeValue(n)),
   }
-  return rga
 }
 
 function deserializeTreeNodeValue<E extends RGAEvent>(
@@ -144,26 +68,55 @@ function deserializeTreeNodeValue<E extends RGAEvent>(
     const { children, ...rest } = raw
     return {
       ...rest,
-      children: deserializeRGA(children, parseEvent, fingerprintFn, compareEvents),
+      children: deserializeTreeRGA(children, parseEvent, fingerprintFn, compareEvents),
     } as RGAParentNode<E>
   }
   return raw as RGATreeNode<E>
 }
 
+function deserializeTreeRGA<E extends RGAEvent>(
+  raw: SerializedRGA,
+  parseEvent: (s: string) => E,
+  fingerprintFn: (value: RGATreeNode<E>) => string,
+  compareEvents: EventComparator<E>,
+): RGA<RGATreeNode<E>, E> {
+  return deserializeRGA<RGATreeNode<E>, E>(
+    raw,
+    parseEvent,
+    (v) => deserializeTreeNodeValue(v, parseEvent, fingerprintFn, compareEvents),
+    fingerprintFn,
+    compareEvents,
+  )
+}
+
 function deserializeTree<E extends RGAEvent>(
-  raw: SerializedRGATreeRoot,
+  raw: { type: string; children: SerializedRGA },
   parseEvent: (s: string) => E,
   fingerprintFn: (value: RGATreeNode<E>) => string,
   compareEvents: EventComparator<E>,
 ): RGATreeRoot<E> {
   return {
     type: 'root',
-    children: deserializeRGA(raw.children, parseEvent, fingerprintFn, compareEvents),
+    children: deserializeTreeRGA(raw.children, parseEvent, fingerprintFn, compareEvents),
   }
 }
 
 // ---- RGAChangeSet serialization ----
 
+interface SerializedRGAChangeSet {
+  event: string
+  changes: SerializedRGAChange[]
+}
+
+interface SerializedRGAChange {
+  type: 'insert' | 'delete' | 'modify'
+  parentPath: SerializedNodeId[]
+  targetId?: SerializedNodeId | null
+  afterId?: SerializedNodeId | null
+  nodes?: unknown[]
+  before?: unknown[]
+}
+
 function serializeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): SerializedRGAChangeSet {
   return {
     event: cs.event.toString(),
@@ -200,19 +153,11 @@ function deserializeChangeSet<E extends RGAEvent>(
 
 // ---- Public API: encode/decode to DAG-CBOR blocks ----
 
-/**
- * Encode an RGATree as a DAG-CBOR block.
- */
-export async function encodeTree<E extends RGAEvent>(
-  root: RGATreeRoot<E>,
-) {
-  const value = stripUndefined(serializeTree(root)) as SerializedRGATreeRoot
+export async function encodeTree<E extends RGAEvent>(root: RGATreeRoot<E>) {
+  const value = stripUndefined(serializeTree(root))
   return encode({ value, codec: cbor, hasher: sha256 })
 }
 
-/**
- * Decode an RGATree from a DAG-CBOR block.
- */
 export async function decodeTree<E extends RGAEvent>(
   block: { bytes: Uint8Array },
   parseEvent: (s: string) => E,
@@ -220,22 +165,14 @@ export async function decodeTree<E extends RGAEvent>(
   compareEvents: EventComparator<E>,
 ): Promise<RGATreeRoot<E>> {
   const decoded = await decode({ bytes: block.bytes, codec: cbor, hasher: sha256 })
-  return deserializeTree(decoded.value as SerializedRGATreeRoot, parseEvent, fingerprintFn, compareEvents)
+  return deserializeTree(decoded.value as { type: string; children: SerializedRGA }, parseEvent, fingerprintFn, compareEvents)
 }
 
-/**
- * Encode an RGAChangeSet as a DAG-CBOR block.
- */
-export async function encodeChangeSet<E extends RGAEvent>(
-  cs: RGAChangeSet<E>,
-) {
-  const value = stripUndefined(serializeChangeSet(cs)) as SerializedRGAChangeSet
+export async function encodeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>) {
+  const value = stripUndefined(serializeChangeSet(cs))
   return encode({ value, codec: cbor, hasher: sha256 })
 }
 
-/**
- * Decode an RGAChangeSet from a DAG-CBOR block.
- */
 export async function decodeChangeSet<E extends RGAEvent>(
   block: { bytes: Uint8Array },
   parseEvent: (s: string) => E,

package/src/crdt/codec.ts

@@ -0,0 +1,116 @@
+/**
+ * DAG-CBOR serialization for plain RGA instances.
+ */
+
+import { encode, decode } from 'multiformats/block'
+import { sha256 } from 'multiformats/hashes/sha2'
+import * as cbor from '@ipld/dag-cbor'
+import { RGA, type RGANodeId, type RGAEvent, type EventComparator } from './rga.js'
+
+/** Recursively strip `undefined` values (not IPLD-compatible). */
+export function stripUndefined(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return null
+  if (Array.isArray(obj)) return obj.map(stripUndefined)
+  if (typeof obj === 'object') {
+    const clean: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+      if (v !== undefined) clean[k] = stripUndefined(v)
+    }
+    return clean
+  }
+  return obj
+}
+
+// ---- Serializable shapes ----
+
+export interface SerializedNodeId {
+  uuid: string
+  event: string
+}
+
+export interface SerializedRGANode<V = unknown> {
+  id: SerializedNodeId
+  value: V
+  afterId: SerializedNodeId | null
+  tombstone: boolean
+}
+
+export interface SerializedRGA<V = unknown> {
+  nodes: SerializedRGANode<V>[]
+}
+
+// ---- Helpers ----
+
+export function serializeNodeId<E extends RGAEvent>(id: RGANodeId<E>): SerializedNodeId {
+  return { uuid: id.uuid, event: id.event.toString() }
+}
+
+export function deserializeNodeId<E extends RGAEvent>(
+  raw: SerializedNodeId,
+  parseEvent: (s: string) => E,
+): RGANodeId<E> {
+  return { uuid: raw.uuid, event: parseEvent(raw.event) }
+}
+
+// ---- Serialize / Deserialize ----
+
+export function serializeRGA<T, E extends RGAEvent>(
+  rga: RGA<T, E>,
+  serializeValue: (v: T) => unknown = (v) => v,
+): SerializedRGA {
+  const nodes: SerializedRGANode[] = []
+  for (const node of rga.nodes.values()) {
+    nodes.push({
+      id: serializeNodeId(node.id),
+      value: serializeValue(node.value),
+      afterId: node.afterId ? serializeNodeId(node.afterId) : null,
+      tombstone: node.tombstone,
+    })
+  }
+  return { nodes }
+}
+
+export function deserializeRGA<T, E extends RGAEvent>(
+  raw: SerializedRGA,
+  parseEvent: (s: string) => E,
+  deserializeValue: (v: unknown) => T,
+  fingerprintFn: (value: T) => string,
+  compareEvents: EventComparator<E>,
+): RGA<T, E> {
+  const rga = new RGA<T, E>(fingerprintFn, compareEvents)
+  for (const rawNode of raw.nodes) {
+    const id = deserializeNodeId(rawNode.id, parseEvent)
+    const afterId = rawNode.afterId ? deserializeNodeId(rawNode.afterId, parseEvent) : undefined
+    const value = deserializeValue(rawNode.value)
+    const key = `${id.uuid}:${id.event.toString()}`
+    rga.nodes.set(key, { id, value, afterId, tombstone: rawNode.tombstone })
+  }
+  return rga
+}
+
+// ---- Public API: encode/decode to DAG-CBOR blocks ----
+
+/**
+ * Encode a plain RGA as a DAG-CBOR block.
+ */
+export async function encodeRGA<T, E extends RGAEvent>(
+  rga: RGA<T, E>,
+  serializeValue: (v: T) => unknown = (v) => v,
+) {
+  const value = stripUndefined(serializeRGA(rga, serializeValue))
+  return encode({ value, codec: cbor, hasher: sha256 })
+}
+
+/**
+ * Decode a plain RGA from a DAG-CBOR block.
+ */
+export async function decodeRGA<T, E extends RGAEvent>(
+  block: { bytes: Uint8Array },
+  parseEvent: (s: string) => E,
+  deserializeValue: (v: unknown) => T,
+  fingerprintFn: (value: T) => string,
+  compareEvents: EventComparator<E>,
+): Promise<RGA<T, E>> {
+  const decoded = await decode({ bytes: block.bytes, codec: cbor, hasher: sha256 })
+  return deserializeRGA(decoded.value as SerializedRGA, parseEvent, deserializeValue, fingerprintFn, compareEvents)
+}