@everystack/cli 0.3.28 → 0.4.0

package/src/cli/schema-diff.ts

@@ -30,6 +30,7 @@ import type {
   ColumnSchema,
   EnumType,
   IndexSchema,
+  SequenceSchema,
 } from './schema-introspect.js';
 
 // ---------------------------------------------------------------------------
@@ -79,10 +80,14 @@ export type SchemaChange =
   | { kind: 'dropType'; name: string }
   /** An enum value the DB has but the Model dropped/renamed — Postgres can't drop one in place (a notice). */
   | { kind: 'enumValuesChanged'; name: string; from: string[]; to: string[] }
-  /** A standalone index to create → `CREATE [UNIQUE] INDEX … [WHERE …]`. */
-  | { kind: 'createIndex'; table: string; name: string; columns: string[]; unique: boolean; where?: string }
+  /** A standalone index to create → `CREATE [UNIQUE] INDEX … [USING …] (…) [INCLUDE …] [WHERE …]`. */
+  | { kind: 'createIndex'; table: string; name: string; columns: string[]; unique: boolean; where?: string; using?: string; include?: string[] }
   /** A standalone index present in the DB but no longer declared → `DROP INDEX` (a removal — gated). */
-  | { kind: 'dropIndex'; table: string; name: string };
+  | { kind: 'dropIndex'; table: string; name: string }
+  /** A declared standalone sequence missing live → `CREATE SEQUENCE`, before any table. */
+  | { kind: 'createSequence'; sequence: SequenceSchema }
+  /** A declared sequence whose live properties differ — a NOTICE, never a silent ALTER (it holds state). */
+  | { kind: 'sequenceDrift'; name: string; declared: SequenceSchema; live: SequenceSchema };
 
 /**
  * Rename intent, keyed like the snapshot's tables (`public.posts`) → { newColumn: oldColumn }.
@@ -131,9 +136,48 @@ export function normalizeDefault(expr: string | null): string | null {
   // `nextval('public.x_seq')` on another. public is always on the search_path — strip it.
   s = s.replace(/^nextval\('public\.([^']+)'/, "nextval('$1'");
 
+  // The deparser also casts the sequence literal (`nextval('x_seq'::regclass)`); an
+  // authored `defaultSql` may spell it bare. One canonical (castless) form for both —
+  // a normalization change, so FINGERPRINT_VERSION was bumped with it.
+  s = s.replace(/^nextval\('([^']+)'::regclass\)$/, "nextval('$1')");
+
   return s;
 }
 
+/**
+ * The sequence a `nextval` default draws from (schema qualification and the `::regclass`
+ * cast stripped), or null when the expression isn't a plain nextval. Drives two decisions:
+ * the `serial` shorthand fires ONLY for a column's own conventional `<table>_<col>_seq`
+ * (anything else would mint a NEW sequence), and a foreign-sequence default is held out
+ * of CREATE/ADD and re-attached as a trailing SET DEFAULT (its sequence may live on a
+ * table created later).
+ */
+export function nextvalSequence(expr: string | null): string | null {
+  if (expr == null) return null;
+  const m = expr.trim().match(/^nextval\('(?:[^'.]+\.)?([^'.]+)'(?:::regclass)?\)$/);
+  return m ? m[1] : null;
+}
+
+/** `public.contracts` / `contracts` → `contracts` (the bare table name for sequence conventions). */
+function bareTable(table: string): string {
+  return table.replace(/^[^.]+\./, '');
+}
+
+/** `CREATE SEQUENCE` DDL for a standalone sequence — emitted BEFORE any table, so a
+ *  column's `defaultSql(nextval(…))` can draw on it from the first CREATE. */
+export function sequenceCreateSql(seq: SequenceSchema): string {
+  let s = `CREATE SEQUENCE ${seq.name} AS ${seq.as}`;
+  if (seq.start != null) s += ` START WITH ${seq.start}`;
+  if (seq.increment != null) s += ` INCREMENT BY ${seq.increment}`;
+  return `${s};`;
+}
+
+/** True when a column's default draws a sequence that is NOT its own conventional one. */
+function isForeignSequenceDefault(table: string, col: ColumnSchema): boolean {
+  const seq = nextvalSequence(col.default);
+  return seq != null && seq !== `${bareTable(table)}_${col.name}_seq`;
+}
+
 // ---------------------------------------------------------------------------
 // Type-change classification — does the conversion need a USING cast and a warning?
 // ---------------------------------------------------------------------------
