sqllens 1.0.0 → 1.2.0

package/dist/references/references.js

@@ -1,10 +1,14 @@
 import { nodeAt } from "../document/node-at.js";
-import { displayName, foldIdentifier, foldTableName } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { endPosition } from "../ir/span.js";
 import { originsOf } from "../lineage/lineage.js";
 import { OPEN_PROVIDER } from "../qualify/template-provider.js";
 import { resolveColumnRef, resolveColumnSource } from "../sema/resolve.js";
-const originKey = (o, dialect) => `${foldTableName(o.table, dialect).join(".")}.${foldIdentifier(o.column, dialect)}`;
+const originKey = (o, dialect) => {
+    const b = resolveBehavior(dialect);
+    return `${b.foldTableName(o.table).join(".")}.${b.fold(o.column)}`;
+};
 /**
  * Find the declaration + every occurrence of the symbol under `offset`. Schema-free works for
  * in-query columns and CTE/alias/source names; a base-table column's cross-boundary identity
@@ -27,7 +31,7 @@ function compute(scopes, offset, schema, ast) {
         const id = columnIdentity(hit.scope, ref, schema);
         const raw = hit.expr.parts[hit.expr.parts.length - 1] ?? "";
         if (id)
-            return collectColumn(scopes, id, schema, displayName(raw, scopes.root.dialect));
+            return collectColumn(scopes, id, schema, behaviorOf(scopes.root).displayName(raw));
     }
     // 2. Else: a NAME under the cursor (a CTE name, a source/table name, a source alias). Find the
     //    smallest declaring cst that covers the offset, keyed by its declaring scope.
@@ -46,13 +50,13 @@ function columnIdentity(scope, ref, schema) {
         return {
             tag: "origins",
             keys: new Set(origins.map((o) => originKey(o, d))),
-            column: foldIdentifier(last ?? "", d),
+            column: resolveBehavior(d).fold(last ?? ""),
         };
     }
     // Schema-free / no origin: bind to the in-query source and key on (source object, column).
     const bySource = resolveColumnSource(scope, ref.parts, schema) ?? boundColumn(scope, ref);
     if (bySource)
-        return { tag: "source", source: bySource.source, column: foldIdentifier(bySource.column, d) };
+        return { tag: "source", source: bySource.source, column: resolveBehavior(d).fold(bySource.column) };
     return undefined;
 }
 /** Schema-free bind via the unified binder, normalized to the (source, column) shape. */
@@ -72,7 +76,7 @@ function columnMatches(id, scope, ref, schema) {
     }
     // source identity: same ResolvedSource object + same column name
     const b = resolveColumnSource(scope, ref.parts, schema) ?? boundColumn(scope, ref);
