@intentius/chant 0.124.22 → 0.124.23

package/src/cli/handlers/graph.ts

@@ -2,7 +2,7 @@ import { dirname, resolve } from "node:path";
 import { discoverOps } from "../../op/discover";
 import { discover } from "../../discovery/index";
 import { partitionByLexicon, computeStackGraph, build, mergeBuildRootEntities } from "../../build";
-import { applyLexiconGraphEdges, buildGraphIr, buildLiveGraphIr, collectUnobserved, overlayGraphs, sourceOverlayGraphs, GRAPH_IR_VERSION, type GraphIR, type IRPipeline, type LexiconGraphEdges, type LiveObservation } from "../../graph-ir";
+import { applyLexiconGraphEdges, applyLexiconOutputs, buildGraphIr, buildLiveGraphIr, collectUnobserved, overlayGraphs, sourceOverlayGraphs, GRAPH_IR_VERSION, type GraphIR, type IRPipeline, type LexiconGraphEdges, type LexiconWorkspaceOutputs, type LiveObservation } from "../../graph-ir";
 import { behaviourOverlay } from "../../behaviour-overlay";
 import type { SerializerResult } from "../../serializer";
 import { applyBehaviourOverlay, behaviourRequestFromIr } from "../../behaviour-graph";
@@ -746,6 +746,26 @@ function withLexiconEdges(ir: GraphIR, plugins: LexiconPlugin[], entities: Map<s
   return reports.length === 0 ? ir : applyLexiconGraphEdges(ir, reports);
 }
 
+/**
+ * Add the outputs the lexicons' `workspaceOutputs` hooks report (#3931) to
+ * the IR's `exports`: a sql table and each of its columns, which `chant
+ * workspace graph` resolves member links against. A hook that throws costs
+ * its own outputs and a warning, not the graph.
+ */
+function withLexiconOutputs(ir: GraphIR, plugins: LexiconPlugin[], entities: Map<string, import("../../declarable").Declarable>): GraphIR {
+  const reports: LexiconWorkspaceOutputs[] = [];
+  for (const p of plugins) {
+    if (!p.workspaceOutputs) continue;
+    try {
+      const report = p.workspaceOutputs(entities);
+      if (report) reports.push(report);
+    } catch (err) {
+      console.error(formatWarning({ message: `the ${p.name} lexicon's workspaceOutputs failed (${err instanceof Error ? err.message : String(err)}); its outputs are left out` }));
+    }
+  }
+  return reports.length === 0 ? ir : applyLexiconOutputs(ir, reports);
+}
+
 /** Returned instead of a graph when the prediction cannot be attempted honestly. */
 const REFUSED = Symbol("behaviour-refused");
 
