@happyvertical/smrt-core 0.30.0

package/dist/migrations/tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.js","sources":["../../src/migrations/tracker.ts"],"sourcesContent":["/**\n * Migration Tracker\n *\n * Manages migration state, tracking which migrations have been applied,\n * and providing idempotent migration application.\n */\n\nimport { randomUUID } from 'node:crypto';\nimport { hostname } from 'node:os';\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine } from '../schema/ddl/index.js';\n// DatabaseEngine comes from the DDL layer (the json-inclusive type that\n// `detectEngine` actually returns), matching `SchemaComparer` in differ.ts.\n// The migration stack supports the JSON adapter post-R11, so the tracker's\n// engine type must include 'json' too — the narrower `migrations/types`\n// alias would reject it.\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type {\n  DriftReport,\n  MigrationDefinition,\n  MigrationResult,\n  MigrationStatus,\n  SchemaMigrationRecord,\n} from '../schema/types.js';\nimport { CREATE_SMRT_SCHEMA_MIGRATIONS_TABLE } from '../system/schema.js';\nimport { computeChecksum, verifyChecksum } from './checksum.js';\nimport type {\n  ApplyMigrationsOptions,\n  DatabaseInterface,\n  MigrationTrackerOptions,\n  RollbackOptions,\n} from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Row type for _smrt_schema_migrations table\n */\ninterface MigrationRow {\n  id: string;\n  name: string;\n  version: string;\n  checksum: string;\n  applied_checksum?: string | null;\n  applied_at: string;\n  execution_time_ms?: number | null;\n  package_name?: string | null;\n  source_file?: string | null;\n  status: string;\n  error_message?: string | null;\n  attempts: number;\n  is_reversible: number | boolean;\n  rolled_back_at?: string | null;\n  applied_by?: string | null;\n  batch: number;\n}\n\n/**\n * Default options for MigrationTracker\n */\nconst DEFAULT_OPTIONS = {\n  lockTimeout: 30000,\n  statementTimeout: 60000,\n  useConcurrentIndexes: true,\n};\n\nclass AtomicMigrationRollback extends Error {\n  constructor(\n    public readonly results: MigrationResult[],\n    public readonly failed: MigrationResult,\n  ) {\n    super(`Atomic migration batch failed at ${failed.name}`);\n  }\n}\n\nconst CONCURRENT_INDEX_STATEMENT_RE =\n  /(?:(?:CREATE\\s+(?:UNIQUE\\s+)?INDEX|DROP\\s+INDEX)\\s+CONCURRENTLY|REINDEX(?:\\s*\\([^)]*\\))?\\s+(?:INDEX|TABLE|SCHEMA|DATABASE|SYSTEM)\\s+CONCURRENTLY)/i;\n\nfunction findConcurrentIndexStatement(\n  definitions: MigrationDefinition[],\n): { migrationName: string; statement: string } | null {\n  for (const definition of definitions) {\n    const statement = definition.up.find((sql) =>\n      CONCURRENT_INDEX_STATEMENT_RE.test(sql),\n    );\n\n    if (statement) {\n      return {\n        migrationName: definition.id,\n        statement,\n      };\n    }\n  }\n\n  return null;\n}\n\n/**\n * MigrationTracker class\n *\n * Provides migration tracking and state management:\n * - Initializes the _smrt_schema_migrations tracking table\n * - Tracks applied migrations with checksums\n * - Provides idempotent migration application\n * - Supports rollback via DOWN scripts\n * - Handles PostgreSQL-specific concerns (CONCURRENTLY, lock timeout)\n */\nexport class MigrationTracker {\n  private db: DatabaseInterface;\n  private options: Required<Omit<MigrationTrackerOptions, 'db' | 'engineHint'>>;\n  private engineHint?: string;\n  private dbEngine: DatabaseEngine;\n  /**\n   * Memoized initialization promise. Storing the in-flight promise (rather\n   * than a `boolean` flag set after the DDL completes) makes `initialize()`\n   * safe under concurrency: multiple parallel callers all `await` the same\n   * promise instead of independently re-running the DDL. On error the slot\n   * is cleared so the next caller retries — a transient failure doesn't\n   * permanently poison the instance.\n   */\n  private initializePromise: Promise<void> | null = null;\n  private currentBatch: number | null = null;\n\n  constructor(options: MigrationTrackerOptions) {\n    this.db = options.db;\n    this.options = {\n      lockTimeout: options.lockTimeout ?? DEFAULT_OPTIONS.lockTimeout,\n      statementTimeout:\n        options.statementTimeout ?? DEFAULT_OPTIONS.statementTimeout,\n      useConcurrentIndexes:\n        options.useConcurrentIndexes ?? DEFAULT_OPTIONS.useConcurrentIndexes,\n    };\n    this.engineHint = options.engineHint;\n    this.dbEngine = this.detectDbEngine();\n  }\n\n  /**\n   * Detect the database engine. Honors an explicit `engineHint` (passed via\n   * `MigrationTrackerOptions`) before falling back to URL parsing — this is\n   * the same `detectEngine` contract used by `SchemaComparer` and the rest\n   * of the migration stack, so the tracker stays consistent with the DDL\n   * the orchestrator generated.\n   */\n  private detectDbEngine(): DatabaseEngine {\n    const dbWithConfig = this.db as DatabaseInterface & {\n      config?: { url?: string };\n    };\n    const url = this.db.url || dbWithConfig.config?.url || '';\n    return detectEngine(url, this.engineHint);\n  }\n\n  /**\n   * Get the current database engine\n   */\n  getEngine(): DatabaseEngine {\n    return this.dbEngine;\n  }\n\n  /**\n   * Initialize the migrations tracking table\n   */\n  async initialize(): Promise<void> {\n    if (!this.initializePromise) {\n      this.initializePromise = this.runInitializeDdl().catch((error) => {\n        this.initializePromise = null;\n        throw error;\n      });\n    }\n    return this.initializePromise;\n  }\n\n  private async runInitializeDdl(): Promise<void> {\n    // Parse and execute each statement in the DDL\n    const statements = CREATE_SMRT_SCHEMA_MIGRATIONS_TABLE.split(';')\n      .map((s) => s.trim())\n      .filter((s) => s.length > 0);\n\n    for (const statement of statements) {\n      await this.db.query(statement);\n    }\n  }\n\n  /**\n   * Get all applied migrations ordered by applied_at\n   */\n  async getAppliedMigrations(): Promise<SchemaMigrationRecord[]> {\n    await this.initialize();\n\n    const result = await this.db.query(\n      `SELECT * FROM _smrt_schema_migrations WHERE status = 'completed' ORDER BY applied_at ASC`,\n    );\n\n    return (result.rows as MigrationRow[]).map((row) => ({\n      ...row,\n      applied_at: new Date(row.applied_at),\n      rolled_back_at: row.rolled_back_at ? new Date(row.rolled_back_at) : null,\n      is_reversible: Boolean(row.is_reversible),\n    })) as SchemaMigrationRecord[];\n  }\n\n  /**\n   * Get pending migrations (defined but not applied)\n   */\n  async getPendingMigrations(\n    definitions: MigrationDefinition[],\n  ): Promise<MigrationDefinition[]> {\n    const applied = await this.getAppliedMigrations();\n    const appliedNames = new Set(applied.map((m) => m.name));\n    return definitions.filter((d) => !appliedNames.has(d.id));\n  }\n\n  /**\n   * Check if a migration has been applied\n   */\n  async isApplied(migrationId: string): Promise<boolean> {\n    await this.initialize();\n\n    const result = await this.db.query(\n      `SELECT 1 FROM _smrt_schema_migrations WHERE name = ? AND status = 'completed' LIMIT 1`,\n      migrationId,\n    );\n\n    return result.rows.length > 0;\n  }\n\n  /**\n   * Get a single migration record by name\n   */\n  async getMigration(name: string): Promise<SchemaMigrationRecord | null> {\n    await this.initialize();\n\n    const result = await this.db.query(\n      `SELECT * FROM _smrt_schema_migrations WHERE name = ? LIMIT 1`,\n      name,\n    );\n\n    if (result.rows.length === 0) return null;\n\n    const row = result.rows[0] as MigrationRow;\n    return {\n      ...row,\n      applied_at: new Date(row.applied_at),\n      rolled_back_at: row.rolled_back_at ? new Date(row.rolled_back_at) : null,\n      is_reversible: Boolean(row.is_reversible),\n    } as SchemaMigrationRecord;\n  }\n\n  /**\n   * Get the next batch number\n   */\n  async getNextBatch(): Promise<number> {\n    await this.initialize();\n\n    const result = await this.db.query(\n      `SELECT MAX(batch) as max_batch FROM _smrt_schema_migrations`,\n    );\n\n    const row = result.rows[0] as { max_batch: number | null } | undefined;\n    return (row?.max_batch ?? 0) + 1;\n  }\n\n  /**\n   * Detect drift between migration definitions and applied migrations\n   */\n  async detectDrift(\n    definitions: MigrationDefinition[],\n  ): Promise<DriftReport[]> {\n    const applied = await this.getAppliedMigrations();\n    const reports: DriftReport[] = [];\n\n    const appliedMap = new Map(applied.map((m) => [m.name, m]));\n    const definitionMap = new Map(definitions.map((d) => [d.id, d]));\n\n    // Check each applied migration against definitions\n    for (const record of applied) {\n      const definition = definitionMap.get(record.name);\n\n      if (!definition) {\n        // Migration applied but definition is missing\n        reports.push({\n          migration_name: record.name,\n          expected_checksum: 'N/A',\n          actual_checksum: record.checksum,\n          drift_type: 'unknown_in_db',\n          recommendation:\n            'Migration exists in database but definition is missing. Manual cleanup may be required.',\n        });\n        continue;\n      }\n\n      // Check checksum\n      const currentChecksum = computeChecksum(definition.up);\n      const verification = verifyChecksum(\n        currentChecksum,\n        record.checksum,\n        record.applied_checksum,\n      );\n\n      if (!verification.valid) {\n        const driftType = verification.drift ?? 'db_modified';\n        reports.push({\n          migration_name: record.name,\n          expected_checksum: record.checksum,\n          actual_checksum: currentChecksum,\n          drift_type: driftType,\n          recommendation:\n            driftType === 'file_modified'\n              ? 'Migration file was modified after application. Create a new migration instead.'\n              : 'Database schema was modified outside of migrations. Review and reconcile manually.',\n        });\n      }\n    }\n\n    return reports;\n  }\n\n  /**\n   * Apply a single migration\n   */\n  async apply(\n    definition: MigrationDefinition,\n    options: ApplyMigrationsOptions = {},\n  ): Promise<MigrationResult> {\n    await this.initialize();\n    const startTime = Date.now();\n    const checksum = computeChecksum(definition.up);\n\n    // Check if migration record already exists\n    const existing = await this.getMigration(definition.id);\n\n    if (existing) {\n      // Handle based on existing status\n      switch (existing.status) {\n        case 'completed':\n          if (!options.force && existing.checksum !== checksum) {\n            return {\n              success: false,\n              applied: false,\n              skipped: false,\n              name: definition.id,\n              checksum,\n              execution_time_ms: 0,\n              error: `Migration ${definition.id} checksum mismatch. Was already applied with different checksum. Use --force to override.`,\n            };\n          }\n\n          if (!options.force && !options.reconcile) {\n            // Already applied, skip\n            return {\n              success: true,\n              applied: false,\n              skipped: true,\n              name: definition.id,\n              checksum,\n              execution_time_ms: 0,\n            };\n          }\n          break;\n\n        case 'failed':\n          if (!options.force && !options.reconcile) {\n            return {\n              success: false,\n              applied: false,\n              skipped: false,\n              name: definition.id,\n              checksum,\n              execution_time_ms: 0,\n              error: `Migration ${definition.id} previously failed: ${existing.error_message || 'Unknown error'}. Use --force to retry.`,\n            };\n          }\n          // Will retry below\n          break;\n\n        case 'running':\n          if (!options.force) {\n            return {\n              success: false,\n              applied: false,\n              skipped: false,\n              name: definition.id,\n              checksum,\n              execution_time_ms: 0,\n              error: `Migration ${definition.id} is currently running or was interrupted. Use --force to retry if the previous run crashed.`,\n            };\n          }\n          // Will retry below\n          break;\n\n        case 'rolled_back':\n          // Rolled back migrations can be re-applied without --force\n          break;\n      }\n    }\n\n    if (options.dryRun) {\n      return {\n        success: true,\n        applied: false,\n        skipped: false,\n        name: definition.id,\n        checksum,\n        execution_time_ms: Date.now() - startTime,\n      };\n    }\n\n    // Get batch number\n    if (this.currentBatch === null) {\n      this.currentBatch = await this.getNextBatch();\n    }\n\n    // Determine if we're updating an existing record or inserting new\n    const id = existing?.id || randomUUID();\n    const attempts = (existing?.attempts || 0) + 1;\n\n    if (existing) {\n      // Update existing record to 'running'\n      await this.db.query(\n        `UPDATE _smrt_schema_migrations\n         SET status = 'running', checksum = ?, attempts = ?, error_message = NULL, batch = ?, applied_by = ?, applied_at = CURRENT_TIMESTAMP\n         WHERE id = ?`,\n        checksum,\n        attempts,\n        this.currentBatch,\n        hostname(),\n        id,\n      );\n    } else {\n      // Insert new record\n      await this.db.query(\n        `INSERT INTO _smrt_schema_migrations\n         (id, name, version, checksum, status, attempts, is_reversible, package_name, source_file, applied_by, batch)\n         VALUES (?, ?, ?, ?, 'running', 1, ?, ?, ?, ?, ?)`,\n        id,\n        definition.id,\n        definition.version,\n        checksum,\n        (definition.is_reversible ?? definition.down.length > 0) ? 1 : 0,\n        definition.package_name ?? null,\n        definition.source_file ?? null,\n        hostname(),\n        this.currentBatch,\n      );\n    }\n\n    try {\n      // Execute the migration\n      await this.executeStatements(definition.up, options);\n\n      // Mark as completed\n      const executionTime = Date.now() - startTime;\n      await this.db.query(\n        `UPDATE _smrt_schema_migrations\n         SET status = 'completed', execution_time_ms = ?, applied_checksum = ?, applied_at = CURRENT_TIMESTAMP\n         WHERE id = ?`,\n        executionTime,\n        checksum,\n        id,\n      );\n\n      return {\n        success: true,\n        applied: true,\n        skipped: false,\n        name: definition.id,\n        checksum,\n        execution_time_ms: executionTime,\n      };\n    } catch (error) {\n      const migrationError =\n        error instanceof Error ? error : new Error(String(error));\n\n      // Mark as failed. In an outer atomic Postgres transaction, a DDL error\n      // aborts the transaction and this status write must be skipped so the\n      // caller can roll back the whole batch while preserving the root error.\n      try {\n        await this.db.query(\n          `UPDATE _smrt_schema_migrations\n           SET status = 'failed', error_message = ?\n           WHERE id = ?`,\n          migrationError.message,\n          id,\n        );\n      } catch (persistError) {\n        // Preserve the migration failure; status persistence is secondary and\n        // may be impossible until the surrounding transaction rolls back.\n        const persistMessage =\n          persistError instanceof Error\n            ? persistError.message\n            : String(persistError);\n        logger.error(\n          `Failed to persist failed status for migration ${definition.id}: ${persistMessage}`,\n        );\n      }\n\n      return {\n        success: false,\n        applied: false,\n        skipped: false,\n        name: definition.id,\n        checksum,\n        execution_time_ms: Date.now() - startTime,\n        error: migrationError,\n      };\n    }\n  }\n\n  /**\n   * Apply multiple migrations in order\n   */\n  async applyAll(\n    definitions: MigrationDefinition[],\n    options: ApplyMigrationsOptions = {},\n  ): Promise<MigrationResult[]> {\n    if (options.atomic && !options.dryRun) {\n      if (!this.db.transaction) {\n        throw new Error(\n          'Atomic migration batches require a database adapter with transaction support.',\n        );\n      }\n\n      if (this.dbEngine === 'postgres') {\n        const concurrentStatement = findConcurrentIndexStatement(definitions);\n        if (concurrentStatement) {\n          throw new Error(\n            `Atomic migration batch cannot include CONCURRENTLY index DDL in ${concurrentStatement.migrationName}; PostgreSQL forbids CONCURRENTLY inside a transaction.`,\n          );\n        }\n      }\n\n      try {\n        return await this.db.transaction(async (tx) => {\n          const txDb = {\n            ...tx,\n            transaction: async <T>(\n              callback: (transactionDb: DatabaseInterface) => Promise<T>,\n            ) => callback(tx as DatabaseInterface),\n          } as DatabaseInterface;\n          const txTracker = new MigrationTracker({\n            db: txDb,\n            lockTimeout: this.options.lockTimeout,\n            statementTimeout: this.options.statementTimeout,\n            useConcurrentIndexes: false,\n          });\n          const results = await txTracker.applyAll(definitions, {\n            ...options,\n            atomic: false,\n            continueOnError: false,\n            postgresSafe: false,\n          });\n          const failed = results.find((result) => !result.success);\n\n          if (failed) {\n            throw new AtomicMigrationRollback(results, failed);\n          }\n\n          return results;\n        });\n      } catch (error) {\n        if (error instanceof AtomicMigrationRollback) {\n          return error.results.map((result) => {\n            if (!result.success || !result.applied) {\n              return result;\n            }\n\n            return {\n              ...result,\n              success: false,\n              applied: false,\n              skipped: false,\n              rolled_back: true,\n              error: new Error(\n                `Rolled back because migration ${error.failed.name} failed`,\n              ),\n            };\n          });\n        }\n\n        throw error;\n      }\n    }\n\n    const results: MigrationResult[] = [];\n    this.currentBatch = await this.getNextBatch();\n\n    for (const definition of definitions) {\n      const result = await this.apply(definition, options);\n      results.push(result);\n      options.onProgress?.(result);\n\n      if (!result.success && !options.continueOnError) {\n        break;\n      }\n    }\n\n    this.currentBatch = null;\n    return results;\n  }\n\n  /**\n   * Rollback a migration\n   */\n  async rollback(\n    name: string,\n    definition: MigrationDefinition,\n    options: RollbackOptions = {},\n  ): Promise<MigrationResult> {\n    await this.initialize();\n    const startTime = Date.now();\n    const checksum = computeChecksum(definition.down);\n\n    const record = await this.getMigration(name);\n    if (!record) {\n      return {\n        success: false,\n        name,\n        checksum,\n        execution_time_ms: 0,\n        error: new Error(`Migration ${name} not found in database`),\n      };\n    }\n\n    if (record.status !== 'completed') {\n      return {\n        success: false,\n        name,\n        checksum,\n        execution_time_ms: 0,\n        error: new Error(\n          `Migration ${name} is not in completed state (current: ${record.status})`,\n        ),\n      };\n    }\n\n    if (!definition.down.length) {\n      return {\n        success: false,\n        name,\n        checksum,\n        execution_time_ms: 0,\n        error: new Error(\n          `Migration ${name} is not reversible (no down statements)`,\n        ),\n      };\n    }\n\n    if (options.dryRun) {\n      return {\n        success: true,\n        name,\n        checksum,\n        execution_time_ms: Date.now() - startTime,\n        rolled_back: true,\n      };\n    }\n\n    try {\n      // Execute DOWN statements\n      await this.executeStatements(definition.down, {});\n\n      // Mark as rolled back\n      await this.db.query(\n        `UPDATE _smrt_schema_migrations\n         SET status = 'rolled_back', rolled_back_at = CURRENT_TIMESTAMP\n         WHERE name = ?`,\n        name,\n      );\n\n      return {\n        success: true,\n        name,\n        checksum,\n        execution_time_ms: Date.now() - startTime,\n        rolled_back: true,\n      };\n    } catch (error) {\n      return {\n        success: false,\n        name,\n        checksum,\n        execution_time_ms: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n        rolled_back: false,\n      };\n    }\n  }\n\n  /**\n   * Get migration history with optional filtering\n   */\n  async getHistory(\n    options: { limit?: number; since?: Date; status?: MigrationStatus } = {},\n  ): Promise<SchemaMigrationRecord[]> {\n    await this.initialize();\n\n    let sql = `SELECT * FROM _smrt_schema_migrations WHERE 1=1`;\n    const params: unknown[] = [];\n\n    if (options.status) {\n      sql += ` AND status = ?`;\n      params.push(options.status);\n    }\n\n    if (options.since) {\n      sql += ` AND applied_at >= ?`;\n      params.push(options.since.toISOString());\n    }\n\n    sql += ` ORDER BY applied_at DESC`;\n\n    if (options.limit) {\n      sql += ` LIMIT ?`;\n      params.push(options.limit);\n    }\n\n    const result = await this.db.query(sql, ...params);\n\n    return (result.rows as MigrationRow[]).map((row) => ({\n      ...row,\n      applied_at: new Date(row.applied_at),\n      rolled_back_at: row.rolled_back_at ? new Date(row.rolled_back_at) : null,\n      is_reversible: Boolean(row.is_reversible),\n    })) as SchemaMigrationRecord[];\n  }\n\n  /**\n   * Execute SQL statements with appropriate transaction handling\n   */\n  private async executeStatements(\n    statements: string[],\n    options: ApplyMigrationsOptions,\n  ): Promise<void> {\n    if (this.dbEngine === 'postgres' && options.postgresSafe) {\n      await this.executePostgresStatements(statements);\n    } else {\n      await this.executeWithTransaction(statements);\n    }\n  }\n\n  /**\n   * Execute statements within a transaction (SQLite/DuckDB)\n   */\n  private async executeWithTransaction(statements: string[]): Promise<void> {\n    if (this.db.transaction) {\n      await this.db.transaction(async (tx) => {\n        for (const sql of statements) {\n          await tx.query(sql);\n        }\n      });\n    } else {\n      // Fallback to sequential execution\n      for (const sql of statements) {\n        await this.db.query(sql);\n      }\n    }\n  }\n\n  /**\n   * Execute statements with PostgreSQL-specific handling\n   *\n   * - CONCURRENTLY statements run outside transaction\n   * - Regular statements run in transaction with lock_timeout\n   *\n   * Both CREATE and DROP variants of CONCURRENTLY must be detected — Postgres\n   * forbids `DROP INDEX CONCURRENTLY` inside a transaction block, just like\n   * the create variant. Issue #1165: the migration generator emits\n   * `DROP INDEX CONCURRENTLY` for shape-drift recreates and orphan-index\n   * cleanups, so the regex needs to cover both keywords.\n   */\n  private async executePostgresStatements(statements: string[]): Promise<void> {\n    const { concurrent: finalConcurrent, regular: finalRegular } =\n      planPostgresStatements(statements, !!this.options.useConcurrentIndexes);\n\n    // CONCURRENTLY statements come from `planPostgresStatements`, which\n    // also pushes any post-transform CREATE/DROP CONCURRENTLY into the\n    // outside-transaction set. The original `concurrentStatements` list\n    // is folded in there too so callers below see one merged stream.\n\n    // Execute regular statements in transaction with timeouts\n    if (finalRegular.length > 0 && this.db.transaction) {\n      await this.db.transaction(async (tx) => {\n        // Set session-level timeouts\n        await tx.query(\n          `SET LOCAL lock_timeout = '${this.options.lockTimeout}ms'`,\n        );\n        await tx.query(\n          `SET LOCAL statement_timeout = '${this.options.statementTimeout}ms'`,\n        );\n\n        for (const sql of finalRegular) {\n          await tx.query(sql);\n        }\n      });\n    } else if (finalRegular.length > 0) {\n      for (const sql of finalRegular) {\n        await this.db.query(sql);\n      }\n    }\n\n    // Execute CONCURRENTLY statements outside transaction\n    for (const sql of finalConcurrent) {\n      // Set lock timeout for the session\n      await this.db.query(`SET lock_timeout = '${this.options.lockTimeout}ms'`);\n      await this.db.query(sql);\n    }\n  }\n}\n\n/**\n * Split a batch of SQL statements into a transaction-safe set and a\n * concurrent set, applying `--postgres-safe` rewriting if requested.\n *\n * Exported for unit testing and to give external callers a way to\n * reason about what the tracker would execute in PostgreSQL safe mode.\n *\n * Rules:\n * - Statements already containing `CONCURRENTLY` for CREATE/DROP INDEX or\n *   REINDEX operations always go to the concurrent set — Postgres rejects\n *   them inside transactions.\n * - When `useConcurrentIndexes` is true, plain `CREATE INDEX` and plain\n *   `DROP INDEX` are rewritten to use `CONCURRENTLY`, then routed to\n *   the concurrent set. This is what the CLI `--postgres-safe` flag and\n *   the auto-migrate path rely on for issue #1165's shape-drift drops.\n * - All other statements stay in the regular (transaction) set.\n */\nexport function planPostgresStatements(\n  statements: string[],\n  useConcurrentIndexes: boolean,\n): { concurrent: string[]; regular: string[] } {\n  const concurrentRegex = CONCURRENT_INDEX_STATEMENT_RE;\n\n  const concurrent: string[] = [];\n  const regular: string[] = [];\n\n  for (const sql of statements) {\n    if (concurrentRegex.test(sql)) {\n      concurrent.push(sql);\n      continue;\n    }\n    if (useConcurrentIndexes) {\n      if (/CREATE\\s+(UNIQUE\\s+)?INDEX\\s+(?!CONCURRENTLY)/i.test(sql)) {\n        concurrent.push(\n          sql.replace(\n            /CREATE\\s+(UNIQUE\\s+)?INDEX\\s+/i,\n            'CREATE $1INDEX CONCURRENTLY ',\n          ),\n        );\n        continue;\n      }\n      if (/DROP\\s+INDEX\\s+(?!CONCURRENTLY)/i.test(sql)) {\n        concurrent.push(\n          sql.replace(/DROP\\s+INDEX\\s+/i, 'DROP INDEX CONCURRENTLY '),\n        );\n        continue;\n      }\n    }\n    regular.push(sql);\n  }\n\n  return { concurrent, regular };\n}\n"],"names":["results"],"mappings":"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"}

