@rvoh/dream 2.30.1 → 2.31.0

package/dist/esm/src/dream/QueryDriver/Kysely.js

@@ -7,7 +7,7 @@
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';
-import { PostgresDialect, sql, } from 'kysely';
+import { NoResultError, PostgresDialect, sql, } from 'kysely';
 import pluralize from 'pluralize-esm';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
@@ -30,6 +30,7 @@ import MissingThroughAssociationSource from '../../errors/associations/MissingTh
 import CannotNegateSimilarityClause from '../../errors/CannotNegateSimilarityClause.js';
 import CannotNamespaceAssociationFilterToAnotherTable from '../../errors/CannotNamespaceAssociationFilterToAnotherTable.js';
 import CannotPassUndefinedAsAValueToAWhereClause from '../../errors/CannotPassUndefinedAsAValueToAWhereClause.js';
+import CannotSaveMissingDream from '../../errors/CannotSaveMissingDream.js';
 import ArrayEqualityRequiresArrayColumn from '../../errors/ops/ArrayEqualityRequiresArrayColumn.js';
 import RowLockIncompatibleWithDistinct from '../../errors/RowLockIncompatibleWithDistinct.js';
 import RowLockIncompatibleWithJoinLoad from '../../errors/RowLockIncompatibleWithJoinLoad.js';
