sqllens 1.1.0 → 1.2.0

package/dist/minijinja/tag-ast.js

@@ -1,41 +1,36 @@
 // ---------------------------------------------------------------------------
-// Task 4 — R2 tag-AST: ref / source / macro-call nodes with the EXACT span
-// contract (docs/minijinja-front-end.md §R2). This is the HARD deliverable: the
-// dbt-anvil extension positions hover / rename / signature-help exactly on the
-// spans emitted here, so every offset must be document-true.
+// R2 tag-AST: the NEUTRAL tag node with the EXACT span contract
+// (docs/minijinja-front-end.md §R2). This is the HARD deliverable: the editor
+// positions hover / rename / signature-help exactly on the spans emitted here, so
+// every offset must be document-true.
 //
 // The walk is a small tree-navigation over the per-tag jinja parse tree, built by
-// parse.ts from a DOCUMENT-native token slice (segment.ts's `tagTokens` — the one
+// parse.ts from a DOCUMENT-native token slice (segment.ts's `tagTokens`, the one
 // whole-document tokenization, sliced per tag via antlr4ng's `ListTokenSource`).
 // Every token in that slice already carries its real document start/stop/line/
 // column, so every span read off it is document-true with NO offset/anchor
-// composition — the parity UPGRADE over the extension's single-line-lossy regex
-// extractors, now by construction rather than by a doc-offset shift.
+// composition.
 //
-// Classification is by the LEADING call name (§R2 / §the hole):
-//   - a bare `ref(...)`             → ref node    (model = last positional string)
-//   - a bare `source(...)`          → source node (source + table, both strings)
-//   - a bare `var(...)`/`env_var(…)`→ that node kind
-//   - a leading NO_OUTPUT_BUILTIN   → config → "config"; the rest → "other"
-//     (config/docs/print/log/return/exceptions — REUSES segment.ts's set, the
-//      single source of truth; `exceptions.raise_compiler_error(…)` classifies
-//      off the leading `exceptions` too)
-//   - `pkg.macro(...)` or a bare unknown call → macro node
-//   - any other expr (bare name, literal, arithmetic) → "other"
-//   - a `{% … %}` statement tag     → "control" (inc1 treatment; precise
-//     if/for/set structure + `{% do macro() %}` macro-in-stmt is inc2)
-//   - a `{# … #}` comment tag       → "other"
+// The tag AST carries NO dbt vocabulary. Every expression tag classifies into one
+// of three neutral kinds:
+//   - a leading call `name(args)` (bare or `pkg.name`) → a "call" node. ref/source/
+//     config/var/env_var/a user macro are ALL just callees, distinguished by `name`.
+//     Whether `ref` denotes a relation is the provider's knowledge, not the tag AST.
+//     Each arg carries {value, span, valueSpan}: a consumer that knows a call's arg
+//     roles (dbt: ref's model is the last arg) reads value + valueSpan straight off.
+//   - a `{% … %}` statement tag → "control" (if/for/set/macro structure).
+//   - any other expr (a bare name, a literal, arithmetic) or a `{# … #}` comment →
+//     "other".
 //
-// Never-wrong (global-constraints): a ref/source node is emitted only when its
-// required string args are actually present; a broken `{{ ref( }}` degrades to a
-// macro node (name = "ref") + the parse's positioned diagnostic, never a ref
-// node with a fabricated modelSpan and never a throw.
+// Never-wrong (global-constraints): a string arg's `value` is a real literal only
+// (a computed arg like `ref(var('x'))` has `value: null`, never fabricated); a
+// broken `{{ ref( }}` degrades to a best-effort node + the parse's positioned
+// diagnostic, never a throw.
 // ---------------------------------------------------------------------------
