@intentius/chant 0.0.3 → 0.0.5

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

@@ -22,14 +22,13 @@ describe("initCommand", () => {
       expect(result.createdFiles).toContain("tsconfig.json");
       expect(result.createdFiles).toContain("chant.config.ts");
       expect(result.createdFiles).toContain(".gitignore");
-      expect(result.createdFiles).toContain("src/_.ts");
       expect(result.createdFiles).toContain("src/config.ts");
       expect(result.createdFiles).toContain("src/data-bucket.ts");
       expect(result.createdFiles).toContain("src/logs-bucket.ts");
     });
   });
 
-  test("aws source files use namespace imports", async () => {
+  test("aws source files use direct imports", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -41,15 +40,15 @@ describe("initCommand", () => {
       await initCommand(options);
 
       const configContent = readFileSync(join(testDir, "src", "config.ts"), "utf-8");
-      expect(configContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
+      expect(configContent).toContain('from "@intentius/chant-lexicon-aws"');
 
       const dataBucketContent = readFileSync(join(testDir, "src", "data-bucket.ts"), "utf-8");
-      expect(dataBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(dataBucketContent).toContain('import * as _ from "./_"');
+      expect(dataBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(dataBucketContent).toContain('from "./config"');
 
       const logsBucketContent = readFileSync(join(testDir, "src", "logs-bucket.ts"), "utf-8");
-      expect(logsBucketContent).toContain('import * as aws from "@intentius/chant-lexicon-aws"');
-      expect(logsBucketContent).toContain('import * as _ from "./_"');
+      expect(logsBucketContent).toContain('from "@intentius/chant-lexicon-aws"');
+      expect(logsBucketContent).toContain('from "./config"');
     });
   });
 
@@ -177,7 +176,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("generates barrel file", async () => {
+  test("does not generate barrel file", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -188,13 +187,11 @@ describe("initCommand", () => {
 
       await initCommand(options);
 
+      // No _.ts barrel — direct imports are used instead
       const barrelPath = join(testDir, "src", "_.ts");
-      expect(existsSync(barrelPath)).toBe(true);
+      expect(existsSync(barrelPath)).toBe(false);
 
-      const barrelContent = readFileSync(barrelPath, "utf-8");
-      expect(barrelContent).toContain('export * from "./config"');
-
-      // No index.ts — barrel re-exports cause duplicate entity errors during build
+      // No index.ts either
       const indexPath = join(testDir, "src", "index.ts");
       expect(existsSync(indexPath)).toBe(false);
     });
@@ -218,7 +215,6 @@ describe("initCommand", () => {
       expect(coreContent).toContain("Value<T>");
       expect(coreContent).toContain("Serializer");
       expect(coreContent).toContain("ChantConfig");
-      expect(coreContent).toContain("barrel");
 
       const corePkg = join(testDir, ".chant", "types", "core", "package.json");
       expect(existsSync(corePkg)).toBe(true);

package/src/cli/commands/init.ts

@@ -214,8 +214,6 @@ export interface ChantConfig {
   };
 }
 
-/** Barrel proxy — lazy-loads all sibling exports */
-export declare function barrel(dir: string): Record<string, unknown>;
 `;
 }
 
@@ -345,7 +343,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Generate source files from plugin (or fallback to a minimal barrel)
+  // Generate source files from plugin (if available)
   let sourceFiles: Record<string, string> = {};
   try {
     const plugin = await loadPlugin(options.lexicon);
@@ -353,10 +351,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
       sourceFiles = plugin.initTemplates();
     }
   } catch {
-    // Plugin not yet installed — write a minimal barrel stub
-    sourceFiles = {
-      "_.ts": "// Barrel — re-export shared config here\n",
-    };
+    // Plugin not yet installed — no source files to scaffold
   }
   for (const [filename, content] of Object.entries(sourceFiles)) {
     writeIfNotExists(

package/src/cli/commands/lint.ts

@@ -1,7 +1,7 @@
 import { resolve, join } from "path";
 import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
 import { runLint } from "../../lint/engine";
-import type { LintRule, LintDiagnostic, LintFix, LintRunOptions } from "../../lint/rule";
+import type { LintRule, LintDiagnostic, LintFix } from "../../lint/rule";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
 import { formatStylish, formatJson, formatSarif } from "../reporters/stylish";
 import { loadLocalRules } from "../../lint/rule-loader";
@@ -241,54 +241,30 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
   // Get all TypeScript files
   const files = getTypeScriptFiles(infraPath);
 
-  // Build barrel exports context for EVL008
-  let runOptions: LintRunOptions | undefined;
-  try {
-    const { scanProject } = require("../../project/scan");
-    const scan = scanProject(infraPath);
-    const barrelExports = new Set<string>(scan.exports.map((e: { name: string }) => e.name));
-    const projectExports = new Map<string, { file: string; className: string }>();
-    for (const exp of scan.exports) {
-      projectExports.set(exp.name, { file: exp.file, className: exp.className });
-    }
-    runOptions = { barrelExports, projectExports, projectScan: scan };
-  } catch {
-    // No barrel file found — EVL008/COR016 will be no-ops
-  }
-
   // Run lint — use per-file rules when overrides are present
   let diagnostics: LintDiagnostic[];
   if (options.rules) {
-    diagnostics = await runLint(files, options.rules, undefined, runOptions);
+    diagnostics = await runLint(files, options.rules, undefined);
   } else if (hasOverrides) {
     diagnostics = [];
     for (const file of files) {
       const relativePath = file.slice(infraPath.length + 1);
       const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-      const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+      const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
       diagnostics.push(...fileDiagnostics);
     }
   } else {
     const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-    diagnostics = await runLint(files, rules, ruleOptions, runOptions);
+    diagnostics = await runLint(files, rules, ruleOptions);
   }
 
   // Apply fixes if requested
   if (options.fix) {
-    // Handle cross-file write fixes (COR016) separately
-    for (const diag of diagnostics) {
-      if (diag.fix?.kind === "write-file" && diag.fix.params) {
-        const path = diag.fix.params.path as string;
-        const content = diag.fix.params.content as string;
-        writeFileSync(path, content, "utf-8");
-      }
-    }
-
-    // Group remaining fixes by file (exclude write-file fixes)
+    // Group fixes by file
     const fixesByFile = new Map<string, LintFix[]>();
 
     for (const diag of diagnostics) {
-      if (diag.fix && diag.fix.kind !== "write-file") {
+      if (diag.fix) {
         const existing = fixesByFile.get(diag.file) ?? [];
         existing.push(diag.fix);
         fixesByFile.set(diag.file, existing);
@@ -303,18 +279,18 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     // Re-lint after fixes to get updated diagnostics
     let postFixDiagnostics: LintDiagnostic[];
     if (options.rules) {
-      postFixDiagnostics = await runLint(files, options.rules, undefined, runOptions);
+      postFixDiagnostics = await runLint(files, options.rules, undefined);
     } else if (hasOverrides) {
       postFixDiagnostics = [];
       for (const file of files) {
         const relativePath = file.slice(infraPath.length + 1);
         const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-        const fileDiagnostics = await runLint([file], fileRules, ruleOptions, runOptions);
+        const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
         postFixDiagnostics.push(...fileDiagnostics);
       }
     } else {
       const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-      postFixDiagnostics = await runLint(files, rules, ruleOptions, runOptions);
+      postFixDiagnostics = await runLint(files, rules, ruleOptions);
     }
     diagnostics.length = 0;
     diagnostics.push(...postFixDiagnostics);

package/src/cli/main.ts

@@ -161,7 +161,7 @@ const registry: CommandDef[] = [
   { name: "import", handler: runImport },
   { name: "init", handler: runInit },
   { name: "init lexicon", handler: runInitLexicon },
-  { name: "update", handler: runUpdate },
+{ name: "update", handler: runUpdate },
   { name: "doctor", handler: runDoctor },
 
   // Dev subcommands

package/src/codegen/docs-interpolation.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { expandFileMarkers } from "./docs";
+
+describe("expandFileMarkers", () => {
+  let dir: string;
+
+  beforeAll(() => {
+    dir = mkdtempSync(join(tmpdir(), "docs-interp-"));
+    mkdirSync(join(dir, "sub"), { recursive: true });
+    writeFileSync(
+      join(dir, "example.ts"),
+      'import { Bucket } from "@intentius/chant-lexicon-aws";\n\nexport const bucket = new Bucket({\n  bucketName: "test",\n});\n',
+    );
+    writeFileSync(
+      join(dir, "sub", "nested.ts"),
+      "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\n",
+    );
+  });
+
+  afterAll(() => {
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("expands full file marker", () => {
+    const result = expandFileMarkers("Before\n\n{{file:example.ts}}\n\nAfter", dir);
+    expect(result).toContain('```typescript title="example.ts"');
+    expect(result).toContain('import { Bucket } from "@intentius/chant-lexicon-aws";');
+    expect(result).toContain("```");
+    expect(result).toStartWith("Before\n\n");
+    expect(result).toEndWith("\n\nAfter");
+  });
+
+  test("expands line range", () => {
+    const result = expandFileMarkers("{{file:sub/nested.ts:3-5}}", dir);
+    expect(result).toContain('```typescript title="nested.ts"');
+    expect(result).toContain("line3\nline4\nline5");
+    expect(result).not.toContain("line2");
+    expect(result).not.toContain("line6");
+  });
+
+  test("supports title override", () => {
+    const result = expandFileMarkers("{{file:example.ts|title=my-file.ts}}", dir);
+    expect(result).toContain('```typescript title="my-file.ts"');
+  });
+
+  test("supports line range with title override", () => {
+    const result = expandFileMarkers(
+      "{{file:sub/nested.ts:2-4|title=snippet.ts}}",
+      dir,
+    );
+    expect(result).toContain('```typescript title="snippet.ts"');
+    expect(result).toContain("line2\nline3\nline4");
+  });
+
+  test("throws on missing file", () => {
+    expect(() => expandFileMarkers("{{file:nope.ts}}", dir)).toThrow(
+      /file not found/,
+    );
+  });
+
+  test("leaves content without markers unchanged", () => {
+    const input = "No markers here\n\n```typescript\ncode\n```\n";
+    expect(expandFileMarkers(input, dir)).toBe(input);
+  });
+
+  test("expands multiple markers", () => {
+    const result = expandFileMarkers(
+      "{{file:example.ts}}\n\n{{file:sub/nested.ts:1-2}}",
+      dir,
+    );
+    expect(result).toContain('title="example.ts"');
+    expect(result).toContain('title="nested.ts"');
+  });
+});

package/src/codegen/docs.ts

@@ -39,6 +39,8 @@ export interface DocsConfig {
   srcDir?: string;
   /** Base path for the generated Astro site (e.g. '/lexicons/aws/') */
   basePath?: string;
+  /** Root directory for resolving {{file:...}} markers in extra page content */
+  examplesDir?: string;
 }
 
 export interface DocsResult {
@@ -84,6 +86,66 @@ interface RuleMeta {
   type: "lint" | "post-synth";
 }
 
+// ── File marker interpolation ──────────────────────────────────────
+
+/**
+ * Expand `{{file:path.ts}}` markers in content with fenced code blocks.
+ *
+ * Supported forms:
+ * - `{{file:path.ts}}` — full file
+ * - `{{file:path.ts:5-12}}` — lines 5–12 (1-based, inclusive)
+ * - `{{file:path.ts|title=custom.ts}}` — override the code block title
+ * - `{{file:path.ts:5-12|title=custom.ts}}` — both
+ */
+export function expandFileMarkers(content: string, examplesDir: string): string {
+  return content.replace(
+    /\{\{file:([^}]+)\}\}/g,
+    (_match, spec: string) => {
+      // Parse options after |
+      let filePart = spec;
+      let title: string | undefined;
+      const pipeIdx = spec.indexOf("|");
+      if (pipeIdx !== -1) {
+        filePart = spec.substring(0, pipeIdx);
+        const opts = spec.substring(pipeIdx + 1);
+        const titleMatch = opts.match(/title=([^\s|]+)/);
+        if (titleMatch) title = titleMatch[1];
+      }
+
+      // Parse line range after :digits-digits at end of filePart
+      let lineStart: number | undefined;
+      let lineEnd: number | undefined;
+      const rangeMatch = filePart.match(/^(.+):(\d+)-(\d+)$/);
+      if (rangeMatch) {
+        filePart = rangeMatch[1];
+        lineStart = parseInt(rangeMatch[2], 10);
+        lineEnd = parseInt(rangeMatch[3], 10);
+      }
+
+      const filePath = join(examplesDir, filePart);
+      let fileContent: string;
+      try {
+        fileContent = readFileSync(filePath, "utf-8");
+      } catch {
+        throw new Error(`File marker {{file:${spec}}} — file not found: ${filePath}`);
+      }
+
+      // Extract line range if specified
+      if (lineStart !== undefined && lineEnd !== undefined) {
+        const lines = fileContent.split("\n");
+        fileContent = lines.slice(lineStart - 1, lineEnd).join("\n");
+      }
+
+      // Determine language from extension
+      const ext = filePart.substring(filePart.lastIndexOf(".") + 1);
+      const lang = ext === "ts" || ext === "tsx" ? "typescript" : ext;
+      const displayTitle = title ?? filePart.substring(filePart.lastIndexOf("/") + 1);
+
+      return `\`\`\`${lang} title="${displayTitle}"\n${fileContent.trimEnd()}\n\`\`\``;
+    },
+  );
+}
+
 // ── Pipeline ───────────────────────────────────────────────────────
 
 /**
@@ -128,15 +190,20 @@ export function docsPipeline(config: DocsConfig): DocsResult {
   // Generate pages
   const pages = new Map<string, string>();
 
-  pages.set(
-    "index.mdx",
-    generateOverview(config, manifest, resources, properties, serviceGroups, rules),
-  );
+  let overviewContent = generateOverview(config, manifest, resources, properties, serviceGroups, rules);
+  if (config.examplesDir) {
+    overviewContent = expandFileMarkers(overviewContent, config.examplesDir);
+  }
+  pages.set("index.mdx", overviewContent);
   const suppress = new Set(config.suppressPages ?? []);
 
   // Extra pages from lexicon config
   if (config.extraPages) {
     for (const page of config.extraPages) {
+      let content = page.content;
+      if (config.examplesDir) {
+        content = expandFileMarkers(content, config.examplesDir);
+      }
       pages.set(
         `${page.slug}.mdx`,
         [
@@ -145,7 +212,7 @@ export function docsPipeline(config: DocsConfig): DocsResult {
           page.description ? `description: "${page.description}"` : "",
           "---",
           "",
-          page.content,
+          content,
           "",
         ]
           .filter(Boolean)
@@ -300,7 +367,15 @@ function buildSidebar(
   config: DocsConfig,
   result: DocsResult,
 ): Array<Record<string, unknown>> {
+  // Starlight prepends basePath to every sidebar `link`, so a site-root-relative
+  // path like "/chant/" becomes "/chant/lexicons/aws/chant/" — a 404.  Instead
+  // we use relative traversal: "../../" is prepended to become
+  // "/chant/lexicons/aws/../../" which the browser resolves to "/chant/".
+  const segments = (config.basePath ?? "/").replace(/^\/|\/$/g, "").split("/");
+  const backLink = segments.length > 1 ? "../".repeat(segments.length - 1) : "/";
+
   const items: Array<Record<string, unknown>> = [
+    { label: "← chant docs", link: backLink },
     { label: "Overview", slug: "index" },
   ];
 

package/src/codegen/generate-registry.test.ts

@@ -69,7 +69,7 @@ describe("buildRegistry", () => {
         typeName: "Test::S3::Bucket",
         attributes: [],
         properties: [],
-        propertyTypes: [{ name: "Bucket_Versioning", cfnType: "Versioning" }],
+        propertyTypes: [{ name: "Bucket_Versioning", specType: "Versioning" }],
       },
     ];
     const naming = makeNaming(resources);

package/src/codegen/generate-registry.ts

@@ -15,11 +15,11 @@ export interface RegistryResource {
   typeName: string;
   attributes: { name: string }[];
   properties: { name: string; constraints: PropertyConstraints }[];
-  propertyTypes: { name: string; cfnType: string }[];
+  propertyTypes: { name: string; specType: string }[];
 }
 
 export interface RegistryConfig<E> {
-  /** Short name extractor (e.g. cfnShortName). */
+  /** Short name extractor (e.g. shortName from the spec type). */
   shortName: (typeName: string) => string;
   /** Build a resource entry from parsed data. */
   buildEntry: (
@@ -80,7 +80,7 @@ export function buildRegistry<E>(
     for (const pt of r.propertyTypes) {
       const defName = extractDefName(pt.name, shortName);
       const ptName = propertyTypeName(tsName, defName);
-      const ptEntry = config.buildPropertyEntry(typeName, pt.cfnType);
+      const ptEntry = config.buildPropertyEntry(typeName, pt.specType);
       entries[ptName] = ptEntry;
 
       if (ptAliases) {

package/src/codegen/package.ts

@@ -5,7 +5,7 @@
  * assemble BundleSpec → compute integrity → attach metadata.
  */
 
-import { readFileSync, readdirSync } from "fs";
+import { readFileSync, readdirSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import type { BundleSpec, LexiconManifest } from "../lexicon";
 import { computeIntegrity } from "../lexicon-integrity";
@@ -147,6 +147,33 @@ export function collectRules(
   return rules;
 }
 
+/**
+ * Write a BundleSpec to the given dist directory.
+ *
+ * Creates the directory structure and writes all artifacts:
+ * manifest.json, meta.json, types/index.d.ts, rules/*, skills/*, integrity.json.
+ */
+export function writeBundleSpec(spec: BundleSpec, distDir: string): void {
+  mkdirSync(join(distDir, "types"), { recursive: true });
+  mkdirSync(join(distDir, "rules"), { recursive: true });
+  mkdirSync(join(distDir, "skills"), { recursive: true });
+
+  writeFileSync(join(distDir, "manifest.json"), JSON.stringify(spec.manifest, null, 2));
+  writeFileSync(join(distDir, "meta.json"), spec.registry);
+  writeFileSync(join(distDir, "types", "index.d.ts"), spec.typesDTS);
+
+  for (const [name, content] of spec.rules) {
+    writeFileSync(join(distDir, "rules", name), content);
+  }
+  for (const [name, content] of spec.skills) {
+    writeFileSync(join(distDir, "skills", name), content);
+  }
+
+  if (spec.integrity) {
+    writeFileSync(join(distDir, "integrity.json"), JSON.stringify(spec.integrity, null, 2));
+  }
+}
+
 /**
  * Collect skills from a plugin's skill definitions.
  */

package/src/codegen/validate.ts

@@ -141,3 +141,19 @@ export async function validateLexiconArtifacts(config: LexiconValidationConfig):
     checks,
   };
 }
+
+/**
+ * Print validation results to stderr and throw on failure.
+ */
+export function printValidationResult(result: ValidateResult): void {
+  for (const check of result.checks) {
+    const status = check.ok ? "OK" : "FAIL";
+    const msg = check.error ? ` — ${check.error}` : "";
+    console.error(`  [${status}] ${check.name}${msg}`);
+  }
+
+  if (!result.success) {
+    throw new Error("Validation failed");
+  }
+  console.error("All validation checks passed.");
+}

package/src/discovery/collect.ts

@@ -1,11 +1,14 @@
 import { isDeclarable, type Declarable } from "../declarable";
 import { isCompositeInstance, expandComposite } from "../composite";
+import { isLexiconOutput } from "../lexicon-output";
 import { DiscoveryError } from "../errors";
 
 /**
  * Collects all declarable entities from imported modules.
  * CompositeInstance exports are expanded into individual entities
  * with `{exportName}_{memberName}` naming.
+ * LexiconOutput exports are also collected so that build() can
+ * extract them and pass them to the serializer.
  *
  * @param modules - Array of module records with their exports
  * @returns Map of export name to Declarable entity
@@ -43,6 +46,10 @@ export function collectEntities(
           }
           entities.set(expandedName, entity);
         }
+      } else if (isLexiconOutput(value)) {
+        // LexiconOutput is not a Declarable but build() expects to find them
+        // in the entities map so it can collect and pass them to serializers
+        entities.set(name, value as unknown as Declarable);
       }
     }
   }

package/src/discovery/files.ts

@@ -30,12 +30,12 @@ export async function findInfraFiles(path: string): Promise<string[]> {
       }
 
       if (entry.isDirectory()) {
-        // Child project boundary — a directory with its own barrel file is a
-        // separate scope, but only if we've already found the project's own
-        // source root (the first barrel directory). The project's own src/
-        // with _.ts is the source root, not a child project.
-        const barrelPath = join(fullPath, "_.ts");
-        if (existsSync(barrelPath)) {
+        // Child project boundary — a directory with its own chant.config.ts
+        // is a separate scope, but only if we've already found the project's
+        // own source root. The first config directory is the source root, not
+        // a child project.
+        const configPath = join(fullPath, "chant.config.ts");
+        if (existsSync(configPath)) {
           if (sourceRoot === null) {
             sourceRoot = fullPath;
           } else {

package/src/discovery/import.ts

@@ -11,7 +11,7 @@ export async function importModule(
   path: string
 ): Promise<Record<string, unknown>> {
   try {
-    return require(path);
+    return await import(path);
   } catch (error) {
     const message =
       error instanceof Error ? error.message : "Unknown import error";

package/src/index.ts

@@ -42,7 +42,6 @@ export * from "./lexicon-schema";
 export * from "./config";
 export * from "./validation";
 export * from "./project-validation";
-export { barrel } from "./barrel";
 export * from "./codegen/naming";
 export * from "./codegen/fetch";
 export * from "./codegen/generate";

package/src/lint/engine.ts

@@ -1,4 +1,4 @@
-import type { LintRule, LintDiagnostic, LintContext, LintRunOptions } from "./rule";
+import type { LintRule, LintDiagnostic, LintContext } from "./rule";
 import { parseFile } from "./parser";
 import { readFileSync } from "fs";
 
@@ -120,7 +120,6 @@ export async function runLint(
   files: string[],
   rules: LintRule[],
   ruleOptions?: Map<string, Record<string, unknown>>,
-  runOptions?: LintRunOptions,
 ): Promise<LintDiagnostic[]> {
   const allDiagnostics: LintDiagnostic[] = [];
   const allRuleIds = new Set(rules.map((r) => r.id));
@@ -140,9 +139,6 @@ export async function runLint(
         entities: [],
         filePath,
         lexicon: undefined,
-        barrelExports: runOptions?.barrelExports,
-        projectExports: runOptions?.projectExports,
-        projectScan: runOptions?.projectScan,
       };
 
       // Execute each rule

package/src/lint/rule.ts

@@ -56,24 +56,6 @@ export interface LintContext {
   filePath: string;
   /** Optional lexicon context (undefined for core rules) */
   lexicon?: string;
-  /** Export names from the barrel file (for EVL008) */
-  barrelExports?: Set<string>;
-  /** All project exports keyed by name (for EVL008) */
-  projectExports?: Map<string, { file: string; className: string }>;
-  /** Project scan result (for COR016) */
-  projectScan?: import("../project/scan").ProjectScan;
-}
-
-/**
- * Options for extending the lint context with project-level information
- */
-export interface LintRunOptions {
-  /** Export names from the barrel file */
-  barrelExports?: Set<string>;
-  /** All project exports keyed by name */
-  projectExports?: Map<string, { file: string; className: string }>;
-  /** Project scan result (for COR016) */
-  projectScan?: import("../project/scan").ProjectScan;
 }
 
 /**