@happyvertical/smrt-core 0.37.0 → 0.37.1

package/dist/manifest.json

@@ -1,8 +1,8 @@
 {
   "version": "1.0.0",
-  "timestamp": 1782683418480,
+  "timestamp": 1782792357137,
   "packageName": "@happyvertical/smrt-core",
-  "packageVersion": "0.37.0",
+  "packageVersion": "0.37.1",
   "objects": {
     "@happyvertical/smrt-core:SmrtClass": {
       "name": "smrtclass",

package/dist/migrations/differ.d.ts

@@ -29,6 +29,35 @@ export interface DiffOptions {
      */
     engineHint?: string;
 }
+/**
+ * Normalize a partial-index `WHERE` predicate so semantically-identical
+ * clauses from different sources compare equal (issue #1692).
+ *
+ * The manifest stores predicates roughly as written (`_meta_type = 'Article'`),
+ * SQLite/DuckDB echo the original CREATE INDEX text verbatim, and PostgreSQL
+ * re-renders them with type casts and extra parentheses
+ * (`((_meta_type)::text = 'Article'::text)`). Normalization:
+ *
+ * - strips a leading `WHERE` keyword,
+ * - removes PostgreSQL `::type` casts (single-word type names — the only kind
+ *   SMRT-generated partial predicates produce, e.g. `_meta_type::text`),
+ * - removes parentheses (SMRT only emits simple `col = 'literal'` predicates,
+ *   so grouping carries no meaning here),
+ * - lowercases everything OUTSIDE single-quoted string literals (SQL keywords
+ *   and identifiers are case-insensitive; literals such as STI discriminator
+ *   class names are case-sensitive, so they are preserved verbatim),
+ * - collapses whitespace and tightens spacing around comparison operators.
+ *
+ * Returns '' for an absent/empty predicate (i.e. a non-partial index).
+ */
+export declare function normalizeIndexPredicate(where?: string | null): string;
+/**
+ * Extract the normalized partial-index predicate from a `CREATE INDEX`
+ * statement — the `WHERE` tail that follows the column-list close paren.
+ * Works for both SQLite/DuckDB `sqlite_master.sql` text and PostgreSQL
+ * `pg_indexes.indexdef`. Returns '' for a non-partial index.
+ */
+export declare function extractIndexPredicate(createIndexSql: string): string;
 /**
  * SchemaComparer class for comparing manifest schemas to database
  */
@@ -55,7 +84,7 @@ export declare class SchemaComparer {
     /**
      * Compare indexes between manifest and database
      *
-     * Three classes of drift the differ now detects:
+     * Four classes of drift the differ now detects:
      *
      * 1. **Missing index** — manifest has an index neither the DB has by name
      *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the
@@ -63,11 +92,13 @@ export declare class SchemaComparer {
      *    classes register indexes with different name prefixes.)
      *
      * 2. **Same-name shape drift** — DB has an index with the manifest's name,
-     *    but its columns or uniqueness flag differ. This is the failure mode
-     *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is
-     *    non-unique, while the manifest declares it unique. Emit
-     *    `drop_index` + `add_index` so the next migrate cycle recreates it
-     *    with the correct shape.
+     *    but its columns, uniqueness flag, or partial-index `WHERE` predicate
+     *    differ. This covers the uniqueness flip in issue #1165
+     *    (`tenants_slug_context_meta_type_idx` materialized non-unique while
+     *    the manifest declares it unique) and the predicate drift in issue
+     *    #1692 (a partial index whose `WHERE` clause was added, removed, or
+     *    altered). Emit `drop_index` + `add_index` so the next migrate cycle
+     *    recreates it with the correct shape.
      *
      * 3. **Orphan in DB** — DB has an index with no manifest counterpart by
      *    name and no signature equivalent. Emit `drop_index` *only* when the
@@ -75,20 +106,36 @@ export declare class SchemaComparer {
      *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by
      *    table-level constraints and need a separate `DROP CONSTRAINT` path
      *    that the differ does not emit yet.
+     *
+     * 4. **Partial-index predicate drift / collision** — two indexes on the
+     *    same column(s) and uniqueness that differ only by their `WHERE`
+     *    predicate (e.g. distinct STI child partial indexes) are no longer
+     *    collapsed to one signature, so the signature-equivalence path (b)
+     *    won't claim one for the other.
+     *
+     * @param dbIndexPredicates - Normalized `WHERE` predicate per DB index
+     *   name from {@link getDbIndexPredicates}. `null` means predicate
+     *   introspection was unavailable for this engine/adapter, in which case
+     *   the comparison falls back to predicate-unaware signatures (the prior
+     *   behavior) so existing partial indexes are never flagged as false drift.
      */
     private compareIndexes;
     /**
-     * Generate a signature for an index based on its columns and uniqueness.
-     * Used for functional equivalence checking (Issue #741).
+     * Generate a signature for an index based on its columns, uniqueness, and
+     * (normalized) partial-index predicate. Used for functional equivalence
+     * checking (Issue #741) and predicate-drift detection (Issue #1692).
      *
      * Note: Column order is preserved because it is semantically significant for
      * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they
      * have different query performance characteristics.
      *
-     * Limitation: Partial indexes (with WHERE clauses) are not fully supported.
-     * The database introspection layer doesn't provide WHERE clause information,
-     * so two partial indexes with the same columns but different WHERE clauses
-     * cannot be distinguished and may be incorrectly treated as equivalent.
+     * The trailing predicate component distinguishes partial indexes that share
+     * columns and uniqueness but differ by their `WHERE` clause (e.g. distinct
+     * STI child partial indexes). Callers pass the already-normalized predicate
+     * so both the manifest (desired) and introspected (DB) sides compare equal
+     * for semantically-identical clauses. An empty string means "no predicate"
+     * (a non-partial index) and is also used on both sides when predicate
+     * introspection is unavailable, preserving the prior behavior.
      *
      * For JSON-path indexes (`@meta({ indexed: true })`) the signature is
      * derived from the JSON path instead of an empty column list, so the
@@ -96,9 +143,44 @@ export declare class SchemaComparer {
      *
      * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)
      * @param uniqueArg - Unique flag (used when first arg is a column array)
+     * @param predicateArg - Normalized partial-index predicate (default '')
      * @returns Signature string
      */
     private getIndexSignature;
+    /**
+     * Whether the active engine supports partial indexes (`CREATE INDEX … WHERE`).
+     *
+     * SQLite and PostgreSQL do. DuckDB rejects them outright, and the JSON
+     * adapter is DuckDB-backed, so on those engines a "partial" index can only
+     * ever exist as a full index. Treating the predicate as significant there
+     * would (a) flag existing full indexes as false drift and (b) emit
+     * `CREATE INDEX … WHERE` DDL the engine rejects, breaking the migration.
+     * Gating on this keeps both the comparison and the generated DDL aligned
+     * with what the engine actually accepts (a partial index degrades to a
+     * full index), matching the pre-#1692 behavior on those engines.
+     */
+    private supportsPartialIndexes;
+    /**
+     * Introspect partial-index predicates for a table, keyed by index name.
+     *
+     * `getTableSchema()` (the @happyvertical/sql introspection) returns only
+     * name/columns/unique, so the `WHERE` predicate is read directly here:
+     *
+     * - PostgreSQL: `pg_indexes.indexdef` carries the full CREATE INDEX text.
+     * - SQLite: the `sqlite_master.sql` column carries the original CREATE INDEX
+     *   text.
+     *
+     * Engines that don't support partial indexes (DuckDB / the DuckDB-backed
+     * JSON adapter) short-circuit to `null` so the comparison stays
+     * predicate-unaware there — see {@link supportsPartialIndexes}.
+     *
+     * Non-partial indexes are omitted from the map (callers treat a missing
+     * entry as the empty predicate). Returns `null` when the catalog query
+     * fails — e.g. an adapter exposing neither catalog — so the index
+     * comparison can fall back to predicate-unaware behavior rather than
+     * flagging every existing partial index as false drift.
+     */
+    private getDbIndexPredicates;
     /**
      * Get list of existing tables from database
      */
@@ -152,7 +234,16 @@ export declare class SchemaComparer {
      */
     private generateDropColumnSQL;
     /**
-     * Generate SQL for adding an index
+     * Generate SQL for adding an index.
+     *
+     * On engines that support partial indexes (SQLite/PostgreSQL) this mirrors
+     * the canonical CREATE INDEX path in the DDL strategies: a partial index
+     * appends its `WHERE` predicate so a detected predicate add/alter (issue
+     * #1692) recreates the index with the correct partial condition rather than
+     * silently widening it to a full index. On DuckDB / the JSON adapter — which
+     * reject partial indexes — the predicate is dropped so the emitted DDL stays
+     * executable (a partial index degrades to a full index there). The predicate
+     * is trimmed and a redundant leading `WHERE` stripped for robustness.
      */
     private generateAddIndexSQL;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAGV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,YAAY,CAAC;AA8BxE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAoC;gBAE3C,EAAE,EAAE,iBAAiB,EAAE,OAAO,GAAE,WAAgB;IAsB5D;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC;IA4CtB;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC;IAqB1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwItB,OAAO,CAAC,0BAA0B;IAkBlC,OAAO,CAAC,gCAAgC;IAexC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,cAAc;IAoJtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,iBAAiB;IAgB/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAoI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAgB3C,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,iBAAiB,EACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBzD"}
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/migrations/differ.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAGV,YAAY,EACZ,gBAAgB,EAChB,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,iBAAiB,EAAsB,MAAM,YAAY,CAAC;AA8BxE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iDAAiD;IACjD,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAuBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAsCrE;AAiBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,OAAO,CAAc;IAC7B,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,WAAW,CAAoC;gBAE3C,EAAE,EAAE,iBAAiB,EAAE,OAAO,GAAE,WAAgB;IAsB5D;;OAEG;IACG,OAAO,CACX,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,UAAU,CAAC;IA4CtB;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,EAAE,CAAC;IAkC1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAwItB,OAAO,CAAC,0BAA0B;IAkBlC,OAAO,CAAC,gCAAgC;IAexC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,OAAO,CAAC,cAAc;IA2KtB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,iBAAiB;IAezB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,sBAAsB;IAI9B;;;;;;;;;;;;;;;;;;;OAmBG;YACW,oBAAoB;IAmDlC;;OAEG;YACW,iBAAiB;IAoB/B;;OAEG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,uBAAuB;IAiD/B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAoI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;;;OAIG;IACH,OAAO,CAAC,mCAAmC;IAgB3C,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAW3B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,oBAAoB;CAG7B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,iBAAiB,EACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,WAAgB,GACxB,OAAO,CAAC,UAAU,CAAC,CAGrB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAI9D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAgBzD"}

package/dist/migrations/differ.js

@@ -25,6 +25,50 @@ function resolveDatabaseUrl(db) {
   const dbWithConfig = db;
   return db.url || dbWithConfig.config?.url || "";
 }
+function normalizeIndexPredicate(where) {
+  if (!where) return "";
+  const stripped = where.trim().replace(/^WHERE\s+/i, "");
+  if (!stripped) return "";
+  let out = "";
+  let i = 0;
+  while (i < stripped.length) {
+    if (stripped[i] === "'") {
+      let literal = "'";
+      i++;
+      while (i < stripped.length) {
+        if (stripped[i] === "'") {
+          if (stripped[i + 1] === "'") {
+            literal += "''";
+            i += 2;
+            continue;
+          }
+          literal += "'";
+          i++;
+          break;
+        }
+        literal += stripped[i];
+        i++;
+      }
+      out += literal;
+    } else {
+      let run = "";
+      while (i < stripped.length && stripped[i] !== "'") {
+        run += stripped[i];
+        i++;
+      }
+      out += normalizeNonLiteralPredicateRun(run);
+    }
+  }
+  return out;
+}
+function normalizeNonLiteralPredicateRun(run) {
+  return run.replace(/::[A-Za-z_]\w*/g, "").replace(/[()]/g, "").toLowerCase().replace(/\s+/g, " ").replace(/\s*([=<>!]+)\s*/g, "$1").trim();
+}
+function extractIndexPredicate(createIndexSql) {
+  const match = createIndexSql.match(/\)\s*WHERE\s+([\s\S]+?)\s*;?\s*$/i);
+  if (!match) return "";
+  return normalizeIndexPredicate(match[1]);
+}
 class SchemaComparer {
   db;
   options;
@@ -89,7 +133,13 @@ class SchemaComparer {
     }
     const columnChanges = this.compareColumns(tableName, manifest, dbSchema);
     changes.push(...columnChanges);
-    const indexChanges = this.compareIndexes(tableName, manifest, dbSchema);
+    const dbIndexPredicates = await this.getDbIndexPredicates(tableName);
+    const indexChanges = this.compareIndexes(
+      tableName,
+      manifest,
+      dbSchema,
+      dbIndexPredicates
+    );
     changes.push(...indexChanges);
     return changes;
   }
@@ -190,7 +240,7 @@ class SchemaComparer {
   /**
    * Compare indexes between manifest and database
    *
-   * Three classes of drift the differ now detects:
+   * Four classes of drift the differ now detects:
    *
    * 1. **Missing index** — manifest has an index neither the DB has by name
    *    nor any equivalent-by-signature. Emit `add_index`. (Issue #741: the
@@ -198,11 +248,13 @@ class SchemaComparer {
    *    classes register indexes with different name prefixes.)
    *
    * 2. **Same-name shape drift** — DB has an index with the manifest's name,
-   *    but its columns or uniqueness flag differ. This is the failure mode
-   *    in issue #1165: `tenants_slug_context_meta_type_idx` exists but is
-   *    non-unique, while the manifest declares it unique. Emit
-   *    `drop_index` + `add_index` so the next migrate cycle recreates it
-   *    with the correct shape.
+   *    but its columns, uniqueness flag, or partial-index `WHERE` predicate
+   *    differ. This covers the uniqueness flip in issue #1165
+   *    (`tenants_slug_context_meta_type_idx` materialized non-unique while
+   *    the manifest declares it unique) and the predicate drift in issue
+   *    #1692 (a partial index whose `WHERE` clause was added, removed, or
+   *    altered). Emit `drop_index` + `add_index` so the next migrate cycle
+   *    recreates it with the correct shape.
    *
    * 3. **Orphan in DB** — DB has an index with no manifest counterpart by
    *    name and no signature equivalent. Emit `drop_index` *only* when the
@@ -210,15 +262,34 @@ class SchemaComparer {
    *    PostgreSQL implicit indexes (`*_pkey`, `*_key`) — those are owned by
    *    table-level constraints and need a separate `DROP CONSTRAINT` path
    *    that the differ does not emit yet.
+   *
+   * 4. **Partial-index predicate drift / collision** — two indexes on the
+   *    same column(s) and uniqueness that differ only by their `WHERE`
+   *    predicate (e.g. distinct STI child partial indexes) are no longer
+   *    collapsed to one signature, so the signature-equivalence path (b)
+   *    won't claim one for the other.
+   *
+   * @param dbIndexPredicates - Normalized `WHERE` predicate per DB index
+   *   name from {@link getDbIndexPredicates}. `null` means predicate
+   *   introspection was unavailable for this engine/adapter, in which case
+   *   the comparison falls back to predicate-unaware signatures (the prior
+   *   behavior) so existing partial indexes are never flagged as false drift.
    */
-  compareIndexes(tableName, manifest, dbSchema) {
+  compareIndexes(tableName, manifest, dbSchema, dbIndexPredicates = null) {
     const changes = [];
+    const predicateAware = dbIndexPredicates !== null;
+    const dbPredicateFor = (name) => predicateAware ? dbIndexPredicates?.get(name) ?? "" : "";
+    const manifestPredicateFor = (idx) => predicateAware ? normalizeIndexPredicate(idx.where) : "";
     const dbIndexesByName = /* @__PURE__ */ new Map();
     const dbIndexSignatures = /* @__PURE__ */ new Map();
     for (const idx of dbSchema.indexes) {
       const unique = idx.unique ?? false;
       dbIndexesByName.set(idx.name, { columns: idx.columns, unique });
-      const signature = this.getIndexSignature(idx.columns, unique);
+      const signature = this.getIndexSignature(
+        idx.columns,
+        unique,
+        dbPredicateFor(idx.name)
+      );
       let bucket = dbIndexSignatures.get(signature);
       if (!bucket) {
         bucket = /* @__PURE__ */ new Set();
@@ -228,11 +299,17 @@ class SchemaComparer {
     }
     const manifestSignatureSet = /* @__PURE__ */ new Set();
     for (const idx of manifest.indexes) {
-      manifestSignatureSet.add(this.getIndexSignature(idx));
+      manifestSignatureSet.add(
+        this.getIndexSignature(idx, void 0, manifestPredicateFor(idx))
+      );
     }
     const claimedDbIndexes = /* @__PURE__ */ new Set();
     for (const idx of manifest.indexes) {
-      const manifestSignature = this.getIndexSignature(idx);
+      const manifestSignature = this.getIndexSignature(
+        idx,
+        void 0,
+        manifestPredicateFor(idx)
+      );
       const dbByName = dbIndexesByName.get(idx.name);
       if (dbByName) {
         claimedDbIndexes.add(idx.name);
@@ -241,7 +318,8 @@ class SchemaComparer {
         }
         const dbSignature = this.getIndexSignature(
           dbByName.columns,
-          dbByName.unique
+          dbByName.unique,
+          dbPredicateFor(idx.name)
         );
         if (dbSignature === manifestSignature) {
           continue;
@@ -282,7 +360,8 @@ class SchemaComparer {
         if (isProtectedDbIndexName(idx.name)) continue;
         const idxSignature = this.getIndexSignature(
           idx.columns,
-          idx.unique ?? false
+          idx.unique ?? false,
+          dbPredicateFor(idx.name)
         );
         if (manifestSignatureSet.has(idxSignature)) continue;
         changes.push({
@@ -296,17 +375,21 @@ class SchemaComparer {
     return changes;
   }
   /**
-   * Generate a signature for an index based on its columns and uniqueness.
-   * Used for functional equivalence checking (Issue #741).
+   * Generate a signature for an index based on its columns, uniqueness, and
+   * (normalized) partial-index predicate. Used for functional equivalence
+   * checking (Issue #741) and predicate-drift detection (Issue #1692).
    *
    * Note: Column order is preserved because it is semantically significant for
    * composite indexes. An index on (a, b) is NOT equivalent to (b, a) - they
    * have different query performance characteristics.
    *
-   * Limitation: Partial indexes (with WHERE clauses) are not fully supported.
-   * The database introspection layer doesn't provide WHERE clause information,
-   * so two partial indexes with the same columns but different WHERE clauses
-   * cannot be distinguished and may be incorrectly treated as equivalent.
+   * The trailing predicate component distinguishes partial indexes that share
+   * columns and uniqueness but differ by their `WHERE` clause (e.g. distinct
+   * STI child partial indexes). Callers pass the already-normalized predicate
+   * so both the manifest (desired) and introspected (DB) sides compare equal
+   * for semantically-identical clauses. An empty string means "no predicate"
+   * (a non-partial index) and is also used on both sides when predicate
+   * introspection is unavailable, preserving the prior behavior.
    *
    * For JSON-path indexes (`@meta({ indexed: true })`) the signature is
    * derived from the JSON path instead of an empty column list, so the
@@ -314,17 +397,91 @@ class SchemaComparer {
    *
    * @param idxOrColumns - Either an IndexDefinition or a column array (legacy)
    * @param uniqueArg - Unique flag (used when first arg is a column array)
+   * @param predicateArg - Normalized partial-index predicate (default '')
    * @returns Signature string
    */
-  getIndexSignature(idxOrColumns, uniqueArg) {
+  getIndexSignature(idxOrColumns, uniqueArg, predicateArg = "") {
     if (Array.isArray(idxOrColumns)) {
-      return `${idxOrColumns.join(",")}:${Boolean(uniqueArg)}`;
+      return `${idxOrColumns.join(",")}:${Boolean(uniqueArg)}:${predicateArg}`;
     }
     const idx = idxOrColumns;
     if (isJsonPathIndex(idx) && idx.jsonPath) {
-      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}`;
+      return `json:${idx.jsonPath.column}.${idx.jsonPath.path}:${Boolean(idx.unique)}:${predicateArg}`;
+    }
+    return `${(idx.columns ?? []).join(",")}:${Boolean(idx.unique)}:${predicateArg}`;
+  }
+  /**
+   * Whether the active engine supports partial indexes (`CREATE INDEX … WHERE`).
+   *
+   * SQLite and PostgreSQL do. DuckDB rejects them outright, and the JSON
+   * adapter is DuckDB-backed, so on those engines a "partial" index can only
+   * ever exist as a full index. Treating the predicate as significant there
+   * would (a) flag existing full indexes as false drift and (b) emit
+   * `CREATE INDEX … WHERE` DDL the engine rejects, breaking the migration.
+   * Gating on this keeps both the comparison and the generated DDL aligned
+   * with what the engine actually accepts (a partial index degrades to a
+   * full index), matching the pre-#1692 behavior on those engines.
+   */
+  supportsPartialIndexes() {
+    return this.engine === "sqlite" || this.engine === "postgres";
+  }
+  /**
+   * Introspect partial-index predicates for a table, keyed by index name.
+   *
+   * `getTableSchema()` (the @happyvertical/sql introspection) returns only
+   * name/columns/unique, so the `WHERE` predicate is read directly here:
+   *
+   * - PostgreSQL: `pg_indexes.indexdef` carries the full CREATE INDEX text.
+   * - SQLite: the `sqlite_master.sql` column carries the original CREATE INDEX
+   *   text.
+   *
+   * Engines that don't support partial indexes (DuckDB / the DuckDB-backed
+   * JSON adapter) short-circuit to `null` so the comparison stays
+   * predicate-unaware there — see {@link supportsPartialIndexes}.
+   *
+   * Non-partial indexes are omitted from the map (callers treat a missing
+   * entry as the empty predicate). Returns `null` when the catalog query
+   * fails — e.g. an adapter exposing neither catalog — so the index
+   * comparison can fall back to predicate-unaware behavior rather than
+   * flagging every existing partial index as false drift.
+   */
+  async getDbIndexPredicates(tableName) {
+    if (!this.supportsPartialIndexes()) {
+      return null;
+    }
+    const predicates = /* @__PURE__ */ new Map();
+    try {
+      if (this.engine === "postgres") {
+        const result2 = await this.db.query(
+          `SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' AND tablename = ${this.quoteLiteral(
+            tableName
+          )}`
+        );
+        for (const row of result2.rows) {
+          if (!row.indexname || !row.indexdef) continue;
+          const predicate = extractIndexPredicate(row.indexdef);
+          if (predicate) predicates.set(row.indexname, predicate);
+        }
+        return predicates;
+      }
+      const result = await this.db.query(
+        `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ${this.quoteLiteral(
+          tableName
+        )} AND name NOT LIKE 'sqlite_%'`
+      );
+      for (const row of result.rows) {
+        if (!row.name || !row.sql) continue;
+        const predicate = extractIndexPredicate(row.sql);
+        if (predicate) predicates.set(row.name, predicate);
+      }
+      return predicates;
+    } catch (err) {
+      logger.debug(
+        `[SchemaComparer] Partial-index predicate introspection unavailable for ${tableName}; falling back to predicate-unaware index comparison`,
+        { error: err instanceof Error ? err.message : String(err) }
+      );
+      return null;
     }
-    return `${(idx.columns ?? []).join(",")}:${Boolean(idx.unique)}`;
   }
   /**
    * Get list of existing tables from database
@@ -547,12 +704,26 @@ class SchemaComparer {
     return `ALTER TABLE ${this.quoteIdentifier(tableName)} DROP COLUMN ${this.quoteIdentifier(colName)}`;
   }
   /**
-   * Generate SQL for adding an index
+   * Generate SQL for adding an index.
+   *
+   * On engines that support partial indexes (SQLite/PostgreSQL) this mirrors
+   * the canonical CREATE INDEX path in the DDL strategies: a partial index
+   * appends its `WHERE` predicate so a detected predicate add/alter (issue
+   * #1692) recreates the index with the correct partial condition rather than
+   * silently widening it to a full index. On DuckDB / the JSON adapter — which
+   * reject partial indexes — the predicate is dropped so the emitted DDL stays
+   * executable (a partial index degrades to a full index there). The predicate
+   * is trimmed and a redundant leading `WHERE` stripped for robustness.
    */
   generateAddIndexSQL(tableName, idx) {
     const uniqueStr = idx.unique ? "UNIQUE " : "";
     const target = renderIndexTarget(idx, this.engine);
-    return `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;
+    let sql = `CREATE ${uniqueStr}INDEX ${this.quoteIdentifier(idx.name)} ON ${this.quoteIdentifier(tableName)} (${target})`;
+    const where = idx.where?.trim().replace(/^WHERE\s+/i, "");
+    if (this.supportsPartialIndexes() && where) {
+      sql += ` WHERE ${where}`;
+    }
+    return sql;
   }
   /**
    * Generate SQL for dropping an index.
@@ -594,8 +765,10 @@ function getSQLFromDiff(diff) {
 }
 export {
   SchemaComparer,
+  extractIndexPredicate,
   generateSchemaDiff,
   getSQLFromDiff,
-  hasActionableChanges
+  hasActionableChanges,
+  normalizeIndexPredicate
 };
 //# sourceMappingURL=differ.js.map