@metaobjectsdev/migrate-ts 0.14.1 → 0.15.0-rc.1

package/src/expected-schema.ts

@@ -40,6 +40,8 @@ import {
   FIELD_SUBTYPE_OBJECT,
   FIELD_SUBTYPE_MAP,
   FIELD_SUBTYPE_UUID,
+  FIELD_SUBTYPE_URI,
+  FIELD_SUBTYPE_INET,
   FIELD_SUBTYPE_ENUM,
   FIELD_ATTR_VALUES,
   FIELD_ATTR_OBJECT_REF,
@@ -47,9 +49,7 @@ import {
   FIELD_ATTR_DB_COLUMN_TYPE,
   DB_COLUMN_TYPE_UUID,
   DB_COLUMN_TYPE_JSONB,
-  DB_COLUMN_TYPE_TIMESTAMP_WITH_TZ,
-  DB_COLUMN_TYPE_UUID_ARRAY,
-  DB_COLUMN_TYPE_TEXT_ARRAY,
+  FIELD_ATTR_LOCAL_TIME,
   STORAGE_FLATTENED,
   DOC_ATTR_DESCRIPTION,
   applyColumnNamingStrategy, DEFAULT_COLUMN_NAMING_STRATEGY,
@@ -110,17 +110,19 @@ export function buildExpectedSchema(
   //   - projections (read-only @kind source with no writable peer — handled by
   //     the view-diff pipeline, not the table diff)
   const entities: { entity: MetaObject; tableName: string }[] = [];
-  for (const child of root.ownChildren()) {
+  // ADR-0039: effective children — resolve rather than rely on root being unextended.
+  for (const child of root.children()) {
     if (child.type !== TYPE_OBJECT) continue;
     if (child.isAbstract) continue;
     if (child.subType === "value") continue;
     // FR-017 TPH: a subtype shares its discriminator base's single table, so it
     // emits no table of its own. Its own columns are folded into the base below.
     if (isTphSubtype(child)) continue;
-    const hasReadOnlySource = child.ownChildren().some(
+    // ADR-0039: effective children — an entity may inherit its source.rdb via extends.
+    const hasReadOnlySource = child.children().some(
       (c) => c instanceof MetaSource && c.isReadOnly(),
     );
-    const hasWritableSource = child.ownChildren().some(
+    const hasWritableSource = child.children().some(
       (c) => c instanceof MetaSource && c.isWritable(),
     );
     // Projection: read-only and not write-through.
@@ -223,6 +225,8 @@ function normalizeForSqlite(sqlType: SqlType): SqlType {
 function discriminatorBaseOf(entity: MetaData): MetaData | undefined {
   let a = entity.superResolved;
   while (a !== undefined) {
+    // ADR-0039 category 3: super-resolution walk — read each ancestor's OWN
+    // @discriminator as we ascend (this manual walk IS the resolution).
     if (a.ownAttr(OBJECT_ATTR_DISCRIMINATOR) !== undefined) return a;
     a = a.superResolved;
   }
@@ -233,19 +237,23 @@ function discriminatorBaseOf(entity: MetaData): MetaData | undefined {
  *  discriminator-bearing ancestor). Such an entity emits no table of its own. */
 function isTphSubtype(entity: MetaData): boolean {
   return (
-    entity.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE) !== undefined &&
+    // ADR-0039: effective attr — @discriminatorValue may be inherited (sub-subtype).
+    entity.attr(OBJECT_ATTR_DISCRIMINATOR_VALUE) !== undefined &&
     discriminatorBaseOf(entity) !== undefined
   );
 }
 
 /** Concrete TPH subtypes whose discriminator base is `base` (root-level scan). */
 function tphConcreteSubtypes(base: MetaObject, root: MetaData): MetaObject[] {
-  if (base.ownAttr(OBJECT_ATTR_DISCRIMINATOR) === undefined) return [];
-  return root.ownChildren().filter(
+  // ADR-0039: effective attr — @discriminator may be inherited.
+  if (base.attr(OBJECT_ATTR_DISCRIMINATOR) === undefined) return [];
+  // ADR-0039: effective children — resolve rather than rely on root being unextended.
+  return root.children().filter(
     (c): c is MetaObject =>
       c.type === TYPE_OBJECT &&
       !c.isAbstract &&
-      c.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE) !== undefined &&
+      // ADR-0039: effective attr — @discriminatorValue may be inherited (sub-subtype).
+      c.attr(OBJECT_ATTR_DISCRIMINATOR_VALUE) !== undefined &&
       discriminatorBaseOf(c) === base,
   );
 }
@@ -264,7 +272,8 @@ function buildTable(
 
   const pkJsNames = pkIdentity ? readIdentityFields(pkIdentity) : [];
   const pkGeneration = pkIdentity
-    ? (pkIdentity.ownAttr(IDENTITY_ATTR_GENERATION) as string | undefined)
+    // ADR-0039: effective attr — @generation may be inherited via the identity's extends.
+    ? (pkIdentity.attr(IDENTITY_ATTR_GENERATION) as string | undefined)
     : undefined;
 
   const primaryKey = pkJsNames.map((jsName) => {
@@ -277,7 +286,8 @@ function buildTable(
     const isPk = pkJsNames.includes(field.name);
     if (
       field.subType === FIELD_SUBTYPE_OBJECT &&
-      field.ownAttr(FIELD_ATTR_STORAGE) === STORAGE_FLATTENED
+      // ADR-0039: resolving — @storage may be inherited via extends.
+      field.attr(FIELD_ATTR_STORAGE) === STORAGE_FLATTENED
     ) {
       // Flattened storage: expand nested value-object fields as prefixed columns.
       // The parent field.object itself does NOT produce its own column.
@@ -291,9 +301,12 @@ function buildTable(
   // OWN fields into the single table as NULLABLE columns (a row of any other
   // subtype stores NULL there), even when the field is @required. Dedupe by
   // column name so an inherited/overridden base column is not re-emitted.
-  if (entity.ownAttr(OBJECT_ATTR_DISCRIMINATOR) !== undefined) {
+  // ADR-0039: effective attr — @discriminator may be inherited (deep TPH base).
+  if (entity.attr(OBJECT_ATTR_DISCRIMINATOR) !== undefined) {
     const existing = new Set(columns.map((c) => c.name));
     for (const sub of tphConcreteSubtypes(entity, root)) {
+      // ADR-0039 category 1: emit-declared-here — fold ONLY the subtype's OWN
+      // fields (inherited base fields are already emitted on the base table).
       for (const field of sub.ownChildren()) {
         if (field.type !== TYPE_FIELD) continue;
         const col = buildColumn(field, false, undefined, strategy);
@@ -339,7 +352,8 @@ function buildSecondaryIndexes(
   // column has `.unique()`. We mirror them in the expected schema so the diff
   // doesn't see them as drop-only on the actual side.
   for (const field of entity.fields()) {
-    if (field.ownAttr(FIELD_ATTR_UNIQUE) !== true) continue;
+    // ADR-0039: resolving — @unique may be inherited via extends.
+    if (field.attr(FIELD_ATTR_UNIQUE) !== true) continue;
     const colName = resolveColumnName(field, strategy);
     indexes.push({
       name: `${tableName}_${colName}_unique`,
@@ -352,7 +366,8 @@ function buildSecondaryIndexes(
   // Drizzle emits the index using the identity's @name attr directly (no table
   // prefix), so the expected name must match.
   for (const identity of entity.secondaryIdentities()) {
-    const exprRaw = identity.ownAttr(IDENTITY_ATTR_EXPR);
+    // ADR-0039: effective attrs — a secondary identity's attrs may be inherited via extends.
+    const exprRaw = identity.attr(IDENTITY_ATTR_EXPR);
     const expr = typeof exprRaw === "string" && exprRaw.trim().length > 0 ? exprRaw.trim() : undefined;
     const fieldNames = readIdentityFields(identity);
     // An expression index keys off @expr (not @fields); a plain index needs @fields.
@@ -361,21 +376,21 @@ function buildSecondaryIndexes(
       const field = findField(entity, jsName);
       return field ? resolveColumnName(field, strategy) : applyColumnNamingStrategy(jsName, strategy);
     });
-    const uniqueAttr = identity.ownAttr(IDENTITY_ATTR_UNIQUE);
+    const uniqueAttr = identity.attr(IDENTITY_ATTR_UNIQUE);
     const index: IndexDescriptor = {
       name: identity.name,
       columns: expr ? [] : cols,
       unique: uniqueAttr !== false,
     };
     if (expr) index.expr = expr;
-    const usingRaw = identity.ownAttr(IDENTITY_ATTR_USING);
+    const usingRaw = identity.attr(IDENTITY_ATTR_USING);
     if (typeof usingRaw === "string" && usingRaw.trim().length > 0 && usingRaw.trim() !== "btree") {
       index.using = usingRaw.trim();
     }
     // @orders — per-field sort direction (positional to @fields). Only attach when
     // at least one field is descending (an all-ascending array is the default and
     // must serialize identically to "no orders" for diff stability).
-    const ordersRaw = identity.ownAttr(IDENTITY_ATTR_ORDERS);
+    const ordersRaw = identity.attr(IDENTITY_ATTR_ORDERS);
     if (Array.isArray(ordersRaw)) {
       const orders = cols.map((_, i) => (ordersRaw[i] === "desc" ? "desc" : "asc")) as (
         "asc" | "desc"
@@ -383,7 +398,7 @@ function buildSecondaryIndexes(
       if (orders.some((o) => o === "desc")) index.orders = orders;
     }
     // @where — partial-index predicate.
-    const whereRaw = identity.ownAttr(IDENTITY_ATTR_WHERE);
+    const whereRaw = identity.attr(IDENTITY_ATTR_WHERE);
     if (typeof whereRaw === "string" && whereRaw.trim().length > 0) {
       index.where = whereRaw.trim();
     }
@@ -430,7 +445,8 @@ function validatorCheck(
     case VALIDATOR_SUBTYPE_REGEX: {
       // Postgres-only: SQLite has no native regex operator.
       if (dialect === "sqlite" || dialect === "d1") return null;
-      const pattern = v.ownAttr(VALIDATOR_ATTR_PATTERN);
+      // ADR-0039: effective attr — @pattern may be inherited via the validator's extends.
+      const pattern = v.attr(VALIDATOR_ATTR_PATTERN);
       if (typeof pattern !== "string" || pattern.length === 0) return null;
       return {
         name: `${tableName}_${col}_regex_chk`,
@@ -531,18 +547,20 @@ function crossFieldCheck(
 ): CheckDescriptor | null {
   switch (v.subType) {
     case VALIDATOR_SUBTYPE_COMPARISON: {
-      const left = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_LEFT), strategy);
-      const right = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_RIGHT), strategy);
-      const op = COMPARISON_SQL_OP[String(v.ownAttr(VALIDATOR_ATTR_OP))];
+      // ADR-0039: effective attrs — cross-field validator attrs may be inherited via extends.
+      const left = resolveRef(entity, v.attr(VALIDATOR_ATTR_LEFT), strategy);
+      const right = resolveRef(entity, v.attr(VALIDATOR_ATTR_RIGHT), strategy);
+      const op = COMPARISON_SQL_OP[String(v.attr(VALIDATOR_ATTR_OP))];
       if (!left || !right || !op) return null;
       const lc = resolveColumnName(left.field, strategy);
       return { name: `${tableName}_${lc}_cmp_chk`, expression: `${left.qcol} ${op} ${right.qcol}` };
     }
     case VALIDATOR_SUBTYPE_REQUIRED_WHEN: {
-      const target = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_FIELD), strategy);
-      const when = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_WHEN), strategy);
+      // ADR-0039: effective attrs — cross-field validator attrs may be inherited via extends.
+      const target = resolveRef(entity, v.attr(VALIDATOR_ATTR_FIELD), strategy);
+      const when = resolveRef(entity, v.attr(VALIDATOR_ATTR_WHEN), strategy);
       if (!target || !when) return null;
-      const lit = renderEquals(v.ownAttr(VALIDATOR_ATTR_EQUALS), when.field, dialect);
+      const lit = renderEquals(v.attr(VALIDATOR_ATTR_EQUALS), when.field, dialect);
       const fc = resolveColumnName(target.field, strategy);
       return {
         name: `${tableName}_${fc}_reqwhen_chk`,
@@ -550,10 +568,11 @@ function crossFieldCheck(
       };
     }
     case VALIDATOR_SUBTYPE_PRESENT_IFF: {
-      const target = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_FIELD), strategy);
-      const when = resolveRef(entity, v.ownAttr(VALIDATOR_ATTR_WHEN), strategy);
+      // ADR-0039: effective attrs — cross-field validator attrs may be inherited via extends.
+      const target = resolveRef(entity, v.attr(VALIDATOR_ATTR_FIELD), strategy);
+      const when = resolveRef(entity, v.attr(VALIDATOR_ATTR_WHEN), strategy);
       if (!target || !when) return null;
-      const lit = renderEquals(v.ownAttr(VALIDATOR_ATTR_EQUALS), when.field, dialect);
+      const lit = renderEquals(v.attr(VALIDATOR_ATTR_EQUALS), when.field, dialect);
       const fc = resolveColumnName(target.field, strategy);
       return {
         name: `${tableName}_${fc}_presentiff_chk`,
@@ -561,7 +580,8 @@ function crossFieldCheck(
       };
     }
     case VALIDATOR_SUBTYPE_AT_LEAST_ONE: {
-      const raw = v.ownAttr(VALIDATOR_ATTR_FIELDS);
+      // ADR-0039: effective attr — @fields may be inherited via the validator's extends.
+      const raw = v.attr(VALIDATOR_ATTR_FIELDS);
       const names = Array.isArray(raw) ? raw : (typeof raw === "string" ? [raw] : []);
       const refs = names.map((n) => resolveRef(entity, n, strategy));
       if (refs.length === 0 || refs.some((r) => r === null)) return null;
@@ -611,7 +631,8 @@ function buildForeignKeys(
     const { onDelete, onUpdate } = resolveReferentialActions(entity, refChild);
     // An explicit @constraintName adopts an existing FK name (e.g. a database
     // created by another toolchain); absent → the auto-derived default.
-    const constraintNameOverride = refChild.ownAttr(IDENTITY_ATTR_CONSTRAINT_NAME);
+    // ADR-0039: effective attr — @constraintName may be inherited via the identity's extends.
+    const constraintNameOverride = refChild.attr(IDENTITY_ATTR_CONSTRAINT_NAME);
     const constraintName =
       typeof constraintNameOverride === "string" && constraintNameOverride.length > 0
         ? constraintNameOverride
@@ -644,7 +665,8 @@ function buildForeignKeys(
 function flattenObjectField(
   field: MetaData, root: MetaRoot, strategy: ColumnNamingStrategy,
 ): ColumnDescriptor[] {
-  const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+  // ADR-0039: resolving — @objectRef may be inherited via extends.
+  const ref = field.attr(FIELD_ATTR_OBJECT_REF);
   if (typeof ref !== "string" || ref.length === 0) return [];
   const targetObject = root.findObject(ref);
   if (targetObject === undefined) return [];
@@ -673,7 +695,8 @@ function buildColumn(
 ): ColumnDescriptor {
   // Both the @required attr and the validator.required child signal NOT NULL.
   const fieldIsRequired = isRequired(field);
-  const defaultRaw = field.ownAttr(FIELD_ATTR_DEFAULT);
+  // ADR-0039: resolving — @default may be inherited via extends.
+  const defaultRaw = field.attr(FIELD_ATTR_DEFAULT);
 
   const col: ColumnDescriptor = {
     name: resolveColumnName(field, strategy),
@@ -692,7 +715,8 @@ function buildColumn(
     // NOT NULL timestamp populates without an explicit value. (The per-update
     // refresh for "onUpdate" is the ORM/trigger's job, not the column default.)
     // An explicit @default always wins, so this only applies when none was set.
-    const autoSet = field.ownAttr(FIELD_ATTR_AUTO_SET);
+    // ADR-0039: resolving — @autoSet may be inherited via extends.
+    const autoSet = field.attr(FIELD_ATTR_AUTO_SET);
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
       col.default = { kind: "expr", value: "now()" };
     }
@@ -708,26 +732,60 @@ function buildColumn(
   return col;
 }
 
+/**
+ * The native Postgres array ELEMENT SqlType for an `isArray` scalar field, or
+ * undefined when the subtype has no native-array form (object/map → single jsonb
+ * column; everything else falls through to the scalar subtype default).
+ *
+ * dbColumnType slim-and-derive Phase 1 wires the two derived cases the design calls
+ * out: `field.string` → `text[]`, `field.uuid` → `uuid[]`. This mirrors codegen-ts's
+ * column-mapper, which emits native `.array()` for the same scalar subtypes.
+ */
+function arrayElementSqlType(field: MetaData): SqlType | undefined {
+  switch (field.subType) {
+    case FIELD_SUBTYPE_STRING: return { kind: "text" };
+    case FIELD_SUBTYPE_UUID:   return { kind: "uuid" };
+    default:                   return undefined;
+  }
+}
+
 function subtypeToSqlType(field: MetaData): SqlType {
   // R6 Plan 2b: a physical @dbColumnType override selects the DB column type
   // instead of the subtype default (the loader has already validated the
   // (subtype × value) pairing, so an unrecognized value never reaches here).
+  // dbColumnType slim-and-derive Phase 1: the array overrides (uuid_array /
+  // text_array) are RETIRED — native text[]/uuid[] are derived from `isArray`
+  // below, not declared here. ADR-0036 Wave 2: `timestamp_with_tz` is RETIRED
+  // too — field.timestamp is tz-aware by default + @localTime opts into naive
+  // (handled in the subtype switch below), not via this physical escape hatch.
+  // ADR-0039: @dbColumnType is the ONE deliberately own-only attr — a physical
+  // column-type override is never inherited (a logical field extending a base
+  // must not silently pick up the base's physical DB type). Keep ownAttr.
   const dbColumnType = field.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE);
   if (typeof dbColumnType === "string") {
     switch (dbColumnType) {
-      case DB_COLUMN_TYPE_UUID:              return { kind: "uuid" };
-      case DB_COLUMN_TYPE_JSONB:             return { kind: "json" };
-      case DB_COLUMN_TYPE_TIMESTAMP_WITH_TZ: return { kind: "timestamp", withTimezone: true };
-      case DB_COLUMN_TYPE_UUID_ARRAY:        return { kind: "array", element: { kind: "uuid" } };
-      case DB_COLUMN_TYPE_TEXT_ARRAY:        return { kind: "array", element: { kind: "text" } };
+      case DB_COLUMN_TYPE_UUID:  return { kind: "uuid" };
+      case DB_COLUMN_TYPE_JSONB: return { kind: "json" };
     }
   }
 
+  // Native array columns are DERIVED from `isArray` (dbColumnType slim-and-derive
+  // Phase 1). Only scalar subtypes with a stable element SqlType get a native
+  // Postgres array (e.g. field.string → text[], field.uuid → uuid[]). field.object
+  // / field.map carry their array-ness inside a single jsonb column (no native
+  // array — handled by the subtype switch returning { kind: "json" }).
+  // ADR-0039: resolving — array-ness may be inherited via extends.
+  if (field.resolvedIsArray()) {
+    const element = arrayElementSqlType(field);
+    if (element !== undefined) return { kind: "array", element };
+  }
+
   const subType = field.subType;
   switch (subType) {
     case FIELD_SUBTYPE_STRING:    {
       // @maxLength is declared as ATTR_SUBTYPE_INT so the loader coerces it to a number.
-      const m = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+      // ADR-0039: resolving — @maxLength may be inherited via extends.
+      const m = field.attr(FIELD_ATTR_MAX_LENGTH);
       return typeof m === "number" ? { kind: "text", maxLength: m } : { kind: "text" };
     }
     case FIELD_SUBTYPE_INT:       return { kind: "integer", bits: 32 };
@@ -738,8 +796,9 @@ function subtypeToSqlType(field: MetaData): SqlType {
     case FIELD_SUBTYPE_DECIMAL:   {
       // @precision/@scale are declared as ATTR_SUBTYPE_INT so the loader coerces them
       // to numbers. Both present → NUMERIC(p,s); absent → bare NUMERIC (back-compat).
-      const precision = field.ownAttr(FIELD_ATTR_PRECISION);
-      const scale = field.ownAttr(FIELD_ATTR_SCALE);
+      // ADR-0039: resolving — @precision / @scale may be inherited via extends.
+      const precision = field.attr(FIELD_ATTR_PRECISION);
+      const scale = field.attr(FIELD_ATTR_SCALE);
       if (typeof precision === "number" && typeof scale === "number") {
         return { kind: "numeric", precision, scale };
       }
@@ -751,10 +810,16 @@ function subtypeToSqlType(field: MetaData): SqlType {
     case FIELD_SUBTYPE_BOOLEAN:   return { kind: "boolean" };
     case FIELD_SUBTYPE_DATE:      return { kind: "date" };
     case FIELD_SUBTYPE_TIME:      return { kind: "time" }; // Postgres native TIME (whole-second wire form)
-    case FIELD_SUBTYPE_TIMESTAMP: return { kind: "timestamp", withTimezone: false };
+    case FIELD_SUBTYPE_TIMESTAMP:
+      // ADR-0036 Wave 2: instant / tz-aware BY DEFAULT (→ timestamptz). A naive
+      // wall-clock value opts out with @localTime:true (→ TIMESTAMP, no tz).
+      // ADR-0039: resolving — @localTime may be inherited via extends.
+      return { kind: "timestamp", withTimezone: field.attr(FIELD_ATTR_LOCAL_TIME) !== true };
     case FIELD_SUBTYPE_OBJECT:
     case FIELD_SUBTYPE_MAP:       return { kind: "json" }; // field.map → single jsonb (pg) / text-json (sqlite) column
     case FIELD_SUBTYPE_UUID:      return { kind: "uuid" }; // R6 Plan 2a — Postgres native uuid
+    case FIELD_SUBTYPE_URI:       return { kind: "text" }; // ADR-0036/0037 Wave 3 — no Postgres uri type → text
+    case FIELD_SUBTYPE_INET:      return { kind: "inet" }; // ADR-0036/0037 Wave 3 — Postgres-native inet
     default:                      return { kind: "text" }; // unknown → text fallback
   }
 }

package/src/introspect/postgres.ts

@@ -148,6 +148,9 @@ export function pgTypeToSqlType(dataType: string, maxLength?: number | null, udt
   // UUID
   if (dt === "uuid") return { kind: "uuid" };
 
+  // INET (ADR-0036/0037 Wave 3 — field.inet)
+  if (dt === "inet") return { kind: "inet" };
+
   // Unknown types (user-defined enums, citext, ltree, etc.) fall back to text
   // so we don't blow up on unrecognised types.
   return { kind: "text" };

package/src/referential-actions.ts

@@ -17,7 +17,8 @@ import { SetNullNotNullableError } from "./errors.js";
 // ---------------------------------------------------------------------------
 
 export function readIdentityFields(identity: MetaData): string[] {
-  const raw = identity.ownAttr(IDENTITY_ATTR_FIELDS);
+  // ADR-0039: effective attr — @fields may be inherited via the identity's extends.
+  const raw = identity.attr(IDENTITY_ATTR_FIELDS);
   if (Array.isArray(raw)) return raw.map(String).filter((s) => s.length > 0);
   // Fallback: comma-separated string form (defensive; canonical form is array)
   if (typeof raw === "string") return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -32,9 +33,10 @@ export function findField(entity: MetaObject, name: string): MetaData | undefine
 }
 
 export function isRequired(field: MetaData): boolean {
-  const attr = field.ownAttr(FIELD_ATTR_REQUIRED);
+  // ADR-0039: resolving — @required and validator.required may be inherited via extends.
+  const attr = field.attr(FIELD_ATTR_REQUIRED);
   if (attr === true || attr === "true") return true;
-  return field.ownChildren().some(
+  return field.children().some(
     (c) => c.type === TYPE_VALIDATOR && c.subType === VALIDATOR_SUBTYPE_REQUIRED,
   );
 }

package/src/sql-type.ts

@@ -18,6 +18,7 @@ export type SqlType =
   | { kind: "json" }
   | { kind: "blob" }
   | { kind: "uuid" }
+  | { kind: "inet" }        // Postgres-native inet (IPv4/IPv6) — field.inet (ADR-0036/0037 Wave 3)
   | { kind: "array"; element: SqlType };   // native SQL array (e.g. uuid[], text[])
 
 /** Structural equality on SqlType. */
@@ -44,6 +45,7 @@ export function sqlTypeEquals(a: SqlType, b: SqlType): boolean {
     case "json":
     case "blob":
     case "uuid":
+    case "inet":
       return true;
   }
 }
@@ -94,6 +96,7 @@ export function isWidening(from: SqlType, to: SqlType): boolean {
     case "json":
     case "blob":
     case "uuid":
+    case "inet":
     case "timestamp":
     case "array":
       // Array element-type changes are not auto-widened — require explicit allow.