drizzle-kit 0.16.8 → 0.16.9

package/index.js

@@ -6232,29 +6232,30 @@ Is ${source_default.bold.blue(
         this.requestLayout();
       }
       render() {
-        let info3 = "";
+        let info2 = "";
         const spin = this.spinner.value();
-        info3 += this.statusText(spin, this.state.tables);
-        info3 += this.statusText(spin, this.state.columns);
-        info3 += this.statusText(spin, this.state.enums);
-        info3 += this.statusText(spin, this.state.indexes);
-        info3 += this.statusText(spin, this.state.fks);
-        return info3;
+        info2 += this.statusText(spin, this.state.tables);
+        info2 += this.statusText(spin, this.state.columns);
+        info2 += this.statusText(spin, this.state.enums);
+        info2 += this.statusText(spin, this.state.indexes);
+        info2 += this.statusText(spin, this.state.fks);
+        return info2;
       }
     };
   }
 });
 
 // src/global.ts
-var originUUID;
+var originUUID, snapshotVersion;
 var init_global = __esm({
   "src/global.ts"() {
     originUUID = "00000000-0000-0000-0000-000000000000";
+    snapshotVersion = "5";
   }
 });
 
 // src/serializer/mysqlSchema.ts
-var index, fk, column, tableV3, table, dialect, schemaHash, schemaInternalV3, schemaInternal, schemaV3, schema2, tableSquashed, schemaSquashed, MySqlSquasher, squashMysqlScheme, mysqlSchema, mysqlSchemaV3, backwardCompatibleMysqlSchema, dryMySql;
+var index, fk, column, tableV3, table, dialect, schemaHash, schemaInternalV3, schemaInternalV4, schemaInternal, schemaV3, schemaV4, schema2, tableSquashed, schemaSquashed, MySqlSquasher, squashMysqlScheme, mysqlSchema, mysqlSchemaV3, backwardCompatibleMysqlSchema, dryMySql;
 var init_mysqlSchema = __esm({
   "src/serializer/mysqlSchema.ts"() {
     init_global();
@@ -6298,7 +6299,7 @@ var init_mysqlSchema = __esm({
       indexes: recordType(stringType(), index),
       foreignKeys: recordType(stringType(), fk)
     }).strict();
-    dialect = enumType(["mysql"]);
+    dialect = literalType("mysql");
     schemaHash = objectType({
       id: stringType(),
       prevId: stringType()
@@ -6308,13 +6309,25 @@ var init_mysqlSchema = __esm({
       dialect,
       tables: recordType(stringType(), tableV3)
     }).strict();
-    schemaInternal = objectType({
+    schemaInternalV4 = objectType({
       version: literalType("4"),
       dialect,
       tables: recordType(stringType(), table),
       schemas: recordType(stringType(), stringType())
     }).strict();
+    schemaInternal = objectType({
+      version: literalType("5"),
+      dialect,
+      tables: recordType(stringType(), table),
+      schemas: recordType(stringType(), stringType()),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      })
+    }).strict();
     schemaV3 = schemaInternalV3.merge(schemaHash);
+    schemaV4 = schemaInternalV4.merge(schemaHash);
     schema2 = schemaInternal.merge(schemaHash);
     tableSquashed = objectType({
       name: stringType(),
@@ -6324,7 +6337,7 @@ var init_mysqlSchema = __esm({
       foreignKeys: recordType(stringType(), stringType())
     }).strict();
     schemaSquashed = objectType({
-      version: literalType("4"),
+      version: literalType("5"),
       dialect,
       tables: recordType(stringType(), tableSquashed),
       schemas: recordType(stringType(), stringType())
@@ -6403,20 +6416,25 @@ var init_mysqlSchema = __esm({
     };
     mysqlSchema = schema2;
     mysqlSchemaV3 = schemaV3;
-    backwardCompatibleMysqlSchema = unionType([schemaV3, schema2]);
+    backwardCompatibleMysqlSchema = unionType([schemaV3, schemaV4, schema2]);
     dryMySql = mysqlSchema.parse({
-      version: "4",
+      version: snapshotVersion,
       dialect: "mysql",
       id: originUUID,
       prevId: "",
       tables: {},
-      schemas: {}
+      schemas: {},
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
     });
   }
 });
 
 // src/serializer/pgSchema.ts
-var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, table2, schemaHash2, pgSchemaInternalV3, pgSchemaInternal, tableSquashed2, pgSchemaSquashed, pgSchemaV3, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
+var indexV2, columnV2, tableV2, enumSchema, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, index2, fk2, column2, tableV32, table2, schemaHash2, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternal, tableSquashed2, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchema, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
 var init_pgSchema = __esm({
   "src/serializer/pgSchema.ts"() {
     init_global();
@@ -6519,17 +6537,29 @@ var init_pgSchema = __esm({
     });
     pgSchemaInternalV3 = objectType({
       version: literalType("3"),
-      dialect: enumType(["pg"]),
+      dialect: literalType("pg"),
       tables: recordType(stringType(), tableV32),
       enums: recordType(stringType(), enumSchema)
     }).strict();
-    pgSchemaInternal = objectType({
+    pgSchemaInternalV4 = objectType({
       version: literalType("4"),
-      dialect: enumType(["pg"]),
+      dialect: literalType("pg"),
       tables: recordType(stringType(), table2),
       enums: recordType(stringType(), enumSchema),
       schemas: recordType(stringType(), stringType())
     }).strict();
+    pgSchemaInternal = objectType({
+      version: literalType("5"),
+      dialect: literalType("pg"),
+      tables: recordType(stringType(), table2),
+      enums: recordType(stringType(), enumSchema),
+      schemas: recordType(stringType(), stringType()),
+      _meta: objectType({
+        schemas: recordType(stringType(), stringType()),
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      })
+    }).strict();
     tableSquashed2 = objectType({
       name: stringType(),
       schema: stringType(),
@@ -6538,18 +6568,20 @@ var init_pgSchema = __esm({
       foreignKeys: recordType(stringType(), stringType())
     }).strict();
     pgSchemaSquashed = objectType({
-      version: literalType("4"),
+      version: literalType("5"),
       dialect: enumType(["pg"]),
       tables: recordType(stringType(), tableSquashed2),
       enums: recordType(stringType(), enumSchema),
       schemas: recordType(stringType(), stringType())
     }).strict();
     pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash2);
+    pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash2);
     pgSchema = pgSchemaInternal.merge(schemaHash2);
     backwardCompatiblePgSchema = unionType([
       pgSchemaV1,
       pgSchemaV2,
       pgSchemaV3,
+      pgSchemaV4,
       pgSchema
     ]);
     PgSquasher = {
@@ -6614,7 +6646,7 @@ var init_pgSchema = __esm({
         })
       );
       return {
-        version: json.version,
+        version: "5",
         dialect: json.dialect,
         tables: mappedTables,
         enums: json.enums,
@@ -6622,19 +6654,24 @@ var init_pgSchema = __esm({
       };
     };
     dryPg = pgSchema.parse({
-      version: "4",
+      version: snapshotVersion,
       dialect: "pg",
       id: originUUID,
       prevId: "",
       tables: {},
       enums: {},
-      schemas: {}
+      schemas: {},
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
     });
   }
 });
 
 // src/serializer/sqliteSchema.ts
-var index3, fk3, compositePK, column3, tableV33, table3, dialect2, schemaHash3, schemaInternalV32, latestVersion, schemaInternal2, schemaV32, schema3, tableSquashed3, schemaSquashed2, SQLiteSquasher, squashSqliteScheme, drySQLite, sqliteSchemaV3, sqliteSchema, backwardCompatibleSqliteSchema;
+var index3, fk3, compositePK, column3, tableV33, table3, dialect2, schemaHash3, schemaInternalV32, schemaInternalV42, latestVersion, schemaInternal2, schemaV32, schemaV42, schema3, tableSquashed3, schemaSquashed2, SQLiteSquasher, squashSqliteScheme, drySQLite, sqliteSchemaV3, sqliteSchema, backwardCompatibleSqliteSchema;
 var init_sqliteSchema = __esm({
   "src/serializer/sqliteSchema.ts"() {
     init_global();
@@ -6690,14 +6727,25 @@ var init_sqliteSchema = __esm({
       tables: recordType(stringType(), tableV33),
       enums: objectType({})
     }).strict();
-    latestVersion = literalType("4");
+    schemaInternalV42 = objectType({
+      version: literalType("4"),
+      dialect: dialect2,
+      tables: recordType(stringType(), table3),
+      enums: objectType({})
+    }).strict();
+    latestVersion = literalType("5");
     schemaInternal2 = objectType({
       version: latestVersion,
       dialect: dialect2,
       tables: recordType(stringType(), table3),
-      enums: objectType({})
+      enums: objectType({}),
+      _meta: objectType({
+        tables: recordType(stringType(), stringType()),
+        columns: recordType(stringType(), stringType())
+      })
     }).strict();
     schemaV32 = schemaInternalV32.merge(schemaHash3).strict();
+    schemaV42 = schemaInternalV42.merge(schemaHash3).strict();
     schema3 = schemaInternal2.merge(schemaHash3).strict();
     tableSquashed3 = objectType({
       name: stringType(),
@@ -6792,21 +6840,25 @@ var init_sqliteSchema = __esm({
       };
     };
     drySQLite = schema3.parse({
-      version: "4",
+      version: snapshotVersion,
       dialect: "sqlite",
       id: originUUID,
       prevId: "",
       tables: {},
-      enums: {}
+      enums: {},
+      _meta: {
+        tables: {},
+        columns: {}
+      }
     });
     sqliteSchemaV3 = schemaV32;
     sqliteSchema = schema3;
-    backwardCompatibleSqliteSchema = unionType([schemaV32, schema3]);
+    backwardCompatibleSqliteSchema = unionType([schemaV32, schemaV42, schema3]);
   }
 });
 
 // src/utils.ts
-var import_fs, prepareOutFolders, mapValues, validatorForDialect, validateWithReport, prepareMigrationFolder;
+var import_fs, import_path, assertV1OutFolder, dryJournal, prepareOutFolder, mapValues, validatorForDialect, validateWithReport, prepareMigrationFolder, prepareMigrationMeta, schemaRenameKey, tableRenameKey, columnRenameKey;
 var init_utils = __esm({
   "src/utils.ts"() {
     import_fs = require("fs");
@@ -6815,16 +6867,41 @@ var init_utils = __esm({
     init_pgSchema();
     init_sqliteSchema();
     init_source();
-    prepareOutFolders = (out) => {
-      const outFolderExists = (0, import_fs.existsSync)(out);
-      if (!outFolderExists) {
-        (0, import_fs.mkdirSync)(out);
-      }
-      const migrationFolders = (0, import_fs.readdirSync)(out).filter(
+    import_path = require("path");
+    init_global();
+    assertV1OutFolder = (out, dialect6) => {
+      if (!(0, import_fs.existsSync)(out))
+        return;
+      const oldMigrationFolders = (0, import_fs.readdirSync)(out).filter(
         (it) => it.length === 14 && /^\d+$/.test(it)
       );
-      migrationFolders.sort();
-      return migrationFolders;
+      if (oldMigrationFolders.length > 0) {
+        console.log(
+          `Your migrations folder format is outdated, please run ${source_default.green.bold(
+            `drizzle-kit up:${dialect6}`
+          )}`
+        );
+        process.exit(1);
+      }
+    };
+    dryJournal = (dialect6) => {
+      return {
+        version: snapshotVersion,
+        dialect: dialect6,
+        entries: []
+      };
+    };
+    prepareOutFolder = (out, dialect6) => {
+      const meta = (0, import_path.join)(out, "meta");
+      const journalPath = (0, import_path.join)(meta, "_journal.json");
+      if (!(0, import_fs.existsSync)((0, import_path.join)(out, "meta"))) {
+        (0, import_fs.mkdirSync)(meta, { recursive: true });
+        (0, import_fs.writeFileSync)(journalPath, JSON.stringify(dryJournal(dialect6)));
+      }
+      const journal = JSON.parse((0, import_fs.readFileSync)(journalPath).toString());
+      const snapshots = (0, import_fs.readdirSync)(meta).filter((it) => !it.startsWith("_")).map((it) => (0, import_path.join)(meta, it));
+      snapshots.sort();
+      return { meta, snapshots, journal };
     };
     mapValues = (obj, map) => {
       const result = Object.keys(obj).reduce(function(result2, key) {
@@ -6836,46 +6913,43 @@ var init_utils = __esm({
     validatorForDialect = (dialect6) => {
       switch (dialect6) {
         case "pg":
-          return { validator: backwardCompatiblePgSchema, version: 4 };
+          return { validator: backwardCompatiblePgSchema, version: 5 };
         case "sqlite":
           return { validator: backwardCompatibleSqliteSchema, version: 4 };
         case "mysql":
           return { validator: backwardCompatibleMysqlSchema, version: 4 };
       }
     };
-    validateWithReport = (root, migrationFolders, dialect6) => {
+    validateWithReport = (snapshots, dialect6) => {
       const { validator, version } = validatorForDialect(dialect6);
-      const result = migrationFolders.reduce(
-        (accum, folder) => {
+      const result = snapshots.reduce(
+        (accum, it) => {
           var _a;
-          const snapshotName = `${folder}/snapshot.json`;
-          const raw = JSON.parse(
-            (0, import_fs.readFileSync)(`./${root}/${folder}/snapshot.json`).toString()
-          );
-          accum.rawMap[folder] = raw;
+          const raw = JSON.parse((0, import_fs.readFileSync)(`./${it}`).toString());
+          accum.rawMap[it] = raw;
           if (raw["version"] && Number(raw["version"]) > version) {
             console.log(
               info(
-                `${folder}/snapshot.json is of unsupported version, please update drizzle-kit`
+                `${it} snapshot is of unsupported version, please update drizzle-kit`
               )
             );
             process.exit(0);
           }
           const result2 = validator.safeParse(raw);
           if (!result2.success) {
-            accum.malformed.push(snapshotName);
+            accum.malformed.push(it);
             return accum;
           }
           const snapshot = result2.data;
           if (snapshot.version !== String(version)) {
-            accum.nonLatest.push(folder);
+            accum.nonLatest.push(it);
             return accum;
           }
           const idEntry = (_a = accum.idsMap[snapshot["prevId"]]) != null ? _a : {
-            parent: folder,
+            parent: it,
             snapshots: []
           };
-          idEntry.snapshots.push(snapshotName);
+          idEntry.snapshots.push(it);
           accum.idsMap[snapshot["prevId"]] = idEntry;
           return accum;
         },
@@ -6890,9 +6964,8 @@ var init_utils = __esm({
       return result;
     };
     prepareMigrationFolder = (outFolder = "drizzle", dialect6) => {
-      const root = outFolder;
-      const migrationFolders = prepareOutFolders(root);
-      const report = validateWithReport(root, migrationFolders, dialect6);
+      const { snapshots, journal } = prepareOutFolder(outFolder, dialect6);
+      const report = validateWithReport(snapshots, dialect6);
       if (report.nonLatest.length > 0) {
         console.log(
           report.nonLatest.map((it) => {
@@ -6923,7 +6996,41 @@ var init_utils = __esm({
       if (abort) {
         process.exit(0);
       }
-      return { migrationFolders };
+      return { snapshots, journal };
+    };
+    prepareMigrationMeta = (schemas, tables, columns) => {
+      const _meta = {
+        schemas: {},
+        tables: {},
+        columns: {}
+      };
+      schemas.forEach((it) => {
+        const from = schemaRenameKey(it.from);
+        const to = schemaRenameKey(it.to);
+        _meta.schemas[from] = to;
+      });
+      tables.forEach((it) => {
+        const from = tableRenameKey(it.from);
+        const to = tableRenameKey(it.to);
+        _meta.tables[from] = to;
+      });
+      columns.forEach((it) => {
+        const from = columnRenameKey(it.from.table, it.from.schema, it.from.column);
+        const to = columnRenameKey(it.to.table, it.to.schema, it.to.column);
+        _meta.columns[from] = to;
+      });
+      return _meta;
+    };
+    schemaRenameKey = (it) => {
+      return it;
+    };
+    tableRenameKey = (it) => {
+      const out = it.schema ? `"${it.schema}"."${it.name}"` : `"${it.name}"`;
+      return out;
+    };
+    columnRenameKey = (table4, schema4, column5) => {
+      const out = schema4 ? `"${schema4}"."${table4}"."${column5}"` : `"${table4}"."${column5}"`;
+      return out;
     };
   }
 });
@@ -7878,7 +7985,7 @@ var require_node2 = __commonJS({
         return path5;
       }
       exports2.normalize = normalize;
-      function join2(aRoot, aPath) {
+      function join22(aRoot, aPath) {
         if (aRoot === "") {
           aRoot = ".";
         }
@@ -7910,7 +8017,7 @@ var require_node2 = __commonJS({
         }
         return joined;
       }
-      exports2.join = join2;
+      exports2.join = join22;
       exports2.isAbsolute = function(aPath) {
         return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
       };
@@ -8083,7 +8190,7 @@ var require_node2 = __commonJS({
               parsed.path = parsed.path.substring(0, index4 + 1);
             }
           }
-          sourceURL = join2(urlGenerate(parsed), sourceURL);
+          sourceURL = join22(urlGenerate(parsed), sourceURL);
         }
         return normalize(sourceURL);
       }
@@ -9939,13 +10046,13 @@ var require_node2 = __commonJS({
       }
       function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
         try {
-          var info3 = gen[key](arg);
-          var value = info3.value;
+          var info2 = gen[key](arg);
+          var value = info2.value;
         } catch (error2) {
           reject(error2);
           return;
         }
-        if (info3.done) {
+        if (info2.done) {
           resolve(value);
         } else {
           Promise.resolve(value).then(_next, _throw);
@@ -9973,7 +10080,7 @@ var require_node2 = __commonJS({
           resolve(data);
         });
       });
-      var readFileSync2 = (fp) => {
+      var readFileSync3 = (fp) => {
         return _fs.default.readFileSync(fp, "utf8");
       };
       var pathExists = (fp) => new Promise((resolve) => {
@@ -10204,7 +10311,7 @@ var require_node2 = __commonJS({
                   data: this.packageJsonCache.get(filepath)[options.packageKey]
                 };
               }
-              const data = this.options.parseJSON(readFileSync2(filepath));
+              const data = this.options.parseJSON(readFileSync3(filepath));
               return {
                 path: filepath,
                 data
@@ -10212,7 +10319,7 @@ var require_node2 = __commonJS({
             }
             return {
               path: filepath,
-              data: readFileSync2(filepath)
+              data: readFileSync3(filepath)
             };
           }
           return {};
@@ -11819,34 +11926,34 @@ var require_node2 = __commonJS({
         var configAbsolutePath = walkForTsConfig(cwd);
         return configAbsolutePath ? path5.resolve(configAbsolutePath) : void 0;
       }
-      function walkForTsConfig(directory, existsSync3) {
-        if (existsSync3 === void 0) {
-          existsSync3 = fs32.existsSync;
+      function walkForTsConfig(directory, existsSync4) {
+        if (existsSync4 === void 0) {
+          existsSync4 = fs32.existsSync;
         }
         var configPath = path5.join(directory, "./tsconfig.json");
-        if (existsSync3(configPath)) {
+        if (existsSync4(configPath)) {
           return configPath;
         }
         var parentDirectory = path5.join(directory, "../");
         if (directory === parentDirectory) {
           return void 0;
         }
-        return walkForTsConfig(parentDirectory, existsSync3);
+        return walkForTsConfig(parentDirectory, existsSync4);
       }
       exports2.walkForTsConfig = walkForTsConfig;
-      function loadTsconfig(configFilePath, existsSync3, readFileSync2) {
-        if (existsSync3 === void 0) {
-          existsSync3 = fs32.existsSync;
+      function loadTsconfig(configFilePath, existsSync4, readFileSync3) {
+        if (existsSync4 === void 0) {
+          existsSync4 = fs32.existsSync;
         }
-        if (readFileSync2 === void 0) {
-          readFileSync2 = function(filename) {
+        if (readFileSync3 === void 0) {
+          readFileSync3 = function(filename) {
             return fs32.readFileSync(filename, "utf8");
           };
         }
-        if (!existsSync3(configFilePath)) {
+        if (!existsSync4(configFilePath)) {
           return void 0;
         }
-        var configString = readFileSync2(configFilePath);
+        var configString = readFileSync3(configFilePath);
         var cleanedJson = StripBom(configString);
         var config = JSON5.parse(cleanedJson);
         var extendedConfig = config.extends;
@@ -11856,10 +11963,10 @@ var require_node2 = __commonJS({
           }
           var currentDir = path5.dirname(configFilePath);
           var extendedConfigPath = path5.join(currentDir, extendedConfig);
-          if (extendedConfig.indexOf("/") !== -1 && extendedConfig.indexOf(".") !== -1 && !existsSync3(extendedConfigPath)) {
+          if (extendedConfig.indexOf("/") !== -1 && extendedConfig.indexOf(".") !== -1 && !existsSync4(extendedConfigPath)) {
             extendedConfigPath = path5.join(currentDir, "node_modules", extendedConfig);
           }
-          var base = loadTsconfig(extendedConfigPath, existsSync3, readFileSync2) || {};
+          var base = loadTsconfig(extendedConfigPath, existsSync4, readFileSync3) || {};
           if (base.compilerOptions && base.compilerOptions.baseUrl) {
             var extendsDir = path5.dirname(extendedConfig);
             base.compilerOptions.baseUrl = path5.join(extendsDir, base.compilerOptions.baseUrl);
@@ -12807,11 +12914,16 @@ var init_pgSerializer = __esm({
         schemas.map((it) => [it.schemaName, it.schemaName])
       );
       return {
-        version: "4",
+        version: "5",
         dialect: "pg",
         tables: result,
         enums: enumsToReturn,
-        schemas: schemasObject
+        schemas: schemasObject,
+        _meta: {
+          schemas: {},
+          tables: {},
+          columns: {}
+        }
       };
     };
     fromDatabase = async (db, progressCallback) => {
@@ -13024,11 +13136,16 @@ var init_pgSerializer = __esm({
       progressCallback("enums", Object.keys(enumsToReturn).length, "done");
       const schemasObject = Object.fromEntries([...schemas].map((it) => [it, it]));
       return {
-        version: "4",
+        version: "5",
         dialect: "pg",
         tables: result,
         enums: enumsToReturn,
-        schemas: schemasObject
+        schemas: schemasObject,
+        _meta: {
+          schemas: {},
+          tables: {},
+          columns: {}
+        }
       };
     };
   }
@@ -13172,12 +13289,12 @@ var init_sqliteSerializer = __esm({
 });
 
 // src/serializer/index.ts
-var import_fs2, import_node, import_path, safeRegister, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
+var import_fs2, import_node, import_path2, safeRegister, serializeMySql, serializePg, serializeSQLite, prepareFilenames;
 var init_serializer = __esm({
   "src/serializer/index.ts"() {
     import_fs2 = __toESM(require("fs"));
     import_node = __toESM(require_node2());
-    import_path = __toESM(require("path"));
+    import_path2 = __toESM(require("path"));
     safeRegister = () => {
       try {
         const { unregister } = (0, import_node.register)({
@@ -13218,8 +13335,8 @@ var init_serializer = __esm({
       return generateSqliteSnapshot2(tables, enums);
     };
     prepareFilenames = (path5) => {
-      const fileName = import_fs2.default.lstatSync(path5).isDirectory() ? null : import_path.default.resolve(path5);
-      const filenames = fileName ? [fileName] : import_fs2.default.readdirSync(path5).map((it) => import_path.default.join(import_path.default.resolve(path5), it));
+      const fileName = import_fs2.default.lstatSync(path5).isDirectory() ? null : import_path2.default.resolve(path5);
+      const filenames = fileName ? [fileName] : import_fs2.default.readdirSync(path5).map((it) => import_path2.default.join(import_path2.default.resolve(path5), it));
       return filenames;
     };
   }
@@ -13235,9 +13352,9 @@ var init_migrationPreparator = __esm({
     init_pgSchema();
     init_sqliteSchema();
     init_mysqlSchema();
-    prepareMySqlMigrationSnapshot = (migrationFolders, outFolder = "drizzle", schemaPath) => {
+    prepareMySqlMigrationSnapshot = (migrationFolders, schemaPath) => {
       const prevSnapshot = mysqlSchema.parse(
-        preparePrevSnapshot(outFolder, migrationFolders, dryMySql)
+        preparePrevSnapshot(migrationFolders, dryMySql)
       );
       const serialized = serializeMySql(schemaPath);
       const id = (0, import_crypto.randomUUID)();
@@ -13246,9 +13363,9 @@ var init_migrationPreparator = __esm({
       const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
       return { prev: prevSnapshot, cur: result };
     };
-    prepareSqliteMigrationSnapshot = (migrationFolders, outFolder = "drizzle", schemaPath) => {
+    prepareSqliteMigrationSnapshot = (snapshots, schemaPath) => {
       const prevSnapshot = sqliteSchema.parse(
-        preparePrevSnapshot(outFolder, migrationFolders, drySQLite)
+        preparePrevSnapshot(snapshots, drySQLite)
       );
       const serialized = serializeSQLite(schemaPath);
       const id = (0, import_crypto.randomUUID)();
@@ -13263,10 +13380,8 @@ var init_migrationPreparator = __esm({
       };
       return { prev: prevSnapshot, cur: result };
     };
-    preparePgMigrationSnapshot = (migrationFolders, outFolder = "drizzle", schemaPath) => {
-      const prevSnapshot = pgSchema.parse(
-        preparePrevSnapshot(outFolder, migrationFolders, dryPg)
-      );
+    preparePgMigrationSnapshot = (snapshots, schemaPath) => {
+      const prevSnapshot = pgSchema.parse(preparePrevSnapshot(snapshots, dryPg));
       const serialized = serializePg(schemaPath);
       const id = (0, import_crypto.randomUUID)();
       const idPrev = prevSnapshot.id;
@@ -13274,16 +13389,13 @@ var init_migrationPreparator = __esm({
       const result = { version, dialect: dialect6, id, prevId: idPrev, ...rest };
       return { prev: prevSnapshot, cur: result };
     };
-    preparePrevSnapshot = (outFolder, migrationFolders, defaultPrev) => {
-      const root = outFolder;
+    preparePrevSnapshot = (snapshots, defaultPrev) => {
       let prevSnapshot;
-      if (migrationFolders.length === 0) {
+      if (snapshots.length === 0) {
         prevSnapshot = defaultPrev;
       } else {
-        const lastSnapshotFolder = migrationFolders[migrationFolders.length - 1];
-        prevSnapshot = JSON.parse(
-          import_fs3.default.readFileSync(`${root}/${lastSnapshotFolder}/snapshot.json`).toString()
-        );
+        const lastSnapshot = snapshots[snapshots.length - 1];
+        prevSnapshot = JSON.parse(import_fs3.default.readFileSync(lastSnapshot).toString());
       }
       return prevSnapshot;
     };
@@ -13477,7 +13589,7 @@ var init_sqlgenerator = __esm({
         return statement.type === "rename_table" && dialect6 === "pg";
       }
       convert(statement) {
-        const { tableNameFrom, tableNameTo, fromSchema: schema4 } = statement;
+        const { tableNameFrom, tableNameTo, toSchema: schema4 } = statement;
         const from = schema4 ? `"${schema4}"."${tableNameFrom}"` : `"${tableNameFrom}"`;
         const to = schema4 ? `"${schema4}"."${tableNameTo}"` : `"${tableNameTo}"`;
         return `ALTER TABLE ${from} RENAME TO ${to};`;
@@ -18841,7 +18953,7 @@ var require_bare = __commonJS({
     var sgr = require_sgr();
     var supportsColor2 = require_supports_color2();
     var mods = sgr.mods;
-    var join = Array.prototype.join;
+    var join4 = Array.prototype.join;
     var defineProperty = Object.defineProperty;
     var max = Math.max;
     var min = Math.min;
@@ -18895,7 +19007,7 @@ var require_bare = __commonJS({
     getFn = function() {
       return setPrototypeOf(
         function self2() {
-          var start = "", end = "", msg = join.call(arguments, " "), conf = self2._cliColorData, hasAnsi = sgr.hasCSI(msg);
+          var start = "", end = "", msg = join4.call(arguments, " "), conf = self2._cliColorData, hasAnsi = sgr.hasCSI(msg);
           forEach(
             conf,
             function(mod, key) {
@@ -20326,7 +20438,7 @@ function diffForRenamedTable(t1, t2) {
   t1.name = t2.name;
   const diffed = (0, import_json_diff.diff)(t1, t2) || {};
   diffed.name = t2.name;
-  return findAlternationsInTable(diffed);
+  return findAlternationsInTable(diffed, t2.schema);
 }
 function diffForRenamedColumn(t1, t2) {
   const renamed = { ...t1, name: t2.name };
@@ -20340,6 +20452,10 @@ function applyJsonDiff(json1, json2) {
   json2 = JSON.parse(JSON.stringify(json2));
   const rawDiff = (0, import_json_diff.diff)(json1, json2);
   const difference = rawDiff;
+  const tableToSchema = Object.entries(json2.tables).reduce((res, it) => {
+    res[it[0]] = it[1].schema;
+    return res;
+  }, {});
   if (!difference)
     return {};
   difference.tables = (_a = difference.tables) != null ? _a : {};
@@ -20369,7 +20485,7 @@ function applyJsonDiff(json1, json2) {
   const schemasEntries = Object.entries(difference.schemas);
   const addedSchemas = schemasEntries.filter((it) => it[0].endsWith("__added")).map((it) => it[1]);
   const deletedSchemas = schemasEntries.filter((it) => it[0].endsWith("__deleted")).map((it) => it[1]);
-  const alteredTablesWithColumns = alteredTables.map((table4) => findAlternationsInTable(table4));
+  const alteredTablesWithColumns = alteredTables.map((table4) => findAlternationsInTable(table4, tableToSchema[table4.name]));
   return {
     addedTables,
     deletedTables,
@@ -20386,10 +20502,13 @@ var init_jsonDiffer = __esm({
   "src/jsonDiffer.js"() {
     import_json_diff = __toESM(require_lib());
     "use-strict";
-    findAlternationsInTable = (table4) => {
+    findAlternationsInTable = (table4, tableSchema) => {
       var _a;
       const columns = (_a = table4.columns) != null ? _a : {};
-      let schema4;
+      let schema4 = {
+        type: "none",
+        value: tableSchema
+      };
       if ("schema" in table4) {
         if (table4.schema.__new) {
           schema4 = { type: "changed", old: table4.schema.__old, new: table4.schema.__new };
@@ -20526,7 +20645,8 @@ var init_jsonStatements = __esm({
     prepareDropTableJson = (table4) => {
       return {
         type: "drop_table",
-        tableName: table4.name
+        tableName: table4.name,
+        schema: table4.schema
       };
     };
     prepareRenameTableJson = (tableFrom, tableTo) => {
@@ -20579,20 +20699,21 @@ var init_jsonStatements = __esm({
         };
       });
     };
-    prepareRenameColumns = (tableName, pairs) => {
+    prepareRenameColumns = (tableName, schema4, pairs) => {
       return pairs.map((it) => {
         return {
           type: "alter_table_rename_column",
           tableName,
           oldColumnName: it.from.name,
-          newColumnName: it.to.name
+          newColumnName: it.to.name,
+          schema: schema4
         };
       });
     };
-    prepareAlterTableColumnsJson = (tableName, deleted, added, altered, addedFk, dialect6) => {
+    prepareAlterTableColumnsJson = (tableName, schema4, deleted, added, altered, addedFk, dialect6) => {
       const addColumns = [];
-      const dropColumns = _prepareDropColumns(tableName, deleted);
-      const alterColumns = _prepareAlterColumns(tableName, altered);
+      const dropColumns = _prepareDropColumns(tableName, schema4, deleted);
+      const alterColumns = _prepareAlterColumns(tableName, schema4, altered);
       if (dialect6 === "sqlite") {
         let jsonCreateFKStatements = Object.values(addedFk);
         const sqliteAddColumns = _prepareSQLiteAddColumns(
@@ -20602,25 +20723,27 @@ var init_jsonStatements = __esm({
         );
         addColumns.push(...sqliteAddColumns);
       } else {
-        addColumns.push(..._prepareAddColumns(tableName, added));
+        addColumns.push(..._prepareAddColumns(tableName, schema4, added));
       }
       return { addColumns, dropColumns, alterColumns };
     };
-    _prepareDropColumns = (taleName, columns) => {
+    _prepareDropColumns = (taleName, schema4, columns) => {
       return columns.map((it) => {
         return {
           type: "alter_table_drop_column",
           tableName: taleName,
-          columnName: it.name
+          columnName: it.name,
+          schema: schema4
         };
       });
     };
-    _prepareAddColumns = (tableName, columns) => {
+    _prepareAddColumns = (tableName, schema4, columns) => {
       return columns.map((it) => {
         return {
           type: "alter_table_add_column",
           tableName,
-          column: it
+          column: it,
+          schema: schema4
         };
       });
     };
@@ -20640,7 +20763,7 @@ var init_jsonStatements = __esm({
         };
       });
     };
-    _prepareAlterColumns = (tableName, columns) => {
+    _prepareAlterColumns = (tableName, schema4, columns) => {
       var _a, _b, _c, _d, _e, _f, _g;
       let statements = [];
       for (const column5 of columns) {
@@ -20650,7 +20773,8 @@ var init_jsonStatements = __esm({
             type: "alter_table_rename_column",
             tableName,
             oldColumnName: column5.name.old,
-            newColumnName: column5.name.new
+            newColumnName: column5.name.new,
+            schema: schema4
           });
         }
         if (((_a = column5.type) == null ? void 0 : _a.type) === "changed") {
@@ -20658,7 +20782,8 @@ var init_jsonStatements = __esm({
             type: "alter_table_alter_column_set_type",
             tableName,
             columnName,
-            newDataType: column5.type.new
+            newDataType: column5.type.new,
+            schema: schema4
           });
         }
         if (((_b = column5.default) == null ? void 0 : _b.type) === "added") {
@@ -20666,7 +20791,8 @@ var init_jsonStatements = __esm({
             type: "alter_table_alter_column_set_default",
             tableName,
             columnName,
-            newDefaultValue: column5.default.value
+            newDefaultValue: column5.default.value,
+            schema: schema4
           });
         }
         if (((_c = column5.default) == null ? void 0 : _c.type) === "changed") {
@@ -20674,21 +20800,24 @@ var init_jsonStatements = __esm({
             type: "alter_table_alter_column_set_default",
             tableName,
             columnName,
-            newDefaultValue: column5.default.new
+            newDefaultValue: column5.default.new,
+            schema: schema4
           });
         }
         if (((_d = column5.default) == null ? void 0 : _d.type) === "deleted") {
           statements.push({
             type: "alter_table_alter_column_drop_default",
             tableName,
-            columnName
+            columnName,
+            schema: schema4
           });
         }
         if (((_e = column5.notNull) == null ? void 0 : _e.type) === "added") {
           statements.push({
             type: "alter_table_alter_column_set_notnull",
             tableName,
-            columnName
+            columnName,
+            schema: schema4
           });
         }
         if (((_f = column5.notNull) == null ? void 0 : _f.type) === "changed") {
@@ -20696,62 +20825,69 @@ var init_jsonStatements = __esm({
           statements.push({
             type,
             tableName,
-            columnName
+            columnName,
+            schema: schema4
           });
         }
         if (((_g = column5.notNull) == null ? void 0 : _g.type) === "deleted") {
           statements.push({
             type: "alter_table_alter_column_drop_notnull",
             tableName,
-            columnName
+            columnName,
+            schema: schema4
           });
         }
       }
       return statements;
     };
-    prepareCreateIndexesJson = (tableName, indexes) => {
+    prepareCreateIndexesJson = (tableName, schema4, indexes) => {
       return Object.values(indexes).map((indexData) => {
         return {
           type: "create_index",
           tableName,
-          data: indexData
+          data: indexData,
+          schema: schema4
         };
       });
     };
-    prepareCreateReferencesJson = (tableName, foreignKeys) => {
+    prepareCreateReferencesJson = (tableName, schema4, foreignKeys) => {
       return Object.values(foreignKeys).map((fkData) => {
         return {
           type: "create_reference",
           tableName,
-          data: fkData
+          data: fkData,
+          schema: schema4
         };
       });
     };
-    prepareDropReferencesJson = (tableName, foreignKeys) => {
+    prepareDropReferencesJson = (tableName, schema4, foreignKeys) => {
       return Object.values(foreignKeys).map((fkData) => {
         return {
           type: "delete_reference",
           tableName,
-          data: fkData
+          data: fkData,
+          schema: schema4
         };
       });
     };
-    prepareAlterReferencesJson = (tableName, foreignKeys) => {
+    prepareAlterReferencesJson = (tableName, schema4, foreignKeys) => {
       return Object.values(foreignKeys).map((fkData) => {
         return {
           type: "alter_reference",
           tableName,
           data: fkData.__new,
-          oldFkey: fkData.__old
+          oldFkey: fkData.__old,
+          schema: schema4
         };
       });
     };
-    prepareDropIndexesJson = (tableName, indexes) => {
+    prepareDropIndexesJson = (tableName, schema4, indexes) => {
       return Object.values(indexes).map((indexData) => {
         return {
           type: "drop_index",
           tableName,
-          data: indexData
+          data: indexData,
+          schema: schema4
         };
       });
     };
@@ -20787,13 +20923,14 @@ var init_jsonStatements = __esm({
 });
 
 // src/snapshotsDiffer.ts
-var makeChanged, makeSelfOrChanged, makePatched, columnSchema, alteredColumnSchema, enumSchema2, changedEnumSchema, tableScheme, alteredTableScheme, diffResultScheme, applySnapshotsDiff;
+var makeChanged, makeSelfOrChanged, makePatched, makeSelfOrPatched, valueFromSelfOrPatchedNew, columnSchema, alteredColumnSchema, enumSchema2, changedEnumSchema, tableScheme, alteredTableScheme, diffResultScheme, applySnapshotsDiff;
 var init_snapshotsDiffer = __esm({
   "src/snapshotsDiffer.ts"() {
     init_sqlgenerator();
     init_lib();
     init_jsonDiffer();
     init_jsonStatements();
+    init_utils();
     makeChanged = (schema4) => {
       return objectType({
         type: enumType(["changed"]),
@@ -20814,20 +20951,53 @@ var init_snapshotsDiffer = __esm({
     makePatched = (schema4) => {
       return unionType([
         objectType({
-          type: enumType(["added"]),
+          type: literalType("added"),
           value: schema4
         }),
         objectType({
-          type: enumType(["deleted"]),
+          type: literalType("deleted"),
           value: schema4
         }),
         objectType({
-          type: enumType(["changed"]),
+          type: literalType("changed"),
+          old: schema4,
+          new: schema4
+        })
+      ]);
+    };
+    makeSelfOrPatched = (schema4) => {
+      return unionType([
+        objectType({
+          type: literalType("none"),
+          value: schema4
+        }),
+        objectType({
+          type: literalType("added"),
+          value: schema4
+        }),
+        objectType({
+          type: literalType("deleted"),
+          value: schema4
+        }),
+        objectType({
+          type: literalType("changed"),
           old: schema4,
           new: schema4
         })
       ]);
     };
+    valueFromSelfOrPatchedNew = (it) => {
+      switch (it.type) {
+        case "none":
+          return it.value;
+        case "added":
+          return it.value;
+        case "deleted":
+          return it.value;
+        case "changed":
+          return it.new;
+      }
+    };
     columnSchema = objectType({
       name: stringType(),
       type: stringType(),
@@ -20840,7 +21010,7 @@ var init_snapshotsDiffer = __esm({
     alteredColumnSchema = objectType({
       name: makeSelfOrChanged(stringType()),
       type: makeChanged(stringType()).optional(),
-      default: makePatched(stringType()).optional(),
+      default: makePatched(anyType()).optional(),
       notNull: makePatched(booleanType()).optional()
     }).strict();
     enumSchema2 = objectType({
@@ -20862,7 +21032,7 @@ var init_snapshotsDiffer = __esm({
     }).strict();
     alteredTableScheme = objectType({
       name: stringType(),
-      schema: makePatched(stringType()).optional(),
+      schema: makeSelfOrPatched(stringType()),
       deleted: columnSchema.array(),
       added: columnSchema.array(),
       altered: alteredColumnSchema.array(),
@@ -20897,25 +21067,32 @@ var init_snapshotsDiffer = __esm({
       addedSchemas: stringType().array(),
       deletedSchemas: stringType().array()
     }).strict();
-    applySnapshotsDiff = async (json1, json2, dialect6, schemasResolver, tablesResolver, columnsResolver) => {
+    applySnapshotsDiff = async (json1, json2, dialect6, schemasResolver2, tablesResolver2, columnsResolver2) => {
       var _a, _b, _c, _d;
       const diffResult = applyJsonDiff(json1, json2);
       if (Object.keys(diffResult).length === 0) {
-        return "";
+        return { statements: [], sql: "" };
       }
       const typedResult = diffResultScheme.parse(diffResult);
       const {
         created: createdSchemas,
         deleted: deletedSchemas,
         renamed: renamedSchemas
-      } = await schemasResolver({
+      } = await schemasResolver2({
         created: typedResult.addedSchemas.map((it) => ({ name: it })),
         deleted: typedResult.deletedSchemas.map((it) => ({ name: it }))
       });
-      const { created, deleted, renamed } = await tablesResolver({
+      const { created, deleted, renamed } = await tablesResolver2({
         created: typedResult.addedTables,
         deleted: typedResult.deletedTables
       });
+      const rSchemas = renamedSchemas.map((it) => ({
+        from: it.from.name,
+        to: it.to.name
+      }));
+      const rTables = renamed.map((it) => {
+        return { from: it.from, to: it.to };
+      });
       const jsonStatements = [];
       const jsonSQLiteCreateTables = created.map((it) => {
         return prepareSQLiteCreateTable(it);
@@ -20924,7 +21101,7 @@ var init_snapshotsDiffer = __esm({
         return prepareCreateTableJson(it);
       });
       const jsonCreateIndexesForCreatedTables = created.map((it) => {
-        return prepareCreateIndexesJson(it.name, it.indexes);
+        return prepareCreateIndexesJson(it.name, it.schema, it.indexes);
       }).flat();
       const jsonDropTables = deleted.map((it) => {
         return prepareDropTableJson(it);
@@ -20941,13 +21118,14 @@ var init_snapshotsDiffer = __esm({
       const jsonRenameColumnsStatements = [];
       const allAlteredResolved = [];
       for (const table4 of allAltered) {
-        const result = await columnsResolver({
+        const result = await columnsResolver2({
           tableName: table4.name,
           created: table4.added,
           deleted: table4.deleted
         });
+        const schema4 = valueFromSelfOrPatchedNew(table4.schema);
         jsonRenameColumnsStatements.push(
-          ...prepareRenameColumns(table4.name, result.renamed)
+          ...prepareRenameColumns(table4.name, schema4, result.renamed)
         );
         const renamedColumnsAltered = result.renamed.map(
           (it) => alteredColumnSchema.parse(diffForRenamedColumn(it.from, it.to))
@@ -20989,7 +21167,7 @@ var init_snapshotsDiffer = __esm({
           it.name,
           it.alteredCompositePKs
         );
-        if (it.schema) {
+        if (it.schema && typeof it.schema !== "string") {
           switch (it.schema.type) {
             case "added": {
               jsonSetTableSchemas.push({
@@ -21022,38 +21200,56 @@ var init_snapshotsDiffer = __esm({
         jsonDeletedCompositePKs.push(...deletedCompositePKs);
         jsonAlteredCompositePKs.push(...alteredCompositePKs);
       });
+      const rColumns = jsonRenameColumnsStatements.map((it) => {
+        const tableName = it.tableName;
+        const schema4 = it.schema;
+        return {
+          from: { schema: schema4, table: tableName, column: it.oldColumnName },
+          to: { schema: schema4, table: tableName, column: it.newColumnName }
+        };
+      });
       const jsonTableAlternations = allAlteredResolved.map((it) => {
+        const schema4 = valueFromSelfOrPatchedNew(it.schema);
         return prepareAlterTableColumnsJson(
           it.name,
+          schema4,
           it.deleted,
           it.added,
           it.altered,
           it.addedForeignKeys,
           dialect6
         );
-      }).flat().reduce((res, it) => {
-        res.createColumns.push(...it.addColumns);
-        res.dropColumns.push(...it.dropColumns);
-        res.alterColumns.push(...it.alterColumns);
-        return res;
-      }, { createColumns: [], dropColumns: [], alterColumns: [] });
+      }).flat().reduce(
+        (res, it) => {
+          res.createColumns.push(...it.addColumns);
+          res.dropColumns.push(...it.dropColumns);
+          res.alterColumns.push(...it.alterColumns);
+          return res;
+        },
+        { createColumns: [], dropColumns: [], alterColumns: [] }
+      );
       const jsonCreateIndexesForAllAlteredTables = allAltered.map((it) => {
-        return prepareCreateIndexesJson(it.name, it.addedIndexes || {});
+        const schema4 = valueFromSelfOrPatchedNew(it.schema);
+        return prepareCreateIndexesJson(it.name, schema4, it.addedIndexes || {});
       }).flat();
       const jsonDropIndexesForAllAlteredTables = allAltered.map((it) => {
-        return prepareDropIndexesJson(it.name, it.deletedIndexes || {});
+        const schema4 = valueFromSelfOrPatchedNew(it.schema);
+        return prepareDropIndexesJson(it.name, schema4, it.deletedIndexes || {});
       }).flat();
       const jsonCreateReferencesForCreatedTables = created.map((it) => {
-        return prepareCreateReferencesJson(it.name, it.foreignKeys);
+        return prepareCreateReferencesJson(it.name, it.schema, it.foreignKeys);
       }).flat();
       const jsonReferencesForAllAlteredTables = allAltered.map((it) => {
-        const forAdded = dialect6 !== "sqlite" ? prepareCreateReferencesJson(it.name, it.addedForeignKeys) : [];
+        const schema4 = valueFromSelfOrPatchedNew(it.schema);
+        const forAdded = dialect6 !== "sqlite" ? prepareCreateReferencesJson(it.name, schema4, it.addedForeignKeys) : [];
         const forAltered = prepareDropReferencesJson(
           it.name,
+          schema4,
           it.deletedForeignKeys
         );
         const alteredFKs = prepareAlterReferencesJson(
           it.name,
+          schema4,
           it.alteredForeignKeys
         );
         return [...forAdded, ...forAltered, ...alteredFKs];
@@ -21115,11 +21311,1334 @@ var init_snapshotsDiffer = __esm({
       jsonStatements.push(...jsonRemoveTableFromSchemas);
       jsonStatements.push(...dropSchemas);
       const sqlStatements = fromJson(jsonStatements, dialect6);
-      return sqlStatements.join("\n");
+      const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
+      return { statements: jsonStatements, sql: sqlStatements.join("\n"), _meta };
     };
   }
 });
 
+// src/utils/words.ts
+var prepareMigrationMetadata, adjectives, heroes;
+var init_words = __esm({
+  "src/utils/words.ts"() {
+    prepareMigrationMetadata = (idx) => {
+      const prefix = idx.toFixed(0).padStart(4, "0");
+      const suffix = `${adjectives.random()}_${heroes.random()}`;
+      const tag = `${prefix}_${suffix}`;
+      return { prefix, suffix, tag };
+    };
+    adjectives = [
+      "abandoned",
+      "aberrant",
+      "abnormal",
+      "absent",
+      "absurd",
+      "acoustic",
+      "adorable",
+      "amazing",
+      "ambiguous",
+      "ambitious",
+      "amused",
+      "amusing",
+      "ancient",
+      "aromatic",
+      "aspiring",
+      "awesome",
+      "bent",
+      "big",
+      "bitter",
+      "bizarre",
+      "black",
+      "blue",
+      "blushing",
+      "bored",
+      "boring",
+      "bouncy",
+      "brainy",
+      "brave",
+      "breezy",
+      "brief",
+      "bright",
+      "broad",
+      "broken",
+      "brown",
+      "bumpy",
+      "burly",
+      "busy",
+      "calm",
+      "careful",
+      "careless",
+      "certain",
+      "charming",
+      "cheerful",
+      "chemical",
+      "chief",
+      "chilly",
+      "chubby",
+      "chunky",
+      "clammy",
+      "classy",
+      "clean",
+      "clear",
+      "clever",
+      "cloudy",
+      "closed",
+      "clumsy",
+      "cold",
+      "colorful",
+      "colossal",
+      "common",
+      "complete",
+      "complex",
+      "concerned",
+      "condemned",
+      "confused",
+      "conscious",
+      "cooing",
+      "cool",
+      "crazy",
+      "cuddly",
+      "cultured",
+      "curious",
+      "curly",
+      "curved",
+      "curvy",
+      "cute",
+      "cynical",
+      "daffy",
+      "daily",
+      "damp",
+      "dapper",
+      "dark",
+      "dashing",
+      "dazzling",
+      "dear",
+      "deep",
+      "demonic",
+      "dizzy",
+      "dry",
+      "dusty",
+      "eager",
+      "early",
+      "easy",
+      "elite",
+      "eminent",
+      "empty",
+      "equal",
+      "even",
+      "exotic",
+      "fair",
+      "faithful",
+      "familiar",
+      "famous",
+      "fancy",
+      "fantastic",
+      "far",
+      "fast",
+      "fat",
+      "faulty",
+      "fearless",
+      "fine",
+      "first",
+      "fixed",
+      "flaky",
+      "flashy",
+      "flat",
+      "flawless",
+      "flimsy",
+      "flippant",
+      "flowery",
+      "fluffy",
+      "foamy",
+      "free",
+      "freezing",
+      "fresh",
+      "friendly",
+      "funny",
+      "furry",
+      "futuristic",
+      "fuzzy",
+      "giant",
+      "gifted",
+      "gigantic",
+      "glamorous",
+      "glorious",
+      "glossy",
+      "good",
+      "goofy",
+      "gorgeous",
+      "graceful",
+      "gray",
+      "great",
+      "greedy",
+      "green",
+      "grey",
+      "groovy",
+      "handy",
+      "happy",
+      "hard",
+      "harsh",
+      "heavy",
+      "hesitant",
+      "high",
+      "hot",
+      "huge",
+      "icy",
+      "illegal",
+      "jazzy",
+      "jittery",
+      "keen",
+      "kind",
+      "known",
+      "lame",
+      "large",
+      "last",
+      "late",
+      "lazy",
+      "lean",
+      "left",
+      "legal",
+      "lethal",
+      "light",
+      "little",
+      "lively",
+      "living",
+      "lonely",
+      "long",
+      "loose",
+      "loud",
+      "lovely",
+      "loving",
+      "low",
+      "lowly",
+      "lucky",
+      "lumpy",
+      "lush",
+      "luxuriant",
+      "lying",
+      "lyrical",
+      "magenta",
+      "magical",
+      "majestic",
+      "many",
+      "massive",
+      "married",
+      "marvelous",
+      "material",
+      "mature",
+      "mean",
+      "medical",
+      "melodic",
+      "melted",
+      "messy",
+      "mighty",
+      "military",
+      "milky",
+      "minor",
+      "misty",
+      "mixed",
+      "moaning",
+      "modern",
+      "motionless",
+      "mushy",
+      "mute",
+      "mysterious",
+      "naive",
+      "nappy",
+      "narrow",
+      "nasty",
+      "natural",
+      "neat",
+      "nebulous",
+      "needy",
+      "nervous",
+      "new",
+      "next",
+      "nice",
+      "nifty",
+      "noisy",
+      "normal",
+      "nostalgic",
+      "nosy",
+      "numerous",
+      "odd",
+      "old",
+      "omniscient",
+      "open",
+      "opposite",
+      "optimal",
+      "orange",
+      "ordinary",
+      "organic",
+      "outgoing",
+      "outstanding",
+      "oval",
+      "overconfident",
+      "overjoyed",
+      "overrated",
+      "pale",
+      "panoramic",
+      "parallel",
+      "parched",
+      "past",
+      "peaceful",
+      "perfect",
+      "perpetual",
+      "petite",
+      "pink",
+      "plain",
+      "polite",
+      "powerful",
+      "premium",
+      "pretty",
+      "previous",
+      "productive",
+      "public",
+      "purple",
+      "puzzling",
+      "quick",
+      "quiet",
+      "rainy",
+      "rapid",
+      "rare",
+      "real",
+      "red",
+      "redundant",
+      "reflective",
+      "regular",
+      "remarkable",
+      "rich",
+      "right",
+      "robust",
+      "romantic",
+      "round",
+      "sad",
+      "safe",
+      "salty",
+      "same",
+      "secret",
+      "serious",
+      "shallow",
+      "sharp",
+      "shiny",
+      "shocking",
+      "short",
+      "silent",
+      "silky",
+      "silly",
+      "simple",
+      "skinny",
+      "sleepy",
+      "slim",
+      "slimy",
+      "slippery",
+      "sloppy",
+      "slow",
+      "small",
+      "smart",
+      "smiling",
+      "smooth",
+      "soft",
+      "solid",
+      "sour",
+      "sparkling",
+      "special",
+      "spicy",
+      "spooky",
+      "spotty",
+      "square",
+      "stale",
+      "steady",
+      "steep",
+      "sticky",
+      "stiff",
+      "stormy",
+      "strange",
+      "striped",
+      "strong",
+      "sturdy",
+      "sudden",
+      "superb",
+      "supreme",
+      "sweet",
+      "swift",
+      "talented",
+      "tan",
+      "tearful",
+      "tense",
+      "thankful",
+      "thick",
+      "thin",
+      "third",
+      "tidy",
+      "tiny",
+      "tired",
+      "tiresome",
+      "tough",
+      "tranquil",
+      "tricky",
+      "true",
+      "typical",
+      "uneven",
+      "unique",
+      "unknown",
+      "unusual",
+      "useful",
+      "vengeful",
+      "violet",
+      "volatile",
+      "wakeful",
+      "wandering",
+      "warm",
+      "watery",
+      "wealthy",
+      "wet",
+      "white",
+      "whole",
+      "wide",
+      "wild",
+      "windy",
+      "wise",
+      "wonderful",
+      "wooden",
+      "woozy",
+      "workable",
+      "worried",
+      "worthless",
+      "yellow",
+      "yielding",
+      "young",
+      "youthful",
+      "yummy",
+      "zippy"
+    ];
+    heroes = [
+      "aaron_stack",
+      "abomination",
+      "absorbing_man",
+      "adam_destine",
+      "adam_warlock",
+      "agent_brand",
+      "agent_zero",
+      "albert_cleary",
+      "alex_power",
+      "alex_wilder",
+      "alice",
+      "amazoness",
+      "amphibian",
+      "angel",
+      "anita_blake",
+      "annihilus",
+      "anthem",
+      "apocalypse",
+      "aqueduct",
+      "arachne",
+      "archangel",
+      "arclight",
+      "ares",
+      "argent",
+      "avengers",
+      "azazel",
+      "banshee",
+      "baron_strucker",
+      "baron_zemo",
+      "barracuda",
+      "bastion",
+      "beast",
+      "bedlam",
+      "ben_grimm",
+      "ben_parker",
+      "ben_urich",
+      "betty_brant",
+      "betty_ross",
+      "beyonder",
+      "big_bertha",
+      "bill_hollister",
+      "bishop",
+      "black_bird",
+      "black_bolt",
+      "black_cat",
+      "black_crow",
+      "black_knight",
+      "black_panther",
+      "black_queen",
+      "black_tarantula",
+      "black_tom",
+      "black_widow",
+      "blackheart",
+      "blacklash",
+      "blade",
+      "blazing_skull",
+      "blindfold",
+      "blink",
+      "blizzard",
+      "blob",
+      "blockbuster",
+      "blonde_phantom",
+      "bloodaxe",
+      "bloodscream",
+      "bloodstorm",
+      "bloodstrike",
+      "blue_blade",
+      "blue_marvel",
+      "blue_shield",
+      "blur",
+      "boom_boom",
+      "boomer",
+      "boomerang",
+      "bromley",
+      "brood",
+      "brother_voodoo",
+      "bruce_banner",
+      "bucky",
+      "bug",
+      "bulldozer",
+      "bullseye",
+      "bushwacker",
+      "butterfly",
+      "cable",
+      "callisto",
+      "calypso",
+      "cammi",
+      "cannonball",
+      "captain_america",
+      "captain_britain",
+      "captain_cross",
+      "captain_flint",
+      "captain_marvel",
+      "captain_midlands",
+      "captain_stacy",
+      "captain_universe",
+      "cardiac",
+      "caretaker",
+      "cargill",
+      "carlie_cooper",
+      "carmella_unuscione",
+      "carnage",
+      "cassandra_nova",
+      "catseye",
+      "celestials",
+      "centennial",
+      "cerebro",
+      "cerise",
+      "chamber",
+      "chameleon",
+      "champions",
+      "changeling",
+      "charles_xavier",
+      "chat",
+      "chimera",
+      "christian_walker",
+      "chronomancer",
+      "clea",
+      "clint_barton",
+      "cloak",
+      "cobalt_man",
+      "colleen_wing",
+      "colonel_america",
+      "colossus",
+      "corsair",
+      "crusher_hogan",
+      "crystal",
+      "cyclops",
+      "dagger",
+      "daimon_hellstrom",
+      "dakota_north",
+      "daredevil",
+      "dark_beast",
+      "dark_phoenix",
+      "darkhawk",
+      "darkstar",
+      "darwin",
+      "dazzler",
+      "deadpool",
+      "deathbird",
+      "deathstrike",
+      "demogoblin",
+      "devos",
+      "dexter_bennett",
+      "diamondback",
+      "doctor_doom",
+      "doctor_faustus",
+      "doctor_octopus",
+      "doctor_spectrum",
+      "doctor_strange",
+      "domino",
+      "donald_blake",
+      "doomsday",
+      "doorman",
+      "dorian_gray",
+      "dormammu",
+      "dracula",
+      "dragon_lord",
+      "dragon_man",
+      "drax",
+      "dreadnoughts",
+      "dreaming_celestial",
+      "dust",
+      "earthquake",
+      "echo",
+      "eddie_brock",
+      "edwin_jarvis",
+      "ego",
+      "electro",
+      "elektra",
+      "emma_frost",
+      "enchantress",
+      "ender_wiggin",
+      "energizer",
+      "epoch",
+      "eternals",
+      "eternity",
+      "excalibur",
+      "exiles",
+      "exodus",
+      "expediter",
+      "ezekiel",
+      "ezekiel_stane",
+      "fabian_cortez",
+      "falcon",
+      "fallen_one",
+      "famine",
+      "fantastic_four",
+      "fat_cobra",
+      "felicia_hardy",
+      "fenris",
+      "firebird",
+      "firebrand",
+      "firedrake",
+      "firelord",
+      "firestar",
+      "fixer",
+      "flatman",
+      "forge",
+      "forgotten_one",
+      "frank_castle",
+      "franklin_richards",
+      "franklin_storm",
+      "freak",
+      "frightful_four",
+      "frog_thor",
+      "gabe_jones",
+      "galactus",
+      "gambit",
+      "gamma_corps",
+      "gamora",
+      "gargoyle",
+      "garia",
+      "gateway",
+      "gauntlet",
+      "genesis",
+      "george_stacy",
+      "gertrude_yorkes",
+      "ghost_rider",
+      "giant_girl",
+      "giant_man",
+      "gideon",
+      "gladiator",
+      "glorian",
+      "goblin_queen",
+      "golden_guardian",
+      "goliath",
+      "gorgon",
+      "gorilla_man",
+      "grandmaster",
+      "gravity",
+      "green_goblin",
+      "gressill",
+      "grey_gargoyle",
+      "greymalkin",
+      "grim_reaper",
+      "groot",
+      "guardian",
+      "guardsmen",
+      "gunslinger",
+      "gwen_stacy",
+      "hairball",
+      "hammerhead",
+      "hannibal_king",
+      "hardball",
+      "harpoon",
+      "harrier",
+      "harry_osborn",
+      "havok",
+      "hawkeye",
+      "hedge_knight",
+      "hellcat",
+      "hellfire_club",
+      "hellion",
+      "hemingway",
+      "hercules",
+      "hex",
+      "hiroim",
+      "hitman",
+      "hobgoblin",
+      "holocaust",
+      "hulk",
+      "human_cannonball",
+      "human_fly",
+      "human_robot",
+      "human_torch",
+      "husk",
+      "hydra",
+      "iceman",
+      "ikaris",
+      "imperial_guard",
+      "impossible_man",
+      "inertia",
+      "infant_terrible",
+      "inhumans",
+      "ink",
+      "invaders",
+      "invisible_woman",
+      "iron_fist",
+      "iron_lad",
+      "iron_man",
+      "iron_monger",
+      "iron_patriot",
+      "ironclad",
+      "jack_flag",
+      "jack_murdock",
+      "jack_power",
+      "jackal",
+      "jackpot",
+      "james_howlett",
+      "jamie_braddock",
+      "jane_foster",
+      "jasper_sitwell",
+      "jazinda",
+      "jean_grey",
+      "jetstream",
+      "jigsaw",
+      "jimmy_woo",
+      "jocasta",
+      "johnny_blaze",
+      "johnny_storm",
+      "joseph",
+      "joshua_kane",
+      "joystick",
+      "jubilee",
+      "juggernaut",
+      "junta",
+      "justice",
+      "justin_hammer",
+      "kabuki",
+      "kang",
+      "karen_page",
+      "karma",
+      "karnak",
+      "kat_farrell",
+      "kate_bishop",
+      "katie_power",
+      "ken_ellis",
+      "khan",
+      "kid_colt",
+      "killer_shrike",
+      "killmonger",
+      "killraven",
+      "king_bedlam",
+      "king_cobra",
+      "kingpin",
+      "kinsey_walden",
+      "kitty_pryde",
+      "klaw",
+      "komodo",
+      "korath",
+      "korg",
+      "korvac",
+      "kree",
+      "krista_starr",
+      "kronos",
+      "kulan_gath",
+      "kylun",
+      "la_nuit",
+      "lady_bullseye",
+      "lady_deathstrike",
+      "lady_mastermind",
+      "lady_ursula",
+      "lady_vermin",
+      "lake",
+      "landau",
+      "layla_miller",
+      "leader",
+      "leech",
+      "legion",
+      "lenny_balinger",
+      "leo",
+      "leopardon",
+      "leper_queen",
+      "lester",
+      "lethal_legion",
+      "lifeguard",
+      "lightspeed",
+      "lila_cheney",
+      "lilandra",
+      "lilith",
+      "lily_hollister",
+      "lionheart",
+      "living_lightning",
+      "living_mummy",
+      "living_tribunal",
+      "liz_osborn",
+      "lizard",
+      "loa",
+      "lockheed",
+      "lockjaw",
+      "logan",
+      "loki",
+      "loners",
+      "longshot",
+      "lord_hawal",
+      "lord_tyger",
+      "lorna_dane",
+      "luckman",
+      "lucky_pierre",
+      "luke_cage",
+      "luminals",
+      "lyja",
+      "ma_gnuci",
+      "mac_gargan",
+      "mach_iv",
+      "machine_man",
+      "mad_thinker",
+      "madame_hydra",
+      "madame_masque",
+      "madame_web",
+      "maddog",
+      "madelyne_pryor",
+      "madripoor",
+      "madrox",
+      "maelstrom",
+      "maestro",
+      "magdalene",
+      "maggott",
+      "magik",
+      "maginty",
+      "magma",
+      "magneto",
+      "magus",
+      "major_mapleleaf",
+      "makkari",
+      "malcolm_colcord",
+      "malice",
+      "mandarin",
+      "mandrill",
+      "mandroid",
+      "manta",
+      "mantis",
+      "marauders",
+      "maria_hill",
+      "mariko_yashida",
+      "marrow",
+      "marten_broadcloak",
+      "martin_li",
+      "marvel_apes",
+      "marvel_boy",
+      "marvel_zombies",
+      "marvex",
+      "masked_marvel",
+      "masque",
+      "master_chief",
+      "master_mold",
+      "mastermind",
+      "mathemanic",
+      "matthew_murdock",
+      "mattie_franklin",
+      "mauler",
+      "maverick",
+      "maximus",
+      "may_parker",
+      "medusa",
+      "meggan",
+      "meltdown",
+      "menace",
+      "mentallo",
+      "mentor",
+      "mephisto",
+      "mephistopheles",
+      "mercury",
+      "mesmero",
+      "metal_master",
+      "meteorite",
+      "micro/macro",
+      "microbe",
+      "microchip",
+      "micromax",
+      "midnight",
+      "miek",
+      "mikhail_rasputin",
+      "millenium_guard",
+      "mimic",
+      "mindworm",
+      "miracleman",
+      "miss_america",
+      "mister_fear",
+      "mister_sinister",
+      "misty_knight",
+      "mockingbird",
+      "moira_mactaggert",
+      "mojo",
+      "mole_man",
+      "molecule_man",
+      "molly_hayes",
+      "molten_man",
+      "mongoose",
+      "mongu",
+      "monster_badoon",
+      "moon_knight",
+      "moondragon",
+      "moonstone",
+      "morbius",
+      "mordo",
+      "morg",
+      "morgan_stark",
+      "morlocks",
+      "morlun",
+      "morph",
+      "mother_askani",
+      "mulholland_black",
+      "multiple_man",
+      "mysterio",
+      "mystique",
+      "namor",
+      "namora",
+      "namorita",
+      "naoko",
+      "natasha_romanoff",
+      "nebula",
+      "nehzno",
+      "nekra",
+      "nemesis",
+      "network",
+      "newton_destine",
+      "next_avengers",
+      "nextwave",
+      "nick_fury",
+      "nico_minoru",
+      "nicolaos",
+      "night_nurse",
+      "night_thrasher",
+      "nightcrawler",
+      "nighthawk",
+      "nightmare",
+      "nightshade",
+      "nitro",
+      "nocturne",
+      "nomad",
+      "norman_osborn",
+      "norrin_radd",
+      "northstar",
+      "nova",
+      "nuke",
+      "obadiah_stane",
+      "odin",
+      "ogun",
+      "old_lace",
+      "omega_flight",
+      "omega_red",
+      "omega_sentinel",
+      "onslaught",
+      "oracle",
+      "orphan",
+      "otto_octavius",
+      "outlaw_kid",
+      "overlord",
+      "owl",
+      "ozymandias",
+      "paibok",
+      "paladin",
+      "pandemic",
+      "paper_doll",
+      "patch",
+      "patriot",
+      "payback",
+      "penance",
+      "pepper_potts",
+      "pestilence",
+      "pet_avengers",
+      "pete_wisdom",
+      "peter_parker",
+      "peter_quill",
+      "phalanx",
+      "phantom_reporter",
+      "phil_sheldon",
+      "photon",
+      "piledriver",
+      "pixie",
+      "plazm",
+      "polaris",
+      "post",
+      "power_man",
+      "power_pack",
+      "praxagora",
+      "preak",
+      "pretty_boy",
+      "pride",
+      "prima",
+      "princess_powerful",
+      "prism",
+      "prodigy",
+      "proemial_gods",
+      "professor_monster",
+      "proteus",
+      "proudstar",
+      "prowler",
+      "psylocke",
+      "psynapse",
+      "puck",
+      "puff_adder",
+      "puma",
+      "punisher",
+      "puppet_master",
+      "purifiers",
+      "purple_man",
+      "pyro",
+      "quasar",
+      "quasimodo",
+      "queen_noir",
+      "quentin_quire",
+      "quicksilver",
+      "rachel_grey",
+      "radioactive_man",
+      "rafael_vega",
+      "rage",
+      "raider",
+      "randall",
+      "randall_flagg",
+      "random",
+      "rattler",
+      "ravenous",
+      "rawhide_kid",
+      "raza",
+      "reaper",
+      "reavers",
+      "red_ghost",
+      "red_hulk",
+      "red_shift",
+      "red_skull",
+      "red_wolf",
+      "redwing",
+      "reptil",
+      "retro_girl",
+      "revanche",
+      "rhino",
+      "rhodey",
+      "richard_fisk",
+      "rick_jones",
+      "ricochet",
+      "rictor",
+      "riptide",
+      "risque",
+      "robbie_robertson",
+      "robin_chapel",
+      "rocket_raccoon",
+      "rocket_racer",
+      "rockslide",
+      "rogue",
+      "roland_deschain",
+      "romulus",
+      "ronan",
+      "roughhouse",
+      "roulette",
+      "roxanne_simpson",
+      "rumiko_fujikawa",
+      "runaways",
+      "russian",
+      "sabra",
+      "sabretooth",
+      "sage",
+      "sally_floyd",
+      "salo",
+      "sandman",
+      "santa_claus",
+      "saracen",
+      "sasquatch",
+      "satana",
+      "sauron",
+      "scalphunter",
+      "scarecrow",
+      "scarlet_spider",
+      "scarlet_witch",
+      "scorpion",
+      "scourge",
+      "scrambler",
+      "scream",
+      "screwball",
+      "sebastian_shaw",
+      "secret_warriors",
+      "selene",
+      "senator_kelly",
+      "sentinel",
+      "sentinels",
+      "sentry",
+      "ser_duncan",
+      "serpent_society",
+      "sersi",
+      "shadow_king",
+      "shadowcat",
+      "shaman",
+      "shape",
+      "shard",
+      "sharon_carter",
+      "sharon_ventura",
+      "shatterstar",
+      "shen",
+      "sheva_callister",
+      "shinko_yamashiro",
+      "shinobi_shaw",
+      "shiva",
+      "shiver_man",
+      "shocker",
+      "shockwave",
+      "shooting_star",
+      "shotgun",
+      "shriek",
+      "silhouette",
+      "silk_fever",
+      "silver_centurion",
+      "silver_fox",
+      "silver_sable",
+      "silver_samurai",
+      "silver_surfer",
+      "silverclaw",
+      "silvermane",
+      "sinister_six",
+      "sir_ram",
+      "siren",
+      "sister_grimm",
+      "skaar",
+      "skin",
+      "skreet",
+      "skrulls",
+      "skullbuster",
+      "slapstick",
+      "slayback",
+      "sleeper",
+      "sleepwalker",
+      "slipstream",
+      "slyde",
+      "smasher",
+      "smiling_tiger",
+      "snowbird",
+      "solo",
+      "songbird",
+      "spacker_dave",
+      "spectrum",
+      "speed",
+      "speed_demon",
+      "speedball",
+      "spencer_smythe",
+      "sphinx",
+      "spiral",
+      "spirit",
+      "spitfire",
+      "spot",
+      "sprite",
+      "spyke",
+      "squadron_sinister",
+      "squadron_supreme",
+      "squirrel_girl",
+      "star_brand",
+      "starbolt",
+      "stardust",
+      "starfox",
+      "starhawk",
+      "starjammers",
+      "stark_industries",
+      "stature",
+      "steel_serpent",
+      "stellaris",
+      "stepford_cuckoos",
+      "stephen_strange",
+      "steve_rogers",
+      "stick",
+      "stingray",
+      "stone_men",
+      "storm",
+      "stranger",
+      "strong_guy",
+      "stryfe",
+      "sue_storm",
+      "sugar_man",
+      "sumo",
+      "sunfire",
+      "sunset_bain",
+      "sunspot",
+      "supernaut",
+      "supreme_intelligence",
+      "surge",
+      "susan_delgado",
+      "swarm",
+      "sway",
+      "switch",
+      "swordsman",
+      "synch",
+      "tag",
+      "talisman",
+      "talkback",
+      "talon",
+      "talos",
+      "tana_nile",
+      "tarantula",
+      "tarot",
+      "taskmaster",
+      "tattoo",
+      "ted_forrester",
+      "tempest",
+      "tenebrous",
+      "terrax",
+      "terror",
+      "texas_twister",
+      "thaddeus_ross",
+      "thanos",
+      "the_anarchist",
+      "the_call",
+      "the_captain",
+      "the_enforcers",
+      "the_executioner",
+      "the_fallen",
+      "the_fury",
+      "the_hand",
+      "the_hood",
+      "the_hunter",
+      "the_initiative",
+      "the_leader",
+      "the_liberteens",
+      "the_order",
+      "the_phantom",
+      "the_professor",
+      "the_renegades",
+      "the_santerians",
+      "the_spike",
+      "the_stranger",
+      "the_twelve",
+      "the_watchers",
+      "thena",
+      "thing",
+      "thor",
+      "thor_girl",
+      "thunderball",
+      "thunderbird",
+      "thunderbolt",
+      "thunderbolt_ross",
+      "thunderbolts",
+      "thundra",
+      "tiger_shark",
+      "tigra",
+      "timeslip",
+      "tinkerer",
+      "titania",
+      "titanium_man",
+      "toad",
+      "toad_men",
+      "tomas",
+      "tombstone",
+      "tomorrow_man",
+      "tony_stark",
+      "toro",
+      "toxin",
+      "trauma",
+      "triathlon",
+      "trish_tilby",
+      "triton",
+      "true_believers",
+      "turbo",
+      "tusk",
+      "tyger_tiger",
+      "typhoid_mary",
+      "tyrannus",
+      "ulik",
+      "ultimates",
+      "ultimatum",
+      "ultimo",
+      "ultragirl",
+      "ultron",
+      "umar",
+      "unicorn",
+      "union_jack",
+      "unus",
+      "valeria_richards",
+      "valkyrie",
+      "vampiro",
+      "vance_astro",
+      "vanisher",
+      "vapor",
+      "vargas",
+      "vector",
+      "veda",
+      "vengeance",
+      "venom",
+      "venus",
+      "vermin",
+      "vertigo",
+      "victor_mancha",
+      "vin_gonzales",
+      "vindicator",
+      "violations",
+      "viper",
+      "virginia_dare",
+      "vision",
+      "vivisector",
+      "vulcan",
+      "vulture",
+      "wallflower",
+      "wallop",
+      "wallow",
+      "war_machine",
+      "warbird",
+      "warbound",
+      "warhawk",
+      "warlock",
+      "warpath",
+      "warstar",
+      "wasp",
+      "weapon_omega",
+      "wendell_rand",
+      "wendell_vaughn",
+      "wendigo",
+      "whiplash",
+      "whirlwind",
+      "whistler",
+      "white_queen",
+      "white_tiger",
+      "whizzer",
+      "wiccan",
+      "wild_child",
+      "wild_pack",
+      "wildside",
+      "william_stryker",
+      "wilson_fisk",
+      "wind_dancer",
+      "winter_soldier",
+      "wither",
+      "wolf_cub",
+      "wolfpack",
+      "wolfsbane",
+      "wolverine",
+      "wonder_man",
+      "wong",
+      "wraith",
+      "wrecker",
+      "wrecking_crew",
+      "xavin",
+      "xorn",
+      "yellow_claw",
+      "yellowjacket",
+      "young_avengers",
+      "zaladane",
+      "zaran",
+      "zarda",
+      "zarek",
+      "zeigeist",
+      "zemo",
+      "zodiak",
+      "zombie",
+      "zuras",
+      "zzzax"
+    ];
+  }
+});
+
 // src/cli/commands/migrate.ts
 var migrate_exports = {};
 __export(migrate_exports, {
@@ -21127,15 +22646,16 @@ __export(migrate_exports, {
   prepareAndMigratePg: () => prepareAndMigratePg,
   prepareAndMigrateSqlite: () => prepareAndMigrateSqlite,
   prepareSQL: () => prepareSQL,
-  prepareSnapshotFolderName: () => prepareSnapshotFolderName
+  prepareSnapshotFolderName: () => prepareSnapshotFolderName,
+  writeResult: () => writeResult
 });
-var import_fs4, import_path2, import_hanji2, prepareAndMigratePg, prepareAndMigrateSqlite, prepareAndMigrateMySql, prepareSQL, promptColumnsConflicts, promptTablesConflict, promptSchemasConflict, writeResult, prepareSnapshotFolderName, two;
+var import_fs4, import_path3, import_hanji2, prepareAndMigratePg, prepareAndMigrateMySql, prepareAndMigrateSqlite, prepareSQL, promptColumnsConflicts, promptTablesConflict, promptSchemasConflict, writeResult, prepareSnapshotFolderName, two;
 var init_migrate = __esm({
   "src/cli/commands/migrate.ts"() {
     import_fs4 = __toESM(require("fs"));
     init_migrationPreparator();
     init_snapshotsDiffer();
-    import_path2 = __toESM(require("path"));
+    import_path3 = __toESM(require("path"));
     import_hanji2 = __toESM(require_hanji());
     init_views();
     init_source();
@@ -21143,68 +22663,68 @@ var init_migrate = __esm({
     init_sqliteSchema();
     init_mysqlSchema();
     init_utils();
+    init_words();
     prepareAndMigratePg = async (config) => {
       const outFolder = config.out;
       const schemaPath = config.schema;
       try {
-        const { migrationFolders } = prepareMigrationFolder(outFolder, "pg");
-        const { prev, cur } = preparePgMigrationSnapshot(
-          migrationFolders,
-          outFolder,
-          schemaPath
-        );
+        assertV1OutFolder(outFolder, "pg");
+        const { snapshots, journal } = prepareMigrationFolder(outFolder, "pg");
+        const { prev, cur } = preparePgMigrationSnapshot(snapshots, schemaPath);
         const validatedPrev = pgSchema.parse(prev);
         const validatedCur = pgSchema.parse(cur);
         const squashedPrev = squashPgScheme(validatedPrev);
         const squashedCur = squashPgScheme(validatedCur);
-        const sql = await prepareSQL(squashedPrev, squashedCur, "pg");
-        writeResult(cur, sql, outFolder);
+        const { statements, sql, _meta } = await prepareSQL(
+          squashedPrev,
+          squashedCur,
+          "pg"
+        );
+        writeResult(cur, sql, snapshots.length, journal, _meta, outFolder);
       } catch (e) {
         console.error(e);
       }
     };
-    prepareAndMigrateSqlite = async (config) => {
+    prepareAndMigrateMySql = async (config) => {
       const outFolder = config.out;
       const schemaPath = config.schema;
       try {
-        const { migrationFolders } = prepareMigrationFolder(outFolder, "sqlite");
-        const { prev, cur } = prepareSqliteMigrationSnapshot(
-          migrationFolders,
-          outFolder,
-          schemaPath
+        assertV1OutFolder(outFolder, "mysql");
+        const { snapshots, journal } = prepareMigrationFolder(outFolder, "mysql");
+        const { prev, cur } = prepareMySqlMigrationSnapshot(snapshots, schemaPath);
+        const validatedPrev = mysqlSchema.parse(prev);
+        const validatedCur = mysqlSchema.parse(cur);
+        const squashedPrev = squashMysqlScheme(validatedPrev);
+        const squashedCur = squashMysqlScheme(validatedCur);
+        const { sql, _meta } = await prepareSQL(
+          squashedPrev,
+          squashedCur,
+          "sqlite"
         );
-        const validatedPrev = sqliteSchema.parse(prev);
-        const validatedCur = sqliteSchema.parse(cur);
-        const squashedPrev = squashSqliteScheme(validatedPrev);
-        const squashedCur = squashSqliteScheme(validatedCur);
-        const sql = await prepareSQL(squashedPrev, squashedCur, "sqlite");
-        writeResult(cur, sql, outFolder);
+        writeResult(cur, sql, snapshots.length, journal, _meta, outFolder);
       } catch (e) {
         console.error(e);
       }
     };
-    prepareAndMigrateMySql = async (config) => {
+    prepareAndMigrateSqlite = async (config) => {
       const outFolder = config.out;
       const schemaPath = config.schema;
       try {
-        const { migrationFolders } = prepareMigrationFolder(outFolder, "mysql");
-        const { prev, cur } = prepareMySqlMigrationSnapshot(
-          migrationFolders,
-          outFolder,
-          schemaPath
-        );
-        const validatedPrev = mysqlSchema.parse(prev);
-        const validatedCur = mysqlSchema.parse(cur);
-        const squashedPrev = squashMysqlScheme(validatedPrev);
-        const squashedCur = squashMysqlScheme(validatedCur);
-        const sql = await prepareSQL(squashedPrev, squashedCur, "mysql");
-        writeResult(cur, sql, outFolder);
+        assertV1OutFolder(outFolder, "sqlite");
+        const { snapshots, journal } = prepareMigrationFolder(outFolder, "sqlite");
+        const { prev, cur } = prepareSqliteMigrationSnapshot(snapshots, schemaPath);
+        const validatedPrev = sqliteSchema.parse(prev);
+        const validatedCur = sqliteSchema.parse(cur);
+        const squashedPrev = squashSqliteScheme(validatedPrev);
+        const squashedCur = squashSqliteScheme(validatedCur);
+        const { sql, _meta } = await prepareSQL(squashedPrev, squashedCur, "mysql");
+        writeResult(cur, sql, snapshots.length, journal, _meta, outFolder);
       } catch (e) {
         console.error(e);
       }
     };
     prepareSQL = async (prev, cur, dialect6) => {
-      const schemasResolver = async (input) => {
+      const schemasResolver2 = async (input) => {
         try {
           const { created, deleted, renamed } = await promptSchemasConflict(
             input.created,
@@ -21216,7 +22736,7 @@ var init_migrate = __esm({
           throw e;
         }
       };
-      const tablesResolver = async (input) => {
+      const tablesResolver2 = async (input) => {
         try {
           const { created, deleted, renamed } = await promptTablesConflict(
             input.created,
@@ -21228,7 +22748,7 @@ var init_migrate = __esm({
           throw e;
         }
       };
-      const columnsResolver = async (input) => {
+      const columnsResolver2 = async (input) => {
         const result = await promptColumnsConflicts(
           input.tableName,
           input.created,
@@ -21245,9 +22765,9 @@ var init_migrate = __esm({
         prev,
         cur,
         dialect6,
-        schemasResolver,
-        tablesResolver,
-        columnsResolver
+        schemasResolver2,
+        tablesResolver2,
+        columnsResolver2
       );
     };
     promptColumnsConflicts = async (tableName, newColumns, missingColumns) => {
@@ -21382,24 +22902,34 @@ var init_migrate = __esm({
       result.deleted.push(...leftMissing);
       return result;
     };
-    writeResult = (cur, sql, outFolder) => {
+    writeResult = (cur, sql, idx, journal, _meta, outFolder) => {
       console.log(schema(cur));
       if (sql.length === 0) {
         console.log("No schema changes, nothing to migrate \u{1F634}");
         return;
       }
+      const { prefix, tag } = prepareMigrationMetadata(idx);
       const toSave = JSON.parse(JSON.stringify(cur));
-      const folderName = prepareSnapshotFolderName();
-      const migrationFolderPath = `./${outFolder}/${folderName}`;
-      import_fs4.default.mkdirSync(migrationFolderPath);
+      toSave["_meta"] = _meta;
+      const metaFolderPath = (0, import_path3.join)(outFolder, "meta");
+      const metaJournal = (0, import_path3.join)(metaFolderPath, "_journal.json");
       import_fs4.default.writeFileSync(
-        `${migrationFolderPath}/snapshot.json`,
+        (0, import_path3.join)(metaFolderPath, `${prefix}_snapshot.json`),
         JSON.stringify(toSave, null, 2)
       );
-      import_fs4.default.writeFileSync(`${migrationFolderPath}/migration.sql`, sql);
-      console.log(
-        source_default.bold.green("Done:"),
-        import_path2.default.join(`${migrationFolderPath}/migration.sql`)
+      journal.entries.push({
+        idx,
+        when: +new Date(),
+        tag
+      });
+      import_fs4.default.writeFileSync(metaJournal, JSON.stringify(journal, null, 2));
+      import_fs4.default.writeFileSync(`${outFolder}/${tag}.sql`, sql);
+      (0, import_hanji2.render)(
+        `[${source_default.green(
+          "\u2713"
+        )}] Your SQL migration file \u279C ${source_default.bold.underline.blue(
+          import_path3.default.join(`${outFolder}/${tag}.sql`)
+        )} \u{1F680}`
       );
     };
     prepareSnapshotFolderName = () => {
@@ -21436,6 +22966,9 @@ var init_utils2 = __esm({
         return group.toUpperCase().replace("-", "").replace("_", "").replace(" ", "");
       });
     };
+    Array.prototype.random = function() {
+      return this[~~(Math.random() * this.length)];
+    };
   }
 });
 
@@ -26298,14 +27831,14 @@ var {
 } = import_index.default;
 
 // src/cli/index.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 init_lib();
 
 // src/cli/commands/check.ts
 init_utils();
 var checkHandler = (out, dialect6) => {
-  const migrationFolders = prepareOutFolders(out);
-  const report = validateWithReport(out, migrationFolders, dialect6);
+  const { snapshots } = prepareOutFolder(out, dialect6);
+  const report = validateWithReport(snapshots, dialect6);
   if (report.nonLatest.length > 0) {
     console.log(
       report.nonLatest.map((it) => {
@@ -26341,7 +27874,7 @@ var checkHandler = (out, dialect6) => {
 // src/cli/index.ts
 var import_hanji4 = __toESM(require_hanji());
 init_views();
-var import_path6 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 
 // src/cli/utils.ts
 init_views();
@@ -26388,7 +27921,7 @@ init_source();
 // package.json
 var package_default = {
   name: "drizzle-kit",
-  version: "0.16.8",
+  version: "0.16.9",
   repository: "https://github.com/drizzle-team/drizzle-kit-mirror",
   author: "Alex Blokh <aleksandrblokh@gmail.com>",
   license: "MIT",
@@ -26466,13 +27999,15 @@ init_utils();
 init_source();
 var import_crypto2 = require("crypto");
 var import_fs5 = require("fs");
-var import_path3 = __toESM(require("path"));
+var import_path4 = __toESM(require("path"));
 init_global();
 init_pgSchema();
 init_utils();
 var upPgHandler = (out) => {
-  const migrationFolders = prepareOutFolders(out);
-  const report = validateWithReport(out, migrationFolders, "pg");
+};
+var upPgHandlerV4 = (out) => {
+  const { snapshots } = prepareOutFolder(out, "pg");
+  const report = validateWithReport(snapshots, "pg");
   let prevId = originUUID;
   report.nonLatest.map((it) => ({
     folder: it,
@@ -26482,10 +28017,10 @@ var upPgHandler = (out) => {
     const result = updateToLatest(it.raw, prevId);
     prevId = result.id;
     console.log(
-      `[${source_default.green("\u2713")}] ${import_path3.default.join(out, folder, "snapshot.json")}`
+      `[${source_default.green("\u2713")}] ${import_path4.default.join(out, folder, "snapshot.json")}`
     );
     (0, import_fs5.writeFileSync)(
-      import_path3.default.join(out, folder, "snapshot.json"),
+      import_path4.default.join(out, folder, "snapshot.json"),
       JSON.stringify(result, null, 2)
     );
   });
@@ -26655,12 +28190,12 @@ var update3to4 = (json) => {
 // src/cli/commands/sqliteUp.ts
 init_source();
 var import_fs6 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 init_sqliteSchema();
 init_utils();
 var upSqliteHandler = (out) => {
-  const migrationFolders = prepareOutFolders(out);
-  const report = validateWithReport(out, migrationFolders, "sqlite");
+  const { snapshots } = prepareOutFolder(out, "sqlite");
+  const report = validateWithReport(snapshots, "sqlite");
   report.nonLatest.map((it) => ({
     folder: it,
     raw: report.rawMap[it]
@@ -26668,10 +28203,10 @@ var upSqliteHandler = (out) => {
     const folder = it.folder;
     const result = updateToLatest2(it.raw);
     console.log(
-      `[${source_default.green("\u2713")}] ${import_path4.default.join(out, folder, "snapshot.json")}`
+      `[${source_default.green("\u2713")}] ${import_path5.default.join(out, folder, "snapshot.json")}`
     );
     import_fs6.default.writeFileSync(
-      import_path4.default.join(out, folder, "snapshot.json"),
+      import_path5.default.join(out, folder, "snapshot.json"),
       JSON.stringify(result, null, 2)
     );
   });
@@ -26703,12 +28238,12 @@ var updateV3toV4 = (old) => {
 // src/cli/commands/mysqlUp.ts
 init_source();
 var import_fs7 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 init_mysqlSchema();
 init_utils();
 var upMysqlHandler = (out) => {
-  const migrationFolders = prepareOutFolders(out);
-  const report = validateWithReport(out, migrationFolders, "mysql");
+  const { snapshots } = prepareOutFolder(out, "mysql");
+  const report = validateWithReport(snapshots, "mysql");
   report.nonLatest.map((it) => ({
     folder: it,
     raw: report.rawMap[it]
@@ -26716,10 +28251,10 @@ var upMysqlHandler = (out) => {
     const folder = it.folder;
     const result = updateToLatest3(it.raw);
     console.log(
-      `[${source_default.green("\u2713")}] ${import_path5.default.join(out, folder, "snapshot.json")}`
+      `[${source_default.green("\u2713")}] ${import_path6.default.join(out, folder, "snapshot.json")}`
     );
     import_fs7.default.writeFileSync(
-      import_path5.default.join(out, folder, "snapshot.json"),
+      import_path6.default.join(out, folder, "snapshot.json"),
       JSON.stringify(result, null, 2)
     );
   });
@@ -26742,6 +28277,273 @@ var updateV3toV42 = (old) => {
   };
 };
 
+// src/cli/commands/upFolders.ts
+var import_fs8 = require("fs");
+var import_path7 = require("path");
+init_jsonDiffer();
+init_snapshotsDiffer();
+init_utils();
+init_words();
+init_pgSchema();
+var schemasResolver = (missingSchemas, newSchemas, sql) => {
+  try {
+    if (missingSchemas.length === 0 || newSchemas.length === 0) {
+      return { created: newSchemas, renamed: [], deleted: missingSchemas };
+    }
+    const result = { created: [], renamed: [], deleted: [] };
+    let index4 = 0;
+    let leftMissing = [...missingSchemas];
+    do {
+      const created = newSchemas[index4];
+      index4 += 1;
+      const possibleRenames = leftMissing.map((it) => {
+        return {
+          value: it,
+          sql: `ALTER SCHEMA "${it.name}" RENAME TO "${created.name}"`
+        };
+      });
+      const renames = possibleRenames.filter((it) => {
+        return sql.includes(it.sql);
+      });
+      if (renames.length > 1)
+        throw new Error("wtf");
+      if (renames.length === 0) {
+        result.created.push(created);
+      } else {
+        const it = renames[0];
+        result.renamed.push({ from: it.value, to: created });
+        delete leftMissing[leftMissing.indexOf(it.value)];
+        leftMissing = leftMissing.filter(Boolean);
+      }
+    } while (index4 < newSchemas.length);
+    result.deleted.push(...leftMissing);
+    return result;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+};
+var tablesResolver = (missingTables, newTables, sql) => {
+  try {
+    if (missingTables.length === 0 || newTables.length === 0) {
+      return { created: newTables, renamed: [], deleted: missingTables };
+    }
+    const result = { created: [], renamed: [], deleted: [] };
+    let index4 = 0;
+    let leftMissing = [...missingTables];
+    do {
+      const created = newTables[index4];
+      index4 += 1;
+      const possibleRenames = leftMissing.map((it) => {
+        const schemaPrefix = created.schema ? `"${created.schema}".` : "";
+        return {
+          value: it,
+          sql: `ALTER TABLE ${schemaPrefix}"${it.name}" RENAME TO ${schemaPrefix}"${created.name}"`
+        };
+      });
+      const renames = possibleRenames.filter((it) => {
+        return sql.includes(it.sql);
+      });
+      if (renames.length > 1)
+        throw new Error("wtf");
+      if (renames.length === 0) {
+        result.created.push(created);
+      } else {
+        const it = renames[0];
+        result.renamed.push({ from: it.value, to: created });
+        delete leftMissing[leftMissing.indexOf(it.value)];
+        leftMissing = leftMissing.filter(Boolean);
+      }
+    } while (index4 < newTables.length);
+    result.deleted.push(...leftMissing);
+    return result;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+};
+var columnsResolver = (tableName, missingColumns, newColumns, sql) => {
+  try {
+    if (missingColumns.length === 0 || newColumns.length === 0) {
+      return { created: newColumns, renamed: [], deleted: missingColumns };
+    }
+    const result = { created: [], renamed: [], deleted: [] };
+    let index4 = 0;
+    let leftMissing = [...missingColumns];
+    do {
+      const created = newColumns[index4];
+      index4 += 1;
+      const possibleRenames = leftMissing.map((it) => {
+        return {
+          value: it,
+          sql: `ALTER TABLE ${tableName} RENAME COLUMN "${it.name}" TO "${created.name}"`
+        };
+      });
+      const renames = possibleRenames.filter((it) => {
+        return sql.includes(it.sql);
+      });
+      if (renames.length > 1)
+        throw new Error("wtf");
+      if (renames.length === 0) {
+        result.created.push(created);
+      } else {
+        const it = renames[0];
+        result.renamed.push({ from: it.value, to: created });
+        delete leftMissing[leftMissing.indexOf(it.value)];
+        leftMissing = leftMissing.filter(Boolean);
+      }
+    } while (index4 < newColumns.length);
+    result.deleted.push(...leftMissing);
+    return result;
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
+};
+var fullfill = (prev, cur, sql) => {
+  const b = pgSchemaV4.parse(cur);
+  if (!prev) {
+    return {
+      version: "5",
+      dialect: b.dialect,
+      id: b.id,
+      prevId: b.prevId,
+      tables: b.tables,
+      enums: b.enums,
+      schemas: b.schemas,
+      _meta: {
+        schemas: {},
+        tables: {},
+        columns: {}
+      }
+    };
+  }
+  const a = pgSchemaV4.parse(prev);
+  const json1 = squashPgScheme(a);
+  const json2 = squashPgScheme(b);
+  const diffResult = applyJsonDiff(json1, json2);
+  const parseResult = diffResultScheme.safeParse(diffResult);
+  if (!parseResult.success) {
+    parseResult.error.errors.forEach((it) => {
+      console.error(it);
+    });
+    throw new Error();
+  }
+  const typedResult = parseResult.data;
+  const { renamed: renamedSchemas } = schemasResolver(
+    typedResult.deletedSchemas.map((it) => ({ name: it })),
+    typedResult.addedSchemas.map((it) => ({ name: it })),
+    sql
+  );
+  const { renamed } = tablesResolver(
+    typedResult.deletedTables,
+    typedResult.addedTables,
+    sql
+  );
+  const renamedWithAlternations = Object.values(
+    alteredTableScheme.array().parse(diffForRenamedTables(renamed))
+  );
+  const allAltered = typedResult.alteredTablesWithColumns.concat(
+    renamedWithAlternations
+  );
+  const rSchemas = renamedSchemas.map((it) => ({ from: it.from.name, to: it.to.name }));
+  const rTables = renamed.map((it) => {
+    return { from: it.from, to: it.to };
+  });
+  const rColumns = allAltered.map((table4) => {
+    const name = table4.name;
+    const result = columnsResolver(name, table4.deleted, table4.added, sql);
+    const tableName = table4.name;
+    const schema4 = typeof table4.schema === "string" ? table4.schema : "";
+    return result.renamed.map((it) => {
+      return {
+        from: { schema: schema4, table: tableName, column: it.from.name },
+        to: { schema: schema4, table: tableName, column: it.to.name }
+      };
+    });
+  }).flat();
+  const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
+  const bpatched = {
+    version: "5",
+    dialect: b.dialect,
+    id: b.id,
+    prevId: b.prevId,
+    tables: b.tables,
+    enums: b.enums,
+    schemas: b.schemas,
+    _meta
+  };
+  pgSchema.parse(bpatched);
+  return {
+    version: "5",
+    dialect: b.dialect,
+    id: b.id,
+    prevId: b.prevId,
+    tables: b.tables,
+    enums: b.enums,
+    schemas: b.schemas,
+    _meta
+  };
+};
+var upgradeFolders = (dialect6, out) => {
+  const oldMigrationFolders = (0, import_fs8.readdirSync)(out).filter(
+    (it) => it.length === 14 && /^\d+$/.test(it)
+  );
+  oldMigrationFolders.sort();
+  const res = oldMigrationFolders.reduce(
+    (res2, it) => {
+      const date = new Date();
+      date.setUTCFullYear(Number(it.substring(0, 4)));
+      date.setUTCMonth(Number(it.substring(4, 6)));
+      date.setUTCDate(Number(it.substring(6, 8)));
+      date.setUTCHours(Number(it.substring(8, 10)));
+      date.setUTCMinutes(Number(it.substring(10, 12)));
+      date.setUTCSeconds(Number(it.substring(12, 14)));
+      const path5 = (0, import_path7.join)(out, it);
+      const pathJson = (0, import_path7.join)(out, it, "snapshot.json");
+      const pathSQL = (0, import_path7.join)(out, it, "migration.sql");
+      const snapshot = JSON.parse((0, import_fs8.readFileSync)(pathJson).toString());
+      const sql = (0, import_fs8.readFileSync)(pathSQL).toString();
+      res2.entries.push({
+        idx: res2.idx,
+        json: snapshot,
+        date,
+        sql,
+        path: path5
+      });
+      res2.idx += 1;
+      return res2;
+    },
+    {
+      entries: [],
+      idx: 0
+    }
+  );
+  const metaFolder = (0, import_path7.join)(`${out}`, "meta");
+  if (!(0, import_fs8.existsSync)(metaFolder)) {
+    (0, import_fs8.mkdirSync)(metaFolder, { recursive: true });
+  }
+  const journal = dryJournal(dialect6);
+  let prev = void 0;
+  res.entries.forEach((it) => {
+    const { prefix, suffix, tag } = prepareMigrationMetadata(it.idx);
+    journal.entries.push({
+      idx: it.idx,
+      when: +it.date,
+      tag
+    });
+    const patchedJSON = fullfill(prev, it.json, it.sql);
+    (0, import_fs8.writeFileSync)(
+      (0, import_path7.join)(`${out}`, "meta", `${prefix}_snapshot.json`),
+      JSON.stringify(patchedJSON)
+    );
+    (0, import_fs8.writeFileSync)((0, import_path7.join)(`${out}`, `${tag}.sql`), it.sql);
+    (0, import_fs8.rmSync)(it.path, { recursive: true });
+    prev = it.json;
+  });
+  (0, import_fs8.writeFileSync)((0, import_path7.join)(metaFolder, "_journal.json"), JSON.stringify(journal));
+};
+
 // src/cli/index.ts
 var printVersions = () => {
   console.log(`${source_default.gray(versions())}
@@ -26750,13 +28552,13 @@ var printVersions = () => {
 var assertEitherConfigOrOut = (config, out) => {
   if (out)
     return out;
-  if (!(0, import_fs8.existsSync)(import_path6.default.join(import_path6.default.resolve(config)))) {
+  if (!(0, import_fs9.existsSync)(import_path8.default.join(import_path8.default.resolve(config)))) {
     console.log(`${config} file does not exist`);
     process.exit(1);
   }
   console.log(`Reading ${config}`);
   const drizzleConfig = JSON.parse(
-    import_fs8.default.readFileSync(import_path6.default.join(import_path6.default.resolve(config))).toString()
+    import_fs9.default.readFileSync(import_path8.default.join(import_path8.default.resolve(config))).toString()
   );
   return drizzleConfig.out;
 };
@@ -26826,7 +28628,7 @@ var prepareGenerateConfig = (options) => {
   if (!(schema4 || out)) {
     const path5 = config != null ? config : "drizzle.config.json";
     const drizzleConfig = JSON.parse(
-      import_fs8.default.readFileSync(import_path6.default.join(import_path6.default.resolve(path5))).toString()
+      import_fs9.default.readFileSync(import_path8.default.join(import_path8.default.resolve(path5))).toString()
     );
     return drizzleConfig;
   }
@@ -26874,6 +28676,8 @@ var upPgCommand = new Command("up:pg").option("--out <out>", `Output folder`).op
     process.exit(0);
   }
   assertPackages("drizzle-orm");
+  upPgHandlerV4(out);
+  upgradeFolders("pg", out);
   upPgHandler(out);
 });
 var upMysqlCommand = new Command("up:mysql").option("--out <out>", `Output folder`).option("--config <config>", `Config path [default=drizzle.config.json]`).action((options) => {
@@ -26921,29 +28725,18 @@ var introspectPgCommand = new Command("introspect:pg").option("--out <out>", `Mi
     console.log("Missing required params");
     return;
   }
-  const migrationFolders = prepareOutFolders(res.data.out);
-  const folderName = prepareSnapshotFolderName();
-  const migrationFolderPath = `./${res.data.out}/${folderName}`;
+  const { snapshots, journal } = prepareOutFolder(res.data.out, "pg");
   const { schema: schema4, ts } = await pgIntrospect2(res.data);
-  const schemaFile = import_path6.default.join(res.data.out, "schema.ts");
-  (0, import_fs8.writeFileSync)(schemaFile, ts);
+  const schemaFile = import_path8.default.join(res.data.out, "schema.ts");
+  (0, import_fs9.writeFileSync)(schemaFile, ts);
   console.log();
-  if (migrationFolders.length === 0) {
-    import_fs8.default.mkdirSync(migrationFolderPath);
-    const snapshotFile = import_path6.default.join(migrationFolderPath, "snapshot.json");
-    (0, import_fs8.writeFileSync)(snapshotFile, JSON.stringify(schema4));
-    const sql = await prepareSQL(
+  if (snapshots.length === 0) {
+    const { sql, _meta } = await prepareSQL(
       squashPgScheme(dryPg),
       squashPgScheme(schema4),
       "pg"
     );
-    const sqlFile = import_path6.default.join(migrationFolderPath, "migration.sql");
-    (0, import_fs8.writeFileSync)(sqlFile, sql);
-    (0, import_hanji4.render)(
-      `[${source_default.green(
-        "\u2713"
-      )}] Your SQL migration file \u279C ${source_default.bold.underline.blue(sqlFile)} \u{1F680}`
-    );
+    writeResult(schema4, sql, 0, journal, _meta, res.data.out);
   } else {
     (0, import_hanji4.render)(
       `[${source_default.blue(