@affectively/aeon 1.3.0 → 1.3.1

package/dist/index.cjs

@@ -195,230 +195,6 @@ var InMemoryStorageAdapter = class {
   }
 };
 
-// src/versioning/SchemaVersionManager.ts
-var SchemaVersionManager = class {
-  versions = /* @__PURE__ */ new Map();
-  versionHistory = [];
-  compatibilityMatrix = /* @__PURE__ */ new Map();
-  currentVersion = null;
-  constructor() {
-    this.initializeDefaultVersions();
-  }
-  /**
-   * Initialize default versions
-   */
-  initializeDefaultVersions() {
-    const v1_0_0 = {
-      major: 1,
-      minor: 0,
-      patch: 0,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      description: "Initial schema version",
-      breaking: false
-    };
-    this.registerVersion(v1_0_0);
-    this.currentVersion = v1_0_0;
-  }
-  /**
-   * Register a new schema version
-   */
-  registerVersion(version) {
-    const versionString = this.versionToString(version);
-    this.versions.set(versionString, version);
-    this.versionHistory.push(version);
-    logger.debug("[SchemaVersionManager] Version registered", {
-      version: versionString,
-      breaking: version.breaking,
-      description: version.description
-    });
-  }
-  /**
-   * Get current version
-   */
-  getCurrentVersion() {
-    if (!this.currentVersion) {
-      throw new Error("No current version set");
-    }
-    return this.currentVersion;
-  }
-  /**
-   * Set current version
-   */
-  setCurrentVersion(version) {
-    if (!this.versions.has(this.versionToString(version))) {
-      throw new Error(
-        `Version ${this.versionToString(version)} not registered`
-      );
-    }
-    this.currentVersion = version;
-    logger.debug("[SchemaVersionManager] Current version set", {
-      version: this.versionToString(version)
-    });
-  }
-  /**
-   * Get version history
-   */
-  getVersionHistory() {
-    return [...this.versionHistory];
-  }
-  /**
-   * Check if version exists
-   */
-  hasVersion(version) {
-    return this.versions.has(this.versionToString(version));
-  }
-  /**
-   * Get version by string (e.g., "1.2.3")
-   */
-  getVersion(versionString) {
-    return this.versions.get(versionString);
-  }
-  /**
-   * Register compatibility rule
-   */
-  registerCompatibility(rule) {
-    if (!this.compatibilityMatrix.has(rule.from)) {
-      this.compatibilityMatrix.set(rule.from, []);
-    }
-    const rules = this.compatibilityMatrix.get(rule.from);
-    if (rules) {
-      rules.push(rule);
-    }
-    logger.debug("[SchemaVersionManager] Compatibility rule registered", {
-      from: rule.from,
-      to: rule.to,
-      compatible: rule.compatible,
-      requiresMigration: rule.requiresMigration
-    });
-  }
-  /**
-   * Check if migration path exists
-   */
-  canMigrate(fromVersion, toVersion) {
-    const fromStr = typeof fromVersion === "string" ? fromVersion : this.versionToString(fromVersion);
-    const toStr = typeof toVersion === "string" ? toVersion : this.versionToString(toVersion);
-    const rules = this.compatibilityMatrix.get(fromStr) || [];
-    return rules.some((r) => r.to === toStr && r.requiresMigration);
-  }
-  /**
-   * Get migration path
-   */
-  getMigrationPath(fromVersion, toVersion) {
-    const path = [];
-    let current = fromVersion;
-    const maxSteps = 100;
-    let steps = 0;
-    while (this.compareVersions(current, toVersion) !== 0 && steps < maxSteps) {
-      const fromStr = this.versionToString(current);
-      const rules = this.compatibilityMatrix.get(fromStr) || [];
-      let found = false;
-      for (const rule of rules) {
-        const nextVersion = this.getVersion(rule.to);
-        if (nextVersion) {
-          if (this.compareVersions(nextVersion, toVersion) <= 0 || this.compareVersions(current, nextVersion) < this.compareVersions(current, toVersion)) {
-            current = nextVersion;
-            path.push(current);
-            found = true;
-            break;
-          }
-        }
-      }
-      if (!found) {
-        break;
-      }
-      steps++;
-    }
-    return path;
-  }
-  /**
-   * Compare two versions
-   * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
-   */
-  compareVersions(v1, v2) {
-    const ver1 = typeof v1 === "string" ? this.parseVersion(v1) : v1;
-    const ver2 = typeof v2 === "string" ? this.parseVersion(v2) : v2;
-    if (ver1.major !== ver2.major) {
-      return ver1.major < ver2.major ? -1 : 1;
-    }
-    if (ver1.minor !== ver2.minor) {
-      return ver1.minor < ver2.minor ? -1 : 1;
-    }
-    if (ver1.patch !== ver2.patch) {
-      return ver1.patch < ver2.patch ? -1 : 1;
-    }
-    return 0;
-  }
-  /**
-   * Parse version string to SchemaVersion
-   */
-  parseVersion(versionString) {
-    const parts = versionString.split(".").map(Number);
-    return {
-      major: parts[0] || 0,
-      minor: parts[1] || 0,
-      patch: parts[2] || 0,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      description: "",
-      breaking: false
-    };
-  }
-  /**
-   * Create new version
-   */
-  createVersion(major, minor, patch, description, breaking = false) {
-    return {
-      major,
-      minor,
-      patch,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      description,
-      breaking
-    };
-  }
-  /**
-   * Convert version to string
-   */
-  versionToString(version) {
-    return `${version.major}.${version.minor}.${version.patch}`;
-  }
-  /**
-   * Get version metadata
-   */
-  getVersionMetadata(version) {
-    const history = this.versionHistory;
-    const currentIndex = history.findIndex(
-      (v) => this.versionToString(v) === this.versionToString(version)
-    );
-    return {
-      version,
-      previousVersion: currentIndex > 0 ? history[currentIndex - 1] : void 0,
-      changes: [version.description],
-      migrationsRequired: this.canMigrate(
-        this.currentVersion || version,
-        version
-      ) ? [this.versionToString(version)] : [],
-      rollbackPossible: currentIndex > 0
-    };
-  }
-  /**
-   * Get all registered versions
-   */
-  getAllVersions() {
-    return Array.from(this.versions.values()).sort(
-      (a, b) => this.compareVersions(a, b)
-    );
-  }
-  /**
-   * Clear all versions (for testing)
-   */
-  clear() {
-    this.versions.clear();
-    this.versionHistory = [];
-    this.compatibilityMatrix.clear();
-    this.currentVersion = null;
-  }
-};
-
 // src/versioning/MigrationEngine.ts
 var MigrationEngine = class {
   migrations = /* @__PURE__ */ new Map();
@@ -1323,489 +1099,6 @@ var MigrationTracker = class _MigrationTracker {
     return (hash >>> 0).toString(16).padStart(8, "0");
   }
 };
