@bjornpagen/bumbledb 1.3.0 → 2.0.0-rc.1

package/src/database/generate.ts

@@ -0,0 +1,116 @@
+/**
+ * The migrations directory: one `NNNN_name/` per migration holding the schema it migrates to
+ * (`schema.json`, the engine's spec, and `schema.ts`, the same schema as SDK code) and its
+ * `migration.ts`; `index.ts` bundles them in order. A migration's hash covers its id and its
+ * `schema.json`, so editing either after it ran is caught by `check`.
+ */
+import { createHash } from "node:crypto"
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { compiledOf } from "../compile.ts"
+import { AuthoringError } from "../errors.ts"
+import { lower } from "../lower.ts"
+import { addon } from "../native/addon.ts"
+import type { AnySchema } from "../schema.ts"
+import { schemaDescriptor } from "../schema.ts"
+
+const DIRECTORY = /^([0-9]{4})_([A-Za-z0-9_]+)$/
+
+/** The `schema.json` text of a schema: its lowered spec, formatted for review. */
+function specText(theory: AnySchema): string {
+	return `${JSON.stringify(lower(schemaDescriptor(theory)), null, "\t")}\n`
+}
+
+/** A migration's hash: sha256 over its id and its `schema.json` text. */
+function migrationHash(id: string, spec: string): string {
+	return createHash("sha256").update(`${id}\n${spec}`).digest("hex")
+}
+
+/** The migration directories under `root`, in order. */
+function migrationIds(root: string): string[] {
+	if (!fs.existsSync(root)) return []
+	return fs
+		.readdirSync(root, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory() && DIRECTORY.test(entry.name))
+		.map((entry) => entry.name)
+		.sort()
+}
+
+function indexText(ids: readonly string[]): string {
+	const imports = ids.map((id) => `import m${id.slice(0, 4)} from "./${id}/migration.ts"`)
+	const list = ids.map((id) => `m${id.slice(0, 4)}`).join(", ")
+	return `${imports.join("\n")}\n\nexport const migrations = [${list}] as const\n`
+}
+
+function migrationText(id: string, hash: string, previous: string | undefined): string {
+	const lines = ['import { Migration } from "@bjornpagen/bumbledb"']
+	if (previous !== undefined) lines.push(`import { schema as from } from "../${previous}/schema.ts"`)
+	lines.push('import { schema as to } from "./schema.ts"', "")
+	lines.push(
+		previous === undefined
+			? `export default Migration.make({ id: "${id}", hash: "${hash}", to })`
+			: `export default Migration.make({ id: "${id}", hash: "${hash}", from, to })`
+	)
+	return `${lines.join("\n")}\n`
+}
+
+type Generated = { readonly _tag: "Unchanged" } | { readonly _tag: "Created"; readonly id: string }
+
+/**
+ * Adds a migration to `schema` under `root` when it differs from the last migration's schema, and
+ * rewrites `index.ts`.
+ */
+function generate(root: string, theory: AnySchema, name: string): Generated {
+	if (!/^[A-Za-z0-9_]+$/.test(name))
+		throw new AuthoringError({ message: `migration name ${name}: letters, digits and _` })
+	const ids = migrationIds(root)
+	const spec = specText(theory)
+	const previous = ids.at(-1)
+	if (previous !== undefined && fs.readFileSync(path.join(root, previous, "schema.json"), "utf8") === spec) {
+		return { _tag: "Unchanged" }
+	}
+	const bindings = addon.schemaBindings(compiledOf(schemaDescriptor(theory)).handle)
+	if (bindings._tag === "Unrepresentable") {
+		throw new AuthoringError({ message: `schema ${theory.name}: ${bindings.coordinate}: ${bindings.reason}` })
+	}
+	const number = previous === undefined ? 1 : Number(previous.slice(0, 4)) + 1
+	const id = `${number.toString().padStart(4, "0")}_${name}`
+	const directory = path.join(root, id)
+	fs.mkdirSync(directory, { recursive: true })
+	fs.writeFileSync(path.join(directory, "schema.json"), spec)
+	fs.writeFileSync(path.join(directory, "schema.ts"), bindings.source)
+	fs.writeFileSync(path.join(directory, "migration.ts"), migrationText(id, migrationHash(id, spec), previous))
+	fs.writeFileSync(path.join(root, "index.ts"), indexText([...ids, id]))
+	return { _tag: "Created", id }
+}
+
+/** Everything `check` found wrong; empty when the directory is consistent with `schema`. */
+function check(
+	root: string,
+	theory: AnySchema,
+	bundled: readonly { readonly id: string; readonly hash: string }[]
+): string[] {
+	const problems: string[] = []
+	const ids = migrationIds(root)
+	if (ids.length === 0) return [`${root}: no migrations; run bumbledb generate`]
+	if (fs.readFileSync(path.join(root, "index.ts"), "utf8") !== indexText(ids)) {
+		problems.push(`${root}/index.ts does not list the migration directories in order; run bumbledb generate`)
+	}
+	ids.forEach((id, index) => {
+		const spec = fs.readFileSync(path.join(root, id, "schema.json"), "utf8")
+		const migration = bundled[index]
+		if (migration === undefined || migration.id !== id) {
+			problems.push(`${id}: not bundled at position ${index + 1}`)
+		} else if (migration.hash !== migrationHash(id, spec)) {
+			problems.push(`${id}: its hash does not match its schema.json; a migration is never edited after it runs`)
+		}
+	})
+	const last = ids.at(-1)
+	if (last !== undefined && fs.readFileSync(path.join(root, last, "schema.json"), "utf8") !== specText(theory)) {
+		problems.push(`the schema differs from ${last}; run bumbledb generate`)
+	}
+	return problems
+}
+
+export type { Generated }
+export { check, generate, migrationHash, migrationIds, specText }

