@vibeorm/schema 2.3.0 → 2.5.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",
@@ -223,10 +142,203 @@ 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
+});
+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
+});
+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
+});
+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 +358,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 +374,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":
@@ -280,22 +400,255 @@ function isSqlObjectIdentity(value) {
 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))
-    throw new VibeError({ code: "VIBE_SCHEMA_INVALID", message: "migrationObjects must be an array" });
+    invalidDeclaration({ path: "migrationObjects", expected: "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);
+  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 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/prisma-literal.ts
 var STRING_ESCAPES = {
   '"': '"',
@@ -389,9 +742,25 @@ function exactIntegerLiteral(params) {
     return asNumber;
   return BigInt(text).toString();
 }
+var DECIMAL_LITERAL = /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/;
+function exactDecimalLiteral(params) {
+  const { text } = params;
+  if (!DECIMAL_LITERAL.test(text)) {
+    throw new VibeError({
+      code: "VIBE_SCHEMA_INVALID",
+      message: `Not a numeric literal: ${JSON.stringify(text)}`,
+      meta: { issues: [{ rule: "malformed-numeric-literal", message: text }], literal: text }
+    });
+  }
+  if (INTEGER_LITERAL.test(text))
+    return exactIntegerLiteral({ text });
+  const mantissa = text.replace(/[eE].*$/, "").replace("-", "").replace(".", "").replace(/^0+/, "");
+  return mantissa.length <= 15 ? Number(text) : text;
+}
 // packages/schema/src/reserved.ts
 var RESERVED_DELEGATE_NAMES = [
   "findMany",
+  "findPage",
   "findFirst",
   "findUnique",
   "findFirstOrThrow",
@@ -710,78 +1079,20 @@ function scalarListDefault(params) {
   });
 }
 
-// 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/m2m.ts
+function implicitJoinTable(params) {
+  const sorted = [params.modelA, params.modelB].sort();
+  const first = sorted[0];
+  const second = sorted[1];
+  const key = params.relationName ?? `${first}To${second}`;
+  return {
+    tableName: `_${key}`,
+    modelA: first,
+    modelB: second,
+    columnA: "A",
+    columnB: "B"
+  };
+}
 
 // packages/schema/src/validate.ts
 var RESERVED_ENUM_NAMES = [
@@ -837,6 +1148,7 @@ var RESERVED_ENUM_NAMES = [
   "SortOrder",
   "SortOrderWithNulls",
   "KeysetToken",
+  "KeysetPage",
   "KeysetOptions",
   "RowLockRequest",
   "JsonValue",
@@ -915,6 +1227,7 @@ var GENERATED_TYPE_NAMES = {
     "MinAggregateInput",
     "MaxAggregateInput",
     "FindManyArgs",
+    "FindPageArgs",
     "FindFirstArgs",
     "FindUniqueArgs",
     "CreateArgs",
@@ -1085,6 +1398,15 @@ function validateGeneratedNames(params) {
 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)) {
@@ -1256,10 +1578,197 @@ function validateSchemaIR(params) {
       });
     }
   }
+  validateIdentifierLengths({ schema, issues });
+  validatePhysicalNameUniqueness({ schema, issues });
   validateGeneratedNames({ schema, issues });
   validateNativeRls({ schema, issues });
   return issues;
 }
+function validatePhysicalNameUniqueness(params) {
+  const { schema, issues } = params;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const owners = new Map;
+  const claim = (entry) => {
+    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}`);
+      return true;
+    }
+    issues.push({
+      rule: "duplicate-physical-name",
+      message: `${entry.what} "${entry.name}" of ${entry.owner} collides with the ${previous} \u2014 both resolve to one physical ${entry.namespace === "relation" ? "object" : "name"}, and only one can exist`,
+      ...entry.model === undefined ? {} : { model: entry.model },
+      ...entry.field === undefined ? {} : { field: entry.field }
+    });
+    return false;
+  };
+  const indexNamespace = (table) => dialect === "mysql" ? `index:${table}` : "relation";
+  const constraintNamespace = (table) => dialect === "mysql" ? "constraint" : `constraint:${table}`;
+  for (const model of schema.models) {
+    const table = model.dbName ?? 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}`, 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 seenIndexKeys = new Set;
+    const declarations = [
+      ...model.indexes.map((index) => ({ index, site: index.kind === "unique" ? "@@unique" : "@@index" })),
+      ...model.fields.filter((fieldIR) => fieldIR.isUnique).map((fieldIR) => ({ index: { kind: "unique", fields: [{ name: fieldIR.name }] }, site: `@unique on "${fieldIR.name}"` }))
+    ];
+    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() ?? ""}`;
+      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), physicalNamespace, name, what: unique ? "unique index" : "index", owner: `${site} on "${model.name}"`, model: model.name });
+      if (index.constraintName !== undefined) {
+        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", 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);
+      if (target !== undefined && target.isView)
+        continue;
+      const name = relation.constraintName ?? defaultForeignKeyName({ table, columns: relation.fields.map((entry) => columnOf(entry)), dialect });
+      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), physicalNamespace, name: checkIR.name, what: "CHECK constraint", owner: `model "${model.name}"`, model: model.name });
+    }
+    for (const exclusion of model.exclusions ?? []) {
+      claim({ namespace: constraintNamespace(table), physicalNamespace, name: exclusion.name, what: "exclusion constraint", owner: `model "${model.name}"`, model: model.name });
+      if (dialect === "postgres")
+        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", 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;
+  for (const model of schema.models) {
+    for (const relation of model.relations) {
+      if (relation.targetModel === model.name)
+        continue;
+      if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
+        continue;
+      const target = schema.models.find((candidate) => candidate.name === 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 } });
+      const joinKey = JSON.stringify([physicalNamespace, join.tableName]);
+      if (seenJoinTables.has(joinKey))
+        continue;
+      seenJoinTables.add(joinKey);
+      const owner = `implicit relation "${model.name}.${relation.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), 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 });
+    }
+  }
+}
+function validateIdentifierLengths(params) {
+  const { schema, issues } = params;
+  const dialect = providerToDialect({ provider: schema.datasource.provider });
+  const limit = IDENTIFIER_LIMITS[dialect];
+  if (limit === undefined)
+    return;
+  const { max, unit } = limit;
+  const consequence = dialect === "postgres" ? `PostgreSQL silently truncates identifiers to ${max} bytes (NAMEDATALEN - 1), so the created object never carries this name and migrations cannot converge` : `MySQL refuses identifiers longer than ${max} characters (ER_TOO_LONG_IDENT)`;
+  const check = (entry) => {
+    const length = identifierLength({ name: entry.name, dialect });
+    if (length <= max)
+      return;
+    issues.push({
+      rule: "identifier-too-long",
+      message: `${entry.what} "${entry.name}" is ${length} ${unit} \u2014 ${consequence}. ${entry.remedy}`,
+      ...entry.model === undefined ? {} : { model: entry.model }
+    });
+  };
+  for (const model of schema.models) {
+    const table = model.dbName ?? model.name;
+    check({ name: table, what: model.isView ? "View name" : "Table name", model: model.name, remedy: `Map "${model.name}" to a shorter physical name (@@map).` });
+    for (const fieldIR of model.fields) {
+      check({ name: fieldIR.dbName ?? fieldIR.name, what: "Column name", model: model.name, remedy: `Map "${model.name}.${fieldIR.name}" to a shorter column name (@map).` });
+    }
+    if (model.isView)
+      continue;
+    for (const index of model.indexes) {
+      if (index.name !== undefined) {
+        check({ name: index.name, what: index.kind === "unique" ? "Unique index name" : "Index name", model: model.name, remedy: "Shorten the index name (map:)." });
+      }
+      if (index.constraintName !== undefined) {
+        check({ name: index.constraintName, what: "Unique constraint name", model: model.name, remedy: "Shorten the constraint name." });
+      }
+    }
+    if (model.primaryKeyConstraintName !== undefined) {
+      check({ name: model.primaryKeyConstraintName, what: "Primary key constraint name", model: model.name, remedy: "Shorten the constraint name (map:)." });
+    }
+    for (const relation of model.relations) {
+      if (relation.constraintName === undefined)
+        continue;
+      check({ name: relation.constraintName, what: "Foreign key constraint name", model: model.name, remedy: "Shorten the constraint name (map:)." });
+    }
+    for (const checkIR of model.checks ?? []) {
+      check({ name: checkIR.name, what: "CHECK constraint name", model: model.name, remedy: "Shorten the CHECK name." });
+    }
+    for (const exclusion of model.exclusions ?? []) {
+      check({ name: exclusion.name, what: "Exclusion constraint name", model: model.name, remedy: "Shorten the exclusion name." });
+    }
+  }
+  if (dialect === "postgres") {
+    for (const enumDef of schema.enums) {
+      if (enumStorageOf({ enumDef }) !== "database")
+        continue;
+      check({ name: enumDef.dbName ?? enumDef.name, what: "Enum type name", remedy: `Map enum "${enumDef.name}" to a shorter type name (@@map).` });
+    }
+  }
+  const seenJoinTables = new Set;
+  for (const model of schema.models) {
+    for (const relation of model.relations) {
+      if (relation.targetModel === model.name)
+        continue;
+      if (!isImplicitManyToManyRelation({ model, relation, models: schema.models }))
+        continue;
+      const join = implicitJoinTable({ modelA: model.name, modelB: relation.targetModel, ...relation.relationName === undefined ? {} : { relationName: relation.relationName } });
+      if (seenJoinTables.has(join.tableName))
+        continue;
+      seenJoinTables.add(join.tableName);
+      const remedy = `Give the relation an explicit shorter name (@relation("...")).`;
+      check({ name: join.tableName, what: "Implicit join table name", model: model.name, remedy });
+      const derived = implicitJoinTableObjectNames({ table: join.tableName });
+      check({ name: derived.uniqueIndex, what: "Implicit join table index name", model: model.name, remedy });
+      check({ name: derived.indexB, what: "Implicit join table index name", model: model.name, remedy });
+      check({ name: derived.foreignKeyA, what: "Implicit join table foreign key name", model: model.name, remedy });
+      check({ name: derived.foreignKeyB, what: "Implicit join table foreign key name", model: model.name, remedy });
+    }
+  }
+}
 function validateModel(params) {
   const { model, modelByName, enumByName, issues } = params;
   const memberNames = new Set;
@@ -1545,6 +2054,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" } });
@@ -1786,25 +2309,12 @@ function validRlsForeignKey(params) {
   ];
   return validFields && uniqueSets.some((set) => set.length === refs.length && set.every((name) => refs.includes(name)));
 }
