@intentius/chant 0.97.0 → 0.98.0

package/dist/cli/commands/import.d.ts

@@ -9,6 +9,11 @@ export interface ImportOptions {
     output?: string;
     /** Force overwrite existing files */
     force?: boolean;
+    /**
+     * Lexicon whose parser handles the file (#2935). Skips detection and the
+     * JSON/YAML check: the raw content goes straight to that plugin's parser.
+     */
+    lexicon?: string;
 }
 /**
  * Import command result
@@ -22,9 +27,50 @@ export interface ImportResult {
     warnings: string[];
     /** Error message if failed */
     error?: string;
-    /** Detected lexicon */
+    /** The lexicon that handled the template */
     lexicon?: string;
+    /**
+     * True when `lexicon` was found by template detection, false or absent when
+     * it was named (`--lexicon`, `--kustomize`) (#2965).
+     */
+    detected?: boolean;
+}
+/**
+ * Parse template content for detection (#2935): JSON first, then YAML. A YAML
+ * file is split into documents with core's `splitYAMLDocuments` (the k8s
+ * parser splits the same way), and each document is parsed on its own, so
+ * detection sees the same per-document objects the plugin's parser will. A
+ * document whose top level is a list parses as that list (#2965). JSON yields
+ * one document, the parsed value, exactly as before. Returns undefined when
+ * the content is neither: core's YAML reader is lenient and turns unparseable
+ * text into an empty mapping, so a file with no non-empty document is
+ * rejected.
+ */
+export declare function parseTemplateDocuments(content: string): unknown[] | undefined;
+/** The outcome of template detection (#2965). */
+export interface TemplateDetection {
+    /** The plugin that handles the template. */
+    plugin: LexiconPlugin;
+    /**
+     * Where it came from: one of the project's lexicons, or an installed
+     * lexicon package tried because none of the project's matched.
+     */
+    source: "project" | "installed";
+    /** Other installed lexicons that also recognized the deciding document. */
+    alsoMatched: string[];
 }
+/**
+ * Detect which lexicon handles a template (#2965). The project's lexicons
+ * (from chant.config, or the lexicons its source imports) are asked first, so
+ * inside a project nothing changes when one of them matches. When none does,
+ * or there is no project, every installed `@intentius/chant-lexicon-*`
+ * package that is not already a project lexicon is asked, in name order,
+ * and one with a `templateParser` is preferred over one without.
+ * Installed lexicons are loaded one at a time and without `init()`; one that
+ * fails to load is skipped. The chosen plugin is initialized before it is
+ * returned.
+ */
+export declare function detectTemplateLexicon(documents: unknown[], projectDir: string): Promise<TemplateDetection | undefined>;
 /**
  * Execute the import command
  */
