@vertekum/schema-builder 0.1.6 → 0.2.0

package/src/emit.ts

@@ -1,11 +1,18 @@
-import type { TreeNode } from './build';
+import type { PatternRef, TreeNode } from './build';
+import type { ResolvedModule } from './resolve';
 
 /**
- * Emit a name tree as the names-and-order JSON Schema shape shipped schemas use: every position
- * `type: object`, declared children under `properties`, `$`-members passing via
- * `patternProperties`, and closure via `unevaluatedProperties: false` — except open positions,
- * which route additions to the members' shared tail through `additionalProperties` instead.
- * Terminal denotation refs used more than once become `$defs`, matching the hand-written style.
+ * Emission — one content rule for every file:
+ *
+ * - PUBLIC productions emit as `$defs` PATTERNS: open at the top (`properties` +
+ *   `patternProperties`, no seal), sealed as normal inside. A pattern never seals —
+ *   sealing belongs to the positions that apply patterns.
+ * - `root` emits as the document's `properties` — the definitive syntagma, sealed per the
+ *   `sealed` pragma. In a def-scope file the root ALSO lands as `$defs.<filename>` and the
+ *   document body applies it by reference, so the file stands alone AND serves as a pattern.
+ * - A position that received a pattern's full member set references it (`allOf` of `$ref`s
+ *   with the seal above); a merge that grew a member drops back to expansion (deep-checked).
+ * - The empty sealed leaf emits once as `$defs.terminal`, referenced from every leaf.
  */
 
 export const STAMP_PREFIX = 'built by @vertekum/schema-builder from';
