@vibeorm/runtime 2.3.0 → 2.4.0

package/dist/index.js

@@ -165,8 +165,8 @@ function compileAdvisoryLock(params) {
   }
   const mode = readMode({ value: request.mode, method });
   if (hasSingle) {
-    const key2 = { key: readInt64({ value: request.key, method }) };
-    return statementFor({ method, mode, key: key2 });
+    const key = { key: readInt64({ value: request.key, method }) };
+    return statementFor({ method, mode, key });
   }
   if (!("classId" in request) || !("objectId" in request)) {
     throw validationError({
@@ -611,20 +611,20 @@ function wirePlanKey(wire) {
 }
 function fieldDecoder(params) {
   const { dialect, field, wire } = params;
-  const decode2 = fieldCodec({ dialect, field }).decode;
+  const decode = fieldCodec({ dialect, field }).decode;
   if (isPostgresEnumList({ dialect, field })) {
     return (value) => decodeValue({ dialect, field, value });
   }
-  if (decode2 === IDENTITY_DECODE)
+  if (decode === IDENTITY_DECODE)
     return null;
   if (field.isList) {
     if (field.scalarType === "Json" && decodeIsNoop({ scalarType: "Json", wire }))
       return null;
-    return (value) => Array.isArray(value) ? value.map((element) => element === null || element === undefined ? element : decode2(element)) : decode2(value);
+    return (value) => Array.isArray(value) ? value.map((element) => element === null || element === undefined ? element : decode(element)) : decode(value);
   }
   if (field.scalarType !== null && decodeIsNoop({ scalarType: field.scalarType, wire }))
     return null;
-  return decode2;
+  return decode;
 }
 function buildDecodePlan(params) {
   const { dialect, model, wire } = params;
@@ -632,12 +632,12 @@ function buildDecodePlan(params) {
   const inPlace = [];
   const renamedColumns = [];
   for (const field of model.fields) {
-    const decode2 = fieldDecoder({ dialect, field, ...wire === undefined ? {} : { wire } });
-    byColumn.set(field.columnName, { name: field.name, decode: decode2 });
+    const decode = fieldDecoder({ dialect, field, ...wire === undefined ? {} : { wire } });
+    byColumn.set(field.columnName, { name: field.name, decode });
     if (field.columnName !== field.name)
       renamedColumns.push(field.columnName);
-    if (decode2 !== null)
-      inPlace.push({ column: field.columnName, decode: decode2 });
+    if (decode !== null)
+      inPlace.push({ column: field.columnName, decode });
   }
   return { byColumn, renamedColumns, decoders: inPlace, inPlace: renamedColumns.length > 0 ? null : inPlace };
 }
@@ -764,12 +764,12 @@ function getJsonDecodePlan(model) {
   const inPlace = [];
   const renamedColumns = [];
   for (const field of model.fields) {
-    const decode2 = field.scalarType === "Json" ? null : field.scalarType === "Bytes" && !field.isList ? decodeBase64Bytes : fieldDecoder({ dialect: "postgres", field });
-    byColumn.set(field.columnName, { name: field.name, decode: decode2 });
+    const decode = field.scalarType === "Json" ? null : field.scalarType === "Bytes" && !field.isList ? decodeBase64Bytes : fieldDecoder({ dialect: "postgres", field });
+    byColumn.set(field.columnName, { name: field.name, decode });
     if (field.columnName !== field.name)
       renamedColumns.push(field.columnName);
-    if (decode2 !== null)
-      inPlace.push({ column: field.columnName, decode: decode2 });
+    if (decode !== null)
+      inPlace.push({ column: field.columnName, decode });
   }
   plan = { byColumn, renamedColumns, decoders: inPlace, inPlace: renamedColumns.length > 0 ? null : inPlace };
   jsonDecodePlanCache.set(model, plan);
@@ -2616,7 +2616,7 @@ function compileOperatorFilter(params) {
   }
   const insensitive = mode === "insensitive";
   const strict = mode === "strict";
-  const ciCollated = (params2) => params2.dialect.name === "mysql" && params2.field.collation?.toLowerCase().endsWith("_ci") === true;
+  const ciCollated = (params) => params.dialect.name === "mysql" && params.field.collation?.toLowerCase().endsWith("_ci") === true;
   const requireStringOperand = (operator, operand) => {
     if (typeof operand !== "string") {
       throw validationError4({
@@ -2903,13 +2903,13 @@ function compileRelationFilter(params) {
         meta: { model: model.name, relation: relation.name }
       });
     }
-    const conditions2 = [];
+    const conditions = [];
     for (const [operator, operand] of Object.entries(value)) {
       if (operand === undefined)
         continue;
       switch (operator) {
         case "some":
-          conditions2.push(buildRelationExists({
+          conditions.push(buildRelationExists({
             ctx,
             link,
             outer,
@@ -2917,7 +2917,7 @@ function compileRelationFilter(params) {
           }));
           break;
         case "none":
-          conditions2.push(buildRelationExists({
+          conditions.push(buildRelationExists({
             ctx,
             link,
             outer,
@@ -2926,7 +2926,7 @@ function compileRelationFilter(params) {
           }));
           break;
         case "every":
-          conditions2.push(buildRelationExists({
+          conditions.push(buildRelationExists({
             ctx,
             link,
             outer,
@@ -2942,15 +2942,15 @@ function compileRelationFilter(params) {
           });
       }
     }
-    if (conditions2.length === 0) {
+    if (conditions.length === 0) {
       throw validationError4({
         message: `filter on relation ${model.name}.${relation.name} must contain some, every or none`,
         meta: { model: model.name, relation: relation.name }
       });
     }
-    if (conditions2.length === 1)
-      return conditions2[0];
-    return { kind: "and", operands: conditions2 };
+    if (conditions.length === 1)
+      return conditions[0];
+    return { kind: "and", operands: conditions };
   }
   let isArm;
   let hasIs = false;
@@ -3145,17 +3145,17 @@ function compileRelationOrderTerms(params) {
           meta: { model: model.name, relation: relation.name }
         });
       }
-      const direction2 = requireDirection(value, `orderBy.${relation.name}._count`);
-      const alias2 = `__ord${++aliasSeq.n}`;
+      const direction = requireDirection(value, `orderBy.${relation.name}._count`);
+      const alias = `__ord${++aliasSeq.n}`;
       const select = link.kind === "manyToMany" ? {
         kind: "select",
-        table: { name: link.join.tableName, alias: alias2 },
+        table: { name: link.join.tableName, alias },
         columns: [],
         selectExpr: { kind: "countAll" },
         where: {
           kind: "cmpCol",
           op: "eq",
-          left: { table: alias2, name: link.join.parentColumn },
+          left: { table: alias, name: link.join.parentColumn },
           right: {
             table: outer,
             name: singleKeyPair({ link, what: "implicit many-to-many ordering" }).parent.columnName
@@ -3163,12 +3163,12 @@ function compileRelationOrderTerms(params) {
         }
       } : {
         kind: "select",
-        table: { name: link.target.tableName, alias: alias2 },
+        table: { name: link.target.tableName, alias },
         columns: [],
         selectExpr: { kind: "countAll" },
-        where: correlateLink({ link, childTable: alias2, outerTable: outer })
+        where: correlateLink({ link, childTable: alias, outerTable: outer })
       };
-      terms.push({ select, direction: direction2 });
+      terms.push({ select, direction });
       continue;
     }
     if (isList) {
@@ -3576,7 +3576,7 @@ function compileUpdateSet(params) {
       });
     }
     if (isPlainObject3(value) && field.scalarType !== "Json") {
-      const entries = Object.entries(value).filter(([, operand2]) => operand2 !== undefined);
+      const entries = Object.entries(value).filter(([, operand]) => operand !== undefined);
       if (entries.length !== 1) {
         throw validationError4({
           message: `update of ${model.name}.${field.name} must use exactly one operation`,
@@ -4134,7 +4134,7 @@ function buildFindShape(params) {
       },
       ...where === undefined ? {} : { where }
     };
-    const statement2 = {
+    const statement = {
       kind: "select",
       table: { name: DISTINCT_TABLE_ALIAS },
       columns: projectionColumns({ model, selectedFields }),
@@ -4144,7 +4144,7 @@ function buildFindShape(params) {
       ...limit === undefined ? {} : { limit },
       ...offset === undefined ? {} : { offset }
     };
-    return { statement: statement2, reverseRows: backward, resortBy };
+    return { statement, reverseRows: backward, resortBy };
   }
   if (distinctOuterOrder !== null) {
     const inner = {
@@ -4160,7 +4160,7 @@ function buildFindShape(params) {
       ...projectionColumns({ model, selectedFields }),
       ...lateralJoins.map((join) => ({ name: join.columnAlias }))
     ];
-    const statement2 = {
+    const statement = {
       kind: "select",
       table: { name: DISTINCT_TABLE_ALIAS },
       columns: outerColumns,
@@ -4169,7 +4169,7 @@ function buildFindShape(params) {
       ...limit === undefined ? {} : { limit },
       ...offset === undefined ? {} : { offset }
     };
-    return { statement: statement2, reverseRows: backward, resortBy };
+    return { statement, reverseRows: backward, resortBy };
   }
   const pageFirst = lateralJoins.length > 0 && (limit !== undefined || offset !== undefined) && orderTerms.every((term) => ("column" in term));
   if (pageFirst && selection !== undefined) {
@@ -4185,7 +4185,7 @@ function buildFindShape(params) {
       ...limit === undefined ? {} : { limit },
       ...offset === undefined ? {} : { offset }
     };
-    const statement2 = {
+    const statement = {
       kind: "select",
       table: { name: model.tableName },
       columns,
@@ -4193,7 +4193,7 @@ function buildFindShape(params) {
       lateralJoins,
       ...orderTerms.length === 0 ? {} : { orderBy: orderTerms }
     };
-    return { statement: statement2, reverseRows: backward, resortBy };
+    return { statement, reverseRows: backward, resortBy };
   }
   const statement = {
     kind: "select",
@@ -4618,9 +4618,9 @@ function compileGroupByOrder(params) {
             }
             agg = { fn: "countAll" };
           } else {
-            const field2 = getFieldMeta({ model, field: selector, context: `orderBy ${name}` });
-            validateAggregatedField({ model, field: field2, key });
-            const aggColumn = key === "_count" ? { name: field2.columnName } : compareColumnRef({ dialect, field: field2 });
+            const field = getFieldMeta({ model, field: selector, context: `orderBy ${name}` });
+            validateAggregatedField({ model, field, key });
+            const aggColumn = key === "_count" ? { name: field.columnName } : compareColumnRef({ dialect, field });
             agg = { fn: AGG_FN_BY_KEY[key], column: aggColumn };
           }
           terms.push({ agg, direction });
@@ -5070,7 +5070,7 @@ function buildQuery(params) {
             throw validationError4({ message: "A conflict update requires an explicit target" });
           const updates = requireObject({ value: spec.update, what: "onConflict.update", model });
           const fields = resolveUpsertUpdateFields({ model, update: Object.keys(updates), targetColumns: new Set(compiled.columns ?? []), skipUpdatedAt: true });
-          const columns2 = Object.fromEntries(model.fields.map((field) => [field.name, field.columnName]));
+          const columns = Object.fromEntries(model.fields.map((field) => [field.name, field.columnName]));
           conflictClause = {
             columns: compiled.columns ?? [],
             ...compiled.constraint === undefined ? {} : { constraint: compiled.constraint },
@@ -5079,7 +5079,7 @@ function buildQuery(params) {
               const fragment = updates[field.name];
               if (!isSqlFragment(fragment))
                 throw validationError4({ message: "Conflict update expressions must be constructed SQL fragments" });
-              return [field.columnName, mapConflictColumns({ fragment, columns: columns2 })];
+              return [field.columnName, mapConflictColumns({ fragment, columns })];
             }))
           };
         } else
@@ -6981,7 +6981,7 @@ function requirePostgres(params) {
   return getSqlDialect2({ dialect: params.dialect });
 }
 async function explainSql(params) {
-  const { executor, sql: sql2, rlsContext } = params;
+  const { executor, sql, rlsContext } = params;
   const mode = params.mode ?? "estimate";
   const dialect = requirePostgres({ dialect: params.dialect });
   const warnings = [];
@@ -6998,7 +6998,7 @@ async function explainSql(params) {
         meta: { mode }
       });
     }
-    assertExecutableRead({ text: sql2.text });
+    assertExecutableRead({ text: sql.text });
     warnings.push("this statement was EXECUTED to produce observed rows and milliseconds; a read-only transaction and a keyword check are not a proof of safety, because a SELECT can call a function with side effects");
   }
   const contextKeys = rlsContext === undefined ? [] : Object.keys(rlsContext);
@@ -7014,7 +7014,7 @@ async function explainSql(params) {
     const report = await explainOnSession({
       executor,
       dialect: params.dialect,
-      sql: sql2,
+      sql,
       mode,
       warnings,
       ...rlsContext === undefined ? {} : { rlsContext },
@@ -7033,7 +7033,7 @@ async function explainSql(params) {
   }
 }
 async function explainOnSession(params) {
-  const { executor, sql: sql2, mode, rlsContext } = params;
+  const { executor, sql, mode, rlsContext } = params;
   const dialect = requirePostgres({ dialect: params.dialect });
   const warnings = params.warnings ?? [];
   const contextKeys = rlsContext === undefined ? [] : Object.keys(rlsContext);
@@ -7061,7 +7061,7 @@ async function explainOnSession(params) {
   }
   const explain = renderPostgresExplain({
     dialect,
-    query: { text: sql2.text, values: [...sql2.values], returning: "none" },
+    query: { text: sql.text, values: [...sql.values], returning: "none" },
     options: mode === "analyze" ? { analyze: true, buffers: true } : {}
   });
   const rows = await run(explain);
@@ -7288,7 +7288,7 @@ function createStatementDiagnostics(params) {
         text: query.text,
         values: (query.values ?? []).map((value) => Array.isArray(value) ? tx.formatArrayParam(value) : value)
       });
-      const report2 = await explainOnSession({
+      const report = await explainOnSession({
         executor,
         dialect: dialect.name,
         sql: { text: statement.text, values: statement.values },
@@ -7297,11 +7297,11 @@ function createStatementDiagnostics(params) {
       });
       return summarizePlan({
         plan: {
-          root: report2.root,
-          nodeCount: report2.nodeCount,
-          truncated: report2.truncated,
-          ...report2.planningTimeMs === undefined ? {} : { planningTimeMs: report2.planningTimeMs },
-          ...report2.executionTimeMs === undefined ? {} : { executionTimeMs: report2.executionTimeMs }
+          root: report.root,
+          nodeCount: report.nodeCount,
+          truncated: report.truncated,
+          ...report.planningTimeMs === undefined ? {} : { planningTimeMs: report.planningTimeMs },
+          ...report.executionTimeMs === undefined ? {} : { executionTimeMs: report.executionTimeMs }
         },
         mode
       });
@@ -7650,13 +7650,13 @@ function recommendFromPlan(params) {
           candidate: false
         });
       } else {
-        const removed2 = node.rowsRemovedByFilter;
+        const removed = node.rowsRemovedByFilter;
         findings.push({
           code: "sequential-scan-on-large-table",
           severity: "warn",
           node: node.nodeType,
           relation,
-          evidence: `sequential scan over "${relation}" (about ${facts.estimatedRows} rows, planner cost ${node.estimatedTotalCost} cost units)` + (removed2 === undefined ? "" : `, discarding ${removed2} rows by filter`) + (node.actualRows === undefined ? "" : `, returning ${node.actualRows}`),
+          evidence: `sequential scan over "${relation}" (about ${facts.estimatedRows} rows, planner cost ${node.estimatedTotalCost} cost units)` + (removed === undefined ? "" : `, discarding ${removed} rows by filter`) + (node.actualRows === undefined ? "" : `, returning ${node.actualRows}`),
           candidate: true,
           indexCandidate: {
             table: relation,
@@ -8207,8 +8207,8 @@ async function loadManyToMany(params) {
   for (const pair of pairs) {
     const rawParent = pair[M2M_PARENT_ALIAS];
     delete pair[M2M_PARENT_ALIAS];
-    const parentKey2 = decodeParent === null || rawParent === null || rawParent === undefined ? rawParent : decodeParent(rawParent);
-    const key = relationValueKey({ value: parentKey2 });
+    const parentKey = decodeParent === null || rawParent === null || rawParent === undefined ? rawParent : decodeParent(rawParent);
+    const key = relationValueKey({ value: parentKey });
     const group = groups.get(key);
     if (group === undefined)
       groups.set(key, [pair]);
@@ -8403,10 +8403,10 @@ async function attachLateralRelations(params) {
     for (const row of rows) {
       const raw = row[column];
       delete row[column];
-      let parsed2 = raw;
+      let parsed = raw;
       if (typeof raw === "string") {
         try {
-          parsed2 = JSON.parse(raw);
+          parsed = JSON.parse(raw);
         } catch (cause) {
           throw new VibeError19({
             code: "VIBE_INTERNAL",
@@ -8417,10 +8417,10 @@ async function attachLateralRelations(params) {
         }
       }
       if (isList) {
-        if (!Array.isArray(parsed2)) {
+        if (!Array.isArray(parsed)) {
           throw new VibeError19({ code: "VIBE_INTERNAL", message: "to-many relation payload must be an array", meta: { relation: node.name } });
         }
-        const children = parsed2.map(decodePosition);
+        const children = parsed.map(decodePosition);
         for (const child of children) {
           for (const name of hiddenOrder)
             delete child[name];
@@ -8428,11 +8428,11 @@ async function attachLateralRelations(params) {
         row[node.name] = children;
         pushAll(kept, children);
       } else {
-        if (parsed2 === null) {
+        if (parsed === null) {
           row[node.name] = null;
           continue;
         }
-        const child = decodePosition(parsed2);
+        const child = decodePosition(parsed);
         for (const name of hiddenOrder)
           delete child[name];
         row[node.name] = child;
@@ -8497,13 +8497,13 @@ function containsSqlFragment(value, seen = new Set) {
   return false;
 }
 function restrictedSqlArgs(params) {
-  const refuse2 = () => params.refusal?.() ?? new VibeError20({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
+  const refuse = () => params.refusal?.() ?? new VibeError20({ code: "VIBE_VALIDATION", message: `SQL fragments are unavailable through ${params.path}; use the unrestricted client`, meta: { path: params.path } });
   if (containsSqlFragment(params.value))
-    throw refuse2();
+    throw refuse();
   const seen = new Map;
   const copy = (value) => {
     if (isSqlFragment2(value))
-      throw refuse2();
+      throw refuse();
     if (typeof value !== "object" || value === null)
       return value;
     if (seen.has(value))
@@ -8796,9 +8796,9 @@ function mergeLevel(params) {
       continue;
     }
     if (spec === true) {
-      const child2 = mergeLevel({ meta, name, definition, mask: targetMask, args: {} });
-      select[relationName] = child2.merged;
-      relationPlans.set(relationName, child2.plan);
+      const child = mergeLevel({ meta, name, definition, mask: targetMask, args: {} });
+      select[relationName] = child.merged;
+      relationPlans.set(relationName, child.plan);
       continue;
     }
     if (!isPlainObject5(spec)) {
@@ -9014,12 +9014,12 @@ function validateNestedVerbs(params) {
       return value;
     if (!arms.some((arm) => value[arm] !== undefined))
       return one(value);
-    const next2 = { ...value };
+    const next = { ...value };
     for (const arm of arms) {
       if (value[arm] !== undefined)
-        next2[arm] = many(value[arm]);
+        next[arm] = many(value[arm]);
     }
-    return next2;
+    return next;
   };
   const eachBody = (value, arms) => Array.isArray(value) ? value.map((item) => body(item, arms)) : body(value, arms);
   const next = { ...verbs };
@@ -9521,20 +9521,20 @@ function scopeSelection(params) {
       if (spec === undefined || spec === false)
         continue;
       if (name === "_count") {
-        const names = spec === true ? model.relations.filter((relation2) => relation2.isList).map((relation2) => relation2.name) : isPlainObject7(spec) && isPlainObject7(spec.select) ? Object.keys(spec.select).filter((key2) => {
-          const entry = spec.select[key2];
+        const names = spec === true ? model.relations.filter((relation) => relation.isList).map((relation) => relation.name) : isPlainObject7(spec) && isPlainObject7(spec.select) ? Object.keys(spec.select).filter((key) => {
+          const entry = spec.select[key];
           return entry === true || isPlainObject7(entry);
         }) : [];
         const countSelect = isPlainObject7(spec) && isPlainObject7(spec.select) ? { ...spec.select } : undefined;
         for (const counted of names) {
-          const relation2 = model.relationByName.get(counted);
-          const target2 = relation2 === undefined ? undefined : meta.modelByName.get(relation2.targetModel);
-          if (target2?.policy !== undefined) {
+          const relation = model.relationByName.get(counted);
+          const target = relation === undefined ? undefined : meta.modelByName.get(relation.targetModel);
+          if (target?.policy !== undefined) {
             throw policyError(`_count of ${model.name}.${counted} cannot enforce @@policy because relation counts take no filter \u2014 use a scoped child count query instead`, { model: model.name, relation: counted });
           }
           const entry = countSelect?.[counted];
-          if (target2 !== undefined && countSelect !== undefined && isPlainObject7(entry) && entry.where !== undefined) {
-            countSelect[counted] = { ...entry, where: scopeWhere({ meta, model: target2, where: entry.where, context }) };
+          if (target !== undefined && countSelect !== undefined && isPlainObject7(entry) && entry.where !== undefined) {
+            countSelect[counted] = { ...entry, where: scopeWhere({ meta, model: target, where: entry.where, context }) };
           }
         }
         if (countSelect !== undefined)
@@ -9627,8 +9627,8 @@ function forceWriteData(params) {
 }
 function forceNestedVerbs(params) {
   const { meta, target, verbs, context } = params;
-  const walk2 = (row, phase) => isPlainObject7(row) ? forceWriteData({ meta, model: target, data: row, context, phase }) : row;
-  const each = (value, phase) => Array.isArray(value) ? value.map((row) => walk2(row, phase)) : walk2(value, phase);
+  const walk = (row, phase) => isPlainObject7(row) ? forceWriteData({ meta, model: target, data: row, context, phase }) : row;
+  const each = (value, phase) => Array.isArray(value) ? value.map((row) => walk(row, phase)) : walk(value, phase);
   const body = (value, keys) => {
     if (!isPlainObject7(value))
       return value;
@@ -9705,7 +9705,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 VibeError24({ code: "VIBE_NOT_FOUND", message: `${method} on ${model.name}: no row matches the unique where inside the bound policy context`, meta: { model: model.name, method } });
+  const notFound = (method) => new VibeError24({ code: "VIBE_NOT_FOUND", message: `${method} on ${model.name}: no row matches the unique where inside the bound policy context`, meta: { model: model.name, method } });
   return {
     findMany: (args) => base.findMany(scopeFind(args)),
     findFirst: (args) => base.findFirst(scopeFind(args)),
@@ -9724,9 +9724,9 @@ function scopedDelegate(params) {
     update: (args) => defer(async (tx) => {
       const raw = tx.$bypassPolicy === undefined ? tx : tx.$bypassPolicy();
       const data = writeData(args.data, "update");
-      const row = await lockThen(raw, args, (raw2, pkWhere) => raw2.$models[model.name].update({ ...scopeWrite(args), data, where: pkWhere }));
+      const row = await lockThen(raw, args, (raw, pkWhere) => raw.$models[model.name].update({ ...scopeWrite(args), data, where: pkWhere }));
       if (row === null)
-        throw notFound2("update");
+        throw notFound("update");
       return row;
     }),
     updateMany: (args) => deferred(() => base.updateMany({
@@ -9769,16 +9769,16 @@ function scopedDelegate(params) {
       const update = writeData(args.update, "update");
       const create = writeData(args.create, "create");
       const projection = scopeWrite(Object.fromEntries(["select", "include"].flatMap((key) => args[key] === undefined ? [] : [[key, args[key]]])));
-      const row = await lockThen(raw, args, (raw2, pkWhere) => raw2.$models[model.name].update({ ...projection, where: pkWhere, data: update }));
+      const row = await lockThen(raw, args, (raw, pkWhere) => raw.$models[model.name].update({ ...projection, where: pkWhere, data: update }));
       if (row !== null)
         return row;
       return await raw.$models[model.name].create({ ...projection, data: create });
     }),
     delete: (args) => defer(async (tx) => {
       const raw = tx.$bypassPolicy === undefined ? tx : tx.$bypassPolicy();
-      const row = await lockThen(raw, args, (raw2, pkWhere) => raw2.$models[model.name].delete({ ...scopeWrite(args), where: pkWhere }));
+      const row = await lockThen(raw, args, (raw, pkWhere) => raw.$models[model.name].delete({ ...scopeWrite(args), where: pkWhere }));
       if (row === null)
-        throw notFound2("delete");
+        throw notFound("delete");
       return row;
     }),
     deleteMany: (args) => deferred(() => base.deleteMany({
@@ -10589,7 +10589,7 @@ function walkNestedVerbs(params) {
   const mode = nestedModeFor(targetEntry);
   const out = { ...verbs };
   const pred = (verbPath) => requirePred({ ctx, model: target, path: verbPath });
-  const refuse2 = (verb, why) => {
+  const refuse = (verb, why) => {
     throw refusal({
       model: target.name,
       path: `${path}.${verb}`,
@@ -10618,7 +10618,7 @@ function walkNestedVerbs(params) {
       continue;
     }
     if (scoped && mode === "refuse" && REFERENCE_VERBS2.includes(verb)) {
-      refuse2(verb, `is disabled \u2014 ${target.name} is configured nested: "refuse"; go through the base client or its own delegate`);
+      refuse(verb, `is disabled \u2014 ${target.name} is configured nested: "refuse"; go through the base client or its own delegate`);
     }
     switch (verb) {
       case "connect":
@@ -10633,9 +10633,9 @@ function walkNestedVerbs(params) {
         if (scoped) {
           const kind = link().kind;
           if (kind === "manyToMany")
-            refuse2(verb, "clears the whole join set \u2014 unlinking other tenants' rows cannot be verified; disconnect explicit rows instead");
+            refuse(verb, "clears the whole join set \u2014 unlinking other tenants' rows cannot be verified; disconnect explicit rows instead");
           if (!implicitSafe)
-            refuse2(verb, "first detaches EVERY current child, which cannot be tenant-filtered on this edge; disconnect explicit rows instead");
+            refuse(verb, "first detaches EVERY current child, which cannot be tenant-filtered on this edge; disconnect explicit rows instead");
         }
         out[verb] = mapItems(operand ?? [], (item) => isPlainObject8(item) ? uniqueWhere(item, verbPath) : item);
         break;
@@ -10646,10 +10646,10 @@ function walkNestedVerbs(params) {
             const kind = link().kind;
             if (kind === "toOneOwner") {
               if (tenancyEdge) {
-                refuse2(verb, "would orphan the row out of its tenant (through-parent set to null) \u2014 delete it or connect a replacement");
+                refuse(verb, "would orphan the row out of its tenant (through-parent set to null) \u2014 delete it or connect a replacement");
               }
             } else if (!implicitSafe) {
-              refuse2(verb, "targets whatever row currently points here \u2014 not tenant-verifiable on this edge");
+              refuse(verb, "targets whatever row currently points here \u2014 not tenant-verifiable on this edge");
             }
           }
           break;
@@ -10660,7 +10660,7 @@ function walkNestedVerbs(params) {
       case "delete": {
         if (!relation.isList) {
           if (scoped && !implicitSafe) {
-            refuse2(verb, "targets whatever row is currently connected \u2014 not tenant-verifiable on this edge");
+            refuse(verb, "targets whatever row is currently connected \u2014 not tenant-verifiable on this edge");
           }
           break;
         }
@@ -10670,7 +10670,7 @@ function walkNestedVerbs(params) {
       case "update": {
         if (!relation.isList) {
           if (scoped && !implicitSafe) {
-            refuse2(verb, "targets whatever row is currently connected \u2014 not tenant-verifiable on this edge; update it through its own delegate");
+            refuse(verb, "targets whatever row is currently connected \u2014 not tenant-verifiable on this edge; update it through its own delegate");
           }
           out[verb] = isPlainObject8(operand) ? "data" in operand && isPlainObject8(operand.data) ? { ...operand, data: walkChildUpdate(operand.data, verbPath) } : walkChildUpdate(operand, verbPath) : operand;
           break;
@@ -10687,7 +10687,7 @@ function walkNestedVerbs(params) {
       case "upsert": {
         if (!relation.isList) {
           if (scoped && !implicitSafe) {
-            refuse2(verb, "updates whatever row is currently connected \u2014 not tenant-verifiable on this edge");
+            refuse(verb, "updates whatever row is currently connected \u2014 not tenant-verifiable on this edge");
           }
           out[verb] = isPlainObject8(operand) ? {
             ...operand,
@@ -10756,9 +10756,9 @@ function rewriteScopedCall(params) {
     case "findUniqueOrThrow": {
       walkSelection({ ctx, model, args, path: root });
       if (!scoped) {
-        const walked2 = walkOwnWhere(args.where, `${root}.where`);
-        if (walked2 !== undefined)
-          args.where = walked2;
+        const walked = walkOwnWhere(args.where, `${root}.where`);
+        if (walked !== undefined)
+          args.where = walked;
         return { model: model.name, method, args };
       }
       const flat = isPlainObject8(args.where) ? flattenUniqueWhere({ model, where: args.where }) : args.where;
@@ -11570,186 +11570,186 @@ class StatementRenderCache {
     this.entries.set(key, slot);
   }
 }
-function addIdent(walk2, name) {
-  walk2.key += `\xA7${name.length}~${name}`;
+function addIdent(walk, name) {
+  walk.key += `\xA7${name.length}~${name}`;
 }
-function addCol(walk2, column) {
+function addCol(walk, column) {
   if (column.table !== undefined)
-    addIdent(walk2, column.table);
-  walk2.key += ".";
-  addIdent(walk2, column.name);
+    addIdent(walk, column.table);
+  walk.key += ".";
+  addIdent(walk, column.name);
   if (column.transform !== undefined)
-    walk2.key += column.transform === "castText" ? "^t" : "^b";
+    walk.key += column.transform === "castText" ? "^t" : "^b";
   if (column.castReal === true)
-    walk2.key += "^r";
+    walk.key += "^r";
   if (column.alias !== undefined) {
-    walk2.key += "^a";
-    addIdent(walk2, column.alias);
+    walk.key += "^a";
+    addIdent(walk, column.alias);
   }
 }
-function addTable(walk2, table) {
-  addIdent(walk2, table.name);
+function addTable(walk, table) {
+  addIdent(walk, table.name);
   if (table.alias !== undefined) {
-    walk2.key += "@";
-    addIdent(walk2, table.alias);
+    walk.key += "@";
+    addIdent(walk, table.alias);
   }
 }
-function addAgg(walk2, agg) {
-  walk2.key += agg.fn;
+function addAgg(walk, agg) {
+  walk.key += agg.fn;
   if (agg.fn !== "countAll")
-    addCol(walk2, agg.column);
+    addCol(walk, agg.column);
 }
-function addSetEntry(walk2, name, value) {
+function addSetEntry(walk, name, value) {
   if (isJsonParamCell(value)) {
-    walk2.key += "=j";
-    addIdent(walk2, name);
-    walk2.values.push(value.text);
+    walk.key += "=j";
+    addIdent(walk, name);
+    walk.values.push(value.text);
     return;
   }
   if (isSetOperation(value)) {
-    walk2.key += `=o${value.__op}`;
-    addIdent(walk2, name);
-    walk2.values.push(value.value);
+    walk.key += `=o${value.__op}`;
+    addIdent(walk, name);
+    walk.values.push(value.value);
     return;
   }
   if (isDbNowMarker(value)) {
-    walk2.key += value.offsetSeconds === 0 ? "=N0" : "=N1";
-    addIdent(walk2, name);
+    walk.key += value.offsetSeconds === 0 ? "=N0" : "=N1";
+    addIdent(walk, name);
     if (value.offsetSeconds !== 0)
-      walk2.values.push(value.offsetSeconds);
+      walk.values.push(value.offsetSeconds);
     return;
   }
   if (isListSetOperation(value)) {
-    walk2.key += `=l${value.__listOp}`;
-    addIdent(walk2, name);
-    walk2.values.push(value.value);
+    walk.key += `=l${value.__listOp}`;
+    addIdent(walk, name);
+    walk.values.push(value.value);
     return;
   }
-  walk2.key += "=v";
-  addIdent(walk2, name);
-  walk2.values.push(value);
+  walk.key += "=v";
+  addIdent(walk, name);
+  walk.values.push(value);
 }
-function addReturning(walk2, returning) {
+function addReturning(walk, returning) {
   if (returning === undefined || returning.length === 0) {
-    walk2.key += "r0";
+    walk.key += "r0";
     return;
   }
-  walk2.key += "r(";
+  walk.key += "r(";
   for (const name of returning)
-    addIdent(walk2, name);
-  walk2.key += ")";
+    addIdent(walk, name);
+  walk.key += ")";
 }
-function walkExpr(walk2, dialect, expr) {
+function walkExpr(walk, dialect, expr) {
   switch (expr.kind) {
     case "cmp":
       if (isDbNowMarker(expr.value)) {
-        walk2.key += `cN${expr.op}${expr.value.offsetSeconds === 0 ? "0" : "1"}`;
-        addCol(walk2, expr.column);
+        walk.key += `cN${expr.op}${expr.value.offsetSeconds === 0 ? "0" : "1"}`;
+        addCol(walk, expr.column);
         if (expr.value.offsetSeconds !== 0)
-          walk2.values.push(expr.value.offsetSeconds);
+          walk.values.push(expr.value.offsetSeconds);
         return true;
       }
-      walk2.key += `c${expr.op}`;
-      addCol(walk2, expr.column);
-      walk2.values.push(expr.value);
+      walk.key += `c${expr.op}`;
+      addCol(walk, expr.column);
+      walk.values.push(expr.value);
       return true;
     case "cmpCol":
-      walk2.key += `k${expr.op}`;
-      addCol(walk2, expr.left);
-      addCol(walk2, expr.right);
+      walk.key += `k${expr.op}`;
+      addCol(walk, expr.left);
+      addCol(walk, expr.right);
       return true;
     case "isNull":
-      walk2.key += expr.negate === true ? "n1" : "n0";
-      addCol(walk2, expr.column);
+      walk.key += expr.negate === true ? "n1" : "n0";
+      addCol(walk, expr.column);
       return true;
     case "inArray": {
       if (expr.values.length === 0) {
-        walk2.key += expr.negate === true ? "z1" : "z0";
+        walk.key += expr.negate === true ? "z1" : "z0";
         return true;
       }
-      walk2.key += expr.negate === true ? "i1" : "i0";
-      addCol(walk2, expr.column);
+      walk.key += expr.negate === true ? "i1" : "i0";
+      addCol(walk, expr.column);
       if (dialect.inArrayStrategy === "any") {
-        walk2.values.push([...expr.values]);
+        walk.values.push([...expr.values]);
       } else {
-        walk2.key += `#${expr.values.length}`;
+        walk.key += `#${expr.values.length}`;
         for (const value of expr.values)
-          walk2.values.push(value);
+          walk.values.push(value);
       }
       return true;
     }
     case "tupleIn": {
       if (expr.columns.length === 0)
         return false;
-      walk2.key += `Tu${expr.negate === true ? "1" : "0"}${expr.columns.length}#${expr.rows.length}(`;
+      walk.key += `Tu${expr.negate === true ? "1" : "0"}${expr.columns.length}#${expr.rows.length}(`;
       for (const column of expr.columns)
-        addCol(walk2, column);
-      walk2.key += ")";
+        addCol(walk, column);
+      walk.key += ")";
       if (expr.rows.length === 0)
         return true;
       for (const row of expr.rows) {
         if (row.length !== expr.columns.length)
           return false;
         for (const value of row)
-          walk2.values.push(value);
+          walk.values.push(value);
       }
       return true;
     }
     case "like":
-      walk2.key += `L${expr.insensitive === true ? "i" : "s"}${expr.negate === true ? "n" : "p"}`;
-      addCol(walk2, expr.column);
-      walk2.values.push(expr.pattern);
+      walk.key += `L${expr.insensitive === true ? "i" : "s"}${expr.negate === true ? "n" : "p"}`;
+      addCol(walk, expr.column);
+      walk.values.push(expr.pattern);
       return true;
     case "strictMatch":
-      walk2.key += `S${expr.op}${expr.negate === true ? "n" : "p"}`;
-      addCol(walk2, expr.column);
-      walk2.values.push(expr.op === "equals" ? expr.value : strictMatchPattern({ strategy: dialect.strictMatchStrategy, op: expr.op, value: expr.value }));
+      walk.key += `S${expr.op}${expr.negate === true ? "n" : "p"}`;
+      addCol(walk, expr.column);
+      walk.values.push(expr.op === "equals" ? expr.value : strictMatchPattern({ strategy: dialect.strictMatchStrategy, op: expr.op, value: expr.value }));
       return true;
     case "and":
     case "or": {
-      walk2.key += `${expr.kind === "and" ? "A" : "O"}${expr.operands.length}(`;
+      walk.key += `${expr.kind === "and" ? "A" : "O"}${expr.operands.length}(`;
       for (const operand of expr.operands) {
-        if (!walkExpr(walk2, dialect, operand))
+        if (!walkExpr(walk, dialect, operand))
           return false;
       }
-      walk2.key += ")";
+      walk.key += ")";
       return true;
     }
     case "not":
-      walk2.key += "!(";
-      if (!walkExpr(walk2, dialect, expr.operand))
+      walk.key += "!(";
+      if (!walkExpr(walk, dialect, expr.operand))
         return false;
-      walk2.key += ")";
+      walk.key += ")";
       return true;
     case "exists":
-      walk2.key += expr.negate === true ? "E1(" : "E0(";
-      if (!walkSelect(walk2, dialect, expr.select))
+      walk.key += expr.negate === true ? "E1(" : "E0(";
+      if (!walkSelect(walk, dialect, expr.select))
         return false;
-      walk2.key += ")";
+      walk.key += ")";
       return true;
     case "aggCmp":
-      walk2.key += `g${expr.op}`;
-      addAgg(walk2, expr.agg);
-      walk2.values.push(expr.value);
+      walk.key += `g${expr.op}`;
+      addAgg(walk, expr.agg);
+      walk.values.push(expr.value);
       return true;
     case "arrayHas":
-      walk2.key += expr.negate === true ? "h1" : "h0";
-      addCol(walk2, expr.column);
-      walk2.values.push(expr.value);
+      walk.key += expr.negate === true ? "h1" : "h0";
+      addCol(walk, expr.column);
+      walk.values.push(expr.value);
       return true;
     case "arrayContainsAll":
-      walk2.key += "H";
-      addCol(walk2, expr.column);
-      walk2.values.push([...expr.values]);
+      walk.key += "H";
+      addCol(walk, expr.column);
+      walk.values.push([...expr.values]);
       return true;
     case "arrayOverlaps":
-      walk2.key += "V";
-      addCol(walk2, expr.column);
-      walk2.values.push([...expr.values]);
+      walk.key += "V";
+      addCol(walk, expr.column);
+      walk.values.push([...expr.values]);
       return true;
     case "arrayIsEmpty":
-      walk2.key += expr.empty ? "e1" : "e0";
-      addCol(walk2, expr.column);
+      walk.key += expr.empty ? "e1" : "e0";
+      addCol(walk, expr.column);
       return true;
     case "jsonFilter":
       return false;
@@ -11757,140 +11757,140 @@ function walkExpr(walk2, dialect, expr) {
     case "fragment":
       return false;
     case "raw":
-      walk2.key += "R(";
-      addIdent(walk2, expr.text);
-      walk2.key += ")";
+      walk.key += "R(";
+      addIdent(walk, expr.text);
+      walk.key += ")";
       return true;
   }
 }
-function walkOrderTerm2(walk2, dialect, term) {
+function walkOrderTerm2(walk, dialect, term) {
   if ("agg" in term) {
-    walk2.key += "a";
-    addAgg(walk2, term.agg);
+    walk.key += "a";
+    addAgg(walk, term.agg);
   } else if ("select" in term) {
-    walk2.key += "q(";
-    if (!walkSelect(walk2, dialect, term.select))
+    walk.key += "q(";
+    if (!walkSelect(walk, dialect, term.select))
       return false;
-    walk2.key += ")";
+    walk.key += ")";
   } else {
-    addCol(walk2, term.column);
-    walk2.key += term.nulls === undefined ? "-" : term.nulls === "first" ? "^" : "$";
+    addCol(walk, term.column);
+    walk.key += term.nulls === undefined ? "-" : term.nulls === "first" ? "^" : "$";
   }
-  walk2.key += term.direction === "asc" ? "+" : "~";
+  walk.key += term.direction === "asc" ? "+" : "~";
   return true;
 }
-function walkSelect(walk2, dialect, statement) {
-  walk2.key += "S{";
+function walkSelect(walk, dialect, statement) {
+  walk.key += "S{";
   if (statement.distinctOn !== undefined && statement.distinctOn.length > 0) {
-    walk2.key += "d(";
+    walk.key += "d(";
     for (const column of statement.distinctOn)
-      addCol(walk2, column);
-    walk2.key += ")";
+      addCol(walk, column);
+    walk.key += ")";
   }
-  walk2.key += "p(";
+  walk.key += "p(";
   for (const column of statement.columns)
-    addCol(walk2, column);
-  walk2.key += ")";
+    addCol(walk, column);
+  walk.key += ")";
   if (statement.selectExpr !== undefined) {
     if (statement.selectExpr.kind === "one") {
-      walk2.key += "x1";
+      walk.key += "x1";
     } else {
-      walk2.key += "xc";
+      walk.key += "xc";
       if (statement.selectExpr.alias !== undefined)
-        addIdent(walk2, statement.selectExpr.alias);
+        addIdent(walk, statement.selectExpr.alias);
     }
   }
   if (statement.aggregates !== undefined) {
     for (const selection of statement.aggregates) {
-      walk2.key += "a";
-      addAgg(walk2, selection.agg);
-      addIdent(walk2, selection.alias);
+      walk.key += "a";
+      addAgg(walk, selection.agg);
+      addIdent(walk, selection.alias);
     }
   }
   if (statement.rowNumber !== undefined) {
-    walk2.key += "W(";
+    walk.key += "W(";
     for (const column of statement.rowNumber.partitionBy)
-      addCol(walk2, column);
-    walk2.key += ":";
+      addCol(walk, column);
+    walk.key += ":";
     for (const term of statement.rowNumber.orderBy) {
-      if (!walkOrderTerm2(walk2, dialect, term))
+      if (!walkOrderTerm2(walk, dialect, term))
         return false;
     }
-    addIdent(walk2, statement.rowNumber.alias);
-    walk2.key += ")";
+    addIdent(walk, statement.rowNumber.alias);
+    walk.key += ")";
   }
-  walk2.key += "f";
-  addTable(walk2, statement.table);
+  walk.key += "f";
+  addTable(walk, statement.table);
   if (statement.fromSelect !== undefined) {
-    walk2.key += "F(";
-    if (!walkSelect(walk2, dialect, statement.fromSelect))
+    walk.key += "F(";
+    if (!walkSelect(walk, dialect, statement.fromSelect))
       return false;
-    walk2.key += ")";
+    walk.key += ")";
   }
   if (statement.innerJoins !== undefined && statement.innerJoins.length > 0) {
     for (const join of statement.innerJoins) {
-      walk2.key += "J(";
-      addTable(walk2, join.table);
+      walk.key += "J(";
+      addTable(walk, join.table);
       for (const pair of join.on) {
-        addCol(walk2, pair.left);
-        walk2.key += "=";
-        addCol(walk2, pair.right);
+        addCol(walk, pair.left);
+        walk.key += "=";
+        addCol(walk, pair.right);
       }
-      walk2.key += ")";
+      walk.key += ")";
     }
   }
   if (statement.lateralJoins !== undefined && statement.lateralJoins.length > 0) {
     for (const join of statement.lateralJoins) {
-      walk2.key += join.agg === "count" ? "Jc(" : join.agg === "jsonArray" ? "Ja(" : "Jo(";
-      walk2.key += join.rowFormat === "positional" ? "pos;" : "obj;";
-      if (!walkSelect(walk2, dialect, join.select))
+      walk.key += join.agg === "count" ? "Jc(" : join.agg === "jsonArray" ? "Ja(" : "Jo(";
+      walk.key += join.rowFormat === "positional" ? "pos;" : "obj;";
+      if (!walkSelect(walk, dialect, join.select))
         return false;
-      addIdent(walk2, join.columnAlias);
-      addIdent(walk2, join.alias);
-      walk2.key += ")";
+      addIdent(walk, join.columnAlias);
+      addIdent(walk, join.alias);
+      walk.key += ")";
     }
   }
   if (statement.where !== undefined) {
-    walk2.key += "w";
-    if (!walkExpr(walk2, dialect, statement.where))
+    walk.key += "w";
+    if (!walkExpr(walk, dialect, statement.where))
       return false;
   }
   if (statement.groupBy !== undefined && statement.groupBy.length > 0) {
-    walk2.key += "b(";
+    walk.key += "b(";
     for (const column of statement.groupBy)
-      addCol(walk2, column);
-    walk2.key += ")";
+      addCol(walk, column);
+    walk.key += ")";
   }
   if (statement.having !== undefined) {
-    walk2.key += "v";
-    if (!walkExpr(walk2, dialect, statement.having))
+    walk.key += "v";
+    if (!walkExpr(walk, dialect, statement.having))
       return false;
   }
   if (statement.orderBy !== undefined && statement.orderBy.length > 0) {
-    walk2.key += "o(";
+    walk.key += "o(";
     for (const term of statement.orderBy) {
-      if (!walkOrderTerm2(walk2, dialect, term))
+      if (!walkOrderTerm2(walk, dialect, term))
         return false;
     }
-    walk2.key += ")";
+    walk.key += ")";
   }
   if (statement.limit !== undefined)
-    walk2.key += `t${statement.limit}`;
+    walk.key += `t${statement.limit}`;
   if (statement.offset !== undefined)
-    walk2.key += `s${statement.offset}`;
+    walk.key += `s${statement.offset}`;
   if (statement.rowLock !== undefined) {
-    walk2.key += `u:${statement.rowLock.strength}/${statement.rowLock.wait}`;
+    walk.key += `u:${statement.rowLock.strength}/${statement.rowLock.wait}`;
   }
-  walk2.key += "}";
+  walk.key += "}";
   return true;
 }
-function walkInsert(walk2, dialect, statement) {
-  walk2.key += "I{";
-  addTable(walk2, statement.table);
-  walk2.key += "c(";
+function walkInsert(walk, dialect, statement) {
+  walk.key += "I{";
+  addTable(walk, statement.table);
+  walk.key += "c(";
   for (const name of statement.columns)
-    addIdent(walk2, name);
-  walk2.key += `)r${statement.rows.length}`;
+    addIdent(walk, name);
+  walk.key += `)r${statement.rows.length}`;
   const arity = statement.columns.length;
   for (let rowIndex = 0;rowIndex < statement.rows.length; rowIndex++) {
     const row = statement.rows[rowIndex];
@@ -11899,95 +11899,95 @@ function walkInsert(walk2, dialect, statement) {
     for (let cell = 0;cell < row.length; cell++) {
       const value = row[cell];
       if (isSqlDefaultCell(value))
-        walk2.key += `D${rowIndex}:${cell};`;
+        walk.key += `D${rowIndex}:${cell};`;
       else if (isJsonParamCell(value)) {
-        walk2.key += `J${rowIndex}:${cell};`;
-        walk2.values.push(value.text);
+        walk.key += `J${rowIndex}:${cell};`;
+        walk.values.push(value.text);
       } else if (isDbNowMarker(value)) {
-        walk2.key += `T${rowIndex}:${cell}:${value.offsetSeconds === 0 ? "0" : "1"};`;
+        walk.key += `T${rowIndex}:${cell}:${value.offsetSeconds === 0 ? "0" : "1"};`;
         if (value.offsetSeconds !== 0)
-          walk2.values.push(value.offsetSeconds);
+          walk.values.push(value.offsetSeconds);
       } else
-        walk2.values.push(value);
+        walk.values.push(value);
     }
   }
   const onConflict = statement.onConflict;
   if (onConflict !== undefined) {
     if ("doNothing" in onConflict) {
-      walk2.key += "N(";
+      walk.key += "N(";
       if (onConflict.constraint !== undefined) {
-        walk2.key += "K";
-        addIdent(walk2, onConflict.constraint);
+        walk.key += "K";
+        addIdent(walk, onConflict.constraint);
       }
       if (onConflict.columns !== undefined) {
         for (const name of onConflict.columns)
-          addIdent(walk2, name);
+          addIdent(walk, name);
       }
       if (onConflict.conflictWhere !== undefined) {
-        walk2.key += "w";
-        addIdent(walk2, onConflict.conflictWhere);
+        walk.key += "w";
+        addIdent(walk, onConflict.conflictWhere);
       }
-      walk2.key += ")";
+      walk.key += ")";
     } else {
       if (Object.values(onConflict.update).some(isSqlFragment3))
         return false;
-      walk2.key += "U(";
+      walk.key += "U(";
       if (onConflict.constraint !== undefined) {
-        walk2.key += "K";
-        addIdent(walk2, onConflict.constraint);
+        walk.key += "K";
+        addIdent(walk, onConflict.constraint);
       }
       for (const name of onConflict.columns)
-        addIdent(walk2, name);
-      walk2.key += ":";
+        addIdent(walk, name);
+      walk.key += ":";
       for (const [name, value] of Object.entries(onConflict.update))
-        addSetEntry(walk2, name, value);
+        addSetEntry(walk, name, value);
       if (onConflict.lastInsertIdColumn !== undefined) {
-        walk2.key += "@";
-        addIdent(walk2, onConflict.lastInsertIdColumn);
+        walk.key += "@";
+        addIdent(walk, onConflict.lastInsertIdColumn);
       }
-      walk2.key += ")";
+      walk.key += ")";
     }
   }
-  addReturning(walk2, statement.returning);
-  walk2.key += "}";
+  addReturning(walk, statement.returning);
+  walk.key += "}";
   return true;
 }
-function walkUpdate(walk2, dialect, statement) {
-  walk2.key += "U{";
-  addTable(walk2, statement.table);
+function walkUpdate(walk, dialect, statement) {
+  walk.key += "U{";
+  addTable(walk, statement.table);
   for (const [name, value] of Object.entries(statement.set))
-    addSetEntry(walk2, name, value);
+    addSetEntry(walk, name, value);
   if (statement.where !== undefined) {
-    walk2.key += "w";
-    if (!walkExpr(walk2, dialect, statement.where))
+    walk.key += "w";
+    if (!walkExpr(walk, dialect, statement.where))
       return false;
   }
-  addReturning(walk2, statement.returning);
-  walk2.key += "}";
+  addReturning(walk, statement.returning);
+  walk.key += "}";
   return true;
 }
-function walkDelete(walk2, dialect, statement) {
-  walk2.key += "D{";
-  addTable(walk2, statement.table);
+function walkDelete(walk, dialect, statement) {
+  walk.key += "D{";
+  addTable(walk, statement.table);
   if (statement.where !== undefined) {
-    walk2.key += "w";
-    if (!walkExpr(walk2, dialect, statement.where))
+    walk.key += "w";
+    if (!walkExpr(walk, dialect, statement.where))
       return false;
   }
-  addReturning(walk2, statement.returning);
-  walk2.key += "}";
+  addReturning(walk, statement.returning);
+  walk.key += "}";
   return true;
 }
-function walkStatement(walk2, dialect, statement) {
+function walkStatement(walk, dialect, statement) {
   switch (statement.kind) {
     case "select":
-      return walkSelect(walk2, dialect, statement);
+      return walkSelect(walk, dialect, statement);
     case "insert":
-      return walkInsert(walk2, dialect, statement);
+      return walkInsert(walk, dialect, statement);
     case "update":
-      return walkUpdate(walk2, dialect, statement);
+      return walkUpdate(walk, dialect, statement);
     case "delete":
-      return walkDelete(walk2, dialect, statement);
+      return walkDelete(walk, dialect, statement);
     case "rlsEnable":
     case "rlsForce":
     case "rlsDisable":
@@ -12025,18 +12025,18 @@ function sameValues(walked, rendered) {
 }
 function renderStatementCached(params) {
   const { dialect, statement, cache } = params;
-  const walk2 = { key: "", values: [] };
-  if (!walkStatement(walk2, dialect, statement)) {
+  const walk = { key: "", values: [] };
+  if (!walkStatement(walk, dialect, statement)) {
     return renderStatement4({ dialect, statement });
   }
-  const slot = cache.get(walk2.key);
+  const slot = cache.get(walk.key);
   if (slot !== undefined) {
     if (slot === null)
       return renderStatement4({ dialect, statement });
-    return { text: slot.text, values: walk2.values, returning: slot.returning };
+    return { text: slot.text, values: walk.values, returning: slot.returning };
   }
   const rendered = renderStatement4({ dialect, statement });
-  cache.set(walk2.key, sameValues(walk2.values, rendered.values) ? { text: rendered.text, returning: rendered.returning } : null);
+  cache.set(walk.key, sameValues(walk.values, rendered.values) ? { text: rendered.text, returning: rendered.returning } : null);
   return rendered;
 }
 
@@ -12057,32 +12057,63 @@ function isPlainObject9(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function descend(params) {
-  const { ctx, model, key } = params;
-  const field = model.fieldByName.get(key);
-  if (field !== undefined)
-    return field.scalarType === "Json" ? "json" : model;
-  const relation = model.relationByName.get(key);
-  if (relation === undefined)
-    return model;
-  return ctx.meta.modelByName.get(relation.targetModel) ?? model;
-}
+var STRUCTURAL_KEYWORDS = Object.freeze({
+  where: { level: "fields", filter: true },
+  having: { level: "fields", filter: true },
+  some: { level: "fields", filter: true },
+  every: { level: "fields", filter: true },
+  none: { level: "fields", filter: true },
+  is: { level: "fields", filter: true },
+  isNot: { level: "fields", filter: true },
+  deleteMany: { level: "fields", filter: true },
+  data: { level: "fields", filter: false },
+  create: { level: "fields", filter: false },
+  set: { level: "fields", filter: false },
+  connect: { level: "fields", filter: false },
+  disconnect: { level: "fields", filter: false },
+  delete: { level: "fields", filter: false },
+  cursor: { level: "fields", filter: false },
+  select: { level: "fields", filter: "inherit" },
+  include: { level: "fields", filter: "inherit" },
+  omit: { level: "fields", filter: "inherit" },
+  orderBy: { level: "fields", filter: "inherit" },
+  connectOrCreate: { level: "structural", filter: "inherit" },
+  upsert: { level: "structural", filter: "inherit" },
+  createMany: { level: "structural", filter: "inherit" },
+  updateMany: { level: "structural", filter: "inherit" },
+  _count: { level: "structural", filter: "inherit" },
+  update: { level: "structural", filter: false }
+});
+var LOGICAL_KEYS = new Set(["AND", "OR", "NOT"]);
 function walkArray(params) {
-  const { ctx, model, value, path, filter } = params;
+  const { ctx, model, value, path, level, filter } = params;
   let changed = false;
   const out = value.map((item, index) => {
-    const next = walkNode({ ctx, model, value: item, path: `${path}[${index}]`, filter });
+    const next = walkNode({ ctx, model, value: item, path: `${path}[${index}]`, level, filter });
     if (next !== item)
       changed = true;
     return next;
   });
   return changed ? out : value;
 }
+function walkJsonOperators(params) {
+  const { ctx, value, path } = params;
+  let filtered = null;
+  for (const operator of Object.keys(value)) {
+    if (value[operator] === undefined) {
+      throw explicitUndefined({ model: ctx.model, method: ctx.method, path: `${path}.${operator}` });
+    }
+    if (value[operator] === SKIP) {
+      filtered ??= { ...value };
+      delete filtered[operator];
+    }
+  }
+  return filtered ?? value;
+}
 function walkNode(params) {
-  const { ctx, model, value, path } = params;
-  const filter = params.filter === true;
+  const { ctx, model, value, path, level, filter } = params;
   if (Array.isArray(value))
-    return walkArray({ ctx, model, value, path, filter });
+    return walkArray({ ctx, model, value, path, level, filter });
   if (!isPlainObject9(value))
     return value;
   let out = null;
@@ -12097,33 +12128,31 @@ function walkNode(params) {
       delete out[key];
       continue;
     }
-    const target = descend({ ctx, model, key });
-    if (target === "json") {
-      if (filter && isPlainObject9(child)) {
-        let filtered = null;
-        for (const operator of Object.keys(child)) {
-          if (child[operator] === undefined) {
-            throw explicitUndefined({ model: ctx.model, method: ctx.method, path: `${childPath}.${operator}` });
-          }
-          if (child[operator] === SKIP) {
-            filtered ??= { ...child };
-            delete filtered[operator];
-          }
-        }
-        if (filtered !== null) {
-          out ??= { ...value };
-          out[key] = filtered;
-        }
+    let next;
+    const keyword = level === "structural" ? STRUCTURAL_KEYWORDS[key] : undefined;
+    if (keyword !== undefined) {
+      next = walkNode({
+        ctx,
+        model,
+        value: child,
+        path: childPath,
+        level: keyword.level,
+        filter: keyword.filter === "inherit" ? filter : keyword.filter
+      });
+    } else if (LOGICAL_KEYS.has(key)) {
+      next = walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter });
+    } else {
+      const field = model.fieldByName.get(key);
+      if (field !== undefined && field.scalarType === "Json") {
+        next = filter && isPlainObject9(child) ? walkJsonOperators({ ctx, value: child, path: childPath }) : child;
+      } else if (field !== undefined) {
+        next = walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter });
+      } else {
+        const relation = model.relationByName.get(key);
+        const target = relation === undefined ? undefined : ctx.meta.modelByName.get(relation.targetModel);
+        next = target === undefined ? walkNode({ ctx, model, value: child, path: childPath, level: "fields", filter }) : walkNode({ ctx, model: target, value: child, path: childPath, level: "structural", filter });
       }
-      continue;
     }
-    const next = walkNode({
-      ctx,
-      model: target,
-      value: child,
-      path: childPath,
-      filter: key === "where" || key === "having" ? true : key === "data" || key === "create" || key === "update" ? false : filter
-    });
     if (next !== child) {
       out ??= { ...value };
       out[key] = next;
@@ -12136,7 +12165,7 @@ function checkStrictArguments(params) {
   if (args === undefined)
     return;
   const ctx = { meta, model: model.clientName, method };
-  const walked = walkNode({ ctx, model, value: args, path: "args" });
+  const walked = walkNode({ ctx, model, value: args, path: "args", level: "structural", filter: false });
   return walked;
 }
 
@@ -13093,11 +13122,11 @@ async function runRows(params) {
   return materializeRows({ dialect: engine.dialect.name, model: plan.model, rows, wire: engine.adapter.wire });
 }
 async function runBoundAffected(params) {
-  const { adapter, text: text2, values } = params;
-  const bound2 = adapter.executeAffected;
-  if (bound2 !== undefined)
-    return await bound2.call(adapter, { text: text2, values });
-  return await adapter.executeUnsafe({ text: text2, values });
+  const { adapter, text, values } = params;
+  const bound = adapter.executeAffected;
+  if (bound !== undefined)
+    return await bound.call(adapter, { text, values });
+  return await adapter.executeUnsafe({ text, values });
 }
 async function runAffected(params) {
   const { engine, plan } = params;
@@ -13314,22 +13343,22 @@ async function runSingleMutation(params) {
         if (!hasIdTrick)
           throw notFound2({ model: source.model.name, method: source.method });
         const where = await insertedKeyWhere({ engine: txEngine, source: { ...source, refetchWhere: null } });
-        const after2 = await refetch({ engine: txEngine, source, where });
-        if (after2 === null)
+        const after = await refetch({ engine: txEngine, source, where });
+        if (after === null)
           throw notFound2({ model: source.model.name, method: source.method });
-        return after2;
+        return after;
       });
     }
     if (source.method === "update") {
       return await engine.adapter.transaction(async (txAdapter) => {
         const txEngine = { ...engine, adapter: txAdapter, inTransaction: true };
-        const { affectedRows: affected2 } = await executeWrite(txEngine);
-        if (affected2 === 0)
+        const { affectedRows: affected } = await executeWrite(txEngine);
+        if (affected === 0)
           throw notFound2({ model: source.model.name, method: source.method });
-        const after2 = await refetch({ engine: txEngine, source, where: knownWhere });
-        if (after2 === null)
+        const after = await refetch({ engine: txEngine, source, where: knownWhere });
+        if (after === null)
           throw notFound2({ model: source.model.name, method: source.method });
-        return after2;
+        return after;
       });
     }
     const { affectedRows: affected } = await executeWrite(engine);
@@ -13509,21 +13538,21 @@ function makeWriteContext(params) {
 }
 function readOnlyDelegate2(params) {
   const { delegate, model } = params;
-  const refuse2 = (method) => async () => {
+  const refuse = (method) => async () => {
     throw viewIsReadOnly({ model, method });
   };
   return {
     ...delegate,
-    create: refuse2("create"),
-    createMany: refuse2("createMany"),
-    createManyAndReturn: refuse2("createManyAndReturn"),
-    update: refuse2("update"),
-    updateMany: refuse2("updateMany"),
-    updateManyAndReturn: refuse2("updateManyAndReturn"),
-    upsert: refuse2("upsert"),
-    upsertMany: refuse2("upsertMany"),
-    delete: refuse2("delete"),
-    deleteMany: refuse2("deleteMany")
+    create: refuse("create"),
+    createMany: refuse("createMany"),
+    createManyAndReturn: refuse("createManyAndReturn"),
+    update: refuse("update"),
+    updateMany: refuse("updateMany"),
+    updateManyAndReturn: refuse("updateManyAndReturn"),
+    upsert: refuse("upsert"),
+    upsertMany: refuse("upsertMany"),
+    delete: refuse("delete"),
+    deleteMany: refuse("deleteMany")
   };
 }
 function isEffectivelyEmptyData(value) {
@@ -13574,7 +13603,7 @@ function createDelegate(params) {
         });
       }
       const shape = resolveResultShape({ meta: target.meta, model: modelMeta, method: "create", args });
-      const row2 = await createWithNested({
+      const row = await createWithNested({
         ctx: makeWriteContext({ engine: target }),
         model: modelMeta,
         data: args.data
@@ -13583,7 +13612,7 @@ function createDelegate(params) {
         engine: target,
         model: modelMeta,
         shape: { ...shape, relationStrategy: "query" },
-        row: row2
+        row
       });
     }
     const built = plan({ engine: target, model, method: "create", args });
@@ -13601,7 +13630,7 @@ function createDelegate(params) {
     const modelMeta = getModelMeta({ meta: target.meta, model });
     if (hasNestedWrites({ model: modelMeta, data: args.data })) {
       const shape = resolveResultShape({ meta: target.meta, model: modelMeta, method: "update", args });
-      const row2 = await updateWithNested({
+      const row = await updateWithNested({
         ctx: makeWriteContext({ engine: target }),
         model: modelMeta,
         where: args.where,
@@ -13611,7 +13640,7 @@ function createDelegate(params) {
         engine: target,
         model: modelMeta,
         shape: { ...shape, relationStrategy: "query" },
-        row: row2
+        row
       });
     }
     const built = plan({ engine: target, model, method: "update", args });
@@ -13688,12 +13717,12 @@ function createDelegate(params) {
         method: "upsert",
         args
       });
-      const row2 = await runUpsertFallback({ engine: target, model: modelMeta, args });
+      const row = await runUpsertFallback({ engine: target, model: modelMeta, args });
       return await finalizeRow({
         engine: target,
         model: modelMeta,
         shape: { ...shape, relationStrategy: "query" },
-        row: row2
+        row
       });
     }
     const built = plan({ engine: target, model, method: "upsert", args });
@@ -13848,11 +13877,11 @@ function withStrictArguments(params) {
 function buildRawStatement(params) {
   const { dialect, strings, values } = params;
   const collector = new ParamCollector(dialect);
-  let text2 = strings[0] ?? "";
+  let text = strings[0] ?? "";
   for (let index = 0;index < values.length; index++) {
-    text2 += collector.add(values[index]) + (strings[index + 1] ?? "");
+    text += collector.add(values[index]) + (strings[index + 1] ?? "");
   }
-  return { text: text2, values: collector.values };
+  return { text, values: collector.values };
 }
 function buildClient(params) {
   const { engine } = params;
@@ -13869,7 +13898,7 @@ function buildClient(params) {
     models[model.name] = delegate;
     models[model.clientName] = delegate;
   }
-  const runRaw = async (method, statement, decodeRows2) => {
+  const runRaw = async (method, statement, decodeRows) => {
     const scope = beginOperation({ engine, kind: "raw", model: null, method });
     scope?.dispatch();
     const running = executeOperation({
@@ -13885,7 +13914,7 @@ function buildClient(params) {
           rowCount: (value) => method.startsWith("$query") ? value.rows.length : value.affectedRows,
           run: () => statement.values.length > 0 ? target.adapter.executeRawBound !== undefined ? target.adapter.executeRawBound(statement) : runBoundAffected({ adapter: target.adapter, text: statement.text, values: statement.values }) : target.adapter.executeUnsafe(statement)
         });
-        decodeRows2?.(result.rows);
+        decodeRows?.(result.rows);
         return result;
       }
     });
@@ -13901,8 +13930,8 @@ function buildClient(params) {
     });
     return await running;
   };
-  const runAdvisoryLock = async (params2) => {
-    const { method, options } = params2;
+  const runAdvisoryLock = async (params) => {
+    const { method, options } = params;
     assertEngineActive({ engine });
     const statement = compileAdvisoryLock({
       dialect: engine.dialect,
@@ -14048,8 +14077,8 @@ function buildClient(params) {
     },
     $queryRaw: async (strings, ...values) => (await runRaw("$queryRaw", buildRawStatement({ dialect: engine.dialect, strings, values }))).rows,
     $executeRaw: async (strings, ...values) => (await runRaw("$executeRaw", buildRawStatement({ dialect: engine.dialect, strings, values }))).affectedRows,
-    $queryRawUnsafe: async (text2, ...values) => (await runRaw("$queryRawUnsafe", { text: text2, values })).rows,
-    $executeRawUnsafe: async (text2, ...values) => (await runRaw("$executeRawUnsafe", { text: text2, values })).affectedRows,
+    $queryRawUnsafe: async (text, ...values) => (await runRaw("$queryRawUnsafe", { text, values })).rows,
+    $executeRawUnsafe: async (text, ...values) => (await runRaw("$executeRawUnsafe", { text, values })).affectedRows,
     $advisoryLock: async (options) => {
       await runAdvisoryLock({ method: "$advisoryLock", options });
     },
@@ -14095,7 +14124,7 @@ function buildClient(params) {
   }
   attachExtensionMounts({ engine, client, models });
   attachDefineView({ client, meta: engine.meta, models });
-  const wrapDelegate = engine.options?.strictArguments !== false ? (params2) => withStrictArguments({ engine, ...params2 }) : undefined;
+  const wrapDelegate = engine.options?.strictArguments !== false ? (params) => withStrictArguments({ engine, ...params }) : undefined;
   if (engine.rlsSchema === undefined)
     attachScoped({ client, meta: engine.meta, ...wrapDelegate === undefined ? {} : { wrapDelegate } });
   if (engine.rlsSchema === undefined) {
@@ -14170,7 +14199,7 @@ function makeMountContext(params) {
     provider: engine.adapter.provider,
     meta: engine.meta,
     model,
-    executeRows: async ({ text: text2, values, method }) => {
+    executeRows: async ({ text, values, method }) => {
       const scope = beginOperation({
         engine,
         kind: "extension",
@@ -14186,11 +14215,11 @@ function makeMountContext(params) {
             kind: "extension",
             model: model?.name ?? null,
             method: method ?? extension,
-            text: text2,
+            text,
             values,
             rowCount: (value) => value.length,
             run: () => target.adapter.execute({
-              text: text2,
+              text,
               values: bindValues({ adapter: target.adapter, values: [...values] })
             })
           });
@@ -14210,11 +14239,12 @@ function makeMountContext(params) {
           meta: { extension }
         });
       }
+      const checked = engine.options?.strictArguments !== false ? checkStrictArguments({ meta: engine.meta, model: target, method: `${extension}.compileWhere`, args: { where } }) : undefined;
       return compileWhere({
         dialect: engine.dialect,
         meta: engine.meta,
         model: target,
-        where,
+        where: checked === undefined ? where : checked.where,
         ...qualify === undefined ? {} : { qualify }
       });
     }
@@ -14273,8 +14303,8 @@ function attachExtensionMounts(params) {
           meta: { extension: mount.extension, model: model.name, property: mount.property }
         });
       }
-      const value2 = createMountSurface({ engine, mount, model });
-      Object.defineProperty(delegate, mount.property, { value: value2, enumerable: true, configurable: true });
+      const value = createMountSurface({ engine, mount, model });
+      Object.defineProperty(delegate, mount.property, { value, enumerable: true, configurable: true });
       continue;
     }
     if (!mount.property.startsWith("$") || mount.property in client) {
@@ -14414,8 +14444,8 @@ function validation(params) {
   return new VibeError32({ code: "VIBE_VALIDATION", message: params.message, meta: params.meta });
 }
 function projectionFor(params) {
-  const { plan: plan2, select, omit } = params;
-  const names = plan2.keys.map((key) => key.field.name);
+  const { plan, select, omit } = params;
+  const names = plan.keys.map((key) => key.field.name);
   if (select !== undefined) {
     const hidden = names.filter((name) => select[name] !== true);
     if (hidden.length === 0)
@@ -14445,13 +14475,13 @@ function iterateKeyset(options) {
     });
   }
   const model = getModelMeta({ meta, model: options.model });
-  const plan2 = compileKeysetOrderPlan({
+  const plan = compileKeysetOrderPlan({
     model,
     dialect,
     terms: compileKeysetOrderInputs({ dialect, meta, model, orderBy }),
     ...options.timestampPrecision === undefined ? {} : { timestampPrecision: options.timestampPrecision }
   });
-  const projection = projectionFor({ plan: plan2, select: options.select, omit: options.omit });
+  const projection = projectionFor({ plan, select: options.select, omit: options.omit });
   const keysetArg = options.timestampPrecision === undefined ? {} : { keyset: { timestampPrecision: options.timestampPrecision } };
   let buffer = [];
   let position = options.after ?? null;
@@ -14482,16 +14512,16 @@ function iterateKeyset(options) {
     const first = rows[0];
     if (position !== null && first !== undefined) {
       const advanced = keysetRowIsAfter({
-        keys: plan2.keys,
-        row: keysetRowValues({ plan: plan2, row: first }),
-        position: decodeKeysetToken({ plan: plan2, token: position })
+        keys: plan.keys,
+        row: keysetRowValues({ plan, row: first }),
+        position: decodeKeysetToken({ plan, token: position })
       });
       if (advanced === false) {
         stop();
         throw new VibeError32({
           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" }
+          meta: { model: options.model, order: plan.signature, reason: "keyset-position-not-advancing" }
         });
       }
     }
@@ -14523,7 +14553,7 @@ function iterateKeyset(options) {
       }
     }
     const raw = buffer.shift();
-    pending = encodeKeysetToken({ plan: plan2, row: raw });
+    pending = encodeKeysetToken({ plan, row: raw });
     position = pending;
     if (projection.hidden.length === 0)
       return { done: false, value: raw };
@@ -14643,115 +14673,115 @@ function createTelemetryCollector(params) {
   };
 }
 export {
-  validateWriteData,
-  updateWithNested,
-  toSqlExecutor,
-  toClientName,
-  summarizePlan,
-  sqlProjection,
-  sql2 as sql,
-  rewriteScopedCall,
-  resolveTelemetryConfig,
-  resolveStatementDiagnostics,
-  resolveScopedModels,
-  resolveResultShape,
-  resolveRelationSelection,
-  resolveRelationLink,
-  recommendFromPlan,
-  readWorkloadStatistics,
-  readOnlyRefusal,
-  queryFingerprint,
-  previewOperation,
-  parsePostgresPlan,
-  parseDiagnosticsEnv,
-  parameterTypeTag,
-  normalizeSql,
-  lateralColumnAlias,
-  keysetRowValues,
-  keysetRowIsAfter,
-  iterateKeyset,
-  isExecutableRead,
-  isDbNow,
-  inspectNativeRlsTransaction,
-  inspectNativeRls,
-  inheritReadOnly,
-  hasNestedWrites,
-  getModelMeta,
-  getFieldMeta,
-  getCodec,
-  generateUuid,
-  generateUlid,
-  generateNanoid,
-  generateDefaultValue,
-  generateCuid,
-  formatStatementDiagnostic,
-  formatNativeRlsReport,
-  explainSql,
-  explainOperation,
-  explainOnSession,
-  encodeValue,
-  encodeKeysetToken,
-  delegateMethodAccess,
-  defineDatabaseModule,
-  decodeValue,
-  decodeRows,
-  decodeRow,
-  decodeKeysetToken,
-  decodeIsNoop2 as decodeIsNoop,
-  decodeAggregateValue,
-  decode2 as decode,
-  dbNow,
-  createWithNested,
-  createView,
-  createTelemetryRecorder,
-  createTelemetryCollector,
-  createStatementDiagnostics,
-  createSqlModel,
-  createScopeRewriter,
-  createClient,
-  compileWhere,
-  compileSelect,
-  compileOrderBy,
-  compileKeysetOrderPlan,
-  compileKeysetOrderInputs,
-  compileAdvisoryLock,
-  clientMemberAccess,
-  checkStrictArguments,
-  buildRuntimeMeta,
-  buildQuery,
-  buildExtensionOperatorMap,
-  buildConnectHooks,
-  attachScoped,
-  attachRelations,
-  attachReadOnly,
-  attachPolicy,
-  attachLateralRelations,
-  attachDefineView,
-  assertNativeRlsReady,
-  assertExtensionManifest,
-  assertComputedManifest,
-  applyWriteValidators,
-  applyComputedFields,
-  analyzeOperationTelemetry,
-  affectedRowsAreRowCounts,
-  WRITE_DELEGATE_METHODS,
-  ViewResult,
-  TELEMETRY_DEFAULTS,
-  STATEMENT_DIAGNOSTICS_DEFAULTS,
-  SQLITE_CODECS,
-  SKIP,
-  READ_DELEGATE_METHODS,
-  POSTGRES_CODECS,
-  PLAN_DEFAULTS,
-  MYSQL_CODECS,
-  KEYSET_TOKEN_VERSION,
-  KEYSET_TOKEN_PREFIX,
-  KEYSET_MAX_PAGE_SIZE,
-  DIALECT_CODECS2 as DIALECT_CODECS,
-  DIAGNOSTIC_THRESHOLDS,
-  DELEGATE_METHOD_ACCESS,
+  CLIENT_MEMBER_ACCESS,
   COUNT_ALIAS,
-  CLIENT_MEMBER_ACCESS
+  DELEGATE_METHOD_ACCESS,
+  DIAGNOSTIC_THRESHOLDS,
+  DIALECT_CODECS2 as DIALECT_CODECS,
+  KEYSET_MAX_PAGE_SIZE,
+  KEYSET_TOKEN_PREFIX,
+  KEYSET_TOKEN_VERSION,
+  MYSQL_CODECS,
+  PLAN_DEFAULTS,
+  POSTGRES_CODECS,
+  READ_DELEGATE_METHODS,
+  SKIP,
+  SQLITE_CODECS,
+  STATEMENT_DIAGNOSTICS_DEFAULTS,
+  TELEMETRY_DEFAULTS,
+  ViewResult,
+  WRITE_DELEGATE_METHODS,
+  affectedRowsAreRowCounts,
+  analyzeOperationTelemetry,
+  applyComputedFields,
+  applyWriteValidators,
+  assertComputedManifest,
+  assertExtensionManifest,
+  assertNativeRlsReady,
+  attachDefineView,
+  attachLateralRelations,
+  attachPolicy,
+  attachReadOnly,
+  attachRelations,
+  attachScoped,
+  buildConnectHooks,
+  buildExtensionOperatorMap,
+  buildQuery,
+  buildRuntimeMeta,
+  checkStrictArguments,
+  clientMemberAccess,
+  compileAdvisoryLock,
+  compileKeysetOrderInputs,
+  compileKeysetOrderPlan,
+  compileOrderBy,
+  compileSelect,
+  compileWhere,
+  createClient,
+  createScopeRewriter,
+  createSqlModel,
+  createStatementDiagnostics,
+  createTelemetryCollector,
+  createTelemetryRecorder,
+  createView,
+  createWithNested,
+  dbNow,
+  decode2 as decode,
+  decodeAggregateValue,
+  decodeIsNoop2 as decodeIsNoop,
+  decodeKeysetToken,
+  decodeRow,
+  decodeRows,
+  decodeValue,
+  defineDatabaseModule,
+  delegateMethodAccess,
+  encodeKeysetToken,
+  encodeValue,
+  explainOnSession,
+  explainOperation,
+  explainSql,
+  formatNativeRlsReport,
+  formatStatementDiagnostic,
+  generateCuid,
+  generateDefaultValue,
+  generateNanoid,
+  generateUlid,
+  generateUuid,
+  getCodec,
+  getFieldMeta,
+  getModelMeta,
+  hasNestedWrites,
+  inheritReadOnly,
+  inspectNativeRls,
+  inspectNativeRlsTransaction,
+  isDbNow,
+  isExecutableRead,
+  iterateKeyset,
+  keysetRowIsAfter,
+  keysetRowValues,
+  lateralColumnAlias,
+  normalizeSql,
+  parameterTypeTag,
+  parseDiagnosticsEnv,
+  parsePostgresPlan,
+  previewOperation,
+  queryFingerprint,
+  readOnlyRefusal,
+  readWorkloadStatistics,
+  recommendFromPlan,
+  resolveRelationLink,
+  resolveRelationSelection,
+  resolveResultShape,
+  resolveScopedModels,
+  resolveStatementDiagnostics,
+  resolveTelemetryConfig,
+  rewriteScopedCall,
+  sql2 as sql,
+  sqlProjection,
+  summarizePlan,
+  toClientName,
+  toSqlExecutor,
+  updateWithNested,
+  validateWriteData
 };
 
-//# debugId=22841846B558EACA64756E2164756E21
+//# debugId=BC9380E497613E8D64756E2164756E21