@rdlabo/workers-hono-kit 0.11.2 → 0.12.0-beta.pr48.sha371f5792ce8a

package/dist/db/database.d.ts

@@ -1,249 +0,0 @@
-import type { Connection, Pool } from 'mysql2/promise';
-import type { HyperdriveLike } from './connection.js';
-/**
- * Dual-connection data layer that separates reads from writes.
- *
- * @remarks
- * The two sides of the database are deliberately handled differently:
- *
- * - Reads go to the **replica** as raw SQL (`QueryRunner.query`) by default, returning plain rows.
- *   Hyperdrive-backed databases also expose `query()` for freshness-sensitive primary SELECTs.
- * - Writes and transactions go to the **primary** through the Drizzle ORM for type safety, but only
- *   via `write(fn)` / `transaction(fn)` — the raw query builder is never exposed. The builder is
- *   awaited inside those methods, which removes a foot-gun: a Drizzle builder is a lazy thenable, so
- *   a bare `return builder` would silently become a no-op.
- *
- * Both sides retry on `ER_LOCK_DEADLOCK`.
- *
- * The kit deliberately avoids depending on the type identity of `drizzle-orm`: the consumer creates
- * the ORM instance with its own copy of `drizzle-orm` and passes it in, and {@link Database} is
- * generic over that ORM type (`TDrizzle`). This keeps the ORM's `MySqlTable`/`SQL` brands from
- * clashing even when the kit and the consumer resolve separate copies of `drizzle-orm`.
- */
-/**
- * Minimal connection interface used for reads.
- *
- * @remarks
- * A mysql2 `Connection` or `Pool` satisfies this structurally.
- */
-export interface QueryRunner {
-    /**
-     * Run a parameterized SQL query.
-     *
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the driver's raw result (typically `[rows, fields]`).
-     */
-    query(sql: string, params?: unknown[]): Promise<unknown>;
-}
-/**
- * Extract the transaction-handle type that a Drizzle instance passes to its `.transaction(cb)`
- * callback.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export type TxOf<TDrizzle> = TDrizzle extends {
-    transaction(cb: (tx: infer Tx) => Promise<unknown>): Promise<unknown>;
-} ? Tx : unknown;
-/**
- * The read/write surface of the data layer.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type used for writes and transactions.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface Database<TDrizzle, TTx = TxOf<TDrizzle>> {
-    /**
-     * Run a raw SQL read against the replica. Hyperdrive-backed databases retry deadlocks and repeat
-     * the SELECT once on a fresh connection after mysql2 reports a fatal connection error.
-     *
-     * @typeParam T - the row shape.
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the rows returned by the query.
-     */
-    read<T>(sql: string, params?: unknown[]): Promise<T[]>;
-    /**
-     * Run a single INSERT/UPDATE/DELETE against the primary, awaited with deadlock retry.
-     *
-     * @typeParam T - the value resolved by `fn`.
-     * @param fn - callback that receives the Drizzle ORM and returns the awaited write.
-     * @returns the value resolved by `fn`.
-     */
-    write<T>(fn: (dz: TDrizzle) => Promise<T>): Promise<T>;
-    /**
-     * Run multiple writes inside a single transaction; the whole transaction is retried on deadlock.
-     *
-     * @typeParam T - the value resolved by `fn`.
-     * @param fn - callback that receives the transaction handle and returns the awaited work.
-     * @returns the value resolved by `fn`.
-     */
-    transaction<T>(fn: (tx: TTx) => Promise<T>): Promise<T>;
-}
-/**
- * A {@link Database} that opens its own connections.
- *
- * @remarks
- * Used by variants that open connections internally. Lifecycle behavior depends on the backing
- * implementation: pool-backed databases close their pool, while Hyperdrive-backed databases leave
- * invocation-scoped connection cleanup to the Workers runtime.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface DisposableDatabase<TDrizzle, TTx = TxOf<TDrizzle>> extends Database<TDrizzle, TTx> {
-    /**
-     * Release resources owned by the implementation. Hyperdrive-backed databases keep this method as
-     * a compatibility no-op; pool-backed databases use it to close their pool.
-     *
-     * @returns a promise that resolves after implementation-specific cleanup.
-     */
-    dispose(): Promise<void>;
-}
-/**
- * A Hyperdrive-backed database with an explicit primary query path.
- *
- * @remarks
- * Use `query()` only for SELECTs that require read-after-write consistency or cannot use the
- * configured replica. Fatal connection errors recreate the primary connection and repeat the
- * SELECT at most once. Writes and transactions are never repeated for connection errors.
- * Read-only transactions are serialized on a separately cached primary connection so their
- * snapshot boundaries cannot mix with ordinary primary operations or with each other. Do not call
- * `readTransaction()` recursively from its own callback.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @typeParam TTx - the transaction-handle type, inferred from `TDrizzle` by default.
- */
-export interface HyperdriveDatabase<TDrizzle, TTx = TxOf<TDrizzle>> extends DisposableDatabase<TDrizzle, TTx> {
-    /**
-     * Run a raw SQL SELECT against the primary database.
-     *
-     * @typeParam T - the complete rows result type (for example, `User[]`).
-     * @param sql - the SQL text, with `?` placeholders for `params`.
-     * @param params - optional positional parameters.
-     * @returns the rows returned by the query, typed as `T`.
-     */
-    query<T = unknown>(sql: string, params?: unknown[]): Promise<T>;
-    /**
-     * Run a repeatable-read, consistent snapshot on the primary database.
-     *
-     * @remarks
-     * The callback is repeated at most once on a fresh connection after a fatal connection error.
-     * This is safe only because the transaction is declared read-only. Use {@link transaction} for
-     * writes; write transactions are never repeated after connection loss. Calls are serialized on
-     * one dedicated connection, so recursive `readTransaction()` calls are not supported.
-     */
-    readTransaction<T>(fn: (reader: ReadTransaction<TTx>) => Promise<T>): Promise<T>;
-}
-/** Primary read-only transaction handles that share one consistent snapshot. */
-export interface ReadTransaction<TTx> {
-    /**
-     * The consumer's Drizzle transaction handle.
-     *
-     * @remarks
-     * Drizzle's type does not distinguish read-only transactions. MySQL enforces read-only mode at
-     * runtime; applications may expose a narrower SELECT-only facade when they need compile-time
-     * enforcement.
-     */
-    orm: TTx;
-    /** Run raw SQL on the same primary connection and snapshot. */
-    query: <T = unknown>(sql: string, params?: unknown[]) => Promise<T>;
-}
-/**
- * Options for {@link createMysqlDatabase}.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export interface CreateMysqlDatabaseOptions<TDrizzle> {
-    /**
-     * The Drizzle ORM used for writes, created by the consumer with its own `drizzle-orm`
-     * (e.g. `drizzle(primary, { schema, ... })`).
-     */
-    orm: TDrizzle;
-    /** The connection used for reads (raw SQL). */
-    replica: QueryRunner;
-}
-/**
- * Assemble a {@link Database} from an already-connected ORM and replica.
- *
- * @remarks
- * The caller (typically the worker entry point) owns creating the connections and the ORM, and is
- * responsible for closing the connections; this variant does not manage their lifecycle.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the write ORM and the read connection.
- * @returns a {@link Database} backed by the supplied ORM and replica.
- * @example
- * ```ts
- * const db = createMysqlDatabase({
- *   orm: drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- *   replica,
- * });
- * const rows = await db.read<User>('SELECT * FROM users WHERE id = ?', [id]);
- * ```
- */
-export declare function createMysqlDatabase<TDrizzle>(options: CreateMysqlDatabaseOptions<TDrizzle>): Database<TDrizzle>;
-/**
- * Options for {@link createHyperdriveDatabase}.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- */
-export interface CreateHyperdriveDatabaseOptions<TDrizzle> {
-    /** The Hyperdrive binding for the primary (write) connection. */
-    primaryHyperdrive: HyperdriveLike;
-    /** The Hyperdrive binding for the replica (read) connection. */
-    replicaHyperdrive: HyperdriveLike;
-    /**
-     * Factory that builds the write ORM from the primary connection, using the consumer's
-     * `drizzle-orm`.
-     */
-    createOrm: (primary: Connection) => TDrizzle;
-    /**
-     * Extra options forwarded to mysql2 `createConnection`, merged on top of the defaults applied by
-     * {@link hyperdriveConnectionOptions} (`disableEval: true`, `decimalNumbers: true`, and
-     * `timezone: '+09:00'`). Pass a field here to override any of those defaults.
-     */
-    connectionOptions?: Record<string, unknown>;
-}
-/**
- * Create a {@link HyperdriveDatabase} that lazily opens its connections from Hyperdrive bindings.
- *
- * @remarks
- * Construct one per request. Connections and the ORM are created on first use and reused for the
- * lifetime of the instance. `read()` uses the replica, while `query()` provides an explicit
- * primary SELECT path. Workers automatically cleans up connections at the end of the invocation,
- * so callers do not need to close them manually. Either SELECT path is repeated once on a fresh
- * connection after a fatal mysql2 connection error. Writes and transactions are never repeated
- * for connection errors because their commit state can be ambiguous.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the primary/replica Hyperdrive bindings, the ORM factory, and connection options.
- * @returns a {@link HyperdriveDatabase} whose compatibility `dispose()` method is a no-op; Workers
- *   cleans up its invocation-scoped connections automatically.
- * @example
- * ```ts
- * const db = createHyperdriveDatabase({
- *   primaryHyperdrive: env.PRIMARY,
- *   replicaHyperdrive: env.REPLICA,
- *   createOrm: (primary) => drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- * });
- * await db.write((dz) => dz.insert(users).values(user));
- * ```
- */
-export declare function createHyperdriveDatabase<TDrizzle>(options: CreateHyperdriveDatabaseOptions<TDrizzle>): HyperdriveDatabase<TDrizzle>;
-/**
- * Internal helper that assembles a {@link Database} from an ORM and a replica connection.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param orm - the Drizzle ORM used for writes and transactions.
- * @param replica - the connection used for reads.
- * @returns a {@link Database} wiring reads to `replica` and writes to `orm`, both with deadlock retry.
- * @internal
- */
-export declare function databaseFrom<TDrizzle>(orm: TDrizzle, replica: QueryRunner): Database<TDrizzle>;
-/**
- * Re-export of the mysql2 `Connection` and `Pool` types.
- *
- * @remarks
- * Both are structurally assignable to the kit's {@link QueryRunner}.
- */
-export type { Connection, Pool };