@@ -33,8 +79,9 @@ export declare function importCommand(options: ImportOptions): Promise<ImportRes
  * Import from an in-memory template string through a KNOWN plugin — no
  * detection, no JSON assumption (#1548). This is the seam
  * `chant import --kustomize <dir>` drives with `kustomize build` output
- * through the k8s plugin's YAML parser; `importCommand` above is the same
- * pipeline behind file reading + JSON detection.
+ * through the k8s plugin's YAML parser, and `chant import <file> --lexicon
+ * <name>` drives with the file's content (#2935); `importCommand` above is
+ * the same pipeline behind file reading + JSON/YAML detection.
  */
 export interface ContentImportOptions {
     /** The raw template content (YAML or JSON — the plugin's parser decides). */

package/dist/cli/commands/import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/import.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,4BAA4B;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,+BAA+B;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,sBAAsB;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAmID;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CA4EjF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,YAAY,CAAC,CA2B5F;AA6ED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB;;uBAEmB;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,+EAA+E;IAC/E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAkBD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAatF;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,OAAO,GAAG,QAAQ,CAAC,EACpD,MAAM,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,GAC3C,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAezD;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,aAAa,EAAE,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,YAAY,CAAC,CAoFvB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAsB5D"}
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/import.ts"],"names":[],"mappings":"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"}

package/dist/cli/handlers/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/misc.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA8ClD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqGnE;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAuClE;AAED,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8CtE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAsIpE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAKpE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBpE"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/misc.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AA8ClD,wBAAsB,QAAQ,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAqGnE;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAuClE;AAED,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA8CtE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAyIpE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAKpE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBpE"}

package/dist/cli/handlers/operator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/operator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"operator.d.ts","sourceRoot":"","sources":["../../../src/cli/handlers/operator.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE9F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAC3F,OAAO,EACuE,KAAK,UAAU,EAC5F,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEuC,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAChG,MAAM,wBAAwB,CAAC;AAKhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAqFlD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA+EtE;AAID;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA4H7E;AAaD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAW9B;AAgED,mNAAmN;AACnN,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAkG5E;AAID,8EAA8E;AAC9E,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE;AAC9E,yGAAyG;GACvG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC;AAE5D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;;;;OAMG;IACH,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9D;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,EACpC,IAAI,GAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GACvE,OAAO,CAAC,iBAAiB,CAAC,CAwD5B;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgDzE;AAuDD,wBAAsB,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CA+ErE;AAED,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,GAC1C;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC;AAElB;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAmM9B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,oBAAoB,EAC9B,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,oBAAoB,EAAE,EAC7B,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,MAAM,EAAE,CAiCV"}

package/dist/cli/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAuG9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAyhBpD;AA6rBD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EAoIvC,CAAC;AA4KF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":";AAMA,OAAO,EAAkB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAuG9E;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAyhBpD;AA+rBD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuBzE;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,UAAU,EAoIvC,CAAC;AA4KF;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB5E"}

package/dist/cli/mcp/tools/import.d.ts

@@ -15,6 +15,10 @@ export declare const importTool: {
                 type: string;
                 description: string;
             };
+            lexicon: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/cli/mcp/tools/import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../../src/cli/mcp/tools/import.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;CAiBtB,CAAC;AAEF;;GAEG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBpF"}
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../../src/cli/mcp/tools/import.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CAqBtB,CAAC;AAEF;;GAEG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBpF"}

package/dist/cli/plugins.d.ts

@@ -20,6 +20,16 @@ export declare function recordProjectLexicons(dir: string): StaticLexiconRead;
  * LexiconPlugin export. Falls back to wrapping a raw Serializer export.
  */
 export declare function loadPlugin(lexiconName: string): Promise<LexiconPlugin>;
+/**
+ * The names of the lexicon packages installed where {@link loadPlugin} can
+ * load them (#2965), sorted. `loadPlugin` imports
+ * `@intentius/chant-lexicon-<name>` from chant's own install and then from the
+ * project (`importLexiconPackage`), so this lists the `@intentius` scope of
+ * every `node_modules` directory Node would search from either place: each
+ * ancestor of chant's own module and each ancestor of `projectDir`. A name
+ * being listed does not promise it loads; the caller still handles a failure.
+ */
+export declare function listInstalledLexicons(projectDir?: string): string[];
 /**
  * The installed version of each named lexicon package (chant #1442).
  *

package/dist/cli/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/cli/plugins.ts"],"names":[],"mappings":"AACA,OAAO,EAAqC,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAI7D,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAKjE;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAIpE;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA8C5E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0C9F;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,EAC7C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,GAClB,KAAK,CAAC,OAAO,YAAY,EAAE,oBAAoB,CAAC,CAMlD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,EAC7C,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC,CAAC;CAC5F,GACA,KAAK,CAAC,OAAO,gBAAgB,EAAE,gBAAgB,CAAC,CAgBlD;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA2BlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnF"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../src/cli/plugins.ts"],"names":[],"mappings":"AACA,OAAO,EAAqC,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAK7D,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAKjE;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAIpE;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CA8C5E;AAID;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,GAAE,MAAsB,GAAG,MAAM,EAAE,CAyBlF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0C9F;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,EAC7C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,WAAW,EAAE,MAAM,GAClB,KAAK,CAAC,OAAO,YAAY,EAAE,oBAAoB,CAAC,CAMlD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,aAAa,EAAE,GAAG,SAAS,EAC7C,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC,CAAC;CAC5F,GACA,KAAK,CAAC,OAAO,gBAAgB,EAAE,gBAAgB,CAAC,CAgBlD;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA2BlF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnF"}

package/dist/yaml.d.ts

@@ -19,6 +19,22 @@ export interface ParseResult {
  * handles the subset of YAML commonly found in CI configuration files.
  */
 export declare function parseYAML(content: string): Record<string, unknown>;
+/**
+ * Parse one YAML (or JSON) document whose top level may be a sequence
+ * (#2965). {@link parseYAML} reads only a top-level mapping and returns `{}`
+ * for a file like `- a\n- b`; its callers rely on getting a mapping back, so
+ * it keeps doing that. This returns the list instead, and otherwise defers to
+ * `parseYAML`.
+ */
+export declare function parseYAMLDocument(content: string): unknown;
+/**
+ * Split a YAML stream into its documents (#2965). A line holding only `---`
+ * starts a document and a line holding only `...` ends one; either may carry
+ * a trailing `# comment`. Documents that are empty or hold only comments are
+ * dropped. The text of each document is returned unparsed, with `\r\n`
+ * normalized to `\n`.
+ */
+export declare function splitYAMLDocuments(content: string): string[];
 /**
  * Parse indentation-based YAML lines into a key-value object.
  */

package/dist/yaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA0BH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgH/D;AAMD,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAuBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASlE;AAiFD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CA8Eb;AA0GD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAqGb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAwBlD"}
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA0BH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgH/D;AAMD,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAuBD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASlE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAa1D;AAKD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAc5D;AAiFD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CA8Eb;AA0GD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAqGb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAwBlD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.97.0",
+  "version": "0.98.0",
   "description": "Declarative infrastructure-as-code toolkit — TypeScript on Node.js",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",

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

@@ -0,0 +1,70 @@
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { LexiconPlugin } from "../../lexicon";
+import { importCommand, importFromContent } from "./import";
+
+// A lexicon that recognizes a template but has no templateParser, as grafana
+// does today (#2940). Import must say it cannot import, not throw
+// "plugin.templateParser is not a function".
+const { detectOnly } = vi.hoisted(() => ({
+  detectOnly: {
+    name: "detect-only",
+    detectTemplate: (data: unknown) =>
+      typeof data === "object" && data !== null && "detectOnlyMarker" in data,
+  } as unknown as LexiconPlugin,
+}));
+
+vi.mock("../plugins", () => ({
+  resolveProjectLexicons: async () => ["detect-only"],
+  loadPlugins: async (names: string[]) => names.map(() => detectOnly),
+}));
+
+const EXPECTED = 'lexicon "detect-only" does not support template import';
+
+describe("import through a lexicon with detectTemplate and no templateParser (#2940)", () => {
+  let testDir: string;
+  let templatePath: string;
+  let outputDir: string;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-import-no-parser-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+    templatePath = join(testDir, "dashboard.json");
+    outputDir = join(testDir, "out");
+    await writeFile(templatePath, JSON.stringify({ detectOnlyMarker: true, panels: [] }));
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("file import with detection fails cleanly", async () => {
+    const result = await importCommand({ templatePath, output: outputDir });
+    expect(result.success).toBe(false);
+    expect(result.error).toBe(EXPECTED);
+    expect(result.error).not.toContain("is not a function");
+    expect(result.lexicon).toBe("detect-only");
+    expect(existsSync(outputDir)).toBe(false);
+  });
+
+  test("file import with --lexicon fails cleanly", async () => {
+    const result = await importCommand({ templatePath, output: outputDir, lexicon: "detect-only" });
+    expect(result.success).toBe(false);
+    expect(result.error).toBe(EXPECTED);
+    expect(existsSync(outputDir)).toBe(false);
+  });
+
+  test("content import fails cleanly", async () => {
+    const result = await importFromContent({
+      content: JSON.stringify({ detectOnlyMarker: true }),
+      lexicon: "detect-only",
+      output: outputDir,
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toBe(EXPECTED);
+    expect(existsSync(outputDir)).toBe(false);
+  });
+});

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

@@ -1,5 +1,12 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import { importCommand, type ImportOptions } from "./import";
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
+import {
+  detectTemplateLexicon,
+  importCommand,
+  parseTemplateDocuments,
+  printImportResult,
+  type ImportOptions,
+} from "./import";
+import { listInstalledLexicons } from "../plugins";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -377,3 +384,253 @@ describe("importCommand", () => {
     }
   });
 });
