@vibeorm/migrate 2.5.0 → 2.7.0

package/dist/fs.js

@@ -15,8 +15,8 @@ function hasMysqlGlobalCatalogVisibility(params) {
 }
 
 // packages/migrate/src/module-ownership.ts
-import { VibeError as VibeError17, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect3, renderModuleDependencyQuery } from "@vibeorm/sql";
+import { VibeError as VibeError18, sqlObjectKey as sqlObjectKey7, sqlObjectNamespace as sqlObjectNamespace3 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect4, renderModuleDependencyQuery } from "@vibeorm/sql";
 
 // packages/migrate/src/desired-state.ts
 import { VibeError, assertValidSchemaIR, isSqlObjectDefinition, isSqlObjectIdentity, providerToDialect, sqlObjectKey } from "@vibeorm/schema";
@@ -115,14 +115,11 @@ function parseMigrationMetadata(params) {
   }
 }
 
-// packages/migrate/src/object-ownership.ts
-import { VibeError as VibeError6, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, sqlObjectKey as sqlObjectKey2 } from "@vibeorm/schema";
-
 // packages/migrate/src/normalize.ts
-import { VibeError as VibeError5, defaultForeignKeyName, defaultIndexName, enumStorageOf, isEnumType as isEnumType5, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { assertIndexOperatorClasses, VibeError as VibeError5, defaultForeignKeyName, defaultIndexName, enumStorageOf, isEnumType as isEnumType5, qualifiedSqlName as qualifiedSqlName3, assertSqlNamespace, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 
 // packages/migrate/src/relations.ts
-import { implicitJoinTable, isImplicitManyToManyRelation } from "@vibeorm/schema";
+import { implicitJoinTable, isImplicitManyToManyRelation, qualifiedSqlName, unsupportedCapability, providerToDialect as providerToDialect2 } from "@vibeorm/schema";
 function detectImplicitM2MPairs(params) {
   const { schema } = params;
   const pairs = [];
@@ -138,14 +135,20 @@ function detectImplicitM2MPairs(params) {
         modelB: relation.targetModel,
         ...relation.relationName === undefined ? {} : { relationName: relation.relationName }
       });
-      if (seen.has(joinTable.tableName))
+      const target = schema.models.find((entry) => entry.name === relation.targetModel);
+      const namespace = qualifiedSqlName({ name: model.name, namespace: model.namespace }).namespace;
+      if (namespace !== qualifiedSqlName({ name: target.name, namespace: target.namespace }).namespace)
+        throw unsupportedCapability({ dialect: providerToDialect2({ provider: schema.datasource.provider }), feature: "implicitJoinNamespaces", hint: "Implicit join parents must share one physical namespace" });
+      const key = JSON.stringify([namespace, joinTable.tableName]);
+      if (seen.has(key))
         continue;
-      seen.add(joinTable.tableName);
+      seen.add(key);
       pairs.push({
         modelA: joinTable.modelA,
         modelB: joinTable.modelB,
         ...relation.relationName === undefined ? {} : { relationName: relation.relationName },
-        tableName: joinTable.tableName
+        tableName: joinTable.tableName,
+        ...model.namespace === undefined && target.namespace === undefined ? {} : { namespace }
       });
     }
   }
@@ -153,7 +156,7 @@ function detectImplicitM2MPairs(params) {
 }
 
 // packages/migrate/src/postgres-types.ts