package/src/database/hosted.ts

@@ -0,0 +1,102 @@
+/**
+ * The addon's hosted machine as a driver port. A hosted step is never cancelled: its output carries
+ * requests the machine then waits on, so every step runs to completion even when its caller is
+ * interrupted.
+ */
+import { Effect } from "effect"
+import type { DbError } from "../errors.ts"
+import type { ChangesRef, OperationRef } from "../native/addon.ts"
+import { addon } from "../native/addon.ts"
+import type {
+	CopyPair,
+	ExternalObject,
+	HeadOut,
+	HostedHandle,
+	IoOutcomeIn,
+	SettledOut,
+	StepOut
+} from "../native/binding.d.ts"
+import { call } from "../native/op.ts"
+import type { MachinePort, Step } from "./driver.ts"
+import type { IoResponse, IoResult } from "./io.ts"
+
+type HostedRef = ExternalObject<HostedHandle>
+
+/** One machine request. `request` ids are 32 hex digits; `revision` present is an exact-revision precondition. */
+type HostedRequest =
+	| { readonly _tag: "Open" }
+	| { readonly _tag: "Sync" }
+	| { readonly _tag: "Resolve"; readonly request: string }
+	| { readonly _tag: "Freeze"; readonly leaseMillis: bigint }
+	| {
+			readonly _tag: "Submit"
+			readonly request: string
+			readonly revision: bigint | null
+			readonly changes: ChangesRef
+	  }
+	| {
+			readonly _tag: "Migrate"
+			readonly step: number
+			readonly base: bigint
+			readonly copy: readonly CopyPair[]
+			readonly rows: ChangesRef
+	  }
+
+function outcomeIn(result: Exclude<IoResult, { readonly _tag: "Body" }>): IoOutcomeIn {
+	return result._tag === "Keys" ? { _tag: "Keys", keys: [...result.keys] } : result
+}
+
+/** A port over one hosted machine; `onHead` sees every head a step reports. */
+function hostedPort(hosted: HostedRef, onHead: (head: HeadOut) => void): MachinePort<HostedRequest, SettledOut> {
+	const step = (
+		operation: string,
+		start: (done: () => void) => OperationRef
+	): Effect.Effect<Step<SettledOut>, DbError> =>
+		call(operation, start, addon.hostedStepTake).pipe(
+			Effect.tap((out: StepOut) =>
+				Effect.sync(() => {
+					if (out.head !== undefined) onHead(out.head)
+				})
+			),
+			Effect.uninterruptible
+		)
+	return {
+		request: (ticket, request) => {
+			switch (request._tag) {
+				case "Open":
+				case "Sync":
+					return step(`Database.${request._tag}`, (done) =>
+						addon.hostedStep(hosted, { _tag: request._tag, ticket }, done)
+					)
+				case "Resolve":
+					return step("Database.resolve", (done) =>
+						addon.hostedStep(hosted, { _tag: "Resolve", ticket, request: request.request }, done)
+					)
+				case "Freeze":
+					return step("Database.freeze", (done) =>
+						addon.hostedStep(hosted, { _tag: "Freeze", ticket, leaseMillis: request.leaseMillis }, done)
+					)
+				case "Submit":
+					return step("Database.submit", (done) =>
+						addon.hostedSubmit(hosted, ticket, request.request, request.revision, request.changes, done)
+					)
+				case "Migrate":
+					return step("Database.migrate", (done) =>
+						addon.hostedMigrate(hosted, ticket, request.step, request.base, [...request.copy], request.rows, done)
+					)
+			}
+		},
+		respond: (response: IoResponse) => {
+			const { id, date, result } = response
+			return result._tag === "Body"
+				? step("Database.respond", (done) =>
+						addon.hostedRespondBody(hosted, id, date, result.lastModified, result.bytes, done)
+					)
+				: step("Database.respond", (done) => addon.hostedRespond(hosted, id, date, outcomeIn(result), done))
+		},
+		close: step("Database.close", (done) => addon.hostedStep(hosted, { _tag: "Close" }, done))
+	}
+}
+
+export type { HostedRef, HostedRequest }
+export { hostedPort }

