@lunora/do 1.0.0-alpha.4 → 1.0.0-alpha.41

package/dist/packem_shared/createMetrics-C4I2Yanj.mjs

@@ -0,0 +1 @@
+export { b as applyCloudflareSpanAttributes, c as createMetrics, a as createTracer, d as dispatchRootSpan } from './context-telemetry-CDpyil58.mjs';

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-DTeFiHYS.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-CGAgiQUz.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 };

package/dist/packem_shared/diffExternalSource-CovHfdyo.mjs

@@ -0,0 +1,44 @@
+import { stableStringify } from './stableStringify-mC40mZts.mjs';
+
+const projectExternalSourceRow = (row, columns) => {
+  const projected = { _id: row._id };
+  if (columns) {
+    for (const key of columns) {
+      if (Object.hasOwn(row, key)) {
+        projected[key] = row[key];
+      }
+    }
+    return projected;
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== "_id" && key !== "_creationTime") {
+      projected[key] = value;
+    }
+  }
+  return projected;
+};
+const diffExternalSource = (pulled, baseline, options) => {
+  const { columns, table } = options;
+  const changes = [];
+  const nextBaseline = /* @__PURE__ */ new Map();
+  for (const source of pulled) {
+    const value = projectExternalSourceRow(source, columns);
+    const id = String(value._id);
+    const json = stableStringify(value);
+    nextBaseline.set(id, json);
+    const before = baseline.get(id);
+    if (before === void 0) {
+      changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
+    } else if (before !== json) {
+      changes.push({ doc: value, id, op: "update", seq: 0, table, ts: 0 });
+    }
+  }
+  for (const id of baseline.keys()) {
+    if (!nextBaseline.has(id)) {
+      changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+    }
+  }
+  return { changes, nextBaseline };
+};
+
+export { diffExternalSource, projectExternalSourceRow };

package/dist/packem_shared/{do-sql-BCHCWtrD.mjs → do-sql-CGAgiQUz.mjs}

@@ -2,6 +2,7 @@ import { sql } from 'drizzle-orm';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 
 const DOC_COLUMN = "__doc__";
