@affectively/dash 5.4.1 → 5.4.5

package/dist/sync/AeonDurableSync.js

@@ -0,0 +1,1984 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../node_modules/.bun/eventemitter3@5.0.4/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+
+// ../../node_modules/.bun/eventemitter3@5.0.4/node_modules/eventemitter3/index.mjs
+var import__ = __toESM(require_eventemitter3(), 1);
+
+// ../aeon/dist/offline/index.js
+var consoleLogger = {
+  debug: (...args) => {
+    console.debug("[AEON:DEBUG]", ...args);
+  },
+  info: (...args) => {
+    console.info("[AEON:INFO]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[AEON:WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[AEON:ERROR]", ...args);
+  }
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+var logger = getLogger();
+var OfflineOperationQueue = class _OfflineOperationQueue extends import__.default {
+  static DEFAULT_PERSIST_KEY = "aeon:offline-queue:v1";
+  queue = /* @__PURE__ */ new Map;
+  syncingIds = /* @__PURE__ */ new Set;
+  maxQueueSize = 1000;
+  defaultMaxRetries = 3;
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(maxQueueSizeOrOptions = 1000, defaultMaxRetries = 3) {
+    super();
+    if (typeof maxQueueSizeOrOptions === "number") {
+      this.maxQueueSize = maxQueueSizeOrOptions;
+      this.defaultMaxRetries = defaultMaxRetries;
+    } else {
+      this.maxQueueSize = maxQueueSizeOrOptions.maxQueueSize ?? 1000;
+      this.defaultMaxRetries = maxQueueSizeOrOptions.defaultMaxRetries ?? 3;
+      if (maxQueueSizeOrOptions.persistence) {
+        this.persistence = {
+          ...maxQueueSizeOrOptions.persistence,
+          key: maxQueueSizeOrOptions.persistence.key ?? _OfflineOperationQueue.DEFAULT_PERSIST_KEY,
+          autoPersist: maxQueueSizeOrOptions.persistence.autoPersist ?? true,
+          autoLoad: maxQueueSizeOrOptions.persistence.autoLoad ?? false,
+          persistDebounceMs: maxQueueSizeOrOptions.persistence.persistDebounceMs ?? 25
+        };
+        if (this.persistence.autoLoad) {
+          this.loadFromPersistence().catch((error) => {
+            logger.error("[OfflineOperationQueue] Failed to load persistence", {
+              key: this.persistence?.key,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          });
+        }
+      }
+    }
+    logger.debug("[OfflineOperationQueue] Initialized", {
+      maxQueueSize: this.maxQueueSize,
+      defaultMaxRetries: this.defaultMaxRetries,
+      persistenceEnabled: this.persistence !== null
+    });
+  }
+  enqueue(type, data, sessionId, priority = "normal", maxRetries) {
+    if (this.queue.size >= this.maxQueueSize) {
+      const oldest = this.findOldestLowPriority();
+      if (oldest) {
+        this.queue.delete(oldest.id);
+        logger.warn("[OfflineOperationQueue] Queue full, removed oldest", {
+          removedId: oldest.id
+        });
+      }
+    }
+    const operation = {
+      id: `op-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      type,
+      data,
+      sessionId,
+      priority,
+      createdAt: Date.now(),
+      retryCount: 0,
+      maxRetries: maxRetries ?? this.defaultMaxRetries,
+      status: "pending"
+    };
+    this.queue.set(operation.id, operation);
+    this.emit("operation-added", operation);
+    this.schedulePersist();
+    logger.debug("[OfflineOperationQueue] Operation enqueued", {
+      id: operation.id,
+      type,
+      priority,
+      queueSize: this.queue.size
+    });
+    return operation;
+  }
+  getNextBatch(batchSize = 10) {
+    const pending = Array.from(this.queue.values()).filter((op) => op.status === "pending" && !this.syncingIds.has(op.id)).sort((a, b) => {
+      const priorityOrder = { high: 0, normal: 1, low: 2 };
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (priorityDiff !== 0)
+        return priorityDiff;
+      return a.createdAt - b.createdAt;
+    });
+    return pending.slice(0, batchSize);
+  }
+  markSyncing(operationIds) {
+    let changed = false;
+    for (const id of operationIds) {
+      const op = this.queue.get(id);
+      if (op) {
+        op.status = "syncing";
+        this.syncingIds.add(id);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.schedulePersist();
+    }
+  }
+  markSynced(operationId) {
+    const op = this.queue.get(operationId);
+    if (op) {
+      op.status = "synced";
+      this.syncingIds.delete(operationId);
+      this.emit("operation-synced", op);
+      this.schedulePersist();
+      setTimeout(() => {
+        this.queue.delete(operationId);
+        this.schedulePersist();
+        if (this.getPendingCount() === 0) {
+          this.emit("queue-empty");
+        }
+      }, 1000);
+    }
+  }
+  markFailed(operationId, error) {
+    const op = this.queue.get(operationId);
+    if (op) {
+      op.retryCount++;
+      op.lastError = error.message;
+      this.syncingIds.delete(operationId);
+      if (op.retryCount >= op.maxRetries) {
+        op.status = "failed";
+        this.emit("operation-failed", op, error);
+        logger.error("[OfflineOperationQueue] Operation permanently failed", {
+          id: operationId,
+          retries: op.retryCount,
+          error: error.message
+        });
+      } else {
+        op.status = "pending";
+        logger.warn("[OfflineOperationQueue] Operation failed, will retry", {
+          id: operationId,
+          retryCount: op.retryCount,
+          maxRetries: op.maxRetries
+        });
+      }
+      this.schedulePersist();
+    }
+  }
+  getOperation(operationId) {
+    return this.queue.get(operationId);
+  }
+  getPendingOperations() {
+    return Array.from(this.queue.values()).filter((op) => op.status === "pending");
+  }
+  getPendingCount() {
+    return Array.from(this.queue.values()).filter((op) => op.status === "pending").length;
+  }
+  getStats() {
+    const operations = Array.from(this.queue.values());
+    const pending = operations.filter((op) => op.status === "pending").length;
+    const syncing = operations.filter((op) => op.status === "syncing").length;
+    const failed = operations.filter((op) => op.status === "failed").length;
+    const synced = operations.filter((op) => op.status === "synced").length;
+    const pendingOps = operations.filter((op) => op.status === "pending");
+    const oldestPendingMs = pendingOps.length > 0 ? Date.now() - Math.min(...pendingOps.map((op) => op.createdAt)) : 0;
+    const averageRetries = operations.length > 0 ? operations.reduce((sum, op) => sum + op.retryCount, 0) / operations.length : 0;
+    return {
+      pending,
+      syncing,
+      failed,
+      synced,
+      totalOperations: operations.length,
+      oldestPendingMs,
+      averageRetries
+    };
+  }
+  clear() {
+    this.queue.clear();
+    this.syncingIds.clear();
+    this.schedulePersist();
+    logger.debug("[OfflineOperationQueue] Queue cleared");
+  }
+  clearFailed() {
+    let changed = false;
+    for (const [id, op] of this.queue.entries()) {
+      if (op.status === "failed") {
+        this.queue.delete(id);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.schedulePersist();
+    }
+  }
+  retryFailed() {
+    let changed = false;
+    for (const op of this.queue.values()) {
+      if (op.status === "failed") {
+        op.status = "pending";
+        op.retryCount = 0;
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.schedulePersist();
+    }
+  }
+  findOldestLowPriority() {
+    const lowPriority = Array.from(this.queue.values()).filter((op) => op.priority === "low" && op.status === "pending").sort((a, b) => a.createdAt - b.createdAt);
+    return lowPriority[0] ?? null;
+  }
+  export() {
+    return Array.from(this.queue.values());
+  }
+  import(operations) {
+    this.queue.clear();
+    this.syncingIds.clear();
+    for (const op of operations) {
+      if (this.isValidOfflineOperation(op)) {
+        this.queue.set(op.id, {
+          ...op,
+          status: op.status === "syncing" ? "pending" : op.status
+        });
+      }
+    }
+    this.schedulePersist();
+    logger.debug("[OfflineOperationQueue] Imported operations", {
+      count: this.queue.size
+    });
+  }
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const envelope = {
+      version: 1,
+      updatedAt: Date.now(),
+      data: this.export()
+    };
+    const serialize = this.persistence.serializer ?? ((value) => JSON.stringify(value));
+    const raw = serialize(envelope);
+    await this.persistence.adapter.setItem(this.persistence.key, raw);
+  }
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return 0;
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return 0;
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !Array.isArray(envelope.data)) {
+      throw new Error("Invalid offline queue persistence payload");
+    }
+    this.queue.clear();
+    this.syncingIds.clear();
+    let imported = 0;
+    for (const operation of envelope.data) {
+      if (this.isValidOfflineOperation(operation)) {
+        this.queue.set(operation.id, {
+          ...operation,
+          status: operation.status === "syncing" ? "pending" : operation.status
+        });
+        imported++;
+      }
+    }
+    logger.debug("[OfflineOperationQueue] Loaded from persistence", {
+      key: this.persistence.key,
+      imported
+    });
+    return imported;
+  }
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    await this.persistence.adapter.removeItem(this.persistence.key);
+  }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      this.persistSafely();
+    }, this.persistence.persistDebounceMs ?? 25);
+  }
+  async persistSafely() {
+    if (!this.persistence) {
+      return;
+    }
+    if (this.persistInFlight) {
+      this.persistPending = true;
+      return;
+    }
+    this.persistInFlight = true;
+    try {
+      await this.saveToPersistence();
+    } catch (error) {
+      logger.error("[OfflineOperationQueue] Persistence write failed", {
+        key: this.persistence.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.persistInFlight = false;
+      const shouldRunAgain = this.persistPending;
+      this.persistPending = false;
+      if (shouldRunAgain) {
+        this.persistSafely();
+      }
+    }
+  }
+  isValidOfflineOperation(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    const validType = candidate.type === "create" || candidate.type === "update" || candidate.type === "delete" || candidate.type === "sync" || candidate.type === "batch";
+    const validPriority = candidate.priority === "high" || candidate.priority === "normal" || candidate.priority === "low";
+    const validStatus = candidate.status === "pending" || candidate.status === "syncing" || candidate.status === "failed" || candidate.status === "synced";
+    return typeof candidate.id === "string" && validType && typeof candidate.data === "object" && candidate.data !== null && !Array.isArray(candidate.data) && typeof candidate.sessionId === "string" && validPriority && typeof candidate.createdAt === "number" && typeof candidate.retryCount === "number" && typeof candidate.maxRetries === "number" && validStatus;
+  }
+};
+
+// ../aeon/dist/distributed/index.js
+var consoleLogger2 = {
+  debug: (...args) => {
+    console.debug("[AEON:DEBUG]", ...args);
+  },
+  info: (...args) => {
+    console.info("[AEON:INFO]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[AEON:WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[AEON:ERROR]", ...args);
+  }
+};
+var currentLogger2 = consoleLogger2;
+function getLogger2() {
+  return currentLogger2;
+}
+var logger2 = {
+  debug: (...args) => getLogger2().debug(...args),
+  info: (...args) => getLogger2().info(...args),
+  warn: (...args) => getLogger2().warn(...args),
+  error: (...args) => getLogger2().error(...args)
+};
+var ReplicationManager = class _ReplicationManager {
+  static DEFAULT_PERSIST_KEY = "aeon:replication-state:v1";
+  replicas = /* @__PURE__ */ new Map;
+  policies = /* @__PURE__ */ new Map;
+  replicationEvents = [];
+  syncStatus = /* @__PURE__ */ new Map;
+  cryptoProvider = null;
+  replicasByDID = /* @__PURE__ */ new Map;
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(options) {
+    if (options?.persistence) {
+      this.persistence = {
+        ...options.persistence,
+        key: options.persistence.key ?? _ReplicationManager.DEFAULT_PERSIST_KEY,
+        autoPersist: options.persistence.autoPersist ?? true,
+        autoLoad: options.persistence.autoLoad ?? false,
+        persistDebounceMs: options.persistence.persistDebounceMs ?? 25
+      };
+    }
+    if (this.persistence?.autoLoad) {
+      this.loadFromPersistence().catch((error) => {
+        logger2.error("[ReplicationManager] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
+  configureCrypto(provider) {
+    this.cryptoProvider = provider;
+    logger2.debug("[ReplicationManager] Crypto configured", {
+      initialized: provider.isInitialized()
+    });
+  }
+  isCryptoEnabled() {
+    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
+  }
+  async registerAuthenticatedReplica(replica, encrypted = false) {
+    const authenticatedReplica = {
+      ...replica,
+      encrypted
+    };
+    this.replicas.set(replica.id, authenticatedReplica);
+    this.replicasByDID.set(replica.did, replica.id);
+    if (!this.syncStatus.has(replica.nodeId)) {
+      this.syncStatus.set(replica.nodeId, { synced: 0, failed: 0 });
+    }
+    if (this.cryptoProvider && replica.publicSigningKey) {
+      await this.cryptoProvider.registerRemoteNode({
+        id: replica.nodeId,
+        did: replica.did,
+        publicSigningKey: replica.publicSigningKey,
+        publicEncryptionKey: replica.publicEncryptionKey
+      });
+    }
+    const event = {
+      type: "replica-added",
+      replicaId: replica.id,
+      nodeId: replica.nodeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      details: { did: replica.did, encrypted, authenticated: true }
+    };
+    this.replicationEvents.push(event);
+    this.schedulePersist();
+    logger2.debug("[ReplicationManager] Authenticated replica registered", {
+      replicaId: replica.id,
+      did: replica.did,
+      encrypted
+    });
+    return authenticatedReplica;
+  }
+  getReplicaByDID(did) {
+    const replicaId = this.replicasByDID.get(did);
+    if (!replicaId)
+      return;
+    return this.replicas.get(replicaId);
+  }
+  getEncryptedReplicas() {
+    return Array.from(this.replicas.values()).filter((r) => r.encrypted);
+  }
+  async encryptForReplica(data, targetReplicaDID) {
+    if (!this.cryptoProvider || !this.cryptoProvider.isInitialized()) {
+      throw new Error("Crypto provider not initialized");
+    }
+    const dataBytes = new TextEncoder().encode(JSON.stringify(data));
+    const encrypted = await this.cryptoProvider.encrypt(dataBytes, targetReplicaDID);
+    const localDID = this.cryptoProvider.getLocalDID();
+    return {
+      ct: encrypted.ct,
+      iv: encrypted.iv,
+      tag: encrypted.tag,
+      epk: encrypted.epk,
+      senderDID: localDID || undefined,
+      targetDID: targetReplicaDID,
+      encryptedAt: encrypted.encryptedAt
+    };
+  }
+  async decryptReplicationData(encrypted) {
+    if (!this.cryptoProvider || !this.cryptoProvider.isInitialized()) {
+      throw new Error("Crypto provider not initialized");
+    }
+    const decrypted = await this.cryptoProvider.decrypt({
+      alg: "ECIES-P256",
+      ct: encrypted.ct,
+      iv: encrypted.iv,
+      tag: encrypted.tag,
+      epk: encrypted.epk
+    }, encrypted.senderDID);
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  }
+  createEncryptedPolicy(name, replicationFactor, consistencyLevel, encryptionMode, options) {
+    const policy = {
+      id: `policy-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name,
+      replicationFactor,
+      consistencyLevel,
+      syncInterval: options?.syncInterval || 1000,
+      maxReplicationLag: options?.maxReplicationLag || 1e4,
+      encryptionMode,
+      requiredCapabilities: options?.requiredCapabilities
+    };
+    this.policies.set(policy.id, policy);
+    logger2.debug("[ReplicationManager] Encrypted policy created", {
+      policyId: policy.id,
+      name,
+      replicationFactor,
+      encryptionMode
+    });
+    return policy;
+  }
+  async verifyReplicaCapabilities(replicaDID, token, policyId) {
+    if (!this.cryptoProvider) {
+      return { authorized: true };
+    }
+    const policy = policyId ? this.policies.get(policyId) : undefined;
+    const result = await this.cryptoProvider.verifyUCAN(token, {
+      requiredCapabilities: policy?.requiredCapabilities?.map((cap) => ({
+        can: cap,
+        with: "*"
+      }))
+    });
+    if (!result.authorized) {
+      logger2.warn("[ReplicationManager] Replica capability verification failed", {
+        replicaDID,
+        error: result.error
+      });
+    }
+    return result;
+  }
+  registerReplica(replica) {
+    this.replicas.set(replica.id, replica);
+    if (!this.syncStatus.has(replica.nodeId)) {
+      this.syncStatus.set(replica.nodeId, { synced: 0, failed: 0 });
+    }
+    const event = {
+      type: "replica-added",
+      replicaId: replica.id,
+      nodeId: replica.nodeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.replicationEvents.push(event);
+    this.schedulePersist();
+    logger2.debug("[ReplicationManager] Replica registered", {
+      replicaId: replica.id,
+      nodeId: replica.nodeId,
+      status: replica.status
+    });
+  }
+  removeReplica(replicaId) {
+    const replica = this.replicas.get(replicaId);
+    if (!replica) {
+      throw new Error(`Replica ${replicaId} not found`);
+    }
+    this.replicas.delete(replicaId);
+    const event = {
+      type: "replica-removed",
+      replicaId,
+      nodeId: replica.nodeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.replicationEvents.push(event);
+    this.schedulePersist();
+    logger2.debug("[ReplicationManager] Replica removed", { replicaId });
+  }
+  createPolicy(name, replicationFactor, consistencyLevel, syncInterval = 1000, maxReplicationLag = 1e4) {
+    const policy = {
+      id: `policy-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name,
+      replicationFactor,
+      consistencyLevel,
+      syncInterval,
+      maxReplicationLag
+    };
+    this.policies.set(policy.id, policy);
+    this.schedulePersist();
+    logger2.debug("[ReplicationManager] Policy created", {
+      policyId: policy.id,
+      name,
+      replicationFactor,
+      consistencyLevel
+    });
+    return policy;
+  }
+  updateReplicaStatus(replicaId, status, lagBytes = 0, lagMillis = 0) {
+    const replica = this.replicas.get(replicaId);
+    if (!replica) {
+      throw new Error(`Replica ${replicaId} not found`);
+    }
+    replica.status = status;
+    replica.lagBytes = lagBytes;
+    replica.lagMillis = lagMillis;
+    replica.lastSyncTime = (/* @__PURE__ */ new Date()).toISOString();
+    const event = {
+      type: status === "syncing" ? "replica-synced" : "sync-failed",
+      replicaId,
+      nodeId: replica.nodeId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      details: { status, lagBytes, lagMillis }
+    };
+    this.replicationEvents.push(event);
+    const syncStatus = this.syncStatus.get(replica.nodeId);
+    if (syncStatus) {
+      if (status === "syncing" || status === "secondary") {
+        syncStatus.synced++;
+      } else if (status === "failed") {
+        syncStatus.failed++;
+      }
+    }
+    logger2.debug("[ReplicationManager] Replica status updated", {
+      replicaId,
+      status,
+      lagBytes,
+      lagMillis
+    });
+    this.schedulePersist();
+  }
+  getReplicasForNode(nodeId) {
+    return Array.from(this.replicas.values()).filter((r) => r.nodeId === nodeId);
+  }
+  getHealthyReplicas() {
+    return Array.from(this.replicas.values()).filter((r) => r.status === "secondary" || r.status === "primary");
+  }
+  getSyncingReplicas() {
+    return Array.from(this.replicas.values()).filter((r) => r.status === "syncing");
+  }
+  getFailedReplicas() {
+    return Array.from(this.replicas.values()).filter((r) => r.status === "failed");
+  }
+  checkReplicationHealth(policyId) {
+    const policy = this.policies.get(policyId);
+    if (!policy) {
+      throw new Error(`Policy ${policyId} not found`);
+    }
+    const healthy = this.getHealthyReplicas();
+    const maxLag = Math.max(0, ...healthy.map((r) => r.lagMillis));
+    return {
+      healthy: healthy.length >= policy.replicationFactor && maxLag <= policy.maxReplicationLag,
+      replicasInPolicy: policy.replicationFactor,
+      healthyReplicas: healthy.length,
+      replicationLag: maxLag
+    };
+  }
+  getConsistencyLevel(policyId) {
+    const policy = this.policies.get(policyId);
+    if (!policy) {
+      return "eventual";
+    }
+    return policy.consistencyLevel;
+  }
+  getReplica(replicaId) {
+    return this.replicas.get(replicaId);
+  }
+  getAllReplicas() {
+    return Array.from(this.replicas.values());
+  }
+  getPolicy(policyId) {
+    return this.policies.get(policyId);
+  }
+  getAllPolicies() {
+    return Array.from(this.policies.values());
+  }
+  getStatistics() {
+    const healthy = this.getHealthyReplicas().length;
+    const syncing = this.getSyncingReplicas().length;
+    const failed = this.getFailedReplicas().length;
+    const total = this.replicas.size;
+    const replicationLags = Array.from(this.replicas.values()).map((r) => r.lagMillis);
+    const avgLag = replicationLags.length > 0 ? replicationLags.reduce((a, b) => a + b) / replicationLags.length : 0;
+    const maxLag = replicationLags.length > 0 ? Math.max(...replicationLags) : 0;
+    return {
+      totalReplicas: total,
+      healthyReplicas: healthy,
+      syncingReplicas: syncing,
+      failedReplicas: failed,
+      healthiness: total > 0 ? healthy / total * 100 : 0,
+      averageReplicationLagMs: avgLag,
+      maxReplicationLagMs: maxLag,
+      totalPolicies: this.policies.size
+    };
+  }
+  getReplicationEvents(limit) {
+    const events = [...this.replicationEvents];
+    if (limit) {
+      return events.slice(-limit);
+    }
+    return events;
+  }
+  getSyncStatus(nodeId) {
+    return this.syncStatus.get(nodeId) || { synced: 0, failed: 0 };
+  }
+  getReplicationLagDistribution() {
+    const distribution = {
+      "0-100ms": 0,
+      "100-500ms": 0,
+      "500-1000ms": 0,
+      "1000+ms": 0
+    };
+    for (const replica of this.replicas.values()) {
+      if (replica.lagMillis <= 100) {
+        distribution["0-100ms"]++;
+      } else if (replica.lagMillis <= 500) {
+        distribution["100-500ms"]++;
+      } else if (replica.lagMillis <= 1000) {
+        distribution["500-1000ms"]++;
+      } else {
+        distribution["1000+ms"]++;
+      }
+    }
+    return distribution;
+  }
+  canSatisfyConsistency(policyId, _requiredAcks) {
+    const policy = this.policies.get(policyId);
+    if (!policy) {
+      return false;
+    }
+    const healthyCount = this.getHealthyReplicas().length;
+    switch (policy.consistencyLevel) {
+      case "eventual":
+        return true;
+      case "read-after-write":
+        return healthyCount >= 1;
+      case "strong":
+        return healthyCount >= policy.replicationFactor;
+      default:
+        return false;
+    }
+  }
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const data = {
+      replicas: this.getAllReplicas(),
+      policies: this.getAllPolicies(),
+      syncStatus: Array.from(this.syncStatus.entries()).map(([nodeId, state]) => ({
+        nodeId,
+        synced: state.synced,
+        failed: state.failed
+      }))
+    };
+    const envelope = {
+      version: 1,
+      updatedAt: Date.now(),
+      data
+    };
+    const serialize = this.persistence.serializer ?? ((value) => JSON.stringify(value));
+    await this.persistence.adapter.setItem(this.persistence.key, serialize(envelope));
+  }
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return { replicas: 0, policies: 0, syncStatus: 0 };
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return { replicas: 0, policies: 0, syncStatus: 0 };
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !envelope.data) {
+      throw new Error("Invalid replication persistence payload");
+    }
+    if (!Array.isArray(envelope.data.replicas) || !Array.isArray(envelope.data.policies) || !Array.isArray(envelope.data.syncStatus)) {
+      throw new Error("Invalid replication persistence structure");
+    }
+    this.replicas.clear();
+    this.policies.clear();
+    this.syncStatus.clear();
+    this.replicasByDID.clear();
+    let importedReplicas = 0;
+    for (const replica of envelope.data.replicas) {
+      if (this.isValidReplica(replica)) {
+        this.replicas.set(replica.id, replica);
+        if (replica.did) {
+          this.replicasByDID.set(replica.did, replica.id);
+        }
+        importedReplicas++;
+      }
+    }
+    let importedPolicies = 0;
+    for (const policy of envelope.data.policies) {
+      if (this.isValidPolicy(policy)) {
+        this.policies.set(policy.id, policy);
+        importedPolicies++;
+      }
+    }
+    let importedSyncStatus = 0;
+    for (const status of envelope.data.syncStatus) {
+      if (typeof status.nodeId === "string" && typeof status.synced === "number" && typeof status.failed === "number") {
+        this.syncStatus.set(status.nodeId, {
+          synced: status.synced,
+          failed: status.failed
+        });
+        importedSyncStatus++;
+      }
+    }
+    logger2.debug("[ReplicationManager] Loaded from persistence", {
+      key: this.persistence.key,
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    });
+    return {
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    };
+  }
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    await this.persistence.adapter.removeItem(this.persistence.key);
+  }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      this.persistSafely();
+    }, this.persistence.persistDebounceMs ?? 25);
+  }
+  async persistSafely() {
+    if (!this.persistence) {
+      return;
+    }
+    if (this.persistInFlight) {
+      this.persistPending = true;
+      return;
+    }
+    this.persistInFlight = true;
+    try {
+      await this.saveToPersistence();
+    } catch (error) {
+      logger2.error("[ReplicationManager] Persistence write failed", {
+        key: this.persistence.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.persistInFlight = false;
+      const shouldRunAgain = this.persistPending;
+      this.persistPending = false;
+      if (shouldRunAgain) {
+        this.persistSafely();
+      }
+    }
+  }
+  isValidReplica(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    const validStatus = candidate.status === "primary" || candidate.status === "secondary" || candidate.status === "syncing" || candidate.status === "failed";
+    return typeof candidate.id === "string" && typeof candidate.nodeId === "string" && validStatus && typeof candidate.lastSyncTime === "string" && typeof candidate.lagBytes === "number" && typeof candidate.lagMillis === "number";
+  }
+  isValidPolicy(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    const validConsistency = candidate.consistencyLevel === "eventual" || candidate.consistencyLevel === "read-after-write" || candidate.consistencyLevel === "strong";
+    return typeof candidate.id === "string" && typeof candidate.name === "string" && typeof candidate.replicationFactor === "number" && validConsistency && typeof candidate.syncInterval === "number" && typeof candidate.maxReplicationLag === "number";
+  }
+  clear() {
+    this.replicas.clear();
+    this.policies.clear();
+    this.replicationEvents = [];
+    this.syncStatus.clear();
+    this.replicasByDID.clear();
+    this.cryptoProvider = null;
+    this.schedulePersist();
+  }
+  getCryptoProvider() {
+    return this.cryptoProvider;
+  }
+};
+var SyncProtocol = class _SyncProtocol {
+  static DEFAULT_PERSIST_KEY = "aeon:sync-protocol:v1";
+  version = "1.0.0";
+  messageQueue = [];
+  messageMap = /* @__PURE__ */ new Map;
+  handshakes = /* @__PURE__ */ new Map;
+  protocolErrors = [];
+  messageCounter = 0;
+  cryptoProvider = null;
+  cryptoConfig = null;
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(options) {
+    if (options?.persistence) {
+      this.persistence = {
+        ...options.persistence,
+        key: options.persistence.key ?? _SyncProtocol.DEFAULT_PERSIST_KEY,
+        autoPersist: options.persistence.autoPersist ?? true,
+        autoLoad: options.persistence.autoLoad ?? false,
+        persistDebounceMs: options.persistence.persistDebounceMs ?? 25
+      };
+    }
+    if (this.persistence?.autoLoad) {
+      this.loadFromPersistence().catch((error) => {
+        logger2.error("[SyncProtocol] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
+  configureCrypto(provider, config) {
+    this.cryptoProvider = provider;
+    this.cryptoConfig = {
+      encryptionMode: config?.encryptionMode ?? "none",
+      requireSignatures: config?.requireSignatures ?? false,
+      requireCapabilities: config?.requireCapabilities ?? false,
+      requiredCapabilities: config?.requiredCapabilities
+    };
+    logger2.debug("[SyncProtocol] Crypto configured", {
+      encryptionMode: this.cryptoConfig.encryptionMode,
+      requireSignatures: this.cryptoConfig.requireSignatures,
+      requireCapabilities: this.cryptoConfig.requireCapabilities
+    });
+  }
+  isCryptoEnabled() {
+    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
+  }
+  getCryptoConfig() {
+    return this.cryptoConfig ? { ...this.cryptoConfig } : null;
+  }
+  getVersion() {
+    return this.version;
+  }
+  async createAuthenticatedHandshake(capabilities, targetDID) {
+    if (!this.cryptoProvider || !this.cryptoProvider.isInitialized()) {
+      throw new Error("Crypto provider not initialized");
+    }
+    const localDID = this.cryptoProvider.getLocalDID();
+    if (!localDID) {
+      throw new Error("Local DID not available");
+    }
+    const publicInfo = await this.cryptoProvider.exportPublicIdentity();
+    if (!publicInfo) {
+      throw new Error("Cannot export public identity");
+    }
+    let ucan;
+    if (targetDID && this.cryptoConfig?.requireCapabilities) {
+      const caps = this.cryptoConfig.requiredCapabilities || [
+        { can: "aeon:sync:read", with: "*" },
+        { can: "aeon:sync:write", with: "*" }
+      ];
+      ucan = await this.cryptoProvider.createUCAN(targetDID, caps);
+    }
+    const handshakePayload = {
+      protocolVersion: this.version,
+      nodeId: localDID,
+      capabilities,
+      state: "initiating",
+      did: localDID,
+      publicSigningKey: publicInfo.publicSigningKey,
+      publicEncryptionKey: publicInfo.publicEncryptionKey,
+      ucan
+    };
+    const message = {
+      type: "handshake",
+      version: this.version,
+      sender: localDID,
+      receiver: targetDID || "",
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: handshakePayload
+    };
+    if (this.cryptoConfig?.requireSignatures) {
+      const signed = await this.cryptoProvider.signData(handshakePayload);
+      message.auth = {
+        senderDID: localDID,
+        receiverDID: targetDID,
+        signature: signed.signature
+      };
+    }
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Authenticated handshake created", {
+      messageId: message.messageId,
+      did: localDID,
+      capabilities: capabilities.length,
+      hasUCAN: !!ucan
+    });
+    return message;
+  }
+  async verifyAuthenticatedHandshake(message) {
+    if (message.type !== "handshake") {
+      return { valid: false, error: "Message is not a handshake" };
+    }
+    const handshake = message.payload;
+    if (!this.cryptoProvider || !this.cryptoConfig) {
+      this.handshakes.set(message.sender, handshake);
+      this.schedulePersist();
+      return { valid: true, handshake };
+    }
+    if (handshake.did && handshake.publicSigningKey) {
+      await this.cryptoProvider.registerRemoteNode({
+        id: handshake.nodeId,
+        did: handshake.did,
+        publicSigningKey: handshake.publicSigningKey,
+        publicEncryptionKey: handshake.publicEncryptionKey
+      });
+    }
+    if (this.cryptoConfig.requireSignatures && message.auth?.signature) {
+      const signed = {
+        payload: handshake,
+        signature: message.auth.signature,
+        signer: message.auth.senderDID || message.sender,
+        algorithm: "ES256",
+        signedAt: Date.now()
+      };
+      const isValid = await this.cryptoProvider.verifySignedData(signed);
+      if (!isValid) {
+        logger2.warn("[SyncProtocol] Handshake signature verification failed", {
+          messageId: message.messageId,
+          sender: message.sender
+        });
+        return { valid: false, error: "Invalid signature" };
+      }
+    }
+    if (this.cryptoConfig.requireCapabilities && handshake.ucan) {
+      const localDID = this.cryptoProvider.getLocalDID();
+      const result = await this.cryptoProvider.verifyUCAN(handshake.ucan, {
+        expectedAudience: localDID || undefined,
+        requiredCapabilities: this.cryptoConfig.requiredCapabilities
+      });
+      if (!result.authorized) {
+        logger2.warn("[SyncProtocol] Handshake UCAN verification failed", {
+          messageId: message.messageId,
+          error: result.error
+        });
+        return { valid: false, error: result.error || "Unauthorized" };
+      }
+    }
+    this.handshakes.set(message.sender, handshake);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Authenticated handshake verified", {
+      messageId: message.messageId,
+      did: handshake.did
+    });
+    return { valid: true, handshake };
+  }
+  async signMessage(message, payload, encrypt = false) {
+    if (!this.cryptoProvider || !this.cryptoProvider.isInitialized()) {
+      throw new Error("Crypto provider not initialized");
+    }
+    const localDID = this.cryptoProvider.getLocalDID();
+    const signed = await this.cryptoProvider.signData(payload);
+    message.auth = {
+      senderDID: localDID || undefined,
+      receiverDID: message.receiver || undefined,
+      signature: signed.signature,
+      encrypted: false
+    };
+    if (encrypt && message.receiver && this.cryptoConfig?.encryptionMode !== "none") {
+      const payloadBytes = new TextEncoder().encode(JSON.stringify(payload));
+      const encrypted = await this.cryptoProvider.encrypt(payloadBytes, message.receiver);
+      message.payload = encrypted;
+      message.auth.encrypted = true;
+      logger2.debug("[SyncProtocol] Message encrypted", {
+        messageId: message.messageId,
+        recipient: message.receiver
+      });
+    } else {
+      message.payload = payload;
+    }
+    return message;
+  }
+  async verifyMessage(message) {
+    if (!this.cryptoProvider || !message.auth) {
+      return { valid: true, payload: message.payload };
+    }
+    let payload = message.payload;
+    if (message.auth.encrypted && message.payload) {
+      try {
+        const encrypted = message.payload;
+        const decrypted = await this.cryptoProvider.decrypt(encrypted, message.auth.senderDID);
+        payload = JSON.parse(new TextDecoder().decode(decrypted));
+        logger2.debug("[SyncProtocol] Message decrypted", {
+          messageId: message.messageId
+        });
+      } catch (error) {
+        return {
+          valid: false,
+          error: `Decryption failed: ${error instanceof Error ? error.message : String(error)}`
+        };
+      }
+    }
+    if (message.auth.signature && message.auth.senderDID) {
+      const signed = {
+        payload,
+        signature: message.auth.signature,
+        signer: message.auth.senderDID,
+        algorithm: "ES256",
+        signedAt: Date.now()
+      };
+      const isValid = await this.cryptoProvider.verifySignedData(signed);
+      if (!isValid) {
+        return { valid: false, error: "Invalid signature" };
+      }
+    }
+    return { valid: true, payload };
+  }
+  createHandshakeMessage(nodeId, capabilities) {
+    const message = {
+      type: "handshake",
+      version: this.version,
+      sender: nodeId,
+      receiver: "",
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        protocolVersion: this.version,
+        nodeId,
+        capabilities,
+        state: "initiating"
+      }
+    };
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Handshake message created", {
+      messageId: message.messageId,
+      nodeId,
+      capabilities: capabilities.length
+    });
+    return message;
+  }
+  createSyncRequestMessage(sender, receiver, sessionId, fromVersion, toVersion, filter) {
+    const message = {
+      type: "sync-request",
+      version: this.version,
+      sender,
+      receiver,
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        sessionId,
+        fromVersion,
+        toVersion,
+        filter
+      }
+    };
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Sync request created", {
+      messageId: message.messageId,
+      sessionId,
+      fromVersion,
+      toVersion
+    });
+    return message;
+  }
+  createSyncResponseMessage(sender, receiver, sessionId, fromVersion, toVersion, data, hasMore = false, offset = 0) {
+    const message = {
+      type: "sync-response",
+      version: this.version,
+      sender,
+      receiver,
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        sessionId,
+        fromVersion,
+        toVersion,
+        data,
+        hasMore,
+        offset
+      }
+    };
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Sync response created", {
+      messageId: message.messageId,
+      sessionId,
+      itemCount: data.length,
+      hasMore
+    });
+    return message;
+  }
+  createAckMessage(sender, receiver, messageId) {
+    const message = {
+      type: "ack",
+      version: this.version,
+      sender,
+      receiver,
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { acknowledgedMessageId: messageId }
+    };
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.schedulePersist();
+    return message;
+  }
+  createErrorMessage(sender, receiver, error, relatedMessageId) {
+    const message = {
+      type: "error",
+      version: this.version,
+      sender,
+      receiver,
+      messageId: this.generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: {
+        error,
+        relatedMessageId
+      }
+    };
+    this.messageMap.set(message.messageId, message);
+    this.messageQueue.push(message);
+    this.protocolErrors.push({
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.schedulePersist();
+    logger2.error("[SyncProtocol] Error message created", {
+      messageId: message.messageId,
+      errorCode: error.code,
+      recoverable: error.recoverable
+    });
+    return message;
+  }
+  validateMessage(message) {
+    const errors = [];
+    if (!message.type) {
+      errors.push("Message type is required");
+    }
+    if (!message.sender) {
+      errors.push("Sender is required");
+    }
+    if (!message.messageId) {
+      errors.push("Message ID is required");
+    }
+    if (!message.timestamp) {
+      errors.push("Timestamp is required");
+    }
+    const timestampValue = new Date(message.timestamp);
+    if (Number.isNaN(timestampValue.getTime())) {
+      errors.push("Invalid timestamp format");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  serializeMessage(message) {
+    try {
+      return JSON.stringify(message);
+    } catch (error) {
+      logger2.error("[SyncProtocol] Message serialization failed", {
+        messageId: message.messageId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to serialize message: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  deserializeMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      const validation = this.validateMessage(message);
+      if (!validation.valid) {
+        throw new Error(`Invalid message: ${validation.errors.join(", ")}`);
+      }
+      return message;
+    } catch (error) {
+      logger2.error("[SyncProtocol] Message deserialization failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to deserialize message: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  processHandshake(message) {
+    if (message.type !== "handshake") {
+      throw new Error("Message is not a handshake");
+    }
+    const handshake = message.payload;
+    const nodeId = message.sender;
+    this.handshakes.set(nodeId, handshake);
+    this.schedulePersist();
+    logger2.debug("[SyncProtocol] Handshake processed", {
+      nodeId,
+      protocolVersion: handshake.protocolVersion,
+      capabilities: handshake.capabilities.length
+    });
+    return handshake;
+  }
+  getMessage(messageId) {
+    return this.messageMap.get(messageId);
+  }
+  getAllMessages() {
+    return [...this.messageQueue];
+  }
+  getMessagesByType(type) {
+    return this.messageQueue.filter((m) => m.type === type);
+  }
+  getMessagesFromSender(sender) {
+    return this.messageQueue.filter((m) => m.sender === sender);
+  }
+  getPendingMessages(receiver) {
+    return this.messageQueue.filter((m) => m.receiver === receiver);
+  }
+  getHandshakes() {
+    return new Map(this.handshakes);
+  }
+  getStatistics() {
+    const messagesByType = {};
+    for (const message of this.messageQueue) {
+      messagesByType[message.type] = (messagesByType[message.type] || 0) + 1;
+    }
+    const errorCount = this.protocolErrors.length;
+    const recoverableErrors = this.protocolErrors.filter((e) => e.error.recoverable).length;
+    return {
+      totalMessages: this.messageQueue.length,
+      messagesByType,
+      totalHandshakes: this.handshakes.size,
+      totalErrors: errorCount,
+      recoverableErrors,
+      unrecoverableErrors: errorCount - recoverableErrors
+    };
+  }
+  getErrors() {
+    return [...this.protocolErrors];
+  }
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const data = {
+      protocolVersion: this.version,
+      messageCounter: this.messageCounter,
+      messageQueue: this.getAllMessages(),
+      handshakes: Array.from(this.handshakes.entries()).map(([nodeId, handshake]) => ({
+        nodeId,
+        handshake
+      })),
+      protocolErrors: this.getErrors()
+    };
+    const envelope = {
+      version: 1,
+      updatedAt: Date.now(),
+      data
+    };
+    const serialize = this.persistence.serializer ?? ((value) => JSON.stringify(value));
+    await this.persistence.adapter.setItem(this.persistence.key, serialize(envelope));
+  }
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return { messages: 0, handshakes: 0, errors: 0 };
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return { messages: 0, handshakes: 0, errors: 0 };
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !envelope.data) {
+      throw new Error("Invalid sync protocol persistence payload");
+    }
+    if (!Array.isArray(envelope.data.messageQueue) || !Array.isArray(envelope.data.handshakes) || !Array.isArray(envelope.data.protocolErrors)) {
+      throw new Error("Invalid sync protocol persistence structure");
+    }
+    const nextMessages = [];
+    for (const message of envelope.data.messageQueue) {
+      const validation = this.validateMessage(message);
+      if (!validation.valid) {
+        throw new Error(`Invalid persisted message ${message?.messageId ?? "unknown"}: ${validation.errors.join(", ")}`);
+      }
+      nextMessages.push(message);
+    }
+    const nextHandshakes = /* @__PURE__ */ new Map;
+    for (const entry of envelope.data.handshakes) {
+      if (typeof entry.nodeId !== "string" || !this.isValidHandshake(entry.handshake)) {
+        throw new Error("Invalid persisted handshake payload");
+      }
+      nextHandshakes.set(entry.nodeId, entry.handshake);
+    }
+    const nextErrors = [];
+    for (const entry of envelope.data.protocolErrors) {
+      if (!this.isValidProtocolErrorEntry(entry)) {
+        throw new Error("Invalid persisted protocol error payload");
+      }
+      nextErrors.push(entry);
+    }
+    this.messageQueue = nextMessages;
+    this.messageMap = new Map(nextMessages.map((m) => [m.messageId, m]));
+    this.handshakes = nextHandshakes;
+    this.protocolErrors = nextErrors;
+    this.messageCounter = Math.max(envelope.data.messageCounter || 0, this.messageQueue.length);
+    logger2.debug("[SyncProtocol] Loaded from persistence", {
+      key: this.persistence.key,
+      messages: this.messageQueue.length,
+      handshakes: this.handshakes.size,
+      errors: this.protocolErrors.length
+    });
+    return {
+      messages: this.messageQueue.length,
+      handshakes: this.handshakes.size,
+      errors: this.protocolErrors.length
+    };
+  }
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    await this.persistence.adapter.removeItem(this.persistence.key);
+  }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      this.persistSafely();
+    }, this.persistence.persistDebounceMs ?? 25);
+  }
+  async persistSafely() {
+    if (!this.persistence) {
+      return;
+    }
+    if (this.persistInFlight) {
+      this.persistPending = true;
+      return;
+    }
+    this.persistInFlight = true;
+    try {
+      await this.saveToPersistence();
+    } catch (error) {
+      logger2.error("[SyncProtocol] Persistence write failed", {
+        key: this.persistence.key,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.persistInFlight = false;
+      const shouldRunAgain = this.persistPending;
+      this.persistPending = false;
+      if (shouldRunAgain) {
+        this.persistSafely();
+      }
+    }
+  }
+  isValidHandshake(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const handshake = value;
+    const validState = handshake.state === "initiating" || handshake.state === "responding" || handshake.state === "completed";
+    return typeof handshake.protocolVersion === "string" && typeof handshake.nodeId === "string" && Array.isArray(handshake.capabilities) && handshake.capabilities.every((cap) => typeof cap === "string") && validState;
+  }
+  isValidProtocolErrorEntry(entry) {
+    if (typeof entry !== "object" || entry === null) {
+      return false;
+    }
+    const candidate = entry;
+    return typeof candidate.timestamp === "string" && typeof candidate.error?.code === "string" && typeof candidate.error.message === "string" && typeof candidate.error.recoverable === "boolean";
+  }
+  generateMessageId() {
+    this.messageCounter++;
+    return `msg-${Date.now()}-${this.messageCounter}`;
+  }
+  clear() {
+    this.messageQueue = [];
+    this.messageMap.clear();
+    this.handshakes.clear();
+    this.protocolErrors = [];
+    this.messageCounter = 0;
+    this.cryptoProvider = null;
+    this.cryptoConfig = null;
+    this.schedulePersist();
+  }
+  getCryptoProvider() {
+    return this.cryptoProvider;
+  }
+};
+
+// ../aeon/dist/persistence/index.js
+var DEFAULT_RULE = {
+  urgency: "deferred",
+  debounce: 50,
+  maxBufferSize: 5000,
+  readThrough: true
+};
+var DashStorageAdapter = class {
+  backend;
+  syncClient;
+  rules;
+  hooks;
+  pendingChanges = /* @__PURE__ */ new Map;
+  syncTimer = null;
+  syncInFlight = false;
+  syncPending = false;
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.syncClient = options.syncClient ?? null;
+    this.hooks = options.hooks ?? {};
+    const defaultRule = {
+      ...DEFAULT_RULE,
+      ...options.rules?.default ?? {}
+    };
+    if (options.syncDebounceMs !== undefined)
+      defaultRule.debounce = options.syncDebounceMs;
+    if (options.maxPendingChanges !== undefined)
+      defaultRule.maxBufferSize = options.maxPendingChanges;
+    if (options.onSyncError && !this.hooks.onSyncError)
+      this.hooks.onSyncError = options.onSyncError;
+    this.rules = {
+      default: defaultRule,
+      prefixes: options.rules?.prefixes ?? {}
+    };
+  }
+  async getItem(key) {
+    const rule = this.getRuleForKey(key);
+    if (rule.readThrough !== false) {
+      const pending = this.pendingChanges.get(key);
+      if (pending) {
+        return pending.operation === "delete" ? null : pending.value ?? null;
+      }
+    }
+    return await this.backend.get(key);
+  }
+  async setItem(key, value) {
+    await this.backend.set(key, value);
+    this.trackChange({
+      key,
+      operation: "set",
+      value,
+      timestamp: Date.now()
+    });
+  }
+  async removeItem(key) {
+    await this.backend.delete(key);
+    this.trackChange({
+      key,
+      operation: "delete",
+      timestamp: Date.now()
+    });
+  }
+  getPendingSyncCount() {
+    return this.pendingChanges.size;
+  }
+  async flushSync() {
+    if (!this.syncClient || this.pendingChanges.size === 0) {
+      return;
+    }
+    if (this.syncTimer) {
+      clearTimeout(this.syncTimer);
+      this.syncTimer = null;
+    }
+    await this.performSync();
+  }
+  trackChange(change) {
+    this.pendingChanges.set(change.key, change);
+    const rule = this.getRuleForKey(change.key);
+    if (rule.urgency === "realtime") {
+      this.performSync();
+      return;
+    }
+    const maxSize = rule.maxBufferSize ?? 5000;
+    if (this.pendingChanges.size >= maxSize) {
+      this.hooks.onBufferOverflow?.(this.getPrefixMatch(change.key) || "default", this.pendingChanges.size, maxSize);
+      this.performSync();
+      return;
+    }
+    this.scheduleSync(rule);
+  }
+  getRuleForKey(key) {
+    const prefix = this.getPrefixMatch(key);
+    return (prefix ? this.rules.prefixes?.[prefix] : this.rules.default) ?? this.rules.default;
+  }
+  getPrefixMatch(key) {
+    if (!this.rules.prefixes)
+      return null;
+    const prefixes = Object.keys(this.rules.prefixes).sort((a, b) => b.length - a.length);
+    return prefixes.find((p) => key.startsWith(p)) ?? null;
+  }
+  scheduleSync(rule) {
+    if (!this.syncClient || this.syncTimer) {
+      return;
+    }
+    const debounceMs = typeof rule.debounce === "string" ? this.parseInterval(rule.debounce) : rule.debounce ?? 50;
+    this.syncTimer = setTimeout(() => {
+      this.syncTimer = null;
+      this.performSync();
+    }, debounceMs);
+  }
+  async performSync() {
+    if (!this.syncClient) {
+      return;
+    }
+    if (this.syncInFlight) {
+      this.syncPending = true;
+      return;
+    }
+    const changes = Array.from(this.pendingChanges.values()).sort((a, b) => a.timestamp - b.timestamp);
+    if (changes.length === 0) {
+      return;
+    }
+    this.pendingChanges.clear();
+    this.syncInFlight = true;
+    try {
+      await this.syncClient.syncChanges(changes);
+      this.hooks.onSync?.(changes);
+      this.hooks.onFlush?.(changes.length);
+    } catch (error) {
+      for (const change of changes) {
+        const current = this.pendingChanges.get(change.key);
+        if (!current || change.timestamp > current.timestamp) {
+          this.pendingChanges.set(change.key, change);
+        }
+      }
+      if (this.hooks.onSyncError) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.hooks.onSyncError(normalizedError, changes);
+      }
+    } finally {
+      this.syncInFlight = false;
+      const rerun = this.syncPending || this.pendingChanges.size > 0;
+      this.syncPending = false;
+      if (rerun) {
+        this.scheduleSync(this.rules.default);
+      }
+    }
+  }
+  parseInterval(input) {
+    const match = input.match(/^(\d+)(ms|s|m|h|d)$/);
+    if (!match)
+      return 50;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1000;
+      case "m":
+        return value * 60 * 1000;
+      case "h":
+        return value * 60 * 60 * 1000;
+      case "d":
+        return value * 24 * 60 * 60 * 1000;
+      default:
+        return 50;
+    }
+  }
+};
+var InMemoryStorageAdapter = class {
+  store = /* @__PURE__ */ new Map;
+  getItem(key) {
+    return this.store.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.store.set(key, value);
+  }
+  removeItem(key) {
+    this.store.delete(key);
+  }
+  async flushSync() {}
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/sync/AeonDurableSync.ts
+function createBrowserStorageBackend() {
+  return {
+    get(key) {
+      if (typeof localStorage === "undefined") {
+        return null;
+      }
+      try {
+        return localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    set(key, value) {
+      if (typeof localStorage === "undefined") {
+        return;
+      }
+      try {
+        localStorage.setItem(key, value);
+      } catch {}
+    },
+    delete(key) {
+      if (typeof localStorage === "undefined") {
+        return;
+      }
+      try {
+        localStorage.removeItem(key);
+      } catch {}
+    }
+  };
+}
+
+class AeonDurableSyncRuntime {
+  adapter;
+  queue;
+  protocol;
+  replication;
+  constructor(config) {
+    const prefix = config.persistenceKeyPrefix ?? `dash:aeon:${config.roomName}`;
+    this.adapter = config.enabled === false ? new InMemoryStorageAdapter : new DashStorageAdapter(config.storageBackend ?? createBrowserStorageBackend(), config.storageOptions ?? {});
+    this.queue = new OfflineOperationQueue({
+      persistence: {
+        adapter: this.adapter,
+        key: `${prefix}:offline`,
+        autoPersist: true,
+        autoLoad: true
+      }
+    });
+    this.protocol = new SyncProtocol({
+      persistence: {
+        adapter: this.adapter,
+        key: `${prefix}:protocol`,
+        autoPersist: true,
+        autoLoad: true
+      }
+    });
+    this.replication = new ReplicationManager({
+      persistence: {
+        adapter: this.adapter,
+        key: `${prefix}:replication`,
+        autoPersist: true,
+        autoLoad: true
+      }
+    });
+  }
+  async initialize() {
+    try {
+      await Promise.all([
+        this.queue.loadFromPersistence(),
+        this.protocol.loadFromPersistence(),
+        this.replication.loadFromPersistence()
+      ]);
+    } catch {}
+  }
+  async flushSync() {
+    if ("flushSync" in this.adapter) {
+      await this.adapter.flushSync();
+    }
+  }
+  recordTransportSelection(roomName, transport, relay) {
+    if (!transport) {
+      return;
+    }
+    try {
+      this.queue.enqueue("update", {
+        roomName,
+        event: "transport-selected",
+        transport,
+        relay,
+        ts: Date.now()
+      }, roomName, "normal");
+      this.protocol.createSyncRequestMessage(roomName, relay ?? "unknown-relay", `transport-${Date.now()}`, "0.0.0", "1.1.0", {
+        transport,
+        relay
+      });
+    } catch {}
+  }
+  recordDiscovery(roomName, relays) {
+    const sanitizedRelays = relays.filter((relay) => typeof relay === "string" && relay.length > 0).slice(0, 32);
+    try {
+      this.queue.enqueue("sync", {
+        roomName,
+        event: "relay-discovery",
+        count: sanitizedRelays.length,
+        relays: sanitizedRelays,
+        ts: Date.now()
+      }, roomName, "low");
+    } catch {}
+  }
+  getPendingOperations() {
+    return this.queue.getPendingCount();
+  }
+}
+export {
+  AeonDurableSyncRuntime
+};