@intentius/chant 0.101.0 → 0.102.0

package/src/cli/commands/check-lexicon.ts

@@ -106,6 +106,36 @@ export async function coverageReportCheck(plugin: LexiconPlugin | undefined): Pr
   };
 }
 
+/**
+ * #3104 — how many composites a lexicon ships.
+ *
+ * This counted every `.ts` file in `src/composites/` except `index.ts`, so
+ * `catalog.ts`, `catalog.test.ts`, `composites.test.ts` and helper modules all
+ * counted: otel reported "4 composite(s)" for `NodeAgent` alone. The same rule
+ * as #1342 applies: a capability is what the plugin exposes, and a lexicon
+ * with composites exposes them through `composites()`, the catalog generated
+ * from its real exports (#2662). Ask that when it is there. Only a lexicon
+ * without it falls back to the files, and then not to tests, the catalog, the
+ * barrel or helper modules.
+ */
+export function countComposites(
+  plugin: LexiconPlugin | undefined,
+  dir: string,
+): { count: number; detail: string } {
+  if (registers(plugin, "composites")) {
+    const { items, error } = safeList(plugin!.composites!.bind(plugin));
+    if (error !== undefined) return { count: 0, detail: `composites() threw: ${error}` };
+    const names = new Set(items.map((e) => e.name));
+    return { count: names.size, detail: `${names.size} composite(s) in composites()` };
+  }
+  const files = listTsFiles(join(dir, "src/composites"), ["index.ts", "catalog.ts", "helpers.ts", "shared.ts"])
+    .filter((f) => !f.endsWith(".test.ts") && !f.endsWith(".d.ts") && !f.endsWith("-helpers.ts"));
+  return {
+    count: files.length,
+    detail: `${files.length} composite file(s) in src/composites/; the plugin has no composites()`,
+  };
+}
+
 /**
  * #2535 — a lexicon that supplies member kinds publishes them as data at a
  * `./workspace-kinds` subpath (ws-031). The file must be JSON, validate as
@@ -551,12 +581,12 @@ export async function checkLexicon(dir: string): Promise<CheckResult> {
       : "reads no config namespace of its own",
   });
 
-  const compositeFiles = listTsFiles(join(dir, "src/composites"), ["index.ts"]);
+  const composites = countComposites(plugin, dir);
   items.push({
-    name: "At least 1 composite in src/composites/",
+    name: "At least 1 composite",
     tier: 2,
-    pass: compositeFiles.length > 0,
-    detail: compositeFiles.length > 0 ? `${compositeFiles.length} composite(s)` : undefined,
+    pass: composites.count > 0,
+    detail: composites.detail,
   });
 
   items.push({
@@ -678,8 +708,8 @@ export async function checkLexicon(dir: string): Promise<CheckResult> {
   items.push({
     name: "At least 5 composites",
     tier: 3,
-    pass: compositeFiles.length >= 5,
-    detail: `${compositeFiles.length} composite(s)`,
+    pass: composites.count >= 5,
+    detail: composites.detail,
   });
 
   const hasActions = existsSync(join(dir, "src/actions")) &&

package/src/cli/commands/import-live.test.ts

@@ -106,6 +106,24 @@ describe("liveImportFromPlugins (#114)", () => {
     expect(result.error).toContain("live export");
   });
 
+  test("warnings an exporter returns reach the result (#3336)", async () => {
+    const withWarnings: ExportedTemplate = { ...sampleIR, warnings: ["bucket is kept by Terraform; left out"] };
+    const result = await liveImportFromPlugins([fakeExporter("fake", withWarnings)], {
+      environment: "prod",
+      output: outputDir,
+      force: true,
+    });
+    expect(result.success).toBe(true);
+    expect(result.warnings).toContain("bucket is kept by Terraform; left out");
+  });
+
+  test("warnings from an export with no resources are kept on the error result (#3336)", async () => {
+    const empty = fakeExporter("fake", { resources: [], parameters: [], warnings: ["everything is kept by Prisma"] });
+    const result = await liveImportFromPlugins([empty], { environment: "prod", output: outputDir });
+    expect(result.success).toBe(false);
+    expect(result.warnings).toContain("everything is kept by Prisma");
+  });
+
   test("--lexicon narrows to the named exporter", async () => {
     const result = await liveImportFromPlugins(
       [fakeExporter("a", sampleIR), fakeExporter("b", sampleIR)],

package/src/cli/commands/import-parser-options.test.ts

@@ -0,0 +1,133 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { LexiconPlugin } from "../../lexicon";
+import type { ParserOptions } from "../../import/parser";
+import { resolveParserOptions } from "../../import/parser-options";
+import { parseArgs } from "../main";
+import { importCommand, importFromContent } from "./import";
+
+const { seen, withOptions, withoutOptions } = vi.hoisted(() => {
+  const seen: unknown[] = [];
+  const parser = {
+    parse: () => ({ resources: [], parameters: [], warnings: ["parsed"] }),
+  };
+  const generator = { generate: () => [{ path: "x.ts", content: "export {};\n" }] };
+  const withOptions = {
+    name: "with-options",
+    detectTemplate: (d: unknown) => typeof d === "object" && d !== null && "marker" in d,
+    parserOptions: () => [
+      { name: "flag", type: "boolean", description: "a switch" },
+      { name: "level", type: "number", description: "a number" },
+      { name: "label", type: "string", description: "a string" },
+    ],
+    templateParser: (options?: ParserOptions) => {
+      seen.push(options);
+      return parser;
+    },
+    templateGenerator: () => generator,
+  } as unknown as LexiconPlugin;
+  const withoutOptions = {
+    name: "without-options",
+    templateParser: () => parser,
+    templateGenerator: () => generator,
+  } as unknown as LexiconPlugin;
+  return { seen, withOptions, withoutOptions };
+});
+
+vi.mock("../plugins", () => ({
+  resolveProjectLexicons: async () => ["with-options"],
+  loadPlugins: async (names: string[]) => names.map((n) => (n === "without-options" ? withoutOptions : withOptions)),
+}));
+
+describe("resolveParserOptions (#2994)", () => {
+  const specs = withOptions as Pick<LexiconPlugin, "name" | "parserOptions">;
+
+  test("no entries is an empty record", () => {
+    expect(resolveParserOptions(specs, undefined)).toEqual({ options: {} });
+  });
+
+  test("converts to the declared types; a bare boolean is true", () => {
+    expect(resolveParserOptions(specs, ["flag", "level=3", "label=a=b"])).toEqual({
+      options: { flag: true, level: 3, label: "a=b" },
+    });
+    expect(resolveParserOptions(specs, ["flag=false"])).toEqual({ options: { flag: false } });
+  });
+
+  test("refuses an unknown name and lists what the lexicon accepts", () => {
+    const r = resolveParserOptions(specs, ["nope"]);
+    expect(r).toMatchObject({ error: expect.stringContaining('Unknown parser option "nope" for lexicon "with-options"') });
+    expect((r as { error: string }).error).toContain("flag (boolean): a switch");
+  });
+
+  test("a lexicon with no options says so", () => {
+    const r = resolveParserOptions({ name: "plain" }, ["x"]);
+    expect((r as { error: string }).error).toBe('Unknown parser option "x" for lexicon "plain"; lexicon "plain" declares no parser options.');
+  });
+
+  test("refuses a bad value", () => {
+    expect(resolveParserOptions(specs, ["flag=maybe"])).toHaveProperty("error");
+    expect(resolveParserOptions(specs, ["level=abc"])).toHaveProperty("error");
+    expect(resolveParserOptions(specs, ["level"])).toHaveProperty("error");
+    expect(resolveParserOptions(specs, ["label"])).toHaveProperty("error");
+  });
+});
+
+describe("chant import --parser-option (#2994)", () => {
+  let dir: string;
+  let templatePath: string;
+
+  beforeEach(async () => {
+    seen.length = 0;
+    dir = join(tmpdir(), `chant-import-parser-options-${Date.now()}-${Math.random()}`);
+    await mkdir(dir, { recursive: true });
+    templatePath = join(dir, "t.json");
+    await writeFile(templatePath, JSON.stringify({ marker: true }));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  test("the flag is parsed, repeatable", () => {
+    const args = parseArgs(["import", "t.json", "--lexicon", "x", "--parser-option", "a", "--parser-option", "b=1"]);
+    expect(args.parserOption).toEqual(["a", "b=1"]);
+  });
+
+  test("--lexicon: the parser receives the typed options", async () => {
+    const result = await importCommand({
+      templatePath, output: join(dir, "out"), lexicon: "with-options", parserOptions: ["flag", "level=2"],
+    });
+    expect(result.success).toBe(true);
+    expect(seen).toEqual([{ flag: true, level: 2 }]);
+  });
+
+  test("detection: the options go to the detected lexicon", async () => {
+    const result = await importCommand({ templatePath, output: join(dir, "out"), parserOptions: ["label=x"] });
+    expect(result.success).toBe(true);
+    expect(seen).toEqual([{ label: "x" }]);
+  });
+
+  test("no options: the parser gets an empty record", async () => {
+    await importCommand({ templatePath, output: join(dir, "out"), lexicon: "with-options" });
+    expect(seen).toEqual([{}]);
+  });
+
+  test("an unknown option is refused before parsing", async () => {
+    const result = await importCommand({
+      templatePath, output: join(dir, "out"), lexicon: "with-options", parserOptions: ["bogus"],
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('Unknown parser option "bogus"');
+    expect(seen).toEqual([]);
+  });
+
+  test("content import refuses an option on a lexicon that declares none", async () => {
+    const result = await importFromContent({
+      content: "{}", lexicon: "without-options", output: join(dir, "out"), parserOptions: ["x"],
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('lexicon "without-options" declares no parser options');
+  });
+});

package/src/cli/commands/import.ts

@@ -7,6 +7,7 @@ import { listInstalledLexicons, loadPlugin, loadPlugins, resolveProjectLexicons
 import type { ExportedTemplate, LexiconPlugin, ResourceSelector } from "../../lexicon";
 import { parseYAMLDocument, splitYAMLDocuments } from "../../yaml";
 import { importLexiconPackage } from "../../lexicon-module";
+import { resolveParserOptions } from "../../import/parser-options";
 import { EmbeddedImports, type EmbeddedContent, type RegisteredEmbeddedImporter } from "../../import/embedded";
 
 /**
@@ -24,6 +25,12 @@ export interface ImportOptions {
    * JSON/YAML check: the raw content goes straight to that plugin's parser.
    */
   lexicon?: string;
