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

package/dist/index.mjs

@@ -1,35 +1,44 @@
-export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow } from './packem_shared/exportShardRows-DZEhUeyI.mjs';
-export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler } from './packem_shared/AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
+export { exportShardRows, exportShardTable, importShardRows, parseExportShardArgs, parseImportShardArgs, selectExportTables, validateImportRow } from './packem_shared/exportShardRows-Dy3oFZ26.mjs';
+export { AGGREGATE_SQL_FUNCTION, aggregateSqlFunction, matchesStaticWhere, normalizeCountArgument, throwingScheduler } from './packem_shared/AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 export { aggregateTableName, coerceAggregateNumber, encodeAggregateKey, foldAggregateTally, readAggregateValue } from './packem_shared/aggregateTableName-CxNqY1Sl.mjs';
-export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy } from './packem_shared/CountRlsUnsupportedError-28ZvvwKS.mjs';
+export { CountRlsUnsupportedError, mergeWhere, planAggregateLookup, selectIndexForAggregate, selectIndexForCount, selectIndexForGroupBy } from './packem_shared/CountRlsUnsupportedError-BGxj0pgS.mjs';
 export { AUTH_METRICS_BUCKETS_TABLE, AUTH_METRICS_BUCKET_MS, AUTH_METRICS_BUCKET_RETENTION, AUTH_METRICS_TABLE, ensureAuthMetricsTables, readAuthMetrics, recordAuthEvent } from './packem_shared/AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
-export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-B6tzuDmM.mjs';
-export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.mjs';
+export { c as createMetrics, a as createTracer, d as dispatchRootSpan } from './packem_shared/context-telemetry-CDpyil58.mjs';
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-DbtlWwcG.mjs';
+export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-CYwBpyTr.mjs';
 export { SCAN_DEP, createDependencyTracker, depKey } from './packem_shared/SCAN_DEP-DLJF8dsj.mjs';
 export { renderSql } from './packem_shared/renderSql-D6eUcn2N.mjs';
