@intentius/chant 0.18.17 → 0.18.18

package/dist/cli/commands/init-lexicon/templates/lint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/lint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAoB1E;AAED,wBAAgB,wBAAwB,IAAI,MAAM,CAGjD"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/lint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAoB1E;AAED,wBAAgB,wBAAwB,IAAI,MAAM,CASjD"}

package/dist/cli/commands/init-lexicon/templates/project.d.ts

@@ -5,6 +5,14 @@ export declare function generatePackageJson(name: string, names: {
     packageName: string;
 }): string;
 export declare function generateTsConfig(): string;
+/**
+ * Build config used by `npm run build` (and CI's `tsc --noEmit`). Uses `bundler`
+ * resolution + the `development` condition so `@intentius/chant/*` resolves to the
+ * workspace source, and excludes tests/docs — the same setup the shipped lexicons
+ * use. (The plain `tsconfig.json` extends the monorepo root and can't be tsc'd on
+ * its own.)
+ */
+export declare function generateTsConfigBuild(): string;
 export declare function generateJustfile(name: string): string;
 export declare function generateGitignore(): string;
 export declare function generateReadme(name: string, names: {

package/dist/cli/commands/init-lexicon/templates/project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/project.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA6BxF;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAWzC;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BrD;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAK1C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA4BnF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA0BnH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA8BvD;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAM9C"}
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/project.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA+BxF;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAWzC;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAmB9C;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BrD;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAK1C;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA4BnF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CA0BnH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA8BvD;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAO9C"}

package/dist/cli/commands/init-lexicon/templates/spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/spec.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,mBAAmB,IAAI,MAAM,CAuB5C;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CA2B5C"}
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../../../../src/cli/commands/init-lexicon/templates/spec.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,mBAAmB,IAAI,MAAM,CAwB5C;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CA2B5C"}

package/dist/cli/commands/init-lexicon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-lexicon.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init-lexicon.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0BAA0B;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAQD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM;;;;;EAQvC;AAqBD;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAoHhG;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBrF"}
+{"version":3,"file":"init-lexicon.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init-lexicon.ts"],"names":[],"mappings":"AAeA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0BAA0B;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAQD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM;;;;;EAQvC;AAqBD;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAqHhG;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBrF"}

package/dist/yaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CA2G/D;AAMD,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASlE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAuEb;AAsDD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAkEb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAelD"}
+{"version":3,"file":"yaml.d.ts","sourceRoot":"","sources":["../src/yaml.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CA2G/D;AAMD,sCAAsC;AACtC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;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;AA+DD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,WAAW,CAyEb;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAelD"}

package/package.json

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

package/src/cli/commands/__fixtures__/init-lexicon-output/package.json

@@ -18,12 +18,12 @@
     "generate": "npx tsx src/codegen/generate-cli.ts",
     "validate": "npx tsx src/validate-cli.ts",
     "docs": "npx tsx src/codegen/docs-cli.ts",
-    "prepack": "npm run generate && npm run validate"
-  },
-  "dependencies": {
-    "@intentius/chant": "workspace:*"
+    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "prepack": "npm run generate && npm run validate && npm run build"
   },
   "devDependencies": {
+    "@intentius/chant": "*",
+    "tsc-alias": "^1.8.17",
     "typescript": "^5.9.3"
   }
 }

package/src/cli/commands/__fixtures__/init-lexicon-output/src/codegen/generate.ts

@@ -8,7 +8,7 @@ import { fileURLToPath } from "url";
  *
  * Each callback has a TODO describing what to implement.
  */