+
+// #2935 — YAML templates reach detection and the plugin's parser instead of
+// failing JSON.parse, and `--lexicon` skips detection.
+describe("importCommand with YAML templates", () => {
+  let testDir: string;
+  let outputDir: string;
+
+  const configMap = `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-config
+data:
+  LOG_LEVEL: info
+`;
+
+  const deployment = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: web
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: web
+  template:
+    metadata:
+      labels:
+        app: web
+    spec:
+      containers:
+        - name: web
+          image: nginx:1.27
+`;
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-import-yaml-test-${Date.now()}-${Math.random()}`);
+    outputDir = join(testDir, "output");
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  /** A project that declares the k8s lexicon, so detection can find it. */
+  async function k8sProject(): Promise<void> {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ lexicons: ["k8s"] }));
+  }
+
+  function generated(files: string[]): string {
+    return files.map((f) => readFileSync(join(outputDir, f), "utf-8")).join("\n");
+  }
+
+  test("detects and imports a single-document k8s manifest", async () => {
+    await k8sProject();
+    const templatePath = join(testDir, "manifest.yaml");
+    await writeFile(templatePath, configMap);
+
+    const result = await importCommand({ templatePath, output: outputDir });
+
+    expect(result.error).toBeUndefined();
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("k8s");
+    expect(generated(result.generatedFiles)).toContain("ConfigMap");
+  }, 30000);
+
+  test("detects and imports a multi-document k8s manifest", async () => {
+    await k8sProject();
+    const templatePath = join(testDir, "manifests.yaml");
+    await writeFile(templatePath, `# app manifests\n---\n${configMap}---\n${deployment}`);
+
+    const result = await importCommand({ templatePath, output: outputDir });
+
+    expect(result.error).toBeUndefined();
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("k8s");
+    const code = generated(result.generatedFiles);
+    expect(code).toContain("ConfigMap");
+    expect(code).toContain("Deployment");
+  }, 30000);
+
+  test("--lexicon imports without detection", async () => {
+    const templatePath = join(testDir, "manifest.yaml");
+    await writeFile(templatePath, configMap);
+
+    const result = await importCommand({ templatePath, output: outputDir, lexicon: "k8s" });
+
+    expect(result.error).toBeUndefined();
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("k8s");
+    expect(result.detected).toBeFalsy();
+    expect(generated(result.generatedFiles)).toContain("ConfigMap");
+  }, 30000);
+
+  // #2965 — with no chant.config and no source imports, every installed
+  // lexicon is tried, not only aws.
+  test("detects a k8s manifest outside a project from the installed lexicons", async () => {
+    const templatePath = join(testDir, "manifest.yaml");
+    await writeFile(templatePath, `--- # config\n${configMap}...\n`);
+
+    const result = await importCommand({ templatePath, output: outputDir });
+
+    expect(result.error).toBeUndefined();
+    expect(result.success).toBe(true);
+    expect(result.lexicon).toBe("k8s");
+    expect(result.detected).toBe(true);
+    expect(generated(result.generatedFiles)).toContain("ConfigMap");
+  }, 60000);
+
+  test("--lexicon with an unknown lexicon fails", async () => {
+    const templatePath = join(testDir, "manifest.yaml");
+    await writeFile(templatePath, configMap);
+
+    const result = await importCommand({ templatePath, output: outputDir, lexicon: "no-such-lexicon" });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("no-such-lexicon");
+  });
+
+  test("content that is neither JSON nor YAML names both formats", async () => {
+    const templatePath = join(testDir, "notes.txt");
+    await writeFile(templatePath, "this is not a template\n{ nor is this");
+
+    const result = await importCommand({ templatePath, output: outputDir });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("JSON");
+    expect(result.error).toContain("YAML");
+  });
+});
+
+// #2965 — detection outside a project, and inside one when the project's
+// lexicons don't match.
+describe("detectTemplateLexicon", () => {
+  let testDir: string;
+
+  const collector = {
+    receivers: { otlp: { protocols: { grpc: {} } } },
+    exporters: { debug: {} },
+    service: { pipelines: { traces: { receivers: ["otlp"], exporters: ["debug"] } } },
+  };
+
+  beforeEach(async () => {
+    testDir = join(tmpdir(), `chant-import-detect-test-${Date.now()}-${Math.random()}`);
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("an empty directory detects an otel collector config from the installed lexicons", async () => {
+    const detection = await detectTemplateLexicon([collector], testDir);
+    expect(detection?.plugin.name).toBe("otel");
+    expect(detection?.source).toBe("installed");
+  }, 60000);
+
+  test("a project lexicon that matches decides", async () => {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ lexicons: ["aws"] }));
+    const detection = await detectTemplateLexicon([{ AWSTemplateFormatVersion: "2010-09-09", Resources: {} }], testDir);
+    expect(detection?.plugin.name).toBe("aws");
+    expect(detection?.source).toBe("project");
+  }, 60000);
+
+  test("inside a project, installed lexicons are tried when the project's don't match", async () => {
+    await writeFile(join(testDir, "chant.config.json"), JSON.stringify({ lexicons: ["aws"] }));
+    const detection = await detectTemplateLexicon([collector], testDir);
+    expect(detection?.plugin.name).toBe("otel");
+    expect(detection?.source).toBe("installed");
+  }, 60000);
+
+  test("names the other installed lexicons that also recognized the template", async () => {
+    // github and forgejo both read a GitHub-Actions-shaped workflow.
+    const workflow = { on: { push: {} }, jobs: { build: { "runs-on": "ubuntu-latest", steps: [] } } };
+    const detection = await detectTemplateLexicon([workflow], testDir);
+    expect(detection).toBeDefined();
+    // github has a template parser and forgejo does not, so github is chosen.
+    expect(detection!.plugin.name).toBe("github");
+    expect(detection!.alsoMatched).toContain("forgejo");
+  }, 60000);
+
+  test("returns undefined when no installed lexicon recognizes the template", async () => {
+    expect(await detectTemplateLexicon([{ version: "1.0", unknownField: {} }], testDir)).toBeUndefined();
+  }, 60000);
+});
+
+describe("listInstalledLexicons", () => {
+  test("lists the @intentius/chant-lexicon-* packages installed alongside chant", () => {
+    const names = listInstalledLexicons(tmpdir());
+    expect(names).toContain("aws");
+    expect(names).toContain("k8s");
+    expect(names).toContain("otel");
+    expect(names).toEqual([...names].sort());
+  });
+});
+
+describe("printImportResult", () => {
+  function printed(result: Parameters<typeof printImportResult>[0]): string {
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    try {
+      printImportResult(result);
+      return log.mock.calls.map((c) => c.join(" ")).join("\n");
+    } finally {
+      log.mockRestore();
+    }
+  }
+
+  test("says Detected lexicon when the lexicon was detected", () => {
+    expect(printed({ success: true, generatedFiles: [], warnings: [], lexicon: "k8s", detected: true })).toContain(
+      "Detected lexicon: k8s",
+    );
+  });
+
+  test("says Lexicon when the lexicon was named", () => {
+    const out = printed({ success: true, generatedFiles: [], warnings: [], lexicon: "k8s" });
+    expect(out).toContain("Lexicon: k8s");
+    expect(out).not.toContain("Detected");
+  });
+});
+
+describe("parseTemplateDocuments", () => {
+  test("JSON yields the parsed value as one document", () => {
+    expect(parseTemplateDocuments('{"a": 1}')).toEqual([{ a: 1 }]);
+    expect(parseTemplateDocuments("[1, 2]")).toEqual([[1, 2]]);
+  });
+
+  test("YAML splits on document separators and skips empty or comment-only documents", () => {
+    const docs = parseTemplateDocuments("---\n# only a comment\n---\na: 1\n---\nb: two\n---\n");
+    expect(docs).toEqual([{ a: 1 }, { b: "two" }]);
+  });
+
+  test("a top-level YAML list parses as a list (#2965)", () => {
+    expect(parseTemplateDocuments("- name: one\n  expr: up\n- name: two\n")).toEqual([
+      [{ name: "one", expr: "up" }, { name: "two" }],
+    ]);
+  });
+
+  test("commented separators and document ends split documents (#2965)", () => {
+    expect(parseTemplateDocuments("--- # first\na: 1\n...\n--- # second\nb: two\n...\n")).toEqual([
+      { a: 1 },
+      { b: "two" },
+    ]);
+  });
+
+  test("returns undefined for content that is neither", () => {
+    expect(parseTemplateDocuments("")).toBeUndefined();
+    expect(parseTemplateDocuments("just some words")).toBeUndefined();
+    expect(parseTemplateDocuments("{ broken json")).toBeUndefined();
+  });
+});

