@intentius/chant 0.102.0 → 0.104.0

package/src/workspace/json-edit.ts

@@ -0,0 +1,142 @@
+/**
+ * Edit one property of a JSON or JSONC document in place (#3308), for the
+ * write commands that change a field of the workspace declaration.
+ *
+ * Only the text of the property changed is touched: the rest of the file
+ * keeps its indentation, key order, line endings, comments and trailing
+ * commas. A new property goes after the last one of its object, indented
+ * like it. The caller re-parses the result and compares it with the value it
+ * meant to write, so an edit this module gets wrong is never written.
+ */
+
+import { parseJsonText, pointerToken } from "./jsonc";
+
+export class JsonEditError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "JsonEditError";
+  }
+}
+
+type Parsed = Extract<ReturnType<typeof parseJsonText>, { ok: true }>;
+
+function parse(text: string, jsonc: boolean): Parsed {
+  const r = parseJsonText(text, { jsonc });
+  if (!r.ok) throw new JsonEditError(`the file does not parse: ${r.message} at line ${r.location.line}, column ${r.location.column}`);
+  return r;
+}
+
+/** The value at a JSON Pointer, or undefined. */
+export function valueAt(root: unknown, pointer: string): unknown {
+  if (pointer === "") return root;
+  let at: unknown = root;
+  for (const raw of pointer.slice(1).split("/")) {
+    const token = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (at === null || typeof at !== "object") return undefined;
+    if (Array.isArray(at)) at = at[Number(token)];
+    else at = Object.prototype.hasOwnProperty.call(at, token) ? (at as Record<string, unknown>)[token] : undefined;
+  }
+  return at;
+}
+
+const isObject = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === "object" && !Array.isArray(v);
+
+/** The text's line ending, and the indentation one level adds (the first indented line's, else two spaces). */
+function style(text: string): { eol: string; unit: string } {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const m = /\n([ \t]+)\S/.exec(text);
+  return { eol, unit: m ? (m[1].startsWith("\t") ? "\t" : m[1]) : "  " };
+}
+
+function lineStart(text: string, offset: number): number {
+  return text.lastIndexOf("\n", offset - 1) + 1;
+}
+
+function lineIndent(text: string, offset: number): string {
+  const start = lineStart(text, offset);
+  return /^[ \t]*/.exec(text.slice(start))![0];
+}
+
+/** The offset of the next character after `from` that is not whitespace or a comment. */
+function skipTrivia(text: string, from: number): number {
+  let i = from;
+  for (;;) {
+    const c = text[i];
+    if (c === " " || c === "\t" || c === "\n" || c === "\r") i++;
+    else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+    } else if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end < 0 ? text.length : end + 2;
+    } else return i;
+  }
+}
+
+function render(value: unknown, indent: string, unit: string, eol: string): string {
+  return JSON.stringify(value, null, unit).split("\n").join(eol + indent);
+}
+
+/**
+ * Set `key` of the object at `objectPointer` to `value`: replace the value's
+ * text when the key is there, else add the key after the object's last one.
+ * Throws a {@link JsonEditError} when there is no object at the pointer.
+ */
+export function setProperty(text: string, jsonc: boolean, objectPointer: string, key: string, value: unknown): string {
+  const r = parse(text, jsonc);
+  const parent = valueAt(r.value, objectPointer);
+  if (!isObject(parent)) throw new JsonEditError(`there is no object at ${objectPointer || "the root"}`);
+  const { eol, unit } = style(text);
+  const child = r.span(`${objectPointer}/${pointerToken(key)}`);
+  if (child) return text.slice(0, child.start) + render(value, lineIndent(text, child.key ?? child.start), unit, eol) + text.slice(child.end);
+
+  const obj = r.span(objectPointer)!;
+  const parentIndent = lineIndent(text, obj.key ?? obj.start);
+  const keys = Object.keys(parent);
+  if (keys.length === 0) {
+    const indent = parentIndent + unit;
+    return `${text.slice(0, obj.start)}{${eol}${indent}${JSON.stringify(key)}: ${render(value, indent, unit, eol)}${eol}${parentIndent}}${text.slice(obj.end)}`;
+  }
+  const last = r.span(`${objectPointer}/${pointerToken(keys[keys.length - 1])}`)!;
+  const next = skipTrivia(text, last.end);
+  const trailingComma = text[next] === ",";
+  if (lineStart(text, last.key!) === lineStart(text, obj.start)) {
+    // An object on one line stays on one line.
+    const entry = `${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+    return trailingComma ? `${text.slice(0, next + 1)} ${entry},${text.slice(next + 1)}` : `${text.slice(0, last.end)}, ${entry}${text.slice(last.end)}`;
+  }
+  const indent = lineIndent(text, last.key!);
+  const after = trailingComma ? next + 1 : last.end;
+  // After a comment that ends the last property's line, so the comment stays with it.
+  const eolAt = text.indexOf("\n", after);
+  const lineEnd = eolAt < 0 ? text.length : text[eolAt - 1] === "\r" ? eolAt - 1 : eolAt;
+  const at = /^[ \t]*(\/\/.*)?$/.test(text.slice(after, lineEnd)) ? lineEnd : after;
+  const entry = `${eol}${indent}${JSON.stringify(key)}: ${render(value, indent, unit, eol)}`;
+  if (trailingComma) return `${text.slice(0, at)}${entry},${text.slice(at)}`;
+  return `${text.slice(0, last.end)},${text.slice(last.end, at)}${entry}${text.slice(at)}`;
+}
+
+/** Remove `key` from the object at `objectPointer`, with the comma that went with it. Unchanged when the key is not there. */
+export function removeProperty(text: string, jsonc: boolean, objectPointer: string, key: string): string {
+  const r = parse(text, jsonc);
+  const parent = valueAt(r.value, objectPointer);
+  if (!isObject(parent)) throw new JsonEditError(`there is no object at ${objectPointer || "the root"}`);
+  const child = r.span(`${objectPointer}/${pointerToken(key)}`);
+  if (!child) return text;
+  const keys = Object.keys(parent);
+  const obj = r.span(objectPointer)!;
+  if (keys.length === 1) return `${text.slice(0, obj.start)}{}${text.slice(obj.end)}`;
+  const next = skipTrivia(text, child.end);
+  if (text[next] === ",") {
+    const start = lineStart(text, child.key!);
+    const ownLine = /^[ \t]*$/.test(text.slice(start, child.key!));
+    let to = next + 1;
+    const eolAt = text.indexOf("\n", to);
+    if (ownLine && /^[ \t\r]*$/.test(text.slice(to, eolAt < 0 ? text.length : eolAt))) to = eolAt < 0 ? text.length : eolAt + 1;
+    else while (text[to] === " ") to++;
+    return text.slice(0, ownLine ? start : child.key!) + text.slice(to);
+  }
+  // The last property, with no trailing comma: remove from the comma after the one before it.
+  const prev = r.span(`${objectPointer}/${pointerToken(keys[keys.indexOf(key) - 1])}`)!;
+  const comma = skipTrivia(text, prev.end);
+  return text.slice(0, comma) + text.slice(child.end);
+}

package/src/workspace/jsonc.ts

@@ -31,6 +31,13 @@ export type JsonParseResult =
        * `key` is set. Falls back to the nearest ancestor that has a position.
        */
       locate(pointer: string, key?: boolean): TextLocation;
+      /**
+       * Where the value at `pointer` is in the text, as offsets: its key's
+       * opening quote (null for an array item or the root), the value's first
+       * character, and the offset just past its last. Undefined when there is
+       * no value at `pointer`. For editing the text in place (#3308).
+       */
+      span(pointer: string): { key: number | null; start: number; end: number } | undefined;
     }
   | { ok: false; message: string; location: TextLocation };
 
@@ -63,6 +70,7 @@ export function parseJsonText(text: string, options: JsonParseOptions): JsonPars
   };
 
   const values = new Map<string, number>();
+  const ends = new Map<string, number>();
   const keys = new Map<string, number>();
   let i = text.charCodeAt(0) === 0xfeff ? 1 : 0;
 
@@ -113,6 +121,12 @@ export function parseJsonText(text: string, options: JsonParseOptions): JsonPars
   function parseValue(pointer: string): unknown {
     skip();
     values.set(pointer, i);
+    const value = parseAt(pointer);
+    ends.set(pointer, i);
+    return value;
+  }
+
+  function parseAt(pointer: string): unknown {
     const c = text[i];
     if (c === "{") return parseObject(pointer);
     if (c === "[") return parseArray(pointer);
@@ -223,6 +237,12 @@ export function parseJsonText(text: string, options: JsonParseOptions): JsonPars
           if (p === "") return toLocation(0);
         }
       },
+      span(pointer) {
+        const start = values.get(pointer);
+        const end = ends.get(pointer);
+        if (start === undefined || end === undefined) return undefined;
+        return { key: keys.get(pointer) ?? null, start, end };
+      },
     };
   } catch (err) {
     if (!(err instanceof JsonSyntaxError)) throw err;

package/src/workspace/kinds.ts

@@ -45,8 +45,34 @@ export interface FileProbe {
    * `live {` block is found without parsing HCL (#2545).
    */
   anyBlock?: { in: string[]; blocks: string[] };
+  /**
+   * A file directly in the directory whose name matches one of `in` parses
+   * as JSON and has a value at one of `pointers`, each a JSON Pointer. This
+   * is how an app member's `package.json` with a `start` script is found
+   * without claiming every Node package (#3151).
+   */
+  anyJsonKey?: { in: string[]; pointers: string[] };
 }
 
+/** A string, integer or boolean field a kind declares for its members (#3151). */
+export interface ScalarKindField {
+  type: "string" | "integer" | "boolean";
+  description: string;
+  /** The value a member that doesn't set the field gets; null when the kind gives none. */
+  default?: string | number | boolean;
+  /** For a string field, a regular expression the value must match. */
+  pattern?: string;
+}
+
+/** An object field: named scalar fields, each with its own default (#3151). */
+export interface ObjectKindField {
+  type: "object";
+  description: string;
+  properties: Record<string, ScalarKindField>;
+}
+
+export type KindField = ScalarKindField | ObjectKindField;
+
 /** What a kind's probe checks in a directory. */
 export type KindProbe =
   /** Files, or blocks in files, sit directly in the directory. */
@@ -99,6 +125,8 @@ export interface MemberKind {
   packageDir?: string;
   /** How `workspace graph` reads a member of this kind (#2874); unset, the member is `kind-not-run`. */
   graph?: KindGraph;
+  /** The fields a member entry of this kind may set, with their defaults (#3151); unset, the kind declares none. */
+  fields?: Record<string, KindField>;
 }
 
 export interface KindRegistry {
@@ -187,8 +215,18 @@ export function builtinKindRegistry(): KindRegistry {
 export function probeKind(kind: MemberKind, tree: WorkspaceTree, dir: string): boolean {
   if ("directory" in kind.probe) return true;
   if ("chantProject" in kind.probe) return holdsChantProject(tree, dir);
-  const { anyFile, anyBlock } = kind.probe;
+  const { anyFile, anyBlock, anyJsonKey } = kind.probe;
   if (anyFile && filesMatching(tree, dir, anyFile).length > 0) return true;
+  if (anyJsonKey) {
+    for (const file of filesMatching(tree, dir, anyJsonKey.in)) {
+      try {
+        const json = JSON.parse(tree.read(file)) as unknown;
+        if (anyJsonKey.pointers.some((p) => atPointer(json, p) !== undefined)) return true;
+      } catch {
+        // A file that isn't JSON is no evidence either way.
+      }
+    }
+  }
   if (anyBlock) {
     const opener = new RegExp(`^\\s*(?:${anyBlock.blocks.map(escapeRegExp).join("|")})\\s*\\{`, "m");
     for (const file of filesMatching(tree, dir, anyBlock.in)) {
@@ -227,6 +265,17 @@ function filesMatching(tree: WorkspaceTree, dir: string, names: readonly string[
   return out.sort();
 }
 
+/** The value at JSON Pointer `pointer` in `json`, or undefined when there is none. */
+function atPointer(json: unknown, pointer: string): unknown {
+  let at: unknown = json;
+  for (const raw of pointer.split("/").slice(1)) {
+    const token = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (at === null || typeof at !== "object" || !Object.prototype.hasOwnProperty.call(at, token)) return undefined;
+    at = (at as Record<string, unknown>)[token];
+  }
+  return at;
+}
+
 function escapeRegExp(text: string): string {
   return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -337,7 +386,7 @@ export function parseKindData(text: string, source: string): KindData {
   const problems: string[] = [];
   const kinds: MemberKind[] = [];
   const seen = new Set<string>();
-  for (const k of (raw as { kinds: { name: string; description: string; precedence: number; probe: FileProbe; outputs?: string[]; graph?: KindGraph }[] }).kinds) {
+  for (const k of (raw as { kinds: { name: string; description: string; precedence: number; probe: FileProbe; outputs?: string[]; graph?: KindGraph; fields?: Record<string, KindField> }[] }).kinds) {
     if (BUILTIN_KIND_NAMES.includes(k.name)) {
       problems.push(`${source}: kind ${k.name} is built in and can't be supplied by a package`);
       continue;
@@ -353,13 +402,16 @@ export function parseKindData(text: string, source: string): KindData {
       probe: {
         ...(k.probe.anyFile ? { anyFile: [...k.probe.anyFile] } : {}),
         ...(k.probe.anyBlock ? { anyBlock: { in: [...k.probe.anyBlock.in], blocks: [...k.probe.anyBlock.blocks] } } : {}),
+        ...(k.probe.anyJsonKey ? { anyJsonKey: { in: [...k.probe.anyJsonKey.in], pointers: [...k.probe.anyJsonKey.pointers] } } : {}),
       },
       precedence: k.precedence,
       shape: "member",
       outputs: { from: "declared", names: [...(k.outputs ?? [])] },
       source,
       ...(k.graph ? { graph: { lexicon: k.graph.lexicon, config: structuredClone(k.graph.config) } } : {}),
+      ...(k.fields ? { fields: structuredClone(k.fields) } : {}),
     });
+    for (const problem of fieldDefaultProblems(k.fields ?? {})) problems.push(`${source}: kind ${k.name} ${problem}`);
   }
   return { kinds, problems };
 }
@@ -590,3 +642,106 @@ export function kindsFileShips(packageDir: string, file: string): boolean {
     return rel === e || rel.startsWith(`${e}/`);
   });
 }