+const geoTableName = (table, indexName) => `${table}__geo_${indexName}`;
 const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
 const jsonPath = (field) => {
   if (field === "_id" || field === "id") {
@@ -84,4 +85,4 @@ const isFtsAvailable = (sql$1) => {
   return available;
 };
 
-export { AGG_KEY as A, DOC_COLUMN as D, AGG_VALUE as a, AGG_COUNT as b, createIndexSql as c, aggUpsertSql as d, qualifiedJsonPathSql as e, isFtsAvailable as i, jsonPathSql as j, quoteIdentifier as q, rowToDocument as r, tableColumns as t };
+export { AGG_KEY as A, DOC_COLUMN as D, AGG_VALUE as a, AGG_COUNT as b, createIndexSql as c, aggUpsertSql as d, qualifiedJsonPathSql as e, geoTableName as g, isFtsAvailable as i, jsonPathSql as j, quoteIdentifier as q, rowToDocument as r, tableColumns as t };

package/dist/packem_shared/{exportShardRows-DZEhUeyI.mjs → exportShardRows-Dy3oFZ26.mjs}

@@ -1,3 +1,5 @@
+import { toErrorBody } from '@lunora/errors';
+
 const DEFAULT_BATCH_SIZE = 200;
 const selectExportTables = (schema, requested) => {
   const isShardLocal = (table) => {
@@ -107,9 +109,8 @@ const importOneRow = async (writer, schema, row, line) => {
     await writer.insert(table, doc, { allowExplicitId: true });
     return { kind: "inserted", table };
   } catch (error) {
-    const code = error.code ?? "INSERT_FAILED";
-    const message = error instanceof Error ? error.message : String(error);
-    return { error: { code, line, message, table }, kind: "error" };
+    const { body } = toErrorBody(error, { fallbackCode: "INSERT_FAILED" });
+    return { error: { code: body.code, line, message: body.message, table }, kind: "error" };
   }
 };
 const importShardRows = async (writer, schema, args) => {

package/dist/packem_shared/isSoftDeleted-CFJmhjFP.mjs

@@ -0,0 +1,217 @@
+import { LunoraError } from '@lunora/errors';
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { runExternalSourceTick, materializeExternalRowsIncremental } from './materializeExternalRows-BtEGs1Fv.mjs';
+
+const SOURCE_CURSOR_TABLE = "__lunora_source_cursor";
+const serializeCursor = (value) => {
+  if (value instanceof Date) {
+    return `d:${value.toISOString()}`;
+  }
+  if (typeof value === "bigint") {
+    return `b:${value.toString()}`;
+  }
+  if (typeof value === "number") {
+    return `n:${value.toString()}`;
+  }
+  return `s:${value}`;
+};
+const deserializeCursor = (text) => {
+  const rest = text.slice(2);
+  switch (text[0]) {
+    case "b": {
+      return BigInt(rest);
+    }
+    case "d": {
+      return new Date(rest);
+    }
+    case "n": {
+      return Number(rest);
+    }
+    default: {
+      return rest;
+    }
+  }
+};
+const INTEGER_STRING = /^-?\d+$/;
+const DECIMAL_STRING = /^-?\d+(?:\.\d+)?$/;
+const cursorAfter = (a, b) => {
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() > b.getTime();
+  }
+  if (typeof a === "bigint" && typeof b === "bigint") {
+    return a > b;
+  }
+  if (typeof a === "number" && typeof b === "number") {
+    return a > b;
+  }
+  if (typeof a === "string" && typeof b === "string" && DECIMAL_STRING.test(a) && DECIMAL_STRING.test(b)) {
+    if (INTEGER_STRING.test(a) && INTEGER_STRING.test(b)) {
+      return BigInt(a) > BigInt(b);
+    }
+    return Number(a) > Number(b);
+  }
+  return String(a) > String(b);
+};
+const maxCursorValue = (rows, column, current) => {
+  let best = current === null ? void 0 : deserializeCursor(current);
+  for (const row of rows) {
+    const raw = row[column];
+    if (raw === null || raw === void 0) {
+      continue;
+    }
+    const value = raw;
+    if (best === void 0 || cursorAfter(value, best)) {
+      best = value;
+    }
+  }
+  return best === void 0 ? null : serializeCursor(best);
+};
+const migrateSourceCursor = (sql$1) => {
+  runDrizzle(
+    sql$1,
+    sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(SOURCE_CURSOR_TABLE)} (
+            table_name TEXT NOT NULL,
+            shard_key TEXT NOT NULL,
+            watermark TEXT,
+            last_reconcile_ms INTEGER,
+            PRIMARY KEY (table_name, shard_key)
+        )`
+  );
+};
+const readSourceCursor = (sql$1, table, shardKey) => {
+  const rows = runDrizzle(
+    sql$1,
+    sql`SELECT watermark, last_reconcile_ms FROM ${sql.identifier(SOURCE_CURSOR_TABLE)} WHERE table_name = ${table} AND shard_key = ${shardKey} LIMIT 1`
+  ).toArray();
+  const row = rows[0];
+  return { lastReconcileMs: row?.last_reconcile_ms ?? null, watermark: row?.watermark ?? null };
+};
+const writeSourceCursor = (sql$1, table, shardKey, state) => {
+  runDrizzle(
+    sql$1,
+    sql`INSERT INTO ${sql.identifier(SOURCE_CURSOR_TABLE)} (table_name, shard_key, watermark, last_reconcile_ms)
+             VALUES (${table}, ${shardKey}, ${state.watermark}, ${state.lastReconcileMs})
+             ON CONFLICT(table_name, shard_key) DO UPDATE SET watermark = excluded.watermark, last_reconcile_ms = excluded.last_reconcile_ms`
+  );
+};
+
+const normalizeSourceValue = (value) => {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "bigint") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((element) => normalizeSourceValue(element));
+  }
+  if (value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return normalizeSourceDocument(value);
+  }
+  return value;
+};
+const normalizeSourceDocument = (document) => {
+  const normalized = {};
+  for (const [key, value] of Object.entries(document)) {
+    normalized[key] = normalizeSourceValue(value);
+  }
+  return normalized;
+};
+const liftSourceId = (row, options = {}) => {
+  const { idColumn = "id", map } = options;
+  const idValue = row[idColumn];
+  if (idValue === void 0 || idValue === null) {
+    throw new LunoraError("INTERNAL", `external-source: row is missing id column "${idColumn}"`);
+  }
+  if (typeof idValue !== "string" && typeof idValue !== "number" && typeof idValue !== "bigint") {
+    throw new TypeError(`external-source: id column "${idColumn}" must be a string or number`);
+  }
+  const id = String(idValue);
+  if (map) {
+    return normalizeSourceDocument({ ...map(row), _id: id });
+  }
+  const body = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key !== idColumn) {
+      body[key] = value;
+    }
+  }
+  return normalizeSourceDocument({ ...body, _id: id });
+};
+const isSourceDue = (refresh, lastPolledMs, nowMs) => {
+  if (refresh === "manual") {
+    return false;
+  }
+  if (refresh === void 0 || lastPolledMs === void 0) {
+    return true;
+  }
+  return nowMs - lastPolledMs >= refresh.everyMs;
+};
+const pullAndLift = async (client, query, parameters, source) => {
+  const rows = await client.query(query, parameters);
+  const documents = rows.map((row) => liftSourceId(row, { idColumn: source.idColumn, map: source.map }));
+  return { documents, rows };
+};
+const pullExternalSourceTick = async (sql, writer, client, table, source, shardKey) => {
+  const parameters = source.tenantBy ? source.tenantBy(shardKey) : [];
+  const { documents } = await pullAndLift(client, source.query, parameters, source);
+  return runExternalSourceTick(sql, writer, documents, { columns: source.columns, table });
+};
+const isSoftDeleted = (row, column) => {
+  const value = row[column];
+  return value !== null && value !== void 0 && value !== false && value !== 0;
+};
+const pullExternalSourceIncrementalTick = async (sql, writer, client, table, source, shardKey, nowMs) => {
+  const { cursor } = source;
+  if (!cursor) {
+    throw new LunoraError(
+      "INTERNAL",
+      `external-source: table "${table}" is mode "incremental" but has no \`cursor\` — this should have been rejected at defineSchema`
+    );
+  }
+  migrateSourceCursor(sql);
+  const state = readSourceCursor(sql, table, shardKey);
+  const tenantParameters = source.tenantBy ? source.tenantBy(shardKey) : [];
+  const reconcileDue = source.reconcileEveryMs !== void 0 && (state.lastReconcileMs === null || nowMs - state.lastReconcileMs >= source.reconcileEveryMs);
+  const fullPull = state.watermark === null || reconcileDue;
+  let slice;
+  let applied;
+  if (state.watermark === null || reconcileDue) {
+    slice = await pullAndLift(client, source.query, tenantParameters, source);
+    const { softDeleteColumn } = source;
+    const documents = softDeleteColumn ? slice.documents.filter((_document, index) => {
+      const row = slice.rows[index];
+      return !(row && isSoftDeleted(row, softDeleteColumn));
+    }) : slice.documents;
+    ({ applied } = await runExternalSourceTick(sql, writer, documents, { columns: source.columns, table }));
+  } else {
+    slice = await pullAndLift(client, cursor.query, [...tenantParameters, deserializeCursor(state.watermark)], source);
+    const { softDeleteColumn } = source;
+    const deletedIds = softDeleteColumn ? new Set(
+      slice.documents.flatMap((document, index) => {
+        const row = slice.rows[index];
+        return row && isSoftDeleted(row, softDeleteColumn) ? [String(document._id)] : [];
+      })
+    ) : void 0;
+    ({ applied } = await materializeExternalRowsIncremental(writer, slice.documents, { columns: source.columns, deletedIds, table }));
+  }
+  const watermark = maxCursorValue(slice.rows, cursor.column, state.watermark);
+  if (fullPull && watermark === null && slice.rows.length > 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — the seed \`query\` must project it (matching \`cursor.query\`'s alias), or the watermark can never advance.`
+    );
+  }
+  const noRowCarriesCursor = slice.rows.length > 0 && slice.rows.every((row) => row[cursor.column] === null || row[cursor.column] === void 0);
+  if (!fullPull && noRowCarriesCursor) {
+    throw new LunoraError(
+      "INTERNAL",
+      `external-source: table "${table}" (mode "incremental") pulled ${String(slice.rows.length)} rows but none carry the cursor column "${cursor.column}" — \`cursor.query\` must project it (matching the seed \`query\`'s alias), or the watermark can never advance and every tick re-pulls the same stranded slice.`
+    );
+  }
+  writeSourceCursor(sql, table, shardKey, { lastReconcileMs: fullPull ? nowMs : state.lastReconcileMs, watermark });
+  return { applied };
+};
+
+export { isSoftDeleted, isSourceDue, liftSourceId, normalizeSourceValue, pullExternalSourceIncrementalTick, pullExternalSourceTick };