-export async function generate(options?: { verbose?: boolean }): Promise<GenerateResult> {
+export async function generate(options?: { verbose?: boolean; force?: boolean }): Promise<GenerateResult> {
   const result = await generatePipeline({
     // Must return Map<typeName, Buffer> — each entry is one schema file.
     // Example: fetch a zip, extract JSON files, key by type name.
@@ -49,7 +49,7 @@ export async function generate(options?: { verbose?: boolean }): Promise<Generat
     generateRuntimeIndex: (results, naming) => {
       throw new Error("TODO: implement generateRuntimeIndex — produce index.ts content");
     },
-  });
+  }, options);
 
   if (options?.verbose) {
     console.error(`Generated ${result.resources} resources, ${result.properties} property types`);

package/src/cli/commands/__fixtures__/init-lexicon-output/src/lint/rules/index.ts

@@ -1 +1,7 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+import { sampleRule } from "./sample";
+
 export { sampleRule } from "./sample";
+
+/** All lint rules provided by this lexicon (imported by plugin.ts's lintRules()). */
+export const rules: LintRule[] = [sampleRule];

package/src/cli/commands/__fixtures__/init-lexicon-output/src/spec/fetch.ts

@@ -9,13 +9,14 @@ const CACHE_FILE = ".cache/schemas.zip";
  *
  * TODO: Point SCHEMA_URL at your real upstream schema source.
  */
-export async function fetchSchemas(options?: { force?: boolean }): Promise<Map<string, string>> {
-  const zipData = await fetchWithCache({
-    url: SCHEMA_URL,
-    cacheFile: CACHE_FILE,
-    force: options?.force,
-  });
+export async function fetchSchemas(options?: { force?: boolean }): Promise<Map<string, Buffer>> {
+  // `force` is the second argument to fetchWithCache (not a FetchConfig field).
+  const zipData = await fetchWithCache(
+    { url: SCHEMA_URL, cacheFile: CACHE_FILE },
+    options?.force,
+  );
 
-  // TODO: Adjust the filter to match your schema file names
+  // TODO: Adjust the filter to match your schema file names. extractFromZip yields
+  // Buffers — decode with `.toString()` in parse.ts as needed.
   return extractFromZip(zipData, (name) => name.endsWith(".json"));
 }

package/src/cli/commands/__fixtures__/init-lexicon-output/src/validate-cli.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env tsx
 import { validate } from "./validate";
 
-await validate({ verbose: true });
+// `validate` takes an optional { basePath }; defaults to the lexicon root.
+await validate();

package/src/cli/commands/__fixtures__/init-lexicon-output/tsconfig.build.json

@@ -0,0 +1,27 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "paths": {},
+    "moduleResolution": "bundler",
+    "customConditions": [
+      "development"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "**/*.test.ts",
+    "node_modules",
+    "dist",
+    "docs"
+  ],
+  "tsc-alias": {
+    "resolveFullPaths": true
+  }
+}

package/src/cli/commands/__snapshots__/init-lexicon.test.ts.snap

@@ -11,7 +11,7 @@ import { fileURLToPath } from "url";
  *
  * Each callback has a TODO describing what to implement.
  */
-export async function generate(options?: { verbose?: boolean }): Promise<GenerateResult> {
+export async function generate(options?: { verbose?: boolean; force?: boolean }): Promise<GenerateResult> {
   const result = await generatePipeline({
     // Must return Map<typeName, Buffer> — each entry is one schema file.
     // Example: fetch a zip, extract JSON files, key by type name.
@@ -52,7 +52,7 @@ export async function generate(options?: { verbose?: boolean }): Promise<Generat
     generateRuntimeIndex: (results, naming) => {
       throw new Error("TODO: implement generateRuntimeIndex — produce index.ts content");
     },
-  });
+  }, options);
 
   if (options?.verbose) {
     console.error(\`Generated \${result.resources} resources, \${result.properties} property types\`);

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

@@ -13,7 +13,7 @@ import { fileURLToPath } from "url";
  *
  * Each callback has a TODO describing what to implement.
  */
-export async function generate(options?: { verbose?: boolean }): Promise<GenerateResult> {
+export async function generate(options?: { verbose?: boolean; force?: boolean }): Promise<GenerateResult> {
   const result = await generatePipeline({
     // Must return Map<typeName, Buffer> — each entry is one schema file.
     // Example: fetch a zip, extract JSON files, key by type name.
@@ -54,7 +54,7 @@ export async function generate(options?: { verbose?: boolean }): Promise<Generat
     generateRuntimeIndex: (results, naming) => {
       throw new Error("TODO: implement generateRuntimeIndex — produce index.ts content");
     },
-  });
+  }, options);
 
   if (options?.verbose) {
     console.error(\`Generated \${result.resources} resources, \${result.properties} property types\`);

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

@@ -25,6 +25,12 @@ export const sampleRule: LintRule = {
 }
 
 export function generateLintRulesIndexTs(): string {
-  return `export { sampleRule } from "./sample";
+  return `import type { LintRule } from "@intentius/chant/lint/rule";
+import { sampleRule } from "./sample";
+
+export { sampleRule } from "./sample";
+
+/** All lint rules provided by this lexicon (imported by plugin.ts's lintRules()). */
+export const rules: LintRule[] = [sampleRule];
 `;
 }

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

@@ -20,12 +20,14 @@ export function generatePackageJson(name: string, names: { packageName: string }
       generate: "npx tsx src/codegen/generate-cli.ts",
       validate: "npx tsx src/validate-cli.ts",
       docs: "npx tsx src/codegen/docs-cli.ts",
-      prepack: "npm run generate && npm run validate",
-    },
-    dependencies: {
-      "@intentius/chant": "workspace:*",
+      build: "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+      prepack: "npm run generate && npm run validate && npm run build",
     },
     devDependencies: {
+      // `*` (not `workspace:*`) so a fresh lexicon `npm install`s under plain npm
+      // (the `workspace:` protocol is rejected outside a workspace).
+      "@intentius/chant": "*",
+      "tsc-alias": "^1.8.17",
       typescript: "^5.9.3",
     },
   };
@@ -46,6 +48,34 @@ export function generateTsConfig(): string {
   return JSON.stringify(config, null, 2) + "\n";
 }
 
+/**
+ * Build config used by `npm run build` (and CI's `tsc --noEmit`). Uses `bundler`
+ * resolution + the `development` condition so `@intentius/chant/*` resolves to the
+ * workspace source, and excludes tests/docs — the same setup the shipped lexicons
+ * use. (The plain `tsconfig.json` extends the monorepo root and can't be tsc'd on
+ * its own.)
+ */
+export function generateTsConfigBuild(): string {
+  const config = {
+    extends: "../../tsconfig.json",
+    compilerOptions: {
+      noEmit: false,
+      declaration: true,
+      declarationMap: true,
+      outDir: "dist",
+      rootDir: "src",
+      paths: {},
+      moduleResolution: "bundler",
+      customConditions: ["development"],
+    },
+    include: ["src/**/*"],
+    exclude: ["**/*.test.ts", "node_modules", "dist", "docs"],
+    "tsc-alias": { resolveFullPaths: true },
+  };
+
+  return JSON.stringify(config, null, 2) + "\n";
+}
+
 export function generateJustfile(name: string): string {
   return `# Default recipe - list all available commands
 default:
@@ -177,6 +207,7 @@ export function generateValidateCliTs(): string {
   return `#!/usr/bin/env tsx
 import { validate } from "./validate";
 
-await validate({ verbose: true });
+// \`validate\` takes an optional { basePath }; defaults to the lexicon root.
+await validate();
 `;
 }

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

@@ -14,14 +14,15 @@ const CACHE_FILE = ".cache/schemas.zip";
  *
  * TODO: Point SCHEMA_URL at your real upstream schema source.
  */
-export async function fetchSchemas(options?: { force?: boolean }): Promise<Map<string, string>> {
-  const zipData = await fetchWithCache({
-    url: SCHEMA_URL,
-    cacheFile: CACHE_FILE,
-    force: options?.force,
-  });
+export async function fetchSchemas(options?: { force?: boolean }): Promise<Map<string, Buffer>> {
+  // \`force\` is the second argument to fetchWithCache (not a FetchConfig field).
+  const zipData = await fetchWithCache(
+    { url: SCHEMA_URL, cacheFile: CACHE_FILE },
+    options?.force,
+  );
 
-  // TODO: Adjust the filter to match your schema file names
+  // TODO: Adjust the filter to match your schema file names. extractFromZip yields
+  // Buffers — decode with \`.toString()\` in parse.ts as needed.
   return extractFromZip(zipData, (name) => name.endsWith(".json"));
 }
 `;

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

@@ -232,6 +232,39 @@ describe("scaffold content validation", () => {
     // AWS references
     expect(content).toContain("lexicons/aws/");
   });
+
+  // Drift guards — keep the scaffold compiling/installing against current core (#749).
+  test("package.json installs under plain npm and can build (#749)", () => {
+    const pkg = JSON.parse(readFileSync(join(targetDir, "package.json"), "utf-8"));
+    expect(JSON.stringify(pkg)).not.toContain("workspace:"); // rejected by plain npm
+    expect(pkg.devDependencies["@intentius/chant"]).toBe("*");
+    expect(pkg.dependencies).toBeUndefined();
+    expect(pkg.devDependencies["tsc-alias"]).toBeTruthy();
+    expect(pkg.scripts.build).toContain("tsconfig.build.json");
+  });
+
+  test("tsconfig.build.json uses bundler resolution + the development condition (#749)", () => {
+    const cfg = JSON.parse(readFileSync(join(targetDir, "tsconfig.build.json"), "utf-8"));
+    expect(cfg.compilerOptions.moduleResolution).toBe("bundler");
+    expect(cfg.compilerOptions.customConditions).toContain("development");
+  });
+
+  test("spec/fetch.ts matches fetchWithCache(config, force) → Map<string, Buffer> (#749)", () => {
+    const content = readFileSync(join(targetDir, "src/spec/fetch.ts"), "utf-8");
+    expect(content).toContain("Promise<Map<string, Buffer>>");
+    expect(content).not.toMatch(/force:\s*options/); // force is the 2nd arg, not a FetchConfig field
+  });
+
+  test("validate-cli.ts calls validate() with no verbose arg (#749)", () => {
+    const content = readFileSync(join(targetDir, "src/validate-cli.ts"), "utf-8");
+    expect(content).toContain("await validate();");
+    expect(content).not.toContain("verbose");
+  });
+
+  test("lint/rules/index.ts exports a `rules` array (plugin.ts imports it) (#749)", () => {
+    const content = readFileSync(join(targetDir, "src/lint/rules/index.ts"), "utf-8");
+    expect(content).toContain("export const rules");
+  });
 });
 
 // ── Fixture snapshot tests ──────────────────────────────────────────

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