+  /**
+   * `--parser-option` entries (`key` or `key=value`) for the lexicon's parser
+   * (#2994). Checked against the lexicon's `parserOptions()`; an unknown name
+   * fails the import before anything is parsed.
+   */
+  parserOptions?: string[];
 }
 
 /**
@@ -345,6 +352,7 @@ export async function importCommand(options: ImportOptions): Promise<ImportResul
       lexicon: options.lexicon,
       output: options.output,
       force: options.force,
+      parserOptions: options.parserOptions,
     });
   }
 
@@ -383,7 +391,7 @@ export async function importCommand(options: ImportOptions): Promise<ImportResul
     );
   }
 
-  const result = await parseAndWrite(plugin, content, outputDir, options.force, warnings, generatedFiles, plugin.name, projectDir);
+  const result = await parseAndWrite(plugin, content, outputDir, options.force, warnings, generatedFiles, plugin.name, projectDir, options.parserOptions);
   return { ...result, detected: true };
 }
 
@@ -402,6 +410,8 @@ export interface ContentImportOptions {
   lexicon: string;
   output?: string;
   force?: boolean;
+  /** `--parser-option` entries for the lexicon's parser (#2994); see {@link ImportOptions.parserOptions}. */
+  parserOptions?: string[];
 }
 
 export async function importFromContent(options: ContentImportOptions): Promise<ImportResult> {
@@ -422,7 +432,7 @@ export async function importFromContent(options: ContentImportOptions): Promise<
     return { success: false, generatedFiles: [], warnings: [], error: `Lexicon "${options.lexicon}" not available.` };
   }
   const projectDir = resolve(options.output ? dirname(options.output) : ".");