-// packages/schema/src/m2m.ts
-function implicitJoinTable(params) {
-  const sorted = [params.modelA, params.modelB].sort();
-  const first = sorted[0];
-  const second = sorted[1];
-  const key = params.relationName ?? `${first}To${second}`;
-  return {
-    tableName: `_${key}`,
-    modelA: first,
-    modelB: second,
-    columnA: "A",
-    columnB: "B"
-  };
-}
 export {
   DIALECTS,
   DIALECT_CAPABILITIES,
   EMPTY_EXTENSION_REGISTRY,
   ENUM_STORAGES,
+  IDENTIFIER_LIMITS,
   MYSQL_CAPABILITIES,
   POSTGRES_CAPABILITIES,
   PREDICATE_COMPARISON_OPS,
@@ -1817,23 +2327,34 @@ export {
   RlsContextError,
   SCOPED_REFUSAL_REASONS,
   SQLITE_CAPABILITIES,
+  SQL_NAMESPACES,
   ScopedQueryError,
   VIBE_ERROR_CODES,
   VibeError,
+  assertIdentifierFits,
+  assertIndexOperatorClasses,
   assertMigrationObjects,
+  assertSqlNamespace,
   assertValidSchemaIR,
   buildComputedManifest,
   buildExtensionRegistry,
   decodePrismaString,
+  defaultForeignKeyName,
+  defaultIndexName,
+  defaultPrimaryKeyName,
   defineExtension,
   encodePrismaString,
   enumStorageOf,
+  exactDecimalLiteral,
   exactIntegerLiteral,
   extensionDeclarations,
   extensionManifestEntry,
   extensionOptionsHash,
   fieldTypeIdentity,
+  fitDefaultName,
+  identifierLength,
   implicitJoinTable,
+  implicitJoinTableObjectNames,
   internalError,
   invalidStoredData,
   isEnumType,
@@ -1844,16 +2365,21 @@ export {
   isSqlObjectDefinition,
   isSqlObjectIdentity,
   mergeExtensionDeclarations,
+  postgresGeneratedObjectName,
   predicateFieldNames,
   predicateKey,
+  prepareDatabaseModuleSchema,
   providerToDialect,
+  qualifiedSqlName,
   scalarListDefault,
   serializeJsonDefault,
+  sqlNamespaceIssue,
   sqlObjectKey,
+  sqlObjectNamespace,
   unsupportedCapability,
   validateComputedConfig,
   validateRlsContextIR,
   validateSchemaIR
 };
 
-//# debugId=5275C43BC09D1F0064756E2164756E21
+//# debugId=20984641ACA6D36E64756E2164756E21