package/dist/db/database.js

@@ -1,196 +0,0 @@
-import { createConnection } from 'mysql2/promise';
-import { hyperdriveConnectionOptions } from './connection.js';
-import { retryWhenDeadlock } from './retry.js';
-/**
- * Assemble a {@link Database} from an already-connected ORM and replica.
- *
- * @remarks
- * The caller (typically the worker entry point) owns creating the connections and the ORM, and is
- * responsible for closing the connections; this variant does not manage their lifecycle.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the write ORM and the read connection.
- * @returns a {@link Database} backed by the supplied ORM and replica.
- * @example
- * ```ts
- * const db = createMysqlDatabase({
- *   orm: drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- *   replica,
- * });
- * const rows = await db.read<User>('SELECT * FROM users WHERE id = ?', [id]);
- * ```
- */
-export function createMysqlDatabase(options) {
-    return databaseFrom(options.orm, options.replica);
-}
-/**
- * Create a {@link HyperdriveDatabase} that lazily opens its connections from Hyperdrive bindings.
- *
- * @remarks
- * Construct one per request. Connections and the ORM are created on first use and reused for the
- * lifetime of the instance. `read()` uses the replica, while `query()` provides an explicit
- * primary SELECT path. Workers automatically cleans up connections at the end of the invocation,
- * so callers do not need to close them manually. Either SELECT path is repeated once on a fresh
- * connection after a fatal mysql2 connection error. Writes and transactions are never repeated
- * for connection errors because their commit state can be ambiguous.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param options - the primary/replica Hyperdrive bindings, the ORM factory, and connection options.
- * @returns a {@link HyperdriveDatabase} whose compatibility `dispose()` method is a no-op; Workers
- *   cleans up its invocation-scoped connections automatically.
- * @example
- * ```ts
- * const db = createHyperdriveDatabase({
- *   primaryHyperdrive: env.PRIMARY,
- *   replicaHyperdrive: env.REPLICA,
- *   createOrm: (primary) => drizzle(primary, { schema, ...DRIZZLE_ORM_OPTIONS }),
- * });
- * await db.write((dz) => dz.insert(users).values(user));
- * ```
- */
-export function createHyperdriveDatabase(options) {
-    const { primaryHyperdrive, replicaHyperdrive, createOrm, connectionOptions } = options;
-    let primaryConn;
-    let replicaConn;
-    let readTransactionConn;
-    let orm;
-    let readTransactionOrm;
-    let readTransactionTail;
-    const primary = () => (primaryConn ??= connect(primaryHyperdrive, connectionOptions));
-    const replica = () => (replicaConn ??= connect(replicaHyperdrive, connectionOptions));
-    const readTransactionConnection = () => (readTransactionConn ??= connect(primaryHyperdrive, connectionOptions));
-    const ormFor = async () => (orm ??= createOrm(await primary()));
-    const readFrom = (connection, sql, params) => retryWhenDeadlock(async () => {
-        const [rows] = (await (await connection).query(sql, params));
-        return rows;
-    });
-    const readWithRecovery = async (connectionFor, reset, sql, params) => {
-        const connection = connectionFor();
-        const outcome = await readFrom(connection, sql, params).then((rows) => ({ ok: true, rows }), (error) => ({ ok: false, error }));
-        if (outcome.ok) {
-            return outcome.rows;
-        }
-        if (!isFatalConnectionError(outcome.error)) {
-            throw outcome.error;
-        }
-        reset(connection);
-        return readFrom(connectionFor(), sql, params);
-    };
-    const resetPrimary = (failedConnection) => {
-        if (primaryConn === failedConnection) {
-            primaryConn = undefined;
-            orm = undefined;
-        }
-    };
-    const resetReadTransaction = (failedConnection) => {
-        if (readTransactionConn === failedConnection) {
-            readTransactionConn = undefined;
-            readTransactionOrm = undefined;
-        }
-    };
-    const withReadTransactionLock = (fn) => {
-        const result = readTransactionTail ? readTransactionTail.then(fn, fn) : fn();
-        readTransactionTail = result.then(() => undefined, () => undefined);
-        return result;
-    };
-    const runReadTransaction = async (connection, fn) => {
-        const conn = await connection;
-        const dz = (readTransactionOrm ??= createOrm(conn));
-        return retryWhenDeadlock(async () => {
-            await conn.query('SET TRANSACTION READ ONLY');
-            return dz.transaction((tx) => fn({
-                orm: tx,
-                query: async (sql, params = []) => {
-                    const [rows] = (await conn.query(sql, params));
-                    return rows;
-                },
-            }), { isolationLevel: 'repeatable read', withConsistentSnapshot: true });
-        });
-    };
-    return {
-        read(sql, params = []) {
-            return readWithRecovery(replica, (failedConnection) => {
-                if (replicaConn === failedConnection) {
-                    replicaConn = undefined;
-                }
-            }, sql, params);
-        },
-        query(sql, params = []) {
-            return readWithRecovery(primary, resetPrimary, sql, params);
-        },
-        async readTransaction(fn) {
-            return withReadTransactionLock(async () => {
-                const connection = readTransactionConnection();
-                const outcome = await runReadTransaction(connection, fn).then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
-                if (outcome.ok) {
-                    return outcome.value;
-                }
-                if (!isFatalConnectionError(outcome.error)) {
-                    throw outcome.error;
-                }
-                resetReadTransaction(connection);
-                return runReadTransaction(readTransactionConnection(), fn);
-            });
-        },
-        async write(fn) {
-            const dz = await ormFor();
-            return retryWhenDeadlock(() => fn(dz));
-        },
-        async transaction(fn) {
-            const dz = (await ormFor());
-            return retryWhenDeadlock(() => dz.transaction(fn));
-        },
-        /** @deprecated Workers cleans up invocation-scoped connections automatically. */
-        async dispose() {
-            return;
-        },
-    };
-}
-/**
- * Internal helper that assembles a {@link Database} from an ORM and a replica connection.
- *
- * @typeParam TDrizzle - the consumer's Drizzle ORM type.
- * @param orm - the Drizzle ORM used for writes and transactions.
- * @param replica - the connection used for reads.
- * @returns a {@link Database} wiring reads to `replica` and writes to `orm`, both with deadlock retry.
- * @internal
- */
-export function databaseFrom(orm, replica) {
-    const drizzleLike = orm;
-    return {
-        read(sql, params = []) {
-            return retryWhenDeadlock(async () => {
-                const [rows] = (await replica.query(sql, params));
-                return rows;
-            });
-        },
-        write(fn) {
-            return retryWhenDeadlock(() => fn(orm));
-        },
-        transaction(fn) {
-            return retryWhenDeadlock(() => drizzleLike.transaction(fn));
-        },
-    };
-}
-function connect(hyperdrive, extra) {
-    return createConnection(hyperdriveConnectionOptions(hyperdrive, extra));
-}
-function isFatalConnectionError(error) {
-    let current = error;
-    const seen = new Set();
-    while (typeof current === 'object' && current !== null && !seen.has(current)) {
-        seen.add(current);
-        const value = current;
-        if (value.fatal === true ||
-            value.code === 'PROTOCOL_CONNECTION_LOST' ||
-            value.code === 'ECONNRESET' ||
-            value.code === 'EPIPE' ||
-            (typeof value.message === 'string' &&
-                (value.message.includes('Connection lost:') ||
-                    value.message.includes("Can't add new command when connection is in closed state")))) {
-            return true;
-        }
-        current = value.cause;
-    }
-    return false;
-}

