@classytic/mongokit 3.39.0 → 3.40.1

package/dist/{Repository-IxI983_m.d.mts → Repository-pnLw1rG5.d.mts}

@@ -1,8 +1,8 @@
-import { _ as UpdateOptions, a as CreateOptions, b as LookupOptions, c as FindOneAndUpdateOptions, d as LookupPopulateResult, g as UpdateManyResult, h as SessionOptions, m as ReadOptions, o as DeleteManyResult, p as OperationOptions, r as CacheableOptions, s as DeleteResult, t as AggregateOptions, u as LookupPopulateOptions, v as WithTransactionOptions, y as LookupBuilder } from "./operations-CrRIoc8Z.mjs";
-import { _ as PopulateSpec, g as ObjectId, i as CountStrategy, r as CollationOptions, t as AggregatePaginationOptions, u as PaginationConfig, v as ReadPreferenceType, x as SortSpec$1, y as SelectSpec } from "./pagination-BpIv2bdS.mjs";
-import { _ as RepositoryOptions, d as PluginType, f as PrioritizedHook, o as Middleware, p as RepositoryContext } from "./repository-ZbLtL7Nk.mjs";
-import { t as PaginationEngine } from "./PaginationEngine-D-P19Y9m.mjs";
-import { AggPaginationRequest, AggRequest, AggResult, ArchiveOptions, ArchiveResult, ArchiveSink, ChangeEvent, FilterInput, KeysetAggPaginationResult, QueryOptions, RepoCapabilities, RepositoryBase, TenantPurgeOptions, TenantPurgeResult, TenantPurgeStrategy, WatchOptions } from "@classytic/repo-core/repository";
+import { S as LookupOptions, _ as SessionOptions, b as WithTransactionOptions, c as DeleteResult, f as LookupPopulateOptions, g as ReadOptions, h as OperationOptions, i as CacheableOptions, l as FindOneAndUpdateOptions, n as AggregateOptions, o as CreateOptions, p as LookupPopulateResult, s as DeleteManyResult, t as AggregateCallOptions, u as GetByIdsOptions, v as UpdateManyResult, x as LookupBuilder, y as UpdateOptions } from "./operations-XiFgG5US.mjs";
+import { A as ObjectId, F as SortSpec$1, M as ReadPreferenceType, N as SelectSpec, c as MongokitPageExtras, i as CountStrategy, j as PopulateSpec, r as CollationOptions, t as AggregatePaginationOptions, u as PaginationConfig } from "./pagination-D6psses0.mjs";
+import { _ as RepositoryOptions, d as PluginType, f as PrioritizedHook, o as Middleware, p as RepositoryContext } from "./repository-DNHfjAZX.mjs";
+import { n as PaginationEngine } from "./PaginationEngine-CRHyuUtw.mjs";
+import { AggPaginationRequest, AggRequest, AggResult, ArchiveOptions, ArchiveResult, ArchiveSink, BulkUpsertOptions, BulkUpsertResult, ChangeEvent, FilterInput, KeysetAggPaginationResult, QueryOptions, RepoCapabilities, RepositoryBase, TenantPurgeOptions, TenantPurgeResult, TenantPurgeStrategy, WatchOptions } from "@classytic/repo-core/repository";
 import { ClientSession, Expression, Model, PipelineStage, PopulateOptions } from "mongoose";
 import { Filter } from "@classytic/repo-core/filter";
 import { RepositoryCacheHandle } from "@classytic/repo-core/cache";
@@ -519,6 +519,37 @@ interface TransitionMachine {
   readonly name: string;
   assertTransition(entityId: string, from: string, to: string): void;
 }
