@swal/edge-mesh 0.0.0-stage → 0.1.0

package/dist/storage/optimizer.js

@@ -0,0 +1,50 @@
+import { compress, decompress, init } from "@bokuweb/zstd-wasm";
+import { decode, encode } from "cbor-x";
+let isZstdInitialized = false;
+/**
+ * Initializes the WASM module for Zstd.
+ * Must be called once before compressing or decompressing.
+ */
+export async function initializeOptimizer() {
+    if (!isZstdInitialized) {
+        await init();
+        isZstdInitialized = true;
+    }
+}
+/**
+ * Utility class to compress large payloads before storing them in local databases (IndexedDB/OPFS)
+ * or broadcasting them across the P2P network.
+ *
+ * It serializes objects to CBOR (Concise Binary Object Representation) and then compresses
+ * the binary stream using Zstandard (Zstd), significantly reducing the required space.
+ */
+export class PayloadOptimizer {
+    /**
+     * Serializes an object to CBOR and compresses it with Zstd.
+     * @param payload Any serializable JavaScript object.
+     * @param level Compression level (default 10).
+     * @returns A Uint8Array containing the compressed binary data.
+     */
+    static async compressPayload(payload, level = 10) {
+        await initializeOptimizer();
+        // 1. Serialize to CBOR
+        const cborBuffer = encode(payload);
+        // 2. Compress with Zstd
+        const compressed = compress(new Uint8Array(cborBuffer), level);
+        return compressed;
+    }
+    /**
+     * Decompresses Zstd data and deserializes it from CBOR back to the original object.
+     * @param buffer The compressed binary data (Uint8Array).
+     * @returns The original parsed object.
+     */
+    static async decompressPayload(buffer) {
+        await initializeOptimizer();
+        // 1. Decompress from Zstd
+        const decompressed = decompress(buffer);
+        // 2. Deserialize from CBOR
+        const payload = decode(decompressed);
+        return payload;
+    }
+}
+//# sourceMappingURL=optimizer.js.map

package/dist/storage/optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer.js","sourceRoot":"","sources":["../../src/storage/optimizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAExC,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAE9B;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB;IACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACxB,MAAM,IAAI,EAAE,CAAC;QACb,iBAAiB,GAAG,IAAI,CAAC;IAC1B,CAAC;AACF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,gBAAgB;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,eAAe,CAC3B,OAAU,EACV,KAAK,GAAW,EAAE;QAElB,MAAM,mBAAmB,EAAE,CAAC;QAE5B,uBAAuB;QACvB,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAEnC,wBAAwB;QACxB,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC;QAE/D,OAAO,UAAU,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAI,MAAkB;QACnD,MAAM,mBAAmB,EAAE,CAAC;QAE5B,0BAA0B;QAC1B,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;QAExC,2BAA2B;QAC3B,MAAM,OAAO,GAAG,MAAM,CAAC,YAAY,CAAM,CAAC;QAE1C,OAAO,OAAO,CAAC;IAChB,CAAC;CACD"}

package/dist/storage/ydoc-persistence.d.ts

@@ -0,0 +1,27 @@
+import * as Y from "yjs";
+import type { IStorage } from "./index.js";
+export interface YDocPersistenceOptions {
+    /** Maximum number of incremental updates to keep before compaction. Default is 100. */
+    readonly maxUpdatesBeforeCompaction?: number;
+}
+export declare class YDocPersistence {
+    private readonly docName;
+    private readonly doc;
+    private readonly storage;
+    private readonly updateHandler;
+    private readonly maxUpdatesBeforeCompaction;
+    private updateCount;
+    /** Promise that resolves when the document is fully loaded and rehydrated from storage. */
+    readonly whenLoaded: Promise<void>;
+    constructor(docName: string, doc: Y.Doc, storage: IStorage, options?: YDocPersistenceOptions);
+    private load;
+    private toUint8Array;
+    private storeUpdate;
+    /**
+     * Compacts the incremental updates of the document into a single snapshot/update
+     * and clears previous individual incremental updates to save storage.
+     */
+    compact(): Promise<void>;
+    destroy(): void;
+}
+//# sourceMappingURL=ydoc-persistence.d.ts.map