@@ -16,94 +23,211 @@ export function stamp(moduleFile: string): string {
 
 type Schema = Record<string, unknown>;
 
-function countDenotations(node: TreeNode, counts: Map<string, number>): void {
-  if (node.denotation) {
-    counts.set(node.denotation, (counts.get(node.denotation) ?? 0) + 1);
+const TERMINAL = 'terminal';
+const PATTERN_VALVE = { '^\\$': true };
+
+export interface EmitOptions {
+  /** The module filename for the provenance stamp, e.g. `color.dfn`. */
+  moduleFile: string;
+  /** Explicit `id` pragma; wins over `schemaId`. */
+  id?: string;
+  /** Derived `$id` (configured base + artifact path) when no pragma id. */
+  schemaId?: string;
+  title?: string;
+  description?: string;
+  /** The file's nature (inline never emits). */
+  scopeKind: 'document' | 'def';
+  /** The document top's seal (`sealed` pragma; default true). */
+  sealed: boolean;
+  /** Public patterns in declaration order: def name → bare tree. */
+  patterns: Map<string, TreeNode>;
+  /** def-scope with a root: the root's def name (the filename). */
+  rootDefName?: string;
+  /** Bare tree for a pattern reference; undefined = expand instead. */
+  bare?: (ref: PatternRef) => TreeNode | undefined;
+  /** Linked mode: the artifact path a cross-module `$ref` should use; undefined = inline. */
+  linkResolve?: (module: ResolvedModule) => string | undefined;
+}
+
+/** Structural equality of name trees — what "the pattern is still intact here" means. */
+function sameTree(a: TreeNode, b: TreeNode): boolean {
+  if (a.open !== b.open) return false;
+  if (a.children.size !== b.children.size) return false;
+  for (const [name, child] of a.children) {
+    const other = b.children.get(name);
+    if (!other || !sameTree(child, other)) return false;
+  }
+  return true;
+}
+
+interface Context {
+  options: EmitOptions;
+  /** Local def names that exist (patterns + rootDefName) — what `#/$defs/…` may target. */
+  localDefs: Set<string>;
+  /** Set when any leaf referenced `$defs.terminal` (decides whether it is emitted). */
+  usedTerminal: { value: boolean };
+  /** Suppress the terminal ref while emitting the terminal def's own body. */
+  inTerminal: boolean;
+}
+
+/** The `$ref` string for a pattern, or undefined when it must expand. */
+function refTargetOf(ref: PatternRef, ctx: Context): string | undefined {
+  if (!ref.module) {
+    return ctx.localDefs.has(ref.name) ? `#/$defs/${ref.name}` : undefined;
+  }
+  const artifact = ctx.options.linkResolve?.(ref.module);
+  if (!artifact) return undefined;
+  if (ref.root) {
+    // A def module's ROOT is referenced as the file itself — the file IS the pattern —
+    // UNLESS the author sealed the file: then the whole-file ref would drag the seal
+    // into the consumer's composition, so the pointer reaches the unsealed def instead.
+    const sealed = ref.module.module.meta.sealed ?? false;
+    return sealed ? `${artifact}#/$defs/root` : artifact;
   }
-  for (const child of node.children.values()) countDenotations(child, counts);
+  return `${artifact}#/$defs/${ref.name}`;
 }
 
-function position(node: TreeNode, defs: Set<string>): Schema {
-  if (node.denotation && defs.has(node.denotation)) {
-    return { $ref: `#/$defs/${node.denotation}` };
+/**
+ * Emit one position. `seal: false` only for a pattern def's own top — everything below
+ * seals as normal.
+ */
+function position(node: TreeNode, ctx: Context, seal: boolean): Schema {
+  // Linked document-child: verbatim top-level branch of a sealed artifact — bare ref.
+  if (node.link && ctx.options.linkResolve) {
+    const artifact = ctx.options.linkResolve(node.link.module);
+    if (artifact) {
+      return { $ref: `${artifact}#/properties/${node.link.top}` };
+    }
+  }
+
+  // The empty sealed leaf, deduped: reference `$defs.terminal`.
+  if (
+    seal &&
+    !ctx.inTerminal &&
+    !node.open &&
+    node.children.size === 0 &&
+    ctx.localDefs.has(TERMINAL)
+  ) {
+    ctx.usedTerminal.value = true;
+    return { $ref: `#/$defs/${TERMINAL}` };
   }
+
+  // Patterns whose member sets are still intact here become `$ref`s; their members leave
+  // `properties`. Open positions always expand — additions need the members spelled out.
+  const refs: string[] = [];
+  const covered = new Set<string>();
+  if (node.patterns && !node.open) {
+    for (const ref of node.patterns.values()) {
+      const target = refTargetOf(ref, ctx);
+      const bare = ctx.options.bare?.(ref);
+      if (!target || !bare || bare.children.size === 0) continue;
+      let intact = true;
+      for (const [name, member] of bare.children) {
+        const mine = node.children.get(name);
+        if (!mine || !sameTree(member, mine)) {
+          intact = false;
+          break;
+        }
+      }
+      if (!intact) continue;
+      refs.push(target);
+      for (const name of bare.children.keys()) covered.add(name);
+    }
+  }
+
   const properties: Schema = {};
   for (const [name, child] of node.children) {
-    properties[name] = position(child, defs);
+    if (covered.has(name)) continue;
+    properties[name] = position(child, ctx, true);
   }
-  const schema: Schema = {
-    type: 'object',
-    properties,
-    patternProperties: { '^\\$': true },
-  };
+
+  const schema: Schema = {};
+  if (refs.length > 0) schema.allOf = refs.map(($ref) => ({ $ref }));
+  schema.type = 'object';
+  if (Object.keys(properties).length > 0 || refs.length === 0) {
+    schema.properties = properties;
+  }
+  schema.patternProperties = { ...PATTERN_VALVE };
   if (node.open) {
-    // Additions join the set: they take the same tail every listed member has. All members share
-    // it by construction (`*` is restricted to name-only sets), so the first child is the shape.
+    // Additions join the set: they take the same tail every listed member has.
     const first = node.children.values().next().value as TreeNode | undefined;
     schema.additionalProperties = first
-      ? position(first, defs)
-      : { type: 'object', patternProperties: { '^\\$': true } };
-  } else {
+      ? position(first, ctx, true)
+      : { type: 'object', patternProperties: { ...PATTERN_VALVE } };
+  } else if (seal) {
     schema.unevaluatedProperties = false;
   }
   return schema;
 }
 
-/** The $def body for a denotation node: its own position schema, never self-referential. */
-function definition(node: TreeNode, defs: Set<string>): Schema {
-  const bare: TreeNode = { ...node, denotation: undefined };
-  return position(bare, defs);
-}
+export function emit(tree: TreeNode | undefined, options: EmitOptions): string {
+  const localDefs = new Set<string>(options.patterns.keys());
+  if (options.rootDefName) localDefs.add(options.rootDefName);
+  // The terminal dedupe steps aside on the rare production named `terminal`.
+  const terminalAvailable = !localDefs.has(TERMINAL);
+  if (terminalAvailable) localDefs.add(TERMINAL);
 
-export interface EmitOptions {
-  /** The module filename for the provenance stamp, e.g. `house.dfn`. */
-  moduleFile: string;
-  /** From the module's pragmas: `id "…"`, `title "…"`, `description "…"`, `scope "…"`. */
-  id?: string;
-  title?: string;
-  description?: string;
-  scope?: 'document' | 'branch';
-}
+  const ctx: Context = {
+    options,
+    localDefs,
+    usedTerminal: { value: false },
+    inTerminal: false,
+  };
 
-export function emit(tree: TreeNode, options: EmitOptions): string {
-  const counts = new Map<string, number>();
-  countDenotations(tree, counts);
-  const shared = new Set(
-    [...counts.entries()].filter(([, n]) => n >= 2).map(([name]) => name),
-  );
+  // Bodies first — they decide whether `$defs.terminal` is needed at all.
+  const defBodies = new Map<string, Schema>();
+  for (const [name, bare] of options.patterns) {
+    defBodies.set(name, position(bare, ctx, false));
+  }
+  if (options.rootDefName && tree) {
+    defBodies.set(options.rootDefName, position(tree, ctx, false));
+  }
+  const body: Schema | undefined =
+    options.scopeKind === 'document' && tree
+      ? position(tree, ctx, options.sealed)
+      : options.scopeKind === 'def' && options.rootDefName
+        ? {
+            type: 'object',
+            allOf: [{ $ref: `#/$defs/${options.rootDefName}` }],
+            patternProperties: { ...PATTERN_VALVE },
+            ...(options.sealed ? { unevaluatedProperties: false } : {}),
+          }
+        : undefined;
 
   const document: Schema = {
     $schema: 'https://json-schema.org/draft/2020-12/schema',
   };
-  if (options.id) document.$id = options.id;
+  const id = options.id ?? options.schemaId;
+  if (id) document.$id = id;
   document.$comment = stamp(options.moduleFile);
   if (options.title) document.title = options.title;
   if (options.description) document.description = options.description;
 
-  if (shared.size > 0) {
+  if (defBodies.size > 0 || ctx.usedTerminal.value) {
     const defs: Schema = {};
-    const collect = (node: TreeNode): void => {
-      if (
-        node.denotation &&
-        shared.has(node.denotation) &&
-        !(node.denotation in defs)
-      ) {
-        defs[node.denotation] = definition(node, shared);
-      }
-      for (const child of node.children.values()) collect(child);
-    };
-    collect(tree);
+    if (ctx.usedTerminal.value && terminalAvailable) {
+      defs[TERMINAL] = {
+        type: 'object',
+        properties: {},
+        patternProperties: { ...PATTERN_VALVE },
+        unevaluatedProperties: false,
+      };
+    }
+    for (const [name, defBody] of defBodies) defs[name] = defBody;
     document.$defs = defs;
   }
 
-  const root = position(tree, shared);
-  document.type = root.type;
-  document.properties = root.properties;
-  document.patternProperties = root.patternProperties;
-  // `scope "branch"`: govern only the named top-level branches — the document root stays
-  // unsealed so sibling vocabularies can bind over the same files. Default seals.
-  if (options.scope !== 'branch') {
-    document.unevaluatedProperties = root.unevaluatedProperties;
+  if (body) {
+    if (body.allOf) document.allOf = body.allOf;
+    document.type = body.type;
+    if (body.properties) document.properties = body.properties;
+    document.patternProperties = body.patternProperties;
+    if (body.additionalProperties !== undefined) {
+      document.additionalProperties = body.additionalProperties;
+    }
+    if (body.unevaluatedProperties !== undefined) {
+      document.unevaluatedProperties = body.unevaluatedProperties;
+    }
   }
 
   return `${JSON.stringify(document, null, 2)}\n`;

package/src/format.ts

@@ -0,0 +1,273 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { type Token, tokenize } from './tokenizer';
+
+/**
+ * The `.dfn` formatter: JS-literal block formatting with authorial break choices.
+ *
+ * Inline vs block is the author's call — a `[` with content on its line stays inline, a `[`
+ * followed by a newline is a block. The formatter owns everything inside that choice: block
+ * indentation (+1 unit per level, closer dedented to its opener's line), canonical token
+ * spacing, comment placement, and whitespace hygiene. It never moves a line break.
+ */
+
+export interface FormatOptions {
+  /** One indent unit (a run of spaces, or '\t'). Default two spaces. */
+  indent: string;
+}
+
+/** Micro-spacing is canonical — one style, no knobs. The seam exists so a knob could. */
+const DEFAULT_OPTIONS: FormatOptions = { indent: '  ' };
+
+/** Split one source line into its code part and its `#` comment (strings respected). */
+function splitComment(line: string): { code: string; comment: string | null } {
+  let inString = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') inString = !inString;
+    if (ch === '#' && !inString) {
+      return { code: line.slice(0, i), comment: line.slice(i).trimEnd() };
+    }
+  }
+  return { code: line, comment: null };
+}
+
+/** The token's source text, re-quoted for strings. */
+function text(token: Token): string {
+  return token.kind === 'string' ? `"${token.value}"` : token.value;
+}
+
+const TIGHT_AFTER = new Set([
+  'dot',
+  'langle',
+  'at',
+  'slash',
+  'bang',
+  'lbracket',
+  'colon',
+]);
+const TIGHT_BEFORE = new Set([
+  'dot',
+  'comma',
+  'question',
+  'rangle',
+  'rbracket',
+  'slash',
+]);
+
+/** The separator between two adjacent tokens on one line. */
+function separator(prev: Token, cur: Token, next: Token | undefined): string {
+  // `*` is tight inside a reference (`<x*>`), spaced before a group closer (`[a | b *]`).
+  if (cur.kind === 'star') return next?.kind === 'rangle' ? '' : ' ';
+  if (prev.kind === 'star') return ''; // always immediately before its closer
+  if (TIGHT_AFTER.has(prev.kind)) return '';
+  if (TIGHT_BEFORE.has(cur.kind)) return '';
+  return ' ';
+}
+
+/** Re-emit one line's tokens under the canonical spacing rules. */
+function printTokens(tokens: Token[]): string {
+  let out = '';
+  for (let i = 0; i < tokens.length; i++) {
+    if (i > 0) out += separator(tokens[i - 1], tokens[i], tokens[i + 1]);
+    out += text(tokens[i]);
+  }
+  return out;
+}
+
+/**
+ * Format a module's source. Throws (a DfnError from the tokenizer) when the source cannot be
+ * lexed — a broken module is lint's report; the formatter never rewrites what it cannot read.
+ */
+export function formatSource(
+  source: string,
+  options: FormatOptions = DEFAULT_OPTIONS,
+): string {
+  // One pass over the whole source: per-line token groups, and which bracket tokens belong to
+  // BLOCK pairs (opener and closer on different lines) — only those contribute indent levels.
+  const tokens = tokenize(source);
+  const byLine = new Map<number, Token[]>();
+  const blockBrackets = new Set<Token>();
+  const opens: Token[] = [];
+  for (const token of tokens) {
+    if (token.kind === 'newline' || token.kind === 'eof') continue;
+    const list = byLine.get(token.line) ?? [];
+    list.push(token);
+    byLine.set(token.line, list);
+    if (token.kind === 'lbracket') opens.push(token);
+    if (token.kind === 'rbracket') {
+      const open = opens.pop();
+      if (open && open.line !== token.line) {
+        blockBrackets.add(open);
+        blockBrackets.add(token);
+      }
+    }
+  }
+
+  const lines = source.split('\n');
+  const out: string[] = [];
+  let level = 0;
+  let blankRun = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const { comment } = splitComment(lines[i]);
+    const lineTokens = byLine.get(i + 1) ?? [];
+
+    if (lineTokens.length === 0 && comment === null) {
+      blankRun += 1;
+      continue;
+    }
+    // Runs of blank lines collapse to one; none at the start of the file.
+    if (blankRun > 0 && out.length > 0) out.push('');
+    blankRun = 0;
+
+    // A leading run of block closers sits at its openers' level, one step back each.
+    let leadingClosers = 0;
+    for (const token of lineTokens) {
+      if (token.kind === 'rbracket' && blockBrackets.has(token))
+        leadingClosers += 1;
+      else break;
+    }
+    const startLevel = Math.max(0, level - leadingClosers);
+    for (const token of lineTokens) {
+      if (!blockBrackets.has(token)) continue;
+      if (token.kind === 'lbracket') level += 1;
+      if (token.kind === 'rbracket') level = Math.max(0, level - 1);
+    }
+
+    const indent = options.indent.repeat(startLevel);
+    const code = printTokens(lineTokens);
+    if (comment !== null) {
+      out.push(
+        code.length > 0
+          ? `${indent}${code}  ${comment}`
+          : `${indent}${comment}`,
+      );
+    } else {
+      out.push(indent + code);
+    }
+  }
+
+  return `${out.join('\n')}\n`;
+}
+
+/**
+ * Resolve the indent unit for a `.dfn` file: the project's `format.indent` when set, else the
+ * nearest `.editorconfig` (`[*.dfn]` over `[*]`, closest file wins, `root = true` stops the
+ * walk), else two spaces.
+ */
+export function resolveIndent(
+  filePath: string,
+  projectIndent?: string | number,
+): string {
+  if (typeof projectIndent === 'number') return ' '.repeat(projectIndent);
+  if (typeof projectIndent === 'string') return projectIndent;
+
+  let dir = dirname(filePath);
+  const configs: string[] = [];
+  for (;;) {
+    const candidate = join(dir, '.editorconfig');
+    if (existsSync(candidate)) {
+      const content = readFileSync(candidate, 'utf8');
+      configs.push(content);
+      if (/^\s*root\s*=\s*true\s*$/im.test(content)) break;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Farthest file first, so closer files (and later sections within a file) override.
+  let style: string | undefined;
+  let size: string | undefined;
+  for (const content of configs.reverse()) {
+    let applies = false;
+    for (const raw of content.split('\n')) {
+      const line = raw.trim();
+      const section = line.match(/^\[(.+)\]$/);
+      if (section) {
+        const glob = section[1];
+        applies =
+          glob === '*' ||
+          glob === '**' ||
+          /(^|[*{,])dfn[},]?$|\*\.dfn/.test(glob);
+        continue;
+      }
+      if (!applies) continue;
+      const pair = line.match(/^([A-Za-z_]+)\s*=\s*(.+)$/);
+      if (!pair) continue;
+      if (pair[1] === 'indent_style') style = pair[2].trim();
+      if (pair[1] === 'indent_size') size = pair[2].trim();
+    }
+  }
+
+  if (style === 'tab') return '\t';
+  const width = size !== undefined ? Number.parseInt(size, 10) : Number.NaN;
+  if (Number.isFinite(width) && width > 0) return ' '.repeat(width);
+  return DEFAULT_OPTIONS.indent;
+}
+
+/** One applied repair. */
+export interface DfnFix {
+  line: number;
+  column: number;
+  message: string;
+}
+
+/**
+ * Apply the mechanical, unambiguous repairs — currently one: a trailing open-set mark
+ * (`<name>*` → `<name*>`, `[a | b]*` → `[a | b *]`). Repaired lines are re-emitted through the
+ * canonical printer; untouched lines stay verbatim. A source that cannot be lexed fixes nothing.
+ */
+export function fixSource(source: string): {
+  content: string;
+  fixes: DfnFix[];
+} {
+  let tokens: Token[];
+  try {
+    tokens = tokenize(source);
+  } catch {
+    return { content: source, fixes: [] };
+  }
+
+  const byLine = new Map<number, Token[]>();
+  for (const token of tokens) {
+    if (token.kind === 'newline' || token.kind === 'eof') continue;
+    const list = byLine.get(token.line) ?? [];
+    list.push(token);
+    byLine.set(token.line, list);
+  }
+
+  const fixes: DfnFix[] = [];
+  const lines = source.split('\n');
+  for (const [line, lineTokens] of byLine) {
+    let repaired = false;
+    for (let i = 0; i + 1 < lineTokens.length; i++) {
+      const closer = lineTokens[i];
+      const star = lineTokens[i + 1];
+      if (
+        (closer.kind === 'rangle' || closer.kind === 'rbracket') &&
+        star.kind === 'star'
+      ) {
+        lineTokens[i] = star;
+        lineTokens[i + 1] = closer;
+        repaired = true;
+        fixes.push({
+          line,
+          column: star.column,
+          message: `moved '*' inside the ${closer.kind === 'rangle' ? 'reference' : 'group'} it opens`,
+        });
+      }
+    }
+    if (repaired) {
+      const raw = lines[line - 1];
+      const { comment } = splitComment(raw);
+      const leading = raw.match(/^\s*/)?.[0] ?? '';
+      const code = printTokens(lineTokens);
+      lines[line - 1] =
+        comment !== null ? `${leading}${code}  ${comment}` : leading + code;
+    }
+  }
+
+  return { content: lines.join('\n'), fixes };
+}

package/src/index.ts

@@ -1,11 +1,37 @@
 import { defineExtension, type ExtensionManifest } from '@vertekum/core';
+import { z } from 'zod';
 import { activate } from './api';
 
+/**
+ * The input/output pair, declared once in config:
+ *
+ *   schemaBuilderExtension({ source: './src/dfn', out: './src/schemas' })
+ *
+ * `source` is where the `.dfn` modules live — the default sweep for `schema build`, `lint`,
+ * and `fmt`. `out` is where built `.json` files land, mirroring `source`'s directory
+ * structure; unset means beside each module. Both resolve relative to the working directory.
+ */
+export const SchemaBuilderSettings = z.object({
+  source: z.string().default('./schemas'),
+  out: z.string().optional(),
+  /**
+   * Linked emission: an unmodified `<@module>` root embedding `$ref`s the child module's own
+   * artifact instead of inlining a copy. Default false — self-contained artifacts.
+   */
+  link: z.boolean().default(false),
+  /**
+   * Base URI for derived `$id`s: each artifact gets base + its artifact-relative path.
+   * A file's `id` pragma wins. Unset: no `$id` unless the pragma supplies one.
+   */
+  schemaId: z.string().optional(),
+});
+
 export const schemaBuilderManifest = {
   id: 'vtk.schema-builder',
   name: 'Schema Builder',
   description:
-    "Builds `.dfn` vocabulary modules — a grammar for declaring which token names may exist, and in what order — into the JSON Schema files the `schemas` config binds. Contributes the 'schema build' command. A non-view extension: no route, no ribbon entry.",
+    "Builds `.dfn` vocabulary modules — a grammar for declaring which token names may exist, and in what order — into the JSON Schema files the `schemas` config binds. Contributes the 'schema build', 'schema lint', and 'schema fmt' commands. A non-view extension: no route, no ribbon entry.",
+  settings: SchemaBuilderSettings,
   activation: ['onStartup'],
 } satisfies ExtensionManifest;
 

package/src/lint.ts

@@ -18,6 +18,8 @@ export interface DfnDiagnostic {
   line: number;
   column: number;
   message: string;
+  /** `error` blocks (exit 1); `warning` reports without failing. Absent = error. */
+  severity?: 'warning';
 }
 
 function toDiagnostic(file: string, error: unknown): DfnDiagnostic {
@@ -38,15 +40,30 @@ function toDiagnostic(file: string, error: unknown): DfnDiagnostic {
 }
 
 /** Lint one module. Returns every finding; an empty array means the grammar is sound. */
-export function lintModule(path: string): DfnDiagnostic[] {
+export function lintModule(
+  path: string,
+  sources?: Map<string, string>,
+): DfnDiagnostic[] {
   let resolved: ReturnType<typeof resolveModule>;
   try {
-    resolved = resolveModule(path);
+    resolved = resolveModule(path, new Set(), sources);
   } catch (error) {
     return [toDiagnostic(path, error)];
   }
 
   const out: DfnDiagnostic[] = [];
+  const warn = (
+    file: string,
+    line: number,
+    column: number,
+    message: string,
+  ): void => {
+    out.push({ file, line, column, message, severity: 'warning' });
+  };
+  // Deprecated forms the parser honored (e.g. `scope "branch"`) surface as warnings.
+  for (const note of resolved.module.notes) {
+    warn(resolved.path, note.line, note.column, note.message);
+  }
   const collect = (walk: () => void): void => {
     try {
       walk();
@@ -57,7 +74,7 @@ export function lintModule(path: string): DfnDiagnostic[] {
 
   for (const [name, node] of resolved.module.productions) {
     collect(() => {
-      evaluateProduction(resolved, name);
+      evaluateProduction(resolved, name, warn);
       assertOpenSetsAreNameSets(resolved, node);
     });
   }
@@ -65,7 +82,7 @@ export function lintModule(path: string): DfnDiagnostic[] {
     // `build` re-expands referenced productions, so a production's error can surface twice —
     // once from its own walk, once through the root. The dedupe below keeps one.
     collect(() => {
-      build(resolved);
+      build(resolved, { warn });
       assertOpenSetsAreNameSets(resolved);
     });
   }