@@ -8,7 +8,7 @@ import { generateCodegenGenerateTs, generateCodegenGenerateCliTs, generateCodege
 import { generateSpecFetchTs, generateSpecParseTs } from "./init-lexicon/templates/spec";
 import { generateSampleRuleTs, generateLintRulesIndexTs } from "./init-lexicon/templates/lint";
 import { generateLspCompletionsTs, generateLspHoverTs } from "./init-lexicon/templates/lsp";
-import { generatePackageJson, generateTsConfig, generateJustfile, generateGitignore, generateReadme, generateSerializerTs, generateValidateTs, generateValidateCliTs } from "./init-lexicon/templates/project";
+import { generatePackageJson, generateTsConfig, generateTsConfigBuild, generateJustfile, generateGitignore, generateReadme, generateSerializerTs, generateValidateTs, generateValidateCliTs } from "./init-lexicon/templates/project";
 import { generatePluginTestTs, generateSerializerTestTs, generateCompletionsTestTs, generateHoverTestTs } from "./init-lexicon/templates/tests";
 import { generateDocsPackageJson, generateDocsTsConfig, generateDocsAstroConfig, generateDocsContentConfig, generateDocsIndexMdx } from "./init-lexicon/templates/docs";
 import { generateExamplePackageJson, generateExampleInfraTs } from "./init-lexicon/templates/examples";
@@ -150,6 +150,7 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/validate-cli.ts": generateValidateCliTs(),
     "package.json": generatePackageJson(name, names),
     "tsconfig.json": generateTsConfig(),
+    "tsconfig.build.json": generateTsConfigBuild(),
     "justfile": generateJustfile(name),
     ".gitignore": generateGitignore(),
     "README.md": generateReadme(name, names),

package/src/yaml.test.ts

@@ -211,3 +211,36 @@ describe("parseScalar", () => {
     expect(parseScalar("hello")).toBe("hello");
   });
 });
