@xubylele/schema-forge 1.5.0 → 1.5.2

package/dist/cli.js

@@ -6,6 +6,13 @@ 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))
@@ -23,13 +30,2144 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 normalizeColumnType3(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 = normalizeColumnType3(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 = normalizeColumnType3(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/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/validate.js
+function normalizeColumnType2(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 = normalizeColumnType2(type).match(/^varchar\((\d+)\)$/);
+  return match ? Number(match[1]) : null;
+}
+function parseNumericType(type) {
+  const match = normalizeColumnType2(type).match(/^numeric\((\d+),(\d+)\)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    precision: Number(match[1]),
+    scale: Number(match[2])
+  };
+}
+function classifyTypeChange(from, to) {
+  const fromType = normalizeColumnType2(from);
+  const toType = normalizeColumnType2(to);
+  const uuidInvolved = fromType === "uuid" || toType === "uuid";
+  if (uuidInvolved && fromType !== toType) {
+    return {
+      severity: "error",
+      message: `Type changed from ${fromType} to ${toType} (likely incompatible cast)`
+    };
+  }
+  if (fromType === "int" && toType === "bigint") {
+    return {
+      severity: "warning",
+      message: "Type widened from int to bigint"
+    };
+  }
+  if (fromType === "bigint" && toType === "int") {
+    return {
+      severity: "error",
+      message: "Type narrowed from bigint to int (likely incompatible cast)"
+    };
+  }
+  if (fromType === "text" && parseVarcharLength(toType) !== null) {
+    return {
+      severity: "error",
+      message: `Type changed from text to ${toType} (may truncate existing values)`
+    };
+  }
+  if (parseVarcharLength(fromType) !== null && toType === "text") {
+    return {
+      severity: "warning",
+      message: "Type widened from varchar(n) to text"
+    };
+  }
+  const fromVarcharLength = parseVarcharLength(fromType);
+  const toVarcharLength = parseVarcharLength(toType);
+  if (fromVarcharLength !== null && toVarcharLength !== null) {
+    if (toVarcharLength >= fromVarcharLength) {
+      return {
+        severity: "warning",
+        message: `Type widened from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`
+      };
+    }
+    return {
+      severity: "error",
+      message: `Type narrowed from varchar(${fromVarcharLength}) to varchar(${toVarcharLength})`
+    };
+  }
+  const fromNumeric = parseNumericType(fromType);
+  const toNumeric = parseNumericType(toType);
+  if (fromNumeric && toNumeric && fromNumeric.scale === toNumeric.scale) {
+    if (toNumeric.precision >= fromNumeric.precision) {
+      return {
+        severity: "warning",
+        message: `Type widened from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`
+      };
+    }
+    return {
+      severity: "error",
+      message: `Type narrowed from numeric(${fromNumeric.precision},${fromNumeric.scale}) to numeric(${toNumeric.precision},${toNumeric.scale})`
+    };
+  }
+  return {
+    severity: "warning",
+    message: `Type changed from ${fromType} to ${toType} (compatibility unknown)`
+  };
+}
+function validateSchemaChanges(previousState, currentSchema) {
+  const findings = [];
+  const diff = diffSchemas(previousState, currentSchema);
+  for (const operation of diff.operations) {
+    switch (operation.kind) {
+      case "drop_table":
+        findings.push({
+          severity: "error",
+          code: "DROP_TABLE",
+          table: operation.tableName,
+          message: "Table removed"
+        });
+        break;
+      case "drop_column":
+        findings.push({
+          severity: "error",
+          code: "DROP_COLUMN",
+          table: operation.tableName,
+          column: operation.columnName,
+          message: "Column removed"
+        });
+        break;
+      case "column_type_changed": {
+        const classification = classifyTypeChange(operation.fromType, operation.toType);
+        findings.push({
+          severity: classification.severity,
+          code: "ALTER_COLUMN_TYPE",
+          table: operation.tableName,
+          column: operation.columnName,
+          from: normalizeColumnType2(operation.fromType),
+          to: normalizeColumnType2(operation.toType),
+          message: classification.message
+        });
+        break;
+      }
+      case "column_nullability_changed":
+        if (operation.from && !operation.to) {
+          findings.push({
+            severity: "warning",
+            code: "SET_NOT_NULL",
+            table: operation.tableName,
+            column: operation.columnName,
+            message: "Column changed to NOT NULL (may fail if data contains NULLs)"
+          });
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  return findings;
+}
+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_diff();
+  }
+});
+
+// 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-manager.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
+  };
+}
+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();
+  }
+});
+
+// node_modules/@xubylele/schema-forge-core/dist/generator/sql-generator.js
+function generateSql(diff, provider, sqlConfig) {
+  const statements = [];
+  for (const operation of diff.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/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,
+  applySqlOps: () => applySqlOps,
+  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,
+  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_validator();
+    init_validate();
+    init_state_manager();
+    init_sql_generator();
+    init_parse_migration();
+    init_apply_ops();
+    init_schema_to_dsl();
+    init_load_migrations();
+    init_split_statements();
+    init_fs();
+    init_normalize();
+    init_paths();
+    init_utils();
+    init_errors();
+  }
+});
+
 // src/cli.ts
 var import_commander6 = require("commander");
 
 // package.json
 var package_default = {
   name: "@xubylele/schema-forge",
-  version: "1.5.0",
+  version: "1.5.2",
   description: "Universal migration generator from schema DSL",
   main: "dist/cli.js",
   type: "commonjs",
@@ -69,7 +2207,6 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
-    "@xubylele/schema-forge-core": "^1.0.4",
     boxen: "^8.0.1",
     chalk: "^5.6.2",
     commander: "^14.0.3"
@@ -77,6 +2214,7 @@ var package_default = {
   devDependencies: {
     "@changesets/cli": "^2.29.8",
     "@types/node": "^25.2.3",
+    "@xubylele/schema-forge-core": "^1.1.0",
     "ts-node": "^10.9.2",
     tsup: "^8.5.1",
     typescript: "^5.9.3",
@@ -86,7 +2224,7 @@ var package_default = {
 
 // src/commands/diff.ts
 var import_commander = require("commander");
-var import_path3 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 
 // src/core/fs.ts
 var import_fs = require("fs");
@@ -179,59 +2317,59 @@ function resolveProvider(provider) {
 var corePromise;
 async function loadCore() {
   if (!corePromise) {
-    corePromise = import("@xubylele/schema-forge-core");
+    corePromise = Promise.resolve().then(() => (init_dist(), dist_exports));
   }
   return corePromise;
 }
-async function parseSchema(source) {
+async function parseSchema2(source) {
   const core = await loadCore();
   return core.parseSchema(source);
 }
-async function validateSchema(schema) {
+async function validateSchema2(schema) {
   const core = await loadCore();
   core.validateSchema(schema);
 }
-async function diffSchemas(previousState, currentSchema) {
+async function diffSchemas2(previousState, currentSchema) {
   const core = await loadCore();
   return core.diffSchemas(previousState, currentSchema);
 }
-async function generateSql(diff, provider, config) {
+async function generateSql2(diff, provider, config) {
   const core = await loadCore();
   return core.generateSql(diff, provider, config);
 }
-async function schemaToState(schema) {
+async function schemaToState2(schema) {
   const core = await loadCore();
   return core.schemaToState(schema);
 }
-async function loadState(statePath) {
+async function loadState2(statePath) {
   const core = await loadCore();
   return core.loadState(statePath);
 }
-async function saveState(statePath, state) {
+async function saveState2(statePath, state) {
   const core = await loadCore();
   return core.saveState(statePath, state);
 }
-async function validateSchemaChanges(previousState, currentSchema) {
+async function validateSchemaChanges2(previousState, currentSchema) {
   const core = await loadCore();
   return core.validateSchemaChanges(previousState, currentSchema);
 }
-async function toValidationReport(findings) {
+async function toValidationReport2(findings) {
   const core = await loadCore();
   return core.toValidationReport(findings);
 }
-async function parseMigrationSql(sql) {
+async function parseMigrationSql2(sql) {
   const core = await loadCore();
   return core.parseMigrationSql(sql);
 }
-async function applySqlOps(ops) {
+async function applySqlOps2(ops) {
   const core = await loadCore();
   return core.applySqlOps(ops);
 }
-async function schemaToDsl(schema) {
+async function schemaToDsl2(schema) {
   const core = await loadCore();
   return core.schemaToDsl(schema);
 }
-async function loadMigrationSqlInput(inputPath) {
+async function loadMigrationSqlInput2(inputPath) {
   const core = await loadCore();
   return core.loadMigrationSqlInput(inputPath);
 }
@@ -288,7 +2426,7 @@ function error(message) {
 // src/commands/diff.ts
 var REQUIRED_CONFIG_FIELDS = ["schemaFile", "stateFile"];
 function resolveConfigPath(root, targetPath) {
-  return import_path3.default.isAbsolute(targetPath) ? targetPath : import_path3.default.join(root, targetPath);
+  return import_path7.default.isAbsolute(targetPath) ? targetPath : import_path7.default.join(root, targetPath);
 }
 async function runDiff() {
   const root = getProjectRoot();
@@ -307,36 +2445,36 @@ async function runDiff() {
   const statePath = resolveConfigPath(root, config.stateFile);
   const { provider } = resolveProvider(config.provider);
   const schemaSource = await readTextFile(schemaPath);
-  const schema = await parseSchema(schemaSource);
+  const schema = await parseSchema2(schemaSource);
   try {
-    await validateSchema(schema);
+    await validateSchema2(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
       throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
-  const previousState = await loadState(statePath);
-  const diff = await diffSchemas(previousState, schema);
+  const previousState = await loadState2(statePath);
+  const diff = await diffSchemas2(previousState, schema);
   if (diff.operations.length === 0) {
     success("No changes detected");
     return;
   }
-  const sql = await generateSql(diff, provider, config.sql);
+  const sql = await generateSql2(diff, provider, config.sql);
   console.log(sql);
 }
 
 // src/commands/generate.ts
 var import_commander2 = require("commander");
-var import_path4 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 
 // src/core/utils.ts
-function nowTimestamp() {
+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 slugifyName(name) {
+function slugifyName2(name) {
   return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "migration";
 }
 
@@ -347,7 +2485,7 @@ var REQUIRED_CONFIG_FIELDS2 = [
   "outputDir"
 ];
 function resolveConfigPath2(root, targetPath) {
-  return import_path4.default.isAbsolute(targetPath) ? targetPath : import_path4.default.join(root, targetPath);
+  return import_path8.default.isAbsolute(targetPath) ? targetPath : import_path8.default.join(root, targetPath);
 }
 async function runGenerate(options) {
   const root = getProjectRoot();
@@ -371,58 +2509,58 @@ async function runGenerate(options) {
   }
   info("Generating SQL...");
   const schemaSource = await readTextFile(schemaPath);
-  const schema = await parseSchema(schemaSource);
+  const schema = await parseSchema2(schemaSource);
   try {
-    await validateSchema(schema);
+    await validateSchema2(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
       throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
-  const previousState = await loadState(statePath);
-  const diff = await diffSchemas(previousState, schema);
+  const previousState = await loadState2(statePath);
+  const diff = await diffSchemas2(previousState, schema);
   if (diff.operations.length === 0) {
     info("No changes detected");
     return;
   }
-  const sql = await generateSql(diff, provider, config.sql);
-  const timestamp = nowTimestamp();
-  const slug = slugifyName(options.name ?? "migration");
+  const sql = await generateSql2(diff, provider, config.sql);
+  const timestamp = nowTimestamp2();
+  const slug = slugifyName2(options.name ?? "migration");
   const fileName = `${timestamp}-${slug}.sql`;
   await ensureDir(outputDir);
-  const migrationPath = import_path4.default.join(outputDir, fileName);
+  const migrationPath = import_path8.default.join(outputDir, fileName);
   await writeTextFile(migrationPath, sql + "\n");
-  const nextState = await schemaToState(schema);
-  await saveState(statePath, nextState);
+  const nextState = await schemaToState2(schema);
+  await saveState2(statePath, nextState);
   success(`SQL generated successfully: ${migrationPath}`);
 }
 
 // src/commands/import.ts
 var import_commander3 = require("commander");
-var import_path5 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 function resolveConfigPath3(root, targetPath) {
-  return import_path5.default.isAbsolute(targetPath) ? targetPath : import_path5.default.join(root, targetPath);
+  return import_path9.default.isAbsolute(targetPath) ? targetPath : import_path9.default.join(root, targetPath);
 }
 async function runImport(inputPath, options = {}) {
   const root = getProjectRoot();
   const absoluteInputPath = resolveConfigPath3(root, inputPath);
-  const inputs = await loadMigrationSqlInput(absoluteInputPath);
+  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 parseMigrationSql(input.sql);
+    const result = await parseMigrationSql2(input.sql);
     allOps.push(...result.ops);
     parseWarnings.push(...result.warnings.map((item) => ({
-      statement: `[${import_path5.default.basename(input.filePath)}] ${item.statement}`,
+      statement: `[${import_path9.default.basename(input.filePath)}] ${item.statement}`,
       reason: item.reason
     })));
   }
-  const applied = await applySqlOps(allOps);
-  const dsl = await schemaToDsl(applied.schema);
+  const applied = await applySqlOps2(allOps);
+  const dsl = await schemaToDsl2(applied.schema);
   let targetPath = options.out;
   if (!targetPath) {
     const configPath = getConfigPath(root);
@@ -515,10 +2653,10 @@ table users {
 
 // src/commands/validate.ts
 var import_commander5 = require("commander");
-var import_path6 = __toESM(require("path"));
+var import_path10 = __toESM(require("path"));
 var REQUIRED_CONFIG_FIELDS3 = ["schemaFile", "stateFile"];
 function resolveConfigPath4(root, targetPath) {
-  return import_path6.default.isAbsolute(targetPath) ? targetPath : import_path6.default.join(root, targetPath);
+  return import_path10.default.isAbsolute(targetPath) ? targetPath : import_path10.default.join(root, targetPath);
 }
 async function runValidate(options = {}) {
   const root = getProjectRoot();
@@ -536,18 +2674,18 @@ async function runValidate(options = {}) {
   const schemaPath = resolveConfigPath4(root, config.schemaFile);
   const statePath = resolveConfigPath4(root, config.stateFile);
   const schemaSource = await readTextFile(schemaPath);
-  const schema = await parseSchema(schemaSource);
+  const schema = await parseSchema2(schemaSource);
   try {
-    await validateSchema(schema);
+    await validateSchema2(schema);
   } catch (error2) {
     if (error2 instanceof Error) {
       throw await createSchemaValidationError(error2.message);
     }
     throw error2;
   }
-  const previousState = await loadState(statePath);
-  const findings = await validateSchemaChanges(previousState, schema);
-  const report = await toValidationReport(findings);
+  const previousState = await loadState2(statePath);
+  const findings = await validateSchemaChanges2(previousState, schema);
+  const report = await toValidationReport2(findings);
   if (options.json) {
     console.log(JSON.stringify(report, null, 2));
     process.exitCode = report.hasErrors ? 1 : 0;