@classytic/mongokit 3.12.0 → 3.13.1

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-D9cORR-o.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-BbHaKwi5.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/actions/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
-import { g as create_exports, i as update_exports, p as delete_exports, u as read_exports, v as aggregate_exports } from "../update-CDxPtpsk.mjs";
+import { g as create_exports, i as update_exports, p as delete_exports, u as read_exports, v as aggregate_exports } from "../update-C-3viiw1.mjs";
 //#region src/actions/index.ts
 var actions_exports = /* @__PURE__ */ __exportAll({
 	aggregate: () => aggregate_exports,

package/dist/adapter/index.d.mts

@@ -0,0 +1,190 @@
+import { Document, Model } from "mongoose";
+import { StandardRepo } from "@classytic/repo-core/repository";
+import { SchemaBuilderOptions, SchemaGenerator } from "@classytic/repo-core/schema";
+import { AdapterRepositoryInput, AdapterSchemaContext, AdapterValidationResult, DataAdapter, OpenApiSchemas, RepositoryLike, SchemaMetadata } from "@classytic/repo-core/adapter";
+
+//#region src/adapter/mongoose-adapter.d.ts
+/**
+ * Options for creating a Mongoose adapter.
+ *
+ * `TDoc` is auto-inferred from the Mongoose model — no explicit type
+ * needed in most call sites.
+ */
+interface MongooseAdapterOptions<TDoc = unknown> {
+  /** Mongoose model instance — preserves document type for type safety. */
+  model: Model<TDoc>;
+  /**
+   * Repository implementing CRUD operations.
+   *
+   * Typed as `AdapterRepositoryInput<TDoc>` (permissive structural shape)
+   * so kit-native repository classes plug in directly. See
+   * `AdapterRepositoryInput` JSDoc in `@classytic/repo-core/adapter` for
+   * why the wider input exists at the boundary.
+   */
+  repository: AdapterRepositoryInput<TDoc>;
+  /**
+   * External schema generator plugin for OpenAPI / introspection docs.
+   * When provided, the adapter delegates schema generation to it.
+   *
+   * **Model type is intentionally `Model<unknown>`, not `Model<TDoc>`**:
+   * schema generators introspect `.schema.paths` — they read metadata,
+   * not document types. Typing as `Model<TDoc>` would force every host
+   * to cast `m as unknown as Model<unknown>` when handing the model to
+   * `buildCrudSchemasFromModel`, because `Model<T>` is invariant in T.
+   * Widening here at the callback boundary trades one documented internal
+   * cast for zero host-side casts.
+   *
+   * @example
+   * ```ts
+   * import { buildCrudSchemasFromModel, createMongooseAdapter } from '@classytic/mongokit';
+   * import { createMongooseAdapter as fromAdapterSubpath } from '@classytic/mongokit/adapter';
+   *
+   * createMongooseAdapter({
+   *   model: ProductModel,
+   *   repository: productRepository,
+   *   schemaGenerator: buildCrudSchemasFromModel,
+   * });
+   * ```
+   */
+  schemaGenerator?: SchemaGenerator<Model<unknown>>;
+}
+/**
+ * Mongoose data adapter — implements the `DataAdapter<TDoc>` contract from
+ * `@classytic/repo-core/adapter`.
+ */
+declare class MongooseAdapter<TDoc = unknown> implements DataAdapter<TDoc> {
+  readonly type: "mongoose";
+  readonly name: string;
+  readonly model: Model<TDoc>;
+  readonly repository: RepositoryLike<TDoc>;
+  private readonly schemaGenerator?;
+  constructor(options: MongooseAdapterOptions<TDoc>);
+  /**
+   * Lightweight path-existence check for hosts that infer absent fields
+   * (e.g. arc's `defineResource()` infers `tenantField: false` when the
+   * configured tenant field doesn't exist on the model). Reads
+   * `model.schema.paths[name]` directly — no allocation, no metadata walk.
+   */
+  hasFieldPath(name: string): boolean;
+  /**
+   * Get schema metadata from a Mongoose model.
+   */
+  getSchemaMetadata(): SchemaMetadata;
+  /**
+   * Generate OpenAPI-shaped schemas from the model.
+   *
+   * Delegates to the `schemaGenerator` callback supplied at construction.
+   * Returns `null` when no callback is configured — hosts treat that as
+   * "no schemas available" and skip OpenAPI generation for the resource.
+   *
+   * Most call sites pass mongokit's own `buildCrudSchemasFromModel`:
+   *
+   * ```ts
+   * createMongooseAdapter({
+   *   model,
+   *   repository,
+   *   schemaGenerator: buildCrudSchemasFromModel,
+   * });
+   * ```
+   */
+  generateSchemas(schemaOptions?: SchemaBuilderOptions, context?: AdapterSchemaContext): OpenApiSchemas | Record<string, unknown> | null;
+  /**
+   * Default `validate` — kits typically override or hosts skip this since
+   * Mongoose enforces validation at save time. Provided for adapter-
+   * contract completeness so consumers that branch on `adapter.validate`
+   * find a no-op success path.
+   */
+  validate(_data: unknown): AdapterValidationResult;
+  /**
+   * Extract relation metadata from Mongoose ref paths.
+   *
+   * Cardinality rules:
+   *   - `field: { type: ObjectId, ref }`  → one-to-one (single ref)
+   *   - `field: [{ type: ObjectId, ref }]` → one-to-many (array of refs)
+   *
+   * Mongoose surfaces array paths with `instance === 'Array'` and a
+   * `caster` SchemaType holding the element-side metadata (including the
+   * `ref` and inner instance). Reading the caster lets us distinguish
+   * one-to-many from a scalar-array path that just happens to declare
+   * something else. Pre-3.12.x this method always returned `'one-to-one'`
+   * regardless of cardinality — wrong metadata for OpenAPI / docs hosts.
+   */
+  private extractRelations;
+}
+/**
+ * Create a Mongoose adapter — produces a framework-agnostic
+ * `DataAdapter<TDoc>` that any host consuming
+ * `@classytic/repo-core/adapter` can wire in.
+ *
+ * Two call shapes:
+ *
+ * ```ts
+ * // Object form (explicit)
+ * const adapter = createMongooseAdapter({
+ *   model: ProductModel,
+ *   repository: productRepository,
+ *   schemaGenerator: buildCrudSchemasFromModel,
+ * });
+ *
+ * // Shorthand form (2-arg) — most common path
+ * const adapter = createMongooseAdapter(ProductModel, productRepository);
+ * ```
+ */
+declare function createMongooseAdapter<TDoc = unknown>(model: Model<TDoc>, repository: AdapterRepositoryInput<TDoc>): DataAdapter<TDoc>;
+declare function createMongooseAdapter<TDoc = unknown>(options: MongooseAdapterOptions<TDoc>): DataAdapter<TDoc>;
+//#endregion
+//#region src/adapter/types.d.ts
+/**
+ * Infer document type from a Mongoose model.
+ *
+ * @example
+ * const ProductModel = mongoose.model('Product', productSchema);
+ * type ProductDoc = InferMongooseDoc<typeof ProductModel>;
+ */
+type InferMongooseDoc<M> = M extends Model<infer D> ? D : never;
+/**
+ * Infer document type from a `Repository<TDoc>` / `StandardRepo<TDoc>`.
+ */
+type InferRepoDoc<R> = R extends StandardRepo<infer D> ? D : never;
+/**
+ * Infer document type from a `DataAdapter`.
+ */
+type InferAdapterDoc<A> = A extends {
+  repository: StandardRepo<infer D>;
+} ? D : never;
+/**
+ * Strip Mongoose-specific surface from a hydrated document type.
+ */
+type CleanDoc<T> = T extends Document ? Omit<T, keyof Document | '_id' | '__v' | '$__' | '$isNew' | 'save' | 'remove'> : T;
+/**
+ * Mongoose document with index signature — usable as a generic constraint.
+ */
+type MongooseDocument = Document & Record<string, unknown>;
+/**
+ * Pin a Mongoose model's document type to match a repository's document type.
+ */
+type MatchingModel<TDoc> = Model<TDoc & Document>;
+/**
+ * Runtime guard: is `value` a Mongoose model?
+ */
+declare function isMongooseModel(value: unknown): value is Model<Document>;
+/**
+ * Mongoose SchemaType internal shape (not fully exposed by `@types/mongoose`).
+ * Used to extract field metadata from schema paths.
+ */
+interface MongooseSchemaType {
+  instance: string;
+  isRequired?: boolean;
+  options?: {
+    ref?: string;
+    enum?: Array<string | number>;
+    minlength?: number;
+    maxlength?: number;
+    min?: number;
+    max?: number;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+//#endregion
+export { type CleanDoc, type InferAdapterDoc, type InferMongooseDoc, type InferRepoDoc, type MatchingModel, MongooseAdapter, type MongooseAdapterOptions, type MongooseDocument, type MongooseSchemaType, createMongooseAdapter, isMongooseModel };

package/dist/adapter/index.mjs

@@ -0,0 +1,2 @@
+import { n as createMongooseAdapter, r as isMongooseModel, t as MongooseAdapter } from "../adapter-DTDMnUOH.mjs";
+export { MongooseAdapter, createMongooseAdapter, isMongooseModel };

package/dist/adapter-DTDMnUOH.mjs

@@ -0,0 +1,158 @@
+import { n as warn } from "./logger-DprijP5h.mjs";
+import { mergeFieldRuleConstraints } from "@classytic/repo-core/schema";
+import { asRepositoryLike, isRepository } from "@classytic/repo-core/adapter";
+//#region src/adapter/types.ts
+/**
+* Runtime guard: is `value` a Mongoose model?
+*/
+function isMongooseModel(value) {
+	return typeof value === "function" && value.prototype && "modelName" in value && "schema" in value;
+}
+//#endregion
+//#region src/adapter/mongoose-adapter.ts
+/**
+* Mongoose data adapter — implements the `DataAdapter<TDoc>` contract from
+* `@classytic/repo-core/adapter`.
+*/
+var MongooseAdapter = class {
+	type = "mongoose";
+	name;
+	model;
+	repository;
+	schemaGenerator;
+	constructor(options) {
+		if (!isMongooseModel(options.model)) throw new TypeError("MongooseAdapter: Invalid model. Expected Mongoose Model instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
+		if (!isRepository(options.repository)) throw new TypeError("MongooseAdapter: Invalid repository. Expected MinimalRepo instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
+		this.model = options.model;
+		this.repository = asRepositoryLike(options.repository);
+		this.schemaGenerator = options.schemaGenerator;
+		this.name = `MongooseAdapter<${options.model.modelName}>`;
+	}
+	/**
+	* Lightweight path-existence check for hosts that infer absent fields
+	* (e.g. arc's `defineResource()` infers `tenantField: false` when the
+	* configured tenant field doesn't exist on the model). Reads
+	* `model.schema.paths[name]` directly — no allocation, no metadata walk.
+	*/
+	hasFieldPath(name) {
+		return Boolean(this.model.schema?.paths?.[name]);
+	}
+	/**
+	* Get schema metadata from a Mongoose model.
+	*/
+	getSchemaMetadata() {
+		const paths = this.model.schema.paths;
+		const fields = {};
+		for (const [fieldName, schemaType] of Object.entries(paths)) {
+			if (fieldName.startsWith("_") && fieldName !== "_id") continue;
+			const typeInfo = schemaType;
+			fields[fieldName] = {
+				type: {
+					String: "string",
+					Number: "number",
+					Boolean: "boolean",
+					Date: "date",
+					ObjectID: "objectId",
+					ObjectId: "objectId",
+					Array: "array",
+					Mixed: "object",
+					Buffer: "object",
+					Embedded: "object"
+				}[typeInfo.instance || "Mixed"] ?? "object",
+				required: !!typeInfo.isRequired,
+				ref: typeInfo.options?.ref
+			};
+		}
+		return {
+			name: this.model.modelName,
+			fields,
+			relations: this.extractRelations(paths)
+		};
+	}
+	/**
+	* Generate OpenAPI-shaped schemas from the model.
+	*
+	* Delegates to the `schemaGenerator` callback supplied at construction.
+	* Returns `null` when no callback is configured — hosts treat that as
+	* "no schemas available" and skip OpenAPI generation for the resource.
+	*
+	* Most call sites pass mongokit's own `buildCrudSchemasFromModel`:
+	*
+	* ```ts
+	* createMongooseAdapter({
+	*   model,
+	*   repository,
+	*   schemaGenerator: buildCrudSchemasFromModel,
+	* });
+	* ```
+	*/
+	generateSchemas(schemaOptions, context) {
+		if (!this.schemaGenerator) return null;
+		try {
+			const generated = this.schemaGenerator(this.model, schemaOptions, context);
+			mergeFieldRuleConstraints(generated, schemaOptions);
+			return generated;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			warn(`[MongooseAdapter:${this.model.modelName}] schemaGenerator threw — schema generation skipped: ${message}`);
+			return null;
+		}
+	}
+	/**
+	* Default `validate` — kits typically override or hosts skip this since
+	* Mongoose enforces validation at save time. Provided for adapter-
+	* contract completeness so consumers that branch on `adapter.validate`
+	* find a no-op success path.
+	*/
+	validate(_data) {
+		return { valid: true };
+	}
+	/**
+	* Extract relation metadata from Mongoose ref paths.
+	*
+	* Cardinality rules:
+	*   - `field: { type: ObjectId, ref }`  → one-to-one (single ref)
+	*   - `field: [{ type: ObjectId, ref }]` → one-to-many (array of refs)
+	*
+	* Mongoose surfaces array paths with `instance === 'Array'` and a
+	* `caster` SchemaType holding the element-side metadata (including the
+	* `ref` and inner instance). Reading the caster lets us distinguish
+	* one-to-many from a scalar-array path that just happens to declare
+	* something else. Pre-3.12.x this method always returned `'one-to-one'`
+	* regardless of cardinality — wrong metadata for OpenAPI / docs hosts.
+	*/
+	extractRelations(paths) {
+		const relations = {};
+		for (const [fieldName, schemaType] of Object.entries(paths)) {
+			const path = schemaType;
+			if (path.instance === "Array") {
+				const elementRef = path.embeddedSchemaType?.options?.ref ?? path.caster?.options?.ref ?? path.options?.ref;
+				if (elementRef) relations[fieldName] = {
+					type: "one-to-many",
+					target: elementRef,
+					foreignKey: fieldName
+				};
+				continue;
+			}
+			const ref = path.options?.ref;
+			if (ref) relations[fieldName] = {
+				type: "one-to-one",
+				target: ref,
+				foreignKey: fieldName
+			};
+		}
+		return Object.keys(relations).length > 0 ? relations : void 0;
+	}
+};
+function createMongooseAdapter(modelOrOptions, repository) {
+	if (isMongooseModel(modelOrOptions)) {
+		if (!repository) throw new TypeError("createMongooseAdapter: repository is required when using 2-arg form.\nUsage: createMongooseAdapter(Model, repository)");
+		return new MongooseAdapter({
+			model: modelOrOptions,
+			repository
+		});
+	}
+	return new MongooseAdapter(modelOrOptions);
+}
+//#endregion
+export { createMongooseAdapter as n, isMongooseModel as r, MongooseAdapter as t };

package/dist/ai/index.d.mts

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

package/dist/ai/index.mjs

@@ -1,4 +1,4 @@
-import { r as warn } from "../logger-8-VS1za6.mjs";
+import { n as warn } from "../logger-DprijP5h.mjs";
 //#region src/ai/url-policy.ts
 /**
 * URL policy helpers for the vector plugin media pipeline.

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

@@ -0,0 +1,149 @@
+import { DataAdapter, RepositoryLike } from "@classytic/repo-core/adapter";
+import { BetterAuthPluginKey, BetterAuthPluginKey as BetterAuthPluginKey$1 } from "@classytic/repo-core/better-auth";
+
+//#region src/better-auth/index.d.ts
+/**
+ * Minimal structural type for the Mongoose surface this module touches.
+ * Declared structurally so the file has zero runtime `import` of mongoose —
+ * mongoose stays a peer dep and is never bundled with mongokit.
+ */
+interface MongooseLike {
+  models: Record<string, unknown>;
+  Schema: new (definition?: Record<string, unknown>, options?: Record<string, unknown>) => MongooseSchemaLike;
+  model: (name: string, schema?: unknown) => MongooseModelLike;
+}
+interface MongooseSchemaLike {
+  index(fields: Record<string, 1 | -1>, options?: Record<string, unknown>): MongooseSchemaLike;
+}
+interface MongooseModelLike {
+  modelName: string;
+  schema: {
+    paths: Record<string, unknown>;
+  };
+}
+/**
+ * Minimal structural type for a `betterAuth()` instance. We only need
+ * `$context` (resolved tables map). Avoids a runtime peer dep on
+ * `better-auth` from this module — declared as an *optional* peer in
+ * package.json for hosts that import this subpath.
+ */
+interface BetterAuthInstance {
+  $context: Promise<{
+    tables: Record<string, BATableConfig>;
+  }> | {
+    tables: Record<string, BATableConfig>;
+  };
+}
+interface BATableConfig {
+  modelName: string;
+  fields: Record<string, BAFieldAttribute>;
+}
+interface BAFieldAttribute {
+  type: 'string' | 'number' | 'boolean' | 'date' | 'string[]' | 'number[]';
+  required?: boolean;
+  unique?: boolean;
+  fieldName?: string;
+  references?: {
+    model: string;
+    field: string;
+    onDelete?: string;
+  };
+  defaultValue?: unknown;
+}
+interface RegisterBetterAuthStubsOptions {
+  /** Plugin sets to include. `core` is always implied. */
+  plugins?: BetterAuthPluginKey$1[];
+  /** Additional collection names beyond the plugin set. */
+  extraCollections?: string[];
+  /** Mirror BA's `usePlural` flag — appends `s` to every collection name. */
+  usePlural?: boolean;
+  /** Per-collection model name override (mirrors BA's `user.modelName`). */
+  modelOverrides?: Partial<Record<string, string>>;
+}
+/**
+ * Register stub Mongoose models for Better Auth's collections so that
+ * Mongoose-based resources can `.populate()` references to BA-owned
+ * documents. Idempotent — safe to call multiple times.
+ *
+ * Schemas are `strict: false` and `_id: false` so BA's writes flow through
+ * unchanged and Mongoose hydrates whatever BA wrote. Use this when you have
+ * resources that *reference* BA collections (`createdBy: { ref: 'user' }`)
+ * but don't expose CRUD on the BA collection itself.
+ *
+ * For full CRUD on a BA collection, use `createBetterAuthOverlay` instead —
+ * it registers the model AND wires it into a `DataAdapter<TDoc>`.
+ *
+ * @returns the model names that were newly registered (excluding any that
+ *          already existed on `mongoose.models`).
+ */
+declare function registerBetterAuthStubs(mongoose: MongooseLike, options?: RegisterBetterAuthStubsOptions): string[];
+interface BetterAuthOverlayOptions<TDoc = Record<string, unknown>> {
+  /** A `betterAuth()` instance. Used to read the resolved schema (`auth.$context.tables`). */
+  auth: BetterAuthInstance;
+  /** Mongoose instance — passed in to keep mongoose a peer dep. */
+  mongoose: MongooseLike;
+  /**
+   * Canonical BA collection name (`'user'`, `'organization'`, `'member'`, ...).
+   * The factory looks up `auth.$context.tables[collection]` to derive the
+   * actual model name (honoring BA's `user.modelName` overrides) and the
+   * field set (honoring `additionalFields` and plugin schema additions).
+   */
+  collection: string;
+  /**
+   * Additional fields to declare on the Mongoose schema. Use this when:
+   *   - You added them via `betterAuth({ user: { additionalFields: { ... } } })`
+   *     and want typed access from your repository
+   *   - You want to declare validators / defaults / indexes on those fields
+   *
+   * Schema stays `strict: false`, so any field BA writes that you DON'T
+   * declare here still round-trips — declaring is about typed access and
+   * Mongoose-side concerns (validators, indexes, defaults).
+   */
+  additionalFields?: Record<string, unknown>;
+  /**
+   * Mongoose schema indexes to attach to the overlay model.
+   *
+   * @example [{ fields: { code: 1 }, options: { unique: true, sparse: true } }]
+   */
+  indexes?: Array<{
+    fields: Record<string, 1 | -1>;
+    options?: Record<string, unknown>;
+  }>;
+  /**
+   * Mirror BA's `usePlural: true` flag. Only used as a fallback when
+   * `auth.$context.tables[collection].modelName` doesn't already include
+   * the pluralization (rare — BA's resolver normally bakes it in).
+   */
+  usePlural?: boolean;
+  /**
+   * 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.
+   */
+  RepositoryClass?: new (Model: ReturnType<MongooseLike['model']>) => RepositoryLike<TDoc>;
+  /**
+   * Optional schema generator. Pass `buildCrudSchemasFromModel` from
+   * `@classytic/mongokit` to wire OpenAPI auto-gen.
+   */
+  schemaGenerator?: any;
+}
+/**
+ * Create a `DataAdapter<TDoc>` over a Better Auth collection.
+ *
+ * Reads `auth.$context.tables[collection]` to resolve the actual model
+ * name and any BA-declared fields. Registers a `strict: false` Mongoose
+ * model, wraps it in a `Repository`, and returns the framework-agnostic
+ * adapter ready for `defineResource({ adapter })`.
+ *
+ * Async because we await BA's resolved schema. Resolves once at boot —
+ * there's no per-request cost. Symmetric with
+ * `@classytic/sqlitekit/better-auth.createBetterAuthOverlay`.
+ *
+ * @throws if `collection` doesn't match any table BA knows about (typo or
+ *         missing plugin), or if a model with the resolved name is already
+ *         registered on `mongoose.models` from a prior call (re-registration
+ *         would silently drop this call's `additionalFields` / `indexes`).
+ */
+declare function createBetterAuthOverlay<TDoc = Record<string, unknown>>(options: BetterAuthOverlayOptions<TDoc>): Promise<DataAdapter<TDoc>>;
+//#endregion
+export { BetterAuthInstance, BetterAuthOverlayOptions, type BetterAuthPluginKey, MongooseLike, RegisterBetterAuthStubsOptions, createBetterAuthOverlay, registerBetterAuthStubs };

package/dist/better-auth/index.mjs

@@ -0,0 +1,81 @@
+import { n as Repository } from "../Repository-d5gWSROf.mjs";
+import { n as createMongooseAdapter } from "../adapter-DTDMnUOH.mjs";
+import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@classytic/repo-core/better-auth";
+//#region src/better-auth/index.ts
+/**
+* Register stub Mongoose models for Better Auth's collections so that
+* Mongoose-based resources can `.populate()` references to BA-owned
+* documents. Idempotent — safe to call multiple times.
+*
+* Schemas are `strict: false` and `_id: false` so BA's writes flow through
+* unchanged and Mongoose hydrates whatever BA wrote. Use this when you have
+* resources that *reference* BA collections (`createdBy: { ref: 'user' }`)
+* but don't expose CRUD on the BA collection itself.
+*
+* For full CRUD on a BA collection, use `createBetterAuthOverlay` instead —
+* it registers the model AND wires it into a `DataAdapter<TDoc>`.
+*
+* @returns the model names that were newly registered (excluding any that
+*          already existed on `mongoose.models`).
+*/
+function registerBetterAuthStubs(mongoose, options = {}) {
+	const names = resolveBetterAuthCollections(options);
+	const registered = [];
+	for (const finalName of names) {
+		if (mongoose.models[finalName]) continue;
+		const schema = new mongoose.Schema({}, {
+			strict: false,
+			collection: finalName,
+			_id: false,
+			timestamps: false
+		});
+		mongoose.model(finalName, schema);
+		registered.push(finalName);
+	}
+	return registered;
+}
+/**
+* Create a `DataAdapter<TDoc>` over a Better Auth collection.
+*
+* Reads `auth.$context.tables[collection]` to resolve the actual model
+* name and any BA-declared fields. Registers a `strict: false` Mongoose
+* model, wraps it in a `Repository`, and returns the framework-agnostic
+* adapter ready for `defineResource({ adapter })`.
+*
+* Async because we await BA's resolved schema. Resolves once at boot —
+* there's no per-request cost. Symmetric with
+* `@classytic/sqlitekit/better-auth.createBetterAuthOverlay`.
+*
+* @throws if `collection` doesn't match any table BA knows about (typo or
+*         missing plugin), or if a model with the resolved name is already
+*         registered on `mongoose.models` from a prior call (re-registration
+*         would silently drop this call's `additionalFields` / `indexes`).
+*/
+async function createBetterAuthOverlay(options) {
+	const { auth, mongoose, collection, additionalFields = {}, indexes = [], usePlural = false, RepositoryClass, schemaGenerator } = options;
+	const ctx = await auth.$context;
+	const tableConfig = ctx.tables[collection];
+	if (!tableConfig) throw new Error(`[mongokit:better-auth] Better Auth has no table named '${collection}'. Available: ${Object.keys(ctx.tables).join(", ")}. Did you enable the right plugin in your betterAuth() config?`);
+	const finalName = usePlural ? pluralizeBetterAuthCollection(tableConfig.modelName) : tableConfig.modelName;
+	if (mongoose.models[finalName]) {
+		if (Object.keys(additionalFields).length > 0 || indexes.length > 0) throw new Error(`[mongokit:better-auth] '${finalName}' already registered on mongoose.models. Cannot apply additionalFields / indexes from this createBetterAuthOverlay() call — mongoose locks schema on first model() call. Either: (a) drop the prior registerBetterAuthStubs() call for '${finalName}', or (b) move additionalFields / indexes into the existing schema definition.`);
+	}
+	let Model = mongoose.models[finalName];
+	if (!Model) {
+		const schema = new mongoose.Schema(additionalFields, {
+			strict: false,
+			collection: finalName,
+			timestamps: false
+		});
+		for (const idx of indexes) schema.index(idx.fields, idx.options);
+		Model = mongoose.model(finalName, schema);
+	}
+	const repository = new (RepositoryClass ?? Repository)(Model);
+	return createMongooseAdapter({
+		model: Model,
+		repository,
+		schemaGenerator
+	});
+}
+//#endregion
+export { createBetterAuthOverlay, registerBetterAuthStubs };