+/** `Repository.getAll` parameters. */
+type GetAllParams = {
+  filters?: Record<string, unknown>;
+  sort?: SortSpec$1 | string;
+  cursor?: string;
+  after?: string;
+  /** Cursor for the PREVIOUS page. Mutually exclusive with `after`/`cursor`. */
+  before?: string;
+  page?: number;
+  pagination?: {
+    page?: number;
+    limit?: number;
+  };
+  limit?: number;
+  search?: string;
+  mode?: 'offset' | 'keyset';
+  hint?: string | Record<string, 1 | -1>;
+  maxTimeMS?: number;
+  countStrategy?: CountStrategy;
+  /** Ceiling for `countStrategy: 'capped'`. */
+  countLimit?: number;
+  readPreference?: ReadPreferenceType;
+  /** Advanced populate options (from QueryParser or Arc's BaseController) */
+  populateOptions?: PopulateOptions[];
+  /** Collation for locale-aware string comparison */
+  collation?: CollationOptions;
+  /** Lookup configurations for $lookup joins (from QueryParser or manual) */
+  lookups?: LookupOptions[];
+  /** Skip pagination entirely — returns raw TDoc[] (same as findAll) */
+  noPagination?: boolean;
+};
 declare class Repository<TDoc = unknown> extends RepositoryBase {
   /**
    * Cache handle ATTACHED BY the unified cache plugin at wiring time —
@@ -591,6 +622,8 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * {@link ID_ADDRESSED_OPERATIONS}.
    */
   private readonly _guardIdAddressed;
+  /** This repository's own `queryDefaults` / `aggregateDefaults` (deployment ones fill the gaps). */
+  private readonly _queryDefaults;
   constructor(Model: Model<TDoc, any, any, any>, plugins?: PluginType[], paginationConfig?: PaginationConfig, options?: RepositoryOptions);
   /**
    * Live read-through view of the hook engine's listener registry.
@@ -741,6 +774,12 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * `_buildContext` inputs), so every op routed through `_runOp` — and the
    * inline-try methods that call this directly — honors them uniformly.
    */
+  /** One command's time bound and concerns: per call, then this repository, then the deployment. */
+  private _opts;
+  /** How an IR request runs: per-call hints, then this repository's and the deployment's defaults. */
+  private _aggRun;
+  /** Scope every join in `pipeline` under its owning collection's policy (see `join-scope.ts`). */
+  private _scopeJoins;
   private _withResilience;
   /**
    * Create single document
@@ -774,16 +813,15 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * const byId = await repo.getByIds(offerIds, ctx);
    * const doc = byId.get(offerId); // O(1); undefined if not found
    *
-   * Sizing: there is no library-imposed cap — the bounds are MongoDB's (the
-   * `$in` array must fit the 16 MB query document; `$in` on an indexed field
-   * is n point-lookups). Keep batches ≤ ~10k ids per call and chunk beyond
-   * that. Don't exclude the id field via `select` — result keys derive from
-   * it.
+   * Chunking: ids are split into `$in` slices of `chunkSize` (default `DEFAULT_ID_CHUNK`), one
+   * command each — sequential inside a session (a transaction runs one operation at a time),
+   * at most `concurrency` (default 4) in flight outside one. `preserveOrder: true` returns an
+   * array aligned with `ids` (`undefined` for a miss). Don't exclude the id field via `select`.
    */
-  getByIds(ids: ReadonlyArray<string | ObjectId>, options?: OperationOptions & {
-    sort?: SortSpec$1 | string;
-    limit?: number;
-  }): Promise<Map<string, TDoc>>;
+  getByIds(ids: ReadonlyArray<string | ObjectId>, options: GetByIdsOptions & {
+    preserveOrder: true;
+  }): Promise<Array<TDoc | undefined>>;
+  getByIds(ids: ReadonlyArray<string | ObjectId>, options?: GetByIdsOptions): Promise<Map<string, TDoc>>;
   /**
    * Get single document by query
    */
@@ -813,6 +851,31 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
     sort?: SortSpec$1 | string;
     limit?: number;
   }): Promise<TDoc[]>;