-  return parseAndWrite(plugin, options.content, outputDir, options.force, [], [], plugin.name, projectDir);
+  return parseAndWrite(plugin, options.content, outputDir, options.force, [], [], plugin.name, projectDir, options.parserOptions);
 }
 
 /**
@@ -520,6 +530,7 @@ async function parseAndWrite(
   generatedFiles: string[],
   lexicon: string,
   projectDir: string,
+  parserOptionEntries?: readonly string[],
 ): Promise<ImportResult> {
   // A lexicon can recognize a template (detectTemplate) without being able to
   // import it (grafana had no parser until #2945). Every path funnels through here, so
@@ -534,11 +545,16 @@ async function parseAndWrite(
     };
   }
 
+  const resolved = resolveParserOptions(plugin, parserOptionEntries);
+  if ("error" in resolved) {
+    return { success: false, generatedFiles: [], warnings: [], error: resolved.error, lexicon: plugin.name };
+  }
+
   // Parse template
   let ir: TemplateIR;
   let embedded: EmbeddedImports | undefined;
   try {
-    const parser = plugin.templateParser();
+    const parser = plugin.templateParser(resolved.options);
     let irs: TemplateIR[];
     ({ irs, embedded } = await parseWithEmbedded([(context) => parser.parse(content, context)], [plugin], projectDir));
     ir = irs[0];
@@ -743,6 +759,8 @@ export async function liveImportFromPlugins(
       warnings.push(`${plugin.name}: live export failed — ${err instanceof Error ? err.message : String(err)}`);
       continue;
     }
+    // What the exporter left out or could not carry (#3336).
+    if (ir.warnings) warnings.push(...ir.warnings);
     if (ir.resources.length === 0) continue;
     irParts.push(ir);
     generatorLexicon ??= plugin;

package/src/cli/commands/init-lexicon/templates/project.ts

@@ -37,7 +37,7 @@ export function generatePackageJson(name: string, names: { packageName: string }
       // (the `workspace:` protocol is rejected outside a workspace).
       "@intentius/chant": "*",
       "tsc-alias": "^1.8.17",
-      typescript: "^5.9.3",
+      typescript: "^5.9.3 || ^7.0.0",
     },
   };
 

package/src/cli/commands/init.test.ts

@@ -87,7 +87,9 @@ describe("initCommand", () => {
 
       expect(pkg.dependencies["@intentius/chant"]).toBeDefined();
       expect(pkg.dependencies["@intentius/chant-lexicon-aws"]).toBeDefined();
-      expect(pkg.devDependencies["typescript"]).toBeDefined();
+      // #3089: the project's TypeScript admits 7, and @types/node backs `types: ["node"]`.
+      expect(pkg.devDependencies["typescript"]).toBe("^5.9.3 || ^7.0.0");
+      expect(pkg.devDependencies["@types/node"]).toBeDefined();
       expect(pkg.scripts.build).toBe("chant build src --lexicon aws");
       expect(pkg.scripts.dev).toBe("chant build src --lexicon aws --watch");
       expect(pkg.scripts.lint).toBe("chant lint src");
@@ -115,6 +117,11 @@ describe("initCommand", () => {
       expect(tsconfig.compilerOptions.rootDir).toBe("./src");
       expect(tsconfig.include).toContain("src");
       expect(tsconfig.compilerOptions.paths).toBeUndefined();
+      // #3089: bundler resolution accepts the extensionless `./config` imports
+      // the templates use; NodeNext rejects them (TS2835).
+      expect(tsconfig.compilerOptions.module).toBe("esnext");
+      expect(tsconfig.compilerOptions.moduleResolution).toBe("bundler");
+      expect(tsconfig.compilerOptions.types).toEqual(["node"]);
     });
   });
 

package/src/cli/commands/init.ts

@@ -62,6 +62,16 @@ export interface InitResult {
   lexiconModule?: string;
 }
 
+/**
+ * The devDependencies a scaffolded project gets, from `chant init` and from
+ * `chant carve` (#3233). The project's TypeScript is for its editor and `tsc`
+ * only; chant parses with its own copy, so any 5.9+ or 7 release works (#3089).
+ */
+export const SCAFFOLD_DEV_DEPENDENCIES = {
+  "@types/node": "^24.0.0",
+  typescript: "^5.9.3 || ^7.0.0",
+} as const;
+
 /**
  * Generate package.json content
  */
