drizzle-multitenant 1.0.10 → 1.2.0

package/dist/index.js

@@ -254,8 +254,161 @@ var DebugLogger = class {
 function createDebugLogger(config) {
   return new DebugLogger(config);
 }
+var PoolCache = class {
+  cache;
+  poolTtlMs;
+  onDispose;
+  constructor(options) {
+    this.poolTtlMs = options.poolTtlMs;
+    this.onDispose = options.onDispose;
+    this.cache = new LRUCache({
+      max: options.maxPools,
+      dispose: (entry, key) => {
+        void this.handleDispose(key, entry);
+      },
+      noDisposeOnSet: true
+    });
+  }
+  /**
+   * Get a pool entry from cache
+   *
+   * This does NOT update the last access time automatically.
+   * Use `touch()` to update access time when needed.
+   */
+  get(schemaName) {
+    return this.cache.get(schemaName);
+  }
+  /**
+   * Set a pool entry in cache
+   *
+   * If the cache is full, the least recently used entry will be evicted.
+   */
+  set(schemaName, entry) {
+    this.cache.set(schemaName, entry);
+  }
+  /**
+   * Check if a pool exists in cache
+   */
+  has(schemaName) {
+    return this.cache.has(schemaName);
+  }
+  /**
+   * Delete a pool from cache
+   *
+   * Note: This triggers the dispose callback if configured.
+   */
+  delete(schemaName) {
+    return this.cache.delete(schemaName);
+  }
+  /**
+   * Get the number of pools in cache
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Get all schema names in cache
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Iterate over all entries in cache
+   *
+   * @yields [schemaName, entry] pairs
+   */
+  *entries() {
+    for (const [key, value] of this.cache.entries()) {
+      yield [key, value];
+    }
+  }
+  /**
+   * Clear all pools from cache
+   *
+   * Each pool's dispose callback will be triggered by the LRU cache.
+   */
+  async clear() {
+    this.cache.clear();
+    await Promise.resolve();
+  }
+  /**
+   * Evict the least recently used pool
+   *
+   * @returns The schema name of the evicted pool, or undefined if cache is empty
+   */
+  evictLRU() {
+    const keys = Array.from(this.cache.keys());
+    if (keys.length === 0) {
+      return void 0;
+    }
+    const lruKey = keys[keys.length - 1];
+    this.cache.delete(lruKey);
+    return lruKey;
+  }
+  /**
+   * Evict pools that have exceeded TTL
+   *
+   * @returns Array of schema names that were evicted
+   */
+  async evictExpired() {
+    if (!this.poolTtlMs) {
+      return [];
+    }
+    const now = Date.now();
+    const toEvict = [];
+    for (const [schemaName, entry] of this.cache.entries()) {
+      if (now - entry.lastAccess > this.poolTtlMs) {
+        toEvict.push(schemaName);
+      }
+    }
+    for (const schemaName of toEvict) {
+      this.cache.delete(schemaName);
+    }
+    return toEvict;
+  }
+  /**
+   * Update last access time for a pool
+   *
+   * This moves the pool to the front of the LRU list.
+   */
+  touch(schemaName) {
+    const entry = this.cache.get(schemaName);
+    if (entry) {
+      entry.lastAccess = Date.now();
+    }
+  }
+  /**
+   * Get the maximum number of pools allowed in cache
+   */
+  getMaxPools() {
+    return this.cache.max;
+  }
+  /**
+   * Get the configured TTL in milliseconds
+   */
+  getTtlMs() {
+    return this.poolTtlMs;
+  }
+  /**
+   * Check if an entry has expired based on TTL
+   */
+  isExpired(entry) {
+    if (!this.poolTtlMs) {
+      return false;
+    }
+    return Date.now() - entry.lastAccess > this.poolTtlMs;
+  }
+  /**
+   * Handle disposal of a cache entry
+   */
+  async handleDispose(schemaName, entry) {
+    if (this.onDispose) {
+      await this.onDispose(schemaName, entry);
+    }
+  }
+};
 
-// src/retry.ts
+// src/pool/retry/retry-handler.ts
 function isRetryableError(error) {
   const message = error.message.toLowerCase();
   if (message.includes("econnrefused") || message.includes("econnreset") || message.includes("etimedout") || message.includes("enotfound") || message.includes("connection refused") || message.includes("connection reset") || message.includes("connection terminated") || message.includes("connection timed out") || message.includes("timeout expired") || message.includes("socket hang up")) {
@@ -269,82 +422,315 @@ function isRetryableError(error) {
   }
   return false;
 }
-function calculateDelay(attempt, config) {
-  const exponentialDelay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
-  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
-  if (config.jitter) {
-    const jitterFactor = 1 + Math.random() * 0.25;
-    return Math.floor(cappedDelay * jitterFactor);
-  }
-  return Math.floor(cappedDelay);
-}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function withRetry(operation, config) {
-  const retryConfig = {
-    maxAttempts: config?.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
-    initialDelayMs: config?.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
-    maxDelayMs: config?.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
-    backoffMultiplier: config?.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
-    jitter: config?.jitter ?? DEFAULT_CONFIG.retry.jitter,
-    isRetryable: config?.isRetryable ?? isRetryableError,
-    onRetry: config?.onRetry
-  };
-  const startTime = Date.now();
-  let lastError = null;
-  for (let attempt = 0; attempt < retryConfig.maxAttempts; attempt++) {
+var RetryHandler = class {
+  config;
+  constructor(config) {
+    this.config = {
+      maxAttempts: config?.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
+      initialDelayMs: config?.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
+      maxDelayMs: config?.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
+      backoffMultiplier: config?.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
+      jitter: config?.jitter ?? DEFAULT_CONFIG.retry.jitter,
+      isRetryable: config?.isRetryable ?? isRetryableError,
+      onRetry: config?.onRetry
+    };
+  }
+  /**
+   * Execute an operation with retry logic
+   *
+   * @param operation - The async operation to execute
+   * @param overrideConfig - Optional config to override defaults for this call
+   * @returns Result with metadata about attempts and timing
+   */
+  async withRetry(operation, overrideConfig) {
+    const config = overrideConfig ? { ...this.config, ...overrideConfig } : this.config;
+    const startTime = Date.now();
+    let lastError = null;
+    for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
+      try {
+        const result = await operation();
+        return {
+          result,
+          attempts: attempt + 1,
+          totalTimeMs: Date.now() - startTime
+        };
+      } catch (error) {
+        lastError = error;
+        const isLastAttempt = attempt >= config.maxAttempts - 1;
+        const checkRetryable = config.isRetryable ?? this.isRetryable;
+        if (isLastAttempt || !checkRetryable(lastError)) {
+          throw lastError;
+        }
+        const delay = this.calculateDelay(attempt, config);
+        config.onRetry?.(attempt + 1, lastError, delay);
+        await sleep(delay);
+      }
+    }
+    throw lastError ?? new Error("Retry failed with no error");
+  }
+  /**
+   * Calculate delay with exponential backoff and optional jitter
+   *
+   * @param attempt - Current attempt number (0-indexed)
+   * @param config - Retry configuration
+   * @returns Delay in milliseconds
+   */
+  calculateDelay(attempt, config) {
+    const cfg = config ? { ...this.config, ...config } : this.config;
+    const exponentialDelay = cfg.initialDelayMs * Math.pow(cfg.backoffMultiplier, attempt);
+    const cappedDelay = Math.min(exponentialDelay, cfg.maxDelayMs);
+    if (cfg.jitter) {
+      const jitterFactor = 1 + Math.random() * 0.25;
+      return Math.floor(cappedDelay * jitterFactor);
+    }
+    return Math.floor(cappedDelay);
+  }
+  /**
+   * Check if an error is retryable
+   *
+   * Uses the configured isRetryable function or the default implementation.
+   */
+  isRetryable(error) {
+    return (this.config.isRetryable ?? isRetryableError)(error);
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the maximum number of attempts
+   */
+  getMaxAttempts() {
+    return this.config.maxAttempts;
+  }
+};
+
+// src/pool/health/health-checker.ts
+var HealthChecker = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Check health of all pools and connections
+   *
+   * Verifies the health of tenant pools and optionally the shared database.
+   * Returns detailed status information for monitoring and load balancer integration.
+   *
+   * @example
+   * ```typescript
+   * // Basic health check
+   * const health = await healthChecker.checkHealth();
+   * console.log(health.healthy); // true/false
+   *
+   * // Check specific tenants only
+   * const health = await healthChecker.checkHealth({
+   *   tenantIds: ['tenant-1', 'tenant-2'],
+   *   ping: true,
+   *   pingTimeoutMs: 3000,
+   * });
+   * ```
+   */
+  async checkHealth(options = {}) {
+    const startTime = Date.now();
+    const {
+      ping = true,
+      pingTimeoutMs = 5e3,
+      includeShared = true,
+      tenantIds
+    } = options;
+    const poolHealthResults = [];
+    let sharedDbStatus = "ok";
+    let sharedDbResponseTimeMs;
+    let sharedDbError;
+    const poolsToCheck = this.getPoolsToCheck(tenantIds);
+    const poolChecks = poolsToCheck.map(async ({ schemaName, tenantId, entry }) => {
+      return this.checkPoolHealth(tenantId, schemaName, entry, ping, pingTimeoutMs);
+    });
+    poolHealthResults.push(...await Promise.all(poolChecks));
+    const sharedPool = this.deps.getSharedPool();
+    if (includeShared && sharedPool) {
+      const sharedResult = await this.checkSharedDbHealth(sharedPool, ping, pingTimeoutMs);
+      sharedDbStatus = sharedResult.status;
+      sharedDbResponseTimeMs = sharedResult.responseTimeMs;
+      sharedDbError = sharedResult.error;
+    }
+    const degradedPools = poolHealthResults.filter((p) => p.status === "degraded").length;
+    const unhealthyPools = poolHealthResults.filter((p) => p.status === "unhealthy").length;
+    const healthy = unhealthyPools === 0 && sharedDbStatus !== "unhealthy";
+    const result = {
+      healthy,
+      pools: poolHealthResults,
+      sharedDb: sharedDbStatus,
+      totalPools: poolHealthResults.length,
+      degradedPools,
+      unhealthyPools,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - startTime
+    };
+    if (sharedDbResponseTimeMs !== void 0) {
+      result.sharedDbResponseTimeMs = sharedDbResponseTimeMs;
+    }
+    if (sharedDbError !== void 0) {
+      result.sharedDbError = sharedDbError;
+    }
+    return result;
+  }
+  /**
+   * Get pools to check based on options
+   */
+  getPoolsToCheck(tenantIds) {
+    const poolsToCheck = [];
+    if (tenantIds && tenantIds.length > 0) {
+      for (const tenantId of tenantIds) {
+        const schemaName = this.deps.getSchemaName(tenantId);
+        const entry = this.deps.getPoolEntry(schemaName);
+        if (entry) {
+          poolsToCheck.push({ schemaName, tenantId, entry });
+        }
+      }
+    } else {
+      for (const [schemaName, entry] of this.deps.getPoolEntries()) {
+        const tenantId = this.deps.getTenantIdBySchema(schemaName) ?? schemaName;
+        poolsToCheck.push({ schemaName, tenantId, entry });
+      }
+    }
+    return poolsToCheck;
+  }
+  /**
+   * Check health of a single tenant pool
+   */
+  async checkPoolHealth(tenantId, schemaName, entry, ping, pingTimeoutMs) {
+    const pool = entry.pool;
+    const totalConnections = pool.totalCount;
+    const idleConnections = pool.idleCount;
+    const waitingRequests = pool.waitingCount;
+    let status = "ok";
+    let responseTimeMs;
+    let error;
+    if (waitingRequests > 0) {
+      status = "degraded";
+    }
+    if (ping) {
+      const pingResult = await this.executePingQuery(pool, pingTimeoutMs);
+      responseTimeMs = pingResult.responseTimeMs;
+      if (!pingResult.success) {
+        status = "unhealthy";
+        error = pingResult.error;
+      } else if (pingResult.responseTimeMs && pingResult.responseTimeMs > pingTimeoutMs / 2) {
+        if (status === "ok") {
+          status = "degraded";
+        }
+      }
+    }
+    const result = {
+      tenantId,
+      schemaName,
+      status,
+      totalConnections,
+      idleConnections,
+      waitingRequests
+    };
+    if (responseTimeMs !== void 0) {
+      result.responseTimeMs = responseTimeMs;
+    }
+    if (error !== void 0) {
+      result.error = error;
+    }
+    return result;
+  }
+  /**
+   * Check health of shared database
+   */
+  async checkSharedDbHealth(sharedPool, ping, pingTimeoutMs) {
+    let status = "ok";
+    let responseTimeMs;
+    let error;
+    const waitingRequests = sharedPool.waitingCount;
+    if (waitingRequests > 0) {
+      status = "degraded";
+    }
+    if (ping) {
+      const pingResult = await this.executePingQuery(sharedPool, pingTimeoutMs);
+      responseTimeMs = pingResult.responseTimeMs;
+      if (!pingResult.success) {
+        status = "unhealthy";
+        error = pingResult.error;
+      } else if (pingResult.responseTimeMs && pingResult.responseTimeMs > pingTimeoutMs / 2) {
+        if (status === "ok") {
+          status = "degraded";
+        }
+      }
+    }
+    const result = { status };
+    if (responseTimeMs !== void 0) {
+      result.responseTimeMs = responseTimeMs;
+    }
+    if (error !== void 0) {
+      result.error = error;
+    }
+    return result;
+  }
+  /**
+   * Execute a ping query with timeout
+   */
+  async executePingQuery(pool, timeoutMs) {
+    const startTime = Date.now();
     try {
-      const result = await operation();
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Health check ping timeout")), timeoutMs);
+      });
+      const queryPromise = pool.query("SELECT 1");
+      await Promise.race([queryPromise, timeoutPromise]);
       return {
-        result,
-        attempts: attempt + 1,
-        totalTimeMs: Date.now() - startTime
+        success: true,
+        responseTimeMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        success: false,
+        responseTimeMs: Date.now() - startTime,
+        error: err.message
       };
-    } catch (error) {
-      lastError = error;
-      const isLastAttempt = attempt >= retryConfig.maxAttempts - 1;
-      if (isLastAttempt || !retryConfig.isRetryable(lastError)) {
-        throw lastError;
-      }
-      const delay = calculateDelay(attempt, retryConfig);
-      retryConfig.onRetry?.(attempt + 1, lastError, delay);
-      await sleep(delay);
     }
   }
-  throw lastError ?? new Error("Retry failed with no error");
-}
-function createRetrier(config) {
-  return (operation) => {
-    return withRetry(operation, config);
-  };
-}
+  /**
+   * Determine overall health status from pool health results
+   */
+  determineOverallHealth(pools, sharedDbStatus = "ok") {
+    const unhealthyPools = pools.filter((p) => p.status === "unhealthy").length;
+    return unhealthyPools === 0 && sharedDbStatus !== "unhealthy";
+  }
+};
 
 // src/pool.ts
 var PoolManager = class {
   constructor(config) {
     this.config = config;
     const maxPools = config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    const poolTtlMs = config.isolation.poolTtlMs ?? DEFAULT_CONFIG.poolTtlMs;
     this.debugLogger = createDebugLogger(config.debug);
-    const userRetry = config.connection.retry ?? {};
-    this.retryConfig = {
-      maxAttempts: userRetry.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
-      initialDelayMs: userRetry.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
-      maxDelayMs: userRetry.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
-      backoffMultiplier: userRetry.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
-      jitter: userRetry.jitter ?? DEFAULT_CONFIG.retry.jitter,
-      isRetryable: userRetry.isRetryable ?? isRetryableError,
-      onRetry: userRetry.onRetry
-    };
-    this.pools = new LRUCache({
-      max: maxPools,
-      dispose: (entry, key) => {
-        this.disposePoolEntry(entry, key);
-      },
-      noDisposeOnSet: true
+    this.retryHandler = new RetryHandler(config.connection.retry);
+    this.poolCache = new PoolCache({
+      maxPools,
+      poolTtlMs,
+      onDispose: (schemaName, entry) => {
+        this.disposePoolEntry(entry, schemaName);
+      }
+    });
+    this.healthChecker = new HealthChecker({
+      getPoolEntries: () => this.poolCache.entries(),
+      getTenantIdBySchema: (schemaName) => this.tenantIdBySchema.get(schemaName),
+      getPoolEntry: (schemaName) => this.poolCache.get(schemaName),
+      getSchemaName: (tenantId) => this.config.isolation.schemaNameTemplate(tenantId),
+      getSharedPool: () => this.sharedPool
     });
   }
-  pools;
+  poolCache;
   tenantIdBySchema = /* @__PURE__ */ new Map();
   pendingConnections = /* @__PURE__ */ new Map();
   sharedPool = null;
@@ -353,22 +739,23 @@ var PoolManager = class {
   cleanupInterval = null;
   disposed = false;
   debugLogger;
-  retryConfig;
+  retryHandler;
+  healthChecker;
   /**
    * Get or create a database connection for a tenant
    */
   getDb(tenantId) {
     this.ensureNotDisposed();
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.pools.get(schemaName);
+    let entry = this.poolCache.get(schemaName);
     if (!entry) {
       entry = this.createPoolEntry(tenantId, schemaName);
-      this.pools.set(schemaName, entry);
+      this.poolCache.set(schemaName, entry);
       this.tenantIdBySchema.set(schemaName, tenantId);
       this.debugLogger.logPoolCreated(tenantId, schemaName);
       void this.config.hooks?.onPoolCreated?.(tenantId);
     }
-    entry.lastAccess = Date.now();
+    this.poolCache.touch(schemaName);
     return entry.db;
   }
   /**
@@ -389,26 +776,26 @@ var PoolManager = class {
   async getDbAsync(tenantId) {
     this.ensureNotDisposed();
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.pools.get(schemaName);
+    let entry = this.poolCache.get(schemaName);
     if (entry) {
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     }
     const pending = this.pendingConnections.get(schemaName);
     if (pending) {
       entry = await pending;
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     }
     const connectionPromise = this.connectWithRetry(tenantId, schemaName);
     this.pendingConnections.set(schemaName, connectionPromise);
     try {
       entry = await connectionPromise;
-      this.pools.set(schemaName, entry);
+      this.poolCache.set(schemaName, entry);
       this.tenantIdBySchema.set(schemaName, tenantId);
       this.debugLogger.logPoolCreated(tenantId, schemaName);
       void this.config.hooks?.onPoolCreated?.(tenantId);
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     } finally {
       this.pendingConnections.delete(schemaName);
@@ -418,8 +805,9 @@ var PoolManager = class {
    * Connect to a tenant database with retry logic
    */
   async connectWithRetry(tenantId, schemaName) {
-    const maxAttempts = this.retryConfig.maxAttempts;
-    const result = await withRetry(
+    const retryConfig = this.retryHandler.getConfig();
+    const maxAttempts = retryConfig.maxAttempts;
+    const result = await this.retryHandler.withRetry(
       async () => {
         const entry = this.createPoolEntry(tenantId, schemaName);
         try {
@@ -434,10 +822,9 @@ var PoolManager = class {
         }
       },
       {
-        ...this.retryConfig,
         onRetry: (attempt, error, delayMs) => {
           this.debugLogger.logConnectionRetry(tenantId, attempt, maxAttempts, error, delayMs);
-          this.retryConfig.onRetry?.(attempt, error, delayMs);
+          retryConfig.onRetry?.(attempt, error, delayMs);
         }
       }
     );
@@ -499,8 +886,9 @@ var PoolManager = class {
    * Connect to shared database with retry logic
    */
   async connectSharedWithRetry() {
-    const maxAttempts = this.retryConfig.maxAttempts;
-    const result = await withRetry(
+    const retryConfig = this.retryHandler.getConfig();
+    const maxAttempts = retryConfig.maxAttempts;
+    const result = await this.retryHandler.withRetry(
       async () => {
         const pool = new Pool({
           connectionString: this.config.connection.url,
@@ -526,10 +914,9 @@ var PoolManager = class {
         }
       },
       {
-        ...this.retryConfig,
         onRetry: (attempt, error, delayMs) => {
           this.debugLogger.logConnectionRetry("shared", attempt, maxAttempts, error, delayMs);
-          this.retryConfig.onRetry?.(attempt, error, delayMs);
+          retryConfig.onRetry?.(attempt, error, delayMs);
         }
       }
     );
@@ -547,13 +934,13 @@ var PoolManager = class {
    */
   hasPool(tenantId) {
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    return this.pools.has(schemaName);
+    return this.poolCache.has(schemaName);
   }
   /**
    * Get count of active pools
    */
   getPoolCount() {
-    return this.pools.size;
+    return this.poolCache.size();
   }
   /**
    * Get all active tenant IDs
@@ -565,7 +952,7 @@ var PoolManager = class {
    * Get the retry configuration
    */
   getRetryConfig() {
-    return { ...this.retryConfig };
+    return this.retryHandler.getConfig();
   }
   /**
    * Pre-warm pools for specified tenants to reduce cold start latency
@@ -624,15 +1011,97 @@ var PoolManager = class {
       details: results
     };
   }
+  /**
+   * Get current metrics for all pools
+   *
+   * Collects metrics on demand with zero overhead when not called.
+   * Returns raw data that can be formatted for any monitoring system.
+   *
+   * @example
+   * ```typescript
+   * const metrics = manager.getMetrics();
+   * console.log(metrics.pools.total); // 15
+   *
+   * // Format for Prometheus
+   * for (const pool of metrics.pools.tenants) {
+   *   gauge.labels(pool.tenantId).set(pool.connections.idle);
+   * }
+   * ```
+   */
+  getMetrics() {
+    this.ensureNotDisposed();
+    const maxPools = this.config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    const tenantMetrics = [];
+    for (const [schemaName, entry] of this.poolCache.entries()) {
+      const tenantId = this.tenantIdBySchema.get(schemaName) ?? schemaName;
+      const pool = entry.pool;
+      tenantMetrics.push({
+        tenantId,
+        schemaName,
+        connections: {
+          total: pool.totalCount,
+          idle: pool.idleCount,
+          waiting: pool.waitingCount
+        },
+        lastAccessedAt: new Date(entry.lastAccess).toISOString()
+      });
+    }
+    return {
+      pools: {
+        total: tenantMetrics.length,
+        maxPools,
+        tenants: tenantMetrics
+      },
+      shared: {
+        initialized: this.sharedPool !== null,
+        connections: this.sharedPool ? {
+          total: this.sharedPool.totalCount,
+          idle: this.sharedPool.idleCount,
+          waiting: this.sharedPool.waitingCount
+        } : null
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Check health of all pools and connections
+   *
+   * Verifies the health of tenant pools and optionally the shared database.
+   * Returns detailed status information for monitoring and load balancer integration.
+   *
+   * @example
+   * ```typescript
+   * // Basic health check
+   * const health = await manager.healthCheck();
+   * console.log(health.healthy); // true/false
+   *
+   * // Use with Express endpoint
+   * app.get('/health', async (req, res) => {
+   *   const health = await manager.healthCheck();
+   *   res.status(health.healthy ? 200 : 503).json(health);
+   * });
+   *
+   * // Check specific tenants only
+   * const health = await manager.healthCheck({
+   *   tenantIds: ['tenant-1', 'tenant-2'],
+   *   ping: true,
+   *   pingTimeoutMs: 3000,
+   * });
+   * ```
+   */
+  async healthCheck(options = {}) {
+    this.ensureNotDisposed();
+    return this.healthChecker.checkHealth(options);
+  }
   /**
    * Manually evict a tenant pool
    */
   async evictPool(tenantId, reason = "manual") {
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    const entry = this.pools.get(schemaName);
+    const entry = this.poolCache.get(schemaName);
     if (entry) {
       this.debugLogger.logPoolEvicted(tenantId, schemaName, reason);
-      this.pools.delete(schemaName);
+      this.poolCache.delete(schemaName);
       this.tenantIdBySchema.delete(schemaName);
       await this.closePool(entry.pool, tenantId);
     }
@@ -642,10 +1111,9 @@ var PoolManager = class {
    */
   startCleanup() {
     if (this.cleanupInterval) return;
-    const poolTtlMs = this.config.isolation.poolTtlMs ?? DEFAULT_CONFIG.poolTtlMs;
     const cleanupIntervalMs = DEFAULT_CONFIG.cleanupIntervalMs;
     this.cleanupInterval = setInterval(() => {
-      void this.cleanupIdlePools(poolTtlMs);
+      void this.cleanupIdlePools();
     }, cleanupIntervalMs);
     this.cleanupInterval.unref();
   }
@@ -666,11 +1134,11 @@ var PoolManager = class {
     this.disposed = true;
     this.stopCleanup();
     const closePromises = [];
-    for (const [schemaName, entry] of this.pools.entries()) {
+    for (const [schemaName, entry] of this.poolCache.entries()) {
       const tenantId = this.tenantIdBySchema.get(schemaName);
       closePromises.push(this.closePool(entry.pool, tenantId ?? schemaName));
     }
-    this.pools.clear();
+    await this.poolCache.clear();
     this.tenantIdBySchema.clear();
     if (this.sharedPool) {
       closePromises.push(this.closePool(this.sharedPool, "shared"));
@@ -732,18 +1200,13 @@ var PoolManager = class {
   /**
    * Cleanup pools that have been idle for too long
    */
-  async cleanupIdlePools(poolTtlMs) {
-    const now = Date.now();
-    const toEvict = [];
-    for (const [schemaName, entry] of this.pools.entries()) {
-      if (now - entry.lastAccess > poolTtlMs) {
-        toEvict.push(schemaName);
-      }
-    }
-    for (const schemaName of toEvict) {
+  async cleanupIdlePools() {
+    const evictedSchemas = await this.poolCache.evictExpired();
+    for (const schemaName of evictedSchemas) {
       const tenantId = this.tenantIdBySchema.get(schemaName);
       if (tenantId) {
-        await this.evictPool(tenantId, "ttl_expired");
+        this.debugLogger.logPoolEvicted(tenantId, schemaName, "ttl_expired");
+        this.tenantIdBySchema.delete(schemaName);
       }
     }
   }
@@ -795,6 +1258,12 @@ function createTenantManager(config) {
     async warmup(tenantIds, options) {
       return poolManager.warmup(tenantIds, options);
     },
+    async healthCheck(options) {
+      return poolManager.healthCheck(options);
+    },
+    getMetrics() {
+      return poolManager.getMetrics();
+    },
     async dispose() {
       await poolManager.dispose();
     }
@@ -935,246 +1404,108 @@ function getFormatConfig(format, tableName = "__drizzle_migrations") {
       };
   }
 }
-
-// src/migrator/migrator.ts
 var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
-var Migrator = class {
-  constructor(tenantConfig, migratorConfig) {
-    this.tenantConfig = tenantConfig;
-    this.migratorConfig = migratorConfig;
-    this.migrationsTable = migratorConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
+var SchemaManager = class {
+  constructor(config, migrationsTable) {
+    this.config = config;
+    this.migrationsTable = migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
   }
   migrationsTable;
   /**
-   * Migrate all tenants in parallel
-   */
-  async migrateAll(options = {}) {
-    const {
-      concurrency = 10,
-      onProgress,
-      onError,
-      dryRun = false
-    } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.migrateTenant(tenantId, migrations, { dryRun, onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    if (aborted) {
-      const remaining = tenantIds.slice(results.length);
-      for (const tenantId of remaining) {
-        results.push(this.createSkippedResult(tenantId));
-      }
-    }
-    return this.aggregateResults(results);
-  }
-  /**
-   * Migrate a single tenant
-   */
-  async migrateTenant(tenantId, migrations, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const appliedMigrations = [];
-    const pool = await this.createPool(schemaName);
-    try {
-      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
-      );
-      if (options.dryRun) {
-        return {
-          tenantId,
-          schemaName,
-          success: true,
-          appliedMigrations: pending.map((m) => m.name),
-          durationMs: Date.now() - startTime,
-          format: format.format
-        };
-      }
-      for (const migration of pending) {
-        const migrationStart = Date.now();
-        options.onProgress?.(tenantId, "migrating", migration.name);
-        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.applyMigration(pool, schemaName, migration, format);
-        await this.migratorConfig.hooks?.afterMigration?.(
-          tenantId,
-          migration.name,
-          Date.now() - migrationStart
-        );
-        appliedMigrations.push(migration.name);
-      }
-      const result = {
-        tenantId,
-        schemaName,
-        success: true,
-        appliedMigrations,
-        durationMs: Date.now() - startTime,
-        format: format.format
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } catch (error) {
-      const result = {
-        tenantId,
-        schemaName,
-        success: false,
-        appliedMigrations,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Migrate specific tenants
+   * Get the schema name for a tenant ID using the configured template
+   *
+   * @param tenantId - The tenant identifier
+   * @returns The PostgreSQL schema name
+   *
+   * @example
+   * ```typescript
+   * const schemaName = schemaManager.getSchemaName('tenant-123');
+   * // Returns: 'tenant_tenant-123' (depends on schemaNameTemplate)
+   * ```
    */
-  async migrateTenants(tenantIds, options = {}) {
-    const migrations = await this.loadMigrations();
-    const results = [];
-    const { concurrency = 10, onProgress, onError } = options;
-    for (let i = 0; i < tenantIds.length; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.migrateTenant(tenantId, migrations, { dryRun: options.dryRun ?? false, onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            onError?.(tenantId, error);
-            return this.createErrorResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return this.aggregateResults(results);
+  getSchemaName(tenantId) {
+    return this.config.isolation.schemaNameTemplate(tenantId);
   }
   /**
-   * Get migration status for all tenants
+   * Create a PostgreSQL pool for a specific schema
+   *
+   * The pool is configured with `search_path` set to the schema,
+   * allowing queries to run in tenant isolation.
+   *
+   * @param schemaName - The PostgreSQL schema name
+   * @returns A configured Pool instance
+   *
+   * @example
+   * ```typescript
+   * const pool = await schemaManager.createPool('tenant_123');
+   * try {
+   *   await pool.query('SELECT * FROM users'); // Queries tenant_123.users
+   * } finally {
+   *   await pool.end();
+   * }
+   * ```
    */
-  async getStatus() {
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const statuses = [];
-    for (const tenantId of tenantIds) {
-      statuses.push(await this.getTenantStatus(tenantId, migrations));
-    }
-    return statuses;
+  async createPool(schemaName) {
+    return new Pool({
+      connectionString: this.config.connection.url,
+      ...this.config.connection.poolConfig,
+      options: `-c search_path="${schemaName}",public`
+    });
   }
   /**
-   * Get migration status for a specific tenant
+   * Create a PostgreSQL pool without schema-specific search_path
+   *
+   * Used for operations that need to work across schemas or
+   * before a schema exists (like creating the schema itself).
+   *
+   * @returns A Pool instance connected to the database
    */
-  async getTenantStatus(tenantId, migrations) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = await this.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const tableExists = await this.migrationsTableExists(pool, schemaName);
-      if (!tableExists) {
-        return {
-          tenantId,
-          schemaName,
-          appliedCount: 0,
-          pendingCount: allMigrations.length,
-          pendingMigrations: allMigrations.map((m) => m.name),
-          status: allMigrations.length > 0 ? "behind" : "ok",
-          format: null
-          // New tenant, no table yet
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
-      );
-      return {
-        tenantId,
-        schemaName,
-        appliedCount: applied.length,
-        pendingCount: pending.length,
-        pendingMigrations: pending.map((m) => m.name),
-        status: pending.length > 0 ? "behind" : "ok",
-        format: format.format
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        appliedCount: 0,
-        pendingCount: 0,
-        pendingMigrations: [],
-        status: "error",
-        error: error.message,
-        format: null
-      };
-    } finally {
-      await pool.end();
-    }
+  async createRootPool() {
+    return new Pool({
+      connectionString: this.config.connection.url,
+      ...this.config.connection.poolConfig
+    });
   }
   /**
-   * Create a new tenant schema and optionally apply migrations
+   * Create a new tenant schema in the database
+   *
+   * @param tenantId - The tenant identifier
+   * @returns Promise that resolves when schema is created
+   *
+   * @example
+   * ```typescript
+   * await schemaManager.createSchema('new-tenant');
+   * ```
    */
-  async createTenant(tenantId, options = {}) {
-    const { migrate = true } = options;
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
+  async createSchema(tenantId) {
+    const schemaName = this.getSchemaName(tenantId);
+    const pool = await this.createRootPool();
     try {
       await pool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
-      if (migrate) {
-        await this.migrateTenant(tenantId);
-      }
     } finally {
       await pool.end();
     }
   }
   /**
-   * Drop a tenant schema
+   * Drop a tenant schema from the database
+   *
+   * @param tenantId - The tenant identifier
+   * @param options - Drop options (cascade, force)
+   * @returns Promise that resolves when schema is dropped
+   *
+   * @example
+   * ```typescript
+   * // Drop with CASCADE (removes all objects)
+   * await schemaManager.dropSchema('old-tenant', { cascade: true });
+   *
+   * // Drop with RESTRICT (fails if objects exist)
+   * await schemaManager.dropSchema('old-tenant', { cascade: false });
+   * ```
    */
-  async dropTenant(tenantId, options = {}) {
+  async dropSchema(tenantId, options = {}) {
     const { cascade = true } = options;
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
+    const schemaName = this.getSchemaName(tenantId);
+    const pool = await this.createRootPool();
     try {
       const cascadeSql = cascade ? "CASCADE" : "RESTRICT";
       await pool.query(`DROP SCHEMA IF EXISTS "${schemaName}" ${cascadeSql}`);
@@ -1183,14 +1514,21 @@ var Migrator = class {
     }
   }
   /**
-   * Check if a tenant schema exists
+   * Check if a tenant schema exists in the database
+   *
+   * @param tenantId - The tenant identifier
+   * @returns True if schema exists, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (await schemaManager.schemaExists('tenant-123')) {
+   *   console.log('Tenant schema exists');
+   * }
+   * ```
    */
-  async tenantExists(tenantId) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
+  async schemaExists(tenantId) {
+    const schemaName = this.getSchemaName(tenantId);
+    const pool = await this.createRootPool();
     try {
       const result = await pool.query(
         `SELECT 1 FROM information_schema.schemata WHERE schema_name = $1`,
@@ -1202,225 +1540,787 @@ var Migrator = class {
     }
   }
   /**
-   * Mark migrations as applied without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
+   * List all schemas matching a pattern
+   *
+   * @param pattern - SQL LIKE pattern to filter schemas (optional)
+   * @returns Array of schema names
+   *
+   * @example
+   * ```typescript
+   * // List all tenant schemas
+   * const schemas = await schemaManager.listSchemas('tenant_%');
+   * ```
    */
-  async markAsApplied(tenantId, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.createPool(schemaName);
+  async listSchemas(pattern) {
+    const pool = await this.createRootPool();
     try {
-      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.loadMigrations();
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      const query = pattern ? `SELECT schema_name FROM information_schema.schemata WHERE schema_name LIKE $1 ORDER BY schema_name` : `SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast') ORDER BY schema_name`;
+      const result = await pool.query(
+        query,
+        pattern ? [pattern] : []
       );
-      for (const migration of pending) {
-        const migrationStart = Date.now();
-        options.onProgress?.(tenantId, "migrating", migration.name);
-        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.recordMigration(pool, schemaName, migration, format);
-        await this.migratorConfig.hooks?.afterMigration?.(
-          tenantId,
-          migration.name,
-          Date.now() - migrationStart
-        );
-        markedMigrations.push(migration.name);
-      }
-      const result = {
-        tenantId,
-        schemaName,
-        success: true,
-        appliedMigrations: markedMigrations,
-        durationMs: Date.now() - startTime,
-        format: format.format
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } catch (error) {
-      const result = {
-        tenantId,
-        schemaName,
-        success: false,
-        appliedMigrations: markedMigrations,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
+      return result.rows.map((row) => row.schema_name);
     } finally {
       await pool.end();
     }
   }
   /**
-   * Mark migrations as applied for all tenants without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
+   * Ensure the migrations table exists with the correct format
+   *
+   * Creates the migrations tracking table if it doesn't exist,
+   * using the appropriate column types based on the format.
+   *
+   * @param pool - Database pool to use
+   * @param schemaName - The schema to create the table in
+   * @param format - The detected/configured table format
+   *
+   * @example
+   * ```typescript
+   * const pool = await schemaManager.createPool('tenant_123');
+   * await schemaManager.ensureMigrationsTable(pool, 'tenant_123', format);
+   * ```
    */
-  async markAllAsApplied(options = {}) {
+  async ensureMigrationsTable(pool, schemaName, format) {
+    const { identifier, timestamp, timestampType } = format.columns;
+    const identifierCol = identifier === "name" ? "name VARCHAR(255) NOT NULL UNIQUE" : "hash TEXT NOT NULL";
+    const timestampCol = timestampType === "bigint" ? `${timestamp} BIGINT NOT NULL` : `${timestamp} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS "${schemaName}"."${format.tableName}" (
+        id SERIAL PRIMARY KEY,
+        ${identifierCol},
+        ${timestampCol}
+      )
+    `);
+  }
+  /**
+   * Check if the migrations table exists in a schema
+   *
+   * @param pool - Database pool to use
+   * @param schemaName - The schema to check
+   * @returns True if migrations table exists
+   *
+   * @example
+   * ```typescript
+   * const pool = await schemaManager.createPool('tenant_123');
+   * if (await schemaManager.migrationsTableExists(pool, 'tenant_123')) {
+   *   console.log('Migrations table exists');
+   * }
+   * ```
+   */
+  async migrationsTableExists(pool, schemaName) {
+    const result = await pool.query(
+      `SELECT 1 FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = $2`,
+      [schemaName, this.migrationsTable]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Get the configured migrations table name
+   *
+   * @returns The migrations table name
+   */
+  getMigrationsTableName() {
+    return this.migrationsTable;
+  }
+};
+
+// src/migrator/drift/column-analyzer.ts
+async function introspectColumns(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      column_name,
+      data_type,
+      udt_name,
+      is_nullable,
+      column_default,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale,
+      ordinal_position
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,
+    [schemaName, tableName]
+  );
+  return result.rows.map((row) => ({
+    name: row.column_name,
+    dataType: row.data_type,
+    udtName: row.udt_name,
+    isNullable: row.is_nullable === "YES",
+    columnDefault: row.column_default,
+    characterMaximumLength: row.character_maximum_length,
+    numericPrecision: row.numeric_precision,
+    numericScale: row.numeric_scale,
+    ordinalPosition: row.ordinal_position
+  }));
+}
+function normalizeDefault(value) {
+  if (value === null) return null;
+  return value.replace(/^'(.+)'::.+$/, "$1").replace(/^(.+)::.+$/, "$1").trim();
+}
+function compareColumns(reference, target) {
+  const drifts = [];
+  const refColMap = new Map(reference.map((c) => [c.name, c]));
+  const targetColMap = new Map(target.map((c) => [c.name, c]));
+  for (const refCol of reference) {
+    const targetCol = targetColMap.get(refCol.name);
+    if (!targetCol) {
+      drifts.push({
+        column: refCol.name,
+        type: "missing",
+        expected: refCol.dataType,
+        description: `Column "${refCol.name}" (${refCol.dataType}) is missing`
+      });
+      continue;
+    }
+    if (refCol.udtName !== targetCol.udtName) {
+      drifts.push({
+        column: refCol.name,
+        type: "type_mismatch",
+        expected: refCol.udtName,
+        actual: targetCol.udtName,
+        description: `Column "${refCol.name}" type mismatch: expected "${refCol.udtName}", got "${targetCol.udtName}"`
+      });
+    }
+    if (refCol.isNullable !== targetCol.isNullable) {
+      drifts.push({
+        column: refCol.name,
+        type: "nullable_mismatch",
+        expected: refCol.isNullable,
+        actual: targetCol.isNullable,
+        description: `Column "${refCol.name}" nullable mismatch: expected ${refCol.isNullable ? "NULL" : "NOT NULL"}, got ${targetCol.isNullable ? "NULL" : "NOT NULL"}`
+      });
+    }
+    const normalizedRefDefault = normalizeDefault(refCol.columnDefault);
+    const normalizedTargetDefault = normalizeDefault(targetCol.columnDefault);
+    if (normalizedRefDefault !== normalizedTargetDefault) {
+      drifts.push({
+        column: refCol.name,
+        type: "default_mismatch",
+        expected: refCol.columnDefault,
+        actual: targetCol.columnDefault,
+        description: `Column "${refCol.name}" default mismatch: expected "${refCol.columnDefault ?? "none"}", got "${targetCol.columnDefault ?? "none"}"`
+      });
+    }
+  }
+  for (const targetCol of target) {
+    if (!refColMap.has(targetCol.name)) {
+      drifts.push({
+        column: targetCol.name,
+        type: "extra",
+        actual: targetCol.dataType,
+        description: `Extra column "${targetCol.name}" (${targetCol.dataType}) not in reference`
+      });
+    }
+  }
+  return drifts;
+}
+
+// src/migrator/drift/index-analyzer.ts
+async function introspectIndexes(pool, schemaName, tableName) {
+  const indexResult = await pool.query(
+    `SELECT indexname, indexdef
+     FROM pg_indexes
+     WHERE schemaname = $1 AND tablename = $2
+     ORDER BY indexname`,
+    [schemaName, tableName]
+  );
+  const indexDetails = await pool.query(
+    `SELECT
+      i.relname as indexname,
+      a.attname as column_name,
+      ix.indisunique as is_unique,
+      ix.indisprimary as is_primary
+     FROM pg_class t
+     JOIN pg_index ix ON t.oid = ix.indrelid
+     JOIN pg_class i ON i.oid = ix.indexrelid
+     JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+     JOIN pg_namespace n ON n.oid = t.relnamespace
+     WHERE n.nspname = $1 AND t.relname = $2
+     ORDER BY i.relname, a.attnum`,
+    [schemaName, tableName]
+  );
+  const indexColumnsMap = /* @__PURE__ */ new Map();
+  for (const row of indexDetails.rows) {
+    const existing = indexColumnsMap.get(row.indexname);
+    if (existing) {
+      existing.columns.push(row.column_name);
+    } else {
+      indexColumnsMap.set(row.indexname, {
+        columns: [row.column_name],
+        isUnique: row.is_unique,
+        isPrimary: row.is_primary
+      });
+    }
+  }
+  return indexResult.rows.map((row) => {
+    const details = indexColumnsMap.get(row.indexname);
+    return {
+      name: row.indexname,
+      columns: details?.columns ?? [],
+      isUnique: details?.isUnique ?? false,
+      isPrimary: details?.isPrimary ?? false,
+      definition: row.indexdef
+    };
+  });
+}
+function compareIndexes(reference, target) {
+  const drifts = [];
+  const refIndexMap = new Map(reference.map((i) => [i.name, i]));
+  const targetIndexMap = new Map(target.map((i) => [i.name, i]));
+  for (const refIndex of reference) {
+    const targetIndex = targetIndexMap.get(refIndex.name);
+    if (!targetIndex) {
+      drifts.push({
+        index: refIndex.name,
+        type: "missing",
+        expected: refIndex.definition,
+        description: `Index "${refIndex.name}" is missing`
+      });
+      continue;
+    }
+    const refCols = refIndex.columns.sort().join(",");
+    const targetCols = targetIndex.columns.sort().join(",");
+    if (refCols !== targetCols || refIndex.isUnique !== targetIndex.isUnique) {
+      drifts.push({
+        index: refIndex.name,
+        type: "definition_mismatch",
+        expected: refIndex.definition,
+        actual: targetIndex.definition,
+        description: `Index "${refIndex.name}" definition differs`
+      });
+    }
+  }
+  for (const targetIndex of target) {
+    if (!refIndexMap.has(targetIndex.name)) {
+      drifts.push({
+        index: targetIndex.name,
+        type: "extra",
+        actual: targetIndex.definition,
+        description: `Extra index "${targetIndex.name}" not in reference`
+      });
+    }
+  }
+  return drifts;
+}
+
+// src/migrator/drift/constraint-analyzer.ts
+async function introspectConstraints(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      tc.constraint_name,
+      tc.constraint_type,
+      kcu.column_name,
+      ccu.table_schema as foreign_table_schema,
+      ccu.table_name as foreign_table_name,
+      ccu.column_name as foreign_column_name,
+      cc.check_clause
+     FROM information_schema.table_constraints tc
+     LEFT JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     LEFT JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.constraint_type = 'FOREIGN KEY'
+     LEFT JOIN information_schema.check_constraints cc
+       ON tc.constraint_name = cc.constraint_name
+       AND tc.constraint_type = 'CHECK'
+     WHERE tc.table_schema = $1 AND tc.table_name = $2
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,
+    [schemaName, tableName]
+  );
+  const constraintMap = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const existing = constraintMap.get(row.constraint_name);
+    if (existing) {
+      if (row.column_name && !existing.columns.includes(row.column_name)) {
+        existing.columns.push(row.column_name);
+      }
+      if (row.foreign_column_name && existing.foreignColumns && !existing.foreignColumns.includes(row.foreign_column_name)) {
+        existing.foreignColumns.push(row.foreign_column_name);
+      }
+    } else {
+      const constraint = {
+        name: row.constraint_name,
+        type: row.constraint_type,
+        columns: row.column_name ? [row.column_name] : []
+      };
+      if (row.foreign_table_name) {
+        constraint.foreignTable = row.foreign_table_name;
+      }
+      if (row.foreign_column_name) {
+        constraint.foreignColumns = [row.foreign_column_name];
+      }
+      if (row.check_clause) {
+        constraint.checkExpression = row.check_clause;
+      }
+      constraintMap.set(row.constraint_name, constraint);
+    }
+  }
+  return Array.from(constraintMap.values());
+}
+function compareConstraints(reference, target) {
+  const drifts = [];
+  const refConstraintMap = new Map(reference.map((c) => [c.name, c]));
+  const targetConstraintMap = new Map(target.map((c) => [c.name, c]));
+  for (const refConstraint of reference) {
+    const targetConstraint = targetConstraintMap.get(refConstraint.name);
+    if (!targetConstraint) {
+      drifts.push({
+        constraint: refConstraint.name,
+        type: "missing",
+        expected: `${refConstraint.type} on (${refConstraint.columns.join(", ")})`,
+        description: `Constraint "${refConstraint.name}" (${refConstraint.type}) is missing`
+      });
+      continue;
+    }
+    const refCols = refConstraint.columns.sort().join(",");
+    const targetCols = targetConstraint.columns.sort().join(",");
+    if (refConstraint.type !== targetConstraint.type || refCols !== targetCols) {
+      drifts.push({
+        constraint: refConstraint.name,
+        type: "definition_mismatch",
+        expected: `${refConstraint.type} on (${refConstraint.columns.join(", ")})`,
+        actual: `${targetConstraint.type} on (${targetConstraint.columns.join(", ")})`,
+        description: `Constraint "${refConstraint.name}" definition differs`
+      });
+    }
+  }
+  for (const targetConstraint of target) {
+    if (!refConstraintMap.has(targetConstraint.name)) {
+      drifts.push({
+        constraint: targetConstraint.name,
+        type: "extra",
+        actual: `${targetConstraint.type} on (${targetConstraint.columns.join(", ")})`,
+        description: `Extra constraint "${targetConstraint.name}" (${targetConstraint.type}) not in reference`
+      });
+    }
+  }
+  return drifts;
+}
+
+// src/migrator/drift/drift-detector.ts
+var DEFAULT_MIGRATIONS_TABLE2 = "__drizzle_migrations";
+var DriftDetector = class {
+  constructor(tenantConfig, schemaManager, driftConfig) {
+    this.tenantConfig = tenantConfig;
+    this.schemaManager = schemaManager;
+    this.driftConfig = driftConfig;
+    this.migrationsTable = driftConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE2;
+  }
+  migrationsTable;
+  /**
+   * Get the schema name for a tenant ID
+   */
+  getSchemaName(tenantId) {
+    return this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+  }
+  /**
+   * Create a pool for a schema
+   */
+  async createPool(schemaName) {
+    return this.schemaManager.createPool(schemaName);
+  }
+  /**
+   * Detect schema drift across all tenants.
+   *
+   * Compares each tenant's schema against a reference tenant (first tenant by default).
+   * Returns a comprehensive report of all differences found.
+   *
+   * @param options - Detection options
+   * @returns Schema drift status with details for each tenant
+   *
+   * @example
+   * ```typescript
+   * // Basic usage - compare all tenants against the first one
+   * const status = await detector.detectDrift();
+   *
+   * // Use a specific tenant as reference
+   * const status = await detector.detectDrift({
+   *   referenceTenant: 'golden-tenant',
+   * });
+   *
+   * // Check specific tenants only
+   * const status = await detector.detectDrift({
+   *   tenantIds: ['tenant-1', 'tenant-2'],
+   * });
+   *
+   * // Skip index and constraint comparison for faster checks
+   * const status = await detector.detectDrift({
+   *   includeIndexes: false,
+   *   includeConstraints: false,
+   * });
+   * ```
+   */
+  async detectDrift(options = {}) {
+    const startTime = Date.now();
     const {
       concurrency = 10,
-      onProgress,
-      onError
+      includeIndexes = true,
+      includeConstraints = true,
+      excludeTables = [this.migrationsTable],
+      onProgress
     } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const tenantIds = options.tenantIds ?? await this.driftConfig.tenantDiscovery();
+    if (tenantIds.length === 0) {
+      return {
+        referenceTenant: "",
+        total: 0,
+        noDrift: 0,
+        withDrift: 0,
+        error: 0,
+        details: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - startTime
+      };
+    }
+    const referenceTenant = options.referenceTenant ?? tenantIds[0];
+    onProgress?.(referenceTenant, "starting");
+    onProgress?.(referenceTenant, "introspecting");
+    const referenceSchema = await this.introspectSchema(referenceTenant, {
+      includeIndexes,
+      includeConstraints,
+      excludeTables
+    });
+    if (!referenceSchema) {
+      return {
+        referenceTenant,
+        total: tenantIds.length,
+        noDrift: 0,
+        withDrift: 0,
+        error: tenantIds.length,
+        details: tenantIds.map((id) => ({
+          tenantId: id,
+          schemaName: this.getSchemaName(id),
+          hasDrift: false,
+          tables: [],
+          issueCount: 0,
+          error: id === referenceTenant ? "Failed to introspect reference tenant" : "Reference tenant introspection failed"
+        })),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: Date.now() - startTime
+      };
+    }
+    onProgress?.(referenceTenant, "completed");
+    const tenantsToCheck = tenantIds.filter((id) => id !== referenceTenant);
     const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
+    results.push({
+      tenantId: referenceTenant,
+      schemaName: referenceSchema.schemaName,
+      hasDrift: false,
+      tables: [],
+      issueCount: 0
+    });
+    for (let i = 0; i < tenantsToCheck.length; i += concurrency) {
+      const batch = tenantsToCheck.slice(i, i + concurrency);
       const batchResults = await Promise.all(
         batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedResult(tenantId);
-          }
           try {
             onProgress?.(tenantId, "starting");
-            const result = await this.markAsApplied(tenantId, { onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
+            onProgress?.(tenantId, "introspecting");
+            const tenantSchema = await this.introspectSchema(tenantId, {
+              includeIndexes,
+              includeConstraints,
+              excludeTables
+            });
+            if (!tenantSchema) {
+              onProgress?.(tenantId, "failed");
+              return {
+                tenantId,
+                schemaName: this.getSchemaName(tenantId),
+                hasDrift: false,
+                tables: [],
+                issueCount: 0,
+                error: "Failed to introspect schema"
+              };
+            }
+            onProgress?.(tenantId, "comparing");
+            const drift = this.compareSchemas(referenceSchema, tenantSchema, {
+              includeIndexes,
+              includeConstraints
+            });
+            onProgress?.(tenantId, "completed");
+            return drift;
           } catch (error) {
             onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorResult(tenantId, error);
+            return {
+              tenantId,
+              schemaName: this.getSchemaName(tenantId),
+              hasDrift: false,
+              tables: [],
+              issueCount: 0,
+              error: error.message
+            };
           }
         })
       );
       results.push(...batchResults);
     }
-    if (aborted) {
-      const remaining = tenantIds.slice(results.length);
-      for (const tenantId of remaining) {
-        results.push(this.createSkippedResult(tenantId));
-      }
-    }
-    return this.aggregateResults(results);
-  }
-  /**
-   * Get sync status for all tenants
-   * Detects divergences between migrations on disk and tracking in database
-   */
-  async getSyncStatus() {
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const statuses = [];
-    for (const tenantId of tenantIds) {
-      statuses.push(await this.getTenantSyncStatus(tenantId, migrations));
-    }
     return {
-      total: statuses.length,
-      inSync: statuses.filter((s) => s.inSync && !s.error).length,
-      outOfSync: statuses.filter((s) => !s.inSync && !s.error).length,
-      error: statuses.filter((s) => !!s.error).length,
-      details: statuses
+      referenceTenant,
+      total: results.length,
+      noDrift: results.filter((r) => !r.hasDrift && !r.error).length,
+      withDrift: results.filter((r) => r.hasDrift && !r.error).length,
+      error: results.filter((r) => !!r.error).length,
+      details: results,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - startTime
     };
   }
   /**
-   * Get sync status for a specific tenant
+   * Compare a specific tenant against a reference tenant.
+   *
+   * @param tenantId - Tenant to check
+   * @param referenceTenantId - Tenant to use as reference
+   * @param options - Introspection options
+   * @returns Drift details for the tenant
+   *
+   * @example
+   * ```typescript
+   * const drift = await detector.compareTenant('tenant-123', 'golden-tenant');
+   * if (drift.hasDrift) {
+   *   console.log(`Found ${drift.issueCount} issues`);
+   * }
+   * ```
    */
-  async getTenantSyncStatus(tenantId, migrations) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = await this.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const migrationNames = new Set(allMigrations.map((m) => m.name));
-      const migrationHashes = new Set(allMigrations.map((m) => m.hash));
-      const tableExists = await this.migrationsTableExists(pool, schemaName);
-      if (!tableExists) {
-        return {
-          tenantId,
-          schemaName,
-          missing: allMigrations.map((m) => m.name),
-          orphans: [],
-          inSync: allMigrations.length === 0,
-          format: null
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedIdentifiers = new Set(applied.map((m) => m.identifier));
-      const missing = allMigrations.filter((m) => !this.isMigrationApplied(m, appliedIdentifiers, format)).map((m) => m.name);
-      const orphans = applied.filter((m) => {
-        if (format.columns.identifier === "name") {
-          return !migrationNames.has(m.identifier);
-        }
-        return !migrationHashes.has(m.identifier) && !migrationNames.has(m.identifier);
-      }).map((m) => m.identifier);
+  async compareTenant(tenantId, referenceTenantId, options = {}) {
+    const {
+      includeIndexes = true,
+      includeConstraints = true,
+      excludeTables = [this.migrationsTable]
+    } = options;
+    const referenceSchema = await this.introspectSchema(referenceTenantId, {
+      includeIndexes,
+      includeConstraints,
+      excludeTables
+    });
+    if (!referenceSchema) {
       return {
         tenantId,
-        schemaName,
-        missing,
-        orphans,
-        inSync: missing.length === 0 && orphans.length === 0,
-        format: format.format
+        schemaName: this.getSchemaName(tenantId),
+        hasDrift: false,
+        tables: [],
+        issueCount: 0,
+        error: "Failed to introspect reference tenant"
       };
-    } catch (error) {
+    }
+    const tenantSchema = await this.introspectSchema(tenantId, {
+      includeIndexes,
+      includeConstraints,
+      excludeTables
+    });
+    if (!tenantSchema) {
       return {
         tenantId,
-        schemaName,
-        missing: [],
-        orphans: [],
-        inSync: false,
-        format: null,
-        error: error.message
+        schemaName: this.getSchemaName(tenantId),
+        hasDrift: false,
+        tables: [],
+        issueCount: 0,
+        error: "Failed to introspect tenant schema"
       };
-    } finally {
-      await pool.end();
     }
+    return this.compareSchemas(referenceSchema, tenantSchema, {
+      includeIndexes,
+      includeConstraints
+    });
   }
   /**
-   * Mark missing migrations as applied for a tenant
-   */
-  async markMissing(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.createPool(schemaName);
+   * Introspect a tenant's schema structure.
+   *
+   * Retrieves all tables, columns, indexes, and constraints
+   * for a tenant's schema.
+   *
+   * @param tenantId - Tenant to introspect
+   * @param options - Introspection options
+   * @returns Schema structure or null if introspection fails
+   *
+   * @example
+   * ```typescript
+   * const schema = await detector.introspectSchema('tenant-123');
+   * if (schema) {
+   *   console.log(`Found ${schema.tables.length} tables`);
+   *   for (const table of schema.tables) {
+   *     console.log(`  ${table.name}: ${table.columns.length} columns`);
+   *   }
+   * }
+   * ```
+   */
+  async introspectSchema(tenantId, options = {}) {
+    const schemaName = this.getSchemaName(tenantId);
+    const pool = await this.createPool(schemaName);
     try {
-      const syncStatus = await this.getTenantSyncStatus(tenantId);
-      if (syncStatus.error) {
-        return {
-          tenantId,
-          schemaName,
-          success: false,
-          markedMigrations: [],
-          removedOrphans: [],
-          error: syncStatus.error,
-          durationMs: Date.now() - startTime
-        };
+      const tables = await this.introspectTables(pool, schemaName, options);
+      return {
+        tenantId,
+        schemaName,
+        tables,
+        introspectedAt: /* @__PURE__ */ new Date()
+      };
+    } catch {
+      return null;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Compare two schema snapshots.
+   *
+   * This method compares pre-introspected schema snapshots,
+   * useful when you already have the schema data available.
+   *
+   * @param reference - Reference (expected) schema
+   * @param target - Target (actual) schema
+   * @param options - Comparison options
+   * @returns Drift details
+   *
+   * @example
+   * ```typescript
+   * const refSchema = await detector.introspectSchema('golden-tenant');
+   * const targetSchema = await detector.introspectSchema('tenant-123');
+   *
+   * if (refSchema && targetSchema) {
+   *   const drift = detector.compareSchemas(refSchema, targetSchema);
+   *   console.log(`Drift detected: ${drift.hasDrift}`);
+   * }
+   * ```
+   */
+  compareSchemas(reference, target, options = {}) {
+    const { includeIndexes = true, includeConstraints = true } = options;
+    const tableDrifts = [];
+    let totalIssues = 0;
+    const refTableMap = new Map(reference.tables.map((t) => [t.name, t]));
+    const targetTableMap = new Map(target.tables.map((t) => [t.name, t]));
+    for (const refTable of reference.tables) {
+      const targetTable = targetTableMap.get(refTable.name);
+      if (!targetTable) {
+        tableDrifts.push({
+          table: refTable.name,
+          status: "missing",
+          columns: refTable.columns.map((c) => ({
+            column: c.name,
+            type: "missing",
+            expected: c.dataType,
+            description: `Column "${c.name}" (${c.dataType}) is missing`
+          })),
+          indexes: [],
+          constraints: []
+        });
+        totalIssues += refTable.columns.length;
+        continue;
       }
-      if (syncStatus.missing.length === 0) {
-        return {
-          tenantId,
-          schemaName,
-          success: true,
-          markedMigrations: [],
-          removedOrphans: [],
-          durationMs: Date.now() - startTime
-        };
+      const columnDrifts = compareColumns(refTable.columns, targetTable.columns);
+      const indexDrifts = includeIndexes ? compareIndexes(refTable.indexes, targetTable.indexes) : [];
+      const constraintDrifts = includeConstraints ? compareConstraints(refTable.constraints, targetTable.constraints) : [];
+      const issues = columnDrifts.length + indexDrifts.length + constraintDrifts.length;
+      totalIssues += issues;
+      if (issues > 0) {
+        tableDrifts.push({
+          table: refTable.name,
+          status: "drifted",
+          columns: columnDrifts,
+          indexes: indexDrifts,
+          constraints: constraintDrifts
+        });
       }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.loadMigrations();
-      const missingSet = new Set(syncStatus.missing);
-      for (const migration of allMigrations) {
-        if (missingSet.has(migration.name)) {
-          await this.recordMigration(pool, schemaName, migration, format);
-          markedMigrations.push(migration.name);
-        }
+    }
+    for (const targetTable of target.tables) {
+      if (!refTableMap.has(targetTable.name)) {
+        tableDrifts.push({
+          table: targetTable.name,
+          status: "extra",
+          columns: targetTable.columns.map((c) => ({
+            column: c.name,
+            type: "extra",
+            actual: c.dataType,
+            description: `Extra column "${c.name}" (${c.dataType}) not in reference`
+          })),
+          indexes: [],
+          constraints: []
+        });
+        totalIssues += targetTable.columns.length;
+      }
+    }
+    return {
+      tenantId: target.tenantId,
+      schemaName: target.schemaName,
+      hasDrift: totalIssues > 0,
+      tables: tableDrifts,
+      issueCount: totalIssues
+    };
+  }
+  /**
+   * Introspect all tables in a schema
+   */
+  async introspectTables(pool, schemaName, options) {
+    const { includeIndexes = true, includeConstraints = true, excludeTables = [] } = options;
+    const tablesResult = await pool.query(
+      `SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = $1
+         AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+      [schemaName]
+    );
+    const tables = [];
+    for (const row of tablesResult.rows) {
+      if (excludeTables.includes(row.table_name)) {
+        continue;
       }
+      const columns = await introspectColumns(pool, schemaName, row.table_name);
+      const indexes = includeIndexes ? await introspectIndexes(pool, schemaName, row.table_name) : [];
+      const constraints = includeConstraints ? await introspectConstraints(pool, schemaName, row.table_name) : [];
+      tables.push({
+        name: row.table_name,
+        columns,
+        indexes,
+        constraints
+      });
+    }
+    return tables;
+  }
+};
+var Seeder = class {
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+  }
+  /**
+   * Seed a single tenant with initial data
+   *
+   * Creates a database connection for the tenant, executes the seed function,
+   * and properly cleans up the connection afterward.
+   *
+   * @param tenantId - The tenant identifier
+   * @param seedFn - Function that seeds the database
+   * @returns Result of the seeding operation
+   *
+   * @example
+   * ```typescript
+   * const result = await seeder.seedTenant('tenant-123', async (db, tenantId) => {
+   *   await db.insert(users).values([
+   *     { name: 'Admin', email: `admin@${tenantId}.com` },
+   *   ]);
+   * });
+   *
+   * if (result.success) {
+   *   console.log(`Seeded ${result.tenantId} in ${result.durationMs}ms`);
+   * }
+   * ```
+   */
+  async seedTenant(tenantId, seedFn) {
+    const startTime = Date.now();
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      const db = drizzle(pool, {
+        schema: this.deps.tenantSchema
+      });
+      await seedFn(db, tenantId);
       return {
         tenantId,
         schemaName,
         success: true,
-        markedMigrations,
-        removedOrphans: [],
         durationMs: Date.now() - startTime
       };
     } catch (error) {
@@ -1428,8 +2328,6 @@ var Migrator = class {
         tenantId,
         schemaName,
         success: false,
-        markedMigrations,
-        removedOrphans: [],
         error: error.message,
         durationMs: Date.now() - startTime
       };
@@ -1438,11 +2336,33 @@ var Migrator = class {
     }
   }
   /**
-   * Mark missing migrations as applied for all tenants
+   * Seed all tenants with initial data in parallel
+   *
+   * Discovers all tenants and seeds them in batches with configurable concurrency.
+   * Supports progress callbacks and abort-on-error behavior.
+   *
+   * @param seedFn - Function that seeds each database
+   * @param options - Seeding options
+   * @returns Aggregate results of all seeding operations
+   *
+   * @example
+   * ```typescript
+   * const results = await seeder.seedAll(
+   *   async (db, tenantId) => {
+   *     await db.insert(settings).values({ key: 'initialized', value: 'true' });
+   *   },
+   *   {
+   *     concurrency: 5,
+   *     onProgress: (id, status) => console.log(`${id}: ${status}`),
+   *   }
+   * );
+   *
+   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+   * ```
    */
-  async markAllMissing(options = {}) {
+  async seedAll(seedFn, options = {}) {
     const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const tenantIds = await this.config.tenantDiscovery();
     const results = [];
     let aborted = false;
     for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
@@ -1450,11 +2370,12 @@ var Migrator = class {
       const batchResults = await Promise.all(
         batch.map(async (tenantId) => {
           if (aborted) {
-            return this.createSkippedSyncResult(tenantId);
+            return this.createSkippedResult(tenantId);
           }
           try {
             onProgress?.(tenantId, "starting");
-            const result = await this.markMissing(tenantId);
+            onProgress?.(tenantId, "seeding");
+            const result = await this.seedTenant(tenantId, seedFn);
             onProgress?.(tenantId, result.success ? "completed" : "failed");
             return result;
           } catch (error) {
@@ -1463,67 +2384,409 @@ var Migrator = class {
             if (action === "abort") {
               aborted = true;
             }
-            return this.createErrorSyncResult(tenantId, error);
+            return this.createErrorResult(tenantId, error);
           }
         })
       );
       results.push(...batchResults);
     }
-    return this.aggregateSyncResults(results);
+    if (aborted) {
+      const remaining = tenantIds.slice(results.length);
+      for (const tenantId of remaining) {
+        results.push(this.createSkippedResult(tenantId));
+      }
+    }
+    return this.aggregateResults(results);
   }
   /**
-   * Remove orphan migration records for a tenant
+   * Seed specific tenants with initial data
+   *
+   * Seeds only the specified tenants in batches with configurable concurrency.
+   *
+   * @param tenantIds - List of tenant IDs to seed
+   * @param seedFn - Function that seeds each database
+   * @param options - Seeding options
+   * @returns Aggregate results of seeding operations
+   *
+   * @example
+   * ```typescript
+   * const results = await seeder.seedTenants(
+   *   ['tenant-1', 'tenant-2', 'tenant-3'],
+   *   async (db) => {
+   *     await db.insert(config).values({ setup: true });
+   *   },
+   *   { concurrency: 2 }
+   * );
+   * ```
    */
-  async cleanOrphans(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const removedOrphans = [];
-    const pool = await this.createPool(schemaName);
+  async seedTenants(tenantIds, seedFn, options = {}) {
+    const { concurrency = 10, onProgress, onError } = options;
+    const results = [];
+    for (let i = 0; i < tenantIds.length; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          try {
+            onProgress?.(tenantId, "starting");
+            onProgress?.(tenantId, "seeding");
+            const result = await this.seedTenant(tenantId, seedFn);
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            onError?.(tenantId, error);
+            return this.createErrorResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Create a skipped result for aborted seeding
+   */
+  createSkippedResult(tenantId) {
+    return {
+      tenantId,
+      schemaName: this.deps.schemaNameTemplate(tenantId),
+      success: false,
+      error: "Skipped due to abort",
+      durationMs: 0
+    };
+  }
+  /**
+   * Create an error result for failed seeding
+   */
+  createErrorResult(tenantId, error) {
+    return {
+      tenantId,
+      schemaName: this.deps.schemaNameTemplate(tenantId),
+      success: false,
+      error: error.message,
+      durationMs: 0
+    };
+  }
+  /**
+   * Aggregate individual results into a summary
+   */
+  aggregateResults(results) {
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter(
+        (r) => !r.success && r.error !== "Skipped due to abort"
+      ).length,
+      skipped: results.filter((r) => r.error === "Skipped due to abort").length,
+      details: results
+    };
+  }
+};
+
+// src/migrator/sync/sync-manager.ts
+var SyncManager = class {
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+  }
+  /**
+   * Get sync status for all tenants
+   *
+   * Detects divergences between migrations on disk and tracking in database.
+   * A tenant is "in sync" when all disk migrations are tracked and no orphan records exist.
+   *
+   * @returns Aggregate sync status for all tenants
+   *
+   * @example
+   * ```typescript
+   * const status = await syncManager.getSyncStatus();
+   * console.log(`Total: ${status.total}, In sync: ${status.inSync}, Out of sync: ${status.outOfSync}`);
+   *
+   * for (const tenant of status.details.filter(d => !d.inSync)) {
+   *   console.log(`${tenant.tenantId}: missing=${tenant.missing.length}, orphans=${tenant.orphans.length}`);
+   * }
+   * ```
+   */
+  async getSyncStatus() {
+    const tenantIds = await this.config.tenantDiscovery();
+    const migrations = await this.deps.loadMigrations();
+    const statuses = [];
+    for (const tenantId of tenantIds) {
+      statuses.push(await this.getTenantSyncStatus(tenantId, migrations));
+    }
+    return {
+      total: statuses.length,
+      inSync: statuses.filter((s) => s.inSync && !s.error).length,
+      outOfSync: statuses.filter((s) => !s.inSync && !s.error).length,
+      error: statuses.filter((s) => !!s.error).length,
+      details: statuses
+    };
+  }
+  /**
+   * Get sync status for a specific tenant
+   *
+   * Compares migrations on disk with records in the database.
+   * Identifies missing migrations (on disk but not tracked) and
+   * orphan records (tracked but not on disk).
+   *
+   * @param tenantId - The tenant identifier
+   * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
+   * @returns Sync status for the tenant
+   *
+   * @example
+   * ```typescript
+   * const status = await syncManager.getTenantSyncStatus('tenant-123');
+   * if (status.missing.length > 0) {
+   *   console.log(`Missing: ${status.missing.join(', ')}`);
+   * }
+   * if (status.orphans.length > 0) {
+   *   console.log(`Orphans: ${status.orphans.join(', ')}`);
+   * }
+   * ```
+   */
+  async getTenantSyncStatus(tenantId, migrations) {
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const pool = await this.deps.createPool(schemaName);
     try {
-      const syncStatus = await this.getTenantSyncStatus(tenantId);
-      if (syncStatus.error) {
-        return {
-          tenantId,
-          schemaName,
-          success: false,
-          markedMigrations: [],
-          removedOrphans: [],
-          error: syncStatus.error,
-          durationMs: Date.now() - startTime
-        };
-      }
-      if (syncStatus.orphans.length === 0) {
+      const allMigrations = migrations ?? await this.deps.loadMigrations();
+      const migrationNames = new Set(allMigrations.map((m) => m.name));
+      const migrationHashes = new Set(allMigrations.map((m) => m.hash));
+      const tableExists = await this.deps.migrationsTableExists(pool, schemaName);
+      if (!tableExists) {
         return {
           tenantId,
           schemaName,
-          success: true,
-          markedMigrations: [],
-          removedOrphans: [],
-          durationMs: Date.now() - startTime
+          missing: allMigrations.map((m) => m.name),
+          orphans: [],
+          inSync: allMigrations.length === 0,
+          format: null
         };
       }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const identifierColumn = format.columns.identifier;
-      for (const orphan of syncStatus.orphans) {
-        await pool.query(
-          `DELETE FROM "${schemaName}"."${format.tableName}" WHERE "${identifierColumn}" = $1`,
-          [orphan]
-        );
-        removedOrphans.push(orphan);
-      }
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedIdentifiers = new Set(applied.map((m) => m.identifier));
+      const missing = allMigrations.filter((m) => !this.isMigrationApplied(m, appliedIdentifiers, format)).map((m) => m.name);
+      const orphans = applied.filter((m) => {
+        if (format.columns.identifier === "name") {
+          return !migrationNames.has(m.identifier);
+        }
+        return !migrationHashes.has(m.identifier) && !migrationNames.has(m.identifier);
+      }).map((m) => m.identifier);
       return {
         tenantId,
         schemaName,
-        success: true,
-        markedMigrations: [],
-        removedOrphans,
-        durationMs: Date.now() - startTime
+        missing,
+        orphans,
+        inSync: missing.length === 0 && orphans.length === 0,
+        format: format.format
       };
     } catch (error) {
       return {
         tenantId,
         schemaName,
-        success: false,
+        missing: [],
+        orphans: [],
+        inSync: false,
+        format: null,
+        error: error.message
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark missing migrations as applied for a tenant
+   *
+   * Records migrations that exist on disk but are not tracked in the database.
+   * Useful for syncing tracking state with already-applied migrations.
+   *
+   * @param tenantId - The tenant identifier
+   * @returns Result of the mark operation
+   *
+   * @example
+   * ```typescript
+   * const result = await syncManager.markMissing('tenant-123');
+   * if (result.success) {
+   *   console.log(`Marked ${result.markedMigrations.length} migrations as applied`);
+   * }
+   * ```
+   */
+  async markMissing(tenantId) {
+    const startTime = Date.now();
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const markedMigrations = [];
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      const syncStatus = await this.getTenantSyncStatus(tenantId);
+      if (syncStatus.error) {
+        return {
+          tenantId,
+          schemaName,
+          success: false,
+          markedMigrations: [],
+          removedOrphans: [],
+          error: syncStatus.error,
+          durationMs: Date.now() - startTime
+        };
+      }
+      if (syncStatus.missing.length === 0) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          markedMigrations: [],
+          removedOrphans: [],
+          durationMs: Date.now() - startTime
+        };
+      }
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      await this.deps.ensureMigrationsTable(pool, schemaName, format);
+      const allMigrations = await this.deps.loadMigrations();
+      const missingSet = new Set(syncStatus.missing);
+      for (const migration of allMigrations) {
+        if (missingSet.has(migration.name)) {
+          await this.recordMigration(pool, schemaName, migration, format);
+          markedMigrations.push(migration.name);
+        }
+      }
+      return {
+        tenantId,
+        schemaName,
+        success: true,
+        markedMigrations,
+        removedOrphans: [],
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
+        markedMigrations,
+        removedOrphans: [],
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark missing migrations as applied for all tenants
+   *
+   * Processes all tenants in parallel with configurable concurrency.
+   * Supports progress callbacks and abort-on-error behavior.
+   *
+   * @param options - Sync options
+   * @returns Aggregate results of all mark operations
+   *
+   * @example
+   * ```typescript
+   * const results = await syncManager.markAllMissing({
+   *   concurrency: 10,
+   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+   * });
+   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+   * ```
+   */
+  async markAllMissing(options = {}) {
+    const { concurrency = 10, onProgress, onError } = options;
+    const tenantIds = await this.config.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedSyncResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.markMissing(tenantId);
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateSyncResults(results);
+  }
+  /**
+   * Remove orphan migration records for a tenant
+   *
+   * Deletes records from the migrations table that don't have
+   * corresponding files on disk.
+   *
+   * @param tenantId - The tenant identifier
+   * @returns Result of the clean operation
+   *
+   * @example
+   * ```typescript
+   * const result = await syncManager.cleanOrphans('tenant-123');
+   * if (result.success) {
+   *   console.log(`Removed ${result.removedOrphans.length} orphan records`);
+   * }
+   * ```
+   */
+  async cleanOrphans(tenantId) {
+    const startTime = Date.now();
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const removedOrphans = [];
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      const syncStatus = await this.getTenantSyncStatus(tenantId);
+      if (syncStatus.error) {
+        return {
+          tenantId,
+          schemaName,
+          success: false,
+          markedMigrations: [],
+          removedOrphans: [],
+          error: syncStatus.error,
+          durationMs: Date.now() - startTime
+        };
+      }
+      if (syncStatus.orphans.length === 0) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          markedMigrations: [],
+          removedOrphans: [],
+          durationMs: Date.now() - startTime
+        };
+      }
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      const identifierColumn = format.columns.identifier;
+      for (const orphan of syncStatus.orphans) {
+        await pool.query(
+          `DELETE FROM "${schemaName}"."${format.tableName}" WHERE "${identifierColumn}" = $1`,
+          [orphan]
+        );
+        removedOrphans.push(orphan);
+      }
+      return {
+        tenantId,
+        schemaName,
+        success: true,
+        markedMigrations: [],
+        removedOrphans,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
         markedMigrations: [],
         removedOrphans,
         error: error.message,
@@ -1534,38 +2797,1498 @@ var Migrator = class {
     }
   }
   /**
-   * Remove orphan migration records for all tenants
+   * Remove orphan migration records for all tenants
+   *
+   * Processes all tenants in parallel with configurable concurrency.
+   * Supports progress callbacks and abort-on-error behavior.
+   *
+   * @param options - Sync options
+   * @returns Aggregate results of all clean operations
+   *
+   * @example
+   * ```typescript
+   * const results = await syncManager.cleanAllOrphans({
+   *   concurrency: 10,
+   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+   * });
+   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+   * ```
+   */
+  async cleanAllOrphans(options = {}) {
+    const { concurrency = 10, onProgress, onError } = options;
+    const tenantIds = await this.config.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedSyncResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.cleanOrphans(tenantId);
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateSyncResults(results);
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  /**
+   * Get applied migrations for a schema
+   */
+  async getAppliedMigrations(pool, schemaName, format) {
+    const identifierColumn = format.columns.identifier;
+    const timestampColumn = format.columns.timestamp;
+    const result = await pool.query(
+      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
+       FROM "${schemaName}"."${format.tableName}"
+       ORDER BY id`
+    );
+    return result.rows.map((row) => {
+      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
+      return {
+        identifier: row.identifier,
+        appliedAt
+      };
+    });
+  }
+  /**
+   * Check if a migration has been applied
+   */
+  isMigrationApplied(migration, appliedIdentifiers, format) {
+    if (format.columns.identifier === "name") {
+      return appliedIdentifiers.has(migration.name);
+    }
+    return appliedIdentifiers.has(migration.hash) || appliedIdentifiers.has(migration.name);
+  }
+  /**
+   * Record a migration as applied (without executing SQL)
+   */
+  async recordMigration(pool, schemaName, migration, format) {
+    const { identifier, timestamp, timestampType } = format.columns;
+    const identifierValue = identifier === "name" ? migration.name : migration.hash;
+    const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
+    await pool.query(
+      `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+      [identifierValue, timestampValue]
+    );
+  }
+  /**
+   * Create a skipped sync result for aborted operations
+   */
+  createSkippedSyncResult(tenantId) {
+    return {
+      tenantId,
+      schemaName: this.deps.schemaNameTemplate(tenantId),
+      success: false,
+      markedMigrations: [],
+      removedOrphans: [],
+      error: "Skipped due to abort",
+      durationMs: 0
+    };
+  }
+  /**
+   * Create an error sync result for failed operations
+   */
+  createErrorSyncResult(tenantId, error) {
+    return {
+      tenantId,
+      schemaName: this.deps.schemaNameTemplate(tenantId),
+      success: false,
+      markedMigrations: [],
+      removedOrphans: [],
+      error: error.message,
+      durationMs: 0
+    };
+  }
+  /**
+   * Aggregate individual sync results into a summary
+   */
+  aggregateSyncResults(results) {
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      details: results
+    };
+  }
+};
+
+// src/migrator/executor/migration-executor.ts
+var MigrationExecutor = class {
+  constructor(config, deps) {
+    this.config = config;
+    this.deps = deps;
+  }
+  /**
+   * Migrate a single tenant
+   *
+   * Applies all pending migrations to the tenant's schema.
+   * Creates the migrations table if it doesn't exist.
+   *
+   * @param tenantId - The tenant identifier
+   * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
+   * @param options - Migration options (dryRun, onProgress)
+   * @returns Migration result with applied migrations and duration
+   *
+   * @example
+   * ```typescript
+   * const result = await executor.migrateTenant('tenant-123', undefined, {
+   *   dryRun: false,
+   *   onProgress: (id, status, name) => console.log(`${id}: ${status} ${name}`),
+   * });
+   *
+   * if (result.success) {
+   *   console.log(`Applied ${result.appliedMigrations.length} migrations`);
+   * }
+   * ```
+   */
+  async migrateTenant(tenantId, migrations, options = {}) {
+    const startTime = Date.now();
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const appliedMigrations = [];
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      await this.config.hooks?.beforeTenant?.(tenantId);
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      await this.deps.ensureMigrationsTable(pool, schemaName, format);
+      const allMigrations = migrations ?? await this.deps.loadMigrations();
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
+      if (options.dryRun) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          appliedMigrations: pending.map((m) => m.name),
+          durationMs: Date.now() - startTime,
+          format: format.format
+        };
+      }
+      for (const migration of pending) {
+        const migrationStart = Date.now();
+        options.onProgress?.(tenantId, "migrating", migration.name);
+        await this.config.hooks?.beforeMigration?.(tenantId, migration.name);
+        await this.applyMigration(pool, schemaName, migration, format);
+        await this.config.hooks?.afterMigration?.(
+          tenantId,
+          migration.name,
+          Date.now() - migrationStart
+        );
+        appliedMigrations.push(migration.name);
+      }
+      const result = {
+        tenantId,
+        schemaName,
+        success: true,
+        appliedMigrations,
+        durationMs: Date.now() - startTime,
+        format: format.format
+      };
+      await this.config.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } catch (error) {
+      const result = {
+        tenantId,
+        schemaName,
+        success: false,
+        appliedMigrations,
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+      await this.config.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark migrations as applied without executing SQL
+   *
+   * Useful for syncing tracking state with already-applied migrations
+   * or when migrations were applied manually.
+   *
+   * @param tenantId - The tenant identifier
+   * @param options - Options with progress callback
+   * @returns Result with list of marked migrations
+   *
+   * @example
+   * ```typescript
+   * const result = await executor.markAsApplied('tenant-123', {
+   *   onProgress: (id, status, name) => console.log(`${id}: marking ${name}`),
+   * });
+   *
+   * console.log(`Marked ${result.appliedMigrations.length} migrations`);
+   * ```
+   */
+  async markAsApplied(tenantId, options = {}) {
+    const startTime = Date.now();
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const markedMigrations = [];
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      await this.config.hooks?.beforeTenant?.(tenantId);
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      await this.deps.ensureMigrationsTable(pool, schemaName, format);
+      const allMigrations = await this.deps.loadMigrations();
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
+      for (const migration of pending) {
+        const migrationStart = Date.now();
+        options.onProgress?.(tenantId, "migrating", migration.name);
+        await this.config.hooks?.beforeMigration?.(tenantId, migration.name);
+        await this.recordMigration(pool, schemaName, migration, format);
+        await this.config.hooks?.afterMigration?.(
+          tenantId,
+          migration.name,
+          Date.now() - migrationStart
+        );
+        markedMigrations.push(migration.name);
+      }
+      const result = {
+        tenantId,
+        schemaName,
+        success: true,
+        appliedMigrations: markedMigrations,
+        durationMs: Date.now() - startTime,
+        format: format.format
+      };
+      await this.config.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } catch (error) {
+      const result = {
+        tenantId,
+        schemaName,
+        success: false,
+        appliedMigrations: markedMigrations,
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+      await this.config.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Get migration status for a specific tenant
+   *
+   * Returns information about applied and pending migrations.
+   *
+   * @param tenantId - The tenant identifier
+   * @param migrations - Optional pre-loaded migrations
+   * @returns Migration status with counts and pending list
+   *
+   * @example
+   * ```typescript
+   * const status = await executor.getTenantStatus('tenant-123');
+   * if (status.status === 'behind') {
+   *   console.log(`Pending: ${status.pendingMigrations.join(', ')}`);
+   * }
+   * ```
+   */
+  async getTenantStatus(tenantId, migrations) {
+    const schemaName = this.deps.schemaNameTemplate(tenantId);
+    const pool = await this.deps.createPool(schemaName);
+    try {
+      const allMigrations = migrations ?? await this.deps.loadMigrations();
+      const tableExists = await this.deps.migrationsTableExists(pool, schemaName);
+      if (!tableExists) {
+        return {
+          tenantId,
+          schemaName,
+          appliedCount: 0,
+          pendingCount: allMigrations.length,
+          pendingMigrations: allMigrations.map((m) => m.name),
+          status: allMigrations.length > 0 ? "behind" : "ok",
+          format: null
+        };
+      }
+      const format = await this.deps.getOrDetectFormat(pool, schemaName);
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: applied.length,
+        pendingCount: pending.length,
+        pendingMigrations: pending.map((m) => m.name),
+        status: pending.length > 0 ? "behind" : "ok",
+        format: format.format
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: 0,
+        pendingCount: 0,
+        pendingMigrations: [],
+        status: "error",
+        error: error.message,
+        format: null
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  // ============================================================================
+  // IMigrationExecutor Interface Methods
+  // ============================================================================
+  /**
+   * Execute a single migration on a schema
+   */
+  async executeMigration(pool, schemaName, migration, format, options) {
+    if (options?.markOnly) {
+      options.onProgress?.("recording");
+      await this.recordMigration(pool, schemaName, migration, format);
+    } else {
+      options?.onProgress?.("applying");
+      await this.applyMigration(pool, schemaName, migration, format);
+    }
+  }
+  /**
+   * Execute multiple migrations on a schema
+   */
+  async executeMigrations(pool, schemaName, migrations, format, options) {
+    const appliedNames = [];
+    for (const migration of migrations) {
+      await this.executeMigration(pool, schemaName, migration, format, options);
+      appliedNames.push(migration.name);
+    }
+    return appliedNames;
+  }
+  /**
+   * Record a migration as applied without executing SQL
+   */
+  async recordMigration(pool, schemaName, migration, format) {
+    const { identifier, timestamp, timestampType } = format.columns;
+    const identifierValue = identifier === "name" ? migration.name : migration.hash;
+    const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
+    await pool.query(
+      `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+      [identifierValue, timestampValue]
+    );
+  }
+  /**
+   * Get list of applied migrations for a tenant
+   */
+  async getAppliedMigrations(pool, schemaName, format) {
+    const identifierColumn = format.columns.identifier;
+    const timestampColumn = format.columns.timestamp;
+    const result = await pool.query(
+      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
+       FROM "${schemaName}"."${format.tableName}"
+       ORDER BY id`
+    );
+    return result.rows.map((row) => {
+      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
+      return {
+        identifier: row.identifier,
+        // Set name or hash based on format
+        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: row.identifier },
+        appliedAt
+      };
+    });
+  }
+  /**
+   * Get pending migrations (not yet applied)
+   */
+  async getPendingMigrations(pool, schemaName, allMigrations, format) {
+    const applied = await this.getAppliedMigrations(pool, schemaName, format);
+    const appliedSet = new Set(applied.map((m) => m.identifier));
+    return allMigrations.filter(
+      (m) => !this.isMigrationApplied(m, appliedSet, format)
+    );
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  /**
+   * Check if a migration has been applied
+   */
+  isMigrationApplied(migration, appliedIdentifiers, format) {
+    if (format.columns.identifier === "name") {
+      return appliedIdentifiers.has(migration.name);
+    }
+    return appliedIdentifiers.has(migration.hash) || appliedIdentifiers.has(migration.name);
+  }
+  /**
+   * Apply a migration to a schema (execute SQL + record)
+   */
+  async applyMigration(pool, schemaName, migration, format) {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(migration.sql);
+      const { identifier, timestamp, timestampType } = format.columns;
+      const identifierValue = identifier === "name" ? migration.name : migration.hash;
+      const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
+      await client.query(
+        `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+        [identifierValue, timestampValue]
+      );
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+};
+
+// src/migrator/executor/batch-executor.ts
+var BatchExecutor = class {
+  constructor(config, executor, loadMigrations) {
+    this.config = config;
+    this.executor = executor;
+    this.loadMigrations = loadMigrations;
+  }
+  /**
+   * Migrate all tenants in parallel
+   *
+   * Processes tenants in batches with configurable concurrency.
+   * Supports progress callbacks, error handling, and abort behavior.
+   *
+   * @param options - Migration options (concurrency, dryRun, callbacks)
+   * @returns Aggregate results for all tenants
+   *
+   * @example
+   * ```typescript
+   * const results = await batchExecutor.migrateAll({
+   *   concurrency: 10,
+   *   dryRun: false,
+   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+   *   onError: (id, error) => {
+   *     console.error(`${id} failed: ${error.message}`);
+   *     return 'continue'; // or 'abort' to stop all
+   *   },
+   * });
+   *
+   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
+   * ```
+   */
+  async migrateAll(options = {}) {
+    const {
+      concurrency = 10,
+      onProgress,
+      onError,
+      dryRun = false
+    } = options;
+    const tenantIds = await this.config.tenantDiscovery();
+    const migrations = await this.loadMigrations();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.executor.migrateTenant(tenantId, migrations, { dryRun, onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    if (aborted) {
+      const remaining = tenantIds.slice(results.length);
+      for (const tenantId of remaining) {
+        results.push(this.createSkippedResult(tenantId));
+      }
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Migrate specific tenants in parallel
+   *
+   * Same as migrateAll but for a subset of tenants.
+   *
+   * @param tenantIds - List of tenant IDs to migrate
+   * @param options - Migration options
+   * @returns Aggregate results for specified tenants
+   *
+   * @example
+   * ```typescript
+   * const results = await batchExecutor.migrateTenants(
+   *   ['tenant-1', 'tenant-2', 'tenant-3'],
+   *   { concurrency: 5 }
+   * );
+   * ```
+   */
+  async migrateTenants(tenantIds, options = {}) {
+    const migrations = await this.loadMigrations();
+    const results = [];
+    const { concurrency = 10, onProgress, onError, dryRun = false } = options;
+    for (let i = 0; i < tenantIds.length; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.executor.migrateTenant(tenantId, migrations, { dryRun, onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            onError?.(tenantId, error);
+            return this.createErrorResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Mark all tenants as applied without executing SQL
+   *
+   * Useful for syncing tracking state with already-applied migrations.
+   * Processes tenants in parallel with configurable concurrency.
+   *
+   * @param options - Migration options
+   * @returns Aggregate results for all tenants
+   *
+   * @example
+   * ```typescript
+   * const results = await batchExecutor.markAllAsApplied({
+   *   concurrency: 10,
+   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
+   * });
+   * ```
+   */
+  async markAllAsApplied(options = {}) {
+    const {
+      concurrency = 10,
+      onProgress,
+      onError
+    } = options;
+    const tenantIds = await this.config.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.executor.markAsApplied(tenantId, { onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    if (aborted) {
+      const remaining = tenantIds.slice(results.length);
+      for (const tenantId of remaining) {
+        results.push(this.createSkippedResult(tenantId));
+      }
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Get migration status for all tenants
+   *
+   * Queries each tenant's migration status sequentially.
+   *
+   * @returns List of migration status for all tenants
+   *
+   * @example
+   * ```typescript
+   * const statuses = await batchExecutor.getStatus();
+   * const behind = statuses.filter(s => s.status === 'behind');
+   * console.log(`${behind.length} tenants need migrations`);
+   * ```
+   */
+  async getStatus() {
+    const tenantIds = await this.config.tenantDiscovery();
+    const migrations = await this.loadMigrations();
+    const statuses = [];
+    for (const tenantId of tenantIds) {
+      statuses.push(await this.executor.getTenantStatus(tenantId, migrations));
+    }
+    return statuses;
+  }
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+  /**
+   * Create a skipped result for aborted operations
+   */
+  createSkippedResult(tenantId) {
+    return {
+      tenantId,
+      schemaName: "",
+      // Schema name not available in batch context
+      success: false,
+      appliedMigrations: [],
+      error: "Skipped due to abort",
+      durationMs: 0
+    };
+  }
+  /**
+   * Create an error result for failed operations
+   */
+  createErrorResult(tenantId, error) {
+    return {
+      tenantId,
+      schemaName: "",
+      // Schema name not available in batch context
+      success: false,
+      appliedMigrations: [],
+      error: error.message,
+      durationMs: 0
+    };
+  }
+  /**
+   * Aggregate individual migration results into a summary
+   */
+  aggregateResults(results) {
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success && r.error !== "Skipped due to abort").length,
+      skipped: results.filter((r) => r.error === "Skipped due to abort").length,
+      details: results
+    };
+  }
+};
+
+// src/migrator/clone/ddl-generator.ts
+async function listTables(pool, schemaName, excludeTables = []) {
+  const excludePlaceholders = excludeTables.length > 0 ? excludeTables.map((_, i) => `$${i + 2}`).join(", ") : "''::text";
+  const result = await pool.query(
+    `SELECT table_name
+     FROM information_schema.tables
+     WHERE table_schema = $1
+       AND table_type = 'BASE TABLE'
+       AND table_name NOT IN (${excludePlaceholders})
+     ORDER BY table_name`,
+    [schemaName, ...excludeTables]
+  );
+  return result.rows.map((r) => r.table_name);
+}
+async function getColumns(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      column_name,
+      data_type,
+      udt_name,
+      is_nullable,
+      column_default,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,
+    [schemaName, tableName]
+  );
+  return result.rows.map((row) => ({
+    columnName: row.column_name,
+    dataType: row.data_type,
+    udtName: row.udt_name,
+    isNullable: row.is_nullable === "YES",
+    columnDefault: row.column_default,
+    characterMaximumLength: row.character_maximum_length,
+    numericPrecision: row.numeric_precision,
+    numericScale: row.numeric_scale
+  }));
+}
+async function generateTableDdl(pool, schemaName, tableName) {
+  const columns = await getColumns(pool, schemaName, tableName);
+  const columnDefs = columns.map((col) => {
+    let type = col.udtName;
+    if (col.dataType === "character varying" && col.characterMaximumLength) {
+      type = `varchar(${col.characterMaximumLength})`;
+    } else if (col.dataType === "character" && col.characterMaximumLength) {
+      type = `char(${col.characterMaximumLength})`;
+    } else if (col.dataType === "numeric" && col.numericPrecision) {
+      type = `numeric(${col.numericPrecision}${col.numericScale ? `, ${col.numericScale}` : ""})`;
+    } else if (col.dataType === "ARRAY") {
+      type = col.udtName.replace(/^_/, "") + "[]";
+    }
+    let definition = `"${col.columnName}" ${type}`;
+    if (!col.isNullable) {
+      definition += " NOT NULL";
+    }
+    if (col.columnDefault) {
+      const defaultValue = col.columnDefault.replace(
+        new RegExp(`"?${schemaName}"?\\.`, "g"),
+        ""
+      );
+      definition += ` DEFAULT ${defaultValue}`;
+    }
+    return definition;
+  });
+  return `CREATE TABLE IF NOT EXISTS "${tableName}" (
+  ${columnDefs.join(",\n  ")}
+)`;
+}
+async function generateIndexDdls(pool, sourceSchema, targetSchema, tableName) {
+  const result = await pool.query(
+    `SELECT indexname, indexdef
+     FROM pg_indexes
+     WHERE schemaname = $1 AND tablename = $2
+       AND indexname NOT LIKE '%_pkey'`,
+    [sourceSchema, tableName]
+  );
+  return result.rows.map(
+    (row) => (
+      // Replace source schema with target schema
+      row.indexdef.replace(new RegExp(`ON "${sourceSchema}"\\."`, "g"), `ON "${targetSchema}"."`).replace(new RegExp(`"${sourceSchema}"\\."`, "g"), `"${targetSchema}"."`)
+    )
+  );
+}
+async function generatePrimaryKeyDdl(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      tc.constraint_name,
+      kcu.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'PRIMARY KEY'
+     ORDER BY kcu.ordinal_position`,
+    [schemaName, tableName]
+  );
+  if (result.rows.length === 0) return null;
+  const columns = result.rows.map((r) => `"${r.column_name}"`).join(", ");
+  const constraintName = result.rows[0].constraint_name;
+  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraintName}" PRIMARY KEY (${columns})`;
+}
+async function generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableName) {
+  const result = await pool.query(
+    `SELECT
+      tc.constraint_name,
+      kcu.column_name,
+      ccu.table_name as foreign_table_name,
+      ccu.column_name as foreign_column_name,
+      rc.update_rule,
+      rc.delete_rule
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.table_schema = ccu.table_schema
+     JOIN information_schema.referential_constraints rc
+       ON tc.constraint_name = rc.constraint_name
+       AND tc.table_schema = rc.constraint_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'FOREIGN KEY'
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,
+    [sourceSchema, tableName]
+  );
+  const fkMap = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const existing = fkMap.get(row.constraint_name);
+    if (existing) {
+      existing.columns.push(row.column_name);
+      existing.foreignColumns.push(row.foreign_column_name);
+    } else {
+      fkMap.set(row.constraint_name, {
+        columns: [row.column_name],
+        foreignTable: row.foreign_table_name,
+        foreignColumns: [row.foreign_column_name],
+        updateRule: row.update_rule,
+        deleteRule: row.delete_rule
+      });
+    }
+  }
+  return Array.from(fkMap.entries()).map(([name, fk]) => {
+    const columns = fk.columns.map((c) => `"${c}"`).join(", ");
+    const foreignColumns = fk.foreignColumns.map((c) => `"${c}"`).join(", ");
+    let ddl = `ALTER TABLE "${targetSchema}"."${tableName}" `;
+    ddl += `ADD CONSTRAINT "${name}" FOREIGN KEY (${columns}) `;
+    ddl += `REFERENCES "${targetSchema}"."${fk.foreignTable}" (${foreignColumns})`;
+    if (fk.updateRule !== "NO ACTION") {
+      ddl += ` ON UPDATE ${fk.updateRule}`;
+    }
+    if (fk.deleteRule !== "NO ACTION") {
+      ddl += ` ON DELETE ${fk.deleteRule}`;
+    }
+    return ddl;
+  });
+}
+async function generateUniqueDdls(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      tc.constraint_name,
+      kcu.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'UNIQUE'
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,
+    [schemaName, tableName]
+  );
+  const uniqueMap = /* @__PURE__ */ new Map();
+  for (const row of result.rows) {
+    const existing = uniqueMap.get(row.constraint_name);
+    if (existing) {
+      existing.push(row.column_name);
+    } else {
+      uniqueMap.set(row.constraint_name, [row.column_name]);
+    }
+  }
+  return Array.from(uniqueMap.entries()).map(([name, columns]) => {
+    const cols = columns.map((c) => `"${c}"`).join(", ");
+    return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${name}" UNIQUE (${cols})`;
+  });
+}
+async function generateCheckDdls(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT
+      tc.constraint_name,
+      cc.check_clause
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.check_constraints cc
+       ON tc.constraint_name = cc.constraint_name
+       AND tc.constraint_schema = cc.constraint_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'CHECK'
+       AND tc.constraint_name NOT LIKE '%_not_null'`,
+    [schemaName, tableName]
+  );
+  return result.rows.map(
+    (row) => `ALTER TABLE "${tableName}" ADD CONSTRAINT "${row.constraint_name}" CHECK (${row.check_clause})`
+  );
+}
+async function getRowCount(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT count(*) FROM "${schemaName}"."${tableName}"`
+  );
+  return parseInt(result.rows[0].count, 10);
+}
+async function generateTableCloneInfo(pool, sourceSchema, targetSchema, tableName) {
+  const [createDdl, indexDdls, pkDdl, uniqueDdls, checkDdls, fkDdls, rowCount] = await Promise.all([
+    generateTableDdl(pool, sourceSchema, tableName),
+    generateIndexDdls(pool, sourceSchema, targetSchema, tableName),
+    generatePrimaryKeyDdl(pool, sourceSchema, tableName),
+    generateUniqueDdls(pool, sourceSchema, tableName),
+    generateCheckDdls(pool, sourceSchema, tableName),
+    generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableName),
+    getRowCount(pool, sourceSchema, tableName)
+  ]);
+  return {
+    name: tableName,
+    createDdl,
+    indexDdls,
+    constraintDdls: [
+      ...pkDdl ? [pkDdl] : [],
+      ...uniqueDdls,
+      ...checkDdls,
+      ...fkDdls
+    ],
+    rowCount
+  };
+}
+
+// src/migrator/clone/data-copier.ts
+async function getTableColumns(pool, schemaName, tableName) {
+  const result = await pool.query(
+    `SELECT column_name
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,
+    [schemaName, tableName]
+  );
+  return result.rows.map((r) => r.column_name);
+}
+function formatAnonymizeValue(value) {
+  if (value === null) {
+    return "NULL";
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "TRUE" : "FALSE";
+  }
+  return String(value);
+}
+async function copyTableData(pool, sourceSchema, targetSchema, tableName, anonymizeRules) {
+  const columns = await getTableColumns(pool, sourceSchema, tableName);
+  if (columns.length === 0) {
+    return 0;
+  }
+  const tableRules = anonymizeRules?.[tableName] ?? {};
+  const selectColumns = columns.map((col) => {
+    if (col in tableRules) {
+      const value = tableRules[col];
+      return `${formatAnonymizeValue(value)} as "${col}"`;
+    }
+    return `"${col}"`;
+  });
+  const insertColumns = columns.map((c) => `"${c}"`).join(", ");
+  const selectExpr = selectColumns.join(", ");
+  const result = await pool.query(
+    `INSERT INTO "${targetSchema}"."${tableName}" (${insertColumns})
+     SELECT ${selectExpr}
+     FROM "${sourceSchema}"."${tableName}"`
+  );
+  return result.rowCount ?? 0;
+}
+async function getTablesInDependencyOrder(pool, schemaName, tables) {
+  const result = await pool.query(
+    `SELECT DISTINCT
+      tc.table_name,
+      ccu.table_name as foreign_table_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.table_schema = ccu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.constraint_type = 'FOREIGN KEY'
+       AND tc.table_name != ccu.table_name`,
+    [schemaName]
+  );
+  const dependencies = /* @__PURE__ */ new Map();
+  const tableSet = new Set(tables);
+  for (const table of tables) {
+    dependencies.set(table, /* @__PURE__ */ new Set());
+  }
+  for (const row of result.rows) {
+    if (tableSet.has(row.table_name) && tableSet.has(row.foreign_table_name)) {
+      dependencies.get(row.table_name).add(row.foreign_table_name);
+    }
+  }
+  const sorted = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  const queue = [];
+  for (const table of tables) {
+    inDegree.set(table, 0);
+  }
+  for (const [table, deps] of dependencies) {
+    for (const dep of deps) {
+      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+    }
+  }
+  for (const [table, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(table);
+    }
+  }
+  while (queue.length > 0) {
+    const table = queue.shift();
+    sorted.push(table);
+    for (const [otherTable, deps] of dependencies) {
+      if (deps.has(table)) {
+        deps.delete(table);
+        const newDegree = (inDegree.get(otherTable) ?? 0) - 1;
+        inDegree.set(otherTable, newDegree);
+        if (newDegree === 0) {
+          queue.push(otherTable);
+        }
+      }
+    }
+  }
+  const remaining = tables.filter((t) => !sorted.includes(t));
+  return [...sorted, ...remaining];
+}
+async function copyAllData(pool, sourceSchema, targetSchema, tables, anonymizeRules, onProgress) {
+  let totalRows = 0;
+  const orderedTables = await getTablesInDependencyOrder(pool, sourceSchema, tables);
+  await pool.query("SET session_replication_role = replica");
+  try {
+    for (let i = 0; i < orderedTables.length; i++) {
+      const table = orderedTables[i];
+      onProgress?.("copying_data", {
+        table,
+        progress: i + 1,
+        total: orderedTables.length
+      });
+      const rows = await copyTableData(pool, sourceSchema, targetSchema, table, anonymizeRules);
+      totalRows += rows;
+    }
+  } finally {
+    await pool.query("SET session_replication_role = DEFAULT");
+  }
+  return totalRows;
+}
+
+// src/migrator/clone/cloner.ts
+var DEFAULT_MIGRATIONS_TABLE3 = "__drizzle_migrations";
+var Cloner = class {
+  constructor(config, deps) {
+    this.deps = deps;
+    this.migrationsTable = config.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE3;
+  }
+  migrationsTable;
+  /**
+   * Clone a tenant to another
+   *
+   * @param sourceTenantId - Source tenant ID
+   * @param targetTenantId - Target tenant ID
+   * @param options - Clone options
+   * @returns Clone result
+   */
+  async cloneTenant(sourceTenantId, targetTenantId, options = {}) {
+    const startTime = Date.now();
+    const {
+      includeData = false,
+      anonymize,
+      excludeTables = [],
+      onProgress
+    } = options;
+    const sourceSchema = this.deps.schemaNameTemplate(sourceTenantId);
+    const targetSchema = this.deps.schemaNameTemplate(targetTenantId);
+    const allExcludes = [this.migrationsTable, ...excludeTables];
+    let sourcePool = null;
+    let rootPool = null;
+    try {
+      onProgress?.("starting");
+      const sourceExists = await this.deps.schemaExists(sourceTenantId);
+      if (!sourceExists) {
+        return this.createErrorResult(
+          sourceTenantId,
+          targetTenantId,
+          targetSchema,
+          `Source tenant "${sourceTenantId}" does not exist`,
+          startTime
+        );
+      }
+      const targetExists = await this.deps.schemaExists(targetTenantId);
+      if (targetExists) {
+        return this.createErrorResult(
+          sourceTenantId,
+          targetTenantId,
+          targetSchema,
+          `Target tenant "${targetTenantId}" already exists`,
+          startTime
+        );
+      }
+      onProgress?.("introspecting");
+      sourcePool = await this.deps.createPool(sourceSchema);
+      const tables = await listTables(sourcePool, sourceSchema, allExcludes);
+      if (tables.length === 0) {
+        onProgress?.("creating_schema");
+        await this.deps.createSchema(targetTenantId);
+        onProgress?.("completed");
+        return {
+          sourceTenant: sourceTenantId,
+          targetTenant: targetTenantId,
+          targetSchema,
+          success: true,
+          tables: [],
+          durationMs: Date.now() - startTime
+        };
+      }
+      const tableInfos = await Promise.all(
+        tables.map((t) => generateTableCloneInfo(sourcePool, sourceSchema, targetSchema, t))
+      );
+      await sourcePool.end();
+      sourcePool = null;
+      onProgress?.("creating_schema");
+      await this.deps.createSchema(targetTenantId);
+      rootPool = await this.deps.createRootPool();
+      onProgress?.("creating_tables");
+      for (const info of tableInfos) {
+        await rootPool.query(`SET search_path TO "${targetSchema}"; ${info.createDdl}`);
+      }
+      onProgress?.("creating_constraints");
+      for (const info of tableInfos) {
+        for (const constraint of info.constraintDdls.filter((c) => !c.includes("FOREIGN KEY"))) {
+          try {
+            await rootPool.query(`SET search_path TO "${targetSchema}"; ${constraint}`);
+          } catch (error) {
+          }
+        }
+      }
+      onProgress?.("creating_indexes");
+      for (const info of tableInfos) {
+        for (const index of info.indexDdls) {
+          try {
+            await rootPool.query(index);
+          } catch (error) {
+          }
+        }
+      }
+      let rowsCopied = 0;
+      if (includeData) {
+        onProgress?.("copying_data");
+        rowsCopied = await copyAllData(
+          rootPool,
+          sourceSchema,
+          targetSchema,
+          tables,
+          anonymize?.enabled ? anonymize.rules : void 0,
+          onProgress
+        );
+      }
+      for (const info of tableInfos) {
+        for (const fk of info.constraintDdls.filter((c) => c.includes("FOREIGN KEY"))) {
+          try {
+            await rootPool.query(fk);
+          } catch (error) {
+          }
+        }
+      }
+      onProgress?.("completed");
+      const result = {
+        sourceTenant: sourceTenantId,
+        targetTenant: targetTenantId,
+        targetSchema,
+        success: true,
+        tables,
+        durationMs: Date.now() - startTime
+      };
+      if (includeData) {
+        result.rowsCopied = rowsCopied;
+      }
+      return result;
+    } catch (error) {
+      options.onError?.(error);
+      onProgress?.("failed");
+      return this.createErrorResult(
+        sourceTenantId,
+        targetTenantId,
+        targetSchema,
+        error.message,
+        startTime
+      );
+    } finally {
+      if (sourcePool) {
+        await sourcePool.end().catch(() => {
+        });
+      }
+      if (rootPool) {
+        await rootPool.end().catch(() => {
+        });
+      }
+    }
+  }
+  createErrorResult(source, target, schema, error, startTime) {
+    return {
+      sourceTenant: source,
+      targetTenant: target,
+      targetSchema: schema,
+      success: false,
+      error,
+      tables: [],
+      durationMs: Date.now() - startTime
+    };
+  }
+};
+
+// src/migrator/migrator.ts
+var DEFAULT_MIGRATIONS_TABLE4 = "__drizzle_migrations";
+var Migrator = class {
+  constructor(tenantConfig, migratorConfig) {
+    this.migratorConfig = migratorConfig;
+    this.migrationsTable = migratorConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE4;
+    this.schemaManager = new SchemaManager(tenantConfig, this.migrationsTable);
+    this.driftDetector = new DriftDetector(tenantConfig, this.schemaManager, {
+      migrationsTable: this.migrationsTable,
+      tenantDiscovery: migratorConfig.tenantDiscovery
+    });
+    this.seeder = new Seeder(
+      { tenantDiscovery: migratorConfig.tenantDiscovery },
+      {
+        createPool: this.schemaManager.createPool.bind(this.schemaManager),
+        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
+        tenantSchema: tenantConfig.schemas.tenant
+      }
+    );
+    this.syncManager = new SyncManager(
+      {
+        tenantDiscovery: migratorConfig.tenantDiscovery,
+        migrationsFolder: migratorConfig.migrationsFolder,
+        migrationsTable: this.migrationsTable
+      },
+      {
+        createPool: this.schemaManager.createPool.bind(this.schemaManager),
+        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
+        migrationsTableExists: this.schemaManager.migrationsTableExists.bind(this.schemaManager),
+        ensureMigrationsTable: this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),
+        getOrDetectFormat: this.getOrDetectFormat.bind(this),
+        loadMigrations: this.loadMigrations.bind(this)
+      }
+    );
+    this.migrationExecutor = new MigrationExecutor(
+      { hooks: migratorConfig.hooks },
+      {
+        createPool: this.schemaManager.createPool.bind(this.schemaManager),
+        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
+        migrationsTableExists: this.schemaManager.migrationsTableExists.bind(this.schemaManager),
+        ensureMigrationsTable: this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),
+        getOrDetectFormat: this.getOrDetectFormat.bind(this),
+        loadMigrations: this.loadMigrations.bind(this)
+      }
+    );
+    this.batchExecutor = new BatchExecutor(
+      { tenantDiscovery: migratorConfig.tenantDiscovery },
+      this.migrationExecutor,
+      this.loadMigrations.bind(this)
+    );
+    this.cloner = new Cloner(
+      { migrationsTable: this.migrationsTable },
+      {
+        createPool: this.schemaManager.createPool.bind(this.schemaManager),
+        createRootPool: this.schemaManager.createRootPool.bind(this.schemaManager),
+        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
+        schemaExists: this.schemaManager.schemaExists.bind(this.schemaManager),
+        createSchema: this.schemaManager.createSchema.bind(this.schemaManager)
+      }
+    );
+  }
+  migrationsTable;
+  schemaManager;
+  driftDetector;
+  seeder;
+  syncManager;
+  migrationExecutor;
+  batchExecutor;
+  cloner;
+  /**
+   * Migrate all tenants in parallel
+   *
+   * Delegates to BatchExecutor for parallel migration operations.
+   */
+  async migrateAll(options = {}) {
+    return this.batchExecutor.migrateAll(options);
+  }
+  /**
+   * Migrate a single tenant
+   *
+   * Delegates to MigrationExecutor for single tenant operations.
+   */
+  async migrateTenant(tenantId, migrations, options = {}) {
+    return this.migrationExecutor.migrateTenant(tenantId, migrations, options);
+  }
+  /**
+   * Migrate specific tenants
+   *
+   * Delegates to BatchExecutor for parallel migration operations.
+   */
+  async migrateTenants(tenantIds, options = {}) {
+    return this.batchExecutor.migrateTenants(tenantIds, options);
+  }
+  /**
+   * Get migration status for all tenants
+   *
+   * Delegates to BatchExecutor for status operations.
+   */
+  async getStatus() {
+    return this.batchExecutor.getStatus();
+  }
+  /**
+   * Get migration status for a specific tenant
+   *
+   * Delegates to MigrationExecutor for single tenant operations.
+   */
+  async getTenantStatus(tenantId, migrations) {
+    return this.migrationExecutor.getTenantStatus(tenantId, migrations);
+  }
+  /**
+   * Create a new tenant schema and optionally apply migrations
+   */
+  async createTenant(tenantId, options = {}) {
+    const { migrate = true } = options;
+    await this.schemaManager.createSchema(tenantId);
+    if (migrate) {
+      await this.migrateTenant(tenantId);
+    }
+  }
+  /**
+   * Drop a tenant schema
+   */
+  async dropTenant(tenantId, options = {}) {
+    await this.schemaManager.dropSchema(tenantId, options);
+  }
+  /**
+   * Check if a tenant schema exists
+   */
+  async tenantExists(tenantId) {
+    return this.schemaManager.schemaExists(tenantId);
+  }
+  /**
+   * Clone a tenant to a new tenant
+   *
+   * By default, clones only schema structure. Use includeData to copy data.
+   *
+   * @example
+   * ```typescript
+   * // Schema-only clone
+   * await migrator.cloneTenant('production', 'dev');
+   *
+   * // Clone with data
+   * await migrator.cloneTenant('production', 'dev', { includeData: true });
+   *
+   * // Clone with anonymization
+   * await migrator.cloneTenant('production', 'dev', {
+   *   includeData: true,
+   *   anonymize: {
+   *     enabled: true,
+   *     rules: {
+   *       users: { email: null, phone: null },
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  async cloneTenant(sourceTenantId, targetTenantId, options = {}) {
+    return this.cloner.cloneTenant(sourceTenantId, targetTenantId, options);
+  }
+  /**
+   * Mark migrations as applied without executing SQL
+   * Useful for syncing tracking state with already-applied migrations
+   *
+   * Delegates to MigrationExecutor for single tenant operations.
+   */
+  async markAsApplied(tenantId, options = {}) {
+    return this.migrationExecutor.markAsApplied(tenantId, options);
+  }
+  /**
+   * Mark migrations as applied for all tenants without executing SQL
+   * Useful for syncing tracking state with already-applied migrations
+   *
+   * Delegates to BatchExecutor for parallel operations.
+   */
+  async markAllAsApplied(options = {}) {
+    return this.batchExecutor.markAllAsApplied(options);
+  }
+  // ============================================================================
+  // Sync Methods (delegated to SyncManager)
+  // ============================================================================
+  /**
+   * Get sync status for all tenants
+   * Detects divergences between migrations on disk and tracking in database
+   */
+  async getSyncStatus() {
+    return this.syncManager.getSyncStatus();
+  }
+  /**
+   * Get sync status for a specific tenant
+   */
+  async getTenantSyncStatus(tenantId, migrations) {
+    return this.syncManager.getTenantSyncStatus(tenantId, migrations);
+  }
+  /**
+   * Mark missing migrations as applied for a tenant
+   */
+  async markMissing(tenantId) {
+    return this.syncManager.markMissing(tenantId);
+  }
+  /**
+   * Mark missing migrations as applied for all tenants
+   */
+  async markAllMissing(options = {}) {
+    return this.syncManager.markAllMissing(options);
+  }
+  /**
+   * Remove orphan migration records for a tenant
+   */
+  async cleanOrphans(tenantId) {
+    return this.syncManager.cleanOrphans(tenantId);
+  }
+  /**
+   * Remove orphan migration records for all tenants
+   */
+  async cleanAllOrphans(options = {}) {
+    return this.syncManager.cleanAllOrphans(options);
+  }
+  // ============================================================================
+  // Seeding Methods (delegated to Seeder)
+  // ============================================================================
+  /**
+   * Seed a single tenant with initial data
+   *
+   * @example
+   * ```typescript
+   * const seed: SeedFunction = async (db, tenantId) => {
+   *   await db.insert(roles).values([
+   *     { name: 'admin', permissions: ['*'] },
+   *     { name: 'user', permissions: ['read'] },
+   *   ]);
+   * };
+   *
+   * await migrator.seedTenant('tenant-123', seed);
+   * ```
+   */
+  async seedTenant(tenantId, seedFn) {
+    return this.seeder.seedTenant(tenantId, seedFn);
+  }
+  /**
+   * Seed all tenants with initial data in parallel
+   *
+   * @example
+   * ```typescript
+   * const seed: SeedFunction = async (db, tenantId) => {
+   *   await db.insert(roles).values([
+   *     { name: 'admin', permissions: ['*'] },
+   *   ]);
+   * };
+   *
+   * await migrator.seedAll(seed, { concurrency: 10 });
+   * ```
+   */
+  async seedAll(seedFn, options = {}) {
+    return this.seeder.seedAll(seedFn, options);
+  }
+  /**
+   * Seed specific tenants with initial data
    */
-  async cleanAllOrphans(options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedSyncResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.cleanOrphans(tenantId);
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorSyncResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return this.aggregateSyncResults(results);
+  async seedTenants(tenantIds, seedFn, options = {}) {
+    return this.seeder.seedTenants(tenantIds, seedFn, options);
   }
   /**
    * Load migration files from the migrations folder
@@ -1590,76 +4313,11 @@ var Migrator = class {
     }
     return migrations.sort((a, b) => a.timestamp - b.timestamp);
   }
-  /**
-   * Create a pool for a specific schema
-   */
-  async createPool(schemaName) {
-    return new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig,
-      options: `-c search_path="${schemaName}",public`
-    });
-  }
-  /**
-   * Ensure migrations table exists with the correct format
-   */
-  async ensureMigrationsTable(pool, schemaName, format) {
-    const { identifier, timestamp, timestampType } = format.columns;
-    const identifierCol = identifier === "name" ? "name VARCHAR(255) NOT NULL UNIQUE" : "hash TEXT NOT NULL";
-    const timestampCol = timestampType === "bigint" ? `${timestamp} BIGINT NOT NULL` : `${timestamp} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;
-    await pool.query(`
-      CREATE TABLE IF NOT EXISTS "${schemaName}"."${format.tableName}" (
-        id SERIAL PRIMARY KEY,
-        ${identifierCol},
-        ${timestampCol}
-      )
-    `);
-  }
-  /**
-   * Check if migrations table exists
-   */
-  async migrationsTableExists(pool, schemaName) {
-    const result = await pool.query(
-      `SELECT 1 FROM information_schema.tables
-       WHERE table_schema = $1 AND table_name = $2`,
-      [schemaName, this.migrationsTable]
-    );
-    return result.rowCount !== null && result.rowCount > 0;
-  }
-  /**
-   * Get applied migrations for a schema
-   */
-  async getAppliedMigrations(pool, schemaName, format) {
-    const identifierColumn = format.columns.identifier;
-    const timestampColumn = format.columns.timestamp;
-    const result = await pool.query(
-      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
-       FROM "${schemaName}"."${format.tableName}"
-       ORDER BY id`
-    );
-    return result.rows.map((row) => {
-      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
-      return {
-        id: row.id,
-        identifier: row.identifier,
-        // Set name or hash based on format
-        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: row.identifier },
-        appliedAt
-      };
-    });
-  }
-  /**
-   * Check if a migration has been applied
-   */
-  isMigrationApplied(migration, appliedIdentifiers, format) {
-    if (format.columns.identifier === "name") {
-      return appliedIdentifiers.has(migration.name);
-    }
-    return appliedIdentifiers.has(migration.hash) || appliedIdentifiers.has(migration.name);
-  }
   /**
    * Get or detect the format for a schema
    * Returns the configured format or auto-detects from existing table
+   *
+   * Note: This method is shared with SyncManager and MigrationExecutor via dependency injection.
    */
   async getOrDetectFormat(pool, schemaName) {
     const configuredFormat = this.migratorConfig.tableFormat ?? "auto";
@@ -1673,118 +4331,45 @@ var Migrator = class {
     const defaultFormat = this.migratorConfig.defaultFormat ?? "name";
     return getFormatConfig(defaultFormat, this.migrationsTable);
   }
+  // ============================================================================
+  // Schema Drift Detection Methods (delegated to DriftDetector)
+  // ============================================================================
   /**
-   * Apply a migration to a schema
-   */
-  async applyMigration(pool, schemaName, migration, format) {
-    const client = await pool.connect();
-    try {
-      await client.query("BEGIN");
-      await client.query(migration.sql);
-      const { identifier, timestamp, timestampType } = format.columns;
-      const identifierValue = identifier === "name" ? migration.name : migration.hash;
-      const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
-      await client.query(
-        `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
-        [identifierValue, timestampValue]
-      );
-      await client.query("COMMIT");
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  /**
-   * Record a migration as applied without executing SQL
-   * Used by markAsApplied to sync tracking state
-   */
-  async recordMigration(pool, schemaName, migration, format) {
-    const { identifier, timestamp, timestampType } = format.columns;
-    const identifierValue = identifier === "name" ? migration.name : migration.hash;
-    const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
-    await pool.query(
-      `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
-      [identifierValue, timestampValue]
-    );
-  }
-  /**
-   * Create a skipped result
-   */
-  createSkippedResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      appliedMigrations: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error result
-   */
-  createErrorResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      appliedMigrations: [],
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate migration results
-   */
-  aggregateResults(results) {
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success && r.error !== "Skipped due to abort").length,
-      skipped: results.filter((r) => r.error === "Skipped due to abort").length,
-      details: results
-    };
-  }
-  /**
-   * Create a skipped sync result
+   * Detect schema drift across all tenants
+   * Compares each tenant's schema against a reference tenant (first tenant by default)
+   *
+   * @example
+   * ```typescript
+   * const drift = await migrator.getSchemaDrift();
+   * if (drift.withDrift > 0) {
+   *   console.log('Schema drift detected!');
+   *   for (const tenant of drift.details) {
+   *     if (tenant.hasDrift) {
+   *       console.log(`Tenant ${tenant.tenantId} has drift:`);
+   *       for (const table of tenant.tables) {
+   *         for (const col of table.columns) {
+   *           console.log(`  - ${table.table}.${col.column}: ${col.description}`);
+   *         }
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
    */
-  createSkippedSyncResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
+  async getSchemaDrift(options = {}) {
+    return this.driftDetector.detectDrift(options);
   }
   /**
-   * Create an error sync result
+   * Get schema drift for a specific tenant compared to a reference
    */
-  createErrorSyncResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: error.message,
-      durationMs: 0
-    };
+  async getTenantSchemaDrift(tenantId, referenceTenantId, options = {}) {
+    return this.driftDetector.compareTenant(tenantId, referenceTenantId, options);
   }
   /**
-   * Aggregate sync results
+   * Introspect the schema of a tenant
    */
-  aggregateSyncResults(results) {
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      details: results
-    };
+  async introspectTenantSchema(tenantId, options = {}) {
+    return this.driftDetector.introspectSchema(tenantId, options);
   }
 };
 function createMigrator(tenantConfig, migratorConfig) {
@@ -2210,6 +4795,71 @@ function withShared(tenantDb, _sharedDb, schemas, options) {
   );
 }
 
-export { CrossSchemaQueryBuilder, DEFAULT_CONFIG, Migrator, WithSharedQueryBuilder, buildCrossSchemaSelect, calculateDelay, createCrossSchemaQuery, createMigrator, createRetrier, createTenantContext, createTenantManager, crossSchemaRaw, defineConfig, isRetryableError, withRetry, withShared, withSharedLookup };
+// src/retry.ts
+function isRetryableError2(error) {
+  const message = error.message.toLowerCase();
+  if (message.includes("econnrefused") || message.includes("econnreset") || message.includes("etimedout") || message.includes("enotfound") || message.includes("connection refused") || message.includes("connection reset") || message.includes("connection terminated") || message.includes("connection timed out") || message.includes("timeout expired") || message.includes("socket hang up")) {
+    return true;
+  }
+  if (message.includes("too many connections") || message.includes("sorry, too many clients") || message.includes("the database system is starting up") || message.includes("the database system is shutting down") || message.includes("server closed the connection unexpectedly") || message.includes("could not connect to server")) {
+    return true;
+  }
+  if (message.includes("ssl connection") || message.includes("ssl handshake")) {
+    return true;
+  }
+  return false;
+}
+function calculateDelay(attempt, config) {
+  const exponentialDelay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+  if (config.jitter) {
+    const jitterFactor = 1 + Math.random() * 0.25;
+    return Math.floor(cappedDelay * jitterFactor);
+  }
+  return Math.floor(cappedDelay);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(operation, config) {
+  const retryConfig = {
+    maxAttempts: config?.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
+    initialDelayMs: config?.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
+    maxDelayMs: config?.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
+    backoffMultiplier: config?.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
+    jitter: config?.jitter ?? DEFAULT_CONFIG.retry.jitter,
+    isRetryable: config?.isRetryable ?? isRetryableError2,
+    onRetry: config?.onRetry
+  };
+  const startTime = Date.now();
+  let lastError = null;
+  for (let attempt = 0; attempt < retryConfig.maxAttempts; attempt++) {
+    try {
+      const result = await operation();
+      return {
+        result,
+        attempts: attempt + 1,
+        totalTimeMs: Date.now() - startTime
+      };
+    } catch (error) {
+      lastError = error;
+      const isLastAttempt = attempt >= retryConfig.maxAttempts - 1;
+      if (isLastAttempt || !retryConfig.isRetryable(lastError)) {
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, retryConfig);
+      retryConfig.onRetry?.(attempt + 1, lastError, delay);
+      await sleep2(delay);
+    }
+  }
+  throw lastError ?? new Error("Retry failed with no error");
+}
+function createRetrier(config) {
+  return (operation) => {
+    return withRetry(operation, config);
+  };
+}
+
+export { CrossSchemaQueryBuilder, DEFAULT_CONFIG, Migrator, WithSharedQueryBuilder, buildCrossSchemaSelect, calculateDelay, createCrossSchemaQuery, createMigrator, createRetrier, createTenantContext, createTenantManager, crossSchemaRaw, defineConfig, isRetryableError2 as isRetryableError, withRetry, withShared, withSharedLookup };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map