@automerge/automerge-repo 0.0.1

package/dist/DocHandle.js

@@ -0,0 +1,227 @@
+import * as A from "@automerge/automerge";
+import debug from "debug";
+import EventEmitter from "eventemitter3";
+import { assign, createMachine, interpret, } from "xstate";
+import { waitFor } from "xstate/lib/waitFor.js";
+import { headsAreSame } from "./helpers/headsAreSame.js";
+import { pause } from "./helpers/pause.js";
+import { withTimeout, TimeoutError } from "./helpers/withTimeout.js";
+/** DocHandle is a wrapper around a single Automerge document that lets us listen for changes. */
+export class DocHandle//
+ extends EventEmitter {
+    documentId;
+    #log;
+    #machine;
+    #timeoutDelay;
+    constructor(documentId, { isNew = false, timeoutDelay = 700000 } = {}) {
+        super();
+        this.documentId = documentId;
+        this.#timeoutDelay = timeoutDelay;
+        this.#log = debug(`automerge-repo:dochandle:${documentId.slice(0, 5)}`);
+        // initial doc
+        const doc = A.init({
+            patchCallback: (patches, { before, after }) => this.emit("patch", { handle: this, patches, before, after }),
+        });
+        /**
+         * Internally we use a state machine to orchestrate document loading and/or syncing, in order to
+         * avoid requesting data we already have, or surfacing intermediate values to the consumer.
+         *
+         *                      ┌─────────┐           ┌────────────┐
+         *  ┌───────┐  ┌──FIND──┤ loading ├─REQUEST──►│ requesting ├─UPDATE──┐
+         *  │ idle  ├──┤        └───┬─────┘           └────────────┘         │
+         *  └───────┘  │            │                                        └─►┌─────────┐
+         *             │            └───────LOAD───────────────────────────────►│  ready  │
+         *             └──CREATE───────────────────────────────────────────────►└─────────┘
+         */
+        this.#machine = interpret(createMachine({
+            predictableActionArguments: true,
+            id: "docHandle",
+            initial: IDLE,
+            context: { documentId, doc },
+            states: {
+                idle: {
+                    on: {
+                        // If we're creating a new document, we don't need to load anything
+                        CREATE: { target: READY },
+                        // If we're accessing an existing document, we need to request it from storage
+                        // and/or the network
+                        FIND: { target: LOADING },
+                        DELETE: { actions: "onDelete", target: DELETED },
+                    },
+                },
+                loading: {
+                    on: {
+                        // LOAD is called by the Repo if the document is found in storage
+                        LOAD: { actions: "onLoad", target: READY },
+                        // REQUEST is called by the Repo if the document is not found in storage
+                        REQUEST: { target: REQUESTING },
+                        DELETE: { actions: "onDelete", target: DELETED },
+                    },
+                },
+                requesting: {
+                    on: {
+                        // UPDATE is called by the Repo when we receive changes from the network
+                        UPDATE: { actions: "onUpdate" },
+                        // REQUEST_COMPLETE is called from `onUpdate` when the doc has been fully loaded from the network
+                        REQUEST_COMPLETE: { target: READY },
+                        DELETE: { actions: "onDelete", target: DELETED },
+                    },
+                },
+                ready: {
+                    on: {
+                        // UPDATE is called by the Repo when we receive changes from the network
+                        UPDATE: { actions: "onUpdate", target: READY },
+                        DELETE: { actions: "onDelete", target: DELETED },
+                    },
+                },
+                error: {},
+                deleted: {},
+            },
+        }, {
+            actions: {
+                /** Apply the binary changes from storage and put the updated doc on context */
+                onLoad: assign((context, { payload }) => {
+                    const { binary } = payload;
+                    const { doc } = context;
+                    const newDoc = A.loadIncremental(doc, binary);
+                    return { doc: newDoc };
+                }),
+                /** Put the updated doc on context; if it's different, emit a `change` event */
+                onUpdate: assign((context, { payload }) => {
+                    const { doc: oldDoc } = context;
+                    const { callback } = payload;
+                    const newDoc = callback(oldDoc);
+                    const docChanged = !headsAreSame(newDoc, oldDoc);
+                    if (docChanged) {
+                        this.emit("change", { handle: this, doc: newDoc });
+                        if (!this.isReady()) {
+                            this.#machine.send(REQUEST_COMPLETE);
+                        }
+                    }
+                    return { doc: newDoc };
+                }),
+                onDelete: assign(() => {
+                    this.emit("delete", { handle: this });
+                    return { doc: undefined };
+                }),
+            },
+        }))
+            .onTransition(({ value: state }, { type: event }) => this.#log(`${event} → ${state}`, this.#doc))
+            .start();
+        this.#machine.send(isNew ? CREATE : FIND);
+    }
+    get doc() {
+        if (!this.isReady()) {
+            throw new Error(`DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`);
+        }
+        return this.#doc;
+    }
+    // PRIVATE
+    /** Returns the current document */
+    get #doc() {
+        return this.#machine?.getSnapshot().context.doc;
+    }
+    /** Returns the docHandle's state (READY, etc.) */
+    get #state() {
+        return this.#machine?.getSnapshot().value;
+    }
+    /** Returns a promise that resolves when the docHandle is in one of the given states */
+    #statePromise(awaitStates) {
+        if (!Array.isArray(awaitStates))
+            awaitStates = [awaitStates];
+        return Promise.any(awaitStates.map(state => waitFor(this.#machine, s => s.matches(state))));
+    }
+    // PUBLIC
+    isReady = () => this.#state === READY;
+    isReadyOrRequesting = () => this.#state === READY || this.#state === REQUESTING;
+    isDeleted = () => this.#state === DELETED;
+    /**
+     * Returns the current document, waiting for the handle to be ready if necessary.
+     */
+    async value(awaitStates = [READY]) {
+        await pause(); // yield one tick because reasons
+        try {
+            // wait for the document to enter one of the desired states
+            await withTimeout(this.#statePromise(awaitStates), this.#timeoutDelay);
+        }
+        catch (error) {
+            if (error instanceof TimeoutError)
+                throw new Error(`DocHandle: timed out loading ${this.documentId}`);
+            else
+                throw error;
+        }
+        // Return the document
+        return this.#doc;
+    }
+    async loadAttemptedValue() {
+        return this.value([READY, REQUESTING]);
+    }
+    /** `load` is called by the repo when the document is found in storage */
+    load(binary) {
+        if (binary.length) {
+            this.#machine.send(LOAD, { payload: { binary } });
+        }
+    }
+    /** `update` is called by the repo when we receive changes from the network */
+    update(callback) {
+        this.#machine.send(UPDATE, { payload: { callback } });
+    }
+    /** `change` is called by the repo when the document is changed locally  */
+    change(callback, options = {}) {
+        if (!this.isReady()) {
+            throw new Error(`DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`);
+        }
+        this.#machine.send(UPDATE, {
+            payload: {
+                callback: (doc) => {
+                    return A.change(doc, options, callback);
+                },
+            },
+        });
+    }
+    changeAt(heads, callback, options = {}) {
+        if (!this.isReady()) {
+            throw new Error(`DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`);
+        }
+        this.#machine.send(UPDATE, {
+            payload: {
+                callback: (doc) => {
+                    return A.changeAt(doc, heads, options, callback);
+                },
+            },
+        });
+    }
+    /** `request` is called by the repo when the document is not found in storage */
+    request() {
+        if (this.#state === LOADING)
+            this.#machine.send(REQUEST);
+    }
+    /** `delete` is called by the repo when the document is deleted */
+    delete() {
+        this.#machine.send(DELETE);
+    }
+}
+// STATE MACHINE TYPES
+// state
+export const HandleState = {
+    IDLE: "idle",
+    LOADING: "loading",
+    REQUESTING: "requesting",
+    READY: "ready",
+    ERROR: "error",
+    DELETED: "deleted",
+};
+// events
+export const Event = {
+    CREATE: "CREATE",
+    LOAD: "LOAD",
+    FIND: "FIND",
+    REQUEST: "REQUEST",
+    REQUEST_COMPLETE: "REQUEST_COMPLETE",
+    UPDATE: "UPDATE",
+    TIMEOUT: "TIMEOUT",
+    DELETE: "DELETE",
+};
+// CONSTANTS
+const { IDLE, LOADING, REQUESTING, READY, ERROR, DELETED } = HandleState;
+const { CREATE, LOAD, FIND, REQUEST, UPDATE, TIMEOUT, DELETE, REQUEST_COMPLETE, } = Event;

