@lunora/do 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/packem_shared/{ReactiveCache-ByVzgH3d.mjs → ReactiveCache-BYlSGY0N.mjs}

@@ -1,11 +1,6 @@
+import { stableStringify } from './stableStringify-MydiuScU.mjs';
 import { depKey, SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
 
-const compareKeys = (a, b) => {
-  if (a < b) {
-    return -1;
-  }
-  return a > b ? 1 : 0;
-};
 const DEFAULT_MAX_ENTRIES = 1e3;
 const DEFAULT_MAX_BYTES = 4 * 1024 * 1024;
 const estimateBytes = (value) => {
@@ -232,28 +227,6 @@ class ReactiveCache {
     }
   }
 }
-const stableStringify = (value) => {
-  if (value === void 0) {
-    return "null";
-  }
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const record = value;
-  const keys = Object.keys(record).toSorted(compareKeys);
-  const parts = [];
-  for (const key of keys) {
-    const raw = record[key];
-    if (raw === void 0) {
-      continue;
-    }
-    parts.push(`${JSON.stringify(key)}:${stableStringify(raw)}`);
-  }
-  return `{${parts.join(",")}}`;
-};
 const reactiveCacheKey = (functionPath, args, identity) => `${identity ?? "\0anon"}\0${functionPath}:${stableStringify(args)}`;
 
 export { ReactiveCache, reactiveCacheKey, stableStringify };

package/dist/packem_shared/{SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs → SESSION_DO_TTL_DEFAULT-BnSKgVO4.mjs}

@@ -1,3 +1,6 @@
+import { c as constantTimeEqual } from './constant-time-equal-BVRWZgES.mjs';
+import { j as jsonResponse } from './json-response-BdbtpOhm.mjs';
+
 const SESSION_DO_TTL_DEFAULT = 7 * 24 * 60 * 60;
 const SESSION_DO_TTL_MAX = 90 * 24 * 60 * 60;
 const SESSION_GC_INTERVAL_MS = 24 * 60 * 60 * 1e3;
@@ -7,20 +10,6 @@ const SESSION_TOKEN_PATTERN = /^[\w-]+$/;
 const MIN_TOKEN_LENGTH = 32;
 const MAX_TOKEN_LENGTH = 256;
 const MAX_USER_ID_LENGTH = 256;
