@affectively/aeon 1.0.0 → 1.2.0

package/dist/index.cjs

@@ -56,6 +56,145 @@ var logger = {
   error: (...args) => getLogger().error(...args)
 };
 
+// src/persistence/DashStorageAdapter.ts
+var DashStorageAdapter = class {
+  backend;
+  syncClient;
+  syncDebounceMs;
+  maxPendingChanges;
+  onSyncError;
+  pendingChanges = /* @__PURE__ */ new Map();
+  syncTimer = null;
+  syncInFlight = false;
+  syncPending = false;
+  constructor(backend, options = {}) {
+    this.backend = backend;
+    this.syncClient = options.syncClient ?? null;
+    this.syncDebounceMs = options.syncDebounceMs ?? 50;
+    this.maxPendingChanges = options.maxPendingChanges ?? 5e3;
+    this.onSyncError = options.onSyncError ?? null;
+  }
+  async getItem(key) {
+    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);
+    this.enforcePendingLimit();
+    this.scheduleSync();
+  }
+  enforcePendingLimit() {
+    if (this.pendingChanges.size <= this.maxPendingChanges) {
+      return;
+    }
+    const sorted = Array.from(this.pendingChanges.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+    const overflow = this.pendingChanges.size - this.maxPendingChanges;
+    for (let i = 0; i < overflow; i++) {
+      const toDrop = sorted[i];
+      if (toDrop) {
+        this.pendingChanges.delete(toDrop.key);
+      }
+    }
+  }
+  scheduleSync() {
+    if (!this.syncClient) {
+      return;
+    }
+    if (this.syncTimer) {
+      clearTimeout(this.syncTimer);
+    }
+    this.syncTimer = setTimeout(() => {
+      void this.performSync();
+    }, this.syncDebounceMs);
+  }
+  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);
+    } 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.onSyncError) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.onSyncError(normalizedError, changes);
+      }
+    } finally {
+      this.syncInFlight = false;
+      const rerun = this.syncPending || this.pendingChanges.size > 0;
+      this.syncPending = false;
+      if (rerun) {
+        this.scheduleSync();
+      }
+    }
+  }
+};
+
+// src/persistence/InMemoryStorageAdapter.ts
+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);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
 // src/versioning/SchemaVersionManager.ts
 var SchemaVersionManager = class {
   versions = /* @__PURE__ */ new Map();
@@ -107,7 +246,9 @@ var SchemaVersionManager = class {
    */
   setCurrentVersion(version) {
     if (!this.versions.has(this.versionToString(version))) {
-      throw new Error(`Version ${this.versionToString(version)} not registered`);
+      throw new Error(
+        `Version ${this.versionToString(version)} not registered`
+      );
     }
     this.currentVersion = version;
     logger.debug("[SchemaVersionManager] Current version set", {
@@ -393,7 +534,9 @@ var MigrationEngine = class {
         id: migrationId,
         error: result.errors[0]
       });
-      throw new Error(`Rollback for ${migrationId} failed: ${result.errors[0]}`);
+      throw new Error(
+        `Rollback for ${migrationId} failed: ${result.errors[0]}`
+      );
     }
   }
   /**
@@ -446,8 +589,14 @@ var MigrationEngine = class {
   getStatistics() {
     const successful = this.executedMigrations.filter((m) => m.success).length;
     const failed = this.executedMigrations.filter((m) => !m.success).length;
-    const totalDuration = this.executedMigrations.reduce((sum, m) => sum + m.duration, 0);
-    const totalAffected = this.executedMigrations.reduce((sum, m) => sum + m.itemsAffected, 0);
+    const totalDuration = this.executedMigrations.reduce(
+      (sum, m) => sum + m.duration,
+      0
+    );
+    const totalAffected = this.executedMigrations.reduce(
+      (sum, m) => sum + m.itemsAffected,
+      0
+    );
     return {
       totalExecuted: this.executedMigrations.length,
       successful,
@@ -501,7 +650,9 @@ var DataTransformer = class {
       return rule.transformer(value);
     } catch (error) {
       if (rule.required) {
-        throw new Error(`Failed to transform required field ${field}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(
+          `Failed to transform required field ${field}: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
       return rule.defaultValue !== void 0 ? rule.defaultValue : value;
     }
@@ -574,7 +725,9 @@ var DataTransformer = class {
   validateTransformation(original, transformed) {
     const issues = [];
     if (original.length !== transformed.length) {
-      issues.push(`Item count mismatch: ${original.length} -> ${transformed.length}`);
+      issues.push(
+        `Item count mismatch: ${original.length} -> ${transformed.length}`
+      );
     }
     for (let i = 0; i < Math.min(original.length, transformed.length); i++) {
       const orig = original[i];
@@ -665,14 +818,40 @@ var DataTransformer = class {
 };
 
 // src/versioning/MigrationTracker.ts
-var MigrationTracker = class {
+var MigrationTracker = class _MigrationTracker {
+  static DEFAULT_PERSIST_KEY = "aeon:migration-tracker:v1";
+  static INTEGRITY_ROOT = "aeon:migration-integrity-root:v1";
   migrations = [];
   snapshots = /* @__PURE__ */ new Map();
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(options) {
+    if (options?.persistence) {
+      this.persistence = {
+        ...options.persistence,
+        key: options.persistence.key ?? _MigrationTracker.DEFAULT_PERSIST_KEY,
+        autoPersist: options.persistence.autoPersist ?? true,
+        autoLoad: options.persistence.autoLoad ?? false,
+        persistDebounceMs: options.persistence.persistDebounceMs ?? 25
+      };
+    }
+    if (this.persistence?.autoLoad) {
+      void this.loadFromPersistence().catch((error) => {
+        logger.error("[MigrationTracker] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
   /**
    * Track a new migration
    */
   recordMigration(record) {
     this.migrations.push({ ...record });
+    this.schedulePersist();
     logger.debug("[MigrationTracker] Migration recorded", {
       id: record.id,
       migrationId: record.migrationId,
@@ -729,7 +908,9 @@ var MigrationTracker = class {
    * Check if can rollback
    */
   canRollback(fromVersion, toVersion) {
-    const fromIndex = this.migrations.findIndex((m) => m.version === fromVersion);
+    const fromIndex = this.migrations.findIndex(
+      (m) => m.version === fromVersion
+    );
     const toIndex = this.migrations.findIndex((m) => m.version === toVersion);
     if (fromIndex === -1 || toIndex === -1) {
       return false;
@@ -753,7 +934,9 @@ var MigrationTracker = class {
     const affectedVersions = [];
     let estimatedDuration = 0;
     if (canRollback) {
-      const fromIndex = this.migrations.findIndex((m) => m.version === fromVersion);
+      const fromIndex = this.migrations.findIndex(
+        (m) => m.version === fromVersion
+      );
       const toIndex = this.migrations.findIndex((m) => m.version === toVersion);
       for (let i = fromIndex; i > toIndex; i--) {
         const migration = this.migrations[i];
@@ -809,12 +992,24 @@ var MigrationTracker = class {
    * Get migration statistics
    */
   getStatistics() {
-    const applied = this.migrations.filter((m) => m.status === "applied").length;
+    const applied = this.migrations.filter(
+      (m) => m.status === "applied"
+    ).length;
     const failed = this.migrations.filter((m) => m.status === "failed").length;
-    const pending = this.migrations.filter((m) => m.status === "pending").length;
-    const rolledBack = this.migrations.filter((m) => m.status === "rolled-back").length;
-    const totalDuration = this.migrations.reduce((sum, m) => sum + m.duration, 0);
-    const totalAffected = this.migrations.reduce((sum, m) => sum + m.itemsAffected, 0);
+    const pending = this.migrations.filter(
+      (m) => m.status === "pending"
+    ).length;
+    const rolledBack = this.migrations.filter(
+      (m) => m.status === "rolled-back"
+    ).length;
+    const totalDuration = this.migrations.reduce(
+      (sum, m) => sum + m.duration,
+      0
+    );
+    const totalAffected = this.migrations.reduce(
+      (sum, m) => sum + m.itemsAffected,
+      0
+    );
     return {
       total: this.migrations.length,
       applied,
@@ -865,7 +1060,147 @@ var MigrationTracker = class {
         status,
         hasError: !!error
       });
+      this.schedulePersist();
+    }
+  }
+  /**
+   * Persist tracker state with integrity chain verification metadata.
+   */
+  async saveToPersistence() {
+    if (!this.persistence) {
+      return;
+    }
+    const normalizedMigrations = this.migrations.map((migration) => ({
+      ...migration,
+      previousHash: void 0,
+      integrityHash: void 0
+    }));
+    const integrityEntries = [];
+    let previousHash = _MigrationTracker.INTEGRITY_ROOT;
+    for (const migration of normalizedMigrations) {
+      const hash = await this.computeDigestHex(
+        `${previousHash}|${this.stableStringify(migration)}`
+      );
+      integrityEntries.push({
+        recordId: migration.id,
+        previousHash,
+        hash
+      });
+      previousHash = hash;
+    }
+    const persistedMigrations = normalizedMigrations.map((migration, index) => ({
+      ...migration,
+      previousHash: integrityEntries[index]?.previousHash,
+      integrityHash: integrityEntries[index]?.hash
+    }));
+    const data = {
+      migrations: persistedMigrations,
+      snapshots: Array.from(this.snapshots.entries()).map(
+        ([recordId, snapshot]) => ({
+          recordId,
+          beforeHash: snapshot.beforeHash,
+          afterHash: snapshot.afterHash,
+          itemCount: snapshot.itemCount
+        })
+      ),
+      integrity: {
+        algorithm: "sha256-chain-v1",
+        entries: integrityEntries,
+        rootHash: previousHash
+      }
+    };
+    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));
+  }
+  /**
+   * Load tracker state and verify integrity chain.
+   */
+  async loadFromPersistence() {
+    if (!this.persistence) {
+      return { migrations: 0, snapshots: 0 };
+    }
+    const raw = await this.persistence.adapter.getItem(this.persistence.key);
+    if (!raw) {
+      return { migrations: 0, snapshots: 0 };
+    }
+    const deserialize = this.persistence.deserializer ?? ((value) => JSON.parse(value));
+    const envelope = deserialize(raw);
+    if (envelope.version !== 1 || !envelope.data) {
+      throw new Error("Invalid migration tracker persistence payload");
+    }
+    if (!Array.isArray(envelope.data.migrations) || !Array.isArray(envelope.data.snapshots) || !envelope.data.integrity || !Array.isArray(envelope.data.integrity.entries) || typeof envelope.data.integrity.rootHash !== "string") {
+      throw new Error("Invalid migration tracker persistence structure");
+    }
+    if (envelope.data.integrity.algorithm !== "sha256-chain-v1") {
+      throw new Error("Unsupported migration integrity algorithm");
+    }
+    if (envelope.data.integrity.entries.length !== envelope.data.migrations.length) {
+      throw new Error("Migration integrity entry count mismatch");
+    }
+    const validatedMigrations = [];
+    let previousHash = _MigrationTracker.INTEGRITY_ROOT;
+    for (let i = 0; i < envelope.data.migrations.length; i++) {
+      const migration = envelope.data.migrations[i];
+      const integrity = envelope.data.integrity.entries[i];
+      if (!this.isValidMigrationRecord(migration)) {
+        throw new Error("Invalid persisted migration record");
+      }
+      if (!integrity || integrity.recordId !== migration.id || integrity.previousHash !== previousHash) {
+        throw new Error("Migration integrity chain mismatch");
+      }
+      const expectedHash = await this.computeDigestHex(
+        `${previousHash}|${this.stableStringify({
+          ...migration,
+          previousHash: void 0,
+          integrityHash: void 0
+        })}`
+      );
+      if (expectedHash !== integrity.hash) {
+        throw new Error("Migration integrity verification failed");
+      }
+      validatedMigrations.push({
+        ...migration,
+        previousHash: integrity.previousHash,
+        integrityHash: integrity.hash
+      });
+      previousHash = expectedHash;
+    }
+    if (previousHash !== envelope.data.integrity.rootHash) {
+      throw new Error("Migration integrity root hash mismatch");
+    }
+    const validatedSnapshots = /* @__PURE__ */ new Map();
+    for (const snapshot of envelope.data.snapshots) {
+      if (typeof snapshot.recordId !== "string" || typeof snapshot.beforeHash !== "string" || typeof snapshot.afterHash !== "string" || typeof snapshot.itemCount !== "number") {
+        throw new Error("Invalid persisted migration snapshot");
+      }
+      validatedSnapshots.set(snapshot.recordId, {
+        beforeHash: snapshot.beforeHash,
+        afterHash: snapshot.afterHash,
+        itemCount: snapshot.itemCount
+      });
+    }
+    this.migrations = validatedMigrations;
+    this.snapshots = validatedSnapshots;
+    logger.debug("[MigrationTracker] Loaded from persistence", {
+      key: this.persistence.key,
+      migrations: this.migrations.length,
+      snapshots: this.snapshots.size
+    });
+    return { migrations: this.migrations.length, snapshots: this.snapshots.size };
+  }
+  /**
+   * Remove persisted migration tracker state.
+   */
+  async clearPersistence() {
+    if (!this.persistence) {
+      return;
     }
+    await this.persistence.adapter.removeItem(this.persistence.key);
   }
   /**
    * Clear history (for testing)
@@ -873,6 +1208,7 @@ var MigrationTracker = class {
   clear() {
     this.migrations = [];
     this.snapshots.clear();
+    this.schedulePersist();
   }
   /**
    * Get total migrations tracked
@@ -891,6 +1227,91 @@ var MigrationTracker = class {
       return time >= start && time <= end;
     });
   }
+  schedulePersist() {
+    if (!this.persistence || this.persistence.autoPersist === false) {
+      return;
+    }
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+    }
+    this.persistTimer = setTimeout(() => {
+      void 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("[MigrationTracker] 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) {
+        void this.persistSafely();
+      }
+    }
+  }
+  isValidMigrationRecord(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const record = value;
+    const validDirection = record.direction === "up" || record.direction === "down";
+    const validStatus = record.status === "pending" || record.status === "applied" || record.status === "failed" || record.status === "rolled-back";
+    return typeof record.id === "string" && typeof record.migrationId === "string" && typeof record.timestamp === "string" && typeof record.version === "string" && validDirection && validStatus && typeof record.duration === "number" && typeof record.itemsAffected === "number" && typeof record.appliedBy === "string";
+  }
+  stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+      return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+      return `[${value.map((item) => this.stableStringify(item)).join(",")}]`;
+    }
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    return `{${entries.map(
+      ([key, entryValue]) => `${JSON.stringify(key)}:${this.stableStringify(entryValue)}`
+    ).join(",")}}`;
+  }
+  async computeDigestHex(value) {
+    if (globalThis.crypto?.subtle) {
+      const bytes = new TextEncoder().encode(value);
+      const normalized = bytes.buffer.slice(
+        bytes.byteOffset,
+        bytes.byteOffset + bytes.byteLength
+      );
+      const digest = await globalThis.crypto.subtle.digest(
+        "SHA-256",
+        normalized
+      );
+      return this.toHex(new Uint8Array(digest));
+    }
+    return this.fallbackDigestHex(value);
+  }
+  toHex(bytes) {
+    return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  fallbackDigestHex(value) {
+    let hash = 2166136261;
+    for (let i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
 };
 var SyncCoordinator = class extends eventemitter3.EventEmitter {
   nodes = /* @__PURE__ */ new Map();
@@ -1248,7 +1669,9 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
    * Get active sync sessions
    */
   getActiveSyncSessions() {
-    return Array.from(this.sessions.values()).filter((s) => s.status === "active");
+    return Array.from(this.sessions.values()).filter(
+      (s) => s.status === "active"
+    );
   }
   /**
    * Get sessions for a node
@@ -1266,8 +1689,14 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
     const completed = sessions.filter((s) => s.status === "completed").length;
     const failed = sessions.filter((s) => s.status === "failed").length;
     const active = sessions.filter((s) => s.status === "active").length;
-    const totalItemsSynced = sessions.reduce((sum, s) => sum + s.itemsSynced, 0);
-    const totalConflicts = sessions.reduce((sum, s) => sum + s.conflictsDetected, 0);
+    const totalItemsSynced = sessions.reduce(
+      (sum, s) => sum + s.itemsSynced,
+      0
+    );
+    const totalConflicts = sessions.reduce(
+      (sum, s) => sum + s.conflictsDetected,
+      0
+    );
     return {
       totalNodes: this.nodes.size,
       onlineNodes: this.getOnlineNodes().length,
@@ -1334,7 +1763,9 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
         }
       }
     }, interval);
-    logger.debug("[SyncCoordinator] Heartbeat monitoring started", { interval });
+    logger.debug("[SyncCoordinator] Heartbeat monitoring started", {
+      interval
+    });
   }
   /**
    * Stop heartbeat monitoring
@@ -1367,7 +1798,8 @@ var SyncCoordinator = class extends eventemitter3.EventEmitter {
 };
 
 // src/distributed/ReplicationManager.ts
-var ReplicationManager = class {
+var ReplicationManager = class _ReplicationManager {
+  static DEFAULT_PERSIST_KEY = "aeon:replication-state:v1";
   replicas = /* @__PURE__ */ new Map();
   policies = /* @__PURE__ */ new Map();
   replicationEvents = [];
@@ -1376,6 +1808,29 @@ var ReplicationManager = class {
   cryptoProvider = null;
   replicasByDID = /* @__PURE__ */ new Map();
   // DID -> replicaId
+  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) {
+      void this.loadFromPersistence().catch((error) => {
+        logger.error("[ReplicationManager] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
   /**
    * Configure cryptographic provider for encrypted replication
    */
@@ -1420,6 +1875,7 @@ var ReplicationManager = class {
       details: { did: replica.did, encrypted, authenticated: true }
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Authenticated replica registered", {
       replicaId: replica.id,
       did: replica.did,
@@ -1449,7 +1905,10 @@ var ReplicationManager = class {
       throw new Error("Crypto provider not initialized");
     }
     const dataBytes = new TextEncoder().encode(JSON.stringify(data));
-    const encrypted = await this.cryptoProvider.encrypt(dataBytes, targetReplicaDID);
+    const encrypted = await this.cryptoProvider.encrypt(
+      dataBytes,
+      targetReplicaDID
+    );
     const localDID = this.cryptoProvider.getLocalDID();
     return {
       ct: encrypted.ct,
@@ -1518,10 +1977,13 @@ var ReplicationManager = class {
       }))
     });
     if (!result.authorized) {
-      logger.warn("[ReplicationManager] Replica capability verification failed", {
-        replicaDID,
-        error: result.error
-      });
+      logger.warn(
+        "[ReplicationManager] Replica capability verification failed",
+        {
+          replicaDID,
+          error: result.error
+        }
+      );
     }
     return result;
   }
@@ -1540,6 +2002,7 @@ var ReplicationManager = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Replica registered", {
       replicaId: replica.id,
       nodeId: replica.nodeId,
@@ -1562,6 +2025,7 @@ var ReplicationManager = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.replicationEvents.push(event);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Replica removed", { replicaId });
   }
   /**
@@ -1577,6 +2041,7 @@ var ReplicationManager = class {
       maxReplicationLag
     };
     this.policies.set(policy.id, policy);
+    this.schedulePersist();
     logger.debug("[ReplicationManager] Policy created", {
       policyId: policy.id,
       name,
@@ -1619,12 +2084,15 @@ var ReplicationManager = class {
       lagBytes,
       lagMillis
     });
+    this.schedulePersist();
   }
   /**
    * Get replicas for node
    */
   getReplicasForNode(nodeId) {
-    return Array.from(this.replicas.values()).filter((r) => r.nodeId === nodeId);
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.nodeId === nodeId
+    );
   }
   /**
    * Get healthy replicas
@@ -1638,13 +2106,17 @@ var ReplicationManager = class {
    * Get syncing replicas
    */
   getSyncingReplicas() {
-    return Array.from(this.replicas.values()).filter((r) => r.status === "syncing");
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.status === "syncing"
+    );
   }
   /**
    * Get failed replicas
    */
   getFailedReplicas() {
-    return Array.from(this.replicas.values()).filter((r) => r.status === "failed");
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.status === "failed"
+    );
   }
   /**
    * Check replication health for policy
@@ -1705,7 +2177,9 @@ var ReplicationManager = class {
     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 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 {
@@ -1779,6 +2253,155 @@ var ReplicationManager = class {
         return false;
     }
   }
+  /**
+   * Persist current replication state snapshot.
+   */
+  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));
+  }
+  /**
+   * Load replication snapshot from persistence.
+   */
+  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++;
+      }
+    }
+    logger.debug("[ReplicationManager] Loaded from persistence", {
+      key: this.persistence.key,
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    });
+    return {
+      replicas: importedReplicas,
+      policies: importedPolicies,
+      syncStatus: importedSyncStatus
+    };
+  }
+  /**
+   * Remove persisted replication snapshot.
+   */
+  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(() => {
+      void 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("[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) {
+        void 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 all state (for testing)
    */
@@ -1789,6 +2412,7 @@ var ReplicationManager = class {
     this.syncStatus.clear();
     this.replicasByDID.clear();
     this.cryptoProvider = null;
+    this.schedulePersist();
   }
   /**
    * Get the crypto provider (for advanced usage)
@@ -1799,7 +2423,8 @@ var ReplicationManager = class {
 };
 
 // src/distributed/SyncProtocol.ts
-var SyncProtocol = class {
+var SyncProtocol = class _SyncProtocol {
+  static DEFAULT_PERSIST_KEY = "aeon:sync-protocol:v1";
   version = "1.0.0";
   messageQueue = [];
   messageMap = /* @__PURE__ */ new Map();
@@ -1809,6 +2434,29 @@ var SyncProtocol = class {
   // Crypto support
   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) {
+      void this.loadFromPersistence().catch((error) => {
+        logger.error("[SyncProtocol] Failed to load persistence", {
+          key: this.persistence?.key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+  }
   /**
    * Configure cryptographic provider for authenticated/encrypted messages
    */
@@ -1896,6 +2544,7 @@ var SyncProtocol = class {
     }
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Authenticated handshake created", {
       messageId: message.messageId,
       did: localDID,
@@ -1914,6 +2563,7 @@ var SyncProtocol = class {
     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) {
@@ -1956,6 +2606,7 @@ var SyncProtocol = class {
       }
     }
     this.handshakes.set(message.sender, handshake);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Authenticated handshake verified", {
       messageId: message.messageId,
       did: handshake.did
@@ -1979,7 +2630,10 @@ var SyncProtocol = class {
     };
     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);
+      const encrypted = await this.cryptoProvider.encrypt(
+        payloadBytes,
+        message.receiver
+      );
       message.payload = encrypted;
       message.auth.encrypted = true;
       logger.debug("[SyncProtocol] Message encrypted", {
@@ -2052,6 +2706,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Handshake message created", {
       messageId: message.messageId,
       nodeId,
@@ -2079,6 +2734,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Sync request created", {
       messageId: message.messageId,
       sessionId,
@@ -2109,6 +2765,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Sync response created", {
       messageId: message.messageId,
       sessionId,
@@ -2132,6 +2789,7 @@ var SyncProtocol = class {
     };
     this.messageMap.set(message.messageId, message);
     this.messageQueue.push(message);
+    this.schedulePersist();
     return message;
   }
   /**
@@ -2156,6 +2814,7 @@ var SyncProtocol = class {
       error,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    this.schedulePersist();
     logger.error("[SyncProtocol] Error message created", {
       messageId: message.messageId,
       errorCode: error.code,
@@ -2180,9 +2839,8 @@ var SyncProtocol = class {
     if (!message.timestamp) {
       errors.push("Timestamp is required");
     }
-    try {
-      new Date(message.timestamp);
-    } catch {
+    const timestampValue = new Date(message.timestamp);
+    if (Number.isNaN(timestampValue.getTime())) {
       errors.push("Invalid timestamp format");
     }
     return {
@@ -2201,7 +2859,9 @@ var SyncProtocol = class {
         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)}`);
+      throw new Error(
+        `Failed to serialize message: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
@@ -2219,7 +2879,9 @@ var SyncProtocol = class {
       logger.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)}`);
+      throw new Error(
+        `Failed to deserialize message: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   /**
@@ -2232,6 +2894,7 @@ var SyncProtocol = class {
     const handshake = message.payload;
     const nodeId = message.sender;
     this.handshakes.set(nodeId, handshake);
+    this.schedulePersist();
     logger.debug("[SyncProtocol] Handshake processed", {
       nodeId,
       protocolVersion: handshake.protocolVersion,
@@ -2284,7 +2947,9 @@ var SyncProtocol = class {
       messagesByType[message.type] = (messagesByType[message.type] || 0) + 1;
     }
     const errorCount = this.protocolErrors.length;
-    const recoverableErrors = this.protocolErrors.filter((e) => e.error.recoverable).length;
+    const recoverableErrors = this.protocolErrors.filter(
+      (e) => e.error.recoverable
+    ).length;
     return {
       totalMessages: this.messageQueue.length,
       messagesByType,
@@ -2300,6 +2965,156 @@ var SyncProtocol = class {
   getErrors() {
     return [...this.protocolErrors];
   }
+  /**
+   * Persist protocol state for reconnect/replay.
+   */
+  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));
+  }
+  /**
+   * Load protocol state from persistence.
+   */
+  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
+    );
+    logger.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
+    };
+  }
+  /**
+   * Clear persisted protocol checkpoint.
+   */
+  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(() => {
+      void 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("[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) {
+        void 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";
+  }
   /**
    * Generate message ID
    */
@@ -2318,6 +3133,7 @@ var SyncProtocol = class {
     this.messageCounter = 0;
     this.cryptoProvider = null;
     this.cryptoConfig = null;
+    this.schedulePersist();
   }
   /**
    * Get the crypto provider (for advanced usage)
@@ -2703,7 +3519,9 @@ var StateReconciler = class {
     }
     return {
       totalReconciliations: this.reconciliationHistory.length,
-      successfulReconciliations: this.reconciliationHistory.filter((r) => r.success).length,
+      successfulReconciliations: this.reconciliationHistory.filter(
+        (r) => r.success
+      ).length,
       totalConflictsResolved: resolvedConflicts,
       averageConflictsPerReconciliation: this.reconciliationHistory.length > 0 ? resolvedConflicts / this.reconciliationHistory.length : 0,
       strategyUsage,
@@ -2727,18 +3545,46 @@ var StateReconciler = class {
   }
 };
 var logger2 = getLogger();
-var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
+var OfflineOperationQueue = class _OfflineOperationQueue extends eventemitter3.EventEmitter {
+  static DEFAULT_PERSIST_KEY = "aeon:offline-queue:v1";
   queue = /* @__PURE__ */ new Map();
   syncingIds = /* @__PURE__ */ new Set();
   maxQueueSize = 1e3;
   defaultMaxRetries = 3;
-  constructor(maxQueueSize = 1e3, defaultMaxRetries = 3) {
+  persistence = null;
+  persistTimer = null;
+  persistInFlight = false;
+  persistPending = false;
+  constructor(maxQueueSizeOrOptions = 1e3, defaultMaxRetries = 3) {
     super();
-    this.maxQueueSize = maxQueueSize;
-    this.defaultMaxRetries = defaultMaxRetries;
+    if (typeof maxQueueSizeOrOptions === "number") {
+      this.maxQueueSize = maxQueueSizeOrOptions;
+      this.defaultMaxRetries = defaultMaxRetries;
+    } else {
+      this.maxQueueSize = maxQueueSizeOrOptions.maxQueueSize ?? 1e3;
+      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) {
+          void this.loadFromPersistence().catch((error) => {
+            logger2.error("[OfflineOperationQueue] Failed to load persistence", {
+              key: this.persistence?.key,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          });
+        }
+      }
+    }
     logger2.debug("[OfflineOperationQueue] Initialized", {
-      maxQueueSize,
-      defaultMaxRetries
+      maxQueueSize: this.maxQueueSize,
+      defaultMaxRetries: this.defaultMaxRetries,
+      persistenceEnabled: this.persistence !== null
     });
   }
   /**
@@ -2767,6 +3613,7 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
     };
     this.queue.set(operation.id, operation);
     this.emit("operation-added", operation);
+    this.schedulePersist();
     logger2.debug("[OfflineOperationQueue] Operation enqueued", {
       id: operation.id,
       type,
@@ -2791,13 +3638,18 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
    * Mark operations as syncing
    */
   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();
+    }
   }
   /**
    * Mark operation as synced
@@ -2808,8 +3660,10 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
       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");
         }
@@ -2841,6 +3695,7 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
           maxRetries: op.maxRetries
         });
       }
+      this.schedulePersist();
     }
   }
   /**
@@ -2893,28 +3748,39 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
   clear() {
     this.queue.clear();
     this.syncingIds.clear();
+    this.schedulePersist();
     logger2.debug("[OfflineOperationQueue] Queue cleared");
   }
   /**
    * Clear failed operations
    */
   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();
+    }
   }
   /**
    * Retry failed operations
    */
   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();
+    }
   }
   /**
    * Find oldest low-priority operation
@@ -2933,12 +3799,125 @@ var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
    * Import queue from persistence
    */
   import(operations) {
+    this.queue.clear();
+    this.syncingIds.clear();
     for (const op of operations) {
-      this.queue.set(op.id, op);
+      if (this.isValidOfflineOperation(op)) {
+        this.queue.set(op.id, {
+          ...op,
+          status: op.status === "syncing" ? "pending" : op.status
+        });
+      }
     }
+    this.schedulePersist();
     logger2.debug("[OfflineOperationQueue] Imported operations", {
-      count: operations.length
+      count: this.queue.size
+    });
+  }
+  /**
+   * Persist current queue snapshot.
+   */
+  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);
+  }
+  /**
+   * Load queue snapshot from persistence.
+   */
+  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++;
+      }
+    }
+    logger2.debug("[OfflineOperationQueue] Loaded from persistence", {
+      key: this.persistence.key,
+      imported
     });