package/dist/EphemeralData.d.ts

@@ -0,0 +1,27 @@
+import EventEmitter from "eventemitter3";
+import { ChannelId, PeerId } from "./index.js";
+import { MessagePayload } from "./network/NetworkAdapter.js";
+/**
+ * EphemeralData provides a mechanism to broadcast short-lived data — cursor positions, presence,
+ * heartbeats, etc. — that is useful in the moment but not worth persisting.
+ */
+export declare class EphemeralData extends EventEmitter<EphemeralDataMessageEvents> {
+    /** Broadcast an ephemeral message */
+    broadcast(channelId: ChannelId, message: unknown): void;
+    /** Receive an ephemeral message */
+    receive(senderId: PeerId, grossChannelId: ChannelId, message: Uint8Array): void;
+}
+export interface EphemeralDataPayload {
+    channelId: ChannelId;
+    peerId: PeerId;
+    data: {
+        peerId: PeerId;
+        channelId: ChannelId;
+        data: unknown;
+    };
+}
+export type EphemeralDataMessageEvents = {
+    message: (event: MessagePayload) => void;
+    data: (event: EphemeralDataPayload) => void;
+};
+//# sourceMappingURL=EphemeralData.d.ts.map

package/dist/EphemeralData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EphemeralData.d.ts","sourceRoot":"","sources":["../src/EphemeralData.ts"],"names":[],"mappings":"AACA,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAE5D;;;GAGG;AACH,qBAAa,aAAc,SAAQ,YAAY,CAAC,0BAA0B,CAAC;IACzE,qCAAqC;IACrC,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO;IAWhD,mCAAmC;IACnC,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU;CASzE;AAID,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,SAAS,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAA;CAC9D;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,OAAO,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;IACxC,IAAI,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAA;CAC5C,CAAA"}