@@ -318,29 +362,76 @@ export function diffSchema(desired: SchemaSnapshot, current: SchemaSnapshot, ren
 
   const e = diffEnums(desired.enums ?? [], current.enums ?? []);
 
+  // Standalone sequences — existence-diffed, DECLARED-SCOPED (a live sequence the models
+  // never declared is invisible: it holds state, and undeclared ≠ ours to drop). A declared
+  // one missing live is a create, before any table (a defaultSql may draw on it from the
+  // first CREATE); live property drift is a NOTICE — never a silent ALTER on a counter.
+  const sequenceCreates: SchemaChange[] = [];
+  const sequenceNotices: SchemaChange[] = [];
+  const currentSeqs = new Map((current.sequences ?? []).map((s) => [s.name, s]));
+  for (const declared of desired.sequences ?? []) {
+    const liveSeq = currentSeqs.get(declared.name);
+    if (!liveSeq) {
+      sequenceCreates.push({ kind: 'createSequence', sequence: declared });
+    } else if (liveSeq.as !== declared.as || (liveSeq.increment ?? 1) !== (declared.increment ?? 1)) {
+      sequenceNotices.push({ kind: 'sequenceDrift', name: declared.name, declared, live: liveSeq });
+    }
+  }
+
+  // Foreign-sequence defaults are held out of CREATE/ADD by the emitters (the sequence
+  // may live on a table created later in the same batch) and re-attached here as
+  // SET DEFAULT changes ordered after every create and add.
+  const trailingDefaults: SchemaChange[] = [];
+  for (const c of creates) {
+    if (c.kind !== 'createTable') continue;
+    for (const col of c.schema.columns) {
+      if (isForeignSequenceDefault(c.table, col)) {
+        trailingDefaults.push({ kind: 'setDefault', table: c.table, column: col.name, expr: col.default! });
+      }
+    }
+  }
+  for (const c of addColumns) {
+    if (c.kind !== 'addColumn') continue;
+    if (isForeignSequenceDefault(c.table, c.column)) {
+      trailingDefaults.push({ kind: 'setDefault', table: c.table, column: c.column.name, expr: c.column.default! });
+    }
+  }
+
   // Enum types come first (a table or column may reference one); value adds before the
   // columns that use them. Table renames run before creates (a rename frees a name a
   // create may reuse) and before every per-table change (which all target the new name).
   // Column renames run before adds and alters for the same reason. Enum drops sit with
   // the other removals; notices are comments — emitted last, after the DDL.
   return [
-    ...e.creates, ...e.adds,
+    ...e.creates, ...e.adds, ...sequenceCreates,
     ...renameTables,
-    ...creates, ...renameColumns, ...addColumns, ...alters,
+    ...creates, ...renameColumns, ...addColumns, ...alters, ...trailingDefaults,
     ...dropConstraints, ...addConstraints, ...createIndexes,
     ...dropColumns, ...dropIndexes, ...dropTables,
-    ...e.drops, ...notices, ...e.notices,
+    ...e.drops, ...notices, ...e.notices, ...sequenceNotices,
   ];
 }
 
 /** A `createIndex` change from an index spec (the new-table path and the per-table diff share it). */
 function createIndexChange(table: string, ix: IndexSchema): SchemaChange {
-  return { kind: 'createIndex', table, name: ix.name, columns: ix.columns, unique: ix.unique, ...(ix.where ? { where: ix.where } : {}) };
+  return {
+    kind: 'createIndex', table, name: ix.name, columns: ix.columns, unique: ix.unique,
+    ...(ix.where ? { where: ix.where } : {}),
+    ...(ix.using ? { using: ix.using } : {}),
+    ...(ix.include?.length ? { include: ix.include } : {}),
+  };
 }
 
