@classytic/mongokit 3.43.1 → 3.45.0

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

@@ -1,11 +1,11 @@
-import { a as ALL_OPERATIONS, s as OP_REGISTRY, t as HOOK_PRIORITY } from "./Repository-Dj6xqPxJ.mjs";
-import { n as warn } from "./logger-K7dPmu2U.mjs";
-import { n as declareCollectionScope } from "./join-scope-DSAznE8E.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";
 import mongoose from "mongoose";
 import { cachePlugin } from "@classytic/repo-core/cache";
 import { adminBypass, payloadHasTenantField } from "@classytic/repo-core/plugins";
-//#region src/plugins/audit-log.plugin.ts
+// src/plugins/audit-log.plugin.ts
 /**
 * Audit log plugin that logs all repository operations
 *
@@ -102,8 +102,7 @@ function auditLogPlugin(logger) {
 		}
 	};
 }
-//#endregion
-//#region src/plugins/audit-trail.plugin.ts
+// src/plugins/audit-trail.plugin.ts
 /**
 * Audit Trail Plugin
 *
@@ -631,8 +630,7 @@ var AuditTrailQuery = class {
 		});
 	}
 };
-//#endregion
-//#region src/plugins/custom-id.plugin.ts
+// src/plugins/custom-id.plugin.ts
 /**
 * Custom ID Plugin
 *
@@ -711,10 +709,54 @@ const counterSchema = new mongoose.Schema({
 * Falls back to the default mongoose connection if none is provided.
 * Lazy-init to avoid model registration errors if mongoose isn't connected yet.
 */
