@intentius/chant 0.100.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

@@ -6,7 +6,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import type { LexiconPlugin, ExportedTemplate, ResourceSelector } from "../../lexicon";
 import type { TypeScriptGenerator } from "../../import/generator";
-import type { TemplateIR } from "../../import/parser";
+import type { TemplateIR, ParseContext } from "../../import/parser";
+import type { EmbeddedContentImporter } from "../../import/embedded";
 
 const generator: TypeScriptGenerator = {
   generate(ir: TemplateIR) {
@@ -105,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)],
@@ -151,4 +170,71 @@ describe("liveImportFromPlugins (#114)", () => {
     expect(result.success).toBe(true);
     expect(seenStack).toBe("loom-backend");
   });
+
+  // #2995: an export with `reparse` goes through the same embedded-content
+  // delegation as file import.
+  describe("embedded content (#2995)", () => {
+    const configText = "service:\n  pipelines: {}\n";
+
+    function hostExporter(): LexiconPlugin {
+      const parse = (context?: ParseContext): TemplateIR => {
+        const ref = context?.embedded?.resolve({
+          host: "fake",
+          hostType: "Fake::ConfigMap",
+          location: "ConfigMap cfg data[\"config.yaml\"]",
+          directory: "cfg",
+          text: configText,
+          expectedOwner: { lexicon: "owner", what: "an owner config" },
+        });
+        return {
+          resources: [{ logicalId: "cfg", type: "Fake::ConfigMap", properties: { data: ref ?? configText } }],
+          parameters: [],
+        };
+      };
+      return {
+        ...fakeExporter("fake", { resources: [], parameters: [] }),
+        async exportResources(): Promise<ExportedTemplate> {
+          return { ...parse(), reparse: (context) => parse(context) };
+        },
+      };
+    }
+
+    const importer: EmbeddedContentImporter = {
+      what: "an owner config",
+      matches: (c) => typeof c.document === "object" && c.document !== null && "service" in c.document,
+      import: () => ({
+        files: [{ path: "config.ts", content: "export const config = {};\n" }],
+        value: { bindings: [{ from: "config.ts", name: "config" }], shape: "single" },
+      }),
+    };
+    const owner: LexiconPlugin = {
+      name: "owner",
+      serializer: {} as never,
+      generate: async () => {},
+      validate: async () => {},
+      coverage: async () => {},
+      package: async () => {},
+      embeddedImporters: () => [importer],
+    };
+
+    test("a loaded owner imports the content and its modules are written beside the host's", async () => {
+      const result = await liveImportFromPlugins([hostExporter(), owner], { environment: "prod", output: outputDir, force: true });
+      expect(result.success).toBe(true);
+      expect(result.warnings).toEqual([]);
+      expect(result.generatedFiles).toEqual(["main.ts", "cfg/config.ts"]);
+      const main = await readFile(join(outputDir, "main.ts"), "utf-8");
+      expect(main).toContain('"$embedded"');
+      expect(main).toContain('"from":"cfg/config.ts"');
+      expect(await readFile(join(outputDir, "cfg/config.ts"), "utf-8")).toContain("export const config");
+    });
+
+    test("with no owner the content is kept as read, with a warning", async () => {
+      const result = await liveImportFromPlugins([hostExporter()], { environment: "prod", output: outputDir, force: true });
+      expect(result.success).toBe(true);
+      expect(result.generatedFiles).toEqual(["main.ts"]);
+      expect(result.warnings.join("\n")).toContain("no installed lexicon imports it");
+      const main = await readFile(join(outputDir, "main.ts"), "utf-8");
+      expect(main).toContain(JSON.stringify(configText));
+    });
+  });
 });

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

@@ -1,12 +1,13 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
 import { join, resolve, basename, dirname } from "path";
 import { formatSuccess, formatWarning, formatError } from "../format";
-import type { TemplateIR, ResourceIR, ParameterIR, TemplateParser } from "../../import/parser";
+import type { TemplateIR, ResourceIR, ParameterIR, ParseContext } from "../../import/parser";
 import type { GeneratedFile, TypeScriptGenerator } from "../../import/generator";
 import { listInstalledLexicons, loadPlugin, loadPlugins, resolveProjectLexicons } from "../plugins";