+
+// ── Member fields (#3151) ────────────────────────────────────────────────────
+
+/** A value a member sets, or a kind's default: what a scalar field holds. */
+export type FieldValue = string | number | boolean;
+
+/** Why a value doesn't fit `field`, phrased to follow "the value", or undefined when it fits. */
+function scalarProblem(field: ScalarKindField, value: unknown): string | undefined {
+  const ok = field.type === "integer" ? typeof value === "number" && Number.isInteger(value) : typeof value === field.type;
+  if (!ok) return `is ${JSON.stringify(value)}, and the field is ${field.type === "integer" ? "an integer" : `a ${field.type}`}`;
+  if (field.pattern !== undefined && typeof value === "string") {
+    let re: RegExp;
+    try {
+      re = new RegExp(field.pattern, "u");
+    } catch {
+      return undefined; // Reported once, against the kind, by fieldDefaultProblems.
+    }
+    if (!re.test(value)) return `is ${JSON.stringify(value)}, which does not match ${field.pattern}`;
+  }
+  return undefined;
+}
+
+/** What is wrong with a kind's own field declarations: a pattern that isn't a regular expression, or a default of the wrong type. */
+function fieldDefaultProblems(fields: Record<string, KindField>): string[] {
+  const out: string[] = [];
+  const scalar = (name: string, f: ScalarKindField) => {
+    if (f.pattern !== undefined) {
+      try {
+        new RegExp(f.pattern, "u");
+      } catch {
+        out.push(`declares field ${name} with pattern ${f.pattern}, which is not a regular expression`);
+        return;
+      }
+    }
+    if (f.default === undefined) return;
+    const problem = scalarProblem(f, f.default);
+    if (problem) out.push(`declares field ${name} whose default ${problem}`);
+  };
+  for (const [name, f] of Object.entries(fields)) {
+    if (f.type === "object") for (const [inner, g] of Object.entries(f.properties)) scalar(`${name}.${inner}`, g);
+    else scalar(name, f);
+  }
+  return out;
+}
+
+/** One problem with a member's fields: the field's path under `fields` (`scripts/start`), and why. */
+export interface MemberFieldProblem {
+  path: string;
+  message: string;
+}
+
+export interface MemberFields {
+  /** Every field the kind declares, set from the entry or its default (null when it has none); null when the kind declares no fields. */
+  fields: Record<string, FieldValue | null | Record<string, FieldValue | null>> | null;
+  problems: MemberFieldProblem[];
+}
+
+/**
+ * A member's fields (#3151): the ones its entry sets, checked against what
+ * its kind declares, with every other declared field at its default. A field
+ * the kind doesn't declare, or a value of the wrong type, is a problem, and
+ * the field reads as its default. A kind no registry knows has no fields to
+ * check against, so it reads as null with no problem (WSP003 reports it).
+ */
+export function resolveMemberFields(kind: MemberKind | undefined, given: Record<string, unknown> | null): MemberFields {
+  if (kind === undefined) return { fields: null, problems: [] };
+  const declared = kind.fields;
+  const problems: MemberFieldProblem[] = [];
+  if (declared === undefined) {
+    if (given !== null) problems.push({ path: "", message: `kind ${kind.name} declares no fields, and the entry sets ${Object.keys(given).join(", ") || "an empty fields block"}` });
+    return { fields: null, problems };
+  }
+  const set = given ?? {};
+  for (const name of Object.keys(set)) {
+    if (!(name in declared)) problems.push({ path: name, message: `kind ${kind.name} declares no field ${name}; its fields are ${Object.keys(declared).join(", ")}` });
+  }
+  const scalar = (path: string, field: ScalarKindField, value: unknown): FieldValue | null => {
+    if (value !== undefined) {
+      const problem = scalarProblem(field, value);
+      if (!problem) return value as FieldValue;
+      problems.push({ path, message: `field ${path.replace("/", ".")} ${problem}` });
+    }
+    return field.default ?? null;
+  };
+  const fields: NonNullable<MemberFields["fields"]> = {};
+  for (const [name, field] of Object.entries(declared)) {
+    if (field.type !== "object") {
+      fields[name] = scalar(name, field, set[name]);
+      continue;
+    }
+    const raw = set[name];
+    let inner: Record<string, unknown> = {};
+    if (raw !== undefined) {
+      if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) inner = raw as Record<string, unknown>;
+      else problems.push({ path: name, message: `field ${name} is ${JSON.stringify(raw)}, and the field is an object` });
+    }
+    for (const key of Object.keys(inner)) {
+      if (!(key in field.properties)) problems.push({ path: `${name}/${key}`, message: `kind ${kind.name} declares no field ${name}.${key}; ${name} has ${Object.keys(field.properties).join(", ")}` });
+    }
+    fields[name] = Object.fromEntries(Object.entries(field.properties).map(([key, f]) => [key, scalar(`${name}/${key}`, f, inner[key])]));
+  }
+  return { fields, problems };
+}

