@launchsecure/launch-kit 0.0.29 → 0.0.30

package/dist/server/parse-worker-entry.js

@@ -1184,6 +1184,8 @@ function extractDeep(absPath) {
     false
   );
   const hasEffects = Object.keys(fileEffects).length > 0;
+  const uiLabels = collectUiLabels(root);
+  const notes = collectNotes(root);
   return {
     elements,
     stateVars,
@@ -1191,10 +1193,77 @@ function extractDeep(absPath) {
     variables,
     responses,
     params,
-    ...hasEffects ? { effects: fileEffects } : {}
+    ...hasEffects ? { effects: fileEffects } : {},
+    ...uiLabels.length > 0 ? { ui_labels: uiLabels } : {},
+    ...notes.length > 0 ? { notes } : {}
   };
 }
-var import_node_fs5, import_node_path5, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS;
+function collectNotes(root) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (out.length >= NOTES_MAX) return;
+    if (node.type === "comment") {
+      const text = node.text;
+      const startRow = node.startPosition.row;
+      NOTE_REGEX.lastIndex = 0;
+      let m;
+      while ((m = NOTE_REGEX.exec(text)) !== null) {
+        const kind = m[1];
+        const author = m[2];
+        const body = m[3];
+        if (!kind || !body) continue;
+        const newlinesBefore = (text.slice(0, m.index).match(/\n/g) ?? []).length;
+        const line = startRow + 1 + newlinesBefore;
+        const key = `${line}:${kind}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const note = {
+          kind,
+          text: body.length <= 200 ? body : body.slice(0, 200) + "...",
+          line
+        };
+        if (author) note.author = author;
+        out.push(note);
+        if (out.length >= NOTES_MAX) return;
+      }
+    }
+    for (const child of node.namedChildren) {
+      visit(child);
+      if (out.length >= NOTES_MAX) return;
+    }
+  }
+  visit(root);
+  return out;
+}
+function collectUiLabels(root) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (out.length >= UI_LABELS_MAX) return;
+    if (node.type === "pair") {
+      const key = node.childForFieldName("key");
+      const val = node.childForFieldName("value");
+      if (key && val) {
+        const keyText = key.type === "property_identifier" ? key.text : stringLiteralValue(key) ?? key.text;
+        if (UI_LABEL_KEYS.has(keyText)) {
+          const strVal = stringLiteralValue(val);
+          if (strVal && strVal.length > 0 && strVal.length <= 200 && !seen.has(strVal)) {
+            seen.add(strVal);
+            out.push(strVal);
+          }
+        }
+      }
+    }
+    for (const child of node.namedChildren) {
+      visit(child);
+      if (out.length >= UI_LABELS_MAX) return;
+    }
+  }
+  visit(root);
+  return out;
+}
+var import_node_fs5, import_node_path5, tsxLanguage, parserInstance, TreeSitterCtor, initPromise, initialized, queriesDir, queryCache, MAX_PARSEABLE_BYTES, MAX_CONSECUTIVE_PARSE_FAILURES, consecutiveParseFailures, ParseCascadeError, PRISMA_MUTATION_METHODS_BUILTIN, SUPABASE_MUTATION_METHODS_BUILTIN, DB_IDENTIFIERS_FALLBACK, extraDbIdentifiers, extraMutationMethods, INLINE_AUTH_IMPORTS, EXEMPT_NAME_PATTERNS, PROTECT_NAME_PATTERNS, TRUST_AS_PROTECT_KEYS, TIMER_FNS, DOM_METHOD_NAMES, CLASSLIST_METHODS, STORAGE_OBJECTS, HISTORY_METHODS, LOCATION_METHODS, ASSIGN_DOM_PROPS, UI_LABEL_KEYS, UI_LABELS_MAX, NOTE_REGEX, NOTES_MAX;
 var init_ts_extractor = __esm({
   "src/server/graph/core/ts-extractor.ts"() {
     "use strict";
@@ -1313,6 +1382,27 @@ var init_ts_extractor = __esm({
       "selected",
       "disabled"
     ]);
+    UI_LABEL_KEYS = /* @__PURE__ */ new Set([
+      "label",
+      "title",
+      "name",
+      "text",
+      "description",
+      "placeholder",
+      "tooltip",
+      "heading",
+      "subheading",
+      "sheetTitle",
+      "sheetDescription",
+      "caption",
+      "cta",
+      "buttonText",
+      "emptyText",
+      "subtitle"
+    ]);
+    UI_LABELS_MAX = 200;
+    NOTE_REGEX = /^\s*(?:\/\/|\/\*+|\*)\s*([A-Z][A-Z0-9_]{1,15})(?:\(([^)]+)\))?:\s*(\S.*?)\s*(?:\*\/)?$/gm;
+    NOTES_MAX = 100;
   }
 });
 
@@ -1320,6 +1410,7 @@ var init_ts_extractor = __esm({
 var parse_worker_entry_exports = {};
 module.exports = __toCommonJS(parse_worker_entry_exports);
 var import_node_worker_threads = require("node:worker_threads");
+var import_pgsql_parser2 = require("pgsql-parser");
 
 // src/server/graph/core/config.ts
 var import_node_fs = require("node:fs");
@@ -1988,6 +2079,7 @@ function generate(rootDir) {
         responses: deep.responses,
         params: deep.params,
         ...deep.effects ? { effects: deep.effects } : {},
+        ...deep.notes ? { notes: deep.notes } : {},
         _dbCalls: dbCalls
         // temp: used for cross-ref building below
       });
@@ -2008,6 +2100,8 @@ function generate(rootDir) {
         conditions: deep.conditions,
         variables: deep.variables,
         ...deep.effects ? { effects: deep.effects } : {},
+        ...deep.ui_labels ? { ui_labels: deep.ui_labels } : {},
+        ...deep.notes ? { notes: deep.notes } : {},
         ...authWrappers.length > 0 ? { auth: authWrappers } : {},
         ...dbCalls.length > 0 ? { _dbCalls: dbCalls } : {}
       });
@@ -2608,6 +2702,7 @@ var prismaSchemaParser = {
 // src/server/graph/parsers/db/sql-migrations.ts
 var import_node_fs8 = require("node:fs");
 var import_node_path7 = require("node:path");
+var import_pgsql_parser = require("pgsql-parser");
 var PG_TO_PRISMA = {
   "TEXT": "String",
   "VARCHAR": "String",
@@ -2638,243 +2733,6 @@ function pgTypeToPrisma(pgType) {
   const upper = pgType.toUpperCase().trim();
   return PG_TO_PRISMA[upper] ?? upper;
 }
-var ID = `(?:"[\\w$]+"|[\\w$]+)`;
-var QID = `(?:${ID}\\.)?${ID}`;
-function bareName(captured) {
-  const parts = captured.split(".");
-  const last = parts[parts.length - 1];
-  return last.replace(/^"(.*)"$/, "$1").trim();
-}
-function parseCreateTable(sql, state) {
-  const re = new RegExp(
-    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s*\\(([\\s\\S]*?)\\);`,
-    "gi"
-  );
-  let m;
-  while ((m = re.exec(sql)) !== null) {
-    const tableName = bareName(m[1]);
-    const body = m[2];
-    const columns = /* @__PURE__ */ new Map();
-    let primaryCol = null;
-    const inlineFks = [];
-    const lines = splitTopLevelCommas(body);
-    for (const raw of lines) {
-      const trimmed = raw.trim().replace(/,\s*$/, "");
-      if (!trimmed || trimmed.startsWith("--")) continue;
-      const namedPk = trimmed.match(new RegExp(`^CONSTRAINT\\s+${ID}\\s+PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
-      if (namedPk) {
-        primaryCol = bareName(namedPk[1]);
-        continue;
-      }
-      const tablePk = trimmed.match(new RegExp(`^PRIMARY\\s+KEY\\s*\\(\\s*(${QID})`, "i"));
-      if (tablePk) {
-        primaryCol = bareName(tablePk[1]);
-        continue;
-      }
-      if (/^UNIQUE\s*\(/i.test(trimmed)) continue;
-      const namedFk = trimmed.match(new RegExp(
-        `^CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
-        "i"
-      ));
-      if (namedFk) {
-        inlineFks.push({
-          constraintName: bareName(namedFk[1]),
-          sourceTable: tableName,
-          sourceColumn: bareName(namedFk[2]),
-          targetTable: bareName(namedFk[3]),
-          targetColumn: bareName(namedFk[4]),
-          onDelete: namedFk[5] ?? null
-        });
-        continue;
-      }
-      const bareFk = trimmed.match(new RegExp(
-        `^FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
-        "i"
-      ));
-      if (bareFk) {
-        inlineFks.push({
-          constraintName: `${tableName}_${bareName(bareFk[1])}_fkey`,
-          sourceTable: tableName,
-          sourceColumn: bareName(bareFk[1]),
-          targetTable: bareName(bareFk[2]),
-          targetColumn: bareName(bareFk[3]),
-          onDelete: bareFk[4] ?? null
-        });
-        continue;
-      }
-      if (/^CONSTRAINT\s/i.test(trimmed)) continue;
-      const colMatch = trimmed.match(new RegExp(`^(${ID})\\s+(.+)`, "i"));
-      if (!colMatch) continue;
-      const colName = bareName(colMatch[1]);
-      let rest = colMatch[2];
-      const inlineRefMatch = rest.match(new RegExp(
-        `\\bREFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
-        "i"
-      ));
-      if (inlineRefMatch) {
-        inlineFks.push({
-          constraintName: `${tableName}_${colName}_fkey`,
-          sourceTable: tableName,
-          sourceColumn: colName,
-          targetTable: bareName(inlineRefMatch[1]),
-          targetColumn: bareName(inlineRefMatch[2]),
-          onDelete: inlineRefMatch[3] ?? null
-        });
-        rest = rest.replace(inlineRefMatch[0], "").trim();
-      }
-      const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
-      const isPrimaryKey = /\bPRIMARY\s+KEY\b/i.test(rest);
-      const isUnique = /\bUNIQUE\b/i.test(rest);
-      const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)(?:\s*,?\s*$)/i);
-      const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-      let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bPRIMARY\s+KEY\b/gi, "").replace(/\bUNIQUE\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim().replace(/,\s*$/, "").trim();
-      columns.set(colName, {
-        name: colName,
-        type: colType,
-        nullable: !isNotNull && !isPrimaryKey,
-        primary: isPrimaryKey,
-        unique: isUnique,
-        default: defaultVal
-      });
-      if (isPrimaryKey) primaryCol = colName;
-    }
-    if (primaryCol && columns.has(primaryCol)) {
-      columns.get(primaryCol).primary = true;
-    }
-    state.tables.set(tableName, { name: tableName, columns });
-    state.fks.push(...inlineFks);
-  }
-}
-function splitTopLevelCommas(body) {
-  const out = [];
-  let depth = 0;
-  let buf = "";
-  let inString = null;
-  for (const ch of body) {
-    if (inString) {
-      buf += ch;
-      if (ch === inString) inString = null;
-      continue;
-    }
-    if (ch === "'" || ch === '"') {
-      inString = ch;
-      buf += ch;
-      continue;
-    }
-    if (ch === "(") depth++;
-    else if (ch === ")") depth--;
-    if (ch === "," && depth === 0) {
-      out.push(buf);
-      buf = "";
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.trim()) out.push(buf);
-  return out;
-}
-function parseCreateEnum(sql, state) {
-  const re = new RegExp(
-    `CREATE\\s+TYPE\\s+(${QID})\\s+AS\\s+ENUM\\s*\\(([^)]+)\\)`,
-    "gi"
-  );
-  let m;
-  while ((m = re.exec(sql)) !== null) {
-    const enumName = bareName(m[1]);
-    const valuesStr = m[2];
-    const values = new Set(
-      valuesStr.split(",").map((v) => v.trim().replace(/^'(.*)'$/, "$1")).filter(Boolean)
-    );
-    state.enums.set(enumName, { name: enumName, values });
-  }
-}
-function parseAlterTable(sql, state) {
-  const addColRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+COLUMN\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QID})\\s+(.+?);`,
-    "gi"
-  );
-  let m;
-  while ((m = addColRe.exec(sql)) !== null) {
-    const tableName = bareName(m[1]);
-    const colName = bareName(m[2]);
-    let rest = m[3];
-    const table = state.tables.get(tableName);
-    if (!table) continue;
-    const isNotNull = /\bNOT\s+NULL\b/i.test(rest);
-    const defaultMatch = rest.match(/\bDEFAULT\s+(.+?)$/i);
-    const defaultVal = defaultMatch ? defaultMatch[1].trim() : null;
-    let colType = rest.replace(/\bNOT\s+NULL\b/gi, "").replace(/\bDEFAULT\s+.*/gi, "").trim();
-    table.columns.set(colName, {
-      name: colName,
-      type: colType,
-      nullable: !isNotNull,
-      primary: false,
-      unique: false,
-      default: defaultVal
-    });
-  }
-  const dropColRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(${QID})\\s+DROP\\s+COLUMN\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
-    "gi"
-  );
-  while ((m = dropColRe.exec(sql)) !== null) {
-    const table = state.tables.get(bareName(m[1]));
-    if (table) table.columns.delete(bareName(m[2]));
-  }
-  const fkRe = new RegExp(
-    `ALTER\\s+TABLE\\s+(${QID})\\s+ADD\\s+CONSTRAINT\\s+(${ID})\\s+FOREIGN\\s+KEY\\s*\\(\\s*(${QID})\\s*\\)\\s+REFERENCES\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?`,
-    "gi"
-  );
-  while ((m = fkRe.exec(sql)) !== null) {
-    state.fks.push({
-      constraintName: bareName(m[2]),
-      sourceTable: bareName(m[1]),
-      sourceColumn: bareName(m[3]),
-      targetTable: bareName(m[4]),
-      targetColumn: bareName(m[5]),
-      onDelete: m[6] ?? null
-    });
-  }
-}
-function parseAlterEnum(sql, state) {
-  const re = new RegExp(
-    `ALTER\\s+TYPE\\s+(${QID})\\s+ADD\\s+VALUE\\s+'([^']+)'`,
-    "gi"
-  );
-  let m;
-  while ((m = re.exec(sql)) !== null) {
-    const en = state.enums.get(bareName(m[1]));
-    if (en) en.values.add(m[2]);
-  }
-}
-function parseDropTable(sql, state) {
-  const re = new RegExp(
-    `DROP\\s+TABLE\\s+(?:IF\\s+EXISTS\\s+)?(${QID})`,
-    "gi"
-  );
-  let m;
-  while ((m = re.exec(sql)) !== null) {
-    const dropped = bareName(m[1]);
-    state.tables.delete(dropped);
-    state.fks = state.fks.filter((fk) => fk.sourceTable !== dropped && fk.targetTable !== dropped);
-  }
-}
-function parseUniqueIndex(sql, state) {
-  const re = new RegExp(
-    `CREATE\\s+UNIQUE\\s+INDEX\\s+(?:(?:IF\\s+NOT\\s+EXISTS\\s+)?(?:${ID}\\s+)?)?ON\\s+(${QID})\\s*\\(\\s*(${QID})\\s*\\)`,
-    "gi"
-  );
-  let m;
-  while ((m = re.exec(sql)) !== null) {
-    const tableName = bareName(m[1]);
-    const colName = bareName(m[2]);
-    const table = state.tables.get(tableName);
-    const col = table?.columns.get(colName);
-    if (col) col.unique = true;
-    if (!state.uniqueIndexes.has(tableName)) state.uniqueIndexes.set(tableName, /* @__PURE__ */ new Set());
-    state.uniqueIndexes.get(tableName).add(colName);
-  }
-}
 function discoverMigrationFiles(migrationsDir) {
   if (!(0, import_node_fs8.existsSync)(migrationsDir)) return [];
   const out = [];
@@ -2889,25 +2747,614 @@ function discoverMigrationFiles(migrationsDir) {
   }
   return out;
 }
