@classytic/mongokit 3.39.0 → 3.40.1

package/dist/indexes/verify-indexes.d.mts

@@ -14,6 +14,10 @@
  * Missing UNIQUE indexes are reported separately from missing regular ones —
  * the first silently admits duplicate data, the second only costs a scan.
  *
+ * Same keys are not the same index: a live index is compared on the options that decide
+ * correctness (`unique`, `partialFilterExpression`, `sparse`, `collation`, `expireAfterSeconds`).
+ * A same-key index that differs is reported as `incompatible` — its fix is a rebuild, not a create.
+ *
  * DELIBERATELY ONE-DIRECTIONAL: an index present in the database but absent
  * from a schema is NOT drift. Auth libraries and migrations manage indexes
  * outside the ODM, and treating those as removable is exactly what makes a
@@ -44,11 +48,20 @@ interface MissingIndex {
   /** The declared key, JSON-stringified — stable to log and to diff. */
   key: string;
 }
+/** A live index on the declared keys whose correctness options differ from the declaration. */
+interface IncompatibleIndex extends MissingIndex {
+  /** Declared `unique` — a mismatch here can already have admitted duplicates. */
+  unique: boolean;
+  /** One line per differing option: `unique: declared true, live false`. */
+  differences: string[];
+}
 interface IndexVerifyReport {
   modelsChecked: number;
   /** Declared `unique` indexes with nothing behind them. Duplicates can already exist. */
   missingUnique: MissingIndex[];
   missingRegular: MissingIndex[];
+  /** Same keys, different semantics — e.g. declared unique, built non-unique. */
+  incompatible: IncompatibleIndex[];
   /** Models whose indexes could not be read — collection absent, or no permission. */
   unreadable: string[];
 }