package/dist/db/jst.d.ts

@@ -1,45 +0,0 @@
-/**
- * JST wire conversion and DATE-column normalization for MySQL / Drizzle.
- *
- * @remarks
- * Business-time semantics are consolidated in {@link ../business-time/index.js | business-time}. This
- * module only owns the MySQL connection default, the DATE column's `toDriver`, and the column
- * `customType` params.
- */
-import type { BusinessDate } from '../business-time/index.js';
-/** Default mysql2 connection `timezone` (for the existing JST DB deployment). */
-export declare const MYSQL_TIMEZONE = "+09:00";
-/**
- * Normalize a client input to `YYYY-MM-DD` (a JST business calendar date) for a MySQL `DATE` column.
- * Accepts ISO 8601 / `YYYY-MM-DD` / empty strings. A `YYYY-MM-DD` value is passed through without
- * constructing a `Date`.
- *
- * @param value - the string or nullish input to normalize.
- * @returns the business date as `YYYY-MM-DD`, or `null` when the input cannot be resolved.
- */
-export declare function toJstDate(value: string | null | undefined): BusinessDate | null;
-/**
- * Build the params for a `customType` backing a MySQL `timestamp` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `timestamp(fsp)`.
- */
-export declare const jstTimestampParams: (fsp?: number) => {
-    dataType: () => string;
-};
-/**
- * Build the params for a `customType` backing a MySQL `datetime` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `datetime(fsp)`.
- */
-export declare const jstDatetimeParams: (fsp?: number) => {
-    dataType: () => string;
-};
-/**
- * Build the params for a `customType` backing a MySQL `date` column with JST normalization.
- *
- * @returns params with `toDriver` running {@link toJstDate}.
- */
-export declare const jstDateParams: () => {
-    dataType: () => string;
-    toDriver: (value: string | null) => string | null;
-};

