@vibeorm/runtime 2.1.0 → 2.2.0

package/dist/index.js

@@ -1649,6 +1649,11 @@ function singleKeyPair(params) {
   }
   return { parent: link.parentKeys[0], child: link.childKeys[0] };
 }
+function inverseRelationName(params) {
+  const { link } = params;
+  const reverse = findReverseRelation({ relation: link.relation, target: link.target });
+  return reverse === null ? null : reverse.name;
+}
 function singlePrimaryKey(params) {
   const { model, relation } = params;
   const pk = model.primaryKey;
@@ -3294,21 +3299,27 @@ function expandCompoundWhere(params) {
 function isAddressableMember(params) {
   return isDirectValue(params.value) || params.nullsNotDistinct && params.value === null;
 }
-function assertUniqueWhere(params) {
-  const { model, where, method } = params;
+function isUniqueWhere(params) {
+  const { model, where } = params;
   for (const field of model.uniqueFields) {
     if (isDirectValue(where[field.name]))
-      return;
+      return true;
   }
   for (const single of model.singleIndexUniques) {
     const field = single.fields[0];
     if (isAddressableMember({ value: where[field.name], nullsNotDistinct: single.nullsNotDistinct }))
-      return;
+      return true;
   }
   for (const group of model.compoundUniques.values()) {
     if (group.fields.every((field) => isAddressableMember({ value: where[field.name], nullsNotDistinct: group.nullsNotDistinct })))
-      return;
+      return true;
   }
+  return false;
+}
+function assertUniqueWhere(params) {
+  const { model, where, method } = params;
+  if (isUniqueWhere({ model, where }))
+    return;
   const candidates = [
     ...model.uniqueFields.map((field) => field.name),
     ...model.singleIndexUniques.map((single) => single.fields[0].name),
@@ -5586,21 +5597,41 @@ function joinValues(params) {
   const childValue = encodeValue({ dialect: dialect.name, field: pair.child, value: childKey });
   return join.parentColumn === "A" ? { a: parentValue, b: childValue } : { a: childValue, b: parentValue };
 }
-async function insertJoinRow(params) {
-  const { run, dialect, link, parentKey, childKey } = params;
+function chunkKeyList(params) {
+  const { dialect, keys, perKey, reserved } = params;
+  if (keys.length === 0)
+    return [];
+  if (dialect.inArrayStrategy !== "expand")
+    return [keys];
+  const size = Math.max(1, Math.floor((dialect.paramBudget - reserved) / perKey));
+  const chunks = [];
+  for (let start = 0;start < keys.length; start += size)
+    chunks.push(keys.slice(start, start + size));
+  return chunks;
+}
+async function insertJoinRows(params) {
+  const { run, dialect, link, parentKey, childKeys } = params;
+  if (childKeys.length === 0)
+    return;
   const join = link.join;
-  const { a, b } = joinValues({ dialect, link, parentKey, childKey });
-  await run.statement({
-    statement: {
-      kind: "insert",
-      table: { name: join.tableName },
-      columns: ["A", "B"],
-      rows: [[a, b]],
-      onConflict: { columns: ["A", "B"], doNothing: true }
-    },
-    model: link.relation.model,
-    method: "nested.connect"
+  const rows = childKeys.map((childKey) => {
+    const { a, b } = joinValues({ dialect, link, parentKey, childKey });
+    return [a, b];
   });
+  const perChunk = Math.max(1, Math.floor(dialect.paramBudget / 2));
+  for (let start = 0;start < rows.length; start += perChunk) {
+    await run.statement({
+      statement: {
+        kind: "insert",
+        table: { name: join.tableName },
+        columns: ["A", "B"],
+        rows: rows.slice(start, start + perChunk),
+        onConflict: { columns: ["A", "B"], doNothing: true }
+      },
+      model: link.relation.model,
+      method: "nested.connect"
+    });
+  }
 }
 async function deleteJoinRows(params) {
   const { run, dialect, link, parentKey, childKeys } = params;
@@ -5629,42 +5660,58 @@ async function deleteJoinRows(params) {
     method: "nested.disconnect"
   });
 }
-async function assertM2MMember(params) {
-  const { run, ctx, link, parentKey, childKey, target, verb, relation } = params;
-  const members = await loadMemberKeys({ run, ctx, link, parentKey });
-  const pair = singleKeyPair({ link, what: "implicit many-to-many writes" });
-  const childValue = encodeValue({ dialect: ctx.dialect.name, field: pair.child, value: childKey });
-  if (members.some((member) => String(member) === String(childValue)))
+async function assertM2MMembers(params) {
+  const { run, ctx, link, parentKey, childKeys, target, verb, relation } = params;
+  if (childKeys.length === 0)
     return;
-  throw notFound({
-    message: `nested "${verb}" on ${link.relation.model}.${relation}: ${target} is not connected`,
-    meta: { relation }
-  });
+  const members = await loadMemberKeys({ run, ctx, link, parentKey, childKeys });
+  const pair = singleKeyPair({ link, what: "implicit many-to-many writes" });
+  const connected = new Set(members.map((member) => String(member)));
+  for (const childKey of childKeys) {
+    const childValue = encodeValue({ dialect: ctx.dialect.name, field: pair.child, value: childKey });
+    if (connected.has(String(childValue)))
+      continue;
+    throw notFound({
+      message: `nested "${verb}" on ${link.relation.model}.${relation}: ${target} is not connected`,
+      meta: { relation }
+    });
+  }
 }
-async function deleteJoinRowsForChild(params) {
-  const { run, dialect, link, childKey } = params;
+async function deleteJoinRowsForChildren(params) {
+  const { run, dialect, link, childKeys } = params;
+  if (childKeys.length === 0)
+    return;
   const join = link.join;
-  const value = encodeValue({
-    dialect: dialect.name,
-    field: singleKeyPair({ link, what: "implicit many-to-many writes" }).child,
-    value: childKey
-  });
+  const pair = singleKeyPair({ link, what: "implicit many-to-many writes" });
+  const values = childKeys.map((childKey) => encodeValue({ dialect: dialect.name, field: pair.child, value: childKey }));
   const isSelf = link.relation.model === link.relation.targetModel;
-  await run.statement({
-    statement: {
-      kind: "delete",
-      table: { name: join.tableName },
-      where: isSelf ? {
-        kind: "or",
-        operands: [
-          { kind: "cmp", op: "eq", column: { name: "A" }, value },
-          { kind: "cmp", op: "eq", column: { name: "B" }, value }
-        ]
-      } : { kind: "cmp", op: "eq", column: { name: join.childColumn }, value }
-    },
-    model: link.relation.model,
-    method: "nested.delete"
-  });
+  for (const chunk of chunkKeyList({ dialect, keys: values, perKey: isSelf ? 2 : 1, reserved: 0 })) {
+    await run.statement({
+      statement: {
+        kind: "delete",
+        table: { name: join.tableName },
+        where: isSelf ? {
+          kind: "or",
+          operands: [
+            { kind: "inArray", column: { name: "A" }, values: [...chunk] },
+            { kind: "inArray", column: { name: "B" }, values: [...chunk] }
+          ]
+        } : { kind: "inArray", column: { name: join.childColumn }, values: [...chunk] }
+      },
+      model: link.relation.model,
+      method: "nested.delete"
+    });
+  }
+}
+async function deleteChildrenByKey(params) {
+  const { run, dialect, link, childKeys } = params;
+  for (const chunk of chunkKeyList({ dialect, keys: childKeys, perKey: 1, reserved: 0 })) {
+    await run.affected({
+      model: link.target.name,
+      method: "deleteMany",
+      args: { where: childAssignment({ link, values: [{ in: [...chunk] }] }) }
+    });
+  }
 }
 function singleVerb(params) {
   const { op } = params;
@@ -5703,6 +5750,48 @@ async function resolveOwnerCreateVerb(params) {
     }
   }
 }
+function isFilterableUniqueWhere(params) {
+  const { target, where } = params;
+  const entries = Object.entries(where).filter(([, value]) => value !== undefined);
+  if (entries.length === 0)
+    return false;
+  if (!entries.every(([key, value]) => target.fieldByName.has(key) && isDirectValue2(value)))
+    return false;
+  return isUniqueWhere({ model: target, where });
+}
+async function connectChildrenByFk(params) {
+  const { run, op, items, fk, verb } = params;
+  const target = op.link.target;
+  if (items.length === 0)
+    return;
+  const batchable = items.length > 1 && items.every((item) => isFilterableUniqueWhere({ target, where: item }));
+  if (!batchable) {
+    for (const item of items) {
+      await run.single({ model: target.name, method: "update", args: { where: item, data: fk } });
+    }
+    return;
+  }
+  const affected = await run.affected({
+    model: target.name,
+    method: "updateMany",
+    args: { where: { OR: items.map((item) => ({ ...item })) }, data: fk }
+  });
+  if (affected >= items.length)
+    return;
+  for (const item of items) {
+    const found = await run.rows({
+      model: target.name,
+      method: "findUnique",
+      args: { where: item, select: childKeySelect({ link: op.link }) }
+    });
+    if (found[0] !== undefined)
+      continue;
+    throw notFound({
+      message: `no ${target.name} record matched the where clause of update()`,
+      meta: { model: target.name, method: "update", relation: op.name, verb }
+    });
+  }
+}
 function sameDefinedKeys(rows) {
   const first = rows[0];
   if (first === undefined)
@@ -5731,14 +5820,14 @@ async function applyChildCreateOps(params) {
         continue;
       }
     }
-    for (const item of items) {
-      if (link.kind === "manyToMany") {
-        let childKey;
+    if (link.kind === "manyToMany") {
+      const childKeys = [];
+      for (const item of items) {
         if (verb === "connect") {
-          childKey = (await resolveTargetKeys({ run, link, where: item, what: `connect ${op.name}` }))[0];
+          childKeys.push((await resolveTargetKeys({ run, link, where: item, what: `connect ${op.name}` }))[0]);
         } else if (verb === "create") {
           const child = await runCreate({ ctx, run, model: target, data: item });
-          childKey = childTupleOf({ link, row: child })[0];
+          childKeys.push(childTupleOf({ link, row: child })[0]);
         } else {
           requireShape({ op, verb, item, keys: ["where", "create"] });
           const found = await run.rows({
@@ -5746,18 +5835,22 @@ async function applyChildCreateOps(params) {
             method: "findUnique",
             args: { where: item.where, select: childKeySelect({ link }) }
           });
-          childKey = found[0] !== undefined ? childTupleOf({ link, row: found[0] })[0] : childTupleOf({
+          childKeys.push(found[0] !== undefined ? childTupleOf({ link, row: found[0] })[0] : childTupleOf({
             link,
             row: await runCreate({ ctx, run, model: target, data: item.create })
-          })[0];
+          })[0]);
         }
-        await insertJoinRow({ run, dialect: ctx.dialect, link, parentKey, childKey });
-        continue;
       }
+      await insertJoinRows({ run, dialect: ctx.dialect, link, parentKey, childKeys });
+      continue;
+    }
+    if (verb === "connect") {
+      await connectChildrenByFk({ run, op, items, fk, verb });
+      continue;
+    }
+    for (const item of items) {
       if (verb === "create") {
         await runCreate({ ctx, run, model: target, data: { ...item, ...fk } });
-      } else if (verb === "connect") {
-        await run.single({ model: target.name, method: "update", args: { where: item, data: fk } });
       } else {
         requireShape({ op, verb, item, keys: ["where", "create"] });
         const found = await run.rows({
@@ -5956,28 +6049,52 @@ async function resolveOwnerUpdateVerb(params) {
   }
 }
 async function loadMemberKeys(params) {
-  const { run, ctx, link, parentKey } = params;
+  const { run, ctx, link, parentKey, childKeys } = params;
   const join = link.join;
-  const rows = await run.statement({
-    statement: {
-      kind: "select",
-      table: { name: join.tableName },
-      columns: [{ name: join.childColumn }],
-      where: {
-        kind: "cmp",
-        op: "eq",
-        column: { name: join.parentColumn },
-        value: encodeValue({
-          dialect: ctx.dialect.name,
-          field: singleKeyPair({ link, what: "implicit many-to-many writes" }).parent,
-          value: parentKey
-        })
-      }
-    },
-    model: link.relation.model,
-    method: "nested.members"
-  });
-  return rows.map((row) => row[join.childColumn]);
+  const pair = singleKeyPair({ link, what: "implicit many-to-many writes" });
+  const parentMatch = {
+    kind: "cmp",
+    op: "eq",
+    column: { name: join.parentColumn },
+    value: encodeValue({ dialect: ctx.dialect.name, field: pair.parent, value: parentKey })
+  };
+  const scan = async (narrow) => {
+    const rows = await run.statement({
+      statement: {
+        kind: "select",
+        table: { name: join.tableName },
+        columns: [{ name: join.childColumn }],
+        where: narrow === null ? parentMatch : {
+          kind: "and",
+          operands: [
+            parentMatch,
+            { kind: "inArray", column: { name: join.childColumn }, values: [...narrow] }
+          ]
+        }
+      },
+      model: link.relation.model,
+      method: "nested.members"
+    });
+    return rows.map((row) => row[join.childColumn]);
+  };
+  if (childKeys === undefined)
+    return await scan(null);
+  const values = childKeys.map((childKey) => encodeValue({ dialect: ctx.dialect.name, field: pair.child, value: childKey }));
+  const found = [];
+  for (const chunk of chunkKeyList({ dialect: ctx.dialect, keys: values, perKey: 1, reserved: 1 })) {
+    found.push(...await scan(chunk));
+  }
+  return found;
+}
+async function membershipFilter(params) {
+  const { run, ctx, link, parentKey } = params;
+  const inverse = inverseRelationName({ link });
+  if (inverse !== null) {
+    const pair = singleKeyPair({ link, what: "implicit many-to-many writes" });
+    return { [inverse]: { some: { [pair.parent.name]: parentKey } } };
+  }
+  const members = await loadMemberKeys({ run, ctx, link, parentKey });
+  return childAssignment({ link, values: [{ in: members }] });
 }
 async function applyChildUpdateOps(params) {
   const { ctx, run, op, parentValues } = params;
@@ -5999,10 +6116,11 @@ async function applyChildUpdateOps(params) {
         const items = toItems({ op, verb, operand: operand ?? [] });
         if (isM2M) {
           await deleteJoinRows({ run, dialect: ctx.dialect, link, parentKey });
+          const childKeys = [];
           for (const item of items) {
-            const childKey = (await resolveTargetKeys({ run, link, where: item, what: `set ${op.name}` }))[0];
-            await insertJoinRow({ run, dialect: ctx.dialect, link, parentKey, childKey });
+            childKeys.push((await resolveTargetKeys({ run, link, where: item, what: `set ${op.name}` }))[0]);
           }
+          await insertJoinRows({ run, dialect: ctx.dialect, link, parentKey, childKeys });
         } else {
           const detach = childDetach({ op, verb });
           await run.affected({
@@ -6010,9 +6128,7 @@ async function applyChildUpdateOps(params) {
             method: "updateMany",
             args: { where: fk, data: detach }
           });
-          for (const item of items) {
-            await run.single({ model: target.name, method: "update", args: { where: item, data: fk } });
-          }
+          await connectChildrenByFk({ run, op, items, fk, verb });
         }
         break;
       }
@@ -6054,23 +6170,31 @@ async function applyChildUpdateOps(params) {
           break;
         }
         const items = toItems({ op, verb, operand });
-        for (const item of items) {
-          if (isM2M) {
-            const childKey = (await resolveTargetKeys({ run, link, where: item, what: `delete ${op.name}` }))[0];
-            await assertM2MMember({ run, ctx, link, parentKey, childKey, target: target.name, verb: "delete", relation: op.name });
-            await deleteJoinRowsForChild({ run, dialect: ctx.dialect, link, childKey });
-            await run.single({
-              model: target.name,
-              method: "delete",
-              args: { where: childAssignment({ link, values: [childKey] }) }
-            });
-          } else {
-            await run.affected({
-              model: target.name,
-              method: "deleteMany",
-              args: { where: { AND: [item, fk] } }
-            });
+        if (isM2M) {
+          const childKeys = [];
+          for (const item of items) {
+            childKeys.push((await resolveTargetKeys({ run, link, where: item, what: `delete ${op.name}` }))[0]);
           }
+          await assertM2MMembers({
+            run,
+            ctx,
+            link,
+            parentKey,
+            childKeys,
+            target: target.name,
+            verb: "delete",
+            relation: op.name
+          });
+          await deleteJoinRowsForChildren({ run, dialect: ctx.dialect, link, childKeys });
+          await deleteChildrenByKey({ run, dialect: ctx.dialect, link, childKeys });
+          break;
+        }
+        for (const item of items) {
+          await run.affected({
+            model: target.name,
+            method: "deleteMany",
+            args: { where: { AND: [item, fk] } }
+          });
         }
         break;
       }
@@ -6096,41 +6220,44 @@ async function applyChildUpdateOps(params) {
           break;
         }
         const items = toItems({ op, verb, operand });
-        for (const item of items) {
+        for (const item of items)
           requireShape({ op, verb, item, keys: ["where", "data"] });
-          if (isM2M) {
-            const childKey = (await resolveTargetKeys({
+        if (isM2M) {
+          const childKeys = [];
+          for (const item of items) {
+            childKeys.push((await resolveTargetKeys({
               run,
               link,
               where: item.where,
               what: `update ${op.name}`
-            }))[0];
-            const members = await loadMemberKeys({ run, ctx, link, parentKey });
-            const childValue = encodeValue({
-              dialect: ctx.dialect.name,
-              field: singleKeyPair({ link, what: "implicit many-to-many writes" }).child,
-              value: childKey
-            });
-            const isMember = members.some((member) => String(member) === String(childValue));
-            if (!isMember) {
-              throw notFound({
-                message: `nested "update" on ${link.relation.model}.${op.name}: ${target.name} is not connected`,
-                meta: { relation: op.name }
-              });
-            }
+            }))[0]);
+          }
+          await assertM2MMembers({
+            run,
+            ctx,
+            link,
+            parentKey,
+            childKeys,
+            target: target.name,
+            verb: "update",
+            relation: op.name
+          });
+          for (const item of items) {
             await run.single({ model: target.name, method: "update", args: { where: item.where, data: item.data } });
-          } else {
-            const affected = await run.affected({
-              model: target.name,
-              method: "updateMany",
-              args: { where: { AND: [item.where, fk] }, data: item.data }
+          }
+          break;
+        }
+        for (const item of items) {
+          const affected = await run.affected({
+            model: target.name,
+            method: "updateMany",
+            args: { where: { AND: [item.where, fk] }, data: item.data }
+          });
+          if (affected === 0) {
+            throw notFound({
+              message: `nested "update" on ${link.relation.model}.${op.name}: no connected ${target.name} matched`,
+              meta: { relation: op.name }
             });
-            if (affected === 0) {
-              throw notFound({
-                message: `nested "update" on ${link.relation.model}.${op.name}: no connected ${target.name} matched`,
-                meta: { relation: op.name }
-              });
-            }
           }
         }
         break;
@@ -6146,12 +6273,11 @@ async function applyChildUpdateOps(params) {
             });
           }
           if (isM2M) {
-            const members = await loadMemberKeys({ run, ctx, link, parentKey });
             await run.affected({
               model: target.name,
               method: "updateMany",
               args: {
-                where: { AND: [item.where ?? {}, childAssignment({ link, values: [{ in: members }] })] },
+                where: { AND: [item.where ?? {}, await membershipFilter({ run, ctx, link, parentKey })] },
                 data
               }
             });
@@ -6169,35 +6295,17 @@ async function applyChildUpdateOps(params) {
         const items = toItems({ op, verb, operand });
         for (const item of items) {
           if (isM2M) {
-            const members = await loadMemberKeys({ run, ctx, link, parentKey });
             const victims = await run.rows({
               model: target.name,
               method: "findMany",
               args: {
-                where: { AND: [item, childAssignment({ link, values: [{ in: members }] })] },
+                where: { AND: [item, await membershipFilter({ run, ctx, link, parentKey })] },
                 select: childKeySelect({ link })
               }
             });
-            for (const victim of victims) {
-              await deleteJoinRowsForChild({
-                run,
-                dialect: ctx.dialect,
-                link,
-                childKey: childTupleOf({ link, row: victim })[0]
-              });
-            }
-            if (victims.length > 0) {
-              await run.affected({
-                model: target.name,
-                method: "deleteMany",
-                args: {
-                  where: childAssignment({
-                    link,
-                    values: [{ in: victims.map((victim) => childTupleOf({ link, row: victim })[0]) }]
-                  })
-                }
-              });
-            }
+            const childKeys = victims.map((victim) => childTupleOf({ link, row: victim })[0]);
+            await deleteJoinRowsForChildren({ run, dialect: ctx.dialect, link, childKeys });
+            await deleteChildrenByKey({ run, dialect: ctx.dialect, link, childKeys });
           } else {
             await run.affected({
               model: target.name,
@@ -6251,12 +6359,12 @@ async function applyChildUpdateOps(params) {
           });
           if (found[0] !== undefined) {
             if (isM2M) {
-              await assertM2MMember({
+              await assertM2MMembers({
                 run,
                 ctx,
                 link,
                 parentKey,
-                childKey: childTupleOf({ link, row: found[0] })[0],
+                childKeys: [childTupleOf({ link, row: found[0] })[0]],
                 target: target.name,
                 verb: "upsert",
                 relation: op.name
@@ -6270,12 +6378,12 @@ async function applyChildUpdateOps(params) {
             await run.single({ model: target.name, method: "update", args: { where: item.where, data: item.update } });
           } else if (isM2M) {
             const child = await runCreate({ ctx, run, model: target, data: item.create });
-            await insertJoinRow({
+            await insertJoinRows({
               run,
               dialect: ctx.dialect,
               link,
               parentKey,
-              childKey: childTupleOf({ link, row: child })[0]
+              childKeys: [childTupleOf({ link, row: child })[0]]
             });
           } else {
             await runCreate({
@@ -6294,20 +6402,23 @@ async function applyChildUpdateOps(params) {
 async function updateWithNested(params) {
   const { ctx, model, where, data } = params;
   const { scalars, ops } = partitionData({ meta: ctx.meta, model, data, phase: "update" });
+  const ownerOps = ops.filter((op) => op.link.kind === "toOneOwner");
+  const needsPreRead = ownerOps.length > 0 || Object.keys(scalars).length === 0;
   return await ctx.transactional(async (run) => {
-    const preRows = await run.rows({ model: model.name, method: "findUnique", args: { where } });
-    const pre = preRows[0];
-    if (pre === undefined) {
-      throw notFound({
-        message: `no ${model.name} record matched the where clause of update()`,
-        meta: { model: model.name }
-      });
+    let pre;
+    if (needsPreRead) {
+      const preRows = await run.rows({ model: model.name, method: "findUnique", args: { where } });
+      pre = preRows[0];
+      if (pre === undefined) {
+        throw notFound({
+          message: `no ${model.name} record matched the where clause of update()`,
+          meta: { model: model.name }
+        });
+      }
     }
     const fkSets = {};
     const deferred = [];
-    for (const op of ops) {
-      if (op.link.kind !== "toOneOwner")
-        continue;
+    for (const op of ownerOps) {
       await resolveOwnerUpdateVerb({ ctx, run, op, pre, fkSets, deferred });
     }
     assertWriteScope({ data, assignments: fkSets });
@@ -6674,22 +6785,35 @@ function parsePostgresPlan(params) {
   };
 }
 var WRITE_LEADERS = ["INSERT", "UPDATE", "DELETE", "MERGE", "TRUNCATE", "CREATE", "DROP", "ALTER", "GRANT", "REVOKE", "COPY", "CALL", "DO"];
+var SIDE_EFFECT_CALLS = /\bpg_(?:try_)?advisory_(?:xact_)?lock(?:_shared)?\s*\(/i;
 function refuse(params) {
   return new VibeError13({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta ?? {} });
 }
-function assertExecutableRead(params) {
+function executableReadRefusal(params) {
   const normalized = normalizeSql({ text: params.text });
   const body = normalized.replace(/;\s*$/, "");
   if (body.includes(";")) {
-    throw refuse({ message: "EXPLAIN ANALYZE refuses multi-statement text: it would execute every statement in it", meta: {} });
+    return refuse({ message: "EXPLAIN ANALYZE refuses multi-statement text: it would execute every statement in it", meta: {} });
   }
   const leader = (body.match(/^\(*\s*([A-Za-z]+)/)?.[1] ?? "").toUpperCase();
   if (WRITE_LEADERS.includes(leader)) {
-    throw refuse({ message: `EXPLAIN ANALYZE refuses a ${leader} statement: the executing mode would perform the write`, meta: { statement: leader } });
+    return refuse({ message: `EXPLAIN ANALYZE refuses a ${leader} statement: the executing mode would perform the write`, meta: { statement: leader } });
   }
   if (leader !== "SELECT" && leader !== "WITH" && leader !== "TABLE" && leader !== "VALUES") {
-    throw refuse({ message: `EXPLAIN ANALYZE only accepts read statements; this one starts with "${leader || "?"}"`, meta: { statement: leader } });
+    return refuse({ message: `EXPLAIN ANALYZE only accepts read statements; this one starts with "${leader || "?"}"`, meta: { statement: leader } });
+  }
+  if (SIDE_EFFECT_CALLS.test(body)) {
+    return refuse({ message: "EXPLAIN ANALYZE refuses a statement that takes an advisory lock: the executing mode would take the lock on the diagnostic session", meta: { statement: leader } });
   }
+  return;
+}
+function assertExecutableRead(params) {
+  const refusal = executableReadRefusal(params);
+  if (refusal !== undefined)
+    throw refusal;
+}
+function isExecutableRead(params) {
+  return executableReadRefusal(params) === undefined;
 }
 async function readPlanContext(params) {
   const { executor, dialect, rlsContextKeys } = params;
@@ -6753,59 +6877,20 @@ async function explainSql(params) {
       await run(session("sessionReadOnly"));
   }
   try {
-    for (const key of contextKeys) {
-      const value = rlsContext?.[key];
-      const statement = renderPostgresWorkload({
-        dialect,
-        query: "setContext",
-        key: `${NATIVE_RLS.settingPrefix}${key}`,
-        value: value === null || value === undefined ? null : String(value)
-      });
-      await run(statement);
-    }
-    const context = await readPlanContext({ executor, dialect, rlsContextKeys: contextKeys });
-    if (!context.representative) {
-      if (params.requireRepresentativeContext === true) {
-        throw new VibeError13({
-          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 }
-        });
-      }
-      warnings.push(context.reason ?? "the plan was taken under a role that bypasses row policies");
-    }
-    const explain = renderPostgresExplain({
-      dialect,
-      query: { text: sql2.text, values: [...sql2.values], returning: "none" },
-      options: mode === "analyze" ? { analyze: true, buffers: true } : {}
-    });
-    const rows = await run(explain);
-    const payload = rows[0]?.["QUERY PLAN"] ?? rows[0]?.["query plan"] ?? rows[0]?.["queryPlan"];
-    const parsed = parsePostgresPlan({
-      payload,
+    const report = await explainOnSession({
+      executor,
+      dialect: params.dialect,
+      sql: sql2,
       mode,
+      warnings,
+      ...rlsContext === undefined ? {} : { rlsContext },
+      ...params.requireRepresentativeContext === undefined ? {} : { requireRepresentativeContext: params.requireRepresentativeContext },
       ...params.maxNodes === undefined ? {} : { maxNodes: params.maxNodes },
       ...params.includeLiterals === undefined ? {} : { includeLiterals: params.includeLiterals }
     });
-    if (parsed.truncated)
-      warnings.push(`the plan was truncated at ${parsed.nodeCount} nodes; raise maxNodes to see the rest`);
-    if (mode === "estimate") {
-      warnings.push("estimated plan: costs are planner cost units (not milliseconds) and rows are estimates (not observations); EXPLAIN still parses, plans and takes planning locks");
-    }
     if (transactional)
       await run(session("sessionCommit"));
-    return {
-      mode,
-      root: parsed.root,
-      nodeCount: parsed.nodeCount,
-      truncated: parsed.truncated,
-      estimatedTotalCostUnits: parsed.root.estimatedTotalCost,
-      ...parsed.planningTimeMs === undefined ? {} : { planningTimeMs: parsed.planningTimeMs },
-      ...parsed.executionTimeMs === undefined ? {} : { executionTimeMs: parsed.executionTimeMs },
-      literalsRedacted: params.includeLiterals !== true,
-      context,
-      warnings
-    };
+    return report;
   } catch (error) {
     if (transactional) {
       await run(session("sessionRollback")).catch(() => []);
@@ -6813,6 +6898,64 @@ async function explainSql(params) {
     throw error;
   }
 }
+async function explainOnSession(params) {
+  const { executor, sql: sql2, mode, rlsContext } = params;
+  const dialect = requirePostgres({ dialect: params.dialect });
+  const warnings = params.warnings ?? [];
+  const contextKeys = rlsContext === undefined ? [] : Object.keys(rlsContext);
+  const run = async (query) => executor({ text: query.text, values: query.values });
+  for (const key of contextKeys) {
+    const value = rlsContext?.[key];
+    const statement = renderPostgresWorkload({
+      dialect,
+      query: "setContext",
+      key: `${NATIVE_RLS.settingPrefix}${key}`,
+      value: value === null || value === undefined ? null : String(value)
+    });
+    await run(statement);
+  }
+  const context = await readPlanContext({ executor, dialect, rlsContextKeys: contextKeys });
+  if (!context.representative) {
+    if (params.requireRepresentativeContext === true) {
+      throw new VibeError13({
+        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 }
+      });
+    }
+    warnings.push(context.reason ?? "the plan was taken under a role that bypasses row policies");
+  }
+  const explain = renderPostgresExplain({
+    dialect,
+    query: { text: sql2.text, values: [...sql2.values], returning: "none" },
+    options: mode === "analyze" ? { analyze: true, buffers: true } : {}
+  });
+  const rows = await run(explain);
+  const payload = rows[0]?.["QUERY PLAN"] ?? rows[0]?.["query plan"] ?? rows[0]?.["queryPlan"];
+  const parsed = parsePostgresPlan({
+    payload,
+    mode,
+    ...params.maxNodes === undefined ? {} : { maxNodes: params.maxNodes },
+    ...params.includeLiterals === undefined ? {} : { includeLiterals: params.includeLiterals }
+  });
+  if (parsed.truncated)
+    warnings.push(`the plan was truncated at ${parsed.nodeCount} nodes; raise maxNodes to see the rest`);
+  if (mode === "estimate") {
+    warnings.push("estimated plan: costs are planner cost units (not milliseconds) and rows are estimates (not observations); EXPLAIN still parses, plans and takes planning locks");
+  }
+  return {
+    mode,
+    root: parsed.root,
+    nodeCount: parsed.nodeCount,
+    truncated: parsed.truncated,
+    estimatedTotalCostUnits: parsed.root.estimatedTotalCost,
+    ...parsed.planningTimeMs === undefined ? {} : { planningTimeMs: parsed.planningTimeMs },
+    ...parsed.executionTimeMs === undefined ? {} : { executionTimeMs: parsed.executionTimeMs },
+    literalsRedacted: params.includeLiterals !== true,
+    context,
+    warnings
+  };
+}
 async function explainOperation(params) {
   const { schema, model, method, args } = params;
   const dialect = requirePostgres({ dialect: params.dialect });
@@ -6847,9 +6990,253 @@ async function explainOperation(params) {
     ...params.includeLiterals === undefined ? {} : { includeLiterals: params.includeLiterals }
   });
 }
+// packages/runtime/src/diagnostics/statement-diagnostics.ts
+import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { renderPostgresWorkload as renderPostgresWorkload2 } from "@vibeorm/sql";
+var STATEMENT_DIAGNOSTICS_DEFAULTS = Object.freeze({
+  slowerThanMs: 0,
+  explain: "off",
+  explainTimeoutMs: 5000,
+  analyzeWarnBelowMs: 1,
+  envVariable: "VIBEORM_DIAGNOSTICS"
+});
+var EXPLAIN_MODES = ["off", "estimate", "analyze"];
+function configError(params) {
+  return new VibeError14({ code: "VIBE_CONFIG", message: params.message, meta: params.meta ?? {} });
+}
+function isExplainMode(value) {
+  return typeof value === "string" && EXPLAIN_MODES.includes(value);
+}
+function assertThreshold(params) {
+  const { value, source } = params;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw configError({
+      message: `${source}: slowerThanMs must be a non-negative number of milliseconds, got ${String(value)}`,
+      meta: { source, value }
+    });
+  }
+  return value;
+}
+function parseDiagnosticsEnv(params) {
+  const raw = params.value?.trim();
+  if (raw === undefined || raw === "")
+    return;
+  const variable = STATEMENT_DIAGNOSTICS_DEFAULTS.envVariable;
+  const [modePart, thresholdPart, ...rest] = raw.split(":");
+  const mode = modePart?.trim().toLowerCase();
+  if (rest.length > 0 || !isExplainMode(mode)) {
+    throw configError({
+      message: `${variable}="${raw}" is not <explain>[:<slowerThanMs>] with explain one of ${EXPLAIN_MODES.join(" | ")} \u2014 e.g. ${variable}=analyze:5`,
+      meta: { variable, value: raw }
+    });
+  }
+  if (thresholdPart === undefined)
+    return { explain: mode, slowerThanMs: STATEMENT_DIAGNOSTICS_DEFAULTS.slowerThanMs };
+  const threshold = thresholdPart.trim();
+  const parsed = /^\d+(?:\.\d+)?$/.test(threshold) ? Number(threshold) : Number.NaN;
+  if (!Number.isFinite(parsed)) {
+    throw configError({
+      message: `${variable}="${raw}": the threshold after ":" must be a non-negative number of milliseconds`,
+      meta: { variable, value: raw }
+    });
+  }
+  return { explain: mode, slowerThanMs: parsed };
+}
+function formatStatementDiagnostic(params) {
+  const { report } = params;
+  const head = `[vibeorm] ${report.model ?? "raw"}.${report.method} ${report.durationMs.toFixed(1)} ms \xB7 ${report.parameterCount} param${report.parameterCount === 1 ? "" : "s"}${report.inTransaction ? " \xB7 in transaction" : ""}`;
+  if (report.plan !== undefined)
+    return `${head} \xB7 ${report.plan.summary}`;
+  if (report.explainSkipped !== undefined) {
+    const detail = report.explainError === undefined ? "" : ` (${report.explainError})`;
+    return `${head} \xB7 explain skipped: ${report.explainSkipped}${detail}`;
+  }
+  return head;
+}
+var defaultSink = (report) => {
+  console.warn(formatStatementDiagnostic({ report }));
+};
+function resolveStatementDiagnostics(params) {
+  const { options } = params;
+  const fromEnv = parseDiagnosticsEnv({ value: params.env });
+  if (options === undefined && fromEnv === undefined)
+    return;
+  const explain = options?.explain ?? fromEnv?.explain ?? STATEMENT_DIAGNOSTICS_DEFAULTS.explain;
+  if (!isExplainMode(explain)) {
+    throw configError({
+      message: `diagnostics.explain must be one of ${EXPLAIN_MODES.join(" | ")}, got ${String(explain)}`,
+      meta: { explain }
+    });
+  }
+  const slowerThanMs = options?.slowerThanMs === undefined ? fromEnv?.slowerThanMs ?? STATEMENT_DIAGNOSTICS_DEFAULTS.slowerThanMs : assertThreshold({ value: options.slowerThanMs, source: "diagnostics" });
+  if (options?.sink !== undefined && typeof options.sink !== "function") {
+    throw configError({ message: "diagnostics.sink must be a function", meta: {} });
+  }
+  return {
+    explain,
+    slowerThanMs,
+    sink: options?.sink ?? defaultSink,
+    showLiterals: options?.showLiterals === true,
+    fromEnvironment: fromEnv !== undefined && (options?.explain === undefined || options.slowerThanMs === undefined)
+  };
+}
+function nodeLabel(node) {
+  const target = node.relation ?? node.indexName;
+  return target === undefined ? node.nodeType : `${node.nodeType} on ${target}`;
+}
+function collectLoops(params) {
+  const out = [];
+  const walk = (node) => {
+    if (node.actualLoops !== undefined && node.actualLoops > 1) {
+      out.push({ node: nodeLabel(node), loops: node.actualLoops, rows: node.actualRows ?? 0 });
+    }
+    for (const child of node.children)
+      walk(child);
+  };
+  walk(params.root);
+  out.sort((a, b) => b.loops - a.loops);
+  return out;
+}
+var formatCount = (value) => value.toLocaleString("en-US");
+function summarizePlan(params) {
+  const { plan, mode } = params;
+  const root = plan.root;
+  const loops = mode === "analyze" ? collectLoops({ root }) : [];
+  const parts = [];
+  if (mode === "analyze") {
+    const executionMs = plan.executionTimeMs ?? root.actualTotalTimeMs;
+    parts.push(executionMs === undefined ? nodeLabel(root) : `${nodeLabel(root)} ${executionMs.toFixed(1)} ms`);
+    const hottest = loops[0];
+    if (hottest !== undefined)
+      parts.push(`${hottest.node} loops=${formatCount(hottest.loops)} rows=${formatCount(hottest.rows)}`);
+    if (root.sharedBlocksHit !== undefined)
+      parts.push(`shared hit ${formatCount(root.sharedBlocksHit)}`);
+    if (root.sharedBlocksRead !== undefined && root.sharedBlocksRead > 0)
+      parts.push(`shared read ${formatCount(root.sharedBlocksRead)}`);
+  } else {
+    parts.push(`${nodeLabel(root)} cost=${root.estimatedTotalCost} rows\u2248${formatCount(root.estimatedRows)} (estimated)`);
+  }
+  if (plan.truncated)
+    parts.push(`plan truncated at ${plan.nodeCount} nodes`);
+  return {
+    summary: parts.join(" \xB7 "),
+    nodes: plan,
+    ...plan.executionTimeMs === undefined ? {} : { executionMs: plan.executionTimeMs },
+    ...plan.planningTimeMs === undefined ? {} : { planningMs: plan.planningTimeMs },
+    ...root.sharedBlocksHit === undefined ? {} : { buffersShared: root.sharedBlocksHit },
+    ...loops.length === 0 ? {} : { loops }
+  };
+}
+function errorCode(error) {
+  return error instanceof VibeError14 ? error.code : "VIBE_INTERNAL";
+}
+function createStatementDiagnostics(params) {
+  const { config, adapter, dialect } = params;
+  const outstanding = new Set;
+  const explainable = dialect.name === "postgres";
+  const timeoutMs = STATEMENT_DIAGNOSTICS_DEFAULTS.explainTimeoutMs;
+  const transactionOptions = adapter.budgets?.statementTimeout === "all-statements" ? { timeout: timeoutMs } : undefined;
+  const report = (diagnostic) => {
+    try {
+      config.sink(diagnostic);
+    } catch {}
+  };
+  const explain = async (statement, mode) => {
+    const run = async (tx) => {
+      if (mode === "analyze") {
+        const readOnly = renderPostgresWorkload2({ dialect, query: "sessionReadOnly" });
+        await tx.execute({ text: readOnly.text, values: readOnly.values });
+      }
+      const executor = statement.raw ? async (query) => (await tx.executeUnsafe({ text: query.text, values: query.values ?? [] })).rows : async (query) => tx.execute({
+        text: query.text,
+        values: (query.values ?? []).map((value) => Array.isArray(value) ? tx.formatArrayParam(value) : value)
+      });
+      const report2 = await explainOnSession({
+        executor,
+        dialect: dialect.name,
+        sql: { text: statement.text, values: statement.values },
+        mode,
+        includeLiterals: config.showLiterals
+      });
+      return summarizePlan({
+        plan: {
+          root: report2.root,
+          nodeCount: report2.nodeCount,
+          truncated: report2.truncated,
+          ...report2.planningTimeMs === undefined ? {} : { planningTimeMs: report2.planningTimeMs },
+          ...report2.executionTimeMs === undefined ? {} : { executionTimeMs: report2.executionTimeMs }
+        },
+        mode
+      });
+    };
+    return transactionOptions === undefined ? adapter.transaction(run) : adapter.transaction(run, transactionOptions);
+  };
+  const schedule = (statement, mode, base) => {
+    const task = new Promise((resolve) => {
+      setTimeout(() => {
+        explain(statement, mode).then((plan) => {
+          report({ ...base, plan });
+          resolve();
+        }, (error) => {
+          report({ ...base, explainSkipped: "error", explainError: errorCode(error) });
+          resolve();
+        });
+      }, 0);
+    });
+    outstanding.add(task);
+    task.finally(() => outstanding.delete(task));
+  };
+  return {
+    config,
+    observe: (statement) => {
+      if (statement.durationMs < config.slowerThanMs)
+        return;
+      const base = {
+        model: statement.model,
+        method: statement.method,
+        text: statement.text,
+        durationMs: statement.durationMs,
+        parameterCount: statement.values.length,
+        inTransaction: statement.inTransaction
+      };
+      if (config.explain === "off") {
+        report(base);
+        return;
+      }
+      if (!explainable) {
+        report({ ...base, explainSkipped: "dialect" });
+        return;
+      }
+      if (statement.inTransaction) {
+        report({ ...base, explainSkipped: "in-transaction" });
+        return;
+      }
+      if (!isExecutableRead({ text: statement.text })) {
+        report({ ...base, explainSkipped: "not-a-read" });
+        return;
+      }
+      schedule(statement, config.explain, base);
+    },
+    flush: async () => {
+      if (outstanding.size === 0)
+        return;
+      let timer;
+      const bound = new Promise((resolve) => {
+        timer = setTimeout(resolve, timeoutMs);
+      });
+      try {
+        await Promise.race([Promise.allSettled([...outstanding]), bound]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    },
+    outstanding: () => outstanding.size
+  };
+}
 // packages/runtime/src/diagnostics/workload.ts
 import { unsupportedCapability as unsupportedCapability6 } from "@vibeorm/schema";
-import { getSqlDialect as getSqlDialect3, renderPostgresWorkload as renderPostgresWorkload2 } from "@vibeorm/sql";
+import { getSqlDialect as getSqlDialect3, renderPostgresWorkload as renderPostgresWorkload3 } from "@vibeorm/sql";
 var STATEMENTS_INFO_MIN_VERSION = 140000;
 var STATEMENTS_MIN_VERSION = 130000;
 var NOTES = Object.freeze({
@@ -6864,7 +7251,7 @@ function num2(value) {
   return typeof value === "number" ? value : Number(value ?? 0);
 }
 async function readAvailability(params) {
-  const query = renderPostgresWorkload2({ dialect: params.dialect, query: "statementExtension" });
+  const query = renderPostgresWorkload3({ dialect: params.dialect, query: "statementExtension" });
   const rows = await params.executor({ text: query.text, values: query.values });
   const row = rows[0] ?? {};
   const installedVersion = row["installedVersion"] === null || row["installedVersion"] === undefined ? null : String(row["installedVersion"]);
@@ -6916,14 +7303,14 @@ async function readWorkloadStatistics(params) {
     notes.push(NOTES.restrictedText);
   let statsReset = null;
   if (availability.serverVersionNum >= STATEMENTS_INFO_MIN_VERSION) {
-    const info = renderPostgresWorkload2({ dialect, query: "statementInfo", schema: availability.schema });
+    const info = renderPostgresWorkload3({ dialect, query: "statementInfo", schema: availability.schema });
     const infoRows = await executor({ text: info.text, values: info.values });
     const value = infoRows[0]?.["statsReset"];
     statsReset = value === null || value === undefined ? null : String(value);
   } else {
     notes.push("this server predates pg_stat_statements_info, so the collection window's reset time is unknown");
   }
-  const snapshot = renderPostgresWorkload2({
+  const snapshot = renderPostgresWorkload3({
     dialect,
     query: "statementSnapshot",
     schema: availability.schema,
@@ -6959,7 +7346,7 @@ async function readWorkloadStatistics(params) {
   };
 }
 // packages/runtime/src/diagnostics/insight.ts
-import { VibeError as VibeError14 } from "@vibeorm/schema";
+import { VibeError as VibeError15 } from "@vibeorm/schema";
 var DIAGNOSTIC_THRESHOLDS = Object.freeze({
   repeatThreshold: 5,
   minRepeatThreshold: 2,
@@ -6977,7 +7364,7 @@ function bounded(params) {
   if (value === undefined)
     return fallback;
   if (!Number.isInteger(value) || value < min || value > max) {
-    throw new VibeError14({
+    throw new VibeError15({
       code: "VIBE_CONFIG",
       message: `${name} must be an integer between ${min} and ${max}, got ${String(value)}`,
       meta: { [name]: value }
@@ -7200,11 +7587,11 @@ function recommendFromPlan(params) {
   return findings.slice(0, maxFindings);
 }
 // packages/runtime/src/relation-loader.ts
-import { VibeError as VibeError16 } from "@vibeorm/schema";
+import { VibeError as VibeError17 } from "@vibeorm/schema";
 import { renderStatement as renderStatement3 } from "@vibeorm/sql";
 
 // packages/runtime/src/computed.ts
-import { VibeError as VibeError15 } from "@vibeorm/schema";
+import { VibeError as VibeError16 } from "@vibeorm/schema";
 function sameNeeds(a, b) {
   if (a.length !== b.length)
     return false;
@@ -7240,7 +7627,7 @@ function assertComputedManifest(params) {
     problems.push(`"${key}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError15({
+    throw new VibeError16({
       code: "VIBE_STALE_CLIENT",
       message: `computed-field config changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { problems }
@@ -7263,6 +7650,87 @@ function applyComputedFields(params) {
 }
 
 // packages/runtime/src/relation-loader.ts
+function resolveRelationConcurrency(params) {
+  const { concurrency } = params;
+  if (concurrency === undefined)
+    return 1;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new VibeError17({
+      code: "VIBE_CONFIG",
+      message: `relationLoading.concurrency must be a positive integer \u2014 got ${String(concurrency)}`,
+      meta: { concurrency }
+    });
+  }
+  return concurrency;
+}
+function createStatementLimiter(params) {
+  const { concurrency } = params;
+  const waiting = [];
+  let active = 0;
+  const release = () => {
+    const next = waiting.shift();
+    if (next === undefined) {
+      active -= 1;
+      return;
+    }
+    next();
+  };
+  return {
+    run: async (task) => {
+      if (active >= concurrency) {
+        await new Promise((resolve) => {
+          waiting.push(resolve);
+        });
+      } else {
+        active += 1;
+      }
+      try {
+        return await task();
+      } finally {
+        release();
+      }
+    }
+  };
+}
+async function runAllSettled(params) {
+  const settled = await Promise.allSettled(params.tasks.map((task) => task()));
+  for (const result of settled) {
+    if (result.status === "rejected")
+      throw result.reason;
+  }
+}
+function createLoaderContext(params) {
+  const { dialect, meta, execute, wire } = params;
+  const concurrency = resolveRelationConcurrency({ concurrency: params.concurrency });
+  if (concurrency === 1)
+    return { dialect, meta, execute, wire, limiter: null };
+  const limiter = createStatementLimiter({ concurrency });
+  return {
+    dialect,
+    meta,
+    execute: (statement) => limiter.run(() => execute(statement)),
+    wire,
+    limiter
+  };
+}
+async function executeChunks(params) {
+  const { ctx, chunks, run } = params;
+  const raw = [];
+  if (ctx.limiter === null || chunks.length < 2) {
+    for (const chunk of chunks)
+      pushAll(raw, await run(chunk));
+    return raw;
+  }
+  const perChunk = chunks.map(() => []);
+  await runAllSettled({
+    tasks: chunks.map((chunk, index) => async () => {
+      perChunk[index] = await run(chunk);
+    })
+  });
+  for (const rows of perChunk)
+    pushAll(raw, rows);
+  return raw;
+}
 var COUNT_VALUE_ALIAS = "__vibe_count";
 var WINDOW_ROW_ALIAS = "__vibe_rn";
 var WINDOW_TABLE_ALIAS = "__vibe_win";
@@ -7372,7 +7840,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 VibeError16({
+      throw new VibeError17({
         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 }
@@ -7411,7 +7879,6 @@ async function loadToManyFk(params) {
       }
     }
   });
-  const raw = [];
   const chunks = chunkKeys({
     ctx,
     keys,
@@ -7420,10 +7887,11 @@ async function loadToManyFk(params) {
     measure: node.args.where !== undefined || bounds !== null,
     arity: link.childKeys.length
   });
-  for (const chunk of chunks) {
-    const statement = build(chunk);
-    pushAll(raw, await ctx.execute({ statement, model: model.name, method: `include.${node.name}` }));
-  }
+  const raw = await executeChunks({
+    ctx,
+    chunks,
+    run: (chunk) => ctx.execute({ statement: build(chunk), model: model.name, method: `include.${node.name}` })
+  });
   const children = materializeRows({ dialect: ctx.dialect.name, model: link.target, rows: raw, wire: ctx.wire });
   const grouped = new Map;
   for (const child of children) {
@@ -7459,7 +7927,6 @@ async function loadToOne(params) {
     node,
     membership: membershipExpr({ ctx, fields: link.childKeys, encodeAs: link.childKeys, tuples: chunk })
   });
-  const raw = [];
   const chunks = chunkKeys({
     ctx,
     keys,
@@ -7468,10 +7935,11 @@ async function loadToOne(params) {
     measure: node.args.where !== undefined,
     arity: link.childKeys.length
   });
-  for (const chunk of chunks) {
-    const statement = build(chunk);
-    pushAll(raw, await ctx.execute({ statement, model: model.name, method: `include.${node.name}` }));
-  }
+  const raw = await executeChunks({
+    ctx,
+    chunks,
+    run: (chunk) => ctx.execute({ statement: build(chunk), model: model.name, method: `include.${node.name}` })
+  });
   const children = materializeRows({ dialect: ctx.dialect.name, model: link.target, rows: raw, wire: ctx.wire });
   const byKey = new Map;
   for (const child of children) {
@@ -7502,7 +7970,7 @@ async function loadManyToMany(params) {
   const link = node.link;
   const join = link.join;
   if (join === null) {
-    throw new VibeError16({
+    throw new VibeError17({
       code: "VIBE_INTERNAL",
       message: `manyToMany relation "${node.name}" resolved without join-table wiring`
     });
@@ -7575,7 +8043,6 @@ async function loadManyToMany(params) {
     };
     return windowedStatement({ inner, columns: outerColumns, bounds });
   };
-  const raw = [];
   const chunks = chunkKeys({
     ctx,
     keys,
@@ -7584,10 +8051,11 @@ async function loadManyToMany(params) {
     measure: node.args.where !== undefined || bounds !== null,
     arity: 1
   });
-  for (const chunk of chunks) {
-    const statement = build(chunk);
-    pushAll(raw, await ctx.execute({ statement, model: model.name, method: `include.${node.name}` }));
-  }
+  const raw = await executeChunks({
+    ctx,
+    chunks,
+    run: (chunk) => ctx.execute({ statement: build(chunk), model: model.name, method: `include.${node.name}` })
+  });
   const pairs = materializeRows({ dialect: ctx.dialect.name, model: target, rows: raw, wire: ctx.wire });
   const decodeParent = fieldDecoder({
     dialect: ctx.dialect.name,
@@ -7614,16 +8082,19 @@ async function loadManyToMany(params) {
   }
   return kept;
 }
-async function loadCounts(params) {
-  const { ctx, model, rows, counts } = params;
-  if (counts.length === 0 || rows.length === 0)
-    return;
+function seedCountBuckets(params) {
+  const { rows, counts } = params;
   for (const row of rows) {
     const bucket = {};
     for (const node of counts)
       bucket[node.name] = 0;
     row._count = bucket;
   }
+}
+async function loadCounts(params) {
+  const { ctx, model, rows, counts } = params;
+  if (counts.length === 0 || rows.length === 0)
+    return;
   for (const node of counts) {
     const name = node.name;
     const link = node.link;
@@ -7681,7 +8152,6 @@ async function loadCounts(params) {
         ]
       };
     };
-    const raw = [];
     const chunks = chunkKeys({
       ctx,
       keys,
@@ -7690,9 +8160,11 @@ async function loadCounts(params) {
       measure: node.where !== undefined,
       arity: groupFields.length
     });
-    for (const chunk of chunks) {
-      pushAll(raw, await ctx.execute({ statement: build(chunk), model: model.name, method: `_count.${name}` }));
-    }
+    const raw = await executeChunks({
+      ctx,
+      chunks,
+      run: (chunk) => ctx.execute({ statement: build(chunk), model: model.name, method: `_count.${name}` })
+    });
     const byKey = new Map;
     for (const entry of raw) {
       const decoded = groupFields.map((field, index) => decodeValue({
@@ -7735,15 +8207,7 @@ async function finishNode(params) {
     applyComputedFields({ model: node.link.target, rows: kept, names: node.args.computed });
   }
   if (node.args.nested !== null && kept.length > 0) {
-    await attachRelations({
-      dialect: ctx.dialect,
-      meta: ctx.meta,
-      model: node.link.target,
-      rows: [...kept],
-      selection: node.args.nested,
-      execute: ctx.execute,
-      ...ctx.wire === undefined ? {} : { wire: ctx.wire }
-    });
+    await attachSelection({ ctx, model: node.link.target, rows: [...kept], selection: node.args.nested });
   }
   if (node.args.strip.length > 0) {
     for (const child of kept) {
@@ -7753,20 +8217,42 @@ async function finishNode(params) {
   }
 }
 async function attachRelations(params) {
-  const { dialect, meta, model, rows, selection, execute, wire } = params;
+  const { dialect, meta, model, rows, selection, execute, wire, concurrency } = params;
   if (rows.length === 0)
     return;
-  const ctx = { dialect, meta, execute, wire };
-  for (const node of selection.relations) {
-    await loadNode({ ctx, model, node, rows });
+  await attachSelection({
+    ctx: createLoaderContext({ dialect, meta, execute, wire, concurrency }),
+    model,
+    rows,
+    selection
+  });
+}
+async function attachSelection(params) {
+  const { ctx, model, rows, selection } = params;
+  if (rows.length === 0)
+    return;
+  if (selection.counts.length > 0)
+    seedCountBuckets({ rows, counts: selection.counts });
+  if (ctx.limiter === null) {
+    for (const node of selection.relations) {
+      await loadNode({ ctx, model, node, rows });
+    }
+    await loadCounts({ ctx, model, rows, counts: selection.counts });
+    return;
   }
-  await loadCounts({ ctx, model, rows, counts: selection.counts });
+  await runAllSettled({
+    tasks: [
+      ...selection.relations.map((node) => () => loadNode({ ctx, model, node, rows })),
+      ...selection.counts.map((node) => () => loadCounts({ ctx, model, rows, counts: [node] }))
+    ]
+  });
 }
 async function attachLateralRelations(params) {
-  const { dialect, meta, rows, selection, execute, wire } = params;
+  const { dialect, meta, rows, selection, execute, wire, concurrency } = params;
   if (rows.length === 0)
     return;
-  const ctx = { dialect, meta, execute, wire };
+  const ctx = createLoaderContext({ dialect, meta, execute, wire, concurrency });
+  const parsed = [];
   for (const node of selection.relations) {
     const column = lateralColumnAlias({ relation: node.name });
     const isList = node.link.relation.isList;
@@ -7776,12 +8262,12 @@ async function attachLateralRelations(params) {
     for (const row of rows) {
       const raw = row[column];
       delete row[column];
-      let parsed = raw;
+      let parsed2 = raw;
       if (typeof raw === "string") {
         try {
-          parsed = JSON.parse(raw);
+          parsed2 = JSON.parse(raw);
         } catch (cause) {
-          throw new VibeError16({
+          throw new VibeError17({
             code: "VIBE_INTERNAL",
             message: `relation column "${column}" returned text that is not valid JSON`,
             meta: { relation: node.name },
@@ -7790,10 +8276,10 @@ async function attachLateralRelations(params) {
         }
       }
       if (isList) {
-        if (!Array.isArray(parsed)) {
-          throw new VibeError16({ code: "VIBE_INTERNAL", message: "to-many relation payload must be an array", meta: { relation: node.name } });
+        if (!Array.isArray(parsed2)) {
+          throw new VibeError17({ code: "VIBE_INTERNAL", message: "to-many relation payload must be an array", meta: { relation: node.name } });
         }
-        const children = parsed.map(decodePosition);
+        const children = parsed2.map(decodePosition);
         for (const child of children) {
           for (const name of hiddenOrder)
             delete child[name];
@@ -7801,18 +8287,27 @@ async function attachLateralRelations(params) {
         row[node.name] = children;
         pushAll(kept, children);
       } else {
-        if (parsed === null) {
+        if (parsed2 === null) {
           row[node.name] = null;
           continue;
         }
-        const child = decodePosition(parsed);
+        const child = decodePosition(parsed2);
         for (const name of hiddenOrder)
           delete child[name];
         row[node.name] = child;
         kept.push(child);
       }
     }
-    await finishNode({ ctx, node, kept });
+    parsed.push({ node, kept });
+  }
+  if (ctx.limiter === null) {
+    for (const entry of parsed) {
+      await finishNode({ ctx, node: entry.node, kept: entry.kept });
+    }
+  } else {
+    await runAllSettled({
+      tasks: parsed.map((entry) => () => finishNode({ ctx, node: entry.node, kept: entry.kept }))
+    });
   }
   if (selection.counts.length === 0)
     return;
@@ -7823,7 +8318,7 @@ async function attachLateralRelations(params) {
       const raw = row[column];
       const count = typeof raw === "number" || typeof raw === "bigint" || typeof raw === "string" && /^\d+$/.test(raw) ? Number(raw) : NaN;
       if (!Number.isSafeInteger(count) || count < 0) {
-        throw new VibeError16({ code: "VIBE_INTERNAL", message: "relation count payload must be a non-negative safe integer", meta: { relation: selection.counts[index]?.name } });
+        throw new VibeError17({ 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];
@@ -7832,7 +8327,7 @@ async function attachLateralRelations(params) {
   }
 }
 // packages/runtime/src/extensions.ts
-import { VibeError as VibeError17, extensionManifestEntry } from "@vibeorm/schema";
+import { VibeError as VibeError18, extensionManifestEntry } from "@vibeorm/schema";
 function assertExtensionManifest(params) {
   const { manifest } = params;
   const instances = params.instances ?? [];
@@ -7855,7 +8350,7 @@ function assertExtensionManifest(params) {
     problems.push(`"${name}" is configured but missing from the generated client`);
   }
   if (problems.length > 0) {
-    throw new VibeError17({
+    throw new VibeError18({
       code: "VIBE_STALE_CLIENT",
       message: `extension list changed since generate; run vibeorm generate \u2014 ${problems.join("; ")}`,
       meta: { manifest, problems }
@@ -7870,7 +8365,7 @@ function buildExtensionOperatorMap(params) {
     for (const operator of extension.sql?.whereOperators ?? []) {
       const existing = owner.get(operator.name);
       if (existing !== undefined) {
-        throw new VibeError17({
+        throw new VibeError18({
           code: "VIBE_CONFIG",
           message: `where operator "${operator.name}" is claimed by both "${existing}" and "${extension.name}"`,
           meta: { operator: operator.name }
@@ -7886,7 +8381,7 @@ function buildExtensionOperatorMap(params) {
           options: extension.options
         });
         if ("error" in compiled) {
-          throw new VibeError17({
+          throw new VibeError18({
             code: "VIBE_VALIDATION",
             message: `"${operator.name}" on ${model}.${field}: ${compiled.error}`,
             meta: { model, field, operator: operator.name, extension: extension.name }
@@ -7918,10 +8413,10 @@ function buildConnectHooks(params) {
   return hooks;
 }
 // packages/runtime/src/views.ts
-import { VibeError as VibeError19 } from "@vibeorm/schema";
+import { VibeError as VibeError20 } from "@vibeorm/schema";
 
 // packages/runtime/src/sql-access.ts
-import { VibeError as VibeError18 } from "@vibeorm/schema";
+import { VibeError as VibeError19 } from "@vibeorm/schema";
 import { isSqlFragment as isSqlFragment2 } from "@vibeorm/sql";
 function containsSqlFragment(value, seen = new Set) {
   if (isSqlFragment2(value))
@@ -7937,7 +8432,7 @@ function restrictedSqlArgs(params) {
   const seen = new Map;
   const copy = (value) => {
     if (isSqlFragment2(value))
-      throw new VibeError18({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
+      throw new VibeError19({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
     if (typeof value !== "object" || value === null)
       return value;
     if (seen.has(value))
@@ -7964,7 +8459,7 @@ function restrictedSqlArgs(params) {
 
 // packages/runtime/src/views.ts
 function validationError6(params) {
-  return new VibeError19({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError20({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 
 class ViewResult {
@@ -8318,7 +8813,7 @@ function createView(params) {
   for (const [clientName, mask] of resolved) {
     const delegate = models[clientName];
     if (delegate === undefined) {
-      throw new VibeError19({
+      throw new VibeError20({
         code: "VIBE_INTERNAL",
         message: `view "${name}": no delegate for model "${mask.model.name}"`,
         meta: { view: name, model: mask.model.name }
@@ -8334,9 +8829,9 @@ function attachDefineView(params) {
   Object.defineProperty(client, "$defineView", { value, enumerable: true });
 }
 // packages/runtime/src/validators.ts
-import { VibeError as VibeError20 } from "@vibeorm/schema";
+import { VibeError as VibeError21 } from "@vibeorm/schema";
 function validationFailed(params) {
-  return new VibeError20({
+  return new VibeError21({
     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 }
@@ -8345,7 +8840,7 @@ function validationFailed(params) {
 function validateValue(params) {
   const result = params.schema["~standard"].validate(params.value);
   if (result instanceof Promise) {
-    throw new VibeError20({
+    throw new VibeError21({
       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 }
@@ -8468,7 +8963,7 @@ function deferPolicyOperation(params) {
 }
 
 // packages/runtime/src/policy.ts
-import { VibeError as VibeError21 } from "@vibeorm/schema";
+import { VibeError as VibeError22 } from "@vibeorm/schema";
 
 // packages/runtime/src/read-only.ts
 import { ReadOnlyClientError } from "@vibeorm/schema";
@@ -8731,7 +9226,7 @@ function inheritReadOnly(params) {
 
 // packages/runtime/src/policy.ts
 function policyError(message, meta) {
-  return new VibeError21({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
+  return new VibeError22({ code: "VIBE_VALIDATION", message, meta: meta ?? {} });
 }
 function policiedModels(meta) {
   return meta.models.filter((model) => model.policy !== undefined);
@@ -9077,7 +9572,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 VibeError21({ 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 VibeError22({ 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)),
@@ -9111,7 +9606,7 @@ function scopedDelegate(params) {
       })
     })),
     upsertMany: () => {
-      throw new VibeError21({
+      throw new VibeError22({
         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 }
@@ -9120,7 +9615,7 @@ function scopedDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError21({
+        throw new VibeError22({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate",
           meta: { model: model.name }
@@ -9191,7 +9686,7 @@ function globalDelegate(params) {
     updateManyAndReturn: (args) => deferred(() => {
       const run = base.updateManyAndReturn;
       if (run === undefined) {
-        throw new VibeError21({
+        throw new VibeError22({
           code: "VIBE_UNSUPPORTED_CAPABILITY",
           message: "updateManyAndReturn is not available on this delegate"
         });
@@ -9202,7 +9697,7 @@ function globalDelegate(params) {
     upsertMany: (args) => deferred(() => {
       if (params.policyBound === false)
         return base.upsertMany(args);
-      throw new VibeError21({
+      throw new VibeError22({
         code: "VIBE_UNSUPPORTED_CAPABILITY",
         message: "upsertMany is not available on a policy-bound client: its conflict target is not policy-checked yet"
       });
@@ -9360,7 +9855,7 @@ function attachPolicy(params) {
   });
 }
 // packages/runtime/src/scoped.ts
-import { ScopedQueryError, VibeError as VibeError22 } from "@vibeorm/schema";
+import { ScopedQueryError, VibeError as VibeError23 } from "@vibeorm/schema";
 function refusal(params) {
   return new ScopedQueryError(params);
 }
@@ -10315,7 +10810,7 @@ function attachScoped(params) {
   Object.defineProperty(client, "$scoped", {
     value: (config) => {
       if (!isPlainObject8(config) || !isPlainObject8(config.models)) {
-        throw new VibeError22({
+        throw new VibeError23({
           code: "VIBE_VALIDATION",
           message: "$scoped takes { scope: string | number | bigint | null, models: { <Model>: \u2026 } }"
         });
@@ -10331,7 +10826,7 @@ function attachScoped(params) {
       }
       const scope = config.scope;
       if (scope !== null && typeof scope !== "string" && typeof scope !== "number" && typeof scope !== "bigint") {
-        throw new VibeError22({
+        throw new VibeError23({
           code: "VIBE_VALIDATION",
           message: `$scoped: scope must be a string, number, bigint or null \u2014 got ${typeof scope}`
         });
@@ -10347,7 +10842,7 @@ function attachScoped(params) {
   });
 }
 // packages/runtime/src/rls-readiness.ts
-import { VibeError as VibeError23, assertValidSchemaIR, unsupportedCapability as unsupportedCapability7 } from "@vibeorm/schema";
+import { VibeError as VibeError24, assertValidSchemaIR, unsupportedCapability as unsupportedCapability7 } 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) {
@@ -10370,6 +10865,35 @@ function intOf(params) {
     return null;
   return Number.parseInt(value, 10);
 }
+function unreadableCatalog(params) {
+  return new VibeError24({
+    code: "VIBE_ADAPTER",
+    message: `native RLS readiness could not read the "${params.key}" result of the folded catalog read: ${params.detail}. ` + "The inspection is refused rather than treated as an empty result set.",
+    meta: { result: params.key }
+  });
+}
+function catalogRowsOf(params) {
+  const value = params.row[params.key];
+  if (value === null || value === undefined)
+    return [];
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch (error) {
+      throw unreadableCatalog({ key: params.key, detail: describeFailure({ error }) });
+    }
+  }
+  if (!Array.isArray(parsed)) {
+    throw unreadableCatalog({ key: params.key, detail: `expected a JSON array, got ${typeof parsed}` });
+  }
+  return parsed.map((entry) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      throw unreadableCatalog({ key: params.key, detail: `expected JSON objects, got ${entry === null ? "null" : typeof entry}` });
+    }
+    return entry;
+  });
+}
 var EXPRESSION_CACHE_LIMITS = Object.freeze({ connections: 64 });
 var expressionCaches = new WeakMap;
 function buildCheck(params) {
@@ -10401,7 +10925,7 @@ function requireNativeRls(params) {
     throw unsupportedCapability7({ dialect: dialect.name, feature: "nativeRowLevelSecurity" });
   }
   if (params.schema.rls === undefined) {
-    throw new VibeError23({
+    throw new VibeError24({
       code: "VIBE_CONFIG",
       message: "Native row-level security readiness requires a schema that declares native RLS"
     });
@@ -10692,8 +11216,9 @@ async function inspectNativeRlsTransaction(params) {
   const dialect = requireNativeRls({ adapter, schema });
   const protectedTables = protectedTablesOf({ schema });
   const unprotected = unprotectedTablesOf({ schema });
-  const identityRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "identity" }));
-  const identityRow = identityRows[0] ?? {};
+  const catalogRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "catalog" }));
+  const catalog = catalogRows[0] ?? {};
+  const identityRow = catalogRowsOf({ row: catalog, key: "identity" })[0] ?? {};
   const identity = {
     currentRole: textOf({ row: identityRow, key: "currentUser" }),
     sessionRole: textOf({ row: identityRow, key: "sessionUser" }),
@@ -10703,13 +11228,13 @@ async function inspectNativeRlsTransaction(params) {
     createRole: flagOf({ row: identityRow, key: "createRole" }),
     serverVersionNum: intOf({ row: identityRow, key: "serverVersionNum" })
   };
-  const elevatedRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "elevatedRoles" }));
-  const controlRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "schemaControl" }));
-  const tableRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "tables" }));
-  const policyRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "policies" }));
-  const viewRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "views" }));
-  const routineRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "routines" }));
-  const triggerRows = await adapter.execute(renderRlsReadinessQuery({ dialect, query: "triggers" }));
+  const elevatedRows = catalogRowsOf({ row: catalog, key: "elevatedRoles" });
+  const controlRows = catalogRowsOf({ row: catalog, key: "schemaControl" });
+  const tableRows = catalogRowsOf({ row: catalog, key: "tables" });
+  const policyRows = catalogRowsOf({ row: catalog, key: "policies" });
+  const viewRows = catalogRowsOf({ row: catalog, key: "views" });
+  const routineRows = catalogRowsOf({ row: catalog, key: "routines" });
+  const triggerRows = catalogRowsOf({ row: catalog, key: "triggers" });
   const controlRow = controlRows[0];
   const control = controlRow === undefined ? undefined : {
     schema: textOf({ row: controlRow, key: "schema" }),
@@ -10813,7 +11338,7 @@ async function inspectNativeRls(params) {
 function requireEmbeddedRole(params) {
   const { role } = params;
   if (typeof role !== "string" || role.length === 0 || role.includes("\x00")) {
-    throw new VibeError23({
+    throw new VibeError24({
       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" }
@@ -10825,7 +11350,7 @@ function assertNativeRlsReady(params) {
   const { report } = params;
   if (report.ready)
     return;
-  throw new VibeError23({
+  throw new VibeError24({
     code: "VIBE_CONFIG",
     message: `Native row-level security is not ready on this database: ${report.problems.map((problem) => `${problem.name} (${problem.status})`).join(", ")}`,
     meta: {
@@ -10851,7 +11376,7 @@ function formatNativeRlsReport(params) {
 }
 // packages/runtime/src/client.ts
 import { compileSql } from "@vibeorm/sql";
-import { RlsContextError as RlsContextError2, VibeError as VibeError27, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
+import { RlsContextError as RlsContextError2, VibeError as VibeError28, assertValidSchemaIR as assertValidSchemaIR2, unsupportedCapability as unsupportedCapability8 } from "@vibeorm/schema";
 import { ADVISORY_LOCK_RESULT_COLUMN, ParamCollector, getSqlDialect as getSqlDialect5, renderRlsContext, renderRlsPolicy as renderRlsPolicy2, renderRlsRole as renderRlsRole2, renderStatement as renderStatement5 } from "@vibeorm/sql";
 
 // packages/runtime/src/render-cache.ts
@@ -11362,11 +11887,11 @@ function renderStatementCached(params) {
 }
 
 // packages/runtime/src/strict-args.ts
-import { VibeError as VibeError24 } from "@vibeorm/schema";
+import { VibeError as VibeError25 } from "@vibeorm/schema";
 var SKIP = Symbol.for("vibeorm.skip");
 function explicitUndefined(params) {
   const { model, method, path } = params;
-  return new VibeError24({
+  return new VibeError25({
     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 }
@@ -11543,10 +12068,10 @@ function bindRlsContext(params) {
 }
 
 // packages/runtime/src/telemetry/recorder.ts
-import { VibeError as VibeError26 } from "@vibeorm/schema";
+import { VibeError as VibeError27 } from "@vibeorm/schema";
 
 // packages/runtime/src/telemetry/config.ts
-import { VibeError as VibeError25 } from "@vibeorm/schema";
+import { VibeError as VibeError26 } from "@vibeorm/schema";
 var TELEMETRY_DEFAULTS = Object.freeze({
   captureSql: false,
   captureParameterValues: false,
@@ -11560,8 +12085,8 @@ var TELEMETRY_DEFAULTS = Object.freeze({
   maxFingerprintLength: 512,
   latencyBucketsMs: Object.freeze([1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000])
 });
-function configError(params) {
-  return new VibeError25({
+function configError2(params) {
+  return new VibeError26({
     code: "VIBE_CONFIG",
     message: `telemetry: ${params.message}`,
     ...params.meta === undefined ? {} : { meta: params.meta }
@@ -11572,7 +12097,7 @@ function positiveInteger(params) {
   if (value === undefined)
     return fallback;
   if (!Number.isInteger(value) || value < 1) {
-    throw configError({ message: `${name} must be a positive integer, received ${String(value)}`, meta: { option: name } });
+    throw configError2({ message: `${name} must be a positive integer, received ${String(value)}`, meta: { option: name } });
   }
   return value;
 }
@@ -11581,22 +12106,22 @@ function nonNegativeNumber(params) {
   if (value === undefined)
     return fallback;
   if (!Number.isFinite(value) || value < 0) {
-    throw configError({ message: `${name} must be a finite number >= 0, received ${String(value)}`, meta: { option: name } });
+    throw configError2({ message: `${name} must be a finite number >= 0, received ${String(value)}`, meta: { option: name } });
   }
   return value;
 }
 function resolveTelemetryConfig(params) {
   const { options } = params;
   if (options.exporter === undefined || options.exporter === null || typeof options.exporter !== "object") {
-    throw configError({ message: "an exporter is required \u2014 telemetry has nowhere to send events without one" });
+    throw configError2({ message: "an exporter is required \u2014 telemetry has nowhere to send events without one" });
   }
   const sampleRate = options.sampleRate ?? TELEMETRY_DEFAULTS.sampleRate;
   if (!Number.isFinite(sampleRate) || sampleRate < 0 || sampleRate > 1) {
-    throw configError({ message: `sampleRate must be between 0 and 1, received ${String(sampleRate)}`, meta: { option: "sampleRate" } });
+    throw configError2({ message: `sampleRate must be between 0 and 1, received ${String(sampleRate)}`, meta: { option: "sampleRate" } });
   }
   const delivery = options.delivery ?? TELEMETRY_DEFAULTS.delivery;
   if (delivery !== "immediate" && delivery !== "buffered") {
-    throw configError({ message: `delivery must be "immediate" or "buffered", received ${JSON.stringify(delivery)}`, meta: { option: "delivery" } });
+    throw configError2({ message: `delivery must be "immediate" or "buffered", received ${JSON.stringify(delivery)}`, meta: { option: "delivery" } });
   }
   return {
     captureSql: options.captureSql ?? TELEMETRY_DEFAULTS.captureSql,
@@ -11649,7 +12174,7 @@ function deriveStage(params) {
   return "decode";
 }
 function errorCodeOf(error) {
-  return error instanceof VibeError26 ? error.code : undefined;
+  return error instanceof VibeError27 ? error.code : undefined;
 }
 function newHistogram(bounds) {
   return { counts: new Array(bounds.length + 1).fill(0), sum: 0, count: 0 };
@@ -11968,8 +12493,8 @@ function createTelemetryRecorder(params) {
 
 // packages/runtime/src/telemetry/statement.ts
 async function instrumentStatement(params) {
-  const { scope, legacy, run } = params;
-  if (scope === undefined && legacy === undefined)
+  const { scope, legacy, diagnose, run } = params;
+  if (scope === undefined && legacy === undefined && diagnose === undefined)
     return await run();
   const started = performance.now();
   let value;
@@ -12017,13 +12542,22 @@ async function instrumentStatement(params) {
     };
     scope.statement(success);
   }
+  diagnose?.({
+    model: params.model,
+    method: params.method,
+    text: params.text,
+    values: params.values,
+    durationMs,
+    inTransaction: params.inTransaction,
+    raw: params.kind === "raw"
+  });
   return value;
 }
 
 // packages/runtime/src/client.ts
 function notFound2(params) {
   const { model, method } = params;
-  return new VibeError27({
+  return new VibeError28({
     code: "VIBE_NOT_FOUND",
     message: `no ${model} record matched the where clause of ${method}()`,
     meta: { model, method }
@@ -12031,7 +12565,7 @@ function notFound2(params) {
 }
 function transactionLifecycleRefusal(params) {
   const { method } = params;
-  return new VibeError27({
+  return new VibeError28({
     code: "VIBE_VALIDATION",
     message: `${method}() is not available on a transaction client \u2014 the connection is owned by the open transaction; call it on the client that started the transaction`,
     meta: { method, inTransaction: true }
@@ -12039,7 +12573,7 @@ function transactionLifecycleRefusal(params) {
 }
 function viewIsReadOnly(params) {
   const { model, method } = params;
-  return new VibeError27({
+  return new VibeError28({
     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 }
@@ -12145,7 +12679,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 VibeError27({
+      throw new VibeError28({
         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" }
@@ -12221,6 +12755,7 @@ function runStatement(params) {
   return instrumentStatement({
     scope: engine.operation,
     legacy: legacySink({ engine }),
+    diagnose: engine.diagnostics?.observe,
     kind: params.kind,
     model: params.model,
     method: params.method,
@@ -12335,7 +12870,7 @@ class QueryPromise extends Promise {
   }
   #claim() {
     if (this.#started) {
-      throw new VibeError27({
+      throw new VibeError28({
         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)"
       });
@@ -12453,14 +12988,14 @@ function plan(params) {
     throw readOnlyRefusal({ path: `${model}.${method}`, reason: "raw" });
   if (args !== undefined && args["lock"] !== undefined) {
     if (engine.inTransaction !== true) {
-      throw new VibeError27({
+      throw new VibeError28({
         code: "VIBE_VALIDATION",
         message: `lock on ${model}.${method}() requires a transaction \u2014 call it on the client $transaction hands its callback (outside one, the lock would release at statement end)`,
         meta: { model, method }
       });
     }
     if (!LOCKABLE_METHODS.includes(method)) {
-      throw new VibeError27({
+      throw new VibeError28({
         code: "VIBE_VALIDATION",
         message: `lock on ${model}.${method}() is not supported \u2014 only ${LOCKABLE_METHODS.join(", ")} take a lock. ` + `Lock the rows with a find inside the transaction, then write them`,
         meta: { model, method }
@@ -12487,7 +13022,7 @@ function readAcquiredVerdict(params) {
     return true;
   if (value === false || value === 0 || value === "f" || value === "false" || value === "0")
     return false;
-  throw new VibeError27({
+  throw new VibeError28({
     code: "VIBE_INTERNAL",
     message: `internal: ${params.method}() expected a boolean "${ADVISORY_LOCK_RESULT_COLUMN}" column, got ${String(value)}`,
     meta: { method: params.method, value: String(value) }
@@ -12547,7 +13082,7 @@ async function insertedKeyWhere(params) {
   });
   const id = result.rows[0]?.id;
   if (id === undefined || id === null) {
-    throw new VibeError27({
+    throw new VibeError28({
       code: "VIBE_INTERNAL",
       message: `could not read back the generated key for ${source.model.name}`,
       meta: { model: source.model.name }
@@ -12723,10 +13258,17 @@ function relationExecutor(params) {
     });
   };
 }
+function relationConcurrency(params) {
+  const { engine } = params;
+  if (engine.inTransaction === true)
+    return 1;
+  return engine.options.relationLoading?.concurrency ?? 1;
+}
 async function finalizeRows(params) {
   const { engine, model, shape, rows } = params;
   if (shape.relations !== null && rows.length > 0) {
     const execute = relationExecutor({ engine });
+    const concurrency = relationConcurrency({ engine });
     if (shape.relationStrategy === "join") {
       await attachLateralRelations({
         dialect: engine.dialect,
@@ -12735,7 +13277,8 @@ async function finalizeRows(params) {
         rows,
         selection: shape.relations,
         execute,
-        wire: engine.adapter.wire
+        wire: engine.adapter.wire,
+        concurrency
       });
     } else {
       await attachRelations({
@@ -12745,7 +13288,8 @@ async function finalizeRows(params) {
         rows,
         selection: shape.relations,
         execute,
-        wire: engine.adapter.wire
+        wire: engine.adapter.wire,
+        concurrency
       });
     }
   }
@@ -12866,7 +13410,7 @@ function createDelegate(params) {
     const skipping = args.onConflict !== undefined;
     if (hasNestedWrites({ model: modelMeta, data: args.data })) {
       if (skipping) {
-        throw new VibeError27({
+        throw new VibeError28({
           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 }
@@ -12967,7 +13511,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 VibeError27({
+      throw new VibeError28({
         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 }
@@ -12975,7 +13519,7 @@ function createDelegate(params) {
     }
     if (!upsertUsesNativeStatement({ model: modelMeta, args })) {
       if (args.onConflict !== undefined) {
-        throw new VibeError27({
+        throw new VibeError28({
           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 }
@@ -13253,7 +13797,7 @@ function buildClient(params) {
     }
     for (const operation of operations) {
       if (!isQueryPromise(operation)) {
-        claimError = new VibeError27({
+        claimError = new VibeError28({
           code: "VIBE_VALIDATION",
           message: "$transaction([...]) takes query promises from model delegate calls \u2014 a foreign promise is already running and cannot join the transaction"
         });
@@ -13318,7 +13862,7 @@ function buildClient(params) {
     $models: models,
     $on: (event, listener) => {
       if (event !== "query") {
-        throw new VibeError27({
+        throw new VibeError28({
           code: "VIBE_VALIDATION",
           message: `unknown client event "${String(event)}" \u2014 supported: "query"`,
           meta: { event }
@@ -13333,7 +13877,7 @@ function buildClient(params) {
     $querySql: async ({ query, decoder }) => {
       assertEngineActive({ engine });
       if (decoder === null || typeof decoder !== "object" || typeof decoder.decode !== "function")
-        throw new VibeError27({ code: "VIBE_VALIDATION", message: "$querySql requires an explicit result decoder" });
+        throw new VibeError28({ code: "VIBE_VALIDATION", message: "$querySql requires an explicit result decoder" });
       const statement = compileSql({ dialect: engine.dialect, query });
       let output = [];
       await runRaw("$querySql", statement, (rows) => {
@@ -13377,6 +13921,7 @@ function buildClient(params) {
       assertEngineActive({ engine, requireContext: false });
       if (engine.inTransaction === true)
         throw transactionLifecycleRefusal({ method: "$disconnect" });
+      await engine.diagnostics?.flush();
       await engine.adapter.disconnect();
       await engine.telemetry?.flush();
     }
@@ -13409,7 +13954,7 @@ function buildClient(params) {
     });
   } else {
     const refuseLegacy = () => {
-      throw new VibeError27({ code: "VIBE_CONFIG", message: "Native row-level security cannot be combined with application policy or tenant scoping" });
+      throw new VibeError28({ 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) => {
@@ -13479,7 +14024,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 VibeError27({
+        throw new VibeError28({
           code: "VIBE_INTERNAL",
           message: `extension "${extension}" compiled a where with no model in scope`,
           meta: { extension }
@@ -13508,24 +14053,24 @@ function createMountSurface(params) {
         for (const key of path) {
           receiver = current;
           if (current === null || typeof current !== "object" && typeof current !== "function")
-            throw new VibeError27({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+            throw new VibeError28({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
           current = Reflect.get(current, key);
         }
         if (typeof current !== "function")
-          throw new VibeError27({ code: "VIBE_CONFIG", message: "Extension mount changed its method shape" });
+          throw new VibeError28({ 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 VibeError27({ code: "VIBE_CONFIG", message: "Native RLS extension mounts must expose plain objects and methods" });
+      throw new VibeError28({ 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 VibeError27({ code: "VIBE_CONFIG", message: "Native RLS extension mount accessors are unsupported" });
+        throw new VibeError28({ 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);
@@ -13542,7 +14087,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 VibeError27({
+        throw new VibeError28({
           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 }
@@ -13553,7 +14098,7 @@ function attachExtensionMounts(params) {
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
-      throw new VibeError27({
+      throw new VibeError28({
         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 }
@@ -13567,6 +14112,15 @@ function createClient(params) {
   const { schema, adapter, options, extensions, computed } = params;
   const dialectName = adapter.dialect;
   const telemetry = options?.telemetry === undefined ? undefined : createTelemetryRecorder({ options: options.telemetry });
+  resolveRelationConcurrency({ concurrency: options?.relationLoading?.concurrency });
+  const diagnosticsConfig = resolveStatementDiagnostics({
+    options: options?.diagnostics,
+    env: process.env[STATEMENT_DIAGNOSTICS_DEFAULTS.envVariable]
+  });
+  const diagnostics = diagnosticsConfig === undefined ? undefined : createStatementDiagnostics({ config: diagnosticsConfig, adapter, dialect: getSqlDialect5({ dialect: dialectName }) });
+  if (diagnosticsConfig !== undefined && diagnosticsConfig.explain === "analyze" && diagnosticsConfig.slowerThanMs < STATEMENT_DIAGNOSTICS_DEFAULTS.analyzeWarnBelowMs) {
+    console.warn(`[vibeorm] diagnostics: explain "analyze" with slowerThanMs ${diagnosticsConfig.slowerThanMs} re-executes every read statement under EXPLAIN ANALYZE \u2014 set a threshold, and never use this against production`);
+  }
   if (schema.rls !== undefined) {
     const dialect = getSqlDialect5({ dialect: dialectName });
     if (!dialect.capabilities.nativeRowLevelSecurity)
@@ -13579,9 +14133,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 VibeError27({ 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 VibeError28({ 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 VibeError27({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
+      throw new VibeError28({ code: "VIBE_CONFIG", message: "Server native row-level security must use the runtime login role, not a runtimeRole switch" });
     }
   }
   if (extensions?.manifest !== undefined) {
@@ -13591,7 +14145,7 @@ function createClient(params) {
     assertComputedManifest({ manifest: computed.manifest, specs: computed.specs });
   }
   if (computed === undefined && options !== undefined && options["computed"] !== undefined) {
-    throw new VibeError27({
+    throw new VibeError28({
       code: "VIBE_CONFIG",
       message: "this client was generated without computed fields \u2014 declare them in vibeorm.config.ts and re-run vibeorm generate",
       meta: {}
@@ -13616,15 +14170,16 @@ function createClient(params) {
       listeners: new Set,
       renderCache: new StatementRenderCache,
       ...telemetry === undefined ? {} : { telemetry },
+      ...diagnostics === undefined ? {} : { diagnostics },
       ...extensions?.mounts === undefined ? {} : { extensionMounts: extensions.mounts },
       ...connectHooks.length === 0 ? {} : { connectHooks }
     }
   });
 }
 // packages/runtime/src/keyset-iterator.ts
-import { VibeError as VibeError28 } from "@vibeorm/schema";
+import { VibeError as VibeError29 } from "@vibeorm/schema";
 function validation(params) {
-  return new VibeError28({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
+  return new VibeError29({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function projectionFor(params) {
   const { plan: plan2, select, omit } = params;
@@ -13701,7 +14256,7 @@ function iterateKeyset(options) {
       });
       if (advanced === false) {
         stop();
-        throw new VibeError28({
+        throw new VibeError29({
           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" }
@@ -13774,7 +14329,7 @@ function iterateKeyset(options) {
   return iterator;
 }
 // packages/runtime/src/telemetry/collector.ts
-import { VibeError as VibeError29 } from "@vibeorm/schema";
+import { VibeError as VibeError30 } from "@vibeorm/schema";
 function createTelemetryCollector(params) {
   const throwOn = new Set(params?.throwOn ?? []);
   const operations = [];
@@ -13784,7 +14339,7 @@ function createTelemetryCollector(params) {
   let shutdowns = 0;
   const hostile = (phase) => {
     if (throwOn.has(phase)) {
-      throw new VibeError29({
+      throw new VibeError30({
         code: "VIBE_INTERNAL",
         message: `telemetry collector: deliberate ${phase} failure`,
         meta: { reason: "telemetry-collector-deliberate-failure", phase }
@@ -13840,7 +14395,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 VibeError29({
+        throw new VibeError30({
           code: "VIBE_VALIDATION",
           message: `telemetry collector: ${matches.length} operations match ${lookup.model ?? "*"}.${lookup.method}`,
           meta: {
@@ -13860,10 +14415,12 @@ export {
   updateWithNested,
   toSqlExecutor,
   toClientName,
+  summarizePlan,
   sqlProjection,
   sql2 as sql,
   rewriteScopedCall,
   resolveTelemetryConfig,
+  resolveStatementDiagnostics,
   resolveScopedModels,
   resolveResultShape,
   resolveRelationSelection,
@@ -13874,12 +14431,14 @@ export {
   queryFingerprint,
   previewOperation,
   parsePostgresPlan,
+  parseDiagnosticsEnv,
   parameterTypeTag,
   normalizeSql,
   lateralColumnAlias,
   keysetRowValues,
   keysetRowIsAfter,
   iterateKeyset,
+  isExecutableRead,
   isDbNow,
   inspectNativeRlsTransaction,
   inspectNativeRls,
@@ -13893,9 +14452,11 @@ export {
   generateNanoid,
   generateDefaultValue,
   generateCuid,
+  formatStatementDiagnostic,
   formatNativeRlsReport,
   explainSql,
   explainOperation,
+  explainOnSession,
   encodeValue,
   encodeKeysetToken,
   delegateMethodAccess,
@@ -13911,6 +14472,7 @@ export {
   createView,
   createTelemetryRecorder,
   createTelemetryCollector,
+  createStatementDiagnostics,
   createSqlModel,
   createScopeRewriter,
   createClient,
@@ -13942,6 +14504,7 @@ export {
   WRITE_DELEGATE_METHODS,
   ViewResult,
   TELEMETRY_DEFAULTS,
+  STATEMENT_DIAGNOSTICS_DEFAULTS,
   SQLITE_CODECS,
   SKIP,
   READ_DELEGATE_METHODS,
@@ -13958,4 +14521,4 @@ export {
   CLIENT_MEMBER_ACCESS
 };
 
-//# debugId=89575B8D7F621EF764756E2164756E21
+//# debugId=66C6E11BD1A77F7364756E2164756E21