-import { ParserRuleContext, TerminalNode } from "antlr4ng";
+import { ParserRuleContext, TerminalNode, Token as AntlrToken } from "antlr4ng";
 import { MinijinjaParser } from "../generated/minijinja/MinijinjaParser.js";
 import { CallExprContext, Endraw_tagContext, MemberExprContext, NameExprContext, Raw_tagContext, StmtContext, } from "../generated/minijinja/MinijinjaParser.js";
 import { endPosition } from "../ir/span.js";
-import { NO_OUTPUT_BUILTINS } from "./segment.js";
 // ---------------------------------------------------------------------------
 // Span helpers. The tokens here come from parse.ts's per-tag `ListTokenSource`
 // slice over the ONE whole-document tokenization (segment.ts's `tagTokens`), so
@@ -257,9 +252,9 @@ function argInfo(call) {
     const args = [];
     if (argList) {
         for (const arg of argList.arg()) {
-            const span = spanOfNode(arg);
-            if (span)
-                args.push({ span });
+            const a = argOf(arg);
+            if (a)
+                args.push(a);
         }
     }
     let argsSpan;
@@ -271,6 +266,42 @@ function argInfo(call) {
     }
     return { args, ...(argsSpan ? { argsSpan } : {}) };
 }
+/** The bare literal token types an argument can be (besides STRING): a consumer reads their text as
+ *  the arg value. */
+const LITERAL_TOKENS = new Set([
+    MinijinjaParser.INT,
+    MinijinjaParser.FLOAT,
+    MinijinjaParser.TRUE,
+    MinijinjaParser.FALSE,
+    MinijinjaParser.NONE,
+]);
+/** One argument as `{value, span, valueSpan?}`. `span` is the WHOLE arg (incl. any `name=` and quotes).
+ *  The literal VALUE + its quote-excluded `valueSpan` come from the value expression: for a kwarg
+ *  (`model='x'`) that's the RHS, for a positional it's the arg itself. A STRING literal yields the
+ *  stripped value + content span; a bare number/bool/none yields its text + its span; anything
+ *  computed yields `value: null` (never fabricated). undefined only when the arg has no span at all. */
+function argOf(arg) {
+    const span = spanOfNode(arg);
+    if (!span)
+        return undefined;
+    const valueCtx = isKwarg(arg) ? kwargValue(arg) : arg;
+    if (valueCtx) {
+        const str = directStringToken(valueCtx);
+        if (str)
+            return { value: stringValue(str), span, valueSpan: stringContentSpan(str) };
+        const v = valueCtx.start;
+        if (v && v === valueCtx.stop && LITERAL_TOKENS.has(v.type)) {
+            return { value: v.text ?? null, span, valueSpan: spanOfNode(valueCtx) };
+        }
+    }
+    return { value: null, span };
+}
+/** The value expression of a kwarg (`id = expr` → the `expr`), or undefined. It is the last child;
+ *  the ASSIGN and id precede it. */
+function kwargValue(arg) {
+    const last = arg.getChild(arg.getChildCount() - 1);
+    return last instanceof ParserRuleContext ? last : undefined;
+}
 /**
  * Extract a CallExprContext into the reusable MacroCall fields — name/nameSpan +
  * optional package via `decomposeCallee`, args[] + argsSpan via `argInfo`. Returns
@@ -279,7 +310,7 @@ function argInfo(call) {
  * fabricated (never-wrong). The `{{ }}` macro node and the `{% %}` control tag both
  * build from this, so a call surfaces identically wherever it appears.
  */
