@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-FHG3ILE4.js

@@ -0,0 +1,2011 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { psqlQuery, stripSqlComments } from './chunk-7B5C6U2K.js';
+import { loadRunaConfig } from './chunk-5NKWR4FF.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, writeFileSync, unlinkSync, readdirSync, readFileSync, mkdirSync, realpathSync } from 'fs';
+import path2, { join, isAbsolute, relative } from 'path';
+import { SUPABASE_SYSTEM_SCHEMAS, detectSchemaNames } from '@runa-ai/runa';
+import { isTable, getTableUniqueName, getTableName } from 'drizzle-orm';
+import { isPgEnum } from 'drizzle-orm/pg-core';
+import { createJiti } from 'jiti';
+import postgres2 from 'postgres';
+import { introspectDatabase } from '@runa-ai/runa/test-generators';
+
+createRequire(import.meta.url);
+
+// src/utils/env-local-bridge.ts
+init_esm_shims();
+var DEFAULT_API_PORT = 54321;
+var DEFAULT_DB_PORT = 54322;
+var RUNA_ENV_LOCAL_MARKER = "# RUNA_AUTO_GENERATED \u2014 do not edit (created by `runa db start`)";
+function envLocalPath(projectRoot) {
+  return path2.join(projectRoot, ".env.local");
+}
+function isNonDefaultPorts(config) {
+  return config.api !== DEFAULT_API_PORT || config.db !== DEFAULT_DB_PORT;
+}
+function buildEnvLocalContent(config) {
+  const dbUrl = `postgresql://postgres:postgres@${config.host}:${config.db}/postgres`;
+  return [
+    RUNA_ENV_LOCAL_MARKER,
+    `# Supabase is running on non-default ports (default: api=${DEFAULT_API_PORT}, db=${DEFAULT_DB_PORT}).`,
+    "# This file overrides .env.development so that `pnpm dev` uses correct ports.",
+    "# Removed automatically by `runa db stop`. Safe to delete manually.",
+    `DATABASE_URL=${dbUrl}`,
+    `DATABASE_URL_ADMIN=${dbUrl}`,
+    `DATABASE_URL_SERVICE=${dbUrl}`,
+    `NEXT_PUBLIC_SUPABASE_URL=http://${config.host}:${config.api}`,
+    ""
+  ].join("\n");
+}
+function isRunaManagedEnvLocal(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content.startsWith(RUNA_ENV_LOCAL_MARKER);
+  } catch {
+    return false;
+  }
+}
+function writeEnvLocalBridge(projectRoot, config) {
+  const filePath = envLocalPath(projectRoot);
+  const fileExists = existsSync(filePath);
+  if (isNonDefaultPorts(config)) {
+    if (fileExists && !isRunaManagedEnvLocal(projectRoot)) {
+      return { written: false, reason: "user-managed" };
+    }
+    writeFileSync(filePath, buildEnvLocalContent(config), "utf-8");
+    return { written: true, ports: { api: config.api, db: config.db } };
+  }
+  if (fileExists && isRunaManagedEnvLocal(projectRoot)) {
+    unlinkSync(filePath);
+    return { written: false, reason: "stale-removed" };
+  }
+  return { written: false, reason: "default-ports" };
+}
+function removeEnvLocalBridge(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  if (!existsSync(filePath)) {
+    return { removed: false, reason: "not-found" };
+  }
+  if (!isRunaManagedEnvLocal(projectRoot)) {
+    return { removed: false, reason: "user-managed" };
+  }
+  unlinkSync(filePath);
+  return { removed: true };
+}
+
+// src/commands/db/utils/schema-sync.ts
+init_esm_shims();
+var VALID_PG_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/;
+function validatePgIdentifier(name, context) {
+  if (!name || typeof name !== "string") {
+    throw new Error(`Invalid ${context}: empty or not a string`);
+  }
+  if (!VALID_PG_IDENTIFIER_PATTERN.test(name)) {
+    throw new Error(
+      `Invalid ${context} "${name}": must start with letter/underscore and contain only alphanumeric/underscore characters`
+    );
+  }
+}
+function escapePgStringLiteral(value) {
+  if (typeof value !== "string") {
+    throw new Error("Value must be a string");
+  }
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "''");
+}
+function buildSafeSchemaInClause(schemas) {
+  if (schemas.length === 0) {
+    throw new Error("No schemas provided for IN clause");
+  }
+  const safeSchemas = [];
+  for (const schema of schemas) {
+    validatePgIdentifier(schema, "schema name");
+    safeSchemas.push(`'${escapePgStringLiteral(schema)}'`);
+  }
+  return safeSchemas.join(",");
+}
+var ERROR_MESSAGES = {
+  PATH_TRAVERSAL: "Schema path validation failed",
+  SCHEMA_NOT_FOUND: "Schema file not found"
+};
+function containsPathTraversal(inputPath) {
+  const normalized = path2.normalize(inputPath);
+  return normalized.includes("..") || inputPath.includes("\0");
+}
+function isPathWithinBase(filePath, baseDir) {
+  try {
+    const resolvedFile = path2.resolve(filePath);
+    const resolvedBase = path2.resolve(baseDir);
+    const normalizedFile = path2.normalize(resolvedFile);
+    const normalizedBase = path2.normalize(resolvedBase);
+    return normalizedFile === normalizedBase || normalizedFile.startsWith(normalizedBase + path2.sep);
+  } catch {
+    return false;
+  }
+}
+function validateSchemaPath(dbPackagePath, projectRoot = process.cwd()) {
+  if (containsPathTraversal(dbPackagePath)) {
+    throw new Error(ERROR_MESSAGES.PATH_TRAVERSAL);
+  }
+  const schemaEntry = path2.join(dbPackagePath, "src", "schema", "index.ts");
+  const absoluteSchemaPath = path2.resolve(projectRoot, schemaEntry);
+  let resolvedProjectRoot;
+  try {
+    resolvedProjectRoot = realpathSync(projectRoot);
+  } catch {
+    resolvedProjectRoot = path2.resolve(projectRoot);
+  }
+  if (!isPathWithinBase(absoluteSchemaPath, resolvedProjectRoot)) {
+    throw new Error(ERROR_MESSAGES.PATH_TRAVERSAL);
+  }
+  if (!existsSync(absoluteSchemaPath)) {
+    throw new Error(ERROR_MESSAGES.SCHEMA_NOT_FOUND);
+  }
+  return absoluteSchemaPath;
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+async function extractSchemaTablesAndEnums(dbPackagePath, projectRoot = process.cwd()) {
+  const validatedSchemaPath = validateSchemaPath(dbPackagePath, projectRoot);
+  const jiti = createJiti(projectRoot, { interopDefault: true });
+  let schemaModule;
+  try {
+    schemaModule = await jiti.import(validatedSchemaPath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const hint = errorMessage.includes("unknown is not defined") ? "\n\nHint: Add 'unknown' to drizzle-orm/pg-core imports:\n  import { unknown, ... } from 'drizzle-orm/pg-core'" : "";
+    throw new Error(`Failed to load schema from ${validatedSchemaPath}: ${errorMessage}${hint}`);
+  }
+  const expectedTables = /* @__PURE__ */ new Set();
+  const expectedEnums = /* @__PURE__ */ new Map();
+  for (const value of Object.values(schemaModule)) {
+    if (isTable(value)) {
+      const unique = String(getTableUniqueName(value));
+      if (unique.startsWith("undefined.")) {
+        expectedTables.add(`public.${getTableName(value)}`);
+      } else {
+        expectedTables.add(unique);
+      }
+      continue;
+    }
+    if (isPgEnum(value)) {
+      expectedEnums.set(value.enumName, {
+        name: value.enumName,
+        values: uniqueSorted(value.enumValues)
+      });
+    }
+  }
+  return { expectedTables, expectedEnums };
+}
+async function fetchDbTablesAndEnums(databaseUrl, options) {
+  const schemaDir = options?.schemaDir ?? "packages/database/src/schema";
+  const managedSchemas = detectSchemaNames(schemaDir, process.cwd());
+  const systemSchemas = /* @__PURE__ */ new Set([
+    ...SUPABASE_SYSTEM_SCHEMAS,
+    ...options?.additionalSystemSchemas ?? []
+  ]);
+  const filteredManagedSchemas = managedSchemas.filter((s) => !systemSchemas.has(s));
+  const schemaList = buildSafeSchemaInClause(filteredManagedSchemas);
+  const tablesSql = `
+SELECT schemaname || '.' || tablename
+FROM pg_tables
+WHERE schemaname IN (${schemaList})
+ORDER BY schemaname, tablename;`.trim();
+  const enumsSql = `
+SELECT t.typname AS enum_name, string_agg(e.enumlabel, ',' ORDER BY e.enumsortorder) AS values
+FROM pg_type t
+JOIN pg_enum e ON t.oid = e.enumtypid
+JOIN pg_namespace n ON n.oid = t.typnamespace
+WHERE n.nspname = 'public'
+GROUP BY t.typname
+ORDER BY t.typname;`.trim();
+  const tablesOut = await psqlQuery({ databaseUrl, sql: tablesSql, mode: "table" });
+  const dbTables = /* @__PURE__ */ new Set();
+  for (const line of tablesOut.split("\n")) {
+    const v = line.trim();
+    if (v.length > 0) dbTables.add(v);
+  }
+  const enumsOut = await psqlQuery({ databaseUrl, sql: enumsSql, mode: "table" });
+  const dbEnums = /* @__PURE__ */ new Map();
+  for (const line of enumsOut.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const [enumName, valuesCsv] = trimmed.split("|").map((s) => s.trim());
+    const values = valuesCsv ? valuesCsv.split(",").map((s) => s.trim()) : [];
+    dbEnums.set(enumName, { name: enumName, values: uniqueSorted(values) });
+  }
+  return { dbTables, dbEnums };
+}
+function diffSchema(params) {
+  const missingTables = uniqueSorted(
+    [...params.expectedTables].filter((t) => !params.dbTables.has(t))
+  );
+  const exclusions = new Set(params.excludeFromOrphanDetection ?? []);
+  const exclusionPatterns = [...exclusions].filter((e) => e.includes("*"));
+  const exactExclusions = [...exclusions].filter((e) => !e.includes("*"));
+  const isExcluded = (table) => {
+    if (exactExclusions.includes(table)) return true;
+    for (const pattern of exclusionPatterns) {
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const regex = new RegExp(`^${escaped.replace(/\\\*/g, ".*")}$`);
+      if (regex.test(table)) return true;
+    }
+    return false;
+  };
+  const orphanTables = uniqueSorted(
+    [...params.dbTables].filter((t) => !params.expectedTables.has(t) && !isExcluded(t))
+  );
+  const expectedEnumNames = new Set(params.expectedEnums.keys());
+  const dbEnumNames = new Set(params.dbEnums.keys());
+  const missingEnums = uniqueSorted([...expectedEnumNames].filter((n) => !dbEnumNames.has(n)));
+  const extraEnums = uniqueSorted([...dbEnumNames].filter((n) => !expectedEnumNames.has(n)));
+  const enumValueMismatches = [];
+  for (const name of uniqueSorted([...expectedEnumNames].filter((n) => dbEnumNames.has(n)))) {
+    const s = params.expectedEnums.get(name);
+    const d = params.dbEnums.get(name);
+    if (!s || !d) continue;
+    const schemaValues = uniqueSorted(s.values);
+    const dbValues = uniqueSorted(d.values);
+    const same = schemaValues.length === dbValues.length && schemaValues.every((v, i) => v === dbValues[i]);
+    if (same) continue;
+    const added = schemaValues.filter((v) => !dbValues.includes(v));
+    const removed = dbValues.filter((v) => !schemaValues.includes(v));
+    enumValueMismatches.push({ name, dbValues, schemaValues, added, removed });
+  }
+  return {
+    expectedTables: params.expectedTables,
+    expectedEnums: params.expectedEnums,
+    dbTables: params.dbTables,
+    dbEnums: params.dbEnums,
+    missingTables,
+    orphanTables,
+    missingEnums,
+    extraEnums,
+    enumValueMismatches
+  };
+}
+function extractTablesFromIdempotentSql(idempotentDir, projectRoot = process.cwd()) {
+  const fullPath = path2.resolve(projectRoot, idempotentDir);
+  if (!existsSync(fullPath)) {
+    return [];
+  }
+  const tables = [];
+  const createTablePattern = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:"?([a-zA-Z_][a-zA-Z0-9_]*)"?\.)?(?:"?([a-zA-Z_][a-zA-Z0-9_]*)"?)/gi;
+  try {
+    const files = readdirSync(fullPath).filter((f) => f.endsWith(".sql"));
+    for (const file of files) {
+      const filePath = path2.join(fullPath, file);
+      const content = readFileSync(filePath, "utf-8");
+      const contentWithoutComments = content.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+      for (const match of contentWithoutComments.matchAll(createTablePattern)) {
+        const schema = match[1] || "public";
+        const tableName = match[2];
+        if (tableName) {
+          tables.push(`${schema}.${tableName}`);
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return [...new Set(tables)].sort();
+}
+
+// src/commands/db/utils/table-registry.ts
+init_esm_shims();
+
+// src/commands/db/utils/semantic-mapper.ts
+init_esm_shims();
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateSemanticName(schema, tableName, useSchemaPrefix = false) {
+  const baseName = snakeToCamel(tableName);
+  if (useSchemaPrefix) {
+    const schemaPrefix = snakeToCamel(schema);
+    return schemaPrefix + baseName.charAt(0).toUpperCase() + baseName.slice(1);
+  }
+  return baseName;
+}
+function groupBySemanticName(tables) {
+  const bySemanticName = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const baseName = snakeToCamel(table.name);
+    const existing = bySemanticName.get(baseName) ?? [];
+    existing.push(table);
+    bySemanticName.set(baseName, existing);
+  }
+  return bySemanticName;
+}
+function collectConflicts(bySemanticName) {
+  const conflicts = [];
+  for (const [semanticName, tables] of bySemanticName) {
+    if (tables.length <= 1) continue;
+    conflicts.push({
+      semanticName,
+      tables: tables.map((table) => table.qualifiedName)
+    });
+  }
+  return conflicts;
+}
+function getSchemaPriorityRank(schema, prioritySchemas) {
+  const index = prioritySchemas.indexOf(schema);
+  return index === -1 ? Number.POSITIVE_INFINITY : index;
+}
+function compareTablesByPriorityAndName(left, right, prioritySchemas) {
+  const leftRank = getSchemaPriorityRank(left.schema, prioritySchemas);
+  const rightRank = getSchemaPriorityRank(right.schema, prioritySchemas);
+  if (leftRank !== rightRank) {
+    return leftRank - rightRank;
+  }
+  return left.qualifiedName.localeCompare(right.qualifiedName);
+}
+function applyOverride(table, overrides, mapping) {
+  const overrideName = overrides[table.qualifiedName];
+  if (!overrideName) return false;
+  mapping[overrideName] = table.qualifiedName;
+  return true;
+}
+function resolveFirstStrategy(table, baseName, tablesWithSameName, prioritySchemas) {
+  const sorted = [...tablesWithSameName].sort(
+    (left, right) => compareTablesByPriorityAndName(left, right, prioritySchemas)
+  );
+  if (sorted[0]?.qualifiedName === table.qualifiedName) {
+    return { mappedName: baseName };
+  }
+  return { skipped: true };
+}
+function resolveConflict(table, baseName, tablesWithSameName, conflictStrategy, prioritySchemas) {
+  switch (conflictStrategy) {
+    case "prefix":
+      return { mappedName: generateSemanticName(table.schema, table.name, true) };
+    case "error":
+      throw new Error(
+        `Semantic name conflict: '${baseName}' maps to multiple tables: ${tablesWithSameName.map((candidate) => candidate.qualifiedName).join(", ")}`
+      );
+    case "first":
+      return resolveFirstStrategy(table, baseName, tablesWithSameName, prioritySchemas);
+  }
+}
+function generateMapping(tables, options = {}) {
+  const { conflictStrategy = "prefix", prioritySchemas = [], overrides = {} } = options;
+  const bySemanticName = groupBySemanticName(tables);
+  const conflicts = collectConflicts(bySemanticName);
+  const mapping = {};
+  const skipped = [];
+  for (const table of tables) {
+    if (applyOverride(table, overrides, mapping)) {
+      continue;
+    }
+    const baseName = snakeToCamel(table.name);
+    const tablesWithSameName = bySemanticName.get(baseName) ?? [];
+    if (tablesWithSameName.length === 1) {
+      mapping[baseName] = table.qualifiedName;
+      continue;
+    }
+    const resolution = resolveConflict(
+      table,
+      baseName,
+      tablesWithSameName,
+      conflictStrategy,
+      prioritySchemas
+    );
+    if (resolution.mappedName) {
+      mapping[resolution.mappedName] = table.qualifiedName;
+    } else if (resolution.skipped) {
+      skipped.push(table.qualifiedName);
+    }
+  }
+  return { mapping, conflicts, skipped };
+}
+function applyMappingToTables(tables, mapping) {
+  const reverseMapping = /* @__PURE__ */ new Map();
+  for (const [semantic, qualified] of Object.entries(mapping)) {
+    reverseMapping.set(qualified, semantic);
+  }
+  return tables.map((table) => ({
+    ...table,
+    semanticName: reverseMapping.get(table.qualifiedName) || table.semanticName
+  }));
+}
+
+// src/commands/db/utils/sql-table-extractor.ts
+init_esm_shims();
+
+// src/commands/db/utils/sql-table-extractor-regex.ts
+init_esm_shims();
+function findTablesRegex(ctx) {
+  const tables = [];
+  const regex = new RegExp(SQL_PATTERNS.createTable.source, "gi");
+  for (const match of ctx.content.matchAll(regex)) {
+    const reference = parseTableReference(match[1] ?? "");
+    if (!reference) continue;
+    const lineNumber = getLineNumber(ctx.content, match.index ?? 0);
+    const tableBody = extractTableBody(ctx.content, match.index ?? 0);
+    tables.push({ schema: reference.schema, name: reference.name, lineNumber, tableBody });
+  }
+  return tables;
+}
+function shouldSkipColumnLine(trimmed) {
+  return !trimmed || trimmed.startsWith("--") || /^(?:PRIMARY|FOREIGN|UNIQUE|CHECK|CONSTRAINT)\s/i.test(trimmed);
+}
+function isReservedKeyword(name) {
+  return /^(?:PRIMARY|FOREIGN|UNIQUE|CHECK|CONSTRAINT)$/i.test(name);
+}
+var COLUMN_CONSTRAINT_KEYWORDS = [
+  "NOT NULL",
+  "DEFAULT",
+  "REFERENCES",
+  "PRIMARY",
+  "UNIQUE",
+  "CHECK",
+  "CONSTRAINT"
+];
+function isBoundaryAtTopLevel(source, index, keyword) {
+  const before = index === 0 || /\s|[(),]/.test(source[index - 1] ?? "");
+  const after = index + keyword.length;
+  const afterChar = source[after] ?? "";
+  const afterBoundary = after === source.length || /\s|[(),]/.test(afterChar);
+  if (!before || !afterBoundary) {
+    return false;
+  }
+  return source.substring(index, after).toUpperCase() === keyword;
+}
+function createConstraintScanState() {
+  return {
+    depth: 0,
+    dollarTag: "",
+    inDollarQuote: false,
+    inDoubleQuote: false,
+    inSingleQuote: false
+  };
+}
+function consumeConstraintDollarQuote(line, index, state) {
+  if ((line[index] ?? "") !== "$" || state.inSingleQuote || state.inDoubleQuote) {
+    return null;
+  }
+  if (state.inDollarQuote) {
+    const closeTag = `$${state.dollarTag}$`;
+    if (!line.slice(index).startsWith(closeTag)) {
+      return null;
+    }
+    state.inDollarQuote = false;
+    state.dollarTag = "";
+    return index + closeTag.length - 1;
+  }
+  const tagMatch = line.slice(index).match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/);
+  if (!tagMatch) {
+    return null;
+  }
+  state.inDollarQuote = true;
+  state.dollarTag = tagMatch[1] ?? "";
+  return index + tagMatch[0].length - 1;
+}
+function consumeConstraintSingleQuote(line, index, state) {
+  if ((line[index] ?? "") !== "'" || state.inDoubleQuote || state.inDollarQuote) {
+    return null;
+  }
+  if (state.inSingleQuote && (line[index + 1] ?? "") === "'") {
+    return index + 1;
+  }
+  state.inSingleQuote = !state.inSingleQuote;
+  return index;
+}
+function consumeConstraintDoubleQuote(line, index, state) {
+  if ((line[index] ?? "") !== '"' || state.inSingleQuote || state.inDollarQuote) {
+    return null;
+  }
+  if (state.inDoubleQuote && (line[index + 1] ?? "") === '"') {
+    return index + 1;
+  }
+  state.inDoubleQuote = !state.inDoubleQuote;
+  return index;
+}
+function consumeConstraintQuote(line, index, state) {
+  const adjustedByDollar = consumeConstraintDollarQuote(line, index, state);
+  if (adjustedByDollar !== null) {
+    return adjustedByDollar;
+  }
+  const adjustedBySingle = consumeConstraintSingleQuote(line, index, state);
+  if (adjustedBySingle !== null) {
+    return adjustedBySingle;
+  }
+  return consumeConstraintDoubleQuote(line, index, state);
+}
+function isInsideConstraintQuote(state) {
+  return state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote;
+}
+function updateConstraintDepth(char, state) {
+  if (char === "(") {
+    state.depth += 1;
+    return;
+  }
+  if (char === ")" && state.depth > 0) {
+    state.depth -= 1;
+  }
+}
+function findKeywordAtTopLevel(upper, index, keywords) {
+  return keywords.some(
+    (keyword) => upper.startsWith(keyword, index) && isBoundaryAtTopLevel(upper, index, keyword)
+  );
+}
+function findConstraintStart(line, keywords = COLUMN_CONSTRAINT_KEYWORDS) {
+  const upper = line.toUpperCase();
+  const state = createConstraintScanState();
+  for (let i = 0; i < upper.length; i++) {
+    const adjustedIndex = consumeConstraintQuote(line, i, state);
+    if (adjustedIndex !== null) {
+      i = adjustedIndex;
+      continue;
+    }
+    if (isInsideConstraintQuote(state)) continue;
+    const char = upper[i] ?? "";
+    updateConstraintDepth(char, state);
+    if (char === "(" || char === ")") continue;
+    if (state.depth !== 0) continue;
+    if (findKeywordAtTopLevel(upper, i, keywords)) return i;
+  }
+  return -1;
+}
+function parseInlineReference(constraintSource) {
+  const referenceStart = findConstraintStart(constraintSource, ["REFERENCES"]);
+  if (referenceStart === -1) {
+    return null;
+  }
+  const afterConstraint = constraintSource.slice(referenceStart);
+  if (!/^\s*REFERENCES\s+/i.test(afterConstraint)) {
+    return null;
+  }
+  const refMatch = afterConstraint.match(
+    new RegExp(`^\\s*REFERENCES\\s+(${TABLE_REFERENCE})\\s*\\(\\s*(${SQL_IDENTIFIER})\\s*\\)`, "i")
+  );
+  if (!refMatch) {
+    return null;
+  }
+  const ref = parseTableReference(refMatch[1] ?? "");
+  const refColumn = unquoteIdentifier(refMatch[2] ?? "");
+  if (!ref || !refColumn) {
+    return null;
+  }
+  return { table: `${ref.schema}.${ref.name}`, column: refColumn };
+}
+function splitColumnDeclaration(line) {
+  const columnMatch = line.match(
+    /^((?:"(?:[^"]|"")*"|[a-zA-Z_][a-zA-Z0-9_]*))\s+(.+?)(?:\s*,\s*)?$/
+  );
+  if (!columnMatch) {
+    return null;
+  }
+  const name = unquoteIdentifier(columnMatch[1] ?? "");
+  const rest = (columnMatch[2] ?? "").trim();
+  if (!name || isReservedKeyword(name)) {
+    return null;
+  }
+  const typeEndIndex = (() => {
+    const withParens = rest;
+    const constraintsIndex = findConstraintStart(withParens);
+    if (constraintsIndex === -1) {
+      return withParens.length;
+    }
+    return constraintsIndex;
+  })();
+  const type = rest.slice(0, typeEndIndex).trim();
+  const remaining = rest.slice(typeEndIndex);
+  const inlineReference = parseInlineReference(remaining);
+  const hasDefault = findConstraintStart(remaining, ["DEFAULT"]) !== -1;
+  const notNull = findConstraintStart(remaining, ["NOT NULL"]) !== -1;
+  const isPrimaryKey = findConstraintStart(remaining, ["PRIMARY KEY"]) !== -1;
+  return {
+    name,
+    type,
+    hasDefault,
+    notNull,
+    isPrimaryKey,
+    inlineReferenceTable: inlineReference?.table,
+    inlineReferenceColumn: inlineReference?.column
+  };
+}
+function parseColumnsRegex(tableBody) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = splitTopLevelSqlStatements(tableBody);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (shouldSkipColumnLine(trimmed)) continue;
+    const column = splitColumnDeclaration(trimmed);
+    if (!column) continue;
+    if (!column.name || seen.has(column.name) || isReservedKeyword(column.name)) continue;
+    seen.add(column.name);
+    columns.push({
+      name: column.name,
+      type: normalizeType(column.type),
+      notNull: column.notNull || column.isPrimaryKey,
+      hasDefault: column.hasDefault,
+      isPrimaryKey: column.isPrimaryKey
+    });
+  }
+  return columns;
+}
+function parsePrimaryKeyRegex(tableBody) {
+  const regex = new RegExp(SQL_PATTERNS.primaryKey.source, "i");
+  const found = [];
+  for (const line of splitTopLevelSqlStatements(tableBody)) {
+    const match = line.match(regex);
+    if (!match || !match[1]) {
+      continue;
+    }
+    for (const col of match[1]?.split(",") ?? []) {
+      const normalized = unquoteIdentifier(col.trim());
+      if (normalized && !found.includes(normalized)) {
+        found.push(normalized);
+      }
+    }
+    regex.lastIndex = 0;
+  }
+  return found;
+}
+function parseExplicitForeignKeys(tableBody) {
+  const fks = [];
+  const fkRegex = new RegExp(SQL_PATTERNS.foreignKey.source, "gi");
+  for (const line of splitTopLevelSqlStatements(tableBody)) {
+    for (const match of line.matchAll(fkRegex)) {
+      const column = unquoteIdentifier(match[1] ?? "");
+      const ref = parseTableReference(match[2] ?? "");
+      const refColumn = unquoteIdentifier(match[3] ?? "");
+      if (!column || !ref || !refColumn) continue;
+      fks.push({
+        column,
+        referencesTable: `${ref.schema}.${ref.name}`,
+        referencesColumn: refColumn,
+        onDelete: normalizeOnAction(match[4]),
+        onUpdate: normalizeOnAction(match[5])
+      });
+    }
+  }
+  return fks;
+}
+function parseInlineForeignKeys(tableBody, existingColumns) {
+  const fks = [];
+  for (const fragment of splitTopLevelSqlStatements(tableBody)) {
+    const declaration = splitColumnDeclaration(fragment);
+    if (!declaration) continue;
+    if (!declaration.inlineReferenceTable || !declaration.inlineReferenceColumn) continue;
+    if (existingColumns.has(declaration.name)) continue;
+    fks.push({
+      column: declaration.name,
+      referencesTable: declaration.inlineReferenceTable,
+      referencesColumn: declaration.inlineReferenceColumn
+    });
+  }
+  return fks;
+}
+function parseForeignKeysRegex(tableBody) {
+  const explicitFks = parseExplicitForeignKeys(tableBody);
+  const existingColumns = new Set(explicitFks.map((fk) => fk.column));
+  const inlineFks = parseInlineForeignKeys(tableBody, existingColumns);
+  return [...explicitFks, ...inlineFks];
+}
+function parseIndexesRegex(content, schema, tableName) {
+  const indexes = [];
+  const regex = new RegExp(SQL_PATTERNS.createIndex.source, "gi");
+  for (const match of content.matchAll(regex)) {
+    const indexTableRef = parseTableReference(match[3] ?? "");
+    if (!indexTableRef) continue;
+    const indexSchema = indexTableRef.schema;
+    const indexTable = indexTableRef.name;
+    if (indexSchema === schema && indexTable === tableName) {
+      const indexName = unquoteIdentifier(match[2] ?? "");
+      if (!indexName) continue;
+      const rawColumns = match[4] ?? "";
+      indexes.push({
+        name: indexName,
+        columns: parseIndexColumns(rawColumns),
+        isUnique: !!match[1]
+      });
+    }
+  }
+  return indexes;
+}
+function hasRlsEnabledRegex(content, schema, tableName) {
+  const regex = new RegExp(SQL_PATTERNS.enableRls.source, "gi");
+  for (const match of content.matchAll(regex)) {
+    const matchTable = parseTableReference(match[1] ?? "");
+    if (!matchTable) continue;
+    if (matchTable.schema === schema && matchTable.name === tableName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/commands/db/utils/sql-table-extractor-rls.ts
+init_esm_shims();
+function readDollarTagAt(content, index) {
+  if (content[index] !== "$") return void 0;
+  const match = content.slice(index).match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/);
+  return match?.[0];
+}
+function consumePolicySingleQuote(content, state) {
+  if (!state.inSingleQuote) return false;
+  const char = content[state.cursor] ?? "";
+  const next = content[state.cursor + 1] ?? "";
+  if (char === "'" && next === "'") {
+    state.cursor += 2;
+    return true;
+  }
+  if (char === "'") {
+    state.inSingleQuote = false;
+  }
+  state.cursor += 1;
+  return true;
+}
+function consumePolicyDoubleQuote(content, state) {
+  if (!state.inDoubleQuote) return false;
+  const char = content[state.cursor] ?? "";
+  const next = content[state.cursor + 1] ?? "";
+  if (char === '"' && next === '"') {
+    state.cursor += 2;
+    return true;
+  }
+  if (char === '"') {
+    state.inDoubleQuote = false;
+  }
+  state.cursor += 1;
+  return true;
+}
+function consumePolicyDollarQuote(content, state) {
+  if (!state.inDollarQuote) return false;
+  const closeTag = `$${state.dollarTag}$`;
+  if (content.startsWith(closeTag, state.cursor)) {
+    state.inDollarQuote = false;
+    state.dollarTag = "";
+    state.cursor += closeTag.length;
+    return true;
+  }
+  state.cursor += 1;
+  return true;
+}
+function trySkipPolicyLineComment(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote) return false;
+  const char = content[state.cursor] ?? "";
+  const next = content[state.cursor + 1] ?? "";
+  if (char !== "-" || next !== "-") return false;
+  const newlineIndex = content.indexOf("\n", state.cursor);
+  state.cursor = newlineIndex === -1 ? content.length : newlineIndex + 1;
+  return true;
+}
+function trySkipPolicyBlockComment(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote) return false;
+  const char = content[state.cursor] ?? "";
+  const next = content[state.cursor + 1] ?? "";
+  if (char !== "/" || next !== "*") return false;
+  const closeIndex = content.indexOf("*/", state.cursor + 2);
+  state.cursor = closeIndex === -1 ? content.length : closeIndex + 2;
+  return true;
+}
+function tryStartPolicyDollarQuote(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote) return false;
+  const tag = readDollarTagAt(content, state.cursor);
+  if (!tag) return false;
+  state.inDollarQuote = true;
+  state.dollarTag = tag.slice(1, -1);
+  state.cursor += tag.length;
+  return true;
+}
+function tryStartPolicySingleQuote(content, state) {
+  if (state.inDoubleQuote || state.inDollarQuote || content[state.cursor] !== "'") return false;
+  state.inSingleQuote = true;
+  state.cursor += 1;
+  return true;
+}
+function tryStartPolicyDoubleQuote(content, state) {
+  if (state.inSingleQuote || state.inDollarQuote || content[state.cursor] !== '"') return false;
+  state.inDoubleQuote = true;
+  state.cursor += 1;
+  return true;
+}
+function consumePolicySqlTrivia(content, state) {
+  if (consumePolicySingleQuote(content, state)) return true;
+  if (consumePolicyDoubleQuote(content, state)) return true;
+  if (consumePolicyDollarQuote(content, state)) return true;
+  if (trySkipPolicyLineComment(content, state)) return true;
+  if (trySkipPolicyBlockComment(content, state)) return true;
+  if (tryStartPolicyDollarQuote(content, state)) return true;
+  if (tryStartPolicySingleQuote(content, state)) return true;
+  return tryStartPolicyDoubleQuote(content, state);
+}
+function findOutsideSqlCharIndex(content, startIndex, predicate) {
+  const state = {
+    cursor: startIndex,
+    inSingleQuote: false,
+    inDoubleQuote: false,
+    inDollarQuote: false,
+    dollarTag: ""
+  };
+  while (state.cursor < content.length) {
+    if (consumePolicySqlTrivia(content, state)) continue;
+    const char = content[state.cursor] ?? "";
+    if (predicate(char, state.cursor)) return state.cursor;
+    state.cursor += 1;
+  }
+  return void 0;
+}
+function extractCreatePolicyStatements(content) {
+  const statements = [];
+  const startRegex = /\bCREATE\s+POLICY\b/gi;
+  let match;
+  while ((match = startRegex.exec(content)) !== null) {
+    const startIndex = match.index ?? 0;
+    const endIndex = findSqlStatementEndForPolicy(content, startIndex);
+    statements.push(content.slice(startIndex, endIndex).trim());
+  }
+  return statements;
+}
+function findSqlStatementEndForPolicy(content, startIndex) {
+  const semicolonIndex = findOutsideSqlCharIndex(content, startIndex, (char) => char === ";");
+  return semicolonIndex === void 0 ? content.length : semicolonIndex + 1;
+}
+function extractBalancedClause(statement, startIndex) {
+  const openParenIndex = statement.indexOf("(", startIndex);
+  if (openParenIndex === -1) return void 0;
+  let depth = 0;
+  let clauseStart = -1;
+  const closeParenIndex = findOutsideSqlCharIndex(statement, openParenIndex, (char, index) => {
+    if (char === "(") {
+      if (depth === 0) clauseStart = index + 1;
+      depth++;
+      return false;
+    }
+    if (char === ")") {
+      depth--;
+      return depth === 0 && clauseStart !== -1;
+    }
+    return false;
+  });
+  if (closeParenIndex === void 0 || clauseStart === -1) return void 0;
+  return statement.slice(clauseStart, closeParenIndex).trim();
+}
+function parsePolicyDefinitionFromStatement(statement, headerRegex, schema, tableName) {
+  const match = statement.match(headerRegex);
+  if (!match) return void 0;
+  const policyName = unquoteIdentifier(match[1] ?? match[2] ?? "");
+  const policyTableRef = parseTableReference(match[3] ?? "");
+  if (!policyName || !policyTableRef) return void 0;
+  if (policyTableRef.schema !== schema || policyTableRef.name !== tableName) return void 0;
+  const usingIndex = statement.search(/\bUSING\s*\(/i);
+  const withCheckIndex = statement.search(/\bWITH\s+CHECK\s*\(/i);
+  return {
+    name: policyName,
+    command: (match[4] || "ALL").toUpperCase(),
+    using: usingIndex !== -1 ? extractBalancedClause(statement, usingIndex) : void 0,
+    withCheck: withCheckIndex !== -1 ? extractBalancedClause(statement, withCheckIndex) : void 0
+  };
+}
+function parsePoliciesRegex(content, schema, tableName) {
+  const policies = [];
+  const statements = extractCreatePolicyStatements(content);
+  const headerRegex = new RegExp(
+    `^\\s*CREATE\\s+POLICY\\s+(?:"((?:[^"]|"")*)"|([a-zA-Z_][a-zA-Z0-9_]*))\\s+ON\\s+(${TABLE_REFERENCE})(?:\\s+AS\\s+\\w+)?(?:\\s+FOR\\s+(\\w+))?`,
+    "i"
+  );
+  for (const statement of statements) {
+    const parsed = parsePolicyDefinitionFromStatement(statement, headerRegex, schema, tableName);
+    if (parsed) {
+      policies.push(parsed);
+    }
+  }
+  return policies;
+}
+
+// src/commands/db/utils/sql-table-extractor-ast.ts
+init_esm_shims();
+function convertAstColumns(columns, include) {
+  if (!include) return void 0;
+  return columns.map((col) => ({
+    name: col.name,
+    type: col.type,
+    notNull: col.notNull,
+    hasDefault: col.hasDefault,
+    isPrimaryKey: col.isPrimaryKey
+  }));
+}
+function convertAstForeignKeys(fks, include) {
+  if (!include) return void 0;
+  const result = fks.map((fk) => ({
+    column: fk.column,
+    referencesTable: fk.referencesTable,
+    referencesColumn: fk.referencesColumn,
+    onDelete: fk.onDelete,
+    onUpdate: fk.onUpdate
+  }));
+  return result.length > 0 ? result : void 0;
+}
+function convertAstIndexes(indexes, include) {
+  if (!include || indexes.length === 0) return void 0;
+  return indexes.map((idx) => ({
+    name: idx.name,
+    columns: idx.columns,
+    isUnique: idx.isUnique
+  }));
+}
+async function extractTablesWithAst(content, filePath, opts) {
+  const parser = await getSqlParserUtils();
+  if (!parser) return [];
+  const astTables = await parser.parseCreateTables(content);
+  const tables = [];
+  for (const astTable of astTables) {
+    if (opts.includeIndexes) {
+      await parser.parseIndexesForTables(content, [astTable]);
+    }
+    const hasRls = hasRlsEnabledRegex(content, astTable.schema, astTable.name);
+    const rlsPolicies = opts.includeRlsPolicies && hasRls ? parsePoliciesRegex(content, astTable.schema, astTable.name) : void 0;
+    tables.push({
+      schema: astTable.schema,
+      name: astTable.name,
+      qualifiedName: astTable.qualifiedName,
+      semanticName: snakeToCamel2(astTable.name),
+      sourceFile: filePath,
+      lineNumber: astTable.lineNumber ?? 1,
+      columns: convertAstColumns(astTable.columns, opts.includeColumns),
+      primaryKey: astTable.primaryKey,
+      foreignKeys: convertAstForeignKeys(astTable.foreignKeys, opts.includeForeignKeys),
+      indexes: convertAstIndexes(astTable.indexes, opts.includeIndexes),
+      hasRls,
+      rlsPolicies: rlsPolicies?.length ? rlsPolicies : void 0
+    });
+  }
+  return tables;
+}
+
+// src/commands/db/utils/sql-table-extractor.ts
+var sqlParserUtils = null;
+var astAvailable = null;
+async function isAstParserAvailable() {
+  if (astAvailable !== null) return astAvailable;
+  try {
+    const { loadSqlParserUtils } = await import('@runa-ai/runa/ast');
+    sqlParserUtils = await loadSqlParserUtils();
+    const isAvailable = await sqlParserUtils.isSqlParserAvailable();
+    astAvailable = isAvailable;
+    return isAvailable;
+  } catch {
+    astAvailable = false;
+    return false;
+  }
+}
+async function getSqlParserUtils() {
+  if (sqlParserUtils) return sqlParserUtils;
+  await isAstParserAvailable();
+  return sqlParserUtils;
+}
+var SQL_IDENTIFIER = '(?:"(?:[^"]|"")*"|[a-zA-Z_][a-zA-Z0-9_]*)';
+var TABLE_REFERENCE = `${SQL_IDENTIFIER}(?:\\s*\\.\\s*${SQL_IDENTIFIER})?`;
+var TABLE_IDENTIFIER = /(?:"(?:[^"]|"")*"|[a-zA-Z_][a-zA-Z0-9_]*)/g;
+var SQL_PATTERNS = {
+  // CREATE TABLE [IF NOT EXISTS] schema.table_name (
+  createTable: new RegExp(
+    `CREATE\\s+TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${TABLE_REFERENCE})\\s*\\(`,
+    "gi"
+  ),
+  // PRIMARY KEY (columns)
+  primaryKey: /PRIMARY\s+KEY\s*\(([^)]+)\)/gi,
+  // FOREIGN KEY (column) REFERENCES schema.table(column) [ON DELETE|UPDATE ...]
+  foreignKey: new RegExp(
+    `FOREIGN\\s+KEY\\s*\\((${SQL_IDENTIFIER})\\)\\s*REFERENCES\\s+(${TABLE_REFERENCE})\\s*\\((${SQL_IDENTIFIER})\\)(?:\\s+ON\\s+DELETE\\s+(\\w+(?:\\s+\\w+)?))?(?:\\s+ON\\s+UPDATE\\s+(\\w+(?:\\s+\\w+)?))?`,
+    "gi"
+  ),
+  // CREATE [UNIQUE] INDEX name ON schema.table (columns)
+  createIndex: new RegExp(
+    `CREATE\\s+(UNIQUE\\s+)?INDEX\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${SQL_IDENTIFIER})\\s+ON\\s+(${TABLE_REFERENCE})(?:\\s+USING\\s+\\w+)?\\s*\\(([^)]+)\\)`,
+    "gi"
+  ),
+  // ALTER TABLE ... ENABLE ROW LEVEL SECURITY
+  enableRls: new RegExp(
+    `ALTER\\s+TABLE\\s+(${TABLE_REFERENCE})\\s+ENABLE\\s+ROW\\s+LEVEL\\s+SECURITY`,
+    "gi"
+  )
+};
+function createTopLevelSplitState() {
+  return {
+    depth: 0,
+    dollarTag: "",
+    inDollarQuote: false,
+    inDoubleQuote: false,
+    inSingleQuote: false,
+    start: 0
+  };
+}
+function consumeDollarQuoteToken(content, index, state) {
+  if ((content[index] ?? "") !== "$" || state.inSingleQuote || state.inDoubleQuote) {
+    return null;
+  }
+  if (state.inDollarQuote) {
+    const closeTag = `$${state.dollarTag}$`;
+    if (!content.slice(index).startsWith(closeTag)) {
+      return null;
+    }
+    state.inDollarQuote = false;
+    state.dollarTag = "";
+    return index + closeTag.length - 1;
+  }
+  const tagMatch = content.slice(index).match(/^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/);
+  if (!tagMatch) {
+    return null;
+  }
+  state.inDollarQuote = true;
+  state.dollarTag = tagMatch[1] ?? "";
+  return index + tagMatch[0].length - 1;
+}
+function consumeSingleQuoteToken(content, index, state) {
+  if ((content[index] ?? "") !== "'" || state.inDoubleQuote || state.inDollarQuote) {
+    return null;
+  }
+  if (state.inSingleQuote && (content[index + 1] ?? "") === "'") {
+    return index + 1;
+  }
+  state.inSingleQuote = !state.inSingleQuote;
+  return index;
+}
+function consumeDoubleQuoteToken(content, index, state) {
+  if ((content[index] ?? "") !== '"' || state.inSingleQuote || state.inDollarQuote) {
+    return null;
+  }
+  if (state.inDoubleQuote && (content[index + 1] ?? "") === '"') {
+    return index + 1;
+  }
+  state.inDoubleQuote = !state.inDoubleQuote;
+  return index;
+}
+function consumeQuoteToken(content, index, state) {
+  const adjustedByDollarQuote = consumeDollarQuoteToken(content, index, state);
+  if (adjustedByDollarQuote !== null) {
+    return adjustedByDollarQuote;
+  }
+  const adjustedBySingleQuote = consumeSingleQuoteToken(content, index, state);
+  if (adjustedBySingleQuote !== null) {
+    return adjustedBySingleQuote;
+  }
+  return consumeDoubleQuoteToken(content, index, state);
+}
+function isInQuotedScope(state) {
+  return state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote;
+}
+function processStructuralToken(content, index, state, chunks) {
+  const char = content[index] ?? "";
+  if (char === "(") {
+    state.depth += 1;
+    return;
+  }
+  if (char === ")" && state.depth > 0) {
+    state.depth -= 1;
+    return;
+  }
+  if (char === "," && state.depth === 0) {
+    chunks.push(content.slice(state.start, index));
+    state.start = index + 1;
+  }
+}
+function splitByTopLevelComma(content) {
+  const chunks = [];
+  const state = createTopLevelSplitState();
+  for (let i = 0; i < content.length; i++) {
+    const adjustedIndex = consumeQuoteToken(content, i, state);
+    if (adjustedIndex !== null) {
+      i = adjustedIndex;
+      continue;
+    }
+    if (isInQuotedScope(state)) continue;
+    processStructuralToken(content, i, state, chunks);
+  }
+  chunks.push(content.slice(state.start));
+  return chunks.map((chunk) => chunk.trim()).filter(Boolean);
+}
+function splitTopLevelSqlStatements(content) {
+  return splitByTopLevelComma(content);
+}
+function splitTopLevelCsv(content) {
+  return splitByTopLevelComma(content);
+}
+function collectSqlFiles(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectSqlFiles(fullPath));
+    } else if (entry.isFile() && fullPath.endsWith(".sql")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function snakeToCamel2(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function getLineNumber(content, position) {
+  return content.substring(0, position).split("\n").length;
+}
+function extractTableBody(content, startPos) {
+  let depth = 0;
+  let bodyStart = -1;
+  let bodyEnd = -1;
+  for (let i = startPos; i < content.length; i++) {
+    const char = content[i];
+    if (char === "(") {
+      if (depth === 0) {
+        bodyStart = i + 1;
+      }
+      depth++;
+    } else if (char === ")") {
+      depth--;
+      if (depth === 0) {
+        bodyEnd = i;
+        break;
+      }
+    }
+  }
+  if (bodyStart === -1 || bodyEnd === -1) {
+    return "";
+  }
+  return content.substring(bodyStart, bodyEnd);
+}
+function normalizeType(type) {
+  return type.trim().replace(/\s+/g, " ").toLowerCase().replace("character varying", "varchar").replace("timestamp with time zone", "timestamptz").replace("timestamp without time zone", "timestamp");
+}
+function unquoteIdentifier(identifier) {
+  const trimmed = identifier.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/""/g, '"');
+  }
+  return trimmed;
+}
+function parseTableReference(ref) {
+  const tokens = [...ref.matchAll(new RegExp(TABLE_IDENTIFIER.source, "g"))].map(
+    (match) => unquoteIdentifier(match[0] ?? "")
+  );
+  if (tokens.length === 1) {
+    return { schema: "public", name: tokens[0] ?? "" };
+  }
+  if (tokens.length === 2) {
+    return { schema: tokens[0] ?? "", name: tokens[1] ?? "" };
+  }
+  return null;
+}
+function parseIndexColumns(rawColumns) {
+  return splitTopLevelCsv(rawColumns).map((col) => {
+    const trimmed = col.trim();
+    const quotedMatch = trimmed.match(/^"([^"]+)"/);
+    if (quotedMatch) {
+      return quotedMatch[1];
+    }
+    const unquotedMatch = trimmed.match(/^(\w+)/);
+    if (unquotedMatch) {
+      return unquotedMatch[1];
+    }
+    return "";
+  }).filter(Boolean);
+}
+function normalizeOnAction(action) {
+  if (!action) return void 0;
+  const normalized = action.toUpperCase().replace(/\s+/g, " ").trim();
+  switch (normalized) {
+    case "CASCADE":
+      return "CASCADE";
+    case "SET NULL":
+      return "SET NULL";
+    case "SET DEFAULT":
+      return "SET DEFAULT";
+    case "RESTRICT":
+      return "RESTRICT";
+    case "NO ACTION":
+      return "NO ACTION";
+    default:
+      return void 0;
+  }
+}
+function resolveOptions(options) {
+  return {
+    includeColumns: options.includeColumns ?? true,
+    includeForeignKeys: options.includeForeignKeys ?? true,
+    includeIndexes: options.includeIndexes ?? true,
+    includeRlsPolicies: options.includeRlsPolicies ?? true
+  };
+}
+function buildTableEntryRegex(table, content, filePath, opts) {
+  const qualifiedName = `${table.schema}.${table.name}`;
+  const pkFromBody = parsePrimaryKeyRegex(table.tableBody);
+  let columns;
+  if (opts.includeColumns) {
+    columns = parseColumnsRegex(table.tableBody);
+    for (const col of columns) {
+      if (pkFromBody.includes(col.name)) {
+        col.isPrimaryKey = true;
+      }
+    }
+  }
+  const foreignKeys = opts.includeForeignKeys ? parseForeignKeysRegex(table.tableBody) : void 0;
+  const indexes = opts.includeIndexes ? parseIndexesRegex(content, table.schema, table.name) : void 0;
+  const hasRls = hasRlsEnabledRegex(content, table.schema, table.name);
+  const rlsPolicies = opts.includeRlsPolicies && hasRls ? parsePoliciesRegex(content, table.schema, table.name) : void 0;
+  return {
+    schema: table.schema,
+    name: table.name,
+    qualifiedName,
+    semanticName: snakeToCamel2(table.name),
+    sourceFile: filePath,
+    lineNumber: table.lineNumber,
+    columns,
+    primaryKey: pkFromBody.length > 0 ? pkFromBody : void 0,
+    foreignKeys: foreignKeys?.length ? foreignKeys : void 0,
+    indexes: indexes?.length ? indexes : void 0,
+    hasRls,
+    rlsPolicies: rlsPolicies?.length ? rlsPolicies : void 0
+  };
+}
+function processTablesFromFileRegex(filePath, opts, seen) {
+  const rawContent = readFileSync(filePath, "utf-8");
+  const content = stripSqlComments(rawContent);
+  const ctx = { content, lines: content.split("\n") };
+  const tables = findTablesRegex(ctx);
+  const entries = [];
+  for (const table of tables) {
+    const qualifiedName = `${table.schema}.${table.name}`;
+    if (seen?.has(qualifiedName)) continue;
+    seen?.add(qualifiedName);
+    entries.push(buildTableEntryRegex(table, content, filePath, opts));
+  }
+  return entries;
+}
+async function processTablesFromFile(filePath, opts, seen) {
+  const content = readFileSync(filePath, "utf-8");
+  if (await isAstParserAvailable()) {
+    const astTables = await extractTablesWithAst(content, filePath, opts);
+    if (astTables.length > 0) {
+      const entries = [];
+      for (const table of astTables) {
+        if (seen?.has(table.qualifiedName)) continue;
+        seen?.add(table.qualifiedName);
+        entries.push(table);
+      }
+      return entries;
+    }
+  }
+  return processTablesFromFileRegex(filePath, opts, seen);
+}
+async function extractTablesFromSqlDir(sqlDir, options = {}) {
+  if (!existsSync(sqlDir)) return [];
+  const opts = resolveOptions(options);
+  const seen = /* @__PURE__ */ new Set();
+  const tableEntries = [];
+  const files = collectSqlFiles(sqlDir).sort();
+  for (const file of files) {
+    const filePath = file;
+    const entries = await processTablesFromFile(filePath, opts, seen);
+    tableEntries.push(...entries);
+  }
+  return tableEntries;
+}
+
+// src/commands/db/utils/table-source-classifier.ts
+init_esm_shims();
+function splitQualifiedName(qualifiedName) {
+  const [schema = "", table = ""] = qualifiedName.split(".", 2);
+  return { schema, table };
+}
+function escapeRegexLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildTablePatternMatcher(patterns) {
+  const compiled = patterns.map((p) => p.trim()).filter((p) => p.length > 0).map((pattern) => {
+    const target = pattern.includes(".") ? "qualified" : "table";
+    const regex = new RegExp(`^${escapeRegexLiteral(pattern).replace(/\\\*/g, ".*")}$`);
+    return { target, regex };
+  });
+  return (qualifiedName) => {
+    const { table } = splitQualifiedName(qualifiedName);
+    for (const entry of compiled) {
+      const candidate = entry.target === "qualified" ? qualifiedName : table;
+      if (entry.regex.test(candidate)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function findIdempotentAncestor(table, partitionParentMap, idempotentManagedTables) {
+  if (idempotentManagedTables.has(table)) {
+    return table;
+  }
+  let current = table;
+  const visited = /* @__PURE__ */ new Set();
+  while (!visited.has(current)) {
+    visited.add(current);
+    const parent = partitionParentMap.get(current);
+    if (!parent) {
+      return null;
+    }
+    if (idempotentManagedTables.has(parent)) {
+      return parent;
+    }
+    current = parent;
+  }
+  return null;
+}
+function isSystemManagedTable(params) {
+  const { schema } = splitQualifiedName(params.qualifiedName);
+  return params.systemSchemas.has(schema) || params.knownSystemTables.has(params.qualifiedName);
+}
+function classifyIdempotentManagedTable(params) {
+  const idempotentAncestor = findIdempotentAncestor(
+    params.qualifiedName,
+    params.partitionParentMap,
+    params.idempotentManagedTables
+  );
+  if (!idempotentAncestor) {
+    return null;
+  }
+  return {
+    qualifiedName: params.qualifiedName,
+    detail: idempotentAncestor === params.qualifiedName ? "matched CREATE TABLE in idempotent SQL" : `partition child of ${idempotentAncestor}`
+  };
+}
+function classifyExtensionSystemOrAllowlistedTable(params) {
+  const extensionName = params.extensionManagedTables.get(params.qualifiedName);
+  if (extensionName) {
+    return {
+      qualifiedName: params.qualifiedName,
+      detail: `managed by extension "${extensionName}"`
+    };
+  }
+  if (isSystemManagedTable({
+    qualifiedName: params.qualifiedName,
+    systemSchemas: params.systemSchemas,
+    knownSystemTables: params.knownSystemTables
+  })) {
+    return {
+      qualifiedName: params.qualifiedName,
+      detail: "system-managed schema/table"
+    };
+  }
+  if (params.exclusionMatcher(params.qualifiedName)) {
+    return {
+      qualifiedName: params.qualifiedName,
+      detail: "allowlisted by database.pgSchemaDiff.excludeFromOrphanDetection"
+    };
+  }
+  return null;
+}
+function classifyMissingSourceTables(params) {
+  const extensionManagedTables = params.extensionManagedTables ?? /* @__PURE__ */ new Map();
+  const partitionParentMap = params.partitionParentMap ?? /* @__PURE__ */ new Map();
+  const exclusionMatcher = buildTablePatternMatcher(params.excludeFromOrphanDetection ?? []);
+  const systemSchemas = new Set(params.systemSchemas ?? []);
+  const knownSystemTables = new Set(params.knownSystemTables ?? []);
+  const classified = {
+    definedInIdempotentDynamicDdl: [],
+    extensionManagedOrSystemTable: [],
+    trulyOrphaned: []
+  };
+  for (const qualifiedName of params.tablesWithoutSource) {
+    const idempotentManagedItem = classifyIdempotentManagedTable({
+      qualifiedName,
+      partitionParentMap,
+      idempotentManagedTables: params.idempotentManagedTables
+    });
+    if (idempotentManagedItem) {
+      classified.definedInIdempotentDynamicDdl.push(idempotentManagedItem);
+      continue;
+    }
+    const extensionSystemOrAllowlistedItem = classifyExtensionSystemOrAllowlistedTable({
+      qualifiedName,
+      extensionManagedTables,
+      systemSchemas,
+      knownSystemTables,
+      exclusionMatcher
+    });
+    if (extensionSystemOrAllowlistedItem) {
+      classified.extensionManagedOrSystemTable.push(extensionSystemOrAllowlistedItem);
+      continue;
+    }
+    classified.trulyOrphaned.push(qualifiedName);
+  }
+  return classified;
+}
+
+// src/commands/db/utils/table-registry-introspection.ts
+init_esm_shims();
+var VALID_PG_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/;
+function validatePgIdentifier2(name, context) {
+  if (!name || typeof name !== "string") {
+    throw new Error(`Invalid ${context}: empty or not a string`);
+  }
+  if (!VALID_PG_IDENTIFIER.test(name)) {
+    throw new Error(
+      `Invalid ${context} "${name}": must start with letter/underscore and contain only alphanumeric/underscore characters`
+    );
+  }
+}
+function buildSafeSchemaInClause2(schemas) {
+  if (schemas.length === 0) {
+    throw new Error("No schemas provided for IN clause");
+  }
+  const safeSchemas = [];
+  for (const schema of schemas) {
+    validatePgIdentifier2(schema, "schema name");
+    safeSchemas.push(`'${schema.replace(/'/g, "''")}'`);
+  }
+  return safeSchemas.join(",");
+}
+async function introspectTablesFromDb(databaseUrl, schemas) {
+  try {
+    const result = await introspectDatabase(databaseUrl, { schemas });
+    return convertIntrospectionToTableEntries(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("ECONNREFUSED") || message.includes("connection refused")) {
+      throw new Error(
+        `[DB Introspection] Cannot connect to database.
+  URL: ${databaseUrl.replace(/:[^:@]+@/, ":***@")}
+  Cause: ${message}
+
+  Solutions:
+  1. Ensure database is running: runa check --fix
+  2. Check DATABASE_URL in .env.development`
+      );
+    }
+    if (message.includes("authentication") || message.includes("password")) {
+      throw new Error(
+        `[DB Introspection] Database authentication failed.
+  Cause: ${message}
+
+  Solutions:
+  1. Check DATABASE_URL credentials
+  2. Verify database user has SELECT on pg_catalog`
+      );
+    }
+    if (message.includes("permission") || message.includes("denied")) {
+      throw new Error(
+        `[DB Introspection] Permission denied.
+  Cause: ${message}
+
+  Solutions:
+  1. Ensure database user has SELECT on information_schema
+  2. Ensure database user has SELECT on pg_catalog`
+      );
+    }
+    throw new Error(
+      `[DB Introspection] Failed to introspect database.
+  Cause: ${message}
+
+  Solutions:
+  1. Run: runa check --verbose
+  2. Verify database is running and accessible`
+    );
+  }
+}
+function buildForeignKeyMap(foreignKeys) {
+  const fksByTable = /* @__PURE__ */ new Map();
+  for (const fk of foreignKeys) {
+    const key = `${fk.schemaName}.${fk.tableName}`;
+    if (!fksByTable.has(key)) fksByTable.set(key, []);
+    fksByTable.get(key)?.push({
+      column: fk.columnName,
+      referencesTable: `${fk.referencedSchema}.${fk.referencedTable}`,
+      referencesColumn: fk.referencedColumn,
+      onDelete: normalizeOnAction2(fk.onDelete),
+      onUpdate: normalizeOnAction2(fk.onUpdate)
+    });
+  }
+  return fksByTable;
+}
+function buildIndexMap(indexes) {
+  const indexesByTable = /* @__PURE__ */ new Map();
+  for (const idx of indexes) {
+    const key = `${idx.schemaName}.${idx.tableName}`;
+    if (!indexesByTable.has(key)) indexesByTable.set(key, []);
+    indexesByTable.get(key)?.push({
+      name: idx.indexName,
+      columns: idx.columns,
+      isUnique: idx.isUnique
+    });
+  }
+  return indexesByTable;
+}
+function buildRlsEnabledMap(rlsTables) {
+  const rlsByTable = /* @__PURE__ */ new Map();
+  for (const rls of rlsTables) {
+    rlsByTable.set(`${rls.schemaName}.${rls.tableName}`, rls.rlsEnabled);
+  }
+  return rlsByTable;
+}
+function buildRlsPoliciesMap(rlsPolicies) {
+  const rlsPoliciesByTable = /* @__PURE__ */ new Map();
+  for (const policy of rlsPolicies) {
+    const key = `${policy.schemaName}.${policy.tableName}`;
+    if (!rlsPoliciesByTable.has(key)) rlsPoliciesByTable.set(key, []);
+    rlsPoliciesByTable.get(key)?.push({
+      name: policy.policyName,
+      command: policy.command,
+      using: policy.usingExpr ?? void 0,
+      withCheck: policy.withCheckExpr ?? void 0
+    });
+  }
+  return rlsPoliciesByTable;
+}
+function buildCheckConstraintsMap(checkConstraints) {
+  const checksByTable = /* @__PURE__ */ new Map();
+  for (const check of checkConstraints) {
+    if (!check.name || !check.definition) {
+      console.warn(
+        `[DB Introspection] Skipping CHECK constraint with missing name or definition in ${check.schemaName}.${check.tableName}`
+      );
+      continue;
+    }
+    const key = `${check.schemaName}.${check.tableName}`;
+    if (!checksByTable.has(key)) checksByTable.set(key, []);
+    checksByTable.get(key)?.push({
+      name: check.name,
+      definition: check.definition,
+      columns: check.columns ?? []
+    });
+  }
+  return checksByTable;
+}
+function buildTriggersMap(triggers) {
+  const triggersByTable = /* @__PURE__ */ new Map();
+  for (const trigger of triggers) {
+    if (!trigger.actionStatement) {
+      console.warn(
+        `[DB Introspection] Skipping trigger ${trigger.triggerName} with missing actionStatement`
+      );
+      continue;
+    }
+    const key = `${trigger.schemaName}.${trigger.tableName}`;
+    if (!triggersByTable.has(key)) triggersByTable.set(key, []);
+    const functionMatch = trigger.actionStatement.match(
+      /EXECUTE\s+(?:FUNCTION|PROCEDURE)\s+([^\s(]+)/i
+    );
+    const functionName = functionMatch?.[1] ?? trigger.actionStatement;
+    triggersByTable.get(key)?.push({
+      name: trigger.triggerName,
+      event: trigger.eventManipulation,
+      timing: trigger.actionTiming,
+      function: functionName
+    });
+  }
+  return triggersByTable;
+}
+function buildPrimaryKeyMap(indexes) {
+  const pkByTable = /* @__PURE__ */ new Map();
+  for (const idx of indexes) {
+    if (idx.indexName.endsWith("_pkey")) {
+      const key = `${idx.schemaName}.${idx.tableName}`;
+      pkByTable.set(key, idx.columns);
+    }
+  }
+  return pkByTable;
+}
+function convertIntrospectionToTableEntries(result) {
+  const fksByTable = buildForeignKeyMap(result.foreignKeys);
+  const indexesByTable = buildIndexMap(result.indexes);
+  const rlsByTable = buildRlsEnabledMap(result.rlsTables);
+  const rlsPoliciesByTable = buildRlsPoliciesMap(result.rlsPolicies);
+  const checksByTable = buildCheckConstraintsMap(result.checkConstraints);
+  const triggersByTable = buildTriggersMap(result.triggers);
+  const pkByTable = buildPrimaryKeyMap(result.indexes);
+  return result.tables.map((table) => {
+    const qualifiedName = `${table.schema}.${table.name}`;
+    const primaryKeyColumns = pkByTable.get(qualifiedName) ?? [];
+    const columns = table.columns.map((col) => ({
+      name: col.name,
+      type: col.type,
+      notNull: !col.nullable,
+      hasDefault: col.default !== null && col.default !== void 0,
+      isPrimaryKey: primaryKeyColumns.includes(col.name)
+    }));
+    return {
+      schema: table.schema,
+      name: table.name,
+      qualifiedName,
+      semanticName: "",
+      // Will be set by semantic mapper
+      sourceFile: "",
+      // Will be set by SQL file mapping
+      columns,
+      primaryKey: pkByTable.get(qualifiedName) ?? table.primaryKey,
+      foreignKeys: fksByTable.get(qualifiedName) ?? [],
+      indexes: indexesByTable.get(qualifiedName) ?? [],
+      hasRls: rlsByTable.get(qualifiedName) ?? false,
+      rlsPolicies: rlsPoliciesByTable.get(qualifiedName) ?? [],
+      checkConstraints: checksByTable.get(qualifiedName) ?? [],
+      triggers: triggersByTable.get(qualifiedName) ?? []
+    };
+  });
+}
+function normalizeOnAction2(action) {
+  if (!action) return void 0;
+  const upper = action.toUpperCase().replace(/\s+/g, " ").trim();
+  switch (upper) {
+    case "CASCADE":
+      return "CASCADE";
+    case "SET NULL":
+      return "SET NULL";
+    case "SET DEFAULT":
+      return "SET DEFAULT";
+    case "RESTRICT":
+      return "RESTRICT";
+    case "NO ACTION":
+      return "NO ACTION";
+    default:
+      return void 0;
+  }
+}
+function shouldSkipDrizzleExport(exportName) {
+  return exportName.endsWith("Schema") || exportName.endsWith("Enum") || exportName.endsWith("Relations");
+}
+function extractDrizzleTableNames(schemaModule) {
+  const drizzleTables = /* @__PURE__ */ new Set();
+  for (const [exportName, exportValue] of Object.entries(schemaModule)) {
+    if (shouldSkipDrizzleExport(exportName)) continue;
+    const maybeTable = exportValue;
+    if (maybeTable?._?.name) {
+      const fullName = maybeTable._.schema ? `${maybeTable._.schema}.${maybeTable._.name}` : maybeTable._.name;
+      drizzleTables.add(fullName);
+    }
+  }
+  return drizzleTables;
+}
+function compareTables(sqlTables, drizzleTables) {
+  const matched = [];
+  const sqlOnly = [];
+  const sqlFullNames = new Set(sqlTables.map((t) => t.qualifiedName));
+  for (const table of sqlTables) {
+    if (drizzleTables.has(table.qualifiedName)) {
+      matched.push(table);
+    } else {
+      sqlOnly.push(table);
+    }
+  }
+  const drizzleOnly = [...drizzleTables].filter((name) => !sqlFullNames.has(name));
+  return { matched, sqlOnly, drizzleOnly };
+}
+async function crossCheckWithDrizzle(sqlTables, drizzleSchemaPath) {
+  if (!existsSync(drizzleSchemaPath)) {
+    return { matched: [], sqlOnly: sqlTables, drizzleOnly: [] };
+  }
+  try {
+    const schemaModule = await import(drizzleSchemaPath);
+    const drizzleTables = extractDrizzleTableNames(schemaModule);
+    return compareTables(sqlTables, drizzleTables);
+  } catch {
+    return { matched: [], sqlOnly: sqlTables, drizzleOnly: [] };
+  }
+}
+
+// src/commands/db/utils/table-registry.ts
+var MANIFEST_VERSION = 2;
+var GENERATOR_VERSION = "1.0.0";
+var DEFAULT_IDEMPOTENT_SQL_DIR = "supabase/schemas/idempotent";
+var KNOWN_EXTENSION_SYSTEM_TABLES = /* @__PURE__ */ new Set([
+  "public.spatial_ref_sys",
+  "public.geometry_columns",
+  "public.geography_columns"
+]);
+var SUPABASE_SYSTEM_SCHEMA_SET = new Set(SUPABASE_SYSTEM_SCHEMAS);
+function toRelativeSourcePath(projectRoot, sourceFile) {
+  let relativeSource = relative(projectRoot, sourceFile);
+  if (relativeSource.startsWith("/") || relativeSource.startsWith("..")) {
+    const schemaMatch = sourceFile.match(/supabase\/schemas\/[^/]+\/[^/]+$/);
+    relativeSource = schemaMatch ? schemaMatch[0] : sourceFile;
+  }
+  return relativeSource;
+}
+function resolveSourceConfig(projectRoot, options) {
+  let idempotentSqlDir = options.idempotentSqlDir ?? DEFAULT_IDEMPOTENT_SQL_DIR;
+  const exclusions = new Set(options.excludeFromOrphanDetection ?? []);
+  try {
+    const config = loadRunaConfig(projectRoot);
+    const pgSchemaDiff = config.database?.pgSchemaDiff;
+    if (!options.idempotentSqlDir && pgSchemaDiff?.idempotentSqlDir) {
+      idempotentSqlDir = pgSchemaDiff.idempotentSqlDir;
+    }
+    if (pgSchemaDiff?.excludeFromOrphanDetection) {
+      for (const pattern of pgSchemaDiff.excludeFromOrphanDetection) {
+        exclusions.add(pattern);
+      }
+    }
+  } catch {
+  }
+  return {
+    idempotentSqlDir: isAbsolute(idempotentSqlDir) ? idempotentSqlDir : join(projectRoot, idempotentSqlDir),
+    excludeFromOrphanDetection: [...exclusions].sort((a, b) => a.localeCompare(b))
+  };
+}
+async function fetchMissingSourceMetadata(params) {
+  const { databaseUrl, schemas } = params;
+  if (schemas.length === 0) {
+    return {
+      extensionManagedTables: /* @__PURE__ */ new Map(),
+      partitionParentMap: /* @__PURE__ */ new Map()
+    };
+  }
+  const isRemoteSupabase = databaseUrl.includes(".supabase.co");
+  const sql = postgres2(databaseUrl, {
+    ...isRemoteSupabase && { ssl: "require" }
+  });
+  try {
+    const schemaList = buildSafeSchemaInClause2(schemas);
+    const [extensionRows, partitionRows] = await Promise.all([
+      sql`
+        SELECT
+          n.nspname AS schema_name,
+          c.relname AS table_name,
+          ext.extname AS extension_name
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        JOIN pg_depend d
+          ON d.classid = 'pg_class'::regclass
+          AND d.objid = c.oid
+          AND d.refclassid = 'pg_extension'::regclass
+          AND d.deptype = 'e'
+        JOIN pg_extension ext ON ext.oid = d.refobjid
+        WHERE c.relkind IN ('r', 'p')
+          AND n.nspname IN (${sql.unsafe(schemaList)})
+      `,
+      sql`
+        SELECT
+          child_ns.nspname AS child_schema,
+          child.relname AS child_table,
+          parent_ns.nspname AS parent_schema,
+          parent.relname AS parent_table
+        FROM pg_inherits i
+        JOIN pg_class child ON child.oid = i.inhrelid
+        JOIN pg_namespace child_ns ON child_ns.oid = child.relnamespace
+        JOIN pg_class parent ON parent.oid = i.inhparent
+        JOIN pg_namespace parent_ns ON parent_ns.oid = parent.relnamespace
+        WHERE child.relkind IN ('r', 'p')
+          AND child_ns.nspname IN (${sql.unsafe(schemaList)})
+      `
+    ]);
+    const extensionManagedTables = /* @__PURE__ */ new Map();
+    for (const row of extensionRows) {
+      extensionManagedTables.set(
+        `${String(row.schema_name)}.${String(row.table_name)}`,
+        String(row.extension_name)
+      );
+    }
+    const partitionParentMap = /* @__PURE__ */ new Map();
+    for (const row of partitionRows) {
+      partitionParentMap.set(
+        `${String(row.child_schema)}.${String(row.child_table)}`,
+        `${String(row.parent_schema)}.${String(row.parent_table)}`
+      );
+    }
+    return { extensionManagedTables, partitionParentMap };
+  } finally {
+    await sql.end();
+  }
+}
+function formatMissingSourceItems(items) {
+  return items.map((item) => item.detail ? `${item.qualifiedName} (${item.detail})` : item.qualifiedName).join(", ");
+}
+function logMissingSourceClassification(classification) {
+  const total = classification.definedInIdempotentDynamicDdl.length + classification.extensionManagedOrSystemTable.length + classification.trulyOrphaned.length;
+  if (total === 0) return;
+  console.warn(`[tables-manifest] \u26A0 ${total} table(s) exist in DB but not in SQL files.`);
+  if (classification.definedInIdempotentDynamicDdl.length > 0) {
+    console.log(
+      `[tables-manifest] info: defined_in_idempotent_dynamic_ddl (${classification.definedInIdempotentDynamicDdl.length})`
+    );
+    console.log(`  ${formatMissingSourceItems(classification.definedInIdempotentDynamicDdl)}`);
+  }
+  if (classification.extensionManagedOrSystemTable.length > 0) {
+    console.log(
+      `[tables-manifest] info: extension_managed/system_table (${classification.extensionManagedOrSystemTable.length})`
+    );
+    console.log(`  ${formatMissingSourceItems(classification.extensionManagedOrSystemTable)}`);
+  }
+  if (classification.trulyOrphaned.length > 0) {
+    console.warn(`[tables-manifest] warn: truly_orphaned (${classification.trulyOrphaned.length})`);
+    console.warn(`  ${classification.trulyOrphaned.join(", ")}`);
+    console.warn(
+      "  \u2192 Add declarative/idempotent SQL definitions or allowlist via database.pgSchemaDiff.excludeFromOrphanDetection."
+    );
+  } else {
+    console.log("[tables-manifest] info: no truly_orphaned tables detected.");
+  }
+}
+async function logDrizzleCrossCheck(tables, drizzleSchemaPath) {
+  const result = await crossCheckWithDrizzle(tables, drizzleSchemaPath);
+  if (result.sqlOnly.length === 0 && result.drizzleOnly.length === 0) return;
+  console.warn("[tables-manifest] SQL\u2194Drizzle discrepancies found:");
+  if (result.sqlOnly.length > 0) {
+    console.warn("  SQL only:", result.sqlOnly.map((t) => t.qualifiedName).join(", "));
+  }
+  if (result.drizzleOnly.length > 0) {
+    console.warn("  Drizzle only:", result.drizzleOnly.join(", "));
+  }
+}
+function logMappingConflicts(conflicts) {
+  if (conflicts.length === 0) return;
+  console.warn("[tables-manifest] Semantic name conflicts detected:");
+  for (const conflict of conflicts) {
+    console.warn(`  '${conflict.semanticName}': ${conflict.tables.join(", ")}`);
+  }
+}
+async function generateTablesManifest(projectRoot, options = {}) {
+  const {
+    sqlDir = join(projectRoot, "supabase/schemas/declarative"),
+    drizzleSchemaPath = join(projectRoot, "packages/database/src/schema/index.js"),
+    outputPath = join(projectRoot, ".runa/manifests/tables.json"),
+    crossCheck = true,
+    databaseUrl,
+    mappingOptions = { conflictStrategy: "prefix" },
+    // includeMetadata is defined in options but not yet used
+    // Reserved for future metadata filtering feature
+    includeMetadata: _includeMetadata = true
+  } = options;
+  const sourceConfig = resolveSourceConfig(projectRoot, options);
+  let tables = [];
+  const source = "introspection";
+  const declarativeTables = await extractTablesFromSqlDir(sqlDir, {
+    includeColumns: false,
+    // Don't need columns from SQL (DB introspection is more accurate)
+    includeForeignKeys: false,
+    includeIndexes: false,
+    includeRlsPolicies: false
+  });
+  const idempotentTablesForSource = await extractTablesFromSqlDir(sourceConfig.idempotentSqlDir, {
+    includeColumns: false,
+    includeForeignKeys: false,
+    includeIndexes: false,
+    includeRlsPolicies: false
+  });
+  const idempotentTablesFromRegex = extractTablesFromIdempotentSql(
+    sourceConfig.idempotentSqlDir,
+    projectRoot
+  );
+  const idempotentManagedTables = /* @__PURE__ */ new Set([
+    ...idempotentTablesFromRegex,
+    ...idempotentTablesForSource.map((t) => t.qualifiedName)
+  ]);
+  const sourceFileMap = /* @__PURE__ */ new Map();
+  const sourceTables = [...declarativeTables, ...idempotentTablesForSource];
+  for (const t of sourceTables) {
+    if (sourceFileMap.has(t.qualifiedName)) {
+      continue;
+    }
+    sourceFileMap.set(t.qualifiedName, {
+      sourceFile: toRelativeSourcePath(projectRoot, t.sourceFile),
+      lineNumber: t.lineNumber
+    });
+  }
+  if (!databaseUrl) {
+    throw new Error(
+      "[tables-manifest] databaseUrl is required.\nDB introspection is the primary source for accurate table metadata.\nEnsure database is running and DATABASE_URL is set.\nRun: runa db sync (which starts the database automatically)"
+    );
+  }
+  console.log("[tables-manifest] Using DB introspection (PostgreSQL system catalogs)...");
+  tables = await introspectTablesFromDb(databaseUrl);
+  tables = tables.map((t) => {
+    const fileInfo = sourceFileMap.get(t.qualifiedName);
+    return {
+      ...t,
+      sourceFile: fileInfo?.sourceFile ?? "",
+      lineNumber: fileInfo?.lineNumber
+    };
+  });
+  console.log(`[tables-manifest] \u2713 Introspected ${tables.length} tables from database`);
+  const tablesWithoutSource = tables.filter((t) => !t.sourceFile);
+  if (tablesWithoutSource.length > 0) {
+    const missingSourceQualifiedNames = tablesWithoutSource.map((t) => t.qualifiedName);
+    const missingSchemas = [...new Set(tablesWithoutSource.map((t) => t.schema))];
+    let extensionManagedTables = /* @__PURE__ */ new Map();
+    let partitionParentMap = /* @__PURE__ */ new Map();
+    try {
+      const metadata = await fetchMissingSourceMetadata({
+        databaseUrl,
+        schemas: missingSchemas
+      });
+      extensionManagedTables = metadata.extensionManagedTables;
+      partitionParentMap = metadata.partitionParentMap;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[tables-manifest] Failed to classify extension/partition metadata: ${message}`);
+    }
+    const classification = classifyMissingSourceTables({
+      tablesWithoutSource: missingSourceQualifiedNames,
+      idempotentManagedTables,
+      extensionManagedTables,
+      partitionParentMap,
+      excludeFromOrphanDetection: sourceConfig.excludeFromOrphanDetection,
+      systemSchemas: SUPABASE_SYSTEM_SCHEMA_SET,
+      knownSystemTables: KNOWN_EXTENSION_SYSTEM_TABLES
+    });
+    logMissingSourceClassification(classification);
+  }
+  if (crossCheck && existsSync(drizzleSchemaPath)) {
+    await logDrizzleCrossCheck(tables, drizzleSchemaPath);
+  }
+  const mappingResult = generateMapping(tables, mappingOptions);
+  logMappingConflicts(mappingResult.conflicts);
+  tables = applyMappingToTables(tables, mappingResult.mapping);
+  const now = /* @__PURE__ */ new Date();
+  const jstOffset = 9 * 60 * 60 * 1e3;
+  const jst = new Date(now.getTime() + jstOffset);
+  const generatedAtJST = `${jst.getUTCFullYear()}-${String(jst.getUTCMonth() + 1).padStart(2, "0")}-${String(jst.getUTCDate()).padStart(2, "0")}T${String(jst.getUTCHours()).padStart(2, "0")}:${String(jst.getUTCMinutes()).padStart(2, "0")}:${String(jst.getUTCSeconds()).padStart(2, "0")}+09:00`;
+  const manifest = {
+    version: MANIFEST_VERSION,
+    source,
+    generatedAt: generatedAtJST,
+    generatorVersion: GENERATOR_VERSION,
+    tables,
+    mapping: mappingResult.mapping
+  };
+  const outputDir = join(outputPath, "..");
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  writeFileSync(outputPath, `${JSON.stringify(manifest, null, 2)}
+`);
+  logManifestSummary(manifest, mappingResult.conflicts);
+  return manifest;
+}
+function logManifestSummary(manifest, conflicts) {
+  const tableCount = manifest.tables.length;
+  const schemas = [...new Set(manifest.tables.map((t) => t.schema))];
+  const mappingCount = Object.keys(manifest.mapping).length;
+  const checkCount = manifest.tables.reduce(
+    (sum, t) => sum + (t.checkConstraints?.length ?? 0),
+    0
+  );
+  const triggerCount = manifest.tables.reduce(
+    (sum, t) => sum + (t.triggers?.length ?? 0),
+    0
+  );
+  console.log("\n\u2713 Tables manifest generated");
+  console.log(`  - Source: DB introspection (PostgreSQL system catalogs)`);
+  console.log(`  - ${tableCount} tables extracted`);
+  console.log(`  - ${schemas.length} schemas: ${schemas.join(", ")}`);
+  console.log(`  - ${mappingCount} semantic names mapped`);
+  if (checkCount > 0) {
+    console.log(`  - ${checkCount} CHECK constraints detected`);
+  }
+  if (triggerCount > 0) {
+    console.log(`  - ${triggerCount} triggers detected`);
+  }
+  const mappingEntries = Object.entries(manifest.mapping).slice(0, 5);
+  if (mappingEntries.length > 0) {
+    console.log(`  - Mappings: ${mappingEntries.map(([k, v]) => `${k}\u2192${v}`).join(", ")}`);
+    if (Object.keys(manifest.mapping).length > 5) {
+      console.log(`    ... and ${Object.keys(manifest.mapping).length - 5} more`);
+    }
+  }
+  const warnings = [];
+  if (conflicts.length > 0) {
+    for (const conflict of conflicts) {
+      warnings.push(`Naming conflict '${conflict.semanticName}': ${conflict.tables.join(", ")}`);
+    }
+  }
+  const expectedTables = ["clients", "projects", "repositories", "workflows", "deployments"];
+  const missingTables = expectedTables.filter((name) => !manifest.mapping[name]);
+  if (missingTables.length > 0) {
+    warnings.push(
+      `Optional SDK tables not found: ${missingTables.join(", ")}
+     (This is OK if your schema uses different names)`
+    );
+  }
+  if (warnings.length > 0) {
+    console.log("\n\u26A0\uFE0F  Warnings:");
+    for (const warning of warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+  console.log("\n\u{1F4A1} Tip: SDK will auto-load this manifest. No additional setup required.");
+  console.log("   Path: .runa/manifests/tables.json\n");
+}
+
+export { diffSchema, extractSchemaTablesAndEnums, extractTablesFromIdempotentSql, fetchDbTablesAndEnums, generateTablesManifest, removeEnvLocalBridge, writeEnvLocalBridge };