package/src/database/io.ts

@@ -0,0 +1,134 @@
+/**
+ * The object-store side of the hosted log. The log machine emits `IoRequest`s as data; this module
+ * runs them against an `ObjectStore` and turns every outcome into an `IoResponse`. Reads are
+ * idempotent and retried here; a create-only PUT is never retried here, because the machine
+ * resolves an ambiguous PUT by reading the key back.
+ */
+import type { Duration } from "effect"
+import { Effect, Schedule } from "effect"
+import { DbError } from "../errors.ts"
+import type { BucketOut, IoRequestOut } from "../native/binding.d.ts"
+
+/** `Log` is the commit log (`log/`, an S3 Express directory bucket); `Checkpoints` holds `ckpt/` and `mig/`. */
+type Bucket = BucketOut
+
+/** One request from the machine. `key` is relative to the database prefix. */
+type IoRequest = IoRequestOut
+
+/** Unix milliseconds on the store's clock. */
+type Millis = bigint
+
+/** Where a GET delivers the object: returned in memory, or written to a local file. */
+type Target = { readonly _tag: "Memory" } | { readonly _tag: "File"; readonly path: string }
+
+/** What a create-only PUT uploads: bytes in memory, or a local file. */
+type Body = { readonly _tag: "Bytes"; readonly bytes: Uint8Array } | { readonly _tag: "File"; readonly path: string }
+
+type Fetched =
+	| { readonly _tag: "Body"; readonly bytes: Uint8Array; readonly lastModified: Millis }
+	| { readonly _tag: "Saved"; readonly lastModified: Millis }
+	| { readonly _tag: "Missing" }
+
+/** `Occupied`: the key exists, or, for a log object, another conditional write to it was in progress. */
+type Created = { readonly _tag: "Created" } | { readonly _tag: "Occupied" }
+
+type Listed = { readonly _tag: "Keys"; readonly keys: readonly string[] }
+
+type Deleted = { readonly _tag: "Deleted" }
+
+/** `Failed` covers everything a store could not answer definitively: 5xx, timeouts, transport. */
+type IoResult = Fetched | Created | Listed | Deleted | { readonly _tag: "Failed" }
+
+interface IoResponse {
+	readonly id: bigint
+	/** The store's `Date` header, when it sent one. */
+	readonly date: Millis | null
+	readonly result: IoResult
+}
+
+/** A store answer plus the store's clock reading. */
+interface Reply<R> {
+	readonly date: Millis | null
+	readonly result: R
+}
+
+/**
+ * The four verbs the log needs. Keys arrive relative; a store owns its own prefix. LIST and DELETE
+ * exist only for `Checkpoints`: LIST order on an Express bucket is not lexicographic, and a `log/`
+ * key must never disappear.
+ */
+interface ObjectStore {
+	readonly get: (bucket: Bucket, key: string, target: Target) => Effect.Effect<Reply<Fetched>, DbError>
+	readonly putIfAbsent: (bucket: Bucket, key: string, body: Body) => Effect.Effect<Reply<Created>, DbError>
+	/** Checkpoint keys under `prefix` after `startAfter`, in lexicographic order. */
+	readonly list: (prefix: string, startAfter: string | null, maxKeys: number) => Effect.Effect<Reply<Listed>, DbError>
+	/** Deletes one checkpoint key; deleting a missing key succeeds. */
+	readonly delete: (key: string) => Effect.Effect<Reply<Deleted>, DbError>
+}
+
+interface ExecutorOptions {
+	/** Bound on one store call; a call that exceeds it counts as `Failed` (or is retried, for a read). */
+	readonly timeout: Duration.Input
+	/** Retry policy for GET, LIST and DELETE. */
+	readonly readRetry: Schedule.Schedule<unknown, unknown>
+}
+
+const defaultExecutorOptions: ExecutorOptions = {
+	timeout: "10 seconds",
+	readRetry: Schedule.exponential("20 millis").pipe(Schedule.jittered, Schedule.upTo({ times: 4 }))
+}
+
+function refused(request: IoRequest): Effect.Effect<never, DbError> {
+	return Effect.fail(new DbError({ operation: `ObjectStore.${request.op._tag}`, reason: { _tag: "InvalidArgument" } }))
+}
+
+function dispatch(store: ObjectStore, request: IoRequest): Effect.Effect<Reply<IoResult>, DbError> {
+	const { bucket, key, op } = request
+	switch (op._tag) {
+		case "GetMemory":
+			return store.get(bucket, key, { _tag: "Memory" })
+		case "GetFile":
+			return store.get(bucket, key, { _tag: "File", path: op.path })
+		case "PutBytes":
+			return store.putIfAbsent(bucket, key, { _tag: "Bytes", bytes: op.bytes })
+		case "PutFile":
+			return store.putIfAbsent(bucket, key, { _tag: "File", path: op.path })
+		case "List":
+			return bucket === "Checkpoints" ? store.list(key, op.startAfter ?? null, op.maxKeys) : refused(request)
+		case "Delete":
+			return bucket === "Checkpoints" ? store.delete(key) : refused(request)
+	}
+}
+
+/** Runs one request to an `IoResponse`; it never fails. */
+function execute(
+	store: ObjectStore,
+	request: IoRequest,
+	options: ExecutorOptions = defaultExecutorOptions
+): Effect.Effect<IoResponse> {
+	const once = Effect.timeout(dispatch(store, request), options.timeout)
+	const write = request.op._tag === "PutBytes" || request.op._tag === "PutFile"
+	const attempts = write ? once : Effect.retry(once, options.readRetry)
+	return attempts.pipe(
+		Effect.map((reply): IoResponse => ({ id: request.id, date: reply.date, result: reply.result })),
+		Effect.catch(() => Effect.succeed<IoResponse>({ id: request.id, date: null, result: { _tag: "Failed" } }))
+	)
+}
+
+export type {
+	Body,
+	Bucket,
+	Created,
+	Deleted,
+	ExecutorOptions,
+	Fetched,
+	IoRequest,
+	IoResponse,
+	IoResult,
+	Listed,
+	Millis,
+	ObjectStore,
+	Reply,
+	Target
+}
+export { defaultExecutorOptions, execute }

