@swal/edge-mesh 0.0.0-stage → 0.1.1

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

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

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

package/dist/sync/engine.js

@@ -0,0 +1,315 @@
+// ─── CONSTANTS ─────────────────────────────────────────────────────────────
+/**
+ * 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 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 const MAX_ENVELOPE_BYTES = 262_144;
+const TIEMPO_ESPERA_SYNC_MS = 2_000;
+export class SyncEngine {
+    eventTarget;
+    docId;
+    opLog;
+    batchSize;
+    timeoutMs;
+    _direction;
+    maxBatchOperations;
+    maxEnvelopeBytes;
+    sincronizando = false;
+    clockLocal = 0;
+    clocksRemotos;
+    constructor(config) {
+        this.eventTarget = new EventTarget();
+        this.docId = config.docId;
+        this.opLog = config.opLog;
+        this.batchSize = config.batchSize ?? MAX_BATCH_SIZE;
+        this.timeoutMs = config.timeoutMs ?? TIEMPO_ESPERA_SYNC_MS;
+        this._direction = config.direction ?? "bidireccional";
+        this.maxBatchOperations = config.maxBatchOperations ?? MAX_BATCH_SIZE;
+        this.maxEnvelopeBytes = config.maxEnvelopeBytes ?? MAX_ENVELOPE_BYTES;
+        this.clocksRemotos = new Map();
+    }
+    // ─── SYNC ────────────────────────────────────────────────────────────
+    async sincronizar(peerId, enviar, recibir) {
+        if (this.sincronizando) {
+            throw new Error("Sync en progreso para este documento");
+        }
+        this.sincronizando = true;
+        const inicio = Date.now();
+        // Declarado fuera del `try` para que la ruta de error pueda informarlo: si
+        // el motor falla DESPUES de rechazar un lote sobredimensionado, ese rechazo
+        // ya ocurrio y no debe desaparecer del informe.
+        let operacionesRechazadas = 0;
+        this.emit("syncIniciado", {
+            docId: this.docId,
+            peerId,
+            direction: this._direction,
+        });
+        try {
+            let operacionesEnviadas = 0;
+            let operacionesRecibidas = 0;
+            let conflictos = 0;
+            // Fase 1: Enviar nuestras operaciones
+            if (this._direction === "bidireccional" ||
+                this._direction === "saliente") {
+                const clockRemoto = this.clocksRemotos.get(peerId) ?? 0;
+                const pendientes = await this.opLog.obtenerDesde(clockRemoto);
+                const batches = [];
+                for (let i = 0; i < pendientes.length; i += this.batchSize) {
+                    batches.push(pendientes.slice(i, i + this.batchSize));
+                }
+                for (const batch of batches) {
+                    await enviar(batch);
+                    operacionesEnviadas += batch.length;
+                }
+            }
+            // Fase 2: Recibir operaciones remotas
+            if (this._direction === "bidireccional" ||
+                this._direction === "entrante") {
+                const operacionesRemotas = await recibir();
+                // Limites de recurso. Corren ANTES de cualquier otra cosa para que
+                // el tope acote el trabajo que un par no autenticado puede
+                // obligarnos a hacer, no solo el log.
+                const { lote, rechazadas: rechazadasPorLimite } = this.aplicarLimitesDeRecurso(peerId, operacionesRemotas);
+                operacionesRechazadas += rechazadasPorLimite;
+                const validadas = lote.filter(esOperacionValida);
+                for (const opRaw of validadas) {
+                    const op = opRaw;
+                    const clockLocal = this.opLog.obtenerUltimaSecuencia();
+                    if (op.secuencia <= clockLocal) {
+                        conflictos++;
+                        this.emit("conflictoDetectado", {
+                            docId: this.docId,
+                            operacionLocal: op,
+                            operacionRemota: op,
+                        });
+                    }
+                }
+                const aplicadas = await this.opLog.aplicarOperaciones(validadas);
+                operacionesRecibidas += aplicadas;
+                // Actualizar clock del peer
+                if (validadas.length > 0) {
+                    const ultimaOp = validadas[validadas.length - 1];
+                    this.clocksRemotos.set(peerId, ultimaOp.secuencia);
+                }
+            }
+            const duracionMs = Date.now() - inicio;
+            this.sincronizando = false;
+            const resultado = {
+                docId: this.docId,
+                operacionesEnviadas,
+                operacionesRecibidas,
+                conflictos,
+                operacionesRechazadas,
+                duracionMs,
+                exito: true,
+            };
+            this.emit("syncCompletado", { resultado, peerId });
+            return resultado;
+        }
+        catch (error) {
+            this.sincronizando = false;
+            const mensaje = error instanceof Error ? error.message : "Error de sincronizacion";
+            this.emit("syncError", {
+                docId: this.docId,
+                peerId,
+                error: mensaje,
+            });
+            return {
+                docId: this.docId,
+                operacionesEnviadas: 0,
+                operacionesRecibidas: 0,
+                conflictos: 0,
+                operacionesRechazadas,
+                duracionMs: Date.now() - inicio,
+                exito: false,
+            };
+        }
+    }
+    // ─── LÍMITES DE RECURSO ──────────────────────────────────────────────
+    /**
+     * 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.
+     */
+    aplicarLimitesDeRecurso(peerId, operaciones) {
+        // Tope 1 — cantidad de operaciones por lote. Se comprueba PRIMERO, sobre el
+        // solo `length`, asi que un lote sobredimensionado cuesta O(1) en vez de O(n)
+        // serializaciones. Medir 500k sobres que vamos a tirar es exactamente el
+        // trabajo que este tope existe para impedir, y emitiria ademas 500k eventos
+        // de rechazo. Nada sobrevive a un rechazo de lote entero, asi que el conteo
+        // informado es la longitud entrante en cualquier caso.
+        if (operaciones.length > this.maxBatchOperations) {
+            this.emit("loteRechazado", {
+                docId: this.docId,
+                peerId,
+                lotesOperaciones: operaciones.length,
+                maximoPermitido: this.maxBatchOperations,
+            });
+            return { lote: [], rechazadas: operaciones.length };
+        }
+        // Tope 2 — tamano serializado por sobre.
+        const lote = [];
+        let rechazadas = 0;
+        for (const op of operaciones) {
+            const bytes = tamanoSerializado(op);
+            if (bytes > this.maxEnvelopeBytes) {
+                rechazadas++;
+                this.emit("sobreRechazadoPorTamano", {
+                    docId: this.docId,
+                    peerId,
+                    secuencia: leerSecuencia(op),
+                    bytes,
+                    maximoPermitido: this.maxEnvelopeBytes,
+                });
+                continue;
+            }
+            lote.push(op);
+        }
+        return { lote, rechazadas };
+    }
+    // ─── CLOCK ───────────────────────────────────────────────────────────
+    actualizarClockLocal(clock) {
+        this.clockLocal = Math.max(this.clockLocal, clock);
+    }
+    actualizarClockRemoto(peerId, clock) {
+        this.clocksRemotos.set(peerId, clock);
+    }
+    obtenerClockLocal() {
+        return this.clockLocal;
+    }
+    obtenerClockRemoto(peerId) {
+        return this.clocksRemotos.get(peerId) ?? 0;
+    }
+    // ─── ESTADO ──────────────────────────────────────────────────────────
+    estaSincronizando() {
+        return this.sincronizando;
+    }
+    // ─── EVENTOS ─────────────────────────────────────────────────────────
+    on(tipo, handler) {
+        this.eventTarget.addEventListener(tipo, handler);
+    }
+    off(tipo, handler) {
+        this.eventTarget.removeEventListener(tipo, handler);
+    }
+    emit(tipo, detalle) {
+        const evento = new CustomEvent(tipo, { detail: detalle });
+        this.eventTarget.dispatchEvent(evento);
+    }
+}
+// ─── TYPE GUARD ────────────────────────────────────────────────────────────
+function esOperacionValida(valor) {
+    if (typeof valor !== "object" || valor === null)
+        return false;
+    const op = valor;
+    return (typeof op.id === "string" &&
+        typeof op.tipo === "string" &&
+        typeof op.secuencia === "number" &&
+        typeof op.timestamp === "number" &&
+        typeof op.autor === "string");
+}
+// ─── MEDICIÓN DE TAMAÑO ─────────────────────────────────────────────
+/**
+ * Tamano en bytes serializados de un sobre entrante, usado por el tope por
+ * sobre.
+ *
+ * Un par hostil controla el payload, asi que esto nunca debe lanzar:
+ * `JSON.stringify` lanza sobre estructuras ciclicas y devuelve `undefined` en
+ * silencio para valores que no puede codificar (BigInt tambien lanza). Ambos
+ * casos significan "no es un sobre bien formado del que podemos hablar", asi que
+ * reportamos `Infinity` y dejamos que el llamador lo rechace. Un payload no
+ * serializable es exactamente el payload que no queremos meter en el CRDT.
+ */
+function tamanoSerializado(valor) {
+    try {
+        const json = JSON.stringify(valor);
+        if (typeof json !== "string")
+            return Number.POSITIVE_INFINITY;
+        return byteLengthUtf8(json);
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+/**
+ * Longitud en bytes UTF-8 sin asignar un Buffer por cada sobre: dos bytes por
+ * unidad de codigo es el coste exacto para ASCII y Latin-1, y para cualquier cosa
+ * por encima de U+07FF solo sobrecuenta si hay caracteres astrales. Sobrecontar es
+ * la direccion segura para un limite de tamano, y el tope de 256 KiB deja varios
+ * ordenes de magnitud de margen para sobres reales, asi que la aproximacion nunca
+ * rechaza uno legitimo.
+ */
+function byteLengthUtf8(json) {
+    let bytes = 0;
+    for (let i = 0; i < json.length; i++) {
+        const code = json.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff)
+            bytes += 4; // par suplente
+        else
+            bytes += 3;
+    }
+    return bytes;
+}
+/** Lee `secuencia` solo para telemetria de rechazo; nunca para decisiones de confianza. */
+function leerSecuencia(valor) {
+    if (typeof valor !== "object" || valor === null)
+        return 0;
+    const secuencia = valor.secuencia;
+    return typeof secuencia === "number" ? secuencia : 0;
+}
+//# sourceMappingURL=engine.js.map

package/dist/sync/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../src/sync/engine.ts"],"names":[],"mappings":"AAGA,8EAA8E;AAE9E;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,GAAY,CAAC;AAE3C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAgB,CAAC;AAEnD,MAAM,qBAAqB,GAAG,KAAc,CAAC;AAuF7C,MAAM,OAAO,UAAU;IACb,WAAW,CAAc;IACzB,KAAK,CAAS;IACN,KAAK,CAAQ;IACb,SAAS,CAAS;IAClB,SAAS,CAAS;IAClB,UAAU,CAAgB;IAC1B,kBAAkB,CAAS;IAC3B,gBAAgB,CAAS;IAClC,aAAa,GAAY,KAAK,CAAC;IAC/B,UAAU,GAAW,CAAC,CAAC;IACd,aAAa,CAAsB;IAEpD,YAAY,MAAwB;QACnC,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,cAAc,CAAC;QACpD,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,qBAAqB,CAAC;QAC3D,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,SAAS,IAAI,eAAe,CAAC;QACtD,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,IAAI,cAAc,CAAC;QACtE,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,IAAI,kBAAkB,CAAC;QACtE,IAAI,CAAC,aAAa,GAAG,IAAI,GAAG,EAAE,CAAC;IAChC,CAAC;IAED,wEAAwE;IAExE,KAAK,CAAC,WAAW,CAChB,MAAc,EACd,MAAkD,EAClD,OAA0C;QAE1C,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC1B,2EAA2E;QAC3E,4EAA4E;QAC5E,gDAAgD;QAChD,IAAI,qBAAqB,GAAG,CAAC,CAAC;QAE9B,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;YACzB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM;YACN,SAAS,EAAE,IAAI,CAAC,UAAU;SAC1B,CAAC,CAAC;QAEH,IAAI,CAAC;YACJ,IAAI,mBAAmB,GAAG,CAAC,CAAC;YAC5B,IAAI,oBAAoB,GAAG,CAAC,CAAC;YAC7B,IAAI,UAAU,GAAG,CAAC,CAAC;YAEnB,sCAAsC;YACtC,IACC,IAAI,CAAC,UAAU,KAAK,eAAe;gBACnC,IAAI,CAAC,UAAU,KAAK,UAAU,EAC7B,CAAC;gBACF,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBACxD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;gBAE9D,MAAM,OAAO,GAA2B,EAAE,CAAC;gBAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBAC5D,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gBACvD,CAAC;gBAED,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;oBAC7B,MAAM,MAAM,CAAC,KAAK,CAAC,CAAC;oBACpB,mBAAmB,IAAI,KAAK,CAAC,MAAM,CAAC;gBACrC,CAAC;YACF,CAAC;YAED,sCAAsC;YACtC,IACC,IAAI,CAAC,UAAU,KAAK,eAAe;gBACnC,IAAI,CAAC,UAAU,KAAK,UAAU,EAC7B,CAAC;gBACF,MAAM,kBAAkB,GAAG,MAAM,OAAO,EAAE,CAAC;gBAE3C,mEAAmE;gBACnE,2DAA2D;gBAC3D,sCAAsC;gBACtC,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,mBAAmB,EAAE,GAC9C,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;gBAC1D,qBAAqB,IAAI,mBAAmB,CAAC;gBAE7C,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;gBAEjD,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;oBAC/B,MAAM,EAAE,GAAG,KAA0C,CAAC;oBACtD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,CAAC;oBAEvD,IAAI,EAAE,CAAC,SAAS,IAAI,UAAU,EAAE,CAAC;wBAChC,UAAU,EAAE,CAAC;wBACb,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE;4BAC/B,KAAK,EAAE,IAAI,CAAC,KAAK;4BACjB,cAAc,EAAE,EAAE;4BAClB,eAAe,EAAE,EAAE;yBACnB,CAAC,CAAC;oBACJ,CAAC;gBACF,CAAC;gBAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,kBAAkB,CACpD,SAAkB,CAClB,CAAC;gBACF,oBAAoB,IAAI,SAAS,CAAC;gBAElC,4BAA4B;gBAC5B,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC1B,MAAM,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAE9C,CAAC;oBACF,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;gBACpD,CAAC;YACF,CAAC;YAED,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC;YACvC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAE3B,MAAM,SAAS,GAAe;gBAC7B,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,mBAAmB;gBACnB,oBAAoB;gBACpB,UAAU;gBACV,qBAAqB;gBACrB,UAAU;gBACV,KAAK,EAAE,IAAI;aACX,CAAC;YAEF,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;YACnD,OAAO,SAAS,CAAC;QAClB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YAChB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC3B,MAAM,OAAO,GACZ,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,yBAAyB,CAAC;YAEpE,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gBACtB,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,MAAM;gBACN,KAAK,EAAE,OAAO;aACd,CAAC,CAAC;YAEH,OAAO;gBACN,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,mBAAmB,EAAE,CAAC;gBACtB,oBAAoB,EAAE,CAAC;gBACvB,UAAU,EAAE,CAAC;gBACb,qBAAqB;gBACrB,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM;gBAC/B,KAAK,EAAE,KAAK;aACZ,CAAC;QACH,CAAC;IACF,CAAC;IAED,wEAAwE;IAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACK,uBAAuB,CAC9B,MAAc,EACd,WAA+B;QAE/B,4EAA4E;QAC5E,8EAA8E;QAC9E,yEAAyE;QACzE,4EAA4E;QAC5E,4EAA4E;QAC5E,uDAAuD;QACvD,IAAI,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAClD,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;gBAC1B,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,MAAM;gBACN,gBAAgB,EAAE,WAAW,CAAC,MAAM;gBACpC,eAAe,EAAE,IAAI,CAAC,kBAAkB;aACxC,CAAC,CAAC;YACH,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,CAAC;QACrD,CAAC;QAED,yCAAyC;QACzC,MAAM,IAAI,GAAc,EAAE,CAAC;QAC3B,IAAI,UAAU,GAAG,CAAC,CAAC;QAEnB,KAAK,MAAM,EAAE,IAAI,WAAW,EAAE,CAAC;YAC9B,MAAM,KAAK,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC;YACpC,IAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACnC,UAAU,EAAE,CAAC;gBACb,IAAI,CAAC,IAAI,CAAC,yBAAyB,EAAE;oBACpC,KAAK,EAAE,IAAI,CAAC,KAAK;oBACjB,MAAM;oBACN,SAAS,EAAE,aAAa,CAAC,EAAE,CAAC;oBAC5B,KAAK;oBACL,eAAe,EAAE,IAAI,CAAC,gBAAgB;iBACtC,CAAC,CAAC;gBACH,SAAS;YACV,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACf,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAC7B,CAAC;IACD,wEAAwE;IAExE,oBAAoB,CAAC,KAAa;QACjC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAED,qBAAqB,CAAC,MAAc,EAAE,KAAa;QAClD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,iBAAiB;QAChB,OAAO,IAAI,CAAC,UAAU,CAAC;IACxB,CAAC;IAED,kBAAkB,CAAC,MAAc;QAChC,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,wEAAwE;IAExE,iBAAiB;QAChB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;IAED,wEAAwE;IAExE,EAAE,CACD,IAAO,EACP,OAA4C;QAE5C,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAc,EAAE,OAAwB,CAAC,CAAC;IAC7E,CAAC;IAED,GAAG,CACF,IAAO,EACP,OAA4C;QAE5C,IAAI,CAAC,WAAW,CAAC,mBAAmB,CACnC,IAAc,EACd,OAAwB,CACxB,CAAC;IACH,CAAC;IAEO,IAAI,CACX,IAAO,EACP,OAAwC;QAExC,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,IAAc,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;CACD;AAED,8EAA8E;AAE9E,SAAS,iBAAiB,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,EAAE,GAAG,KAAgC,CAAC;IAC5C,OAAO,CACN,OAAO,EAAE,CAAC,EAAE,KAAK,QAAQ;QACzB,OAAO,EAAE,CAAC,IAAI,KAAK,QAAQ;QAC3B,OAAO,EAAE,CAAC,SAAS,KAAK,QAAQ;QAChC,OAAO,EAAE,CAAC,SAAS,KAAK,QAAQ;QAChC,OAAO,EAAE,CAAC,KAAK,KAAK,QAAQ,CAC5B,CAAC;AACH,CAAC;AAED,uEAAuE;AAEvE;;;;;;;;;;GAUG;AACH,SAAS,iBAAiB,CAAC,KAAc;IACxC,IAAI,CAAC;QACJ,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,MAAM,CAAC,iBAAiB,CAAC;QAC9D,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,MAAM,CAAC,iBAAiB,CAAC;IACjC,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,cAAc,CAAC,IAAY;IACnC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,IAAI,GAAG,IAAI;YAAE,KAAK,IAAI,CAAC,CAAC;aACvB,IAAI,IAAI,GAAG,KAAK;YAAE,KAAK,IAAI,CAAC,CAAC;aAC7B,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM;YACxC,KAAK,IAAI,CAAC,CAAC,CAAC,eAAe;;YACvB,KAAK,IAAI,CAAC,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED,2FAA2F;AAC3F,SAAS,aAAa,CAAC,KAAc;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,CAAC,CAAC;IAC1D,MAAM,SAAS,GAAI,KAAiC,CAAC,SAAS,CAAC;IAC/D,OAAO,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AACtD,CAAC"}

package/dist/sync/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ChunkSyncManager.js";
+export * from "./engine.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/sync/index.js

@@ -0,0 +1,3 @@
+export * from "./ChunkSyncManager.js";
+export * from "./engine.js";
+//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/transport/TorTransportAdapter.d.ts

@@ -0,0 +1,70 @@
+import type { NodoId, TipoTransporte } from "../types/index.js";
+import type { ITransport, TransportEventMap } from "./types.js";
+export interface TorTransportAdapterOptions {
+    /** SOCKS/HTTP Tor proxy URL (e.g., "socks5://127.0.0.1:9050") */
+    readonly proxyUrl?: string;
+    /** Tor Onion hidden service address for this node (e.g., "abcdef1234567890.onion") */
+    readonly onionAddress?: string;
+    /** SOCKS proxy port (default: 9050) */
+    readonly socksPort?: number;
+    /** Control port for Tor process management (default: 9051) */
+    readonly controlPort?: number;
+    /** Fallback transport if direct Tor proxy tunnel fails */
+    readonly fallbackTransport?: ITransport;
+    /** Custom tunnel handler function for proxying data over SOCKS/Tor socket */
+    readonly tunnelHandler?: (data: unknown, targetOnion?: string) => Promise<unknown>;
+    /** Automatically connect proxy tunnel upon creation (default: false) */
+    readonly autoConnect?: boolean;
+}
+/**
+ * TorTransportAdapter provides hidden service proxy tunnel fallback for NAT traversal
+ * when direct WebRTC or TCP connections fail behind severe CGNAT.
+ */
+export declare class TorTransportAdapter implements ITransport {
+    readonly tipo: TipoTransporte;
+    readonly eventTarget: EventTarget;
+    readonly nodoId: NodoId;
+    private readonly options;
+    private readonly deduplicator;
+    private readonly onionPeerMap;
+    private readonly activeConnections;
+    private onionAddress;
+    private conectado;
+    private tunnelActive;
+    constructor(nodoId: NodoId, options?: TorTransportAdapterOptions);
+    on<K extends keyof TransportEventMap>(tipo: K, handler: (ev: TransportEventMap[K]) => void): void;
+    off<K extends keyof TransportEventMap>(tipo: K, handler: (ev: TransportEventMap[K]) => void): void;
+    private emit;
+    /**
+     * Establish Tor onion hidden service proxy tunnel.
+     */
+    conectar(): Promise<void>;
+    /**
+     * Register remote peer's onion hidden service address for proxy routing.
+     */
+    registerOnionPeer(peerId: string, onionAddress: string): void;
+    /**
+     * Get node's local onion hidden service address.
+     */
+    getOnionAddress(): string;
+    /**
+     * Returns true if the proxy tunnel is established and active.
+     */
+    isTunnelActive(): boolean;
+    /**
+     * Send envelope or payload to a remote node via Tor hidden service proxy tunnel.
+     */
+    enviar(destino: NodoId, payload: unknown, tipoMensaje?: string): Promise<void>;
+    /**
+     * Broadcast envelope or payload across all connected onion hidden service peers.
+     */
+    transmitir(payload: unknown, tipoMensaje?: string): Promise<void>;
+    /**
+     * Helper method to process incoming proxy tunnel payloads into the adapter.
+     */
+    receivePayload(datos: unknown, from?: NodoId): void;
+    estaConectado(): boolean;
+    obtenerConexiones(): readonly string[];
+    cerrar(): Promise<void>;
+}
+//# sourceMappingURL=TorTransportAdapter.d.ts.map

package/dist/transport/TorTransportAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TorTransportAdapter.d.ts","sourceRoot":"","sources":["../../src/transport/TorTransportAdapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEX,MAAM,EAEN,cAAc,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEhE,MAAM,WAAW,0BAA0B;IAC1C,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sFAAsF;IACtF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,uCAAuC;IACvC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,UAAU,CAAC;IACxC,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,CAAC,EAAE,CACxB,IAAI,EAAE,OAAO,EACb,WAAW,CAAC,EAAE,MAAM,KAChB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,wEAAwE;IACxE,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,UAAU;IACrD,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAuB;IACpD,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAc;IAChD,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,YAAY,CAAkB;IAEtC,YAAY,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,0BAA+B,EAiBnE;IAED,EAAE,CAAC,CAAC,SAAS,MAAM,iBAAiB,EACnC,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,IAAI,GACzC,IAAI,CAEN;IAED,GAAG,CAAC,CAAC,SAAS,MAAM,iBAAiB,EACpC,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,CAAC,EAAE,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAAK,IAAI,GACzC,IAAI,CAKN;IAED,OAAO,CAAC,IAAI;IASZ;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CA2B9B;IAED;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAG5D;IAED;;OAEG;IACH,eAAe,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,cAAc,IAAI,OAAO,CAExB;IAED;;OAEG;IACG,MAAM,CACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,WAAW,GAAE,MAA0B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;IAED;;OAEG;IACG,UAAU,CACf,OAAO,EAAE,OAAO,EAChB,WAAW,GAAE,MAA0B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiBf;IAED;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAWlD;IAED,aAAa,IAAI,OAAO,CAEvB;IAED,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErC;IAEK,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAe5B;CACD"}