package/dist/db/jst.js

@@ -1,47 +0,0 @@
-/**
- * JST wire conversion and DATE-column normalization for MySQL / Drizzle.
- *
- * @remarks
- * Business-time semantics are consolidated in {@link ../business-time/index.js | business-time}. This
- * module only owns the MySQL connection default, the DATE column's `toDriver`, and the column
- * `customType` params.
- */
-import { normalizeBusinessDate } from '../business-time/index.js';
-/** Default mysql2 connection `timezone` (for the existing JST DB deployment). */
-export const MYSQL_TIMEZONE = '+09:00';
-/**
- * Normalize a client input to `YYYY-MM-DD` (a JST business calendar date) for a MySQL `DATE` column.
- * Accepts ISO 8601 / `YYYY-MM-DD` / empty strings. A `YYYY-MM-DD` value is passed through without
- * constructing a `Date`.
- *
- * @param value - the string or nullish input to normalize.
- * @returns the business date as `YYYY-MM-DD`, or `null` when the input cannot be resolved.
- */
-export function toJstDate(value) {
-    return normalizeBusinessDate(value ?? null);
-}
-/**
- * Build the params for a `customType` backing a MySQL `timestamp` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `timestamp(fsp)`.
- */
-export const jstTimestampParams = (fsp) => ({
-    dataType: () => (fsp != null ? `timestamp(${fsp})` : 'timestamp'),
-});
-/**
- * Build the params for a `customType` backing a MySQL `datetime` column with `Date` pass-through.
- *
- * @param fsp - optional fractional-seconds precision; when provided, emits `datetime(fsp)`.
- */
-export const jstDatetimeParams = (fsp) => ({
-    dataType: () => (fsp != null ? `datetime(${fsp})` : 'datetime'),
-});
-/**
- * Build the params for a `customType` backing a MySQL `date` column with JST normalization.
- *
- * @returns params with `toDriver` running {@link toJstDate}.
- */
-export const jstDateParams = () => ({
-    dataType: () => 'date',
-    toDriver: (value) => toJstDate(value),
-});

