@vibeorm/schema 2.4.0 → 3.0.0

package/dist/index.js

@@ -1,85 +1,4 @@
 // @bun
-// packages/schema/src/ir.ts
-var DIALECTS = ["postgres", "sqlite", "mysql"];
-function providerToDialect(params) {
-  const { provider } = params;
-  switch (provider) {
-    case "postgresql":
-    case "pglite":
-      return "postgres";
-    case "sqlite":
-      return "sqlite";
-    case "mysql":
-      return "mysql";
-  }
-}
-function isEnumType(fieldType) {
-  return typeof fieldType === "object" && "enum" in fieldType;
-}
-function fieldTypeIdentity(params) {
-  const { type } = params;
-  return isEnumType(type) ? `enum:${type.enum}` : type;
-}
-var ENUM_STORAGES = ["database", "string"];
-function enumStorageOf(params) {
-  return params.enumDef.storage ?? "database";
-}
-// packages/schema/src/predicate.ts
-var PREDICATE_COMPARISON_OPS = [
-  "eq",
-  "ne",
-  "gt",
-  "gte",
-  "lt",
-  "lte"
-];
-function isPredicateFieldRef(operand) {
-  return operand.kind === "field";
-}
-function predicateFieldNames(params) {
-  const seen = new Set;
-  const walk = (node) => {
-    switch (node.kind) {
-      case "compare":
-        seen.add(node.left.name);
-        if (isPredicateFieldRef(node.right))
-          seen.add(node.right.name);
-        return;
-      case "inList":
-      case "isNull":
-        seen.add(node.field.name);
-        return;
-      case "and":
-      case "or":
-        for (const operand of node.operands)
-          walk(operand);
-        return;
-      case "not":
-        walk(node.operand);
-        return;
-    }
-  };
-  walk(params.predicate);
-  return [...seen];
-}
-function predicateKey(params) {
-  const encode = (node) => {
-    switch (node.kind) {
-      case "compare":
-        return `cmp(${node.op},${node.left.name},${isPredicateFieldRef(node.right) ? `f:${node.right.name}` : `v:${typeof node.right.value}:${String(node.right.value)}`})`;
-      case "inList":
-        return `in${node.negate === true ? "!" : ""}(${node.field.name},[${node.values.map((entry) => `${typeof entry.value}:${String(entry.value)}`).join("|")}])`;
-      case "isNull":
-        return `null${node.negate === true ? "!" : ""}(${node.field.name})`;
-      case "and":
-      case "or":
-        return `${node.kind}(${node.operands.map(encode).join(",")})`;
-      case "not":
-        return `not(${encode(node.operand)})`;
-    }
-  };
-  return encode(params.predicate);
-}
 // packages/schema/src/errors.ts
 var VIBE_ERROR_CODES = [
   "VIBE_NOT_FOUND",
@@ -100,6 +19,7 @@ var VIBE_ERROR_CODES = [
   "VIBE_RLS_CONTEXT",
   "VIBE_PERMISSION_DENIED",
   "VIBE_ADAPTER",
+  "VIBE_ADAPTER_CLOSED",
   "VIBE_INTERNAL"
 ];
 
@@ -223,10 +143,206 @@ class ReadOnlyClientError extends VibeError {
   }
 }
 