package/dist/migrations/types.d.ts

@@ -0,0 +1,221 @@
+import { DatabaseInterface, ColumnDefinitionWithName as SqlColumnDefinitionWithName, IndexDefinition as SqlIndexDefinition, TableSchemaInfo as SqlTableSchemaInfo } from '@happyvertical/sql';
+import { MigrationResult } from '../schema/types.js';
+export type { SqlColumnDefinitionWithName, DatabaseInterface, SqlIndexDefinition, SqlTableSchemaInfo, };
+export type { DriftReport, MigrationDefinition, MigrationResult, MigrationStatus, SchemaChange, SchemaDiff, SchemaMigrationRecord, } from '../schema/types.js';
+/**
+ * Options for the MigrationTracker
+ */
+export interface MigrationTrackerOptions {
+    /** Database interface from @happyvertical/sql */
+    db: DatabaseInterface;
+    /** PostgreSQL lock timeout in milliseconds (default: 30000) */
+    lockTimeout?: number;
+    /** PostgreSQL statement timeout in milliseconds (default: 60000) */
+    statementTimeout?: number;
+    /** Use CREATE INDEX CONCURRENTLY for indexes in PostgreSQL (default: true) */
+    useConcurrentIndexes?: boolean;
+    /**
+     * Explicit engine hint used when `db.url` is empty or ambiguous (e.g. JSON
+     * adapter, or adapters that expose the URL on `db.config?.url`). Without
+     * it the tracker falls back to URL-only detection and may skip
+     * Postgres-specific safety paths (CONCURRENTLY rewrites, lock timeouts)
+     * on connections whose caller meant Postgres.
+     */
+    engineHint?: string;
+}
+/**
+ * Table schema info from database introspection
+ */
+export interface TableSchemaInfo {
+    tableName: string;
+    columns: Record<string, ColumnInfo>;
+    indexes: IndexInfo[];
+    foreignKeys?: ForeignKeyInfo[];
+}
+/**
+ * Column info from database introspection
+ */
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    notNull?: boolean;
+    defaultValue?: unknown;
+    primaryKey?: boolean;
+}
+/**
+ * Index info from database introspection
+ */
+export interface IndexInfo {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+}
+/**
+ * Foreign key info from database introspection
+ */
+export interface ForeignKeyInfo {
+    column: string;
+    referencesTable: string;
+    referencesColumn: string;
+    onDelete?: string;
+    onUpdate?: string;
+}
+/**
+ * Column definition with name for alterTable operations
+ */
+export interface ColumnDefinitionWithName {
+    name: string;
+    type: string;
+    notNull?: boolean;
+    defaultValue?: unknown;
+    unique?: boolean;
+    primaryKey?: boolean;
+}
+/**
+ * Index definition for alterTable operations
+ */
+export interface IndexDefinition {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+    where?: string;
+}
+/**
+ * Database engine type
+ */
+export type DatabaseEngine = 'sqlite' | 'postgres' | 'duckdb';
+/**
+ * Options for batch migration application
+ */
+export interface ApplyMigrationsOptions {
+    /** Apply the full batch in one transaction and roll back all applied changes on first failure */
+    atomic?: boolean;
+    /** Continue applying migrations even if one fails */
+    continueOnError?: boolean;
+    /** Dry run - don't actually apply migrations */
+    dryRun?: boolean;
+    /** Force application even if checksums don't match */
+    force?: boolean;
+    /**
+     * Reconcile migration history with live schema drift.
+     *
+     * When true, the tracker may re-run a migration if the caller has already
+     * independently determined the change is still required. Completed
+     * migrations still require a checksum match. Failed migrations may be retried
+     * with the current definition because they were never applied successfully.
+     * Running migrations still require `force` because SMRT does not currently
+     * have a heartbeat or lock-owner check that can prove the original process
+     * is dead.
+     */
+    reconcile?: boolean;
+    /** Use PostgreSQL-safe operations (CONCURRENTLY, lock timeout) */
+    postgresSafe?: boolean;
+    /** Called after each migration attempt completes, before the batch continues */
+    onProgress?: (result: MigrationResult) => void;
+}
+/**
+ * Options for rollback operations
+ */
+export interface RollbackOptions {
+    /** Number of migrations to rollback (default: 1) */
+    steps?: number;
+    /** Rollback to a specific migration (exclusive - migrations after this will be rolled back) */
+    to?: string;
+    /** Dry run - don't actually rollback */
+    dryRun?: boolean;
+    /** Skip confirmation prompt */
+    force?: boolean;
+}
+/**
+ * Options for migration file parsing
+ */
+export interface ParseMigrationOptions {
+    /** Expected format of migration file */
+    format?: 'sql' | 'typescript';
+}
+/**
+ * Parsed migration file content
+ */
+export interface ParsedMigrationFile {
+    /** Migration ID extracted from file */
+    id: string;
+    /** Description extracted from file */
+    description?: string;
+    /** UP SQL statements */
+    up: string[];
+    /** DOWN SQL statements */
+    down: string[];
+    /** Dependencies extracted from file */
+    dependencies?: string[];
+}
+/**
+ * Migration mode configuration
+ */
+export type MigrationMode = 'dynamic';
+/**
+ * Data migration for updating existing data (e.g., STI discriminator upgrades)
+ */
+export interface DataMigration {
+    type: 'data';
+    table: string;
+    description: string;
+    up: DataMigrationStatement[];
+    down: DataMigrationStatement[];
+}
+/**
+ * Single data migration statement with optional parameters
+ */
+export interface DataMigrationStatement {
+    sql: string;
+    params?: unknown[];
+}
+/**
+ * STI discriminator migration (specific type of data migration)
+ */
+export interface StiDiscriminatorMigration extends DataMigration {
+    type: 'data';
+    migrationCategory: 'sti-discriminator';
+    oldValue: string;
+    newValue: string;
+    table: string;
+    column: string;
+}
+/**
+ * Result of applying a data migration
+ */
+export interface DataMigrationResult {
+    success: boolean;
+    name: string;
+    rowsAffected?: number;
+    execution_time_ms: number;
+    error?: string;
+}
+/**
+ * Migrations configuration for smrt.config.js
+ */
+export interface MigrationsConfig {
+    /** Directory for migration files (default: './migrations') */
+    directory?: string;
+    /** Tracking table name (default: '_smrt_schema_migrations') */
+    table?: string;
+    /** Default file format (default: 'sql') */
+    format?: 'sql' | 'typescript';
+    /** Naming scheme (default: 'sequence') */
+    naming?: 'sequence' | 'timestamp';
+    /** Migration mode (default: 'dynamic') */
+    mode?: MigrationMode;
+    /** Or configure by environment */
+    modeByEnvironment?: Record<string, MigrationMode>;
+    /** Auto-generate DOWN scripts (default: true) */
+    autoGenerateDown?: boolean;
+    /** PostgreSQL-specific options */
+    postgres?: {
+        /** Use CONCURRENTLY for index creation (default: true) */
+        useConcurrently?: boolean;
+        /** Lock timeout for migrations (default: '30s') */
+        lockTimeout?: string;
+        /** Statement timeout for migrations (default: '60s') */
+        statementTimeout?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/migrations/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/migrations/types.ts"],"names":[],"mappings":"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"}

package/dist/migrations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel file for migrations module
+ * This file exists because vite's getCoreEntries() expects src/migrations.ts
+ * when the package.json export is ./dist/migrations.js
+ */
+export * from './migrations/index.js';
+//# sourceMappingURL=migrations.d.ts.map

package/dist/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../src/migrations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,uBAAuB,CAAC"}

package/dist/migrations.js

@@ -0,0 +1,26 @@
+import { BackfillTracker } from "./migrations/backfill-tracker.js";
+import { computeChecksum, normalizeSQL, shortChecksum, verifyChecksum } from "./migrations/checksum.js";
+import { SchemaComparer, generateSchemaDiff, getSQLFromDiff, hasActionableChanges } from "./migrations/differ.js";
+import { MigrationGenerator, createMigrationDefinition, generateMigrationSequence, generateMigrationTimestamp } from "./migrations/generator.js";
+import { getPendingSchemaStatements, migrateSmrtSchemas } from "./migrations/orchestrate.js";
+import { MigrationTracker, planPostgresStatements } from "./migrations/tracker.js";
+export {
+  BackfillTracker,
+  MigrationGenerator,
+  MigrationTracker,
+  SchemaComparer,
+  computeChecksum,
+  createMigrationDefinition,
+  generateMigrationSequence,
+  generateMigrationTimestamp,
+  generateSchemaDiff,
+  getPendingSchemaStatements,
+  getSQLFromDiff,
+  hasActionableChanges,
+  migrateSmrtSchemas,
+  normalizeSQL,
+  planPostgresStatements,
+  shortChecksum,
+  verifyChecksum
+};
+//# sourceMappingURL=migrations.js.map

package/dist/migrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/dist/node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js

@@ -0,0 +1,56 @@
+const balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+const maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+const range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+export {
+  balanced,
+  range
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js"],"sourcesContent":["export const balanced = (a, b, str) => {\n    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;\n    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;\n    const r = ma !== null && mb != null && range(ma, mb, str);\n    return (r && {\n        start: r[0],\n        end: r[1],\n        pre: str.slice(0, r[0]),\n        body: str.slice(r[0] + ma.length, r[1]),\n        post: str.slice(r[1] + mb.length),\n    });\n};\nconst maybeMatch = (reg, str) => {\n    const m = str.match(reg);\n    return m ? m[0] : null;\n};\nexport const range = (a, b, str) => {\n    let begs, beg, left, right = undefined, result;\n    let ai = str.indexOf(a);\n    let bi = str.indexOf(b, ai + 1);\n    let i = ai;\n    if (ai >= 0 && bi > 0) {\n        if (a === b) {\n            return [ai, bi];\n        }\n        begs = [];\n        left = str.length;\n        while (i >= 0 && !result) {\n            if (i === ai) {\n                begs.push(i);\n                ai = str.indexOf(a, i + 1);\n            }\n            else if (begs.length === 1) {\n                const r = begs.pop();\n                if (r !== undefined)\n                    result = [r, bi];\n            }\n            else {\n                beg = begs.pop();\n                if (beg !== undefined && beg < left) {\n                    left = beg;\n                    right = bi;\n                }\n                bi = str.indexOf(b, i + 1);\n            }\n            i = ai < bi && ai >= 0 ? ai : bi;\n        }\n        if (begs.length && right !== undefined) {\n            result = [left, right];\n        }\n    }\n    return result;\n};\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":"AAAY,MAAC,WAAW,CAAC,GAAG,GAAG,QAAQ;AACnC,QAAM,KAAK,aAAa,SAAS,WAAW,GAAG,GAAG,IAAI;AACtD,QAAM,KAAK,aAAa,SAAS,WAAW,GAAG,GAAG,IAAI;AACtD,QAAM,IAAI,OAAO,QAAQ,MAAM,QAAQ,MAAM,IAAI,IAAI,GAAG;AACxD,SAAQ,KAAK;AAAA,IACT,OAAO,EAAE,CAAC;AAAA,IACV,KAAK,EAAE,CAAC;AAAA,IACR,KAAK,IAAI,MAAM,GAAG,EAAE,CAAC,CAAC;AAAA,IACtB,MAAM,IAAI,MAAM,EAAE,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAC,CAAC;AAAA,IACtC,MAAM,IAAI,MAAM,EAAE,CAAC,IAAI,GAAG,MAAM;AAAA,EACxC;AACA;AACA,MAAM,aAAa,CAAC,KAAK,QAAQ;AAC7B,QAAM,IAAI,IAAI,MAAM,GAAG;AACvB,SAAO,IAAI,EAAE,CAAC,IAAI;AACtB;AACY,MAAC,QAAQ,CAAC,GAAG,GAAG,QAAQ;AAChC,MAAI,MAAM,KAAK,MAAM,QAAQ,QAAW;AACxC,MAAI,KAAK,IAAI,QAAQ,CAAC;AACtB,MAAI,KAAK,IAAI,QAAQ,GAAG,KAAK,CAAC;AAC9B,MAAI,IAAI;AACR,MAAI,MAAM,KAAK,KAAK,GAAG;AACnB,QAAI,MAAM,GAAG;AACT,aAAO,CAAC,IAAI,EAAE;AAAA,IAClB;AACA,WAAO,CAAA;AACP,WAAO,IAAI;AACX,WAAO,KAAK,KAAK,CAAC,QAAQ;AACtB,UAAI,MAAM,IAAI;AACV,aAAK,KAAK,CAAC;AACX,aAAK,IAAI,QAAQ,GAAG,IAAI,CAAC;AAAA,MAC7B,WACS,KAAK,WAAW,GAAG;AACxB,cAAM,IAAI,KAAK,IAAG;AAClB,YAAI,MAAM;AACN,mBAAS,CAAC,GAAG,EAAE;AAAA,MACvB,OACK;AACD,cAAM,KAAK,IAAG;AACd,YAAI,QAAQ,UAAa,MAAM,MAAM;AACjC,iBAAO;AACP,kBAAQ;AAAA,QACZ;AACA,aAAK,IAAI,QAAQ,GAAG,IAAI,CAAC;AAAA,MAC7B;AACA,UAAI,KAAK,MAAM,MAAM,IAAI,KAAK;AAAA,IAClC;AACA,QAAI,KAAK,UAAU,UAAU,QAAW;AACpC,eAAS,CAAC,MAAM,KAAK;AAAA,IACzB;AAAA,EACJ;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/brace-expansion@5.0.5/node_modules/brace-expansion/dist/esm/index.js

@@ -0,0 +1,163 @@
+import { balanced } from "../../../../../balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js";
+const escSlash = "\0SLASH" + Math.random() + "\0";
+const escOpen = "\0OPEN" + Math.random() + "\0";
+const escClose = "\0CLOSE" + Math.random() + "\0";
+const escComma = "\0COMMA" + Math.random() + "\0";
+const escPeriod = "\0PERIOD" + Math.random() + "\0";
+const escSlashPattern = new RegExp(escSlash, "g");
+const escOpenPattern = new RegExp(escOpen, "g");
+const escClosePattern = new RegExp(escClose, "g");
+const escCommaPattern = new RegExp(escComma, "g");
+const escPeriodPattern = new RegExp(escPeriod, "g");
+const slashPattern = /\\\\/g;
+const openPattern = /\\{/g;
+const closePattern = /\\}/g;
+const commaPattern = /\\,/g;
+const periodPattern = /\\\./g;
+const EXPANSION_MAX = 1e5;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str, options = {}) {
+  if (!str) {
+    return [];
+  }
+  const { max = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length && k < max; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max, true);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max, false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max, false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
+export {
+  EXPANSION_MAX,
+  expand
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/brace-expansion@5.0.5/node_modules/brace-expansion/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/brace-expansion@5.0.5/node_modules/brace-expansion/dist/esm/index.js"],"sourcesContent":["import { balanced } from 'balanced-match';\nconst escSlash = '\\0SLASH' + Math.random() + '\\0';\nconst escOpen = '\\0OPEN' + Math.random() + '\\0';\nconst escClose = '\\0CLOSE' + Math.random() + '\\0';\nconst escComma = '\\0COMMA' + Math.random() + '\\0';\nconst escPeriod = '\\0PERIOD' + Math.random() + '\\0';\nconst escSlashPattern = new RegExp(escSlash, 'g');\nconst escOpenPattern = new RegExp(escOpen, 'g');\nconst escClosePattern = new RegExp(escClose, 'g');\nconst escCommaPattern = new RegExp(escComma, 'g');\nconst escPeriodPattern = new RegExp(escPeriod, 'g');\nconst slashPattern = /\\\\\\\\/g;\nconst openPattern = /\\\\{/g;\nconst closePattern = /\\\\}/g;\nconst commaPattern = /\\\\,/g;\nconst periodPattern = /\\\\\\./g;\nexport const EXPANSION_MAX = 100_000;\nfunction numeric(str) {\n    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);\n}\nfunction escapeBraces(str) {\n    return str\n        .replace(slashPattern, escSlash)\n        .replace(openPattern, escOpen)\n        .replace(closePattern, escClose)\n        .replace(commaPattern, escComma)\n        .replace(periodPattern, escPeriod);\n}\nfunction unescapeBraces(str) {\n    return str\n        .replace(escSlashPattern, '\\\\')\n        .replace(escOpenPattern, '{')\n        .replace(escClosePattern, '}')\n        .replace(escCommaPattern, ',')\n        .replace(escPeriodPattern, '.');\n}\n/**\n * Basically just str.split(\",\"), but handling cases\n * where we have nested braced sections, which should be\n * treated as individual members, like {a,{b,c},d}\n */\nfunction parseCommaParts(str) {\n    if (!str) {\n        return [''];\n    }\n    const parts = [];\n    const m = balanced('{', '}', str);\n    if (!m) {\n        return str.split(',');\n    }\n    const { pre, body, post } = m;\n    const p = pre.split(',');\n    p[p.length - 1] += '{' + body + '}';\n    const postParts = parseCommaParts(post);\n    if (post.length) {\n        ;\n        p[p.length - 1] += postParts.shift();\n        p.push.apply(p, postParts);\n    }\n    parts.push.apply(parts, p);\n    return parts;\n}\nexport function expand(str, options = {}) {\n    if (!str) {\n        return [];\n    }\n    const { max = EXPANSION_MAX } = options;\n    // I don't know why Bash 4.3 does this, but it does.\n    // Anything starting with {} will have the first two bytes preserved\n    // but *only* at the top level, so {},a}b will not expand to anything,\n    // but a{},b}c will be expanded to [a}c,abc].\n    // One could argue that this is a bug in Bash, but since the goal of\n    // this module is to match Bash's rules, we escape a leading {}\n    if (str.slice(0, 2) === '{}') {\n        str = '\\\\{\\\\}' + str.slice(2);\n    }\n    return expand_(escapeBraces(str), max, true).map(unescapeBraces);\n}\nfunction embrace(str) {\n    return '{' + str + '}';\n}\nfunction isPadded(el) {\n    return /^-?0\\d/.test(el);\n}\nfunction lte(i, y) {\n    return i <= y;\n}\nfunction gte(i, y) {\n    return i >= y;\n}\nfunction expand_(str, max, isTop) {\n    /** @type {string[]} */\n    const expansions = [];\n    const m = balanced('{', '}', str);\n    if (!m)\n        return [str];\n    // no need to expand pre, since it is guaranteed to be free of brace-sets\n    const pre = m.pre;\n    const post = m.post.length ? expand_(m.post, max, false) : [''];\n    if (/\\$$/.test(m.pre)) {\n        for (let k = 0; k < post.length && k < max; k++) {\n            const expansion = pre + '{' + m.body + '}' + post[k];\n            expansions.push(expansion);\n        }\n    }\n    else {\n        const isNumericSequence = /^-?\\d+\\.\\.-?\\d+(?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isAlphaSequence = /^[a-zA-Z]\\.\\.[a-zA-Z](?:\\.\\.-?\\d+)?$/.test(m.body);\n        const isSequence = isNumericSequence || isAlphaSequence;\n        const isOptions = m.body.indexOf(',') >= 0;\n        if (!isSequence && !isOptions) {\n            // {a},b}\n            if (m.post.match(/,(?!,).*\\}/)) {\n                str = m.pre + '{' + m.body + escClose + m.post;\n                return expand_(str, max, true);\n            }\n            return [str];\n        }\n        let n;\n        if (isSequence) {\n            n = m.body.split(/\\.\\./);\n        }\n        else {\n            n = parseCommaParts(m.body);\n            if (n.length === 1 && n[0] !== undefined) {\n                // x{{a,b}}y ==> x{a}y x{b}y\n                n = expand_(n[0], max, false).map(embrace);\n                //XXX is this necessary? Can't seem to hit it in tests.\n                /* c8 ignore start */\n                if (n.length === 1) {\n                    return post.map(p => m.pre + n[0] + p);\n                }\n                /* c8 ignore stop */\n            }\n        }\n        // at this point, n is the parts, and we know it's not a comma set\n        // with a single entry.\n        let N;\n        if (isSequence && n[0] !== undefined && n[1] !== undefined) {\n            const x = numeric(n[0]);\n            const y = numeric(n[1]);\n            const width = Math.max(n[0].length, n[1].length);\n            let incr = n.length === 3 && n[2] !== undefined ?\n                Math.max(Math.abs(numeric(n[2])), 1)\n                : 1;\n            let test = lte;\n            const reverse = y < x;\n            if (reverse) {\n                incr *= -1;\n                test = gte;\n            }\n            const pad = n.some(isPadded);\n            N = [];\n            for (let i = x; test(i, y); i += incr) {\n                let c;\n                if (isAlphaSequence) {\n                    c = String.fromCharCode(i);\n                    if (c === '\\\\') {\n                        c = '';\n                    }\n                }\n                else {\n                    c = String(i);\n                    if (pad) {\n                        const need = width - c.length;\n                        if (need > 0) {\n                            const z = new Array(need + 1).join('0');\n                            if (i < 0) {\n                                c = '-' + z + c.slice(1);\n                            }\n                            else {\n                                c = z + c;\n                            }\n                        }\n                    }\n                }\n                N.push(c);\n            }\n        }\n        else {\n            N = [];\n            for (let j = 0; j < n.length; j++) {\n                N.push.apply(N, expand_(n[j], max, false));\n            }\n        }\n        for (let j = 0; j < N.length; j++) {\n            for (let k = 0; k < post.length && expansions.length < max; k++) {\n                const expansion = pre + N[j] + post[k];\n                if (!isTop || isSequence || expansion) {\n                    expansions.push(expansion);\n                }\n            }\n        }\n    }\n    return expansions;\n}\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/minimatch@10.2.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js

@@ -0,0 +1,13 @@
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+export {
+  assertValidPattern
+};
+//# sourceMappingURL=assert-valid-pattern.js.map

package/dist/node_modules/.pnpm/minimatch@10.2.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-valid-pattern.js","sources":["../../../../../../../../../../node_modules/.pnpm/minimatch@10.2.3/node_modules/minimatch/dist/esm/assert-valid-pattern.js"],"sourcesContent":["const MAX_PATTERN_LENGTH = 1024 * 64;\nexport const assertValidPattern = (pattern) => {\n    if (typeof pattern !== 'string') {\n        throw new TypeError('invalid pattern');\n    }\n    if (pattern.length > MAX_PATTERN_LENGTH) {\n        throw new TypeError('pattern is too long');\n    }\n};\n//# sourceMappingURL=assert-valid-pattern.js.map"],"names":[],"mappings":"AAAA,MAAM,qBAAqB,OAAO;AACtB,MAAC,qBAAqB,CAAC,YAAY;AAC3C,MAAI,OAAO,YAAY,UAAU;AAC7B,UAAM,IAAI,UAAU,iBAAiB;AAAA,EACzC;AACA,MAAI,QAAQ,SAAS,oBAAoB;AACrC,UAAM,IAAI,UAAU,qBAAqB;AAAA,EAC7C;AACJ;","x_google_ignoreList":[0]}