-export function callToMacroCall(call) {
+function callToMacroCall(call) {
     const callee = decomposeCallee(call);
     if (!callee || !callee.nameSpan)
         return undefined;
@@ -306,26 +337,159 @@ function macroNode(call, callee, tagSpan, tree) {
         if (mc)
             calls.push(mc);
     }
+    const callSpan = spanOfNode(call) ?? tagSpan;
     const mc = callToMacroCall(call);
     if (mc)
-        return { kind: "macro", ...mc, tagSpan, calls };
+        return { kind: "call", ...mc, callSpan, tagSpan, calls };
     // Degenerate fallback: a callee with a name but no locatable span (a broken
     // tree). Preserve the pre-refactor node shape — nameSpan defaults to tagSpan,
     // args are still extracted. (Unreachable for a well-formed parsed call, where
     // the identifier token always has a span; kept for behavioral parity.)
     const { args, argsSpan } = argInfo(call);
     return {
-        kind: "macro",
+        kind: "call",
         name: callee.name,
         nameSpan: tagSpan,
         ...(callee.packageName !== undefined ? { packageName: callee.packageName } : {}),
         ...(callee.packageSpan !== undefined ? { packageSpan: callee.packageSpan } : {}),
+        callSpan,
         tagSpan,
         ...(argsSpan ? { argsSpan } : {}),
         args,
         calls,
     };
 }
+/** The tag's significant tokens: default channel, no EOF, no `{{`/`}}`/`{%` delimiters. */
+function significantTokens(tokens) {
+    const P = MinijinjaParser;
+    return tokens.filter((t) => t.channel === AntlrToken.DEFAULT_CHANNEL &&
+        t.type !== AntlrToken.EOF &&
+        t.type !== P.EXPR_OPEN &&
+        t.type !== P.EXPR_CLOSE &&
+        t.type !== P.STMT_OPEN);
+}
+/** The INNERMOST still-open CALL paren in `sig` (the call being typed), or undefined when none is
+ *  open. Every `(` is pushed (a call when the token before it is an `id` / `pkg.id`, else a grouping
+ *  paren = null) and every `)` pops, so `outer(inner(` reports inner, a call after a keyword
+ *  (`if is_incremental(`) is found past the leading words, and a grouping paren never masks the call
+ *  it sits inside. */
+function trailingOpenCall(sig) {
+    const P = MinijinjaParser;
+    const stack = [];
+    for (let i = 0; i < sig.length; i++) {
+        const t = sig[i];
+        if (t.type === P.LPAREN) {
+            const prev = sig[i - 1];
+            if (prev?.type === P.ID) {
+                const packageTok = sig[i - 2]?.type === P.DOT && sig[i - 3]?.type === P.ID ? sig[i - 3] : undefined;
+                stack.push({ nameTok: prev, ...(packageTok ? { packageTok } : {}), lparenIdx: i });
+            }
+            else {
+                stack.push(null); // a grouping paren, not a call
+            }
+        }
+        else if (t.type === P.RPAREN) {
+            stack.pop();
+        }
+    }
+    for (let k = stack.length - 1; k >= 0; k--) {
+        const e = stack[k];
+        if (e)
+            return e;
+    }
+    return undefined;
+}
+/** The args of an unclosed call: the significant tokens from just after its `(` (index `from`) to the
+ *  end, split into args by top-level commas. Best-effort per `argFromTokens`. */
+function argsFrom(sig, from) {
+    const P = MinijinjaParser;
+    const args = [];
+    let depth = 0;
+    let cur = [];
+    for (let i = from; i < sig.length; i++) {
+        const t = sig[i];
+        if (t.type === P.LPAREN) {
+            depth++;
+            cur.push(t);
+        }
+        else if (t.type === P.RPAREN) {
+            if (depth === 0)
+                break;
+            depth--;
+            cur.push(t);
+        }
+        else if (t.type === P.COMMA && depth === 0) {
+            if (cur.length > 0)
+                args.push(argFromTokens(cur));
+            cur = [];
+        }
+        else {
+            cur.push(t);
+        }
+    }
+    if (cur.length > 0)
+        args.push(argFromTokens(cur));
+    return args;
+}
+/** The reusable MacroCall fields of the innermost unclosed call in `tokens`, or undefined when none is
+ *  open (a bare name / non-call expr). Shared by the expr-tag node recovery and the control-tag
+ *  embedded-call recovery. Args are best-effort: a complete STRING is value + quote-excluded span; a
+ *  partial or computed arg is `value: null` + its span (never fabricated). */
+function openCall(tokens) {
+    const sig = significantTokens(tokens);
+    const open = trailingOpenCall(sig);
+    if (!open)
+        return undefined;
+    const lparen = sig[open.lparenIdx];
+    const last = sig[sig.length - 1];
+    return {
+        name: open.nameTok.text ?? "",
+        nameSpan: spanFromTokens(open.nameTok, open.nameTok),
+        ...(open.packageTok
+            ? { packageName: open.packageTok.text ?? "", packageSpan: spanFromTokens(open.packageTok, open.packageTok) }
+            : {}),
+        argsSpan: spanFromTokens(lparen, last),
+        args: argsFrom(sig, open.lparenIdx + 1),
+    };
+}
+/** An UNCLOSED / mid-typing expr-tag call (`{{ ref('cu`, `{{ outer(inner(`) recovered as a neutral
+ *  "call" node flagged `incomplete: true`, so completion can place the caret's slot. Reports the
+ *  INNERMOST open call. Undefined when there's no open `id (` (a bare name / non-call expr stays
+ *  "other"). */
+function incompleteCall(tokens, tagSpan) {
+    const c = openCall(tokens);
+    if (!c || !c.argsSpan)
+        return undefined;
+    const from = c.packageSpan ?? c.nameSpan;
+    return {
+        kind: "call",
+        name: c.name,
+        nameSpan: c.nameSpan,
+        ...(c.packageName !== undefined ? { packageName: c.packageName, packageSpan: c.packageSpan } : {}),
+        callSpan: {
+            start: from.start,
+            end: c.argsSpan.end,
+            line: from.line,
+            column: from.column,
+            endLine: c.argsSpan.endLine,
+            endColumn: c.argsSpan.endColumn,
+        },
+        tagSpan,
+        argsSpan: c.argsSpan,
+        args: c.args,
+        calls: [],
+        incomplete: true,
+    };
+}
+/** One arg of an incomplete call from its raw tokens: a lone complete STRING → value + quote-excluded
+ *  span; anything else (a partial/unterminated string, a computed expression) → value null + span. */
+function argFromTokens(toks) {
+    const span = spanFromTokens(toks[0], toks[toks.length - 1]);
+    if (toks.length === 1 && toks[0].type === MinijinjaParser.STRING) {
+        return { value: stringValue(toks[0]), span, valueSpan: stringContentSpan(toks[0]) };
+    }
+    return { value: null, span };
+}
 /** Keywords whose stmt declares a name we surface (set target / macro name / for loop var). */
 const NAME_DECLARING = new Set(["set", "macro", "for"]);
 /**
@@ -371,7 +535,7 @@ function controlNode(tree, tagSpan) {
  * offset/anchor composition anywhere in this file). Returns undefined only for an
  * empty/degenerate tree (never throws).
  */
-export function tagNodesOf(seg, tree) {
+export function tagNodesOf(seg, tree, tokens = []) {
     // tagSpan is the whole tag including delimiters — the segment bounds are exact
     // (they cover `{{ … }}` / `{% … %}` / `{# … #}` and any `-` whitespace control);
     // its line/column come from the tree's own start token (the tag's OPEN token).
@@ -399,70 +563,26 @@ export function tagNodesOf(seg, tree) {
         const selfKeyword = selfContainedKeyword(tree);
         if (selfKeyword)
             return { kind: "control", tagSpan, keyword: selfKeyword, calls: [] };
-        return controlNode(tree, tagSpan);
+        const node = controlNode(tree, tagSpan);
+        // Recover a trailing UNCLOSED call being typed (`{% if is_incremental(`), which the tree parse
+        // could not build, and add it to `calls` so completion can place the caret's slot inside it.
+        const partial = openCall(tokens);
+        return partial && node.kind === "control" ? { ...node, calls: [...node.calls, partial] } : node;
     }
     if (seg.tagKind === "comment")
         return { kind: "other", tagSpan };
     // Expr tag: classify by the leading call.
     const call = findTopCall(tree);
-    if (!call)
-        return { kind: "other", tagSpan };
+    if (!call) {
+        // No complete call node: recover an UNCLOSED/mid-typing call from the raw tokens
+        // (`{{ ref('cu`) so completion can place the caret's slot. A bare non-call expr stays "other".
+        return incompleteCall(tokens, tagSpan) ?? { kind: "other", tagSpan };
+    }
     const callee = decomposeCallee(call);
     if (!callee)
         return { kind: "other", tagSpan };
-    const leading = callee.leading;
-    const bare = callee.packageName === undefined;
-    // Bare special forms (ref/source/var/env_var never take a package qualifier).
-    if (bare && leading === "ref") {
-        // The model is the LAST positional arg (dbt: ref('pkg','model')), and only
-        // when THAT arg is a direct string literal — a computed target
-        // (`ref(var('x'))`) does not fabricate a model.
-        const pos = positionalArgs(call.arg_list());
-        const modelArg = pos.at(-1);
-        const modelTok = modelArg ? directStringToken(modelArg) : undefined;
-        if (modelTok) {
-            const callSpan = spanOfNode(call) ?? tagSpan;
-            return {
-                kind: "ref",
-                model: stringValue(modelTok),
-                modelSpan: stringContentSpan(modelTok),
-                callSpan,
-                tagSpan,
-            };
-        }
-        // computed / broken / argless ref → macro fallback (never a fabricated model).
-        return macroNode(call, callee, tagSpan, tree);
-    }
-    if (bare && leading === "source") {
-        // source('name', 'table') — both must be DIRECT string literals; a computed
-        // arg does not fabricate a name/table.
-        const pos = positionalArgs(call.arg_list());
-        const srcTok = pos[0] ? directStringToken(pos[0]) : undefined;
-        const tblTok = pos[1] ? directStringToken(pos[1]) : undefined;
-        if (srcTok && tblTok) {
-            const callSpan = spanOfNode(call) ?? tagSpan;
-            return {
-                kind: "source",
-                sourceName: stringValue(srcTok),
-                tableName: stringValue(tblTok),
-                sourceNameSpan: stringContentSpan(srcTok),
-                tableNameSpan: stringContentSpan(tblTok),
-                callSpan,
-                tagSpan,
-            };
-        }
-        return macroNode(call, callee, tagSpan, tree);
-    }
-    if (bare && leading === "var")
-        return { kind: "var", tagSpan };
-    if (bare && leading === "env_var")
-        return { kind: "env_var", tagSpan };
-    // No-output builtins (config/docs/print/log/return/exceptions) — config is its
-    // own kind; the rest map to "other". Applies to the leading name whether bare
-    // (`config(...)`) or member (`exceptions.raise_compiler_error(...)`).
-    if (NO_OUTPUT_BUILTINS.has(leading)) {
-        return leading === "config" ? { kind: "config", tagSpan } : { kind: "other", tagSpan };
-    }
-    // pkg.macro(...) or a bare unknown call → macro.
+    // Every expression-call tag is one neutral CALL node. ref/source/config/var/env_var are just
+    // callees distinguished by `name`; the provider (DbtTemplateProvider) interprets what each call
+    // MEANS (relation / no-output / scalar). The tag AST carries no dbt vocabulary.
     return macroNode(call, callee, tagSpan, tree);
 }

package/dist/mysql/behavior.d.ts

@@ -0,0 +1,2 @@
+import type { DialectBehavior } from "../dialect-behavior/behavior.js";
+export declare const mysqlBehavior: DialectBehavior;

package/dist/mysql/behavior.js

@@ -0,0 +1,21 @@
+// The mysql DialectBehavior: everything the semantic layer needs for mysql, assembled from
+// this folder's own pieces. The registry wires it; nothing here reaches a central per-dialect table.
+import { mysqlLiteral, mysqlParseType, MYSQL_FUNCTION_RETURNS } from "./infer.js";
+import { displayName, fold, foldTableName, matchesSourceKey } from "./fold.js";
+import { likePatternToRegExp } from "../scope/like-pattern.js";
+import { SIGNATURES } from "../signature/signatures.js";
+import { acceptsFor } from "../dialect-behavior/coerce-rules.js";
+export const mysqlBehavior = {
+    fold,
+    displayName,
+    foldTableName,
+    matchesSourceKey,
+    likeMatch: (pattern, value) => likePatternToRegExp(pattern).test(value),
+    literal: mysqlLiteral,
+    parseType: mysqlParseType,
+    functions: MYSQL_FUNCTION_RETURNS,
+    division: "decimal",
+    signatures: SIGNATURES.mysql,
+    // STR_TO_NUM=true, BOOL_NUM=true: mysql implicitly coerces both string->number and bool<->number.
+    accepts: (argType, paramText) => acceptsFor(mysqlParseType, true, true, argType, paramText),
+};

package/dist/mysql/fold.d.ts

@@ -0,0 +1,8 @@
+import { type FoldRule, type IdentKind } from "../ident/fold.js";
+export declare const MYSQL_FOLD_RULE: FoldRule;
+/** Fold an identifier to its MySQL identity key. */
+export declare function fold(raw: string, kind?: IdentKind): string;
+/** Presentation twin: strip delimiters, no case change. */
+export declare function displayName(raw: string): string;
+export declare function foldTableName(parts: string[]): string[];
+export declare function matchesSourceKey(key: string, rawPart: string): boolean;

package/dist/mysql/fold.js

@@ -0,0 +1,49 @@
+// MySQL identifier folding. The FoldRule plus its bound engine, colocated here because BOTH the
+// upstream lower() and the downstream DialectBehavior need it (the fold rule is the one dialect concern
+// used at two stages).
+//
+// dev.mysql.com/doc/refman/8.4/en/identifier-case-sensitivity.html — verified live. This module's
+// fold rule is per-DIALECT, not per-identifier-KIND (only BigQuery's `tableCase` override draws
+// that distinction), so one rule must cover both halves of a genuinely split MySQL reality:
+// "Partition, subpartition, column, index, stored routine, event, and resource group names are
+// not case-sensitive on any platform, nor are column aliases" — unconditional, so this module
+// folds unquoted AND backtick-quoted identifiers to lower for equality (column/alias/CTE/field
+// names, the identifier kinds this module actually threads through scope/qualify/infer today).
+// KNOWN LIMITATION (documented here, not silently dropped): table/database names are genuinely
+// platform/`lower_case_table_names`-dependent — "case sensitivity of the underlying operating
+// system plays a part": case-SENSITIVE by default on Unix (lower_case_table_names=0), case-
+// INSENSITIVE by default on Windows (=1) and macOS (=2), and the variable "can only be
+// configured when initializing the server" (not discoverable from SQL text alone). A static
+// analyzer with no server/OS context cannot resolve this per-installation choice; this module
+// applies the same lower-fold to table identifiers too (foldTableName's kind:"table" path, since
+// no `tableCase` override is set here) — correct for the Windows/macOS default and for Unix
+// installs whose tables happen to be written in a single consistent case (the common case), WRONG
+// only when a Unix-collation database genuinely holds two tables differing only in case (e.g.
+// `Orders` and `orders` as distinct tables) — a real but narrow misresolution, called out here
+// rather than left for a caller to discover by surprise. Identifier quote char is the backtick by
+// default (ANSI_QUOTES mode, which repurposes `"` as the identifier quote and `` ` `` stops being
+// special, is a session/server SQL-mode setting not visible in the SQL text either — out of
+// scope for the same reason as lower_case_table_names). Doubled-quote escape: "To include a quote
+// character within an identifier, quote the identifier and double the quote character" (example:
+// `` `a``b` `` → `` a`b ``).
+import { displayWith, foldWith } from "../ident/fold.js";
+const BACKTICK = ["`", "`"];
+export const MYSQL_FOLD_RULE = {
+    delimiters: [BACKTICK],
+    unquoted: "lower",
+    quoted: "lower",
+};
+/** Fold an identifier to its MySQL identity key. */
+export function fold(raw, kind = "other") {
+    return foldWith(MYSQL_FOLD_RULE, raw, kind);
+}
+/** Presentation twin: strip delimiters, no case change. */
+export function displayName(raw) {
+    return displayWith(MYSQL_FOLD_RULE, raw);
+}
+export function foldTableName(parts) {
+    return parts.map((p) => fold(p, "table"));
+}
+export function matchesSourceKey(key, rawPart) {
+    return key === fold(rawPart) || key === fold(rawPart, "table");
+}

package/dist/mysql/index.d.ts

@@ -0,0 +1,7 @@
+import { lower } from "./lower.js";
+import { parseMysql } from "./parse.js";
+export declare const mysql: {
+    parse: typeof parseMysql;
+    lower: typeof lower;
+    behavior: import("../dialect-behavior/behavior.js").DialectBehavior;
+};

package/dist/mysql/index.js

@@ -0,0 +1,10 @@
+// The complete mysql dialect module: parse + lower (front end) and behavior (semantic knowledge).
+// The registry wires this; to understand everything sqllens does for mysql, read this folder.
+import { mysqlBehavior } from "./behavior.js";
+import { lower } from "./lower.js";
+import { parseMysql } from "./parse.js";
+export const mysql = {
+    parse: parseMysql,
+    lower,
+    behavior: mysqlBehavior,
+};

package/dist/{infer/mysql.d.ts → mysql/infer.d.ts}

@@ -1,5 +1,5 @@
-import { type Type } from "./types.js";
-import type { FnRule } from "./functions.js";
+import { type Type } from "../infer/types.js";
+import type { FnRule } from "../infer/functions.js";
 export declare const MYSQL_ALIASES: Record<string, string>;
 export declare function mysqlParseType(text: string): Type;
 /** MySQL literal forms (dev.mysql.com/doc/refman/8.4/en/literals.html). Numerics split on MySQL's

package/dist/{infer/mysql.js → mysql/infer.js}

@@ -1,4 +1,5 @@
-import { parseType, scalar, UNKNOWN } from "./types.js";
+import { parseType, scalar, UNKNOWN } from "../infer/types.js";
+import { fold } from "./fold.js";
 // ---------------------------------------------------------------------------
 // MySQL inference knowledge — function return types, literal forms, and scalar-type aliases,
 // from the MySQL 8.4 Reference Manual (dev.mysql.com/doc/refman/8.4/en/). Same contract as every
@@ -58,7 +59,7 @@ export const MYSQL_ALIASES = {
     unsignedint: "bigint",
 };
 export function mysqlParseType(text) {
-    return parseType(text, MYSQL_ALIASES, "mysql");
+    return parseType(text, MYSQL_ALIASES, fold);
 }
 const S = scalar("string");
 const BIG = scalar("bigint");

package/dist/mysql/signatures.generated.d.ts

@@ -0,0 +1,6 @@
+import type { FnSignature } from "../signature/signatures.js";
+/** The merged function-signature table for mysql: curated overrides folded over the harvested
+ *  doc-derived long tail (overrides win by key, replacing the whole overload set), keyed by
+ *  lowercased name. Each name maps to an ORDERED overload set - a name with one documented shape
+ *  is a one-element array. `origin` says which layer produced the set. */
+export declare const MYSQL_SIGNATURES: Record<string, FnSignature[]>;