-    return b !== undefined && b.source === id.source && foldIdentifier(b.column, scope.dialect) === id.column;
+    return b !== undefined && b.source === id.source && behaviorOf(scope).fold(b.column) === id.column;
 }
 function collectColumn(scopes, id, schema, symbol) {
     const occ = [];
@@ -113,7 +117,7 @@ function columnDeclaration(root, id, schema) {
                     continue;
                 if (p.name === undefined)
                     continue;
-                if (foldIdentifier(p.name, scope.dialect) !== want)
+                if (behaviorOf(scope).fold(p.name) !== want)
                     continue;
                 // This projection produces a column of the target name. Confirm it shares the identity
                 // by resolving the projection's own column refs — for `origins` identity check overlap,
@@ -188,7 +192,8 @@ function declCstFor(scope, src) {
 }
 function collectName(scopes, hit) {
     const dialect = scopes.root.dialect;
-    const target = foldIdentifier(hit.name, dialect);
+    const b = resolveBehavior(dialect);
+    const target = b.fold(hit.name);
     const occ = [];
     const seen = new Set();
     const add = (cst, role) => {
@@ -217,7 +222,7 @@ function collectName(scopes, hit) {
             if (src.kind === "relation" || src.kind === "pivot")
                 continue;
             const n = sourceName(src);
-            if (n !== undefined && foldIdentifier(n, dialect) === target) {
+            if (n !== undefined && b.fold(n) === target) {
                 const cst = sourceCst(src);
                 // Don't double-count the declaration cst as a reference.
                 if (cst && cst !== declCst)
@@ -226,7 +231,7 @@ function collectName(scopes, hit) {
             // An alias use also references the name when the symbol IS the alias.
             if (hit.kind === "alias") {
                 const a = aliasName(src);
-                if (a !== undefined && foldIdentifier(a, dialect) === target)
+                if (a !== undefined && b.fold(a) === target)
                     add(sourceAliasCst(src), "reference");
             }
         }
@@ -235,7 +240,7 @@ function collectName(scopes, hit) {
     };
     visit(scopes.root);
     return {
-        symbol: displayName(hit.name, dialect),
+        symbol: b.displayName(hit.name),
         kind: hit.kind,
         declaration: declCst ? spanOf(declCst) : undefined,
         occurrences: occ,
@@ -249,7 +254,7 @@ function cteDefCst(root, target) {
     const visit = (scope) => {
         for (const [name, cteRef] of scope.ctes) {
             // Map keys are already folded; the def name is raw and folds here.
-            if (name === target || foldIdentifier(cteRef.def.name, scope.dialect) === target) {
+            if (name === target || behaviorOf(scope).fold(cteRef.def.name) === target) {
                 found = found ?? cteRef.def.cst;
             }
         }

package/dist/scope/like-pattern.d.ts

@@ -0,0 +1,2 @@
+/** SQL LIKE pattern to an anchored case-insensitive RegExp (`%` to `.*`, `_` to `.`). */
+export declare function likePatternToRegExp(pattern: string): RegExp;

package/dist/scope/like-pattern.js

@@ -0,0 +1,15 @@
+// SQL LIKE/ILIKE pattern matching. A leaf module (no scope/IR imports) so the dialect-behavior
+// registry can depend on it without pulling in scope.ts — which imports the behavior carrier, which
+// imports the registry (the cycle this split breaks).
+//
+// NOTE: LIKE pattern semantics are dialect-specific (T-SQL adds `[a-c]` / `[^…]` character classes and
+// an ESCAPE clause; Postgres/Snowflake treat `[` as a literal). This shared `%`/`_` translation is the
+// current floor, exposed per-dialect via DialectBehavior.likeMatch so a dialect can override it later.
+/** SQL LIKE pattern to an anchored case-insensitive RegExp (`%` to `.*`, `_` to `.`). */
+export function likePatternToRegExp(pattern) {
+    const escaped = pattern
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/%/g, ".*")
+        .replace(/_/g, ".");
+    return new RegExp(`^${escaped}$`, "i");
+}

package/dist/scope/scope.d.ts

@@ -1,5 +1,6 @@
 import type { ColumnRef, CteDef, GraphTableSource, LateralViewSource, PipeStage, PivotInfo, QueryBody, QueryExpr, SubquerySource, TableSource, UnpivotInfo } from "../ir/ir.js";
 import type { StatementCategory } from "../ir/statement.js";
+import { likePatternToRegExp } from "./like-pattern.js";
 export interface ScopeTree {
     /** Discriminant tag — lets api.ts's `isScopeTree` identify a ScopeTree structurally
      *  instead of shape-sniffing `root`/`statement`. */
@@ -126,7 +127,7 @@ export declare function splitColumnRefInScope(scope: Scope, parts: string[]): Sp
  *  the unified binder (src/sema/resolve.ts) for the projection-alias fallback. */
 export declare function aliasVisibleClause(clause: ColumnRef["clause"] | undefined): boolean;
 export declare function matchesProjectionAlias(scope: Scope, name: string): boolean;
-export declare function applyPivotCols(base: string[], p: PivotInfo, dialect?: string): string[];
+export declare function applyPivotCols(base: string[], p: PivotInfo, dialect?: string): string[] | "unknown";
 export declare function applyUnpivotCols(base: string[], u: UnpivotInfo, dialect?: string): string[];
 /** `UNION BY NAME` output: left columns in order, then right-only columns appended. */
 export declare function mergeByName(left: string[] | "unknown", right: string[] | "unknown", dialect?: string): string[] | "unknown";
@@ -140,15 +141,14 @@ export declare function applyStarModifiers(cols: string[], star: {
         to: string;
     }[];
 }, dialect?: string): string[];
-/** SQL LIKE pattern → an anchored case-insensitive RegExp (`%` → `.*`, `_` → `.`). */
-export declare function likePatternToRegExp(pattern: string): RegExp;
+export { likePatternToRegExp };
 /** The columns a resolved source exposes, or "unknown" when it needs a schema (a bare table).
  *  Exported for the unified binder's schema-free path (src/sema/resolve.ts). */
-export declare function sourceOutputs(src: ResolvedSource): string[] | "unknown";
+export declare function sourceOutputs(src: ResolvedSource, dialect: string): string[] | "unknown";
 /** The reshaped columns of an aliased PIVOT/UNPIVOT source: its base columns (via `cols`) with the
  *  pivot/unpivot transform applied. "unknown" if any base relation's columns need a schema we lack.
  *  Shared by the schema-free scope path and the schema-fed qualify / resolve / lineage passes (each
  *  passes its own column resolver), so an aliased pivot exposes the same reshaped set everywhere. */
 export declare function pivotSourceOutputs(src: Extract<ResolvedSource, {
     kind: "pivot";
-}>, cols: (s: ResolvedSource) => string[] | "unknown"): string[] | "unknown";
+}>, cols: (s: ResolvedSource) => string[] | "unknown", dialect: string | undefined): string[] | "unknown";

package/dist/scope/scope.js

@@ -1,4 +1,6 @@
-import { foldIdentifier } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
+import { likePatternToRegExp } from "./like-pattern.js";
 export function resolveScopes(query, dialect) {
     const d = dialect ?? query.dialect;
     if (!d)
@@ -15,11 +17,12 @@ export function resolveScopes(query, dialect) {
  * or the table fold (these differ only for BigQuery's case-preserving table identifiers).
  */
 export function splitColumnRef(parts, isSource, dialect) {
+    const b = resolveBehavior(dialect);
     const keyOf = (part) => {
-        const k = foldIdentifier(part, dialect);
+        const k = b.fold(part);
         if (isSource(k))
             return k;
-        const kt = foldIdentifier(part, dialect, "table");
+        const kt = b.fold(part, "table");
         return kt !== k && isSource(kt) ? kt : undefined;
     };
     // `schema.table.col[.field…]` — the 2-token qualifier is keyed by the table (its last part).
@@ -54,8 +57,9 @@ export function aliasVisibleClause(clause) {
     return clause === "groupBy" || clause === "having" || clause === "qualify" || clause === "orderBy";
 }
 export function matchesProjectionAlias(scope, name) {
-    const n = foldIdentifier(name, scope.dialect);
-    return aliasNames(scope).some((a) => foldIdentifier(a, scope.dialect) === n);
+    const b = behaviorOf(scope);
+    const n = b.fold(name);
+    return aliasNames(scope).some((a) => b.fold(a) === n);
 }
 /** The output alias names of a scope — a select's projection names, or (for a set op) the
  *  left branch's, since a union's output columns come from its first branch. */
@@ -90,7 +94,7 @@ function buildQueryScope(query, parent, dialect) {
         // Declared column aliases (WITH c (x, y) AS …) rename what the CTE exposes.
         if (cte.columnAliases)
             cteScope.outputs = cte.columnAliases;
-        scope.ctes.set(foldIdentifier(cte.name, scope.dialect), { def: cte, scope: cteScope });
+        scope.ctes.set(behaviorOf(scope).fold(cte.name), { def: cte, scope: cteScope });
         scope.children.push(cteScope);
     }
     fillScope(scope);
@@ -126,7 +130,7 @@ function fillScope(scope) {
     const pivotAlias = body.pivot?.alias ?? body.unpivot?.alias;
     if (pivotAlias) {
         const base = body.from.map((source) => resolveSource(scope, source));
-        scope.sources.set(foldIdentifier(pivotAlias, scope.dialect), {
+        scope.sources.set(behaviorOf(scope).fold(pivotAlias), {
             kind: "pivot",
             alias: pivotAlias,
             base,
@@ -213,7 +217,7 @@ function buildStageScope(pipeScope, stage, incoming) {
             const cteScope = buildQueryScope(cte.body, ss);
             if (cte.columnAliases)
                 cteScope.outputs = cte.columnAliases;
-            ss.ctes.set(foldIdentifier(cte.name, ss.dialect), { def: cte, scope: cteScope });
+            ss.ctes.set(behaviorOf(ss).fold(cte.name), { def: cte, scope: cteScope });
             ss.children.push(cteScope);
         }
     }
@@ -285,7 +289,7 @@ function buildGraphScope(parent, src) {
             alias: el.variable,
             cst: el.variableCst ?? el.cst,
         };
-        scope.sources.set(foldIdentifier(el.variable, scope.dialect), {
+        scope.sources.set(behaviorOf(scope).fold(el.variable), {
             kind: "table",
             name: [el.variable],
             source: ts,
@@ -324,13 +328,13 @@ function stageOutputsFree(stage, incoming, scope) {
         case "drop":
             if (incoming === "unknown")
                 return "unknown";
-            return incoming.filter((c) => !stage.drop.some((d) => foldIdentifier(d, scope.dialect) === foldIdentifier(c, scope.dialect)));
+            return incoming.filter((c) => !stage.drop.some((d) => behaviorOf(scope).fold(d) === behaviorOf(scope).fold(c)));
         case "rename":
             if (incoming === "unknown")
                 return "unknown";
             return applyRenameList(incoming, stage.renames, scope.dialect);
         case "select":
-            return projectionOutputsFree(stage.projections, incoming);
+            return projectionOutputsFree(stage.projections, incoming, scope.dialect);
         case "aggregate":
             return aggregateOutputsFree(stage, incoming);
         case "extend":
@@ -348,7 +352,7 @@ function stageOutputsFree(stage, incoming, scope) {
 }
 /** Project a star-or-named list against the incoming columns (schema-free: incoming is the only source,
  *  so a qualified `t.*` or an anonymous expression yields "unknown"). */
-function projectionOutputsFree(projections, incoming) {
+function projectionOutputsFree(projections, incoming, dialect) {
     if (projections.length === 0)
         return "unknown";
     const names = [];
@@ -359,7 +363,7 @@ function projectionOutputsFree(projections, incoming) {
             const star = p.expr.kind === "star" ? p.expr : undefined;
             if (star?.qualifier)
                 return "unknown";
-            names.push(...(star ? applyStarModifiers(incoming, star) : incoming));
+            names.push(...(star ? applyStarModifiers(incoming, star, dialect) : incoming));
         }
         else if (p.name !== undefined) {
             names.push(p.name);
@@ -395,8 +399,9 @@ function simpleProjNames(projections) {
     return names;
 }
 function applyRenameList(cols, renames, dialect) {
-    const map = new Map(renames.map((r) => [foldIdentifier(r.from, dialect), r.to]));
-    return cols.map((c) => map.get(foldIdentifier(c, dialect)) ?? c);
+    const b = resolveBehavior(dialect);
+    const map = new Map(renames.map((r) => [b.fold(r.from), r.to]));
+    return cols.map((c) => map.get(b.fold(c)) ?? c);
 }
 /** A select's output columns, accounting for a PIVOT/UNPIVOT transforming the FROM relation. */
 function computeOutputs(scope, body) {
@@ -412,7 +417,7 @@ function computeOutputs(scope, body) {
 function baseRelationColumns(scope) {
     for (const src of scope.sources.values()) {
         if (src.kind !== "lateral")
-            return sourceOutputs(src);
+            return sourceOutputs(src, scope.dialect);
     }
     return "unknown";
 }
@@ -421,12 +426,15 @@ function baseRelationColumns(scope) {
 // in scope.outputs). PIVOT consumes the FOR + aggregate columns and adds the IN-list value columns;
 // UNPIVOT consumes the IN-list columns and adds the name + value columns; both keep the passthrough rest.
 export function applyPivotCols(base, p, dialect) {
-    const fold = (n) => foldIdentifier(n, dialect);
+    // Data-dependent pivot (no static IN-list): output columns are not enumerable — never guess.
+    if (p.dynamic)
+        return "unknown";
+    const fold = (n) => resolveBehavior(dialect).fold(n);
     const consumed = new Set([...p.forColumns, ...p.aggColumns].map(fold));
     return [...base.filter((c) => !consumed.has(fold(c))), ...p.values];
 }
 export function applyUnpivotCols(base, u, dialect) {
-    const fold = (n) => foldIdentifier(n, dialect);
+    const fold = (n) => resolveBehavior(dialect).fold(n);
     const removed = new Set(u.removed.map(fold));
     return [...base.filter((c) => !removed.has(fold(c))), u.nameColumn, u.valueColumn];
 }
@@ -442,21 +450,23 @@ function pivotOutputs(scope, p) {
 export function mergeByName(left, right, dialect) {
     if (left === "unknown" || right === "unknown")
         return "unknown";
-    const seen = new Set(left.map((c) => foldIdentifier(c, dialect)));
-    return [...left, ...right.filter((c) => !seen.has(foldIdentifier(c, dialect)))];
+    const b = resolveBehavior(dialect);
+    const seen = new Set(left.map((c) => b.fold(c)));
+    return [...left, ...right.filter((c) => !seen.has(b.fold(c)))];
 }
 /** Apply a star node's modifiers to an expansion: EXCLUDE/EXCEPT removes, ILIKE filters by
  *  pattern, RENAME renames (REPLACE keeps name and position — no expansion change). */
 export function applyStarModifiers(cols, star, dialect) {
-    const fold = (n) => foldIdentifier(n, dialect);
+    const fold = (n) => resolveBehavior(dialect).fold(n);
     let out = cols;
     if (star.exclude) {
         const removed = new Set(star.exclude.map(fold));
         out = out.filter((c) => !removed.has(fold(c)));
     }
     if (star.ilike !== undefined) {
-        const rx = likePatternToRegExp(star.ilike);
-        out = out.filter((c) => rx.test(fold(c)));
+        const b = resolveBehavior(dialect);
+        const pat = star.ilike;
+        out = out.filter((c) => b.likeMatch(pat, fold(c)));
     }
     if (star.rename) {
         const renames = new Map(star.rename.map((r) => [fold(r.from), r.to]));
@@ -464,14 +474,9 @@ export function applyStarModifiers(cols, star, dialect) {
     }
     return out;
 }
-/** SQL LIKE pattern → an anchored case-insensitive RegExp (`%` → `.*`, `_` → `.`). */
-export function likePatternToRegExp(pattern) {
-    const escaped = pattern
-        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-        .replace(/%/g, ".*")
-        .replace(/_/g, ".");
-    return new RegExp(`^${escaped}$`, "i");
-}
+// likePatternToRegExp moved to ./like-pattern.js (leaf module, breaks the scope->carrier->registry
+// cycle); re-exported here so existing importers keep resolving it from scope.ts.
+export { likePatternToRegExp };
 function outputsOf(body) {
     if (body.projections.length === 0)
         return "unknown";
@@ -486,7 +491,7 @@ function outputsOf(body) {
 function lookupCte(scope, name) {
     if (!scope)
         return undefined;
-    const key = foldIdentifier(name, scope.dialect);
+    const key = behaviorOf(scope).fold(name);
     for (let s = scope; s; s = s.parent) {
         const hit = s.ctes.get(key);
         if (hit)
@@ -499,23 +504,24 @@ function lookupCte(scope, name) {
  *  `o.col` binds to `"O"` but not `"o"`). Aliases fold as "other"; a table's own name part folds
  *  as kind "table" (BigQuery preserves table case). */
 function sourceKey(source, dialect, isCte = false) {
+    const b = resolveBehavior(dialect);
     if (source.kind === "lateral")
-        return foldIdentifier(source.alias ?? "", dialect);
+        return b.fold(source.alias ?? "");
     if (source.kind === "graphtable") {
         return source.alias
-            ? foldIdentifier(source.alias, dialect)
-            : foldIdentifier(source.graph[source.graph.length - 1] ?? "graph_table", dialect, "table");
+            ? b.fold(source.alias)
+            : b.fold(source.graph[source.graph.length - 1] ?? "graph_table", "table");
     }
     if (source.alias)
-        return foldIdentifier(source.alias, dialect);
+        return b.fold(source.alias);
     if (source.kind === "table") {
-        return foldIdentifier(source.name[source.name.length - 1] ?? "", dialect, isCte ? "other" : "table");
+        return b.fold(source.name[source.name.length - 1] ?? "", isCte ? "other" : "table");
     }
     return "";
 }
 /** The columns a resolved source exposes, or "unknown" when it needs a schema (a bare table).
  *  Exported for the unified binder's schema-free path (src/sema/resolve.ts). */
-export function sourceOutputs(src) {
+export function sourceOutputs(src, dialect) {
     if (src.kind === "table")
         return src.source.columnAliases ?? "unknown";
     if (src.kind === "cte")
@@ -527,21 +533,21 @@ export function sourceOutputs(src) {
     if (src.kind === "graphtable")
         return src.scope.outputs;
     if (src.kind === "pivot")
-        return pivotSourceOutputs(src, (s) => sourceOutputs(s));
+        return pivotSourceOutputs(src, (s) => sourceOutputs(s, dialect), dialect);
     return src.scope.outputs; // subquery
 }
 /** The reshaped columns of an aliased PIVOT/UNPIVOT source: its base columns (via `cols`) with the
  *  pivot/unpivot transform applied. "unknown" if any base relation's columns need a schema we lack.
  *  Shared by the schema-free scope path and the schema-fed qualify / resolve / lineage passes (each
  *  passes its own column resolver), so an aliased pivot exposes the same reshaped set everywhere. */
-export function pivotSourceOutputs(src, cols) {
+export function pivotSourceOutputs(src, cols, dialect) {
     const parts = src.base.map(cols);
     if (parts.some((p) => p === "unknown"))
         return "unknown";
     const base = parts.flat();
     if (src.pivot)
-        return applyPivotCols(base, src.pivot);
+        return applyPivotCols(base, src.pivot, dialect);
     if (src.unpivot)
-        return applyUnpivotCols(base, src.unpivot);
+        return applyUnpivotCols(base, src.unpivot, dialect);
     return "unknown";
 }

package/dist/sema/resolve.js

@@ -1,4 +1,5 @@
-import { foldIdentifier, matchesSourceKey } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { tableSourceColumns } from "../qualify/relation-columns.js";
 import { aliasVisibleClause, applyPivotCols, applyStarModifiers, applyUnpivotCols, matchesProjectionAlias, mergeByName, pivotSourceOutputs, sourceOutputs, splitColumnRefInScope, } from "../scope/scope.js";
 /**
@@ -54,12 +55,12 @@ function resolveParts(scope, parts, clause, schema) {
  * outward; without a schema an unknown source yields `needs-schema`.
  */
 function resolveByName(scope, column, fields, schema) {
-    const name = foldIdentifier(column, scope.dialect);
+    const name = behaviorOf(scope).fold(column);
     const sources = [...scope.sources.values()];
-    const colsOf = (src) => schema ? (columnNamesOf(src, schema, undefined, scope.dialect) ?? "unknown") : sourceOutputs(src);
+    const colsOf = (src) => schema ? (columnNamesOf(src, schema, undefined, scope.dialect) ?? "unknown") : sourceOutputs(src, scope.dialect);
     const matches = sources.filter((s) => {
         const cols = colsOf(s);
-        return cols !== "unknown" && cols.some((c) => foldIdentifier(c, scope.dialect) === name);
+        return cols !== "unknown" && cols.some((c) => behaviorOf(scope).fold(c) === name);
     });
     if (matches.length === 1)
         return { kind: "bound", source: matches[0], column, fields };
@@ -93,12 +94,13 @@ export function resolveColumnSource(scope, parts, schema) {
  * name folds equal. Returns undefined when no projection produces the column (a bare `*`/source).
  */
 export function findProducerProjection(projections, column, aliases, dialect) {
-    const want = foldIdentifier(column, dialect);
+    const b = resolveBehavior(dialect);
+    const want = b.fold(column);
     if (aliases) {
-        const i = aliases.findIndex((a) => foldIdentifier(a, dialect) === want);
+        const i = aliases.findIndex((a) => b.fold(a) === want);
         return i >= 0 ? projections[i] : undefined;
     }
-    return projections.find((p) => !p.isStar && p.name !== undefined && foldIdentifier(p.name, dialect) === want);
+    return projections.find((p) => !p.isStar && p.name !== undefined && b.fold(p.name) === want);
 }
 /** The output column names a source exposes — schema for a table, the (schema-expanded) output
  *  names for a derived relation (column aliases rename them), the AS columns for a lateral view.
@@ -119,7 +121,7 @@ export function columnNamesOf(src, schema, visited = new Set(), dialect) {
     if (src.kind === "graphtable")
         return outputNames(src.scope, schema, visited);
     if (src.kind === "pivot") {
-        const r = pivotSourceOutputs(src, (s) => columnNamesOf(s, schema, visited, dialect) ?? "unknown");
+        const r = pivotSourceOutputs(src, (s) => columnNamesOf(s, schema, visited, dialect) ?? "unknown", dialect);
         return r === "unknown" ? undefined : r;
     }
     return src.source.columns; // lateral
@@ -166,7 +168,10 @@ function computeOutputNames(scope, schema, visited) {
     // A PIVOT/UNPIVOT with no result alias reshapes the FROM relation — expand the sources, transform.
     if (body.pivot && !body.pivot.alias) {
         const base = sourceColumnsAll(scope, schema, visited);
-        return base ? applyPivotCols(base, body.pivot, scope.dialect) : undefined;
+        if (!base)
+            return undefined;
+        const out = applyPivotCols(base, body.pivot, scope.dialect);
+        return out === "unknown" ? undefined : out; // dynamic pivot → unknown, resolved as undefined here
     }
     if (body.unpivot && !body.unpivot.alias) {
         const base = sourceColumnsAll(scope, schema, visited);
@@ -194,7 +199,7 @@ function projectionNames(scope, projections, schema, visited) {
             const want = star?.qualifier ? (star.qualifier[star.qualifier.length - 1] ?? "") : undefined;
             const expanded = [];
             for (const [key, src] of scope.sources) {
-                if (want !== undefined && !matchesSourceKey(key, want, scope.dialect))
+                if (want !== undefined && !behaviorOf(scope).matchesSourceKey(key, want))
                     continue;
                 const cols = columnNamesOf(src, schema, visited, scope.dialect);
                 if (!cols)
@@ -240,13 +245,13 @@ function pipeStageNames(scope, schema, visited) {
             return [...aggs, ...keys];
         }
         case "drop": {
-            const fold = (n) => foldIdentifier(n, scope.dialect);
+            const fold = (n) => behaviorOf(scope).fold(n);
             return incoming ? incoming.filter((c) => !stage.drop.some((d) => fold(d) === fold(c))) : undefined;
         }
         case "rename": {
             if (!incoming)
                 return undefined;
-            const fold = (n) => foldIdentifier(n, scope.dialect);
+            const fold = (n) => behaviorOf(scope).fold(n);
             const m = new Map(stage.renames.map((r) => [fold(r.from), r.to]));
             return incoming.map((c) => m.get(fold(c)) ?? c);
         }

package/dist/session.d.ts

@@ -14,7 +14,7 @@ import type { SchemaProvider } from "./qualify/schema-provider.js";
 import { type TemplateProvider } from "./qualify/template-provider.js";
 import type { Occurrences } from "./references/references.js";
 import type { LineageHop } from "./lineage/hops.js";
-import { type SignatureInfo } from "./signature/signature.js";
+import { type SignatureHelpInfo } from "./signature/signature.js";
 import type { Scope, ScopeTree } from "./scope/scope.js";
 import type { Span, Sym } from "./symbols/symbols.js";
 import type { TemplateEngine } from "./template/engine.js";
@@ -69,7 +69,7 @@ export declare class SqlSession {
      *  infers it. A miss returns Type's own `unknown` (src/infer/types.ts's UNKNOWN), never a throw. */
     typeAt(offset: number): Type;
     completeAt(offset: number): Completion[];
-    signatureAt(offset: number): SignatureInfo | null;
+    signatureAt(offset: number): SignatureHelpInfo | null;
     referencesAt(offset: number): Occurrences | null;
     lineageAt(offset: number): LineageHop | undefined;
     variantAt(offset: number): DocumentVariant | undefined;

package/dist/signature/signature.d.ts

@@ -1,14 +1,22 @@
 import type { SqlDocument } from "../document/document.js";
 import type { SchemaProvider } from "../qualify/schema-provider.js";
-/** What the editor shows while typing inside a call's parens. */
-export interface SignatureInfo {
-    /** e.g. "date_add(start_date: date, num_days: int)" — or just "myfunc" when uncurated. */
+/** One rendered overload: e.g. "date_add(start_date: date, num_days: int)". */
+export interface SignatureLabel {
     label: string;
-    /** One per param; [] when uncurated. */
+    /** One per param; [] for the name-only fallback entry. */
     parameters: {
         label: string;
     }[];
-    /** 0-based arg index the caret is in. */
+}
+/** What the editor shows while typing inside a call's parens: every overload of the called name,
+ *  which one is active, and which of ITS params the caret is in. */
+export interface SignatureHelpInfo {
+    /** Every overload of the called name, in harvested/authored order; a single one-element array for
+     *  an uncurated name (the name-only fallback) or a name with one documented shape. */
+    signatures: SignatureLabel[];
+    /** Index into `signatures` of the overload the editor should highlight. */
+    activeSignature: number;
+    /** 0-based arg index the caret is in, within the active signature. */
     activeParameter: number;
 }
 /**
@@ -16,4 +24,4 @@ export interface SignatureInfo {
  * recognizable call. `schema` is accepted for parity with the other features (and future
  * overload selection) but the curated tables don't need it today. NEVER throws.
  */
-export declare function signatureAt(doc: SqlDocument, offset: number, _schema?: SchemaProvider): SignatureInfo | null;
+export declare function signatureAt(doc: SqlDocument, offset: number, _schema?: SchemaProvider): SignatureHelpInfo | null;