@lunora/do 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/assertValidClientId-CBZ1zC96.mjs

@@ -0,0 +1,1745 @@
+import { sql } from 'drizzle-orm';
+import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './matchesStaticWhere-CFk6adSu.mjs';
+import { encodeAggregateKey, foldAggregateTally, aggregateTableName, coerceAggregateNumber, readAggregateValue } from './aggregateTableName-CxNqY1Sl.mjs';
+import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-28ZvvwKS.mjs';
+import { appendCdcChange } from './applyCdcChanges-Ctdmxmrv.mjs';
+export { CDC_LOG_TABLE, CDC_META_TABLE, applyCdcChanges, bumpCdcEpoch, migrateCdcLog, migrateCdcMeta, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './applyCdcChanges-Ctdmxmrv.mjs';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { i as isFtsAvailable, D as DOC_COLUMN$1, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT, d as aggUpsertSql, j as jsonPathSql, q as quoteIdentifier, t as tableColumns, e as qualifiedJsonPathSql } from './do-sql-BCHCWtrD.mjs';
+import { param } from './renderSql-D6eUcn2N.mjs';
+import { s as sortColumnName, m as matchesRankStaticWhere, e as encodePartitionKey, b as serializeSqlValue, r as rankTableName, a as resolveRankPartition, R as RANK_TIEBREAK } from './rank-CrkEIpF4.mjs';
+import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, scoreDocument } from './ftsTableName-BLEMawrp.mjs';
+import { SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
+import { decodeCursor, normalizeOrderKeys, buildSeekWhere, encodeCursor, buildSeekBeforeWhere } from './buildSeekWhere-lVsNXSLy.mjs';
+import NotFoundError from './NotFoundError-CMuMZt81.mjs';
+import { assertFlatPredicate, resolveRelationPredicates } from './assertFlatPredicate-DyVYReuT.mjs';
+import { runRowValidators, resolveWith, applyOnDelete } from './applyOnDelete-CMif2RKw.mjs';
+import { guardWriter } from './guardWriter-u3UlnCH5.mjs';
+import { createSystemReader } from './createSystemReader-8CzSZP9V.mjs';
+import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+import { runTriggers } from './runTriggers-5N6_Fx0A.mjs';
+import { compileWhereSql } from './compileWhereSql-CXrhFA3G.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BF5eL7kW.mjs';
+export { I as IDEMPOTENCY_TABLE, m as migrateIdempotency, r as readIdempotent, t as trimIdempotent, w as writeIdempotent } from './ctx-db-idempotency-DkC9rP91.mjs';
+export { runShardMigrations } from './runShardMigrations-C3bn5r93.mjs';
+
+const rankIndexFieldsUnchanged = (index, previous, next) => {
+  const fields = [...index.partitionBy ?? [], ...index.sortBy.map((key) => key.field), ...index.where ? Object.keys(index.where) : []];
+  return fields.every((field) => previous[field] === next[field]);
+};
+const syncRankIndexEntry = (sql$1, tableName, index, id, previous, next) => {
+  if (previous && next && rankIndexFieldsUnchanged(index, previous, next)) {
+    return;
+  }
+  const rankTable = rankTableName(tableName, index.name);
+  if (previous) {
+    runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(rankTable)} WHERE ${sql.identifier("__id__")} = ${id}`);
+  }
+  if (!next || index.where && !matchesRankStaticWhere(next, index.where)) {
+    return;
+  }
+  const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+  const columnsSql = sql.join(
+    ["__id__", "__partition__", ...sortColumns].map((column) => sql.identifier(column)),
+    sql`, `
+  );
+  const partitionKey = encodePartitionKey(index.partitionBy ?? [], next);
+  const sortValues = index.sortBy.map((key) => serializeSqlValue(next[key.field] ?? null));
+  const valuesSql = sql.join(
+    [id, partitionKey, ...sortValues].map((value) => param(value)),
+    sql`, `
+  );
+  runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(rankTable)} (${columnsSql}) VALUES (${valuesSql})`);
+};
+const createCompanionSync = (deps) => {
+  const { broadcast, invalidateCache, recordCdc, schema, sql: sql$1 } = deps;
+  const backfilled = /* @__PURE__ */ new Set();
+  const rankBackfilled = /* @__PURE__ */ new Set();
+  const ensureBackfilledIndex = (tableName, index) => {
+    const cacheKey = `${tableName}::${index.name}`;
+    if (backfilled.has(cacheKey)) {
+      return;
+    }
+    const aggTable = aggregateTableName(tableName, index.name);
+    const by = index.by ?? [];
+    const tallies = /* @__PURE__ */ new Map();
+    const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`).toArray();
+    for (const row of rows) {
+      const record = rowToDocument(row);
+      if (!record) {
+        continue;
+      }
+      if (index.where && !matchesStaticWhere(record, index.where)) {
+        continue;
+      }
+      const encoded = encodeAggregateKey(by, record);
+      foldAggregateTally(tallies, encoded, index, record);
+    }
+    runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(aggTable)}`);
+    const CHUNK_ROWS = 32;
+    const entries = [...tallies];
+    for (let start = 0; start < entries.length; start += CHUNK_ROWS) {
+      const chunk = entries.slice(start, start + CHUNK_ROWS);
+      const rowsSql = sql.join(
+        chunk.map(([encoded, tally]) => sql`(${encoded}, ${tally.value}, ${tally.count})`),
+        sql`, `
+      );
+      runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(aggTable)} (${AGG_KEY}, ${AGG_VALUE}, ${AGG_COUNT}) VALUES ${rowsSql}`);
+    }
+    backfilled.add(cacheKey);
+  };
+  const recomputeExtreme = (tableName, index, record) => {
+    const by = index.by ?? [];
+    const sqlFunction = aggregateSqlFunction(index.op);
+    const field = index.field ?? "";
+    const conditions = [];
+    for (const key of by) {
+      const value = serializeSqlValue(record[key] ?? null);
+      if (value === null) {
+        conditions.push(sql`${jsonPathSql(key)} IS NULL`);
+      } else {
+        conditions.push(sql`${jsonPathSql(key)} = ${value}`);
+      }
+    }
+    for (const [key, expected] of Object.entries(index.where ?? {})) {
+      const literal = expected !== null && typeof expected === "object" && !Array.isArray(expected) ? expected.eq : expected;
+      const value = serializeSqlValue(literal);
+      if (value === null) {
+        conditions.push(sql`${jsonPathSql(key)} IS NULL`);
+      } else {
+        conditions.push(sql`${jsonPathSql(key)} = ${value}`);
+      }
+    }
+    const whereSql = conditions.length > 0 ? sql` WHERE ${sql.join(conditions, sql` AND `)}` : sql``;
+    const ref = jsonPathSql(field);
+    const row = runDrizzle(
+      sql$1,
+      sql`SELECT ${sql.raw(sqlFunction)}(${ref}) AS value FROM ${sql.identifier(tableName)}${whereSql}`
+    ).one();
+    return { value: row.value ?? null };
+  };
+  const applyAggregateDelta = (tableName, index, previous, next) => {
+    const aggTable = aggregateTableName(tableName, index.name);
+    const { op } = index;
+    const field = index.field ?? "";
+    const pruneIfEmpty = (encodedKey) => {
+      runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encodedKey} AND ${AGG_COUNT} <= 0`);
+    };
+    const removes = previous && (!index.where || matchesStaticWhere(previous, index.where)) ? previous : void 0;
+    const adds = next && (!index.where || matchesStaticWhere(next, index.where)) ? next : void 0;
+    if (!removes && !adds) {
+      return;
+    }
+    if (op === "count") {
+      for (const [record, delta] of [
+        [removes, -1],
+        [adds, 1]
+      ]) {
+        if (!record) {
+          continue;
+        }
+        const encoded = encodeAggregateKey(index.by ?? [], record);
+        runDrizzle(
+          sql$1,
+          aggUpsertSql(
+            aggTable,
+            encoded,
+            delta,
+            delta,
+            sql`${AGG_VALUE} = ${AGG_VALUE} + excluded.${AGG_VALUE}, ${AGG_COUNT} = ${AGG_COUNT} + excluded.${AGG_COUNT}`
+          )
+        );
+      }
+      if (removes) {
+        pruneIfEmpty(encodeAggregateKey(index.by ?? [], removes));
+      }
+      return;
+    }
+    if (op === "sum" || op === "avg") {
+      for (const [record, sign] of [
+        [removes, -1],
+        [adds, 1]
+      ]) {
+        if (!record) {
+          continue;
+        }
+        const numeric = coerceAggregateNumber(record[field]);
+        if (numeric === void 0) {
+          continue;
+        }
+        const encoded = encodeAggregateKey(index.by ?? [], record);
+        runDrizzle(
+          sql$1,
+          aggUpsertSql(
+            aggTable,
+            encoded,
+            sign * numeric,
+            sign,
+            sql`${AGG_VALUE} = COALESCE(${AGG_VALUE}, 0) + excluded.${AGG_VALUE}, ${AGG_COUNT} = ${AGG_COUNT} + excluded.${AGG_COUNT}`
+          )
+        );
+      }
+      if (removes) {
+        pruneIfEmpty(encodeAggregateKey(index.by ?? [], removes));
+      }
+      return;
+    }
+    if (removes) {
+      const encoded = encodeAggregateKey(index.by ?? [], removes);
+      const removedValue = coerceAggregateNumber(removes[field]);
+      const existing = runDrizzle(
+        sql$1,
+        sql`SELECT ${AGG_VALUE} AS value, ${AGG_COUNT} AS count FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encoded}`
+      ).toArray()[0];
+      const remainingCount = (existing?.count ?? 0) - 1;
+      if (remainingCount <= 0) {
+        runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encoded}`);
+      } else if (existing && removedValue !== void 0 && existing.value !== null && removedValue === existing.value) {
+        const recomputed = recomputeExtreme(tableName, index, removes);
+        runDrizzle(
+          sql$1,
+          sql`UPDATE ${sql.identifier(aggTable)} SET ${AGG_VALUE} = ${recomputed.value}, ${AGG_COUNT} = ${remainingCount} WHERE ${AGG_KEY} = ${encoded}`
+        );
+      } else {
+        runDrizzle(sql$1, sql`UPDATE ${sql.identifier(aggTable)} SET ${AGG_COUNT} = ${AGG_COUNT} - 1 WHERE ${AGG_KEY} = ${encoded}`);
+      }
+    }
+    if (adds) {
+      const encoded = encodeAggregateKey(index.by ?? [], adds);
+      const addedValue = coerceAggregateNumber(adds[field]);
+      if (addedValue === void 0) {
+        runDrizzle(
+          sql$1,
+          // eslint-disable-next-line unicorn/no-null -- seeds an extreme-less group with NULL value
+          aggUpsertSql(aggTable, encoded, null, 1, sql`${AGG_COUNT} = ${AGG_COUNT} + 1`)
+        );
+      } else {
+        const op2 = op === "min" ? "MIN" : "MAX";
+        runDrizzle(
+          sql$1,
+          aggUpsertSql(
+            aggTable,
+            encoded,
+            addedValue,
+            1,
+            sql`${AGG_VALUE} = ${sql.raw(op2)}(COALESCE(${AGG_VALUE}, excluded.${AGG_VALUE}), excluded.${AGG_VALUE}), ${AGG_COUNT} = ${AGG_COUNT} + 1`
+          )
+        );
+      }
+    }
+  };
+  const ensureBackfilledForTable = (tableName) => {
+    const indexes = schema.tables[tableName]?.aggregateIndexes;
+    if (!indexes || indexes.length === 0) {
+      return;
+    }
+    for (const index of indexes) {
+      ensureBackfilledIndex(tableName, index);
+    }
+  };
+  const syncAggregates = (tableName, previous, next) => {
+    const indexes = schema.tables[tableName]?.aggregateIndexes;
+    if (!indexes || indexes.length === 0) {
+      return;
+    }
+    for (const index of indexes) {
+      applyAggregateDelta(tableName, index, previous, next);
+    }
+  };
+  const ensureRankBackfilled = (tableName, index) => {
+    const cacheKey = `${tableName}::rank::${index.name}`;
+    if (rankBackfilled.has(cacheKey)) {
+      return;
+    }
+    const rankTable = rankTableName(tableName, index.name);
+    const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`).toArray();
+    runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(rankTable)}`);
+    const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+    const columnsSql = sql.join(
+      ["__id__", "__partition__", ...sortColumns].map((column) => sql.identifier(column)),
+      sql`, `
+    );
+    for (const row of rows) {
+      const record = rowToDocument(row);
+      if (!record) {
+        continue;
+      }
+      if (index.where && !matchesRankStaticWhere(record, index.where)) {
+        continue;
+      }
+      const partitionKey = encodePartitionKey(index.partitionBy ?? [], record);
+      const sortValues = index.sortBy.map((key) => serializeSqlValue(record[key.field] ?? null));
+      const valuesSql = sql.join(
+        [record["_id"], partitionKey, ...sortValues].map((value) => param(value)),
+        sql`, `
+      );
+      runDrizzle(sql$1, sql`INSERT INTO ${sql.identifier(rankTable)} (${columnsSql}) VALUES (${valuesSql})`);
+    }
+    rankBackfilled.add(cacheKey);
+  };
+  const ensureRankBackfilledForTable = (tableName) => {
+    const indexes = schema.tables[tableName]?.rankIndexes;
+    if (!indexes || indexes.length === 0) {
+      return;
+    }
+    for (const index of indexes) {
+      ensureRankBackfilled(tableName, index);
+    }
+  };
+  const syncRanks = (tableName, id, previous, next) => {
+    const indexes = schema.tables[tableName]?.rankIndexes;
+    if (!indexes || indexes.length === 0) {
+      return;
+    }
+    for (const index of indexes) {
+      syncRankIndexEntry(sql$1, tableName, index, id, previous, next);
+    }
+  };
+  const syncSearch = (tableName, id, document) => {
+    const indexes = schema.tables[tableName]?.searchIndexes;
+    if (!indexes || indexes.length === 0 || !isFtsAvailable(sql$1)) {
+      return;
+    }
+    for (const index of indexes) {
+      const ftName = ftsTableName(tableName, index.name);
+      runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(ftName)} WHERE ${sql.identifier("__id__")} = ${id}`);
+      if (document) {
+        runDrizzle(
+          sql$1,
+          sql`INSERT INTO ${sql.identifier(ftName)} (${sql.identifier("__text__")}, ${sql.identifier("__id__")}) VALUES (${stringifySearchText(document[index.field])}, ${id})`
+        );
+      }
+    }
+  };
+  const syncCompanionsForInsert = (tableName, id, document) => {
+    syncSearch(tableName, id, document);
+    syncAggregates(tableName, void 0, document);
+    syncRanks(tableName, id, void 0, document);
+    invalidateCache(tableName, id);
+    recordCdc(tableName, id, "insert", document);
+    broadcast({ key: id, op: "insert", row: document, table: tableName });
+  };
+  return {
+    ensureBackfilledForTable,
+    ensureBackfilledIndex,
+    ensureRankBackfilled,
+    ensureRankBackfilledForTable,
+    syncAggregates,
+    syncCompanionsForInsert,
+    syncRanks,
+    syncSearch
+  };
+};
+
+const DOC_COLUMN = "__doc__";
+const encodeRankCursor = (values) => {
+  const json = JSON.stringify(values);
+  const bytes = new TextEncoder().encode(json);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCodePoint(byte);
+  }
+  return btoa(binary);
+};
+const resolveRankSeekTuple = (options) => {
+  if (options.after) {
+    return [options.after.partitionKey, ...options.after.sortValues, options.after.rowId];
+  }
+  return options.cursor ? decodeCursor(options.cursor) : void 0;
+};
+const buildRankSeekClause = (decoded, sortColumns, sortBy) => {
+  if (decoded?.length !== 1 + sortColumns.length + 1) {
+    return void 0;
+  }
+  const cols = [{ column: "__partition__", direction: "asc" }];
+  for (const [i, column] of sortColumns.entries()) {
+    cols.push({ column, direction: sortBy[i]?.direction ?? "asc" });
+  }
+  cols.push({ column: RANK_TIEBREAK, direction: "asc" });
+  const branches = [];
+  for (const [pivot, col] of cols.entries()) {
+    const conditions = [];
+    for (const [prefix, prefixCol] of cols.slice(0, pivot).entries()) {
+      conditions.push(sql`${sql.identifier(prefixCol.column)} IS ${decoded[prefix]}`);
+    }
+    conditions.push(sql`${sql.identifier(col.column)} ${sql.raw(col.direction === "desc" ? "<" : ">")} ${decoded[pivot]}`);
+    const [firstCondition] = conditions;
+    branches.push(conditions.length === 1 && firstCondition !== void 0 ? firstCondition : sql`(${sql.join(conditions, sql` AND `)})`);
+  }
+  return sql`(${sql.join(branches, sql` OR `)})`;
+};
+const NO_RANK_CURSOR = null;
+const buildRankContinueCursor = (last, sortColumns) => {
+  if (last === void 0) {
+    return NO_RANK_CURSOR;
+  }
+  const cursorValues = [last["__partition__"], ...sortColumns.map((column) => last[column]), last[RANK_TIEBREAK]];
+  return encodeRankCursor(cursorValues);
+};
+const buildRankPageRows = (rankRows, byId, sortColumns) => {
+  const rows = [];
+  for (const rankRow of rankRows) {
+    const rowId = rankRow[RANK_TIEBREAK];
+    if (typeof rowId !== "string") {
+      continue;
+    }
+    const doc = byId.get(rowId);
+    if (!doc) {
+      continue;
+    }
+    const partitionKey = typeof rankRow["__partition__"] === "string" ? rankRow["__partition__"] : "";
+    const sortValues = sortColumns.map((column) => rankRow[column] ?? null);
+    rows.push({ doc, key: { partitionKey, rowId, sortValues } });
+  }
+  return rows;
+};
+const hydrateDocsById = (deps, tableName, ids) => {
+  const { rowToDocument } = deps;
+  const byId = /* @__PURE__ */ new Map();
+  if (ids.length === 0) {
+    return byId;
+  }
+  const idList = sql.join(
+    ids.map((id) => param(id)),
+    sql`, `
+  );
+  const documentRows = runDrizzle(
+    deps.sql,
+    sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(tableName)} WHERE id IN (${idList})`
+  ).toArray();
+  for (const documentRow of documentRows) {
+    const record = rowToDocument(documentRow);
+    const recordId = documentRow["id"];
+    if (record && typeof recordId === "string") {
+      byId.set(recordId, record);
+    }
+  }
+  return byId;
+};
+const computeRankPage = (deps, tableName, indexName, rankPageOptions) => {
+  const { assertRankPartitionLocal, ensureRankBackfilled, onRead, schema } = deps;
+  const definition = schema.tables[tableName];
+  if (!definition) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  const index = definition.rankIndexes?.find((i) => i.name === indexName);
+  if (!index) {
+    throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+  }
+  assertRankPartitionLocal(tableName, definition, index);
+  onRead(tableName, SCAN_DEP);
+  ensureRankBackfilled(tableName, index);
+  const rankTable = rankTableName(tableName, index.name);
+  const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+  const take = Math.max(1, Math.min(1e3, Math.floor(rankPageOptions.take ?? 100)));
+  const effective = mergeWhere(rankPageOptions.baseWhere, rankPageOptions.where);
+  const partitionFromWhere = resolveRankPartition(index, effective);
+  const orderClauses = [sql`${sql.identifier("__partition__")} ASC`];
+  for (const [i, column] of sortColumns.entries()) {
+    const direction = index.sortBy[i]?.direction;
+    orderClauses.push(sql`${sql.identifier(column)} ${sql.raw(direction === "desc" ? "DESC" : "ASC")}`);
+  }
+  orderClauses.push(sql`${sql.identifier(RANK_TIEBREAK)} ASC`);
+  const whereClauses = [];
+  if (typeof rankPageOptions.partitionKey === "string") {
+    whereClauses.push(sql`${sql.identifier("__partition__")} = ${rankPageOptions.partitionKey}`);
+  } else if (partitionFromWhere) {
+    whereClauses.push(sql`${sql.identifier("__partition__")} = ${encodePartitionKey(index.partitionBy ?? [], partitionFromWhere)}`);
+  }
+  const decoded = resolveRankSeekTuple(rankPageOptions);
+  const seek = buildRankSeekClause(decoded, sortColumns, index.sortBy);
+  if (seek) {
+    whereClauses.push(seek);
+  }
+  const idColumn = sql.identifier(RANK_TIEBREAK);
+  const partitionColumn = sql.identifier("__partition__");
+  const innerWhere = whereClauses.length > 0 ? sql` WHERE ${sql.join(whereClauses, sql` AND `)}` : sql``;
+  const selectColumns = sortColumns.length > 0 ? sql`${idColumn}, ${partitionColumn}, ${sql.join(
+    sortColumns.map((column) => sql.identifier(column)),
+    sql`, `
+  )}` : sql`${idColumn}, ${partitionColumn}`;
+  const query = sql`SELECT ${selectColumns} FROM ${sql.identifier(rankTable)}${innerWhere} ORDER BY ${sql.join(orderClauses, sql`, `)} LIMIT ${sql.raw(String(take + 1))}`;
+  const rankRows = runDrizzle(deps.sql, query).toArray();
+  const hasMore = rankRows.length > take;
+  const usable = hasMore ? rankRows.slice(0, take) : rankRows;
+  const pageIds = usable.map((rankRow) => rankRow[RANK_TIEBREAK]);
+  const rows = buildRankPageRows(usable, hydrateDocsById(deps, tableName, pageIds), sortColumns);
+  const continueCursor = hasMore ? buildRankContinueCursor(usable.at(-1), sortColumns) : NO_RANK_CURSOR;
+  const directions = index.sortBy.map((key) => key.direction === "desc" ? "desc" : "asc");
+  return { continueCursor, directions, hasMore, rows };
+};
+
+const CLIENT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const assertValidClientId = (clientId) => {
+  if (!CLIENT_ID_PATTERN.test(clientId)) {
+    throw new Error(`invalid clientId ${JSON.stringify(clientId)}: a client-supplied row id must be a UUID`);
+  }
+};
+const MAX_TRIGGER_DEPTH = 50;
+const DEFAULT_BATCH_LIMIT = 500;
+const assertBatchLimit = (count, limit, op) => {
+  const cap = limit ?? DEFAULT_BATCH_LIMIT;
+  if (count > cap) {
+    throw Object.assign(new Error(`${op}: batch of ${String(count)} exceeds the limit of ${String(cap)} (raise options.limit or chunk the call)`), {
+      code: "BATCH_LIMIT_EXCEEDED",
+      name: "LunoraError",
+      status: 400
+    });
+  }
+};
+const createRangeBuilder = (stage) => {
+  const builder = {
+    eq: (field, value) => {
+      stage.sqlConditions.push({ comparator: "=", field, value });
+      return builder;
+    },
+    gt: (field, value) => {
+      stage.sqlConditions.push({ comparator: ">", field, value });
+      return builder;
+    },
+    gte: (field, value) => {
+      stage.sqlConditions.push({ comparator: ">=", field, value });
+      return builder;
+    },
+    lt: (field, value) => {
+      stage.sqlConditions.push({ comparator: "<", field, value });
+      return builder;
+    },
+    lte: (field, value) => {
+      stage.sqlConditions.push({ comparator: "<=", field, value });
+      return builder;
+    }
+  };
+  return builder;
+};
+const createSearchBuilder = (search, tableName) => {
+  const builder = {
+    eq: (field, value) => {
+      if (!search.definition.filterFields?.includes(field)) {
+        throw new Error(`field "${field}" is not a filter field of search index "${search.indexName}" on table "${tableName}"`);
+      }
+      search.filters.push({ field, value });
+      return builder;
+    },
+    search: (field, query) => {
+      if (field !== search.definition.field) {
+        throw new Error(`search index "${search.indexName}" on table "${tableName}" indexes "${search.definition.field}", not "${field}"`);
+      }
+      const stage = search;
+      stage.field = field;
+      stage.query = query;
+      stage.hasQuery = true;
+      return builder;
+    }
+  };
+  return builder;
+};
+const searchViaFts = (sql$1, tableName, search, limit) => {
+  const tokens = tokenizeSearch(search.query);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const ftName = ftsTableName(tableName, search.indexName);
+  const whereClauses = [sql`f.${sql.identifier("__text__")} MATCH ${buildFtsMatch(tokens)}`];
+  for (const filter of search.filters) {
+    whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
+  }
+  let query = sql`SELECT m.id, m._creationTime, m.${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(ftName)} f JOIN ${sql.identifier(tableName)} m ON m.id = f.${sql.identifier("__id__")} WHERE ${sql.join(whereClauses, sql` AND `)} ORDER BY f.rank, m._creationTime DESC`;
+  if (typeof limit === "number") {
+    query = sql`${query} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit))))}`;
+  }
+  const rows = runDrizzle(sql$1, query).toArray();
+  const docs = [];
+  for (const row of rows) {
+    const record = rowToDocument(row);
+    if (record) {
+      docs.push(record);
+    }
+  }
+  return docs;
+};
+const searchViaScan = (sql$1, tableName, search, limit) => {
+  const tokens = tokenizeSearch(search.query);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const whereClauses = [];
+  for (const filter of search.filters) {
+    whereClauses.push(sql`${jsonPathSql(filter.field)} = ${serializeSqlValue(filter.value)}`);
+  }
+  let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
+  if (whereClauses.length > 0) {
+    query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
+  }
+  const rows = runDrizzle(sql$1, query).toArray();
+  const scored = [];
+  for (const row of rows) {
+    const record = rowToDocument(row);
+    if (!record) {
+      continue;
+    }
+    const score = scoreDocument(stringifySearchText(record[search.field]), tokens);
+    if (score > 0) {
+      scored.push({ creationTime: typeof record["_creationTime"] === "number" ? record["_creationTime"] : 0, doc: record, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score || b.creationTime - a.creationTime);
+  const docs = scored.map((entry) => entry.doc);
+  return typeof limit === "number" ? docs.slice(0, Math.max(0, Math.floor(limit))) : docs;
+};
+const doWhereSqlStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };
+const makeRelationExistsSqlStrategy = (onRead) => {
+  let aliasCounter = 0;
+  const scopeStack = [];
+  const strategy = {
+    fieldRef: jsonPathSql,
+    relationExists: (request) => {
+      const { childWhere, negated, parentTable, relation } = request;
+      const alias = `__rel_${String(aliasCounter)}`;
+      const parentRef = scopeStack.at(-1) ?? parentTable;
+      aliasCounter += 1;
+      onRead(relation.table, SCAN_DEP);
+      const parentColumn = relation.kind === "one" ? relation.field : relation.references;
+      const childColumn = relation.kind === "one" ? relation.references : relation.field;
+      const correlation = sql`${qualifiedJsonPathSql(alias, childColumn)} = ${qualifiedJsonPathSql(parentRef, parentColumn)}`;
+      scopeStack.push(alias);
+      const childSql = compileWhereSql(childWhere, strategy);
+      scopeStack.pop();
+      const condition = childSql ? sql`${correlation} AND ${childSql}` : correlation;
+      const body = sql`EXISTS (SELECT 1 FROM ${sql.identifier(relation.table)} AS ${sql.identifier(alias)} WHERE ${condition})`;
+      return negated ? sql`NOT ${body}` : body;
+    },
+    serialize: serializeSqlValue
+  };
+  return strategy;
+};
+const compileOrderBySql = (keys) => {
+  const parts = keys.map((key) => sql`${jsonPathSql(key.field)} ${sql.raw(key.direction === "desc" ? "DESC" : "ASC")}`);
+  if (!keys.some((key) => key.field === "_id" || key.field === "id")) {
+    parts.push(sql`${jsonPathSql("id")} ASC`);
+  }
+  return sql.join(parts, sql`, `);
+};
+const COMPARATOR_TO_OPERATOR = { "<": "lt", "<=": "lte", "=": "eq", ">": "gt", ">=": "gte" };
+const paginateOrderKeys = (stage) => {
+  const direction = stage.order;
+  if (stage.indexFields.length > 0) {
+    return stage.indexFields.map((field) => {
+      return { direction, field };
+    });
+  }
+  return [{ direction, field: "_creationTime" }];
+};
+const paginateWhere = (stage, orderKeys, cursor, endCursor) => {
+  const clauses = stage.sqlConditions.map((condition) => {
+    return {
+      [condition.field]: { [COMPARATOR_TO_OPERATOR[condition.comparator] ?? "eq"]: condition.value }
+    };
+  });
+  if (cursor) {
+    clauses.push(buildSeekWhere(orderKeys, decodeCursor(cursor)));
+  }
+  if (endCursor) {
+    clauses.push(buildSeekBeforeWhere(orderKeys, decodeCursor(endCursor)));
+  }
+  if (clauses.length === 0) {
+    return void 0;
+  }
+  return clauses.length === 1 ? clauses[0] : { AND: clauses };
+};
+const scanDocs = (rows, filters, cap) => {
+  const docs = [];
+  for (const row of rows) {
+    const record = rowToDocument(row);
+    if (record && filters.every((predicate) => predicate(record))) {
+      docs.push(record);
+      if (cap !== void 0 && docs.length > cap) {
+        break;
+      }
+    }
+  }
+  return docs;
+};
+const paginateStage = (sql$1, tableName, stage, options) => {
+  const numberItems = Math.max(0, Math.floor(options.numItems));
+  const orderKeys = paginateOrderKeys(stage);
+  const bounded = typeof options.endCursor === "string";
+  const whereCondition = compileWhereSql(paginateWhere(stage, orderKeys, options.cursor, options.endCursor), doWhereSqlStrategy);
+  let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
+  if (whereCondition) {
+    query = sql`${query} WHERE ${whereCondition}`;
+  }
+  query = sql`${query} ORDER BY ${compileOrderBySql(orderKeys)}`;
+  const filtered = stage.inMemoryFilters.length > 0;
+  if (!filtered && !bounded) {
+    query = sql`${query} LIMIT ${sql.raw(String(numberItems + 1))}`;
+  }
+  const rows = runDrizzle(sql$1, query).toArray();
+  const docs = scanDocs(rows, stage.inMemoryFilters, filtered || bounded ? void 0 : numberItems);
+  if (bounded) {
+    const middle = docs.length >= 2 ? docs[Math.floor(docs.length / 2) - 1] : void 0;
+    return {
+      // eslint-disable-next-line unicorn/no-null -- QueryPage.continueCursor is `null | string`; a bounded page echoes its fixed endCursor (never null in this branch since `bounded` requires it), the `?? null` only satisfies the type
+      continueCursor: options.endCursor ?? null,
+      isDone: true,
+      page: docs,
+      // eslint-disable-next-line unicorn/no-null -- splitCursor is `null | string`; null marks "too small to split" so the client can read the field unconditionally
+      splitCursor: middle ? encodeCursor(middle, orderKeys) : null
+    };
+  }
+  const hasMore = docs.length > numberItems;
+  const page = hasMore ? docs.slice(0, numberItems) : docs;
+  const last = page.at(-1);
+  return {
+    // eslint-disable-next-line unicorn/no-null -- QueryPage.continueCursor is `null | string`: null is the documented "no further page" cursor on the wire
+    continueCursor: hasMore && last ? encodeCursor(last, orderKeys) : null,
+    isDone: !hasMore,
+    page
+  };
+};
+class NotUniqueError extends Error {
+  code = "NOT_UNIQUE";
+  status = 400;
+  constructor(message = "unique() found more than one matching document") {
+    super(message);
+    this.name = "NotUniqueError";
+  }
+}
+const ID_WHITESPACE_PATTERN = /\s/u;
+const NUL_CHARACTER = String.fromCodePoint(0);
+const normalizeIdStructurally = (schema, tableName, id) => {
+  if (!schema.tables[tableName]) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  if (typeof id !== "string" || id.length === 0 || ID_WHITESPACE_PATTERN.test(id) || id.includes(NUL_CHARACTER)) {
+    return null;
+  }
+  return id;
+};
+const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
+  const tableDefinition = schema.tables[tableName];
+  if (!tableDefinition) {
+    throw new Error(`unknown table: ${tableName}`);
+  }
+  const stage = {
+    indexFields: [],
+    indexName: void 0,
+    inMemoryFilters: [],
+    order: "asc",
+    sqlConditions: []
+  };
+  const runSearchFetch = (limit) => {
+    const { search } = stage;
+    if (!search) {
+      throw new Error("runSearchFetch called without a staged search");
+    }
+    const filtered = stage.inMemoryFilters.length > 0;
+    const engineLimit = filtered ? void 0 : limit;
+    const docs = isFtsAvailable(sql$1) ? searchViaFts(sql$1, tableName, search, engineLimit) : searchViaScan(sql$1, tableName, search, engineLimit);
+    if (!filtered) {
+      return docs;
+    }
+    const result = [];
+    for (const record of docs) {
+      if (stage.inMemoryFilters.every((predicate) => predicate(record))) {
+        result.push(record);
+        if (typeof limit === "number" && result.length >= limit) {
+          break;
+        }
+      }
+    }
+    return result;
+  };
+  const buildOrderClause = () => {
+    const orderFields = stage.indexFields.length > 0 ? stage.indexFields : ["_creationTime"];
+    const orderDirection = stage.order === "desc" ? "DESC" : "ASC";
+    return sql.join(
+      orderFields.map((field) => sql`${jsonPathSql(field)} ${sql.raw(orderDirection)}`),
+      sql`, `
+    );
+  };
+  const runFetch = (limit) => {
+    if (stage.search) {
+      return runSearchFetch(limit);
+    }
+    const whereClauses = [];
+    for (const condition of stage.sqlConditions) {
+      whereClauses.push(sql`${jsonPathSql(condition.field)} ${sql.raw(condition.comparator)} ${serializeSqlValue(condition.value)}`);
+    }
+    let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
+    if (whereClauses.length > 0) {
+      query = sql`${query} WHERE ${sql.join(whereClauses, sql` AND `)}`;
+    }
+    query = sql`${query} ORDER BY ${buildOrderClause()}`;
+    if (typeof limit === "number" && stage.inMemoryFilters.length === 0) {
+      query = sql`${query} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit))))}`;
+    }
+    const rows = runDrizzle(sql$1, query).toArray();
+    const docs = [];
+    for (const row of rows) {
+      const record = rowToDocument(row);
+      if (!record) {
+        continue;
+      }
+      if (stage.inMemoryFilters.every((predicate) => predicate(record))) {
+        docs.push(record);
+        if (typeof limit === "number" && docs.length >= limit) {
+          break;
+        }
+      }
+    }
+    return docs;
+  };
+  const reader = {
+    // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
+    async collect() {
+      return runFetch(void 0);
+    },
+    filter(predicate) {
+      stage.inMemoryFilters.push(predicate);
+      return reader;
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
+    async first() {
+      const rows = runFetch(stage.inMemoryFilters.length > 0 ? void 0 : 1);
+      return rows[0] ?? null;
+    },
+    order(direction) {
+      stage.order = direction === "desc" ? "desc" : "asc";
+      return reader;
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
+    async paginate(options) {
+      if (stage.search) {
+        throw new Error("pagination is not supported on search queries; use .take(n) or .collect()");
+      }
+      return paginateStage(sql$1, tableName, stage, options);
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
+    async take(limit) {
+      return runFetch(limit);
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
+    async unique() {
+      const rows = runFetch(stage.inMemoryFilters.length > 0 ? void 0 : 2);
+      if (rows.length > 1) {
+        throw new NotUniqueError(`unique() on table "${tableName}" matched ${String(rows.length)} documents; expected at most one`);
+      }
+      return rows[0] ?? null;
+    },
+    withIndex(indexName, range) {
+      const definition = tableDefinition.indexes.find((index) => index.name === indexName);
+      if (!definition) {
+        throw new Error(`unknown index "${indexName}" on table "${tableName}"`);
+      }
+      onIndexUse(tableName, indexName, "index");
+      stage.indexName = indexName;
+      stage.indexFields = definition.fields;
+      if (range) {
+        range(createRangeBuilder(stage));
+      }
+      return reader;
+    },
+    withSearchIndex(indexName, search) {
+      const definition = (tableDefinition.searchIndexes ?? []).find((index) => index.name === indexName);
+      if (!definition) {
+        throw new Error(`unknown search index "${indexName}" on table "${tableName}"`);
+      }
+      onIndexUse(tableName, indexName, "search");
+      const searchStage = {
+        definition,
+        field: definition.field,
+        filters: [],
+        hasQuery: false,
+        indexName,
+        query: ""
+      };
+      stage.search = searchStage;
+      search(createSearchBuilder(searchStage, tableName));
+      if (!searchStage.hasQuery) {
+        throw new Error(`search index "${indexName}" on table "${tableName}" requires a .search(field, query) call`);
+      }
+      return reader;
+    }
+  };
+  return reader;
+};
+const applyInsertDefaults = (definition, document, auth) => {
+  const result = { ...document };
+  for (const [field, column] of tableColumns(definition)) {
+    if (column.serverDefault) {
+      result[field] = column.serverDefault({ auth });
+      continue;
+    }
+    if (result[field] !== void 0) {
+      continue;
+    }
+    if (column.defaultFn) {
+      result[field] = column.defaultFn();
+    } else if ("defaultValue" in column) {
+      result[field] = column.defaultValue;
+    }
+  }
+  return result;
+};
+const applyOnUpdate = (definition, provided, target, auth) => {
+  const out = target;
+  for (const [field, column] of tableColumns(definition)) {
+    if (column.serverDefault) {
+      if (field in provided) {
+        out[field] = column.serverDefault({ auth });
+      }
+      continue;
+    }
+    if (column.onUpdateFn && !(field in provided)) {
+      out[field] = column.onUpdateFn();
+    }
+  }
+};
+const assertNoExplicitUndefined = (op, document) => {
+  for (const field of Object.keys(document)) {
+    if (document[field] === void 0) {
+      throw new Error(`Cannot ${op} field '${field}' to undefined — use null to clear a nullable field, or omit the key to leave it unchanged.`);
+    }
+  }
+};
+const UNIQUE_VIOLATION_RE = /unique constraint failed/i;
+const isUniqueViolation = (error) => error instanceof Error && UNIQUE_VIOLATION_RE.test(error.message);
+const runWrite = (sql, table, query) => {
+  try {
+    runDrizzle(sql, query);
+  } catch (error) {
+    if (isUniqueViolation(error)) {
+      throw new ConflictError(`unique constraint violation on "${table}"`, "unique");
+    }
+    throw error;
+  }
+};
+const runGuardedWrite = (sql$1, table, query) => {
+  runWrite(sql$1, table, query);
+  const changedRow = runDrizzle(sql$1, sql`SELECT changes() AS changed`).one();
+  if (changedRow.changed === 0) {
+    throw new ConflictError(`optimistic concurrency conflict on "${table}" — the row changed during this mutation; refetch and retry`, "occ");
+  }
+};
+const countRankBefore = (sql$1, rankTable, sortColumns, sortBy, partitionKey, serializedSortValues, rowId) => {
+  const beforeBranches = [];
+  for (let pivot = 0; pivot < sortColumns.length + 1; pivot += 1) {
+    const conditions = [];
+    for (let prefix = 0; prefix < pivot; prefix += 1) {
+      conditions.push(sql`${sql.identifier(sortColumns[prefix])} IS ${serializedSortValues[prefix]}`);
+    }
+    const column = sortColumns[pivot];
+    const sortKey = sortBy[pivot];
+    if (column !== void 0 && sortKey !== void 0) {
+      const operator = sortKey.direction === "desc" ? ">" : "<";
+      conditions.push(sql`${sql.identifier(column)} ${sql.raw(operator)} ${serializedSortValues[pivot]}`);
+    } else {
+      conditions.push(sql`${sql.identifier(RANK_TIEBREAK)} < ${rowId}`);
+    }
+    const [firstCondition] = conditions;
+    beforeBranches.push(conditions.length === 1 && firstCondition !== void 0 ? firstCondition : sql`(${sql.join(conditions, sql` AND `)})`);
+  }
+  const beforeWhere = sql.join(beforeBranches, sql` OR `);
+  const beforeRow = runDrizzle(
+    sql$1,
+    sql`SELECT COUNT(*) AS c FROM ${sql.identifier(rankTable)} WHERE ${sql.identifier("__partition__")} = ${partitionKey} AND (${beforeWhere})`
+  ).one();
+  const totalRow = runDrizzle(
+    sql$1,
+    sql`SELECT COUNT(*) AS c FROM ${sql.identifier(rankTable)} WHERE ${sql.identifier("__partition__")} = ${partitionKey}`
+  ).one();
+  return { before: beforeRow.c, total: totalRow.c };
+};
+const createShardCtxDb = (options) => {
+  const { sql: sql$1 } = options;
+  const { schema } = options;
+  const broadcast = options.broadcast ?? (() => void 0);
+  const onRead = options.onRead ?? (() => void 0);
+  const onIndexUse = options.onIndexUse ?? (() => void 0);
+  const onWrite = options.onWrite ?? (() => void 0);
+  const { cache } = options;
+  const clock = options.clock ?? (() => Date.now());
+  const generateId = options.idGenerator ?? (() => crypto.randomUUID());
+  const scheduler = options.scheduler ?? throwingScheduler;
+  const { globalDb } = options;
+  const auth = options.auth ?? { identity: null, userId: null };
+  const cdcEnabled = options.cdc ?? false;
+  const systemScheduler = scheduler;
+  const system = createSystemReader({
+    scheduler: typeof systemScheduler.list === "function" && typeof systemScheduler.get === "function" ? systemScheduler : void 0,
+    storage: options.storage
+  });
+  const recordCdc = (table, id, op, doc) => {
+    if (cdcEnabled) {
+      appendCdcChange(sql$1, clock(), table, id, op, doc);
+    }
+  };
+  const isGlobalTable = (tableName) => schema.tables[tableName]?.shardMode?.kind === "global";
+  const routeBackend = (table, op) => {
+    if (isGlobalTable(table)) {
+      if (!globalDb) {
+        throw new Error(`cross-backend ${op} for global table '${table}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`);
+      }
+      return globalDb;
+    }
+    return writer;
+  };
+  const routeForHolder = (holderTable) => routeBackend(holderTable, "cascade");
+  const globalWriterFor = (tableName, op) => {
+    if (!isGlobalTable(tableName)) {
+      return void 0;
+    }
+    if (!globalDb) {
+      throw new Error(`${op} on global table '${tableName}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`);
+    }
+    return globalDb;
+  };
+  const globalFallback = () => globalDb;
+  const relationFetcher = (relationTable, relationArgs) => routeBackend(relationTable, "relation load").findMany(relationTable, relationArgs);
+  const relationCounter = (relationTable, relationWhere) => routeBackend(relationTable, "relation load").count(relationTable, relationWhere);
+  const relationPredicateFetcher = (relationTable, relationArgs) => {
+    if (isGlobalTable(relationTable)) {
+      onRead(relationTable, SCAN_DEP);
+    }
+    return relationFetcher(relationTable, relationArgs);
+  };
+  const canPushRelationExists = (relation) => !isGlobalTable(relation.table);
+  const relationExistsPushDown = options.relationExistsPushDown ?? "auto";
+  const relationExistsPushDownEnabled = relationExistsPushDown !== "never";
+  const { maxRelationKeys } = options;
+  const resolveAggregateRelations = (where, predicateTable, relationBaseWhere) => resolveRelationPredicates(where, {
+    fetcher: relationPredicateFetcher,
+    maxRelationKeys,
+    relationBaseWhere,
+    schema,
+    tableName: predicateTable
+  });
+  let triggerDepth = 0;
+  const triggerMatchers = /* @__PURE__ */ new Set();
+  for (const [tableName, definition] of Object.entries(schema.tables)) {
+    for (const trigger of Object.values(definition.triggerMap ?? {})) {
+      triggerMatchers.add(`${tableName} ${trigger.timing} ${trigger.op}`);
+    }
+  }
+  const hasMatchingTrigger = (tableName, timing, op) => triggerMatchers.has(`${tableName} ${timing} ${op}`);
+  const fireTriggers = async (timing, op, event) => {
+    triggerDepth += 1;
+    if (triggerDepth > MAX_TRIGGER_DEPTH) {
+      triggerDepth -= 1;
+      throw new ConflictError(
+        `trigger recursion exceeded ${String(MAX_TRIGGER_DEPTH)} levels on "${event.table}" — check for a self-triggering write`,
+        "trigger"
+      );
+    }
+    try {
+      await runTriggers({ ctx: triggerContext, event, op, schema, tableName: event.table, timing });
+    } finally {
+      triggerDepth -= 1;
+    }
+  };
+  const {
+    ensureBackfilledForTable,
+    ensureBackfilledIndex: ensureBackfilled,
+    ensureRankBackfilled,
+    ensureRankBackfilledForTable,
+    syncAggregates,
+    syncCompanionsForInsert,
+    syncRanks,
+    syncSearch
+  } = createCompanionSync({
+    broadcast,
+    invalidateCache: (table, id) => cache?.invalidate(table, id),
+    recordCdc,
+    schema,
+    sql: sql$1
+  });
+  const assertRankPartitionLocal = (tableName, definition, index) => {
+    const { shardMode } = definition;
+    if (shardMode?.kind !== "shardBy") {
+      return;
+    }
+    if (shardMode.field !== void 0 && (index.partitionBy ?? []).includes(shardMode.field)) {
+      return;
+    }
+    throw Object.assign(
+      new Error(
+        `rank index "${index.name}" on "${tableName}" partitions across shards (shard key "${shardMode.field ?? "?"}" is not in partitionBy) — a shard-local rank()/rankPage() would be wrong; roll it up through the Query Coordinator instead`
+      ),
+      { code: "CROSS_SHARD_RANK_UNSUPPORTED", name: "LunoraError", status: 400 }
+    );
+  };
+  const locateRowById = (id, expectedTable) => {
+    const nonGlobalTables = Object.entries(schema.tables).filter(([, definition]) => definition.shardMode?.kind !== "global").map(([tableName2]) => tableName2).filter((tableName2) => expectedTable === void 0 || tableName2 === expectedTable);
+    if (nonGlobalTables.length === 0) {
+      return void 0;
+    }
+    const branches = nonGlobalTables.map(
+      (tableName2) => (
+        // The table-name discriminator stays an inline literal (escaped) rather than a bound param so it reads as `'<table>' AS __t__`.
+        sql`SELECT ${sql.raw(`'${tableName2.replaceAll("'", "''")}'`)} AS __t__, id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName2)} WHERE id = ${id}`
+      )
+    );
+    const probeQuery = sql`${sql.join(branches, sql` UNION ALL `)} LIMIT 1`;
+    const [firstRow] = runDrizzle(sql$1, probeQuery).toArray();
+    if (!firstRow) {
+      return void 0;
+    }
+    const tableName = firstRow["__t__"];
+    const row = rowToDocument(firstRow);
+    if (typeof tableName !== "string" || !row) {
+      return void 0;
+    }
+    const rawDocument = firstRow[DOC_COLUMN$1];
+    const documentJson = typeof rawDocument === "string" ? rawDocument : JSON.stringify(rawDocument ?? {});
+    return { docJson: documentJson, row, tableName };
+  };
+  const rankPageDeps = {
+    assertRankPartitionLocal,
+    ensureRankBackfilled,
+    onRead,
+    rowToDocument,
+    schema,
+    sql: sql$1
+  };
+  const writer = {
+    // `ctx.db.system` — best-effort read-only system tables. Assigned here so
+    // it rides along on the same `DatabaseWriterLike` the generated ctx hands
+    // to query/mutation/action handlers. See {@link SystemDatabaseReader}.
+    system,
+    async aggregate(tableName, aggOptions) {
+      const global = globalWriterFor(tableName, "aggregate");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.aggregate(tableName, aggOptions);
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      aggregateSqlFunction(aggOptions.op);
+      if (aggOptions.op === "count") {
+        return writer.count(tableName, {
+          baseWhere: aggOptions.baseWhere,
+          relationBaseWhere: aggOptions.relationBaseWhere,
+          restrictsCounts: aggOptions.restrictsCounts,
+          where: aggOptions.where
+        });
+      }
+      if (!aggOptions.field) {
+        throw new Error(`aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
+      }
+      onRead(tableName, SCAN_DEP);
+      const effective = mergeWhere(aggOptions.baseWhere, aggOptions.where);
+      const resolved = await resolveAggregateRelations(effective, tableName, aggOptions.relationBaseWhere);
+      const hasRelation = resolved !== effective;
+      if (definition.aggregateIndexes && !aggOptions.baseWhere && !hasRelation) {
+        const planned = selectIndexForAggregate(definition.aggregateIndexes, aggOptions.op, aggOptions.field, aggOptions.where);
+        if (planned) {
+          ensureBackfilled(tableName, planned.index);
+          const encoded = encodeAggregateKey(planned.index.by ?? [], planned.key);
+          const aggTable = aggregateTableName(tableName, planned.index.name);
+          const indexed = runDrizzle(
+            sql$1,
+            sql`SELECT ${AGG_VALUE} AS value, ${AGG_COUNT} AS count FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encoded}`
+          ).toArray()[0];
+          return readAggregateValue(aggOptions.op, indexed);
+        }
+      }
+      const whereCondition = compileWhereSql(resolved, doWhereSqlStrategy);
+      const aggregateSql = aggregateSqlFunction(aggOptions.op);
+      const ref = jsonPathSql(aggOptions.field);
+      let query = sql`SELECT ${sql.raw(aggregateSql)}(${ref}) AS value FROM ${sql.identifier(tableName)}`;
+      if (whereCondition) {
+        query = sql`${query} WHERE ${whereCondition}`;
+      }
+      const row = runDrizzle(sql$1, query).toArray();
+      const value = row[0]?.value;
+      if (value === null || value === void 0) {
+        return null;
+      }
+      return value;
+    },
+    async count(tableName, whereOrOptions) {
+      const global = globalWriterFor(tableName, "count");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.count(tableName, whereOrOptions);
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      const countOptions = normalizeCountArgument(whereOrOptions);
+      if (countOptions.restrictsCounts) {
+        throw new CountRlsUnsupportedError(tableName);
+      }
+      onRead(tableName, SCAN_DEP);
+      const effective = mergeWhere(countOptions.baseWhere, countOptions.where);
+      const resolved = await resolveAggregateRelations(effective, tableName, countOptions.relationBaseWhere);
+      const hasRelation = resolved !== effective;
+      if (definition.aggregateIndexes && !countOptions.baseWhere && !hasRelation) {
+        const planned = selectIndexForCount(definition.aggregateIndexes, countOptions.where);
+        if (planned) {
+          ensureBackfilled(tableName, planned.index);
+          const encoded = encodeAggregateKey(planned.index.by ?? [], planned.key);
+          const aggTable = aggregateTableName(tableName, planned.index.name);
+          const row2 = runDrizzle(
+            sql$1,
+            sql`SELECT ${AGG_VALUE} AS value FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encoded}`
+          ).toArray();
+          return row2[0] === void 0 ? 0 : row2[0].value ?? 0;
+        }
+      }
+      const whereCondition = compileWhereSql(resolved, doWhereSqlStrategy);
+      let query = sql`SELECT COUNT(*) AS count FROM ${sql.identifier(tableName)}`;
+      if (whereCondition) {
+        query = sql`${query} WHERE ${whereCondition}`;
+      }
+      const row = runDrizzle(sql$1, query).one();
+      return row.count;
+    },
+    async delete(id, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global) {
+          await global.delete(id);
+        }
+        return;
+      }
+      const { docJson: existingJson, row: existing, tableName } = located;
+      if (hasMatchingTrigger(tableName, "before", "delete")) {
+        await fireTriggers("before", "delete", { id, op: "delete", previous: existing, table: tableName });
+      }
+      await applyOnDelete({
+        deletedId: id,
+        deletedReference: (references) => existing[references],
+        findHolders: async (holderTable, field, value) => {
+          const holders = await routeForHolder(holderTable).findMany(holderTable, { where: { [field]: value } });
+          return holders.page;
+        },
+        onCascade: (holderTable, holderId) => routeForHolder(holderTable).delete(holderId),
+        onRestrict: (message) => {
+          throw new ConflictError(message, "restrict");
+        },
+        // eslint-disable-next-line unicorn/no-null -- `set null` onDelete: the FK column is set to SQL NULL, the documented semantics of the action
+        onSetNull: (holderTable, holderId, field) => routeForHolder(holderTable).patch(holderId, { [field]: null }),
+        schema,
+        tableName
+      });
+      ensureBackfilledForTable(tableName);
+      ensureRankBackfilledForTable(tableName);
+      runGuardedWrite(
+        sql$1,
+        tableName,
+        sql`DELETE FROM ${sql.identifier(tableName)} WHERE id = ${id} AND ${sql.identifier(DOC_COLUMN$1)} = ${existingJson}`
+      );
+      syncSearch(tableName, id, void 0);
+      syncAggregates(tableName, existing, void 0);
+      syncRanks(tableName, id, existing, void 0);
+      cache?.invalidate(tableName, id);
+      recordCdc(tableName, id, "delete");
+      broadcast({ key: id, op: "delete", table: tableName });
+      if (hasMatchingTrigger(tableName, "after", "delete")) {
+        await fireTriggers("after", "delete", { id, op: "delete", previous: existing, table: tableName });
+      }
+      await onWrite({ id, op: "delete", table: tableName });
+    },
+    async deleteMany(ids, batchOptions, expectedTable) {
+      assertBatchLimit(ids.length, batchOptions?.limit, "deleteMany");
+      for (const id of ids) {
+        await writer.delete(id, expectedTable);
+      }
+      return { deleted: ids.length };
+    },
+    async findFirst(tableName, args = {}) {
+      const result = await writer.findMany(tableName, { ...args, limit: 1 });
+      return result.page[0] ?? null;
+    },
+    async findFirstOrThrow(tableName, args = {}) {
+      const document = await writer.findFirst(tableName, args);
+      if (document === null) {
+        throw new NotFoundError(`findFirstOrThrow: no "${tableName}" document matched`);
+      }
+      return document;
+    },
+    // eslint-disable-next-line sonarjs/cognitive-complexity -- reader method closed over the writer ctx (sql/schema/onRead/strategy/cache/resolveWith); splitting would thread that shared state through every helper and read worse (see data-migration.ts)
+    async findMany(tableName, args = {}) {
+      const global = globalWriterFor(tableName, "findMany");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.findMany(tableName, args);
+      }
+      if (!schema.tables[tableName]) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      const isFullScan = !args.where && !args.baseWhere;
+      if (isFullScan) {
+        onRead(tableName, SCAN_DEP);
+      } else {
+        onRead(tableName);
+      }
+      const orderKeys = normalizeOrderKeys(args.orderBy);
+      const seek = args.cursor ? buildSeekWhere(orderKeys, decodeCursor(args.cursor)) : void 0;
+      let predicate = mergeWhere(args.baseWhere, args.where);
+      predicate = await resolveRelationPredicates(predicate, {
+        canPushExists: relationExistsPushDownEnabled ? canPushRelationExists : void 0,
+        existsPushMode: relationExistsPushDown === "always" ? "always" : "auto",
+        fetcher: relationPredicateFetcher,
+        maxRelationKeys,
+        relationBaseWhere: args.relationBaseWhere,
+        schema,
+        tableName
+      });
+      if (seek) {
+        predicate = predicate ? { AND: [predicate, seek] } : seek;
+      }
+      const whereStrategy = relationExistsPushDownEnabled ? makeRelationExistsSqlStrategy(onRead) : doWhereSqlStrategy;
+      const whereCondition = compileWhereSql(predicate, whereStrategy);
+      let query = sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN$1)} FROM ${sql.identifier(tableName)}`;
+      if (whereCondition) {
+        query = sql`${query} WHERE ${whereCondition}`;
+      }
+      query = sql`${query} ORDER BY ${compileOrderBySql(orderKeys)}`;
+      const limit = typeof args.limit === "number" ? Math.max(0, Math.floor(args.limit)) : void 0;
+      if (limit !== void 0) {
+        query = sql`${query} LIMIT ${sql.raw(String(limit + 1))}`;
+      }
+      const rows = runDrizzle(sql$1, query).toArray();
+      const docs = [];
+      for (const row of rows) {
+        const record = rowToDocument(row);
+        if (record) {
+          docs.push(record);
+          if (!isFullScan && typeof record["_id"] === "string") {
+            onRead(tableName, record["_id"]);
+          }
+        }
+      }
+      if (limit === void 0) {
+        if (args.with) {
+          await resolveWith({
+            counter: relationCounter,
+            fetcher: relationFetcher,
+            parents: docs,
+            relationBaseWhere: args.relationBaseWhere,
+            schema,
+            tableName,
+            with: args.with
+          });
+        }
+        return { continueCursor: null, isDone: true, page: docs };
+      }
+      const hasMore = docs.length > limit;
+      const page = hasMore ? docs.slice(0, limit) : docs;
+      const last = page.at(-1);
+      if (args.with) {
+        await resolveWith({
+          counter: relationCounter,
+          fetcher: relationFetcher,
+          parents: page,
+          relationBaseWhere: args.relationBaseWhere,
+          schema,
+          tableName,
+          with: args.with
+        });
+      }
+      return {
+        // eslint-disable-next-line unicorn/no-null -- QueryPage.continueCursor is `null | string`: null is the documented "no further page" cursor on the wire
+        continueCursor: hasMore && last ? encodeCursor(last, orderKeys) : null,
+        isDone: !hasMore,
+        page
+      };
+    },
+    async get(id, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global) {
+          return global.get(id);
+        }
+        return null;
+      }
+      onRead(located.tableName, id);
+      return located.row;
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- async to satisfy the optional seam's Promise contract; the underlying lookup is sync
+    async lookupById(id, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        return null;
+      }
+      onRead(located.tableName, id);
+      return { row: located.row, tableName: located.tableName };
+    },
+    // eslint-disable-next-line sonarjs/cognitive-complexity -- the indexed/scan branching is closed over the writer ctx and reads worse when split
+    async groupBy(tableName, groupOptions) {
+      const global = globalWriterFor(tableName, "groupBy");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.groupBy(tableName, groupOptions);
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      onRead(tableName, SCAN_DEP);
+      const agg = groupOptions.agg ?? { op: "count" };
+      aggregateSqlFunction(agg.op);
+      if (agg.op !== "count" && !agg.field) {
+        throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
+      }
+      const effective = mergeWhere(groupOptions.baseWhere, groupOptions.where);
+      const resolved = await resolveAggregateRelations(effective, tableName, groupOptions.relationBaseWhere);
+      const hasRelation = resolved !== effective;
+      if (definition.aggregateIndexes && !groupOptions.baseWhere && !hasRelation) {
+        const planned = selectIndexForGroupBy(definition.aggregateIndexes, agg.op, agg.field, groupOptions.by, groupOptions.where);
+        if (planned) {
+          ensureBackfilled(tableName, planned.index);
+          const aggTable = aggregateTableName(tableName, planned.index.name);
+          const partialKeys = Object.keys(planned.partial);
+          const indexedResult = [];
+          if (partialKeys.length === (planned.index.by ?? []).length && partialKeys.length > 0) {
+            const encoded = encodeAggregateKey(planned.index.by ?? [], planned.partial);
+            const rowsIndexed2 = runDrizzle(
+              sql$1,
+              sql`SELECT ${AGG_VALUE} AS value, ${AGG_COUNT} AS count FROM ${sql.identifier(aggTable)} WHERE ${AGG_KEY} = ${encoded}`
+            ).toArray();
+            if (rowsIndexed2.length > 0) {
+              indexedResult.push({
+                key: { ...planned.partial },
+                value: readAggregateValue(agg.op, rowsIndexed2[0])
+              });
+            }
+            return indexedResult;
+          }
+          const rowsIndexed = runDrizzle(
+            sql$1,
+            sql`SELECT ${AGG_KEY} AS key, ${AGG_VALUE} AS value, ${AGG_COUNT} AS count FROM ${sql.identifier(aggTable)}`
+          ).toArray();
+          for (const row of rowsIndexed) {
+            const decoded = JSON.parse(row.key);
+            indexedResult.push({ key: decoded, value: readAggregateValue(agg.op, row) });
+          }
+          return indexedResult;
+        }
+      }
+      const whereCondition = compileWhereSql(resolved, doWhereSqlStrategy);
+      const select = groupOptions.by.map((field) => sql`${jsonPathSql(field)} AS ${sql.identifier(field)}`);
+      if (agg.op === "count") {
+        select.push(sql`COUNT(*) AS value`);
+      } else {
+        const { field } = agg;
+        if (field === void 0) {
+          throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
+        }
+        select.push(sql`${sql.raw(aggregateSqlFunction(agg.op))}(${jsonPathSql(field)}) AS value`);
+      }
+      let query = sql`SELECT ${sql.join(select, sql`, `)} FROM ${sql.identifier(tableName)}`;
+      if (whereCondition) {
+        query = sql`${query} WHERE ${whereCondition}`;
+      }
+      query = sql`${query} GROUP BY ${sql.join(
+        groupOptions.by.map((field) => jsonPathSql(field)),
+        sql`, `
+      )}`;
+      const rows = runDrizzle(sql$1, query).toArray();
+      const result = [];
+      for (const row of rows) {
+        const key = {};
+        for (const field of groupOptions.by) {
+          key[field] = row[field] ?? null;
+        }
+        const { value } = row;
+        result.push({ key, value: value === null || value === void 0 ? null : Number(value) });
+      }
+      return result;
+    },
+    async insert(tableName, document, insertOptions) {
+      const global = globalWriterFor(tableName, "insert");
+      if (global) {
+        const id2 = await global.insert(tableName, document, insertOptions);
+        broadcast({ key: id2, op: "insert", row: { ...document, _id: id2 }, table: tableName });
+        return id2;
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      const withDefaults = applyInsertDefaults(definition, document, auth);
+      runRowValidators(definition, withDefaults);
+      let id;
+      if (insertOptions?.clientId !== void 0) {
+        assertValidClientId(insertOptions.clientId);
+        id = insertOptions.clientId;
+      } else if (insertOptions?.allowExplicitId && typeof withDefaults["_id"] === "string") {
+        id = withDefaults["_id"];
+      } else {
+        id = generateId();
+      }
+      const creationTime = typeof withDefaults["_creationTime"] === "number" ? withDefaults["_creationTime"] : clock();
+      const documentWithMeta = { ...withDefaults, _creationTime: creationTime, _id: id };
+      if (hasMatchingTrigger(tableName, "before", "insert")) {
+        await fireTriggers("before", "insert", { doc: { ...documentWithMeta }, id, op: "insert", table: tableName });
+      }
+      ensureBackfilledForTable(tableName);
+      ensureRankBackfilledForTable(tableName);
+      runWrite(
+        sql$1,
+        tableName,
+        sql`INSERT INTO ${sql.identifier(tableName)} (id, _creationTime, ${sql.identifier(DOC_COLUMN$1)}) VALUES (${id}, ${creationTime}, ${JSON.stringify(documentWithMeta)})`
+      );
+      syncCompanionsForInsert(tableName, id, documentWithMeta);
+      if (hasMatchingTrigger(tableName, "after", "insert")) {
+        await fireTriggers("after", "insert", { doc: documentWithMeta, id, op: "insert", table: tableName });
+      }
+      await onWrite({ doc: documentWithMeta, id, op: "insert", table: tableName });
+      return id;
+    },
+    async insertManyUnsafe(tableName, documents, batchOptions) {
+      assertBatchLimit(documents.length, batchOptions?.limit, "insertManyUnsafe");
+      if (documents.length === 0) {
+        return [];
+      }
+      const global = globalWriterFor(tableName, "insert");
+      if (global) {
+        const globalIds = [];
+        for (const document of documents) {
+          const globalId = await global.insert(tableName, document, { allowExplicitId: batchOptions?.allowExplicitId });
+          broadcast({ key: globalId, op: "insert", row: { ...document, _id: globalId }, table: tableName });
+          globalIds.push(globalId);
+        }
+        return globalIds;
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      ensureBackfilledForTable(tableName);
+      ensureRankBackfilledForTable(tableName);
+      const rows = documents.map((document) => {
+        const withDefaults = applyInsertDefaults(definition, document, auth);
+        const id = batchOptions?.allowExplicitId === true && typeof withDefaults["_id"] === "string" ? withDefaults["_id"] : generateId();
+        const creationTime = typeof withDefaults["_creationTime"] === "number" ? withDefaults["_creationTime"] : clock();
+        return { creationTime, document: { ...withDefaults, _creationTime: creationTime, _id: id }, id };
+      });
+      const valuesSql = sql.join(
+        rows.map((row) => sql`(${row.id}, ${row.creationTime}, ${JSON.stringify(row.document)})`),
+        sql`, `
+      );
+      runWrite(sql$1, tableName, sql`INSERT INTO ${sql.identifier(tableName)} (id, _creationTime, ${sql.identifier(DOC_COLUMN$1)}) VALUES ${valuesSql}`);
+      for (const { document, id } of rows) {
+        syncCompanionsForInsert(tableName, id, document);
+        await onWrite({ doc: document, id, op: "insert", table: tableName });
+      }
+      return rows.map((row) => row.id);
+    },
+    async insertMany(tableName, documents, batchOptions) {
+      assertBatchLimit(documents.length, batchOptions?.limit, "insertMany");
+      const ids = [];
+      for (const document of documents) {
+        ids.push(await writer.insert(tableName, document));
+      }
+      return ids;
+    },
+    normalizeId(tableName, id) {
+      return normalizeIdStructurally(schema, tableName, id);
+    },
+    async patch(id, patch, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global) {
+          await global.patch(id, patch);
+          return;
+        }
+        throw new Error(`document not found: ${id}`);
+      }
+      const { docJson: existingJson, row: existing, tableName } = located;
+      const tableDefinition = schema.tables[tableName];
+      if (!tableDefinition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      onRead(tableName, id);
+      assertNoExplicitUndefined("patch", patch);
+      const merged = { ...existing, ...patch, _id: id };
+      applyOnUpdate(tableDefinition, patch, merged, auth);
+      runRowValidators(tableDefinition, merged);
+      if (hasMatchingTrigger(tableName, "before", "update")) {
+        await fireTriggers("before", "update", { doc: { ...merged }, id, op: "update", previous: existing, table: tableName });
+      }
+      ensureBackfilledForTable(tableName);
+      ensureRankBackfilledForTable(tableName);
+      runGuardedWrite(
+        sql$1,
+        tableName,
+        sql`UPDATE ${sql.identifier(tableName)} SET ${sql.identifier(DOC_COLUMN$1)} = ${JSON.stringify(merged)} WHERE id = ${id} AND ${sql.identifier(DOC_COLUMN$1)} = ${existingJson}`
+      );
+      syncSearch(tableName, id, merged);
+      syncAggregates(tableName, existing, merged);
+      syncRanks(tableName, id, existing, merged);
+      cache?.invalidate(tableName, id);
+      recordCdc(tableName, id, "update", merged);
+      broadcast({ key: id, op: "update", row: merged, table: tableName });
+      if (hasMatchingTrigger(tableName, "after", "update")) {
+        await fireTriggers("after", "update", { doc: merged, id, op: "update", previous: existing, table: tableName });
+      }
+      await onWrite({ doc: merged, id, op: "update", table: tableName });
+    },
+    async patchMany(patches, batchOptions, expectedTable) {
+      assertBatchLimit(patches.length, batchOptions?.limit, "patchMany");
+      for (const entry of patches) {
+        await writer.patch(entry.id, entry.patch, expectedTable);
+      }
+    },
+    query(tableName) {
+      const global = globalWriterFor(tableName, "query");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.query(tableName);
+      }
+      onRead(tableName, SCAN_DEP);
+      return buildReader(sql$1, schema, tableName, onIndexUse);
+    },
+    async rank(tableName, indexName, rankOptions) {
+      const global = globalWriterFor(tableName, "rank");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.rank(tableName, indexName, rankOptions);
+      }
+      onIndexUse(tableName, indexName, "rank");
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      const index = definition.rankIndexes?.find((i) => i.name === indexName);
+      if (!index) {
+        throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+      }
+      assertRankPartitionLocal(tableName, definition, index);
+      if (rankOptions.restrictsCounts) {
+        throw new CountRlsUnsupportedError(tableName);
+      }
+      onRead(tableName, SCAN_DEP);
+      ensureRankBackfilled(tableName, index);
+      const rowId = typeof rankOptions.row === "string" ? rankOptions.row : rankOptions.row["_id"];
+      if (!rowId) {
+        return null;
+      }
+      const rankTable = rankTableName(tableName, index.name);
+      const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+      const sortColumnList = sortColumns.map((column) => quoteIdentifier(column)).join(", ");
+      const ownRows = runDrizzle(
+        sql$1,
+        sql`SELECT ${sql.identifier("__partition__")}, ${sql.raw(sortColumnList)} FROM ${sql.identifier(rankTable)} WHERE ${sql.identifier("__id__")} = ${rowId}`
+      ).toArray();
+      const [own] = ownRows;
+      if (own === void 0) {
+        return null;
+      }
+      let partitionKey = own["__partition__"];
+      const effective = mergeWhere(rankOptions.baseWhere, rankOptions.where);
+      assertFlatPredicate(effective, schema, tableName, "rank");
+      const partitionFromWhere = resolveRankPartition(index, effective);
+      if (partitionFromWhere) {
+        const requestedKey = encodePartitionKey(index.partitionBy ?? [], partitionFromWhere);
+        if (requestedKey !== partitionKey) {
+          return null;
+        }
+        partitionKey = requestedKey;
+      }
+      const ownSortValues = sortColumns.map((column) => own[column]);
+      const { before, total } = countRankBefore(sql$1, rankTable, sortColumns, index.sortBy, partitionKey, ownSortValues, rowId);
+      return { position: before + 1, total };
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- DatabaseWriterLike returns Promises (the D1 twin awaits I/O); the body is synchronous SQLite
+    async rankBefore(tableName, indexName, rankBeforeOptions) {
+      if (isGlobalTable(tableName)) {
+        throw new Error(
+          `rankBefore is not supported on the global (.global()) table '${tableName}' — cross-shard rank cursors apply only to sharded tables`
+        );
+      }
+      const definition = schema.tables[tableName];
+      if (!definition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      const index = definition.rankIndexes?.find((i) => i.name === indexName);
+      if (!index) {
+        throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+      }
+      if (rankBeforeOptions.restrictsCounts) {
+        throw new CountRlsUnsupportedError(tableName);
+      }
+      onRead(tableName, SCAN_DEP);
+      ensureRankBackfilled(tableName, index);
+      const rankTable = rankTableName(tableName, index.name);
+      const sortColumns = index.sortBy.map((_, i) => sortColumnName(i));
+      const serialized = index.sortBy.map((_, i) => serializeSqlValue(rankBeforeOptions.sortValues[i] ?? null));
+      return countRankBefore(sql$1, rankTable, sortColumns, index.sortBy, rankBeforeOptions.partitionKey, serialized, rankBeforeOptions.rowId);
+    },
+    async rankPage(tableName, indexName, rankPageOptions = {}) {
+      assertFlatPredicate(mergeWhere(rankPageOptions.baseWhere, rankPageOptions.where), schema, tableName, "rankPage");
+      const global = globalWriterFor(tableName, "rankPage");
+      if (global) {
+        onRead(tableName, SCAN_DEP);
+        return global.rankPage(tableName, indexName, rankPageOptions);
+      }
+      onIndexUse(tableName, indexName, "rank");
+      const { continueCursor, hasMore, rows } = computeRankPage(rankPageDeps, tableName, indexName, rankPageOptions);
+      return { continueCursor, isDone: !hasMore, page: rows.map((row) => row.doc) };
+    },
+    // eslint-disable-next-line @typescript-eslint/require-await -- DatabaseWriterLike returns Promises (the D1 twin awaits I/O); the body is synchronous SQLite
+    async rankPageRows(tableName, indexName, rankPageOptions = {}) {
+      assertFlatPredicate(mergeWhere(rankPageOptions.baseWhere, rankPageOptions.where), schema, tableName, "rankPage");
+      onIndexUse(tableName, indexName, "rank");
+      const { directions, hasMore, rows } = computeRankPage(rankPageDeps, tableName, indexName, rankPageOptions);
+      return { directions, hasMore, rows };
+    },
+    async replace(id, document, expectedTable) {
+      const located = locateRowById(id, expectedTable);
+      if (!located) {
+        const global = expectedTable === void 0 ? globalFallback() : void 0;
+        if (global) {
+          await global.replace(id, document);
+          return;
+        }
+        throw new Error(`document not found: ${id}`);
+      }
+      const { docJson: existingJson, row: previous, tableName } = located;
+      const tableDefinition = schema.tables[tableName];
+      if (!tableDefinition) {
+        throw new Error(`unknown table: ${tableName}`);
+      }
+      assertNoExplicitUndefined("replace", document);
+      const creationTime = typeof document["_creationTime"] === "number" ? document["_creationTime"] : clock();
+      const replaced = { ...document, _creationTime: creationTime, _id: id };
+      applyOnUpdate(tableDefinition, document, replaced, auth);
+      runRowValidators(tableDefinition, replaced);
+      if (hasMatchingTrigger(tableName, "before", "update")) {
+        await fireTriggers("before", "update", { doc: { ...replaced }, id, op: "update", previous, table: tableName });
+      }
+      ensureBackfilledForTable(tableName);
+      ensureRankBackfilledForTable(tableName);
+      runGuardedWrite(
+        sql$1,
+        tableName,
+        sql`UPDATE ${sql.identifier(tableName)} SET _creationTime = ${creationTime}, ${sql.identifier(DOC_COLUMN$1)} = ${JSON.stringify(replaced)} WHERE id = ${id} AND ${sql.identifier(DOC_COLUMN$1)} = ${existingJson}`
+      );
+      syncSearch(tableName, id, replaced);
+      syncAggregates(tableName, previous, replaced);
+      syncRanks(tableName, id, previous, replaced);
+      cache?.invalidate(tableName, id);
+      recordCdc(tableName, id, "update", replaced);
+      broadcast({ key: id, op: "update", row: replaced, table: tableName });
+      if (hasMatchingTrigger(tableName, "after", "update")) {
+        await fireTriggers("after", "update", { doc: replaced, id, op: "update", previous, table: tableName });
+      }
+      await onWrite({ doc: replaced, id, op: "update", table: tableName });
+    }
+  };
+  const triggerContext = { db: writer, scheduler };
+  return options.enforceRls === true ? guardWriter(writer, schema, (id, expectedTable) => locateRowById(id, expectedTable)?.tableName) : writer;
+};
+
+export { NotUniqueError, appendCdcChange, assertValidClientId, createShardCtxDb, normalizeIdStructurally };