-function parseMigrations(migrationsDir) {
+var postgresDialect = {
+  parse(sql) {
+    return (0, import_pgsql_parser.parseSync)(sql);
+  },
+  applyAll(ast, state, filepath) {
+    const stmts = ast.stmts ?? [];
+    extractTablesFromStmts(stmts, state);
+    extractEnumsFromStmts(stmts, state);
+    extractIndexesFromStmts(stmts, state, filepath);
+    extractPoliciesFromStmts(stmts, state, filepath);
+    extractExtensionsFromStmts(stmts, state, filepath);
+    extractTriggersFromStmts(stmts, state, filepath);
+    extractFunctionsFromStmts(stmts, state, filepath);
+    extractViewsFromStmts(stmts, state, filepath);
+    applyDropIndexes(stmts, state);
+    applyDropPolicies(stmts, state);
+    applyDropsForSchemaObjects(stmts, state);
+    applyAstAlterEnums(stmts, state);
+    applyAstAlterations(stmts, state);
+  },
+  extractMigrationInfo(ast, name, filepath) {
+    const stmts = ast.stmts ?? [];
+    return extractMigrationInfoFromStmts(stmts, name, filepath);
+  }
+};
+function parseMigrations(migrationsDir, dialect = postgresDialect) {
   const state = {
     tables: /* @__PURE__ */ new Map(),
     enums: /* @__PURE__ */ new Map(),
     fks: [],
-    uniqueIndexes: /* @__PURE__ */ new Map()
+    uniqueIndexes: /* @__PURE__ */ new Map(),
+    indexes: [],
+    policies: [],
+    extensions: [],
+    triggers: [],
+    functions: [],
+    views: []
   };
   if (!migrationsDir) return state;
   for (const sqlPath of discoverMigrationFiles(migrationsDir)) {
     const sql = (0, import_node_fs8.readFileSync)(sqlPath, "utf-8");
-    parseCreateEnum(sql, state);
-    parseCreateTable(sql, state);
-    parseAlterTable(sql, state);
-    parseAlterEnum(sql, state);
-    parseDropTable(sql, state);
-    parseUniqueIndex(sql, state);
+    let ast;
+    try {
+      ast = dialect.parse(sql);
+    } catch {
+      continue;
+    }
+    dialect.applyAll(ast, state, sqlPath);
   }
   return state;
 }
+function extractIndexesFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const stmt = wrap.stmt ?? {};
+    const ix = stmt.IndexStmt;
+    if (!ix) continue;
+    const name = ix.idxname ?? "";
+    if (!name) continue;
+    const table = ix.relation?.relname ?? "";
+    const unique = !!ix.unique;
+    const method = String(ix.accessMethod ?? "btree").toLowerCase();
+    const params = ix.indexParams ?? [];
+    const columns = [];
+    let hasExpressions = false;
+    for (const p of params) {
+      const elem = p.IndexElem;
+      if (!elem) continue;
+      if (elem.name) columns.push(elem.name);
+      else if (elem.expr) hasExpressions = true;
+    }
+    const hasPredicate = !!ix.whereClause;
+    const existing = state.indexes.findIndex((i) => i.name === name);
+    const next = { name, table, unique, method, columns, hasExpressions, hasPredicate, filepath };
+    if (existing >= 0) state.indexes[existing] = next;
+    else state.indexes.push(next);
+    if (unique && columns.length === 1 && !hasPredicate && !hasExpressions) {
+      const t = state.tables.get(table);
+      const col = t?.columns.get(columns[0]);
+      if (col) col.unique = true;
+      if (!state.uniqueIndexes.has(table)) state.uniqueIndexes.set(table, /* @__PURE__ */ new Set());
+      state.uniqueIndexes.get(table).add(columns[0]);
+    }
+  }
+}
+function applyDropIndexes(stmts, state) {
+  for (const wrap of stmts) {
+    const drop = wrap.stmt?.DropStmt;
+    if (!drop || drop.removeType !== "OBJECT_INDEX") continue;
+    const objects = drop.objects ?? [];
+    const droppedNames = /* @__PURE__ */ new Set();
+    for (const obj of objects) {
+      const items = obj.List?.items ?? [];
+      const last = items[items.length - 1]?.String?.sval;
+      if (last) droppedNames.add(last);
+    }
+    if (droppedNames.size > 0) {
+      state.indexes = state.indexes.filter((i) => !droppedNames.has(i.name));
+    }
+  }
+}
+function formatPgTypeName(typeName) {
+  const names = (typeName?.names ?? []).map((n) => n.String?.sval ?? "").filter(Boolean);
+  const base = (names[names.length - 1] ?? "").toLowerCase();
+  const PG_INTERNAL_MAP = {
+    int4: "INTEGER",
+    int8: "BIGINT",
+    int2: "SMALLINT",
+    float8: "DOUBLE PRECISION",
+    float4: "REAL",
+    bool: "BOOLEAN",
+    bpchar: "CHAR",
+    timestamptz: "TIMESTAMPTZ",
+    timestamp: "TIMESTAMP",
+    numeric: "NUMERIC",
+    text: "TEXT",
+    varchar: "VARCHAR",
+    jsonb: "JSONB",
+    json: "JSON",
+    uuid: "UUID",
+    date: "DATE",
+    bytea: "BYTEA"
+  };
+  return PG_INTERNAL_MAP[base] ?? base.toUpperCase();
+}
+function applyAstAlterations(stmts, state) {
+  for (const wrap of stmts) {
+    const stmt = wrap.stmt ?? {};
+    const kind = Object.keys(stmt)[0];
+    if (!kind) continue;
+    if (kind === "AlterTableStmt") {
+      const body = stmt.AlterTableStmt;
+      const tableName = body.relation?.relname ?? "";
+      const table = state.tables.get(tableName);
+      if (!table) continue;
+      const cmds = body.cmds ?? [];
+      for (const c of cmds) {
+        const cmd = c.AlterTableCmd;
+        if (!cmd) continue;
+        const subtype = cmd.subtype ?? "";
+        const colName = cmd.name ?? "";
+        const col = colName ? table.columns.get(colName) : void 0;
+        switch (subtype) {
+          case "AT_AlterColumnType": {
+            if (!col) break;
+            const typeName = cmd.def?.ColumnDef?.typeName ?? cmd.def?.typeName;
+            if (typeName) col.type = formatPgTypeNameWithMods(typeName);
+            break;
+          }
+          case "AT_SetNotNull":
+            if (col) col.nullable = false;
+            break;
+          case "AT_DropNotNull":
+            if (col) col.nullable = true;
+            break;
+          case "AT_AddColumn": {
+            const cd = cmd.def?.ColumnDef;
+            if (!cd) break;
+            const newColName = cd.colname ?? "";
+            if (!newColName) break;
+            if (table.columns.has(newColName)) break;
+            let nullable = true;
+            let primary = false;
+            let unique = false;
+            let defaultVal = null;
+            for (const c2 of cd.constraints ?? []) {
+              const ct = c2.Constraint;
+              if (!ct) continue;
+              if (ct.contype === "CONSTR_NOTNULL") nullable = false;
+              else if (ct.contype === "CONSTR_PRIMARY") {
+                primary = true;
+                nullable = false;
+              } else if (ct.contype === "CONSTR_UNIQUE") unique = true;
+              else if (ct.contype === "CONSTR_DEFAULT") defaultVal = "<expr>";
+            }
+            table.columns.set(newColName, {
+              name: newColName,
+              type: formatPgTypeNameWithMods(cd.typeName),
+              nullable,
+              primary,
+              unique,
+              default: defaultVal
+            });
+            break;
+          }
+          case "AT_DropColumn":
+            if (colName) table.columns.delete(colName);
+            break;
+          case "AT_AddConstraint": {
+            const ct = cmd.def?.Constraint;
+            if (!ct) break;
+            if (ct.contype !== "CONSTR_FOREIGN") break;
+            const fkCols = (ct.fk_attrs ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+            const pkCols = (ct.pk_attrs ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+            const pkTable = ct.pktable?.relname ?? "";
+            if (fkCols.length && pkCols.length && pkTable) {
+              state.fks.push({
+                constraintName: ct.conname || `${tableName}_${fkCols[0]}_fkey`,
+                sourceTable: tableName,
+                sourceColumn: fkCols[0],
+                targetTable: pkTable,
+                targetColumn: pkCols[0],
+                onDelete: mapFkAction(ct.fk_del_action)
+              });
+            }
+            break;
+          }
+        }
+      }
+    } else if (kind === "RenameStmt") {
+      const body = stmt.RenameStmt;
+      const renameType = body.renameType ?? "";
+      const newName = body.newname ?? "";
+      if (renameType === "OBJECT_COLUMN") {
+        const tableName = body.relation?.relname ?? "";
+        const oldName = body.subname ?? "";
+        const table = state.tables.get(tableName);
+        if (!table || !oldName || !newName) continue;
+        const col = table.columns.get(oldName);
+        if (col) {
+          col.name = newName;
+          table.columns.delete(oldName);
+          table.columns.set(newName, col);
+        }
+      } else if (renameType === "OBJECT_TABLE") {
+        const oldName = body.relation?.relname ?? "";
+        if (!oldName || !newName) continue;
+        const t = state.tables.get(oldName);
+        if (!t) continue;
+        state.tables.delete(oldName);
+        t.name = newName;
+        state.tables.set(newName, t);
+        for (const fk of state.fks) {
+          if (fk.sourceTable === oldName) fk.sourceTable = newName;
+          if (fk.targetTable === oldName) fk.targetTable = newName;
+        }
+      }
+    }
+  }
+}
+function extractPoliciesFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreatePolicyStmt;
+    if (!body) continue;
+    const name = body.policy_name ?? "";
+    if (!name) continue;
+    const table = body.table?.relname ?? "";
+    const cmdRaw = String(body.cmd_name ?? "all").toUpperCase();
+    const command = ["SELECT", "INSERT", "UPDATE", "DELETE", "ALL"].includes(cmdRaw) ? cmdRaw : "ALL";
+    const permissive = body.permissive === true;
+    const roles = (body.roles ?? []).map((r) => {
+      const rs = r.RoleSpec;
+      if (!rs) return "";
+      if (rs.roletype === "ROLESPEC_PUBLIC") return "public";
+      if (rs.roletype === "ROLESPEC_CURRENT_USER") return "current_user";
+      if (rs.roletype === "ROLESPEC_CSTRING" && rs.rolename) return rs.rolename;
+      return "";
+    }).filter(Boolean);
+    const hasUsing = !!body.qual;
+    const hasWithCheck = !!body.with_check;
+    const existing = state.policies.findIndex((p) => p.table === table && p.name === name);
+    const next = { name, table, command, permissive, roles, hasUsing, hasWithCheck, filepath };
+    if (existing >= 0) state.policies[existing] = next;
+    else state.policies.push(next);
+  }
+}
+function applyDropPolicies(stmts, state) {
+  for (const wrap of stmts) {
+    const drop = wrap.stmt?.DropStmt;
+    if (!drop || drop.removeType !== "OBJECT_POLICY") continue;
+    const objects = drop.objects ?? [];
+    for (const obj of objects) {
+      const items = obj.List?.items ?? [];
+      if (items.length < 2) continue;
+      const table = items[0]?.String?.sval ?? "";
+      const policyName = items[items.length - 1]?.String?.sval ?? "";
+      if (!table || !policyName) continue;
+      state.policies = state.policies.filter((p) => !(p.table === table && p.name === policyName));
+    }
+  }
+}
+function mapFkAction(action) {
+  if (!action) return null;
+  const m = {
+    r: "RESTRICT",
+    c: "CASCADE",
+    s: "SET NULL",
+    d: "SET DEFAULT",
+    a: "NO ACTION",
+    // pgsql-parser may also emit FKCONSTR_ACTION_* enum strings:
+    FKCONSTR_ACTION_RESTRICT: "RESTRICT",
+    FKCONSTR_ACTION_CASCADE: "CASCADE",
+    FKCONSTR_ACTION_SETNULL: "SET NULL",
+    FKCONSTR_ACTION_SETDEFAULT: "SET DEFAULT",
+    FKCONSTR_ACTION_NOACTION: "NO ACTION"
+  };
+  return m[action] ?? null;
+}
+function formatPgTypeNameWithMods(typeName) {
+  const base = formatPgTypeName(typeName);
+  if (base === "String" || base === "unknown") return base;
+  const typmods = [];
+  for (const m of typeName?.typmods ?? []) {
+    const v = m.A_Const?.ival?.ival;
+    if (typeof v === "number") typmods.push(v);
+  }
+  return typmods.length ? `${base}(${typmods.join(",")})` : base;
+}
+function extractTablesFromStmts(stmts, state) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreateStmt;
+    if (!body) continue;
+    const tableName = body.relation?.relname ?? "";
+    if (!tableName) continue;
+    const columns = /* @__PURE__ */ new Map();
+    const fks = [];
+    let primaryCol = null;
+    for (const elt of body.tableElts ?? []) {
+      if (elt.ColumnDef) {
+        const cd = elt.ColumnDef;
+        const colName = cd.colname ?? "";
+        if (!colName) continue;
+        const colType = formatPgTypeNameWithMods(cd.typeName);
+        let nullable = true;
+        let primary = false;
+        let unique = false;
+        let defaultVal = null;
+        for (const c of cd.constraints ?? []) {
+          const ct = c.Constraint;
+          if (!ct) continue;
+          switch (ct.contype) {
+            case "CONSTR_NOTNULL":
+              nullable = false;
+              break;
+            case "CONSTR_PRIMARY":
+              primary = true;
+              nullable = false;
+              primaryCol = colName;
+              break;
+            case "CONSTR_UNIQUE":
+              unique = true;
+              break;
+            case "CONSTR_DEFAULT":
+              defaultVal = "<expr>";
+              break;
+            case "CONSTR_FOREIGN": {
+              const pkTable = ct.pktable?.relname ?? "";
+              const pkCols = (ct.pk_attrs ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+              if (pkTable && pkCols.length) {
+                fks.push({
+                  constraintName: ct.conname || `${tableName}_${colName}_fkey`,
+                  sourceTable: tableName,
+                  sourceColumn: colName,
+                  targetTable: pkTable,
+                  targetColumn: pkCols[0],
+                  onDelete: mapFkAction(ct.fk_del_action)
+                });
+              }
+              break;
+            }
+          }
+        }
+        columns.set(colName, {
+          name: colName,
+          type: colType,
+          nullable,
+          primary,
+          unique,
+          default: defaultVal
+        });
+      } else if (elt.Constraint) {
+        const ct = elt.Constraint;
+        switch (ct.contype) {
+          case "CONSTR_PRIMARY": {
+            const keys = (ct.keys ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+            if (keys.length) primaryCol = keys[0];
+            break;
+          }
+          case "CONSTR_FOREIGN": {
+            const fkCols = (ct.fk_attrs ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+            const pkCols = (ct.pk_attrs ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+            const pkTable = ct.pktable?.relname ?? "";
+            if (fkCols.length && pkCols.length && pkTable) {
+              fks.push({
+                constraintName: ct.conname || `${tableName}_${fkCols[0]}_fkey`,
+                sourceTable: tableName,
+                sourceColumn: fkCols[0],
+                targetTable: pkTable,
+                targetColumn: pkCols[0],
+                onDelete: mapFkAction(ct.fk_del_action)
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (primaryCol && columns.has(primaryCol)) {
+      columns.get(primaryCol).primary = true;
+      columns.get(primaryCol).nullable = false;
+    }
+    state.tables.set(tableName, { name: tableName, columns });
+    state.fks.push(...fks);
+  }
+}
+function extractEnumsFromStmts(stmts, state) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreateEnumStmt;
+    if (!body) continue;
+    const names = (body.typeName ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+    const enumName = names[names.length - 1] ?? "";
+    if (!enumName) continue;
+    const vals = new Set(
+      (body.vals ?? []).map((s) => s.String?.sval ?? "").filter(Boolean)
+    );
+    state.enums.set(enumName, { name: enumName, values: vals });
+  }
+}
+function applyAstAlterEnums(stmts, state) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.AlterEnumStmt;
+    if (!body) continue;
+    const names = (body.typeName ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+    const enumName = names[names.length - 1] ?? "";
+    const en = state.enums.get(enumName);
+    if (!en) continue;
+    if (body.newVal) en.values.add(String(body.newVal));
+  }
+}
+function extractExtensionsFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreateExtensionStmt;
+    if (!body) continue;
+    const name = body.extname ?? "";
+    if (!name) continue;
+    let schema = null;
+    let version = null;
+    for (const opt of body.options ?? []) {
+      const de = opt.DefElem;
+      if (!de) continue;
+      if (de.defname === "schema" && de.arg?.String?.sval) schema = de.arg.String.sval;
+      else if (de.defname === "new_version" && de.arg?.String?.sval) version = de.arg.String.sval;
+    }
+    const next = { name, schema, version, filepath };
+    const existing = state.extensions.findIndex((e) => e.name === name);
+    if (existing >= 0) state.extensions[existing] = next;
+    else state.extensions.push(next);
+  }
+}
+function extractTriggersFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreateTrigStmt;
+    if (!body) continue;
+    const name = body.trigname ?? "";
+    if (!name) continue;
+    const table = body.relation?.relname ?? "";
+    const timingVal = body.timing ?? 0;
+    const eventsVal = body.events ?? 0;
+    const timing = timingVal & 2 ? "BEFORE" : timingVal & 64 ? "INSTEAD OF" : "AFTER";
+    const events = [];
+    if (eventsVal & 4) events.push("INSERT");
+    if (eventsVal & 8) events.push("DELETE");
+    if (eventsVal & 16) events.push("UPDATE");
+    if (eventsVal & 32) events.push("TRUNCATE");
+    const funcname = body.funcname ?? [];
+    const funcCall = funcname[funcname.length - 1]?.String?.sval ?? "";
+    const forEach = body.row ? "ROW" : "STATEMENT";
+    const hasWhen = !!body.whenClause;
+    const next = { name, table, timing, events, function: funcCall, hasWhen, forEach, filepath };
+    const existing = state.triggers.findIndex((t) => t.table === table && t.name === name);
+    if (existing >= 0) state.triggers[existing] = next;
+    else state.triggers.push(next);
+  }
+}
+function functionIdFor(name, schema) {
+  return schema ? `${schema}.${name}` : name;
+}
+function extractFunctionsFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const body = wrap.stmt?.CreateFunctionStmt;
+    if (!body) continue;
+    const fn = body.funcname ?? [];
+    if (fn.length === 0) continue;
+    const name = fn[fn.length - 1]?.String?.sval ?? "";
+    if (!name) continue;
+    const schema = fn.length > 1 ? fn[fn.length - 2]?.String?.sval ?? null : null;
+    let language = "sql";
+    for (const opt of body.options ?? []) {
+      const de = opt.DefElem;
+      if (de?.defname === "language" && de.arg?.String?.sval) language = de.arg.String.sval;
+    }
+    const returnType = body.returnType ? formatPgTypeName(body.returnType) : "";
+    const isProcedure = !!body.is_procedure;
+    const next = { name, schema, language, returnType, isProcedure, filepath };
+    const id = functionIdFor(name, schema);
+    const existing = state.functions.findIndex((f) => functionIdFor(f.name, f.schema) === id);
+    if (existing >= 0) state.functions[existing] = next;
+    else state.functions.push(next);
+  }
+}
+function extractViewsFromStmts(stmts, state, filepath) {
+  for (const wrap of stmts) {
+    const stmt = wrap.stmt ?? {};
+    const view = stmt.ViewStmt;
+    if (view) {
+      const name = view.view?.relname ?? "";
+      if (!name) continue;
+      const schema = view.view?.schemaname ?? null;
+      const next = {
+        name,
+        schema,
+        isMaterialized: false,
+        withCheckOption: String(view.withCheckOption ?? "NO_CHECK_OPTION"),
+        filepath
+      };
+      const id = functionIdFor(name, schema);
+      const existing = state.views.findIndex((v) => functionIdFor(v.name, v.schema) === id);
+      if (existing >= 0) state.views[existing] = next;
+      else state.views.push(next);
+    }
+    const ctas = stmt.CreateTableAsStmt;
+    if (ctas && ctas.objtype === "OBJECT_MATVIEW") {
+      const name = ctas.into?.rel?.relname ?? "";
+      if (!name) continue;
+      const schema = ctas.into?.rel?.schemaname ?? null;
+      const next = {
+        name,
+        schema,
+        isMaterialized: true,
+        withCheckOption: "N/A",
+        filepath
+      };
+      const id = functionIdFor(name, schema);
+      const existing = state.views.findIndex((v) => functionIdFor(v.name, v.schema) === id);
+      if (existing >= 0) state.views[existing] = next;
+      else state.views.push(next);
+    }
+  }
+}
+function applyDropsForSchemaObjects(stmts, state) {
+  for (const wrap of stmts) {
+    const drop = wrap.stmt?.DropStmt;
+    if (!drop) continue;
+    const removeType = drop.removeType ?? "";
+    const objects = drop.objects ?? [];
+    if (removeType === "OBJECT_TABLE") {
+      const droppedTables = /* @__PURE__ */ new Set();
+      for (const obj of objects) {
+        const items = obj.List?.items ?? [];
+        const last = items[items.length - 1]?.String?.sval;
+        if (last) droppedTables.add(last);
+      }
+      if (droppedTables.size > 0) {
+        for (const t of droppedTables) state.tables.delete(t);
+        state.fks = state.fks.filter((fk) => !droppedTables.has(fk.sourceTable) && !droppedTables.has(fk.targetTable));
+      }
+    } else if (removeType === "OBJECT_TYPE") {
+      const droppedEnums = /* @__PURE__ */ new Set();
+      for (const obj of objects) {
+        const tn = obj.TypeName;
+        if (!tn) continue;
+        const names = (tn.names ?? []).map((s) => s.String?.sval ?? "").filter(Boolean);
+        const last = names[names.length - 1];
+        if (last) droppedEnums.add(last);
+      }
+      for (const e of droppedEnums) state.enums.delete(e);
+    } else if (removeType === "OBJECT_EXTENSION") {
+      const names = /* @__PURE__ */ new Set();
+      for (const obj of objects) {
+        const sval = obj.String?.sval;
+        if (sval) names.add(sval);
+      }
+      if (names.size > 0) state.extensions = state.extensions.filter((e) => !names.has(e.name));
+    } else if (removeType === "OBJECT_TRIGGER") {
+      for (const obj of objects) {
+        const items = obj.List?.items ?? [];
+        if (items.length < 2) continue;
+        const table = items[0]?.String?.sval ?? "";
+        const trigName = items[items.length - 1]?.String?.sval ?? "";
+        if (!table || !trigName) continue;
+        state.triggers = state.triggers.filter((t) => !(t.table === table && t.name === trigName));
+      }
+    } else if (removeType === "OBJECT_FUNCTION" || removeType === "OBJECT_PROCEDURE") {
+      for (const obj of objects) {
+        const items = obj.ObjectWithArgs?.objname?.items ?? obj.ObjectWithArgs?.objname ?? obj.List?.items ?? [];
+        if (!items.length) continue;
+        const segs = items.map((s) => s.String?.sval ?? "").filter(Boolean);
+        if (!segs.length) continue;
+        const name = segs[segs.length - 1];
+        const schema = segs.length > 1 ? segs[segs.length - 2] : null;
+        const id = functionIdFor(name, schema);
+        state.functions = state.functions.filter((f) => functionIdFor(f.name, f.schema) !== id);
+      }
+    } else if (removeType === "OBJECT_VIEW" || removeType === "OBJECT_MATVIEW") {
+      for (const obj of objects) {
+        const items = obj.List?.items ?? [];
+        if (!items.length) continue;
+        const name = items[items.length - 1]?.String?.sval ?? "";
+        const schema = items.length > 1 ? items[items.length - 2]?.String?.sval ?? null : null;
+        if (!name) continue;
+        const id = functionIdFor(name, schema);
+        state.views = state.views.filter((v) => functionIdFor(v.name, v.schema) !== id);
+      }
+    }
+  }
+}
+function indexIsPrismaUncoverable(idx) {
+  return idx.hasPredicate || idx.hasExpressions || idx.method !== "btree";
+}
 function loadPrismaState(schemaPath) {
   if (!schemaPath || !(0, import_node_fs8.existsSync)(schemaPath)) return null;
   const content = (0, import_node_fs8.readFileSync)(schemaPath, "utf-8");
@@ -3074,6 +3521,96 @@ function verify(sqlState, prisma) {
   }
   return { contradictions, flaggedEdges };
 }
+function deriveMigrationName(sqlPath) {
+  const segments = sqlPath.split(/[\\/]/);
+  const last = segments[segments.length - 1];
+  if (last === "migration.sql" && segments.length >= 2) {
+    return segments[segments.length - 2];
+  }
+  return last.replace(/\.sql$/, "");
+}
+function extractMigrationInfoFromStmts(stmts, name, filepath) {
+  let isDestructive = false;
+  let hasOrphanCheck = false;
+  let hasSidecarBackup = false;
+  let hasPreFlightNotice = false;
+  let containsBackfill = false;
+  let containsDropColumn = false;
+  let containsDropTable = false;
+  for (const wrap of stmts) {
+    const stmt = wrap.stmt ?? {};
+    const kind = Object.keys(stmt)[0];
+    if (!kind) continue;
+    const body = stmt[kind] ?? {};
+    switch (kind) {
+      case "AlterTableStmt": {
+        const cmds = body.cmds ?? [];
+        for (const c of cmds) {
+          const subtype = c.AlterTableCmd?.subtype;
+          if (subtype === "AT_DropColumn") {
+            containsDropColumn = true;
+            isDestructive = true;
+          } else if (subtype === "AT_AlterColumnType" || subtype === "AT_DropNotNull" || subtype === "AT_DropConstraint") {
+            isDestructive = true;
+          }
+        }
+        break;
+      }
+      case "DropStmt": {
+        const removeType = body.removeType ?? "";
+        if (removeType === "OBJECT_TABLE") {
+          containsDropTable = true;
+          isDestructive = true;
+        } else if (removeType === "OBJECT_TYPE" || removeType === "OBJECT_COLUMN" || removeType === "OBJECT_INDEX" || removeType === "OBJECT_POLICY") {
+          isDestructive = true;
+        }
+        break;
+      }
+      case "CreateStmt": {
+        const relname = body.relation?.relname ?? "";
+        if (relname.startsWith("_backup_")) hasSidecarBackup = true;
+        break;
+      }
+      case "CreateTableAsStmt": {
+        const relname = body.into?.rel?.relname ?? "";
+        if (relname.startsWith("_backup_")) hasSidecarBackup = true;
+        break;
+      }
+      case "UpdateStmt":
+      case "InsertStmt":
+      case "DeleteStmt": {
+        containsBackfill = true;
+        break;
+      }
+      case "DoStmt": {
+        const args = body.args ?? [];
+        for (const arg of args) {
+          const def = arg.DefElem;
+          if (!def || def.defname !== "as") continue;
+          const code = def.arg?.String?.sval ?? "";
+          if (/\bRAISE\s+EXCEPTION\b/i.test(code)) hasOrphanCheck = true;
+          if (/\bRAISE\s+NOTICE\b/i.test(code)) hasPreFlightNotice = true;
+        }
+        break;
+      }
+    }
+  }
+  const tsMatch = name.match(/^(\d{8,14})/);
+  const timestamp = tsMatch ? tsMatch[1] : null;
+  return {
+    name,
+    filepath,
+    timestamp,
+    isDestructive,
+    hasOrphanCheck,
+    hasSidecarBackup,
+    hasPreFlightNotice,
+    containsBackfill,
+    containsDropColumn,
+    containsDropTable,
+    statementCount: stmts.length
+  };
+}
 function migrationsDirFor(rootDir) {
   const paths = resolveProjectPaths(rootDir, loadConfig(rootDir));
   if (!paths) return null;
@@ -3128,6 +3665,132 @@ function generate3(rootDir) {
       values: [...sqlEnum.values]
     });
   }
