sqllens 1.1.0 → 1.2.0

package/dist/infer/infer.js

@@ -1,15 +1,15 @@
-import { foldIdentifier } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { asProvider, tableSourceColumns } from "../qualify/relation-columns.js";
-import { likePatternToRegExp, resolveScopes } from "../scope/scope.js";
+import { resolveScopes } from "../scope/scope.js";
 import { resolveColumnSource } from "../sema/resolve.js";
 import { coerce, commonType } from "./coerce.js";
-import { inferDialect } from "./dialect.js";
 import { parseType, scalar, UNKNOWN } from "./types.js";
 const BOOLEAN = scalar("boolean");
 const INT = scalar("int");
 const freshCtx = () => ({ seen: new Set(), env: new Map() });
 export function inferType(expr, scope, schema, ctx = freshCtx()) {
-    const d = inferDialect(scope.dialect);
+    const d = behaviorOf(scope);
     switch (expr.kind) {
         case "literal":
             return d.literal(expr.text);
@@ -74,14 +74,14 @@ function columnType(col, scope, schema, ctx) {
         return v ? VALUE_TYPES[v.type] : UNKNOWN;
     }
     if (col.parts.length === 1) {
-        const param = ctx.env.get(foldIdentifier(col.parts[0], scope.dialect)); // a lambda parameter shadows columns
+        const param = ctx.env.get(behaviorOf(scope).fold(col.parts[0])); // a lambda parameter shadows columns
         if (param)
             return param;
     }
     const found = resolveColumnSource(scope, col.parts, schema);
     if (!found)
         return UNKNOWN;
-    const base = sourceColumnType(found.source, found.column, schema, ctx, inferDialect(scope.dialect), scope.dialect);
+    const base = sourceColumnType(found.source, found.column, schema, ctx, behaviorOf(scope), scope.dialect);
     return found.fields.length ? fieldType(base, found.fields, scope.dialect) : base;
 }
 function sourceColumnType(src, column, schema, ctx, d, dialect) {
@@ -139,7 +139,7 @@ function starPassthroughType(child, column, schema, ctx) {
             continue; // renamed away
         if (star.exclude?.some((e) => eq(e, under, d)))
             continue;
-        if (star.ilike !== undefined && !likePatternToRegExp(star.ilike).test(foldIdentifier(under, d)))
+        if (star.ilike !== undefined && !resolveBehavior(d).likeMatch(star.ilike, resolveBehavior(d).fold(under)))
             continue;
         ctx.seen.add(child);
         const replaced = star.replace?.find((r) => eq(r.column, under, d));
@@ -159,7 +159,7 @@ function fieldType(type, fields, dialect) {
         if (t.kind !== "struct")
             return UNKNOWN;
         // Struct-field names on a Type are stored FOLDED — fold only the reference side.
-        const hit = t.fields.find((ff) => ff.name === foldIdentifier(f, dialect));
+        const hit = t.fields.find((ff) => ff.name === resolveBehavior(dialect).fold(f));
         if (!hit)
             return UNKNOWN;
         t = hit.type;
@@ -170,7 +170,7 @@ function fieldType(type, fields, dialect) {
 function functionType(fn, scope, schema, ctx) {
     const name = fn.name.toLowerCase();
     const args = fn.args;
-    const d = inferDialect(scope.dialect);
+    const d = behaviorOf(scope);
     // Higher-order and constructor forms are BARE-name Spark/GoogleSQL builtins; a qualified/dotted
     // call (e.g. a `dataset.transform(...)` UDF) must not borrow them.
     if (fn.qualifier === undefined) {
@@ -255,7 +255,7 @@ function lambdaResult(lambda, paramTypes, scope, schema, ctx) {
     if (lambda?.kind !== "lambda")
         return undefined;
     const env = new Map(ctx.env);
-    lambda.params.forEach((p, i) => env.set(foldIdentifier(p, scope.dialect), paramTypes[i] ?? UNKNOWN));
+    lambda.params.forEach((p, i) => env.set(behaviorOf(scope).fold(p), paramTypes[i] ?? UNKNOWN));
     return inferType(lambda.body, scope, schema, { seen: ctx.seen, env });
 }
 function arrayElem(t) {
@@ -275,7 +275,7 @@ function constructor(name, args, scope, schema, ctx) {
             const key = args[i];
             const fname = key.kind === "literal" ? stringValue(key.text) : `col${i / 2 + 1}`;
             fields.push({
-                name: foldIdentifier(fname, scope.dialect),
+                name: behaviorOf(scope).fold(fname),
                 type: inferType(args[i + 1], scope, schema, ctx),
             });
         }
@@ -285,14 +285,16 @@ function constructor(name, args, scope, schema, ctx) {
         return {
             kind: "struct",
             fields: args.map((a, i) => ({
-                name: a.kind === "column" ? foldIdentifier(a.parts[a.parts.length - 1], scope.dialect) : `col${i + 1}`,
+                name: a.kind === "column" ? behaviorOf(scope).fold(a.parts[a.parts.length - 1]) : `col${i + 1}`,
                 type: inferType(a, scope, schema, ctx),
             })),
         };
     }
     if (name === "from_json") {
         const s = args[1];
-        return s?.kind === "literal" ? parseType(stringValue(s.text), undefined, scope.dialect) : UNKNOWN;
+        return s?.kind === "literal"
+            ? parseType(stringValue(s.text), undefined, (n) => behaviorOf(scope).fold(n))
+            : UNKNOWN;
     }
     return undefined;
 }
@@ -352,5 +354,5 @@ function stringValue(text) {
     return quoted ? t.slice(1, -1) : t;
 }
 function eq(a, b, dialect) {
-    return foldIdentifier(a, dialect) === foldIdentifier(b, dialect);
+    return resolveBehavior(dialect).fold(a) === resolveBehavior(dialect).fold(b);
 }

package/dist/infer/nullability.js

@@ -1,6 +1,5 @@
-import { foldIdentifier } from "../ident/fold.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { tableSourceColumns } from "../qualify/relation-columns.js";
-import { likePatternToRegExp } from "../scope/scope.js";
 import { resolveColumnSource } from "../sema/resolve.js";
 const freshCtx = () => ({ seen: new Set() });
 export function inferNullability(expr, scope, schema, ctx = freshCtx()) {
@@ -118,7 +117,7 @@ function starPassthroughNullability(child, column, schema, ctx) {
             continue; // renamed away
         if (star.exclude?.some((e) => eq(e, under, d)))
             continue;
-        if (star.ilike !== undefined && !likePatternToRegExp(star.ilike).test(foldIdentifier(under, d)))
+        if (star.ilike !== undefined && !resolveBehavior(d).likeMatch(star.ilike, resolveBehavior(d).fold(under)))
             continue;
         ctx.seen.add(child);
         const replaced = star.replace?.find((r) => eq(r.column, under, d));
@@ -283,5 +282,5 @@ function functionNullability(fn, scope, schema, ctx) {
 }
 // --- helpers ---------------------------------------------------------------
 function eq(a, b, dialect) {
-    return foldIdentifier(a, dialect) === foldIdentifier(b, dialect);
+    return resolveBehavior(dialect).fold(a) === resolveBehavior(dialect).fold(b);
 }

package/dist/infer/types.d.ts

@@ -26,7 +26,7 @@ export declare function scalar(name: string): Type;
  *  T-SQL, e.g. bit→boolean, datetime→timestamp, nvarchar→string). `dialect` folds struct field
  *  names with that dialect's identifier rules (fields are stored folded — identity keys); absent,
  *  the default fold (backtick-strip + lower) reproduces the legacy behavior. */
-export declare function parseType(text: string, aliases?: Record<string, string>, dialect?: string): Type;
+export declare function parseType(text: string, aliases?: Record<string, string>, foldField?: (name: string) => string): Type;
 /** Spark/Databricks scalar type aliases → the shared canonical names (also the default table for
  *  `parseType` below). Exported so `src/dialect-symbols.ts` can build the databricks `types` set from
  *  it without duplicating the table. */

package/dist/infer/types.js

@@ -8,7 +8,6 @@
 // identity keys. Comparisons against a raw reference fold only the reference side; re-folding a
 // stored name would corrupt a preserved-case (quoted snowflake/postgres) field.
 // ---------------------------------------------------------------------------
-import { foldIdentifier } from "../ident/fold.js";
 export const UNKNOWN = { kind: "unknown" };
 /** A scalar type by canonical name (after alias normalisation). */
 export function scalar(name) {
@@ -19,20 +18,20 @@ export function scalar(name) {
  *  T-SQL, e.g. bit→boolean, datetime→timestamp, nvarchar→string). `dialect` folds struct field
  *  names with that dialect's identifier rules (fields are stored folded — identity keys); absent,
  *  the default fold (backtick-strip + lower) reproduces the legacy behavior. */
-export function parseType(text, aliases = SCALAR_ALIASES, dialect) {
+export function parseType(text, aliases = SCALAR_ALIASES, foldField) {
     const s = text.trim();
     if (s === "")
         return UNKNOWN;
     const array = /^array\s*<(.*)>$/is.exec(s);
     if (array)
-        return { kind: "array", element: parseType(array[1], undefined, dialect) };
+        return { kind: "array", element: parseType(array[1], undefined, foldField) };
     const map = /^map\s*<(.*)>$/is.exec(s);
     if (map) {
         const [key, value] = splitTopLevel(map[1]);
         return {
             kind: "map",
-            key: parseType(key ?? "", undefined, dialect),
-            value: parseType(value ?? "", undefined, dialect),
+            key: parseType(key ?? "", undefined, foldField),
+            value: parseType(value ?? "", undefined, foldField),
         };
     }
     const struct = /^struct\s*<(.*)>$/is.exec(s);
@@ -42,9 +41,10 @@ export function parseType(text, aliases = SCALAR_ALIASES, dialect) {
             const colon = topLevelColon(part);
             if (colon < 0)
                 continue;
-            const name = foldIdentifier(part.slice(0, colon).trim(), dialect);
+            const raw = part.slice(0, colon).trim();
+            const name = foldField ? foldField(raw) : raw;
             if (name) {
-                fields.push({ name, type: parseType(stripComment(part.slice(colon + 1).trim()), undefined, dialect) });
+                fields.push({ name, type: parseType(stripComment(part.slice(colon + 1).trim()), undefined, foldField) });
             }
         }
         return { kind: "struct", fields };

package/dist/ir/ir.d.ts

@@ -118,6 +118,11 @@ export interface PivotInfo {
     /** The pivoted relation's alias (T-SQL `… PIVOT (…) AS pvt`), referenced by later columns.
      *  Absent for Spark, where the pivot transforms the SELECT directly. */
     alias?: string;
+    /** True when the output columns are data-dependent and cannot be enumerated statically (DuckDB's
+     *  statement `PIVOT … ON … USING` with no fixed IN-list — the distinct ON-values become columns).
+     *  The reshape is still modelled (source + consumed columns visible); downstream resolves the output
+     *  to "unknown" rather than guessing a column set. */
+    dynamic?: boolean;
 }
 export interface UnpivotInfo {
     /** The value column the unpivot produces. */
@@ -612,28 +617,32 @@ export interface LateralViewSource {
     pseudo?: true;
     cst: ParserRuleContext;
 }
-/** Present when a source was written as a minijinja template tag ({{ ref('x') }} / {{ source('a','b') }} /
- *  a macro call in a FROM slot). Attached post-lower by the jinja front end (src/minijinja/apply-tags.ts);
- *  plain SQL parses never carry it. `opaque: true` = the tag's output relation is undeterminable
- *  (macro / computed ref) and `name` is the raw placeholder — qualify treats the source as an opaque
- *  relation (no unknown-table/-column diagnostics). Without `opaque`, `name` carries the tag's literal
- *  dbt-logical name parts (ref model, or [sourceName, tableName]). This type is IR-neutral (no import
- *  from src/minijinja); consumers needing the full TagNode correlate by `span` with parseTemplated().tags. */
+/** Present when a source was written as a minijinja template tag: a call in a FROM slot
+ *  ({{ ref('x') }} / {{ source('a','b') }} / a macro), or a non-call expression. Attached post-lower by
+ *  the jinja front end (src/minijinja/apply-tags.ts); plain SQL parses never carry it. When the
+ *  TemplateProvider resolves the call's relation, `name` carries the resolved name parts and the
+ *  source's columns bind through the provider. When it does not (the neutral provider, a plain macro, a
+ *  computed call), `name` stays the raw placeholder and the source is an opaque relation (no
+ *  unknown-table/-column diagnostics). The tag AST and this marker are dbt-NEUTRAL: ref vs source is not
+ *  a stored kind but the callee name on `call` (call.name === "ref"), resolved by the provider the same
+ *  way a SQL function's type comes from a dialect registry. This type is IR-neutral (no import from
+ *  src/minijinja); consumers needing the full TagNode correlate by `span` with parseTemplated().tags. */
 export interface TemplateSourceInfo {
-    /** `"expr"` = a non-call templated expression in the slot (a bare variable `{{ t }}`, a concat
-     *  `{{ a ~ b }}`, …) — always `opaque` (its relation is undeterminable), `name` stays the raw
-     *  placeholder, exactly like the macro-opaque case. */
-    kind: "ref" | "source" | "macro" | "expr";
+    /** `"call"` = a template call occupies the slot; its `call` is the provider key that names the
+     *  source and types its columns. `"expr"` = a non-call templated expression (a bare variable
+     *  `{{ t }}`, a concat `{{ a ~ b }}`) that carries no call, so it stays opaque and `name` is the
+     *  raw placeholder. */
+    kind: "call" | "expr";
     /** The whole tag's span ({{ … }} inclusive), document coordinates. */
     span: PartSpan;
     opaque?: true;
-    /** Present when a bare `{{ t }}` resolved through a literal `{% set t = ref('x') %}`: `kind`/`name`
-     *  carry the resolved ref/source, but the TagNode at `span` is the USE site (kind "other"), not a
-     *  ref/source node — consumers correlating span→TagNode must not expect a ref node here. */
+    /** Present when a bare `{{ t }}` resolved through a literal `{% set t = ref('x') %}`: `name`/`call`
+     *  carry the resolved relation, but the TagNode at `span` is the USE site (kind "other"), not the
+     *  call node, so consumers correlating span to TagNode must not expect a call node here. */
     indirect?: true;
-    /** The provider key for this source's tag (ref/source/macro calls, and resolved set-indirection):
-     *  the semantic layer resolves the source through `TemplateProvider.expansion(call)`. Absent only
-     *  on the opaque `"expr"` kind (no call to ask about). */
+    /** The provider key for this source's tag (any call in a FROM slot, and resolved set-indirection):
+     *  the semantic layer resolves the source through `TemplateProvider.expansion(call)`. Absent only on
+     *  the opaque `"expr"` kind (no call to ask about). */
     call?: TemplateCall;
 }
 export interface TableSource {

package/dist/ir/span.js

@@ -2,8 +2,6 @@
 // START line/column; when the last token's TEXT spans newlines (a multi-line string literal,
 // dollar-quoted body, or block comment), the end position must advance the line and reset the
 // column. This is the one place that does that math so symbols.ts and qualify.ts agree.
-// (src/lsp/ranges.ts works on an antlr Token directly and carries an equivalent fix of its own —
-// it cannot import from the application layer the other way around.)
 /**
  * End position (exclusive) of a token, given its 1-based start `line`, 0-based start `column`, and
  * `text`. For a single-line token this is the start line and `column + text.length`. For a token

package/dist/ir/walk.js

@@ -1,8 +1,8 @@
 // ---------------------------------------------------------------------------
 // Shared IR walk helpers — expr/query-tree traversal with no scope/document
-// knowledge, so both src/document/node-at.ts (offset → smallest covering Expr)
-// and src/lsp/features/folding.ts (IR → foldable ranges) single-source the same
-// walk instead of carrying byte-for-byte duplicates.
+// knowledge, so src/document/node-at.ts (offset → smallest covering Expr) and
+// any other IR-only consumer single-source the same walk instead of carrying
+// byte-for-byte duplicates.
 // ---------------------------------------------------------------------------
 /** Every QueryExpr reachable in the IR (the AST and its nested query blocks). */
 export function allQueryExprs(root) {

package/dist/lineage/hops.js

@@ -1,4 +1,5 @@
-import { foldIdentifier, foldTableName } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { OPEN_PROVIDER } from "../qualify/template-provider.js";
 import { nodeAt } from "../document/node-at.js";
 import { findProducerProjection, resolveColumnSource } from "../sema/resolve.js";
@@ -129,7 +130,7 @@ function followColumn(scope, parts, walk, trail = []) {
     const { source, column } = binding;
     if (source.kind === "table") {
         // A recursive CTE's self-reference is a plain table here (see Walk.activeCtes) — cycle-guard it.
-        if (source.name.length === 1 && walk.activeCtes.has(foldIdentifier(source.name[0], scope.dialect)))
+        if (source.name.length === 1 && walk.activeCtes.has(behaviorOf(scope).fold(source.name[0])))
             return [{ kind: "unresolved", via }];
         return [{ kind: "origin", origin: { table: source.name, column }, via }];
     }
@@ -141,7 +142,7 @@ function followColumn(scope, parts, walk, trail = []) {
     }
     if (walk.seen.has(child))
         return [{ kind: "unresolved", via }]; // recursive-CTE cycle guard
-    const cteName = source.kind === "cte" ? foldIdentifier(source.ref.def.name, scope.dialect) : undefined;
+    const cteName = source.kind === "cte" ? behaviorOf(scope).fold(source.ref.def.name) : undefined;
     walk.seen.add(child);
     if (cteName)
         walk.activeCtes.add(cteName);
@@ -195,11 +196,12 @@ function forkLegs(setopScope, column, aliases, dialect, walk, trail = []) {
 /** The position of `column` in a set-op's output: via declared CTE aliases if given, else the set-op's
  *  own output names (the left branch's, positionally). -1 when not determinable (falls back to name). */
 function columnIndex(setopScope, column, aliases, dialect) {
-    const want = foldIdentifier(column, dialect);
+    const bh = resolveBehavior(dialect);
+    const want = bh.fold(column);
     if (aliases)
-        return aliases.findIndex((a) => foldIdentifier(a, dialect) === want);
+        return aliases.findIndex((a) => bh.fold(a) === want);
     const outs = setopScope.outputs;
-    return outs !== "unknown" ? outs.findIndex((o) => foldIdentifier(o, dialect) === want) : -1;
+    return outs !== "unknown" ? outs.findIndex((o) => bh.fold(o) === want) : -1;
 }
 /** The projection producing `column` in one set-op leg — by name for BY NAME, else by position with a
  *  name fallback (positional legs can differ in column name: `SELECT a AS x … UNION SELECT b …`). */
@@ -207,9 +209,9 @@ function legProducer(leg, column, idx, byName, dialect) {
     if (leg.body.kind !== "select")
         return undefined;
     const projs = leg.body.projections;
-    const byNameHit = () => projs.find((p) => !p.isStar &&
-        p.name !== undefined &&
-        foldIdentifier(p.name, dialect) === foldIdentifier(column, dialect));
+    const bh = resolveBehavior(dialect);
+    const wantName = bh.fold(column);
+    const byNameHit = () => projs.find((p) => !p.isStar && p.name !== undefined && bh.fold(p.name) === wantName);
     if (byName)
         return byNameHit();
     if (idx >= 0 && idx < projs.length && !projs[idx].isStar)
@@ -407,8 +409,9 @@ function childExprs(expr) {
     }
 }
 function dedupOrigins(origins, dialect) {
+    const b = resolveBehavior(dialect);
     const by = new Map();
     for (const o of origins)
-        by.set(`${foldTableName(o.table, dialect).join(".")}.${foldIdentifier(o.column, dialect)}`, o);
+        by.set(`${b.foldTableName(o.table).join(".")}.${b.fold(o.column)}`, o);
     return [...by.values()];
 }

package/dist/lineage/lineage.js

@@ -1,4 +1,5 @@
-import { foldIdentifier, foldTableName, matchesSourceKey } from "../ident/fold.js";
+import { behaviorOf } from "../dialect-behavior/carrier.js";
+import { resolveBehavior } from "../dialect-behavior/registry.js";
 import { resolveScopes } from "../scope/scope.js";
 import { columnNamesOf, findProducerProjection, resolveColumnSource } from "../sema/resolve.js";
 /** Lineage of a query's output columns: each output → the base-table columns it derives from. */
@@ -71,12 +72,12 @@ function pipeStageLineage(scope, schema, seen) {
             return [...aggs, ...keys];
         }
         case "drop": {
-            const fold = (n) => foldIdentifier(n, scope.dialect);
+            const fold = (n) => behaviorOf(scope).fold(n);
             const dropped = new Set(stage.drop.map(fold));
             return passthrough().filter((l) => !dropped.has(fold(l.output)));
         }
         case "rename": {
-            const fold = (n) => foldIdentifier(n, scope.dialect);
+            const fold = (n) => behaviorOf(scope).fold(n);
             const map = new Map(stage.renames.map((r) => [fold(r.from), r.to]));
             return passthrough().map((l) => ({
                 output: map.get(fold(l.output)) ?? l.output,
@@ -84,7 +85,7 @@ function pipeStageLineage(scope, schema, seen) {
             }));
         }
         case "set": {
-            const fold = (n) => foldIdentifier(n, scope.dialect);
+            const fold = (n) => behaviorOf(scope).fold(n);
             const set = new Map(stage.assignments.map((a) => [fold(a.column), a.expr]));
             return passthrough().map((l) => {
                 const e = set.get(fold(l.output));
@@ -113,7 +114,7 @@ function starLineage(scope, qualifier, schema, seen) {
     const want = qualifier ? (qualifier[qualifier.length - 1] ?? "") : undefined;
     const out = [];
     for (const [key, src] of scope.sources) {
-        if (want !== undefined && !matchesSourceKey(key, want, scope.dialect))
+        if (want !== undefined && !behaviorOf(scope).matchesSourceKey(key, want))
             continue;
         for (const col of columnNamesOf(src, schema, undefined, scope.dialect) ?? []) {
             out.push({ output: col, origins: dedup(columnOrigins(src, col, schema, seen), scope.dialect) });
@@ -217,12 +218,14 @@ function subqueryOrigins(query, schema, seen, dialect) {
     return exprOrigins(root.body.projections[0].expr, root, schema, seen);
 }
 function dedup(origins, dialect) {
+    const b = resolveBehavior(dialect);
     const byKey = new Map();
     for (const o of origins) {
-        byKey.set(`${foldTableName(o.table, dialect).join(".")}.${foldIdentifier(o.column, dialect)}`, o);
+        byKey.set(`${b.foldTableName(o.table).join(".")}.${b.fold(o.column)}`, o);
     }
     return [...byKey.values()];
 }
 function eq(a, b, dialect) {
-    return foldIdentifier(a, dialect) === foldIdentifier(b, dialect);
+    const bh = resolveBehavior(dialect);
+    return bh.fold(a) === bh.fold(b);
 }

package/dist/minijinja/apply-tags.d.ts

@@ -1,5 +1,6 @@
 import type { QueryExpr } from "../ir/ir.js";
-import type { TagNode } from "./tag-ast.js";
+import type { TemplateCall, TemplateProvider } from "../qualify/template-provider.js";
+import type { MacroCall, TagNode } from "./tag-ast.js";
 /** The rebuilt AST plus the tag↔node correlations collected while building it. */
 export interface TagCorrelation {
     ast: QueryExpr;
@@ -9,10 +10,16 @@ export interface TagCorrelation {
     byTag: Map<TagNode, object>;
 }
 /**
- * Rewrite templated FROM/JOIN sources in `ast` to carry their dbt-logical name +
- * a `template` marker, correlating each source to a tag by span containment.
- * Returns the SAME `ast` reference when nothing correlates (structural sharing);
- * returns a re-frozen rebuilt tree otherwise. Total — never throws; the
- * correlation maps are empty (not absent) on the no-op and error paths.
+ * Rewrite templated FROM/JOIN sources in `ast` to carry their provider-resolved name (when the
+ * provider resolves the call) plus a `template` marker, correlating each source to a tag by span
+ * containment. Returns the SAME `ast` reference when nothing correlates (structural sharing);
+ * returns a re-frozen rebuilt tree otherwise. Total, never throws; the correlation maps are empty
+ * (not absent) on the no-op and error paths.
  */
-export declare function applyTemplateTags(ast: QueryExpr, tags: TagNode[], text: string): TagCorrelation;
+export declare function applyTemplateTags(ast: QueryExpr, tags: TagNode[], text: string, provider: TemplateProvider): TagCorrelation;
+/**
+ * The provider key of a tag-AST MacroCall — name + package + literal args, with kwargs
+ * carried separately (the channel-agreed TemplateCall contract: quote-stripped, escapes
+ * NOT resolved, computed arguments null, kwargs never dropped).
+ */
+export declare function callOf(mc: MacroCall, text: string): TemplateCall;