+  /**
+   * The keyset cursor `getAll({ sort, filters, mode: 'keyset' })` would mint for `row`, under the
+   * same policy scope, so a page resumes AFTER it. For composing keyset walks (repo-core
+   * `mergeKeysetPages` via `keysetSource`), where the last CONSUMED row is not a page's last row.
+   */
+  keysetCursor(row: unknown, options: ReadOptions & {
+    sort: SortSpec$1 | string;
+    filters?: Record<string, unknown>;
+    collation?: CollationOptions;
+  }): Promise<string>;
+  /**
+   * Resumable keyset batches over `_id`: each batch is ONE bounded `find` (no long-lived server
+   * cursor, so no cursor timeout and no CSOT lifetime budget), memory is one batch, and every
+   * batch carries a `checkpoint`. Pass a checkpoint back as `after` to resume: rows written
+   * behind it are not revisited, rows ahead of it are reached. A checkpoint is bound to the
+   * collection, the post-policy filter (tenant included) and is refused elsewhere.
+   */
+  iterate(filter?: Record<string, unknown>, options?: ReadOptions & {
+    after?: string;
+    batchSize?: number;
+    select?: SelectSpec;
+  }): AsyncIterableIterator<{
+    docs: TDoc[];
+    checkpoint: string;
+  }>;
   /**
    * Streaming reads — async iterator over data, suitable for migrations,
    * backfills, schema audits, and any once-a-quarter "touch every row"
@@ -916,36 +979,19 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * // Skip cache for fresh data
    * await repo.getAll({ filters: { status: 'active' } }, { skipCache: true });
    */
-  getAll(params?: {
-    filters?: Record<string, unknown>;
-    sort?: SortSpec$1 | string;
-    cursor?: string;
-    after?: string;
-    /** Cursor for the PREVIOUS page. Mutually exclusive with `after`/`cursor`. */
-    before?: string;
-    page?: number;
-    pagination?: {
-      page?: number;
-      limit?: number;
-    };
-    limit?: number;
-    search?: string;
-    mode?: 'offset' | 'keyset';
-    hint?: string | Record<string, 1 | -1>;
-    maxTimeMS?: number;
-    countStrategy?: CountStrategy;
-    /** Ceiling for `countStrategy: 'capped'`. */
-    countLimit?: number;
-    readPreference?: ReadPreferenceType;
-    /** Advanced populate options (from QueryParser or Arc's BaseController) */
-    populateOptions?: PopulateOptions[];
-    /** Collation for locale-aware string comparison */
-    collation?: CollationOptions;
-    /** Lookup configurations for $lookup joins (from QueryParser or manual) */
-    lookups?: LookupOptions[];
-    /** Skip pagination entirely — returns raw TDoc[] (same as findAll) */
-    noPagination?: boolean;
-  }, options?: CacheableOptions): Promise<OffsetPaginationResult<TDoc> | KeysetPaginationResult<TDoc> | TDoc[]>;
+  /** An explicit `mode` (or `noPagination`) decides the envelope, so the result type follows it. */
+  getAll(params: GetAllParams & {
+    mode: 'offset';
+    noPagination?: false;
+  }, options?: CacheableOptions): Promise<OffsetPaginationResult<TDoc>>;
+  getAll(params: GetAllParams & {
+    mode: 'keyset';
+    noPagination?: false;
+  }, options?: CacheableOptions): Promise<KeysetPaginationResult<TDoc>>;
+  getAll(params: GetAllParams & {
+    noPagination: true;
+  }, options?: CacheableOptions): Promise<TDoc[]>;
+  getAll(params?: GetAllParams, options?: CacheableOptions): Promise<OffsetPaginationResult<TDoc> | KeysetPaginationResult<TDoc> | TDoc[]>;
   /**
    * Atomic "look up by filter, insert `data` if missing, return the doc."
    *
@@ -1268,6 +1314,11 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
   }, patch?: Record<string, unknown>, options?: SessionOptions & {
     idField?: string;
     upsert?: boolean;
+    /**
+     * The document as the caller just read it in this session. Hooks' `loadTarget()`
+     * returns it instead of reading again. Pass only a read taken in the same session.
+     */
+    target?: Record<string, unknown>;
   }): Promise<TDoc | null>;
   /**
    * State-machine-backed CAS transition with status history — the
@@ -1543,6 +1594,13 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
   archiveByFilter(filter: Record<string, unknown> | Filter, sink: ArchiveSink<TDoc>, options?: ArchiveOptions & {
     session?: ClientSession;
   }): Promise<ArchiveResult>;
+  /**
+   * Many keyed upserts in ONE command with an exact per-row outcome (repo-core `bulkUpsert` IR).
+   * Sub-ops pass through the `before:bulkUpsert` policy hooks (tenant, soft-delete) like bulkWrite
+   * sub-ops. Refused unless a unique index is pinned by the key plus the policy scope. Needs
+   * MongoDB 8.0 (client bulkWrite with verbose results).
+   */
+  bulkUpsert(rows: readonly Record<string, unknown>[], options: BulkUpsertOptions): Promise<BulkUpsertResult>;
   /**
    * Kit-native aggregation pipeline — takes a MongoDB stage array and
    * returns the raw pipeline output. Use this for `$lookup`, `$unwind`,
@@ -1582,7 +1640,7 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * Policy hooks (multi-tenant, soft-delete) inject context.filters
    * which are prepended as a `$match` stage.
    */