-const jsonResponse = (status, body) => Response.json(body, {
-  headers: { "content-type": "application/json" },
-  status
-});
-const constantTimeEqual = (a, b) => {
-  const max = Math.max(a.length, b.length);
-  let diff = a.length ^ b.length;
-  for (let index = 0; index < max; index += 1) {
-    const charA = index < a.length ? a.charCodeAt(index) : 0;
-    const charB = index < b.length ? b.charCodeAt(index) : 0;
-    diff |= charA ^ charB;
-  }
-  return diff === 0;
-};
 const isAuthorized = (request, env) => {
   const expected = env.SESSION_DO_SECRET;
   if (typeof expected !== "string" || expected.length === 0) {
@@ -68,7 +57,7 @@ class SessionDO {
   async fetch(request) {
     const env = this.env ?? {};
     if (!isAuthorized(request, env)) {
-      return jsonResponse(401, { error: { code: "UNAUTHORIZED", message: "missing or invalid SessionDO secret" } });
+      return jsonResponse({ error: { code: "UNAUTHORIZED", message: "missing or invalid SessionDO secret" } }, 401);
     }
     const url = new URL(request.url);
     if (request.method === "POST" && url.pathname === "/create") {
@@ -80,7 +69,7 @@ class SessionDO {
     if (request.method === "DELETE" && url.pathname === "/revoke") {
       return this.handleRevoke(request);
     }
-    return jsonResponse(404, { error: { code: "NOT_FOUND", message: "no such session route" } });
+    return jsonResponse({ error: { code: "NOT_FOUND", message: "no such session route" } }, 404);
   }
   /**
    * Sweep expired session records. Lazy expiry-on-read ({@link handleGet})
@@ -116,25 +105,25 @@ class SessionDO {
     try {
       body = await request.json();
     } catch {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const token = validateToken(body.token);
     if (token === void 0) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const { userId } = body;
     if (typeof userId !== "string" || userId.length === 0 || userId.length > MAX_USER_ID_LENGTH) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const ttlSeconds = resolveTtlSeconds(body.ttlSeconds);
     if (ttlSeconds === void 0) {
-      return jsonResponse(400, { error: "invalid_request" });
+      return jsonResponse({ error: "invalid_request" }, 400);
     }
     const now = Date.now();
     const record = { createdAt: now, expiresAt: now + ttlSeconds * 1e3, userId };
     await this.state.storage.put(`s:${token}`, record);
     await this.armGcAlarm();
-    return jsonResponse(201, { token, ...record });
+    return jsonResponse({ token, ...record }, 201);
   }
   /**
    * Ensure a GC alarm is pending. Only sets one when none is currently
@@ -155,25 +144,25 @@ class SessionDO {
   async handleGet(request) {
     const token = request.headers.get(SESSION_TOKEN_HEADER);
     if (!token) {
-      return jsonResponse(400, { error: { code: "INVALID_INPUT", message: "token required" } });
+      return jsonResponse({ error: { code: "INVALID_INPUT", message: "token required" } }, 400);
     }
     const record = await this.state.storage.get(`s:${token}`);
     if (!record) {
-      return jsonResponse(404, { error: { code: "NOT_FOUND", message: "session not found" } });
+      return jsonResponse({ error: { code: "NOT_FOUND", message: "session not found" } }, 404);
     }
     if (record.expiresAt < Date.now()) {
       await this.state.storage.delete(`s:${token}`);
-      return jsonResponse(404, { error: { code: "EXPIRED", message: "session expired" } });
+      return jsonResponse({ error: { code: "EXPIRED", message: "session expired" } }, 404);
     }
-    return jsonResponse(200, { token, ...record });
+    return jsonResponse({ token, ...record }, 200);
   }
   async handleRevoke(request) {
     const token = request.headers.get(SESSION_TOKEN_HEADER);
     if (!token) {
-      return jsonResponse(400, { error: { code: "INVALID_INPUT", message: "token required" } });
+      return jsonResponse({ error: { code: "INVALID_INPUT", message: "token required" } }, 400);
     }
     await this.state.storage.delete(`s:${token}`);
-    return jsonResponse(200, { ok: true });
+    return jsonResponse({ ok: true }, 200);
   }
 }
 

package/dist/packem_shared/{SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs → SHARD_REGISTRY_DO_NAME-D99roc-r.mjs}

@@ -1,22 +1,20 @@
+import { j as jsonResponse } from './json-response-BdbtpOhm.mjs';
+
 const SHARD_REGISTRY_DO_NAME = "__lunora_shard_registry__";
 const STORAGE_KEY = "__tables__";
-const jsonResponse = (status, body) => Response.json(body, {
-  headers: { "content-type": "application/json" },
-  status
-});
 const readTableShardBody = async (request) => {
   let body;
   try {
     body = await request.json();
   } catch {
-    return { kind: "error", response: jsonResponse(400, { error: { code: "BAD_REQUEST", message: "invalid JSON body" } }) };
+    return { kind: "error", response: jsonResponse({ error: { code: "BAD_REQUEST", message: "invalid JSON body" } }, 400) };
   }
   const table = typeof body.table === "string" ? body.table.trim() : "";
   const shardKey = typeof body.shardKey === "string" ? body.shardKey.trim() : "";
   if (!table || !shardKey) {
     return {
       kind: "error",
-      response: jsonResponse(400, { error: { code: "BAD_REQUEST", message: "table and shardKey required" } })
+      response: jsonResponse({ error: { code: "BAD_REQUEST", message: "table and shardKey required" } }, 400)
     };
   }
   return { kind: "ok", value: { shardKey, table } };
@@ -56,7 +54,7 @@ class ShardRegistryDO {
     if (request.method === "GET" && url.pathname === "/snapshot") {
       return this.handleSnapshot();
     }
-    return jsonResponse(404, { error: { code: "NOT_FOUND", message: `unknown shard-registry route ${request.method} ${url.pathname}` } });
+    return jsonResponse({ error: { code: "NOT_FOUND", message: `unknown shard-registry route ${request.method} ${url.pathname}` } }, 404);
   }
   /**
    * Load the persisted snapshot exactly once. `blockConcurrencyWhile`
@@ -83,9 +81,9 @@ class ShardRegistryDO {
   handleList(url) {
     const table = url.searchParams.get("table");
     if (!table) {
-      return jsonResponse(400, { error: { code: "BAD_REQUEST", message: "missing required query parameter: table" } });
+      return jsonResponse({ error: { code: "BAD_REQUEST", message: "missing required query parameter: table" } }, 400);
     }
-    return jsonResponse(200, { shardKeys: [...this.tables.get(table) ?? []] });
+    return jsonResponse({ shardKeys: [...this.tables.get(table) ?? []] }, 200);
   }
   async handleRegister(request) {
     const parsed = await readTableShardBody(request);
@@ -100,11 +98,11 @@ class ShardRegistryDO {
         this.tables.set(table, set);
       }
       if (set.has(shardKey)) {
-        return jsonResponse(200, { changed: false, ok: true });
+        return jsonResponse({ changed: false, ok: true }, 200);
       }
       set.add(shardKey);
       await this.persist();
-      return jsonResponse(200, { changed: true, ok: true });
+      return jsonResponse({ changed: true, ok: true }, 200);
     });
   }
   handleSnapshot() {
@@ -112,7 +110,7 @@ class ShardRegistryDO {
     for (const [table, set] of this.tables) {
       out[table] = [...set];
     }
-    return jsonResponse(200, { tables: out });
+    return jsonResponse({ tables: out }, 200);
   }
   async handleUnregister(request) {
     const parsed = await readTableShardBody(request);
@@ -123,14 +121,14 @@ class ShardRegistryDO {
     return this.state.blockConcurrencyWhile(async () => {
       const set = this.tables.get(table);
       if (!set?.has(shardKey)) {
-        return jsonResponse(200, { changed: false, ok: true });
+        return jsonResponse({ changed: false, ok: true }, 200);
       }
       set.delete(shardKey);
       if (set.size === 0) {
         this.tables.delete(table);
       }
       await this.persist();
-      return jsonResponse(200, { changed: true, ok: true });
+      return jsonResponse({ changed: true, ok: true }, 200);
     });
   }
   /** Serialize the in-memory map to a single JSON-safe object and put. */

package/dist/packem_shared/{applyOnDelete-CMif2RKw.mjs → applyOnDelete-BXSq3S70.mjs}

@@ -1,3 +1,16 @@
+import { LunoraError } from '@lunora/errors';
+import { applySelect } from './applySelect-WQY8m62C.mjs';
+
+const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
+const fanOutScalarCounts = async (counter, tableName, whereField, values, policyWhere) => {
+  const pairs = await Promise.all(
+    values.map(async (value) => {
+      const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
+      return [value, await counter(tableName, countWhere)];
+    })
+  );
+  return new Map(pairs);
+};
 const distinctValues = (rows, field) => {
   const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
@@ -9,19 +22,19 @@ const distinctValues = (rows, field) => {
   return [...seen];
 };
 const resolveWith = async (options) => {
-  const { counter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
+  const { groupedCounter, fetcher, parents, relationBaseWhere, schema, tableName, with: withInput } = options;
   if (parents.length === 0) {
     return;
   }
   const parentDefinition = schema.tables[tableName];
   if (!parentDefinition) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   const relationMap = parentDefinition.relationMap ?? {};
   const requireRelation = (name) => {
     const relation = relationMap[name];
     if (!relation) {
-      throw new Error(`unknown relation "${name}" on table "${tableName}"`);
+      throw new LunoraError("INTERNAL", `unknown relation "${name}" on table "${tableName}"`);
     }
     return relation;
   };
@@ -44,7 +57,8 @@ const resolveWith = async (options) => {
       byReference.set(child[relation.references], child);
     }
     for (const parent of parents) {
-      parent[name] = byReference.get(parent[relation.field]) ?? null;
+      const child = byReference.get(parent[relation.field]);
+      parent[name] = child ? projectChildren([child], nested)[0] ?? null : null;
     }
   };
   const loadMany = async (name, relation, nested) => {
@@ -77,19 +91,16 @@ const resolveWith = async (options) => {
     const cap = typeof nested.limit === "number" ? Math.max(0, Math.floor(nested.limit)) : void 0;
     for (const parent of parents) {
       const group = groups.get(parent[relation.references]) ?? [];
-      parent[name] = cap === void 0 ? group : group.slice(0, cap);
+      parent[name] = projectChildren(cap === void 0 ? group : group.slice(0, cap), nested);
     }
   };
   const resolveCounts = async (countInput) => {
     for (const name of Object.keys(countInput)) {
       const relation = requireRelation(name);
       const [whereField, parentField] = relation.kind === "many" ? [relation.field, relation.references] : [relation.references, relation.field];
-      const countByValue = /* @__PURE__ */ new Map();
       const policyWhere = relationBaseWhere?.(relation.table);
-      for (const value of distinctValues(parents, parentField)) {
-        const countWhere = policyWhere ? { AND: [{ [whereField]: value }, policyWhere] } : { [whereField]: value };
-        countByValue.set(value, await counter(relation.table, countWhere));
-      }
+      const values = distinctValues(parents, parentField);
+      const countByValue = values.length === 0 ? /* @__PURE__ */ new Map() : await groupedCounter(relation.table, whereField, values, policyWhere);
       for (const parent of parents) {
         const counts = parent["_count"] ?? {};
         const parentValue = parent[parentField];
@@ -135,7 +146,7 @@ const applyRelationOnDelete = async (options, holderTable, relation) => {
 const applyOnDelete = async (options) => {
   const { schema, tableName } = options;
   if (!schema.tables[tableName]) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   for (const [holderTable, holderDefinition] of Object.entries(schema.tables)) {
     const relations = holderDefinition.relationMap;
@@ -162,4 +173,4 @@ const runRowValidators = (definition, document) => {
   }
 };
 
-export { applyOnDelete, distinctValues, resolveWith, runRowValidators };
+export { applyOnDelete, distinctValues, fanOutScalarCounts, resolveWith, runRowValidators };

package/dist/packem_shared/{buildSeekWhere-lVsNXSLy.mjs → applySelect-WQY8m62C.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const TIEBREAK_FIELD = "id";
 const ID_FIELDS = /* @__PURE__ */ new Set(["_id", "id"]);
 const normalizeOrderKeys = (orderBy) => {
@@ -30,7 +32,7 @@ const encodeCursor = (record, keys) => {
   values.push(record["_id"]);
   return toBase64(JSON.stringify(values));
 };
-const invalidCursor = () => Object.assign(new TypeError("invalid cursor"), { code: "BAD_REQUEST", name: "LunoraError", status: 400 });
+const invalidCursor = () => new LunoraError("BAD_REQUEST", "invalid cursor");
 const decodeCursor = (cursor) => {
   let decoded;
   try {
@@ -80,5 +82,22 @@ const buildSeekBeforeWhere = (keys, cursorValues) => {
   }
   return { OR: branches };
 };
+const SELECT_SYSTEM_FIELDS = ["_id", "_creationTime"];
+const applySelect = (page, select, withInput) => {
+  if (!select) {
+    return page;
+  }
+  const keep = /* @__PURE__ */ new Set([...select, ...SELECT_SYSTEM_FIELDS, ...withInput ? Object.keys(withInput) : []]);
+  return page.map((document) => {
+    const projected = {};
+    for (const key of keep) {
+      if (key in document) {
+        projected[key] = document[key];
+      }
+    }
+    return projected;
+  });
+};
+const softDeleteScope = (softDeleteMode, includeDeleted) => softDeleteMode && includeDeleted !== true ? { [softDeleteMode.field]: { isNull: true } } : void 0;
 
-export { buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys };
+export { applySelect, buildSeekBeforeWhere, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope };

package/dist/packem_shared/{armRestore-BJk53Ro8.mjs → armRestore-4Px61hHS.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const pitrUnavailable = () => Object.assign(
   new Error("native PITR is unavailable here (local dev or a non-SQLite Durable Object); use `lunora backup restore` for off-platform recovery"),
   {
@@ -12,11 +14,7 @@ const toTime = (time) => {
   }
   const parsed = Date.parse(time);
   if (Number.isNaN(parsed)) {
-    throw Object.assign(new Error(`pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`), {
-      code: "BAD_REQUEST",
-      name: "LunoraError",
-      status: 400
-    });
+    throw new LunoraError("BAD_REQUEST", `pitr: invalid time "${time}" — expected epoch-ms or an ISO timestamp`);
   }
   return parsed;
 };
@@ -37,11 +35,7 @@ const armRestore = async (storage, args) => {
   let target = args.bookmark;
   if (target === void 0) {
     if (args.time === void 0) {
-      throw Object.assign(new Error("pitrRestore: provide a `bookmark` or a `time` to restore to"), {
-        code: "BAD_REQUEST",
-        name: "LunoraError",
-        status: 400
-      });
+      throw new LunoraError("BAD_REQUEST", "pitrRestore: provide a `bookmark` or a `time` to restore to");
     }
     if (!storage.getBookmarkForTime) {
       throw pitrUnavailable();

package/dist/packem_shared/{backfillAggregateIndexes-BF5eL7kW.mjs → backfillAggregateIndexes-DDoT-UUI.mjs}

@@ -1,10 +1,11 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere } from './matchesStaticWhere-CFk6adSu.mjs';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } 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 } from './rank-CrkEIpF4.mjs';
+import { sortColumnName, matchesRankStaticWhere, encodePartitionKey, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 
 const backfillAggregateIndex = (sql$1, tableName, index) => {
   const aggTable = aggregateTableName(tableName, index.name);

package/dist/packem_shared/{compileWhereSql-CXrhFA3G.mjs → compileWhereSql-DE6yfRcQ.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
 
 const RELATION_EXISTS_KEY = "__relationExists";
@@ -11,9 +12,10 @@ const isOperatorObject = (value) => {
   const keys = Object.keys(value);
   return keys.length > 0 && keys.every((key) => OPERATOR_KEY_SET.has(key));
 };
+const escapeLikeTerm = (value) => typeof value === "string" ? value.replaceAll(/[\\%_]/g, (character) => `\\${character}`) : value;
 const compileContains = (reference, value, strategy) => {
-  const term = sql`${strategy.serialize(value)}`;
-  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%'`;
+  const term = sql`${strategy.serialize(escapeLikeTerm(value))}`;
+  return strategy.likeContains ? strategy.likeContains(reference, term) : sql`${reference} LIKE '%' || ${term} || '%' ESCAPE '\\'`;
 };
 const compileComparator = (reference, operator, comparator, value, strategy) => {
   if (value === null) {
@@ -93,7 +95,7 @@ const STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["AND", "NOT", "OR", RELATION_EX
 const compileStructuralKey = (key, value, strategy) => {
   if (key === RELATION_EXISTS_KEY) {
     if (!strategy.relationExists) {
-      throw new Error("encountered a relation EXISTS marker without a relationExists strategy hook");
+      throw new LunoraError("INTERNAL", "encountered a relation EXISTS marker without a relationExists strategy hook");
     }
     return strategy.relationExists(value);
   }

package/dist/packem_shared/constant-time-equal-BVRWZgES.mjs

@@ -0,0 +1,12 @@
+const constantTimeEqual = (a, b) => {
+  const max = Math.max(a.length, b.length);
+  let diff = a.length ^ b.length;
+  for (let index = 0; index < max; index += 1) {
+    const charA = index < a.length ? a.charCodeAt(index) : 0;
+    const charB = index < b.length ? b.charCodeAt(index) : 0;
+    diff |= charA ^ charB;
+  }
+  return diff === 0;
+};
+
+export { constantTimeEqual as c };

package/dist/packem_shared/{createSystemReader-8CzSZP9V.mjs → createSystemReader-D12eNH13.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const toScheduledFunctionDoc = (record) => {
   const doc = {
     args: record["args"] ?? {},
@@ -40,13 +42,13 @@ const toStorageMetadata = (object) => {
 const createSystemReader = (options = {}) => {
   const requireScheduler = () => {
     if (!options.scheduler) {
-      throw new Error('ctx.db.system.query("_scheduled_functions"): no scheduler configured. Pass `scheduler` to createShardDO().');
+      throw new LunoraError("INTERNAL", 'ctx.db.system.query("_scheduled_functions"): no scheduler configured. Pass `scheduler` to createShardDO().');
     }
     return options.scheduler;
   };
   const requireStorage = () => {
     if (!options.storage) {
-      throw new Error('ctx.db.system.query("_storage"): no storage configured. Pass `storage` to createShardDO().');
+      throw new LunoraError("INTERNAL", 'ctx.db.system.query("_storage"): no storage configured. Pass `storage` to createShardDO().');
     }
     return options.storage;
   };

package/dist/packem_shared/ctx-db-idempotency-BdcNpvY4.mjs

@@ -0,0 +1,108 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+
+const CLIENT_WATERMARK_TABLE = "__client_watermark";
+const migrateClientWatermark = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(CLIENT_WATERMARK_TABLE)} (
+            identity TEXT NOT NULL,
+            client_id TEXT NOT NULL,
+            last_mutation_id INTEGER NOT NULL,
+            PRIMARY KEY (identity, client_id)
+        )`
+  );
+};
+const readClientWatermark = (sql$1, identity, clientId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT last_mutation_id FROM ${sql.identifier(CLIENT_WATERMARK_TABLE)} WHERE identity = ${identity} AND client_id = ${clientId} LIMIT 1`
+  ).toArray();
+  return rows[0]?.last_mutation_id ?? 0;
+};
+const advanceClientWatermark = (sql$1, identity, clientId, mutationId) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(CLIENT_WATERMARK_TABLE)} (identity, client_id, last_mutation_id) VALUES (${identity}, ${clientId}, ${mutationId})
+             ON CONFLICT(identity, client_id) DO UPDATE SET last_mutation_id = MAX(last_mutation_id, excluded.last_mutation_id)`
+  );
+};
+
+const GLOBAL_SHAPE_SNAPSHOT_TABLE = "__global_shape_snapshot";
+const migrateGlobalShapeSnapshot = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (
+            connection_id TEXT NOT NULL,
+            sub_id TEXT NOT NULL,
+            members TEXT NOT NULL,
+            PRIMARY KEY (connection_id, sub_id)
+        )`
+  );
+};
+const readGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT members FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId} LIMIT 1`
+  ).toArray();
+  const raw = rows[0]?.members;
+  if (raw === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object") {
+      return /* @__PURE__ */ new Map();
+    }
+    return new Map(Object.entries(parsed));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+};
+const writeGlobalShapeSnapshot = (sql$1, connectionId, subId, snapshot) => {
+  const members = JSON.stringify(Object.fromEntries(snapshot));
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} (connection_id, sub_id, members) VALUES (${connectionId}, ${subId}, ${members})
+             ON CONFLICT(connection_id, sub_id) DO UPDATE SET members = excluded.members`
+  );
+};
+const deleteGlobalShapeSnapshot = (sql$1, connectionId, subId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId} AND sub_id = ${subId}`);
+};
+const deleteGlobalShapeSnapshotsForConnection = (sql$1, connectionId) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(GLOBAL_SHAPE_SNAPSHOT_TABLE)} WHERE connection_id = ${connectionId}`);
+};
+
+const IDEMPOTENCY_TABLE = "__idempotency";
+const migrateIdempotency = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(IDEMPOTENCY_TABLE)} (
+            identity TEXT NOT NULL,
+            mutation_id TEXT NOT NULL,
+            result_json TEXT NOT NULL,
+            ts REAL NOT NULL,
+            PRIMARY KEY (identity, mutation_id)
+        )`
+  );
+};
+const readIdempotent = (sql$1, identity, mutationId) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT result_json, ts FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE identity = ${identity} AND mutation_id = ${mutationId} LIMIT 1`
+  ).toArray();
+  const row = rows[0];
+  return row === void 0 ? void 0 : { resultJson: row.result_json, ts: row.ts };
+};
+const writeIdempotent = (sql$1, identity, mutationId, resultJson, ts) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT OR IGNORE INTO ${sql.identifier(IDEMPOTENCY_TABLE)} (identity, mutation_id, result_json, ts) VALUES (${identity}, ${mutationId}, ${resultJson}, ${ts})`
+  );
+};
+const trimIdempotent = (sql$1, olderThanTs) => {
+  runDrizzle(sql$1, sql`DELETE FROM ${sql.identifier(IDEMPOTENCY_TABLE)} WHERE ts < ${olderThanTs}`);
+};
+
+export { CLIENT_WATERMARK_TABLE as C, GLOBAL_SHAPE_SNAPSHOT_TABLE as G, IDEMPOTENCY_TABLE as I, migrateIdempotency as a, migrateGlobalShapeSnapshot as b, advanceClientWatermark as c, deleteGlobalShapeSnapshot as d, deleteGlobalShapeSnapshotsForConnection as e, readGlobalShapeSnapshot as f, readIdempotent as g, writeIdempotent as h, migrateClientWatermark as m, readClientWatermark as r, trimIdempotent as t, writeGlobalShapeSnapshot as w };

package/dist/packem_shared/ctx-db-shapes-Cz9dHyh1.mjs

@@ -0,0 +1,53 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { D as DOC_COLUMN, r as rowToDocument, j as jsonPathSql } from './do-sql-BCHCWtrD.mjs';
+import { compileWhereSql } from './compileWhereSql-DE6yfRcQ.mjs';
+import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
+
+const shapeWhereStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };
+const idInClause = (ids) => {
+  if (ids.length === 0) {
+    return void 0;
+  }
+  return sql`id IN (${sql.join(
+    ids.map((id) => sql`${id}`),
+    sql`, `
+  )})`;
+};
+const composeWhere = (effectiveWhere, idRestriction) => {
+  const conditions = [];
+  if (idRestriction) {
+    conditions.push(idRestriction);
+  }
+  const compiled = compileWhereSql(effectiveWhere, shapeWhereStrategy);
+  if (compiled) {
+    conditions.push(compiled);
+  }
+  if (conditions.length === 0) {
+    return sql``;
+  }
+  return sql` WHERE ${sql.join(conditions, sql` AND `)}`;
+};
+const selectShapeRows = (sql$1, table, effectiveWhere) => {
+  const whereClause = composeWhere(effectiveWhere, void 0);
+  const rows = runDrizzle(sql$1, sql`SELECT id, _creationTime, ${sql.identifier(DOC_COLUMN)} FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  const result = [];
+  for (const row of rows) {
+    const doc = rowToDocument(row);
+    const { id } = row;
+    if (doc !== void 0 && typeof id === "string") {
+      result.push({ doc, id });
+    }
+  }
+  return result;
+};
+const selectShapeMemberIds = (sql$1, table, effectiveWhere, ids) => {
+  if (ids.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  const whereClause = composeWhere(effectiveWhere, idInClause(ids));
+  const rows = runDrizzle(sql$1, sql`SELECT id FROM ${sql.identifier(table)}${whereClause}`).toArray();
+  return new Set(rows.map((row) => row.id));
+};
+
+export { selectShapeMemberIds as a, selectShapeRows as s };