+export { diffExternalSource } from './packem_shared/diffExternalSource-CovHfdyo.mjs';
+export { materializeExternalRows, materializeExternalRowsIncremental, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-BtEGs1Fv.mjs';
+export { isSoftDeleted, isSourceDue, liftSourceId, pullExternalSourceIncrementalTick, pullExternalSourceTick } from './packem_shared/isSoftDeleted-CFJmhjFP.mjs';
 export { FUNCTION_METRICS_BUCKETS_TABLE, FUNCTION_METRICS_BUCKET_MS, FUNCTION_METRICS_BUCKET_RETENTION, FUNCTION_METRICS_INDEX_TABLE, FUNCTION_METRICS_TABLE, ensureFunctionMetricsTables, readFunctionMetricBuckets, readFunctionMetricIndexHits, readFunctionMetrics, readFunctionMetricsTotals, recordFunctionMetric } from './packem_shared/FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-Dzdqq5J2.mjs';
+export { GEO_DEFAULT_PRECISION, boundingBoxGeohashes, coveringGeohashes, encodeGeohash, haversineMeters, pointInBoundingBox } from './packem_shared/GEO_DEFAULT_PRECISION-BWnsNmpP.mjs';
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, FLAGS_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-CnZkbXH_.mjs';
 export { LogBuffer } from './packem_shared/LogBuffer-B_Ezju_N.mjs';
 export { MAIL_RETENTION, MAIL_TABLE, clearCapturedMail, ensureMailTable, readCapturedMail, recordCapturedMail } from './packem_shared/MAIL_RETENTION-CPpgl-dX.mjs';
-export { default as NotFoundError } from './packem_shared/NotFoundError-CMuMZt81.mjs';
-export { armRestore, readBookmark } from './packem_shared/armRestore-BJk53Ro8.mjs';
-export { buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys } from './packem_shared/buildSeekWhere-lVsNXSLy.mjs';
-export { R as RANK_TIEBREAK, e as encodePartitionKey, m as matchesRankStaticWhere, r as rankTableName, a as resolveRankPartition, s as sortColumnName } from './packem_shared/rank-CrkEIpF4.mjs';
-export { ReactiveCache, reactiveCacheKey, stableStringify } from './packem_shared/ReactiveCache-ByVzgH3d.mjs';
-export { serveRelationFanout } from './packem_shared/serveRelationFanout-CFBKWJ8Q.mjs';
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-DyVYReuT.mjs';
-export { applyOnDelete, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-CMif2RKw.mjs';
-export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-u3UlnCH5.mjs';
+export { default as NotFoundError } from './packem_shared/NotFoundError-C70b9hLw.mjs';
+export { armRestore, readBookmark } from './packem_shared/armRestore-4Px61hHS.mjs';
+export { applySelect, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope } from './packem_shared/applySelect-WQY8m62C.mjs';
+export { RANK_TIEBREAK, encodePartitionKey, matchesRankStaticWhere, rankTableName, resolveRankPartition, sortColumnName } from './packem_shared/RANK_TIEBREAK-CXhdcA1o.mjs';
+export { ReactiveCache, reactiveCacheKey } from './packem_shared/ReactiveCache-DnSvbjil.mjs';
+export { serveRelationFanout } from './packem_shared/serveRelationFanout-k7HTh3CC.mjs';
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-BEan1CRD.mjs';
+export { applyOnDelete, fanOutScalarCounts, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-BXSq3S70.mjs';
+export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-DTvHvRzY.mjs';
 export { buildFtsMatch, ftsTableName, scoreDocument, stringifySearchText, tokenizeSearch } from './packem_shared/buildFtsMatch-BLEMawrp.mjs';
 export { M as MIN_ADMIN_TOKEN_LENGTH, a as MIN_AUTH_SECRET_LENGTH, b as buildSecurityAudit } from './packem_shared/security-audit-CucgBice.mjs';
-export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-ilPZsVwu.mjs';
-export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO, subscriptionListDeltas } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-3lZ2yigq.mjs';
-export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-BsAbi5Mn.mjs';
-export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-dDcFE1YZ.mjs';
-export { createSystemReader } from './packem_shared/createSystemReader-8CzSZP9V.mjs';
-export { ConflictError } from './packem_shared/ConflictError-C0STs6bU.mjs';
+export { SESSION_DO_TTL_DEFAULT, SessionDO } from './packem_shared/SESSION_DO_TTL_DEFAULT-BnSKgVO4.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-B4Cpm7Qv.mjs';
+export { SHARD_REGISTRY_DO_NAME, ShardRegistryDO } from './packem_shared/SHARD_REGISTRY_DO_NAME-D99roc-r.mjs';
+export { MAX_SQL_ROWS, assertReadonly, runReadonlySql } from './packem_shared/MAX_SQL_ROWS-iFAA8FbD.mjs';
+export { createSystemReader } from './packem_shared/createSystemReader-D12eNH13.mjs';
+export { ConflictError } from './packem_shared/ConflictError-CLoq37xH.mjs';
 export { hasTrigger, runTriggers } from './packem_shared/hasTrigger-5N6_Fx0A.mjs';
-export { compileWhereSql } from './packem_shared/compileWhereSql-CXrhFA3G.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-Ctdmxmrv.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BbVPvciS.mjs';
-export { runShardMigrations } from './packem_shared/runShardMigrations-PabobOjF.mjs';
+export { selectExpiredIds } from './packem_shared/selectExpiredIds-C5W29Upb.mjs';
+export { compileWhereSql } from './packem_shared/compileWhereSql-DE6yfRcQ.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-uwOJxJJZ.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BGTwynwh.mjs';
+export { runShardMigrations } from './packem_shared/runShardMigrations-BVax6rYu.mjs';
+export { stableStringify } from './packem_shared/stableStringify-mC40mZts.mjs';
+export { stableWireKey } from './packem_shared/stableWireKey-DKuXO7T5.mjs';
+export { subscriptionListDeltas } from './packem_shared/subscriptionListDeltas-CT76bYny.mjs';

package/dist/packem_shared/{ADMIN_FUNCTIONS-Dzdqq5J2.mjs → ADMIN_FUNCTIONS-CnZkbXH_.mjs}

@@ -1,9 +1,16 @@
+import { LunoraError } from '@lunora/errors';
+
+const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
+
 const ADMIN_FUNCTION_PREFIX = "__lunora_admin__:";
 const RELATION_FUNCTION_PREFIX = "__lunora_relation__:";
+const FLAGS_FUNCTION_PREFIX = "__lunora_flags__:";
 const ADMIN_FUNCTIONS = {
   applyCdc: "__lunora_admin__:applyCdc",
+  assignIssue: "__lunora_admin__:assignIssue",
   cdcSync: "__lunora_admin__:cdcSync",
   clearCapturedMail: "__lunora_admin__:clearCapturedMail",
+  clearQueueMessages: "__lunora_admin__:clearQueueMessages",
   clearTable: "__lunora_admin__:clearTable",
   createWorkflowInstance: "__lunora_admin__:createWorkflowInstance",
   deleteRows: "__lunora_admin__:deleteRows",
@@ -15,18 +22,27 @@ const ADMIN_FUNCTIONS = {
   getAuditLog: "__lunora_admin__:getAuditLog",
   getAuthMetrics: "__lunora_admin__:getAuthMetrics",
   getCapturedMail: "__lunora_admin__:getCapturedMail",
+  getFanoutMetrics: "__lunora_admin__:getFanoutMetrics",
   getFunctionStats: "__lunora_admin__:getFunctionStats",
+  getIssues: "__lunora_admin__:getIssues",
+  getMetricHistory: "__lunora_admin__:getMetricHistory",
+  getMetricSeries: "__lunora_admin__:getMetricSeries",
   listSubscriptions: "__lunora_admin__:listSubscriptions",
   listTableIndexes: "__lunora_admin__:listTableIndexes",
   getLogs: "__lunora_admin__:getLogs",
   getMetrics: "__lunora_admin__:getMetrics",
   getPitrBookmark: "__lunora_admin__:getPitrBookmark",
+  getQueueMessages: "__lunora_admin__:getQueueMessages",
   getRequestLog: "__lunora_admin__:getRequestLog",
   getSecurityAudit: "__lunora_admin__:getSecurityAudit",
   getSettings: "__lunora_admin__:getSettings",
+  getTraces: "__lunora_admin__:getTraces",
   // eslint-disable-next-line no-secrets/no-secrets -- reserved admin RPC path constant, not a credential
   getWorkflowInstanceStatus: "__lunora_admin__:getWorkflowInstanceStatus",
+  ignoreIssue: "__lunora_admin__:ignoreIssue",
   importShard: "__lunora_admin__:importShard",
+  listFlags: "__lunora_admin__:listFlags",
+  listQueues: "__lunora_admin__:listQueues",
   listTables: "__lunora_admin__:listTables",
   listWorkflows: "__lunora_admin__:listWorkflows",
   maskPolicies: "__lunora_admin__:maskPolicies",
@@ -38,11 +54,16 @@ const ADMIN_FUNCTIONS = {
   recordAuthEvent: "__lunora_admin__:recordAuthEvent",
   recordContainerEvent: "__lunora_admin__:recordContainerEvent",
   recordMail: "__lunora_admin__:recordMail",
+  recordQueueMessage: "__lunora_admin__:recordQueueMessage",
+  replayQueueMessage: "__lunora_admin__:replayQueueMessage",
+  resolveIssue: "__lunora_admin__:resolveIssue",
   rlsPolicies: "__lunora_admin__:rlsPolicies",
   runAs: "__lunora_admin__:runAs",
   runMigration: "__lunora_admin__:runMigration",
   runSql: "__lunora_admin__:runSql",
+  sendQueueMessage: "__lunora_admin__:sendQueueMessage",
   sendTestMail: "__lunora_admin__:sendTestMail",
+  setIssueSeverity: "__lunora_admin__:setIssueSeverity",
   storageOrphans: "__lunora_admin__:storageOrphans",
   storageReferences: "__lunora_admin__:storageReferences",
   storageRules: "__lunora_admin__:storageRules",
@@ -91,7 +112,6 @@ const expandDocumentRows = (columns, rows) => {
 };
 const escapeLike = (value) => value.replaceAll(/[\\%_]/g, (character) => `\\${character}`);
 const isInternalTable = (name) => name.startsWith("sqlite_") || name.startsWith("_cf_") || name.startsWith("__miniflare") || name.startsWith("__lunora") || name.includes("__fts_");
-const quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
 const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
 const countRows = (sql, quotedTable) => {
   const row = sql.exec(`SELECT COUNT(*) AS c FROM ${quotedTable}`).one();
@@ -169,7 +189,7 @@ const buildOrderBy = (orderBy, physicalColumns) => {
 const readTablePage = (sql, options) => {
   const { table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? DEFAULT_PAGE_SIZE), 1, MAX_PAGE_SIZE);
   const offset = Math.max(0, Math.trunc(options.offset ?? 0));
@@ -195,14 +215,17 @@ const readTablePage = (sql, options) => {
   const orderSql = order === void 0 ? "" : ` ORDER BY ${order.sql}`;
   const whereParams = predicate?.parameters ?? [];
   const orderParams = order?.params ?? [];
-  const total = predicate === void 0 ? countRows(sql, quoted) : Number(sql.exec(`SELECT COUNT(*) AS c FROM ${quoted}${whereSql}`, ...whereParams).one().c);
+  let total;
+  if (!options.skipCount) {
+    total = predicate === void 0 ? countRows(sql, quoted) : Number(sql.exec(`SELECT COUNT(*) AS c FROM ${quoted}${whereSql}`, ...whereParams).one().c);
+  }
   const rawRows = sql.exec(`SELECT * FROM ${quoted}${whereSql}${orderSql} LIMIT ? OFFSET ?`, ...whereParams, ...orderParams, limit, offset).toArray();
   return withReferences({ ...expandDocumentRows(columns, rawRows), total });
 };
 const selectMatchingIds = (sql, options) => {
   const { table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? MAX_PAGE_SIZE), 1, MAX_PAGE_SIZE);
   const quoted = quoteIdentifier(table);
@@ -233,16 +256,16 @@ const knownDisplayColumns = (sql, quotedTable, physicalColumns) => {
 const facetColumn = (sql, options) => {
   const { column, table } = options;
   if (isInternalTable(table) || !tableExists(sql, table)) {
-    throw Object.assign(new Error(`unknown table: ${table}`), { code: "UNKNOWN_TABLE", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_TABLE", `unknown table: ${table}`, { status: 404 });
   }
   const quoted = quoteIdentifier(table);
   const physicalColumns = sql.exec(`PRAGMA table_info(${quoted})`).toArray().map((info) => info.name);
   if (!knownDisplayColumns(sql, quoted, physicalColumns).has(column)) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_COLUMN", `unknown column: ${column}`, { status: 404 });
   }
   const resolved = resolveColumnExpression(column, physicalColumns);
   if (resolved === void 0) {
-    throw Object.assign(new Error(`unknown column: ${column}`), { code: "UNKNOWN_COLUMN", name: "LunoraError", status: 404 });
+    throw new LunoraError("UNKNOWN_COLUMN", `unknown column: ${column}`, { status: 404 });
   }
   const limit = clamp(Math.trunc(options.limit ?? DEFAULT_FACET_LIMIT), 1, MAX_FACET_LIMIT);
   const needle = options.search?.trim() ?? "";
@@ -309,5 +332,43 @@ const summarizeSubscriptions = (attachments) => {
   const totalSubscriptions = connections.reduce((sum, connection) => sum + connection.subscriptions.length, 0);
   return { connections, totalConnections: connections.length, totalSubscriptions };
 };
+const DEFAULT_FANOUT_TOPIC_LIMIT = 20;
+const createFanoutCounters = () => {
+  return { maxMs: 0, passes: 0, peakSocketsIterated: 0, socketsDelivered: 0, socketsIterated: 0, totalMs: 0 };
+};
+const recordFanoutPass = (counters, iterated, delivered, ms) => {
+  return {
+    maxMs: Math.max(counters.maxMs, ms),
+    passes: counters.passes + 1,
+    peakSocketsIterated: Math.max(counters.peakSocketsIterated, iterated),
+    socketsDelivered: counters.socketsDelivered + delivered,
+    socketsIterated: counters.socketsIterated + iterated,
+    totalMs: counters.totalMs + ms
+  };
+};
+const summarizeFanoutTopics = (attachments, limit = DEFAULT_FANOUT_TOPIC_LIMIT) => {
+  const shapeCounts = /* @__PURE__ */ new Map();
+  const whisperCounts = /* @__PURE__ */ new Map();
+  for (const attachment of attachments) {
+    for (const shape of Object.values(attachment.shapes ?? {})) {
+      const key = shape.name ?? "(unknown shape)";
+      shapeCounts.set(key, (shapeCounts.get(key) ?? 0) + 1);
+    }
+    for (const topic of attachment.whispers ?? []) {
+      whisperCounts.set(topic, (whisperCounts.get(topic) ?? 0) + 1);
+    }
+  }
+  const topics = [
+    ...[...shapeCounts].map(([topic, subscribers]) => {
+      return { kind: "shape", subscribers, topic };
+    }),
+    ...[...whisperCounts].map(([topic, subscribers]) => {
+      return { kind: "whisper", subscribers, topic };
+    })
+  ];
+  topics.sort((a, b) => b.subscribers - a.subscribers || a.topic.localeCompare(b.topic));
+  const peakSubscribers = topics[0]?.subscribers ?? 0;
+  return { peakSubscribers, topics: topics.slice(0, limit), totalConnections: attachments.length };
+};
 
-export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, MAX_PAGE_SIZE, RELATION_FUNCTION_PREFIX, facetColumn, findStorageReferences, listTables, readTablePage, selectMatchingIds, summarizeSubscriptions };
+export { ADMIN_FUNCTIONS, ADMIN_FUNCTION_PREFIX, DEFAULT_FANOUT_TOPIC_LIMIT, FLAGS_FUNCTION_PREFIX, MAX_PAGE_SIZE, RELATION_FUNCTION_PREFIX, createFanoutCounters, facetColumn, findStorageReferences, listTables, readTablePage, recordFanoutPass, selectMatchingIds, summarizeFanoutTopics, summarizeSubscriptions };

package/dist/packem_shared/{AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs → AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const COUNT_OPTION_KEYS = /* @__PURE__ */ new Set(["baseWhere", "relationBaseWhere", "restrictsCounts", "where"]);
 const matchesStaticWhere = (document, predicate) => {
   for (const [field, expected] of Object.entries(predicate)) {
@@ -38,16 +40,16 @@ const AGGREGATE_SQL_FUNCTION = { avg: "AVG", count: "COUNT", max: "MAX", min: "M
 const aggregateSqlFunction = (op) => {
   const sqlFunction = AGGREGATE_SQL_FUNCTION[op];
   if (sqlFunction === void 0) {
-    throw new Error(`unknown aggregate op "${op}": expected one of ${Object.keys(AGGREGATE_SQL_FUNCTION).join(", ")}`);
+    throw new LunoraError("INTERNAL", `unknown aggregate op "${op}": expected one of ${Object.keys(AGGREGATE_SQL_FUNCTION).join(", ")}`);
   }
   return sqlFunction;
 };
 const throwingScheduler = {
   runAfter: () => {
-    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+    throw new LunoraError("INTERNAL", "ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
   },
   runAt: () => {
-    throw new Error("ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
+    throw new LunoraError("INTERNAL", "ctx.scheduler: no scheduler configured for triggers. Pass `scheduler` to the ctx-db factory.");
   }
 };
 

package/dist/packem_shared/{CDC_LOG_TABLE-Ctdmxmrv.mjs → CDC_LOG_TABLE-uwOJxJJZ.mjs}

@@ -1,6 +1,6 @@
 import { sql } from 'drizzle-orm';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
-import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 
 const CDC_LOG_TABLE = "__cdc_log";
 const migrateCdcLog = (sql$1) => {
@@ -26,9 +26,13 @@ const appendCdcChange = (sql$1, ts, table, id, op, doc) => {
 const readCdcChanges = (sql$1, options = {}) => {
   const sinceSeq = options.sinceSeq ?? 0;
   const limit = Math.max(1, Math.min(options.limit ?? 1e3, 1e4));
+  const tableFilter = options.tables && options.tables.size > 0 ? sql` AND ${sql.identifier("table")} IN (${sql.join(
+    [...options.tables].map((table) => sql`${table}`),
+    sql`, `
+  )})` : sql``;
   const rows = runDrizzle(
     sql$1,
-    sql`SELECT seq, ts, ${sql.identifier("table")}, id, op, doc FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq > ${sinceSeq} ORDER BY seq ASC LIMIT ${limit}`
+    sql`SELECT seq, ts, ${sql.identifier("table")}, id, op, doc FROM ${sql.identifier(CDC_LOG_TABLE)} WHERE seq > ${sinceSeq}${tableFilter} ORDER BY seq ASC LIMIT ${limit}`
   ).toArray();
   const changes = rows.map((row) => {
     const base = { id: row.id, op: row.op, seq: row.seq, table: row.table, ts: row.ts };
@@ -75,7 +79,7 @@ const bumpCdcEpoch = (sql$1) => {
 };
 const applyCdcChange = async (writer, change) => {
   if (change.op === "delete") {
-    await writer.delete(change.id);
+    await writer.delete(change.id, change.table);
     return;
   }
   const document = change.doc ?? {};
@@ -91,7 +95,7 @@ const applyCdcChange = async (writer, change) => {
         fields[key] = value;
       }
     }
-    await writer.replace(change.id, fields);
+    await writer.replace(change.id, fields, void 0, { allowExplicitId: true });
   }
 };
 const applyCdcChanges = async (writer, changes) => {

package/dist/packem_shared/{ConflictError-C0STs6bU.mjs → ConflictError-CLoq37xH.mjs}

@@ -1,11 +1,10 @@
-class ConflictError extends Error {
-  code = "CONFLICT";
+import { LunoraError } from '@lunora/errors';
+
+class ConflictError extends LunoraError {
   /** Why the conflict fired; `occ` is the contention signal the metrics layer counts. */
   kind;
-  status = 409;
   constructor(message = "Optimistic concurrency conflict", kind = "conflict") {
-    super(message);
-    this.name = "ConflictError";
+    super("CONFLICT", message, { name: "ConflictError" });
     this.kind = kind;
   }
 }

package/dist/packem_shared/{CountRlsUnsupportedError-28ZvvwKS.mjs → CountRlsUnsupportedError-BGxj0pgS.mjs}

@@ -1,9 +1,9 @@
-class CountRlsUnsupportedError extends Error {
-  code = "COUNT_RLS_UNSUPPORTED";
-  name = "LunoraError";
-  status = 422;
+import { LunoraError } from '@lunora/errors';
+
+class CountRlsUnsupportedError extends LunoraError {
   constructor(table) {
     super(
+      "COUNT_RLS_UNSUPPORTED",
       table === void 0 ? "count() is not supported in an RLS-restricted context" : `count() is not supported on table "${table}" inside an RLS-restricted context`
     );
   }

package/dist/packem_shared/{DATA_MIGRATION_STATE_TABLE-PTtTiQ7U.mjs → DATA_MIGRATION_STATE_TABLE-CYwBpyTr.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const DATA_MIGRATION_STATE_TABLE = "__lunora_migrations";
 const DEFAULT_BATCH_SIZE = 100;
 const STALE_CLAIM_TIMEOUT_MS = 3e4;
@@ -128,7 +130,7 @@ const runDataMigration = async (options) => {
   const batchSize = options.batchSize ?? migration.batchSize ?? DEFAULT_BATCH_SIZE;
   const transform = direction === "up" ? migration.up : migration.down;
   if (!transform) {
-    throw new Error(`data migration "${migration.id}" has no \`${direction}\` transform`);
+    throw new LunoraError("INTERNAL", `data migration "${migration.id}" has no \`${direction}\` transform`);
   }
   let cursor = null;
   let processed = 0;
@@ -176,7 +178,9 @@ const runDataMigration = async (options) => {
         if (next !== void 0) {
           changed += 1;
           if (!dryRun) {
-            await writer.replace(String(document["_id"]), { ...next, _creationTime: document["_creationTime"], _id: document["_id"] });
+            await writer.replace(String(document["_id"]), { ...next, _creationTime: document["_creationTime"], _id: document["_id"] }, void 0, {
+              allowExplicitId: true
+            });
           }
         }
         if (!dryRun) {
@@ -229,7 +233,11 @@ const runDataMigration = async (options) => {
     throw error;
   }
   if (!dryRun && !isDone) {
-    releaseClaim(sql, migration.id);
+    try {
+      releaseClaim(sql, migration.id);
+    } catch (error) {
+      console.warn(`data migration "${migration.id}": releaseClaim failed`, error);
+    }
   }
   return { changed, cursor: isDone ? null : cursor, direction, dryRun, id: migration.id, processed, status: isDone ? "completed" : "in_progress" };
 };

package/dist/packem_shared/{DEFAULT_MAX_RELATION_KEYS-DyVYReuT.mjs → DEFAULT_MAX_RELATION_KEYS-BEan1CRD.mjs}

@@ -1,4 +1,5 @@
-import { distinctValues } from './applyOnDelete-CMif2RKw.mjs';
+import { LunoraError } from '@lunora/errors';
+import { distinctValues } from './applyOnDelete-BXSq3S70.mjs';
 
 const RELATION_EXISTS_KEY = "__relationExists";
 
@@ -43,7 +44,7 @@ const containsRelationPredicate = (where, schema, tableName) => {
 };
 const assertFlatPredicate = (where, schema, tableName, op) => {
   if (where && containsRelationPredicate(where, schema, tableName)) {
-    throw new Error(`relation-crossing predicates are not supported in ${op}() — use them in findMany/findFirst or an RLS read policy`);
+    throw new LunoraError("INTERNAL", `relation-crossing predicates are not supported in ${op}() — use them in findMany/findFirst or an RLS read policy`);
   }
 };
 const projectChildKeys = async (relation, childWhere, projectField, context, escalatable) => {
@@ -58,7 +59,8 @@ const projectChildKeys = async (relation, childWhere, projectField, context, esc
     if (escalatable) {
       return KEY_OVERFLOW;
     }
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `relation predicate on "${relation.table}" matched ${String(keys.length)} rows, exceeding the ${String(context.maxRelationKeys)}-key limit; narrow the predicate (a same-shard EXISTS push-down lifts this cap)`
     );
   }
@@ -67,7 +69,7 @@ const projectChildKeys = async (relation, childWhere, projectField, context, esc
 const compileOperator = async (operator, relation, childWhere, context, escalatable) => {
   const meta = RELATION_OPERATOR_META[operator];
   if (!meta) {
-    throw new Error(`unknown relation operator "${operator}"`);
+    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
   }
   const { clause, project } = joinColumns(relation);
   const keys = await projectChildKeys(relation, meta.negateChild ? { NOT: childWhere } : childWhere, project, context, escalatable);
@@ -85,7 +87,7 @@ const compileOperator = async (operator, relation, childWhere, context, escalata
 const buildExistsMarker = async (operator, relation, childWhere, parentTable, context) => {
   const meta = RELATION_OPERATOR_META[operator];
   if (!meta) {
-    throw new Error(`unknown relation operator "${operator}"`);
+    throw new LunoraError("INTERNAL", `unknown relation operator "${operator}"`);
   }
   const base = context.relationBaseWhere?.(relation.table);
   const predicatePart = meta.negateChild ? { NOT: childWhere } : childWhere;
@@ -97,7 +99,7 @@ const buildExistsMarker = async (operator, relation, childWhere, parentTable, co
 const assertCardinality = (operator, name, relation) => {
   const meta = RELATION_OPERATOR_META[operator];
   if (meta && meta.kind !== relation.kind) {
-    throw new Error(`relation operator "${operator}" requires a to-${meta.kind} relation, but "${name}" is to-${relation.kind}`);
+    throw new LunoraError("INTERNAL", `relation operator "${operator}" requires a to-${meta.kind} relation, but "${name}" is to-${relation.kind}`);
   }
 };
 const resolveRelationNode = async (name, relation, predicate, parentTable, context) => {
@@ -156,5 +158,54 @@ const resolveRelationPredicates = async (where, options) => {
     schema: options.schema
   });
 };
+const firstShardedHit = (branches, schema, tableName) => {
+  for (const branch of branches) {
+    const hit = findShardedRelationTarget(branch, schema, tableName);
+    if (hit) {
+      return hit;
+    }
+  }
+  return void 0;
+};
+const inspectKey = (key, value, schema, tableName) => {
+  if (key === "AND" || key === "OR") {
+    return firstShardedHit(branchesOf(value), schema, tableName);
+  }
+  if (key === "NOT") {
+    return firstShardedHit([value ?? {}], schema, tableName);
+  }
+  const relation = schema.tables[tableName]?.relationMap?.[key];
+  if (!relation || !isRelationPredicate(value)) {
+    return void 0;
+  }
+  if (schema.tables[relation.table]?.shardMode?.kind === "shardBy") {
+    return { relation: key, target: relation.table };
+  }
+  return firstShardedHit(Object.values(value), schema, relation.table);
+};
+const findShardedRelationTarget = (where, schema, tableName) => {
+  for (const key of Object.keys(where)) {
+    const hit = inspectKey(key, where[key], schema, tableName);
+    if (hit) {
+      return hit;
+    }
+  }
+  return void 0;
+};
+const assertShapeShardable = (effectiveWhere, schema, table) => {
+  if (!effectiveWhere) {
+    return;
+  }
+  const offending = findShardedRelationTarget(effectiveWhere, schema, table);
+  if (!offending) {
+    return;
+  }
+  throw Object.assign(
+    new Error(
+      `shape on "${table}" joins the sharded table "${offending.target}" via relation "${offending.relation}" — a live shape cannot replicate rows that live in another shard's Durable Object. Fix it by (a) denormalizing the joined columns into "${table}", or (b) moving "${offending.target}" to .global() so it is served through the latency-tiered D1 shape tier.`
+    ),
+    { code: "SHAPE_CROSS_SHARD_JOIN", name: "LunoraError", status: 400 }
+  );
+};
 
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates };

package/dist/packem_shared/GEO_DEFAULT_PRECISION-BWnsNmpP.mjs

@@ -0,0 +1,114 @@
+const BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz";
+const GEO_DEFAULT_PRECISION = 9;
+const EARTH_RADIUS_METERS = 63710088e-1;
+const CELL_WIDTH_METERS = [Number.POSITIVE_INFINITY, 5009400, 1252300, 156500, 39100, 4900, 1200, 152.9, 38.2, 4.77, 1.19, 0.149, 0.037];
+const clampPrecision = (precision) => Math.min(Math.max(Math.trunc(precision), 1), 12);
+const encodeGeohash = (point, precision) => {
+  const chars = clampPrecision(precision);
+  let latMin = -90;
+  let latMax = 90;
+  let lngMin = -180;
+  let lngMax = 180;
+  let hash = "";
+  let bit = 0;
+  let index = 0;
+  let even = true;
+  while (hash.length < chars) {
+    if (even) {
+      const mid = (lngMin + lngMax) / 2;
+      if (point.lng >= mid) {
+        index = index * 2 + 1;
+        lngMin = mid;
+      } else {
+        index *= 2;
+        lngMax = mid;
+      }
+    } else {
+      const mid = (latMin + latMax) / 2;
+      if (point.lat >= mid) {
+        index = index * 2 + 1;
+        latMin = mid;
+      } else {
+        index *= 2;
+        latMax = mid;
+      }
+    }
+    even = !even;
+    if (bit < 4) {
+      bit += 1;
+    } else {
+      hash += BASE32[index] ?? "0";
+      bit = 0;
+      index = 0;
+    }
+  }
+  return hash;
+};
+const haversineMeters = (a, b) => {
+  const toRadians = (degrees) => degrees * Math.PI / 180;
+  const dLat = toRadians(b.lat - a.lat);
+  const dLng = toRadians(b.lng - a.lng);
+  const lat1 = toRadians(a.lat);
+  const lat2 = toRadians(b.lat);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.min(1, Math.sqrt(h)));
+};
+const precisionForRadius = (radiusMeters) => {
+  for (let length = CELL_WIDTH_METERS.length - 1; length >= 1; length -= 1) {
+    const width = CELL_WIDTH_METERS[length];
+    if (width !== void 0 && width >= radiusMeters) {
+      return length;
+    }
+  }
+  return 1;
+};
+const NEIGHBOURS = {
+  east: ["bc01fg45238967deuvhjyznpkmstqrwx", "bc01fg45238967deuvhjyznpkmstqrwx"],
+  north: ["p0r21436x8zb9dcf5h7kjnmqesgutwvy", "bc01fg45238967deuvhjyznpkmstqrwx"],
+  south: ["14365h7k9dcfesgujnmqp0r2twvyx8zb", "238967debc01fg45kmstqrwxuvhjyznp"],
+  west: ["238967debc01fg45kmstqrwxuvhjyznp", "238967debc01fg45kmstqrwxuvhjyznp"]
+};
+const BORDERS = {
+  east: ["bcfguvyz", "prxz"],
+  north: ["prxz", "bcfguvyz"],
+  south: ["028b", "0145hjnp"],
+  west: ["0145hjnp", "028b"]
+};
+const adjacent = (hash, direction) => {
+  const lower = hash.toLowerCase();
+  const lastChar = lower.at(-1) ?? "";
+  let base = lower.slice(0, -1);
+  const type = lower.length % 2 === 0 ? 0 : 1;
+  if (BORDERS[direction][type].includes(lastChar) && base !== "") {
+    base = adjacent(base, direction);
+  }
+  return base + (BASE32[NEIGHBOURS[direction][type].indexOf(lastChar)] ?? "");
+};
+const coveringGeohashes = (center, radiusMeters) => {
+  const precision = precisionForRadius(Math.max(radiusMeters, 1));
+  const origin = encodeGeohash(center, precision);
+  const north = adjacent(origin, "north");
+  const south = adjacent(origin, "south");
+  const cells = [
+    origin,
+    north,
+    south,
+    adjacent(origin, "east"),
+    adjacent(origin, "west"),
+    adjacent(north, "east"),
+    adjacent(north, "west"),
+    adjacent(south, "east"),
+    adjacent(south, "west")
+  ];
+  return [...new Set(cells)];
+};
+const pointInBoundingBox = (point, box) => point.lat >= box.sw.lat && point.lat <= box.ne.lat && point.lng >= box.sw.lng && point.lng <= box.ne.lng;
+const boundingBoxCenter = (box) => {
+  return { lat: (box.sw.lat + box.ne.lat) / 2, lng: (box.sw.lng + box.ne.lng) / 2 };
+};
+const boundingBoxGeohashes = (box) => {
+  const center = boundingBoxCenter(box);
+  return coveringGeohashes(center, Math.max(haversineMeters(center, box.ne), 1));
+};
+
+export { GEO_DEFAULT_PRECISION, boundingBoxCenter, boundingBoxGeohashes, coveringGeohashes, encodeGeohash, haversineMeters, pointInBoundingBox };

package/dist/packem_shared/{MAX_SQL_ROWS-dDcFE1YZ.mjs → MAX_SQL_ROWS-iFAA8FbD.mjs}

@@ -1,10 +1,42 @@
+import { LunoraError } from '@lunora/errors';
+
 const MAX_SQL_ROWS = 1e3;
 const READONLY_LEAD = /^(?:explain\s+(?:query\s+plan\s+)?)?(?:select|with)\b/iu;
 const FORBIDDEN_KEYWORD = /\b(?:alter|attach|create|delete|detach|drop|insert|pragma|reindex|replace|truncate|update|vacuum)\b/iu;
-const LEADING_NOISE = /^(?:\s|--[^\n]*\n?|\/\*[\s\S]*?\*\/)+/u;
 const TRAILING_SEMICOLON = /;\s*$/u;
-const stripLeading = (sql) => sql.replace(LEADING_NOISE, "");
-const sqlError = (message, code) => Object.assign(new Error(message), { code, name: "LunoraError", status: 400 });
+const WHITESPACE = /\s/u;
+const skipLineComment = (sql, from) => {
+  let index = from + 2;
+  while (index < sql.length && sql[index] !== "\n") {
+    index += 1;
+  }
+  return index;
+};
+const skipBlockComment = (sql, from) => {
+  const close = sql.indexOf("*/", from + 2);
+  return close === -1 ? -1 : close + 2;
+};
+const stripLeading = (sql) => {
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index];
+    if (char !== void 0 && WHITESPACE.test(char)) {
+      index += 1;
+    } else if (char === "-" && sql[index + 1] === "-") {
+      index = skipLineComment(sql, index);
+    } else if (char === "/" && sql[index + 1] === "*") {
+      const next = skipBlockComment(sql, index);
+      if (next === -1) {
+        break;
+      }
+      index = next;
+    } else {
+      break;
+    }
+  }
+  return sql.slice(index);
+};
+const sqlError = (message, code) => new LunoraError(code, message, { status: 400 });
 const assertReadonly = (query) => {
   const trimmed = stripLeading(query).trim();
   if (trimmed === "") {