package/dist/storage/ydoc-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ydoc-persistence.d.ts","sourceRoot":"","sources":["../../src/storage/ydoc-persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,WAAW,sBAAsB;IACtC,uFAAuF;IACvF,QAAQ,CAAC,0BAA0B,CAAC,EAAE,MAAM,CAAC;CAC7C;AAED,qBAAa,eAAe;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAW;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgD;IAC9E,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAAS;IACpD,OAAO,CAAC,WAAW,CAAK;IAExB,2FAA2F;IAC3F,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnC,YACC,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,CAAC,CAAC,GAAG,EACV,OAAO,EAAE,QAAQ,EACjB,OAAO,GAAE,sBAA2B,EAepC;YAEa,IAAI;IAwDlB,OAAO,CAAC,YAAY;YAgBN,WAAW;IAczB;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CA4B7B;IAED,OAAO,IAAI,IAAI,CAEd;CACD"}

package/dist/storage/ydoc-persistence.js

@@ -0,0 +1,128 @@
+import * as Y from "yjs";
+export class YDocPersistence {
+    docName;
+    doc;
+    storage;
+    updateHandler;
+    maxUpdatesBeforeCompaction;
+    updateCount = 0;
+    /** Promise that resolves when the document is fully loaded and rehydrated from storage. */
+    whenLoaded;
+    constructor(docName, doc, storage, options = {}) {
+        this.docName = docName;
+        this.doc = doc;
+        this.storage = storage;
+        this.maxUpdatesBeforeCompaction = options.maxUpdatesBeforeCompaction ?? 100;
+        this.updateHandler = (update, origin) => {
+            // Avoid saving updates that came from the persistence provider itself during rehydration.
+            if (origin === this)
+                return;
+            void this.storeUpdate(update);
+        };
+        this.doc.on("update", this.updateHandler);
+        this.whenLoaded = this.load();
+    }
+    async load() {
+        try {
+            // 1. Retrieve compaction records (if any)
+            const compacts = await this.storage.list({
+                prefijo: `ydoc:${this.docName}:compact:`,
+            });
+            let latestCompactTimestamp = 0;
+            let compactValue = null;
+            if (compacts.length > 0) {
+                // Since list returns entries sorted by timestamp, the last one is the latest
+                const latestCompact = compacts[compacts.length - 1];
+                latestCompactTimestamp = latestCompact.timestamp;
+                // Recover the compact value
+                if (latestCompact.valor) {
+                    compactValue = this.toUint8Array(latestCompact.valor);
+                }
+            }
+            // 2. Retrieve incremental updates
+            const updates = await this.storage.list({
+                prefijo: `ydoc:${this.docName}:update:`,
+            });
+            // Filter updates to apply only those that were saved after the latest compaction (or all if no compaction)
+            const updatesToApply = updates.filter((entry) => entry.timestamp >= latestCompactTimestamp);
+            this.updateCount = updatesToApply.length;
+            // 3. Apply updates transactionally with `this` origin to avoid echoing/double saving
+            this.doc.transact(() => {
+                if (compactValue && compactValue.length > 0) {
+                    Y.applyUpdate(this.doc, compactValue);
+                }
+                for (const entry of updatesToApply) {
+                    if (entry.valor) {
+                        const updateBytes = this.toUint8Array(entry.valor);
+                        if (updateBytes.length > 0) {
+                            Y.applyUpdate(this.doc, updateBytes);
+                        }
+                    }
+                }
+            }, this);
+        }
+        catch (error) {
+            console.error(`[YDocPersistence] Error loading Y.Doc "${this.docName}":`, error);
+            throw error;
+        }
+    }
+    toUint8Array(valor) {
+        if (valor instanceof Uint8Array) {
+            return valor;
+        }
+        if (Array.isArray(valor)) {
+            return new Uint8Array(valor);
+        }
+        if (typeof valor === "object" && valor !== null && "data" in valor) {
+            const arr = valor.data;
+            if (Array.isArray(arr)) {
+                return new Uint8Array(arr);
+            }
+        }
+        throw new Error("Unsupported serialized update format");
+    }
+    async storeUpdate(update) {
+        const timestamp = Date.now();
+        const id = Math.random().toString(36).substring(2, 9);
+        const key = `ydoc:${this.docName}:update:${timestamp}:${id}`;
+        // Convert Uint8Array to Array to ensure compatibility with all serialization adapters
+        await this.storage.set(key, Array.from(update));
+        this.updateCount++;
+        if (this.updateCount >= this.maxUpdatesBeforeCompaction) {
+            void this.compact();
+        }
+    }
+    /**
+     * Compacts the incremental updates of the document into a single snapshot/update
+     * and clears previous individual incremental updates to save storage.
+     */
+    async compact() {
+        await this.whenLoaded;
+        const state = Y.encodeStateAsUpdate(this.doc);
+        const timestamp = Date.now();
+        const compactKey = `ydoc:${this.docName}:compact:${timestamp}`;
+        await this.storage.set(compactKey, Array.from(state));
+        this.updateCount = 0;
+        // Clean up previous updates and compact records
+        const updates = await this.storage.list({
+            prefijo: `ydoc:${this.docName}:update:`,
+        });
+        const compacts = await this.storage.list({
+            prefijo: `ydoc:${this.docName}:compact:`,
+        });
+        for (const entry of updates) {
+            if (entry.timestamp < timestamp) {
+                await this.storage.delete(entry.key);
+            }
+        }
+        for (const entry of compacts) {
+            if (entry.timestamp < timestamp) {
+                await this.storage.delete(entry.key);
+            }
+        }
+    }
+    destroy() {
+        this.doc.off("update", this.updateHandler);
+    }
+}
+//# sourceMappingURL=ydoc-persistence.js.map