@@ -88,23 +98,28 @@ function generatePackageJson(
       ...extraScripts,
     },
     dependencies,
-    devDependencies: {
-      typescript: "^5.0.0",
-    },
+    devDependencies: { ...SCAFFOLD_DEV_DEPENDENCIES },
   };
 
   return JSON.stringify(pkg, null, 2);
 }
 
 /**
- * Generate tsconfig.json content with path mappings for .chant/ types
+ * Generate tsconfig.json content.
+ *
+ * `bundler` resolution, because chant resolves a project's imports the way tsx
+ * and fold do: `./config` with no extension. NodeNext rejects that form
+ * (TS2835), and its suggested `./config.js` makes fold fall back to running the
+ * file (#3089). `types` names node because TypeScript 6 and later no longer load
+ * every `@types` package by default.
  */
-function generateTsConfig(lexicon: string): string {
+export function generateTsConfig(): string {
   const config = {
     compilerOptions: {
       target: "ES2022",
-      module: "NodeNext",
-      moduleResolution: "NodeNext",
+      module: "esnext",
+      moduleResolution: "bundler",
+      types: ["node"],
       strict: true,
       esModuleInterop: true,
       skipLibCheck: true,
@@ -307,7 +322,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   // Generate tsconfig.json
   writeIfNotExists(
     join(targetDir, "tsconfig.json"),
-    generateTsConfig(options.lexicon),
+    generateTsConfig(),
     "tsconfig.json",
     createdFiles,
     warnings,

package/src/cli/commands/lint.test.ts

@@ -281,6 +281,43 @@ export const b = new Bucket({ config: { y: 2 } });
     expect(result.diagnostics.some(d => d.ruleId === "COR001")).toBe(true);
     expect(result.diagnostics.filter(d => d.ruleId === "COR001")).toHaveLength(2);
   });
+
+  // #2511: a project-local rule that throws is an error, never a clean pass.
+  test("a project-local rule that throws fails the lint and names the rule, file and message", async () => {
+    await mkdir(join(testDir, ".chant", "rules"), { recursive: true });
+    await writeFile(
+      join(testDir, ".chant", "rules", "local.ts"),
+      `
+export const boom = {
+  id: "LOCAL_BOOM",
+  severity: "warning",
+  category: "correctness",
+  check() { throw new Error("cannot read sibling file"); },
+};
+export const fine = {
+  id: "LOCAL_FINE",
+  severity: "warning",
+  category: "correctness",
+  check(ctx) {
+    return [{ file: ctx.filePath, line: 1, column: 1, ruleId: "LOCAL_FINE", severity: "warning", message: "fine ran" }];
+  },
+};
+      `,
+    );
+    const file = join(testDir, "clean.ts");
+    await writeFile(file, `// chant-disable\nexport const config = { a: 1 };\n`);
+
+    const result = await lintCommand({ path: testDir, format: "stylish" });
+
+    expect(result.success).toBe(false);
+    const threw = result.diagnostics.filter((d) => d.ruleId === "LOCAL_BOOM");
+    expect(threw).toHaveLength(1);
+    expect(threw[0].severity).toBe("error");
+    expect(threw[0].file).toBe(file);
+    expect(threw[0].message).toContain("LOCAL_BOOM");
+    expect(threw[0].message).toContain(file);
+    expect(threw[0].message).toContain("cannot read sibling file");
+  });
 });
 
 describe("isLintRule", () => {

package/src/cli/commands/onboard.test.ts

@@ -7,6 +7,7 @@ import {
   patchDockerfile,
   patchRootTsconfigPaths,
   insertPrepackAfterEach,
+  patchLexiconList,
 } from "./onboard";
 
 function makeTempDir(): string {
@@ -184,6 +185,8 @@ function writeFixtureRepo(root: string): void {
   writeFileSync(join(root, ".github/workflows/publish.yml"), publishContent);
   writeFileSync(join(root, "test/Dockerfile.smoke"), dockerLoopContent);
   writeFileSync(join(root, "test/Dockerfile.smoke-npm"), dockerNpmContent);
+  writeFileSync(join(root, "test/smoke-npm-lexicons.txt"), "aws\ngitlab\nk8s\n");
+  writeFileSync(join(root, "test/smoke-e2e-lexicons.txt"), "aws\nk8s\n");
 }
 
 const TRACKED = [
@@ -193,6 +196,8 @@ const TRACKED = [
   ".github/workflows/publish.yml",
   "test/Dockerfile.smoke",
   "test/Dockerfile.smoke-npm",
+  "test/smoke-npm-lexicons.txt",
+  "test/smoke-e2e-lexicons.txt",
 ];
 
 function snapshot(root: string): Record<string, string> {
@@ -223,8 +228,12 @@ describe("onboardCommand", () => {
       "publish.yml (prepack)",
       "Dockerfile.smoke (lexicon list)",
       "Dockerfile.smoke-npm (lexicon list)",
+      "smoke-npm-lexicons.txt (lexicon list)",
     ]);
-    expect(result.skipped).toEqual([]);
+    expect(result.skipped).toHaveLength(1);
+    expect(result.skipped[0]).toContain("smoke-e2e-lexicons.txt: not patched");
+    expect(readFileSync(join(root, "test/smoke-npm-lexicons.txt"), "utf-8")).toBe("aws\ngitlab\nk8s\nterraform\n");
+    expect(readFileSync(join(root, "test/smoke-e2e-lexicons.txt"), "utf-8")).toBe("aws\nk8s\n");
 
     const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
     expect(pkg.dependencies["@intentius/chant-lexicon-terraform"]).toBe("workspace:*");
@@ -254,6 +263,8 @@ describe("onboardCommand", () => {
       "publish.yml: prepack for terraform already present",
       "Dockerfile.smoke: already covers terraform",
       "Dockerfile.smoke-npm: already covers terraform",
+      "smoke-npm-lexicons.txt: terraform already in test/smoke-npm-lexicons.txt",
+      expect.stringContaining("smoke-e2e-lexicons.txt: not patched"),
     ]);
   });
 
@@ -312,9 +323,9 @@ describe("root tsconfig.json paths (#1614)", () => {
 
     const cfg = JSON.parse(readFileSync(join(root, "tsconfig.json"), "utf-8"));
     expect(cfg.compilerOptions.paths["@intentius/chant-lexicon-terraform"]).toEqual([
-      "lexicons/terraform/src/index.ts",
+      "./lexicons/terraform/src/index.ts",
     ]);
-    expect(cfg.compilerOptions.paths["@intentius/chant-lexicon-terraform/*"]).toEqual(["lexicons/terraform/src/*"]);
+    expect(cfg.compilerOptions.paths["@intentius/chant-lexicon-terraform/*"]).toEqual(["./lexicons/terraform/src/*"]);
     // Existing entries untouched
     expect(cfg.compilerOptions.paths["@intentius/chant-lexicon-aws"]).toEqual(["lexicons/aws/src/index.ts"]);
     expect(cfg.compilerOptions.moduleResolution).toBe("node");
@@ -462,3 +473,42 @@ describe("insertPrepackAfterEach", () => {
     ]);
   });
 });
+
+describe("smoke lists and publish.yml reporting (#3227)", () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = makeTempDir();
+    writeFixtureRepo(root);
+  });
+
+  afterEach(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test("patchLexiconList appends once and keeps the trailing newline", () => {
+    const file = join(root, "test/smoke-npm-lexicons.txt");
+    writeFileSync(file, "aws\nk8s");
+    expect(patchLexiconList(file, "sql").patched).toBe(true);
+    expect(readFileSync(file, "utf-8")).toBe("aws\nk8s\nsql\n");
+    expect(patchLexiconList(file, "sql").patched).toBe(false);
+    expect(readFileSync(file, "utf-8")).toBe("aws\nk8s\nsql\n");
+  });
+
+  test("a Dockerfile that reads the list file points at it instead of claiming coverage", () => {
+    const file = join(root, "test/Dockerfile.smoke-npm");
+    writeFileSync(file, "RUN LEXICONS=$(cat /app/test/smoke-npm-lexicons.txt) && \\\n    for lex in $LEXICONS; do :; done\n");
+    const result = patchDockerfile(file, "sql");
+    expect(result.patched).toBe(false);
+    expect(result.reason).toContain("test/smoke-npm-lexicons.txt");
+    expect(result.reason).not.toContain("already covers");
+  });
+
+  test("publish.yml with no per-lexicon prepack lines says nothing needs patching", () => {
+    writeFileSync(join(root, ".github/workflows/publish.yml"), "name: publish\njobs:\n  test:\n    steps:\n      - run: bash scripts/publish-verify-ci.sh\n");
+    const result = onboardCommand({ name: "sql", root });
+    const line = result.skipped.find((s) => s.startsWith("publish.yml:"));
+    expect(line).toContain("nothing to patch");
+    expect(line).toContain("scripts/ci-lexicon-artifacts.sh");
+  });
+});