-  aggregatePipelinePaginate(options?: AggregatePaginationOptions): Promise<AggregatePaginationResult<TDoc>>;
+  aggregatePipelinePaginate(options?: AggregatePaginationOptions): Promise<AggregatePaginationResult<TDoc, MongokitPageExtras>>;
   /**
    * Portable aggregation. Compiles the repo-core `AggRequest` IR to
    * `[{$match}, {$group}, {$addFields}, {$project}, {$match}, {$sort},
@@ -1605,7 +1663,9 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * `context.filter`, which is merged into the pre-aggregate `$match`
    * before compilation.
    */
-  aggregate<TRow extends Record<string, unknown> = Record<string, unknown>>(req: AggRequest, options?: QueryOptions): Promise<AggResult<TRow>>;
+  aggregate<TRow extends Record<string, unknown> = Record<string, unknown>>(req: AggRequest, options?: QueryOptions & AggregateCallOptions): Promise<AggResult<TRow> & {
+    plan?: unknown;
+  }>;
   /**
    * Invalidate every aggregate-cache entry tagged with ANY of the
    * given tags. Delegates to the unified cache plugin's handle
@@ -1801,6 +1861,12 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
    * 4. DEFAULT (500) — user-registered hooks
    */
   _buildContext(operation: string, options: Record<string, unknown> | object): Promise<RepositoryContext>;