package/dist/storage/ydoc-persistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ydoc-persistence.js","sourceRoot":"","sources":["../../src/storage/ydoc-persistence.ts"],"names":[],"mappings":"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"}

package/dist/sync/ChunkSyncManager.d.ts

@@ -0,0 +1,41 @@
+import type { NodoId } from "../types/index.js";
+export interface SyncChunk<T = unknown> {
+    readonly id: string;
+    readonly docId: string;
+    readonly payload: T;
+    readonly lamportTimestamp: number;
+    readonly nodeId: NodoId;
+    readonly version: number;
+    readonly createdAt: number;
+}
+export interface ChunkConflictResolution<T = unknown> {
+    readonly winner: SyncChunk<T>;
+    readonly loser: SyncChunk<T>;
+    readonly resolutionStrategy: "lamport" | "node_tiebreak" | "manual";
+}
+export interface ChunkSyncConfig {
+    readonly nodeId: NodoId;
+    readonly maxRetries?: number;
+    readonly retryDelayMs?: number;
+}
+export declare class ChunkSyncManager<T = unknown> {
+    readonly nodeId: NodoId;
+    private currentLamport;
+    private readonly chunks;
+    private readonly retryQueue;
+    private readonly maxRetries;
+    private readonly retryDelayMs;
+    constructor(config: ChunkSyncConfig);
+    getLamportTimestamp(): number;
+    tick(): number;
+    createChunk(docId: string, payload: T): SyncChunk<T>;
+    receiveChunk(incoming: SyncChunk<T>): {
+        accepted: boolean;
+        resolution?: ChunkConflictResolution<T>;
+    };
+    getChunk(docId: string): SyncChunk<T> | undefined;
+    enqueueRetry(chunk: SyncChunk<T>): void;
+    getPendingRetries(): SyncChunk<T>[];
+    clearQueue(): void;
+}
+//# sourceMappingURL=ChunkSyncManager.d.ts.map

package/dist/sync/ChunkSyncManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkSyncManager.d.ts","sourceRoot":"","sources":["../../src/sync/ChunkSyncManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,OAAO;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC,GAAG,OAAO;IACnD,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,SAAS,GAAG,eAAe,GAAG,QAAQ,CAAC;CACpE;AAED,MAAM,WAAW,eAAe;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,qBAAa,gBAAgB,CAAC,CAAC,GAAG,OAAO;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;IAC1D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAInB;IACR,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC,YAAY,MAAM,EAAE,eAAe,EAIlC;IAED,mBAAmB,IAAI,MAAM,CAE5B;IAED,IAAI,IAAI,MAAM,CAGb;IAED,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAenD;IAED,YAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG;QACrC,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;KACxC,CAsDA;IAED,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAEhD;IAED,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAMtC;IAED,iBAAiB,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAWlC;IAED,UAAU,IAAI,IAAI,CAEjB;CACD"}

package/dist/sync/ChunkSyncManager.js

