@runa-ai/runa-cli 0.8.0 → 0.9.0

package/dist/chunk-ZWDWFMOX.js

@@ -0,0 +1,1514 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { blankDollarQuotedBodies, stripSqlComments, psqlSyncQuery, parsePostgresUrl, buildPsqlArgs, buildPsqlEnv } from './chunk-A6A7JIRD.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import path from 'path';
+import { execFileSync, spawnSync, spawn } from 'child_process';
+import { createCLILogger } from '@runa-ai/runa';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+
+createRequire(import.meta.url);
+
+// src/commands/db/apply/helpers/pg-schema-diff-helpers.ts
+init_esm_shims();
+
+// src/commands/db/utils/declarative-dependency-contract.ts
+init_esm_shims();
+
+// src/commands/db/utils/declarative-dependency-collectors.ts
+init_esm_shims();
+
+// src/commands/db/utils/declarative-dependency-sql-utils.ts
+init_esm_shims();
+
+// src/commands/db/utils/sql-filename-parser.ts
+init_esm_shims();
+var SQL_FILENAME_PATTERN = /^(\d{2,3})_([a-z][a-z0-9_]*)\.sql$/;
+function parseSqlFilename(filename) {
+  const match = filename.match(SQL_FILENAME_PATTERN);
+  if (!match) return null;
+  const prefixStr = match[1];
+  const domain = match[2];
+  if (!prefixStr || !domain) return null;
+  return {
+    prefix: Number.parseInt(prefixStr, 10),
+    domain,
+    raw: filename
+  };
+}
+
+// src/commands/db/utils/declarative-dependency-sql-utils.ts
+var FUNCTION_DEFINITION_RE = /^\s*CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+(?:(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_]*))\s*\.\s*)?(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_]*))/i;
+var QUALIFIED_FUNCTION_CALL_RE = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\.\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+var EXECUTE_FUNCTION_RE = /\bEXECUTE\s+FUNCTION\s+([A-Za-z_][A-Za-z0-9_]*)\s*\.\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+var UNQUALIFIED_FUNCTION_CALL_RE = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+var DEFAULT_UNQUALIFIED_CALL_RE = /\bDEFAULT\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+var CHECK_UNQUALIFIED_CALL_RE = /\bCHECK\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+var DYNAMIC_SQL_EXECUTE_RE = /\bEXECUTE\b/g;
+var STATIC_EXECUTE_LITERAL_RE = /\bEXECUTE\s+('(?:[^']|'')*')/gi;
+var DOLLAR_TAG_RE = /\$([A-Za-z_][A-Za-z0-9_]*)?\$/g;
+var PUBLIC_SCHEMA = "public";
+function countNewlines(text) {
+  let count = 0;
+  for (const char of text) {
+    if (char === "\n") count += 1;
+  }
+  return count;
+}
+function toRelative(targetDir, filePath) {
+  return path.relative(targetDir, filePath).replaceAll(path.sep, "/");
+}
+function collectSqlFiles(targetDir, layer, relativeDir) {
+  const directory = relativeDir ? path.isAbsolute(relativeDir) ? relativeDir : path.join(targetDir, relativeDir) : path.join(targetDir, "supabase", "schemas", layer);
+  if (!existsSync(directory)) {
+    return [];
+  }
+  return readdirSync(directory).filter((file) => file.endsWith(".sql")).sort((a, b) => a.localeCompare(b)).map((file) => {
+    const absolutePath = path.join(directory, file);
+    return {
+      absolutePath,
+      relativePath: toRelative(targetDir, absolutePath),
+      content: readFileSync(absolutePath, "utf-8")
+    };
+  });
+}
+function blankQuotedStrings(content) {
+  let result = "";
+  let index = 0;
+  while (index < content.length) {
+    const current = content[index] ?? "";
+    const next = content[index + 1] ?? "";
+    if ((current === "E" || current === "e") && next === "'") {
+      result += "  ";
+      index += 2;
+      while (index < content.length) {
+        const inner = content[index] ?? "";
+        const innerNext = content[index + 1] ?? "";
+        if (inner === "\\" && index + 1 < content.length) {
+          result += "  ";
+          index += 2;
+          continue;
+        }
+        if (inner === "'" && innerNext === "'") {
+          result += "  ";
+          index += 2;
+          continue;
+        }
+        result += inner === "\n" ? "\n" : " ";
+        index += 1;
+        if (inner === "'") break;
+      }
+      continue;
+    }
+    if (current === "'") {
+      result += " ";
+      index += 1;
+      while (index < content.length) {
+        const inner = content[index] ?? "";
+        const innerNext = content[index + 1] ?? "";
+        if (inner === "'" && innerNext === "'") {
+          result += "  ";
+          index += 2;
+          continue;
+        }
+        result += inner === "\n" ? "\n" : " ";
+        index += 1;
+        if (inner === "'") break;
+      }
+      continue;
+    }
+    if (current === '"') {
+      result += " ";
+      index += 1;
+      while (index < content.length) {
+        const inner = content[index] ?? "";
+        const innerNext = content[index + 1] ?? "";
+        if (inner === '"' && innerNext === '"') {
+          result += "  ";
+          index += 2;
+          continue;
+        }
+        result += inner === "\n" ? "\n" : " ";
+        index += 1;
+        if (inner === '"') break;
+      }
+      continue;
+    }
+    result += current;
+    index += 1;
+  }
+  return result;
+}
+function sanitizeTopLevelSql(statement) {
+  return blankQuotedStrings(blankDollarQuotedBodies(stripSqlComments(statement)));
+}
+function sanitizeExecutableCode(content) {
+  return blankQuotedStrings(blankDollarQuotedBodies(stripSqlComments(content)));
+}
+function sanitizeExecutableCodePreserveStrings(content) {
+  return blankDollarQuotedBodies(stripSqlComments(content));
+}
+function extractManagedSchemas(files) {
+  const schemas = /* @__PURE__ */ new Set([PUBLIC_SCHEMA]);
+  for (const file of files) {
+    const filename = path.basename(file.relativePath);
+    const parsed = parseSqlFilename(filename);
+    if (parsed) {
+      schemas.add(parsed.domain);
+    }
+  }
+  return schemas;
+}
+function extractDefinitionFromStatement(statement, file, line, layer) {
+  const match = statement.match(FUNCTION_DEFINITION_RE);
+  if (!match) return null;
+  const schema = (match[1] ?? match[2] ?? PUBLIC_SCHEMA).toLowerCase();
+  const name = (match[3] ?? match[4] ?? "").toLowerCase();
+  if (!name) return null;
+  return {
+    qualifiedName: `${schema}.${name}`,
+    schema,
+    name,
+    file,
+    line,
+    layer
+  };
+}
+function extractFirstDollarBody(statement, baseLine) {
+  DOLLAR_TAG_RE.lastIndex = 0;
+  const opening = DOLLAR_TAG_RE.exec(statement);
+  if (!opening || opening.index === void 0) {
+    return null;
+  }
+  const delimiter = opening[0];
+  const bodyStart = opening.index + delimiter.length;
+  const closingIndex = statement.indexOf(delimiter, bodyStart);
+  if (closingIndex < 0) {
+    return null;
+  }
+  return {
+    body: statement.slice(bodyStart, closingIndex),
+    startLine: baseLine + countNewlines(statement.slice(0, bodyStart))
+  };
+}
+function shouldIgnoreQualifiedFunctionCall(prefix) {
+  const compactPrefix = prefix.replace(/\s+/g, " ").trim().toUpperCase();
+  return [
+    /\bON FUNCTION$/i,
+    /\bCREATE FUNCTION$/i,
+    /\bCREATE OR REPLACE FUNCTION$/i,
+    /\bALTER FUNCTION$/i,
+    /\bDROP FUNCTION$/i,
+    /\bCOMMENT ON FUNCTION$/i,
+    /\bCREATE TABLE(?: IF NOT EXISTS)?$/i,
+    /\bALTER TABLE$/i,
+    /\bINSERT INTO$/i,
+    /\bUPDATE$/i,
+    /\bDELETE FROM$/i,
+    /\bFROM$/i,
+    /\bJOIN$/i,
+    /\bREFERENCES$/i,
+    /\bTABLE$/i,
+    /\bON$/i
+  ].some((pattern) => pattern.test(compactPrefix));
+}
+function decodeSqlStringLiteral(literal) {
+  if (!literal.startsWith("'") || !literal.endsWith("'") || literal.length < 2) {
+    return null;
+  }
+  return literal.slice(1, -1).replaceAll("''", "'");
+}
+
+// src/commands/db/utils/declarative-dependency-collectors.ts
+var WARNING_CODE_LEVELS = {
+  UNQUALIFIED_CUSTOM_FUNCTION_CALL: "medium",
+  DYNAMIC_SQL_EXECUTE: "high"
+};
+function collectReferencesFromCode(params) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sanitized = params.code;
+  const pattern = params.pattern ?? QUALIFIED_FUNCTION_CALL_RE;
+  pattern.lastIndex = 0;
+  for (const match of sanitized.matchAll(pattern)) {
+    const schema = match[1]?.toLowerCase();
+    const name = match[2]?.toLowerCase();
+    const index = match.index ?? 0;
+    if (!schema || !name) continue;
+    const prefix = sanitized.slice(Math.max(0, index - 80), index);
+    if (shouldIgnoreQualifiedFunctionCall(prefix)) continue;
+    const line = params.baseLine + countNewlines(sanitized.slice(0, index));
+    const qualifiedName = `${schema}.${name}`;
+    const dedupeKey = `${params.file}:${line}:${qualifiedName}:${params.source}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    references.push({
+      qualifiedName,
+      schema,
+      name,
+      file: params.file,
+      line,
+      source: params.source
+    });
+  }
+  return references;
+}
+function collectStaticExecuteLiterals(params) {
+  const literals = [];
+  STATIC_EXECUTE_LITERAL_RE.lastIndex = 0;
+  for (const match of params.code.matchAll(STATIC_EXECUTE_LITERAL_RE)) {
+    const quotedSql = match[1];
+    const index = match.index ?? 0;
+    if (!quotedSql) continue;
+    const suffix = params.code.slice(index + match[0].length);
+    const nextToken = suffix.match(/^\s*([A-Za-z_]+|\|\|)/)?.[1]?.toUpperCase();
+    if (nextToken === "||") {
+      continue;
+    }
+    const decodedSql = decodeSqlStringLiteral(quotedSql);
+    if (!decodedSql) continue;
+    literals.push({
+      index,
+      line: params.baseLine + countNewlines(params.code.slice(0, index)),
+      decodedSql
+    });
+  }
+  return literals;
+}
+function collectReferencesFromStaticExecuteLiterals(params) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const literal of collectStaticExecuteLiterals({
+    code: params.code,
+    baseLine: params.baseLine
+  })) {
+    for (const reference of collectReferencesFromCode({
+      code: literal.decodedSql,
+      file: params.file,
+      baseLine: literal.line,
+      source: params.source
+    })) {
+      const dedupeKey = `${reference.file}:${reference.line}:${reference.qualifiedName}:${reference.source}`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      references.push(reference);
+    }
+  }
+  return references;
+}
+function collectReferencesForStatement(statement, file, line) {
+  const sanitizedTopLevel = sanitizeTopLevelSql(statement);
+  const trimmed = statement.trimStart().toUpperCase();
+  const references = collectReferencesFromCode({
+    code: sanitizedTopLevel,
+    file,
+    baseLine: line,
+    source: "statement"
+  });
+  if (/\bEXECUTE\s+FUNCTION\b/i.test(sanitizedTopLevel)) {
+    references.push(
+      ...collectReferencesFromCode({
+        code: sanitizedTopLevel,
+        file,
+        baseLine: line,
+        source: "statement",
+        pattern: EXECUTE_FUNCTION_RE
+      })
+    );
+  }
+  const uniqueTopLevelReferences = references.filter((reference, index, list) => {
+    return list.findIndex(
+      (candidate) => candidate.file === reference.file && candidate.line === reference.line && candidate.qualifiedName === reference.qualifiedName && candidate.source === reference.source
+    ) === index;
+  });
+  const definition = extractDefinitionFromStatement(statement, file, line, "declarative");
+  const filteredTopLevel = definition ? uniqueTopLevelReferences.filter(
+    (reference) => reference.qualifiedName !== definition.qualifiedName
+  ) : uniqueTopLevelReferences;
+  const body = extractFirstDollarBody(statement, line);
+  if (!body) {
+    return filteredTopLevel;
+  }
+  const source = trimmed.startsWith("DO ") || trimmed.startsWith("DO$$") ? "do-body" : "function-body";
+  const rawExecutableBody = sanitizeExecutableCodePreserveStrings(body.body);
+  const bodyReferences = collectReferencesFromCode({
+    code: sanitizeExecutableCode(body.body),
+    file,
+    baseLine: body.startLine,
+    source
+  });
+  const staticExecuteReferences = collectReferencesFromStaticExecuteLiterals({
+    code: rawExecutableBody,
+    file,
+    baseLine: body.startLine,
+    source
+  });
+  return [...filteredTopLevel, ...bodyReferences, ...staticExecuteReferences];
+}
+function collectCustomFunctionNames(definitions) {
+  return new Set(definitions.map((definition) => definition.name));
+}
+function collectWarningsFromCode(params) {
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const patterns = params.patterns ?? [UNQUALIFIED_FUNCTION_CALL_RE];
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    for (const match of params.code.matchAll(pattern)) {
+      const name = match[1]?.toLowerCase();
+      const index = match.index ?? 0;
+      if (!name || !params.knownFunctionNames.has(name)) continue;
+      const previousChar = params.code[Math.max(0, index - 1)] ?? "";
+      if (previousChar === ".") continue;
+      const line = params.baseLine + countNewlines(params.code.slice(0, index));
+      const dedupeKey = `${params.file}:${line}:${name}:${params.source}:unqualified`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      warnings.push({
+        code: "UNQUALIFIED_CUSTOM_FUNCTION_CALL",
+        level: WARNING_CODE_LEVELS.UNQUALIFIED_CUSTOM_FUNCTION_CALL,
+        file: params.file,
+        line,
+        source: params.source,
+        message: `Declarative SQL uses custom function via unqualified call: ${name}(...)`,
+        suggestion: "Schema-qualify custom helper calls so declarative dependency resolution does not depend on search_path."
+      });
+    }
+  }
+  return warnings;
+}
+function collectDynamicSqlWarnings(params) {
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  DYNAMIC_SQL_EXECUTE_RE.lastIndex = 0;
+  for (const match of params.code.matchAll(DYNAMIC_SQL_EXECUTE_RE)) {
+    const index = match.index ?? 0;
+    const line = params.baseLine + countNewlines(params.code.slice(0, index));
+    if (params.resolvedExecuteIndexes?.has(index)) continue;
+    const dedupeKey = `${params.file}:${line}:${params.source}:execute`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    warnings.push({
+      code: "DYNAMIC_SQL_EXECUTE",
+      level: WARNING_CODE_LEVELS.DYNAMIC_SQL_EXECUTE,
+      file: params.file,
+      line,
+      source: params.source,
+      message: "Declarative SQL uses dynamic SQL via EXECUTE; dependency closure cannot be proven statically.",
+      suggestion: "Prefer schema-qualified static SQL when possible, or manually review EXECUTE blocks for declarative-only dependency closure."
+    });
+  }
+  return warnings;
+}
+function collectWarningsForStatement(statement, file, line, knownFunctionNames) {
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const sanitizedTopLevel = sanitizeTopLevelSql(statement);
+  const trimmed = statement.trimStart().toUpperCase();
+  for (const warning of collectWarningsFromCode({
+    code: sanitizedTopLevel,
+    file,
+    baseLine: line,
+    source: "statement",
+    knownFunctionNames,
+    patterns: [DEFAULT_UNQUALIFIED_CALL_RE, CHECK_UNQUALIFIED_CALL_RE]
+  })) {
+    const key = `${warning.file}:${warning.line}:${warning.code}:${warning.source}:${warning.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    warnings.push(warning);
+  }
+  const body = extractFirstDollarBody(statement, line);
+  if (!body) {
+    return warnings;
+  }
+  const source = trimmed.startsWith("DO ") || trimmed.startsWith("DO$$") ? "do-body" : "function-body";
+  const rawExecutableBody = sanitizeExecutableCodePreserveStrings(body.body);
+  const sanitizedBody = sanitizeExecutableCode(body.body);
+  const staticExecuteLiterals = collectStaticExecuteLiterals({
+    code: rawExecutableBody,
+    baseLine: body.startLine
+  });
+  const resolvedExecuteIndexes = new Set(staticExecuteLiterals.map((literal) => literal.index));
+  for (const warning of collectWarningsFromCode({
+    code: sanitizedBody,
+    file,
+    baseLine: body.startLine,
+    source,
+    knownFunctionNames
+  })) {
+    const key = `${warning.file}:${warning.line}:${warning.code}:${warning.source}:${warning.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    warnings.push(warning);
+  }
+  for (const literal of staticExecuteLiterals) {
+    for (const warning of collectWarningsFromCode({
+      code: literal.decodedSql,
+      file,
+      baseLine: literal.line,
+      source,
+      knownFunctionNames
+    })) {
+      const key = `${warning.file}:${warning.line}:${warning.code}:${warning.source}:${warning.message}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      warnings.push(warning);
+    }
+  }
+  for (const warning of collectDynamicSqlWarnings({
+    code: rawExecutableBody,
+    file,
+    baseLine: body.startLine,
+    source,
+    resolvedExecuteIndexes
+  })) {
+    const key = `${warning.file}:${warning.line}:${warning.code}:${warning.source}:${warning.message}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    warnings.push(warning);
+  }
+  return warnings;
+}
+
+// src/commands/db/utils/sql-boundary-parser.ts
+init_esm_shims();
+var DOLLAR_QUOTE_PATTERN = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/;
+function countNewlines2(text) {
+  let count = 0;
+  for (const char of text) {
+    if (char === "\n") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function appendToCurrent(state, text) {
+  if (!text) return;
+  if (state.atStatementStart) {
+    state.atStatementStart = false;
+    state.statementStartLine = state.currentLine;
+  }
+  state.current += text;
+  state.currentLine += countNewlines2(text);
+}
+function finalizeCurrentStatement(state) {
+  const statement = state.current.trim();
+  if (statement.length > 0) {
+    state.statements.push({ statement, line: state.statementStartLine });
+  }
+  state.current = "";
+  state.atStatementStart = true;
+  state.statementStartLine = state.currentLine;
+}
+function trySkipLeadingWhitespace(content, state) {
+  if (!state.atStatementStart) return false;
+  let skipped = false;
+  while (state.index < content.length) {
+    const char = content[state.index] ?? "";
+    if (!char || !/\s/.test(char)) break;
+    if (char === "\n") {
+      state.currentLine += 1;
+    }
+    state.index += 1;
+    skipped = true;
+  }
+  return skipped;
+}
+function trySkipLeadingLineComment(content, state) {
+  if (!state.atStatementStart) return false;
+  if (content[state.index] !== "-" || content[state.index + 1] !== "-") return false;
+  state.index += 2;
+  while (state.index < content.length) {
+    const char = content[state.index] ?? "";
+    state.index += 1;
+    if (char === "\n") {
+      state.currentLine += 1;
+      break;
+    }
+  }
+  return true;
+}
+function trySkipLeadingBlockComment(content, state) {
+  if (!state.atStatementStart) return false;
+  if (content[state.index] !== "/" || content[state.index + 1] !== "*") return false;
+  state.index += 2;
+  while (state.index + 1 < content.length && !(content[state.index] === "*" && content[state.index + 1] === "/")) {
+    if (content[state.index] === "\n") {
+      state.currentLine += 1;
+    }
+    state.index += 1;
+  }
+  if (state.index + 1 < content.length) {
+    state.index += 2;
+  }
+  return true;
+}
+function tryStartInlineLineComment(content, state) {
+  if (content[state.index] !== "-" || content[state.index + 1] !== "-") return false;
+  appendToCurrent(state, "--");
+  state.mode = "lineComment";
+  state.index += 2;
+  return true;
+}
+function tryStartInlineBlockComment(content, state) {
+  if (content[state.index] !== "/" || content[state.index + 1] !== "*") return false;
+  appendToCurrent(state, "/*");
+  state.mode = "blockComment";
+  state.index += 2;
+  return true;
+}
+function parseDollarDelimiterAt(content, index) {
+  const match = content.slice(index).match(DOLLAR_QUOTE_PATTERN);
+  return match ? match[0] : null;
+}
+function tryStartDollarQuote(content, state) {
+  const delimiter = parseDollarDelimiterAt(content, state.index);
+  if (!delimiter) return false;
+  appendToCurrent(state, delimiter);
+  state.mode = "dollarQuote";
+  state.dollarDelimiter = delimiter;
+  state.index += delimiter.length;
+  return true;
+}
+function tryStartSingleQuote(content, state) {
+  if (content[state.index] !== "'") return false;
+  appendToCurrent(state, "'");
+  state.mode = "singleQuote";
+  state.index += 1;
+  return true;
+}
+function tryStartDoubleQuote(content, state) {
+  if (content[state.index] !== '"') return false;
+  appendToCurrent(state, '"');
+  state.mode = "doubleQuote";
+  state.index += 1;
+  return true;
+}
+function tryTerminateStatement(content, state) {
+  if (content[state.index] !== ";") return false;
+  finalizeCurrentStatement(state);
+  state.index += 1;
+  return true;
+}
+function consumeLineComment(content, state) {
+  const char = content[state.index] ?? "";
+  appendToCurrent(state, char);
+  state.index += 1;
+  if (char === "\n") {
+    state.mode = "normal";
+  }
+}
+function consumeBlockComment(content, state) {
+  const char = content[state.index] ?? "";
+  const next = content[state.index + 1] ?? "";
+  if (char === "*" && next === "/") {
+    appendToCurrent(state, "*/");
+    state.index += 2;
+    state.mode = "normal";
+    return;
+  }
+  appendToCurrent(state, char);
+  state.index += 1;
+}
+function consumeSingleQuote(content, state) {
+  const char = content[state.index] ?? "";
+  const next = content[state.index + 1] ?? "";
+  if (char === "'" && next === "'") {
+    appendToCurrent(state, "''");
+    state.index += 2;
+    return;
+  }
+  appendToCurrent(state, char);
+  state.index += 1;
+  if (char === "'") {
+    state.mode = "normal";
+  }
+}
+function consumeDoubleQuote(content, state) {
+  const char = content[state.index] ?? "";
+  const next = content[state.index + 1] ?? "";
+  if (char === '"' && next === '"') {
+    appendToCurrent(state, '""');
+    state.index += 2;
+    return;
+  }
+  appendToCurrent(state, char);
+  state.index += 1;
+  if (char === '"') {
+    state.mode = "normal";
+  }
+}
+function consumeDollarQuote(content, state) {
+  if (state.dollarDelimiter && content.startsWith(state.dollarDelimiter, state.index)) {
+    appendToCurrent(state, state.dollarDelimiter);
+    state.index += state.dollarDelimiter.length;
+    state.dollarDelimiter = "";
+    state.mode = "normal";
+    return;
+  }
+  const char = content[state.index] ?? "";
+  appendToCurrent(state, char);
+  state.index += 1;
+}
+function consumeCurrentMode(content, state) {
+  if (state.mode === "lineComment") {
+    consumeLineComment(content, state);
+    return true;
+  }
+  if (state.mode === "blockComment") {
+    consumeBlockComment(content, state);
+    return true;
+  }
+  if (state.mode === "singleQuote") {
+    consumeSingleQuote(content, state);
+    return true;
+  }
+  if (state.mode === "doubleQuote") {
+    consumeDoubleQuote(content, state);
+    return true;
+  }
+  if (state.mode === "dollarQuote") {
+    consumeDollarQuote(content, state);
+    return true;
+  }
+  return false;
+}
+var SPLIT_STEPS = [
+  consumeCurrentMode,
+  trySkipLeadingWhitespace,
+  trySkipLeadingLineComment,
+  trySkipLeadingBlockComment,
+  tryStartInlineLineComment,
+  tryStartInlineBlockComment,
+  tryStartDollarQuote,
+  tryStartSingleQuote,
+  tryStartDoubleQuote,
+  tryTerminateStatement
+];
+function runSplitStep(content, state) {
+  for (const step of SPLIT_STEPS) {
+    if (step(content, state)) {
+      return true;
+    }
+  }
+  return false;
+}
+function splitSqlStatements(content) {
+  const state = {
+    statements: [],
+    current: "",
+    mode: "normal",
+    dollarDelimiter: "",
+    index: 0,
+    currentLine: 1,
+    statementStartLine: 1,
+    atStatementStart: true
+  };
+  while (state.index < content.length) {
+    if (runSplitStep(content, state)) continue;
+    appendToCurrent(state, content[state.index] ?? "");
+    state.index += 1;
+  }
+  finalizeCurrentStatement(state);
+  return state.statements;
+}
+var KNOWN_DDL_COMMANDS = /* @__PURE__ */ new Set(["CREATE", "ALTER", "DROP", "RENAME", "TRUNCATE", "COMMENT"]);
+var CREATE_NOISE_KEYWORDS = /* @__PURE__ */ new Set([
+  "OR",
+  "REPLACE",
+  "IF",
+  "NOT",
+  "EXISTS",
+  "GLOBAL",
+  "TEMP",
+  "TEMPORARY",
+  "UNLOGGED",
+  "UNIQUE",
+  "CONCURRENTLY",
+  "RECURSIVE"
+]);
+var ALTER_DROP_NOISE_KEYWORDS = /* @__PURE__ */ new Set([
+  "COLUMN",
+  "IF",
+  "NOT",
+  "EXISTS",
+  "ONLY",
+  "CONCURRENTLY"
+]);
+var MULTI_TOKEN_DDL_OBJECT_PATTERNS = [
+  { tokens: ["MATERIALIZED", "VIEW"], object: "MATERIALIZED_VIEW" },
+  { tokens: ["FOREIGN", "TABLE"], object: "FOREIGN_TABLE" },
+  { tokens: ["FOREIGN", "DATA", "WRAPPER"], object: "FOREIGN_DATA_WRAPPER" },
+  { tokens: ["USER", "MAPPING"], object: "USER_MAPPING" },
+  { tokens: ["TEXT", "SEARCH", "CONFIGURATION"], object: "TEXT_SEARCH_CONFIGURATION" },
+  { tokens: ["TEXT", "SEARCH", "DICTIONARY"], object: "TEXT_SEARCH_DICTIONARY" },
+  { tokens: ["TEXT", "SEARCH", "PARSER"], object: "TEXT_SEARCH_PARSER" },
+  { tokens: ["TEXT", "SEARCH", "TEMPLATE"], object: "TEXT_SEARCH_TEMPLATE" },
+  { tokens: ["DEFAULT", "PRIVILEGES"], object: "DEFAULT_PRIVILEGES" },
+  { tokens: ["OPERATOR", "CLASS"], object: "OPERATOR_CLASS" },
+  { tokens: ["OPERATOR", "FAMILY"], object: "OPERATOR_FAMILY" },
+  { tokens: ["ACCESS", "METHOD"], object: "ACCESS_METHOD" },
+  { tokens: ["EVENT", "TRIGGER"], object: "EVENT_TRIGGER" }
+];
+var COMMENT_NOISE_KEYWORDS = /* @__PURE__ */ new Set(["ON"]);
+var NON_DDL_MAINTENANCE_PATTERNS = [
+  /^\s*(?:ANALYZE|VACUUM|REINDEX|CLUSTER)\b/i,
+  /^\s*REFRESH\s+MATERIALIZED\s+VIEW\b/i
+];
+var NON_SCHEMA_OPERATION_PATTERNS = [
+  /^\s*DO\b/i,
+  /^\s*ALTER\s+DEFAULT\s+PRIVILEGES\b/i,
+  /^\s*EXECUTE\b/i,
+  /^\s*(?:INSERT|UPDATE|DELETE|COPY|MERGE|TRUNCATE|VACUUM|ANALYZE|REINDEX|CLUSTER)\b/i,
+  /^\s*REFRESH\s+MATERIALIZED\s+VIEW\b/i
+];
+function isNonDdlMaintenanceStatement(statement) {
+  return NON_DDL_MAINTENANCE_PATTERNS.some((pattern) => pattern.test(statement));
+}
+function isNonSchemaOperation(statement) {
+  return NON_SCHEMA_OPERATION_PATTERNS.some((pattern) => pattern.test(statement));
+}
+function getTokenAt(tokens, index, offset = 0) {
+  return tokens[index + offset] ?? "";
+}
+function advancePastNoiseKeywords(tokens, startIndex, noiseKeywords) {
+  let index = Math.max(1, startIndex);
+  while (index < tokens.length && noiseKeywords.has(tokens[index])) {
+    index += 1;
+  }
+  return index;
+}
+function matchMultiTokenDdlObject(tokens, startIndex) {
+  for (const pattern of MULTI_TOKEN_DDL_OBJECT_PATTERNS) {
+    if (pattern.tokens.length > 0 && pattern.tokens.every((value, offset) => getTokenAt(tokens, startIndex, offset) === value)) {
+      return pattern.object;
+    }
+  }
+  if (getTokenAt(tokens, startIndex) === "TEXT" && getTokenAt(tokens, startIndex + 1) === "SEARCH") {
+    return "TEXT_SEARCH";
+  }
+  return null;
+}
+function tokenizeForPlacementCheck(statement) {
+  return statement.replace(/\s+/g, " ").trim().split(" ").map((token) => token.toUpperCase()).filter((token) => token.length > 0);
+}
+function sanitizeObjectToken(token) {
+  return token.replace(/^[^A-Z0-9_]+|[^A-Z0-9_]+$/g, "");
+}
+function extractDdlObject(statement) {
+  const tokens = tokenizeForPlacementCheck(statement);
+  if (tokens.length < 2) return null;
+  const command = tokens[0];
+  if (!command || !KNOWN_DDL_COMMANDS.has(command)) return null;
+  let index = 1;
+  const token = (offset = 0) => getTokenAt(tokens, index, offset);
+  const resolveCommandObject = () => {
+    const object = matchMultiTokenDdlObject(tokens, index);
+    if (object) return object;
+    const next = token();
+    if (!next) return null;
+    return sanitizeObjectToken(next) || null;
+  };
+  if (command === "CREATE") {
+    index = advancePastNoiseKeywords(tokens, index, CREATE_NOISE_KEYWORDS);
+    return resolveCommandObject();
+  }
+  if (command === "ALTER" || command === "DROP" || command === "TRUNCATE" || command === "RENAME") {
+    index = advancePastNoiseKeywords(tokens, index, ALTER_DROP_NOISE_KEYWORDS);
+    return resolveCommandObject();
+  }
+  if (command === "COMMENT") {
+    index = advancePastNoiseKeywords(tokens, index, COMMENT_NOISE_KEYWORDS);
+    return resolveCommandObject();
+  }
+  return null;
+}
+function isPartitionOfCreateTable(statement) {
+  return /\bCREATE\s+TABLE\b.*\bPARTITION\s+OF\b/i.test(statement);
+}
+function shouldReviewUnknownDeclarativeDdl(statement, declarativePreferredObjects, idempotentPreferredObjects) {
+  const object = extractDdlObject(statement);
+  if (!object) return null;
+  if (declarativePreferredObjects.has(object)) return null;
+  if (idempotentPreferredObjects.has(object)) return object;
+  return object;
+}
+function shouldReviewUnknownIdempotentDdl(statement, idempotentPreferredObjects, declarativePreferredObjects) {
+  const object = extractDdlObject(statement);
+  if (!object) return null;
+  if (idempotentPreferredObjects.has(object)) return null;
+  if (declarativePreferredObjects.has(object)) return object;
+  if (object === "TABLE" && isPartitionOfCreateTable(statement)) return null;
+  return object;
+}
+
+// src/commands/db/utils/declarative-dependency-contract.ts
+var DECLARATIVE_CONTRACT_NOTE = "Declarative desired-state build ignores idempotent-only helpers from supabase/schemas/idempotent/*.sql.";
+var DB_APPLY_CHECK_MODE_CONTRACT_NOTE = "Check mode ignores idempotent-only helpers when building declarative desired state.";
+var MAX_DETAILED_DECLARATIVE_WARNINGS = 10;
+var WARNING_CODE_LABELS = {
+  UNQUALIFIED_CUSTOM_FUNCTION_CALL: "Unqualified custom helper call",
+  DYNAMIC_SQL_EXECUTE: "Dynamic SQL via EXECUTE"
+};
+function collectDefinitions(files, layer) {
+  const definitions = [];
+  for (const file of files) {
+    const statements = splitSqlStatements(file.content);
+    for (const statement of statements) {
+      const definition = extractDefinitionFromStatement(
+        statement.statement,
+        file.relativePath,
+        statement.line,
+        layer
+      );
+      if (definition) {
+        definitions.push(definition);
+      }
+    }
+  }
+  return definitions;
+}
+function collectDeclarativeReferences(files) {
+  const references = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const statements = splitSqlStatements(file.content);
+    for (const statement of statements) {
+      for (const reference of collectReferencesForStatement(
+        statement.statement,
+        file.relativePath,
+        statement.line
+      )) {
+        const key = `${reference.file}:${reference.line}:${reference.qualifiedName}:${reference.source}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        references.push(reference);
+      }
+    }
+  }
+  return references;
+}
+function collectDeclarativeWarnings(files, knownFunctionNames) {
+  const warnings = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const statements = splitSqlStatements(file.content);
+    for (const statement of statements) {
+      for (const warning of collectWarningsForStatement(
+        statement.statement,
+        file.relativePath,
+        statement.line,
+        knownFunctionNames
+      )) {
+        const key = `${warning.file}:${warning.line}:${warning.code}:${warning.source}:${warning.message}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        warnings.push(warning);
+      }
+    }
+  }
+  return warnings;
+}
+function buildDefinitionMap(definitions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    map.set(definition.qualifiedName, definition);
+  }
+  return map;
+}
+function buildViolations(params) {
+  const violations = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const reference of params.references) {
+    const declarativeDefinition = params.declarativeDefinitions.get(reference.qualifiedName);
+    if (declarativeDefinition) continue;
+    const idempotentDefinition = params.idempotentDefinitions.get(reference.qualifiedName);
+    if (idempotentDefinition) {
+      const key2 = `${reference.file}:${reference.line}:${reference.qualifiedName}:idempotent`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      violations.push({
+        code: "DECLARATIVE_IDEMPOTENT_ONLY_FUNCTION",
+        file: reference.file,
+        line: reference.line,
+        qualifiedName: reference.qualifiedName,
+        source: reference.source,
+        message: `Declarative SQL references function defined only in idempotent SQL: ${reference.qualifiedName}`,
+        suggestion: "Move the helper into declarative SQL or stop calling it from declarative desired-state SQL.",
+        definedIn: {
+          file: idempotentDefinition.file,
+          line: idempotentDefinition.line,
+          layer: idempotentDefinition.layer
+        }
+      });
+      continue;
+    }
+    if (!params.managedSchemas.has(reference.schema)) continue;
+    const key = `${reference.file}:${reference.line}:${reference.qualifiedName}:managed`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (reference.schema === PUBLIC_SCHEMA) {
+      violations.push({
+        code: "DECLARATIVE_PUBLIC_UNKNOWN_FUNCTION",
+        file: reference.file,
+        line: reference.line,
+        qualifiedName: reference.qualifiedName,
+        source: reference.source,
+        message: `Declarative SQL references public function not defined in declarative SQL: ${reference.qualifiedName}`,
+        suggestion: "Define the helper in declarative SQL or use an unqualified built-in/extension function if this is not schema-owned."
+      });
+      continue;
+    }
+    violations.push({
+      code: "DECLARATIVE_UNKNOWN_MANAGED_FUNCTION",
+      file: reference.file,
+      line: reference.line,
+      qualifiedName: reference.qualifiedName,
+      source: reference.source,
+      message: `Declarative SQL references managed-schema function not defined in declarative SQL: ${reference.qualifiedName}`,
+      suggestion: "Define the function in declarative SQL before referencing it from schema-owned desired-state SQL."
+    });
+  }
+  return violations;
+}
+function analyzeDeclarativeDependencyContract(targetDir = process.cwd()) {
+  const declarativeFiles = collectSqlFiles(targetDir, "declarative");
+  const idempotentFiles = collectSqlFiles(targetDir, "idempotent");
+  const managedSchemas = extractManagedSchemas(declarativeFiles);
+  const declarativeDefinitions = collectDefinitions(declarativeFiles, "declarative");
+  const idempotentDefinitions = collectDefinitions(idempotentFiles, "idempotent");
+  const knownFunctionNames = collectCustomFunctionNames([
+    ...declarativeDefinitions,
+    ...idempotentDefinitions
+  ]);
+  const references = collectDeclarativeReferences(declarativeFiles);
+  const warnings = collectDeclarativeWarnings(declarativeFiles, knownFunctionNames);
+  const violations = buildViolations({
+    references,
+    declarativeDefinitions: buildDefinitionMap(declarativeDefinitions),
+    idempotentDefinitions: buildDefinitionMap(idempotentDefinitions),
+    managedSchemas
+  });
+  return {
+    contractNote: DECLARATIVE_CONTRACT_NOTE,
+    managedSchemas: [...managedSchemas].sort((a, b) => a.localeCompare(b)),
+    violations,
+    warnings,
+    references,
+    definitions: {
+      declarative: declarativeDefinitions,
+      idempotent: idempotentDefinitions
+    }
+  };
+}
+function formatDeclarativeDependencyViolation(violation) {
+  return {
+    summary: `${violation.file}:${violation.line} - ${violation.message}`,
+    callee: `callee: ${violation.qualifiedName}`,
+    definedIn: violation.definedIn ? `defined in ${violation.definedIn.layer}: ${violation.definedIn.file}:${violation.definedIn.line}` : void 0,
+    suggestion: `suggestion: ${violation.suggestion}`
+  };
+}
+function formatDeclarativeDependencyWarning(warning) {
+  return {
+    summary: `${warning.file}:${warning.line} - [${warning.level}] ${warning.message}`,
+    suggestion: `suggestion: ${warning.suggestion}`
+  };
+}
+function summarizeDeclarativeDependencyWarnings(warnings) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const warning of warnings) {
+    counts.set(warning.code, (counts.get(warning.code) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([code, count]) => ({
+    code,
+    count,
+    label: WARNING_CODE_LABELS[code]
+  })).sort((left, right) => right.count - left.count || left.code.localeCompare(right.code));
+}
+
+// src/commands/db/apply/helpers/pg-schema-diff-patterns.ts
+init_esm_shims();
+var STATEMENT_IDX_REGEX = /^-- Statement (?:Idx\.|Index|#)\s*(\d+)/;
+var HAZARD_REGEX = /^-- (?:Hazard|Warning|Risk)\s+([\w-]+):\s*(.+)/;
+var EXTENSION_TYPE_MAP = {
+  geometry: "postgis",
+  geography: "postgis",
+  box2d: "postgis",
+  box3d: "postgis",
+  raster: "postgis_raster",
+  vector: "vector",
+  halfvec: "vector",
+  sparsevec: "vector",
+  cube: "cube",
+  citext: "citext",
+  hstore: "hstore",
+  ltree: "ltree"
+};
+var HAZARD_HINT_KEYWORDS = ["hazard", "warning", "dangerous", "destructive"];
+function hasUnparsedHazardHints(stderr) {
+  const lower = stderr.toLowerCase();
+  return HAZARD_HINT_KEYWORDS.some((kw) => lower.includes(kw));
+}
+
+// src/commands/db/apply/helpers/pg-schema-diff-version.ts
+init_esm_shims();
+var logger = createCLILogger("db:apply:version");
+var SUPPORTED_PG_SCHEMA_DIFF_VERSIONS = {
+  minMajor: 0,
+  minMinor: 9,
+  maxMajor: 1,
+  maxMinor: 0
+};
+function parseVersion(raw) {
+  const match = raw.trim().match(/v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    raw: raw.trim(),
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function isVersionSupported(version) {
+  const { minMajor, minMinor, maxMajor, maxMinor } = SUPPORTED_PG_SCHEMA_DIFF_VERSIONS;
+  if (version.major < minMajor || version.major > maxMajor) return false;
+  if (version.major === minMajor && version.minor < minMinor) return false;
+  if (version.major === maxMajor && version.minor > maxMinor) return false;
+  return true;
+}
+function detectPgSchemaDiffVersion(binaryPath) {
+  try {
+    const output = execFileSync(binaryPath, ["version"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    const parsed = parseVersion(output);
+    if (parsed) return parsed;
+  } catch {
+  }
+  try {
+    const output = execFileSync(binaryPath, ["--version"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    return parseVersion(output);
+  } catch {
+    return null;
+  }
+}
+function getSupportedRangeLabel() {
+  const { minMajor, minMinor, maxMajor, maxMinor } = SUPPORTED_PG_SCHEMA_DIFF_VERSIONS;
+  return `${minMajor}.${minMinor}.x \u2013 ${maxMajor}.${maxMinor}.x`;
+}
+function verifyPgSchemaDiffVersion(binaryPath, options = {}) {
+  const strict = options.strict === true;
+  const version = detectPgSchemaDiffVersion(binaryPath);
+  if (!version) {
+    const message = `Could not detect pg-schema-diff version (--version failed). Expected tested range: ${getSupportedRangeLabel()}.`;
+    if (strict) {
+      throw new Error(`${message} Aborting in strict mode.`);
+    }
+    logger.debug(message);
+    return;
+  }
+  if (!isVersionSupported(version)) {
+    const message = `pg-schema-diff version ${version.raw} is outside tested range ${getSupportedRangeLabel()}. Plan parsing or hazard detection may behave unexpectedly.`;
+    if (strict) {
+      throw new Error(`${message} Aborting in strict mode.`);
+    }
+    logger.warn(message);
+  } else {
+    logger.debug(`pg-schema-diff version ${version.raw} (compatible)`);
+  }
+}
+
+// src/commands/db/apply/helpers/pg-schema-diff-helpers.ts
+var logger2 = createCLILogger("db:apply");
+var STALE_IDLE_CONNECTION_MIN_AGE_SECONDS = 30;
+function verifyPgSchemaDiffBinary(options = {}) {
+  const whichResult = spawnSync("which", ["pg-schema-diff"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (whichResult.status !== 0) {
+    logger2.error("pg-schema-diff not found in PATH");
+    logger2.error(`PATH: ${process.env.PATH?.split(":").slice(0, 10).join(":") || "undefined"}...`);
+    throw new Error(
+      "pg-schema-diff binary not found in PATH. Check that setup-pg-schema-diff action completed successfully."
+    );
+  }
+  const binaryPath = (whichResult.stdout || "").trim();
+  logger2.step(`pg-schema-diff found: ${binaryPath}`);
+  verifyPgSchemaDiffVersion(binaryPath, { strict: options.strictVersion === true });
+}
+function isTransientStartupError(errorOutput) {
+  return errorOutput.includes("the database system is starting up") || errorOutput.includes("the database system is shutting down") || errorOutput.includes("could not connect to server") || errorOutput.includes("Connection refused") || errorOutput.includes("server closed the connection unexpectedly");
+}
+function isTransientConnectionError(errorOutput) {
+  return errorOutput.includes("terminating connection due to administrator command") || errorOutput.includes("SQLSTATE 57P01") || errorOutput.includes("server closed the connection unexpectedly") || errorOutput.includes("SSL connection has been closed unexpectedly") || errorOutput.includes("connection to server was lost");
+}
+var DB_READINESS_MAX_RETRIES = 5;
+var DB_READINESS_BASE_DELAY_MS = 1e3;
+var DB_READINESS_MAX_DELAY_MS = 8e3;
+async function verifyDatabaseConnection(dbUrl, options) {
+  const maxRetries = options?.maxRetries ?? DB_READINESS_MAX_RETRIES;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const connTestResult = psqlSyncQuery({
+      databaseUrl: dbUrl,
+      sql: "SELECT 1",
+      timeout: 3e4
+    });
+    if (connTestResult.status === 0) {
+      if (attempt > 0) {
+        logger2.step(`Database connection verified (after ${attempt} retries)`);
+      } else {
+        logger2.step("Database connection verified");
+      }
+      return;
+    }
+    const stderr = connTestResult.stderr || connTestResult.stdout || "";
+    if (!isTransientStartupError(stderr) || attempt === maxRetries) {
+      logger2.error("Database connection test failed");
+      logger2.error(`Exit code: ${connTestResult.status}`);
+      logger2.error(`Stderr: ${stderr || "(empty)"}`);
+      throw new Error(`Database connection failed: ${stderr || "(no output)"}`);
+    }
+    const delay = Math.min(
+      DB_READINESS_BASE_DELAY_MS * 2 ** attempt + Math.random() * 500,
+      DB_READINESS_MAX_DELAY_MS
+    );
+    logger2.warn(
+      `Database not ready (attempt ${attempt + 1}/${DB_READINESS_MAX_RETRIES}), retrying in ${Math.round(delay)}ms...`
+    );
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
+}
+var TYPE_TO_EXTENSION = EXTENSION_TYPE_MAP;
+function detectMissingExtensionType(errorOutput) {
+  const typePattern = /type ["']?(\w+)["']? does not exist/gi;
+  const matches = [...errorOutput.matchAll(typePattern)];
+  const missingTypes = [...new Set(matches.map((m) => m[1].toLowerCase()))];
+  if (missingTypes.length === 0) {
+    return { detected: false, missingTypes: [], suggestedExtensions: [] };
+  }
+  const extensions = /* @__PURE__ */ new Set();
+  for (const type of missingTypes) {
+    const ext = TYPE_TO_EXTENSION[type];
+    if (ext) extensions.add(ext);
+  }
+  return {
+    detected: true,
+    missingTypes,
+    suggestedExtensions: [...extensions]
+  };
+}
+function formatExtensionErrorHint(detection) {
+  if (!detection.detected) return "";
+  const lines = [];
+  lines.push("");
+  lines.push("Missing extension type(s) detected:");
+  for (const type of detection.missingTypes) {
+    const ext = TYPE_TO_EXTENSION[type];
+    lines.push(`  type "${type}" \u2192 extension: ${ext ?? "unknown"}`);
+  }
+  if (detection.suggestedExtensions.length > 0) {
+    lines.push("");
+    lines.push("Fix 1: Add to supabase/schemas/idempotent/00_extensions.sql:");
+    for (const ext of detection.suggestedExtensions) {
+      lines.push(`  CREATE EXTENSION IF NOT EXISTS ${ext};`);
+    }
+    const extList = detection.suggestedExtensions.map((e) => `'${e}'`).join(", ");
+    lines.push("");
+    lines.push("Fix 2: Configure shadow DB in runa.config.ts:");
+    lines.push(`  database: { pgSchemaDiff: { shadowDbExtensions: [${extList}] } }`);
+  }
+  return lines.join("\n");
+}
+function detectPartitionPrivilegeError(errorOutput) {
+  const pattern = /privileges on partitions:?\s*not implemented/i;
+  const match = errorOutput.match(pattern);
+  return {
+    detected: !!match,
+    errorFragment: match ? match[0] : ""
+  };
+}
+function formatPartitionPrivilegeHint(detection) {
+  if (!detection.detected) return "";
+  const lines = [];
+  lines.push("");
+  lines.push("Partition privilege error detected:");
+  lines.push(`  pg-schema-diff rejected: "${detection.errorFragment}"`);
+  lines.push("");
+  lines.push("Cause: Non-owner GRANTs exist on partition child tables in the database.");
+  lines.push("pg-schema-diff v1.0.5 does not support privilege diffs on partitions.");
+  lines.push("");
+  lines.push("Fix options:");
+  lines.push("  1. Update runa CLI: npm install -g @runa-ai/runa-cli@latest");
+  lines.push("     (Auto-cleans partition ACLs before pg-schema-diff)");
+  lines.push("  2. Manual: Revoke non-owner privileges from partition children:");
+  lines.push("     REVOKE ALL ON <partition_child> FROM <role>;");
+  lines.push("  3. Define partitions ONLY in idempotent/*.sql (not declarative/*.sql)");
+  return lines.join("\n");
+}
+function detectMissingQualifiedFunction(errorOutput) {
+  const patterns = [
+    /function\s+"?([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\([^"\n]*\)"?\s+does not exist/i,
+    /function\s+([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\([^)\n]*\)\s+does not exist/i
+  ];
+  for (const pattern of patterns) {
+    const match = errorOutput.match(pattern);
+    const schema = match?.[1]?.toLowerCase();
+    const name = match?.[2]?.toLowerCase();
+    if (!schema || !name) continue;
+    return {
+      detected: true,
+      qualifiedName: `${schema}.${name}`,
+      signature: `${schema}.${name}(...)`
+    };
+  }
+  return { detected: false };
+}
+function buildBoundaryHintTargetDir(schemasDir, targetDir) {
+  if (targetDir) {
+    return targetDir;
+  }
+  const normalizedSchemasDir = path.normalize(schemasDir);
+  const declarativeSuffix = path.normalize(path.join("supabase", "schemas", "declarative"));
+  if (normalizedSchemasDir.endsWith(declarativeSuffix)) {
+    return path.resolve(schemasDir, "..", "..", "..");
+  }
+  return null;
+}
+function formatDeclarativeDependencyBoundaryHint(errorOutput, schemasDir, targetDir) {
+  const detection = detectMissingQualifiedFunction(errorOutput);
+  if (!detection.detected || !detection.qualifiedName) {
+    return "";
+  }
+  const resolvedTargetDir = buildBoundaryHintTargetDir(schemasDir, targetDir);
+  if (!resolvedTargetDir) {
+    return "";
+  }
+  const analysis = analyzeDeclarativeDependencyContract(resolvedTargetDir);
+  const matchingViolations = analysis.violations.filter(
+    (violation) => violation.qualifiedName === detection.qualifiedName
+  );
+  if (matchingViolations.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("");
+  lines.push("Declarative dependency boundary hint:");
+  lines.push(
+    `  pg-schema-diff could not resolve ${detection.signature ?? detection.qualifiedName} while building declarative desired state.`
+  );
+  for (const violation of matchingViolations.slice(0, 3)) {
+    const formatted = formatDeclarativeDependencyViolation(violation);
+    lines.push(`  ${formatted.summary}`);
+    lines.push(`  ${formatted.callee}`);
+    if (formatted.definedIn) {
+      lines.push(`  ${formatted.definedIn}`);
+    }
+    lines.push(`  ${formatted.suggestion}`);
+  }
+  if (matchingViolations.length > 3) {
+    lines.push(`  ...and ${matchingViolations.length - 3} more caller(s).`);
+  }
+  return lines.join("\n");
+}
+function detectDropTableStatements(planOutput) {
+  const tables = [];
+  for (const line of planOutput.split("\n")) {
+    const match = line.trim().match(/^DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?(?:"([^"]+)"|(\w+))\.(?:"([^"]+)"|(\w+))/i);
+    if (match) {
+      tables.push(`${match[1] ?? match[2]}.${match[3] ?? match[4]}`);
+    }
+  }
+  return tables;
+}
+function freeConnectionSlotsForPgSchemaDiff(dbUrl, verbose) {
+  try {
+    const result = psqlSyncQuery({
+      databaseUrl: dbUrl,
+      sql: buildIdleConnectionCleanupSql(),
+      timeout: 1e4
+    });
+    if (result.status === 0 && verbose) {
+      const lines = (result.stdout || "").split("\n").filter((l) => l.trim() === "t");
+      logger2.debug(`Freed ${lines.length} idle connection(s) for pg-schema-diff`);
+    }
+  } catch {
+    logger2.warn("Could not free connection slots (non-fatal, pg-schema-diff may still succeed)");
+  }
+}
+var CLEANUP_INTERVAL_SECONDS = 5;
+var CLEANUP_DURATION_SECONDS = 330;
+function buildIdleConnectionCleanupSql() {
+  return `SELECT pg_terminate_backend(pid)
+FROM pg_stat_activity
+WHERE pid <> pg_backend_pid()
+  AND state = 'idle'
+  AND backend_type = 'client backend'
+  AND COALESCE(application_name, '') <> '${PG_SCHEMA_DIFF_APP_NAME}'
+  AND state_change < now() - interval '${STALE_IDLE_CONNECTION_MIN_AGE_SECONDS} seconds'`;
+}
+function startConnectionCleanupDaemon(dbUrl, verbose) {
+  try {
+    const conn = parsePostgresUrl(dbUrl);
+    const args = buildPsqlArgs(conn, { onErrorStop: false });
+    const rounds = Math.ceil(CLEANUP_DURATION_SECONDS / CLEANUP_INTERVAL_SECONDS);
+    const terminateSql = buildIdleConnectionCleanupSql().replace(/'/g, "''");
+    const sql = `DO $$ BEGIN FOR i IN 1..${rounds} LOOP PERFORM * FROM (${terminateSql}) AS terminated; PERFORM pg_sleep(${CLEANUP_INTERVAL_SECONDS}); END LOOP; END $$;`;
+    const child = spawn("psql", [...args, "-t", "-c", sql], {
+      stdio: "ignore",
+      env: buildPsqlEnv(conn),
+      detached: true
+    });
+    child.unref();
+    if (verbose) {
+      logger2.debug(
+        `Connection cleanup daemon started (pid=${child.pid}, interval=${CLEANUP_INTERVAL_SECONDS}s)`
+      );
+    }
+    return child;
+  } catch {
+    logger2.warn("Could not start connection cleanup daemon (non-fatal)");
+    return null;
+  }
+}
+function stopConnectionCleanupDaemon(child, verbose) {
+  if (!child) return;
+  try {
+    child.kill("SIGTERM");
+    if (verbose) {
+      logger2.debug("Connection cleanup daemon stopped");
+    }
+  } catch {
+  }
+}
+var PG_SCHEMA_DIFF_PLAN_TIMEOUT_MS = 3e5;
+var PG_SCHEMA_DIFF_APPLY_TIMEOUT_MS = 6e5;
+var PG_SCHEMA_DIFF_APP_NAME = "runa_pg_schema_diff";
+var PG_SCHEMA_DIFF_PLAN_MAX_RETRIES = 2;
+var PG_SCHEMA_DIFF_PLAN_RETRY_DELAY_MS = 3e3;
+function appendApplicationName(dsn, appName) {
+  try {
+    const url = new URL(dsn);
+    url.searchParams.set("application_name", appName);
+    return url.toString();
+  } catch {
+    const separator = dsn.includes("?") ? "&" : "?";
+    return `${dsn}${separator}application_name=${appName}`;
+  }
+}
+function buildPgSchemaDiffPlanArgs(dbUrl, schemasDir, includeSchemas, options) {
+  const taggedDsn = appendApplicationName(dbUrl, PG_SCHEMA_DIFF_APP_NAME);
+  const planArgs = [
+    "plan",
+    "--from-dsn",
+    taggedDsn,
+    "--to-dir",
+    schemasDir,
+    "--disable-plan-validation",
+    ...includeSchemas.flatMap((schema) => ["--include-schema", schema])
+  ];
+  if (options?.tempDbDsn) {
+    planArgs.push("--temp-db-dsn", options.tempDbDsn);
+  }
+  return planArgs;
+}
+function throwPgSchemaDiffSpawnError(error, signal) {
+  logger2.error("pg-schema-diff failed to spawn:");
+  logger2.error(`Error: ${error.message}`);
+  if (error.code === "ENOENT") {
+    throw new Error("pg-schema-diff binary not found. Ensure it is installed and in PATH.");
+  }
+  if (signal === "SIGTERM") {
+    throw new Error(
+      `pg-schema-diff plan timed out after ${PG_SCHEMA_DIFF_PLAN_TIMEOUT_MS / 1e3}s. This may indicate a connection issue or an extremely large schema diff.`
+    );
+  }
+  throw new Error(`pg-schema-diff spawn failed: ${error.message}`);
+}
+function logPgSchemaDiffPlanFailure(status, signal, schemasDir, planStderr, planOutput, targetDir) {
+  logger2.error("pg-schema-diff plan failed:");
+  logger2.error(`Exit code: ${status}`);
+  logger2.error(`Signal: ${signal || "none"}`);
+  logger2.error(`Stderr: ${planStderr || "(empty)"}`);
+  const combinedOutput = planStderr || planOutput;
+  const extensionDetection = detectMissingExtensionType(combinedOutput);
+  if (extensionDetection.detected) {
+    logger2.error(formatExtensionErrorHint(extensionDetection));
+  }
+  const partitionDetection = detectPartitionPrivilegeError(combinedOutput);
+  if (partitionDetection.detected) {
+    logger2.error(formatPartitionPrivilegeHint(partitionDetection));
+  }
+  const boundaryHint = formatDeclarativeDependencyBoundaryHint(
+    combinedOutput,
+    schemasDir,
+    targetDir
+  );
+  if (boundaryHint) {
+    logger2.error(boundaryHint);
+  }
+}
+function executePgSchemaDiffPlan(dbUrl, schemasDir, includeSchemas, verbose, options) {
+  const planArgs = buildPgSchemaDiffPlanArgs(dbUrl, schemasDir, includeSchemas, options);
+  if (verbose) {
+    logger2.debug(`pg-schema-diff ${planArgs.join(" ")}`);
+  }
+  for (let attempt = 0; attempt <= PG_SCHEMA_DIFF_PLAN_MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      logger2.warn(
+        `Retrying pg-schema-diff plan (attempt ${attempt + 1}/${PG_SCHEMA_DIFF_PLAN_MAX_RETRIES + 1}) after ${PG_SCHEMA_DIFF_PLAN_RETRY_DELAY_MS}ms...`
+      );
+      spawnSync("sleep", [String(PG_SCHEMA_DIFF_PLAN_RETRY_DELAY_MS / 1e3)], {
+        stdio: "ignore"
+      });
+    }
+    const cleanupDaemon = startConnectionCleanupDaemon(dbUrl, verbose);
+    let planResult;
+    try {
+      planResult = spawnSync("pg-schema-diff", planArgs, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: PG_SCHEMA_DIFF_PLAN_TIMEOUT_MS
+      });
+    } finally {
+      stopConnectionCleanupDaemon(cleanupDaemon, verbose);
+    }
+    const planOutput = planResult.stdout || "";
+    const planStderr = planResult.stderr || "";
+    if (planResult.error) {
+      throwPgSchemaDiffSpawnError(planResult.error, planResult.signal);
+    }
+    if (planResult.status !== 0 && !planOutput.trim()) {
+      if (attempt < PG_SCHEMA_DIFF_PLAN_MAX_RETRIES && isTransientConnectionError(planStderr)) {
+        logger2.warn(
+          `pg-schema-diff plan failed with transient connection error: ${planStderr.split("\n")[0]}`
+        );
+        continue;
+      }
+      logPgSchemaDiffPlanFailure(
+        planResult.status,
+        planResult.signal,
+        schemasDir,
+        planStderr,
+        planOutput,
+        options?.targetDir
+      );
+      throw new Error(
+        `pg-schema-diff plan failed (exit ${planResult.status}): ${planStderr || "(no output)"}`
+      );
+    }
+    if (attempt > 0) {
+      logger2.step(`pg-schema-diff plan succeeded on attempt ${attempt + 1}`);
+    }
+    return { planOutput, planStderr };
+  }
+  throw new Error("pg-schema-diff plan failed after all retries");
+}
+
+export { DB_APPLY_CHECK_MODE_CONTRACT_NOTE, FUNCTION_DEFINITION_RE, HAZARD_REGEX, MAX_DETAILED_DECLARATIVE_WARNINGS, PG_SCHEMA_DIFF_APPLY_TIMEOUT_MS, PUBLIC_SCHEMA, STATEMENT_IDX_REGEX, analyzeDeclarativeDependencyContract, blankQuotedStrings, buildIdleConnectionCleanupSql, collectSqlFiles, countNewlines, detectDropTableStatements, detectMissingExtensionType, detectMissingQualifiedFunction, detectPartitionPrivilegeError, detectPgSchemaDiffVersion, executePgSchemaDiffPlan, extractDdlObject, extractFirstDollarBody, formatDeclarativeDependencyBoundaryHint, formatDeclarativeDependencyViolation, formatDeclarativeDependencyWarning, formatExtensionErrorHint, formatPartitionPrivilegeHint, freeConnectionSlotsForPgSchemaDiff, hasUnparsedHazardHints, isNonDdlMaintenanceStatement, isNonSchemaOperation, parseSqlFilename, sanitizeExecutableCode, sanitizeExecutableCodePreserveStrings, shouldReviewUnknownDeclarativeDdl, shouldReviewUnknownIdempotentDdl, splitSqlStatements, startConnectionCleanupDaemon, stopConnectionCleanupDaemon, summarizeDeclarativeDependencyWarnings, verifyDatabaseConnection, verifyPgSchemaDiffBinary };