package/dist/EphemeralData.js

@@ -0,0 +1,28 @@
+import { decode, encode } from "cbor-x";
+import EventEmitter from "eventemitter3";
+/**
+ * EphemeralData provides a mechanism to broadcast short-lived data — cursor positions, presence,
+ * heartbeats, etc. — that is useful in the moment but not worth persisting.
+ */
+export class EphemeralData extends EventEmitter {
+    /** Broadcast an ephemeral message */
+    broadcast(channelId, message) {
+        const messageBytes = encode(message);
+        this.emit("message", {
+            targetId: "*",
+            channelId: ("m/" + channelId),
+            message: messageBytes,
+            broadcast: true,
+        });
+    }
+    /** Receive an ephemeral message */
+    receive(senderId, grossChannelId, message) {
+        const data = decode(message);
+        const channelId = grossChannelId.slice(2);
+        this.emit("data", {
+            peerId: senderId,
+            channelId,
+            data,
+        });
+    }
+}

package/dist/Repo.d.ts

@@ -0,0 +1,30 @@
+import { DocCollection } from "./DocCollection.js";
+import { EphemeralData } from "./EphemeralData.js";
+import { NetworkAdapter } from "./network/NetworkAdapter.js";
+import { NetworkSubsystem } from "./network/NetworkSubsystem.js";
+import { StorageAdapter } from "./storage/StorageAdapter.js";
+import { StorageSubsystem } from "./storage/StorageSubsystem.js";
+import { DocumentId, PeerId } from "./types.js";
+/** A Repo is a DocCollection with networking, syncing, and storage capabilities. */
+export declare class Repo extends DocCollection {
+    #private;
+    networkSubsystem: NetworkSubsystem;
+    storageSubsystem?: StorageSubsystem;
+    ephemeralData: EphemeralData;
+    constructor({ storage, network, peerId, sharePolicy }: RepoConfig);
+}
+export interface RepoConfig {
+    /** Our unique identifier */
+    peerId?: PeerId;
+    /** A storage adapter can be provided, or not */
+    storage?: StorageAdapter;
+    /** One or more network adapters must be provided */
+    network: NetworkAdapter[];
+    /**
+     * Normal peers typically share generously with everyone (meaning we sync all our documents with
+     * all peers). A server only syncs documents that a peer explicitly requests by ID.
+     */
+    sharePolicy?: SharePolicy;
+}
+export type SharePolicy = (peerId: PeerId, documentId?: DocumentId) => Promise<boolean>;
+//# sourceMappingURL=Repo.d.ts.map