+// packages/schema/src/physical-names.ts
+var IDENTIFIER_LIMITS = Object.freeze({
+  postgres: { max: 63, unit: "bytes" },
+  mysql: { max: 64, unit: "characters" },
+  sqlite: undefined
+});
+var ENCODER = new TextEncoder;
+function identifierLength(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  return limit?.unit === "bytes" ? ENCODER.encode(params.name).length : [...params.name].length;
+}
+function cutIdentifier(params) {
+  let out = "";
+  let used = 0;
+  for (const char of params.name) {
+    const size = params.unit === "bytes" ? ENCODER.encode(char).length : 1;
+    if (used + size > params.length)
+      break;
+    out += char;
+    used += size;
+  }
+  return out;
+}
+function fitDefaultName(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  if (limit === undefined)
+    return `${params.prefix}${params.suffix}`;
+  const room = limit.max - identifierLength({ name: params.suffix, dialect: params.dialect });
+  if (identifierLength({ name: params.prefix, dialect: params.dialect }) <= room)
+    return `${params.prefix}${params.suffix}`;
+  return `${cutIdentifier({ name: params.prefix, length: room, unit: limit.unit })}${params.suffix}`;
+}
+function assertIdentifierFits(params) {
+  const limit = IDENTIFIER_LIMITS[params.dialect];
+  if (limit === undefined)
+    return;
+  const length = identifierLength({ name: params.name, dialect: params.dialect });
+  if (length <= limit.max)
+    return;
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `${params.what} "${params.name}" is ${length} ${limit.unit} \u2014 ${params.dialect} keeps at most ${limit.max}; the created object would never carry this name and migrations could not converge. ${params.remedy}`,
+    meta: { name: params.name, dialect: params.dialect, length, max: limit.max }
+  });
+}
+function defaultIndexName(params) {
+  return fitDefaultName({
+    prefix: `${params.table}_${params.columns.join("_")}`,
+    suffix: params.unique ? "_key" : "_idx",
+    dialect: params.dialect
+  });
+}
+function defaultForeignKeyName(params) {
+  return fitDefaultName({ prefix: `${params.table}_${params.columns.join("_")}`, suffix: "_fkey", dialect: params.dialect });
+}
+function defaultPrimaryKeyName(params) {
+  return fitDefaultName({ prefix: params.table, suffix: "_pkey", dialect: params.dialect });
+}
+function implicitJoinTableObjectNames(params) {
+  return {
+    uniqueIndex: `${params.table}_AB_unique`,
+    indexB: `${params.table}_B_index`,
+    foreignKeyA: `${params.table}_A_fkey`,
+    foreignKeyB: `${params.table}_B_fkey`
+  };
+}
+function postgresGeneratedObjectName(params) {
+  const limit = IDENTIFIER_LIMITS.postgres;
+  const overhead = params.label.length + 2;
+  let chars1 = [...params.name1];
+  let chars2 = [...params.name2];
+  const bytes = (chars) => ENCODER.encode(chars.join("")).length;
+  while (bytes(chars1) + bytes(chars2) + overhead > limit.max) {
+    if (bytes(chars1) > bytes(chars2))
+      chars1 = chars1.slice(0, -1);
+    else
+      chars2 = chars2.slice(0, -1);
+  }
+  return `${chars1.join("")}_${chars2.join("")}_${params.label}`;
+}
+
+// packages/schema/src/namespaces.ts
+var SQL_NAMESPACES = Object.freeze({
+  postgres: "public",
+  sqlite: "main",
+  private: Object.freeze(["_vibeorm_shadow", "_vibe_shadow"])
+});
+function sqlNamespaceIssue(params) {
+  const { namespace } = params;
+  if (typeof namespace !== "string" || namespace.trim().length === 0 || namespace.includes("\x00"))
+    return "Namespace must be a non-empty identifier without NUL bytes";
+  if (identifierLength({ name: namespace, dialect: "postgres" }) > IDENTIFIER_LIMITS.postgres.max)
+    return "PostgreSQL namespace exceeds its identifier byte limit";
+  if (namespace === "information_schema" || namespace.startsWith("pg_") || SQL_NAMESPACES.private.includes(namespace))
+    return "System and private VibeORM namespaces cannot be declared";
+  if (params.allowPublic === false && namespace === SQL_NAMESPACES.postgres)
+    return "A fixed package namespace must be non-public; omit namespace for a legacy public artifact";
+  return;
+}
+function assertSqlNamespace(params) {
+  if (params.dialect !== "postgres")
+    throw unsupportedCapability({ dialect: params.dialect, feature: "fixedNamespaces" });
+  const issue = sqlNamespaceIssue(params);
+  if (issue !== undefined)
+    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: issue, meta: { rule: "namespace", namespace: params.namespace } });
+}
+function qualifiedSqlName(params) {
+  return { namespace: params.namespace ?? params.defaultNamespace ?? SQL_NAMESPACES.postgres, name: params.name };
+}
+// packages/schema/src/capabilities.ts
+var POSTGRES_CAPABILITIES = Object.freeze({
+  fixedNamespaces: true,
+  externalObjects: true,
+  indexOperatorClasses: true,
+  exclusionConstraints: true,
+  exclusionExtensions: Object.freeze(["btree_gist"]),
+  checkNormalization: "rollback",
+  nativeRowLevelSecurity: true,
+  returning: true,
+  scalarArrays: true,
+  nativeEnums: true,
+  ilike: true,
+  lateralJoin: true,
+  distinctOn: true,
+  partialIndexes: true,
+  conflictTargetConstraint: true,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: true,
+  orderByNulls: true,
+  fullTextEngines: Object.freeze(["bm25", "tsvector"]),
+  rowLockStrengths: Object.freeze(["update", "noKeyUpdate", "share", "keyShare"]),
+  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
+  advisoryLocks: true,
+  timeOfDayTypes: Object.freeze(["time", "timetz"])
+});
+var SQLITE_CAPABILITIES = Object.freeze({
+  fixedNamespaces: false,
+  externalObjects: false,
+  indexOperatorClasses: false,
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "sourceText",
+  nativeRowLevelSecurity: false,
+  returning: true,
+  scalarArrays: false,
+  nativeEnums: false,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: true,
+  conflictTargetConstraint: false,
+  transactionalDdl: true,
+  createManyAndReturn: true,
+  jsonColumnType: false,
+  orderByNulls: true,
+  fullTextEngines: Object.freeze(["fts5"]),
+  rowLockStrengths: Object.freeze([]),
+  rowLockWaitPolicies: Object.freeze([]),
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze([])
+});
+var MYSQL_CAPABILITIES = Object.freeze({
+  fixedNamespaces: false,
+  externalObjects: false,
+  indexOperatorClasses: false,
+  exclusionConstraints: false,
+  exclusionExtensions: Object.freeze([]),
+  checkNormalization: "temporary",
+  nativeRowLevelSecurity: false,
+  returning: false,
+  scalarArrays: false,
+  nativeEnums: true,
+  ilike: false,
+  lateralJoin: false,
+  distinctOn: false,
+  partialIndexes: false,
+  conflictTargetConstraint: false,
+  transactionalDdl: false,
+  createManyAndReturn: false,
+  jsonColumnType: true,
+  orderByNulls: false,
+  fullTextEngines: Object.freeze(["fulltext"]),
+  rowLockStrengths: Object.freeze(["update", "share"]),
+  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
+  advisoryLocks: false,
+  timeOfDayTypes: Object.freeze(["time"])
+});
+var DIALECT_CAPABILITIES = Object.freeze({
+  postgres: POSTGRES_CAPABILITIES,
+  sqlite: SQLITE_CAPABILITIES,
+  mysql: MYSQL_CAPABILITIES
+});
+
 // packages/schema/src/migration-objects.ts
 function sqlObjectKey(params) {
   const object = params.identity;
   switch (object.kind) {
+    case "namespace":
+      return JSON.stringify([object.kind, object.name]);
     case "table":
     case "view":
     case "sequence":
@@ -246,6 +362,12 @@ function sqlObjectKey(params) {
       return JSON.stringify([object.kind, object.table.namespace, object.table.name, object.column]);
   }
 }
+function sqlObjectNamespace(params) {
+  const identity = params.identity;
+  if (identity.kind === "namespace")
+    return identity.name;
+  return "table" in identity ? identity.table.namespace : identity.name.namespace;
+}
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -256,6 +378,8 @@ function isSqlObjectIdentity(value) {
   if (!record(value))
     return false;
   switch (value.kind) {
+    case "namespace":
+      return typeof value.name === "string" && value.name.length > 0;
     case "table":
     case "view":
     case "sequence":
@@ -277,24 +401,271 @@ function isSqlObjectIdentity(value) {
       return false;
   }
 }
-function isSqlObjectDefinition(value) {
-  return record(value) && (value.format === "catalog-v1" || value.format === "catalog-v2") && isSqlObjectIdentity(value.identity) && record(value.facts) && Object.keys(value.facts).length > 0 && Object.values(value.facts).every((fact) => fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")) && Array.isArray(value.dependencies) && value.dependencies.every(isSqlObjectIdentity);
+function isSqlObjectDefinition(value) {
+  return record(value) && (value.format === "catalog-v1" || value.format === "catalog-v2") && isSqlObjectIdentity(value.identity) && record(value.facts) && Object.keys(value.facts).length > 0 && Object.values(value.facts).every((fact) => fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")) && Array.isArray(value.dependencies) && value.dependencies.every(isSqlObjectIdentity);
+}
+function qualifiedNameIssue(params) {
+  if (!record(params.value))
+    return { path: params.path, expected: "qualified SQL name { namespace, name }" };
+  const member = typeof params.value.namespace !== "string" || params.value.namespace.length === 0 ? "namespace" : "name";
+  return { path: `${params.path}.${member}`, expected: "non-empty string" };
+}
+function identityIssue(params) {
+  const { value, path } = params;
+  if (!record(value))
+    return { path, expected: "SQL object identity" };
+  switch (value.kind) {
+    case "namespace":
+      return { path: `${path}.name`, expected: "non-empty namespace string" };
+    case "table":
+    case "view":
+    case "sequence":
+    case "postgresExtension":
+    case "enum":
+      return qualifiedNameIssue({ value: value.name, path: `${path}.name` });
+    case "function": {
+      if (!name(value.name))
+        return qualifiedNameIssue({ value: value.name, path: `${path}.name` });
+      if (!Array.isArray(value.argumentTypes))
+        return { path: `${path}.argumentTypes`, expected: "array of qualified SQL type names" };
+      const index = value.argumentTypes.findIndex((entry) => !name(entry));
+      return qualifiedNameIssue({ value: value.argumentTypes[index], path: `${path}.argumentTypes[${index}]` });
+    }
+    case "index":
+    case "trigger":
+    case "constraint":
+    case "column":
+    case "columnDefault":
+    case "generatedColumn": {
+      if (!name(value.table))
+        return qualifiedNameIssue({ value: value.table, path: `${path}.table` });
+      if (value.kind === "column" || value.kind === "columnDefault" || value.kind === "generatedColumn")
+        return { path: `${path}.column`, expected: "non-empty column name" };
+      if (typeof value.name !== "string" || value.name.length === 0)
+        return { path: `${path}.name`, expected: "non-empty object name" };
+      return { path: `${path}.constraintType`, expected: ["check", "foreignKey", "exclusion", "unique", "primaryKey"] };
+    }
+    default:
+      return { path: `${path}.kind`, expected: ["namespace", "table", "view", "sequence", "postgresExtension", "enum", "function", "index", "trigger", "constraint", "column", "columnDefault", "generatedColumn"] };
+  }
+}
+function definitionIssue(params) {
+  const { value, path } = params;
+  if (!record(value))
+    return { path, expected: "independent SQL object definition" };
+  if (value.format !== "catalog-v1" && value.format !== "catalog-v2")
+    return { path: `${path}.format`, expected: ["catalog-v1", "catalog-v2"] };
+  if (!isSqlObjectIdentity(value.identity))
+    return identityIssue({ value: value.identity, path: `${path}.identity` });
+  if (!record(value.facts) || Object.keys(value.facts).length === 0)
+    return { path: `${path}.facts`, expected: "non-empty serializable catalog facts" };
+  for (const [key, fact] of Object.entries(value.facts)) {
+    if (!(fact === null || typeof fact === "string" || typeof fact === "boolean" || typeof fact === "number" && Number.isFinite(fact) || Array.isArray(fact) && fact.every((entry) => typeof entry === "string")))
+      return { path: `${path}.facts.${key}`, expected: "string, finite number, boolean, null or string array" };
+  }
+  if (!Array.isArray(value.dependencies))
+    return { path: `${path}.dependencies`, expected: "array of SQL object identities" };
+  const index = value.dependencies.findIndex((entry) => !isSqlObjectIdentity(entry));
+  return identityIssue({ value: value.dependencies[index], path: `${path}.dependencies[${index}]` });
+}
+function invalidDeclaration(params) {
+  const expected = typeof params.expected === "string" ? params.expected : params.expected.join(", ");
+  throw new VibeError({
+    code: "VIBE_SCHEMA_INVALID",
+    message: `Invalid migration-only object declaration at ${params.path}; expected ${expected}`,
+    meta: { path: params.path, expected: params.expected, ...params.id === undefined ? {} : { id: params.id } }
+  });
+}
+function assertMigrationObjects(params) {
+  if (!Array.isArray(params.objects))
+    invalidDeclaration({ path: "migrationObjects", expected: "array" });
+  const ids = new Set;
+  const owners = new Set;
+  for (const [index, value] of params.objects.entries()) {
+    const object = value;
+    const path = `migrationObjects[${index}]`;
+    if (!record(object))
+      invalidDeclaration({ path, expected: "object" });
+    if (typeof object.id !== "string" || object.id.length === 0)
+      invalidDeclaration({ path: `${path}.id`, expected: "non-empty string" });
+    const id = object.id;
+    if (!["postgres", "sqlite", "mysql"].includes(String(object.dialect)))
+      invalidDeclaration({ path: `${path}.dialect`, expected: ["postgres", "sqlite", "mysql"], id });
+    const identity = object.identity;
+    if (!isSqlObjectIdentity(identity))
+      invalidDeclaration({ ...identityIssue({ value: identity, path: `${path}.identity` }), id });
+    for (const member of ["create", "drop"]) {
+      const statements = object[member];
+      if (!Array.isArray(statements))
+        invalidDeclaration({ path: `${path}.${member}`, expected: "array of SQL strings", id });
+      const invalid = statements.findIndex((entry) => typeof entry !== "string");
+      if (invalid !== -1)
+        invalidDeclaration({ path: `${path}.${member}[${invalid}]`, expected: "SQL string", id });
+    }
+    if (!Array.isArray(object.dependsOn))
+      invalidDeclaration({ path: `${path}.dependsOn`, expected: "array of SQL object identities", id });
+    for (const [dependencyIndex, dependency] of object.dependsOn.entries())
+      if (!isSqlObjectIdentity(dependency))
+        invalidDeclaration({ ...identityIssue({ value: dependency, path: `${path}.dependsOn[${dependencyIndex}]` }), id });
+    if (object.expected !== undefined) {
+      if (!isSqlObjectDefinition(object.expected))
+        invalidDeclaration({ ...definitionIssue({ value: object.expected, path: `${path}.expected` }), id });
+      if (sqlObjectKey({ identity: object.expected.identity }) !== sqlObjectKey({ identity }))
+        invalidDeclaration({ path: `${path}.expected.identity`, expected: "the declaration's SQL object identity", id });
+    }
+    const key = sqlObjectKey({ identity });
+    if (ids.has(id) || owners.has(key))
+      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate migration object identity or id", meta: { id, key, path: `${path}.${ids.has(id) ? "id" : "identity"}` } });
+    ids.add(id);
+    owners.add(key);
+  }
+}
+
+// packages/schema/src/index-operator-classes.ts
+function assertIndexOperatorClasses(params) {
+  for (const model of params.schema.models)
+    for (const index of model.indexes)
+      for (const field of index.fields) {
+        if (field.operatorClass === undefined)
+          continue;
+        if (!DIALECT_CAPABILITIES[params.dialect].indexOperatorClasses)
+          throw unsupportedCapability({ dialect: params.dialect, feature: "indexOperatorClasses" });
+        if (index.kind === "unique" && params.physical !== true)
+          throw unsupportedCapability({ dialect: params.dialect, feature: "uniqueIndexOperatorClasses", hint: "custom unique operator classes can change client selector equality" });
+        if (!isSqlObjectIdentity({ kind: "table", name: field.operatorClass }))
+          throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Index operator class must be a qualified SQL name { namespace, name }", meta: { rule: "index-operator-class-identity", model: model.name, field: field.name } });
+      }
+}
+// packages/schema/src/ir.ts
+var DIALECTS = ["postgres", "sqlite", "mysql"];
+function providerToDialect(params) {
+  const { provider } = params;
+  switch (provider) {
+    case "postgresql":
+    case "pglite":
+      return "postgres";
+    case "sqlite":
+      return "sqlite";
+    case "mysql":
+      return "mysql";
+  }
+}
+function isEnumType(fieldType) {
+  return typeof fieldType === "object" && "enum" in fieldType;
+}
+function fieldTypeIdentity(params) {
+  const { type } = params;
+  return isEnumType(type) ? type.namespace === undefined || type.namespace === "public" ? `enum:${type.enum}` : JSON.stringify(["enum", type.namespace, type.enum]) : type;
+}
+var ENUM_STORAGES = ["database", "string"];
+function enumStorageOf(params) {
+  return params.enumDef.storage ?? "database";
+}
+
+// packages/schema/src/module-schema.ts
+function prepareDatabaseModuleSchema(params) {
+  const { schema, module } = params;
+  const namespace = module.namespace;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  if (namespace !== undefined)
+    assertSqlNamespace({ namespace, dialect, allowPublic: false });
+  const expected = namespace ?? SQL_NAMESPACES.postgres;
+  for (const entry of [...schema.models, ...schema.enums]) {
+    if (entry.namespace === undefined)
+      continue;
+    assertSqlNamespace({ namespace: entry.namespace, dialect });
+    if (qualifiedSqlName({ name: entry.dbName ?? entry.name, namespace: entry.namespace }).namespace !== expected)
+      throw new VibeError({ code: "VIBE_CONFIG", message: "Module schema placement differs from its immutable namespace; host configuration cannot remap it", meta: { reason: "module-placement-mismatch", moduleId: module.id, name: entry.name } });
+  }
+  for (const model of schema.models)
+    for (const field of model.fields) {
+      if (!isEnumType(field.type) || field.type.namespace === undefined)
+        continue;
+      assertSqlNamespace({ namespace: field.type.namespace, dialect });
+      if (field.type.namespace !== expected)
+        throw new VibeError({ code: "VIBE_CONFIG", message: "Module enum reference placement differs from its immutable namespace", meta: { reason: "module-placement-mismatch", moduleId: module.id, model: model.name, field: field.name } });
+    }
+  if (namespace === undefined)
+    return schema;
+  const nativeEnums = new Set(schema.enums.filter((entry) => enumStorageOf({ enumDef: entry }) === "database").map((entry) => entry.name));
+  return {
+    ...schema,
+    models: schema.models.map((model) => ({ ...model, namespace, fields: model.fields.map((field) => {
+      const type = field.type;
+      return isEnumType(type) && nativeEnums.has(type.enum) ? { ...field, type: { ...type, namespace } } : field;
+    }) })),
+    enums: schema.enums.map((entry) => enumStorageOf({ enumDef: entry }) === "database" ? { ...entry, namespace } : entry)
+  };
+}
+// packages/schema/src/predicate.ts
+var PREDICATE_COMPARISON_OPS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+function isPredicateFieldRef(operand) {
+  return operand.kind === "field";
 }
-function assertMigrationObjects(params) {
-  if (!Array.isArray(params.objects))
-    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "migrationObjects must be an array" });
-  const ids = new Set;
-  const owners = new Set;
-  for (const object of params.objects) {
-    if (!record(object) || typeof object.id !== "string" || object.id.length === 0 || !["postgres", "sqlite", "mysql"].includes(String(object.dialect)) || !isSqlObjectIdentity(object.identity) || !Array.isArray(object.create) || !object.create.every((sql) => typeof sql === "string") || !Array.isArray(object.drop) || !object.drop.every((sql) => typeof sql === "string") || !Array.isArray(object.dependsOn) || !object.dependsOn.every(isSqlObjectIdentity) || object.expected !== undefined && (!isSqlObjectDefinition(object.expected) || sqlObjectKey({ identity: object.expected.identity }) !== sqlObjectKey({ identity: object.identity }))) {
-      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Invalid migration-only object declaration" });
-    }
-    const key = sqlObjectKey({ identity: object.identity });
-    if (ids.has(object.id) || owners.has(key))
-      throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Duplicate migration object identity or id", meta: { id: object.id, key } });
-    ids.add(object.id);
-    owners.add(key);
-  }
+function predicateFieldNames(params) {
+  const seen = new Set;
+  const walk = (node) => {
+    switch (node.kind) {
+      case "compare":
+        seen.add(node.left.name);
+        if (isPredicateFieldRef(node.right))
+          seen.add(node.right.name);
+        return;
+      case "inList":
+      case "isNull":
+        seen.add(node.field.name);
+        return;
+      case "and":
+      case "or":
+        for (const operand of node.operands)
+          walk(operand);
+        return;
+      case "not":
+        walk(node.operand);
+        return;
+    }
+  };
+  walk(params.predicate);
+  return [...seen];
+}
+function predicateKey(params) {
+  const encode = (node) => {
+    switch (node.kind) {
+      case "compare":
+        return `cmp(${node.op},${node.left.name},${isPredicateFieldRef(node.right) ? `f:${node.right.name}` : `v:${typeof node.right.value}:${String(node.right.value)}`})`;
+      case "inList":
+        return `in${node.negate === true ? "!" : ""}(${node.field.name},[${node.values.map((entry) => `${typeof entry.value}:${String(entry.value)}`).join("|")}])`;
+      case "isNull":
+        return `null${node.negate === true ? "!" : ""}(${node.field.name})`;
+      case "and":
+      case "or":
+        return `${node.kind}(${node.operands.map(encode).join(",")})`;
+      case "not":
+        return `not(${encode(node.operand)})`;
+    }
+  };
+  return encode(params.predicate);
+}
+// packages/schema/src/time-of-day.ts
+var TIME_OF_DAY_NATIVE_TYPE = /^time(tz)?(?:\(\d+\))?$|^time(?:\(\d+\))?with(out)?timezone$/;
+function timeOfDayType(params) {
+  if (params.nativeType === undefined)
+    return;
+  const match = TIME_OF_DAY_NATIVE_TYPE.exec(params.nativeType.toLowerCase().replace(/\s+/g, ""));
+  if (match === null)
+    return;
+  if (match[1] !== undefined)
+    return "timetz";
+  if (match[0].endsWith("withtimezone") && match[2] === undefined)
+    return "timetz";
+  return "time";
 }
 // packages/schema/src/prisma-literal.ts
 var STRING_ESCAPES = {
@@ -407,6 +778,7 @@ function exactDecimalLiteral(params) {
 // packages/schema/src/reserved.ts
 var RESERVED_DELEGATE_NAMES = [
   "findMany",
+  "findPage",
   "findFirst",
   "findUnique",
   "findFirstOrThrow",
@@ -740,160 +1112,6 @@ function implicitJoinTable(params) {
   };
 }
 
-// packages/schema/src/physical-names.ts
-var IDENTIFIER_LIMITS = Object.freeze({
-  postgres: { max: 63, unit: "bytes" },
-  mysql: { max: 64, unit: "characters" },
-  sqlite: undefined
-});
-var ENCODER = new TextEncoder;
-function identifierLength(params) {
-  const limit = IDENTIFIER_LIMITS[params.dialect];
-  return limit?.unit === "bytes" ? ENCODER.encode(params.name).length : [...params.name].length;
-}
-function cutIdentifier(params) {
-  let out = "";
-  let used = 0;
-  for (const char of params.name) {
-    const size = params.unit === "bytes" ? ENCODER.encode(char).length : 1;
-    if (used + size > params.length)
-      break;
-    out += char;
-    used += size;
-  }
-  return out;
-}
-function fitDefaultName(params) {
-  const limit = IDENTIFIER_LIMITS[params.dialect];
-  if (limit === undefined)
-    return `${params.prefix}${params.suffix}`;
-  const room = limit.max - identifierLength({ name: params.suffix, dialect: params.dialect });
-  if (identifierLength({ name: params.prefix, dialect: params.dialect }) <= room)
-    return `${params.prefix}${params.suffix}`;
-  return `${cutIdentifier({ name: params.prefix, length: room, unit: limit.unit })}${params.suffix}`;
-}
-function assertIdentifierFits(params) {
-  const limit = IDENTIFIER_LIMITS[params.dialect];
-  if (limit === undefined)
-    return;
-  const length = identifierLength({ name: params.name, dialect: params.dialect });
-  if (length <= limit.max)
-    return;
-  throw new VibeError({
-    code: "VIBE_SCHEMA_INVALID",
-    message: `${params.what} "${params.name}" is ${length} ${limit.unit} \u2014 ${params.dialect} keeps at most ${limit.max}; the created object would never carry this name and migrations could not converge. ${params.remedy}`,
-    meta: { name: params.name, dialect: params.dialect, length, max: limit.max }
-  });
-}
-function defaultIndexName(params) {
-  return fitDefaultName({
-    prefix: `${params.table}_${params.columns.join("_")}`,
-    suffix: params.unique ? "_key" : "_idx",
-    dialect: params.dialect
-  });
-}
-function defaultForeignKeyName(params) {
-  return fitDefaultName({ prefix: `${params.table}_${params.columns.join("_")}`, suffix: "_fkey", dialect: params.dialect });
-}
-function defaultPrimaryKeyName(params) {
-  return fitDefaultName({ prefix: params.table, suffix: "_pkey", dialect: params.dialect });
-}
-function implicitJoinTableObjectNames(params) {
-  return {
-    uniqueIndex: `${params.table}_AB_unique`,
-    indexB: `${params.table}_B_index`,
-    foreignKeyA: `${params.table}_A_fkey`,
-    foreignKeyB: `${params.table}_B_fkey`
-  };
-}
-function postgresGeneratedObjectName(params) {
-  const limit = IDENTIFIER_LIMITS.postgres;
-  const overhead = params.label.length + 2;
-  let chars1 = [...params.name1];
-  let chars2 = [...params.name2];
-  const bytes = (chars) => ENCODER.encode(chars.join("")).length;
-  while (bytes(chars1) + bytes(chars2) + overhead > limit.max) {
-    if (bytes(chars1) > bytes(chars2))
-      chars1 = chars1.slice(0, -1);
-    else
-      chars2 = chars2.slice(0, -1);
-  }
-  return `${chars1.join("")}_${chars2.join("")}_${params.label}`;
-}
-
-// packages/schema/src/capabilities.ts
-var POSTGRES_CAPABILITIES = Object.freeze({
-  exclusionConstraints: true,
-  exclusionExtensions: Object.freeze(["btree_gist"]),
-  checkNormalization: "rollback",
-  nativeRowLevelSecurity: true,
-  returning: true,
-  scalarArrays: true,
-  nativeEnums: true,
-  ilike: true,
-  lateralJoin: true,
-  distinctOn: true,
-  partialIndexes: true,
-  conflictTargetConstraint: true,
-  transactionalDdl: true,
-  createManyAndReturn: true,
-  jsonColumnType: true,
-  orderByNulls: true,
-  fullTextEngines: Object.freeze(["bm25", "tsvector"]),
-  rowLockStrengths: Object.freeze(["update", "noKeyUpdate", "share", "keyShare"]),
-  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: true
-});
-var SQLITE_CAPABILITIES = Object.freeze({
-  exclusionConstraints: false,
-  exclusionExtensions: Object.freeze([]),
-  checkNormalization: "sourceText",
-  nativeRowLevelSecurity: false,
-  returning: true,
-  scalarArrays: false,
-  nativeEnums: false,
-  ilike: false,
-  lateralJoin: false,
-  distinctOn: false,
-  partialIndexes: true,
-  conflictTargetConstraint: false,
-  transactionalDdl: true,
-  createManyAndReturn: true,
-  jsonColumnType: false,
-  orderByNulls: true,
-  fullTextEngines: Object.freeze(["fts5"]),
-  rowLockStrengths: Object.freeze([]),
-  rowLockWaitPolicies: Object.freeze([]),
-  advisoryLocks: false
-});
-var MYSQL_CAPABILITIES = Object.freeze({
-  exclusionConstraints: false,
-  exclusionExtensions: Object.freeze([]),
-  checkNormalization: "temporary",
-  nativeRowLevelSecurity: false,
-  returning: false,
-  scalarArrays: false,
-  nativeEnums: true,
-  ilike: false,
-  lateralJoin: false,
-  distinctOn: false,
-  partialIndexes: false,
-  conflictTargetConstraint: false,
-  transactionalDdl: false,
-  createManyAndReturn: false,
-  jsonColumnType: true,
-  orderByNulls: false,
-  fullTextEngines: Object.freeze(["fulltext"]),
-  rowLockStrengths: Object.freeze(["update", "share"]),
-  rowLockWaitPolicies: Object.freeze(["wait", "nowait", "skipLocked"]),
-  advisoryLocks: false
-});
-var DIALECT_CAPABILITIES = Object.freeze({
-  postgres: POSTGRES_CAPABILITIES,
-  sqlite: SQLITE_CAPABILITIES,
-  mysql: MYSQL_CAPABILITIES
-});
-
 // packages/schema/src/validate.ts
 var RESERVED_ENUM_NAMES = [
   "sql",
@@ -913,6 +1131,11 @@ var RESERVED_ENUM_NAMES = [
   "UncertainKeys",
   "HasSelectedField",
   "Provided",
+  "SelectionMember",
+  "SelectionValue",
+  "BagKeys",
+  "IncludedRelation",
+  "IncludedCount",
   "ViewDelegateMap",
   "extensionManifest",
   "extensionMounts",
@@ -948,6 +1171,7 @@ var RESERVED_ENUM_NAMES = [
   "SortOrder",
   "SortOrderWithNulls",
   "KeysetToken",
+  "KeysetPage",
   "KeysetOptions",
   "RowLockRequest",
   "JsonValue",
@@ -1025,7 +1249,20 @@ var GENERATED_TYPE_NAMES = {
     "SumAggregateInput",
     "MinAggregateInput",
     "MaxAggregateInput",
+    "CountAggregateHavingInput",
+    "AvgAggregateHavingInput",
+    "SumAggregateHavingInput",
+    "MinAggregateHavingInput",
+    "MaxAggregateHavingInput",
+    "CountAggregateOrderByInput",
+    "AvgAggregateOrderByInput",
+    "SumAggregateOrderByInput",
+    "MinAggregateOrderByInput",
+    "MaxAggregateOrderByInput",
+    "HavingInput",
+    "GroupByOrderByInput",
     "FindManyArgs",
+    "FindPageArgs",
     "FindFirstArgs",
     "FindUniqueArgs",
     "CreateArgs",
@@ -1052,6 +1289,7 @@ var GENERATED_TYPE_NAMES = {
     "AggregateSelection",
     "CountOutput",
     "RelationPayload",
+    "ResolvedSelection",
     "IncludePayload",
     "GetPayload",
     "AggregateResult",
@@ -1193,9 +1431,69 @@ function validateGeneratedNames(params) {
       register({ name: `${declared.name}${suffix}`, owner: `enum "${declared.name}"` });
   }
 }
+function foreignKeyKeys(params) {
+  const distinct = new Set;
+  const repeated = [];
+  for (const fields of params.keys) {
+    if (new Set(fields).size === fields.length)
+      distinct.add(JSON.stringify([...fields].sort()));
+    else
+      repeated.push(fields);
+  }
+  return { distinct, repeated };
+}
+function matchesForeignKey(params) {
+  if (params.keys.distinct.has(JSON.stringify([...params.references].sort())))
+    return true;
+  return params.keys.repeated.some((fields) => fields.length === params.references.length && fields.every((name) => params.references.includes(name)));
+}
+function referencesPartialOnly(params) {
+  const { target, references, schema, lookups } = params;
+  let partial = lookups.partialKeys.get(target);
+  if (partial === undefined) {
+    partial = foreignKeyKeys({ keys: target.indexes.filter((index) => index.kind === "unique" && (index.where !== undefined || index.wherePredicate !== undefined)).map((index) => index.fields.map((field) => field.name)) });
+    lookups.partialKeys.set(target, partial);
+  }
+  if (partial.distinct.size === 0 && partial.repeated.length === 0)
+    return false;
+  if (!matchesForeignKey({ keys: partial, references }))
+    return false;
+  let total = lookups.totalKeys.get(target);
+  if (total === undefined) {
+    total = foreignKeyKeys({ keys: [
+      ...target.fields.filter((field) => field.isId || field.isUnique).map((field) => [field.name]),
+      ...target.primaryKey === undefined ? [] : [target.primaryKey.fields],
+      ...target.indexes.filter((index) => index.kind === "unique" && index.where === undefined && index.wherePredicate === undefined).map((index) => index.fields.map((field) => field.name))
+    ] });
+    lookups.totalKeys.set(target, total);
+  }
+  if (matchesForeignKey({ keys: total, references }))
+    return false;
+  if (lookups.independentTables === undefined) {
+    const tables = new Set;
+    for (const object of schema.migrationObjects ?? []) {
+      const identity = object.identity;
+      if (identity.kind === "index" || identity.kind === "constraint" && (identity.constraintType === "unique" || identity.constraintType === "primaryKey")) {
+        tables.add(JSON.stringify([identity.table.namespace, identity.table.name]));
+      }
+    }
+    lookups.independentTables = tables;
+  }
+  const placement = qualifiedSqlName({ name: target.dbName ?? target.name, namespace: target.namespace });
+  return !lookups.independentTables.has(JSON.stringify([placement.namespace, placement.name]));
+}
 function validateSchemaIR(params) {
   const { schema } = params;
   const issues = [];
+  for (const entry of [...schema.models, ...schema.enums]) {
+    if (entry.namespace === undefined)
+      continue;
+    const issue = sqlNamespaceIssue({ namespace: entry.namespace });
+    if (issue !== undefined)
+      issues.push({ rule: "namespace", message: issue });
+    if (providerToDialect({ provider: schema.datasource.provider }) !== "postgres")
+      issues.push({ rule: "namespace-dialect", message: "Explicit fixed namespaces require PostgreSQL or PGlite" });
+  }
   const modelByName = new Map;
   for (const model of schema.models) {
     if (modelByName.has(model.name)) {
@@ -1254,8 +1552,18 @@ function validateSchemaIR(params) {
       });
     }
   }
+  const fieldsByModel = new Map;
+  for (const model of schema.models) {
+    const fields = new Map;
+    for (const field of model.fields)
+      if (!fields.has(field.name))
+        fields.set(field.name, field);
+    fieldsByModel.set(model, fields);
+  }
+  const lookups = { fieldsByModel, partialKeys: new Map, totalKeys: new Map };
+  const postgres = providerToDialect({ provider: schema.datasource.provider }) === "postgres";
   for (const model of schema.models) {
-    validateModel({ model, modelByName, enumByName, issues });
+    validateModel({ model, modelByName, enumByName, issues, schema, lookups, postgres });
   }
   for (const model of schema.models) {
     for (const relation of model.relations) {
@@ -1300,19 +1608,11 @@ function validateSchemaIR(params) {
     }
   }
   for (const model of schema.models) {
-    const fieldNames = new Set(model.fields.map((field) => field.name));
-    const defaultKeys = new Set;
-    if (model.primaryKey !== undefined && model.primaryKey.fields.length > 1 && model.primaryKey.clientName === undefined) {
-      defaultKeys.add(model.primaryKey.fields.join("_"));
-    }
-    for (const index of model.indexes) {
-      if (index.kind === "unique" && index.where === undefined && index.fields.length > 1 && index.clientName === undefined) {
-        defaultKeys.add(index.fields.map((field) => field.name).join("_"));
-      }
-    }
-    const seenSelectorNames = new Set;
+    const fieldNames = fieldsByModel.get(model);
+    const seenSelectorNames = new Map;
+    const addressable = (names) => names.every((name) => fieldNames.get(name)?.isUnsupported !== true);
     const checkSelectorName = (params) => {
-      const { clientName, fieldCount, where, isUnique, site } = params;
+      const { clientName, fields, where, isUnique, site } = params;
       if (!isUnique) {
         issues.push({
           rule: "client-name-non-unique",
@@ -1329,7 +1629,7 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldCount < 2) {
+      if (fields.length < 2) {
         issues.push({
           rule: "client-name-single-field",
           message: `name: ("${clientName}") on a single-field ${site} of "${model.name}" \u2014 the field itself is the selector; name: applies to compound groups only`,
@@ -1337,7 +1637,9 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      if (fieldNames.has(clientName) || defaultKeys.has(clientName) || seenSelectorNames.has(clientName)) {
+      const tuple = JSON.stringify(fields);
+      const previous = seenSelectorNames.get(clientName);
+      if (fieldNames.has(clientName) || previous !== undefined && previous !== tuple) {
         issues.push({
           rule: "client-name-collision",
           message: `name: ("${clientName}") on "${model.name}" collides with a field or another unique selector \u2014 WhereUniqueInput keys must be unambiguous`,
@@ -1345,22 +1647,22 @@ function validateSchemaIR(params) {
         });
         return;
       }
-      seenSelectorNames.add(clientName);
+      seenSelectorNames.set(clientName, tuple);
     };
-    if (model.primaryKey !== undefined && model.primaryKey.clientName !== undefined) {
+    if (model.primaryKey !== undefined && (model.primaryKey.clientName !== undefined || model.primaryKey.fields.length > 1 && addressable(model.primaryKey.fields))) {
       checkSelectorName({
-        clientName: model.primaryKey.clientName,
-        fieldCount: model.primaryKey.fields.length,
+        clientName: model.primaryKey.clientName ?? model.primaryKey.fields.join("_"),
+        fields: model.primaryKey.fields,
         isUnique: true,
         site: "@@id"
       });
     }
     for (const index of model.indexes) {
-      if (index.clientName === undefined)
+      if (index.clientName === undefined && (index.kind !== "unique" || index.where !== undefined || index.fields.length < 2 || !addressable(index.fields.map((field) => field.name))))
         continue;
       checkSelectorName({
-        clientName: index.clientName,
-        fieldCount: index.fields.length,
+        clientName: index.clientName ?? index.fields.map((field) => field.name).join("_"),
+        fields: index.fields.map((field) => field.name),
         ...index.where === undefined ? {} : { where: index.where },
         isUnique: index.kind === "unique",
         site: "@@unique"
@@ -1368,17 +1670,17 @@ function validateSchemaIR(params) {
     }
   }
   validateIdentifierLengths({ schema, issues });
-  validatePhysicalNameUniqueness({ schema, issues });
+  validatePhysicalNameUniqueness({ schema, issues, modelByName, fieldsByModel });
   validateGeneratedNames({ schema, issues });
   validateNativeRls({ schema, issues });
   return issues;
 }
 function validatePhysicalNameUniqueness(params) {
-  const { schema, issues } = params;
+  const { schema, issues, modelByName, fieldsByModel } = params;
   const dialect = providerToDialect({ provider: schema.datasource.provider });
   const owners = new Map;
   const claim = (entry) => {
-    const key = `${entry.namespace}\x00${entry.name}`;
+    const key = JSON.stringify([entry.physicalNamespace ?? "public", entry.namespace, entry.name]);
     const previous = owners.get(key);
     if (previous === undefined) {
       owners.set(key, `${entry.what} of ${entry.owner}`);
@@ -1396,14 +1698,16 @@ function validatePhysicalNameUniqueness(params) {
   const constraintNamespace = (table) => dialect === "mysql" ? "constraint" : `constraint:${table}`;
   for (const model of schema.models) {
     const table = model.dbName ?? model.name;
-    if (!claim({ namespace: "relation", name: table, what: model.isView ? "view" : "table", owner: `model "${model.name}"`, model: model.name }))
+    const physicalNamespace = qualifiedSqlName({ name: table, namespace: model.namespace }).namespace;
+    if (!claim({ namespace: "relation", physicalNamespace, name: table, what: model.isView ? "view" : "table", owner: `model "${model.name}"`, model: model.name }))
       continue;
     for (const fieldIR of model.fields) {
-      claim({ namespace: `column:${table}`, name: fieldIR.dbName ?? fieldIR.name, what: "column", owner: `field "${model.name}.${fieldIR.name}"`, model: model.name, field: fieldIR.name });
+      claim({ namespace: `column:${table}`, physicalNamespace, name: fieldIR.dbName ?? fieldIR.name, what: "column", owner: `field "${model.name}.${fieldIR.name}"`, model: model.name, field: fieldIR.name });
     }
     if (model.isView)
       continue;
-    const columnOf = (name) => model.fields.find((candidate) => candidate.name === name)?.dbName ?? name;
+    const fields = fieldsByModel.get(model);
+    const columnOf = (name) => fields.get(name)?.dbName ?? name;
     const seenIndexKeys = new Set;
     const declarations = [
       ...model.indexes.map((index) => ({ index, site: index.kind === "unique" ? "@@unique" : "@@index" })),
@@ -1411,45 +1715,45 @@ function validatePhysicalNameUniqueness(params) {
     ];
     for (const { index, site } of declarations) {
       const unique = index.kind === "unique";
-      const columns = index.fields.map((entry) => `${columnOf(entry.name)}${entry.sort === "desc" ? " desc" : ""}`);
-      const key = `${unique ? "u" : "i"}${index.nullsNotDistinct === true ? "n" : ""}:${unique ? "btree" : index.kind}:${columns.join(",")}:${index.where?.trim() ?? ""}`;
+      const columns = index.fields.map((entry) => [columnOf(entry.name), entry.sort === "desc", entry.operatorClass === undefined ? null : [entry.operatorClass.namespace, entry.operatorClass.name]]);
+      const key = JSON.stringify([unique, index.nullsNotDistinct === true, unique ? "btree" : index.kind, columns, index.where?.trim() ?? ""]);
       if (seenIndexKeys.has(key))
         continue;
       seenIndexKeys.add(key);
       const name = index.name ?? defaultIndexName({ table, columns: index.fields.map((entry) => columnOf(entry.name)), unique, dialect });
-      claim({ namespace: indexNamespace(table), name, what: unique ? "unique index" : "index", owner: `${site} on "${model.name}"`, model: model.name });
+      claim({ namespace: indexNamespace(table), physicalNamespace, name, what: unique ? "unique index" : "index", owner: `${site} on "${model.name}"`, model: model.name });
       if (index.constraintName !== undefined) {
-        claim({ namespace: constraintNamespace(table), name: index.constraintName, what: "unique constraint", owner: `${site} on "${model.name}"`, model: model.name });
+        claim({ namespace: constraintNamespace(table), physicalNamespace, name: index.constraintName, what: "unique constraint", owner: `${site} on "${model.name}"`, model: model.name });
       }
     }
     if (dialect === "postgres" && (model.primaryKey !== undefined || model.fields.some((fieldIR) => fieldIR.isId))) {
       const name = model.primaryKeyConstraintName ?? defaultPrimaryKeyName({ table, dialect });
-      claim({ namespace: "relation", name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
-      claim({ namespace: constraintNamespace(table), name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: "relation", physicalNamespace, name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, name, what: "primary key", owner: `model "${model.name}"`, model: model.name });
     }
     for (const relation of model.relations) {
       if (relation.fields === undefined || relation.fields.length === 0)
         continue;
-      const target = schema.models.find((candidate) => candidate.name === relation.targetModel);
+      const target = modelByName.get(relation.targetModel);
       if (target !== undefined && target.isView)
         continue;
       const name = relation.constraintName ?? defaultForeignKeyName({ table, columns: relation.fields.map((entry) => columnOf(entry)), dialect });
-      claim({ namespace: constraintNamespace(table), name, what: "foreign key", owner: `relation "${model.name}.${relation.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, name, what: "foreign key", owner: `relation "${model.name}.${relation.name}"`, model: model.name });
     }
     for (const checkIR of model.checks ?? []) {
-      claim({ namespace: constraintNamespace(table), name: checkIR.name, what: "CHECK constraint", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, name: checkIR.name, what: "CHECK constraint", owner: `model "${model.name}"`, model: model.name });
     }
     for (const exclusion of model.exclusions ?? []) {
-      claim({ namespace: constraintNamespace(table), name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
+      claim({ namespace: constraintNamespace(table), physicalNamespace, name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
       if (dialect === "postgres")
-        claim({ namespace: "relation", name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
+        claim({ namespace: "relation", physicalNamespace, name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
     }
   }
   if (dialect === "postgres") {
     for (const enumDef of schema.enums) {
       if (enumStorageOf({ enumDef }) !== "database")
         continue;
-      claim({ namespace: "relation", name: enumDef.dbName ?? enumDef.name, what: "enum type", owner: `enum "${enumDef.name}"` });
+      claim({ namespace: "relation", physicalNamespace: qualifiedSqlName({ name: enumDef.dbName ?? enumDef.name, namespace: enumDef.namespace }).namespace, name: enumDef.dbName ?? enumDef.name, what: "enum type", owner: `enum "${enumDef.name}"` });
     }
   }
   const seenJoinTables = new Set;
@@ -1459,17 +1763,24 @@ function validatePhysicalNameUniqueness(params) {
         continue;
       if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
         continue;
+      const target = modelByName.get(relation.targetModel);
+      const physicalNamespace = model.namespace ?? "public";
+      if ((target?.namespace ?? "public") !== physicalNamespace) {
+        issues.push({ rule: "implicit-join-namespace", message: "Implicit many-to-many endpoints must share one fixed namespace", model: model.name, field: relation.name });
+        continue;
+      }
       const join = implicitJoinTable({ modelA: model.name, modelB: relation.targetModel, ...relation.relationName === undefined ? {} : { relationName: relation.relationName } });
-      if (seenJoinTables.has(join.tableName))
+      const joinKey = JSON.stringify([physicalNamespace, join.tableName]);
+      if (seenJoinTables.has(joinKey))
         continue;
-      seenJoinTables.add(join.tableName);
+      seenJoinTables.add(joinKey);
       const owner = `implicit relation "${model.name}.${relation.name}"`;
-      claim({ namespace: "relation", name: join.tableName, what: "join table", owner, model: model.name });
+      claim({ namespace: "relation", physicalNamespace, name: join.tableName, what: "join table", owner, model: model.name });
       const derived = implicitJoinTableObjectNames({ table: join.tableName });
-      claim({ namespace: indexNamespace(join.tableName), name: derived.uniqueIndex, what: "unique index", owner, model: model.name });
-      claim({ namespace: indexNamespace(join.tableName), name: derived.indexB, what: "index", owner, model: model.name });
-      claim({ namespace: constraintNamespace(join.tableName), name: derived.foreignKeyA, what: "foreign key", owner, model: model.name });
-      claim({ namespace: constraintNamespace(join.tableName), name: derived.foreignKeyB, what: "foreign key", owner, model: model.name });
+      claim({ namespace: indexNamespace(join.tableName), physicalNamespace, name: derived.uniqueIndex, what: "unique index", owner, model: model.name });
+      claim({ namespace: indexNamespace(join.tableName), physicalNamespace, name: derived.indexB, what: "index", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), physicalNamespace, name: derived.foreignKeyA, what: "foreign key", owner, model: model.name });
+      claim({ namespace: constraintNamespace(join.tableName), physicalNamespace, name: derived.foreignKeyB, what: "foreign key", owner, model: model.name });
     }
   }
 }
@@ -1551,7 +1862,7 @@ function validateIdentifierLengths(params) {
   }
 }
 function validateModel(params) {
-  const { model, modelByName, enumByName, issues } = params;
+  const { model, modelByName, enumByName, issues, lookups, postgres } = params;
   const memberNames = new Set;
   for (const field of model.fields) {
     if (memberNames.has(field.name)) {
@@ -1653,8 +1964,23 @@ function validateModel(params) {
     }
     memberNames.add(relation.name);
   }
-  const fieldNames = new Set(model.fields.map((f) => f.name));
-  const hasIdField = model.fields.some((f) => f.isId);
+  const fieldNames = new Set(lookups.fieldsByModel.get(model).keys());
+  const idFields = model.fields.filter((f) => f.isId);
+  const hasIdField = idFields.length > 0;
+  if (idFields.length > 1) {
+    issues.push({
+      rule: "multiple-field-ids",
+      message: `Model "${model.name}" has multiple @id fields (${idFields.map((field) => field.name).join(", ")}); declare one compound primary key instead`,
+      model: model.name
+    });
+  }
+  if (idFields.length === 1 && model.primaryKey !== undefined && (model.primaryKey.fields.length !== 1 || model.primaryKey.fields[0] !== idFields[0]?.name)) {
+    issues.push({
+      rule: "conflicting-primary-key",
+      message: `Model "${model.name}" declares @id on "${idFields[0]?.name}" and a different block primary key; both declarations must name the same single logical field`,
+      model: model.name
+    });
+  }
   if (!model.isView && !hasIdField && model.primaryKey === undefined) {
     issues.push({
       rule: "missing-id",
@@ -1713,8 +2039,14 @@ function validateModel(params) {
           });
         }
       }
+      if (postgres && new Set(relation.references).size !== relation.references.length) {
+        issues.push({ rule: "relation-duplicate-column", message: `Relation "${model.name}.${relation.name}" repeats a referenced column`, model: model.name, field: relation.name });
+      }
       if (target !== undefined) {
-        const targetFieldNames = new Set(target.fields.map((f) => f.name));
+        if (postgres && referencesPartialOnly({ target, references: relation.references, schema: params.schema, lookups })) {
+          issues.push({ rule: "relation-partial-only-target", message: `Relation "${model.name}.${relation.name}" references only a partial unique key`, model: model.name, field: relation.name });
+        }
+        const targetFieldNames = lookups.fieldsByModel.get(target);
         for (const refField of relation.references) {
           if (!targetFieldNames.has(refField)) {
             issues.push({
@@ -1835,6 +2167,20 @@ function validatePredicateFields(params) {
 }
 function assertValidSchemaIR(params) {
   const dialect = providerToDialect({ provider: params.schema.datasource.provider });
+  assertIndexOperatorClasses({ schema: params.schema, dialect });
+  for (const entry of [...params.schema.models, ...params.schema.enums])
+    if (entry.namespace !== undefined)
+      assertSqlNamespace({ namespace: entry.namespace, dialect });
+  for (const model of params.schema.models)
+    for (const field of model.fields) {
+      if (!isEnumType(field.type) || field.type.namespace === undefined)
+        continue;
+      assertSqlNamespace({ namespace: field.type.namespace, dialect });
+      const enumType = field.type;
+      const declared = params.schema.enums.find((entry) => entry.name === enumType.enum || entry.dbName === enumType.enum);
+      if (declared !== undefined && (declared.namespace ?? "public") !== enumType.namespace)
+        throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Enum reference namespace differs from its declared native type", meta: { rule: "enum-namespace", model: model.name, field: field.name } });
+    }
   for (const model of params.schema.models) {
     if (model.exclusions !== undefined && !Array.isArray(model.exclusions))
       throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "Exclusions must be an array", meta: { rule: "exclusion-definition" } });
@@ -1868,6 +2214,16 @@ function assertValidSchemaIR(params) {
     if (dialect === "mysql" && counters.length > 1)
       throw unsupportedCapability({ dialect, feature: "multiple auto-increment columns" });
     for (const field of model.fields) {
+      const timeOfDay = field.isUnsupported === true || field.type !== "DateTime" ? undefined : timeOfDayType({ nativeType: field.nativeType });
+      if (timeOfDay !== undefined && !DIALECT_CAPABILITIES[dialect].timeOfDayTypes.includes(timeOfDay)) {
+        const instead = dialect === "sqlite" ? "sqlite has no time-of-day column type; store a plain DateTime or a String" : "there is no time-with-offset type here; use @db.Time(n), which stores the UTC time of day";
+        const error = unsupportedCapability({ dialect, feature: "timeOfDayTypes", hint: `${model.name}.${field.name} declares @db.${field.nativeType ?? ""} (${timeOfDay}) \u2014 ${instead}` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
+      if (timeOfDay !== undefined && dialect === "mysql" && field.default?.kind === "now") {
+        const error = unsupportedCapability({ dialect, feature: "@default(now()) on a TIME column", hint: `${model.name}.${field.name} \u2014 MySQL has no current-time default for TIME; drop the default and write the value (or use @updatedAt)` });
+        throw new VibeError({ code: error.code, message: error.message, meta: { ...error.meta, model: model.name, field: field.name, nativeType: field.nativeType } });
+      }
       if (field.default?.kind === "list") {
         if (dialect !== "postgres")
           throw unsupportedCapability({ dialect, feature: "scalar-list defaults" });
@@ -2094,11 +2450,14 @@ export {
   RlsContextError,
   SCOPED_REFUSAL_REASONS,
   SQLITE_CAPABILITIES,
+  SQL_NAMESPACES,
   ScopedQueryError,
   VIBE_ERROR_CODES,
   VibeError,
   assertIdentifierFits,
+  assertIndexOperatorClasses,
   assertMigrationObjects,
+  assertSqlNamespace,
   assertValidSchemaIR,
   buildComputedManifest,
   buildExtensionRegistry,
@@ -2132,14 +2491,19 @@ export {
   postgresGeneratedObjectName,
   predicateFieldNames,
   predicateKey,
+  prepareDatabaseModuleSchema,
   providerToDialect,
+  qualifiedSqlName,
   scalarListDefault,
   serializeJsonDefault,
+  sqlNamespaceIssue,
   sqlObjectKey,
+  sqlObjectNamespace,
+  timeOfDayType,
   unsupportedCapability,
   validateComputedConfig,
   validateRlsContextIR,
   validateSchemaIR
 };
 
-//# debugId=47DE6CAFB1D4DC2864756E2164756E21
+//# debugId=99BBBD6C3E58D9DD64756E2164756E21