-var SyncCoordinator = class extends eventemitter3.EventEmitter {
-  nodes = /* @__PURE__ */ new Map();
-  sessions = /* @__PURE__ */ new Map();
-  syncEvents = [];
-  nodeHeartbeats = /* @__PURE__ */ new Map();
-  heartbeatInterval = null;
-  // Crypto support
-  cryptoProvider = null;
-  nodesByDID = /* @__PURE__ */ new Map();
-  // DID -> nodeId
-  constructor() {
-    super();
-  }
-  /**
-   * Configure cryptographic provider for authenticated sync
-   */
-  configureCrypto(provider) {
-    this.cryptoProvider = provider;
-    logger.debug("[SyncCoordinator] Crypto configured", {
-      initialized: provider.isInitialized()
-    });
-  }
-  /**
-   * Check if crypto is configured
-   */
-  isCryptoEnabled() {
-    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
-  }
-  /**
-   * Register a node with DID-based identity
-   */
-  async registerAuthenticatedNode(nodeInfo) {
-    const node = {
-      ...nodeInfo
-    };
-    this.nodes.set(node.id, node);
-    this.nodeHeartbeats.set(node.id, Date.now());
-    this.nodesByDID.set(nodeInfo.did, node.id);
-    if (this.cryptoProvider) {
-      await this.cryptoProvider.registerRemoteNode({
-        id: node.id,
-        did: nodeInfo.did,
-        publicSigningKey: nodeInfo.publicSigningKey,
-        publicEncryptionKey: nodeInfo.publicEncryptionKey
-      });
-    }
-    const event = {
-      type: "node-joined",
-      nodeId: node.id,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      data: { did: nodeInfo.did, authenticated: true }
-    };
-    this.syncEvents.push(event);
-    this.emit("node-joined", node);
-    logger.debug("[SyncCoordinator] Authenticated node registered", {
-      nodeId: node.id,
-      did: nodeInfo.did,
-      version: node.version
-    });
-    return node;
-  }
-  /**
-   * Get node by DID
-   */
-  getNodeByDID(did) {
-    const nodeId = this.nodesByDID.get(did);
-    if (!nodeId) return void 0;
-    return this.nodes.get(nodeId);
-  }
-  /**
-   * Get all authenticated nodes (nodes with DIDs)
-   */
-  getAuthenticatedNodes() {
-    return Array.from(this.nodes.values()).filter((n) => n.did);
-  }
-  /**
-   * Create an authenticated sync session with UCAN-based authorization
-   */
-  async createAuthenticatedSyncSession(initiatorDID, participantDIDs, options) {
-    const initiatorNodeId = this.nodesByDID.get(initiatorDID);
-    if (!initiatorNodeId) {
-      throw new Error(`Initiator node with DID ${initiatorDID} not found`);
-    }
-    const participantIds = [];
-    for (const did of participantDIDs) {
-      const nodeId = this.nodesByDID.get(did);
-      if (nodeId) {
-        participantIds.push(nodeId);
-      }
-    }
-    let sessionToken;
-    if (this.cryptoProvider && this.cryptoProvider.isInitialized()) {
-      const capabilities = (options?.requiredCapabilities || ["aeon:sync:read", "aeon:sync:write"]).map((cap) => ({ can: cap, with: "*" }));
-      if (participantDIDs.length > 0) {
-        sessionToken = await this.cryptoProvider.createUCAN(
-          participantDIDs[0],
-          capabilities,
-          { expirationSeconds: 3600 }
-          // 1 hour
-        );
-      }
-    }
-    const session = {
-      id: `sync-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-      initiatorId: initiatorNodeId,
-      participantIds,
-      status: "pending",
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      itemsSynced: 0,
-      itemsFailed: 0,
-      conflictsDetected: 0,
-      initiatorDID,
-      participantDIDs,
-      encryptionMode: options?.encryptionMode || "none",
-      requiredCapabilities: options?.requiredCapabilities,
-      sessionToken
-    };
-    this.sessions.set(session.id, session);
-    const event = {
-      type: "sync-started",
-      sessionId: session.id,
-      nodeId: initiatorNodeId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      data: {
-        authenticated: true,
-        initiatorDID,
-        participantCount: participantDIDs.length,
-        encryptionMode: session.encryptionMode
-      }
-    };
-    this.syncEvents.push(event);
-    this.emit("sync-started", session);
-    logger.debug("[SyncCoordinator] Authenticated sync session created", {
-      sessionId: session.id,
-      initiatorDID,
-      participants: participantDIDs.length,
-      encryptionMode: session.encryptionMode
-    });
-    return session;
-  }
-  /**
-   * Verify a node's UCAN capabilities for a session
-   */
-  async verifyNodeCapabilities(sessionId, nodeDID, token) {
-    if (!this.cryptoProvider) {
-      return { authorized: true };
-    }
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      return { authorized: false, error: `Session ${sessionId} not found` };
-    }
-    const result = await this.cryptoProvider.verifyUCAN(token, {
-      requiredCapabilities: session.requiredCapabilities?.map((cap) => ({
-        can: cap,
-        with: "*"
-      }))
-    });
-    if (!result.authorized) {
-      logger.warn("[SyncCoordinator] Node capability verification failed", {
-        sessionId,
-        nodeDID,
-        error: result.error
-      });
-    }
-    return result;
-  }
-  /**
-   * Register a node in the cluster
-   */
-  registerNode(node) {
-    this.nodes.set(node.id, node);
-    this.nodeHeartbeats.set(node.id, Date.now());
-    const event = {
-      type: "node-joined",
-      nodeId: node.id,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.syncEvents.push(event);
-    this.emit("node-joined", node);
-    logger.debug("[SyncCoordinator] Node registered", {
-      nodeId: node.id,
-      address: node.address,
-      version: node.version
-    });
-  }
-  /**
-   * Deregister a node from the cluster
-   */
-  deregisterNode(nodeId) {
-    const node = this.nodes.get(nodeId);
-    if (!node) {
-      throw new Error(`Node ${nodeId} not found`);
-    }
-    this.nodes.delete(nodeId);
-    this.nodeHeartbeats.delete(nodeId);
-    const event = {
-      type: "node-left",
-      nodeId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.syncEvents.push(event);
-    this.emit("node-left", node);
-    logger.debug("[SyncCoordinator] Node deregistered", { nodeId });
-  }
-  /**
-   * Create a new sync session
-   */
-  createSyncSession(initiatorId, participantIds) {
-    const node = this.nodes.get(initiatorId);
-    if (!node) {
-      throw new Error(`Initiator node ${initiatorId} not found`);
-    }
-    const session = {
-      id: `sync-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-      initiatorId,
-      participantIds,
-      status: "pending",
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      itemsSynced: 0,
-      itemsFailed: 0,
-      conflictsDetected: 0
-    };
-    this.sessions.set(session.id, session);
-    const event = {
-      type: "sync-started",
-      sessionId: session.id,
-      nodeId: initiatorId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.syncEvents.push(event);
-    this.emit("sync-started", session);
-    logger.debug("[SyncCoordinator] Sync session created", {
-      sessionId: session.id,
-      initiator: initiatorId,
-      participants: participantIds.length
-    });
-    return session;
-  }
-  /**
-   * Update sync session
-   */
-  updateSyncSession(sessionId, updates) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Session ${sessionId} not found`);
-    }
-    Object.assign(session, updates);
-    if (updates.status === "completed" || updates.status === "failed") {
-      session.endTime = (/* @__PURE__ */ new Date()).toISOString();
-      const event = {
-        type: "sync-completed",
-        sessionId,
-        nodeId: session.initiatorId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        data: { status: updates.status, itemsSynced: session.itemsSynced }
-      };
-      this.syncEvents.push(event);
-      this.emit("sync-completed", session);
-    }
-    logger.debug("[SyncCoordinator] Sync session updated", {
-      sessionId,
-      status: session.status,
-      itemsSynced: session.itemsSynced
-    });
-  }
-  /**
-   * Record a conflict during sync
-   */
-  recordConflict(sessionId, nodeId, conflictData) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.conflictsDetected++;
-      const event = {
-        type: "conflict-detected",
-        sessionId,
-        nodeId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        data: conflictData
-      };
-      this.syncEvents.push(event);
-      this.emit("conflict-detected", { session, nodeId, conflictData });
-      logger.debug("[SyncCoordinator] Conflict recorded", {
-        sessionId,
-        nodeId,
-        totalConflicts: session.conflictsDetected
-      });
-    }
-  }
-  /**
-   * Update node status
-   */
-  updateNodeStatus(nodeId, status) {
-    const node = this.nodes.get(nodeId);
-    if (!node) {
-      throw new Error(`Node ${nodeId} not found`);
-    }
-    node.status = status;
-    this.nodeHeartbeats.set(nodeId, Date.now());
-    logger.debug("[SyncCoordinator] Node status updated", {
-      nodeId,
-      status
-    });
-  }
-  /**
-   * Record heartbeat from node
-   */
-  recordHeartbeat(nodeId) {
-    const node = this.nodes.get(nodeId);
-    if (!node) {
-      return;
-    }
-    node.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
-    this.nodeHeartbeats.set(nodeId, Date.now());
-  }
-  /**
-   * Get all nodes
-   */
-  getNodes() {
-    return Array.from(this.nodes.values());
-  }
-  /**
-   * Get node by ID
-   */
-  getNode(nodeId) {
-    return this.nodes.get(nodeId);
-  }
-  /**
-   * Get online nodes
-   */
-  getOnlineNodes() {
-    return Array.from(this.nodes.values()).filter((n) => n.status === "online");
-  }
-  /**
-   * Get nodes by capability
-   */
-  getNodesByCapability(capability) {
-    return Array.from(this.nodes.values()).filter(
-      (n) => n.capabilities.includes(capability)
-    );
-  }
-  /**
-   * Get sync session
-   */
-  getSyncSession(sessionId) {
-    return this.sessions.get(sessionId);
-  }
-  /**
-   * Get all sync sessions
-   */
-  getAllSyncSessions() {
-    return Array.from(this.sessions.values());
-  }
-  /**
-   * Get active sync sessions
-   */
-  getActiveSyncSessions() {
-    return Array.from(this.sessions.values()).filter(
-      (s) => s.status === "active"
-    );
-  }
-  /**
-   * Get sessions for a node
-   */
-  getSessionsForNode(nodeId) {
-    return Array.from(this.sessions.values()).filter(
-      (s) => s.initiatorId === nodeId || s.participantIds.includes(nodeId)
-    );
-  }
-  /**
-   * Get sync statistics
-   */
-  getStatistics() {
-    const sessions = Array.from(this.sessions.values());
-    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
-    );
-    return {
-      totalNodes: this.nodes.size,
-      onlineNodes: this.getOnlineNodes().length,
-      offlineNodes: this.nodes.size - this.getOnlineNodes().length,
-      totalSessions: sessions.length,
-      activeSessions: active,
-      completedSessions: completed,
-      failedSessions: failed,
-      successRate: sessions.length > 0 ? completed / sessions.length * 100 : 0,
-      totalItemsSynced,
-      totalConflicts,
-      averageConflictsPerSession: sessions.length > 0 ? totalConflicts / sessions.length : 0
-    };
-  }
-  /**
-   * Get sync events
-   */
-  getSyncEvents(limit) {
-    const events = [...this.syncEvents];
-    if (limit) {
-      return events.slice(-limit);
-    }
-    return events;
-  }
-  /**
-   * Get sync events for session
-   */
-  getSessionEvents(sessionId) {
-    return this.syncEvents.filter((e) => e.sessionId === sessionId);
-  }
-  /**
-   * Check node health
-   */
-  getNodeHealth() {
-    const health = {};
-    for (const [nodeId, lastHeartbeat] of this.nodeHeartbeats) {
-      const now = Date.now();
-      const downtime = now - lastHeartbeat;
-      const isHealthy = downtime < 3e4;
-      health[nodeId] = {
-        isHealthy,
-        downtime
-      };
-    }
-    return health;
-  }
-  /**
-   * Start heartbeat monitoring
-   */
-  startHeartbeatMonitoring(interval = 5e3) {
-    if (this.heartbeatInterval) {
-      return;
-    }
-    this.heartbeatInterval = setInterval(() => {
-      const health = this.getNodeHealth();
-      for (const [nodeId, { isHealthy }] of Object.entries(health)) {
-        const node = this.nodes.get(nodeId);
-        if (!node) {
-          continue;
-        }
-        const newStatus = isHealthy ? "online" : "offline";
-        if (node.status !== newStatus) {
-          this.updateNodeStatus(nodeId, newStatus);
-        }
-      }
-    }, interval);
-    logger.debug("[SyncCoordinator] Heartbeat monitoring started", {
-      interval
-    });
-  }
-  /**
-   * Stop heartbeat monitoring
-   */
-  stopHeartbeatMonitoring() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-      logger.debug("[SyncCoordinator] Heartbeat monitoring stopped");
-    }
-  }
-  /**
-   * Clear all state (for testing)
-   */
-  clear() {
-    this.nodes.clear();
-    this.sessions.clear();
-    this.syncEvents = [];
-    this.nodeHeartbeats.clear();
-    this.nodesByDID.clear();
-    this.cryptoProvider = null;
-    this.stopHeartbeatMonitoring();
-  }
-  /**
-   * Get the crypto provider (for advanced usage)
-   */
-  getCryptoProvider() {
-    return this.cryptoProvider;
-  }
-};
 
 // src/distributed/ReplicationManager.ts
 var ReplicationManager = class _ReplicationManager {
@@ -5250,15 +4543,7 @@ var AdaptiveCompressionOptimizer = class {
     };
   }
 };
-var adaptiveOptimizerInstance = null;
-function getAdaptiveCompressionOptimizer() {
-  if (!adaptiveOptimizerInstance) {
-    adaptiveOptimizerInstance = new AdaptiveCompressionOptimizer();
-  }
-  return adaptiveOptimizerInstance;
-}
 function resetAdaptiveCompressionOptimizer() {
-  adaptiveOptimizerInstance = null;
 }
 var logger8 = getLogger();
 var AgentPresenceManager = class extends eventemitter3.EventEmitter {
@@ -5703,12 +4988,6 @@ var AgentPresenceManager = class extends eventemitter3.EventEmitter {
   }
 };
 var instances = /* @__PURE__ */ new Map();
-function getAgentPresenceManager(sessionId) {
-  if (!instances.has(sessionId)) {
-    instances.set(sessionId, new AgentPresenceManager(sessionId));
-  }
-  return instances.get(sessionId);
-}
 function clearAgentPresenceManager(sessionId) {
   const instance = instances.get(sessionId);
   if (instance) {
@@ -5810,6 +5089,34 @@ var NullCryptoProvider = class {
   }
 };
 
+// src/index.ts
+var Link = (() => {
+  throw new Error(
+    "Link: Stub called from @affectively/aeon. Import from @affectively/aeon-flux-react or mock in tests."
+  );
+});
+var useAeonPage = (() => {
+  throw new Error(
+    "useAeonPage: Stub called from @affectively/aeon. Import from @affectively/aeon-flux-react or mock in tests."
+  );
+});
+var getAdaptiveCompressionOptimizer = (() => {
+  throw new Error("getAdaptiveCompressionOptimizer: Stub");
+});
+var SchemaVersionManager2 = class {
+  constructor() {
+    throw new Error("SchemaVersionManager: Stub");
+  }
+};
+var getAgentPresenceManager = (() => {
+  throw new Error("getAgentPresenceManager: Stub");
+});
+var SyncCoordinator2 = class {
+  constructor() {
+    throw new Error("SyncCoordinator: Stub");
+  }
+};
+
 exports.AEON_CAPABILITIES = AEON_CAPABILITIES;
 exports.AdaptiveCompressionOptimizer = AdaptiveCompressionOptimizer;
 exports.AgentPresenceManager = AgentPresenceManager;
@@ -5820,15 +5127,16 @@ exports.DashStorageAdapter = DashStorageAdapter;
 exports.DataTransformer = DataTransformer;
 exports.DeltaSyncOptimizer = DeltaSyncOptimizer;
 exports.InMemoryStorageAdapter = InMemoryStorageAdapter;
+exports.Link = Link;
 exports.MigrationEngine = MigrationEngine;
 exports.MigrationTracker = MigrationTracker;
 exports.NullCryptoProvider = NullCryptoProvider;
 exports.OfflineOperationQueue = OfflineOperationQueue;
 exports.PrefetchingEngine = PrefetchingEngine;
 exports.ReplicationManager = ReplicationManager;
-exports.SchemaVersionManager = SchemaVersionManager;
+exports.SchemaVersionManager = SchemaVersionManager2;
 exports.StateReconciler = StateReconciler;
-exports.SyncCoordinator = SyncCoordinator;
+exports.SyncCoordinator = SyncCoordinator2;
 exports.SyncProtocol = SyncProtocol;
 exports.clearAgentPresenceManager = clearAgentPresenceManager;
 exports.createNamespacedLogger = createNamespacedLogger;
@@ -5850,5 +5158,6 @@ exports.resetLogger = resetLogger;
 exports.resetOfflineOperationQueue = resetOfflineOperationQueue;
 exports.resetPrefetchingEngine = resetPrefetchingEngine;
 exports.setLogger = setLogger;
+exports.useAeonPage = useAeonPage;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map