@vibeorm/runtime 2.0.0 → 2.0.2

package/dist/index.js

@@ -304,7 +304,7 @@ function getFieldMeta(params) {
   return found;
 }
 // packages/runtime/src/codecs.ts
-import { parsePgArrayLiteral, toPgArrayLiteral } from "@vibeorm/sql";
+import { JSON_TRANSPORT, projectionOutputName, parsePgArrayLiteral, toPgArrayLiteral } from "@vibeorm/sql";
 import { VibeError as VibeError3, isEnumType as isEnumType2 } from "@vibeorm/schema";
 import { DIALECT_CODECS, decodeIsNoop } from "@vibeorm/sql";
 import {
@@ -445,16 +445,16 @@ function buildDecodePlan(params) {
   const { dialect, model, wire } = params;
   const byColumn = new Map;
   const inPlace = [];
-  let renamed = false;
+  const renamedColumns = [];
   for (const field of model.fields) {
     const decode = fieldDecoder({ dialect, field, ...wire === undefined ? {} : { wire } });
     byColumn.set(field.columnName, { name: field.name, decode });
     if (field.columnName !== field.name)
-      renamed = true;
+      renamedColumns.push(field.columnName);
     if (decode !== null)
       inPlace.push({ column: field.columnName, decode });
   }
-  return { byColumn, inPlace: renamed ? null : inPlace };
+  return { byColumn, renamedColumns, decoders: inPlace, inPlace: renamedColumns.length > 0 ? null : inPlace };
 }
 function viewWire(wire) {
   return wire?.json === "parsed" ? { json: "parsed" } : undefined;
@@ -488,6 +488,58 @@ function decodeRowWithPlan(plan, row) {
   }
   return out;
 }
+var projectionBindings = new WeakMap;
+function materializeProjection(params) {
+  const { plan, rows } = params;
+  let binding = projectionBindings.get(plan);
+  for (let index = 0;index < rows.length; index++) {
+    const row = rows[index];
+    if (plan.renamedColumns.length > 0 && !plan.renamedColumns.some((column) => Object.hasOwn(row, column))) {
+      for (const entry of plan.decoders) {
+        const value = row[entry.column];
+        if (value !== null && value !== undefined)
+          row[entry.column] = entry.decode(value);
+      }
+      continue;
+    }
+    const keys = Object.keys(row);
+    let matches = binding !== undefined && keys.length === binding.keys.length;
+    if (matches)
+      for (let i = 0;i < keys.length; i++) {
+        if (keys[i] !== binding?.keys[i]) {
+          matches = false;
+          break;
+        }
+      }
+    if (binding === undefined || !matches) {
+      const slots = keys.map((column) => {
+        const entry = plan.byColumn.get(column);
+        return { column, name: entry?.name ?? column, decode: entry?.decode ?? null };
+      });
+      const decoders = [];
+      for (const slot of slots)
+        if (slot.decode !== null)
+          decoders.push({ column: slot.column, decode: slot.decode });
+      binding = { keys, slots, decoders, renamed: slots.some((slot) => slot.column !== slot.name) };
+      projectionBindings.set(plan, binding);
+    }
+    if (binding.renamed) {
+      const out = {};
+      for (const slot of binding.slots) {
+        const value = row[slot.column];
+        out[slot.name] = value === null || value === undefined || slot.decode === null ? value : slot.decode(value);
+      }
+      rows[index] = out;
+    } else {
+      for (const slot of binding.decoders) {
+        const value = row[slot.column];
+        if (value !== null && value !== undefined)
+          row[slot.column] = slot.decode(value);
+      }
+    }
+  }
+  return rows;
+}
 function decodeRow(params) {
   const { dialect, model, row, wire } = params;
   return decodeRowWithPlan(getDecodePlan({ dialect, model, wire }), row);
@@ -500,11 +552,10 @@ function decodeRows(params) {
 function materializeRows(params) {
   const { dialect, model, rows, wire } = params;
   const plan = getDecodePlan({ dialect, model, wire });
-  if (plan.inPlace === null) {
-    for (let index = 0;index < rows.length; index++) {
-      rows[index] = decodeRowWithPlan(plan, rows[index]);
-    }
+  if (rows.length === 0 || plan.inPlace?.length === 0)
     return rows;
+  if (plan.inPlace === null || Object.keys(rows[0]).length < plan.byColumn.size) {
+    return materializeProjection({ plan, rows });
   }
   const decoders = plan.inPlace;
   if (decoders.length === 0)
@@ -526,39 +577,58 @@ function getJsonDecodePlan(model) {
     return plan;
   const byColumn = new Map;
   const inPlace = [];
-  let renamed = false;
+  const renamedColumns = [];
   for (const field of model.fields) {
     const decode = field.scalarType === "Json" ? null : field.scalarType === "Bytes" && !field.isList ? decodeBase64Bytes : fieldDecoder({ dialect: "postgres", field });
     byColumn.set(field.columnName, { name: field.name, decode });
     if (field.columnName !== field.name)
-      renamed = true;
+      renamedColumns.push(field.columnName);
     if (decode !== null)
       inPlace.push({ column: field.columnName, decode });
   }
-  plan = { byColumn, inPlace: renamed ? null : inPlace };
+  plan = { byColumn, renamedColumns, decoders: inPlace, inPlace: renamedColumns.length > 0 ? null : inPlace };
   jsonDecodePlanCache.set(model, plan);
   return plan;
 }
-function materializeJsonRows(params) {
-  const { model, rows } = params;
+function positionalMaterializer(params) {
+  const { model, columns } = params;
   const plan = getJsonDecodePlan(model);
-  if (plan.inPlace === null) {
-    for (let index = 0;index < rows.length; index++) {
-      rows[index] = decodeRowWithPlan(plan, rows[index]);
+  const slots = columns.map((column) => {
+    const output = projectionOutputName({ column });
+    const entry = plan.byColumn.get(output);
+    if (entry === undefined)
+      throw new VibeError3({ code: "VIBE_INTERNAL", message: "positional projection has no schema field", meta: { model: model.name, column: output } });
+    return entry;
+  });
+  const width = slots.length;
+  const chunkSize = JSON_TRANSPORT.chunkSize;
+  const chunked = width > chunkSize;
+  const count = Math.ceil(width / chunkSize);
+  const invalid = () => {
+    throw new VibeError3({ 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();
+  return (value) => {
+    if (!Array.isArray(value) || value.length !== (chunked ? count : width))
+      return invalid();
+    if (chunked) {
+      for (let index = 0;index < count; index++) {
+        const chunk = value[index];
+        if (!Array.isArray(chunk) || chunk.length !== Math.min(chunkSize, width - index * chunkSize))
+          return invalid();
+      }
     }
-    return rows;
-  }
-  const decoders = plan.inPlace;
-  if (decoders.length === 0)
-    return rows;
-  for (const row of rows) {
-    for (const entry of decoders) {
-      const value = row[entry.column];
-      if (value !== null && value !== undefined)
-        row[entry.column] = entry.decode(value);
+    const out = {};
+    for (let index = 0;index < width; index++) {
+      const slot = slots[index];
+      const cell = chunked ? value[Math.floor(index / chunkSize)][index % chunkSize] : value[index];
+      if (cell === undefined)
+        return invalid();
+      out[slot.name] = cell === null || slot.decode === null ? cell : slot.decode(cell);
     }
-  }
-  return rows;
+    return out;
+  };
 }
 function decodeAggregateValue(params) {
   const { dialect, key, field, value } = params;
@@ -576,8 +646,73 @@ function decodeAggregateValue(params) {
     return String(value);
   return field === null ? value : decodeValue({ dialect, field, value });
 }
+// packages/runtime/src/lateral-projection.ts
+import { VibeError as VibeError4, unsupportedCapability } from "@vibeorm/schema";
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+var LATERAL_CHILD_ALIAS = "__rel";
+var projections = new WeakMap;
+function lateralProjection(params) {
+  const { node } = params;
+  const cached = projections.get(node);
+  if (cached !== undefined)
+    return cached;
+  const model = node.link.target;
+  const hiddenOrder = lateralHiddenOrderFields({ node });
+  const names = node.args.projected === null ? model.fields.map((field) => field.name) : [...node.args.projected, ...hiddenOrder];
+  const columns = names.map((name) => {
+    const field = model.fieldByName.get(name);
+    if (field === undefined)
+      throw new VibeError4({ 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) });
+  projections.set(node, descriptor);
+  return descriptor;
+}
+function lateralHiddenOrderFields(params) {
+  const { node } = params;
+  const projected = node.args.projected;
+  if (projected === null || node.args.orderBy === undefined)
+    return [];
+  const target = node.link.target;
+  const hidden = [];
+  const items = Array.isArray(node.args.orderBy) ? node.args.orderBy : [node.args.orderBy];
+  for (const item of items) {
+    if (!isPlainObject(item))
+      continue;
+    for (const [name, value] of Object.entries(item)) {
+      if (value === undefined)
+        continue;
+      if (!target.fieldByName.has(name))
+        continue;
+      if (!projected.includes(name) && !hidden.includes(name))
+        hidden.push(name);
+    }
+  }
+  return hidden;
+}
+function applyLateralTransform(params) {
+  const { model, column } = params;
+  const field = model.fieldByColumn.get(column.name);
+  if (field === undefined)
+    return column;
+  const scalar = field.scalarType;
+  if (scalar !== "BigInt" && scalar !== "Decimal" && scalar !== "Bytes")
+    return column;
+  if (field.isList) {
+    throw unsupportedCapability({
+      dialect: "postgres",
+      feature: `join-strategy relation loading of ${model.name}.${field.name} (${scalar}[])`,
+      hint: 'list columns of BigInt/Decimal/Bytes have no faithful JSON wire form \u2014 use the portable "query" relation strategy'
+    });
+  }
+  return { ...column, transform: scalar === "Bytes" ? "encodeBase64" : "castText" };
+}
+
 // packages/runtime/src/query-builder.ts
-import { VibeError as VibeError7, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
+import { VibeError as VibeError8, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
 import {
   SQL_DEFAULT_CELL,
   containsPattern,
@@ -590,9 +725,9 @@ import {
 } from "@vibeorm/sql";
 
 // packages/runtime/src/bulk-upsert.ts
-import { VibeError as VibeError4, unsupportedCapability } from "@vibeorm/schema";
+import { VibeError as VibeError5, unsupportedCapability as unsupportedCapability2 } from "@vibeorm/schema";
 function validationError(params) {
-  return new VibeError4({
+  return new VibeError5({
     code: "VIBE_VALIDATION",
     message: params.message,
     ...params.meta === undefined ? {} : { meta: params.meta }
@@ -680,7 +815,7 @@ function assertConflictTargetIsEnforceable(params) {
   const groups = uniqueGroupSignatures({ model });
   if (groups.size <= 1)
     return;
-  throw unsupportedCapability({
+  throw unsupportedCapability2({
     dialect: dialect.name,
     feature: `an enforced conflict target on ${model.clientName}.upsertMany() (${model.name} declares ${groups.size} unique groups)`,
     hint: "mysql's ON DUPLICATE KEY UPDATE fires on ANY unique index, so another one can decide the conflict \u2014 pass allowAnyUniqueConflict: true to accept that, or gate the call per dialect"
@@ -803,7 +938,7 @@ function assertNoDuplicateSecondaryUniques(params) {
       const key = conflictKeyOf({ row, columns });
       const first = firstIndexByKey.get(key);
       if (first !== undefined) {
-        throw unsupportedCapability({
+        throw unsupportedCapability2({
           dialect: dialect.name,
           feature: `${model.clientName}.upsertMany() with rows ${first} and ${index} carrying the same ${fields.map((field) => field.name).join(" + ")}`,
           hint: `ON DUPLICATE KEY UPDATE has no conflict target: it resolves through whichever unique index an incoming row matches, so row ${index} would UPDATE row ${first} through unique (${columns.join(", ")}) and one of the two rows you submitted would silently not exist. Deduplicate the feed on those columns as well as on the conflict target, or submit the colliding rows in separate calls. allowAnyUniqueConflict widens which STORED row a single incoming row may replace; it does not authorise two submitted rows collapsing into one`
@@ -885,7 +1020,7 @@ function assertConflictKeysAreComparable(params) {
   if (target.kind === "constraint") {
     if (engineComparesEveryPair)
       return;
-    throw unsupportedCapability({
+    throw unsupportedCapability2({
       dialect: dialect.name,
       feature: `a ${statementCount > 1 ? "chunked " : ""}${model.clientName}.upsertMany() batch arbitrated by constraint "${target.constraint}"`,
       hint: statementCount > 1 ? `a named constraint hides which columns decide the conflict, so only the engine can tell whether two incoming rows address the same stored row \u2014 and it only compares rows inside ONE statement, while this batch of ${model.name} rows needs ${statementCount}. Submit fewer rows per call, or name the unique group's fields instead of the constraint` : "a named constraint hides which columns decide the conflict, so this dialect would silently keep the last of two rows that address the same stored row"
@@ -903,7 +1038,7 @@ function assertConflictKeysAreComparable(params) {
       notes.push(`@collation("${field.collation}")`);
     return notes.length === 0 ? `${field.name} (column "${field.columnName}")` : `${field.name} (column "${field.columnName}", ${notes.join(", ")})`;
   }).join(", ");
-  throw unsupportedCapability({
+  throw unsupportedCapability2({
     dialect: dialect.name,
     feature: `${model.clientName}.upsertMany() on conflict target ${described}`,
     hint: statementCount > 1 ? `only the database can tell whether two of these keys address the same stored row \u2014 its column type, collation, scale or precision decides \u2014 and it only compares rows inside ONE statement, while this batch of ${model.name} rows needs ${statementCount}. Submit fewer rows per call, or ${remedyFor({ dialect, fields: opaque })}` : `only the database can tell whether two of these keys address the same stored row \u2014 its column type, collation, scale or precision decides \u2014 and this dialect answers a doubled key by silently keeping the last row instead of refusing it. Deduplicate the feed against the same rule the column uses, or ${remedyFor({ dialect, fields: opaque })}`
@@ -911,7 +1046,7 @@ function assertConflictKeysAreComparable(params) {
 }
 
 // packages/runtime/src/keyset.ts
-import { VibeError as VibeError5 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 var KEYSET_TOKEN_VERSION = 1;
 var KEYSET_TOKEN_PREFIX = "vk1.";
 var KEYSET_MAX_PAGE_SIZE = 1e4;
@@ -921,10 +1056,10 @@ var DATETIME_NEEDS_PRECISION_ASSERTION = Object.freeze({
   sqlite: false
 });
 function keysetValidation(params) {
-  return new VibeError5({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError6({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function keysetUnsupported(params) {
-  return new VibeError5({
+  return new VibeError6({
     code: "VIBE_UNSUPPORTED_CAPABILITY",
     message: params.message,
     meta: params.meta
@@ -1307,11 +1442,11 @@ function decodeKeysetToken(params) {
 }
 
 // packages/runtime/src/relation-plan.ts
-import { VibeError as VibeError6, implicitJoinTable } from "@vibeorm/schema";
+import { VibeError as VibeError7, implicitJoinTable } from "@vibeorm/schema";
 function validationError2(params) {
-  return new VibeError6({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError7({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
 }
 function relationKeyOf(relation) {
@@ -1334,7 +1469,7 @@ function keyFields(params) {
   return names.map((name) => {
     const field = model.fieldByName.get(name);
     if (field === undefined) {
-      throw new VibeError6({
+      throw new VibeError7({
         code: "VIBE_SCHEMA_INVALID",
         message: `relation "${relation.name}" on ${relation.model} names unknown ${what} field "${name}"`,
         meta: { model: relation.model, relation: relation.name }
@@ -1346,7 +1481,7 @@ function keyFields(params) {
 function singleKeyPair(params) {
   const { link, what } = params;
   if (link.parentKeys.length !== 1 || link.childKeys.length !== 1) {
-    throw new VibeError6({
+    throw new VibeError7({
       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 }
@@ -1385,7 +1520,7 @@ function resolveRelationLinkUncached(params) {
   const target = getModelMeta({ meta, model: relation.targetModel });
   if (relation.type === "manyToMany") {
     if (relation.model === relation.targetModel) {
-      throw new VibeError6({
+      throw new VibeError7({
         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 }
@@ -1427,7 +1562,7 @@ function resolveRelationLinkUncached(params) {
   }
   const reverse = findReverseRelation({ relation, target });
   if (reverse === null || reverse.fields === undefined || reverse.fields.length === 0) {
-    throw new VibeError6({
+    throw new VibeError7({
       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 }
@@ -1452,7 +1587,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 VibeError6({
+    throw new VibeError7({
       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 }
@@ -1508,7 +1643,7 @@ function compileChildSelect(params) {
 }
 function compileChildOmit(params) {
   const { model, omit, relation } = params;
-  if (!isPlainObject(omit)) {
+  if (!isPlainObject2(omit)) {
     throw validationError2({
       message: `omit on relation "${relation}" must be an object`,
       meta: { model: model.name, relation }
@@ -1586,7 +1721,7 @@ function resolveCounts(params) {
   if (spec === true) {
     return model.relations.filter((relation) => relation.isList).map((relation) => resolveCountNode({ meta, model, name: relation.name, where: undefined }));
   }
-  if (!isPlainObject(spec) || !isPlainObject(spec.select)) {
+  if (!isPlainObject2(spec) || !isPlainObject2(spec.select)) {
     throw validationError2({
       message: `_count on model "${model.name}" must be true or { select: { relation: true } }`,
       meta: { model: model.name }
@@ -1600,7 +1735,7 @@ function resolveCounts(params) {
       nodes.push(resolveCountNode({ meta, model, name, where: undefined }));
       continue;
     }
-    if (!isPlainObject(value)) {
+    if (!isPlainObject2(value)) {
       throw validationError2({
         message: `_count.select.${name} on model "${model.name}" must be true, false, or { where: \u2026 }`,
         meta: { model: model.name, relation: name }
@@ -1617,7 +1752,7 @@ function resolveCounts(params) {
       }
     }
     const where = value.where;
-    if (where !== undefined && !isPlainObject(where)) {
+    if (where !== undefined && !isPlainObject2(where)) {
       throw validationError2({
         message: `_count.select.${name}.where on model "${model.name}" must be an object`,
         meta: { model: model.name, relation: name }
@@ -1657,7 +1792,7 @@ function resolveNode(params) {
     });
   }
   const where = raw.where === undefined ? undefined : (() => {
-    if (!isPlainObject(raw.where)) {
+    if (!isPlainObject2(raw.where)) {
       throw validationError2({
         message: `where on relation "${relation.name}" must be an object`,
         meta: { model: model.name, relation: relation.name }
@@ -1720,8 +1855,8 @@ function resolveNode(params) {
 }
 function resolveRelationSelection(params) {
   const { meta, model, select, include } = params;
-  const selectSpec = isPlainObject(select) ? select : null;
-  const includeSpec = isPlainObject(include) ? include : null;
+  const selectSpec = isPlainObject2(select) ? select : null;
+  const includeSpec = isPlainObject2(include) ? include : null;
   if (includeSpec !== null) {
     for (const [key, value] of Object.entries(includeSpec)) {
       if (value === undefined || value === false)
@@ -1735,7 +1870,7 @@ function resolveRelationSelection(params) {
           meta: { model: model.name, relation: key }
         });
       }
-      if (value !== true && !isPlainObject(value)) {
+      if (value !== true && !isPlainObject2(value)) {
         throw validationError2({
           message: `include.${key} on model "${model.name}" must be true or an object`,
           meta: { model: model.name, relation: key }
@@ -1747,14 +1882,14 @@ function resolveRelationSelection(params) {
   if (selectSpec !== null) {
     for (const relation of model.relations) {
       const value = selectSpec[relation.name];
-      if (value === true || isPlainObject(value))
+      if (value === true || isPlainObject2(value))
         specs.set(relation.name, value);
     }
   }
   if (includeSpec !== null) {
     for (const relation of model.relations) {
       const value = includeSpec[relation.name];
-      if (value === true || isPlainObject(value))
+      if (value === true || isPlainObject2(value))
         specs.set(relation.name, value);
     }
   }
@@ -1802,9 +1937,9 @@ var AGG_FN_BY_KEY = {
   _max: "max"
 };
 function validationError3(params) {
-  return new VibeError7({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError8({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
 }
 function isDirectValue(value) {
@@ -1855,7 +1990,7 @@ function compileLock(params) {
 function compileConflictTarget(params) {
   const { dialect, meta, model, method, target, where } = params;
   if ((target !== undefined || where !== undefined) && dialect.doNothingForm === "insertIgnore") {
-    throw unsupportedCapability2({
+    throw unsupportedCapability3({
       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"
@@ -1871,9 +2006,9 @@ function compileConflictTarget(params) {
         });
       }
       out.columns = target.map((name) => getFieldMeta({ model, field: String(name), context: "onConflict target" }).columnName);
-    } else if (isPlainObject2(target) && typeof target.constraint === "string" && target.constraint.length > 0 && Object.keys(target).length === 1) {
+    } else if (isPlainObject3(target) && typeof target.constraint === "string" && target.constraint.length > 0 && Object.keys(target).length === 1) {
       if (!dialect.capabilities.conflictTargetConstraint) {
-        throw unsupportedCapability2({
+        throw unsupportedCapability3({
           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"
@@ -1895,7 +2030,7 @@ function compileConflictTarget(params) {
       });
     }
     if (!dialect.capabilities.partialIndexes) {
-      throw unsupportedCapability2({
+      throw unsupportedCapability3({
         dialect: dialect.name,
         feature: "a partial-index conflict target",
         hint: "this dialect has no partial indexes to target"
@@ -1939,7 +2074,7 @@ function compileDbNowFilter(params) {
 }
 function requireObject(params) {
   const { value, what, model } = params;
-  if (!isPlainObject2(value)) {
+  if (!isPlainObject3(value)) {
     throw validationError3({
       message: `${what} must be an object on model "${model.name}"`,
       meta: { model: model.name, argument: what }
@@ -1981,7 +2116,7 @@ function assertListFilterable(params) {
   const { dialect, model, field, operator } = params;
   if (dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability2({
+  throw unsupportedCapability3({
     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"
@@ -1991,7 +2126,7 @@ function assertListWritable(params) {
   const { dialect, model, field } = params;
   if (!field.isList || dialect.capabilities.scalarArrays)
     return;
-  throw unsupportedCapability2({
+  throw unsupportedCapability3({
     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"
@@ -2108,7 +2243,7 @@ function compileJsonFieldFilter(params) {
   const requireOp = (op) => {
     if (dialect.supportedJsonOps.includes(op))
       return;
-    throw unsupportedCapability2({
+    throw unsupportedCapability3({
       dialect: dialect.name,
       feature: `json filter "${op}" on ${model.name}.${field.name}`,
       hint: `this dialect can express: ${dialect.supportedJsonOps.join(", ")}`
@@ -2268,7 +2403,7 @@ function compileOperatorFilter(params) {
           });
           break;
         }
-        if (isPlainObject2(operand)) {
+        if (isPlainObject3(operand)) {
           conditions.push({
             kind: "not",
             operand: compileOperatorFilter({ ctx, model, field, filter: operand, qualify })
@@ -2385,7 +2520,7 @@ function compileFieldFilter(params) {
     assertListFilterable({ dialect, model, field, operator: "equals" });
     return { kind: "cmp", op: "eq", column, value: encodeValue({ dialect: dialect.name, field, value }) };
   }
-  if (isPlainObject2(value)) {
+  if (isPlainObject3(value)) {
     return compileOperatorFilter({ ctx, model, field, filter: value, qualify });
   }
   throw validationError3({
@@ -2471,7 +2606,7 @@ function buildRelationExists(params) {
 }
 function requirePredicateObject(params) {
   const { model, relation, operator, operand } = params;
-  if (!isPlainObject2(operand)) {
+  if (!isPlainObject3(operand)) {
     throw validationError3({
       message: `"${operator}" on relation ${model.name}.${relation.name} expects a where object`,
       meta: { model: model.name, relation: relation.name, operator }
@@ -2484,7 +2619,7 @@ function compileRelationFilter(params) {
   const link = resolveRelationLink({ meta: ctx.meta, model, relation });
   const outer = qualify ?? model.tableName;
   if (relation.isList) {
-    if (!isPlainObject2(value)) {
+    if (!isPlainObject3(value)) {
       throw validationError3({
         message: `filter on relation ${model.name}.${relation.name} must be { some | every | none: \u2026 }`,
         meta: { model: model.name, relation: relation.name }
@@ -2546,7 +2681,7 @@ function compileRelationFilter(params) {
   if (value === null) {
     isArm = null;
     hasIs = true;
-  } else if (isPlainObject2(value) && (("is" in value) || ("isNot" in value))) {
+  } else if (isPlainObject3(value) && (("is" in value) || ("isNot" in value))) {
     for (const key of Object.keys(value)) {
       if (value[key] === undefined)
         continue;
@@ -2563,7 +2698,7 @@ function compileRelationFilter(params) {
         });
       }
     }
-  } else if (isPlainObject2(value)) {
+  } else if (isPlainObject3(value)) {
     isArm = value;
     hasIs = true;
   } else {
@@ -2659,7 +2794,7 @@ function compileOrderTerm(params) {
   const column = dialect !== undefined ? compareColumnRef({ dialect, field, ...qualify === undefined ? {} : { table: qualify } }) : columnRef({ field, ...qualify === undefined ? {} : { table: qualify } });
   if (spec === "asc" || spec === "desc")
     return { column, direction: spec };
-  if (isPlainObject2(spec)) {
+  if (isPlainObject3(spec)) {
     const { sort, nulls } = spec;
     if (sort !== "asc" && sort !== "desc") {
       throw validationError3({
@@ -2831,7 +2966,7 @@ function resolveComputedSelection(params) {
   const specs = model.computed;
   if (specs === null || aggregating)
     return null;
-  if (isPlainObject2(args.select)) {
+  if (isPlainObject3(args.select)) {
     const names = [];
     for (const [name, value] of Object.entries(args.select)) {
       if (!specs.has(name) || value === undefined || value === false)
@@ -2846,7 +2981,7 @@ function resolveComputedSelection(params) {
     }
     return names.length === 0 ? null : names;
   }
-  if (isPlainObject2(args.omit)) {
+  if (isPlainObject3(args.omit)) {
     const names = [];
     for (const name of specs.keys()) {
       const value = args.omit[name];
@@ -3154,7 +3289,7 @@ function compileUpdateSet(params) {
         meta: { model: model.name, field: field.name }
       });
     }
-    if (isPlainObject2(value) && field.scalarType !== "Json") {
+    if (isPlainObject3(value) && field.scalarType !== "Json") {
       const entries = Object.entries(value).filter(([, operand2]) => operand2 !== undefined);
       if (entries.length !== 1) {
         throw validationError3({
@@ -3316,7 +3451,7 @@ function parseCursor(params) {
 function keysetFieldOfTerm(params) {
   const { dialect, model, term } = params;
   if (!("column" in term)) {
-    throw unsupportedCapability2({
+    throw unsupportedCapability3({
       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"
@@ -3324,7 +3459,7 @@ function keysetFieldOfTerm(params) {
   }
   const field = model.fieldByColumn.get(term.column.name);
   if (field === undefined) {
-    throw unsupportedCapability2({
+    throw unsupportedCapability3({
       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"
@@ -3470,7 +3605,7 @@ function orderByScalarFields(params) {
         visit(entry);
       return;
     }
-    if (!isPlainObject2(value))
+    if (!isPlainObject3(value))
       return;
     for (const [key, spec] of Object.entries(value)) {
       if (spec === undefined)
@@ -3667,7 +3802,10 @@ function buildFindShape(params) {
   const absTake = take === undefined ? undefined : Math.abs(take);
   const limit = firstLimit === undefined ? absTake : absTake === undefined ? firstLimit : Math.min(firstLimit, absTake);
   const offset = skip;
-  const lateralJoins = useLateral ? selection.relations.map((node, index) => buildLateralJoinClause({ dialect, meta, model, node, index })) : [];
+  const lateralJoins = useLateral ? [
+    ...selection.relations.map((node, index) => buildLateralJoinClause({ dialect, meta, model, node, index })),
+    ...selection.counts.map((node, index) => buildLateralCount({ dialect, meta, model, node, index }))
+  ] : [];
   const projected = projectionColumns({
     model,
     selectedFields,
@@ -3686,6 +3824,15 @@ function buildFindShape(params) {
     }
     return out;
   };
+  const withKeyColumns = (inner, keys) => {
+    const out = [...inner];
+    for (const field of keys) {
+      if (out.some((column) => column.name === field.columnName))
+        continue;
+      out.push(columnRef({ field, ...qualify === undefined ? {} : { table: qualify } }));
+    }
+    return out;
+  };
   if (emulateDistinct) {
     const arranged = orderTerms;
     const windowOrder = arranged.slice(distinctLeadCount);
@@ -3738,6 +3885,30 @@ function buildFindShape(params) {
     };
     return { statement: statement2, reverseRows: backward, resortBy };
   }
+  const pageFirst = lateralJoins.length > 0 && (limit !== undefined || offset !== undefined) && orderTerms.every((term) => ("column" in term));
+  if (pageFirst && selection !== undefined) {
+    const correlationKeys = [...selection.relations, ...selection.counts].flatMap((node) => node.link.parentKeys);
+    const innerColumns = withOuterOrderKeys(withKeyColumns(projected, correlationKeys), orderTerms);
+    const inner = {
+      kind: "select",
+      table: { name: model.tableName },
+      columns: innerColumns,
+      ...where === undefined ? {} : { where },
+      ...distinctOn === undefined ? {} : { distinctOn },
+      ...orderTerms.length === 0 ? {} : { orderBy: orderTerms },
+      ...limit === undefined ? {} : { limit },
+      ...offset === undefined ? {} : { offset }
+    };
+    const statement2 = {
+      kind: "select",
+      table: { name: model.tableName },
+      columns,
+      fromSelect: inner,
+      lateralJoins,
+      ...orderTerms.length === 0 ? {} : { orderBy: orderTerms }
+    };
+    return { statement: statement2, reverseRows: backward, resortBy };
+  }
   const statement = {
     kind: "select",
     table: { name: model.tableName },
@@ -3751,73 +3922,66 @@ function buildFindShape(params) {
   };
   return { statement, reverseRows: backward, resortBy };
 }
-var LATERAL_CHILD_ALIAS = "__rel";
 var DISTINCT_TABLE_ALIAS = "__dist";
 var DISTINCT_ROW_NUMBER_ALIAS = "__rn";
 function lateralColumnAlias(params) {
   return `__rel_${params.relation}`;
 }
-function lateralHiddenOrderFields(params) {
-  const { node } = params;
-  const projected = node.args.projected;
-  if (projected === null || node.args.orderBy === undefined)
-    return [];
-  const target = node.link.target;
-  const hidden = [];
-  const items = Array.isArray(node.args.orderBy) ? node.args.orderBy : [node.args.orderBy];
-  for (const item of items) {
-    if (!isPlainObject2(item))
-      continue;
-    for (const [name, value] of Object.entries(item)) {
-      if (value === undefined)
-        continue;
-      if (!target.fieldByName.has(name))
-        continue;
-      if (!projected.includes(name) && !hidden.includes(name))
-        hidden.push(name);
-    }
-  }
-  return hidden;
+function lateralCountAlias(params) {
+  return `__vibe_count_${params.index}`;
 }
-var lateralFieldByColumn = new WeakMap;
-function fieldByColumnName(model) {
-  let map = lateralFieldByColumn.get(model);
-  if (map === undefined) {
-    map = new Map(model.fields.map((field) => [field.columnName, field]));
-    lateralFieldByColumn.set(model, map);
-  }
-  return map;
-}
-function applyLateralTransform(params) {
-  const { model, column } = params;
-  const field = fieldByColumnName(model).get(column.name);
-  if (field === undefined)
-    return column;
-  const scalar = field.scalarType;
-  if (scalar !== "BigInt" && scalar !== "Decimal" && scalar !== "Bytes")
-    return column;
-  if (field.isList) {
-    throw unsupportedCapability2({
-      dialect: "postgres",
-      feature: `join-strategy relation loading of ${model.name}.${field.name} (${scalar}[])`,
-      hint: 'list columns of BigInt/Decimal/Bytes have no faithful JSON wire form \u2014 use the portable "query" relation strategy'
-    });
+function buildLateralCount(params) {
+  const { dialect, meta, model, node, index } = params;
+  const { link } = node;
+  const childAlias = "__count_child";
+  const joinAlias = "__count_join";
+  const columnAlias = lateralCountAlias({ index });
+  let select;
+  const filter = node.where === undefined ? undefined : compileWhere({
+    dialect,
+    meta,
+    model: link.target,
+    where: node.where,
+    qualify: childAlias
+  });
+  if (link.kind === "manyToMany") {
+    const join = link.join;
+    const pair = singleKeyPair({ link, what: "implicit many-to-many relation count" });
+    const correlation = {
+      kind: "cmpCol",
+      op: "eq",
+      left: { table: joinAlias, name: join.parentColumn },
+      right: { table: model.tableName, name: pair.parent.columnName }
+    };
+    select = {
+      kind: "select",
+      table: filter === undefined ? { name: join.tableName, alias: joinAlias } : { name: link.target.tableName, 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 },
+        on: [{ left: { table: joinAlias, name: join.childColumn }, right: { table: childAlias, name: pair.child.columnName } }]
+      }] }
+    };
+  } else {
+    const correlation = correlateLink({ link, childTable: childAlias, outerTable: model.tableName });
+    select = {
+      kind: "select",
+      table: { name: link.target.tableName, alias: childAlias },
+      columns: [],
+      selectExpr: { kind: "countAll", alias: columnAlias },
+      where: filter === undefined ? correlation : { kind: "and", operands: [correlation, filter] }
+    };
   }
-  return { ...column, transform: scalar === "Bytes" ? "encodeBase64" : "castText" };
+  return { alias: `__count_${index}`, columnAlias, agg: "count", select };
 }
 function buildLateralJoinClause(params) {
   const { dialect, meta, model, node, index } = params;
   const link = node.link;
   const target = link.target;
   const aliasSeq = { n: 0 };
-  const projected = node.args.projected;
-  const hiddenOrder = lateralHiddenOrderFields({ node });
-  const selectedWithOrder = projected === null || hiddenOrder.length === 0 ? projected : [...projected, ...hiddenOrder];
-  const columns = projectionColumns({
-    model: target,
-    selectedFields: selectedWithOrder,
-    table: LATERAL_CHILD_ALIAS
-  }).map((column) => applyLateralTransform({ model: target, column }));
+  const { columns } = lateralProjection({ node });
   let correlate;
   if (link.kind === "manyToMany") {
     const join = link.join;
@@ -3876,6 +4040,7 @@ function buildLateralJoinClause(params) {
     alias: `__lat_${index}`,
     columnAlias: lateralColumnAlias({ relation: node.name }),
     agg: isList ? "jsonArray" : "jsonObject",
+    rowFormat: "positional",
     select: {
       kind: "select",
       table: { name: target.tableName, alias: LATERAL_CHILD_ALIAS },
@@ -4037,7 +4202,7 @@ function compileAggregatePredicate(params) {
     const aggColumn = key === "_count" ? { name: field.columnName } : compareColumnRef({ dialect, field });
     agg = { fn: AGG_FN_BY_KEY[key], column: aggColumn };
   }
-  const spec = isPlainObject2(filter) ? filter : { equals: filter };
+  const spec = isPlainObject3(filter) ? filter : { equals: filter };
   const out = [];
   for (const [operator, operand] of Object.entries(spec)) {
     if (operand === undefined)
@@ -4104,7 +4269,7 @@ function compileHaving(params) {
         meta: { model: model.name, field: field.name }
       });
     };
-    if (isPlainObject2(value)) {
+    if (isPlainObject3(value)) {
       const plain = {};
       for (const [operator, operand] of Object.entries(value)) {
         if (operand === undefined)
@@ -4191,7 +4356,7 @@ function compileGroupByOrder(params) {
 function overlayRefetchWhere(params) {
   const { model, where, data } = params;
   const out = { ...where };
-  if (!isPlainObject2(data))
+  if (!isPlainObject3(data))
     return out;
   for (const key of Object.keys(out)) {
     if (!model.fieldByName.has(key))
@@ -4203,7 +4368,7 @@ function overlayRefetchWhere(params) {
       out[key] = value;
       continue;
     }
-    if (isPlainObject2(value) && (isDirectValue(value.set) || value.set === null)) {
+    if (isPlainObject3(value) && (isDirectValue(value.set) || value.set === null)) {
       out[key] = value.set;
     }
   }
@@ -4234,7 +4399,7 @@ function resolveStrategy(params) {
   const strategy = explicit ?? defaultRelationStrategy ?? "query";
   if (strategy === "join" && !dialect.capabilities.lateralJoin) {
     if (explicit !== undefined || hasRelations) {
-      throw unsupportedCapability2({
+      throw unsupportedCapability3({
         dialect: dialect.name,
         feature: 'relationStrategy "join"',
         hint: 'lateral joins are postgres-only \u2014 use the portable "query" strategy on this dialect'
@@ -4271,7 +4436,7 @@ function buildQuery(params) {
   const aggregating = method === "aggregate" || method === "groupBy" || method === "count";
   const relationCapable = RELATION_CAPABLE_METHODS.includes(method);
   const relations = relationCapable ? resolveRelationSelection({ meta, model, select: args.select, include: args.include }) : null;
-  if (!relationCapable && !aggregating && isPlainObject2(args.select)) {
+  if (!relationCapable && !aggregating && isPlainObject3(args.select)) {
     for (const key of Object.keys(args.select)) {
       if (args.select[key] === undefined || args.select[key] === false)
         continue;
@@ -4641,7 +4806,7 @@ function buildQuery(params) {
     case "createMany":
     case "createManyAndReturn": {
       if (method === "createManyAndReturn" && !dialect.capabilities.createManyAndReturn) {
-        throw unsupportedCapability2({
+        throw unsupportedCapability3({
           dialect: dialect.name,
           feature: "createManyAndReturn",
           hint: "this dialect cannot RETURNING multiple inserted rows \u2014 use createMany then findMany"
@@ -4773,7 +4938,7 @@ function buildQuery(params) {
     case "updateManyAndReturn": {
       const isUnique = method === "update";
       if (method === "updateManyAndReturn" && !dialect.capabilities.returning) {
-        throw unsupportedCapability2({
+        throw unsupportedCapability3({
           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"
@@ -4818,7 +4983,7 @@ function buildQuery(params) {
           });
         }
         if (!dialect.capabilities.conflictTargetConstraint) {
-          throw unsupportedCapability2({
+          throw unsupportedCapability3({
             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"
@@ -4836,7 +5001,7 @@ function buildQuery(params) {
       const targetFields = conflictTargetGroup({ model, where }).fields;
       for (const field of targetFields) {
         if (!(field.columnName in row.values)) {
-          throw new VibeError7({
+          throw new VibeError8({
             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 }
@@ -4847,7 +5012,7 @@ function buildQuery(params) {
       for (const [key, value] of Object.entries(where)) {
         if (value === undefined || nativeTargetNames.has(key))
           continue;
-        throw new VibeError7({
+        throw new VibeError8({
           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 }
@@ -4900,7 +5065,7 @@ function buildQuery(params) {
 import { getSqlDialect, renderStatement } from "@vibeorm/sql";
 
 // packages/runtime/src/relation-key.ts
-import { VibeError as VibeError8 } from "@vibeorm/schema";
+import { VibeError as VibeError9 } from "@vibeorm/schema";
 function relationValueKey(params) {
   const { value } = params;
   if (value === null || value === undefined)
@@ -4933,7 +5098,7 @@ function relationTupleKey(params) {
     if (value === null || value === undefined)
       return null;
     if (typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array)) {
-      throw new VibeError8({
+      throw new VibeError9({
         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) }
@@ -4959,7 +5124,7 @@ function assertWriteScope(params) {
 }
 
 // packages/runtime/src/nested-writes.ts
-import { VibeError as VibeError9 } from "@vibeorm/schema";
+import { VibeError as VibeError10 } from "@vibeorm/schema";
 function parentTupleOf(params) {
   const { link, row } = params;
   return link.parentKeys.map((field) => row[field.name]);
@@ -5006,12 +5171,12 @@ function detachAssignment(params) {
   return out;
 }
 function validationError4(params) {
-  return new VibeError9({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError10({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function notFound(params) {
-  return new VibeError9({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
+  return new VibeError10({ code: "VIBE_NOT_FOUND", message: params.message, meta: params.meta });
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
 }
 function isDirectValue2(value) {
@@ -5019,7 +5184,7 @@ function isDirectValue2(value) {
 }
 function hasNestedWrites(params) {
   const { model, data } = params;
-  if (!isPlainObject3(data))
+  if (!isPlainObject4(data))
     return false;
   for (const [key, value] of Object.entries(data)) {
     if (value === undefined)
@@ -5059,7 +5224,7 @@ function partitionData(params) {
       scalars[key] = value;
       continue;
     }
-    if (!isPlainObject3(value)) {
+    if (!isPlainObject4(value)) {
       throw validationError4({
         message: `relation ${model.name}.${key} in data must be an object of nested-write operations`,
         meta: { model: model.name, relation: key }
@@ -5101,7 +5266,7 @@ function toItems(params) {
     });
   }
   return list.map((item) => {
-    if (!isPlainObject3(item)) {
+    if (!isPlainObject4(item)) {
       throw validationError4({
         message: `nested "${verb}" on ${op.link.relation.model}.${op.name} expects object items`,
         meta: { relation: op.name, verb }
@@ -5113,7 +5278,7 @@ function toItems(params) {
 function requireShape(params) {
   const { op, verb, item, keys } = params;
   for (const key of keys) {
-    if (!isPlainObject3(item[key])) {
+    if (!isPlainObject4(item[key])) {
       throw validationError4({
         message: `nested "${verb}" on ${op.link.relation.model}.${op.name} needs an object "${key}"`,
         meta: { relation: op.name, verb, missing: key }
@@ -5368,7 +5533,7 @@ function createNeedsTransaction(params) {
     if (op.link.kind !== "toOneOwner")
       return true;
     const { verb, operand } = singleVerb({ op });
-    if (verb !== "connect" || !isPlainObject3(operand))
+    if (verb !== "connect" || !isPlainObject4(operand))
       return true;
     const entries = Object.entries(operand).filter(([, value]) => value !== undefined);
     const named = new Map(entries);
@@ -5385,7 +5550,7 @@ async function createWithNested(params) {
 }
 function updateDataOf(params) {
   const { op, operand } = params;
-  if ("data" in operand && isPlainObject3(operand.data))
+  if ("data" in operand && isPlainObject4(operand.data))
     return operand.data;
   if ("data" in operand) {
     throw validationError4({
@@ -5476,7 +5641,7 @@ async function resolveOwnerUpdateVerb(params) {
       return;
     }
     case "update": {
-      if (!isPlainObject3(operand)) {
+      if (!isPlainObject4(operand)) {
         throw validationError4({
           message: `nested "update" on ${link.relation.model}.${op.name} expects an object`,
           meta: { relation: op.name }
@@ -5499,7 +5664,7 @@ async function resolveOwnerUpdateVerb(params) {
       return;
     }
     default: {
-      if (!isPlainObject3(operand)) {
+      if (!isPlainObject4(operand)) {
         throw validationError4({
           message: `nested "upsert" on ${link.relation.model}.${op.name} expects an object`,
           meta: { relation: op.name }
@@ -5640,7 +5805,7 @@ async function applyChildUpdateOps(params) {
       }
       case "update": {
         if (link.kind === "toOneInverse") {
-          if (!isPlainObject3(operand)) {
+          if (!isPlainObject4(operand)) {
             throw validationError4({
               message: `nested "update" on ${link.relation.model}.${op.name} expects an object`,
               meta: { relation: op.name }
@@ -5703,7 +5868,7 @@ async function applyChildUpdateOps(params) {
         const items = toItems({ op, verb, operand });
         for (const item of items) {
           const data = item.data;
-          if (!isPlainObject3(data)) {
+          if (!isPlainObject4(data)) {
             throw validationError4({
               message: `nested "updateMany" on ${link.relation.model}.${op.name} needs an object "data"`,
               meta: { relation: op.name }
@@ -5774,7 +5939,7 @@ async function applyChildUpdateOps(params) {
       }
       default: {
         if (link.kind === "toOneInverse") {
-          if (!isPlainObject3(operand)) {
+          if (!isPlainObject4(operand)) {
             throw validationError4({
               message: `nested "upsert" on ${link.relation.model}.${op.name} expects an object`,
               meta: { relation: op.name }
@@ -6113,7 +6278,7 @@ function previewOperation(params) {
   };
 }
 // packages/runtime/src/diagnostics/plan.ts
-import { VibeError as VibeError10, unsupportedCapability as unsupportedCapability3 } from "@vibeorm/schema";
+import { VibeError as VibeError11, unsupportedCapability as unsupportedCapability4 } 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 = [
@@ -6132,7 +6297,7 @@ var CONDITION_KEYS = [
   "Output"
 ];
 function planError(params) {
-  return new VibeError10({ code: "VIBE_ADAPTER", message: params.message, meta: {} });
+  return new VibeError11({ code: "VIBE_ADAPTER", message: params.message, meta: {} });
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
@@ -6165,14 +6330,14 @@ function parsePostgresPlan(params) {
   const maxNodes = params.maxNodes ?? PLAN_DEFAULTS.maxNodes;
   const includeLiterals = params.includeLiterals === true;
   if (!Number.isInteger(maxNodes) || maxNodes < 1) {
-    throw new VibeError10({ code: "VIBE_CONFIG", message: `maxNodes must be a positive integer, got ${String(maxNodes)}`, meta: { maxNodes } });
+    throw new VibeError11({ 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 VibeError10({
+      throw new VibeError11({
         code: "VIBE_ADAPTER",
         message: "EXPLAIN returned malformed JSON",
         meta: { reason: "malformed-plan-json", mode }
@@ -6239,7 +6404,7 @@ function parsePostgresPlan(params) {
 }
 var WRITE_LEADERS = ["INSERT", "UPDATE", "DELETE", "MERGE", "TRUNCATE", "CREATE", "DROP", "ALTER", "GRANT", "REVOKE", "COPY", "CALL", "DO"];
 function refuse(params) {
-  return new VibeError10({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta ?? {} });
+  return new VibeError11({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta ?? {} });
 }
 function assertExecutableRead(params) {
   const normalized = normalizeSql({ text: params.text });
@@ -6278,7 +6443,7 @@ async function readPlanContext(params) {
 }
 function requirePostgres(params) {
   if (params.dialect !== "postgres") {
-    throw unsupportedCapability3({
+    throw unsupportedCapability4({
       dialect: params.dialect,
       feature: "query plan inspection",
       hint: "plan inspection is PostgreSQL-shaped; operation tracing (telemetry) works on every dialect"
@@ -6330,7 +6495,7 @@ async function explainSql(params) {
     const context = await readPlanContext({ executor, dialect, rlsContextKeys: contextKeys });
     if (!context.representative) {
       if (params.requireRepresentativeContext === true) {
-        throw new VibeError10({
+        throw new VibeError11({
           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 }
@@ -6412,7 +6577,7 @@ async function explainOperation(params) {
   });
 }
 // packages/runtime/src/diagnostics/workload.ts
-import { unsupportedCapability as unsupportedCapability4 } from "@vibeorm/schema";
+import { unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
 import { getSqlDialect as getSqlDialect3, renderPostgresWorkload as renderPostgresWorkload2 } from "@vibeorm/sql";
 var STATEMENTS_INFO_MIN_VERSION = 140000;
 var STATEMENTS_MIN_VERSION = 130000;
@@ -6445,7 +6610,7 @@ async function readAvailability(params) {
 async function readWorkloadStatistics(params) {
   const { executor } = params;
   if (params.dialect !== "postgres") {
-    throw unsupportedCapability4({
+    throw unsupportedCapability5({
       dialect: params.dialect,
       feature: "workload statistics (pg_stat_statements)",
       hint: "server workload statistics are PostgreSQL-only; operation telemetry works on every dialect"
@@ -6523,7 +6688,7 @@ async function readWorkloadStatistics(params) {
   };
 }
 // packages/runtime/src/diagnostics/insight.ts
-import { VibeError as VibeError11 } from "@vibeorm/schema";
+import { VibeError as VibeError12 } from "@vibeorm/schema";
 var DIAGNOSTIC_THRESHOLDS = Object.freeze({
   repeatThreshold: 5,
   minRepeatThreshold: 2,
@@ -6541,7 +6706,7 @@ function bounded(params) {
   if (value === undefined)
     return fallback;
   if (!Number.isInteger(value) || value < min || value > max) {
-    throw new VibeError11({
+    throw new VibeError12({
       code: "VIBE_CONFIG",
       message: `${name} must be an integer between ${min} and ${max}, got ${String(value)}`,
       meta: { [name]: value }
@@ -6764,11 +6929,11 @@ function recommendFromPlan(params) {
   return findings.slice(0, maxFindings);
 }
 // packages/runtime/src/relation-loader.ts
-import { VibeError as VibeError13 } from "@vibeorm/schema";
+import { VibeError as VibeError14 } from "@vibeorm/schema";
 import { renderStatement as renderStatement3 } from "@vibeorm/sql";
 
 // packages/runtime/src/computed.ts
-import { VibeError as VibeError12 } from "@vibeorm/schema";
+import { VibeError as VibeError13 } from "@vibeorm/schema";
 function sameNeeds(a, b) {
   if (a.length !== b.length)
     return false;
@@ -6804,7 +6969,7 @@ function assertComputedManifest(params) {
     problems.push(`"${key}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError12({
+    throw new VibeError13({
       code: "VIBE_STALE_CLIENT",
       message: `computed-field config changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { problems }
@@ -6936,7 +7101,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 VibeError13({
+      throw new VibeError14({
         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 }
@@ -7066,7 +7231,7 @@ async function loadManyToMany(params) {
   const link = node.link;
   const join = link.join;
   if (join === null) {
-    throw new VibeError13({
+    throw new VibeError14({
       code: "VIBE_INTERNAL",
       message: `manyToMany relation "${node.name}" resolved without join-table wiring`
     });
@@ -7327,14 +7492,15 @@ async function attachRelations(params) {
   await loadCounts({ ctx, model, rows, counts: selection.counts });
 }
 async function attachLateralRelations(params) {
-  const { dialect, meta, model, rows, selection, execute, wire } = params;
+  const { dialect, meta, rows, selection, execute, wire } = params;
   if (rows.length === 0)
     return;
   const ctx = { dialect, meta, execute, wire };
   for (const node of selection.relations) {
     const column = lateralColumnAlias({ relation: node.name });
     const isList = node.link.relation.isList;
-    const hiddenOrder = lateralHiddenOrderFields({ node });
+    const { columns, hiddenOrder } = lateralProjection({ node });
+    const decodePosition = positionalMaterializer({ model: node.link.target, columns });
     const kept = [];
     for (const row of rows) {
       const raw = row[column];
@@ -7344,7 +7510,7 @@ async function attachLateralRelations(params) {
         try {
           parsed = JSON.parse(raw);
         } catch (cause) {
-          throw new VibeError13({
+          throw new VibeError14({
             code: "VIBE_INTERNAL",
             message: `relation column "${column}" returned text that is not valid JSON`,
             meta: { relation: node.name },
@@ -7353,8 +7519,10 @@ async function attachLateralRelations(params) {
         }
       }
       if (isList) {
-        const list = Array.isArray(parsed) ? parsed : [];
-        const children = materializeJsonRows({ model: node.link.target, rows: list });
+        if (!Array.isArray(parsed)) {
+          throw new VibeError14({ 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) {
           for (const name of hiddenOrder)
             delete child[name];
@@ -7362,14 +7530,11 @@ async function attachLateralRelations(params) {
         row[node.name] = children;
         pushAll(kept, children);
       } else {
-        if (parsed === null || parsed === undefined || typeof parsed !== "object") {
+        if (parsed === null) {
           row[node.name] = null;
           continue;
         }
-        const child = materializeJsonRows({
-          model: node.link.target,
-          rows: [parsed]
-        })[0];
+        const child = decodePosition(parsed);
         for (const name of hiddenOrder)
           delete child[name];
         row[node.name] = child;
@@ -7378,10 +7543,25 @@ async function attachLateralRelations(params) {
     }
     await finishNode({ ctx, node, kept });
   }
-  await loadCounts({ ctx, model, rows, counts: selection.counts });
+  if (selection.counts.length === 0)
+    return;
+  for (const row of rows) {
+    const counts = {};
+    for (let index = 0;index < selection.counts.length; index++) {
+      const column = lateralCountAlias({ index });
+      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 VibeError14({ 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];
+    }
+    row._count = counts;
+  }
 }
 // packages/runtime/src/extensions.ts
-import { VibeError as VibeError14, extensionManifestEntry } from "@vibeorm/schema";
+import { VibeError as VibeError15, extensionManifestEntry } from "@vibeorm/schema";
 function assertExtensionManifest(params) {
   const { manifest } = params;
   const instances = params.instances ?? [];
@@ -7404,7 +7584,7 @@ function assertExtensionManifest(params) {
     problems.push(`"${name}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError14({
+    throw new VibeError15({
       code: "VIBE_STALE_CLIENT",
       message: `extension list changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { manifest, problems }
@@ -7419,7 +7599,7 @@ function buildExtensionOperatorMap(params) {
     for (const operator of extension.sql?.whereOperators ?? []) {
       const existing = owner.get(operator.name);
       if (existing !== undefined) {
-        throw new VibeError14({
+        throw new VibeError15({
           code: "VIBE_CONFIG",
           message: `where operator "${operator.name}" is claimed by both "${existing}" and "${extension.name}"`,
           meta: { operator: operator.name }
@@ -7435,7 +7615,7 @@ function buildExtensionOperatorMap(params) {
           options: extension.options
         });
         if ("error" in compiled) {
-          throw new VibeError14({
+          throw new VibeError15({
             code: "VIBE_VALIDATION",
             message: `"${operator.name}" on ${model}.${field}: ${compiled.error}`,
             meta: { model, field, operator: operator.name, extension: extension.name }
@@ -7467,9 +7647,9 @@ function buildConnectHooks(params) {
   return hooks;
 }
 // packages/runtime/src/views.ts
-import { VibeError as VibeError15 } from "@vibeorm/schema";
+import { VibeError as VibeError16 } from "@vibeorm/schema";
 function validationError5(params) {
-  return new VibeError15({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError16({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 
 class ViewResult {
@@ -7518,12 +7698,12 @@ class ViewResult {
     return out;
   }
 }
-function isPlainObject4(value) {
+function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveDefinition(params) {
   const { meta, name, definition } = params;
-  if (!isPlainObject4(definition)) {
+  if (!isPlainObject5(definition)) {
     throw validationError5({
       message: `view "${name}": definition must be an object of { modelKey: { field: true } }`,
       meta: { view: name }
@@ -7540,7 +7720,7 @@ function resolveDefinition(params) {
         meta: { view: name, model: key }
       });
     }
-    if (!isPlainObject4(fieldSpec)) {
+    if (!isPlainObject5(fieldSpec)) {
       throw validationError5({
         message: `view "${name}": definition.${key} must be an object of { field: true }`,
         meta: { view: name, model: model.name }
@@ -7595,7 +7775,7 @@ function revealSet(params) {
   const revealed = new Set;
   if (reveal === undefined)
     return revealed;
-  if (!isPlainObject4(reveal)) {
+  if (!isPlainObject5(reveal)) {
     throw validationError5({
       message: `view "${name}": reveal must be an object of { field: true }`,
       meta: { view: name, model: mask.model.name }
@@ -7633,13 +7813,13 @@ function mergeLevel(params) {
   const revealed = revealSet({ name, mask, reveal: args.reveal });
   let scalars;
   const userSelect = args.select;
-  if (userSelect !== undefined && !isPlainObject4(userSelect)) {
+  if (userSelect !== undefined && !isPlainObject5(userSelect)) {
     throw validationError5({
       message: `view "${name}": select must be an object`,
       meta: { view: name, model: model.name }
     });
   }
-  if (isPlainObject4(userSelect)) {
+  if (isPlainObject5(userSelect)) {
     scalars = new Set;
     for (const [key, flag] of Object.entries(userSelect)) {
       if (flag === false || flag === undefined)
@@ -7657,7 +7837,7 @@ function mergeLevel(params) {
   const collectRelations = (source, argName) => {
     if (source === undefined)
       return;
-    if (!isPlainObject4(source)) {
+    if (!isPlainObject5(source)) {
       throw validationError5({
         message: `view "${name}": ${argName} must be an object`,
         meta: { view: name, model: model.name }
@@ -7705,7 +7885,7 @@ function mergeLevel(params) {
       relationPlans.set(relationName, child2.plan);
       continue;
     }
-    if (!isPlainObject4(spec)) {
+    if (!isPlainObject5(spec)) {
       throw validationError5({
         message: `view "${name}": include.${relationName} must be true or an object`,
         meta: { view: name, model: model.name, relation: relationName }
@@ -7743,7 +7923,7 @@ function wrapRows(params) {
       const value = record[relationName];
       if (Array.isArray(value)) {
         record[relationName] = wrapRows({ rows: value, plan: childPlan });
-      } else if (isPlainObject4(value)) {
+      } else if (isPlainObject5(value)) {
         record[relationName] = wrapRows({ rows: [value], plan: childPlan })[0];
       }
     }
@@ -7768,7 +7948,7 @@ function createViewDelegate(params) {
   const { meta, name, definition, mask, delegate } = params;
   const merge = (args) => {
     const raw = args ?? {};
-    if (!isPlainObject4(raw)) {
+    if (!isPlainObject5(raw)) {
       throw validationError5({
         message: `view "${name}": query args must be an object`,
         meta: { view: name, model: mask.model.name }
@@ -7823,7 +8003,7 @@ function createView(params) {
   for (const [clientName, mask] of resolved) {
     const delegate = models[clientName];
     if (delegate === undefined) {
-      throw new VibeError15({
+      throw new VibeError16({
         code: "VIBE_INTERNAL",
         message: `view "${name}": no delegate for model "${mask.model.name}"`,
         meta: { view: name, model: mask.model.name }
@@ -7839,9 +8019,9 @@ function attachDefineView(params) {
   Object.defineProperty(client, "$defineView", { value, enumerable: true });
 }
 // packages/runtime/src/validators.ts
-import { VibeError as VibeError16 } from "@vibeorm/schema";
+import { VibeError as VibeError17 } from "@vibeorm/schema";
 function validationFailed(params) {
-  return new VibeError16({
+  return new VibeError17({
     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 }
@@ -7850,7 +8030,7 @@ function validationFailed(params) {
 function validateValue(params) {
   const result = params.schema["~standard"].validate(params.value);
   if (result instanceof Promise) {
-    throw new VibeError16({
+    throw new VibeError17({
       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 }
@@ -7862,12 +8042,12 @@ function validateValue(params) {
   return result.value;
 }
 var ATOMIC_OPERATORS = ["set", "increment", "decrement", "multiply", "divide", "push"];
-function isPlainObject5(value) {
+function isPlainObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function operatorOf(params) {
   const { model, field, value } = params;
-  if (!isPlainObject5(value))
+  if (!isPlainObject6(value))
     return;
   const meta = model.fieldByName.get(field);
   if (meta === undefined || meta.scalarType === "Json")
@@ -7911,10 +8091,10 @@ function validateWriteData(params) {
 }
 function validateNestedVerbs(params) {
   const { meta, target, verbs, validators } = params;
-  const one = (row) => isPlainObject5(row) ? validateWriteData({ meta, model: target, data: row, validators }) : row;
+  const one = (row) => isPlainObject6(row) ? validateWriteData({ meta, model: target, data: row, validators }) : row;
   const many = (value) => Array.isArray(value) ? value.map(one) : one(value);
   const body = (value, arms) => {
-    if (!isPlainObject5(value))
+    if (!isPlainObject6(value))
       return value;
     if (!arms.some((arm) => value[arm] !== undefined))
       return one(value);
@@ -7930,11 +8110,11 @@ function validateNestedVerbs(params) {
   if (verbs.create !== undefined)
     next.create = many(verbs.create);
   if (verbs.createMany !== undefined) {
-    next.createMany = isPlainObject5(verbs.createMany) ? { ...verbs.createMany, data: many(verbs.createMany.data) } : many(verbs.createMany);
+    next.createMany = isPlainObject6(verbs.createMany) ? { ...verbs.createMany, data: many(verbs.createMany.data) } : many(verbs.createMany);
   }
   if (verbs.connectOrCreate !== undefined) {
     const entries = Array.isArray(verbs.connectOrCreate) ? verbs.connectOrCreate : [verbs.connectOrCreate];
-    const mapped = entries.map((entry) => isPlainObject5(entry) ? { ...entry, create: many(entry.create) } : entry);
+    const mapped = entries.map((entry) => isPlainObject6(entry) ? { ...entry, create: many(entry.create) } : entry);
     next.connectOrCreate = Array.isArray(verbs.connectOrCreate) ? mapped : mapped[0];
   }
   if (verbs.update !== undefined)
@@ -7973,14 +8153,14 @@ function deferPolicyOperation(params) {
 }
 
 // packages/runtime/src/policy.ts
-import { VibeError as VibeError17 } from "@vibeorm/schema";
+import { VibeError as VibeError18 } from "@vibeorm/schema";
 function policyError(message, meta) {
-  return new VibeError17({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
+  return new VibeError18({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
 }
 function policiedModels(meta) {
   return meta.models.filter((model) => model.policy !== undefined);
 }
-function isPlainObject6(value) {
+function isPlainObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function deferred(build) {
@@ -8016,7 +8196,7 @@ function uniqueToFilter(params) {
 }
 function scopeWhere(params) {
   const { meta, model, where, context } = params;
-  if (!isPlainObject6(where))
+  if (!isPlainObject7(where))
     return where;
   const out = {};
   const extra = [];
@@ -8036,10 +8216,10 @@ function scopeWhere(params) {
     }
     const scoped = target.policy !== undefined;
     const pred = () => predicateFor({ model: target, context });
-    const walkChild = (child) => isPlainObject6(child) ? scopeWhere({ meta, model: target, where: child, context }) : child;
+    const walkChild = (child) => isPlainObject7(child) ? scopeWhere({ meta, model: target, where: child, context }) : child;
     const parts = [];
     if (relation.isList) {
-      if (!isPlainObject6(value)) {
+      if (!isPlainObject7(value)) {
         out[key] = value;
         continue;
       }
@@ -8060,7 +8240,7 @@ function scopeWhere(params) {
       const arms = [];
       if (value === null) {
         arms.push({ arm: "is", operand: null });
-      } else if (isPlainObject6(value) && (("is" in value) || ("isNot" in value))) {
+      } else if (isPlainObject7(value) && (("is" in value) || ("isNot" in value))) {
         let mixed = false;
         for (const [op, operand] of Object.entries(value)) {
           if (operand === undefined)
@@ -8074,7 +8254,7 @@ function scopeWhere(params) {
           out[key] = value;
           continue;
         }
-      } else if (isPlainObject6(value)) {
+      } else if (isPlainObject7(value)) {
         arms.push({ arm: "is", operand: value });
       } else {
         out[key] = value;
@@ -8112,7 +8292,7 @@ function scopeWhere(params) {
 function assertPolicyOrder(params) {
   const { meta, model, orderBy } = params;
   for (const term of Array.isArray(orderBy) ? orderBy : [orderBy]) {
-    if (!isPlainObject6(term))
+    if (!isPlainObject7(term))
       continue;
     for (const [name, spec] of Object.entries(term)) {
       if (spec === undefined)
@@ -8134,18 +8314,18 @@ function scopeSelection(params) {
   assertPolicyOrder({ meta, model, orderBy: args.orderBy });
   for (const key of ["include", "select"]) {
     const block = args[key];
-    if (!isPlainObject6(block))
+    if (!isPlainObject7(block))
       continue;
     const next = { ...block };
     for (const [name, spec] of Object.entries(block)) {
       if (spec === undefined || spec === false)
         continue;
       if (name === "_count") {
-        const names = spec === true ? model.relations.filter((relation2) => relation2.isList).map((relation2) => relation2.name) : isPlainObject6(spec) && isPlainObject6(spec.select) ? Object.keys(spec.select).filter((key2) => {
+        const names = spec === true ? model.relations.filter((relation2) => relation2.isList).map((relation2) => relation2.name) : isPlainObject7(spec) && isPlainObject7(spec.select) ? Object.keys(spec.select).filter((key2) => {
           const entry = spec.select[key2];
-          return entry === true || isPlainObject6(entry);
+          return entry === true || isPlainObject7(entry);
         }) : [];
-        const countSelect = isPlainObject6(spec) && isPlainObject6(spec.select) ? { ...spec.select } : undefined;
+        const countSelect = isPlainObject7(spec) && isPlainObject7(spec.select) ? { ...spec.select } : undefined;
         for (const counted of names) {
           const relation2 = model.relationByName.get(counted);
           const target2 = relation2 === undefined ? undefined : meta.modelByName.get(relation2.targetModel);
@@ -8153,7 +8333,7 @@ function scopeSelection(params) {
             throw policyError(`_count of ${model.name}.${counted} cannot enforce @@policy because relation counts take no filter \u2014 use a scoped child count query instead`, { model: model.name, relation: counted });
           }
           const entry = countSelect?.[counted];
-          if (target2 !== undefined && countSelect !== undefined && isPlainObject6(entry) && entry.where !== undefined) {
+          if (target2 !== undefined && countSelect !== undefined && isPlainObject7(entry) && entry.where !== undefined) {
             countSelect[counted] = { ...entry, where: scopeWhere({ meta, model: target2, where: entry.where, context }) };
           }
         }
@@ -8195,7 +8375,7 @@ function forceWriteData(params) {
   if (model.policy !== undefined) {
     const value = predicateFor({ model, context })[model.policy.field];
     const given = data[model.policy.field];
-    const explicit = isPlainObject6(given) && "set" in given ? given.set : given;
+    const explicit = isPlainObject7(given) && "set" in given ? given.set : given;
     if (explicit !== undefined && explicit !== value) {
       throw policyError(`${phase} on ${model.name}: data.${model.policy.field} conflicts with the bound policy context`, { model: model.name, field: model.policy.field, phase });
     }
@@ -8213,7 +8393,7 @@ function forceWriteData(params) {
   }
   for (const [name, spec] of Object.entries(data)) {
     const relation = model.relationByName.get(name);
-    if (relation === undefined || !isPlainObject6(spec))
+    if (relation === undefined || !isPlainObject7(spec))
       continue;
     const target = meta.modelByName.get(relation.targetModel);
     if (target === undefined)
@@ -8245,10 +8425,10 @@ function forceWriteData(params) {
 }
 function forceNestedVerbs(params) {
   const { meta, target, verbs, context } = params;
-  const walk2 = (row, phase) => isPlainObject6(row) ? forceWriteData({ meta, model: target, data: row, context, phase }) : row;
+  const walk2 = (row, phase) => isPlainObject7(row) ? forceWriteData({ meta, model: target, data: row, context, phase }) : row;
   const each = (value, phase) => Array.isArray(value) ? value.map((row) => walk2(row, phase)) : walk2(value, phase);
   const body = (value, keys) => {
-    if (!isPlainObject6(value))
+    if (!isPlainObject7(value))
       return value;
     const hasArm = keys.some((key) => value[key] !== undefined);
     if (!hasArm)
@@ -8264,12 +8444,12 @@ function forceNestedVerbs(params) {
   const out = { ...verbs };
   if (verbs.create !== undefined)
     out.create = each(verbs.create, "create");
-  if (verbs.createMany !== undefined && isPlainObject6(verbs.createMany)) {
+  if (verbs.createMany !== undefined && isPlainObject7(verbs.createMany)) {
     out.createMany = { ...verbs.createMany, data: each(verbs.createMany.data, "create") };
   }
   if (verbs.connectOrCreate !== undefined) {
     const entries = Array.isArray(verbs.connectOrCreate) ? verbs.connectOrCreate : [verbs.connectOrCreate];
-    const mapped = entries.map((entry) => isPlainObject6(entry) ? { ...entry, create: each(entry.create, "create") } : entry);
+    const mapped = entries.map((entry) => isPlainObject7(entry) ? { ...entry, create: each(entry.create, "create") } : entry);
     out.connectOrCreate = Array.isArray(verbs.connectOrCreate) ? mapped : mapped[0];
   }
   if (verbs.update !== undefined) {
@@ -8319,7 +8499,7 @@ 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 notFound2 = (method) => new VibeError17({ 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 notFound2 = (method) => new VibeError18({ 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)),
     findFirst: (args) => base.findFirst(scopeFind(args)),
@@ -8353,7 +8533,7 @@ function scopedDelegate(params) {
       })
     })),
     upsertMany: () => {
-      throw new VibeError17({
+      throw new VibeError18({
         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 }
@@ -8362,7 +8542,7 @@ function scopedDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError17({
+        throw new VibeError18({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate",
           meta: { model: model.name }
@@ -8433,7 +8613,7 @@ function globalDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError17({
+        throw new VibeError18({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate"
         });
@@ -8444,7 +8624,7 @@ function globalDelegate(params) {
     upsertMany: (args) => deferred(() => {
       if (params.policyBound === false)
         return base.upsertMany(args);
-      throw new VibeError17({
+      throw new VibeError18({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "upsertMany is not available on a policy-bound client: its conflict target is not policy-checked yet"
       });
@@ -8491,7 +8671,7 @@ function attachPolicy(params) {
     const guardValue = (value, key) => {
       if (typeof value === "function")
         return guard(key);
-      if (!isPlainObject6(value))
+      if (!isPlainObject7(value))
         return value;
       const namespace = {};
       for (const inner of Object.keys(value)) {
@@ -8599,11 +8779,11 @@ function attachPolicy(params) {
   });
 }
 // packages/runtime/src/scoped.ts
-import { ScopedQueryError, VibeError as VibeError18 } from "@vibeorm/schema";
+import { ScopedQueryError, VibeError as VibeError19 } from "@vibeorm/schema";
 function refusal(params) {
   return new ScopedQueryError(params);
 }
-function isPlainObject7(value) {
+function isPlainObject8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
 }
 var SCOPEABLE_COLUMN_TYPES = ["String", "Int", "BigInt"];
@@ -8649,7 +8829,7 @@ function resolveScopedModels(params) {
       resolved.set(model.name, { kind: "none" });
       continue;
     }
-    if (!isPlainObject7(entry)) {
+    if (!isPlainObject8(entry)) {
       throw refusal({
         model: model.name,
         path: "models",
@@ -8797,7 +8977,7 @@ function mergeWhere2(params) {
 }
 function injectUniqueWhere(params) {
   const { where, pred } = params;
-  if (!isPlainObject7(where))
+  if (!isPlainObject8(where))
     return { AND: [pred] };
   const existing = where.AND === undefined ? [] : Array.isArray(where.AND) ? where.AND : [where.AND];
   return { ...where, AND: [...existing, pred] };
@@ -8808,7 +8988,7 @@ function flattenUniqueWhere(params) {
     return where;
   const out = {};
   for (const [key, value] of Object.entries(where)) {
-    if (isPlainObject7(value) && model.compoundUniques.has(key))
+    if (isPlainObject8(value) && model.compoundUniques.has(key))
       Object.assign(out, value);
     else
       out[key] = value;
@@ -8828,7 +9008,7 @@ function walkWhere(params) {
   const out = {};
   const extra = [];
   const walkGroup = (value, key) => {
-    const walkItem = (item) => isPlainObject7(item) ? walkWhere({ ctx, model, where: item, path: `${path}.${key}` }) : item;
+    const walkItem = (item) => isPlainObject8(item) ? walkWhere({ ctx, model, where: item, path: `${path}.${key}` }) : item;
     return Array.isArray(value) ? value.map(walkItem) : walkItem(value);
   };
   for (const [key, value] of Object.entries(where)) {
@@ -8848,10 +9028,10 @@ function walkWhere(params) {
     const scoped = targetEntry.kind !== "none";
     const childPath = `${path}.${key}`;
     const pred = () => requirePred({ ctx, model: target, path: childPath });
-    const walkChild = (child, op) => isPlainObject7(child) ? walkWhere({ ctx, model: target, where: child, path: `${childPath}.${op}` }) : child;
+    const walkChild = (child, op) => isPlainObject8(child) ? walkWhere({ ctx, model: target, where: child, path: `${childPath}.${op}` }) : child;
     const parts = [];
     if (relation.isList) {
-      if (!isPlainObject7(value)) {
+      if (!isPlainObject8(value)) {
         out[key] = value;
         continue;
       }
@@ -8872,7 +9052,7 @@ function walkWhere(params) {
       const arms = [];
       if (value === null) {
         arms.push({ arm: "is", operand: null });
-      } else if (isPlainObject7(value) && (("is" in value) || ("isNot" in value))) {
+      } else if (isPlainObject8(value) && (("is" in value) || ("isNot" in value))) {
         let mixed = false;
         for (const [op, operand] of Object.entries(value)) {
           if (operand === undefined)
@@ -8886,7 +9066,7 @@ function walkWhere(params) {
           out[key] = value;
           continue;
         }
-      } else if (isPlainObject7(value)) {
+      } else if (isPlainObject8(value)) {
         arms.push({ arm: "is", operand: value });
       } else {
         out[key] = value;
@@ -8941,7 +9121,7 @@ function walkOrderTerm(params) {
         message: `$scoped: orderBy through ${model.name}.${key} reaches scoped model ${target.name} \u2014 ordering by a foreign row's values would leak; order by own columns instead`
       });
     }
-    if (isPlainObject7(spec)) {
+    if (isPlainObject8(spec)) {
       walkOrderTerm({ ctx, model: target, term: spec, path: `${path}.${key}` });
     }
   }
@@ -8950,7 +9130,7 @@ function walkOrderBy(params) {
   const { ctx, model, orderBy, path } = params;
   const terms = Array.isArray(orderBy) ? orderBy : [orderBy];
   for (const term of terms) {
-    if (isPlainObject7(term))
+    if (isPlainObject8(term))
       walkOrderTerm({ ctx, model, term, path });
   }
 }
@@ -8977,7 +9157,7 @@ function walkCountSpec(params) {
     }
     return spec;
   }
-  if (!isPlainObject7(spec) || !isPlainObject7(spec.select))
+  if (!isPlainObject8(spec) || !isPlainObject8(spec.select))
     return spec;
   const select = { ...spec.select };
   for (const [name, flag] of Object.entries(select)) {
@@ -8987,7 +9167,7 @@ function walkCountSpec(params) {
     if (relation === undefined)
       continue;
     guard(relation);
-    if (isPlainObject7(flag) && isPlainObject7(flag.where)) {
+    if (isPlainObject8(flag) && isPlainObject8(flag.where)) {
       const target = ctx.meta.modelByName.get(relation.targetModel);
       select[name] = { ...flag, where: walkWhere({ ctx, model: target, where: flag.where, path: `${path}.${name}.where` }) };
     }
@@ -8998,7 +9178,7 @@ function walkSelection(params) {
   const { ctx, model, args, path } = params;
   for (const blockKey of ["include", "select"]) {
     const block = args[blockKey];
-    if (!isPlainObject7(block))
+    if (!isPlainObject8(block))
       continue;
     const next = { ...block };
     for (const [name, spec] of Object.entries(block)) {
@@ -9018,10 +9198,10 @@ function walkSelection(params) {
       const childPath = `${blockPath}.${name}`;
       if (spec === true && !scoped)
         continue;
-      const child = spec === true ? {} : isPlainObject7(spec) ? { ...spec } : spec;
-      if (!isPlainObject7(child))
+      const child = spec === true ? {} : isPlainObject8(spec) ? { ...spec } : spec;
+      if (!isPlainObject8(child))
         continue;
-      const walkedWhere = isPlainObject7(child.where) ? walkWhere({ ctx, model: target, where: child.where, path: `${childPath}.where` }) : child.where;
+      const walkedWhere = isPlainObject8(child.where) ? walkWhere({ ctx, model: target, where: child.where, path: `${childPath}.where` }) : child.where;
       if (scoped) {
         child.where = mergeWhere2({ where: walkedWhere, pred: requirePred({ ctx, model: target, path: childPath }) });
       } else if (walkedWhere !== undefined) {
@@ -9068,7 +9248,7 @@ function protectScopedData(params) {
   }
   for (const [name, verbs] of Object.entries(out)) {
     const relation = model.relationByName.get(name);
-    if (relation === undefined || !isPlainObject7(verbs))
+    if (relation === undefined || !isPlainObject8(verbs))
       continue;
     const target = ctx.meta.modelByName.get(relation.targetModel);
     const targetEntry = entryOf(ctx, target);
@@ -9086,7 +9266,7 @@ function mapItems(value, fn) {
 }
 function walkCreateData(params) {
   const { ctx, model, data, path } = params;
-  if (!isPlainObject7(data))
+  if (!isPlainObject8(data))
     return data;
   const entry = entryOf(ctx, model);
   const out = { ...data };
@@ -9126,7 +9306,7 @@ function walkCreateData(params) {
   }
   for (const [key, value] of Object.entries(out)) {
     const relation = model.relationByName.get(key);
-    if (relation === undefined || !isPlainObject7(value))
+    if (relation === undefined || !isPlainObject8(value))
       continue;
     out[key] = walkNestedVerbs({ ctx, model, relation, verbs: value, path: `${path}.${key}`, phase: "create" });
   }
@@ -9134,14 +9314,14 @@ function walkCreateData(params) {
 }
 function walkUpdateData(params) {
   const { ctx, model, data, path } = params;
-  if (!isPlainObject7(data))
+  if (!isPlainObject8(data))
     return data;
   const entry = entryOf(ctx, model);
   const out = { ...data };
   if (entry.kind === "column") {
     const given = out[entry.field.name];
     if (given !== undefined) {
-      const setValue = isPlainObject7(given) && Object.keys(given).length === 1 ? given.set : given;
+      const setValue = isPlainObject8(given) && Object.keys(given).length === 1 ? given.set : given;
       if (setValue !== ctx.scope) {
         throw refusal({
           model: model.name,
@@ -9166,7 +9346,7 @@ function walkUpdateData(params) {
   }
   for (const [key, value] of Object.entries(out)) {
     const relation = model.relationByName.get(key);
-    if (relation === undefined || !isPlainObject7(value))
+    if (relation === undefined || !isPlainObject8(value))
       continue;
     out[key] = walkNestedVerbs({ ctx, model, relation, verbs: value, path: `${path}.${key}`, phase: "update" });
   }
@@ -9192,7 +9372,7 @@ function walkNestedVerbs(params) {
       message: `$scoped: nested "${verb}" on ${model.name}.${relation.name} (${target.name}) ${why}`
     });
   };
-  const walkTargetWhere = (where, verbPath) => isPlainObject7(where) ? walkWhere({ ctx, model: target, where, path: verbPath }) : where;
+  const walkTargetWhere = (where, verbPath) => isPlainObject8(where) ? walkWhere({ ctx, model: target, where, path: verbPath }) : where;
   const uniqueWhere = (where, verbPath) => {
     const walked = walkTargetWhere(where, verbPath);
     return scoped ? injectUniqueWhere({ where: walked, pred: pred(verbPath) }) : walked;
@@ -9217,10 +9397,10 @@ function walkNestedVerbs(params) {
     }
     switch (verb) {
       case "connect":
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? uniqueWhere(item, verbPath) : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? uniqueWhere(item, verbPath) : item);
         break;
       case "connectOrCreate":
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? { ...item, where: uniqueWhere(item.where, verbPath), create: walkChildCreate(item.create, verbPath) } : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? { ...item, where: uniqueWhere(item.where, verbPath), create: walkChildCreate(item.create, verbPath) } : item);
         break;
       case "set": {
         if (phase === "create")
@@ -9232,7 +9412,7 @@ function walkNestedVerbs(params) {
           if (!implicitSafe)
             refuse2(verb, "first detaches EVERY current child, which cannot be tenant-filtered on this edge; disconnect explicit rows instead");
         }
-        out[verb] = mapItems(operand ?? [], (item) => isPlainObject7(item) ? uniqueWhere(item, verbPath) : item);
+        out[verb] = mapItems(operand ?? [], (item) => isPlainObject8(item) ? uniqueWhere(item, verbPath) : item);
         break;
       }
       case "disconnect": {
@@ -9249,7 +9429,7 @@ function walkNestedVerbs(params) {
           }
           break;
         }
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? uniqueWhere(item, verbPath) : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? uniqueWhere(item, verbPath) : item);
         break;
       }
       case "delete": {
@@ -9259,7 +9439,7 @@ function walkNestedVerbs(params) {
           }
           break;
         }
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? uniqueWhere(item, verbPath) : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? uniqueWhere(item, verbPath) : item);
         break;
       }
       case "update": {
@@ -9267,14 +9447,14 @@ function walkNestedVerbs(params) {
           if (scoped && !implicitSafe) {
             refuse2(verb, "targets whatever row is currently connected \u2014 not tenant-verifiable on this edge; update it through its own delegate");
           }
-          out[verb] = isPlainObject7(operand) ? "data" in operand && isPlainObject7(operand.data) ? { ...operand, data: walkChildUpdate(operand.data, verbPath) } : walkChildUpdate(operand, verbPath) : operand;
+          out[verb] = isPlainObject8(operand) ? "data" in operand && isPlainObject8(operand.data) ? { ...operand, data: walkChildUpdate(operand.data, verbPath) } : walkChildUpdate(operand, verbPath) : operand;
           break;
         }
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? { ...item, where: uniqueWhere(item.where, verbPath), data: walkChildUpdate(item.data, verbPath) } : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? { ...item, where: uniqueWhere(item.where, verbPath), data: walkChildUpdate(item.data, verbPath) } : item);
         break;
       }
       case "updateMany":
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? { ...item, where: filterWhere(item.where, verbPath), data: walkChildUpdate(item.data, verbPath) } : item);
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? { ...item, where: filterWhere(item.where, verbPath), data: walkChildUpdate(item.data, verbPath) } : item);
         break;
       case "deleteMany":
         out[verb] = mapItems(operand, (item) => filterWhere(item, verbPath));
@@ -9284,14 +9464,14 @@ function walkNestedVerbs(params) {
           if (scoped && !implicitSafe) {
             refuse2(verb, "updates whatever row is currently connected \u2014 not tenant-verifiable on this edge");
           }
-          out[verb] = isPlainObject7(operand) ? {
+          out[verb] = isPlainObject8(operand) ? {
             ...operand,
             create: walkChildCreate(operand.create, verbPath),
             update: walkChildUpdate(operand.update, verbPath)
           } : operand;
           break;
         }
-        out[verb] = mapItems(operand, (item) => isPlainObject7(item) ? {
+        out[verb] = mapItems(operand, (item) => isPlainObject8(item) ? {
           ...item,
           where: uniqueWhere(item.where, verbPath),
           create: walkChildCreate(item.create, verbPath),
@@ -9333,7 +9513,7 @@ function rewriteScopedCall(params) {
   const root = `${model.clientName}.${method}`;
   const args = { ...params.args ?? {} };
   const ownPred = () => requirePred({ ctx, model, path: root });
-  const walkOwnWhere = (where, path) => isPlainObject7(where) ? walkWhere({ ctx, model, where, path }) : where;
+  const walkOwnWhere = (where, path) => isPlainObject8(where) ? walkWhere({ ctx, model, where, path }) : where;
   if (FIND_LIKE.includes(method)) {
     const walked = walkOwnWhere(args.where, `${root}.where`);
     if (scoped)
@@ -9355,8 +9535,8 @@ function rewriteScopedCall(params) {
           args.where = walked2;
         return { model: model.name, method, args };
       }
-      const flat = isPlainObject7(args.where) ? flattenUniqueWhere({ model, where: args.where }) : args.where;
-      const walked = isPlainObject7(flat) ? walkWhere({ ctx, model, where: flat, path: `${root}.where` }) : flat;
+      const flat = isPlainObject8(args.where) ? flattenUniqueWhere({ model, where: args.where }) : args.where;
+      const walked = isPlainObject8(flat) ? walkWhere({ ctx, model, where: flat, path: `${root}.where` }) : flat;
       args.where = mergeWhere2({ where: walked, pred: ownPred() });
       return {
         model: model.name,
@@ -9483,14 +9663,14 @@ function scopeExtensionProps2(params) {
       out[key] = (args) => {
         try {
           const path = `${model.clientName}.${key}`;
-          const walked = isPlainObject7(args?.where) ? walkWhere({ ctx, model, where: args.where, path: `${path}.where` }) : args?.where;
+          const walked = isPlainObject8(args?.where) ? walkWhere({ ctx, model, where: args.where, path: `${path}.where` }) : args?.where;
           const where = entry.kind === "none" ? walked : mergeWhere2({ where: walked, pred: requirePred({ ctx, model, path }) });
           return prop({ ...args ?? {}, ...where === undefined ? {} : { where } });
         } catch (error) {
           return Promise.reject(error);
         }
       };
-    } else if (isPlainObject7(prop)) {
+    } else if (isPlainObject8(prop)) {
       out[key] = scopeExtensionProps2({
         ctx,
         model,
@@ -9552,8 +9732,8 @@ function attachScoped(params) {
   const { client, meta } = params;
   Object.defineProperty(client, "$scoped", {
     value: (config) => {
-      if (!isPlainObject7(config) || !isPlainObject7(config.models)) {
-        throw new VibeError18({
+      if (!isPlainObject8(config) || !isPlainObject8(config.models)) {
+        throw new VibeError19({
           code: "VIBE_VALIDATION",
           message: "$scoped takes { scope: string | number | bigint | null, models: { <Model>: \u2026 } }"
         });
@@ -9569,7 +9749,7 @@ function attachScoped(params) {
       }
       const scope = config.scope;
       if (scope !== null && typeof scope !== "string" && typeof scope !== "number" && typeof scope !== "bigint") {
-        throw new VibeError18({
+        throw new VibeError19({
           code: "VIBE_VALIDATION",
           message: `$scoped: scope must be a string, number, bigint or null \u2014 got ${typeof scope}`
         });
@@ -9585,7 +9765,7 @@ function attachScoped(params) {
   });
 }
 // packages/runtime/src/rls-readiness.ts
-import { VibeError as VibeError19, assertValidSchemaIR, unsupportedCapability as unsupportedCapability5 } from "@vibeorm/schema";
+import { VibeError as VibeError20, assertValidSchemaIR, unsupportedCapability as unsupportedCapability6 } 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) {
@@ -9636,10 +9816,10 @@ function unprotectedTablesOf(params) {
 function requireNativeRls(params) {
   const dialect = getSqlDialect4({ dialect: params.adapter.dialect });
   if (!dialect.capabilities.nativeRowLevelSecurity) {
-    throw unsupportedCapability5({ dialect: dialect.name, feature: "nativeRowLevelSecurity" });
+    throw unsupportedCapability6({ dialect: dialect.name, feature: "nativeRowLevelSecurity" });
   }
   if (params.schema.rls === undefined) {
-    throw new VibeError19({
+    throw new VibeError20({
       code: "VIBE_CONFIG",
       message: "Native row-level security readiness requires a schema that declares native RLS"
     });
@@ -10051,7 +10231,7 @@ async function inspectNativeRls(params) {
 function requireEmbeddedRole(params) {
   const { role } = params;
   if (typeof role !== "string" || role.length === 0 || role.includes("\x00")) {
-    throw new VibeError19({
+    throw new VibeError20({
       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" }
@@ -10063,7 +10243,7 @@ function assertNativeRlsReady(params) {
   const { report } = params;
   if (report.ready)
     return;
-  throw new VibeError19({
+  throw new VibeError20({
     code: "VIBE_CONFIG",
     message: `Native row-level security is not ready on this database: ${report.problems.map((problem) => `${problem.name} (${problem.status})`).join(", ")}`,
     meta: {
@@ -10088,7 +10268,7 @@ function formatNativeRlsReport(params) {
   return lines;
 }
 // packages/runtime/src/client.ts
-import { RlsContextError as RlsContextError2, VibeError as VibeError23, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
+import { RlsContextError as RlsContextError2, VibeError as VibeError24, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
 import { ParamCollector, getSqlDialect as getSqlDialect5, renderRlsContext, renderRlsPolicy as renderRlsPolicy2, renderRlsRole as renderRlsRole2 } from "@vibeorm/sql";
 
 // packages/runtime/src/render-cache.ts
@@ -10105,12 +10285,25 @@ var MAX_ENTRIES = 512;
 
 class StatementRenderCache {
   entries = new Map;
+  get size() {
+    return this.entries.size;
+  }
   get(key) {
-    return this.entries.get(key);
+    const slot = this.entries.get(key);
+    if (slot === undefined)
+      return;
+    this.entries.delete(key);
+    this.entries.set(key, slot);
+    return slot;
   }
   set(key, slot) {
-    if (this.entries.size >= MAX_ENTRIES && !this.entries.has(key))
-      this.entries.clear();
+    if (this.entries.has(key)) {
+      this.entries.delete(key);
+    } else if (this.entries.size >= MAX_ENTRIES) {
+      const oldest = this.entries.keys().next();
+      if (!oldest.done)
+        this.entries.delete(oldest.value);
+    }
     this.entries.set(key, slot);
   }
 }
@@ -10384,7 +10577,8 @@ function walkSelect(walk2, dialect, statement) {
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     for (const join of statement.lateralJoins) {
-      walk2.key += join.agg === "jsonArray" ? "Ja(" : "Jo(";
+      walk2.key += join.agg === "count" ? "Jc(" : join.agg === "jsonArray" ? "Ja(" : "Jo(";
+      walk2.key += join.rowFormat === "positional" ? "pos;" : "obj;";
       if (!walkSelect(walk2, dialect, join.select))
         return false;
       addIdent(walk2, join.columnAlias);
@@ -10579,17 +10773,17 @@ function renderStatementCached(params) {
 }
 
 // packages/runtime/src/strict-args.ts
-import { VibeError as VibeError20 } from "@vibeorm/schema";
+import { VibeError as VibeError21 } from "@vibeorm/schema";
 var SKIP = Symbol.for("vibeorm.skip");
 function explicitUndefined(params) {
   const { model, method, path } = params;
-  return new VibeError20({
+  return new VibeError21({
     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 }
   });
 }
-function isPlainObject8(value) {
+function isPlainObject9(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
   const proto = Object.getPrototypeOf(value);
@@ -10621,7 +10815,7 @@ function walkNode(params) {
   const filter = params.filter === true;
   if (Array.isArray(value))
     return walkArray({ ctx, model, value, path, filter });
-  if (!isPlainObject8(value))
+  if (!isPlainObject9(value))
     return value;
   let out = null;
   for (const key of Object.keys(value)) {
@@ -10637,7 +10831,7 @@ function walkNode(params) {
     }
     const target = descend({ ctx, model, key });
     if (target === "json") {
-      if (filter && isPlainObject8(child)) {
+      if (filter && isPlainObject9(child)) {
         let filtered = null;
         for (const operator of Object.keys(child)) {
           if (child[operator] === undefined) {
@@ -10760,10 +10954,10 @@ function bindRlsContext(params) {
 }
 
 // packages/runtime/src/telemetry/recorder.ts
-import { VibeError as VibeError22 } from "@vibeorm/schema";
+import { VibeError as VibeError23 } from "@vibeorm/schema";
 
 // packages/runtime/src/telemetry/config.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { VibeError as VibeError22 } from "@vibeorm/schema";
 var TELEMETRY_DEFAULTS = Object.freeze({
   captureSql: false,
   captureParameterValues: false,
@@ -10778,7 +10972,7 @@ var TELEMETRY_DEFAULTS = Object.freeze({
   latencyBucketsMs: Object.freeze([1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000])
 });
 function configError(params) {
-  return new VibeError21({
+  return new VibeError22({
     code: "VIBE_CONFIG",
     message: `telemetry: ${params.message}`,
     ...params.meta === undefined ? {} : { meta: params.meta }
@@ -10866,7 +11060,7 @@ function deriveStage(params) {
   return "decode";
 }
 function errorCodeOf(error) {
-  return error instanceof VibeError22 ? error.code : undefined;
+  return error instanceof VibeError23 ? error.code : undefined;
 }
 function newHistogram(bounds) {
   return { counts: new Array(bounds.length + 1).fill(0), sum: 0, count: 0 };
@@ -11240,7 +11434,7 @@ async function instrumentStatement(params) {
 // packages/runtime/src/client.ts
 function notFound2(params) {
   const { model, method } = params;
-  return new VibeError23({
+  return new VibeError24({
     code: "VIBE_NOT_FOUND",
     message: `no ${model} record matched the where clause of ${method}()`,
     meta: { model, method }
@@ -11248,7 +11442,7 @@ function notFound2(params) {
 }
 function viewIsReadOnly(params) {
   const { model, method } = params;
-  return new VibeError23({
+  return new VibeError24({
     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 }
@@ -11354,7 +11548,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 VibeError23({
+      throw new VibeError24({
         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" }
@@ -11521,7 +11715,7 @@ class QueryPromise extends Promise {
   }
   claim() {
     if (this.started) {
-      throw new VibeError23({
+      throw new VibeError24({
         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)"
       });
@@ -11622,7 +11816,7 @@ async function runAffected(params) {
 function plan(params) {
   const { engine, model, method, args } = params;
   if (args !== undefined && args["lock"] !== undefined && engine.inTransaction !== true) {
-    throw new VibeError23({
+    throw new VibeError24({
       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 }
@@ -11677,7 +11871,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 unsupportedCapability6({
+    throw unsupportedCapability7({
       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"
@@ -11695,7 +11889,7 @@ async function insertedKeyWhere(params) {
   });
   const id = result.rows[0]?.id;
   if (id === undefined || id === null) {
-    throw new VibeError23({
+    throw new VibeError24({
       code: "VIBE_INTERNAL",
       message: `could not read back the generated key for ${source.model.name}`,
       meta: { model: source.model.name }
@@ -12012,7 +12206,7 @@ function createDelegate(params) {
     const skipping = args.onConflict !== undefined;
     if (hasNestedWrites({ model: modelMeta, data: args.data })) {
       if (skipping) {
-        throw new VibeError23({
+        throw new VibeError24({
           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 }
@@ -12113,7 +12307,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 VibeError23({
+      throw new VibeError24({
         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 }
@@ -12121,7 +12315,7 @@ function createDelegate(params) {
     }
     if (!upsertUsesNativeStatement({ model: modelMeta, args })) {
       if (args.onConflict !== undefined) {
-        throw new VibeError23({
+        throw new VibeError24({
           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 }
@@ -12363,7 +12557,7 @@ function buildClient(params) {
     }
     for (const operation of operations) {
       if (!(operation instanceof QueryPromise)) {
-        claimError = new VibeError23({
+        claimError = new VibeError24({
           code: "VIBE_VALIDATION",
           message: "$transaction([...]) takes query promises from model delegate calls \u2014 a foreign promise is already running and cannot join the transaction"
         });
@@ -12428,7 +12622,7 @@ function buildClient(params) {
     $models: models,
     $on: (event, listener) => {
       if (event !== "query") {
-        throw new VibeError23({
+        throw new VibeError24({
           code: "VIBE_VALIDATION",
           message: `unknown client event "${String(event)}" \u2014 supported: "query"`,
           meta: { event }
@@ -12494,7 +12688,7 @@ function buildClient(params) {
     attachPolicy({ client, meta: engine.meta, ...wrapDelegate === undefined ? {} : { wrapDelegate } });
   } else {
     const refuseLegacy = () => {
-      throw new VibeError23({ code: "VIBE_CONFIG", message: "Native row-level security cannot be combined with application policy or tenant scoping" });
+      throw new VibeError24({ 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) => {
@@ -12556,7 +12750,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 VibeError23({
+        throw new VibeError24({
           code: "VIBE_INTERNAL",
           message: `extension "${extension}" compiled a where with no model in scope`,
           meta: { extension }
@@ -12585,24 +12779,24 @@ function createMountSurface(params) {
         for (const key of path) {
           receiver = current;
           if (current === null || typeof current !== "object" && typeof current !== "function")
-            throw new VibeError23({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+            throw new VibeError24({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
           current = Reflect.get(current, key);
         }
         if (typeof current !== "function")
-          throw new VibeError23({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+          throw new VibeError24({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
         return 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 VibeError23({ code: "VIBE_CONFIG", message: "Native RLS extension mounts must expose plain objects and methods" });
+      throw new VibeError24({ 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 VibeError23({ code: "VIBE_CONFIG", message: "Native RLS extension mount accessors are unsupported" });
+        throw new VibeError24({ 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);
@@ -12619,7 +12813,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 VibeError23({
+        throw new VibeError24({
           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 }
@@ -12630,7 +12824,7 @@ function attachExtensionMounts(params) {
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
-      throw new VibeError23({
+      throw new VibeError24({
         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 }
@@ -12647,7 +12841,7 @@ function createClient(params) {
   if (schema.rls !== undefined) {
     const dialect = getSqlDialect5({ dialect: dialectName });
     if (!dialect.capabilities.nativeRowLevelSecurity)
-      throw unsupportedCapability6({ dialect: dialectName, feature: "nativeRowLevelSecurity" });
+      throw unsupportedCapability7({ dialect: dialectName, feature: "nativeRowLevelSecurity" });
     assertValidSchemaIR2({ schema });
     for (const model of schema.models) {
       if (model.rls !== "unprotected")
@@ -12656,9 +12850,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 VibeError23({ 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 VibeError24({ 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 VibeError23({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
+      throw new VibeError24({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
     }
   }
   if (extensions?.manifest !== undefined) {
@@ -12668,7 +12862,7 @@ function createClient(params) {
     assertComputedManifest({ manifest: computed.manifest, specs: computed.specs });
   }
   if (computed === undefined && options !== undefined && options["computed"] !== undefined) {
-    throw new VibeError23({
+    throw new VibeError24({
       code: "VIBE_CONFIG",
       message: "this client was generated without computed fields \u2014 declare them in vibeorm.config.ts and re-run vibeorm generate",
       meta: {}
@@ -12699,9 +12893,9 @@ function createClient(params) {
   });
 }
 // packages/runtime/src/keyset-iterator.ts
-import { VibeError as VibeError24 } from "@vibeorm/schema";
+import { VibeError as VibeError25 } from "@vibeorm/schema";
 function validation(params) {
-  return new VibeError24({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError25({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function projectionFor(params) {
   const { plan: plan2, select, omit } = params;
@@ -12778,7 +12972,7 @@ function iterateKeyset(options) {
       });
       if (advanced === false) {
         stop();
-        throw new VibeError24({
+        throw new VibeError25({
           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: plan2.signature, reason: "keyset-position-not-advancing" }
@@ -12851,7 +13045,7 @@ function iterateKeyset(options) {
   return iterator;
 }
 // packages/runtime/src/telemetry/collector.ts
-import { VibeError as VibeError25 } from "@vibeorm/schema";
+import { VibeError as VibeError26 } from "@vibeorm/schema";
 function createTelemetryCollector(params) {
   const throwOn = new Set(params?.throwOn ?? []);
   const operations = [];
@@ -12861,7 +13055,7 @@ function createTelemetryCollector(params) {
   let shutdowns = 0;
   const hostile = (phase) => {
     if (throwOn.has(phase)) {
-      throw new VibeError25({
+      throw new VibeError26({
         code: "VIBE_INTERNAL",
         message: `telemetry collector: deliberate ${phase} failure`,
         meta: { reason: "telemetry-collector-deliberate-failure", phase }
@@ -12917,7 +13111,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 VibeError25({
+        throw new VibeError26({
           code: "VIBE_VALIDATION",
           message: `telemetry collector: ${matches.length} operations match ${lookup.model ?? "*"}.${lookup.method}`,
           meta: {
@@ -13021,4 +13215,4 @@ export {
   COUNT_ALIAS
 };
 
-//# debugId=08CBEBB868708E5A64756E2164756E21
+//# debugId=ADD0DD01D02385B864756E2164756E21