@vibeorm/migrate 2.0.0-alpha.1 → 2.0.0-alpha.10

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

@@ -1 +1 @@
-{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../src/introspect/mysql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EASV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA0G/C,uEAAuE;AACvE,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CA0K1F"}
+{"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

@@ -1,25 +1,12 @@
-/**
- * Postgres / PGlite introspection: live database → SchemaIR.
- *
- * Representation contract (the differ's round-trip depends on it, LEARNINGS):
- *
- * - Type mapping is the REVERSE of dialect-matrix §2; `nativeType` is set only
- *   when the column's type is NOT the canonical mapping for its scalar.
- * - Identity columns and `nextval(...)` defaults → `@default(autoincrement())`.
- * - Enum ARRAY columns (`data_type = 'ARRAY'`, `udt_name = '_EnumName'`) are
- *   enum lists — never `String[]`.
- * - Unknown column types (tsvector, geometry, …) become `isUnsupported` fields
- *   with the raw type in `nativeType` — kept, not dropped.
- * - FK/join-table representation comes from introspect/shared.ts — the ONE
- *   structural rule every dialect introspector uses.
- * - Views (`isView: true`) are returned with their columns only.
- * - The `_vibe_migrations` bookkeeping table is skipped.
- * - Hardcoded to the `public` schema (v1 parity).
- */
 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

@@ -1 +1 @@
-{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/introspect/postgres.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA4J/C,gFAAgF;AAChF,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwK7F"}
+{"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

@@ -5,7 +5,12 @@
  * 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.
+ *   `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,
@@ -36,6 +41,8 @@ export type IntrospectedIndex = {
         readonly desc: boolean;
     }[];
     readonly where?: string;
+    /** `UNIQUE NULLS NOT DISTINCT` (postgres 15+). */
+    readonly nullsNotDistinct?: boolean;
 };
 /** A detected physical join table. */
 export type JoinTableInfo = {

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

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/introspect/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;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;CACzB,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,CAsCP;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;AAwDD,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD"}
+{"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.map

@@ -1 +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,CAwH3F;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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"mysql-types.d.ts","sourceRoot":"","sources":["../src/mysql-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,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"}
+{"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

@@ -39,6 +39,8 @@ export type NormalizedIndex = {
     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 = {
@@ -60,6 +62,12 @@ export type NormalizedTable = {
     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 = {
@@ -87,6 +95,13 @@ 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;
@@ -99,10 +114,23 @@ export declare function defaultFingerprintFor(params: {
     dialect: Dialect;
 }): string | null;
 /**
- * Partial-index predicates are compared loosely: postgres re-serializes the
- * expression (extra parentheses, quoted identifiers), so the comparison key
- * strips quoting, parentheses, whitespace and case. `::type` casts postgres
- * adds during normalization (e.g. `'x'::text`) are stripped too.
+ * 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;

package/dist/normalize.d.ts.map

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

package/dist/postgres-types.d.ts

@@ -21,7 +21,10 @@ export declare function normalizeNativeType(params: {
 /**
  * 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(3)` compare equal.
+ * `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;
@@ -62,6 +65,10 @@ export declare function defaultFingerprint(params: {
 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).

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

@@ -1 +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+BF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAgBhE;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,CA2B5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuBzE;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"}
+{"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

@@ -31,6 +31,12 @@ 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>;

package/dist/push.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAoBxE,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,4EAA4E;IAC5E,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACvC,GAAG,OAAO,CAAC,UAAU,CAAC,CA8EtB;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAEpB"}
+{"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"}

package/dist/recovery.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Establishing what actually happened, before a nontransactional migration
+ * re-runs anything.
+ *
+ * A migration that runs outside a transaction can die between a statement
+ * committing and the journal recording it. The only honest recovery is to ask
+ * the database what the world looks like now and compare it against the
+ * statement's DECLARED postcondition (execution.ts). Three answers exist:
+ *
+ * - `"satisfied"` — the live catalog already matches the declaration. Skip it.
+ * - `"runnable"` — the declaration is demonstrably not in effect, and running
+ *   the statement is the way to get there.
+ * - a thrown `VibeError` — the state is neither, and no automatic action is
+ *   safe. Nothing is dropped, nothing is re-run: the operator decides.
+ *
+ * There is deliberately NO fourth answer of the form "probably fine, re-run
+ * it". This module never claims exactly-once execution of arbitrary SQL; it
+ * only decides the cases a declared postcondition can actually settle.
+ *
+ * Comparison is conservative by design. Expressions must match verbatim apart
+ * from surrounding whitespace. Quotes and whitespace inside literals can change
+ * meaning; any difference is a CONFLICT — a false conflict costs an operator one
+ * look, a false match corrupts a schema.
+ */
+import type { Dialect } from "@vibeorm/schema";
+import type { MigrationOperation } from "./execution.ts";
+import type { SqlExecutor } from "./types.ts";
+/** Whether a declared operation's postcondition already holds. */
+export type OperationState = "satisfied" | "runnable";
+/**
+ * Ask the database whether a declared operation is already in effect.
+ *
+ * PostgreSQL only: it is the one dialect with a nontransactional migration
+ * regime here, and every probe reads its catalogs.
+ */
+export declare function establishOperationState(params: {
+    executor: SqlExecutor;
+    dialect: Dialect;
+    operation: MigrationOperation;
+}): Promise<OperationState>;
+//# sourceMappingURL=recovery.d.ts.map

package/dist/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAS/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,kEAAkE;AAClE,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,UAAU,CAAC;AA6BtD;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,kBAAkB,CAAC;CAC/B,GAAG,OAAO,CAAC,cAAc,CAAC,CAkG1B"}

package/dist/relations.d.ts

@@ -1,14 +1,24 @@
 /**
  * Implicit many-to-many detection on Schema IR.
  *
- * ONE structural rule, kept in lock-step with the parser's
- * `findImplicitM2MCounterpart` (see LEARNINGS): two relation fields form an
+ * ONE structural rule in @vibeorm/schema, also used by RLS validation and
+ * matching the parser's ambiguity rule (see LEARNINGS): two fields form an
  * implicit M:N **iff** both are lists that declare no FK columns, they are
  * distinct fields (self-exclusion — a 1:N self-relation must never pair with
- * itself), and their relation names match symmetrically (both unnamed, or both
- * the same name). Detection never reads `relation.type`, because an
- * introspected schema represents a real join table as two unnamed `oneToMany`
- * list sides — trusting the type would break round-trip stability.
+ * itself), their relation names match symmetrically (both unnamed, or both
+ * the same name), and each side is the OTHER'S SOLE counterpart under that
+ * name key. Detection never reads `relation.type`, because an introspected
+ * schema represents a real join table as two unnamed `oneToMany` list sides —
+ * trusting the type would break round-trip stability.
+ *
+ * The sole-counterpart requirement is the phantom-join-table fix, round two:
+ * two models holding foreign keys INTO EACH OTHER introspect as an unnamed
+ * fieldless list on each side (every FK synthesizes one on its target), and
+ * name-matching alone would marry those lists into a join table that exists
+ * nowhere. Counting EVERY relation under the name key — FK-owning sides
+ * included — disambiguates: the parser rejects the same shape as
+ * `ambiguous-relation` at parse time, so parsed and introspected schemas
+ * resolve identically.
  *
  * The join-table naming itself comes from the ONE shared convention in
  * `@vibeorm/schema` (`implicitJoinTable`) — never re-derived here.

package/dist/relations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAuB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAErE,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GAAG,eAAe,EAAE,CA2CtF"}
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GAAG,eAAe,EAAE,CA4BtF"}

package/dist/renames.d.ts

@@ -0,0 +1,58 @@
+/**
+ * EXPLICIT physical renames.
+ *
+ * The differ deliberately has no rename detection: two schemas that differ by
+ * a name are indistinguishable from a drop plus a create, and guessing between
+ * them from "similar shapes" is how a migration tool silently destroys a
+ * column. A rename therefore only ever happens because someone WROTE one down,
+ * as an old physical name and a new physical name, and it is validated against
+ * both schemas before a single statement is rendered.
+ *
+ * `@map` / `@@map` remains the no-DDL option: mapping a model or field to the
+ * name the database already uses changes generated code only. Use a rename
+ * intent when the DATABASE object must actually move.
+ *
+ * What a physical rename preserves, on every dialect that supports it: the
+ * rows, the column defaults, the indexes and constraints attached to the
+ * object, and inbound foreign keys — the object keeps its identity, only its
+ * name changes. PostgreSQL policy expressions follow the rename too, because
+ * they are stored parsed and reference the object by identity, not by text.
+ *
+ * What refuses instead of guessing: renaming a table and one of its columns in
+ * the same plan (the second intent's table name is then ambiguous), an intent
+ * whose endpoints do not both check out against the two schemas, and two
+ * intents pointing at the same object.
+ */
+import type { Dialect, SchemaIR } from "@vibeorm/schema";
+import type { MigrationStep } from "./types.ts";
+/** One deliberately written rename, in PHYSICAL (database) names. */
+export type RenameIntent = {
+    readonly kind: "table";
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly kind: "column";
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+};
+/**
+ * Validate rename intents against the two schemas and turn them into steps,
+ * returning the SOURCE schema rewritten as if the renames had happened.
+ *
+ * The rewrite is what keeps the rest of the diff honest: once the source model
+ * carries the new physical name, the ordinary differ sees one table on both
+ * sides and emits no drop/create pair for it. Only `dbName` moves — the
+ * logical IR graph (relations, index field lists) is untouched, so nothing
+ * downstream has to know a rename happened.
+ */
+export declare function planRenames(params: {
+    from: SchemaIR;
+    to: SchemaIR;
+    renames: readonly RenameIntent[];
+    dialect: Dialect;
+}): {
+    readonly steps: readonly MigrationStep[];
+    readonly from: SchemaIR;
+};
+//# sourceMappingURL=renames.d.ts.map

package/dist/renames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renames.d.ts","sourceRoot":"","sources":["../src/renames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAW,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,qEAAqE;AACrE,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACtE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAuBpG;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE;IAClC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IACjC,OAAO,EAAE,OAAO,CAAC;CAClB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAkGxE"}

package/dist/runner.d.ts

@@ -2,21 +2,40 @@
  * Migration runner: generate named migrations from IR diffs, apply them with
  * bookkeeping in `_vibe_migrations`, report status, and repair records.
  *
- * Concurrency: `applyMigrations` takes an advisory lock for the whole run —
- * `pg_advisory_lock(1447645253)` on postgres ("VIBE" in ASCII, blocking,
- * released in a finally), `GET_LOCK('vibeorm_migrate', 60)` on mysql (throws
- * VIBE_MIGRATION on timeout). sqlite needs none: it is single-writer and
- * `BEGIN` serializes. Locks are session-scoped — the SqlExecutor contract
- * (types.ts) requires one session for the whole operation.
+ * Concurrency: `applyMigrations` and `rollbackMigration` take an advisory lock
+ * for the whole run — `pg_advisory_lock(1447645253)` on postgres ("VIBE" in
+ * ASCII, blocking, released in a finally), `GET_LOCK('vibeorm_migrate', 60)`
+ * on mysql (throws VIBE_MIGRATION on timeout). sqlite needs none: it is
+ * single-writer and `BEGIN` serializes. Locks are session-scoped — the
+ * SqlExecutor contract (types.ts) requires one session for the whole
+ * operation.
  *
- * Execution strategy per dialect (`DIALECT_CAPABILITIES[dialect]`):
+ * Lock ORDER matters: the lock is taken BEFORE `ensureMigrationsTable`, never
+ * after. Two concurrent first-time runs against a fresh postgres database
+ * would otherwise both issue `CREATE TABLE IF NOT EXISTS _vibe_migrations`,
+ * which is a catalog race on postgres (a duplicate-key error on
+ * `pg_type_typname_nsp_index`, not a no-op). `migrationStatus` and
+ * `resolveMigration` deliberately take NO lock — wrapping reads in the
+ * migration lock would make `status` block behind a running migrate — so two
+ * concurrent FIRST-EVER `status`/`resolve` calls on a fresh database can still
+ * hit that race; retrying either is enough, since the table then exists.
+ *
+ * Execution strategy per dialect (`DIALECT_CAPABILITIES[dialect]`) AND per
+ * script:
  *
  * - transactionalDdl (postgres, sqlite): each migration runs inside
- *   BEGIN/COMMIT with its bookkeeping INSERT — atomic. EXCEPT sqlite scripts
- *   containing a table-rebuild block, which manage their own transactions
- *   (execute.ts `usesSelfManagedTransactions`); those run unwrapped and are
- *   re-runnable (the rebuild recipe is effectively idempotent), with the
- *   record written after the script completes.
+ *   BEGIN/COMMIT with its bookkeeping INSERT — atomic.
+ * - EXCEPT sqlite scripts containing a table-rebuild block, which manage their
+ *   own transactions (execute.ts `usesSelfManagedTransactions`) and therefore
+ *   cannot be wrapped. Those take the SAME per-statement bookkeeping as mysql
+ *   (below). They are NOT simply "re-runnable": a pure rebuild block is
+ *   effectively idempotent, but any plain statement in the same script
+ *   auto-commits on its own, so without a recorded statement_index a crash
+ *   wedged the migration forever (every later run replayed statements that had
+ *   already run). Resuming into a rebuild block rewinds to that block's
+ *   `PRAGMA foreign_keys=OFF` (execute.ts `selfManagedResumeStart`): the block
+ *   is transactional, so nothing of it survived, and the pragma is
+ *   session-scoped and gone after a crash.
  * - mysql (transactionalDdl: false — DDL auto-commits): the runner records
  *   PER-STATEMENT progress instead. The row is inserted up front
  *   (statement_index 0), advanced after every statement, and on failure the
@@ -26,22 +45,36 @@
  *   reaches the statement count (or its checksum is empty — resolveMigration
  *   records, which store statement_index 2147483647).
  *
+ * `usesStatementBookkeeping` is the ONE predicate deciding which of the two
+ * regimes a (dialect, script) pair is in; apply, status and rollback all read
+ * it, so they can never disagree about whether a record is complete.
+ *
  * Checksums (sha256 over the joined SQL) pin a migration's content:
  * re-applying a renamed-or-edited migration is a VIBE_MIGRATION error, never
  * a silent divergence.
  */
 import type { Dialect, SchemaIR, VibeExtension } from "@vibeorm/schema";
-import type { AppliedResult, MigrationFile, MigrationStatus, SqlExecutor } from "./types.ts";
-/** Name of the migrations bookkeeping table (skipped by introspection). */
-export declare const MIGRATIONS_TABLE_NAME: string;
+import type { MigrationExecution } from "./execution.ts";
+import type { RenameIntent } from "./renames.ts";
+import type { AppliedResult, MigrationFile, MigrationStatus, RecordedMigration, SqlExecutor } from "./types.ts";
+export { MIGRATIONS_TABLE_NAME } from "./journal-table.ts";
 /** Create the bookkeeping table when missing. */
 export declare function ensureMigrationsTable(params: {
     executor: SqlExecutor;
     dialect?: Dialect;
 }): Promise<void>;
-/** sha256 hex over the migration's statements — its identity across runs. */
+/**
+ * sha256 hex over the migration's statements — its identity across runs.
+ *
+ * A NON-default execution block (execution.ts) folds a canonical description
+ * of itself in, so changing how a migration executes after it was applied is
+ * caught by the same checksum refusal that catches changing its SQL. A default
+ * or absent block contributes NOTHING, which is what keeps every migration
+ * written before this feature — and every journal row recording one — valid.
+ */
 export declare function migrationChecksum(params: {
     sql: readonly string[];
+    execution?: MigrationExecution;
 }): string;
 /**
  * Diff two IRs and render a named migration for a dialect (postgres if
@@ -56,18 +89,24 @@ export declare function generateMigration(params: {
     dialect?: Dialect;
     /** Configured extension instances — their artifacts land in the migration. */
     extensions?: readonly VibeExtension[];
+    /** Explicit physical renames (renames.ts); never inferred from the diff. */
+    renames?: readonly RenameIntent[];
+    /** Explicit execution semantics for the generated file. */
+    execution?: MigrationExecution;
 }): MigrationFile;
 /**
  * Apply migrations in order under an advisory lock (see module doc).
  * Already-recorded migrations are checksum-verified and skipped; a mismatch
  * throws VIBE_MIGRATION (a recorded migration whose SQL changed is
- * corruption, not drift to paper over). On mysql, a partially-applied
+ * corruption, not drift to paper over). Where progress is recorded per
+ * statement (mysql, and self-managed sqlite scripts), a partially-applied
  * migration RESUMES from its recorded statement_index. Records created by
  * `resolveMigration` (empty checksum) skip verification.
  */
 export declare function applyMigrations(params: {
     executor: SqlExecutor;
     migrations: readonly MigrationFile[];
+    acceptSecurityChanges?: boolean;
     /** Execution dialect; postgres if omitted. */
     dialect?: Dialect;
 }): Promise<AppliedResult>;
@@ -77,7 +116,26 @@ export declare function migrationStatus(params: {
     migrations: readonly MigrationFile[];
     /** Bookkeeping dialect; postgres if omitted. */
     dialect?: Dialect;
+    /** Trusted current deployment; policy state is verified independently of migration records. */
+    schema?: SchemaIR;
 }): Promise<MigrationStatus>;
+/**
+ * The bookkeeping journal itself, in the order rows were written — i.e. the
+ * order migrations were actually applied, which is what a rollback must walk
+ * backwards. Every row is returned and classified, including the ones
+ * `migrationStatus` folds away: a mismatched record, a partially applied one
+ * and a record whose file is gone all still occupy a position in history, and
+ * a caller that skips them rolls back the WRONG migration (F28).
+ *
+ * Takes no lock, exactly like `migrationStatus`.
+ */
+export declare function recordedMigrations(params: {
+    executor: SqlExecutor;
+    /** Known migration files — classification needs their SQL. */
+    migrations: readonly MigrationFile[];
+    /** Bookkeeping dialect; postgres if omitted. */
+    dialect?: Dialect;
+}): Promise<RecordedMigration[]>;
 /**
  * Repair the bookkeeping table without running SQL: mark a migration as
  * `"applied"` (upsert its record; pass `checksum` to also pin its content —
@@ -101,19 +159,22 @@ export declare function resolveMigration(params: {
  * the record pins a checksum — its up SQL must still match (rolling back with
  * drifted files would run a down that no longer mirrors what was applied).
  *
- * Dialect behavior mirrors apply: postgres/sqlite run the down inside
- * BEGIN/COMMIT with the bookkeeping DELETE (atomic; sqlite rebuild scripts
- * run unwrapped, see module doc). mysql DDL auto-commits, so progress is
- * recorded per-statement in the existing `statement_index` column, NEGATIVE
- * to mark the rollback direction: after k down statements, the row stores
- * -(k+1). A failed mysql rollback resumes from the recorded statement on the
- * next call; `applyMigrations` refuses a mid-rollback record. A partially
- * APPLIED mysql migration cannot be rolled back — its down mirrors the full
- * up; finish applying (apply resumes) or repair with `resolveMigration`.
+ * Dialect behavior mirrors apply exactly (same `usesStatementBookkeeping`
+ * predicate, read over the DOWN script): postgres/sqlite run the down inside
+ * BEGIN/COMMIT with the bookkeeping DELETE (atomic). mysql DDL auto-commits,
+ * and a sqlite down containing a table-rebuild block cannot be wrapped, so
+ * both record progress per-statement in the existing `statement_index`
+ * column, NEGATIVE to mark the rollback direction: after k down statements,
+ * the row stores -(k+1). A failed rollback resumes from the recorded
+ * statement on the next call; `applyMigrations` refuses a mid-rollback record
+ * (that check reads the sign only, so it holds for every dialect). A
+ * partially APPLIED migration cannot be rolled back — its down mirrors the
+ * full up; finish applying (apply resumes) or repair with `resolveMigration`.
  */
 export declare function rollbackMigration(params: {
     executor: SqlExecutor;
     migration: MigrationFile;
+    acceptSecurityChanges?: boolean;
     /** Execution dialect; postgres if omitted. */
     dialect?: Dialect;
 }): Promise<void>;