@@ -0,0 +1,115 @@
+export class ChunkSyncManager {
+    nodeId;
+    currentLamport = 0;
+    chunks = new Map();
+    retryQueue = [];
+    maxRetries;
+    retryDelayMs;
+    constructor(config) {
+        this.nodeId = config.nodeId;
+        this.maxRetries = config.maxRetries ?? 3;
+        this.retryDelayMs = config.retryDelayMs ?? 1000;
+    }
+    getLamportTimestamp() {
+        return this.currentLamport;
+    }
+    tick() {
+        this.currentLamport += 1;
+        return this.currentLamport;
+    }
+    createChunk(docId, payload) {
+        const ts = this.tick();
+        const chunkId = `${docId}_${this.nodeId}_${ts}_${Date.now()}`;
+        const chunk = {
+            id: chunkId,
+            docId,
+            payload,
+            lamportTimestamp: ts,
+            nodeId: this.nodeId,
+            version: 1,
+            createdAt: Date.now(),
+        };
+        this.chunks.set(docId, chunk);
+        return chunk;
+    }
+    receiveChunk(incoming) {
+        // Advance local Lamport clock
+        this.currentLamport =
+            Math.max(this.currentLamport, incoming.lamportTimestamp) + 1;
+        const existing = this.chunks.get(incoming.docId);
+        if (!existing) {
+            this.chunks.set(incoming.docId, incoming);
+            return { accepted: true };
+        }
+        // Conflict reconciliation using Lamport timestamps
+        if (incoming.lamportTimestamp > existing.lamportTimestamp) {
+            this.chunks.set(incoming.docId, incoming);
+            return {
+                accepted: true,
+                resolution: {
+                    winner: incoming,
+                    loser: existing,
+                    resolutionStrategy: "lamport",
+                },
+            };
+        }
+        else if (incoming.lamportTimestamp < existing.lamportTimestamp) {
+            return {
+                accepted: false,
+                resolution: {
+                    winner: existing,
+                    loser: incoming,
+                    resolutionStrategy: "lamport",
+                },
+            };
+        }
+        else {
+            // Deterministic tie-breaker: lex compare node IDs
+            if (incoming.nodeId > existing.nodeId) {
+                this.chunks.set(incoming.docId, incoming);
+                return {
+                    accepted: true,
+                    resolution: {
+                        winner: incoming,
+                        loser: existing,
+                        resolutionStrategy: "node_tiebreak",
+                    },
+                };
+            }
+            else {
+                return {
+                    accepted: false,
+                    resolution: {
+                        winner: existing,
+                        loser: incoming,
+                        resolutionStrategy: "node_tiebreak",
+                    },
+                };
+            }
+        }
+    }
+    getChunk(docId) {
+        return this.chunks.get(docId);
+    }
+    enqueueRetry(chunk) {
+        this.retryQueue.push({
+            chunk,
+            attempts: 0,
+            nextRetry: Date.now() + this.retryDelayMs,
+        });
+    }
+    getPendingRetries() {
+        const now = Date.now();
+        return this.retryQueue
+            .filter((item) => item.nextRetry <= now && item.attempts < this.maxRetries)
+            .map((item) => {
+            item.attempts += 1;
+            item.nextRetry = now + this.retryDelayMs * 2 ** item.attempts;
+            return item.chunk;
+        });
+    }
+    clearQueue() {
+        this.retryQueue.length = 0;
+    }
+}
+//# sourceMappingURL=ChunkSyncManager.js.map

package/dist/sync/ChunkSyncManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkSyncManager.js","sourceRoot":"","sources":["../../src/sync/ChunkSyncManager.ts"],"names":[],"mappings":"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"}

package/dist/sync/conflict-resolver.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Conflict resolver for concurrent backlog updates.
+ * Implements last-writer-wins with vector clocks.
+ */
+export interface VectorClock {
+    [nodeId: string]: number;
+}
+export interface ConflictEntry {
+    key: string;
+    localValue: unknown;
+    remoteValue: unknown;
+    localClock: VectorClock;
+    remoteClock: VectorClock;
+    timestamp: number;
+}
+/**
+ * Compare two vector clocks.
+ * Returns: -1 if a < b, 0 if concurrent, 1 if a > b
+ */
+export declare function compareClocks(a: VectorClock, b: VectorClock): number;
+/**
+ * Resolve conflict using last-writer-wins.
+ * If concurrent, use timestamp as tiebreaker.
+ */
+export declare function resolveConflict(local: unknown, remote: unknown, localClock: VectorClock, remoteClock: VectorClock, localTimestamp: number, remoteTimestamp: number): {
+    winner: "local" | "remote";
+    reason: string;
+};
+/**
+ * Increment vector clock for a node.
+ */
+export declare function incrementClock(clock: VectorClock, nodeId: string): VectorClock;
+//# sourceMappingURL=conflict-resolver.d.ts.map

