@ignex/ninox 0.1.1

package/dist/index.js

@@ -0,0 +1,4370 @@
+import { ObjectId, MongoClient, Decimal128 } from 'mongodb';
+import { writeFile, mkdir, readdir } from 'fs/promises';
+import { basename, join } from 'path';
+import { pathToFileURL } from 'url';
+
+// src/utils/timeout.ts
+var withTimeout = (promise, timeoutMs, label) => {
+  if (timeoutMs <= 0) return promise;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`Operation timed out after ${timeoutMs}ms: ${label}`));
+    }, timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleepJittered = (ms, jitterMs = 1e3) => sleep(ms + Math.floor(Math.random() * Math.min(ms, jitterMs)));
+
+// src/capabilities.ts
+var createMongoCapabilitiesStore = () => {
+  let state = { probed: false, transactionsSupported: false };
+  return {
+    get: () => state,
+    set: (capabilities) => {
+      state = capabilities;
+    },
+    reset: () => {
+      state = { probed: false, transactionsSupported: false };
+    }
+  };
+};
+var readMongoTransactionsEnvOverride = () => {
+  const raw = process.env.MONGO_USE_TRANSACTIONS;
+  if (raw === void 0) return void 0;
+  return ["1", "true", "yes"].includes(raw.toLowerCase());
+};
+var probeMongoCapabilities = async (client) => {
+  try {
+    const db = client && "startSession" in client ? client.db() : client;
+    if (!db) return { probed: false, transactionsSupported: false };
+    const hello = await withTimeout(
+      db.admin().command({ hello: 1 }),
+      5e3,
+      "probeMongoCapabilities: hello"
+    );
+    const isReplicaSet = typeof hello.setName === "string" && hello.setName.length > 0;
+    const isMongos = hello.msg === "isdbgrid";
+    return { probed: true, transactionsSupported: isReplicaSet || isMongos };
+  } catch {
+    return { probed: false, transactionsSupported: false };
+  }
+};
+var mongoTransactionsEnabled = (store, options = {}) => {
+  const env = options.envOverride ?? readMongoTransactionsEnvOverride();
+  if (env !== void 0) return env;
+  const state = store.get();
+  if (state.probed) return state.transactionsSupported;
+  if (options.urlHint) return /replicaSet=/.test(options.urlHint);
+  return false;
+};
+
+// src/errors/classes.ts
+var ERROR_HTTP_STATUS = {
+  BAD_REQUEST: 400,
+  NOT_FOUND: 404,
+  DUPLICATE_KEY: 409,
+  VERSION_CONFLICT: 409,
+  COLLECTION_EXISTS: 409,
+  SCHEMA_DRIFT: 409,
+  VALIDATION_FAILED: 422,
+  MONGO_TIMEOUT: 504
+};
+var AppError = class extends Error {
+  code;
+  statusCode;
+  extra;
+  constructor(code, message, statusCode = 500, extra) {
+    super(message);
+    this.name = "AppError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.extra = extra;
+  }
+  /**
+   * Stable, client-safe serialization for framework error middleware: a
+   * framework can forward `JSON.stringify(error)` (or `error.toJSON()`) straight
+   * to the client — no parsing of server internals. `stack` is dropped; the
+   * shape is always `{ name, code, message, statusCode, ...(extra) }`.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      ...this.extra !== void 0 ? { extra: this.extra } : {}
+    };
+  }
+};
+var DomainError = class extends AppError {
+  constructor(code, message, extra) {
+    super(code, message, ERROR_HTTP_STATUS[code] ?? 400, extra);
+    this.name = "DomainError";
+  }
+};
+var InfraError = class extends AppError {
+  constructor(code, message, extra) {
+    super(code, message, ERROR_HTTP_STATUS[code] ?? 500, extra);
+    this.name = "InfraError";
+  }
+};
+var BadRequest = class extends DomainError {
+  constructor(message, extra) {
+    super("BAD_REQUEST", message, extra);
+    this.name = "BadRequest";
+  }
+};
+var isAppError = (err) => err instanceof AppError;
+var isDomainError = (err) => err instanceof DomainError;
+var isInfraError = (err) => err instanceof InfraError;
+
+// src/errors/transient.ts
+var TRANSIENT_MONGO_ERROR_CODES = Object.freeze(
+  /* @__PURE__ */ new Set([
+    6,
+    // HostUnreachable
+    7,
+    // HostNotFound
+    89,
+    // NetworkTimeout
+    91,
+    // ShutdownInProgress
+    189,
+    // PrimarySteppedDown
+    9001,
+    // SocketException
+    10107,
+    // NotWritablePrimary
+    11600,
+    // InterruptedAtShutdown
+    11602,
+    // InterruptedDueToReplStateChange
+    13435,
+    // NotPrimaryNoSecondaryOk
+    13436
+    // NotPrimaryOrSecondary
+  ])
+);
+var TRANSIENT_NAME = /MongoNetworkError|PoolClearedError|MongoWriteConcernError|MongoNotPrimaryError|MongoNodeIsRecoveringError|MongoNetworkTimeoutError/;
+var isMongoTransientError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  if (typeof e.name === "string" && TRANSIENT_NAME.test(e.name)) return true;
+  if (typeof e.code === "number" && TRANSIENT_MONGO_ERROR_CODES.has(e.code)) return true;
+  return false;
+};
+var isMongoDuplicateKeyError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  if (e.code === 11e3) return true;
+  if (typeof e.message === "string" && /E11000|duplicate key/i.test(e.message)) return true;
+  return false;
+};
+
+// src/errors/driver-map.ts
+var extractValidationPaths = (errInfo) => {
+  if (!errInfo || typeof errInfo !== "object") return [];
+  const info = errInfo;
+  const out = [];
+  for (const rule of info.details?.schemaRulesNotSatisfied ?? []) {
+    if (typeof rule.propertyName === "string") out.push(rule.propertyName);
+    for (const prop of rule.propertiesNotSatisfied ?? []) {
+      if (typeof prop.propertyName === "string") out.push(prop.propertyName);
+    }
+    for (const prop of rule.additionalProperties ?? []) {
+      if (typeof prop === "string") out.push(prop);
+    }
+  }
+  return [...new Set(out)];
+};
+var addValidationContext = (context, errInfo) => {
+  if (!errInfo || typeof errInfo !== "object") return;
+  const info = errInfo;
+  if (info.failingDocumentId !== void 0) context.documentId = info.failingDocumentId;
+  const fields = extractValidationPaths(errInfo);
+  if (fields.length > 0) context.fields = fields;
+  if (info.details !== void 0) context.details = info.details;
+};
+var isBulkWriteError = (error) => typeof error === "object" && error !== null && "writeErrors" in error && Array.isArray(error.writeErrors);
+var mapMongoDriverError = (error, ctx = {}) => {
+  if (error instanceof AppError) return error;
+  const context = { ...ctx };
+  if (isMongoDuplicateKeyError(error)) {
+    const e = error;
+    if (e.keyPattern) context.keyPattern = e.keyPattern;
+    if (e.keyValue) context.keyValue = e.keyValue;
+    return new DomainError("DUPLICATE_KEY", "Duplicate key error", context);
+  }
+  if (isBulkWriteError(error)) {
+    const first = error.writeErrors[0];
+    if (first?.code === 11e3) {
+      if (first.keyPattern) context.keyPattern = first.keyPattern;
+      if (first.keyValue) context.keyValue = first.keyValue;
+      return new DomainError("DUPLICATE_KEY", first.errmsg ?? "Duplicate key error", context);
+    }
+    if (first?.code === 121) {
+      addValidationContext(context, first.errInfo);
+      return new DomainError("VALIDATION_FAILED", "Document failed schema validation", context);
+    }
+    return new InfraError("MONGO_QUERY_ERROR", "Bulk write failed", context);
+  }
+  const code = error.code;
+  switch (code) {
+    case 112:
+      return new DomainError("VERSION_CONFLICT", "Document version conflict", context);
+    case 50:
+      return new InfraError("MONGO_TIMEOUT", "MongoDB operation timed out", context);
+    case 121: {
+      addValidationContext(context, error.errInfo);
+      return new DomainError("VALIDATION_FAILED", "Document failed schema validation", context);
+    }
+  }
+  if (isMongoTransientError(error)) {
+    const e = error;
+    return new InfraError("MONGO_QUERY_ERROR", e.message ?? "Transient MongoDB error", context);
+  }
+  const msg = error.message ?? "MongoDB query error";
+  return new InfraError("MONGO_QUERY_ERROR", msg, context);
+};
+var isMappedMongoError = (error) => error instanceof AppError;
+
+// src/errors/http-status.ts
+var httpStatusForError = (err) => {
+  if (err instanceof AppError) return err.statusCode;
+  if (isMongoTransientError(err)) return 503;
+  return 500;
+};
+var serializeError = (err, ctx = {}) => {
+  const mapped = mapMongoDriverError(err, ctx);
+  if (mapped instanceof AppError) return mapped.toJSON();
+  if (mapped instanceof Error) {
+    return { name: mapped.name, code: "UNKNOWN", message: mapped.message, statusCode: 500 };
+  }
+  return { name: "UnknownError", code: "UNKNOWN", message: String(mapped), statusCode: 500 };
+};
+var cloneDeep = (value) => {
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value instanceof ObjectId) return new ObjectId(value.toHexString());
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
+  if (Array.isArray(value)) return value.map((item) => cloneDeep(item));
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = cloneDeep(v);
+    }
+    return out;
+  }
+  return value;
+};
+
+// src/utils/hash.ts
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var toPrimitive = (v) => {
+  if (v === void 0 || v === null) return null;
+  if (typeof v === "bigint") return v.toString();
+  if (v instanceof Date) return `date:${v.getTime()}`;
+  if (typeof v === "object") {
+    const anyV = v;
+    if (typeof anyV.toHexString === "function") return `oid:${anyV.toHexString()}`;
+    if (anyV instanceof RegExp) return `re:${anyV.source}/${anyV.flags}`;
+  }
+  return v;
+};
+var stableStringify = (value) => {
+  const visit = (v) => {
+    if (Array.isArray(v)) return v.map(visit);
+    if (isPlainObject(v)) {
+      const out = {};
+      for (const key of Object.keys(v).sort()) out[key] = visit(v[key]);
+      return out;
+    }
+    return toPrimitive(v);
+  };
+  return JSON.stringify(visit(value));
+};
+var hashString = (input) => {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(36);
+};
+var stableHash = (value) => hashString(stableStringify(value));
+
+// src/utils/lru.ts
+var LRU = class {
+  max;
+  map = /* @__PURE__ */ new Map();
+  /** Number of entries evicted to make room for new ones (capacity evictions only). */
+  evictions = 0;
+  constructor(options) {
+    if (options.max <= 0) throw new Error("LRU max must be > 0");
+    this.max = options.max;
+  }
+  get size() {
+    return this.map.size;
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value === void 0) return void 0;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  peek(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) {
+        this.map.delete(oldest);
+        this.evictions++;
+      }
+    }
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+  }
+  keys() {
+    return this.map.keys();
+  }
+  entries() {
+    return this.map.entries();
+  }
+  [Symbol.iterator]() {
+    return this.map.entries();
+  }
+};
+
+// src/cache/in-flight.ts
+var InFlight = class {
+  pending = /* @__PURE__ */ new Map();
+  get size() {
+    return this.pending.size;
+  }
+  run(key, fn) {
+    const existing = this.pending.get(key);
+    if (existing) return existing;
+    const promise = fn().finally(() => {
+      this.pending.delete(key);
+    });
+    this.pending.set(key, promise);
+    return promise;
+  }
+  clear() {
+    this.pending.clear();
+  }
+};
+var estimateSize = (value) => {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "string") return value.length * 2;
+  if (typeof value === "number" || typeof value === "boolean") return 8;
+  if (value instanceof ObjectId) return 16;
+  if (value instanceof Date) return 8;
+  if (Array.isArray(value)) return value.reduce((sum, v) => sum + estimateSize(v), 0);
+  if (typeof value === "object") {
+    let sum = 0;
+    for (const [k, v] of Object.entries(value)) {
+      sum += k.length * 2 + estimateSize(v);
+    }
+    return sum;
+  }
+  return 0;
+};
+
+// src/cache/hot-cache/ticker.ts
+var RefreshTicker = class {
+  constructor(host, tickIntervalMs) {
+    this.host = host;
+    this.intervalMs = tickIntervalMs;
+  }
+  timer;
+  intervalMs;
+  /** Whether the timer is currently running. */
+  get running() {
+    return this.timer !== void 0;
+  }
+  /** Start the interval (idempotent). The timer is `.unref()`'d so it never holds the process open. */
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      try {
+        this.tick();
+      } catch (err) {
+        this.host.logger.warn?.(
+          { error: err instanceof Error ? err.message : String(err) },
+          "hot cache tick failed"
+        );
+      }
+    }, this.intervalMs);
+    const t = this.timer;
+    t?.unref?.();
+  }
+  /** Stop the interval (idempotent). */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  /** Background refresh pass: re-run loaders for due entries, swap fresh values. */
+  tick() {
+    const now = Date.now();
+    for (const q of this.host.queries().values()) {
+      if (q.refreshIntervalMs <= 0) continue;
+      for (const [key, entry] of [...q.lru.entries()]) {
+        if (entry.nextRefreshAt <= now) {
+          q.refreshes++;
+          void this.host.fetch(q, key, entry.args, q.gen).catch((err) => {
+            const current = q.lru.peek(key);
+            if (current) current.nextRefreshAt = now + q.refreshIntervalMs;
+            this.host.logger.warn?.(
+              {
+                error: err instanceof Error ? err.message : String(err),
+                query: q.name
+              },
+              "hot cache background refresh failed (stale value retained)"
+            );
+          });
+        }
+      }
+    }
+  }
+  /**
+   * In standalone mode the ticker only refreshes queries with an explicit
+   * `refreshIntervalMs`. A query with neither `refreshIntervalMs` nor `ttlMs`
+   * set is served until it is manually invalidated — an easy way to serve
+   * unbounded-stale data. Surface those queries once so the operator opts in
+   * deliberately.
+   */
+  warnUnboundedStaleness() {
+    const unbounded = [...this.host.queries().values()].filter(
+      (q) => q.refreshIntervalMs <= 0 && q.ttlMs <= 0
+    );
+    if (unbounded.length === 0) return;
+    this.host.logger.warn?.(
+      { queries: unbounded.map((q) => q.name) },
+      "hot cache: standalone mode \u2014 these queries have no refreshIntervalMs/ttlMs, so values are served until manually invalidated (unbounded staleness); set refreshIntervalMs or ttlMs to bound it"
+    );
+  }
+};
+
+// src/cache/hot-cache/types.ts
+var WATCH_SEP = "\0";
+
+// src/cache/hot-cache/watcher.ts
+var WatchCoordinator = class {
+  constructor(host) {
+    this.host = host;
+  }
+  streams = /* @__PURE__ */ new Map();
+  failedStreams = /* @__PURE__ */ new Set();
+  stopped = true;
+  /** Number of currently open change streams. */
+  get size() {
+    return this.streams.size;
+  }
+  /** Mark the coordinator as running and open watchers for all watch refs (idempotent). */
+  start() {
+    this.stopped = false;
+    this.openWatchStreams();
+  }
+  /** Close every watcher and clear failure bookkeeping (idempotent). */
+  async stop() {
+    this.stopped = true;
+    const closes = [...this.streams.values()].map((stream) => {
+      try {
+        return Promise.resolve(stream.close()).catch(() => {
+        });
+      } catch {
+        return Promise.resolve();
+      }
+    });
+    this.streams.clear();
+    this.failedStreams.clear();
+    await Promise.allSettled(closes);
+  }
+  openWatchStreams() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const q of this.host.queries().values()) {
+      for (const ref of q.config.watch ?? []) {
+        const key = `${ref.db.databaseName}${WATCH_SEP}${ref.collection}`;
+        if (seen.has(key) || this.streams.has(key)) continue;
+        seen.add(key);
+        void this.watchLoop(key, ref);
+      }
+    }
+  }
+  /**
+   * Long-lived change-stream consumer for one collection. Each data change
+   * invalidates the queries bound to it. On permanent "not supported" errors the
+   * watcher is dropped and, if every planned stream failed, the cache falls back
+   * to the standalone ticker. Transient errors retry with backoff.
+   */
+  async watchLoop(key, ref) {
+    let backoff = 0;
+    while (!this.stopped) {
+      try {
+        const stream = ref.db.collection(ref.collection).watch([]);
+        stream.on("error", () => {
+        });
+        this.streams.set(key, stream);
+        if (backoff > 0) {
+          this.host.logger.warn?.(
+            { collection: ref.collection },
+            "hot cache: change stream reconnected \u2014 invalidating collection to drop entries missed during the outage"
+          );
+          this.host.invalidateCollection(ref.collection);
+        }
+        const iterator = stream[Symbol.asyncIterator]();
+        for await (const _change of iterator) {
+          this.host.invalidateCollection(ref.collection);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.host.logger.warn?.(
+          { error: message, collection: ref.collection },
+          "hot cache change stream error"
+        );
+        const abandoned = this.streams.get(key);
+        this.streams.delete(key);
+        if (abandoned) {
+          try {
+            await abandoned.close();
+          } catch {
+          }
+        }
+        if (/only supported on replica sets|not supported|ChangeStream/i.test(message)) {
+          this.markStreamFailed(key);
+          return;
+        }
+      }
+      if (this.stopped) return;
+      backoff = Math.min(backoff + 1e3, 5e3);
+      await sleepJittered(backoff);
+    }
+  }
+  markStreamFailed(key) {
+    this.failedStreams.add(key);
+    if (!this.host.isReplica()) return;
+    const planned = this.plannedStreamKeys();
+    if (planned.size > 0 && [...planned].every((k) => this.failedStreams.has(k))) {
+      this.host.logger.warn?.({}, "hot cache: change streams unsupported, falling back to ticker");
+      this.host.fallbackToStandalone();
+    }
+  }
+  plannedStreamKeys() {
+    const set = /* @__PURE__ */ new Set();
+    for (const q of this.host.queries().values()) {
+      for (const ref of q.config.watch ?? []) {
+        set.add(`${ref.db.databaseName}${WATCH_SEP}${ref.collection}`);
+      }
+    }
+    return set;
+  }
+};
+
+// src/cache/hot-cache/index.ts
+var HotCache = class {
+  options;
+  logger;
+  refreshEnabled;
+  queries = /* @__PURE__ */ new Map();
+  inflight = new InFlight();
+  watcher;
+  ticker;
+  _mode = "unknown";
+  started = false;
+  startAttempted = false;
+  stopped = false;
+  disposed = false;
+  startPromise;
+  constructor(options = {}) {
+    this.options = options;
+    this.refreshEnabled = options.autoRefresh !== false;
+    this.logger = options.logger ?? { debug() {
+    }, info() {
+    }, warn() {
+    }, error() {
+    } };
+    this.ticker = new RefreshTicker(
+      {
+        queries: () => this.queries,
+        fetch: (q, key, args, gen) => this.fetch(q, key, args, gen),
+        logger: this.logger
+      },
+      options.tickIntervalMs ?? 1e3
+    );
+    this.watcher = new WatchCoordinator({
+      queries: () => this.queries,
+      invalidateCollection: (collection) => this.invalidateCollection(collection),
+      isReplica: () => this._mode === "replica",
+      fallbackToStandalone: () => {
+        this._mode = "standalone";
+        if (this.refreshEnabled) this.ticker.start();
+      },
+      logger: this.logger
+    });
+  }
+  /** Number of cached entries across all registered queries. */
+  get size() {
+    let total = 0;
+    for (const q of this.queries.values()) total += q.lru.size;
+    return total;
+  }
+  /** Resolved mode: `unknown` until `start()` (or the first `get`) probes. */
+  get mode() {
+    return this._mode;
+  }
+  /** Whether the standalone background-refresh ticker is enabled (`autoRefresh`). */
+  get autoRefresh() {
+    return this.refreshEnabled;
+  }
+  /** Whether a query with this name has been registered. */
+  has(name) {
+    return this.queries.has(name);
+  }
+  /**
+   * Opt a query into the hot cache. Throws `BadRequest` on a duplicate name.
+   * Returns a fully typed accessor — `.get(...args)` (intellisense on the loader
+   * parameters) and `.invalidate()` / `.invalidate(...args)` for manual
+   * invalidation (all entries or a single parameter set).
+   */
+  register(name, config) {
+    if (this.queries.has(name)) {
+      throw new BadRequest(`hot cache: query '${name}' is already registered`);
+    }
+    const query = {
+      name,
+      config,
+      lru: new LRU({
+        max: config.maxSize ?? this.options.defaultMaxSize ?? 500
+      }),
+      ttlMs: config.ttlMs ?? this.options.defaultTtlMs ?? 0,
+      refreshIntervalMs: config.refreshIntervalMs ?? 0,
+      clone: config.clone ?? false,
+      maxValueBytes: config.maxValueBytes,
+      gen: 0,
+      hits: 0,
+      misses: 0,
+      refreshes: 0,
+      loadErrors: 0,
+      sizeSkips: 0,
+      warnedSize: false
+    };
+    this.queries.set(name, query);
+    if (this._mode === "replica" && !this.stopped) {
+      this.watcher.start();
+    }
+    return {
+      get: (...args) => this.get(name, ...args),
+      invalidate: (...args) => {
+        if (args.length === 0) this.invalidate(name);
+        else this.invalidateParams(name, ...args);
+      }
+    };
+  }
+  /**
+   * Read-through read by dynamic name lookup. Call parameters are hashed into
+   * the cache key (`keyOf` override wins). Throws `BadRequest` for an unknown
+   * query name. For fully typed parameters/results prefer the accessor returned
+   * by `register()` — this dynamic form returns `Promise<unknown>`.
+   */
+  async get(name, ...args) {
+    this.ensureStarted();
+    const q = this.queries.get(name);
+    if (!q) throw new BadRequest(`hot cache: unknown query '${name}'`);
+    const key = q.config.keyOf ? q.config.keyOf(...args) : stableHash(args);
+    const entry = q.lru.get(key);
+    if (entry && !(q.ttlMs > 0 && entry.expiresAt <= Date.now())) {
+      q.hits++;
+      return q.clone ? cloneDeep(entry.value) : entry.value;
+    }
+    if (entry && q.ttlMs > 0 && entry.expiresAt <= Date.now()) {
+      q.lru.delete(key);
+    }
+    q.misses++;
+    return this.fetch(q, key, args, q.gen);
+  }
+  /** Drop every cached entry for a registered query. */
+  invalidate(name) {
+    const q = this.queries.get(name);
+    if (!q) return;
+    q.lru.clear();
+    q.gen++;
+  }
+  /**
+   * Drop only the cached entry for a specific parameter set. The key is computed
+   * exactly like `get` (`keyOf` override ?? `stableHash` of args), so the same
+   * parameters invalidate the same entry.
+   */
+  invalidateParams(name, ...args) {
+    const q = this.queries.get(name);
+    if (!q) return;
+    const key = q.config.keyOf ? q.config.keyOf(...args) : stableHash(args);
+    q.lru.delete(key);
+    q.gen++;
+  }
+  /**
+   * Invalidate every query bound to a physical collection (via `watch`). Can be
+   * called manually to wire ORM write hooks in standalone mode.
+   */
+  invalidateCollection(collection) {
+    for (const q of this.queries.values()) {
+      if (q.config.watch?.some((ref) => ref.collection === collection)) {
+        q.lru.clear();
+        q.gen++;
+      }
+    }
+  }
+  /** Drop every cached entry for every query. */
+  clear() {
+    for (const q of this.queries.values()) {
+      q.lru.clear();
+      q.gen++;
+    }
+  }
+  /**
+   * Runtime observability snapshot: total queries/entries plus per-query
+   * counters (`hits`, `misses`, background `refreshes`, `loadErrors`, and
+   * `sizeSkips` for entries dropped by `maxValueBytes`). Useful for dashboards
+   * and cache-effectiveness checks.
+   */
+  stats() {
+    const perQuery = {};
+    for (const [name, q] of this.queries) {
+      perQuery[name] = {
+        size: q.lru.size,
+        hits: q.hits,
+        misses: q.misses,
+        refreshes: q.refreshes,
+        loadErrors: q.loadErrors,
+        sizeSkips: q.sizeSkips,
+        evictions: q.lru.evictions
+      };
+    }
+    return { mode: this._mode, queries: this.queries.size, entries: this.size, perQuery };
+  }
+  /**
+   * Probe replica support once, then start change-stream watchers (replica) or
+   * the global refresh ticker (standalone). Idempotent — resolves the mode.
+   */
+  async start() {
+    if (this.disposed) return this._mode;
+    if (this.started) return this._mode;
+    if (!this.startPromise) {
+      this.startPromise = this.runStart();
+    }
+    return this.startPromise;
+  }
+  /**
+   * Stop the ticker, close every change stream, and **dispose** the instance.
+   * Terminal: a later `get()` serves cached values read-through but never
+   * re-probes or re-opens background resources.
+   */
+  async stop() {
+    this.disposed = true;
+    this.stopped = true;
+    this.ticker.stop();
+    await this.watcher.stop();
+    this.inflight.clear();
+    for (const q of this.queries.values()) q.gen++;
+    this.started = false;
+    this.startAttempted = false;
+    this.startPromise = void 0;
+    this._mode = "unknown";
+  }
+  /* ----------------------------- internals ----------------------------- */
+  async runStart() {
+    this.stopped = false;
+    const supported = this.options.mode === "replica" ? true : this.options.mode === "standalone" ? false : await (this.options.probe ?? this.defaultProbe)();
+    if (this.disposed) {
+      this.started = false;
+      return this._mode;
+    }
+    if (supported) {
+      this._mode = "replica";
+      this.watcher.start();
+    } else {
+      this._mode = "standalone";
+      if (this.refreshEnabled) {
+        this.ticker.start();
+        this.ticker.warnUnboundedStaleness();
+      }
+    }
+    this.started = true;
+    return this._mode;
+  }
+  ensureStarted() {
+    if (this.disposed || this.started || this.startAttempted) return;
+    this.startAttempted = true;
+    void this.start().catch((err) => {
+      this.logger.warn?.(
+        { error: err instanceof Error ? err.message : String(err) },
+        "hot cache start failed; reads continue without auto-refresh"
+      );
+    });
+  }
+  defaultProbe = async () => {
+    for (const q of this.queries.values()) {
+      for (const ref of q.config.watch ?? []) {
+        const caps = await probeMongoCapabilities(ref.db);
+        if (!caps.probed) {
+          this.logger.warn?.(
+            { db: ref.db.databaseName },
+            "hot cache: replica probe returned no result (timeout?) \u2014 falling back to the standalone ticker; pass `mode` or a custom `probe` to pin the behavior"
+          );
+          return false;
+        }
+        return caps.transactionsSupported;
+      }
+    }
+    return false;
+  };
+  fetch(q, key, args, gen) {
+    const dedupeKey = `${q.name}${WATCH_SEP}${key}`;
+    return this.inflight.run(dedupeKey, async () => {
+      try {
+        const value = await q.config.loader(...args);
+        if (q.gen === gen) {
+          if (q.maxValueBytes !== void 0 && estimateSize(value) > q.maxValueBytes) {
+            q.sizeSkips++;
+            if (!q.warnedSize) {
+              q.warnedSize = true;
+              this.logger.warn?.(
+                { query: q.name, bytes: estimateSize(value), max: q.maxValueBytes },
+                "hot cache: value exceeds maxValueBytes \u2014 returned but not cached"
+              );
+            }
+          } else {
+            this.setEntry(q, key, args, value);
+          }
+        }
+        return value;
+      } catch (err) {
+        q.loadErrors++;
+        throw err;
+      }
+    });
+  }
+  setEntry(q, key, args, value) {
+    const now = Date.now();
+    q.lru.set(key, {
+      value,
+      args,
+      expiresAt: q.ttlMs > 0 ? now + q.ttlMs : Infinity,
+      nextRefreshAt: q.refreshIntervalMs > 0 ? now + q.refreshIntervalMs : Infinity
+    });
+  }
+};
+var createHotCache = (options) => new HotCache(options);
+
+// src/cache/query-cache.ts
+var SEP = "\0";
+var NS_SEP = "
";
+var cacheCollectionKey = (dbName, physical) => `${dbName}${NS_SEP}${physical}`;
+var QueryCache = class {
+  lru;
+  index = /* @__PURE__ */ new Map();
+  ttlMs;
+  clone;
+  hits = 0;
+  misses = 0;
+  sets = 0;
+  deletes = 0;
+  invalidateEvents = 0;
+  clearEvents = 0;
+  constructor(options = {}) {
+    this.lru = new LRU({ max: options.maxSize ?? 500 });
+    this.ttlMs = options.ttlMs ?? 0;
+    this.clone = options.clone ?? false;
+  }
+  get size() {
+    return this.lru.size;
+  }
+  /** Cache-health snapshot: sizes plus lifetime hit/miss/eviction counters. */
+  stats() {
+    return {
+      size: this.lru.size,
+      maxSize: this.lru.max,
+      hits: this.hits,
+      misses: this.misses,
+      sets: this.sets,
+      deletes: this.deletes,
+      invalidateEvents: this.invalidateEvents,
+      clearEvents: this.clearEvents,
+      evictions: this.lru.evictions
+    };
+  }
+  /** Compose a cache key for a collection + filter/options hash. */
+  key(collection, filterHash) {
+    return `${collection}${SEP}${filterHash}`;
+  }
+  get(key) {
+    const entry = this.lru.get(key);
+    if (!entry) {
+      this.misses++;
+      return void 0;
+    }
+    if (this.ttlMs > 0 && Date.now() > entry.expiresAt) {
+      this.lru.delete(key);
+      this.misses++;
+      return void 0;
+    }
+    this.hits++;
+    return this.clone ? cloneDeep(entry.value) : entry.value;
+  }
+  set(key, value, ttlMs) {
+    this.sets++;
+    const ttl = ttlMs ?? this.ttlMs;
+    const expiresAt = ttl > 0 ? Date.now() + ttl : Infinity;
+    this.lru.set(key, { value, expiresAt });
+    const sep = key.indexOf(SEP);
+    const collection = sep === -1 ? key : key.slice(0, sep);
+    let keys = this.index.get(collection);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      this.index.set(collection, keys);
+    }
+    keys.add(key);
+  }
+  delete(key) {
+    this.deletes++;
+    this.lru.delete(key);
+  }
+  /** Drop every cached entry belonging to a physical collection. */
+  invalidateByCollection(collection) {
+    const keys = this.index.get(collection);
+    if (!keys) return;
+    this.invalidateEvents++;
+    for (const key of keys) this.lru.delete(key);
+    this.index.delete(collection);
+  }
+  clear() {
+    this.clearEvents++;
+    this.lru.clear();
+    this.index.clear();
+  }
+};
+
+// src/graceful-transaction.ts
+var withGracefulMongoTransaction = async (runner, fn, options = {}) => {
+  const enabled = options.capabilities === void 0 || mongoTransactionsEnabled(options.capabilities, { urlHint: options.urlHint });
+  if (!enabled) return fn(null);
+  try {
+    return await runner.transaction(fn);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "";
+    if (/Transaction numbers are only allowed|transactions are not supported/i.test(message)) {
+      options.logger?.warn?.({ error: message }, "transactions unsupported, falling back");
+      return fn(null);
+    }
+    if (options.wrapMongoErrors !== false) {
+      throw mapMongoDriverError(err, { op: "transaction" });
+    }
+    throw err;
+  }
+};
+
+// src/hooks/hooks.ts
+var HOOK_NAMES = [
+  "beforeCreate",
+  "afterCreate",
+  "beforeUpdate",
+  "afterUpdate",
+  "beforeDelete",
+  "afterDelete",
+  "afterRead"
+];
+var hasHook = (registry, collection, name) => registry?.[collection]?.[name] !== void 0;
+var runHooks = async (registry, collection, name, ctx) => {
+  const hooks = registry?.[collection];
+  const hook = hooks?.[name];
+  if (!hook) return;
+  await hook(ctx);
+};
+
+// src/loader/dataloader.ts
+var DataLoader = class {
+  batchFn;
+  maxBatchSize;
+  maxBatchDelayMs;
+  cacheEnabled;
+  keyOf;
+  cache;
+  queue = [];
+  scheduled = false;
+  flushing = false;
+  constructor(options) {
+    this.batchFn = options.batch;
+    this.maxBatchSize = options.maxBatchSize ?? 1e3;
+    this.maxBatchDelayMs = options.maxBatchDelayMs ?? 0;
+    this.cacheEnabled = options.cache ?? true;
+    this.keyOf = options.keyOf ?? ((key) => `${typeof key}:${String(key)}`);
+    this.cache = options.cacheMap ?? /* @__PURE__ */ new Map();
+  }
+  /** Load one key. Concurrent loads are batched; cached keys resolve instantly. */
+  load(key) {
+    const canonicalKey2 = this.keyOf(key);
+    if (this.cacheEnabled) {
+      const cached = this.cache.get(canonicalKey2);
+      if (cached) return cached;
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.queue.push({ key, canonicalKey: canonicalKey2, promise, resolve, reject });
+    if (this.cacheEnabled) this.cache.set(canonicalKey2, promise);
+    this.scheduleFlush();
+    return promise;
+  }
+  /** Load many keys (each resolves independently). */
+  loadMany(keys) {
+    return Promise.all(keys.map((key) => this.load(key)));
+  }
+  clear(key) {
+    this.cache.delete(this.keyOf(key));
+    return this;
+  }
+  clearAll() {
+    this.cache.clear();
+    return this;
+  }
+  /** Pre-populate the cache without hitting the batch function. */
+  prime(key, value) {
+    if (this.cacheEnabled) this.cache.set(this.keyOf(key), Promise.resolve(value));
+    return this;
+  }
+  get pendingCount() {
+    return this.queue.length;
+  }
+  scheduleFlush() {
+    if (this.scheduled) return;
+    this.scheduled = true;
+    if (this.maxBatchDelayMs > 0) {
+      setTimeout(() => {
+        void this.flush();
+      }, this.maxBatchDelayMs);
+    } else {
+      queueMicrotask(() => {
+        void this.flush();
+      });
+    }
+  }
+  async flush() {
+    if (this.flushing) return;
+    if (this.queue.length === 0) {
+      this.scheduled = false;
+      return;
+    }
+    const items = this.queue.splice(0, this.maxBatchSize);
+    this.flushing = true;
+    try {
+      const resultMap = await this.batchFn(items.map((item) => item.key));
+      for (const item of items) {
+        item.resolve(resultMap.get(item.key));
+      }
+    } catch (error) {
+      for (const item of items) {
+        if (this.cacheEnabled && this.cache.get(item.canonicalKey) === item.promise) {
+          this.cache.delete(item.canonicalKey);
+        }
+        item.reject(error);
+      }
+    } finally {
+      this.flushing = false;
+      this.scheduled = false;
+      if (this.queue.length > 0) {
+        this.scheduled = true;
+        queueMicrotask(() => {
+          void this.flush();
+        });
+      }
+    }
+  }
+};
+var canonicalKey = (value) => {
+  if (value === void 0 || value === null) return "null";
+  if (typeof value === "object") {
+    const anyValue = value;
+    if (typeof anyValue.toHexString === "function") return `oid:${anyValue.toHexString()}`;
+    if (value instanceof Date) return `date:${value.getTime()}`;
+  }
+  return `${typeof value}:${String(value)}`;
+};
+
+// src/migrations/types.ts
+var MIGRATION_FILE = /^(\d+)_.+\.(ts|js|mjs)$/;
+var JOURNAL_COLLECTION = "_migrations";
+
+// src/migrations/files.ts
+var migrationNameOf = (file) => basename(file).replace(/\.(ts|js|mjs)$/, "");
+var listMigrationFiles = async (dir) => {
+  const files = await readdir(dir);
+  return files.filter((file) => MIGRATION_FILE.test(file)).sort();
+};
+var loadMigration = async (dir, file) => {
+  const mod = await import(pathToFileURL(join(dir, file)).href);
+  return { name: migrationNameOf(file), ...mod };
+};
+var ensureMigrationDir = async (dir) => {
+  await mkdir(dir, { recursive: true });
+};
+var nextMigrationNumber = async (dir) => {
+  const files = await readdir(dir);
+  return files.reduce((max, file) => {
+    const match = MIGRATION_FILE.exec(file);
+    return match ? Math.max(max, Number(match[1])) : max;
+  }, 0) + 1;
+};
+
+// src/migrations/journal.ts
+var createMigrationJournal = (manager) => {
+  const appliedNames = async () => {
+    const rows = await manager.findMany(JOURNAL_COLLECTION);
+    return new Set(
+      rows.filter((row) => row.status === void 0 || row.status === "applied").map((row) => row.name)
+    );
+  };
+  const cleanupStale = async () => {
+    await manager.deleteMany(JOURNAL_COLLECTION, {
+      status: "running",
+      appliedAt: { $lt: new Date(Date.now() - 6e4) }
+    }).catch(() => {
+    });
+  };
+  const claim = async (name, file) => {
+    const claimed = await manager.findOneAndUpdate(
+      JOURNAL_COLLECTION,
+      { name },
+      {
+        $setOnInsert: {
+          name,
+          appliedAt: /* @__PURE__ */ new Date(),
+          status: "running",
+          file
+        }
+      },
+      { upsert: true, returnDocument: "before" }
+    );
+    return claimed === null;
+  };
+  const markApplied = async (name) => {
+    await manager.updateOne(JOURNAL_COLLECTION, { name, status: "running" }, { $set: { status: "applied" } }).catch(async () => {
+      await manager.insertOne(JOURNAL_COLLECTION, {
+        name,
+        appliedAt: /* @__PURE__ */ new Date(),
+        status: "applied"
+      }).catch(() => {
+      });
+    });
+  };
+  const removeRunning = async (name) => {
+    await manager.deleteOne(JOURNAL_COLLECTION, { name, status: "running" }).catch(() => {
+    });
+  };
+  const unrecord = async (name) => {
+    await manager.deleteOne(JOURNAL_COLLECTION, { name });
+  };
+  return { appliedNames, cleanupStale, claim, markApplied, removeRunning, unrecord };
+};
+
+// src/migrations/index.ts
+var createMongoMigrationRunner = (service, options = {}) => {
+  const migrationDir = options.migrationDir ?? service.config?.migrationDir ?? "./migrations";
+  const logger = options.logger ?? service.logger;
+  const manager = () => {
+    const key = Object.keys(service.db)[0];
+    const db = key ? service.db[key] : void 0;
+    if (!db) throw new Error("No database client connected \u2014 call service.makeConnections() first");
+    return db;
+  };
+  const up = async () => {
+    await ensureMigrationDir(migrationDir);
+    const journal = createMigrationJournal(manager());
+    await journal.cleanupStale();
+    const files = await listMigrationFiles(migrationDir);
+    const applied = await journal.appliedNames();
+    const pending = files.filter((file) => !applied.has(migrationNameOf(file)));
+    for (const file of pending) {
+      const migration = await loadMigration(migrationDir, file);
+      logger.info({ name: migration.name }, "running migration up");
+      if (!await journal.claim(migration.name, basename(file))) {
+        logger.info({ name: migration.name }, "migration already applied, skipping");
+        continue;
+      }
+      try {
+        await migration.up({ service, logger, name: migration.name });
+        await journal.markApplied(migration.name);
+      } catch (err) {
+        await journal.removeRunning(migration.name);
+        throw err;
+      }
+      logger.info({ name: migration.name }, "migration applied");
+    }
+  };
+  const down = async (targetName) => {
+    const files = await listMigrationFiles(migrationDir);
+    const journal = createMigrationJournal(manager());
+    const applied = await journal.appliedNames();
+    const appliedFiles = files.filter((file) => applied.has(migrationNameOf(file))).reverse();
+    for (const file of appliedFiles) {
+      const migration = await loadMigration(migrationDir, file);
+      logger.info({ name: migration.name }, "running migration down");
+      await migration.down({ service, logger, name: migration.name });
+      await journal.unrecord(migration.name);
+      logger.info({ name: migration.name }, "migration rolled back");
+      if (targetName && migration.name === targetName) break;
+    }
+  };
+  const status = async () => {
+    const files = await listMigrationFiles(migrationDir);
+    const applied = await createMigrationJournal(manager()).appliedNames();
+    const all = files.map(migrationNameOf);
+    return {
+      applied: all.filter((name) => applied.has(name)),
+      pending: all.filter((name) => !applied.has(name))
+    };
+  };
+  const create = async (name) => {
+    await ensureMigrationDir(migrationDir);
+    const next = await nextMigrationNumber(migrationDir);
+    const padded = String(next).padStart(3, "0");
+    const fileName = `${padded}_${name}.ts`;
+    const filePath = join(migrationDir, fileName);
+    const template = `import type { MigrationContext } from '@ignex/ninox';
+
+export const up = async (ctx: MigrationContext): Promise<void> => {
+  // const users = ctx.service.db.primaryClient;
+  // await users.createSchema('users');
+};
+
+export const down = async (ctx: MigrationContext): Promise<void> => {
+  // const users = ctx.service.db.primaryClient;
+  // await users.client.dropCollection('users');
+};
+`;
+    await writeFile(filePath, template, "utf8");
+    logger.info({ name, file: fileName }, "migration scaffolded");
+    return filePath;
+  };
+  return { up, down, status, create };
+};
+
+// src/mongo-helpers.ts
+var withRetry = async (fn, options = {}, _ctx) => {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+  const delayMs = options.delayMs ?? 150;
+  const logger = options.logger;
+  let attempt = 0;
+  let lastError;
+  while (attempt < maxAttempts) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      attempt += 1;
+      if (attempt >= maxAttempts || !isMongoTransientError(err)) throw err;
+      const backoff = delayMs * 2 ** (attempt - 1);
+      logger?.debug?.({ attempt, backoffMs: backoff, error: err?.message }, "retrying");
+      await sleep(backoff);
+    }
+  }
+  throw lastError ?? new Error("withRetry: no attempt was made (maxAttempts must be >= 1)");
+};
+var withTransaction = async (client, fn) => {
+  const session = client.startSession();
+  try {
+    session.startTransaction();
+    const result = await fn(session);
+    await session.commitTransaction();
+    return result;
+  } catch (err) {
+    await session.abortTransaction().catch(() => {
+    });
+    throw err;
+  } finally {
+    await session.endSession().catch(() => {
+    });
+  }
+};
+
+// src/shared/constants.ts
+var DEFAULT_MAX_LIMIT = 1e3;
+var DEFAULT_FIND_LIMIT = 100;
+var MAX_BATCH_OPS = 1e5;
+
+// src/query-builder/query-builder.ts
+var QueryBuilder = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  _filter = {};
+  _sort;
+  _skip;
+  _limit;
+  _projection;
+  _options = {};
+  get filter() {
+    return this._filter;
+  }
+  /** Shallow-merge a filter into the current one (later keys win). */
+  where(filter) {
+    this._filter = { ...this._filter, ...filter };
+    return this;
+  }
+  /** AND-combine the current filter with a new one. */
+  and(filter) {
+    this._filter = { $and: [this._filter, filter] };
+    return this;
+  }
+  /** OR-combine: current filter AND (filter1 OR filter2 ...). */
+  or(...filters) {
+    this._filter = { $and: [this._filter, { $or: filters }] };
+    return this;
+  }
+  /** Set the sort order (`{ field: 1 | -1 }`). */
+  sort(sort) {
+    this._sort = sort;
+    return this;
+  }
+  /** Skip the first `n` matching documents. */
+  skip(n) {
+    this._skip = n;
+    return this;
+  }
+  /** Limit the result set to `n` documents. */
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  /** Project only the given fields — the projection is pushed to the driver. */
+  select(fields) {
+    const projection = {};
+    for (const field of fields) projection[field] = 1;
+    this._projection = projection;
+    return this;
+  }
+  /** Raw projection document (`{ field: 1 }` / `{ field: 0 }`). */
+  project(projection) {
+    this._projection = projection;
+    return this;
+  }
+  /** Set the index hint. */
+  hint(hint) {
+    this._options.hint = hint;
+    return this;
+  }
+  /** Set the driver cursor batch size. */
+  batchSize(n) {
+    this._options.batchSize = n;
+    return this;
+  }
+  /** Run the query inside a transaction session. */
+  session(session) {
+    this._options.session = session;
+    return this;
+  }
+  /** Cap server-side execution time. */
+  maxTimeMS(ms) {
+    this._options.maxTimeMS = ms;
+    return this;
+  }
+  /** Bypass the read cache for this query when `false`. */
+  cache(on) {
+    this._options.cache = on;
+    return this;
+  }
+  /** Override in-flight dedup for this query when set. */
+  dedupe(on) {
+    this._options.dedupe = on;
+    return this;
+  }
+  /** Compile the builder into driver options (does not execute). */
+  compile() {
+    const out = { ...this._options };
+    if (this._sort) out.sort = this._sort;
+    if (this._skip !== void 0) out.skip = this._skip;
+    if (this._limit !== void 0) out.limit = this._limit;
+    if (this._projection) out.projection = this._projection;
+    return out;
+  }
+  countOptions() {
+    const out = { ...this._options };
+    if (this._skip !== void 0) out.skip = this._skip;
+    if (this._limit !== void 0) out.limit = this._limit;
+    return out;
+  }
+  /** Fetch one document (limit forced to 1). */
+  async one() {
+    const options = this.compile();
+    if (options.limit === void 0) options.limit = 1;
+    return this.ctx.run(
+      "mongo.getOne",
+      this._filter,
+      (opts) => this.ctx.collection.findOne(
+        this._filter,
+        opts
+      ),
+      options
+    );
+  }
+  /** Fetch many documents (default limit 100 when unset). */
+  async many() {
+    const options = this.compile();
+    if (options.limit === void 0) options.limit = DEFAULT_FIND_LIMIT;
+    return this.ctx.run(
+      "mongo.findMany",
+      this._filter,
+      (opts) => this.ctx.collection.find(this._filter, opts).toArray(),
+      options
+    );
+  }
+  /** Streaming cursor (raw driver cursor; no retry, applies batchSize). */
+  cursor() {
+    return this.ctx.collection.find(
+      this._filter,
+      this.compile()
+    );
+  }
+  /** Count matching documents. */
+  async count() {
+    return this.ctx.run(
+      "mongo.countDocuments",
+      this._filter,
+      (opts) => this.ctx.collection.countDocuments(this._filter, opts),
+      this.countOptions()
+    );
+  }
+  /** True when at least one document matches. */
+  async exists() {
+    return await this.one() !== null;
+  }
+};
+
+// src/relation/relation.ts
+var belongsTo = (config) => ({
+  type: "belongsTo",
+  foreignField: "_id",
+  ...config
+});
+var hasMany = (config) => ({
+  type: "hasMany",
+  foreignField: "_id",
+  ...config
+});
+var manyToMany = (config) => ({
+  type: "manyToMany",
+  foreignField: "_id",
+  ...config
+});
+
+// src/repository/repository.ts
+var createRepository = (manager, collection, options = {}) => {
+  const repo = {
+    collection,
+    manager,
+    getById: (id, o) => manager.getOne(collection, { _id: id }, o),
+    getByIds: (ids, o) => manager.findMany(collection, { _id: { $in: ids } }, o),
+    findOne: (filter, o) => manager.getOne(collection, filter, o),
+    findOneOrFail: (filter, o) => manager.getOneOrFail(collection, filter, o),
+    findMany: (filter, o) => manager.findMany(collection, filter, {
+      ...o ?? {},
+      ...options.limit !== void 0 ? { limit: options.limit } : {}
+    }),
+    findActive: (filter, o) => manager.findActive(collection, filter, o),
+    count: (filter, o) => manager.countDocuments(collection, filter, o),
+    exists: async (filter, o) => await manager.getOne(collection, filter, { ...o ?? {}, projection: { _id: 1 } }) !== null,
+    distinct: (field, filter, o) => manager.distinct(collection, field, filter, o),
+    create: (doc, o) => manager.insertOne(collection, doc, o),
+    createMany: (docs, o) => manager.insertMany(collection, docs, o),
+    update: (id, patch, o) => manager.updateOne(collection, { _id: id }, patch, o),
+    updateVersioned: (id, patch, o) => manager.updateWithVersion(collection, { _id: id }, patch, o),
+    deleteById: (id, o) => manager.deleteOne(collection, { _id: id }, o),
+    softDelete: (id, o) => manager.softDeleteOne(collection, { _id: id }, o),
+    page: (filter, config) => manager.paginateFlexible(collection, filter, config),
+    pageCursor: (filter, config) => manager.paginateCursor(collection, filter, config),
+    pipeline: (o) => manager.pipeline(collection, o),
+    aggregate: (stages, o) => manager.aggregate(collection, stages, o),
+    // The repository's public signature already validates `relations` at the
+    // call site; the manager's mapped-type param can't be re-inferred here
+    // (TS mapped-type inference friction), so delegate through the validated
+    // shape without weakening the public type.
+    populate: (docs, relations, o) => manager.populate(docs, relations, o),
+    watch: (pipeline, options2) => manager.watchCollection(collection, pipeline, options2)
+  };
+  return repo;
+};
+
+// src/schema/collections.ts
+var resolveItemName = (item) => "schema" in item ? item.schema.name : item.name;
+var resolveItemValue = (item) => {
+  if ("schema" in item) {
+    const def = item;
+    return {
+      schema: def.schema,
+      ...def.indexes ? { indexes: def.indexes } : {},
+      ...def.hooks ? { hooks: def.hooks } : {},
+      ...def.timestamps !== void 0 ? { timestamps: def.timestamps } : {}
+    };
+  }
+  return item;
+};
+var defineCollection = (name, schema, extras = {}) => {
+  const namedSchema = { ...schema, name };
+  return {
+    name,
+    schema: namedSchema,
+    ...extras.indexes ? { indexes: extras.indexes } : {},
+    ...extras.hooks ? { hooks: extras.hooks } : {},
+    ...extras.timestamps !== void 0 ? { timestamps: extras.timestamps } : {}
+  };
+};
+var defineCollections = (...items) => {
+  const out = {};
+  for (const item of items) {
+    const name = resolveItemName(item);
+    if (name in out) {
+      throw new Error(`defineCollections: duplicate collection name "${name}"`);
+    }
+    out[name] = resolveItemValue(item);
+  }
+  return out;
+};
+
+// src/schema/to-mongo-schema.ts
+var addNumericBounds = (out, field) => {
+  if (field.minimum !== void 0) out.minimum = field.minimum;
+  if (field.maximum !== void 0) out.maximum = field.maximum;
+  if (field.multipleOf !== void 0) out.multipleOf = field.multipleOf;
+  if (field.exclusiveMinimum) out.exclusiveMinimum = true;
+  if (field.exclusiveMaximum) out.exclusiveMaximum = true;
+  return out;
+};
+var convertField = (field) => {
+  if (field.kind === "raw") {
+    const out2 = { ...field.fragment };
+    if (field.description && !out2.description) out2.description = field.description;
+    return out2;
+  }
+  const out = {};
+  if (field.description) out.description = field.description;
+  switch (field.kind) {
+    case "string":
+      out.bsonType = "string";
+      if (field.minLength !== void 0) out.minLength = field.minLength;
+      if (field.maxLength !== void 0) out.maxLength = field.maxLength;
+      if (field.pattern) out.pattern = field.pattern;
+      return out;
+    case "number":
+      out.bsonType = field.integer ? "int" : "number";
+      return addNumericBounds(out, field);
+    case "double":
+      out.bsonType = "double";
+      return addNumericBounds(out, field);
+    case "long":
+      out.bsonType = "long";
+      return addNumericBounds(out, field);
+    case "decimal":
+      out.bsonType = "decimal";
+      return addNumericBounds(out, field);
+    case "boolean":
+      out.bsonType = "bool";
+      return out;
+    case "date":
+      out.bsonType = "date";
+      return out;
+    case "objectId":
+      out.bsonType = "objectId";
+      return out;
+    case "geoPoint":
+      return {
+        bsonType: "object",
+        required: ["type", "coordinates"],
+        properties: {
+          type: { enum: ["Point"] },
+          coordinates: {
+            bsonType: "array",
+            items: { bsonType: "number" },
+            minItems: 2,
+            maxItems: 2
+          }
+        }
+      };
+    case "null":
+      out.bsonType = "null";
+      return out;
+    case "any":
+      return out;
+    case "enum": {
+      out.enum = [...field.values];
+      const types = /* @__PURE__ */ new Set();
+      for (const v of field.values) {
+        if (v === null) types.add("null");
+        else if (typeof v === "string") types.add("string");
+        else if (typeof v === "number") {
+          const allInt = field.values.every((x) => typeof x !== "number" || Number.isInteger(x));
+          types.add(allInt ? "int" : "number");
+          break;
+        }
+      }
+      if (types.size === 1) {
+        out.bsonType = [...types][0];
+      } else if (types.size > 1) {
+        out.bsonType = [...types];
+      }
+      return out;
+    }
+    case "array":
+      out.bsonType = "array";
+      out.items = convertField(field.items);
+      if (field.minItems !== void 0) out.minItems = field.minItems;
+      if (field.maxItems !== void 0) out.maxItems = field.maxItems;
+      if (field.uniqueItems) out.uniqueItems = true;
+      return out;
+    case "object":
+      return convertObject(field);
+  }
+};
+var convertObject = (field) => {
+  const out = { bsonType: "object" };
+  const required = [];
+  const properties = {};
+  for (const [key, prop] of Object.entries(field.properties)) {
+    properties[key] = convertField(prop);
+    if (!prop.flags.optional && !prop.flags.hasDefault) required.push(key);
+  }
+  if (required.length > 0) out.required = required;
+  out.properties = properties;
+  out.additionalProperties = field.additionalProperties ?? false;
+  if (field.minProperties !== void 0) out.minProperties = field.minProperties;
+  if (field.maxProperties !== void 0) out.maxProperties = field.maxProperties;
+  return out;
+};
+var ORM_RESERVED_FIELDS = {
+  __v: { bsonType: "int" },
+  deletedAt: { bsonType: ["date", "null"] }
+};
+var toMongoSchema = (schema) => {
+  const result = convertObject(schema);
+  result.properties ??= {};
+  if (!result.properties._id) {
+    result.properties._id = { bsonType: "objectId" };
+  }
+  for (const [key, fragment] of Object.entries(ORM_RESERVED_FIELDS)) {
+    if (!result.properties[key]) result.properties[key] = fragment;
+  }
+  return result;
+};
+var toMongoValidator = (schema) => ({
+  $jsonSchema: toMongoSchema(schema)
+});
+
+// src/schema/types.ts
+var chain = (field) => {
+  const obj = field;
+  obj.optional = () => chain({ ...field, flags: { ...field.flags, optional: true } });
+  obj.default = (value) => chain({ ...field, flags: { ...field.flags, hasDefault: true, defaultValue: value } });
+  return obj;
+};
+var BASE = { flags: { optional: false, hasDefault: false } };
+function objectField(properties, opts = {}) {
+  return chain({ kind: "object", properties, ...BASE, ...opts });
+}
+var s = {
+  /** UTF-8 string field (optional `format` / length / regex constraints). */
+  string(opts = {}) {
+    return chain({ kind: "string", ...BASE, ...opts });
+  },
+  /** 32-bit integer field with optional bounds (min/max, exclusive, multipleOf). */
+  integer(opts = {}) {
+    return chain({ kind: "number", integer: true, ...BASE, ...opts });
+  },
+  /** Double/float field with optional bounds (min/max, exclusive, multipleOf). */
+  number(opts = {}) {
+    return chain({ kind: "number", integer: false, ...BASE, ...opts });
+  },
+  /** Strict BSON `double` (IEEE 754 float64) field. */
+  double(opts = {}) {
+    return chain({ kind: "double", ...BASE, ...opts });
+  },
+  /** Strict BSON `long` (int64) field — inferred as `number`. */
+  long(opts = {}) {
+    return chain({ kind: "long", ...BASE, ...opts });
+  },
+  /** Strict BSON `decimal` (Decimal128) field — inferred as `Decimal128`. */
+  decimal(opts = {}) {
+    return chain({ kind: "decimal", ...BASE, ...opts });
+  },
+  /** Boolean field. */
+  boolean() {
+    return chain({ kind: "boolean", ...BASE });
+  },
+  /** UTC datetime field (BSON date). */
+  date() {
+    return chain({ kind: "date", ...BASE });
+  },
+  /** MongoDB ObjectId field (`_id` and foreign keys). */
+  objectId() {
+    return chain({ kind: "objectId", ...BASE });
+  },
+  /** Array of `items` (nested schema types allowed), with optional length/uniqueness. */
+  array(items, opts = {}) {
+    const field = { kind: "array", items, ...BASE, ...opts };
+    return chain(field);
+  },
+  object: objectField,
+  /** Enum union of literal string/number values. */
+  enum(values) {
+    const field = { kind: "enum", values, ...BASE };
+    return chain(field);
+  },
+  /** Unconstrained field (no validator bounds). */
+  any() {
+    return chain({ kind: "any", ...BASE });
+  },
+  /** Explicitly-nullable field. */
+  null() {
+    return chain({ kind: "null", ...BASE });
+  },
+  /** GeoJSON Point field (type `Point` + `[lng, lat]` coordinates) for `2dsphere` queries. */
+  geoPoint() {
+    return chain({ kind: "geoPoint", ...BASE });
+  },
+  /**
+   * Raw `$jsonSchema` escape hatch: pass an arbitrary fragment through verbatim
+   * to the validator. Use for Mongo keywords the DSL doesn't model (e.g.
+   * `patternProperties`, `allOf`, `anyOf`, `dependencies`).
+   */
+  jsonSchema(fragment) {
+    return chain({ kind: "raw", fragment, ...BASE });
+  }
+};
+var optional = (field) => chain({ ...field, flags: { ...field.flags, optional: true } });
+var withDefault = (field, value) => chain({ ...field, flags: { ...field.flags, hasDefault: true, defaultValue: value } });
+var push = (issues, path, code, expected, message) => {
+  issues.push({ path, code, expected, message });
+};
+var describeValue = (value) => {
+  if (value instanceof ObjectId) return "ObjectId";
+  if (value instanceof Date) return "Date";
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+};
+var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof ObjectId) && !(value instanceof RegExp);
+var numericValue = (value) => {
+  if (value instanceof Decimal128) {
+    const n = Number(value.toString());
+    return Number.isNaN(n) ? void 0 : n;
+  }
+  if (typeof value === "number" && !Number.isNaN(value)) return value;
+  return void 0;
+};
+var checkNumericBounds = (field, value, path, issues) => {
+  const num = numericValue(value);
+  if (num === void 0) return;
+  if (field.minimum !== void 0 && (field.exclusiveMinimum ? num <= field.minimum : num < field.minimum)) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `minimum ${field.minimum}${field.exclusiveMinimum ? " (exclusive)" : ""}`,
+      `${num} out of range`
+    );
+  }
+  if (field.maximum !== void 0 && (field.exclusiveMaximum ? num >= field.maximum : num > field.maximum)) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `maximum ${field.maximum}${field.exclusiveMaximum ? " (exclusive)" : ""}`,
+      `${num} out of range`
+    );
+  }
+  if (field.multipleOf !== void 0 && field.multipleOf > 0 && num % field.multipleOf !== 0) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `multipleOf ${field.multipleOf}`,
+      `${num} is not a multiple of ${field.multipleOf}`
+    );
+  }
+};
+var bsonTypeMatches = (bsonType, value) => {
+  switch (bsonType) {
+    case "objectId":
+      return value instanceof ObjectId;
+    case "int":
+      return typeof value === "number" && Number.isInteger(value);
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "string":
+      return typeof value === "string";
+    case "bool":
+      return typeof value === "boolean";
+    case "date":
+      return value instanceof Date;
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject2(value);
+    case "double":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "long":
+      return typeof value === "number" && Number.isInteger(value);
+    case "decimal":
+      return value instanceof Decimal128;
+    default:
+      return true;
+  }
+};
+var checkReservedValue = (key, value, path, issues) => {
+  const fragment = ORM_RESERVED_FIELDS[key];
+  if (!fragment) return;
+  const types = Array.isArray(fragment.bsonType) ? fragment.bsonType : [fragment.bsonType];
+  if (types.some((t) => bsonTypeMatches(t, value))) return;
+  push(
+    issues,
+    path,
+    "type",
+    types.join(" | "),
+    `Reserved field "${key}" must be ${types.join(" | ")}`
+  );
+};
+
+// src/schema/validate-doc/field-validators.ts
+var stringValidator = (_deps, field, value, path, issues) => {
+  const f = field;
+  if (typeof value !== "string") {
+    push(issues, path, "type", "string", `Expected string, got ${describeValue(value)}`);
+    return;
+  }
+  if (f.minLength !== void 0 && value.length < f.minLength) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `string(minLength ${f.minLength})`,
+      `Length ${value.length} < ${f.minLength}`
+    );
+  }
+  if (f.maxLength !== void 0 && value.length > f.maxLength) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `string(maxLength ${f.maxLength})`,
+      `Length ${value.length} > ${f.maxLength}`
+    );
+  }
+  if (f.pattern) {
+    try {
+      if (!new RegExp(f.pattern).test(value)) {
+        push(
+          issues,
+          path,
+          "constraint",
+          `string(pattern ${f.pattern})`,
+          `"${value}" does not match pattern`
+        );
+      }
+    } catch {
+    }
+  }
+};
+var numberValidator = (_deps, field, value, path, issues) => {
+  const f = field;
+  const expected = f.integer ? "integer" : "number";
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    push(issues, path, "type", expected, `Expected ${expected}, got ${describeValue(value)}`);
+    return;
+  }
+  if (f.integer && !Number.isInteger(value)) {
+    push(issues, path, "type", "integer", `Expected integer, got ${value}`);
+  }
+  checkNumericBounds(f, value, path, issues);
+};
+var floatingValidator = (_deps, field, value, path, issues) => {
+  const f = field;
+  const ok = f.kind === "decimal" ? value instanceof Decimal128 : f.kind === "long" ? typeof value === "number" && Number.isInteger(value) : typeof value === "number" && !Number.isNaN(value);
+  if (!ok) {
+    push(issues, path, "type", f.kind, `Expected ${f.kind}, got ${describeValue(value)}`);
+    return;
+  }
+  checkNumericBounds(f, value, path, issues);
+};
+var booleanValidator = (_deps, _field, value, path, issues) => {
+  if (typeof value !== "boolean") {
+    push(issues, path, "type", "boolean", `Expected boolean, got ${describeValue(value)}`);
+  }
+};
+var dateValidator = (_deps, _field, value, path, issues) => {
+  if (!(value instanceof Date)) {
+    push(issues, path, "type", "date", `Expected Date, got ${describeValue(value)}`);
+  }
+};
+var objectIdValidator = (_deps, _field, value, path, issues) => {
+  if (!(value instanceof ObjectId)) {
+    push(issues, path, "type", "ObjectId", `Expected ObjectId, got ${describeValue(value)}`);
+  }
+};
+var geoPointValidator = (_deps, _field, value, path, issues) => {
+  if (!isPlainObject2(value)) {
+    push(issues, path, "type", "GeoPoint", `Expected GeoPoint object, got ${describeValue(value)}`);
+    return;
+  }
+  const gp = value;
+  if (gp.type !== "Point") {
+    push(
+      issues,
+      path,
+      "enum",
+      'GeoPoint(type "Point")',
+      `Expected type "Point", got ${JSON.stringify(gp.type)}`
+    );
+  }
+  const coords = gp.coordinates;
+  if (!Array.isArray(coords) || coords.length !== 2 || !coords.every((c) => typeof c === "number" && Number.isFinite(c))) {
+    push(
+      issues,
+      path,
+      "constraint",
+      "GeoPoint(coordinates: [lng, lat])",
+      "Expected [lng, lat] pair of finite numbers"
+    );
+  }
+};
+var nullValidator = (_deps, _field, value, path, issues) => {
+  if (value !== null) {
+    push(issues, path, "type", "null", `Expected null, got ${describeValue(value)}`);
+  }
+};
+var anyValidator = () => {
+};
+var rawValidator = () => {
+};
+var enumValidator = (_deps, field, value, path, issues) => {
+  const f = field;
+  if (!f.values.includes(value)) {
+    push(
+      issues,
+      path,
+      "enum",
+      `enum[${f.values.join(", ")}]`,
+      `Value ${JSON.stringify(value)} is not in the allowed set`
+    );
+  }
+};
+var arrayValidator = (deps2, field, value, path, issues) => {
+  const f = field;
+  if (!Array.isArray(value)) {
+    push(
+      issues,
+      path,
+      "type",
+      `array<${f.items.kind}>`,
+      `Expected array, got ${describeValue(value)}`
+    );
+    return;
+  }
+  if (f.minItems !== void 0 && value.length < f.minItems) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `array(minItems ${f.minItems})`,
+      `Length ${value.length} < ${f.minItems}`
+    );
+  }
+  if (f.maxItems !== void 0 && value.length > f.maxItems) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `array(maxItems ${f.maxItems})`,
+      `Length ${value.length} > ${f.maxItems}`
+    );
+  }
+  if (f.uniqueItems) {
+    const seen = new Set(
+      value.map(
+        (item) => item instanceof ObjectId ? item.toHexString() : typeof item === "object" && item !== null ? JSON.stringify(item) : item
+      )
+    );
+    if (seen.size !== value.length) {
+      push(issues, path, "constraint", "array(uniqueItems)", "Array contains duplicate items");
+    }
+  }
+  value.forEach((item, i) => {
+    deps2.validateValue(f.items, item, `${path}[${i}]`, issues);
+  });
+};
+var objectValidator = (deps2, field, value, path, issues) => {
+  const f = field;
+  if (!isPlainObject2(value)) {
+    push(issues, path, "type", "object", `Expected object, got ${describeValue(value)}`);
+    return;
+  }
+  deps2.validateObjectProps(f, value, path, issues, false);
+};
+var FIELD_VALIDATORS = {
+  string: stringValidator,
+  number: numberValidator,
+  double: floatingValidator,
+  long: floatingValidator,
+  decimal: floatingValidator,
+  boolean: booleanValidator,
+  date: dateValidator,
+  objectId: objectIdValidator,
+  geoPoint: geoPointValidator,
+  null: nullValidator,
+  any: anyValidator,
+  raw: rawValidator,
+  enum: enumValidator,
+  array: arrayValidator,
+  object: objectValidator
+};
+
+// src/schema/validate-doc/validate.ts
+function validateValue(field, value, path, issues) {
+  const validator = FIELD_VALIDATORS[field.kind];
+  if (validator) validator(deps, field, value, path, issues);
+}
+function validateObjectProps(field, value, path, issues, topLevel) {
+  const propPath = (key) => path ? `${path}.${key}` : key;
+  for (const [key, prop] of Object.entries(field.properties)) {
+    const present = key in value && value[key] !== void 0;
+    if (!present) {
+      if (!prop.flags.optional && !prop.flags.hasDefault) {
+        push(issues, propPath(key), "missing", prop.kind, `Required field "${key}" is missing`);
+      }
+      continue;
+    }
+    validateValue(prop, value[key], propPath(key), issues);
+  }
+  if (field.additionalProperties !== true) {
+    const allowedReserved = topLevel ? /* @__PURE__ */ new Set(["_id", ...Object.keys(ORM_RESERVED_FIELDS)]) : /* @__PURE__ */ new Set();
+    for (const key of Object.keys(value)) {
+      if (key in field.properties) continue;
+      if (allowedReserved.has(key)) continue;
+      push(
+        issues,
+        propPath(key),
+        "unknown_key",
+        "no additional properties",
+        `Unexpected field "${key}"`
+      );
+    }
+  }
+  const propCount = Object.keys(value).length;
+  if (field.minProperties !== void 0 && propCount < field.minProperties) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `object(minProperties ${field.minProperties})`,
+      `Has ${propCount} properties < ${field.minProperties}`
+    );
+  }
+  if (field.maxProperties !== void 0 && propCount > field.maxProperties) {
+    push(
+      issues,
+      path,
+      "constraint",
+      `object(maxProperties ${field.maxProperties})`,
+      `Has ${propCount} properties > ${field.maxProperties}`
+    );
+  }
+  if (topLevel) {
+    if ("_id" in value && !("_id" in field.properties) && value._id !== void 0) {
+      if (!(value._id instanceof ObjectId)) {
+        push(issues, "_id", "type", "ObjectId", 'Reserved field "_id" must be ObjectId');
+      }
+    }
+    for (const key of Object.keys(ORM_RESERVED_FIELDS)) {
+      if (key in field.properties) continue;
+      if (key in value && value[key] !== void 0) {
+        checkReservedValue(key, value[key], key, issues);
+      }
+    }
+  }
+}
+var deps = { validateValue, validateObjectProps };
+var validateDoc = (schema, doc) => {
+  const issues = [];
+  if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+    push(issues, "", "type", "object", `Expected a document object, got ${describeValue(doc)}`);
+    return issues;
+  }
+  validateObjectProps(schema, doc, "", issues, true);
+  return issues;
+};
+
+// src/service/collection-name.ts
+var DEFAULT_COLLECTION_PREFIX_SEPARATOR = "-";
+var createResolveCollectionName = (config) => {
+  const sep = config.collectionPrefixSeparator ?? DEFAULT_COLLECTION_PREFIX_SEPARATOR;
+  return (logical) => {
+    const override = config.collectionPhysicalNames?.[logical];
+    if (override) return override;
+    const prefix = config.collectionPrefix;
+    if (!prefix) return logical;
+    return `${prefix}${sep}${logical}`;
+  };
+};
+
+// src/service/connection-uri.ts
+var normalizeMongoUrl = (rawUrl) => {
+  try {
+    const url = new URL(rawUrl);
+    if (!url.searchParams.has("retryWrites")) url.searchParams.set("retryWrites", "false");
+    const hasWriteConcern = url.searchParams.has("w") || url.searchParams.has("wtimeoutMS") || url.searchParams.has("writeConcern");
+    if (!hasWriteConcern) url.searchParams.set("w", "1");
+    const hostCount = url.hostname.split(",").length;
+    if (hostCount === 1 && !url.searchParams.has("replicaSet") && !url.searchParams.has("directConnection")) {
+      url.searchParams.set("directConnection", "true");
+    }
+    return url.toString();
+  } catch {
+    return rawUrl;
+  }
+};
+
+// src/service/cache-invalidation.ts
+var SEP2 = "\0";
+var CacheInvalidator = class {
+  cache;
+  logger;
+  streams = /* @__PURE__ */ new Map();
+  disabled = false;
+  stopped = true;
+  warnedUnsupported = false;
+  constructor(options) {
+    this.cache = options.cache;
+    this.logger = options.logger;
+  }
+  /** Number of currently open change streams. */
+  get size() {
+    return this.streams.size;
+  }
+  /**
+   * Open one watcher per unique (database, physical collection). Idempotent:
+   * already-open streams are skipped; after `stop()` a later `start()` reopens.
+   * Never throws — failures are logged (on unsupported servers it disables once).
+   */
+  async start(refs) {
+    if (this.disabled) return;
+    this.stopped = false;
+    const seen = /* @__PURE__ */ new Set();
+    for (const ref of refs) {
+      const key = `${ref.db.databaseName}${SEP2}${ref.collection}`;
+      if (seen.has(key) || this.streams.has(key)) continue;
+      seen.add(key);
+      void this.watchLoop(key, ref);
+    }
+  }
+  /** Close every watcher. Safe to call repeatedly, and before any `start`. */
+  async stop() {
+    this.stopped = true;
+    const closes = [...this.streams.values()].map((stream) => {
+      try {
+        return Promise.resolve(stream.close()).catch(() => {
+        });
+      } catch {
+        return Promise.resolve();
+      }
+    });
+    this.streams.clear();
+    await Promise.allSettled(closes);
+  }
+  async watchLoop(key, ref) {
+    let backoff = 0;
+    while (!this.stopped) {
+      try {
+        const stream = ref.db.collection(ref.collection).watch([]);
+        stream.on("error", () => {
+        });
+        this.streams.set(key, stream);
+        if (backoff > 0) {
+          this.cache.invalidateByCollection(
+            cacheCollectionKey(ref.db.databaseName, ref.collection)
+          );
+        }
+        const iterator = stream[Symbol.asyncIterator]();
+        for await (const _change of iterator) {
+          this.cache.invalidateByCollection(
+            cacheCollectionKey(ref.db.databaseName, ref.collection)
+          );
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const abandoned = this.streams.get(key);
+        this.streams.delete(key);
+        if (abandoned) {
+          try {
+            await abandoned.close();
+          } catch {
+          }
+        }
+        if (/only supported on replica sets/i.test(message)) {
+          this.disabled = true;
+          if (!this.warnedUnsupported) {
+            this.warnedUnsupported = true;
+            this.logger.warn?.(
+              { collection: ref.collection, error: message },
+              "cacheWatch: change streams are not supported here (standalone?) \u2014 the query cache stays write-through only; set cache: { ttlMs } or disable cacheWatch"
+            );
+          }
+          return;
+        }
+        if (this.stopped) return;
+        this.logger.warn?.(
+          { error: message, collection: ref.collection },
+          "cacheWatch: change stream error, retrying with backoff"
+        );
+        backoff = Math.min(backoff + 1e3, 5e3);
+        await sleepJittered(backoff);
+      }
+    }
+  }
+};
+
+// src/utils/logger.ts
+var createNoopLogger = () => ({
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+});
+var LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
+var fmtObj = (obj) => {
+  try {
+    return JSON.stringify(obj);
+  } catch {
+    return String(obj);
+  }
+};
+var createConsoleLogger = (level = "info") => {
+  const threshold = LEVEL_RANK[level];
+  const make = (method) => {
+    const rank = LEVEL_RANK[method];
+    const fn = (a, b) => {
+      if (rank < threshold) return;
+      const obj = typeof a === "string" ? void 0 : a;
+      const msg = typeof a === "string" ? a : b;
+      const prefix = obj !== void 0 ? fmtObj(obj) : "";
+      if (msg && prefix) {
+        console[method](`[${method.toUpperCase()}]`, prefix, msg);
+      } else {
+        console[method](`[${method.toUpperCase()}]`, msg ?? prefix);
+      }
+    };
+    return fn;
+  };
+  return {
+    debug: make("debug"),
+    info: make("info"),
+    warn: make("warn"),
+    error: make("error")
+  };
+};
+
+// src/service/config.ts
+var resolveCache = (value) => {
+  if (value === null) return void 0;
+  if (value === void 0) return new QueryCache();
+  if (value instanceof QueryCache) return value;
+  return new QueryCache(value);
+};
+var resolveRuntimeConfig = (configOverrides) => {
+  const config = {
+    defaultDb: configOverrides.defaultDb ?? process.env.MONGO_URL ?? "mongodb://localhost:27017/",
+    migrationDir: configOverrides.migrationDir ?? process.env.MIGRATION_DIR ?? "./migrations",
+    appName: configOverrides.appName ?? process.env.APP_NAME ?? "unknown-app"
+  };
+  const logger = configOverrides.logger ?? createConsoleLogger();
+  const perfEnabled = configOverrides.perf !== false;
+  const sharedCache = perfEnabled ? resolveCache(configOverrides.cache) : void 0;
+  const dedupeReads = perfEnabled ? configOverrides.dedupeReads ?? true : false;
+  const wrapMongoErrors = configOverrides.wrapMongoErrors !== false;
+  return { config, logger, perfEnabled, sharedCache, dedupeReads, wrapMongoErrors };
+};
+var makeGetDbUrl = (dbClients, config) => (name) => {
+  const clientConfig = dbClients[name];
+  if (clientConfig?.dbUrl) return normalizeMongoUrl(clientConfig.dbUrl);
+  const envName = `DB_${name.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}`;
+  const envUrl = process.env[envName];
+  if (envUrl) return normalizeMongoUrl(envUrl);
+  return normalizeMongoUrl(config.defaultDb);
+};
+var makeConnectionFactory = (dbClients, db, getDbUrl, buildManager2, openedClients = /* @__PURE__ */ new Map()) => {
+  return async (names) => {
+    const keys = names && names.length > 0 ? names : Object.keys(dbClients);
+    const openedThisCall = [];
+    const assignedThisCall = [];
+    try {
+      for (const key of keys) {
+        const definition = dbClients[key];
+        const dbUrl = getDbUrl(key);
+        let client = openedClients.get(dbUrl);
+        if (!client) {
+          client = new MongoClient(dbUrl, {
+            connectTimeoutMS: definition.connectTimeoutMs ?? 1e4,
+            serverSelectionTimeoutMS: definition.connectTimeoutMs ?? 1e4,
+            ...definition.readPreference && { readPreference: definition.readPreference },
+            ...definition.readConcern && { readConcern: definition.readConcern },
+            ...definition.writeConcern && { writeConcern: definition.writeConcern }
+          });
+          client.on("error", () => {
+          });
+          openedClients.set(dbUrl, client);
+          openedThisCall.push({ url: dbUrl, client });
+          await client.connect();
+        }
+        const dbKey = `${key}Client`;
+        db[dbKey] = buildManager2(key, definition.name, client);
+        assignedThisCall.push(dbKey);
+      }
+    } catch (err) {
+      await Promise.allSettled(openedThisCall.map(({ client }) => client.close()));
+      for (const { url } of openedThisCall) openedClients.delete(url);
+      for (const dbKey of assignedThisCall) delete db[dbKey];
+      throw err;
+    }
+  };
+};
+var closeConnections = async (openedClients) => {
+  const closes = [...openedClients.values()].map((client) => {
+    try {
+      return Promise.resolve(client.close()).catch(() => {
+      });
+    } catch {
+      return Promise.resolve();
+    }
+  });
+  await Promise.allSettled(closes);
+  openedClients.clear();
+};
+
+// src/service/health.ts
+var createHealth = (db) => async () => {
+  const started = performance.now();
+  const dbs = await Promise.all(
+    Object.entries(db).map(async ([key, manager]) => {
+      const name = key.replace(/Client$/, "");
+      const handle = manager?.client;
+      if (!handle) return { name, ok: false };
+      try {
+        const t0 = performance.now();
+        await withTimeout(handle.admin().command({ ping: 1 }), 2e3, `health:${name}`);
+        return { name, ok: true, latencyMs: performance.now() - t0 };
+      } catch {
+        return { name, ok: false };
+      }
+    })
+  );
+  return { ok: dbs.every((r) => r.ok), latencyMs: performance.now() - started, dbs };
+};
+
+// src/relation/populate.ts
+var createForeignKeyLoader = (deps2, collection, foreignField, options = {}) => new DataLoader({
+  maxBatchSize: options.maxBatchSize,
+  cache: options.cache,
+  keyOf: canonicalKey,
+  batch: async (keys) => {
+    const docs = await deps2.findMany(
+      collection,
+      { [foreignField]: { $in: keys } },
+      {
+        limit: options.maxDocs
+      }
+    );
+    const index = /* @__PURE__ */ new Map();
+    for (const doc of docs) {
+      const value = doc[foreignField];
+      const canonical = canonicalKey(value);
+      const bucket = index.get(canonical) ?? [];
+      bucket.push(doc);
+      index.set(canonical, bucket);
+    }
+    const map = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      map.set(key, index.get(canonicalKey(key)) ?? []);
+    }
+    return map;
+  }
+});
+var distinctKeys = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of values) {
+    if (value === void 0 || value === null) continue;
+    const canonical = canonicalKey(value);
+    if (!seen.has(canonical)) {
+      seen.add(canonical);
+      out.push(value);
+    }
+  }
+  return out;
+};
+var makePopulator = (deps2) => {
+  const populate = async (docs, relations, options = {}) => {
+    for (const relation of relations) {
+      const target = relation.foreignField ?? "_id";
+      const sourceKeys = distinctKeys(docs.map((doc) => doc[relation.localField]));
+      if (relation.type === "belongsTo") {
+        const loader = createForeignKeyLoader(deps2, relation.collection, target, options);
+        const values = await loader.loadMany(sourceKeys);
+        const byKey = new Map(sourceKeys.map((key, i) => [canonicalKey(key), values[i]]));
+        for (const doc of docs) {
+          const key = doc[relation.localField];
+          const match = key === void 0 || key === null ? void 0 : byKey.get(canonicalKey(key))?.[0];
+          doc[relation.as] = match ?? (relation.optional ? void 0 : null);
+        }
+      } else if (relation.type === "hasMany") {
+        const loader = createForeignKeyLoader(deps2, relation.collection, target, options);
+        const values = await loader.loadMany(sourceKeys);
+        const byKey = new Map(sourceKeys.map((key, i) => [canonicalKey(key), values[i] ?? []]));
+        for (const doc of docs) {
+          const key = doc[relation.localField];
+          doc[relation.as] = key === void 0 || key === null ? [] : byKey.get(canonicalKey(key)) ?? [];
+        }
+      } else {
+        const throughLoader = createForeignKeyLoader(
+          deps2,
+          relation.through.collection,
+          relation.through.localField,
+          options
+        );
+        const throughValues = await throughLoader.loadMany(sourceKeys);
+        const throughByKey = new Map(
+          sourceKeys.map((key, i) => [canonicalKey(key), throughValues[i] ?? []])
+        );
+        const joinDocs = throughValues.flat();
+        const targetKeys = distinctKeys(
+          joinDocs.map((join3) => join3[relation.through.foreignField])
+        );
+        const targetLoader = createForeignKeyLoader(deps2, relation.collection, target, options);
+        const targetValues = await targetLoader.loadMany(targetKeys);
+        const targetByKey = new Map(
+          targetKeys.map((key, i) => [canonicalKey(key), targetValues[i] ?? []])
+        );
+        for (const doc of docs) {
+          const key = doc[relation.localField];
+          const joins = key === void 0 || key === null ? [] : throughByKey.get(canonicalKey(key)) ?? [];
+          const targets = joins.flatMap(
+            (join3) => targetByKey.get(canonicalKey(join3[relation.through.foreignField])) ?? []
+          );
+          doc[relation.as] = targets;
+        }
+      }
+    }
+    return docs;
+  };
+  return { populate };
+};
+
+// src/types.ts
+var asCollectionDefinition = (value) => {
+  if (value && typeof value === "object" && "schema" in value) {
+    const def = value;
+    const ts = def.timestamps;
+    const timestamps = ts === true ? { createdAt: "createdAt", updatedAt: "updatedAt" } : ts && typeof ts === "object" ? ts : void 0;
+    return {
+      schema: def.schema,
+      indexes: def.indexes ?? [],
+      hooks: def.hooks ?? {},
+      ...timestamps ? { timestamps } : {}
+    };
+  }
+  return { schema: value, indexes: [], hooks: {} };
+};
+
+// src/service/trace-db-op.ts
+var traceDbOp = async (logger, meta, fn, options = {}) => {
+  const start = performance.now();
+  logger.debug({ ...meta, operation: "start" }, "start");
+  try {
+    const result = await fn();
+    const durationMs = performance.now() - start;
+    logger.info({ ...meta, durationMs }, "ok");
+    return result;
+  } catch (err) {
+    const durationMs = performance.now() - start;
+    const loggable = err instanceof Error ? { name: err.name, message: err.message, code: err.code } : err;
+    logger.error({ ...meta, durationMs, error: loggable }, "error");
+    if (options.wrapMongoErrors) throw mapMongoDriverError(err, meta);
+    throw err;
+  }
+};
+
+// src/service/op-deps.ts
+var makeOpDeps = (logger, dbLabel, resolve, wrapMongoErrors) => {
+  const trace = (meta2, fn) => traceDbOp(logger, meta2, fn, { wrapMongoErrors });
+  const meta = (collection, op) => ({
+    collection: String(collection),
+    physicalCollection: resolve(String(collection)),
+    db: dbLabel,
+    op
+  });
+  return { trace, meta };
+};
+
+// src/service/query-options.ts
+var resolveQueryOptions = (options) => {
+  const maxAttempts = Math.max(1, options?.maxAttempts ?? 3);
+  const retryDelayMs = options?.retryDelayMs ?? 150;
+  const {
+    session,
+    maxTimeMS,
+    hint,
+    batchSize,
+    drift,
+    maxAttempts: _ma,
+    retryDelayMs: _rd,
+    dedupe,
+    cache,
+    retryWrites,
+    ...rest
+  } = options ?? {};
+  return {
+    maxAttempts,
+    retryDelayMs,
+    dedupe,
+    cache,
+    retryWrites,
+    sdk: { session, maxTimeMS, hint, batchSize, drift },
+    driverOpts: rest
+  };
+};
+var resolveDriftMode = (perOp, serviceDefault) => {
+  if (perOp === true) return "throw";
+  if (perOp === false) return "off";
+  if (perOp === "off" || perOp === "report" || perOp === "throw") return perOp;
+  return serviceDefault ?? "report";
+};
+
+// src/service/crud-op.ts
+var defineCrudOp = async (deps2, collection, opName, execute, options, write = false) => {
+  const resolved = resolveQueryOptions(options);
+  const maxAttempts = write && resolved.retryWrites !== true ? 1 : resolved.maxAttempts;
+  return deps2.trace(
+    deps2.meta(collection, opName),
+    async () => withRetry(async () => execute(resolved), {
+      maxAttempts,
+      delayMs: resolved.retryDelayMs
+    })
+  );
+};
+
+// src/service/pipeline-builder.ts
+var PipelineBuilder = class _PipelineBuilder {
+  constructor(deps2, stages = []) {
+    this.deps = deps2;
+    this.stages = stages;
+  }
+  /** Raw accumulated stages — embeddable into `$lookup` / `$facet` branches. */
+  raw() {
+    return this.stages;
+  }
+  assertNonNegativeFinite(name, n) {
+    if (!Number.isFinite(n) || n < 0) {
+      throw new BadRequest(`pipeline.${name}(): ${name} must be a non-negative finite number`);
+    }
+  }
+  /* --------------------------- shape-keeping --------------------------- */
+  match(filter) {
+    this.stages.push({ $match: filter });
+    return this;
+  }
+  sort(sort) {
+    this.stages.push({ $sort: sort });
+    return this;
+  }
+  limit(n) {
+    this.assertNonNegativeFinite("limit", n);
+    this.stages.push({ $limit: n });
+    return this;
+  }
+  skip(n) {
+    this.assertNonNegativeFinite("skip", n);
+    this.stages.push({ $skip: n });
+    return this;
+  }
+  sample(n) {
+    this.assertNonNegativeFinite("sample", n);
+    this.stages.push({ $sample: { size: n } });
+    return this;
+  }
+  /**
+   * `$geoNear` — requires a `2dsphere`/`2d` index and MUST be the first stage.
+   * Adds the computed distance to `spec.distanceField` on every output doc.
+   */
+  geoNear(spec) {
+    if (this.stages.length > 0) {
+      throw new Error("pipeline.geoNear(): $geoNear must be the first pipeline stage");
+    }
+    return this.derive({ $geoNear: spec });
+  }
+  /* --------------------------- shape-changing -------------------------- */
+  project(projection) {
+    return this.derive({ $project: projection });
+  }
+  addFields(fields) {
+    return this.derive({ $addFields: fields });
+  }
+  set(fields) {
+    return this.derive({ $set: fields });
+  }
+  unset(fields) {
+    return this.derive({ $unset: fields });
+  }
+  count(field) {
+    return this.derive({ $count: field });
+  }
+  group(group) {
+    return this.derive({ $group: group });
+  }
+  unwind(path) {
+    return this.derive({ $unwind: path });
+  }
+  lookup(spec) {
+    return this.derive({
+      $lookup: this.evalLookup(spec)
+    });
+  }
+  facet(facets) {
+    return this.derive({ $facet: this.evalFacets(facets) });
+  }
+  /* ------------------------------ terminals ---------------------------- */
+  /** Run the pipeline and return every output document. */
+  toArray() {
+    return defineCrudOp(
+      this.deps.crudDeps,
+      this.deps.logical,
+      "mongo.pipeline",
+      (r) => this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk)).toArray(),
+      this.deps.options
+    );
+  }
+  /** Run the pipeline and return the first output document (or null). */
+  async first() {
+    return defineCrudOp(
+      this.deps.crudDeps,
+      this.deps.logical,
+      "mongo.pipeline",
+      async (r) => {
+        const cursor = this.deps.coll().aggregate(this.stages, this.deps.mergeDriver(r.driverOpts, r.sdk));
+        try {
+          return await cursor.tryNext();
+        } finally {
+          await cursor.close();
+        }
+      },
+      this.deps.options
+    );
+  }
+  /** Streaming cursor (raw driver cursor; no retry / trace). */
+  cursor() {
+    return this.deps.coll().aggregate(this.stages, this.deps.options);
+  }
+  /* ------------------------------ internals ---------------------------- */
+  derive(stage) {
+    return new _PipelineBuilder(this.deps, [...this.stages, stage]);
+  }
+  evalLookup(spec) {
+    const { pipeline, ...rest } = spec;
+    if (typeof pipeline === "function") {
+      const sub = new _PipelineBuilder(this.deps, []);
+      const result = pipeline(sub);
+      return { ...rest, pipeline: normalizeSubPipeline(result, "$lookup") };
+    }
+    return spec;
+  }
+  evalFacets(facets) {
+    const out = {};
+    for (const [name, branch] of Object.entries(facets)) {
+      if (typeof branch === "function") {
+        const sub = new _PipelineBuilder(this.deps, []);
+        const result = branch(sub);
+        out[name] = normalizeSubPipeline(result, `$facet.${name}`);
+      } else {
+        out[name] = branch;
+      }
+    }
+    return out;
+  }
+};
+var normalizeSubPipeline = (result, where) => {
+  if (Array.isArray(result) && result.some((s2) => s2 instanceof PipelineBuilder)) {
+    throw new TypeError(
+      `aggregation sub-pipeline (${where}) must be written as a chained builder \u2014 e.g. \`(o) => o.match(...).project(...)\` \u2014 not as an array of builder results like \`[o.match(...), o.project(...)]\` (each element is a builder, not a stage).`
+    );
+  }
+  return result instanceof PipelineBuilder ? result.raw() : result;
+};
+var stageBuilder = () => new PipelineBuilder({
+  logical: "",
+  coll: () => {
+    throw new Error("stage-only pipeline builders cannot be executed");
+  },
+  crudDeps: {
+    trace: () => Promise.reject(new Error("stage-only pipeline builders cannot be executed")),
+    meta: () => ({ collection: "", physicalCollection: "", db: "", op: "" })
+  },
+  mergeDriver: () => ({})
+});
+
+// src/service/aggregation-stages.ts
+var buildAggregationStages = () => {
+  let emitted = 0;
+  const mark = (stage) => {
+    emitted++;
+    return stage;
+  };
+  return {
+    match: (filter) => mark({ $match: filter }),
+    project: (fields) => mark({ $project: fields }),
+    addFields: (fields) => mark({ $addFields: fields }),
+    set: (fields) => mark({ $set: fields }),
+    unset: (fields) => mark({ $unset: fields }),
+    sort: (sort) => mark({ $sort: sort }),
+    limit: (n) => mark({ $limit: n }),
+    skip: (n) => mark({ $skip: n }),
+    count: (field) => mark({ $count: field }),
+    group: (group) => mark({ $group: group }),
+    lookup: (params) => {
+      const { pipeline, ...rest } = params;
+      if (typeof pipeline === "function") {
+        const sub = stageBuilder();
+        const result = pipeline(sub);
+        return mark({
+          $lookup: {
+            ...rest,
+            pipeline: normalizeSubPipeline(result, "$lookup")
+          }
+        });
+      }
+      return mark({ $lookup: params });
+    },
+    facet: (facets) => {
+      const out = {};
+      for (const [name, branch] of Object.entries(facets)) {
+        out[name] = typeof branch === "function" ? branch(
+          buildAggregationStages()
+        ) : branch;
+      }
+      return mark({ $facet: out });
+    },
+    unwind: (path) => mark({ $unwind: path }),
+    fill: (params) => mark({ $fill: params }),
+    bucket: (params) => mark({ $bucket: params }),
+    bucketAuto: (params) => mark({ $bucketAuto: params }),
+    densify: (params) => mark({ $densify: params }),
+    geoNear: (spec) => {
+      if (emitted > 0) {
+        throw new Error("aggregate.geoNear(): $geoNear must be the first pipeline stage");
+      }
+      return mark({ $geoNear: spec });
+    }
+  };
+};
+
+// src/service/aggregation/aggregate.ts
+var makeAggregateOps = (ctx) => {
+  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const aggregate = async (collection, pipelineBuilder, options) => {
+    const stages = buildAggregationStages();
+    const pipeline2 = pipelineBuilder(stages);
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.aggregate",
+      (r) => coll(collection).aggregate(pipeline2, mergeAggOptions2(r.driverOpts, r.sdk)),
+      options
+    );
+  };
+  const pipeline = (collection, options) => new PipelineBuilder({
+    logical: collection,
+    coll: () => coll(collection),
+    crudDeps: deps2,
+    mergeDriver: mergeAggOptions2,
+    options
+  });
+  return { aggregate, pipeline };
+};
+
+// src/service/aggregation/helpers.ts
+var mergeAggOptions = (driverOpts, sdk) => ({
+  ...driverOpts,
+  session: sdk.session,
+  maxTimeMS: sdk.maxTimeMS,
+  hint: sdk.hint,
+  batchSize: sdk.batchSize
+});
+var DATE_PART_FORMATS = {
+  hour: "%Y-%m-%dT%H",
+  day: "%Y-%m-%d",
+  week: "%Y-W%V",
+  month: "%Y-%m",
+  year: "%Y"
+};
+
+// src/service/aggregation/group.ts
+var makeGroupOps = (ctx) => {
+  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const groupBy = async (collection, baseFilter, config, customization = {}, options) => {
+    if (config.limit !== void 0 && (!Number.isFinite(config.limit) || config.limit < 0)) {
+      throw new BadRequest("groupBy: `limit` must be a non-negative finite number");
+    }
+    const pipeline = [
+      ...customization.prePipeline ?? [],
+      { $match: baseFilter },
+      { $group: { _id: config.groupBy, ...config.accumulate ?? {} } },
+      ...config.sort && Object.keys(config.sort).length > 0 ? [{ $sort: config.sort }] : [],
+      ...config.limit !== void 0 ? [{ $limit: config.limit }] : [],
+      ...customization.postPipeline ?? []
+    ];
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.groupBy",
+      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
+      options
+    );
+  };
+  const dateRangeAnalysis = async (collection, baseFilter, dateConfig, analysisConfig = {}, customization = {}, options) => {
+    if (analysisConfig.limit !== void 0 && (!Number.isFinite(analysisConfig.limit) || analysisConfig.limit < 0)) {
+      throw new BadRequest("dateRangeAnalysis: `limit` must be a non-negative finite number");
+    }
+    const granularity = dateConfig.granularity ?? "day";
+    const format = DATE_PART_FORMATS[granularity];
+    const datePart = {
+      $dateToString: { format, date: `$${dateConfig.dateField}` }
+    };
+    const pipeline = [
+      ...customization.prePipeline ?? [],
+      {
+        $match: {
+          ...baseFilter,
+          [dateConfig.dateField]: { $gte: dateConfig.startDate, $lte: dateConfig.endDate }
+        }
+      },
+      { $group: { _id: datePart, ...analysisConfig.accumulate ?? {} } },
+      ...analysisConfig.sort && Object.keys(analysisConfig.sort).length > 0 ? [{ $sort: analysisConfig.sort }] : [],
+      ...analysisConfig.limit !== void 0 ? [{ $limit: analysisConfig.limit }] : [],
+      ...customization.postPipeline ?? []
+    ];
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.dateRangeAnalysis",
+      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
+      options
+    );
+  };
+  return { groupBy, dateRangeAnalysis };
+};
+
+// src/service/aggregation/lookup-join.ts
+var makeLookupJoinOp = (ctx) => {
+  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2, resolve } = ctx;
+  const lookupJoin = async (collection, baseFilter, lookups, customization = {}, options) => {
+    const pipeline = [
+      ...customization.prePipeline ?? [],
+      { $match: baseFilter },
+      ...lookups.map((lookup) => ({
+        $lookup: {
+          from: resolve(lookup.fromCollection),
+          localField: lookup.localField,
+          foreignField: lookup.foreignField,
+          as: lookup.as,
+          ...lookup.pipeline ? { pipeline: lookup.pipeline } : {}
+        }
+      })),
+      ...lookups.filter((lookup) => lookup.unwindSingle).map((lookup) => ({
+        $unwind: { path: `$${lookup.as}`, preserveNullAndEmptyArrays: true }
+      })),
+      ...customization.postPipeline ?? []
+    ];
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.lookupJoin",
+      (r) => coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray(),
+      options
+    );
+  };
+  return { lookupJoin };
+};
+
+// src/shared/pagination-math.ts
+var normalizePageLimit = (query, maxLimit, defaults = {}) => {
+  const rawPage = query.page ?? defaults.page ?? 1;
+  const limit = query.limit ?? defaults.limit ?? 10;
+  if (typeof rawPage !== "number" || !Number.isFinite(rawPage)) {
+    throw new BadRequest("page must be a finite number");
+  }
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    throw new BadRequest("limit must be a finite number");
+  }
+  if (limit < 1) throw new BadRequest("limit must be >= 1");
+  if (limit > maxLimit) throw new BadRequest(`limit ${limit} exceeds maxLimit ${maxLimit}`);
+  const page = Math.max(1, Math.floor(rawPage));
+  return { page, limit, offset: (page - 1) * limit };
+};
+
+// src/shared/pagination-result.ts
+var buildPaginationResult = (data, totalCount, page, limit) => {
+  const totalPages = totalCount === 0 ? 0 : Math.ceil(totalCount / limit);
+  return {
+    data,
+    totalCount,
+    hasNextPage: page < totalPages,
+    hasPrevPage: page > 1,
+    currentPage: page,
+    totalPages
+  };
+};
+
+// src/service/aggregation-pipeline.ts
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var buildRegexSearchStages = (baseFilter, searchConfig) => {
+  const { searchFields, searchTerm, fuzzy = false, caseSensitive = false } = searchConfig;
+  const escaped = escapeRegex(searchTerm);
+  const pattern = fuzzy ? escaped.split("").join(".*") : escaped;
+  const $or = searchFields.map((field) => ({
+    [field]: { $regex: pattern, $options: caseSensitive ? "" : "i" }
+  }));
+  return [{ $match: { ...baseFilter, $or } }];
+};
+var buildTextSearchStages = (baseFilter, searchConfig) => [
+  {
+    $match: {
+      ...baseFilter,
+      $text: {
+        $search: searchConfig.searchTerm,
+        ...searchConfig.caseSensitive !== void 0 && {
+          $caseSensitive: searchConfig.caseSensitive
+        },
+        ...searchConfig.language !== void 0 && { $language: searchConfig.language },
+        ...searchConfig.diacriticSensitive !== void 0 && {
+          $diacriticSensitive: searchConfig.diacriticSensitive
+        }
+      }
+    }
+  },
+  { $addFields: { searchScore: { $meta: "textScore" } } }
+];
+var buildSearchStages = (baseFilter, searchConfig) => searchConfig.useRegex ? buildRegexSearchStages(baseFilter, searchConfig) : buildTextSearchStages(baseFilter, searchConfig);
+
+// src/service/aggregation/text-search.ts
+var makeTextSearchOp = (ctx) => {
+  const { deps: deps2, coll, mergeAggOptions: mergeAggOptions2 } = ctx;
+  const textSearch = async (collection, baseFilter, searchConfig, paginationConfig = {}, customization = {}, options) => {
+    const normalized = normalizePageLimit(
+      { page: paginationConfig.page, limit: paginationConfig.limit },
+      paginationConfig.maxLimit ?? DEFAULT_MAX_LIMIT
+    );
+    const searchStages = buildSearchStages(
+      baseFilter,
+      searchConfig
+    );
+    const pipeline = [
+      ...customization.prePipeline ?? [],
+      ...searchStages,
+      {
+        $facet: {
+          data: [
+            ...searchConfig.sortByScore ? [{ $sort: { searchScore: { $meta: "textScore" } } }] : [],
+            ...paginationConfig.sort && Object.keys(paginationConfig.sort).length > 0 ? [{ $sort: paginationConfig.sort }] : [],
+            { $skip: normalized.offset },
+            { $limit: normalized.limit },
+            ...customization.postPipeline ?? []
+          ],
+          totalCount: [{ $count: "count" }]
+        }
+      }
+    ];
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.textSearch",
+      async (r) => {
+        const rows = await coll(collection).aggregate(pipeline, mergeAggOptions2(r.driverOpts, r.sdk)).toArray();
+        const row = rows[0];
+        const data = row?.data ?? [];
+        const totalCount = row?.totalCount?.[0]?.count ?? 0;
+        return buildPaginationResult(data, totalCount, normalized.page, normalized.limit);
+      },
+      options
+    );
+  };
+  return { textSearch };
+};
+
+// src/service/aggregation/index.ts
+var makeAggregationOps = (client, dbLabel, logger, opts) => {
+  const resolve = opts.resolveCollectionName;
+  const deps2 = makeOpDeps(logger, dbLabel, resolve, opts.wrapMongoErrors === true);
+  const coll = (collection) => client.collection(resolve(String(collection)));
+  const ctx = {
+    resolve,
+    deps: deps2,
+    coll,
+    mergeAggOptions
+  };
+  return {
+    ...makeAggregateOps(ctx),
+    ...makeGroupOps(ctx),
+    ...makeTextSearchOp(ctx),
+    ...makeLookupJoinOp(ctx)
+  };
+};
+
+// src/service/drift.ts
+var checkDocsDrift = (options, collection, op, docs) => {
+  if (options.drift === "off") return;
+  const schema = options.getSchema?.(collection);
+  if (!schema) return;
+  for (const doc of docs) {
+    const issues = validateDoc(schema, doc);
+    if (issues.length === 0) continue;
+    const detail = issues.map((i) => `${i.path}: ${i.message}`).join("; ");
+    const extra = { collection, db: options.db, op, issues };
+    if (options.drift === "throw") {
+      throw new DomainError(
+        "SCHEMA_DRIFT",
+        `Document drifted from schema in "${collection}": ${detail}`,
+        extra
+      );
+    }
+    options.logger.warn(extra, `[drift] ${collection} (${options.db}, ${op}): ${detail}`);
+  }
+};
+
+// src/service/update-format.ts
+var hasUpdateOperator = (update) => {
+  if (!update) return false;
+  return Object.keys(update).some((key) => key.startsWith("$"));
+};
+var formatUpdateFilter = (update) => {
+  if (hasUpdateOperator(update)) {
+    return update;
+  }
+  return { $set: update };
+};
+
+// src/service/crud/context.ts
+var createCrudContext = (client, dbLabel, logger, opts) => {
+  const resolve = opts.resolveCollectionName;
+  const deps2 = makeOpDeps(
+    logger,
+    dbLabel,
+    resolve,
+    opts.wrapMongoErrors === true
+  );
+  const coll = (name) => client.collection(resolve(String(name)));
+  const toDriverFilter = (filter) => filter;
+  const run = (collection, opName, execute, options) => defineCrudOp(deps2, collection, opName, execute, options);
+  const writeRun = (collection, opName, execute, options) => defineCrudOp(deps2, collection, opName, execute, options, true);
+  const invalidate = (collection) => {
+    opts.cache?.invalidateByCollection(
+      cacheCollectionKey(client.databaseName, resolve(String(collection)))
+    );
+  };
+  const timestampsFor = (collection) => opts.timestamps?.[String(collection)];
+  const stampCreate = (collection, doc) => {
+    const ts = timestampsFor(collection);
+    if (!ts) return;
+    const now = /* @__PURE__ */ new Date();
+    if (ts.createdAt && doc[ts.createdAt] === void 0) doc[ts.createdAt] = now;
+    if (ts.updatedAt && doc[ts.updatedAt] === void 0) doc[ts.updatedAt] = now;
+  };
+  const stampUpdate = (collection, update) => {
+    const formatted = formatUpdateFilter(update);
+    const ts = timestampsFor(collection);
+    if (ts?.updatedAt) {
+      const $set = { ...formatted.$set, [ts.updatedAt]: /* @__PURE__ */ new Date() };
+      return { ...formatted, $set };
+    }
+    return formatted;
+  };
+  const stampReplace = (collection, doc) => {
+    const ts = timestampsFor(collection);
+    if (!ts?.updatedAt) return doc;
+    return { ...doc, [ts.updatedAt]: /* @__PURE__ */ new Date() };
+  };
+  const read = async (collection, opName, filter, options, execute, shape = "none") => {
+    const physical = resolve(String(collection));
+    const resolved = resolveQueryOptions(options);
+    const noSession = !resolved.sdk.session;
+    const useCache = opts.cache !== void 0 && noSession && resolved.cache !== false;
+    const shouldDedupe = resolved.dedupe !== false && (resolved.dedupe === true || opts.dedupeReads === true && noSession) && opts.inFlight !== void 0;
+    const checkDrift = (value) => {
+      const mode = resolveDriftMode(resolved.sdk.drift, opts.drift);
+      if (mode === "off") return;
+      if (resolved.driverOpts.projection !== void 0) return;
+      const docs = shape === "many" ? value : shape === "one" && value !== null ? [value] : [];
+      checkDocsDrift(
+        { logger, db: dbLabel, drift: mode, getSchema: opts.getSchema },
+        String(collection),
+        opName,
+        docs
+      );
+    };
+    const executeWrapped = () => deps2.trace(
+      deps2.meta(collection, opName),
+      () => withRetry(() => execute(resolved), {
+        maxAttempts: resolved.maxAttempts,
+        delayMs: resolved.retryDelayMs
+      })
+    );
+    const key = useCache ? opts.cache.key(
+      cacheCollectionKey(client.databaseName, physical),
+      stableHash([filter, options])
+    ) : void 0;
+    const fetchAndCheck = () => executeWrapped().then((value) => {
+      checkDrift(value);
+      return value;
+    });
+    const runOnce = () => {
+      if (useCache && key) {
+        const hit = opts.cache.get(key);
+        if (hit !== void 0) return Promise.resolve(hit);
+        return fetchAndCheck().then((value) => {
+          opts.cache.set(key, value);
+          return value;
+        });
+      }
+      return fetchAndCheck();
+    };
+    if (shouldDedupe) {
+      const dedupeKey = `${cacheCollectionKey(client.databaseName, physical)}|${opName}|${stableHash([filter, options])}`;
+      return opts.inFlight.run(dedupeKey, runOnce);
+    }
+    return runOnce();
+  };
+  const normalizeFindOptions = (options) => {
+    if (!options) return {};
+    const { select, ...rest } = options;
+    if (!select || select.length === 0) return rest;
+    const projection = {};
+    for (const field of select) projection[String(field)] = 1;
+    return { ...rest, projection };
+  };
+  return {
+    client,
+    dbLabel,
+    logger,
+    opts,
+    resolve,
+    trace: deps2.trace,
+    meta: deps2.meta,
+    coll,
+    toDriverFilter,
+    run,
+    writeRun,
+    invalidate,
+    stampCreate,
+    stampUpdate,
+    stampReplace,
+    read,
+    normalizeFindOptions
+  };
+};
+
+// src/shared/soft-delete.ts
+var buildMongoActiveFilter = () => ({ $or: [{ deletedAt: { $exists: false } }, { deletedAt: null }] });
+var mergeMongoActiveFilter = (softDelete, filter) => {
+  if (!softDelete) return filter ?? {};
+  const active = buildMongoActiveFilter();
+  if (!filter || Object.keys(filter).length === 0) return active;
+  return { $and: [filter, active] };
+};
+
+// src/service/crud/read-ops.ts
+var makeReadOps = (ctx) => {
+  const { client, opts } = ctx;
+  const { coll, toDriverFilter, read, normalizeFindOptions } = ctx;
+  const getOne = async (collection, filter, options) => {
+    const f = filter ?? {};
+    const o = normalizeFindOptions(options);
+    const doc = await read(
+      collection,
+      "mongo.getOne",
+      f,
+      o,
+      async (r) => {
+        const opts2 = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint
+        };
+        return coll(collection).findOne(toDriverFilter(f), opts2);
+      },
+      "one"
+    );
+    if (doc !== null && hasHook(opts.hooks, String(collection), "afterRead")) {
+      const exposed = cloneDeep(doc);
+      await runHooks(opts.hooks, String(collection), "afterRead", {
+        collection: String(collection),
+        doc: exposed
+      });
+      return exposed;
+    }
+    return doc;
+  };
+  const getOneOrFail = async (collection, filter, options, errorFactory) => {
+    const doc = await getOne(collection, filter, options);
+    if (doc === null) {
+      if (errorFactory) throw errorFactory(String(collection));
+      throw new DomainError(
+        "NOT_FOUND",
+        `Document not found in collection "${String(collection)}"`,
+        {
+          collection: String(collection)
+        }
+      );
+    }
+    return doc;
+  };
+  const findMany = async (collection, filter, options) => {
+    const merged = normalizeFindOptions({
+      ...options,
+      limit: options?.limit ?? DEFAULT_FIND_LIMIT
+    });
+    const docs = await read(
+      collection,
+      "mongo.findMany",
+      filter ?? {},
+      merged,
+      async (r) => {
+        const opts2 = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint
+        };
+        return coll(collection).find(toDriverFilter(filter ?? {}), opts2).toArray();
+      },
+      "many"
+    );
+    if (hasHook(opts.hooks, String(collection), "afterRead")) {
+      const exposed = cloneDeep(docs);
+      await runHooks(opts.hooks, String(collection), "afterRead", {
+        collection: String(collection),
+        docs: exposed
+      });
+      return exposed;
+    }
+    return docs;
+  };
+  const findManyCursor = (collection, filter, options) => {
+    const {
+      session,
+      hint,
+      maxTimeMS,
+      batchSize,
+      maxAttempts: _ma,
+      retryDelayMs: _rd,
+      dedupe: _d,
+      cache: _c,
+      ...rest
+    } = normalizeFindOptions(options);
+    const findOpts = {
+      ...rest,
+      ...session && { session },
+      ...hint && { hint },
+      ...maxTimeMS && { maxTimeMS },
+      ...batchSize && { batchSize }
+    };
+    return coll(collection).find(toDriverFilter(filter ?? {}), findOpts);
+  };
+  const findActive = async (collection, filter, options) => findMany(collection, mergeMongoActiveFilter(true, filter), options);
+  const findActiveOne = async (collection, filter, options) => getOne(collection, mergeMongoActiveFilter(true, filter), options);
+  const countDocuments = async (collection, filter, options) => read(
+    collection,
+    "mongo.countDocuments",
+    filter ?? {},
+    options,
+    async (r) => {
+      const opts2 = {
+        ...r.driverOpts,
+        session: r.sdk.session,
+        maxTimeMS: r.sdk.maxTimeMS,
+        hint: r.sdk.hint
+      };
+      return coll(collection).countDocuments(toDriverFilter(filter ?? {}), opts2);
+    },
+    "none"
+  );
+  const distinct = async (collection, field, filter, options) => {
+    const f = filter ?? {};
+    const o = normalizeFindOptions(options);
+    return read(
+      collection,
+      "mongo.distinct",
+      f,
+      o,
+      async (r) => {
+        const opts2 = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint
+        };
+        return coll(collection).distinct(
+          String(field),
+          toDriverFilter(f),
+          opts2
+        );
+      },
+      "none"
+    );
+  };
+  const estimatedDocumentCount = async (collection, options) => ctx.run(
+    collection,
+    "mongo.estimatedDocumentCount",
+    async (r) => {
+      const opts2 = {
+        ...r.driverOpts,
+        session: r.sdk.session,
+        maxTimeMS: r.sdk.maxTimeMS
+      };
+      return coll(collection).estimatedDocumentCount(opts2);
+    },
+    options
+  );
+  return {
+    getOne,
+    getOneOrFail,
+    findMany,
+    findManyCursor,
+    findActive,
+    findActiveOne,
+    countDocuments,
+    distinct,
+    estimatedDocumentCount
+  };
+};
+
+// src/service/crud/watch-ops.ts
+var makeWatchOps = (ctx) => {
+  const { client, resolve, coll, read } = ctx;
+  const watchCollection = (collection, pipeline, options) => coll(collection).watch(pipeline, options);
+  const query = (collection) => {
+    const physical = resolve(String(collection));
+    const handle = client.collection(physical);
+    return new QueryBuilder({
+      physicalName: physical,
+      collection: handle,
+      run: async (opName, filter, execute, options) => read(
+        collection,
+        opName,
+        filter,
+        options,
+        async (r) => {
+          const opts = {
+            ...r.driverOpts,
+            session: r.sdk.session,
+            maxTimeMS: r.sdk.maxTimeMS,
+            hint: r.sdk.hint
+          };
+          return execute(opts);
+        },
+        opName === "mongo.getOne" ? "one" : opName === "mongo.findMany" ? "many" : "none"
+      )
+    });
+  };
+  return {
+    watchCollection,
+    query
+  };
+};
+
+// src/service/crud/write-ops.ts
+var makeWriteOps = (ctx, readOps) => {
+  const { opts } = ctx;
+  const { coll, toDriverFilter, writeRun, invalidate, stampCreate, stampUpdate, stampReplace } = ctx;
+  const { getOne } = readOps;
+  const insertOne = async (collection, doc, options) => {
+    await runHooks(opts.hooks, String(collection), "beforeCreate", {
+      collection: String(collection),
+      doc
+    });
+    stampCreate(collection, doc);
+    const result = await writeRun(
+      collection,
+      "mongo.insertOne",
+      async (r) => {
+        const insertOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).insertOne(doc, insertOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    await runHooks(opts.hooks, String(collection), "afterCreate", {
+      collection: String(collection),
+      doc
+    });
+    return result;
+  };
+  const insertMany = async (collection, docs, options) => {
+    await runHooks(opts.hooks, String(collection), "beforeCreate", {
+      collection: String(collection),
+      docs
+    });
+    for (const d of docs) stampCreate(collection, d);
+    if (docs.length > MAX_BATCH_OPS) {
+      throw new BadRequest(
+        `insertMany: too many docs (${docs.length} > ${MAX_BATCH_OPS}); split the batch`
+      );
+    }
+    const result = await writeRun(
+      collection,
+      "mongo.insertMany",
+      async (r) => {
+        const bulkOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).insertMany(
+          docs,
+          bulkOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    await runHooks(opts.hooks, String(collection), "afterCreate", {
+      collection: String(collection),
+      docs
+    });
+    return result;
+  };
+  const updateOne = async (collection, filter, update, options) => {
+    await runHooks(opts.hooks, String(collection), "beforeUpdate", {
+      collection: String(collection),
+      filter
+    });
+    const effective = stampUpdate(collection, update);
+    const result = await writeRun(
+      collection,
+      "mongo.updateOne",
+      async (r) => {
+        const updateOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).updateOne(
+          toDriverFilter(filter),
+          effective,
+          updateOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    await runHooks(opts.hooks, String(collection), "afterUpdate", {
+      collection: String(collection),
+      filter
+    });
+    return result;
+  };
+  const updateMany = async (collection, filter, update, options) => {
+    const effective = stampUpdate(collection, update);
+    const result = await writeRun(
+      collection,
+      "mongo.updateMany",
+      async (r) => {
+        const updateOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).updateMany(
+          toDriverFilter(filter),
+          effective,
+          updateOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const findOneAndUpdate = async (collection, filter, update, options) => {
+    const effective = stampUpdate(collection, update);
+    const result = await writeRun(
+      collection,
+      "mongo.findOneAndUpdate",
+      async (r) => {
+        const fOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint,
+          // `after` is the ORM's default, but honor an explicit caller override.
+          returnDocument: r.driverOpts.returnDocument ?? "after"
+        };
+        return coll(collection).findOneAndUpdate(
+          toDriverFilter(filter),
+          effective,
+          fOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const findOneAndReplace = async (collection, filter, replacement, options) => {
+    const effective = stampReplace(collection, replacement);
+    const result = await writeRun(
+      collection,
+      "mongo.findOneAndReplace",
+      async (r) => {
+        const fOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint,
+          // `after` is the ORM's default, but honor an explicit caller override.
+          returnDocument: r.driverOpts.returnDocument ?? "after"
+        };
+        return coll(collection).findOneAndReplace(
+          toDriverFilter(filter),
+          effective,
+          fOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const replaceOne = async (collection, filter, replacement, options) => {
+    const result = await writeRun(
+      collection,
+      "mongo.replaceOne",
+      async (r) => {
+        const repOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).replaceOne(
+          toDriverFilter(filter),
+          stampReplace(collection, replacement),
+          repOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const deleteOne = async (collection, filter, options) => {
+    await runHooks(opts.hooks, String(collection), "beforeDelete", {
+      collection: String(collection),
+      filter
+    });
+    const result = await writeRun(
+      collection,
+      "mongo.deleteOne",
+      async (r) => {
+        const delOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).deleteOne(toDriverFilter(filter), delOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    await runHooks(opts.hooks, String(collection), "afterDelete", {
+      collection: String(collection),
+      filter
+    });
+    return result;
+  };
+  const deleteMany = async (collection, filter, options) => {
+    const result = await writeRun(
+      collection,
+      "mongo.deleteMany",
+      async (r) => {
+        const delOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).deleteMany(toDriverFilter(filter), delOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const findOneAndDelete = async (collection, filter, options) => {
+    const result = await writeRun(
+      collection,
+      "mongo.findOneAndDelete",
+      async (r) => {
+        const fOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint
+        };
+        return coll(collection).findOneAndDelete(
+          toDriverFilter(filter),
+          fOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const softDeleteOne = async (collection, filter, options) => {
+    const active = mergeMongoActiveFilter(true, filter);
+    const result = await writeRun(
+      collection,
+      "mongo.softDeleteOne",
+      async (r) => {
+        const updateOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).updateOne(
+          active,
+          { $set: { deletedAt: /* @__PURE__ */ new Date() } },
+          updateOpts
+        );
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const upsert = async (collection, filter, update, options) => {
+    const formatted = stampUpdate(collection, update);
+    const result = await writeRun(
+      collection,
+      "mongo.upsert",
+      async (r) => {
+        const updateOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          upsert: true
+        };
+        return coll(collection).updateOne(toDriverFilter(filter), formatted, updateOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const bulkUpsert = async (collection, operations, options) => {
+    const writes = operations.map((op) => ({
+      updateOne: {
+        filter: op.filter,
+        update: stampUpdate(collection, op.update),
+        upsert: op.upsert ?? true
+      }
+    }));
+    if (operations.length > MAX_BATCH_OPS) {
+      throw new BadRequest(
+        `bulkUpsert: too many operations (${operations.length} > ${MAX_BATCH_OPS}); split the batch`
+      );
+    }
+    const result = await writeRun(
+      collection,
+      "mongo.bulkUpsert",
+      async (r) => {
+        const bulkOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).bulkWrite(writes, bulkOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const bulkWrite = async (collection, operations, options) => {
+    if (operations.length > MAX_BATCH_OPS) {
+      throw new BadRequest(
+        `bulkWrite: too many operations (${operations.length} > ${MAX_BATCH_OPS}); split the batch`
+      );
+    }
+    const result = await writeRun(
+      collection,
+      "mongo.bulkWrite",
+      async (r) => {
+        const bulkOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session
+        };
+        return coll(collection).bulkWrite(operations, bulkOpts);
+      },
+      options
+    );
+    invalidate(collection);
+    return result;
+  };
+  const updateWithVersion = async (collection, filter, update, options) => {
+    const existing = await getOne(collection, filter, {
+      ...options,
+      cache: false
+    });
+    if (!existing) return { ok: false, reason: "not_found" };
+    const current = existing.__v;
+    const versionFilter = current === void 0 ? { __v: { $exists: false } } : { __v: current };
+    const formatted = stampUpdate(collection, update);
+    const versionedUpdate = {
+      ...formatted,
+      $inc: { ...formatted.$inc, __v: 1 }
+    };
+    const result = await findOneAndUpdate(
+      collection,
+      { ...filter, ...versionFilter },
+      versionedUpdate,
+      { ...options, returnDocument: "after" }
+    );
+    if (result === null) return { ok: false, reason: "version_conflict" };
+    return { ok: true, doc: result };
+  };
+  return {
+    insertOne,
+    insertMany,
+    updateOne,
+    updateMany,
+    findOneAndUpdate,
+    findOneAndReplace,
+    deleteOne,
+    deleteMany,
+    softDeleteOne,
+    upsert,
+    bulkUpsert,
+    bulkWrite,
+    updateWithVersion,
+    findOneAndDelete,
+    replaceOne
+  };
+};
+
+// src/service/crud/index.ts
+var makeCrudOps = (client, dbLabel, logger, opts) => {
+  const ctx = createCrudContext(client, dbLabel, logger, opts);
+  const readOps = makeReadOps(ctx);
+  return {
+    ...readOps,
+    ...makeWriteOps(ctx, readOps),
+    ...makeWatchOps(ctx)
+  };
+};
+var tag = (value) => {
+  if (value instanceof ObjectId) return { t: "oid", v: value.toHexString() };
+  if (value instanceof Date) return { t: "date", v: value.toISOString() };
+  if (typeof value === "string") return { t: "string", v: value };
+  if (typeof value === "number") return { t: "number", v: value };
+  if (typeof value === "boolean") return { t: "boolean", v: value };
+  if (value === null || value === void 0) return { t: "null" };
+  throw new BadRequest(
+    `paginateCursor: unsupported sort value type "${typeof value}" \u2014 key values must be ObjectId, Date, string, number, boolean, or null`
+  );
+};
+var untag = (tagged) => {
+  switch (tagged.t) {
+    case "oid":
+      return new ObjectId(tagged.v);
+    case "date":
+      return new Date(tagged.v);
+    case "string":
+      return tagged.v;
+    case "number":
+      return tagged.v;
+    case "boolean":
+      return tagged.v;
+    case "null":
+      return null;
+  }
+};
+var encodeCursor = (cursor) => Buffer.from(
+  JSON.stringify({
+    sort: cursor.sort,
+    values: cursor.values.map(tag)
+  }),
+  "utf8"
+).toString("base64url");
+var decodeCursor = (cursor) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new BadRequest("paginateCursor: invalid cursor");
+  }
+  if (!parsed || typeof parsed !== "object" || !parsed.sort || !Array.isArray(parsed.values)) {
+    throw new BadRequest("paginateCursor: invalid cursor payload");
+  }
+  return { sort: parsed.sort, values: parsed.values.map(untag) };
+};
+var buildKeysetFilter = (sort, values, direction) => {
+  const keys = Object.entries(sort);
+  const ors = [];
+  for (let i = 0; i < keys.length; i++) {
+    const cond = {};
+    for (let j = 0; j < i; j++) {
+      const [f] = keys[j];
+      cond[f] = values[j];
+    }
+    const [field, dir] = keys[i];
+    const value = values[i];
+    const cmp = direction === "after" ? dir === 1 ? "$gt" : "$lt" : dir === 1 ? "$lt" : "$gt";
+    cond[field] = { [cmp]: value };
+    ors.push(cond);
+  }
+  return { $or: ors };
+};
+
+// src/service/pagination/cursor.ts
+var makePaginateCursor = (ctx) => {
+  const { client, dbLabel, logger, opts, resolve, deps: deps2 } = ctx;
+  const paginateCursor = async (collection, baseFilter, config) => {
+    const sortKeys = Object.entries(config.sort);
+    if (sortKeys.length === 0) {
+      throw new BadRequest(
+        "paginateCursor: `sort` is required (include a unique tiebreaker like `_id`)"
+      );
+    }
+    if (config.before !== void 0 && config.after !== void 0) {
+      throw new BadRequest("paginateCursor: provide either `after` or `before`, not both");
+    }
+    const limit = normalizePageLimit(
+      { page: 1, limit: config.limit },
+      config.maxLimit ?? DEFAULT_MAX_LIMIT,
+      { limit: DEFAULT_FIND_LIMIT }
+    ).limit;
+    const backwards = config.before !== void 0 && config.after === void 0;
+    const effectiveSort = backwards ? Object.fromEntries(sortKeys.map(([f, d]) => [f, d * -1])) : config.sort;
+    let filter = baseFilter;
+    if (config.after !== void 0 || config.before !== void 0) {
+      const cursor = config.after ?? config.before;
+      const decoded = decodeCursor(cursor);
+      if (JSON.stringify(decoded.sort) !== JSON.stringify(config.sort)) {
+        throw new BadRequest("paginateCursor: cursor was created with a different sort");
+      }
+      if (decoded.values.length !== sortKeys.length) {
+        throw new BadRequest("paginateCursor: cursor was created with a different sort");
+      }
+      filter = {
+        $and: [baseFilter, buildKeysetFilter(effectiveSort, decoded.values, "after")]
+      };
+    }
+    const rows = await defineCrudOp(
+      deps2,
+      collection,
+      "mongo.paginateCursor",
+      async (r) => {
+        const findOpts = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint
+        };
+        return client.collection(resolve(String(collection))).find(filter, findOpts).sort(effectiveSort).limit(limit + 1).toArray();
+      },
+      config.queryOptions
+    );
+    const hasMore = rows.length > limit;
+    const page = backwards ? rows.slice(0, limit).reverse() : rows.slice(0, limit);
+    checkDocsDrift(
+      {
+        logger,
+        db: dbLabel,
+        drift: resolveDriftMode(config.queryOptions?.drift, opts.drift),
+        getSchema: opts.getSchema
+      },
+      String(collection),
+      "mongo.paginateCursor",
+      page
+    );
+    const boundary = backwards ? rows[limit] : page[page.length - 1];
+    const nextCursor = hasMore && boundary !== void 0 ? encodeCursor({
+      sort: config.sort,
+      values: sortKeys.map(([f]) => boundary[f])
+    }) : null;
+    return { data: page, nextCursor, hasMore };
+  };
+  return { paginateCursor };
+};
+
+// src/service/pagination/offset.ts
+var makePaginateFlexible = (ctx) => {
+  const { client, dbLabel, logger, opts, resolve, deps: deps2 } = ctx;
+  const paginateFlexible = async (collection, baseFilter, config = {}) => {
+    const normalized = normalizePageLimit(
+      { page: config.page, limit: config.limit },
+      config.maxLimit ?? DEFAULT_MAX_LIMIT
+    );
+    const dataStages = [
+      ...config.prePipeline ?? [],
+      ...config.sort && Object.keys(config.sort).length > 0 ? [{ $sort: config.sort }] : [],
+      { $skip: normalized.offset },
+      { $limit: normalized.limit },
+      ...config.postPipeline ?? []
+    ];
+    const pipeline = [
+      { $match: baseFilter },
+      {
+        $facet: {
+          data: dataStages,
+          totalCount: [{ $count: "count" }]
+        }
+      }
+    ];
+    return defineCrudOp(
+      deps2,
+      collection,
+      "mongo.paginateFlexible",
+      async (r) => {
+        const aggOptions = {
+          ...r.driverOpts,
+          session: r.sdk.session,
+          maxTimeMS: r.sdk.maxTimeMS,
+          hint: r.sdk.hint,
+          batchSize: r.sdk.batchSize
+        };
+        const rows = await client.collection(resolve(String(collection))).aggregate(pipeline, aggOptions).toArray();
+        const row = rows[0];
+        const data = row?.data ?? [];
+        const totalCount = row?.totalCount?.[0]?.count ?? 0;
+        checkDocsDrift(
+          {
+            logger,
+            db: dbLabel,
+            drift: resolveDriftMode(config.queryOptions?.drift, opts.drift),
+            getSchema: opts.getSchema
+          },
+          String(collection),
+          "mongo.paginateFlexible",
+          data
+        );
+        return buildPaginationResult(data, totalCount, normalized.page, normalized.limit);
+      },
+      config.queryOptions
+    );
+  };
+  return { paginateFlexible };
+};
+
+// src/service/pagination/index.ts
+var makePaginationOps = (client, dbLabel, logger, opts) => {
+  const resolve = opts.resolveCollectionName;
+  const deps2 = makeOpDeps(logger, dbLabel, resolve, opts.wrapMongoErrors === true);
+  const ctx = {
+    client,
+    dbLabel,
+    logger,
+    opts,
+    resolve,
+    deps: deps2
+  };
+  return {
+    ...makePaginateFlexible(ctx),
+    ...makePaginateCursor(ctx)
+  };
+};
+
+// src/service/schema-ops.ts
+var indexKeyOf = (key) => JSON.stringify(
+  Object.keys(key).sort().map((k) => [k, key[k]])
+);
+var makeSchemaOps = (client, _logger, opts) => {
+  const createSchema = async (collection, createCollectionOptions) => {
+    const physical = opts.resolveCollectionName(collection);
+    const def = opts.getDefinition(collection);
+    const validator = def?.schema ? toMongoValidator(def.schema) : void 0;
+    try {
+      await client.createCollection(physical, {
+        ...validator ? { validator } : {},
+        ...createCollectionOptions ?? {}
+      });
+    } catch (err) {
+      if (err?.code === 48) {
+        throw new DomainError("COLLECTION_EXISTS", `Collection "${collection}" already exists`, {
+          physicalCollection: physical
+        });
+      }
+      throw err;
+    }
+    const indexes = def?.indexes ?? [];
+    if (indexes.length > 0) {
+      try {
+        await client.collection(physical).createIndexes(
+          indexes.map((index) => ({
+            key: index.key,
+            ...index.options ?? {}
+          }))
+        );
+      } catch (err) {
+        await client.dropCollection(physical).catch(() => {
+        });
+        throw err;
+      }
+    }
+  };
+  const updateSchema = async (collection, schema) => {
+    const physical = opts.resolveCollectionName(collection);
+    const def = opts.getDefinition(collection);
+    const resolved = schema ?? def?.schema;
+    if (!resolved) {
+      throw new Error(`No schema available for collection "${collection}"`);
+    }
+    await client.command({
+      collMod: physical,
+      validator: toMongoValidator(resolved)
+    });
+  };
+  const syncIndexes = async (collection) => {
+    const physical = opts.resolveCollectionName(collection);
+    const def = opts.getDefinition(collection);
+    const declared = def?.indexes ?? [];
+    const handle = client.collection(physical);
+    const existing = (await handle.listIndexes().toArray()).filter((i) => i.name !== "_id_");
+    const existingByKey = new Map(
+      existing.map((i) => [indexKeyOf(i.key), i.name])
+    );
+    const declaredByKey = new Map(declared.map((d) => [indexKeyOf(d.key), d]));
+    const created = [];
+    const dropped = [];
+    for (const [key] of declaredByKey) {
+      if (!existingByKey.has(key)) {
+        await handle.createIndex(
+          declaredByKey.get(key).key,
+          declaredByKey.get(key).options
+        );
+      }
+    }
+    const after = (await handle.listIndexes().toArray()).filter((i) => i.name !== "_id_");
+    const afterByKey = new Map(after.map((i) => [indexKeyOf(i.key), i.name]));
+    for (const [key, spec] of declaredByKey) {
+      if (!existingByKey.has(key)) {
+        created.push(spec.options?.name ?? afterByKey.get(key) ?? JSON.stringify(spec.key));
+      }
+    }
+    for (const [key, name] of existingByKey) {
+      if (!declaredByKey.has(key)) {
+        await handle.dropIndex(name);
+        dropped.push(name);
+      }
+    }
+    return { created, dropped };
+  };
+  return { createSchema, updateSchema, syncIndexes };
+};
+
+// src/service/transaction.ts
+var makeTransactionOps = (client, handle, logger, _config, opts) => {
+  const transaction = async (fn, options) => {
+    const session = client.startSession();
+    try {
+      return await session.withTransaction(async () => fn(session), options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "";
+      const code = err?.code;
+      const unsupported = code === 20 || /Transaction numbers are only allowed/i.test(message) || /does not support retryable writes/i.test(message);
+      if (unsupported) {
+        logger.warn?.({ code }, "transactions unsupported, falling back to non-transactional");
+        return fn(null);
+      }
+      if (opts.wrapMongoErrors) {
+        throw mapMongoDriverError(err, { db: handle.databaseName, op: "transaction" });
+      }
+      throw err;
+    } finally {
+      await session.endSession();
+    }
+  };
+  const migrate = async (name, fn, filePath) => {
+    const journal = handle.collection(
+      opts.migrationCollectionPhysical
+    );
+    await transaction(async (session) => {
+      const sessionOpts = session ? { session } : {};
+      const claim = await journal.findOneAndUpdate(
+        { name },
+        {
+          $setOnInsert: {
+            name,
+            appliedAt: /* @__PURE__ */ new Date(),
+            ...filePath ? { file: filePath } : {}
+          }
+        },
+        { upsert: true, returnDocument: "before", ...sessionOpts }
+      );
+      if (claim) {
+        logger.info({ name }, "migration already applied, skipping");
+        return;
+      }
+      try {
+        await fn(session);
+      } catch (err) {
+        await journal.deleteOne({ name }, sessionOpts).catch(() => {
+        });
+        throw err;
+      }
+    });
+  };
+  return { transaction, migrate };
+};
+
+// src/service/manager.ts
+var buildManager = (deps2, dbKey, dbName, client) => {
+  const { dbClients, config, logger, sharedCache, dedupeReads, inFlight, collectionRefs } = deps2;
+  const definition = dbClients[dbKey];
+  const handle = client.db(dbName);
+  const baseResolveCollectionName = createResolveCollectionName(definition);
+  const registry = /* @__PURE__ */ new Map();
+  const hooks = {};
+  const timestamps = {};
+  for (const [logical, value] of Object.entries(definition.collections)) {
+    const def = asCollectionDefinition(value);
+    registry.set(logical, def);
+    hooks[logical] = def.hooks;
+    if (def.timestamps) timestamps[logical] = def.timestamps;
+    collectionRefs.push({ db: handle, collection: baseResolveCollectionName(logical) });
+  }
+  const getDefinition = (logical) => registry.get(logical);
+  const resolveCollectionName = (logical) => {
+    if (!registry.has(logical) && !logical.startsWith("_")) {
+      throw new BadRequest(`Unknown collection "${logical}"`);
+    }
+    return baseResolveCollectionName(logical);
+  };
+  const crud = makeCrudOps(handle, dbName, logger, {
+    resolveCollectionName,
+    wrapMongoErrors: deps2.wrapMongoErrors,
+    cache: sharedCache,
+    dedupeReads,
+    inFlight,
+    hooks,
+    timestamps,
+    drift: deps2.drift,
+    getSchema: (logical) => getDefinition(logical)?.schema
+  });
+  const pagination = makePaginationOps(handle, dbName, logger, {
+    resolveCollectionName,
+    wrapMongoErrors: deps2.wrapMongoErrors,
+    drift: deps2.drift,
+    getSchema: (logical) => getDefinition(logical)?.schema
+  });
+  const aggregation = makeAggregationOps(handle, dbName, logger, {
+    resolveCollectionName,
+    wrapMongoErrors: deps2.wrapMongoErrors
+  });
+  const schema = makeSchemaOps(handle, logger, { resolveCollectionName, getDefinition });
+  const transactionOps = makeTransactionOps(client, handle, logger, config, {
+    migrationCollectionPhysical: resolveCollectionName("_migrations"),
+    wrapMongoErrors: deps2.wrapMongoErrors
+  });
+  const populator = makePopulator({
+    findMany: async (logical, filter, options) => {
+      const physical = resolveCollectionName(logical);
+      return handle.collection(physical).find(filter, {
+        projection: options?.projection,
+        limit: options?.limit ?? 1e4
+      }).toArray();
+    }
+  });
+  const populate = (async (docs, relations, options = {}) => {
+    const result = await populator.populate(docs, relations, options);
+    return result;
+  });
+  return {
+    ...crud,
+    ...pagination,
+    ...aggregation,
+    ...schema,
+    ...transactionOps,
+    populate,
+    client: handle,
+    db: deps2.db
+  };
+};
+
+// src/service/index.ts
+var createMongoService = (dbClients, configOverrides = {}) => {
+  const runtime = resolveRuntimeConfig(configOverrides);
+  const { config, logger, sharedCache, dedupeReads } = runtime;
+  const db = {};
+  const openedClients = /* @__PURE__ */ new Map();
+  const inFlight = new InFlight();
+  const getDbUrl = makeGetDbUrl(dbClients, config);
+  const collectionRefs = [];
+  const cacheInvalidator = sharedCache !== void 0 && configOverrides.cacheWatch === true ? new CacheInvalidator({ cache: sharedCache, logger }) : void 0;
+  const baseMakeConnections = makeConnectionFactory(
+    dbClients,
+    db,
+    getDbUrl,
+    ((key, dbName, client) => buildManager(
+      {
+        dbClients,
+        config,
+        logger,
+        sharedCache,
+        dedupeReads,
+        inFlight,
+        wrapMongoErrors: runtime.wrapMongoErrors,
+        drift: configOverrides.drift,
+        collectionRefs,
+        db
+      },
+      key,
+      dbName,
+      client
+    )),
+    openedClients
+  );
+  const makeConnections = async (names) => {
+    await baseMakeConnections(names);
+    await cacheInvalidator?.start(collectionRefs);
+  };
+  const closeConnections2 = async () => {
+    await cacheInvalidator?.stop();
+    collectionRefs.length = 0;
+    await closeConnections(openedClients);
+  };
+  const eachDb = async (fn) => {
+    return Promise.all(Object.keys(db).map((key) => fn(db[key], key.replace(/Client$/, ""))));
+  };
+  const health = createHealth(db);
+  return {
+    db,
+    makeConnections,
+    closeConnections: closeConnections2,
+    eachDb,
+    health,
+    getDbUrl,
+    config,
+    logger,
+    ObjectId: ObjectId
+  };
+};
+
+// src/shared/merge-filters.ts
+var mergeMongoFilters = (...parts) => {
+  const out = {};
+  for (const part of parts) {
+    if (!part) continue;
+    Object.assign(out, part);
+  }
+  return out;
+};
+
+// src/shared/strip-primary-key.ts
+var stripDocumentId = (doc) => {
+  if (!("_id" in doc)) return doc;
+  const { _id, ...rest } = doc;
+  return rest;
+};
+var stripPrimaryKey = (patch, key) => {
+  if (!(key in patch)) return patch;
+  const { [key]: _, ...rest } = patch;
+  return rest;
+};
+
+// src/toolkit.ts
+var createMongoToolkit = (dbClients, options = {}) => {
+  const service = createMongoService(dbClients, options);
+  const migrations = createMongoMigrationRunner(service, {
+    migrationDir: service.config.migrationDir
+  });
+  return { service, migrations };
+};
+
+// src/utils/memoize.ts
+var makeStore = (maxSize) => {
+  if (maxSize <= 0) {
+    const map = /* @__PURE__ */ new Map();
+    return {
+      get: (k) => map.get(k),
+      set: (k, v) => {
+        map.set(k, v);
+      },
+      has: (k) => map.has(k),
+      delete: (k) => {
+        map.delete(k);
+      }
+    };
+  }
+  return new LRU({ max: maxSize });
+};
+var createCachedFactory = (factory, options = {}) => {
+  const maxSize = options.maxSize ?? 100;
+  const cache = makeStore(maxSize);
+  return (key) => {
+    const existing = cache.get(key);
+    if (existing !== void 0) return existing;
+    const value = factory(key);
+    cache.set(key, value);
+    return value;
+  };
+};
+var createCachedAsyncFactory = (factory, options = {}) => {
+  const maxSize = options.maxSize ?? 100;
+  const cache = makeStore(maxSize);
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key) => {
+    const inflight = inFlight.get(key);
+    if (inflight) return inflight;
+    const cached = cache.get(key);
+    if (cached) return cached;
+    const promise = factory(key);
+    inFlight.set(key, promise);
+    cache.set(key, promise);
+    promise.then(
+      () => {
+        inFlight.delete(key);
+      },
+      () => {
+        inFlight.delete(key);
+        if (cache.get(key) === promise) cache.delete(key);
+      }
+    );
+    return promise;
+  };
+};
+
+export { AppError, BadRequest, CacheInvalidator, DEFAULT_FIND_LIMIT, DEFAULT_MAX_LIMIT, DataLoader, DomainError, ERROR_HTTP_STATUS, HOOK_NAMES, HotCache, InFlight, InfraError, LRU, MAX_BATCH_OPS, QueryBuilder, QueryCache, TRANSIENT_MONGO_ERROR_CODES, belongsTo, buildKeysetFilter, buildMongoActiveFilter, buildPaginationResult, cacheCollectionKey, canonicalKey, createCachedAsyncFactory, createCachedFactory, createConsoleLogger, createHotCache, createMongoCapabilitiesStore, createMongoMigrationRunner, createMongoService, createMongoToolkit, createNoopLogger, createRepository, createResolveCollectionName, decodeCursor, defineCollection, defineCollections, encodeCursor, hasMany, hashString, httpStatusForError, isAppError, isDomainError, isInfraError, isMappedMongoError, isMongoDuplicateKeyError, isMongoTransientError, manyToMany, mapMongoDriverError, mergeMongoActiveFilter, mergeMongoFilters, normalizeMongoUrl, normalizePageLimit, optional, probeMongoCapabilities, runHooks, s, serializeError, sleep, sleepJittered, stableHash, stableStringify, stripDocumentId, stripPrimaryKey, toMongoSchema, toMongoValidator, validateDoc, withDefault, withGracefulMongoTransaction, withRetry, withTimeout, withTransaction };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map