@vibeorm/migrate 1.3.1 → 2.0.0-alpha.10

package/dist/execute.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Statement-execution helpers shared by push and the migration runner.
+ *
+ * Two sqlite realities live here:
+ *
+ * - SELF-MANAGED SCRIPTS: the table-rebuild recipe (ddl/sqlite.ts) carries its
+ *   own `PRAGMA foreign_keys=OFF; BEGIN; … COMMIT; PRAGMA foreign_keys=ON;`
+ *   sequence, because `PRAGMA foreign_keys` is a no-op inside a transaction.
+ *   Callers must NOT wrap such scripts in an outer BEGIN/COMMIT —
+ *   `usesSelfManagedTransactions` detects them. Plain statements in a
+ *   self-managed script auto-commit individually (documented sqlite
+ *   limitation: a mixed script is not atomic as a whole; each rebuild block
+ *   is). Because of that, the migration runner records per-statement progress
+ *   for these scripts and resumes with `selfManagedResumeStart`, which rewinds
+ *   INTO the enclosing block so the session-scoped `PRAGMA foreign_keys=OFF`
+ *   is re-issued before the block replays.
+ * - `PRAGMA foreign_key_check` RETURNS VIOLATION ROWS instead of failing —
+ *   `executeStatement` runs it row-returning (`values: []`, the adapter-sqlite
+ *   contract for reads) and throws VIBE_MIGRATION when any come back.
+ */
+import type { Dialect } from "@vibeorm/schema";
+import type { SqlExecutor } from "./types.ts";
+/** True when the script manages its own transactions (sqlite rebuilds). */
+export declare function usesSelfManagedTransactions(params: {
+    sql: readonly string[];
+}): boolean;
+/**
+ * Where a resume of a self-managed sqlite script must actually restart.
+ *
+ * A recorded statement_index can point INSIDE a rebuild block: the progress
+ * UPDATE issued after `PRAGMA foreign_keys=OFF;` auto-commits (no transaction
+ * is open yet), while every UPDATE after the block's `BEGIN;` is rolled back
+ * with the crash — so the persisted index lands on the block's `BEGIN;`, one
+ * past a pragma that is SESSION-scoped and gone in the new session. Resuming
+ * there would run the rebuild — `DROP TABLE` of a possibly-referenced parent
+ * included — with foreign keys ON.
+ *
+ * This rewinds `start` to the nearest preceding `PRAGMA foreign_keys=OFF` that
+ * is not already closed by a `PRAGMA foreign_keys=ON`. Replaying from a
+ * block's start is safe only for an uncommitted block: the runner checkpoints
+ * past COMMIT inside the transaction, so a committed block is never replayed.
+ * Legacy journals pointing AT COMMIT are ambiguous and refused by the runner.
+ * Scripts with no marker before `start` are returned unchanged.
+ */
+export declare function selfManagedResumeStart(params: {
+    sql: readonly string[];
+    start: number;
+}): number;
+/** True when a supported block must checkpoint BEFORE committing its transaction. */
+export declare function isSelfManagedCommit(params: {
+    statement: string;
+}): boolean;
+/**
+ * An old writer could persist an index AT COMMIT after the block committed.
+ * The new writer checkpoints past it atomically and cannot produce this state.
+ * Keep historical uncertainty visible until an operator establishes the result.
+ */
+export declare function assertSelfManagedResumeSafe(params: {
+    sql: readonly string[];
+    start: number;
+    migration: string;
+    direction: "up" | "down";
+}): void;
+/**
+ * Can this statement of a self-managed sqlite script commit together with its
+ * own journal checkpoint?
+ *
+ * True for a statement that sits OUTSIDE every rebuild block and that sqlite
+ * allows inside a transaction. Wrapping such a statement with its checkpoint in
+ * one `BEGIN`/`COMMIT` closes the crash window entirely: either both landed or
+ * neither did, so a resume never has to guess whether it already ran.
+ *
+ * Block membership is decided by {@link selfManagedResumeStart}, the SAME
+ * backward scan the resume path uses — the two can never disagree about where a
+ * block starts. Inside a block no wrapping is possible or needed: the block
+ * carries its own transaction, so nothing of it survives a crash and
+ * `selfManagedResumeStart` rewinds to its opening pragma.
+ */
+export declare function canCheckpointAtomically(params: {
+    sql: readonly string[];
+    index: number;
+}): boolean;
+/**
+ * Refuse a self-managed sqlite script whose control flow the resume path
+ * cannot honour, BEFORE any statement of it runs.
+ *
+ * The generated rebuild recipe (ddl/sqlite.ts) always emits
+ * `PRAGMA foreign_keys=OFF;` immediately followed by `BEGIN;`, and `COMMIT;`
+ * immediately followed by `PRAGMA foreign_keys=ON;`. Recovery relies on that
+ * adjacency: it is what makes "inside a foreign-keys-off region" and "inside a
+ * transaction" the same statement set, so rewinding to the region's pragma can
+ * never replay anything that already committed.
+ *
+ * A hand-authored script that deviates breaks the equivalence silently. An
+ * unclosed pragma, or a statement between `COMMIT;` and the restore, commits on
+ * its own while still counting as region-internal, so a crash replays it. That
+ * is a data defect with no error attached, so the script is refused up front
+ * instead. `resolveMigration` and `migrationStatus` are deliberately not
+ * gated by this: an operator must still be able to read and repair the journal
+ * row of a migration that is refused.
+ */
+export declare function assertSupportedSelfManagedScript(params: {
+    sql: readonly string[];
+    migration: string;
+    direction: "up" | "down";
+}): void;
+/**
+ * Execute one migration statement. On sqlite, `PRAGMA foreign_key_check` is
+ * executed row-returning and its violations become a VIBE_MIGRATION error.
+ */
+export declare function executeStatement(params: {
+    executor: SqlExecutor;
+    statement: string;
+    dialect: Dialect;
+}): Promise<void>;
+/**
+ * Best-effort cleanup after a failed self-managed sqlite script: roll back a
+ * possibly-open rebuild transaction and restore FK enforcement. Never throws
+ * — the original failure matters more.
+ */
+export declare function cleanupSelfManagedFailure(params: {
+    executor: SqlExecutor;
+}): Promise<void>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAU9C,2EAA2E;AAC3E,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,OAAO,CAEvF;AA+BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC7C,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAcT;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;CAC1B,GAAG,IAAI,CAWP;AAyBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAIV;AAgCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gCAAgC,CAAC,MAAM,EAAE;IACvD,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;CAC1B,GAAG,IAAI,CAyDP;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED;;;;GAIG;AACH,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhG"}