+  /**
+   * `memo` and (for an id-addressed op) `loadTarget` — attached before the before-hooks
+   * run so every hook of one operation shares one read. A caller that has just read the
+   * document in the same session passes it as `target`, and nothing is read at all.
+   */
+  private _sharedReadSeams;
   /**
    * Feed the resolved filter of a guarded verb to the distribution guard.
    * The slot follows `OP_REGISTRY[op].policyKey` (`query` vs `filters`);
@@ -1916,4 +1982,4 @@ declare class Repository<TDoc = unknown> extends RepositoryBase {
   private _translateError;
 }
 //#endregion
-export { AggregationPlan as a, SortOrder as c, AggregationBuilder as i, SortSpec as l, Repository as n, GroupSpec as o, TransitionMachine as r, ProjectionSpec as s, HOOK_PRIORITY as t, VectorSearchOptions as u };
+export { AggregationBuilder as a, ProjectionSpec as c, VectorSearchOptions as d, TransitionMachine as i, SortOrder as l, HOOK_PRIORITY as n, AggregationPlan as o, Repository as r, GroupSpec as s, GetAllParams as t, SortSpec as u };

package/dist/actions/index.d.mts

@@ -1,2 +1,2 @@
-import { c as create_d_exports, i as delete_d_exports, n as update_d_exports, r as read_d_exports, u as aggregate_d_exports } from "../index-CmjNyulu.mjs";
+import { c as create_d_exports, i as delete_d_exports, n as update_d_exports, r as read_d_exports, u as aggregate_d_exports } from "../index-SYF8N28D.mjs";
 export { aggregate_d_exports as aggregate, create_d_exports as create, delete_d_exports as deleteActions, read_d_exports as read, update_d_exports as update };

package/dist/actions/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
-import { b as create_exports, i as update_exports, m as aggregate_exports, p as delete_exports, u as read_exports } from "../update-c_01A0if.mjs";
+import { S as create_exports, i as update_exports, m as aggregate_exports, p as delete_exports, u as read_exports } from "../update-WgeAUJ_I.mjs";
 //#region src/actions/index.ts
 var actions_exports = /* @__PURE__ */ __exportAll({
 	aggregate: () => aggregate_exports,

package/dist/adapter/index.mjs

@@ -1,2 +1,2 @@
-import { n as createMongooseAdapter, r as isMongooseModel, t as MongooseAdapter } from "../adapter-BrVfPFSW.mjs";
+import { n as createMongooseAdapter, r as isMongooseModel, t as MongooseAdapter } from "../adapter-CkMoMF83.mjs";
 export { MongooseAdapter, createMongooseAdapter, isMongooseModel };

package/dist/{adapter-BrVfPFSW.mjs → adapter-CkMoMF83.mjs}

@@ -1,5 +1,5 @@
 import { n as warn } from "./logger-K7dPmu2U.mjs";
-import { t as buildCrudSchemasFromModel } from "./mongooseToJsonSchema-waUVQwK4.mjs";
+import { t as buildCrudSchemasFromModel } from "./mongooseToJsonSchema-C3k4ide0.mjs";
 import { matchesRecordFilter } from "@classytic/repo-core/filter";
 import { mergeFieldRuleConstraints } from "@classytic/repo-core/schema";
 import { asRepositoryLike, isRepository } from "@classytic/repo-core/adapter";

package/dist/ai/index.d.mts

@@ -1,4 +1,4 @@
-import { l as Plugin } from "../repository-ZbLtL7Nk.mjs";
+import { l as Plugin } from "../repository-DNHfjAZX.mjs";
 import { PipelineStage } from "mongoose";
 //#region src/ai/types.d.ts
 /** Supported similarity metrics for vector search */

package/dist/better-auth/index.mjs

@@ -1,5 +1,5 @@
-import { n as Repository } from "../Repository-D7fDpyFx.mjs";
-import { n as createMongooseAdapter } from "../adapter-BrVfPFSW.mjs";
+import { n as Repository } from "../Repository-CYhSC9ut.mjs";
+import { n as createMongooseAdapter } from "../adapter-CkMoMF83.mjs";
 import { asReadOnlyRepo } from "@classytic/repo-core/repository";
 import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@classytic/repo-core/better-auth";
 //#region src/better-auth/index.ts

package/dist/{create-repository-CRXjDa3N.d.mts → create-repository-BUx9vfG9.d.mts}

@@ -1,8 +1,8 @@
-import { u as PaginationConfig } from "./pagination-BpIv2bdS.mjs";
-import { _ as RepositoryOptions, d as PluginType } from "./repository-ZbLtL7Nk.mjs";
-import { T as AuditTrailOptions, _ as RepositoryCachePluginOptions, i as CustomIdOptions, t as MultiTenantOptions } from "./multi-tenant.plugin-B-tzNeYL.mjs";
-import { n as Repository } from "./Repository-IxI983_m.mjs";
-import { i as Logger, o as SoftDeleteOptions } from "./plugin-options-BuvtOSZf.mjs";
+import { u as PaginationConfig } from "./pagination-D6psses0.mjs";
+import { _ as RepositoryOptions, d as PluginType } from "./repository-DNHfjAZX.mjs";
+import { D as AuditTrailOptions, i as CustomIdOptions, t as MultiTenantOptions, y as RepositoryCachePluginOptions } from "./multi-tenant.plugin-a3UhQARj.mjs";
+import { r as Repository } from "./Repository-pnLw1rG5.mjs";
+import { i as Logger, o as SoftDeleteOptions } from "./plugin-options-CRhIvSzx.mjs";
 import { Model } from "mongoose";
 //#region src/create-repository.d.ts
 /**

package/dist/{create-repository-DOe9E_5F.mjs → create-repository-BYyWzLbt.mjs}

@@ -1,5 +1,5 @@
-import { n as Repository } from "./Repository-D7fDpyFx.mjs";
-import { a as customIdPlugin, f as auditTrailPlugin, i as multiTenantPlugin, m as auditLogPlugin, n as softDeletePlugin, t as timestampPlugin, u as cachePlugin } from "./timestamp.plugin-B5eiaItQ.mjs";
+import { n as Repository } from "./Repository-CYhSC9ut.mjs";
+import { b as auditLogPlugin, g as cachePlugin, i as multiTenantPlugin, l as customIdPlugin, n as softDeletePlugin, t as timestampPlugin, v as auditTrailPlugin } from "./timestamp.plugin-zfdLYZiO.mjs";
 import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "./method-registry.plugin-C63pGn1d.mjs";
 //#region src/create-repository.ts
 function isLoggerAudit(value) {

package/dist/idempotency/index.d.mts

@@ -0,0 +1,23 @@
+import { Connection, Model } from "mongoose";
+import { IdempotencyClaimStore } from "@classytic/repo-core/idempotency";
+//#region src/idempotency/index.d.ts
+interface IdempotencyModelOptions {
+  /** Collection name. Default `idempotency_claims`. */
+  collection?: string;
+  /** Mongoose model name. Default `IdempotencyClaim`. Must be unique per connection. */
+  modelName?: string;
+}
+interface IdempotencyStoreOptions {
+  /**
+   * How long a claim is kept after its last write before the TTL monitor removes it.
+   * Default 7 days. Size it to the longest a caller may retry — a retry after the claim
+   * is gone executes again. An offline till that syncs days later needs more.
+   */
+  retentionSeconds?: number;
+}
+/** Build (or return) the claims model on `connection`. Idempotent per connection. */
+declare function createIdempotencyModel(connection: Connection, options?: IdempotencyModelOptions): Model<Record<string, unknown>>;
+/** The store over a model from {@link createIdempotencyModel}. */
+declare function createIdempotencyStore(model: Model<Record<string, unknown>>, options?: IdempotencyStoreOptions): IdempotencyClaimStore;
+//#endregion
+export { IdempotencyModelOptions, IdempotencyStoreOptions, createIdempotencyModel, createIdempotencyStore };

package/dist/idempotency/index.mjs

@@ -0,0 +1,134 @@
+import { Schema } from "mongoose";
+import { identityKey } from "@classytic/repo-core/idempotency";
+//#region src/idempotency/index.ts
+/**
+* The mongo {@link IdempotencyClaimStore} — use this with `runIdempotent` from
+* `@classytic/repo-core/idempotency`; never keep a per-module claims table.
+*
+* ```ts
+* const store = createIdempotencyStore(createIdempotencyModel(connection));
+* const run = await runIdempotent({ store, identity, requestFingerprint, execute });
+* ```
+*
+* One document per identity, `_id` = `identityKey(identity)`, so "insert iff absent" is
+* the `_id` index and every compare-and-set is a single-document filter. Proven by
+* `runIdempotencyStoreConformance` (`@classytic/repo-core/testing`) in this package's tests.
+*/
+const DEFAULT_RETENTION_SECONDS = 604800;
+/** Build (or return) the claims model on `connection`. Idempotent per connection. */
+function createIdempotencyModel(connection, options = {}) {
+	const { collection = "idempotency_claims", modelName = "IdempotencyClaim" } = options;
+	const existing = connection.models[modelName];
+	if (existing) return existing;
+	const schema = new Schema({
+		_id: {
+			type: String,
+			required: true
+		},
+		identity: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		requestFingerprint: {
+			type: String,
+			required: true
+		},
+		state: {
+			type: String,
+			enum: [
+				"in_flight",
+				"succeeded",
+				"failed"
+			],
+			required: true
+		},
+		leaseToken: {
+			type: String,
+			required: true
+		},
+		leaseExpiresAt: {
+			type: Date,
+			required: true
+		},
+		createdAt: {
+			type: Date,
+			required: true
+		},
+		completedAt: { type: Date },
+		result: { type: Schema.Types.Mixed },
+		attempts: {
+			type: Number,
+			required: true
+		},
+		progress: { type: Schema.Types.Mixed },
+		context: { type: Schema.Types.Mixed },
+		lastError: { type: String },
+		purgeAt: {
+			type: Date,
+			required: true
+		}
+	}, {
+		collection,
+		versionKey: false,
+		minimize: false
+	});
+	schema.index({ purgeAt: 1 }, {
+		expireAfterSeconds: 0,
+		name: "retention"
+	});
+	schema.index({
+		"identity.operation": 1,
+		state: 1,
+		leaseExpiresAt: 1
+	}, { name: "lapsed_sweep" });
+	return connection.model(modelName, schema);
+}
+/** The store over a model from {@link createIdempotencyModel}. */
+function createIdempotencyStore(model, options = {}) {
+	const retentionMs = (options.retentionSeconds ?? DEFAULT_RETENTION_SECONDS) * 1e3;
+	const claims = () => model.collection;
+	const toDoc = (claim) => ({
+		...claim,
+		_id: identityKey(claim.identity),
+		purgeAt: new Date(Date.now() + retentionMs)
+	});
+	/** The caller's transaction, so a claim commits or rolls back with the writes it describes. */
+	const withSession = (options) => options?.session ? { session: options.session } : {};
+	const ownedInFlight = (identity, leaseToken) => ({
+		_id: identityKey(identity),
+		state: "in_flight",
+		leaseToken
+	});
+	return {
+		async get(identity, options) {
+			const doc = await claims().findOne({ _id: identityKey(identity) }, withSession(options));
+			if (!doc) return null;
+			const { _id, purgeAt, ...claim } = doc;
+			return claim;
+		},
+		async insert(claim, options) {
+			try {
+				await claims().insertOne(toDoc(claim), withSession(options));
+				return true;
+			} catch (error) {
+				if (error.code === 11e3) return false;
+				throw error;
+			}
+		},
+		async swap(identity, expectedLeaseToken, next, options) {
+			return (await claims().replaceOne(ownedInFlight(identity, expectedLeaseToken), toDoc(next), withSession(options))).matchedCount === 1;
+		},
+		async release(identity, expectedLeaseToken, options) {
+			return (await claims().deleteOne(ownedInFlight(identity, expectedLeaseToken), withSession(options))).deletedCount === 1;
+		},
+		async listLapsed(operation, now, limit) {
+			return (await claims().find({
+				"identity.operation": operation,
+				state: "in_flight",
+				leaseExpiresAt: { $lte: now }
+			}).sort({ leaseExpiresAt: 1 }).limit(limit).toArray()).map(({ _id, purgeAt, ...claim }) => claim);
+		}
+	};
+}
+//#endregion
+export { createIdempotencyModel, createIdempotencyStore };