-import { VibeError as VibeError2, isEnumType, scalarListDefault, serializeJsonDefault } from "@vibeorm/schema";
+import { VibeError as VibeError2, isEnumType, scalarListDefault, serializeJsonDefault, qualifiedSqlName as qualifiedSqlName2 } from "@vibeorm/schema";
 import { POSTGRES_CODECS, postgresDialect, toPgArrayLiteral, parsePostgresTypeName, renderPostgresTypeName } from "@vibeorm/sql";
 var SCALAR_TO_PG = {
   String: "text",
@@ -169,6 +172,9 @@ var SCALAR_TO_PG = {
 var CANONICAL_EQUIVALENTS = {
   DateTime: ["timestamptz(3)", "timestamptz(6)"]
 };
+var EXACT_CANONICAL_EQUIVALENTS = {
+  DateTime: ["timestamptz(6)"]
+};
 var CANONICAL_UDT = {
   text: "String",
   bool: "Boolean",
@@ -237,13 +243,15 @@ var NATIVE_ALIASES = {
 var IMPLICIT_MODIFIERS = {
   bit: "(1)"
 };
+var DEFAULT_PRECISION_SIX = new Set(["timestamp", "time", "timetz"]);
 function normalizeNativeType(params) {
   const compact = params.raw.toLowerCase().replace(/\s+/g, "");
   const match = compact.match(/^([a-z_0-9]+)(\(.*\))?(\[\])?$/);
   if (match === null)
     return compact;
   const base = NATIVE_ALIASES[match[1]] ?? match[1];
-  return `${base}${match[2] ?? IMPLICIT_MODIFIERS[base] ?? ""}${match[3] ?? ""}`;
+  const modifier = DEFAULT_PRECISION_SIX.has(base) && match[2] === "(6)" ? "" : match[2] ?? IMPLICIT_MODIFIERS[base] ?? "";
+  return `${base}${modifier}${match[3] ?? ""}`;
 }
 function parseUnsupportedPostgresType(params) {
   const temporal = /^\s*(time(?:stamp)?)\s*(\(\s*\d+\s*\))?\s+(with|without)\s+time\s+zone\s*((?:\[\s*\]\s*)*)$/i.exec(params.raw);
@@ -256,7 +264,7 @@ function parseUnsupportedPostgresType(params) {
   return NATIVE_ALIASES[base] === undefined ? undefined : parsePostgresTypeName({ raw: normalizeNativeType(params) });
 }
 function columnTypeKey(params) {
-  const { field } = params;
+  const { field, exact } = params;
   const listSuffix = field.isList ? "[]" : "";
   if (field.isUnsupported === true) {
     const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
@@ -267,22 +275,48 @@ function columnTypeKey(params) {
     const scalar = namespace === undefined || namespace === "pg_catalog" ? scalarForBuiltinType({ name: parsed.name }) : undefined;
     if (scalar !== undefined) {
       const { isUnsupported: _unsupported, nativeTypeIdentity: _identity, ...rest } = field;
-      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList } });
+      return columnTypeKey({ field: { ...rest, type: scalar, nativeType: `${parsed.name}${parsed.modifier ?? ""}`, isList: parsed.array || field.isList }, ...exact === undefined ? {} : { exact } });
     }
     return `u:${JSON.stringify([namespace ?? null, parsed.name, parsed.modifier, parsed.array || field.isList])}`;
   }
   if (isEnumType(field.type)) {
-    return `e:${field.type.enum}${listSuffix}`;
+    const identity = qualifiedSqlName2({ name: field.type.enum, namespace: field.type.namespace });
+    return `e:${JSON.stringify([identity.namespace, identity.name])}${listSuffix}`;
   }
   if (field.nativeType !== undefined) {
     const normalized = normalizeNativeType({ raw: field.nativeType });
     const canonical = normalizeNativeType({ raw: SCALAR_TO_PG[field.type] });
-    const isCanonical = normalized === canonical || (CANONICAL_EQUIVALENTS[field.type]?.includes(normalized) ?? false);
+    const equivalents = exact === true ? EXACT_CANONICAL_EQUIVALENTS : CANONICAL_EQUIVALENTS;
+    const isCanonical = normalized === canonical || (equivalents[field.type]?.includes(normalized) ?? false);
     if (!isCanonical)
       return `n:${normalized}${listSuffix}`;
   }
   return `s:${field.type}${listSuffix}`;
 }
+function declaresExactColumnType(params) {
+  const { field } = params;
+  if (field.isUnsupported === true || field.nativeType === undefined || isEnumType(field.type))
+    return false;
+  return CANONICAL_EQUIVALENTS[field.type]?.includes(normalizeNativeType({ raw: field.nativeType })) ?? false;
+}
+function timestamptzPrecision(params) {
+  const { field } = params;
+  if (field.type !== "DateTime" || field.isUnsupported === true)
+    return;
+  const normalized = field.nativeType === undefined ? "timestamptz" : normalizeNativeType({ raw: field.nativeType });
+  if (normalized === "timestamptz")
+    return 6;
+  const match = /^timestamptz\((\d)\)$/.exec(normalized);
+  return match === null ? undefined : Number(match[1]);
+}
+function isTimestamptzPrecisionWidening(params) {
+  const { from, to } = params;
+  if (from.isList !== to.isList)
+    return false;
+  const before = timestamptzPrecision({ field: from });
+  const after = timestamptzPrecision({ field: to });
+  return before !== undefined && after !== undefined && after >= before;
+}
 function isScalarToArrayChange(params) {
   const { from, to } = params;
   if (from.isList || !to.isList)
@@ -309,7 +343,7 @@ function columnTypeSql(params) {
   }
   const listSuffix = field.isList ? "[]" : "";
   if (isEnumType(field.type)) {
-    return `${postgresDialect.quoteIdent({ name: "public" })}.${postgresDialect.quoteIdent({ name: field.type.enum })}${listSuffix}`;
+    return `${postgresDialect.quoteIdent({ name: field.type.namespace ?? "public" })}.${postgresDialect.quoteIdent({ name: field.type.enum })}${listSuffix}`;
   }
   if (field.nativeType !== undefined) {
     const normalized = normalizeNativeType({ raw: field.nativeType });
@@ -426,18 +460,18 @@ function quotePgString(params) {
 }
 
 // packages/migrate/src/sqlite-types.ts
-import { VibeError as VibeError3, isEnumType as isEnumType3, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError3, isEnumType as isEnumType3, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 import { ParamCollector, sqliteDialect } from "@vibeorm/sql";
 
 // packages/migrate/src/enum-values.ts
-import { isEnumType as isEnumType2, unsupportedCapability } from "@vibeorm/schema";
+import { isEnumType as isEnumType2, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 function resolveEnumValues(params) {
   const { name, enums } = params;
   const direct = enums.get(name);
   if (direct !== undefined)
     return direct.values;
   for (const enumDef of enums.values()) {
-    if (enumDef.name === name)
+    if ((enumDef.name === name || enumDef.dbName === name) && (params.namespace === undefined || (enumDef.namespace ?? "public") === params.namespace))
       return enumDef.values;
   }
   return;
@@ -452,7 +486,7 @@ function assertEnumStringTransition(params) {
     return;
   const reason = from.isList !== to.isList ? "change scalar/list shape separately from enum storage" : from.default?.kind === "dbgenerated" || to.default?.kind === "dbgenerated" ? "database-expression defaults may depend on the native enum type \u2014 migrate the default explicitly first" : dialect === "mysql" && isEnumType2(to.type) ? "non-strict mysql can silently replace out-of-list strings with '' \u2014 validate and migrate this column manually in strict mode" : undefined;
   if (reason !== undefined) {
-    throw unsupportedCapability({ dialect, feature: `enum storage conversion on "${table}"."${column}"`, hint: reason });
+    throw unsupportedCapability2({ dialect, feature: `enum storage conversion on "${table}"."${column}"`, hint: reason });
   }
 }
 
@@ -469,7 +503,7 @@ var SCALAR_TO_SQLITE = {
   Bytes: "BLOB"
 };
 function refuseSqliteScalarList(params) {
-  throw unsupportedCapability2({
+  throw unsupportedCapability3({
     dialect: "sqlite",
     feature: `scalar list column "${params.field.name}"`,
     hint: "sqlite has no array column type \u2014 model the list as a separate table or a Json column"
@@ -605,7 +639,7 @@ function parseSqliteEnumChecks(params) {
 }
 
 // packages/migrate/src/mysql-types.ts
-import { VibeError as VibeError4, isEnumType as isEnumType4, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { VibeError as VibeError4, isEnumType as isEnumType4, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 import { mysqlDialect } from "@vibeorm/sql";
 var SCALAR_TO_MYSQL = {
   String: `varchar(${mysqlDialect.conflictKeyEquality.defaultStringMaxLength})`,
@@ -619,7 +653,7 @@ var SCALAR_TO_MYSQL = {
   Bytes: "longblob"
 };
 function refuseMysqlScalarList(params) {
-  throw unsupportedCapability3({
+  throw unsupportedCapability4({
     dialect: "mysql",
     feature: `scalar list column "${params.field.name}"`,
     hint: "mysql has no array column type \u2014 model the list as a separate table or a JSON column"
@@ -691,7 +725,7 @@ function mysqlColumnTypeSql(params) {
       });
     }
     if (values.some((value) => /[\\\x00-\x1f\x7f]/.test(value)))
-      throw unsupportedCapability3({ dialect: "mysql", feature: "mysqlEnumLiteralEscaping", hint: "ENUM labels containing backslashes or control characters require a reviewed SQL-mode-specific migration" });
+      throw unsupportedCapability4({ dialect: "mysql", feature: "mysqlEnumLiteralEscaping", hint: "ENUM labels containing backslashes or control characters require a reviewed SQL-mode-specific migration" });
     return `ENUM(${values.map((value) => quotePgString({ value })).join(", ")})`;
   }
   if (field.nativeType !== undefined) {
@@ -750,25 +784,31 @@ function parseMysqlEnumColumnType(params) {
 function normalizeSchema(params) {
   const { schema } = params;
   const dialect = params.dialect ?? "postgres";
+  assertIndexOperatorClasses({ schema, dialect, physical: true });
   const enums = new Map;
   for (const enumDef of schema.enums) {
+    if (enumDef.namespace !== undefined)
+      assertSqlNamespace({ namespace: enumDef.namespace, dialect });
     if (enumStorageOf({ enumDef }) === "string")
       continue;
-    enums.set(enumDef.dbName ?? enumDef.name, enumDef);
+    enums.set(physicalNameKey({ name: enumDef.dbName ?? enumDef.name, namespace: enumDef.namespace, dialect }), enumDef);
   }
   const tables = new Map;
   const views = new Map;
   for (const model of schema.models) {
+    if (model.namespace !== undefined)
+      assertSqlNamespace({ namespace: model.namespace, dialect });
     if (model.isView) {
-      views.set(model.dbName ?? model.name, model);
+      views.set(physicalNameKey({ name: model.dbName ?? model.name, namespace: model.namespace, dialect }), model);
       continue;
     }
     const table = normalizeModel({ model, schema, dialect, enums });
-    tables.set(table.table, table);
+    tables.set(physicalNameKey({ name: table.table, namespace: table.namespace, dialect }), table);
   }
   const joinTables = new Map;
   for (const pair of detectImplicitM2MPairs({ schema })) {
-    joinTables.set(pair.tableName, normalizeJoinTable({ pair, schema, dialect }));
+    const join = normalizeJoinTable({ pair, schema, dialect });
+    joinTables.set(physicalNameKey({ name: join.table, namespace: join.namespace, dialect }), join);
   }
   return { tables, joinTables, enums, views };
 }
@@ -776,12 +816,15 @@ function physicalEnumField(params) {
   const { field, schema, dialect, table } = params;
   if (!isEnumType5(field.type))
     return field;
-  const name = field.type.enum;
-  const enumDef = schema.enums.find((candidate) => candidate.name === name || candidate.dbName === name);
+  const type = field.type;
+  if (type.namespace !== undefined)
+    assertSqlNamespace({ namespace: type.namespace, dialect });
+  const name = type.enum;
+  const enumDef = schema.enums.find((candidate) => (candidate.name === name || candidate.dbName === name) && (type.namespace === undefined || qualifiedSqlName3({ name, namespace: candidate.namespace }).namespace === type.namespace));
   if (enumDef === undefined)
     return field;
   if (enumStorageOf({ enumDef }) !== "string") {
-    return dialect === "postgres" ? { ...field, type: { enum: enumDef.dbName ?? enumDef.name } } : field;
+    return dialect === "postgres" ? { ...field, type: { enum: enumDef.dbName ?? enumDef.name, ...enumDef.namespace === undefined ? {} : { namespace: enumDef.namespace } } } : field;
   }
   const physical = {
     ...field,
@@ -808,7 +851,7 @@ function assertStringEnumLabelsFit(params) {
   const charLimit = varchar?.[1] === undefined ? undefined : Number(varchar[1]);
   const tooLong = values.some((value) => charLimit !== undefined && [...value].length > charLimit || textBytes !== undefined && new TextEncoder().encode(value).length > textBytes);
   if (!supported || tooLong) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect,
       feature: `string enum column "${table}"."${field.dbName ?? field.name}" stored as ${type}`,
       hint: supported ? "an enum label exceeds the physical column limit \u2014 choose a wider varchar or text type" : "use text or varchar storage; other types cannot preserve arbitrary enum labels verbatim"
@@ -816,16 +859,20 @@ function assertStringEnumLabelsFit(params) {
   }
 }
 function columnTypeKeyFor(params) {
-  const { field, dialect, enums } = params;
+  const { field, dialect, enums, exact } = params;
   switch (dialect) {
     case "postgres":
-      return columnTypeKey({ field });
+      return columnTypeKey({ field, ...exact === undefined ? {} : { exact } });
     case "sqlite":
       return sqliteColumnTypeKey({ field, enums });
     case "mysql":
       return mysqlColumnTypeKey({ field, enums });
   }
 }
+function columnTypeChanged(params) {
+  const { declared, actual } = params;
+  return declared.pinsExactType ? declared.exactTypeKey !== actual.exactTypeKey : declared.typeKey !== actual.typeKey;
+}
 function defaultFingerprintFor(params) {
   const { field, dialect } = params;
   switch (dialect) {
@@ -848,6 +895,8 @@ function normalizeModel(params) {
       name,
       field,
       typeKey: columnTypeKeyFor({ field, dialect, enums }),
+      exactTypeKey: columnTypeKeyFor({ field, dialect, enums, exact: true }),
+      pinsExactType: dialect === "postgres" && declaresExactColumnType({ field }),
       nullable: field.isOptional,
       defaultKey: defaultFingerprintFor({ field, dialect })
     });
@@ -858,7 +907,7 @@ function normalizeModel(params) {
   const checks = new Map;
   for (const check of model.checks ?? [])
     checks.set(check.name, check.expression);
-  return { model, table, columns, pk, indexes, fks, checks };
+  return { model, table, ...model.namespace === undefined ? {} : { namespace: model.namespace }, columns, pk, indexes, fks, checks };
 }
 function normalizePk(params) {
   const { model } = params;
@@ -879,7 +928,8 @@ function normalizeIndexes(params) {
       return {
         name: fieldDbName({ model, name: field.name }),
         desc: field.sort === "desc",
-        ...decimal ? { decimal: true } : {}
+        ...decimal ? { decimal: true } : {},
+        ...field.operatorClass === undefined ? {} : { operatorClass: field.operatorClass }
       };
     });
     const where = index.where;
@@ -910,7 +960,7 @@ function normalizeIndexes(params) {
 }
 function indexComparisonKey(params) {
   const { unique, kind, columns, where, nullsNotDistinct } = params;
-  const cols = columns.map((column) => `${column.name}${column.desc ? " desc" : ""}`).join(",");
+  const cols = columns.map((column) => `${column.name}${column.desc ? " desc" : ""}${column.operatorClass === undefined ? "" : ` ops:${JSON.stringify([column.operatorClass.namespace, column.operatorClass.name])}`}`).join(",");
   return `${unique ? "u" : "i"}${nullsNotDistinct === true ? "n" : ""}:${kind}:${cols}:${normalizeWhere({ where })}`;
 }
 function normalizeWhere(params) {
@@ -1088,7 +1138,7 @@ function normalizeFks(params) {
       const field = model.fields.find((candidate) => candidate.name === name);
       return field === undefined ? true : !field.isOptional;
     });
-    const key = `${columns.join(",")}\u2192${refTable}.${refColumns.join(",")}`;
+    const key = `${columns.join(",")}\u2192${physicalNameKey({ name: refTable, namespace: target?.namespace, dialect: params.dialect })}.${refColumns.join(",")}`;
     if (result.has(key))
       continue;
     result.set(key, {
@@ -1096,6 +1146,7 @@ function normalizeFks(params) {
       constraintName: relation.constraintName ?? defaultForeignKeyName({ table, columns, dialect: params.dialect }),
       columns,
       refTable,
+      ...target?.namespace === undefined ? {} : { refNamespace: target.namespace },
       refColumns,
       onDelete: resolveOnDelete({ explicit: relation.onDelete, required }),
       onUpdate: resolveOnUpdate({ explicit: relation.onUpdate })
@@ -1107,6 +1158,7 @@ function normalizeJoinTable(params) {
   const { pair, schema, dialect } = params;
   return {
     table: pair.tableName,
+    ...pair.namespace === undefined ? {} : { namespace: pair.namespace },
     a: joinTableEnd({ modelName: pair.modelA, schema, dialect, joinTable: pair.tableName }),
     b: joinTableEnd({ modelName: pair.modelB, schema, dialect, joinTable: pair.tableName })
   };
@@ -1132,10 +1184,24 @@ function joinTableEnd(params) {
   }
   return {
     table: model.dbName ?? model.name,
+    ...model.namespace === undefined ? {} : { namespace: model.namespace },
     column: pkField.dbName ?? pkField.name,
     field: physicalEnumField({ field: pkField, schema, dialect: params.dialect, table: model.dbName ?? model.name })
   };
 }
+function physicalNameKey(params) {
+  if (params.dialect !== undefined && params.dialect !== "postgres")
+    return params.name;
+  const identity = qualifiedSqlName3(params);
+  return JSON.stringify([identity.namespace, identity.name]);
+}
+function schemaNamespaces(params) {
+  return [...new Set([
+    ...params.schema.models.flatMap((model) => model.namespace === undefined || model.namespace === "public" ? [] : [model.namespace]),
+    ...params.schema.enums.flatMap((entry) => enumStorageOf({ enumDef: entry }) === "string" || entry.namespace === undefined || entry.namespace === "public" ? [] : [entry.namespace]),
+    ...(params.schema.migrationObjects ?? []).flatMap((object) => object.identity.kind === "namespace" ? [object.identity.name] : [])
+  ])];
+}
 function fieldDbName(params) {
   const { model, name } = params;
   const field = model.fields.find((candidate) => candidate.name === name);
@@ -1143,6 +1209,7 @@ function fieldDbName(params) {
 }
 
 // packages/migrate/src/object-ownership.ts
+import { VibeError as VibeError6, defaultPrimaryKeyName, enumStorageOf as enumStorageOf2, implicitJoinTableObjectNames, postgresGeneratedObjectName, qualifiedSqlName as qualifiedSqlName4, sqlObjectKey as sqlObjectKey2 } from "@vibeorm/schema";
 function legacyMigrationObjects(params) {
   return params.artifacts.map((artifact) => {
     const owner = artifact.owns;
@@ -1166,13 +1233,14 @@ function legacyMigrationObjects(params) {
 }
 function preserveMigrationObjects(params) {
   const namespace = params.namespace ?? (params.to.datasource.provider === "sqlite" ? "main" : "public");
-  const objects = params.objects.filter((object) => ("table" in object.identity ? object.identity.table.namespace : object.identity.name.namespace) === namespace);
+  const objects = params.objects;
   const models = params.from.models.flatMap((model) => {
     const table = model.dbName ?? model.name;
-    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
-    if (objects.some((object) => (object.identity.kind === "table" || object.identity.kind === "view") && object.identity.name.name === table))
+    const placement = qualifiedSqlName4({ name: table, namespace: model.namespace, defaultNamespace: namespace });
+    const target = params.to.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect: params.to.datasource.provider === "sqlite" ? "sqlite" : params.to.datasource.provider === "mysql" ? "mysql" : "postgres" }) === physicalNameKey({ ...placement, dialect: params.to.datasource.provider === "sqlite" ? "sqlite" : params.to.datasource.provider === "mysql" ? "mysql" : "postgres" }));
+    if (objects.some((object) => (object.identity.kind === "table" || object.identity.kind === "view") && object.identity.name.name === table && object.identity.name.namespace === placement.namespace))
       return [];
-    const owners = objects.map((object) => object.identity).filter((identity) => ("table" in identity) && identity.table.name === table);
+    const owners = objects.map((object) => object.identity).filter((identity) => ("table" in identity) && identity.table.name === table && identity.table.namespace === placement.namespace);
     return [{
       ...model,
       fields: model.fields.flatMap((field) => {
@@ -1194,7 +1262,7 @@ function preserveMigrationObjects(params) {
       relations: model.relations.filter((relation) => !owners.some((owner) => owner.kind === "constraint" && owner.constraintType === "foreignKey" && owner.name === relation.constraintName))
     }];
   });
-  const enums = params.from.enums.filter((enumDef) => enumStorageOf2({ enumDef }) === "string" || !objects.some((object) => object.identity.kind === "enum" && object.identity.name.name === (enumDef.dbName ?? enumDef.name)));
+  const enums = params.from.enums.filter((enumDef) => enumStorageOf2({ enumDef }) === "string" || !objects.some((object) => object.identity.kind === "enum" && object.identity.name.name === (enumDef.dbName ?? enumDef.name) && object.identity.name.namespace === (enumDef.namespace ?? namespace)));
   return { ...params.from, models, enums };
 }
 function sqlitePreservedSchema(params) {
@@ -1213,7 +1281,8 @@ function sqlitePreservedSchema(params) {
   }) };
 }
 function removalIdentity(params) {
-  const { step, namespace } = params;
+  const { step } = params;
+  const namespace = step.namespace ?? params.namespace;
   const table = "table" in step && step.table !== undefined ? { namespace, name: step.table } : undefined;
   switch (step.kind) {
     case "dropEnum":
@@ -1244,18 +1313,22 @@ function removalIdentity(params) {
 function schemaObjectIdentities(params) {
   const normalized = normalizeSchema({ schema: params.schema, dialect: params.dialect });
   const result = [];
-  if (params.dialect === "postgres")
-    for (const name of normalized.enums.keys())
-      result.push({ kind: "enum", name: { namespace: params.namespace, name } });
-  for (const [name, model] of normalized.tables) {
-    const table = { namespace: params.namespace, name };
+  if (params.dialect === "postgres") {
+    for (const namespace of schemaNamespaces({ schema: params.schema }))
+      result.push({ kind: "namespace", name: namespace });
+    for (const enumDef of normalized.enums.values())
+      result.push({ kind: "enum", name: qualifiedSqlName4({ name: enumDef.dbName ?? enumDef.name, namespace: enumDef.namespace, defaultNamespace: params.namespace }) });
+  }
+  for (const model of normalized.tables.values()) {
+    const name = model.table;
+    const table = qualifiedSqlName4({ name, namespace: model.namespace, defaultNamespace: params.namespace });
     result.push({ kind: "table", name: table });
     for (const [column, definition] of model.columns) {
       result.push({ kind: "column", table, column });
       if (definition.defaultKey !== null)
         result.push({ kind: "columnDefault", table, column });
       if (params.dialect === "postgres" && definition.field.default?.kind === "autoincrement")
-        result.push({ kind: "sequence", name: { namespace: params.namespace, name: postgresGeneratedObjectName({ name1: name, name2: column, label: "seq" }) } });
+        result.push({ kind: "sequence", name: { namespace: table.namespace, name: postgresGeneratedObjectName({ name1: name, name2: column, label: "seq" }) } });
     }
     for (const exclusion of model.model.exclusions ?? [])
       result.push({ kind: "constraint", constraintType: "exclusion", table, name: exclusion.name });
@@ -1271,16 +1344,17 @@ function schemaObjectIdentities(params) {
     if (model.pk.length > 0)
       result.push({ kind: "constraint", constraintType: "primaryKey", table, name: model.model.primaryKeyConstraintName ?? (params.dialect === "mysql" ? "PRIMARY" : defaultPrimaryKeyName({ table: name, dialect: params.dialect })) });
   }
-  for (const name of normalized.joinTables.keys()) {
-    const table = { namespace: params.namespace, name };
+  for (const join of normalized.joinTables.values()) {
+    const name = join.table;
+    const table = qualifiedSqlName4({ name, namespace: join.namespace, defaultNamespace: params.namespace });
     result.push({ kind: "table", name: table });
     const derived = implicitJoinTableObjectNames({ table: name });
     result.push({ kind: "column", table, column: "A" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyA });
     result.push({ kind: "column", table, column: "B" }, { kind: "constraint", constraintType: "foreignKey", table, name: derived.foreignKeyB });
     result.push({ kind: "index", table, name: derived.uniqueIndex }, { kind: "index", table, name: derived.indexB });
   }
-  for (const name of normalized.views.keys())
-    result.push({ kind: "view", name: { namespace: params.namespace, name } });
+  for (const view of normalized.views.values())
+    result.push({ kind: "view", name: qualifiedSqlName4({ name: view.dbName ?? view.name, namespace: view.namespace, defaultNamespace: params.namespace }) });
   return result;
 }
 function assertRetainedMigrationObjects(params) {
@@ -1340,7 +1414,7 @@ function assertRemovalAuthorization(params) {
       integrity.push(identity);
     if (step.kind === "dropTable" || step.kind === "dropJoinTable") {
       for (const child of [...declared, ...params.removeUnmanaged ?? []]) {
-        if ((child.kind === "constraint" || child.kind === "index") && child.table.namespace === params.namespace && child.table.name === step.table)
+        if ((child.kind === "constraint" || child.kind === "index") && child.table.namespace === (step.namespace ?? params.namespace) && child.table.name === step.table)
           integrity.push(child);
       }
     }
@@ -1352,22 +1426,311 @@ function assertRemovalAuthorization(params) {
 }
 
 // packages/migrate/src/inventory.ts
-import { VibeError as VibeError16, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey5 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect2, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
+import { VibeError as VibeError17, defaultForeignKeyName as defaultForeignKeyName2, defaultPrimaryKeyName as defaultPrimaryKeyName2, isSqlObjectIdentity as isSqlObjectIdentity2, sqlObjectKey as sqlObjectKey6 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect3, renderMigrationInventory, renderSqliteColumnInventory as renderSqliteColumnInventory2, renderMysqlObjectMembers as renderMysqlObjectMembers2, sqliteTableConstraints as sqliteTableConstraints3, renderSqliteForeignKeyInventory } from "@vibeorm/sql";
+
+// packages/migrate/src/external-objects.ts
+import { IDENTIFIER_LIMITS, VibeError as VibeError7, identifierLength, sqlNamespaceIssue, sqlObjectKey as sqlObjectKey3, sqlObjectNamespace, qualifiedSqlName as qualifiedSqlName5, enumStorageOf as enumStorageOf3, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { getSqlDialect, renderExternalOwnershipCatalog, renderReplayCoverageGaps } from "@vibeorm/sql";
+var partitionPatterns = new WeakMap;
+function invalid2(params) {
+  return new VibeError7({ code: "VIBE_CONFIG", message: `Invalid external ownership declaration: ${params.detail}`, meta: { reason: "external-declaration-invalid", ...params.owner === undefined ? {} : { owner: params.owner } }, ...params.cause === undefined ? {} : { cause: params.cause } });
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function identifier(value) {
+  return typeof value === "string" && value.trim().length > 0 && !value.includes("\x00") && identifierLength({ name: value, dialect: "postgres" }) <= IDENTIFIER_LIMITS.postgres.max;
+}
+function names(params) {
+  if (params.value === undefined)
+    return;
+  if (!Array.isArray(params.value) || !params.value.every(identifier) || new Set(params.value).size !== params.value.length)
+    throw invalid2({ detail: `${params.key} must contain unique non-empty PostgreSQL identifiers` });
+  return [...params.value];
+}
+async function parseExternalObjects(params) {
+  return Promise.resolve().then(() => {
+    if (!Array.isArray(params.value))
+      throw invalid2({ detail: "external must be an array" });
+    if (params.value.length > 0 && params.dialect !== undefined && params.dialect !== "postgres")
+      throw unsupportedCapability6({ dialect: params.dialect, feature: "externalObjects" });
+    const owners = new Set;
+    const claims = new Set;
+    const compiled = [];
+    const tableClaims = [];
+    const result = [];
+    for (const value of params.value) {
+      if (!record2(value) || typeof value.owner !== "string" || value.owner.trim().length === 0 || value.owner.includes("\x00"))
+        throw invalid2({ detail: "each entry needs a non-empty owner" });
+      const owner = value.owner;
+      if (owners.has(owner))
+        throw invalid2({ detail: "an owner must have one declaration", owner });
+      owners.add(owner);
+      const allowed = value.schema === undefined ? ["owner", "tables", "partitions", "functions"] : ["owner", "schema"];
+      if (Object.keys(value).some((key) => !allowed.includes(key)))
+        throw invalid2({ detail: "whole-schema and named-object declarations are exclusive; unknown keys refuse", owner });
+      const claim = (options) => {
+        const { kind, name } = options;
+        const key = JSON.stringify([kind, name]);
+        if (claims.has(key))
+          throw invalid2({ detail: `${kind} ${JSON.stringify(name)} has conflicting owners`, owner });
+        claims.add(key);
+      };
+      if (value.schema !== undefined) {
+        const issue = sqlNamespaceIssue({ namespace: value.schema, allowPublic: false });
+        if (issue !== undefined || typeof value.schema !== "string")
+          throw invalid2({ detail: issue ?? "schema must be a string", owner });
+        claim({ kind: "namespace", name: value.schema });
+        result.push(Object.freeze({ owner, schema: value.schema }));
+        continue;
+      }
+      const tables = names({ value: value.tables, key: "tables" });
+      const functions = names({ value: value.functions, key: "functions" });
+      const partitions = [];
+      const ownerPatterns = [];
+      if (value.partitions !== undefined) {
+        if (!Array.isArray(value.partitions))
+          throw invalid2({ detail: "partitions must be an array", owner });
+        for (const partition of value.partitions) {
+          if (!record2(partition) || Object.keys(partition).some((key) => key !== "parent" && key !== "pattern") || !identifier(partition.parent) || typeof partition.pattern !== "string" || partition.pattern.length === 0 || !tables?.includes(partition.parent))
+            throw invalid2({ detail: "partition patterns require a parent in the same owner's tables", owner });
+          const pattern = new RegExp(`^(?:${partition.pattern})$`);
+          compiled.push({ owner, pattern });
+          ownerPatterns.push({ parent: partition.parent, pattern });
+          partitions.push(Object.freeze({ parent: partition.parent, pattern: partition.pattern }));
+        }
+      }
+      if ((tables?.length ?? 0) + (functions?.length ?? 0) + partitions.length === 0)
+        throw invalid2({ detail: "named ownership needs at least one table or function", owner });
+      for (const name of tables ?? []) {
+        if (name === "_vibe_migrations")
+          throw invalid2({ detail: "the migration journal cannot be claimed externally", owner });
+        claim({ kind: "table", name });
+        tableClaims.push({ owner, name });
+      }
+      for (const name of functions ?? [])
+        claim({ kind: "function", name });
+      const declaration = Object.freeze({ owner, ...tables === undefined ? {} : { tables: Object.freeze(tables) }, ...functions === undefined ? {} : { functions: Object.freeze(functions) }, ...value.partitions === undefined ? {} : { partitions: Object.freeze(partitions) } });
+      partitionPatterns.set(declaration, ownerPatterns);
+      result.push(declaration);
+    }
+    for (const table of tableClaims)
+      for (const pattern of compiled) {
+        if (table.owner !== pattern.owner && pattern.pattern.exec(table.name)?.[0] === table.name)
+          throw invalid2({ detail: "a full-name pattern claims another owner's named table", owner: pattern.owner });
+      }
+    return Object.freeze(result);
+  }).catch((cause) => {
+    if (cause instanceof VibeError7)
+      throw cause;
+    throw invalid2({ detail: "regular-expression pattern cannot be compiled", cause });
+  });
+}
+function nameKey(name) {
+  return sqlObjectKey3({ identity: { kind: "table", name } });
+}
+function schemaOwner(params) {
+  return params.external.find((entry) => entry.schema === params.namespace)?.owner;
+}
+function declaredTableOwner(params) {
+  const whole = schemaOwner({ external: params.external, namespace: params.name.namespace });
+  if (whole !== undefined || params.name.namespace !== "public")
+    return whole;
+  const matches = params.external.filter((entry) => {
+    if (entry.tables?.includes(params.name.name))
+      return true;
+    const patterns = partitionPatterns.get(entry);
+    if ((entry.partitions?.length ?? 0) > 0 && patterns === undefined)
+      throw invalid2({ detail: "resolve partition declarations returned by parseExternalObjects", owner: entry.owner });
+    return patterns?.some(({ pattern }) => pattern.exec(params.name.name)?.[0] === params.name.name) === true;
+  });
+  if (matches.length > 1)
+    throw new VibeError7({ code: "VIBE_CONFIG", message: "A table is claimed by more than one external owner", meta: { reason: "external-owner-collision", identity: { kind: "table", name: params.name }, owners: matches.map((entry) => entry.owner) } });
+  return matches[0]?.owner;
+}
+function externalObjectOwner(params) {
+  const { identity, external } = params;
+  const whole = schemaOwner({ external: external.declarations, namespace: sqlObjectNamespace({ identity }) });
+  if (whole !== undefined)
+    return whole;
+  if (identity.kind === "table" || "table" in identity) {
+    const name = "table" in identity ? identity.table : identity.name;
+    return external.tables.find((entry) => nameKey(entry.name) === nameKey(name))?.owner ?? declaredTableOwner({ external: external.declarations, name });
+  }
+  if (identity.kind === "sequence")
+    return external.sequences.find((entry) => nameKey(entry.name) === nameKey(identity.name))?.owner;
+  if (identity.kind === "function" && identity.name.namespace === "public")
+    return external.declarations.find((entry) => entry.functions?.includes(identity.name.name))?.owner;
+  return;
+}
+function resolveExternalObjectOwnership(params) {
+  if (params.external.length > 0 && params.dialect !== "postgres")
+    throw unsupportedCapability6({ dialect: params.dialect, feature: "externalObjects" });
+  if (params.catalog.inventory.some((object) => object.inspectionUnavailable !== undefined))
+    throw new VibeError7({ code: "VIBE_MIGRATION", message: "External ownership requires complete catalog visibility", meta: { reason: "external-inventory-unavailable", objects: params.catalog.inventory.filter((object) => object.inspectionUnavailable !== undefined) } });
+  const tables = new Map;
+  const assign = (entry) => {
+    const key = nameKey(entry.name);
+    const prior = tables.get(key)?.owner ?? declaredTableOwner({ external: params.external, name: entry.name });
+    if (prior !== undefined && prior !== entry.owner)
+      throw new VibeError7({ code: "VIBE_CONFIG", message: "An inherited table has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "table", name: entry.name }, owners: [prior, entry.owner] } });
+    if (tables.has(key))
+      return false;
+    tables.set(key, entry);
+    return true;
+  };
+  for (const declaration of params.external)
+    for (const name of declaration.tables ?? [])
+      assign({ owner: declaration.owner, name: { namespace: "public", name } });
+  for (const object of params.catalog.inventory) {
+    if (object.identity.kind !== "table")
+      continue;
+    const owner = declaredTableOwner({ external: params.external, name: object.identity.name });
+    if (owner !== undefined)
+      assign({ owner, name: object.identity.name });
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const edge of params.catalog.inheritance) {
+      const owner = tables.get(nameKey(edge.parent))?.owner;
+      if (owner !== undefined && assign({ owner, name: edge.child }))
+        changed = true;
+    }
+  }
+  const sequences = params.catalog.ownedSequences.flatMap((edge) => {
+    const owner = tables.get(nameKey(edge.table))?.owner;
+    if (owner === undefined)
+      return [];
+    const whole = schemaOwner({ external: params.external, namespace: edge.sequence.namespace });
+    if (whole !== undefined && whole !== owner)
+      throw new VibeError7({ code: "VIBE_CONFIG", message: "An owned sequence has conflicting external owners", meta: { reason: "external-owner-collision", identity: { kind: "sequence", name: edge.sequence }, owners: [whole, owner] } });
+    return [{ owner, name: edge.sequence }];
+  });
+  const closure = { declarations: params.external, catalog: params.catalog, inventory: params.catalog.inventory, tables: [...tables.values()], sequences, owners: [], identities: [] };
+  for (const edge of params.catalog.foreignKeys) {
+    const owner = externalObjectOwner({ external: closure, identity: { kind: "table", name: edge.table } });
+    const targetOwner = externalObjectOwner({ external: closure, identity: { kind: "table", name: edge.target } });
+    if (owner !== targetOwner && (owner !== undefined || targetOwner !== undefined))
+      throw new VibeError7({ code: "VIBE_MIGRATION", message: "Foreign keys cannot cross external ownership boundaries", meta: { reason: "external-cross-owner-foreign-key", name: edge.name, table: edge.table, target: edge.target, owner: owner ?? "application", targetOwner: targetOwner ?? "application" } });
+  }
+  const observed = new Map;
+  for (const namespace of params.catalog.namespaces) {
+    if (schemaOwner({ external: params.external, namespace }) !== undefined)
+      observed.set(sqlObjectKey3({ identity: { kind: "namespace", name: namespace } }), { kind: "namespace", name: namespace });
+  }
+  for (const object of params.catalog.inventory)
+    observed.set(sqlObjectKey3({ identity: object.identity }), object.identity);
+  const owners = params.external.map((entry) => {
+    const identities = [...observed.values()].filter((identity) => externalObjectOwner({ identity, external: closure }) === entry.owner);
+    const missing = [];
+    if (entry.schema !== undefined && !params.catalog.namespaces.includes(entry.schema))
+      missing.push({ kind: "namespace", name: entry.schema });
+    for (const name of entry.tables ?? [])
+      if (!params.catalog.inventory.some(({ identity }) => identity.kind === "table" && identity.name.namespace === "public" && identity.name.name === name))
+        missing.push({ kind: "table", name: { namespace: "public", name } });
+    for (const name of entry.functions ?? [])
+      if (!params.catalog.inventory.some(({ identity }) => identity.kind === "function" && identity.name.namespace === "public" && identity.name.name === name))
+        missing.push({ kind: "function", name: { namespace: "public", name } });
+    return { owner: entry.owner, state: "excluded", count: identities.length, identities, missing };
+  });
+  return { ...closure, owners, identities: owners.flatMap((owner) => owner.identities) };
+}
+function catalogName(params) {
+  const namespace = params.row[params.namespace];
+  const name = params.row[params.name];
+  if (!identifier(namespace) || !identifier(name))
+    throw new VibeError7({ code: "VIBE_MIGRATION", message: "Malformed external ownership catalog endpoint", meta: { reason: "external-inventory-unavailable" } });
+  return { namespace, name };
+}
+async function inspectExternalObjects(params) {
+  const external = await parseExternalObjects({ value: params.external, dialect: params.dialect });
+  if (params.dialect !== "postgres")
+    return resolveExternalObjectOwnership({ external, dialect: params.dialect, catalog: { namespaces: [], inventory: params.inventory ?? [], inheritance: [], ownedSequences: [], foreignKeys: [] } });
+  const read = async (operation) => {
+    const query = renderExternalOwnershipCatalog({ dialect: getSqlDialect({ dialect: params.dialect }), operation });
+    return params.executor({ text: query.text, values: [...query.values] });
+  };
+  const namespaceRows = await read("namespaces");
+  if (namespaceRows.some((row) => !identifier(row.namespace) || row.visible !== true))
+    throw new VibeError7({ code: "VIBE_MIGRATION", message: "External ownership cannot prove visibility of every inspected namespace", meta: { reason: "external-inventory-unavailable" } });
+  const namespaces = namespaceRows.map((row) => String(row.namespace));
+  const [inherited, owned, foreignKeys] = await Promise.all([read("inheritance"), read("ownedSequences"), read("foreignKeys")]);
+  const inventory = params.inventory ?? (await Promise.all(namespaces.map((namespace) => inspectMigrationInventory({ executor: params.executor, dialect: params.dialect, namespace })))).flat();
+  const coverageGaps = (await Promise.all(namespaces.map(async (namespace) => {
+    const query = renderReplayCoverageGaps({ dialect: getSqlDialect({ dialect: params.dialect }), namespace });
+    return params.executor({ text: query.text, values: [...query.values] });
+  }))).flat();
+  return resolveExternalObjectOwnership({ external, dialect: params.dialect, catalog: {
+    namespaces,
+    inventory,
+    coverageGaps,
+    inheritance: inherited.map((row) => ({ parent: catalogName({ row, namespace: "parentNamespace", name: "parentName" }), child: catalogName({ row, namespace: "namespace", name: "name" }) })),
+    ownedSequences: owned.map((row) => ({ table: catalogName({ row, namespace: "tableNamespace", name: "tableName" }), sequence: catalogName({ row, namespace: "namespace", name: "name" }) })),
+    foreignKeys: foreignKeys.map((row) => ({ table: catalogName({ row, namespace: "namespace", name: "table" }), target: catalogName({ row, namespace: "refNamespace", name: "refTable" }), name: catalogName({ row, namespace: "namespace", name: "name" }).name }))
+  } });
+}
+function assertExternalOwnershipClaims(params) {
+  for (const identity of params.identities) {
+    const owner = externalObjectOwner({ identity, external: params.external }) ?? (identity.kind === "namespace" ? [...params.external.tables, ...params.external.sequences].find((entry) => entry.name.namespace === identity.name)?.owner : undefined);
+    if (owner !== undefined)
+      throw new VibeError7({ code: "VIBE_CONFIG", message: "Application or module declarations collide with external ownership", meta: { reason: "external-owned-object-collision", owner, identity } });
+  }
+}
+function projectExternalSchema(params) {
+  const { schema, external } = params;
+  const models = schema.models.filter((model) => externalObjectOwner({ external, identity: { kind: model.isView ? "view" : "table", name: qualifiedSqlName5({ name: model.dbName ?? model.name, namespace: model.namespace }) } }) === undefined);
+  const removed = new Set(schema.models.filter((model) => !models.includes(model)).map((model) => model.name));
+  for (const model of models)
+    for (const relation of model.relations)
+      if (removed.has(relation.targetModel))
+        throw new VibeError7({ code: "VIBE_MIGRATION", message: "Application relations cannot depend on externally owned tables", meta: { reason: "external-cross-owner-foreign-key", model: model.name, relation: relation.name } });
+  return {
+    ...schema,
+    models,
+    enums: schema.enums.filter((entry) => enumStorageOf3({ enumDef: entry }) === "string" || externalObjectOwner({ external, identity: { kind: "enum", name: qualifiedSqlName5({ name: entry.dbName ?? entry.name, namespace: entry.namespace }) } }) === undefined),
+    ...schema.migrationObjects === undefined ? {} : { migrationObjects: schema.migrationObjects.filter((object) => externalObjectOwner({ external, identity: object.identity }) === undefined) }
+  };
+}
+function projectExternalState(params) {
+  return { ...params.state, schema: projectExternalSchema({ schema: params.state.schema, external: params.external }), definitions: params.state.definitions.filter((definition) => externalObjectOwner({ external: params.external, identity: definition.identity }) === undefined) };
+}
+function projectExternalInventory(params) {
+  return params.inventory.filter((object) => externalObjectOwner({ identity: object.identity, external: params.external }) === undefined);
+}
+function migrationCoverageGaps(params) {
+  const recognized = new Set([...params.namespaces, ...params.external?.tables.map((entry) => entry.name.namespace) ?? [], ...params.external?.sequences.map((entry) => entry.name.namespace) ?? []]);
+  const kept = params.gaps.filter((gap) => {
+    const namespace = typeof gap.namespace === "string" ? gap.namespace : params.namespace;
+    if (gap.kind === "namespace" && typeof gap.name === "string" && recognized.has(gap.name))
+      return false;
+    const external = params.external;
+    if (external === undefined)
+      return true;
+    if (external.declarations.some((entry) => entry.schema === namespace || gap.kind === "namespace" && entry.schema === gap.name))
+      return false;
+    const name = gap.kind === "rule" ? gap.parent : gap.name;
+    if ((gap.kind === "relation-layout" || gap.kind === "rule") && typeof name === "string" && externalObjectOwner({ external, identity: { kind: "table", name: { namespace, name } } }) !== undefined)
+      return false;
+    return true;
+  });
+  return [...new Map(kept.map((gap) => [JSON.stringify(gap), gap])).values()];
+}
 
 // packages/migrate/src/exclusions.ts
 import { randomUUID } from "crypto";
-import { VibeError as VibeError7, sqlObjectKey as sqlObjectKey3 } from "@vibeorm/schema";
+import { VibeError as VibeError8, sqlObjectKey as sqlObjectKey4 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect2, renderExclusionCatalog, renderExclusionProbe } from "@vibeorm/sql";
 async function deparseExclusion(params) {
   const probe = `vibe_exclusion_${randomUUID().replaceAll("-", "")}`;
   await params.executor({ text: "SAVEPOINT vibe_exclusion_probe" });
   try {
-    for (const text of renderExclusionProbe({ dialect: postgresDialect2, table: params.table, probe, definition: params.definition }))
+    for (const text of renderExclusionProbe({ dialect: postgresDialect2, table: params.table, ...params.namespace === undefined ? {} : { namespace: params.namespace }, probe, definition: params.definition }))
       await params.executor({ text });
     const rows = await params.executor({ text: renderExclusionCatalog({ dialect: postgresDialect2, probe }) });
     if (typeof rows[0]?.definition !== "string")
-      throw new VibeError7({ code: "VIBE_MIGRATION", message: "Exclusion probe unavailable", meta: { reason: "exclusion-inspection-unavailable" } });
+      throw new VibeError8({ code: "VIBE_MIGRATION", message: "Exclusion probe unavailable", meta: { reason: "exclusion-inspection-unavailable" } });
     return rows[0].definition;
   } finally {
     await params.executor({ text: "ROLLBACK TO SAVEPOINT vibe_exclusion_probe" });
@@ -1378,7 +1741,7 @@ async function prepareExclusionDiff(params) {
   const models = [];
   for (const model of params.from.models) {
     const table = model.dbName ?? model.name;
-    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table && (entry.namespace ?? "public") === (model.namespace ?? "public"));
     const exclusions = [];
     for (const before of model.exclusions ?? []) {
       const next = target?.exclusions?.find((entry) => entry.name === before.name);
@@ -1386,22 +1749,22 @@ async function prepareExclusionDiff(params) {
         exclusions.push(before);
         continue;
       }
-      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: "public", name: table }, name: before.name };
+      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: model.namespace ?? "public", name: table }, name: before.name };
       if (params.probe === "rollback") {
-        const normalized = await deparseExclusion({ executor: params.executor, table, definition: next.definition });
+        const normalized = await deparseExclusion({ executor: params.executor, table, ...model.namespace === undefined ? {} : { namespace: model.namespace }, definition: next.definition });
         exclusions.push(normalized === before.definition ? next : { name: before.name, definition: before.definition, requiredExtensions: before.requiredExtensions });
         continue;
       }
-      const previous = params.previous?.schema.models.find((entry) => (entry.dbName ?? entry.name) === table)?.exclusions?.find((entry) => entry.name === before.name);
+      const previous = params.previous?.schema.models.find((entry) => (entry.dbName ?? entry.name) === table && (entry.namespace ?? "public") === (model.namespace ?? "public"))?.exclusions?.find((entry) => entry.name === before.name);
       if (previous !== undefined) {
         exclusions.push(previous);
         continue;
       }
-      if (params.replaceChecks?.some((entry) => sqlObjectKey3({ identity: entry }) === sqlObjectKey3({ identity }))) {
+      if (params.replaceChecks?.some((entry) => sqlObjectKey4({ identity: entry }) === sqlObjectKey4({ identity }))) {
         exclusions.push({ name: before.name, definition: before.definition, requiredExtensions: before.requiredExtensions });
         continue;
       }
-      throw new VibeError7({ code: "VIBE_MIGRATION", message: "Exclusion equivalence requires a rollback probe or explicit replacement", meta: { reason: "explicit-replacement-required", identity } });
+      throw new VibeError8({ code: "VIBE_MIGRATION", message: "Exclusion equivalence requires a rollback probe or explicit replacement", meta: { reason: "explicit-replacement-required", identity } });
     }
     models.push({ ...model, exclusions });
   }
@@ -1410,20 +1773,20 @@ async function prepareExclusionDiff(params) {
 async function verifyExclusions(params) {
   if (!params.expected.schema.models.some((model) => (model.exclusions?.length ?? 0) > 0))
     return [];
-  const rows = await params.executor({ text: renderExclusionCatalog({ dialect: postgresDialect2 }) });
+  const rows = (await Promise.all([...new Set(params.expected.schema.models.map((model) => model.namespace ?? "public"))].map(async (namespace) => (await params.executor({ text: renderExclusionCatalog({ dialect: postgresDialect2, namespace }) })).map((row) => ({ ...row, namespace }))))).flat();
   const objects = [];
   for (const model of params.expected.schema.models)
     for (const exclusion of model.exclusions ?? []) {
       const table = model.dbName ?? model.name;
-      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: "public", name: table }, name: exclusion.name };
-      const row = rows.find((entry) => entry.table_name === table && entry.constraint_name === exclusion.name);
+      const identity = { kind: "constraint", constraintType: "exclusion", table: { namespace: model.namespace ?? "public", name: table }, name: exclusion.name };
+      const row = rows.find((entry) => entry.namespace === (model.namespace ?? "public") && entry.table_name === table && entry.constraint_name === exclusion.name);
       if (row === undefined) {
         objects.push({ identity, ownership: "schema", state: "missing", differences: [] });
         continue;
       }
       const differences = ["validated", "valid", "ready"].flatMap((attribute) => row[attribute] === true ? [] : [{ attribute, expected: true, actual: row[attribute] }]);
-      const independentlyVerified = params.expected.definitions.some((entry) => sqlObjectKey3({ identity: entry.identity }) === sqlObjectKey3({ identity }));
-      const definition = independentlyVerified ? row.definition : params.probe === "rollback" ? await deparseExclusion({ executor: params.executor, table, definition: exclusion.definition }) : (exclusion.normalizationSource === exclusion.definition ? exclusion.normalizedDefinition : undefined) ?? exclusion.definition;
+      const independentlyVerified = params.expected.definitions.some((entry) => sqlObjectKey4({ identity: entry.identity }) === sqlObjectKey4({ identity }));
+      const definition = independentlyVerified ? row.definition : params.probe === "rollback" ? await deparseExclusion({ executor: params.executor, table, ...model.namespace === undefined ? {} : { namespace: model.namespace }, definition: exclusion.definition }) : (exclusion.normalizationSource === exclusion.definition ? exclusion.normalizedDefinition : undefined) ?? exclusion.definition;
       if (definition !== row.definition)
         differences.push({ attribute: "definition", expected: definition, actual: row.definition });
       objects.push({ identity, ownership: "schema", state: differences.length === 0 ? "matching" : params.probe === "rollback" ? "changed" : "unavailable", differences });
@@ -1433,22 +1796,19 @@ async function verifyExclusions(params) {
 
 // packages/migrate/src/inspect-objects.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { VibeError as VibeError15, sqlObjectKey as sqlObjectKey4, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2 } from "@vibeorm/schema";
-import { getSqlDialect, renderMigrationObjectBatch, renderMigrationObjectQuery, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2, renderSqliteColumnInventory } from "@vibeorm/sql";
+import { VibeError as VibeError16, sqlObjectKey as sqlObjectKey5, sqlObjectNamespace as sqlObjectNamespace2, DIALECT_CAPABILITIES as DIALECT_CAPABILITIES2, qualifiedSqlName as qualifiedSqlName8 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect2, renderMigrationObjectBatch, renderMigrationObjectQuery as renderMigrationObjectQuery2, renderCheckProbe, renderMigrationNamespace, renderMigrationDependencies, renderMysqlObjectMembers, renderMysqlCheckProbe, sqliteColumnClauses as sqliteColumnClauses2, renderMigrationVisibility, sqliteTableConstraints as sqliteTableConstraints2, renderSqliteColumnInventory } from "@vibeorm/sql";
 
 // packages/migrate/src/introspect/postgres.ts
 import { renderExclusionCatalog as renderExclusionCatalog2 } from "@vibeorm/sql";
 import { parsePgArrayLiteral } from "@vibeorm/sql";
 import { scalarListDefault as scalarListDefault2 } from "@vibeorm/schema";
 import { exactIntegerLiteral } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect6, renderRlsReadinessQuery } from "@vibeorm/sql";
-import { VibeError as VibeError12 } from "@vibeorm/schema";
-
-// packages/migrate/src/journal-table.ts
-var MIGRATIONS_TABLE_NAME = "_vibe_migrations";
+import { postgresDialect as postgresDialect6, renderRlsReadinessQuery, renderPostgresPhysicalCatalog, renderPostgresIndexKeys, renderMigrationObjectQuery } from "@vibeorm/sql";
+import { VibeError as VibeError13, assertSqlNamespace as assertSqlNamespace2, isReservedClientName } from "@vibeorm/schema";
 
 // packages/migrate/src/introspect/shared.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
+import { VibeError as VibeError9 } from "@vibeorm/schema";
 function detectJoinTable(params) {
   const { table, columnNames, fkGroups, indexes } = params;
   if (!table.startsWith("_"))
@@ -1466,8 +1826,8 @@ function detectJoinTable(params) {
   if (fkA.refTable > fkB.refTable || tableFks.some((fk) => !fk.required || fk.onDelete !== "Cascade" || fk.onUpdate !== "Cascade"))
     return null;
   const tableIndexes = indexes.filter((index) => index.table === table);
-  const canonicalAb = (index) => index.unique && index.kind === "btree" && index.where === undefined && index.nullsNotDistinct !== true && index.columns.length === 2 && index.columns[0]?.name === "A" && index.columns[1]?.name === "B" && index.columns.every((column) => !column.desc);
-  const canonicalB = (index) => !index.unique && index.kind === "btree" && index.where === undefined && index.columns.length === 1 && index.columns[0]?.name === "B" && !index.columns[0].desc;
+  const canonicalAb = (index) => index.unique && index.kind === "btree" && index.where === undefined && index.nullsNotDistinct !== true && index.columns.length === 2 && index.columns[0]?.name === "A" && index.columns[1]?.name === "B" && index.columns.every((column) => !column.desc && column.operatorClass === undefined);
+  const canonicalB = (index) => !index.unique && index.kind === "btree" && index.where === undefined && index.columns.length === 1 && index.columns[0]?.name === "B" && !index.columns[0].desc && index.columns[0].operatorClass === undefined;
   if (tableIndexes.length !== 2 || tableIndexes.filter(canonicalAb).length !== 1 || tableIndexes.filter(canonicalB).length !== 1)
     return null;
   const sorted = [fkA.refTable, fkB.refTable].sort();
@@ -1487,7 +1847,7 @@ function addFkRelations(params) {
       const primary = target?.primaryKey?.fields ?? target?.fields.filter((field) => field.isId).map((field) => field.name) ?? [];
       const columns = primary.map((name) => target?.fields.find((field) => field.name === name)?.dbName ?? name);
       if (columns.length !== 1 || fk.refColumns.length !== 1 || columns[0] !== fk.refColumns[0])
-        throw new VibeError8({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Join table "${table}" does not reference the single-column primary key of "${fk.refTable}"; automatic join compression is unavailable`, meta: { feature: "implicitJoinReferencedKey", table, target: fk.refTable } });
+        throw new VibeError9({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Join table "${table}" does not reference the single-column primary key of "${fk.refTable}"; automatic join compression is unavailable`, meta: { feature: "implicitJoinReferencedKey", table, target: fk.refTable } });
     }
   const relationsByModel = new Map;
   const takeName = nameAllocator({ models });
@@ -1499,9 +1859,9 @@ function addFkRelations(params) {
     const target = modelsByName.get(group.refTable);
     if (owner === undefined || target === undefined)
       continue;
-    const relationName = ambiguousPairs.has(modelPairKey({ a: group.table, b: group.refTable })) ? `${group.table}_${group.columns.join("_")}To${group.refTable}` : undefined;
+    const relationName = ambiguousPairs.has(modelPairKey({ a: group.table, b: group.refTable })) ? `${owner.dbName ?? owner.name}_${group.columns.join("_")}To${target.dbName ?? target.name}` : undefined;
     const fkSide = {
-      name: takeName({ model: owner.name, base: lowerFirst(group.refTable) }),
+      name: takeName({ model: owner.name, base: lowerFirst(target.dbName ?? target.name) }),
       model: owner.name,
       targetModel: group.refTable,
       type: "manyToOne",
@@ -1516,7 +1876,7 @@ function addFkRelations(params) {
     };
     pushRelation({ relationsByModel, relation: fkSide });
     const listSide = {
-      name: takeName({ model: target.name, base: lowerFirst(group.table) }),
+      name: takeName({ model: target.name, base: lowerFirst(owner.dbName ?? owner.name) }),
       model: target.name,
       targetModel: group.table,
       type: "oneToMany",
@@ -1542,7 +1902,7 @@ function addJoinTableRelations(params) {
     pushRelation({
       relationsByModel,
       relation: {
-        name: takeName({ model: modelA.name, base: lowerFirst(modelB.name) }),
+        name: takeName({ model: modelA.name, base: lowerFirst(modelB.dbName ?? modelB.name) }),
         model: modelA.name,
         targetModel: modelB.name,
         type: "oneToMany",
@@ -1554,7 +1914,7 @@ function addJoinTableRelations(params) {
     pushRelation({
       relationsByModel,
       relation: {
-        name: takeName({ model: modelB.name, base: lowerFirst(modelA.name) }),
+        name: takeName({ model: modelB.name, base: lowerFirst(modelA.dbName ?? modelA.name) }),
         model: modelB.name,
         targetModel: modelA.name,
         type: "oneToMany",
@@ -1635,14 +1995,14 @@ function lowerFirst(value) {
 }
 
 // packages/migrate/src/postgres-type-identity.ts
-import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { VibeError as VibeError10, qualifiedSqlName as qualifiedSqlName6 } from "@vibeorm/schema";
 import { postgresDialect as postgresDialect3, renderPostgresTypeIdentity } from "@vibeorm/sql";
 async function resolvePostgresTypeIdentities(params) {
   const unavailable = [];
   const models = [];
   for (const model of params.schema.models) {
-    const table = { namespace: "public", name: model.dbName ?? model.name };
-    const previous = params.previous?.models.find((entry) => (entry.dbName ?? entry.name) === table.name);
+    const table = qualifiedSqlName6({ name: model.dbName ?? model.name, namespace: model.namespace });
+    const previous = params.previous?.models.find((entry) => (entry.dbName ?? entry.name) === table.name && (entry.namespace ?? "public") === table.namespace);
     const fields = [];
     for (const field of model.fields) {
       if (field.isUnsupported !== true) {
@@ -1653,7 +2013,7 @@ async function resolvePostgresTypeIdentities(params) {
       const parsed = parseUnsupportedPostgresType({ raw: field.nativeType ?? "" });
       const evidence = field.nativeTypeIdentity;
       if (evidence !== undefined && (evidence.source !== field.nativeType || parsed?.namespace !== undefined && parsed.namespace !== evidence.namespace)) {
-        throw new VibeError9({ code: "VIBE_MIGRATION", message: "PostgreSQL type evidence no longer matches its declaration; recapture the independent reference", meta: { reason: "type-reference-invalid", shadowReusable: true, table: table.name, column } });
+        throw new VibeError10({ code: "VIBE_MIGRATION", message: "PostgreSQL type evidence no longer matches its declaration; recapture the independent reference", meta: { reason: "type-reference-invalid", shadowReusable: true, table: table.name, column } });
       }
       const prior = previous?.fields.find((entry) => (entry.dbName ?? entry.name) === column && entry.isUnsupported === true);
       const priorType = parseUnsupportedPostgresType({ raw: prior?.nativeType ?? "" });
@@ -1663,7 +2023,7 @@ async function resolvePostgresTypeIdentities(params) {
         const source = params.mode === "catalog" ? { table, column } : { type: { name: parsed?.name ?? "", ...namespace === undefined && params.mode === "reference" ? {} : { namespace: namespace ?? "pg_catalog" } } };
         const query = renderPostgresTypeIdentity({ dialect: postgresDialect3, source });
         const rows = parsed === undefined && params.mode !== "catalog" ? [] : await params.executor({ text: query.text, values: [...query.values] }).then((rows) => rows, (cause) => {
-          throw new VibeError9({ code: "VIBE_MIGRATION", message: "PostgreSQL type identity inspection failed", meta: { reason: "type-inspection-unavailable", table: table.name, column }, cause });
+          throw new VibeError10({ code: "VIBE_MIGRATION", message: "PostgreSQL type identity inspection failed", meta: { reason: "type-inspection-unavailable", table: table.name, column }, cause });
         });
         const resolved = rows.length === 1 ? rows[0] : undefined;
         namespace = typeof resolved?.namespace === "string" && (resolved.name === parsed?.name || parsed === undefined && params.mode === "catalog") ? resolved.namespace : undefined;
@@ -1681,11 +2041,11 @@ async function resolvePostgresTypeIdentities(params) {
 }
 
 // packages/migrate/src/introspect/postgres-rls.ts
-import { VibeError as VibeError11, assertValidSchemaIR as assertValidSchemaIR3 } from "@vibeorm/schema";
+import { VibeError as VibeError12, assertValidSchemaIR as assertValidSchemaIR3 } from "@vibeorm/schema";
 import { NATIVE_RLS, postgresDialect as postgresDialect5, renderRlsPolicy as renderRlsPolicy2 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/rls.ts
-import { VibeError as VibeError10, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { VibeError as VibeError11, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import * as sql from "@vibeorm/sql";
 function isRlsProtected(params) {
   return params.model.rls !== undefined && params.model.rls !== "unprotected";
@@ -1715,7 +2075,18 @@ function assertRlsDialect(params) {
   if (params.schema.rls === undefined && !params.schema.models.some((model) => model.rls !== undefined))
     return;
   if (!sql.DIALECT_CAPABILITIES[params.dialect].nativeRowLevelSecurity) {
-    throw unsupportedCapability5({ dialect: params.dialect, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability7({ dialect: params.dialect, feature: "nativeRowLevelSecurity" });
+  }
+  for (const model of params.schema.models) {
+    if (model.namespace !== undefined && model.namespace !== "public" && isRlsProtected({ model }))
+      throw unsupportedCapability7({ dialect: params.dialect, feature: "fixedNamespaceNativeRls", hint: "Named package schemas do not support native RLS placement in this contract" });
+    const policy = model.rls;
+    if (isRlsProtected({ model }) && typeof policy === "object" && "through" in policy) {
+      const relation = model.relations.find((entry) => entry.name === policy.through);
+      const parent = params.schema.models.find((entry) => entry.name === relation?.targetModel);
+      if (parent?.namespace !== undefined && parent.namespace !== "public")
+        throw unsupportedCapability7({ dialect: params.dialect, feature: "fixedNamespaceNativeRls" });
+    }
   }
   assertValidSchemaIR2({ schema: params.schema });
 }
@@ -1723,8 +2094,9 @@ function withRlsSteps(params) {
   const { from, to, steps } = params;
   const before = orderedRlsModels({ schema: from });
   const after = orderedRlsModels({ schema: to });
-  const beforeByTable = new Map(before.map((model) => [model.dbName ?? model.name, model]));
-  const afterByTable = new Map(after.map((model) => [model.dbName ?? model.name, model]));
+  const tableKey = (params) => physicalNameKey(params);
+  const beforeByTable = new Map(before.map((model) => [tableKey({ name: model.dbName ?? model.name, namespace: model.namespace }), model]));
+  const afterByTable = new Map(after.map((model) => [tableKey({ name: model.dbName ?? model.name, namespace: model.namespace }), model]));
   const changed = new Set;
   const policyChanges = new Set;
   for (const [table, model] of beforeByTable) {
@@ -1736,7 +2108,7 @@ function withRlsSteps(params) {
   }
   for (const step of steps) {
     if (step.kind === "dropTable" || step.kind === "dropColumn" || step.kind === "alterColumn" || step.kind === "dropForeignKey" || step.kind === "dropPrimaryKey")
-      changed.add(step.table);
+      changed.add(tableKey({ name: step.table, namespace: step.namespace }));
   }
   for (const schema of [from, to]) {
     for (const model of orderedRlsModels({ schema })) {
@@ -1745,9 +2117,9 @@ function withRlsSteps(params) {
       const through = model.rls.through;
       const relation = model.relations.find((entry) => entry.name === through);
       const parent = schema.models.find((entry) => entry.name === relation?.targetModel);
-      if (parent !== undefined && changed.has(parent.dbName ?? parent.name)) {
-        changed.add(model.dbName ?? model.name);
-        policyChanges.add(model.dbName ?? model.name);
+      if (parent !== undefined && changed.has(tableKey({ name: parent.dbName ?? parent.name, namespace: parent.namespace }))) {
+        changed.add(tableKey({ name: model.dbName ?? model.name, namespace: model.namespace }));
+        policyChanges.add(tableKey({ name: model.dbName ?? model.name, namespace: model.namespace }));
       }
     }
   }
@@ -1756,20 +2128,22 @@ function withRlsSteps(params) {
   const removals = [];
   for (const model of [...before].reverse()) {
     const table = model.dbName ?? model.name;
-    if (!changed.has(table))
+    const key = tableKey({ name: table, namespace: model.namespace });
+    if (!changed.has(key))
       continue;
-    const target = afterByTable.get(table);
-    const securityChange = target === undefined ? `remove native RLS protection from "${table}"` : policyChanges.has(table) && target.rls !== "deny" ? `replace native RLS policy on "${table}" (access may widen)` : undefined;
+    const target = afterByTable.get(key);
+    const securityChange = target === undefined ? `remove native RLS protection from "${table}"` : policyChanges.has(key) && target.rls !== "deny" ? `replace native RLS policy on "${table}" (access may widen)` : undefined;
     drops.push({ kind: "dropPolicy", table, destructive: false, ...securityChange === undefined ? {} : { securityChange } });
-    if (target === undefined && to.models.some((entry) => (entry.dbName ?? entry.name) === table)) {
+    if (target === undefined && to.models.some((entry) => tableKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace }) === key)) {
       removals.push({ kind: "noForceRls", table, destructive: false }, { kind: "disableRls", table, destructive: false });
     }
   }
   for (const model of after) {
     const table = model.dbName ?? model.name;
-    if (beforeByTable.has(table) && !changed.has(table))
+    const key = tableKey({ name: table, namespace: model.namespace });
+    if (beforeByTable.has(key) && !changed.has(key))
       continue;
-    if (!beforeByTable.has(table))
+    if (!beforeByTable.has(key))
       installs.push({ kind: "enableRls", table, destructive: false }, { kind: "forceRls", table, destructive: false });
     installs.push({ kind: "createPolicy", table, schema: to, model: model.name, destructive: false });
   }
@@ -1781,7 +2155,7 @@ function isRlsStep(params) {
 function renderRlsStep(params) {
   const { step, dialect } = params;
   if (!sql.DIALECT_CAPABILITIES[dialect].nativeRowLevelSecurity)
-    throw unsupportedCapability5({ dialect, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability7({ dialect, feature: "nativeRowLevelSecurity" });
   const common = { dialect: sql.postgresDialect, table: "table" in step ? step.table ?? "" : "" };
   switch (step.kind) {
     case "enableRls":
@@ -1797,11 +2171,11 @@ function renderRlsStep(params) {
       const renderers = sql;
       const renderer = renderers[name];
       if (renderer === undefined)
-        throw unsupportedCapability5({ dialect, feature: "nativeRowLevelSecurity", hint: `The SQL package must provide ${name} before this migration can execute` });
+        throw unsupportedCapability7({ dialect, feature: "nativeRowLevelSecurity", hint: `The SQL package must provide ${name} before this migration can execute` });
       return [renderer(common).text];
     }
     default:
-      throw new VibeError10({ code: "VIBE_MIGRATION", message: "Expected a native RLS migration step" });
+      throw new VibeError11({ code: "VIBE_MIGRATION", message: "Expected a native RLS migration step" });
   }
 }
 function securityChangesOf(params) {
@@ -1810,7 +2184,7 @@ function securityChangesOf(params) {
 function assertSecurityAcknowledgement(params) {
   if (params.securityChanges.length === 0 || params.acceptSecurityChanges === true)
     return;
-  throw new VibeError10({
+  throw new VibeError11({
     code: "VIBE_MIGRATION",
     message: `Security changes require acceptSecurityChanges: true; acceptDataLoss does not authorize them:
 ${params.securityChanges.join(`
@@ -1849,7 +2223,7 @@ async function readPostgresRls(params) {
   return [...tables.values()];
 }
 function conflict(params) {
-  throw new VibeError11({
+  throw new VibeError12({
     code: "VIBE_MIGRATION",
     message: `Native RLS on public.${params.table} cannot be managed safely (${params.attributes.join(", ")}). Review the live policies and restore the deployed declaration, or remove conflicting policies explicitly with administrator credentials. Supply rlsSchema/previousSchema for the deployed policy; no policy is deleted or adopted automatically.`,
     meta: params
@@ -1860,10 +2234,11 @@ async function verifyPostgresRls(params) {
   if (schema !== undefined && schema.rls !== undefined)
     assertValidSchemaIR3({ schema });
   await executor({ text: "SET LOCAL search_path = ''" });
-  const declared = new Map((schema?.models ?? []).map((model) => [model.dbName ?? model.name, model]));
+  const declared = (schema?.models ?? []).filter((model) => model.namespace === undefined || model.namespace === "public");
+  const byTable = new Map(declared.map((model) => [model.dbName ?? model.name, model]));
   let tables = await readPostgresRls({ executor });
   for (const state of tables) {
-    const model = declared.get(state.table);
+    const model = byTable.get(state.table);
     if (!state.enabled && !state.force && state.policies.length === 0 && (model === undefined || !isRlsProtected({ model })))
       continue;
     await executor({ text: `LOCK TABLE "public".${postgresDialect5.quoteIdent({ name: state.table })} IN ACCESS EXCLUSIVE MODE` });
@@ -1871,7 +2246,7 @@ async function verifyPostgresRls(params) {
   tables = await readPostgresRls({ executor });
   const matched = new Set;
   for (const state of tables) {
-    const model = declared.get(state.table);
+    const model = byTable.get(state.table);
     const active = state.enabled || state.force || state.policies.length > 0;
     if (schema === undefined && active)
       conflict({ table: state.table, reason: "rls-unmanaged", attributes: ["security metadata cannot be exported losslessly without a trusted declaration"] });
@@ -1918,7 +2293,7 @@ async function verifyPostgresRls(params) {
     matched.add(state.table);
   }
   if (params.requireInstalled === true) {
-    for (const [table, model] of declared) {
+    for (const [table, model] of byTable) {
       if (isRlsProtected({ model }) && !matched.has(table))
         conflict({ table, reason: "rls-drift", attributes: ["missing table"] });
     }
@@ -1930,8 +2305,9 @@ function projectPostgresRls(params) {
   if (declared?.rls === undefined || matched.size === 0)
     return physical;
   const models = physical.models.map((model) => {
-    const source = declared.models.find((entry) => (entry.dbName ?? entry.name) === model.name);
-    if (source === undefined || !matched.has(model.name))
+    const physicalName = model.dbName ?? model.name;
+    const source = declared.models.find((entry) => (entry.dbName ?? entry.name) === physicalName && (entry.namespace ?? "public") === (model.namespace ?? "public"));
+    if (source === undefined || model.namespace !== undefined && model.namespace !== "public" || !matched.has(physicalName))
       return { ...model, rls: "unprotected" };
     const sourcePolicy = source.rls;
     let rls = "deny";
@@ -1942,7 +2318,8 @@ function projectPostgresRls(params) {
       const target = declared.models.find((entry) => entry.name === sourceRelation.targetModel);
       const fields = sourceRelation.fields.map((name) => source.fields.find((entry) => entry.name === name)?.dbName ?? name);
       const references = sourceRelation.references.map((name) => target.fields.find((entry) => entry.name === name)?.dbName ?? name);
-      const relation = model.relations.find((entry) => entry.targetModel === (target.dbName ?? target.name) && JSON.stringify(entry.fields) === JSON.stringify(fields) && JSON.stringify(entry.references) === JSON.stringify(references));
+      const physicalTarget = physical.models.find((entry) => (entry.dbName ?? entry.name) === (target.dbName ?? target.name) && (entry.namespace ?? "public") === (target.namespace ?? "public"));
+      const relation = model.relations.find((entry) => entry.targetModel === physicalTarget?.name && JSON.stringify(entry.fields) === JSON.stringify(fields) && JSON.stringify(entry.references) === JSON.stringify(references));
       if (relation === undefined)
         conflict({ table: model.name, reason: "rls-drift", attributes: ["through foreign key"] });
       rls = { through: relation.name };
@@ -1953,146 +2330,6 @@ function projectPostgresRls(params) {
 }
 
 // packages/migrate/src/introspect/postgres.ts
-var EXTENSION_OWNED_FILTER = `NOT EXISTS (
-      SELECT 1
-      FROM pg_catalog.pg_depend d
-      JOIN pg_catalog.pg_class c ON c.oid = d.objid
-      JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-      WHERE d.classid = 'pg_class'::regclass
-        AND d.deptype = 'e'
-        AND n.nspname = 'public'
-        AND c.relname = table_name
-    )`;
-var TABLES_QUERY = `
-  SELECT table_name
-  FROM information_schema.tables
-  WHERE table_schema = 'public'
-    AND table_type = 'BASE TABLE'
-    AND table_name <> '${MIGRATIONS_TABLE_NAME}'
-    AND ${EXTENSION_OWNED_FILTER}
-  ORDER BY table_name;
-`;
-var VIEWS_QUERY = `
-  SELECT table_name
-  FROM information_schema.views
-  WHERE table_schema = 'public'
-    AND ${EXTENSION_OWNED_FILTER}
-  ORDER BY table_name;
-`;
-var COLUMNS_QUERY = `
-  SELECT
-    table_name,
-    column_name,
-    data_type,
-    udt_name,
-    is_nullable,
-    is_identity,
-    is_generated,
-    collation_name,
-    column_default,
-    datetime_precision,
-    character_maximum_length,
-    numeric_precision,
-    numeric_scale,
-    ordinal_position,
-    (
-      SELECT format_type(a.atttypid, a.atttypmod)
-      FROM pg_attribute a
-      JOIN pg_class c ON c.oid = a.attrelid
-      JOIN pg_namespace n ON n.oid = c.relnamespace
-      WHERE n.nspname = 'public'
-        AND c.relname = columns.table_name
-        AND a.attname = columns.column_name
-    ) AS full_type
-  FROM information_schema.columns AS columns
-  WHERE table_schema = 'public'
-  ORDER BY table_name, ordinal_position;
-`;
-var CONSTRAINTS_QUERY = `
-  SELECT
-    c.conname AS constraint_name,
-    CASE c.contype WHEN 'p' THEN 'PRIMARY KEY' ELSE 'UNIQUE' END AS constraint_type,
-    cl.relname AS table_name,
-    att.attname AS column_name
-  FROM pg_catalog.pg_constraint c
-  JOIN pg_catalog.pg_class cl    ON cl.oid = c.conrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
-  JOIN unnest(c.conkey) WITH ORDINALITY AS k(attnum, ord) ON true
-  JOIN pg_catalog.pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = k.attnum
-  WHERE c.contype IN ('p', 'u')
-    AND n.nspname = 'public'
-  ORDER BY cl.relname, c.conname, k.ord;
-`;
-var CHECKS_QUERY = `
-  SELECT
-    cl.relname AS table_name,
-    c.conname AS constraint_name,
-    pg_get_constraintdef(c.oid) AS definition
-  FROM pg_catalog.pg_constraint c
-  JOIN pg_catalog.pg_class cl    ON cl.oid = c.conrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = cl.relnamespace
-  WHERE c.contype = 'c'
-    AND n.nspname = 'public'
-  ORDER BY cl.relname, c.conname;
-`;
-var FOREIGN_KEYS_QUERY = `
-  SELECT
-    c.conname   AS constraint_name,
-    cl.relname  AS table_name,
-    att.attname AS column_name,
-    fcl.relname AS foreign_table_name,
-    fatt.attname AS foreign_column_name,
-    c.confdeltype AS on_delete_char,
-    c.confupdtype AS on_update_char,
-    c.convalidated AS validated,
-    c.condeferrable AS deferrable,
-    (SELECT bool_and(t.tgenabled IN ('O', 'A')) FROM pg_catalog.pg_trigger t WHERE t.tgconstraint = c.oid) AS triggers_enabled
-  FROM pg_catalog.pg_constraint c
-  JOIN pg_catalog.pg_class cl     ON cl.oid = c.conrelid
-  JOIN pg_catalog.pg_namespace n  ON n.oid = cl.relnamespace
-  JOIN pg_catalog.pg_class fcl    ON fcl.oid = c.confrelid
-  JOIN pg_catalog.pg_namespace fn ON fn.oid = fcl.relnamespace
-  JOIN unnest(c.conkey)  WITH ORDINALITY AS lk(attnum, ord) ON true
-  JOIN unnest(c.confkey) WITH ORDINALITY AS rk(attnum, ord) ON lk.ord = rk.ord
-  JOIN pg_catalog.pg_attribute att  ON att.attrelid = c.conrelid  AND att.attnum = lk.attnum
-  JOIN pg_catalog.pg_attribute fatt ON fatt.attrelid = c.confrelid AND fatt.attnum = rk.attnum
-  WHERE c.contype = 'f'
-    AND n.nspname = 'public'
-    AND fn.nspname = 'public'
-  ORDER BY cl.relname, c.conname, lk.ord;
-`;
-var ENUMS_QUERY = `
-  SELECT
-    t.typname AS type_name,
-    e.enumlabel AS enum_value,
-    e.enumsortorder AS sort_order
-  FROM pg_type t
-  JOIN pg_enum e ON t.oid = e.enumtypid
-  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  WHERE n.nspname = 'public'
-  ORDER BY t.typname, e.enumsortorder;
-`;
-var INDEXES_QUERY = `
-  SELECT
-    tablename AS table_name,
-    indexname AS index_name,
-    indexdef AS index_def,
-    con.conname AS backing_constraint,
-    con.contype AS backing_constraint_type,
-    health.indisvalid AS valid,
-    health.indisready AS ready,
-    health.indimmediate AS immediate,
-    health.indexprs IS NULL AS plain_columns,
-    health.indnkeyatts AS key_count,
-    health.indnatts AS attribute_count
-  FROM pg_indexes ix
-  JOIN pg_catalog.pg_namespace ns ON ns.nspname = ix.schemaname
-  JOIN pg_catalog.pg_class idx ON idx.relnamespace = ns.oid AND idx.relname = ix.indexname
-  JOIN pg_catalog.pg_index health ON health.indexrelid = idx.oid
-  LEFT JOIN pg_catalog.pg_constraint con ON con.conindid = idx.oid AND con.contype IN ('p', 'u', 'x')
-  WHERE schemaname = 'public'
-  ORDER BY tablename, indexname;
-`;
 async function introspectPostgres(params) {
   const { executor } = params;
   if (params.inTransaction !== true)
@@ -2101,14 +2338,14 @@ async function introspectPostgres(params) {
     const savedPath = await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "readSearchPath" }));
     const searchPath = savedPath[0]?.searchPath;
     if (typeof searchPath !== "string")
-      throw new VibeError12({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
+      throw new VibeError13({ code: "VIBE_MIGRATION", message: "Cannot read the migration search_path" });
     const matched = await verifyPostgresRls({ executor, ...params.rlsSchema === undefined ? {} : { schema: params.rlsSchema }, ...params.requireInstalledRls === undefined ? {} : { requireInstalled: params.requireInstalledRls } }).then((verified) => verified, (error) => {
-      if (error instanceof VibeError12)
+      if (error instanceof VibeError13)
         throw error;
-      throw new VibeError12({ code: "VIBE_MIGRATION", message: "Native RLS verification could not complete. Check migration privileges and supply the deployed schema as previousSchema/rlsSchema before changing referenced columns.", meta: { reason: "rls-verification-unavailable" }, cause: error });
+      throw new VibeError13({ code: "VIBE_MIGRATION", message: "Native RLS verification could not complete. Check migration privileges and supply the deployed schema as previousSchema/rlsSchema before changing referenced columns.", meta: { reason: "rls-verification-unavailable" }, cause: error });
     });
     await executor(renderRlsReadinessQuery({ dialect: postgresDialect6, query: "setSearchPath", searchPath }));
-    const physical = await introspectPhysicalPostgres({ executor });
+    const physical = await introspectPhysicalPostgres({ executor, namespaces: params.namespaces ?? ["public", ...params.rlsSchema?.models.flatMap((model) => model.namespace === undefined ? [] : [model.namespace]) ?? []] });
     return projectPostgresRls({ physical, ...params.rlsSchema === undefined ? {} : { declared: params.rlsSchema }, matched });
   } finally {
     if (params.inTransaction !== true)
@@ -2117,17 +2354,51 @@ async function introspectPostgres(params) {
 }
 async function introspectPhysicalPostgres(params) {
   const { executor } = params;
+  const namespaces = [...new Set(params.namespaces ?? ["public"])];
+  const physicalNames = new Map;
+  const enumIdentities = new Map;
+  const namespaceObjects = [];
+  const read = async (query) => {
+    const groups = await Promise.all(namespaces.map(async (namespace) => {
+      assertSqlNamespace2({ namespace, dialect: "postgres" });
+      const sql = renderPostgresPhysicalCatalog({ dialect: postgresDialect6, namespace, query });
+      const rows = await executor({ text: sql.text, values: [...sql.values] });
+      return rows.map((row) => {
+        const name = typeof row.table_name === "string" ? row.table_name : undefined;
+        const table = name === undefined ? undefined : physicalNameKey({ namespace, name });
+        if (table !== undefined && name !== undefined)
+          physicalNames.set(table, { namespace, name });
+        const typeName = typeof row.type_name === "string" ? row.type_name : undefined;
+        const enumKey = typeName === undefined ? undefined : physicalNameKey({ namespace, name: typeName });
+        if (enumKey !== undefined && typeName !== undefined)
+          enumIdentities.set(enumKey, { namespace, name: typeName });
+        return { ...row, ...table === undefined ? {} : { table_name: table }, ...enumKey === undefined ? {} : { type_name: enumKey }, ...typeof row.foreign_table_name === "string" ? { foreign_table_name: physicalNameKey({ namespace: typeof row.foreign_namespace === "string" ? row.foreign_namespace : namespace, name: row.foreign_table_name }) } : {} };
+      });
+    }));
+    return groups.flat();
+  };
+  for (const namespace of namespaces) {
+    if (namespace === "public")
+      continue;
+    const query = renderMigrationObjectQuery({ dialect: postgresDialect6, identity: { kind: "namespace", name: namespace } });
+    if ((await executor({ text: query.text, values: [...query.values] })).length > 0)
+      namespaceObjects.push({ id: `namespace:${namespace}`, dialect: "postgres", identity: { kind: "namespace", name: namespace }, create: [], drop: [], dependsOn: [] });
+  }
   const [tableRows, viewRows, columnRows, constraintRows, fkRows, enumRows, indexRows, checkRows, exclusionRows] = await Promise.all([
-    executor({ text: TABLES_QUERY }),
-    executor({ text: VIEWS_QUERY }),
-    executor({ text: COLUMNS_QUERY }),
-    executor({ text: CONSTRAINTS_QUERY }),
-    executor({ text: FOREIGN_KEYS_QUERY }),
-    executor({ text: ENUMS_QUERY }),
-    executor({ text: INDEXES_QUERY }),
-    executor({ text: CHECKS_QUERY }),
-    executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6 }) })
+    read("tables"),
+    read("views"),
+    read("columns"),
+    read("constraints"),
+    read("foreignKeys"),
+    read("enums"),
+    read("indexes"),
+    read("checks"),
+    Promise.all(namespaces.map(async (namespace) => (await executor({ text: renderExclusionCatalog2({ dialect: postgresDialect6, namespace }) })).map((row) => ({ ...row, table_name: physicalNameKey({ namespace, name: String(row.table_name) }) })))).then((rows) => rows.flat())
   ]);
+  const keysQuery = renderPostgresIndexKeys({ dialect: postgresDialect6 });
+  const indexKeys = await executor({ text: keysQuery.text, values: [...keysQuery.values] });
+  if (indexKeys.some((row) => typeof row.table_namespace !== "string" || typeof row.table_name !== "string" || typeof row.index_name !== "string" || typeof row.method !== "string" || typeof row.unique !== "boolean" || typeof row.descending !== "boolean" || typeof row.exact_default !== "boolean" && row.column_name !== null || typeof row.operator_namespace !== "string" || typeof row.operator_name !== "string" || !Number.isSafeInteger(Number(row.ordinal)) || Number(row.ordinal) < 1))
+    throw new VibeError13({ code: "VIBE_MIGRATION", message: "PostgreSQL index-key identity is incomplete", meta: { reason: "index-inspection-unavailable" } });
   const tables = tableRows.map((row) => row.table_name);
   const views = viewRows.map((row) => row.table_name);
   const columns = columnRows.map((row) => ({
@@ -2135,6 +2406,7 @@ async function introspectPhysicalPostgres(params) {
     name: row.column_name,
     dataType: row.data_type,
     udtName: row.udt_name,
+    udtNamespace: typeof row.udt_schema === "string" ? row.udt_schema : "public",
     nullable: row.is_nullable === "YES",
     identity: row.is_identity === "YES",
     columnDefault: row.column_default ?? null,
@@ -2167,7 +2439,7 @@ async function introspectPhysicalPostgres(params) {
     const table = row.table_name;
     const constraintName = row.constraint_name;
     const columnName = row.column_name;
-    constraintNames.add(constraintName);
+    constraintNames.add(JSON.stringify([table, constraintName]));
     if (row.constraint_type === "PRIMARY KEY") {
       pkNames.set(table, constraintName);
       const list = pkByTable.get(table);
@@ -2176,9 +2448,10 @@ async function introspectPhysicalPostgres(params) {
       else
         list.push(columnName);
     } else {
-      const entry = uniquesByConstraint.get(constraintName);
+      const constraintKey = JSON.stringify([table, constraintName]);
+      const entry = uniquesByConstraint.get(constraintKey);
       if (entry === undefined)
-        uniquesByConstraint.set(constraintName, { table, columns: [columnName] });
+        uniquesByConstraint.set(constraintKey, { table, name: constraintName, columns: [columnName] });
       else
         entry.columns.push(columnName);
     }
@@ -2225,17 +2498,35 @@ async function introspectPhysicalPostgres(params) {
   for (const row of indexRows) {
     if (row.backing_constraint_type === "x")
       continue;
-    const parsed = parseIndexDef({
-      table: row.table_name,
-      name: row.index_name,
-      def: row.index_def
-    });
-    if (parsed !== null)
-      indexes.push(parsed);
+    const operands = indexKeys.filter((key) => physicalNameKey({ namespace: String(key.table_namespace), name: String(key.table_name) }) === row.table_name && key.index_name === row.index_name);
+    if (row.plain_columns === true && operands.length !== Number(row.key_count))
+      throw new VibeError13({ code: "VIBE_MIGRATION", message: "Plain index keys could not be read completely; refusing name-only operator-class introspection", meta: { reason: "index-inspection-unavailable", table: row.table_name, index: row.index_name } });
+    if (operands.length > 0) {
+      if (operands.every((key) => typeof key.column_name === "string"))
+        indexes.push({
+          table: String(row.table_name),
+          name: String(row.index_name),
+          unique: operands[0].unique === true,
+          kind: String(operands[0].method),
+          columns: operands.map((key) => ({ name: String(key.column_name), desc: key.descending === true, ...key.exact_default === true ? {} : { operatorClass: { namespace: String(key.operator_namespace), name: String(key.operator_name) } } })),
+          ...typeof operands[0].predicate === "string" ? { where: operands[0].predicate } : {},
+          ...operands[0].nulls_not_distinct === true ? { nullsNotDistinct: true } : {}
+        });
+      else {
+        const parsed = parseIndexDef({ table: String(row.table_name), name: String(row.index_name), def: String(row.index_def) });
+        if (parsed !== null)
+          indexes.push(parsed);
+      }
+    } else {
+      const parsed = parseIndexDef({ table: String(row.table_name), name: String(row.index_name), def: String(row.index_def) });
+      if (parsed !== null)
+        indexes.push(parsed);
+    }
   }
   const joinTables = new Map;
   for (const table of tables) {
-    if (!table.startsWith("_"))
+    const physicalTable = physicalNames.get(table);
+    if (!physicalTable.name.startsWith("_"))
       continue;
     const tableFks = fkRows.filter((row) => row.table_name === table);
     const tableIndexes = indexRows.filter((row) => row.table_name === table);
@@ -2251,14 +2542,16 @@ async function introspectPhysicalPostgres(params) {
       return source === undefined || target === undefined || typeof source.full_type !== "string" || source.full_type.length === 0 || source.full_type !== target.full_type || source.column_default !== null || source.is_identity !== "NO" || source.is_generated !== "NEVER" || source.is_nullable !== "NO" || source.collation_name === undefined || source.collation_name !== target.collation_name;
     }))
       continue;
+    if (tableFks.some((row) => row.foreign_namespace !== undefined && row.foreign_namespace !== physicalTable.namespace))
+      continue;
     const detected = detectJoinTable({
-      table,
+      table: physicalTable.name,
       columnNames: columns.filter((column) => column.table === table).map((column) => column.name),
-      fkGroups,
-      indexes
+      fkGroups: fkGroups.filter((group) => group.table === table).map((group) => ({ ...group, table: physicalTable.name, refTable: physicalNames.get(group.refTable)?.name ?? group.refTable })),
+      indexes: indexes.filter((index) => index.table === table).map((index) => ({ ...index, table: physicalTable.name }))
     });
     if (detected !== null)
-      joinTables.set(table, detected);
+      joinTables.set(table, { ...detected, ...physicalTable.namespace === "public" && namespaces.length === 1 ? {} : { relationName: detected.relationName ?? physicalTable.name.slice(1) }, tableA: physicalNameKey({ namespace: physicalTable.namespace, name: detected.tableA }), tableB: physicalNameKey({ namespace: physicalTable.namespace, name: detected.tableB }) });
   }
   const models = [];
   for (const table of tables) {
@@ -2266,6 +2559,7 @@ async function introspectPhysicalPostgres(params) {
       continue;
     models.push(buildModel({
       table,
+      physicalTable: physicalNames.get(table).name,
       isView: false,
       columns,
       pkByTable,
@@ -2281,6 +2575,7 @@ async function introspectPhysicalPostgres(params) {
   for (const view of views) {
     models.push(buildModel({
       table: view,
+      physicalTable: physicalNames.get(view).name,
       isView: true,
       columns,
       pkByTable,
@@ -2294,14 +2589,59 @@ async function introspectPhysicalPostgres(params) {
   }
   addFkRelations({ models, fkGroups, joinTables });
   addJoinTableRelations({ models, joinTables });
+  const logicalNames = new Set([...physicalNames.values(), ...enumIdentities.values()].map((entry) => entry.name));
+  const logicalName = (params) => {
+    if (!params.duplicates && /^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(params.name) && !isReservedClientName({ name: params.name.charAt(0).toLowerCase() + params.name.slice(1) }))
+      return params.name;
+    const hex = Array.from(new TextEncoder().encode(params.key), (byte) => byte.toString(16).padStart(2, "0")).join("");
+    let name = `VibePhysical_${hex}`;
+    while (logicalNames.has(name))
+      name += "_";
+    logicalNames.add(name);
+    return name;
+  };
+  const modelNames = new Map(models.map((model) => {
+    const identity = physicalNames.get(model.name);
+    const duplicates = [...physicalNames.values()].filter((entry) => entry.name === identity.name).length > 1;
+    return [model.name, logicalName({ key: model.name, name: identity.name, duplicates })];
+  }));
+  const enumLogicalNames = new Map(enums.map((entry) => {
+    const identity = enumIdentities.get(entry.name);
+    const duplicates = [...enumIdentities.values()].filter((candidate) => candidate.name === identity.name).length > 1;
+    return [entry.name, logicalName({ key: entry.name, name: identity.name, duplicates })];
+  }));
+  const qualifiedModels = models.map((model) => {
+    const identity = physicalNames.get(model.name);
+    const name = modelNames.get(model.name);
+    const { dbName: _physicalName, ...metadata } = model;
+    return {
+      ...metadata,
+      name,
+      ...name === identity.name ? {} : { dbName: identity.name },
+      ...identity.namespace === "public" ? {} : { namespace: identity.namespace },
+      fields: model.fields.map((field) => {
+        if (typeof field.type === "string")
+          return field;
+        const identity = enumIdentities.get(field.type.enum);
+        return { ...field, type: { enum: enumLogicalNames.get(field.type.enum), ...identity.namespace === "public" ? {} : { namespace: identity.namespace } } };
+      }),
+      relations: model.relations.map((relation) => ({ ...relation, name: /^[$_\p{ID_Start}][$_\u200c\u200d\p{ID_Continue}]*$/u.test(relation.name) ? relation.name : `relation_${Array.from(new TextEncoder().encode(relation.name), (byte) => byte.toString(16).padStart(2, "0")).join("")}`, model: name, targetModel: modelNames.get(relation.targetModel) ?? relation.targetModel }))
+    };
+  });
+  const qualifiedEnums = enums.map((entry) => {
+    const identity = enumIdentities.get(entry.name);
+    const name = enumLogicalNames.get(entry.name);
+    return { ...entry, name, ...name === identity.name ? {} : { dbName: identity.name }, ...identity.namespace === "public" ? {} : { namespace: identity.namespace } };
+  });
   const resolved = await resolvePostgresTypeIdentities({ executor, mode: "catalog", schema: {
     datasource: { provider: "postgresql" },
-    models,
-    enums,
-    extensions: []
+    models: qualifiedModels,
+    enums: qualifiedEnums,
+    extensions: [],
+    ...namespaceObjects.length === 0 ? {} : { migrationObjects: namespaceObjects }
   } });
   if (resolved.unavailable.length > 0)
-    throw new VibeError12({ code: "VIBE_MIGRATION", message: "PostgreSQL column type identity could not be read", meta: { reason: "type-inspection-unavailable", columns: resolved.unavailable } });
+    throw new VibeError13({ code: "VIBE_MIGRATION", message: "PostgreSQL column type identity could not be read", meta: { reason: "type-inspection-unavailable", columns: resolved.unavailable } });
   return resolved.schema;
 }
 function buildModel(params) {
@@ -2310,18 +2650,19 @@ function buildModel(params) {
   const pk = pkByTable.get(table) ?? [];
   const uniqueSingles = new Set;
   const multiUniques = [];
-  for (const [name, unique] of uniquesByConstraint) {
+  for (const unique of uniquesByConstraint.values()) {
+    const name = unique.name;
     if (unique.table !== table)
       continue;
     if (unique.columns.length === 1)
       uniqueSingles.add(unique.columns[0]);
     multiUniques.push({ name, columns: unique.columns });
   }
-  const tableIndexes = indexes.filter((index) => index.table === table && !constraintNames.has(index.name));
+  const tableIndexes = indexes.filter((index) => index.table === table && !constraintNames.has(JSON.stringify([table, index.name])));
   for (const index of tableIndexes) {
     if (!index.unique)
       continue;
-    if (index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true) {
+    if (index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true && index.columns[0]?.operatorClass === undefined) {
       uniqueSingles.add(index.columns[0].name);
     }
   }
@@ -2336,7 +2677,7 @@ function buildModel(params) {
     });
   }
   for (const index of tableIndexes) {
-    if (index.unique && index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true && index.name === `${table}_${index.columns[0].name}_key`) {
+    if (index.unique && index.columns.length === 1 && index.where === undefined && index.nullsNotDistinct !== true && index.columns[0]?.operatorClass === undefined && index.name === `${params.physicalTable}_${index.columns[0].name}_key`) {
       continue;
     }
     modelIndexes.push({
@@ -2344,7 +2685,8 @@ function buildModel(params) {
       kind: index.unique ? "unique" : index.kind,
       fields: index.columns.map((column) => ({
         name: column.name,
-        ...column.desc ? { sort: "desc" } : {}
+        ...column.desc ? { sort: "desc" } : {},
+        ...column.operatorClass === undefined ? {} : { operatorClass: column.operatorClass }
       })),
       ...index.where === undefined ? {} : { where: index.where },
       ...index.nullsNotDistinct === true ? { nullsNotDistinct: true } : {}
@@ -2352,6 +2694,7 @@ function buildModel(params) {
   }
   return {
     name: table,
+    dbName: params.physicalTable,
     fields,
     relations: [],
     indexes: modelIndexes,
@@ -2389,8 +2732,9 @@ function reverseMapType(params) {
   const { column, enumNames } = params;
   const isList = column.dataType === "ARRAY";
   const udt = isList ? column.udtName.replace(/^_/, "") : column.udtName;
-  if (enumNames.has(udt)) {
-    return { type: { enum: udt }, isList };
+  const enumKey = physicalNameKey({ namespace: column.udtNamespace, name: udt });
+  if (enumNames.has(enumKey)) {
+    return { type: { enum: enumKey }, isList };
   }
   const canonical = CANONICAL_UDT[udt];
   if (canonical !== undefined) {
@@ -2412,8 +2756,9 @@ function reverseMapType(params) {
 function nonCanonicalModifier(params) {
   const { column, udt, scalar } = params;
   if (column.dataType === "ARRAY" && column.fullType !== null) {
-    const element = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^(numeric|timestamptz)\([\d,]+\)$/.test(element))
+    const temporal = parseUnsupportedPostgresType({ raw: column.fullType });
+    const element = temporal?.name === "timestamptz" ? `timestamptz${temporal.modifier}` : normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
+    if (element !== "timestamptz(6)" && /^(numeric|timestamptz)\([\d,]+\)$/.test(element))
       return element;
   }
   if (scalar === "DateTime" && udt === "timestamptz") {
@@ -2430,9 +2775,9 @@ function nonCanonicalModifier(params) {
 }
 function withModifier(params) {
   const { column, udt } = params;
-  if (udt === "varchar" && column.dataType === "ARRAY" && column.fullType !== null) {
+  if ((udt === "varchar" || udt === "bpchar" || udt === "bit" || udt === "varbit") && column.dataType === "ARRAY" && column.fullType !== null) {
     const elementType = normalizeNativeType({ raw: column.fullType }).replace(/\[\]$/, "");
-    if (/^varchar\(\d+\)$/.test(elementType))
+    if (/^(varchar|char|bit|varbit)\(\d+\)$/.test(elementType))
       return elementType;
   }
   if ((udt === "varchar" || udt === "bpchar") && column.charMaxLength !== null) {
@@ -2442,6 +2787,10 @@ function withModifier(params) {
     return "char";
   if ((udt === "bit" || udt === "varbit") && column.charMaxLength !== null)
     return `${udt}(${column.charMaxLength})`;
+  if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.dataType === "ARRAY" && column.fullType !== null) {
+    const element = parseUnsupportedPostgresType({ raw: column.fullType });
+    return element === undefined || element.modifier === "" || element.modifier === "(6)" ? udt : `${udt}${element.modifier}`;
+  }
   if ((udt === "timestamp" || udt === "time" || udt === "timetz") && column.datetimePrecision !== null && column.datetimePrecision !== 6) {
     return `${udt}(${column.datetimePrecision})`;
   }
@@ -2596,7 +2945,12 @@ function toNumberOrNull(value) {
 // packages/migrate/src/introspect/mysql.ts
 import { exactIntegerLiteral as exactIntegerLiteral2 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect2 } from "@vibeorm/sql";
-var TABLES_QUERY2 = `
+
+// packages/migrate/src/journal-table.ts
+var MIGRATIONS_TABLE_NAME = "_vibe_migrations";
+
+// packages/migrate/src/introspect/mysql.ts
+var TABLES_QUERY = `
   SELECT table_name, engine
   FROM information_schema.tables
   WHERE table_schema = DATABASE()
@@ -2604,13 +2958,13 @@ var TABLES_QUERY2 = `
     AND table_name <> '${MIGRATIONS_TABLE_NAME}'
   ORDER BY table_name;
 `;
-var VIEWS_QUERY2 = `
+var VIEWS_QUERY = `
   SELECT table_name
   FROM information_schema.views
   WHERE table_schema = DATABASE()
   ORDER BY table_name;
 `;
-var COLUMNS_QUERY2 = `
+var COLUMNS_QUERY = `
   SELECT
     table_name,
     column_name,
@@ -2641,7 +2995,7 @@ var STATISTICS_QUERY = `
   WHERE table_schema = DATABASE()
   ORDER BY table_name, index_name, seq_in_index;
 `;
-var FOREIGN_KEYS_QUERY2 = `
+var FOREIGN_KEYS_QUERY = `
   SELECT
     constraint_name,
     table_name,
@@ -2661,7 +3015,7 @@ var REFERENTIAL_QUERY = `
   FROM information_schema.referential_constraints
   WHERE constraint_schema = DATABASE();
 `;
-var CHECKS_QUERY2 = `
+var CHECKS_QUERY = `
   SELECT
     tc.table_name AS table_name,
     tc.constraint_name AS constraint_name,
@@ -2688,13 +3042,13 @@ function catalogField(params) {
 async function introspectMysql(params) {
   const { executor } = params;
   const [tableRows, viewRows, columnRows, statisticRows, fkRows, refRows, checkRows] = await Promise.all([
-    executor({ text: TABLES_QUERY2 }),
-    executor({ text: VIEWS_QUERY2 }),
-    executor({ text: COLUMNS_QUERY2 }),
+    executor({ text: TABLES_QUERY }),
+    executor({ text: VIEWS_QUERY }),
+    executor({ text: COLUMNS_QUERY }),
     executor({ text: STATISTICS_QUERY }),
-    executor({ text: FOREIGN_KEYS_QUERY2 }),
+    executor({ text: FOREIGN_KEYS_QUERY }),
     executor({ text: REFERENTIAL_QUERY }),
-    executor({ text: CHECKS_QUERY2 })
+    executor({ text: CHECKS_QUERY })
   ]);
   const checksByTable = new Map;
   for (const row of checkRows) {
@@ -3448,7 +3802,7 @@ function q(name) {
 }
 
 // packages/migrate/src/execute.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
 var SELF_MANAGED_MARKER = "PRAGMA foreign_keys=OFF";
 var FK_CHECK_PREFIX = "PRAGMA foreign_key_check";
 function usesSelfManagedTransactions(params) {
@@ -3489,7 +3843,7 @@ function assertSelfManagedResumeSafe(params) {
   const completedIndex = params.direction === "up" ? params.start + 1 : -(params.start + 2);
   const rewind = selfManagedResumeStart({ sql: params.sql, start: params.start });
   const retryIndex = params.direction === "up" ? rewind : -(rewind + 1);
-  throw new VibeError13({
+  throw new VibeError14({
     code: "VIBE_MIGRATION",
     message: `migration "${params.migration}" has a legacy sqlite checkpoint at ${params.direction} COMMIT (statement ${params.start + 1}). The block may already have committed; replay is refused. Inspect the block's effects. If it committed, set its journal statement_index to ${completedIndex} and error to NULL to resume the remaining statements. Only if the entire block did not commit, set statement_index to ${retryIndex} and error to NULL to retry the block. Do not mark the whole migration applied unless all remaining statements also ran.`,
     meta: { reason: "uncertain-statement", migration: params.migration, statementIndex: params.start, direction: params.direction, dialect: "sqlite" }
@@ -3518,7 +3872,7 @@ function unsupportedScript(params) {
   const { migration, direction, index, problem, found } = params;
   const subject = direction === "down" ? `the down script of migration "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${params.statements}`;
-  return new VibeError13({
+  return new VibeError14({
     code: "VIBE_MIGRATION",
     message: `${subject} manages its own sqlite transactions, and ${position} breaks the shape recovery depends on: ${found}. ` + `A table-rebuild block must be written exactly as \`${SUPPORTED_BLOCK_SHAPE}\`. ` + "Inside that block a crash rolls everything back, so a resume can replay it safely. " + "A statement that sits in a foreign-keys-off region with no transaction around it commits on its own, " + "and the resume would run it a second time with no error raised either time. " + "Nothing has been executed. Move the statement after `PRAGMA foreign_keys=ON`, where it commits together " + "with its own journal checkpoint, or give it its own `BEGIN;` and `COMMIT;`. " + 'See "Self-managed sqlite scripts" in docs/migrations.md.',
     meta: { reason: "unsupported-self-managed-script", problem, migration, statementIndex: index, direction }
@@ -3574,7 +3928,7 @@ async function executeStatement(params) {
     const rows = await executor({ text: statement, values: [] });
     if (rows.length > 0) {
       const sample = rows.slice(0, 5).map((row) => `${String(row.table)} rowid ${String(row.rowid)} \u2192 ${String(row.parent)}`).join("; ");
-      throw new VibeError13({
+      throw new VibeError14({
         code: "VIBE_MIGRATION",
         message: `foreign key check failed after table rebuild: ${rows.length} violation(s) \u2014 ${sample}`,
         meta: { violations: rows }
@@ -3593,9 +3947,44 @@ async function cleanupSelfManagedFailure(params) {
   } catch {}
 }
 
+// packages/migrate/src/operator-classes.ts
+import { defaultIndexName as defaultIndexName2, qualifiedSqlName as qualifiedSqlName7 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect7, renderPostgresIndexKeys as renderPostgresIndexKeys2 } from "@vibeorm/sql";
+async function prepareOperatorClassDiff(params) {
+  const models = [];
+  for (const live of params.from.models) {
+    const table = qualifiedSqlName7({ name: live.dbName ?? live.name, namespace: live.namespace });
+    const authored = params.to.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace }) === physicalNameKey(table));
+    if (authored === undefined || !authored.indexes.some((index) => index.fields.some((field) => field.operatorClass !== undefined))) {
+      models.push(live);
+      continue;
+    }
+    const query = renderPostgresIndexKeys2({ dialect: postgresDialect7, table });
+    const rows = await params.executor({ text: query.text, values: [...query.values] });
+    const indexes = live.indexes.map((index) => {
+      const declared = authored.indexes.find((entry) => (entry.name ?? defaultIndexName2({ table: table.name, columns: entry.fields.map((field) => authored.fields.find((candidate) => candidate.name === field.name)?.dbName ?? field.name), unique: entry.kind === "unique", dialect: "postgres" })) === index.name && entry.kind === index.kind);
+      if (declared === undefined)
+        return index;
+      return { ...index, fields: index.fields.map((field, position) => {
+        const requested = declared.fields[position];
+        const operatorClass = requested?.operatorClass;
+        const physicalColumn = authored.fields.find((entry) => entry.name === requested?.name)?.dbName ?? requested?.name;
+        if (field.operatorClass !== undefined || operatorClass === undefined || physicalColumn !== field.name)
+          return field;
+        const row = rows.find((entry) => entry.index_name === index.name && Number(entry.ordinal) === position + 1 && entry.column_name === field.name);
+        if (row?.exact_default !== true || row.operator_namespace !== operatorClass.namespace || row.operator_name !== operatorClass.name || row.method !== (index.kind === "unique" ? "btree" : index.kind))
+          return field;
+        return { ...field, operatorClass };
+      }) };
+    });
+    models.push({ ...live, indexes });
+  }
+  return { ...params.from, models };
+}
+
 // packages/migrate/src/postgres-default-equivalence.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect7, renderPostgresDefaultFunctionIdentity } from "@vibeorm/sql";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect8, renderPostgresDefaultFunctionIdentity } from "@vibeorm/sql";
 var IDENTIFIER = '(?:"(?:[^"\\u0000]|"")+"|[A-Za-z_][A-Za-z_0-9$]*)';
 var CALL = new RegExp(`^\\s*(${IDENTIFIER})(?:\\s*\\.\\s*(${IDENTIFIER}))?\\s*\\(\\s*\\)\\s*$`);
 function parseCall(params) {
@@ -3611,9 +4000,9 @@ async function equivalentPostgresDefaultFunction(params) {
   const observed = parseCall({ expression: params.actual });
   if (expected?.namespace === undefined || observed === undefined)
     return false;
-  const query = renderPostgresDefaultFunctionIdentity({ dialect: postgresDialect7, table: params.table, column: params.column });
+  const query = renderPostgresDefaultFunctionIdentity({ dialect: postgresDialect8, table: params.table, column: params.column });
   const rows = await params.executor({ text: query.text, values: [...query.values] }).catch((cause) => {
-    throw new VibeError14({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
+    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot inspect the stored default function identity", meta: { reason: "default-inspection-unavailable", table: params.table, column: params.column }, cause });
   });
   if (rows.length !== 1)
     return false;
@@ -3641,8 +4030,8 @@ function factsOf(params) {
 }
 async function inspectSqlObject(params) {
   return Promise.resolve().then(async () => {
-    const namespace = "table" in params.identity ? params.identity.table.namespace : params.identity.name.namespace;
-    const query = renderMigrationObjectQuery({ dialect: getSqlDialect({ dialect: params.dialect }), identity: params.identity });
+    const namespace = sqlObjectNamespace2({ identity: params.identity });
+    const query = renderMigrationObjectQuery2({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
     if (params.dialect === "mysql")
       await assertCatalogVisibility({ executor: params.executor, dialect: params.dialect, namespace });
     const rows = await params.executor({ text: query.text, values: [...query.values] });
@@ -3666,7 +4055,7 @@ async function inspectSqlObject(params) {
         const constraintType = params.identity.constraintType;
         const constraint = sqliteTableConstraints2({ sql: String(facts.definition ?? "") }).find((entry) => entry.name === name && entry.type === constraintType);
         if (constraint === undefined && constraintType === "primaryKey" && name === `${params.identity.table.name}_pkey`) {
-          const query = renderSqliteColumnInventory({ dialect: getSqlDialect({ dialect: "sqlite" }), namespace: params.identity.table.namespace, table: params.identity.table.name });
+          const query = renderSqliteColumnInventory({ dialect: getSqlDialect2({ dialect: "sqlite" }), namespace: params.identity.table.namespace, table: params.identity.table.name });
           const columns = (await params.executor({ text: query.text, values: [...query.values] })).filter((column) => Number(column.pk) > 0).sort((a, b) => Number(a.pk) - Number(b.pk));
           if (columns.length === 0)
             return { state: "missing" };
@@ -3689,12 +4078,12 @@ async function inspectSqlObject(params) {
     if (params.identity.kind === "columnDefault")
       facts = { definition: facts.definition ?? null };
     if (params.dialect === "postgres") {
-      const query = renderMigrationDependencies({ dialect: getSqlDialect({ dialect: params.dialect }), identity: params.identity });
+      const query = renderMigrationDependencies({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
       const rows = await params.executor({ text: query.text, values: [...query.values] });
       return postgresInspection({ identity: params.identity, facts, addresses: rows.map((row) => row.address) });
     }
     if (params.dialect === "mysql") {
-      const query = renderMysqlObjectMembers({ dialect: getSqlDialect({ dialect: params.dialect }), identity: params.identity });
+      const query = renderMysqlObjectMembers({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: params.identity });
       if (query !== undefined) {
         const rows = await params.executor({ text: query.text, values: [...query.values] });
         if (params.identity.kind === "function" && rows.length === 0)
@@ -3708,7 +4097,7 @@ async function inspectSqlObject(params) {
       }
     }
     return { state: "present", definition: { identity: params.identity, facts, dependencies: [], format: "catalog-v2" } };
-  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError15 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
+  }).catch((error) => ({ state: "unavailable", reason: error instanceof VibeError16 ? String(error.meta.feature ?? error.code) : "catalog-query-failed" }));
 }
 function postgresInspection(params) {
   if (!params.addresses.every((address) => typeof address === "string"))
@@ -3723,7 +4112,7 @@ function postgresInspection(params) {
   return { state: "present", definition: { identity: params.identity, facts, dependencies, format: "catalog-v2" } };
 }
 function unavailableReason(params) {
-  return params.error instanceof VibeError15 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
+  return params.error instanceof VibeError16 ? String(params.error.meta.feature ?? params.error.meta.reason ?? params.error.code) : "catalog-query-failed";
 }
 async function readBatch(params) {
   const positions = new Set(params.batch.positions);
@@ -3731,7 +4120,7 @@ async function readBatch(params) {
     const rows = new Map;
     for (const row of await params.executor({ text: params.batch.text, values: [...params.batch.values] })) {
       if (typeof row.position !== "number" || !Number.isInteger(row.position) || !positions.has(row.position))
-        throw new VibeError15({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
+        throw new VibeError16({ code: "VIBE_MIGRATION", message: "Invalid batched catalog identity", meta: { reason: "catalog-query-failed" } });
       const matches = rows.get(row.position) ?? [];
       matches.push(row);
       rows.set(row.position, matches);
@@ -3759,7 +4148,7 @@ async function inspectSqlObjects(params) {
   }
   return Promise.resolve().then(async () => {
     const results = params.identities.map(() => ({ state: "unavailable", reason: "catalog-query-failed" }));
-    for (const batch of renderMigrationObjectBatch({ dialect: getSqlDialect({ dialect: params.dialect }), identities: params.identities })) {
+    for (const batch of renderMigrationObjectBatch({ dialect: getSqlDialect2({ dialect: params.dialect }), identities: params.identities })) {
       const outcome = await readBatch({ executor: params.executor, batch });
       for (const position of batch.positions) {
         results[position] = outcome.ok ? batchedInspection({ identity: params.identities[position], matches: outcome.rows.get(position) ?? [] }) : { state: "unavailable", reason: outcome.reason };
@@ -3771,12 +4160,12 @@ async function inspectSqlObjects(params) {
 async function assertCatalogVisibility(params) {
   if (params.dialect !== "mysql")
     return;
-  const query = renderMigrationVisibility({ dialect: getSqlDialect({ dialect: params.dialect }), namespace: params.namespace });
+  const query = renderMigrationVisibility({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace });
   const rows = await params.executor({ text: query.text, values: [...query.values] });
   const grants = new Set(rows.map((row) => row.privilege));
   const missing = ["SELECT", "TRIGGER", "SHOW VIEW", "EXECUTE"].filter((privilege) => !grants.has(privilege));
   if (missing.length > 0)
-    throw new VibeError15({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
+    throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL catalog visibility requires direct database-wide grants; role-only or partial grants cannot prove object absence", meta: { reason: "inventory-unavailable", missing } });
 }
 var CATALOG_V1_OMITTED_FACTS = Object.freeze({
   function: ["definerOwner"],
@@ -3794,27 +4183,29 @@ function compare(params) {
     if (expected === undefined !== (actual === undefined) || canonicalMigrationJson({ value: expected }) !== canonicalMigrationJson({ value: actual }))
       differences.push({ attribute: key, expected, actual });
   }
-  const expected = params.expected.dependencies.map((identity) => sqlObjectKey4({ identity })).sort();
-  const actual = params.live.dependencies.map((identity) => sqlObjectKey4({ identity })).sort();
+  const expected = params.expected.dependencies.map((identity) => sqlObjectKey5({ identity })).sort();
+  const actual = params.live.dependencies.map((identity) => sqlObjectKey5({ identity })).sort();
   if (JSON.stringify(expected) !== JSON.stringify(actual))
     differences.push({ attribute: "dependencies", expected, actual });
   return differences;
 }
 function assertProbeMode(params) {
   if (params.probe !== undefined && params.probe !== "none" && DIALECT_CAPABILITIES2[params.dialect].checkNormalization !== params.probe)
-    throw new VibeError15({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
+    throw new VibeError16({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `${params.probe} CHECK probes are unavailable on ${params.dialect}`, meta: { feature: "checkProbe", dialect: params.dialect } });
 }
 async function verifyMigrationState(params) {
   return verifyState(params);
 }
 async function verifyState(params) {
+  if (params.external !== undefined)
+    params = { ...params, expected: projectExternalState({ state: params.expected, external: params.external }) };
   assertProbeMode({ dialect: params.dialect, probe: params.probe });
   const declarations = params.expected.schema.migrationObjects ?? [];
-  const owned = new Set(declarations.map((object) => sqlObjectKey4({ identity: object.identity })));
-  const definitions = new Map(params.expected.definitions.map((definition) => [sqlObjectKey4({ identity: definition.identity }), definition]));
-  const identities = new Map(params.expected.definitions.map((definition) => [sqlObjectKey4({ identity: definition.identity }), definition.identity]));
+  const owned = new Set(declarations.map((object) => sqlObjectKey5({ identity: object.identity })));
+  const definitions = new Map(params.expected.definitions.map((definition) => [sqlObjectKey5({ identity: definition.identity }), definition]));
+  const identities = new Map(params.expected.definitions.map((definition) => [sqlObjectKey5({ identity: definition.identity }), definition.identity]));
   for (const object of declarations)
-    identities.set(sqlObjectKey4({ identity: object.identity }), object.identity);
+    identities.set(sqlObjectKey5({ identity: object.identity }), object.identity);
   const objects = [];
   const inspections = params.batch === true ? await inspectSqlObjects({ ...params, identities: [...identities.values()] }) : undefined;
   let position = 0;
@@ -3825,6 +4216,8 @@ async function verifyState(params) {
     position++;
     if (live.state !== "present") {
       objects.push({ identity, ownership, state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
+    } else if (expected === undefined && identity.kind === "namespace") {
+      objects.push({ identity, ownership, state: "matching", differences: [] });
     } else if (expected === undefined) {
       objects.push({ identity, ownership, state: "unavailable", reason: "independent-definition-required", differences: [] });
     } else if (params.dialect === "postgres" && identity.kind === "table" && (expected.facts.persistence === undefined || expected.facts.options === undefined)) {
@@ -3834,23 +4227,31 @@ async function verifyState(params) {
       objects.push({ identity, ownership, state: differences.length === 0 ? "matching" : "changed", differences });
     }
   }
-  if (params.expected.schema.models.length > 0 || params.expected.schema.enums.length > 0)
+  if (params.dialect === "postgres" && schemaNamespaces({ schema: params.expected.schema }).length > 0 || params.expected.schema.models.length > 0 || params.expected.schema.enums.length > 0)
     objects.push(...await verifySchemaObjects(params));
   if (params.dialect === "postgres")
     objects.push(...await verifyExclusions(params));
   return { inSync: objects.every((object) => object.state === "matching"), objects };
 }
 async function verifySchemaObjects(params) {
-  const physical = params.dialect === "postgres" ? await introspectPhysicalPostgres({ executor: params.executor }) : params.dialect === "mysql" ? await introspectMysql({ executor: params.executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor: params.executor }) : await introspectSqlite({ executor: params.executor });
+  const physical = params.dialect === "postgres" ? await introspectPhysicalPostgres({ executor: params.executor, namespaces: ["public", ...params.namespaces ?? [], ...schemaNamespaces({ schema: params.expected.schema })] }) : params.dialect === "mysql" ? await introspectMysql({ executor: params.executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor: params.executor }) : await introspectSqlite({ executor: params.executor });
   const resolved = params.dialect === "postgres" ? await resolvePostgresTypeIdentities({ executor: params.executor, schema: params.expected.schema, mode: "verify" }) : { schema: params.expected.schema, unavailable: [] };
   const expected = normalizeSchema({ schema: resolved.schema, dialect: params.dialect });
-  const actual = normalizeSchema({ schema: physical, dialect: params.dialect });
+  const physicalComparison = params.external === undefined ? physical : projectExternalSchema({ schema: physical, external: params.external });
+  const comparable = params.dialect === "postgres" ? await prepareOperatorClassDiff({ executor: params.executor, from: physicalComparison, to: resolved.schema }) : physicalComparison;
+  const actual = normalizeSchema({ schema: comparable, dialect: params.dialect });
   const objects = resolved.unavailable.map((identity) => ({ identity, ownership: "schema", state: "unavailable", reason: "type-reference-required", differences: [] }));
   const namespace = await migrationNamespace({ executor: params.executor, dialect: params.dialect });
   const sqliteTableOptions = params.dialect === "sqlite" && expected.tables.size > 0 ? await params.executor({ text: "PRAGMA main.table_list;", values: [] }) : undefined;
   if (params.dialect === "postgres")
-    for (const [name, desired] of expected.enums) {
-      const identity = { kind: "enum", name: { namespace, name } };
+    for (const name of schemaNamespaces({ schema: params.expected.schema })) {
+      const identity = { kind: "namespace", name };
+      const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
+      objects.push({ identity, ownership: "schema", state: inspection.state === "present" ? "matching" : inspection.state, differences: [], ...inspection.state === "unavailable" ? { reason: inspection.reason } : {} });
+    }
+  if (params.dialect === "postgres")
+    for (const desired of expected.enums.values()) {
+      const identity = { kind: "enum", name: qualifiedSqlName8({ name: desired.dbName ?? desired.name, namespace: desired.namespace, defaultNamespace: namespace }) };
       const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
       if (live.state !== "present") {
         objects.push({ identity, ownership: "schema", state: live.state, differences: [], ...live.state === "unavailable" ? { reason: live.reason } : {} });
@@ -3864,9 +4265,10 @@ async function verifySchemaObjects(params) {
       const matching = canonicalMigrationJson({ value: desired.values }) === canonicalMigrationJson({ value: values });
       objects.push({ identity, ownership: "schema", state: matching ? "matching" : "changed", differences: matching ? [] : [{ attribute: "values", expected: desired.values, actual: values }] });
     }
-  for (const [name, desired] of expected.tables) {
-    const table = { namespace, name };
-    const live = actual.tables.get(name);
+  for (const [key, desired] of expected.tables) {
+    const name = desired.table;
+    const table = qualifiedSqlName8({ name, namespace: desired.namespace, defaultNamespace: namespace });
+    const live = actual.tables.get(key);
     if (live === undefined) {
       const presence = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity: { kind: "table", name: table } });
       objects.push({ identity: { kind: "table", name: table }, ownership: "schema", state: presence.state === "missing" ? "missing" : "unavailable", ...presence.state === "missing" ? {} : { reason: "schema-definition-not-visible" }, differences: [] });
@@ -3887,12 +4289,13 @@ async function verifySchemaObjects(params) {
     pin("primaryKey", desired.pk, live.pk);
     for (const [column, field] of desired.columns) {
       const stored = live.columns.get(column);
-      pin(`columns.${column}.type`, field.typeKey, stored?.typeKey);
+      const exactType = field.pinsExactType;
+      pin(`columns.${column}.type`, exactType ? field.exactTypeKey : field.typeKey, exactType ? stored?.exactTypeKey : stored?.typeKey);
       pin(`columns.${column}.nullable`, field.nullable, stored?.nullable);
       if (params.dialect === "mysql" && field.field.collation !== undefined) {
         pin(`columns.${column}.collation`, field.field.collation.toLowerCase(), stored?.field.collation?.toLowerCase());
       }
-      const ownedDefault = params.expected.schema.migrationObjects?.some((object) => (object.identity.kind === "columnDefault" || object.identity.kind === "generatedColumn") && object.identity.table.namespace === namespace && object.identity.table.name === name && object.identity.column === column);
+      const ownedDefault = params.expected.schema.migrationObjects?.some((object) => (object.identity.kind === "columnDefault" || object.identity.kind === "generatedColumn") && object.identity.table.namespace === table.namespace && object.identity.table.name === name && object.identity.column === column);
       if (!ownedDefault) {
         const desiredDefault = field.field.default;
         const actualDefault = stored?.field.default;
@@ -3903,10 +4306,10 @@ async function verifySchemaObjects(params) {
     }
     for (const [key, fk] of desired.fks) {
       const stored = live.fks.get(key);
-      pin(`foreignKeys.${fk.constraintName}`, { columns: fk.columns, refTable: fk.refTable, refColumns: fk.refColumns, onDelete: fk.onDelete, onUpdate: fk.onUpdate }, stored === undefined ? undefined : { columns: stored.columns, refTable: stored.refTable, refColumns: stored.refColumns, onDelete: stored.onDelete, onUpdate: stored.onUpdate });
+      pin(`foreignKeys.${fk.constraintName}`, { columns: fk.columns, refTable: fk.refTable, refNamespace: fk.refNamespace ?? namespace, refColumns: fk.refColumns, onDelete: fk.onDelete, onUpdate: fk.onUpdate }, stored === undefined ? undefined : { columns: stored.columns, refTable: stored.refTable, refNamespace: stored.refNamespace ?? namespace, refColumns: stored.refColumns, onDelete: stored.onDelete, onUpdate: stored.onUpdate });
       if (params.dialect === "postgres" && stored !== undefined) {
         const identity = { kind: "constraint", constraintType: "foreignKey", table, name: stored.constraintName };
-        if (params.expected.definitions.some((definition) => sqlObjectKey4({ identity: definition.identity }) === sqlObjectKey4({ identity })))
+        if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
           continue;
         const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (inspection.state !== "present") {
@@ -3922,7 +4325,7 @@ async function verifySchemaObjects(params) {
       if (params.dialect !== "postgres" || !live.indexes.has(key))
         continue;
       const identity = { kind: "index", table, name: live.indexes.get(key).name };
-      if (params.expected.definitions.some((definition) => sqlObjectKey4({ identity: definition.identity }) === sqlObjectKey4({ identity })))
+      if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
         continue;
       const inspection = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
       if (inspection.state !== "present") {
@@ -3935,7 +4338,7 @@ async function verifySchemaObjects(params) {
     objects.push({ identity: { kind: "table", name: table }, ownership: "schema", state: differences.length === 0 ? "matching" : "changed", differences });
     for (const [check, expression] of desired.checks) {
       const identity = { kind: "constraint", constraintType: "check", table, name: check };
-      if (params.expected.definitions.some((definition) => sqlObjectKey4({ identity: definition.identity }) === sqlObjectKey4({ identity })))
+      if (params.expected.definitions.some((definition) => sqlObjectKey5({ identity: definition.identity }) === sqlObjectKey5({ identity })))
         continue;
       const stored = live.checks.get(check);
       if (stored === undefined) {
@@ -3975,13 +4378,14 @@ async function verifySchemaObjects(params) {
   }
   for (const [name, join] of expected.joinTables) {
     const stored = actual.joinTables.get(name);
-    const shape = (value) => value === undefined ? undefined : { a: { table: value.a.table, column: value.a.column }, b: { table: value.b.table, column: value.b.column } };
+    const shape = (value) => value === undefined ? undefined : { a: { table: value.a.table, namespace: value.a.namespace ?? namespace, column: value.a.column }, b: { table: value.b.table, namespace: value.b.namespace ?? namespace, column: value.b.column } };
     const matching = canonicalMigrationJson({ value: shape(join) }) === canonicalMigrationJson({ value: shape(stored) });
-    objects.push({ identity: { kind: "table", name: { namespace, name } }, ownership: "schema", state: stored === undefined ? "missing" : matching ? "matching" : "changed", differences: matching ? [] : [{ attribute: "joinTable", expected: shape(join), actual: shape(stored) }] });
+    objects.push({ identity: { kind: "table", name: qualifiedSqlName8({ name: join.table, namespace: join.namespace, defaultNamespace: namespace }) }, ownership: "schema", state: stored === undefined ? "missing" : matching ? "matching" : "changed", differences: matching ? [] : [{ attribute: "joinTable", expected: shape(join), actual: shape(stored) }] });
   }
-  for (const [name] of expected.views) {
-    if (!params.expected.definitions.some((definition) => definition.identity.kind === "view" && definition.identity.name.namespace === namespace && definition.identity.name.name === name))
-      objects.push({ identity: { kind: "view", name: { namespace, name } }, ownership: "schema", state: actual.views.has(name) ? "unavailable" : "missing", reason: "independent-definition-required", differences: [] });
+  for (const [key, view] of expected.views) {
+    const name = qualifiedSqlName8({ name: view.dbName ?? view.name, namespace: view.namespace, defaultNamespace: namespace });
+    if (!params.expected.definitions.some((definition) => definition.identity.kind === "view" && definition.identity.name.namespace === name.namespace && definition.identity.name.name === name.name))
+      objects.push({ identity: { kind: "view", name }, ownership: "schema", state: actual.views.has(key) ? "unavailable" : "missing", reason: "independent-definition-required", differences: [] });
   }
   return objects;
 }
@@ -3990,16 +4394,25 @@ async function verifyMigrationTransition(params) {
 }
 async function verifySqliteTransitionBeforeRestore(params) {
   if (params.dialect !== "sqlite")
-    throw new VibeError15({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
+    throw new VibeError16({ code: "VIBE_INTERNAL", message: "SQLite rebuild verification requires the SQLite dialect" });
   await executeStatement({ executor: params.executor, dialect: "sqlite", statement: "PRAGMA foreign_key_check;" });
   return verifyTransition({ ...params, sqliteRestorePending: true });
 }
 async function verifyTransition(params) {
-  const report = await verifyState({ executor: params.executor, dialect: params.dialect, expected: params.to, ...params.sqliteRestorePending === true ? { sqliteRestorePending: true } : {}, ...params.probe === undefined ? {} : { probe: params.probe } });
+  const external = params.external;
+  if (external !== undefined) {
+    for (const identity of params.removals ?? []) {
+      const owner = externalObjectOwner({ identity, external });
+      if (owner !== undefined)
+        throw new VibeError16({ code: "VIBE_MIGRATION", message: "Transition removals cannot target externally owned objects", meta: { reason: "external-owned-removal", owner, identity } });
+    }
+    params = { ...params, from: projectExternalState({ state: params.from, external }), to: projectExternalState({ state: params.to, external }) };
+  }
+  const report = await verifyState({ executor: params.executor, dialect: params.dialect, expected: params.to, ...params.namespaces === undefined ? {} : { namespaces: params.namespaces }, ...external === undefined ? {} : { external }, ...params.sqliteRestorePending === true ? { sqliteRestorePending: true } : {}, ...params.probe === undefined ? {} : { probe: params.probe } });
   const namespace = await migrationNamespace(params);
   const identities = (state) => [...schemaObjectIdentities({ schema: state.schema, dialect: params.dialect, namespace }), ...(state.schema.migrationObjects ?? []).map((object) => object.identity), ...state.definitions.map((definition) => definition.identity)];
-  const retained = new Set(identities(params.to).map((identity) => sqlObjectKey4({ identity })));
-  const removed = new Map([...identities(params.from).filter((identity) => !retained.has(sqlObjectKey4({ identity }))), ...params.removals ?? []].map((identity) => [sqlObjectKey4({ identity }), identity]));
+  const retained = new Set(identities(params.to).map((identity) => sqlObjectKey5({ identity })));
+  const removed = new Map([...identities(params.from).filter((identity) => identity.kind !== "namespace" && !retained.has(sqlObjectKey5({ identity }))), ...params.removals ?? []].map((identity) => [sqlObjectKey5({ identity }), identity]));
   const objects = [...report.objects];
   for (const identity of removed.values()) {
     const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
@@ -4012,16 +4425,16 @@ async function verifyTransition(params) {
 async function migrationNamespace(params) {
   if (params.dialect !== "mysql")
     return params.dialect === "sqlite" ? "main" : "public";
-  const query = renderMigrationNamespace({ dialect: getSqlDialect({ dialect: params.dialect }) });
+  const query = renderMigrationNamespace({ dialect: getSqlDialect2({ dialect: params.dialect }) });
   const rows = await params.executor({ text: query.text, values: [] });
   const namespace = rows[0]?.namespace;
   if (typeof namespace !== "string" || namespace.length === 0)
-    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
+    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot determine the migration namespace", meta: { reason: "inspection-unavailable" } });
   return namespace;
 }
 function assertMigrationState(params) {
   if (!params.report.inSync)
-    throw new VibeError15({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", shadowReusable: true, objects: params.report.objects.filter((object) => object.state !== "matching") } });
+    throw new VibeError16({ code: "VIBE_MIGRATION", message: "Migration state could not be verified", meta: { reason: "migration-state-unverified", shadowReusable: true, objects: params.report.objects.filter((object) => object.state !== "matching") } });
 }
 async function deparsePostgresCheck(params) {
   const definition = await deparsePostgresCheckDefinition({ ...params, constraint: "vibeorm_check_probe" });
@@ -4031,11 +4444,11 @@ async function deparsePostgresCheckDefinition(params) {
   const name = "vibeorm_check_probe";
   await params.executor({ text: "SAVEPOINT vibeorm_check_probe" });
   try {
-    const query = renderCheckProbe({ dialect: getSqlDialect({ dialect: "postgres" }), table: params.table, expression: params.expression, name });
+    const query = renderCheckProbe({ dialect: getSqlDialect2({ dialect: "postgres" }), table: params.table, expression: params.expression, name });
     await params.executor({ text: query.text });
     const result = await inspectSqlObject({ executor: params.executor, dialect: "postgres", identity: { kind: "constraint", constraintType: "check", table: params.table, name } });
     if (result.state !== "present" || typeof result.definition.facts.definition !== "string")
-      throw new VibeError15({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: "CHECK normalization probe unavailable", meta: { reason: "check-inspection-unavailable" } });
     return { ...result.definition, identity: { kind: "constraint", constraintType: "check", table: params.table, name: params.constraint }, facts: { ...result.definition.facts, definition: result.definition.facts.definition.replace(/ NOT VALID$/, ""), validated: true } };
   } finally {
     await params.executor({ text: "ROLLBACK TO SAVEPOINT vibeorm_check_probe" });
@@ -4044,7 +4457,7 @@ async function deparsePostgresCheckDefinition(params) {
 }
 async function deparseMysqlCheck(params) {
   const probe = `vibe_check_${randomUUID2().replaceAll("-", "")}`;
-  const dialect = getSqlDialect({ dialect: "mysql" });
+  const dialect = getSqlDialect2({ dialect: "mysql" });
   const clone = renderMysqlCheckProbe({ dialect, probe, operation: "clone", table: params.table });
   await params.executor({ text: clone.text });
   let created = true;
@@ -4053,7 +4466,7 @@ async function deparseMysqlCheck(params) {
     const source = await params.executor({ text: read.text, values: [] });
     const definition = source[0]?.["Create Table"];
     if (typeof definition !== "string")
-      throw new VibeError15({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: "Cannot read temporary clone definition" });
     const drop = renderMysqlCheckProbe({ dialect, probe, operation: "drop" });
     await params.executor({ text: drop.text });
     created = false;
@@ -4064,7 +4477,7 @@ async function deparseMysqlCheck(params) {
     const normalizedDefinition = rows[0]?.["Create Table"];
     const check = typeof normalizedDefinition === "string" ? parseSqliteNamedChecks({ tableSql: normalizedDefinition }).find((entry) => entry.name === probe) : undefined;
     if (check === undefined)
-      throw new VibeError15({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL temporary CHECK deparse unavailable", meta: { reason: "check-inspection-unavailable" } });
     return check.expression;
   } finally {
     if (created) {
@@ -4078,7 +4491,7 @@ async function prepareCheckDiff(params) {
   const models = [];
   for (const model of params.from.models) {
     const table = model.dbName ?? model.name;
-    const target = params.to.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    const target = params.to.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect: params.dialect }) === physicalNameKey({ name: table, namespace: model.namespace, dialect: params.dialect }));
     const checks = [];
     for (const check of model.checks ?? []) {
       const next = target?.checks?.find((entry) => entry.name === check.name);
@@ -4086,12 +4499,12 @@ async function prepareCheckDiff(params) {
         checks.push({ name: check.name, expression: check.expression });
         continue;
       }
-      const identity = { kind: "constraint", constraintType: "check", table: { namespace: await migrationNamespace({ executor: params.executor, dialect: params.dialect }), name: table }, name: check.name };
+      const identity = { kind: "constraint", constraintType: "check", table: qualifiedSqlName8({ name: table, namespace: model.namespace, defaultNamespace: await migrationNamespace({ executor: params.executor, dialect: params.dialect }) }), name: check.name };
       if (params.dialect === "postgres" && params.probe === "rollback") {
         const desired = await deparsePostgresCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "rollback" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError15({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         if (live.definition.facts.definition === desired) {
           checks.push(next);
           continue;
@@ -4103,20 +4516,20 @@ async function prepareCheckDiff(params) {
         const desired = await deparseMysqlCheck({ executor: params.executor, table: identity.table, expression: next.expression, probe: "temporary" });
         const live = await inspectSqlObject({ executor: params.executor, dialect: params.dialect, identity });
         if (live.state !== "present")
-          throw new VibeError15({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
+          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Live CHECK inspection unavailable", meta: { reason: "check-inspection-unavailable", identity } });
         checks.push(desired === live.definition.facts.definition ? next : { name: check.name, expression: check.expression });
         continue;
       }
-      const previous = params.previous?.schema.models.find((entry) => (entry.dbName ?? entry.name) === table)?.checks?.find((entry) => entry.name === check.name);
+      const previous = params.previous?.schema.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect: params.dialect }) === physicalNameKey({ name: table, namespace: model.namespace, dialect: params.dialect }))?.checks?.find((entry) => entry.name === check.name);
       if (previous !== undefined) {
         checks.push(previous.expression === next.expression ? next : { name: check.name, expression: check.expression });
         continue;
       }
-      if (params.replaceChecks?.some((entry) => sqlObjectKey4({ identity: entry }) === sqlObjectKey4({ identity }))) {
+      if (params.replaceChecks?.some((entry) => sqlObjectKey5({ identity: entry }) === sqlObjectKey5({ identity }))) {
         checks.push({ name: check.name, expression: check.expression });
         continue;
       }
-      throw new VibeError15({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
+      throw new VibeError16({ code: "VIBE_MIGRATION", message: `Cannot establish CHECK equivalence for ${table}.${check.name}; request a rollback probe or an explicit replacement`, meta: { reason: "explicit-replacement-required", identity } });
     }
     models.push({ ...model, checks });
   }
@@ -4126,7 +4539,7 @@ async function prepareCheckDiff(params) {
 // packages/migrate/src/inventory.ts
 async function inspectMigrationInventory(params) {
   await assertCatalogVisibility(params);
-  const query = renderMigrationInventory({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace });
+  const query = renderMigrationInventory({ dialect: getSqlDialect3({ dialect: params.dialect }), namespace: params.namespace });
   const rows = await params.executor({ text: query.text, values: [...query.values] });
   const objects = [];
   const kinds = {
@@ -4143,14 +4556,18 @@ async function inspectMigrationInventory(params) {
   for (const row of rows) {
     const name = row.name;
     if (typeof name !== "string" || typeof row.kind !== "string")
-      throw new VibeError16({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
+      throw new VibeError17({ code: "VIBE_MIGRATION", message: "Malformed catalog identity", meta: { reason: "inventory-unavailable" } });
     const qualified = { namespace: params.namespace, name };
     const table = { namespace: params.namespace, name: String(row.parent ?? "") };
     let identity;
     switch (row.kind) {
+      case "namespace":
+        identity = { kind: "namespace", name };
+        break;
       case "table":
       case "view":
       case "sequence":
+      case "enum":
         identity = { kind: row.kind, name: qualified };
         break;
       case "trigger":
@@ -4165,27 +4582,27 @@ async function inspectMigrationInventory(params) {
       case "constraint": {
         const constraintType = kinds[String(row.subtype)];
         if (constraintType === undefined)
-          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Unknown constraint catalog kind", meta: { reason: "inventory-unavailable" } });
         identity = { kind: "constraint", table, name, constraintType };
         break;
       }
       case "function": {
         let argumentTypes = JSON.parse(String(row.signature));
         if (params.dialect === "mysql") {
-          const query = renderMysqlObjectMembers2({ dialect: getSqlDialect2({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
+          const query = renderMysqlObjectMembers2({ dialect: getSqlDialect3({ dialect: params.dialect }), identity: { kind: "function", name: qualified, argumentTypes: [] } });
           const members = await params.executor({ text: query.text, values: [...query.values] });
           if (members.length === 0)
-            throw new VibeError16({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
+            throw new VibeError17({ code: "VIBE_MIGRATION", message: "MySQL function signature unavailable", meta: { reason: "inventory-unavailable", name } });
           argumentTypes = members.filter((member) => member.mode !== null).map((member) => ({ namespace: "mysql", name: String(member.type) }));
         }
         const candidate = { kind: "function", name: qualified, argumentTypes };
         if (!isSqlObjectIdentity2(candidate))
-          throw new VibeError16({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
+          throw new VibeError17({ code: "VIBE_MIGRATION", message: "Invalid function signature in catalog", meta: { reason: "inventory-unavailable" } });
         identity = candidate;
         break;
       }
       default:
-        throw new VibeError16({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
+        throw new VibeError17({ code: "VIBE_MIGRATION", message: `Unknown catalog object kind ${row.kind}`, meta: { reason: "inventory-unavailable" } });
     }
     objects.push({ identity, ...typeof row.backing === "string" ? { backingConstraint: row.backing } : {} });
     if (params.dialect === "sqlite" && row.kind === "table" && typeof row.definition === "string" && !/^\s*CREATE\s+VIRTUAL\s+TABLE\b/i.test(row.definition)) {
@@ -4201,11 +4618,11 @@ async function inspectMigrationInventory(params) {
         objects.push({ identity: { kind: "constraint", constraintType: "check", table: qualified, name: check.name } });
       if ([...row.definition.matchAll(/\bCHECK\s*\(/gi)].length > checks.length)
         objects.push({ identity: { kind: "table", name: qualified }, inspectionUnavailable: "sqlite-unnamed-check-definition-unavailable" });
-      const query = renderSqliteColumnInventory2({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
+      const query = renderSqliteColumnInventory2({ dialect: getSqlDialect3({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const columns = await params.executor({ text: query.text, values: [...query.values] });
       if (columns.some((column) => Number(column.pk) > 0) && !clauses.some((clause) => clause.type === "primaryKey"))
         objects.push({ identity: { kind: "constraint", constraintType: "primaryKey", table: qualified, name: defaultPrimaryKeyName2({ table: qualified.name, dialect: "sqlite" }) } });
-      const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect2({ dialect: params.dialect }), namespace: params.namespace, table: name });
+      const fkQuery = renderSqliteForeignKeyInventory({ dialect: getSqlDialect3({ dialect: params.dialect }), namespace: params.namespace, table: name });
       const foreignKeys = await params.executor({ text: fkQuery.text, values: [...fkQuery.values] });
       const groups = new Map;
       for (const fk of foreignKeys)
@@ -4224,48 +4641,47 @@ async function inspectMigrationInventory(params) {
       }
     }
   }
-  return [...new Map(objects.map((object) => [sqlObjectKey5({ identity: object.identity }), object])).values()];
+  return [...new Map(objects.map((object) => [sqlObjectKey6({ identity: object.identity }), object])).values()];
 }
 
 // packages/migrate/src/module-ownership.ts
 function refusal(params) {
-  return new VibeError17({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
+  return new VibeError18({ code: "VIBE_MIGRATION", message: "Module ownership or dependencies cannot be reconciled with the declared and live schema; no package SQL was authorized", meta: params });
 }
 function identities(params) {
   return [...schemaObjectIdentities({ schema: params.state.schema, dialect: params.dialect, namespace: params.namespace }), ...(params.state.schema.migrationObjects ?? []).map((object) => object.identity), ...params.state.definitions.map((definition) => definition.identity)];
 }
 function moduleNamespace(params) {
-  if (params.origin.dialect !== "mysql")
-    return params.origin.dialect === "sqlite" ? "main" : "public";
-  const first = params.origin.owned[0];
-  if (first === undefined)
+  const namespaces = [...new Set(params.origin.owned.map((identity) => sqlObjectNamespace3({ identity })))];
+  if (namespaces.length > 1 || namespaces.length === 0 && params.origin.dialect === "mysql")
     throw refusal({ reason: "module-namespace-required", moduleId: params.origin.moduleId });
-  return "table" in first ? first.table.namespace : first.name.namespace;
+  return namespaces[0] ?? (params.origin.dialect === "sqlite" ? "main" : "public");
 }
 function moduleOwnedObjects(params) {
   const { desiredState } = params;
+  if (params.namespace === undefined && desiredState.dialect === "mysql")
+    throw refusal({ reason: "module-namespace-required" });
   const namespace = params.namespace ?? (desiredState.dialect === "sqlite" ? "main" : "public");
   const all = [desiredState.from, desiredState.to, ...desiredState.down === undefined ? [] : [desiredState.down]].flatMap((state) => identities({ state, dialect: desiredState.dialect, namespace }));
-  return [...new Map(all.map((identity) => [sqlObjectKey6({ identity }), identity])).values()].sort((a, b) => sqlObjectKey6({ identity: a }).localeCompare(sqlObjectKey6({ identity: b })));
+  return [...new Map(all.map((identity) => [sqlObjectKey7({ identity }), identity])).values()].sort((a, b) => sqlObjectKey7({ identity: a }).localeCompare(sqlObjectKey7({ identity: b })));
 }
 function assertModuleOwnership(params) {
   const { origin } = params;
   const state = origin.source.desiredState;
   const namespace = moduleNamespace({ origin });
   const expected = moduleOwnedObjects({ desiredState: state, namespace });
-  const owned = new Set(origin.owned.map((identity) => sqlObjectKey6({ identity })));
-  if (expected.length !== owned.size || expected.some((identity) => !owned.has(sqlObjectKey6({ identity }))))
+  const owned = new Set(origin.owned.map((identity) => sqlObjectKey7({ identity })));
+  if (expected.length !== owned.size || expected.some((identity) => !owned.has(sqlObjectKey7({ identity }))))
     throw refusal({ reason: "module-ownership-invalid", moduleId: origin.moduleId });
   for (const identity of expected) {
-    const name = "table" in identity ? identity.table : typeof identity.name === "object" ? identity.name : undefined;
-    if (name?.namespace !== namespace || name.name === "_vibe_migrations")
+    if (sqlObjectNamespace3({ identity }) !== namespace || ("table" in identity ? identity.table.name : typeof identity.name === "object" ? identity.name.name : undefined) === "_vibe_migrations")
       throw refusal({ reason: "module-ownership-invalid", moduleId: origin.moduleId, identity });
   }
   for (const target of [state.from, state.to, ...state.down === undefined ? [] : [state.down]]) {
     if (target.schema.rls !== undefined || target.schema.extensions.length > 0)
       throw refusal({ reason: "module-schema-unsupported", moduleId: origin.moduleId });
     for (const dependency of [...target.definitions.flatMap((definition) => definition.dependencies), ...(target.schema.migrationObjects ?? []).flatMap((object) => object.dependsOn), ...state.unmanagedRemovals ?? []]) {
-      if (!owned.has(sqlObjectKey6({ identity: dependency })))
+      if (!owned.has(sqlObjectKey7({ identity: dependency })))
         throw refusal({ reason: "module-external-dependency", moduleId: origin.moduleId, identity: dependency });
     }
   }
@@ -4273,28 +4689,29 @@ function assertModuleOwnership(params) {
     return;
   const local = params.desiredState;
   const rest = (actual, source) => {
-    const tables = new Set(source.schema.models.map((model) => model.dbName ?? model.name));
-    const enums = new Set(source.schema.enums.map((entry) => entry.dbName ?? entry.name));
-    const selected = actual.schema.models.filter((model) => tables.has(model.dbName ?? model.name));
-    const selectedEnums = actual.schema.enums.filter((entry) => enums.has(entry.dbName ?? entry.name));
+    const keyOf = (entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect: origin.dialect });
+    const tables = new Set(source.schema.models.map(keyOf));
+    const enums = new Set(source.schema.enums.map(keyOf));
+    const selected = actual.schema.models.filter((model) => tables.has(keyOf(model)));
+    const selectedEnums = actual.schema.enums.filter((entry) => enums.has(keyOf(entry)));
     if (canonicalMigrationJson({ value: selected }) !== canonicalMigrationJson({ value: source.schema.models }) || canonicalMigrationJson({ value: selectedEnums }) !== canonicalMigrationJson({ value: source.schema.enums }))
       throw refusal({ reason: "module-source-state-mismatch", moduleId: origin.moduleId });
-    const selectedObjects = (actual.schema.migrationObjects ?? []).filter((object) => owned.has(sqlObjectKey6({ identity: object.identity })));
-    const selectedDefinitions = actual.definitions.filter((definition) => owned.has(sqlObjectKey6({ identity: definition.identity })));
+    const selectedObjects = (actual.schema.migrationObjects ?? []).filter((object) => owned.has(sqlObjectKey7({ identity: object.identity })));
+    const selectedDefinitions = actual.definitions.filter((definition) => owned.has(sqlObjectKey7({ identity: definition.identity })));
     if (canonicalMigrationJson({ value: selectedObjects }) !== canonicalMigrationJson({ value: source.schema.migrationObjects ?? [] }) || canonicalMigrationJson({ value: selectedDefinitions }) !== canonicalMigrationJson({ value: source.definitions }))
       throw refusal({ reason: "module-source-state-mismatch", moduleId: origin.moduleId });
-    return { ...actual, schema: { ...actual.schema, models: actual.schema.models.filter((model) => !tables.has(model.dbName ?? model.name)), enums: actual.schema.enums.filter((entry) => !enums.has(entry.dbName ?? entry.name)), migrationObjects: (actual.schema.migrationObjects ?? []).filter((object) => !owned.has(sqlObjectKey6({ identity: object.identity }))) }, definitions: actual.definitions.filter((definition) => !owned.has(sqlObjectKey6({ identity: definition.identity }))) };
+    return { ...actual, schema: { ...actual.schema, models: actual.schema.models.filter((model) => !tables.has(keyOf(model))), enums: actual.schema.enums.filter((entry) => !enums.has(keyOf(entry))), migrationObjects: (actual.schema.migrationObjects ?? []).filter((object) => !owned.has(sqlObjectKey7({ identity: object.identity }))) }, definitions: actual.definitions.filter((definition) => !owned.has(sqlObjectKey7({ identity: definition.identity }))) };
   };
   const before = canonicalMigrationJson({ value: rest(local.from, state.from) });
   if (before !== canonicalMigrationJson({ value: rest(local.to, state.to) }) || before !== canonicalMigrationJson({ value: rest(local.down ?? local.from, state.down ?? state.from) }))
     throw refusal({ reason: "module-mutates-application-state", moduleId: origin.moduleId });
 }
 function dependencyUnavailable(params) {
-  return new VibeError17({ code: "VIBE_MIGRATION", message: "Cannot establish module foreign-key dependencies across namespaces. MySQL requires direct global SHOW VIEW (or SELECT) without partial revokes; SHOW VIEW exposes metadata without granting external row reads. Restore catalog visibility before retrying", meta: { reason: "module-dependency-unavailable", moduleId: params.origin.moduleId }, ...params.cause === undefined ? {} : { cause: params.cause } });
+  return new VibeError18({ code: "VIBE_MIGRATION", message: "Cannot establish module foreign-key dependencies across namespaces. MySQL requires direct global SHOW VIEW (or SELECT) without partial revokes; SHOW VIEW exposes metadata without granting external row reads. Restore catalog visibility before retrying", meta: { reason: "module-dependency-unavailable", moduleId: params.origin.moduleId }, ...params.cause === undefined ? {} : { cause: params.cause } });
 }
 async function assertCrossNamespaceModuleDependencies(params) {
   const { executor, origin } = params;
-  const dialect = getSqlDialect3({ dialect: origin.dialect });
+  const dialect = getSqlDialect4({ dialect: origin.dialect });
   const query = renderModuleDependencyQuery({ dialect, operation: { kind: "foreignKeys", namespace: params.namespace, tables: [...params.tables] } });
   if (query === undefined)
     return;
@@ -4321,15 +4738,15 @@ async function assertCrossNamespaceModuleDependencies(params) {
 async function assertLiveModuleOwnership(params) {
   const { executor, origin } = params;
   const namespace = moduleNamespace({ origin });
-  if (await migrationNamespace({ executor, dialect: origin.dialect }) !== namespace)
+  if (origin.dialect !== "postgres" && await migrationNamespace({ executor, dialect: origin.dialect }) !== namespace)
     throw refusal({ reason: "module-placement-mismatch", moduleId: origin.moduleId });
   const inventory = await inspectMigrationInventory({ executor, dialect: origin.dialect, namespace });
-  const before = new Set(identities({ state: origin.source.desiredState.from, dialect: origin.dialect, namespace }).map((identity) => sqlObjectKey6({ identity })));
-  const owned = new Set(origin.owned.map((identity) => sqlObjectKey6({ identity })));
+  const before = new Set(identities({ state: origin.source.desiredState.from, dialect: origin.dialect, namespace }).map((identity) => sqlObjectKey7({ identity })));
+  const owned = new Set(origin.owned.map((identity) => sqlObjectKey7({ identity })));
   const tables = new Set(origin.owned.flatMap((identity) => identity.kind === "table" ? [identity.name.name] : []));
   await assertCrossNamespaceModuleDependencies({ executor, origin, namespace, tables });
   for (const object of inventory) {
-    const key = sqlObjectKey6({ identity: object.identity });
+    const key = sqlObjectKey7({ identity: object.identity });
     if (params.resume !== true && owned.has(key) && !before.has(key))
       throw refusal({ reason: "module-object-collision", moduleId: origin.moduleId, identity: object.identity });
     if (!owned.has(key) && (["function", "view", "trigger"].includes(object.identity.kind) || ("table" in object.identity) && tables.has(object.identity.table.name) && object.backingConstraint === undefined))
@@ -4337,7 +4754,7 @@ async function assertLiveModuleOwnership(params) {
     if (object.inspectionUnavailable !== undefined && (owned.has(key) || ("table" in object.identity) && tables.has(object.identity.table.name)))
       throw refusal({ reason: "module-dependency-unavailable", moduleId: origin.moduleId, identity: object.identity });
   }
-  const physical = origin.dialect === "postgres" ? await introspectPhysicalPostgres({ executor }) : origin.dialect === "mysql" ? await introspectMysql({ executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor }) : await introspectSqlite({ executor });
+  const physical = origin.dialect === "postgres" ? await introspectPhysicalPostgres({ executor, namespaces: [namespace] }) : origin.dialect === "mysql" ? await introspectMysql({ executor }) : params.sqliteRestorePending === true ? await introspectSqliteBeforeForeignKeyRestore({ executor }) : await introspectSqlite({ executor });
   for (const model of physical.models)
     for (const relation of model.relations) {
       const target = physical.models.find((candidate) => candidate.name === relation.targetModel);
@@ -4352,12 +4769,51 @@ async function assertApplicationModuleState(params) {
     const options = { executor: params.executor, dialect: origin.dialect, from: state.from, to: state.to, removals: state.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } };
     const report = params.sqliteRestorePending === true ? await verifySqliteTransitionBeforeRestore(options) : await verifyMigrationTransition(options);
     if (!report.inSync)
-      throw new VibeError17({ code: "VIBE_MIGRATION", message: `Application SQL cannot change objects owned by module ${origin.moduleId}; use its reviewed module upgrade`, meta: { reason: "module-application-mutation", moduleId: origin.moduleId, report } });
+      throw new VibeError18({ code: "VIBE_MIGRATION", message: `Application SQL cannot change objects owned by module ${origin.moduleId}; use its reviewed module upgrade`, meta: { reason: "module-application-mutation", moduleId: origin.moduleId, report } });
   }
 }
 
+// packages/migrate/src/module-adoption.ts
+import { VibeError as VibeError19 } from "@vibeorm/schema";
+var MODULE_ADOPTION_METADATA = Object.freeze({ filename: "module-adoption.json", version: 1 });
+function invalid3() {
+  return new VibeError19({ code: "VIBE_MIGRATION", message: "Local module adoption proof is malformed or lacks immutable source provenance; restore the reviewed local history", meta: { reason: "module-adoption-invalid" } });
+}
+function assertMarker(params) {
+  const value = params.value;
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 3 || !("version" in value) || value.version !== 1 || !("reverse" in value) || value.reverse !== "refuse" || !("referenceFingerprint" in value) || typeof value.referenceFingerprint !== "string" || !/^[a-f0-9]{64}$/.test(value.referenceFingerprint))
+    throw invalid3();
+}
+function assertModuleAdoption(params) {
+  if (params.migration.moduleAdoption === undefined)
+    return;
+  assertMarker({ value: params.migration.moduleAdoption });
+  if (params.migration.moduleOrigin === undefined)
+    throw invalid3();
+  assertModuleOrigin({ value: params.migration.moduleOrigin });
+}
+function parseModuleAdoption(params) {
+  return parseMigrationMetadata({ text: params.text, failure: invalid3, parse: (value) => {
+    const checked = { value };
+    assertMarker(checked);
+    return Object.freeze(checked.value);
+  } });
+}
+function moduleAdoptionChecksumSuffix(params) {
+  if (params.moduleAdoption === undefined)
+    return "";
+  assertModuleAdoption({ migration: params });
+  return `
+-- vibeorm:module-adoption ${canonicalMigrationJson({ value: params.moduleAdoption })}`;
+}
+function serializeModuleAdoption(params) {
+  assertModuleAdoption(params);
+  return params.migration.moduleAdoption === undefined ? undefined : JSON.stringify(params.migration.moduleAdoption, null, 2) + `
+`;
+}
+
 // packages/migrate/src/sql-statements.ts
-import { VibeError as VibeError18 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } from "@vibeorm/schema";
 var COMPOUND_BODY_HEADER = /^(?:\s|--[^\n]*\n|\/\*[\s\S]*?\*\/)*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY)\s+)?(?:DEFINER\s*=\s*\S+\s+)?(?:TRIGGER|PROCEDURE|FUNCTION|EVENT)\b/i;
 var BLOCK_OPENERS = new Set(["BEGIN", "CASE", "IF", "LOOP", "WHILE", "REPEAT"]);
 function splitSqlStatements(params) {
@@ -4433,7 +4889,7 @@ function splitSqlStatements(params) {
             continue;
           }
           if (dialect === "mysql" || dialect === undefined) {
-            throw new VibeError18({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
+            throw new VibeError20({ code: "VIBE_MIGRATION", message: "SQL string backslash escaping depends on the session SQL mode; use mode-independent quoting and pass the migration dialect", meta: { reason: "sql-mode-ambiguous", dialect } });
           }
         }
         if (value === endQuote) {
@@ -4507,15 +4963,15 @@ function joinSqlStatements(params) {
 
 // packages/migrate/src/module-origin.ts
 import { createHash } from "crypto";
-import { VibeError as VibeError19, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey7 } from "@vibeorm/schema";
+import { VibeError as VibeError21, isSqlObjectIdentity as isSqlObjectIdentity3, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
 var MODULE_ORIGIN_METADATA = Object.freeze({ filename: "module-origin.json", version: 1 });
-function invalid2() {
-  return new VibeError19({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
+function invalid4() {
+  return new VibeError21({ code: "VIBE_MIGRATION", message: "Module migration origin is malformed or differs from its immutable package artifact; restore the reviewed artifact", meta: { reason: "module-origin-invalid" } });
 }
-function record2(value) {
+function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function identifier(value) {
+function identifier2(value) {
   return typeof value === "string" && value.trim().length > 0 && !value.includes("\x00");
 }
 function strings(value) {
@@ -4533,17 +4989,17 @@ function freezeData(params) {
 }
 function assertModuleOrigin(params) {
   const value = params.value;
-  if (!record2(value) || value.version !== 1 || !identifier(value.moduleId) || !identifier(value.revision) || !(value.previousRevision === null || identifier(value.previousRevision)) || value.previousRevision === value.revision || !["postgres", "sqlite", "mysql"].includes(String(value.dialect)) || !strings(value.contracts) || value.contracts.length === 0 || !value.contracts.every(identifier) || new Set(value.contracts).size !== value.contracts.length || !Array.isArray(value.owned) || !value.owned.every(isSqlObjectIdentity3) || !record2(value.source) || "moduleOrigin" in value.source || !identifier(value.source.name) || !strings(value.source.sql) || typeof value.source.destructive !== "boolean" || value.source.downSql !== undefined && !strings(value.source.downSql) || value.source.desiredState === undefined || value.source.desiredStatePending !== undefined || typeof value.artifactChecksum !== "string" || !/^[a-f0-9]{64}$/.test(value.artifactChecksum))
-    throw invalid2();
-  if (new Set(value.owned.map((identity) => sqlObjectKey7({ identity }))).size !== value.owned.length)
-    throw invalid2();
+  if (!record3(value) || value.version !== 1 || !identifier2(value.moduleId) || !identifier2(value.revision) || !(value.previousRevision === null || identifier2(value.previousRevision)) || value.previousRevision === value.revision || !["postgres", "sqlite", "mysql"].includes(String(value.dialect)) || !strings(value.contracts) || value.contracts.length === 0 || !value.contracts.every(identifier2) || new Set(value.contracts).size !== value.contracts.length || !Array.isArray(value.owned) || !value.owned.every(isSqlObjectIdentity3) || !record3(value.source) || "moduleOrigin" in value.source || "moduleAdoption" in value.source || !identifier2(value.source.name) || !strings(value.source.sql) || typeof value.source.destructive !== "boolean" || value.source.downSql !== undefined && !strings(value.source.downSql) || value.source.desiredState === undefined || value.source.desiredStatePending !== undefined || typeof value.artifactChecksum !== "string" || !/^[a-f0-9]{64}$/.test(value.artifactChecksum))
+    throw invalid4();
+  if (new Set(value.owned.map((identity) => sqlObjectKey8({ identity }))).size !== value.owned.length)
+    throw invalid4();
   const desired = { value: value.source.desiredState, migration: value.source.name };
   assertDesiredState(desired);
   if (desired.value.dialect !== value.dialect)
-    throw invalid2();
+    throw invalid4();
   const { artifactChecksum, ...payload } = value;
   if (checksum({ value: payload }) !== artifactChecksum)
-    throw invalid2();
+    throw invalid4();
   assertModuleOwnership({ origin: value });
 }
 function createModuleOrigin(params) {
@@ -4566,7 +5022,7 @@ function parseModuleOrigin(params) {
     const checked = { value };
     assertModuleOrigin(checked);
     return checked.value;
-  }, failure: invalid2 });
+  }, failure: invalid4 });
 }
 function assertMaterializedModuleMigration(params) {
   const { migration } = params;
@@ -4574,7 +5030,7 @@ function assertMaterializedModuleMigration(params) {
     return;
   const restored = restoreModuleMigration({ migration, origin: migration.moduleOrigin });
   if (migration.desiredState === undefined || canonicalMigrationJson({ value: restored }) !== canonicalMigrationJson({ value: migration }))
-    throw new VibeError19({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
+    throw new VibeError21({ code: "VIBE_MIGRATION", message: "Materialized module metadata differs from its immutable source", meta: { reason: "module-source-state-mismatch", moduleId: migration.moduleOrigin.moduleId } });
 }
 function restoreModuleMigration(params) {
   const { migration, origin } = params;
@@ -4585,25 +5041,27 @@ function restoreModuleMigration(params) {
       continue;
     const normalized = (sql) => sql.flatMap((text) => splitSqlStatements({ sql: text, dialect: origin.dialect }));
     if (canonicalMigrationJson({ value: normalized(actual) }) !== canonicalMigrationJson({ value: normalized(origin.source[key] ?? []) }))
-      throw invalid2();
+      throw invalid4();
   }
   for (const key of ["execution", "downExecution", "rls", "securityChanges", "downSecurityChanges"]) {
     if (migration[key] !== undefined && canonicalMigrationJson({ value: migration[key] }) !== canonicalMigrationJson({ value: origin.source[key] }))
-      throw invalid2();
+      throw invalid4();
   }
-  return { ...origin.source, name: migration.name, ...migration.desiredState === undefined ? {} : { desiredState: migration.desiredState }, moduleOrigin: origin };
+  const restored = { ...origin.source, name: migration.name, ...migration.desiredState === undefined ? {} : { desiredState: migration.desiredState }, moduleOrigin: origin, ...migration.moduleAdoption === undefined ? {} : { moduleAdoption: migration.moduleAdoption } };
+  assertModuleAdoption({ migration: restored });
+  return restored;
 }
 
 // packages/migrate/src/fs.ts
 import { readFile, readdir } from "fs/promises";
 import { join } from "path";
-import { VibeError as VibeError33, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
+import { VibeError as VibeError36, assertValidSchemaIR as assertValidSchemaIR4 } from "@vibeorm/schema";
 
 // packages/migrate/src/migration-checksum.ts
 import { createHash as createHash2 } from "crypto";
 
 // packages/migrate/src/execution.ts
-import { VibeError as VibeError20 } from "@vibeorm/schema";
+import { VibeError as VibeError22 } from "@vibeorm/schema";
 var EXECUTION_SIDECAR_FILENAME = "execution.json";
 var EXECUTION_SIDECAR_VERSION = 1;
 function isDefaultExecution(params) {
@@ -4641,8 +5099,8 @@ function executionChecksumSuffix(params) {
 ${lines.join(`
 `)}`;
 }
-function invalid3(params) {
-  return new VibeError20({
+function invalid5(params) {
+  return new VibeError22({
     code: "VIBE_MIGRATION",
     message: `invalid execution metadata for migration "${params.migration}": ${params.detail}`,
     meta: { reason: "execution-metadata-invalid", migration: params.migration }
@@ -4653,22 +5111,22 @@ function assertValidExecution(params) {
   if (execution === undefined)
     return;
   if (execution.transaction !== "default" && execution.transaction !== "none") {
-    throw invalid3({ migration, detail: `unknown transaction mode ${JSON.stringify(execution.transaction)}` });
+    throw invalid5({ migration, detail: `unknown transaction mode ${JSON.stringify(execution.transaction)}` });
   }
   for (const [label, value] of [["lockTimeoutMs", execution.lockTimeoutMs], ["statementTimeoutMs", execution.statementTimeoutMs]]) {
     if (value === undefined)
       continue;
     if (!Number.isSafeInteger(value) || value < 0) {
-      throw invalid3({ migration, detail: `${label} must be a non-negative integer number of milliseconds` });
+      throw invalid5({ migration, detail: `${label} must be a non-negative integer number of milliseconds` });
     }
   }
   const seen = new Set;
   for (const binding of execution.operations ?? []) {
     if (!Number.isSafeInteger(binding.statement) || binding.statement < 0 || binding.statement >= statements) {
-      throw invalid3({ migration, detail: `operation refers to statement ${String(binding.statement)}, which is outside the migration's ${String(statements)} statement(s)` });
+      throw invalid5({ migration, detail: `operation refers to statement ${String(binding.statement)}, which is outside the migration's ${String(statements)} statement(s)` });
     }
     if (seen.has(binding.statement)) {
-      throw invalid3({ migration, detail: `statement ${String(binding.statement)} carries more than one declared operation` });
+      throw invalid5({ migration, detail: `statement ${String(binding.statement)} carries more than one declared operation` });
     }
     seen.add(binding.statement);
   }
@@ -4693,7 +5151,7 @@ function parseExecutionSidecar(params) {
   try {
     parsed = JSON.parse(params.text);
   } catch (error) {
-    throw new VibeError20({
+    throw new VibeError22({
       code: "VIBE_MIGRATION",
       message: `invalid execution metadata for migration "${migration}": not valid JSON`,
       meta: { reason: "execution-metadata-invalid", migration },
@@ -4701,10 +5159,10 @@ function parseExecutionSidecar(params) {
     });
   }
   if (parsed === null || typeof parsed !== "object")
-    throw invalid3({ migration, detail: "expected a JSON object" });
+    throw invalid5({ migration, detail: "expected a JSON object" });
   const body = parsed;
   if (body.version !== EXECUTION_SIDECAR_VERSION) {
-    throw invalid3({ migration, detail: `unsupported sidecar version ${String(body.version)} (this build reads version ${String(EXECUTION_SIDECAR_VERSION)})` });
+    throw invalid5({ migration, detail: `unsupported sidecar version ${String(body.version)} (this build reads version ${String(EXECUTION_SIDECAR_VERSION)})` });
   }
   const up = body.up === undefined ? undefined : body.up;
   const down = body.down === undefined ? undefined : body.down;
@@ -4786,22 +5244,25 @@ function describeMigrationRisks(params) {
 function migrationChecksum(params) {
   const suffix = executionChecksumSuffix({ ...params.execution === undefined ? {} : { execution: params.execution } });
   return createHash2("sha256").update(params.sql.join(`
-`) + suffix + moduleOriginChecksumSuffix(params) + (params.desiredStatePending === true ? `
+`) + suffix + moduleOriginChecksumSuffix(params) + moduleAdoptionChecksumSuffix(params) + (params.desiredStatePending === true ? `
 -- vibeorm:desired-state unfinalized-v1` : "") + desiredStateChecksumSuffix({ ...params.desiredState === undefined ? {} : { desiredState: params.desiredState } }) + (params.desiredState === undefined ? "" : `
 -- vibeorm:down ${JSON.stringify(params.downSql ?? null)}${executionChecksumSuffix({ ...params.downExecution === undefined ? {} : { execution: params.downExecution } })}`)).digest("hex");
 }
 
 // packages/migrate/src/shadow-guard.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect4, renderShadowOperation } from "@vibeorm/sql";
+import { VibeError as VibeError23 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect5, renderShadowOperation } from "@vibeorm/sql";
 var replayExecutors = new WeakSet;
+function isShadowReplayExecutor(params) {
+  return replayExecutors.has(params.executor);
+}
 async function assertDatabaseNotShadow(params) {
   if (params.dialect === "sqlite" || replayExecutors.has(params.executor))
     return;
-  const [query] = renderShadowOperation({ dialect: getSqlDialect4({ dialect: params.dialect }), operation: { kind: "markerExists" } });
+  const [query] = renderShadowOperation({ dialect: getSqlDialect5({ dialect: params.dialect }), operation: { kind: "markerExists" } });
   const rows = await params.executor({ text: query.text, values: [...query.values] });
   if (rows.length !== 0)
-    throw new VibeError21({ code: "VIBE_MIGRATION", message: "This database is claimed as a disposable migration shadow. Application migrations must use the deployment target.", meta: { reason: "shadow-database-is-not-target" } });
+    throw new VibeError23({ code: "VIBE_MIGRATION", message: "This database is claimed as a disposable migration shadow. Application migrations must use the deployment target.", meta: { reason: "shadow-database-is-not-target" } });
 }
 function runShadowReplay(params) {
   replayExecutors.add(params.executor);
@@ -4810,10 +5271,95 @@ function runShadowReplay(params) {
   });
 }
 
+// packages/migrate/src/external-dependencies.ts
+import { VibeError as VibeError24, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect6, renderExternalDependents } from "@vibeorm/sql";
+function externalDependencyTargets(params) {
+  return params.steps.flatMap((step) => {
+    const namespace = step.namespace ?? params.namespace;
+    switch (step.kind) {
+      case "dropEnum":
+        return [{ kind: "type", namespace, name: step.enumName, dependency: { kind: "enum", name: { namespace, name: step.enumName } } }];
+      case "dropTable":
+      case "dropJoinTable":
+        return [{ kind: "relation", namespace, name: step.table, dependency: { kind: "table", name: { namespace, name: step.table } } }];
+      case "dropView":
+        return [{ kind: "relation", namespace, name: step.table, dependency: { kind: "view", name: { namespace, name: step.table } } }];
+      case "dropColumn":
+        return [{ kind: "column", namespace, name: step.table, column: step.column, dependency: { kind: "column", table: { namespace, name: step.table }, column: step.column } }];
+      case "alterColumn":
+        return step.changes.includes("type") ? [{ kind: "column", namespace, name: step.table, column: step.column, dependency: { kind: "column", table: { namespace, name: step.table }, column: step.column } }] : [];
+      default:
+        return [];
+    }
+  });
+}
+function unavailable() {
+  return new VibeError24({ code: "VIBE_MIGRATION", message: "Malformed catalog dependency row", meta: { reason: "external-inventory-unavailable" } });
+}
+function text(params) {
+  const value = params.row[params.key];
+  if (value === null || value === undefined)
+    return;
+  if (typeof value !== "string")
+    throw unavailable();
+  return value;
+}
+function dependentOwner(params) {
+  const { row, external } = params;
+  const relationNamespace = text({ row, key: "relationNamespace" });
+  const relationName = text({ row, key: "relationName" });
+  const relationKind = text({ row, key: "relationKind" });
+  const column = text({ row, key: "columnName" });
+  const dependentClass = text({ row, key: "dependentClass" });
+  const objectNamespace = text({ row, key: "objectNamespace" });
+  const objectName = text({ row, key: "objectName" });
+  if (relationNamespace !== undefined && relationName !== undefined) {
+    const name = { namespace: relationNamespace, name: relationName };
+    const anchor = relationKind === "r" || relationKind === "p" || relationKind === "f" ? { kind: "table", name } : relationKind === "v" || relationKind === "m" ? { kind: "view", name } : relationKind === "S" ? { kind: "sequence", name } : { kind: "namespace", name: relationNamespace };
+    const owner = externalObjectOwner({ identity: anchor, external });
+    const identity = anchor.kind === "table" && column !== undefined && dependentClass === "pg_attrdef" ? { kind: "columnDefault", table: name, column } : anchor.kind === "table" && column !== undefined ? { kind: "column", table: name, column } : anchor.kind === "namespace" ? undefined : anchor;
+    return { ...owner === undefined ? {} : { owner }, ...identity === undefined ? {} : { identity } };
+  }
+  const anchor = dependentClass === "pg_proc" && objectNamespace !== undefined && objectName !== undefined ? { kind: "function", name: { namespace: objectNamespace, name: objectName }, argumentTypes: [] } : objectNamespace === undefined ? undefined : { kind: "namespace", name: objectNamespace };
+  const owner = anchor === undefined ? undefined : externalObjectOwner({ identity: anchor, external });
+  return owner === undefined ? {} : { owner };
+}
+function assertNoExternalDependents(params) {
+  for (const row of params.rows) {
+    const target = typeof row.position === "number" ? params.targets[row.position] : undefined;
+    const type = text({ row, key: "dependentType" });
+    const identity = text({ row, key: "dependentIdentity" });
+    const referenced = text({ row, key: "referenced" });
+    if (target === undefined || type === undefined || identity === undefined || referenced === undefined)
+      throw unavailable();
+    const dependent = dependentOwner({ row, external: params.external });
+    if (dependent.owner === undefined)
+      continue;
+    throw new VibeError24({
+      code: "VIBE_MIGRATION",
+      message: "An externally owned object depends on an application object this change drops or retypes; automatic DDL is refused",
+      meta: { reason: "external-owned-dependency", owner: dependent.owner, ...dependent.identity === undefined ? {} : { identity: dependent.identity }, dependent: { type, identity }, dependency: target.dependency, referenced }
+    });
+  }
+}
+async function refuseExternalDependents(params) {
+  if (params.external.declarations.length === 0)
+    return;
+  if (params.dialect !== "postgres")
+    throw unsupportedCapability8({ dialect: params.dialect, feature: "externalObjects" });
+  const targets = externalDependencyTargets({ steps: params.steps, namespace: params.namespace });
+  if (targets.length === 0)
+    return;
+  const query = renderExternalDependents({ dialect: getSqlDialect6({ dialect: params.dialect }), targets: targets.map(({ dependency, ...target }) => target) });
+  const rows = await params.executor({ text: query.text, values: [...query.values] });
+  assertNoExternalDependents({ external: params.external, targets, rows });
+}
+
 // packages/migrate/src/module-history.ts
-import { VibeError as VibeError22, sqlObjectKey as sqlObjectKey8 } from "@vibeorm/schema";
+import { VibeError as VibeError25, sqlObjectKey as sqlObjectKey9, providerToDialect as providerToDialect3 } from "@vibeorm/schema";
 function refusal2(params) {
-  return new VibeError22({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
+  return new VibeError25({ code: "VIBE_MIGRATION", message: `Module ${params.moduleId} history, ownership or predecessor state is inconsistent; restore or complete the reviewed upgrade first`, meta: params });
 }
 function moduleHistoryHeads(params) {
   const heads = new Map;
@@ -4848,20 +5394,22 @@ function applicationModuleOrigins(params) {
   return origins;
 }
 function preserves(params) {
-  const tables = new Set(params.expected.schema.models.map((model) => model.dbName ?? model.name));
-  const enums = new Set(params.expected.schema.enums.map((entry) => entry.dbName ?? entry.name));
-  const models = params.actual.schema.models.filter((model) => tables.has(model.dbName ?? model.name));
-  const declaredEnums = params.actual.schema.enums.filter((entry) => enums.has(entry.dbName ?? entry.name));
+  const dialect = providerToDialect3({ provider: params.expected.schema.datasource.provider });
+  const keyOf = (entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect });
+  const tables = new Set(params.expected.schema.models.map(keyOf));
+  const enums = new Set(params.expected.schema.enums.map(keyOf));
+  const models = params.actual.schema.models.filter((model) => tables.has(keyOf(model)));
+  const declaredEnums = params.actual.schema.enums.filter((entry) => enums.has(keyOf(entry)));
   if (canonicalMigrationJson({ value: models }) !== canonicalMigrationJson({ value: params.expected.schema.models }) || canonicalMigrationJson({ value: declaredEnums }) !== canonicalMigrationJson({ value: params.expected.schema.enums }))
     throw refusal2({ reason: "module-application-mutation", moduleId: params.moduleId });
-  const objectKeys = new Set((params.expected.schema.migrationObjects ?? []).map((object) => sqlObjectKey8({ identity: object.identity })));
-  const definitionKeys = new Set(params.expected.definitions.map((definition) => sqlObjectKey8({ identity: definition.identity })));
-  if (canonicalMigrationJson({ value: (params.actual.schema.migrationObjects ?? []).filter((object) => objectKeys.has(sqlObjectKey8({ identity: object.identity }))) }) !== canonicalMigrationJson({ value: params.expected.schema.migrationObjects ?? [] }) || canonicalMigrationJson({ value: params.actual.definitions.filter((definition) => definitionKeys.has(sqlObjectKey8({ identity: definition.identity }))) }) !== canonicalMigrationJson({ value: params.expected.definitions }))
+  const objectKeys = new Set((params.expected.schema.migrationObjects ?? []).map((object) => sqlObjectKey9({ identity: object.identity })));
+  const definitionKeys = new Set(params.expected.definitions.map((definition) => sqlObjectKey9({ identity: definition.identity })));
+  if (canonicalMigrationJson({ value: (params.actual.schema.migrationObjects ?? []).filter((object) => objectKeys.has(sqlObjectKey9({ identity: object.identity }))) }) !== canonicalMigrationJson({ value: params.expected.schema.migrationObjects ?? [] }) || canonicalMigrationJson({ value: params.actual.definitions.filter((definition) => definitionKeys.has(sqlObjectKey9({ identity: definition.identity }))) }) !== canonicalMigrationJson({ value: params.expected.definitions }))
     throw refusal2({ reason: "module-application-mutation", moduleId: params.moduleId });
   for (const model of params.actual.schema.models)
     for (const relation of model.relations) {
       const target = params.actual.schema.models.find((candidate) => candidate.name === relation.targetModel);
-      if (target !== undefined && tables.has(model.dbName ?? model.name) !== tables.has(target.dbName ?? target.name))
+      if (target !== undefined && tables.has(keyOf(model)) !== tables.has(keyOf(target)))
         throw refusal2({ reason: "module-external-dependency", moduleId: params.moduleId });
     }
 }
@@ -4871,7 +5419,7 @@ function assertModuleUpgradeHistory(params) {
   const register = (migration) => {
     const origin = migration.moduleOrigin;
     for (const identity of origin.owned) {
-      const key = sqlObjectKey8({ identity });
+      const key = sqlObjectKey9({ identity });
       if (owners.has(key) && owners.get(key) !== origin.moduleId)
         throw refusal2({ reason: "module-object-collision", moduleId: origin.moduleId });
       owners.set(key, origin.moduleId);
@@ -4918,11 +5466,11 @@ function assertModuleUpgradeHistory(params) {
 }
 
 // packages/migrate/src/module-journal.ts
-import { VibeError as VibeError24 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect5, MODULE_JOURNAL_COLUMN, renderModuleJournal } from "@vibeorm/sql";
+import { VibeError as VibeError27 } from "@vibeorm/schema";
+import { getSqlDialect as getSqlDialect7, MODULE_JOURNAL_COLUMN, renderModuleJournal } from "@vibeorm/sql";
 
 // packages/migrate/src/journal-read.ts
-import { VibeError as VibeError23 } from "@vibeorm/schema";
+import { VibeError as VibeError26 } from "@vibeorm/schema";
 var MISSING_TABLE_IDENTIFIERS = new Set(["42P01", "42S02", "ER_NO_SUCH_TABLE"]);
 function isMissingTable(params) {
   let current = params.cause;
@@ -4946,7 +5494,7 @@ async function readJournalRows(params) {
       if (presence.state === "missing")
         return;
     }
-    throw new VibeError23({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
+    throw new VibeError26({ code: "VIBE_MIGRATION", message: "Cannot inspect migration history; check SELECT privileges", meta: { reason: "history-unavailable" }, cause });
   });
   if (rows === undefined)
     return;
@@ -4954,7 +5502,7 @@ async function readJournalRows(params) {
   for (const row of rows) {
     const index = row.statement_index;
     if (typeof row.name !== "string" || typeof row.checksum !== "string" || typeof index !== "number" && typeof index !== "string" || typeof index === "string" && !/^-?\d+$/.test(index) || !Number.isSafeInteger(Number(index)) || row.module_origin !== null && row.module_origin !== undefined && typeof row.module_origin !== "string" || row.error !== null && row.error !== undefined && typeof row.error !== "string" || result.has(row.name)) {
-      throw new VibeError23({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
+      throw new VibeError26({ code: "VIBE_MIGRATION", message: "Malformed migration journal row", meta: { reason: "history-unavailable" } });
     }
     result.set(row.name, { checksum: row.checksum, statementIndex: Number(index), ...typeof row.error === "string" ? { error: row.error } : {}, ...typeof row.module_origin === "string" ? { moduleEntry: row.module_origin } : {} });
   }
@@ -4962,41 +5510,41 @@ async function readJournalRows(params) {
 }
 
 // packages/migrate/src/module-journal.ts
-function invalid4() {
-  return new VibeError24({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
+function invalid6() {
+  return new VibeError27({ code: "VIBE_MIGRATION", message: "Module migration history is missing, altered or inconsistent; restore the reviewed history before using this module", meta: { reason: "module-history-invalid" } });
 }
 function parseModuleJournalEntry(params) {
-  return parseMigrationMetadata({ text: params.text, failure: invalid4, parse: (value) => {
+  return parseMigrationMetadata({ text: params.text, failure: invalid6, parse: (value) => {
     if (value === null || typeof value !== "object" || !("version" in value) || value.version !== 1 || !("complete" in value) || typeof value.complete !== "boolean" || !("migration" in value) || value.migration === null || typeof value.migration !== "object")
-      throw invalid4();
+      throw invalid6();
     const migration = value.migration;
     assertModuleOrigin({ value: migration.moduleOrigin });
     if (migration.name !== params.name || migrationChecksum(migration) !== params.checksum)
-      throw invalid4();
+      throw invalid6();
     assertMaterializedModuleMigration({ migration });
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
     return { version: 1, complete: value.complete, migration };
   } });
 }
 async function readModuleJournal(params) {
-  const query = renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: { kind: "read" } });
+  const query = renderModuleJournal({ dialect: getSqlDialect7({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: { kind: "read" } });
   const rows = await readJournalRows({ ...params, query });
   return new Map([...rows ?? []].map(([name, row]) => {
     const entry = row.moduleEntry === undefined ? undefined : parseModuleJournalEntry({ text: row.moduleEntry, name, checksum: row.checksum });
     if (entry !== undefined && entry.migration.moduleOrigin.dialect !== params.dialect)
-      throw invalid4();
+      throw invalid6();
     return [name, { row, ...entry === undefined ? {} : { entry } }];
   }));
 }
 async function ensureModuleJournal(params) {
-  const dialect = getSqlDialect5({ dialect: params.dialect });
+  const dialect = getSqlDialect7({ dialect: params.dialect });
   const columns = await params.executor(renderModuleJournal({ dialect, table: MIGRATIONS_TABLE_NAME, operation: { kind: "columns" } }));
   if (columns.some((row) => row.name === MODULE_JOURNAL_COLUMN))
     return;
   await params.executor(renderModuleJournal({ dialect, table: MIGRATIONS_TABLE_NAME, operation: { kind: "addColumn" } }));
 }
 async function insertModuleJournal(params) {
-  await params.executor(renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
+  await params.executor(renderModuleJournal({ dialect: getSqlDialect7({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
     kind: "insert",
     name: params.migration.name,
     checksum: migrationChecksum(params.migration),
@@ -5005,7 +5553,7 @@ async function insertModuleJournal(params) {
   } }));
 }
 async function completeModuleJournal(params) {
-  await params.executor(renderModuleJournal({ dialect: getSqlDialect5({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
+  await params.executor(renderModuleJournal({ dialect: getSqlDialect7({ dialect: params.dialect }), table: MIGRATIONS_TABLE_NAME, operation: {
     kind: "complete",
     name: params.migration.name,
     entry: canonicalMigrationJson({ value: { version: 1, migration: params.migration, complete: true } })
@@ -5014,27 +5562,27 @@ async function completeModuleJournal(params) {
 function moduleRecordComplete(params) {
   const { migration, stored } = params;
   if (stored.moduleEntry === undefined || stored.checksum === "")
-    throw invalid4();
+    throw invalid6();
   const entry = parseModuleJournalEntry({ text: stored.moduleEntry, name: migration.name, checksum: stored.checksum });
   if (migrationChecksum(migration) !== stored.checksum)
-    throw invalid4();
+    throw invalid6();
   return entry.complete && stored.error === undefined && stored.statementIndex === migration.sql.length;
 }
 
 // packages/migrate/src/runner.ts
-import { VibeError as VibeError32 } from "@vibeorm/schema";
+import { VibeError as VibeError35 } from "@vibeorm/schema";
 import {
   DIALECT_CAPABILITIES as DIALECT_CAPABILITIES3,
-  getSqlDialect as getSqlDialect7,
+  getSqlDialect as getSqlDialect9,
   renderMigrationSessionRead,
   renderMigrationSessionRestore,
   renderMigrationSessionSet
 } from "@vibeorm/sql";
 
 // packages/migrate/src/recovery.ts
-import { VibeError as VibeError25 } from "@vibeorm/schema";
+import { VibeError as VibeError28 } from "@vibeorm/schema";
 import {
-  getSqlDialect as getSqlDialect6,
+  getSqlDialect as getSqlDialect8,
   renderColumnStateQuery,
   renderConstraintStateQuery,
   renderIndexStateQuery,
@@ -5048,7 +5596,7 @@ function constraintUnverifiable(params) {
   });
 }
 function conflict2(params) {
-  return new VibeError25({
+  return new VibeError28({
     code: "VIBE_MIGRATION",
     message: params.message,
     meta: { reason: params.reason, ...params.meta }
@@ -5073,7 +5621,7 @@ function sameShape(params) {
 }
 async function establishOperationState(params) {
   const { executor, operation } = params;
-  const dialect = getSqlDialect6({ dialect: params.dialect });
+  const dialect = getSqlDialect8({ dialect: params.dialect });
   const run = async (query) => executor({ text: query.text, values: [...query.values] });
   switch (operation.kind) {
     case "createIndexConcurrently": {
@@ -5152,11 +5700,11 @@ async function establishOperationState(params) {
 }
 
 // packages/migrate/src/differ.ts
-import { isEnumType as isEnumType6, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
-import { VibeError as VibeError27 } from "@vibeorm/schema";
+import { assertIndexOperatorClasses as assertIndexOperatorClasses2, isEnumType as isEnumType6, qualifiedSqlName as qualifiedSqlName9, unsupportedCapability as unsupportedCapability10 } from "@vibeorm/schema";
+import { VibeError as VibeError30 } from "@vibeorm/schema";
 
 // packages/migrate/src/renames.ts
-import { VibeError as VibeError26 } from "@vibeorm/schema";
+import { VibeError as VibeError29, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 function tableOf(model) {
   return model.dbName ?? model.name;
 }
@@ -5167,7 +5715,7 @@ function hasColumn(params) {
   return params.model.fields.some((field) => (field.dbName ?? field.name) === params.column);
 }
 function ambiguous(params) {
-  return new VibeError26({
+  return new VibeError29({
     code: "VIBE_MIGRATION",
     message: `rename refused: ${params.detail}`,
     meta: { reason: "rename-ambiguous", ...params.meta }
@@ -5177,6 +5725,8 @@ function planRenames(params) {
   const { to, dialect } = params;
   if (params.renames.length === 0)
     return { steps: [], from: params.from };
+  if ([params.from, params.to].some((schema) => schema.models.some((model) => model.namespace !== undefined && model.namespace !== "public" && params.renames.some((intent) => intent.kind === "table" ? [intent.from, intent.to].includes(tableOf(model)) : intent.table === tableOf(model)))))
+    throw unsupportedCapability9({ dialect, feature: "qualifiedRenameIntent", hint: "Use reviewed namespace-qualified SQL for a physical rename in a fixed namespace" });
   const renamedTables = new Map;
   const renamedColumns = new Map;
   const steps = [];
@@ -5268,9 +5818,19 @@ function planRenames(params) {
 // packages/migrate/src/differ.ts
 function diffSchemas(params) {
   const dialect = params.dialect ?? "postgres";
+  assertIndexOperatorClasses2({ schema: params.to, dialect });
+  for (const kind of ["models", "enums"])
+    for (const entry of params.to[kind]) {
+      const key = physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect });
+      const before = params.from[kind].find((candidate) => candidate.name === entry.name) ?? params.from[kind].find((candidate) => (candidate.dbName ?? candidate.name) === (entry.dbName ?? entry.name) && !params.to[kind].some((target) => physicalNameKey({ name: target.dbName ?? target.name, namespace: target.namespace, dialect }) === physicalNameKey({ name: candidate.dbName ?? candidate.name, namespace: candidate.namespace, dialect })));
+      if (before !== undefined && qualifiedSqlName9({ name: entry.name, namespace: before.namespace }).namespace !== qualifiedSqlName9({ name: entry.name, namespace: entry.namespace }).namespace && !params.from[kind].some((candidate) => physicalNameKey({ name: candidate.dbName ?? candidate.name, namespace: candidate.namespace, dialect }) === key))
+        throw unsupportedCapability10({ dialect, feature: "automaticNamespaceMove", hint: "Moving populated objects to a fixed namespace requires an explicit reviewed migration" });
+    }
+  for (const schema of [params.from, params.to])
+    normalizeSchema({ schema, dialect });
   for (const schema of [params.from, params.to])
     if (dialect !== "postgres" && schema.models.some((model) => (model.exclusions?.length ?? 0) > 0))
-      throw unsupportedCapability6({ dialect, feature: "exclusionConstraints" });
+      throw unsupportedCapability10({ dialect, feature: "exclusionConstraints" });
   assertRlsDialect({ schema: params.from, dialect });
   assertRlsDialect({ schema: params.to, dialect });
   if (dialect !== "postgres")
@@ -5280,6 +5840,7 @@ function diffSchemas(params) {
   const from = normalizeSchema({ schema: params.from, dialect });
   const to = normalizeSchema({ schema: params.to, dialect });
   const buckets = {
+    createNamespace: dialect === "postgres" ? schemaNamespaces({ schema: params.to }).filter((namespace) => !schemaNamespaces({ schema: params.from }).includes(namespace)).map((namespace) => ({ kind: "createNamespace", namespace, destructive: false })) : [],
     dropExclusion: [],
     addExclusion: [],
     dropView: [],
@@ -5309,16 +5870,17 @@ function diffSchemas(params) {
   diffTables({ from, to, buckets, dialect });
   for (const model of params.to.models) {
     const table = model.dbName ?? model.name;
-    const previous = params.from.models.find((entry) => (entry.dbName ?? entry.name) === table);
+    const placement = model.namespace === undefined ? {} : { namespace: model.namespace };
+    const previous = params.from.models.find((entry) => physicalNameKey({ name: entry.dbName ?? entry.name, namespace: entry.namespace, dialect }) === physicalNameKey({ name: table, namespace: model.namespace, dialect }));
     for (const exclusion of model.exclusions ?? []) {
       const before = previous?.exclusions?.find((entry) => entry.name === exclusion.name);
       if (before?.definition === exclusion.definition)
         continue;
       if (before?.catalogDefinition)
-        throw new VibeError27({ code: "VIBE_MIGRATION", message: "Exclusion comparison requires normalized evidence", meta: { reason: "exclusion-inspection-unavailable", table, name: exclusion.name } });
+        throw new VibeError30({ code: "VIBE_MIGRATION", message: "Exclusion comparison requires normalized evidence", meta: { reason: "exclusion-inspection-unavailable", table, name: exclusion.name } });
       if (before !== undefined)
-        buckets.dropExclusion.push({ kind: "dropExclusion", table, exclusion: before, destructive: false });
-      buckets.addExclusion.push({ kind: "addExclusion", table, exclusion, destructive: false });
+        buckets.dropExclusion.push({ kind: "dropExclusion", table, ...placement, exclusion: before, destructive: false });
+      buckets.addExclusion.push({ kind: "addExclusion", table, ...placement, exclusion, destructive: false });
     }
     for (const exclusion of previous?.exclusions ?? [])
       if (!model.exclusions?.some((entry) => entry.name === exclusion.name))
@@ -5326,6 +5888,7 @@ function diffSchemas(params) {
   }
   refuseDependentEnumStorageChanges({ from, to, buckets, dialect });
   return withRlsSteps({ from: params.from, to: params.to, steps: [
+    ...buckets.createNamespace,
     ...renamed.steps,
     ...buckets.dropView,
     ...buckets.createEnum,
@@ -5358,7 +5921,7 @@ function refuseScalarListColumns(params) {
     for (const field of model.fields) {
       if (!field.isList || field.isUnsupported === true)
         continue;
-      throw unsupportedCapability6({
+      throw unsupportedCapability10({
         dialect,
         feature: `scalar list column "${model.name}.${field.name}"`,
         hint: `${dialect} has no array column type \u2014 model the list as a separate table or a ${dialect === "mysql" ? "JSON" : "Json"} column`
@@ -5378,12 +5941,12 @@ function diffEnums(params) {
     const currentValues = new Set(enumDef.values);
     for (const value of enumDef.values) {
       if (!previousValues.has(value)) {
-        buckets.addEnumValue.push({ kind: "addEnumValue", enumName: name, value, destructive: false });
+        buckets.addEnumValue.push({ kind: "addEnumValue", enumName: enumDef.dbName ?? enumDef.name, ...enumDef.namespace === undefined ? {} : { namespace: enumDef.namespace }, value, destructive: false });
       }
     }
     for (const value of previous.values) {
       if (!currentValues.has(value)) {
-        throw unsupportedCapability6({
+        throw unsupportedCapability10({
           dialect: "postgres",
           feature: `removing value "${value}" from enum "${name}"`,
           hint: "postgres cannot drop enum values \u2014 recreate the type manually (create new type, ALTER COLUMN ... USING, drop old type)"
@@ -5391,9 +5954,9 @@ function diffEnums(params) {
       }
     }
   }
-  for (const [name] of from.enums) {
+  for (const [name, enumDef] of from.enums) {
     if (!to.enums.has(name)) {
-      buckets.dropEnum.push({ kind: "dropEnum", enumName: name, destructive: true });
+      buckets.dropEnum.push({ kind: "dropEnum", enumName: enumDef.dbName ?? enumDef.name, ...enumDef.namespace === undefined ? {} : { namespace: enumDef.namespace }, destructive: true });
     }
   }
 }
@@ -5403,10 +5966,10 @@ function refuseDependentEnumStorageChanges(params) {
     if (step.kind !== "alterColumn" || !isEnumStringTransition({ from: step.from, to: step.to }))
       continue;
     for (const normalized of [from, to]) {
-      const hasFk = [...normalized.tables.values()].some((table) => [...table.fks.values()].some((fk) => table.table === step.table && fk.columns.includes(step.column) || fk.refTable === step.table && fk.refColumns.includes(step.column)));
-      const hasJoin = [...normalized.joinTables.values()].some((join) => [join.a, join.b].some((end) => end.table === step.table && end.column === step.column));
+      const hasFk = [...normalized.tables.values()].some((table) => [...table.fks.values()].some((fk) => table.table === step.table && (table.namespace ?? "public") === (step.namespace ?? "public") && fk.columns.includes(step.column) || fk.refTable === step.table && (fk.refNamespace ?? "public") === (step.namespace ?? "public") && fk.refColumns.includes(step.column)));
+      const hasJoin = [...normalized.joinTables.values()].some((join) => [join.a, join.b].some((end) => end.table === step.table && (end.namespace ?? "public") === (step.namespace ?? "public") && end.column === step.column));
       if (hasFk || hasJoin) {
-        throw unsupportedCapability6({
+        throw unsupportedCapability10({
           dialect,
           feature: `enum storage conversion on "${step.table}"."${step.column}" with foreign-key dependencies`,
           hint: "migrate the referencing columns and constraints together in a reviewed manual migration"
@@ -5417,28 +5980,31 @@ function refuseDependentEnumStorageChanges(params) {
 }
 function diffViews(params) {
   const { from, to, buckets } = params;
-  for (const [name] of from.views) {
+  for (const [name, view] of from.views) {
     if (!to.views.has(name)) {
-      buckets.dropView.push({ kind: "dropView", table: name, destructive: true });
+      buckets.dropView.push({ kind: "dropView", table: view.dbName ?? view.name, ...view.namespace === undefined ? {} : { namespace: view.namespace }, destructive: true });
     }
   }
 }
 function diffJoinTables(params) {
   const { from, to, buckets } = params;
-  for (const [table, joinTable] of to.joinTables) {
-    if (!from.joinTables.has(table)) {
+  for (const [key, joinTable] of to.joinTables) {
+    if (!from.joinTables.has(key)) {
+      const table = joinTable.table;
+      const placement = joinTable.namespace === undefined ? {} : { namespace: joinTable.namespace };
       buckets.createJoinTable.push({
         kind: "createJoinTable",
         table,
+        ...placement,
         a: joinTable.a,
         b: joinTable.b,
         destructive: false
       });
     }
   }
-  for (const [table] of from.joinTables) {
-    if (!to.joinTables.has(table)) {
-      buckets.dropJoinTable.push({ kind: "dropJoinTable", table, destructive: true });
+  for (const [key, joinTable] of from.joinTables) {
+    if (!to.joinTables.has(key)) {
+      buckets.dropJoinTable.push({ kind: "dropJoinTable", table: joinTable.table, ...joinTable.namespace === undefined ? {} : { namespace: joinTable.namespace }, destructive: true });
     }
   }
 }
@@ -5463,9 +6029,9 @@ function diffTables(params) {
       continue;
     if (dialect !== "sqlite")
       for (const fk of table.fks.values()) {
-        buckets.dropForeignKey.push({ kind: "dropForeignKey", table: name, constraintName: fk.constraintName, destructive: false });
+        buckets.dropForeignKey.push({ kind: "dropForeignKey", table: table.table, ...table.namespace === undefined ? {} : { namespace: table.namespace }, constraintName: fk.constraintName, destructive: false });
       }
-    buckets.dropTable.push({ kind: "dropTable", table: name, destructive: true });
+    buckets.dropTable.push({ kind: "dropTable", table: table.table, ...table.namespace === undefined ? {} : { namespace: table.namespace }, destructive: true });
   }
 }
 function createWholeTable(params) {
@@ -5473,6 +6039,7 @@ function createWholeTable(params) {
   buckets.createTable.push({
     kind: "createTable",
     table: table.table,
+    ...table.namespace === undefined ? {} : { namespace: table.namespace },
     columns: [...table.columns.values()].map((column) => column.field),
     primaryKey: table.pk,
     ...table.model.primaryKeyConstraintName === undefined ? {} : { primaryKeyConstraintName: table.model.primaryKeyConstraintName },
@@ -5483,6 +6050,7 @@ function createWholeTable(params) {
     buckets.createIndex.push({
       kind: "createIndex",
       table: table.table,
+      ...table.namespace === undefined ? {} : { namespace: table.namespace },
       name: index.name,
       indexKind: index.kind,
       unique: index.unique,
@@ -5496,6 +6064,7 @@ function createWholeTable(params) {
     buckets.addForeignKey.push({
       kind: "addForeignKey",
       table: table.table,
+      ...table.namespace === undefined ? {} : { namespace: table.namespace },
       constraintName: fk.constraintName,
       columns: fk.columns,
       refTable: fk.refTable,
@@ -5509,14 +6078,15 @@ function createWholeTable(params) {
 function diffOneTable(params) {
   const { previous, current, buckets, dialect, fromEnums, toEnums } = params;
   const table = current.table;
+  const placement = current.namespace === undefined ? {} : { namespace: current.namespace };
   for (const [name, column] of current.columns) {
     const before = previous.columns.get(name);
     if (before === undefined) {
-      buckets.addColumn.push({ kind: "addColumn", table, column: column.field, destructive: false });
+      buckets.addColumn.push({ kind: "addColumn", table, ...placement, column: column.field, destructive: false });
       continue;
     }
     const changes = [];
-    if (before.typeKey !== column.typeKey)
+    if (columnTypeChanged({ declared: column, actual: before }))
       changes.push("type");
     if (before.nullable !== column.nullable)
       changes.push("nullability");
@@ -5528,25 +6098,25 @@ function diffOneTable(params) {
     if (changes.length === 0)
       continue;
     if (changes.includes("type") && [...previous.checks].some(([name, expression]) => current.checks.get(name) === expression)) {
-      throw unsupportedCapability6({ dialect, feature: "alterColumnWithRetainedCheck", hint: "CHECK dependencies and type compatibility are not proven; use a reviewed migration that replaces and revalidates the affected constraints" });
+      throw unsupportedCapability10({ dialect, feature: "alterColumnWithRetainedCheck", hint: "CHECK dependencies and type compatibility are not proven; use a reviewed migration that replaces and revalidates the affected constraints" });
     }
     const storageChange = isEnumStringTransition({ from: before.field, to: column.field });
     if (storageChange) {
       assertEnumStringTransition({ from: before.field, to: column.field, dialect, table, column: name });
       if (isEnumType6(before.field.type) && column.field.type === "String") {
-        const values = resolveEnumValues({ name: before.field.type.enum, enums: fromEnums });
+        const values = resolveEnumValues({ name: before.field.type.enum, namespace: before.field.type.namespace, enums: fromEnums });
         if (values !== undefined)
           assertStringEnumLabelsFit({ field: column.field, values, dialect, table });
       }
     }
-    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(storageChange && column.field.type === "String");
+    let narrowingType = changes.includes("type") && !isScalarToArrayChange({ from: before.field, to: column.field }) && !(dialect === "postgres" && isTimestamptzPrecisionWidening({ from: before.field, to: column.field })) && !(storageChange && column.field.type === "String");
     if (dialect !== "postgres" && changes.includes("type") && isEnumType6(before.field.type) && isEnumType6(column.field.type)) {
       const fromValues = resolveEnumValues({ name: before.field.type.enum, enums: fromEnums });
       const toValues = resolveEnumValues({ name: column.field.type.enum, enums: toEnums });
       if (fromValues !== undefined && toValues !== undefined) {
         const removed = fromValues.filter((value) => !toValues.includes(value));
         if (removed.length > 0) {
-          throw unsupportedCapability6({
+          throw unsupportedCapability10({
             dialect,
             feature: `removing value(s) ${removed.map((value) => `"${value}"`).join(", ")} from enum column "${table}"."${name}"`,
             hint: "migrate the stored values away first, then recreate the column with the narrower enum"
@@ -5558,6 +6128,7 @@ function diffOneTable(params) {
     buckets.alterColumn.push({
       kind: "alterColumn",
       table,
+      ...placement,
       column: name,
       from: before.field,
       to: column.field,
@@ -5567,19 +6138,20 @@ function diffOneTable(params) {
   }
   for (const [name] of previous.columns) {
     if (!current.columns.has(name)) {
-      buckets.dropColumn.push({ kind: "dropColumn", table, column: name, destructive: true });
+      buckets.dropColumn.push({ kind: "dropColumn", table, ...placement, column: name, destructive: true });
     }
   }
   const pkBefore = previous.pk.join(",");
   const pkAfter = current.pk.join(",");
   if (pkBefore !== pkAfter) {
     if (previous.pk.length > 0) {
-      buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, destructive: false, ...previous.model.primaryKeyConstraintName === undefined ? {} : { constraintName: previous.model.primaryKeyConstraintName } });
+      buckets.dropPrimaryKey.push({ kind: "dropPrimaryKey", table, ...placement, destructive: false, ...previous.model.primaryKeyConstraintName === undefined ? {} : { constraintName: previous.model.primaryKeyConstraintName } });
     }
     if (current.pk.length > 0) {
       buckets.addPrimaryKey.push({
         kind: "addPrimaryKey",
         table,
+        ...placement,
         columns: current.pk,
         ...current.model.primaryKeyConstraintName === undefined ? {} : { constraintName: current.model.primaryKeyConstraintName },
         destructive: false
@@ -5591,15 +6163,15 @@ function diffOneTable(params) {
     if (before === expression)
       continue;
     if (before !== undefined && previous.model.checks?.some((check) => check.name === name && check.catalogExpression === true))
-      throw new VibeError27({ code: "VIBE_MIGRATION", message: "Unequal catalog CHECK text requires normalized evidence or explicit replacement through the live planner", meta: { reason: "check-inspection-unavailable", table, name } });
+      throw new VibeError30({ code: "VIBE_MIGRATION", message: "Unequal catalog CHECK text requires normalized evidence or explicit replacement through the live planner", meta: { reason: "check-inspection-unavailable", table, name } });
     if (before !== undefined)
-      buckets.dropCheck.push({ kind: "dropCheck", table, name, destructive: false });
-    buckets.addCheck.push({ kind: "addCheck", table, name, expression, destructive: false });
+      buckets.dropCheck.push({ kind: "dropCheck", table, ...placement, name, destructive: false });
+    buckets.addCheck.push({ kind: "addCheck", table, ...placement, name, expression, destructive: false });
   }
   for (const [name] of previous.checks) {
     if (current.checks.has(name))
       continue;
-    buckets.dropCheck.push({ kind: "dropCheck", table, name, destructive: false });
+    buckets.dropCheck.push({ kind: "dropCheck", table, ...placement, name, destructive: false });
   }
   for (const [key, index] of current.indexes) {
     if (previous.indexes.has(key))
@@ -5607,6 +6179,7 @@ function diffOneTable(params) {
     buckets.createIndex.push({
       kind: "createIndex",
       table,
+      ...placement,
       name: index.name,
       indexKind: index.kind,
       unique: index.unique,
@@ -5619,7 +6192,7 @@ function diffOneTable(params) {
   for (const [key, index] of previous.indexes) {
     if (current.indexes.has(key))
       continue;
-    buckets.dropIndex.push({ kind: "dropIndex", name: index.name, table, destructive: false, ...index.constraintName === undefined ? {} : { constraintName: index.constraintName } });
+    buckets.dropIndex.push({ kind: "dropIndex", name: index.name, table, ...placement, destructive: false, ...index.constraintName === undefined ? {} : { constraintName: index.constraintName } });
   }
   for (const [key, fk] of current.fks) {
     const before = previous.fks.get(key);
@@ -5627,9 +6200,11 @@ function diffOneTable(params) {
       buckets.addForeignKey.push({
         kind: "addForeignKey",
         table,
+        ...placement,
         constraintName: fk.constraintName,
         columns: fk.columns,
         refTable: fk.refTable,
+        ...fk.refNamespace === undefined ? {} : { refNamespace: fk.refNamespace },
         refColumns: fk.refColumns,
         onDelete: fk.onDelete,
         onUpdate: fk.onUpdate,
@@ -5641,15 +6216,18 @@ function diffOneTable(params) {
       buckets.dropForeignKey.push({
         kind: "dropForeignKey",
         table,
+        ...placement,
         constraintName: before.constraintName,
         destructive: false
       });
       buckets.addForeignKey.push({
         kind: "addForeignKey",
         table,
+        ...placement,
         constraintName: fk.constraintName,
         columns: fk.columns,
         refTable: fk.refTable,
+        ...fk.refNamespace === undefined ? {} : { refNamespace: fk.refNamespace },
         refColumns: fk.refColumns,
         onDelete: fk.onDelete,
         onUpdate: fk.onUpdate,
@@ -5663,6 +6241,7 @@ function diffOneTable(params) {
     buckets.dropForeignKey.push({
       kind: "dropForeignKey",
       table,
+      ...placement,
       constraintName: fk.constraintName,
       destructive: false
     });
@@ -5670,12 +6249,12 @@ function diffOneTable(params) {
 }
 
 // packages/migrate/src/ddl/render.ts
-import { VibeError as VibeError31, sqlObjectKey as sqlObjectKey9 } from "@vibeorm/schema";
+import { VibeError as VibeError34, sqlObjectKey as sqlObjectKey10 } from "@vibeorm/schema";
 
 // packages/migrate/src/ddl/postgres.ts
 import { renderExclusionSetup } from "@vibeorm/sql";
-import { VibeError as VibeError28, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
-import { postgresDialect as postgresDialect8, renderRlsPolicyPath } from "@vibeorm/sql";
+import { VibeError as VibeError31, assertSqlNamespace as assertSqlNamespace3, defaultPrimaryKeyName as defaultPrimaryKeyName3, implicitJoinTableObjectNames as implicitJoinTableObjectNames2, isEnumType as isEnumType7 } from "@vibeorm/schema";
+import { postgresDialect as postgresDialect9, renderRlsPolicyPath, renderIndexColumns } from "@vibeorm/sql";
 function renderPostgresSteps(params) {
   refuseSameTransactionEnumUse({ steps: params.steps });
   return params.steps.flatMap((step) => renderStep({ step }));
@@ -5685,19 +6264,21 @@ function refuseSameTransactionEnumUse(params) {
   for (const step of params.steps) {
     if (step.kind !== "addEnumValue")
       continue;
-    const values = added.get(step.enumName) ?? new Set;
+    const key = JSON.stringify([step.namespace ?? "public", step.enumName]);
+    const values = added.get(key) ?? new Set;
     values.add(step.value);
-    added.set(step.enumName, values);
+    added.set(key, values);
   }
   if (added.size === 0)
     return;
   const use = (field) => {
     if (!isEnumType7(field.type))
       return;
-    const enumName = field.type.enum;
+    const type = field.type;
+    const enumName = type.enum;
     const def = field.default;
     const candidates = def?.kind === "list" ? def.values : def?.kind === "enumValue" || def?.kind === "literal" ? [def.value] : [];
-    const value = candidates.find((entry) => typeof entry === "string" && added.get(enumName)?.has(entry) === true);
+    const value = candidates.find((entry) => typeof entry === "string" && added.get(JSON.stringify([type.namespace ?? "public", enumName]))?.has(entry) === true);
     return value === undefined ? undefined : { enumName, value };
   };
   for (const step of params.steps) {
@@ -5709,7 +6290,7 @@ function refuseSameTransactionEnumUse(params) {
       const found = use(field);
       if (found === undefined)
         continue;
-      throw new VibeError28({
+      throw new VibeError31({
         code: "VIBE_MIGRATION",
         message: `enum value "${found.value}" is added to "${found.enumName}" and used as a default on "${step.table}"."${field.dbName ?? field.name}" in the same migration \u2014 PostgreSQL cannot use an enum member before the transaction that added it commits. Split this into two migrations: the first containing only the ALTER TYPE ... ADD VALUE, the second the column change`,
         meta: { enum: found.enumName, value: found.value, table: step.table, column: field.dbName ?? field.name, rule: "enum-value-used-in-adding-transaction" }
@@ -5720,27 +6301,30 @@ function refuseSameTransactionEnumUse(params) {
 function renderStep(params) {
   const { step } = params;
   switch (step.kind) {
+    case "createNamespace":
+      assertSqlNamespace3({ namespace: step.namespace, dialect: "postgres", allowPublic: false });
+      return [`CREATE SCHEMA ${q2(step.namespace)};`];
     case "addExclusion":
-      return [...renderExclusionSetup({ dialect: postgresDialect8, exclusion: step.exclusion }), `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.exclusion.name)} ${step.exclusion.definition};`];
+      return [...renderExclusionSetup({ dialect: postgresDialect9, exclusion: step.exclusion }), `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.exclusion.name)} ${step.exclusion.definition};`];
     case "dropExclusion":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.exclusion.name)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.exclusion.name)};`];
     case "enableRls":
     case "forceRls":
     case "disableRls":
     case "noForceRls":
     case "createPolicy":
     case "dropPolicy":
-      return step.kind === "createPolicy" ? [renderRlsPolicyPath({ dialect: postgresDialect8, stage: "save" }).text, renderRlsPolicyPath({ dialect: postgresDialect8, stage: "empty" }).text, ...renderRlsStep({ step, dialect: "postgres" }), renderRlsPolicyPath({ dialect: postgresDialect8, stage: "restore" }).text] : renderRlsStep({ step, dialect: "postgres" });
+      return step.kind === "createPolicy" ? [renderRlsPolicyPath({ dialect: postgresDialect9, stage: "save" }).text, renderRlsPolicyPath({ dialect: postgresDialect9, stage: "empty" }).text, ...renderRlsStep({ step, dialect: "postgres" }), renderRlsPolicyPath({ dialect: postgresDialect9, stage: "restore" }).text] : renderRlsStep({ step, dialect: "postgres" });
     case "createEnum": {
       const name = step.enumDef.dbName ?? step.enumDef.name;
       const values = step.enumDef.values.map((value) => quotePgString({ value })).join(", ");
-      return [`CREATE TYPE ${publicName(name)} AS ENUM (${values});`];
+      return [`CREATE TYPE ${qualifiedName(name, step.enumDef.namespace)} AS ENUM (${values});`];
     }
     case "dropEnum":
-      return [`DROP TYPE ${publicName(step.enumName)};`];
+      return [`DROP TYPE ${qualifiedName(step.enumName, step.namespace)};`];
     case "addEnumValue":
       return [
-        `ALTER TYPE ${publicName(step.enumName)} ADD VALUE IF NOT EXISTS ${quotePgString({ value: step.value })};`
+        `ALTER TYPE ${qualifiedName(step.enumName, step.namespace)} ADD VALUE IF NOT EXISTS ${quotePgString({ value: step.value })};`
       ];
     case "createTable": {
       const lines = step.columns.map((column) => `  ${columnDefSql({ field: column })}`);
@@ -5751,101 +6335,101 @@ function renderStep(params) {
       for (const check of step.checks ?? []) {
         lines.push(`  CONSTRAINT ${q2(check.name)} CHECK (${check.expression})`);
       }
-      return [`CREATE TABLE ${publicName(step.table)} (
+      return [`CREATE TABLE ${qualifiedName(step.table, step.namespace)} (
 ${lines.join(`,
 `)}
 );`];
     }
     case "dropTable":
     case "dropJoinTable":
-      return [`DROP TABLE ${publicName(step.table)};`];
+      return [`DROP TABLE ${qualifiedName(step.table, step.namespace)};`];
     case "dropView":
-      return [`DROP VIEW IF EXISTS ${publicName(step.table)};`];
+      return [`DROP VIEW IF EXISTS ${qualifiedName(step.table, step.namespace)};`];
     case "addColumn":
-      return [`ALTER TABLE ${publicName(step.table)} ADD COLUMN ${columnDefSql({ field: step.column })};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD COLUMN ${columnDefSql({ field: step.column })};`];
     case "dropColumn":
-      return [`ALTER TABLE ${publicName(step.table)} DROP COLUMN ${q2(step.column)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP COLUMN ${q2(step.column)};`];
     case "alterColumn":
       return renderAlterColumn({ step });
     case "createIndex": {
       const unique = step.unique ? "UNIQUE " : "";
       const using = !step.unique && step.indexKind !== "btree" ? ` USING ${step.indexKind}` : "";
-      const cols = step.columns.map((column) => `${q2(column.name)}${column.desc ? " DESC" : ""}`).join(", ");
+      const cols = renderIndexColumns({ dialect: postgresDialect9, columns: step.columns, unique: step.unique }).join(", ");
       const nulls = step.nullsNotDistinct === true ? " NULLS NOT DISTINCT" : "";
       const where = step.where === undefined ? "" : ` WHERE ${step.where}`;
       return [
-        `CREATE ${unique}INDEX ${q2(step.name)} ON ${publicName(step.table)}${using} (${cols})${nulls}${where};`
+        `CREATE ${unique}INDEX ${q2(step.name)} ON ${qualifiedName(step.table, step.namespace)}${using} (${cols})${nulls}${where};`
       ];
     }
     case "dropIndex":
       if (step.constraintName !== undefined) {
         if (step.table === undefined)
-          throw new VibeError28({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
-        return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName)};`];
+          throw new VibeError31({ code: "VIBE_MIGRATION", message: "Constraint-backed index removal requires its owning table" });
+        return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.constraintName)};`];
       }
-      return [`DROP INDEX ${publicName(step.name)};`];
+      return [`DROP INDEX ${qualifiedName(step.name, step.namespace)};`];
     case "addCheck":
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.name)} CHECK (${step.expression});`
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.name)} CHECK (${step.expression});`
       ];
     case "dropCheck":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.name)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.name)};`];
     case "addForeignKey": {
       const cols = step.columns.map((column) => q2(column)).join(", ");
       const refCols = step.refColumns.map((column) => q2(column)).join(", ");
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${publicName(step.refTable)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]};`
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${qualifiedName(step.refTable, step.refNamespace)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]};`
       ];
     }
     case "addForeignKeyNotValid": {
       const cols = step.columns.map((column) => q2(column)).join(", ");
       const refCols = step.refColumns.map((column) => q2(column)).join(", ");
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${publicName(step.refTable)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]} NOT VALID;`
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.constraintName)} FOREIGN KEY (${cols}) REFERENCES ${qualifiedName(step.refTable, step.refNamespace)} (${refCols}) ON DELETE ${CASCADE_ACTION_SQL[step.onDelete]} ON UPDATE ${CASCADE_ACTION_SQL[step.onUpdate]} NOT VALID;`
       ];
     }
     case "addCheckNotValid":
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.name)} CHECK (${step.expression}) NOT VALID;`
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.name)} CHECK (${step.expression}) NOT VALID;`
       ];
     case "validateConstraint":
-      return [`ALTER TABLE ${publicName(step.table)} VALIDATE CONSTRAINT ${q2(step.name)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} VALIDATE CONSTRAINT ${q2(step.name)};`];
     case "renameTable":
-      return [`ALTER TABLE ${publicName(step.from)} RENAME TO ${q2(step.to)};`];
+      return [`ALTER TABLE ${qualifiedName(step.from, step.namespace)} RENAME TO ${q2(step.to)};`];
     case "renameColumn":
-      return [`ALTER TABLE ${publicName(step.table)} RENAME COLUMN ${q2(step.from)} TO ${q2(step.to)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} RENAME COLUMN ${q2(step.from)} TO ${q2(step.to)};`];
     case "dropForeignKey":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName)};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.constraintName)};`];
     case "createJoinTable": {
       const aType = columnTypeSql({ field: { ...step.a.field, isList: false } });
       const bType = columnTypeSql({ field: { ...step.b.field, isList: false } });
       const names = implicitJoinTableObjectNames2({ table: step.table });
       return [
-        `CREATE TABLE ${publicName(step.table)} (
+        `CREATE TABLE ${qualifiedName(step.table, step.namespace)} (
   "A" ${aType} NOT NULL,
   "B" ${bType} NOT NULL
 );`,
-        `CREATE UNIQUE INDEX ${q2(names.uniqueIndex)} ON ${publicName(step.table)} ("A", "B");`,
-        `CREATE INDEX ${q2(names.indexB)} ON ${publicName(step.table)} ("B");`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${publicName(step.a.table)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${publicName(step.b.table)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
+        `CREATE UNIQUE INDEX ${q2(names.uniqueIndex)} ON ${qualifiedName(step.table, step.namespace)} ("A", "B");`,
+        `CREATE INDEX ${q2(names.indexB)} ON ${qualifiedName(step.table, step.namespace)} ("B");`,
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(names.foreignKeyA)} FOREIGN KEY ("A") REFERENCES ${qualifiedName(step.a.table, step.a.namespace)} (${q2(step.a.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`,
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(names.foreignKeyB)} FOREIGN KEY ("B") REFERENCES ${qualifiedName(step.b.table, step.b.namespace)} (${q2(step.b.column)}) ON DELETE CASCADE ON UPDATE CASCADE;`
       ];
     }
     case "addPrimaryKey": {
       const cols = step.columns.map((column) => q2(column)).join(", ");
       return [
-        `ALTER TABLE ${publicName(step.table)} ADD CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${cols});`
+        `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ADD CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))} PRIMARY KEY (${cols});`
       ];
     }
     case "dropPrimaryKey":
-      return [`ALTER TABLE ${publicName(step.table)} DROP CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))};`];
+      return [`ALTER TABLE ${qualifiedName(step.table, step.namespace)} DROP CONSTRAINT ${q2(step.constraintName ?? defaultPrimaryKeyName3({ table: step.table, dialect: "postgres" }))};`];
   }
 }
 function columnDefSql(params) {
   const { field } = params;
   const name = q2(field.dbName ?? field.name);
   if (field.default?.kind === "autoincrement" && !isIdentityColumn({ field })) {
-    throw new VibeError28({
+    throw new VibeError31({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -5865,7 +6449,7 @@ function renderAlterColumn(params) {
   const { step } = params;
   const statements = [];
   const column = q2(step.column);
-  const alterPrefix = `ALTER TABLE ${publicName(step.table)} ALTER COLUMN ${column}`;
+  const alterPrefix = `ALTER TABLE ${qualifiedName(step.table, step.namespace)} ALTER COLUMN ${column}`;
   const storageChange = step.changes.includes("type") && isEnumStringTransition({ from: step.from, to: step.to });
   if (storageChange)
     assertEnumStringTransition({ from: step.from, to: step.to, dialect: "postgres", table: step.table, column: step.column });
@@ -5881,7 +6465,7 @@ function renderAlterColumn(params) {
   }
   if (step.changes.includes("default") || droppedDefault) {
     if (step.to.default?.kind === "autoincrement") {
-      throw new VibeError28({
+      throw new VibeError31({
         code: "VIBE_MIGRATION",
         message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
         meta: { table: step.table, column: step.column }
@@ -5892,15 +6476,16 @@ function renderAlterColumn(params) {
   }
   return statements;
 }
-function publicName(name) {
-  return `${q2("public")}.${q2(name)}`;
+function qualifiedName(name, namespace = "public") {
+  assertSqlNamespace3({ namespace, dialect: "postgres" });
+  return `${q2(namespace)}.${q2(name)}`;
 }
 function q2(name) {
-  return postgresDialect8.quoteIdent({ name });
+  return postgresDialect9.quoteIdent({ name });
 }
 
 // packages/migrate/src/ddl/sqlite.ts
-import { VibeError as VibeError29, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError32, implicitJoinTableObjectNames as implicitJoinTableObjectNames3, isEnumType as isEnumType8, unsupportedCapability as unsupportedCapability11 } from "@vibeorm/schema";
 import { sqliteDialect as sqliteDialect3 } from "@vibeorm/sql";
 
 // packages/migrate/src/ddl/drop-order.ts
@@ -5950,6 +6535,8 @@ function orderDropsChildrenFirst(params) {
 function describeStep(params) {
   const { step } = params;
   switch (step.kind) {
+    case "createNamespace":
+      return `create namespace ${JSON.stringify(step.namespace)}`;
     case "addExclusion":
       return `add exclusion "${step.exclusion.name}" on "${step.table}"`;
     case "dropExclusion":
@@ -6020,6 +6607,12 @@ function describeStep(params) {
 // packages/migrate/src/ddl/sqlite.ts
 function renderSqliteSteps(params) {
   const { steps } = params;
+  for (const step of steps) {
+    if (step.kind === "createIndex" && step.columns.some((column) => column.operatorClass !== undefined))
+      throw unsupportedCapability11({ dialect: "sqlite", feature: "indexOperatorClasses" });
+    if (step.kind === "createNamespace" || step.namespace !== undefined || step.refNamespace !== undefined)
+      throw unsupportedCapability11({ dialect: "sqlite", feature: "fixedNamespaces" });
+  }
   for (const step of steps)
     if (isRlsStep({ step }))
       renderRlsStep({ step, dialect: "sqlite" });
@@ -6040,7 +6633,7 @@ function renderSqliteSteps(params) {
         continue;
       const awaitsNewParent = [...toNorm?.tables.get(table)?.fks.values() ?? []].some((fk) => createdTables.has(fk.refTable));
       if (awaitsNewParent) {
-        throw new VibeError29({
+        throw new VibeError32({
           code: "VIBE_MIGRATION",
           message: `cannot order this sqlite migration safely: rebuilding "${table}" must happen BEFORE the dropped table(s) it references (${[
             ...droppedTables
@@ -6069,7 +6662,7 @@ function renderSqliteSteps(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError29({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "createEnum":
       case "dropEnum":
       case "addEnumValue":
@@ -6155,7 +6748,7 @@ function renderSqliteSteps(params) {
       case "renameColumn": {
         const renamed = step.kind === "renameTable" ? step.from : step.table;
         if (rebuildSet.has(renamed) || step.kind === "renameTable" && rebuildSet.has(step.to)) {
-          throw new VibeError29({
+          throw new VibeError32({
             code: "VIBE_MIGRATION",
             message: `sqlite cannot rename "${renamed}" in the same migration that rebuilds it \u2014 the table-rebuild recipe is written against a single table name. Split the rename and the column/constraint change into two migrations`,
             meta: { reason: "rename-ambiguous", table: renamed, dialect: "sqlite" }
@@ -6167,7 +6760,7 @@ function renderSqliteSteps(params) {
       case "addForeignKeyNotValid":
       case "addCheckNotValid":
       case "validateConstraint":
-        throw unsupportedCapability7({
+        throw unsupportedCapability11({
           dialect: "sqlite",
           feature: "stagedConstraints",
           hint: "sqlite applies constraint changes by rebuilding the table; add the constraint in one step"
@@ -6209,7 +6802,7 @@ function classifyRebuilds(params) {
     switch (step.kind) {
       case "addExclusion":
       case "dropExclusion":
-        throw new VibeError29({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
+        throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "sqlite", feature: "exclusionConstraints" } });
       case "alterColumn":
       case "dropForeignKey":
       case "addPrimaryKey":
@@ -6261,7 +6854,7 @@ async function assertSqliteRebuildTableOptions(params) {
   for (const table of params.tables) {
     const row = rows.find((entry) => entry.schema === "main" && entry.name === table);
     if (row === undefined || Number(row.strict) !== 0 || Number(row.wr) !== 0) {
-      throw unsupportedCapability7({ dialect: "sqlite", feature: "sqliteRebuildTableOptions", hint: `Cannot reproduce the existing table options of "${table}"; use a reviewed migration that preserves STRICT and WITHOUT ROWID` });
+      throw unsupportedCapability11({ dialect: "sqlite", feature: "sqliteRebuildTableOptions", hint: `Cannot reproduce the existing table options of "${table}"; use a reviewed migration that preserves STRICT and WITHOUT ROWID` });
     }
   }
 }
@@ -6270,7 +6863,7 @@ function renderTableRebuild(params) {
   const source = from.tables.get(table);
   const target = to.tables.get(table);
   if (source === undefined || target === undefined) {
-    throw new VibeError29({
+    throw new VibeError32({
       code: "VIBE_MIGRATION",
       message: `cannot rebuild "${table}" \u2014 the table is missing from the ${source === undefined ? "from" : "to"} schema`,
       meta: { table }
@@ -6297,7 +6890,7 @@ function renderTableRebuild(params) {
   }));
   const common = [...new Set([...target.columns.keys(), ...params.preservedColumns.keys()])].filter((name) => params.preservedColumns.get(name)?.generated !== true && (source.columns.has(name) || params.preservedColumns.has(name)));
   if (common.length === 0) {
-    throw unsupportedCapability7({ dialect: "sqlite", feature: "sqliteRebuildWithoutRowTransfer", hint: `Rebuilding "${table}" has no transferable columns and would discard every row; use explicit renames or a reviewed data migration` });
+    throw unsupportedCapability11({ dialect: "sqlite", feature: "sqliteRebuildWithoutRowTransfer", hint: `Rebuilding "${table}" has no transferable columns and would discard every row; use explicit renames or a reviewed data migration` });
   }
   const cols = common.map((name) => q3(name)).join(", ");
   statements.push(`INSERT INTO ${q3(tmp)} (${cols}) SELECT ${cols} FROM ${q3(table)};`);
@@ -6405,7 +6998,7 @@ function columnDefSql2(params) {
   const { field, constraintTable, enums, inlinePkAutoincrement } = params;
   const name = field.dbName ?? field.name;
   if (field.default?.kind === "autoincrement" && !inlinePkAutoincrement) {
-    throw new VibeError29({
+    throw new VibeError32({
       code: "VIBE_MIGRATION",
       message: `autoincrement on sqlite requires "${field.name}" to be the single-column Int or BigInt primary key`,
       meta: { field: field.name }
@@ -6424,7 +7017,7 @@ function columnDefSql2(params) {
     const enumName = field.type.enum;
     const values = resolveEnumValues({ name: enumName, enums });
     if (values === undefined) {
-      throw new VibeError29({
+      throw new VibeError32({
         code: "VIBE_MIGRATION",
         message: `enum "${enumName}" on column "${field.name}" is not declared in the schema \u2014 sqlite rendering needs the target schema's enums for the CHECK constraint`,
         meta: { field: field.name, enum: enumName }
@@ -6438,14 +7031,14 @@ function columnDefSql2(params) {
 function createIndexSql(params) {
   const { table, name, unique, kind, columns, where } = params;
   if (params.nullsNotDistinct === true) {
-    throw unsupportedCapability7({
+    throw unsupportedCapability11({
       dialect: "sqlite",
       feature: `UNIQUE NULLS NOT DISTINCT (index "${name}")`,
       hint: "sqlite treats NULLs as distinct in unique indexes and has no switch \u2014 gate the flag per dialect"
     });
   }
   if (!unique && kind !== "btree") {
-    throw unsupportedCapability7({
+    throw unsupportedCapability11({
       dialect: "sqlite",
       feature: `index kind "${kind}" (index "${name}")`,
       hint: "sqlite indexes are btree only; use an extension-specific virtual table for others"
@@ -6459,7 +7052,7 @@ function requireSchemas(params) {
   const { step, fromNorm, toNorm } = params;
   if (fromNorm !== undefined && toNorm !== undefined)
     return;
-  throw new VibeError29({
+  throw new VibeError32({
     code: "VIBE_MIGRATION",
     message: `sqlite step "${describeStep({ step })}" requires a table rebuild \u2014 renderSteps needs the { from, to } schemas to construct it`,
     meta: { step: step.kind }
@@ -6470,10 +7063,14 @@ function q3(name) {
 }
 
 // packages/migrate/src/ddl/mysql.ts
-import { VibeError as VibeError30, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { VibeError as VibeError33, implicitJoinTableObjectNames as implicitJoinTableObjectNames4, unsupportedCapability as unsupportedCapability12 } from "@vibeorm/schema";
 import { mysqlDialect as mysqlDialect3 } from "@vibeorm/sql";
 function renderMysqlSteps(params) {
   for (const step of params.steps) {
+    if (step.namespace !== undefined || step.refNamespace !== undefined || step.kind === "createNamespace")
+      throw unsupportedCapability12({ dialect: "mysql", feature: "fixedNamespaces" });
+    if (step.kind === "createIndex" && step.columns.some((column) => column.operatorClass !== undefined))
+      throw unsupportedCapability12({ dialect: "mysql", feature: "indexOperatorClasses" });
     if (isRlsStep({ step }))
       renderRlsStep({ step, dialect: "mysql" });
     if (step.kind !== "alterColumn" || !step.changes.some((change) => change === "type" || change === "nullability" || change === "collation"))
@@ -6483,7 +7080,7 @@ function renderMysqlSteps(params) {
       return object.dialect === "mysql" && (identity.kind === "columnDefault" || identity.kind === "generatedColumn" || identity.kind === "column") && identity.table.name === step.table && identity.column === step.column;
     });
     if (owner !== undefined)
-      throw unsupportedCapability8({ dialect: "mysql", feature: "mysqlOwnedColumnRewrite", hint: `MODIFY COLUMN would overwrite migration-owned ${owner.id}; use a reviewed migration that preserves the complete column definition` });
+      throw unsupportedCapability12({ dialect: "mysql", feature: "mysqlOwnedColumnRewrite", hint: `MODIFY COLUMN would overwrite migration-owned ${owner.id}; use a reviewed migration that preserves the complete column definition` });
   }
   const enums = new Map;
   for (const enumDef of params.to?.enums ?? []) {
@@ -6503,7 +7100,7 @@ function renderMysqlSteps(params) {
       continue;
     const retainedIndex = [...table.indexes.values()].some((index) => index.columns[0]?.name === auto && !params.steps.some((candidate) => candidate.kind === "dropIndex" && candidate.table === step.table && candidate.name === index.name));
     if (!retainedIndex)
-      throw unsupportedCapability8({ dialect: "mysql", feature: "mysqlAutoIncrementKeyRemoval", hint: `Removing the last leading key of AUTO_INCREMENT column "${step.table}.${auto}" requires a reviewed combined ALTER` });
+      throw unsupportedCapability12({ dialect: "mysql", feature: "mysqlAutoIncrementKeyRemoval", hint: `Removing the last leading key of AUTO_INCREMENT column "${step.table}.${auto}" requires a reviewed combined ALTER` });
   }
   let dropCursor = 0;
   const inlineIndexes = new Map;
@@ -6512,7 +7109,7 @@ function renderMysqlSteps(params) {
     const columns = step.kind === "createTable" ? step.columns : step.kind === "addColumn" ? [step.column] : [];
     const counters = columns.filter((field) => field.default?.kind === "autoincrement");
     if (counters.length > 1)
-      throw unsupportedCapability8({ dialect: "mysql", feature: "multiple auto-increment columns" });
+      throw unsupportedCapability12({ dialect: "mysql", feature: "multiple auto-increment columns" });
     for (const column of counters) {
       const name = column.dbName ?? column.name;
       if (step.kind === "createTable" && step.primaryKey[0] === name)
@@ -6521,7 +7118,7 @@ function renderMysqlSteps(params) {
         continue;
       const key = params.steps.find((candidate) => candidate.kind === "createIndex" && candidate.table === step.table && candidate.columns[0]?.name === name && !candidate.columns[0]?.desc && candidate.where === undefined && candidate.nullsNotDistinct !== true && (candidate.unique || candidate.indexKind === "btree"));
       if (key === undefined)
-        throw unsupportedCapability8({ dialect: "mysql", feature: `auto-increment column ${step.table}.${name} without an accompanying leading index` });
+        throw unsupportedCapability12({ dialect: "mysql", feature: `auto-increment column ${step.table}.${name} without an accompanying leading index` });
       inlineIndexes.set(step, key);
       consumed.add(key);
     }
@@ -6540,6 +7137,8 @@ function renderMysqlSteps(params) {
 function renderStep2(params) {
   const { step, enums } = params;
   switch (step.kind) {
+    case "createNamespace":
+      throw unsupportedCapability12({ dialect: "mysql", feature: "fixedNamespaces" });
     case "enableRls":
     case "forceRls":
     case "disableRls":
@@ -6581,21 +7180,21 @@ ${lines.join(`,
       return renderAlterColumn2({ step, enums });
     case "createIndex": {
       if (step.where !== undefined) {
-        throw unsupportedCapability8({
+        throw unsupportedCapability12({
           dialect: "mysql",
           feature: `partial index "${step.name}"`,
           hint: "mysql has no partial indexes \u2014 drop the WHERE predicate or gate the index per dialect"
         });
       }
       if (step.nullsNotDistinct === true) {
-        throw unsupportedCapability8({
+        throw unsupportedCapability12({
           dialect: "mysql",
           feature: `UNIQUE NULLS NOT DISTINCT (index "${step.name}")`,
           hint: "mysql treats NULLs as distinct in unique indexes and has no switch \u2014 gate the flag per dialect"
         });
       }
       if (!step.unique && step.indexKind !== "btree") {
-        throw unsupportedCapability8({
+        throw unsupportedCapability12({
           dialect: "mysql",
           feature: `index kind "${step.indexKind}" (index "${step.name}")`,
           hint: "mysql secondary indexes are btree only"
@@ -6612,12 +7211,12 @@ ${lines.join(`,
       ];
     case "addExclusion":
     case "dropExclusion":
-      throw new VibeError30({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
+      throw new VibeError33({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: "Exclusion constraints require PostgreSQL", meta: { dialect: "mysql", feature: "exclusionConstraints" } });
     case "dropCheck":
       return [`ALTER TABLE ${q4(step.table)} DROP CHECK ${q4(step.name)};`];
     case "dropIndex": {
       if (step.table === undefined) {
-        throw new VibeError30({
+        throw new VibeError33({
           code: "VIBE_MIGRATION",
           message: `dropIndex "${step.name}" carries no table \u2014 mysql's DROP INDEX requires one`,
           meta: { index: step.name }
@@ -6639,7 +7238,7 @@ ${lines.join(`,
     case "addForeignKeyNotValid":
     case "addCheckNotValid":
     case "validateConstraint":
-      throw unsupportedCapability8({
+      throw unsupportedCapability12({
         dialect: "mysql",
         feature: "stagedConstraints",
         hint: "MySQL validates a constraint when it is added; add it in one step, or take the outage window that scan needs"
@@ -6674,7 +7273,7 @@ function columnDefSql3(params) {
   const name = q4(field.dbName ?? field.name);
   const autoincrement = field.default?.kind === "autoincrement";
   if (autoincrement && field.type !== "Int" && field.type !== "BigInt") {
-    throw new VibeError30({
+    throw new VibeError33({
       code: "VIBE_MIGRATION",
       message: `autoincrement default on "${field.name}" requires a non-list Int or BigInt column`,
       meta: { field: field.name }
@@ -6696,7 +7295,7 @@ function renderAlterColumn2(params) {
   const { step, enums } = params;
   assertEnumStringTransition({ from: step.from, to: step.to, dialect: "mysql", table: step.table, column: step.column });
   if (step.to.default?.kind === "autoincrement" && step.from.default?.kind !== "autoincrement") {
-    throw new VibeError30({
+    throw new VibeError33({
       code: "VIBE_MIGRATION",
       message: `cannot add autoincrement to existing column "${step.table}"."${step.column}" \u2014 drop and recreate the column instead`,
       meta: { table: step.table, column: step.column }
@@ -6729,31 +7328,31 @@ function declaredSqlitePreservation(params) {
   if (params.from === undefined || to === undefined || (params.from.migrationObjects?.length ?? 0) === 0)
     return { to, restore, columns };
   const invalid = sqliteInvalidatedTables({ steps: params.steps, from: params.from });
-  const retained = new Set((to.migrationObjects ?? []).map((object) => sqlObjectKey9({ identity: object.identity })));
+  const retained = new Set((to.migrationObjects ?? []).map((object) => sqlObjectKey10({ identity: object.identity })));
   for (const object of params.from.migrationObjects ?? []) {
     const identity = object.identity;
-    if (!("table" in identity) || identity.table.namespace !== "main" || !invalid.rebuilt.has(identity.table.name) || !retained.has(sqlObjectKey9({ identity })))
+    if (!("table" in identity) || identity.table.namespace !== "main" || !invalid.rebuilt.has(identity.table.name) || !retained.has(sqlObjectKey10({ identity })))
       continue;
     const facts = object.expected?.facts;
     if (facts === undefined)
-      throw new VibeError31({ code: "VIBE_MIGRATION", message: "SQLite rebuild requires independently declared preservation definitions", meta: { reason: "sqlite-preservation-unavailable", identity } });
+      throw new VibeError34({ code: "VIBE_MIGRATION", message: "SQLite rebuild requires independently declared preservation definitions", meta: { reason: "sqlite-preservation-unavailable", identity } });
     if (identity.kind === "trigger" || identity.kind === "index") {
       if (identity.kind === "index" && to.models.some((model) => (model.dbName ?? model.name) === identity.table.name && model.indexes.some((index) => index.name === identity.name)))
         continue;
       if (typeof facts.definition !== "string")
-        throw new VibeError31({ code: "VIBE_MIGRATION", message: "Missing SQLite restoration SQL", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite restoration SQL", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const statements = restore.get(identity.table.name) ?? [];
       statements.push(facts.definition);
       restore.set(identity.table.name, statements);
     } else if (identity.kind === "column" || identity.kind === "generatedColumn") {
       if (typeof facts.columnDefinition !== "string")
-        throw new VibeError31({ code: "VIBE_MIGRATION", message: "Missing SQLite column clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite column clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const fields = columns.get(identity.table.name) ?? new Map;
       fields.set(identity.column, { sql: facts.columnDefinition, generated: Number(facts.generated) > 1 });
       columns.set(identity.table.name, fields);
     } else if (identity.kind === "columnDefault") {
       if (facts.definition !== null && typeof facts.definition !== "string")
-        throw new VibeError31({ code: "VIBE_MIGRATION", message: "Missing SQLite default clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
+        throw new VibeError34({ code: "VIBE_MIGRATION", message: "Missing SQLite default clause", meta: { reason: "sqlite-preservation-unavailable", identity } });
       const expression = facts.definition;
       to = { ...to, models: to.models.map((model) => (model.dbName ?? model.name) !== identity.table.name ? model : { ...model, fields: model.fields.map((field) => {
         if ((field.dbName ?? field.name) !== identity.column)
@@ -7038,10 +7637,10 @@ function assertNativeMigrationMetadata(params) {
   if (!native)
     return;
   if (!DIALECT_CAPABILITIES3[params.dialect].nativeRowLevelSecurity) {
-    throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
+    throw new VibeError35({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Native RLS migrations are unsupported on ${params.dialect}`, meta: { feature: "nativeRowLevelSecurity", dialect: params.dialect } });
   }
   if (params.migration.rls === undefined) {
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Native RLS migration files require trusted rls.from/rls.to schema metadata. SQL alone cannot prove policy ownership or drift; regenerate with preserved security metadata.", meta: { reason: "rls-migration-metadata-required", migration: params.migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Native RLS migration files require trusted rls.from/rls.to schema metadata. SQL alone cannot prove policy ownership or drift; regenerate with preserved security metadata.", meta: { reason: "rls-migration-metadata-required", migration: params.migration.name } });
   }
 }
 var PG_ADVISORY_LOCK_KEY = 1447645253;
@@ -7086,11 +7685,11 @@ async function assertForwardStart(params) {
   const state = params.migration.desiredState;
   if (state === undefined)
     return;
-  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.from, ...params.probe === undefined ? {} : { probe: params.probe } });
+  const report = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.from, external: params.external, ...params.probe === undefined ? {} : { probe: params.probe } });
   if (report.inSync)
     return;
   if (state.down !== undefined) {
-    const restored = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.down, ...params.probe === undefined ? {} : { probe: params.probe } });
+    const restored = await verifyMigrationState({ executor: params.executor, dialect: params.dialect, expected: state.down, external: params.external, ...params.probe === undefined ? {} : { probe: params.probe } });
     if (restored.inSync)
       return;
   }
@@ -7122,12 +7721,12 @@ function generateMigration(params) {
     }),
     ...orderedMigrationObjects({ objects: to.migrationObjects ?? [] }).flatMap((object) => {
       if (object.dialect !== dialect)
-        throw new VibeError32({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}` });
+        throw new VibeError35({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Migration object ${object.id} requires ${object.dialect}` });
       const previous = (params.desiredState?.from.schema.migrationObjects ?? from.migrationObjects)?.find((entry) => entry.id === object.id);
       if (previous === undefined)
         return [...object.create];
       if (JSON.stringify(previous) !== JSON.stringify(object))
-        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", shadowReusable: true, id: object.id } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration-owned object ${object.id} changed; supply a reviewed forward SQL migration`, meta: { reason: "migration-object-replacement-required", shadowReusable: true, id: object.id } });
       return [];
     })
   ];
@@ -7153,8 +7752,8 @@ async function withMigrationLock(params) {
     }, (cause) => releaseLock({ executor, dialect: params.dialect }).then(() => {
       throw cause;
     }, (cleanupCause) => {
-      if (cause instanceof VibeError32)
-        throw new VibeError32({ code: cause.code, message: cause.message, meta: { ...cause.meta, cleanupCause }, cause });
+      if (cause instanceof VibeError35)
+        throw new VibeError35({ code: cause.code, message: cause.message, meta: { ...cause.meta, cleanupCause }, cause });
       throw cause;
     }));
   };
@@ -7178,16 +7777,17 @@ function validateMigrationReplay(params) {
 }
 function assertMigrationMetadata(params) {
   const { migration, dialect } = params;
+  assertModuleAdoption({ migration });
   if (migration.moduleOrigin !== undefined) {
     assertMaterializedModuleMigration({ migration });
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   if (migration.desiredStatePending === true)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration ${migration.name} has unfinalized desired state; finalize its reviewed before/after declarations before applying`, meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration ${migration.name} has unfinalized desired state; finalize its reviewed before/after declarations before applying`, meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   if (migration.desiredState !== undefined) {
     assertDesiredState({ value: migration.desiredState, migration: migration.name });
     if (migration.desiredState.dialect !== dialect)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch", migration: migration.name } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch", migration: migration.name } });
   }
   assertNativeMigrationMetadata({ migration, sql: migration.sql, dialect });
   assertExecutable({ migration, execution: migration.execution, sql: migration.sql, dialect });
@@ -7195,20 +7795,25 @@ function assertMigrationMetadata(params) {
 async function applyMigrations(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
+  const trustedReplay = isShadowReplayExecutor({ executor });
   if (params.history !== undefined && params.history !== "complete" && params.history !== "subset")
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Unknown migration history validation mode", meta: { reason: "history-mode-invalid" } });
   if (params.history === "complete")
     assertDistinctMigrationNames({ migrations });
   for (const migration of migrations)
     assertMigrationMetadata({ migration, dialect });
+  const externalDeclarations = await parseExternalObjects({ value: params.external ?? [], dialect });
   return withMigrationLock({ executor, dialect, run: async (executor) => {
+    const external = externalDeclarations.length === 0 ? undefined : await inspectExternalObjects({ executor, dialect, external: externalDeclarations });
     let moduleRecords = await readModuleJournal({ executor, dialect });
     const recorded = new Map([...moduleRecords].map(([name, record]) => [name, record.row]));
+    if (external !== undefined)
+      assertExternalOwnershipClaims({ external, identities: [...migrations.flatMap((migration) => migration.moduleOrigin?.owned ?? []), ...[...moduleRecords.values()].flatMap((record) => record.entry?.migration.moduleOrigin?.owned ?? [])] });
     if (migrations.some((migration) => migration.moduleOrigin !== undefined) || [...moduleRecords.values()].some((record) => record.entry !== undefined)) {
       assertModuleUpgradeHistory({ migrations, records: moduleRecords });
       const namespace = await migrationNamespace({ executor, dialect });
-      if (migrations.some((migration) => migration.moduleOrigin !== undefined && moduleNamespace({ origin: migration.moduleOrigin }) !== namespace))
-        throw new VibeError32({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
+      if (dialect !== "postgres" && migrations.some((migration) => migration.moduleOrigin !== undefined && moduleNamespace({ origin: migration.moduleOrigin }) !== namespace))
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: "Module placement differs from the active database namespace", meta: { reason: "module-placement-mismatch" } });
     }
     if (params.history === "complete")
       assertCompleteHistory({ migrations, recorded, dialect });
@@ -7217,6 +7822,12 @@ async function applyMigrations(params) {
       const stored = recorded.get(migration.name);
       return stored === undefined || !isCompleteRecord({ dialect, migration, stored });
     });
+    const adopted = pending.find((migration) => migration.moduleAdoption !== undefined);
+    if (adopted !== undefined && !trustedReplay)
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: "An adopted source must be recorded by the verified adoption workflow, never executed by ordinary apply", meta: { reason: "module-adoption-recording-required", migration: adopted.name } });
+    if (external !== undefined && !trustedReplay)
+      for (const migration of pending)
+        await assertExternalMigrationMutation({ executor, migration, dialect, namespace: await migrationNamespace({ executor, dialect }), external });
     validateMigrationReplay({ ...params, migrations: pending, dialect });
     await ensureMigrationsTable({ executor, dialect });
     if (migrations.some((migration) => migration.moduleOrigin !== undefined))
@@ -7229,7 +7840,7 @@ async function applyMigrations(params) {
         await assertLiveModuleOwnership({ executor, origin: migration.moduleOrigin, resume: stored !== undefined });
       if (stored !== undefined) {
         if (stored.statementIndex < 0) {
-          throw new VibeError32({
+          throw new VibeError35({
             code: "VIBE_MIGRATION",
             message: `migration "${migration.name}" is mid-rollback (${-stored.statementIndex - 1} down statement(s) done) \u2014 finish it with \`migrate down\` or repair with resolveMigration before applying`,
             meta: { migration: migration.name, statementIndex: stored.statementIndex }
@@ -7251,6 +7862,7 @@ async function applyMigrations(params) {
             migration,
             start: stored.statementIndex,
             moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }),
+            external,
             ...params.probe === undefined ? {} : { probe: params.probe },
             insertRecord: false,
             ...stored.error === undefined ? {} : { storedError: stored.error }
@@ -7266,10 +7878,10 @@ async function applyMigrations(params) {
           executor,
           dialect,
           ...migration.execution === undefined ? {} : { execution: migration.execution },
-          run: () => runNonTransactional({ executor, dialect, migration, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), start: 0, insertRecord: true, ...params.probe === undefined ? {} : { probe: params.probe } })
+          run: () => runNonTransactional({ executor, dialect, migration, external, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), start: 0, insertRecord: true, ...params.probe === undefined ? {} : { probe: params.probe } })
         });
       } else {
-        await runTransactional({ executor, dialect, migration, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), ...params.probe === undefined ? {} : { probe: params.probe } });
+        await runTransactional({ executor, dialect, migration, external, moduleOrigins: applicationModuleOrigins({ migration, records: moduleRecords }), ...params.probe === undefined ? {} : { probe: params.probe } });
       }
       if (migration.moduleOrigin !== undefined)
         moduleRecords = await readModuleJournal({ executor, dialect });
@@ -7277,10 +7889,11 @@ async function applyMigrations(params) {
     }
     const final = migrations.at(-1);
     if (final?.desiredState !== undefined) {
+      const finalExternal = externalDeclarations.length === 0 ? undefined : await inspectExternalObjects({ executor, dialect, external: externalDeclarations });
       if (params.probe === "rollback")
         await executor({ text: "BEGIN" });
       try {
-        assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: final.desiredState.from, to: final.desiredState.to, removals: final.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: final.desiredState.from, to: final.desiredState.to, external: finalExternal, removals: comparisonRemovals({ migration: final, external: finalExternal }), ...params.probe === undefined ? {} : { probe: params.probe } }) });
       } finally {
         if (params.probe === "rollback")
           await executor({ text: "ROLLBACK" });
@@ -7289,6 +7902,27 @@ async function applyMigrations(params) {
     return { applied, skipped };
   } });
 }
+function comparisonRemovals(params) {
+  return params.migration.desiredState?.unmanagedRemovals?.filter((identity) => params.external === undefined || externalObjectOwner({ identity, external: params.external }) === undefined);
+}
+async function assertExternalMigrationMutation(params) {
+  assertExternalOwnershipClaims({ external: params.external, identities: params.migration.desiredState?.unmanagedRemovals ?? [] });
+  const state = params.migration.desiredState;
+  if (state === undefined)
+    return;
+  const identities = [];
+  const steps = diffSchemas({ from: state.from.schema, to: state.to.schema, dialect: params.dialect });
+  for (const step of steps) {
+    if (step.kind === "createNamespace")
+      identities.push({ kind: "namespace", name: step.namespace });
+    else if ("table" in step && typeof step.table === "string")
+      identities.push({ kind: "table", name: { namespace: step.namespace ?? params.namespace, name: step.table } });
+    else if ("enumName" in step)
+      identities.push({ kind: "enum", name: { namespace: step.namespace ?? params.namespace, name: step.enumName } });
+  }
+  assertExternalOwnershipClaims({ external: params.external, identities });
+  await refuseExternalDependents({ executor: params.executor, dialect: params.dialect, external: params.external, steps, namespace: params.namespace });
+}
 async function migrationStatus(params) {
   const { executor, migrations } = params;
   const dialect = params.dialect ?? "postgres";
@@ -7364,7 +7998,7 @@ async function repairMigration(params) {
   const { executor, name, dialect } = params;
   const moduleRecord = (await readModuleJournal({ executor, dialect })).get(name);
   if (moduleRecord?.entry !== undefined)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Module history cannot be marked applied or deleted without verified module recovery", meta: { reason: "module-resolution-required", moduleId: moduleRecord.entry.migration.moduleOrigin.moduleId } });
   await ensureMigrationsTable({ executor, dialect });
   if (params.as === "applied") {
     const insert = `INSERT INTO ${q5(dialect, MIGRATIONS_TABLE_NAME)} (${q5(dialect, "name")}, ${q5(dialect, "checksum")}, ${q5(dialect, "statement_index")}) VALUES (${ph(dialect, 1)}, ${ph(dialect, 2)}, ${RESOLVED_STATEMENT_INDEX})`;
@@ -7386,7 +8020,7 @@ async function rollbackMigration(params) {
     const stored = assertRollbackRecord({ migration, stored: recorded.get(migration.name), dialect });
     const newest = [...recorded.keys()].at(-1);
     if (newest !== migration.name)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${migration.name}" is not the newest recorded migration; select rollback again`, meta: { reason: "rollback-not-latest", migration: migration.name, newest } });
     await validateRollbackRecovery({ executor, migration, downSql, stored, dialect });
     await executeRollback({ ...params, executor, dialect, downSql, stored });
   } });
@@ -7404,7 +8038,7 @@ async function rollbackMigrations(params) {
       const target = journal.findIndex((row) => row.name === params.to);
       const row = journal[target];
       if (row?.state !== "applied")
-        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Rollback target "${params.to}" is not a known applied migration`, meta: { reason: "rollback-target-invalid", to: params.to, state: row?.state } });
       assertMigrationMetadata({ migration: byName.get(row.name), dialect });
       start = target + 1;
     }
@@ -7412,7 +8046,7 @@ async function rollbackMigrations(params) {
     for (const row of journal.slice(start).reverse()) {
       const migration = byName.get(row.name);
       if (migration === undefined)
-        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Cannot roll back "${row.name}" without its migration file`, meta: { reason: "rollback-file-missing", migration: row.name } });
       const stored = assertRollbackRecord({ migration, stored: recorded.get(row.name), dialect });
       const downSql = validateRollbackFile({ ...params, migration, dialect });
       plan.push({ migration, downSql, stored });
@@ -7429,20 +8063,23 @@ async function rollbackMigrations(params) {
 }
 function validateRollbackFile(params) {
   const { migration, dialect } = params;
+  assertModuleAdoption({ migration });
+  if (migration.moduleAdoption !== undefined)
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Reversal across verified module adoption is refused; it would execute destructive source down SQL against pre-existing data", meta: { reason: "module-adoption-reverse-refused", migration: migration.name } });
   if (migration.desiredStatePending === true)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Unfinalized desired state cannot be rolled back", meta: { reason: "desired-state-unfinalized", migration: migration.name } });
   if (migration.moduleOrigin !== undefined) {
     assertMaterializedModuleMigration({ migration });
     assertModuleOwnership({ origin: migration.moduleOrigin, desiredState: migration.desiredState });
   }
   const downSql = migration.downSql;
   if (downSql === undefined)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" has no down.sql; roll it back manually, then repair with resolveMigration (as: "rolled-back")`, meta: { reason: "rollback-down-missing", migration: migration.name } });
   assertProbeMode({ dialect, probe: params.probe });
   if (migration.desiredState !== undefined) {
     assertDesiredState({ value: migration.desiredState, migration: migration.name });
     if (migration.desiredState.dialect !== dialect)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch" } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Migration desired-state dialect mismatch", meta: { reason: "desired-state-dialect-mismatch" } });
     assertRemovalAuthorization({ steps: diffSchemas({ from: migration.desiredState.to.schema, to: (migration.desiredState.down ?? migration.desiredState.from).schema, dialect }), previous: migration.desiredState.to, dialect, namespace: dialect === "sqlite" ? "main" : "public", ...params.acceptIntegrityLoss === undefined ? {} : { acceptIntegrityLoss: params.acceptIntegrityLoss } });
   }
   assertNativeMigrationMetadata({ migration, sql: downSql, dialect });
@@ -7455,10 +8092,10 @@ function validateRollbackFile(params) {
 function assertRollbackRecord(params) {
   const { migration, stored, dialect } = params;
   if (stored === undefined)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is not recorded as applied; nothing to roll back`, meta: { migration: migration.name } });
   assertChecksumMatches({ migration, stored: stored.checksum });
   if (stored.statementIndex >= 0 && (!isCompleteRecord({ dialect, migration, stored }) || stored.error !== undefined))
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: `migration "${migration.name}" is only partially applied or has an unresolved error; its down mirrors the FULL up. Finish or repair with resolveMigration`, meta: { reason: "rollback-partial-up", migration: migration.name, statementIndex: stored.statementIndex } });
   return stored;
 }
 async function validateRollbackRecovery(params) {
@@ -7467,7 +8104,7 @@ async function validateRollbackRecovery(params) {
     return;
   const start = -stored.statementIndex - 1;
   if (start > downSql.length)
-    throw new VibeError32({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
+    throw new VibeError35({ code: "VIBE_MIGRATION", message: "Rollback progress exceeds its statement count", meta: { reason: "rollback-progress-invalid", migration: migration.name } });
   if (dialect === "sqlite" && usesSelfManagedTransactions({ sql: downSql }))
     assertSelfManagedResumeSafe({ sql: downSql, start, migration: migration.name, direction: "down" });
   if (!marksInflight({ dialect, execution: migration.downExecution }) || start >= downSql.length)
@@ -7502,9 +8139,9 @@ async function runTransactionalDown(params) {
     const limits = migration.downExecution;
     if (wrap && dialect === "postgres" && limits !== undefined) {
       if ((limits.lockTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect9({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
       if ((limits.statementTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect9({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
     }
     if (migration.desiredState !== undefined)
       assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
@@ -7533,7 +8170,7 @@ async function runTransactionalDown(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError32({
+    throw new VibeError35({
       code: "VIBE_MIGRATION",
       message: `rollback of "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name, ...timeoutDiagnostic({ error }) },
@@ -7616,7 +8253,7 @@ async function runNonTransactionalDown(params) {
           values: [marks ? `${INFLIGHT_PREFIX}${index}` : error instanceof Error ? error.message : String(error), migration.name]
         });
       } catch {}
-      throw new VibeError32({
+      throw new VibeError35({
         code: "VIBE_MIGRATION",
         message: `rollback of "${migration.name}" failed at down statement ${index + 1} of ${downSql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running the rollback resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeoutDiagnostic({ error }) },
@@ -7643,11 +8280,11 @@ async function runTransactional(params) {
     const limits = migration.execution;
     if (wrap && dialect === "postgres" && limits !== undefined) {
       if ((limits.lockTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect9({ dialect }), setting: "lock_timeout", milliseconds: limits.lockTimeoutMs, local: true }).text });
       if ((limits.statementTimeoutMs ?? 0) > 0)
-        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect7({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
+        await executor({ text: renderMigrationSessionSet({ dialect: getSqlDialect9({ dialect }), setting: "statement_timeout", milliseconds: limits.statementTimeoutMs, local: true }).text });
     }
-    await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
+    await assertForwardStart({ executor, dialect, migration, external: params.external, ...params.probe === undefined ? {} : { probe: params.probe } });
     await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.from, inTransaction: true, requireInstalledRls: true });
@@ -7657,7 +8294,7 @@ async function runTransactional(params) {
       statementIndex += 1;
     }
     if (migration.desiredState !== undefined)
-      assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+      assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, external: params.external, removals: comparisonRemovals({ migration, external: params.external }), dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     if (migration.rls !== undefined)
       await introspectPostgres({ executor, rlsSchema: migration.rls.to, inTransaction: true, requireInstalledRls: true });
     await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
@@ -7678,7 +8315,7 @@ async function runTransactional(params) {
     } else {
       await cleanupSelfManagedFailure({ executor });
     }
-    throw new VibeError32({
+    throw new VibeError35({
       code: "VIBE_MIGRATION",
       message: `migration "${migration.name}" failed: ${error instanceof Error ? error.message : String(error)}`,
       meta: { migration: migration.name },
@@ -7701,9 +8338,9 @@ async function runNonTransactional(params) {
   await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
   if (insertRecord) {
     if (migration.desiredState !== undefined) {
-      await assertForwardStart({ executor, dialect, migration, ...params.probe === undefined ? {} : { probe: params.probe } });
+      await assertForwardStart({ executor, dialect, migration, external: params.external, ...params.probe === undefined ? {} : { probe: params.probe } });
       if (migration.sql.length === 0)
-        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, external: params.external, removals: comparisonRemovals({ migration, external: params.external }), dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
     }
     if (migration.moduleOrigin !== undefined)
       await insertModuleJournal({ executor, dialect, migration, index: 0, complete: false });
@@ -7726,7 +8363,7 @@ async function runNonTransactional(params) {
       const state = await establishOperationState({ executor, dialect, operation });
       if (state === "satisfied") {
         if (start + 1 === migration.sql.length && migration.desiredState !== undefined)
-          assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+          assertMigrationState({ report: await verifyMigrationTransition({ executor, dialect, from: migration.desiredState.from, to: migration.desiredState.to, external: params.external, removals: comparisonRemovals({ migration, external: params.external }), ...params.probe === undefined ? {} : { probe: params.probe } }) });
         if (start + 1 === migration.sql.length)
           await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
         await checkpoint(start + 1);
@@ -7756,7 +8393,7 @@ async function runNonTransactional(params) {
       }
       await executeStatement({ executor, statement: migration.sql[index], dialect });
       if (index === migration.sql.length - 1 && migration.desiredState !== undefined)
-        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, removals: migration.desiredState.unmanagedRemovals, dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
+        assertMigrationState({ report: await verifyMigrationTransition({ executor, from: migration.desiredState.from, to: migration.desiredState.to, external: params.external, removals: comparisonRemovals({ migration, external: params.external }), dialect, ...params.probe === undefined ? {} : { probe: params.probe } }) });
       if (index === migration.sql.length - 1)
         await assertApplicationModuleState({ executor, origins: params.moduleOrigins, probe: params.probe });
       if (atomic) {
@@ -7774,7 +8411,7 @@ async function runNonTransactional(params) {
       } catch {}
       const sqlState = sqlStateOf(error);
       const timeout = sqlState === "55P03" ? "lock-timeout" : sqlState === "57014" ? "statement-timeout" : undefined;
-      throw new VibeError32({
+      throw new VibeError35({
         code: "VIBE_MIGRATION",
         message: timeout === "lock-timeout" ? `migration "${migration.name}" gave up waiting for a lock at statement ${index + 1} of ${migration.sql.length} (lock_timeout ${String(execution?.lockTimeoutMs ?? 0)}ms, SQLSTATE 55P03). Another session holds a conflicting lock; inspect the declared operation before retrying.` : timeout === "statement-timeout" ? `migration "${migration.name}" exceeded its statement_timeout at statement ${index + 1} of ${migration.sql.length} (${String(execution?.statementTimeoutMs ?? 0)}ms, SQLSTATE 57014). Inspect the declared operation before retrying.` : `migration "${migration.name}" failed at statement ${index + 1} of ${migration.sql.length}: ${error instanceof Error ? error.message : String(error)}. ${marks ? "The statement outcome is unknown; inspect its effects before resolving or retrying." : "Progress is recorded; re-running applyMigrations resumes from this statement."}`,
         meta: { migration: migration.name, statementIndex: index, ...marks ? { outcome: "unknown" } : {}, ...timeout === undefined ? {} : { reason: timeout, sqlState } },
@@ -7785,7 +8422,7 @@ async function runNonTransactional(params) {
       await checkpoint(index + 1);
   }
   if (migration.moduleOrigin !== undefined) {
-    assertMigrationState({ report: await verifyMigrationState({ executor, dialect, expected: migration.desiredState.to }) });
+    assertMigrationState({ report: await verifyMigrationState({ executor, dialect, expected: migration.desiredState.to, external: params.external }) });
     await completeModuleJournal({ executor, dialect, migration });
   }
 }
@@ -7802,7 +8439,7 @@ async function acquireLock(params) {
     });
     const acquired = Number(rows[0]?.vibe_lock) === 1;
     if (!acquired) {
-      throw new VibeError32({
+      throw new VibeError35({
         code: "VIBE_MIGRATION",
         message: `could not acquire the migration lock ('${MYSQL_LOCK_NAME}') within ${MYSQL_LOCK_TIMEOUT_SECONDS}s \u2014 another migration run is in progress`,
         meta: { lock: MYSQL_LOCK_NAME }
@@ -7837,7 +8474,7 @@ function uncertainStatement(params) {
   const subject = direction === "down" ? `rollback of "${migration}"` : `migration "${migration}"`;
   const position = `${direction === "down" ? "down statement" : "statement"} ${index + 1} of ${statements.length}`;
   const why = dialect === "mysql" ? "MySQL commits every statement on its own, so nothing outside the statement records whether it finished." : "That statement declares no operation whose effect recovery can read back from the catalog.";
-  return new VibeError32({
+  return new VibeError35({
     code: "VIBE_MIGRATION",
     message: `${subject} was interrupted while ${position} was running. ${why} ` + "It may or may not have committed, and replaying it could apply it twice, so VibeORM stops here instead of guessing. " + 'Inspect what that statement did to the database, then follow "Recovering from a stopped migration" in docs/migrations.md: ' + `clear the \`error\` column of this migration's journal row if the statement did NOT land, set \`statement_index\` to ${direction === "down" ? -(index + 2) : index + 1} if it DID, ` + "or finish the whole migration by hand and record that with `vibeorm migrate resolve --applied`. " + `The statement was: ${statements[index].slice(0, 200)}`,
     meta: {
@@ -7855,7 +8492,7 @@ function assertExecutable(params) {
   if (execution === undefined || isDefaultExecution({ execution }))
     return;
   if (dialect !== "postgres") {
-    throw new VibeError32({
+    throw new VibeError35({
       code: "VIBE_UNSUPPORTED_CAPABILITY",
       message: `migration "${migration.name}" declares explicit execution semantics (transaction: "${execution.transaction}"), which only the postgres runner implements \u2014 ${dialect} has no separate nontransactional regime to opt into`,
       meta: { reason: "nontransactional-unsupported", dialect, migration: migration.name, feature: "nontransactionalMigrations" }
@@ -7878,7 +8515,7 @@ async function withSessionLimits(params) {
   const statement = execution?.statementTimeoutMs ?? 0;
   if (dialect !== "postgres" || lock === 0 && statement === 0)
     return params.run();
-  const sqlDialect = getSqlDialect7({ dialect });
+  const sqlDialect = getSqlDialect9({ dialect });
   const previous = (await executor({ text: renderMigrationSessionRead({ dialect: sqlDialect }).text, values: [] }))[0];
   if (lock > 0)
     await executor({ text: renderMigrationSessionSet({ dialect: sqlDialect, setting: "lock_timeout", milliseconds: lock }).text });
@@ -7931,7 +8568,7 @@ function assertChecksumMatches(params) {
   const actual = checksumOf({ migration });
   if (stored === actual)
     return;
-  throw new VibeError32({
+  throw new VibeError35({
     code: "VIBE_MIGRATION",
     message: `checksum mismatch for migration "${migration.name}" \u2014 its SQL changed after it was applied (recorded ${stored.slice(0, 12)}\u2026, current ${actual.slice(0, 12)}\u2026)`,
     meta: { migration: migration.name, recorded: stored, current: actual }
@@ -7942,7 +8579,7 @@ function assertResumable(params) {
   const actual = checksumOf({ migration });
   if (stored.checksum === actual)
     return;
-  throw new VibeError32({
+  throw new VibeError35({
     code: "VIBE_MIGRATION",
     message: `migration "${migration.name}" is partially applied (${stored.statementIndex} statement(s) done) and its SQL has CHANGED since \u2014 refusing to resume; restore the original SQL or repair with resolveMigration`,
     meta: {
@@ -7962,7 +8599,7 @@ function assertDistinctMigrationNames(params) {
   const names = new Set;
   for (const migration of params.migrations) {
     if (names.has(migration.name))
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Duplicate migration file identity "${migration.name}"`, meta: { reason: "history-duplicate-file", migration: migration.name } });
     names.add(migration.name);
   }
 }
@@ -7970,15 +8607,15 @@ function assertCompleteHistory(params) {
   const byName = new Map(params.migrations.map((migration) => [migration.name, migration]));
   for (const name of params.recorded.keys()) {
     if (!byName.has(name))
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Recorded migration "${name}" has no file in the complete chain`, meta: { reason: "history-unknown-file", migration: name } });
   }
   let index = 0;
   for (const [name, stored] of params.recorded) {
     const migration = params.migrations[index];
     if (migration?.name !== name)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: "Recorded migration order is not a prefix of the supplied complete chain", meta: { reason: "history-order-conflict", migration: name, expected: migration?.name, position: index } });
     if (stored.statementIndex >= 0 && !isCompleteRecord({ dialect: params.dialect, migration, stored }) && index !== params.recorded.size - 1)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Partial migration "${name}" precedes later recorded work`, meta: { reason: "history-partial-not-last", migration: name } });
     index++;
   }
 }
@@ -7987,16 +8624,16 @@ async function assertApplyHistory(params) {
   const byName = new Map(migrations.map((migration) => [migration.name, migration]));
   for (const [name, stored] of recorded) {
     if (stored.statementIndex < 0) {
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" is mid-rollback; finish or resolve it before applying`, meta: { reason: "history-rolling-back", migration: name, statementIndex: stored.statementIndex } });
     }
     const migration = byName.get(name);
     if (migration === undefined) {
       if (stored.error !== undefined)
-        throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
+        throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error but no supplied file`, meta: { reason: "history-unknown-dirty", migration: name } });
       continue;
     }
     if (isCompleteRecord({ dialect, migration, stored }) && stored.error !== undefined)
-      throw new VibeError32({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
+      throw new VibeError35({ code: "VIBE_MIGRATION", message: `Migration "${name}" has an unresolved journal error`, meta: { reason: "history-dirty", migration: name } });
     if (isCompleteRecord({ dialect, migration, stored }))
       assertChecksumMatches({ migration, stored: stored.checksum });
     else
@@ -8021,10 +8658,10 @@ async function assertApplyHistory(params) {
   }
 }
 function q5(dialect, name) {
-  return getSqlDialect7({ dialect }).quoteIdent({ name });
+  return getSqlDialect9({ dialect }).quoteIdent({ name });
 }
 function ph(dialect, index) {
-  return getSqlDialect7({ dialect }).placeholder({ index });
+  return getSqlDialect9({ dialect }).placeholder({ index });
 }
 
 // packages/migrate/src/fs.ts
@@ -8032,7 +8669,7 @@ function absent(error) {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
 }
 function failure(params) {
-  return new VibeError33({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
+  return new VibeError36({ code: "VIBE_MIGRATION", message: `Cannot read migration file ${params.path}`, meta: { reason: "migration-file-unreadable", path: params.path }, cause: params.cause });
 }
 async function optionalFile(params) {
   return readFile(params.path, "utf-8").catch((cause) => {
@@ -8046,13 +8683,13 @@ function rlsMetadata(params) {
     const metadata = JSON.parse(params.text);
     const strings = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
     if (metadata?.version !== 1 || typeof metadata.destructive !== "boolean" || metadata.rls === undefined || !strings(metadata.securityChanges) || !strings(metadata.downSecurityChanges) || metadata.sqlChecksum !== migrationChecksum({ sql: params.migration.sql }) || metadata.downChecksum !== migrationChecksum({ sql: params.migration.downSql ?? [] })) {
-      throw new VibeError33({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
+      throw new VibeError36({ code: "VIBE_MIGRATION", message: "Invalid native RLS metadata" });
     }
     assertValidSchemaIR4({ schema: metadata.rls.from });
     assertValidSchemaIR4({ schema: metadata.rls.to });
     return { ...params.migration, rls: metadata.rls, destructive: metadata.destructive, securityChanges: metadata.securityChanges, downSecurityChanges: metadata.downSecurityChanges };
   }).catch((cause) => {
-    throw new VibeError33({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
+    throw new VibeError36({ code: "VIBE_MIGRATION", message: `Invalid native RLS metadata for migration "${params.migration.name}"`, meta: { reason: "rls-migration-metadata-invalid", migration: params.migration.name }, cause });
   });
 }
 async function loadMigrationFiles(params) {
@@ -8085,13 +8722,17 @@ async function loadMigrationFiles(params) {
     const desired = await optionalFile({ path: join(directory, DESIRED_STATE_METADATA.filename) });
     if (desired !== undefined) {
       const pending = await Promise.resolve().then(() => isUnfinalizedDesiredState({ text: desired })).catch((cause) => {
-        throw new VibeError33({ code: "VIBE_MIGRATION", message: `Malformed desired state for ${name}`, meta: { reason: "desired-state-invalid", migration: name }, cause });
+        throw new VibeError36({ code: "VIBE_MIGRATION", message: `Malformed desired state for ${name}`, meta: { reason: "desired-state-invalid", migration: name }, cause });
       });
       migration = pending ? { ...migration, desiredStatePending: true } : { ...migration, desiredState: parseDesiredStateSidecar({ text: desired, migration: name }) };
     }
     const origin = await optionalFile({ path: join(directory, MODULE_ORIGIN_METADATA.filename) });
     if (origin !== undefined)
       migration = restoreModuleMigration({ migration, origin: parseModuleOrigin({ text: origin }) });
+    const adoption = await optionalFile({ path: join(directory, MODULE_ADOPTION_METADATA.filename) });
+    if (adoption !== undefined)
+      migration = { ...migration, moduleAdoption: parseModuleAdoption({ text: adoption }) };
+    assertModuleAdoption({ migration });
     migrations.push(migration);
   }
   return migrations;
@@ -8102,4 +8743,4 @@ export {
   splitSqlStatements
 };
 
-//# debugId=B0F3289A0E0F6E5B64756E2164756E21
+//# debugId=000F8CFDEDF957F264756E2164756E21