@intentius/chant 0.0.14 → 0.0.16

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "Apache-2.0",
   "type": "module",
-  "files": ["src/", "bin/"],
+  "files": [
+    "src/",
+    "bin/"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -13,13 +16,16 @@
   "exports": {
     ".": "./src/index.ts",
     "./cli": "./src/cli/index.ts",
-    "./cli/*": "./src/cli/*",
-    "./*": "./src/*"
+    "./cli/*": "./src/cli/*.ts",
+    "./*": "./src/*.ts"
   },
   "dependencies": {
     "fflate": "^0.8.2",
     "picomatch": "^4.0.3",
     "typescript": "^5.5.0",
     "zod": "^4.3.6"
+  },
+  "optionalDependencies": {
+    "tsx": "^4.0.0"
   }
 }

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

@@ -208,6 +208,35 @@ export function checkLexicon(dir: string): CheckResult {
     detail: `${mdxFiles.length} page(s)`,
   });
 
+  // Post-synth check count (excluding helpers, tests, and support files)
+  const postSynthCheckFiles = listTsFiles(join(dir, "src/lint/post-synth"), ["index.ts"])
+    .filter((f) => !f.endsWith(".test.ts") && !f.endsWith("-helpers.ts") && f !== "helpers.ts" && !f.startsWith("arm-") && !f.startsWith("k8s-"));
+  items.push({
+    name: "At least 15 post-synth checks",
+    tier: 2,
+    pass: postSynthCheckFiles.length >= 15,
+    detail: `${postSynthCheckFiles.length} check(s)`,
+  });
+
+  // Skills count
+  const skillsDir = join(dir, "src/skills");
+  const skillFiles = existsSync(skillsDir) ? readdirSync(skillsDir).filter((f) => f.endsWith(".md")) : [];
+  items.push({
+    name: "At least 3 skills",
+    tier: 2,
+    pass: skillFiles.length >= 3,
+    detail: `${skillFiles.length} skill(s)`,
+  });
+
+  // initTemplates count — check for template branches in plugin.ts
+  const initTemplateBranches = (pluginContent.match(/template\s*===\s*["']/g) || []).length + 1; // +1 for default
+  items.push({
+    name: "At least 3 initTemplates",
+    tier: 2,
+    pass: initTemplateBranches >= 3,
+    detail: `${initTemplateBranches} template(s)`,
+  });
+
   // ── Tier 3: Thoroughness ───────────────────────────────────────
 
   // Each lint rule has a test (per-file or consolidated)
@@ -276,6 +305,24 @@ export function checkLexicon(dir: string): CheckResult {
     pass: hasActions,
   });
 
+  // Validate required names count
+  const validateContent = readOr(join(dir, "src/validate.ts"));
+  const requiredNamesMatches = validateContent.match(/["'][A-Z][a-zA-Z]+["']/g) || [];
+  items.push({
+    name: "validate.ts checks at least 30 required names",
+    tier: 3,
+    pass: requiredNamesMatches.length >= 30,
+    detail: `${requiredNamesMatches.length} required name(s)`,
+  });
+
+  // Composite test file exists
+  const hasCompositeTest = existsSync(join(dir, "src/composites/composites.test.ts"));
+  items.push({
+    name: "Composite test file exists",
+    tier: 3,
+    pass: hasCompositeTest,
+  });
+
   // Examples with tests (per-example or consolidated root test file)
   const examplesDir = join(dir, "examples");
   let examplesWithTests = 0;

package/src/cli/commands/doctor.ts

@@ -147,7 +147,7 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
     }
   }
 
-  // Check 8: tsconfig.json has paths
+  // Check 8: tsconfig.json does NOT have paths (they break runtime resolution)
   const tsconfigPath = join(projectPath, "tsconfig.json");
   if (existsSync(tsconfigPath)) {
     try {
@@ -156,8 +156,8 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
       // Strip single-line comments for basic parsing
       const cleaned = raw.replace(/\/\/.*$/gm, "");
       const tsconfig = JSON.parse(cleaned);
-      if (!tsconfig.compilerOptions?.paths) {
-        checks.push({ name: "tsconfig-paths", status: "warn", message: "tsconfig.json missing compilerOptions.paths" });
+      if (tsconfig.compilerOptions?.paths) {
+        checks.push({ name: "tsconfig-paths", status: "warn", message: "tsconfig.json has compilerOptions.paths — these break runtime module resolution (bun and tsx follow them). Remove the paths block." });
       } else {
         checks.push({ name: "tsconfig-paths", status: "pass" });
       }
@@ -203,10 +203,9 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
       if (!plugin.skills) continue;
       const skills = plugin.skills();
       if (skills.length === 0) continue;
-      const skillsDir = join(projectPath, ".chant", "skills", plugin.name);
       let missing = 0;
       for (const skill of skills) {
-        if (!existsSync(join(skillsDir, `${skill.name}.md`))) {
+        if (!existsSync(join(projectPath, "skills", skill.name, "SKILL.md"))) {
           missing++;
         }
       }

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

@@ -94,7 +94,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("generates valid tsconfig.json with path mappings", async () => {
+  test("generates valid tsconfig.json without path mappings", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -114,8 +114,7 @@ describe("initCommand", () => {
       expect(tsconfig.compilerOptions.strict).toBe(true);
       expect(tsconfig.compilerOptions.rootDir).toBe("./src");
       expect(tsconfig.include).toContain("src");
-      expect(tsconfig.compilerOptions.paths["@intentius/chant"]).toEqual(["./.chant/types/core"]);
-      expect(tsconfig.compilerOptions.paths["@intentius/chant-lexicon-aws"]).toEqual(["./.chant/types/lexicon-aws"]);
+      expect(tsconfig.compilerOptions.paths).toBeUndefined();
     });
   });
 

package/src/cli/commands/init.ts

@@ -61,6 +61,16 @@ export interface InitResult {
   error?: string;
 }
 
+/**
+ * Detect whether the user's project uses bun or npm.
+ * Checks for lock files first, then falls back to runtime detection.
+ */
+function detectPackageManager(dir?: string): "bun" | "npm" {
+  if (dir && (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock")))) return "bun";
+  if (typeof globalThis.Bun !== "undefined") return "bun";
+  return "npm";
+}
+
 /**
  * Detect the IDE environment for MCP config
  */
@@ -142,12 +152,6 @@ function generateTsConfig(lexicon: string): string {
       declaration: true,
       outDir: "./dist",
       rootDir: "./src",
-      paths: {
-        "@intentius/chant": ["./.chant/types/core"],
-        "@intentius/chant/*": ["./.chant/types/core/*"],
-        [`@intentius/chant-lexicon-${lexicon}`]: [`./.chant/types/lexicon-${lexicon}`],
-        [`@intentius/chant-lexicon-${lexicon}/*`]: [`./.chant/types/lexicon-${lexicon}/*`],
-      },
     },
     include: ["src"],
     exclude: ["node_modules", "dist"],
@@ -177,7 +181,7 @@ node_modules/
 .chant/types/
 .chant/meta/
 .chant/rules/
-.chant/skills/
+skills/
 `;
 }
 
@@ -236,11 +240,11 @@ export interface ChantConfig {
 /**
  * Generate MCP config
  */
-function generateMcpConfig(_ide: "claude-code" | "cursor" | "generic"): string {
+function generateMcpConfig(_ide: "claude-code" | "cursor" | "generic", pm: "bun" | "npm"): string {
   const config = {
     mcpServers: {
       chant: {
-        command: "npx",
+        command: pm === "bun" ? "bunx" : "npx",
         args: ["chant", "serve", "mcp"],
       },
     },
@@ -450,7 +454,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
 
     writeIfNotExists(
       join(mcpDir, "mcp.json"),
-      generateMcpConfig(ide),
+      generateMcpConfig(ide, detectPackageManager(targetDir)),
       `~/.${ide === "generic" ? "config/mcp" : ide}/mcp.json`,
       createdFiles,
       warnings,
@@ -458,28 +462,16 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   }
 
   // Install skills from the lexicon's plugin
-  // Write to both .chant/skills/ (chant's own location) and .claude/skills/ (Claude Code discovery)
   try {
     const plugin = await loadPlugin(options.lexicon);
     if (plugin.skills) {
       const skills = plugin.skills();
       if (skills.length > 0) {
-        // .chant/skills/ — chant's own skill storage
-        const chantSkillsDir = join(targetDir, ".chant", "skills", options.lexicon);
-        mkdirSync(chantSkillsDir, { recursive: true });
         for (const skill of skills) {
-          const skillPath = join(chantSkillsDir, `${skill.name}.md`);
-          writeFileSync(skillPath, skill.content);
-          createdFiles.push(`.chant/skills/${options.lexicon}/${skill.name}.md`);
-        }
-
-        // .claude/skills/ — Claude Code skill discovery format
-        for (const skill of skills) {
-          const claudeSkillDir = join(targetDir, ".claude", "skills", skill.name);
-          mkdirSync(claudeSkillDir, { recursive: true });
-          const claudeSkillPath = join(claudeSkillDir, "SKILL.md");
-          writeFileSync(claudeSkillPath, skill.content);
-          createdFiles.push(`.claude/skills/${skill.name}/SKILL.md`);
+          const skillDir = join(targetDir, "skills", skill.name);
+          mkdirSync(skillDir, { recursive: true });
+          writeFileSync(join(skillDir, "SKILL.md"), skill.content);
+          createdFiles.push(`skills/${skill.name}/SKILL.md`);
         }
       }
     }
@@ -519,6 +511,8 @@ export async function printInitResult(
 
   console.log("");
 
+  const pm = detectPackageManager(options?.cwd);
+
   // Interactive install prompt
   if (!options?.skipInstall) {
     const shouldInstall = await promptInstall();
@@ -527,9 +521,9 @@ export async function printInitResult(
       const cwd = options?.cwd ?? ".";
       console.log("Installing dependencies...");
       try {
-        execSync("npm install", { cwd, stdio: "inherit" });
+        execSync(`${pm} install`, { cwd, stdio: "inherit" });
       } catch {
-        console.error(formatWarning({ message: "Install failed. Run 'npm install' manually." }));
+        console.error(formatWarning({ message: `Install failed. Run '${pm} install' manually.` }));
       }
     }
   }
@@ -538,6 +532,6 @@ export async function printInitResult(
   console.log("Next steps:");
   console.log("  1. Edit src/config.ts");
   console.log("  2. Add resources in src/");
-  console.log("  3. npm run build");
+  console.log(`  3. ${pm} run build`);
 }
 

package/src/cli/commands/update.ts

@@ -164,10 +164,10 @@ export async function updateCommand(options: UpdateOptions): Promise<UpdateResul
       if (plugin.skills) {
         const skills = plugin.skills();
         if (skills.length > 0) {
-          const skillsDir = join(projectDir, ".chant", "skills", plugin.name);
-          mkdirSync(skillsDir, { recursive: true });
           for (const skill of skills) {
-            writeFileSync(join(skillsDir, `${skill.name}.md`), skill.content);
+            const skillDir = join(projectDir, "skills", skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, "SKILL.md"), skill.content);
           }
           synced.push(`${plugin.name} skills (${skills.length})`);
         }

package/src/codegen/generate-typescript.ts

@@ -102,9 +102,12 @@ export function writeConstructor(
     const optional = p.required ? "" : "?";
     const tsType = resolveConstructorType(p.type, remap);
     if (p.description) {
-      lines.push(`    /** ${p.description} */`);
+      // Sanitize: escape */ to prevent breaking JSDoc comments
+      const safeDesc = p.description.replace(/\*\//g, "*\\/");
+      lines.push(`    /** ${safeDesc} */`);
     }
-    lines.push(`    ${p.name}${optional}: ${tsType};`);
+    const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+    lines.push(`    ${safeName}${optional}: ${tsType};`);
   }
   if (resourceAttributesType) {
     lines.push(`  }, attributes?: ${resourceAttributesType});`);

package/src/codegen/generate.test.ts

@@ -0,0 +1,111 @@
+import { describe, test, expect } from "bun:test";
+import { generatePipeline, type GeneratePipelineConfig, type ParsedResult } from "./generate";
+import { NamingStrategy } from "./naming";
+
+interface TestResult extends ParsedResult {
+  name: string;
+}
+
+function makeConfig(
+  schemas: Map<string, Buffer>,
+  parseOverride?: (name: string, data: Buffer) => TestResult | TestResult[] | null,
+): GeneratePipelineConfig<TestResult> {
+  return {
+    fetchSchemas: async () => schemas,
+    parseSchema: parseOverride ?? ((name, _data) => ({
+      name,
+      propertyTypes: [],
+      enums: [],
+    })),
+    createNaming: (results) => new NamingStrategy(
+      results.map((r) => ({ typeName: r.name, propertyTypes: r.propertyTypes })),
+      {
+        priorityNames: {},
+        priorityAliases: {},
+        priorityPropertyAliases: {},
+        serviceAbbreviations: {},
+        shortName: (t) => t,
+        serviceName: () => "",
+      },
+    ),
+    generateRegistry: () => "{}",
+    generateTypes: () => "// types",
+    generateRuntimeIndex: () => "// index",
+  };
+}
+
+describe("generatePipeline", () => {
+  test("processes single-result parseSchema", async () => {
+    const schemas = new Map([
+      ["TypeA", Buffer.from("a")],
+      ["TypeB", Buffer.from("b")],
+    ]);
+    const result = await generatePipeline(makeConfig(schemas));
+    expect(result.resources).toBe(2);
+    expect(result.warnings).toHaveLength(0);
+  });
+
+  test("supports parseSchema returning arrays", async () => {
+    const schemas = new Map([
+      ["combined", Buffer.from("data")],
+    ]);
+
+    const config = makeConfig(schemas, (_name, _data) => [
+      { name: "TypeA", propertyTypes: [{ name: "PropA" }], enums: [] },
+      { name: "TypeB", propertyTypes: [{ name: "PropB" }], enums: [] },
+      { name: "TypeC", propertyTypes: [], enums: [{}] },
+    ]);
+
+    const result = await generatePipeline(config);
+    expect(result.resources).toBe(3);
+    expect(result.properties).toBe(2);
+    expect(result.enums).toBe(1);
+  });
+
+  test("handles parseSchema returning null (skip)", async () => {
+    const schemas = new Map([
+      ["skip-me", Buffer.from("x")],
+      ["keep-me", Buffer.from("y")],
+    ]);
+    const config = makeConfig(schemas, (name, _data) => {
+      if (name === "skip-me") return null;
+      return { name, propertyTypes: [], enums: [] };
+    });
+
+    const result = await generatePipeline(config);
+    expect(result.resources).toBe(1);
+  });
+
+  test("handles mixed single and array returns", async () => {
+    const schemas = new Map([
+      ["single", Buffer.from("s")],
+      ["multi", Buffer.from("m")],
+    ]);
+    const config = makeConfig(schemas, (name, _data) => {
+      if (name === "multi") {
+        return [
+          { name: "MultiA", propertyTypes: [], enums: [] },
+          { name: "MultiB", propertyTypes: [], enums: [] },
+        ];
+      }
+      return { name, propertyTypes: [], enums: [] };
+    });
+
+    const result = await generatePipeline(config);
+    expect(result.resources).toBe(3);
+  });
+
+  test("collects parse errors as warnings", async () => {
+    const schemas = new Map([
+      ["bad", Buffer.from("x")],
+    ]);
+    const config = makeConfig(schemas, () => {
+      throw new Error("parse failed");
+    });
+
+    const result = await generatePipeline(config);
+    expect(result.resources).toBe(0);
+    expect(result.warnings).toHaveLength(1);
+    expect(result.warnings[0].error).toContain("parse failed");
+  });
+});

package/src/codegen/generate.ts

@@ -48,8 +48,13 @@ export interface GeneratePipelineConfig<T extends ParsedResult> {
   /** Fetch or provide raw schema data. */
   fetchSchemas: (opts: { force?: boolean }) => Promise<Map<string, Buffer>>;
 
-  /** Parse a single schema buffer into a result. Returns null to skip. */
-  parseSchema: (typeName: string, data: Buffer) => T | null;
+  /**
+   * Parse a single schema buffer into results. Returns null to skip.
+   *
+   * May return an array when a single schema file produces multiple results
+   * (e.g. K8s OpenAPI spec, GitLab CI schema).
+   */
+  parseSchema: (typeName: string, data: Buffer) => T | T[] | null;
 
   /** Create a naming strategy from the parsed results. */
   createNaming: (results: T[]) => NamingStrategy;
@@ -119,7 +124,13 @@ export async function generatePipeline<T extends ParsedResult>(
   for (const [typeName, data] of schemas) {
     try {
       const result = config.parseSchema(typeName, data);
-      if (result) results.push(result);
+      if (result) {
+        if (Array.isArray(result)) {
+          results.push(...result);
+        } else {
+          results.push(result);
+        }
+      }
     } catch (err) {
       warnings.push({
         file: typeName,

package/src/index.ts

@@ -33,6 +33,7 @@ export * from "./lint/selectors";
 export * from "./lint/named-checks";
 export * from "./lint/post-synth";
 export * from "./lint/rule-loader";
+export * from "./lint/discover";
 export * from "./import/parser";
 export * from "./import/generator";
 export * from "./lexicon";

package/src/lint/discover.test.ts

@@ -0,0 +1,69 @@
+import { describe, test, expect } from "bun:test";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { discoverLintRules, discoverPostSynthChecks } from "./discover";
+
+const thisDir = dirname(fileURLToPath(import.meta.url));
+
+describe("discoverLintRules", () => {
+  test("returns empty array for non-existent directory", () => {
+    const rules = discoverLintRules("/nonexistent/path", import.meta.url);
+    expect(rules).toEqual([]);
+  });
+
+  test("discovers rules from a real lexicon", () => {
+    // Use the Helm lexicon's rules directory as a real test case
+    const helmRulesDir = join(thisDir, "../../../../lexicons/helm/src/lint/rules");
+    const rules = discoverLintRules(helmRulesDir, import.meta.url);
+    expect(rules.length).toBeGreaterThan(0);
+    // Each discovered rule should have the expected shape
+    for (const rule of rules) {
+      expect(typeof rule.id).toBe("string");
+      expect(typeof rule.severity).toBe("string");
+      expect(typeof rule.category).toBe("string");
+      expect(typeof rule.check).toBe("function");
+    }
+  });
+
+  test("sorts rules by id", () => {
+    const helmRulesDir = join(thisDir, "../../../../lexicons/helm/src/lint/rules");
+    const rules = discoverLintRules(helmRulesDir, import.meta.url);
+    for (let i = 1; i < rules.length; i++) {
+      expect(rules[i].id.localeCompare(rules[i - 1].id)).toBeGreaterThanOrEqual(0);
+    }
+  });
+});
+
+describe("discoverPostSynthChecks", () => {
+  test("returns empty array for non-existent directory", () => {
+    const checks = discoverPostSynthChecks("/nonexistent/path", import.meta.url);
+    expect(checks).toEqual([]);
+  });
+
+  test("discovers checks from a real lexicon", () => {
+    const helmPostSynthDir = join(thisDir, "../../../../lexicons/helm/src/lint/post-synth");
+    const checks = discoverPostSynthChecks(helmPostSynthDir, import.meta.url);
+    expect(checks.length).toBeGreaterThan(0);
+    for (const check of checks) {
+      expect(typeof check.id).toBe("string");
+      expect(typeof check.description).toBe("string");
+      expect(typeof check.check).toBe("function");
+    }
+  });
+
+  test("sorts checks by id", () => {
+    const helmPostSynthDir = join(thisDir, "../../../../lexicons/helm/src/lint/post-synth");
+    const checks = discoverPostSynthChecks(helmPostSynthDir, import.meta.url);
+    for (let i = 1; i < checks.length; i++) {
+      expect(checks[i].id.localeCompare(checks[i - 1].id)).toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  test("does not include lint rules", () => {
+    // Post-synth checks should not pick up lint rules (which also have check())
+    const helmRulesDir = join(thisDir, "../../../../lexicons/helm/src/lint/rules");
+    const checks = discoverPostSynthChecks(helmRulesDir, import.meta.url);
+    // Lint rules have severity, post-synth checks don't — so this should be empty
+    expect(checks.length).toBe(0);
+  });
+});

package/src/lint/discover.ts

@@ -0,0 +1,112 @@
+/**
+ * Auto-discovery for lint rules and post-synth checks.
+ *
+ * Scans directories for .ts files and loads exported rules/checks,
+ * eliminating the need to manually list every rule in plugin.ts.
+ */
+
+import { readdirSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+import type { LintRule } from "./rule";
+import type { PostSynthCheck } from "./post-synth";
+
+/**
+ * Discover lint rules from a directory.
+ *
+ * Scans the directory for .ts files (excluding tests, helpers, and index files),
+ * loads each module, and collects any exported objects that look like a LintRule
+ * (has `id`, `severity`, `category`, and `check` function).
+ *
+ * @param dir - Absolute path to the rules directory
+ * @param importMetaUrl - The caller's import.meta.url (for createRequire)
+ */
+export function discoverLintRules(dir: string, importMetaUrl: string): LintRule[] {
+  const require = createRequire(importMetaUrl);
+  const rules: LintRule[] = [];
+
+  for (const file of listRuleFiles(dir)) {
+    try {
+      // Strip .ts extension — require() resolves without it
+      const modPath = join(dir, file.replace(/\.ts$/, ""));
+      const mod = require(modPath);
+      for (const exp of Object.values(mod)) {
+        if (isLintRule(exp)) rules.push(exp);
+      }
+    } catch {
+      // Skip files that fail to load
+    }
+  }
+
+  return rules.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/**
+ * Discover post-synth checks from a directory.
+ *
+ * Scans the directory for .ts files (excluding tests, helpers, and index files),
+ * loads each module, and collects any exported objects that look like a PostSynthCheck
+ * (has `id`, `description`, and `check` function).
+ *
+ * @param dir - Absolute path to the post-synth rules directory
+ * @param importMetaUrl - The caller's import.meta.url (for createRequire)
+ */
+export function discoverPostSynthChecks(dir: string, importMetaUrl: string): PostSynthCheck[] {
+  const require = createRequire(importMetaUrl);
+  const checks: PostSynthCheck[] = [];
+
+  for (const file of listRuleFiles(dir)) {
+    try {
+      // Strip .ts extension — require() resolves without it
+      const modPath = join(dir, file.replace(/\.ts$/, ""));
+      const mod = require(modPath);
+      for (const exp of Object.values(mod)) {
+        if (isPostSynthCheck(exp)) checks.push(exp);
+      }
+    } catch {
+      // Skip files that fail to load
+    }
+  }
+
+  return checks.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/**
+ * List rule files in a directory (excluding tests, helpers, index).
+ */
+function listRuleFiles(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter((f) => {
+      if (!f.endsWith(".ts")) return false;
+      if (f.endsWith(".test.ts")) return false;
+      if (f === "index.ts") return false;
+      if (f.includes("helper")) return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+
+function isLintRule(obj: unknown): obj is LintRule {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    typeof o.id === "string" &&
+    typeof o.severity === "string" &&
+    typeof o.category === "string" &&
+    typeof o.check === "function"
+  );
+}
+
+function isPostSynthCheck(obj: unknown): obj is PostSynthCheck {
+  if (typeof obj !== "object" || obj === null) return false;
+  const o = obj as Record<string, unknown>;
+  return (
+    typeof o.id === "string" &&
+    typeof o.description === "string" &&
+    typeof o.check === "function" &&
+    // Exclude LintRules (which also have check) by checking for PostSynthCheck-specific fields
+    typeof o.severity !== "string"
+  );
+}

package/src/lint/rules/index.ts

@@ -25,6 +25,7 @@ export { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 export { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
 export { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 export { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
+export { isInsideCompositeFactory } from "./composite-scope";
 
 import { flatDeclarationsRule } from "./flat-declarations";
 import { exportRequiredRule } from "./export-required";

package/src/serializer-walker.test.ts

@@ -101,6 +101,29 @@ describe("walkValue", () => {
     expect(walkValue((resource as any).Ref, names, mockVisitor)).toEqual({ __ref: "MyTable" });
   });
 
+  test("resolves __attrRef envelope inside intrinsic toJSON output", () => {
+    // Simulate an intrinsic whose toJSON() produces an __attrRef envelope
+    // (e.g., AttrRef inside a Sub template literal)
+    const intrinsic = {
+      [INTRINSIC_MARKER]: true as const,
+      toJSON: () => ({
+        MyIntrinsic: { __attrRef: { entity: "MyResource", attribute: "Arn" } },
+      }),
+    };
+    const names = new Map<Declarable, string>();
+    expect(walkValue(intrinsic, names, mockVisitor)).toEqual({
+      MyIntrinsic: { __getAtt: ["MyResource", "Arn"] },
+    });
+  });
+
+  test("resolves standalone __attrRef envelope in plain object", () => {
+    const names = new Map<Declarable, string>();
+    const value = { __attrRef: { entity: "MyBucket", attribute: "DomainName" } };
+    expect(walkValue(value, names, mockVisitor)).toEqual({
+      __getAtt: ["MyBucket", "DomainName"],
+    });
+  });
+
   test("complex nested structure", () => {
     const resource = makeDeclarable("Test::Role");
     const ref = new AttrRef(resource, "arn");

package/src/serializer-walker.ts

@@ -43,10 +43,10 @@ export function walkValue(
     return visitor.attrRef(name, value.attribute);
   }
 
-  // Handle Intrinsics
+  // Handle Intrinsics — walk the toJSON() result to resolve any embedded AttrRef markers
   if (typeof value === "object" && value !== null && INTRINSIC_MARKER in value) {
     if ("toJSON" in value && typeof value.toJSON === "function") {
-      return value.toJSON();
+      return walkValue(value.toJSON(), entityNames, visitor);
     }
   }
 
@@ -67,6 +67,12 @@ export function walkValue(
     return value.map((item) => walkValue(item, entityNames, visitor));
   }
 
+  // Handle serialized AttrRef envelopes (produced by AttrRef.toJSON() inside intrinsics)
+  if (typeof value === "object" && "__attrRef" in value) {
+    const ref = (value as { __attrRef: { entity: string; attribute: string } }).__attrRef;
+    return visitor.attrRef(ref.entity, ref.attribute);
+  }
+
   // Handle objects
   if (typeof value === "object") {
     const result: Record<string, unknown> = {};

package/src/yaml.test.ts

@@ -88,6 +88,27 @@ describe("emitYAML", () => {
     const result = emitYAML({ key: "val" }, 1);
     expect(result).toBe("\n  key: val");
   });
+
+  test("multiline string emits as | block scalar", () => {
+    const result = emitYAML("line1\nline2\nline3", 0);
+    expect(result).toBe("|\nline1\nline2\nline3");
+  });
+
+  test("multiline string trims trailing empty line", () => {
+    // Template literals often end with \n producing a trailing empty line
+    const result = emitYAML("line1\nline2\n", 0);
+    expect(result).toBe("|\nline1\nline2");
+  });
+
+  test("multiline string inside object value is properly indented", () => {
+    const result = emitYAML({ config: "line1\nline2\nline3" }, 0);
+    expect(result).toContain("config: |\n  line1\n  line2\n  line3");
+  });
+
+  test("multiline string inside array item is properly indented", () => {
+    const result = emitYAML([{ data: "a\nb" }], 0);
+    expect(result).toContain("data: |\n    a\n    b");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/yaml.ts

@@ -35,6 +35,13 @@ export function emitYAML(value: unknown, indent: number): string {
   }
 
   if (typeof value === "string") {
+    // Multiline strings use YAML literal block scalar (|)
+    if (value.includes("\n")) {
+      const lines = value.split("\n");
+      // Trim trailing empty line if present (common for template strings)
+      const trimmed = lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+      return "|\n" + trimmed.map((l) => `${prefix}${l}`).join("\n");
+    }
     // Quote strings that could be misinterpreted
     if (
       value === "" ||
@@ -225,6 +232,58 @@ export function parseYAMLLines(
   return { value: result, endIndex: i };
 }
 
+/**
+ * Parse the value of a key inside an array item.
+ * If the inline value is empty, look ahead for a nested object or array.
+ */
+function parseArrayItemValue(
+  inlineValue: string,
+  lines: string[],
+  currentIndex: number,
+  childIndent: number,
+): unknown {
+  if (inlineValue !== "" && !inlineValue.startsWith("#")) {
+    if (inlineValue.startsWith("[")) {
+      try { return JSON.parse(inlineValue); } catch { return inlineValue; }
+    }
+    if (inlineValue.startsWith("{")) {
+      try { return JSON.parse(inlineValue); } catch { return inlineValue; }
+    }
+    return parseScalar(inlineValue);
+  }
+  // Empty inline value — check for nested block
+  const nextIdx = currentIndex + 1;
+  if (nextIdx < lines.length) {
+    const nextLine = lines[nextIdx];
+    if (nextLine.trim() !== "" && !nextLine.trim().startsWith("#")) {
+      const ni = nextLine.search(/\S/);
+      if (ni >= childIndent) {
+        if (nextLine.trimStart().startsWith("- ")) {
+          return parseYAMLArray(lines, nextIdx, ni).value;
+        }
+        return parseYAMLLines(lines, nextIdx, ni).value;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Skip past a nested block (object or array) starting at startIndex with the given indent.
+ * Returns the index of the first line that is NOT part of the nested block.
+ */
+function skipNestedBlock(lines: string[], startIndex: number, childIndent: number): number {
+  let j = startIndex;
+  while (j < lines.length) {
+    const l = lines[j];
+    if (l.trim() === "" || l.trim().startsWith("#")) { j++; continue; }
+    const ni = l.search(/\S/);
+    if (ni < childIndent) break;
+    j++;
+  }
+  return j;
+}
+
 /**
  * Parse a block array (lines starting with `- `).
  */
@@ -253,10 +312,12 @@ export function parseYAMLArray(
       const kvMatch = itemValue.match(/^([^\s:][^:]*?):\s*(.*)$/);
       if (kvMatch) {
         const obj: Record<string, unknown> = {};
-        obj[kvMatch[1].trim()] = parseScalar(kvMatch[2].trim());
+        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 = i + 1;
+        let j = kvMatch[2].trim() === "" || kvMatch[2].trim().startsWith("#")
+          ? skipNestedBlock(lines, i + 1, nextIndent)
+          : i + 1;
         while (j < lines.length) {
           const nextLine = lines[j];
           if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
@@ -264,11 +325,17 @@ export function parseYAMLArray(
             continue;
           }
           const ni = nextLine.search(/\S/);
-          if (ni !== nextIndent) break;
+          if (ni < nextIndent) break;
+          if (ni > nextIndent) break; // belongs to a nested block already consumed
           const nextKV = nextLine.match(/^(\s*)([^\s:][^:]*?):\s*(.*)$/);
           if (nextKV) {
-            obj[nextKV[2].trim()] = parseScalar(nextKV[3].trim());
-            j++;
+            const nextVal = nextKV[3].trim();
+            obj[nextKV[2].trim()] = parseArrayItemValue(nextVal, lines, j, ni + 2);
+            if (nextVal === "" || nextVal.startsWith("#")) {
+              j = skipNestedBlock(lines, j + 1, ni + 2);
+            } else {
+              j++;
+            }
           } else {
             break;
           }