package/src/cli/commands/import.ts

@@ -3,8 +3,9 @@ import { join, resolve, basename, dirname } from "path";
 import { formatSuccess, formatWarning, formatError } from "../format";
 import type { TemplateIR, ResourceIR, ParameterIR, TemplateParser } from "../../import/parser";
 import type { GeneratedFile, TypeScriptGenerator } from "../../import/generator";
-import { loadPlugins, resolveProjectLexicons } from "../plugins";
+import { listInstalledLexicons, loadPlugin, loadPlugins, resolveProjectLexicons } from "../plugins";
 import type { LexiconPlugin, ResourceSelector } from "../../lexicon";
+import { parseYAMLDocument, splitYAMLDocuments } from "../../yaml";
 
 /**
  * Import command options
@@ -16,6 +17,11 @@ export interface ImportOptions {
   output?: string;
   /** Force overwrite existing files */
   force?: boolean;
+  /**
+   * Lexicon whose parser handles the file (#2935). Skips detection and the
+   * JSON/YAML check: the raw content goes straight to that plugin's parser.
+   */
+  lexicon?: string;
 }
 
 /**
@@ -30,8 +36,13 @@ export interface ImportResult {
   warnings: string[];
   /** Error message if failed */
   error?: string;
-  /** Detected lexicon */
+  /** The lexicon that handled the template */
   lexicon?: string;
