@classytic/arc 2.23.0 → 2.28.0

package/dist/integrations/websocket.mjs

@@ -648,7 +648,15 @@ function safeAsync(p, logger, op, ctx) {
 */
 var SendQueue = class {
 	entries = [];
-	/** `coalesceKey → entries[] index` for O(1) replacement. */
+	/**
+	* Logical queue head — `entries[head..]` is the live queue. Draining
+	* advances the pointer instead of `shift()`ing (which moves every
+	* trailing element AND invalidated every tracked coalesce index,
+	* making a full drain O(n²)). The prefix is garbage-collected by
+	* {@link compactIfNeeded} — amortized O(1) per drained frame.
+	*/
+	head = 0;
+	/** `coalesceKey → ABSOLUTE entries[] index` for O(1) replacement. */
 	coalesceIndex = /* @__PURE__ */ new Map();
 	socket;
 	capacity;
@@ -666,7 +674,7 @@ var SendQueue = class {
 	/** Ordered, guaranteed-best-effort delivery. Overflow ⇒ terminate. */
 	send(payload) {
 		if (this.disposed) return;
-		if (this.entries.length >= this.capacity) {
+		if (this.size() >= this.capacity) {
 			this.terminate("Queue overflow");
 			return;
 		}
@@ -685,7 +693,7 @@ var SendQueue = class {
 		if (this.disposed) return;
 		if (coalesceKey !== void 0) {
 			const idx = this.coalesceIndex.get(coalesceKey);
-			if (idx !== void 0 && this.entries[idx]) {
+			if (idx !== void 0 && idx >= this.head && this.entries[idx]) {
 				this.entries[idx] = {
 					payload,
 					cls: "droppable",
@@ -695,12 +703,16 @@ var SendQueue = class {
 				return;
 			}
 		}
-		if (this.entries.length >= this.capacity) {
-			const shedIdx = this.entries.findIndex((e) => e.cls === "droppable");
+		if (this.size() >= this.capacity) {
+			let shedIdx = -1;
+			for (let i = this.head; i < this.entries.length; i++) if (this.entries[i]?.cls === "droppable") {
+				shedIdx = i;
+				break;
+			}
 			if (shedIdx === -1) return;
 			const evicted = this.entries.splice(shedIdx, 1)[0];
 			if (evicted?.coalesceKey !== void 0) this.coalesceIndex.delete(evicted.coalesceKey);
-			this.reindexCoalesceFrom(shedIdx);
+			for (const [key, idx] of this.coalesceIndex) if (idx > shedIdx) this.coalesceIndex.set(key, idx - 1);
 		}
 		this.entries.push({
 			payload,
@@ -718,28 +730,44 @@ var SendQueue = class {
 	*/
 	flush() {
 		if (this.disposed) return;
-		while (this.entries.length > 0 && this.socket.readyState === 1) {
+		while (this.size() > 0 && this.socket.readyState === 1) {
 			if ((this.socket.bufferedAmount ?? 0) >= this.drainThreshold) {
 				this.scheduleRetry();
-				return;
+				break;
 			}
-			const entry = this.entries.shift();
+			const entry = this.entries[this.head];
 			if (!entry) return;
+			this.head++;
 			if (entry.coalesceKey !== void 0) this.coalesceIndex.delete(entry.coalesceKey);
-			if (this.coalesceIndex.size > 0) this.reindexCoalesceFrom(0);
 			try {
 				this.socket.send(entry.payload);
 			} catch {
 				return;
 			}
 		}
+		this.compactIfNeeded();
 	}
 	size() {
-		return this.entries.length;
+		return this.entries.length - this.head;
+	}
+	/**
+	* Drop the drained prefix once it dominates the array. Rebuilding the
+	* (small) coalesce index here is the amortized cost that replaces the
+	* per-frame O(n) reindex the old `shift()` drain paid.
+	*/
+	compactIfNeeded() {
+		if (this.head < 64 || this.head * 2 < this.entries.length) return;
+		this.entries = this.entries.slice(this.head);
+		this.head = 0;
+		if (this.coalesceIndex.size > 0) {
+			this.coalesceIndex.clear();
+			this.reindexCoalesceFrom(0);
+		}
 	}
 	dispose() {
 		this.disposed = true;
 		this.entries.length = 0;
+		this.head = 0;
 		this.coalesceIndex.clear();
 		if (this.retryTimer) {
 			clearTimeout(this.retryTimer);
@@ -829,7 +857,6 @@ async function handleConnection(ctx, socket, request) {
 		clientId: serviceClientId,
 		authMode: options.auth
 	});
-	options.messageEnvelope;
 	const urlPushRef = readPushRefFromRequest(request);
 	let pushRef;
 	let envelope;
@@ -1279,7 +1306,7 @@ var RoomManager = class {
 		for (const clientId of members) {
 			if (clientId === excludeClientId) continue;
 			const client = this.clients.get(clientId);
-			if (!client || client.socket.readyState !== 1) continue;
+			if (client?.socket.readyState !== 1) continue;
 			if ((client.socket.bufferedAmount ?? 0) > WS_BACKPRESSURE_LIMIT) continue;
 			try {
 				client.socket.send(message);
@@ -1303,7 +1330,7 @@ var RoomManager = class {
 		if (!members) return;
 		for (const clientId of members) {
 			const client = this.clients.get(clientId);
-			if (!client || client.socket.readyState !== 1) continue;
+			if (client?.socket.readyState !== 1) continue;
 			if (client.queue) client.queue.sendRealtime(message, coalesceKey);
 			else if ((client.socket.bufferedAmount ?? 0) <= WS_BACKPRESSURE_LIMIT) try {
 				client.socket.send(message);

package/dist/{interface-C1_WLTMK.d.mts → interface-BGZCzOGL.d.mts}

@@ -1,34 +1,5 @@
+import { CacheAdapter } from "@classytic/repo-core/cache";
 //#region src/cache/interface.d.ts
-/**
- * Cache Store Interface — aligned with `@classytic/repo-core/cache.CacheAdapter`.
- *
- * Arc's cache layer speaks the same `get / set(ttlSeconds?) / del / clear(pattern?)`
- * transport-level contract published by `@classytic/repo-core`. One Redis
- * implementation drops into Arc's `QueryCache`, mongokit's cache plugin,
- * sqlitekit's cache plugin, and every future kit without wrapper shims.
- *
- * Arc extends the bare adapter with two optional observability fields —
- * `name` (for diagnostics) and `stats()` (for the response-cache plugin) —
- * that are opt-in: consumers implementing only `CacheAdapter` still
- * structurally satisfy `CacheStore`, so a raw repo-core adapter plugs
- * directly into Arc.
- *
- * ## TTL unit
- *
- * `ttlSeconds`, not milliseconds. Matches Redis (`SET … EX seconds`) which
- * is the dominant backend. `0` or `undefined` means no expiry; implementations
- * may apply their own default.
- *
- * ## Not-found semantics
- *
- * `get()` returns `undefined` on miss / expired. Matches repo-core.
- *
- * ## Sync-or-async
- *
- * Method returns are `Promise<T> | T` — in-memory `Map` adapters can be
- * synchronous; Redis adapters are async. Consumers always `await`, so
- * sync values just short-circuit the microtask.
- */
 interface CacheLogger {
   warn(message: string, ...args: unknown[]): void;
   error(message: string, ...args: unknown[]): void;
@@ -45,7 +16,14 @@ interface CacheStats {
   /** Number of entries evicted since creation */
   evictions: number;
 }
-interface CacheStore<TValue = unknown> {
+/**
+ * `extends CacheAdapter` is load-bearing: repo-core owns the transport
+ * contract, and extending (instead of maintaining a structural copy) makes
+ * any drift between the two a COMPILE error in arc rather than a runtime
+ * incompatibility — e.g. an argument-order divergence on `increment` would
+ * make a conforming adapter misread a TTL as the increment amount.
+ */
+interface CacheStore<TValue = unknown> extends CacheAdapter {
   /** Store name for logs/diagnostics. Optional to match repo-core's bare `CacheAdapter`. */
   readonly name?: string;
   /**
@@ -70,6 +48,21 @@ interface CacheStore<TValue = unknown> {
    * need strict invalidation must check for its presence: `store.clear?.(pattern)`.
    */
   clear?(pattern?: string): Promise<void> | void;
+  /**
+   * Atomic increment — adds `by` (default 1) to the integer at `key`,
+   * creating it with value `by` when absent; returns the NEW value.
+   * Signature is the canonical `@classytic/repo-core/cache.CacheAdapter`
+   * contract — Redis adapters map to `INCRBY` (+ `EXPIRE` when
+   * `ttlSeconds` is given).
+   *
+   * Optional — consumers feature-detect it. Arc's `QueryCache` uses it for
+   * version-based invalidation: with `increment`, concurrent bumps from
+   * multiple replicas are strictly monotonic and never collide; without it,
+   * QueryCache falls back to a read-modify-write that is monotonic within a
+   * process but can lose a concurrent replica's bump. Distributed hosts
+   * should use a store that implements this.
+   */
+  increment?(key: string, by?: number, ttlSeconds?: number): Promise<number> | number;
   /** Cache statistics for observability. Optional. */
   stats?(): CacheStats;
 }

package/dist/{mcpPlugin-BtzIL_kM.mjs → mcpPlugin-Cs6nRGCt.mjs}

@@ -1,16 +1,18 @@
 import { p as isArcError, t as ArcError } from "./errors-DkO8Nk6-.mjs";
-import { b as isElevated, c as getOrgId, g as getUserId, x as isMember } from "./types-bHblZ9YN.mjs";
-import { t as BaseController } from "./BaseController-BQ8KNvWC.mjs";
-import { i as applyFieldReadPermissions, r as normalizePermissionResult, s as resolveEffectiveRoles } from "./applyPermissionResult-Tw4iXtlf.mjs";
+import { n as requireSingleHeaderValue } from "./headers-BvlQSDMB.mjs";
+import { b as isElevated, c as getOrgId, g as getUserId, x as isMember } from "./types-CSyCxl2V.mjs";
+import { t as BaseController } from "./BaseController-B65zbz9m.mjs";
+import { i as applyFieldReadPermissions, r as normalizePermissionResult, s as resolveEffectiveRoles } from "./applyPermissionResult-BnyVE9eD.mjs";
 import { t as executePipeline } from "./pipe-BOLmGIxa.mjs";
-import { d as buildRequestScopeProjection, i as resolvePipelineSteps, t as resolveActionPermission } from "./actionPermissions-lszoJle1.mjs";
-import { n as validateAggregations } from "./validate-C2mGgSXg.mjs";
-import { n as executeAggregation } from "./buildHandler-D_2ULWxZ.mjs";
+import { r as resolvePipelineSteps, u as buildRequestScopeProjection } from "./pipeline-BGRnV-To.mjs";
+import { n as validateAggregations } from "./validate-Bk44F2yT.mjs";
+import { n as executeAggregation } from "./buildHandler-Dtwd8fdz.mjs";
 import { t as pluralize } from "./pluralize-BhrgwZb9.mjs";
+import { t as resolveActionPermission } from "./actionPermissions-CAphcmUG.mjs";
 import { t as createIdempotencyResult } from "./interface-n5hpKg1d.mjs";
 import { r as shouldRejectAdditionalProperties, t as normalizeSchemaIR } from "./schemaIR-Ca7ySNPx.mjs";
-import { createHash, randomUUID } from "node:crypto";
 import { isHttpError, toErrorContract } from "@classytic/repo-core/errors";
+import { createHash, randomUUID } from "node:crypto";
 import fp from "fastify-plugin";
 import { z } from "zod";
 //#region src/integrations/mcp/createMcpServer.ts
@@ -2382,7 +2384,7 @@ function registerStatefulRoutes(fastify, prefix, options, cache, createServer, T
 				}
 			});
 		}
-		const sessionId = request.headers["mcp-session-id"];
+		const sessionId = requireSingleHeaderValue(request.headers, "mcp-session-id");
 		if (sessionId) {
 			const entry = cache.get(sessionId);
 			if (entry) {
@@ -2417,7 +2419,7 @@ function registerStatefulRoutes(fastify, prefix, options, cache, createServer, T
 		await transport.handleRequest(request.raw, reply.raw, request.body);
 	});
 	fastify.get(prefix, async (request, reply) => {
-		const sessionId = request.headers["mcp-session-id"];
+		const sessionId = requireSingleHeaderValue(request.headers, "mcp-session-id");
 		if (!sessionId) return reply.code(400).send({ error: "Missing Mcp-Session-Id header" });
 		const entry = cache.get(sessionId);
 		if (!entry) return reply.code(403).send({ error: "Unauthorized" });
@@ -2432,7 +2434,7 @@ function registerStatefulRoutes(fastify, prefix, options, cache, createServer, T
 		await entry.transport.handleRequest(request.raw, reply.raw);
 	});
 	fastify.delete(prefix, async (request, reply) => {
-		const sessionId = request.headers["mcp-session-id"];
+		const sessionId = requireSingleHeaderValue(request.headers, "mcp-session-id");
 		if (!sessionId) return reply.code(400).send({ error: "Missing Mcp-Session-Id header" });
 		const entry = cache.get(sessionId);
 		if (!entry) return reply.code(204).send();

package/dist/{memory-CLXA2VeJ.mjs → memory-CmnzXE5Z.mjs}

@@ -76,6 +76,35 @@ var MemoryCacheStore = class {
 		const entry = this.cache.get(key);
 		if (entry) this.removeEntry(key, entry);
 	}
+	/**
+	* Atomic increment (canonical `CacheAdapter` signature: key, by, ttl) —
+	* synchronous on purpose: no `await` between read and write means
+	* concurrent bumps on the event loop can't interleave, which is the whole
+	* point of the `CacheStore.increment` contract.
+	*
+	* TTL semantics follow the repo-core contract: `ttlSeconds` applies only
+	* when the key is CREATED — an existing counter keeps its original expiry
+	* (Redis `EXPIRE ... NX` semantics), so every conforming adapter ages a
+	* counter identically.
+	*/
+	increment(key, by = 1, ttlSeconds) {
+		const now = Date.now();
+		const entry = this.cache.get(key);
+		const live = entry && entry.expiresAt > now;
+		const next = (live && typeof entry.value === "number" ? entry.value : 0) + by;
+		const effectiveTtlSeconds = ttlSeconds ?? this.defaultTtlSeconds;
+		if (entry) this.currentBytes -= entry.size;
+		this.cache.delete(key);
+		const size = 8;
+		this.cache.set(key, {
+			value: next,
+			size,
+			expiresAt: live ? entry.expiresAt : now + Math.max(1, effectiveTtlSeconds) * 1e3
+		});
+		this.currentBytes += size;
+		this.evictToLimit();
+		return next;
+	}
 	async clear(pattern) {
 		if (pattern === void 0) {
 			this.cache.clear();

package/dist/middleware/index.d.mts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, L as RequestWithExtras, Q as MiddlewareConfig } from "../index-BBsvQt7U.mjs";
+import { I as MiddlewareHandler, L as RequestWithExtras, Q as MiddlewareConfig } from "../index-DPRH0Cme.mjs";
 import { RouteHandlerMethod } from "fastify";
 //#region src/middleware/middleware.d.ts
 interface NamedMiddleware {
@@ -90,6 +90,14 @@ interface MultipartBodyOptions {
    * @example ['avatar', 'cover']       // multi-field upload (profile editor)
    */
   requiredFields?: string[];
+  /**
+   * Cap on the TOTAL buffered file bytes per request (default: 25 MiB).
+   * Per-file and per-count limits bound individual files but not their
+   * SUM — without this, `maxFiles: 5` × `maxFileSize: 10 MiB` lets one
+   * request retain ~50 MiB of process memory, and concurrency multiplies
+   * it (20 such uploads ≈ 1 GiB). Exceeding the cap returns 413.
+   */
+  maxTotalBytes?: number;
 }
 /**
  * Create a multipart body parsing middleware.
@@ -102,6 +110,14 @@ interface MultipartBodyOptions {
  * For non-multipart requests (regular JSON), this is a no-op — the request
  * passes through unchanged. This makes it safe to add to create/update
  * middlewares without breaking JSON clients.
+ *
+ * **BUFFERED — for small uploads only.** Every accepted file is held fully
+ * in process memory for the request's lifetime; memory cost is
+ * `concurrency × maxTotalBytes`. Suitable for avatars, documents, and
+ * form attachments. For large files use PRESIGNED direct-to-object-storage
+ * uploads (see the files-upload preset / production guide) and pair upload
+ * routes with strict rate limits — buffering video through the app tier is
+ * the wrong architecture regardless of limits.
  */
 declare function multipartBody(options?: MultipartBodyOptions): RouteHandlerMethod;
 //#endregion

package/dist/middleware/index.mjs

@@ -1,5 +1,5 @@
 import { t as CRUD_OPERATIONS } from "../constants-DNre0wRg.mjs";
-import { t as multipartBody } from "../multipartBody-CHEQSZ6G.mjs";
+import { t as multipartBody } from "../multipartBody-D0eBvkeq.mjs";
 //#region src/middleware/middleware.ts
 /**
 * Named Middleware — Priority-based, conditional middleware execution.

package/dist/migrations/index.d.mts

@@ -1,41 +1,5 @@
+import { LockAdapter } from "@classytic/repo-core/lock";
 //#region src/migrations/index.d.ts
-/**
- * Schema Versioning and Migrations System
- *
- * Manages database schema changes over time with version tracking.
- * Supports forward migrations, rollbacks, and schema compatibility layers.
- *
- * DB-agnostic: the `db` parameter is typed as `unknown` — the user passes
- * whatever connection object their adapter uses (Mongoose db, Prisma client,
- * Knex instance, etc.) and their `up`/`down` functions cast it internally.
- *
- * @example
- * import { defineMigration, MigrationRunner } from '@classytic/arc/migrations';
- *
- * const productV2 = defineMigration({
- *   version: 2,
- *   resource: 'product',
- *   up: async (db) => {
- *     const mongo = db as import('mongoose').mongo.Db;
- *     await mongo.collection('products').updateMany(
- *       {},
- *       { $rename: { 'oldField': 'newField' } }
- *     );
- *   },
- *   down: async (db) => {
- *     const mongo = db as import('mongoose').mongo.Db;
- *     await mongo.collection('products').updateMany(
- *       {},
- *       { $rename: { 'newField': 'oldField' } }
- *     );
- *   },
- * });
- *
- * const runner = new MigrationRunner(mongoose.connection.db, {
- *   store: new MongoMigrationStore(mongoose.connection.db),
- * });
- * await runner.up(migrations);
- */
 interface Migration {
   /** Migration version (sequential number) */
   version: number;
@@ -63,6 +27,12 @@ interface MigrationRecord {
   description?: string;
   appliedAt: Date;
   executionTime: number;
+  /**
+   * SHA-256 of the migration's `up` + `down` source at apply time.
+   * Present on records written by 2.24+; older records lack it and are
+   * skipped by drift detection.
+   */
+  checksum?: string;
 }
 /**
  * DB-agnostic migration store interface.
@@ -75,8 +45,14 @@ interface MigrationRecord {
 interface MigrationStore {
   /** Get all applied migration records, sorted by appliedAt ascending */
   getApplied(): Promise<MigrationRecord[]>;
-  /** Record a completed migration */
-  record(migration: Migration, executionTime: number): Promise<void>;
+  /**
+   * Record a completed migration. `meta.checksum` (2.24+) is the source
+   * checksum for drift detection — stores should persist it when given;
+   * existing two-argument implementations remain valid and simply skip it.
+   */
+  record(migration: Migration, executionTime: number, meta?: {
+    checksum?: string;
+  }): Promise<void>;
   /** Remove a migration record (for rollback) */
   remove(migration: Migration): Promise<void>;
 }
@@ -123,7 +99,9 @@ declare class MongoMigrationStore implements MigrationStore {
     collectionName?: string;
   });
   getApplied(): Promise<MigrationRecord[]>;
-  record(migration: Migration, executionTime: number): Promise<void>;
+  record(migration: Migration, executionTime: number, meta?: {
+    checksum?: string;
+  }): Promise<void>;
   remove(migration: Migration): Promise<void>;
 }
 interface MigrationRunnerOptions {
@@ -131,7 +109,41 @@ interface MigrationRunnerOptions {
   store: MigrationStore;
   /** Logger (defaults to process.stdout/stderr) */
   logger?: MigrationLogger;
+  /**
+   * Ecosystem lock adapter (`LockAdapter` from `@classytic/repo-core/lock`)
+   * for multi-replica / concurrent-deploy safety.
+   * When set, `up()` / `down()` / `downTo()` acquire the `arc:migrations`
+   * lease first and FAIL FAST if another runner holds it — two replicas
+   * starting together can no longer both execute the same migration.
+   * Omit only when a single owner (deploy job, CI step) runs migrations.
+   */
+  lock?: LockAdapter;
+  /**
+   * Lease duration for the migration lock (default: 10 minutes). Must
+   * comfortably exceed the slowest migration so the lease cannot lapse
+   * mid-run and admit a second runner.
+   */
+  lockLeaseMs?: number;
+  /** Lease holder identity (default: random per runner instance). */
+  holderId?: string;
+  /**
+   * What to do when an APPLIED migration's current source no longer matches
+   * the checksum recorded at apply time (the file was edited after being
+   * applied — drift that silently invalidates rollback correctness).
+   *   - `'warn'` (default) — log and continue. Checksums come from
+   *     `Function.prototype.toString()`, so a transpile-target change can
+   *     shift them without semantic drift; warn keeps that honest.
+   *   - `'error'` — throw before running anything.
+   * Records without a checksum (written by older stores) are skipped.
+   */
+  checksumMismatch?: "warn" | "error";
 }
+/**
+ * Source checksum for drift detection — SHA-256 over the migration's
+ * `up`/`down` source. Stable for a given build; a transpile-target change
+ * can legitimately shift it (hence `checksumMismatch: 'warn'` default).
+ */
+declare function computeMigrationChecksum(migration: Migration): string;
 /**
  * Define a migration
  */
@@ -162,9 +174,40 @@ declare class MigrationRunner {
   private readonly db;
   private readonly store;
   private readonly log;
+  private readonly lock?;
+  private readonly lockLeaseMs;
+  private readonly holderId;
+  private readonly checksumMismatch;
   constructor(db: unknown, opts: MigrationRunnerOptions);
   /**
-   * Run all pending migrations
+   * Acquire the migration lease (when a lock is configured) and run `fn`.
+   * Fail-fast on contention: a concurrent deploy should error loudly, not
+   * queue — the OTHER runner is applying the same set.
+   *
+   * The lease renews while `fn` runs (`startRenewingLease` — serialized,
+   * awaited teardown), so a migration slower than `lockLeaseMs` can't let
+   * a second deployment acquire the lock mid-run. Ownership loss is
+   * ENFORCED, not just logged: `fn` receives a `leaseLost` probe to refuse
+   * starting further migrations, and even a successful `fn` fails the run
+   * when the lease was lost — a concurrent runner may have interleaved, so
+   * the applied state must be verified, not trusted. (A stale holder's
+   * in-flight write can only be truly fenced by a token from the lock
+   * contract — planned repo-core evolution.)
+   */
+  private withLock;
+  /**
+   * Drift detection: compare each APPLIED record's stored checksum against
+   * the current source of the same migration. A mismatch means the file was
+   * edited after being applied — its `down()` may no longer invert what
+   * actually ran.
+   */
+  private verifyChecksums;
+  /**
+   * Run all pending migrations.
+   *
+   * With a `lock` configured, the applied set is (re)read INSIDE the lease —
+   * a runner that raced another deploy computes pending against the winner's
+   * completed writes, not a stale pre-lock snapshot.
    */
   up(migrations: Migration[]): Promise<void>;
   /**
@@ -172,9 +215,16 @@ declare class MigrationRunner {
    */
   down(migrations: Migration[]): Promise<void>;
   /**
-   * Rollback to specific version
+   * Rollback to a specific version.
+   *
+   * Versions are RESOURCE-scoped, so a bare numeric threshold is only
+   * meaningful within one resource. When the applied set spans multiple
+   * resources, `options.resource` is required — rolling every resource back
+   * across a shared number silently reverts unrelated schemas.
    */
-  downTo(migrations: Migration[], targetVersion: number): Promise<void>;
+  downTo(migrations: Migration[], targetVersion: number, options?: {
+    resource?: string;
+  }): Promise<void>;
   /**
    * Get all applied migrations
    */
@@ -242,4 +292,4 @@ declare class MigrationRegistry {
   clear(): void;
 }
 //#endregion
-export { Migration, MigrationLogger, MigrationRecord, MigrationRegistry, MigrationRunner, MigrationRunnerOptions, MigrationStore, MongoMigrationStore, SchemaVersion, defineMigration, withSchemaVersion };
+export { Migration, MigrationLogger, MigrationRecord, MigrationRegistry, MigrationRunner, MigrationRunnerOptions, MigrationStore, MongoMigrationStore, SchemaVersion, computeMigrationChecksum, defineMigration, withSchemaVersion };