@@ -26,10 +26,10 @@ here.**
   column.** Postgres stores `"key" ~ '^[a-z]+$'` as `((key)::text ~ '^[a-z]+$'::text)`; the
   literal's `::text` was already folded away but the column's was not, so a database `migrate`
   had just built showed the same constraint as both added and dropped. The comparison now
-  drops a `::text` cast only when it sits directly before a regex-match operator (`~`, `~*`,
-  `!~`, `!~*`), whatever the column type; a changed pattern or any other cast still reads as
-  drift. Known gap: on a `citext` column the cast and uncast spellings differ in meaning
-  (case-sensitive vs case-insensitive) but compare equal. Schema comparison is TypeScript-owned, so no other port
+  drops a `(col)::text` cast before a regex-match operator (`~`, `~*`, `!~`, `!~*`) only when
+  the database column is `text`, `varchar` or `bpchar`; on any other column, `citext` included,
+  the cast changes the operator and still reads as drift, as does a changed pattern or any
+  other cast. Schema comparison is TypeScript-owned, so no other port
   carries this comparison.
 
 - **The api reference now follows a routes generator's `filter` as well as its `expose`.**
 
@@ -41,12 +41,17 @@ function unwrapBacktickIdentifiers(expr: string): string {
     .join("");
 }
 
+const NO_COLUMNS: ReadonlySet<string> = new Set();
+
 /**
  * Canonical form: drop casts/brackets/parens, fold `= ANY (ARRAY[…])` back to `IN`,
  * lower-case, collapse whitespace, canonicalize cast target types, and collapse spacing
  * around commas, casts and SYMBOLIC operators (outside single-quoted literals).
+ *
+ * `textColumns` (lower-cased names of text-family columns) lets a `(col)::text` cast before
+ * a regex operator fold away; see isElidableCast.
  */