+  let indexNodeCount = 0;
+  for (const idx of sqlState.indexes) {
+    if (!indexIsPrismaUncoverable(idx)) continue;
+    nodes.push({
+      id: `index:${idx.name}`,
+      type: "index",
+      name: idx.name,
+      source: "sql",
+      table: idx.table,
+      unique: idx.unique,
+      method: idx.method,
+      columns: idx.columns,
+      has_expressions: idx.hasExpressions,
+      has_predicate: idx.hasPredicate,
+      filepath: idx.filepath
+    });
+    indexNodeCount++;
+  }
+  let extensionNodeCount = 0;
+  for (const ext of sqlState.extensions) {
+    nodes.push({
+      id: `extension:${ext.name}`,
+      type: "extension",
+      name: ext.name,
+      source: "sql",
+      schema: ext.schema,
+      version: ext.version,
+      filepath: ext.filepath
+    });
+    extensionNodeCount++;
+  }
+  let triggerNodeCount = 0;
+  for (const trg of sqlState.triggers) {
+    nodes.push({
+      id: `trigger:${trg.table}:${trg.name}`,
+      type: "trigger",
+      name: trg.name,
+      source: "sql",
+      table: trg.table,
+      timing: trg.timing,
+      events: trg.events,
+      function: trg.function,
+      has_when: trg.hasWhen,
+      for_each: trg.forEach,
+      filepath: trg.filepath
+    });
+    triggerNodeCount++;
+  }
+  let functionNodeCount = 0;
+  for (const fn of sqlState.functions) {
+    const qualified = fn.schema ? `${fn.schema}.${fn.name}` : fn.name;
+    nodes.push({
+      id: `function:${qualified}`,
+      type: "function",
+      name: fn.name,
+      source: "sql",
+      schema: fn.schema,
+      language: fn.language,
+      return_type: fn.returnType,
+      is_procedure: fn.isProcedure,
+      filepath: fn.filepath
+    });
+    functionNodeCount++;
+  }
+  let viewNodeCount = 0;
+  for (const vw of sqlState.views) {
+    const qualified = vw.schema ? `${vw.schema}.${vw.name}` : vw.name;
+    nodes.push({
+      id: `${vw.isMaterialized ? "matview" : "view"}:${qualified}`,
+      type: vw.isMaterialized ? "materialized_view" : "view",
+      name: vw.name,
+      source: "sql",
+      schema: vw.schema,
+      is_materialized: vw.isMaterialized,
+      with_check_option: vw.withCheckOption,
+      filepath: vw.filepath
+    });
+    viewNodeCount++;
+  }
+  let policyNodeCount = 0;
+  for (const pol of sqlState.policies) {
+    nodes.push({
+      id: `policy:${pol.table}:${pol.name}`,
+      type: "policy",
+      name: pol.name,
+      source: "sql",
+      table: pol.table,
+      command: pol.command,
+      permissive: pol.permissive,
+      roles: pol.roles,
+      has_using: pol.hasUsing,
+      has_with_check: pol.hasWithCheck,
+      filepath: pol.filepath
+    });
+    policyNodeCount++;
+  }
+  const migrationFiles = migrationsDir ? discoverMigrationFiles(migrationsDir) : [];
+  let migrationNodeCount = 0;
+  for (const sqlPath of migrationFiles) {
+    const sql = (0, import_node_fs8.readFileSync)(sqlPath, "utf-8");
+    const name = deriveMigrationName(sqlPath);
+    let ast;
+    try {
+      ast = postgresDialect.parse(sql);
+    } catch {
+      ast = { stmts: [] };
+    }
+    const info = postgresDialect.extractMigrationInfo(ast, name, sqlPath);
+    nodes.push({
+      id: `migration:${name}`,
+      type: "migration",
+      name,
+      source: "sql",
+      filepath: info.filepath,
+      timestamp: info.timestamp,
+      is_destructive: info.isDestructive,
+      has_orphan_check: info.hasOrphanCheck,
+      has_sidecar_backup: info.hasSidecarBackup,
+      has_pre_flight_notice: info.hasPreFlightNotice,
+      contains_backfill: info.containsBackfill,
+      contains_drop_column: info.containsDropColumn,
+      contains_drop_table: info.containsDropTable,
+      statement_count: info.statementCount
+    });
+    migrationNodeCount++;
+  }
   const sqlOnlyTables = new Set(nodes.filter((n) => n.type === "table").map((n) => n.id));
   const edges = sqlState.fks.filter((fk) => sqlOnlyTables.has(fk.sourceTable)).map((fk) => ({
     source: fk.sourceTable,
@@ -3146,6 +3809,13 @@ function generate3(rootDir) {
       sql_tables: sqlState.tables.size,
       sql_enums: sqlState.enums.size,
       sql_fks: sqlState.fks.length,
+      sql_index_nodes: indexNodeCount,
+      sql_policy_nodes: policyNodeCount,
+      sql_extension_nodes: extensionNodeCount,
+      sql_trigger_nodes: triggerNodeCount,
+      sql_function_nodes: functionNodeCount,
+      sql_view_nodes: viewNodeCount,
+      sql_migration_nodes: migrationNodeCount,
       additive_nodes: nodes.length,
       contradictions_found: contradictions.length,
       flagged_edges_found: flaggedEdges.length
@@ -4693,6 +5363,7 @@ if (!import_node_worker_threads.parentPort) {
 async function run(req) {
   try {
     await initTreeSitter();
+    await (0, import_pgsql_parser2.loadModule)();
     const config = loadConfig(req.rootDir);
     setExtractorConfig({
       dbIdentifiers: config.parsers?.patterns?.dbIdentifiers,