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

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { SQL } from 'drizzle-orm';
 import { DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
 /**
@@ -110,17 +111,13 @@ interface GroupByEntry {
   value: AggregateResult;
 }
 /**
-* Thrown when `count` runs in an RLS-restricted ctx. The structural shape
-* (`name: "LunoraError"`, `code`, `status`) lets the runtime's error mapper
-* route it without an `instanceof` check, so `@lunora/do` stays free of a
-* runtime dependency on `@lunora/server`. Status mirrors the
-* `COUNT_RLS_UNSUPPORTED` entry in the `LunoraErrorCode` taxonomy (422):
-* the operation is invalid in this context, not malformed.
+* Thrown when `count` runs in an RLS-restricted ctx. A `LunoraError` subclass
+* (`code: "COUNT_RLS_UNSUPPORTED"`, `status: 422`) recognised structurally by the
+* runtime's error mapper (via `isLunoraError`), so `@lunora/do` needs no runtime
+* dependency on `@lunora/server`. 422 = the operation is invalid in this context,
+* not malformed.
 */
-declare class CountRlsUnsupportedError extends Error {
-  readonly code: string;
-  override readonly name = "LunoraError";
-  readonly status: number;
+declare class CountRlsUnsupportedError extends LunoraError {
   constructor(table?: string);
 }
 /**
@@ -761,37 +758,6 @@ declare class ReactiveCache {
 * everyone. Anonymous/subscription callers pass `null` (their own bucket).
 */
 declare const reactiveCacheKey: (functionPath: string, args: Record<string, unknown>, identity: null | string) => string;
-/**
-* `ctx.db.system` — a best-effort, read-only reader over Lunora's *system*
-* tables.
-*
-* Convex surfaces a handful of read-only system tables (`_scheduled_functions`,
-* `_storage`, ...) through `ctx.db.system`. Lunora mirrors that surface, but with
-* one load-bearing caveat: **the data these tables expose does not live in the
-* shard's SQLite**. Scheduled functions live in the `SchedulerDO`; storage
-* objects live in R2. So unlike `ctx.db.&lt;table>` — which reads the same
-* transactional SQLite snapshot the mutation writes into — `ctx.db.system`
-* reaches across a network/DO boundary on every call.
-*
-* Consequences callers must keep in mind:
-*
-* Asynchronous + eventually consistent: each `collect()` / `get()` issues a fresh
-* read against the backing source. A row a mutation just scheduled may not yet be
-* visible; a job that just fired may still appear pending.
-*
-* NOT part of the transaction snapshot: reading a system table inside a mutation
-* does not pin it; there is no OCC guard and no subscription dependency is
-* recorded. Treat the result as a point-in-time best effort.
-*
-* Read-only: there is no `insert`/`patch`/`delete`. Mutate scheduled jobs via
-* `ctx.scheduler`, storage objects via `ctx.storage`.
-*
-* The reader is intentionally minimal: `query(table).collect()` returns the full
-* list (no indexes, no filtering, no pagination) and `get(table, id)` resolves a
-* single row. That matches Convex's system-table read surface closely enough for
-* the studio / introspection use cases without re-implementing the query
-* planner against a remote source.
-*/
 /** The system tables `ctx.db.system` can read. */
 type SystemTableName = "_scheduled_functions" | "_storage";
 /**
@@ -1893,14 +1859,12 @@ interface DatabaseWriterLike {
   system?: SystemDatabaseReader;
 }
 /**
-* Thrown by `.unique()` when more than one row matches. Like {@link ConflictError}
-* / `NotFoundError`, `code` / `status` are declared as own properties so the
-* cross-package structural error mapper renders it as a 400 without an
-* `instanceof` check against `@lunora/do`.
+* Thrown by `.unique()` when more than one row matches. A `LunoraError` subclass
+* (`code: "NOT_UNIQUE"`, `status: 400`) recognised structurally by the
+* cross-package transport mapper (via `isLunoraError`) without an `instanceof`
+* check against `@lunora/do`.
 */
-declare class NotUniqueError extends Error {
-  readonly code: string;
-  readonly status: number;
+declare class NotUniqueError extends LunoraError {
   constructor(message?: string);
 }
 /**
@@ -3449,13 +3413,11 @@ declare const clearCapturedMail: (sql: SqlExec) => {
 /**
 * Thrown by `findFirstOrThrow` when no document matches the query.
 *
-* Like `ConflictError`, `code` / `status` are declared as own properties
-* so the cross-package structural error mapper maps it to a 404 without an
-* `instanceof` check against `@lunora/do`.
+* A `LunoraError` subclass (`code: "NOT_FOUND"`, `status: 404`) so the
+* cross-package transport mapper maps it to a 404 structurally (via
+* `isLunoraError`) without an `instanceof` check against `@lunora/do`.
 */
-declare class NotFoundError extends Error {
-  readonly code: string;
-  readonly status: number;
+declare class NotFoundError extends LunoraError {
   constructor(message?: string);
 }
 /**
@@ -3691,24 +3653,6 @@ interface LogEventInput {
 * that want the raw values.
 */
 /**
-* Secure-by-default write-path guard for `ctx.db`.
-*
-* When a schema is marked `defineSchema(...).rls("required")`, the generated
-* user-facing ctx wraps its writer with {@link guardWriter}. The guard denies
-* every read/write against a PROTECTED table (any table not marked `.public()`)
-* so a procedure that forgot `.use(rls(policies))` fails CLOSED — it can never
-* silently see or mutate a protected table through the unwrapped writer.
-*
-* The guard is transparent to the RLS middleware: it hangs the UNWRAPPED writer
-* off {@link RLS_UNWRAP_SYMBOL}, so `@lunora/server`'s `rls()` middleware
-* recovers the raw writer (via the same `Symbol.for` key — no cross-package
-* import) to evaluate policies and issue policy-filtered reads without tripping
-* the guard. Only procedures that NEVER engaged RLS keep talking to the guard.
-*
-* Admin / migration / studio writers (built from `createShardCtxDb` WITHOUT
-* `enforceRls`) are never guarded — they are trusted system paths.
-*/
-/**
 * Well-known symbol the guard hangs the unwrapped writer off of. `Symbol.for`
 * (the cross-realm global registry) lets `@lunora/server`'s RLS middleware read
 * it WITHOUT importing this module — both sides reference the same registered
@@ -3717,14 +3661,12 @@ interface LogEventInput {
 declare const RLS_UNWRAP_SYMBOL: symbol;
 /**
 * Thrown when a raw (non-RLS) handler touches a protected table under a
-* `.rls("required")` schema. `code` / `status` / `table` are own properties (not
-* just inherited prototype state) so structural callers across packages — which
-* deliberately avoid a hard `@lunora/do` runtime dependency — recognise the
-* shape without an `instanceof` check (mirrors `ConflictError`).
-*/
-declare class RlsRequiredError extends Error {
-  readonly code: string;
-  readonly status: number;
+* `.rls("required")` schema. A `LunoraError` subclass (`code: "RLS_REQUIRED"`,
+* `status: 403`) recognised structurally across packages (via `isLunoraError`) —
+* which deliberately avoid a hard `@lunora/do` runtime dependency — without an
+* `instanceof` check. `table` is kept as an own property.
+*/
+declare class RlsRequiredError extends LunoraError {
   readonly table: string;
   constructor(table: string);
 }
@@ -6587,18 +6529,14 @@ type ConflictKind = "conflict" | "occ" | "restrict" | "trigger" | "unique";
 * Thrown by mutation handlers when an optimistic-concurrency check fails (or a
 * related write guard trips — see {@link ConflictKind}).
 *
-* The runtime maps this to a 409 response so clients can decide whether to
-* refetch + retry or surface the conflict. `code` / `status` / `kind` are
-* declared as own properties (not just inherited prototype state) so structural
-* callers across packages — which deliberately avoid taking a hard runtime
-* dependency on `@lunora/do` — can recognise the shape without an `instanceof`
-* check.
-*/
-declare class ConflictError extends Error {
-  readonly code: string;
+* A `LunoraError` subclass (`code: "CONFLICT"`, `status: 409`) so the runtime/DO
+* transport mappers recognise it structurally (via `isLunoraError`) — structural
+* callers across packages still avoid a hard `instanceof` dependency on
+* `@lunora/do`. `kind` is kept as an own property for the metrics layer.
+*/
+declare class ConflictError extends LunoraError {
   /** Why the conflict fired; `occ` is the contention signal the metrics layer counts. */
   readonly kind: ConflictKind;
-  readonly status: number;
   constructor(message?: string, kind?: ConflictKind);
 }
 /**

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { SQL } from 'drizzle-orm';
 import { DrizzleSqliteDODatabase } from 'drizzle-orm/durable-sqlite';
 /**
@@ -110,17 +111,13 @@ interface GroupByEntry {
   value: AggregateResult;
 }
 /**
-* Thrown when `count` runs in an RLS-restricted ctx. The structural shape
-* (`name: "LunoraError"`, `code`, `status`) lets the runtime's error mapper
-* route it without an `instanceof` check, so `@lunora/do` stays free of a
-* runtime dependency on `@lunora/server`. Status mirrors the
-* `COUNT_RLS_UNSUPPORTED` entry in the `LunoraErrorCode` taxonomy (422):
-* the operation is invalid in this context, not malformed.
+* Thrown when `count` runs in an RLS-restricted ctx. A `LunoraError` subclass
+* (`code: "COUNT_RLS_UNSUPPORTED"`, `status: 422`) recognised structurally by the
+* runtime's error mapper (via `isLunoraError`), so `@lunora/do` needs no runtime
+* dependency on `@lunora/server`. 422 = the operation is invalid in this context,
+* not malformed.
 */
-declare class CountRlsUnsupportedError extends Error {
-  readonly code: string;
-  override readonly name = "LunoraError";
-  readonly status: number;
+declare class CountRlsUnsupportedError extends LunoraError {
   constructor(table?: string);
 }
 /**
@@ -761,37 +758,6 @@ declare class ReactiveCache {
 * everyone. Anonymous/subscription callers pass `null` (their own bucket).
 */
 declare const reactiveCacheKey: (functionPath: string, args: Record<string, unknown>, identity: null | string) => string;
-/**
-* `ctx.db.system` — a best-effort, read-only reader over Lunora's *system*
-* tables.
-*
-* Convex surfaces a handful of read-only system tables (`_scheduled_functions`,
-* `_storage`, ...) through `ctx.db.system`. Lunora mirrors that surface, but with
-* one load-bearing caveat: **the data these tables expose does not live in the
-* shard's SQLite**. Scheduled functions live in the `SchedulerDO`; storage
-* objects live in R2. So unlike `ctx.db.&lt;table>` — which reads the same
-* transactional SQLite snapshot the mutation writes into — `ctx.db.system`
-* reaches across a network/DO boundary on every call.
-*
-* Consequences callers must keep in mind:
-*
-* Asynchronous + eventually consistent: each `collect()` / `get()` issues a fresh
-* read against the backing source. A row a mutation just scheduled may not yet be
-* visible; a job that just fired may still appear pending.
-*
-* NOT part of the transaction snapshot: reading a system table inside a mutation
-* does not pin it; there is no OCC guard and no subscription dependency is
-* recorded. Treat the result as a point-in-time best effort.
-*
-* Read-only: there is no `insert`/`patch`/`delete`. Mutate scheduled jobs via
-* `ctx.scheduler`, storage objects via `ctx.storage`.
-*
-* The reader is intentionally minimal: `query(table).collect()` returns the full
-* list (no indexes, no filtering, no pagination) and `get(table, id)` resolves a
-* single row. That matches Convex's system-table read surface closely enough for
-* the studio / introspection use cases without re-implementing the query
-* planner against a remote source.
-*/
 /** The system tables `ctx.db.system` can read. */
 type SystemTableName = "_scheduled_functions" | "_storage";
 /**
@@ -1893,14 +1859,12 @@ interface DatabaseWriterLike {
   system?: SystemDatabaseReader;
 }
 /**
-* Thrown by `.unique()` when more than one row matches. Like {@link ConflictError}
-* / `NotFoundError`, `code` / `status` are declared as own properties so the
-* cross-package structural error mapper renders it as a 400 without an
-* `instanceof` check against `@lunora/do`.
+* Thrown by `.unique()` when more than one row matches. A `LunoraError` subclass
+* (`code: "NOT_UNIQUE"`, `status: 400`) recognised structurally by the
+* cross-package transport mapper (via `isLunoraError`) without an `instanceof`
+* check against `@lunora/do`.
 */
-declare class NotUniqueError extends Error {
-  readonly code: string;
-  readonly status: number;
+declare class NotUniqueError extends LunoraError {
   constructor(message?: string);
 }
 /**
@@ -3449,13 +3413,11 @@ declare const clearCapturedMail: (sql: SqlExec) => {
 /**
 * Thrown by `findFirstOrThrow` when no document matches the query.
 *
-* Like `ConflictError`, `code` / `status` are declared as own properties
-* so the cross-package structural error mapper maps it to a 404 without an
-* `instanceof` check against `@lunora/do`.
+* A `LunoraError` subclass (`code: "NOT_FOUND"`, `status: 404`) so the
+* cross-package transport mapper maps it to a 404 structurally (via
+* `isLunoraError`) without an `instanceof` check against `@lunora/do`.
 */
-declare class NotFoundError extends Error {
-  readonly code: string;
-  readonly status: number;
+declare class NotFoundError extends LunoraError {
   constructor(message?: string);
 }
 /**
@@ -3691,24 +3653,6 @@ interface LogEventInput {
 * that want the raw values.
 */
 /**
-* Secure-by-default write-path guard for `ctx.db`.
-*
-* When a schema is marked `defineSchema(...).rls("required")`, the generated
-* user-facing ctx wraps its writer with {@link guardWriter}. The guard denies
-* every read/write against a PROTECTED table (any table not marked `.public()`)
-* so a procedure that forgot `.use(rls(policies))` fails CLOSED — it can never
-* silently see or mutate a protected table through the unwrapped writer.
-*
-* The guard is transparent to the RLS middleware: it hangs the UNWRAPPED writer
-* off {@link RLS_UNWRAP_SYMBOL}, so `@lunora/server`'s `rls()` middleware
-* recovers the raw writer (via the same `Symbol.for` key — no cross-package
-* import) to evaluate policies and issue policy-filtered reads without tripping
-* the guard. Only procedures that NEVER engaged RLS keep talking to the guard.
-*
-* Admin / migration / studio writers (built from `createShardCtxDb` WITHOUT
-* `enforceRls`) are never guarded — they are trusted system paths.
-*/
-/**
 * Well-known symbol the guard hangs the unwrapped writer off of. `Symbol.for`
 * (the cross-realm global registry) lets `@lunora/server`'s RLS middleware read
 * it WITHOUT importing this module — both sides reference the same registered
@@ -3717,14 +3661,12 @@ interface LogEventInput {
 declare const RLS_UNWRAP_SYMBOL: symbol;
 /**
 * Thrown when a raw (non-RLS) handler touches a protected table under a
-* `.rls("required")` schema. `code` / `status` / `table` are own properties (not
-* just inherited prototype state) so structural callers across packages — which
-* deliberately avoid a hard `@lunora/do` runtime dependency — recognise the
-* shape without an `instanceof` check (mirrors `ConflictError`).
-*/
-declare class RlsRequiredError extends Error {
-  readonly code: string;
-  readonly status: number;
+* `.rls("required")` schema. A `LunoraError` subclass (`code: "RLS_REQUIRED"`,
+* `status: 403`) recognised structurally across packages (via `isLunoraError`) —
+* which deliberately avoid a hard `@lunora/do` runtime dependency — without an
+* `instanceof` check. `table` is kept as an own property.
+*/
+declare class RlsRequiredError extends LunoraError {
   readonly table: string;
   constructor(table: string);
 }
@@ -6587,18 +6529,14 @@ type ConflictKind = "conflict" | "occ" | "restrict" | "trigger" | "unique";
 * Thrown by mutation handlers when an optimistic-concurrency check fails (or a
 * related write guard trips — see {@link ConflictKind}).
 *
-* The runtime maps this to a 409 response so clients can decide whether to
-* refetch + retry or surface the conflict. `code` / `status` / `kind` are
-* declared as own properties (not just inherited prototype state) so structural
-* callers across packages — which deliberately avoid taking a hard runtime
-* dependency on `@lunora/do` — can recognise the shape without an `instanceof`
-* check.
-*/
-declare class ConflictError extends Error {
-  readonly code: string;
+* A `LunoraError` subclass (`code: "CONFLICT"`, `status: 409`) so the runtime/DO
+* transport mappers recognise it structurally (via `isLunoraError`) — structural
+* callers across packages still avoid a hard `instanceof` dependency on
+* `@lunora/do`. `kind` is kept as an own property for the metrics layer.
+*/
+declare class ConflictError extends LunoraError {
   /** Why the conflict fired; `occ` is the contention signal the metrics layer counts. */
   readonly kind: ConflictKind;
-  readonly status: number;
   constructor(message?: string, kind?: ConflictKind);
 }
 /**

package/dist/index.mjs

@@ -1,40 +1,40 @@
 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 { 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-Do5h_jiW.mjs';
-export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-DfPxn8I0.mjs';
+export { NotUniqueError, assertValidClientId, createShardCtxDb, normalizeIdStructurally } from './packem_shared/NotUniqueError-D1U5SBFR.mjs';
+export { DATA_MIGRATION_STATE_TABLE, readMigrationStatus, runDataMigration } from './packem_shared/DATA_MIGRATION_STATE_TABLE-DB3IYUR3.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-Cx9HUPJj.mjs';
-export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-Bj6EXy50.mjs';
-export { isSourceDue, liftSourceId, pullExternalSourceTick } from './packem_shared/isSourceDue-9mJRJ9Ld.mjs';
+export { materializeExternalRows, readExternalSourceBaseline, runExternalSourceTick } from './packem_shared/materializeExternalRows-DNcvoLRT.mjs';
+export { isSourceDue, liftSourceId, pullExternalSourceTick } from './packem_shared/isSourceDue-BptUN8CR.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, FLAGS_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, facetColumn, listTables, readTablePage, selectMatchingIds } from './packem_shared/ADMIN_FUNCTIONS-DSUQ5fX9.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 { default as NotFoundError } from './packem_shared/NotFoundError-C70b9hLw.mjs';
 export { armRestore, readBookmark } from './packem_shared/armRestore-BJk53Ro8.mjs';
 export { applySelect, buildSeekWhere, decodeCursor, encodeCursor, normalizeOrderKeys, softDeleteScope } from './packem_shared/applySelect-BvZdFUBT.mjs';
 export { RANK_TIEBREAK, encodePartitionKey, matchesRankStaticWhere, rankTableName, resolveRankPartition, sortColumnName } from './packem_shared/RANK_TIEBREAK-CXhdcA1o.mjs';
 export { ReactiveCache, reactiveCacheKey } from './packem_shared/ReactiveCache-BYlSGY0N.mjs';
 export { serveRelationFanout } from './packem_shared/serveRelationFanout-C5axmGDj.mjs';
-export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-DU-Y4-LJ.mjs';
-export { applyOnDelete, fanOutScalarCounts, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-BQ-8ZlZ1.mjs';
-export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs';
+export { DEFAULT_MAX_RELATION_KEYS, assertFlatPredicate, assertShapeShardable, containsRelationPredicate, isRelationPredicate, resolveRelationPredicates } from './packem_shared/DEFAULT_MAX_RELATION_KEYS-CjM9Y1_G.mjs';
+export { applyOnDelete, fanOutScalarCounts, resolveWith, runRowValidators } from './packem_shared/applyOnDelete-CAwZfp-5.mjs';
+export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter } from './packem_shared/RLS_UNWRAP_SYMBOL-DnjkqVgY.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 } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-BfPNp3Jh.mjs';
+export { ROOT_DO_SIZE_WARN_BYTES, ROOT_SHARD_NAME, ShardDO } from './packem_shared/ROOT_DO_SIZE_WARN_BYTES-BQoX61l-.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 { 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-MW_Lk8nJ.mjs';
-export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-DSycmnDf.mjs';
-export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-BZsOqDXP.mjs';
-export { runShardMigrations } from './packem_shared/runShardMigrations-nIwoQeOK.mjs';
+export { compileWhereSql } from './packem_shared/compileWhereSql-DE6yfRcQ.mjs';
+export { CDC_LOG_TABLE, applyCdcChanges, readCdcChanges, trimCdcChanges } from './packem_shared/CDC_LOG_TABLE-DZSVKRr7.mjs';
+export { backfillAggregateIndexes, backfillRankIndexes } from './packem_shared/backfillAggregateIndexes-DDoT-UUI.mjs';
+export { runShardMigrations } from './packem_shared/runShardMigrations-DeZr0KZp.mjs';
 export { stableStringify } from './packem_shared/stableStringify-MydiuScU.mjs';
 export { s as subscriptionListDeltas } from './packem_shared/subscription-delivery-CK8qga-k.mjs';

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;
   }
 }

package/dist/packem_shared/{ROOT_DO_SIZE_WARN_BYTES-BfPNp3Jh.mjs → ROOT_DO_SIZE_WARN_BYTES-BQoX61l-.mjs}

@@ -1,8 +1,9 @@
+import { LunoraError, toErrorBody } from '@lunora/errors';
 import { drizzle } from 'drizzle-orm/durable-sqlite';
 import { e as encodeWire, a as awaitWsDrain, t as trySendFrame, d as decodeWire, s as subscriptionListDeltas, b as sendDeltaFrames } from './subscription-delivery-CK8qga-k.mjs';
 import { parseExportShardArgs, parseImportShardArgs } from './exportShardRows-DZEhUeyI.mjs';
 import { recordAuthEvent, readAuthMetrics } from './AUTH_METRICS_BUCKETS_TABLE-CiHHYeJi.mjs';
-import { DATA_MIGRATION_STATE_TABLE, readMigrationStatus } from './DATA_MIGRATION_STATE_TABLE-DfPxn8I0.mjs';
+import { DATA_MIGRATION_STATE_TABLE, readMigrationStatus } from './DATA_MIGRATION_STATE_TABLE-DB3IYUR3.mjs';
 import { SCAN_DEP, createDependencyTracker, tableFromDepKey } from './SCAN_DEP-DLJF8dsj.mjs';
 import { readFunctionMetricsTotals, readFunctionMetricIndexHits, recordFunctionMetric, mergeScanAttribution, readFunctionMetrics, readFunctionMetricBuckets } from './FUNCTION_METRICS_BUCKETS_TABLE-UDNVD7FS.mjs';
 import { createFanoutCounters, ADMIN_FUNCTION_PREFIX, RELATION_FUNCTION_PREFIX, selectMatchingIds, ADMIN_FUNCTIONS, findStorageReferences, listTables, summarizeSubscriptions, summarizeFanoutTopics, readTablePage, facetColumn, FLAGS_FUNCTION_PREFIX, recordFanoutPass, MAX_PAGE_SIZE } from './ADMIN_FUNCTIONS-DSUQ5fX9.mjs';
@@ -14,10 +15,10 @@ import { stableStringify } from './stableStringify-MydiuScU.mjs';
 import { redact, standardRules } from '@visulima/redact';
 import { i as isDevEnvironment, c as buildSettings, b as buildSecurityAudit } from './security-audit-CucgBice.mjs';
 import { runReadonlySql } from './MAX_SQL_ROWS-dDcFE1YZ.mjs';
-import { ConflictError } from './ConflictError-C0STs6bU.mjs';
+import { ConflictError } from './ConflictError-CLoq37xH.mjs';
 import { e as deleteGlobalShapeSnapshotsForConnection, g as readIdempotent, h as writeIdempotent, t as trimIdempotent, r as readClientWatermark, m as migrateClientWatermark, c as advanceClientWatermark, d as deleteGlobalShapeSnapshot, f as readGlobalShapeSnapshot, w as writeGlobalShapeSnapshot } from './ctx-db-idempotency-BdcNpvY4.mjs';
-import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-DSycmnDf.mjs';
-import { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-0RaIOy7J.mjs';
+import { CDC_LOG_TABLE, readCdcChanges, readCdcCursor, readCdcEpoch, minCdcSeq, bumpCdcEpoch } from './CDC_LOG_TABLE-DZSVKRr7.mjs';
+import { a as selectShapeMemberIds, s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 
 const MAX_BATCH_ENTRIES = 500;
 
@@ -199,7 +200,7 @@ const shapeRoutingKey = (name, args) => stableStringify({ args: args ?? {}, name
 const DEFAULT_PROMOTION_THRESHOLDS = { tDown: 4e3, tUp: 8e3 };
 const nextPromotionState = (current, subscribers, thresholds = DEFAULT_PROMOTION_THRESHOLDS) => {
   if (thresholds.tDown >= thresholds.tUp) {
-    throw new Error(`invalid promotion thresholds: tDown (${String(thresholds.tDown)}) must be < tUp (${String(thresholds.tUp)})`);
+    throw new LunoraError("INTERNAL", `invalid promotion thresholds: tDown (${String(thresholds.tDown)}) must be < tUp (${String(thresholds.tUp)})`);
   }
   if (current === "owned") {
     return subscribers >= thresholds.tUp ? "promoted" : "owned";
@@ -305,7 +306,7 @@ const envPositiveInt = (env, key, fallback) => {
 };
 const RELAY_MULTICAST_IDENTITY = {};
 const assertNeverFrame = (frame) => {
-  throw new Error(`unhandled relay frame: ${JSON.stringify(frame)}`);
+  throw new LunoraError("INTERNAL", `unhandled relay frame: ${JSON.stringify(frame)}`);
 };
 const asRelayNamespace = (value) => {
   if (value === null || typeof value !== "object") {
@@ -4009,27 +4010,11 @@ class ShardDO {
    */
   // eslint-disable-next-line class-methods-use-this -- cohesive DO instance method (groups with the request handlers); kept non-static so subclasses can override the error mapping
   errorToResponse(error) {
-    if (error instanceof ConflictError) {
-      return jsonResponse({ error: { code: error.code, message: error.message } }, error.status);
-    }
-    if (error && typeof error === "object" && error.name === "ValidationError") {
-      const message = error instanceof Error ? error.message : "validation failed";
-      return jsonResponse({ error: { code: "VALIDATION_ERROR", message } }, 400);
-    }
-    if (error && typeof error === "object" && error.name === "LunoraError") {
-      const lunoraError = error;
-      const status = typeof lunoraError.status === "number" ? lunoraError.status : 500;
-      const body = {
-        code: lunoraError.code ?? "INTERNAL",
-        message: lunoraError.message ?? "internal error"
-      };
-      if (lunoraError.data !== void 0) {
-        body.data = encodeWire(lunoraError.data);
-      }
-      return jsonResponse({ error: body }, status);
+    const { body, redacted, status } = toErrorBody(error, { encodeData: encodeWire, fallbackCode: "RPC_FAILED", redactedMessage: "internal error" });
+    if (redacted) {
+      console.error("[@lunora/do] internal error:", error);
     }
-    console.error("[@lunora/do] unhandled RPC error:", error);
-    return jsonResponse({ error: { code: "RPC_FAILED", message: "internal error" } }, 500);
+    return jsonResponse({ error: body }, status);
   }
   /**
    * Batch dispatch (plan 088). Applies each `calls[]` entry through the SAME
@@ -5007,7 +4992,6 @@ class ShardDO {
    * 4. On normal completion send `{type:"complete"}`; on throw send
    * `{type:"error"}`. Either way drop the controller.
    */
-  // eslint-disable-next-line sonarjs/cognitive-complexity -- the stream lifecycle (ack → chunk pump → complete/error) plus the structured-vs-redacted error branch is the wire protocol and reads clearer inline than split across helpers sharing the controller + socket
   async handleStream(ws, id, functionPath, args) {
     const iterable = this.executeStream(functionPath, args);
     if (!iterable) {
@@ -5047,16 +5031,13 @@ class ShardDO {
         ws.send(JSON.stringify({ id, type: "complete" }));
       }
     } catch (error) {
-      const { code } = error;
-      const isStructured = typeof code === "string";
-      if (!isStructured) {
+      const { body, redacted } = toErrorBody(error, { fallbackCode: "INTERNAL_SERVER_ERROR", redactedMessage: "internal error" });
+      if (redacted) {
         console.error("[@lunora/do] unhandled stream error:", error);
       }
-      const rawMessage = error instanceof Error ? error.message : String(error);
-      const message = isStructured ? rawMessage : "internal error";
       ws.send(
         JSON.stringify({
-          error: { code: isStructured ? code : "INTERNAL_SERVER_ERROR", message },
+          error: { code: body.code, message: body.message },
           id,
           type: "error"
         })
@@ -5338,8 +5319,8 @@ class ShardDO {
       resolved = this.resolveShape(shape.name, shape.args ?? {}, identity);
     } catch (error) {
       this.recordShapeError(`shape:seed:${subId}`, error);
-      const code = typeof error.code === "string" ? error.code : "SHAPE_RESOLVE_FAILED";
-      return { code, message: error instanceof Error ? error.message : "shape resolution failed" };
+      const { body } = toErrorBody(error, { fallbackCode: "SHAPE_RESOLVE_FAILED", redactedMessage: "shape resolution failed" });
+      return { code: body.code, message: body.message };
     }
     if (!resolved) {
       return { code: "SHAPE_NOT_FOUND", message: `shape "${shape.name}" not found or not permitted` };
@@ -5351,8 +5332,8 @@ class ShardDO {
       return await this.seedOpLogShape(ws, subId, shape, resolved);
     } catch (error) {
       this.recordShapeError(`shape:seed:${subId}`, error);
-      const code = typeof error.code === "string" ? error.code : "SHAPE_SEED_FAILED";
-      return { code, message: error instanceof Error ? error.message : "shape seed failed" };
+      const { body } = toErrorBody(error, { fallbackCode: "SHAPE_SEED_FAILED", redactedMessage: "shape seed failed" });
+      return { code: body.code, message: body.message };
     }
   }
   /**

package/dist/packem_shared/{applyOnDelete-BQ-8ZlZ1.mjs → applyOnDelete-CAwZfp-5.mjs}

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { applySelect } from './applySelect-BvZdFUBT.mjs';
 
 const projectChildren = (documents, nested) => nested.select ? applySelect(documents, nested.select, nested.with) : documents;
@@ -27,13 +28,13 @@ const resolveWith = async (options) => {
   }
   const parentDefinition = schema.tables[tableName];
   if (!parentDefinition) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   const relationMap = parentDefinition.relationMap ?? {};
   const requireRelation = (name) => {
     const relation = relationMap[name];
     if (!relation) {
-      throw new Error(`unknown relation "${name}" on table "${tableName}"`);
+      throw new LunoraError("INTERNAL", `unknown relation "${name}" on table "${tableName}"`);
     }
     return relation;
   };
@@ -145,7 +146,7 @@ const applyRelationOnDelete = async (options, holderTable, relation) => {
 const applyOnDelete = async (options) => {
   const { schema, tableName } = options;
   if (!schema.tables[tableName]) {
-    throw new Error(`unknown table: ${tableName}`);
+    throw new LunoraError("INTERNAL", `unknown table: ${tableName}`);
   }
   for (const [holderTable, holderDefinition] of Object.entries(schema.tables)) {
     const relations = holderDefinition.relationMap;

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

@@ -1,5 +1,5 @@
 import { sql } from 'drizzle-orm';
-import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CFk6adSu.mjs';
+import { matchesStaticWhere } from './AGGREGATE_SQL_FUNCTION-CQsu2Xga.mjs';
 import { encodeAggregateKey, foldAggregateTally, aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, r as rowToDocument, A as AGG_KEY, a as AGG_VALUE, b as AGG_COUNT } from './do-sql-BCHCWtrD.mjs';

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

@@ -1,3 +1,4 @@
+import { LunoraError } from '@lunora/errors';
 import { sql } from 'drizzle-orm';
 
 const RELATION_EXISTS_KEY = "__relationExists";
@@ -94,7 +95,7 @@ const STRUCTURAL_KEYS = /* @__PURE__ */ new Set(["AND", "NOT", "OR", RELATION_EX
 const compileStructuralKey = (key, value, strategy) => {
   if (key === RELATION_EXISTS_KEY) {
     if (!strategy.relationExists) {
-      throw new Error("encountered a relation EXISTS marker without a relationExists strategy hook");
+      throw new LunoraError("INTERNAL", "encountered a relation EXISTS marker without a relationExists strategy hook");
     }
     return strategy.relationExists(value);
   }

package/dist/packem_shared/{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-shapes-0RaIOy7J.mjs → ctx-db-shapes-Cz9dHyh1.mjs}

@@ -1,7 +1,7 @@
 import { sql } from 'drizzle-orm';
 import { r as runDrizzle } from './do-exec-5eQy5cEi.mjs';
 import { D as DOC_COLUMN, r as rowToDocument, j as jsonPathSql } from './do-sql-BCHCWtrD.mjs';
-import { compileWhereSql } from './compileWhereSql-MW_Lk8nJ.mjs';
+import { compileWhereSql } from './compileWhereSql-DE6yfRcQ.mjs';
 import { s as serializeSqlValue } from './serialize-sql-BlRUoiQe.mjs';
 
 const shapeWhereStrategy = { fieldRef: jsonPathSql, serialize: serializeSqlValue };

package/dist/packem_shared/{isSourceDue-9mJRJ9Ld.mjs → isSourceDue-BptUN8CR.mjs}

@@ -1,10 +1,11 @@
-import { runExternalSourceTick } from './materializeExternalRows-Bj6EXy50.mjs';
+import { LunoraError } from '@lunora/errors';
+import { runExternalSourceTick } from './materializeExternalRows-DNcvoLRT.mjs';
 
 const liftSourceId = (row, options = {}) => {
   const { idColumn = "id", map } = options;
   const idValue = row[idColumn];
   if (idValue === void 0 || idValue === null) {
-    throw new Error(`external-source: row is missing id column "${idColumn}"`);
+    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`);

package/dist/packem_shared/{materializeExternalRows-Bj6EXy50.mjs → materializeExternalRows-DNcvoLRT.mjs}

@@ -1,5 +1,5 @@
-import { applyCdcChanges } from './CDC_LOG_TABLE-DSycmnDf.mjs';
-import { s as selectShapeRows } from './ctx-db-shapes-0RaIOy7J.mjs';
+import { applyCdcChanges } from './CDC_LOG_TABLE-DZSVKRr7.mjs';
+import { s as selectShapeRows } from './ctx-db-shapes-Cz9dHyh1.mjs';
 import { diffExternalSource, projectExternalSourceRow } from './diffExternalSource-Cx9HUPJj.mjs';
 import { stableStringify } from './stableStringify-MydiuScU.mjs';
 

package/dist/packem_shared/{runShardMigrations-nIwoQeOK.mjs → runShardMigrations-DeZr0KZp.mjs}

@@ -1,6 +1,6 @@
 import { sql } from 'drizzle-orm';
 import { aggregateTableName } from './aggregateTableName-CxNqY1Sl.mjs';
-import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-DSycmnDf.mjs';
+import { migrateCdcLog, migrateCdcMeta } from './CDC_LOG_TABLE-DZSVKRr7.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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/do",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.22",
   "description": "Lunora Durable Objects: ShardDO (SQLite, OCC, hibernated WebSocket subscriptions) and SessionDO",
   "keywords": [
     "cloudflare",
@@ -46,6 +46,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@lunora/errors": "1.0.0-alpha.1",
     "@visulima/redact": "3.0.0-alpha.14",
     "drizzle-orm": "^0.45.2"
   },

package/dist/packem_shared/NotFoundError-CMuMZt81.mjs

@@ -1,10 +0,0 @@
-class NotFoundError extends Error {
-  code = "NOT_FOUND";
-  status = 404;
-  constructor(message = "Document not found") {
-    super(message);
-    this.name = "NotFoundError";
-  }
-}
-
-export { NotFoundError as default };