@classytic/mongokit 3.14.0 → 3.16.0

package/dist/{PaginationEngine-CfQRM1yz.mjs → PaginationEngine-0XXTW-9b.mjs}

@@ -1,7 +1,7 @@
 import { n as warn } from "./logger-DprijP5h.mjs";
 import { t as createError } from "./error-B00pI7dV.mjs";
-import { n as encodeCursor, r as resolveCursorFilter } from "./cursor-J84rR6wG.mjs";
-import { r as validateKeysetSort, t as getPrimaryField } from "./sort-CrZjTK25.mjs";
+import { n as encodeCursor, r as resolveCursorFilter } from "./cursor-4LMYa4ga.mjs";
+import { r as validateKeysetSort, t as getPrimaryField } from "./sort-RPVz5u0w.mjs";
 //#region src/pagination/utils/index-hint.ts
 /**
 * Read a Mongoose schema's declared indexes, defensively.

package/dist/{Repository-BGL1Pq8w.mjs → Repository-DE7D2QeS.mjs}

@@ -1,15 +1,42 @@
 import { a as count, b as LookupBuilder, c as getByQuery, d as deleteById, f as deleteByQuery, h as createMany, l as getOrCreate, m as create, n as update, o as exists, r as updateByQuery, s as getById, t as findOneAndUpdate, x as compileFilterToMongo, y as distinct } from "./update-BXMnCvO6.mjs";
 import { n as warn } from "./logger-DprijP5h.mjs";
 import { n as isDuplicateKeyError, r as parseDuplicateKeyError, t as createError } from "./error-B00pI7dV.mjs";
-import { t as PaginationEngine } from "./PaginationEngine-CfQRM1yz.mjs";
+import { t as PaginationEngine } from "./PaginationEngine-0XXTW-9b.mjs";
 import { hasNearOperator, rewriteNearForCount } from "./query/primitives/geo.mjs";
-import { r as isValidIdForType, t as getSchemaIdType } from "./id-resolution-B0Odvvou.mjs";
+import { r as isValidIdForType, t as getSchemaIdType } from "./id-resolution-DduoO4LI.mjs";
 import { isFilter } from "@classytic/repo-core/filter";
 import mongoose from "mongoose";
 import { HOOK_PRIORITY } from "@classytic/repo-core/hooks";
-import { RepositoryBase, runChunkedPurge, validatePluginOrder } from "@classytic/repo-core/repository";
+import { RepositoryBase, runChunkedPurge, throwIfAborted, validatePluginOrder, withRetry } from "@classytic/repo-core/repository";
 import { compileUpdateSpecToMongo, isUpdateSpec } from "@classytic/repo-core/update";
 import { decodeAggCursor, encodeAggCursor, isKeysetMode, normalizeGroupBy, validateMeasures } from "@classytic/repo-core/aggregate";
+//#region src/capabilities.ts
+const MONGOKIT_CAPABILITIES = {
+	transactions: true,
+	nestedTransactions: true,
+	upsert: true,
+	duplicateKeyError: true,
+	distinct: true,
+	aggregate: true,
+	aggregateOps: {
+		percentile: true,
+		stddev: true,
+		topN: true,
+		customDateBuckets: true,
+		dateBucketSubMinute: true,
+		cache: true
+	},
+	getOrCreate: true,
+	countAndExists: true,
+	purgeByField: true,
+	arrayOperators: true,
+	regexFilter: true,
+	changeStreams: true,
+	lean: true,
+	lookupPopulate: true,
+	streaming: true
+};
+//#endregion
 //#region src/operations.ts
 /**
 * The registry. Order intentionally groups by category for readability.
@@ -127,6 +154,11 @@ const OP_REGISTRY = {
 		mutates: false,
 		hasIdContext: false
 	},
+	watch: {
+		policyKey: "query",
+		mutates: false,
+		hasIdContext: false
+	},
 	getAll: {
 		policyKey: "filters",
 		mutates: false,
@@ -1649,6 +1681,34 @@ function assertNoMixedPatchShape(opName, patch) {
 	const flatKeys = patchKeys.filter((k) => !k.startsWith("$"));
 	throw createError(400, `[${opName}] assertNoMixedPatchShape: patch mixes Mongo operators (${operatorKeys.join(", ")}) with raw field keys (${flatKeys.join(", ")}). Mongo would silently DROP the flat keys — that's a write-loss bug we refuse to forward. Either wrap the flat keys in $set explicitly, or remove the operator keys.`);
 }
+/** Mongo `operationType` → portable `ChangeEvent.operation`. */
+const CHANGE_OPERATION_MAP = {
+	insert: "create",
+	update: "update",
+	replace: "replace",
+	delete: "delete"
+};
+/**
+* Re-root a compiled Mongo match document under a prefix (`fullDocument`)
+* so a caller filter like `{ status: 'pending' }` matches the change
+* stream's post-image. Logical operators (`$and` / `$or` / `$nor`)
+* recurse; `$`-prefixed top-level operators ($expr etc.) pass through
+* unprefixed — they reference paths explicitly.
+*/
+function prefixMatchPaths(match, prefix) {
+	const out = {};
+	for (const [key, value] of Object.entries(match)) if (key === "$and" || key === "$or" || key === "$nor") out[key] = value.map((clause) => prefixMatchPaths(clause, prefix));
+	else if (key.startsWith("$")) out[key] = value;
+	else out[`${prefix}.${key}`] = value;
+	return out;
+}
+/** Best-available commit timestamp for a change-stream document. */
+function changeEventTimestamp(change) {
+	if (change.wallTime instanceof Date) return change.wallTime;
+	const highBits = change.clusterTime?.getHighBits?.();
+	if (typeof highBits === "number" && highBits > 0) return /* @__PURE__ */ new Date(highBits * 1e3);
+	return /* @__PURE__ */ new Date();
+}
 /**
 * Plugin phase priorities (lower = runs first).
 *
@@ -1673,6 +1733,12 @@ const HOOK_PRIORITY$1 = HOOK_PRIORITY;
 * upgrading from 3.9 need no code changes.
 */
 var Repository = class extends RepositoryBase {
+	/**
+	* Runtime capability descriptor required by `StandardRepo<TDoc>`
+	* (repo-core 0.6.0). Hosts feature-detect once at boot instead of
+	* try/catching `UnsupportedOperationError` per call.
+	*/
+	capabilities = MONGOKIT_CAPABILITIES;
 	Model;
 	/**
 	* Mongoose model name. Duplicated on the instance for BC — arc / catalog /
@@ -1696,7 +1762,10 @@ var Repository = class extends RepositoryBase {
 		super({
 			name: Model.modelName,
 			hooks: options.hooks ?? "async",
-			pluginOrderChecks: "off"
+			pluginOrderChecks: "off",
+			schema: options.schema,
+			updateSchema: options.updateSchema,
+			events: options.events
 		});
 		validatePluginOrder(plugins, Model.modelName, options.pluginOrderChecks ?? "warn", (m) => {
 			warn(m);
@@ -1909,7 +1978,7 @@ var Repository = class extends RepositoryBase {
 	async _runOp(op, context, fn) {
 		return this._composeMiddleware(op, context, async () => {
 			try {
-				const result = await fn();
+				const result = await this._withResilience(context, fn);
 				await this._emitHook(`after:${op}`, {
 					context,
 					result
@@ -1925,6 +1994,28 @@ var Repository = class extends RepositoryBase {
 		});
 	}
 	/**
+	* Resilience envelope around the DRIVER round-trip only — the repo-core
+	* 0.6.0 `QueryOptions.signal` / `QueryOptions.retryPolicy` contract.
+	*
+	* `throwIfAborted` stops a cancelled request before the next driver call;
+	* `withRetry` retries transient failures with exponential backoff (and is
+	* a zero-cost passthrough when no policy was passed, so we wrap
+	* unconditionally). Crucially this wraps `fn` AFTER `_buildContext` ran —
+	* before-hooks (validation, tenant scope, audit, events) execute exactly
+	* once per logical call and are NEVER re-run on retry; only the driver
+	* call repeats.
+	*
+	* Both knobs are read from the context (the options bag is spread into
+	* `_buildContext` inputs), so every op routed through `_runOp` — and the
+	* inline-try methods that call this directly — honors them uniformly.
+	*/
+	_withResilience(context, fn) {
+		const signal = context.signal;
+		const retryPolicy = context.retryPolicy;
+		throwIfAborted(signal);
+		return withRetry(fn, retryPolicy, signal);
+	}
+	/**
 	* Create single document
 	*/
 	async create(data, options = {}) {
@@ -1967,10 +2058,10 @@ var Repository = class extends RepositoryBase {
 			try {
 				const effectiveIdField = options.idField ?? this.idField;
 				if (effectiveIdField !== "_id") {
-					const result = await getByQuery(this.Model, {
+					const result = await this._withResilience(context, () => getByQuery(this.Model, {
 						[effectiveIdField]: id,
 						...context.query || {}
-					}, context);
+					}, context));
 					await this._emitHook("after:getById", {
 						context,
 						result
@@ -1982,7 +2073,7 @@ var Repository = class extends RepositoryBase {
 					if (wantsThrow) throw createError(404, "Document not found");
 					return null;
 				}
-				const result = await getById(this.Model, id, context);
+				const result = await this._withResilience(context, () => getById(this.Model, id, context));
 				if (!result && wantsThrow) throw createError(404, "Document not found");
 				await this._emitHook("after:getById", {
 					context,
@@ -2047,7 +2138,7 @@ var Repository = class extends RepositoryBase {
 			}
 			const finalQuery = context.query || query;
 			try {
-				const result = await getByQuery(this.Model, finalQuery, context);
+				const result = await this._withResilience(context, () => getByQuery(this.Model, finalQuery, context));
 				await this._emitHook("after:getOne", {
 					context,
 					result
@@ -2155,6 +2246,135 @@ var Repository = class extends RepositoryBase {
 		}
 	}
 	/**
+	* Portable change feed — `StandardRepo.watch()` over Mongo change
+	* streams (`Model.watch`). Requires a replica set (or mongos); a
+	* standalone mongod rejects change streams at open time — gate on
+	* `repo.capabilities.changeStreams` plus your deployment topology.
+	*
+	* Semantics:
+	*   - **Plugin-routed like every other read.** The filter goes through
+	*     the standard `before:watch` hook pipeline (`OP_REGISTRY.watch`,
+	*     policyKey `'query'`) BEFORE the change-stream pipeline is built —
+	*     `multiTenantPlugin` injects the tenant scope (and throws under
+	*     `required: true` exactly like other reads), `softDeletePlugin`
+	*     injects the deletion-state predicate. A tenant-scoped repo never
+	*     streams cross-tenant changes.
+	*   - `fullDocument: 'updateLookup'` — update events carry the post-
+	*     image document when it still exists at lookup time.
+	*   - `filter` (record or Filter IR) is compiled with the standard
+	*     filter compiler and applied against `fullDocument.*` paths, so
+	*     `watch({ status: 'pending' })` matches the post-image. Delete
+	*     events have no `fullDocument` and therefore don't match a
+	*     non-empty post-policy filter — use `bypassTenant` / an unscoped
+	*     repo without a filter to observe deletes.
+	*   - `options.signal` ends the iterator (closes the stream). A
+	*     pre-aborted signal rejects at the op boundary like every other op.
+	*   - `options.resumeAfter` forwards a previously captured Mongo
+	*     resume token for at-least-once consumption across restarts.
+	*
+	* Context keys for policy plugins (`organizationId`, `bypassTenant`,
+	* `includeDeleted`, ...) ride the options bag at runtime — same as every
+	* other op. The contract's `WatchOptions` type doesn't declare an index
+	* signature, so typed callers widen at the call site (or rely on an
+	* ALS `resolveContext` so no per-call tenant key is needed).
+	*
+	* @example
+	* ```ts
+	* const ac = new AbortController();
+	* for await (const change of repo.watch({ status: 'pending' }, { signal: ac.signal })) {
+	*   if (change.operation === 'create') enqueue(change.doc!);
+	* }
+	* ```
+	*/
+	async *watch(filter, options = {}) {
+		const context = await this._buildContext("watch", {
+			query: filter ?? {},
+			...options
+		});
+		const pipeline = [{ $match: { operationType: { $in: [
+			"insert",
+			"update",
+			"replace",
+			"delete"
+		] } } }];
+		const compiled = compileFilterToMongo(context.query ?? {});
+		if (Object.keys(compiled).length > 0) pipeline.push({ $match: prefixMatchPaths(compiled, "fullDocument") });
+		const stream = this.Model.watch(pipeline, {
+			fullDocument: "updateLookup",
+			...options.resumeAfter !== void 0 ? { resumeAfter: options.resumeAfter } : {}
+		});
+		const queue = [];
+		let streamError = null;
+		let ended = false;
+		let notify = null;
+		const wake = () => {
+			const resolve = notify;
+			notify = null;
+			resolve?.();
+		};
+		const onChange = (change) => {
+			queue.push(change);
+			wake();
+		};
+		const onError = (error) => {
+			streamError = error;
+			wake();
+		};
+		const onClose = () => {
+			ended = true;
+			wake();
+		};
+		stream.on("change", onChange);
+		stream.on("error", onError);
+		stream.on("close", onClose);
+		const closeStream = async () => {
+			try {
+				await stream.close();
+			} catch {}
+		};
+		const signal = options.signal;
+		const onAbort = () => {
+			ended = true;
+			wake();
+			closeStream();
+		};
+		try {
+			if (signal) {
+				if (signal.aborted) return;
+				signal.addEventListener("abort", onAbort, { once: true });
+			}
+			while (true) {
+				if (signal?.aborted) return;
+				const change = queue.shift();
+				if (change) {
+					const operation = CHANGE_OPERATION_MAP[change.operationType];
+					if (!operation) continue;
+					yield {
+						operation,
+						id: change.documentKey?._id,
+						...change.fullDocument !== void 0 ? { doc: change.fullDocument } : {},
+						timestamp: changeEventTimestamp(change)
+					};
+					continue;
+				}
+				if (streamError) {
+					if (signal?.aborted) return;
+					throw streamError;
+				}
+				if (ended) return;
+				await new Promise((resolve) => {
+					notify = resolve;
+				});
+			}
+		} finally {
+			if (signal) signal.removeEventListener("abort", onAbort);
+			stream.removeListener("change", onChange);
+			stream.removeListener("error", onError);
+			stream.removeListener("close", onClose);
+			await closeStream();
+		}
+	}
+	/**
 	* Unified pagination - auto-detects offset vs keyset based on params
 	*
 	* Auto-detection logic:
@@ -2428,11 +2648,11 @@ var Repository = class extends RepositoryBase {
 					}
 				}
 				let result;
-				if (effectiveIdField !== "_id") result = await updateByQuery(this.Model, {
+				if (effectiveIdField !== "_id") result = await this._withResilience(context, () => updateByQuery(this.Model, {
 					[effectiveIdField]: id,
 					...context.query || {}
-				}, context.data || data, context);
-				else result = await update(this.Model, id, context.data || data, context);
+				}, context.data || data, context));
+				else result = await this._withResilience(context, () => update(this.Model, id, context.data || data, context));
 				if (!result && wantsThrow) throw createError(404, "Document not found");
 				await this._emitHook("after:update", {
 					context,
@@ -2903,10 +3123,10 @@ var Repository = class extends RepositoryBase {
 					[effectiveIdField]: id,
 					...context.query || {}
 				} : void 0;
-				const result = deleteQuery ? await deleteByQuery(this.Model, deleteQuery, { session: options.session }) : await deleteById(this.Model, id, {
+				const result = await this._withResilience(context, () => deleteQuery ? deleteByQuery(this.Model, deleteQuery, { session: options.session }) : deleteById(this.Model, id, {
 					session: options.session,
 					query: context.query
-				});
+				}));
 				if (!result && wantsThrow) throw createError(404, "Document not found");
 				await this._emitHook("after:delete", {
 					context,
@@ -2999,7 +3219,7 @@ var Repository = class extends RepositoryBase {
 				}
 				const finalQuery = context.query || filter;
 				if (!finalQuery || Object.keys(finalQuery).length === 0) throw createError(400, "deleteMany requires a non-empty query filter after policy hooks.");
-				const result = await this.Model.deleteMany(finalQuery, { session: options.session }).exec();
+				const result = await this._withResilience(context, () => this.Model.deleteMany(finalQuery, { session: options.session }).exec());
 				await this._emitHook("after:deleteMany", {
 					context,
 					result
@@ -3394,9 +3614,9 @@ var Repository = class extends RepositoryBase {
 				};
 				if (isKeyset && sort) {
 					const parsedSort = this._parseSort(sort);
-					const { validateKeysetSort } = await import("./sort-CrZjTK25.mjs").then((n) => n.n);
-					const { encodeCursor, resolveCursorFilter } = await import("./cursor-J84rR6wG.mjs").then((n) => n.t);
-					const { getPrimaryField } = await import("./sort-CrZjTK25.mjs").then((n) => n.n);
+					const { validateKeysetSort } = await import("./sort-RPVz5u0w.mjs").then((n) => n.n);
+					const { encodeCursor, resolveCursorFilter } = await import("./cursor-4LMYa4ga.mjs").then((n) => n.t);
+					const { getPrimaryField } = await import("./sort-RPVz5u0w.mjs").then((n) => n.n);
 					const normalizedSort = validateKeysetSort(parsedSort, this._pagination.config.strictKeysetSortFields);
 					const cursorVersion = this._pagination.config.cursorVersion ?? 1;
 					const minCursorVersion = this._pagination.config.minCursorVersion ?? 1;
@@ -3621,6 +3841,7 @@ var Repository = class extends RepositoryBase {
 	* 4. DEFAULT (500) — user-registered hooks
 	*/
 	async _buildContext(operation, options) {
+		throwIfAborted(options.signal);
 		const normalized = this._normalizeFilterSlots(options);
 		return await super._buildContext(operation, normalized);
 	}
@@ -3795,4 +4016,4 @@ var Repository = class extends RepositoryBase {
 	}
 };
 //#endregion
-export { withTransaction as a, MUTATING_OPERATIONS as c, operationsByPolicyKey as d, isTransactionUnsupported as i, OP_REGISTRY as l, Repository as n, AggregationBuilder as o, batchTransaction as r, ALL_OPERATIONS as s, HOOK_PRIORITY$1 as t, READ_OPERATIONS as u };
+export { withTransaction as a, MUTATING_OPERATIONS as c, operationsByPolicyKey as d, MONGOKIT_CAPABILITIES as f, isTransactionUnsupported as i, OP_REGISTRY as l, Repository as n, AggregationBuilder as o, batchTransaction as r, ALL_OPERATIONS as s, HOOK_PRIORITY$1 as t, READ_OPERATIONS as u };

package/dist/actions/index.d.mts

@@ -1,2 +1,2 @@
-import { a as create_d_exports, i as delete_d_exports, n as update_d_exports, o as aggregate_d_exports, r as read_d_exports } from "../index-Dccha9dw.mjs";
+import { a as create_d_exports, i as delete_d_exports, n as update_d_exports, o as aggregate_d_exports, r as read_d_exports } from "../index-CV5vv-8E.mjs";
 export { aggregate_d_exports as aggregate, create_d_exports as create, delete_d_exports as deleteActions, read_d_exports as read, update_d_exports as update };

package/dist/ai/index.d.mts

@@ -1,4 +1,4 @@
-import { G as Plugin } from "../types-BbaPZleN.mjs";
+import { G as Plugin } from "../types-BWZILovv.mjs";
 import { PipelineStage } from "mongoose";
 
 //#region src/ai/types.d.ts

package/dist/ai/index.mjs

@@ -269,7 +269,9 @@ function vectorPlugin(options) {
 		name: "vector",
 		apply(repo) {
 			if (!repo.registerMethod) throw new Error("[mongokit] vectorPlugin requires methodRegistryPlugin");
+			let vectorSearchUnavailable = null;
 			repo.registerMethod("searchSimilar", async function searchSimilar(params) {
+				if (vectorSearchUnavailable) throw vectorSearchUnavailable;
 				const field = resolveField(fields, params.field);
 				let queryVector;
 				if (Array.isArray(params.query)) queryVector = params.query;
@@ -281,11 +283,18 @@ function vectorPlugin(options) {
 				const pipeline = buildVectorSearchPipeline(field, queryVector, params);
 				const agg = repo.Model.aggregate(pipeline);
 				if (params.session) agg.session(params.session);
-				return (await withVectorErrorHints(() => agg.exec(), {
-					indexName: field.index,
-					dimensions: field.dimensions,
-					filterPaths: params.filter ? Object.keys(params.filter) : void 0
-				})).map((doc) => {
+				let results;
+				try {
+					results = await withVectorErrorHints(() => agg.exec(), {
+						indexName: field.index,
+						dimensions: field.dimensions,
+						filterPaths: params.filter ? Object.keys(params.filter) : void 0
+					});
+				} catch (err) {
+					if (err.code === "NOT_ATLAS") vectorSearchUnavailable = err;
+					throw err;
+				}
+				return results.map((doc) => {
 					const score = doc._score ?? 0;
 					const { _score, ...rest } = doc;
 					return {

package/dist/better-auth/index.d.mts

@@ -119,6 +119,21 @@ interface BetterAuthOverlayOptions<TDoc = Record<string, unknown>> {
    * Subclass `Repository<TDoc>` to add domain methods (e.g. `getByEmail`,
    * `deactivate`, `getAdmins`). When omitted, the default `Repository<TDoc>`
    * is used — the standard CRUD surface is already complete.
+   *
+   * **Plugin composition warning.** The default overlay repo is built with
+   * NO plugins, deliberately:
+   *
+   *   - **Do NOT apply `multiTenantPlugin` to BA overlays.** Better Auth's
+   *     tables are global by design — `user`, `session`, `account`,
+   *     `verification` have no tenant column at all, and `member` /
+   *     `invitation` carry `organizationId` under BA's OWN semantics
+   *     (membership rows, not tenant-scoped data). A tenant plugin with
+   *     `required: true` would break every read; scope BA queries with
+   *     explicit filters (`{ organizationId }`) at the call site instead.
+   *   - **`cachePlugin` is safe only because the data is global** — if you
+   *     wire it in a custom `RepositoryClass`, remember BA's own writes go
+   *     through BA's driver and will NOT invalidate mongokit's cache. Use
+   *     short TTLs or skip caching BA collections entirely.
    */
   RepositoryClass?: new (Model: ReturnType<MongooseLike['model']>) => RepositoryLike<TDoc>;
   /**
@@ -145,5 +160,44 @@ interface BetterAuthOverlayOptions<TDoc = Record<string, unknown>> {
  *         would silently drop this call's `additionalFields` / `indexes`).
  */
 declare function createBetterAuthOverlay<TDoc = Record<string, unknown>>(options: BetterAuthOverlayOptions<TDoc>): Promise<DataAdapter<TDoc>>;
+/**
+ * Minimal structural surface for the one write we need. Satisfied by BOTH a
+ * native MongoDB `Collection` (`db.collection('session')`) and a Mongoose
+ * `Model` — so the host passes whichever it has, and mongokit keeps mongoose +
+ * the mongodb driver as peer deps with zero runtime import.
+ */
+interface SessionUpdaterLike {
+  updateMany(filter: Record<string, unknown>, update: Record<string, unknown>): Promise<{
+    modifiedCount?: number;
+  }>;
+}
+/**
+ * Clear a dangling `activeOrganizationId` from Better Auth `session` rows.
+ *
+ * WHY THIS EXISTS: Better Auth purges its `member` / `invitation` rows when an
+ * org is deleted (or a member removed), but it NEVER clears
+ * `session.activeOrganizationId`. A session left pointing at an org the user is
+ * no longer a member of makes `organization.getActiveMember()` return
+ * `MEMBER_NOT_FOUND`, and any frontend that trusts that stale pointer hangs —
+ * amplified by `session.cookieCache`, which serves the dead pointer for minutes.
+ *
+ * This is intentionally a host-invoked helper, NOT part of the arc org-delete
+ * cascade: arc is DB-agnostic (it purges through `@classytic/repo-core`
+ * adapters and must not reach a raw collection), whereas the `session`
+ * collection is a Better-Auth/mongo concern this kit already owns. Hosts wire
+ * it into their `organizationHooks`:
+ *   - `afterDeleteOrganization` → org-wide (omit `userId`)
+ *   - `afterRemoveMember`       → one user (pass `userId`)
+ *
+ * The mongodb adapter stores `activeOrganizationId` as a STRING, so the org id
+ * is matched as-is (no ObjectId construction). `session.userId` is an ObjectId,
+ * so for the member-removal path pass `userId` already in the form your driver
+ * compares against (a constructed ObjectId) — it's matched verbatim.
+ *
+ * @returns the number of sessions whose pointer was cleared.
+ */
+declare function clearActiveOrganizationFromSessions(sessions: SessionUpdaterLike, organizationId: string, options?: {
+  userId?: unknown;
+}): Promise<number>;
 //#endregion
-export { BetterAuthInstance, BetterAuthOverlayOptions, type BetterAuthPluginKey, MongooseLike, RegisterBetterAuthStubsOptions, createBetterAuthOverlay, registerBetterAuthStubs };
+export { BetterAuthInstance, BetterAuthOverlayOptions, type BetterAuthPluginKey, MongooseLike, RegisterBetterAuthStubsOptions, SessionUpdaterLike, clearActiveOrganizationFromSessions, createBetterAuthOverlay, registerBetterAuthStubs };

package/dist/better-auth/index.mjs

@@ -1,4 +1,4 @@
-import { n as Repository } from "../Repository-BGL1Pq8w.mjs";
+import { n as Repository } from "../Repository-DE7D2QeS.mjs";
 import { n as createMongooseAdapter } from "../adapter-gG_uyFSZ.mjs";
 import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@classytic/repo-core/better-auth";
 //#region src/better-auth/index.ts
@@ -77,5 +77,35 @@ async function createBetterAuthOverlay(options) {
 		schemaGenerator
 	});
 }
+/**
+* Clear a dangling `activeOrganizationId` from Better Auth `session` rows.
+*
+* WHY THIS EXISTS: Better Auth purges its `member` / `invitation` rows when an
+* org is deleted (or a member removed), but it NEVER clears
+* `session.activeOrganizationId`. A session left pointing at an org the user is
+* no longer a member of makes `organization.getActiveMember()` return
+* `MEMBER_NOT_FOUND`, and any frontend that trusts that stale pointer hangs —
+* amplified by `session.cookieCache`, which serves the dead pointer for minutes.
+*
+* This is intentionally a host-invoked helper, NOT part of the arc org-delete
+* cascade: arc is DB-agnostic (it purges through `@classytic/repo-core`
+* adapters and must not reach a raw collection), whereas the `session`
+* collection is a Better-Auth/mongo concern this kit already owns. Hosts wire
+* it into their `organizationHooks`:
+*   - `afterDeleteOrganization` → org-wide (omit `userId`)
+*   - `afterRemoveMember`       → one user (pass `userId`)
+*
+* The mongodb adapter stores `activeOrganizationId` as a STRING, so the org id
+* is matched as-is (no ObjectId construction). `session.userId` is an ObjectId,
+* so for the member-removal path pass `userId` already in the form your driver
+* compares against (a constructed ObjectId) — it's matched verbatim.
+*
+* @returns the number of sessions whose pointer was cleared.
+*/
+async function clearActiveOrganizationFromSessions(sessions, organizationId, options) {
+	const filter = { activeOrganizationId: organizationId };
+	if (options?.userId != null) filter.userId = options.userId;
+	return (await sessions.updateMany(filter, { $set: { activeOrganizationId: null } })).modifiedCount ?? 0;
+}
 //#endregion
-export { createBetterAuthOverlay, registerBetterAuthStubs };
+export { clearActiveOrganizationFromSessions, createBetterAuthOverlay, registerBetterAuthStubs };

package/dist/{index-Dccha9dw.d.mts → index-CV5vv-8E.d.mts}

@@ -1,4 +1,4 @@
-import { B as ObjectId, Dt as LookupOptions, H as OperationOptions, I as MinMaxResult, J as PopulateSpec, T as GroupResult, Z as ReadPreferenceType, ft as UpdateManyResult, ht as UpdateWithValidationResult, i as AnyDocument, it as SelectSpec, p as CreateOptions, pt as UpdateOptions, ut as SortSpec, v as DeleteResult, w as FindOneAndUpdateOptions } from "./types-BbaPZleN.mjs";
+import { B as ObjectId, Dt as LookupOptions, H as OperationOptions, I as MinMaxResult, J as PopulateSpec, T as GroupResult, Z as ReadPreferenceType, ft as UpdateManyResult, ht as UpdateWithValidationResult, i as AnyDocument, it as SelectSpec, p as CreateOptions, pt as UpdateOptions, ut as SortSpec, v as DeleteResult, w as FindOneAndUpdateOptions } from "./types-BWZILovv.mjs";
 import { Model, PipelineStage } from "mongoose";
 
 //#region src/actions/aggregate.d.ts