package/src/workspace/lexicon-symbols.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Symbol resolvers from a member's lexicon (#3313): `graph --intent
+ * path#symbol` on a file in a member whose lexicon exports a resolver.
+ *
+ * The workspace has a chant member `db` whose chant.config.json declares a
+ * lexicon by module path, `lexicon/plugin.mjs`, which resolves `create table`
+ * and `create function` statements in `.sql` files. A loader stands in for
+ * the plugin in the unit cases; one case loads the module path the way any
+ * command does.
+ */
+
+import { join } from "node:path";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, contract, git, repo } from "./__fixtures__/contract-repo";
+import { intentGraph, type IntentDocument, type RegionNode } from "./intent";
+import intentSchema from "./intent.schema.json";
+import { memberSymbolResolvers, type SymbolPluginLoader } from "./lexicon-symbols";
+import { resolveSymbol, type SymbolDeclaration, type SymbolResolver } from "./symbols";
+
+afterAll(cleanScratch);
+
+const intent = contract(intentSchema);
+
+/** A tiny SQL resolver: each `create table|function <name>` up to the line ending in `;`. */
+const SQL_RESOLVER_SOURCE = `
+export const sqlResolver = {
+  language: "SQL",
+  extensions: [".sql"],
+  declarations(path, text) {
+    const lines = text.split("\\n");
+    const out = [];
+    lines.forEach((line, i) => {
+      const m = /^create\\s+(table|function)\\s+([a-z_.]+)/i.exec(line);
+      if (!m) return;
+      let end = i;
+      while (end < lines.length - 1 && !lines[end].trimEnd().endsWith(";")) end++;
+      out.push({ qualified: m[2], kind: m[1].toLowerCase(), lines: { start: i + 1, end: end + 1 } });
+    });
+    return out;
+  },
+};
+`;
+
+const PLUGIN = `${SQL_RESOLVER_SOURCE}
+export const plugin = {
+  name: "sqlish",
+  serializer: { name: "sqlish", rulePrefix: "SQI", serialize: () => "" },
+  async generate() {},
+  async validate() {},
+  async coverage() {},
+  async package() {},
+  symbolResolvers: () => [sqlResolver],
+};
+`;
+
+const SCHEMA = ["-- the app's schema", "create table app.users (", "  id int primary key", ");", "", "create function app.touch()", "  returns void as $$ select 1 $$ language sql;", ""].join("\n");
+
+async function sqlResolver(): Promise<SymbolResolver> {
+  const mod = (await import(`data:text/javascript,${encodeURIComponent(SQL_RESOLVER_SOURCE)}`)) as { sqlResolver: SymbolResolver };
+  return mod.sqlResolver;
+}
+
+function workspace(): string {
+  const root = repo(
+    {
+      "chant.workspace.json": `${JSON.stringify({
+        name: "demo",
+        schema: 1,
+        members: [
+          { name: "db", dir: "db", kind: "chant" },
+          { name: "notes", dir: "notes", kind: "other", because: "prose" },
+        ],
+      })}\n`,
+      "db/chant.config.json": `${JSON.stringify({ lexicons: [{ name: "sqlish", module: "../lexicon/plugin.mjs" }] })}\n`,
+      "db/schema.sql": SCHEMA,
+      "db/main.ts": "export const x = 1;\n",
+      "lexicon/plugin.mjs": PLUGIN,
+      "notes/schema.sql": SCHEMA,
+    },
+    true,
+  );
+  git(root, "branch", "-M", "main");
+  return root;
+}
+
+const region = (doc: IntentDocument) => {
+  if ("error" in doc) throw new Error(`${doc.error.code}: ${doc.error.message}`);
+  return doc.nodes.find((n) => n.kind === "region") as RegionNode;
+};
+
+describe("a lexicon's symbol resolvers (#3313)", () => {
+  test("resolveSymbol uses an extra resolver for its extensions, and core's for .ts", async () => {
+    const sql = await sqlResolver();
+    expect(resolveSymbol("db/schema.sql", SCHEMA, "app.users", [sql])).toEqual({ ok: true, declaration: { qualified: "app.users", kind: "table", lines: { start: 2, end: 4 } } });
+    expect(resolveSymbol("db/schema.sql", SCHEMA, "users", [sql])).toMatchObject({ ok: true, declaration: { qualified: "app.users" } });
+    expect(resolveSymbol("db/schema.sql", SCHEMA, "app.users")).toMatchObject({ ok: false, reason: "unsupported" });
+    // A lexicon's resolver never takes .ts from core's.
+    const greedy: SymbolResolver = { language: "greedy", extensions: [".ts"], declarations: (): SymbolDeclaration[] => [{ qualified: "x", kind: "lie", lines: { start: 9, end: 9 } }] };
+    expect(resolveSymbol("a.ts", "export const x = 1;\n", "x", [greedy])).toMatchObject({ ok: true, declaration: { kind: "variable", lines: { start: 1, end: 1 } } });
+  });
+
+  test("graph --intent path#symbol resolves through the member's lexicon", async () => {
+    const root = workspace();
+    const sql = await sqlResolver();
+    const load: SymbolPluginLoader = async (name) => {
+      expect(name).toBe("sqlish");
+      return { name, symbolResolvers: () => [sql] };
+    };
+    const { doc } = await intentGraph({ cwd: root, region: "db/schema.sql#app.touch", loadLexicon: load });
+    intent.expectValid(doc);
+    expect(region(doc)).toMatchObject({ path: "db/schema.sql", lines: { start: 6, end: 7 }, member: "db", symbol: { name: "app.touch", qualified: "app.touch", kind: "function" } });
+  });
+
+  test("loads the lexicon the member's config declares, by module path, as any command does", async () => {
+    const root = workspace();
+    const { doc } = await intentGraph({ cwd: root, region: "db/schema.sql#app.users" });
+    intent.expectValid(doc);
+    expect(region(doc)).toMatchObject({ lines: { start: 2, end: 4 }, symbol: { qualified: "app.users", kind: "table" } });
+  });
+
+  test("a file in a member with no such lexicon, or whose lexicon fails, stays intent-symbol-unsupported and says why", async () => {
+    const root = workspace();
+    const other = await intentGraph({ cwd: root, region: "notes/schema.sql#app.users" });
+    intent.expectValid(other.doc);
+    expect("error" in other.doc && other.doc.error.code).toBe("intent-symbol-unsupported");
+    const broken = await intentGraph({
+      cwd: root,
+      region: "db/schema.sql#app.users",
+      loadLexicon: async () => {
+        throw new Error("Cannot find package");
+      },
+    });
+    expect("error" in broken.doc && broken.doc.error).toMatchObject({ code: "intent-symbol-unsupported", message: expect.stringContaining('lexicon "sqlish" could not be loaded: Cannot find package') });
+  });
+
+  test("a malformed resolver or bad declarations are dropped, not read as lines", async () => {
+    const root = workspace();
+    const got = await memberSymbolResolvers(join(root, "db"), async () => ({
+      symbolResolvers: () => [
+        { language: "bad", extensions: ["sql"], declarations: () => [] },
+        { language: "ok", extensions: [".sql"], declarations: () => [{ qualified: "t", kind: "table", lines: { start: 3, end: 1 } }, { qualified: "u", kind: "table", lines: { start: 1, end: 2 } }] },
+      ],
+    }));
+    expect(got.problems).toEqual([expect.stringContaining("not { language, extensions")]);
+    expect(got.resolvers).toHaveLength(1);
+    expect(got.resolvers[0].declarations("x.sql", "")).toEqual([{ qualified: "u", kind: "table", lines: { start: 1, end: 2 } }]);
+  });
+});