package/dist/packem_shared/json-response-BdbtpOhm.mjs

@@ -0,0 +1,3 @@
+const jsonResponse = (body, status = 200, headers) => Response.json(body, { headers: { "content-type": "application/json", ...headers }, status });
+
+export { jsonResponse as j };

package/dist/packem_shared/materializeExternalRows-BtEGs1Fv.mjs

@@ -0,0 +1,45 @@
+import { applyCdcChanges } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
+import { s as selectShapeRows } from './ctx-db-shapes-DTeFiHYS.mjs';
+import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-CovHfdyo.mjs';
+import { stableStringify } from './stableStringify-mC40mZts.mjs';
+
+const materializeExternalRows = async (writer, pulled, baseline, options) => {
+  const { changes, nextBaseline } = diffExternalSource(pulled, baseline, options);
+  await applyCdcChanges(writer, changes);
+  return { applied: changes.length, nextBaseline };
+};
+const materializeExternalRowsIncremental = async (writer, pulled, options) => {
+  const { columns, deletedIds, table } = options;
+  const changes = [];
+  for (const source of pulled) {
+    const value = projectExternalSourceRow(source, columns);
+    const id = String(value._id);
+    if (deletedIds?.has(id)) {
+      const existing = await writer.get(id, table);
+      if (existing) {
+        changes.push({ id, op: "delete", seq: 0, table, ts: 0 });
+      }
+      continue;
+    }
+    const stored = await writer.get(id, table);
+    if (stored && stableStringify(projectExternalSourceRow({ ...stored, _id: id }, columns)) === stableStringify(value)) {
+      continue;
+    }
+    changes.push({ doc: value, id, op: "insert", seq: 0, table, ts: 0 });
+  }
+  await applyCdcChanges(writer, changes);
+  return { applied: changes.length };
+};
+const readExternalSourceBaseline = (sql, table, columns) => {
+  const baseline = /* @__PURE__ */ new Map();
+  for (const { doc, id } of selectShapeRows(sql, table, void 0)) {
+    baseline.set(id, stableStringify(projectExternalSourceRow({ ...doc, _id: id }, columns)));
+  }
+  return baseline;
+};
+const runExternalSourceTick = async (sql, writer, pulled, options) => {
+  const baseline = readExternalSourceBaseline(sql, options.table, options.columns);
+  return materializeExternalRows(writer, pulled, baseline, options);
+};
+
+export { materializeExternalRows, materializeExternalRowsIncremental, readExternalSourceBaseline, runExternalSourceTick };