package/dist/sync/conflict-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-resolver.d.ts","sourceRoot":"","sources":["../../src/sync/conflict-resolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC3B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,WAAW,CAAC;IACxB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,GAAG,MAAM,CAepE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,WAAW,EACvB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,GACrB;IAAE,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAehD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,GACZ,WAAW,CAKb"}

package/dist/sync/conflict-resolver.js

@@ -0,0 +1,54 @@
+/**
+ * Conflict resolver for concurrent backlog updates.
+ * Implements last-writer-wins with vector clocks.
+ */
+/**
+ * Compare two vector clocks.
+ * Returns: -1 if a < b, 0 if concurrent, 1 if a > b
+ */
+export function compareClocks(a, b) {
+    let aGreater = false;
+    let bGreater = false;
+    const allNodes = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const node of allNodes) {
+        const aVal = a[node] ?? 0;
+        const bVal = b[node] ?? 0;
+        if (aVal > bVal)
+            aGreater = true;
+        if (bVal > aVal)
+            bGreater = true;
+    }
+    if (aGreater && !bGreater)
+        return 1;
+    if (bGreater && !aGreater)
+        return -1;
+    return 0; // concurrent
+}
+/**
+ * Resolve conflict using last-writer-wins.
+ * If concurrent, use timestamp as tiebreaker.
+ */
+export function resolveConflict(local, remote, localClock, remoteClock, localTimestamp, remoteTimestamp) {
+    const cmp = compareClocks(localClock, remoteClock);
+    if (cmp === 1) {
+        return { winner: "local", reason: "local clock dominates" };
+    }
+    if (cmp === -1) {
+        return { winner: "remote", reason: "remote clock dominates" };
+    }
+    // Concurrent — use timestamp
+    if (localTimestamp >= remoteTimestamp) {
+        return { winner: "local", reason: "concurrent, local newer" };
+    }
+    return { winner: "remote", reason: "concurrent, remote newer" };
+}
+/**
+ * Increment vector clock for a node.
+ */
+export function incrementClock(clock, nodeId) {
+    return {
+        ...clock,
+        [nodeId]: (clock[nodeId] ?? 0) + 1,
+    };
+}
+//# sourceMappingURL=conflict-resolver.js.map

package/dist/sync/conflict-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-resolver.js","sourceRoot":"","sources":["../../src/sync/conflict-resolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,CAAc,EAAE,CAAc;IAC3D,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACjE,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,IAAI,GAAG,IAAI;YAAE,QAAQ,GAAG,IAAI,CAAC;QACjC,IAAI,IAAI,GAAG,IAAI;YAAE,QAAQ,GAAG,IAAI,CAAC;IAClC,CAAC;IAED,IAAI,QAAQ,IAAI,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,QAAQ,IAAI,CAAC,QAAQ;QAAE,OAAO,CAAC,CAAC,CAAC;IACrC,OAAO,CAAC,CAAC,CAAC,aAAa;AACxB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC9B,KAAc,EACd,MAAe,EACf,UAAuB,EACvB,WAAwB,EACxB,cAAsB,EACtB,eAAuB;IAEvB,MAAM,GAAG,GAAG,aAAa,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAEnD,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;QACf,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC;IAC7D,CAAC;IACD,IAAI,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC;QAChB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC;IAC/D,CAAC;IAED,6BAA6B;IAC7B,IAAI,cAAc,IAAI,eAAe,EAAE,CAAC;QACvC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,yBAAyB,EAAE,CAAC;IAC/D,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC;AACjE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAC7B,KAAkB,EAClB,MAAc;IAEd,OAAO;QACN,GAAG,KAAK;QACR,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;KAClC,CAAC;AACH,CAAC"}

package/dist/sync/engine.d.ts