+
+// Block scalars (#910) — round-trip parity with js-yaml for literal/folded/chomping,
+// including block scalars nested inside array items (the case that mis-parsed).
+describe("parseYAML block scalars (#910)", () => {
+  test("top-level literal | keeps newlines, clips to one trailing", () => {
+    expect(parseYAML("run: |\n  line1\n  line2\n")).toEqual({ run: "line1\nline2\n" });
+  });
+
+  test("literal | nested inside a later array item (the reported bug)", () => {
+    expect(
+      parseYAML("steps:\n  - name: first\n    run: echo hi\n  - name: second\n    run: |\n      line1\n      line2\n"),
+    ).toEqual({
+      steps: [
+        { name: "first", run: "echo hi" },
+        { name: "second", run: "line1\nline2\n" },
+      ],
+    });
+  });
+
+  test("block scalar as an array item's first key, with a sibling key after", () => {
+    expect(parseYAML("steps:\n  - run: |\n      a\n      b\n    name: x\n")).toEqual({
+      steps: [{ run: "a\nb\n", name: "x" }],
+    });
+  });
+
+  test("strip |- drops the trailing newline; a sibling key after still parses", () => {
+    expect(parseYAML("a: |-\n  x\n  y\nb: 2\n")).toEqual({ a: "x\ny", b: 2 });
+  });
+
+  test("folded > folds line breaks to spaces, blank line to one newline", () => {
+    expect(parseYAML("msg: >\n  a\n  b\n\n  c\n")).toEqual({ msg: "a b\nc\n" });
+  });
+});

