@palbase/backend 25.1.0 → 27.0.0

package/dist/test/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -23,7 +24,8 @@ __export(test_exports, {
   TestApiError: () => TestApiError,
   api: () => api,
   createTestApi: () => createTestApi,
-  fakeDatabase: () => fakeDatabase
+  fakeDatabase: () => fakeDatabase,
+  isolated: () => isolated
 });
 module.exports = __toCommonJS(test_exports);
 
@@ -40,8 +42,13 @@ function asPowChallenge(details) {
   const { id, prefix, difficulty } = c;
   if (typeof id !== "string" || typeof prefix !== "string") return null;
   if (typeof difficulty !== "number" || !Number.isInteger(difficulty) || difficulty < 0) return null;
-  return { id, prefix, difficulty };
+  return {
+    id,
+    prefix,
+    difficulty
+  };
 }
+__name(asPowChallenge, "asPowChallenge");
 var encoder = new TextEncoder();
 var hasher = null;
 async function digester() {
@@ -56,16 +63,17 @@ async function digester() {
       );
       if (typeof mod.createHash === "function") {
         const createHash = mod.createHash;
-        hasher = (input) => new Uint8Array(createHash("sha256").update(input).digest());
+        hasher = /* @__PURE__ */ __name((input) => new Uint8Array(createHash("sha256").update(input).digest()), "hasher");
         return hasher;
       }
     } catch {
     }
   }
-  hasher = async (input) => new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(input)));
+  hasher = /* @__PURE__ */ __name(async (input) => new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(input))), "hasher");
   return hasher;
 }
