@storacha/md-merge 0.7.0 → 0.9.0

package/dist/codec.d.ts

@@ -5,9 +5,29 @@
  * adding recursive handling of nested RGA children in tree nodes.
  */
 import { type RGAEvent, type EventComparator } from './crdt/rga.js';
+import { type SerializedRGA, type SerializedNodeId } from './crdt/codec.js';
 import type { RGATreeRoot } from './types.js';
 import type { RGAChangeSet } from './types.js';
 export { encodeRGA, decodeRGA } from './crdt/codec.js';
+export declare function serializeTree<E extends RGAEvent>(root: RGATreeRoot<E>): unknown;
+export declare function deserializeTree<E extends RGAEvent>(raw: {
+    type: string;
+    children: SerializedRGA;
+}, parseEvent: (s: string) => E, compareEvents: EventComparator<E>): RGATreeRoot<E>;
+export interface SerializedRGAChangeSet {
+    event: string;
+    changes: SerializedRGAChange[];
+}
+export interface SerializedRGAChange {
+    type: 'insert' | 'delete' | 'modify';
+    parentPath: SerializedNodeId[];
+    targetId?: SerializedNodeId | null;
+    afterId?: SerializedNodeId | null;
+    nodes?: unknown[];
+    before?: unknown[];
+}
+export declare function serializeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): SerializedRGAChangeSet;
+export declare function deserializeChangeSet<E extends RGAEvent>(raw: SerializedRGAChangeSet, parseEvent: (s: string) => E): RGAChangeSet<E>;
 export declare function encodeTree<E extends RGAEvent>(root: RGATreeRoot<E>): Promise<import("multiformats").BlockView<unknown, 113, 18, 1>>;
 export declare function decodeTree<E extends RGAEvent>(block: {
     bytes: Uint8Array;

package/dist/codec.js

@@ -31,7 +31,7 @@ function serializeTreeNodeValue(node) {
     }
     return node;
 }
-function serializeTree(root) {
+export function serializeTree(root) {
     return {
         type: 'root',
         children: serializeRGA(root.children, (n) => serializeTreeNodeValue(n)),
@@ -50,13 +50,13 @@ function deserializeTreeNodeValue(raw, parseEvent, compareEvents) {
 function deserializeTreeRGA(raw, parseEvent, compareEvents) {
     return deserializeRGA(raw, parseEvent, (v) => deserializeTreeNodeValue(v, parseEvent, compareEvents), compareEvents);
 }
-function deserializeTree(raw, parseEvent, compareEvents) {
+export function deserializeTree(raw, parseEvent, compareEvents) {
     return {
         type: 'root',
         children: deserializeTreeRGA(raw.children, parseEvent, compareEvents),
     };
 }
-function serializeChangeSet(cs) {
+export function serializeChangeSet(cs) {
     return {
         event: cs.event.toString(),
         changes: cs.changes.map(c => ({
@@ -69,7 +69,7 @@ function serializeChangeSet(cs) {
         })),
     };
 }
-function deserializeChangeSet(raw, parseEvent) {
+export function deserializeChangeSet(raw, parseEvent) {
     return {
         event: parseEvent(raw.event),
         changes: raw.changes.map(c => {

package/dist/diff.js

@@ -109,14 +109,19 @@ function diffGap(oldNodes, newNodes, oldStartIdx, newStartIdx, pathPrefix) {
         });
         oi++;
     }
-    // Remaining new = inserts
-    while (ni < newNodes.length) {
+    // Remaining new = inserts (batched into a single change)
+    if (ni < newNodes.length) {
+        const insertNodes = [];
+        const insertIdx = newStartIdx + ni;
+        while (ni < newNodes.length) {
+            insertNodes.push(newNodes[ni]);
+            ni++;
+        }
         changes.push({
             type: "insert",
-            path: [...pathPrefix, newStartIdx + ni],
-            nodes: [newNodes[ni]],
+            path: [...pathPrefix, insertIdx],
+            nodes: insertNodes,
         });
-        ni++;
     }
     return changes;
 }

package/dist/index.d.ts

@@ -9,7 +9,8 @@ import type { RGAEvent, EventComparator } from "./crdt/rga.js";
 export { parse, stringify, stringifyNode, fingerprint } from "./parse.js";
 export { diff, applyChangeSet } from "./diff.js";
 export { toRGATree, toMdast, applyMdastToRGATree, generateRGAChangeSet, applyRGAChangeSet, mergeRGATrees, } from "./rga-tree.js";
-export { encodeTree, decodeTree, encodeChangeSet, decodeChangeSet, encodeRGA, decodeRGA, } from "./codec.js";
+export { encodeTree, decodeTree, encodeChangeSet, decodeChangeSet, encodeRGA, decodeRGA, serializeTree, deserializeTree, serializeChangeSet, deserializeChangeSet, type SerializedRGAChangeSet, type SerializedRGAChange, } from "./codec.js";
+export { stripUndefined, serializeRGA, deserializeRGA, serializeNodeId, deserializeNodeId, type SerializedRGA, type SerializedNodeId, } from "./crdt/codec.js";
 export type { ChangeSet, Change, RGAChangeSet, RGAChange, RGATreeRoot, RGATreeNode, RGAParentNode, RGALeafNode, } from "./types.js";
 export { RGA, type RGAEvent, type RGANodeId, type EventComparator, } from "./types.js";
 /**

package/dist/index.js

@@ -10,7 +10,8 @@ import { toRGATree, toMdast, generateRGAChangeSet, applyRGAChangeSet, } from "./
 export { parse, stringify, stringifyNode, fingerprint } from "./parse.js";
 export { diff, applyChangeSet } from "./diff.js";
 export { toRGATree, toMdast, applyMdastToRGATree, generateRGAChangeSet, applyRGAChangeSet, mergeRGATrees, } from "./rga-tree.js";
-export { encodeTree, decodeTree, encodeChangeSet, decodeChangeSet, encodeRGA, decodeRGA, } from "./codec.js";
+export { encodeTree, decodeTree, encodeChangeSet, decodeChangeSet, encodeRGA, decodeRGA, serializeTree, deserializeTree, serializeChangeSet, deserializeChangeSet, } from "./codec.js";
+export { stripUndefined, serializeRGA, deserializeRGA, serializeNodeId, deserializeNodeId, } from "./crdt/codec.js";
 export { RGA, } from "./types.js";
 /**
  * Compute an RGA-addressed changeset between an existing RGA tree and new markdown.

package/dist/rga-tree.js

@@ -189,18 +189,20 @@ export function applyRGAChangeSet(root, changeset, compareEvents) {
                 break;
             }
             case "insert": {
+                let afterId = change.afterId;
                 for (const node of change.nodes ?? []) {
                     const rgaNode = convertNode(node, changeset.event, compareEvents);
-                    currentRGA.insert(change.afterId, rgaNode, changeset.event);
+                    afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
                 }
                 break;
             }
             case "modify": {
                 if (change.targetId)
                     currentRGA.delete(change.targetId);
+                let afterId = change.afterId;
                 for (const node of change.nodes ?? []) {
                     const rgaNode = convertNode(node, changeset.event, compareEvents);
-                    currentRGA.insert(change.afterId, rgaNode, changeset.event);
+                    afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
                 }
                 break;
             }

package/package.json

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

package/src/codec.ts

@@ -51,7 +51,7 @@ function serializeTreeNodeValue<E extends RGAEvent>(node: RGATreeNode<E>): unkno
   return node
 }
 
-function serializeTree<E extends RGAEvent>(root: RGATreeRoot<E>): unknown {
+export function serializeTree<E extends RGAEvent>(root: RGATreeRoot<E>): unknown {
   return {
     type: 'root',
     children: serializeRGA(root.children, (n: RGATreeNode<E>) => serializeTreeNodeValue(n)),
@@ -86,7 +86,7 @@ function deserializeTreeRGA<E extends RGAEvent>(
   )
 }
 
-function deserializeTree<E extends RGAEvent>(
+export function deserializeTree<E extends RGAEvent>(
   raw: { type: string; children: SerializedRGA },
   parseEvent: (s: string) => E,
   compareEvents: EventComparator<E>,
@@ -99,12 +99,12 @@ function deserializeTree<E extends RGAEvent>(
 
 // ---- RGAChangeSet serialization ----
 
-interface SerializedRGAChangeSet {
+export interface SerializedRGAChangeSet {
   event: string
   changes: SerializedRGAChange[]
 }
 
-interface SerializedRGAChange {
+export interface SerializedRGAChange {
   type: 'insert' | 'delete' | 'modify'
   parentPath: SerializedNodeId[]
   targetId?: SerializedNodeId | null
@@ -113,7 +113,7 @@ interface SerializedRGAChange {
   before?: unknown[]
 }
 
-function serializeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): SerializedRGAChangeSet {
+export function serializeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): SerializedRGAChangeSet {
   return {
     event: cs.event.toString(),
     changes: cs.changes.map(c => ({
@@ -127,7 +127,7 @@ function serializeChangeSet<E extends RGAEvent>(cs: RGAChangeSet<E>): Serialized
   }
 }
 
-function deserializeChangeSet<E extends RGAEvent>(
+export function deserializeChangeSet<E extends RGAEvent>(
   raw: SerializedRGAChangeSet,
   parseEvent: (s: string) => E,
 ): RGAChangeSet<E> {

package/src/diff.ts

@@ -131,14 +131,19 @@ function diffGap(
     });
     oi++;
   }
-  // Remaining new = inserts
-  while (ni < newNodes.length) {
+  // Remaining new = inserts (batched into a single change)
+  if (ni < newNodes.length) {
+    const insertNodes: RootContent[] = [];
+    const insertIdx = newStartIdx + ni;
+    while (ni < newNodes.length) {
+      insertNodes.push(newNodes[ni] as RootContent);
+      ni++;
+    }
     changes.push({
       type: "insert",
-      path: [...pathPrefix, newStartIdx + ni],
-      nodes: [newNodes[ni] as RootContent],
+      path: [...pathPrefix, insertIdx],
+      nodes: insertNodes,
     });
-    ni++;
   }
   return changes;
 }

package/src/index.ts

@@ -33,7 +33,22 @@ export {
   decodeChangeSet,
   encodeRGA,
   decodeRGA,
+  serializeTree,
+  deserializeTree,
+  serializeChangeSet,
+  deserializeChangeSet,
+  type SerializedRGAChangeSet,
+  type SerializedRGAChange,
 } from "./codec.js";
+export {
+  stripUndefined,
+  serializeRGA,
+  deserializeRGA,
+  serializeNodeId,
+  deserializeNodeId,
+  type SerializedRGA,
+  type SerializedNodeId,
+} from "./crdt/codec.js";
 export type {
   ChangeSet,
   Change,

package/src/rga-tree.ts

@@ -272,25 +272,27 @@ export function applyRGAChangeSet<E extends RGAEvent>(
         break;
       }
       case "insert": {
+        let afterId = change.afterId;
         for (const node of change.nodes ?? []) {
           const rgaNode = convertNode(
             node as Node,
             changeset.event,
             compareEvents,
           );
-          currentRGA.insert(change.afterId, rgaNode, changeset.event);
+          afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
         }
         break;
       }
       case "modify": {
         if (change.targetId) currentRGA.delete(change.targetId);
+        let afterId = change.afterId;
         for (const node of change.nodes ?? []) {
           const rgaNode = convertNode(
             node as Node,
             changeset.event,
             compareEvents,
           );
-          currentRGA.insert(change.afterId, rgaNode, changeset.event);
+          afterId = currentRGA.insert(afterId, rgaNode, changeset.event);
         }
         break;
       }

package/test/rga-tree.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { parse, stringify } from "../src/parse.js";
-import { toRGATree, toMdast, applyMdastToRGATree, mergeRGATrees } from "../src/rga-tree.js";
+import { toRGATree, toMdast, applyMdastToRGATree, mergeRGATrees, applyRGAChangeSet } from "../src/rga-tree.js";
 import {
   RGA,
   type RGAEvent,
@@ -321,3 +321,129 @@ describe("mergeRGATrees", () => {
     expect(tree2.children.nodes.size).toBe(origSize2);
   });
 });
+
+describe("multi-append", () => {
+  it("handles appending multiple nodes at once", () => {
+    const oldMd = "# Hello\n\nOriginal.\n";
+    const newMd = "# Hello\n\nOriginal.\n\nSecond.\n\nThird.\n";
+    const oldRoot = parse(oldMd);
+    const newRoot = parse(newMd);
+    const tree = toRGATree(oldRoot, r1, cmp);
+
+    const r2 = new TestEvent("r2");
+    const updated = applyMdastToRGATree(tree, newRoot, r2, cmp);
+    const result = stringify(toMdast(updated));
+
+    expect(result).toContain("Original.");
+    expect(result).toContain("Second.");
+    expect(result).toContain("Third.");
+    // Verify order is preserved
+    const origIdx = result.indexOf("Original.");
+    const secIdx = result.indexOf("Second.");
+    const thirdIdx = result.indexOf("Third.");
+    expect(origIdx).toBeLessThan(secIdx);
+    expect(secIdx).toBeLessThan(thirdIdx);
+  });
+
+  it("handles appending to an empty children array", () => {
+    const oldMd = "";
+    const newMd = "# Hello\n\nWorld.\n";
+    const oldRoot = parse(oldMd);
+    const newRoot = parse(newMd);
+    const tree = toRGATree(oldRoot, r1, cmp);
+
+    const r2 = new TestEvent("r2");
+    const updated = applyMdastToRGATree(tree, newRoot, r2, cmp);
+    const result = stringify(toMdast(updated));
+
+    expect(result).toContain("Hello");
+    expect(result).toContain("World.");
+  });
+});
+
+describe("applyRGAChangeSet multi-node", () => {
+  const r2 = new TestEvent("r2");
+
+  it("insert with multiple nodes preserves order", () => {
+    const tree = toRGATree(parse("# Hello\n"), r1, cmp);
+    const afterId = tree.children.toNodes()[0].id; // after the heading
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "insert" as const,
+        parentPath: [],
+        afterId,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "First" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Second" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Third" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    expect(md).toContain("First");
+    expect(md).toContain("Second");
+    expect(md).toContain("Third");
+    expect(md.indexOf("First")).toBeLessThan(md.indexOf("Second"));
+    expect(md.indexOf("Second")).toBeLessThan(md.indexOf("Third"));
+  });
+
+  it("modify with multiple replacement nodes preserves order", () => {
+    const tree = toRGATree(parse("# Hello\n\nOriginal.\n"), r1, cmp);
+    const nodes = tree.children.toNodes();
+    const targetId = nodes[1].id; // the paragraph
+    const afterId = nodes[0].id; // after the heading
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "modify" as const,
+        parentPath: [],
+        targetId,
+        afterId,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "Replacement A" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Replacement B" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    expect(md).not.toContain("Original.");
+    expect(md).toContain("Replacement A");
+    expect(md).toContain("Replacement B");
+    expect(md.indexOf("Replacement A")).toBeLessThan(md.indexOf("Replacement B"));
+  });
+
+  it("insert at start (no afterId) with multiple nodes preserves relative order", () => {
+    // Insert two nodes at root with no afterId. RGA ordering means they
+    // appear after existing r1 nodes (r2 > r1), but their relative order
+    // (A before B) is preserved via chained afterIds.
+    const tree = toRGATree(parse("# Existing\n"), r1, cmp);
+
+    const changeset = {
+      event: r2,
+      changes: [{
+        type: "insert" as const,
+        parentPath: [],
+        afterId: undefined,
+        nodes: [
+          { type: "paragraph", children: [{ type: "text", value: "Added A" }] },
+          { type: "paragraph", children: [{ type: "text", value: "Added B" }] },
+        ] as any,
+      }],
+    };
+
+    const result = applyRGAChangeSet(tree, changeset, cmp);
+    const md = stringify(toMdast(result));
+
+    // Relative order of the inserted nodes is preserved
+    expect(md.indexOf("Added A")).toBeLessThan(md.indexOf("Added B"));
+  });
+});