@classytic/mongokit 3.43.0 → 3.44.0

package/dist/{timestamp.plugin-DpOWavVI.mjs → timestamp.plugin-Bz_zL9PX.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-eMRYZ_2Y.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-PO5r1Qoy.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-DzVIwhU2.mjs";
+import { r as FieldPreset } from "./plugin-options-Bpcuz9kS.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-C2PFxfIv.mjs}

@@ -1,8 +1,8 @@
-import { t as createError } from "./error-BuByZwKU.mjs";
-import { d as setTransactionDeadline } from "./query-defaults-BxUcSOoF.mjs";
+import { d as setTransactionDeadline } from "./query-defaults-aUoKlEbh.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.
 *
@@ -678,5 +676,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-DcfmNbJe.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 { i as applyToQuery } from "./query-defaults-aUoKlEbh.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,
@@ -109,8 +109,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 +224,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 +462,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 +849,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 +1019,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 +1108,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 +1245,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 +1428,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 };

package/dist/usage/index.d.mts

@@ -1,8 +1,7 @@
 import { Connection } from "mongoose";
 import { UsageStore } from "@classytic/repo-core/usage";
-//#region src/usage/index.d.ts
 /** Adapter-construction options. */
-interface MongoUsageStoreOptions {
+export interface MongoUsageStoreOptions {
   /**
    * Mongoose connection. Defaults to `mongoose.connection` (the
    * default global connection). Apps using a named connection pass
@@ -18,6 +17,4 @@ interface MongoUsageStoreOptions {
  * Build a Mongo-backed usage store. Idempotent — the underlying model
  * is registered once per `(connection, modelName)` pair.
  */
-declare function createMongoUsageStore(options?: MongoUsageStoreOptions): UsageStore;
-//#endregion
-export { MongoUsageStoreOptions, createMongoUsageStore };
+export declare function createMongoUsageStore(options?: MongoUsageStoreOptions): UsageStore;

package/dist/usage/index.mjs

@@ -1,6 +1,6 @@
-import { n as isDuplicateKeyError } from "../error-BuByZwKU.mjs";
+import { n as isDuplicateKeyError } from "../error-DjdmPLWO.mjs";
 import mongoose, { Schema } from "mongoose";
-//#region src/usage/index.ts
+// src/usage/index.ts
 /**
 * Build a Mongo-backed usage store. Idempotent — the underlying model
 * is registered once per `(connection, modelName)` pair.
@@ -8,9 +8,12 @@ import mongoose, { Schema } from "mongoose";
 function createMongoUsageStore(options = {}) {
 	const { connection, collectionName = "usage_counters", modelName = "MongoUsageCounter" } = options;
 	const model = getOrCreateModel(connection ?? mongoose, modelName, collectionName);
+	const ready = model.init();
+	ready.catch(() => void 0);
 	return {
 		name: "mongo",
 		async increment(bucket, amount) {
+			await ready;
 			const filter = {
 				actor: bucket.actor,
 				period: bucket.period,
@@ -28,9 +31,9 @@ function createMongoUsageStore(options = {}) {
 				actor,
 				period
 			}).select("kind count").lean();
-			const out = {};
-			for (const row of rows) out[row.kind] = row.count;
-			return out;
+			const sums = /* @__PURE__ */ new Map();
+			for (const row of rows) sums.set(row.kind, (sums.get(row.kind) ?? 0) + row.count);
+			return Object.fromEntries(sums);
 		}
 	};
 }
@@ -63,5 +66,4 @@ function getOrCreateModel(conn, modelName, collectionName) {
 	}, { unique: true });
 	return conn.model(modelName, schema, collectionName);
 }
-//#endregion
 export { createMongoUsageStore };