-import type { LexiconPlugin, ResourceSelector } from "../../lexicon";
+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,19 +432,20 @@ 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);
 }
 
 /**
  * The importers for the content a host's parser offered (#2962): those of the
- * project's lexicons, and of each installed lexicon whose `detectTemplate`
- * recognizes one of the offered documents. The recognizing is done with the
+ * plugins already loaded, of the project's lexicons, and of each installed
+ * lexicon whose `detectTemplate` recognizes one of the offered documents
+ * (#2995 adds the loaded ones). The recognizing is done with the
  * lexicon's light `/detect` module, so a lexicon is loaded in full only when
  * it may own something; one that fails to load is skipped.
  */
 async function embeddedImportersFor(
   offered: readonly EmbeddedContent[],
-  host: LexiconPlugin,
+  loaded: readonly LexiconPlugin[],
   projectDir: string,
 ): Promise<RegisteredEmbeddedImporter[]> {
   const documents = offered.map((c) => c.document).filter((d) => typeof d === "object" && d !== null);
@@ -446,7 +457,8 @@ async function embeddedImportersFor(
   } catch {
     projectNames = [];
   }
-  const candidates: string[] = [...projectNames];
+  // Plugins already loaded (the host, or live import's exporters) are asked too.
+  const candidates: string[] = [...new Set([...loaded.map((p) => p.name), ...projectNames])];
   for (const name of listInstalledLexicons(projectDir)) {
     if (candidates.includes(name)) continue;
     try {
@@ -471,7 +483,7 @@ async function embeddedImportersFor(
   for (const name of candidates) {
     let plugin: LexiconPlugin;
     try {
-      plugin = name === host.name ? host : await loadPlugin(name);
+      plugin = loaded.find((p) => p.name === name) ?? (await loadPlugin(name));
     } catch {
       continue;
     }
@@ -488,22 +500,24 @@ async function embeddedImportersFor(
 
 /**
  * Parse, resolving embedded content (#2962). A first parse with a probe
- * collects what the parser offers; when it offers anything, the owners'
- * importers are loaded and the content is parsed again with them. A parser
- * that offers nothing is parsed once, and nothing is loaded.
+ * collects what the parsers offer; when they offer anything, the owners'
+ * importers are loaded and each is parsed again with them, through one
+ * resolver so their directories stay distinct. A parse is a template
+ * parser over a file's content, or an export's `reparse` (#2995). Parsers
+ * that offer nothing are parsed once, and nothing is loaded. `loaded` are
+ * plugins already loaded, reused when one of them owns content.
  */
 async function parseWithEmbedded(
-  plugin: LexiconPlugin,
-  parser: TemplateParser,
-  content: string,
+  parses: ReadonlyArray<(context: ParseContext) => TemplateIR>,
+  loaded: readonly LexiconPlugin[],
   projectDir: string,
-): Promise<{ ir: TemplateIR; embedded?: EmbeddedImports }> {
+): Promise<{ irs: TemplateIR[]; embedded?: EmbeddedImports }> {
   const probe = new EmbeddedImports([], { quiet: true });
-  const ir = parser.parse(content, { embedded: probe });
-  if (probe.offered.length === 0) return { ir };
-  const importers = await embeddedImportersFor(probe.offered, plugin, projectDir);
+  const irs = parses.map((parse) => parse({ embedded: probe }));
+  if (probe.offered.length === 0) return { irs };
+  const importers = await embeddedImportersFor(probe.offered, loaded, projectDir);
   const embedded = new EmbeddedImports(importers);
-  return { ir: parser.parse(content, { embedded }), embedded };
+  return { irs: parses.map((parse) => parse({ embedded })), embedded };
 }
 
 /** The shared tail of every template import: parse → generate → write. */
@@ -516,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
@@ -530,12 +545,19 @@ 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();
-    ({ ir, embedded } = await parseWithEmbedded(plugin, parser, content, projectDir));
+    const parser = plugin.templateParser(resolved.options);
+    let irs: TemplateIR[];
+    ({ irs, embedded } = await parseWithEmbedded([(context) => parser.parse(content, context)], [plugin], projectDir));
+    ir = irs[0];
   } catch (err) {
     return {
       success: false,
@@ -701,6 +723,7 @@ export async function liveImportFromPlugins(
   options: LiveImportOptions,
 ): Promise<ImportResult> {
   const outputDir = resolve(options.output ?? "./infra/");
+  const projectDir = resolve(options.output ? dirname(options.output) : ".");
   const warnings: string[] = [];
 
   let exporters = plugins.filter((p) => p.exportResources && p.templateGenerator);
@@ -720,10 +743,10 @@ export async function liveImportFromPlugins(
   }
 
   // Collect IR from every exporter, tagging which lexicon produced output.
-  const irParts: TemplateIR[] = [];
+  let irParts: ExportedTemplate[] = [];
   let generatorLexicon: LexiconPlugin | undefined;
   for (const plugin of exporters) {
-    let ir: TemplateIR;
+    let ir: ExportedTemplate;
     try {
       ir = await plugin.exportResources!({
         environment: options.environment,
@@ -736,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;
@@ -754,6 +779,23 @@ export async function liveImportFromPlugins(
     warnings.push("Multiple lexicons exported resources; generated with the first. Use --lexicon to target one.");
   }
 
+  // Content embedded in exported resources goes to the lexicon that owns it,
+  // as in file import (#2995). An export without `reparse` keeps it as read.
+  let embedded: EmbeddedImports | undefined;
+  if (irParts.some((part) => part.reparse)) {
+    try {
+      const parses = irParts.map((part) => part.reparse ?? (() => part));
+      let irs: TemplateIR[];
+      ({ irs, embedded } = await parseWithEmbedded(parses, plugins, projectDir));
+      irParts = irs;
+    } catch (err) {
+      warnings.push(
+        `Embedded content is kept as written, because resolving it failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    if (embedded) warnings.push(...embedded.warnings);
+  }
+
   const ir = mergeIR(irParts);
   const generator = generatorLexicon.templateGenerator!();
 
@@ -761,8 +803,10 @@ export async function liveImportFromPlugins(
     mkdirSync(outputDir, { recursive: true });
   }
 
-  const { files, warnings: layoutWarnings } = generateOrganizedFiles(ir, generator);
+  const { files: hostFiles, warnings: layoutWarnings } = generateOrganizedFiles(ir, generator);
   warnings.push(...layoutWarnings);
+  // The owners' modules for embedded content, each in a directory of its own.
+  const files = [...hostFiles, ...(embedded?.files ?? [])];
   const generatedFiles: string[] = [];
   for (const file of files) {
     const filePath = join(outputDir, file.path);

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", () => {