package/dist/Repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Repo.d.ts","sourceRoot":"","sources":["../src/Repo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAEhE,OAAO,EAAa,UAAU,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAM1D,oFAAoF;AACpF,qBAAa,IAAK,SAAQ,aAAa;;IAGrC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,aAAa,EAAE,aAAa,CAAA;gBAEhB,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,UAAU;CA+GlE;AAED,MAAM,WAAW,UAAU;IACzB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf,gDAAgD;IAChD,OAAO,CAAC,EAAE,cAAc,CAAA;IAExB,oDAAoD;IACpD,OAAO,EAAE,cAAc,EAAE,CAAA;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,MAAM,MAAM,WAAW,GAAG,CACxB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,UAAU,KACpB,OAAO,CAAC,OAAO,CAAC,CAAA"}

package/dist/Repo.js

@@ -0,0 +1,97 @@
+import { DocCollection } from "./DocCollection.js";
+import { EphemeralData } from "./EphemeralData.js";
+import { NetworkSubsystem } from "./network/NetworkSubsystem.js";
+import { StorageSubsystem } from "./storage/StorageSubsystem.js";
+import { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js";
+import debug from "debug";
+const SYNC_CHANNEL = "sync_channel";
+/** A Repo is a DocCollection with networking, syncing, and storage capabilities. */
+export class Repo extends DocCollection {
+    #log;
+    networkSubsystem;
+    storageSubsystem;
+    ephemeralData;
+    constructor({ storage, network, peerId, sharePolicy }) {
+        super();
+        this.#log = debug(`automerge-repo:repo`);
+        this.sharePolicy = sharePolicy ?? this.sharePolicy;
+        // DOC COLLECTION
+        // The `document` event is fired by the DocCollection any time we create a new document or look
+        // up a document by ID. We listen for it in order to wire up storage and network synchronization.
+        this.on("document", async ({ handle }) => {
+            if (storageSubsystem) {
+                // Save when the document changes
+                handle.on("change", async ({ handle }) => {
+                    const doc = await handle.value();
+                    storageSubsystem.save(handle.documentId, doc);
+                });
+                // Try to load from disk
+                const binary = await storageSubsystem.loadBinary(handle.documentId);
+                handle.load(binary);
+            }
+            handle.request();
+            // Register the document with the synchronizer. This advertises our interest in the document.
+            synchronizer.addDocument(handle.documentId);
+        });
+        this.on("delete-document", ({ documentId }) => {
+            // TODO Pass the delete on to the network
+            // synchronizer.removeDocument(documentId)
+            if (storageSubsystem) {
+                storageSubsystem.remove(documentId);
+            }
+        });
+        // SYNCHRONIZER
+        // The synchronizer uses the network subsystem to keep documents in sync with peers.
+        const synchronizer = new CollectionSynchronizer(this);
+        // When the synchronizer emits sync messages, send them to peers
+        synchronizer.on("message", ({ targetId, channelId, message, broadcast }) => {
+            this.#log(`sending sync message to ${targetId}`);
+            networkSubsystem.sendMessage(targetId, channelId, message, broadcast);
+        });
+        // STORAGE
+        // The storage subsystem has access to some form of persistence, and deals with save and loading documents.
+        const storageSubsystem = storage ? new StorageSubsystem(storage) : undefined;
+        this.storageSubsystem = storageSubsystem;
+        // NETWORK
+        // The network subsystem deals with sending and receiving messages to and from peers.
+        const networkSubsystem = new NetworkSubsystem(network, peerId);
+        this.networkSubsystem = networkSubsystem;
+        // When we get a new peer, register it with the synchronizer
+        networkSubsystem.on("peer", async ({ peerId }) => {
+            this.#log("peer connected", { peerId });
+            synchronizer.addPeer(peerId);
+        });
+        // When a peer disconnects, remove it from the synchronizer
+        networkSubsystem.on("peer-disconnected", ({ peerId }) => {
+            synchronizer.removePeer(peerId);
+        });
+        // Handle incoming messages
+        networkSubsystem.on("message", async (msg) => {
+            const { senderId, channelId, message } = msg;
+            // TODO: this demands a more principled way of associating channels with recipients
+            // Ephemeral channel ids start with "m/"
+            if (channelId.startsWith("m/")) {
+                // Ephemeral message
+                this.#log(`receiving ephemeral message from ${senderId}`);
+                ephemeralData.receive(senderId, channelId, message);
+            }
+            else {
+                // Sync message
+                this.#log(`receiving sync message from ${senderId}`);
+                await synchronizer.receiveSyncMessage(senderId, channelId, message);
+            }
+        });
+        // We establish a special channel for sync messages
+        networkSubsystem.join(SYNC_CHANNEL);
+        // EPHEMERAL DATA
+        // The ephemeral data subsystem uses the network to send and receive messages that are not
+        // persisted to storage, e.g. cursor position, presence, etc.
+        const ephemeralData = new EphemeralData();
+        this.ephemeralData = ephemeralData;
+        // Send ephemeral messages to peers
+        ephemeralData.on("message", ({ targetId, channelId, message, broadcast }) => {
+            this.#log(`sending ephemeral message to ${targetId}`);
+            networkSubsystem.sendMessage(targetId, channelId, message, broadcast);
+        });
+    }
+}

package/dist/helpers/arraysAreEqual.d.ts

@@ -0,0 +1,2 @@
+export declare const arraysAreEqual: <T>(a: T[], b: T[]) => boolean;
+//# sourceMappingURL=arraysAreEqual.d.ts.map

package/dist/helpers/arraysAreEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arraysAreEqual.d.ts","sourceRoot":"","sources":["../../src/helpers/arraysAreEqual.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,gCACiD,CAAA"}

package/dist/helpers/arraysAreEqual.js

@@ -0,0 +1 @@
+export const arraysAreEqual = (a, b) => a.length === b.length && a.every((element, index) => element === b[index]);

package/dist/helpers/eventPromise.d.ts

@@ -0,0 +1,5 @@
+import EventEmitter from "eventemitter3";
+/** Returns a promise that resolves when the given event is emitted on the given emitter. */
+export declare const eventPromise: (emitter: EventEmitter, event: string) => Promise<any>;
+export declare const eventPromises: (emitters: EventEmitter[], event: string) => Promise<any[]>;
+//# sourceMappingURL=eventPromise.d.ts.map

package/dist/helpers/eventPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventPromise.d.ts","sourceRoot":"","sources":["../../src/helpers/eventPromise.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AAExC,4FAA4F;AAC5F,eAAO,MAAM,YAAY,YAAa,YAAY,SAAS,MAAM,iBACE,CAAA;AAEnE,eAAO,MAAM,aAAa,aAAc,YAAY,EAAE,SAAS,MAAM,mBAGpE,CAAA"}

package/dist/helpers/eventPromise.js

@@ -0,0 +1,6 @@
+/** Returns a promise that resolves when the given event is emitted on the given emitter. */
+export const eventPromise = (emitter, event) => new Promise(resolve => emitter.once(event, d => resolve(d)));
+export const eventPromises = (emitters, event) => {
+    const promises = emitters.map(emitter => eventPromise(emitter, event));
+    return Promise.all(promises);
+};

package/dist/helpers/headsAreSame.d.ts

@@ -0,0 +1,3 @@
+import * as A from "@automerge/automerge";
+export declare const headsAreSame: <T>(a: A.unstable.Doc<T>, b: A.unstable.Doc<T>) => boolean;
+//# sourceMappingURL=headsAreSame.d.ts.map

package/dist/helpers/headsAreSame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headsAreSame.d.ts","sourceRoot":"","sources":["../../src/helpers/headsAreSame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAA;AAGzC,eAAO,MAAM,YAAY,4DAIxB,CAAA"}

package/dist/helpers/headsAreSame.js

@@ -0,0 +1,7 @@
+import * as A from "@automerge/automerge";
+import { arraysAreEqual } from "./arraysAreEqual.js";
+export const headsAreSame = (a, b) => {
+    const aHeads = A.getHeads(a);
+    const bHeads = A.getHeads(b);
+    return arraysAreEqual(aHeads, bHeads);
+};

package/dist/helpers/mergeArrays.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeArrays(myArrays: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=mergeArrays.d.ts.map

package/dist/helpers/mergeArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/mergeArrays.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,cAgBjD"}

package/dist/helpers/mergeArrays.js

@@ -0,0 +1,15 @@
+export function mergeArrays(myArrays) {
+    // Get the total length of all arrays.
+    let length = 0;
+    myArrays.forEach(item => {
+        length += item.length;
+    });
+    // Create a new array with total length and merge all source arrays.
+    const mergedArray = new Uint8Array(length);
+    let offset = 0;
+    myArrays.forEach(item => {
+        mergedArray.set(item, offset);
+        offset += item.length;
+    });
+    return mergedArray;
+}

package/dist/helpers/pause.d.ts

@@ -0,0 +1,3 @@
+export declare const pause: (t?: number) => Promise<void>;
+export declare function rejectOnTimeout<T>(promise: Promise<T>, millis: number): Promise<T>;
+//# sourceMappingURL=pause.d.ts.map

package/dist/helpers/pause.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pause.d.ts","sourceRoot":"","sources":["../../src/helpers/pause.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,+BAC4C,CAAA;AAE9D,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAKlF"}

package/dist/helpers/pause.js

@@ -0,0 +1,7 @@
+export const pause = (t = 0) => new Promise(resolve => setTimeout(() => resolve(), t));
+export function rejectOnTimeout(promise, millis) {
+    return Promise.race([
+        promise,
+        pause(millis).then(() => { throw new Error("timeout exceeded"); }),
+    ]);
+}

package/dist/helpers/withTimeout.d.ts

@@ -0,0 +1,9 @@
+/**
+ * If `promise` is resolved before `t` ms elapse, the timeout is cleared and the result of the
+ * promise is returned. If the timeout ends first, a `TimeoutError` is thrown.
+ */
+export declare const withTimeout: <T>(promise: Promise<T>, t: number) => Promise<T>;
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=withTimeout.d.ts.map

package/dist/helpers/withTimeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTimeout.d.ts","sourceRoot":"","sources":["../../src/helpers/withTimeout.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,WAAW,8BAEnB,MAAM,eAcV,CAAA;AAED,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAI5B"}

package/dist/helpers/withTimeout.js

@@ -0,0 +1,22 @@
+/**
+ * If `promise` is resolved before `t` ms elapse, the timeout is cleared and the result of the
+ * promise is returned. If the timeout ends first, a `TimeoutError` is thrown.
+ */
+export const withTimeout = async (promise, t) => {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new TimeoutError(`withTimeout: timed out after ${t}ms`)), t);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+};
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TimeoutError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { DocCollection } from "./DocCollection.js";
+export { DocHandle, HandleState } from "./DocHandle.js";
+export type { DocHandleChangePayload, DocHandleMessagePayload, DocHandlePatchPayload, } from "./DocHandle.js";
+export { NetworkAdapter } from "./network/NetworkAdapter.js";
+export type { InboundMessagePayload, MessagePayload, OpenPayload, PeerCandidatePayload, PeerDisconnectedPayload, } from "./network/NetworkAdapter.js";
+export { NetworkSubsystem } from "./network/NetworkSubsystem.js";
+export { Repo, type SharePolicy } from "./Repo.js";
+export { StorageAdapter } from "./storage/StorageAdapter.js";
+export { StorageSubsystem } from "./storage/StorageSubsystem.js";
+export { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js";
+export * from "./types.js";
+export * from "./test-utilities/adapter-tests.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACvD,YAAY,EACV,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,YAAY,EACV,qBAAqB,EACrB,cAAc,EACd,WAAW,EACX,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAA;AACjF,cAAc,YAAY,CAAA;AAC1B,cAAc,mCAAmC,CAAA"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { DocCollection } from "./DocCollection.js";
+export { DocHandle, HandleState } from "./DocHandle.js";
+export { NetworkAdapter } from "./network/NetworkAdapter.js";
+export { NetworkSubsystem } from "./network/NetworkSubsystem.js";
+export { Repo } from "./Repo.js";
+export { StorageAdapter } from "./storage/StorageAdapter.js";
+export { StorageSubsystem } from "./storage/StorageSubsystem.js";
+export { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js";
+export * from "./types.js";
+export * from "./test-utilities/adapter-tests.js";

package/dist/network/NetworkAdapter.d.ts

@@ -0,0 +1,37 @@
+import EventEmitter from "eventemitter3";
+import { PeerId, ChannelId } from "../types.js";
+export declare abstract class NetworkAdapter extends EventEmitter<NetworkAdapterEvents> {
+    peerId?: PeerId;
+    abstract connect(url?: string): void;
+    abstract sendMessage(peerId: PeerId, channelId: ChannelId, message: Uint8Array, broadcast: boolean): void;
+    abstract join(channelId: ChannelId): void;
+    abstract leave(channelId: ChannelId): void;
+}
+export interface NetworkAdapterEvents {
+    open: (payload: OpenPayload) => void;
+    close: () => void;
+    "peer-candidate": (payload: PeerCandidatePayload) => void;
+    "peer-disconnected": (payload: PeerDisconnectedPayload) => void;
+    message: (payload: InboundMessagePayload) => void;
+}
+export interface OpenPayload {
+    network: NetworkAdapter;
+}
+export interface PeerCandidatePayload {
+    peerId: PeerId;
+    channelId: ChannelId;
+}
+export interface MessagePayload {
+    targetId: PeerId;
+    channelId: ChannelId;
+    message: Uint8Array;
+    broadcast: boolean;
+}
+export interface InboundMessagePayload extends MessagePayload {
+    type?: string;
+    senderId: PeerId;
+}
+export interface PeerDisconnectedPayload {
+    peerId: PeerId;
+}
+//# sourceMappingURL=NetworkAdapter.d.ts.map

package/dist/network/NetworkAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkAdapter.d.ts","sourceRoot":"","sources":["../../src/network/NetworkAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE/C,8BAAsB,cAAe,SAAQ,YAAY,CAAC,oBAAoB,CAAC;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAA;IAEf,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI;IAEpC,QAAQ,CAAC,WAAW,CAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,OAAO,GACjB,IAAI;IAEP,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAEzC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;CAC3C;AAID,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAA;IACpC,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gBAAgB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACzD,mBAAmB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAA;IAC/D,OAAO,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,IAAI,CAAA;CAClD;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,cAAc,CAAA;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,EAAE,UAAU,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAA;CACf"}

package/dist/network/NetworkAdapter.js

@@ -0,0 +1,4 @@
+import EventEmitter from "eventemitter3";
+export class NetworkAdapter extends EventEmitter {
+    peerId; // hmmm, maybe not
+}