@@ -888,6 +908,7 @@ async function runGraphView(
       ? ctx.plugins
       : await loadPlugins(await projectLexiconsOrNone(projectPath));
     ir = withLexiconEdges(ir, plugins as LexiconPlugin[], result.entities);
+    ir = withLexiconOutputs(ir, plugins as LexiconPlugin[], result.entities);
     const predicted = await predictOntoIr(ir, plugins as LexiconPlugin[], ctx.args, {
       // No environment on the declared path: the file is not deployed anywhere
       // yet, and naming one would claim it was.

package/src/graph-ir.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "vitest";
-import { buildGraphIr } from "./graph-ir";
+import { applyLexiconOutputs, buildGraphIr } from "./graph-ir";
 import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 import { AttrRef } from "./attrref";
 import { LexiconOutput } from "./lexicon-output";
@@ -370,3 +370,25 @@ describe("whole declarables held in an entity's fields (#3257)", () => {
     expect(ir.edges).toEqual([{ from: "lb", to: "vpc", kind: "ref", viaAttr: "actions" }]);
   });
 });
+
+describe("applyLexiconOutputs (#3931)", () => {
+  test("adds each reported output to exports on the node that declares it, keeping a hand-written export", () => {
+    const orders = decl({ lexicon: "sql", entityType: "Postgres::Table", props: {} });
+    const ir = buildGraphIr(new Map<string, Declarable>([["orders", orders]]));
+    const withOutputs = applyLexiconOutputs({ ...ir, exports: [{ name: "public.orders", node: "orders", attr: "name" }] }, [
+      {
+        outputs: [
+          { name: "public.orders", entity: "orders" },
+          { name: "public.orders.buyer_id", entity: "orders", previously: ["public.orders.customer_id"] },
+          { name: "other.thing", entity: "notANode" },
+        ],
+      },
+    ]);
+    expect(withOutputs.exports).toEqual([
+      { name: "other.thing" },
+      { name: "public.orders", node: "orders", attr: "name" },
+      { name: "public.orders.buyer_id", node: "orders", previously: ["public.orders.customer_id"] },
+    ]);
+    expect(applyLexiconOutputs(ir, [{ outputs: [] }])).toBe(ir);
+  });
+});

package/src/graph-ir.ts

@@ -155,6 +155,43 @@ export interface LexiconGraphReference {
   dangling?: boolean;
 }
 
+/**
+ * One output a lexicon reports for its own declarations (#3931): a name a
+ * workspace link may target, such as a sql table's `public.orders` or a
+ * column's `public.orders.customer_id`.
+ */
+export interface LexiconWorkspaceOutput {
+  /** The output's name, as a link's `output` names it. */
+  name: string;
+  /** The entity key that declares it. */
+  entity: string;
+  /**
+   * Names the output had before, from a rename hint in source (a sql
+   * `-- previously:` comment). A link to one of them is told where it went.
+   */
+  previously?: string[];
+}
+
+/** One file the reader was handed but could not read without running it (#3931). */
+export interface LexiconUnreadSource {
+  /** The file's path, as the caller names it in messages. */
+  file: string;
+  text: string;
+  /** Why it was not read: the fold's located reason. */
+  reason: string;
+}
+
+/** What a lexicon's `workspaceOutputs` hook returns (#3931). */
+export interface LexiconWorkspaceOutputs {
+  outputs: LexiconWorkspaceOutput[];
+  /**
+   * Why the list may be incomplete, one line each: a declaration whose name
+   * can't be known statically, a file of this lexicon's that did not fold, a
+   * view whose columns can't be derived. Empty or absent when it is complete.
+   */
+  gaps?: string[];
+}
+
 /** What a lexicon's `graphEdges` hook returns (#3910). */
 export interface LexiconGraphEdges {
   references: LexiconGraphReference[];
@@ -304,6 +341,8 @@ export interface IRExport {
   value?: unknown;
   /** The deployed stack that publishes it, on an observed graph (#1279). */
   stack?: string;
+  /** Names the output had before, from a rename hint a lexicon read (#3931). */
+  previously?: string[];
 }
 
 /** A cross-stack import this stack consumes — a `Parameter` fed from another
@@ -834,6 +873,32 @@ export function applyLexiconGraphEdges(ir: GraphIR, reports: readonly LexiconGra
   return out;
 }
 
+/**
+ * Add the outputs the lexicons' `workspaceOutputs` hooks report (#3931) to a
+ * built IR's `exports`, each on the node that declares it. An output whose
+ * name is already exported (a hand-written `output()`) keeps the existing
+ * export. Pure. Returns `ir` itself when no report added anything.
+ */
+export function applyLexiconOutputs(ir: GraphIR, reports: readonly LexiconWorkspaceOutputs[]): GraphIR {
+  const nodeIds = new Set(ir.nodes.map((n) => n.id));
+  const names = new Set((ir.exports ?? []).map((e) => e.name));
+  const added: IRExport[] = [];
+  for (const report of reports) {
+    for (const o of report.outputs) {
+      if (names.has(o.name)) continue;
+      names.add(o.name);
+      added.push({
+        name: o.name,
+        ...(nodeIds.has(o.entity) ? { node: o.entity } : {}),
+        ...(o.previously && o.previously.length > 0 ? { previously: [...o.previously] } : {}),
+      });
+    }
+  }
+  if (added.length === 0) return ir;
+  const exports = [...(ir.exports ?? []), ...added].sort((a, b) => a.name.localeCompare(b.name));
+  return { ...ir, exports };
+}
+
 function danglingKey(d: IRDanglingRef): string {
   return `${d.from}\0${d.path}\0${d.value}`;
 }

package/src/lexicon.ts

@@ -23,7 +23,7 @@ import type { OwnershipChannel, OwnershipMarker } from "./ownership";
 import type { LexiconConfigSchema } from "./lexicon-config";
 import type { RuleMeta } from "./audit/catalog";
 import type { ReferenceCatalog } from "./graph-refs";
-import type { IREdge, LexiconGraphEdges } from "./graph-ir";
+import type { IREdge, LexiconGraphEdges, LexiconUnreadSource, LexiconWorkspaceOutputs } from "./graph-ir";
 import type { DescribeResourcesResult, UnobservedReason } from "./observation";
 import type { DescribeIdentityOptions, DescribeIdentityResult } from "./identity";
 import type { DeepNormalizationHooks, DeepObservationResult } from "./deep-observation";
@@ -1450,6 +1450,31 @@ export interface LexiconPlugin {
    */
   graphEdges?(entities: ReadonlyMap<string, Declarable>): LexiconGraphEdges | undefined;
 
+  /**
+   * The workspace outputs this lexicon's declarations expose (#3931): names
+   * another member's link may target, without anyone writing `output(...)`.
+   * The sql lexicon answers each table and view as `<schema>.<table>` and
+   * each column as `<schema>.<table>.<column>`.
+   *
+   * Called two ways, with the same answer expected from both:
+   *
+   * - by `chant workspace check`, offline, with the entities the member's
+   *   source folds to (`foldProject` under `sandbox`: no member code runs),
+   *   and `unread` listing the files that did not fold, with their text. A
+   *   file of this lexicon's among them is a gap: the list is then incomplete
+   *   and a link to a name not in it is unresolved rather than missing;
+   * - by `chant graph --format ir`, with the built entities and no `unread`.
+   *   The outputs land on the IR's `exports`, which `chant workspace graph`
+   *   resolves links against.
+   *
+   * Names come from the declarations as written in source, never from an
+   * environment's or profile's rendering, so they stay the same everywhere
+   * the member deploys. Pure: no I/O. Return `undefined` when the project
+   * declares nothing this lexicon reports. Omit for lexicons with no such
+   * declarations.
+   */
+  workspaceOutputs?(entities: ReadonlyMap<string, Declarable>, unread?: readonly LexiconUnreadSource[]): LexiconWorkspaceOutputs | undefined;
+
   // LSP
   /** Provide completions for LSP */
   completionProvider?(ctx: CompletionContext): CompletionItem[];

package/src/wave-loop-golden.test.ts

@@ -43,6 +43,9 @@ beforeEach(() => {
   // A CI job's locator would land on every pending fact.
   vi.stubEnv("GITHUB_ACTIONS", "");
   vi.stubEnv("GITLAB_CI", "");
+  // A pull request's address would land on every pending fact too.
+  vi.stubEnv("GITHUB_REF_NAME", "");
+  vi.stubEnv("CI_MERGE_REQUEST_IID", "");
 });
 afterEach(() => vi.unstubAllEnvs());
 

package/src/workspace/checks/links.ts

@@ -17,31 +17,58 @@
  * | WSP096 | a consumer states the same link twice |
  * | WSP097 | an entry lists `outputs` for a kind that doesn't take them from the entry |
  * | WSP098 | a link states a `protocol` and its kind is not `telemetry` (#2558) |
+ * | WSP099 | a kind's link reader could not read part of a member's files without guessing (#3932) |
+ *
+ * Links a kind's reader finds in a member's own files (#3932), such as a dbt
+ * project's sources, are checked by WSP093 to WSP095 like declared ones, and
+ * their findings name the member's file and line instead of the declaration.
  */
 
 import type { WorkspaceCheck, WorkspaceCheckContext, WorkspaceDiagnostic } from "../checks";
 import type { Member } from "../declaration";
 import { sourceMemberHandles } from "../member-handles";
+import { readKindLinks, type KindLinkRead } from "../kind-link-readers";
 import { DEFAULT_LINK_KIND, LINK_KINDS, TELEMETRY_LINK_KIND, linkTargetProblem, resolveLinks, type AmbiguousRow, type LinkRow, type LinkTableRow } from "../links";
 
 const tables = new WeakMap<WorkspaceCheckContext, LinkTableRow[]>();
+const reads = new WeakMap<WorkspaceCheckContext, Map<string, KindLinkRead>>();
+
+/** What each member's kind reader found (#3932), read once per check run. */
+function kindReads(ctx: WorkspaceCheckContext): Map<string, KindLinkRead> {
+  let read = reads.get(ctx);
+  if (!read) {
+    read = readKindLinks(ctx.declaration, ctx.tree, ctx.kinds);
+    reads.set(ctx, read);
+  }
+  return read;
+}
 
 /** The link rows for a check run, resolved once and shared by every link check. */
 export function linkTable(ctx: WorkspaceCheckContext): LinkTableRow[] {
   let rows = tables.get(ctx);
   if (!rows) {
-    rows = resolveLinks(ctx.declaration, sourceMemberHandles(ctx.declaration, ctx.tree, ctx.groups, ctx.kinds));
+    rows = resolveLinks(ctx.declaration, sourceMemberHandles(ctx.declaration, ctx.tree, ctx.groups, ctx.kinds, ctx.facts?.lexiconOutputs), undefined, kindReads(ctx));
     tables.set(ctx, rows);
   }
   return rows;
 }
 
-const declaredRows = (ctx: WorkspaceCheckContext) => linkTable(ctx).filter((r): r is LinkRow => r.status !== "ambiguous" && r.origin === "declared");
+/** The declared links, and the links a kind's reader found: the rows a member states. */
+const statedRows = (ctx: WorkspaceCheckContext) => linkTable(ctx).filter((r): r is LinkRow => r.status !== "ambiguous" && r.origin !== "inferred:joinKey");
 
-function linkFinding(check: WorkspaceCheck, row: LinkRow, field: string, message: string): WorkspaceDiagnostic {
-  return { checkId: check.id, severity: check.severity, message, entity: row.consumer, pointer: `${row.pointer}/${field}` };
+/** A finding at a declared link's field in the declaration, or at the file and line a reader's link came from. */
+function linkFinding(check: WorkspaceCheck, ctx: WorkspaceCheckContext, row: LinkTableRow, field: string, message: string): WorkspaceDiagnostic {
+  const base = { checkId: check.id, severity: check.severity, message, entity: row.consumer };
+  if (row.origin === "kind-reader" && row.file !== undefined) {
+    const member = ctx.declaration.members.find((m) => m.name === row.consumer);
+    return { ...base, pointer: member?.pointer ?? "", treeFile: row.file, line: row.line ?? 1, column: 1 };
+  }
+  return { ...base, pointer: `${(row as LinkRow).pointer}/${field}` };
 }
 
+/** Where a reader's link came from, for its message; empty for a declared link. */
+const statedAt = (row: LinkRow) => (row.origin === "kind-reader" ? ` (read by ${row.reader} from ${row.file}:${row.line})` : "");
+
 const describeLink = (row: LinkRow) => `${row.consumer}'s link to ${row.producer} output ${row.output}`;
 
 export const LINK_CHECKS: readonly WorkspaceCheck[] = [
@@ -87,9 +114,9 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
     severity: "error",
     configurable: true,
     check(ctx) {
-      return declaredRows(ctx)
+      return statedRows(ctx)
         .filter((r) => r.status === "missing")
-        .map((r) => linkFinding(this, r, "output", `${describeLink(r)} does not resolve: ${r.reason}`));
+        .map((r) => linkFinding(this, ctx, r, "output", `${describeLink(r)}${statedAt(r)} does not resolve: ${r.reason}`));
     },
   },
   {
@@ -99,9 +126,9 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
     severity: "info",
     configurable: true,
     check(ctx) {
-      return declaredRows(ctx)
+      return statedRows(ctx)
         .filter((r) => r.status === "unresolved")
-        .map((r) => linkFinding(this, r, "output", `${describeLink(r)} is kept unresolved: ${r.reason}`));
+        .map((r) => linkFinding(this, ctx, r, "output", `${describeLink(r)}${statedAt(r)} is kept unresolved: ${r.reason}`));
     },
   },
   {
@@ -115,6 +142,10 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
       return linkTable(ctx)
         .filter((r): r is AmbiguousRow => r.status === "ambiguous")
         .map((r) => {
+          if (r.origin === "kind-reader") {
+            const choices = r.candidates.map((c) => c.producer).join(", ");
+            return linkFinding(this, ctx, r, "", `${r.consumer}'s link to ${r.input} (read by ${r.reader}) has no single producer: ${r.reason}${choices ? `. Candidates: ${choices}` : ""}`);
+          }
           const choices = r.candidates.map((c) => `${c.producer} output ${c.output} (${c.label})`).join(", ");
           const first = r.candidates[0];
           return {
@@ -201,4 +232,22 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
       );
     },
   },
+  {
+    id: "WSP099",
+    name: "kind-reader-gap",
+    description:
+      "A kind's link reader read every link in a member's files that it could read without guessing (#3932). A value it would have to render, such as a Jinja template in a dbt source, is reported here with its file and line, and the links it would state are not checked.",
+    severity: "info",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const [member, read] of kindReads(ctx)) {
+        const pointer = ctx.declaration.members.find((m) => m.name === member)?.pointer ?? "";
+        for (const gap of read.gaps) {
+          out.push({ checkId: this.id, severity: this.severity, message: `${member} (read by ${read.reader}): ${gap.message}`, entity: member, pointer, treeFile: gap.file, line: gap.line, column: 1 });
+        }
+      }
+      return out;
+    },
+  },
 ];

package/src/workspace/checks.e2e.test.ts

@@ -75,7 +75,7 @@ describe("the WSP catalog", () => {
     expect(list.filter((id) => /^WSP(07|08|09|10)\d$/.test(id))).toEqual([
       "WSP071", "WSP072", "WSP073",
       "WSP081", "WSP082", "WSP083",
-      "WSP091", "WSP092", "WSP093", "WSP094", "WSP095", "WSP096", "WSP097", "WSP098",
+      "WSP091", "WSP092", "WSP093", "WSP094", "WSP095", "WSP096", "WSP097", "WSP098", "WSP099",
       "WSP101", "WSP102", "WSP103", "WSP104", "WSP105", "WSP106",
     ]);
   });

package/src/workspace/checks.ts

@@ -24,7 +24,7 @@
  * | WSP001 to WSP011 | the declaration and member kinds (this file) |
  * | WSP071, WSP072 | member ledgers |
  * | WSP081 to WSP083 | recorded pipelines |
- * | WSP091 to WSP098 | member links (#2539, #2558) |
+ * | WSP091 to WSP099 | member links (#2539, #2558), and those a kind's reader finds in a member's files (#3932) |
  * | WSP101 to WSP106 | generated files |
  * | WSP111 to WSP114 | records read with `--kind` (#2549) |
  * | WSP115 | the record kinds the declaration names (#2680) |
@@ -59,6 +59,7 @@ import { BOX_CHECKS } from "./checks/boxes";
 import { DIAGRAM_CHECKS } from "./checks/diagrams";
 import { loadDeclaredKinds, type DeclaredKind } from "./declared-kinds";
 import { resolveBoxIntents, type ResolvedBoxIntent } from "./box-intent";
+import { gatherLexiconOutputs, type MemberLexiconOutputs } from "./lexicon-outputs";
 
 /**
  * What the checks beyond the declaration read, gathered from the checkout
@@ -80,6 +81,8 @@ export interface WorkspaceFacts {
   live?: LiveLinkFacts;
   /** The decision record each box's intent names, read from the working tree (#2850). */
   boxIntents?: readonly ResolvedBoxIntent[];
+  /** The outputs linked members' lexicons report about their declarations, read by folding their source (#3931). */
+  lexiconOutputs?: ReadonlyMap<string, MemberLexiconOutputs>;
 }
 
 /** What every declaration check reads. */
@@ -355,7 +358,7 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...LEDGER_CHECKS,
   // Recorded pipelines (#2542).
   ...PIPELINE_CHECKS,
-  // Member links (#2539, #2558), WSP091 to WSP098.
+  // Member links (#2539, #2558, #3932), WSP091 to WSP099.
   ...LINK_CHECKS,
   // Generated files (#2541).
   ...GENERATED_CHECKS,
@@ -521,7 +524,11 @@ export async function runDeclarationChecks(
   const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree, acceptance: !options.tree });
   // A box's intent is read from the working tree's records, so not under --at (#2850).
   const boxIntents = declaredKinds && !options.tree ? await resolveBoxIntents(declaration, root, declaredKinds) : undefined;
+  // A linked member's lexicons name its tables and columns as outputs (#3931); reading them folds its source, never runs it.
+  const lexiconOutputs =
+    options.gather === false ? undefined : await gatherLexiconOutputs(root, declaration, options.tree ? workingTree(root) : tree, groups, registry, { atRevision: options.tree !== undefined });
   const facts: WorkspaceFacts = {
+    ...(lexiconOutputs && lexiconOutputs.size > 0 ? { lexiconOutputs } : {}),
     ...gathered,
     ...(options.records ? { records: options.records } : {}),
     ...(declaredKinds ? { declaredKinds } : {}),

package/src/workspace/compose-graph.ts

@@ -33,6 +33,7 @@ import type { FactoryView, ListingView } from "./box-factory";
 import type { Declaration } from "./declaration";
 import type { KindRegistry } from "./kinds";
 import { graphLinks, type LinkTableRow } from "./links";
+import type { KindLinkRead } from "./kind-link-readers";
 import type { RecordLinkRow } from "./record-assets";
 import type { ReasonCode } from "./reason-codes";
 import { GRAPH_IR_VERSION, type GraphIR, type IRExport, type IRGroups, type IRImport, type IREdge, type IRNode } from "../graph-ir";
@@ -302,12 +303,13 @@ function sorted(rec: Record<string, string[]>): Record<string, string[]> {
  * Compose the members' IRs into the workspace document. Members keep the
  * order they are given in. With `links`, the `links` section is filled from
  * the declaration; `kinds` lets a member that isn't composed but whose kind
- * lists its outputs (`other`, kinds from a package) be a link target.
+ * lists its outputs (`other`, kinds from a package) be a link target, and
+ * `read` holds the links each member's kind reader found in its files (#3932).
  */
 export function composeWorkspaceGraph(
   workspace: { name: string; root: string },
   inputs: ComposeInput[],
-  links?: { declaration: Declaration; kinds?: KindRegistry },
+  links?: { declaration: Declaration; kinds?: KindRegistry; read?: ReadonlyMap<string, KindLinkRead> },
 ): WorkspaceGraph {
   const nodes: ComposedNode[] = [];
   const edges: ComposedEdge[] = [];
@@ -370,7 +372,7 @@ export function composeWorkspaceGraph(
     exports,
     imports,
     links: links
-      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), collectors, exports, imports }, links.kinds)
+      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), collectors, exports, imports }, links.kinds, links.read)
       : [],
     collectors,
     records: [],

package/src/workspace/dbt-kind.e2e.test.ts

@@ -0,0 +1,95 @@
+/**
+ * The `dbt` kind end to end (#3932): the sql lexicon pinned as a package,
+ * its kinds file found through node_modules, and this checkout's chant CLI
+ * running `workspace check` and `workspace graph`. The producer is a real
+ * sql member, a chant project that declares `orders`, whose tables and
+ * columns are outputs through the sql lexicon's hook (#3931).
+ */
+
+import { spawnSync } from "node:child_process";
+import { readFileSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, contract, declaration, REPO, repo } from "./__fixtures__/contract-repo";
+import schema from "./graph.schema.json";
+
+afterAll(cleanScratch);
+
+const TIMEOUT = 120_000;
+const LEXICON = "@intentius/chant-lexicon-sql";
+const VERSION = (JSON.parse(readFileSync(join(REPO, "lexicons", "sql", "package.json"), "utf-8")) as { version: string }).version;
+
+function chant(cwd: string, ...argv: string[]) {
+  return spawnSync(process.execPath, ["--import", pathToFileURL(join(REPO, "node_modules/tsx/dist/loader.mjs")).href, join(REPO, "packages/core/src/cli/main.ts"), ...argv], {
+    cwd,
+    encoding: "utf-8",
+    timeout: TIMEOUT,
+    env: { ...process.env, NO_COLOR: "1", TSX_DISABLE_CACHE: "1" },
+  });
+}
+
+const SQL_CONFIG = `import type { ChantConfig } from "@intentius/chant";\nexport default { lexicons: ["sql"], sql: { dialect: "postgres" } } satisfies ChantConfig;\n`;
+
+const orders = (columns: string[]) =>
+  [
+    `import { table } from "@intentius/chant-lexicon-sql/postgres";`,
+    ``,
+    `export const orders = table\``,
+    `  CREATE TABLE orders (`,
+    ...columns.map((c, i) => `    ${c}${i < columns.length - 1 ? "," : ""}`),
+    `  )\`;`,
+    ``,
+  ].join("\n");
+
+function workspace(columns: string[]): string {
+  const root = repo({
+    "chant.workspace.json": declaration(
+      [
+        { name: "db", dir: "db", kind: "chant" },
+        { name: "analytics", dir: "analytics", kind: "dbt", fields: { sqlMember: "db" } },
+      ],
+      { pins: [{ package: LEXICON, version: VERSION }] },
+    ),
+    "db/chant.config.ts": SQL_CONFIG,
+    "db/src/orders.ts": orders(columns),
+    "analytics/dbt_project.yml": "name: analytics\nversion: '1.0'\nprofile: analytics\n",
+    "analytics/models/staging/sources.yml": "version: 2\n\nsources:\n  - name: shop\n    schema: public\n    tables:\n      - name: orders\n        columns:\n          - name: id\n          - name: customer_id\n",
+    ".gitignore": "node_modules\n",
+  });
+  symlinkSync(join(REPO, "node_modules"), join(root, "node_modules"), "dir");
+  return root;
+}
+
+describe("a dbt member through the pinned sql lexicon (#3932)", () => {
+  test(
+    "check passes while the sql member has public.orders.customer_id, and fails naming the dbt source file once it is dropped",
+    () => {
+      const ok = chant(workspace(["id bigint PRIMARY KEY", "customer_id bigint NOT NULL"]), "workspace", "check");
+      expect(ok.status, ok.stdout + ok.stderr).toBe(0);
+
+      const dropped = chant(workspace(["id bigint PRIMARY KEY"]), "workspace", "check");
+      expect(dropped.status).toBe(1);
+      const text = dropped.stdout + dropped.stderr;
+      expect(text).toContain("analytics/models/staging/sources.yml:10");
+      expect(text).toContain("WSP093");
+      expect(text).toMatch(/link to db output public\.orders\.customer_id .*does not resolve/);
+    },
+    TIMEOUT,
+  );
+
+  test(
+    "workspace graph lists the dbt member's links with their file and line",
+    () => {
+      const run = chant(workspace(["id bigint PRIMARY KEY"]), "workspace", "graph");
+      const doc = JSON.parse(run.stdout) as { links: { origin: string; consumer: string; producer: string; output: string; status: string; file?: string; line?: number }[] };
+      contract(schema).expectValid(doc);
+      expect(doc.links.filter((l) => l.origin === "kind-reader").map((l) => `${l.consumer} -> ${l.producer}.${l.output} ${l.status} ${l.file}:${l.line}`)).toEqual([
+        "analytics -> db.public.orders resolved analytics/models/staging/sources.yml:7",
+        "analytics -> db.public.orders.id resolved analytics/models/staging/sources.yml:9",
+        "analytics -> db.public.orders.customer_id missing analytics/models/staging/sources.yml:10",
+      ]);
+    },
+    TIMEOUT,
+  );
+});