package/src/yaml.ts

@@ -155,6 +155,85 @@ export function parseYAML(content: string): Record<string, unknown> {
   return parseYAMLLines(lines, 0, 0).value as Record<string, unknown>;
 }
 
+/**
+ * A block-scalar header: `|` (literal, keep newlines) or `>` (folded, newlines →
+ * spaces), with a chomping indicator (`-` strip trailing newlines, `+` keep them,
+ * default clip to a single one). Returns null when `inline` isn't a block header.
+ */
+interface BlockScalarHeader {
+  style: "literal" | "folded";
+  chomp: "clip" | "strip" | "keep";
+}
+function blockScalarHeader(inline: string): BlockScalarHeader | null {
+  const m = inline.match(/^([|>])([+-]?)(?:\s+#.*)?$/);
+  if (!m) return null;
+  return {
+    style: m[1] === "|" ? "literal" : "folded",
+    chomp: m[2] === "-" ? "strip" : m[2] === "+" ? "keep" : "clip",
+  };
+}
+
+/**
+ * Parse a block scalar's body — the lines indented past `parentIndent`, dedented
+ * by the block's own indent (the first content line's). Handles literal/folded
+ * styles and clip/strip/keep chomping, matching js-yaml. Returns the string value
+ * and the index of the first line that is NOT part of the block.
+ */
+function parseBlockScalar(
+  lines: string[],
+  startIndex: number,
+  parentIndent: number,
+  header: BlockScalarHeader,
+): { value: string; endIndex: number } {
+  const raw: string[] = [];
+  let blockIndent = -1;
+  let i = startIndex;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") {
+      raw.push(""); // a blank line is part of the block (kept/chomped later)
+      continue;
+    }
+    const ni = line.search(/\S/);
+    if (ni <= parentIndent) break; // dedented out of the block
+    if (blockIndent === -1) blockIndent = ni;
+    if (ni < blockIndent) break;
+    raw.push(line.slice(blockIndent));
+  }
+  // Trailing blank lines belong to the block (chomping decides their fate).
+  let text: string;
+  if (header.style === "folded") {
+    // Fold each run of non-empty lines into a space-joined paragraph; a run of N
+    // blank lines between paragraphs becomes N newlines (a single blank → one
+    // newline), matching YAML folded semantics.
+    text = "";
+    let buf: string[] = [];
+    let blankRun = 0;
+    let wrote = false;
+    const flush = (): void => {
+      if (buf.length === 0) return;
+      if (wrote) text += "\n".repeat(blankRun);
+      text += buf.join(" ");
+      buf = [];
+      blankRun = 0;
+      wrote = true;
+    };
+    for (const l of raw) {
+      if (l === "") { flush(); blankRun++; }
+      else buf.push(l);
+    }
+    flush();
+  } else {
+    text = raw.join("\n");
+  }
+  const trailing = text.match(/\n*$/)?.[0].length ?? 0;
+  const stripped = text.replace(/\n+$/, "");
+  if (header.chomp === "strip") text = stripped;
+  else if (header.chomp === "keep") text = stripped + "\n".repeat(Math.max(trailing, raw.length > 0 ? 1 : 0));
+  else text = stripped === "" ? "" : stripped + "\n"; // clip
+  return { value: text, endIndex: i };
+}
+
 /**
  * Parse indentation-based YAML lines into a key-value object.
  */
