sqllens 1.10.0 → 1.10.1

package/dist/document/document.d.ts

@@ -163,7 +163,7 @@ export declare class SqlDocument {
      *  `parse()`. It is the document's one cell when the placeholder splits into one statement (every
      *  single-statement model), and the carrier of the engine result (`templated`) that a multi-cell
      *  document's slices are built from. `r.tokens`/`r.diagnostics` are ALREADY document coordinates
-     *  (the cell always starts at 0), so — unlike `buildCell` — nothing is shifted. Mirrors
+     *  (the cell always starts at 0), so, unlike `buildCell`, nothing is shifted. Mirrors
      *  `buildCell`'s CachedCell/StatementCell shapes so every downstream consumer (analyze(), cellAt(),
      *  nodeAt()…) sees the same structure whether the document is plain or templated. Cached in the SAME
      *  cross-edit `_cellCache` as plain cells, under a prefixed key so a templated cell can never

package/dist/document/document.js

@@ -182,7 +182,7 @@ export class SqlDocument {
                     cells.push(built.cell);
                     backing.push(built.cached);
                 }
-                templated = withCellCorrelation(r, backing);
+                templated = withCellCorrelation(r, cells, backing);
             }
         }
         else {
@@ -282,7 +282,7 @@ export class SqlDocument {
      *  `parse()`. It is the document's one cell when the placeholder splits into one statement (every
      *  single-statement model), and the carrier of the engine result (`templated`) that a multi-cell
      *  document's slices are built from. `r.tokens`/`r.diagnostics` are ALREADY document coordinates
-     *  (the cell always starts at 0), so — unlike `buildCell` — nothing is shifted. Mirrors
+     *  (the cell always starts at 0), so, unlike `buildCell`, nothing is shifted. Mirrors
      *  `buildCell`'s CachedCell/StatementCell shapes so every downstream consumer (analyze(), cellAt(),
      *  nodeAt()…) sees the same structure whether the document is plain or templated. Cached in the SAME
      *  cross-edit `_cellCache` as plain cells, under a prefixed key so a templated cell can never
@@ -354,15 +354,18 @@ export class SqlDocument {
                 category: c.sql.ast.statement ?? "other",
                 ast: c.sql.ast,
                 cst: c.sql.cst,
-                // Resolve scopes from the already-lowered (marker-carrying) ast — do NOT re-parse.
+                // Resolve scopes from the already-lowered (marker-carrying) ast: never re-parse.
                 scopes: toScopes(c.sql.ast, { dialect: this.dialect }),
                 tokens: c.sql.tokens,
                 errors: c.sql.errors,
                 diagnostics: c.sql.diagnostics,
                 analysis: new WeakMap(),
-                correlation: { tagOf: c.tagOf, nodeOf: c.nodeOf },
+                correlation: {
+                    tagStartOf: new Map(c.links.map((l) => [l.node, l.tagStart])),
+                    primaryAt: new Map(c.links.filter((l) => l.primary).map((l) => [l.tagStart, l.node])),
+                },
             };
-            // Cache only the FIRST product for a key (see buildCell — duplicates stay uncached).
+            // Cache only the FIRST product for a key (see buildCell: duplicates stay uncached).
             if (this._cellCache.get(key) === undefined)
                 this._cellCache.set(key, cached);
         }
