@vibeorm/migrate 1.3.1 → 2.0.0-alpha.10

package/dist/introspect/mysql.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MySQL introspection: live database → SchemaIR, from
+ * `information_schema.{tables,views,columns,statistics,key_column_usage,
+ * referential_constraints}` (scoped to `DATABASE()`).
+ *
+ * Representation mirrors introspect/postgres.ts exactly (shared.ts carries
+ * the one relation/join-table rule). MySQL-specific decisions:
+ *
+ * - `COLUMN_TYPE` is the reverse-mapping source: `tinyint(1)` → Boolean (the
+ *   marker), `varchar(191)` → String, `enum('A','B')` → an enum whose values
+ *   are parsed from the type and whose NAME is synthesized as
+ *   `<Table>_<column>` — mysql enums are nameless, so the schema-declared
+ *   name is unrecoverable. The differ compares enum columns by VALUE LIST
+ *   (normalize.ts), so the synthetic names never produce phantom steps.
+ * - `EXTRA = auto_increment` → `@default(autoincrement())`;
+ *   `DEFAULT_GENERATED` expressions → `dbgenerated` (CURRENT_TIMESTAMP(…) →
+ *   `now` first).
+ * - Non-canonical column types keep `COLUMN_TYPE` in `nativeType`; unknown
+ *   types become `isUnsupported` fields (F3: keep, don't drop).
+ * - Indexes named like an FK constraint on the same table are SKIPPED: mysql
+ *   auto-creates them for FKs without a covering index, and surfacing them
+ *   would churn round-trips with phantom index steps.
+ * - The `_vibe_migrations` bookkeeping table is skipped.
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live mysql database (current schema) into SchemaIR. */
+export declare function introspectMysql(params: {
+    executor: SqlExecutor;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=mysql.d.ts.map

package/dist/introspect/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../src/introspect/mysql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAUV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyH/C,uEAAuE;AACvE,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CA6M1F"}

package/dist/introspect/postgres-rls.d.ts

@@ -0,0 +1,41 @@
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Catalog attributes are intentionally not represented as authored policy declarations. */
+export type PostgresRlsPolicy = {
+    readonly name: string;
+    readonly command: string;
+    readonly permissive: boolean;
+    readonly roles: string;
+    readonly using: string | null;
+    readonly withCheck: string | null;
+    readonly comment: string | null;
+};
+/** Every public ordinary/partitioned table, including tables with flags but no policies. */
+export type PostgresRlsTable = {
+    readonly table: string;
+    readonly enabled: boolean;
+    readonly force: boolean;
+    readonly policies: readonly PostgresRlsPolicy[];
+};
+/** Read both clauses and all structural attributes; callers pin search_path and transaction. */
+export declare function readPostgresRls(params: {
+    executor: SqlExecutor;
+}): Promise<PostgresRlsTable[]>;
+/**
+ * Compare against a trusted deployed declaration, not a policy name/comment/hash.
+ * An explicit previousSchema/status check requires every declared policy to exist.
+ * Push without a previous schema permits installing protection on an ordinary table.
+ * Must run inside the caller's transaction. Locks survive the rolled-back probe.
+ */
+export declare function verifyPostgresRls(params: {
+    executor: SqlExecutor;
+    schema?: SchemaIR;
+    requireInstalled?: boolean;
+}): Promise<ReadonlySet<string>>;
+/** Attach only verified declarations, mapped to the physical names introspection uses. No SQL parsing. */
+export declare function projectPostgresRls(params: {
+    physical: SchemaIR;
+    declared?: SchemaIR;
+    matched: ReadonlySet<string>;
+}): SchemaIR;
+//# sourceMappingURL=postgres-rls.d.ts.map

package/dist/introspect/postgres-rls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-rls.d.ts","sourceRoot":"","sources":["../../src/introspect/postgres-rls.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAwB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAGtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,4FAA4F;AAC5F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CAAC;AACF,4FAA4F;AAC5F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACjD,CAAC;AAeF,gGAAgG;AAChG,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAepG;AAUD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAyD/B;AAED,0GAA0G;AAC1G,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,GAAG,QAAQ,CAsB9H"}

package/dist/introspect/postgres.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live postgres/pglite database (public schema) into SchemaIR. */
+export declare function introspectPostgres(params: {
+    executor: SqlExecutor;
+    /** Trusted policy declaration; missing this refuses lossy RLS introspection/export. */
+    rlsSchema?: SchemaIR;
+    /** The caller owns BEGIN/COMMIT, keeping probe locks through subsequent migration DDL. */
+    inTransaction?: boolean;
+    requireInstalledRls?: boolean;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/introspect/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/introspect/postgres.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EASV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA0L/C,gFAAgF;AAChF,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,QAAQ,EAAE,WAAW,CAAC;IACtB,uFAAuF;IACvF,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,0FAA0F;IAC1F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuBpB"}

package/dist/introspect/shared.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Introspection helpers shared by ALL dialect introspectors — the join-table
+ * detection rule and the relation/naming conventions live HERE, once
+ * (LEARNINGS: implicit-M2M conventions must never be re-implemented per
+ * consumer). Every dialect introspector produces the same representation:
+ *
+ * - FKs become an UNNAMED `manyToOne` on the owning model plus an UNNAMED
+ *   `oneToMany` list side on the target — EXCEPT when the model pair carries
+ *   more than one unnamed relation pair (mutual FKs, twin FKs to one target,
+ *   an FK alongside a default-named join table): those FK pairs get a
+ *   synthesized `@relation` name so `db pull` output re-parses (the parser
+ *   rejects the unnamed shape as `ambiguous-relation`) and implicit-M2M
+ *   detection keeps its name keys unique.
+ * - A table matching the implicit join-table shape (name `_X`, exactly columns
+ *   "A" and "B", two single-column FKs, a unique index on (A, B)) is NOT a
+ *   model: it becomes two unnamed `oneToMany` list sides on the joined models,
+ *   carrying `relationName` when the physical name differs from the default
+ *   `_AToB`.
+ */
+import type { CascadeAction, ModelIR } from "@vibeorm/schema";
+/** A grouped foreign key (composite-capable), dialect-independent. */
+export type FkGroup = {
+    readonly constraintName: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete: CascadeAction;
+    readonly onUpdate: CascadeAction;
+    /** Every FK column NOT NULL (drives isOptional on the relation). */
+    readonly required: boolean;
+};
+/** An introspected index in the shape join-table detection needs. */
+export type IntrospectedIndex = {
+    readonly table: string;
+    readonly name: string;
+    readonly unique: boolean;
+    readonly kind: string;
+    readonly columns: readonly {
+        readonly name: string;
+        readonly desc: boolean;
+    }[];
+    readonly where?: string;
+    /** `UNIQUE NULLS NOT DISTINCT` (postgres 15+). */
+    readonly nullsNotDistinct?: boolean;
+};
+/** A detected physical join table. */
+export type JoinTableInfo = {
+    readonly tableA: string;
+    readonly tableB: string;
+    readonly relationName?: string;
+};
+/**
+ * Detect whether a physical table is an implicit many-to-many join table:
+ * name starts with `_`, columns are exactly "A"/"B", two single-column FKs
+ * cover them, and a unique index spans (A, B). Purely structural — never
+ * reads relation types (round-trip stability, LEARNINGS).
+ */
+export declare function detectJoinTable(params: {
+    table: string;
+    columnNames: readonly string[];
+    fkGroups: readonly FkGroup[];
+    indexes: readonly IntrospectedIndex[];
+}): JoinTableInfo | null;
+/** Add manyToOne + inverse oneToMany relation pairs for every FK group. */
+export declare function addFkRelations(params: {
+    models: ModelIR[];
+    fkGroups: readonly FkGroup[];
+    joinTables: ReadonlyMap<string, JoinTableInfo>;
+}): void;
+/** Add the two unnamed oneToMany list sides for every detected join table. */
+export declare function addJoinTableRelations(params: {
+    models: ModelIR[];
+    joinTables: ReadonlyMap<string, JoinTableInfo>;
+}): void;
+/** Lower-case the first character (relation field names from table names). */
+export declare function lowerFirst(value: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/introspect/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/introspect/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAc,MAAM,iBAAiB,CAAC;AAI1E,sEAAsE;AACtE,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,qEAAqE;AACrE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,kDAAkD;IAClD,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AAIF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvC,GAAG,aAAa,GAAG,IAAI,CA8BvB;AAID,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAChD,GAAG,IAAI,CA+CP;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAChD,GAAG,IAAI,CAuCP;AAmGD,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/introspect/sqlite.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SQLite introspection: live database → SchemaIR, from `sqlite_master` (table
+ * and index SQL text) plus `PRAGMA table_info / index_list / index_xinfo /
+ * foreign_key_list`.
+ *
+ * THE TEXT-TYPE AMBIGUITY, stated honestly: sqlite stores only the four
+ * storage classes we emit, so the reverse mapping is TEXT→String,
+ * INTEGER→Int, REAL→Float, BLOB→Bytes — ALWAYS. A DateTime/Decimal/Json
+ * column pulls back as String and a Boolean/BigInt as Int; there is no marker
+ * to recover the richer type. The differ compensates by comparing columns by
+ * storage class on sqlite (normalize.ts), so round-trips stay diff-clean.
+ * Two markers DO survive:
+ * - enums: our named CHECK constraints (`<table>_<column>_enum_<Enum>`)
+ *   recover both the enum's name and values;
+ * - autoincrement: the literal `PRIMARY KEY AUTOINCREMENT` text on a
+ *   single-column INTEGER PK.
+ * Any other declared type (VARCHAR(30), DATETIME, … from a foreign database)
+ * becomes an `isUnsupported` field with the raw type preserved in
+ * `nativeType` (F3: keep, don't drop).
+ *
+ * Representation mirrors introspect/postgres.ts exactly (shared.ts is the one
+ * relation/join-table rule): unnamed relation pairs, structural join-table
+ * detection, single-column uniques folded into `isUnique`, composite PKs on
+ * `model.primaryKey` (PK columns are never optional), views with columns
+ * only. Skipped: the `_vibe_migrations` table, `sqlite_*` internals
+ * (sqlite_sequence comes with AUTOINCREMENT), and expression indexes
+ * (index_xinfo reports no column name for them).
+ *
+ * Every row-returning query passes `values: []` — through `toSqlExecutor` a
+ * value-less text runs on the adapter's multi-statement batch path, which
+ * returns no rows (adapter-sqlite contract).
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live sqlite database into SchemaIR. */
+export declare function introspectSqlite(params: {
+    executor: SqlExecutor;
+}): Promise<SchemaIR>;
+/**
+ * Recover an expression index's column list from its `sqlite_master.sql`
+ * (SQLITE-2). Only shapes WE emit parse — plain quoted columns and
+ * `CAST("col" AS REAL)`, each with an optional direction; a trailing partial
+ * WHERE clause is fine (it sits OUTSIDE the column list — closure item 2).
+ * Anything else (other expressions, COLLATE clauses) returns null and the
+ * caller skips the index as before.
+ */
+export declare function parseIndexColumnsFromSql(params: {
+    sql: string | null;
+}): {
+    name: string;
+    desc: boolean;
+}[] | null;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/introspect/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/introspect/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyB/C,uDAAuD;AACvD,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuI3F;AAwGD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,IAAI,CAqD3C"}

package/dist/journal-table.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The bookkeeping table's name, alone in a leaf module.
+ *
+ * It used to live in runner.ts, which the three introspectors import while
+ * runner.ts is itself importing THEM — a cycle whose outcome depended on which
+ * module the process happened to evaluate first, and which surfaced as
+ * "Cannot access 'MIGRATIONS_TABLE_NAME' before initialization" as soon as the
+ * import order shifted. A leaf module has no such ordering: it can be
+ * evaluated before anything that needs it.
+ *
+ * runner.ts re-exports the name, so the public surface is unchanged.
+ */
+/** Name of the migrations bookkeeping table (skipped by introspection). */
+export declare const MIGRATIONS_TABLE_NAME: string;
+//# sourceMappingURL=journal-table.d.ts.map

package/dist/journal-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-table.d.ts","sourceRoot":"","sources":["../src/journal-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,EAAE,MAA2B,CAAC"}

package/dist/mysql-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * MySQL column-type mapping (IR → column type and back), native-type
+ * normalization, comparison keys and default rendering.
+ *
+ * dialect-matrix §2: String → varchar(191) by default (191 because
+ * utf8mb4 × 4 bytes keeps the column inside the 767-byte legacy index-key
+ * limit; `@db.Text` opts into TEXT, which we never index), Boolean →
+ * tinyint(1) (THE marker that lets introspection recover Boolean),
+ * Int → int, BigInt → bigint, Float → double, Decimal → decimal(65,30),
+ * DateTime → datetime(3), Json → json, Bytes → longblob, enums → inline
+ * `ENUM('A', 'B')` — nameless in the database, so comparison keys use the
+ * VALUE LIST (like sqlite) and a pulled schema synthesizes
+ * `<Table>_<column>` enum names. Scalar lists are unsupported.
+ */
+import type { EnumIR, FieldIR, ScalarType } from "@vibeorm/schema";
+/** IR scalar → canonical mysql column type (information_schema spelling). */
+export declare const SCALAR_TO_MYSQL: Readonly<Record<ScalarType, string>>;
+/** Render-time backstop for scalar-list columns (the differ refuses earlier). */
+export declare function refuseMysqlScalarList(params: {
+    field: FieldIR;
+}): never;
+/**
+ * Normalize a mysql type string for comparison: lowercase, whitespace
+ * stripped, base de-aliased, integer display widths dropped (mysql 8.0.19+
+ * omits them; older catalogs report `int(11)`) — EXCEPT `tinyint(1)`, which is
+ * the Boolean marker and must survive normalization.
+ */
+export declare function normalizeMysqlType(params: {
+    raw: string;
+}): string;
+/**
+ * Comparison key for a column on mysql. Enum columns key on their VALUE LIST
+ * (order-sensitive — mysql ENUM order defines sort order); a native type equal
+ * to the scalar's canonical mapping is dropped so `String` and
+ * `String @db.VarChar(191)` compare equal.
+ */
+export declare function mysqlColumnTypeKey(params: {
+    field: FieldIR;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/**
+ * Default fingerprint on mysql: postgres rules verbatim — tinyint(1) lets the
+ * introspector map `DEFAULT '1'` back to a boolean literal, so booleans keep
+ * their `bool:` fingerprint (unlike sqlite).
+ */
+export declare function mysqlDefaultFingerprint(params: {
+    field: FieldIR;
+}): string | null;
+/** Render the mysql column type for a field (no NOT NULL, no default). */
+export declare function mysqlColumnTypeSql(params: {
+    field: FieldIR;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/**
+ * Render the `DEFAULT` expression for a field on mysql, or `undefined` when
+ * the column takes none. `now()` renders `CURRENT_TIMESTAMP(3)` (precision
+ * must match the datetime(3) column); booleans store as 1/0.
+ */
+export declare function mysqlDefaultSql(params: {
+    field: FieldIR;
+}): string | undefined;
+/** Parse an information_schema `COLUMN_TYPE` of form `enum('A','B')`. */
+export declare function parseMysqlEnumColumnType(params: {
+    columnType: string;
+}): string[] | null;
+//# sourceMappingURL=mysql-types.d.ts.map

package/dist/mysql-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql-types.d.ts","sourceRoot":"","sources":["../src/mysql-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAMnE,6EAA6E;AAC7E,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAUhE,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,KAAK,CAMvE;AAaD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CASlE;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,GAAG,MAAM,CAgBT;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAEjF;AAID,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,GAAG,MAAM,CA8BT;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuB9E;AAID,yEAAyE;AACzE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,GAAG,IAAI,CAQxF"}

package/dist/normalize.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Schema-IR normalization for diffing.
+ *
+ * Both sides of a diff (a parsed/DSL schema and an introspected one) collapse
+ * into the same normalized shape, so representation differences never produce
+ * phantom steps. The normalizations, each pinned by a differ test:
+ *
+ * - `@unique` on a field and a `kind: "unique"` model index are the same
+ *   unique index (the database stores both identically).
+ * - A single `@id` field and a single-field `@@id` are the same primary key.
+ * - Field names resolve to db names (`@map` / `@@map`) everywhere.
+ * - FK cascade actions resolve Prisma's defaults (required → Restrict,
+ *   optional → SetNull, onUpdate → Cascade) before comparing.
+ * - App-level defaults (uuid/cuid/nanoid/ulid) compare as "no database
+ *   default"; `isUpdatedAt` is app-level and ignored entirely.
+ * - Implicit M2M pairs collapse to their join table regardless of whether the
+ *   sides are parser `manyToMany` fields or introspected unnamed `oneToMany`
+ *   list sides (structural detection, LEARNINGS).
+ * - Views never join the table diff (migrate does not manage view DDL in this
+ *   wave) but ARE collected by db name, so the differ can emit DROP VIEW for
+ *   views the target schema no longer declares (board #26).
+ */
+import type { CascadeAction, Dialect, EnumIR, FieldIR, ModelIR, SchemaIR } from "@vibeorm/schema";
+import type { IndexColumn, JoinTableEnd } from "./types.ts";
+/** A column ready for comparison. */
+export type NormalizedColumn = {
+    /** Column db name. */
+    readonly name: string;
+    readonly field: FieldIR;
+    readonly typeKey: string;
+    readonly nullable: boolean;
+    readonly defaultKey: string | null;
+};
+/** An index (unique or not) ready for comparison. `key` ignores the name. */
+export type NormalizedIndex = {
+    readonly key: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly unique: boolean;
+    readonly columns: readonly IndexColumn[];
+    readonly where?: string;
+    /** `UNIQUE NULLS NOT DISTINCT` (postgres 15+). */
+    readonly nullsNotDistinct?: boolean;
+};
+/** A foreign key ready for comparison. `key` excludes the cascade actions. */
+export type NormalizedFk = {
+    readonly key: string;
+    readonly constraintName: string;
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete: CascadeAction;
+    readonly onUpdate: CascadeAction;
+};
+/** A model collapsed to its database shape. */
+export type NormalizedTable = {
+    readonly model: ModelIR;
+    /** Table db name. */
+    readonly table: string;
+    readonly columns: ReadonlyMap<string, NormalizedColumn>;
+    /** Primary-key column db names (empty = none). */
+    readonly pk: readonly string[];
+    readonly indexes: ReadonlyMap<string, NormalizedIndex>;
+    readonly fks: ReadonlyMap<string, NormalizedFk>;
+    /**
+     * CHECK constraints, name → raw expression. NAME-keyed in the diff —
+     * engines re-serialize expressions on introspection, so text is never
+     * compared (an expression change = rename the check).
+     */
+    readonly checks: ReadonlyMap<string, string>;
+};
+/** An implicit M2M join table collapsed to its database shape. */
+export type NormalizedJoinTable = {
+    readonly table: string;
+    readonly a: JoinTableEnd;
+    readonly b: JoinTableEnd;
+};
+/** A whole schema, ready for diffing. */
+export type NormalizedSchema = {
+    readonly tables: ReadonlyMap<string, NormalizedTable>;
+    readonly joinTables: ReadonlyMap<string, NormalizedJoinTable>;
+    /** Enums keyed by db name. */
+    readonly enums: ReadonlyMap<string, EnumIR>;
+    /** View models keyed by db name — present for drop detection only (#26). */
+    readonly views: ReadonlyMap<string, ModelIR>;
+};
+/**
+ * Collapse a SchemaIR into its comparable database shape. `dialect` (default
+ * postgres) selects the column comparison keys: on sqlite columns compare by
+ * STORAGE CLASS (TEXT/INTEGER/REAL/BLOB — the TEXT-ambiguity rule), on mysql
+ * by mysql column type; enum columns on both compare by VALUE LIST, never by
+ * name (the database does not store one).
+ */
+export declare function normalizeSchema(params: {
+    schema: SchemaIR;
+    dialect?: Dialect;
+}): NormalizedSchema;
+/** Refuse string storage that cannot preserve every enum label verbatim. */
+export declare function assertStringEnumLabelsFit(params: {
+    field: FieldIR;
+    values: readonly string[];
+    dialect: Dialect;
+    table: string;
+}): void;
+/** Dialect-routed column type comparison key. */
+export declare function columnTypeKeyFor(params: {
+    field: FieldIR;
+    dialect: Dialect;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/** Dialect-routed default fingerprint. */
+export declare function defaultFingerprintFor(params: {
+    field: FieldIR;
+    dialect: Dialect;
+}): string | null;
+/**
+ * Comparison key for a partial-index predicate.
+ *
+ * The engines re-serialize these expressions on introspection (postgres adds
+ * parentheses around every operand, quotes identifiers and appends `::type`
+ * casts), so the key must absorb THAT and nothing else. Erasing quotes,
+ * parentheses and case wholesale (what this did before, F29) made
+ * `'ACTIVE'` equal to `'active'` and `(a OR b) AND c` equal to
+ * `a OR (b AND c)` — two different indexes comparing equal is a migration
+ * step that never gets generated.
+ *
+ * So: string literals keep their bytes; identifiers and keywords fold to lower
+ * case and lose their quoting; `::type` casts and REDUNDANT parentheses are
+ * dropped by parsing the boolean structure and re-emitting it with the minimum
+ * parenthesization, which keeps genuine grouping differences visible.
+ *
+ * A predicate this parser cannot read falls back to its token sequence — never
+ * to the old lossy key.
+ */
+export declare function normalizeWhere(params: {
+    where: string | undefined;
+}): string;
+/** Resolve a field name to its db column name on a model. */
+export declare function fieldDbName(params: {
+    model: ModelIR;
+    name: string;
+}): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/normalize.d.ts.map

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

package/dist/postgres-types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Postgres column-type mapping (IR → pg text and back), native-type
+ * normalization, default-value fingerprints/rendering, and cascade-action
+ * resolution.
+ *
+ * The forward mapping implements dialect-matrix §2; the fingerprint helpers are
+ * the differ's normalization layer — both the differ and the introspector lean
+ * on them so `diff(introspect(push(X)), X) = []` holds by construction.
+ */
+import type { CascadeAction, FieldIR, ScalarType } from "@vibeorm/schema";
+/** IR scalar → canonical postgres column type. */
+export declare const SCALAR_TO_PG: Readonly<Record<ScalarType, string>>;
+/**
+ * Normalize a native type string for comparison: lowercase, whitespace
+ * stripped, base name de-aliased. `"VarChar(191)"` and `"character varying(191)"`
+ * both become `"varchar(191)"`.
+ */
+export declare function normalizeNativeType(params: {
+    raw: string;
+}): string;
+/**
+ * Comparison key for a column's type. Two columns with equal keys need no
+ * ALTER. A native type equal to the scalar's canonical mapping is dropped, so
+ * `DateTime` and `DateTime @db.Timestamptz` compare equal — and so do the
+ * mapping's `CANONICAL_EQUIVALENTS` (`@db.Timestamptz(6)`, the same type
+ * spelled explicitly, and `@db.Timestamptz(3)`, what the 2.0 alphas created).
+ * Any other precision stays distinct and still diffs.
+ */
+export declare function columnTypeKey(params: {
+    field: FieldIR;
+}): string;
+/**
+ * True when a type change from `from` to `to` is the safe scalar→array repair
+ * (same base type, scalar becomes a one-element array via a `USING` clause —
+ * the LEARNINGS enum-array lesson). Every other type change is treated as
+ * potentially narrowing, i.e. destructive.
+ */
+export declare function isScalarToArrayChange(params: {
+    from: FieldIR;
+    to: FieldIR;
+}): boolean;
+/** Render the postgres column type for a field (no identity, no default). */
+export declare function columnTypeSql(params: {
+    field: FieldIR;
+}): string;
+/** True when the field renders as an identity column (autoincrement Int/BigInt). */
+export declare function isIdentityColumn(params: {
+    field: FieldIR;
+}): boolean;
+/**
+ * Normalized fingerprint of a column default for diffing, or `null` when the
+ * database carries no default. App-level id generators (uuid / cuid / nanoid /
+ * ulid) fingerprint as `null`: the runtime injects them client-side, so the
+ * database honestly has no default — this is what keeps introspection
+ * round-trips stable for `@default(uuid())` columns.
+ */
+export declare function defaultFingerprint(params: {
+    field: FieldIR;
+}): string | null;
+/**
+ * Render the `DEFAULT` expression for a field, or `undefined` when the column
+ * takes no database default (no default declared, app-level generators,
+ * autoincrement — which renders as identity instead).
+ */
+export declare function defaultSql(params: {
+    field: FieldIR;
+}): string | undefined;
+/** True for scalars whose defaults postgres reports back as numeric literals. */
+export declare function isNumericScalar(params: {
+    type: ScalarType;
+}): boolean;
+/**
+ * `pg_constraint.confdeltype` / `confupdtype` single-char codes → IR actions
+ * (used by the introspector).
+ */
+export declare const PG_CHAR_TO_CASCADE_ACTION: Readonly<Record<string, CascadeAction>>;
+/** CascadeAction → SQL clause body. */
+export declare const CASCADE_ACTION_SQL: Readonly<Record<CascadeAction, string>>;
+/**
+ * Effective onDelete with Prisma's postgres defaults applied (LEARNINGS):
+ * required FK → Restrict, optional FK → SetNull.
+ */
+export declare function resolveOnDelete(params: {
+    explicit: CascadeAction | undefined;
+    required: boolean;
+}): CascadeAction;
+/** Effective onUpdate — Prisma's postgres default is Cascade. */
+export declare function resolveOnUpdate(params: {
+    explicit: CascadeAction | undefined;
+}): CascadeAction;
+/** Quote a postgres string literal (single quotes, doubled embedded quotes). */
+export declare function quotePgString(params: {
+    value: string;
+}): string;
+//# sourceMappingURL=postgres-types.d.ts.map

package/dist/postgres-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-types.d.ts","sourceRoot":"","sources":["../src/postgres-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAK1E,kDAAkD;AAClD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAU7D,CAAC;AA+CF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAmBhE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAMrF;AAID,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAsBhE;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAQpE;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAsC5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuBzE;AAKD,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,OAAO,CAGrE;AAID;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAM7E,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAMtE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,aAAa,CAGhB;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,GAAG,aAAa,CAE9F;AAID,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE/D"}

package/dist/push.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `db push` / `db pull` at library level (the CLI wires these).
+ *
+ * push = introspect → diff → render → apply, routed per dialect
+ * (`providerToDialect(schema.datasource.provider)`):
+ *
+ * - postgres/pglite: all statements in ONE transaction (transactional DDL).
+ * - sqlite: transactional too, UNLESS the script contains a table-rebuild
+ *   block — those manage their own `PRAGMA foreign_keys` + BEGIN/COMMIT
+ *   sequence (ddl/sqlite.ts) and run unwrapped; `PRAGMA foreign_key_check`
+ *   violations become VIBE_MIGRATION errors (execute.ts).
+ * - mysql: DDL auto-commits — statements run sequentially, no wrap.
+ *
+ * Destructive steps are REFUSED unless `acceptDataLoss` is set — the error
+ * lists every destructive step, loudly (dialect honesty: never silently drop
+ * data).
+ */
+import type { Dialect, SchemaIR, VibeExtension } from "@vibeorm/schema";
+import type { PushResult, SqlExecutor } from "./types.ts";
+/**
+ * Make the live database match `schema`. Returns the steps that were applied
+ * and the SQL executed (both empty when the database already matched — pushing
+ * twice is a no-op by the differ's round-trip property).
+ *
+ * @throws VibeError VIBE_SCHEMA_INVALID when the target schema fails validation.
+ * @throws VibeError VIBE_UNSUPPORTED_CAPABILITY for dialect-impossible constructs
+ *   (scalar lists on sqlite/mysql, partial indexes on mysql, enum-value removal).
+ * @throws VibeError VIBE_MIGRATION when destructive steps exist and `acceptDataLoss` is not set.
+ */
+export declare function push(params: {
+    executor: SqlExecutor;
+    schema: SchemaIR;
+    acceptDataLoss?: boolean;
+    /** Separate authorization for removing or potentially widening native policies. */
+    acceptSecurityChanges?: boolean;
+    /** Deployed declaration when changing a policy or its referenced columns. */
+    previousSchema?: SchemaIR;
+    /** Return planned SQL and security changes without applying or requiring acknowledgements. */
+    dryRun?: boolean;
+    /** Configured extension instances — their artifacts apply with the diff. */
+    extensions?: readonly VibeExtension[];
+}): Promise<PushResult>;
+/**
+ * Introspect the live database into SchemaIR (the CLI's `db pull`).
+ * `dialect` selects the introspector — postgres if omitted (back-compat).
+ */
+export declare function pull(params: {
+    executor: SqlExecutor;
+    dialect?: Dialect;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=push.d.ts.map

package/dist/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAqB,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAuB3F,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,EAAE,QAAQ,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,6EAA6E;IAC7E,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,8FAA8F;IAC9F,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACvC,GAAG,OAAO,CAAC,UAAU,CAAC,CAmBtB;AAiJD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAGpB"}