+  /**
+   * True when `lexicon` was found by template detection, false or absent when
+   * it was named (`--lexicon`, `--kustomize`) (#2965).
+   */
+  detected?: boolean;
 }
 
 /**
@@ -40,18 +51,117 @@ export interface ImportResult {
 type ResourceCategory = "storage" | "compute" | "network" | "other";
 
 /**
- * Detect which plugin handles a template by asking each plugin.
- * @param data - Parsed JSON object
- * @param plugins - Loaded lexicon plugins
- * @returns The matching plugin, or undefined if none match
+ * Parse template content for detection (#2935): JSON first, then YAML. A YAML
+ * file is split into documents with core's `splitYAMLDocuments` (the k8s
+ * parser splits the same way), and each document is parsed on its own, so
+ * detection sees the same per-document objects the plugin's parser will. A
+ * document whose top level is a list parses as that list (#2965). JSON yields
+ * one document, the parsed value, exactly as before. Returns undefined when
+ * the content is neither: core's YAML reader is lenient and turns unparseable
+ * text into an empty mapping, so a file with no non-empty document is
+ * rejected.
+ */
+export function parseTemplateDocuments(content: string): unknown[] | undefined {
+  try {
+    return [JSON.parse(content)];
+  } catch {
+    // Not JSON: try YAML.
+  }
+  const documents: unknown[] = [];
+  for (const chunk of splitYAMLDocuments(content)) {
+    let doc: unknown;
+    try {
+      doc = parseYAMLDocument(chunk);
+    } catch {
+      continue;
+    }
+    if (typeof doc === "object" && doc !== null && Object.keys(doc).length > 0) {
+      documents.push(doc);
+    }
+  }
+  return documents.length > 0 ? documents : undefined;
+}
+
+/** The outcome of template detection (#2965). */
+export interface TemplateDetection {
+  /** The plugin that handles the template. */
+  plugin: LexiconPlugin;
+  /**
+   * Where it came from: one of the project's lexicons, or an installed
+   * lexicon package tried because none of the project's matched.
+   */
+  source: "project" | "installed";
+  /** Other installed lexicons that also recognized the deciding document. */
+  alsoMatched: string[];
+}
+
+/**
+ * Find the plugins that recognize a template. Documents are tried in file
+ * order and the first one some plugin recognizes decides; every plugin that
+ * recognizes that document is returned, in the order given. For a JSON
+ * template there is exactly one document, so this is the old behaviour.
+ */
+function matchingPlugins(documents: unknown[], plugins: LexiconPlugin[]): LexiconPlugin[] {
+  for (const data of documents) {
+    const matches = plugins.filter((plugin) => {
+      try {
+        return plugin.detectTemplate?.(data) === true;
+      } catch {
+        return false;
+      }
+    });
+    if (matches.length > 0) return matches;
+  }
+  return [];
+}
+
+/**
+ * Detect which lexicon handles a template (#2965). The project's lexicons
+ * (from chant.config, or the lexicons its source imports) are asked first, so
+ * inside a project nothing changes when one of them matches. When none does,
+ * or there is no project, every installed `@intentius/chant-lexicon-*`
+ * package that is not already a project lexicon is asked, in name order,
+ * and one with a `templateParser` is preferred over one without.
+ * Installed lexicons are loaded one at a time and without `init()`; one that
+ * fails to load is skipped. The chosen plugin is initialized before it is
+ * returned.
  */