package/dist/db/migrate.d.ts

@@ -1,51 +0,0 @@
-import type { QueryRunner } from './database.js';
-/** Identifying info for the baseline (i.e. first) migration. */
-export interface BaselineEntry {
-    /** The migration tag (e.g. `0000_melted_weapon_omega`). */
-    tag: string;
-    /** The `when` from `_journal.json` (= drizzle's `created_at` / `folderMillis`). */
-    when: number;
-    /** The sha256 of the raw `<tag>.sql` contents (the same algorithm as drizzle). */
-    hash: string;
-}
-/**
- * Read the baseline (first) entry from `migrationsFolder` (drizzle's `out`, e.g. `./drizzle`).
- *
- * @param migrationsFolder - the folder containing `meta/_journal.json` and `<tag>.sql`.
- * @returns the baseline entry (tag/when/hash).
- * @throws Error when the journal is missing, the entries are empty, or `<tag>.sql` is missing.
- */
-export declare function readBaselineEntry(migrationsFolder: string): BaselineEntry;
-/** Options for {@link baselineMigrations}. */
-export interface BaselineMigrationsOptions {
-    /** A QueryRunner for raw SQL (a mysql2 `Connection`/`Pool` is assignable). Must already be connected to the target DB. */
-    db: QueryRunner;
-    /** Drizzle's `out` folder (defaults to `./drizzle`). */
-    migrationsFolder?: string;
-}
-/** The result of {@link baselineMigrations}. */
-export type BaselineResult = {
-    status: 'inserted';
-    tag: string;
-    when: number;
-    hash: string;
-} | {
-    status: 'already-baselined';
-    tag: string;
-    when: number;
-};
-/**
- * Record the baseline (0000) as "applied" on an existing DB. Idempotent, with safety guards.
- *
- * @remarks
- * Guards:
- * - If a baseline marker (`created_at = when`) already exists → **no-op** (`already-baselined`).
- * - If there is no marker but `__drizzle_migrations` has other rows → **abort** (unexpected state).
- * - If the target DB has no base tables (an empty DB) → **abort** (skipping 0000 on an empty DB would
- *   never create the tables; use `db:migrate` for a fresh DB).
- *
- * @param options - the connection and migrations folder; see {@link BaselineMigrationsOptions}.
- * @returns whether a marker was inserted or the DB was already baselined.
- * @throws Error when one of the guards above trips.
- */
-export declare function baselineMigrations(options: BaselineMigrationsOptions): Promise<BaselineResult>;