package/dist/execution.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Explicit execution semantics for a migration file: which transaction regime
+ * it runs in, which session limits it scopes to its own work, and what each of
+ * its statements is DECLARED to do.
+ *
+ * Why declarations and not SQL parsing: a nontransactional migration can die
+ * between a statement committing and the journal recording it. Recovery then
+ * has to establish what actually happened, and the only honest way to do that
+ * is to compare the live catalog against a declared postcondition. Guessing an
+ * operation out of SQL text is exactly the class of bug F29/F33 came from.
+ *
+ * CHECKSUM COMPATIBILITY — the rule this module exists to protect. A migration
+ * with no execution block, or one that asks for nothing beyond today's
+ * behaviour, hashes byte-for-byte as before ({@link isDefaultExecution} is
+ * true ⇒ {@link executionChecksumSuffix} is empty). Every migration file
+ * written before this feature existed therefore keeps its historical checksum
+ * and no journal row starts looking corrupt. Only an explicitly non-default
+ * block folds a canonical description into the hash, so editing execution
+ * semantics after a migration was applied surfaces as the existing
+ * checksum-mismatch refusal instead of silently changing how it runs.
+ */
+import type { Dialect } from "@vibeorm/schema";
+import type { MigrationStep } from "./types.ts";
+/**
+ * How the runner wraps a migration's statements.
+ *
+ * - `"default"` — the dialect's own regime, unchanged: one transaction per
+ *   migration on postgres/sqlite, per-statement bookkeeping on mysql.
+ * - `"none"` — the migration runs OUTSIDE any transaction the runner opens,
+ *   with per-statement journal progress. Required for statements PostgreSQL
+ *   refuses inside a transaction block, `CREATE INDEX CONCURRENTLY` first
+ *   among them.
+ */
+export type MigrationTransactionMode = "default" | "none";
+/**
+ * What one statement of a nontransactional migration is declared to do — the
+ * postcondition recovery checks against the live catalog. Declared by whoever
+ * wrote the migration; never inferred from the SQL text.
+ */
+export type MigrationOperation = {
+    readonly kind: "createIndexConcurrently";
+    readonly index: string;
+    readonly table: string;
+    readonly unique: boolean;
+    /** Access method as PostgreSQL names it (`btree`, `gin`, …). */
+    readonly method: string;
+    /** Key columns in index order, as PostgreSQL deparses them. */
+    readonly columns: readonly string[];
+    /** Partial-index predicate, when the index has one. */
+    readonly where?: string;
+} | {
+    readonly kind: "dropIndexConcurrently";
+    readonly index: string;
+} | {
+    readonly kind: "addConstraintNotValid";
+    readonly table: string;
+    readonly constraint: string;
+} | {
+    readonly kind: "validateConstraint";
+    readonly table: string;
+    readonly constraint: string;
+} | {
+    readonly kind: "renameTable";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "renameColumn";
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+};
+/** One statement's declared operation, keyed by its index in `MigrationFile.sql`. */
+export type MigrationOperationBinding = {
+    /** 0-based index into the migration's statement array. */
+    readonly statement: number;
+    readonly operation: MigrationOperation;
+};
+/** Explicit execution semantics of one direction (up or down) of a migration. */
+export type MigrationExecution = {
+    readonly transaction: MigrationTransactionMode;
+    /** Migration-owned `lock_timeout` in milliseconds; 0 = no limit (server default). */
+    readonly lockTimeoutMs?: number;
+    /** Migration-owned `statement_timeout` in milliseconds; 0 = no limit. */
+    readonly statementTimeoutMs?: number;
+    readonly operations?: readonly MigrationOperationBinding[];
+};
+/** On-disk sidecar filename beside `migration.sql` / `down.sql`. */
+export declare const EXECUTION_SIDECAR_FILENAME: string;
+/** Sidecar format version — bumped only on an incompatible layout change. */
+export declare const EXECUTION_SIDECAR_VERSION: number;
+/** True when the block asks for nothing beyond the dialect's existing behaviour. */
+export declare function isDefaultExecution(params: {
+    execution?: MigrationExecution;
+}): boolean;
+/** Deterministic one-line description of an operation — checksum input and error text. */
+export declare function describeOperation(params: {
+    operation: MigrationOperation;
+}): string;
+/**
+ * The canonical text folded into the migration checksum — EMPTY for a default
+ * block, so historical checksums are untouched (see the module doc). The text
+ * is built field by field in a fixed order rather than JSON-stringified, so it
+ * cannot drift with object key order.
+ */
+export declare function executionChecksumSuffix(params: {
+    execution?: MigrationExecution;
+}): string;
+/**
+ * Structural checks a declared block must pass before the runner trusts it:
+ * every operation binding points at a real statement, no statement carries two
+ * operations, and the timeouts are non-negative safe integers.
+ */
+export declare function assertValidExecution(params: {
+    execution?: MigrationExecution;
+    statements: number;
+    migration: string;
+}): void;
+/** The operation declared for one statement, if any. */
+export declare function operationFor(params: {
+    execution?: MigrationExecution;
+    statement: number;
+}): MigrationOperation | undefined;
+/**
+ * Serialize the execution sidecar, or `undefined` when both directions are
+ * default and no file should be written at all. Keeping the file absent for
+ * ordinary migrations is what makes the feature invisible to existing trees.
+ */
+export declare function serializeExecutionSidecar(params: {
+    execution?: MigrationExecution;
+    downExecution?: MigrationExecution;
+}): string | undefined;
+/**
+ * Read and validate the sidecar. Nothing here is trusted: an unknown version,
+ * a malformed body or an out-of-range operation binding refuses rather than
+ * silently degrading to default semantics — a migration that believes it runs
+ * outside a transaction and quietly runs inside one is exactly the failure
+ * this metadata exists to prevent.
+ */
+export declare function parseExecutionSidecar(params: {
+    text: string;
+    migration: string;
+    statements: number;
+    downStatements: number;
+}): {
+    readonly execution?: MigrationExecution;
+    readonly downExecution?: MigrationExecution;
+};
+/** A reviewable risk a planned migration carries, for dry-run output. */
+export type MigrationRisk = {
+    readonly kind: "tableRewrite" | "exclusiveLock" | "concurrentIndex" | "validateScan" | "notOnline";
+    readonly detail: string;
+    readonly table?: string;
+};
+/**
+ * Describe the operational risk of a planned migration, for dry-run output.
+ *
+ * Deliberately conservative and deliberately incomplete: it reports what the
+ * step model can prove (a type change that rewrites the table on postgres, an
+ * ALTER/DROP that takes ACCESS EXCLUSIVE, a validation scan) and it always
+ * appends the `notOnline` note, because nothing here — `lock_timeout`
+ * included — makes a migration online. A short lock WAIT is not a short lock
+ * HOLD.
+ */
+export declare function describeMigrationRisks(params: {
+    steps: readonly MigrationStep[];
+    dialect: Dialect;
+}): readonly MigrationRisk[];
+//# sourceMappingURL=execution.d.ts.map