@@ -66,4 +79,4 @@ declare function verifyIndexes(connection: IndexVerifiableConnection, options?:
 /** One-line summary for a boot log. */
 declare function formatIndexReport(report: IndexVerifyReport): string;
 //#endregion
-export { IndexVerifiableConnection, IndexVerifiableModel, IndexVerifyReport, MissingIndex, VerifyIndexesOptions, formatIndexReport, verifyIndexes };
+export { IncompatibleIndex, IndexVerifiableConnection, IndexVerifiableModel, IndexVerifyReport, MissingIndex, VerifyIndexesOptions, formatIndexReport, verifyIndexes };

package/dist/indexes/verify-indexes.mjs

@@ -22,12 +22,45 @@ function textFields(key) {
 	const fields = Object.entries(key).filter(([, dir]) => dir === "text").map(([field]) => field);
 	return fields.length > 0 ? fields.sort() : null;
 }
+/** Order-free JSON, so `{a:1,b:2}` equals `{b:2,a:1}` — option objects are not order-sensitive. */
+function canonical(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}`;
+}
+/**
+* The options that change what an index GUARANTEES, compared declared → live. Absent means
+* off (`unique`, `sparse`) or none (`partialFilterExpression`, `expireAfterSeconds`). A collation
+* is compared on the DECLARED fields only: the server fills in every default it does not store.
+*/
+function optionDifferences(declared, live) {
+	const diffs = [];
+	const flag = (name) => {
+		const d = declared[name] === true;
+		const l = live[name] === true;
+		if (d !== l) diffs.push(`${name}: declared ${d}, live ${l}`);
+	};
+	flag("unique");
+	flag("sparse");
+	for (const name of ["partialFilterExpression", "expireAfterSeconds"]) {
+		const d = declared[name] === void 0 ? "none" : canonical(declared[name]);
+		const l = live[name] === void 0 ? "none" : canonical(live[name]);
+		if (d !== l) diffs.push(`${name}: declared ${d}, live ${l}`);
+	}
+	const dColl = declared.collation;
+	const lColl = live.collation;
+	if (dColl) {
+		if (Object.keys(dColl).filter((k) => canonical(dColl[k]) !== canonical(lColl?.[k])).length > 0) diffs.push(`collation: declared ${canonical(dColl)}, live ${lColl ? canonical(lColl) : "none"}`);
+	} else if (lColl && lColl.locale !== "simple") diffs.push(`collation: declared none, live ${canonical(lColl)}`);
+	return diffs;
+}
 async function verifyIndexes(connection, options = {}) {
 	const include = options.includeModel ?? (() => true);
 	const report = {
 		modelsChecked: 0,
 		missingUnique: [],
 		missingRegular: [],
+		incompatible: [],
 		unreadable: []
 	};
 	for (const name of connection.modelNames().sort()) {
@@ -39,8 +72,12 @@ async function verifyIndexes(connection, options = {}) {
 		let existingText;
 		try {
 			const live = await model.collection.listIndexes().toArray();
-			existing = new Set(live.map((i) => normalizeKey(i.key)));
-			existingText = new Set(live.filter((i) => i.weights).map((i) => JSON.stringify(Object.keys(i.weights).sort())));
+			existing = /* @__PURE__ */ new Map();
+			existingText = /* @__PURE__ */ new Map();
+			for (const index of live) {
+				const [map, k] = index.weights ? [existingText, JSON.stringify(Object.keys(index.weights).sort())] : [existing, normalizeKey(index.key)];
+				map.set(k, [...map.get(k) ?? [], index]);
+			}
 		} catch {
 			report.unreadable.push(name);
 			continue;
@@ -48,15 +85,24 @@ async function verifyIndexes(connection, options = {}) {
 		report.modelsChecked += 1;
 		for (const [key, indexOptions] of declared) {
 			const asText = textFields(key);
-			if (asText) {
-				if (existingText.has(JSON.stringify(asText))) continue;
-			} else if (existing.has(normalizeKey(key))) continue;
+			const sameKey = asText ? existingText.get(JSON.stringify(asText)) : existing.get(normalizeKey(key));
 			const entry = {
 				model: name,
 				collection: model.collection.name,
 				key: JSON.stringify(key)
 			};
-			if (indexOptions?.unique) report.missingUnique.push(entry);
+			const opts = indexOptions ?? {};
+			if (sameKey && sameKey.length > 0) {
+				const diffsPerCandidate = sameKey.map((live) => optionDifferences(opts, live));
+				if (diffsPerCandidate.some((d) => d.length === 0)) continue;
+				report.incompatible.push({
+					...entry,
+					unique: opts.unique === true,
+					differences: diffsPerCandidate[0] ?? []
+				});
+				continue;
+			}
+			if (opts.unique === true) report.missingUnique.push(entry);
 			else report.missingRegular.push(entry);
 		}
 	}
@@ -67,7 +113,8 @@ function formatIndexReport(report) {
 	const parts = [
 		`${report.modelsChecked} models checked`,
 		`missing unique: ${report.missingUnique.length}`,
-		`missing regular: ${report.missingRegular.length}`
+		`missing regular: ${report.missingRegular.length}`,
+		`incompatible: ${report.incompatible.length}`
 	];
 	if (report.unreadable.length > 0) parts.push(`unreadable: ${report.unreadable.length}`);
 	return `[index-check] ${parts.join(" — ")}`;

package/dist/join-scope-DSAznE8E.mjs

@@ -0,0 +1,168 @@
+import { t as createError } from "./error-BuByZwKU.mjs";
+import mongoose from "mongoose";
+//#region src/repository/join-scope.ts
+/**
+* Join scope — a joined collection is read under ITS OWN policy, or not at all.
+*
+* Policy plugins (`multiTenantPlugin`, `softDeletePlugin`) declare a scope rule on the MODEL they
+* are bound to, and every repository marks its model governed. {@link scopeJoins} walks a
+* pipeline (nested sub-pipelines and `$facet` branches included) and, for each `$lookup`,
+* `$unionWith` and `$graphLookup`, resolves `from` to the registered models that own that
+* collection, then prepends the union of their rules (fail closed). It REFUSES, with a closed
+* code, a `from` no model owns (the silent-empty-join: a wrong literal matches nothing and raises
+* nothing) and a collection no repository governs. `unscopedJoins` names collections the caller
+* asserts are company-wide; a collection with a declared rule cannot be unscoped that way —
+* `bypassTenant` is the explicit cross-tenant form.
+*/
+const JOIN_ERROR_CODES = {
+	UNKNOWN_COLLECTION: "mongokit.join.unknown_collection",
+	UNGOVERNED_COLLECTION: "mongokit.join.ungoverned_collection",
+	UNSCOPE_REFUSED: "mongokit.join.unscope_refused",
+	UNRESOLVABLE_FROM: "mongokit.join.unresolvable_from"
+};
+const RULES = Symbol.for("@classytic/mongokit/collection-scope-rules");
+const GOVERNED = Symbol.for("@classytic/mongokit/governed-model");
+const TENANT_FIELDS = Symbol.for("@classytic/mongokit/tenant-fields");
+/** Called by a policy plugin at bind: reads of this model's collection carry `rule`. */
+function declareCollectionScope(model, rule, meta = {}) {
+	const holder = model;
+	if (!holder[RULES]) Object.defineProperty(holder, RULES, {
+		value: /* @__PURE__ */ new Set(),
+		enumerable: false
+	});
+	holder[RULES]?.add(rule);
+	if (meta.tenantField) {
+		if (!holder[TENANT_FIELDS]) Object.defineProperty(holder, TENANT_FIELDS, {
+			value: /* @__PURE__ */ new Set(),
+			enumerable: false
+		});
+		holder[TENANT_FIELDS]?.add(meta.tenantField);
+	}
+}
+/** The tenant fields declared on this model by its repositories' tenant plugins. */
+function tenantFieldsOf(model) {
+	return [...model[TENANT_FIELDS] ?? []];
+}
+/** Called by every Repository: this model's scope is known (possibly none). */
+function markGoverned(model) {
+	const holder = model;
+	if (!holder[GOVERNED]) Object.defineProperty(holder, GOVERNED, {
+		value: true,
+		enumerable: false
+	});
+}
+function owners(connection, collection) {
+	return Object.values(connection.models).filter((m) => m.collection?.collectionName === collection);
+}
+function resemblance(connection, from) {
+	const pluralize = mongoose.pluralize();
+	const target = from.toLowerCase();
+	return Object.values(connection.models).filter((m) => {
+		const name = m.modelName.toLowerCase();
+		return name === target || `${name}s` === target || pluralize?.(m.modelName) === target;
+	}).map((m) => `model '${m.modelName}' lives in collection '${m.collection?.collectionName}'`).join("; ");
+}
+/** The predicate a join into `from` must carry, `undefined` for none; throws when unknown. */
+function scopeForCollection(from, env) {
+	if (typeof from !== "string" || from.length === 0) throw createError(500, `[mongokit] a join's 'from' must be a collection name, got ${JSON.stringify(from)}`, {
+		code: JOIN_ERROR_CODES.UNRESOLVABLE_FROM,
+		meta: { from }
+	});
+	const unscoped = env.unscopedJoins?.includes(from) === true;
+	const found = owners(env.connection, from);
+	if (found.length === 0) {
+		if (unscoped) return void 0;
+		const hint = resemblance(env.connection, from);
+		throw createError(500, `[mongokit] join into '${from}': no registered model owns that collection, so the join would match nothing.${hint ? ` Did you mean: ${hint}?` : ""} Take 'from' from Model.collection.name.`, {
+			code: JOIN_ERROR_CODES.UNKNOWN_COLLECTION,
+			meta: {
+				from,
+				suggestion: hint || void 0
+			}
+		});
+	}
+	const governed = found.some((m) => m[GOVERNED] === true);
+	const rules = /* @__PURE__ */ new Set();
+	for (const m of found) for (const r of m[RULES] ?? []) rules.add(r);
+	if (!governed && rules.size === 0) {
+		if (unscoped) return void 0;
+		throw createError(500, `[mongokit] join into '${from}': no repository governs it, so its tenant/soft-delete scope is unknown. Build its repository, or list it in unscopedJoins if it is company-wide.`, {
+			code: JOIN_ERROR_CODES.UNGOVERNED_COLLECTION,
+			meta: {
+				from,
+				models: found.map((m) => m.modelName)
+			}
+		});
+	}
+	const predicates = [];
+	for (const rule of rules) {
+		const p = rule(env.context, env.operation);
+		if (p && Object.keys(p).length > 0) predicates.push(p);
+	}
+	if (predicates.length === 0) return void 0;
+	if (unscoped) throw createError(500, `[mongokit] join into '${from}': it is scoped by its repository and cannot be listed in unscopedJoins. Use bypassTenant for a deliberate cross-tenant read.`, {
+		code: JOIN_ERROR_CODES.UNSCOPE_REFUSED,
+		meta: { from }
+	});
+	return predicates.length === 1 ? predicates[0] : { $and: predicates };
+}
+function scopedPipeline(sub, scope, env) {
+	const walked = walk(Array.isArray(sub) ? sub : [], env);
+	return scope ? [{ $match: scope }, ...walked] : walked;
+}
+/**
+* Return `pipeline` with every join scoped; throws on an unknown or ungoverned `from`. The result
+* is the one documented narrowing of a caller's stage array to mongoose's stage union (stage
+* validity is the server's call); `aggregatePipeline` no longer carries its own.
+*/
+function scopeJoins(pipeline, env) {
+	return walk(pipeline, env);
+}
+function walk(pipeline, env) {
+	return pipeline.map((raw) => {
+		const stage = raw;
+		if (stage.$lookup) {
+			const l = stage.$lookup;
+			if (l.from === void 0) return { $lookup: {
+				...l,
+				pipeline: scopedPipeline(l.pipeline, void 0, env)
+			} };
+			const scope = scopeForCollection(l.from, env);
+			if (!scope && l.pipeline === void 0) return stage;
+			return { $lookup: {
+				...l,
+				pipeline: scopedPipeline(l.pipeline, scope, env)
+			} };
+		}
+		if (stage.$unionWith) {
+			const u = typeof stage.$unionWith === "string" ? { coll: stage.$unionWith } : stage.$unionWith;
+			if (u.coll === void 0) return { $unionWith: {
+				...u,
+				pipeline: scopedPipeline(u.pipeline, void 0, env)
+			} };
+			const scope = scopeForCollection(u.coll, env);
+			if (!scope && u.pipeline === void 0) return stage;
+			return { $unionWith: {
+				...u,
+				pipeline: scopedPipeline(u.pipeline, scope, env)
+			} };
+		}
+		if (stage.$graphLookup) {
+			const g = stage.$graphLookup;
+			const scope = scopeForCollection(g.from, env);
+			if (!scope) return stage;
+			const existing = g.restrictSearchWithMatch;
+			return { $graphLookup: {
+				...g,
+				restrictSearchWithMatch: existing ? { $and: [existing, scope] } : scope
+			} };
+		}
+		if (stage.$facet) {
+			const branches = stage.$facet;
+			return { $facet: Object.fromEntries(Object.entries(branches).map(([k, v]) => [k, walk(v, env)])) };
+		}
+		return stage;
+	});
+}
+//#endregion
+export { scopeJoins as a, scopeForCollection as i, declareCollectionScope as n, tenantFieldsOf as o, markGoverned as r, JOIN_ERROR_CODES as t };

