@classytic/mongokit 3.44.0 → 3.46.0

package/dist/sync/index.mjs

@@ -1,4 +1,4 @@
-import { o as withTransaction } from "../transaction-C2PFxfIv.mjs";
+import { o as withTransaction } from "../transaction-C6Oj941P.mjs";
 import { Schema, Types } from "mongoose";
 import { CursorExpiredError } from "@classytic/repo-core/sync";
 // src/sync/index.ts
@@ -394,6 +394,45 @@ function createChangeLogStore(models, storeOptions = {}) {
 		scope: id.scope,
 		docId: id.docId
 	});
+	/**
+	* The entry a reader of one document ends on, which retention keeps. A tombstone applies
+	* unconditionally (`changeLogPlugin` writes version 0); an upsert only above the version held. So:
+	* the last tombstone, unless upserts follow it, then the highest of those (the first on a tie).
+	* Not simply the last cursor: branch stock records a lower version after a higher one.
+	*/
+	const winnerOf = (rows) => {
+		let held = null;
+		for (const row of [...rows].sort((a, b) => a.seq - b.seq)) if (row.op === "delete") held = {
+			seq: row.seq,
+			version: Number.NEGATIVE_INFINITY
+		};
+		else if (!held || row.version > held.version) held = {
+			seq: row.seq,
+			version: row.version
+		};
+		return held?.seq ?? 0;
+	};
+	const winnerSeq = async (filter) => {
+		const tomb = await entries.findOne({
+			...filter,
+			op: "delete"
+		}).sort({ seq: -1 }).select({ seq: 1 }).lean().exec();
+		const bound = filter.seq ?? {};
+		return (await entries.findOne(tomb?.seq === void 0 ? {
+			...filter,
+			op: "upsert"
+		} : {
+			...filter,
+			op: "upsert",
+			seq: {
+				...bound,
+				$gt: tomb.seq
+			}
+		}).sort({
+			version: -1,
+			seq: 1
+		}).select({ seq: 1 }).lean().exec())?.seq ?? tomb?.seq ?? 0;
+	};
 	const toEntry = (row) => ({
 		scope: row.scope,
 		docId: row.docId,
@@ -506,11 +545,11 @@ function createChangeLogStore(models, storeOptions = {}) {
 			const groups = entries.aggregate([
 				{ $group: {
 					_id: docKey,
-					latest: { $max: "$seq" },
+					top: { $max: "$seq" },
 					n: { $sum: 1 }
 				} },
 				{ $match: { n: { $gt: 1 } } },
-				{ $project: { latest: 1 } }
+				{ $project: { top: 1 } }
 			]).allowDiskUse(true).cursor({ batchSize });
 			let removed = 0;
 			let ops = [];
@@ -520,9 +559,17 @@ function createChangeLogStore(models, storeOptions = {}) {
 				ops = [];
 			};
 			for await (const g of groups) {
+				const doc = docOf(g._id);
+				const keep = await winnerSeq({
+					...doc,
+					seq: { $lte: g.top }
+				});
 				ops.push({ deleteMany: { filter: {
-					...docOf(g._id),
-					seq: { $lt: g.latest }
+					...doc,
+					seq: {
+						$lte: g.top,
+						$ne: keep
+					}
 				} } });
 				if (ops.length >= batchSize) await flush();
 			}
@@ -533,6 +580,66 @@ function createChangeLogStore(models, storeOptions = {}) {
 			const seq = await horizonFor(options);
 			return seq > 0 ? toCursor(seq) : "";
 		},
+		async snapshot(cursor, options = {}) {
+			const { upTo: bound, ...view } = options;
+			const limit = view.limit ?? DEFAULT_LIMIT;
+			const upTo = bound === void 0 ? await horizonFor(view) : fromCursor(bound);
+			const after = fromCursor(cursor);
+			const upToCursor = upTo > 0 ? toCursor(upTo) : "";
+			if (after >= upTo) return {
+				changes: [],
+				cursor,
+				hasMore: false,
+				upTo: upToCursor
+			};
+			const rows = await entries.find({
+				seq: {
+					$gt: after,
+					$lte: upTo
+				},
+				...viewOf(view)
+			}).sort({ seq: 1 }).limit(limit + 1).lean().exec();
+			const page = rows.slice(0, limit);
+			const latest = /* @__PURE__ */ new Map();
+			if (page.length > 0) {
+				const keyOf = (r) => JSON.stringify([
+					typeof r.tenantId === "string" ? r.tenantId : null,
+					r.scope,
+					r.docId
+				]);
+				const docs = new Map(page.map((r) => [keyOf(r), r]));
+				const groups = await entries.aggregate([{ $match: {
+					seq: { $lte: upTo },
+					$or: [...docs.values()].map((r) => docOf({
+						tenantId: typeof r.tenantId === "string" ? r.tenantId : null,
+						scope: r.scope,
+						docId: r.docId
+					}))
+				} }, { $group: {
+					_id: docKey,
+					rows: { $push: {
+						seq: "$seq",
+						version: "$version",
+						op: "$op"
+					} }
+				} }]).allowDiskUse(true).exec();
+				for (const g of groups) latest.set(keyOf(g._id), winnerOf(g.rows));
+				const changes = page.filter((r) => latest.get(keyOf(r)) === r.seq && r.op === "upsert").map(toEntry);
+				const last = page[page.length - 1];
+				return {
+					changes,
+					cursor: toCursor(last.seq),
+					hasMore: rows.length > limit,
+					upTo: upToCursor
+				};
+			}
+			return {
+				changes: [],
+				cursor,
+				hasMore: false,
+				upTo: upToCursor
+			};
+		},
 		async prune(before, options = {}) {
 			if (!(before instanceof Date) || Number.isNaN(before.getTime())) throw new Error("[mongokit:sync] prune(before) needs a valid Date");
 			const batchSize = options.batchSize ?? 1e3;
@@ -569,20 +676,23 @@ function createChangeLogStore(models, storeOptions = {}) {
 			};
 			for await (const g of groups) {
 				const doc = docOf(g._id);
-				const latest = await topSeq(doc);
-				let deletedMax;
-				if (latest > g.oldMax) deletedMax = g.oldMax;
-				else if (g.n > 1) deletedMax = await topSeq({
+				const keep = await winnerSeq(doc);
+				const deletedMax = await topSeq({
 					...doc,
 					at: old,
-					seq: { $lt: latest }
+					seq: {
+						$lte: g.oldMax,
+						$ne: keep
+					}
 				});
-				else continue;
 				if (deletedMax <= 0) continue;
 				ops.push({ deleteMany: { filter: {
 					...doc,
 					at: old,
-					seq: { $lte: deletedMax }
+					seq: {
+						$lte: deletedMax,
+						$ne: keep
+					}
 				} } });
 				batchMax = Math.max(batchMax, deletedMax);
 				const key = JSON.stringify([doc.tenantId, doc.scope]);

package/dist/testkit/index.d.mts

@@ -1,5 +1,5 @@
-import { n as CreateRepositoryConfig } from "../create-repository-BOFUYj1l.mjs";
-import { r as Repository } from "../Repository-B6oL6OMv.mjs";
+import { n as CreateRepositoryConfig } from "../create-repository-DG-gwOf0.mjs";
+import { r as Repository } from "../Repository-DJuRmBNx.mjs";
 import { Connection, Model, Schema } from "mongoose";
 import { MongoMemoryReplSet, MongoMemoryServer } from "mongodb-memory-server";
 /**

package/dist/testkit/index.mjs

@@ -1,4 +1,4 @@
-import { t as createRepository } from "../create-repository-D7MQpIZo.mjs";
+import { t as createRepository } from "../create-repository-C9DHHcl7.mjs";
 import { createConnection } from "mongoose";
 import { rmSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, readdir, rm, stat } from "node:fs/promises";

package/dist/{timestamp.plugin-Bz_zL9PX.mjs → timestamp.plugin-B-IJrlYb.mjs}

@@ -1,4 +1,4 @@
-import { a as ALL_OPERATIONS, s as OP_REGISTRY, t as HOOK_PRIORITY } from "./Repository-eMRYZ_2Y.mjs";
+import { a as ALL_OPERATIONS, s as OP_REGISTRY, t as HOOK_PRIORITY } from "./Repository-DheA7oW-.mjs";
 import { n as warn } from "./logger-hbWOlj_X.mjs";
 import { n as declareCollectionScope } from "./join-scope-C1gOtZ59.mjs";
 import { throwIfAborted, withRetry } from "@classytic/repo-core/repository";

package/dist/{to-plain-PO5r1Qoy.d.mts → to-plain-Do-8jTKC.d.mts}

@@ -1,5 +1,5 @@
-import { y as UserContext } from "./repository-DzVIwhU2.mjs";
-import { r as FieldPreset } from "./plugin-options-Bpcuz9kS.mjs";
+import { y as UserContext } from "./repository-B0aFVgP2.mjs";
+import { r as FieldPreset } from "./plugin-options-DrNGWV5b.mjs";
 import mongoose, { Schema } from "mongoose";
 import { CacheAdapter } from "@classytic/repo-core/cache";
 import { HttpError } from "@classytic/repo-core/errors";

package/dist/{transaction-C2PFxfIv.mjs → transaction-C6Oj941P.mjs}

@@ -1,4 +1,4 @@
-import { d as setTransactionDeadline } from "./query-defaults-aUoKlEbh.mjs";
+import { u as setTransactionDeadline } from "./query-defaults-DwvWUjZU.mjs";
 import { t as createError } from "./error-DjdmPLWO.mjs";
 import mongoose from "mongoose";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -494,18 +494,17 @@ function timeoutError(cause, csot) {
 }
 /**
 * The driver's convenient-transaction algorithm (start → callback → commit, label-based retry,
-* jittered backoff, a deadline), run here so the driver never attaches a session `timeoutContext`:
-* with one, every legacy bulk write (`insertMany`, `bulkWrite`) in the transaction is refused once
-* the client carries `timeoutMS` (driver <= 7.7: the bulk path re-resolves the inherited client
-* `timeoutMS` as a per-op one). Each operation keeps its own per-op CSOT budget instead.
-* Deadline: `transactionOptions.timeoutMS`, else the client's `timeoutMS`, else 120 s (as the driver).
-* Pinned by `tests/integration/csot-transaction-matrix.test.ts`.
+* jittered backoff, a deadline), run here and nowhere else: the driver's own `timeoutMS` / CSOT is a
+* no-op since 7.8, so the budget is mongokit's. `transactionOptions.timeoutMS` is that budget, enforced
+* by mongokit alone: every mongokit operation in the transaction is sent with `maxTimeMS` = what
+* remains of it, the commit is bounded by `maxCommitTimeMS`, and the retry loop stops at the deadline
+* (a spent budget before the commit aborts, so the outcome is known). Without it the deadline is 120 s
+* (as the driver) and operations carry only their own bound. The client's `timeoutMS` is not read.
+* Pinned by `tests/integration/transaction-budget-matrix.test.ts`.
 */
 async function runTransaction(session, callback, transactionOptions = {}) {
 	assertSessionSurface(session, DRIVEN);
-	const { timeoutMS: explicitTimeout, ...startOptions } = transactionOptions;
-	const clientTimeout = session.timeoutMS;
-	const timeoutMS = explicitTimeout ?? clientTimeout;
+	const { timeoutMS, ...startOptions } = transactionOptions;
 	const csot = timeoutMS != null;
 	const deadline = performance.now() + (timeoutMS ?? MAX_TRANSACTION_TIMEOUT_MS);
 	let lastError;
@@ -517,7 +516,10 @@ async function runTransaction(session, callback, transactionOptions = {}) {
 				if (performance.now() + backoff >= deadline) throw timeoutError(lastError, csot);
 				await setTimeout$1(backoff);
 			}
-			session.startTransaction(startOptions);
+			session.startTransaction(csot && startOptions.maxCommitTimeMS === void 0 ? {
+				...startOptions,
+				maxCommitTimeMS: Math.max(1, Math.floor(deadline - performance.now()))
+			} : startOptions);
 			let result;
 			try {
 				result = await callback(session);
@@ -539,7 +541,7 @@ async function runTransaction(session, callback, transactionOptions = {}) {
 					throw late;
 				}
 				try {
-					await session.commitTransaction(csot ? { timeoutMS: Math.max(1, Math.floor(left)) } : void 0);
+					await session.commitTransaction();
 					return result;
 				} catch (err) {
 					lastError = err;

package/dist/{update-DcfmNbJe.mjs → update-CYaJMu6j.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
 import { t as createError } from "./error-DjdmPLWO.mjs";
 import { n as warn } from "./logger-hbWOlj_X.mjs";
-import { i as applyToQuery } from "./query-defaults-aUoKlEbh.mjs";
+import { r as applyToQuery } from "./query-defaults-DwvWUjZU.mjs";
 import { coerceFilterDates, isFilter } from "@classytic/repo-core/filter";
 // src/actions/create.ts
 var create_exports = /* @__PURE__ */ __exportAll({
@@ -17,8 +17,6 @@ var create_exports = /* @__PURE__ */ __exportAll({
 async function create(Model, data, options = {}) {
 	const document = new Model(data);
 	const saveOptions = { session: options.session };
-	const bound = options.queryOptions?.maxTimeMS;
-	if (bound !== void 0) Object.assign(saveOptions, { timeoutMS: bound });
 	const wc = options.queryOptions?.writeConcern;
 	if (wc) Object.assign(saveOptions, { writeConcern: {
 		...wc.w !== void 0 ? { w: wc.w } : {},
@@ -71,7 +69,7 @@ async function createMany(Model, dataArray, options = {}) {
 		const wc = options.queryOptions?.writeConcern;
 		if (wc) Object.assign(insertOptions, { writeConcern: wc });
 		const bound = options.queryOptions?.maxTimeMS;
-		if (bound !== void 0) Object.assign(insertOptions, { timeoutMS: bound });
+		if (bound !== void 0) Object.assign(insertOptions, { maxTimeMS: bound });
 		return await Model.insertMany(dataArray, insertOptions);
 	} catch (err) {
 		const inserted = err.insertedDocs;

package/dist/utils/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-PO5r1Qoy.mjs";
+import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-Do-8jTKC.mjs";
 import { ClientSession, Model } from "mongoose";
 /**
  * Default slice for `$in` fan-out. Larger than `runChunkedPurge`'s 1000 on purpose:

package/dist/{validation-chain.plugin-B3gZCZj4.d.mts → validation-chain.plugin-COYrUdd8.d.mts}

@@ -1,7 +1,7 @@
-import { A as ObjectId, F as SortSpec, N as SelectSpec, j as PopulateSpec } from "./pagination-DAUg5zOY.mjs";
-import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-DzVIwhU2.mjs";
-import { n as RetentionPurgeEvent, r as RetentionPurgeRequest } from "./retention-purge-DqcYvRnG.mjs";
-import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-Bpcuz9kS.mjs";
+import { A as ObjectId, F as SortSpec, N as SelectSpec, j as PopulateSpec } from "./pagination-BAM9cA4N.mjs";
+import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-B0aFVgP2.mjs";
+import { n as RetentionPurgeEvent, r as RetentionPurgeRequest } from "./retention-purge-CCd_VXUf.mjs";
+import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-DrNGWV5b.mjs";
 import { BulkWriteResult } from "@classytic/repo-core/repository";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -112,6 +112,13 @@ interface AppendOnlyPluginOptions {
    * refused (403 `RETENTION_PURGE_DISABLED`).
    */
   allowPurge?: boolean | undefined;
+  /**
+   * Allow `archiveByFilter(filter, sink, { retentionPurge })` to delete the rows its
+   * sink acknowledged, and nothing else: a retentionPurge delete without the run's
+   * attestation is still refused. Audited via `after:append-only-purge` with
+   * `archived: true`. Implied by `allowPurge`. Default `false`.
+   */
+  allowArchive?: boolean | undefined;
 }
 /** Payload of `after:append-only-purge`: one per successful purge call. */
 type AppendOnlyPurgeEvent = RetentionPurgeEvent;
@@ -127,6 +134,8 @@ interface BulkWriteOptions {
   comment?: unknown;
   let?: Record<string, unknown>;
   ignoreUndefined?: boolean;
+  /** Server-side time bound for the write. */
+  maxTimeMS?: number;
   /** Plugin context (tenant id, actor, ...) - spread into the op context. */
   [key: string]: unknown;
 }
@@ -358,6 +367,12 @@ interface ImmutableStatesPluginOptions {
    * option is refused (403 `RETENTION_PURGE_DISABLED`).
    */
   allowPurge?: boolean | undefined;
+  /**
+   * Allow `archiveByFilter(filter, sink, { retentionPurge })` to delete frozen rows its
+   * sink acknowledged, and nothing else (see `appendOnlyPlugin`'s `allowArchive`).
+   * Implied by `allowPurge`. Default `false`.
+   */
+  allowArchive?: boolean | undefined;
   /** Domain error to throw. Default: 403 `IMMUTABLE_STATE_VIOLATION`. */
   errorFactory?: ((ctx: {
     id: unknown;

package/dist/{validation-chain.plugin-DNY6MIF6.mjs → validation-chain.plugin-DJplVJ12.mjs}

@@ -1,9 +1,9 @@
 import { t as createError } from "./error-DjdmPLWO.mjs";
-import { a as ALL_OPERATIONS, f as readRetentionPurge, p as retentionPurgeEvent, s as OP_REGISTRY } from "./Repository-eMRYZ_2Y.mjs";
+import { a as ALL_OPERATIONS, f as readRetentionPurge, p as retentionPurgeEvent, s as OP_REGISTRY } from "./Repository-DheA7oW-.mjs";
 import { n as collectIds, r as idChunks, t as DEFAULT_ID_CHUNK } from "./id-chunks-DH-RAZWG.mjs";
-import { w as upsert } from "./update-DcfmNbJe.mjs";
+import { w as upsert } from "./update-CYaJMu6j.mjs";
 import { n as warn } from "./logger-hbWOlj_X.mjs";
-import { c as tenantContextKeysOf, o as forwardScope } from "./timestamp.plugin-Bz_zL9PX.mjs";
+import { c as tenantContextKeysOf, o as forwardScope } from "./timestamp.plugin-B-IJrlYb.mjs";
 import { r as getFieldsForUser } from "./field-selection-DPFaFw9Y.mjs";
 import mongoose from "mongoose";
 import { HOOK_PRIORITY } from "@classytic/repo-core/hooks";
@@ -125,6 +125,7 @@ function aggregateHelpersPlugin() {
 * applies). The same option is honoured by `immutableStatesPlugin`, so a
 * repository with both plugins purges through one call. Prefer it over
 * `bypassAppendOnly` for retention: it is delete-only and carries a reason.
+* `allowArchive: true` admits only `archiveByFilter`'s attested chunk deletes.
 *
 * `skipPlugins` is deliberately IGNORED — same policy as tenant scope
 * and soft delete: integrity fences don't have a convenience bypass.
@@ -154,7 +155,8 @@ function appendOnlyPlugin(options = {}) {
 			const modelName = repo.Model?.modelName ?? "model";
 			const purgeGuard = {
 				plugin: "appendOnlyPlugin",
-				allowPurge: options.allowPurge === true
+				allowPurge: options.allowPurge === true,
+				allowArchive: options.allowArchive === true
 			};
 			const priority = options.priority ?? HOOK_PRIORITY.POLICY;
 			for (const [op, meta] of Object.entries(OP_REGISTRY)) {
@@ -183,7 +185,7 @@ function appendOnlyPlugin(options = {}) {
 					});
 				}, { priority });
 			}
-			if (options.allowPurge) for (const op of ["delete", "deleteMany"]) repo.on(`after:${op}`, async (payload) => {
+			if (options.allowPurge || options.allowArchive) for (const op of ["delete", "deleteMany"]) repo.on(`after:${op}`, async (payload) => {
 				const event = retentionPurgeEvent(op, payload.context, payload.result);
 				if (event) await repo.emitAsync("after:append-only-purge", event);
 			});
@@ -827,7 +829,8 @@ function immutableStatesPlugin(options) {
 			};
 			const purgeGuard = {
 				plugin: "immutableStatesPlugin",
-				allowPurge: options.allowPurge === true
+				allowPurge: options.allowPurge === true,
+				allowArchive: options.allowArchive === true
 			};
 			const purgeRequest = (op, ctx) => readRetentionPurge(ctx, op, purgeGuard);
 			for (const op of [
@@ -842,7 +845,7 @@ function immutableStatesPlugin(options) {
 				await guardDelete(ctx);
 			});
 			const emitPurge = async (operation, context, result) => {
-				if (!options.allowPurge || context[internalFlag]) return;
+				if (!(options.allowPurge || options.allowArchive) || context[internalFlag]) return;
 				const base = retentionPurgeEvent(operation, context, result);
 				if (!base) return;
 				const event = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.44.0",
+  "version": "3.46.0",
   "description": "Production-grade MongoDB repositories - smart pagination, events, and plugins. Built on @classytic/repo-core.",
   "type": "module",
   "sideEffects": false,
@@ -152,9 +152,9 @@
   },
   "homepage": "https://github.com/classytic/mongokit#readme",
   "peerDependencies": {
-    "@classytic/repo-core": ">=0.37.0",
+    "@classytic/repo-core": ">=0.38.0",
     "mongodb-memory-server": ">=11.3.0",
-    "mongoose": ">=9.11.4"
+    "mongoose": ">=9.12.0"
   },
   "peerDependenciesMeta": {
     "mongodb-memory-server": {
@@ -202,25 +202,25 @@
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@better-auth/api-key": "^1.7.15",
-    "@better-auth/mongo-adapter": "^1.7.15",
-    "@biomejs/biome": "^2.6.4",
+    "@better-auth/api-key": "^1.7.18",
+    "@better-auth/mongo-adapter": "^1.7.18",
+    "@biomejs/biome": "^2.6.5",
     "@classytic/dev-tools": "^0.2.1",
-    "@classytic/repo-core": "^0.37.0",
+    "@classytic/repo-core": "^0.38.0",
     "@types/node": "^26.6.6",
     "@vitest/coverage-v8": "^5.1.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
-    "better-auth": "^1.7.15",
+    "better-auth": "^1.7.18",
     "dotenv": "^18.0.9",
     "fast-check": "^4.10.2",
     "knip": "^6.44.1",
-    "mongodb": "~7.7.0",
+    "mongodb": "~7.8.0",
     "mongodb-memory-server": "^11.3.0",
-    "mongoose": "^9.11.4",
+    "mongoose": "^9.12.0",
     "publint": "^0.3.25",
     "ts-api": "npm:typescript@~5.9.3",
-    "tsdown": "^0.23.4",
+    "tsdown": "^0.23.5",
     "typescript": "~7.0.2",
     "vitest": "^5.1.0"
   }

package/skills/mongokit/references/plugins-tenancy.md

@@ -37,6 +37,7 @@ Retention purge (append-only or frozen rows): build `appendOnlyPlugin` and/or `i
 `purgeByFilter(filter, { type: 'hard' }, { retentionPurge: { reason, actor } })` (or `deleteMany(filter, { mode: 'hard', retentionPurge })`).
 Each delete call emits `after:append-only-purge` / `after:immutable-states-purge` with `deletedCount` and `session`. Listeners are awaited and a
 throwing one fails the purge; write the audit row with `{ session: event.session }` so it commits or aborts with the delete. Ordinary deletes stay refused.
+Archive (move to cold storage) on those repos: `allowArchive: true`, then `archiveByFilter(filter, sink, { retentionPurge })`; only chunks the sink acknowledged are deleted (event `archived: true`).
 Function-form anonymize writes through the guarded `updateMany` (frozen / append-only rows refused); `immutableStatesPlugin` reads state in the call's session.
 
 `leasePlugin` (after `methodRegistryPlugin`): `lease({ filter, leaseFor, leasedBy, now })` claims a pending row or a dead lease (a row

package/skills/mongokit/references/transactions-outbox.md

@@ -77,12 +77,14 @@ Resolution order: per call, then repository (`queryDefaults` option), then deplo
 import { assertQueryDefaultsConfigured, configureAggregateDefaults, configureQueryDefaults } from '@classytic/mongokit';
 configureQueryDefaults({ maxTimeMS: 15000, readConcern: 'majority', comment: 'api' });
 configureAggregateDefaults({ maxTimeMs: 30000, allowDiskUse: true });
-assertQueryDefaultsConfigured(mongoose.connection);   // boot gate: throws without maxTimeMS or a client timeoutMS
+assertQueryDefaultsConfigured();   // boot gate: throws without a deployment maxTimeMS
 await repo.getAll({ mode: 'offset', page: 1 }, { comment: 'orders.list', maxTimeMS: 5000, hint: { organizationId: 1, createdAt: -1 } });
 ```
 
 Inside a transaction a default read or write concern is dropped (the transaction owns it); a per-call one is passed through.
 
+The bound is the server-side `maxTimeMS`. The driver's `timeoutMS` (CSOT) is a no-op since 7.8, so never rely on it. A single `create()` (Mongoose `save()`) forwards no `maxTimeMS` and is not server-bounded; `createMany`, updates, deletes, `bulkWrite`, reads and aggregates are. `withTransaction({ transactionOptions: { timeoutMS } })` is mongokit's own budget for the whole transaction: each operation gets `maxTimeMS` = what remains, the commit gets `maxCommitTimeMS`.
+
 ## Verify indexes
 
 ```ts