@happyvertical/smrt-core 0.36.5 → 0.36.7

package/dist/manifest.json

@@ -1,8 +1,8 @@
 {
   "version": "1.0.0",
-  "timestamp": 1782485410377,
+  "timestamp": 1782507312564,
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.36.5",
+  "packageVersion": "0.36.7",
   "objects": {
     "@happyvertical/smrt-core:SmrtClass": {
       "name": "smrtclass",

package/dist/mcp-advisor/index.d.ts

@@ -495,5 +495,5 @@ export declare const TOOLS: ({
  * Exported so the routing switch can be unit-tested in-process (the stdio
  * entrypoint guard below keeps importing this module side-effect free).
  */
-export declare function handleToolCall(name: string, args: any): Promise<any>;
+export declare function handleToolCall(name: string, args: Record<string, unknown>): Promise<unknown>;
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp-advisor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp-advisor/index.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AA8BH;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqUjB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CA2B1E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp-advisor/index.ts"],"names":[],"mappings":";AACA;;;;;;;GAOG;AA2CH;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqUjB,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CA+BlB"}

package/dist/mcp-advisor/tools/get-object-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-object-config.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/get-object-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEtE;;GAEG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAqFvB"}
+{"version":3,"file":"get-object-config.d.ts","sourceRoot":"","sources":["../../../src/mcp-advisor/tools/get-object-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEtE;;GAEG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAuFvB"}

package/dist/mcp-advisor/types.d.ts

@@ -8,7 +8,7 @@
  */
 export interface ToolResponse {
     success: boolean;
-    data?: any;
+    data?: unknown;
     error?: string;
     warnings?: string[];
 }
@@ -43,7 +43,7 @@ export interface GenerateFieldDefinitionsInput {
     fields: Array<{
         name: string;
         type: 'text' | 'integer' | 'decimal' | 'boolean' | 'datetime' | 'json' | 'foreignKey';
-        _meta?: Record<string, any>;
+        _meta?: Record<string, unknown>;
     }>;
 }
 /**
@@ -139,7 +139,7 @@ export interface McpToolDefinition {
     description: string;
     inputSchema: {
         type: string;
-        properties: Record<string, any>;
+        properties: Record<string, unknown>;
         required?: string[];
     };
 }
@@ -175,9 +175,9 @@ export interface FieldDefinition {
     name: string;
     type: string;
     required: boolean;
-    default?: any;
+    default?: unknown;
     description?: string;
-    constraints?: Record<string, any>;
+    constraints?: Record<string, unknown>;
 }
 /**
  * Input for get-object-config tool

package/dist/mcp-advisor/types.d.ts.map

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

package/dist/migrations/differ.js.map

@@ -1 +1 @@
-{"version":3,"file":"differ.js","sources":["../../src/migrations/differ.ts"],"sourcesContent":["/**\n * Schema Differ\n *\n * Compares manifest schemas to database schemas and generates\n * a SchemaDiff with the differences.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type {\n  ColumnDefinition,\n  IndexDefinition,\n  SchemaChange,\n  SchemaDefinition,\n  SchemaDiff,\n  SQLDataType,\n} from '../schema/types.js';\nimport { isJsonPathIndex, renderIndexTarget } from '../schema/utils.js';\nimport type { DatabaseInterface, SqlTableSchemaInfo } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Valid SQLDataType values for validation\n */\nconst VALID_SQL_DATA_TYPES: Set<SQLDataType> = new Set([\n  'TEXT',\n  'INTEGER',\n  'REAL',\n  'BLOB',\n  'BOOLEAN',\n  'JSON',\n  'TIMESTAMP',\n  'UUID',\n]);\n\ninterface GeneratedTypeUpgradeSQL {\n  sql: string;\n  statements?: string[];\n}\n\n/**\n * Check if a string is a valid SQLDataType\n */\nfunction isValidSQLDataType(type: string): type is SQLDataType {\n  return VALID_SQL_DATA_TYPES.has(type as SQLDataType);\n}\n\n/**\n * Options for schema comparison\n */\nexport interface DiffOptions {\n  /** Include dropped tables in diff (default: false for safety) */\n  includeDroppedTables?: boolean;\n  /** Include dropped columns in diff (default: false for safety) */\n  includeDroppedColumns?: boolean;\n  /**\n   * Drop indexes that exist in the database but are absent from the manifest\n   * AND are not functionally equivalent to anything in the manifest. Default:\n   * false. The differ always skips primary-key indexes (`*_pkey`) and the\n   * implicit indexes that PostgreSQL creates from inline UNIQUE constraints\n   * (`*_key`) — those are owned by table-level constraints, not by the\n   * index list, and dropping them here would break the constraint.\n   */\n  includeDroppedIndexes?: boolean;\n  /** Ignore type mismatches (just log warnings) */\n  ignoreTypeMismatches?: boolean;\n  /**\n   * Explicit engine hint forwarded to `detectEngine` when picking the DDL\n   * strategy used for *existing-table* SQL (ALTER/CREATE INDEX/etc.). Use\n   * this when `db.url` is empty or ambiguous (e.g. JSON adapter, in-memory\n   * wrappers where the URL lives on `db.config?.url`). Without it the\n   * comparer falls back to URL-only detection, which can produce SQLite-\n   * flavored SQL on a connection whose caller meant Postgres or DuckDB.\n   */\n  engineHint?: string;\n}\n\n/**\n * Suffix patterns for indexes that the differ refuses to drop.\n * - `_pkey`: PostgreSQL primary key implicit index.\n * - `_key`: PostgreSQL implicit index for inline `UNIQUE (...)` table\n *   constraints. Dropping these by name does not drop the underlying\n *   constraint, and dropping the constraint requires a separate DDL path\n *   (`ALTER TABLE ... DROP CONSTRAINT`) the differ does not emit today.\n */\nconst PROTECTED_INDEX_SUFFIXES = ['_pkey', '_key'];\n\nfunction isProtectedDbIndexName(name: string): boolean {\n  return PROTECTED_INDEX_SUFFIXES.some((suffix) => name.endsWith(suffix));\n}\n\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * SchemaComparer class for comparing manifest schemas to database\n */\nexport class SchemaComparer {\n  private db: DatabaseInterface;\n  private options: DiffOptions;\n  private engine: DatabaseEngine;\n  private ddlStrategy: ReturnType<typeof getDDLStrategy>;\n\n  constructor(db: DatabaseInterface, options: DiffOptions = {}) {\n    this.db = db;\n    this.options = {\n      includeDroppedTables: false,\n      includeDroppedColumns: false,\n      includeDroppedIndexes: false,\n      ignoreTypeMismatches: false,\n      ...options,\n    };\n    // Use the shared detectEngine utility for consistent detection.\n    // Handles :memory:, .json, and other edge cases. The JSON adapter is\n    // detected structurally (it exposes `exportTable`) because its url can be\n    // empty; otherwise fall back to URL-based detection, where `engineHint`\n    // lets callers override when `db.url` is empty or points at an adapter\n    // whose engine isn't obvious from the URL alone (some in-memory wrappers).\n    this.engine =\n      typeof (this.db as any).exportTable === 'function'\n        ? 'json'\n        : detectEngine(resolveDatabaseUrl(this.db), this.options.engineHint);\n    this.ddlStrategy = getDDLStrategy(this.engine);\n  }\n\n  /**\n   * Compare manifest schemas to database and return differences\n   */\n  async compare(\n    manifestSchemas: Record<string, SchemaDefinition>,\n  ): Promise<SchemaDiff> {\n    const diff: SchemaDiff = {\n      added_tables: [],\n      dropped_tables: [],\n      changes: [],\n      has_changes: false,\n    };\n\n    // Get list of existing tables\n    const existingTables = await this.getExistingTables();\n\n    // Check each manifest schema against database\n    for (const [tableName, schema] of Object.entries(manifestSchemas)) {\n      if (!existingTables.has(tableName)) {\n        // Table doesn't exist - add to added_tables\n        diff.added_tables.push(schema);\n        diff.has_changes = true;\n      } else {\n        // Table exists - compare columns and indexes\n        const tableChanges = await this.compareTable(tableName, schema);\n        if (tableChanges.length > 0) {\n          diff.changes.push(...tableChanges);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    // Check for dropped tables (if enabled)\n    if (this.options.includeDroppedTables) {\n      for (const tableName of existingTables) {\n        // Skip system tables\n        if (tableName.startsWith('_smrt_') || tableName.startsWith('sqlite_')) {\n          continue;\n        }\n        if (!manifestSchemas[tableName]) {\n          diff.dropped_tables.push(tableName);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    return diff;\n  }\n\n  /**\n   * Compare a single table's schema to manifest\n   */\n  async compareTable(\n    tableName: string,\n    manifest: SchemaDefinition,\n  ): Promise<SchemaChange[]> {\n    const changes: SchemaChange[] = [];\n\n    // Get current table schema from database\n    const dbSchema = await this.db.getTableSchema?.(tableName);\n    if (!dbSchema) {\n      // Table doesn't exist - this is an add_table case\n      return changes;\n    }\n\n    // Compare columns\n    const columnChanges = this.compareColumns(tableName, manifest, dbSchema);\n    changes.push(...columnChanges);\n\n    // Compare indexes\n    const indexChanges = this.compareIndexes(tableName, manifest, dbSchema);\n    changes.push(...indexChanges);\n\n    return changes;\n  }\n\n  /**\n   * Compare columns between manifest and database\n   */\n  private compareColumns(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n    const dbColumnNames = new Set(Object.keys(dbSchema.columns));\n\n    // Check for new and modified columns\n    for (const [colName, colDef] of Object.entries(manifest.columns)) {\n      if (!dbColumnNames.has(colName)) {\n        // Column doesn't exist - add it\n        changes.push({\n          type: 'add_column',\n          table: tableName,\n          name: colName,\n          column: colDef,\n          sql: this.generateAddColumnSQL(tableName, colName, colDef),\n        });\n      } else {\n        // Column exists - check for type mismatch\n        const dbCol = dbSchema.columns[colName];\n\n        // Map manifest's abstract type to engine-specific type\n        // e.g., JSON → TEXT for SQLite, JSON → JSONB for PostgreSQL\n        // Validate the manifest type before mapping\n        const manifestType = colDef.type;\n        if (!isValidSQLDataType(manifestType)) {\n          // Invalid manifest type - treat as TEXT (safest fallback)\n          logger.warn(\n            `[SchemaComparer] Invalid manifest type \"${manifestType}\" for ${tableName}.${colName}, treating as TEXT`,\n          );\n        }\n        const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n          ? manifestType\n          : 'TEXT';\n        const expectedEngineType = this.ddlStrategy.mapType(validatedType);\n        const normalizedExpected = this.normalizeType(expectedEngineType);\n        const normalizedActual = this.normalizeType(dbCol.type);\n\n        // R11: native `uuid` and `text` are interchangeable for SMRT-owned\n        // identifiers/references, but not for arbitrary provenance text. Keep\n        // the tolerance directional:\n        //   - manifest UUID + DB text is tolerated for structural ID/ref\n        //     columns so old deployments are not forced into native UUID.\n        //   - manifest TEXT + DB uuid is tolerated only for structural ID/ref\n        //     columns that are intentionally UUID-compatible.\n        // Plain TEXT columns with DB uuid now surface as repairable drift.\n        const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(\n          colName,\n          colDef,\n          normalizedExpected,\n          normalizedActual,\n        );\n\n        // #1335: native `json`/`jsonb` (DB) and `text` (manifest) are\n        // interchangeable for SMRT — the convention is to serialize JSON values\n        // into TEXT columns, and a native-json column already holds exactly that\n        // data. So the differ must NOT flag a json<->text difference in EITHER\n        // direction:\n        //   - manifest TEXT vs DB json   (native-json column, text-convention manifest)\n        //   - manifest JSON vs DB text   (the canary case: an enum/plain field\n        //     mis-inferred as JSON by a downstream scanner, sitting on a real\n        //     `text` column holding bare values like 'active')\n        // Generating an ALTER here is pure churn at best and data-destroying at\n        // worst: `status::jsonb` on a column holding 'active' raises\n        // \"invalid input syntax for type json\" and aborts the whole atomic\n        // migration. Like the uuid/text tolerance, this lives at the equality\n        // gate only (not in `normalizeType`) so `isCompatibleTypeUpgrade` still\n        // treats JSON and TEXT as distinct buckets for OTHER upgrade paths.\n        const isJsonTextEquivalent =\n          (normalizedExpected === 'JSON' && normalizedActual === 'TEXT') ||\n          (normalizedExpected === 'TEXT' && normalizedActual === 'JSON');\n\n        if (\n          normalizedExpected !== normalizedActual &&\n          !isUuidTextEquivalent &&\n          !isJsonTextEquivalent\n        ) {\n          // Check if this is a safe type upgrade that SMRT can handle\n          // Since SMRT owns the data lifecycle, we know the intent from the manifest\n          if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {\n            // Generate type upgrade SQL\n            const generatedSQL = this.generateTypeUpgradeSQL(\n              tableName,\n              colName,\n              colDef,\n              dbCol.type,\n            );\n            changes.push({\n              type: 'type_upgrade',\n              table: tableName,\n              name: colName,\n              column: colDef,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n              sql: generatedSQL.sql,\n              ...(generatedSQL.statements\n                ? { sqlStatements: generatedSQL.statements }\n                : {}),\n            });\n          } else if (!this.options.ignoreTypeMismatches) {\n            changes.push({\n              type: 'type_mismatch',\n              table: tableName,\n              name: colName,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n            });\n          }\n        }\n      }\n    }\n\n    // Check for dropped columns (if enabled)\n    if (this.options.includeDroppedColumns) {\n      const manifestColumnNames = new Set(Object.keys(manifest.columns));\n      for (const colName of dbColumnNames) {\n        if (!manifestColumnNames.has(colName)) {\n          changes.push({\n            type: 'drop_column',\n            table: tableName,\n            name: colName,\n            sql: this.generateDropColumnSQL(tableName, colName),\n          });\n        }\n      }\n    }\n\n    return changes;\n  }\n\n  private isUuidTextEquivalentColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n    normalizedExpected: string,\n    normalizedActual: string,\n  ): boolean {\n    const expectedUuidActualText =\n      normalizedExpected === 'UUID' && normalizedActual === 'TEXT';\n    const expectedTextActualUuid =\n      normalizedExpected === 'TEXT' && normalizedActual === 'UUID';\n\n    if (!expectedUuidActualText && !expectedTextActualUuid) {\n      return false;\n    }\n\n    return this.isStructuralUuidCompatibleColumn(columnName, colDef);\n  }\n\n  private isStructuralUuidCompatibleColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n  ): boolean {\n    return (\n      colDef.primaryKey === true ||\n      Boolean(colDef.foreignKey) ||\n      colDef.referenceKind === 'id' ||\n      colDef.referenceKind === 'foreignKey' ||\n      colDef.referenceKind === 'crossPackageRef' ||\n      colDef.referenceKind === 'tenantId' ||\n      (columnName === 'id' && colDef.type === 'TEXT')\n    );\n  }\n\n  /**\n   * Compare indexes between manifest and database\n   *\n   * Three classes of drift the differ now detects:\n   *\n   * 1. **Missing index** — manifest has an index neither the DB has by name\n   *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the\n   *    signature check protects against creating duplicates when STI child\n   *    classes register indexes with different name prefixes.)\n   *\n   * 2. **Same-name shape drift** — DB has an index with the manifest's name,\n   *    but its columns or uniqueness flag differ. This is the failure mode\n   *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is\n   *    non-unique, while the manifest declares it unique. Emit\n   *    `drop_index` + `add_index` so the next migrate cycle recreates it\n   *    with the correct shape.\n   *\n   * 3. **Orphan in DB** — DB has an index with no manifest counterpart by\n   *    name and no signature equivalent. Emit `drop_index` *only* when the\n   *    caller opts in via `includeDroppedIndexes`, and even then never for\n   *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by\n   *    table-level constraints and need a separate `DROP CONSTRAINT` path\n   *    that the differ does not emit yet.\n   */\n  private compareIndexes(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n\n    // Index DB indexes by name and by signature for fast lookup.\n    // dbIndexSignatures groups *all* DB index names sharing a signature so\n    // duplicates under different names all get claimed by a single matching\n    // manifest entry — otherwise the orphan sweep would drop the un-claimed\n    // siblings even though they are functionally equivalent to the manifest.\n    const dbIndexesByName = new Map<\n      string,\n      { columns: string[]; unique: boolean }\n    >();\n    const dbIndexSignatures = new Map<string, Set<string>>();\n    for (const idx of dbSchema.indexes) {\n      const unique = idx.unique ?? false;\n      dbIndexesByName.set(idx.name, { columns: idx.columns, unique });\n      const signature = this.getIndexSignature(idx.columns, unique);\n      let bucket = dbIndexSignatures.get(signature);\n      if (!bucket) {\n        bucket = new Set();\n        dbIndexSignatures.set(signature, bucket);\n      }\n      bucket.add(idx.name);\n    }\n\n    // Manifest signatures — used during the orphan sweep to skip DB indexes\n    // that match a manifest entry's signature even if no specific manifest\n    // entry \"claimed\" them by name.\n    const manifestSignatureSet = new Set<string>();\n    for (const idx of manifest.indexes) {\n      manifestSignatureSet.add(this.getIndexSignature(idx));\n    }\n\n    // Track which DB indexes a manifest entry has claimed, so the orphan\n    // pass below doesn't re-flag indexes that match by signature alone.\n    const claimedDbIndexes = new Set<string>();\n\n    for (const idx of manifest.indexes) {\n      const manifestSignature = this.getIndexSignature(idx);\n\n      // (a) Same name in DB — verify shape matches.\n      const dbByName = dbIndexesByName.get(idx.name);\n      if (dbByName) {\n        claimedDbIndexes.add(idx.name);\n\n        // JSON-path indexes (`@meta({ indexed: true })`) cannot be reliably\n        // compared by DB introspection — SQLite expression indexes surface\n        // as `[null]` columns, so the signature would always mismatch and\n        // every diff run would emit drop+recreate. Trust the name match\n        // here; if the json path itself changes, the index name changes\n        // too (we encode the field name into it), so a name match is a\n        // stronger guarantee than the column list for this index family.\n        if (isJsonPathIndex(idx)) {\n          continue;\n        }\n\n        const dbSignature = this.getIndexSignature(\n          dbByName.columns,\n          dbByName.unique,\n        );\n        if (dbSignature === manifestSignature) {\n          continue; // Same name, same shape — nothing to do.\n        }\n\n        // Same name, drifted shape. Most often this is a uniqueness flip\n        // (issue #1165: 3-column index materialized non-unique). Recreate.\n        //\n        // Rollback caveat: the auto-generated DOWN script for the\n        // `add_index` half drops the (newly correct) index, and the\n        // `drop_index` half has no DOWN. Rolling back a recreate leaves\n        // the table without the index entirely instead of restoring the\n        // wrong-shape original. Capturing the original shape would\n        // require richer DB introspection than the differ currently has,\n        // so this asymmetry is accepted — the failure mode after an\n        // un-rolled-back recreate is \"missing index\" rather than\n        // \"permanently broken UPSERT,\" which is recoverable.\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n        changes.push({\n          type: 'add_index',\n          table: tableName,\n          name: idx.name,\n          index: idx,\n          sql: this.generateAddIndexSQL(tableName, idx),\n        });\n        continue;\n      }\n\n      // (b) Different name in DB but functionally equivalent — keep as-is.\n      // Claim *every* DB name sharing this signature so duplicate-shape\n      // indexes (e.g., a stale `<name>_idx` plus the implicit `<name>_key`\n      // from the same constraint) all survive the orphan sweep.\n      const equivalentIndexNames = dbIndexSignatures.get(manifestSignature);\n      if (equivalentIndexNames && equivalentIndexNames.size > 0) {\n        for (const name of equivalentIndexNames) {\n          claimedDbIndexes.add(name);\n        }\n        continue;\n      }\n\n      // (c) Genuinely missing — add it.\n      changes.push({\n        type: 'add_index',\n        table: tableName,\n        name: idx.name,\n        index: idx,\n        sql: this.generateAddIndexSQL(tableName, idx),\n      });\n    }\n\n    // Orphan-index sweep (opt-in via includeDroppedIndexes).\n    if (this.options.includeDroppedIndexes) {\n      for (const idx of dbSchema.indexes) {\n        if (claimedDbIndexes.has(idx.name)) continue;\n        if (isProtectedDbIndexName(idx.name)) continue;\n\n        // Belt-and-suspenders: even if a DB index wasn't formally claimed\n        // by a manifest entry (e.g., shape-drift recreate consumed the\n        // claim slot), don't drop it if its signature still matches\n        // something the manifest declares. That would contradict the\n        // option doc (\"not functionally equivalent to anything in the\n        // manifest\") and risk dropping a still-needed index.\n        const idxSignature = this.getIndexSignature(\n          idx.columns,\n          idx.unique ?? false,\n        );\n        if (manifestSignatureSet.has(idxSignature)) continue;\n\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n      }\n    }\n\n    return changes;\n  }\n\n  /**\n   * Generate a signature for an index based on its columns and uniqueness.\n   * Used for functional equivalence checking (Issue #741).\n   *\n   * Note: Column order is preserved because it is semantically significant for\n   * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they\n   * have different query performance characteristics.\n   *\n   * Limitation: Partial indexes (with WHERE clauses) are not fully supported.\n   * The database introspection layer doesn't provide WHERE clause information,\n   * so two partial indexes with the same columns but different WHERE clauses\n   * cannot be distinguished and may be incorrectly treated as equivalent.\n   *\n   * For JSON-path indexes (`@meta({ indexed: true })`) the signature is\n   * derived from the JSON path instead of an empty column list, so the\n   * differ can distinguish two jsonPath indexes against different paths.\n   *\n   * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)\n   * @param uniqueArg - Unique flag (used when first arg is a column array)\n   * @returns Signature string\n   */\n  private getIndexSignature(\n    idxOrColumns: IndexDefinition | string[],\n    uniqueArg?: boolean,\n  ): string {\n    if (Array.isArray(idxOrColumns)) {\n      return `${idxOrColumns.join(',')}:${Boolean(uniqueArg)}`;\n    }\n    const idx = idxOrColumns;\n    if (isJsonPathIndex(idx) && idx.jsonPath) {\n      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}`;\n    }\n    return `${(idx.columns ?? []).join(',')}:${Boolean(idx.unique)}`;\n  }\n\n  /**\n   * Get list of existing tables from database\n   */\n  private async getExistingTables(): Promise<Set<string>> {\n    let query: string;\n    if (this.engine === 'postgres') {\n      query = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;\n    } else {\n      // SQLite and DuckDB\n      query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;\n    }\n\n    const result = await this.db.query(query);\n    const rows = result.rows as { name?: string; table_name?: string }[];\n    return new Set(\n      rows.map((r) => r.name || r.table_name || '').filter(Boolean),\n    );\n  }\n\n  /**\n   * Normalize SQL types for comparison\n   */\n  private normalizeType(type: string): string {\n    const upper = type.toUpperCase().trim();\n\n    // Integer types\n    if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) {\n      return 'INTEGER';\n    }\n\n    // Text types\n    if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) {\n      return 'TEXT';\n    }\n\n    // UUID normalizes to its own bucket — deliberately NOT folded into TEXT.\n    // The text<->uuid drift tolerance (R11) is applied at the equality gate\n    // in `compare()` only, so that `isCompatibleTypeUpgrade` (which also\n    // calls normalizeType) still treats `uuid` as distinct from text and\n    // won't mis-classify e.g. `uuid`->`timestamp` as a compatible\n    // \"TEXT->TIMESTAMP\" upgrade.\n    if (/^UUID$/i.test(upper)) {\n      return 'UUID';\n    }\n\n    // Decimal types\n    if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) {\n      return 'REAL';\n    }\n\n    // Boolean types\n    if (/^(BOOLEAN|BOOL)/i.test(upper)) {\n      return 'BOOLEAN';\n    }\n\n    // Date/time types\n    if (/^(DATETIME|TIMESTAMP|DATE|TIME)/i.test(upper)) {\n      return 'TIMESTAMP';\n    }\n\n    // Blob types\n    if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) {\n      return 'BLOB';\n    }\n\n    // JSON types\n    if (/^(JSON|JSONB)/i.test(upper)) {\n      return 'JSON';\n    }\n\n    return upper;\n  }\n\n  /**\n   * Check if a type change is a safe upgrade that can be auto-migrated.\n   *\n   * SMRT controls the data lifecycle for these columns, so we know:\n   * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)\n   * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings\n   *   before newer manifests normalized the column type.\n   * - INTEGER→REAL: Safe widening of integer to floating point\n   * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for\n   *   legacy integer columns that were previously stored as text/real.\n   *\n   * @param manifestType - The abstract type from the manifest (e.g., 'JSON')\n   * @param dbType - The actual type in the database (e.g., 'TEXT')\n   * @returns true if the change from dbType to manifestType is a safe upgrade\n   */\n  private isCompatibleTypeUpgrade(\n    manifestType: string,\n    dbType: string,\n  ): boolean {\n    const manifest = this.normalizeType(manifestType);\n    const db = this.normalizeType(dbType);\n\n    // TEXT → JSON is safe: SMRT serializes arrays/objects as JSON text\n    // When the manifest says JSON, the data is already valid JSON in TEXT column\n    if (manifest === 'JSON' && db === 'TEXT') {\n      return true;\n    }\n\n    // JSON → TEXT is also safe (downgrade, but data is preserved as-is)\n    if (manifest === 'TEXT' && db === 'JSON') {\n      return true;\n    }\n\n    // UUID → TEXT is safe for plain text/provenance fields that were\n    // mistakenly materialized as native uuid: the stored UUID value can be\n    // rendered losslessly as text.\n    if (manifest === 'TEXT' && db === 'UUID') {\n      return true;\n    }\n\n    // INTEGER → REAL is safe (widening)\n    if (manifest === 'REAL' && db === 'INTEGER') {\n      return true;\n    }\n\n    // PostgreSQL can safely repair legacy integer columns when the generated\n    // migration validates that every existing value is already an integer.\n    if (\n      this.engine === 'postgres' &&\n      manifest === 'INTEGER' &&\n      (db === 'TEXT' || db === 'REAL')\n    ) {\n      return true;\n    }\n\n    // TEXT/JSON → TIMESTAMP is a legacy-drift repair. Invalid values fail\n    // explicitly during migration rather than being silently coerced.\n    if (manifest === 'TIMESTAMP' && (db === 'TEXT' || db === 'JSON')) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Generate SQL for a type upgrade migration.\n   *\n   * Engine-specific SQL:\n   * - SQLite: TEXT and JSON are equivalent, no-op or comment\n   * - DuckDB: ALTER COLUMN TYPE (native type conversion)\n   * - PostgreSQL: ALTER COLUMN TYPE with USING clause\n   */\n  private generateTypeUpgradeSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n    dbType: string,\n  ): GeneratedTypeUpgradeSQL {\n    const quotedTable = this.quoteIdentifier(tableName);\n    const quotedCol = this.quoteIdentifier(colName);\n    const manifestType = colDef.type;\n\n    // Validate manifestType before mapping\n    const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n      ? manifestType\n      : 'TEXT';\n    const targetType = this.ddlStrategy.mapType(validatedType);\n\n    switch (this.engine) {\n      case 'sqlite':\n        // SQLite has dynamic typing - TEXT and JSON are functionally equivalent\n        // For SQLite, we just return a comment since no actual change is needed\n        if (\n          this.normalizeType(manifestType) === 'JSON' &&\n          this.normalizeType(dbType) === 'TEXT'\n        ) {\n          return {\n            sql: `-- SQLite: ${quotedCol} already stores JSON as TEXT (no change needed)`,\n          };\n        }\n        // For other type upgrades, SQLite requires recreating the table\n        return {\n          sql: `-- SQLite: Type upgrade for ${quotedCol} requires table recreation`,\n        };\n\n      case 'postgres': {\n        // PostgreSQL defaults must be dropped/reset around some type changes\n        // so drift repairs can succeed even when an existing default cannot\n        // be cast automatically to the target type.\n        const manifestNormalized = this.normalizeType(manifestType);\n        const dbNormalized = this.normalizeType(dbType);\n        const preflightSQL =\n          manifestNormalized === 'INTEGER' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'REAL')\n            ? this.generatePostgresIntegerPreflightSQL(\n                quotedTable,\n                quotedCol,\n                tableName,\n                colName,\n                dbNormalized,\n              )\n            : null;\n        const clauses: string[] = [];\n\n        if (colDef.defaultValue !== undefined) {\n          clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);\n        }\n\n        let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;\n        if (manifestNormalized === 'JSON' && dbNormalized === 'TEXT') {\n          // #1335: a bare `${col}::jsonb` cast raises \"invalid input syntax for\n          // type json\" on any row whose text is not already valid JSON (e.g. a\n          // legacy enum column holding 'active'). `to_jsonb(col)` instead wraps\n          // ANY text value as a JSON string and never errors, so a genuine\n          // TEXT->JSON widening survives non-JSON legacy data. (Note: with the\n          // json<->text equality tolerance added in this fix, the normal\n          // compare path no longer reaches here; this keeps the SQL safe for\n          // callers that construct a type_upgrade directly.)\n          typeClause += ` USING to_jsonb(${quotedCol})`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'JSON') {\n          // #1335: a native-json column cast back to text is value-preserving\n          // (`::text` renders the stored JSON as its text form), so this arm is\n          // safe. (Note: like the TEXT->JSON arm above, the json<->text equality\n          // tolerance means the normal compare path no longer reaches here; this\n          // keeps the SQL safe for callers that construct a type_upgrade\n          // directly.)\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'UUID') {\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'TEXT'\n        ) {\n          typeClause += ` USING trim(${quotedCol}::text)::integer`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'REAL'\n        ) {\n          typeClause += ` USING ${quotedCol}::integer`;\n        } else if (\n          manifestNormalized === 'TIMESTAMP' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'JSON')\n        ) {\n          typeClause += ` USING NULLIF(NULLIF(trim(both '\"' from ${quotedCol}::text), ''), 'null')::timestamp`;\n        }\n\n        clauses.push(typeClause);\n\n        if (colDef.defaultValue !== undefined) {\n          const formattedDefault = this.ddlStrategy.formatDefaultValue(\n            colDef.defaultValue,\n            validatedType,\n          );\n          const defaultSql =\n            manifestNormalized === 'JSON'\n              ? `${formattedDefault}::${targetType.toLowerCase()}`\n              : formattedDefault;\n          clauses.push(`ALTER COLUMN ${quotedCol} SET DEFAULT ${defaultSql}`);\n        }\n\n        const alterSql = `ALTER TABLE ${quotedTable} ${clauses.join(', ')}`;\n\n        return preflightSQL\n          ? { sql: alterSql, statements: [preflightSQL, alterSql] }\n          : { sql: alterSql };\n      }\n\n      case 'duckdb':\n        // DuckDB supports ALTER COLUMN TYPE for type conversions\n        return {\n          sql: `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${targetType}`,\n        };\n\n      default: {\n        // Escape special characters in type names for safe comment generation\n        const safeDbType = dbType.replace(/[^\\w]/g, '_');\n        const safeManifestType = manifestType.replace(/[^\\w]/g, '_');\n        return {\n          sql: `-- Type upgrade for ${quotedCol}: ${safeDbType} → ${safeManifestType}`,\n        };\n      }\n    }\n  }\n\n  /**\n   * Quote a SQL identifier\n   */\n  private quoteIdentifier(name: string): string {\n    return `\"${name.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  /**\n   * Generate a PostgreSQL preflight guard for narrowing legacy columns to\n   * INTEGER. PostgreSQL's REAL→INTEGER cast rounds fractional values, so the\n   * generated migration must fail before the ALTER can silently change data.\n   */\n  private generatePostgresIntegerPreflightSQL(\n    quotedTable: string,\n    quotedCol: string,\n    tableName: string,\n    colName: string,\n    dbNormalized: string,\n  ): string {\n    const invalidCondition =\n      dbNormalized === 'REAL'\n        ? `${quotedCol} IS NOT NULL AND ${quotedCol} <> trunc(${quotedCol})`\n        : `${quotedCol} IS NOT NULL AND trim(${quotedCol}::text) !~ '^[+-]?[0-9]+$'`;\n    const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;\n\n    return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;\n  }\n\n  private quoteLiteral(value: string): string {\n    return `'${value.replace(/'/g, \"''\")}'`;\n  }\n\n  /**\n   * Generate SQL for adding a column\n   */\n  private generateAddColumnSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n  ): string {\n    // Build the ADD COLUMN definition inline (main) rather than delegating to\n    // the DDL strategy's generateColumnDefinition: that builder is for CREATE\n    // TABLE and would emit `PRIMARY KEY` (invalid in ALTER ... ADD COLUMN) and\n    // suppress single-column UNIQUE on engines that require inline unique at\n    // table-create time (DuckDB) — but an ADD COLUMN has no inline-constraint\n    // pass, so the UNIQUE must be emitted here. mapType still maps abstract\n    // types per dialect (UUID→native uuid / TEXT — R11); invalid types fall\n    // back to TEXT, matching the compareColumns guard.\n    const validatedType: SQLDataType = isValidSQLDataType(colDef.type)\n      ? colDef.type\n      : 'TEXT';\n    if (!isValidSQLDataType(colDef.type)) {\n      logger.warn(\n        `[SchemaComparer] Invalid manifest type \"${colDef.type}\" for ${tableName}.${colName}, treating as TEXT`,\n      );\n    }\n\n    const parts: string[] = [\n      this.quoteIdentifier(colName),\n      this.ddlStrategy.mapType(validatedType),\n    ];\n\n    if (colDef.notNull) {\n      parts.push('NOT NULL');\n    }\n    if (colDef.unique) {\n      parts.push('UNIQUE');\n    }\n    if (colDef.defaultValue !== undefined) {\n      const defaultVal = this.ddlStrategy.formatDefaultValue(\n        colDef.defaultValue,\n        validatedType,\n      );\n      parts.push(`DEFAULT ${defaultVal}`);\n    }\n    if (colDef.check) {\n      parts.push(`CHECK (${colDef.check})`);\n    }\n\n    const columnDefinition = parts.join(' ');\n\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${columnDefinition}`;\n  }\n\n  /**\n   * Generate SQL for dropping a column\n   */\n  private generateDropColumnSQL(tableName: string, colName: string): string {\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;\n  }\n\n  /**\n   * Generate SQL for adding an index\n   */\n  private generateAddIndexSQL(tableName: string, idx: IndexDefinition): string {\n    const uniqueStr = idx.unique ? 'UNIQUE ' : '';\n    const target = renderIndexTarget(idx, this.engine);\n    return `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;\n  }\n\n  /**\n   * Generate SQL for dropping an index.\n   *\n   * This SQL is consumed by the manifest-driven execution path:\n   *\n   * - `db:migrate` runs the SQL we put in `change.sql` directly, with the\n   *   tracker's `executePostgresStatements` adding CONCURRENTLY when\n   *   `--postgres-safe` is on.\n   *\n   * PostgreSQL ends up with `CONCURRENTLY` when it should.\n   * Keeping this method engine-agnostic also means the diff preview text\n   * stays readable (no engine-specific noise) for engines like SQLite\n   * where CONCURRENTLY isn't a thing.\n   */\n  private generateDropIndexSQL(indexName: string): string {\n    return `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`;\n  }\n}\n\n/**\n * Generate a SchemaDiff from manifest and database\n */\nexport async function generateSchemaDiff(\n  db: DatabaseInterface,\n  manifestSchemas: Record<string, SchemaDefinition>,\n  options: DiffOptions = {},\n): Promise<SchemaDiff> {\n  const comparer = new SchemaComparer(db, options);\n  return comparer.compare(manifestSchemas);\n}\n\n/**\n * Check if a diff has any actionable changes (excluding type mismatches)\n */\nexport function hasActionableChanges(diff: SchemaDiff): boolean {\n  if (diff.added_tables.length > 0) return true;\n  if (diff.dropped_tables.length > 0) return true;\n  return diff.changes.some((c) => c.type !== 'type_mismatch');\n}\n\n/**\n * Get SQL statements from a diff for execution\n */\nexport function getSQLFromDiff(diff: SchemaDiff): string[] {\n  const statements: string[] = [];\n\n  // Add table creation (requires full DDL generation - not included here)\n  // This is typically handled by ensureSchema()\n\n  // Add column and index changes\n  for (const change of diff.changes) {\n    if (change.type !== 'type_mismatch') {\n      statements.push(\n        ...(change.sqlStatements ?? (change.sql ? [change.sql] : [])),\n      );\n    }\n  }\n\n  return statements;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"differ.js","sources":["../../src/migrations/differ.ts"],"sourcesContent":["/**\n * Schema Differ\n *\n * Compares manifest schemas to database schemas and generates\n * a SchemaDiff with the differences.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport { detectEngine, getDDLStrategy } from '../schema/ddl/index.js';\nimport type { DatabaseEngine } from '../schema/ddl/types.js';\nimport type {\n  ColumnDefinition,\n  IndexDefinition,\n  SchemaChange,\n  SchemaDefinition,\n  SchemaDiff,\n  SQLDataType,\n} from '../schema/types.js';\nimport { isJsonPathIndex, renderIndexTarget } from '../schema/utils.js';\nimport type { DatabaseInterface, SqlTableSchemaInfo } from './types.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Valid SQLDataType values for validation\n */\nconst VALID_SQL_DATA_TYPES: Set<SQLDataType> = new Set([\n  'TEXT',\n  'INTEGER',\n  'REAL',\n  'BLOB',\n  'BOOLEAN',\n  'JSON',\n  'TIMESTAMP',\n  'UUID',\n]);\n\ninterface GeneratedTypeUpgradeSQL {\n  sql: string;\n  statements?: string[];\n}\n\n/**\n * Check if a string is a valid SQLDataType\n */\nfunction isValidSQLDataType(type: string): type is SQLDataType {\n  return VALID_SQL_DATA_TYPES.has(type as SQLDataType);\n}\n\n/**\n * Options for schema comparison\n */\nexport interface DiffOptions {\n  /** Include dropped tables in diff (default: false for safety) */\n  includeDroppedTables?: boolean;\n  /** Include dropped columns in diff (default: false for safety) */\n  includeDroppedColumns?: boolean;\n  /**\n   * Drop indexes that exist in the database but are absent from the manifest\n   * AND are not functionally equivalent to anything in the manifest. Default:\n   * false. The differ always skips primary-key indexes (`*_pkey`) and the\n   * implicit indexes that PostgreSQL creates from inline UNIQUE constraints\n   * (`*_key`) — those are owned by table-level constraints, not by the\n   * index list, and dropping them here would break the constraint.\n   */\n  includeDroppedIndexes?: boolean;\n  /** Ignore type mismatches (just log warnings) */\n  ignoreTypeMismatches?: boolean;\n  /**\n   * Explicit engine hint forwarded to `detectEngine` when picking the DDL\n   * strategy used for *existing-table* SQL (ALTER/CREATE INDEX/etc.). Use\n   * this when `db.url` is empty or ambiguous (e.g. JSON adapter, in-memory\n   * wrappers where the URL lives on `db.config?.url`). Without it the\n   * comparer falls back to URL-only detection, which can produce SQLite-\n   * flavored SQL on a connection whose caller meant Postgres or DuckDB.\n   */\n  engineHint?: string;\n}\n\n/**\n * Suffix patterns for indexes that the differ refuses to drop.\n * - `_pkey`: PostgreSQL primary key implicit index.\n * - `_key`: PostgreSQL implicit index for inline `UNIQUE (...)` table\n *   constraints. Dropping these by name does not drop the underlying\n *   constraint, and dropping the constraint requires a separate DDL path\n *   (`ALTER TABLE ... DROP CONSTRAINT`) the differ does not emit today.\n */\nconst PROTECTED_INDEX_SUFFIXES = ['_pkey', '_key'];\n\nfunction isProtectedDbIndexName(name: string): boolean {\n  return PROTECTED_INDEX_SUFFIXES.some((suffix) => name.endsWith(suffix));\n}\n\nfunction resolveDatabaseUrl(db: DatabaseInterface): string {\n  const dbWithConfig = db as DatabaseInterface & {\n    config?: { url?: string };\n  };\n  return db.url || dbWithConfig.config?.url || '';\n}\n\n/**\n * SchemaComparer class for comparing manifest schemas to database\n */\nexport class SchemaComparer {\n  private db: DatabaseInterface;\n  private options: DiffOptions;\n  private engine: DatabaseEngine;\n  private ddlStrategy: ReturnType<typeof getDDLStrategy>;\n\n  constructor(db: DatabaseInterface, options: DiffOptions = {}) {\n    this.db = db;\n    this.options = {\n      includeDroppedTables: false,\n      includeDroppedColumns: false,\n      includeDroppedIndexes: false,\n      ignoreTypeMismatches: false,\n      ...options,\n    };\n    // Use the shared detectEngine utility for consistent detection.\n    // Handles :memory:, .json, and other edge cases. The JSON adapter is\n    // detected structurally (it exposes `exportTable`) because its url can be\n    // empty; otherwise fall back to URL-based detection, where `engineHint`\n    // lets callers override when `db.url` is empty or points at an adapter\n    // whose engine isn't obvious from the URL alone (some in-memory wrappers).\n    this.engine =\n      typeof (this.db as { exportTable?: unknown }).exportTable === 'function'\n        ? 'json'\n        : detectEngine(resolveDatabaseUrl(this.db), this.options.engineHint);\n    this.ddlStrategy = getDDLStrategy(this.engine);\n  }\n\n  /**\n   * Compare manifest schemas to database and return differences\n   */\n  async compare(\n    manifestSchemas: Record<string, SchemaDefinition>,\n  ): Promise<SchemaDiff> {\n    const diff: SchemaDiff = {\n      added_tables: [],\n      dropped_tables: [],\n      changes: [],\n      has_changes: false,\n    };\n\n    // Get list of existing tables\n    const existingTables = await this.getExistingTables();\n\n    // Check each manifest schema against database\n    for (const [tableName, schema] of Object.entries(manifestSchemas)) {\n      if (!existingTables.has(tableName)) {\n        // Table doesn't exist - add to added_tables\n        diff.added_tables.push(schema);\n        diff.has_changes = true;\n      } else {\n        // Table exists - compare columns and indexes\n        const tableChanges = await this.compareTable(tableName, schema);\n        if (tableChanges.length > 0) {\n          diff.changes.push(...tableChanges);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    // Check for dropped tables (if enabled)\n    if (this.options.includeDroppedTables) {\n      for (const tableName of existingTables) {\n        // Skip system tables\n        if (tableName.startsWith('_smrt_') || tableName.startsWith('sqlite_')) {\n          continue;\n        }\n        if (!manifestSchemas[tableName]) {\n          diff.dropped_tables.push(tableName);\n          diff.has_changes = true;\n        }\n      }\n    }\n\n    return diff;\n  }\n\n  /**\n   * Compare a single table's schema to manifest\n   */\n  async compareTable(\n    tableName: string,\n    manifest: SchemaDefinition,\n  ): Promise<SchemaChange[]> {\n    const changes: SchemaChange[] = [];\n\n    // Get current table schema from database\n    const dbSchema = await this.db.getTableSchema?.(tableName);\n    if (!dbSchema) {\n      // Table doesn't exist - this is an add_table case\n      return changes;\n    }\n\n    // Compare columns\n    const columnChanges = this.compareColumns(tableName, manifest, dbSchema);\n    changes.push(...columnChanges);\n\n    // Compare indexes\n    const indexChanges = this.compareIndexes(tableName, manifest, dbSchema);\n    changes.push(...indexChanges);\n\n    return changes;\n  }\n\n  /**\n   * Compare columns between manifest and database\n   */\n  private compareColumns(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n    const dbColumnNames = new Set(Object.keys(dbSchema.columns));\n\n    // Check for new and modified columns\n    for (const [colName, colDef] of Object.entries(manifest.columns)) {\n      if (!dbColumnNames.has(colName)) {\n        // Column doesn't exist - add it\n        changes.push({\n          type: 'add_column',\n          table: tableName,\n          name: colName,\n          column: colDef,\n          sql: this.generateAddColumnSQL(tableName, colName, colDef),\n        });\n      } else {\n        // Column exists - check for type mismatch\n        const dbCol = dbSchema.columns[colName];\n\n        // Map manifest's abstract type to engine-specific type\n        // e.g., JSON → TEXT for SQLite, JSON → JSONB for PostgreSQL\n        // Validate the manifest type before mapping\n        const manifestType = colDef.type;\n        if (!isValidSQLDataType(manifestType)) {\n          // Invalid manifest type - treat as TEXT (safest fallback)\n          logger.warn(\n            `[SchemaComparer] Invalid manifest type \"${manifestType}\" for ${tableName}.${colName}, treating as TEXT`,\n          );\n        }\n        const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n          ? manifestType\n          : 'TEXT';\n        const expectedEngineType = this.ddlStrategy.mapType(validatedType);\n        const normalizedExpected = this.normalizeType(expectedEngineType);\n        const normalizedActual = this.normalizeType(dbCol.type);\n\n        // R11: native `uuid` and `text` are interchangeable for SMRT-owned\n        // identifiers/references, but not for arbitrary provenance text. Keep\n        // the tolerance directional:\n        //   - manifest UUID + DB text is tolerated for structural ID/ref\n        //     columns so old deployments are not forced into native UUID.\n        //   - manifest TEXT + DB uuid is tolerated only for structural ID/ref\n        //     columns that are intentionally UUID-compatible.\n        // Plain TEXT columns with DB uuid now surface as repairable drift.\n        const isUuidTextEquivalent = this.isUuidTextEquivalentColumn(\n          colName,\n          colDef,\n          normalizedExpected,\n          normalizedActual,\n        );\n\n        // #1335: native `json`/`jsonb` (DB) and `text` (manifest) are\n        // interchangeable for SMRT — the convention is to serialize JSON values\n        // into TEXT columns, and a native-json column already holds exactly that\n        // data. So the differ must NOT flag a json<->text difference in EITHER\n        // direction:\n        //   - manifest TEXT vs DB json   (native-json column, text-convention manifest)\n        //   - manifest JSON vs DB text   (the canary case: an enum/plain field\n        //     mis-inferred as JSON by a downstream scanner, sitting on a real\n        //     `text` column holding bare values like 'active')\n        // Generating an ALTER here is pure churn at best and data-destroying at\n        // worst: `status::jsonb` on a column holding 'active' raises\n        // \"invalid input syntax for type json\" and aborts the whole atomic\n        // migration. Like the uuid/text tolerance, this lives at the equality\n        // gate only (not in `normalizeType`) so `isCompatibleTypeUpgrade` still\n        // treats JSON and TEXT as distinct buckets for OTHER upgrade paths.\n        const isJsonTextEquivalent =\n          (normalizedExpected === 'JSON' && normalizedActual === 'TEXT') ||\n          (normalizedExpected === 'TEXT' && normalizedActual === 'JSON');\n\n        if (\n          normalizedExpected !== normalizedActual &&\n          !isUuidTextEquivalent &&\n          !isJsonTextEquivalent\n        ) {\n          // Check if this is a safe type upgrade that SMRT can handle\n          // Since SMRT owns the data lifecycle, we know the intent from the manifest\n          if (this.isCompatibleTypeUpgrade(colDef.type, dbCol.type)) {\n            // Generate type upgrade SQL\n            const generatedSQL = this.generateTypeUpgradeSQL(\n              tableName,\n              colName,\n              colDef,\n              dbCol.type,\n            );\n            changes.push({\n              type: 'type_upgrade',\n              table: tableName,\n              name: colName,\n              column: colDef,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n              sql: generatedSQL.sql,\n              ...(generatedSQL.statements\n                ? { sqlStatements: generatedSQL.statements }\n                : {}),\n            });\n          } else if (!this.options.ignoreTypeMismatches) {\n            changes.push({\n              type: 'type_mismatch',\n              table: tableName,\n              name: colName,\n              mismatch: {\n                expected: colDef.type,\n                actual: dbCol.type,\n              },\n            });\n          }\n        }\n      }\n    }\n\n    // Check for dropped columns (if enabled)\n    if (this.options.includeDroppedColumns) {\n      const manifestColumnNames = new Set(Object.keys(manifest.columns));\n      for (const colName of dbColumnNames) {\n        if (!manifestColumnNames.has(colName)) {\n          changes.push({\n            type: 'drop_column',\n            table: tableName,\n            name: colName,\n            sql: this.generateDropColumnSQL(tableName, colName),\n          });\n        }\n      }\n    }\n\n    return changes;\n  }\n\n  private isUuidTextEquivalentColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n    normalizedExpected: string,\n    normalizedActual: string,\n  ): boolean {\n    const expectedUuidActualText =\n      normalizedExpected === 'UUID' && normalizedActual === 'TEXT';\n    const expectedTextActualUuid =\n      normalizedExpected === 'TEXT' && normalizedActual === 'UUID';\n\n    if (!expectedUuidActualText && !expectedTextActualUuid) {\n      return false;\n    }\n\n    return this.isStructuralUuidCompatibleColumn(columnName, colDef);\n  }\n\n  private isStructuralUuidCompatibleColumn(\n    columnName: string,\n    colDef: ColumnDefinition,\n  ): boolean {\n    return (\n      colDef.primaryKey === true ||\n      Boolean(colDef.foreignKey) ||\n      colDef.referenceKind === 'id' ||\n      colDef.referenceKind === 'foreignKey' ||\n      colDef.referenceKind === 'crossPackageRef' ||\n      colDef.referenceKind === 'tenantId' ||\n      (columnName === 'id' && colDef.type === 'TEXT')\n    );\n  }\n\n  /**\n   * Compare indexes between manifest and database\n   *\n   * Three classes of drift the differ now detects:\n   *\n   * 1. **Missing index** — manifest has an index neither the DB has by name\n   *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the\n   *    signature check protects against creating duplicates when STI child\n   *    classes register indexes with different name prefixes.)\n   *\n   * 2. **Same-name shape drift** — DB has an index with the manifest's name,\n   *    but its columns or uniqueness flag differ. This is the failure mode\n   *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is\n   *    non-unique, while the manifest declares it unique. Emit\n   *    `drop_index` + `add_index` so the next migrate cycle recreates it\n   *    with the correct shape.\n   *\n   * 3. **Orphan in DB** — DB has an index with no manifest counterpart by\n   *    name and no signature equivalent. Emit `drop_index` *only* when the\n   *    caller opts in via `includeDroppedIndexes`, and even then never for\n   *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by\n   *    table-level constraints and need a separate `DROP CONSTRAINT` path\n   *    that the differ does not emit yet.\n   */\n  private compareIndexes(\n    tableName: string,\n    manifest: SchemaDefinition,\n    dbSchema: SqlTableSchemaInfo,\n  ): SchemaChange[] {\n    const changes: SchemaChange[] = [];\n\n    // Index DB indexes by name and by signature for fast lookup.\n    // dbIndexSignatures groups *all* DB index names sharing a signature so\n    // duplicates under different names all get claimed by a single matching\n    // manifest entry — otherwise the orphan sweep would drop the un-claimed\n    // siblings even though they are functionally equivalent to the manifest.\n    const dbIndexesByName = new Map<\n      string,\n      { columns: string[]; unique: boolean }\n    >();\n    const dbIndexSignatures = new Map<string, Set<string>>();\n    for (const idx of dbSchema.indexes) {\n      const unique = idx.unique ?? false;\n      dbIndexesByName.set(idx.name, { columns: idx.columns, unique });\n      const signature = this.getIndexSignature(idx.columns, unique);\n      let bucket = dbIndexSignatures.get(signature);\n      if (!bucket) {\n        bucket = new Set();\n        dbIndexSignatures.set(signature, bucket);\n      }\n      bucket.add(idx.name);\n    }\n\n    // Manifest signatures — used during the orphan sweep to skip DB indexes\n    // that match a manifest entry's signature even if no specific manifest\n    // entry \"claimed\" them by name.\n    const manifestSignatureSet = new Set<string>();\n    for (const idx of manifest.indexes) {\n      manifestSignatureSet.add(this.getIndexSignature(idx));\n    }\n\n    // Track which DB indexes a manifest entry has claimed, so the orphan\n    // pass below doesn't re-flag indexes that match by signature alone.\n    const claimedDbIndexes = new Set<string>();\n\n    for (const idx of manifest.indexes) {\n      const manifestSignature = this.getIndexSignature(idx);\n\n      // (a) Same name in DB — verify shape matches.\n      const dbByName = dbIndexesByName.get(idx.name);\n      if (dbByName) {\n        claimedDbIndexes.add(idx.name);\n\n        // JSON-path indexes (`@meta({ indexed: true })`) cannot be reliably\n        // compared by DB introspection — SQLite expression indexes surface\n        // as `[null]` columns, so the signature would always mismatch and\n        // every diff run would emit drop+recreate. Trust the name match\n        // here; if the json path itself changes, the index name changes\n        // too (we encode the field name into it), so a name match is a\n        // stronger guarantee than the column list for this index family.\n        if (isJsonPathIndex(idx)) {\n          continue;\n        }\n\n        const dbSignature = this.getIndexSignature(\n          dbByName.columns,\n          dbByName.unique,\n        );\n        if (dbSignature === manifestSignature) {\n          continue; // Same name, same shape — nothing to do.\n        }\n\n        // Same name, drifted shape. Most often this is a uniqueness flip\n        // (issue #1165: 3-column index materialized non-unique). Recreate.\n        //\n        // Rollback caveat: the auto-generated DOWN script for the\n        // `add_index` half drops the (newly correct) index, and the\n        // `drop_index` half has no DOWN. Rolling back a recreate leaves\n        // the table without the index entirely instead of restoring the\n        // wrong-shape original. Capturing the original shape would\n        // require richer DB introspection than the differ currently has,\n        // so this asymmetry is accepted — the failure mode after an\n        // un-rolled-back recreate is \"missing index\" rather than\n        // \"permanently broken UPSERT,\" which is recoverable.\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n        changes.push({\n          type: 'add_index',\n          table: tableName,\n          name: idx.name,\n          index: idx,\n          sql: this.generateAddIndexSQL(tableName, idx),\n        });\n        continue;\n      }\n\n      // (b) Different name in DB but functionally equivalent — keep as-is.\n      // Claim *every* DB name sharing this signature so duplicate-shape\n      // indexes (e.g., a stale `<name>_idx` plus the implicit `<name>_key`\n      // from the same constraint) all survive the orphan sweep.\n      const equivalentIndexNames = dbIndexSignatures.get(manifestSignature);\n      if (equivalentIndexNames && equivalentIndexNames.size > 0) {\n        for (const name of equivalentIndexNames) {\n          claimedDbIndexes.add(name);\n        }\n        continue;\n      }\n\n      // (c) Genuinely missing — add it.\n      changes.push({\n        type: 'add_index',\n        table: tableName,\n        name: idx.name,\n        index: idx,\n        sql: this.generateAddIndexSQL(tableName, idx),\n      });\n    }\n\n    // Orphan-index sweep (opt-in via includeDroppedIndexes).\n    if (this.options.includeDroppedIndexes) {\n      for (const idx of dbSchema.indexes) {\n        if (claimedDbIndexes.has(idx.name)) continue;\n        if (isProtectedDbIndexName(idx.name)) continue;\n\n        // Belt-and-suspenders: even if a DB index wasn't formally claimed\n        // by a manifest entry (e.g., shape-drift recreate consumed the\n        // claim slot), don't drop it if its signature still matches\n        // something the manifest declares. That would contradict the\n        // option doc (\"not functionally equivalent to anything in the\n        // manifest\") and risk dropping a still-needed index.\n        const idxSignature = this.getIndexSignature(\n          idx.columns,\n          idx.unique ?? false,\n        );\n        if (manifestSignatureSet.has(idxSignature)) continue;\n\n        changes.push({\n          type: 'drop_index',\n          table: tableName,\n          name: idx.name,\n          sql: this.generateDropIndexSQL(idx.name),\n        });\n      }\n    }\n\n    return changes;\n  }\n\n  /**\n   * Generate a signature for an index based on its columns and uniqueness.\n   * Used for functional equivalence checking (Issue #741).\n   *\n   * Note: Column order is preserved because it is semantically significant for\n   * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they\n   * have different query performance characteristics.\n   *\n   * Limitation: Partial indexes (with WHERE clauses) are not fully supported.\n   * The database introspection layer doesn't provide WHERE clause information,\n   * so two partial indexes with the same columns but different WHERE clauses\n   * cannot be distinguished and may be incorrectly treated as equivalent.\n   *\n   * For JSON-path indexes (`@meta({ indexed: true })`) the signature is\n   * derived from the JSON path instead of an empty column list, so the\n   * differ can distinguish two jsonPath indexes against different paths.\n   *\n   * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)\n   * @param uniqueArg - Unique flag (used when first arg is a column array)\n   * @returns Signature string\n   */\n  private getIndexSignature(\n    idxOrColumns: IndexDefinition | string[],\n    uniqueArg?: boolean,\n  ): string {\n    if (Array.isArray(idxOrColumns)) {\n      return `${idxOrColumns.join(',')}:${Boolean(uniqueArg)}`;\n    }\n    const idx = idxOrColumns;\n    if (isJsonPathIndex(idx) && idx.jsonPath) {\n      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}`;\n    }\n    return `${(idx.columns ?? []).join(',')}:${Boolean(idx.unique)}`;\n  }\n\n  /**\n   * Get list of existing tables from database\n   */\n  private async getExistingTables(): Promise<Set<string>> {\n    let query: string;\n    if (this.engine === 'postgres') {\n      query = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;\n    } else {\n      // SQLite and DuckDB\n      query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;\n    }\n\n    const result = await this.db.query(query);\n    const rows = result.rows as { name?: string; table_name?: string }[];\n    return new Set(\n      rows.map((r) => r.name || r.table_name || '').filter(Boolean),\n    );\n  }\n\n  /**\n   * Normalize SQL types for comparison\n   */\n  private normalizeType(type: string): string {\n    const upper = type.toUpperCase().trim();\n\n    // Integer types\n    if (/^(INTEGER|INT|BIGINT|SMALLINT|TINYINT)$/i.test(upper)) {\n      return 'INTEGER';\n    }\n\n    // Text types\n    if (/^(TEXT|CLOB|STRING|VARCHAR|CHAR)/i.test(upper)) {\n      return 'TEXT';\n    }\n\n    // UUID normalizes to its own bucket — deliberately NOT folded into TEXT.\n    // The text<->uuid drift tolerance (R11) is applied at the equality gate\n    // in `compare()` only, so that `isCompatibleTypeUpgrade` (which also\n    // calls normalizeType) still treats `uuid` as distinct from text and\n    // won't mis-classify e.g. `uuid`->`timestamp` as a compatible\n    // \"TEXT->TIMESTAMP\" upgrade.\n    if (/^UUID$/i.test(upper)) {\n      return 'UUID';\n    }\n\n    // Decimal types\n    if (/^(REAL|FLOAT|DOUBLE|DECIMAL|NUMERIC|NUMBER)/i.test(upper)) {\n      return 'REAL';\n    }\n\n    // Boolean types\n    if (/^(BOOLEAN|BOOL)/i.test(upper)) {\n      return 'BOOLEAN';\n    }\n\n    // Date/time types\n    if (/^(DATETIME|TIMESTAMP|DATE|TIME)/i.test(upper)) {\n      return 'TIMESTAMP';\n    }\n\n    // Blob types\n    if (/^(BLOB|BINARY|BYTEA)/i.test(upper)) {\n      return 'BLOB';\n    }\n\n    // JSON types\n    if (/^(JSON|JSONB)/i.test(upper)) {\n      return 'JSON';\n    }\n\n    return upper;\n  }\n\n  /**\n   * Check if a type change is a safe upgrade that can be auto-migrated.\n   *\n   * SMRT controls the data lifecycle for these columns, so we know:\n   * - TEXT→JSON: The column stores JSON data serialized as text (arrays, objects)\n   * - TEXT/JSON→TIMESTAMP: Legacy system columns stored timestamp strings\n   *   before newer manifests normalized the column type.\n   * - INTEGER→REAL: Safe widening of integer to floating point\n   * - TEXT/REAL→INTEGER on PostgreSQL: explicit data-checked repairs for\n   *   legacy integer columns that were previously stored as text/real.\n   *\n   * @param manifestType - The abstract type from the manifest (e.g., 'JSON')\n   * @param dbType - The actual type in the database (e.g., 'TEXT')\n   * @returns true if the change from dbType to manifestType is a safe upgrade\n   */\n  private isCompatibleTypeUpgrade(\n    manifestType: string,\n    dbType: string,\n  ): boolean {\n    const manifest = this.normalizeType(manifestType);\n    const db = this.normalizeType(dbType);\n\n    // TEXT → JSON is safe: SMRT serializes arrays/objects as JSON text\n    // When the manifest says JSON, the data is already valid JSON in TEXT column\n    if (manifest === 'JSON' && db === 'TEXT') {\n      return true;\n    }\n\n    // JSON → TEXT is also safe (downgrade, but data is preserved as-is)\n    if (manifest === 'TEXT' && db === 'JSON') {\n      return true;\n    }\n\n    // UUID → TEXT is safe for plain text/provenance fields that were\n    // mistakenly materialized as native uuid: the stored UUID value can be\n    // rendered losslessly as text.\n    if (manifest === 'TEXT' && db === 'UUID') {\n      return true;\n    }\n\n    // INTEGER → REAL is safe (widening)\n    if (manifest === 'REAL' && db === 'INTEGER') {\n      return true;\n    }\n\n    // PostgreSQL can safely repair legacy integer columns when the generated\n    // migration validates that every existing value is already an integer.\n    if (\n      this.engine === 'postgres' &&\n      manifest === 'INTEGER' &&\n      (db === 'TEXT' || db === 'REAL')\n    ) {\n      return true;\n    }\n\n    // TEXT/JSON → TIMESTAMP is a legacy-drift repair. Invalid values fail\n    // explicitly during migration rather than being silently coerced.\n    if (manifest === 'TIMESTAMP' && (db === 'TEXT' || db === 'JSON')) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Generate SQL for a type upgrade migration.\n   *\n   * Engine-specific SQL:\n   * - SQLite: TEXT and JSON are equivalent, no-op or comment\n   * - DuckDB: ALTER COLUMN TYPE (native type conversion)\n   * - PostgreSQL: ALTER COLUMN TYPE with USING clause\n   */\n  private generateTypeUpgradeSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n    dbType: string,\n  ): GeneratedTypeUpgradeSQL {\n    const quotedTable = this.quoteIdentifier(tableName);\n    const quotedCol = this.quoteIdentifier(colName);\n    const manifestType = colDef.type;\n\n    // Validate manifestType before mapping\n    const validatedType: SQLDataType = isValidSQLDataType(manifestType)\n      ? manifestType\n      : 'TEXT';\n    const targetType = this.ddlStrategy.mapType(validatedType);\n\n    switch (this.engine) {\n      case 'sqlite':\n        // SQLite has dynamic typing - TEXT and JSON are functionally equivalent\n        // For SQLite, we just return a comment since no actual change is needed\n        if (\n          this.normalizeType(manifestType) === 'JSON' &&\n          this.normalizeType(dbType) === 'TEXT'\n        ) {\n          return {\n            sql: `-- SQLite: ${quotedCol} already stores JSON as TEXT (no change needed)`,\n          };\n        }\n        // For other type upgrades, SQLite requires recreating the table\n        return {\n          sql: `-- SQLite: Type upgrade for ${quotedCol} requires table recreation`,\n        };\n\n      case 'postgres': {\n        // PostgreSQL defaults must be dropped/reset around some type changes\n        // so drift repairs can succeed even when an existing default cannot\n        // be cast automatically to the target type.\n        const manifestNormalized = this.normalizeType(manifestType);\n        const dbNormalized = this.normalizeType(dbType);\n        const preflightSQL =\n          manifestNormalized === 'INTEGER' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'REAL')\n            ? this.generatePostgresIntegerPreflightSQL(\n                quotedTable,\n                quotedCol,\n                tableName,\n                colName,\n                dbNormalized,\n              )\n            : null;\n        const clauses: string[] = [];\n\n        if (colDef.defaultValue !== undefined) {\n          clauses.push(`ALTER COLUMN ${quotedCol} DROP DEFAULT`);\n        }\n\n        let typeClause = `ALTER COLUMN ${quotedCol} TYPE ${targetType}`;\n        if (manifestNormalized === 'JSON' && dbNormalized === 'TEXT') {\n          // #1335: a bare `${col}::jsonb` cast raises \"invalid input syntax for\n          // type json\" on any row whose text is not already valid JSON (e.g. a\n          // legacy enum column holding 'active'). `to_jsonb(col)` instead wraps\n          // ANY text value as a JSON string and never errors, so a genuine\n          // TEXT->JSON widening survives non-JSON legacy data. (Note: with the\n          // json<->text equality tolerance added in this fix, the normal\n          // compare path no longer reaches here; this keeps the SQL safe for\n          // callers that construct a type_upgrade directly.)\n          typeClause += ` USING to_jsonb(${quotedCol})`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'JSON') {\n          // #1335: a native-json column cast back to text is value-preserving\n          // (`::text` renders the stored JSON as its text form), so this arm is\n          // safe. (Note: like the TEXT->JSON arm above, the json<->text equality\n          // tolerance means the normal compare path no longer reaches here; this\n          // keeps the SQL safe for callers that construct a type_upgrade\n          // directly.)\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (manifestNormalized === 'TEXT' && dbNormalized === 'UUID') {\n          typeClause += ` USING ${quotedCol}::text`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'TEXT'\n        ) {\n          typeClause += ` USING trim(${quotedCol}::text)::integer`;\n        } else if (\n          manifestNormalized === 'INTEGER' &&\n          dbNormalized === 'REAL'\n        ) {\n          typeClause += ` USING ${quotedCol}::integer`;\n        } else if (\n          manifestNormalized === 'TIMESTAMP' &&\n          (dbNormalized === 'TEXT' || dbNormalized === 'JSON')\n        ) {\n          typeClause += ` USING NULLIF(NULLIF(trim(both '\"' from ${quotedCol}::text), ''), 'null')::timestamp`;\n        }\n\n        clauses.push(typeClause);\n\n        if (colDef.defaultValue !== undefined) {\n          const formattedDefault = this.ddlStrategy.formatDefaultValue(\n            colDef.defaultValue,\n            validatedType,\n          );\n          const defaultSql =\n            manifestNormalized === 'JSON'\n              ? `${formattedDefault}::${targetType.toLowerCase()}`\n              : formattedDefault;\n          clauses.push(`ALTER COLUMN ${quotedCol} SET DEFAULT ${defaultSql}`);\n        }\n\n        const alterSql = `ALTER TABLE ${quotedTable} ${clauses.join(', ')}`;\n\n        return preflightSQL\n          ? { sql: alterSql, statements: [preflightSQL, alterSql] }\n          : { sql: alterSql };\n      }\n\n      case 'duckdb':\n        // DuckDB supports ALTER COLUMN TYPE for type conversions\n        return {\n          sql: `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${targetType}`,\n        };\n\n      default: {\n        // Escape special characters in type names for safe comment generation\n        const safeDbType = dbType.replace(/[^\\w]/g, '_');\n        const safeManifestType = manifestType.replace(/[^\\w]/g, '_');\n        return {\n          sql: `-- Type upgrade for ${quotedCol}: ${safeDbType} → ${safeManifestType}`,\n        };\n      }\n    }\n  }\n\n  /**\n   * Quote a SQL identifier\n   */\n  private quoteIdentifier(name: string): string {\n    return `\"${name.replace(/\"/g, '\"\"')}\"`;\n  }\n\n  /**\n   * Generate a PostgreSQL preflight guard for narrowing legacy columns to\n   * INTEGER. PostgreSQL's REAL→INTEGER cast rounds fractional values, so the\n   * generated migration must fail before the ALTER can silently change data.\n   */\n  private generatePostgresIntegerPreflightSQL(\n    quotedTable: string,\n    quotedCol: string,\n    tableName: string,\n    colName: string,\n    dbNormalized: string,\n  ): string {\n    const invalidCondition =\n      dbNormalized === 'REAL'\n        ? `${quotedCol} IS NOT NULL AND ${quotedCol} <> trunc(${quotedCol})`\n        : `${quotedCol} IS NOT NULL AND trim(${quotedCol}::text) !~ '^[+-]?[0-9]+$'`;\n    const message = `Cannot convert ${tableName}.${colName} to INTEGER: found non-integer values`;\n\n    return `DO $$ BEGIN IF EXISTS (SELECT 1 FROM ${quotedTable} WHERE ${invalidCondition}) THEN RAISE EXCEPTION ${this.quoteLiteral(message)}; END IF; END $$`;\n  }\n\n  private quoteLiteral(value: string): string {\n    return `'${value.replace(/'/g, \"''\")}'`;\n  }\n\n  /**\n   * Generate SQL for adding a column\n   */\n  private generateAddColumnSQL(\n    tableName: string,\n    colName: string,\n    colDef: ColumnDefinition,\n  ): string {\n    // Build the ADD COLUMN definition inline (main) rather than delegating to\n    // the DDL strategy's generateColumnDefinition: that builder is for CREATE\n    // TABLE and would emit `PRIMARY KEY` (invalid in ALTER ... ADD COLUMN) and\n    // suppress single-column UNIQUE on engines that require inline unique at\n    // table-create time (DuckDB) — but an ADD COLUMN has no inline-constraint\n    // pass, so the UNIQUE must be emitted here. mapType still maps abstract\n    // types per dialect (UUID→native uuid / TEXT — R11); invalid types fall\n    // back to TEXT, matching the compareColumns guard.\n    const validatedType: SQLDataType = isValidSQLDataType(colDef.type)\n      ? colDef.type\n      : 'TEXT';\n    if (!isValidSQLDataType(colDef.type)) {\n      logger.warn(\n        `[SchemaComparer] Invalid manifest type \"${colDef.type}\" for ${tableName}.${colName}, treating as TEXT`,\n      );\n    }\n\n    const parts: string[] = [\n      this.quoteIdentifier(colName),\n      this.ddlStrategy.mapType(validatedType),\n    ];\n\n    if (colDef.notNull) {\n      parts.push('NOT NULL');\n    }\n    if (colDef.unique) {\n      parts.push('UNIQUE');\n    }\n    if (colDef.defaultValue !== undefined) {\n      const defaultVal = this.ddlStrategy.formatDefaultValue(\n        colDef.defaultValue,\n        validatedType,\n      );\n      parts.push(`DEFAULT ${defaultVal}`);\n    }\n    if (colDef.check) {\n      parts.push(`CHECK (${colDef.check})`);\n    }\n\n    const columnDefinition = parts.join(' ');\n\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} ADD COLUMN ${columnDefinition}`;\n  }\n\n  /**\n   * Generate SQL for dropping a column\n   */\n  private generateDropColumnSQL(tableName: string, colName: string): string {\n    return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;\n  }\n\n  /**\n   * Generate SQL for adding an index\n   */\n  private generateAddIndexSQL(tableName: string, idx: IndexDefinition): string {\n    const uniqueStr = idx.unique ? 'UNIQUE ' : '';\n    const target = renderIndexTarget(idx, this.engine);\n    return `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;\n  }\n\n  /**\n   * Generate SQL for dropping an index.\n   *\n   * This SQL is consumed by the manifest-driven execution path:\n   *\n   * - `db:migrate` runs the SQL we put in `change.sql` directly, with the\n   *   tracker's `executePostgresStatements` adding CONCURRENTLY when\n   *   `--postgres-safe` is on.\n   *\n   * PostgreSQL ends up with `CONCURRENTLY` when it should.\n   * Keeping this method engine-agnostic also means the diff preview text\n   * stays readable (no engine-specific noise) for engines like SQLite\n   * where CONCURRENTLY isn't a thing.\n   */\n  private generateDropIndexSQL(indexName: string): string {\n    return `DROP INDEX IF EXISTS ${this.quoteIdentifier(indexName)}`;\n  }\n}\n\n/**\n * Generate a SchemaDiff from manifest and database\n */\nexport async function generateSchemaDiff(\n  db: DatabaseInterface,\n  manifestSchemas: Record<string, SchemaDefinition>,\n  options: DiffOptions = {},\n): Promise<SchemaDiff> {\n  const comparer = new SchemaComparer(db, options);\n  return comparer.compare(manifestSchemas);\n}\n\n/**\n * Check if a diff has any actionable changes (excluding type mismatches)\n */\nexport function hasActionableChanges(diff: SchemaDiff): boolean {\n  if (diff.added_tables.length > 0) return true;\n  if (diff.dropped_tables.length > 0) return true;\n  return diff.changes.some((c) => c.type !== 'type_mismatch');\n}\n\n/**\n * Get SQL statements from a diff for execution\n */\nexport function getSQLFromDiff(diff: SchemaDiff): string[] {\n  const statements: string[] = [];\n\n  // Add table creation (requires full DDL generation - not included here)\n  // This is typically handled by ensureSchema()\n\n  // Add column and index changes\n  for (const change of diff.changes) {\n    if (change.type !== 'type_mismatch') {\n      statements.push(\n        ...(change.sqlStatements ?? (change.sql ? [change.sql] : [])),\n      );\n    }\n  }\n\n  return statements;\n}\n"],"names":[],"mappings":"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"}

package/dist/scanner/manifest-generator.d.ts

@@ -1,4 +1,11 @@
 import { ScanResult, SmartObjectManifest, SmrtVisibility } from './types.js';
+/** Package.json shape consumed for import-path and component discovery. */
+interface PackageJsonLike {
+    name?: string;
+    main?: string;
+    exports?: Record<string, unknown>;
+    [key: string]: unknown;
+}
 export declare class ManifestGenerator {
     /**
      * Generate manifest from scan results
@@ -16,7 +23,7 @@ export declare class ManifestGenerator {
     generateManifest(scanResults: ScanResult[], options?: {
         packageName?: string;
         packageVersion?: string;
-        packageJson?: any;
+        packageJson?: PackageJsonLike;
         smrtDependencies?: string[];
         includeVisibility?: SmrtVisibility[];
     }): SmartObjectManifest;
@@ -272,7 +279,7 @@ export declare class ManifestGenerator {
      * @param packageName - Package name for component export paths
      * @param packageJson - Full package.json for component discovery
      */
-    generateAgentManifests(manifest: SmartObjectManifest, packageName?: string, packageJson?: any): void;
+    generateAgentManifests(manifest: SmartObjectManifest, packageName?: string, packageJson?: PackageJsonLike): void;
     /**
      * Get deduplicated list of method names exposed via CLI and MCP config
      */
@@ -299,8 +306,9 @@ export declare class ManifestGenerator {
 export declare function generateManifest(scanResults: ScanResult[], options?: {
     packageName?: string;
     packageVersion?: string;
-    packageJson?: any;
+    packageJson?: PackageJsonLike;
     smrtDependencies?: string[];
     includeVisibility?: SmrtVisibility[];
 }): SmartObjectManifest;
+export {};
 //# sourceMappingURL=manifest-generator.d.ts.map

package/dist/scanner/manifest-generator.d.ts.map

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

package/dist/scanner/manifest-generator.js

@@ -327,6 +327,8 @@ ${failures.map((failure) => `  - ${failure}`).join("\n")}`
             rules.push({
               field: fieldName,
               rule: "pattern",
+              // RegExp patterns expose `.source`; a JSON-collapsed RegExp ({})
+              // has none, preserving the prior `undefined` value exactly.
               value: typeof pattern === "string" ? pattern : pattern.source,
               fieldType: field.type
             });
@@ -506,20 +508,21 @@ ${failures.map((failure) => `  - ${failure}`).join("\n")}`
     return obj.schema?.tableName || obj.decoratorConfig?.tableName || this.classNameToTableName(obj.className);
   }
   refreshManifestSchemaDDL(schema, generator, owner, manifest) {
+    const columns = {};
+    for (const [name, column] of Object.entries(schema.columns)) {
+      columns[name] = {
+        // ManifestColumnDefinition stores `type` as a plain string; it is
+        // always a valid SQLDataType for DDL rendering.
+        type: column.type,
+        primaryKey: column.primaryKey,
+        notNull: column.notNull,
+        unique: column.unique,
+        defaultValue: column.default
+      };
+    }
     const schemaDefinition = {
       tableName: schema.tableName,
-      columns: Object.fromEntries(
-        Object.entries(schema.columns).map(([name, column]) => [
-          name,
-          {
-            type: column.type,
-            primaryKey: column.primaryKey,
-            notNull: column.notNull,
-            unique: column.unique,
-            defaultValue: column.default
-          }
-        ])
-      ),
+      columns,
       indexes: (schema.indexes || []).map((index) => ({
         name: index.name,
         columns: index.columns,
@@ -1177,11 +1180,12 @@ ${failures.map((failure) => `  - ${failure}`).join("\n")}`
       }
       const mainExport = packageJson.exports["."];
       if (mainExport) {
-        if (typeof mainExport === "object") {
-          if (mainExport.import) {
+        if (mainExport && typeof mainExport === "object") {
+          const conditional = mainExport;
+          if (conditional.import) {
             return packageName;
           }
-          if (mainExport.default) {
+          if (conditional.default) {
             return packageName;
           }
         }