@affectively/aeon 1.0.0

package/dist/index.cjs

@@ -0,0 +1,4671 @@
+'use strict';
+
+var eventemitter3 = require('eventemitter3');
+
+// src/utils/logger.ts
+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 noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+function setLogger(logger9) {
+  currentLogger = logger9;
+}
+function resetLogger() {
+  currentLogger = consoleLogger;
+}
+function disableLogging() {
+  currentLogger = noopLogger;
+}
+function createNamespacedLogger(namespace) {
+  const logger9 = getLogger();
+  return {
+    debug: (...args) => logger9.debug(`[${namespace}]`, ...args),
+    info: (...args) => logger9.info(`[${namespace}]`, ...args),
+    warn: (...args) => logger9.warn(`[${namespace}]`, ...args),
+    error: (...args) => logger9.error(`[${namespace}]`, ...args)
+  };
+}
+var logger = {
+  debug: (...args) => getLogger().debug(...args),
+  info: (...args) => getLogger().info(...args),
+  warn: (...args) => getLogger().warn(...args),
+  error: (...args) => getLogger().error(...args)
+};
+
+// 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();
+  executedMigrations = [];
+  state = {
+    currentVersion: "1.0.0",
+    appliedMigrations: [],
+    failedMigrations: [],
+    lastMigrationTime: (/* @__PURE__ */ new Date()).toISOString(),
+    totalMigrationsRun: 0
+  };
+  /**
+   * Register a migration
+   */
+  registerMigration(migration) {
+    this.migrations.set(migration.id, migration);
+    logger.debug("[MigrationEngine] Migration registered", {
+      id: migration.id,
+      version: migration.version,
+      name: migration.name
+    });
+  }
+  /**
+   * Execute a migration
+   */
+  async executeMigration(migrationId, data) {
+    const migration = this.migrations.get(migrationId);
+    if (!migration) {
+      throw new Error(`Migration ${migrationId} not found`);
+    }
+    const startTime = Date.now();
+    const result = {
+      migrationId,
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: 0,
+      itemsAffected: 0,
+      errors: []
+    };
+    try {
+      logger.debug("[MigrationEngine] Executing migration", {
+        id: migrationId,
+        version: migration.version
+      });
+      migration.up(data);
+      result.success = true;
+      result.itemsAffected = Array.isArray(data) ? data.length : 1;
+      result.duration = Date.now() - startTime;
+      this.state.appliedMigrations.push(migrationId);
+      this.state.currentVersion = migration.version;
+      this.state.totalMigrationsRun++;
+      this.state.lastMigrationTime = result.timestamp;
+      this.executedMigrations.push(result);
+      logger.debug("[MigrationEngine] Migration executed successfully", {
+        id: migrationId,
+        duration: result.duration,
+        itemsAffected: result.itemsAffected
+      });
+      return result;
+    } catch (error) {
+      result.errors = [error instanceof Error ? error.message : String(error)];
+      this.state.failedMigrations.push(migrationId);
+      this.executedMigrations.push(result);
+      logger.error("[MigrationEngine] Migration failed", {
+        id: migrationId,
+        error: result.errors[0]
+      });
+      throw new Error(`Migration ${migrationId} failed: ${result.errors[0]}`);
+    }
+  }
+  /**
+   * Rollback a migration
+   */
+  async rollbackMigration(migrationId, data) {
+    const migration = this.migrations.get(migrationId);
+    if (!migration) {
+      throw new Error(`Migration ${migrationId} not found`);
+    }
+    if (!migration.down) {
+      throw new Error(`Migration ${migrationId} does not support rollback`);
+    }
+    const startTime = Date.now();
+    const result = {
+      migrationId,
+      success: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: 0,
+      itemsAffected: 0,
+      errors: []
+    };
+    try {
+      logger.debug("[MigrationEngine] Rolling back migration", {
+        id: migrationId,
+        version: migration.version
+      });
+      migration.down(data);
+      result.success = true;
+      result.itemsAffected = Array.isArray(data) ? data.length : 1;
+      result.duration = Date.now() - startTime;
+      this.state.appliedMigrations = this.state.appliedMigrations.filter(
+        (id) => id !== migrationId
+      );
+      this.executedMigrations.push(result);
+      logger.debug("[MigrationEngine] Migration rolled back", {
+        id: migrationId,
+        duration: result.duration
+      });
+      return result;
+    } catch (error) {
+      result.errors = [error instanceof Error ? error.message : String(error)];
+      this.executedMigrations.push(result);
+      logger.error("[MigrationEngine] Rollback failed", {
+        id: migrationId,
+        error: result.errors[0]
+      });
+      throw new Error(`Rollback for ${migrationId} failed: ${result.errors[0]}`);
+    }
+  }
+  /**
+   * Get migration state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get migration execution history
+   */
+  getExecutionHistory() {
+    return [...this.executedMigrations];
+  }
+  /**
+   * Get migration by ID
+   */
+  getMigration(migrationId) {
+    return this.migrations.get(migrationId);
+  }
+  /**
+   * Get all registered migrations
+   */
+  getAllMigrations() {
+    return Array.from(this.migrations.values());
+  }
+  /**
+   * Get applied migrations
+   */
+  getAppliedMigrations() {
+    return [...this.state.appliedMigrations];
+  }
+  /**
+   * Get failed migrations
+   */
+  getFailedMigrations() {
+    return [...this.state.failedMigrations];
+  }
+  /**
+   * Get pending migrations
+   */
+  getPendingMigrations() {
+    return this.getAllMigrations().filter(
+      (m) => !this.state.appliedMigrations.includes(m.id)
+    );
+  }
+  /**
+   * Get migration statistics
+   */
+  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);
+    return {
+      totalExecuted: this.executedMigrations.length,
+      successful,
+      failed,
+      successRate: this.executedMigrations.length > 0 ? successful / this.executedMigrations.length * 100 : 0,
+      totalDurationMs: totalDuration,
+      averageDurationMs: this.executedMigrations.length > 0 ? totalDuration / this.executedMigrations.length : 0,
+      totalAffected
+    };
+  }
+  /**
+   * Clear history (for testing)
+   */
+  clear() {
+    this.migrations.clear();
+    this.executedMigrations = [];
+    this.state = {
+      currentVersion: "1.0.0",
+      appliedMigrations: [],
+      failedMigrations: [],
+      lastMigrationTime: (/* @__PURE__ */ new Date()).toISOString(),
+      totalMigrationsRun: 0
+    };
+  }
+};
+
+// src/versioning/DataTransformer.ts
+var DataTransformer = class {
+  rules = /* @__PURE__ */ new Map();
+  transformationHistory = [];
+  /**
+   * Register a transformation rule
+   */
+  registerRule(rule) {
+    this.rules.set(rule.field, rule);
+    logger.debug("[DataTransformer] Rule registered", {
+      field: rule.field,
+      required: rule.required,
+      hasDefault: rule.defaultValue !== void 0
+    });
+  }
+  /**
+   * Transform a single field value
+   */
+  transformField(field, value) {
+    const rule = this.rules.get(field);
+    if (!rule) {
+      return value;
+    }
+    try {
+      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)}`);
+      }
+      return rule.defaultValue !== void 0 ? rule.defaultValue : value;
+    }
+  }
+  /**
+   * Transform a single object
+   */
+  transformObject(data) {
+    const transformed = {};
+    for (const [key, value] of Object.entries(data)) {
+      try {
+        transformed[key] = this.transformField(key, value);
+      } catch (error) {
+        logger.warn("[DataTransformer] Field transformation failed", {
+          field: key,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        const rule = this.rules.get(key);
+        if (!rule || !rule.required) {
+          transformed[key] = value;
+        }
+      }
+    }
+    return transformed;
+  }
+  /**
+   * Transform a collection of items
+   */
+  transformCollection(items) {
+    const startTime = Date.now();
+    const result = {
+      success: true,
+      itemsTransformed: 0,
+      itemsFailed: 0,
+      errors: [],
+      warnings: [],
+      duration: 0
+    };
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      try {
+        if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+          this.transformObject(item);
+          result.itemsTransformed++;
+        } else {
+          result.warnings.push(`Item ${i} is not a transformable object`);
+        }
+      } catch (error) {
+        result.errors.push({
+          item,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        result.itemsFailed++;
+      }
+    }
+    result.duration = Date.now() - startTime;
+    result.success = result.itemsFailed === 0;
+    this.transformationHistory.push(result);
+    logger.debug("[DataTransformer] Collection transformed", {
+      total: items.length,
+      transformed: result.itemsTransformed,
+      failed: result.itemsFailed,
+      duration: result.duration
+    });
+    return result;
+  }
+  /**
+   * Validate transformed data
+   */
+  validateTransformation(original, transformed) {
+    const issues = [];
+    if (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];
+      const trans = transformed[i];
+      if (!this.validateItem(orig, trans)) {
+        issues.push(`Item ${i} validation failed`);
+      }
+    }
+    return {
+      valid: issues.length === 0,
+      issues
+    };
+  }
+  /**
+   * Validate a single item transformation
+   */
+  validateItem(original, transformed) {
+    if (original === null || original === void 0) {
+      return true;
+    }
+    if (typeof original === "object" && typeof transformed !== "object") {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get transformation history
+   */
+  getTransformationHistory() {
+    return [...this.transformationHistory];
+  }
+  /**
+   * Get transformation statistics
+   */
+  getStatistics() {
+    const totalTransformed = this.transformationHistory.reduce(
+      (sum, r) => sum + r.itemsTransformed,
+      0
+    );
+    const totalFailed = this.transformationHistory.reduce(
+      (sum, r) => sum + r.itemsFailed,
+      0
+    );
+    const totalDuration = this.transformationHistory.reduce(
+      (sum, r) => sum + r.duration,
+      0
+    );
+    return {
+      totalBatches: this.transformationHistory.length,
+      totalTransformed,
+      totalFailed,
+      successRate: totalTransformed + totalFailed > 0 ? totalTransformed / (totalTransformed + totalFailed) * 100 : 0,
+      totalDurationMs: totalDuration,
+      averageBatchDurationMs: this.transformationHistory.length > 0 ? totalDuration / this.transformationHistory.length : 0
+    };
+  }
+  /**
+   * Get registered rules
+   */
+  getRules() {
+    return Array.from(this.rules.values());
+  }
+  /**
+   * Get rule for field
+   */
+  getRule(field) {
+    return this.rules.get(field);
+  }
+  /**
+   * Clear all rules (for testing)
+   */
+  clearRules() {
+    this.rules.clear();
+  }
+  /**
+   * Clear history (for testing)
+   */
+  clearHistory() {
+    this.transformationHistory = [];
+  }
+  /**
+   * Clear all state (for testing)
+   */
+  clear() {
+    this.clearRules();
+    this.clearHistory();
+  }
+};
+
+// src/versioning/MigrationTracker.ts
+var MigrationTracker = class {
+  migrations = [];
+  snapshots = /* @__PURE__ */ new Map();
+  /**
+   * Track a new migration
+   */
+  recordMigration(record) {
+    this.migrations.push({ ...record });
+    logger.debug("[MigrationTracker] Migration recorded", {
+      id: record.id,
+      migrationId: record.migrationId,
+      version: record.version,
+      status: record.status
+    });
+  }
+  /**
+   * Track migration with snapshot
+   */
+  trackMigration(migrationId, version, beforeHash, afterHash, itemCount, duration, itemsAffected, appliedBy = "system") {
+    const record = {
+      id: `${migrationId}-${Date.now()}`,
+      migrationId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version,
+      direction: "up",
+      status: "applied",
+      duration,
+      itemsAffected,
+      dataSnapshot: {
+        beforeHash,
+        afterHash,
+        itemCount
+      },
+      appliedBy
+    };
+    this.recordMigration(record);
+    this.snapshots.set(record.id, {
+      beforeHash,
+      afterHash,
+      itemCount
+    });
+  }
+  /**
+   * Get all migration records
+   */
+  getMigrations() {
+    return this.migrations.map((m) => ({ ...m }));
+  }
+  /**
+   * Get migrations for a specific version
+   */
+  getMigrationsForVersion(version) {
+    return this.migrations.filter((m) => m.version === version);
+  }
+  /**
+   * Get migration by ID
+   */
+  getMigration(id) {
+    return this.migrations.find((m) => m.id === id);
+  }
+  /**
+   * Check if can rollback
+   */
+  canRollback(fromVersion, toVersion) {
+    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;
+    }
+    if (toIndex >= fromIndex) {
+      return false;
+    }
+    for (let i = fromIndex; i > toIndex; i--) {
+      if (!this.migrations[i]?.dataSnapshot) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get rollback path
+   */
+  getRollbackPath(fromVersion, toVersion) {
+    const canRollback = this.canRollback(fromVersion, toVersion);
+    const path = [];
+    const affectedVersions = [];
+    let estimatedDuration = 0;
+    if (canRollback) {
+      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];
+        if (migration) {
+          path.push(migration.migrationId);
+          affectedVersions.push(migration.version);
+          estimatedDuration += migration.duration;
+        }
+      }
+    }
+    return {
+      path,
+      canRollback,
+      affectedVersions,
+      estimatedDuration
+    };
+  }
+  /**
+   * Get applied migrations
+   */
+  getAppliedMigrations() {
+    return this.migrations.filter((m) => m.status === "applied");
+  }
+  /**
+   * Get failed migrations
+   */
+  getFailedMigrations() {
+    return this.migrations.filter((m) => m.status === "failed");
+  }
+  /**
+   * Get pending migrations
+   */
+  getPendingMigrations() {
+    return this.migrations.filter((m) => m.status === "pending");
+  }
+  /**
+   * Get latest migration
+   */
+  getLatestMigration() {
+    return this.migrations[this.migrations.length - 1];
+  }
+  /**
+   * Get migration timeline
+   */
+  getTimeline() {
+    return this.migrations.map((m) => ({
+      timestamp: m.timestamp,
+      version: m.version,
+      status: m.status
+    }));
+  }
+  /**
+   * Get migration statistics
+   */
+  getStatistics() {
+    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);
+    return {
+      total: this.migrations.length,
+      applied,
+      failed,
+      pending,
+      rolledBack,
+      successRate: this.migrations.length > 0 ? applied / this.migrations.length * 100 : 0,
+      totalDurationMs: totalDuration,
+      averageDurationMs: this.migrations.length > 0 ? totalDuration / this.migrations.length : 0,
+      totalItemsAffected: totalAffected
+    };
+  }
+  /**
+   * Get audit trail
+   */
+  getAuditTrail(migrationId) {
+    const filtered = migrationId ? this.migrations.filter((m) => m.migrationId === migrationId) : this.migrations;
+    return filtered.map((m) => ({
+      id: m.id,
+      timestamp: m.timestamp,
+      migrationId: m.migrationId,
+      version: m.version,
+      status: m.status,
+      appliedBy: m.appliedBy,
+      duration: m.duration,
+      itemsAffected: m.itemsAffected,
+      error: m.errorMessage
+    }));
+  }
+  /**
+   * Get data snapshot for recovery
+   */
+  getSnapshot(recordId) {
+    return this.snapshots.get(recordId);
+  }
+  /**
+   * Update migration status
+   */
+  updateMigrationStatus(recordId, status, error) {
+    const migration = this.migrations.find((m) => m.id === recordId);
+    if (migration) {
+      migration.status = status;
+      if (error) {
+        migration.errorMessage = error;
+      }
+      logger.debug("[MigrationTracker] Migration status updated", {
+        recordId,
+        status,
+        hasError: !!error
+      });
+    }
+  }
+  /**
+   * Clear history (for testing)
+   */
+  clear() {
+    this.migrations = [];
+    this.snapshots.clear();
+  }
+  /**
+   * Get total migrations tracked
+   */
+  getTotalMigrations() {
+    return this.migrations.length;
+  }
+  /**
+   * Find migrations by time range
+   */
+  getMigrationsByTimeRange(startTime, endTime) {
+    const start = new Date(startTime).getTime();
+    const end = new Date(endTime).getTime();
+    return this.migrations.filter((m) => {
+      const time = new Date(m.timestamp).getTime();
+      return time >= start && time <= end;
+    });
+  }
+};
+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 {
+  replicas = /* @__PURE__ */ new Map();
+  policies = /* @__PURE__ */ new Map();
+  replicationEvents = [];
+  syncStatus = /* @__PURE__ */ new Map();
+  // Crypto support
+  cryptoProvider = null;
+  replicasByDID = /* @__PURE__ */ new Map();
+  // DID -> replicaId
+  /**
+   * Configure cryptographic provider for encrypted replication
+   */
+  configureCrypto(provider) {
+    this.cryptoProvider = provider;
+    logger.debug("[ReplicationManager] Crypto configured", {
+      initialized: provider.isInitialized()
+    });
+  }
+  /**
+   * Check if crypto is configured
+   */
+  isCryptoEnabled() {
+    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
+  }
+  /**
+   * Register an authenticated replica with DID
+   */
+  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);
+    logger.debug("[ReplicationManager] Authenticated replica registered", {
+      replicaId: replica.id,
+      did: replica.did,
+      encrypted
+    });
+    return authenticatedReplica;
+  }
+  /**
+   * Get replica by DID
+   */
+  getReplicaByDID(did) {
+    const replicaId = this.replicasByDID.get(did);
+    if (!replicaId) return void 0;
+    return this.replicas.get(replicaId);
+  }
+  /**
+   * Get all encrypted replicas
+   */
+  getEncryptedReplicas() {
+    return Array.from(this.replicas.values()).filter((r) => r.encrypted);
+  }
+  /**
+   * Encrypt data for replication to a specific replica
+   */
+  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 || void 0,
+      targetDID: targetReplicaDID,
+      encryptedAt: encrypted.encryptedAt
+    };
+  }
+  /**
+   * Decrypt data received from replication
+   */
+  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));
+  }
+  /**
+   * Create an encrypted replication policy
+   */
+  createEncryptedPolicy(name, replicationFactor, consistencyLevel, encryptionMode, options) {
+    const policy = {
+      id: `policy-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      name,
+      replicationFactor,
+      consistencyLevel,
+      syncInterval: options?.syncInterval || 1e3,
+      maxReplicationLag: options?.maxReplicationLag || 1e4,
+      encryptionMode,
+      requiredCapabilities: options?.requiredCapabilities
+    };
+    this.policies.set(policy.id, policy);
+    logger.debug("[ReplicationManager] Encrypted policy created", {
+      policyId: policy.id,
+      name,
+      replicationFactor,
+      encryptionMode
+    });
+    return policy;
+  }
+  /**
+   * Verify a replica's capabilities via UCAN
+   */
+  async verifyReplicaCapabilities(replicaDID, token, policyId) {
+    if (!this.cryptoProvider) {
+      return { authorized: true };
+    }
+    const policy = policyId ? this.policies.get(policyId) : void 0;
+    const result = await this.cryptoProvider.verifyUCAN(token, {
+      requiredCapabilities: policy?.requiredCapabilities?.map((cap) => ({
+        can: cap,
+        with: "*"
+      }))
+    });
+    if (!result.authorized) {
+      logger.warn("[ReplicationManager] Replica capability verification failed", {
+        replicaDID,
+        error: result.error
+      });
+    }
+    return result;
+  }
+  /**
+   * Register a replica
+   */
+  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);
+    logger.debug("[ReplicationManager] Replica registered", {
+      replicaId: replica.id,
+      nodeId: replica.nodeId,
+      status: replica.status
+    });
+  }
+  /**
+   * Remove a replica
+   */
+  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);
+    logger.debug("[ReplicationManager] Replica removed", { replicaId });
+  }
+  /**
+   * Create a replication policy
+   */
+  createPolicy(name, replicationFactor, consistencyLevel, syncInterval = 1e3, 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);
+    logger.debug("[ReplicationManager] Policy created", {
+      policyId: policy.id,
+      name,
+      replicationFactor,
+      consistencyLevel
+    });
+    return policy;
+  }
+  /**
+   * Update replica status
+   */
+  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++;
+      }
+    }
+    logger.debug("[ReplicationManager] Replica status updated", {
+      replicaId,
+      status,
+      lagBytes,
+      lagMillis
+    });
+  }
+  /**
+   * Get replicas for node
+   */
+  getReplicasForNode(nodeId) {
+    return Array.from(this.replicas.values()).filter((r) => r.nodeId === nodeId);
+  }
+  /**
+   * Get healthy replicas
+   */
+  getHealthyReplicas() {
+    return Array.from(this.replicas.values()).filter(
+      (r) => r.status === "secondary" || r.status === "primary"
+    );
+  }
+  /**
+   * Get syncing replicas
+   */
+  getSyncingReplicas() {
+    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");
+  }
+  /**
+   * Check replication health for policy
+   */
+  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
+    };
+  }
+  /**
+   * Get consistency level
+   */
+  getConsistencyLevel(policyId) {
+    const policy = this.policies.get(policyId);
+    if (!policy) {
+      return "eventual";
+    }
+    return policy.consistencyLevel;
+  }
+  /**
+   * Get replica
+   */
+  getReplica(replicaId) {
+    return this.replicas.get(replicaId);
+  }
+  /**
+   * Get all replicas
+   */
+  getAllReplicas() {
+    return Array.from(this.replicas.values());
+  }
+  /**
+   * Get policy
+   */
+  getPolicy(policyId) {
+    return this.policies.get(policyId);
+  }
+  /**
+   * Get all policies
+   */
+  getAllPolicies() {
+    return Array.from(this.policies.values());
+  }
+  /**
+   * Get replication statistics
+   */
+  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
+    };
+  }
+  /**
+   * Get replication events
+   */
+  getReplicationEvents(limit) {
+    const events = [...this.replicationEvents];
+    if (limit) {
+      return events.slice(-limit);
+    }
+    return events;
+  }
+  /**
+   * Get sync status for node
+   */
+  getSyncStatus(nodeId) {
+    return this.syncStatus.get(nodeId) || { synced: 0, failed: 0 };
+  }
+  /**
+   * Get replication lag distribution
+   */
+  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 <= 1e3) {
+        distribution["500-1000ms"]++;
+      } else {
+        distribution["1000+ms"]++;
+      }
+    }
+    return distribution;
+  }
+  /**
+   * Check if can satisfy consistency level
+   */
+  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;
+      // Always achievable
+      case "read-after-write":
+        return healthyCount >= 1;
+      case "strong":
+        return healthyCount >= policy.replicationFactor;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Clear all state (for testing)
+   */
+  clear() {
+    this.replicas.clear();
+    this.policies.clear();
+    this.replicationEvents = [];
+    this.syncStatus.clear();
+    this.replicasByDID.clear();
+    this.cryptoProvider = null;
+  }
+  /**
+   * Get the crypto provider (for advanced usage)
+   */
+  getCryptoProvider() {
+    return this.cryptoProvider;
+  }
+};
+
+// src/distributed/SyncProtocol.ts
+var SyncProtocol = class {
+  version = "1.0.0";
+  messageQueue = [];
+  messageMap = /* @__PURE__ */ new Map();
+  handshakes = /* @__PURE__ */ new Map();
+  protocolErrors = [];
+  messageCounter = 0;
+  // Crypto support
+  cryptoProvider = null;
+  cryptoConfig = null;
+  /**
+   * Configure cryptographic provider for authenticated/encrypted messages
+   */
+  configureCrypto(provider, config) {
+    this.cryptoProvider = provider;
+    this.cryptoConfig = {
+      encryptionMode: config?.encryptionMode ?? "none",
+      requireSignatures: config?.requireSignatures ?? false,
+      requireCapabilities: config?.requireCapabilities ?? false,
+      requiredCapabilities: config?.requiredCapabilities
+    };
+    logger.debug("[SyncProtocol] Crypto configured", {
+      encryptionMode: this.cryptoConfig.encryptionMode,
+      requireSignatures: this.cryptoConfig.requireSignatures,
+      requireCapabilities: this.cryptoConfig.requireCapabilities
+    });
+  }
+  /**
+   * Check if crypto is configured
+   */
+  isCryptoEnabled() {
+    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
+  }
+  /**
+   * Get crypto configuration
+   */
+  getCryptoConfig() {
+    return this.cryptoConfig ? { ...this.cryptoConfig } : null;
+  }
+  /**
+   * Get protocol version
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Create authenticated handshake message with DID and keys
+   */
+  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);
+    logger.debug("[SyncProtocol] Authenticated handshake created", {
+      messageId: message.messageId,
+      did: localDID,
+      capabilities: capabilities.length,
+      hasUCAN: !!ucan
+    });
+    return message;
+  }
+  /**
+   * Verify and process an authenticated handshake
+   */
+  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);
+      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) {
+        logger.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 || void 0,
+        requiredCapabilities: this.cryptoConfig.requiredCapabilities
+      });
+      if (!result.authorized) {
+        logger.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);
+    logger.debug("[SyncProtocol] Authenticated handshake verified", {
+      messageId: message.messageId,
+      did: handshake.did
+    });
+    return { valid: true, handshake };
+  }
+  /**
+   * Sign and optionally encrypt a message payload
+   */
+  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 || void 0,
+      receiverDID: message.receiver || void 0,
+      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;
+      logger.debug("[SyncProtocol] Message encrypted", {
+        messageId: message.messageId,
+        recipient: message.receiver
+      });
+    } else {
+      message.payload = payload;
+    }
+    return message;
+  }
+  /**
+   * Verify signature and optionally decrypt a 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));
+        logger.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 };
+  }
+  /**
+   * Create handshake message
+   */
+  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);
+    logger.debug("[SyncProtocol] Handshake message created", {
+      messageId: message.messageId,
+      nodeId,
+      capabilities: capabilities.length
+    });
+    return message;
+  }
+  /**
+   * Create sync request 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);
+    logger.debug("[SyncProtocol] Sync request created", {
+      messageId: message.messageId,
+      sessionId,
+      fromVersion,
+      toVersion
+    });
+    return message;
+  }
+  /**
+   * Create sync response 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);
+    logger.debug("[SyncProtocol] Sync response created", {
+      messageId: message.messageId,
+      sessionId,
+      itemCount: data.length,
+      hasMore
+    });
+    return message;
+  }
+  /**
+   * Create acknowledgement 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);
+    return message;
+  }
+  /**
+   * Create error 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()
+    });
+    logger.error("[SyncProtocol] Error message created", {
+      messageId: message.messageId,
+      errorCode: error.code,
+      recoverable: error.recoverable
+    });
+    return message;
+  }
+  /**
+   * Validate 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");
+    }
+    try {
+      new Date(message.timestamp);
+    } catch {
+      errors.push("Invalid timestamp format");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Serialize message
+   */
+  serializeMessage(message) {
+    try {
+      return JSON.stringify(message);
+    } catch (error) {
+      logger.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)}`);
+    }
+  }
+  /**
+   * Deserialize message
+   */
+  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) {
+      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)}`);
+    }
+  }
+  /**
+   * Process handshake
+   */
+  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);
+    logger.debug("[SyncProtocol] Handshake processed", {
+      nodeId,
+      protocolVersion: handshake.protocolVersion,
+      capabilities: handshake.capabilities.length
+    });
+    return handshake;
+  }
+  /**
+   * Get message
+   */
+  getMessage(messageId) {
+    return this.messageMap.get(messageId);
+  }
+  /**
+   * Get all messages
+   */
+  getAllMessages() {
+    return [...this.messageQueue];
+  }
+  /**
+   * Get messages by type
+   */
+  getMessagesByType(type) {
+    return this.messageQueue.filter((m) => m.type === type);
+  }
+  /**
+   * Get messages from sender
+   */
+  getMessagesFromSender(sender) {
+    return this.messageQueue.filter((m) => m.sender === sender);
+  }
+  /**
+   * Get pending messages
+   */
+  getPendingMessages(receiver) {
+    return this.messageQueue.filter((m) => m.receiver === receiver);
+  }
+  /**
+   * Get handshakes
+   */
+  getHandshakes() {
+    return new Map(this.handshakes);
+  }
+  /**
+   * Get protocol statistics
+   */
+  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
+    };
+  }
+  /**
+   * Get protocol errors
+   */
+  getErrors() {
+    return [...this.protocolErrors];
+  }
+  /**
+   * Generate message ID
+   */
+  generateMessageId() {
+    this.messageCounter++;
+    return `msg-${Date.now()}-${this.messageCounter}`;
+  }
+  /**
+   * Clear all state (for testing)
+   */
+  clear() {
+    this.messageQueue = [];
+    this.messageMap.clear();
+    this.handshakes.clear();
+    this.protocolErrors = [];
+    this.messageCounter = 0;
+    this.cryptoProvider = null;
+    this.cryptoConfig = null;
+  }
+  /**
+   * Get the crypto provider (for advanced usage)
+   */
+  getCryptoProvider() {
+    return this.cryptoProvider;
+  }
+};
+
+// src/distributed/StateReconciler.ts
+var StateReconciler = class {
+  stateVersions = /* @__PURE__ */ new Map();
+  reconciliationHistory = [];
+  cryptoProvider = null;
+  requireSignedVersions = false;
+  /**
+   * Configure cryptographic provider for signed state versions
+   */
+  configureCrypto(provider, requireSigned = false) {
+    this.cryptoProvider = provider;
+    this.requireSignedVersions = requireSigned;
+    logger.debug("[StateReconciler] Crypto configured", {
+      initialized: provider.isInitialized(),
+      requireSigned
+    });
+  }
+  /**
+   * Check if crypto is configured
+   */
+  isCryptoEnabled() {
+    return this.cryptoProvider !== null && this.cryptoProvider.isInitialized();
+  }
+  /**
+   * Record a signed state version with cryptographic verification
+   */
+  async recordSignedStateVersion(key, version, data) {
+    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 dataBytes = new TextEncoder().encode(JSON.stringify(data));
+    const hashBytes = await this.cryptoProvider.hash(dataBytes);
+    const hash = Array.from(hashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const versionData = { version, data, hash };
+    const signed = await this.cryptoProvider.signData(versionData);
+    const stateVersion = {
+      version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nodeId: localDID,
+      hash,
+      data,
+      signerDID: localDID,
+      signature: signed.signature,
+      signedAt: signed.signedAt
+    };
+    if (!this.stateVersions.has(key)) {
+      this.stateVersions.set(key, []);
+    }
+    this.stateVersions.get(key).push(stateVersion);
+    logger.debug("[StateReconciler] Signed state version recorded", {
+      key,
+      version,
+      signerDID: localDID,
+      hash: hash.slice(0, 16) + "..."
+    });
+    return stateVersion;
+  }
+  /**
+   * Verify a state version's signature
+   */
+  async verifyStateVersion(version) {
+    if (!version.signature || !version.signerDID) {
+      if (this.requireSignedVersions) {
+        return { valid: false, error: "Signature required but not present" };
+      }
+      const dataBytes = new TextEncoder().encode(JSON.stringify(version.data));
+      if (this.cryptoProvider) {
+        const hashBytes = await this.cryptoProvider.hash(dataBytes);
+        const computedHash = Array.from(hashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (computedHash !== version.hash) {
+          return { valid: false, error: "Hash mismatch" };
+        }
+      }
+      return { valid: true };
+    }
+    if (!this.cryptoProvider) {
+      return { valid: false, error: "Crypto provider not configured" };
+    }
+    const versionData = {
+      version: version.version,
+      data: version.data,
+      hash: version.hash
+    };
+    const signed = {
+      payload: versionData,
+      signature: version.signature,
+      signer: version.signerDID,
+      algorithm: "ES256",
+      signedAt: version.signedAt || Date.now()
+    };
+    const isValid = await this.cryptoProvider.verifySignedData(signed);
+    if (!isValid) {
+      return { valid: false, error: "Invalid signature" };
+    }
+    return { valid: true };
+  }
+  /**
+   * Reconcile with verification - only accept verified versions
+   */
+  async reconcileWithVerification(key, strategy = "last-write-wins") {
+    const versions = this.stateVersions.get(key) || [];
+    const verifiedVersions = [];
+    const verificationErrors = [];
+    for (const version of versions) {
+      const result2 = await this.verifyStateVersion(version);
+      if (result2.valid) {
+        verifiedVersions.push(version);
+      } else {
+        verificationErrors.push(
+          `Version ${version.version} from ${version.nodeId}: ${result2.error}`
+        );
+        logger.warn("[StateReconciler] Version verification failed", {
+          version: version.version,
+          nodeId: version.nodeId,
+          error: result2.error
+        });
+      }
+    }
+    if (verifiedVersions.length === 0) {
+      return {
+        success: false,
+        mergedState: null,
+        conflictsResolved: 0,
+        strategy,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        verificationErrors
+      };
+    }
+    let result;
+    switch (strategy) {
+      case "last-write-wins":
+        result = this.reconcileLastWriteWins(verifiedVersions);
+        break;
+      case "vector-clock":
+        result = this.reconcileVectorClock(verifiedVersions);
+        break;
+      case "majority-vote":
+        result = this.reconcileMajorityVote(verifiedVersions);
+        break;
+      default:
+        result = this.reconcileLastWriteWins(verifiedVersions);
+    }
+    return { ...result, verificationErrors };
+  }
+  /**
+   * Record a state version
+   */
+  recordStateVersion(key, version, timestamp, nodeId, hash, data) {
+    if (!this.stateVersions.has(key)) {
+      this.stateVersions.set(key, []);
+    }
+    const versions = this.stateVersions.get(key);
+    versions.push({
+      version,
+      timestamp,
+      nodeId,
+      hash,
+      data
+    });
+    logger.debug("[StateReconciler] State version recorded", {
+      key,
+      version,
+      nodeId,
+      hash
+    });
+  }
+  /**
+   * Detect conflicts in state versions
+   */
+  detectConflicts(key) {
+    const versions = this.stateVersions.get(key);
+    if (!versions || versions.length <= 1) {
+      return false;
+    }
+    const hashes = new Set(versions.map((v) => v.hash));
+    return hashes.size > 1;
+  }
+  /**
+   * Compare two states and generate diff
+   */
+  compareStates(state1, state2) {
+    const diff = {
+      added: {},
+      modified: {},
+      removed: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    for (const [key, value] of Object.entries(state2)) {
+      if (!(key in state1)) {
+        diff.added[key] = value;
+      } else if (JSON.stringify(state1[key]) !== JSON.stringify(value)) {
+        diff.modified[key] = { old: state1[key], new: value };
+      }
+    }
+    for (const key of Object.keys(state1)) {
+      if (!(key in state2)) {
+        diff.removed.push(key);
+      }
+    }
+    return diff;
+  }
+  /**
+   * Reconcile states using last-write-wins strategy
+   */
+  reconcileLastWriteWins(versions) {
+    if (versions.length === 0) {
+      throw new Error("No versions to reconcile");
+    }
+    const sorted = [...versions].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+    const latest = sorted[0];
+    const conflictsResolved = versions.length - 1;
+    const result = {
+      success: true,
+      mergedState: latest.data,
+      conflictsResolved,
+      strategy: "last-write-wins",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.reconciliationHistory.push(result);
+    logger.debug("[StateReconciler] State reconciled (last-write-wins)", {
+      winnerNode: latest.nodeId,
+      conflictsResolved
+    });
+    return result;
+  }
+  /**
+   * Reconcile states using vector clock strategy
+   */
+  reconcileVectorClock(versions) {
+    if (versions.length === 0) {
+      throw new Error("No versions to reconcile");
+    }
+    const sorted = [...versions].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+    const latest = sorted[0];
+    let conflictsResolved = 0;
+    for (const v of versions) {
+      const timeDiff = Math.abs(
+        new Date(v.timestamp).getTime() - new Date(latest.timestamp).getTime()
+      );
+      if (timeDiff > 100) {
+        conflictsResolved++;
+      }
+    }
+    const result = {
+      success: true,
+      mergedState: latest.data,
+      conflictsResolved,
+      strategy: "vector-clock",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.reconciliationHistory.push(result);
+    logger.debug("[StateReconciler] State reconciled (vector-clock)", {
+      winnerVersion: latest.version,
+      conflictsResolved
+    });
+    return result;
+  }
+  /**
+   * Reconcile states using majority vote strategy
+   */
+  reconcileMajorityVote(versions) {
+    if (versions.length === 0) {
+      throw new Error("No versions to reconcile");
+    }
+    const hashGroups = /* @__PURE__ */ new Map();
+    for (const version of versions) {
+      if (!hashGroups.has(version.hash)) {
+        hashGroups.set(version.hash, []);
+      }
+      hashGroups.get(version.hash).push(version);
+    }
+    let majorityVersion = null;
+    let maxCount = 0;
+    for (const [, versionGroup] of hashGroups) {
+      if (versionGroup.length > maxCount) {
+        maxCount = versionGroup.length;
+        majorityVersion = versionGroup[0];
+      }
+    }
+    if (!majorityVersion) {
+      majorityVersion = versions[0];
+    }
+    const conflictsResolved = versions.length - maxCount;
+    const result = {
+      success: true,
+      mergedState: majorityVersion.data,
+      conflictsResolved,
+      strategy: "majority-vote",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.reconciliationHistory.push(result);
+    logger.debug("[StateReconciler] State reconciled (majority-vote)", {
+      majorityCount: maxCount,
+      conflictsResolved
+    });
+    return result;
+  }
+  /**
+   * Merge multiple states
+   */
+  mergeStates(states) {
+    if (states.length === 0) {
+      return {};
+    }
+    if (states.length === 1) {
+      return states[0];
+    }
+    const merged = {};
+    for (const state of states) {
+      if (typeof state === "object" && state !== null) {
+        Object.assign(merged, state);
+      }
+    }
+    return merged;
+  }
+  /**
+   * Validate state after reconciliation
+   */
+  validateState(state) {
+    const errors = [];
+    if (state === null) {
+      errors.push("State is null");
+    } else if (state === void 0) {
+      errors.push("State is undefined");
+    } else if (typeof state !== "object") {
+      errors.push("State is not an object");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Get state versions for a key
+   */
+  getStateVersions(key) {
+    return this.stateVersions.get(key) || [];
+  }
+  /**
+   * Get all state versions
+   */
+  getAllStateVersions() {
+    const result = {};
+    for (const [key, versions] of this.stateVersions) {
+      result[key] = [...versions];
+    }
+    return result;
+  }
+  /**
+   * Get reconciliation history
+   */
+  getReconciliationHistory() {
+    return [...this.reconciliationHistory];
+  }
+  /**
+   * Get reconciliation statistics
+   */
+  getStatistics() {
+    const resolvedConflicts = this.reconciliationHistory.reduce(
+      (sum, r) => sum + r.conflictsResolved,
+      0
+    );
+    const strategyUsage = {};
+    for (const result of this.reconciliationHistory) {
+      strategyUsage[result.strategy] = (strategyUsage[result.strategy] || 0) + 1;
+    }
+    return {
+      totalReconciliations: this.reconciliationHistory.length,
+      successfulReconciliations: this.reconciliationHistory.filter((r) => r.success).length,
+      totalConflictsResolved: resolvedConflicts,
+      averageConflictsPerReconciliation: this.reconciliationHistory.length > 0 ? resolvedConflicts / this.reconciliationHistory.length : 0,
+      strategyUsage,
+      trackedKeys: this.stateVersions.size
+    };
+  }
+  /**
+   * Clear all state (for testing)
+   */
+  clear() {
+    this.stateVersions.clear();
+    this.reconciliationHistory = [];
+    this.cryptoProvider = null;
+    this.requireSignedVersions = false;
+  }
+  /**
+   * Get the crypto provider (for advanced usage)
+   */
+  getCryptoProvider() {
+    return this.cryptoProvider;
+  }
+};
+var logger2 = getLogger();
+var OfflineOperationQueue = class extends eventemitter3.EventEmitter {
+  queue = /* @__PURE__ */ new Map();
+  syncingIds = /* @__PURE__ */ new Set();
+  maxQueueSize = 1e3;
+  defaultMaxRetries = 3;
+  constructor(maxQueueSize = 1e3, defaultMaxRetries = 3) {
+    super();
+    this.maxQueueSize = maxQueueSize;
+    this.defaultMaxRetries = defaultMaxRetries;
+    logger2.debug("[OfflineOperationQueue] Initialized", {
+      maxQueueSize,
+      defaultMaxRetries
+    });
+  }
+  /**
+   * Add operation to the queue
+   */
+  enqueue(type, data, sessionId, priority = "normal", maxRetries) {
+    if (this.queue.size >= this.maxQueueSize) {
+      const oldest = this.findOldestLowPriority();
+      if (oldest) {
+        this.queue.delete(oldest.id);
+        logger2.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);
+    logger2.debug("[OfflineOperationQueue] Operation enqueued", {
+      id: operation.id,
+      type,
+      priority,
+      queueSize: this.queue.size
+    });
+    return operation;
+  }
+  /**
+   * Get next operations to sync (by priority)
+   */
+  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);
+  }
+  /**
+   * Mark operations as syncing
+   */
+  markSyncing(operationIds) {
+    for (const id of operationIds) {
+      const op = this.queue.get(id);
+      if (op) {
+        op.status = "syncing";
+        this.syncingIds.add(id);
+      }
+    }
+  }
+  /**
+   * Mark operation as synced
+   */
+  markSynced(operationId) {
+    const op = this.queue.get(operationId);
+    if (op) {
+      op.status = "synced";
+      this.syncingIds.delete(operationId);
+      this.emit("operation-synced", op);
+      setTimeout(() => {
+        this.queue.delete(operationId);
+        if (this.getPendingCount() === 0) {
+          this.emit("queue-empty");
+        }
+      }, 1e3);
+    }
+  }
+  /**
+   * Mark operation as failed
+   */
+  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);
+        logger2.error("[OfflineOperationQueue] Operation permanently failed", {
+          id: operationId,
+          retries: op.retryCount,
+          error: error.message
+        });
+      } else {
+        op.status = "pending";
+        logger2.warn("[OfflineOperationQueue] Operation failed, will retry", {
+          id: operationId,
+          retryCount: op.retryCount,
+          maxRetries: op.maxRetries
+        });
+      }
+    }
+  }
+  /**
+   * Get operation by ID
+   */
+  getOperation(operationId) {
+    return this.queue.get(operationId);
+  }
+  /**
+   * Get all pending operations
+   */
+  getPendingOperations() {
+    return Array.from(this.queue.values()).filter(
+      (op) => op.status === "pending"
+    );
+  }
+  /**
+   * Get pending count
+   */
+  getPendingCount() {
+    return Array.from(this.queue.values()).filter(
+      (op) => op.status === "pending"
+    ).length;
+  }
+  /**
+   * Get queue statistics
+   */
+  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 all operations
+   */
+  clear() {
+    this.queue.clear();
+    this.syncingIds.clear();
+    logger2.debug("[OfflineOperationQueue] Queue cleared");
+  }
+  /**
+   * Clear failed operations
+   */
+  clearFailed() {
+    for (const [id, op] of this.queue.entries()) {
+      if (op.status === "failed") {
+        this.queue.delete(id);
+      }
+    }
+  }
+  /**
+   * Retry failed operations
+   */
+  retryFailed() {
+    for (const op of this.queue.values()) {
+      if (op.status === "failed") {
+        op.status = "pending";
+        op.retryCount = 0;
+      }
+    }
+  }
+  /**
+   * Find oldest low-priority operation
+   */
+  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 queue for persistence
+   */
+  export() {
+    return Array.from(this.queue.values());
+  }
+  /**
+   * Import queue from persistence
+   */
+  import(operations) {
+    for (const op of operations) {
+      this.queue.set(op.id, op);
+    }
+    logger2.debug("[OfflineOperationQueue] Imported operations", {
+      count: operations.length
+    });
+  }
+};
+var offlineQueueInstance = null;
+function getOfflineOperationQueue() {
+  if (!offlineQueueInstance) {
+    offlineQueueInstance = new OfflineOperationQueue();
+  }
+  return offlineQueueInstance;
+}
+function resetOfflineOperationQueue() {
+  offlineQueueInstance = null;
+}
+
+// src/compression/CompressionEngine.ts
+var logger3 = getLogger();
+var CompressionEngine = class {
+  stats = {
+    totalCompressed: 0,
+    totalDecompressed: 0,
+    totalOriginalBytes: 0,
+    totalCompressedBytes: 0,
+    averageCompressionRatio: 0,
+    compressionTimeMs: 0,
+    decompressionTimeMs: 0
+  };
+  preferredAlgorithm = "gzip";
+  constructor(preferredAlgorithm = "gzip") {
+    this.preferredAlgorithm = preferredAlgorithm;
+    logger3.debug("[CompressionEngine] Initialized", {
+      algorithm: preferredAlgorithm,
+      supportsNative: this.supportsNativeCompression()
+    });
+  }
+  /**
+   * Check if native compression is available
+   */
+  supportsNativeCompression() {
+    return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
+  }
+  /**
+   * Compress data
+   */
+  async compress(data) {
+    const startTime = performance.now();
+    const inputData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const originalSize = inputData.byteLength;
+    let compressed;
+    let algorithm = this.preferredAlgorithm;
+    if (this.supportsNativeCompression()) {
+      try {
+        compressed = await this.compressNative(inputData, this.preferredAlgorithm);
+      } catch (error) {
+        logger3.warn("[CompressionEngine] Native compression failed, using fallback", error);
+        compressed = inputData;
+        algorithm = "none";
+      }
+    } else {
+      compressed = inputData;
+      algorithm = "none";
+    }
+    const compressionRatio = originalSize > 0 ? 1 - compressed.byteLength / originalSize : 0;
+    const batch = {
+      id: `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      compressed,
+      originalSize,
+      compressedSize: compressed.byteLength,
+      compressionRatio,
+      algorithm,
+      timestamp: Date.now()
+    };
+    const elapsed = performance.now() - startTime;
+    this.stats.totalCompressed++;
+    this.stats.totalOriginalBytes += originalSize;
+    this.stats.totalCompressedBytes += compressed.byteLength;
+    this.stats.compressionTimeMs += elapsed;
+    this.updateAverageRatio();
+    logger3.debug("[CompressionEngine] Compressed", {
+      original: originalSize,
+      compressed: compressed.byteLength,
+      ratio: (compressionRatio * 100).toFixed(1) + "%",
+      algorithm,
+      timeMs: elapsed.toFixed(2)
+    });
+    return batch;
+  }
+  /**
+   * Decompress data
+   */
+  async decompress(batch) {
+    const startTime = performance.now();
+    let decompressed;
+    if (batch.algorithm === "none") {
+      decompressed = batch.compressed;
+    } else if (this.supportsNativeCompression()) {
+      try {
+        decompressed = await this.decompressNative(
+          batch.compressed,
+          batch.algorithm
+        );
+      } catch (error) {
+        logger3.warn("[CompressionEngine] Native decompression failed", error);
+        throw error;
+      }
+    } else {
+      throw new Error("Native decompression not available");
+    }
+    const elapsed = performance.now() - startTime;
+    this.stats.totalDecompressed++;
+    this.stats.decompressionTimeMs += elapsed;
+    logger3.debug("[CompressionEngine] Decompressed", {
+      compressed: batch.compressedSize,
+      decompressed: decompressed.byteLength,
+      algorithm: batch.algorithm,
+      timeMs: elapsed.toFixed(2)
+    });
+    return decompressed;
+  }
+  /**
+   * Compress using native CompressionStream
+   */
+  async compressNative(data, algorithm) {
+    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.close();
+    const chunks = [];
+    let done = false;
+    while (!done) {
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
+      }
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  }
+  /**
+   * Decompress using native DecompressionStream
+   */
+  async decompressNative(data, algorithm) {
+    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.close();
+    const chunks = [];
+    let done = false;
+    while (!done) {
+      const result = await reader.read();
+      done = result.done;
+      if (result.value) {
+        chunks.push(result.value);
+      }
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return combined;
+  }
+  /**
+   * Split compressed batch into chunks for transmission
+   */
+  splitIntoChunks(batch, chunkSize = 64 * 1024) {
+    const chunks = [];
+    const data = batch.compressed;
+    const total = Math.ceil(data.byteLength / chunkSize);
+    for (let i = 0; i < total; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, data.byteLength);
+      const chunkData = data.slice(start, end);
+      chunks.push({
+        chunkId: `${batch.id}-chunk-${i}`,
+        batchId: batch.id,
+        data: chunkData,
+        index: i,
+        total,
+        checksum: this.simpleChecksum(chunkData)
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Reassemble chunks into compressed batch
+   */
+  reassembleChunks(chunks) {
+    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}`);
+    }
+    const totalLength = sorted.reduce((sum, chunk) => sum + chunk.data.length, 0);
+    const combined = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of sorted) {
+      combined.set(chunk.data, offset);
+      offset += chunk.data.length;
+    }
+    return combined;
+  }
+  /**
+   * Simple checksum for chunk verification
+   */
+  simpleChecksum(data) {
+    let hash = 0;
+    for (let i = 0; i < data.length; i++) {
+      hash = (hash << 5) - hash + data[i] | 0;
+    }
+    return hash.toString(16);
+  }
+  /**
+   * Update average compression ratio
+   */
+  updateAverageRatio() {
+    if (this.stats.totalOriginalBytes > 0) {
+      this.stats.averageCompressionRatio = 1 - this.stats.totalCompressedBytes / this.stats.totalOriginalBytes;
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalCompressed: 0,
+      totalDecompressed: 0,
+      totalOriginalBytes: 0,
+      totalCompressedBytes: 0,
+      averageCompressionRatio: 0,
+      compressionTimeMs: 0,
+      decompressionTimeMs: 0
+    };
+  }
+};
+var compressionEngineInstance = null;
+function getCompressionEngine() {
+  if (!compressionEngineInstance) {
+    compressionEngineInstance = new CompressionEngine();
+  }
+  return compressionEngineInstance;
+}
+function resetCompressionEngine() {
+  compressionEngineInstance = null;
+}
+
+// src/compression/DeltaSyncOptimizer.ts
+var logger4 = getLogger();
+var DeltaSyncOptimizer = class {
+  operationHistory = /* @__PURE__ */ new Map();
+  stats = {
+    totalOperations: 0,
+    totalFull: 0,
+    totalDelta: 0,
+    totalOriginalSize: 0,
+    totalDeltaSize: 0,
+    averageReductionPercent: 0,
+    lastSyncTime: 0,
+    fullOperationThreshold: 1e3
+    // Force full if delta > 1KB
+  };
+  constructor(fullOperationThreshold = 1e3) {
+    this.stats.fullOperationThreshold = fullOperationThreshold;
+    logger4.debug("[DeltaSyncOptimizer] Initialized", {
+      threshold: fullOperationThreshold
+    });
+  }
+  /**
+   * Compute delta for single operation
+   */
+  computeDelta(operation) {
+    const operationJson = JSON.stringify(operation);
+    const originalSize = new TextEncoder().encode(operationJson).byteLength;
+    const previous = this.operationHistory.get(operation.id);
+    if (!previous) {
+      const delta = {
+        id: `delta-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+        type: "full",
+        operationId: operation.id,
+        operationType: operation.type,
+        sessionId: operation.sessionId,
+        timestamp: Date.now(),
+        fullData: operation.data,
+        priority: operation.priority
+      };
+      this.stats.totalOperations++;
+      this.stats.totalFull++;
+      this.stats.totalOriginalSize += originalSize;
+      const deltaSize2 = new TextEncoder().encode(
+        JSON.stringify(delta)
+      ).byteLength;
+      this.stats.totalDeltaSize += deltaSize2;
+      this.operationHistory.set(operation.id, operation);
+      return delta;
+    }
+    const changes = {};
+    const changeMask = [];
+    let hasMeaningfulChanges = false;
+    for (const [key, value] of Object.entries(operation.data)) {
+      const oldValue = previous.data[key];
+      if (!this.deepEqual(value, oldValue)) {
+        changes[key] = value;
+        changeMask.push(key);
+        hasMeaningfulChanges = true;
+      }
+    }
+    for (const key of Object.keys(previous.data)) {
+      if (!(key in operation.data)) {
+        changes[key] = null;
+        changeMask.push(`${key}:deleted`);
+        hasMeaningfulChanges = true;
+      }
+    }
+    const deltaData = {
+      id: `delta-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      type: "delta",
+      operationId: operation.id,
+      operationType: operation.type,
+      sessionId: operation.sessionId,
+      timestamp: Date.now(),
+      changes: hasMeaningfulChanges ? changes : void 0,
+      changeMask: hasMeaningfulChanges ? changeMask : void 0,
+      priority: operation.priority
+    };
+    const deltaSize = new TextEncoder().encode(
+      JSON.stringify(deltaData)
+    ).byteLength;
+    const finalDelta = deltaSize > this.stats.fullOperationThreshold ? {
+      ...deltaData,
+      type: "full",
+      fullData: operation.data,
+      changes: void 0,
+      changeMask: void 0
+    } : deltaData;
+    this.stats.totalOperations++;
+    if (finalDelta.type === "full") {
+      this.stats.totalFull++;
+    } else {
+      this.stats.totalDelta++;
+    }
+    this.stats.totalOriginalSize += originalSize;
+    this.stats.totalDeltaSize += deltaSize;
+    this.operationHistory.set(operation.id, operation);
+    return finalDelta;
+  }
+  /**
+   * Compute deltas for batch of operations
+   */
+  computeBatchDeltas(operations) {
+    const deltas = operations.map((op) => this.computeDelta(op));
+    const totalOriginalSize = operations.reduce(
+      (sum, op) => sum + new TextEncoder().encode(JSON.stringify(op)).byteLength,
+      0
+    );
+    const totalDeltaSize = deltas.reduce(
+      (sum, delta) => sum + new TextEncoder().encode(JSON.stringify(delta)).byteLength,
+      0
+    );
+    const reductionPercent = totalOriginalSize > 0 ? Math.round(
+      (totalOriginalSize - totalDeltaSize) / totalOriginalSize * 100
+    ) : 0;
+    const batch = {
+      batchId: `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      operations: deltas,
+      timestamp: Date.now(),
+      totalOriginalSize,
+      totalDeltaSize,
+      reductionPercent
+    };
+    logger4.debug("[DeltaSyncOptimizer] Batch computed", {
+      operations: operations.length,
+      reduction: reductionPercent,
+      size: totalDeltaSize
+    });
+    return batch;
+  }
+  /**
+   * Decompress delta operation back to full operation
+   */
+  decompressDelta(delta) {
+    if (delta.type === "full") {
+      return {
+        id: delta.operationId,
+        type: delta.operationType,
+        sessionId: delta.sessionId,
+        data: delta.fullData || {},
+        status: "pending",
+        createdAt: delta.timestamp
+      };
+    }
+    const previous = this.operationHistory.get(delta.operationId);
+    if (!previous) {
+      logger4.warn("[DeltaSyncOptimizer] Cannot decompress - no history", {
+        operationId: delta.operationId
+      });
+      return {
+        id: delta.operationId,
+        type: delta.operationType,
+        sessionId: delta.sessionId,
+        data: delta.changes || {},
+        status: "pending",
+        createdAt: delta.timestamp
+      };
+    }
+    const reconstructed = {
+      ...previous,
+      data: {
+        ...previous.data,
+        ...delta.changes || {}
+      }
+    };
+    if (delta.changes) {
+      for (const [key, value] of Object.entries(delta.changes)) {
+        if (value === null) {
+          delete reconstructed.data[key];
+        }
+      }
+    }
+    return reconstructed;
+  }
+  /**
+   * Update history after successful sync
+   */
+  updateHistory(operations) {
+    for (const op of operations) {
+      this.operationHistory.set(op.id, op);
+    }
+    logger4.debug("[DeltaSyncOptimizer] History updated", {
+      count: operations.length,
+      totalHistorySize: this.operationHistory.size
+    });
+  }
+  /**
+   * Clear history for specific operations
+   */
+  clearHistory(operationIds) {
+    for (const id of operationIds) {
+      this.operationHistory.delete(id);
+    }
+    logger4.debug("[DeltaSyncOptimizer] History cleared", {
+      cleared: operationIds.length,
+      remaining: this.operationHistory.size
+    });
+  }
+  /**
+   * Get current performance statistics
+   */
+  getStats() {
+    if (this.stats.totalOperations > 0) {
+      this.stats.averageReductionPercent = Math.round(
+        (this.stats.totalOriginalSize - this.stats.totalDeltaSize) / this.stats.totalOriginalSize * 100
+      );
+    }
+    return { ...this.stats };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalOperations: 0,
+      totalFull: 0,
+      totalDelta: 0,
+      totalOriginalSize: 0,
+      totalDeltaSize: 0,
+      averageReductionPercent: 0,
+      lastSyncTime: 0,
+      fullOperationThreshold: this.stats.fullOperationThreshold
+    };
+    logger4.debug("[DeltaSyncOptimizer] Stats reset");
+  }
+  /**
+   * Set the full operation threshold
+   */
+  setFullOperationThreshold(bytes) {
+    this.stats.fullOperationThreshold = bytes;
+    logger4.debug("[DeltaSyncOptimizer] Threshold updated", { bytes });
+  }
+  /**
+   * Get history size for memory monitoring
+   */
+  getHistorySize() {
+    return this.operationHistory.size;
+  }
+  /**
+   * Get memory footprint estimate
+   */
+  getMemoryEstimate() {
+    let totalBytes = 0;
+    for (const op of this.operationHistory.values()) {
+      totalBytes += new TextEncoder().encode(JSON.stringify(op)).byteLength;
+    }
+    return totalBytes;
+  }
+  /**
+   * Deep equality check for nested objects
+   */
+  deepEqual(a, b) {
+    if (a === b) return true;
+    if (a == null || b == null) return false;
+    if (typeof a !== "object" || typeof b !== "object") return false;
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!this.deepEqual(aObj[key], bObj[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+var deltaSyncInstance = null;
+function getDeltaSyncOptimizer(threshold) {
+  if (!deltaSyncInstance) {
+    deltaSyncInstance = new DeltaSyncOptimizer(threshold);
+  }
+  return deltaSyncInstance;
+}
+function resetDeltaSyncOptimizer() {
+  deltaSyncInstance = null;
+}
+
+// src/optimization/PrefetchingEngine.ts
+var logger5 = getLogger();
+var PrefetchingEngine = class {
+  operationHistory = [];
+  patterns = /* @__PURE__ */ new Map();
+  prefetchCache = /* @__PURE__ */ new Map();
+  maxHistoryEntries = 1e3;
+  maxCachePerType = 5;
+  prefetchTTL = 5 * 60 * 1e3;
+  // 5 minutes
+  predictionThreshold = 0.3;
+  stats = {
+    totalPrefetched: 0,
+    totalHits: 0,
+    totalMisses: 0,
+    totalOverwrites: 0,
+    hitRatio: 0,
+    bandwidthSaved: 0,
+    patternsDetected: 0,
+    predictionAccuracy: 0
+  };
+  lastPredictionTime = 0;
+  predictionInterval = 30 * 1e3;
+  constructor() {
+    logger5.debug("[PrefetchingEngine] Initialized", {
+      ttl: this.prefetchTTL,
+      threshold: this.predictionThreshold
+    });
+  }
+  /**
+   * Record operation for pattern analysis
+   */
+  recordOperation(operationType, size) {
+    const now = Date.now();
+    this.operationHistory.push({
+      type: operationType,
+      timestamp: now,
+      size
+    });
+    if (this.operationHistory.length > this.maxHistoryEntries) {
+      this.operationHistory.shift();
+    }
+    if (Math.random() < 0.1) {
+      this.cleanExpiredPrefetches();
+    }
+    logger5.debug("[PrefetchingEngine] Operation recorded", {
+      type: operationType,
+      size,
+      historySize: this.operationHistory.length
+    });
+  }
+  /**
+   * Analyze patterns in operation history
+   */
+  analyzePatterns() {
+    if (this.operationHistory.length < 5) {
+      return;
+    }
+    const patterns = /* @__PURE__ */ new Map();
+    for (let length = 2; length <= 3; length++) {
+      for (let i = 0; i < this.operationHistory.length - length; i++) {
+        const sequence = this.operationHistory.slice(i, i + length).map((op) => op.type);
+        const key = sequence.join(" \u2192 ");
+        if (!patterns.has(key)) {
+          patterns.set(key, {
+            sequence,
+            frequency: 0,
+            probability: 0,
+            lastOccurred: 0,
+            avgIntervalMs: 0
+          });
+        }
+        const pattern = patterns.get(key);
+        pattern.frequency++;
+        pattern.lastOccurred = Date.now();
+      }
+    }
+    const totalSequences = this.operationHistory.length;
+    for (const [key, pattern] of patterns.entries()) {
+      pattern.probability = Math.min(1, pattern.frequency / totalSequences);
+    }
+    this.patterns = patterns;
+    this.stats.patternsDetected = patterns.size;
+    logger5.debug("[PrefetchingEngine] Patterns analyzed", {
+      patternsFound: patterns.size
+    });
+  }
+  /**
+   * Predict next operations
+   */
+  predictNextOperations(recentOperations) {
+    const now = Date.now();
+    if (now - this.lastPredictionTime > this.predictionInterval) {
+      this.analyzePatterns();
+      this.lastPredictionTime = now;
+    }
+    if (this.patterns.size === 0) {
+      return [];
+    }
+    const predictions = [];
+    const recentTypeSequence = recentOperations.slice(-3).map((op) => op.type).join(" \u2192 ");
+    for (const [key, pattern] of this.patterns.entries()) {
+      if (key.includes(recentTypeSequence)) {
+        const nextType = pattern.sequence[pattern.sequence.length - 1];
+        const prediction = {
+          operationType: nextType,
+          probability: pattern.probability,
+          reason: `Detected pattern: ${key}`,
+          shouldPrefetch: pattern.probability > this.predictionThreshold,
+          estimatedTimeMs: pattern.avgIntervalMs
+        };
+        predictions.push(prediction);
+      }
+    }
+    const deduped = Array.from(
+      new Map(predictions.map((p) => [p.operationType, p])).values()
+    ).sort((a, b) => b.probability - a.probability);
+    logger5.debug("[PrefetchingEngine] Predictions", {
+      predictions: deduped.slice(0, 3).map((p) => ({
+        type: p.operationType,
+        probability: (p.probability * 100).toFixed(1) + "%"
+      }))
+    });
+    return deduped;
+  }
+  /**
+   * Add prefetched batch
+   */
+  addPrefetchedBatch(operationType, compressed, originalSize) {
+    if (!this.prefetchCache.has(operationType)) {
+      this.prefetchCache.set(operationType, []);
+    }
+    const cache = this.prefetchCache.get(operationType);
+    if (cache.length >= this.maxCachePerType) {
+      const oldest = cache.shift();
+      if (oldest.hitCount === 0) {
+        this.stats.totalMisses++;
+      } else {
+        this.stats.totalOverwrites++;
+      }
+    }
+    const batch = {
+      id: `prefetch-${operationType}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      operationType,
+      compressed,
+      compressedSize: compressed.length,
+      originalSize,
+      compressionRatio: 1 - compressed.length / originalSize,
+      compressed_at: Date.now(),
+      created_at: Date.now(),
+      ttl: this.prefetchTTL,
+      expiresAt: Date.now() + this.prefetchTTL,
+      hitCount: 0,
+      missCount: 0
+    };
+    cache.push(batch);
+    this.stats.totalPrefetched++;
+    this.stats.bandwidthSaved += originalSize - compressed.length;
+    logger5.debug("[PrefetchingEngine] Prefetched batch added", {
+      type: operationType,
+      id: batch.id,
+      ratio: (batch.compressionRatio * 100).toFixed(1) + "%"
+    });
+    return batch;
+  }
+  /**
+   * Try to use prefetched batch
+   */
+  getPrefetchedBatch(operationType) {
+    const cache = this.prefetchCache.get(operationType);
+    if (!cache || cache.length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    for (let i = 0; i < cache.length; i++) {
+      const batch = cache[i];
+      if (batch.expiresAt > now) {
+        batch.hitCount++;
+        this.stats.totalHits++;
+        this.updatePredictionAccuracy(true);
+        logger5.debug("[PrefetchingEngine] Prefetch hit", {
+          type: operationType,
+          id: batch.id
+        });
+        return batch;
+      } else {
+        cache.splice(i, 1);
+        i--;
+        batch.missCount++;
+        this.stats.totalMisses++;
+        this.updatePredictionAccuracy(false);
+      }
+    }
+    return null;
+  }
+  /**
+   * Update prediction accuracy metric
+   */
+  updatePredictionAccuracy(hit) {
+    const total = this.stats.totalHits + this.stats.totalMisses;
+    if (total === 0) return;
+    this.stats.predictionAccuracy = this.stats.totalHits / total;
+  }
+  /**
+   * Clean expired prefetches
+   */
+  cleanExpiredPrefetches() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [type, cache] of this.prefetchCache.entries()) {
+      for (let i = cache.length - 1; i >= 0; i--) {
+        if (cache[i].expiresAt < now) {
+          const batch = cache.splice(i, 1)[0];
+          if (batch.hitCount === 0) {
+            this.stats.totalMisses++;
+          }
+          cleanedCount++;
+        }
+      }
+      if (cache.length === 0) {
+        this.prefetchCache.delete(type);
+      }
+    }
+    if (cleanedCount > 0) {
+      logger5.debug("[PrefetchingEngine] Cleaned expired prefetches", {
+        count: cleanedCount
+      });
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const total = this.stats.totalHits + this.stats.totalMisses;
+    this.stats.hitRatio = total > 0 ? this.stats.totalHits / total : 0;
+    return { ...this.stats };
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this.operationHistory = [];
+    this.patterns.clear();
+    this.prefetchCache.clear();
+    this.stats = {
+      totalPrefetched: 0,
+      totalHits: 0,
+      totalMisses: 0,
+      totalOverwrites: 0,
+      hitRatio: 0,
+      bandwidthSaved: 0,
+      patternsDetected: 0,
+      predictionAccuracy: 0
+    };
+    logger5.debug("[PrefetchingEngine] Cleared all caches");
+  }
+};
+var prefetchingEngineInstance = null;
+function getPrefetchingEngine() {
+  if (!prefetchingEngineInstance) {
+    prefetchingEngineInstance = new PrefetchingEngine();
+  }
+  return prefetchingEngineInstance;
+}
+function resetPrefetchingEngine() {
+  prefetchingEngineInstance = null;
+}
+
+// src/optimization/BatchTimingOptimizer.ts
+var logger6 = getLogger();
+var BatchTimingOptimizer = class {
+  networkHistory = [];
+  activityHistory = [];
+  stats = {
+    totalBatches: 0,
+    immediateDeliveries: 0,
+    deferredBatches: 0,
+    averageWaitTimeMs: 0,
+    averageDeliveryTimeMs: 0,
+    networkWindowsUsed: 0,
+    congestionAvoided: 0,
+    userFocusedOptimizations: 0
+  };
+  lastActivityTime = Date.now();
+  isUserActive = true;
+  congestionDetectionWindow = 60 * 1e3;
+  optimalBatchSize = 50 * 1024;
+  constructor() {
+    logger6.debug("[BatchTimingOptimizer] Initialized", {
+      congestionWindow: this.congestionDetectionWindow,
+      optimalBatchSize: this.optimalBatchSize
+    });
+  }
+  /**
+   * Record network measurement
+   */
+  recordNetworkMeasurement(latencyMs, bandwidthMbps) {
+    const quality = this.assessNetworkQuality(latencyMs, bandwidthMbps);
+    this.networkHistory.push({
+      latencyMs,
+      bandwidthMbps,
+      timestamp: Date.now(),
+      quality
+    });
+    if (this.networkHistory.length > 100) {
+      this.networkHistory.shift();
+    }
+    this.stats.networkWindowsUsed++;
+    logger6.debug("[BatchTimingOptimizer] Network measured", {
+      latency: latencyMs + "ms",
+      bandwidth: bandwidthMbps.toFixed(1) + " Mbps",
+      quality
+    });
+  }
+  /**
+   * Assess network quality
+   */
+  assessNetworkQuality(latencyMs, bandwidthMbps) {
+    if (latencyMs < 20 && bandwidthMbps > 10) return "excellent";
+    if (latencyMs < 50 && bandwidthMbps > 5) return "good";
+    if (latencyMs < 100 && bandwidthMbps > 2) return "fair";
+    return "poor";
+  }
+  /**
+   * Detect congestion in network
+   */
+  detectCongestion() {
+    const recentMeasurements = this.networkHistory.filter(
+      (m) => Date.now() - m.timestamp < this.congestionDetectionWindow
+    );
+    if (recentMeasurements.length < 3) {
+      return 0;
+    }
+    const poorCount = recentMeasurements.filter(
+      (m) => m.quality === "poor"
+    ).length;
+    return poorCount / recentMeasurements.length;
+  }
+  /**
+   * Find next optimal network window
+   */
+  findOptimalWindow() {
+    const now = Date.now();
+    const recentMeasurements = this.networkHistory.slice(-20);
+    if (recentMeasurements.length === 0) {
+      return {
+        startTime: now,
+        endTime: now + 1e3,
+        expectedDurationMs: 1e3,
+        latencyMs: 50,
+        bandwidthMbps: 5,
+        quality: "good",
+        isStable: true,
+        congestionLevel: 0,
+        recommendedBatchSize: this.optimalBatchSize
+      };
+    }
+    const avgLatency = recentMeasurements.reduce((sum, m) => sum + m.latencyMs, 0) / recentMeasurements.length;
+    const avgBandwidth = recentMeasurements.reduce((sum, m) => sum + m.bandwidthMbps, 0) / recentMeasurements.length;
+    const latencyVariance = Math.sqrt(
+      recentMeasurements.reduce(
+        (sum, m) => sum + Math.pow(m.latencyMs - avgLatency, 2),
+        0
+      ) / recentMeasurements.length
+    ) / avgLatency;
+    const isStable = latencyVariance < 0.2;
+    const congestionLevel = this.detectCongestion();
+    const quality = this.assessNetworkQuality(avgLatency, avgBandwidth);
+    const recommendedBatchSize = Math.max(
+      10 * 1024,
+      Math.min(500 * 1024, avgBandwidth * 1024 * 100 / 8)
+    );
+    return {
+      startTime: now,
+      endTime: now + (isStable ? 30 * 1e3 : 10 * 1e3),
+      expectedDurationMs: isStable ? 30 * 1e3 : 10 * 1e3,
+      latencyMs: avgLatency,
+      bandwidthMbps: avgBandwidth,
+      quality,
+      isStable,
+      congestionLevel,
+      recommendedBatchSize
+    };
+  }
+  /**
+   * Get scheduling decision for a batch
+   */
+  getSchedulingDecision(batchSize, batchPriority = "normal", isUserTriggered = false) {
+    const now = Date.now();
+    const currentWindow = this.findOptimalWindow();
+    const congestionLevel = this.detectCongestion();
+    let shouldSendNow = false;
+    let recommendedDelay = 0;
+    let reason = "";
+    let priority = batchPriority;
+    if (priority === "critical") {
+      shouldSendNow = true;
+      reason = "Critical operation (bypass optimization)";
+    } else if (isUserTriggered && this.isUserActive) {
+      shouldSendNow = true;
+      reason = "User-triggered operation";
+      priority = "high";
+    } else if (currentWindow.quality === "excellent" || currentWindow.quality === "good") {
+      if (congestionLevel < 0.3) {
+        shouldSendNow = true;
+        reason = "Good network conditions";
+      } else {
+        shouldSendNow = true;
+        reason = "Good network despite some congestion";
+        recommendedDelay = 1e3 + Math.random() * 2e3;
+      }
+    } else if (currentWindow.quality === "fair") {
+      if (priority === "high") {
+        shouldSendNow = true;
+        reason = "High priority despite fair network";
+      } else {
+        shouldSendNow = false;
+        reason = "Fair network: waiting for better window";
+        recommendedDelay = 30 * 1e3 + Math.random() * 30 * 1e3;
+      }
+    } else {
+      shouldSendNow = false;
+      reason = "Poor network conditions: deferring";
+      if (priority === "high") {
+        recommendedDelay = 60 * 1e3 + Math.random() * 30 * 1e3;
+      } else {
+        recommendedDelay = 120 * 1e3 + Math.random() * 60 * 1e3;
+      }
+    }
+    const estimatedDeliveryMs = batchSize / (currentWindow.bandwidthMbps * 1024 * 1024 / 8) * 1e3 + currentWindow.latencyMs + recommendedDelay;
+    const decision = {
+      shouldSendNow,
+      nextOptimalWindowMs: now + recommendedDelay,
+      recommendedDelay,
+      reason,
+      priority,
+      estimatedDeliveryMs
+    };
+    logger6.debug("[BatchTimingOptimizer] Scheduling decision", {
+      size: (batchSize / 1024).toFixed(1) + " KB",
+      shouldSendNow,
+      delay: recommendedDelay + "ms",
+      reason
+    });
+    return decision;
+  }
+  /**
+   * Apply scheduling and update stats
+   */
+  applyScheduling(batchSize, sendNow, actualDelay) {
+    this.stats.totalBatches++;
+    if (sendNow) {
+      this.stats.immediateDeliveries++;
+    } else {
+      this.stats.deferredBatches++;
+    }
+    const totalWait = this.stats.averageWaitTimeMs * (this.stats.totalBatches - 1) + actualDelay;
+    this.stats.averageWaitTimeMs = totalWait / this.stats.totalBatches;
+    if (this.detectCongestion() > 0.3 && !sendNow) {
+      this.stats.congestionAvoided++;
+    }
+    if (this.isUserActive) {
+      this.stats.userFocusedOptimizations++;
+    }
+    this.stats.networkWindowsUsed++;
+  }
+  /**
+   * Get optimal batch size recommendation
+   */
+  getOptimalBatchSize() {
+    const window = this.findOptimalWindow();
+    return window.recommendedBatchSize;
+  }
+  /**
+   * Get current network window
+   */
+  getCurrentNetworkWindow() {
+    return this.findOptimalWindow();
+  }
+  /**
+   * Set user activity state
+   */
+  setUserActive(active) {
+    this.isUserActive = active;
+    if (active) {
+      this.lastActivityTime = Date.now();
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Clear history
+   */
+  clear() {
+    this.networkHistory = [];
+    this.activityHistory = [];
+    this.stats = {
+      totalBatches: 0,
+      immediateDeliveries: 0,
+      deferredBatches: 0,
+      averageWaitTimeMs: 0,
+      averageDeliveryTimeMs: 0,
+      networkWindowsUsed: 0,
+      congestionAvoided: 0,
+      userFocusedOptimizations: 0
+    };
+  }
+};
+var batchTimingOptimizerInstance = null;
+function getBatchTimingOptimizer() {
+  if (!batchTimingOptimizerInstance) {
+    batchTimingOptimizerInstance = new BatchTimingOptimizer();
+  }
+  return batchTimingOptimizerInstance;
+}
+function resetBatchTimingOptimizer() {
+  batchTimingOptimizerInstance = null;
+}
+
+// src/optimization/AdaptiveCompressionOptimizer.ts
+var logger7 = getLogger();
+var AdaptiveCompressionOptimizer = class {
+  currentLevel = 6;
+  networkProfile = {
+    estimatedSpeedKbps: 5e3,
+    latencyMs: 50,
+    isOnline: true,
+    isWifi: false,
+    isFast: true,
+    isSlow: false,
+    isEmpty: false
+  };
+  deviceProfile = {
+    cpuCores: 4,
+    cpuUtilization: 0.3,
+    memoryAvailableMB: 512,
+    memoryTotalMB: 1024,
+    isConstrained: false,
+    isPremium: false,
+    supportsWebWorkers: true,
+    supportsWebAssembly: true
+  };
+  compressionHistory = [];
+  stats = {
+    currentLevel: 6,
+    averageCompressionMs: 10,
+    averageRatio: 0.85,
+    levelsUsed: /* @__PURE__ */ new Set([6]),
+    adjustmentCount: 0,
+    totalBatches: 0,
+    networkCondition: "normal"
+  };
+  constructor() {
+    logger7.debug("[AdaptiveCompressionOptimizer] Initialized", {
+      level: this.currentLevel
+    });
+  }
+  /**
+   * Update network conditions
+   */
+  updateNetworkConditions(speedKbps, latencyMs, isOnline) {
+    this.networkProfile.estimatedSpeedKbps = speedKbps;
+    if (latencyMs !== void 0) {
+      this.networkProfile.latencyMs = latencyMs;
+    }
+    if (isOnline !== void 0) {
+      this.networkProfile.isOnline = isOnline;
+    }
+    this.networkProfile.isFast = speedKbps > 5e3;
+    this.networkProfile.isSlow = speedKbps < 1e3;
+    this.networkProfile.isEmpty = speedKbps < 100;
+    if (isOnline === false) {
+      this.stats.networkCondition = "offline";
+    } else if (this.networkProfile.isSlow) {
+      this.stats.networkCondition = "slow";
+    } else if (this.networkProfile.isFast) {
+      this.stats.networkCondition = "fast";
+    } else {
+      this.stats.networkCondition = "normal";
+    }
+    logger7.debug("[AdaptiveCompressionOptimizer] Network updated", {
+      speedKbps,
+      condition: this.stats.networkCondition
+    });
+  }
+  /**
+   * Update device resource usage
+   */
+  updateDeviceResources(cpuUtilization, memoryAvailableMB) {
+    this.deviceProfile.cpuUtilization = Math.max(0, Math.min(1, cpuUtilization));
+    this.deviceProfile.memoryAvailableMB = memoryAvailableMB;
+    this.deviceProfile.isConstrained = memoryAvailableMB < 512;
+    this.deviceProfile.isPremium = memoryAvailableMB > 2048;
+    logger7.debug("[AdaptiveCompressionOptimizer] Device resources updated", {
+      cpuUtilization: (cpuUtilization * 100).toFixed(1) + "%",
+      memoryAvailableMB
+    });
+  }
+  /**
+   * Record compression performance
+   */
+  recordCompressionPerformance(level, compressionMs, ratio) {
+    this.compressionHistory.push({
+      level,
+      ratio,
+      timeMs: compressionMs,
+      timestamp: Date.now()
+    });
+    if (this.compressionHistory.length > 100) {
+      this.compressionHistory.shift();
+    }
+    this.stats.totalBatches++;
+    this.stats.averageCompressionMs = this.compressionHistory.reduce((sum, h) => sum + h.timeMs, 0) / this.compressionHistory.length;
+    this.stats.averageRatio = this.compressionHistory.reduce((sum, h) => sum + h.ratio, 0) / this.compressionHistory.length;
+  }
+  /**
+   * Get compression recommendation based on conditions
+   */
+  getRecommendedLevel() {
+    const networkFactor = this.calculateNetworkFactor();
+    const deviceFactor = this.calculateDeviceFactor();
+    const combinedFactor = (networkFactor + deviceFactor) / 2;
+    const recommendedLevel = Math.max(
+      1,
+      Math.min(9, Math.round(combinedFactor * 9))
+    );
+    const estimatedCompressionMs = this.estimateCompressionTime(recommendedLevel);
+    const estimatedRatio = this.estimateCompressionRatio(recommendedLevel);
+    let reason = "";
+    if (networkFactor < 0.3 && deviceFactor < 0.3) {
+      reason = "Slow network + constrained device: using level 1-2 (fast)";
+    } else if (networkFactor > 0.7 && deviceFactor > 0.7) {
+      reason = "Fast network + premium device: using level 8-9 (best compression)";
+    } else if (networkFactor > 0.7) {
+      reason = "Fast network: prioritizing compression ratio";
+    } else if (deviceFactor < 0.3) {
+      reason = "Constrained device: prioritizing speed";
+    } else {
+      reason = "Normal conditions: balanced compression level";
+    }
+    const recommendation = {
+      recommendedLevel,
+      reason,
+      confidence: this.compressionHistory.length > 10 ? 0.9 : 0.5,
+      estimatedCompressionMs,
+      estimatedRatio,
+      networkFactor,
+      deviceFactor
+    };
+    logger7.debug("[AdaptiveCompressionOptimizer] Recommendation", recommendation);
+    return recommendation;
+  }
+  /**
+   * Calculate network factor (0-1)
+   */
+  calculateNetworkFactor() {
+    if (!this.networkProfile.isOnline) return 0;
+    const speedMbps = this.networkProfile.estimatedSpeedKbps / 1e3;
+    if (speedMbps < 0.1) return 0;
+    if (speedMbps < 1) return 0.1 + speedMbps / 1 * 0.2;
+    if (speedMbps < 5) return 0.3 + (speedMbps - 1) / 4 * 0.3;
+    if (speedMbps < 20) return 0.6 + (speedMbps - 5) / 15 * 0.3;
+    return Math.min(1, 0.9 + (speedMbps - 20) / 200);
+  }
+  /**
+   * Calculate device factor (0-1)
+   */
+  calculateDeviceFactor() {
+    let factor = 0.5;
+    if (this.deviceProfile.isPremium) {
+      factor = 0.8;
+    } else if (this.deviceProfile.isConstrained) {
+      factor = 0.2;
+    }
+    if (this.deviceProfile.cpuUtilization > 0.8) {
+      factor *= 0.7;
+    } else if (this.deviceProfile.cpuUtilization < 0.2) {
+      factor *= 1.1;
+    }
+    if (this.deviceProfile.supportsWebAssembly) {
+      factor = Math.min(1, factor + 0.1);
+    }
+    return Math.max(0, Math.min(1, factor));
+  }
+  /**
+   * Estimate compression time for a level (in ms)
+   */
+  estimateCompressionTime(level) {
+    return Math.max(1, level * 2.5);
+  }
+  /**
+   * Estimate compression ratio for a level
+   */
+  estimateCompressionRatio(level) {
+    return 0.6 + level / 9 * 0.3;
+  }
+  /**
+   * Apply recommendation and get new level
+   */
+  applyRecommendation() {
+    const recommendation = this.getRecommendedLevel();
+    const oldLevel = this.currentLevel;
+    const shouldChange = recommendation.confidence > 0.7 || Math.abs(recommendation.recommendedLevel - oldLevel) > 2;
+    if (shouldChange) {
+      this.currentLevel = recommendation.recommendedLevel;
+      this.stats.levelsUsed.add(this.currentLevel);
+      if (oldLevel !== this.currentLevel) {
+        this.stats.adjustmentCount++;
+        logger7.debug("[AdaptiveCompressionOptimizer] Level adjusted", {
+          from: oldLevel,
+          to: this.currentLevel,
+          reason: recommendation.reason
+        });
+      }
+    }
+    this.stats.currentLevel = this.currentLevel;
+    return this.currentLevel;
+  }
+  /**
+   * Get current level
+   */
+  getCurrentLevel() {
+    return this.currentLevel;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Get detailed analysis
+   */
+  getDetailedAnalysis() {
+    return {
+      stats: this.stats,
+      network: this.networkProfile,
+      device: this.deviceProfile,
+      recommendation: this.getRecommendedLevel(),
+      history: this.compressionHistory.slice(-20)
+    };
+  }
+};
+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 {
+  presences = /* @__PURE__ */ new Map();
+  sessionId;
+  heartbeatInterval = null;
+  heartbeatTimeout = 3e4;
+  inactivityThreshold = 6e4;
+  constructor(sessionId) {
+    super();
+    this.sessionId = sessionId;
+    this.startHeartbeatCheck();
+    logger8.debug("[AgentPresenceManager] Initialized", { sessionId });
+  }
+  /**
+   * Add or update agent presence
+   */
+  updatePresence(agentId, presence) {
+    const existing = this.presences.get(agentId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const updated = {
+      ...existing,
+      ...presence,
+      agentId,
+      joinedAt: existing?.joinedAt ?? now,
+      lastSeen: now
+    };
+    this.presences.set(agentId, updated);
+    this.emit("presence_updated", {
+      agentId,
+      presence: updated
+    });
+  }
+  /**
+   * Agent joined
+   */
+  agentJoined(agentId, name, role = "user", metadata) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const presence = {
+      agentId,
+      name,
+      role,
+      status: "online",
+      joinedAt: now,
+      lastSeen: now,
+      metadata
+    };
+    this.presences.set(agentId, presence);
+    this.emit("agent_joined", { agentId, presence });
+    logger8.debug("[AgentPresenceManager] Agent joined", { agentId, name, role });
+  }
+  /**
+   * Agent left
+   */
+  agentLeft(agentId) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.status = "offline";
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("agent_left", { agentId, presence });
+      logger8.debug("[AgentPresenceManager] Agent left", { agentId });
+    }
+  }
+  /**
+   * Update cursor position
+   */
+  updateCursor(agentId, x, y, path) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.cursorPosition = { x, y, path };
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("cursor_updated", {
+        agentId,
+        cursorPosition: presence.cursorPosition
+      });
+    }
+  }
+  /**
+   * Update active section
+   */
+  updateActiveSection(agentId, section) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.activeSection = section;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("section_updated", {
+        agentId,
+        activeSection: section
+      });
+    }
+  }
+  /**
+   * Update status
+   */
+  updateStatus(agentId, status) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      presence.status = status;
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+      this.emit("status_updated", { agentId, status });
+    }
+  }
+  /**
+   * Heartbeat from agent (keeps them online)
+   */
+  heartbeat(agentId) {
+    const presence = this.presences.get(agentId);
+    if (presence) {
+      if (presence.status === "reconnecting") {
+        presence.status = "online";
+        this.emit("status_updated", { agentId, status: "online" });
+      }
+      presence.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+      this.presences.set(agentId, presence);
+    }
+  }
+  /**
+   * Get presence for agent
+   */
+  getPresence(agentId) {
+    return this.presences.get(agentId);
+  }
+  /**
+   * Get all online agents
+   */
+  getOnlineAgents() {
+    return Array.from(this.presences.values()).filter(
+      (p) => p.status === "online"
+    );
+  }
+  /**
+   * Get all agents
+   */
+  getAllAgents() {
+    return Array.from(this.presences.values());
+  }
+  /**
+   * Get all presences
+   */
+  getAllPresences() {
+    return Array.from(this.presences.values());
+  }
+  /**
+   * Get agent count
+   */
+  getAgentCount() {
+    const counts = {
+      online: 0,
+      away: 0,
+      offline: 0,
+      reconnecting: 0
+    };
+    this.presences.forEach((p) => {
+      counts[p.status]++;
+    });
+    return counts;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      totalAgents: this.presences.size,
+      onlineAgents: Array.from(this.presences.values()).filter(
+        (p) => p.status === "online"
+      ).length,
+      offlineAgents: Array.from(this.presences.values()).filter(
+        (p) => p.status === "offline"
+      ).length,
+      awayAgents: Array.from(this.presences.values()).filter(
+        (p) => p.status === "away"
+      ).length,
+      reconnectingAgents: Array.from(this.presences.values()).filter(
+        (p) => p.status === "reconnecting"
+      ).length
+    };
+  }
+  /**
+   * Clear expired presences
+   */
+  clearExpiredPresences(maxAgeMs) {
+    const now = Date.now();
+    const toRemove = [];
+    this.presences.forEach((presence, agentId) => {
+      const lastSeenTime = new Date(presence.lastSeen).getTime();
+      const ageMs = now - lastSeenTime;
+      if (ageMs > maxAgeMs && presence.status === "offline") {
+        toRemove.push(agentId);
+      }
+    });
+    toRemove.forEach((agentId) => {
+      this.presences.delete(agentId);
+    });
+    if (toRemove.length > 0) {
+      logger8.debug("[AgentPresenceManager] Cleared expired presences", {
+        count: toRemove.length
+      });
+    }
+  }
+  /**
+   * Get agents by role
+   */
+  getByRole(role) {
+    return Array.from(this.presences.values()).filter((p) => p.role === role);
+  }
+  /**
+   * Get agents in active section
+   */
+  getInSection(section) {
+    return Array.from(this.presences.values()).filter(
+      (p) => p.activeSection === section && p.status === "online"
+    );
+  }
+  /**
+   * Get presence timeline
+   */
+  getPresenceStats() {
+    const stats = {
+      total: this.presences.size,
+      online: 0,
+      away: 0,
+      offline: 0,
+      reconnecting: 0,
+      byRole: {}
+    };
+    this.presences.forEach((p) => {
+      stats[p.status]++;
+      stats.byRole[p.role] = (stats.byRole[p.role] ?? 0) + 1;
+    });
+    return stats;
+  }
+  /**
+   * Start heartbeat check (mark inactive agents as away)
+   */
+  startHeartbeatCheck() {
+    this.heartbeatInterval = setInterval(() => {
+      const now = Date.now();
+      this.presences.forEach((presence) => {
+        const lastSeenTime = new Date(presence.lastSeen).getTime();
+        const timeSinceLastSeen = now - lastSeenTime;
+        if (timeSinceLastSeen > this.inactivityThreshold && presence.status === "online") {
+          presence.status = "away";
+          this.emit("status_updated", {
+            agentId: presence.agentId,
+            status: "away"
+          });
+        }
+        if (timeSinceLastSeen > this.heartbeatTimeout && presence.status !== "offline") {
+          presence.status = "reconnecting";
+          this.emit("status_updated", {
+            agentId: presence.agentId,
+            status: "reconnecting"
+          });
+        }
+      });
+    }, 1e4);
+  }
+  /**
+   * Stop heartbeat monitoring
+   */
+  stopHeartbeatMonitoring() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  /**
+   * Clear all presences
+   */
+  clear() {
+    this.presences.clear();
+  }
+  /**
+   * Destroy the manager
+   */
+  destroy() {
+    this.stopHeartbeatMonitoring();
+    this.presences.clear();
+    this.removeAllListeners();
+    logger8.debug("[AgentPresenceManager] Destroyed", { sessionId: this.sessionId });
+  }
+};
+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) {
+    instance.destroy();
+    instances.delete(sessionId);
+  }
+}
+
+// src/crypto/types.ts
+var AEON_CAPABILITIES = {
+  // Basic sync operations
+  SYNC_READ: "aeon:sync:read",
+  SYNC_WRITE: "aeon:sync:write",
+  SYNC_ADMIN: "aeon:sync:admin",
+  // Node operations
+  NODE_REGISTER: "aeon:node:register",
+  NODE_HEARTBEAT: "aeon:node:heartbeat",
+  // Replication operations
+  REPLICATE_READ: "aeon:replicate:read",
+  REPLICATE_WRITE: "aeon:replicate:write",
+  // State operations
+  STATE_READ: "aeon:state:read",
+  STATE_WRITE: "aeon:state:write",
+  STATE_RECONCILE: "aeon:state:reconcile"
+};
+var DEFAULT_CRYPTO_CONFIG = {
+  defaultEncryptionMode: "none",
+  requireSignatures: false,
+  requireCapabilities: false,
+  allowedSignatureAlgorithms: ["ES256", "Ed25519"],
+  allowedEncryptionAlgorithms: ["ECIES-P256", "AES-256-GCM"],
+  sessionKeyExpiration: 24 * 60 * 60 * 1e3
+  // 24 hours
+};
+
+// src/crypto/CryptoProvider.ts
+var NullCryptoProvider = class {
+  notConfiguredError() {
+    return new Error("Crypto provider not configured");
+  }
+  async generateIdentity() {
+    throw this.notConfiguredError();
+  }
+  getLocalDID() {
+    return null;
+  }
+  async exportPublicIdentity() {
+    return null;
+  }
+  async registerRemoteNode() {
+  }
+  async getRemotePublicKey() {
+    return null;
+  }
+  async sign() {
+    throw this.notConfiguredError();
+  }
+  async signData(_data) {
+    throw this.notConfiguredError();
+  }
+  async verify() {
+    return true;
+  }
+  async verifySignedData() {
+    return true;
+  }
+  async encrypt() {
+    throw this.notConfiguredError();
+  }
+  async decrypt() {
+    throw this.notConfiguredError();
+  }
+  async getSessionKey() {
+    throw this.notConfiguredError();
+  }
+  async encryptWithSessionKey() {
+    throw this.notConfiguredError();
+  }
+  async decryptWithSessionKey() {
+    throw this.notConfiguredError();
+  }
+  async createUCAN() {
+    throw this.notConfiguredError();
+  }
+  async verifyUCAN() {
+    return { authorized: true };
+  }
+  async delegateCapabilities() {
+    throw this.notConfiguredError();
+  }
+  async hash() {
+    throw this.notConfiguredError();
+  }
+  randomBytes(length) {
+    return crypto.getRandomValues(new Uint8Array(length));
+  }
+  isInitialized() {
+    return false;
+  }
+};
+
+exports.AEON_CAPABILITIES = AEON_CAPABILITIES;
+exports.AdaptiveCompressionOptimizer = AdaptiveCompressionOptimizer;
+exports.AgentPresenceManager = AgentPresenceManager;
+exports.BatchTimingOptimizer = BatchTimingOptimizer;
+exports.CompressionEngine = CompressionEngine;
+exports.DEFAULT_CRYPTO_CONFIG = DEFAULT_CRYPTO_CONFIG;
+exports.DataTransformer = DataTransformer;
+exports.DeltaSyncOptimizer = DeltaSyncOptimizer;
+exports.MigrationEngine = MigrationEngine;
+exports.MigrationTracker = MigrationTracker;
+exports.NullCryptoProvider = NullCryptoProvider;
+exports.OfflineOperationQueue = OfflineOperationQueue;
+exports.PrefetchingEngine = PrefetchingEngine;
+exports.ReplicationManager = ReplicationManager;
+exports.SchemaVersionManager = SchemaVersionManager;
+exports.StateReconciler = StateReconciler;
+exports.SyncCoordinator = SyncCoordinator;
+exports.SyncProtocol = SyncProtocol;
+exports.clearAgentPresenceManager = clearAgentPresenceManager;
+exports.createNamespacedLogger = createNamespacedLogger;
+exports.disableLogging = disableLogging;
+exports.getAdaptiveCompressionOptimizer = getAdaptiveCompressionOptimizer;
+exports.getAgentPresenceManager = getAgentPresenceManager;
+exports.getBatchTimingOptimizer = getBatchTimingOptimizer;
+exports.getCompressionEngine = getCompressionEngine;
+exports.getDeltaSyncOptimizer = getDeltaSyncOptimizer;
+exports.getLogger = getLogger;
+exports.getOfflineOperationQueue = getOfflineOperationQueue;
+exports.getPrefetchingEngine = getPrefetchingEngine;
+exports.logger = logger;
+exports.resetAdaptiveCompressionOptimizer = resetAdaptiveCompressionOptimizer;
+exports.resetBatchTimingOptimizer = resetBatchTimingOptimizer;
+exports.resetCompressionEngine = resetCompressionEngine;
+exports.resetDeltaSyncOptimizer = resetDeltaSyncOptimizer;
+exports.resetLogger = resetLogger;
+exports.resetOfflineOperationQueue = resetOfflineOperationQueue;
+exports.resetPrefetchingEngine = resetPrefetchingEngine;
+exports.setLogger = setLogger;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map