@lunora/do 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/packem_shared/{ADMIN_FUNCTIONS-DSUQ5fX9.mjs → ADMIN_FUNCTIONS-BbQdj8h1.mjs}

@@ -7,6 +7,7 @@ const ADMIN_FUNCTIONS = {
   applyCdc: "__lunora_admin__:applyCdc",
   cdcSync: "__lunora_admin__:cdcSync",
   clearCapturedMail: "__lunora_admin__:clearCapturedMail",
+  clearQueueMessages: "__lunora_admin__:clearQueueMessages",
   clearTable: "__lunora_admin__:clearTable",
   createWorkflowInstance: "__lunora_admin__:createWorkflowInstance",
   deleteRows: "__lunora_admin__:deleteRows",
@@ -25,6 +26,7 @@ const ADMIN_FUNCTIONS = {
   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",
@@ -44,10 +46,13 @@ const ADMIN_FUNCTIONS = {
   recordAuthEvent: "__lunora_admin__:recordAuthEvent",
   recordContainerEvent: "__lunora_admin__:recordContainerEvent",
   recordMail: "__lunora_admin__:recordMail",
+  recordQueueMessage: "__lunora_admin__:recordQueueMessage",
+  replayQueueMessage: "__lunora_admin__:replayQueueMessage",
   rlsPolicies: "__lunora_admin__:rlsPolicies",
   runAs: "__lunora_admin__:runAs",
   runMigration: "__lunora_admin__:runMigration",
   runSql: "__lunora_admin__:runSql",
+  sendQueueMessage: "__lunora_admin__:sendQueueMessage",
   sendTestMail: "__lunora_admin__:sendTestMail",
   storageOrphans: "__lunora_admin__:storageOrphans",
   storageReferences: "__lunora_admin__:storageReferences",

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-DSycmnDf.mjs → CDC_LOG_TABLE-DZSVKRr7.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) => {

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-DfPxn8I0.mjs → DATA_MIGRATION_STATE_TABLE-DB3IYUR3.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;

package/dist/packem_shared/{DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs → DEFAULT_MAX_RELATION_KEYS-CjM9Y1_G.mjs}

@@ -1,4 +1,5 @@
-import { distinctValues } from './applyOnDelete-BQ-8ZlZ1.mjs';
+import { LunoraError } from '@lunora/errors';
+import { distinctValues } from './applyOnDelete-CAwZfp-5.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) => {

package/dist/packem_shared/NotFoundError-C70b9hLw.mjs

@@ -0,0 +1,9 @@
+import { LunoraError } from '@lunora/errors';
+
+class NotFoundError extends LunoraError {
+  constructor(message = "Document not found") {
+    super("NOT_FOUND", message, { name: "NotFoundError" });
+  }
+}
+
+export { NotFoundError as default };

package/dist/packem_shared/{NotUniqueError-Do5h_jiW.mjs → NotUniqueError-D1U5SBFR.mjs}

@@ -1,9 +1,10 @@
+import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
+import { matchesStaticWhere, aggregateSqlFunction, normalizeCountArgument, throwingScheduler } from './AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName, coerceAggregateNumber, readAggregateValue } from './aggregateTableName-CxNqY1Sl.mjs';
-import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-28ZvvwKS.mjs';
-import { appendCdcChange } from './CDC_LOG_TABLE-DSycmnDf.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { mergeWhere, CountRlsUnsupportedError, selectIndexForGroupBy, selectIndexForCount, selectIndexForAggregate } from './CountRlsUnsupportedError-BGxj0pgS.mjs';
+import { appendCdcChange } from './CDC_LOG_TABLE-DZSVKRr7.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, bumpCdcEpoch, minCdcSeq, readCdcChanges, readCdcCursor, readCdcEpoch, trimCdcChanges } from './CDC_LOG_TABLE-DZSVKRr7.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { i as isFtsAvailable, D as DOC_COLUMN$1, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT, d as aggUpsertSql, j as jsonPathSql, q as quoteIdentifier, t as tableColumns, e as qualifiedJsonPathSql } from './do-sql-BCHCWtrD.mjs';
 import { param } from './renderSql-D6eUcn2N.mjs';
@@ -12,18 +13,18 @@ import { stringifySearchText, ftsTableName, tokenizeSearch, buildFtsMatch, score
 import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 import { SCAN_DEP } from './SCAN_DEP-DLJF8dsj.mjs';
 import { decodeCursor, normalizeOrderKeys, buildSeekWhere, applySelect, encodeCursor, softDeleteScope, buildSeekBeforeWhere } from './applySelect-BvZdFUBT.mjs';
-import NotFoundError from './NotFoundError-CMuMZt81.mjs';
-import { assertFlatPredicate, resolveRelationPredicates } from './DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs';
-import { runRowValidators, resolveWith, applyOnDelete, fanOutScalarCounts } from './applyOnDelete-BQ-8ZlZ1.mjs';
-import { guardWriter } from './RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs';
-import { createSystemReader } from './createSystemReader-8CzSZP9V.mjs';
-import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+import NotFoundError from './NotFoundError-C70b9hLw.mjs';
+import { assertFlatPredicate, resolveRelationPredicates } from './DEFAULT_MAX_RELATION_KEYS-CjM9Y1_G.mjs';
+import { runRowValidators, resolveWith, applyOnDelete, fanOutScalarCounts } from './applyOnDelete-CAwZfp-5.mjs';
+import { guardWriter } from './RLS_UNWRAP_SYMBOL-DnjkqVgY.mjs';
+import { createSystemReader } from './createSystemReader-D12eNH13.mjs';
+import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 import { runTriggers } from './hasTrigger-5N6_Fx0A.mjs';
-import { compileWhereSql } from './compileWhereSql-MW_Lk8nJ.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-BZsOqDXP.mjs';
+import { compileWhereSql } from './compileWhereSql-DE6yfRcQ.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './backfillAggregateIndexes-DDoT-UUI.mjs';
 export { C as CLIENT_WATERMARK_TABLE, G as GLOBAL_SHAPE_SNAPSHOT_TABLE, I as IDEMPOTENCY_TABLE, c as advanceClientWatermark, d as deleteGlobalShapeSnapshot, e as deleteGlobalShapeSnapshotsForConnection, m as migrateClientWatermark, b as migrateGlobalShapeSnapshot, r as readClientWatermark, f as readGlobalShapeSnapshot, g as readIdempotent, t as trimIdempotent, w as writeGlobalShapeSnapshot, h as writeIdempotent } from './ctx-db-idempotency-BdcNpvY4.mjs';
-export { runShardMigrations } from './runShardMigrations-nIwoQeOK.mjs';
-export { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-0RaIOy7J.mjs';
+export { runShardMigrations } from './runShardMigrations-DeZr0KZp.mjs';
+export { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 
 const rankIndexFieldsUnchanged = (index, previous, next) => {
   const fields = [...index.partitionBy ?? [], ...index.sortBy.map((key) => key.field), ...index.where ? Object.keys(index.where) : []];
@@ -422,11 +423,11 @@ const computeRankPage = (deps, tableName, indexName, rankPageOptions) => {
   const { assertRankPartitionLocal, ensureRankBackfilled, onRead, schema } = deps;
   const definition = schema.tables[tableName];
   if (!definition) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   const index = definition.rankIndexes?.find((i) => i.name === indexName);
   if (!index) {
-    throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+    throw new LunoraError("INTERNAL", `unknown rankIndex "${indexName}" on table "${tableName}"`);
   }
   assertRankPartitionLocal(tableName, definition, index);
   onRead(tableName, SCAN_DEP);
@@ -474,7 +475,7 @@ const computeRankPage = (deps, tableName, indexName, rankPageOptions) => {
 const CLIENT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 const assertValidClientId = (clientId) => {
   if (!CLIENT_ID_PATTERN.test(clientId)) {
-    throw new Error(`invalid clientId ${JSON.stringify(clientId)}: a client-supplied row id must be a UUID`);
+    throw new LunoraError("INTERNAL", `invalid clientId ${JSON.stringify(clientId)}: a client-supplied row id must be a UUID`);
   }
 };
 const MAX_TRIGGER_DEPTH = 50;
@@ -518,14 +519,17 @@ const createSearchBuilder = (search, tableName) => {
   const builder = {
     eq: (field, value) => {
       if (!search.definition.filterFields?.includes(field)) {
-        throw new Error(`field "${field}" is not a filter field of search index "${search.indexName}" on table "${tableName}"`);
+        throw new LunoraError("INTERNAL", `field "${field}" is not a filter field of search index "${search.indexName}" on table "${tableName}"`);
       }
       search.filters.push({ field, value });
       return builder;
     },
     search: (field, query) => {
       if (field !== search.definition.field) {
-        throw new Error(`search index "${search.indexName}" on table "${tableName}" indexes "${search.definition.field}", not "${field}"`);
+        throw new LunoraError(
+          "INTERNAL",
+          `search index "${search.indexName}" on table "${tableName}" indexes "${search.definition.field}", not "${field}"`
+        );
       }
       const stage = search;
       stage.field = field;
@@ -706,19 +710,16 @@ const paginateStage = (sql$1, tableName, stage, options, scopeCondition) => {
     page
   };
 };
-class NotUniqueError extends Error {
-  code = "NOT_UNIQUE";
-  status = 400;
+class NotUniqueError extends LunoraError {
   constructor(message = "unique() found more than one matching document") {
-    super(message);
-    this.name = "NotUniqueError";
+    super("NOT_UNIQUE", message, { name: "NotUniqueError" });
   }
 }
 const ID_WHITESPACE_PATTERN = /\s/u;
 const NUL_CHARACTER = String.fromCodePoint(0);
 const normalizeIdStructurally = (schema, tableName, id) => {
   if (!schema.tables[tableName]) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   if (typeof id !== "string" || id.length === 0 || ID_WHITESPACE_PATTERN.test(id) || id.includes(NUL_CHARACTER)) {
     return null;
@@ -728,7 +729,7 @@ const normalizeIdStructurally = (schema, tableName, id) => {
 const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
   const tableDefinition = schema.tables[tableName];
   if (!tableDefinition) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   const scopeWhere = softDeleteScope(tableDefinition.softDeleteMode, void 0);
   const scopeCondition = scopeWhere ? compileWhereSql(scopeWhere, doWhereSqlStrategy) : void 0;
@@ -742,7 +743,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
   const runSearchFetch = (limit) => {
     const { search } = stage;
     if (!search) {
-      throw new Error("runSearchFetch called without a staged search");
+      throw new LunoraError("INTERNAL", "runSearchFetch called without a staged search");
     }
     const filtered = stage.inMemoryFilters.length > 0;
     const engineLimit = filtered ? void 0 : limit;
@@ -825,7 +826,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     // eslint-disable-next-line @typescript-eslint/require-await -- TableReaderLike returns Promises (the D1 twin awaits real I/O); the DO impl is synchronous over local SQLite
     async paginate(options) {
       if (stage.search) {
-        throw new Error("pagination is not supported on search queries; use .take(n) or .collect()");
+        throw new LunoraError("INTERNAL", "pagination is not supported on search queries; use .take(n) or .collect()");
       }
       return paginateStage(sql$1, tableName, stage, options, scopeCondition);
     },
@@ -844,7 +845,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     withIndex(indexName, range) {
       const definition = tableDefinition.indexes.find((index) => index.name === indexName);
       if (!definition) {
-        throw new Error(`unknown index "${indexName}" on table "${tableName}"`);
+        throw new LunoraError("INTERNAL", `unknown index "${indexName}" on table "${tableName}"`);
       }
       onIndexUse(tableName, indexName, "index");
       stage.indexName = indexName;
@@ -857,7 +858,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
     withSearchIndex(indexName, search) {
       const definition = (tableDefinition.searchIndexes ?? []).find((index) => index.name === indexName);
       if (!definition) {
-        throw new Error(`unknown search index "${indexName}" on table "${tableName}"`);
+        throw new LunoraError("INTERNAL", `unknown search index "${indexName}" on table "${tableName}"`);
       }
       onIndexUse(tableName, indexName, "search");
       const searchStage = {
@@ -871,7 +872,7 @@ const buildReader = (sql$1, schema, tableName, onIndexUse = () => void 0) => {
       stage.search = searchStage;
       search(createSearchBuilder(searchStage, tableName));
       if (!searchStage.hasQuery) {
-        throw new Error(`search index "${indexName}" on table "${tableName}" requires a .search(field, query) call`);
+        throw new LunoraError("INTERNAL", `search index "${indexName}" on table "${tableName}" requires a .search(field, query) call`);
       }
       return reader;
     }
@@ -913,7 +914,10 @@ const applyOnUpdate = (definition, provided, target, auth) => {
 const assertNoExplicitUndefined = (op, document) => {
   for (const field of Object.keys(document)) {
     if (document[field] === void 0) {
-      throw new Error(`Cannot ${op} field '${field}' to undefined — use null to clear a nullable field, or omit the key to leave it unchanged.`);
+      throw new LunoraError(
+        "INTERNAL",
+        `Cannot ${op} field '${field}' to undefined — use null to clear a nullable field, or omit the key to leave it unchanged.`
+      );
     }
   }
 };
@@ -993,7 +997,10 @@ const createShardCtxDb = (options) => {
   const routeBackend = (table, op) => {
     if (isGlobalTable(table)) {
       if (!globalDb) {
-        throw new Error(`cross-backend ${op} for global table '${table}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`);
+        throw new LunoraError(
+          "INTERNAL",
+          `cross-backend ${op} for global table '${table}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`
+        );
       }
       return globalDb;
     }
@@ -1005,7 +1012,7 @@ const createShardCtxDb = (options) => {
       return void 0;
     }
     if (!globalDb) {
-      throw new Error(`${op} on global table '${tableName}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`);
+      throw new LunoraError("INTERNAL", `${op} on global table '${tableName}' requires a globalDb writer — pass one to createShardCtxDb({ globalDb })`);
     }
     return globalDb;
   };
@@ -1036,7 +1043,7 @@ const createShardCtxDb = (options) => {
     }
     const definition = schema.tables[relationTable];
     if (!definition) {
-      throw new Error(`unknown table: ${relationTable}`);
+      throw new LunoraError("INTERNAL", `unknown table: ${relationTable}`);
     }
     onRead(relationTable, SCAN_DEP);
     const softScope = softDeleteScope(definition.softDeleteMode, void 0);
@@ -1153,7 +1160,7 @@ const createShardCtxDb = (options) => {
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       aggregateSqlFunction(aggOptions.op);
       if (aggOptions.op === "count") {
@@ -1165,7 +1172,7 @@ const createShardCtxDb = (options) => {
         });
       }
       if (!aggOptions.field) {
-        throw new Error(`aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
+        throw new LunoraError("INTERNAL", `aggregate(${tableName}, { op: "${aggOptions.op}" }): "field" is required for non-count reducers`);
       }
       onRead(tableName, SCAN_DEP);
       const aggScope = softDeleteScope(definition.softDeleteMode, void 0);
@@ -1207,7 +1214,7 @@ const createShardCtxDb = (options) => {
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       const countOptions = normalizeCountArgument(whereOrOptions);
       if (countOptions.restrictsCounts) {
@@ -1338,7 +1345,7 @@ const createShardCtxDb = (options) => {
       }
       const findManyDefinition = schema.tables[tableName];
       if (!findManyDefinition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       const isFullScan = !args.where && !args.baseWhere;
       if (isFullScan) {
@@ -1451,13 +1458,13 @@ const createShardCtxDb = (options) => {
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       onRead(tableName, SCAN_DEP);
       const agg = groupOptions.agg ?? { op: "count" };
       aggregateSqlFunction(agg.op);
       if (agg.op !== "count" && !agg.field) {
-        throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
+        throw new LunoraError("INTERNAL", `groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
       }
       const groupScope = softDeleteScope(definition.softDeleteMode, void 0);
       const effective = mergeWhere(mergeWhere(groupOptions.baseWhere, groupOptions.where), groupScope);
@@ -1502,7 +1509,7 @@ const createShardCtxDb = (options) => {
       } else {
         const { field } = agg;
         if (field === void 0) {
-          throw new Error(`groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
+          throw new LunoraError("INTERNAL", `groupBy(${tableName}, { agg: { op: "${agg.op}" } }): "field" is required for non-count reducers`);
         }
         select.push(sql`${sql.raw(aggregateSqlFunction(agg.op))}(${jsonPathSql(field)}) AS value`);
       }
@@ -1535,7 +1542,7 @@ const createShardCtxDb = (options) => {
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       const withDefaults = applyInsertDefaults(definition, document, auth);
       runRowValidators(definition, withDefaults);
@@ -1584,7 +1591,7 @@ const createShardCtxDb = (options) => {
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       ensureBackfilledForTable(tableName);
       ensureRankBackfilledForTable(tableName);
@@ -1624,12 +1631,12 @@ const createShardCtxDb = (options) => {
           await global.patch(id, patch);
           return;
         }
-        throw new Error(`document not found: ${id}`);
+        throw new LunoraError("INTERNAL", `document not found: ${id}`);
       }
       const { docJson: existingJson, row: existing, tableName } = located;
       const tableDefinition = schema.tables[tableName];
       if (!tableDefinition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       onRead(tableName, id);
       assertNoExplicitUndefined("patch", patch);
@@ -1681,11 +1688,11 @@ const createShardCtxDb = (options) => {
       onIndexUse(tableName, indexName, "rank");
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       const index = definition.rankIndexes?.find((i) => i.name === indexName);
       if (!index) {
-        throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+        throw new LunoraError("INTERNAL", `unknown rankIndex "${indexName}" on table "${tableName}"`);
       }
       assertRankPartitionLocal(tableName, definition, index);
       if (rankOptions.restrictsCounts) {
@@ -1726,17 +1733,18 @@ const createShardCtxDb = (options) => {
     // eslint-disable-next-line @typescript-eslint/require-await -- DatabaseWriterLike returns Promises (the D1 twin awaits I/O); the body is synchronous SQLite
     async rankBefore(tableName, indexName, rankBeforeOptions) {
       if (isGlobalTable(tableName)) {
-        throw new Error(
+        throw new LunoraError(
+          "INTERNAL",
           `rankBefore is not supported on the global (.global()) table '${tableName}' — cross-shard rank cursors apply only to sharded tables`
         );
       }
       const definition = schema.tables[tableName];
       if (!definition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       const index = definition.rankIndexes?.find((i) => i.name === indexName);
       if (!index) {
-        throw new Error(`unknown rankIndex "${indexName}" on table "${tableName}"`);
+        throw new LunoraError("INTERNAL", `unknown rankIndex "${indexName}" on table "${tableName}"`);
       }
       if (rankBeforeOptions.restrictsCounts) {
         throw new CountRlsUnsupportedError(tableName);
@@ -1774,11 +1782,11 @@ const createShardCtxDb = (options) => {
           await global.restore(id);
           return;
         }
-        throw new Error(`document not found: ${id}`);
+        throw new LunoraError("INTERNAL", `document not found: ${id}`);
       }
       const field = schema.tables[located.tableName]?.softDeleteMode?.field;
       if (!field) {
-        throw new Error(`ctx.db.restore: table "${located.tableName}" is not a .softDelete() table`);
+        throw new LunoraError("INTERNAL", `ctx.db.restore: table "${located.tableName}" is not a .softDelete() table`);
       }
       const wasDeleted = located.row[field] !== null && located.row[field] !== void 0;
       await writer.patch(id, { [field]: null }, expectedTable);
@@ -1794,12 +1802,12 @@ const createShardCtxDb = (options) => {
           await global.replace(id, document);
           return;
         }
-        throw new Error(`document not found: ${id}`);
+        throw new LunoraError("INTERNAL", `document not found: ${id}`);
       }
       const { docJson: existingJson, row: previous, tableName } = located;
       const tableDefinition = schema.tables[tableName];
       if (!tableDefinition) {
-        throw new Error(`unknown table: ${tableName}`);
+        throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
       }
       assertNoExplicitUndefined("replace", document);
       const creationTime = typeof document["_creationTime"] === "number" ? document["_creationTime"] : clock();

package/dist/packem_shared/{RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs → RLS_UNWRAP_SYMBOL-DnjkqVgY.mjs}

@@ -1,13 +1,14 @@
+import { LunoraError } from '@lunora/errors';
+
 const RLS_UNWRAP_SYMBOL = /* @__PURE__ */ Symbol.for("lunora.ctxdb.rls-unwrap");
-class RlsRequiredError extends Error {
-  code = "RLS_REQUIRED";
-  status = 403;
+class RlsRequiredError extends LunoraError {
   table;
   constructor(table) {
     super(
-      `ctx.db access to "${table}" is denied: the schema is marked .rls("required"), so this table is protected. Apply RLS with .use(rls(policies)) in the procedure, or mark the table .public() to opt it out.`
+      "RLS_REQUIRED",
+      `ctx.db access to "${table}" is denied: the schema is marked .rls("required"), so this table is protected. Apply RLS with .use(rls(policies)) in the procedure, or mark the table .public() to opt it out.`,
+      { name: "RlsRequiredError" }
     );
-    this.name = "RlsRequiredError";
     this.table = table;
   }
 }