package/src/database/mem.ts

@@ -0,0 +1,113 @@
+import * as fs from "node:fs/promises"
+import { Effect } from "effect"
+import { DbError } from "../errors.ts"
+import type { Body, Bucket, Created, Deleted, Fetched, Listed, Millis, ObjectStore, Reply, Target } from "./io.ts"
+
+type Verb = "get" | "putIfAbsent" | "list" | "delete"
+
+/** `Fail`: the call fails before it has any effect. `Lose`: the call takes effect, then fails, like a lost response. */
+type Fault = "Fail" | "Lose"
+
+interface MemStoreOptions {
+	/** The store clock behind `Date` and `Last-Modified`. Defaults to a counter that ticks once per call. */
+	readonly clock?: () => Millis
+	/** Picks the fault, if any, for each call. */
+	readonly fault?: (call: { readonly verb: Verb; readonly bucket: Bucket; readonly key: string }) => Fault | undefined
+}
+
+interface Stored {
+	readonly bytes: Uint8Array
+	readonly lastModified: Millis
+}
+
+/** An in-memory store with the create-only semantics of S3, and deterministic fault injection for tests. */
+interface MemStore extends ObjectStore {
+	/** A copy of the objects currently in `bucket`, by key. */
+	readonly objects: (bucket: Bucket) => ReadonlyMap<string, Uint8Array>
+}
+
+function failure(operation: string): DbError {
+	return new DbError({ operation, reason: { _tag: "Io", kind: "Injected" } })
+}
+
+function make(options: MemStoreOptions = {}): MemStore {
+	let ticks = 0n
+	const clock =
+		options.clock ??
+		(() => {
+			ticks += 1n
+			return ticks
+		})
+	const buckets: Record<Bucket, Map<string, Stored>> = { Log: new Map(), Checkpoints: new Map() }
+
+	function run<R>(
+		verb: Verb,
+		bucket: Bucket,
+		key: string,
+		body: (now: Millis) => Effect.Effect<R, DbError>
+	): Effect.Effect<Reply<R>, DbError> {
+		return Effect.suspend(() => {
+			const fault = options.fault?.({ verb, bucket, key })
+			const operation = `MemStore.${verb}`
+			if (fault === "Fail") return Effect.fail(failure(operation))
+			const now = clock()
+			return Effect.flatMap(body(now), (result) =>
+				fault === "Lose" ? Effect.fail(failure(operation)) : Effect.succeed({ date: now, result })
+			)
+		})
+	}
+
+	const io = <A>(operation: string, f: () => Promise<A>) =>
+		Effect.tryPromise({
+			try: f,
+			catch: () => new DbError({ operation, reason: { _tag: "Io", kind: "File" } })
+		})
+
+	return {
+		get: (bucket: Bucket, key: string, target: Target) =>
+			run("get", bucket, key, (): Effect.Effect<Fetched, DbError> => {
+				const stored = buckets[bucket].get(key)
+				if (stored === undefined) return Effect.succeed({ _tag: "Missing" })
+				if (target._tag === "Memory") {
+					return Effect.succeed({ _tag: "Body", bytes: stored.bytes.slice(), lastModified: stored.lastModified })
+				}
+				return io("MemStore.get", () => fs.writeFile(target.path, stored.bytes)).pipe(
+					Effect.as<Fetched>({ _tag: "Saved", lastModified: stored.lastModified })
+				)
+			}),
+		putIfAbsent: (bucket: Bucket, key: string, body: Body) =>
+			run("putIfAbsent", bucket, key, (now): Effect.Effect<Created, DbError> => {
+				const bytes =
+					body._tag === "Bytes"
+						? Effect.succeed(body.bytes.slice())
+						: io("MemStore.putIfAbsent", () => fs.readFile(body.path)).pipe(
+								Effect.map((buffer) => new Uint8Array(buffer))
+							)
+				return Effect.map(bytes, (owned): Created => {
+					const objects = buckets[bucket]
+					if (objects.has(key)) return { _tag: "Occupied" }
+					objects.set(key, { bytes: owned, lastModified: now })
+					return { _tag: "Created" }
+				})
+			}),
+		list: (prefix: string, startAfter: string | null, maxKeys: number) =>
+			run("list", "Checkpoints", prefix, (): Effect.Effect<Listed> => {
+				const keys = [...buckets.Checkpoints.keys()]
+					.filter((key) => key.startsWith(prefix) && (startAfter === null || key > startAfter))
+					.sort()
+					.slice(0, maxKeys)
+				return Effect.succeed({ _tag: "Keys", keys })
+			}),
+		delete: (key: string) =>
+			run("delete", "Checkpoints", key, (): Effect.Effect<Deleted> => {
+				buckets.Checkpoints.delete(key)
+				return Effect.succeed({ _tag: "Deleted" })
+			}),
+		objects: (bucket: Bucket) => new Map([...buckets[bucket]].map(([key, stored]) => [key, stored.bytes.slice()]))
+	}
+}
+
+const MemStore = Object.freeze({ make })
+
+export type { Fault, MemStoreOptions }
+export { MemStore }