package/dist/{mongooseToJsonSchema-waUVQwK4.mjs → mongooseToJsonSchema-C3k4ide0.mjs}

@@ -46,14 +46,18 @@ function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
 	const jsonCreate = buildJsonSchemaFromPaths(mongooseSchema, options);
 	const jsonUpdate = buildJsonSchemaForUpdate(jsonCreate, options);
 	const jsonResponse = buildJsonSchemaForResponse(mongooseSchema, options);
+	const idPath = mongooseSchema.path("_id");
 	return {
 		createBody: jsonCreate,
 		updateBody: jsonUpdate,
 		params: {
 			type: "object",
-			properties: { id: {
+			properties: { id: idPath === void 0 || isObjectIdInstance(idPath.instance ?? "") ? {
 				type: "string",
 				pattern: "^[0-9a-fA-F]{24}$"
+			} : {
+				type: "string",
+				minLength: 1
 			} },
 			required: ["id"]
 		},

package/dist/{multi-tenant.plugin-B-tzNeYL.d.mts → multi-tenant.plugin-a3UhQARj.d.mts}

@@ -1,5 +1,5 @@
-import { g as ObjectId } from "./pagination-BpIv2bdS.mjs";
-import { l as Plugin, p as RepositoryContext } from "./repository-ZbLtL7Nk.mjs";
+import { A as ObjectId } from "./pagination-D6psses0.mjs";
+import { l as Plugin, p as RepositoryContext } from "./repository-DNHfjAZX.mjs";
 import mongoose, { Connection } from "mongoose";
 import { CacheAdapter as CacheAdapter$1, CacheOptions, RepositoryCacheHandle as RepositoryCacheHandle$1, RepositoryCachePluginOptions, cachePlugin } from "@classytic/repo-core/cache";
 import { TenantConfig } from "@classytic/repo-core/tenant";
@@ -307,6 +307,22 @@ interface CustomIdOptions {
  * });
  */
 declare function getNextSequence(counterKey: string, increment?: number, connection?: mongoose.Connection, session?: mongoose.ClientSession): Promise<number>;
+/**
+ * Current value of a counter, or `null` when it has never been created.
+ * `null` and `0` differ: only a missing counter needs seeding.
+ */
+declare function readSequence(counterKey: string, connection?: mongoose.Connection): Promise<number | null>;
+/**
+ * Raise a counter to at least `floor` — never lowers it. Atomic (`$max` +
+ * upsert), so concurrent seeders converge on the highest floor.
+ *
+ * Use before a counter's first increment when ids were already issued under
+ * another key (e.g. moving from a global to a per-tenant sequence); otherwise
+ * the new counter restarts at 1 and re-issues taken ids.
+ *
+ * @returns The counter's value after the raise.
+ */
+declare function ensureSequenceAtLeast(counterKey: string, floor: number, connection?: mongoose.Connection): Promise<number>;
 interface SequentialIdOptions {
   /** Prefix string (e.g., 'INV', 'ORD') */
   prefix: string;
@@ -638,4 +654,4 @@ declare function adminBypass(options: {
   adminRoles: readonly string[];
 }): (context: RepositoryContext, operation: string) => boolean;
 //#endregion
-export { ensureAuditTrailReady as A, AuditTrailMethods as C, AuditTrailQueryOptions as D, AuditTrailQuery as E, EnsureAuditTrailReadyOptions as O, AuditQueryResult as S, AuditTrailOptions as T, RepositoryCachePluginOptions as _, DateSequentialIdOptions as a, AuditOperation as b, SequentialIdOptions as c, getNextSequence as d, prefixedId as f, RepositoryCacheHandle$1 as g, CacheOptions as h, CustomIdOptions as i, auditTrailPlugin as k, customIdPlugin as l, CacheAdapter$1 as m, adminBypass as n, IdGenerator as o, sequentialId as p, multiTenantPlugin as r, PrefixedIdOptions as s, MultiTenantOptions as t, dateSequentialId as u, cachePlugin as v, AuditTrailMode as w, AuditQueryOptions as x, AuditEntry as y };
+export { EnsureAuditTrailReadyOptions as A, AuditQueryOptions as C, AuditTrailOptions as D, AuditTrailMode as E, ensureAuditTrailReady as M, AuditTrailQuery as O, AuditOperation as S, AuditTrailMethods as T, CacheOptions as _, DateSequentialIdOptions as a, cachePlugin as b, SequentialIdOptions as c, ensureSequenceAtLeast as d, getNextSequence as f, CacheAdapter$1 as g, sequentialId as h, CustomIdOptions as i, auditTrailPlugin as j, AuditTrailQueryOptions as k, customIdPlugin as l, readSequence as m, adminBypass as n, IdGenerator as o, prefixedId as p, multiTenantPlugin as r, PrefixedIdOptions as s, MultiTenantOptions as t, dateSequentialId as u, RepositoryCacheHandle$1 as v, AuditQueryResult as w, AuditEntry as x, RepositoryCachePluginOptions as y };

package/dist/{operations-CrRIoc8Z.d.mts → operations-XiFgG5US.d.mts}

@@ -1,4 +1,4 @@
-import { _ as PopulateSpec, g as ObjectId, i as CountStrategy, r as CollationOptions, v as ReadPreferenceType, x as SortSpec, y as SelectSpec } from "./pagination-BpIv2bdS.mjs";
+import { A as ObjectId, F as SortSpec, M as ReadPreferenceType, N as SelectSpec, b as WriteConcernSpec, i as CountStrategy, j as PopulateSpec, r as CollationOptions, v as ReadConcernLevel } from "./pagination-D6psses0.mjs";
 import { DeleteManyResult, DeleteResult, LookupPopulateResult, UpdateManyResult } from "@classytic/repo-core/repository";
 import { PipelineStage, PopulateOptions } from "mongoose";
 import { Filter } from "@classytic/repo-core/filter";
@@ -312,13 +312,20 @@ interface SessionOptions {
    * substitute for access control — gate it at the host layer.
    */
   bypassAppendOnly?: boolean;
+  /** Write concern for this call; beats `queryDefaults.writeConcern`. Ignored by reads. */
+  writeConcern?: WriteConcernSpec;
   /** Extensible — plugins can read custom fields from options */
   [key: string]: unknown;
 }
-/** Read options — session + readPreference for read-only operations */
+/** Read options. Each field beats the repository and deployment `queryDefaults`. */
 interface ReadOptions extends SessionOptions {
   /** Read preference for replica sets (e.g. 'secondaryPreferred') */
   readPreference?: ReadPreferenceType;
+  /** Server-side time bound for this command. */
+  maxTimeMS?: number;
+  readConcern?: ReadConcernLevel;
+  /** Profiler / log tag. */
+  comment?: string;
 }
 /** Repository operation options */
 interface OperationOptions extends ReadOptions {
@@ -436,21 +443,17 @@ interface FindOneAndUpdateOptions extends OperationOptions {
   runValidators?: boolean;
   /** Collation for locale-aware string comparison. */
   collation?: CollationOptions;
-  /** Maximum execution time in milliseconds. */
-  maxTimeMS?: number;
+  /** Force an index (name or key pattern). */
+  hint?: string | Record<string, 1 | -1>;
 }
 /** Aggregate operation options */
 interface AggregateOptions extends ReadOptions {
   /** Allow aggregation to use disk for large sorts/groups */
   allowDiskUse?: boolean;
-  /** Comment for profiler/logs */
-  comment?: string;
-  /** Maximum execution time in milliseconds */
-  maxTimeMS?: number;
-  /** Read concern level */
-  readConcern?: {
-    level: string;
-  };
+  /** Force an index (name or key pattern). */
+  hint?: string | Record<string, 1 | -1>;
+  /** Collections the caller asserts are company-wide, joinable without a governing repository. */
+  unscopedJoins?: readonly string[];
   /** Collation for locale-aware string comparison */
   collation?: CollationOptions;
   /** Maximum allowed pipeline stages (governance) */
@@ -532,5 +535,25 @@ interface MinMaxResult {
   min: unknown;
   max: unknown;
 }
+/** Kit-native options for the portable `aggregate(req)`; each field beats every default. */
+interface AggregateCallOptions {
+  /** Also return the winning plan (a second command). */
+  explain?: 'queryPlanner' | 'executionStats' | 'allPlansExecution';
+  /** Collections the caller asserts are company-wide (see `join-scope.ts`). */
+  unscopedJoins?: readonly string[];
+  maxTimeMS?: number;
+  readPreference?: ReadPreferenceType;
+  readConcern?: ReadConcernLevel;
+  comment?: string;
+}
+/** `getByIds` options: chunked `$in` reads, optionally aligned with the input order. */
+interface GetByIdsOptions extends OperationOptions {
+  /** Ids per `$in` command. Default `DEFAULT_ID_CHUNK` (10,000). */
+  chunkSize?: number;
+  /** Chunks in flight at once outside a session. Default 4. */
+  concurrency?: number;
+  /** Return `Array<TDoc | undefined>` aligned with the input ids instead of a Map. */
+  preserveOrder?: boolean;
+}
 //#endregion
-export { UpdateOptions as _, CreateOptions as a, LookupOptions as b, FindOneAndUpdateOptions as c, LookupPopulateResult as d, MinMaxResult as f, UpdateManyResult as g, SessionOptions as h, ConvenientTransactionOptions as i, GroupResult as l, ReadOptions as m, CacheOperationOptions as n, DeleteManyResult as o, OperationOptions as p, CacheableOptions as r, DeleteResult as s, AggregateOptions as t, LookupPopulateOptions as u, WithTransactionOptions as v, LookupBuilder as y };
+export { LookupOptions as S, SessionOptions as _, ConvenientTransactionOptions as a, WithTransactionOptions as b, DeleteResult as c, GroupResult as d, LookupPopulateOptions as f, ReadOptions as g, OperationOptions as h, CacheableOptions as i, FindOneAndUpdateOptions as l, MinMaxResult as m, AggregateOptions as n, CreateOptions as o, LookupPopulateResult as p, CacheOperationOptions as r, DeleteManyResult as s, AggregateCallOptions as t, GetByIdsOptions as u, UpdateManyResult as v, LookupBuilder as x, UpdateOptions as y };

package/dist/outbox/index.d.mts

@@ -1,4 +1,4 @@
-import { n as Repository } from "../Repository-IxI983_m.mjs";
+import { r as Repository } from "../Repository-pnLw1rG5.mjs";
 import { Connection, Model } from "mongoose";
 //#region src/outbox/index.d.ts
 /** Delivery states. `dead_letter` is terminal and operator-visible. */

package/dist/outbox/index.mjs

@@ -1,4 +1,4 @@
-import { n as Repository } from "../Repository-D7fDpyFx.mjs";
+import { n as Repository } from "../Repository-CYhSC9ut.mjs";
 import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "../method-registry.plugin-C63pGn1d.mjs";
 import { Schema } from "mongoose";
 //#region src/outbox/index.ts
@@ -172,12 +172,14 @@ function createOutboxModel(connection, options = {}) {
 	*
 	* Mongo rejects `unique` combined with a `sparse: true` + partial filter ("cannot mix"), and
 	* the failure is that the index silently never builds — so duplicate events insert happily
-	* and the outbox's idempotency guarantee is gone with nothing in the logs. Filtering on
-	* `$type: 'string'` indexes only rows that actually carry a key.
+	* and the outbox's idempotency guarantee is gone with nothing in the logs. `$gte: ''` indexes
+	* only rows that carry a string key — the same rows as `$type: 'string'`, but the dedupe
+	* lookup by key can use it (a `$type` filter is never implied by an equality query).
 	*/
 	schema.index({ dedupeKey: 1 }, {
+		name: "dedupeKey_str",
 		unique: true,
-		partialFilterExpression: { dedupeKey: { $type: "string" } }
+		partialFilterExpression: { dedupeKey: { $gte: "" } }
 	});
 	/**
 	* The DEAD-LETTER read. `getDeadLettered` is part of the `OutboxStore` contract and is what

package/dist/pagination/PaginationEngine.d.mts

@@ -1,2 +1,2 @@
-import { t as PaginationEngine } from "../PaginationEngine-D-P19Y9m.mjs";
-export { PaginationEngine };
+import { n as PaginationEngine, t as CountMemoKey } from "../PaginationEngine-CRHyuUtw.mjs";
+export { CountMemoKey, PaginationEngine };

package/dist/pagination/PaginationEngine.mjs

@@ -1,2 +1,2 @@
-import { t as PaginationEngine } from "../PaginationEngine-DQ7beTCR.mjs";
+import { t as PaginationEngine } from "../PaginationEngine-CfT2Cxkj.mjs";
 export { PaginationEngine };

package/dist/pagination/utils/limits.d.mts

@@ -1,4 +1,4 @@
-import { u as PaginationConfig } from "../../pagination-BpIv2bdS.mjs";
+import { u as PaginationConfig } from "../../pagination-D6psses0.mjs";
 //#region src/pagination/utils/limits.d.ts
 /**
  * Validates and sanitizes limit value