@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-sql-analyzer-F77ZMQXR.js

@@ -0,0 +1,3840 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-sql-analyzer.ts
+var IDENTITY = { byteOffset: 0, rowOffset: 0, columnOffset: 0 };
+var SQL_KEYWORDS = /* @__PURE__ */ new Set([
+  "all",
+  "alter",
+  "analyze",
+  "and",
+  "any",
+  "array",
+  "as",
+  "asc",
+  "at",
+  "authorization",
+  "begin",
+  "between",
+  "both",
+  "by",
+  "cascade",
+  "case",
+  "cast",
+  "check",
+  "collate",
+  "column",
+  "comment",
+  "commit",
+  "concurrently",
+  "conflict",
+  "constraint",
+  "copy",
+  "create",
+  "cross",
+  "cube",
+  "current",
+  "current_date",
+  "current_role",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "database",
+  "default",
+  "deferrable",
+  "deferred",
+  "delete",
+  "desc",
+  "distinct",
+  "do",
+  "drop",
+  "else",
+  "end",
+  "except",
+  "execute",
+  "exists",
+  "explain",
+  "false",
+  "fetch",
+  "filter",
+  "first",
+  "for",
+  "foreign",
+  "from",
+  "full",
+  "function",
+  "generated",
+  "global",
+  "grant",
+  "group",
+  "grouping",
+  "having",
+  "if",
+  "ilike",
+  "in",
+  "index",
+  "initially",
+  "inner",
+  "inout",
+  "insert",
+  "intersect",
+  "into",
+  "is",
+  "join",
+  "key",
+  "language",
+  "last",
+  "lateral",
+  "leading",
+  "left",
+  "like",
+  "limit",
+  "local",
+  "localtime",
+  "localtimestamp",
+  "natural",
+  "not",
+  "nothing",
+  "null",
+  "nulls",
+  "offset",
+  "on",
+  "only",
+  "or",
+  "order",
+  "out",
+  "outer",
+  "over",
+  "overlaps",
+  "partition",
+  "preceding",
+  "precision",
+  "primary",
+  "procedure",
+  "range",
+  "recursive",
+  "references",
+  "rename",
+  "replace",
+  "reset",
+  "restrict",
+  "returning",
+  "revoke",
+  "right",
+  "rollback",
+  "row",
+  "rows",
+  "savepoint",
+  "schema",
+  "select",
+  "session_user",
+  "set",
+  "show",
+  "similar",
+  "some",
+  "start",
+  "table",
+  "tablesample",
+  "then",
+  "to",
+  "trailing",
+  "transaction",
+  "trigger",
+  "true",
+  "truncate",
+  "union",
+  "unique",
+  "unknown",
+  "unlogged",
+  "update",
+  "using",
+  "vacuum",
+  "values",
+  "view",
+  "when",
+  "where",
+  "window",
+  "with"
+]);
+function isPostgresCatalogName(t) {
+  if (t.length <= 3) return false;
+  if (!t.startsWith("pg_")) return false;
+  for (let i = 3; i < t.length; i++) {
+    const c = t.charCodeAt(i);
+    if (c !== 95 && (c < 97 || c > 122)) return false;
+  }
+  return true;
+}
+var INFORMATION_SCHEMA_VIEWS = /* @__PURE__ */ new Set([
+  "columns",
+  "tables",
+  "views",
+  "routines",
+  "schemata",
+  "sequences",
+  "key_column_usage",
+  "table_constraints",
+  "constraint_column_usage",
+  "referential_constraints",
+  "check_constraints",
+  "routine_parameters",
+  "table_privileges",
+  "column_privileges",
+  "role_table_grants",
+  "role_routine_grants",
+  "trigger",
+  "triggers",
+  "views"
+]);
+var PLATFORM_SCHEMAS = /* @__PURE__ */ new Set(["vault", "auth", "storage", "extensions", "realtime", "graphql", "pgsodium", "pgtle"]);
+var MODE_KEYWORD_TYPES = /* @__PURE__ */ new Set(["keyword_in", "keyword_out", "keyword_inout", "keyword_variadic"]);
+function classifyExternalTarget(target, qualified, wholeQuotedName = false) {
+  if (qualified) {
+    const q = qualified.toLowerCase();
+    if (q.startsWith("information_schema.")) return "informationSchema";
+    const qdot = q.indexOf(".");
+    if (qdot > 0 && PLATFORM_SCHEMAS.has(q.slice(0, qdot))) return "platform";
+  }
+  const t = target.toLowerCase();
+  if (!wholeQuotedName && t.startsWith("information_schema.")) return "informationSchema";
+  if (INFORMATION_SCHEMA_VIEWS.has(t)) return "informationSchema";
+  if (isPostgresCatalogName(t)) return "postgresCatalog";
+  if (t === "public") return "implicitSchema";
+  const dot = t.indexOf(".");
+  if (!wholeQuotedName && dot > 0) {
+    const schema = t.slice(0, dot);
+    if (PLATFORM_SCHEMAS.has(schema)) return "platform";
+  }
+  return null;
+}
+var SQL_PROVIDED_FUNCTIONS = /* @__PURE__ */ new Set([
+  // 102 names. `isempty` is PostgreSQL's range function and sits in the PostgreSQL group, not
+  // pgTAP's `is_empty` — the two are one character apart and a different provider.
+  // pgTAP — the PostgreSQL unit-testing extension. `boundary/internal/db/sqltest/` is a suite of
+  // it: `select plan(8);` … `select * from finish();`.
+  "plan",
+  "finish",
+  "collect_tap",
+  "ok",
+  "skip",
+  "cmp_ok",
+  "set_ne",
+  "results_ne",
+  "row_eq",
+  "is_empty",
+  "isnt_empty",
+  "is_strict",
+  "isnt_strict",
+  "has_index",
+  "hasnt_index",
+  "has_function",
+  "has_trigger",
+  "has_view",
+  "hasnt_view",
+  "has_table",
+  "hasnt_table",
+  "has_column",
+  "hasnt_column",
+  "has_domain",
+  "has_type",
+  "col_not_null",
+  "col_is_null",
+  "col_is_pk",
+  "col_has_default",
+  "col_hasnt_default",
+  "col_default_is",
+  "col_type_is",
+  "domain_type_is",
+  "fk_ok",
+  "trigger_is",
+  "volatility_is",
+  "throws_like",
+  // PostgreSQL's own built-ins — the `SQL_BUILTINS` remit's first clause. `isempty` is HERE and not
+  // with pgTAP's `is_empty`: it is PostgreSQL's range function (`isempty(anyrange)`), a different
+  // spelling with a different provider, and the two are one character apart.
+  "isempty",
+  "family",
+  "json_typeof",
+  "json_to_recordset",
+  "jsonb_to_recordset",
+  "jsonb_array_length",
+  "jsonb_object_keys",
+  "jsonb_array_elements_text",
+  "to_regprocedure",
+  "convert_to",
+  "convert_from",
+  "regexp_split_to_array",
+  "regexp_split_to_table",
+  "current_schema",
+  "xmlconcat2",
+  "pow",
+  "enum_first",
+  "get_byte",
+  "cosh",
+  // uuid-ossp, beside the `uuid_generate_v4`/`uuid_generate_v1`/`uuid_nil` `SQL_BUILTINS` carries.
+  "uuid_generate_v1mc",
+  // DuckDB — the engine the corpus's `duckdb/` tree runs on.
+  "read_parquet",
+  "read_csv",
+  "read_csv_auto",
+  "len",
+  "strlen",
+  "strftime",
+  "quantile_cont",
+  "quantile_disc",
+  "approx_quantile",
+  "reservoir_quantile",
+  "date_diff",
+  "array_contains",
+  "array_push_back",
+  "array_pop_front",
+  "list",
+  "list_resize",
+  "list_distinct",
+  "list_transform",
+  "list_position",
+  "list_aggregate",
+  "list_sum",
+  "countif",
+  "arg_min",
+  "hash",
+  "bitstring_agg",
+  "lttb",
+  "median",
+  "min_by",
+  "max_by",
+  "product",
+  "instr",
+  "group_concat",
+  // SQLite — its core functions plus the extensions its own source tree ships.
+  "hex",
+  "strdup",
+  "randomblob",
+  "sha1",
+  "sha1b",
+  "sha1_query",
+  "sha3_query",
+  "ieee754_from_int",
+  "parse_create_index",
+  "shell_prompt_test",
+  // MSSQL's metadata function, and pg_cron's scheduling pair.
+  "columnproperty",
+  "schedule",
+  "unschedule"
+]);
+var SQL_BUILTINS = /* @__PURE__ */ new Set([
+  // Provided by PostgreSQL or a stock EXTENSION rather than by this project.
+  //
+  // WHY THIS BLOCK EXISTS, measured 2026-09-27. Every name the analyzer
+  // suppresses here is one a consumer of the graph could otherwise mistake for
+  // a project function — and an AI agent reading `calls X->encode` has no way to
+  // know `encode` is pgcrypto's. Classifying the whole unknown population on
+  // ProxiCall put 48 edges / 3 names in this category (`encode` 30, `digest` 17,
+  // `daterange` 1) and a further 122 edges / 42 names that were ALSO SQL-provided
+  // but live in files the grammar cannot parse (`uuid_generate_v4` 16,
+  // `gen_random_bytes` 12, `array_append`, `regexp_replace`, `regexp_matches`,
+  // `has_function_privilege`). Only 11 edges are genuinely dangling project
+  // references, so the raw "unknown" count was overwhelmingly this gap and not a
+  // real dangling-reference problem.
+  //
+  // Extensions are included deliberately: uuid-ossp, pgcrypto and PostGIS ship
+  // these functions as part of a normal PostgreSQL install, and a project that
+  // calls them has no declaration for them anywhere.
+  //
+  // pgcrypto
+  "encode",
+  "decode",
+  "digest",
+  "hmac",
+  "crypt",
+  "gen_salt",
+  "gen_random_bytes",
+  "gen_random_uuid",
+  // uuid-ossp and friends
+  "uuid_generate_v4",
+  "uuid_generate_v1",
+  "uuid_nil",
+  "gen_random_uuid",
+  // pgTAP / assertion helpers
+  "has_function_privilege",
+  "has_table_privilege",
+  "has_schema_privilege",
+  "has_column_privilege",
+  "has_database_privilege",
+  "has_type_privilege",
+  "throws_ok",
+  "lives_ok",
+  "is",
+  "isnt",
+  "matches",
+  "results_eq",
+  "set_eq",
+  // information_schema / catalogue accessors
+  "pg_get_functiondef",
+  "pg_get_viewdef",
+  "pg_get_indexdef",
+  "pg_get_constraintdef",
+  "pg_get_triggerdef",
+  "pg_get_expr",
+  "pg_get_userbyid",
+  "pg_get_viewdef",
+  "pg_get_partkeydef",
+  "pg_get_statisticsobjdef_columns",
+  "pg_tablespace_location",
+  "pg_relation_filenode",
+  "pg_get_function_arguments",
+  "pg_get_function_result",
+  "obj_description",
+  "col_description",
+  "shobj_description",
+  "col_description_schema",
+  "pg_describe_object",
+  "pg_identify_object",
+  "pg_get_object_address",
+  "pg_get_object_keywords",
+  "has_any_column_privilege",
+  "has_sequence_privilege",
+  "pg_get_ruledef",
+  "pg_get_triggerdef",
+  "pg_stat_get_numscans",
+  "aclexplode",
+  "acldefault",
+  "makeaclitem",
+  "pg_backend_memory_contexts",
+  "pg_get_function_identity_arguments",
+  "format_type",
+  "pg_typeof",
+  "pg_table_is_visible",
+  "pg_function_is_visible",
+  "pg_opclass_is_visible",
+  "pg_conversion_is_visible",
+  "pg_collation_is_visible",
+  "pg_ts_config_is_visible",
+  "pg_statistics_obj_is_visible",
+  "pg_total_relation_size",
+  "pg_relation_size",
+  "pg_table_size",
+  "pg_indexes_size",
+  "pg_database_size",
+  "pg_size_pretty",
+  "pg_column_size",
+  "pg_size_bytes",
+  "pg_encoding_to_char",
+  "pg_char_to_encoding",
+  "pg_advisory_lock",
+  "pg_advisory_unlock",
+  "pg_advisory_xact_lock",
+  "pg_try_advisory_lock",
+  "pg_notify",
+  "pg_sleep",
+  "pg_backend_pid",
+  "pg_current_xact_id",
+  "txid_current",
+  "pg_export_snapshot",
+  "pg_import_snapshot",
+  "pg_cancel_backend",
+  "pg_terminate_backend",
+  "pg_reload_conf",
+  "pg_stat_reset",
+  "pg_is_in_recovery",
+  "pg_last_wal_receive_lsn",
+  "pg_current_wal_lsn",
+  "pg_wal_lsn_diff",
+  "pg_switch_wal",
+  "pg_create_restore_point",
+  "pg_replication_origin_advance",
+  "pg_logical_emit_message",
+  "pg_column_is_updatable",
+  "pg_index_column_has_property",
+  "pg_indexam_has_property",
+  "pg_index_has_property",
+  "pg_index_column_has_property",
+  "pg_options_to_table",
+  "pg_tablespace_databases",
+  "pg_ls_dir",
+  "pg_read_file",
+  "pg_read_binary_file",
+  "pg_stat_file",
+  "pg_ls_logdir",
+  "pg_ls_waldir",
+  "pg_ls_tmpdir",
+  "pg_ls_archive_statusdir",
+  // string / pattern builtins the corpus leans on
+  "regexp_replace",
+  "regexp_match",
+  "regexp_matches",
+  "regexp_count",
+  "regexp_instr",
+  "regexp_like",
+  "regexp_substr",
+  "split_part",
+  "string_to_array",
+  "array_to_string",
+  "array_position",
+  "array_positions",
+  "array_remove",
+  "array_replace",
+  "array_prepend",
+  "array_append",
+  "array_cat",
+  "array_fill",
+  "cardinality",
+  "array_dims",
+  "array_upper",
+  "array_lower",
+  "array_ndims",
+  "array_length",
+  "trim_array",
+  "width_bucket",
+  // range / multirange, which the corpus uses for exclusion constraints
+  "daterange",
+  "tsrange",
+  "tstzrange",
+  "int4range",
+  "int8range",
+  "numrange",
+  "range_merge",
+  "range_lower",
+  "range_upper",
+  "range_lower_inc",
+  "range_upper_inc",
+  "range_lower_inf",
+  "range_upper_inf",
+  "range_empty",
+  "int4multirange",
+  "datemultirange",
+  "int8multirange",
+  "nummultirange",
+  "tsmultirange",
+  "tstzmultirange",
+  "range_contains",
+  "range_contained_by",
+  "range_overlaps",
+  "range_adjacent",
+  // PostGIS, which the extension corpus is full of
+  "st_x",
+  "st_y",
+  "st_z",
+  "st_m",
+  "st_2d",
+  "st_3d",
+  "st_srid",
+  "st_set_srid",
+  "st_astext",
+  "st_asbinary",
+  "st_asgeojson",
+  "st_geometrytype",
+  "st_type",
+  "st_geometryn",
+  "st_numgeometries",
+  "st_npoints",
+  "st_nrings",
+  "st_isempty",
+  "st_isvalid",
+  "st_isvalidreason",
+  "st_issimple",
+  "st_isclosed",
+  "st_isring",
+  "st_transform",
+  "st_intersects",
+  "st_contains",
+  "st_within",
+  "st_containsproperly",
+  "st_covers",
+  "st_coveredby",
+  "st_overlaps",
+  "st_crosses",
+  "st_touches",
+  "st_distance",
+  "st_dwithin",
+  "st_area",
+  "st_perimeter",
+  "st_length",
+  "st_length2d",
+  "st_buffer",
+  "st_convexhull",
+  "st_envelope",
+  "st_centroid",
+  "st_makeenvelope",
+  "st_makepoint",
+  "st_makeline",
+  "st_geographyfromtext",
+  "st_geometryfromtext",
+  "st_geogfromtext",
+  "st_geomfromtext",
+  "st_point",
+  "postgis_version",
+  "postgis_full_version",
+  "postgis_geos_version",
+  "box2d",
+  "box3d",
+  "geometry",
+  "geography",
+  "box",
+  "path",
+  "polygon",
+  // aggregate / window extras the corpus uses
+  "percentile_cont",
+  "percentile_disc",
+  "mode",
+  "rank",
+  "dense_rank",
+  "row_number",
+  "ntile",
+  "first_value",
+  "last_value",
+  "nth_value",
+  "grouping",
+  "corr",
+  "covar_pop",
+  "covar_samp",
+  "regr_slope",
+  "regr_intercept",
+  "regr_r2",
+  "regr_count",
+  "regr_avgx",
+  "regr_avgy",
+  "bool_and",
+  "bool_or",
+  "every",
+  "bit_and",
+  "bit_or",
+  "bit_xor",
+  "json_agg",
+  "json_object_agg",
+  // statistical aggregates, which the corpus uses and this set was missing
+  "stddev",
+  "stddev_pop",
+  "stddev_samp",
+  "variance",
+  "var_pop",
+  "var_samp",
+  "stddev_pop_zscore",
+  // hosted-platform functions a project calls with no local declaration
+  "jwt",
+  "auth_uid",
+  "current_user_id",
+  "aggregate",
+  // aggregate
+  "any_value",
+  "array_agg",
+  "avg",
+  "bit_and",
+  "bit_or",
+  "bool_and",
+  "bool_or",
+  "count",
+  "every",
+  "json_agg",
+  "json_object_agg",
+  "jsonb_agg",
+  "jsonb_object_agg",
+  "max",
+  "min",
+  "string_agg",
+  "sum",
+  "xmlagg",
+  // window
+  "cume_dist",
+  "dense_rank",
+  "first_value",
+  "lag",
+  "last_value",
+  "lead",
+  "nth_value",
+  "ntile",
+  "percent_rank",
+  "percentile_cont",
+  "percentile_disc",
+  "rank",
+  "row_number",
+  // numeric / math
+  "abs",
+  "acos",
+  "asin",
+  "atan",
+  "atan2",
+  "cbrt",
+  "ceil",
+  "ceiling",
+  "cos",
+  "cot",
+  "degrees",
+  "div",
+  "exp",
+  "floor",
+  "gcd",
+  "lcm",
+  "ln",
+  "log",
+  "log10",
+  "mod",
+  "pi",
+  "power",
+  "radians",
+  "random",
+  "round",
+  "scale",
+  "sign",
+  "sin",
+  "sqrt",
+  "tan",
+  "trunc",
+  "width_bucket",
+  // string
+  "ascii",
+  "btrim",
+  "char_length",
+  "character_length",
+  "chr",
+  "concat",
+  "concat_ws",
+  "format",
+  "initcap",
+  "left",
+  "length",
+  "lower",
+  "lpad",
+  "ltrim",
+  "md5",
+  "overlay",
+  "position",
+  "quote_ident",
+  "quote_literal",
+  "repeat",
+  "replace",
+  "reverse",
+  "right",
+  "rpad",
+  "rtrim",
+  "split_part",
+  "starts_with",
+  "strpos",
+  "substr",
+  "substring",
+  "translate",
+  "trim",
+  "upper",
+  // date / time
+  "age",
+  "clock_timestamp",
+  "current_date",
+  "current_time",
+  "current_timestamp",
+  "date",
+  "date_bin",
+  "date_part",
+  "date_trunc",
+  "datediff",
+  "dateadd",
+  "datetime",
+  "extract",
+  "getdate",
+  "getutcdate",
+  "interval",
+  "isfinite",
+  "justify_days",
+  "justify_hours",
+  "justify_interval",
+  "localtime",
+  "localtimestamp",
+  "make_date",
+  "make_interval",
+  "make_time",
+  "make_timestamp",
+  "make_timestamptz",
+  "now",
+  "statement_timestamp",
+  "sysdate",
+  "timeofday",
+  "to_char",
+  "to_date",
+  "to_number",
+  "to_timestamp",
+  "transaction_timestamp",
+  // conditional / null
+  "coalesce",
+  "greatest",
+  "ifnull",
+  "iif",
+  "least",
+  "nullif",
+  "nvl",
+  "nvl2",
+  // json
+  "json_array_length",
+  "json_build_array",
+  "json_build_object",
+  "json_each",
+  "json_each_text",
+  "json_extract",
+  "json_object",
+  "json_object_field",
+  "json_object_keys",
+  "json_populate_record",
+  "json_query",
+  "json_set",
+  "json_strip_nulls",
+  "json_type",
+  "jsonb_array_elements",
+  "jsonb_build_object",
+  "jsonb_each",
+  "jsonb_each_text",
+  "jsonb_pretty",
+  "jsonb_set",
+  "jsonb_typeof",
+  "row_to_json",
+  "to_json",
+  "to_jsonb",
+  // array / set
+  "array_fill",
+  "array_length",
+  "array_lower",
+  "array_position",
+  "array_to_string",
+  "array_upper",
+  "cardinality",
+  "generate_series",
+  "generate_subscripts",
+  "unnest",
+  "range_agg",
+  "width_bucket",
+  // system / session / type
+  "coalesce",
+  "current_setting",
+  "format_type",
+  "nextval",
+  "pg_advisory_lock",
+  "pg_backend_pid",
+  "pg_cancel_backend",
+  "pg_client_encoding",
+  "pg_column_size",
+  "pg_current_xact_id",
+  "pg_terminate_backend",
+  "pg_typeof",
+  "pg_total_relation_size",
+  "set_config",
+  "setseed",
+  "setval",
+  "to_regclass",
+  "txid_current",
+  "version",
+  "newid",
+  "scope_identity",
+  "dense_rank",
+  // cast / conversion
+  "cast",
+  "convert",
+  "convert_tz",
+  "parse_ident",
+  "try_cast",
+  "try_convert",
+  "try_parse_ident"
+]);
+var identifierTypes = /* @__PURE__ */ new Set(["identifier", "literal"]);
+var queryTypes = /* @__PURE__ */ new Set(["select", "set_operation", "create_query", "subquery", "cte"]);
+var PSQL_INCLUDE_COMMANDS = /* @__PURE__ */ new Set(["i", "ir"]);
+var PSQL_INCLUDE_SUFFIXES = [".sql", ".psql", ".dump"];
+var REPLACEABLE_DECLARATIONS = /* @__PURE__ */ new Set([
+  "create_function",
+  "create_procedure",
+  "create_view",
+  "create_materialized_view"
+]);
+var CONSTRUCTOR_VALUE_NODES = /* @__PURE__ */ new Set(["list", "array"]);
+var RESERVED_AS_COLUMN_NAME = /* @__PURE__ */ new Set(["like"]);
+function isTagIdentStart(code) {
+  return code >= 65 && code <= 90 || // A-Z
+  code >= 97 && code <= 122 || // a-z
+  code === 95;
+}
+function isTagIdentPart(code) {
+  return isTagIdentStart(code) || code >= 48 && code <= 57;
+}
+function dollarTagAt(content, at) {
+  if (content.charCodeAt(at) !== 36) return null;
+  let i = at + 1;
+  if (i < content.length && isTagIdentStart(content.charCodeAt(i))) {
+    i++;
+    while (i < content.length && isTagIdentPart(content.charCodeAt(i))) i++;
+  }
+  if (i < content.length && content.charCodeAt(i) === 36) return content.slice(at, i + 1);
+  return null;
+}
+function opensWithConstraintKeyword(text) {
+  const KEYWORD = "CONSTRAINT";
+  let i = 0;
+  const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11;
+  while (i < text.length && isSpace(text.charCodeAt(i))) i++;
+  if (text.charCodeAt(i) === 44) {
+    i++;
+    while (i < text.length && isSpace(text.charCodeAt(i))) i++;
+  }
+  if (i + KEYWORD.length > text.length) return false;
+  for (let k = 0; k < KEYWORD.length; k++) {
+    let c = text.charCodeAt(i + k);
+    if (c >= 97 && c <= 122) c -= 32;
+    if (c !== KEYWORD.charCodeAt(k)) return false;
+  }
+  return isSpace(text.charCodeAt(i + KEYWORD.length));
+}
+var RESYNC_ERROR_SPAN_RATIO = 0.6;
+var RESYNC_MIN_ERROR_NODES = 1;
+function fileModuleNameFor(filePath) {
+  const slash = filePath.lastIndexOf("/");
+  const base = slash >= 0 ? filePath.slice(slash + 1) : filePath;
+  return base.length > 0 ? base : "migration.sql";
+}
+function qualifiedNameFor(file, name, ownerName, kind) {
+  return name === file && kind === ASTEngine.SymbolKind.Module ? file : `${file}::${ownerName ? `${ownerName}.${name}` : name}`;
+}
+var RealSqlAnalyzer = class _RealSqlAnalyzer {
+  analyze(rootNode, content, filePath) {
+    this.treeIndexes = /* @__PURE__ */ new WeakMap();
+    const fileModuleName = fileModuleNameFor(filePath);
+    const state = {
+      fileModuleName,
+      nestedStatements: /* @__PURE__ */ new Set(),
+      localCtes: /* @__PURE__ */ new Set(),
+      symbols: [],
+      relationships: [],
+      imports: [],
+      exports: [],
+      relationshipKeys: /* @__PURE__ */ new Set(),
+      relationshipsByKey: /* @__PURE__ */ new Map(),
+      redeclared: /* @__PURE__ */ new Map(),
+      routineNames: /* @__PURE__ */ new Set(),
+      includeKeys: /* @__PURE__ */ new Set(),
+      symbolKeys: /* @__PURE__ */ new Set(),
+      declarationKeys: /* @__PURE__ */ new Set(),
+      symbolNames: /* @__PURE__ */ new Set(),
+      idCounts: /* @__PURE__ */ new Map(),
+      patterns: /* @__PURE__ */ new Set(),
+      slice: IDENTITY,
+      metadata: {
+        linesOfCode: this.countLines(content),
+        performanceScore: 100,
+        architecturalInsights: [],
+        detectedFrameworks: ["SQL"],
+        patterns: [],
+        complexity: 1,
+        cyclomaticComplexity: 1
+      },
+      ambiguity: {
+        errorNodes: 0,
+        unparseableRegions: 0,
+        resyncStatements: 0,
+        resyncDeclarations: 0,
+        resyncSkipped: 0,
+        keywordTargetsSuppressed: 0,
+        recoveryCallsSuppressed: 0,
+        sweepDeclarationsRecovered: 0,
+        sweepStatementsDispatched: 0,
+        builtinCallsSuppressed: 0,
+        quotedIdentifiers: 0,
+        constraintsRecoveredFromError: 0,
+        executeLiterals: 0,
+        executeRecovered: 0,
+        executeSkipped: 0,
+        psqlCommandsSkipped: 0,
+        includeNonLiteral: 0,
+        extensionImportsEmitted: 0,
+        overridesEmitted: 0,
+        overloadNotReplacementSkipped: 0,
+        pgCatalogMarkedExternal: 0,
+        providedFunctionCallsMarked: 0,
+        instantiationsEmitted: 0,
+        reservedNameSymbolsSuppressed: 0,
+        /**
+         * A `contains` edge DROPPED because its source and target bare NAMES were equal.
+         *
+         * The counter exists because the drop was SILENT — a legal column that shares its table's
+         * name simply did not appear in the graph, and nothing said so. Measured over the whole
+         * admitted population on 2026-10-21: **9 edges in 7 files**, every one of them a real
+         * declaration the table did not own in the graph. The guard now tests the DECLARATION
+         * IDENTITY where the call site has it, so these edges are published; the counter is what
+         * would catch a case where the identity is not available and the name test still fires.
+         */
+        sameNameContainmentSuppressed: 0,
+        indexOwnersAdopted: 0,
+        indexOwnersExternalToFile: 0,
+        unnamedIndexSkipped: 0,
+        containmentRetargeted: 0,
+        containmentRetargetSkipped: 0
+      }
+    };
+    this.collectParseErrors(rootNode, state);
+    state.symbols.unshift({
+      name: fileModuleName,
+      kind: ASTEngine.SymbolKind.Module,
+      range: this.range(rootNode, state),
+      visibility: "public",
+      metadata: { sqlSpecific: true, isMigration: true, scriptPath: filePath }
+    });
+    if (rootNode) this.processRoot(rootNode, state);
+    const resync = this.resyncNeeded(rootNode, state);
+    if (resync) this.runResync(content, state);
+    this.runExecuteScan(content, state);
+    this.adoptLateDeclaredIndexOwners(state);
+    this.publishQualifiedNames(state);
+    this.retargetContainmentEdges(state);
+    const tables = state.symbols.filter((s) => s.metadata?.type === "table");
+    if (tables.length > 2) state.metadata.architecturalInsights.push("Complex schema detected");
+    if (state.patterns.has("Foreign Key Constraints")) {
+      state.metadata.architecturalInsights.push("Relational integrity enforced via Foreign Keys");
+    }
+    if (state.externalTargets) state.metadata.externalTargets = state.externalTargets;
+    state.metadata.patterns = [...state.patterns].sort();
+    state.metadata.complexity = Math.max(1, state.metadata.cyclomaticComplexity ?? 1);
+    state.metadata.ambiguity = state.ambiguity;
+    return {
+      symbols: state.symbols,
+      relationships: state.relationships,
+      imports: state.imports,
+      exports: state.exports,
+      metadata: state.metadata,
+      errors: state.metadata.errors ?? []
+    };
+  }
+  /**
+   * Give an index symbol the owner its `contains` edge already names, when the
+   * table was declared AFTER the index.
+   *
+   * `processIndex` attaches the owner when the table symbol already exists, which
+   * covers `CREATE TABLE` then `CREATE INDEX`. The reverse order — a migration that
+   * adds the index first, or a file where the table is recovered by the
+   * declaration sweep or the EXECUTE-literal pass after the index was walked —
+   * leaves the index with `ownerName: undefined` while `contains table -> index`
+   * says otherwise. 70 containment edges over a 200-file corpus slice were in that
+   * state before this pass, and `bb_graph`'s owner-cascade and `bb_impact`'s reverse
+   * walk both read `ownerName`, so the member read as an orphan that happened to be
+   * named in an edge.
+   *
+   * WHY IT IS A SEPARATE PASS AND NOT A LOOKAHEAD. Declaration order in a SQL file
+   * is not the order the analyzer visits in: the root walk dispatches top-level
+   * statements, the declaration sweep then re-walks the whole tree, and the resync
+   * and EXECUTE-literal passes append afterwards. Any "is the table there yet"
+   * question asked at `processIndex` time is answered about a partial file. A pass
+   * at the end is a question about the finished one.
+   *
+   * IT ADDS NO EDGE AND NO SYMBOL. It writes four fields the symbol should have had
+   * from the start, and counts what it did in `ambiguity.indexOwnersAdopted`, so a
+   * file where the order was already right reports 0.
+   */
+  /**
+  * CAUSE A — publish a `qualifiedName` that is an IDENTIFIER rather than a repeat of `name`.
+  *
+  * MEASURED before this existed. Over the whole admitted SQL population (1,962 files, 199 corpus
+  * repos, production `parseFile`; record
+  * `validation/m14/fixtures/sql/measurements/pass13-ambiguity-split-BEFORE.json`): 18,652 symbols
+  * collapsed to 7,875 distinct `name`s, and the count of symbols whose `qualifiedName` DIFFERED
+  * from their `name` was **0**. Every ambiguous target in that run therefore also had no
+  * `qualifiedName` to disambiguate it — the brief's A symptom, 100% of the time.
+  *
+  * WHY THE FIELD WAS INERT, and it was not this lane's choice of names.
+  * `src/ast/pool-worker.ts` derives the stored value as
+  * `s.qualifiedName || s.metadata?.fqn || (s.scope ? \`${s.scope}.${s.name}\` : s.name)`.
+  * This analyzer sets `ownerName` and never `scope`, so the third arm never fired and the derived
+  * value was `name`. `metadata.fqn` is the arm that formula reads first after the analyzer's own
+  * field, it is the field the C# family already writes (`real-csharp-analyzer.ts` `fqn: fullName`),
+  * and fsharp took it for the same reason (`real-fsharp-analyzer.ts:138`). So this writes the one
+  * field that is designed for the job rather than renaming anything.
+  *
+  * WHY THE FILE IS PART OF IT. `ownerName` alone is not an identifier for this language: SQL
+  * collides overwhelmingly WITHIN a kind, and the corpus measurement names the offenders — 187
+  * files declare a symbol called `id`, 104 declare `name`, 36 declare `changed_by`, every one of
+  * them a `property` (a column). An `owner.name` qualified name would read `items.id` in
+  * `001_init.sql` and `items.id` again in `002_orders.sql`, so the name that exists to make a
+  * symbol addressable would still not address it. `search_path` is what resolves those in a live
+  * database and a migration file is loaded as a unit, so the file is the outer scope SQL actually
+  * has, and it goes in.
+  *
+  * `name` is untouched. The published name surface every consumer reads is exactly what it was,
+  * which is why this needs no fixture change and no coordination with any other lane; the
+  * relationship targets are untouched too, so no edge changes which row it names. What changes is
+  * that `brain_symbol.qualified_name` now carries an identifier, and the store's pass-1 resolution
+  * (`target_external = qualified_name`, the only EXACT match it owns) has something exact to match
+  * for any edge that chooses to target it.
+  *
+  * NOT CLAIMED: this does not make an edge resolve that did not resolve. Resolution is the store's
+  * name-keyed passes, measured in `store-resolution.mts`; a distinct qualified name is a
+  * precondition for a name-keyed choice to be checkable, not a resolution itself.
+  */
+  publishQualifiedNames(state) {
+    const file = state.fileModuleName;
+    for (const s of state.symbols) {
+      if (!s.name) continue;
+      const fqn = qualifiedNameFor(file, s.name, s.ownerName, s.kind);
+      s.qualifiedName = fqn;
+      s.metadata = { ...s.metadata, fqn };
+    }
+  }
+  /**
+   * Rewrites every `contains` edge's TARGET to the qualified name of its member.
+   *
+   * ## WHY THIS IS THE CHANGE AND NOT THE OTHER ONE
+   *
+   * `pass13-ambiguity-split-AFTER.json` measured `K3_qname` EQUAL to `K0_bare` on all six firing
+   * types — 651/651, 2,512/2,512, 4,364/4,364 — for one reason: every symbol carried a qualified
+   * name and no edge targeted one, so the identifier existed and nothing used it. The store's
+   * resolution pass 1 (`parallel-indexer.ts:3773`) matches `target_external = qualified_name`, which
+   * is the only EXACT match it owns; pass 2 needs the bare name to be unique in the project and pass 3
+   * needs a dot. A bare member name meets none of the three in a migration corpus.
+   *
+   * `contains` is the ONE type where the qualified name is a fact rather than a guess, and that is
+   * what makes this safe to do here and not on the other five:
+   *
+   *   - The member was declared INSIDE the owner, in THIS parse result. `createSymbol` pushes the
+   *     member and emits `contains owner -> member` in the same walk. So the target's identity is
+   *     derivable from this file alone — no guessing which file declares it.
+   *   - `calls`, `uses` and `references` name something in ANOTHER file and the analyzer does not
+   *     know which. Emitting a qualified name there would be inventing the file, which is the
+   *     fabrication the M14 contract forbids and which the oracle counts as `unexplained`. Those
+   *     targets stay bare, and the report says so.
+   *
+   * ## WHY IT IS SELF-VERIFYING
+   *
+   * The candidate is admitted only if it is in the set of qualified names THIS parse result
+   * published. So the pass cannot introduce a target string no symbol publishes — the exact defect
+   * the graphql lane shipped and had to revert. A candidate that fails the check is left bare and
+   * counted in `containmentRetargetSkipped`, which is the falsifier: a non-zero value means the
+   * edge's (owner, member) pair does not name a symbol this file publishes, and the number of
+   * those is the cost.
+   *
+   * ## WHY THE SOURCE STAYS BARE
+   *
+   * Only the target is rewritten. The store resolves a relationship's SOURCE by exact name match
+   * over the symbols of the file being stored (`nameToSymbol.get(sourceName)`), so a qualified
+   * source would stop resolving — `store-resolution.mts` currently reads `src_unres: 200` on
+   * `contains` and this pass must not make it worse. Containment survives on the target alone,
+   * because the member's qualified name already contains the owner.
+   *
+   * ## WHAT IT DOES NOT CLAIM
+   *
+   * This does not make an edge resolve that did not resolve. Measured over the admitted corpus at
+   * the 600-file population of `validation/m14/fixtures/sql/contains-fqn-probe.mts`:
+   *
+   *   contains edges                                   5,552
+   *   target qualified name is a symbol this file published   5,552  (100.0%)
+   *   bare name today: unique                          2,067  (37.2%)
+   *   bare name today: ambiguous                       3,485  (62.8%)
+   *   qualified names published by >1 symbol              195   <- the falsifier
+   *   contains edges landing on such a name                 85   (1.5%)
+   *
+   * So the projected move is 62.8% of `contains` targets from "the reverse walk picks a winner by a
+   * rule nobody chose" to an exact bind, with 85 edges still landing on a name that is not unique —
+   * which is the residue `memberKind` already separates on the edge, and the honest limit of this
+   * change.
+   */
+  retargetContainmentEdges(state) {
+    const published = /* @__PURE__ */ new Set();
+    for (const s of state.symbols) {
+      const fqn = typeof s.qualifiedName === "string" ? s.qualifiedName : s.metadata?.fqn;
+      if (typeof fqn === "string" && fqn.length > 0) published.add(fqn);
+    }
+    const file = state.fileModuleName;
+    for (const rel of state.relationships) {
+      if (rel.type !== ASTEngine.RelationshipType.Contains) continue;
+      const owner = rel.source;
+      const member = rel.target;
+      if (!owner || !member) continue;
+      const candidate = qualifiedNameFor(file, member, owner, ASTEngine.SymbolKind.Property);
+      if (!published.has(candidate)) {
+        state.ambiguity.containmentRetargetSkipped++;
+        continue;
+      }
+      rel.target = candidate;
+      rel.metadata = { ...rel.metadata, qualifiedTarget: true };
+      state.ambiguity.containmentRetargeted++;
+    }
+  }
+  adoptLateDeclaredIndexOwners(state) {
+    for (const symbol of state.symbols) {
+      if (symbol.metadata?.type !== "index") continue;
+      if (symbol.ownerName) continue;
+      const table = symbol.metadata.table;
+      if (typeof table !== "string" || table.length === 0) continue;
+      const owner = this.existingSymbol(table, ASTEngine.SymbolKind.Class, state);
+      if (!owner) {
+        symbol.ownerName = table;
+        symbol.ownerKind = ASTEngine.SymbolKind.Class;
+        symbol.parent = table;
+        symbol.metadata = { ...symbol.metadata, ownerExternalToFile: true };
+        state.ambiguity.indexOwnersExternalToFile++;
+        continue;
+      }
+      symbol.ownerName = owner.name;
+      symbol.ownerKind = owner.kind;
+      symbol.parent = owner.name;
+      symbol.parentId = `${owner.id}.${symbol.name}`;
+      symbol.metadata = { ...symbol.metadata, ownerDeclaredLater: true };
+      state.ambiguity.indexOwnersAdopted++;
+    }
+  }
+  // ---------------------------------------------------------------- errors
+  /**
+   * ERROR and MISSING nodes, reported on the analyzer's own channel.
+   *
+   * The engine also reports tree errors, but every gate that calls
+   * `analyzer.analyze` directly (the M14 fixture lane, the mutation harness, the
+   * contract battery) sees only what the analyzer returns, and the previous
+   * version returned `errors: []` unconditionally — a file it could not parse at
+   * all read as a clean 0 symbols / 0 relationships / 0 errors. A `severity`
+   * field is part of the ParseError contract and the indexer keys its
+   * `hasSyntaxErrors` report off it, so these are warnings, not errors.
+   */
+  collectParseErrors(rootNode, state) {
+    if (!rootNode || !rootNode.hasError) return;
+    const errors = [];
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.type === "ERROR" || current.isMissing) {
+        state.ambiguity.errorNodes++;
+        if (current.type === "ERROR") state.ambiguity.unparseableRegions++;
+        if (errors.length < 50) {
+          errors.push({
+            message: current.type === "ERROR" ? "Unrecoverable syntax region: tree-sitter-sql could not parse this subtree. Extraction continued on a best-effort basis, so symbols and relationships inside this range may be missing." : `Missing ${current.type} token: the source is syntactically incomplete at this point. Extraction continued on a best-effort basis.`,
+            range: this.range(current, state),
+            severity: "warning"
+          });
+        }
+      }
+      for (let i = current.namedChildCount - 1; i >= 0; i--) {
+        const child = current.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    ;
+    state.metadata.errors = errors;
+  }
+  // ---------------------------------------------------------------- resync
+  /** Is this parse damaged badly enough that a per-statement re-parse pays? */
+  resyncNeeded(rootNode, state) {
+    if (!rootNode || !rootNode.hasError) return false;
+    if (state.ambiguity.errorNodes < RESYNC_MIN_ERROR_NODES) return false;
+    if (rootNode.type === "ERROR") return true;
+    for (let i = 0; i < rootNode.namedChildCount; i++) {
+      const child = rootNode.namedChild(i);
+      if (child?.type !== "ERROR") continue;
+      const span = child.endIndex - child.startIndex;
+      if (span > 0 && span / Math.max(1, rootNode.endIndex - rootNode.startIndex) >= RESYNC_ERROR_SPAN_RATIO) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Re-parse the file one top-level statement at a time and extract from the
+   * statements the whole-file parse could not reach.
+   *
+   * Why this is worth a second parse: the grammar requires a dollar-quoted body
+   * to be `BEGIN … END` of parseable `statement`s, so ONE statement keyword it
+   * does not know (RAISE, GET DIAGNOSTICS, …) leaves the closing tag
+   * unconsumed and the parser absorbs the rest of the file into a single ERROR.
+   * Measured over 441 files / 2,336 textual declarations: the whole-file parse
+   * reaches 1,557 (66.65%); re-parsing per statement reaches 2,263 (96.88%).
+   *
+   * Offsets are translated back to FILE coordinates by `Slice`, so a symbol
+   * recovered here carries the same 1-based lines and byte bounds as one the
+   * main pass produced. Any failure degrades to the main pass alone, which is
+   * exactly today's behaviour.
+   */
+  runResync(content, state) {
+    const slices = this.splitTopLevelStatements(content);
+    if (slices.length === 0) return;
+    state.ambiguity.resyncStatements = slices.length;
+    let parser = null;
+    try {
+      parser = this.acquireParser();
+    } catch {
+      state.ambiguity.resyncSkipped = slices.length;
+      return;
+    }
+    if (!parser) {
+      state.ambiguity.resyncSkipped = slices.length;
+      return;
+    }
+    const savedSlice = state.slice;
+    try {
+      for (const slice of slices) {
+        let tree;
+        try {
+          tree = parser.parse(slice.text);
+        } catch {
+          state.ambiguity.resyncSkipped++;
+          continue;
+        }
+        if (!tree?.rootNode) {
+          state.ambiguity.resyncSkipped++;
+          continue;
+        }
+        const before = state.symbols.length;
+        state.slice = {
+          byteOffset: slice.start,
+          rowOffset: slice.row,
+          columnOffset: slice.column
+        };
+        this.processRoot(tree.rootNode, state);
+        const recovered = state.symbols.length - before;
+        if (recovered > 0) state.ambiguity.resyncDeclarations += recovered;
+        state.slice = savedSlice;
+        tree.delete?.();
+      }
+    } catch {
+      state.ambiguity.resyncSkipped++;
+    } finally {
+      state.slice = savedSlice;
+    }
+  }
+  /**
+   * `EXECUTE [IMMEDIATE] '<sql>'` literals, as re-parseable slices.
+   *
+   * WHY THIS PASS EXISTS, and why it is TEXT rather than tree.
+   *
+   * PostgreSQL migrations reach the database two ways: by writing DDL, or by
+   * handing it over as a string inside a procedural body. Measured on the 387
+   * PostgreSQL extension files this lane can parse within 400 KB
+   * (/usr/share/postgresql/14/extension), the analyzer emits 2,172 symbols while
+   * **1,326 further CREATE declarations sit inside `EXECUTE '...'` literals**,
+   * across 78 files — INDEX 546, TABLE 312, SEQUENCE 234, SCHEMA 78, VIEW 78,
+   * TRIGGER 78. That is a potential +61 % on the corpus, and it is invisible to
+   * every tree-based pass, because the DDL is a string: a tree-sitter grammar
+   * parses one language and cannot produce `statement` nodes for SQL that is
+   * text inside a literal, at any amount of grammar work.
+   *
+   * The plpgsql grammar candidate (validation/m60/sql/v4-plpgsql-candidate.json)
+   * was the attempt to reach them through the tree, and it is instructive: it
+   * cut ProxiCall error nodes 36 % and added 9 % structure while leaving the
+   * product output byte-identical, because parsing the body still leaves the DDL
+   * inside a string. This pass reads the text instead, which is why it needs no
+   * grammar change and works on the grammar that is actually wired.
+   *
+   * WHAT IS SKIPPED, and why each skip is necessary:
+   *   - `--` and `/* *\/` comments, so `-- EXECUTE 'CREATE TABLE x'` in a
+   *     comment is not a declaration. Measured on the corpus, comments carry
+   *     real DDL text and this is the main false-positive risk.
+   *   - `'...'` strings, so an `EXECUTE` inside another string is not matched,
+   *     and so the matched literal's own text is not rescanned.
+   *   - `"..."` and `` `...` `` quoted identifiers, for the same reason.
+   * Dollar-quoted regions are deliberately NOT skipped: that is precisely where
+   * these literals live.
+   *
+   * The returned text is the RAW between-the-quotes slice, with `''` left
+   * intact. That is not laziness, it is what makes the offsets exact: `''` is a
+   * valid escaped quote inside a SQL string, so the parser reads it correctly
+   * as written, and the slice is a contiguous substring of the file, so
+   * `slice.byteOffset` maps every recovered range back to its true absolute
+   * position. Unescaping first would shorten the text and silently shift every
+   * range after the first escaped quote.
+   */
+  scanExecuteLiterals(content) {
+    const out = [];
+    let i = 0;
+    let lineComment = false;
+    let blockComment = false;
+    let quote = null;
+    let row = 0;
+    let lineStart = 0;
+    const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11;
+    const isWord = (c) => isTagIdentPart(c);
+    const wordAt = (at, word) => {
+      if (at + word.length > content.length) return 0;
+      for (let k = 0; k < word.length; k++) {
+        let c = content.charCodeAt(at + k);
+        if (c >= 97 && c <= 122) c -= 32;
+        if (c !== word.charCodeAt(k)) return 0;
+      }
+      if (at > 0 && isWord(content.charCodeAt(at - 1))) return 0;
+      if (isWord(content.charCodeAt(at + word.length))) return 0;
+      return word.length;
+    };
+    while (i < content.length) {
+      const c = content[i];
+      if (lineComment) {
+        if (c === "\n") {
+          lineComment = false;
+          row++;
+          lineStart = i + 1;
+        }
+        i++;
+        continue;
+      }
+      if (blockComment) {
+        if (c === "*" && content[i + 1] === "/") {
+          blockComment = false;
+          i += 2;
+          continue;
+        }
+        if (c === "\n") {
+          row++;
+          lineStart = i + 1;
+        }
+        i++;
+        continue;
+      }
+      if (quote) {
+        if (c === quote) {
+          if (content[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          quote = null;
+        }
+        if (c === "\n") {
+          row++;
+          lineStart = i + 1;
+        }
+        i++;
+        continue;
+      }
+      if (c === "-" && content[i + 1] === "-") {
+        lineComment = true;
+        i += 2;
+        continue;
+      }
+      if (c === "/" && content[i + 1] === "*") {
+        blockComment = true;
+        i += 2;
+        continue;
+      }
+      if (c === "'" || c === '"' || c === "`") {
+        quote = c;
+        i++;
+        continue;
+      }
+      if (isWord(content.charCodeAt(i))) {
+        const len = wordAt(i, "EXECUTE");
+        if (len) {
+          let j = i + len;
+          while (j < content.length && isSpace(content.charCodeAt(j))) j++;
+          const imm = wordAt(j, "IMMEDIATE");
+          if (imm) {
+            j += imm;
+            while (j < content.length && isSpace(content.charCodeAt(j))) j++;
+          }
+          if (content[j] === "'") {
+            let k = j + 1;
+            let closed = false;
+            while (k < content.length) {
+              if (content[k] === "'") {
+                if (content[k + 1] === "'") {
+                  k += 2;
+                  continue;
+                }
+                closed = true;
+                break;
+              }
+              if (content[k] === "\n") {
+                row++;
+                lineStart = k + 1;
+              }
+              k++;
+            }
+            if (closed) {
+              const text = content.slice(j + 1, k);
+              if (text.length > 0) out.push({ text, start: j + 1 });
+              i = k + 1;
+              continue;
+            }
+          }
+        }
+      }
+      if (c === "\n") {
+        row++;
+        lineStart = i + 1;
+      }
+      i++;
+    }
+    void lineStart;
+    return out;
+  }
+  /** 0-based row of an absolute offset. */
+  rowOf(content, offset) {
+    let row = 0;
+    for (let i = 0; i < offset && i < content.length; i++) {
+      if (content[i] === "\n") row++;
+    }
+    return row;
+  }
+  /**
+   * The EXECUTE-literal pass: re-parse each literal's contents as SQL and let
+   * the ordinary extraction path run over it.
+   *
+   * Structurally identical to `runResync`, and for the same reasons: the same
+   * parser, `state.slice` for absolute offsets, and `declarationKeys` making it
+   * strictly additive. A declaration that the main pass or the resync already
+   * emitted cannot be emitted again, so this pass can only add.
+   */
+  runExecuteScan(content, state) {
+    const literals = this.scanExecuteLiterals(content);
+    if (literals.length === 0) return;
+    state.ambiguity.executeLiterals = literals.length;
+    let parser = null;
+    try {
+      parser = this.acquireParser();
+    } catch {
+      state.ambiguity.executeSkipped = literals.length;
+      return;
+    }
+    if (!parser) {
+      state.ambiguity.executeSkipped = literals.length;
+      return;
+    }
+    const savedSlice = state.slice;
+    try {
+      for (const lit of literals) {
+        let tree;
+        try {
+          tree = parser.parse(lit.text);
+        } catch {
+          state.ambiguity.executeSkipped++;
+          continue;
+        }
+        if (!tree?.rootNode) {
+          state.ambiguity.executeSkipped++;
+          continue;
+        }
+        const before = state.symbols.length;
+        const at = this.lineColumnAt(content, lit.start);
+        state.slice = { byteOffset: lit.start, rowOffset: at.row, columnOffset: at.column };
+        this.processRoot(tree.rootNode, state);
+        state.ambiguity.executeRecovered += state.symbols.length - before;
+        state.slice = savedSlice;
+        tree.delete?.();
+      }
+    } catch {
+      state.ambiguity.executeSkipped++;
+    } finally {
+      state.slice = savedSlice;
+    }
+  }
+  /**
+   * Hand the analyzer the grammar it should re-parse with.
+   *
+   * `analyze` is synchronous and `Language.load` is not, so the resync pass
+   * cannot build its own parser on the first file it sees. The engine calls this
+   * in `parseRaw` — it has already loaded the SQL grammar for the file it is
+   * parsing — and any harness that drives the analyzer directly can do the same,
+   * which is what keeps the resync visible to the fixture lane instead of
+   * silently inert. Without a grammar the resync is skipped and counted in
+   * `ambiguity.resyncSkipped`; the main pass is unaffected either way.
+   */
+  static setGrammar(language, ParserCtor) {
+    if (!language) return;
+    _RealSqlAnalyzer._language = language;
+    if (ParserCtor) globalThis.__bbTreeSitterParser = ParserCtor;
+    _RealSqlAnalyzer._parser = null;
+  }
+  static _language = null;
+  static _parser = null;
+  static _loading = false;
+  /** The parser is built lazily and reused: a file that parsed cleanly must not
+   *  pay for a second parse, and a clean file never asks for one at all. */
+  acquireParser() {
+    if (_RealSqlAnalyzer._parser) return _RealSqlAnalyzer._parser;
+    const language = _RealSqlAnalyzer._language;
+    if (language) {
+      const ParserCtor = globalThis.__bbTreeSitterParser;
+      if (ParserCtor) {
+        try {
+          const parser = new ParserCtor();
+          parser.setLanguage(language);
+          _RealSqlAnalyzer._parser = parser;
+          return parser;
+        } catch {
+          return null;
+        }
+      }
+    }
+    this.kickoffGrammarLoad();
+    return null;
+  }
+  /** One-shot async load, so a harness that never called `setGrammar` still gets
+   *  the resync from the second SQL file onwards. */
+  kickoffGrammarLoad() {
+    if (_RealSqlAnalyzer._loading || _RealSqlAnalyzer._language) return;
+    _RealSqlAnalyzer._loading = true;
+    void (async () => {
+      try {
+        const wasm = await import("./wasm-NMWO3WXY.js");
+        const mod = await wasm.loadWebTreeSitter();
+        const ParserCtor = mod?.Parser ?? mod?.default?.Parser ?? mod?.default;
+        const LanguageCtor = mod?.Language ?? mod?.default?.Language;
+        if (ParserCtor) globalThis.__bbTreeSitterParser = ParserCtor;
+        if (!LanguageCtor) return;
+        const { readFileSync } = await import("fs");
+        const bytes = new Uint8Array(readFileSync(wasm.resolveWasmAsset("tree-sitter-sql.wasm")));
+        const grammar = await LanguageCtor.load(bytes);
+        _RealSqlAnalyzer.setGrammar(grammar);
+      } catch {
+      } finally {
+        _RealSqlAnalyzer._loading = false;
+      }
+    })();
+  }
+  /**
+   * Split a SQL file into top-level statements on `;`, honouring the four
+   * contexts a `;` can appear in without ending a statement: a single-quoted
+   * string, a double-quoted identifier, a `--`/`/* *\/` comment, and a
+   * dollar-quoted string. The dollar-quote case is the one that matters — a
+   * PL/pgSQL body is full of `;` and splitting inside it would hand the resync
+   * a fragment that cannot parse.
+   */
+  splitTopLevelStatements(content) {
+    const out = [];
+    let start = 0;
+    let i = 0;
+    let quote = null;
+    let lineComment = false;
+    let blockComment = false;
+    let dollar = null;
+    const origin = this.lineColumnAt(content, 0);
+    const push = (endExclusive) => {
+      const text = content.slice(start, endExclusive);
+      if (text.trim().length === 0) return;
+      const at = this.lineColumnAt(content, start);
+      out.push({ text, start, row: at.row, column: start === 0 ? origin.column + at.column : at.column });
+    };
+    while (i < content.length) {
+      const c = content[i];
+      if (lineComment) {
+        if (c === "\n") lineComment = false;
+        i++;
+        continue;
+      }
+      if (blockComment) {
+        if (c === "*" && content[i + 1] === "/") {
+          blockComment = false;
+          i += 2;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (dollar) {
+        if (content.startsWith(dollar, i)) {
+          i += dollar.length;
+          dollar = null;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (quote) {
+        if (c === "\\") {
+          i += 2;
+          continue;
+        }
+        if (c === quote) {
+          if (content[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          quote = null;
+        }
+        i++;
+        continue;
+      }
+      if (c === "-" && content[i + 1] === "-") {
+        lineComment = true;
+        i += 2;
+        continue;
+      }
+      if (c === "/" && content[i + 1] === "*") {
+        blockComment = true;
+        i += 2;
+        continue;
+      }
+      if (c === "'" || c === '"' || c === "`") {
+        quote = c;
+        i++;
+        continue;
+      }
+      if (c === "$") {
+        const tag = dollarTagAt(content, i);
+        if (tag) {
+          dollar = tag;
+          i += tag.length;
+          continue;
+        }
+      }
+      if (c === ";") {
+        i++;
+        push(i);
+        start = i;
+        continue;
+      }
+      i++;
+    }
+    if (start < content.length) push(content.length);
+    return out;
+  }
+  /** 0-based row and 0-based column of a byte offset. */
+  lineColumnAt(content, offset) {
+    let row = 0;
+    let lineStart = 0;
+    for (let i = 0; i < offset && i < content.length; i++) {
+      if (content[i] === "\n") {
+        row++;
+        lineStart = i + 1;
+      }
+    }
+    return { row, column: offset - lineStart };
+  }
+  // ---------------------------------------------------------------- walk
+  processRoot(node, state) {
+    const stack = [];
+    for (let i = node.namedChildCount - 1; i >= 0; i--) {
+      const child = node.namedChild(i);
+      if (child) stack.push(child);
+    }
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.type === "transaction" || current.type === "block") {
+        this.addPattern(current.type === "transaction" ? "Transaction Management" : "Procedural Block", state);
+        this.bumpComplexity(current, state);
+        for (let i = current.namedChildCount - 1; i >= 0; i--) {
+          const child = current.namedChild(i);
+          if (child && (child.type === "statement" || child.type === "block" || child.type === "transaction")) stack.push(child);
+        }
+        continue;
+      }
+      state.localCtes.clear();
+      if (current.type === "statement") {
+        for (const cte of this.descendants(current, "cte")) {
+          const nm = this.firstIdentifier(cte, state);
+          if (nm) state.localCtes.add(this.identifierName(nm, state));
+        }
+      }
+      if (current.type === "statement") state.nestedStatements.add(current.startIndex + state.slice.byteOffset);
+      this.processStatement(current, state, null);
+    }
+    this.sweepDeclarations(node, state);
+  }
+  /**
+   * Every declaration node in the tree, at any depth, each emitted once.
+   *
+   * `program` requires every top-level item to be a `statement`/`block`/
+   * `transaction`, and error recovery routinely buries a declaration inside one
+   * of those: on the corpus's `database/schema.sql` a function whose body the
+   * grammar could not fully parse swallows the rest of the file, and the 158
+   * `CREATE TABLE` nodes after it end up NESTED INSIDE that function's
+   * `function_body` — a declaration inside a declaration. Walking the whole tree
+   * for declaration nodes finds them: 1,644 of 2,336 corpus declarations against
+   * 1,557 for the root-children walk alone.
+   *
+   * The sweep DESCENDS THROUGH declarations rather than stopping at them, which
+   * is the whole point: a `create_table` inside a `create_function` is reachable
+   * only by passing through the function. The earlier version stopped at the first
+   * declaration it met, so every such nested declaration stayed invisible — and
+   * `business_profiles`, `business_rules`, `business_content` and
+   * `business_locations` (the corpus's most-referenced tables) were among the
+   * casualties, 117 edges in the unknown-symbol population of `probe/
+   * unknown-symbols.mts`. `declarationKeys` keeps the walk from dispatching the
+   * same node twice, and `createSymbol`'s identity check makes a re-dispatch
+   * idempotent, so descending is safe and costs one redundant walk of a body.
+   */
+  sweepDeclarations(node, state) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.type === "statement" && !state.nestedStatements.has(current.startIndex + state.slice.byteOffset)) {
+        state.nestedStatements.add(current.startIndex + state.slice.byteOffset);
+        const saved = new Set(state.localCtes);
+        state.localCtes = this.cteScope(current, state);
+        this.processStatement(current, state, null);
+        state.localCtes.clear();
+        state.ambiguity.sweepStatementsDispatched++;
+        for (const name of saved) state.localCtes.add(name);
+      }
+      if (DECLARATION_NODES.has(current.type)) {
+        if (this.markDeclaration(current, state)) {
+          this.dispatchDeclaration(current, state, null);
+          state.ambiguity.sweepDeclarationsRecovered++;
+        }
+      }
+      for (let i = current.namedChildCount - 1; i >= 0; i--) {
+        const child = current.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  processStatement(node, state, owner) {
+    if (node.type === "statement") {
+      const children = this.namedChildren(node);
+      const isQueryPart = (c) => queryTypes.has(c.type) || c.type === "from" || c.type === "cte";
+      if (children.some(isQueryPart)) this.processQuery(node, state, owner);
+      for (const child of children) {
+        if (isQueryPart(child)) continue;
+        this.processStatement(child, state, owner);
+      }
+      return;
+    }
+    if (DECLARATION_NODES.has(node.type)) {
+      const declaredName = this.declarationOwner(node, state);
+      this.processCalls(node, declaredName, state);
+      if (this.markDeclaration(node, state)) this.dispatchDeclaration(node, state, owner);
+      return;
+    }
+    switch (node.type) {
+      case "alter_table":
+        this.addPattern("Schema Evolution (ALTER)", state);
+        this.recordTableTarget(node, "uses", "alter", state);
+        this.processCalls(node, this.referenceLeaf(this.directChild(node, "object_reference"), state) ?? state.fileModuleName, state);
+        this.processAlterTable(node, state);
+        return;
+      case "drop_table":
+      case "drop_view":
+      case "drop_index":
+      case "drop_type":
+      case "drop_schema":
+      case "drop_sequence":
+      case "drop_column":
+      case "drop_constraint":
+      case "drop_function":
+      case "drop_policy":
+        this.addPattern("Schema Evolution (DROP)", state);
+        this.recordTableTarget(node, "uses", "drop", state);
+        return;
+      case "do_statement":
+        this.processDo(node, state);
+        return;
+      case "insert":
+        this.recordDml(node, "insert", state);
+        return;
+      case "update":
+        this.recordDml(node, "update", state);
+        return;
+      case "delete":
+        this.recordDml(node, "delete", state);
+        return;
+      case "select":
+      case "set_operation":
+      case "cte":
+      case "create_query":
+      case "subquery":
+        this.processQuery(node, state, owner);
+        return;
+      case "set_statement":
+      case "reset_statement":
+        this.addPattern("Session Configuration", state);
+        return;
+      case "comment_statement":
+        this.processComment(node, state);
+        return;
+      case "grant_statement":
+      case "revoke_statement":
+        this.processGrant(node, state, node.type === "grant_statement" ? "grant" : "revoke");
+        return;
+      case "transaction":
+      case "block":
+        this.addPattern("Transaction Management", state);
+        this.bumpComplexity(node, state);
+        return;
+      // No `merge` / `truncate` / `copy` arms: those grammar rules are HIDDEN
+      // (`_merge_statement`, `_truncate_statement`, `_copy_statement`), so the
+      // keywords and references inline into `statement` and a node of those
+      // types can never exist. Measured over the corpus and the dialect battery.
+      // The `keyword_*` arms below are the only real routes.
+      case "keyword_merge":
+        this.processInlineMerge(node, state);
+        return;
+      case "keyword_truncate":
+        this.processInlineTruncate(node, state);
+        return;
+      case "keyword_copy":
+        this.processInlineCopy(node, state);
+        return;
+      case "returning":
+        this.processReturning(node, state);
+        return;
+      case "psql_meta_command":
+        this.processPsqlMetaCommand(node, state);
+        return;
+      default:
+        return;
+    }
+  }
+  /** Record that this declaration node has been dispatched, so neither the main
+   *  walk nor the sweep can emit it twice, and so the sweep can report how much
+   *  it contributed that the main walk could not reach.
+   *
+   *  THE KEY IS IN FILE COORDINATES, and that is load-bearing rather than
+   *  cosmetic. `node.startIndex` is relative to the PARSE that produced the node,
+   *  and three of this analyzer's passes produce nodes from a re-parsed SLICE: the
+   *  main walk parses the whole file (so its offsets are already file offsets),
+   *  the resync pass parses one statement at a time, and the EXECUTE-literal pass
+   *  parses the text between a literal's quotes. Keyed on the raw `startIndex`,
+   *  a declaration inside an EXECUTE literal collided with whatever the main pass
+   *  had already seen at the same SLICE-LOCAL offset, and was silently dropped.
+   *  `state.slice.byteOffset` maps a slice node back to its true position — the
+   *  raw literal is handed to the parser with its `''` escapes intact precisely so
+   *  it stays a contiguous substring of the file and that mapping holds — so the
+   *  file coordinate is both correct and unique.
+   *
+   *  This was invisible while `processStatement` called `markDeclaration` and then
+   *  dispatched regardless of the answer: the redundant dispatch is what was
+   *  masking the collision. Making the guard load-bearing (`if (markDeclaration(…))`)
+   *  and correct are the same piece of work, and `validation/m14/fixtures/sql/
+   *  sqld11` is what caught it — its `quoted_name` table lives inside an EXECUTE
+   *  literal and vanished the moment the guard started meaning what it says. */
+  /**
+  * The name a declaration's own invocations belong to.
+  *
+  * A function call inside a `CREATE FUNCTION` body is a call BY that function; one
+  * inside a table's column `DEFAULT` is a call BY that table. `global` is the
+  * analyzer's synthetic owner and is only correct where there is no declaration to
+  * attribute to — which is why the anonymous-statement path uses it and this does
+  * not.
+  */
+  declarationOwner(node, state) {
+    const object = this.directChild(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return state.fileModuleName;
+    return this.identifierName(nameNode, state) || state.fileModuleName;
+  }
+  markDeclaration(node, state) {
+    const key = `${node.startIndex + state.slice.byteOffset}:${node.type}`;
+    if (state.declarationKeys.has(key)) return false;
+    state.declarationKeys.add(key);
+    return true;
+  }
+  dispatchDeclaration(node, state, owner) {
+    if (REPLACEABLE_DECLARATIONS.has(node.type)) this.recordReplacement(node, state);
+    switch (node.type) {
+      case "create_table":
+        this.processTable(node, state);
+        return;
+      case "create_view":
+      case "create_materialized_view":
+        this.processView(node, state);
+        return;
+      case "create_index":
+        this.processIndex(node, state);
+        return;
+      case "create_function":
+        this.processFunction(node, state);
+        return;
+      case "create_procedure":
+        this.processProcedure(node, state);
+        return;
+      case "create_trigger":
+        this.processTrigger(node, state);
+        return;
+      case "create_type":
+        this.processType(node, state);
+        return;
+      case "create_schema":
+        this.processNamedContainer(node, ASTEngine.SymbolKind.Namespace, "schema", state);
+        return;
+      case "create_sequence":
+        this.processNamedContainer(node, ASTEngine.SymbolKind.Constant, "sequence", state);
+        return;
+      case "create_role":
+        this.processNamedContainer(node, ASTEngine.SymbolKind.Namespace, "role", state);
+        return;
+      case "create_extension":
+        this.processExtension(node, state);
+        return;
+      case "create_database":
+        this.processDatabase(node, state);
+        return;
+      case "create_policy":
+        this.processPolicy(node, state);
+        return;
+      case "do_statement":
+        this.processDo(node, state);
+        return;
+      default:
+        return;
+    }
+  }
+  /**
+   * `CREATE OR REPLACE FUNCTION f` when this file ALREADY declared `f` of the
+   * same kind: the second declaration replaces the first.
+   *
+   * The scope is exactly that, and each clause of it is a measured boundary:
+   *
+   *   - SAME FILE only. 666 OR REPLACE declarations exist over the 1,460-file
+   *     census and all but a handful replace a declaration made in a DIFFERENT
+   *     file — a migration chain re-declaring what the previous migration
+   *     declared. A per-file analyzer cannot see those, so this emits for the 15
+   *     events it can and declares the rest rather than pretending to them.
+   *   - SAME KIND only. Keyed on the name alone, `CREATE FUNCTION
+   *     hdb_catalog.f()` at line 7 and `CREATE TRIGGER f` at line 25 of Hasura's
+   *     `10_to_11.sql` counted as a redefinition; they are two different objects
+   *     that happen to share a name, and the probe that produced that number is
+   *     the same shape-versus-role error this lane has now hit three times.
+   *   - `OR REPLACE` REQUIRED on the later declaration. Measured 20 same-kind
+   *     re-declarations carry no `OR REPLACE` and PostgreSQL rejects those
+   *     outright ("relation already exists"), so calling them overrides would
+   *     assert a replacement the language does not perform.
+   *
+   * The SOURCE is the file's own `module` symbol, this lane's spelling for a file-level fact
+   * about a named object (`uses <file>->t` for a DML target, `references <file>->t` for
+   * `GRANT … ON t`). It was the literal `global` until the file became a symbol; see
+   * `fileModuleNameFor` for the measurement. The source and the target cannot be the same
+   * object: SQL replacement is same-name, so any source/target pair would collapse to a
+   * self-loop `overrides f->f` that tells a graph consumer nothing about which
+   * declaration replaced which. The lines that do distinguish them ride in
+   * metadata instead, which is where a consumer can read them.
+   */
+  recordReplacement(node, state) {
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    const name = this.identifierName(nameNode, state);
+    const nameKey = `${node.type}:${name}`;
+    const key = `${nameKey}${this.routineSignature(node, state)}`;
+    const line = node.startPosition.row + state.slice.rowOffset + 1;
+    const replaces = this.directChild(node, "keyword_replace") !== null;
+    if (!replaces) {
+      if (!state.redeclared.has(key)) state.redeclared.set(key, line);
+      state.routineNames.add(nameKey);
+      return;
+    }
+    const prior = state.redeclared.get(key);
+    if (prior === void 0) {
+      if (state.routineNames.has(nameKey)) state.ambiguity.overloadNotReplacementSkipped++;
+      state.redeclared.set(key, line);
+      state.routineNames.add(nameKey);
+      return;
+    }
+    this.addRelationship(ASTEngine.RelationshipType.Overrides, state.fileModuleName, name, state, {
+      orReplace: true,
+      redefinition: true,
+      scope: "file",
+      priorLine: prior,
+      replacementLine: line
+    });
+    state.redeclared.set(key, line);
+    state.routineNames.add(nameKey);
+    state.ambiguity.overridesEmitted++;
+  }
+  /**
+   * The argument-type list that makes a ROUTINE's identity, as a key suffix.
+   *
+   * PostgreSQL does not identify a function by its name. `CREATE OR REPLACE
+   * FUNCTION f(a int)` and `CREATE OR REPLACE FUNCTION f(a int, b int)` are two
+   * functions that coexist, which is why `\df f` prints two rows — so an
+   * `overrides` edge between them asserts a replacement the language never
+   * performs. Only the INPUT types participate: `RETURNS TABLE (…)` declares OUT
+   * parameters and is not part of the call signature.
+   *
+   * Returns `""` for every non-routine kind. A VIEW has no arguments and no
+   * overloading, so `CREATE OR REPLACE VIEW v` twice really is one object
+   * replacing itself, and the key stays name-only exactly as before.
+   *
+   * The types are lowercased and comma-joined so a spelling difference that
+   * PostgreSQL does not distinguish (`INTEGER` / `integer`) cannot split one
+   * identity into two keys.
+   */
+  routineSignature(node, state) {
+    if (node.type !== "create_function" && node.type !== "create_procedure") return "";
+    const args = this.directChild(node, "function_arguments");
+    if (!args) return "()";
+    const types = [];
+    for (const argument of this.namedChildren(args)) {
+      if (argument.type !== "function_argument") continue;
+      const param = this.functionArgument(argument, state);
+      if (param?.direction === "out") continue;
+      types.push(this.argumentTypeText(argument, state).toLowerCase());
+    }
+    return `(${types.join(",")})`;
+  }
+  /**
+   * One parameter's declared type, read even when the parameter has NO NAME.
+   *
+   * WHY THIS IS NOT `functionArgument(...).type`. A PostgreSQL parameter may be
+   * written without a name — `CREATE FUNCTION f(integer, text)` is legal and is
+   * the form the corpus's own overloads use. `functionArgument` looks for the
+   * parameter's name first and returns `null` when there is none, so reading the
+   * type through it collapsed every unnamed parameter to the empty string: the
+   * 60-file incoming-gate population's remaining `overrides` edges after the
+   * first signature fix were `overloaded_unnamed_param` (5 declarations),
+   * `overloaded_unnamed_json_jsonb_param` (3), `color` (2) and `isodate` (2) —
+   * every one of them a set of unnamed-parameter overloads whose types the key
+   * could not see.
+   *
+   * The discriminator is CHILD ORDER, not a search, and that is the pinned
+   * grammar's own layout: the mode keyword (if any) comes first, then the
+   * parameter NAME if it has one, then the type. `firstIdentifier` cannot be used
+   * to find the name, because an unnamed `object_reference` type such as
+   * `my_type` contains an `identifier` descendant of its own and would be
+   * mistaken for the parameter's name — the same shape-versus-role error that
+   * produced the fabricated FK on every custom-typed column (SQL-D1).
+   *
+   * The `array_size_definition` suffix is KEPT: PostgreSQL treats `integer[]` and
+   * `integer` as different input argument types, so dropping the `[]` would merge
+   * two distinct routines.
+   */
+  argumentTypeText(argument, state) {
+    const custom = argument.childForFieldName?.("custom_type");
+    if (custom) {
+      const sized = this.namedChildren(argument).some((c) => c.type === "array_size_definition");
+      return `${this.referenceText(custom, state)}${sized ? "[]" : ""}`;
+    }
+    const children = this.namedChildren(argument);
+    let i = 0;
+    while (i < children.length && MODE_KEYWORD_TYPES.has(children[i].type)) i++;
+    if (children[i]?.type === "identifier") {
+      return this.spanAfter(argument, children[i], (c) => c.type === "keyword_default" || c.type === "literal");
+    }
+    const parts = [];
+    for (; i < children.length; i++) {
+      const t = children[i].text.trim();
+      if (t.length > 0) parts.push(t);
+    }
+    return parts.join(" ");
+  }
+  // ---------------------------------------------------------------- tables
+  processTable(node, state) {
+    const object = this.directChild(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    const table = this.createSymbol(
+      this.identifierName(nameNode, state),
+      ASTEngine.SymbolKind.Class,
+      nameNode,
+      null,
+      state,
+      {
+        type: "table",
+        isSchemaEntity: true,
+        qualifiedName: object ? this.referenceText(object, state) : this.identifierName(nameNode, state)
+      }
+    );
+    const childOwner = state.symbols.find((s) => s.name === table.name && s.metadata?.type === "table");
+    for (const clause of this.namedChildren(node).filter((c) => c.type === "inherit_clause")) {
+      const parents = this.namedChildren(clause).filter((c) => c.type === "object_reference").map((c) => this.identifierName(this.referenceNameNode(c) ?? c, state)).filter((n) => n.length > 0);
+      if (!childOwner) continue;
+      for (const parent of parents) {
+        this.addRelationship(ASTEngine.RelationshipType.Extends, table.name, parent, state, {
+          clause: "inherits",
+          evidenceClass: "structural"
+        }, this.range(clause, state).startLine);
+      }
+    }
+    const definitions = this.directChild(node, "column_definitions");
+    if (definitions) {
+      for (const column of this.namedChildren(definitions)) {
+        if (column.type === "column_definition") this.processColumn(column, table, state);
+      }
+      const tableConstraints = this.directChild(definitions, "constraints");
+      if (tableConstraints) {
+        for (const child of this.namedChildren(tableConstraints)) {
+          if (child.type === "constraint") {
+            this.processConstraint(child, table, state);
+          } else {
+            const recovered = this.recoverNamedConstraint(child);
+            if (recovered) this.processConstraint(recovered, table, state);
+          }
+        }
+      }
+    }
+    this.addPattern("Tables", state);
+  }
+  /**
+   * Is this column name a reserved word that error recovery re-emitted?
+   *
+   * Only an UNQUOTED name can be one: a quoted `"like"` arrives as a `literal` and
+   * is a legal column name in every dialect, so the guard keys on the node type as
+   * well as the text. See `RESERVED_AS_COLUMN_NAME` for the measured counts and for
+   * why this list is two words and not the whole keyword set.
+   */
+  reservedColumnName(node) {
+    if (node.type !== "identifier") return false;
+    if (!RESERVED_AS_COLUMN_NAME.has(node.text.toLowerCase())) return false;
+    return true;
+  }
+  /**
+   * A `CONSTRAINT <name> FOREIGN KEY` the grammar could not build a `constraint`
+   * node for arrives as an ERROR whose own children are still
+   * `keyword_constraint` + `identifier`. Rebuild a constraint-shaped view of it
+   * so `processConstraint` has a node to read, and say so in the symbol's
+   * metadata — the recovery is deterministic, but it is a recovery.
+   */
+  recoverNamedConstraint(node) {
+    if (node.type !== "ERROR" && !node.hasError) return null;
+    const text = node.text;
+    if (!opensWithConstraintKeyword(text)) return null;
+    const children = this.namedChildren(node);
+    const keywordAt = children.findIndex((c) => c.type === "keyword_constraint");
+    if (keywordAt < 0) return null;
+    const nameAt = children.findIndex((c, i) => i > keywordAt && identifierTypes.has(c.type));
+    if (nameAt < 0) return null;
+    const rest = this.descendants(node, "constraint")[0];
+    void rest;
+    return node;
+  }
+  processColumn(node, table, state) {
+    const rawName = node.childForFieldName?.("name") ?? this.firstIdentifier(node);
+    if (!rawName || !identifierTypes.has(rawName.type)) return;
+    if (this.reservedColumnName(rawName)) {
+      state.ambiguity.reservedNameSymbolsSuppressed++;
+      return;
+    }
+    let isPrimaryKey = false;
+    let isUnique = false;
+    let isNullable = true;
+    let references;
+    let referenceNode = null;
+    const children = this.namedChildren(node);
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type === "keyword_primary") isPrimaryKey = true;
+      if (child.type === "keyword_unique") isUnique = true;
+      if (child.type === "keyword_not" && children[i + 1]?.type === "keyword_null") isNullable = false;
+      if (child.type === "object_reference" && children[i - 1]?.type === "keyword_references") {
+        referenceNode = child;
+        references = this.referenceLeaf(child, state);
+      }
+    }
+    const column = this.createSymbol(
+      this.identifierName(rawName, state),
+      ASTEngine.SymbolKind.Property,
+      rawName,
+      table,
+      state,
+      {
+        type: "column",
+        sqlType: this.columnType(node, state),
+        isPrimaryKey,
+        isUnique,
+        isNullable,
+        references
+      }
+    );
+    this.addRelationship(ASTEngine.RelationshipType.Contains, table.name, column.name, state, { memberKind: ASTEngine.SymbolKind.Property }, this.range(rawName, state).startLine, table.id, column.id);
+    if (isPrimaryKey) this.addPattern("Primary Key Constraint", state);
+    if (isUnique) this.addPattern("Unique Constraint", state);
+    if (references && referenceNode) {
+      this.addPattern("Foreign Key Constraints", state);
+      this.addRelationship(ASTEngine.RelationshipType.References, table.name, references, state, {
+        constraint: "foreign_key",
+        column: column.name
+      });
+    }
+  }
+  /**
+   * A column's declared type.
+   *
+   * The grammar puts `type` on the type node and, for an array, on
+   * `array_size_definition` as well — `childForFieldName("type")` returns only
+   * the first, so `c int[]` reported `"int"`. Both fields are read and the
+   * array suffix appended. A user-defined type arrives as `custom_type` (which
+   * `childForFieldName("type")` also resolves) and is returned whole, so
+   * `my_schema.my_type` and `character varying(20)` survive intact.
+   */
+  columnType(node, state) {
+    const parts = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const field = node.fieldNameForChild(i);
+      if (field !== "type" && field !== "custom_type") continue;
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === "identifier" || child.type === "literal") continue;
+      if (parts.some((p) => p.startIndex === child.startIndex)) continue;
+      parts.push({ text: child.text, startIndex: child.startIndex, endIndex: child.endIndex });
+    }
+    if (parts.length === 0) {
+      const fallback = node.childForFieldName?.("type") ?? node.childForFieldName?.("custom_type");
+      if (fallback) parts.push({ text: fallback.text, startIndex: fallback.startIndex, endIndex: fallback.endIndex });
+    }
+    void state;
+    if (parts.length === 0) return void 0;
+    parts.sort((a, b) => a.startIndex - b.startIndex);
+    let out = "";
+    for (const part of parts) {
+      if (out && part.startIndex > parts[parts.indexOf(part) - 1].endIndex) out += " ";
+      out += part.text;
+    }
+    return out;
+  }
+  processConstraint(node, table, state) {
+    const children = this.namedChildren(node);
+    const keywordAt = children.findIndex((c) => c.type === "keyword_constraint");
+    let nameNode = null;
+    if (keywordAt >= 0) {
+      nameNode = children.slice(keywordAt + 1).find((c) => identifierTypes.has(c.type)) ?? null;
+    } else {
+      nameNode = node.childForFieldName?.("name") ?? null;
+    }
+    if (!nameNode && keywordAt < 0) {
+      const cand = this.directChild(node, "identifier");
+      const cols = children.find((c) => c.type === "ordered_columns" || c.type === "column");
+      if (cand && (!cols || cand.startIndex < cols.startIndex)) nameNode = cand;
+    }
+    const hasPrimary = this.containsChildType(node, "keyword_primary");
+    const hasUnique = this.containsChildType(node, "keyword_unique");
+    const referenceNode = this.referencesTarget(node);
+    const reference = referenceNode ? this.referenceLeaf(referenceNode, state) : void 0;
+    const recovered = node.type === "ERROR";
+    if (nameNode) {
+      const constraint = this.createSymbol(
+        this.identifierName(nameNode, state),
+        ASTEngine.SymbolKind.Constant,
+        nameNode,
+        table,
+        state,
+        {
+          type: "constraint",
+          constraintKind: reference ? "foreign_key" : hasPrimary ? "primary_key" : hasUnique ? "unique" : "check",
+          ...recovered ? { recoveredFromErrorRegion: true } : {}
+        }
+      );
+      this.addRelationship(ASTEngine.RelationshipType.Contains, table.name, constraint.name, state, { memberKind: ASTEngine.SymbolKind.Constant }, this.range(nameNode, state).startLine, table.id, constraint.id);
+    }
+    if (hasPrimary) this.addPattern("Primary Key Constraint", state);
+    if (hasUnique) this.addPattern("Unique Constraint", state);
+    if (reference) {
+      this.addPattern("Foreign Key Constraints", state);
+      this.addRelationship(ASTEngine.RelationshipType.References, table.name, reference, state, { constraint: "foreign_key" });
+    }
+  }
+  /** The `object_reference` a `REFERENCES` clause points at, if there is one. */
+  referencesTarget(node) {
+    const children = this.namedChildren(node);
+    for (let i = 0; i < children.length; i++) {
+      if (children[i].type === "keyword_references" && children[i + 1]?.type === "object_reference") {
+        return children[i + 1];
+      }
+    }
+    return null;
+  }
+  // ---------------------------------------------------------------- views / indexes
+  processView(node, state) {
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    const kind = node.type === "create_materialized_view" ? "materialized_view" : "view";
+    const view = this.createSymbol(
+      this.identifierName(nameNode, state),
+      ASTEngine.SymbolKind.Class,
+      nameNode,
+      null,
+      state,
+      { type: kind, isSchemaEntity: true, qualifiedName: object ? this.referenceText(object, state) : this.identifierName(nameNode, state) }
+    );
+    this.addPattern(kind === "view" ? "Views" : "Materialized Views", state);
+    const query = this.firstDescendant(node, "create_query");
+    if (query) this.processQuery(query, state, view);
+  }
+  processIndex(node, state) {
+    const identifiers = this.namedChildren(node).filter((c) => c.type === "identifier" || c.type === "literal");
+    const nameNode = identifiers[0] ?? this.firstIdentifier(node);
+    if (!nameNode) return;
+    const object = this.firstDescendant(node, "object_reference");
+    const tableName = object ? this.referenceLeaf(object, state) : void 0;
+    let hasOwnName = false;
+    for (let i = 0; i < node.childCount; i++) {
+      if (node.fieldNameForChild(i) === "column") {
+        hasOwnName = true;
+        break;
+      }
+    }
+    if (!hasOwnName) {
+      state.ambiguity.unnamedIndexSkipped++;
+      return;
+    }
+    const name = this.identifierName(nameNode, state);
+    const owner = tableName ? this.existingSymbol(tableName, ASTEngine.SymbolKind.Class, state) : void 0;
+    this.createSymbol(name, ASTEngine.SymbolKind.Constant, nameNode, owner ?? null, state, {
+      type: "index",
+      indexName: name,
+      table: tableName,
+      columns: this.identifierTexts(this.firstDescendant(node, "index_fields"), state),
+      ...tableName && !owner ? { ownerDeclaredLater: true } : {}
+    });
+    this.addPattern("Custom Indexes", state);
+    if (tableName) {
+      this.addRelationship(ASTEngine.RelationshipType.References, name, tableName, state, { dependency: true, indexOn: tableName });
+      this.addRelationship(ASTEngine.RelationshipType.Contains, tableName, name, state, { memberKind: ASTEngine.SymbolKind.Constant }, this.range(nameNode, state).startLine, owner?.id ?? tableName, owner ? `${owner.id}.${name}` : name);
+      if (state.metadata.performanceScore !== void 0) state.metadata.performanceScore += 10;
+    }
+  }
+  // ---------------------------------------------------------------- functions
+  processFunction(node, state) {
+    this.processCallable(node, state, { kind: ASTEngine.SymbolKind.Function, pattern: "Stored Functions" });
+  }
+  processProcedure(node, state) {
+    this.processCallable(node, state, { kind: ASTEngine.SymbolKind.Function, pattern: "Procedures", type: "procedure" });
+  }
+  processCallable(node, state, opts) {
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    const name = this.identifierName(nameNode, state);
+    const params = this.callableParameters(node, state);
+    const returns = this.returnTypeText(node, state);
+    const returnsTable = this.returnsTableNode(node);
+    this.createSymbol(name, opts.kind, nameNode, null, state, {
+      ...opts.type ? { type: opts.type } : {},
+      functionName: name,
+      qualifiedName: object ? this.referenceText(object, state) : name,
+      sqlFunction: true,
+      ...returnsTable ? { returnsTable: true } : {}
+    }, { parameters: params, returnType: returns });
+    this.addPattern(opts.pattern, state);
+    this.processQueryDependencies(node, null, state, name);
+    this.processCalls(node, name, state);
+  }
+  /**
+   * A parameter's declared type, read from the grammar's own layout.
+   *
+   * `function_argument` has NO `type` field at all — only `custom_type`, and only
+   * when the type is a user-defined name. The builtin type is simply the child
+   * after the parameter's name, which is why the previous accessor (matching
+   * `type` or `keyword_*`) lost `integer`, `bigint`, `numeric`, `varchar`,
+   * `timestamp` and `uuid` — 69 parameters on the corpus, and inconsistently:
+   * `UUID` and `TEXT` came through, `bigint` did not.
+   *
+   * It also matched the mode keyword first, so `IN a integer` produced
+   * `{ name: "a", type: "IN" }` — a fabricated type. Everything from the name to
+   * the DEFAULT is the type; the mode keyword sits BEFORE the name and so falls
+   * outside the span on its own.
+   */
+  callableParameters(node, state) {
+    const params = [];
+    const args = this.directChild(node, "function_arguments");
+    if (args) {
+      for (const argument of this.namedChildren(args)) {
+        if (argument.type !== "function_argument") continue;
+        const param = this.functionArgument(argument, state);
+        if (param) params.push(param);
+      }
+    }
+    const table = this.returnsTableNode(node);
+    if (table) {
+      for (const column of this.namedChildren(table)) {
+        if (column.type !== "column_definition") continue;
+        const nameNode = column.childForFieldName?.("name") ?? this.firstIdentifier(column);
+        if (!nameNode) continue;
+        params.push({
+          name: this.identifierName(nameNode, state),
+          type: this.columnType(column, state),
+          direction: "out"
+        });
+      }
+    }
+    return params;
+  }
+  functionArgument(argument, state) {
+    const nameNode = argument.childForFieldName?.("name") ?? this.firstIdentifier(argument);
+    if (!nameNode) return null;
+    const children = this.namedChildren(argument);
+    const nameIndex = children.findIndex((c) => c.startIndex === nameNode.startIndex);
+    const hasDefault = children.some((c) => c.type === "keyword_default");
+    const type = this.spanAfter(argument, nameNode, (c) => c.type === "keyword_default" || c.type === "literal");
+    const before = nameIndex >= 0 ? children.slice(0, nameIndex) : [];
+    const modeNode = before.find((c) => c.type === "keyword_inout") ?? before.find((c) => c.type === "keyword_in") ?? before.find((c) => c.type === "keyword_out");
+    const param = { name: this.identifierName(nameNode, state) };
+    if (type) param.type = type;
+    if (hasDefault) param.isOptional = true;
+    const direction = modeNode?.type === "keyword_inout" ? "inout" : modeNode?.type === "keyword_in" ? "in" : modeNode?.type === "keyword_out" ? "out" : void 0;
+    if (direction) param.direction = direction;
+    return param;
+  }
+  /**
+   * The source text between `fromExclusive` and the first child that `stopAt`
+   * accepts, read out of the container's own text so the spacing is the
+   * source's own (`int[]`, not `int []`; `numeric(10,2)`, not `numeric (10,2)`).
+   */
+  spanAfter(container, fromExclusive, stopAt) {
+    const from = fromExclusive.endIndex - container.startIndex;
+    let to = container.endIndex - container.startIndex;
+    for (const child of this.namedChildren(container)) {
+      if (child.startIndex < fromExclusive.endIndex) continue;
+      if (stopAt(child)) {
+        to = child.startIndex - container.startIndex;
+        break;
+      }
+    }
+    if (to <= from) return "";
+    return container.text.substring(from, to).trim();
+  }
+  /** The `column_definitions` of a `RETURNS TABLE (...)`, if that is the return. */
+  returnsTableNode(node) {
+    const children = this.namedChildren(node);
+    const returnsAt = children.findIndex((c) => c.type === "keyword_returns");
+    if (returnsAt < 0) return null;
+    if (children[returnsAt + 1]?.type !== "keyword_table") return null;
+    return children[returnsAt + 2]?.type === "column_definitions" ? children[returnsAt + 2] : null;
+  }
+  /**
+   * Everything after `RETURNS`, up to the body or the language clause.
+   *
+   * The previous version took the single next sibling, which read `int` for
+   * `RETURNS int[]` (the `[]` is a following `array_size_definition`), `SETOF`
+   * for `RETURNS SETOF record`, and `TABLE` for `RETURNS TABLE (a int, b text)`.
+   */
+  returnTypeText(node, state) {
+    const children = this.namedChildren(node);
+    const returnsAt = children.findIndex((c) => c.type === "keyword_returns");
+    if (returnsAt < 0) return void 0;
+    void state;
+    return this.spanAfter(
+      node,
+      children[returnsAt],
+      (c) => c.type === "function_body" || c.type === "function_language" || c.type === "function_volatility" || c.type === "function_strictness"
+    ) || void 0;
+  }
+  // ---------------------------------------------------------------- triggers
+  /**
+   * A trigger's name, its table, and the function it executes.
+   *
+   * These were read as the FIRST THREE `object_reference`s anywhere in the
+   * subtree. A `WHEN (old.a <> new.a)` clause contributes two more
+   * (`old` and `new` are `object_reference`s in this grammar), so the action
+   * function was read as `old` and the analyzer emitted
+   * `calls tg -> old` instead of `calls tg -> audit_it`. The three references are
+   * read from the trigger's own top level instead: the first is the name, the one
+   * after `keyword_on` is the table, and the last is the executed routine.
+   */
+  processTrigger(node, state) {
+    const top = this.namedChildren(node).filter((c) => c.type === "object_reference");
+    if (top.length === 0) return;
+    const nameRef = top[0];
+    const onAt = this.namedChildren(node).findIndex((c) => c.type === "keyword_on");
+    const tableRef = onAt >= 0 ? this.namedChildren(node).slice(onAt + 1).find((c) => c.type === "object_reference") ?? null : top[1] ?? null;
+    const actionRef = top.length > 1 ? top[top.length - 1] : null;
+    const nameNode = this.referenceNameNode(nameRef);
+    if (!nameNode) return;
+    const name = this.identifierName(nameNode, state);
+    const target = tableRef && tableRef !== nameRef ? this.referenceLeaf(tableRef, state) : void 0;
+    const action = actionRef && actionRef !== nameRef && actionRef !== tableRef ? this.referenceLeaf(actionRef, state) : void 0;
+    this.createSymbol(name, ASTEngine.SymbolKind.Function, nameNode, null, state, {
+      type: "trigger",
+      isTrigger: true,
+      targetTable: target,
+      actionFunction: action
+    });
+    this.addPattern("Triggers", state);
+    if (target) this.addRelationship(ASTEngine.RelationshipType.References, name, target, state, { triggerTarget: true });
+    if (action) {
+      const parts = actionRef ? this.referenceParts(actionRef, state) : [];
+      this.addRelationship(
+        ASTEngine.RelationshipType.Calls,
+        name,
+        action,
+        state,
+        { triggerAction: true, ...parts.length > 1 ? { qualified: parts.join(".") } : {} }
+      );
+    }
+  }
+  // ---------------------------------------------------------------- types / containers
+  processType(node, state) {
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    const enumElements = this.firstDescendant(node, "enum_elements");
+    const values = this.literalTexts(enumElements);
+    const attributes = this.directChild(node, "column_definitions");
+    const fields = attributes ? this.namedChildren(attributes).filter((c) => c.type === "column_definition").map((c) => {
+      const fieldName = c.childForFieldName?.("name") ?? this.firstIdentifier(c);
+      return fieldName ? this.identifierName(fieldName, state) : void 0;
+    }).filter((v) => !!v) : [];
+    this.createSymbol(this.identifierName(nameNode, state), ASTEngine.SymbolKind.Type, nameNode, null, state, {
+      type: values.length > 0 ? "enum" : "custom_type",
+      enumValues: values,
+      ...fields.length ? { fields } : {},
+      customType: true
+    });
+    this.addPattern(values.length > 0 ? "Enum Types" : "Custom Types", state);
+  }
+  processNamedContainer(node, kind, type, state) {
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    this.createSymbol(this.identifierName(nameNode, state), kind, nameNode, null, state, { type, isSchemaEntity: true });
+    this.addPattern(type === "schema" ? "Schemas" : type === "sequence" ? "Sequences" : type === "extension" ? "Extensions" : "Roles", state);
+  }
+  /**
+   * `CREATE EXTENSION name` — a declaration AND a dependency, and only the
+   * declaration was being read.
+   *
+   * The extension is the closest thing SQL has to a separately published unit: it
+   * ships its own types, functions and operators, it lives outside this unit, and
+   * the database cannot run this file without it. `processNamedContainer` recorded
+   * the symbol and stopped there, so 27 declarations over the 1,460-file census
+   * produced 27 `module` symbols and **no edge at all** — a real cross-unit
+   * dependency, invisible in the graph, in the one construct where SQL genuinely
+   * has one.
+   *
+   * The edge is `imports`, and it is the same type the psql `\i`/`\ir` pass emits
+   * for a different reason: a dependency on a named artifact resolved from outside
+   * the file before the file's own SQL can mean anything. The two mechanisms are
+   * kept distinguishable in metadata (`extensionInstall` vs `psqlInclude`) because
+   * they answer different questions — one is "this file loads another FILE", the
+   * other is "this file requires another DISTRIBUTION to be installed" — and a
+   * consumer that cannot tell them apart will read a `\i schema.sql` edge as
+   * evidence about the environment.
+   *
+   * WHY the FILE MODULE as the SOURCE and why the target is an external name. The
+   * extension is not declared by this file; it is installed into the DATABASE.
+   * Labelling the edge `external` keeps it distinguishable from a psql include,
+   * whose target IS a file in this repository and is in principle resolvable. That
+   * makes the extension edges the only `imports` edges in this lane with a target
+   * that can never bind, which is a property of the construct and is stated here
+   * rather than left for a reader to discover from the resolution rate.
+   *
+   * `evidenceClass` is `structural`: `create_extension` is a visible rule and the
+   * name is in the `object_reference` the rule puts there. Nothing here is a name
+   * match. `CREATE EXTENSION IF NOT EXISTS` is the same shape with a guard
+   * keyword, so it is the same edge — the extension is still required.
+   */
+  processExtension(node, state) {
+    this.processNamedContainer(node, ASTEngine.SymbolKind.Module, "extension", state);
+    const object = this.firstDescendant(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) {
+      state.ambiguity.includeNonLiteral++;
+      return;
+    }
+    const name = this.identifierName(nameNode, state);
+    if (SQL_KEYWORDS.has(name.toLowerCase())) {
+      state.ambiguity.keywordTargetsSuppressed++;
+      return;
+    }
+    const line = node.startPosition.row + state.slice.rowOffset + 1;
+    this.addRelationship(ASTEngine.RelationshipType.Imports, state.fileModuleName, name, state, {
+      extensionInstall: true,
+      external: true,
+      fileDependency: false,
+      scope: "database",
+      line
+    });
+    state.ambiguity.extensionImportsEmitted++;
+    state.imports.push({
+      module: name,
+      items: [],
+      importType: "sql_extension",
+      lineNumber: line,
+      line,
+      range: this.range(node, state),
+      isExternal: true,
+      metadata: { extensionInstall: true, scope: "database" }
+    });
+  }
+  processDatabase(node, state) {
+    const object = this.directChild(node, "object_reference");
+    const nameNode = object ? this.referenceNameNode(object) : this.firstIdentifier(node);
+    if (!nameNode) return;
+    this.createSymbol(this.identifierName(nameNode, state), ASTEngine.SymbolKind.Namespace, nameNode, null, state, {
+      type: "database",
+      isSchemaEntity: true
+    });
+    this.addPattern("Databases", state);
+  }
+  /**
+   * `CREATE POLICY <name> ON <table> …` — a row-level-security policy.
+   *
+   * The name is the first `object_reference` and the table is the one after
+   * `keyword_on`; both are real schema entities, so the policy is a symbol and
+   * the table is an edge. `AS PERMISSIVE|RESTRICTIVE` and `TO <role>` are
+   * deliberately not edged: a role is not a table, which is the same rule the
+   * GRANT rule is written to keep.
+   *
+   * The policy's USING/WITH CHECK expressions are read through the same
+   * declaration sweep as any other query node, so tables named inside them are
+   * still reached.
+   */
+  processPolicy(node, state) {
+    const children = this.namedChildren(node);
+    const nameRef = children.find((c) => c.type === "object_reference");
+    const onAt = children.findIndex((c) => c.type === "keyword_on");
+    const targetRef = onAt >= 0 ? children.slice(onAt + 1).find((c) => c.type === "object_reference") ?? null : null;
+    const nameNode = nameRef ? this.referenceNameNode(nameRef) : null;
+    if (!nameRef || !nameNode) return;
+    const name = this.identifierName(nameNode, state);
+    this.createSymbol(name, ASTEngine.SymbolKind.Constant, nameNode, null, state, {
+      type: "policy",
+      isSchemaEntity: true,
+      ...targetRef ? { policyOn: this.referenceLeaf(targetRef, state) } : {}
+    });
+    this.addPattern("Row Level Security", state);
+    const target = targetRef ? this.referenceLeaf(targetRef, state) : void 0;
+    if (target) this.addRelationship(ASTEngine.RelationshipType.References, name, target, state, { policyOn: true });
+  }
+  /**
+   * `DO $$ … $$` — an anonymous procedural block.
+   *
+   * It declares nothing, so it mints no symbol, but the body is a real query
+   * when the grammar could parse it (`EXECUTE format('DROP POLICY …')` and
+   * `SELECT … FROM pg_policies` are the shapes a migrations corpus is full of),
+   * so its table references are read and the procedural pattern is reported.
+   */
+  processDo(node, state) {
+    this.addPattern("Anonymous Procedural Block", state);
+    this.bumpComplexity(node, state);
+    this.processQueryDependencies(node, null, state);
+    this.processCalls(node, state.fileModuleName, state);
+  }
+  // ---------------------------------------------------------------- dml
+  recordDml(node, operation, state) {
+    const scope = node.parent?.type === "statement" ? node.parent : node;
+    const object = this.dmlTargetNode(node);
+    const target = object ? this.referenceLeaf(object, state) : this.referenceLeaf(this.firstDescendant(scope, "object_reference"), state);
+    if (target) {
+      const parts = object ? this.referenceParts(object, state) : [];
+      this.addRelationship(ASTEngine.RelationshipType.Uses, state.fileModuleName, target, state, {
+        operation,
+        tableReference: true,
+        ...parts.length > 1 ? { qualified: parts.join(".") } : {}
+      });
+    }
+    this.addPattern(`${operation.toUpperCase()} Statements`, state);
+    this.processQueryDependencies(scope, null, state);
+  }
+  /**
+   * `MERGE INTO t USING s` — the rule is hidden (`_merge_statement`), so there is
+   * no `merge` node: the keywords and both references are inlined into
+   * `statement`. Both tables are real dependencies and neither was emitted.
+   */
+  processMerge(node, state) {
+    for (const ref of this.namedChildren(node).filter((c) => c.type === "object_reference")) {
+      const target = this.referenceLeaf(ref, state);
+      if (target) this.addRelationship(ASTEngine.RelationshipType.Uses, state.fileModuleName, target, state, { operation: "merge", tableReference: true });
+    }
+    this.addPattern("MERGE Statements", state);
+  }
+  processTruncate(node, state) {
+    for (const ref of this.namedChildren(node).filter((c) => c.type === "object_reference")) {
+      const target = this.referenceLeaf(ref, state);
+      if (target) this.addRelationship(ASTEngine.RelationshipType.Uses, state.fileModuleName, target, state, { operation: "truncate", tableReference: true });
+    }
+    this.addPattern("TRUNCATE Statements", state);
+  }
+  processCopy(node, state) {
+    const target = this.referenceLeaf(this.firstDescendant(node, "object_reference"), state);
+    if (target) this.addRelationship(ASTEngine.RelationshipType.Uses, state.fileModuleName, target, state, { operation: "copy", tableReference: true });
+    this.addPattern("COPY Statements", state);
+  }
+  /**
+   * A hidden-rule statement (`MERGE`, `TRUNCATE`, `COPY`) arrives as a KEYWORD
+   * child of `statement`, because `_merge_statement` / `_truncate_statement` /
+   * `_copy_statement` inline into their parent and emit no node of their own — so
+   * no node of type `merge`/`truncate`/`copy` can exist to dispatch on. The
+   * handler needs the enclosing `statement` (it holds the object_references), so
+   * walk up SEEKING for it rather than by a fixed hop count: the first version
+   * climbed four parents, sailed past `statement`, landed on `program`, and
+   * emitted nothing.
+   */
+  /**
+   * The nearest ANCESTOR `statement` — the scope a nested statement inherits.
+   *
+   * SQL attaches its `WITH` list to the STATEMENT, so a statement inside a `cte`
+   * body, inside a plpgsql block or inside a dollar-quoted fragment inherits the
+   * CTEs of the statement it is nested in, and nothing else. Distinct from
+   * `enclosingStatement` above, which SEEKING includes the node itself and falls
+   * back to it: this one starts at the parent and admits that there may be none,
+   * because a top-level statement has no enclosing scope to inherit.
+   *
+   * `descendants` is transitive, so one level of lookup suffices however deeply
+   * the statement is buried.
+   */
+  ancestorStatement(node) {
+    let parent = node.parent;
+    while (parent) {
+      if (parent.type === "statement") return parent;
+      parent = parent.parent;
+    }
+    return null;
+  }
+  enclosingStatement(node) {
+    let current = node;
+    while (current) {
+      if (current.type === "statement") return current;
+      current = current.parent;
+    }
+    return node;
+  }
+  processInlineMerge(keyword, state) {
+    this.processMerge(this.enclosingStatement(keyword), state);
+  }
+  processInlineTruncate(keyword, state) {
+    this.processTruncate(this.enclosingStatement(keyword), state);
+  }
+  processInlineCopy(keyword, state) {
+    this.processCopy(this.enclosingStatement(keyword), state);
+  }
+  /** `RETURNING col` names columns of the statement's own target table. */
+  processReturning(node, state) {
+    const columns = this.identifierTexts(node, state);
+    if (columns.length === 0) return;
+    this.addPattern("RETURNING Clause", state);
+  }
+  /**
+   * psql meta-commands. `\i` / `\ir` name another FILE, which is an import; the
+   * other 121 shapes over the census corpus do not, and are counted rather than
+   * silently ignored so a command the grammar starts producing later appears in
+   * a number instead of in nothing.
+   *
+   * `psql_meta_command` is a LEAF token — the whole `\ir schema.sql` is one node
+   * with no children — so both the command word and its argument have to be read
+   * out of that one string. A character scan rather than a regex, per this
+   * lane's zero-regex policy (`reviews/regex-policy.md`, and
+   * `validation/m12/results/regex-census.json` which once recorded SQL at all as
+   * unregistered).
+   *
+   * Three guards, each of which has already cost something if dropped:
+   *   - the command must be `i` or `ir` exactly, so `\echo`, `\set`, `\gexec`,
+   *     `\gset`, `\pset`, `\if`, `\endif` stay out (`\gset` writes a variable
+   *     FROM a query, which is the opposite direction, and `\o`/`\g` write a
+   *     query result TO a file, which is not a source dependency).
+   *   - the argument must not begin with `:`. `\i :script` includes a file whose
+   *     NAME is computed by an earlier `\set`, and a target invented from a
+   *     variable name is a fabricated edge. Measured 0 on the corpus, so the
+   *     guard costs nothing there and is kept for the corpus that uses it.
+   *   - the argument must carry a SQL/dump suffix, so `\i` onto an extensionless
+   *     name is skipped rather than resolved against nothing.
+   *
+   * The path is kept exactly as written — `../../orioledb.sql` is what the file
+   * says and what a reader needs — with `relativeToScript` recording that `\ir`
+   * resolves against the including script's own directory rather than psql's
+   * working directory.
+   */
+  processPsqlMetaCommand(node, state) {
+    const text = node.text;
+    if (text.length < 2 || text.charCodeAt(0) !== 92) return;
+    const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12 || c === 11;
+    let end = 1;
+    while (end < text.length && !isSpace(text.charCodeAt(end))) end++;
+    const command = text.slice(1, end).toLowerCase();
+    if (!PSQL_INCLUDE_COMMANDS.has(command)) {
+      state.ambiguity.psqlCommandsSkipped++;
+      return;
+    }
+    let start = end;
+    while (start < text.length && isSpace(text.charCodeAt(start))) start++;
+    let stop = text.length;
+    while (stop > start && isSpace(text.charCodeAt(stop - 1))) stop--;
+    const argument = text.slice(start, stop);
+    if (argument.length === 0) {
+      state.ambiguity.includeNonLiteral++;
+      return;
+    }
+    if (argument.charCodeAt(0) === 58) {
+      state.ambiguity.includeNonLiteral++;
+      return;
+    }
+    for (let i = 0; i < argument.length; i++) {
+      if (isSpace(argument.charCodeAt(i))) {
+        state.ambiguity.includeNonLiteral++;
+        return;
+      }
+    }
+    const lowered = argument.toLowerCase();
+    let suffixOk = false;
+    for (const suffix of PSQL_INCLUDE_SUFFIXES) {
+      if (lowered.length > suffix.length && lowered.endsWith(suffix)) {
+        suffixOk = true;
+        break;
+      }
+    }
+    if (!suffixOk) {
+      state.ambiguity.includeNonLiteral++;
+      return;
+    }
+    const line = node.startPosition.row + state.slice.rowOffset + 1;
+    const kind = `${command} ${argument} ${line}`;
+    if (state.includeKeys.has(kind)) return;
+    state.includeKeys.add(kind);
+    this.addRelationship(ASTEngine.RelationshipType.Imports, state.fileModuleName, argument, state, {
+      psqlInclude: true,
+      includeKind: command,
+      relativeToScript: command === "ir",
+      fileDependency: true,
+      line
+    });
+    this.addPattern("psql Script Include", state);
+    state.imports.push({
+      module: argument,
+      items: [],
+      importType: "sql_import",
+      lineNumber: line,
+      line,
+      range: this.range(node, state),
+      isExternal: false,
+      metadata: { psqlInclude: true, includeKind: command, relativeToScript: command === "ir" }
+    });
+  }
+  /** `COMMENT ON <object> …` — the object named is a real dependency. */
+  processComment(node, state) {
+    this.addPattern("SQL Documentation", state);
+    const children = this.namedChildren(node);
+    const onAt = children.findIndex((c) => c.type === "keyword_on");
+    const object = onAt >= 0 ? children.slice(onAt + 1).find((c) => c.type === "object_reference") ?? null : null;
+    if (!object) return;
+    const parts = this.referenceParts(object, state);
+    const isColumnComment = children.some((c) => c.type === "keyword_column");
+    const target = isColumnComment && parts.length >= 2 ? parts[parts.length - 2] : parts[parts.length - 1];
+    if (!target) return;
+    const column = isColumnComment && parts.length >= 1 ? parts[parts.length - 1] : void 0;
+    this.addRelationship(ASTEngine.RelationshipType.References, state.fileModuleName, target, state, {
+      operation: "comment",
+      documented: true,
+      ...column && column !== target ? { column } : {}
+    });
+  }
+  /**
+   * `GRANT` / `REVOKE`.
+   *
+   * The grammar rule keeps the grantee an `identifier`/`literal` and never an
+   * `object_reference`, which is the structural reason `REVOKE SELECT ON t FROM
+   * joe` can no longer publish `uses global->joe` — before the rule existed the
+   * statement was an ERROR and the role name was reachable through a `from`
+   * clause. The object the privilege applies to IS an `object_reference`, and it
+   * is a real schema entity, so it is the one thing here that gets an edge.
+   */
+  processGrant(node, state, operation) {
+    this.addPattern("Permissions (GRANT/REVOKE)", state);
+    const object = this.firstDescendant(node, "object_reference");
+    const target = object ? this.referenceLeaf(object, state) : void 0;
+    if (target) {
+      this.addRelationship(ASTEngine.RelationshipType.References, state.fileModuleName, target, state, { operation, privilege: true });
+    }
+  }
+  /**
+   * Columns added by `ALTER TABLE … ADD COLUMN`.
+   *
+   * The grammar gives each added column its OWN `add_column` SIBLING rather than
+   * one comma list, so `ALTER TABLE t ADD COLUMN a int, ADD COLUMN b text,
+   * ADD COLUMN c numeric(6,2)` has three. Reading the first descendant published
+   * only `a` and dropped the rest — measured on the corpus, a five-column
+   * `ADD COLUMN IF NOT EXISTS …` migration published one of its five columns.
+   */
+  processAlterTable(node, state) {
+    const table = this.referenceLeaf(this.directChild(node, "object_reference"), state);
+    if (!table) return;
+    const owner = state.symbols.find((s) => s.name === table && s.metadata?.type === "table");
+    for (const spec of this.namedChildren(node).filter((c) => c.type === "inherit_specification")) {
+      const isRemoval = this.namedChildren(spec).some((c) => c.type === "keyword_no");
+      if (isRemoval) continue;
+      const parentNode = this.namedChildren(spec).find((c) => c.type === "object_reference");
+      const parent = parentNode ? this.referenceLeaf(parentNode, state) : "";
+      if (!parent || !owner) continue;
+      this.addRelationship(ASTEngine.RelationshipType.Extends, table, parent, state, {
+        clause: "inherit",
+        evidenceClass: "structural"
+      }, this.range(spec, state).startLine);
+    }
+    const added = this.namedChildren(node).filter((c) => c.type === "add_column");
+    if (added.length === 0) return;
+    if (!owner) return;
+    for (const add of added) {
+      const definition = this.firstDescendant(add, "column_definition");
+      if (!definition) continue;
+      const nameNode = definition.childForFieldName?.("name") ?? this.firstIdentifier(definition);
+      if (!nameNode || !identifierTypes.has(nameNode.type)) continue;
+      const inheritKind = this.inheritClauseKind(nameNode, add, node);
+      if (inheritKind === "inherit" || inheritKind === "noInherit" || this.reservedColumnName(nameNode)) {
+        state.ambiguity.reservedNameSymbolsSuppressed++;
+        if (inheritKind === "inherit") {
+          const parentNode = definition.childForFieldName?.("type") ?? definition.childForFieldName?.("custom_type");
+          const parentName = parentNode ? this.identifierName(parentNode, state) : "";
+          if (parentName) {
+            this.addRelationship(ASTEngine.RelationshipType.Extends, table, parentName, state, {
+              clause: "inherit"
+            }, this.range(nameNode, state).startLine);
+          }
+        }
+        continue;
+      }
+      const column = this.createSymbol(
+        this.identifierName(nameNode, state),
+        ASTEngine.SymbolKind.Property,
+        nameNode,
+        owner,
+        state,
+        { type: "column", sqlType: this.columnType(definition, state), addedByAlter: true }
+      );
+      this.addRelationship(ASTEngine.RelationshipType.Contains, table, column.name, state, { memberKind: ASTEngine.SymbolKind.Property }, this.range(nameNode, state).startLine, this.existingSymbol(table, ASTEngine.SymbolKind.Class, state)?.id ?? table, column.id);
+    }
+  }
+  /**
+   * WHAT IS THIS `ALTER TABLE` COLUMN, really? The wired grammar has no `INHERIT` clause, so
+   * `ALTER TABLE c INHERIT p` arrives as
+   *   (add_column (column_definition name:(identifier "INHERIT")
+   *                custom_type:(object_reference name:(identifier "p"))))
+   * — a column named INHERIT whose type is the parent table. THREE legal SQL statements arrive in
+   * that shape, and the answer is STRUCTURAL, never a name list:
+   *
+   *   "column"    `ALTER TABLE c ADD COLUMN inherit int;` — a REAL column. `inherit` is a
+   *               NON-RESERVED PostgreSQL keyword (PostgreSQL 18 keyword appendix, Table C.1:
+   *               `INHERIT | non-reserved`), so this is legal SQL and the column is PUBLISHED.
+   *               The grammar SAW the column: the `add_column` carries `keyword_add` and/or
+   *               `keyword_column`.
+   *   "inherit"   `ALTER TABLE c INHERIT p;` — the mis-parse of a real inheritance clause. The
+   *               grammar saw NEITHER `ADD` nor `COLUMN`, because it had nothing else to call it,
+   *               and there is no `NO`. The parent's name survives in `custom_type`, so the
+   *               RELATION is recoverable and `extends` is published from it.
+   *   "noInherit" `ALTER TABLE c NO INHERIT p;` — the clause that REMOVES inheritance. It parses
+   *               to (alter_table … (ERROR (keyword_no)) (add_column (column_definition
+   *               name:(identifier "INHERIT") custom_type:(object_reference "p")))), and it is
+   *               NEITHER a column NOR a relation: publishing either asserts the opposite of what
+   *               the statement says.
+   *
+   * `null` means the column is not one of these three — an ordinary column, and the caller's
+   * business.
+   */
+  inheritClauseKind(nameNode, addColumn, alterTable) {
+    if (nameNode.type !== "identifier") return null;
+    if (nameNode.text.toLowerCase() !== "inherit") return null;
+    if (this.directChild(addColumn, "keyword_add") !== null) return "column";
+    if (this.directChild(addColumn, "keyword_column") !== null) return "column";
+    if (this.descendants(alterTable, "keyword_no").length > 0) return "noInherit";
+    return "inherit";
+  }
+  // ---------------------------------------------------------------- queries
+  processQuery(node, state, owner) {
+    if (this.containsType(node, "join")) this.addPattern("Join Query Mapping", state);
+    if (this.containsType(node, "cte")) this.addPattern("Common Table Expressions (CTE)", state);
+    if (this.containsType(node, "set_operation")) this.addPattern("Set Operations (UNION/INTERSECT/EXCEPT)", state);
+    if (this.containsType(node, "subquery")) this.addPattern("Subqueries", state);
+    if (this.containsType(node, "case")) this.addPattern("Conditional Logic (CASE/WHEN)", state);
+    if (this.containsType(node, "all_fields")) {
+      this.addPattern("SELECT *", state);
+      if (state.metadata.performanceScore !== void 0) state.metadata.performanceScore = Math.max(0, state.metadata.performanceScore - 30);
+      this.addInsight("SELECT * detected \u2014 consider explicit column selection", state);
+    }
+    this.bumpComplexity(node, state);
+    this.processQueryDependencies(node, owner, state);
+    this.processCalls(node, owner?.name ?? state.fileModuleName, state);
+  }
+  processQueryDependencies(node, owner, state, sourceOverride) {
+    const source = sourceOverride ?? owner?.name ?? state.fileModuleName;
+    const localCtes = this.cteScope(node, state);
+    for (const relation of this.descendants(node, "relation")) {
+      const object = this.namedChildren(relation).find((c) => c.type === "object_reference");
+      if (!object) continue;
+      this.addTableEdge(source, object, localCtes, state);
+    }
+    for (const from of this.descendants(node, "from")) {
+      for (const child of this.namedChildren(from)) {
+        if (child.type !== "object_reference") continue;
+        this.addTableEdge(source, child, localCtes, state);
+      }
+    }
+    for (const merge of this.descendants(node, "keyword_merge")) {
+      void merge;
+    }
+    this.processInstantiations(node, source, state);
+  }
+  /**
+   * `ROW(...)::my_composite` — a value BUILT for a named type.
+   *
+   * PostgreSQL implements a composite cast as a call to that type's constructor,
+   * so this is the one place SQL constructs an instance of a declared type, and it
+   * is what the ontology's `instantiates` names. Measured over the 1,460-file
+   * census: 4,406 `cast` nodes, of which only those carrying a `custom_type`
+   * FIELD name a user type at all (a builtin target such as `::integer` is a bare
+   * anonymous token), and of those the ones whose VALUE side is a constructor
+   * rather than a pre-existing value are the construction events.
+   *
+   * Two guards, and both were arrived at by discarding a wrong answer:
+   *
+   *   - the value side must CONSTRUCT. `x::my_enum` and `col::my_type` convert a
+   *     value that already exists; publishing those would assert an object was
+   *     created where none was. A `cast` whose left side is an ERROR is also
+   *     skipped: DuckDB's `[a+b, …]::vec4` parses as `ERROR :: type` because the
+   *     grammar cannot read a bracketed array literal, so the shape is a damaged
+   *     parse and not a construction the analyzer can vouch for.
+   *   - the type name must not be a keyword or a builtin. DuckDB's
+   *     `CAST(ROW(x) AS ROW(a INT, b INT))` puts the literal word `ROW` in the
+   *     same `custom_type` field, and 67 casts corpus-wide target a name no file
+   *     declares. Those stay external names, which is what they are.
+   *
+   * The target may be declared in another file — a composite type is usually
+   * declared once and constructed from many migrations — so an unresolved target
+   * is the normal case for this type and is reported as such rather than
+   * suppressed. `evidenceClass` is `structural` because the constructor and the
+   * type name are both in grammar-mandated positions; nothing here is a name
+   * match.
+   */
+  /**
+   * The names of the `cte` nodes the given node is INSIDE, nearest first.
+   *
+   * A CTE's own name is bound inside its own body — that is what makes
+   * `WITH RECURSIVE t AS (… FROM t …)` work — so every reference inside that body
+   * has to see it. The nodes naming it are ANCESTORS of the reference and
+   * DESCENDANTS of nothing the reference owns, which is why a scope computed from
+   * `descendants(reference, "cte")` or `descendants(enclosingStatement, "cte")`
+   * cannot contain it. Only the chain from the node to the root does.
+   *
+   * Bounded by construction: it is one pass up the parent chain and it collects a
+   * node's own name, so it cannot pick up a name a later sibling CTE declared.
+   */
+  ancestorCteNames(node, state) {
+    const names = [];
+    for (let a = node.parent; a; a = a.parent) {
+      if (a.type !== "cte") continue;
+      const nm = this.firstIdentifier(a, state);
+      if (nm) names.push(this.identifierName(nm, state));
+    }
+    return names;
+  }
+  /**
+   * THE CTE SCOPE of a node, which is two sets and neither of them is
+   * `descendants(node, "cte")`.
+   *
+   * SQL's rule is that a WITH list's names are visible to every LATER item in the
+   * list and to the main query — not only inside the item that declares them. So:
+   *
+   *   WITH aoc5_input(i) AS (…), lines(y,line) AS (… FROM aoc5_input …),
+   *        rules(b,a) AS (… FROM lines …), updates(y,x,v) AS (… FROM lines …)
+   *   SELECT … FROM updates;
+   *
+   * `updates`' body reads `lines`, a SIBLING CTE. Both the per-node set and the
+   * sweep's `ancestorStatement` set miss it: the body is its own `statement`, its
+   * subtree holds no `cte`, and the node that names `lines` is neither an ancestor
+   * nor a descendant of the reference. Measured over the grown corpus, this leaked
+   * 32 `uses` edges across 16 DuckDB benchmark files — the same wrong output as
+   * pass 1's CTE leak, reached through a third entry point.
+   *
+   * The two sets that do settle it:
+   *
+   *   1. every `cte` under the OUTERMOST enclosing `statement`, which is the WITH
+   *      list the body belongs to — siblings included;
+   *   2. the `cte` names on the ANCESTOR CHAIN, which is what a CTE's own body
+   *      needs and is the only set that can see the node naming it.
+   *
+   * WHY THE OUTERMOST statement and not the nearest. Two `WITH` lists in one file
+   * are two scopes, and a name from the first must not shadow a table in the
+   * second. The outermost enclosing `statement` is exactly one WITH list.
+   *
+   * WHY A WIDER SCOPE WAS TRIED AND REVERTED, since this is the third attempt.
+   * `ParseState.localCtes`'s field comment records an ancestor walk that collected
+   * everything under the with-clause and shadowed real tables outside its actual
+   * scope. That version walked ancestors and kept DESCENDANTS of each — which
+   * re-reaches the same set this one does, but from the wrong root when the
+   * reference is in the OUTER query: it pulled in a WITH list belonging to a
+   * function body further up the file. Anchoring on the outermost statement of the
+   * reference itself removes that, because a reference in the outer query has that
+   * outer query as its own outermost statement. `sqld5` and `sqld14` pin both
+   * directions.
+   */
+  cteScope(node, state) {
+    let outermost = node;
+    for (let a = node.parent; a; a = a.parent) if (a.type === "statement") outermost = a;
+    const scope = /* @__PURE__ */ new Set();
+    const collect = (from) => {
+      for (const cte of this.descendants(from, "cte")) {
+        const nm = this.firstIdentifier(cte, state);
+        if (nm) scope.add(this.identifierName(nm, state));
+      }
+    };
+    collect(outermost);
+    if (outermost !== node) collect(node);
+    if (node.type === "cte" || node.parent?.type === "cte") {
+      let listRoot = node.parent;
+      if (listRoot?.type === "cte") listRoot = listRoot.parent;
+      if (listRoot) collect(listRoot);
+    }
+    for (const name of this.ancestorCteNames(node, state)) scope.add(name);
+    return scope;
+  }
+  processInstantiations(node, source, state) {
+    for (const cast of this.descendants(node, "cast")) {
+      const target = cast.childForFieldName?.("custom_type");
+      if (!target) continue;
+      const name = this.referenceLeaf(target, state);
+      if (!name) continue;
+      const lowered = name.toLowerCase();
+      if (SQL_KEYWORDS.has(lowered) || SQL_BUILTINS.has(lowered)) {
+        state.ambiguity.keywordTargetsSuppressed++;
+        continue;
+      }
+      let value = null;
+      for (let i = 0; i < cast.childCount; i++) {
+        const child = cast.child(i);
+        if (!child) continue;
+        if (child.type === "::") break;
+        if (child.isNamed) value = child;
+      }
+      if (!value || value.hasError) continue;
+      if (!this.constructsAValue(value)) continue;
+      this.addRelationship(ASTEngine.RelationshipType.Instantiates, source, name, state, {
+        operation: "cast",
+        construction: true,
+        constructor: value.type
+      });
+      state.ambiguity.instantiationsEmitted++;
+    }
+  }
+  /**
+   * Is this expression BUILDING a value, rather than naming one?
+   *
+   * `ROW(1,2)` is the grammar's `invocation` whose callee is the bare word `ROW`,
+   * and that callee name is the discriminator: `nextval('s')::bigint` is also an
+   * `invocation` and is a conversion. `('a', 2)` and `ARRAY[...]` are `list` /
+   * `array`, which cannot be anything but a constructed collection. Anything else
+   * — a `field`, a `parameter`, a bare `literal`, a `parenthesized_expression`
+   * wrapping a column — is a value that already existed.
+   */
+  constructsAValue(node) {
+    if (CONSTRUCTOR_VALUE_NODES.has(node.type)) return true;
+    if (node.type === "invocation") {
+      const callee = this.directChild(node, "object_reference");
+      const nameNode = callee ? this.referenceNameNode(callee) : this.firstIdentifier(node);
+      return nameNode?.text.toLowerCase() === "row";
+    }
+    return false;
+  }
+  addTableEdge(source, object, localCtes, state) {
+    const parts = this.referenceParts(object, state);
+    if (parts.length === 0) return;
+    const leaf = parts[parts.length - 1];
+    if (parts.length === 1 && (localCtes.has(leaf) || state.localCtes.has(leaf))) return;
+    const wholeQuoted = this.wholeQuotedReferenceName(object, parts.length);
+    this.addRelationship(ASTEngine.RelationshipType.Uses, source, leaf, state, {
+      tableReference: true,
+      ...parts.length > 1 ? { qualified: parts.join(".") } : {},
+      ...wholeQuoted ? { quotedName: true } : {}
+    });
+  }
+  /**
+   * Call edges, one per `invocation` the grammar actually recognised.
+   *
+   * An `invocation` node whose OWN subtree carries an ERROR is skipped, and that
+   * test is the whole fix. Error recovery will synthesise an `invocation` whose
+   * callee slot holds whatever token it happened to reach, and the measured case
+   * is a PL/pgSQL cursor loop:
+   *
+   *   CREATE OR REPLACE FUNCTION _drop_all_policies(p_table TEXT) … AS $$
+   *   DECLARE r RECORD;
+   *   BEGIN
+   *     FOR r IN SELECT policyname FROM pg_policies WHERE … LOOP   -- unparseable
+   *       EXECUTE format('DROP POLICY … %I', r.policyname, p_table);
+   *   END LOOP;
+   *   END; $$ LANGUAGE plpgsql;
+   *
+   * parses the `FOR … LOOP` as `invocation( object_reference("p_table"),
+   * ERROR("LOOP EXECUTE format"), term, term, term )` — so the first
+   * object_reference child, which the callee is read from, is the function's own
+   * PARAMETER, and the analyzer published `calls _drop_all_policies -> p_table`:
+   * a call into a variable. Five such edges measured on the corpus, one per
+   * migration that writes this shape.
+   *
+   * Per-node `hasError` is the right granularity: a clean invocation beside a
+   * damaged sibling is unaffected, so no real call is lost, and it is a property
+   * of the tree rather than a guess about the text. The suppression is counted in
+   * `ambiguity.recoveryCallsSuppressed` so it is visible rather than silent.
+   */
+  processCalls(node, source, state) {
+    for (const invocation of this.descendants(node, "invocation")) {
+      if (invocation.hasError) {
+        state.ambiguity.recoveryCallsSuppressed++;
+        continue;
+      }
+      const object = this.directChild(invocation, "object_reference");
+      const target = object ? this.referenceLeaf(object, state) : "";
+      if (!target) continue;
+      if (SQL_KEYWORDS.has(target.toLowerCase())) {
+        state.ambiguity.keywordTargetsSuppressed++;
+        continue;
+      }
+      if (SQL_BUILTINS.has(target.toLowerCase())) {
+        state.ambiguity.builtinCallsSuppressed++;
+        continue;
+      }
+      const parts = object ? this.referenceParts(object, state) : [];
+      const wholeQuoted = object ? this.wholeQuotedReferenceName(object, parts.length) : false;
+      this.addRelationship(ASTEngine.RelationshipType.Calls, source, target, state, {
+        ...parts.length > 1 ? { qualified: parts.join(".") } : {},
+        ...wholeQuoted ? { quotedName: true } : {}
+      });
+    }
+  }
+  recordTableTarget(node, type, operation, state) {
+    const object = this.firstDescendant(node, "object_reference");
+    if (!object) return;
+    const target = this.referenceLeaf(object, state);
+    if (!target) return;
+    const parts = this.referenceParts(object, state);
+    this.addRelationship(type === "uses" ? ASTEngine.RelationshipType.Uses : ASTEngine.RelationshipType.References, state.fileModuleName, target, state, {
+      operation,
+      tableReference: true,
+      ...parts.length > 1 ? { qualified: parts.join(".") } : {}
+    });
+  }
+  /**
+   * The `object_reference` node whose leaf is the DML statement's own target, or
+   * `null` when the shape does not have one. Split out of `dmlTarget` so the CALLER
+   * can read the reference's parts and not only its leaf: a bare leaf throws away
+   * the qualification, which is the whole content of `INSERT INTO app.t`.
+   */
+  dmlTargetNode(node) {
+    if (node.type === "insert") return this.directChild(node, "object_reference");
+    if (node.type === "update") {
+      const relation = this.directChild(node, "relation");
+      return relation ? this.directChild(relation, "object_reference") : this.firstDescendant(node, "object_reference");
+    }
+    if (node.type === "delete") {
+      const scope = node.parent?.type === "statement" ? node.parent : node;
+      return this.directChild(scope, "from") ? this.firstDescendant(this.directChild(scope, "from"), "object_reference") : this.firstDescendant(scope, "object_reference");
+    }
+    return this.firstDescendant(node, "object_reference");
+  }
+  dmlTarget(node, state) {
+    const object = this.dmlTargetNode(node);
+    return object ? this.referenceLeaf(object, state) : void 0;
+  }
+  // ---------------------------------------------------------------- symbols / edges
+  createSymbol(name, kind, node, parent, state, metadata = {}, extra = {}) {
+    const identity = `${node.startIndex + state.slice.byteOffset}:${kind}:${name}:${parent?.name ?? ""}`;
+    if (state.symbolKeys.has(identity)) {
+      return state.symbols.find((s) => s.name === name && s.kind === kind && s.ownerName === parent?.name) ?? this.placeholder(name, kind, parent);
+    }
+    state.symbolKeys.add(identity);
+    const symbol = {
+      name,
+      kind,
+      range: this.range(node, state),
+      parentId: parent ? `${parent.id}.${name}` : void 0,
+      ownerName: parent?.name,
+      ownerKind: parent?.kind,
+      parent: parent?.name,
+      metadata,
+      ...extra
+    };
+    let id = symbol.parentId ?? name;
+    const seen = state.idCounts.get(id) ?? 0;
+    state.idCounts.set(id, seen + 1);
+    if (seen > 0) id = `${id}#${seen + 1}`;
+    symbol.id = id;
+    state.symbols.push(symbol);
+    state.symbolNames.add(name);
+    if (parent) this.addRelationship(ASTEngine.RelationshipType.Contains, parent.name, name, state, { memberKind: symbol.kind }, symbol.range.startLine, parent.id, symbol.id);
+    return symbol;
+  }
+  /**
+   * A symbol of this name and kind already emitted in this file, if any.
+   *
+   * Used to attach a member to an owner that is declared as a SIBLING statement.
+   * `createSymbol` returns a `placeholder` when its identity key is taken, so an
+   * index declared after its table already resolves through the ordinary path; this
+   * covers the other order, where the index arrives first.
+   */
+  existingSymbol(name, kind, state) {
+    return state.symbols.find((s) => s.name === name && s.kind === kind);
+  }
+  placeholder(name, kind, parent) {
+    return {
+      name,
+      kind,
+      id: parent ? `${parent.id}.${name}` : name,
+      range: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startIndex: 0, endIndex: 0 },
+      ownerName: parent?.name,
+      metadata: {}
+    };
+  }
+  addRelationship(type, source, target, state, metadata = {}, line, ownerId, memberId) {
+    if (!source || !target) return;
+    if (type === ASTEngine.RelationshipType.Contains) {
+      if (ownerId !== void 0 && memberId !== void 0) {
+        if (ownerId === memberId) return;
+      } else if (source === target) {
+        state.ambiguity.sameNameContainmentSuppressed++;
+        return;
+      }
+    }
+    if (SQL_KEYWORDS.has(target.toLowerCase()) && !state.symbolNames.has(target)) {
+      state.ambiguity.keywordTargetsSuppressed++;
+      return;
+    }
+    let externalKind = classifyExternalTarget(
+      target,
+      metadata.qualified,
+      metadata.quotedName === true
+    );
+    if (!externalKind && type === ASTEngine.RelationshipType.Calls && !state.symbolNames.has(target) && SQL_PROVIDED_FUNCTIONS.has(target.toLowerCase())) {
+      externalKind = "providedFunction";
+      state.ambiguity.providedFunctionCallsMarked++;
+    }
+    if (externalKind && !state.externalTargets) {
+      state.externalTargets = { postgresCatalog: 0, informationSchema: 0, implicitSchema: 0, platform: 0, providedFunction: 0 };
+    }
+    if (externalKind) {
+      state.externalTargets[externalKind]++;
+      metadata = { ...metadata, external: externalKind };
+      if (externalKind === "postgresCatalog") {
+        metadata = { ...metadata, external: externalKind, isExternal: true };
+        state.ambiguity.pgCatalogMarkedExternal++;
+      }
+      if (externalKind === "providedFunction") {
+        metadata = { ...metadata, external: externalKind, isExternal: true };
+      }
+    }
+    const key = `${type}\0${source}\0${target}\0${metadata.memberKind ?? ""}`;
+    const existing = state.relationshipsByKey.get(key);
+    if (existing) {
+      if (metadata.operation) {
+        const operations = Array.isArray(existing.metadata?.operations) ? existing.metadata.operations : existing.metadata?.operation ? [existing.metadata.operation] : [];
+        if (!operations.includes(metadata.operation)) {
+          existing.metadata = { ...existing.metadata, operations: [...operations, metadata.operation] };
+        }
+      }
+      return;
+    }
+    state.relationshipKeys.add(key);
+    const relationship = {
+      type,
+      source,
+      target,
+      confidence: 1,
+      weight: 1,
+      ...line !== void 0 ? { line, line_number: line } : {},
+      metadata: { ...metadata, evidenceClass: metadata.evidenceClass ?? this.evidenceClassFor(type, metadata) }
+    };
+    state.relationshipsByKey.set(key, relationship);
+    state.relationships.push(relationship);
+  }
+  /**
+   * The tier an emitted edge was actually derived at.
+   *
+   * WHY THIS EXISTS, and what it cost to be missing. Until this mapping existed
+   * every edge this analyzer emitted carried `confidence: 1` and NO
+   * `evidenceClass` at all — so the honesty contract's §4 requirement, that the
+   * heuristic/deterministic ratio be a queryable NUMBER, was not answerable for
+   * this lane: the census reported `evidenceClass` absent on 22,073 of 22,073
+   * edges, which reads as "no heuristics" and in fact means "nothing recorded".
+   * A field that is absent is not the same claim as a field that is uniformly
+   * `structural`, and only one of them is true.
+   *
+   * The tiers, and why each edge lands where it does:
+   *
+   *   structural          the fact is in a grammar-mandated position. Every
+   *                       `contains` (an owner and a member the grammar nested
+   *                       it under), every `imports` (a `psql_meta_command`
+   *                       token naming a file), every `overrides` (an
+   *                       `OR REPLACE` on a name this file declared), every
+   *                       `instantiates` (a `cast` whose `custom_type` FIELD is
+   *                       the type), and every `references` — the FK target sits
+   *                       after `keyword_references`, the trigger's table after
+   *                       `keyword_on`, the policy's table after `keyword_on`,
+   *                       GRANT/REVOKE's object is the statement's own
+   *                       `object_reference`. Each of those is a fixed slot, not a
+   *                       name match.
+   *   usage_contextual    the name sits in a bare name slot with nothing around
+   *                       it to corroborate: a `uses` edge from a `from`/`relation`
+   *                       clause (the relation may be a CTE, which is why the CTE
+   *                       guard exists), and a `calls` edge whose callee is an
+   *                       UNQUALIFIED `invocation` — `my_func(1)`, which the
+   *                       grammar has told us is a call and not which `my_func`
+   *                       among the schemas resolves it.
+   *   reference_qualified the name was read through a QUALIFIED reference, which
+   *                       is the one case that carries its own disambiguation:
+   *                       `schema.func(...)` names one object by construction.
+   *
+   * `confidence` stays 1 for all of them, and that is now a claim rather than an
+   * omission: no edge this analyzer emits is a guess about a NAME. Where the
+   * analyzer genuinely cannot tell — a target it labels `external`, a
+   * concatenation fragment whose identifier is computed at run time — the edge is
+   * not emitted at all, and the suppression is counted in `ambiguity` instead.
+   */
+  evidenceClassFor(type, metadata) {
+    switch (type) {
+      case ASTEngine.RelationshipType.Imports:
+        return "import_based";
+      case ASTEngine.RelationshipType.Calls:
+      case ASTEngine.RelationshipType.Uses:
+        return metadata.qualified ? "reference_qualified" : "usage_contextual";
+      case ASTEngine.RelationshipType.Contains:
+      case ASTEngine.RelationshipType.References:
+      case ASTEngine.RelationshipType.Extends:
+      case ASTEngine.RelationshipType.Implements:
+      case ASTEngine.RelationshipType.Exports:
+      case ASTEngine.RelationshipType.Overrides:
+      case ASTEngine.RelationshipType.Instantiates:
+        return "structural";
+      default:
+        return "structural";
+    }
+  }
+  // ---------------------------------------------------------------- identifiers
+  /**
+   * An identifier's NAME, with the delimiter removed.
+   *
+   * Three quoting styles, three behaviours before this: `"MyTable"` kept its
+   * double quotes in `name` and `id`, `` `users` `` kept its backticks, and
+   * `[dbo].[Users]` had them stripped. The quotes are SQL syntax, not part of
+   * the name, so they are removed here and the raw text kept in metadata.
+   */
+  identifierName(node, state) {
+    const raw = node.text;
+    const stripped = this.stripIdentifierQuotes(raw);
+    if (stripped !== raw) {
+      state.ambiguity.quotedIdentifiers++;
+      return stripped;
+    }
+    return raw;
+  }
+  stripIdentifierQuotes(value) {
+    if (value.length < 2) return value;
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "`" && last === "`" || first === "[" && last === "]") {
+      const inner = value.slice(1, -1);
+      return first === '"' ? inner.replaceAll('""', '"') : inner;
+    }
+    return value;
+  }
+  /**
+   * Is this reference ONE quoted identifier, so a dot inside its text belongs to the NAME?
+   *
+   * NOT `node.type === "literal"`, and the grammar is why. Measured:
+   * `SELECT * FROM "vault.secret"` parses to `object_reference( identifier("\"vault.secret\"") )` —
+   * a single `identifier` whose TEXT carries the quotes — while `SELECT * FROM vault.secret`
+   * parses to `object_reference( identifier("vault"), identifier("secret") )`. So quotedness is a
+   * property of the leaf's text, not of its node type, and a check on the node type reads every
+   * quoted name as unqualified: it passed the fixture's positive case for the wrong reason and
+   * would have left `"vault.secret"` labelled as Supabase's `vault` schema.
+   *
+   * `parts.length === 1` is the other half and it is what makes this safe: `"vault"."secret"` is
+   * two leaves and IS qualified, so a two-part reference is never treated as a whole name.
+   */
+  wholeQuotedReferenceName(node, parts) {
+    if (parts !== 1) return false;
+    const nameNode = this.referenceNameNode(node);
+    if (!nameNode) return false;
+    if (nameNode.type === "literal") return true;
+    return this.stripIdentifierQuotes(nameNode.text) !== nameNode.text;
+  }
+  /**
+   * The parts of an `object_reference`, each unquoted.
+   *
+   * A QUALIFIED COLUMN reference nests its table as an `object_reference` CHILD
+   * rather than as a sibling identifier — this is the shape
+   * `COMMENT ON COLUMN business_inventory_items.calories` produces:
+   *
+   *   object_reference "business_inventory_items.calories"
+   *     object_reference "business_inventory_items"
+   *     identifier "calories"
+   *
+   * so a flat identifier walk sees only `calories` and the reference resolves to
+   * the COLUMN, which is how a column was published as a table dependency. When
+   * the first named child is itself a reference, its parts are the prefix.
+   */
+  referenceParts(node, state) {
+    const parts = [];
+    for (const child of this.namedChildren(node)) {
+      if (child.type === "object_reference") {
+        parts.push(...this.referenceParts(child, state));
+        continue;
+      }
+      if (child.type === "identifier" || child.type === "literal") parts.push(this.identifierName(child, state));
+    }
+    if (parts.length === 0) {
+      for (const id of this.descendants(node, "identifier")) parts.push(this.identifierName(id, state));
+    }
+    return parts;
+  }
+  referenceNameNode(node) {
+    if (node.type === "identifier" || node.type === "literal") return node;
+    return node.childForFieldName?.("name") ?? this.lastIdentifier(node);
+  }
+  lastIdentifier(node) {
+    const ids = this.descendants(node, "identifier");
+    if (ids.length) return ids[ids.length - 1];
+    const literals = this.descendants(node, "literal");
+    return literals.length ? literals[literals.length - 1] : null;
+  }
+  referenceLeaf(node, state) {
+    if (!node) return void 0;
+    const nameNode = this.referenceNameNode(node);
+    return nameNode ? this.identifierName(nameNode, state) : void 0;
+  }
+  referenceText(node, state) {
+    const parts = this.referenceParts(node, state);
+    return parts.length ? parts.join(".") : node.text;
+  }
+  // ---------------------------------------------------------------- metadata
+  addPattern(pattern, state) {
+    state.patterns.add(pattern);
+  }
+  addInsight(insight, state) {
+    const list = state.metadata.architecturalInsights;
+    if (Array.isArray(list) && !list.includes(insight)) list.push(insight);
+  }
+  bumpComplexity(node, state) {
+    const stack = [node];
+    let increment = 0;
+    while (stack.length) {
+      const current = stack.pop();
+      if (current.type === "case" || current.type === "join" || current.type === "when_clause" || current.type === "set_operation") increment++;
+      for (let i = 0; i < current.namedChildCount; i++) {
+        const child = current.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    state.metadata.cyclomaticComplexity = (state.metadata.cyclomaticComplexity ?? 1) + increment;
+  }
+  // ---------------------------------------------------------------- traversal helpers
+  directChild(node, type) {
+    for (const child of this.namedChildren(node)) if (child.type === type) return child;
+    return null;
+  }
+  /**
+   * Per-parse memo for `namedChildren`, and a per-TREE document-order index for `descendants`.
+   *
+   * WHY THIS EXISTS, measured rather than guessed. `node --cpu-prof` on
+   * `postgrest/test/io/fixtures/big_schema.sql` (392 KB, 67,508 named nodes, depth 43) put
+   * **134 of 154 seconds** inside `walkDescendants` — 87 % of the whole run — against
+   * `ts_parser_parse_wasm` at **0.33 s**. The grammar was never the problem; the walk was.
+   * The file then crossed `engine.ts`'s 120 s analyzer timeout, returned
+   * `analysisVersion: "2.0-basic-fallback"` with 0 symbols and 0 relationships, and in 2 of 3
+   * solo runs. That is what made this lane's corpus total BIMODAL (see the docs page).
+   *
+   * The blowup is arithmetic, and it is not subtle once counted: 29,662 `descendants` calls
+   * collapsed to 4,199 distinct (node, type) queries, and those 4,199 walks visited
+   * **99,159,647 nodes** — 1,469 visits per node in the file. The queries sit near the root, so
+   * each one rescanned a near-root subtree: the memo alone removed 85 % of the CALLS and none of
+   * the COST.
+   *
+    * WHY AN INDEX RATHER THAN A SMALLER WALK. "Is node X of type T inside subtree S" is an
+    * interval question, and tree-sitter already gives every node a byte range. So one preorder
+    * walk per tree groups nodes by type in document order, and a query becomes a binary search for
+    * the first node of type T at or after S's start, then a forward scan while candidates begin
+    * before S's end, keeping those that also END inside it. Cost becomes proportional to the
+    * matches inside the subtree rather than to the subtree — the difference between 23,617 visits
+    * per query and a handful.
+    *
+    * WHY THE KEY IS `(node.tree, node.id)` AND NOT THE NODE OBJECT. This is the load-bearing
+    * detail, and it was measured rather than assumed, because the obvious key is wrong:
+    * web-tree-sitter's `unmarshalNode` ends in `new Node(...)`, so **every** property access
+    * returns a FRESH wrapper. Verified directly on the wired wasm (`_ident.mts` in this lane's
+    * fixtures): `rootNode === rootNode` is false, `namedChild(0) === namedChild(0)` is false, while
+    * `rootNode.tree === rootNode.tree` is true and `namedChild(0).id === namedChild(0).id` is true.
+    * A `WeakMap<Node, …>` therefore misses on essentially every lookup — which is exactly what a
+    * first attempt did: it removed 85 % of the `descendants` CALLS and none of the COST, and an
+    * index built the same way rebuilt itself **200+ times for one tree** because the root handle
+    * it keyed on was a new object each time. `Node.id` is documented as unique within a tree and
+    * `Node.tree` is the tree it belongs to, and both are plain fields, so together they are a
+    * stable identity.
+    *
+    * WHY PER TREE, LAZILY. `runResync` re-parses each top-level statement into its OWN tree and
+    * feeds those nodes back through `processRoot`, so there is more than one tree per parse and
+    * "the" tree is not a field anyone can set — `node.tree` is what says which. The build is lazy
+    * because a file that asks no subtree question should not pay for it.
+    */
+  treeIndexes = /* @__PURE__ */ new WeakMap();
+  /** This tree's index, built on first use. One preorder walk, then O(1) thereafter. */
+  indexFor(node) {
+    const tree = node.tree;
+    const existing = this.treeIndexes.get(tree);
+    if (existing) return existing;
+    const byType = /* @__PURE__ */ new Map();
+    const nodes = /* @__PURE__ */ new Map();
+    const stack = [{ node: node.tree.rootNode, depth: 0 }];
+    while (stack.length) {
+      const { node: current, depth } = stack.pop();
+      const count = current.namedChildCount;
+      const children = [];
+      for (let i = 0; i < count; i++) {
+        const child = current.namedChild(i);
+        if (child) children.push(child);
+      }
+      const entry = nodes.get(current.id);
+      if (entry) {
+        entry.children = children;
+        entry.depth = depth;
+      } else nodes.set(current.id, { children, depth });
+      const bucket = byType.get(current.type);
+      if (bucket) bucket.push(current);
+      else byType.set(current.type, [current]);
+      for (let i = children.length - 1; i >= 0; i--) stack.push({ node: children[i], depth: depth + 1 });
+    }
+    const index = { byType, nodes };
+    this.treeIndexes.set(tree, index);
+    return index;
+  }
+  firstIdentifier(node, state) {
+    if (!node) return null;
+    void state;
+    const ids = this.descendants(node, "identifier");
+    if (ids.length) return ids[0];
+    const literals = this.descendants(node, "literal");
+    return literals.length ? literals[0] : null;
+  }
+  containsChildType(node, type) {
+    if (node.type === type) return true;
+    for (const child of this.namedChildren(node)) if (this.containsChildType(child, type)) return true;
+    return false;
+  }
+  /**
+   * An index's key columns, in source order.
+   *
+   * `index_fields` holds a list of `field` nodes, each of which names its column
+   * in a FIELD (`column` for a plain name, `function` for an expression) and
+   * carries the name as a child — an `identifier` when unquoted, a `literal` when
+   * quoted. Collecting `identifier` descendants alone therefore dropped every
+   * quoted index column (`ON t ("b")` reported `[]`) and, on an expression
+   * column, reported the expression's ARGUMENT rather than the expression.
+   * Read the `field`'s own `column` field first, and its `function` text second,
+   * because both are what the writer of the index meant.
+   */
+  identifierTexts(node, state) {
+    if (!node) return [];
+    const out = [];
+    for (const field of this.namedChildren(node)) {
+      if (field.type !== "field") continue;
+      const column = field.childForFieldName?.("column");
+      if (column) {
+        out.push(this.identifierName(column, state));
+        continue;
+      }
+      const fn = field.childForFieldName?.("function");
+      if (fn) {
+        out.push(fn.text);
+        continue;
+      }
+      const leaf = this.firstIdentifier(field, state);
+      if (leaf) out.push(this.identifierName(leaf, state));
+    }
+    return out;
+  }
+  literalTexts(node) {
+    return node ? this.descendants(node, "literal").map((n) => n.text) : [];
+  }
+  containsType(node, type) {
+    return this.findDescendant(node, type) !== null;
+  }
+  /**
+   * The first descendant of `type` in DOCUMENT order, or null.
+   *
+   * Same order `descendants` produces — children pushed in reverse so the stack pops left to
+   * right — but it STOPS at the first match. `descendants(node, type)[0]` walked the entire
+   * subtree and then threw all but one node away, and `containsType` above did the same to ask
+   * a yes/no question; both were hot enough to show in the profile.
+   */
+  /**
+   * The first DESCENDANT of `type` in document order, or null.
+   *
+   * `findDescendant` stops at the first match; `descendants` cannot, because it returns a list.
+   * Both read the same index, so a `null` here and an empty array there mean the same thing.
+   */
+  findDescendant(node, type) {
+    if (node.type === type) return node;
+    const index = this.indexFor(node);
+    const depth = index.nodes.get(node.id).depth;
+    const candidates = index.byType.get(type);
+    if (!candidates) return null;
+    for (let i = this.lowerBound(candidates, node.startIndex); i < candidates.length; i++) {
+      const candidate = candidates[i];
+      if (candidate.startIndex > node.endIndex) break;
+      if (candidate.endIndex <= node.endIndex && index.nodes.get(candidate.id).depth > depth) return candidate;
+    }
+    return null;
+  }
+  /** The first entry of a document-order array whose `startIndex` is >= the given one. */
+  lowerBound(sorted, startIndex) {
+    let lo = 0;
+    let hi = sorted.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (sorted[mid].startIndex < startIndex) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  }
+  firstDescendant(node, type) {
+    return this.findDescendant(node, type);
+  }
+  /**
+   * Every DESCENDANT of `type` in `node`'s subtree, in document order.
+   *
+   * `type` is REQUIRED, not optional. The walk this replaced had an optional type and an untyped
+   * branch, and all 14 call sites passed one — so the untyped branch was unreachable code that a
+   * source count would have called a feature. Requiring the argument turns that from a claim into
+   * a compile error if a caller ever wants the untyped walk.
+   */
+  descendants(node, type) {
+    const index = this.indexFor(node);
+    const entry = index.nodes.get(node.id);
+    let memo = entry.descendants;
+    if (!memo) {
+      memo = /* @__PURE__ */ new Map();
+      entry.descendants = memo;
+    }
+    const hit = memo.get(type);
+    if (hit) return hit;
+    const found = this.withinType(index, node, type);
+    memo.set(type, found);
+    return found;
+  }
+  /** Every node of `type` strictly inside `node`'s subtree, in document order. */
+  withinType(index, node, type) {
+    const candidates = index.byType.get(type);
+    if (!candidates) return [];
+    const depth = index.nodes.get(node.id).depth;
+    const found = [];
+    for (let i = this.lowerBound(candidates, node.startIndex); i < candidates.length; i++) {
+      const candidate = candidates[i];
+      if (candidate.startIndex > node.endIndex) break;
+      if (candidate.endIndex <= node.endIndex && index.nodes.get(candidate.id).depth > depth) found.push(candidate);
+    }
+    return found;
+  }
+  namedChildren(node) {
+    return this.indexFor(node).nodes.get(node.id).children;
+  }
+  /**
+   * 1-based rows AND columns.
+   *
+   * The engine's own ParseError range uses `startPosition.column + 1`
+   * (engine.ts:1180) and every other analyzer that builds a range helper does
+   * the same — this one was the only 0-based range in the tree, so all four
+   * column fields of every SQL symbol were off by one across the whole corpus.
+   * `startIndex`/`endIndex` stay 0-based byte offsets, as everywhere else.
+   */
+  range(node, state) {
+    const slice = state.slice;
+    const startRow = node.startPosition.row + slice.rowOffset;
+    const endRow = node.endPosition.row + slice.rowOffset;
+    return {
+      startLine: startRow + 1,
+      startColumn: node.startPosition.row === 0 ? node.startPosition.column + slice.columnOffset + 1 : node.startPosition.column + 1,
+      endLine: endRow + 1,
+      endColumn: node.endPosition.row === 0 ? node.endPosition.column + slice.columnOffset + 1 : node.endPosition.column + 1,
+      startIndex: node.startIndex + slice.byteOffset,
+      endIndex: node.endIndex + slice.byteOffset
+    };
+  }
+  countLines(content) {
+    let lines = 1;
+    for (let i = 0; i < content.length; i++) if (content[i] === "\n") lines++;
+    return lines;
+  }
+};
+var DECLARATION_NODES = /* @__PURE__ */ new Set([
+  "create_table",
+  "create_view",
+  "create_materialized_view",
+  "create_index",
+  "create_function",
+  "create_procedure",
+  "create_trigger",
+  "create_type",
+  "create_schema",
+  "create_sequence",
+  "create_role",
+  "create_extension",
+  "create_database",
+  "create_policy"
+]);
+export {
+  DECLARATION_NODES,
+  RealSqlAnalyzer,
+  SQL_BUILTINS,
+  SQL_KEYWORDS,
+  SQL_PROVIDED_FUNCTIONS
+};