package/dist/packem_shared/{runShardMigrations-PabobOjF.mjs → runShardMigrations-BVax6rYu.mjs}

@@ -1,10 +1,10 @@
 import { sql } from 'drizzle-orm';
 import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-Ctdmxmrv.mjs';
-import { m as migrateIdempotency } from './ctx-db-idempotency-DkC9rP91.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-uwOJxJJZ.mjs';
+import { m as migrateClientWatermark, a as migrateIdempotency, b as migrateGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { D as DOC_COLUMN, j as jsonPathSql, c as createIndexSql, t as tableColumns, i as isFtsAvailable, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';
-import { s as sortColumnName, r as rankTableName } from './rank-CrkEIpF4.mjs';
+import { D as DOC_COLUMN, j as jsonPathSql, c as createIndexSql, t as tableColumns, i as isFtsAvailable, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT, g as geoTableName } from './do-sql-CGAgiQUz.mjs';
+import { sortColumnName, rankTableName } from './RANK_TIEBREAK-CXhdcA1o.mjs';
 import { ftsTableName } from './buildFtsMatch-BLEMawrp.mjs';
 
 const migrateSecondaryIndexes = (sql$1, tableName, definition) => {
@@ -36,6 +36,20 @@ const migrateSearchIndexes = (sql$1, tableName, definition) => {
     );
   }
 };
+const migrateGeoIndexes = (sql$1, tableName, definition) => {
+  if (!definition.geoIndexes) {
+    return;
+  }
+  for (const index of definition.geoIndexes) {
+    const geoTable = geoTableName(tableName, index.name);
+    runDrizzle(
+      sql$1,
+      sql`CREATE TABLE IF NOT EXISTS ${sql.identifier(geoTable)} (${sql.identifier("__id__")} TEXT PRIMARY KEY, ${sql.identifier("__geohash__")} TEXT NOT NULL, ${sql.identifier("__lat__")} REAL NOT NULL, ${sql.identifier("__lng__")} REAL NOT NULL)`
+    );
+    const btreeName = `${tableName}__geo_${index.name}__btree`;
+    runDrizzle(sql$1, createIndexSql(btreeName, geoTable, sql`${sql.identifier("__geohash__")} ASC, ${sql.identifier("__id__")} ASC`, false));
+  }
+};
 const migrateAggregateIndexes = (sql$1, tableName, definition) => {
   if (!definition.aggregateIndexes) {
     return;
@@ -90,14 +104,17 @@ const runShardMigrations = (sql$1, schema, options = {}) => {
     );
     migrateSecondaryIndexes(sql$1, tableName, definition);
     migrateSearchIndexes(sql$1, tableName, definition);
+    migrateGeoIndexes(sql$1, tableName, definition);
     migrateAggregateIndexes(sql$1, tableName, definition);
     migrateRankIndexes(sql$1, tableName, definition);
   }
   if (options.cdc) {
     migrateCdcLog(sql$1);
     migrateCdcMeta(sql$1);
+    migrateClientWatermark(sql$1);
   }
   migrateIdempotency(sql$1);
+  migrateGlobalShapeSnapshot(sql$1);
 };
 
 export { runShardMigrations };

package/dist/packem_shared/selectExpiredIds-C5W29Upb.mjs

@@ -0,0 +1,18 @@
+import { sql } from 'drizzle-orm';
+import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
+import { j as jsonPathSql } from './do-sql-CGAgiQUz.mjs';
+
+const selectExpiredIds = (sql$1, spec, now, limit) => {
+  const cutoff = now - (spec.after ?? 0);
+  const conditions = [sql`${jsonPathSql(spec.field)} IS NOT NULL`, sql`${jsonPathSql(spec.field)} < ${cutoff}`];
+  if (spec.softDeleteField !== void 0) {
+    conditions.push(sql`${jsonPathSql(spec.softDeleteField)} IS NULL`);
+  }
+  const query = sql`SELECT id FROM ${sql.identifier(spec.table)} WHERE ${sql.join(conditions, sql` AND `)} LIMIT ${sql.raw(String(Math.max(0, Math.floor(limit)) + 1))}`;
+  const rows = runDrizzle(sql$1, query).toArray();
+  const hasMore = rows.length > limit;
+  const ids = rows.slice(0, limit).map((row) => row.id);
+  return { hasMore, ids };
+};
+
+export { selectExpiredIds };

package/dist/packem_shared/serialize-sql-BlRUoiQe.mjs

@@ -0,0 +1,14 @@
+const serializeSqlValue = (value) => {
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (value === null || typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  return JSON.stringify(value);
+};
+
+export { serializeSqlValue as s };

package/dist/packem_shared/{serveRelationFanout-CFBKWJ8Q.mjs → serveRelationFanout-k7HTh3CC.mjs}

@@ -1,17 +1,14 @@
-import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-Dzdqq5J2.mjs';
+import { LunoraError } from '@lunora/errors';
+import { RELATION_FUNCTION_PREFIX } from './ADMIN_FUNCTIONS-CnZkbXH_.mjs';
 
 const serveRelationFanout = async (schema, database, functionPath, args) => {
   const table = typeof args["table"] === "string" ? args["table"] : "";
   const definition = schema.tables[table];
   if (!definition) {
-    throw Object.assign(new Error(`${RELATION_FUNCTION_PREFIX} unknown table "${table}"`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `${RELATION_FUNCTION_PREFIX} unknown table "${table}"`, { status: 404 });
   }
   if (definition.shardMode?.kind === "global") {
-    throw Object.assign(new Error(`${RELATION_FUNCTION_PREFIX} table "${table}" is global, not shard-local`), {
-      code: "BAD_REQUEST",
-      name: "LunoraError",
-      status: 400
-    });
+    throw new LunoraError("BAD_REQUEST", `${RELATION_FUNCTION_PREFIX} table "${table}" is global, not shard-local`);
   }
   const where = args["where"] ?? void 0;
   if (functionPath === `${RELATION_FUNCTION_PREFIX}count`) {