-export function normalizeCheckExpr(expr: string): string {
+export function normalizeCheckExpr(expr: string, textColumns: ReadonlySet<string> = NO_COLUMNS): string {
   const stripped = unwrapBacktickIdentifiers(expr)
     .toLowerCase()
     // Drop `::text` / `::"MyType"` type casts PG adds to literals. The lookbehind
@@ -95,7 +100,7 @@ export function normalizeCheckExpr(expr: string): string {
   // meaningful, so two checks differing only there must stay distinct — else a real
   // pattern change reads as clean drift, which is this file's failure in the other
   // direction and the worse of the two.
-  return collapseSeparatorSpacingOutsideQuotes(folded);
+  return collapseSeparatorSpacingOutsideQuotes(folded, textColumns);
 }
 
 /**
@@ -192,15 +197,17 @@ function readCastTarget(s: string, i: number): { type: string; consumed: number
  * cast on anything that is not a literal or a text-returning operator is a REAL cast and
  * survives, because erasing it would let a genuine change read as clean drift.
  */
-function isElidableCast(type: string, lhs: string, rest: string): boolean {
-  // `::text` directly before a regex-match operator (`~`, `~*`, `!~`, `!~*`). Those
-  // operators are defined on text, so on a varchar/text column PG adds the cast itself
-  // (`"key" ~ '…'` comes back `((key)::text ~ '…'::text)`). The comparator sees only the
-  // expression string, never the column type, so this elides the cast for every column.
-  // Known gap: on a `citext` column `col::text ~ 'A'` (case-sensitive) and `col ~ 'A'`
-  // (citext's own case-insensitive operator) both normalize alike, so switching between
-  // the two spellings reads as clean.
-  if (type === "text" && /^\s*!?~\*?(?![-+*\/<>=~!@#%^&|?])/.test(rest)) return true;
+function isElidableCast(type: string, lhs: string, rest: string, textColumns: ReadonlySet<string>): boolean {
+  // `::text` on a COLUMN directly before a regex-match operator (`~`, `~*`, `!~`, `!~*`),
+  // and only when the caller names that column as text-family (text, character varying,
+  // character). On such a column PG adds the cast itself (`"key" ~ '…'` comes back
+  // `((key)::text ~ '…'::text)`). On any other column, citext included, the cast changes
+  // the operator (`col::text ~ 'A'` is case-sensitive, `col ~ 'A'` on citext is not), so it
+  // survives. With no set supplied nothing is elided.
+  if (type === "text" && /^\s*!?~\*?(?![-+*\/<>=~!@#%^&|?])/.test(rest)) {
+    const column = /(?:^|[^\w.])([a-z_]\w*)$/.exec(lhs)?.[1];
+    if (column !== undefined && textColumns.has(column)) return true;
+  }
   // `->>` / `#>>` yield text; a following `::text` cannot change anything.
   if (type === "text" && /(?:->>|#>>)\s*(?:'(?:[^']|'')*'|[\w."]+)$/.test(lhs)) return true;
   // A numeric literal cast to a numeric type.
@@ -218,7 +225,7 @@ function isElidableCast(type: string, lhs: string, rest: string): boolean {
  * distinct regex CHECKs would compare equal — a real change reading as clean drift, which
  * is this file's failure in the worse direction.
  */
-function collapseSeparatorSpacingOutsideQuotes(s: string): string {
+function collapseSeparatorSpacingOutsideQuotes(s: string, textColumns: ReadonlySet<string>): string {
   let out = "";
   let i = 0;
   const n = s.length;
@@ -254,7 +261,7 @@ function collapseSeparatorSpacingOutsideQuotes(s: string): string {
       const target = readCastTarget(s, i);
       i += target.consumed;
       const lhs = out.replace(/\s+$/, "");
-      token = isElidableCast(target.type, lhs, s.slice(i)) ? "" : `::${target.type}`;
+      token = isElidableCast(target.type, lhs, s.slice(i), textColumns) ? "" : `::${target.type}`;
       out = lhs;
       // Whitespace AFTER the target type is load-bearing — `x::integer is not null` must
       // not become `x::integeris not null` — so the cast, unlike a comma or an operator,
@@ -280,9 +287,13 @@ function collapseSeparatorSpacingOutsideQuotes(s: string): string {
 }
 
 /** True when two CHECK expressions are equivalent after normalization. */
-export function checkExprEquals(a: string | undefined, b: string | undefined): boolean {
+export function checkExprEquals(
+  a: string | undefined,
+  b: string | undefined,
+  textColumns?: ReadonlySet<string>,
+): boolean {
   if (a === undefined || b === undefined) return false;
-  return normalizeCheckExpr(a) === normalizeCheckExpr(b);
+  return normalizeCheckExpr(a, textColumns) === normalizeCheckExpr(b, textColumns);
 }
 
 /**
 
@@ -809,6 +809,8 @@ function respelledSpread(expected: CheckDescriptor, actual: CheckDescriptor): {
   return checkExprRespelledNullSafe(expected.expression, actual.expression) ? { respelled: true } : {};
 }
 
+const PG_TEXT_FAMILY_UDTS: ReadonlySet<string> = new Set(["text", "varchar", "bpchar"]);
+
 function diffTableChecks(
   expected: TableDescriptor,
   actual: TableDescriptor,
@@ -829,12 +831,15 @@ function diffTableChecks(
   const exprFallback = dialect === "sqlite" || dialect === "d1";
   const actualByName = new Map(actual.checks.filter((c) => c.name !== "").map((c) => [c.name, c]));
   const consumed = new Set<CheckDescriptor>();
+  const textColumns = new Set(
+    actual.columns.filter((c) => c.udtName !== undefined && PG_TEXT_FAMILY_UDTS.has(c.udtName)).map((c) => c.name.toLowerCase()),
+  );
 
   for (const ec of expected.checks) {
     const ac = actualByName.get(ec.name);
     if (ac) {
       consumed.add(ac);
-      if (!checkExprEquals(ec.expression, ac.expression)) {
+      if (!checkExprEquals(ec.expression, ac.expression, textColumns)) {
         const respelled = respelledSpread(ec, ac);
         changes.push({ kind: "drop-check", table: expected.name, ...sx, check: ec.name, restore: ac, ...respelled, status: ALLOWED });
         changes.push({ kind: "add-check", table: expected.name, ...sx, check: ec, ...respelled, status: ALLOWED });
 
@@ -475,6 +475,7 @@ async function readColumns(k: Kysely<any>, schema: string, tableName: string): P
       name: r.column_name,
       sqlType,
       nullable: r.is_nullable === "YES",
+      udtName: r.udt_name.toLowerCase(),
     };
 
     const def = parsePgDefault(r.column_default);
 
@@ -46,6 +46,12 @@ export interface ColumnDescriptor {
   name: string;
   sqlType: SqlType;
   nullable: boolean;
+  /**
+   * Postgres `udt_name` as introspected (`text`, `varchar`, `bpchar`, `citext`, …). Set by
+   * the Postgres introspector only; absent on the expected side and on SQLite. `sqlType`
+   * folds every unrecognised type into `text`, so this is the only place citext survives.
+   */
+  udtName?: string;
   default?: ColumnDefault;
   identity?: "increment" | "uuid";
   /**
 
@@ -50,3 +50,23 @@ describe("diffTableChecks — postgres existing-table evolution", () => {
     expect(r.changes.some((c) => c.kind.endsWith("-check"))).toBe(false);
   });
 });
+
+describe("diffTableChecks — regex check on a text-family column", () => {
+  const generated = CHK("spaces_key_regex_chk", `"key" ~ '^[a-z0-9][a-z0-9-]*$'`);
+  const stored = CHK("spaces_key_regex_chk", `(((key)::text ~ '^[a-z0-9][a-z0-9-]*$'::text))`);
+  const withKey = (udtName: string | undefined, checks: CheckDescriptor[]): SchemaSnapshot => ({
+    tables: [{ name: "spaces", columns: [{ name: "key", sqlType: { kind: "text" }, nullable: false, ...(udtName ? { udtName } : {}) }],
+      indexes: [], foreignKeys: [], checks, primaryKey: [] }],
+    views: [],
+  });
+  const checkChanges = async (udtName: string | undefined) => {
+    const r = await diff({ expected: withKey(undefined, [generated]), actual: withKey(udtName, [stored]), dialect: "postgres" });
+    return r.changes.filter((c) => c.kind.endsWith("-check"));
+  };
+  test.each(["text", "varchar", "bpchar"])("%s column: Postgres's rewrite is no drift", async (udt) => {
+    expect(await checkChanges(udt)).toEqual([]);
+  });
+  test("citext column: cast vs uncast is drift", async () => {
+    expect((await checkChanges("citext")).map((c) => c.kind).sort()).toEqual(["add-check", "drop-check"]);
+  });
+});
@@ -208,14 +208,21 @@ describe("stripCheckWrapper", () => {
 describe("regex check on a varchar/text column", () => {
   const generated = `"key" ~ '^[a-z0-9][a-z0-9-]*$'`;
   const introspected = `(((key)::text ~ '^[a-z0-9][a-z0-9-]*$'::text))`;
-  test("Postgres's added column cast does not read as drift", () => {
-    expect(checkExprEquals(generated, introspected)).toBe(true);
-    expect(checkExprEquals(generated, `(((key)::text !~* '^[a-z0-9][a-z0-9-]*$'::text))`)).toBe(false);
+  const textColumns = new Set(["key"]);
+  test("Postgres's added column cast does not read as drift on a text-family column", () => {
+    expect(checkExprEquals(generated, introspected, textColumns)).toBe(true);
+    expect(checkExprEquals(generated, `(((key)::text !~* '^[a-z0-9][a-z0-9-]*$'::text))`, textColumns)).toBe(false);
+  });
+  test("without a text-family column set the cast is kept", () => {
+    expect(checkExprEquals(generated, introspected)).toBe(false);
+  });
+  test("a cast on a column outside the set (citext) reads as drift", () => {
+    expect(checkExprEquals(generated, introspected, new Set(["other"]))).toBe(false);
   });
   test("a changed regex pattern still reads as drift", () => {
-    expect(checkExprEquals(generated, `(((key)::text ~ '^[a-z][a-z0-9-]*$'::text))`)).toBe(false);
+    expect(checkExprEquals(generated, `(((key)::text ~ '^[a-z][a-z0-9-]*$'::text))`, textColumns)).toBe(false);
   });
   test("a cast that is not before a regex operator survives", () => {
-    expect(checkExprEquals("qty > 0", "((qty)::text > '0'::text)")).toBe(false);
+    expect(checkExprEquals("qty > 0", "((qty)::text > '0'::text)", new Set(["qty"]))).toBe(false);
   });
 });