@@ -806,6 +807,8 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             }
         }
         catch (error) {
+            if (dream.isPersisted && error instanceof NoResultError)
+                throw new CannotSaveMissingDream(dream);
             switch (pgErrorType(error)) {
                 case COLUMN_OVERFLOW:
                     throw new ColumnOverflow(error instanceof Error ? error : new Error('database column overflow'));

package/dist/esm/src/dream/internal/saveDream.js

@@ -3,6 +3,7 @@ import { clearSortableSaveState } from '../../decorators/field/sortable/helpers/
 import performSortablePositionWork from '../../decorators/field/sortable/helpers/performSortablePositionWork.js';
 import prepareSortableFieldsForSave from '../../decorators/field/sortable/helpers/prepareSortableFieldsForSave.js';
 import { cacheSortableSnapshots } from '../../decorators/field/sortable/helpers/sortableSnapshot.js';
+import CannotSaveMissingDream from '../../errors/CannotSaveMissingDream.js';
 import ValidationError from '../../errors/ValidationError.js';
 import sqlAttributes from '../../helpers/sqlAttributes.js';
 import { DateTime } from '../../utils/datetime/DateTime.js';
@@ -114,6 +115,14 @@ async function writeDream(dream, txn, { alreadyPersisted, sortableFieldConfigs,
         dream.createdAt = now;
     if (!dream.dirtyAttributes().updatedAt && dream.columns().has('updatedAt'))
         dream.updatedAt = now;
+    // The scope-lock read above positively found the row gone, so there is
+    // nothing to update. Raised here rather than after the write because the
+    // write below would not reach the database at all on a position-only save,
+    // whose attributes Sortable has already cleared; a save that does carry data
+    // raises the equivalent diagnostic from the driver, which sees the update
+    // match no row.
+    if (alreadyPersisted && !rowFoundBeforeWrite)
+        throw new CannotSaveMissingDream(dream);
     const hasUnsavedData = !!Object.keys(sqlAttributes(dream)).length;
     // BeforeSave/Update actions may clear all the data that we intended to save, leaving us with
     // an invalid update command. The Sortable decorator is an example of this.

package/dist/esm/src/errors/CannotSaveMissingDream.js

@@ -0,0 +1,24 @@
+/**
+ * Raised when saving a persisted instance whose database row no longer exists —
+ * the row was deleted between the moment the instance was loaded and the moment
+ * the save reached the database.
+ *
+ * This is the write-side counterpart of `RecordNotFound`, and applications catch
+ * it for the same reasons: a request updating a record another request has since
+ * deleted should answer 404 or 409 rather than 500, and a background job holding
+ * a stale instance should usually drop the work rather than fail loudly. Nothing
+ * is written when it is raised.
+ *
+ * It does not mean the save was rejected — a save that fails validation raises
+ * `ValidationError`, and a constraint violation raises its own error. It means
+ * the row that the instance stands for is gone.
+ *
+ * Dream raises it from the query driver, so a custom driver overriding
+ * `saveDream` translates its own adapter's empty-result error the same way, as
+ * the test-app MySQL driver does.
+ */
+export default class CannotSaveMissingDream extends Error {
+    constructor(dream) {
+        super(`Cannot save ${dream.sanitizedConstructorName} with primary key ${String(dream.primaryKeyValue())} because its persisted database row no longer exists.`);
+    }
+}

package/dist/esm/src/errors/SortableBatchRequiresTooManyScopeLocks.js

@@ -1,4 +1,6 @@
 /**
+ * @internal
+ *
  * Raised when a batch of a locked `Query#destroy` or `Query#update` on a
  * sortable model would carry its transaction past the number of advisory
  * sort-scope locks Dream is willing to hold at once.
@@ -27,6 +29,11 @@
  * — a long multi-batch run inside a transaction you opened — either let Dream
  * open a transaction per batch (do not pass a transaction of your own) or
  * commit between runs, which is what releases the locks as it goes.
+ *
+ * Not exported from `@rvoh/dream/errors`. Exceeding the bound is a sizing
+ * mistake in the calling code, not a runtime condition an application can
+ * recover from, so there is nothing for a consumer to catch: the fix is a
+ * smaller batch or a narrower transaction, never a retry.
  */
 export default class SortableBatchRequiresTooManyScopeLocks extends Error {
     dreamClassName;

package/dist/esm/src/errors/associations/MissingRequiredBelongsToAssociation.js

@@ -48,10 +48,15 @@ export default class MissingRequiredBelongsToAssociation extends Error {
 Attempting to access required BelongsTo association \`${this.associationName}\` on an instance of \`${this.dreamClass.sanitizedName}\`,
 but the loaded association is null.
 
-${this.foreignKeyMessage}
-
-If the associated record was deleted, check whether the inverse HasOne/HasMany association should specify dependent: 'destroy'.
+${this.foreignKeyMessage}${this.populatedForeignKeyDiagnosticMessage}
 `;
+    }
+    get populatedForeignKeyDiagnosticMessage() {
+        if (this.foreignKeyValue === null || this.foreignKeyValue === undefined)
+            return '';
+        return `
+
+The associated record may have been deleted (including soft-deleted), or it may not match this association’s target—for example, its STI type may differ from the targeted STI child. If the record was deleted unexpectedly, check whether the inverse HasOne/HasMany association should specify \`dependent: 'destroy'\`.`;
     }
     get foreignKeyMessage() {
         if (this.foreignKeyValue === null || this.foreignKeyValue === undefined) {

package/dist/esm/src/package-exports/errors.js

@@ -1,18 +1,27 @@
 export { pgErrorType } from '../db/errors.js';
 export { default as NonLoadedAssociation } from '../errors/associations/NonLoadedAssociation.js';
+export { default as CannotSaveMissingDream } from '../errors/CannotSaveMissingDream.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from '../errors/CreateOrFindByFailedToCreateAndFind.js';
 export { default as CheckConstraintViolation } from '../errors/db/CheckConstraintViolation.js';
 export { default as ColumnOverflow } from '../errors/db/ColumnOverflow.js';
 export { default as DataIncompatibleWithDatabaseField } from '../errors/db/DataIncompatibleWithDatabaseField.js';
 export { default as DataTypeColumnTypeMismatch } from '../errors/db/DataTypeColumnTypeMismatch.js';
 export { default as NotNullViolation } from '../errors/db/NotNullViolation.js';
+// Raised by the framework packages layered on Dream, not only by Dream: psychic
+// (`src/controller/index.ts`) raises it for a controller's global name, and
+// psychic-workers (`src/background/BaseBackgroundedService.ts`,
+// `src/background/BaseScheduledService.ts`) for service global names. Both reach it
+// through this entry point, so unexporting it breaks the build of every application
+// that installs either package.
 export { default as GlobalNameNotSet } from '../errors/dream-app/GlobalNameNotSet.js';
 export { default as DecryptionError } from '../errors/encrypt/DecryptionError.js';
 export { default as DecryptionParseError } from '../errors/encrypt/DecryptionParseError.js';
 export { default as DecryptionRotationError } from '../errors/encrypt/DecryptionRotationError.js';
 export { default as RecordNotFound } from '../errors/RecordNotFound.js';
+// Caught through this entry point by psychic
+// (`test-app/src/app/controllers/SerializerTestsController.ts`), which distinguishes it
+// to prove a controller can render a missing-serializers failure as a response.
 export { default as MissingSerializersDefinition } from '../errors/serializers/MissingSerializersDefinition.js';
-export { default as SortableBatchRequiresTooManyScopeLocks } from '../errors/SortableBatchRequiresTooManyScopeLocks.js';
 export { default as SortableScopeDidNotStabilize } from '../errors/SortableScopeDidNotStabilize.js';
 export { default as SortableScopeLockWaitTimedOut } from '../errors/SortableScopeLockWaitTimedOut.js';
 export { default as ValidationError } from '../errors/ValidationError.js';

package/dist/types/src/decorators/Decorators.d.ts

@@ -63,18 +63,93 @@ export default class Decorators<TD extends typeof Dream, T extends Dream = Insta
         default?: boolean;
     }): any;
     /**
-     * The Sortable decorator automatically adjusts the value of the columns
-     * corresponding to the decorated field.
-     *
-     * NOTE: the Sortable decorator may not be used in STI child models (it may be used in the STI base class)
+     * Marks an integer column as a sortable position: Dream keeps the positions of
+     * every record in a sort scope contiguous, starting at 1, as records are
+     * created, moved, destroyed and undestroyed.
      *
      * ```ts
-     * class Balloon {
+     * class Post extends ApplicationModel {
      *   @deco.Sortable({ scope: 'user' })
-     *   public position: DreamColumn<Balloon, 'position'>
+     *   public position: number
+     * }
+     *
+     * await post.update({ position: 2 }) // the records at 2 and above shift up
+     * ```
+     *
+     * A position past the end of the scope is clamped to the end, and a position
+     * below 1 — or none at all — lands the record at the end.
+     *
+     * **A save that changes the sort scope ignores a position given alongside it.**
+     * The record lands at the end of the scope it moves into, whatever position the
+     * same `update` supplied:
+     *
+     * ```ts
+     * await post.update({ user: otherUser, position: 1 })
+     * // post is now the last record in otherUser's scope, not the first
+     * ```
+     *
+     * Move it in two saves to place it: `await post.update({ user: otherUser })`,
+     * then `await post.update({ position: 1 })`.
+     *
+     * Sortable requires a query driver that supports advisory transaction locks —
+     * the `PostgresQueryDriver` does — since every position write serializes the
+     * writers of its sort scope on one. This concurrency guarantee first shipped
+     * in Dream 2.28.0 and begins only after every writer is running a lock-aware
+     * release. During the first rolling deployment, older processes take no
+     * advisory locks and can still race the upgraded processes.
+     *
+     * All participating Dream writers of one hot scope serialize. Ordinary saves
+     * and destroys with `skipHooks`, direct query writes, raw SQL, and older
+     * pre-lock Dream processes bypass Sortable maintenance and do not participate
+     * in its locking protocol. Undestroy still performs stabilized Sortable
+     * maintenance and acquires scope locks with `skipHooks: true`; locked query
+     * batches likewise acquire their scope locks during preflight, before any
+     * per-record callbacks, even when those callbacks skip hooks. A waiter that
+     * enters the protocol holds a pooled connection until the holder finishes or
+     * `sortableScopeLockTimeout` expires; sustained contention can therefore
+     * produce latency waves, timeouts, and pool starvation. Keep database work
+     * inside the lock window short, and avoid cross-region database latency for
+     * hot scopes.
+     *
+     * `SortableScopeDidNotStabilize` and `SortableScopeLockWaitTimedOut` are the
+     * expected Dream errors an application may choose to retry. Database deadlocks
+     * remain native adapter errors (for example PostgreSQL code `40P01` or MySQL
+     * errno `1213`) so their driver fields and stacks remain intact. A database
+     * deadlock aborts the whole transaction: retry by starting the transaction
+     * again from the beginning, never by continuing it or retrying only the failed
+     * statement. Recurrent deadlocks call for shorter transactions or a consistent
+     * multi-resource acquisition order; they do not by themselves prove Sortable
+     * caused the cycle.
+     *
+     * ```ts
+     * import {
+     *   SortableScopeDidNotStabilize,
+     *   SortableScopeLockWaitTimedOut,
+     * } from '@rvoh/dream/errors'
+     *
+     * const runTransaction = async () =>
+     *   await ApplicationModel.transaction(async txn => {
+     *     // bind every operation in the attempt to txn
+     *   })
+     *
+     * try {
+     *   await runTransaction()
+     * } catch (error) {
+     *   const adapterDeadlock =
+     *     (error as { code?: string }).code === '40P01' ||
+     *     (error as { errno?: number }).errno === 1213
+     *   const retryable =
+     *     error instanceof SortableScopeDidNotStabilize ||
+     *     error instanceof SortableScopeLockWaitTimedOut ||
+     *     adapterDeadlock
+     *   if (!retryable) throw error
+     *
+     *   await runTransaction() // one whole-transaction retry
      * }
      * ```
      *
+     * NOTE: the Sortable decorator may not be used in STI child models (it may be used in the STI base class)
+     *
      * @param opts - Configuration options for the sortable decorator
      * @param opts.scope - The column, association, or combination thereof which you would like to restrict the incrementing logic to. Can be a single column name, a single belongs-to association name, or an array of column/association names
      * @returns A Sortable decorator

package/dist/types/src/decorators/field/sortable/Sortable.d.ts

@@ -1,35 +1,8 @@
 /**
- * Marks an integer column as a sortable position: Dream keeps the positions of
- * every record in a sort scope contiguous, starting at 1, as records are
- * created, moved, destroyed and undestroyed.
- *
- * ```ts
- * class Post extends ApplicationModel {
- *   @deco.Sortable({ scope: 'user' })
- *   public position: number
- * }
- *
- * await post.update({ position: 2 }) // the records at 2 and above shift up
- * ```
- *
- * A position past the end of the scope is clamped to the end, and a position
- * below 1 — or none at all — lands the record at the end.
- *
- * **A save that changes the sort scope ignores a position given alongside it.**
- * The record lands at the end of the scope it moves into, whatever position the
- * same `update` supplied:
- *
- * ```ts
- * await post.update({ user: otherUser, position: 1 })
- * // post is now the last record in otherUser's scope, not the first
- * ```
- *
- * Move it in two saves to place it: `await post.update({ user: otherUser })`,
- * then `await post.update({ position: 1 })`.
- *
- * Sortable requires a query driver that supports advisory transaction locks —
- * the `PostgresQueryDriver` does — since every position write serializes the
- * writers of its sort scope on one.
+ * The implementation behind `@deco.Sortable`. The decorator's semantics —
+ * position clamping, what a scope-changing save does with a position given
+ * alongside it, and the advisory-lock concurrency protocol — are documented on
+ * `Decorators#Sortable`, which is where a consumer reads them.
  */
 export default function Sortable(opts?: SortableOpts): any;
 interface SortableOpts {

package/dist/types/src/dream/Query.d.ts

@@ -1356,13 +1356,15 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *   {@link Query.delete | delete} (a single statement, no hooks or cascade)
      *   are the right tools for bulk removal.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade.
+     *
      * @param options - Options for destroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.lock - If true, each batch is re-selected with an exclusive row lock inside its own transaction before being destroyed, making the destroy a compare-and-set. Defaults to false
      * @param options.batchSize - The number of records to process per batch. Must be a positive integer. Defaults to 10 when `lock` is true, and to 1000 otherwise
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade destroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
      * @returns The number of records that were removed
      * @throws InvalidBatchSize if `batchSize` is not a positive integer
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
@@ -1433,11 +1435,12 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *   transaction ends, so every batch's scope keys are still held when the
      *   next one preflights. That accumulation is bounded — the preflight counts
      *   the keys the transaction already holds along with the ones the batch
-     *   would add, and refuses with `SortableBatchRequiresTooManyScopeLocks`
-     *   rather than letting a long run over a high-cardinality sort scope exhaust
-     *   `max_locks_per_transaction` for the whole cluster — so a run long enough
-     *   raises instead of completing. Letting Dream open a transaction per batch
-     *   releases the keys as it goes and gives each batch the whole budget.
+     *   would add, and raises rather than letting a long run over a
+     *   high-cardinality sort scope exhaust `max_locks_per_transaction` for the
+     *   whole cluster — so a run long enough raises instead of completing. That
+     *   refusal is a sizing failure to fix, not a condition to catch: letting
+     *   Dream open a transaction per batch releases the keys as it goes and gives
+     *   each batch the whole budget, and a smaller `batchSize` takes fewer.
      * - the preflight covers **the claimed rows' own scopes only**. A
      *   `dependent: 'destroy'` cascade under `destroy({ lock: true })` destroys
      *   child records of other tables, and a sortable child takes its own table's
@@ -1454,8 +1457,18 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     private lockedBatches;
     /**
      * Destroys all records matching the Query,
-     * ignoring the SoftDelete decorator and
-     * permanently removing records from the database.
+     * permanently removing each matched record from
+     * the database instead of soft deleting it.
+     *
+     * The SoftDelete decorator is bypassed when
+     * deleting each matched record, not when
+     * matching: the Query selects under its default
+     * scopes, `dream:SoftDelete` among them, so on a
+     * SoftDelete model it matches only records that
+     * have not already been soft deleted. Reaching
+     * soft deleted records takes
+     * `removeDefaultScope('dream:SoftDelete')` on
+     * the Query.
      *
      * Calls model hooks and applies cascade destroy
      * to associations with `dependent: 'destroy'`,
@@ -1470,17 +1483,26 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * // 12
      * ```
      *
+     * ```ts
+     * await User.removeDefaultScope('dream:SoftDelete')
+     *   .where({ email: ops.ilike('%burpcollaborator%') })
+     *   .reallyDestroy()
+     * // 12
+     * ```
+     *
      * A `limit` or `offset` on the Query is incompatible with `reallyDestroy`,
      * exactly as it is with {@link Query.destroy}: a limit- or offset-carrying
      * Query throws at runtime.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade.
+     *
      * @param options - Options for destroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the destroy operation. Defaults to false
      * @param options.cascade - If false, skips destroying associations marked `dependent: 'destroy'`. Defaults to true
      * @param options.lock - If true, each batch is re-selected with an exclusive row lock inside its own transaction before being destroyed, making the destroy a compare-and-set. See {@link Query.destroy} for the full semantics. Defaults to false
      * @param options.batchSize - The number of records to process per batch. Must be a positive integer. Defaults to 10 when `lock` is true, and to 1000 otherwise
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade destroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade destroying. Defaults to an empty array
      * @returns The number of records that were removed
      * @throws InvalidBatchSize if `batchSize` is not a positive integer
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
@@ -1509,11 +1531,13 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * re-applied to every window — so a limit- or offset-carrying Query throws
      * at runtime.
      *
+     * To bypass a default scope, chain `removeDefaultScope` onto the Query
+     * before calling this method; it is Query state, not an option, and it
+     * carries through to the cascade. The SoftDelete scope is always bypassed.
+     *
      * @param options - Options for undestroying the instance
      * @param options.skipHooks - If true, skips applying model hooks during the undestroy operation. Defaults to false
      * @param options.cascade - If false, skips undestroying associations marked `dependent: 'destroy'`. Defaults to true
-     * @param options.bypassAllDefaultScopes - If true, bypasses user-removable default scopes when cascade undestroying; an STI child's reserved discriminator remains enforced, including when associations are loaded. Defaults to false
-     * @param options.defaultScopesToBypass - An array of default scope names to bypass when cascade undestroying (soft delete is always bypassed). Defaults to an empty array
      * @returns The number of records that were removed
      * @throws BatchingIncompatibleWithLimitOrOffset if the query carries a `limit` or `offset`
      */

package/dist/types/src/errors/CannotSaveMissingDream.d.ts

@@ -0,0 +1,23 @@
+import Dream from '../Dream.js';
+/**
+ * Raised when saving a persisted instance whose database row no longer exists —
+ * the row was deleted between the moment the instance was loaded and the moment
+ * the save reached the database.
+ *
+ * This is the write-side counterpart of `RecordNotFound`, and applications catch
+ * it for the same reasons: a request updating a record another request has since
+ * deleted should answer 404 or 409 rather than 500, and a background job holding
+ * a stale instance should usually drop the work rather than fail loudly. Nothing
+ * is written when it is raised.
+ *
+ * It does not mean the save was rejected — a save that fails validation raises
+ * `ValidationError`, and a constraint violation raises its own error. It means
+ * the row that the instance stands for is gone.
+ *
+ * Dream raises it from the query driver, so a custom driver overriding
+ * `saveDream` translates its own adapter's empty-result error the same way, as
+ * the test-app MySQL driver does.
+ */
+export default class CannotSaveMissingDream extends Error {
+    constructor(dream: Dream);
+}

package/dist/types/src/errors/SortableBatchRequiresTooManyScopeLocks.d.ts

@@ -1,4 +1,6 @@
 /**
+ * @internal
+ *
  * Raised when a batch of a locked `Query#destroy` or `Query#update` on a
  * sortable model would carry its transaction past the number of advisory
  * sort-scope locks Dream is willing to hold at once.
@@ -27,6 +29,11 @@
  * — a long multi-batch run inside a transaction you opened — either let Dream
  * open a transaction per batch (do not pass a transaction of your own) or
  * commit between runs, which is what releases the locks as it goes.
+ *
+ * Not exported from `@rvoh/dream/errors`. Exceeding the bound is a sizing
+ * mistake in the calling code, not a runtime condition an application can
+ * recover from, so there is nothing for a consumer to catch: the fix is a
+ * smaller batch or a narrower transaction, never a retry.
  */
 export default class SortableBatchRequiresTooManyScopeLocks extends Error {
     dreamClassName: string;

package/dist/types/src/errors/associations/MissingRequiredBelongsToAssociation.d.ts

@@ -44,6 +44,7 @@ export default class MissingRequiredBelongsToAssociation extends Error {
         polymorphic: boolean;
     });
     get message(): string;
+    private get populatedForeignKeyDiagnosticMessage();
     private get foreignKeyMessage();
     private formatValue;
 }

package/dist/types/src/package-exports/errors.d.ts

@@ -1,5 +1,6 @@
 export { pgErrorType } from '../db/errors.js';
 export { default as NonLoadedAssociation } from '../errors/associations/NonLoadedAssociation.js';
+export { default as CannotSaveMissingDream } from '../errors/CannotSaveMissingDream.js';
 export { default as CreateOrFindByFailedToCreateAndFind } from '../errors/CreateOrFindByFailedToCreateAndFind.js';
 export { default as CheckConstraintViolation } from '../errors/db/CheckConstraintViolation.js';
 export { default as ColumnOverflow } from '../errors/db/ColumnOverflow.js';
@@ -12,7 +13,6 @@ export { default as DecryptionParseError } from '../errors/encrypt/DecryptionPar
 export { default as DecryptionRotationError } from '../errors/encrypt/DecryptionRotationError.js';
 export { default as RecordNotFound } from '../errors/RecordNotFound.js';
 export { default as MissingSerializersDefinition } from '../errors/serializers/MissingSerializersDefinition.js';
-export { default as SortableBatchRequiresTooManyScopeLocks } from '../errors/SortableBatchRequiresTooManyScopeLocks.js';
 export { default as SortableScopeDidNotStabilize } from '../errors/SortableScopeDidNotStabilize.js';
 export { default as SortableScopeLockWaitTimedOut } from '../errors/SortableScopeLockWaitTimedOut.js';
 export { default as ValidationError } from '../errors/ValidationError.js';

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVkkFPwjAUx7/LOxekY3SsRyEmxoiaGD0QDmV7uIauJW2HWQjf3VQuFdGNU5vm/fv79fUdwBrjHfAlZaOMUEpXBCxuFBZeGu2AH4BSGhYtagQOLw3adm7lHu2tcAgEtlKXwGkyJdBYBRwKJZxDd1Ouh2fVw8rXCsipAjh4Vw5CfHA6IFBUUpUWNfBlko9XRwJJPo7oD61D1Ua3dvB/1V9jQMeUBYWwRg7PxvkPi66/xYVEh0egTrK477MKi+3MaOetkNq/SaNE+KL/0GitsW74V7SPwzSPHYxqav20R7tR5rMP+UegB4+Nsog3F17c68LUO+HlWuG79FU4WwuHdxJV2UOh846rJmKSURKaQihLGKEsTb8HhCXsTPu13eHp9WH3KF0tfFH19L0c7tO+NI08FsYvGqWuGZXzSBfzePwC4ktvDw=="
+window.hierarchyData = "eJyVk11PwyAUhv/LuWZT2o50XLrFxBinJkYvll2w9sySUViAzjTL/rvB3eD8KLuCkPPyPMDhANYY74AvKcsKQildEbC4UVh5abQDfgBKaRi0aBE4PHdo+7mVe7Q3wiEQ2EpdA6dZSaCzCjhUSjiH7qpej8+qx41vFZBTBXDwrh6F+Oi0QKBqpKotauDLbJqvjgSyaR7R73uHqo92HeD/qL/EgOaUBYUwRg5Pxvl3iy7d4pfEgEegTsoyos4arLYzo523Qmr/Ko0S4Yn+Q6O1xrrxX9EEB3Ydn3xmVNfqxz3ajTIfKeRvgRReVkS8ufDiTlem3Qkv1wrfpG/C2lo4vJWo6gSFwT0u6ohJWZJwKYSyIieUMfrVIKzIz7Rf+h2eTh9mD9K1wldNou/v4ZTrY/FXXRi/6JS6pFXOI0PM4/ET1ulvBQ=="

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "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"
+window.navigationData = "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"