drizzle-multitenant 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,1634 +1,16 @@
-import { Pool } from 'pg';
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { LRUCache } from 'lru-cache';
-import { AsyncLocalStorage } from 'async_hooks';
-import { readdir, readFile } from 'fs/promises';
-import { join, basename } from 'path';
-import { createHash } from 'crypto';
-import { sql, getTableName } from 'drizzle-orm';
-
-// src/config.ts
-function defineConfig(config) {
-  validateConfig(config);
-  return config;
-}
-function validateConfig(config) {
-  if (!config.connection.url) {
-    throw new Error("[drizzle-multitenant] connection.url is required");
-  }
-  if (!config.isolation.strategy) {
-    throw new Error("[drizzle-multitenant] isolation.strategy is required");
-  }
-  if (config.isolation.strategy !== "schema") {
-    throw new Error(
-      `[drizzle-multitenant] isolation.strategy "${config.isolation.strategy}" is not yet supported. Only "schema" is currently available.`
-    );
-  }
-  if (!config.isolation.schemaNameTemplate) {
-    throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate is required");
-  }
-  if (typeof config.isolation.schemaNameTemplate !== "function") {
-    throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate must be a function");
-  }
-  if (!config.schemas.tenant) {
-    throw new Error("[drizzle-multitenant] schemas.tenant is required");
-  }
-  if (config.isolation.maxPools !== void 0 && config.isolation.maxPools < 1) {
-    throw new Error("[drizzle-multitenant] isolation.maxPools must be at least 1");
-  }
-  if (config.isolation.poolTtlMs !== void 0 && config.isolation.poolTtlMs < 0) {
-    throw new Error("[drizzle-multitenant] isolation.poolTtlMs must be non-negative");
-  }
-  if (config.connection.retry) {
-    const retry = config.connection.retry;
-    if (retry.maxAttempts !== void 0 && retry.maxAttempts < 1) {
-      throw new Error("[drizzle-multitenant] connection.retry.maxAttempts must be at least 1");
-    }
-    if (retry.initialDelayMs !== void 0 && retry.initialDelayMs < 0) {
-      throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs must be non-negative");
-    }
-    if (retry.maxDelayMs !== void 0 && retry.maxDelayMs < 0) {
-      throw new Error("[drizzle-multitenant] connection.retry.maxDelayMs must be non-negative");
-    }
-    if (retry.backoffMultiplier !== void 0 && retry.backoffMultiplier < 1) {
-      throw new Error("[drizzle-multitenant] connection.retry.backoffMultiplier must be at least 1");
-    }
-    if (retry.initialDelayMs !== void 0 && retry.maxDelayMs !== void 0 && retry.initialDelayMs > retry.maxDelayMs) {
-      throw new Error(
-        "[drizzle-multitenant] connection.retry.initialDelayMs cannot be greater than maxDelayMs"
-      );
-    }
-  }
-}
-
-// src/types.ts
-var DEFAULT_CONFIG = {
-  maxPools: 50,
-  poolTtlMs: 60 * 60 * 1e3,
-  // 1 hour
-  cleanupIntervalMs: 6e4,
-  // 1 minute
-  poolConfig: {
-    max: 10,
-    idleTimeoutMillis: 3e4,
-    connectionTimeoutMillis: 5e3
-  },
-  retry: {
-    maxAttempts: 3,
-    initialDelayMs: 100,
-    maxDelayMs: 5e3,
-    backoffMultiplier: 2,
-    jitter: true
-  }
-};
-
-// src/debug.ts
-var PREFIX = "[drizzle-multitenant]";
-var DEFAULT_SLOW_QUERY_THRESHOLD = 1e3;
-var DebugLogger = class {
-  enabled;
-  logQueries;
-  logPoolEvents;
-  slowQueryThreshold;
-  logger;
-  constructor(config) {
-    this.enabled = config?.enabled ?? false;
-    this.logQueries = config?.logQueries ?? true;
-    this.logPoolEvents = config?.logPoolEvents ?? true;
-    this.slowQueryThreshold = config?.slowQueryThreshold ?? DEFAULT_SLOW_QUERY_THRESHOLD;
-    this.logger = config?.logger ?? this.defaultLogger;
-  }
-  /**
-   * Check if debug mode is enabled
-   */
-  isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Log a query execution
-   */
-  logQuery(tenantId, query, durationMs) {
-    if (!this.enabled || !this.logQueries) return;
-    const isSlowQuery = durationMs >= this.slowQueryThreshold;
-    const type = isSlowQuery ? "slow_query" : "query";
-    const context = {
-      type,
-      tenantId,
-      query: this.truncateQuery(query),
-      durationMs
-    };
-    if (isSlowQuery) {
-      this.logger(
-        `${PREFIX} tenant=${tenantId} SLOW_QUERY duration=${durationMs}ms query="${this.truncateQuery(query)}"`,
-        context
-      );
-    } else {
-      this.logger(
-        `${PREFIX} tenant=${tenantId} query="${this.truncateQuery(query)}" duration=${durationMs}ms`,
-        context
-      );
-    }
-  }
-  /**
-   * Log pool creation
-   */
-  logPoolCreated(tenantId, schemaName) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "pool_created",
-      tenantId,
-      schemaName
-    };
-    this.logger(
-      `${PREFIX} tenant=${tenantId} POOL_CREATED schema=${schemaName}`,
-      context
-    );
-  }
-  /**
-   * Log pool eviction
-   */
-  logPoolEvicted(tenantId, schemaName, reason) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "pool_evicted",
-      tenantId,
-      schemaName,
-      metadata: reason ? { reason } : void 0
-    };
-    const reasonStr = reason ? ` reason=${reason}` : "";
-    this.logger(
-      `${PREFIX} tenant=${tenantId} POOL_EVICTED schema=${schemaName}${reasonStr}`,
-      context
-    );
-  }
-  /**
-   * Log pool error
-   */
-  logPoolError(tenantId, error) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "pool_error",
-      tenantId,
-      error: error.message
-    };
-    this.logger(
-      `${PREFIX} tenant=${tenantId} POOL_ERROR error="${error.message}"`,
-      context
-    );
-  }
-  /**
-   * Log warmup event
-   */
-  logWarmup(tenantId, success, durationMs, alreadyWarm) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "warmup",
-      tenantId,
-      durationMs,
-      metadata: { success, alreadyWarm }
-    };
-    const status = alreadyWarm ? "already_warm" : success ? "success" : "failed";
-    this.logger(
-      `${PREFIX} tenant=${tenantId} WARMUP status=${status} duration=${durationMs}ms`,
-      context
-    );
-  }
-  /**
-   * Log connection retry event
-   */
-  logConnectionRetry(identifier, attempt, maxAttempts, error, delayMs) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "connection_retry",
-      tenantId: identifier,
-      error: error.message,
-      metadata: { attempt, maxAttempts, delayMs }
-    };
-    this.logger(
-      `${PREFIX} tenant=${identifier} CONNECTION_RETRY attempt=${attempt}/${maxAttempts} delay=${delayMs}ms error="${error.message}"`,
-      context
-    );
-  }
-  /**
-   * Log connection success after retries
-   */
-  logConnectionSuccess(identifier, attempts, totalTimeMs) {
-    if (!this.enabled || !this.logPoolEvents) return;
-    const context = {
-      type: "pool_created",
-      tenantId: identifier,
-      durationMs: totalTimeMs,
-      metadata: { attempts }
-    };
-    if (attempts > 1) {
-      this.logger(
-        `${PREFIX} tenant=${identifier} CONNECTION_SUCCESS attempts=${attempts} totalTime=${totalTimeMs}ms`,
-        context
-      );
-    }
-  }
-  /**
-   * Log a custom debug message
-   */
-  log(message, context) {
-    if (!this.enabled) return;
-    this.logger(`${PREFIX} ${message}`, context);
-  }
-  /**
-   * Default logger implementation using console
-   */
-  defaultLogger(message, _context) {
-    console.log(message);
-  }
-  /**
-   * Truncate long queries for readability
-   */
-  truncateQuery(query, maxLength = 100) {
-    const normalized = query.replace(/\s+/g, " ").trim();
-    if (normalized.length <= maxLength) {
-      return normalized;
-    }
-    return normalized.substring(0, maxLength - 3) + "...";
-  }
-};
-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/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")) {
-    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 sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-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 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 {
-        success: true,
-        responseTimeMs: Date.now() - startTime
-      };
-    } catch (err) {
-      return {
-        success: false,
-        responseTimeMs: Date.now() - startTime,
-        error: err.message
-      };
-    }
-  }
-  /**
-   * 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);
-    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
-    });
-  }
-  poolCache;
-  tenantIdBySchema = /* @__PURE__ */ new Map();
-  pendingConnections = /* @__PURE__ */ new Map();
-  sharedPool = null;
-  sharedDb = null;
-  sharedDbPending = null;
-  cleanupInterval = null;
-  disposed = false;
-  debugLogger;
-  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.poolCache.get(schemaName);
-    if (!entry) {
-      entry = this.createPoolEntry(tenantId, schemaName);
-      this.poolCache.set(schemaName, entry);
-      this.tenantIdBySchema.set(schemaName, tenantId);
-      this.debugLogger.logPoolCreated(tenantId, schemaName);
-      void this.config.hooks?.onPoolCreated?.(tenantId);
-    }
-    this.poolCache.touch(schemaName);
-    return entry.db;
-  }
-  /**
-   * Get or create a database connection for a tenant with retry and validation
-   *
-   * This async version validates the connection by executing a ping query
-   * and retries on transient failures with exponential backoff.
-   *
-   * @example
-   * ```typescript
-   * // Get tenant database with automatic retry
-   * const db = await manager.getDbAsync('tenant-123');
-   *
-   * // Queries will use the validated connection
-   * const users = await db.select().from(users);
-   * ```
-   */
-  async getDbAsync(tenantId) {
-    this.ensureNotDisposed();
-    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.poolCache.get(schemaName);
-    if (entry) {
-      this.poolCache.touch(schemaName);
-      return entry.db;
-    }
-    const pending = this.pendingConnections.get(schemaName);
-    if (pending) {
-      entry = await pending;
-      this.poolCache.touch(schemaName);
-      return entry.db;
-    }
-    const connectionPromise = this.connectWithRetry(tenantId, schemaName);
-    this.pendingConnections.set(schemaName, connectionPromise);
-    try {
-      entry = await connectionPromise;
-      this.poolCache.set(schemaName, entry);
-      this.tenantIdBySchema.set(schemaName, tenantId);
-      this.debugLogger.logPoolCreated(tenantId, schemaName);
-      void this.config.hooks?.onPoolCreated?.(tenantId);
-      this.poolCache.touch(schemaName);
-      return entry.db;
-    } finally {
-      this.pendingConnections.delete(schemaName);
-    }
-  }
-  /**
-   * Connect to a tenant database with retry logic
-   */
-  async connectWithRetry(tenantId, schemaName) {
-    const retryConfig = this.retryHandler.getConfig();
-    const maxAttempts = retryConfig.maxAttempts;
-    const result = await this.retryHandler.withRetry(
-      async () => {
-        const entry = this.createPoolEntry(tenantId, schemaName);
-        try {
-          await entry.pool.query("SELECT 1");
-          return entry;
-        } catch (error) {
-          try {
-            await entry.pool.end();
-          } catch {
-          }
-          throw error;
-        }
-      },
-      {
-        onRetry: (attempt, error, delayMs) => {
-          this.debugLogger.logConnectionRetry(tenantId, attempt, maxAttempts, error, delayMs);
-          retryConfig.onRetry?.(attempt, error, delayMs);
-        }
-      }
-    );
-    this.debugLogger.logConnectionSuccess(tenantId, result.attempts, result.totalTimeMs);
-    return result.result;
-  }
-  /**
-   * Get or create the shared database connection
-   */
-  getSharedDb() {
-    this.ensureNotDisposed();
-    if (!this.sharedDb) {
-      this.sharedPool = new Pool({
-        connectionString: this.config.connection.url,
-        ...DEFAULT_CONFIG.poolConfig,
-        ...this.config.connection.poolConfig
-      });
-      this.sharedPool.on("error", (err) => {
-        void this.config.hooks?.onError?.("shared", err);
-      });
-      this.sharedDb = drizzle(this.sharedPool, {
-        schema: this.config.schemas.shared
-      });
-    }
-    return this.sharedDb;
-  }
-  /**
-   * Get or create the shared database connection with retry and validation
-   *
-   * This async version validates the connection by executing a ping query
-   * and retries on transient failures with exponential backoff.
-   *
-   * @example
-   * ```typescript
-   * // Get shared database with automatic retry
-   * const sharedDb = await manager.getSharedDbAsync();
-   *
-   * // Queries will use the validated connection
-   * const plans = await sharedDb.select().from(plans);
-   * ```
-   */
-  async getSharedDbAsync() {
-    this.ensureNotDisposed();
-    if (this.sharedDb) {
-      return this.sharedDb;
-    }
-    if (this.sharedDbPending) {
-      return this.sharedDbPending;
-    }
-    this.sharedDbPending = this.connectSharedWithRetry();
-    try {
-      const db = await this.sharedDbPending;
-      return db;
-    } finally {
-      this.sharedDbPending = null;
-    }
-  }
-  /**
-   * Connect to shared database with retry logic
-   */
-  async connectSharedWithRetry() {
-    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,
-          ...DEFAULT_CONFIG.poolConfig,
-          ...this.config.connection.poolConfig
-        });
-        try {
-          await pool.query("SELECT 1");
-          pool.on("error", (err) => {
-            void this.config.hooks?.onError?.("shared", err);
-          });
-          this.sharedPool = pool;
-          this.sharedDb = drizzle(pool, {
-            schema: this.config.schemas.shared
-          });
-          return this.sharedDb;
-        } catch (error) {
-          try {
-            await pool.end();
-          } catch {
-          }
-          throw error;
-        }
-      },
-      {
-        onRetry: (attempt, error, delayMs) => {
-          this.debugLogger.logConnectionRetry("shared", attempt, maxAttempts, error, delayMs);
-          retryConfig.onRetry?.(attempt, error, delayMs);
-        }
-      }
-    );
-    this.debugLogger.logConnectionSuccess("shared", result.attempts, result.totalTimeMs);
-    return result.result;
-  }
-  /**
-   * Get schema name for a tenant
-   */
-  getSchemaName(tenantId) {
-    return this.config.isolation.schemaNameTemplate(tenantId);
-  }
-  /**
-   * Check if a pool exists for a tenant
-   */
-  hasPool(tenantId) {
-    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    return this.poolCache.has(schemaName);
-  }
-  /**
-   * Get count of active pools
-   */
-  getPoolCount() {
-    return this.poolCache.size();
-  }
-  /**
-   * Get all active tenant IDs
-   */
-  getActiveTenantIds() {
-    return Array.from(this.tenantIdBySchema.values());
-  }
-  /**
-   * Get the retry configuration
-   */
-  getRetryConfig() {
-    return this.retryHandler.getConfig();
-  }
-  /**
-   * Pre-warm pools for specified tenants to reduce cold start latency
-   *
-   * Uses automatic retry with exponential backoff for connection failures.
-   */
-  async warmup(tenantIds, options = {}) {
-    this.ensureNotDisposed();
-    const startTime = Date.now();
-    const { concurrency = 10, ping = true, onProgress } = 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) => {
-          const tenantStart = Date.now();
-          onProgress?.(tenantId, "starting");
-          try {
-            const alreadyWarm = this.hasPool(tenantId);
-            if (ping) {
-              await this.getDbAsync(tenantId);
-            } else {
-              this.getDb(tenantId);
-            }
-            const durationMs = Date.now() - tenantStart;
-            onProgress?.(tenantId, "completed");
-            this.debugLogger.logWarmup(tenantId, true, durationMs, alreadyWarm);
-            return {
-              tenantId,
-              success: true,
-              alreadyWarm,
-              durationMs
-            };
-          } catch (error) {
-            const durationMs = Date.now() - tenantStart;
-            onProgress?.(tenantId, "failed");
-            this.debugLogger.logWarmup(tenantId, false, durationMs, false);
-            return {
-              tenantId,
-              success: false,
-              alreadyWarm: false,
-              durationMs,
-              error: error.message
-            };
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      alreadyWarm: results.filter((r) => r.alreadyWarm).length,
-      durationMs: Date.now() - startTime,
-      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.poolCache.get(schemaName);
-    if (entry) {
-      this.debugLogger.logPoolEvicted(tenantId, schemaName, reason);
-      this.poolCache.delete(schemaName);
-      this.tenantIdBySchema.delete(schemaName);
-      await this.closePool(entry.pool, tenantId);
-    }
-  }
-  /**
-   * Start automatic cleanup of idle pools
-   */
-  startCleanup() {
-    if (this.cleanupInterval) return;
-    const cleanupIntervalMs = DEFAULT_CONFIG.cleanupIntervalMs;
-    this.cleanupInterval = setInterval(() => {
-      void this.cleanupIdlePools();
-    }, cleanupIntervalMs);
-    this.cleanupInterval.unref();
-  }
-  /**
-   * Stop automatic cleanup
-   */
-  stopCleanup() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-  /**
-   * Dispose all pools and cleanup resources
-   */
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.stopCleanup();
-    const closePromises = [];
-    for (const [schemaName, entry] of this.poolCache.entries()) {
-      const tenantId = this.tenantIdBySchema.get(schemaName);
-      closePromises.push(this.closePool(entry.pool, tenantId ?? schemaName));
-    }
-    await this.poolCache.clear();
-    this.tenantIdBySchema.clear();
-    if (this.sharedPool) {
-      closePromises.push(this.closePool(this.sharedPool, "shared"));
-      this.sharedPool = null;
-      this.sharedDb = null;
-    }
-    await Promise.all(closePromises);
-  }
-  /**
-   * Create a new pool entry for a tenant
-   */
-  createPoolEntry(tenantId, schemaName) {
-    const pool = new Pool({
-      connectionString: this.config.connection.url,
-      ...DEFAULT_CONFIG.poolConfig,
-      ...this.config.connection.poolConfig,
-      options: `-c search_path=${schemaName},public`
-    });
-    pool.on("error", async (err) => {
-      this.debugLogger.logPoolError(tenantId, err);
-      void this.config.hooks?.onError?.(tenantId, err);
-      await this.evictPool(tenantId, "error");
-    });
-    const db = drizzle(pool, {
-      schema: this.config.schemas.tenant
-    });
-    return {
-      db,
-      pool,
-      lastAccess: Date.now(),
-      schemaName
-    };
-  }
-  /**
-   * Dispose a pool entry (called by LRU cache)
-   */
-  disposePoolEntry(entry, schemaName) {
-    const tenantId = this.tenantIdBySchema.get(schemaName);
-    this.tenantIdBySchema.delete(schemaName);
-    if (tenantId) {
-      this.debugLogger.logPoolEvicted(tenantId, schemaName, "lru_eviction");
-    }
-    void this.closePool(entry.pool, tenantId ?? schemaName).then(() => {
-      if (tenantId) {
-        void this.config.hooks?.onPoolEvicted?.(tenantId);
-      }
-    });
-  }
-  /**
-   * Close a pool gracefully
-   */
-  async closePool(pool, identifier) {
-    try {
-      await pool.end();
-    } catch (error) {
-      void this.config.hooks?.onError?.(identifier, error);
-    }
-  }
-  /**
-   * Cleanup pools that have been idle for too long
-   */
-  async cleanupIdlePools() {
-    const evictedSchemas = await this.poolCache.evictExpired();
-    for (const schemaName of evictedSchemas) {
-      const tenantId = this.tenantIdBySchema.get(schemaName);
-      if (tenantId) {
-        this.debugLogger.logPoolEvicted(tenantId, schemaName, "ttl_expired");
-        this.tenantIdBySchema.delete(schemaName);
-      }
-    }
-  }
-  /**
-   * Ensure the manager hasn't been disposed
-   */
-  ensureNotDisposed() {
-    if (this.disposed) {
-      throw new Error("[drizzle-multitenant] TenantManager has been disposed");
-    }
-  }
-};
-
-// src/manager.ts
-function createTenantManager(config) {
-  const poolManager = new PoolManager(config);
-  poolManager.startCleanup();
-  return {
-    getDb(tenantId) {
-      return poolManager.getDb(tenantId);
-    },
-    async getDbAsync(tenantId) {
-      return poolManager.getDbAsync(tenantId);
-    },
-    getSharedDb() {
-      return poolManager.getSharedDb();
-    },
-    async getSharedDbAsync() {
-      return poolManager.getSharedDbAsync();
-    },
-    getSchemaName(tenantId) {
-      return poolManager.getSchemaName(tenantId);
-    },
-    hasPool(tenantId) {
-      return poolManager.hasPool(tenantId);
-    },
-    getPoolCount() {
-      return poolManager.getPoolCount();
-    },
-    getActiveTenantIds() {
-      return poolManager.getActiveTenantIds();
-    },
-    getRetryConfig() {
-      return poolManager.getRetryConfig();
-    },
-    async evictPool(tenantId) {
-      await poolManager.evictPool(tenantId);
-    },
-    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();
-    }
-  };
-}
-function createTenantContext(manager) {
-  const storage = new AsyncLocalStorage();
-  function getTenantOrNull() {
-    return storage.getStore();
-  }
-  function getTenant() {
-    const context = getTenantOrNull();
-    if (!context) {
-      throw new Error(
-        "[drizzle-multitenant] No tenant context found. Make sure you are calling this within runWithTenant()."
-      );
-    }
-    return context;
-  }
-  function getTenantId() {
-    return getTenant().tenantId;
-  }
-  function getTenantDb() {
-    const tenantId = getTenantId();
-    return manager.getDb(tenantId);
-  }
-  function getSharedDb() {
-    return manager.getSharedDb();
-  }
-  function isInTenantContext() {
-    return getTenantOrNull() !== void 0;
-  }
-  function runWithTenant(context, callback) {
-    if (!context.tenantId) {
-      throw new Error("[drizzle-multitenant] tenantId is required in context");
-    }
-    return storage.run(context, callback);
-  }
-  return {
-    runWithTenant,
-    getTenant,
-    getTenantOrNull,
-    getTenantId,
-    getTenantDb,
-    getSharedDb,
-    isInTenantContext
-  };
-}
-
-// src/migrator/table-format.ts
-async function detectTableFormat(pool, schemaName, tableName) {
-  const tableExists = await pool.query(
-    `SELECT EXISTS (
+import {Pool}from'pg';import {drizzle}from'drizzle-orm/node-postgres';import {LRUCache}from'lru-cache';import {AsyncLocalStorage}from'async_hooks';import {readdir,readFile}from'fs/promises';import {join,basename}from'path';import {createHash}from'crypto';import {existsSync}from'fs';import {sql,getTableName}from'drizzle-orm';function Se(c){return be(c),c}function be(c){if(!c.connection.url)throw new Error("[drizzle-multitenant] connection.url is required");if(!c.isolation.strategy)throw new Error("[drizzle-multitenant] isolation.strategy is required");if(c.isolation.strategy!=="schema")throw new Error(`[drizzle-multitenant] isolation.strategy "${c.isolation.strategy}" is not yet supported. Only "schema" is currently available.`);if(!c.isolation.schemaNameTemplate)throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate is required");if(typeof c.isolation.schemaNameTemplate!="function")throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate must be a function");if(!c.schemas.tenant)throw new Error("[drizzle-multitenant] schemas.tenant is required");if(c.isolation.maxPools!==void 0&&c.isolation.maxPools<1)throw new Error("[drizzle-multitenant] isolation.maxPools must be at least 1");if(c.isolation.poolTtlMs!==void 0&&c.isolation.poolTtlMs<0)throw new Error("[drizzle-multitenant] isolation.poolTtlMs must be non-negative");if(c.connection.retry){let e=c.connection.retry;if(e.maxAttempts!==void 0&&e.maxAttempts<1)throw new Error("[drizzle-multitenant] connection.retry.maxAttempts must be at least 1");if(e.initialDelayMs!==void 0&&e.initialDelayMs<0)throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs must be non-negative");if(e.maxDelayMs!==void 0&&e.maxDelayMs<0)throw new Error("[drizzle-multitenant] connection.retry.maxDelayMs must be non-negative");if(e.backoffMultiplier!==void 0&&e.backoffMultiplier<1)throw new Error("[drizzle-multitenant] connection.retry.backoffMultiplier must be at least 1");if(e.initialDelayMs!==void 0&&e.maxDelayMs!==void 0&&e.initialDelayMs>e.maxDelayMs)throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs cannot be greater than maxDelayMs")}}var T={maxPools:50,poolTtlMs:36e5,cleanupIntervalMs:6e4,poolConfig:{max:10,idleTimeoutMillis:3e4,connectionTimeoutMillis:5e3},retry:{maxAttempts:3,initialDelayMs:100,maxDelayMs:5e3,backoffMultiplier:2,jitter:true}};var R="[drizzle-multitenant]";var W=class{enabled;logQueries;logPoolEvents;slowQueryThreshold;logger;constructor(e){this.enabled=e?.enabled??false,this.logQueries=e?.logQueries??true,this.logPoolEvents=e?.logPoolEvents??true,this.slowQueryThreshold=e?.slowQueryThreshold??1e3,this.logger=e?.logger??this.defaultLogger;}isEnabled(){return this.enabled}logQuery(e,t,n){if(!this.enabled||!this.logQueries)return;let a=n>=this.slowQueryThreshold,s={type:a?"slow_query":"query",tenantId:e,query:this.truncateQuery(t),durationMs:n};a?this.logger(`${R} tenant=${e} SLOW_QUERY duration=${n}ms query="${this.truncateQuery(t)}"`,s):this.logger(`${R} tenant=${e} query="${this.truncateQuery(t)}" duration=${n}ms`,s);}logPoolCreated(e,t){if(!this.enabled||!this.logPoolEvents)return;let n={type:"pool_created",tenantId:e,schemaName:t};this.logger(`${R} tenant=${e} POOL_CREATED schema=${t}`,n);}logPoolEvicted(e,t,n){if(!this.enabled||!this.logPoolEvents)return;let a={type:"pool_evicted",tenantId:e,schemaName:t,metadata:n?{reason:n}:void 0},r=n?` reason=${n}`:"";this.logger(`${R} tenant=${e} POOL_EVICTED schema=${t}${r}`,a);}logPoolError(e,t){if(!this.enabled||!this.logPoolEvents)return;let n={type:"pool_error",tenantId:e,error:t.message};this.logger(`${R} tenant=${e} POOL_ERROR error="${t.message}"`,n);}logWarmup(e,t,n,a){if(!this.enabled||!this.logPoolEvents)return;let r={type:"warmup",tenantId:e,durationMs:n,metadata:{success:t,alreadyWarm:a}},s=a?"already_warm":t?"success":"failed";this.logger(`${R} tenant=${e} WARMUP status=${s} duration=${n}ms`,r);}logConnectionRetry(e,t,n,a,r){if(!this.enabled||!this.logPoolEvents)return;let s={type:"connection_retry",tenantId:e,error:a.message,metadata:{attempt:t,maxAttempts:n,delayMs:r}};this.logger(`${R} tenant=${e} CONNECTION_RETRY attempt=${t}/${n} delay=${r}ms error="${a.message}"`,s);}logConnectionSuccess(e,t,n){if(!this.enabled||!this.logPoolEvents)return;let a={type:"pool_created",tenantId:e,durationMs:n,metadata:{attempts:t}};t>1&&this.logger(`${R} tenant=${e} CONNECTION_SUCCESS attempts=${t} totalTime=${n}ms`,a);}log(e,t){this.enabled&&this.logger(`${R} ${e}`,t);}defaultLogger(e,t){console.log(e);}truncateQuery(e,t=100){let n=e.replace(/\s+/g," ").trim();return n.length<=t?n:n.substring(0,t-3)+"..."}};function G(c){return new W(c)}var x=class{cache;poolTtlMs;onDispose;constructor(e){this.poolTtlMs=e.poolTtlMs,this.onDispose=e.onDispose,this.cache=new LRUCache({max:e.maxPools,dispose:(t,n)=>{this.handleDispose(n,t);},noDisposeOnSet:true});}get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t);}has(e){return this.cache.has(e)}delete(e){return this.cache.delete(e)}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}*entries(){for(let[e,t]of this.cache.entries())yield [e,t];}async clear(){this.cache.clear(),await Promise.resolve();}evictLRU(){let e=Array.from(this.cache.keys());if(e.length===0)return;let t=e[e.length-1];return this.cache.delete(t),t}async evictExpired(){if(!this.poolTtlMs)return [];let e=Date.now(),t=[];for(let[n,a]of this.cache.entries())e-a.lastAccess>this.poolTtlMs&&t.push(n);for(let n of t)this.cache.delete(n);return t}touch(e){let t=this.cache.get(e);t&&(t.lastAccess=Date.now());}getMaxPools(){return this.cache.max}getTtlMs(){return this.poolTtlMs}isExpired(e){return this.poolTtlMs?Date.now()-e.lastAccess>this.poolTtlMs:false}async handleDispose(e,t){this.onDispose&&await this.onDispose(e,t);}};function J(c){let e=c.message.toLowerCase();return !!(e.includes("econnrefused")||e.includes("econnreset")||e.includes("etimedout")||e.includes("enotfound")||e.includes("connection refused")||e.includes("connection reset")||e.includes("connection terminated")||e.includes("connection timed out")||e.includes("timeout expired")||e.includes("socket hang up")||e.includes("too many connections")||e.includes("sorry, too many clients")||e.includes("the database system is starting up")||e.includes("the database system is shutting down")||e.includes("server closed the connection unexpectedly")||e.includes("could not connect to server")||e.includes("ssl connection")||e.includes("ssl handshake"))}function Me(c){return new Promise(e=>setTimeout(e,c))}var E=class{config;constructor(e){this.config={maxAttempts:e?.maxAttempts??T.retry.maxAttempts,initialDelayMs:e?.initialDelayMs??T.retry.initialDelayMs,maxDelayMs:e?.maxDelayMs??T.retry.maxDelayMs,backoffMultiplier:e?.backoffMultiplier??T.retry.backoffMultiplier,jitter:e?.jitter??T.retry.jitter,isRetryable:e?.isRetryable??J,onRetry:e?.onRetry};}async withRetry(e,t){let n=t?{...this.config,...t}:this.config,a=Date.now(),r=null;for(let s=0;s<n.maxAttempts;s++)try{return {result:await e(),attempts:s+1,totalTimeMs:Date.now()-a}}catch(i){r=i;let o=s>=n.maxAttempts-1,m=n.isRetryable??this.isRetryable;if(o||!m(r))throw r;let l=this.calculateDelay(s,n);n.onRetry?.(s+1,r,l),await Me(l);}throw r??new Error("Retry failed with no error")}calculateDelay(e,t){let n=t?{...this.config,...t}:this.config,a=n.initialDelayMs*Math.pow(n.backoffMultiplier,e),r=Math.min(a,n.maxDelayMs);if(n.jitter){let s=1+Math.random()*.25;return Math.floor(r*s)}return Math.floor(r)}isRetryable(e){return (this.config.isRetryable??J)(e)}getConfig(){return {...this.config}}getMaxAttempts(){return this.config.maxAttempts}};var P=class{constructor(e){this.deps=e;}async checkHealth(e={}){let t=Date.now(),{ping:n=true,pingTimeoutMs:a=5e3,includeShared:r=true,tenantIds:s}=e,i=[],o="ok",m,l,h=this.getPoolsToCheck(s).map(async({schemaName:S,tenantId:N,entry:M})=>this.checkPoolHealth(N,S,M,n,a));i.push(...await Promise.all(h));let d=this.deps.getSharedPool();if(r&&d){let S=await this.checkSharedDbHealth(d,n,a);o=S.status,m=S.responseTimeMs,l=S.error;}let g=i.filter(S=>S.status==="degraded").length,w=i.filter(S=>S.status==="unhealthy").length,b={healthy:w===0&&o!=="unhealthy",pools:i,sharedDb:o,totalPools:i.length,degradedPools:g,unhealthyPools:w,timestamp:new Date().toISOString(),durationMs:Date.now()-t};return m!==void 0&&(b.sharedDbResponseTimeMs=m),l!==void 0&&(b.sharedDbError=l),b}getPoolsToCheck(e){let t=[];if(e&&e.length>0)for(let n of e){let a=this.deps.getSchemaName(n),r=this.deps.getPoolEntry(a);r&&t.push({schemaName:a,tenantId:n,entry:r});}else for(let[n,a]of this.deps.getPoolEntries()){let r=this.deps.getTenantIdBySchema(n)??n;t.push({schemaName:n,tenantId:r,entry:a});}return t}async checkPoolHealth(e,t,n,a,r){let s=n.pool,i=s.totalCount,o=s.idleCount,m=s.waitingCount,l="ok",u,h;if(m>0&&(l="degraded"),a){let g=await this.executePingQuery(s,r);u=g.responseTimeMs,g.success?g.responseTimeMs&&g.responseTimeMs>r/2&&l==="ok"&&(l="degraded"):(l="unhealthy",h=g.error);}let d={tenantId:e,schemaName:t,status:l,totalConnections:i,idleConnections:o,waitingRequests:m};return u!==void 0&&(d.responseTimeMs=u),h!==void 0&&(d.error=h),d}async checkSharedDbHealth(e,t,n){let a="ok",r,s;if(e.waitingCount>0&&(a="degraded"),t){let m=await this.executePingQuery(e,n);r=m.responseTimeMs,m.success?m.responseTimeMs&&m.responseTimeMs>n/2&&a==="ok"&&(a="degraded"):(a="unhealthy",s=m.error);}let o={status:a};return r!==void 0&&(o.responseTimeMs=r),s!==void 0&&(o.error=s),o}async executePingQuery(e,t){let n=Date.now();try{let a=new Promise((s,i)=>{setTimeout(()=>i(new Error("Health check ping timeout")),t);}),r=e.query("SELECT 1");return await Promise.race([r,a]),{success:!0,responseTimeMs:Date.now()-n}}catch(a){return {success:false,responseTimeMs:Date.now()-n,error:a.message}}}determineOverallHealth(e,t="ok"){return e.filter(a=>a.status==="unhealthy").length===0&&t!=="unhealthy"}};var k=class{constructor(e){this.config=e;let t=e.isolation.maxPools??T.maxPools,n=e.isolation.poolTtlMs??T.poolTtlMs;this.debugLogger=G(e.debug),this.retryHandler=new E(e.connection.retry),this.poolCache=new x({maxPools:t,poolTtlMs:n,onDispose:(a,r)=>{this.disposePoolEntry(r,a);}}),this.healthChecker=new P({getPoolEntries:()=>this.poolCache.entries(),getTenantIdBySchema:a=>this.tenantIdBySchema.get(a),getPoolEntry:a=>this.poolCache.get(a),getSchemaName:a=>this.config.isolation.schemaNameTemplate(a),getSharedPool:()=>this.sharedPool});}poolCache;tenantIdBySchema=new Map;pendingConnections=new Map;sharedPool=null;sharedDb=null;sharedDbPending=null;cleanupInterval=null;disposed=false;debugLogger;retryHandler;healthChecker;getDb(e){this.ensureNotDisposed();let t=this.config.isolation.schemaNameTemplate(e),n=this.poolCache.get(t);return n||(n=this.createPoolEntry(e,t),this.poolCache.set(t,n),this.tenantIdBySchema.set(t,e),this.debugLogger.logPoolCreated(e,t),this.config.hooks?.onPoolCreated?.(e)),this.poolCache.touch(t),n.db}async getDbAsync(e){this.ensureNotDisposed();let t=this.config.isolation.schemaNameTemplate(e),n=this.poolCache.get(t);if(n)return this.poolCache.touch(t),n.db;let a=this.pendingConnections.get(t);if(a)return n=await a,this.poolCache.touch(t),n.db;let r=this.connectWithRetry(e,t);this.pendingConnections.set(t,r);try{return n=await r,this.poolCache.set(t,n),this.tenantIdBySchema.set(t,e),this.debugLogger.logPoolCreated(e,t),this.config.hooks?.onPoolCreated?.(e),this.poolCache.touch(t),n.db}finally{this.pendingConnections.delete(t);}}async connectWithRetry(e,t){let n=this.retryHandler.getConfig(),a=n.maxAttempts,r=await this.retryHandler.withRetry(async()=>{let s=this.createPoolEntry(e,t);try{return await s.pool.query("SELECT 1"),s}catch(i){try{await s.pool.end();}catch{}throw i}},{onRetry:(s,i,o)=>{this.debugLogger.logConnectionRetry(e,s,a,i,o),n.onRetry?.(s,i,o);}});return this.debugLogger.logConnectionSuccess(e,r.attempts,r.totalTimeMs),r.result}getSharedDb(){return this.ensureNotDisposed(),this.sharedDb||(this.sharedPool=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig}),this.sharedPool.on("error",e=>{this.config.hooks?.onError?.("shared",e);}),this.sharedDb=drizzle(this.sharedPool,{schema:this.config.schemas.shared})),this.sharedDb}async getSharedDbAsync(){if(this.ensureNotDisposed(),this.sharedDb)return this.sharedDb;if(this.sharedDbPending)return this.sharedDbPending;this.sharedDbPending=this.connectSharedWithRetry();try{return await this.sharedDbPending}finally{this.sharedDbPending=null;}}async connectSharedWithRetry(){let e=this.retryHandler.getConfig(),t=e.maxAttempts,n=await this.retryHandler.withRetry(async()=>{let a=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig});try{return await a.query("SELECT 1"),a.on("error",r=>{this.config.hooks?.onError?.("shared",r);}),this.sharedPool=a,this.sharedDb=drizzle(a,{schema:this.config.schemas.shared}),this.sharedDb}catch(r){try{await a.end();}catch{}throw r}},{onRetry:(a,r,s)=>{this.debugLogger.logConnectionRetry("shared",a,t,r,s),e.onRetry?.(a,r,s);}});return this.debugLogger.logConnectionSuccess("shared",n.attempts,n.totalTimeMs),n.result}getSchemaName(e){return this.config.isolation.schemaNameTemplate(e)}hasPool(e){let t=this.config.isolation.schemaNameTemplate(e);return this.poolCache.has(t)}getPoolCount(){return this.poolCache.size()}getActiveTenantIds(){return Array.from(this.tenantIdBySchema.values())}getRetryConfig(){return this.retryHandler.getConfig()}async warmup(e,t={}){this.ensureNotDisposed();let n=Date.now(),{concurrency:a=10,ping:r=true,onProgress:s}=t,i=[];for(let o=0;o<e.length;o+=a){let m=e.slice(o,o+a),l=await Promise.all(m.map(async u=>{let h=Date.now();s?.(u,"starting");try{let d=this.hasPool(u);r?await this.getDbAsync(u):this.getDb(u);let g=Date.now()-h;return s?.(u,"completed"),this.debugLogger.logWarmup(u,!0,g,d),{tenantId:u,success:!0,alreadyWarm:d,durationMs:g}}catch(d){let g=Date.now()-h;return s?.(u,"failed"),this.debugLogger.logWarmup(u,false,g,false),{tenantId:u,success:false,alreadyWarm:false,durationMs:g,error:d.message}}}));i.push(...l);}return {total:i.length,succeeded:i.filter(o=>o.success).length,failed:i.filter(o=>!o.success).length,alreadyWarm:i.filter(o=>o.alreadyWarm).length,durationMs:Date.now()-n,details:i}}getMetrics(){this.ensureNotDisposed();let e=this.config.isolation.maxPools??T.maxPools,t=[];for(let[n,a]of this.poolCache.entries()){let r=this.tenantIdBySchema.get(n)??n,s=a.pool;t.push({tenantId:r,schemaName:n,connections:{total:s.totalCount,idle:s.idleCount,waiting:s.waitingCount},lastAccessedAt:new Date(a.lastAccess).toISOString()});}return {pools:{total:t.length,maxPools:e,tenants:t},shared:{initialized:this.sharedPool!==null,connections:this.sharedPool?{total:this.sharedPool.totalCount,idle:this.sharedPool.idleCount,waiting:this.sharedPool.waitingCount}:null},timestamp:new Date().toISOString()}}async healthCheck(e={}){return this.ensureNotDisposed(),this.healthChecker.checkHealth(e)}async evictPool(e,t="manual"){let n=this.config.isolation.schemaNameTemplate(e),a=this.poolCache.get(n);a&&(this.debugLogger.logPoolEvicted(e,n,t),this.poolCache.delete(n),this.tenantIdBySchema.delete(n),await this.closePool(a.pool,e));}startCleanup(){if(this.cleanupInterval)return;let e=T.cleanupIntervalMs;this.cleanupInterval=setInterval(()=>{this.cleanupIdlePools();},e),this.cleanupInterval.unref();}stopCleanup(){this.cleanupInterval&&(clearInterval(this.cleanupInterval),this.cleanupInterval=null);}async dispose(){if(this.disposed)return;this.disposed=true,this.stopCleanup();let e=[];for(let[t,n]of this.poolCache.entries()){let a=this.tenantIdBySchema.get(t);e.push(this.closePool(n.pool,a??t));}await this.poolCache.clear(),this.tenantIdBySchema.clear(),this.sharedPool&&(e.push(this.closePool(this.sharedPool,"shared")),this.sharedPool=null,this.sharedDb=null),await Promise.all(e);}createPoolEntry(e,t){let n=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig,options:`-c search_path=${t},public`});return n.on("error",async r=>{this.debugLogger.logPoolError(e,r),this.config.hooks?.onError?.(e,r),await this.evictPool(e,"error");}),{db:drizzle(n,{schema:this.config.schemas.tenant}),pool:n,lastAccess:Date.now(),schemaName:t}}disposePoolEntry(e,t){let n=this.tenantIdBySchema.get(t);this.tenantIdBySchema.delete(t),n&&this.debugLogger.logPoolEvicted(n,t,"lru_eviction"),this.closePool(e.pool,n??t).then(()=>{n&&this.config.hooks?.onPoolEvicted?.(n);});}async closePool(e,t){try{await e.end();}catch(n){this.config.hooks?.onError?.(t,n);}}async cleanupIdlePools(){let e=await this.poolCache.evictExpired();for(let t of e){let n=this.tenantIdBySchema.get(t);n&&(this.debugLogger.logPoolEvicted(n,t,"ttl_expired"),this.tenantIdBySchema.delete(t));}}ensureNotDisposed(){if(this.disposed)throw new Error("[drizzle-multitenant] TenantManager has been disposed")}};function Re(c){let e=new k(c);return e.startCleanup(),{getDb(t){return e.getDb(t)},async getDbAsync(t){return e.getDbAsync(t)},getSharedDb(){return e.getSharedDb()},async getSharedDbAsync(){return e.getSharedDbAsync()},getSchemaName(t){return e.getSchemaName(t)},hasPool(t){return e.hasPool(t)},getPoolCount(){return e.getPoolCount()},getActiveTenantIds(){return e.getActiveTenantIds()},getRetryConfig(){return e.getRetryConfig()},async evictPool(t){await e.evictPool(t);},async warmup(t,n){return e.warmup(t,n)},async healthCheck(t){return e.healthCheck(t)},getMetrics(){return e.getMetrics()},async dispose(){await e.dispose();}}}function De(c){let e=new AsyncLocalStorage;function t(){return e.getStore()}function n(){let m=t();if(!m)throw new Error("[drizzle-multitenant] No tenant context found. Make sure you are calling this within runWithTenant().");return m}function a(){return n().tenantId}function r(){let m=a();return c.getDb(m)}function s(){return c.getSharedDb()}function i(){return t()!==void 0}function o(m,l){if(!m.tenantId)throw new Error("[drizzle-multitenant] tenantId is required in context");return e.run(m,l)}return {runWithTenant:o,getTenant:n,getTenantOrNull:t,getTenantId:a,getTenantDb:r,getSharedDb:s,isInTenantContext:i}}async function Y(c,e,t){if(!(await c.query(`SELECT EXISTS (
       SELECT 1 FROM information_schema.tables
       WHERE table_schema = $1 AND table_name = $2
-    ) as exists`,
-    [schemaName, tableName]
-  );
-  if (!tableExists.rows[0]?.exists) {
-    return null;
-  }
-  const columnsResult = await pool.query(
-    `SELECT column_name, data_type
+    ) as exists`,[e,t])).rows[0]?.exists)return null;let a=await c.query(`SELECT column_name, data_type
      FROM information_schema.columns
-     WHERE table_schema = $1 AND table_name = $2`,
-    [schemaName, tableName]
-  );
-  const columnMap = new Map(
-    columnsResult.rows.map((r) => [r.column_name, r.data_type])
-  );
-  if (columnMap.has("name")) {
-    return {
-      format: "name",
-      tableName,
-      columns: {
-        identifier: "name",
-        timestamp: columnMap.has("applied_at") ? "applied_at" : "created_at",
-        timestampType: "timestamp"
-      }
-    };
-  }
-  if (columnMap.has("hash")) {
-    const createdAtType = columnMap.get("created_at");
-    if (createdAtType === "bigint") {
-      return {
-        format: "drizzle-kit",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "bigint"
-        }
-      };
-    }
-    return {
-      format: "hash",
-      tableName,
-      columns: {
-        identifier: "hash",
-        timestamp: "created_at",
-        timestampType: "timestamp"
-      }
-    };
-  }
-  return null;
-}
-function getFormatConfig(format, tableName = "__drizzle_migrations") {
-  switch (format) {
-    case "name":
-      return {
-        format: "name",
-        tableName,
-        columns: {
-          identifier: "name",
-          timestamp: "applied_at",
-          timestampType: "timestamp"
-        }
-      };
-    case "hash":
-      return {
-        format: "hash",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "timestamp"
-        }
-      };
-    case "drizzle-kit":
-      return {
-        format: "drizzle-kit",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "bigint"
-        }
-      };
-  }
-}
-var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
-var SchemaManager = class {
-  constructor(config, migrationsTable) {
-    this.config = config;
-    this.migrationsTable = migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
-  }
-  migrationsTable;
-  /**
-   * 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)
-   * ```
-   */
-  getSchemaName(tenantId) {
-    return this.config.isolation.schemaNameTemplate(tenantId);
-  }
-  /**
-   * 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 createPool(schemaName) {
-    return new Pool({
-      connectionString: this.config.connection.url,
-      ...this.config.connection.poolConfig,
-      options: `-c search_path="${schemaName}",public`
-    });
-  }
-  /**
-   * 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 createRootPool() {
-    return new Pool({
-      connectionString: this.config.connection.url,
-      ...this.config.connection.poolConfig
-    });
-  }
-  /**
-   * 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 createSchema(tenantId) {
-    const schemaName = this.getSchemaName(tenantId);
-    const pool = await this.createRootPool();
-    try {
-      await pool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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 dropSchema(tenantId, options = {}) {
-    const { cascade = true } = options;
-    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}`);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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 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`,
-        [schemaName]
-      );
-      return result.rowCount !== null && result.rowCount > 0;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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 listSchemas(pattern) {
-    const pool = await this.createRootPool();
-    try {
-      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] : []
-      );
-      return result.rows.map((row) => row.schema_name);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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 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}" (
+     WHERE table_schema = $1 AND table_name = $2`,[e,t]),r=new Map(a.rows.map(s=>[s.column_name,s.data_type]));return r.has("name")?{format:"name",tableName:t,columns:{identifier:"name",timestamp:r.has("applied_at")?"applied_at":"created_at",timestampType:"timestamp"}}:r.has("hash")?r.get("created_at")==="bigint"?{format:"drizzle-kit",tableName:t,columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}}:{format:"hash",tableName:t,columns:{identifier:"hash",timestamp:"created_at",timestampType:"timestamp"}}:null}function _(c,e="__drizzle_migrations"){switch(c){case "name":return {format:"name",tableName:e,columns:{identifier:"name",timestamp:"applied_at",timestampType:"timestamp"}};case "hash":return {format:"hash",tableName:e,columns:{identifier:"hash",timestamp:"created_at",timestampType:"timestamp"}};case "drizzle-kit":return {format:"drizzle-kit",tableName:e,columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}}}}var xe="__drizzle_migrations",O=class{constructor(e,t){this.config=e;this.migrationsTable=t??xe;}migrationsTable;getSchemaName(e){return this.config.isolation.schemaNameTemplate(e)}async createPool(e){return new Pool({connectionString:this.config.connection.url,...this.config.connection.poolConfig,options:`-c search_path="${e}",public`})}async createRootPool(){return new Pool({connectionString:this.config.connection.url,...this.config.connection.poolConfig})}async createSchema(e){let t=this.getSchemaName(e),n=await this.createRootPool();try{await n.query(`CREATE SCHEMA IF NOT EXISTS "${t}"`);}finally{await n.end();}}async dropSchema(e,t={}){let{cascade:n=true}=t,a=this.getSchemaName(e),r=await this.createRootPool();try{let s=n?"CASCADE":"RESTRICT";await r.query(`DROP SCHEMA IF EXISTS "${a}" ${s}`);}finally{await r.end();}}async schemaExists(e){let t=this.getSchemaName(e),n=await this.createRootPool();try{let a=await n.query("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1",[t]);return a.rowCount!==null&&a.rowCount>0}finally{await n.end();}}async listSchemas(e){let t=await this.createRootPool();try{let n=e?"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";return (await t.query(n,e?[e]:[])).rows.map(r=>r.schema_name)}finally{await t.end();}}async ensureMigrationsTable(e,t,n){let{identifier:a,timestamp:r,timestampType:s}=n.columns,i=a==="name"?"name VARCHAR(255) NOT NULL UNIQUE":"hash TEXT NOT NULL",o=s==="bigint"?`${r} BIGINT NOT NULL`:`${r} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;await e.query(`
+      CREATE TABLE IF NOT EXISTS "${t}"."${n.tableName}" (
         id SERIAL PRIMARY KEY,
-        ${identifierCol},
-        ${timestampCol}
+        ${i},
+        ${o}
       )
-    `);
-  }
-  /**
-   * 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
+    `);}async migrationsTableExists(e,t){let n=await e.query(`SELECT 1 FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = $2`,[t,this.migrationsTable]);return n.rowCount!==null&&n.rowCount>0}getMigrationsTableName(){return this.migrationsTable}};async function ee(c,e,t){return (await c.query(`SELECT
       column_name,
       data_type,
       udt_name,
@@ -1640,94 +22,10 @@ async function introspectColumns(pool, schemaName, tableName) {
       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
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>({name:a.column_name,dataType:a.data_type,udtName:a.udt_name,isNullable:a.is_nullable==="YES",columnDefault:a.column_default,characterMaximumLength:a.character_maximum_length,numericPrecision:a.numeric_precision,numericScale:a.numeric_scale,ordinalPosition:a.ordinal_position}))}function Z(c){return c===null?null:c.replace(/^'(.+)'::.+$/,"$1").replace(/^(.+)::.+$/,"$1").trim()}function te(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({column:r.name,type:"missing",expected:r.dataType,description:`Column "${r.name}" (${r.dataType}) is missing`});continue}r.udtName!==s.udtName&&t.push({column:r.name,type:"type_mismatch",expected:r.udtName,actual:s.udtName,description:`Column "${r.name}" type mismatch: expected "${r.udtName}", got "${s.udtName}"`}),r.isNullable!==s.isNullable&&t.push({column:r.name,type:"nullable_mismatch",expected:r.isNullable,actual:s.isNullable,description:`Column "${r.name}" nullable mismatch: expected ${r.isNullable?"NULL":"NOT NULL"}, got ${s.isNullable?"NULL":"NOT NULL"}`});let i=Z(r.columnDefault),o=Z(s.columnDefault);i!==o&&t.push({column:r.name,type:"default_mismatch",expected:r.columnDefault,actual:s.columnDefault,description:`Column "${r.name}" default mismatch: expected "${r.columnDefault??"none"}", got "${s.columnDefault??"none"}"`});}for(let r of e)n.has(r.name)||t.push({column:r.name,type:"extra",actual:r.dataType,description:`Extra column "${r.name}" (${r.dataType}) not in reference`});return t}async function ne(c,e,t){let n=await c.query(`SELECT indexname, indexdef
      FROM pg_indexes
      WHERE schemaname = $1 AND tablename = $2
-     ORDER BY indexname`,
-    [schemaName, tableName]
-  );
-  const indexDetails = await pool.query(
-    `SELECT
+     ORDER BY indexname`,[e,t]),a=await c.query(`SELECT
       i.relname as indexname,
       a.attname as column_name,
       ix.indisunique as is_unique,
@@ -1738,77 +36,7 @@ async function introspectIndexes(pool, schemaName, tableName) {
      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
+     ORDER BY i.relname, a.attnum`,[e,t]),r=new Map;for(let s of a.rows){let i=r.get(s.indexname);i?i.columns.push(s.column_name):r.set(s.indexname,{columns:[s.column_name],isUnique:s.is_unique,isPrimary:s.is_primary});}return n.rows.map(s=>{let i=r.get(s.indexname);return {name:s.indexname,columns:i?.columns??[],isUnique:i?.isUnique??false,isPrimary:i?.isPrimary??false,definition:s.indexdef}})}function re(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({index:r.name,type:"missing",expected:r.definition,description:`Index "${r.name}" is missing`});continue}let i=r.columns.sort().join(","),o=s.columns.sort().join(",");(i!==o||r.isUnique!==s.isUnique)&&t.push({index:r.name,type:"definition_mismatch",expected:r.definition,actual:s.definition,description:`Index "${r.name}" definition differs`});}for(let r of e)n.has(r.name)||t.push({index:r.name,type:"extra",actual:r.definition,description:`Extra index "${r.name}" not in reference`});return t}async function ae(c,e,t){let n=await c.query(`SELECT
       tc.constraint_name,
       tc.constraint_type,
       kcu.column_name,
@@ -1827,1698 +55,20 @@ async function introspectConstraints(pool, schemaName, tableName) {
        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,
-      includeIndexes = true,
-      includeConstraints = true,
-      excludeTables = [this.migrationsTable],
-      onProgress
-    } = options;
-    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 = [];
-    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) => {
-          try {
-            onProgress?.(tenantId, "starting");
-            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");
-            return {
-              tenantId,
-              schemaName: this.getSchemaName(tenantId),
-              hasDrift: false,
-              tables: [],
-              issueCount: 0,
-              error: error.message
-            };
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return {
-      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
-    };
-  }
-  /**
-   * 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 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: this.getSchemaName(tenantId),
-        hasDrift: false,
-        tables: [],
-        issueCount: 0,
-        error: "Failed to introspect reference tenant"
-      };
-    }
-    const tenantSchema = await this.introspectSchema(tenantId, {
-      includeIndexes,
-      includeConstraints,
-      excludeTables
-    });
-    if (!tenantSchema) {
-      return {
-        tenantId,
-        schemaName: this.getSchemaName(tenantId),
-        hasDrift: false,
-        tables: [],
-        issueCount: 0,
-        error: "Failed to introspect tenant schema"
-      };
-    }
-    return this.compareSchemas(referenceSchema, tenantSchema, {
-      includeIndexes,
-      includeConstraints
-    });
-  }
-  /**
-   * 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 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;
-      }
-      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
-        });
-      }
-    }
-    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
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,t]),a=new Map;for(let r of n.rows){let s=a.get(r.constraint_name);if(s)r.column_name&&!s.columns.includes(r.column_name)&&s.columns.push(r.column_name),r.foreign_column_name&&s.foreignColumns&&!s.foreignColumns.includes(r.foreign_column_name)&&s.foreignColumns.push(r.foreign_column_name);else {let i={name:r.constraint_name,type:r.constraint_type,columns:r.column_name?[r.column_name]:[]};r.foreign_table_name&&(i.foreignTable=r.foreign_table_name),r.foreign_column_name&&(i.foreignColumns=[r.foreign_column_name]),r.check_clause&&(i.checkExpression=r.check_clause),a.set(r.constraint_name,i);}}return Array.from(a.values())}function se(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({constraint:r.name,type:"missing",expected:`${r.type} on (${r.columns.join(", ")})`,description:`Constraint "${r.name}" (${r.type}) is missing`});continue}let i=r.columns.sort().join(","),o=s.columns.sort().join(",");(r.type!==s.type||i!==o)&&t.push({constraint:r.name,type:"definition_mismatch",expected:`${r.type} on (${r.columns.join(", ")})`,actual:`${s.type} on (${s.columns.join(", ")})`,description:`Constraint "${r.name}" definition differs`});}for(let r of e)n.has(r.name)||t.push({constraint:r.name,type:"extra",actual:`${r.type} on (${r.columns.join(", ")})`,description:`Extra constraint "${r.name}" (${r.type}) not in reference`});return t}var Ee="__drizzle_migrations",$=class{constructor(e,t,n){this.tenantConfig=e;this.schemaManager=t;this.driftConfig=n;this.migrationsTable=n.migrationsTable??Ee;}migrationsTable;getSchemaName(e){return this.tenantConfig.isolation.schemaNameTemplate(e)}async createPool(e){return this.schemaManager.createPool(e)}async detectDrift(e={}){let t=Date.now(),{concurrency:n=10,includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[this.migrationsTable],onProgress:i}=e,o=e.tenantIds??await this.driftConfig.tenantDiscovery();if(o.length===0)return {referenceTenant:"",total:0,noDrift:0,withDrift:0,error:0,details:[],timestamp:new Date().toISOString(),durationMs:Date.now()-t};let m=e.referenceTenant??o[0];i?.(m,"starting"),i?.(m,"introspecting");let l=await this.introspectSchema(m,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!l)return {referenceTenant:m,total:o.length,noDrift:0,withDrift:0,error:o.length,details:o.map(d=>({tenantId:d,schemaName:this.getSchemaName(d),hasDrift:false,tables:[],issueCount:0,error:d===m?"Failed to introspect reference tenant":"Reference tenant introspection failed"})),timestamp:new Date().toISOString(),durationMs:Date.now()-t};i?.(m,"completed");let u=o.filter(d=>d!==m),h=[];h.push({tenantId:m,schemaName:l.schemaName,hasDrift:false,tables:[],issueCount:0});for(let d=0;d<u.length;d+=n){let g=u.slice(d,d+n),w=await Promise.all(g.map(async y=>{try{i?.(y,"starting"),i?.(y,"introspecting");let b=await this.introspectSchema(y,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!b)return i?.(y,"failed"),{tenantId:y,schemaName:this.getSchemaName(y),hasDrift:!1,tables:[],issueCount:0,error:"Failed to introspect schema"};i?.(y,"comparing");let S=this.compareSchemas(l,b,{includeIndexes:a,includeConstraints:r});return i?.(y,"completed"),S}catch(b){return i?.(y,"failed"),{tenantId:y,schemaName:this.getSchemaName(y),hasDrift:false,tables:[],issueCount:0,error:b.message}}}));h.push(...w);}return {referenceTenant:m,total:h.length,noDrift:h.filter(d=>!d.hasDrift&&!d.error).length,withDrift:h.filter(d=>d.hasDrift&&!d.error).length,error:h.filter(d=>!!d.error).length,details:h,timestamp:new Date().toISOString(),durationMs:Date.now()-t}}async compareTenant(e,t,n={}){let{includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[this.migrationsTable]}=n,i=await this.introspectSchema(t,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!i)return {tenantId:e,schemaName:this.getSchemaName(e),hasDrift:false,tables:[],issueCount:0,error:"Failed to introspect reference tenant"};let o=await this.introspectSchema(e,{includeIndexes:a,includeConstraints:r,excludeTables:s});return o?this.compareSchemas(i,o,{includeIndexes:a,includeConstraints:r}):{tenantId:e,schemaName:this.getSchemaName(e),hasDrift:false,tables:[],issueCount:0,error:"Failed to introspect tenant schema"}}async introspectSchema(e,t={}){let n=this.getSchemaName(e),a=await this.createPool(n);try{let r=await this.introspectTables(a,n,t);return {tenantId:e,schemaName:n,tables:r,introspectedAt:new Date}}catch{return null}finally{await a.end();}}compareSchemas(e,t,n={}){let{includeIndexes:a=true,includeConstraints:r=true}=n,s=[],i=0,o=new Map(e.tables.map(l=>[l.name,l])),m=new Map(t.tables.map(l=>[l.name,l]));for(let l of e.tables){let u=m.get(l.name);if(!u){s.push({table:l.name,status:"missing",columns:l.columns.map(y=>({column:y.name,type:"missing",expected:y.dataType,description:`Column "${y.name}" (${y.dataType}) is missing`})),indexes:[],constraints:[]}),i+=l.columns.length;continue}let h=te(l.columns,u.columns),d=a?re(l.indexes,u.indexes):[],g=r?se(l.constraints,u.constraints):[],w=h.length+d.length+g.length;i+=w,w>0&&s.push({table:l.name,status:"drifted",columns:h,indexes:d,constraints:g});}for(let l of t.tables)o.has(l.name)||(s.push({table:l.name,status:"extra",columns:l.columns.map(u=>({column:u.name,type:"extra",actual:u.dataType,description:`Extra column "${u.name}" (${u.dataType}) not in reference`})),indexes:[],constraints:[]}),i+=l.columns.length);return {tenantId:t.tenantId,schemaName:t.schemaName,hasDrift:i>0,tables:s,issueCount:i}}async introspectTables(e,t,n){let{includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[]}=n,i=await e.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,
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        success: false,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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 seedAll(seedFn, 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");
-            onProgress?.(tenantId, "seeding");
-            const result = await this.seedTenant(tenantId, seedFn);
-            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);
-  }
-  /**
-   * 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 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 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,
-          missing: allMigrations.map((m) => m.name),
-          orphans: [],
-          inSync: allMigrations.length === 0,
-          format: null
-        };
-      }
-      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,
-        missing,
-        orphans,
-        inSync: missing.length === 0 && orphans.length === 0,
-        format: format.format
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        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,
-        durationMs: Date.now() - startTime
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * 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
+       ORDER BY table_name`,[t]),o=[];for(let m of i.rows){if(s.includes(m.table_name))continue;let l=await ee(e,t,m.table_name),u=a?await ne(e,t,m.table_name):[],h=r?await ae(e,t,m.table_name):[];o.push({name:m.table_name,columns:l,indexes:u,constraints:h});}return o}};var A=class{constructor(e,t){this.config=e;this.deps=t;}async seedTenant(e,t){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=await this.deps.createPool(a);try{let s=drizzle(r,{schema:this.deps.tenantSchema});return await t(s,e),{tenantId:e,schemaName:a,success:!0,durationMs:Date.now()-n}}catch(s){return {tenantId:e,schemaName:a,success:false,error:s.message,durationMs:Date.now()-n}}finally{await r.end();}}async seedAll(e,t={}){let{concurrency:n=10,onProgress:a,onError:r}=t,s=await this.config.tenantDiscovery(),i=[],o=false;for(let m=0;m<s.length&&!o;m+=n){let l=s.slice(m,m+n),u=await Promise.all(l.map(async h=>{if(o)return this.createSkippedResult(h);try{a?.(h,"starting"),a?.(h,"seeding");let d=await this.seedTenant(h,e);return a?.(h,d.success?"completed":"failed"),d}catch(d){return a?.(h,"failed"),r?.(h,d)==="abort"&&(o=true),this.createErrorResult(h,d)}}));i.push(...u);}if(o){let m=s.slice(i.length);for(let l of m)i.push(this.createSkippedResult(l));}return this.aggregateResults(i)}async seedTenants(e,t,n={}){let{concurrency:a=10,onProgress:r,onError:s}=n,i=[];for(let o=0;o<e.length;o+=a){let m=e.slice(o,o+a),l=await Promise.all(m.map(async u=>{try{r?.(u,"starting"),r?.(u,"seeding");let h=await this.seedTenant(u,t);return r?.(u,h.success?"completed":"failed"),h}catch(h){return r?.(u,"failed"),s?.(u,h),this.createErrorResult(u,h)}}));i.push(...l);}return this.aggregateResults(i)}createSkippedResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:"Skipped due to abort",durationMs:0}}createErrorResult(e,t){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:t.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success&&t.error!=="Skipped due to abort").length,skipped:e.filter(t=>t.error==="Skipped due to abort").length,details:e}}};var Ne="public",v=class{constructor(e,t){this.config=e;this.deps=t;this.schemaName=e.schemaName??Ne;}schemaName;async seed(e){let t=Date.now(),n=await this.deps.createPool();try{this.config.hooks?.onStart?.();let a=drizzle(n,{schema:this.deps.sharedSchema});return await e(a),this.config.hooks?.onComplete?.(),{schemaName:this.schemaName,success:!0,durationMs:Date.now()-t}}catch(a){return this.config.hooks?.onError?.(a),{schemaName:this.schemaName,success:false,error:a.message,durationMs:Date.now()-t}}finally{await n.end();}}};var F=class{constructor(e,t){this.config=e;this.deps=t;}async getSyncStatus(){let e=await this.config.tenantDiscovery(),t=await this.deps.loadMigrations(),n=[];for(let a of e)n.push(await this.getTenantSyncStatus(a,t));return {total:n.length,inSync:n.filter(a=>a.inSync&&!a.error).length,outOfSync:n.filter(a=>!a.inSync&&!a.error).length,error:n.filter(a=>!!a.error).length,details:n}}async getTenantSyncStatus(e,t){let n=this.deps.schemaNameTemplate(e),a=await this.deps.createPool(n);try{let r=t??await this.deps.loadMigrations(),s=new Set(r.map(g=>g.name)),i=new Set(r.map(g=>g.hash));if(!await this.deps.migrationsTableExists(a,n))return {tenantId:e,schemaName:n,missing:r.map(g=>g.name),orphans:[],inSync:r.length===0,format:null};let m=await this.deps.getOrDetectFormat(a,n),l=await this.getAppliedMigrations(a,n,m),u=new Set(l.map(g=>g.identifier)),h=r.filter(g=>!this.isMigrationApplied(g,u,m)).map(g=>g.name),d=l.filter(g=>(m.columns.identifier==="name"||!i.has(g.identifier))&&!s.has(g.identifier)).map(g=>g.identifier);return {tenantId:e,schemaName:n,missing:h,orphans:d,inSync:h.length===0&&d.length===0,format:m.format}}catch(r){return {tenantId:e,schemaName:n,missing:[],orphans:[],inSync:false,format:null,error:r.message}}finally{await a.end();}}async markMissing(e){let t=Date.now(),n=this.deps.schemaNameTemplate(e),a=[],r=await this.deps.createPool(n);try{let s=await this.getTenantSyncStatus(e);if(s.error)return {tenantId:e,schemaName:n,success:!1,markedMigrations:[],removedOrphans:[],error:s.error,durationMs:Date.now()-t};if(s.missing.length===0)return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-t};let i=await this.deps.getOrDetectFormat(r,n);await this.deps.ensureMigrationsTable(r,n,i);let o=await this.deps.loadMigrations(),m=new Set(s.missing);for(let l of o)m.has(l.name)&&(await this.recordMigration(r,n,l,i),a.push(l.name));return {tenantId:e,schemaName:n,success:!0,markedMigrations:a,removedOrphans:[],durationMs:Date.now()-t}}catch(s){return {tenantId:e,schemaName:n,success:false,markedMigrations:a,removedOrphans:[],error:s.message,durationMs:Date.now()-t}}finally{await r.end();}}async markAllMissing(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedSyncResult(u);try{n?.(u,"starting");let h=await this.markMissing(u);return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorSyncResult(u,h)}}));s.push(...l);}return this.aggregateSyncResults(s)}async cleanOrphans(e){let t=Date.now(),n=this.deps.schemaNameTemplate(e),a=[],r=await this.deps.createPool(n);try{let s=await this.getTenantSyncStatus(e);if(s.error)return {tenantId:e,schemaName:n,success:!1,markedMigrations:[],removedOrphans:[],error:s.error,durationMs:Date.now()-t};if(s.orphans.length===0)return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-t};let i=await this.deps.getOrDetectFormat(r,n),o=i.columns.identifier;for(let m of s.orphans)await r.query(`DELETE FROM "${n}"."${i.tableName}" WHERE "${o}" = $1`,[m]),a.push(m);return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:a,durationMs:Date.now()-t}}catch(s){return {tenantId:e,schemaName:n,success:false,markedMigrations:[],removedOrphans:a,error:s.message,durationMs:Date.now()-t}}finally{await r.end();}}async cleanAllOrphans(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedSyncResult(u);try{n?.(u,"starting");let h=await this.cleanOrphans(u);return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorSyncResult(u,h)}}));s.push(...l);}return this.aggregateSyncResults(s)}async getAppliedMigrations(e,t,n){let a=n.columns.identifier,r=n.columns.timestamp;return (await e.query(`SELECT id, "${a}" as identifier, "${r}" as applied_at
+       FROM "${t}"."${n.tableName}"
+       ORDER BY id`)).rows.map(i=>{let o=n.columns.timestampType==="bigint"?new Date(Number(i.applied_at)):new Date(i.applied_at);return {identifier:i.identifier,appliedAt:o}})}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async recordMigration(e,t,n,a){let{identifier:r,timestamp:s,timestampType:i}=a.columns,o=r==="name"?n.name:n.hash,m=i==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${t}"."${a.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]);}createSkippedSyncResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:"Skipped due to abort",durationMs:0}}createErrorSyncResult(e,t){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:t.message,durationMs:0}}aggregateSyncResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success).length,details:e}}};var L=class{constructor(e,t){this.config=e;this.deps=t;}async migrateTenant(e,t,n={}){let a=Date.now(),r=this.deps.schemaNameTemplate(e),s=[],i=await this.deps.createPool(r);try{await this.config.hooks?.beforeTenant?.(e);let o=await this.deps.getOrDetectFormat(i,r);await this.deps.ensureMigrationsTable(i,r,o);let m=t??await this.deps.loadMigrations(),l=await this.getAppliedMigrations(i,r,o),u=new Set(l.map(g=>g.identifier)),h=m.filter(g=>!this.isMigrationApplied(g,u,o));if(n.dryRun)return {tenantId:e,schemaName:r,success:!0,appliedMigrations:h.map(g=>g.name),durationMs:Date.now()-a,format:o.format};for(let g of h){let w=Date.now();n.onProgress?.(e,"migrating",g.name),await this.config.hooks?.beforeMigration?.(e,g.name),await this.applyMigration(i,r,g,o),await this.config.hooks?.afterMigration?.(e,g.name,Date.now()-w),s.push(g.name);}let d={tenantId:e,schemaName:r,success:!0,appliedMigrations:s,durationMs:Date.now()-a,format:o.format};return await this.config.hooks?.afterTenant?.(e,d),d}catch(o){let m={tenantId:e,schemaName:r,success:false,appliedMigrations:s,error:o.message,durationMs:Date.now()-a};return await this.config.hooks?.afterTenant?.(e,m),m}finally{await i.end();}}async markAsApplied(e,t={}){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=[],s=await this.deps.createPool(a);try{await this.config.hooks?.beforeTenant?.(e);let i=await this.deps.getOrDetectFormat(s,a);await this.deps.ensureMigrationsTable(s,a,i);let o=await this.deps.loadMigrations(),m=await this.getAppliedMigrations(s,a,i),l=new Set(m.map(d=>d.identifier)),u=o.filter(d=>!this.isMigrationApplied(d,l,i));for(let d of u){let g=Date.now();t.onProgress?.(e,"migrating",d.name),await this.config.hooks?.beforeMigration?.(e,d.name),await this.recordMigration(s,a,d,i),await this.config.hooks?.afterMigration?.(e,d.name,Date.now()-g),r.push(d.name);}let h={tenantId:e,schemaName:a,success:!0,appliedMigrations:r,durationMs:Date.now()-n,format:i.format};return await this.config.hooks?.afterTenant?.(e,h),h}catch(i){let o={tenantId:e,schemaName:a,success:false,appliedMigrations:r,error:i.message,durationMs:Date.now()-n};return await this.config.hooks?.afterTenant?.(e,o),o}finally{await s.end();}}async getTenantStatus(e,t){let n=this.deps.schemaNameTemplate(e),a=await this.deps.createPool(n);try{let r=t??await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(a,n))return {tenantId:e,schemaName:n,appliedCount:0,pendingCount:r.length,pendingMigrations:r.map(u=>u.name),status:r.length>0?"behind":"ok",format:null};let i=await this.deps.getOrDetectFormat(a,n),o=await this.getAppliedMigrations(a,n,i),m=new Set(o.map(u=>u.identifier)),l=r.filter(u=>!this.isMigrationApplied(u,m,i));return {tenantId:e,schemaName:n,appliedCount:o.length,pendingCount:l.length,pendingMigrations:l.map(u=>u.name),status:l.length>0?"behind":"ok",format:i.format}}catch(r){return {tenantId:e,schemaName:n,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:r.message,format:null}}finally{await a.end();}}async executeMigration(e,t,n,a,r){r?.markOnly?(r.onProgress?.("recording"),await this.recordMigration(e,t,n,a)):(r?.onProgress?.("applying"),await this.applyMigration(e,t,n,a));}async executeMigrations(e,t,n,a,r){let s=[];for(let i of n)await this.executeMigration(e,t,i,a,r),s.push(i.name);return s}async recordMigration(e,t,n,a){let{identifier:r,timestamp:s,timestampType:i}=a.columns,o=r==="name"?n.name:n.hash,m=i==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${t}"."${a.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]);}async getAppliedMigrations(e,t,n){let a=n.columns.identifier,r=n.columns.timestamp;return (await e.query(`SELECT id, "${a}" as identifier, "${r}" as applied_at
+       FROM "${t}"."${n.tableName}"
+       ORDER BY id`)).rows.map(i=>{let o=n.columns.timestampType==="bigint"?new Date(Number(i.applied_at)):new Date(i.applied_at);return {identifier:i.identifier,...n.columns.identifier==="name"?{name:i.identifier}:{hash:i.identifier},appliedAt:o}})}async getPendingMigrations(e,t,n,a){let r=await this.getAppliedMigrations(e,t,a),s=new Set(r.map(i=>i.identifier));return n.filter(i=>!this.isMigrationApplied(i,s,a))}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async applyMigration(e,t,n,a){let r=await e.connect();try{await r.query("BEGIN"),await r.query(n.sql);let{identifier:s,timestamp:i,timestampType:o}=a.columns,m=s==="name"?n.name:n.hash,l=o==="bigint"?Date.now():new Date;await r.query(`INSERT INTO "${t}"."${a.tableName}" ("${s}", "${i}") VALUES ($1, $2)`,[m,l]),await r.query("COMMIT");}catch(s){throw await r.query("ROLLBACK"),s}finally{r.release();}}};var I=class{constructor(e,t,n){this.config=e;this.executor=t;this.loadMigrations=n;}async migrateAll(e={}){let{concurrency:t=10,onProgress:n,onError:a,dryRun:r=false}=e,s=await this.config.tenantDiscovery(),i=await this.loadMigrations(),o=[],m=false;for(let l=0;l<s.length&&!m;l+=t){let u=s.slice(l,l+t),h=await Promise.all(u.map(async d=>{if(m)return this.createSkippedResult(d);try{n?.(d,"starting");let g=await this.executor.migrateTenant(d,i,{dryRun:r,onProgress:n});return n?.(d,g.success?"completed":"failed"),g}catch(g){return n?.(d,"failed"),a?.(d,g)==="abort"&&(m=true),this.createErrorResult(d,g)}}));o.push(...h);}if(m){let l=s.slice(o.length);for(let u of l)o.push(this.createSkippedResult(u));}return this.aggregateResults(o)}async migrateTenants(e,t={}){let n=await this.loadMigrations(),a=[],{concurrency:r=10,onProgress:s,onError:i,dryRun:o=false}=t;for(let m=0;m<e.length;m+=r){let l=e.slice(m,m+r),u=await Promise.all(l.map(async h=>{try{s?.(h,"starting");let d=await this.executor.migrateTenant(h,n,{dryRun:o,onProgress:s});return s?.(h,d.success?"completed":"failed"),d}catch(d){return s?.(h,"failed"),i?.(h,d),this.createErrorResult(h,d)}}));a.push(...u);}return this.aggregateResults(a)}async markAllAsApplied(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedResult(u);try{n?.(u,"starting");let h=await this.executor.markAsApplied(u,{onProgress:n});return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorResult(u,h)}}));s.push(...l);}if(i){let o=r.slice(s.length);for(let m of o)s.push(this.createSkippedResult(m));}return this.aggregateResults(s)}async getStatus(){let e=await this.config.tenantDiscovery(),t=await this.loadMigrations(),n=[];for(let a of e)n.push(await this.executor.getTenantStatus(a,t));return n}createSkippedResult(e){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:"Skipped due to abort",durationMs:0}}createErrorResult(e,t){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:t.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success&&t.error!=="Skipped due to abort").length,skipped:e.filter(t=>t.error==="Skipped due to abort").length,details:e}}};async function ie(c,e,t=[]){let n=t.length>0?t.map((r,s)=>`$${s+2}`).join(", "):"''::text";return (await c.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
+       AND table_name NOT IN (${n})
+     ORDER BY table_name`,[e,...t])).rows.map(r=>r.table_name)}async function ke(c,e,t){return (await c.query(`SELECT
       column_name,
       data_type,
       udt_name,
@@ -3529,68 +79,13 @@ async function getColumns(pool, schemaName, tableName) {
       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
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>({columnName:a.column_name,dataType:a.data_type,udtName:a.udt_name,isNullable:a.is_nullable==="YES",columnDefault:a.column_default,characterMaximumLength:a.character_maximum_length,numericPrecision:a.numeric_precision,numericScale:a.numeric_scale}))}async function Oe(c,e,t){let a=(await ke(c,e,t)).map(r=>{let s=r.udtName;r.dataType==="character varying"&&r.characterMaximumLength?s=`varchar(${r.characterMaximumLength})`:r.dataType==="character"&&r.characterMaximumLength?s=`char(${r.characterMaximumLength})`:r.dataType==="numeric"&&r.numericPrecision?s=`numeric(${r.numericPrecision}${r.numericScale?`, ${r.numericScale}`:""})`:r.dataType==="ARRAY"&&(s=r.udtName.replace(/^_/,"")+"[]");let i=`"${r.columnName}" ${s}`;if(r.isNullable||(i+=" NOT NULL"),r.columnDefault){let o=r.columnDefault.replace(new RegExp(`"?${e}"?\\.`,"g"),"");i+=` DEFAULT ${o}`;}return i});return `CREATE TABLE IF NOT EXISTS "${t}" (
+  ${a.join(`,
+  `)}
+)`}async function $e(c,e,t,n){return (await c.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
+       AND indexname NOT LIKE '%_pkey'`,[e,n])).rows.map(r=>r.indexdef.replace(new RegExp(`ON "${e}"\\."`,"g"),`ON "${t}"."`).replace(new RegExp(`"${e}"\\."`,"g"),`"${t}"."`))}async function Ae(c,e,t){let n=await c.query(`SELECT
       tc.constraint_name,
       kcu.column_name
      FROM information_schema.table_constraints tc
@@ -3600,17 +95,7 @@ async function generatePrimaryKeyDdl(pool, schemaName, tableName) {
      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
+     ORDER BY kcu.ordinal_position`,[e,t]);if(n.rows.length===0)return null;let a=n.rows.map(s=>`"${s.column_name}"`).join(", "),r=n.rows[0].constraint_name;return `ALTER TABLE "${t}" ADD CONSTRAINT "${r}" PRIMARY KEY (${a})`}async function ve(c,e,t,n){let a=await c.query(`SELECT
       tc.constraint_name,
       kcu.column_name,
       ccu.table_name as foreign_table_name,
@@ -3630,43 +115,7 @@ async function generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableNam
      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
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,n]),r=new Map;for(let s of a.rows){let i=r.get(s.constraint_name);i?(i.columns.push(s.column_name),i.foreignColumns.push(s.foreign_column_name)):r.set(s.constraint_name,{columns:[s.column_name],foreignTable:s.foreign_table_name,foreignColumns:[s.foreign_column_name],updateRule:s.update_rule,deleteRule:s.delete_rule});}return Array.from(r.entries()).map(([s,i])=>{let o=i.columns.map(u=>`"${u}"`).join(", "),m=i.foreignColumns.map(u=>`"${u}"`).join(", "),l=`ALTER TABLE "${t}"."${n}" `;return l+=`ADD CONSTRAINT "${s}" FOREIGN KEY (${o}) `,l+=`REFERENCES "${t}"."${i.foreignTable}" (${m})`,i.updateRule!=="NO ACTION"&&(l+=` ON UPDATE ${i.updateRule}`),i.deleteRule!=="NO ACTION"&&(l+=` ON DELETE ${i.deleteRule}`),l})}async function Fe(c,e,t){let n=await c.query(`SELECT
       tc.constraint_name,
       kcu.column_name
      FROM information_schema.table_constraints tc
@@ -3676,26 +125,7 @@ async function generateUniqueDdls(pool, schemaName, tableName) {
      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
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,t]),a=new Map;for(let r of n.rows){let s=a.get(r.constraint_name);s?s.push(r.column_name):a.set(r.constraint_name,[r.column_name]);}return Array.from(a.entries()).map(([r,s])=>{let i=s.map(o=>`"${o}"`).join(", ");return `ALTER TABLE "${t}" ADD CONSTRAINT "${r}" UNIQUE (${i})`})}async function Le(c,e,t){return (await c.query(`SELECT
       tc.constraint_name,
       cc.check_clause
      FROM information_schema.table_constraints tc
@@ -3705,91 +135,12 @@ async function generateCheckDdls(pool, schemaName, tableName) {
      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
+       AND tc.constraint_name NOT LIKE '%_not_null'`,[e,t])).rows.map(a=>`ALTER TABLE "${t}" ADD CONSTRAINT "${a.constraint_name}" CHECK (${a.check_clause})`)}async function Ie(c,e,t){let n=await c.query(`SELECT count(*) FROM "${e}"."${t}"`);return parseInt(n.rows[0].count,10)}async function oe(c,e,t,n){let[a,r,s,i,o,m,l]=await Promise.all([Oe(c,e,n),$e(c,e,t,n),Ae(c,e,n),Fe(c,e,n),Le(c,e,n),ve(c,e,t,n),Ie(c,e,n)]);return {name:n,createDdl:a,indexDdls:r,constraintDdls:[...s?[s]:[],...i,...o,...m],rowCount:l}}async function He(c,e,t){return (await c.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
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>a.column_name)}function qe(c){return c===null?"NULL":typeof c=="string"?`'${c.replace(/'/g,"''")}'`:typeof c=="boolean"?c?"TRUE":"FALSE":String(c)}async function je(c,e,t,n,a){let r=await He(c,e,n);if(r.length===0)return 0;let s=a?.[n]??{},i=r.map(u=>{if(u in s){let h=s[u];return `${qe(h)} as "${u}"`}return `"${u}"`}),o=r.map(u=>`"${u}"`).join(", "),m=i.join(", ");return (await c.query(`INSERT INTO "${t}"."${n}" (${o})
+     SELECT ${m}
+     FROM "${e}"."${n}"`)).rowCount??0}async function ze(c,e,t){let n=await c.query(`SELECT DISTINCT
       tc.table_name,
       ccu.table_name as foreign_table_name
      FROM information_schema.table_constraints tc
@@ -3798,1068 +149,6 @@ async function getTablesInDependencyOrder(pool, schemaName, tables) {
        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 seedTenants(tenantIds, seedFn, options = {}) {
-    return this.seeder.seedTenants(tenantIds, seedFn, options);
-  }
-  /**
-   * Load migration files from the migrations folder
-   */
-  async loadMigrations() {
-    const files = await readdir(this.migratorConfig.migrationsFolder);
-    const migrations = [];
-    for (const file of files) {
-      if (!file.endsWith(".sql")) continue;
-      const filePath = join(this.migratorConfig.migrationsFolder, file);
-      const content = await readFile(filePath, "utf-8");
-      const match = file.match(/^(\d+)_/);
-      const timestamp = match?.[1] ? parseInt(match[1], 10) : 0;
-      const hash = createHash("sha256").update(content).digest("hex");
-      migrations.push({
-        name: basename(file, ".sql"),
-        path: filePath,
-        sql: content,
-        timestamp,
-        hash
-      });
-    }
-    return migrations.sort((a, b) => a.timestamp - b.timestamp);
-  }
-  /**
-   * 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";
-    if (configuredFormat !== "auto") {
-      return getFormatConfig(configuredFormat, this.migrationsTable);
-    }
-    const detected = await detectTableFormat(pool, schemaName, this.migrationsTable);
-    if (detected) {
-      return detected;
-    }
-    const defaultFormat = this.migratorConfig.defaultFormat ?? "name";
-    return getFormatConfig(defaultFormat, this.migrationsTable);
-  }
-  // ============================================================================
-  // Schema Drift Detection Methods (delegated to DriftDetector)
-  // ============================================================================
-  /**
-   * 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}`);
-   *         }
-   *       }
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  async getSchemaDrift(options = {}) {
-    return this.driftDetector.detectDrift(options);
-  }
-  /**
-   * Get schema drift for a specific tenant compared to a reference
-   */
-  async getTenantSchemaDrift(tenantId, referenceTenantId, options = {}) {
-    return this.driftDetector.compareTenant(tenantId, referenceTenantId, options);
-  }
-  /**
-   * Introspect the schema of a tenant
-   */
-  async introspectTenantSchema(tenantId, options = {}) {
-    return this.driftDetector.introspectSchema(tenantId, options);
-  }
-};
-function createMigrator(tenantConfig, migratorConfig) {
-  return new Migrator(tenantConfig, migratorConfig);
-}
-var CrossSchemaQueryBuilder = class {
-  constructor(context) {
-    this.context = context;
-  }
-  fromTable = null;
-  joins = [];
-  selectFields = {};
-  whereCondition = null;
-  orderByFields = [];
-  limitValue = null;
-  offsetValue = null;
-  /**
-   * Set the main table to query from
-   */
-  from(source, table) {
-    const schemaName = this.getSchemaName(source);
-    this.fromTable = { table, source, schemaName };
-    return this;
-  }
-  /**
-   * Add an inner join
-   */
-  innerJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "inner");
-  }
-  /**
-   * Add a left join
-   */
-  leftJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "left");
-  }
-  /**
-   * Add a right join
-   */
-  rightJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "right");
-  }
-  /**
-   * Add a full outer join
-   */
-  fullJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "full");
-  }
-  /**
-   * Select specific fields
-   */
-  select(fields) {
-    this.selectFields = fields;
-    return this;
-  }
-  /**
-   * Add a where condition
-   */
-  where(condition) {
-    this.whereCondition = condition;
-    return this;
-  }
-  /**
-   * Add order by
-   */
-  orderBy(...fields) {
-    this.orderByFields = fields;
-    return this;
-  }
-  /**
-   * Set limit
-   */
-  limit(value) {
-    this.limitValue = value;
-    return this;
-  }
-  /**
-   * Set offset
-   */
-  offset(value) {
-    this.offsetValue = value;
-    return this;
-  }
-  /**
-   * Execute the query and return typed results
-   */
-  async execute() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");
-    }
-    const sqlQuery = this.buildSql();
-    const result = await this.context.tenantDb.execute(sqlQuery);
-    return result.rows;
-  }
-  /**
-   * Build the SQL query
-   */
-  buildSql() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified");
-    }
-    const parts = [];
-    const selectParts = Object.entries(this.selectFields).map(([alias, column]) => {
-      const columnName = column.name;
-      return sql`${sql.raw(`"${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-    });
-    if (selectParts.length === 0) {
-      parts.push(sql`SELECT *`);
-    } else {
-      parts.push(sql`SELECT ${sql.join(selectParts, sql`, `)}`);
-    }
-    const fromTableRef = this.getFullTableName(this.fromTable.schemaName, this.fromTable.table);
-    parts.push(sql` FROM ${sql.raw(fromTableRef)}`);
-    for (const join2 of this.joins) {
-      const joinTableRef = this.getFullTableName(join2.schemaName, join2.table);
-      const joinType = this.getJoinKeyword(join2.type);
-      parts.push(sql` ${sql.raw(joinType)} ${sql.raw(joinTableRef)} ON ${join2.condition}`);
-    }
-    if (this.whereCondition) {
-      parts.push(sql` WHERE ${this.whereCondition}`);
-    }
-    if (this.orderByFields.length > 0) {
-      parts.push(sql` ORDER BY ${sql.join(this.orderByFields, sql`, `)}`);
-    }
-    if (this.limitValue !== null) {
-      parts.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`);
-    }
-    if (this.offsetValue !== null) {
-      parts.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`);
-    }
-    return sql.join(parts, sql``);
-  }
-  /**
-   * Add a join to the query
-   */
-  addJoin(source, table, condition, type) {
-    const schemaName = this.getSchemaName(source);
-    this.joins.push({ table, source, schemaName, condition, type });
-    return this;
-  }
-  /**
-   * Get schema name for a source
-   */
-  getSchemaName(source) {
-    if (source === "tenant") {
-      return this.context.tenantSchema ?? "tenant";
-    }
-    return this.context.sharedSchema ?? "public";
-  }
-  /**
-   * Get fully qualified table name
-   */
-  getFullTableName(schemaName, table) {
-    const tableName = getTableName(table);
-    return `"${schemaName}"."${tableName}"`;
-  }
-  /**
-   * Get SQL keyword for join type
-   */
-  getJoinKeyword(type) {
-    switch (type) {
-      case "inner":
-        return "INNER JOIN";
-      case "left":
-        return "LEFT JOIN";
-      case "right":
-        return "RIGHT JOIN";
-      case "full":
-        return "FULL OUTER JOIN";
-    }
-  }
-};
-function createCrossSchemaQuery(context) {
-  return new CrossSchemaQueryBuilder(context);
-}
-async function withSharedLookup(config) {
-  const {
-    tenantDb,
-    tenantTable,
-    sharedTable,
-    foreignKey,
-    sharedKey = "id",
-    sharedFields,
-    where: whereCondition
-  } = config;
-  const tenantTableName = getTableName(tenantTable);
-  const sharedTableName = getTableName(sharedTable);
-  const sharedFieldList = sharedFields.map((field) => `s."${String(field)}"`).join(", ");
-  const queryParts = [
-    `SELECT t.*, ${sharedFieldList}`,
-    `FROM "${tenantTableName}" t`,
-    `LEFT JOIN "public"."${sharedTableName}" s ON t."${String(foreignKey)}" = s."${String(sharedKey)}"`
-  ];
-  if (whereCondition) {
-    queryParts.push("WHERE");
-  }
-  const sqlQuery = sql.raw(queryParts.join(" "));
-  const result = await tenantDb.execute(sqlQuery);
-  return result.rows;
-}
-async function crossSchemaRaw(db, options) {
-  const { tenantSchema, sharedSchema, sql: rawSql } = options;
-  const processedSql = rawSql.replace(/\$tenant\./g, `"${tenantSchema}".`).replace(/\$shared\./g, `"${sharedSchema}".`);
-  const query = sql.raw(processedSql);
-  const result = await db.execute(query);
-  return result.rows;
-}
-function buildCrossSchemaSelect(fields, tenantSchema, _sharedSchema) {
-  const columns = Object.entries(fields).map(([alias, column]) => {
-    const columnName = column.name;
-    return `"${columnName}" as "${alias}"`;
-  });
-  const getSchema = () => {
-    return tenantSchema;
-  };
-  return { columns, getSchema };
-}
-function extractTablesFromSchema(schema) {
-  const tables = /* @__PURE__ */ new Set();
-  for (const value of Object.values(schema)) {
-    if (value && typeof value === "object" && "_" in value) {
-      const branded = value;
-      if (branded._?.brand === "Table") {
-        tables.add(value);
-      }
-    }
-  }
-  return tables;
-}
-function isSharedTable(table, sharedTables) {
-  return sharedTables.has(table);
-}
-var WithSharedQueryBuilder = class {
-  constructor(tenantDb, sharedTables, tenantSchemaName, sharedSchemaName = "public") {
-    this.tenantDb = tenantDb;
-    this.sharedTables = sharedTables;
-    this.tenantSchemaName = tenantSchemaName;
-    this.sharedSchemaName = sharedSchemaName;
-  }
-  fromTable = null;
-  joins = [];
-  selectFields = {};
-  whereCondition = null;
-  orderByFields = [];
-  limitValue = null;
-  offsetValue = null;
-  /**
-   * Set the main table to query from
-   * Automatically detects if it's a tenant or shared table
-   */
-  from(table) {
-    const isShared = isSharedTable(table, this.sharedTables);
-    this.fromTable = {
-      table,
-      isShared,
-      schemaName: isShared ? this.sharedSchemaName : this.tenantSchemaName
-    };
-    return this;
-  }
-  /**
-   * Add a left join with automatic schema detection
-   */
-  leftJoin(table, condition) {
-    return this.addJoin(table, condition, "left");
-  }
-  /**
-   * Add an inner join with automatic schema detection
-   */
-  innerJoin(table, condition) {
-    return this.addJoin(table, condition, "inner");
-  }
-  /**
-   * Add a right join with automatic schema detection
-   */
-  rightJoin(table, condition) {
-    return this.addJoin(table, condition, "right");
-  }
-  /**
-   * Add a full outer join with automatic schema detection
-   */
-  fullJoin(table, condition) {
-    return this.addJoin(table, condition, "full");
-  }
-  /**
-   * Select specific fields
-   */
-  select(fields) {
-    this.selectFields = fields;
-    return this;
-  }
-  /**
-   * Add a WHERE condition
-   */
-  where(condition) {
-    this.whereCondition = condition;
-    return this;
-  }
-  /**
-   * Add ORDER BY
-   */
-  orderBy(...fields) {
-    this.orderByFields = fields;
-    return this;
-  }
-  /**
-   * Set LIMIT
-   */
-  limit(value) {
-    this.limitValue = value;
-    return this;
-  }
-  /**
-   * Set OFFSET
-   */
-  offset(value) {
-    this.offsetValue = value;
-    return this;
-  }
-  /**
-   * Execute the query and return typed results
-   */
-  async execute() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");
-    }
-    const sqlQuery = this.buildSql();
-    const result = await this.tenantDb.execute(sqlQuery);
-    return result.rows;
-  }
-  /**
-   * Add a join to the query
-   */
-  addJoin(table, condition, type) {
-    const isShared = isSharedTable(table, this.sharedTables);
-    this.joins.push({
-      table,
-      isShared,
-      schemaName: isShared ? this.sharedSchemaName : this.tenantSchemaName,
-      condition,
-      type
-    });
-    return this;
-  }
-  /**
-   * Build the SQL query
-   */
-  buildSql() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified");
-    }
-    const parts = [];
-    const selectParts = Object.entries(this.selectFields).map(([alias, column]) => {
-      const columnName = column.name;
-      const tableName = this.getTableAliasForColumn(column);
-      if (tableName) {
-        return sql`${sql.raw(`"${tableName}"."${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-      }
-      return sql`${sql.raw(`"${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-    });
-    if (selectParts.length === 0) {
-      parts.push(sql`SELECT *`);
-    } else {
-      parts.push(sql`SELECT ${sql.join(selectParts, sql`, `)}`);
-    }
-    const fromTableName = getTableName(this.fromTable.table);
-    const fromTableRef = `"${this.fromTable.schemaName}"."${fromTableName}"`;
-    parts.push(sql` FROM ${sql.raw(fromTableRef)} "${sql.raw(fromTableName)}"`);
-    for (const join2 of this.joins) {
-      const joinTableName = getTableName(join2.table);
-      const joinTableRef = `"${join2.schemaName}"."${joinTableName}"`;
-      const joinKeyword = this.getJoinKeyword(join2.type);
-      parts.push(
-        sql` ${sql.raw(joinKeyword)} ${sql.raw(joinTableRef)} "${sql.raw(joinTableName)}" ON ${join2.condition}`
-      );
-    }
-    if (this.whereCondition) {
-      parts.push(sql` WHERE ${this.whereCondition}`);
-    }
-    if (this.orderByFields.length > 0) {
-      parts.push(sql` ORDER BY ${sql.join(this.orderByFields, sql`, `)}`);
-    }
-    if (this.limitValue !== null) {
-      parts.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`);
-    }
-    if (this.offsetValue !== null) {
-      parts.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`);
-    }
-    return sql.join(parts, sql``);
-  }
-  /**
-   * Get table alias for a column (used in SELECT)
-   */
-  getTableAliasForColumn(column) {
-    const columnTable = column.table;
-    if (columnTable) {
-      return getTableName(columnTable);
-    }
-    return null;
-  }
-  /**
-   * Get SQL keyword for join type
-   */
-  getJoinKeyword(type) {
-    switch (type) {
-      case "inner":
-        return "INNER JOIN";
-      case "left":
-        return "LEFT JOIN";
-      case "right":
-        return "RIGHT JOIN";
-      case "full":
-        return "FULL OUTER JOIN";
-    }
-  }
-};
-function withShared(tenantDb, _sharedDb, schemas, options) {
-  const sharedTables = extractTablesFromSchema(schemas.shared);
-  return new WithSharedQueryBuilder(
-    tenantDb,
-    sharedTables,
-    options?.tenantSchema ?? "tenant",
-    options?.sharedSchema ?? "public"
-  );
-}
-
-// 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
+       AND tc.table_name != ccu.table_name`,[e]),a=new Map,r=new Set(t);for(let l of t)a.set(l,new Set);for(let l of n.rows)r.has(l.table_name)&&r.has(l.foreign_table_name)&&a.get(l.table_name).add(l.foreign_table_name);let s=[],i=new Map,o=[];for(let l of t)i.set(l,0);for(let[l,u]of a)for(let h of u)i.set(h,(i.get(h)??0)+1);for(let[l,u]of i)u===0&&o.push(l);for(;o.length>0;){let l=o.shift();s.push(l);for(let[u,h]of a)if(h.has(l)){h.delete(l);let d=(i.get(u)??0)-1;i.set(u,d),d===0&&o.push(u);}}let m=t.filter(l=>!s.includes(l));return [...s,...m]}async function ce(c,e,t,n,a,r){let s=0,i=await ze(c,e,n);await c.query("SET session_replication_role = replica");try{for(let o=0;o<i.length;o++){let m=i[o];r?.("copying_data",{table:m,progress:o+1,total:i.length});let l=await je(c,e,t,m,a);s+=l;}}finally{await c.query("SET session_replication_role = DEFAULT");}return s}var Be="__drizzle_migrations",H=class{constructor(e,t){this.deps=t;this.migrationsTable=e.migrationsTable??Be;}migrationsTable;async cloneTenant(e,t,n={}){let a=Date.now(),{includeData:r=false,anonymize:s,excludeTables:i=[],onProgress:o}=n,m=this.deps.schemaNameTemplate(e),l=this.deps.schemaNameTemplate(t),u=[this.migrationsTable,...i],h=null,d=null;try{if(o?.("starting"),!await this.deps.schemaExists(e))return this.createErrorResult(e,t,l,`Source tenant "${e}" does not exist`,a);if(await this.deps.schemaExists(t))return this.createErrorResult(e,t,l,`Target tenant "${t}" already exists`,a);o?.("introspecting"),h=await this.deps.createPool(m);let y=await ie(h,m,u);if(y.length===0)return o?.("creating_schema"),await this.deps.createSchema(t),o?.("completed"),{sourceTenant:e,targetTenant:t,targetSchema:l,success:!0,tables:[],durationMs:Date.now()-a};let b=await Promise.all(y.map(M=>oe(h,m,l,M)));await h.end(),h=null,o?.("creating_schema"),await this.deps.createSchema(t),d=await this.deps.createRootPool(),o?.("creating_tables");for(let M of b)await d.query(`SET search_path TO "${l}"; ${M.createDdl}`);o?.("creating_constraints");for(let M of b)for(let D of M.constraintDdls.filter(C=>!C.includes("FOREIGN KEY")))try{await d.query(`SET search_path TO "${l}"; ${D}`);}catch{}o?.("creating_indexes");for(let M of b)for(let D of M.indexDdls)try{await d.query(D);}catch{}let S=0;r&&(o?.("copying_data"),S=await ce(d,m,l,y,s?.enabled?s.rules:void 0,o));for(let M of b)for(let D of M.constraintDdls.filter(C=>C.includes("FOREIGN KEY")))try{await d.query(D);}catch{}o?.("completed");let N={sourceTenant:e,targetTenant:t,targetSchema:l,success:!0,tables:y,durationMs:Date.now()-a};return r&&(N.rowsCopied=S),N}catch(g){return n.onError?.(g),o?.("failed"),this.createErrorResult(e,t,l,g.message,a)}finally{h&&await h.end().catch(()=>{}),d&&await d.end().catch(()=>{});}}createErrorResult(e,t,n,a,r){return {sourceTenant:e,targetTenant:t,targetSchema:n,success:false,error:a,tables:[],durationMs:Date.now()-r}}};var We="public",q=class{constructor(e,t){this.config=e;this.deps=t;this.schemaName=e.schemaName??We;}schemaName;async migrate(e={}){let t=Date.now(),n=[],a=await this.deps.createPool();try{e.onProgress?.("starting"),await this.config.hooks?.beforeMigration?.();let r=await this.deps.getOrDetectFormat(a,this.schemaName);await this.deps.ensureMigrationsTable(a,this.schemaName,r);let s=await this.deps.loadMigrations(),i=await this.getAppliedMigrations(a,r),o=new Set(i.map(l=>l.identifier)),m=s.filter(l=>!this.isMigrationApplied(l,o,r));if(e.dryRun)return {schemaName:this.schemaName,success:!0,appliedMigrations:m.map(l=>l.name),durationMs:Date.now()-t,format:r.format};for(let l of m){let u=Date.now();e.onProgress?.("migrating",l.name),await this.applyMigration(a,l,r),await this.config.hooks?.afterMigration?.(l.name,Date.now()-u),n.push(l.name);}return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:n,durationMs:Date.now()-t,format:r.format}}catch(r){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:n,error:r.message,durationMs:Date.now()-t}}finally{await a.end();}}async markAsApplied(e={}){let t=Date.now(),n=[],a=await this.deps.createPool();try{e.onProgress?.("starting");let r=await this.deps.getOrDetectFormat(a,this.schemaName);await this.deps.ensureMigrationsTable(a,this.schemaName,r);let s=await this.deps.loadMigrations(),i=await this.getAppliedMigrations(a,r),o=new Set(i.map(l=>l.identifier)),m=s.filter(l=>!this.isMigrationApplied(l,o,r));for(let l of m)e.onProgress?.("migrating",l.name),await this.recordMigration(a,l,r),n.push(l.name);return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:n,durationMs:Date.now()-t,format:r.format}}catch(r){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:n,error:r.message,durationMs:Date.now()-t}}finally{await a.end();}}async getStatus(){let e=await this.deps.createPool();try{let t=await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(e,this.schemaName))return {schemaName:this.schemaName,appliedCount:0,pendingCount:t.length,pendingMigrations:t.map(o=>o.name),status:t.length>0?"behind":"ok",format:null};let a=await this.deps.getOrDetectFormat(e,this.schemaName),r=await this.getAppliedMigrations(e,a),s=new Set(r.map(o=>o.identifier)),i=t.filter(o=>!this.isMigrationApplied(o,s,a));return {schemaName:this.schemaName,appliedCount:r.length,pendingCount:i.length,pendingMigrations:i.map(o=>o.name),status:i.length>0?"behind":"ok",format:a.format}}catch(t){return {schemaName:this.schemaName,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:t.message,format:null}}finally{await e.end();}}async getAppliedMigrations(e,t){let n=t.columns.identifier,a=t.columns.timestamp;return (await e.query(`SELECT id, "${n}" as identifier, "${a}" as applied_at
+       FROM "${this.schemaName}"."${t.tableName}"
+       ORDER BY id`)).rows.map(s=>{let i=t.columns.timestampType==="bigint"?new Date(Number(s.applied_at)):new Date(s.applied_at);return {identifier:s.identifier,...t.columns.identifier==="name"?{name:s.identifier}:{hash:s.identifier},appliedAt:i}})}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async applyMigration(e,t,n){let a=await e.connect();try{await a.query("BEGIN"),await a.query(t.sql);let{identifier:r,timestamp:s,timestampType:i}=n.columns,o=r==="name"?t.name:t.hash,m=i==="bigint"?Date.now():new Date;await a.query(`INSERT INTO "${this.schemaName}"."${n.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]),await a.query("COMMIT");}catch(r){throw await a.query("ROLLBACK"),r}finally{a.release();}}async recordMigration(e,t,n){let{identifier:a,timestamp:r,timestampType:s}=n.columns,i=a==="name"?t.name:t.hash,o=s==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${this.schemaName}"."${n.tableName}" ("${a}", "${r}") VALUES ($1, $2)`,[i,o]);}};var Ue="__drizzle_migrations",ge="__drizzle_shared_migrations",j=class{constructor(e,t){this.migratorConfig=t;if(this.migrationsTable=t.migrationsTable??Ue,this.schemaManager=new O(e,this.migrationsTable),this.driftDetector=new $(e,this.schemaManager,{migrationsTable:this.migrationsTable,tenantDiscovery:t.tenantDiscovery}),this.seeder=new A({tenantDiscovery:t.tenantDiscovery},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,tenantSchema:e.schemas.tenant}),this.syncManager=new F({tenantDiscovery:t.tenantDiscovery,migrationsFolder:t.migrationsFolder,migrationsTable:this.migrationsTable},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.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 L({hooks:t.hooks},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.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 I({tenantDiscovery:t.tenantDiscovery},this.migrationExecutor,this.loadMigrations.bind(this)),this.cloner=new H({migrationsTable:this.migrationsTable},{createPool:this.schemaManager.createPool.bind(this.schemaManager),createRootPool:this.schemaManager.createRootPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,schemaExists:this.schemaManager.schemaExists.bind(this.schemaManager),createSchema:this.schemaManager.createSchema.bind(this.schemaManager)}),t.sharedMigrationsFolder&&existsSync(t.sharedMigrationsFolder)){let n=t.sharedMigrationsTable??ge,a=t.sharedHooks,r={schemaName:"public",migrationsTable:n};(a?.beforeMigration||a?.afterApply)&&(r.hooks={},a.beforeMigration&&(r.hooks.beforeMigration=a.beforeMigration),a.afterApply&&(r.hooks.afterMigration=a.afterApply)),this.sharedMigrationExecutor=new q(r,{createPool:this.schemaManager.createRootPool.bind(this.schemaManager),migrationsTableExists:this.schemaManager.migrationsTableExists.bind(this.schemaManager),ensureMigrationsTable:this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),getOrDetectFormat:this.getOrDetectSharedFormat.bind(this),loadMigrations:this.loadSharedMigrations.bind(this)});}else this.sharedMigrationExecutor=null;e.schemas.shared?this.sharedSeeder=new v({schemaName:"public"},{createPool:this.schemaManager.createRootPool.bind(this.schemaManager),sharedSchema:e.schemas.shared}):this.sharedSeeder=null;}migrationsTable;schemaManager;driftDetector;seeder;syncManager;migrationExecutor;batchExecutor;cloner;sharedMigrationExecutor;sharedSeeder;async migrateAll(e={}){return this.batchExecutor.migrateAll(e)}async migrateTenant(e,t,n={}){return this.migrationExecutor.migrateTenant(e,t,n)}async migrateTenants(e,t={}){return this.batchExecutor.migrateTenants(e,t)}async getStatus(){return this.batchExecutor.getStatus()}async getTenantStatus(e,t){return this.migrationExecutor.getTenantStatus(e,t)}async createTenant(e,t={}){let{migrate:n=true}=t;await this.schemaManager.createSchema(e),n&&await this.migrateTenant(e);}async dropTenant(e,t={}){await this.schemaManager.dropSchema(e,t);}async tenantExists(e){return this.schemaManager.schemaExists(e)}async cloneTenant(e,t,n={}){return this.cloner.cloneTenant(e,t,n)}async markAsApplied(e,t={}){return this.migrationExecutor.markAsApplied(e,t)}async markAllAsApplied(e={}){return this.batchExecutor.markAllAsApplied(e)}async getSyncStatus(){return this.syncManager.getSyncStatus()}async getTenantSyncStatus(e,t){return this.syncManager.getTenantSyncStatus(e,t)}async markMissing(e){return this.syncManager.markMissing(e)}async markAllMissing(e={}){return this.syncManager.markAllMissing(e)}async cleanOrphans(e){return this.syncManager.cleanOrphans(e)}async cleanAllOrphans(e={}){return this.syncManager.cleanAllOrphans(e)}async seedTenant(e,t){return this.seeder.seedTenant(e,t)}async seedAll(e,t={}){return this.seeder.seedAll(e,t)}async seedTenants(e,t,n={}){return this.seeder.seedTenants(e,t,n)}hasSharedSeeding(){return this.sharedSeeder!==null}async seedShared(e){return this.sharedSeeder?this.sharedSeeder.seed(e):{schemaName:"public",success:false,error:"Shared schema not configured. Set schemas.shared in tenant config.",durationMs:0}}async seedAllWithShared(e,t,n={}){let a=await this.seedShared(e),r=await this.seedAll(t,n);return {shared:a,tenants:r}}async loadMigrations(){let e=await readdir(this.migratorConfig.migrationsFolder),t=[];for(let n of e){if(!n.endsWith(".sql"))continue;let a=join(this.migratorConfig.migrationsFolder,n),r=await readFile(a,"utf-8"),s=n.match(/^(\d+)_/),i=s?.[1]?parseInt(s[1],10):0,o=createHash("sha256").update(r).digest("hex");t.push({name:basename(n,".sql"),path:a,sql:r,timestamp:i,hash:o});}return t.sort((n,a)=>n.timestamp-a.timestamp)}async getOrDetectFormat(e,t){let n=this.migratorConfig.tableFormat??"auto";if(n!=="auto")return _(n,this.migrationsTable);let a=await Y(e,t,this.migrationsTable);if(a)return a;let r=this.migratorConfig.defaultFormat??"name";return _(r,this.migrationsTable)}async loadSharedMigrations(){if(!this.migratorConfig.sharedMigrationsFolder)return [];let e=await readdir(this.migratorConfig.sharedMigrationsFolder),t=[];for(let n of e){if(!n.endsWith(".sql"))continue;let a=join(this.migratorConfig.sharedMigrationsFolder,n),r=await readFile(a,"utf-8"),s=n.match(/^(\d+)_/),i=s?.[1]?parseInt(s[1],10):0,o=createHash("sha256").update(r).digest("hex");t.push({name:basename(n,".sql"),path:a,sql:r,timestamp:i,hash:o});}return t.sort((n,a)=>n.timestamp-a.timestamp)}async getOrDetectSharedFormat(e,t){let n=this.migratorConfig.sharedMigrationsTable??ge,a=this.migratorConfig.tableFormat??"auto";if(a!=="auto")return _(a,n);let r=await Y(e,t,n);if(r)return r;let s=this.migratorConfig.defaultFormat??"name";return _(s,n)}hasSharedMigrations(){return this.sharedMigrationExecutor!==null}async migrateShared(e={}){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.migrate(e):{schemaName:"public",success:false,appliedMigrations:[],error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",durationMs:0}}async getSharedStatus(){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.getStatus():{schemaName:"public",appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",format:null}}async markSharedAsApplied(e={}){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.markAsApplied(e):{schemaName:"public",success:false,appliedMigrations:[],error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",durationMs:0}}async migrateAllWithShared(e={}){let{sharedOptions:t,...n}=e,a=await this.migrateShared(t??{}),r=await this.migrateAll(n);return {shared:a,tenants:r}}async getSchemaDrift(e={}){return this.driftDetector.detectDrift(e)}async getTenantSchemaDrift(e,t,n={}){return this.driftDetector.compareTenant(e,t,n)}async introspectTenantSchema(e,t={}){return this.driftDetector.introspectSchema(e,t)}};function Qe(c,e){return new j(c,e)}var z=class{constructor(e){this.context=e;}fromTable=null;joins=[];selectFields={};whereCondition=null;orderByFields=[];limitValue=null;offsetValue=null;from(e,t){let n=this.getSchemaName(e);return this.fromTable={table:t,source:e,schemaName:n},this}innerJoin(e,t,n){return this.addJoin(e,t,n,"inner")}leftJoin(e,t,n){return this.addJoin(e,t,n,"left")}rightJoin(e,t,n){return this.addJoin(e,t,n,"right")}fullJoin(e,t,n){return this.addJoin(e,t,n,"full")}select(e){return this.selectFields=e,this}where(e){return this.whereCondition=e,this}orderBy(...e){return this.orderByFields=e,this}limit(e){return this.limitValue=e,this}offset(e){return this.offsetValue=e,this}async execute(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");let e=this.buildSql();return (await this.context.tenantDb.execute(e)).rows}buildSql(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified");let e=[],t=Object.entries(this.selectFields).map(([a,r])=>{let s=r.name;return sql`${sql.raw(`"${s}"`)} as ${sql.raw(`"${a}"`)}`});t.length===0?e.push(sql`SELECT *`):e.push(sql`SELECT ${sql.join(t,sql`, `)}`);let n=this.getFullTableName(this.fromTable.schemaName,this.fromTable.table);e.push(sql` FROM ${sql.raw(n)}`);for(let a of this.joins){let r=this.getFullTableName(a.schemaName,a.table),s=this.getJoinKeyword(a.type);e.push(sql` ${sql.raw(s)} ${sql.raw(r)} ON ${a.condition}`);}return this.whereCondition&&e.push(sql` WHERE ${this.whereCondition}`),this.orderByFields.length>0&&e.push(sql` ORDER BY ${sql.join(this.orderByFields,sql`, `)}`),this.limitValue!==null&&e.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`),this.offsetValue!==null&&e.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`),sql.join(e,sql``)}addJoin(e,t,n,a){let r=this.getSchemaName(e);return this.joins.push({table:t,source:e,schemaName:r,condition:n,type:a}),this}getSchemaName(e){return e==="tenant"?this.context.tenantSchema??"tenant":this.context.sharedSchema??"public"}getFullTableName(e,t){let n=getTableName(t);return `"${e}"."${n}"`}getJoinKeyword(e){switch(e){case "inner":return "INNER JOIN";case "left":return "LEFT JOIN";case "right":return "RIGHT JOIN";case "full":return "FULL OUTER JOIN"}}};function Ye(c){return new z(c)}async function Ve(c){let{tenantDb:e,tenantTable:t,sharedTable:n,foreignKey:a,sharedKey:r="id",sharedFields:s,where:i}=c,o=getTableName(t),m=getTableName(n),u=[`SELECT t.*, ${s.map(g=>`s."${String(g)}"`).join(", ")}`,`FROM "${o}" t`,`LEFT JOIN "public"."${m}" s ON t."${String(a)}" = s."${String(r)}"`];i&&u.push("WHERE");let h=sql.raw(u.join(" "));return (await e.execute(h)).rows}async function Ke(c,e){let{tenantSchema:t,sharedSchema:n,sql:a}=e,r=a.replace(/\$tenant\./g,`"${t}".`).replace(/\$shared\./g,`"${n}".`),s=sql.raw(r);return (await c.execute(s)).rows}function Ge(c,e,t){return {columns:Object.entries(c).map(([r,s])=>`"${s.name}" as "${r}"`),getSchema:()=>e}}function Xe(c){let e=new Set;for(let t of Object.values(c))t&&typeof t=="object"&&"_"in t&&t._?.brand==="Table"&&e.add(t);return e}function pe(c,e){return e.has(c)}var B=class{constructor(e,t,n,a="public"){this.tenantDb=e;this.sharedTables=t;this.tenantSchemaName=n;this.sharedSchemaName=a;}fromTable=null;joins=[];selectFields={};whereCondition=null;orderByFields=[];limitValue=null;offsetValue=null;from(e){let t=pe(e,this.sharedTables);return this.fromTable={table:e,isShared:t,schemaName:t?this.sharedSchemaName:this.tenantSchemaName},this}leftJoin(e,t){return this.addJoin(e,t,"left")}innerJoin(e,t){return this.addJoin(e,t,"inner")}rightJoin(e,t){return this.addJoin(e,t,"right")}fullJoin(e,t){return this.addJoin(e,t,"full")}select(e){return this.selectFields=e,this}where(e){return this.whereCondition=e,this}orderBy(...e){return this.orderByFields=e,this}limit(e){return this.limitValue=e,this}offset(e){return this.offsetValue=e,this}async execute(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");let e=this.buildSql();return (await this.tenantDb.execute(e)).rows}addJoin(e,t,n){let a=pe(e,this.sharedTables);return this.joins.push({table:e,isShared:a,schemaName:a?this.sharedSchemaName:this.tenantSchemaName,condition:t,type:n}),this}buildSql(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified");let e=[],t=Object.entries(this.selectFields).map(([r,s])=>{let i=s.name,o=this.getTableAliasForColumn(s);return o?sql`${sql.raw(`"${o}"."${i}"`)} as ${sql.raw(`"${r}"`)}`:sql`${sql.raw(`"${i}"`)} as ${sql.raw(`"${r}"`)}`});t.length===0?e.push(sql`SELECT *`):e.push(sql`SELECT ${sql.join(t,sql`, `)}`);let n=getTableName(this.fromTable.table),a=`"${this.fromTable.schemaName}"."${n}"`;e.push(sql` FROM ${sql.raw(a)} "${sql.raw(n)}"`);for(let r of this.joins){let s=getTableName(r.table),i=`"${r.schemaName}"."${s}"`,o=this.getJoinKeyword(r.type);e.push(sql` ${sql.raw(o)} ${sql.raw(i)} "${sql.raw(s)}" ON ${r.condition}`);}return this.whereCondition&&e.push(sql` WHERE ${this.whereCondition}`),this.orderByFields.length>0&&e.push(sql` ORDER BY ${sql.join(this.orderByFields,sql`, `)}`),this.limitValue!==null&&e.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`),this.offsetValue!==null&&e.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`),sql.join(e,sql``)}getTableAliasForColumn(e){let t=e.table;return t?getTableName(t):null}getJoinKeyword(e){switch(e){case "inner":return "INNER JOIN";case "left":return "LEFT JOIN";case "right":return "RIGHT JOIN";case "full":return "FULL OUTER JOIN"}}};function Ze(c,e,t,n){let a=Xe(t.shared);return new B(c,a,n?.tenantSchema??"tenant",n?.sharedSchema??"public")}function fe(c){let e=c.message.toLowerCase();return !!(e.includes("econnrefused")||e.includes("econnreset")||e.includes("etimedout")||e.includes("enotfound")||e.includes("connection refused")||e.includes("connection reset")||e.includes("connection terminated")||e.includes("connection timed out")||e.includes("timeout expired")||e.includes("socket hang up")||e.includes("too many connections")||e.includes("sorry, too many clients")||e.includes("the database system is starting up")||e.includes("the database system is shutting down")||e.includes("server closed the connection unexpectedly")||e.includes("could not connect to server")||e.includes("ssl connection")||e.includes("ssl handshake"))}function ye(c,e){let t=e.initialDelayMs*Math.pow(e.backoffMultiplier,c),n=Math.min(t,e.maxDelayMs);if(e.jitter){let a=1+Math.random()*.25;return Math.floor(n*a)}return Math.floor(n)}function et(c){return new Promise(e=>setTimeout(e,c))}async function Te(c,e){let t={maxAttempts:e?.maxAttempts??T.retry.maxAttempts,initialDelayMs:e?.initialDelayMs??T.retry.initialDelayMs,maxDelayMs:e?.maxDelayMs??T.retry.maxDelayMs,backoffMultiplier:e?.backoffMultiplier??T.retry.backoffMultiplier,jitter:e?.jitter??T.retry.jitter,isRetryable:e?.isRetryable??fe,onRetry:e?.onRetry},n=Date.now(),a=null;for(let r=0;r<t.maxAttempts;r++)try{return {result:await c(),attempts:r+1,totalTimeMs:Date.now()-n}}catch(s){if(a=s,r>=t.maxAttempts-1||!t.isRetryable(a))throw a;let o=ye(r,t);t.onRetry?.(r+1,a,o),await et(o);}throw a??new Error("Retry failed with no error")}function tt(c){return e=>Te(e,c)}export{z as CrossSchemaQueryBuilder,T as DEFAULT_CONFIG,j as Migrator,B as WithSharedQueryBuilder,Ge as buildCrossSchemaSelect,ye as calculateDelay,Ye as createCrossSchemaQuery,Qe as createMigrator,tt as createRetrier,De as createTenantContext,Re as createTenantManager,Ke as crossSchemaRaw,Se as defineConfig,fe as isRetryableError,Te as withRetry,Ze as withShared,Ve as withSharedLookup};