+    return imported;
+  }
+  /**
+   * Remove persisted queue snapshot.
+   */
+  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(() => {
+      void 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("[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) {
+        void 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;
   }
 };
 var offlineQueueInstance = null;
@@ -2989,9 +3968,15 @@ var CompressionEngine = class {
     let algorithm = this.preferredAlgorithm;
     if (this.supportsNativeCompression()) {
       try {
-        compressed = await this.compressNative(inputData, this.preferredAlgorithm);
+        compressed = await this.compressNative(
+          inputData,
+          this.preferredAlgorithm
+        );
       } catch (error) {
-        logger3.warn("[CompressionEngine] Native compression failed, using fallback", error);
+        logger3.warn(
+          "[CompressionEngine] Native compression failed, using fallback",
+          error
+        );
         compressed = inputData;
         algorithm = "none";
       }
@@ -3063,7 +4048,13 @@ var CompressionEngine = class {
     const stream = new CompressionStream(algorithm);
     const writer = stream.writable.getWriter();
     const reader = stream.readable.getReader();
-    writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    writer.write(
+      new Uint8Array(
+        data.buffer,
+        data.byteOffset,
+        data.byteLength
+      )
+    );
     writer.close();
     const chunks = [];
     let done = false;
@@ -3090,7 +4081,13 @@ var CompressionEngine = class {
     const stream = new DecompressionStream(algorithm);
     const writer = stream.writable.getWriter();
     const reader = stream.readable.getReader();
-    writer.write(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    writer.write(
+      new Uint8Array(
+        data.buffer,
+        data.byteOffset,
+        data.byteLength
+      )
+    );
     writer.close();
     const chunks = [];
     let done = false;
@@ -3139,9 +4136,14 @@ var CompressionEngine = class {
     const sorted = [...chunks].sort((a, b) => a.index - b.index);
     const total = sorted[0]?.total ?? 0;
     if (sorted.length !== total) {
-      throw new Error(`Missing chunks: got ${sorted.length}, expected ${total}`);
+      throw new Error(
+        `Missing chunks: got ${sorted.length}, expected ${total}`
+      );
     }
-    const totalLength = sorted.reduce((sum, chunk) => sum + chunk.data.length, 0);
+    const totalLength = sorted.reduce(
+      (sum, chunk) => sum + chunk.data.length,
+      0
+    );
     const combined = new Uint8Array(totalLength);
     let offset = 0;
     for (const chunk of sorted) {
@@ -4072,7 +5074,10 @@ var AdaptiveCompressionOptimizer = class {
    * Update device resource usage
    */
   updateDeviceResources(cpuUtilization, memoryAvailableMB) {
-    this.deviceProfile.cpuUtilization = Math.max(0, Math.min(1, cpuUtilization));
+    this.deviceProfile.cpuUtilization = Math.max(
+      0,
+      Math.min(1, cpuUtilization)
+    );
     this.deviceProfile.memoryAvailableMB = memoryAvailableMB;
     this.deviceProfile.isConstrained = memoryAvailableMB < 512;
     this.deviceProfile.isPremium = memoryAvailableMB > 2048;
@@ -4132,7 +5137,10 @@ var AdaptiveCompressionOptimizer = class {
       networkFactor,
       deviceFactor
     };
-    logger7.debug("[AdaptiveCompressionOptimizer] Recommendation", recommendation);
+    logger7.debug(
+      "[AdaptiveCompressionOptimizer] Recommendation",
+      recommendation
+    );
     return recommendation;
   }
   /**
@@ -4284,7 +5292,11 @@ var AgentPresenceManager = class extends eventemitter3.EventEmitter {
     };
     this.presences.set(agentId, presence);
     this.emit("agent_joined", { agentId, presence });
-    logger8.debug("[AgentPresenceManager] Agent joined", { agentId, name, role });
+    logger8.debug("[AgentPresenceManager] Agent joined", {
+      agentId,
+      name,
+      role
+    });
   }
   /**
    * Agent left
@@ -4329,6 +5341,157 @@ var AgentPresenceManager = class extends eventemitter3.EventEmitter {
       });
     }
   }
+  /**
+   * Update focused node path
+   */
+  updateFocusNode(agentId, nodePath) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.focusNode = nodePath;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("focus_updated", {
+        agentId,
+        focusNode: nodePath
+      });
+    }
+  }
+  /**
+   * Update text selection range
+   */
+  updateSelection(agentId, selectionRange) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.selectionRange = selectionRange;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("selection_updated", {
+        agentId,
+        selectionRange
+      });
+    }
+  }
+  /**
+   * Update typing state
+   */
+  updateTyping(agentId, isTyping, field, isComposing = false) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const previous = presence.typingState;
+      const typingState = {
+        isTyping,
+        field,
+        isComposing,
+        startedAt: isTyping && !previous?.isTyping ? now : isTyping ? previous?.startedAt : void 0,
+        stoppedAt: isTyping ? void 0 : now
+      };
+      presence.typingState = typingState;
+      presence.lastSeen = now;
+      this.presences.set(agentId, presence);
+      this.emit("typing_updated", {
+        agentId,
+        typingState
+      });
+    }
+  }
+  /**
+   * Update scroll state
+   */
+  updateScroll(agentId, scrollState) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.scrollState = {
+        ...scrollState,
+        depth: Math.max(0, Math.min(1, scrollState.depth))
+      };
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("scroll_updated", {
+        agentId,
+        scrollState: presence.scrollState
+      });
+    }
+  }
+  /**
+   * Update viewport size
+   */
+  updateViewport(agentId, width, height) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.viewport = { width, height };
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("viewport_updated", {
+        agentId,
+        viewport: presence.viewport
+      });
+    }
+  }
+  /**
+   * Update input state
+   */
+  updateInputState(agentId, inputState) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.inputState = inputState;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("input_state_updated", {
+        agentId,
+        inputState
+      });
+    }
+  }
+  /**
+   * Clear input state
+   */
+  clearInputState(agentId) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.inputState = void 0;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("input_state_updated", {
+        agentId,
+        inputState: void 0
+      });
+    }
+  }
+  /**
+   * Update emotional state
+   */
+  updateEmotionState(agentId, emotionState) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      const enrichedState = {
+        ...emotionState,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      presence.emotionState = enrichedState;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("emotion_updated", {
+        agentId,
+        emotionState: enrichedState
+      });
+    }
+  }
+  /**
+   * Clear emotional state
+   */
+  clearEmotionState(agentId) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.emotionState = void 0;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("emotion_updated", {
+        agentId,
+        emotionState: void 0
+      });
+    }
+  }
   /**
    * Update status
    */
@@ -4518,7 +5681,9 @@ var AgentPresenceManager = class extends eventemitter3.EventEmitter {
     this.stopHeartbeatMonitoring();
     this.presences.clear();
     this.removeAllListeners();
-    logger8.debug("[AgentPresenceManager] Destroyed", { sessionId: this.sessionId });
+    logger8.debug("[AgentPresenceManager] Destroyed", {
+      sessionId: this.sessionId
+    });
   }
 };
 var instances = /* @__PURE__ */ new Map();
@@ -4635,8 +5800,10 @@ exports.AgentPresenceManager = AgentPresenceManager;
 exports.BatchTimingOptimizer = BatchTimingOptimizer;
 exports.CompressionEngine = CompressionEngine;
 exports.DEFAULT_CRYPTO_CONFIG = DEFAULT_CRYPTO_CONFIG;
+exports.DashStorageAdapter = DashStorageAdapter;
 exports.DataTransformer = DataTransformer;
 exports.DeltaSyncOptimizer = DeltaSyncOptimizer;
+exports.InMemoryStorageAdapter = InMemoryStorageAdapter;
 exports.MigrationEngine = MigrationEngine;
 exports.MigrationTracker = MigrationTracker;
 exports.NullCryptoProvider = NullCryptoProvider;