@@ -0,0 +1,168 @@
+import type { OpLog } from "../op-log/index.js";
+import type { NodoId } from "../types/index.js";
+/**
+ * Tope de operaciones que ponemos en el cable en un solo lote. Tambien se usa
+ * como tope de entrada por defecto (ver `maxBatchOperations`).
+ *
+ * Por que 500: un documento CRDT que se ha dividido de verdad en mas de unos
+ * pocos cientos de operaciones es un documento que hay que resyncar con un
+ * snapshot, no fusionar operacion a operacion. 500 operaciones de una nota
+ * clinica tipica (~600 bytes de payload mas una firma ML-DSA-65 de ~3.3 KB)
+ * caben de sobra en el presupuesto de un datagrama WebRTC, asi que un par
+ * conforme nunca necesita un frame mayor.
+ */
+export declare const MAX_BATCH_SIZE: 500;
+/**
+ * Tope duro del tamano serializado de un sobre recibido.
+ *
+ * Por que 256 KiB: una operacion CRDT es una edicion (un campo de un registro),
+ * no un documento entero. Incluso una patologica — una insercion de texto completo
+ * o una referencia a un adjunto en base64 — queda muy por debajo de 256 KiB,
+ * mientras que algo mayor es mucho mas probable que un intento de agotamiento de
+ * memoria que datos clinicos reales. Tambien mantiene acotado el coste transitorio
+ * de validar un sobre, sea cual sea lo que el par haya puesto en `datos`.
+ */
+export declare const MAX_ENVELOPE_BYTES: 262144;
+export type SyncDirection = "bidireccional" | "entrante" | "saliente";
+export interface SyncEngineConfig {
+    readonly docId: string;
+    readonly opLog: OpLog;
+    readonly batchSize?: number;
+    readonly timeoutMs?: number;
+    readonly direction?: SyncDirection;
+    /**
+     * Tope duro del numero de operaciones aceptadas de un mismo par en una ronda
+     * de sync (por defecto: {@link MAX_BATCH_SIZE}).
+     *
+     * Ver {@link SyncEngine} para por que un lote sobredimensionado se rechaza
+     * entero en vez de aplicarse en trozos.
+     */
+    readonly maxBatchOperations?: number;
+    /**
+     * Tope duro del tamano en bytes serializados de un sobre recibido (por
+     * defecto: {@link MAX_ENVELOPE_BYTES}). Los sobres sobredimensionados se
+     * rechazan, nunca se truncan.
+     */
+    readonly maxEnvelopeBytes?: number;
+}
+export interface SyncResult {
+    readonly docId: string;
+    readonly operacionesEnviadas: number;
+    readonly operacionesRecibidas: number;
+    readonly conflictos: number;
+    /**
+     * Operaciones rechazadas por los limites de recurso (sobre sobredimensionado,
+     * lote sobredimensionado). Un operador ve asi la basura de transporte en la
+     * misma cuenta que las demas senales de rechazo.
+     */
+    readonly operacionesRechazadas: number;
+    readonly duracionMs: number;
+    readonly exito: boolean;
+}
+export interface SyncEngineEventMap {
+    syncIniciado: CustomEvent<{
+        readonly docId: string;
+        readonly peerId: NodoId;
+        readonly direction: SyncDirection;
+    }>;
+    syncCompletado: CustomEvent<{
+        readonly resultado: SyncResult;
+        readonly peerId: NodoId;
+    }>;
+    syncError: CustomEvent<{
+        readonly docId: string;
+        readonly peerId: NodoId;
+        readonly error: string;
+    }>;
+    conflictoDetectado: CustomEvent<{
+        readonly docId: string;
+        readonly operacionLocal: unknown;
+        readonly operacionRemota: unknown;
+    }>;
+    /**
+     * Un lote entrante excedia `maxBatchOperations` y se rechazo entero.
+     * `lotesOperaciones` es cuantas operaciones intento empujar el par.
+     */
+    loteRechazado: CustomEvent<{
+        readonly docId: string;
+        readonly peerId: NodoId;
+        readonly lotesOperaciones: number;
+        readonly maximoPermitido: number;
+    }>;
+    /**
+     * Un sobre excedia `maxEnvelopeBytes` y fue rechazado. Los sobres nunca se
+     * truncan: una operacion partida a la mitad dejaria la secuencia en vuelo y el
+     * log inconsistente.
+     */
+    sobreRechazadoPorTamano: CustomEvent<{
+        readonly docId: string;
+        readonly peerId: NodoId;
+        readonly secuencia: number;
+        readonly bytes: number;
+        readonly maximoPermitido: number;
+    }>;
+}
+export declare class SyncEngine {
+    readonly eventTarget: EventTarget;
+    readonly docId: string;
+    private readonly opLog;
+    private readonly batchSize;
+    private readonly timeoutMs;
+    private readonly _direction;
+    private readonly maxBatchOperations;
+    private readonly maxEnvelopeBytes;
+    private sincronizando;
+    private clockLocal;
+    private readonly clocksRemotos;
+    constructor(config: SyncEngineConfig);
+    sincronizar(peerId: NodoId, enviar: (ops: readonly unknown[]) => Promise<void>, recibir: () => Promise<readonly unknown[]>): Promise<SyncResult>;
+    /**
+     * Acota la memoria que un solo par puede hacer que este nodo asigne
+     * aplicando dos topes duros a un lote entrante.
+     *
+     * 1. **Tope de cantidad.** Un lote con mas de `maxBatchOperations` entradas se
+     *    rechaza ENTERO, no en trozos. Esta comprobacion va primero, sobre el solo
+     *    `length`, asi que un lote sobredimensionado se rechaza en tiempo constante.
+     *
+     *    Compromiso, enunciado explicitamente porque es la decision discutible:
+     *    - *Por que rechazar entero en vez de por trozos*: el rechazo es atomico y
+     *      auditable. El par recibe un unico evento `loteRechazado` claro en vez de
+     *      una fusion parcial silenciosa, el operador ve un solo rechazo contable en
+     *      `operacionesRechazadas`, y `aplicarOperaciones` nunca se invoca con un
+     *      array sin limite. Tambien significa que un par hostil no puede lograr una
+     *      escritura parcial confirmada antes de descubrir que el resto es basura:
+     *      trocear un lote envenenado aplicaria las primeras N operaciones y luego
+     *      pararia, dejando en el log operaciones que ya le dijimos al par que no
+     *      podemos verificar. Como el lote entero se descarta, la pasada por sobre
+     *      se omite por completo: serializar 500k sobres solo para tirarlos seria
+     *      justamente la tormenta de asignaciones que este tope existe para
+     *      impedir.
+     *    - *Que perdemos*: un par legitamente atrasado, con 800 operaciones
+     *      pendientes, no obtiene nada esta ronda en vez de 500 de ellas. Eso es
+     *      recuperable y correcto en el cable — `recibir()` es el closure de
+     *      transporte del propio llamador, asi que un llamador conforme vuelve a
+     *      ofrecer el resto desde el clock anunciado por el par, tal como ya debe
+     *      hacer con los lotes salientes que troceamos en `batchSize`. No se pierde
+     *      ninguna operacion; la puesta al dia simplemente tarda otra ronda. La
+     *      siguiente ronda vuelve a estar acotada por el mismo tope, que es el punto.
+     *
+     * 2. **Tope de bytes por sobre.** Un sobre cuya forma serializada exceda
+     *    `maxEnvelopeBytes` se descarta. NUNCA se trunca: un sobre truncado se
+     *    parsea como una operacion parcial, lo que avanzaria la secuencia con un
+     *    delta parcial y dejaria el log CRDT inconsistente. Rechazar es la unica
+     *    opcion que mantiene el log entero.
+     *
+     * Los rechazos se cuentan en `SyncResult.operacionesRechazadas` para que un
+     * operador vea la basura junto a los rechazos de confianza.
+     */
+    private aplicarLimitesDeRecurso;
+    actualizarClockLocal(clock: number): void;
+    actualizarClockRemoto(peerId: NodoId, clock: number): void;
+    obtenerClockLocal(): number;
+    obtenerClockRemoto(peerId: NodoId): number;
+    estaSincronizando(): boolean;
+    on<K extends keyof SyncEngineEventMap>(tipo: K, handler: (ev: SyncEngineEventMap[K]) => void): void;
+    off<K extends keyof SyncEngineEventMap>(tipo: K, handler: (ev: SyncEngineEventMap[K]) => void): void;
+    private emit;
+}
+//# sourceMappingURL=engine.d.ts.map