package/dist/execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../src/execution.ts"],"names":[],"mappings":"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"}

package/dist/extensions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Extension artifacts in the migrate pipeline (extensions.md §3 migrate plane).
+ *
+ * Extensions own database objects the core differ does not model: CREATE
+ * EXTENSION, generated tsvector columns, FTS5 shadow tables + triggers,
+ * specialty indexes (gin_trgm_ops, hnsw, bm25, FULLTEXT). The contract:
+ *
+ *   1. `collectExtensionArtifacts` asks each configured extension for its
+ *      artifacts (dialect-correct, idempotent SQL + a structured owner).
+ *   2. `stripExtensionArtifacts` removes owned objects from the INTROSPECTED
+ *      IR before diffing, so the core differ never schedules their drop —
+ *      the introspector-representation-is-the-contract rule (LEARNINGS).
+ *   3. `planMissingArtifacts` decides which artifacts must be created, by
+ *      checking the introspected IR for their owners (columns, indexes,
+ *      tables by name); non-introspectable owners (postgres extensions,
+ *      triggers) rely on their idempotent IF NOT EXISTS forms and always run.
+ *
+ * Removing a declaration does NOT auto-drop its artifacts (mirrors the v1
+ * phantom-join-table precedent) — `drop` SQL is carried for tooling, not
+ * scheduled by push.
+ */
+import type { Dialect, ExtensionArtifact, SchemaIR, VibeExtension } from "@vibeorm/schema";
+/** Artifacts of every configured extension for this schema, in order. */
+export type CollectedArtifacts = {
+    /** CREATE EXTENSION-class artifacts — run BEFORE the core diff SQL. */
+    readonly setup: readonly ExtensionArtifact[];
+    /** Object artifacts (columns, indexes, shadow tables, triggers) — run AFTER. */
+    readonly objects: readonly ExtensionArtifact[];
+};
+export declare function collectExtensionArtifacts(params: {
+    schema: SchemaIR;
+    dialect: Dialect;
+    extensions: readonly VibeExtension[];
+}): CollectedArtifacts;
+/**
+ * Remove extension-owned objects from an INTROSPECTED SchemaIR so the core
+ * differ never sees them (they are neither dropped nor re-created by it).
+ */
+export declare function stripExtensionArtifacts(params: {
+    schema: SchemaIR;
+    artifacts: readonly ExtensionArtifact[];
+}): SchemaIR;
+/** Owner presence the IR cannot answer, probed live by push (both optional). */
+export type InstalledExtensionState = {
+    /** `SELECT extname FROM pg_extension` — postgres only. */
+    readonly pgExtensions?: ReadonlySet<string>;
+    /** `sqlite_master WHERE type='trigger'` names — sqlite only. */
+    readonly triggers?: ReadonlySet<string>;
+};
+/**
+ * The artifacts whose owner is missing from the introspected IR (must be
+ * created). Owners the IR cannot see — postgres extensions and triggers —
+ * consult the live-probed `installed` state when given, else always plan;
+ * their `create` SQL is idempotent (IF NOT EXISTS) so replays converge.
+ */
+export declare function planMissingArtifacts(params: {
+    introspected: SchemaIR;
+    artifacts: readonly ExtensionArtifact[];
+    installed?: InstalledExtensionState;
+}): ExtensionArtifact[];
+/** Probe live owner state the IR cannot carry (used by push before planning). */
+export declare function probeInstalledExtensionState(params: {
+    executor: (execParams: {
+        text: string;
+        values?: unknown[];
+    }) => Promise<Record<string, unknown>[]>;
+    dialect: Dialect;
+    artifacts: readonly ExtensionArtifact[];
+}): Promise<InstalledExtensionState>;
+/** Flatten artifacts to their create statements, in order. */
+export declare function artifactCreateSql(params: {
+    artifacts: readonly ExtensionArtifact[];
+}): string[];
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EACV,OAAO,EACP,iBAAiB,EAEjB,QAAQ,EACR,aAAa,EACd,MAAM,iBAAiB,CAAC;AAIzB,yEAAyE;AACzE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,uEAAuE;IACvE,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAChD,CAAC;AAEF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,MAAM,EAAE,QAAQ,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CACtC,GAAG,kBAAkB,CAwBrB;AAkBD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,MAAM,EAAE,QAAQ,CAAC;IACjB,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACzC,GAAG,QAAQ,CAyCX;AAID,gFAAgF;AAChF,MAAM,MAAM,uBAAuB,GAAG;IACpC,0DAA0D;IAC1D,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,gEAAgE;IAChE,QAAQ,CAAC,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACzC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,YAAY,EAAE,QAAQ,CAAC;IACvB,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACxC,SAAS,CAAC,EAAE,uBAAuB,CAAC;CACrC,GAAG,iBAAiB,EAAE,CA8BtB;AAED,iFAAiF;AACjF,wBAAsB,4BAA4B,CAAC,MAAM,EAAE;IACzD,QAAQ,EAAE,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IACnG,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACzC,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAiBnC;AAED,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,SAAS,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACzC,GAAG,MAAM,EAAE,CAEX"}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @vibeorm/migrate — schema diffing, per-dialect DDL rendering, migration
+ * running, push/pull and database introspection for VibeORM v2.
+ *
+ * All three dialects are live: postgres/pglite, sqlite (table-rebuild recipe
+ * for the ALTERs sqlite cannot express) and mysql (non-transactional runner
+ * with per-statement resume). `renderSteps` / `push` / `pull` /
+ * `generateMigration` / `applyMigrations` route per dialect; the per-dialect
+ * modules live under src/ddl/ and src/introspect/.
+ */
+export { describeStep } from "./types.ts";
+export type { AlterColumnAspect, AppliedResult, IndexColumn, JoinTableEnd, MigrationFile, MigrationStatus, MigrationStep, PushResult, RecordedMigration, RecordedMigrationState, SqlExecutor, } from "./types.ts";
+export { diffSchemas } from "./differ.ts";
+export { detectImplicitM2MPairs } from "./relations.ts";
+export type { ImplicitM2MPair } from "./relations.ts";
+export { renderSteps } from "./ddl/render.ts";
+export { introspectPostgres } from "./introspect/postgres.ts";
+export { introspectSqlite } from "./introspect/sqlite.ts";
+export { introspectMysql } from "./introspect/mysql.ts";
+export { MIGRATIONS_TABLE_NAME, applyMigrations, ensureMigrationsTable, generateMigration, migrationChecksum, migrationStatus, recordedMigrations, resolveMigration, rollbackMigration, } from "./runner.ts";
+export { EXECUTION_SIDECAR_FILENAME, EXECUTION_SIDECAR_VERSION, assertValidExecution, describeMigrationRisks, describeOperation, executionChecksumSuffix, isDefaultExecution, operationFor, parseExecutionSidecar, serializeExecutionSidecar, } from "./execution.ts";
+export type { MigrationExecution, MigrationOperation, MigrationOperationBinding, MigrationRisk, MigrationTransactionMode, } from "./execution.ts";
+export { establishOperationState } from "./recovery.ts";
+export type { OperationState } from "./recovery.ts";
+export { planRenames } from "./renames.ts";
+export type { RenameIntent } from "./renames.ts";
+export { generateDownMigration } from "./down.ts";
+export type { DownMigrationFile } from "./down.ts";
+export { pull, push } from "./push.ts";
+export { artifactCreateSql, collectExtensionArtifacts, planMissingArtifacts, probeInstalledExtensionState, stripExtensionArtifacts, } from "./extensions.ts";
+export type { CollectedArtifacts, InstalledExtensionState } from "./extensions.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,aAAa,EACb,eAAe,EACf,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,sBAAsB,EACtB,WAAW,GACZ,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AACxD,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAItD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAI9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAIxD,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAIrB,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,yBAAyB,EACzB,aAAa,EACb,wBAAwB,GACzB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAIjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAInD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIvC,OAAO,EACL,iBAAiB,EACjB,yBAAyB,EACzB,oBAAoB,EACpB,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC"}