-function detectPlugin(data: unknown, plugins: LexiconPlugin[]): LexiconPlugin | undefined {
-  for (const plugin of plugins) {
-    if (plugin.detectTemplate?.(data)) {
-      return plugin;
+export async function detectTemplateLexicon(
+  documents: unknown[],
+  projectDir: string,
+): Promise<TemplateDetection | undefined> {
+  let projectNames: string[] = [];
+  let projectPlugins: LexiconPlugin[] = [];
+  try {
+    projectNames = await resolveProjectLexicons(projectDir);
+    projectPlugins = await loadPlugins(projectNames);
+  } catch {
+    projectPlugins = [];
+  }
+
+  const [fromProject] = matchingPlugins(documents, projectPlugins);
+  if (fromProject) return { plugin: fromProject, source: "project", alsoMatched: [] };
+
+  const installed: LexiconPlugin[] = [];
+  for (const name of listInstalledLexicons(projectDir)) {
+    if (projectNames.includes(name)) continue;
+    try {
+      installed.push(await loadPlugin(name));
+    } catch {
+      // Not loadable from here: it cannot handle the template either.
     }
   }
-  return undefined;
+
+  // A lexicon that can import the template goes ahead of one that only
+  // recognizes it (github and forgejo both read an Actions workflow).
+  const matches = matchingPlugins(documents, installed);
+  const [plugin, ...others] = [
+    ...matches.filter((p) => p.templateParser),
+    ...matches.filter((p) => !p.templateParser),
+  ];
+  if (!plugin) return undefined;
+  await plugin.init?.();
+  return { plugin, source: "installed", alsoMatched: others.map((p) => p.name) };
 }
 
 /**
@@ -195,61 +305,63 @@ export async function importCommand(options: ImportOptions): Promise<ImportResul
     };
   }
 
-  // Load plugins and detect lexicon
-  let data: unknown;
-  try {
-    data = JSON.parse(content);
-  } catch {
+  // `--lexicon <name>` names the plugin, so there is nothing to detect and no
+  // format to check: the plugin's parser decides what it accepts (#2935).
+  if (options.lexicon) {
+    return importFromContent({
+      content,
+      lexicon: options.lexicon,
+      output: options.output,
+      force: options.force,
+    });
+  }
+
+  // Parse for detection: JSON, falling back to YAML.
+  const documents = parseTemplateDocuments(content);
+  if (!documents) {
     return {
       success: false,
       generatedFiles: [],
       warnings: [],
-      error: "Template is not valid JSON.",
+      error: "Template is neither valid JSON nor YAML.",
     };
   }
 
-  // Load plugins — resolve from the output directory (or CWD) so that
-  // project config is found relative to where the user is working, not
-  // an arbitrary monorepo root.
+  // Detect from the output directory (or CWD) so that project config is
+  // found relative to where the user is working, not an arbitrary monorepo
+  // root.
   const projectDir = resolve(options.output ? dirname(options.output) : ".");
-  let plugins: LexiconPlugin[];
-  try {
-    const lexiconNames = await resolveProjectLexicons(projectDir);
-    plugins = await loadPlugins(lexiconNames);
-  } catch {
-    plugins = [];
-  }
-
-  // If no plugins resolved (no config, no source files), try common lexicons
-  if (plugins.length === 0) {
-    try {
-      plugins = await loadPlugins(["aws"]);
-    } catch {
-      // No lexicons available at all
-    }
-  }
-
-  const plugin = detectPlugin(data, plugins);
-  if (!plugin) {
+  const detection = await detectTemplateLexicon(documents, projectDir);
+  if (!detection) {
     return {
       success: false,
       generatedFiles: [],
       warnings: [],
-      error: "Could not detect template lexicon. No installed lexicon recognizes this template.",
+      error:
+        "Could not detect template lexicon. No installed lexicon recognizes this template. " +
+        "Pass --lexicon <name> to import it with a specific lexicon.",
     };
   }
 
-  const lexicon = plugin.name;
+  const { plugin } = detection;
+  if (detection.alsoMatched.length > 0) {
+    warnings.push(
+      `The template is also recognized by ${detection.alsoMatched.join(", ")}. ` +
+        `Importing with ${plugin.name}; pass --lexicon <name> to choose another.`,
+    );
+  }
 
-  return parseAndWrite(plugin, content, outputDir, options.force, warnings, generatedFiles, lexicon);
+  const result = parseAndWrite(plugin, content, outputDir, options.force, warnings, generatedFiles, plugin.name);
+  return { ...result, detected: true };
 }
 
 /**
  * Import from an in-memory template string through a KNOWN plugin — no
  * detection, no JSON assumption (#1548). This is the seam
  * `chant import --kustomize <dir>` drives with `kustomize build` output
- * through the k8s plugin's YAML parser; `importCommand` above is the same
- * pipeline behind file reading + JSON detection.
+ * through the k8s plugin's YAML parser, and `chant import <file> --lexicon
+ * <name>` drives with the file's content (#2935); `importCommand` above is
+ * the same pipeline behind file reading + JSON/YAML detection.
  */
 export interface ContentImportOptions {
   /** The raw template content (YAML or JSON — the plugin's parser decides). */
@@ -277,15 +389,6 @@ export async function importFromContent(options: ContentImportOptions): Promise<
   if (!plugin) {
     return { success: false, generatedFiles: [], warnings: [], error: `Lexicon "${options.lexicon}" not available.` };
   }
-  if (!plugin.templateParser || !plugin.templateGenerator) {
-    return {
-      success: false,
-      generatedFiles: [],
-      warnings: [],
-      error: `Lexicon "${plugin.name}" does not support template import.`,
-      lexicon: plugin.name,
-    };
-  }
   return parseAndWrite(plugin, options.content, outputDir, options.force, [], [], plugin.name);
 }
 
@@ -299,10 +402,23 @@ function parseAndWrite(
   generatedFiles: string[],
   lexicon: string,
 ): ImportResult {
+  // A lexicon can recognize a template (detectTemplate) without being able to
+  // import it (grafana has no parser). Every path funnels through here, so
+  // this one check covers detection, --lexicon and content import (#2940).
+  if (!plugin.templateParser || !plugin.templateGenerator) {
+    return {
+      success: false,
+      generatedFiles: [],
+      warnings: [],
+      error: `lexicon "${plugin.name}" does not support template import`,
+      lexicon: plugin.name,
+    };
+  }
+
   // Parse template
   let ir: TemplateIR;
   try {
-    const parser = plugin.templateParser!();
+    const parser = plugin.templateParser();
     ir = parser.parse(content);
   } catch (err) {
     return {
@@ -319,7 +435,7 @@ function parseAndWrite(
     warnings.push(...ir.warnings);
   }
 
-  const generator = plugin.templateGenerator!();
+  const generator = plugin.templateGenerator();
 
   // Check output directory
   if (existsSync(outputDir) && !force) {
@@ -545,6 +661,7 @@ export async function liveImportFromPlugins(
     generatedFiles,
     warnings,
     lexicon: generatorLexicon.name,
+    detected: !options.lexicon,
   };
 }
 
@@ -562,7 +679,7 @@ export function printImportResult(result: ImportResult): void {
   }
 
   if (result.lexicon) {
-    console.log(`Detected lexicon: ${result.lexicon}`);
+    console.log(`${result.detected ? "Detected lexicon" : "Lexicon"}: ${result.lexicon}`);
   }
 
   if (result.generatedFiles.length > 0) {

package/src/cli/handlers/misc.ts

@@ -374,10 +374,13 @@ export async function runImport(ctx: CommandContext): Promise<number> {
     return result.success ? 0 : 1;
   }
 
+  // A template file: JSON or YAML, detected, unless `--lexicon` names the
+  // plugin (#2935).
   const result = await importCommand({
     templatePath: ctx.args.path,
     output: ctx.args.output,
     force: ctx.args.force,
+    lexicon: ctx.args.lexicon,
   });
 
   printImportResult(result);

package/src/cli/handlers/operator-steward-signal.e2e.test.ts

@@ -45,7 +45,7 @@ function sleep(ms: number): Promise<void> {
 }
 
 describe("chant operator --steward — a repeated SIGTERM (#2872)", () => {
-  test("a second and third SIGTERM sent in quick succession still release the steward's lease", async () => {
+  test("repeated SIGTERMs sent in quick succession still release the steward's lease and exit 0", async () => {
     const dir = repo(
       {
         "chant.config.ts": "export default { lexicons: [] };\n",
@@ -77,16 +77,24 @@ describe("chant operator --steward — a repeated SIGTERM (#2872)", () => {
       await sleep(50);
     }
 
-    // Three SIGTERMs, each given a moment to actually reach the child's event
-    // loop before the next: with `process.once`, the first one's auto-removal
-    // happens the instant it fires, so the second (or third) finds no
-    // listener left and the process exits right there, skipping the
-    // `finally` that releases the lease.
-    child.kill("SIGTERM");
-    await sleep(30);
-    child.kill("SIGTERM");
-    await sleep(30);
-    child.kill("SIGTERM");
+    // A SIGTERM, then more every few ms until the child is gone, each given
+    // a moment to reach the child's event loop before the next. With
+    // `process.once`, the first one's auto-removal happens the instant it
+    // fires, so the second finds no listener left and the process exits
+    // right there, skipping the `finally` that releases the lease. Firing
+    // until the child closes (not a fixed three) also covers the stretch
+    // after that `finally`, up to `process.exit`: when the handler removed
+    // its listeners there, a SIGTERM arriving in that stretch ended the
+    // process by signal (exit code null) though the lease was released. With
+    // three signals 30ms apart that failed CI now and then (runs
+    // 36357297831, 36358285603, 36368551353); signalling to the end hit it
+    // every time.
+    let closed = false;
+    child.on("close", () => (closed = true));
+    for (let sent = 0; !closed && sent < 1000; sent++) {
+      child.kill("SIGTERM");
+      await sleep(5);
+    }
 
     const code = await exited;
     expect(code, `chant operator --steward did not exit cleanly; stderr:\n${stderr}`).toBe(0);

package/src/cli/handlers/operator.ts

@@ -216,7 +216,12 @@ export async function runOperator(ctx: CommandContext): Promise<number> {
     });
     return 0;
   } finally {
-    process.removeListener("SIGINT", onSigint);
+    // Only when no signal started this shutdown. After one did, the process
+    // exits right after this returns, and removing the listener would put
+    // SIGINT back to its default disposition for that last stretch: a repeat
+    // signal arriving there ends the process by signal instead of the exit
+    // code (see the steward's `finally` below).
+    if (!stopping) process.removeListener("SIGINT", onSigint);
   }
 }
 
@@ -347,8 +352,17 @@ export async function runStewardOperator(ctx: CommandContext): Promise<number> {
     // A courtesy: the lease expires on its own if this never runs.
     const { record } = await readLease(stewardLeaseName(steward.name)).catch(() => ({ record: undefined }));
     if (record?.holder === holder) await releaseLease(stewardLeaseName(steward.name), holder, record.token).catch(() => false);
-    process.removeListener("SIGINT", onSigint);
-    process.removeListener("SIGTERM", onSigint);
+    // Removed only when no signal started this shutdown. After one did, the
+    // CLI goes on to `flushAndExit` (../main.ts) and `process.exit`, and
+    // removing the last SIGTERM listener hands the signal back to its
+    // default disposition for that stretch: a repeat SIGTERM arriving there
+    // ended the process by signal (exit code null) with the lease already
+    // released. That was the operator-steward-signal e2e test's intermittent
+    // failure; a SIGTERM every 2ms after the first hit it 8 runs of 8.
+    if (!stopping) {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigint);
+    }
   }
 }
 

package/src/cli/main.ts

@@ -1091,7 +1091,8 @@ Options:
                         - build: json (default) or yaml
                         - list: text (default) or json
                         - lint: stylish (default), json, or sarif
-  -d, --lexicon <name>  Build only the specified lexicon (e.g. aws, gitlab)
+  -d, --lexicon <name>  Build only the specified lexicon (e.g. aws, gitlab);
+                        import: use this lexicon instead of detecting one
       --env <name>      Active environment: sets CHANT_ENV so env-aware source
                         re-evaluates for that environment (build + graph), and
                         drives organizational policy. Must be in chant.config
@@ -1201,6 +1202,7 @@ Examples:
   chant run --components all --env production
   chant components export prod --component search-service -o ./dist/search-service
   chant import template.json --output ./infra/
+  chant import manifest.yaml --lexicon k8s --output ./infra/
   chant import --from prod --name my-bucket --output src/
   chant lint ./infra/
   chant lint ./infra/ --format sarif

package/src/cli/mcp/tools/import.ts

@@ -17,6 +17,10 @@ export const importTool = {
         type: "string",
         description: "Output directory (default: ./infra/)",
       },
+      lexicon: {
+        type: "string",
+        description: "Lexicon to import with (e.g. k8s); skips template detection",
+      },
     },
     required: ["source"],
   },
@@ -28,11 +32,13 @@ export const importTool = {
 export async function handleImport(params: Record<string, unknown>): Promise<unknown> {
   const source = params.source as string;
   const output = params.output as string | undefined;
+  const lexicon = params.lexicon as string | undefined;
 
   const result = await importCommand({
     templatePath: source,
     output,
     force: true,
+    lexicon,
   });
 
   if (!result.success) {

package/src/cli/plugins.ts

@@ -2,8 +2,9 @@ import { importLexiconModule, importLexiconPackage, lexiconModulePath, lexiconNa
 import { readLexiconDeclarationsStatically, type StaticLexiconRead } from "../config-static";
 export { unknownPathLexiconsNotice } from "../config-static";
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, readdirSync, readFileSync, type Dirent } from "node:fs";
 import { isLexiconPlugin, type LexiconPlugin } from "../lexicon";
 import { loadChantConfigUpward } from "../config";
 import { findInfraFiles, detectLexicons } from "../index";
@@ -80,6 +81,44 @@ export async function loadPlugin(lexiconName: string): Promise<LexiconPlugin> {
   throw new Error(`Package ${packageName} does not export a LexiconPlugin or Serializer`);
 }
 
+const LEXICON_PACKAGE_PREFIX = "chant-lexicon-";
+
+/**
+ * The names of the lexicon packages installed where {@link loadPlugin} can
+ * load them (#2965), sorted. `loadPlugin` imports
+ * `@intentius/chant-lexicon-<name>` from chant's own install and then from the
+ * project (`importLexiconPackage`), so this lists the `@intentius` scope of
+ * every `node_modules` directory Node would search from either place: each
+ * ancestor of chant's own module and each ancestor of `projectDir`. A name
+ * being listed does not promise it loads; the caller still handles a failure.
+ */
+export function listInstalledLexicons(projectDir: string = process.cwd()): string[] {
+  const names = new Set<string>();
+  const starts = [dirname(fileURLToPath(import.meta.url)), resolve(projectDir)];
+  for (const start of starts) {
+    let dir = start;
+    for (;;) {
+      const scope = join(dir, "node_modules", "@intentius");
+      let entries: Dirent[] = [];
+      try {
+        entries = readdirSync(scope, { withFileTypes: true });
+      } catch {
+        // No @intentius scope here.
+      }
+      for (const entry of entries) {
+        if (!entry.name.startsWith(LEXICON_PACKAGE_PREFIX)) continue;
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        const name = entry.name.slice(LEXICON_PACKAGE_PREFIX.length);
+        if (name !== "") names.add(name);
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return [...names].sort();
+}
+
 /**
  * The installed version of each named lexicon package (chant #1442).
  *

package/src/yaml.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { emitYAML, parseYAML, parseScalar } from "./yaml";
+import { emitYAML, parseYAML, parseYAMLDocument, parseScalar, splitYAMLDocuments } from "./yaml";
 
 // ---------------------------------------------------------------------------
 // emitYAML
@@ -538,3 +538,55 @@ describe("parseYAML — a colon without following space is not a mapping (#2013)
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// parseYAMLDocument / splitYAMLDocuments (#2965)
+// ---------------------------------------------------------------------------
+
+describe("parseYAMLDocument", () => {
+  test("a top-level list parses as a list", () => {
+    expect(parseYAMLDocument("- a\n- b\n")).toEqual(["a", "b"]);
+    expect(parseYAMLDocument("# rules\n\n- name: one\n  expr: up\n- name: two\n")).toEqual([
+      { name: "one", expr: "up" },
+      { name: "two" },
+    ]);
+  });
+
+  test("parseYAML still returns a mapping for the same input", () => {
+    expect(parseYAML("- a\n- b\n")).toEqual({});
+  });
+
+  test("a mapping and JSON parse as parseYAML parses them", () => {
+    expect(parseYAMLDocument("a: 1\nb:\n  - x\n")).toEqual({ a: 1, b: ["x"] });
+    expect(parseYAMLDocument("[1, 2]")).toEqual([1, 2]);
+    expect(parseYAMLDocument("")).toEqual({});
+  });
+});
+
+describe("splitYAMLDocuments", () => {
+  test("splits on bare --- separators", () => {
+    expect(splitYAMLDocuments("a: 1\n---\nb: 2\n")).toEqual(["a: 1", "b: 2\n"]);
+  });
+
+  test("a separator may carry a trailing comment", () => {
+    expect(splitYAMLDocuments("--- # first\na: 1\n---   # second\nb: 2")).toEqual(["a: 1", "b: 2"]);
+  });
+
+  test("... ends a document", () => {
+    expect(splitYAMLDocuments("a: 1\n...\nb: 2\n... # done\n")).toEqual(["a: 1", "b: 2"]);
+    expect(splitYAMLDocuments("---\na: 1\n...\n---\nb: 2\n...\n")).toEqual(["a: 1", "b: 2"]);
+  });
+
+  test("drops empty and comment-only documents", () => {
+    expect(splitYAMLDocuments("# header\n---\n\n---\na: 1\n---\n# trailing\n")).toEqual(["a: 1"]);
+    expect(splitYAMLDocuments("")).toEqual([]);
+  });
+
+  test("only a whole-line marker splits", () => {
+    expect(splitYAMLDocuments("a: ---\nb: |\n  ---\n---x: 1\n")).toEqual(["a: ---\nb: |\n  ---\n---x: 1\n"]);
+  });
+
+  test("normalizes CRLF line endings", () => {
+    expect(splitYAMLDocuments("a: 1\r\n--- # c\r\nb: 2\r\n")).toEqual(["a: 1", "b: 2\n"]);
+  });
+});

package/src/yaml.ts

@@ -193,6 +193,54 @@ export function parseYAML(content: string): Record<string, unknown> {
   return parseYAMLLines(lines, 0, 0).value as Record<string, unknown>;
 }
 
+/**
+ * Parse one YAML (or JSON) document whose top level may be a sequence
+ * (#2965). {@link parseYAML} reads only a top-level mapping and returns `{}`
+ * for a file like `- a\n- b`; its callers rely on getting a mapping back, so
+ * it keeps doing that. This returns the list instead, and otherwise defers to
+ * `parseYAML`.
+ */
+export function parseYAMLDocument(content: string): unknown {
+  try {
+    return JSON.parse(content);
+  } catch {
+    // Fall through to YAML parsing
+  }
+
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  const first = lines.findIndex((line) => line.trim() !== "" && !line.trim().startsWith("#"));
+  if (first !== -1 && /^\s*- /.test(lines[first])) {
+    return parseYAMLArray(lines, first, lines[first].search(/\S/)).value;
+  }
+  return parseYAMLLines(lines, 0, 0).value;
+}
+
+/** A document start (`---`) or end (`...`) marker, optionally followed by a comment. */
+const DOCUMENT_MARKER = /^(?:---|\.\.\.)(?:[ \t]+#.*)?[ \t]*$/;
+
+/**
+ * Split a YAML stream into its documents (#2965). A line holding only `---`
+ * starts a document and a line holding only `...` ends one; either may carry
+ * a trailing `# comment`. Documents that are empty or hold only comments are
+ * dropped. The text of each document is returned unparsed, with `\r\n`
+ * normalized to `\n`.
+ */
+export function splitYAMLDocuments(content: string): string[] {
+  const documents: string[] = [];
+  let current: string[] = [];
+  const flush = (): void => {
+    const text = current.join("\n");
+    if (text.replace(/#[^\n]*/g, "").trim() !== "") documents.push(text);
+    current = [];
+  };
+  for (const line of content.replace(/\r\n?/g, "\n").split("\n")) {
+    if (DOCUMENT_MARKER.test(line)) flush();
+    else current.push(line);
+  }
+  flush();
+  return documents;
+}
+
 /**
  * A block-scalar header: `|` (literal, keep newlines) or `>` (folded, newlines →
  * spaces), with a chomping indicator (`-` strip trailing newlines, `+` keep them,