-/** An index's content identity — columns, uniqueness, and partial predicate, name-independent (like checks). */
+/**
+ * An index's content identity — key entries (expressions/direction/opclass are canonical
+ * text, normalized like checks), uniqueness, predicate, access method, and INCLUDE set:
+ * name-independent, and no longer blind to anything `CREATE INDEX` can say (Brick E —
+ * the consumer's 31 phantom drop/creates). Plain btree indexes key exactly as before
+ * plus a constant tail — both sides compute the same key, so nothing churns.
+ */
 function indexKey(ix: IndexSchema): string {
-  return `${ix.unique ? 'u' : ''}|${ix.columns.join(',')}|${normalizeCheck(ix.where ?? '')}`;
+  const entries = ix.columns.map((c) => normalizeCheck(c)).join(',');
+  return `${ix.unique ? 'u' : ''}|${entries}|${normalizeCheck(ix.where ?? '')}|${ix.using ?? 'btree'}|${(ix.include ?? []).join(',')}`;
 }
 
 /**
@@ -555,25 +646,31 @@ const enumLiteral = (value: string): string => `'${value.replace(/'/g, "''")}'`;
  * column), or null. CREATE/ADD COLUMN must use the shorthand — it creates the backing
  * sequence, which a bare `DEFAULT nextval(...)` would reference before it exists.
  */