package/src/cli/commands/onboard.ts

@@ -117,6 +117,10 @@ function patchRootPackageJson(root: string, name: string): PatchResult {
  * The whole-repo typecheck runs with `moduleResolution: node`, which never
  * reads package exports maps, so every lexicon needs a bare + subpath
  * mapping here or an example importing the package fails to resolve.
+ *
+ * Entries are `./`-prefixed like every other entry (#3227): with no `baseUrl`
+ * (removed in #3205) a bare `lexicons/...` path is invalid and tsx's tsconfig
+ * loader throws on it for every run in the repo.
  */
 export function patchRootTsconfigPaths(root: string, name: string): PatchResult {
   const tsconfigPath = join(root, "tsconfig.json");
@@ -128,8 +132,8 @@ export function patchRootTsconfigPaths(root: string, name: string): PatchResult
 
   const bare = `@intentius/chant-lexicon-${name}`;
   const wanted: Record<string, string[]> = {
-    [bare]: [`lexicons/${name}/src/index.ts`],
-    [`${bare}/*`]: [`lexicons/${name}/src/*`],
+    [bare]: [`./lexicons/${name}/src/index.ts`],
+    [`${bare}/*`]: [`./lexicons/${name}/src/*`],
   };
 
   let changed = false;
@@ -297,7 +301,15 @@ function patchPublishWorkflow(root: string, name: string): PatchResult {
   }
 
   if (!insertPrepackAfterEach(lines, name)) {
-    return { patched: false, reason: "no prepack line found to anchor on" };
+    // #3227 — not a failure and not "covered by a prepack line": publish.yml
+    // carries no per-lexicon lines. The run builds every lexicon through
+    // scripts/ci-lexicon-artifacts.sh and publishes through
+    // scripts/publish-packages.sh, both of which enumerate the workspace.
+    return {
+      patched: false,
+      reason:
+        "nothing to patch: it has no per-lexicon prepack lines; scripts/ci-lexicon-artifacts.sh and scripts/publish-packages.sh enumerate the workspace",
+    };
   }
   writeFileSync(filePath, lines.join("\n"));
   return { patched: true };
@@ -321,6 +333,12 @@ export function patchDockerfile(filePath: string, name: string): PatchResult {
 
   const changed = addToLexiconLoops(lines, name) || insertPrepackAfterEach(lines, name);
   if (!changed) {
+    // #3227 — the smoke-npm and smoke-e2e images read their lexicon list from
+    // a file. Point at it instead of reporting a missing anchor.
+    const listFile = lines.join("\n").match(/test\/(smoke-[\w-]+-lexicons\.txt)/)?.[1];
+    if (listFile) {
+      return { patched: false, reason: `reads its lexicon list from test/${listFile}, not from the Dockerfile` };
+    }
     return { patched: false, reason: "no lexicon loop or prepack line found to anchor on" };
   }
 
@@ -328,6 +346,22 @@ export function patchDockerfile(filePath: string, name: string): PatchResult {
   return { patched: true };
 }
 
+/**
+ * Append a lexicon to a one-name-per-line list file (test/smoke-npm-lexicons.txt).
+ * Idempotent; keeps the file's trailing newline.
+ */
+export function patchLexiconList(filePath: string, name: string): PatchResult {
+  const rel = filePath.split("/").slice(-2).join("/");
+  if (!existsSync(filePath)) return { patched: false, reason: `${rel} not found` };
+  const content = readFileSync(filePath, "utf-8");
+  if (content.split("\n").some((l) => l.trim() === name)) {
+    return { patched: false, reason: `${name} already in ${rel}` };
+  }
+  const sep = content === "" || content.endsWith("\n") ? "" : "\n";
+  writeFileSync(filePath, `${content}${sep}${name}\n`);
+  return { patched: true };
+}
+
 /**
  * Execute the onboard command — patches monorepo infrastructure for a new lexicon.
  */
@@ -375,6 +409,20 @@ export function onboardCommand(options: OnboardOptions): OnboardResult {
     patchDockerfile(join(root, "test/Dockerfile.smoke-npm"), options.name),
   );
 
+  // 6. Smoke image lexicon lists (#3227). The npm smoke packs every lexicon.
+  //    The e2e list is opt-in: it names the lexicons an example uses plus
+  //    their dependencies, so onboard leaves it alone and says so.
+  record(
+    "smoke-npm-lexicons.txt",
+    "lexicon list",
+    patchLexiconList(join(root, "test/smoke-npm-lexicons.txt"), options.name),
+  );
+  if (existsSync(join(root, "test/smoke-e2e-lexicons.txt"))) {
+    skipped.push(
+      `smoke-e2e-lexicons.txt: not patched; it lists only lexicons an e2e example uses (and their dependencies). Add ${options.name} to test/smoke-e2e-lexicons.txt when an example needs it`,
+    );
+  }
+
   return { success: true, patched, skipped, verbose: options.verbose };
 }
 
@@ -396,7 +444,7 @@ export async function printOnboardResult(result: OnboardResult, name: string): P
 
   if (result.skipped.length > 0) {
     console.log("");
-    console.log("Skipped (already covered):");
+    console.log("Not patched (already covered, or nothing to patch):");
     for (const s of result.skipped) {
       console.log(`  ${s}`);
     }