@@ -222,8 +301,15 @@ export function parseYAMLLines(
         }
         i++;
       } else {
-        result[key] = parseScalar(inlineValue);
-        i++;
+        const header = blockScalarHeader(inlineValue);
+        if (header) {
+          const block = parseBlockScalar(lines, i + 1, indent, header);
+          result[key] = block.value;
+          i = block.endIndex;
+        } else {
+          result[key] = parseScalar(inlineValue);
+          i++;
+        }
       }
     } else if (line.trimStart().startsWith("- ")) {
       break;
@@ -246,6 +332,15 @@ function parseArrayItemValue(
   childIndent: number,
 ): unknown {
   if (inlineValue !== "" && !inlineValue.startsWith("#")) {
+    const header = blockScalarHeader(inlineValue);
+    if (header) {
+      // Block scalar nested under an array-item key (e.g. `- name: x\n  run: |`).
+      // The body is indented past the key's column. On a `- key: |` line the key
+      // sits 2 cols past the dash; on its own line it's the line's indent (#910).
+      const dash = lines[currentIndex].match(/^(\s*)- /);
+      const keyIndent = dash ? dash[1].length + 2 : lines[currentIndex].search(/\S/);
+      return parseBlockScalar(lines, currentIndex + 1, keyIndent, header).value;
+    }
     if (inlineValue.startsWith("[")) {
       try { return JSON.parse(inlineValue); } catch { return inlineValue; }
     }
@@ -323,9 +418,13 @@ export function parseYAMLArray(
         obj[kvMatch[1].trim()] = parseArrayItemValue(kvMatch[2].trim(), lines, i, indent + 2);
         // Check for more keys at indent+2
         const nextIndent = indent + 2;
-        let j = kvMatch[2].trim() === "" || kvMatch[2].trim().startsWith("#")
+        const firstVal = kvMatch[2].trim();
+        let j = firstVal === "" || firstVal.startsWith("#")
           ? skipNestedBlock(lines, i + 1, nextIndent)
-          : i + 1;
+          : blockScalarHeader(firstVal)
+            // Block body is indented past the key (nextIndent); skip it (#910).
+            ? skipNestedBlock(lines, i + 1, nextIndent + 1)
+            : i + 1;
         while (j < lines.length) {
           const nextLine = lines[j];
           if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
@@ -341,6 +440,9 @@ export function parseYAMLArray(
             obj[nextKV[2].trim()] = parseArrayItemValue(nextVal, lines, j, ni + 2);
             if (nextVal === "" || nextVal.startsWith("#")) {
               j = skipNestedBlock(lines, j + 1, ni + 2);
+            } else if (blockScalarHeader(nextVal)) {
+              // Skip the block body (indented past this key at `ni`) (#910).
+              j = skipNestedBlock(lines, j + 1, ni + 1);
             } else {
               j++;
             }