-function getCounterModel(connection) {
+function getCounterModel(connection, collection) {
 	const conn = connection ?? mongoose.connection;
-	if (conn.models._MongoKitCounter) return conn.models._MongoKitCounter;
-	return conn.model("_MongoKitCounter", counterSchema);
+	const modelName = collection === void 0 || collection === "_mongokit_counters" ? "_MongoKitCounter" : `_MongoKitCounter:${collection}`;
+	if (conn.models[modelName]) return conn.models[modelName];
+	return conn.model(modelName, counterSchema, collection ?? "_mongokit_counters");
+}
+/**
+* Bind the atomic counter API to a connection and, optionally, a
+* collection other than `_mongokit_counters`.
+*
+* @example
+* const counters = createSequenceCounter({ connection, collection: 'app_counters' });
+* await withTransaction(connection, async (session) => {
+*   const seq = await counters.next('alert.stream', 1, session);
+* });
+*/
+function createSequenceCounter(options = {}) {
+	const { connection, collection } = options;
+	assertCounterCollection("createSequenceCounter", collection);
+	const model = () => getCounterModel(connection, collection);
+	return {
+		next: (counterKey, increment = 1, session) => incrementCounter(model(), counterKey, increment, session),
+		read: (counterKey, session) => readCounter(model(), counterKey, session),
+		ensureAtLeast: (counterKey, floor, session) => raiseCounter(model(), counterKey, floor, session),
+		nextInPeriod: (baseKey, periodOptions) => nextInPeriod(model(), baseKey, periodOptions)
+	};
+}
+function assertCounterCollection(fn, collection) {
+	if (collection !== void 0 && (typeof collection !== "string" || collection.length === 0)) throw new Error(`${fn}: collection must be a non-empty string`);
+}
+async function incrementCounter(Counter, counterKey, increment, session) {
+	const result = await Counter.findOneAndUpdate({ _id: counterKey }, { $inc: { seq: increment } }, {
+		upsert: true,
+		returnDocument: "after",
+		session
+	});
+	if (!result) throw new Error(`Failed to increment counter '${counterKey}'`);
+	return result.seq;
+}
+async function raiseCounter(Counter, counterKey, floor, session) {
+	if (!Number.isSafeInteger(floor) || floor < 0) throw new Error(`ensureSequenceAtLeast: floor must be a non-negative integer, got ${floor}`);
+	const result = await Counter.findOneAndUpdate({ _id: counterKey }, { $max: { seq: floor } }, {
+		upsert: true,
+		returnDocument: "after",
+		session
+	});
+	if (!result) throw new Error(`Failed to seed counter '${counterKey}'`);
+	return result.seq;
 }
 /**
 * Atomically increment and return the next sequence value for a given key.
@@ -746,20 +788,17 @@ function getCounterModel(connection) {
 * });
 */
 async function getNextSequence(counterKey, increment = 1, connection, session) {
-	const result = await getCounterModel(connection).findOneAndUpdate({ _id: counterKey }, { $inc: { seq: increment } }, {
-		upsert: true,
-		returnDocument: "after",
-		session
-	});
-	if (!result) throw new Error(`Failed to increment counter '${counterKey}'`);
-	return result.seq;
+	return incrementCounter(getCounterModel(connection), counterKey, increment, session);
 }
 /**
 * Current value of a counter, or `null` when it has never been created.
 * `null` and `0` differ: only a missing counter needs seeding.
 */
-async function readSequence(counterKey, connection) {
-	const doc = await getCounterModel(connection).findById(counterKey).lean();
+async function readSequence(counterKey, connection, session) {
+	return readCounter(getCounterModel(connection), counterKey, session);
+}
+async function readCounter(Counter, counterKey, session) {
+	const doc = await Counter.findById(counterKey, null, session ? { session } : {}).lean();
 	return doc ? doc.seq : null;
 }
 /**
@@ -772,14 +811,109 @@ async function readSequence(counterKey, connection) {
 *
 * @returns The counter's value after the raise.
 */
-async function ensureSequenceAtLeast(counterKey, floor, connection) {
-	if (!Number.isSafeInteger(floor) || floor < 0) throw new Error(`ensureSequenceAtLeast: floor must be a non-negative integer, got ${floor}`);
-	const result = await getCounterModel(connection).findOneAndUpdate({ _id: counterKey }, { $max: { seq: floor } }, {
-		upsert: true,
-		returnDocument: "after"
-	});
-	if (!result) throw new Error(`Failed to seed counter '${counterKey}'`);
-	return result.seq;
+async function ensureSequenceAtLeast(counterKey, floor, connection, session) {
+	return raiseCounter(getCounterModel(connection), counterKey, floor, session);
+}
+const SEQUENCE_PERIODS = /* @__PURE__ */ new Set([
+	"year",
+	"month",
+	"day"
+]);
+/** One cached formatter per zone; construction is the expensive part of Intl. */
+const civilFormatters = /* @__PURE__ */ new Map();
+function civilFormatter(fn, timeZone) {
+	if (typeof timeZone !== "string" || timeZone.length === 0) throw new Error(`${fn}: timeZone must be a non-empty IANA time zone (e.g. 'Asia/Riyadh')`);
+	let formatter = civilFormatters.get(timeZone);
+	if (!formatter) {
+		try {
+			formatter = new Intl.DateTimeFormat("en-US", {
+				timeZone,
+				calendar: "gregory",
+				numberingSystem: "latn",
+				year: "numeric",
+				month: "2-digit",
+				day: "2-digit"
+			});
+		} catch {
+			throw new Error(`${fn}: unknown time zone '${timeZone}'`);
+		}
+		civilFormatters.set(timeZone, formatter);
+	}
+	return formatter;
+}
+/**
+* The civil date of an instant in a zone. Read from the zone's own rules
+* (Intl), never by adding a fixed offset, so DST shifts and zone-rule changes
+* (a skipped or repeated local day) land on the date a wall clock there shows.
+*/
+function civilParts(fn, at, timeZone) {
+	const formatter = civilFormatter(fn, timeZone);
+	let year = "";
+	let month = "";
+	let day = "";
+	for (const part of formatter.formatToParts(at)) if (part.type === "year") year = part.value;
+	else if (part.type === "month") month = part.value;
+	else if (part.type === "day") day = part.value;
+	return {
+		year: year.padStart(4, "0"),
+		month,
+		day
+	};
+}
+function assertInstant(fn, at) {
+	if (!(at instanceof Date) || Number.isNaN(at.getTime())) throw new Error(`${fn}: at must be a valid Date`);
+}
+/**
+* The civil period of an instant in an IANA time zone: `'2026'` (year),
+* `'2026-03'` (month) or `'2026-03-14'` (day). The period suffix every
+* period-scoped counter key ends with.
+*
+* @example
+* civilPeriodKey(new Date('2026-12-31T21:00:00Z'), 'year', 'Asia/Riyadh'); // '2027'
+* civilPeriodKey(new Date('2026-12-31T21:00:00Z'), 'year', 'UTC');         // '2026'
+*/
+function civilPeriodKey(at, period, timeZone) {
+	assertInstant("civilPeriodKey", at);
+	if (!SEQUENCE_PERIODS.has(period)) throw new Error(`civilPeriodKey: period must be 'year', 'month' or 'day', got '${period}'`);
+	const { year, month, day } = civilParts("civilPeriodKey", at, timeZone);
+	if (period === "year") return year;
+	if (period === "month") return `${year}-${month}`;
+	return `${year}-${month}-${day}`;
+}
+/**
+* The counter key and civil period for a base key at an instant. Use it to
+* `read` / `ensureAtLeast` the same counter `getNextPeriodSequence` bumps.
+*/
+function periodCounterKey(baseKey, options) {
+	if (typeof baseKey !== "string" || baseKey.length === 0) throw new Error("periodCounterKey: baseKey must be a non-empty string");
+	const period = civilPeriodKey(options.at ?? /* @__PURE__ */ new Date(), options.period, options.timeZone);
+	return {
+		counterKey: `${baseKey}${options.keySeparator ?? ":"}${period}`,
+		period
+	};
+}
+/**
+* Atomically issue the next value of a counter that resets every civil
+* year / month / day in an IANA time zone. The period is derived from `at`
+* (default now) in `timeZone`, so every replica agrees on it whatever its
+* `TZ`, and DST never moves a boundary.
+*
+* @example Yearly reference `OC-2026-000123` in Riyadh
+* const { seq, period } = await getNextPeriodSequence('occ.occurrence', {
+*   period: 'year', timeZone: 'Asia/Riyadh', at: reportedAt, connection, session,
+* });
+* const ref = `OC-${period}-${String(seq).padStart(6, '0')}`;
+*/
+async function getNextPeriodSequence(baseKey, options) {
+	return nextInPeriod(getCounterModel(options.connection), baseKey, options);
+}
+async function nextInPeriod(Counter, baseKey, options) {
+	const { counterKey, period } = periodCounterKey(baseKey, options);
+	return {
+		seq: await incrementCounter(Counter, counterKey, options.increment ?? 1, options.session),
+		period,
+		counterKey
+	};
 }
 /**
 * Generator: Simple sequential counter.
@@ -796,10 +930,11 @@ async function ensureSequenceAtLeast(counterKey, floor, connection) {
 * ```
 */
 function sequentialId(options) {
-	const { prefix, model, padding = 4, separator = "-", counterKey } = options;
+	const { prefix, model, padding = 4, separator = "-", counterKey, counterCollection } = options;
 	const key = counterKey || model.modelName;
+	assertCounterCollection("sequentialId", counterCollection);
 	return async (context) => {
-		const seq = await getNextSequence(key, 1, context._counterConnection, context.session);
+		const seq = await incrementCounter(getCounterModel(context._counterConnection, counterCollection), key, 1, context.session);
 		return `${prefix}${separator}${String(seq).padStart(padding, "0")}`;
 	};
 }
@@ -834,21 +969,31 @@ function sequentialId(options) {
 * ```
 */
 function dateSequentialId(options) {
-	const { prefix, model, partition = "monthly", padding = 4, separator = "-", scope = "global", tenantKey = "organizationId", timezone = "local" } = options;
+	const { prefix, model, partition = "monthly", padding = 4, separator = "-", scope = "global", tenantKey = "organizationId", timezone = "local", timeZone, at, counterKey: baseCounterKey, counterCollection } = options;
+	assertCounterCollection("dateSequentialId", counterCollection);
+	if (timeZone !== void 0) civilFormatter("dateSequentialId", timeZone);
+	if (baseCounterKey !== void 0 && (typeof baseCounterKey !== "string" || baseCounterKey.length === 0)) throw new Error("dateSequentialId: counterKey must be a non-empty string");
 	/** Per-generator, not module-level — two generators warn independently. */
 	const overflowWarned = /* @__PURE__ */ new Set();
 	const paddingCeiling = 10 ** padding;
 	return async (context) => {
-		const now = /* @__PURE__ */ new Date();
-		const utc = timezone === "utc";
-		const year = String(utc ? now.getUTCFullYear() : now.getFullYear());
-		const month = String((utc ? now.getUTCMonth() : now.getMonth()) + 1).padStart(2, "0");
-		const day = String(utc ? now.getUTCDate() : now.getDate()).padStart(2, "0");
-		let keyBase = model.modelName;
+		const now = at?.(context) ?? /* @__PURE__ */ new Date();
+		assertInstant("dateSequentialId", now);
+		let year;
+		let month;
+		let day;
+		if (timeZone !== void 0) ({year, month, day} = civilParts("dateSequentialId", now, timeZone));
+		else {
+			const utc = timezone === "utc";
+			year = String(utc ? now.getUTCFullYear() : now.getFullYear());
+			month = String((utc ? now.getUTCMonth() : now.getMonth()) + 1).padStart(2, "0");
+			day = String(utc ? now.getUTCDate() : now.getDate()).padStart(2, "0");
+		}
+		let keyBase = baseCounterKey ?? model.modelName;
 		if (scope === "tenant") {
 			const tenantId = context[tenantKey];
 			if (tenantId === void 0 || tenantId === null || tenantId === "") throw new Error(`[mongokit] dateSequentialId: scope 'tenant' requires '${tenantKey}' in context for '${model.modelName}' create, but none was provided. Pass it per call (repo.create(data, { ${tenantKey}: '<id>' })) or resolve it ambiently; the generator never falls back to the global counter.`);
-			keyBase = `${model.modelName}:${String(tenantId)}`;
+			keyBase = `${keyBase}:${String(tenantId)}`;
 		}
 		let datePart;
 		let counterKey;
@@ -865,7 +1010,7 @@ function dateSequentialId(options) {
 				datePart = `${year}${separator}${month}`;
 				counterKey = `${keyBase}:${year}-${month}`;
 		}
-		const seq = await getNextSequence(counterKey, 1, context._counterConnection, context.session);
+		const seq = await incrementCounter(getCounterModel(context._counterConnection, counterCollection), counterKey, 1, context.session);
 		if (seq >= paddingCeiling && !overflowWarned.has(counterKey)) {
 			overflowWarned.add(counterKey);
 			warn(`[mongokit] dateSequentialId: '${model.modelName}' sequence ${seq} exceeds padding ${padding} (max ${paddingCeiling - 1}) for period '${counterKey}'. Ids remain unique but no longer sort lexically — raise \`padding\` for new periods, or use a finer \`partition\`.`);
@@ -957,8 +1102,7 @@ function customIdPlugin(options) {
 		}
 	};
 }
-//#endregion
-//#region src/utils/scope.ts
+// src/utils/scope.ts
 /** Tenant context keys forwarded even when no tenant plugin declared one. */
 const CONVENTIONAL_TENANT_KEYS = ["organizationId", "tenantId"];
 const ATTRIBUTION_KEYS = [
@@ -1013,8 +1157,7 @@ function forwardScope(source, tenantKeys = CONVENTIONAL_TENANT_KEYS) {
 function isScopeKey(key, tenantKeys = CONVENTIONAL_TENANT_KEYS) {
 	return key === "bypassTenant" || tenantKeys.includes(key) || ATTRIBUTION_KEYS.includes(key);
 }
-//#endregion
-//#region src/plugins/multi-tenant.plugin.ts
+// src/plugins/multi-tenant.plugin.ts
 /**
 * Multi-Tenant Plugin
 *
@@ -1063,6 +1206,9 @@ function multiTenantPlugin(options = {}) {
 	const extraOps = [{
 		op: "getDeleted",
 		policyKey: "filters"
+	}, {
+		op: "searchSimilar",
+		policyKey: "filters"
 	}];
 	return {
 		name: "multi-tenant",
@@ -1256,8 +1402,7 @@ function multiTenantPlugin(options = {}) {
 function adminBypass$1(options) {
 	return adminBypass(options);
 }
-//#endregion
-//#region src/plugins/soft-delete.plugin.ts
+// src/plugins/soft-delete.plugin.ts
 /**
 * Build the deletion-state filter for either side of the soft-delete
 * boundary. One parameterized helper covers both directions so the two
@@ -1563,8 +1708,7 @@ function softDeletePlugin(options = {}) {
 		}
 	};
 }
-//#endregion
-//#region src/plugins/timestamp.plugin.ts
+// src/plugins/timestamp.plugin.ts
 /**
 * Timestamp plugin that auto-injects timestamps
 *
@@ -1602,5 +1746,4 @@ function timestampPlugin() {
 		}
 	};
 }
-//#endregion
-export { AuditTrailQuery as _, declareTenantContextKey as a, auditLogPlugin as b, tenantContextKeysOf as c, ensureSequenceAtLeast as d, getNextSequence as f, cachePlugin as g, sequentialId as h, multiTenantPlugin as i, customIdPlugin as l, readSequence as m, softDeletePlugin as n, forwardScope as o, prefixedId as p, adminBypass$1 as r, isScopeKey as s, timestampPlugin as t, dateSequentialId as u, auditTrailPlugin as v, ensureAuditTrailReady as y };
+export { ensureAuditTrailReady as C, auditTrailPlugin as S, prefixedId as _, declareTenantContextKey as a, cachePlugin as b, tenantContextKeysOf as c, customIdPlugin as d, dateSequentialId as f, periodCounterKey as g, getNextSequence as h, multiTenantPlugin as i, civilPeriodKey as l, getNextPeriodSequence as m, softDeletePlugin as n, forwardScope as o, ensureSequenceAtLeast as p, adminBypass$1 as r, isScopeKey as s, timestampPlugin as t, createSequenceCounter as u, readSequence as v, auditLogPlugin as w, AuditTrailQuery as x, sequentialId as y };

package/dist/{to-plain-vksRrLtc.mjs → to-plain-CEKv_ylg.mjs}

@@ -1,4 +1,4 @@
-//#region src/utils/memory-cache.ts
+// src/utils/memory-cache.ts
 /**
 * Creates an in-memory cache adapter
 *
@@ -63,8 +63,7 @@ function createMemoryCache(maxEntries = 1e3) {
 		}
 	};
 }
-//#endregion
-//#region src/utils/to-plain.ts
+// src/utils/to-plain.ts
 /**
 * Convert a hydrated Mongoose (sub)document to a plain object — the
 * spread-safety primitive for domain verbs that rebuild embedded lines.
@@ -94,5 +93,4 @@ function createMemoryCache(maxEntries = 1e3) {
 function toPlain(value) {
 	return value !== null && value !== void 0 && typeof value.toObject === "function" ? value.toObject() : value;
 }
-//#endregion
 export { createMemoryCache as n, toPlain as t };

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

@@ -1,10 +1,9 @@
-import { y as UserContext } from "./repository-MqAP409e.mjs";
-import { r as FieldPreset } from "./plugin-options-Cirmb4Kp.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";
 import { CrudSchemas, SchemaBuilderOptions } from "@classytic/repo-core/schema";
-//#region src/utils/error.d.ts
 /** Optional structured fields for createError. */
 interface CreateErrorOptions {
   /** Stable machine-readable code (e.g. `SEARCH_NOT_CONFIGURED`). */
@@ -70,8 +69,6 @@ interface ParseDuplicateKeyOptions {
  * Returns `null` when the error is not a duplicate-key error.
  */
 declare function parseDuplicateKeyError(error: unknown, options?: ParseDuplicateKeyOptions): HttpError | null;
-//#endregion
-//#region src/utils/field-selection.d.ts
 /**
  * Get allowed fields for a user based on their context
  *
@@ -138,8 +135,6 @@ declare function filterResponseData<T extends Record<string, unknown>>(data: T |
  * });
  */
 declare function createFieldPreset(config: Partial<FieldPreset>): FieldPreset;
-//#endregion
-//#region src/utils/id-resolution.d.ts
 /** Normalized _id type — covers the common Mongoose _id declarations */
 type IdType = 'objectid' | 'string' | 'number' | 'uuid' | 'unknown';
 /**
@@ -212,8 +207,6 @@ declare function isValidIdForType(id: unknown, idType: IdType): boolean;
  * await col.deleteMany({ customerId: { $in: idVariants(userId) } });
  */
 declare function idVariants(id: unknown): unknown[];
-//#endregion
-//#region src/utils/logger.d.ts
 /**
  * Internal Logger
  *
@@ -244,8 +237,6 @@ interface LoggerConfig {
  * Pass `false` to silence all output.
  */
 declare function configureLogger(config: Partial<LoggerConfig> | false): void;
-//#endregion
-//#region src/utils/memory-cache.d.ts
 /**
  * Creates an in-memory cache adapter
  *
@@ -257,8 +248,6 @@ declare function configureLogger(config: Partial<LoggerConfig> | false): void;
  * @param maxEntries - Maximum cache entries before oldest are evicted (default: 1000)
  */
 declare function createMemoryCache(maxEntries?: number): CacheAdapter;
-//#endregion
-//#region src/utils/mongooseToJsonSchema.d.ts
 /**
  * Return shape for the schema builders. Structurally a `CrudSchemas` plus
  * an `[key: string]: unknown` index signature so the function reference
@@ -298,8 +287,6 @@ declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, opti
  * `SchemaGenerator<Model<unknown>>`, so the contract claim above is unchanged.
  */
 declare function buildCrudSchemasFromModel<TDoc = unknown>(mongooseModel: mongoose.Model<TDoc>, options?: SchemaBuilderOptions): CrudSchemasFramework;
-//#endregion
-//#region src/utils/to-plain.d.ts
 /**
  * Convert a hydrated Mongoose (sub)document to a plain object — the
  * spread-safety primitive for domain verbs that rebuild embedded lines.
@@ -327,5 +314,4 @@ declare function buildCrudSchemasFromModel<TDoc = unknown>(mongooseModel: mongoo
  * defensively over values that may or may not be hydrated.
  */
 declare function toPlain<T>(value: T): T;
-//#endregion
 export { parseDuplicateKeyError as S, getMongooseProjection as _, createMemoryCache as a, createError as b, IdType as c, isObjectIdInstance as d, isValidIdForType as f, getFieldsForUser as g, filterResponseData as h, buildCrudSchemasFromMongooseSchema as i, getSchemaIdType as l, createFieldPreset as m, CrudSchemasFramework as n, LoggerConfig as o, toObjectId as p, buildCrudSchemasFromModel as r, configureLogger as s, toPlain as t, idVariants as u, CreateErrorOptions as v, isDuplicateKeyError as x, ParseDuplicateKeyOptions as y };

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

@@ -1,8 +1,8 @@
-import { t as createError } from "./error-BuByZwKU.mjs";
-import { d as setTransactionDeadline } from "./query-defaults-BxUcSOoF.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";
-//#region src/capabilities.ts
+// src/capabilities.ts
 /**
 * Read the provenance of a capability descriptor's `transactions` flag.
 * A descriptor without the field is a static declaration (`'declared'`) —
@@ -252,8 +252,7 @@ async function probeMongoCapabilities(connection, options = {}) {
 	PROBE_INFLIGHT.set(key, run);
 	return DERIVED[await run];
 }
-//#endregion
-//#region src/tx-bound.ts
+// src/tx-bound.ts
 /**
 * Map of session-aware method name → positional index of the `{ session }`
 * options bag. Keep this list in sync with the method signatures in
@@ -391,8 +390,7 @@ function createTxBoundRepo(outer, session) {
 		};
 	} });
 }
-//#endregion
-//#region src/transaction.ts
+// src/transaction.ts
 /**
 * Cross-repo transaction helper.
 *
@@ -496,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;
@@ -519,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);
@@ -541,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;
@@ -678,5 +678,4 @@ function isTransactionUnsupported(error) {
 function supportsTransactions(connection) {
 	return resolveTransactionSupport(connection) !== "no";
 }
-//#endregion
 export { supportsTransactions as a, MONGOKIT_CAPABILITIES as c, probeMongoCapabilities as d, resetCapabilityProbeCache as f, transactionResolutionOf as h, runTransaction as i, capabilitiesForSupport as l, resolveTransactionSupport as m, batchTransaction as n, withTransaction as o, resolveMongoCapabilities as p, isTransactionUnsupported as r, createTxBoundRepo as s, TRANSACTION_ERROR_CODES as t, classifyHelloReply as u };

package/dist/{type-utils-CLzRFtIA.d.mts → type-utils-CKvuewAL.d.mts}

@@ -1,6 +1,5 @@
 import { Document, Model } from "mongoose";
 import { ValidationResult } from "@classytic/repo-core/schema";
-//#region src/types/type-utils.d.ts
 /**
  * Infer document type from a Mongoose Model
  * @example
@@ -159,5 +158,4 @@ type UpdateWithValidationResult<T> = {
     violations?: ValidationResult['violations'];
   };
 };
-//#endregion
 export { InferRawDoc as a, NonNullableFields as c, Strict as d, UpdatePatch as f, InferDocument as i, PartialBy as l, DeepPartial as n, KeysOfType as o, UpdateWithValidationResult as p, DocField as r, MongoOperatorUpdate as s, CreateInput as t, RequiredBy as u };

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

@@ -1,9 +1,9 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as warn } from "./logger-K7dPmu2U.mjs";
-import { t as createError } from "./error-BuByZwKU.mjs";
-import { i as applyToQuery } from "./query-defaults-BxUcSOoF.mjs";
+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 { r as applyToQuery } from "./query-defaults-DwvWUjZU.mjs";
 import { coerceFilterDates, isFilter } from "@classytic/repo-core/filter";
-//#region src/actions/create.ts
+// src/actions/create.ts
 var create_exports = /* @__PURE__ */ __exportAll({
 	create: () => create,
 	createDefault: () => createDefault,
@@ -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;
@@ -109,8 +107,7 @@ async function upsert(Model, query, data, options = {}) {
 		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
 	});
 }
-//#endregion
-//#region src/filter/cast-schema.ts
+// src/filter/cast-schema.ts
 /** Operators whose operand is a single scalar to cast. */
 const SCALAR_OPS = /* @__PURE__ */ new Set([
 	"$eq",
@@ -225,8 +222,7 @@ function castFilterToSchema(filter, schema) {
 	}
 	return changed ? out : filter;
 }
-//#endregion
-//#region src/filter/compile.ts
+// src/filter/compile.ts
 /**
 * Compile a Filter IR node to a MongoDB query object. Returns `{}`
 * when the node is `TRUE` (or an empty `and`) so callers can merge
@@ -464,8 +460,7 @@ function asOperators(condition) {
 function escapeRegexChar(ch) {
 	return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
 }
-//#endregion
-//#region src/query/LookupBuilder.ts
+// src/query/LookupBuilder.ts
 /** Stages that are never valid inside a $lookup pipeline */
 const BLOCKED_PIPELINE_STAGES = [
 	"$out",
@@ -852,8 +847,7 @@ function compileSelectToProjection(select) {
 *    - For read-heavy workloads: Consider caching or materialized views
 *    - For real-time dashboards: Consider separate aggregation collections
 */
-//#endregion
-//#region src/actions/aggregate.ts
+// src/actions/aggregate.ts
 var aggregate_exports = /* @__PURE__ */ __exportAll({
 	aggregate: () => aggregate,
 	aggregatePaginate: () => aggregatePaginate,
@@ -1023,8 +1017,7 @@ async function minMax(Model, field, query = {}, options = {}) {
 		max: null
 	};
 }
-//#endregion
-//#region src/actions/delete.ts
+// src/actions/delete.ts
 var delete_exports = /* @__PURE__ */ __exportAll({
 	deleteById: () => deleteById,
 	deleteByQuery: () => deleteByQuery,
@@ -1113,8 +1106,7 @@ async function restore(Model, id, options = {}) {
 		id: String(id)
 	};
 }
-//#endregion
-//#region src/actions/read.ts
+// src/actions/read.ts
 var read_exports = /* @__PURE__ */ __exportAll({
 	count: () => count,
 	exists: () => exists,
@@ -1251,8 +1243,7 @@ async function exists(Model, query, options = {}) {
 	applyToQuery(q, options.queryOptions ?? {});
 	return q;
 }
-//#endregion
-//#region src/actions/update.ts
+// src/actions/update.ts
 var update_exports = /* @__PURE__ */ __exportAll({
 	findOneAndUpdate: () => findOneAndUpdate,
 	increment: () => increment,
@@ -1435,5 +1426,4 @@ async function pushToArray(Model, id, field, value, options = {}) {
 async function pullFromArray(Model, id, field, value, options = {}) {
 	return update(Model, id, { $pull: { [field]: value } }, options);
 }
-//#endregion
 export { isCreateManyPartialError as C, create_exports as S, SHORTHAND_OPS as _, count as a, create as b, getByQuery as c, deleteById as d, deleteByQuery as f, LookupBuilder as g, distinct as h, update_exports as i, getOrCreate as l, aggregate_exports as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, compileFilterToMongo as v, upsert as w, createMany as x, castFilterToSchema as y };