@@ -920,25 +923,29 @@ function setResolutionKey(r, text) {
     return parts.join("\n");
 }
 /** The `templated` facade of a MULTI-cell templated document: the whole-text engine result with
- *  `tagOf`/`nodeOf` answering from the CELLS' own correlations — the per-statement IR consumers reach
- *  through `statements`/`cellAt`/`nodeAt` — never from the whole-text parse, whose nodes a multi-cell
- *  document does not expose (its `ast` is the compound facade). Everything else is the engine's. */
-function withCellCorrelation(r, cells) {
+ *  `tagOf`/`nodeOf` answering from the CELLS' own correlations (the per-statement IR consumers reach
+ *  through `statements`/`cellAt`/`nodeAt`), never from the whole-text parse, whose nodes a multi-cell
+ *  document does not expose (its `ast` is the compound facade). A cell's join names its tag by
+ *  cell-relative start, so the answer is always one of THIS parse's TagNodes, whichever parse the
+ *  cached cell was built under. Everything else is the engine's. */
+function withCellCorrelation(r, cells, backing) {
+    const tagAt = new Map(r.tags.map((t) => [t.tagSpan.start, t]));
     return {
         ...r,
         tagOf: (node) => {
-            for (const c of cells) {
-                const tag = c.correlation?.tagOf(node);
-                if (tag)
-                    return tag;
+            for (let i = 0; i < backing.length; i++) {
+                const rel = backing[i].correlation?.tagStartOf.get(node);
+                if (rel !== undefined)
+                    return tagAt.get(cells[i].span.start + rel);
             }
             return undefined;
         },
         nodeOf: (tag) => {
-            for (const c of cells) {
-                const node = c.correlation?.nodeOf(tag);
-                if (node)
-                    return node;
+            for (let i = 0; i < backing.length; i++) {
+                const span = cells[i].span;
+                if (tag.tagSpan.start < span.start || tag.tagSpan.start >= span.end)
+                    continue;
+                return backing[i].correlation?.primaryAt.get(tag.tagSpan.start - span.start);
             }
             return undefined;
         },

package/dist/document/split.d.ts

@@ -2,7 +2,8 @@ import type { Dialect } from "../dialect.js";
 export interface StatementCellSpan {
     /** doc offset, inclusive — cell text includes leading trivia. */
     start: number;
-    /** doc offset, exclusive — includes the trailing separator (`;` / GO line). */
+    /** doc offset, exclusive — includes the trailing separator (`;` / GO line); the document's last
+     *  cell also includes whatever trivia follows its separator, up to `text.length`. */
     end: number;
 }
 /**

package/dist/document/split.js

@@ -26,7 +26,10 @@ const NON_OPENER_END_SUFFIXES = new Set(["IF", "WHILE", "FOR", "LOOP", "REPEAT"]
 function wholeDoc(text) {
     return [{ start: 0, end: text.length }];
 }
-/** Every offset in `text` where a top-level separator ends (exclusive), in ascending order. */
+/** Every offset in `text` where a top-level separator ends (exclusive), in ascending order. A
+ *  separator that no channel-0 token follows (only whitespace, comments, the final newline) is not
+ *  a split end: the trivia after it belongs to the cell it terminates, so a single terminated
+ *  statement is one cell rather than a statement plus a token-less tail cell. */
 function findSplitEnds(text, tokens, dialect) {
     const channel0 = tokens.filter((t) => t.channel === 0);
     const ends = [];
@@ -80,6 +83,11 @@ function findSplitEnds(text, tokens, dialect) {
             }
         }
     }
+    // Tokens are in source order, so the last channel-0 token decides whether anything real follows
+    // the last separator.
+    const lastReal = channel0[channel0.length - 1];
+    if (ends.length > 0 && (lastReal === undefined || lastReal.start < ends[ends.length - 1]))
+        ends.pop();
     return ends;
 }
 /** Turn ascending split-end offsets into contiguous cells tiling `[0, text.length)`. A doc

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

@@ -15,6 +15,12 @@ export interface TagCorrelation {
     byNode: WeakMap<object, TagNode>;
     /** TagNode → the IR node it became (undefined-by-absence for tags with no IR presence). */
     byTag: Map<TagNode, object>;
+    /** Every attached (node, tag) pair in attach order: the enumerable form of `byNode`, for a
+     *  caller that must re-key the join to another parse's TagNodes (a cached statement cell). */
+    links: {
+        node: object;
+        tag: TagNode;
+    }[];
 }
 /**
  * Rewrite templated FROM/JOIN sources in `ast` to carry their provider-resolved name (when the

package/dist/minijinja/apply-tags.js

@@ -39,6 +39,7 @@ const ZERO_BASE = { line: 0, column: 0, offset: 0 };
  *  of which one this walk visits first. */
 function attach(ctx, node, tag) {
     ctx.byNode.set(node, tag);
+    ctx.links.push({ node, tag });
     const existing = ctx.byTag.get(tag);
     if (existing?.kind !== "column")
         ctx.byTag.set(tag, node);
@@ -59,13 +60,14 @@ function attach(ctx, node, tag) {
 export function applyTemplateTags(ast, tags, text, provider, base = ZERO_BASE) {
     const byNode = new WeakMap();
     const byTag = new Map();
+    const links = [];
     try {
         // config is a no-output tag (whitespace-filled), so it can never yield a table
         // source and stays out of the correlation set even though ExprTag admits it.
         // An incomplete/mid-typing call (`{{ ref('cu`) is NOT a resolved source, so skip it.
         const relTags = tags.filter((t) => (t.kind === "call" && !t.incomplete) || t.kind === "other");
         if (relTags.length === 0)
-            return { ast, byNode, byTag };
+            return { ast, byNode, byTag, links };
         const nameConfig = ast.dialect !== undefined ? resolveBehavior(ast.dialect).nameConfig : undefined;
         const ctx = {
             relTags,
@@ -75,6 +77,7 @@ export function applyTemplateTags(ast, tags, text, provider, base = ZERO_BASE) {
             base,
             byNode,
             byTag,
+            links,
             ...(nameConfig ? { nameConfig } : {}),
         };
         const next = transformQuery(ast, ctx);
@@ -82,11 +85,11 @@ export function applyTemplateTags(ast, tags, text, provider, base = ZERO_BASE) {
         // fill gets a `template` marker (span + provider key), so inference resolves it
         // through the provider and qualify never checks the placeholder as a real column.
         const marked = markTemplateExprs(next, ctx);
-        return { ast: marked === ast ? ast : freezeIR(marked), byNode, byTag };
+        return { ast: marked === ast ? ast : freezeIR(marked), byNode, byTag, links };
     }
     catch (e) {
         debugRethrow(e);
-        return { ast, byNode: new WeakMap(), byTag: new Map() };
+        return { ast, byNode: new WeakMap(), byTag: new Map(), links: [] };
     }
 }
 /** The TemplateExprInfo for a scalar-slot tag: its span + (when an identity is extractable)

package/dist/minijinja/parse.d.ts

@@ -35,7 +35,8 @@ export declare function tokenizeTemplated(text: string, dialect: Dialect, opts?:
  * correlated onto it by DOCUMENT offset (a node's cell offset plus the cell's start). The cell's
  * sources then carry their provider-resolved names and `template` markers exactly as the
  * whole-text parse's do, never the fill; a marker's `span` is rebased to cell coordinates like
- * every other span in the cell IR, while `tagOf`/`nodeOf` answer with `whole.tags`'s own nodes.
+ * every other span in the cell IR, and the tag↔node join is returned as cell-relative `links`
+ * so a cached cell re-keys it to whatever parse it is later reused under.
  * Total: `applyTemplateTags` leaves the plain parse in place on any internal surprise.
  */
 export declare function parseTemplatedCell(whole: TemplatedParseResult, span: {

package/dist/minijinja/parse.js

@@ -658,7 +658,8 @@ export function tokenizeTemplated(text, dialect, opts) {
  * correlated onto it by DOCUMENT offset (a node's cell offset plus the cell's start). The cell's
  * sources then carry their provider-resolved names and `template` markers exactly as the
  * whole-text parse's do, never the fill; a marker's `span` is rebased to cell coordinates like
- * every other span in the cell IR, while `tagOf`/`nodeOf` answer with `whole.tags`'s own nodes.
+ * every other span in the cell IR, and the tag↔node join is returned as cell-relative `links`
+ * so a cached cell re-keys it to whatever parse it is later reused under.
  * Total: `applyTemplateTags` leaves the plain parse in place on any internal surprise.
  */
 export function parseTemplatedCell(whole, span, text, dialect, opts) {
@@ -667,8 +668,11 @@ export function parseTemplatedCell(whole, span, text, dialect, opts) {
     const correlation = applyTemplateTags(sql.ast, whole.tags, text, provider, cellBaseOf(text, span.start));
     return {
         sql: { ...sql, ast: correlation.ast },
-        tagOf: (node) => correlation.byNode.get(node),
-        nodeOf: (tag) => correlation.byTag.get(tag),
+        links: correlation.links.map(({ node, tag }) => ({
+            node,
+            tagStart: tag.tagSpan.start - span.start,
+            primary: correlation.byTag.get(tag) === node,
+        })),
     };
 }
 /** The cell start's 0-based line / column / char offset in `text` (`\n` is the line break, the

package/dist/template/engine.d.ts

@@ -88,6 +88,17 @@ export interface TemplatedParseResult {
      *  scrubber widened to it. Empty array when none. */
     diagnosticsOf(tag: TagNode): SyntaxDiagnostic[];
 }
+/** One template-marked node of a statement cell's IR and the tag it came from, the tag named by
+ *  its CELL-relative start offset rather than by object: a cell is cached across edits and reused
+ *  under a later parse whose TagNodes are fresh objects, so the join is re-keyed to that parse's
+ *  tag at the same offset. `primary` marks the tag's one answer (a scalar-slot tag marks both a
+ *  column expression and its column-ref record; the expression is primary). */
+export interface TemplatedCellLink {
+    node: object;
+    /** `tag.tagSpan.start - cell.span.start`. */
+    tagStart: number;
+    primary: boolean;
+}
 /** One statement CELL of a templated document (`TemplateEngine.parseCell`): the plain per-dialect
  *  parse of the cell's placeholder slice, in CELL-relative coordinates like a plain document's
  *  cells, with the whole-document tags correlated onto it (provider-resolved source names,
@@ -96,11 +107,9 @@ export interface TemplatedCellResult {
     /** The cell's SQL parse over its placeholder slice (ast / cst / tokens / errors / diagnostics),
      *  every span cell-relative. A `template` marker's span is cell-relative too. */
     sql: ParseResultIR;
-    /** The whole document's TagNode a template-marked node of THIS cell's IR came from. */
-    tagOf(node: object): TagNode | undefined;
-    /** The node of THIS cell's IR a whole-document tag became; undefined when the tag sits in
-     *  another cell or has no IR presence. */
-    nodeOf(tag: TagNode): object | undefined;
+    /** The tag↔node join over THIS cell's IR, position- and identity-independent (see
+     *  `TemplatedCellLink`). Empty when nothing correlates. */
+    links: TemplatedCellLink[];
 }
 /** A template engine: the syntax front end for one templating language over
  *  SQL. `parse` must satisfy the engine contract the conformance suite
@@ -113,7 +122,7 @@ export interface TemplateEngine {
     parse(text: string, dialect: Dialect, opts?: TemplatedParseOptions): TemplatedParseResult;
     /** Optional: coherent per-branch variant enumeration, for engines with control-flow arms. */
     variants?(text: string, dialect: Dialect): TemplateVariant[];
-    /** Optional: the products of ONE statement cell of a templated document — the plain parse of
+    /** Optional: the products of ONE statement cell of a templated document, the plain parse of
      *  `whole.placeholder`'s slice `[span.start, span.end)` (cell-relative) with `whole`'s tags
      *  correlated onto it. `whole` is this engine's own `parse` result for the full `text`, `span`
      *  a `splitStatements` span over that placeholder. An engine without it keeps the templated

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sqllens",
-	"version": "1.10.0",
+	"version": "1.10.1",
 	"description": "A TypeScript SQL parser and static analyzer: parse, resolve names, infer types, and trace column lineage across many SQL dialects (Databricks, T-SQL, Snowflake, BigQuery, Redshift, PostgreSQL, DuckDB, Trino, SQLite, MySQL).",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",