@vibeorm/runtime 2.4.1 → 2.6.0

package/dist/index.js

@@ -30,7 +30,7 @@ function createSqlModel(params) {
   if (model === undefined)
     throw new VibeError({ code: "VIBE_VALIDATION", message: "Unknown SQL model" });
   const tableName = model.dbName ?? model.name;
-  const table = sql.ident({ parts: [tableName] });
+  const table = sql.ident({ parts: model.namespace === undefined ? [tableName] : [model.namespace, tableName] });
   const fields = Object.fromEntries(model.fields.filter((field) => field.isUnsupported !== true).map((field) => {
     let decoder;
     if (isEnumType(field.type)) {
@@ -199,8 +199,62 @@ function statementFor(params) {
     key: params.key
   };
 }
+// packages/runtime/src/advisory-key.ts
+import { createHash } from "crypto";
+import { VibeError as VibeError5 } from "@vibeorm/schema";
+function advisoryKeyOf(params) {
+  const { text } = params;
+  const refuse = () => new VibeError5({
+    code: "VIBE_VALIDATION",
+    message: "advisoryKeyOf text must be a well-formed UTF-16 string",
+    meta: { reason: "advisory-key-text" }
+  });
+  if (typeof text !== "string")
+    throw refuse();
+  for (let index = 0;index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = text.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343))
+        throw refuse();
+      index++;
+    } else if (unit >= 56320 && unit <= 57343) {
+      throw refuse();
+    }
+  }
+  return createHash("sha256").update(text, "utf8").digest().readBigInt64BE(0);
+}
+// packages/runtime/src/transaction-row-changes.ts
+import { VibeError as VibeError6 } from "@vibeorm/schema";
+var observations = new WeakMap;
+function registerTransactionObservation(params) {
+  observations.set(params.db, params.observation);
+}
+function inheritTransactionObservation(params) {
+  const observation = observations.get(params.from);
+  if (observation !== undefined)
+    observations.set(params.to, observation);
+}
+function transactionRowChanges(params) {
+  const observation = observations.get(params.db);
+  if (observation === undefined)
+    throw new VibeError6({
+      code: "VIBE_CONFIG",
+      message: "transactionRowChanges requires a registered handle from this VibeORM runtime installation",
+      meta: { reason: "transaction-observation-handle" }
+    });
+  if (!observation.inTransaction)
+    throw new VibeError6({
+      code: "VIBE_TRANSACTION",
+      message: "transactionRowChanges requires an active transaction handle",
+      meta: { reason: "transaction-observation-context" }
+    });
+  observation.assertActive();
+  const count = observation.read();
+  return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : "unknown";
+}
 // packages/runtime/src/model-meta.ts
-import { VibeError as VibeError5, enumStorageOf, isEnumType as isEnumType2, validateComputedConfig } from "@vibeorm/schema";
+import { VibeError as VibeError7, enumStorageOf, isEnumType as isEnumType2, validateComputedConfig } from "@vibeorm/schema";
 import { enumMembershipCodec } from "@vibeorm/sql";
 function toClientName(params) {
   const { name } = params;
@@ -308,6 +362,7 @@ function buildFieldMeta(params) {
     type: field.type,
     scalarType: enumName === null ? field.type : null,
     enumName,
+    ...enumStorage !== "database" || enumDef === undefined || enumDef.namespace === undefined && (!isEnumType2(field.type) || field.type.namespace === undefined) ? {} : { enumSqlName: { namespace: enumDef.namespace ?? (isEnumType2(field.type) ? field.type.namespace : undefined) ?? "public", name: enumDef.dbName ?? enumDef.name } },
     enumStorage,
     enumCodec: enumStorage === "string" && enumDef !== undefined ? enumMembershipCodec({ model, field: field.name, enum: enumDef.name, members: enumDef.values }) : null,
     isList: field.isList,
@@ -329,7 +384,7 @@ function buildModelMeta(params) {
     for (const name of model.primaryKey.fields) {
       const field = fieldByName.get(name);
       if (field === undefined) {
-        throw new VibeError5({
+        throw new VibeError7({
           code: "VIBE_SCHEMA_INVALID",
           message: `model "${model.name}" declares composite primary-key field "${name}", which does not exist`,
           meta: { model: model.name, field: name }
@@ -396,6 +451,7 @@ function buildModelMeta(params) {
     name: model.name,
     clientName: toClientName({ name: model.name }),
     tableName: model.dbName ?? model.name,
+    ...model.namespace === undefined ? {} : { namespace: model.namespace },
     fields,
     fieldByName,
     fieldByColumn,
@@ -435,7 +491,7 @@ function getModelMeta(params) {
   const { meta, model } = params;
   const found = meta.modelByName.get(model);
   if (found === undefined) {
-    throw new VibeError5({
+    throw new VibeError7({
       code: "VIBE_VALIDATION",
       message: `unknown model "${model}"`,
       meta: { model, known: [...new Set(meta.models.map((entry) => entry.name))] }
@@ -448,20 +504,20 @@ function getFieldMeta(params) {
   const found = model.fieldByName.get(field);
   if (found === undefined) {
     if (model.computed !== null && model.computed.has(field)) {
-      throw new VibeError5({
+      throw new VibeError7({
         code: "VIBE_VALIDATION",
         message: `"${field}" on model "${model.name}" is a computed field \u2014 computed fields appear in results (select/omit) only, not in ${context}`,
         meta: { model: model.name, field, context, computed: true }
       });
     }
     if (model.relationByName.has(field)) {
-      throw new VibeError5({
+      throw new VibeError7({
         code: "VIBE_VALIDATION",
         message: `"${field}" on model "${model.name}" is a relation \u2014 not valid in ${context} here (relation writes use nested-write verbs, relation reads use select/include)`,
         meta: { model: model.name, field, context }
       });
     }
-    throw new VibeError5({
+    throw new VibeError7({
       code: "VIBE_VALIDATION",
       message: `unknown field "${field}" on model "${model.name}" in ${context}`,
       meta: { model: model.name, field, context }
@@ -471,8 +527,8 @@ function getFieldMeta(params) {
 }
 // packages/runtime/src/codecs.ts
 import { JSON_TRANSPORT, projectionOutputName, parsePgArrayLiteral, toPgArrayLiteral } from "@vibeorm/sql";
-import { VibeError as VibeError6, isEnumType as isEnumType3 } from "@vibeorm/schema";
-import { DIALECT_CODECS, decodeIsNoop } from "@vibeorm/sql";
+import { VibeError as VibeError8, isEnumType as isEnumType3 } from "@vibeorm/schema";
+import { DIALECT_CODECS, decodeIsNoop, nativeEnumArrayParameter } from "@vibeorm/sql";
 import {
   DIALECT_CODECS as DIALECT_CODECS2,
   MYSQL_CODECS,
@@ -500,7 +556,10 @@ function encodeValue(params) {
   const codec = fieldCodec({ dialect, field });
   if (field.isList && Array.isArray(value)) {
     const elements = value.map((element) => element === null || element === undefined ? element : codec.encode(element));
-    return isPostgresEnumList({ dialect, field }) ? toPgArrayLiteral({ values: elements }) : elements;
+    if (!isPostgresEnumList({ dialect, field }))
+      return elements;
+    const literal = toPgArrayLiteral({ values: elements });
+    return field.enumSqlName === undefined ? literal : nativeEnumArrayParameter({ value: literal, type: field.enumSqlName });
   }
   return codec.encode(value);
 }
@@ -533,7 +592,7 @@ function validateAtomicOperand(params) {
   } else if (typeof value === "number" && Number.isFinite(value)) {
     return value;
   }
-  throw new VibeError6({
+  throw new VibeError8({
     code: "VIBE_VALIDATION",
     message: `Invalid arithmetic operand for ${field.scalarType} field "${field.name}"`,
     meta: { field: field.name, value }
@@ -542,7 +601,7 @@ function validateAtomicOperand(params) {
 function toRealNumber(params) {
   const { field, value } = params;
   const refuse = () => {
-    throw new VibeError6({
+    throw new VibeError8({
       code: "VIBE_VALIDATION",
       message: `"${String(value)}" is not a numeric value for the Decimal field "${field.name}"`,
       meta: { field: field.name, value }
@@ -782,7 +841,7 @@ function positionalMaterializer(params) {
     const output = projectionOutputName({ column });
     const entry = plan.byColumn.get(output);
     if (entry === undefined)
-      throw new VibeError6({ code: "VIBE_INTERNAL", message: "positional projection has no schema field", meta: { model: model.name, column: output } });
+      throw new VibeError8({ code: "VIBE_INTERNAL", message: "positional projection has no schema field", meta: { model: model.name, column: output } });
     return entry;
   });
   const width = slots.length;
@@ -790,7 +849,7 @@ function positionalMaterializer(params) {
   const chunked = width > chunkSize;
   const count = Math.ceil(width / chunkSize);
   const invalid = () => {
-    throw new VibeError6({ code: "VIBE_INTERNAL", message: "positional relation payload does not match its SQL projection", meta: { model: model.name, expectedColumns: width } });
+    throw new VibeError8({ code: "VIBE_INTERNAL", message: "positional relation payload does not match its SQL projection", meta: { model: model.name, expectedColumns: width } });
   };
   if (width === 0 || new Set(slots.map((slot) => slot.name)).size !== width)
     return invalid();
@@ -832,7 +891,7 @@ function decodeAggregateValue(params) {
   return field === null ? value : decodeValue({ dialect, field, value });
 }
 // packages/runtime/src/lateral-projection.ts
-import { VibeError as VibeError7, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError9, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
 }
@@ -849,7 +908,7 @@ function lateralProjection(params) {
   const columns = names.map((name) => {
     const field = model.fieldByName.get(name);
     if (field === undefined)
-      throw new VibeError7({ code: "VIBE_INTERNAL", message: "lateral projection references an unknown field", meta: { model: model.name, field: name } });
+      throw new VibeError9({ code: "VIBE_INTERNAL", message: "lateral projection references an unknown field", meta: { model: model.name, field: name } });
     return Object.freeze(applyLateralTransform({ model, column: { table: LATERAL_CHILD_ALIAS, name: field.columnName } }));
   });
   const descriptor = Object.freeze({ columns: Object.freeze(columns), hiddenOrder: Object.freeze(hiddenOrder) });
@@ -898,7 +957,7 @@ function applyLateralTransform(params) {
 
 // packages/runtime/src/query-builder.ts
 import { isSqlFragment, mapConflictColumns } from "@vibeorm/sql";
-import { VibeError as VibeError11, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { VibeError as VibeError13, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 import {
   SQL_DEFAULT_CELL,
   containsPattern,
@@ -912,9 +971,9 @@ import {
 import { describeRowLock } from "@vibeorm/sql";
 
 // packages/runtime/src/bulk-upsert.ts
-import { VibeError as VibeError8, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 function validationError2(params) {
-  return new VibeError8({
+  return new VibeError10({
     code: "VIBE_VALIDATION",
     message: params.message,
     ...params.meta === undefined ? {} : { meta: params.meta }
@@ -1238,7 +1297,7 @@ function assertConflictKeysAreComparable(params) {
 }
 
 // packages/runtime/src/keyset.ts
-import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { VibeError as VibeError11 } from "@vibeorm/schema";
 var KEYSET_TOKEN_VERSION = 1;
 var KEYSET_TOKEN_PREFIX = "vk1.";
 var KEYSET_MAX_PAGE_SIZE = 1e4;
@@ -1247,11 +1306,12 @@ var DATETIME_NEEDS_PRECISION_ASSERTION = Object.freeze({
   mysql: true,
   sqlite: false
 });
+var MILLISECOND_EXACT_NATIVE_TYPE = /^(?:timestamptz|timestamp|datetime)\(\s*[0-3]\s*\)$/i;
 function keysetValidation(params) {
-  return new VibeError9({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError11({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function keysetUnsupported(params) {
-  return new VibeError9({
+  return new VibeError11({
     code: "VIBE_UNSUPPORTED_CAPABILITY",
     message: params.message,
     meta: params.meta
@@ -1356,9 +1416,9 @@ function compileKeysetOrderPlan(params) {
         meta: { model: model.name, field: field.name, feature: "keysetOrderKey" }
       });
     }
-    if (tag === "t" && DATETIME_NEEDS_PRECISION_ASSERTION[dialect.name] === true && timestampPrecision === undefined) {
+    if (tag === "t" && DATETIME_NEEDS_PRECISION_ASSERTION[dialect.name] === true && timestampPrecision === undefined && (model.isView || !MILLISECOND_EXACT_NATIVE_TYPE.test(field.nativeType ?? ""))) {
       throw keysetUnsupported({
-        message: `keyset pagination cannot order by ${model.name}.${field.name} on ${dialect.name}: this engine may store sub-millisecond timestamps, ` + "and a JavaScript Date truncates them, which would re-deliver rows inside the same millisecond. " + 'Pass keyset: { timestampPrecision: "milliseconds" } to assert the column is millisecond-exact, or order by a lossless key.',
+        message: `keyset pagination cannot order by ${model.name}.${field.name} on ${dialect.name}: this engine may store sub-millisecond timestamps, ` + "and a JavaScript Date truncates them, which would re-deliver rows inside the same millisecond. " + "Declare the column millisecond-exact (@db.Timestamptz(3), dsl.datetime().tz({ precision: 3 })), " + 'pass keyset: { timestampPrecision: "milliseconds" } to assert it is, or order by a lossless key.',
         meta: { model: model.name, field: field.name, feature: "keysetTimestampPrecision", dialect: dialect.name }
       });
     }
@@ -1371,7 +1431,7 @@ function compileKeysetOrderPlan(params) {
       meta: { model: model.name, orderFields: [...seen], feature: "keysetTieBreaker" }
     });
   }
-  return { model: model.name, keys, signature: signatureOf2({ model: model.name, keys }) };
+  return { model: model.name, keys, signature: signatureOf2({ model: model.name, keys, ...model.namespace === undefined ? {} : { namespace: model.namespace, table: model.tableName } }) };
 }
 function signatureOf2(params) {
   const { model, keys } = params;
@@ -1379,7 +1439,7 @@ function signatureOf2(params) {
     const base = `${key.field.name}:${key.direction}`;
     return key.field.isOptional ? `${base}:nulls=${key.nulls}` : base;
   });
-  return [model, ...parts].join("|");
+  return [model, ...params.namespace === undefined ? [] : [`physical=${JSON.stringify([params.namespace, params.table])}`], ...parts].join("|");
 }
 function encodeValueFor(params) {
   const { key, value, model } = params;
@@ -1634,9 +1694,9 @@ function decodeKeysetToken(params) {
 }
 
 // packages/runtime/src/relation-plan.ts
-import { VibeError as VibeError10, implicitJoinTable } from "@vibeorm/schema";
+import { VibeError as VibeError12, implicitJoinTable, qualifiedSqlName, unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
 function validationError3(params) {
-  return new VibeError10({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError12({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
@@ -1661,7 +1721,7 @@ function keyFields(params) {
   return names.map((name) => {
     const field = model.fieldByName.get(name);
     if (field === undefined) {
-      throw new VibeError10({
+      throw new VibeError12({
         code: "VIBE_SCHEMA_INVALID",
         message: `relation "${relation.name}" on ${relation.model} names unknown ${what} field "${name}"`,
         meta: { model: relation.model, relation: relation.name }
@@ -1673,7 +1733,7 @@ function keyFields(params) {
 function singleKeyPair(params) {
   const { link, what } = params;
   if (link.parentKeys.length !== 1 || link.childKeys.length !== 1) {
-    throw new VibeError10({
+    throw new VibeError12({
       code: "VIBE_UNSUPPORTED_CAPABILITY",
       message: `${what} on relation "${link.relation.name}" of ${link.relation.model} needs a single-column relation key \u2014 this relation links ${link.parentKeys.length} columns; use an explicit junction model`,
       meta: { model: link.relation.model, relation: link.relation.name, arity: link.parentKeys.length }
@@ -1717,12 +1777,15 @@ function resolveRelationLinkUncached(params) {
   const target = getModelMeta({ meta, model: relation.targetModel });
   if (relation.type === "manyToMany") {
     if (relation.model === relation.targetModel) {
-      throw new VibeError10({
+      throw new VibeError12({
         code: "VIBE_SCHEMA_INVALID",
         message: `relation "${relation.name}" on ${relation.model} is an implicit self many-to-many: both sides own the ` + `same join-table column, so this field and its inverse would read the same rows. Model each direction ` + `with an explicit junction model.`,
         meta: { model: relation.model, relation: relation.name, targetModel: relation.targetModel }
       });
     }
+    const namespace = qualifiedSqlName({ name: model.tableName, namespace: model.namespace }).namespace;
+    if (namespace !== qualifiedSqlName({ name: target.tableName, namespace: target.namespace }).namespace)
+      throw unsupportedCapability4({ dialect: "postgres", feature: "implicitJoinNamespaces", hint: "Implicit join parents must share one physical namespace" });
     const join = implicitJoinTable({
       modelA: relation.model,
       modelB: relation.targetModel,
@@ -1737,6 +1800,7 @@ function resolveRelationLinkUncached(params) {
       childKeys: [singlePrimaryKey({ model: target, relation })],
       join: {
         tableName: join.tableName,
+        ...model.namespace === undefined && target.namespace === undefined ? {} : { namespace },
         parentColumn: parentIsA ? "A" : "B",
         childColumn: parentIsA ? "B" : "A"
       }
@@ -1759,7 +1823,7 @@ function resolveRelationLinkUncached(params) {
   }
   const reverse = findReverseRelation({ relation, target });
   if (reverse === null || reverse.fields === undefined || reverse.fields.length === 0) {
-    throw new VibeError10({
+    throw new VibeError12({
       code: "VIBE_SCHEMA_INVALID",
       message: `relation "${relation.name}" on ${relation.model} has no foreign-key counterpart on ${relation.targetModel}`,
       meta: { model: relation.model, relation: relation.name, target: relation.targetModel }
@@ -1784,7 +1848,7 @@ function pairedKeys(params) {
   const parentKeys = keyFields({ model, names: parentNames, relation, what: "fields" });
   const childKeys = keyFields({ model: target, names: childNames, relation, what: "references" });
   if (parentKeys.length !== childKeys.length) {
-    throw new VibeError10({
+    throw new VibeError12({
       code: "VIBE_SCHEMA_INVALID",
       message: `relation "${relation.name}" on ${relation.model} links ${parentKeys.length} field(s) to ${childKeys.length} reference(s) \u2014 a foreign key must pair every column`,
       meta: { model: relation.model, relation: relation.name }
@@ -2134,7 +2198,7 @@ var AGG_FN_BY_KEY = {
   _max: "max"
 };
 function validationError4(params) {
-  return new VibeError11({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError13({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
@@ -2238,21 +2302,21 @@ function assertLockIsExpressible(params) {
   if (rowLockStrengths.length === 0) {
     if (lock.strength === "update" && lock.wait === "wait")
       return;
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: site,
       hint: `${dialect.name} has no locking-read clause at all. Only lock: "update" is accepted there, ` + `as the documented no-op its single-writer transactions already provide`
     });
   }
   if (!rowLockStrengths.includes(lock.strength)) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: site,
       hint: `${dialect.name} has these lock strengths: ${rowLockStrengths.join(", ")}`
     });
   }
   if (!rowLockWaitPolicies.includes(lock.wait)) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: site,
       hint: `${dialect.name} has these lock wait policies: ${rowLockWaitPolicies.join(", ")}`
@@ -2262,7 +2326,7 @@ function assertLockIsExpressible(params) {
 function compileConflictTarget(params) {
   const { dialect, meta, model, method, target, where } = params;
   if ((target !== undefined || where !== undefined) && dialect.doNothingForm === "insertIgnore") {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: `a conflict target on ${model.clientName}.${method}()`,
       hint: "mysql's INSERT IGNORE / ON DUPLICATE KEY fire on ANY duplicate key \u2014 no target can be named; gate the call per dialect"
@@ -2280,7 +2344,7 @@ function compileConflictTarget(params) {
       out.columns = target.map((name) => getFieldMeta({ model, field: String(name), context: "onConflict target" }).columnName);
     } else if (isPlainObject3(target) && typeof target.constraint === "string" && target.constraint.length > 0 && Object.keys(target).length === 1) {
       if (!dialect.capabilities.conflictTargetConstraint) {
-        throw unsupportedCapability4({
+        throw unsupportedCapability5({
           dialect: dialect.name,
           feature: "a named-constraint conflict target (ON CONFLICT ON CONSTRAINT)",
           hint: "only postgres supports ON CONSTRAINT targets \u2014 name the indexed columns instead"
@@ -2302,7 +2366,7 @@ function compileConflictTarget(params) {
       });
     }
     if (!dialect.capabilities.partialIndexes) {
-      throw unsupportedCapability4({
+      throw unsupportedCapability5({
         dialect: dialect.name,
         feature: "a partial-index conflict target",
         hint: "this dialect has no partial indexes to target"
@@ -2388,7 +2452,7 @@ function assertListFilterable(params) {
   const { dialect, model, field, operator } = params;
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability4({
+  throw unsupportedCapability5({
     dialect: dialect.name,
     feature: `scalar list filter "${operator}" on ${model.name}.${field.name}`,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -2398,7 +2462,7 @@ function assertListWritable(params) {
   const { dialect, model, field } = params;
   if (!field.isList || dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability4({
+  throw unsupportedCapability5({
     dialect: dialect.name,
     feature: `writing the scalar list ${model.name}.${field.name}`,
     hint: "only postgres has native array columns \u2014 model the list as a related table instead"
@@ -2515,7 +2579,7 @@ function compileJsonFieldFilter(params) {
   const requireOp = (op) => {
     if (dialect.supportedJsonOps.includes(op))
       return;
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: `json filter "${op}" on ${model.name}.${field.name}`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2836,7 +2900,7 @@ function buildRelationExists(params) {
       kind: "exists",
       select: {
         kind: "select",
-        table: { name: target.tableName, alias: childAlias },
+        table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace }, alias: childAlias },
         columns: [],
         selectExpr: { kind: "one" },
         where: correlated({
@@ -2852,7 +2916,7 @@ function buildRelationExists(params) {
       ...negate ? { negate: true } : {},
       select: {
         kind: "select",
-        table: { name: join.tableName, alias: jtAlias },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace }, alias: jtAlias },
         columns: [],
         selectExpr: { kind: "one" },
         where: {
@@ -2875,7 +2939,7 @@ function buildRelationExists(params) {
     ...negate ? { negate: true } : {},
     select: {
       kind: "select",
-      table: { name: target.tableName, alias: childAlias },
+      table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace }, alias: childAlias },
       columns: [],
       selectExpr: { kind: "one" },
       where: correlated(correlateLink({ link, childTable: childAlias, outerTable: outer }))
@@ -3149,7 +3213,7 @@ function compileRelationOrderTerms(params) {
       const alias = `__ord${++aliasSeq.n}`;
       const select = link.kind === "manyToMany" ? {
         kind: "select",
-        table: { name: link.join.tableName, alias },
+        table: { name: link.join.tableName, ...link.join?.namespace === undefined ? {} : { namespace: link.join.namespace }, alias },
         columns: [],
         selectExpr: { kind: "countAll" },
         where: {
@@ -3163,7 +3227,7 @@ function compileRelationOrderTerms(params) {
         }
       } : {
         kind: "select",
-        table: { name: link.target.tableName, alias },
+        table: { name: link.target.tableName, ...link.target.namespace === undefined ? {} : { namespace: link.target.namespace }, alias },
         columns: [],
         selectExpr: { kind: "countAll" },
         where: correlateLink({ link, childTable: alias, outerTable: outer })
@@ -3183,7 +3247,7 @@ function compileRelationOrderTerms(params) {
     terms.push({
       select: {
         kind: "select",
-        table: { name: link.target.tableName, alias },
+        table: { name: link.target.tableName, ...link.target.namespace === undefined ? {} : { namespace: link.target.namespace }, alias },
         columns: [compareColumnRef({ dialect, field, table: alias })],
         where: correlateLink({ link, childTable: alias, outerTable: outer })
       },
@@ -3737,7 +3801,7 @@ function parseCursor(params) {
 function keysetFieldOfTerm(params) {
   const { dialect, model, term } = params;
   if (!("column" in term)) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: `keyset pagination over a relation or aggregate orderBy on model "${model.name}"`,
       hint: "order by scalar columns plus a unique tie-breaker; a correlated subquery value is not on the row, so no position can describe it"
@@ -3745,7 +3809,7 @@ function keysetFieldOfTerm(params) {
   }
   const field = model.fieldByColumn.get(term.column.name);
   if (field === undefined) {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: dialect.name,
       feature: `keyset pagination over a computed order key on model "${model.name}"`,
       hint: "order by scalar columns plus a unique tie-breaker"
@@ -4125,7 +4189,7 @@ function buildFindShape(params) {
     const outerOrder = distinctOuterOrder ?? arranged.slice(0, distinctLeadCount);
     const inner = {
       kind: "select",
-      table: { name: model.tableName },
+      table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
       columns: withOuterOrderKeys(columns, outerOrder),
       rowNumber: {
         partitionBy: distinctPartition,
@@ -4149,7 +4213,7 @@ function buildFindShape(params) {
   if (distinctOuterOrder !== null) {
     const inner = {
       kind: "select",
-      table: { name: model.tableName },
+      table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
       columns: withOuterOrderKeys(columns, distinctOuterOrder),
       ...lateralJoins.length > 0 ? { lateralJoins } : {},
       ...where === undefined ? {} : { where },
@@ -4177,7 +4241,7 @@ function buildFindShape(params) {
     const innerColumns = withOuterOrderKeys(withKeyColumns(projected, correlationKeys), orderTerms);
     const inner = {
       kind: "select",
-      table: { name: model.tableName },
+      table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
       columns: innerColumns,
       ...where === undefined ? {} : { where },
       ...distinctOn === undefined ? {} : { distinctOn },
@@ -4187,7 +4251,7 @@ function buildFindShape(params) {
     };
     const statement = {
       kind: "select",
-      table: { name: model.tableName },
+      table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
       columns,
       fromSelect: inner,
       lateralJoins,
@@ -4197,7 +4261,7 @@ function buildFindShape(params) {
   }
   const statement = {
     kind: "select",
-    table: { name: model.tableName },
+    table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
     columns,
     ...lateralJoins.length > 0 ? { lateralJoins } : {},
     ...where === undefined ? {} : { where },
@@ -4241,12 +4305,12 @@ function buildLateralCount(params) {
     };
     select = {
       kind: "select",
-      table: filter === undefined ? { name: join.tableName, alias: joinAlias } : { name: link.target.tableName, alias: childAlias },
+      table: filter === undefined ? { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace }, alias: joinAlias } : { name: link.target.tableName, ...link.target.namespace === undefined ? {} : { namespace: link.target.namespace }, alias: childAlias },
       columns: [],
       selectExpr: { kind: "countAll", alias: columnAlias },
       where: filter === undefined ? correlation : { kind: "and", operands: [correlation, filter] },
       ...filter === undefined ? {} : { innerJoins: [{
-        table: { name: join.tableName, alias: joinAlias },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace }, alias: joinAlias },
         on: [{ left: { table: joinAlias, name: join.childColumn }, right: { table: childAlias, name: pair.child.columnName } }]
       }] }
     };
@@ -4254,7 +4318,7 @@ function buildLateralCount(params) {
     const correlation = correlateLink({ link, childTable: childAlias, outerTable: model.tableName });
     select = {
       kind: "select",
-      table: { name: link.target.tableName, alias: childAlias },
+      table: { name: link.target.tableName, ...link.target.namespace === undefined ? {} : { namespace: link.target.namespace }, alias: childAlias },
       columns: [],
       selectExpr: { kind: "countAll", alias: columnAlias },
       where: filter === undefined ? correlation : { kind: "and", operands: [correlation, filter] }
@@ -4277,7 +4341,7 @@ function buildLateralJoinClause(params) {
       kind: "exists",
       select: {
         kind: "select",
-        table: { name: join.tableName, alias: jtAlias },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace }, alias: jtAlias },
         columns: [],
         selectExpr: { kind: "one" },
         where: {
@@ -4329,7 +4393,7 @@ function buildLateralJoinClause(params) {
     rowFormat: "positional",
     select: {
       kind: "select",
-      table: { name: target.tableName, alias: LATERAL_CHILD_ALIAS },
+      table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace }, alias: LATERAL_CHILD_ALIAS },
       columns,
       where,
       ...orderBy === undefined || orderBy.length === 0 ? {} : { orderBy },
@@ -4685,7 +4749,7 @@ function resolveStrategy(params) {
   const strategy = explicit ?? defaultRelationStrategy ?? "query";
   if (strategy === "join" && !dialect.capabilities.lateralJoin) {
     if (explicit !== undefined || hasRelations) {
-      throw unsupportedCapability4({
+      throw unsupportedCapability5({
         dialect: dialect.name,
         feature: 'relationStrategy "join"',
         hint: 'lateral joins are postgres-only \u2014 use the portable "query" strategy on this dialect'
@@ -4856,7 +4920,7 @@ function buildQuery(params) {
       const bounded = countTake !== undefined || countSkip !== undefined;
       const boundedInner = (innerFields) => ({
         kind: "select",
-        table: { name: model.tableName },
+        table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
         columns: projectionColumns({ model, selectedFields: innerFields }),
         ...where === undefined ? {} : { where },
         ...countOrder === undefined || countOrder.length === 0 ? {} : { orderBy: countOrder },
@@ -4915,7 +4979,7 @@ function buildQuery(params) {
           aggregateSpec: { selections, countShorthand: false },
           statement: {
             kind: "select",
-            table: { name: model.tableName },
+            table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
             columns: [],
             aggregates: aggSelects,
             ...where === undefined ? {} : { where }
@@ -4940,7 +5004,7 @@ function buildQuery(params) {
         countAlias: COUNT_ALIAS,
         statement: {
           kind: "select",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           columns: [],
           selectExpr: { kind: "countAll", alias: COUNT_ALIAS },
           ...where === undefined ? {} : { where }
@@ -4960,7 +5024,7 @@ function buildQuery(params) {
           aggregateSpec: spec,
           statement: {
             kind: "select",
-            table: { name: model.tableName },
+            table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
             columns: [],
             aggregates: aggSelects,
             ...where === undefined ? {} : { where }
@@ -4970,7 +5034,7 @@ function buildQuery(params) {
       const innerFields = referenced.length > 0 ? referenced : model.primaryKey.map((field) => field.name);
       const inner = {
         kind: "select",
-        table: { name: model.tableName },
+        table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
         columns: projectionColumns({ model, selectedFields: innerFields }),
         ...where === undefined ? {} : { where },
         ...orderBy === undefined || orderBy.length === 0 ? {} : { orderBy },
@@ -5023,7 +5087,7 @@ function buildQuery(params) {
         groupByFields: byFields.map((field) => field.name),
         statement: {
           kind: "select",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           columns: byColumns,
           ...aggSelects.length === 0 ? {} : { aggregates: aggSelects },
           ...where === undefined ? {} : { where },
@@ -5065,7 +5129,7 @@ function buildQuery(params) {
           throw validationError4({ message: "DO NOTHING cannot carry update expressions" });
         if (spec.action === "update") {
           if (!dialect.capabilities.returning)
-            throw unsupportedCapability4({ dialect: dialect.name, feature: "create onConflict update returning", hint: "use upsertMany for a count-only conflict update" });
+            throw unsupportedCapability5({ dialect: dialect.name, feature: "create onConflict update returning", hint: "use upsertMany for a count-only conflict update" });
           if (compiled.columns === undefined && compiled.constraint === undefined)
             throw validationError4({ message: "A conflict update requires an explicit target" });
           const updates = requireObject({ value: spec.update, what: "onConflict.update", model });
@@ -5103,7 +5167,7 @@ function buildQuery(params) {
         refetchWhere: row.knownKey,
         statement: {
           kind: "insert",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           columns,
           rows: [columns.map((column) => row.values[column])],
           ...conflictClause === undefined ? {} : { onConflict: conflictClause },
@@ -5114,7 +5178,7 @@ function buildQuery(params) {
     case "createMany":
     case "createManyAndReturn": {
       if (method === "createManyAndReturn" && !dialect.capabilities.createManyAndReturn) {
-        throw unsupportedCapability4({
+        throw unsupportedCapability5({
           dialect: dialect.name,
           feature: "createManyAndReturn",
           hint: "this dialect cannot RETURNING multiple inserted rows \u2014 use createMany then findMany"
@@ -5151,7 +5215,7 @@ function buildQuery(params) {
       }
       const statements = groups.map((group) => ({
         kind: "insert",
-        table: { name: model.tableName },
+        table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
         columns: group.columns,
         rows: group.rows,
         ...manyConflict === undefined ? {} : { onConflict: manyConflict },
@@ -5237,7 +5301,7 @@ function buildQuery(params) {
       };
       const upsertStatements = upsertGroups.map((group) => ({
         kind: "insert",
-        table: { name: model.tableName },
+        table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
         columns: group.columns,
         rows: group.rows,
         onConflict
@@ -5254,7 +5318,7 @@ function buildQuery(params) {
     case "updateManyAndReturn": {
       const isUnique = method === "update";
       if (method === "updateManyAndReturn" && !dialect.capabilities.returning) {
-        throw unsupportedCapability4({
+        throw unsupportedCapability5({
           dialect: dialect.name,
           feature: "updateManyAndReturn",
           hint: "this dialect has no RETURNING \u2014 use updateMany then findMany, accepting that the read is a separate, unprotected statement"
@@ -5276,7 +5340,7 @@ function buildQuery(params) {
         refetchWhere: isUnique ? uniqueRefetchWhere({ model, where, data: args.data }) : null,
         statement: {
           kind: "update",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           set: compileUpdateSet({
             dialect,
             model,
@@ -5299,7 +5363,7 @@ function buildQuery(params) {
           });
         }
         if (!dialect.capabilities.conflictTargetConstraint) {
-          throw unsupportedCapability4({
+          throw unsupportedCapability5({
             dialect: dialect.name,
             feature: "a named-constraint conflict target on upsert",
             hint: "only postgres supports ON CONFLICT ON CONSTRAINT \u2014 rely on the where-derived column target instead"
@@ -5317,7 +5381,7 @@ function buildQuery(params) {
       const targetFields = conflictTargetGroup({ model, where }).fields;
       for (const field of targetFields) {
         if (!(field.columnName in row.values)) {
-          throw new VibeError11({
+          throw new VibeError13({
             code: "VIBE_INTERNAL",
             message: `upsert on ${model.name}: create data does not bind conflict-target column "${field.columnName}" \u2014 this shape must run the find-then-write fallback flow`,
             meta: { model: model.name, column: field.columnName }
@@ -5328,7 +5392,7 @@ function buildQuery(params) {
       for (const [key, value] of Object.entries(where)) {
         if (value === undefined || nativeTargetNames.has(key))
           continue;
-        throw new VibeError11({
+        throw new VibeError13({
           code: "VIBE_INTERNAL",
           message: `upsert on ${model.name}: where field "${key}" is not part of the conflict target \u2014 guarded upserts must run the find-then-write fallback flow`,
           meta: { model: model.name, field: key }
@@ -5343,7 +5407,7 @@ function buildQuery(params) {
         refetchWhereBase: { ...where },
         statement: {
           kind: "insert",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           columns,
           rows: [columns.map((column) => row.values[column])],
           onConflict: {
@@ -5369,7 +5433,7 @@ function buildQuery(params) {
         refetchWhere: isUnique ? where : null,
         statement: {
           kind: "delete",
-          table: { name: model.tableName },
+          table: { name: model.tableName, ...model.namespace === undefined ? {} : { namespace: model.namespace } },
           ...compiled === undefined ? {} : { where: compiled },
           ...isUnique ? { returning: returningColumns({ model, selectedFields }) } : {}
         }
@@ -5381,7 +5445,7 @@ function buildQuery(params) {
 import { getSqlDialect, renderStatement } from "@vibeorm/sql";
 
 // packages/runtime/src/extensions.ts
-import { VibeError as VibeError12, extensionManifestEntry } from "@vibeorm/schema";
+import { VibeError as VibeError14, extensionManifestEntry } from "@vibeorm/schema";
 function assertExtensionManifest(params) {
   const { manifest } = params;
   const instances = params.instances ?? [];
@@ -5404,7 +5468,7 @@ function assertExtensionManifest(params) {
     problems.push(`"${name}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError12({
+    throw new VibeError14({
       code: "VIBE_STALE_CLIENT",
       message: `extension list changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { manifest, problems }
@@ -5419,7 +5483,7 @@ function buildExtensionOperatorMap(params) {
     for (const operator of extension.sql?.whereOperators ?? []) {
       const existing = owner.get(operator.name);
       if (existing !== undefined) {
-        throw new VibeError12({
+        throw new VibeError14({
           code: "VIBE_CONFIG",
           message: `where operator "${operator.name}" is claimed by both "${existing}" and "${extension.name}"`,
           meta: { operator: operator.name }
@@ -5435,7 +5499,7 @@ function buildExtensionOperatorMap(params) {
           options: extension.options
         });
         if ("error" in compiled) {
-          throw new VibeError12({
+          throw new VibeError14({
             code: "VIBE_VALIDATION",
             message: `"${operator.name}" on ${model}.${field}: ${compiled.error}`,
             meta: { model, field, operator: operator.name, extension: extension.name }
@@ -5468,7 +5532,7 @@ function buildConnectHooks(params) {
 }
 
 // packages/runtime/src/relation-key.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
 function relationValueKey(params) {
   const { value } = params;
   if (value === null || value === undefined)
@@ -5501,7 +5565,7 @@ function relationTupleKey(params) {
     if (value === null || value === undefined)
       return null;
     if (typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array)) {
-      throw new VibeError13({
+      throw new VibeError15({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "a relation key of this type cannot be compared faithfully in memory \u2014 relation links support String, Int, BigInt, Boolean, DateTime and Bytes keys",
         meta: { received: Object.prototype.toString.call(value) }
@@ -5527,7 +5591,7 @@ function assertWriteScope(params) {
 }
 
 // packages/runtime/src/nested-writes.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { VibeError as VibeError16 } from "@vibeorm/schema";
 function parentTupleOf(params) {
   const { link, row } = params;
   return link.parentKeys.map((field) => row[field.name]);
@@ -5574,10 +5638,10 @@ function detachAssignment(params) {
   return out;
 }
 function validationError5(params) {
-  return new VibeError14({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError16({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function notFound(params) {
-  return new VibeError14({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
+  return new VibeError16({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
 }
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
@@ -5744,7 +5808,7 @@ async function insertJoinRows(params) {
     await run.statement({
       statement: {
         kind: "insert",
-        table: { name: join.tableName },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace } },
         columns: ["A", "B"],
         rows: rows.slice(start, start + perChunk),
         onConflict: { columns: ["A", "B"], doNothing: true }
@@ -5764,7 +5828,7 @@ async function deleteJoinRows(params) {
     await run.statement({
       statement: {
         kind: "delete",
-        table: { name: join.tableName },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace } },
         where: {
           kind: "and",
           operands: [
@@ -5813,7 +5877,7 @@ async function deleteJoinRowsForChildren(params) {
     await run.statement({
       statement: {
         kind: "delete",
-        table: { name: join.tableName },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace } },
         where: isSelf ? {
           kind: "or",
           operands: [
@@ -6193,7 +6257,7 @@ async function loadMemberKeys(params) {
     const rows = await run.statement({
       statement: {
         kind: "select",
-        table: { name: join.tableName },
+        table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace } },
         columns: [{ name: join.childColumn }],
         where: narrow === null ? parentMatch : {
           kind: "and",
@@ -6794,7 +6858,7 @@ function previewOperation(params) {
   };
 }
 // packages/runtime/src/diagnostics/plan.ts
-import { VibeError as VibeError15, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { VibeError as VibeError17, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
 import { NATIVE_RLS, getSqlDialect as getSqlDialect2, renderPostgresExplain, renderPostgresWorkload, renderStatement as renderStatement2 } from "@vibeorm/sql";
 var PLAN_DEFAULTS = Object.freeze({ maxNodes: 200, maxConditionLength: 2000 });
 var CONDITION_KEYS = [
@@ -6813,7 +6877,7 @@ var CONDITION_KEYS = [
   "Output"
 ];
 function planError(params) {
-  return new VibeError15({ code: "VIBE_ADAPTER", message: params.message, meta: {} });
+  return new VibeError17({ code: "VIBE_ADAPTER", message: params.message, meta: {} });
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -6846,14 +6910,14 @@ function parsePostgresPlan(params) {
   const maxNodes = params.maxNodes ?? PLAN_DEFAULTS.maxNodes;
   const includeLiterals = params.includeLiterals === true;
   if (!Number.isInteger(maxNodes) || maxNodes < 1) {
-    throw new VibeError15({ code: "VIBE_CONFIG", message: `maxNodes must be a positive integer, got ${String(maxNodes)}`, meta: { maxNodes } });
+    throw new VibeError17({ code: "VIBE_CONFIG", message: `maxNodes must be a positive integer, got ${String(maxNodes)}`, meta: { maxNodes } });
   }
   let parsed = payload;
   if (typeof payload === "string") {
     try {
       parsed = JSON.parse(payload);
     } catch {
-      throw new VibeError15({
+      throw new VibeError17({
         code: "VIBE_ADAPTER",
         message: "EXPLAIN returned malformed JSON",
         meta: { reason: "malformed-plan-json", mode }
@@ -6921,7 +6985,7 @@ function parsePostgresPlan(params) {
 var WRITE_LEADERS = ["INSERT", "UPDATE", "DELETE", "MERGE", "TRUNCATE", "CREATE", "DROP", "ALTER", "GRANT", "REVOKE", "COPY", "CALL", "DO"];
 var SIDE_EFFECT_CALLS = /\bpg_(?:try_)?advisory_(?:xact_)?lock(?:_shared)?\s*\(/i;
 function refuse(params) {
-  return new VibeError15({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta ?? {} });
+  return new VibeError17({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta ?? {} });
 }
 function executableReadRefusal(params) {
   const normalized = normalizeSql({ text: params.text });
@@ -6972,7 +7036,7 @@ async function readPlanContext(params) {
 }
 function requirePostgres(params) {
   if (params.dialect !== "postgres") {
-    throw unsupportedCapability5({
+    throw unsupportedCapability6({
       dialect: params.dialect,
       feature: "query plan inspection",
       hint: "plan inspection is PostgreSQL-shaped; operation tracing (telemetry) works on every dialect"
@@ -7051,7 +7115,7 @@ async function explainOnSession(params) {
   const context = await readPlanContext({ executor, dialect, rlsContextKeys: contextKeys });
   if (!context.representative) {
     if (params.requireRepresentativeContext === true) {
-      throw new VibeError15({
+      throw new VibeError17({
         code: "VIBE_RLS_CONTEXT",
         message: `refusing to report a plan taken under a non-representative identity: ${context.reason ?? "role bypasses row policies"}`,
         meta: { currentUser: context.currentUser, bypassRls: context.bypassRls, superuser: context.superuser }
@@ -7127,7 +7191,7 @@ async function explainOperation(params) {
   });
 }
 // packages/runtime/src/diagnostics/statement-diagnostics.ts
-import { VibeError as VibeError16 } from "@vibeorm/schema";
+import { VibeError as VibeError18 } from "@vibeorm/schema";
 import { renderPostgresWorkload as renderPostgresWorkload2 } from "@vibeorm/sql";
 var STATEMENT_DIAGNOSTICS_DEFAULTS = Object.freeze({
   slowerThanMs: 0,
@@ -7139,7 +7203,7 @@ var STATEMENT_DIAGNOSTICS_DEFAULTS = Object.freeze({
 });
 var EXPLAIN_MODES = ["off", "estimate", "analyze"];
 function configError(params) {
-  return new VibeError16({ code: "VIBE_CONFIG", message: params.message, meta: params.meta ?? {} });
+  return new VibeError18({ code: "VIBE_CONFIG", message: params.message, meta: params.meta ?? {} });
 }
 function isExplainMode(value) {
   return typeof value === "string" && EXPLAIN_MODES.includes(value);
@@ -7265,7 +7329,7 @@ function summarizePlan(params) {
   };
 }
 function errorCode(error) {
-  return error instanceof VibeError16 ? error.code : "VIBE_INTERNAL";
+  return error instanceof VibeError18 ? error.code : "VIBE_INTERNAL";
 }
 function createStatementDiagnostics(params) {
   const { config, adapter, dialect } = params;
@@ -7376,7 +7440,7 @@ function createStatementDiagnostics(params) {
   };
 }
 // packages/runtime/src/diagnostics/workload.ts
-import { unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect3, renderPostgresWorkload as renderPostgresWorkload3 } from "@vibeorm/sql";
 var STATEMENTS_INFO_MIN_VERSION = 140000;
 var STATEMENTS_MIN_VERSION = 130000;
@@ -7409,7 +7473,7 @@ async function readAvailability(params) {
 async function readWorkloadStatistics(params) {
   const { executor } = params;
   if (params.dialect !== "postgres") {
-    throw unsupportedCapability6({
+    throw unsupportedCapability7({
       dialect: params.dialect,
       feature: "workload statistics (pg_stat_statements)",
       hint: "server workload statistics are PostgreSQL-only; operation telemetry works on every dialect"
@@ -7487,7 +7551,7 @@ async function readWorkloadStatistics(params) {
   };
 }
 // packages/runtime/src/diagnostics/insight.ts
-import { VibeError as VibeError17 } from "@vibeorm/schema";
+import { VibeError as VibeError19 } from "@vibeorm/schema";
 var DIAGNOSTIC_THRESHOLDS = Object.freeze({
   repeatThreshold: 5,
   minRepeatThreshold: 2,
@@ -7505,7 +7569,7 @@ function bounded(params) {
   if (value === undefined)
     return fallback;
   if (!Number.isInteger(value) || value < min || value > max) {
-    throw new VibeError17({
+    throw new VibeError19({
       code: "VIBE_CONFIG",
       message: `${name} must be an integer between ${min} and ${max}, got ${String(value)}`,
       meta: { [name]: value }
@@ -7728,11 +7792,11 @@ function recommendFromPlan(params) {
   return findings.slice(0, maxFindings);
 }
 // packages/runtime/src/relation-loader.ts
-import { VibeError as VibeError19 } from "@vibeorm/schema";
+import { VibeError as VibeError21 } from "@vibeorm/schema";
 import { renderStatement as renderStatement3 } from "@vibeorm/sql";
 
 // packages/runtime/src/computed.ts
-import { VibeError as VibeError18 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } from "@vibeorm/schema";
 function sameNeeds(a, b) {
   if (a.length !== b.length)
     return false;
@@ -7768,7 +7832,7 @@ function assertComputedManifest(params) {
     problems.push(`"${key}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError18({
+    throw new VibeError20({
       code: "VIBE_STALE_CLIENT",
       message: `computed-field config changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { problems }
@@ -7796,7 +7860,7 @@ function resolveRelationConcurrency(params) {
   if (concurrency === undefined)
     return 1;
   if (!Number.isInteger(concurrency) || concurrency < 1) {
-    throw new VibeError19({
+    throw new VibeError21({
       code: "VIBE_CONFIG",
       message: `relationLoading.concurrency must be a positive integer \u2014 got ${String(concurrency)}`,
       meta: { concurrency }
@@ -7944,7 +8008,7 @@ function buildChildStatement(params) {
   if (window === undefined) {
     return {
       kind: "select",
-      table: { name: target.tableName },
+      table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace } },
       columns,
       where,
       ...orderBy === undefined || orderBy.length === 0 ? {} : { orderBy }
@@ -7952,7 +8016,7 @@ function buildChildStatement(params) {
   }
   const inner = {
     kind: "select",
-    table: { name: target.tableName },
+    table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace } },
     columns,
     where,
     rowNumber: { partitionBy: [...window.partitionBy], orderBy: orderBy ?? [], alias: WINDOW_ROW_ALIAS }
@@ -7981,7 +8045,7 @@ function chunkKeys(params) {
     const rendered = renderStatement3({ dialect: ctx.dialect, statement: build(keys.slice(0, 1)) });
     fixed = rendered.values.length - (expands ? arity : 1);
     if (fixed + arity > budget) {
-      throw new VibeError19({
+      throw new VibeError21({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: `relation "${relation}" needs ${fixed + arity} bound parameters for its own predicate, more than ${ctx.dialect.name}'s ${budget}-parameter statement budget \u2014 narrow the nested filter`,
         meta: { relation, dialect: ctx.dialect.name, required: fixed + arity, budget }
@@ -8111,7 +8175,7 @@ async function loadManyToMany(params) {
   const link = node.link;
   const join = link.join;
   if (join === null) {
-    throw new VibeError19({
+    throw new VibeError21({
       code: "VIBE_INTERNAL",
       message: `manyToMany relation "${node.name}" resolved without join-table wiring`
     });
@@ -8156,11 +8220,11 @@ async function loadManyToMany(params) {
     const where = nestedWhere === undefined ? membership : { kind: "and", operands: [membership, nestedWhere] };
     const base = {
       kind: "select",
-      table: { name: target.tableName },
+      table: { name: target.tableName, ...target.namespace === undefined ? {} : { namespace: target.namespace } },
       columns: [...childColumns, { table: M2M_JOIN_ALIAS, name: join.parentColumn, alias: M2M_PARENT_ALIAS }],
       innerJoins: [
         {
-          table: { name: join.tableName, alias: M2M_JOIN_ALIAS },
+          table: { name: join.tableName, ...join.namespace === undefined ? {} : { namespace: join.namespace }, alias: M2M_JOIN_ALIAS },
           on: [
             {
               left: { table: M2M_JOIN_ALIAS, name: join.childColumn },
@@ -8270,7 +8334,7 @@ async function loadCounts(params) {
       const where = filter === undefined ? membership : { kind: "and", operands: [membership, filter] };
       const base = {
         kind: "select",
-        table: { name: joinsChildTable ? target.tableName : table },
+        table: { name: joinsChildTable ? target.tableName : table, ...(joinsChildTable || join === null ? target.namespace : join.namespace) === undefined ? {} : { namespace: joinsChildTable || join === null ? target.namespace : join.namespace } },
         columns: projectedColumns,
         selectExpr: { kind: "countAll", alias: COUNT_VALUE_ALIAS },
         where,
@@ -8282,7 +8346,7 @@ async function loadCounts(params) {
         ...base,
         innerJoins: [
           {
-            table: { name: join.tableName, alias: M2M_JOIN_ALIAS },
+            table: { name: join.tableName, ...join?.namespace === undefined ? {} : { namespace: join.namespace }, alias: M2M_JOIN_ALIAS },
             on: [
               {
                 left: { table: M2M_JOIN_ALIAS, name: join.childColumn },
@@ -8408,7 +8472,7 @@ async function attachLateralRelations(params) {
         try {
           parsed = JSON.parse(raw);
         } catch (cause) {
-          throw new VibeError19({
+          throw new VibeError21({
             code: "VIBE_INTERNAL",
             message: `relation column "${column}" returned text that is not valid JSON`,
             meta: { relation: node.name },
@@ -8418,7 +8482,7 @@ async function attachLateralRelations(params) {
       }
       if (isList) {
         if (!Array.isArray(parsed)) {
-          throw new VibeError19({ code: "VIBE_INTERNAL", message: "to-many relation payload must be an array", meta: { relation: node.name } });
+          throw new VibeError21({ code: "VIBE_INTERNAL", message: "to-many relation payload must be an array", meta: { relation: node.name } });
         }
         const children = parsed.map(decodePosition);
         for (const child of children) {
@@ -8459,7 +8523,7 @@ async function attachLateralRelations(params) {
       const raw = row[column];
       const count = typeof raw === "number" || typeof raw === "bigint" || typeof raw === "string" && /^\d+$/.test(raw) ? Number(raw) : NaN;
       if (!Number.isSafeInteger(count) || count < 0) {
-        throw new VibeError19({ code: "VIBE_INTERNAL", message: "relation count payload must be a non-negative safe integer", meta: { relation: selection.counts[index]?.name } });
+        throw new VibeError21({ code: "VIBE_INTERNAL", message: "relation count payload must be a non-negative safe integer", meta: { relation: selection.counts[index]?.name } });
       }
       counts[selection.counts[index].name] = count;
       delete row[column];
@@ -8468,11 +8532,11 @@ async function attachLateralRelations(params) {
   }
 }
 // packages/runtime/src/views.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { VibeError as VibeError23 } from "@vibeorm/schema";
 
 // packages/runtime/src/sql-access.ts
 import { Buffer as Buffer2 } from "buffer";
-import { VibeError as VibeError20 } from "@vibeorm/schema";
+import { VibeError as VibeError22 } from "@vibeorm/schema";
 import { isSqlFragment as isSqlFragment2 } from "@vibeorm/sql";
 function containsSqlFragment(value, seen = new Set) {
   if (isSqlFragment2(value))
@@ -8497,7 +8561,7 @@ function containsSqlFragment(value, seen = new Set) {
   return false;
 }
 function restrictedSqlArgs(params) {
-  const refuse = () => params.refusal?.() ?? new VibeError20({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
+  const refuse = () => params.refusal?.() ?? new VibeError22({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
   if (containsSqlFragment(params.value))
     throw refuse();
   const seen = new Map;
@@ -8559,13 +8623,13 @@ function restrictConflictPredicates(params) {
     const target = spec.target;
     const declared = conflictSchemas.get(params.meta)?.get(params.model.name)?.some((index) => typeof spec.where === "string" && index.where === spec.where && Array.isArray(target) && target.length === index.fields.length && index.fields.every((field, position) => field === target[position]));
     if (declared !== true)
-      throw new VibeError20({ code: "VIBE_VALIDATION", message: `${params.path}: ${key}.where must match a declared unique index and its target fields; free-form SQL requires the unrestricted client`, meta: { model: params.model.name, path: params.path } });
+      throw new VibeError22({ code: "VIBE_VALIDATION", message: `${params.path}: ${key}.where must match a declared unique index and its target fields; free-form SQL requires the unrestricted client`, meta: { model: params.model.name, path: params.path } });
   }
 }
 
 // packages/runtime/src/views.ts
 function validationError6(params) {
-  return new VibeError21({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError23({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 
 class ViewResult {
@@ -8919,7 +8983,7 @@ function createView(params) {
   for (const [clientName, mask] of resolved) {
     const delegate = models[clientName];
     if (delegate === undefined) {
-      throw new VibeError21({
+      throw new VibeError23({
         code: "VIBE_INTERNAL",
         message: `view "${name}": no delegate for model "${mask.model.name}"`,
         meta: { view: name, model: mask.model.name }
@@ -8935,9 +8999,9 @@ function attachDefineView(params) {
   Object.defineProperty(client, "$defineView", { value, enumerable: true });
 }
 // packages/runtime/src/validators.ts
-import { VibeError as VibeError22 } from "@vibeorm/schema";
+import { VibeError as VibeError24 } from "@vibeorm/schema";
 function validationFailed(params) {
-  return new VibeError22({
+  return new VibeError24({
     code: "VIBE_VALIDATION",
     message: `validation failed for ${params.model}.${params.field}: ${params.issues[0]?.message ?? "invalid value"}`,
     meta: { model: params.model, field: params.field, issues: params.issues }
@@ -8946,7 +9010,7 @@ function validationFailed(params) {
 function validateValue(params) {
   const result = params.schema["~standard"].validate(params.value);
   if (result instanceof Promise) {
-    throw new VibeError22({
+    throw new VibeError24({
       code: "VIBE_VALIDATION",
       message: `async validator on ${params.model}.${params.field} \u2014 write validators must be synchronous (validate before calling the client for async rules)`,
       meta: { model: params.model, field: params.field }
@@ -9069,10 +9133,10 @@ function deferPolicyOperation(params) {
 }
 
 // packages/runtime/src/policy.ts
-import { VibeError as VibeError24 } from "@vibeorm/schema";
+import { VibeError as VibeError27 } from "@vibeorm/schema";
 
 // packages/runtime/src/module-context.ts
-import { VibeError as VibeError23 } from "@vibeorm/schema";
+import { VibeError as VibeError25 } from "@vibeorm/schema";
 var binders = new WeakMap;
 function registerModuleBinder(params) {
   binders.set(params.client, params.bind);
@@ -9085,7 +9149,7 @@ function inheritReadOnlyModuleBinder(params) {
 function bindModuleContext(params) {
   const bind = binders.get(params.db);
   if (bind === undefined)
-    throw new VibeError23({
+    throw new VibeError25({
       code: "VIBE_CONFIG",
       message: `Module ${params.artifact.manifest.id} needs an unrestricted handle from the same VibeORM runtime installation; scoped and foreign handles cannot attach package models`,
       meta: { reason: "module_handle", moduleId: params.artifact.manifest.id, protocol: params.artifact.manifest.protocol }
@@ -9094,9 +9158,10 @@ function bindModuleContext(params) {
 }
 
 // packages/runtime/src/read-only.ts
-import { ReadOnlyClientError } from "@vibeorm/schema";
+import { ReadOnlyClientError, VibeError as VibeError26 } from "@vibeorm/schema";
 var READ_DELEGATE_METHODS = Object.freeze([
   "findMany",
+  "findPage",
   "findFirst",
   "findFirstOrThrow",
   "findUnique",
@@ -9124,6 +9189,42 @@ var DELEGATE_METHOD_ACCESS = Object.freeze(Object.fromEntries([
 function delegateMethodAccess(params) {
   return Object.hasOwn(DELEGATE_METHOD_ACCESS, params.method) ? DELEGATE_METHOD_ACCESS[params.method] : undefined;
 }
+function createDelegateMethodClassifier(params) {
+  const context = contexts.get(params.db);
+  if (context === undefined)
+    throw new VibeError26({
+      code: "VIBE_CONFIG",
+      message: "Configured classification requires a registered VibeORM client handle",
+      meta: { reason: "delegate-classifier-handle" }
+    });
+  context.assertActive?.();
+  return ({ method, model }) => {
+    context.assertActive?.();
+    const target = model === undefined ? undefined : context.meta.models.find((entry) => entry.name === model || entry.clientName === model);
+    if (model !== undefined && target === undefined)
+      return;
+    const core = delegateMethodAccess({ method });
+    if (core !== undefined)
+      return core;
+    const parts = method.split(".");
+    if (parts.length > 2)
+      return;
+    const [property, member] = parts;
+    const mount = context.mounts.find((entry) => entry.property === property && (target === undefined ? entry.scope === "client" : entry.scope === "model" && entry.model === target.name));
+    if (mount === undefined || mount.readOnly === undefined)
+      return;
+    const root = params.db;
+    const owner = target === undefined ? root : root.$models?.[target.name];
+    if (typeof owner !== "object" || owner === null || property === undefined)
+      return;
+    const value = owner[property];
+    if (mount.readOnly === true)
+      return member === undefined && typeof value === "function" ? "read" : undefined;
+    if (member === undefined || !mount.readOnly.includes(member) || typeof value !== "object" || value === null)
+      return;
+    return typeof value[member] === "function" ? "read" : undefined;
+  };
+}
 var CLIENT_MEMBER_ACCESS = Object.freeze({
   $models: "rebuilt",
   $on: "forwarded",
@@ -9323,8 +9424,11 @@ function readOnlyOver(params) {
   const existing = facades.get(params.client);
   if (existing !== undefined)
     return existing;
-  const built = buildReadOnly(params);
+  const context = contexts.get(params.client) ?? params.context;
+  const built = buildReadOnly({ client: params.client, context });
   inheritReadOnlyModuleBinder({ from: params.client, to: built });
+  inheritTransactionObservation({ from: params.client, to: built });
+  contexts.set(built, context);
   facades.set(params.client, built);
   return built;
 }
@@ -9332,7 +9436,8 @@ function attachReadOnly(params) {
   const context = {
     meta: params.meta,
     mounts: params.mounts ?? [],
-    operations: params.operations
+    operations: params.operations,
+    ...params.assertActive === undefined ? {} : { assertActive: params.assertActive }
   };
   contexts.set(params.client, context);
   Object.defineProperty(params.client, "$readOnly", {
@@ -9346,6 +9451,7 @@ function inheritReadOnly(params) {
   if (context === undefined)
     return;
   contexts.set(params.to, context);
+  inheritTransactionObservation({ from: params.from, to: params.to });
   Object.defineProperty(params.to, "$readOnly", {
     value: () => readOnlyOver({ client: params.to, context }),
     enumerable: true,
@@ -9355,7 +9461,7 @@ function inheritReadOnly(params) {
 
 // packages/runtime/src/policy.ts
 function policyError(message, meta) {
-  return new VibeError24({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
+  return new VibeError27({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
 }
 function policiedModels(meta) {
   return meta.models.filter((model) => model.policy !== undefined);
@@ -9705,9 +9811,10 @@ function scopedDelegate(params) {
     const pkWhere = pk.length === 1 ? { [pk[0]]: target[pk[0]] } : { [pkClientKey()]: Object.fromEntries(pk.map((name) => [name, target[name]])) };
     return write(raw, pkWhere);
   };
-  const notFound = (method) => new VibeError24({ code: "VIBE_NOT_FOUND", message: `${method} on ${model.name}: no row matches the unique where inside the bound policy context`, meta: { model: model.name, method } });
+  const notFound = (method) => new VibeError27({ code: "VIBE_NOT_FOUND", message: `${method} on ${model.name}: no row matches the unique where inside the bound policy context`, meta: { model: model.name, method } });
   return {
     findMany: (args) => base.findMany(scopeFind(args)),
+    findPage: (args) => base.findPage(scopeFind(args)),
     findFirst: (args) => base.findFirst(scopeFind(args)),
     findFirstOrThrow: (args) => base.findFirstOrThrow(scopeFind(args)),
     findUnique: (args) => base.findFirst(scopeUnique(args)),
@@ -9739,7 +9846,7 @@ function scopedDelegate(params) {
       })
     })),
     upsertMany: () => {
-      throw new VibeError24({
+      throw new VibeError27({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "upsertMany is not available on a policy-bound client: its conflict target is not policy-checked yet",
         meta: { model: model.name }
@@ -9748,7 +9855,7 @@ function scopedDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError24({
+        throw new VibeError27({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate",
           meta: { model: model.name }
@@ -9807,6 +9914,7 @@ function globalDelegate(params) {
   const payload = (value, phase) => forceWriteData({ meta, model, data: value ?? {}, context, phase });
   const overrides = {
     findMany: (args) => base.findMany(readArgs(args)),
+    findPage: (args) => base.findPage(readArgs(args)),
     findFirst: (args) => base.findFirst(readArgs(args)),
     findFirstOrThrow: (args) => base.findFirstOrThrow(readArgs(args)),
     findUnique: (args) => base.findUnique(readArgs(args)),
@@ -9822,7 +9930,7 @@ function globalDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError24({
+        throw new VibeError27({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate"
         });
@@ -9833,7 +9941,7 @@ function globalDelegate(params) {
     upsertMany: (args) => deferred(() => {
       if (params.policyBound === false)
         return base.upsertMany(args);
-      throw new VibeError24({
+      throw new VibeError27({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "upsertMany is not available on a policy-bound client: its conflict target is not policy-checked yet"
       });
@@ -10004,7 +10112,7 @@ function attachPolicy(params) {
   });
 }
 // packages/runtime/src/scoped.ts
-import { ScopedQueryError, VibeError as VibeError25 } from "@vibeorm/schema";
+import { ScopedQueryError, VibeError as VibeError28 } from "@vibeorm/schema";
 function refusal(params) {
   return new ScopedQueryError(params);
 }
@@ -10728,7 +10836,7 @@ function createScopeRewriter(params) {
     })
   };
 }
-var FIND_LIKE = ["findMany", "findFirst", "findFirstOrThrow", "count", "aggregate", "groupBy"];
+var FIND_LIKE = ["findPage", "findMany", "findFirst", "findFirstOrThrow", "count", "aggregate", "groupBy"];
 function rewriteScopedCall(params) {
   const { meta, resolved, scope, preds, method } = params;
   const ctx = { meta, resolved, scope, preds };
@@ -10857,6 +10965,7 @@ function scopedDelegate2(params) {
   };
   return {
     findMany: (args) => run("findMany", args),
+    findPage: (args) => run("findPage", args),
     findFirst: (args) => run("findFirst", args),
     findFirstOrThrow: (args) => run("findFirstOrThrow", args),
     findUnique: (args) => run("findUnique", args),
@@ -10960,7 +11069,7 @@ function attachScoped(params) {
   Object.defineProperty(client, "$scoped", {
     value: (config) => {
       if (!isPlainObject8(config) || !isPlainObject8(config.models)) {
-        throw new VibeError25({
+        throw new VibeError28({
           code: "VIBE_VALIDATION",
           message: "$scoped takes { scope: string | number | bigint | null, models: { <Model>: \u2026 } }"
         });
@@ -10976,7 +11085,7 @@ function attachScoped(params) {
       }
       const scope = config.scope;
       if (scope !== null && typeof scope !== "string" && typeof scope !== "number" && typeof scope !== "bigint") {
-        throw new VibeError25({
+        throw new VibeError28({
           code: "VIBE_VALIDATION",
           message: `$scoped: scope must be a string, number, bigint or null \u2014 got ${typeof scope}`
         });
@@ -10992,7 +11101,7 @@ function attachScoped(params) {
   });
 }
 // packages/runtime/src/rls-readiness.ts
-import { VibeError as VibeError26, assertValidSchemaIR, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError29, assertValidSchemaIR, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { NATIVE_RLS as NATIVE_RLS2, getSqlDialect as getSqlDialect4, renderRlsPolicy, renderRlsRole, NATIVE_RLS_PROBE_POLICY, renderRlsReadinessQuery, renderRlsProbeTable } from "@vibeorm/sql";
 import { RLS_READINESS_SQL, NATIVE_RLS_PROBE_POLICY as NATIVE_RLS_PROBE_POLICY2 } from "@vibeorm/sql";
 function textOf(params) {
@@ -11016,7 +11125,7 @@ function intOf(params) {
   return Number.parseInt(value, 10);
 }
 function unreadableCatalog(params) {
-  return new VibeError26({
+  return new VibeError29({
     code: "VIBE_ADAPTER",
     message: `native RLS readiness could not read the "${params.key}" result of the folded catalog read: ${params.detail}. ` + "The inspection is refused rather than treated as an empty result set.",
     meta: { result: params.key }
@@ -11072,10 +11181,10 @@ function unprotectedTablesOf(params) {
 function requireNativeRls(params) {
   const dialect = getSqlDialect4({ dialect: params.adapter.dialect });
   if (!dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability7({ dialect: dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability8({ dialect: dialect.name, feature: "nativeRowLevelSecurity" });
   }
   if (params.schema.rls === undefined) {
-    throw new VibeError26({
+    throw new VibeError29({
       code: "VIBE_CONFIG",
       message: "Native row-level security readiness requires a schema that declares native RLS"
     });
@@ -11092,24 +11201,27 @@ async function probeExpressions(params) {
   if (tables.length === 0)
     return { available: true, expressions: [] };
   return adapter.transaction(async (tx) => {
-    const current = await tx.execute(renderRlsReadinessQuery({ dialect, query: "readSearchPath" }));
+    const current = await tx.execute({ ...renderRlsReadinessQuery({ dialect, query: "readSearchPath" }), effect: "read" });
     const searchPath = current[0] === undefined ? "" : textOf({ row: current[0], key: "searchPath" });
-    await tx.execute(renderRlsReadinessQuery({ dialect, query: "setSearchPath", searchPath: "" }));
+    await tx.execute({ ...renderRlsReadinessQuery({ dialect, query: "setSearchPath", searchPath: "" }), effect: "read" });
     for (const entry of params.desired === undefined ? tables : []) {
-      await tx.executeUnsafe(renderRlsProbeTable({ dialect, table: entry.table, action: "create" }));
-      await tx.executeUnsafe(renderRlsPolicy({
-        dialect,
-        schema,
-        model: entry.model,
-        policyName: NATIVE_RLS_PROBE_POLICY,
-        targetSchema: "pg_temp"
-      }));
+      await tx.executeUnsafe({ ...renderRlsProbeTable({ dialect, table: entry.table, action: "create" }), effect: "read" });
+      await tx.executeUnsafe({
+        ...renderRlsPolicy({
+          dialect,
+          schema,
+          model: entry.model,
+          policyName: NATIVE_RLS_PROBE_POLICY,
+          targetSchema: "pg_temp"
+        }),
+        effect: "read"
+      });
     }
-    const rows = await tx.execute(renderRlsReadinessQuery({ dialect, query: "expressions" }));
+    const rows = await tx.execute({ ...renderRlsReadinessQuery({ dialect, query: "expressions" }), effect: "read" });
     for (const entry of params.desired === undefined ? tables : []) {
-      await tx.executeUnsafe(renderRlsProbeTable({ dialect, table: entry.table, action: "drop" }));
+      await tx.executeUnsafe({ ...renderRlsProbeTable({ dialect, table: entry.table, action: "drop" }), effect: "read" });
     }
-    await tx.execute(renderRlsReadinessQuery({ dialect, query: "setSearchPath", searchPath }));
+    await tx.execute({ ...renderRlsReadinessQuery({ dialect, query: "setSearchPath", searchPath }), effect: "read" });
     return {
       available: true,
       expressions: [...rows.filter((row) => params.desired === undefined || row.probe === false).map((row) => ({
@@ -11366,7 +11478,7 @@ async function inspectNativeRlsTransaction(params) {
   const dialect = requireNativeRls({ adapter, schema });
   const protectedTables = protectedTablesOf({ schema });
   const unprotected = unprotectedTablesOf({ schema });
-  const catalogRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "catalog" }));
+  const catalogRows = await adapter.execute({ ...renderRlsReadinessQuery({ dialect, query: "catalog" }), effect: "read" });
   const catalog = catalogRows[0] ?? {};
   const identityRow = catalogRowsOf({ row: catalog, key: "identity" })[0] ?? {};
   const identity = {
@@ -11476,7 +11588,7 @@ async function inspectNativeRls(params) {
   const embeddedRole = adapter.provider === "pglite" ? requireEmbeddedRole({ role: params.runtimeRole }) : undefined;
   return adapter.transaction(async (tx) => {
     if (embeddedRole !== undefined) {
-      await tx.executeUnsafe(renderRlsRole({ dialect: getSqlDialect4({ dialect: adapter.dialect }), role: embeddedRole }));
+      await tx.executeUnsafe({ ...renderRlsRole({ dialect: getSqlDialect4({ dialect: adapter.dialect }), role: embeddedRole }), effect: "read" });
     }
     return inspectNativeRlsTransaction({
       adapter: tx,
@@ -11488,7 +11600,7 @@ async function inspectNativeRls(params) {
 function requireEmbeddedRole(params) {
   const { role } = params;
   if (typeof role !== "string" || role.length === 0 || role.includes("\x00")) {
-    throw new VibeError26({
+    throw new VibeError29({
       code: "VIBE_CONFIG",
       message: "PGlite native row-level security requires a pre-existing restricted runtime role (nativeRls.runtimeRole) \u2014 its default embedded session is privileged and bypasses every policy",
       meta: { provider: "pglite" }
@@ -11500,7 +11612,7 @@ function assertNativeRlsReady(params) {
   const { report } = params;
   if (report.ready)
     return;
-  throw new VibeError26({
+  throw new VibeError29({
     code: "VIBE_CONFIG",
     message: `Native row-level security is not ready on this database: ${report.problems.map((problem) => `${problem.name} (${problem.status})`).join(", ")}`,
     meta: {
@@ -11525,17 +11637,114 @@ function formatNativeRlsReport(params) {
   return lines;
 }
 // packages/runtime/src/database-module.ts
-import { createHash } from "crypto";
-import { VibeError as VibeError31, assertValidSchemaIR as assertValidSchemaIR3, providerToDialect } from "@vibeorm/schema";
+import { createHash as createHash2 } from "crypto";
+import { VibeError as VibeError35, assertValidSchemaIR as assertValidSchemaIR3, prepareDatabaseModuleSchema, providerToDialect } from "@vibeorm/schema";
+
+// packages/runtime/src/client.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// packages/runtime/src/find-page.ts
+import { VibeError as VibeError30 } from "@vibeorm/schema";
+
+// packages/runtime/src/keyset-projection.ts
+function keysetProjection(params) {
+  const { plan, select, omit } = params;
+  const names = plan.keys.map((key) => key.field.name);
+  if (select !== undefined) {
+    const hidden = names.filter((name) => select[name] !== true);
+    if (hidden.length === 0)
+      return { select, hidden };
+    const widened = { ...select };
+    for (const name of hidden)
+      widened[name] = true;
+    return { select: widened, hidden };
+  }
+  if (omit !== undefined) {
+    const hidden = names.filter((name) => omit[name] === true);
+    if (hidden.length === 0)
+      return { omit, hidden };
+    const narrowed = { ...omit };
+    for (const name of hidden)
+      narrowed[name] = false;
+    return { omit: narrowed, hidden };
+  }
+  return { hidden: [] };
+}
+
+// packages/runtime/src/find-page.ts
+var PAGE_ARGUMENTS = new Set([
+  "where",
+  "orderBy",
+  "take",
+  "after",
+  "select",
+  "include",
+  "omit",
+  "relationStrategy",
+  "keyset"
+]);
+function validatePageArgs(params) {
+  const { model, args } = params;
+  if (typeof args !== "object" || args === null || Array.isArray(args)) {
+    throw new VibeError30({ code: "VIBE_VALIDATION", message: `${model}.findPage requires an argument object`, meta: { model, reason: "keyset-page-args" } });
+  }
+  for (const key of Object.keys(args)) {
+    if (!PAGE_ARGUMENTS.has(key)) {
+      throw new VibeError30({ code: "VIBE_VALIDATION", message: `${model}.findPage does not accept ${key}`, meta: { model, argument: key, reason: "keyset-page-argument" } });
+    }
+  }
+  const take = "take" in args ? args.take : undefined;
+  if (typeof take !== "number" || !Number.isSafeInteger(take) || take < 1 || take > KEYSET_MAX_PAGE_SIZE) {
+    throw new VibeError30({ code: "VIBE_VALIDATION", message: `findPage take must be an integer between 1 and ${KEYSET_MAX_PAGE_SIZE}`, meta: { model, reason: "keyset-page-size" } });
+  }
+  return args;
+}
+function preparePage(params) {
+  const { meta, model, dialect, args } = params;
+  const plan = compileKeysetOrderPlan({
+    model,
+    dialect,
+    terms: compileKeysetOrderInputs({ meta, model, dialect, orderBy: args.orderBy }),
+    ...parseKeysetOptions({ model, value: args.keyset })
+  });
+  const projection = keysetProjection({
+    plan,
+    select: args.select,
+    omit: args.omit
+  });
+  return {
+    plan,
+    args: {
+      ...args,
+      take: args.take + 1,
+      ...projection.select === undefined ? {} : { select: projection.select },
+      ...projection.omit === undefined ? {} : { omit: projection.omit }
+    }
+  };
+}
+function pageContinuation(params) {
+  const { plan, rows, take, after } = params;
+  const first = rows[0];
+  if (typeof after === "string" && first !== undefined && keysetRowIsAfter({
+    keys: plan.keys,
+    row: keysetRowValues({ plan, row: first }),
+    position: decodeKeysetToken({ plan, token: after })
+  }) === false) {
+    throw new VibeError30({ code: "VIBE_DATA_INVALID", message: `keyset page for ${plan.model} is not advancing; check ordering precision`, meta: { model: plan.model, reason: "keyset-position-not-advancing" } });
+  }
+  const last = rows[take - 1];
+  return rows.length > take && last !== undefined ? encodeKeysetToken({ plan, row: last }) : null;
+}
 
 // packages/runtime/src/client.ts
 import { compileSql } from "@vibeorm/sql";
-import { RlsContextError as RlsContextError2, VibeError as VibeError30, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { RlsContextError as RlsContextError2, VibeError as VibeError34, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability9 } from "@vibeorm/schema";
 import { ADVISORY_LOCK_RESULT_COLUMN, ParamCollector, getSqlDialect as getSqlDialect5, renderRlsContext, renderRlsPolicy as renderRlsPolicy2, renderRlsRole as renderRlsRole2, renderStatement as renderStatement5 } from "@vibeorm/sql";
 
 // packages/runtime/src/render-cache.ts
 import {
   isSqlFragment as isSqlFragment3,
+  isNativeEnumArrayParameter,
   isDbNowMarker,
   isJsonParamCell,
   isListSetOperation,
@@ -11587,7 +11796,22 @@ function addCol(walk, column) {
     addIdent(walk, column.alias);
   }
 }
+function addParameter(walk, value) {
+  if (isNativeEnumArrayParameter(value)) {
+    walk.key += "enumArray";
+    addIdent(walk, value.type.namespace);
+    addIdent(walk, value.type.name);
+    walk.values.push(value.value);
+    return;
+  }
+  walk.key += "param";
+  walk.values.push(value);
+}
 function addTable(walk, table) {
+  if (table.namespace !== undefined) {
+    walk.key += "namespace";
+    addIdent(walk, table.namespace);
+  }
   addIdent(walk, table.name);
   if (table.alias !== undefined) {
     walk.key += "@";
@@ -11609,7 +11833,7 @@ function addSetEntry(walk, name, value) {
   if (isSetOperation(value)) {
     walk.key += `=o${value.__op}`;
     addIdent(walk, name);
-    walk.values.push(value.value);
+    addParameter(walk, value.value);
     return;
   }
   if (isDbNowMarker(value)) {
@@ -11622,12 +11846,12 @@ function addSetEntry(walk, name, value) {
   if (isListSetOperation(value)) {
     walk.key += `=l${value.__listOp}`;
     addIdent(walk, name);
-    walk.values.push(value.value);
+    addParameter(walk, value.value);
     return;
   }
   walk.key += "=v";
   addIdent(walk, name);
-  walk.values.push(value);
+  addParameter(walk, value);
 }
 function addReturning(walk, returning) {
   if (returning === undefined || returning.length === 0) {
@@ -11651,7 +11875,7 @@ function walkExpr(walk, dialect, expr) {
       }
       walk.key += `c${expr.op}`;
       addCol(walk, expr.column);
-      walk.values.push(expr.value);
+      addParameter(walk, expr.value);
       return true;
     case "cmpCol":
       walk.key += `k${expr.op}`;
@@ -11670,7 +11894,7 @@ function walkExpr(walk, dialect, expr) {
       walk.key += expr.negate === true ? "i1" : "i0";
       addCol(walk, expr.column);
       if (dialect.inArrayStrategy === "any") {
-        walk.values.push([...expr.values]);
+        addParameter(walk, Array.isArray(expr.values) ? [...expr.values] : expr.values);
       } else {
         walk.key += `#${expr.values.length}`;
         for (const value of expr.values)
@@ -11730,22 +11954,22 @@ function walkExpr(walk, dialect, expr) {
     case "aggCmp":
       walk.key += `g${expr.op}`;
       addAgg(walk, expr.agg);
-      walk.values.push(expr.value);
+      addParameter(walk, expr.value);
       return true;
     case "arrayHas":
       walk.key += expr.negate === true ? "h1" : "h0";
       addCol(walk, expr.column);
-      walk.values.push(expr.value);
+      addParameter(walk, expr.value);
       return true;
     case "arrayContainsAll":
       walk.key += "H";
       addCol(walk, expr.column);
-      walk.values.push([...expr.values]);
+      addParameter(walk, Array.isArray(expr.values) ? [...expr.values] : expr.values);
       return true;
     case "arrayOverlaps":
       walk.key += "V";
       addCol(walk, expr.column);
-      walk.values.push([...expr.values]);
+      addParameter(walk, Array.isArray(expr.values) ? [...expr.values] : expr.values);
       return true;
     case "arrayIsEmpty":
       walk.key += expr.empty ? "e1" : "e0";
@@ -12041,11 +12265,11 @@ function renderStatementCached(params) {
 }
 
 // packages/runtime/src/strict-args.ts
-import { VibeError as VibeError27 } from "@vibeorm/schema";
+import { VibeError as VibeError31 } from "@vibeorm/schema";
 var SKIP = Symbol.for("vibeorm.skip");
 function explicitUndefined(params) {
   const { model, method, path } = params;
-  return new VibeError27({
+  return new VibeError31({
     code: "VIBE_VALIDATION",
     message: `${model}.${method}(): explicit undefined at ${path} \u2014 an undefined value is refused ` + `because it would silently drop the property (widening a filter or losing a write). ` + `Omit the property, or pass SKIP to omit it deliberately; ` + `VibeClient({ strictArguments: false }) restores the legacy behaviour.`,
     meta: { model, method, path }
@@ -12251,10 +12475,10 @@ function bindRlsContext(params) {
 }
 
 // packages/runtime/src/telemetry/recorder.ts
-import { VibeError as VibeError29 } from "@vibeorm/schema";
+import { VibeError as VibeError33 } from "@vibeorm/schema";
 
 // packages/runtime/src/telemetry/config.ts
-import { VibeError as VibeError28 } from "@vibeorm/schema";
+import { VibeError as VibeError32 } from "@vibeorm/schema";
 var TELEMETRY_DEFAULTS = Object.freeze({
   captureSql: false,
   captureParameterValues: false,
@@ -12269,7 +12493,7 @@ var TELEMETRY_DEFAULTS = Object.freeze({
   latencyBucketsMs: Object.freeze([1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000])
 });
 function configError2(params) {
-  return new VibeError28({
+  return new VibeError32({
     code: "VIBE_CONFIG",
     message: `telemetry: ${params.message}`,
     ...params.meta === undefined ? {} : { meta: params.meta }
@@ -12357,7 +12581,7 @@ function deriveStage(params) {
   return "decode";
 }
 function errorCodeOf(error) {
-  return error instanceof VibeError29 ? error.code : undefined;
+  return error instanceof VibeError33 ? error.code : undefined;
 }
 function newHistogram(bounds) {
   return { counts: new Array(bounds.length + 1).fill(0), sum: 0, count: 0 };
@@ -12740,7 +12964,7 @@ async function instrumentStatement(params) {
 // packages/runtime/src/client.ts
 function notFound2(params) {
   const { model, method } = params;
-  return new VibeError30({
+  return new VibeError34({
     code: "VIBE_NOT_FOUND",
     message: `no ${model} record matched the where clause of ${method}()`,
     meta: { model, method }
@@ -12748,7 +12972,7 @@ function notFound2(params) {
 }
 function transactionLifecycleRefusal(params) {
   const { method } = params;
-  return new VibeError30({
+  return new VibeError34({
     code: "VIBE_VALIDATION",
     message: `${method}() is not available on a transaction client \u2014 the connection is owned by the open transaction; call it on the client that started the transaction`,
     meta: { method, inTransaction: true }
@@ -12756,7 +12980,7 @@ function transactionLifecycleRefusal(params) {
 }
 function viewIsReadOnly(params) {
   const { model, method } = params;
-  return new VibeError30({
+  return new VibeError34({
     code: "VIBE_VALIDATION",
     message: `${model} is a view \u2014 ${method}() is not available on views (they are read-only); write to the underlying table instead`,
     meta: { model, method }
@@ -12863,7 +13087,7 @@ async function engineTransaction(params) {
     const support = engine.adapter.budgets?.transactionDeadline;
     const requested = options.deadline.enforcement ?? "between-statements";
     if (support === undefined || support === "unsupported" || requested === "cancel-running-statements" && support !== "cancel-running-statements") {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "the adapter does not declare support for the requested transaction deadline",
         meta: { provider: engine.adapter.provider, feature: "transactionDeadline", requested, supported: support ?? "undeclared" }
@@ -12876,10 +13100,10 @@ async function engineTransaction(params) {
     const execute = async () => {
       if (engine.rlsSchema !== undefined && engine.inTransaction !== true) {
         if (adapter.provider === "pglite") {
-          await adapter.executeUnsafe(renderRlsRole2({ dialect: engine.dialect, role: engine.options.nativeRls.runtimeRole }));
+          await adapter.executeUnsafe({ ...renderRlsRole2({ dialect: engine.dialect, role: engine.options.nativeRls.runtimeRole }), effect: "read" });
         }
         if (engine.context !== undefined && Object.keys(engine.rlsSchema.rls.context).length > 0) {
-          await adapter.executeUnsafe(renderRlsContext({ dialect: engine.dialect, context: engine.rlsSchema.rls.context, values: engine.context.settings }));
+          await adapter.executeUnsafe({ ...renderRlsContext({ dialect: engine.dialect, context: engine.rlsSchema.rls.context, values: engine.context.settings }), effect: "read" });
         }
         const readiness = await inspectNativeRlsTransaction({ adapter, schema: engine.rlsSchema, runtimeRole: engine.options.nativeRls?.runtimeRole, cacheKey: engine.rootIdentity });
         assertNativeRlsReady({ report: readiness });
@@ -13052,7 +13276,7 @@ class QueryPromise extends Promise {
   }
   #claim() {
     if (this.#started) {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_VALIDATION",
         message: "$transaction([...]) needs operations that have not dispatched \u2014 pass delegate calls in the same tick they are created (this one was awaited or created earlier and already executed outside the transaction)"
       });
@@ -13097,6 +13321,21 @@ var LAZY_OPERATIONS = {
       refuseQueryPromise({ value: params.value, reason: params.reason });
   }
 };
+function statementEffect(params) {
+  if (params.adapter.rowChanges === undefined)
+    return;
+  const { statement, dialect } = params;
+  if (containsSqlFragment(statement))
+    return "unknown";
+  if (statement.kind === "select" || statement.kind === "advisoryLock" || statement.kind === "rlsContext" || statement.kind === "rlsRole")
+    return "read";
+  if (statement.kind === "insert") {
+    if (dialect.upsertForm === "onDuplicateKey" && statement.onConflict !== undefined && !("doNothing" in statement.onConflict))
+      return "unknown";
+    return "write";
+  }
+  return statement.kind === "update" || statement.kind === "delete" ? "write" : "unknown";
+}
 async function runRows(params) {
   const { engine, plan } = params;
   const renderStarted = renderClock({ engine });
@@ -13116,17 +13355,19 @@ async function runRows(params) {
     rowCount: (value) => value.length,
     run: () => engine.adapter.execute({
       text: rendered.text,
-      values: bindValues({ adapter: engine.adapter, values: rendered.values })
+      values: bindValues({ adapter: engine.adapter, values: rendered.values }),
+      effect: statementEffect({ statement: plan.statement, dialect: engine.dialect, adapter: engine.adapter })
     })
   });
   return materializeRows({ dialect: engine.dialect.name, model: plan.model, rows, wire: engine.adapter.wire });
 }
 async function runBoundAffected(params) {
-  const { adapter, text, values } = params;
+  const { adapter, text, values, effect } = params;
+  const input = { text, values, ...effect === undefined ? {} : { effect } };
   const bound = adapter.executeAffected;
   if (bound !== undefined)
-    return await bound.call(adapter, { text, values });
-  return await adapter.executeUnsafe({ text, values });
+    return await bound.call(adapter, input);
+  return await adapter.executeUnsafe(input);
 }
 async function runAffected(params) {
   const { engine, plan } = params;
@@ -13159,7 +13400,8 @@ async function runAffected(params) {
     run: () => runBoundAffected({
       adapter: engine.adapter,
       text: rendered.text,
-      values: bindValues({ adapter: engine.adapter, values: rendered.values })
+      values: bindValues({ adapter: engine.adapter, values: rendered.values }),
+      effect: statementEffect({ statement: plan.statement, dialect: engine.dialect, adapter: engine.adapter })
     })
   });
   return result.affectedRows;
@@ -13170,14 +13412,14 @@ function plan(params) {
   const args = engine.readOnlySql === true ? restrictedSqlArgs({ value: params.args, path: "$readOnly", refusal: () => readOnlyRefusal({ path: `${model}.${method}`, reason: "raw" }) }) : params.args;
   if (args !== undefined && args["lock"] !== undefined) {
     if (engine.inTransaction !== true) {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_VALIDATION",
         message: `lock on ${model}.${method}() requires a transaction \u2014 call it on the client $transaction hands its callback (outside one, the lock would release at statement end)`,
         meta: { model, method }
       });
     }
     if (!LOCKABLE_METHODS.includes(method)) {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_VALIDATION",
         message: `lock on ${model}.${method}() is not supported \u2014 only ${LOCKABLE_METHODS.join(", ")} take a lock. ` + `Lock the rows with a find inside the transaction, then write them`,
         meta: { model, method }
@@ -13204,7 +13446,7 @@ function readAcquiredVerdict(params) {
     return true;
   if (value === false || value === 0 || value === "f" || value === "false" || value === "0")
     return false;
-  throw new VibeError30({
+  throw new VibeError34({
     code: "VIBE_INTERNAL",
     message: `internal: ${params.method}() expected a boolean "${ADVISORY_LOCK_RESULT_COLUMN}" column, got ${String(value)}`,
     meta: { method: params.method, value: String(value) }
@@ -13246,7 +13488,7 @@ async function insertedKeyWhere(params) {
   const keyField = source.model.primaryKey[0];
   const lastInsertIdSql = engine.dialect.lastInsertIdSql;
   if (lastInsertIdSql === null || source.model.primaryKey.length !== 1 || keyField === undefined) {
-    throw unsupportedCapability8({
+    throw unsupportedCapability9({
       dialect: engine.dialect.name,
       feature: `${source.method} on ${source.model.name} without RETURNING`,
       hint: "this model's key is assigned by the database and cannot be read back on this dialect"
@@ -13264,11 +13506,11 @@ async function insertedKeyWhere(params) {
     text: lastInsertIdSql,
     values: [],
     rowCount: (value) => value.rows.length,
-    run: () => engine.adapter.executeUnsafe({ text: lastInsertIdSql })
+    run: () => engine.adapter.executeUnsafe({ text: lastInsertIdSql, effect: "read" })
   });
   const id = result.rows[0]?.id;
   if (id === undefined || id === null) {
-    throw new VibeError30({
+    throw new VibeError34({
       code: "VIBE_INTERNAL",
       message: `could not read back the generated key for ${source.model.name}`,
       meta: { model: source.model.name }
@@ -13303,7 +13545,8 @@ async function runSingleMutation(params) {
       run: () => runBoundAffected({
         adapter: target.adapter,
         text: rendered.text,
-        values: bindValues({ adapter: target.adapter, values: rendered.values })
+        values: bindValues({ adapter: target.adapter, values: rendered.values }),
+        effect: statementEffect({ statement, dialect: target.dialect, adapter: target.adapter })
       })
     });
     return result;
@@ -13439,7 +13682,8 @@ function relationExecutor(params) {
       rowCount: (value) => value.length,
       run: () => engine.adapter.execute({
         text: rendered.text,
-        values: bindValues({ adapter: engine.adapter, values: rendered.values })
+        values: bindValues({ adapter: engine.adapter, values: rendered.values }),
+        effect: statementEffect({ statement, dialect: engine.dialect, adapter: engine.adapter })
       })
     });
   };
@@ -13521,7 +13765,8 @@ function makeRunner(params) {
         rowCount: (value) => value.length,
         run: () => engine.adapter.execute({
           text: rendered.text,
-          values: bindValues({ adapter: engine.adapter, values: rendered.values })
+          values: bindValues({ adapter: engine.adapter, values: rendered.values }),
+          effect: statementEffect({ statement, dialect: engine.dialect, adapter: engine.adapter })
         })
       });
     }
@@ -13575,6 +13820,16 @@ function createDelegate(params) {
     const rows = shapeRows({ plan: built, rows: await runRows({ engine: target, plan: built }) });
     return await finalizeRows({ engine: target, model: built.model, shape: shapeOf(built), rows });
   };
+  const findPage = async (target, input) => {
+    const args = validatePageArgs({ model, args: input });
+    const original = plan({ engine: target, model, method: "findMany", args });
+    const page = preparePage({ meta: target.meta, model: original.model, dialect: target.dialect, args });
+    const built = plan({ engine: target, model, method: "findMany", args: page.args });
+    const rows = await runRows({ engine: target, plan: built });
+    const nextCursor = pageContinuation({ plan: page.plan, rows, take: args.take, after: args.after });
+    const items = await finalizeRows({ engine: target, model: built.model, shape: shapeOf(original), rows: rows.slice(0, args.take) });
+    return { items, nextCursor };
+  };
   const findFirst = async (target, args) => {
     const built = plan({ engine: target, model, method: "findFirst", args });
     const rows = shapeRows({ plan: built, rows: await runRows({ engine: target, plan: built }) });
@@ -13596,7 +13851,7 @@ function createDelegate(params) {
     const skipping = args.onConflict !== undefined;
     if (hasNestedWrites({ model: modelMeta, data: args.data })) {
       if (skipping) {
-        throw new VibeError30({
+        throw new VibeError34({
           code: "VIBE_VALIDATION",
           message: `onConflict cannot combine with nested writes on ${modelMeta.name}.create() \u2014 insert the parent row alone, then connect relations`,
           meta: { model: modelMeta.name }
@@ -13697,7 +13952,7 @@ function createDelegate(params) {
   const upsert = async (target, args) => {
     const modelMeta = getModelMeta({ meta: target.meta, model });
     if (hasNestedWrites({ model: modelMeta, data: args.create }) || hasNestedWrites({ model: modelMeta, data: args.update })) {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_VALIDATION",
         message: `nested writes are not supported inside upsert arms on ${modelMeta.name} \u2014 use create()/update() with nested data`,
         meta: { model: modelMeta.name }
@@ -13705,7 +13960,7 @@ function createDelegate(params) {
     }
     if (!upsertUsesNativeStatement({ model: modelMeta, args })) {
       if (args.onConflict !== undefined) {
-        throw new VibeError30({
+        throw new VibeError34({
           code: "VIBE_VALIDATION",
           message: `onConflict on ${modelMeta.name}.upsert() needs the native single-statement path \u2014 this shape (a guard field beyond the conflict target, or create data not binding the where's key) runs the find-then-write fallback, which cannot honor an explicit conflict target`,
           meta: { model: modelMeta.name }
@@ -13763,7 +14018,8 @@ function createDelegate(params) {
       rowCount: (value) => value.length,
       run: () => target.adapter.execute({
         text: rendered.text,
-        values: bindValues({ adapter: target.adapter, values: rendered.values })
+        values: bindValues({ adapter: target.adapter, values: rendered.values }),
+        effect: statementEffect({ statement: built.statement, dialect: target.dialect, adapter: target.adapter })
       })
     });
     if (built.aggregateSpec !== null) {
@@ -13803,6 +14059,7 @@ function createDelegate(params) {
   const lazy = (method, run) => createQueryPromise({ engine, run, model, method });
   const delegate = {
     findMany: (args) => lazy("findMany", (target) => findMany(target, args)),
+    findPage: (args) => lazy("findPage", (target) => findPage(target, args)),
     findFirst: (args) => lazy("findFirst", (target) => findFirst(target, args)),
     findUnique: (args) => lazy("findUnique", (target) => findUnique(target, args)),
     findFirstOrThrow: (args) => lazy("findFirstOrThrow", async (target) => {
@@ -13954,7 +14211,8 @@ function buildClient(params) {
       run: () => runBoundAffected({
         adapter: target.adapter,
         text: rendered.text,
-        values: bindValues({ adapter: target.adapter, values: rendered.values })
+        values: bindValues({ adapter: target.adapter, values: rendered.values }),
+        effect: statementEffect({ statement, dialect: target.dialect, adapter: target.adapter })
       })
     });
     if (scope !== undefined)
@@ -13983,7 +14241,7 @@ function buildClient(params) {
     }
     for (const operation of operations) {
       if (!isQueryPromise(operation)) {
-        claimError = new VibeError30({
+        claimError = new VibeError34({
           code: "VIBE_VALIDATION",
           message: "$transaction([...]) takes query promises from model delegate calls \u2014 a foreign promise is already running and cannot join the transaction"
         });
@@ -14048,7 +14306,7 @@ function buildClient(params) {
     $models: models,
     $on: (event, listener) => {
       if (event !== "query") {
-        throw new VibeError30({
+        throw new VibeError34({
           code: "VIBE_VALIDATION",
           message: `unknown client event "${String(event)}" \u2014 supported: "query"`,
           meta: { event }
@@ -14063,7 +14321,7 @@ function buildClient(params) {
     $querySql: async ({ query, decoder }) => {
       assertEngineActive({ engine });
       if (decoder === null || typeof decoder !== "object" || typeof decoder.decode !== "function")
-        throw new VibeError30({ code: "VIBE_VALIDATION", message: "$querySql requires an explicit result decoder" });
+        throw new VibeError34({ code: "VIBE_VALIDATION", message: "$querySql requires an explicit result decoder" });
       const statement = compileSql({ dialect: engine.dialect, query });
       let output = [];
       await runRaw("$querySql", statement, (rows) => {
@@ -14086,7 +14344,7 @@ function buildClient(params) {
     $connect: async () => {
       assertEngineActive({ engine, requireContext: false });
       if (engine.borrowedModule === true)
-        throw new VibeError30({ code: "VIBE_VALIDATION", message: "A package module borrows its adapter; the application owns connection lifecycle", meta: { reason: "module_borrowed_lifecycle", method: "$connect" } });
+        throw new VibeError34({ code: "VIBE_VALIDATION", message: "A package module borrows its adapter; the application owns connection lifecycle", meta: { reason: "module_borrowed_lifecycle", method: "$connect" } });
       if (engine.inTransaction === true)
         throw transactionLifecycleRefusal({ method: "$connect" });
       if (engine.rlsSchema !== undefined) {
@@ -14108,7 +14366,7 @@ function buildClient(params) {
     $disconnect: async () => {
       assertEngineActive({ engine, requireContext: false });
       if (engine.borrowedModule === true)
-        throw new VibeError30({ code: "VIBE_VALIDATION", message: "A package module borrows its adapter; the application owns connection lifecycle", meta: { reason: "module_borrowed_lifecycle", method: "$disconnect" } });
+        throw new VibeError34({ code: "VIBE_VALIDATION", message: "A package module borrows its adapter; the application owns connection lifecycle", meta: { reason: "module_borrowed_lifecycle", method: "$disconnect" } });
       if (engine.inTransaction === true)
         throw transactionLifecycleRefusal({ method: "$disconnect" });
       await engine.diagnostics?.flush();
@@ -14140,11 +14398,12 @@ function buildClient(params) {
       client,
       meta: engine.meta,
       ...engine.extensionMounts === undefined ? {} : { mounts: engine.extensionMounts },
-      operations: LAZY_OPERATIONS
+      operations: LAZY_OPERATIONS,
+      assertActive: () => assertEngineActive({ engine })
     });
   } else {
     const refuseLegacy = () => {
-      throw new VibeError30({ code: "VIBE_CONFIG", message: "Native row-level security cannot be combined with application policy or tenant scoping" });
+      throw new VibeError34({ code: "VIBE_CONFIG", message: "Native row-level security cannot be combined with application policy or tenant scoping" });
     };
     Object.defineProperties(client, {
       $withContext: { enumerable: true, value: (context) => {
@@ -14162,7 +14421,8 @@ function buildClient(params) {
         client,
         meta: engine.meta,
         ...engine.extensionMounts === undefined ? {} : { mounts: engine.extensionMounts },
-        operations: LAZY_OPERATIONS
+        operations: LAZY_OPERATIONS,
+        assertActive: () => assertEngineActive({ engine })
       });
     }
     for (const delegate of Object.values(models))
@@ -14173,12 +14433,12 @@ function buildClient(params) {
   registerModuleBinder({ client, bind: ({ schema, manifest }) => {
     assertEngineActive({ engine, requireContext: false });
     if (engine.rlsSchema !== undefined || engine.meta.models.some((model) => model.policy !== undefined))
-      throw new VibeError30({ code: "VIBE_CONFIG", message: `Module ${manifest.id} cannot attach models to a policy or native-RLS context`, meta: { reason: "module_restricted_context", moduleId: manifest.id } });
+      throw new VibeError34({ code: "VIBE_CONFIG", message: `Module ${manifest.id} cannot attach models to a policy or native-RLS context`, meta: { reason: "module_restricted_context", moduleId: manifest.id } });
     if (manifest.dialect !== engine.dialect.name)
-      throw new VibeError30({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Module ${manifest.id} requires ${manifest.dialect}, received ${engine.dialect.name}`, meta: { reason: "module_dialect", moduleId: manifest.id } });
+      throw new VibeError34({ code: "VIBE_UNSUPPORTED_CAPABILITY", message: `Module ${manifest.id} requires ${manifest.dialect}, received ${engine.dialect.name}`, meta: { reason: "module_dialect", moduleId: manifest.id } });
     const previous = engine.moduleManifests.get(manifest.id);
     if (previous !== undefined && (previous.schemaChecksum !== manifest.schemaChecksum || previous.revision !== manifest.revision || previous.contract !== manifest.contract))
-      throw new VibeError30({ code: "VIBE_CONFIG", message: `Module ${manifest.id} was already bound with a different manifest; use compatible package artifacts`, meta: { reason: "module_manifest_conflict", moduleId: manifest.id, revision: manifest.revision } });
+      throw new VibeError34({ code: "VIBE_CONFIG", message: `Module ${manifest.id} was already bound with a different manifest; use compatible package artifacts`, meta: { reason: "module_manifest_conflict", moduleId: manifest.id, revision: manifest.revision } });
     let meta = moduleMetadata.get(schema);
     if (meta === undefined) {
       meta = buildRuntimeMeta({ schema });
@@ -14189,8 +14449,14 @@ function buildClient(params) {
     const { validate: _validate, ...options } = engine.options;
     return buildClient({ engine: { ...engine, meta, options, borrowedModule: true, extensionMounts: [], connectHooks: [], renderCache: new StatementRenderCache } });
   } });
+  registerTransactionObservation({ db: client, observation: {
+    inTransaction: engine.inTransaction === true,
+    assertActive: () => assertEngineActive({ engine }),
+    read: () => engine.adapter.rowChanges?.() ?? "unknown"
+  } });
   return client;
 }
+var EXTENSION_EFFECT = new AsyncLocalStorage;
 function makeMountContext(params) {
   const { engine, extension, model } = params;
   return {
@@ -14220,7 +14486,8 @@ function makeMountContext(params) {
             rowCount: (value) => value.length,
             run: () => target.adapter.execute({
               text,
-              values: bindValues({ adapter: target.adapter, values: [...values] })
+              values: bindValues({ adapter: target.adapter, values: [...values] }),
+              effect: EXTENSION_EFFECT.getStore() ?? "unknown"
             })
           });
           return model === null ? rows : materializeRows({ dialect: target.dialect.name, model, rows, wire: target.adapter.wire });
@@ -14233,7 +14500,7 @@ function makeMountContext(params) {
     compileWhere: ({ where, model: modelName, qualify }) => {
       const target = modelName === undefined ? model : getModelMeta({ meta: engine.meta, model: modelName });
       if (target === null) {
-        throw new VibeError30({
+        throw new VibeError34({
           code: "VIBE_INTERNAL",
           message: `extension "${extension}" compiled a where with no model in scope`,
           meta: { extension }
@@ -14253,8 +14520,27 @@ function makeMountContext(params) {
 function createMountSurface(params) {
   const { engine, mount, model } = params;
   const original = mount.create(makeMountContext({ engine, extension: mount.extension, model }));
+  const effectOf = (path, args) => {
+    if (containsSqlFragment(args))
+      return "unknown";
+    return mount.readOnly === true && path.length === 0 || Array.isArray(mount.readOnly) && path.length === 1 && mount.readOnly.includes(String(path[0])) ? "read" : "unknown";
+  };
+  const wrapEffects = (value, path) => {
+    if (typeof value === "function")
+      return function(...args) {
+        return EXTENSION_EFFECT.run(effectOf(path, args), () => Reflect.apply(value, this, args));
+      };
+    if (value === null || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      return value;
+    const result = Object.create(Object.getPrototypeOf(value));
+    for (const key of Reflect.ownKeys(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      Object.defineProperty(result, key, "value" in descriptor ? { ...descriptor, value: wrapEffects(descriptor.value, [...path, key]) } : descriptor);
+    }
+    return result;
+  };
   if (engine.rlsSchema === undefined)
-    return original;
+    return wrapEffects(original, []);
   const wrap = (value, path) => {
     if (typeof value === "function") {
       return (...args) => createQueryPromise({ engine, run: async (target) => {
@@ -14263,24 +14549,24 @@ function createMountSurface(params) {
         for (const key of path) {
           receiver = current;
           if (current === null || typeof current !== "object" && typeof current !== "function")
-            throw new VibeError30({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+            throw new VibeError34({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
           current = Reflect.get(current, key);
         }
         if (typeof current !== "function")
-          throw new VibeError30({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
-        return Reflect.apply(current, receiver, args);
+          throw new VibeError34({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+        return EXTENSION_EFFECT.run(effectOf(path, args), () => Reflect.apply(current, receiver, args));
       } });
     }
     if (value === null || typeof value !== "object")
       return value;
     if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
-      throw new VibeError30({ code: "VIBE_CONFIG", message: "Native RLS extension mounts must expose plain objects and methods" });
+      throw new VibeError34({ code: "VIBE_CONFIG", message: "Native RLS extension mounts must expose plain objects and methods" });
     }
     const result = {};
     for (const key of Reflect.ownKeys(value)) {
       const descriptor = Object.getOwnPropertyDescriptor(value, key);
       if (!("value" in descriptor))
-        throw new VibeError30({ code: "VIBE_CONFIG", message: "Native RLS extension mount accessors are unsupported" });
+        throw new VibeError34({ code: "VIBE_CONFIG", message: "Native RLS extension mount accessors are unsupported" });
       Object.defineProperty(result, key, { value: wrap(descriptor.value, [...path, key]), enumerable: descriptor.enumerable });
     }
     return Object.freeze(result);
@@ -14297,7 +14583,7 @@ function attachExtensionMounts(params) {
       const model = getModelMeta({ meta: engine.meta, model: mount.model ?? "" });
       const delegate = models[model.name];
       if (delegate === undefined || mount.property in delegate) {
-        throw new VibeError30({
+        throw new VibeError34({
           code: "VIBE_CONFIG",
           message: `extension "${mount.extension}" cannot mount "${mount.property}" on ${model.name} \u2014 the name is taken`,
           meta: { extension: mount.extension, model: model.name, property: mount.property }
@@ -14308,7 +14594,7 @@ function attachExtensionMounts(params) {
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
-      throw new VibeError30({
+      throw new VibeError34({
         code: "VIBE_CONFIG",
         message: `extension "${mount.extension}" cannot mount client property "${mount.property}" \u2014 root mounts are $-prefixed and must not collide`,
         meta: { extension: mount.extension, property: mount.property }
@@ -14334,7 +14620,7 @@ function createClient(params) {
   if (schema.rls !== undefined) {
     const dialect = getSqlDialect5({ dialect: dialectName });
     if (!dialect.capabilities.nativeRowLevelSecurity)
-      throw unsupportedCapability8({ dialect: dialectName, feature: "nativeRowLevelSecurity" });
+      throw unsupportedCapability9({ dialect: dialectName, feature: "nativeRowLevelSecurity" });
     assertValidSchemaIR2({ schema });
     for (const model of schema.models) {
       if (model.rls !== "unprotected")
@@ -14343,9 +14629,9 @@ function createClient(params) {
     const role = options?.nativeRls?.runtimeRole;
     if (adapter.provider === "pglite") {
       if (typeof role !== "string" || role.length === 0 || role.includes("\x00"))
-        throw new VibeError30({ code: "VIBE_CONFIG", message: "PGlite native row-level security requires a pre-existing restricted runtimeRole; embedded binding is not a boundary against the host process" });
+        throw new VibeError34({ code: "VIBE_CONFIG", message: "PGlite native row-level security requires a pre-existing restricted runtimeRole; embedded binding is not a boundary against the host process" });
     } else if (role !== undefined) {
-      throw new VibeError30({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
+      throw new VibeError34({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
     }
   }
   if (extensions?.manifest !== undefined) {
@@ -14355,7 +14641,7 @@ function createClient(params) {
     assertComputedManifest({ manifest: computed.manifest, specs: computed.specs });
   }
   if (computed === undefined && options !== undefined && options["computed"] !== undefined) {
-    throw new VibeError30({
+    throw new VibeError34({
       code: "VIBE_CONFIG",
       message: "this client was generated without computed fields \u2014 declare them in vibeorm.config.ts and re-run vibeorm generate",
       meta: {}
@@ -14408,16 +14694,17 @@ function freezeData(params) {
 function defineDatabaseModule(params) {
   for (const key of ["id", "contract", "revision"]) {
     if (typeof params[key] !== "string" || params[key].trim().length === 0 || params[key].includes("\x00"))
-      throw new VibeError31({ code: "VIBE_CONFIG", message: `Database module ${key} must be a non-empty identifier`, meta: { reason: "module_manifest", key } });
+      throw new VibeError35({ code: "VIBE_CONFIG", message: `Database module ${key} must be a non-empty identifier`, meta: { reason: "module_manifest", key } });
   }
-  assertValidSchemaIR3({ schema: params.schema });
-  if (params.schema.rls !== undefined || params.schema.extensions.length > 0 || params.schema.models.some((model) => model.policy !== undefined))
-    throw new VibeError31({
+  const preparedSchema = prepareDatabaseModuleSchema({ schema: params.schema, module: params });
+  assertValidSchemaIR3({ schema: preparedSchema });
+  if (preparedSchema.rls !== undefined || preparedSchema.extensions.length > 0 || preparedSchema.models.some((model) => model.policy !== undefined))
+    throw new VibeError35({
       code: "VIBE_UNSUPPORTED_CAPABILITY",
       message: `Module ${params.id} cannot declare extensions, policy or native RLS in this module protocol`,
       meta: { reason: "module_schema_feature", moduleId: params.id }
     });
-  const serialized = JSON.stringify(canonicalValue({ value: params.schema }));
+  const serialized = JSON.stringify(canonicalValue({ value: preparedSchema }));
   const schema = JSON.parse(serialized);
   freezeData({ value: schema });
   const manifest = Object.freeze({
@@ -14425,11 +14712,12 @@ function defineDatabaseModule(params) {
     contract: params.contract,
     revision: params.revision,
     protocol: 1,
+    ...params.namespace === undefined ? {} : { namespace: params.namespace },
     dialect: providerToDialect({ provider: schema.datasource.provider }),
-    schemaChecksum: createHash("sha256").update(serialized).digest("hex")
+    schemaChecksum: createHash2("sha256").update(serialized).digest("hex")
   });
-  if (params.manifest !== undefined && Object.keys(manifest).some((key) => params.manifest[key] !== manifest[key]))
-    throw new VibeError31({
+  if (params.manifest !== undefined && (params.manifest.namespace !== manifest.namespace || Object.keys(manifest).some((key) => params.manifest[key] !== manifest[key])))
+    throw new VibeError35({
       code: "VIBE_STALE_CLIENT",
       message: `Module ${params.id} has incompatible or modified generated metadata; regenerate with a compatible runtime`,
       meta: { reason: "module_artifact", moduleId: params.id, revision: params.revision, protocol: params.manifest.protocol }
@@ -14439,32 +14727,9 @@ function defineDatabaseModule(params) {
   return Object.freeze({ ...artifact, bind, create: ({ adapter }) => bind({ db: createClient({ schema, adapter }) }) });
 }
 // packages/runtime/src/keyset-iterator.ts
-import { VibeError as VibeError32 } from "@vibeorm/schema";
+import { VibeError as VibeError36 } from "@vibeorm/schema";
 function validation(params) {
-  return new VibeError32({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
-}
-function projectionFor(params) {
-  const { plan, select, omit } = params;
-  const names = plan.keys.map((key) => key.field.name);
-  if (select !== undefined) {
-    const hidden = names.filter((name) => select[name] !== true);
-    if (hidden.length === 0)
-      return { select, hidden };
-    const widened = { ...select };
-    for (const name of hidden)
-      widened[name] = true;
-    return { select: widened, hidden };
-  }
-  if (omit !== undefined) {
-    const hidden = names.filter((name) => omit[name] === true);
-    if (hidden.length === 0)
-      return { omit, hidden };
-    const narrowed = { ...omit };
-    for (const name of hidden)
-      narrowed[name] = false;
-    return { omit: narrowed, hidden };
-  }
-  return { hidden: [] };
+  return new VibeError36({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function iterateKeyset(options) {
   const { source, meta, dialect, orderBy, pageSize, signal } = options;
@@ -14481,7 +14746,7 @@ function iterateKeyset(options) {
     terms: compileKeysetOrderInputs({ dialect, meta, model, orderBy }),
     ...options.timestampPrecision === undefined ? {} : { timestampPrecision: options.timestampPrecision }
   });
-  const projection = projectionFor({ plan, select: options.select, omit: options.omit });
+  const projection = keysetProjection({ plan, select: options.select, omit: options.omit });
   const keysetArg = options.timestampPrecision === undefined ? {} : { keyset: { timestampPrecision: options.timestampPrecision } };
   let buffer = [];
   let position = options.after ?? null;
@@ -14518,7 +14783,7 @@ function iterateKeyset(options) {
       });
       if (advanced === false) {
         stop();
-        throw new VibeError32({
+        throw new VibeError36({
           code: "VIBE_DATA_INVALID",
           message: `keyset traversal of "${options.model}" is not advancing: the engine returned a row that does not sort after the previous position. ` + "The ordering is not total, or a cursor value lost precision \u2014 a DateTime column finer than milliseconds asserted as millisecond-exact does this.",
           meta: { model: options.model, order: plan.signature, reason: "keyset-position-not-advancing" }
@@ -14591,7 +14856,7 @@ function iterateKeyset(options) {
   return iterator;
 }
 // packages/runtime/src/telemetry/collector.ts
-import { VibeError as VibeError33 } from "@vibeorm/schema";
+import { VibeError as VibeError37 } from "@vibeorm/schema";
 function createTelemetryCollector(params) {
   const throwOn = new Set(params?.throwOn ?? []);
   const operations = [];
@@ -14601,7 +14866,7 @@ function createTelemetryCollector(params) {
   let shutdowns = 0;
   const hostile = (phase) => {
     if (throwOn.has(phase)) {
-      throw new VibeError33({
+      throw new VibeError37({
         code: "VIBE_INTERNAL",
         message: `telemetry collector: deliberate ${phase} failure`,
         meta: { reason: "telemetry-collector-deliberate-failure", phase }
@@ -14657,7 +14922,7 @@ function createTelemetryCollector(params) {
     operationFor: (lookup) => {
       const matches = operations.filter((event) => event.method === lookup.method && (lookup.model === undefined || event.model === lookup.model));
       if (matches.length > 1) {
-        throw new VibeError33({
+        throw new VibeError37({
           code: "VIBE_VALIDATION",
           message: `telemetry collector: ${matches.length} operations match ${lookup.model ?? "*"}.${lookup.method}`,
           meta: {
@@ -14691,6 +14956,7 @@ export {
   TELEMETRY_DEFAULTS,
   ViewResult,
   WRITE_DELEGATE_METHODS,
+  advisoryKeyOf,
   affectedRowsAreRowCounts,
   analyzeOperationTelemetry,
   applyComputedFields,
@@ -14717,6 +14983,7 @@ export {
   compileSelect,
   compileWhere,
   createClient,
+  createDelegateMethodClassifier,
   createScopeRewriter,
   createSqlModel,
   createStatementDiagnostics,
@@ -14780,8 +15047,9 @@ export {
   summarizePlan,
   toClientName,
   toSqlExecutor,
+  transactionRowChanges,
   updateWithNested,
   validateWriteData
 };
 
-//# debugId=BC9380E497613E8D64756E2164756E21
+//# debugId=F8F07DD9CF6AA47D64756E2164756E21