package/src/database/migration.ts

@@ -0,0 +1,107 @@
+import type { Effect, Scope } from "effect"
+import type { ChangeDraft } from "../changes.ts"
+import type { QueryReader } from "../db.ts"
+import type { DbError } from "../errors.ts"
+import { AuthoringError } from "../errors.ts"
+import type { AnySchema } from "../schema.ts"
+import { schemaDescriptor, schemasAgree } from "../schema.ts"
+
+/** What `populate` reads from (the database at the old schema) and writes into (rows at the new one). */
+interface PopulateContext<From extends AnySchema, To extends AnySchema> {
+	readonly from: QueryReader<From>
+	readonly into: ChangeDraft<To>
+}
+
+/**
+ * Computes the rows a migration adds at its new schema, reading the database at the old one.
+ * Relations that keep their name and fields are copied unchanged without code.
+ */
+type Populate<From extends AnySchema, To extends AnySchema> = (
+	context: PopulateContext<From, To>
+) => Effect.Effect<void, DbError, Scope.Scope>
+
+/**
+ * One bundled migration: its stable `id` (the directory name), the content `hash` that
+ * `bumbledb generate` wrote (64 hex digits), and the schema it migrates to. The first migration of a
+ * bundle has no `from`: it is the initial schema, and its `populate` seeds a newly created database
+ * once.
+ */
+interface Migration<From extends AnySchema | undefined = AnySchema | undefined, To extends AnySchema = AnySchema> {
+	readonly id: string
+	readonly hash: string
+	readonly from: From
+	readonly to: To
+	readonly populate?: Populate<From extends AnySchema ? From : To, To>
+}
+
+/** Any migration of a bundle; its `populate` is read back through {@link populateOf}. */
+interface AnyMigration {
+	readonly id: string
+	readonly hash: string
+	readonly from: AnySchema | undefined
+	readonly to: AnySchema
+	readonly populate?: unknown
+}
+
+/** A bundle: the initial migration first, then each migration from its predecessor's schema. */
+type Migrations = readonly [AnyMigration, ...AnyMigration[]]
+
+const HASH = /^[0-9a-f]{64}$/
+const ID = /^[0-9]{4}_[A-Za-z0-9_]+$/
+
+function make<To extends AnySchema, From extends AnySchema = never>(input: {
+	readonly id: string
+	readonly hash: string
+	readonly from?: From
+	readonly to: To
+	readonly populate?: Populate<[From] extends [never] ? To : From, To>
+}): Migration<[From] extends [never] ? undefined : From, To>
+function make(input: {
+	readonly id: string
+	readonly hash: string
+	readonly from?: AnySchema
+	readonly to: AnySchema
+	readonly populate?: Populate<AnySchema, AnySchema>
+}): AnyMigration {
+	if (!ID.test(input.id)) throw new AuthoringError({ message: `migration ${input.id}: an id is NNNN_name` })
+	if (!HASH.test(input.hash)) throw new AuthoringError({ message: `migration ${input.id}: a hash is 64 hex digits` })
+	const migration = {
+		id: input.id,
+		hash: input.hash,
+		from: input.from === undefined ? undefined : schemaDescriptor(input.from),
+		to: schemaDescriptor(input.to),
+		...(input.populate === undefined ? {} : { populate: input.populate })
+	}
+	return Object.freeze(migration)
+}
+
+/** The populate step of a migration `make` built. */
+function populateOf(migration: AnyMigration): Populate<AnySchema, AnySchema> | undefined {
+	return migration.populate as Populate<AnySchema, AnySchema> | undefined
+}
+
+/** Checks that each migration starts from its predecessor's schema and that ids are unique. */
+function verifyBundle(migrations: Migrations): void {
+	const ids = new Set<string>()
+	migrations.forEach((migration, index) => {
+		if (ids.has(migration.id)) throw new AuthoringError({ message: `migrations: ${migration.id} appears twice` })
+		ids.add(migration.id)
+		const previous = migrations[index - 1]
+		if (previous === undefined) {
+			if (migration.from !== undefined) {
+				throw new AuthoringError({ message: `migrations: the first migration ${migration.id} has no from schema` })
+			}
+			return
+		}
+		if (migration.from === undefined || !schemasAgree(migration.from, previous.to)) {
+			throw new AuthoringError({
+				message: `migrations: ${migration.id} must start from the schema ${previous.id} migrates to`
+			})
+		}
+	})
+}
+
+const Migration = Object.freeze({ make })
+
+export type { AnyMigration, Migrations, Populate, PopulateContext }
+export { Migration, populateOf, verifyBundle }