-function serialSpelling(col: ColumnSchema): string | null {
-  if (col.default == null || !/^nextval\('[^']+'::regclass\)$/.test(col.default)) return null;
+function serialSpelling(col: ColumnSchema, table: string): string | null {
+  // ONLY the column's own conventional sequence is a serial declaration — the shorthand
+  // creates a sequence, so spelling it for a foreign `nextval` would mint a duplicate
+  // and silently detach the column from the sequence it declared.
+  const seq = nextvalSequence(col.default);
+  if (seq == null || seq !== `${bareTable(table)}_${col.name}_seq`) return null;
   if (col.type === 'integer') return 'serial';
   if (col.type === 'bigint') return 'bigserial';
   return null;
 }
 
 /** A column definition body (no leading indent): `"name" type [DEFAULT expr] [NOT NULL]`. */
-function columnSql(col: ColumnSchema): string {
-  const serial = serialSpelling(col);
+function columnSql(col: ColumnSchema, table: string): string {
+  const serial = serialSpelling(col, table);
   let s = `${quote(col.name)} ${serial ?? col.type}`;
-  if (!serial && col.default != null) s += ` DEFAULT ${col.default}`;
+  // A foreign-sequence default is held out — diffSchema appends the trailing SET DEFAULT
+  // (after every create), so the CREATE never references a sequence that doesn't exist yet.
+  if (!serial && col.default != null && !isForeignSequenceDefault(table, col)) s += ` DEFAULT ${col.default}`;
   if (col.notNull) s += ' NOT NULL';
   return s;
 }
 
 /** `CREATE TABLE` from the IR: columns + PK/unique/check inline; FKs are emitted separately. */
 function createTableSql(t: TableSchema): string {
-  const lines = t.columns.map((c) => `\t${columnSql(c)}`);
+  const lines = t.columns.map((c) => `\t${columnSql(c, t.table)}`);
   if (t.primaryKey.length) lines.push(`\tPRIMARY KEY (${colList(t.primaryKey)})`);
   for (const u of t.uniques) lines.push(`\tCONSTRAINT ${quote(u.name)} UNIQUE (${colList(u.columns)})`);
   for (const ck of t.checks) lines.push(`\tCONSTRAINT ${quote(ck.name)} CHECK ${wrapOnce(ck.expr)}`);
@@ -613,7 +710,7 @@ function emitOne(change: SchemaChange, opts: EmitOptions): string {
     case 'dropTable':
       return `DROP TABLE ${change.table};`;
     case 'addColumn': {
-      const ddl = `ALTER TABLE ${change.table} ADD COLUMN ${columnSql(change.column)};`;
+      const ddl = `ALTER TABLE ${change.table} ADD COLUMN ${columnSql(change.column, change.table)};`;
       // Adding a NOT NULL column with no default fails on a table that already has rows.
       if (change.column.notNull && change.column.default == null) {
         return `-- WARNING: ADD COLUMN ${quote(change.column.name)} NOT NULL on ${change.table} has no default and FAILS if the table has rows; add a default or backfill first.\n${ddl}`;
@@ -674,8 +771,13 @@ function emitOne(change: SchemaChange, opts: EmitOptions): string {
       return `DROP TYPE ${quote(change.name)};`;
     case 'createIndex': {
       const unique = change.unique ? 'UNIQUE ' : '';
+      const using = change.using ? ` USING ${change.using}` : '';
+      // A plain identifier entry quotes as before; a canonical-text entry (expression,
+      // DESC, opclass) passes verbatim — quoting the whole thing would mangle it.
+      const entry = (c: string): string => (/^[a-z_][a-z0-9_$]*$/i.test(c) ? quote(c) : c);
+      const include = change.include?.length ? ` INCLUDE (${colList(change.include)})` : '';
       const where = change.where ? ` WHERE ${change.where}` : '';
-      return `CREATE ${unique}INDEX ${quote(change.name)} ON ${change.table} (${colList(change.columns)})${where};`;
+      return `CREATE ${unique}INDEX ${quote(change.name)} ON ${change.table}${using} (${change.columns.map(entry).join(', ')})${include}${where};`;
     }
     case 'dropIndex': {
       const schema = change.table.includes('.') ? `${change.table.split('.')[0]}.` : '';
@@ -683,6 +785,10 @@ function emitOne(change: SchemaChange, opts: EmitOptions): string {
     }
     case 'enumValuesChanged':
       return `-- NOTICE: enum ${quote(change.name)} values changed ([${change.from.join(', ')}] → [${change.to.join(', ')}]) in a way Postgres can't apply in place (a removal, reorder, or rename). ADD VALUE only appends; reshaping an enum needs a manual type swap (create new type, ALTER COLUMN ... TYPE using a cast, drop old).`;
+    case 'createSequence':
+      return sequenceCreateSql(change.sequence);
+    case 'sequenceDrift':
+      return `-- NOTICE: sequence ${change.name} differs from its declaration (declared AS ${change.declared.as}${change.declared.increment != null ? ` INCREMENT ${change.declared.increment}` : ''}; live AS ${change.live.as}${change.live.increment != null ? ` INCREMENT ${change.live.increment}` : ''}). A sequence holds a counter — reshape it by hand (ALTER SEQUENCE) after deciding what the counter should be.`;
   }
 }
 

package/src/cli/schema-fingerprint.ts

@@ -39,23 +39,30 @@
  *    fingerprints. The version prefix plus the re-diff path keep that honest.
  *
  * Coverage is partial and SAYS SO: `UNFINGERPRINTED_SQL` enumerates what the
- * base fingerprint does not see (standalone sequences, triggers, domains,
- * composite types, foreign/partitioned tables, extensions) so partial
- * coverage reads as a report, never as "covered everything".
+ * base fingerprint does not see (triggers — drift-checked separately by the
+ * reconciler's provenance — domains, composite types, foreign/partitioned
+ * tables, extensions) so partial coverage reads as a report, never as
+ * "covered everything". Standalone sequences left this list in v3: covered.
  */
 
 import { createHash } from 'node:crypto';
-import type { ModelDescriptor } from '@everystack/model';
+import type { ModelDescriptor, SequenceDescriptor } from '@everystack/model';
 import type { SchemaSnapshot, TableSchema } from './schema-introspect.js';
 import type { AuthzContract, TableContract } from './authz-contract.js';
-import { compileTableSchema, compileEnums } from './schema-compile.js';
+import { compileTableSchema, compileEnums, compileSequences } from './schema-compile.js';
 import { compileTableContract } from './authz-compile.js';
 import { normalizeDefault, normalizeCheck } from './schema-diff.js';
 
 // v2: expression fields (defaults, checks, partial-index WHERE) normalize through
 // the diff's pg-deparse normalizers before hashing, so the model form and the live
 // deparsed form agree — the identity `fingerprintModels === fingerprintLive` holds.
-export const FINGERPRINT_VERSION = 2;
+// v3: nextval defaults canonicalize to the castless form (`nextval('x_seq')`), so an
+// authored `defaultSql` and the deparser's `nextval('x_seq'::regclass)` hash equal
+// (canonical forms changed for every serial column's default → the bump). ALSO in v3:
+// STANDALONE SEQUENCES enter the canonical form (declared via defineSequence,
+// introspected from pg_sequence minus serial-owned) — a coverage expansion; the
+// `sequences` key appears only when any exist, so sequence-free states hash unchanged.
+export const FINGERPRINT_VERSION = 3;
 
 // ---------------------------------------------------------------------------
 // Canonical form.
@@ -149,12 +156,23 @@ export interface CanonicalState {
   tables: Array<Record<string, unknown>>;
   enums: Array<{ name: string; values: string[] }>;
   authz: Array<Record<string, unknown>>;
+  /** Standalone sequences — present ONLY when any exist, so a sequence-free state's
+   *  canonical form (and hash) is byte-identical to the pre-coverage form. */
+  sequences?: Array<Record<string, unknown>>;
 }
 
 export function canonicalizeState(
   snapshot: SchemaSnapshot,
   authzTables: TableContract[],
 ): CanonicalState {
+  const sequences = byKey(
+    (snapshot.sequences ?? []).map((s) => ({
+      name: s.name, as: s.as,
+      ...(s.start != null ? { start: s.start } : {}),
+      ...(s.increment != null ? { increment: s.increment } : {}),
+    })),
+    (s) => String(s.name),
+  );
   return {
     v: FINGERPRINT_VERSION,
     tables: byKey(snapshot.tables.map(canonicalTable), (t) => String(t.table)),
@@ -163,6 +181,7 @@ export function canonicalizeState(
       (e) => e.name,
     ),
     authz: byKey(authzTables.map(canonicalAuthzTable), (t) => String(t.table)),
+    ...(sequences.length ? { sequences } : {}),
   };
 }
 
@@ -184,11 +203,12 @@ export function fingerprintState(
 /** The DECLARED state: compile the models to the same canonical shape and hash it. */
 export function fingerprintModels(
   models: ModelDescriptor[],
-  opts: { schema?: string } = {},
+  opts: { schema?: string; sequences?: SequenceDescriptor[] } = {},
 ): Fingerprint {
   const snapshot: SchemaSnapshot = {
     tables: models.map((m) => compileTableSchema(m, opts)),
     enums: compileEnums(models),
+    ...(opts.sequences?.length ? { sequences: compileSequences(opts.sequences) } : {}),
   };
   const authzTables = models.map((m) => compileTableContract(m, opts));
   return fingerprintState(snapshot, authzTables);
@@ -210,17 +230,7 @@ export function fingerprintLive(snapshot: SchemaSnapshot, contract: AuthzContrac
  * types, foreign tables, partitioned tables, and installed extensions.
  */
 export const UNFINGERPRINTED_SQL = `
-SELECT 'sequence' AS kind, n.nspname || '.' || c.relname AS identity
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-WHERE c.relkind = 'S'
-  AND n.nspname NOT IN ('pg_catalog', 'information_schema') AND n.nspname NOT LIKE 'pg_%'
-  AND NOT EXISTS (
-    SELECT 1 FROM pg_depend d
-    WHERE d.objid = c.oid AND d.deptype IN ('a', 'i') AND d.refobjsubid > 0
-  )
-UNION ALL
-SELECT 'trigger', n.nspname || '.' || c.relname || '.' || t.tgname
+SELECT 'trigger' AS kind, n.nspname || '.' || c.relname || '.' || t.tgname AS identity
 FROM pg_trigger t
 JOIN pg_class c ON c.oid = t.tgrelid
 JOIN pg_namespace n ON n.oid = c.relnamespace

package/src/cli/schema-introspect.ts

@@ -53,10 +53,17 @@ export interface CheckConstraint {
 /** A standalone index (NOT one backing a PK or UNIQUE constraint — those are excluded). */
 export interface IndexSchema {
   name: string;
+  /** Canonical key text per position: a plain column name, or anything richer verbatim —
+   *  `lower(email)`, `created_at DESC`, `title text_pattern_ops` (Brick E: expression
+   *  indexes, direction, and opclass are IDENTITY, not noise). Default ASC is stripped. */
   columns: string[];
   unique: boolean;
   /** Partial-index predicate (`WHERE …`), omitted when the index is total. */
   where?: string;
+  /** Access method when not btree (`'gin'`, `'gist'`, …) — btree is never spelled. */
+  using?: string;
+  /** `INCLUDE (…)` covering columns. */
+  include?: string[];
 }
 
 export interface TableSchema {
@@ -78,10 +85,25 @@ export interface EnumType {
   values: string[];
 }
 
+/** A STANDALONE sequence — one no serial column owns (those stay implicit in their
+ *  column). It holds state (the counter position), so it lives in the base schema:
+ *  migrated before tables, diffed by existence, fingerprinted. `start`/`increment`
+ *  are omitted when they are PostgreSQL's defaults (1), so a declaration that omits
+ *  them matches a live default exactly. */
+export interface SequenceSchema {
+  /** Bare for public (`order_number_seq`), qualified otherwise (`reporting.order_seq`). */
+  name: string;
+  as: 'integer' | 'bigint';
+  start?: number;
+  increment?: number;
+}
+
 export interface SchemaSnapshot {
   tables: TableSchema[];
   /** Enum types in the schema (`CREATE TYPE … AS ENUM`). Absent/empty when none. */
   enums?: EnumType[];
+  /** Standalone sequences (serial-owned ones excluded). Absent/empty when none. */
+  sequences?: SequenceSchema[];
 }
 
 // ---------------------------------------------------------------------------
@@ -163,6 +185,30 @@ GROUP BY n.nspname, t.typname
 ORDER BY n.nspname, t.typname;
 `.trim();
 
+/**
+ * STANDALONE sequences — the ones no serial column owns (a serial's implicit sequence
+ * has an 'a'/'i' pg_depend link to its column and stays represented BY that column).
+ * These hold state, so they are base-schema: migrated, diffed, fingerprinted.
+ */
+export const SEQUENCES_SQL = `
+SELECT
+  n.nspname AS schema,
+  c.relname AS name,
+  format_type(s.seqtypid, NULL) AS data_type,
+  s.seqstart AS start,
+  s.seqincrement AS increment
+FROM pg_sequence s
+JOIN pg_class c ON c.oid = s.seqrelid
+JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_%'
+  AND NOT EXISTS (
+    SELECT 1 FROM pg_depend d
+    WHERE d.objid = c.oid AND d.deptype IN ('a', 'i') AND d.refobjsubid > 0
+  )
+ORDER BY n.nspname, c.relname;
+`.trim();
+
 /**
  * Standalone indexes — `CREATE INDEX` the app declares, NOT the implicit indexes that back a
  * primary key or unique constraint (those are excluded by the `conindid` check, since they're
@@ -179,9 +225,12 @@ SELECT
   (SELECT array_agg(a.attname ORDER BY k.ord)
      FROM unnest(idx.indkey) WITH ORDINALITY k(attnum, ord)
      JOIN pg_attribute a ON a.attrelid = idx.indrelid AND a.attnum = k.attnum) AS columns,
-  pg_get_expr(idx.indpred, idx.indrelid) AS predicate
+  pg_get_expr(idx.indpred, idx.indrelid) AS predicate,
+  pg_get_indexdef(idx.indexrelid) AS definition,
+  am.amname AS method
 FROM pg_index idx
 JOIN pg_class i ON i.oid = idx.indexrelid
+JOIN pg_am am ON am.oid = i.relam
 JOIN pg_class t ON t.oid = idx.indrelid
 JOIN pg_namespace n ON n.oid = t.relnamespace
 WHERE t.relkind = 'r'
@@ -300,17 +349,107 @@ export interface IndexRow {
   is_unique: unknown;
   columns: unknown;
   predicate: unknown;
+  /** `pg_get_indexdef` — the authoritative key list (expressions, DESC, opclass, INCLUDE).
+   *  Optional: a legacy row without it falls back to the plain columns array. */
+  definition?: unknown;
+  /** `pg_am.amname`. Optional; btree folds to absent. */
+  method?: unknown;
 }
 
-export function indexRowToDescriptor(row: IndexRow): { table: string; index: IndexSchema } {
-  const columns = Array.isArray(row.columns) ? row.columns.map(String) : [];
-  const pred = row.predicate == null ? '' : String(row.predicate);
+/** Split a parenthesized list on top-level commas (expression entries contain their own). */
+function splitTopLevel(list: string): string[] {
+  const out: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < list.length; i++) {
+    const ch = list[i];
+    if (ch === '(') depth++;
+    else if (ch === ')') depth--;
+    else if (ch === ',' && depth === 0) {
+      out.push(list.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(list.slice(start));
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+
+/** The parenthesized group starting at `open` (which must point at '('), content only. */
+function parenGroup(text: string, open: number): string | null {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === '(') depth++;
+    else if (text[i] === ')' && --depth === 0) return text.slice(open + 1, i);
+  }
+  return null;
+}
+
+/** Canonicalize one key entry: unquote a plain `"col"`, strip the default ` ASC`. */
+function canonicalKeyEntry(entry: string): string {
+  let s = entry.trim().replace(/\s+ASC$/i, '');
+  const quoted = s.match(/^"((?:[^"]|"")*)"$/);
+  if (quoted) s = quoted[1].replace(/""/g, '"');
+  return s;
+}
+
+/**
+ * The extended identity from a `pg_get_indexdef` text (Brick E): canonical key entries
+ * (expressions, direction, opclass — default ASC stripped, plain names unquoted), the
+ * access method from the `USING` clause (btree folds to absent), INCLUDE columns,
+ * uniqueness, and the partial predicate. Null when the text isn't index DDL.
+ */
+export function parseIndexDefinition(definition: string): Omit<IndexSchema, 'name'> | null {
+  const usingMatch = definition.match(/\sUSING\s+(\w+)\s*\(/i);
+  if (!usingMatch || usingMatch.index === undefined) return null;
+  const open = definition.indexOf('(', usingMatch.index);
+  const keyList = parenGroup(definition, open);
+  if (keyList === null) return null;
+  const columns = splitTopLevel(keyList).map(canonicalKeyEntry);
+  const method = usingMatch[1].toLowerCase();
+  const after = definition.slice(open + keyList.length + 2);
+  const includeAt = after.search(/^\s*INCLUDE\s*\(/i);
+  const include = includeAt >= 0
+    ? splitTopLevel(parenGroup(after, after.indexOf('(')) ?? '').map(canonicalKeyEntry)
+    : undefined;
+  const whereMatch = after.match(/\sWHERE\s+(.+)$/i);
+  let where = whereMatch ? whereMatch[1].trim() : '';
+  // pg_get_indexdef wraps the predicate in one pair of parens — strip it.
+  if (where.startsWith('(') && parenGroup(where, 0) === where.slice(1, -1)) where = where.slice(1, -1).trim();
   return {
-    table: `${row.schema}.${row.table}`,
-    index: { name: row.name, columns, unique: coerceBool(row.is_unique), ...(pred ? { where: pred } : {}) },
+    columns,
+    unique: /^CREATE\s+UNIQUE\s+INDEX/i.test(definition),
+    ...(where ? { where } : {}),
+    ...(method !== 'btree' ? { using: method } : {}),
+    ...(include?.length ? { include } : {}),
   };
 }
 
+/** A row's index descriptor: the definition text when present (the extended identity);
+ *  a legacy row without one keeps the old plain-columns path, so fixtures stay valid.
+ *  `is_unique`/`predicate`/`method` row fields take precedence over the parsed text. */
+export function indexRowToDescriptor(row: IndexRow): { table: string; index: IndexSchema } {
+  const pred = row.predicate == null ? '' : String(row.predicate);
+  const table = `${row.schema}.${row.table}`;
+  const base = { name: row.name, unique: coerceBool(row.is_unique), ...(pred ? { where: pred } : {}) };
+
+  const parsed = row.definition == null ? null : parseIndexDefinition(String(row.definition));
+  if (parsed) {
+    const method = row.method == null ? parsed.using : String(row.method).toLowerCase();
+    return {
+      table,
+      index: {
+        ...base,
+        columns: parsed.columns,
+        ...(method && method !== 'btree' ? { using: method } : {}),
+        ...(parsed.include?.length ? { include: parsed.include } : {}),
+      },
+    };
+  }
+
+  const columns = Array.isArray(row.columns) ? row.columns.map(String) : [];
+  return { table, index: { ...base, columns } };
+}
+
 export interface EnumRow {
   schema: string;
   name: string;
@@ -322,11 +461,32 @@ export function enumRowToDescriptor(row: EnumRow): EnumType {
   return { name: row.name, values };
 }
 
+export interface SequenceRow {
+  schema: string;
+  name: string;
+  data_type: unknown;
+  start: unknown;
+  increment: unknown;
+}
+
+export function sequenceRowToDescriptor(row: SequenceRow): SequenceSchema {
+  const start = Number(row.start ?? 1);
+  const increment = Number(row.increment ?? 1);
+  return {
+    name: row.schema === 'public' ? row.name : `${row.schema}.${row.name}`,
+    as: String(row.data_type) === 'integer' ? 'integer' : 'bigint',
+    // PostgreSQL's defaults are omitted, so declared-without matches live-default.
+    ...(start !== 1 ? { start } : {}),
+    ...(increment !== 1 ? { increment } : {}),
+  };
+}
+
 export interface SchemaRows {
   columns: ColumnRow[];
   constraints: ConstraintRow[];
   enums?: EnumRow[];
   indexes?: IndexRow[];
+  sequences?: SequenceRow[];
 }
 
 /**
@@ -400,9 +560,15 @@ export function assembleSchema(rows: SchemaRows): SchemaSnapshot {
     .map(enumRowToDescriptor)
     .sort((a, b) => a.name.localeCompare(b.name));
 
+  const sequences = (rows.sequences ?? [])
+    .filter((r) => !IGNORED_SCHEMAS.has(r.schema))
+    .map(sequenceRowToDescriptor)
+    .sort((a, b) => a.name.localeCompare(b.name));
+
   return {
     tables: [...tables.values()].sort((a, b) => a.table.localeCompare(b.table)),
     enums,
+    ...(sequences.length ? { sequences } : {}),
   };
 }
 
@@ -413,13 +579,14 @@ export function assembleSchema(rows: SchemaRows): SchemaSnapshot {
  * `assembleSchema`. This is the `current` side `db:generate` diffs the compiled Models against.
  */
 export async function introspectSchema(run: QueryRunner): Promise<SchemaSnapshot> {
-  const [columns, constraints, enums, indexes] = await Promise.all([
-    run(COLUMNS_SQL), run(CONSTRAINTS_SQL), run(ENUMS_SQL), run(INDEXES_SQL),
+  const [columns, constraints, enums, indexes, sequences] = await Promise.all([
+    run(COLUMNS_SQL), run(CONSTRAINTS_SQL), run(ENUMS_SQL), run(INDEXES_SQL), run(SEQUENCES_SQL),
   ]);
   return assembleSchema({
     columns: columns as ColumnRow[],
     constraints: constraints as ConstraintRow[],
     enums: enums as EnumRow[],
     indexes: indexes as IndexRow[],
+    sequences: sequences as SequenceRow[],
   });
 }