@xubylele/schema-forge 1.7.0 → 1.8.1

package/dist/api.js

@@ -0,0 +1,3632 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/@xubylele/schema-forge-core/dist/core/parser.js
+function parseSchema(source) {
+  const lines = source.split("\n");
+  const tables = {};
+  let currentLine = 0;
+  const validBaseColumnTypes = /* @__PURE__ */ new Set([
+    "uuid",
+    "varchar",
+    "text",
+    "int",
+    "bigint",
+    "boolean",
+    "timestamptz",
+    "date"
+  ]);
+  const validIdentifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  function normalizeColumnType6(type) {
+    return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+  }
+  function isValidColumnType2(type) {
+    const normalizedType = normalizeColumnType6(type);
+    if (validBaseColumnTypes.has(normalizedType)) {
+      return true;
+    }
+    const varcharMatch = normalizedType.match(/^varchar\((\d+)\)$/);
+    if (varcharMatch) {
+      const length = Number(varcharMatch[1]);
+      return Number.isInteger(length) && length > 0;
+    }
+    const numericMatch = normalizedType.match(/^numeric\((\d+),(\d+)\)$/);
+    if (numericMatch) {
+      const precision = Number(numericMatch[1]);
+      const scale = Number(numericMatch[2]);
+      return Number.isInteger(precision) && Number.isInteger(scale) && precision > 0 && scale >= 0 && scale <= precision;
+    }
+    return false;
+  }
+  function validateIdentifier(identifier, lineNum, context) {
+    if (!validIdentifierPattern.test(identifier)) {
+      throw new Error(`Line ${lineNum}: Invalid ${context} name '${identifier}'. Use letters, numbers, and underscores, and do not start with a number.`);
+    }
+  }
+  function validateDefaultValue(value, lineNum) {
+    let parenBalance = 0;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let index = 0; index < value.length; index++) {
+      const char = value[index];
+      if (char === "'" && !inDoubleQuote) {
+        if (inSingleQuote && value[index + 1] === "'") {
+          index++;
+          continue;
+        }
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (char === '"' && !inSingleQuote) {
+        if (inDoubleQuote && value[index + 1] === '"') {
+          index++;
+          continue;
+        }
+        inDoubleQuote = !inDoubleQuote;
+        continue;
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        parenBalance++;
+        continue;
+      }
+      if (char === ")") {
+        parenBalance--;
+        if (parenBalance < 0) {
+          throw new Error(`Line ${lineNum}: Invalid default value '${value}'. Unmatched parentheses in function call.`);
+        }
+      }
+    }
+    if (inSingleQuote || inDoubleQuote) {
+      throw new Error(`Line ${lineNum}: Invalid default value '${value}'. Unterminated quoted string.`);
+    }
+    if (parenBalance > 0) {
+      if (parenBalance === 1) {
+        throw new Error(`Line ${lineNum}: Invalid default value '${value}'. Function call is missing closing parenthesis.`);
+      }
+      throw new Error(`Line ${lineNum}: Invalid default value '${value}'. Unmatched parentheses in function call.`);
+    }
+  }
+  function cleanLine(line) {
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let index = 0; index < line.length; index++) {
+      const char = line[index];
+      const nextChar = line[index + 1];
+      if (char === "'" && !inDoubleQuote) {
+        if (inSingleQuote && nextChar === "'") {
+          index++;
+          continue;
+        }
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (char === '"' && !inSingleQuote) {
+        if (inDoubleQuote && nextChar === '"') {
+          index++;
+          continue;
+        }
+        inDoubleQuote = !inDoubleQuote;
+        continue;
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue;
+      }
+      if (char === "#") {
+        line = line.substring(0, index);
+        break;
+      }
+      if (char === "/" && nextChar === "/") {
+        line = line.substring(0, index);
+        break;
+      }
+    }
+    return line.trim();
+  }
+  function parseForeignKey(fkRef, lineNum) {
+    const parts = fkRef.split(".");
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw new Error(`Line ${lineNum}: Invalid foreign key format '${fkRef}'. Expected format: table.column`);
+    }
+    validateIdentifier(parts[0], lineNum, "foreign key table");
+    validateIdentifier(parts[1], lineNum, "foreign key column");
+    return {
+      table: parts[0],
+      column: parts[1]
+    };
+  }
+  function parseColumn(line, lineNum) {
+    const tokens = line.split(/\s+/).filter((t) => t.length > 0);
+    const modifiers = /* @__PURE__ */ new Set(["pk", "unique", "nullable", "default", "fk"]);
+    const appliedModifiers = /* @__PURE__ */ new Set();
+    if (tokens.length < 2) {
+      throw new Error(`Line ${lineNum}: Invalid column definition. Expected: <name> <type> [modifiers...]`);
+    }
+    const colName = tokens[0];
+    const colType = normalizeColumnType6(tokens[1]);
+    validateIdentifier(colName, lineNum, "column");
+    if (!isValidColumnType2(colType)) {
+      throw new Error(`Line ${lineNum}: Invalid column type '${tokens[1]}'. Valid types: ${Array.from(validBaseColumnTypes).join(", ")}, varchar(n), numeric(p,s)`);
+    }
+    const column = {
+      name: colName,
+      type: colType,
+      nullable: true
+    };
+    let i = 2;
+    while (i < tokens.length) {
+      const modifier = tokens[i];
+      const markModifierApplied = (name) => {
+        if (appliedModifiers.has(name)) {
+          throw new Error(`Line ${lineNum}: Duplicate modifier '${name}'`);
+        }
+        appliedModifiers.add(name);
+      };
+      switch (modifier) {
+        case "pk":
+          markModifierApplied("pk");
+          column.primaryKey = true;
+          i++;
+          break;
+        case "unique":
+          markModifierApplied("unique");
+          column.unique = true;
+          i++;
+          break;
+        case "nullable":
+          if (appliedModifiers.has("not null")) {
+            throw new Error(`Line ${lineNum}: Cannot combine 'nullable' with 'not null'`);
+          }
+          markModifierApplied("nullable");
+          column.nullable = true;
+          i++;
+          break;
+        case "not":
+          if (tokens[i + 1] !== "null") {
+            throw new Error(`Line ${lineNum}: Unknown modifier 'not'`);
+          }
+          if (appliedModifiers.has("nullable")) {
+            throw new Error(`Line ${lineNum}: Cannot combine 'not null' with 'nullable'`);
+          }
+          markModifierApplied("not null");
+          column.nullable = false;
+          i += 2;
+          break;
+        case "default":
+          markModifierApplied("default");
+          i++;
+          if (i >= tokens.length) {
+            throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
+          }
+          {
+            const defaultTokens = [];
+            while (i < tokens.length && !modifiers.has(tokens[i]) && !(tokens[i] === "not" && tokens[i + 1] === "null")) {
+              defaultTokens.push(tokens[i]);
+              i++;
+            }
+            if (defaultTokens.length === 0) {
+              throw new Error(`Line ${lineNum}: 'default' modifier requires a value`);
+            }
+            const defaultValue = defaultTokens.join(" ");
+            validateDefaultValue(defaultValue, lineNum);
+            column.default = defaultValue;
+          }
+          break;
+        case "fk":
+          markModifierApplied("fk");
+          i++;
+          if (i >= tokens.length) {
+            throw new Error(`Line ${lineNum}: 'fk' modifier requires a table.column reference`);
+          }
+          column.foreignKey = parseForeignKey(tokens[i], lineNum);
+          i++;
+          break;
+        default:
+          throw new Error(`Line ${lineNum}: Unknown modifier '${modifier}'`);
+      }
+    }
+    return column;
+  }
+  function parseTableBlock(startLine) {
+    const firstLine = cleanLine(lines[startLine]);
+    const match = firstLine.match(/^table\s+(\w+)\s*\{\s*$/);
+    if (!match) {
+      throw new Error(`Line ${startLine + 1}: Invalid table definition. Expected: table <name> {`);
+    }
+    const tableName = match[1];
+    validateIdentifier(tableName, startLine + 1, "table");
+    if (tables[tableName]) {
+      throw new Error(`Line ${startLine + 1}: Duplicate table definition '${tableName}'`);
+    }
+    const columns = [];
+    let lineIdx = startLine + 1;
+    let foundClosingBrace = false;
+    while (lineIdx < lines.length) {
+      const cleaned = cleanLine(lines[lineIdx]);
+      if (!cleaned) {
+        lineIdx++;
+        continue;
+      }
+      if (cleaned === "}") {
+        foundClosingBrace = true;
+        break;
+      }
+      try {
+        const column = parseColumn(cleaned, lineIdx + 1);
+        columns.push(column);
+      } catch (error2) {
+        throw error2;
+      }
+      lineIdx++;
+    }
+    if (!foundClosingBrace) {
+      throw new Error(`Line ${startLine + 1}: Table '${tableName}' block not closed (missing '}')`);
+    }
+    const primaryKeyColumn = columns.find((column) => column.primaryKey)?.name ?? null;
+    tables[tableName] = {
+      name: tableName,
+      columns,
+      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
+    };
+    return lineIdx;
+  }
+  while (currentLine < lines.length) {
+    const cleaned = cleanLine(lines[currentLine]);
+    if (!cleaned) {
+      currentLine++;
+      continue;
+    }
+    if (cleaned.startsWith("table ")) {
+      currentLine = parseTableBlock(currentLine);
+    } else {
+      throw new Error(`Line ${currentLine + 1}: Unexpected content '${cleaned}'. Expected table definition.`);
+    }
+    currentLine++;
+  }
+  return { tables };
+}
+var init_parser = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/parser.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/normalize.js
+function normalizeIdent(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function pkName(table) {
+  return `pk_${normalizeIdent(table)}`;
+}
+function uqName(table, column) {
+  return `uq_${normalizeIdent(table)}_${normalizeIdent(column)}`;
+}
+function legacyPkName(table) {
+  return `${normalizeIdent(table)}_pkey`;
+}
+function legacyUqName(table, column) {
+  return `${normalizeIdent(table)}_${normalizeIdent(column)}_key`;
+}
+function normalizeSpacesOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let pendingSpace = false;
+  for (const char of value) {
+    if (char === "'" && !inDoubleQuote) {
+      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+        result += " ";
+      }
+      pendingSpace = false;
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+        result += " ";
+      }
+      pendingSpace = false;
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && /\s/.test(char)) {
+      pendingSpace = true;
+      continue;
+    }
+    if (pendingSpace && result.length > 0 && result[result.length - 1] !== " ") {
+      result += " ";
+    }
+    pendingSpace = false;
+    result += char;
+  }
+  return result.trim();
+}
+function normalizeKnownFunctionsOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let buffer = "";
+  function flushBuffer() {
+    if (!buffer) {
+      return;
+    }
+    result += buffer.replace(/\bnow\s*\(\s*\)/gi, "now()").replace(/\bgen_random_uuid\s*\(\s*\)/gi, "gen_random_uuid()");
+    buffer = "";
+  }
+  for (const char of value) {
+    if (char === "'" && !inDoubleQuote) {
+      flushBuffer();
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      flushBuffer();
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) {
+      result += char;
+      continue;
+    }
+    buffer += char;
+  }
+  flushBuffer();
+  return result;
+}
+function normalizePunctuationOutsideQuotes(value) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index];
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && (char === "(" || char === ")")) {
+      while (result.endsWith(" ")) {
+        result = result.slice(0, -1);
+      }
+      result += char;
+      let lookahead = index + 1;
+      while (lookahead < value.length && value[lookahead] === " ") {
+        lookahead++;
+      }
+      index = lookahead - 1;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && char === ",") {
+      while (result.endsWith(" ")) {
+        result = result.slice(0, -1);
+      }
+      result += ", ";
+      let lookahead = index + 1;
+      while (lookahead < value.length && value[lookahead] === " ") {
+        lookahead++;
+      }
+      index = lookahead - 1;
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}
+function normalizeDefault(expr) {
+  if (expr === void 0 || expr === null) {
+    return null;
+  }
+  const trimmed = expr.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  const normalizedSpacing = normalizeSpacesOutsideQuotes(trimmed);
+  const normalizedPunctuation = normalizePunctuationOutsideQuotes(normalizedSpacing);
+  return normalizeKnownFunctionsOutsideQuotes(normalizedPunctuation);
+}
+var init_normalize = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/normalize.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/diff.js
+function getTableNamesFromState(state) {
+  return new Set(Object.keys(state.tables));
+}
+function getTableNamesFromSchema(schema) {
+  return new Set(Object.keys(schema.tables));
+}
+function getColumnNamesFromState(stateColumns) {
+  return new Set(Object.keys(stateColumns));
+}
+function getColumnNamesFromSchema(dbColumns) {
+  return new Set(dbColumns.map((column) => column.name));
+}
+function getSortedNames(names) {
+  return Array.from(names).sort((a, b) => a.localeCompare(b));
+}
+function normalizeColumnType(type) {
+  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function resolveStatePrimaryKey(table) {
+  return table.primaryKey ?? Object.entries(table.columns).find(([, column]) => column.primaryKey)?.[0] ?? null;
+}
+function resolveSchemaPrimaryKey(table) {
+  return table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
+}
+function normalizeNullable(nullable) {
+  return nullable ?? true;
+}
+function diffSchemas(oldState, newSchema) {
+  const operations = [];
+  const oldTableNames = getTableNamesFromState(oldState);
+  const newTableNames = getTableNamesFromSchema(newSchema);
+  const sortedNewTableNames = getSortedNames(newTableNames);
+  const sortedOldTableNames = getSortedNames(oldTableNames);
+  for (const tableName of sortedNewTableNames) {
+    if (!oldTableNames.has(tableName)) {
+      operations.push({
+        kind: "create_table",
+        table: newSchema.tables[tableName]
+      });
+    }
+  }
+  const commonTableNames = sortedNewTableNames.filter((tableName) => oldTableNames.has(tableName));
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousType = normalizeColumnType(previousColumn.type);
+      const currentType = normalizeColumnType(column.type);
+      if (previousType !== currentType) {
+        operations.push({
+          kind: "column_type_changed",
+          tableName,
+          columnName: column.name,
+          fromType: previousColumn.type,
+          toType: column.type
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
+    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
+    if (previousPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
+      operations.push({
+        kind: "drop_primary_key_constraint",
+        tableName
+      });
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousUnique = previousColumn.unique ?? false;
+      const currentUnique = column.unique ?? false;
+      if (previousUnique !== currentUnique) {
+        operations.push({
+          kind: "column_unique_changed",
+          tableName,
+          columnName: column.name,
+          from: previousUnique,
+          to: currentUnique
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousNullable = normalizeNullable(previousColumn.nullable);
+      const currentNullable = normalizeNullable(column.nullable);
+      if (previousNullable !== currentNullable) {
+        operations.push({
+          kind: "column_nullability_changed",
+          tableName,
+          columnName: column.name,
+          from: previousNullable,
+          to: currentNullable
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    for (const column of newTable.columns) {
+      const previousColumn = oldTable.columns[column.name];
+      if (!previousColumn) {
+        continue;
+      }
+      const previousDefault = normalizeDefault(previousColumn.default);
+      const currentDefault = normalizeDefault(column.default);
+      if (previousDefault !== currentDefault) {
+        operations.push({
+          kind: "column_default_changed",
+          tableName,
+          columnName: column.name,
+          fromDefault: previousDefault,
+          toDefault: currentDefault
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const oldColumnNames = getColumnNamesFromState(oldTable.columns);
+    for (const column of newTable.columns) {
+      if (!oldColumnNames.has(column.name)) {
+        operations.push({
+          kind: "add_column",
+          tableName,
+          column
+        });
+      }
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const previousPrimaryKey = resolveStatePrimaryKey(oldTable);
+    const currentPrimaryKey = resolveSchemaPrimaryKey(newTable);
+    if (currentPrimaryKey !== null && previousPrimaryKey !== currentPrimaryKey) {
+      operations.push({
+        kind: "add_primary_key_constraint",
+        tableName,
+        columnName: currentPrimaryKey
+      });
+    }
+  }
+  for (const tableName of commonTableNames) {
+    const newTable = newSchema.tables[tableName];
+    const oldTable = oldState.tables[tableName];
+    if (!newTable || !oldTable) {
+      continue;
+    }
+    const newColumnNames = getColumnNamesFromSchema(newTable.columns);
+    for (const columnName of Object.keys(oldTable.columns)) {
+      if (!newColumnNames.has(columnName)) {
+        operations.push({
+          kind: "drop_column",
+          tableName,
+          columnName
+        });
+      }
+    }
+  }
+  for (const tableName of sortedOldTableNames) {
+    if (!newTableNames.has(tableName)) {
+      operations.push({
+        kind: "drop_table",
+        tableName
+      });
+    }
+  }
+  return { operations };
+}
+var init_diff = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/diff.js"() {
+    "use strict";
+    init_normalize();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/drift-analyzer.js
+function normalizeColumnType2(type) {
+  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function getSortedNames2(values) {
+  return Array.from(values).sort((left, right) => left.localeCompare(right));
+}
+function analyzeSchemaDrift(state, liveSchema) {
+  const stateTableNames = getSortedNames2(Object.keys(state.tables));
+  const liveTableNames = getSortedNames2(Object.keys(liveSchema.tables));
+  const liveTableNameSet = new Set(liveTableNames);
+  const stateTableNameSet = new Set(stateTableNames);
+  const missingTables = stateTableNames.filter((tableName) => !liveTableNameSet.has(tableName));
+  const extraTables = liveTableNames.filter((tableName) => !stateTableNameSet.has(tableName));
+  const commonTableNames = liveTableNames.filter((tableName) => stateTableNameSet.has(tableName));
+  const columnDifferences = [];
+  const typeMismatches = [];
+  for (const tableName of commonTableNames) {
+    const stateTable = state.tables[tableName];
+    const liveTable = liveSchema.tables[tableName];
+    if (!stateTable || !liveTable) {
+      continue;
+    }
+    const stateColumnNames = getSortedNames2(Object.keys(stateTable.columns));
+    const liveColumnsByName = new Map(liveTable.columns.map((column) => [column.name, column]));
+    const liveColumnNames = getSortedNames2(liveColumnsByName.keys());
+    const stateColumnNameSet = new Set(stateColumnNames);
+    const liveColumnNameSet = new Set(liveColumnNames);
+    const missingInLive = stateColumnNames.filter((columnName) => !liveColumnNameSet.has(columnName));
+    const extraInLive = liveColumnNames.filter((columnName) => !stateColumnNameSet.has(columnName));
+    if (missingInLive.length > 0 || extraInLive.length > 0) {
+      columnDifferences.push({
+        tableName,
+        missingInLive,
+        extraInLive
+      });
+    }
+    const commonColumns = stateColumnNames.filter((columnName) => liveColumnNameSet.has(columnName));
+    for (const columnName of commonColumns) {
+      const stateColumn = stateTable.columns[columnName];
+      const liveColumn = liveColumnsByName.get(columnName);
+      if (!stateColumn || !liveColumn) {
+        continue;
+      }
+      const expectedType = stateColumn.type;
+      const actualType = liveColumn.type;
+      if (normalizeColumnType2(expectedType) !== normalizeColumnType2(actualType)) {
+        typeMismatches.push({
+          tableName,
+          columnName,
+          expectedType,
+          actualType
+        });
+      }
+    }
+  }
+  return {
+    missingTables,
+    extraTables,
+    columnDifferences,
+    typeMismatches
+  };
+}
+var init_drift_analyzer = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/drift-analyzer.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/validator.js
+function isValidColumnType(type) {
+  const normalizedType = type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+  if (VALID_BASE_COLUMN_TYPES.includes(normalizedType)) {
+    return true;
+  }
+  return /^varchar\(\d+\)$/.test(normalizedType) || /^numeric\(\d+,\d+\)$/.test(normalizedType);
+}
+function validateSchema(schema) {
+  validateDuplicateTables(schema);
+  for (const tableName in schema.tables) {
+    const table = schema.tables[tableName];
+    validateTableColumns(tableName, table, schema.tables);
+  }
+}
+function validateDuplicateTables(schema) {
+  const tableNames = Object.keys(schema.tables);
+  const seen = /* @__PURE__ */ new Set();
+  for (const tableName of tableNames) {
+    if (seen.has(tableName)) {
+      throw new Error(`Duplicate table: '${tableName}'`);
+    }
+    seen.add(tableName);
+  }
+}
+function validateTableColumns(tableName, table, allTables) {
+  const columnNames = /* @__PURE__ */ new Set();
+  const primaryKeyColumns = [];
+  for (const column of table.columns) {
+    if (columnNames.has(column.name)) {
+      throw new Error(`Table '${tableName}': duplicate column '${column.name}'`);
+    }
+    columnNames.add(column.name);
+    if (column.primaryKey) {
+      primaryKeyColumns.push(column.name);
+    }
+    if (!isValidColumnType(column.type)) {
+      throw new Error(`Table '${tableName}', column '${column.name}': type '${column.type}' is not valid. Supported types: ${VALID_BASE_COLUMN_TYPES.join(", ")}, varchar(n), numeric(p,s)`);
+    }
+    if (column.foreignKey) {
+      const fkTable = column.foreignKey.table;
+      const fkColumn = column.foreignKey.column;
+      if (!allTables[fkTable]) {
+        throw new Error(`Table '${tableName}', column '${column.name}': referenced table '${fkTable}' does not exist`);
+      }
+      const referencedTable = allTables[fkTable];
+      const columnExists = referencedTable.columns.some((col) => col.name === fkColumn);
+      if (!columnExists) {
+        throw new Error(`Table '${tableName}', column '${column.name}': table '${fkTable}' does not have column '${fkColumn}'`);
+      }
+    }
+  }
+  if (primaryKeyColumns.length > 1) {
+    throw new Error(`Table '${tableName}': can only have one primary key (found ${primaryKeyColumns.length})`);
+  }
+  const normalizedPrimaryKey = table.primaryKey ?? primaryKeyColumns[0] ?? null;
+  if (table.primaryKey && !columnNames.has(table.primaryKey)) {
+    throw new Error(`Table '${tableName}': primary key column '${table.primaryKey}' does not exist`);
+  }
+  if (table.primaryKey && primaryKeyColumns.length === 1 && primaryKeyColumns[0] !== table.primaryKey) {
+    throw new Error(`Table '${tableName}': column-level primary key '${primaryKeyColumns[0]}' does not match table primary key '${table.primaryKey}'`);
+  }
+  if (normalizedPrimaryKey) {
+    const pkMatches = table.columns.filter((column) => column.name === normalizedPrimaryKey);
+    if (pkMatches.length !== 1) {
+      throw new Error(`Table '${tableName}': primary key column '${normalizedPrimaryKey}' is invalid`);
+    }
+  }
+}
+var VALID_BASE_COLUMN_TYPES;
+var init_validator = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/validator.js"() {
+    "use strict";
+    VALID_BASE_COLUMN_TYPES = [
+      "uuid",
+      "varchar",
+      "text",
+      "int",
+      "bigint",
+      "boolean",
+      "timestamptz",
+      "date"
+    ];
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/safety/operation-classifier.js
+function normalizeColumnType3(type) {
+  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function parseVarcharLength(type) {
+  const match = normalizeColumnType3(type).match(/^varchar\((\d+)\)$/);
+  return match ? Number(match[1]) : null;
+}
+function parseNumericType(type) {
+  const match = normalizeColumnType3(type).match(/^numeric\((\d+),(\d+)\)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    precision: Number(match[1]),
+    scale: Number(match[2])
+  };
+}
+function classifyTypeChange(from, to) {
+  const fromType = normalizeColumnType3(from);
+  const toType = normalizeColumnType3(to);
+  const uuidInvolved = fromType === "uuid" || toType === "uuid";
+  if (uuidInvolved && fromType !== toType) {
+    return "DESTRUCTIVE";
+  }
+  if (fromType === "int" && toType === "bigint") {
+    return "WARNING";
+  }
+  if (fromType === "bigint" && toType === "int") {
+    return "DESTRUCTIVE";
+  }
+  if (fromType === "text" && parseVarcharLength(toType) !== null) {
+    return "DESTRUCTIVE";
+  }
+  if (parseVarcharLength(fromType) !== null && toType === "text") {
+    return "WARNING";
+  }
+  const fromVarcharLength = parseVarcharLength(fromType);
+  const toVarcharLength = parseVarcharLength(toType);
+  if (fromVarcharLength !== null && toVarcharLength !== null) {
+    if (toVarcharLength >= fromVarcharLength) {
+      return "WARNING";
+    }
+    return "DESTRUCTIVE";
+  }
+  const fromNumeric = parseNumericType(fromType);
+  const toNumeric = parseNumericType(toType);
+  if (fromNumeric && toNumeric && fromNumeric.scale === toNumeric.scale) {
+    if (toNumeric.precision >= fromNumeric.precision) {
+      return "WARNING";
+    }
+    return "DESTRUCTIVE";
+  }
+  return "WARNING";
+}
+function classifyOperation(operation) {
+  switch (operation.kind) {
+    case "create_table":
+      return "SAFE";
+    case "add_column":
+      return "SAFE";
+    case "drop_table":
+      return "DESTRUCTIVE";
+    case "drop_column":
+      return "DESTRUCTIVE";
+    case "column_type_changed":
+      return classifyTypeChange(operation.fromType, operation.toType);
+    case "column_nullability_changed":
+      if (operation.from && !operation.to) {
+        return "WARNING";
+      }
+      return "SAFE";
+    case "column_default_changed":
+      return "SAFE";
+    case "column_unique_changed":
+      return "SAFE";
+    case "drop_primary_key_constraint":
+      return "DESTRUCTIVE";
+    case "add_primary_key_constraint":
+      return "SAFE";
+    default:
+      const _exhaustive = operation;
+      return _exhaustive;
+  }
+}
+var init_operation_classifier = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/safety/operation-classifier.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/safety/safety-checker.js
+function normalizeColumnType4(type) {
+  return type.toLowerCase().trim().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function parseVarcharLength2(type) {
+  const match = normalizeColumnType4(type).match(/^varchar\((\d+)\)$/);
+  return match ? Number(match[1]) : null;
+}
+function parseNumericType2(type) {
+  const match = normalizeColumnType4(type).match(/^numeric\((\d+),(\d+)\)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    precision: Number(match[1]),
+    scale: Number(match[2])
+  };
+}
+function generateTypeChangeMessage(from, to) {
+  const fromType = normalizeColumnType4(from);
+  const toType = normalizeColumnType4(to);
+  const uuidInvolved = fromType === "uuid" || toType === "uuid";
+  if (uuidInvolved && fromType !== toType) {
+    return `Type changed from ${fromType} to ${toType} (likely incompatible cast)`;
+  }
+  if (fromType === "int" && toType === "bigint") {
+    return "Type widened from int to bigint";
+  }
+  if (fromType === "bigint" && toType === "int") {
+    return "Type narrowed from bigint to int (likely incompatible cast)";
+  }
+  if (fromType === "text" && parseVarcharLength2(toType) !== null) {
+    return `Type changed from text to ${toType} (may truncate existing values)`;
+  }
+  if (parseVarcharLength2(fromType) !== null && toType === "text") {
+    const length = parseVarcharLength2(fromType);
+    return `Type widened from varchar(${length}) to text`;
+  }
+  const fromVarcharLength = parseVarcharLength2(fromType);
+  const toVarcharLength = parseVarcharLength2(toType);
+  if (fromVarcharLength !== null && toVarcharLength !== null) {
+    if (toVarcharLength >= fromVarcharLength) {
+      return `Type widened from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`;
+    }
+    return `Type narrowed from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`;
+  }
+  const fromNumeric = parseNumericType2(fromType);
+  const toNumeric = parseNumericType2(toType);
+  if (fromNumeric && toNumeric && fromNumeric.scale === toNumeric.scale) {
+    if (toNumeric.precision >= fromNumeric.precision) {
+      return `Type widened from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`;
+    }
+    return `Type narrowed from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`;
+  }
+  return `Type changed from ${fromType} to ${toType} (compatibility unknown)`;
+}
+function checkOperationSafety(operation) {
+  const safetyLevel = classifyOperation(operation);
+  if (safetyLevel === "SAFE") {
+    return null;
+  }
+  switch (operation.kind) {
+    case "drop_table":
+      return {
+        safetyLevel,
+        code: "DROP_TABLE",
+        table: operation.tableName,
+        message: "Table removed",
+        operationKind: operation.kind
+      };
+    case "drop_column":
+      return {
+        safetyLevel,
+        code: "DROP_COLUMN",
+        table: operation.tableName,
+        column: operation.columnName,
+        message: "Column removed",
+        operationKind: operation.kind
+      };
+    case "column_type_changed":
+      return {
+        safetyLevel,
+        code: "ALTER_COLUMN_TYPE",
+        table: operation.tableName,
+        column: operation.columnName,
+        from: normalizeColumnType4(operation.fromType),
+        to: normalizeColumnType4(operation.toType),
+        message: generateTypeChangeMessage(operation.fromType, operation.toType),
+        operationKind: operation.kind
+      };
+    case "column_nullability_changed":
+      if (operation.from && !operation.to) {
+        return {
+          safetyLevel,
+          code: "SET_NOT_NULL",
+          table: operation.tableName,
+          column: operation.columnName,
+          message: "Column changed to NOT NULL (may fail if data contains NULLs)",
+          operationKind: operation.kind
+        };
+      }
+      return null;
+    case "drop_primary_key_constraint":
+      return {
+        safetyLevel,
+        code: "DROP_TABLE",
+        // Reuse code for primary key drops
+        table: operation.tableName,
+        message: "Primary key constraint removed",
+        operationKind: operation.kind
+      };
+    default:
+      return null;
+  }
+}
+function checkSchemaSafety(previousState, currentSchema) {
+  const findings = [];
+  const diff2 = diffSchemas(previousState, currentSchema);
+  for (const operation of diff2.operations) {
+    const finding = checkOperationSafety(operation);
+    if (finding) {
+      findings.push(finding);
+    }
+  }
+  const hasWarnings = findings.some((f) => f.safetyLevel === "WARNING");
+  const hasDestructiveOps = findings.some((f) => f.safetyLevel === "DESTRUCTIVE");
+  return {
+    findings,
+    hasSafeIssues: false,
+    // All findings are non-safe by definition
+    hasWarnings,
+    hasDestructiveOps
+  };
+}
+var init_safety_checker = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/safety/safety-checker.js"() {
+    "use strict";
+    init_diff();
+    init_operation_classifier();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/safety/index.js
+var init_safety = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/safety/index.js"() {
+    "use strict";
+    init_operation_classifier();
+    init_safety_checker();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/validate.js
+function safetyLevelToSeverity(level) {
+  if (level === "DESTRUCTIVE") {
+    return "error";
+  }
+  return "warning";
+}
+function adaptSafetyFinding(finding) {
+  return {
+    severity: safetyLevelToSeverity(finding.safetyLevel),
+    code: finding.code,
+    table: finding.table,
+    column: finding.column,
+    from: finding.from,
+    to: finding.to,
+    message: finding.message
+  };
+}
+function validateSchemaChanges(previousState, currentSchema) {
+  const safetyReport = checkSchemaSafety(previousState, currentSchema);
+  return safetyReport.findings.map(adaptSafetyFinding);
+}
+function toValidationReport(findings) {
+  const errors = findings.filter((finding) => finding.severity === "error");
+  const warnings = findings.filter((finding) => finding.severity === "warning");
+  return {
+    hasErrors: errors.length > 0,
+    hasWarnings: warnings.length > 0,
+    errors: errors.map(({ severity, ...finding }) => finding),
+    warnings: warnings.map(({ severity, ...finding }) => finding)
+  };
+}
+var init_validate = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/validate.js"() {
+    "use strict";
+    init_safety();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/fs.js
+async function ensureDir2(dirPath) {
+  try {
+    await import_fs2.promises.mkdir(dirPath, { recursive: true });
+  } catch (error2) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
+  }
+}
+async function fileExists2(filePath) {
+  try {
+    await import_fs2.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile2(filePath) {
+  try {
+    return await import_fs2.promises.readFile(filePath, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to read file ${filePath}: ${error2}`);
+  }
+}
+async function writeTextFile2(filePath, content) {
+  try {
+    const dir = import_path3.default.dirname(filePath);
+    await ensureDir2(dir);
+    await import_fs2.promises.writeFile(filePath, content, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to write file ${filePath}: ${error2}`);
+  }
+}
+async function readJsonFile2(filePath, fallback) {
+  try {
+    const exists = await fileExists2(filePath);
+    if (!exists) {
+      return fallback;
+    }
+    const content = await readTextFile2(filePath);
+    return JSON.parse(content);
+  } catch (error2) {
+    throw new Error(`Failed to read JSON file ${filePath}: ${error2}`);
+  }
+}
+async function writeJsonFile2(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    await writeTextFile2(filePath, content);
+  } catch (error2) {
+    throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
+  }
+}
+async function findFiles(dirPath, pattern) {
+  const results = [];
+  try {
+    const items = await import_fs2.promises.readdir(dirPath, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = import_path3.default.join(dirPath, item.name);
+      if (item.isDirectory()) {
+        const subResults = await findFiles(fullPath, pattern);
+        results.push(...subResults);
+      } else if (item.isFile() && pattern.test(item.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (error2) {
+    throw new Error(`Failed to find files in ${dirPath}: ${error2}`);
+  }
+  return results;
+}
+var import_fs2, import_path3;
+var init_fs = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/fs.js"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path3 = __toESM(require("path"), 1);
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/state-transform.js
+async function schemaToState(schema) {
+  const tables = {};
+  for (const [tableName, table] of Object.entries(schema.tables)) {
+    const columns = {};
+    const primaryKeyColumn = table.primaryKey ?? table.columns.find((column) => column.primaryKey)?.name ?? null;
+    for (const column of table.columns) {
+      columns[column.name] = {
+        type: column.type,
+        ...column.primaryKey !== void 0 && { primaryKey: column.primaryKey },
+        ...column.unique !== void 0 && { unique: column.unique },
+        nullable: column.nullable ?? true,
+        ...column.default !== void 0 && { default: column.default },
+        ...column.foreignKey !== void 0 && { foreignKey: column.foreignKey }
+      };
+    }
+    tables[tableName] = {
+      columns,
+      ...primaryKeyColumn !== null && { primaryKey: primaryKeyColumn }
+    };
+  }
+  return {
+    version: 1,
+    tables
+  };
+}
+var init_state_transform = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/state-transform.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/state-manager.js
+async function loadState(statePath) {
+  return await readJsonFile2(statePath, { version: 1, tables: {} });
+}
+async function saveState(statePath, state) {
+  const dirPath = import_path4.default.dirname(statePath);
+  await ensureDir2(dirPath);
+  await writeJsonFile2(statePath, state);
+}
+var import_path4;
+var init_state_manager = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/state-manager.js"() {
+    "use strict";
+    import_path4 = __toESM(require("path"), 1);
+    init_fs();
+    init_state_transform();
+    init_state_transform();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/generator/sql-generator.js
+function generateSql(diff2, provider, sqlConfig) {
+  const statements = [];
+  for (const operation of diff2.operations) {
+    const sql = generateOperation(operation, provider, sqlConfig);
+    if (sql) {
+      statements.push(sql);
+    }
+  }
+  return statements.join("\n\n");
+}
+function generateOperation(operation, provider, sqlConfig) {
+  switch (operation.kind) {
+    case "create_table":
+      return generateCreateTable(operation.table, provider, sqlConfig);
+    case "drop_table":
+      return generateDropTable(operation.tableName);
+    case "column_type_changed":
+      return generateAlterColumnType(operation.tableName, operation.columnName, operation.toType);
+    case "column_nullability_changed":
+      return generateAlterColumnNullability(operation.tableName, operation.columnName, operation.to);
+    case "add_column":
+      return generateAddColumn(operation.tableName, operation.column, provider, sqlConfig);
+    case "column_default_changed":
+      return generateAlterColumnDefault(operation.tableName, operation.columnName, operation.toDefault);
+    case "drop_column":
+      return generateDropColumn(operation.tableName, operation.columnName);
+    case "column_unique_changed":
+      return operation.to ? generateAddUniqueConstraint(operation.tableName, operation.columnName) : generateDropUniqueConstraint(operation.tableName, operation.columnName);
+    case "drop_primary_key_constraint":
+      return generateDropPrimaryKeyConstraint(operation.tableName);
+    case "add_primary_key_constraint":
+      return generateAddPrimaryKeyConstraint(operation.tableName, operation.columnName);
+  }
+}
+function generateCreateTable(table, provider, sqlConfig) {
+  const columnDefs = table.columns.map((col) => generateColumnDefinition(col, provider, sqlConfig));
+  const lines = ["CREATE TABLE " + table.name + " ("];
+  columnDefs.forEach((colDef, index) => {
+    const isLast = index === columnDefs.length - 1;
+    lines.push("  " + colDef + (isLast ? "" : ","));
+  });
+  lines.push(");");
+  return lines.join("\n");
+}
+function generateColumnDefinition(column, provider, sqlConfig) {
+  const parts = [column.name, column.type];
+  if (column.foreignKey) {
+    parts.push(`references ${column.foreignKey.table}(${column.foreignKey.column})`);
+  }
+  if (column.primaryKey) {
+    parts.push("primary key");
+  }
+  if (column.unique) {
+    parts.push("unique");
+  }
+  if (column.nullable === false) {
+    parts.push("not null");
+  }
+  if (column.default !== void 0) {
+    parts.push("default " + column.default);
+  } else if (column.type === "uuid" && column.primaryKey && provider === "supabase") {
+    parts.push("default gen_random_uuid()");
+  }
+  return parts.join(" ");
+}
+function generateDropTable(tableName) {
+  return `DROP TABLE ${tableName};`;
+}
+function generateAddColumn(tableName, column, provider, sqlConfig) {
+  const colDef = generateColumnDefinition(column, provider, sqlConfig);
+  return `ALTER TABLE ${tableName} ADD COLUMN ${colDef};`;
+}
+function generateDropColumn(tableName, columnName) {
+  return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
+}
+function generateAlterColumnType(tableName, columnName, newType) {
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType} USING ${columnName}::${newType};`;
+}
+function generateAddUniqueConstraint(tableName, columnName) {
+  const deterministicConstraintName = uqName(tableName, columnName);
+  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} UNIQUE (${columnName});`;
+}
+function generateDropUniqueConstraint(tableName, columnName) {
+  const deterministicConstraintName = uqName(tableName, columnName);
+  const fallbackConstraintName = legacyUqName(tableName, columnName);
+  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+}
+function generateDropPrimaryKeyConstraint(tableName) {
+  const deterministicConstraintName = pkName(tableName);
+  const fallbackConstraintName = legacyPkName(tableName);
+  return generateDropConstraintStatements(tableName, [deterministicConstraintName, fallbackConstraintName]);
+}
+function generateAddPrimaryKeyConstraint(tableName, columnName) {
+  const deterministicConstraintName = pkName(tableName);
+  return `ALTER TABLE ${tableName} ADD CONSTRAINT ${deterministicConstraintName} PRIMARY KEY (${columnName});`;
+}
+function generateDropConstraintStatements(tableName, constraintNames) {
+  const uniqueConstraintNames = Array.from(new Set(constraintNames));
+  return uniqueConstraintNames.map((constraintName) => `ALTER TABLE ${tableName} DROP CONSTRAINT IF EXISTS ${constraintName};`).join("\n");
+}
+function generateAlterColumnDefault(tableName, columnName, newDefault) {
+  if (newDefault === null) {
+    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT;`;
+  }
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${newDefault};`;
+}
+function generateAlterColumnNullability(tableName, columnName, toNullable) {
+  if (toNullable) {
+    return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL;`;
+  }
+  return `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL;`;
+}
+var init_sql_generator = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/generator/sql-generator.js"() {
+    "use strict";
+    init_normalize();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/split-statements.js
+function splitSqlStatements(sql) {
+  const statements = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let dollarTag = null;
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index];
+    const next = index + 1 < sql.length ? sql[index + 1] : "";
+    if (inLineComment) {
+      current += char;
+      if (char === "\n") {
+        inLineComment = false;
+      }
+      index++;
+      continue;
+    }
+    if (inBlockComment) {
+      current += char;
+      if (char === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        index += 2;
+        continue;
+      }
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && dollarTag === null) {
+      if (char === "-" && next === "-") {
+        current += char + next;
+        inLineComment = true;
+        index += 2;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        current += char + next;
+        inBlockComment = true;
+        index += 2;
+        continue;
+      }
+    }
+    if (!inDoubleQuote && dollarTag === null && char === "'") {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index += 2;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && dollarTag === null && char === '"') {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index += 2;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      index++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (dollarTag === null && char === "$") {
+        const remainder = sql.slice(index);
+        const match = remainder.match(/^\$[a-zA-Z_][a-zA-Z0-9_]*\$|^\$\$/);
+        if (match) {
+          dollarTag = match[0];
+          current += match[0];
+          index += match[0].length;
+          continue;
+        }
+      }
+      if (dollarTag !== null && sql.startsWith(dollarTag, index)) {
+        current += dollarTag;
+        index += dollarTag.length;
+        dollarTag = null;
+        continue;
+      }
+    }
+    if (!inSingleQuote && !inDoubleQuote && dollarTag === null && char === ";") {
+      if (current.trim().length > 0) {
+        statements.push(current.trim());
+      }
+      current = "";
+      index++;
+      continue;
+    }
+    current += char;
+    index++;
+  }
+  if (current.trim().length > 0) {
+    statements.push(current.trim());
+  }
+  return statements;
+}
+var init_split_statements = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/split-statements.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/parse-migration.js
+function normalizeSqlType(type) {
+  return type.trim().toLowerCase().replace(/\s+/g, " ").replace(/\s*\(\s*/g, "(").replace(/\s*,\s*/g, ",").replace(/\s*\)\s*/g, ")");
+}
+function unquoteIdentifier(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    return trimmed.slice(1, -1).replace(/""/g, '"');
+  }
+  return trimmed;
+}
+function normalizeIdentifier(identifier) {
+  const parts = identifier.trim().split(".").map((part) => unquoteIdentifier(part)).filter((part) => part.length > 0);
+  const leaf = parts.length > 0 ? parts[parts.length - 1] : identifier.trim();
+  return leaf.toLowerCase();
+}
+function removeSqlComments(statement) {
+  let result = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0; index < statement.length; index++) {
+    const char = statement[index];
+    const next = index + 1 < statement.length ? statement[index + 1] : "";
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "-" && next === "-") {
+        inLineComment = true;
+        index++;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        inBlockComment = true;
+        index++;
+        continue;
+      }
+    }
+    if (char === "'" && !inDoubleQuote) {
+      if (inSingleQuote && next === "'") {
+        result += "''";
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      result += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      if (inDoubleQuote && next === '"') {
+        result += '""';
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      result += char;
+      continue;
+    }
+    result += char;
+  }
+  return result.trim();
+}
+function splitTopLevelComma(input) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    const next = index + 1 < input.length ? input[index + 1] : "";
+    if (char === "'" && !inDoubleQuote) {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth = Math.max(0, depth - 1);
+      } else if (char === "," && depth === 0) {
+        const segment = current.trim();
+        if (segment.length > 0) {
+          parts.push(segment);
+        }
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  const tail = current.trim();
+  if (tail.length > 0) {
+    parts.push(tail);
+  }
+  return parts;
+}
+function tokenize(segment) {
+  const tokens = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = 0; index < segment.length; index++) {
+    const char = segment[index];
+    const next = index + 1 < segment.length ? segment[index + 1] : "";
+    if (char === "'" && !inDoubleQuote) {
+      current += char;
+      if (inSingleQuote && next === "'") {
+        current += next;
+        index++;
+        continue;
+      }
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      current += char;
+      if (inDoubleQuote && next === '"') {
+        current += next;
+        index++;
+        continue;
+      }
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        depth++;
+      } else if (char === ")") {
+        depth = Math.max(0, depth - 1);
+      }
+      if (/\s/.test(char) && depth === 0) {
+        if (current.length > 0) {
+          tokens.push(current);
+          current = "";
+        }
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function parseColumnDefinition(segment) {
+  const tokens = tokenize(segment);
+  if (tokens.length < 2) {
+    return null;
+  }
+  const name = normalizeIdentifier(tokens[0]);
+  let cursor = 1;
+  const typeTokens = [];
+  while (cursor < tokens.length) {
+    const lower = tokens[cursor].toLowerCase();
+    if (COLUMN_CONSTRAINT_KEYWORDS.has(lower)) {
+      break;
+    }
+    typeTokens.push(tokens[cursor]);
+    cursor++;
+  }
+  if (typeTokens.length === 0) {
+    return null;
+  }
+  const parsed = {
+    name,
+    type: normalizeSqlType(typeTokens.join(" ")),
+    nullable: true
+  };
+  while (cursor < tokens.length) {
+    const lower = tokens[cursor].toLowerCase();
+    if (lower === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
+      parsed.primaryKey = true;
+      parsed.nullable = false;
+      cursor += 2;
+      continue;
+    }
+    if (lower === "unique") {
+      parsed.unique = true;
+      cursor++;
+      continue;
+    }
+    if (lower === "not" && tokens[cursor + 1]?.toLowerCase() === "null") {
+      parsed.nullable = false;
+      cursor += 2;
+      continue;
+    }
+    if (lower === "null") {
+      parsed.nullable = true;
+      cursor++;
+      continue;
+    }
+    if (lower === "default") {
+      cursor++;
+      const defaultTokens = [];
+      while (cursor < tokens.length) {
+        const probe = tokens[cursor].toLowerCase();
+        if (probe === "constraint" || probe === "references" || probe === "check" || probe === "not" && tokens[cursor + 1]?.toLowerCase() === "null" || probe === "null" || probe === "unique" || probe === "primary" && tokens[cursor + 1]?.toLowerCase() === "key") {
+          break;
+        }
+        defaultTokens.push(tokens[cursor]);
+        cursor++;
+      }
+      parsed.default = normalizeDefault(defaultTokens.join(" "));
+      continue;
+    }
+    cursor++;
+  }
+  return parsed;
+}
+function parseCreateTableConstraint(segment) {
+  const normalized = segment.trim().replace(/\s+/g, " ");
+  const constraintMatch = normalized.match(/^constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
+  if (constraintMatch) {
+    const [, rawName, kind, rawColumns] = constraintMatch;
+    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
+    if (kind.toLowerCase().includes("primary")) {
+      return { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns };
+    }
+    return { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
+  }
+  const barePk = normalized.match(/^primary\s+key\s*\((.+)\)$/i);
+  if (barePk) {
+    const columns = splitTopLevelComma(barePk[1]).map((item) => normalizeIdentifier(item));
+    return { type: "PRIMARY_KEY", columns };
+  }
+  const bareUnique = normalized.match(/^unique\s*\((.+)\)$/i);
+  if (bareUnique) {
+    const columns = splitTopLevelComma(bareUnique[1]).map((item) => normalizeIdentifier(item));
+    return { type: "UNIQUE", columns };
+  }
+  return null;
+}
+function parseAlterTablePrefix(stmt) {
+  const match = stmt.match(/^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const remainder = match[1].trim();
+  const tokens = tokenize(remainder);
+  if (tokens.length < 2) {
+    return null;
+  }
+  const tableToken = tokens[0];
+  const table = normalizeIdentifier(tableToken);
+  const rest = remainder.slice(tableToken.length).trim();
+  return { table, rest };
+}
+function parseCreateTable(stmt) {
+  const match = stmt.match(/^create\s+table\s+(?:if\s+not\s+exists\s+)?(.+?)\s*\((.*)\)$/is);
+  if (!match) {
+    return null;
+  }
+  const table = normalizeIdentifier(match[1]);
+  const body = match[2];
+  const segments = splitTopLevelComma(body);
+  const columns = [];
+  const constraints = [];
+  for (const segment of segments) {
+    const constraint = parseCreateTableConstraint(segment);
+    if (constraint) {
+      constraints.push(constraint);
+      continue;
+    }
+    const column = parseColumnDefinition(segment);
+    if (column) {
+      columns.push(column);
+    }
+  }
+  return {
+    kind: "CREATE_TABLE",
+    table,
+    columns,
+    constraints
+  };
+}
+function parseAlterTableAddColumn(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^add\s+column\s+(?:if\s+not\s+exists\s+)?(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const column = parseColumnDefinition(match[1]);
+  if (!column) {
+    return null;
+  }
+  return { kind: "ADD_COLUMN", table: prefix.table, column };
+}
+function parseAlterColumnType(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+type\s+(.+)$/i);
+  if (!match) {
+    return null;
+  }
+  const column = normalizeIdentifier(match[1]);
+  const toType = normalizeSqlType(match[2].replace(/\s+using\s+[\s\S]*$/i, "").trim());
+  return {
+    kind: "ALTER_COLUMN_TYPE",
+    table: prefix.table,
+    column,
+    toType
+  };
+}
+function parseSetDropNotNull(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+not\s+null$/i);
+  if (setMatch) {
+    return {
+      kind: "SET_NOT_NULL",
+      table: prefix.table,
+      column: normalizeIdentifier(setMatch[1])
+    };
+  }
+  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+not\s+null$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_NOT_NULL",
+      table: prefix.table,
+      column: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseSetDropDefault(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const setMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+set\s+default\s+(.+)$/i);
+  if (setMatch) {
+    return {
+      kind: "SET_DEFAULT",
+      table: prefix.table,
+      column: normalizeIdentifier(setMatch[1]),
+      expr: normalizeDefault(setMatch[2].trim()) ?? setMatch[2].trim()
+    };
+  }
+  const dropMatch = prefix.rest.match(/^alter\s+column\s+([^\s]+)\s+drop\s+default$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_DEFAULT",
+      table: prefix.table,
+      column: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseAddDropConstraint(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const addMatch = prefix.rest.match(/^add\s+constraint\s+([^\s]+)\s+(primary\s+key|unique)\s*\((.+)\)$/i);
+  if (addMatch) {
+    const [, rawName, kind, rawColumns] = addMatch;
+    const columns = splitTopLevelComma(rawColumns).map((item) => normalizeIdentifier(item));
+    const constraint = kind.toLowerCase().includes("primary") ? { type: "PRIMARY_KEY", name: normalizeIdentifier(rawName), columns } : { type: "UNIQUE", name: normalizeIdentifier(rawName), columns };
+    return {
+      kind: "ADD_CONSTRAINT",
+      table: prefix.table,
+      constraint
+    };
+  }
+  const dropMatch = prefix.rest.match(/^drop\s+constraint\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (dropMatch) {
+    return {
+      kind: "DROP_CONSTRAINT",
+      table: prefix.table,
+      name: normalizeIdentifier(dropMatch[1])
+    };
+  }
+  return null;
+}
+function parseDropColumn(stmt) {
+  const prefix = parseAlterTablePrefix(stmt);
+  if (!prefix) {
+    return null;
+  }
+  const match = prefix.rest.match(/^drop\s+column\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (!match) {
+    return null;
+  }
+  return {
+    kind: "DROP_COLUMN",
+    table: prefix.table,
+    column: normalizeIdentifier(match[1])
+  };
+}
+function parseDropTable(stmt) {
+  const match = stmt.match(/^drop\s+table\s+(?:if\s+exists\s+)?([^\s]+)(?:\s+cascade)?$/i);
+  if (!match) {
+    return null;
+  }
+  return {
+    kind: "DROP_TABLE",
+    table: normalizeIdentifier(match[1])
+  };
+}
+function parseMigrationSql(sql) {
+  const statements = splitSqlStatements(sql);
+  const ops = [];
+  const warnings = [];
+  for (const raw of statements) {
+    const stmt = removeSqlComments(raw).trim();
+    if (!stmt) {
+      continue;
+    }
+    let parsed = null;
+    for (const parseFn of PARSERS) {
+      parsed = parseFn(stmt);
+      if (parsed) {
+        break;
+      }
+    }
+    if (parsed) {
+      ops.push(parsed);
+    } else {
+      warnings.push({
+        statement: stmt,
+        reason: "Unsupported or unrecognized statement"
+      });
+    }
+  }
+  return { ops, warnings };
+}
+var COLUMN_CONSTRAINT_KEYWORDS, PARSERS;
+var init_parse_migration = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/parse-migration.js"() {
+    "use strict";
+    init_normalize();
+    init_split_statements();
+    COLUMN_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+      "primary",
+      "unique",
+      "not",
+      "null",
+      "default",
+      "constraint",
+      "references",
+      "check"
+    ]);
+    PARSERS = [
+      parseCreateTable,
+      parseAlterTableAddColumn,
+      parseAlterColumnType,
+      parseSetDropNotNull,
+      parseSetDropDefault,
+      parseAddDropConstraint,
+      parseDropColumn,
+      parseDropTable
+    ];
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/apply-ops.js
+function toSchemaColumn(column) {
+  return {
+    name: column.name,
+    type: column.type,
+    nullable: column.nullable,
+    ...column.default !== void 0 ? { default: column.default } : {},
+    ...column.unique !== void 0 ? { unique: column.unique } : {},
+    ...column.primaryKey !== void 0 ? { primaryKey: column.primaryKey } : {}
+  };
+}
+function applySingleColumnConstraint(table, constraint) {
+  if (constraint.columns.length !== 1) {
+    return false;
+  }
+  const targetColumn = table.columns.find((column) => column.name === constraint.columns[0]);
+  if (!targetColumn) {
+    return false;
+  }
+  if (constraint.type === "PRIMARY_KEY") {
+    table.primaryKey = targetColumn.name;
+    targetColumn.primaryKey = true;
+    targetColumn.nullable = false;
+    return true;
+  }
+  targetColumn.unique = true;
+  return true;
+}
+function clearConstraintByName(table, name) {
+  if (name.endsWith("_pkey") || name.startsWith("pk_")) {
+    if (table.primaryKey) {
+      const pkColumn = table.columns.find((column) => column.name === table.primaryKey);
+      if (pkColumn) {
+        pkColumn.primaryKey = false;
+      }
+      table.primaryKey = null;
+    }
+    return;
+  }
+  if (name.endsWith("_key") || name.startsWith("uq_")) {
+    for (const column of table.columns) {
+      if (column.unique) {
+        column.unique = false;
+      }
+    }
+  }
+}
+function getOrCreateTable(tables, name) {
+  if (!tables[name]) {
+    tables[name] = { name, columns: [] };
+  }
+  return tables[name];
+}
+function applySqlOps(ops) {
+  const tables = {};
+  const warnings = [];
+  for (const op of ops) {
+    switch (op.kind) {
+      case "CREATE_TABLE": {
+        const table = {
+          name: op.table,
+          columns: op.columns.map(toSchemaColumn)
+        };
+        for (const column of table.columns) {
+          if (column.primaryKey) {
+            table.primaryKey = column.name;
+          }
+        }
+        for (const constraint of op.constraints) {
+          const applied = applySingleColumnConstraint(table, constraint);
+          if (!applied) {
+            warnings.push({
+              statement: `CREATE TABLE ${op.table}`,
+              reason: `Constraint ${constraint.type}${constraint.name ? ` (${constraint.name})` : ""} is unsupported for schema reconstruction`
+            });
+          }
+        }
+        tables[op.table] = table;
+        break;
+      }
+      case "ADD_COLUMN": {
+        const table = getOrCreateTable(tables, op.table);
+        table.columns = table.columns.filter((column) => column.name !== op.column.name);
+        table.columns.push(toSchemaColumn(op.column));
+        if (op.column.primaryKey) {
+          table.primaryKey = op.column.name;
+        }
+        break;
+      }
+      case "ALTER_COLUMN_TYPE": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        const column = table.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.type = op.toType;
+        }
+        break;
+      }
+      case "SET_NOT_NULL": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.nullable = false;
+        }
+        break;
+      }
+      case "DROP_NOT_NULL": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.nullable = true;
+        }
+        break;
+      }
+      case "SET_DEFAULT": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.default = op.expr;
+        }
+        break;
+      }
+      case "DROP_DEFAULT": {
+        const table = tables[op.table];
+        const column = table?.columns.find((item) => item.name === op.column);
+        if (column) {
+          column.default = null;
+        }
+        break;
+      }
+      case "ADD_CONSTRAINT": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        const applied = applySingleColumnConstraint(table, op.constraint);
+        if (!applied) {
+          warnings.push({
+            statement: `ALTER TABLE ${op.table} ADD CONSTRAINT ${op.constraint.name ?? "<unnamed>"}`,
+            reason: `Constraint ${op.constraint.type} is unsupported for schema reconstruction`
+          });
+        }
+        break;
+      }
+      case "DROP_CONSTRAINT": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        clearConstraintByName(table, op.name);
+        break;
+      }
+      case "DROP_COLUMN": {
+        const table = tables[op.table];
+        if (!table) {
+          break;
+        }
+        table.columns = table.columns.filter((column) => column.name !== op.column);
+        if (table.primaryKey === op.column) {
+          table.primaryKey = null;
+        }
+        break;
+      }
+      case "DROP_TABLE": {
+        delete tables[op.table];
+        break;
+      }
+    }
+  }
+  const schema = { tables };
+  return { schema, warnings };
+}
+var init_apply_ops = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/apply-ops.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/schema-to-dsl.js
+function renderColumn(column) {
+  const parts = [column.name, column.type];
+  if (column.primaryKey) {
+    parts.push("pk");
+  }
+  if (column.unique) {
+    parts.push("unique");
+  }
+  if (column.nullable === false && !column.primaryKey) {
+    parts.push("not null");
+  }
+  if (column.default !== void 0 && column.default !== null) {
+    parts.push(`default ${column.default}`);
+  }
+  return `  ${parts.join(" ")}`;
+}
+function schemaToDsl(schema) {
+  const tableNames = Object.keys(schema.tables).sort((left, right) => left.localeCompare(right));
+  const blocks = tableNames.map((tableName) => {
+    const table = schema.tables[tableName];
+    const lines = [`table ${table.name} {`];
+    for (const column of table.columns) {
+      lines.push(renderColumn(column));
+    }
+    lines.push("}");
+    return lines.join("\n");
+  });
+  if (blocks.length === 0) {
+    return "# SchemaForge schema definition\n";
+  }
+  return `# SchemaForge schema definition
+
+${blocks.join("\n\n")}
+`;
+}
+var init_schema_to_dsl = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/schema-to-dsl.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/load-migrations.js
+async function loadMigrationSqlInput(inputPath) {
+  const stats = await import_fs4.promises.stat(inputPath);
+  if (stats.isFile()) {
+    if (!inputPath.toLowerCase().endsWith(".sql")) {
+      throw new Error(`Input file must be a .sql file: ${inputPath}`);
+    }
+    return [{ filePath: inputPath, sql: await readTextFile2(inputPath) }];
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`Input path must be a .sql file or directory: ${inputPath}`);
+  }
+  const sqlFiles = await findFiles(inputPath, /\.sql$/i);
+  sqlFiles.sort((left, right) => import_path5.default.basename(left).localeCompare(import_path5.default.basename(right)));
+  const result = [];
+  for (const filePath of sqlFiles) {
+    result.push({
+      filePath,
+      sql: await readTextFile2(filePath)
+    });
+  }
+  return result;
+}
+var import_fs4, import_path5;
+var init_load_migrations = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/load-migrations.js"() {
+    "use strict";
+    import_fs4 = require("fs");
+    import_path5 = __toESM(require("path"), 1);
+    init_fs();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/sql/introspect-postgres.js
+function toTableKey(schema, table) {
+  if (schema === DEFAULT_SCHEMA) {
+    return table;
+  }
+  return `${schema}.${table}`;
+}
+function normalizeSchemas(schemas) {
+  const values = schemas ?? [DEFAULT_SCHEMA];
+  const deduped = /* @__PURE__ */ new Set();
+  for (const schema of values) {
+    const trimmed = schema.trim();
+    if (trimmed.length > 0) {
+      deduped.add(trimmed);
+    }
+  }
+  if (deduped.size === 0) {
+    deduped.add(DEFAULT_SCHEMA);
+  }
+  return Array.from(deduped).sort((a, b) => a.localeCompare(b));
+}
+function normalizeColumnType5(row) {
+  const dataType = row.data_type.toLowerCase();
+  const udtName = row.udt_name.toLowerCase();
+  if (dataType === "character varying") {
+    if (row.character_maximum_length !== null) {
+      return `varchar(${row.character_maximum_length})`;
+    }
+    return "varchar";
+  }
+  if (dataType === "timestamp with time zone") {
+    return "timestamptz";
+  }
+  if (dataType === "integer" || udtName === "int4") {
+    return "int";
+  }
+  if (dataType === "bigint" || udtName === "int8") {
+    return "bigint";
+  }
+  if (dataType === "numeric") {
+    if (row.numeric_precision !== null && row.numeric_scale !== null) {
+      return `numeric(${row.numeric_precision},${row.numeric_scale})`;
+    }
+    return "numeric";
+  }
+  if (dataType === "boolean" || udtName === "bool") {
+    return "boolean";
+  }
+  if (dataType === "uuid") {
+    return "uuid";
+  }
+  if (dataType === "text") {
+    return "text";
+  }
+  if (dataType === "date") {
+    return "date";
+  }
+  return dataType;
+}
+function normalizeConstraints(constraintRows, foreignKeyRows) {
+  const constraints = /* @__PURE__ */ new Map();
+  for (const row of constraintRows) {
+    const key = `${row.table_schema}.${row.table_name}.${row.constraint_name}.${row.constraint_type}`;
+    const existing = constraints.get(key);
+    if (existing) {
+      if (row.column_name !== null) {
+        existing.columns.push({
+          name: row.column_name,
+          position: row.ordinal_position ?? Number.MAX_SAFE_INTEGER
+        });
+      }
+      if (!existing.checkClause && row.check_clause) {
+        existing.checkClause = row.check_clause;
+      }
+      continue;
+    }
+    constraints.set(key, {
+      tableSchema: row.table_schema,
+      tableName: row.table_name,
+      name: row.constraint_name,
+      type: row.constraint_type,
+      columns: row.column_name === null ? [] : [{
+        name: row.column_name,
+        position: row.ordinal_position ?? Number.MAX_SAFE_INTEGER
+      }],
+      ...row.check_clause ? { checkClause: row.check_clause } : {}
+    });
+  }
+  const normalized = [];
+  for (const value of constraints.values()) {
+    value.columns.sort((left, right) => {
+      if (left.position !== right.position) {
+        return left.position - right.position;
+      }
+      return left.name.localeCompare(right.name);
+    });
+    normalized.push({
+      tableSchema: value.tableSchema,
+      tableName: value.tableName,
+      name: value.name,
+      type: value.type,
+      columns: value.columns.map((item) => item.name),
+      ...value.checkClause ? { checkClause: value.checkClause } : {}
+    });
+  }
+  const foreignKeys = /* @__PURE__ */ new Map();
+  for (const row of foreignKeyRows) {
+    const key = `${row.table_schema}.${row.table_name}.${row.constraint_name}`;
+    const existing = foreignKeys.get(key);
+    if (existing) {
+      existing.local.push({ name: row.local_column_name, position: row.position });
+      existing.referenced.push({ name: row.referenced_column_name, position: row.position });
+      continue;
+    }
+    foreignKeys.set(key, {
+      tableSchema: row.table_schema,
+      tableName: row.table_name,
+      name: row.constraint_name,
+      local: [{ name: row.local_column_name, position: row.position }],
+      referencedTableSchema: row.referenced_table_schema,
+      referencedTableName: row.referenced_table_name,
+      referenced: [{ name: row.referenced_column_name, position: row.position }]
+    });
+  }
+  for (const value of foreignKeys.values()) {
+    value.local.sort((left, right) => left.position - right.position || left.name.localeCompare(right.name));
+    value.referenced.sort((left, right) => left.position - right.position || left.name.localeCompare(right.name));
+    normalized.push({
+      tableSchema: value.tableSchema,
+      tableName: value.tableName,
+      name: value.name,
+      type: "FOREIGN KEY",
+      columns: value.local.map((item) => item.name),
+      referencedTableSchema: value.referencedTableSchema,
+      referencedTableName: value.referencedTableName,
+      referencedColumns: value.referenced.map((item) => item.name)
+    });
+  }
+  normalized.sort((left, right) => {
+    if (left.tableSchema !== right.tableSchema) {
+      return left.tableSchema.localeCompare(right.tableSchema);
+    }
+    if (left.tableName !== right.tableName) {
+      return left.tableName.localeCompare(right.tableName);
+    }
+    const typeOrderDiff = CONSTRAINT_TYPE_ORDER[left.type] - CONSTRAINT_TYPE_ORDER[right.type];
+    if (typeOrderDiff !== 0) {
+      return typeOrderDiff;
+    }
+    if (left.name !== right.name) {
+      return left.name.localeCompare(right.name);
+    }
+    return left.columns.join(",").localeCompare(right.columns.join(","));
+  });
+  return normalized;
+}
+async function introspectPostgresSchema(options) {
+  const schemaFilter = normalizeSchemas(options.schemas);
+  const [tableRows, columnRows, constraintRows, foreignKeyRows] = await Promise.all([
+    options.query(TABLES_QUERY, [schemaFilter]),
+    options.query(COLUMNS_QUERY, [schemaFilter]),
+    options.query(CONSTRAINTS_QUERY, [schemaFilter]),
+    options.query(FOREIGN_KEYS_QUERY, [schemaFilter])
+  ]);
+  const sortedTables = [...tableRows].sort((left, right) => {
+    if (left.table_schema !== right.table_schema) {
+      return left.table_schema.localeCompare(right.table_schema);
+    }
+    return left.table_name.localeCompare(right.table_name);
+  });
+  const sortedColumns = [...columnRows].sort((left, right) => {
+    if (left.table_schema !== right.table_schema) {
+      return left.table_schema.localeCompare(right.table_schema);
+    }
+    if (left.table_name !== right.table_name) {
+      return left.table_name.localeCompare(right.table_name);
+    }
+    if (left.ordinal_position !== right.ordinal_position) {
+      return left.ordinal_position - right.ordinal_position;
+    }
+    return left.column_name.localeCompare(right.column_name);
+  });
+  const normalizedConstraints = normalizeConstraints(constraintRows, foreignKeyRows);
+  const tableMap = /* @__PURE__ */ new Map();
+  const columnMap = /* @__PURE__ */ new Map();
+  for (const row of sortedTables) {
+    const key = toTableKey(row.table_schema, row.table_name);
+    const table = { name: key, columns: [], primaryKey: null };
+    tableMap.set(key, table);
+    columnMap.set(key, /* @__PURE__ */ new Map());
+  }
+  for (const row of sortedColumns) {
+    const key = toTableKey(row.table_schema, row.table_name);
+    const table = tableMap.get(key);
+    const columnsByName = columnMap.get(key);
+    if (!table || !columnsByName) {
+      continue;
+    }
+    const column = {
+      name: row.column_name,
+      type: normalizeColumnType5(row),
+      nullable: row.is_nullable === "YES"
+    };
+    const normalizedDefault = normalizeDefault(row.column_default);
+    if (normalizedDefault !== null) {
+      column.default = normalizedDefault;
+    }
+    table.columns.push(column);
+    columnsByName.set(column.name, column);
+  }
+  for (const constraint of normalizedConstraints) {
+    const tableKey = toTableKey(constraint.tableSchema, constraint.tableName);
+    const table = tableMap.get(tableKey);
+    const columnsByName = columnMap.get(tableKey);
+    if (!table || !columnsByName) {
+      continue;
+    }
+    if (constraint.type === "PRIMARY KEY") {
+      if (constraint.columns.length === 1) {
+        const column = columnsByName.get(constraint.columns[0]);
+        if (column) {
+          column.primaryKey = true;
+          column.nullable = false;
+          table.primaryKey = column.name;
+        }
+      }
+      continue;
+    }
+    if (constraint.type === "UNIQUE") {
+      if (constraint.columns.length === 1) {
+        const column = columnsByName.get(constraint.columns[0]);
+        if (column) {
+          column.unique = true;
+        }
+      }
+      continue;
+    }
+    if (constraint.type === "FOREIGN KEY") {
+      if (constraint.columns.length === 1 && constraint.referencedColumns && constraint.referencedColumns.length === 1 && constraint.referencedTableName) {
+        const column = columnsByName.get(constraint.columns[0]);
+        if (column) {
+          column.foreignKey = {
+            table: toTableKey(constraint.referencedTableSchema ?? DEFAULT_SCHEMA, constraint.referencedTableName),
+            column: constraint.referencedColumns[0]
+          };
+        }
+      }
+    }
+  }
+  const orderedTableNames = Array.from(tableMap.keys()).sort((left, right) => left.localeCompare(right));
+  const tables = {};
+  for (const tableName of orderedTableNames) {
+    const table = tableMap.get(tableName);
+    if (table) {
+      tables[tableName] = table;
+    }
+  }
+  return { tables };
+}
+var DEFAULT_SCHEMA, CONSTRAINT_TYPE_ORDER, TABLES_QUERY, COLUMNS_QUERY, CONSTRAINTS_QUERY, FOREIGN_KEYS_QUERY;
+var init_introspect_postgres = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/sql/introspect-postgres.js"() {
+    "use strict";
+    init_normalize();
+    DEFAULT_SCHEMA = "public";
+    CONSTRAINT_TYPE_ORDER = {
+      "PRIMARY KEY": 0,
+      UNIQUE: 1,
+      "FOREIGN KEY": 2,
+      CHECK: 3
+    };
+    TABLES_QUERY = `
+SELECT
+  table_schema,
+  table_name
+FROM information_schema.tables
+WHERE table_type = 'BASE TABLE'
+  AND table_schema = ANY($1::text[])
+`;
+    COLUMNS_QUERY = `
+SELECT
+  table_schema,
+  table_name,
+  column_name,
+  ordinal_position,
+  is_nullable,
+  data_type,
+  udt_name,
+  character_maximum_length,
+  numeric_precision,
+  numeric_scale,
+  column_default
+FROM information_schema.columns
+WHERE table_schema = ANY($1::text[])
+`;
+    CONSTRAINTS_QUERY = `
+SELECT
+  tc.table_schema,
+  tc.table_name,
+  tc.constraint_name,
+  tc.constraint_type,
+  kcu.column_name,
+  kcu.ordinal_position,
+  cc.check_clause
+FROM information_schema.table_constraints tc
+LEFT JOIN information_schema.key_column_usage kcu
+  ON tc.constraint_catalog = kcu.constraint_catalog
+  AND tc.constraint_schema = kcu.constraint_schema
+  AND tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+  AND tc.table_name = kcu.table_name
+LEFT JOIN information_schema.check_constraints cc
+  ON tc.constraint_catalog = cc.constraint_catalog
+  AND tc.constraint_schema = cc.constraint_schema
+  AND tc.constraint_name = cc.constraint_name
+WHERE tc.table_schema = ANY($1::text[])
+  AND tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE', 'CHECK')
+`;
+    FOREIGN_KEYS_QUERY = `
+SELECT
+  src_ns.nspname AS table_schema,
+  src.relname AS table_name,
+  con.conname AS constraint_name,
+  src_attr.attname AS local_column_name,
+  ref_ns.nspname AS referenced_table_schema,
+  ref.relname AS referenced_table_name,
+  ref_attr.attname AS referenced_column_name,
+  src_key.ord AS position
+FROM pg_constraint con
+JOIN pg_class src
+  ON src.oid = con.conrelid
+JOIN pg_namespace src_ns
+  ON src_ns.oid = src.relnamespace
+JOIN pg_class ref
+  ON ref.oid = con.confrelid
+JOIN pg_namespace ref_ns
+  ON ref_ns.oid = ref.relnamespace
+JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS src_key(attnum, ord)
+  ON TRUE
+JOIN LATERAL unnest(con.confkey) WITH ORDINALITY AS ref_key(attnum, ord)
+  ON ref_key.ord = src_key.ord
+JOIN pg_attribute src_attr
+  ON src_attr.attrelid = con.conrelid
+  AND src_attr.attnum = src_key.attnum
+JOIN pg_attribute ref_attr
+  ON ref_attr.attrelid = con.confrelid
+  AND ref_attr.attnum = ref_key.attnum
+WHERE con.contype = 'f'
+  AND src_ns.nspname = ANY($1::text[])
+`;
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/paths.js
+function getProjectRoot2(cwd = process.cwd()) {
+  return cwd;
+}
+function getSchemaForgeDir2(root) {
+  return import_path6.default.join(root, "schemaforge");
+}
+function getSchemaFilePath2(root, config) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  const fileName = config?.schemaFile || "schema.sf";
+  return import_path6.default.join(schemaForgeDir, fileName);
+}
+function getConfigPath2(root) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  return import_path6.default.join(schemaForgeDir, "config.json");
+}
+function getStatePath2(root, config) {
+  const schemaForgeDir = getSchemaForgeDir2(root);
+  const fileName = config?.stateFile || "state.json";
+  return import_path6.default.join(schemaForgeDir, fileName);
+}
+var import_path6;
+var init_paths = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/paths.js"() {
+    "use strict";
+    import_path6 = __toESM(require("path"), 1);
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/utils.js
+function nowTimestamp() {
+  const date = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+}
+function slugifyName(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+}
+var init_utils = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/utils.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/core/errors.js
+var SchemaValidationError;
+var init_errors = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/core/errors.js"() {
+    "use strict";
+    SchemaValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SchemaValidationError";
+      }
+    };
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  SchemaValidationError: () => SchemaValidationError,
+  analyzeSchemaDrift: () => analyzeSchemaDrift,
+  applySqlOps: () => applySqlOps,
+  checkOperationSafety: () => checkOperationSafety,
+  checkSchemaSafety: () => checkSchemaSafety,
+  classifyOperation: () => classifyOperation,
+  diffSchemas: () => diffSchemas,
+  ensureDir: () => ensureDir2,
+  fileExists: () => fileExists2,
+  findFiles: () => findFiles,
+  generateSql: () => generateSql,
+  getColumnNamesFromSchema: () => getColumnNamesFromSchema,
+  getColumnNamesFromState: () => getColumnNamesFromState,
+  getConfigPath: () => getConfigPath2,
+  getProjectRoot: () => getProjectRoot2,
+  getSchemaFilePath: () => getSchemaFilePath2,
+  getSchemaForgeDir: () => getSchemaForgeDir2,
+  getStatePath: () => getStatePath2,
+  getTableNamesFromSchema: () => getTableNamesFromSchema,
+  getTableNamesFromState: () => getTableNamesFromState,
+  introspectPostgresSchema: () => introspectPostgresSchema,
+  legacyPkName: () => legacyPkName,
+  legacyUqName: () => legacyUqName,
+  loadMigrationSqlInput: () => loadMigrationSqlInput,
+  loadState: () => loadState,
+  normalizeDefault: () => normalizeDefault,
+  normalizeIdent: () => normalizeIdent,
+  nowTimestamp: () => nowTimestamp,
+  parseAddDropConstraint: () => parseAddDropConstraint,
+  parseAlterColumnType: () => parseAlterColumnType,
+  parseAlterTableAddColumn: () => parseAlterTableAddColumn,
+  parseCreateTable: () => parseCreateTable,
+  parseDropColumn: () => parseDropColumn,
+  parseDropTable: () => parseDropTable,
+  parseMigrationSql: () => parseMigrationSql,
+  parseSchema: () => parseSchema,
+  parseSetDropDefault: () => parseSetDropDefault,
+  parseSetDropNotNull: () => parseSetDropNotNull,
+  pkName: () => pkName,
+  readJsonFile: () => readJsonFile2,
+  readTextFile: () => readTextFile2,
+  saveState: () => saveState,
+  schemaToDsl: () => schemaToDsl,
+  schemaToState: () => schemaToState,
+  slugifyName: () => slugifyName,
+  splitSqlStatements: () => splitSqlStatements,
+  toValidationReport: () => toValidationReport,
+  uqName: () => uqName,
+  validateSchema: () => validateSchema,
+  validateSchemaChanges: () => validateSchemaChanges,
+  writeJsonFile: () => writeJsonFile2,
+  writeTextFile: () => writeTextFile2
+});
+var init_dist = __esm({
+  "node_modules/@xubylele/schema-forge-core/dist/index.js"() {
+    "use strict";
+    init_parser();
+    init_diff();
+    init_drift_analyzer();
+    init_validator();
+    init_validate();
+    init_safety();
+    init_state_manager();
+    init_sql_generator();
+    init_parse_migration();
+    init_apply_ops();
+    init_schema_to_dsl();
+    init_load_migrations();
+    init_split_statements();
+    init_introspect_postgres();
+    init_fs();
+    init_normalize();
+    init_paths();
+    init_utils();
+    init_errors();
+  }
+});
+
+// src/api.ts
+var api_exports = {};
+__export(api_exports, {
+  EXIT_CODES: () => EXIT_CODES,
+  diff: () => diff,
+  doctor: () => doctor,
+  generate: () => generate,
+  importSchema: () => importSchema,
+  init: () => init,
+  introspect: () => introspect,
+  validate: () => validate
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/commands/diff.ts
+var import_commander = require("commander");
+var import_path7 = __toESM(require("path"));
+
+// src/core/fs.ts
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+async function ensureDir(dirPath) {
+  try {
+    await import_fs.promises.mkdir(dirPath, { recursive: true });
+  } catch (error2) {
+    throw new Error(`Failed to create directory ${dirPath}: ${error2}`);
+  }
+}
+async function fileExists(filePath) {
+  try {
+    await import_fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile(filePath) {
+  try {
+    return await import_fs.promises.readFile(filePath, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to read file ${filePath}: ${error2}`);
+  }
+}
+async function writeTextFile(filePath, content) {
+  try {
+    const dir = import_path.default.dirname(filePath);
+    await ensureDir(dir);
+    await import_fs.promises.writeFile(filePath, content, "utf-8");
+  } catch (error2) {
+    throw new Error(`Failed to write file ${filePath}: ${error2}`);
+  }
+}
+async function readJsonFile(filePath, fallback) {
+  try {
+    const exists = await fileExists(filePath);
+    if (!exists) {
+      return fallback;
+    }
+    const content = await readTextFile(filePath);
+    return JSON.parse(content);
+  } catch (error2) {
+    throw new Error(`Failed to read JSON file ${filePath}: ${error2}`);
+  }
+}
+async function writeJsonFile(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    await writeTextFile(filePath, content);
+  } catch (error2) {
+    throw new Error(`Failed to write JSON file ${filePath}: ${error2}`);
+  }
+}
+
+// src/core/paths.ts
+var import_path2 = __toESM(require("path"));
+function getProjectRoot(cwd = process.cwd()) {
+  return cwd;
+}
+function getSchemaForgeDir(root) {
+  return import_path2.default.join(root, "schemaforge");
+}
+function getSchemaFilePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.schemaFile || "schema.sf";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+function getConfigPath(root) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  return import_path2.default.join(schemaForgeDir, "config.json");
+}
+function getStatePath(root, config) {
+  const schemaForgeDir = getSchemaForgeDir(root);
+  const fileName = config?.stateFile || "state.json";
+  return import_path2.default.join(schemaForgeDir, fileName);
+}
+
+// src/core/provider.ts
+var DEFAULT_PROVIDER = "postgres";
+function resolveProvider(provider) {
+  if (!provider) {
+    return { provider: DEFAULT_PROVIDER, usedDefault: true };
+  }
+  return { provider, usedDefault: false };
+}
+
+// src/domain.ts
+var corePromise;
+async function loadCore() {
+  if (!corePromise) {
+    corePromise = Promise.resolve().then(() => (init_dist(), dist_exports));
+  }
+  return corePromise;
+}
+async function parseSchema2(source) {
+  const core = await loadCore();
+  return core.parseSchema(source);
+}
+async function validateSchema2(schema) {
+  const core = await loadCore();
+  core.validateSchema(schema);
+}
+async function diffSchemas2(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.diffSchemas(previousState, currentSchema);
+}
+async function generateSql2(diff2, provider, config) {
+  const core = await loadCore();
+  return core.generateSql(diff2, provider, config);
+}
+async function schemaToState2(schema) {
+  const core = await loadCore();
+  return core.schemaToState(schema);
+}
+async function loadState2(statePath) {
+  const core = await loadCore();
+  return core.loadState(statePath);
+}
+async function saveState2(statePath, state) {
+  const core = await loadCore();
+  return core.saveState(statePath, state);
+}
+async function validateSchemaChanges2(previousState, currentSchema) {
+  const core = await loadCore();
+  return core.validateSchemaChanges(previousState, currentSchema);
+}
+async function toValidationReport2(findings) {
+  const core = await loadCore();
+  return core.toValidationReport(findings);
+}
+async function parseMigrationSql2(sql) {
+  const core = await loadCore();
+  return core.parseMigrationSql(sql);
+}
+async function introspectPostgresSchema2(options) {
+  const core = await loadCore();
+  return core.introspectPostgresSchema(options);
+}
+async function analyzeSchemaDrift2(state, liveSchema) {
+  const core = await loadCore();
+  return core.analyzeSchemaDrift(state, liveSchema);
+}
+async function applySqlOps2(ops) {
+  const core = await loadCore();
+  return core.applySqlOps(ops);
+}
+async function schemaToDsl2(schema) {
+  const core = await loadCore();
+  return core.schemaToDsl(schema);
+}
+async function loadMigrationSqlInput2(inputPath) {
+  const core = await loadCore();
+  return core.loadMigrationSqlInput(inputPath);
+}
+async function createSchemaValidationError(message) {
+  const core = await loadCore();
+  return new core.SchemaValidationError(message);
+}
+
+// src/core/postgres.ts
+var import_pg = require("pg");
+function resolvePostgresConnectionString(options = {}) {
+  const explicitUrl = options.url?.trim();
+  if (explicitUrl) {
+    return explicitUrl;
+  }
+  const envUrl = process.env.DATABASE_URL?.trim();
+  if (envUrl) {
+    return envUrl;
+  }
+  throw new Error("PostgreSQL connection URL is required. Pass --url or set DATABASE_URL.");
+}
+function parseSchemaList(value) {
+  if (!value) {
+    return void 0;
+  }
+  const schemas = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return schemas.length > 0 ? schemas : void 0;
+}
+async function withPostgresQueryExecutor(connectionString, run) {
+  const client = new import_pg.Client({ connectionString });
+  await client.connect();
+  const query = async (sql, params) => {
+    const result = await client.query(sql, params ? [...params] : void 0);
+    return result.rows;
+  };
+  try {
+    return await run(query);
+  } finally {
+    await client.end();
+  }
+}
+
+// src/utils/exitCodes.ts
+var EXIT_CODES = {
+  /** Successful operation */
+  SUCCESS: 0,
+  /** Validation error (invalid DSL syntax, config errors, missing files, etc.) */
+  VALIDATION_ERROR: 1,
+  /** Drift detected - Reserved for future use when comparing actual DB state vs schema */
+  DRIFT_DETECTED: 2,
+  /** Destructive operation detected in CI environment without --force */
+  CI_DESTRUCTIVE: 3
+};
+
+// src/utils/output.ts
+var import_boxen = __toESM(require("boxen"));
+var import_chalk = require("chalk");
+var isInteractive = Boolean(process.stdout?.isTTY);
+var colorsEnabled = isInteractive && process.env.FORCE_COLOR !== "0" && !("NO_COLOR" in process.env);
+var color = new import_chalk.Chalk({ level: colorsEnabled ? 3 : 0 });
+var theme = {
+  primary: color.cyanBright,
+  success: color.hex("#00FF88"),
+  warning: color.hex("#FFD166"),
+  error: color.hex("#EF476F"),
+  accent: color.magentaBright
+};
+function success(message) {
+  const text = theme.success(`[OK] ${message}`);
+  if (!isInteractive) {
+    console.log(text);
+    return;
+  }
+  try {
+    console.log(
+      (0, import_boxen.default)(text, {
+        padding: 1,
+        borderColor: "cyan",
+        borderStyle: "round"
+      })
+    );
+  } catch {
+    console.log(text);
+  }
+}
+function info(message) {
+  console.log(theme.primary(message));
+}
+function warning(message) {
+  console.warn(theme.warning(`[WARN] ${message}`));
+}
+function error(message) {
+  console.error(theme.error(`[ERROR] ${message}`));
+}
+function forceWarning(message) {
+  console.error(theme.warning(`[FORCE] ${message}`));
+}
+
+// src/utils/prompt.ts
+var import_node_readline = __toESM(require("readline"));
+function isCI() {
+  return process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true";
+}
+function formatFindingsSummary(findings) {
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const lines = [];
+  if (errors.length > 0) {
+    lines.push(theme.error("DESTRUCTIVE OPERATIONS:"));
+    for (const finding of errors) {
+      const columnPart = finding.column ? `.${finding.column}` : "";
+      const fromTo = finding.from && finding.to ? ` (${finding.from} \u2192 ${finding.to})` : "";
+      lines.push(theme.error(`  \u2022 ${finding.code}: ${finding.table}${columnPart}${fromTo}`));
+    }
+  }
+  if (warnings.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(theme.warning("WARNING OPERATIONS:"));
+    for (const finding of warnings) {
+      const columnPart = finding.column ? `.${finding.column}` : "";
+      const fromTo = finding.from && finding.to ? ` (${finding.from} \u2192 ${finding.to})` : "";
+      lines.push(theme.warning(`  \u2022 ${finding.code}: ${finding.table}${columnPart}${fromTo}`));
+    }
+  }
+  return lines.join("\n");
+}
+async function readConfirmation(input = process.stdin, output = process.stdout) {
+  const rl = import_node_readline.default.createInterface({
+    input,
+    output
+  });
+  return new Promise((resolve) => {
+    const askQuestion = () => {
+      rl.question(theme.primary("Proceed with these changes? (yes/no): "), (answer) => {
+        const normalized = answer.trim().toLowerCase();
+        if (normalized === "yes" || normalized === "y") {
+          rl.close();
+          resolve(true);
+        } else if (normalized === "no" || normalized === "n") {
+          rl.close();
+          resolve(false);
+        } else {
+          console.log(theme.warning('Please answer "yes" or "no".'));
+          askQuestion();
+        }
+      });
+    };
+    askQuestion();
+  });
+}
+async function confirmDestructiveOps(findings, input, output) {
+  const riskyFindings = findings.filter(
+    (f) => f.severity === "error" || f.severity === "warning"
+  );
+  if (riskyFindings.length === 0) {
+    return true;
+  }
+  if (isCI()) {
+    error("Cannot run interactive prompts in CI environment. Use --force flag to bypass safety checks.");
+    process.exitCode = EXIT_CODES.CI_DESTRUCTIVE;
+    return false;
+  }
+  console.log("");
+  console.log(formatFindingsSummary(riskyFindings));
+  console.log("");
+  const confirmed = await readConfirmation(input, output);
+  if (!confirmed) {
+    warning("Operation cancelled by user.");
+  }
+  return confirmed;
+}
+function hasDestructiveFindings(findings) {
+  return findings.some((f) => f.severity === "error" || f.severity === "warning");
+}
+
+// src/commands/diff.ts
+function resolveConfigPath(root, targetPath) {
+  return import_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
+}
+async function runDiff(options = {}) {
+  if (options.safe && options.force) {
+    throw new Error("Cannot use --safe and --force flags together. Choose one:\n  --safe: Block destructive operations\n  --force: Bypass safety checks");
+  }
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  const useLiveDatabase = Boolean(options.url || process.env.DATABASE_URL);
+  const requiredFields = useLiveDatabase ? ["schemaFile"] : ["schemaFile", "stateFile"];
+  for (const field of requiredFields) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath(root, config.schemaFile);
+  const statePath = config.stateFile ? resolveConfigPath(root, config.stateFile) : null;
+  const { provider } = resolveProvider(config.provider);
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = await parseSchema2(schemaSource);
+  try {
+    await validateSchema2(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
+    }
+    throw error2;
+  }
+  const previousState = useLiveDatabase ? await withPostgresQueryExecutor(
+    resolvePostgresConnectionString({ url: options.url }),
+    async (query) => {
+      const schemaFilters = parseSchemaList(options.schema);
+      const liveSchema = await introspectPostgresSchema2({
+        query,
+        ...schemaFilters ? { schemas: schemaFilters } : {}
+      });
+      return schemaToState2(liveSchema);
+    }
+  ) : await loadState2(statePath ?? "");
+  const diff2 = await diffSchemas2(previousState, schema);
+  if (options.force) {
+    forceWarning("Are you sure to use --force? This option will bypass safety checks for destructive operations.");
+  }
+  if (options.safe && !options.force && diff2.operations.length > 0) {
+    const findings = await validateSchemaChanges2(previousState, schema);
+    const destructiveFindings = findings.filter((f) => f.severity === "error");
+    if (destructiveFindings.length > 0) {
+      const errorMessages = destructiveFindings.map((f) => {
+        const target = f.column ? `${f.table}.${f.column}` : f.table;
+        const typeRange = f.from && f.to ? ` (${f.from} -> ${f.to})` : "";
+        return `  - ${f.code}: ${target}${typeRange}`;
+      }).join("\n");
+      throw await createSchemaValidationError(
+        `Cannot proceed with --safe flag: Found ${destructiveFindings.length} destructive operation(s):
+${errorMessages}
+
+Remove --safe flag or modify schema to avoid destructive changes.`
+      );
+    }
+  }
+  if (!options.safe && !options.force && diff2.operations.length > 0) {
+    const findings = await validateSchemaChanges2(previousState, schema);
+    const riskyFindings = findings.filter((f) => f.severity === "error" || f.severity === "warning");
+    if (riskyFindings.length > 0) {
+      const confirmed = await confirmDestructiveOps(findings);
+      if (!confirmed) {
+        if (process.exitCode !== EXIT_CODES.CI_DESTRUCTIVE) {
+          process.exitCode = EXIT_CODES.VALIDATION_ERROR;
+        }
+        return;
+      }
+    }
+  }
+  if (diff2.operations.length === 0) {
+    success("No changes detected");
+    process.exitCode = EXIT_CODES.SUCCESS;
+    return;
+  }
+  const sql = await generateSql2(diff2, provider, config.sql);
+  console.log(sql);
+  process.exitCode = EXIT_CODES.SUCCESS;
+}
+
+// src/commands/doctor.ts
+var import_commander2 = require("commander");
+var import_path8 = __toESM(require("path"));
+function resolveConfigPath2(root, targetPath) {
+  return import_path8.default.isAbsolute(targetPath) ? targetPath : import_path8.default.join(root, targetPath);
+}
+function hasDrift(report) {
+  return report.missingTables.length > 0 || report.extraTables.length > 0 || report.columnDifferences.length > 0 || report.typeMismatches.length > 0;
+}
+function printDriftReport(report) {
+  if (report.missingTables.length > 0) {
+    console.log(`Missing tables in live DB: ${report.missingTables.join(", ")}`);
+  }
+  if (report.extraTables.length > 0) {
+    console.log(`Extra tables in live DB: ${report.extraTables.join(", ")}`);
+  }
+  for (const difference of report.columnDifferences) {
+    if (difference.missingInLive.length > 0) {
+      console.log(`Missing columns in ${difference.tableName}: ${difference.missingInLive.join(", ")}`);
+    }
+    if (difference.extraInLive.length > 0) {
+      console.log(`Extra columns in ${difference.tableName}: ${difference.extraInLive.join(", ")}`);
+    }
+  }
+  for (const mismatch of report.typeMismatches) {
+    console.log(`Type mismatch ${mismatch.tableName}.${mismatch.columnName}: ${mismatch.expectedType} -> ${mismatch.actualType}`);
+  }
+}
+async function runDoctor(options = {}) {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  if (!config.stateFile || typeof config.stateFile !== "string") {
+    throw new Error("Invalid config: 'stateFile' is required");
+  }
+  const statePath = resolveConfigPath2(root, config.stateFile);
+  const previousState = await loadState2(statePath);
+  const schemaFilters = parseSchemaList(options.schema);
+  const liveSchema = await withPostgresQueryExecutor(
+    resolvePostgresConnectionString({ url: options.url }),
+    (query) => introspectPostgresSchema2({
+      query,
+      ...schemaFilters ? { schemas: schemaFilters } : {}
+    })
+  );
+  const driftReport = await analyzeSchemaDrift2(previousState, liveSchema);
+  const detected = hasDrift(driftReport);
+  process.exitCode = detected ? EXIT_CODES.DRIFT_DETECTED : EXIT_CODES.SUCCESS;
+  if (options.json) {
+    console.log(JSON.stringify(driftReport, null, 2));
+    return;
+  }
+  if (!detected) {
+    success("No schema drift detected");
+    return;
+  }
+  console.log("Schema drift detected");
+  printDriftReport(driftReport);
+}
+
+// src/commands/generate.ts
+var import_commander3 = require("commander");
+var import_path9 = __toESM(require("path"));
+
+// src/core/utils.ts
+function nowTimestamp2() {
+  const date = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return String(date.getFullYear()) + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
+}
+function slugifyName2(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
+}
+
+// src/commands/generate.ts
+var REQUIRED_CONFIG_FIELDS = [
+  "schemaFile",
+  "stateFile",
+  "outputDir"
+];
+function resolveConfigPath3(root, targetPath) {
+  return import_path9.default.isAbsolute(targetPath) ? targetPath : import_path9.default.join(root, targetPath);
+}
+async function runGenerate(options) {
+  if (options.safe && options.force) {
+    throw new Error("Cannot use --safe and --force flags together. Choose one:\n  --safe: Block destructive operations\n  --force: Bypass safety checks");
+  }
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  for (const field of REQUIRED_CONFIG_FIELDS) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath3(root, config.schemaFile);
+  const statePath = resolveConfigPath3(root, config.stateFile);
+  const outputDir = resolveConfigPath3(root, config.outputDir);
+  const { provider, usedDefault } = resolveProvider(config.provider);
+  if (usedDefault) {
+    info("Provider not set; defaulting to postgres.");
+  }
+  info("Generating SQL...");
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = await parseSchema2(schemaSource);
+  try {
+    await validateSchema2(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
+    }
+    throw error2;
+  }
+  const previousState = await loadState2(statePath);
+  const diff2 = await diffSchemas2(previousState, schema);
+  if (options.force) {
+    forceWarning("Are you sure to use --force? This option will bypass safety checks for destructive operations.");
+  }
+  if (options.safe && !options.force && diff2.operations.length > 0) {
+    const findings = await validateSchemaChanges2(previousState, schema);
+    const destructiveFindings = findings.filter((f) => f.severity === "error");
+    if (destructiveFindings.length > 0) {
+      const errorMessages = destructiveFindings.map((f) => {
+        const target = f.column ? `${f.table}.${f.column}` : f.table;
+        const typeRange = f.from && f.to ? ` (${f.from} -> ${f.to})` : "";
+        return `  - ${f.code}: ${target}${typeRange}`;
+      }).join("\n");
+      throw await createSchemaValidationError(
+        `Cannot proceed with --safe flag: Found ${destructiveFindings.length} destructive operation(s):
+${errorMessages}
+
+Remove --safe flag or modify schema to avoid destructive changes.`
+      );
+    }
+  }
+  if (!options.safe && !options.force && diff2.operations.length > 0) {
+    const findings = await validateSchemaChanges2(previousState, schema);
+    const riskyFindings = findings.filter((f) => f.severity === "error" || f.severity === "warning");
+    if (riskyFindings.length > 0) {
+      const confirmed = await confirmDestructiveOps(findings);
+      if (!confirmed) {
+        if (process.exitCode !== EXIT_CODES.CI_DESTRUCTIVE) {
+          process.exitCode = EXIT_CODES.VALIDATION_ERROR;
+        }
+        return;
+      }
+    }
+  }
+  if (diff2.operations.length === 0) {
+    info("No changes detected");
+    process.exitCode = EXIT_CODES.SUCCESS;
+    return;
+  }
+  const sql = await generateSql2(diff2, provider, config.sql);
+  const timestamp = nowTimestamp2();
+  const slug = slugifyName2(options.name ?? "migration");
+  const fileName = `${timestamp}-${slug}.sql`;
+  await ensureDir(outputDir);
+  const migrationPath = import_path9.default.join(outputDir, fileName);
+  await writeTextFile(migrationPath, sql + "\n");
+  const nextState = await schemaToState2(schema);
+  await saveState2(statePath, nextState);
+  success(`SQL generated successfully: ${migrationPath}`);
+  process.exitCode = EXIT_CODES.SUCCESS;
+}
+
+// src/commands/import.ts
+var import_commander4 = require("commander");
+var import_path10 = __toESM(require("path"));
+function resolveConfigPath4(root, targetPath) {
+  return import_path10.default.isAbsolute(targetPath) ? targetPath : import_path10.default.join(root, targetPath);
+}
+async function runImport(inputPath, options = {}) {
+  const root = getProjectRoot();
+  const absoluteInputPath = resolveConfigPath4(root, inputPath);
+  const inputs = await loadMigrationSqlInput2(absoluteInputPath);
+  if (inputs.length === 0) {
+    throw new Error(`No .sql migration files found in: ${absoluteInputPath}`);
+  }
+  const allOps = [];
+  const parseWarnings = [];
+  for (const input of inputs) {
+    const result = await parseMigrationSql2(input.sql);
+    allOps.push(...result.ops);
+    parseWarnings.push(...result.warnings.map((item) => ({
+      statement: `[${import_path10.default.basename(input.filePath)}] ${item.statement}`,
+      reason: item.reason
+    })));
+  }
+  const applied = await applySqlOps2(allOps);
+  const dsl = await schemaToDsl2(applied.schema);
+  let targetPath = options.out;
+  if (!targetPath) {
+    const configPath = getConfigPath(root);
+    if (await fileExists(configPath)) {
+      const config = await readJsonFile(configPath, {});
+      if (typeof config.schemaFile === "string" && config.schemaFile.length > 0) {
+        targetPath = config.schemaFile;
+      }
+    }
+  }
+  const schemaPath = targetPath ? resolveConfigPath4(root, targetPath) : getSchemaFilePath(root);
+  await writeTextFile(schemaPath, dsl);
+  success(`Imported ${inputs.length} migration file(s) into ${schemaPath}`);
+  info(`Parsed ${allOps.length} supported DDL operation(s)`);
+  const warnings = [...parseWarnings, ...applied.warnings];
+  if (warnings.length > 0) {
+    warning(`Ignored ${warnings.length} unsupported item(s)`);
+    for (const item of warnings.slice(0, 10)) {
+      warning(`${item.reason}: ${item.statement}`);
+    }
+    if (warnings.length > 10) {
+      warning(`...and ${warnings.length - 10} more`);
+    }
+  }
+  process.exitCode = EXIT_CODES.SUCCESS;
+}
+
+// src/commands/init.ts
+var import_commander5 = require("commander");
+async function runInit() {
+  const root = getProjectRoot();
+  const schemaForgeDir = getSchemaForgeDir(root);
+  if (await fileExists(schemaForgeDir)) {
+    throw new Error("schemaforge/ directory already exists. Please remove it or run init in a different directory.");
+  }
+  const schemaFilePath = getSchemaFilePath(root);
+  const configPath = getConfigPath(root);
+  const statePath = getStatePath(root);
+  if (await fileExists(schemaFilePath)) {
+    throw new Error(`${schemaFilePath} already exists`);
+  }
+  if (await fileExists(configPath)) {
+    throw new Error(`${configPath} already exists`);
+  }
+  if (await fileExists(statePath)) {
+    throw new Error(`${statePath} already exists`);
+  }
+  info("Initializing schema project...");
+  await ensureDir(schemaForgeDir);
+  const schemaContent = `# SchemaForge schema definition
+# Run: schema-forge generate
+
+table users {
+  id uuid pk
+  created_at timestamptz default now()
+}
+`;
+  await writeTextFile(schemaFilePath, schemaContent);
+  success(`Created ${schemaFilePath}`);
+  const config = {
+    provider: "postgres",
+    outputDir: "migrations",
+    schemaFile: "schemaforge/schema.sf",
+    stateFile: "schemaforge/state.json",
+    sql: {
+      uuidDefault: "gen_random_uuid()",
+      timestampDefault: "now()"
+    }
+  };
+  await writeJsonFile(configPath, config);
+  success(`Created ${configPath}`);
+  const state = {
+    version: 1,
+    tables: {}
+  };
+  await writeJsonFile(statePath, state);
+  success(`Created ${statePath}`);
+  const outputDir = "migrations";
+  await ensureDir(outputDir);
+  success(`Created ${outputDir}`);
+  success("Project initialized successfully");
+  info("Next steps:");
+  info("  1. Edit schemaforge/schema.sf to define your schema");
+  info("  2. Run: schema-forge generate");
+  process.exitCode = EXIT_CODES.SUCCESS;
+}
+
+// src/commands/introspect.ts
+var import_commander6 = require("commander");
+var import_path11 = __toESM(require("path"));
+function resolveOutputPath(root, outputPath) {
+  return import_path11.default.isAbsolute(outputPath) ? outputPath : import_path11.default.join(root, outputPath);
+}
+async function runIntrospect(options = {}) {
+  const connectionString = resolvePostgresConnectionString({ url: options.url });
+  const schemas = parseSchemaList(options.schema);
+  const root = getProjectRoot();
+  const schema = await withPostgresQueryExecutor(connectionString, (query) => introspectPostgresSchema2({
+    query,
+    ...schemas ? { schemas } : {}
+  }));
+  const output = JSON.stringify(schema, null, 2);
+  if (!options.json && !options.out) {
+    info(`Introspected ${Object.keys(schema.tables).length} table(s) from PostgreSQL.`);
+  }
+  if (options.out) {
+    const outputPath = resolveOutputPath(root, options.out);
+    await writeTextFile(outputPath, `${output}
+`);
+    success(`Live schema written to ${outputPath}`);
+  }
+  if (options.json || !options.out) {
+    console.log(output);
+  }
+}
+
+// src/commands/validate.ts
+var import_commander7 = require("commander");
+var import_path12 = __toESM(require("path"));
+function resolveConfigPath5(root, targetPath) {
+  return import_path12.default.isAbsolute(targetPath) ? targetPath : import_path12.default.join(root, targetPath);
+}
+async function runValidate(options = {}) {
+  const root = getProjectRoot();
+  const configPath = getConfigPath(root);
+  const useLiveDatabase = Boolean(options.url || process.env.DATABASE_URL);
+  if (!await fileExists(configPath)) {
+    throw new Error('SchemaForge project not initialized. Run "schema-forge init" first.');
+  }
+  const config = await readJsonFile(configPath, {});
+  const requiredFields = ["schemaFile", "stateFile"];
+  for (const field of requiredFields) {
+    const value = config[field];
+    if (!value || typeof value !== "string") {
+      throw new Error(`Invalid config: '${field}' is required`);
+    }
+  }
+  const schemaPath = resolveConfigPath5(root, config.schemaFile);
+  if (!config.stateFile) {
+    throw new Error("Invalid config: 'stateFile' is required");
+  }
+  const statePath = resolveConfigPath5(root, config.stateFile);
+  const schemaSource = await readTextFile(schemaPath);
+  const schema = await parseSchema2(schemaSource);
+  try {
+    await validateSchema2(schema);
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      throw await createSchemaValidationError(error2.message);
+    }
+    throw error2;
+  }
+  const previousState = await loadState2(statePath);
+  if (useLiveDatabase) {
+    const schemaFilters = parseSchemaList(options.schema);
+    const liveSchema = await withPostgresQueryExecutor(
+      resolvePostgresConnectionString({ url: options.url }),
+      (query) => introspectPostgresSchema2({
+        query,
+        ...schemaFilters ? { schemas: schemaFilters } : {}
+      })
+    );
+    const driftReport = await analyzeSchemaDrift2(previousState, liveSchema);
+    const hasDrift2 = driftReport.missingTables.length > 0 || driftReport.extraTables.length > 0 || driftReport.columnDifferences.length > 0 || driftReport.typeMismatches.length > 0;
+    process.exitCode = hasDrift2 ? EXIT_CODES.DRIFT_DETECTED : EXIT_CODES.SUCCESS;
+    if (options.json) {
+      console.log(JSON.stringify(driftReport, null, 2));
+      return;
+    }
+    if (!hasDrift2) {
+      success("No schema drift detected");
+      return;
+    }
+    if (driftReport.missingTables.length > 0) {
+      console.log(`Missing tables in live DB: ${driftReport.missingTables.join(", ")}`);
+    }
+    if (driftReport.extraTables.length > 0) {
+      console.log(`Extra tables in live DB: ${driftReport.extraTables.join(", ")}`);
+    }
+    for (const difference of driftReport.columnDifferences) {
+      if (difference.missingInLive.length > 0) {
+        console.log(`Missing columns in ${difference.tableName}: ${difference.missingInLive.join(", ")}`);
+      }
+      if (difference.extraInLive.length > 0) {
+        console.log(`Extra columns in ${difference.tableName}: ${difference.extraInLive.join(", ")}`);
+      }
+    }
+    for (const mismatch of driftReport.typeMismatches) {
+      console.log(`Type mismatch ${mismatch.tableName}.${mismatch.columnName}: ${mismatch.expectedType} -> ${mismatch.actualType}`);
+    }
+    return;
+  }
+  const findings = await validateSchemaChanges2(previousState, schema);
+  const report = await toValidationReport2(findings);
+  if (isCI() && hasDestructiveFindings(findings)) {
+    process.exitCode = EXIT_CODES.CI_DESTRUCTIVE;
+  } else {
+    process.exitCode = report.hasErrors ? EXIT_CODES.VALIDATION_ERROR : EXIT_CODES.SUCCESS;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  if (findings.length === 0) {
+    success("No destructive changes detected");
+    return;
+  }
+  console.log(
+    `Validation Summary: ${report.errors.length} error(s), ${report.warnings.length} warning(s)`
+  );
+  const tableOrder = Array.from(new Set(findings.map((finding) => finding.table)));
+  for (const tableName of tableOrder) {
+    console.log(tableName);
+    for (const finding of findings.filter((entry) => entry.table === tableName)) {
+      const target = finding.column ? `${finding.table}.${finding.column}` : finding.table;
+      const typeRange = finding.from && finding.to ? ` (${finding.from} -> ${finding.to})` : "";
+      console.log(
+        `${finding.severity.toUpperCase()}: ${finding.code} ${target}${typeRange} - ${finding.message}`
+      );
+    }
+  }
+}
+
+// src/api.ts
+function captureExitCode() {
+  const raw = process.exitCode;
+  process.exitCode = void 0;
+  return typeof raw === "number" ? raw : 0;
+}
+async function runWithResult(fn) {
+  try {
+    await fn();
+    return { exitCode: captureExitCode() };
+  } catch {
+    process.exitCode = void 0;
+    return { exitCode: EXIT_CODES.VALIDATION_ERROR };
+  }
+}
+async function init() {
+  return runWithResult(() => runInit());
+}
+async function generate(options = {}) {
+  return runWithResult(() => runGenerate(options));
+}
+async function diff(options = {}) {
+  return runWithResult(() => runDiff(options));
+}
+async function doctor(options = {}) {
+  return runWithResult(() => runDoctor(options));
+}
+async function validate(options = {}) {
+  return runWithResult(() => runValidate(options));
+}
+async function introspect(options = {}) {
+  return runWithResult(() => runIntrospect(options));
+}
+async function importSchema(inputPath, options = {}) {
+  return runWithResult(() => runImport(inputPath, options));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXIT_CODES,
+  diff,
+  doctor,
+  generate,
+  importSchema,
+  init,
+  introspect,
+  validate
+});