package/src/workspace/lexicon-symbols.ts

@@ -0,0 +1,125 @@
+/**
+ * Symbol resolvers a member's lexicons contribute (#3313), for
+ * `chant workspace graph --intent <path>#<symbol>` on a file core's own
+ * resolver does not read (`symbols.ts`).
+ *
+ * The lexicons are the ones the member's `chant.config.ts` (or `.json`)
+ * names, read without running the config when it can be read statically
+ * (`../config-static.ts`), and by loading it as `chant run` does otherwise.
+ * Each is loaded as any command loads it (`loadPlugin`), and its plugin's
+ * `symbolResolvers()` answers. A lexicon that can't be loaded, or whose
+ * resolvers are malformed, contributes nothing, and the reason is kept so a
+ * refusal can say why the file has no resolver.
+ */
+
+import { join } from "node:path";
+import { lexiconNames } from "../lexicon-module";
+import type { SymbolDeclaration, SymbolResolver } from "./symbols";
+
+/** Loads a lexicon plugin by name; `loadPlugin` from the CLI unless a test swaps it. */
+export type SymbolPluginLoader = (name: string) => Promise<{ name?: string; symbolResolvers?: () => unknown }>;
+
+export interface MemberSymbolResolvers {
+  resolvers: SymbolResolver[];
+  /** Why a lexicon contributed nothing it may have meant to: its config or plugin couldn't be read, or a resolver was malformed. */
+  problems: string[];
+}
+
+const firstLine = (err: unknown): string => (err instanceof Error ? err.message : String(err)).split("\n")[0];
+
+/** A resolver a plugin returned, checked: a language, extensions starting with a dot, and a declarations function. */
+function checked(lexicon: string, value: unknown, problems: string[]): SymbolResolver | undefined {
+  const r = value as Partial<SymbolResolver> | null;
+  const ok =
+    r !== null &&
+    typeof r === "object" &&
+    typeof r.language === "string" &&
+    Array.isArray(r.extensions) &&
+    r.extensions.length > 0 &&
+    r.extensions.every((e) => typeof e === "string" && /^\.[^./\\]+$/.test(e)) &&
+    typeof r.declarations === "function";
+  if (!ok) {
+    problems.push(`lexicon "${lexicon}" returned a symbol resolver that is not { language, extensions: [".ext", ...], declarations(path, text) }`);
+    return undefined;
+  }
+  const declarations = r.declarations!.bind(r);
+  return {
+    language: `${r.language} (lexicon ${lexicon})`,
+    extensions: [...r.extensions!],
+    // A resolver's output is checked where it is used, so a bad entry is dropped rather than read as lines.
+    declarations(path: string, text: string): SymbolDeclaration[] {
+      const out = declarations(path, text);
+      if (!Array.isArray(out)) return [];
+      return out.filter(
+        (d) =>
+          d !== null &&
+          typeof d === "object" &&
+          typeof d.qualified === "string" &&
+          d.qualified !== "" &&
+          typeof d.kind === "string" &&
+          Number.isInteger(d.lines?.start) &&
+          Number.isInteger(d.lines?.end) &&
+          d.lines.start >= 1 &&
+          d.lines.end >= d.lines.start,
+      );
+    },
+  };
+}
+
+/** The lexicon names a member's config declares: read statically when it can be, else by loading the config. */
+async function memberLexicons(dir: string): Promise<string[]> {
+  const { readLexiconDeclarationsStatically } = await import("../config-static");
+  const read = readLexiconDeclarationsStatically(dir);
+  if (read.status === "no-config") return [];
+  if (read.status === "read") {
+    const { registerLexiconDeclarations } = await import("../lexicon-module");
+    const { dirname } = await import("node:path");
+    registerLexiconDeclarations(read.entries, dirname(read.configPath));
+    return lexiconNames(read.entries);
+  }
+  const { loadChantConfig } = await import("../config");
+  const { config } = await loadChantConfig(dir);
+  return lexiconNames(config.lexicons ?? []);
+}
+
+/** The symbol resolvers the lexicons of the member at `dir` (on disk) contribute, in config order. */
+export async function memberSymbolResolvers(dir: string, load?: SymbolPluginLoader): Promise<MemberSymbolResolvers> {
+  const problems: string[] = [];
+  let names: string[];
+  try {
+    names = await memberLexicons(dir);
+  } catch (err) {
+    return { resolvers: [], problems: [`its chant.config could not be read: ${firstLine(err)}`] };
+  }
+  const loader = load ?? ((await import("../cli/plugins")).loadPlugin as SymbolPluginLoader);
+  const resolvers: SymbolResolver[] = [];
+  for (const name of names) {
+    let plugin: Awaited<ReturnType<SymbolPluginLoader>>;
+    try {
+      plugin = await loader(name);
+    } catch (err) {
+      problems.push(`lexicon "${name}" could not be loaded: ${firstLine(err)}`);
+      continue;
+    }
+    if (typeof plugin.symbolResolvers !== "function") continue;
+    let listed: unknown;
+    try {
+      listed = plugin.symbolResolvers();
+    } catch (err) {
+      problems.push(`lexicon "${name}" symbolResolvers() threw: ${firstLine(err)}`);
+      continue;
+    }
+    if (!Array.isArray(listed)) {
+      problems.push(`lexicon "${name}" symbolResolvers() did not return a list`);
+      continue;
+    }
+    for (const r of listed) {
+      const ok = checked(name, r, problems);
+      if (ok) resolvers.push(ok);
+    }
+  }
+  return { resolvers, problems };
+}
+
+/** The member directory on disk for a member's `dir` under the workspace root. */
+export const memberDirOnDisk = (root: string, dir: string): string => (dir === "." ? root : join(root, ...dir.split("/")));