-var now = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+__name(digester, "digester");
+var now = /* @__PURE__ */ __name(() => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now(), "now");
 function leadingZeroBits(hash) {
   let bits = 0;
   for (const byte of hash) {
@@ -77,18 +85,18 @@ function leadingZeroBits(hash) {
   }
   return bits;
 }
+__name(leadingZeroBits, "leadingZeroBits");
 var MAX_POW_DIFFICULTY = 24;
 function powBudget(difficulty) {
   return 8 * 2 ** difficulty;
 }
+__name(powBudget, "powBudget");
 var POW_TIME_BUDGET_MS = 12e4;
 var CALIBRATION_WARMUP = 1024;
 var CALIBRATION_END = 9216;
 async function solvePowChallenge(challenge, maxIterations = powBudget(challenge.difficulty), signal) {
   if (challenge.difficulty > MAX_POW_DIFFICULTY) {
-    throw new Error(
-      `proof-of-work: refusing difficulty ${challenge.difficulty}; this client attempts at most ${MAX_POW_DIFFICULTY}, which is the highest a Palbase stack issues`
-    );
+    throw new Error(`proof-of-work: refusing difficulty ${challenge.difficulty}; this client attempts at most ${MAX_POW_DIFFICULTY}, which is the highest a Palbase stack issues`);
   }
   const digest = await digester();
   let warmedAt = 0;
@@ -100,9 +108,7 @@ async function solvePowChallenge(challenge, maxIterations = powBudget(challenge.
         throw new DOMException("proof-of-work solve aborted", "AbortError");
       }
       if (now() > deadline) {
-        throw new Error(
-          `proof-of-work: gave up on difficulty ${challenge.difficulty} after ${POW_TIME_BUDGET_MS / 1e3}s and ${nonce.toLocaleString()} attempts \u2014 the tail this run drew is longer than the allowance`
-        );
+        throw new Error(`proof-of-work: gave up on difficulty ${challenge.difficulty} after ${POW_TIME_BUDGET_MS / 1e3}s and ${nonce.toLocaleString()} attempts \u2014 the tail this run drew is longer than the allowance`);
       }
     }
     if (nonce === CALIBRATION_WARMUP) {
@@ -114,9 +120,7 @@ async function solvePowChallenge(challenge, maxIterations = powBudget(challenge.
       const rate = (CALIBRATION_END - CALIBRATION_WARMUP) / (elapsed / 1e3);
       const expectedMs = 2 ** challenge.difficulty / rate * 1e3;
       if (expectedMs > POW_TIME_BUDGET_MS) {
-        throw new Error(
-          `proof-of-work: difficulty ${challenge.difficulty} needs about ${Math.round(expectedMs / 1e3)}s here (${Math.round(rate).toLocaleString()} digests/s) and this client allows ${POW_TIME_BUDGET_MS / 1e3}s; refusing before spending the time rather than after`
-        );
+        throw new Error(`proof-of-work: difficulty ${challenge.difficulty} needs about ${Math.round(expectedMs / 1e3)}s here (${Math.round(rate).toLocaleString()} digests/s) and this client allows ${POW_TIME_BUDGET_MS / 1e3}s; refusing before spending the time rather than after`);
       }
       deadline = now() + (POW_TIME_BUDGET_MS - (now() - warmedAt));
     }
@@ -128,13 +132,15 @@ async function solvePowChallenge(challenge, maxIterations = powBudget(challenge.
       };
     }
   }
-  throw new Error(
-    `proof-of-work: no nonce found for difficulty ${challenge.difficulty} within ${maxIterations} attempts`
-  );
+  throw new Error(`proof-of-work: no nonce found for difficulty ${challenge.difficulty} within ${maxIterations} attempts`);
 }
+__name(solvePowChallenge, "solvePowChallenge");
 
 // src/test/api.ts
 var TestApiError = class extends Error {
+  static {
+    __name(this, "TestApiError");
+  }
   status;
   error;
   /** Payload of an error your code threw — `new BadRequest({ fields })` arrives here. */
@@ -154,12 +160,11 @@ var TestApiError = class extends Error {
 };
 function required(value, envName) {
   if (!value) {
-    throw new Error(
-      `${envName} is not set \u2014 the test client has nowhere to send requests. This is set by the deploy that runs your tests; if you are running them by hand, set it yourself.`
-    );
+    throw new Error(`${envName} is not set \u2014 the test client has nowhere to send requests. This is set by the deploy that runs your tests; if you are running them by hand, set it yourself.`);
   }
   return value;
 }
+__name(required, "required");
 function isLocalTarget(baseUrl) {
   try {
     const { hostname } = new URL(baseUrl);
@@ -168,6 +173,7 @@ function isLocalTarget(baseUrl) {
     return false;
   }
 }
+__name(isLocalTarget, "isLocalTarget");
 function secondsUntilExpiry(token) {
   const body = token.split(".")[1];
   if (!body) return null;
@@ -178,6 +184,7 @@ function secondsUntilExpiry(token) {
     return null;
   }
 }
+__name(secondsUntilExpiry, "secondsUntilExpiry");
 function createTestApi(config) {
   const baseUrl = required(config.baseUrl, "PALBASE_TEST_BASE_URL").replace(/\/$/, "");
   const apiKey = required(config.apiKey, "PALBASE_TEST_API_KEY");
@@ -192,7 +199,9 @@ function createTestApi(config) {
       // Selects the release under test. Omit it and the gateway serves the LIVE
       // one, which would make the whole suite grade the wrong code. Absent only
       // against a local stack, which has a single version.
-      ...candidateToken ? { "x-palbase-candidate": candidateToken } : {},
+      ...candidateToken ? {
+        "x-palbase-candidate": candidateToken
+      } : {},
       ...opts.headers
     };
     if (bearer) headers.authorization = `Bearer ${bearer}`;
@@ -205,7 +214,12 @@ function createTestApi(config) {
     });
     const text = await res.text();
     const parsed = text ? safeParse(text) : void 0;
-    requests.push({ method, path, status: res.status, ms: Date.now() - startedAt });
+    requests.push({
+      method,
+      path,
+      status: res.status,
+      ms: Date.now() - startedAt
+    });
     if (!res.ok) {
       if (res.status === 401 && bearer) {
         const left = secondsUntilExpiry(bearer);
@@ -220,41 +234,39 @@ function createTestApi(config) {
     }
     return parsed;
   }
+  __name(call, "call");
   return {
     requests,
-    get: (path, opts) => call("GET", path, void 0, opts),
-    post: (path, body, opts) => call("POST", path, body, opts),
-    patch: (path, body, opts) => call("PATCH", path, body, opts),
-    put: (path, body, opts) => call("PUT", path, body, opts),
-    delete: (path, opts) => call("DELETE", path, void 0, opts),
-    query: (path, body, opts) => call("QUERY", path, body, opts),
+    get: /* @__PURE__ */ __name((path, opts) => call("GET", path, void 0, opts), "get"),
+    post: /* @__PURE__ */ __name((path, body, opts) => call("POST", path, body, opts), "post"),
+    patch: /* @__PURE__ */ __name((path, body, opts) => call("PATCH", path, body, opts), "patch"),
+    put: /* @__PURE__ */ __name((path, body, opts) => call("PUT", path, body, opts), "put"),
+    delete: /* @__PURE__ */ __name((path, opts) => call("DELETE", path, void 0, opts), "delete"),
+    query: /* @__PURE__ */ __name((path, body, opts) => call("QUERY", path, body, opts), "query"),
     async signInAs(name) {
       const identity = (config.identities ?? {})[name];
       if (!identity) {
         const declared = Object.keys(config.identities ?? {});
-        throw new Error(
-          `no test identity named ${JSON.stringify(name)} \u2014 the deploy mints one per user declared in config/test-users.ts` + (declared.length ? `; this run has: ${declared.join(", ")}` : (
-            // Not "you declared none": from here the two causes are
-            // indistinguishable, and blaming the customer's config for a
-            // platform failure sends them to look in the wrong file. The
-            // deploy log names which one it was.
-            ", and this run has none \u2014 either your config declares no users or the deploy could not mint them; the deploy log says which"
-          ))
-        );
+        throw new Error(`no test identity named ${JSON.stringify(name)} \u2014 the deploy mints one per user declared in config/test-users.ts` + (declared.length ? `; this run has: ${declared.join(", ")}` : (
+          // indistinguishable, and blaming the customer's config for a
+          // platform failure sends them to look in the wrong file. The
+          // deploy log names which one it was.
+          ", and this run has none \u2014 either your config declares no users or the deploy could not mint them; the deploy log says which"
+        )));
       }
       if (identity.accessToken) {
         bearer = identity.accessToken;
-        return { id: identity.id ?? "", email: identity.email };
+        return {
+          id: identity.id ?? "",
+          email: identity.email
+        };
       }
       return this.signIn(identity);
     },
     async signIn(credentials) {
-      const attempt = async (extra) => call(
-        "POST",
-        "/auth/login",
-        credentials,
-        extra ? { headers: extra } : {}
-      );
+      const attempt = /* @__PURE__ */ __name(async (extra) => call("POST", "/auth/login", credentials, extra ? {
+        headers: extra
+      } : {}), "attempt");
       let result;
       try {
         result = await attempt();
@@ -265,7 +277,9 @@ function createTestApi(config) {
         result = await attempt(await solvePowChallenge(challenge));
       }
       bearer = result.access_token;
-      return result.user ?? { id: "" };
+      return result.user ?? {
+        id: ""
+      };
     },
     async signOut() {
       await call("POST", "/auth/logout", void 0);
@@ -276,6 +290,7 @@ function createTestApi(config) {
     }
   };
 }
+__name(createTestApi, "createTestApi");
 function parseIdentities(raw) {
   if (!raw) return {};
   try {
@@ -284,6 +299,7 @@ function parseIdentities(raw) {
     return {};
   }
 }
+__name(parseIdentities, "parseIdentities");
 function safeParse(text) {
   try {
     return JSON.parse(text);
@@ -291,6 +307,7 @@ function safeParse(text) {
     return text;
   }
 }
+__name(safeParse, "safeParse");
 var configured = null;
 var api = new Proxy({}, {
   get(_target, prop) {
@@ -304,57 +321,438 @@ var api = new Proxy({}, {
   }
 });
 
+// src/test/container.ts
+var import_reflect_metadata = require("reflect-metadata");
+function isolated() {
+  const over = /* @__PURE__ */ new Map();
+  const local = /* @__PURE__ */ new Map();
+  const make = /* @__PURE__ */ __name((c) => {
+    if (over.has(c)) return over.get(c);
+    const hit = local.get(c);
+    if (hit !== void 0) return hit;
+    const meta = Reflect.getMetadata("design:paramtypes", c) ?? [];
+    const inst = new c(...meta.map((d) => make(d)));
+    local.set(c, inst);
+    return inst;
+  }, "make");
+  const api2 = {
+    with(t, v) {
+      over.set(t, v);
+      return api2;
+    },
+    get(t) {
+      return make(t);
+    }
+  };
+  return api2;
+}
+__name(isolated, "isolated");
+
 // src/db/input-guards.ts
-var KNOWN_OPS = /* @__PURE__ */ new Set(["gt", "gte", "lt", "lte", "neq", "eq", "in"]);
+var REF_BRAND = /* @__PURE__ */ Symbol.for("palbase.db.ref");
+function brandOf(v) {
+  if (typeof v !== "object" || v === null) return void 0;
+  return Object.hasOwn(v, REF_BRAND) ? v[REF_BRAND] : void 0;
+}
+__name(brandOf, "brandOf");
+function isColRef(v) {
+  return brandOf(v) === "col" && typeof v.$col === "string";
+}
+__name(isColRef, "isColRef");
+function isSqlFragment(v) {
+  if (brandOf(v) !== "sql") return false;
+  const f = v.$sql;
+  return f !== void 0 && Array.isArray(f.text) && Array.isArray(f.values);
+}
+__name(isSqlFragment, "isSqlFragment");
+var TX_EXPR = /* @__PURE__ */ Symbol.for("palbase.tx.expr");
+function isColumnExpr(v) {
+  if (typeof v !== "object" && typeof v !== "function") return false;
+  if (v === null) return false;
+  try {
+    return v[TX_EXPR] !== void 0;
+  } catch {
+    return false;
+  }
+}
+__name(isColumnExpr, "isColumnExpr");
+function assertNoExpressionHandles(caller, table, cols, data) {
+  for (const c of cols) {
+    const v = data[c];
+    if (isColumnExpr(v)) {
+      throw new Error(`${caller}(${table}): "${c}" bir ifade tutama\u011F\u0131 ald\u0131 (increment()/decrement()/now()). Bu yolda de\u011Fer beklenir. Saya\xE7 art\u0131\u015F\u0131 i\xE7in updateMany(where, { ${c}: increment(n) }) ya da $transaction i\xE7inde tx.tables.${table}.updateWhere(where, { ${c}: increment(n) }) kullan\u0131n.`);
+    }
+    if (isColRef(v)) {
+      throw new Error(`${caller}(${table}): "${c}" bir col() ald\u0131. Kolon referans\u0131 yaln\u0131z F\u0130LTREDE durabilir; bir kolonun de\u011Ferini ba\u015Fka bir kolona yazmak i\xE7in $query kullan\u0131n.`);
+    }
+  }
+}
+__name(assertNoExpressionHandles, "assertNoExpressionHandles");
+var KNOWN_OPS = /* @__PURE__ */ new Set([
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "neq",
+  "in",
+  // K1 metin operatörleri (FR-005) ve null testi (FR-006). Bu küme
+  // `fakeDatabase()` ile ORTAK kaynaktır: fake bir çağrıyı motorun reddettiği
+  // yerde kabul ederse, yazarın testi üretimde patlayan koda karşı yeşil verir.
+  "contains",
+  "icontains",
+  "startsWith",
+  "endsWith",
+  "isNull"
+]);
+var REFUSED_OPS = {
+  eq: 'e\u015Fitlik \xC7IPLAK yaz\u0131l\u0131r: { <kolon>: <de\u011Fer> } (ya da kolon kar\u015F\u0131la\u015Ft\u0131rmas\u0131 i\xE7in { <kolon>: col("\u2026") })'
+};
 function assertUsableFilter(caller, table, where) {
+  const COMPOSITES = /* @__PURE__ */ new Set([
+    "OR",
+    "AND",
+    "NOT"
+  ]);
   if (!where) return;
+  if (isSqlFragment(where)) return;
   for (const [col, cond] of Object.entries(where)) {
+    if (COMPOSITES.has(col)) {
+      const branches = col === "NOT" ? [
+        cond
+      ] : cond;
+      if (!Array.isArray(branches) && col !== "NOT") {
+        throw new Error(`${caller}(${table}): where.${col} bir dizi olmal\u0131`);
+      }
+      for (const b of branches) {
+        if (b === null || typeof b !== "object") {
+          throw new Error(`${caller}(${table}): where.${col} dallar\u0131 filtre nesnesi olmal\u0131`);
+        }
+        assertUsableFilter(caller, table, b);
+      }
+      continue;
+    }
+    if (col === "has") {
+      if (cond === null || typeof cond !== "object" || Array.isArray(cond)) {
+        throw new Error(`${caller}(${table}): where.has bir ili\u015Fki haritas\u0131 olmal\u0131 ({ <ili\u015Fki>: { \u2026 } })`);
+      }
+      for (const [rel, inner] of Object.entries(cond)) {
+        if (inner === null || typeof inner !== "object" || Array.isArray(inner)) {
+          throw new Error(`${caller}(${table}): where.has.${rel} bir filtre nesnesi olmal\u0131`);
+        }
+        assertUsableFilter(caller, table, inner);
+      }
+      continue;
+    }
     if (cond === void 0) {
-      throw new Error(
-        `${caller}(${table}): where.${col} de\u011Feri undefined \u2014 bu bir filtre de\u011Feri de\u011Fil. Ba\u011Flan\u0131nca NULL olur ve '= NULL' hi\xE7bir sat\u0131ra uymaz, yani sorgu sessizce bo\u015F sonu\xE7 d\xF6nerdi. De\u011Fer yoksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n.`
-      );
+      throw new Error(`${caller}(${table}): where.${col} de\u011Feri undefined \u2014 bu bir filtre de\u011Feri de\u011Fil. Ba\u011Flan\u0131nca NULL olur ve '= NULL' hi\xE7bir sat\u0131ra uymaz, yani sorgu sessizce bo\u015F sonu\xE7 d\xF6nerdi. De\u011Fer yoksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n.`);
     }
     if (cond === null || typeof cond !== "object" || Array.isArray(cond)) continue;
+    if (isColRef(cond)) continue;
     const entries = Object.entries(cond);
     if (entries.length === 0) {
-      throw new Error(
-        `${caller}(${table}): where.${col} bo\u015F bir operat\xF6r nesnesi ({}) \u2014 hi\xE7bir ko\u015Ful \xFCretmez, yani bu alan filtreden sessizce D\xDC\u015EERD\u0130. Ko\u015Ful kurulmayacaksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n (D-21).`
-      );
+      throw new Error(`${caller}(${table}): where.${col} bo\u015F bir operat\xF6r nesnesi ({}) \u2014 hi\xE7bir ko\u015Ful \xFCretmez, yani bu alan filtreden sessizce D\xDC\u015EERD\u0130. Ko\u015Ful kurulmayacaksa anahtar\u0131 filtreye hi\xE7 koymay\u0131n (D-21).`);
     }
     for (const [op, v] of entries) {
       if (op === "in") {
         if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${col}.in bir dizi olmal\u0131`);
         if (v.some((x) => x === void 0)) {
-          throw new Error(
-            `${caller}(${table}): where.${col}.in listesinde undefined var \u2014 sessizce NULL'a ba\u011Flan\u0131r ve o eleman hi\xE7bir sat\u0131rla e\u015Fle\u015Fmez. Listeyi kurarken eleyin.`
-          );
+          throw new Error(`${caller}(${table}): where.${col}.in listesinde undefined var \u2014 sessizce NULL'a ba\u011Flan\u0131r ve o eleman hi\xE7bir sat\u0131rla e\u015Fle\u015Fmez. Listeyi kurarken eleyin.`);
         }
         continue;
       }
+      if (REFUSED_OPS[op] !== void 0) {
+        throw new Error(`${caller}(${table}): where.${col}.${op} bu filtre dilinde yok \u2014 ${REFUSED_OPS[op]}`);
+      }
       if (!KNOWN_OPS.has(op)) {
-        throw new Error(
-          `${caller}(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in)`
-        );
+        throw new Error(`${caller}(${table}): where.${col} bilinmeyen operat\xF6r "${op}" (gt/gte/lt/lte/neq/in/contains/icontains/startsWith/endsWith/isNull)`);
       }
       if (v === void 0) {
-        throw new Error(
-          `${caller}(${table}): where.${col}.${op} de\u011Feri undefined \u2014 kar\u015F\u0131la\u015Ft\u0131rman\u0131n sa\u011F taraf\u0131 NULL olur ve sonu\xE7 hi\xE7bir sat\u0131ra uymaz. Ko\u015Fulu kurmay\u0131n.`
-        );
+        throw new Error(`${caller}(${table}): where.${col}.${op} de\u011Feri undefined \u2014 kar\u015F\u0131la\u015Ft\u0131rman\u0131n sa\u011F taraf\u0131 NULL olur ve sonu\xE7 hi\xE7bir sat\u0131ra uymaz. Ko\u015Fulu kurmay\u0131n.`);
       }
     }
   }
 }
+__name(assertUsableFilter, "assertUsableFilter");
 function assertUsableWriteValues(caller, table, cols, data) {
   for (const c of cols) {
     if (data[c] === void 0) {
-      throw new Error(
-        `${caller}(${table}): "${c}" de\u011Feri undefined \u2014 bu bir yazma de\u011Feri de\u011Fil. Kolonu bo\u015Faltmak istiyorsan null yaz; kolonu de\u011Fi\u015Ftirmek istemiyorsan nesneye hi\xE7 koyma (bir eksik istek alan\u0131 sessizce NULL yaz\u0131yordu \u2014 FR-016).`
-      );
+      throw new Error(`${caller}(${table}): "${c}" de\u011Feri undefined \u2014 bu bir yazma de\u011Feri de\u011Fil. Kolonu bo\u015Faltmak istiyorsan null yaz; kolonu de\u011Fi\u015Ftirmek istemiyorsan nesneye hi\xE7 koyma (bir eksik istek alan\u0131 sessizce NULL yaz\u0131yordu \u2014 FR-016).`);
     }
   }
 }
+__name(assertUsableWriteValues, "assertUsableWriteValues");
+
+// src/db/tx-plan.ts
+var TxRefError = class extends Error {
+  static {
+    __name(this, "TxRefError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "TxRefError";
+  }
+};
+var TxPlanError = class extends Error {
+  static {
+    __name(this, "TxPlanError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "TxPlanError";
+  }
+};
+var EXPR = /* @__PURE__ */ Symbol.for("palbase.tx.expr");
+var REF = /* @__PURE__ */ Symbol.for("palbase.tx.ref");
+var ROW = /* @__PURE__ */ Symbol.for("palbase.tx.row");
+var ROWS = /* @__PURE__ */ Symbol.for("palbase.tx.rows");
+var TRAPPED_PROPS = [
+  "then",
+  "valueOf",
+  "toString",
+  "toJSON",
+  Symbol.toPrimitive
+];
+function trap(prop, what, hint) {
+  const name = typeof prop === "symbol" ? prop.description ?? String(prop) : prop;
+  throw new TxRefError(`${what} was used as a value (via \`${name}\`). Nothing in a transaction callback has run yet, so there is no value to read. ${hint}`);
+}
+__name(trap, "trap");
+function columnExprOf(v) {
+  return exprOf(v);
+}
+__name(columnExprOf, "columnExprOf");
+function makeRef(op, field) {
+  const target = {
+    [REF]: {
+      op,
+      field
+    }
+  };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop === REF) return t[REF];
+      if (TRAPPED_PROPS.includes(prop)) {
+        trap(prop, `\`${field}\` of a row this transaction has not written yet`, "Pass it to another operation in the same plan, or return it from the callback and read it after `transaction()` resolves.");
+      }
+      return void 0;
+    }
+  });
+}
+__name(makeRef, "makeRef");
+function makeRowHandle(op) {
+  const target = {
+    [ROW]: op
+  };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (prop === ROW) return t[ROW];
+      if (TRAPPED_PROPS.includes(prop)) {
+        trap(prop, "A row this transaction has not written yet", "Read one of its columns to reference it, or return the row from the callback and read it after `transaction()` resolves.");
+      }
+      if (typeof prop === "symbol") return void 0;
+      return makeRef(op, prop);
+    }
+  });
+}
+__name(makeRowHandle, "makeRowHandle");
+function exprOf(v) {
+  if (typeof v !== "object" || v === null) return null;
+  const e = v[EXPR];
+  return typeof e === "object" && e !== null ? e : null;
+}
+__name(exprOf, "exprOf");
+var SKIPPED_OP = -1;
+var TxRowsImpl = class TxRowsImpl2 {
+  static {
+    __name(this, "TxRowsImpl");
+  }
+  builder;
+  opIndex;
+  what;
+  // Present so `isRowsHandle` recognises the object; never read for its value.
+  [ROWS] = true;
+  guarded = false;
+  constructor(builder, opIndex, what) {
+    this.builder = builder;
+    this.opIndex = opIndex;
+    this.what = what;
+  }
+  // The type-level `await` guard made real: TS rejects `await rows` at compile
+  // time, and reaching this means someone called `.then(...)` by hand.
+  then() {
+    throw new TxRefError(`${this.what} cannot be awaited: a transaction callback builds a plan, it does not run statements. Remove the \`await\`.`);
+  }
+  expectOne(error) {
+    this.declareGuard("one", 1, error);
+    if (this.opIndex === SKIPPED_OP) throw error;
+    return makeRowHandle(this.opIndex);
+  }
+  expectNone(error) {
+    this.declareGuard("none", 0, error);
+  }
+  expectAtLeast(n, error) {
+    assertGuardCount(n, "expectAtLeast");
+    this.declareGuard("atLeast", n, error);
+    if (this.opIndex === SKIPPED_OP && n > 0) throw error;
+  }
+  expectAtMost(n, error) {
+    assertGuardCount(n, "expectAtMost");
+    this.declareGuard("atMost", n, error);
+  }
+  declareGuard(kind, n, error) {
+    if (!(error instanceof Error)) {
+      throw new TxPlanError(`${this.what}: an expectation needs the Error to throw when it does not hold (e.g. \`.expect\u2026(new Conflict("already accepted"))\`).`);
+    }
+    if (this.guarded) {
+      throw new TxPlanError(`${this.what} already has an expectation. One operation carries one expectation; declare the second one on its own operation.`);
+    }
+    this.guarded = true;
+    if (this.opIndex === SKIPPED_OP) return;
+    this.builder.attachGuard(this.opIndex, kind, n, error);
+  }
+};
+function assertGuardCount(n, fn) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new TxPlanError(`${fn}(n) needs a non-negative integer, got ${String(n)}`);
+  }
+}
+__name(assertGuardCount, "assertGuardCount");
 
 // src/__tests__/helpers/mock-db.ts
+function refuseFragment(caller, table, where) {
+  if (isSqlFragment(where)) {
+    throw new Error(`${caller}(${table}): fakeDatabase bir sqlFragment'i de\u011Ferlendiremez \u2014 sahte depo SQL \xE7al\u0131\u015Ft\u0131rmaz. Filtreyi tipli filtre diliyle kurun (gt/gte/lt/lte/neq/in/contains/isNull, OR/AND/NOT), ya da bu testi ger\xE7ek bir Postgres'e kar\u015F\u0131 yaz\u0131n.`);
+  }
+  if (where === null || typeof where !== "object") return;
+  for (const [k, v] of Object.entries(where)) {
+    if (k === "OR" || k === "AND") {
+      for (const branch of Array.isArray(v) ? v : []) refuseFragment(caller, table, branch);
+    } else if (k === "NOT") {
+      refuseFragment(caller, table, v);
+    }
+  }
+}
+__name(refuseFragment, "refuseFragment");
+function addDecimal(cell, by, sign) {
+  if (cell === null || cell === void 0) return null;
+  if (typeof cell === "number" && typeof by === "number") return cell + sign * by;
+  const a = String(cell);
+  const b = String(by);
+  const parse = /* @__PURE__ */ __name((x) => {
+    const m = /^([+-]?)(\d*)(?:\.(\d*))?$/.exec(x.trim());
+    if (m === null || m[2] === "" && (m[3] ?? "") === "") return null;
+    const frac = m[3] ?? "";
+    const unit = BigInt(`${m[1] === "-" ? "-" : ""}${m[2] === "" ? "0" : m[2]}${frac}`);
+    return {
+      unit,
+      scale: frac.length
+    };
+  }, "parse");
+  const pa = parse(a);
+  const pb = parse(b);
+  if (pa === null || pb === null) {
+    throw new Error(`fakeDatabase: increment()/decrement() say\u0131sal olmayan bir de\u011Fere uyguland\u0131 ("${a}") \u2014 Postgres bunu "operator does not exist" ile reddeder.`);
+  }
+  const scale = Math.max(pa.scale, pb.scale);
+  const lift = /* @__PURE__ */ __name((v) => v.unit * 10n ** BigInt(scale - v.scale), "lift");
+  const total = lift(pa) + BigInt(sign) * lift(pb);
+  if (scale === 0) return typeof cell === "number" ? Number(total) : total.toString();
+  const neg = total < 0n;
+  const digits = (neg ? -total : total).toString().padStart(scale + 1, "0");
+  const out = `${neg ? "-" : ""}${digits.slice(0, -scale)}.${digits.slice(-scale)}`;
+  return typeof cell === "number" ? Number(out) : out;
+}
+__name(addDecimal, "addDecimal");
+function rowMatchesFilter(caller, table, row, f) {
+  return Object.entries(f).every(([k, c]) => {
+    if (k === "OR") return c.some((b) => rowMatchesFilter(caller, table, row, b));
+    if (k === "AND") return c.every((b) => rowMatchesFilter(caller, table, row, b));
+    if (k === "NOT") return !rowMatchesFilter(caller, table, row, c);
+    if (k === "has") {
+      throw new Error(`${caller}(${table}): fakeDatabase bir \`has\` filtresini \xE7\xF6zemez \u2014 ili\u015Fki grafi\u011Fi bildirimden t\xFCretiliyor ve sahte deponun bildirimi yok. Bu testi ger\xE7ek bir Postgres'e kar\u015F\u0131 yaz\u0131n, ya da ili\u015Fkiyi filtrede A\xC7IK\xC7A kurun (\xF6nce ili\u015Fki tablosunu okuyup { id: { in: [...] } } ile s\xFCz\xFCn).`);
+    }
+    return matchesCell(caller, table, row, k, c);
+  });
+}
+__name(rowMatchesFilter, "rowMatchesFilter");
+function cmp(a, b, op) {
+  if (a === null || a === void 0 || b === null || b === void 0) return false;
+  const l = a instanceof Date ? a.getTime() : a;
+  const r = b instanceof Date ? b.getTime() : b;
+  switch (op) {
+    case "eq":
+      return l === r;
+    case "neq":
+      return l !== r;
+    case "gt":
+      return l > r;
+    case "gte":
+      return l >= r;
+    case "lt":
+      return l < r;
+    case "lte":
+      return l <= r;
+    default:
+      return false;
+  }
+}
+__name(cmp, "cmp");
+function matchesCell(caller, table, row, key, cond) {
+  if (isColRef(cond)) return cmp(row[key], row[cond.$col], "eq");
+  if (cond !== null && typeof cond === "object" && !Array.isArray(cond)) {
+    return Object.entries(cond).every(([op, v]) => {
+      const cell = row[key];
+      if (isColRef(v)) {
+        if (![
+          "neq",
+          "gt",
+          "gte",
+          "lt",
+          "lte"
+        ].includes(op)) {
+          throw new Error(`${caller}(${table}): where.${key}.${op} col() ile kullan\u0131lamaz`);
+        }
+        return cmp(cell, row[v.$col], op);
+      }
+      switch (op) {
+        case "in":
+          if (!Array.isArray(v)) throw new Error(`${caller}(${table}): where.${key}.in bir dizi olmal\u0131`);
+          if (v.some(isColRef)) {
+            throw new Error(`${caller}(${table}): where.${key}.in col() ile kullan\u0131lamaz \u2014 kolon kar\u015F\u0131la\u015Ft\u0131rmas\u0131 i\xE7in gt/gte/lt/lte/neq kullan\u0131n`);
+          }
+          return v.includes(cell);
+        case "neq":
+        case "gt":
+        case "gte":
+        case "lt":
+        case "lte":
+          return cmp(cell, v, op);
+        // K1 metin operatörleri (FR-005) ve null testi (FR-006). Bunlar BURADA
+        // da olmak zorunda: guard onları KABUL ettiği anda fake sessizce yanlış
+        // cevap verir ve yazarın testi, üretimde farklı davranan koda karşı
+        // yeşil verirdi (input-guards.ts'in uyardığı tam sınıf).
+        case "isNull":
+          if (typeof v !== "boolean") throw new Error(`${caller}(${table}): where.${key}.isNull bir boolean olmal\u0131`);
+          return v ? cell == null : cell != null;
+        case "contains":
+        case "icontains":
+        case "startsWith":
+        case "endsWith": {
+          if (typeof v !== "string") throw new Error(`${caller}(${table}): where.${key}.${op} bir string olmal\u0131`);
+          if (typeof cell !== "string") return false;
+          if (op === "contains") return cell.includes(v);
+          if (op === "icontains") return cell.toLowerCase().includes(v.toLowerCase());
+          if (op === "startsWith") return cell.startsWith(v);
+          return cell.endsWith(v);
+        }
+        default:
+          throw new Error(`${caller}(${table}): where.${key} bilinmeyen operat\xF6r "${op}"`);
+      }
+    });
+  }
+  return row[key] === cond;
+}
+__name(matchesCell, "matchesCell");
 function createMockDB() {
   const store = /* @__PURE__ */ new Map();
   const tracked = {
@@ -370,11 +768,15 @@ function createMockDB() {
     }
     return rows;
   }
+  __name(rowsOf, "rowsOf");
   function track(map, table, row) {
     const list = map.get(table);
     if (list) list.push(row);
-    else map.set(table, [row]);
+    else map.set(table, [
+      row
+    ]);
   }
+  __name(track, "track");
   const ops = {
     // The bulk ops and count run against the SAME in-memory store the direct
     // ops write to, so a test that writes three rows and counts them gets 3 —
@@ -383,26 +785,38 @@ function createMockDB() {
     async updateMany(table, where, set) {
       if (Object.keys(where).length === 0) throw new Error(`updateMany(${table}): bo\u015F filtre`);
       assertUsableFilter("updateMany", table, where);
+      refuseFragment("updateMany", table, where);
       assertUsableWriteValues("updateMany", table, Object.keys(set), set);
-      const hit = (store.get(table) ?? []).filter(
-        (r) => Object.entries(where).every(([k, v]) => r[k] === v)
-      );
-      for (const row of hit) Object.assign(row, set);
+      const hit = (store.get(table) ?? []).filter((r) => rowMatchesFilter("updateMany", table, r, where));
+      for (const row of hit) {
+        for (const [k, v] of Object.entries(set)) {
+          const expr = columnExprOf(v);
+          if (expr !== null && expr.fn === "now") {
+            row[k] = /* @__PURE__ */ new Date();
+            continue;
+          }
+          if (expr !== null) {
+            row[k] = addDecimal(row[k], expr.by, expr.fn === "inc" ? 1 : -1);
+            continue;
+          }
+          row[k] = v;
+        }
+      }
       return hit;
     },
     async deleteMany(table, where) {
       if (Object.keys(where).length === 0) throw new Error(`deleteMany(${table}): bo\u015F filtre`);
       assertUsableFilter("deleteMany", table, where);
+      refuseFragment("deleteMany", table, where);
       const list = store.get(table) ?? [];
-      const keep = list.filter((r) => !Object.entries(where).every(([k, v]) => r[k] === v));
+      const keep = list.filter((r) => !rowMatchesFilter("deleteMany", table, r, where));
       store.set(table, keep);
       return list.length - keep.length;
     },
     async count(table, where = {}) {
       assertUsableFilter("count", table, where);
-      return (store.get(table) ?? []).filter(
-        (r) => Object.entries(where).every(([k, v]) => r[k] === v)
-      ).length;
+      refuseFragment("count", table, where);
+      return (store.get(table) ?? []).filter((r) => rowMatchesFilter("count", table, r, where)).length;
     },
     async search(_table, _params) {
       return [];
@@ -417,25 +831,90 @@ function createMockDB() {
       return [];
     },
     async supersede(_table, _id, row) {
-      return { id: crypto.randomUUID(), ...row };
+      return {
+        id: crypto.randomUUID(),
+        ...row
+      };
     },
     async query(_sql, _params) {
       return [];
     },
     async insert(table, data) {
       assertUsableWriteValues("insert", table, Object.keys(data), data);
-      const record = { id: crypto.randomUUID(), ...data };
+      assertNoExpressionHandles("insert", table, Object.keys(data), data);
+      const record = {
+        id: crypto.randomUUID(),
+        ...data
+      };
       rowsOf(table).push(record);
       track(tracked.inserted, table, record);
       return record;
     },
+    /**
+    * `claim` — motorla PARİTE (FR-033).
+    *
+    * Fake bunu sunmasaydı `claim` ile yazılmış bir servis, iskelenin yazarlara
+    * önerdiği test yolunda `undefined is not a function` verirdi; sunup da
+    * FARKLI davransaydı (ör. hep `inserted: true`) idempotency testi üretimde
+    * çalışmayan koda karşı yeşil olurdu.
+    *
+    * Anahtar ZATEN VARSA var olan satır dönüyor ve hiçbir şey yazılmıyor —
+    * motorun 23505 dalının aynısı.
+    */
+    /**
+    * `lockRows` — sahte depoda kilit YOKTUR, ama çağrı da patlamamalı.
+    *
+    * Motorla parite burada "aynı SQL" değil, "aynı SÖZLEŞME": boş liste
+    * no-op, tekrar edenler tekilleşir, ve PK'sı olmayan tablo adıyla
+    * reddedilir. Kilidin kendisi tek işlemli bir sahte depoda anlamsız —
+    * ama sözleşmeyi bozan bir çağrı burada da hata almalı.
+    */
+    async lockRows(table, ids) {
+      if (ids.length === 0) return;
+      const rows = store.get(table) ?? [];
+      const unique = [
+        ...new Set(ids)
+      ].sort();
+      const missing = unique.filter((id) => !rows.some((r) => r["id"] === id));
+      if (missing.length > 0 && rows.length > 0) {
+        throw new Error(`lockRows(${table}): \u015Fu id'ler yok: ${missing.join(", ")} \u2014 kilitlenecek sat\u0131r bulunamad\u0131.`);
+      }
+    },
+    /** Sahte depoda kilit yok; sözleşme (çağrı patlamaz) korunuyor. */
+    async advisoryXactLock(_key) {
+      return void 0;
+    },
+    async claim(table, unique, extra = {}) {
+      const keyCols = Object.keys(unique);
+      if (keyCols.length === 0) {
+        throw new Error(`claim(${table}): benzersiz alan verilmedi. claim, bir anahtar\u0131 sahiplenmektir; anahtar yoksa sahiplenecek bir \u015Fey de yok \u2014 insert(${table}, \u2026) kullan\u0131n.`);
+      }
+      assertUsableWriteValues("claim", table, keyCols, unique);
+      const existing = (store.get(table) ?? []).find((r) => keyCols.every((c) => r[c] === unique[c]));
+      if (existing) return {
+        inserted: false,
+        row: existing
+      };
+      const record = {
+        id: crypto.randomUUID(),
+        ...unique,
+        ...extra
+      };
+      rowsOf(table).push(record);
+      track(tracked.inserted, table, record);
+      return {
+        inserted: true,
+        row: record
+      };
+    },
     // Same semantics the engine's SQL has: match on the conflict columns, update
     // everything else, and return the resulting row either way.
-    async upsert(table, data, opts) {
+    async put(table, data, opts) {
       if (opts.onConflict.length === 0) {
-        throw new Error(`upsert into ${table}: onConflict en az bir kolon ad\u0131 ister`);
+        throw new Error(`put into ${table}: onConflict en az bir kolon ad\u0131 ister`);
       }
       assertUsableWriteValues("upsert", table, Object.keys(data), data);
+      assertNoExpressionHandles("upsert", table, Object.keys(data), data);
       const rows = rowsOf(table);
       const existing = rows.find((r) => opts.onConflict.every((c) => r[c] === data[c]));
       if (existing) {
@@ -444,16 +923,26 @@ function createMockDB() {
         }
         return existing;
       }
-      const record = { id: crypto.randomUUID(), ...data };
+      const record = {
+        id: crypto.randomUUID(),
+        ...data
+      };
       rows.push(record);
       track(tracked.inserted, table, record);
       return record;
     },
     async update(table, id, data) {
       assertUsableWriteValues("update", table, Object.keys(data), data);
+      assertNoExpressionHandles("update", table, Object.keys(data), data);
       const rows = store.get(table) ?? [];
       const idx = rows.findIndex((r) => r["id"] === id);
-      const updated = idx >= 0 ? { ...rows[idx], ...data } : { id, ...data };
+      const updated = idx >= 0 ? {
+        ...rows[idx],
+        ...data
+      } : {
+        id,
+        ...data
+      };
       if (idx >= 0) {
         rows[idx] = updated;
       }
@@ -466,7 +955,9 @@ function createMockDB() {
       if (idx >= 0) rows.splice(idx, 1);
       const list = tracked.deleted.get(table);
       if (list) list.push(id);
-      else tracked.deleted.set(table, [id]);
+      else tracked.deleted.set(table, [
+        id
+      ]);
     },
     async findById(table, id) {
       const rows = store.get(table) ?? [];
@@ -478,51 +969,60 @@ function createMockDB() {
     // thing a stand-in must never do.
     async findMany(table, query, opts) {
       assertUsableFilter("findMany", table, query);
+      refuseFragment("findMany", table, query);
       const rows = store.get(table) ?? [];
-      const matches2 = (row, key, cond) => {
-        if (cond !== null && typeof cond === "object" && !Array.isArray(cond)) {
-          return Object.entries(cond).every(([op, v]) => {
-            const cell = row[key];
-            switch (op) {
-              case "in":
-                return Array.isArray(v) && v.includes(cell);
-              case "neq":
-                return cell !== v;
-              case "gt":
-                return cell > v;
-              case "gte":
-                return cell >= v;
-              case "lt":
-                return cell < v;
-              case "lte":
-                return cell <= v;
-              default:
-                throw new Error(`findMany(${table}): where.${key} bilinmeyen operat\xF6r "${op}"`);
+      let out = query ? rows.filter((row) => rowMatchesFilter("findMany", table, row, query)) : [
+        ...rows
+      ];
+      const orderSpecs = opts?.orderBy === void 0 ? [] : Array.isArray(opts.orderBy) ? opts.orderBy : [
+        opts.orderBy
+      ];
+      if (orderSpecs.length > 0) {
+        out = [
+          ...out
+        ].sort((a, b) => {
+          for (const o of orderSpecs) {
+            const dir = o.direction === "desc" ? -1 : 1;
+            const x = a[o.column];
+            const y = b[o.column];
+            const xNull = x === null || x === void 0;
+            const yNull = y === null || y === void 0;
+            if (xNull || yNull) {
+              if (xNull && yNull) continue;
+              const nullsFirst = o.nulls === void 0 ? dir === -1 : o.nulls === "first";
+              return (xNull ? 1 : -1) * (nullsFirst ? -1 : 1);
             }
-          });
-        }
-        return row[key] === cond;
-      };
-      let out = query ? rows.filter((row) => Object.entries(query).every(([k, c]) => matches2(row, k, c))) : [...rows];
-      const order = opts?.orderBy;
-      if (order) {
-        const dir = order.direction === "desc" ? -1 : 1;
-        out = [...out].sort((a, b) => {
-          const x = a[order.column];
-          const y = b[order.column];
-          return x === y ? 0 : (x < y ? -1 : 1) * dir;
+            if (x === y) continue;
+            return (x < y ? -1 : 1) * dir;
+          }
+          return 0;
         });
       }
-      return opts?.limit === void 0 ? out : out.slice(0, opts.limit);
+      const page = opts?.limit === void 0 ? out : out.slice(0, opts.limit);
+      const cols = opts?.select;
+      if (cols === void 0 || cols.length === 0) return page;
+      return page.map((row) => Object.fromEntries(cols.map((c) => [
+        c,
+        row[c]
+      ])));
     }
   };
   async function txPlan(plan) {
     const snapshot = /* @__PURE__ */ new Map();
-    for (const [table, rows] of store) snapshot.set(table, [...rows]);
+    for (const [table, rows] of store) snapshot.set(table, [
+      ...rows
+    ]);
     const trackedSnapshot = {
       inserted: cloneTracked(tracked.inserted),
       updated: cloneTracked(tracked.updated),
-      deleted: new Map([...tracked.deleted].map(([k, v]) => [k, [...v]]))
+      deleted: new Map([
+        ...tracked.deleted
+      ].map(([k, v]) => [
+        k,
+        [
+          ...v
+        ]
+      ]))
     };
     const results = [];
     try {
@@ -540,8 +1040,11 @@ function createMockDB() {
       tracked.deleted = trackedSnapshot.deleted;
       throw err;
     }
-    return { results };
+    return {
+      results
+    };
   }
+  __name(txPlan, "txPlan");
   function applyOp(op, results) {
     switch (op.op) {
       case "upsert": {
@@ -553,27 +1056,54 @@ function createMockDB() {
           for (const [key, value] of Object.entries(values)) {
             if (!conflict.includes(key)) hit[key] = value;
           }
-          return { rows: [hit], rows_affected: 1 };
+          return {
+            rows: [
+              hit
+            ],
+            rows_affected: 1
+          };
         }
-        const created = { id: crypto.randomUUID(), ...values };
+        const created = {
+          id: crypto.randomUUID(),
+          ...values
+        };
         rows.push(created);
         track(tracked.inserted, op.table, created);
-        return { rows: [created], rows_affected: 1 };
+        return {
+          rows: [
+            created
+          ],
+          rows_affected: 1
+        };
       }
       case "insert": {
-        const record = { id: crypto.randomUUID(), ...resolveMap(op.values ?? {}, results, null) };
+        const record = {
+          id: crypto.randomUUID(),
+          ...resolveMap(op.values ?? {}, results, null)
+        };
         rowsOf(op.table).push(record);
         track(tracked.inserted, op.table, record);
-        return { rows: [record], rows_affected: 1 };
+        return {
+          rows: [
+            record
+          ],
+          rows_affected: 1
+        };
       }
       case "insertMany": {
         const written = (op.rows ?? []).map((row) => {
-          const record = { id: crypto.randomUUID(), ...resolveMap(row, results, null) };
+          const record = {
+            id: crypto.randomUUID(),
+            ...resolveMap(row, results, null)
+          };
           rowsOf(op.table).push(record);
           track(tracked.inserted, op.table, record);
           return record;
         });
-        return { rows: written, rows_affected: written.length };
+        return {
+          rows: written,
+          rows_affected: written.length
+        };
       }
       case "update": {
         const rows = rowsOf(op.table);
@@ -582,12 +1112,18 @@ function createMockDB() {
         for (let i = 0; i < rows.length; i++) {
           const row = rows[i];
           if (!row || !matches(row, where)) continue;
-          const next = { ...row, ...resolveMap(op.set ?? {}, results, row) };
+          const next = {
+            ...row,
+            ...resolveMap(op.set ?? {}, results, row)
+          };
           rows[i] = next;
           track(tracked.updated, op.table, next);
           written.push(next);
         }
-        return { rows: written, rows_affected: written.length };
+        return {
+          rows: written,
+          rows_affected: written.length
+        };
       }
       case "delete": {
         const rows = rowsOf(op.table);
@@ -599,23 +1135,32 @@ function createMockDB() {
           const list = tracked.deleted.get(op.table);
           const key = typeof id === "string" ? id : String(id);
           if (list) list.push(key);
-          else tracked.deleted.set(op.table, [key]);
+          else tracked.deleted.set(op.table, [
+            key
+          ]);
         }
-        return { rows: removed, rows_affected: removed.length };
+        return {
+          rows: removed,
+          rows_affected: removed.length
+        };
       }
       case "select": {
         const where = resolveMap(op.where ?? {}, results, null);
         let found = rowsOf(op.table).filter((row) => matches(row, where));
         if (op.limit !== void 0) found = found.slice(0, op.limit);
-        return { rows: found, rows_affected: found.length };
+        return {
+          rows: found,
+          rows_affected: found.length
+        };
       }
     }
   }
+  __name(applyOp, "applyOp");
   const client = {
     ...ops,
     // No real savepoint in memory: the fake runs the callback against the SAME
     // store. An assertion about rollback here would be asserting the fake.
-    attempt: (fn) => fn(ops),
+    attempt: /* @__PURE__ */ __name((fn) => fn(ops), "attempt"),
     txPlan,
     // In tests there is no real DB role; `asService()` returns the same
     // in-memory client so RLS-bypass code paths still hit the same store and
@@ -634,14 +1179,25 @@ function createMockDB() {
       return tracked.deleted.get(table) ?? [];
     },
     seed(table, data) {
-      store.set(table, [...data]);
+      store.set(table, [
+        ...data
+      ]);
     }
   };
   return client;
 }
+__name(createMockDB, "createMockDB");
 function cloneTracked(map) {
-  return new Map([...map].map(([k, v]) => [k, [...v]]));
+  return new Map([
+    ...map
+  ].map(([k, v]) => [
+    k,
+    [
+      ...v
+    ]
+  ]));
 }
+__name(cloneTracked, "cloneTracked");
 function resolveValue(value, results, current, column) {
   if (typeof value !== "object" || value === null) return value;
   const tagged = value;
@@ -663,6 +1219,7 @@ function resolveValue(value, results, current, column) {
   }
   return value;
 }
+__name(resolveValue, "resolveValue");
 function resolveMap(map, results, current) {
   const out = {};
   for (const [key, value] of Object.entries(map)) {
@@ -670,11 +1227,11 @@ function resolveMap(map, results, current) {
   }
   return out;
 }
+__name(resolveMap, "resolveMap");
 function matches(row, where) {
-  return Object.entries(where).every(
-    ([key, value]) => value === null ? row[key] === null || row[key] === void 0 : row[key] === value
-  );
+  return Object.entries(where).every(([key, value]) => value === null ? row[key] === null || row[key] === void 0 : row[key] === value);
 }
+__name(matches, "matches");
 function guardFailure(guard, count) {
   if (!guard) return null;
   const ok = guard.kind === "one" ? count === 1 : guard.kind === "none" ? count === 0 : guard.kind === "atLeast" ? count >= guard.n : count <= guard.n;
@@ -684,6 +1241,7 @@ function guardFailure(guard, count) {
     message: `expected ${guard.kind} ${guard.n} row(s), got ${count}`
   });
 }
+__name(guardFailure, "guardFailure");
 function txRejection(status, code, extra) {
   const err = new Error(extra.message);
   err.status = status;
@@ -691,31 +1249,37 @@ function txRejection(status, code, extra) {
   if (extra.slot !== void 0) err.slot = extra.slot;
   return err;
 }
+__name(txRejection, "txRejection");
 
 // src/test/fake-db.ts
 function fakeDatabase() {
   const mock = createMockDB();
   const queries = [];
   const db = Object.assign(Object.create(Object.getPrototypeOf(mock)), mock, {
-    query: async (sql, params = []) => {
-      queries.push({ sql, params });
+    query: /* @__PURE__ */ __name(async (sql, params = []) => {
+      queries.push({
+        sql,
+        params
+      });
       return mock.query(sql, params);
-    }
+    }, "query")
   });
   return {
     db,
     queries,
-    seed: (table, rows) => mock.seed(table, rows),
-    inserted: (table) => mock.inserted(table),
-    updated: (table) => mock.updated(table),
-    deleted: (table) => mock.deleted(table)
+    seed: /* @__PURE__ */ __name((table, rows) => mock.seed(table, rows), "seed"),
+    inserted: /* @__PURE__ */ __name((table) => mock.inserted(table), "inserted"),
+    updated: /* @__PURE__ */ __name((table) => mock.updated(table), "updated"),
+    deleted: /* @__PURE__ */ __name((table) => mock.deleted(table), "deleted")
   };
 }
+__name(fakeDatabase, "fakeDatabase");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   TestApiError,
   api,
   createTestApi,
-  fakeDatabase
+  fakeDatabase,
+  isolated
 });
 //# sourceMappingURL=index.cjs.map