add tests for cli

package.json

···
   "description": "TypeSpec-based IDL for ATProto Lexicons",
   "scripts": {
     "build": "pnpm -r build",
-    "test": "pnpm --filter @typelex/emitter test",
+    "test": "pnpm -r test",
     "test:watch": "pnpm --filter @typelex/emitter test:watch",
     "example": "pnpm --filter @typelex/example build",
     "playground": "pnpm --filter @typelex/playground dev",

packages/cli/package.json

···
     "build": "tsc",
     "clean": "rm -rf dist",
     "watch": "tsc --watch",
+    "test": "npm run build && vitest run",
+    "test:watch": "npm run build && vitest watch",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
···
   "license": "MIT",
   "dependencies": {
     "@typespec/compiler": "^1.4.0",
+    "globby": "^14.0.0",
     "picocolors": "^1.1.1",
     "yargs": "^18.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@types/yargs": "^17.0.33",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0",
+    "@typelex/emitter": "workspace:*"
   },
   "peerDependencies": {
     "@typelex/emitter": "^0.2.0"

packages/cli/src/commands/init.ts

···
 
 function gradientText(text: string): string {
   const colors = [
-    '\x1b[38;5;33m',
-    '\x1b[38;5;69m',
-    '\x1b[38;5;99m',
-    '\x1b[38;5;133m',
-    '\x1b[38;5;170m',
-    '\x1b[38;5;170m',
-    '\x1b[38;5;133m',
+    "\x1b[38;5;33m",
+    "\x1b[38;5;69m",
+    "\x1b[38;5;99m",
+    "\x1b[38;5;133m",
+    "\x1b[38;5;170m",
+    "\x1b[38;5;170m",
+    "\x1b[38;5;133m",
   ];
-  const reset = '\x1b[0m';
+  const reset = "\x1b[0m";
 
-  return text.split('').map((char, i) => {
-    const colorIndex = Math.floor((i / text.length) * colors.length);
-    return colors[colorIndex] + char;
-  }).join('') + reset;
+  return (
+    text
+      .split("")
+      .map((char, i) => {
+        const colorIndex = Math.floor((i / text.length) * colors.length);
+        return colors[colorIndex] + char;
+      })
+      .join("") + reset
+  );
 }
 
 function createMainTemplate(namespace: string): string {
···
   });
 
   return new Promise((resolve) => {
-    rl.question(`Enter your app's root namespace (e.g. ${pc.cyan("com.example.*")}): `, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
+    rl.question(
+      `Enter your app's root namespace (e.g. ${pc.cyan("com.example.*")}): `,
+      (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      },
+    );
   });
 }
 
-export async function initCommand(isSetup: boolean = false, flags: string[] = []): Promise<void> {
+export async function initCommand(
+  isSetup: boolean = false,
+  flags: string[] = [],
+): Promise<void> {
   const originalCwd = process.cwd();
 
   // Find nearest package.json upward
···
 
   // Install dependencies
   await new Promise<void>((resolvePromise, reject) => {
-    const args = packageManager === "npm"
-      ? ["install", "--save-dev", "@typelex/cli@latest", "@typelex/emitter@latest"]
-      : ["add", "-D", "@typelex/cli@latest", "@typelex/emitter@latest"];
+    const args =
+      packageManager === "npm"
+        ? [
+            "install",
+            "--save-dev",
+            "@typelex/cli@latest",
+            "@typelex/emitter@latest",
+          ]
+        : ["add", "-D", "@typelex/cli@latest", "@typelex/emitter@latest"];
 
     // Add any additional flags
     args.push(...flags);
···
 
     install.on("close", (code) => {
       if (code === 0) {
-        console.log(`\n${pc.green("✓")} Installed ${pc.dim("@typelex/cli")} and ${pc.dim("@typelex/emitter")}\n`);
+        console.log(
+          `\n${pc.green("✓")} Installed ${pc.dim("@typelex/cli")} and ${pc.dim("@typelex/emitter")}\n`,
+        );
         resolvePromise();
       } else {
         console.error(pc.red("✗ Failed to install dependencies"));
···
     : lexiconsDir || "./lexicons";
 
   // Inform about external lexicons
-  console.log(`\nLexicons other than ${pc.cyan(namespace)} will be considered external.`);
-  console.log(`Put them into the ${pc.cyan(displayLexiconsPath)} folder as JSON.\n`);
+  console.log(
+    `\nLexicons other than ${pc.cyan(namespace)} will be considered external.`,
+  );
+  console.log(
+    `Put them into the ${pc.cyan(displayLexiconsPath)} folder as JSON.\n`,
+  );
 
   // Create typelex directory
   await mkdir(typelexDir, { recursive: true });
···
     await access(mainTspPath);
     const content = await readFile(mainTspPath, "utf-8");
     if (content.trim().length > 0) {
-      console.log(`${pc.green("✓")} ${pc.cyan("typelex/main.tsp")} already exists, skipping`);
+      console.log(
+        `${pc.green("✓")} ${pc.cyan("typelex/main.tsp")} already exists, skipping`,
+      );
       shouldCreateMain = false;
     }
   } catch {
···
     }
     if (!packageJson.scripts["build:typelex"]) {
       const outFlag = lexiconsDir ? ` --out ${lexiconsDir}` : "";
-      packageJson.scripts["build:typelex"] = `typelex compile ${namespace}${outFlag}`;
-      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
-      console.log(`${pc.green("✓")} Added ${pc.cyan("build:typelex")} script to ${pc.cyan("package.json")}`);
+      packageJson.scripts["build:typelex"] =
+        `typelex compile ${namespace}${outFlag}`;
+      await writeFile(
+        packageJsonPath,
+        JSON.stringify(packageJson, null, 2) + "\n",
+        "utf-8",
+      );
+      console.log(
+        `${pc.green("✓")} Added ${pc.cyan("build:typelex")} script to ${pc.cyan("package.json")}`,
+      );
       if (hasLocalLexicons) {
-        console.log(pc.dim(`  Using existing lexicons directory: ${pc.cyan("./lexicons")}`));
+        console.log(
+          pc.dim(
+            `  Using existing lexicons directory: ${pc.cyan("./lexicons")}`,
+          ),
+        );
       } else if (lexiconsDir) {
-        console.log(pc.dim(`  Using existing lexicons directory: ${pc.cyan(lexiconsDir)}`));
+        console.log(
+          pc.dim(
+            `  Using existing lexicons directory: ${pc.cyan(lexiconsDir)}`,
+          ),
+        );
       }
     } else {
-      console.log(`${pc.green("✓")} ${pc.cyan("build:typelex")} script already exists in ${pc.cyan("package.json")}`);
+      console.log(
+        `${pc.green("✓")} ${pc.cyan("build:typelex")} script already exists in ${pc.cyan("package.json")}`,
+      );
     }
   } catch (err) {
-    console.warn(pc.yellow(`⚠ Could not update ${pc.cyan("package.json")}:`), (err as Error).message);
+    console.warn(
+      pc.yellow(`⚠ Could not update ${pc.cyan("package.json")}:`),
+      (err as Error).message,
+    );
   }
 
   console.log(`\n${pc.green("✓")} ${pc.bold("All set!")}`);
   console.log(`\n${pc.bold("Next steps:")}`);
-  console.log(`  ${pc.dim("1.")} Edit ${pc.cyan("typelex/main.tsp")} to define your lexicons`);
-  console.log(`  ${pc.dim("2.")} Keep putting external lexicons into ${pc.cyan(displayLexiconsPath)}`);
-  console.log(`  ${pc.dim("3.")} Run ${pc.cyan("npm run build:typelex")} to compile to JSON`);
+  console.log(
+    `  ${pc.dim("1.")} Edit ${pc.cyan("typelex/main.tsp")} to define your lexicons`,
+  );
+  console.log(
+    `  ${pc.dim("2.")} Keep putting external lexicons into ${pc.cyan(displayLexiconsPath)}`,
+  );
+  console.log(
+    `  ${pc.dim("3.")} Run ${pc.cyan("npm run build:typelex")} to compile to JSON`,
+  );
 }

packages/cli/test/helpers/test-project.ts

···
+import { mkdtemp, rm, mkdir, writeFile, readFile, readdir, stat } from "fs/promises";
+import { join, resolve, dirname } from "path";
+import { tmpdir } from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export interface TestProjectOptions {
+  packageManager?: "npm" | "pnpm";
+}
+
+export class TestProject {
+  public readonly path: string;
+  public scenarioPath?: string;
+  private cleanupHandlers: Array<() => Promise<void>> = [];
+
+  constructor(path: string) {
+    this.path = path;
+  }
+
+  static async create(options: TestProjectOptions = {}): Promise<TestProject> {
+    const tmpDir = await mkdtemp(join(tmpdir(), "typelex-test-"));
+    const project = new TestProject(tmpDir);
+
+    // Create lock file based on package manager (scenarios provide their own package.json and lexicons)
+    if (options.packageManager === "pnpm") {
+      await writeFile(join(tmpDir, "pnpm-lock.yaml"), "lockfileVersion: '6.0'\n");
+    } else if (options.packageManager === "npm") {
+      // npm is default, no lock file needed for detection
+    }
+
+    return project;
+  }
+
+  async cleanup(): Promise<void> {
+    for (const handler of this.cleanupHandlers) {
+      await handler();
+    }
+    await rm(this.path, { recursive: true, force: true });
+  }
+
+  async writeFile(relativePath: string, content: string): Promise<void> {
+    const fullPath = join(this.path, relativePath);
+    await mkdir(join(fullPath, ".."), { recursive: true });
+    await writeFile(fullPath, content);
+  }
+
+  async readFile(relativePath: string): Promise<string> {
+    return readFile(join(this.path, relativePath), "utf-8");
+  }
+
+  async fileExists(relativePath: string): Promise<boolean> {
+    try {
+      await stat(join(this.path, relativePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async readJson(relativePath: string): Promise<unknown> {
+    const content = await this.readFile(relativePath);
+    return JSON.parse(content);
+  }
+
+  async getDirectoryContents(relativePath: string = ""): Promise<string[]> {
+    const fullPath = join(this.path, relativePath);
+    try {
+      return await readdir(fullPath);
+    } catch {
+      return [];
+    }
+  }
+
+  async runCommand(
+    command: string,
+    args: string[],
+    options: { input?: string; env?: Record<string, string>; cwd?: string } = {}
+  ): Promise<{ stdout: string; stderr: string; exitCode: number; output: string }> {
+    return new Promise((promiseResolve, promiseReject) => {
+      // Add monorepo node_modules/.bin to PATH for tsp and other tools
+      const monorepoRoot = resolve(__dirname, "../../../..");
+      const tspBinPath = join(monorepoRoot, "node_modules/.bin");
+      const envPath = options.env?.PATH || process.env.PATH || "";
+      const newPath = `${tspBinPath}:${envPath}`;
+
+      const child = spawn(command, args, {
+        cwd: options.cwd || this.path,
+        env: { ...process.env, ...options.env, PATH: newPath },
+      });
+
+      let stdout = "";
+      let stderr = "";
+
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+
+      if (options.input) {
+        child.stdin?.write(options.input);
+        child.stdin?.end();
+      }
+
+      child.on("close", (exitCode) => {
+        promiseResolve({
+          stdout,
+          stderr,
+          exitCode: exitCode ?? 0,
+          output: stdout + stderr  // Combined output for easier testing
+        });
+      });
+
+      child.on("error", promiseReject);
+    });
+  }
+
+  async runTypelex(args: string[], options?: { input?: string; cwd?: string }): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    output: string; // Combined stdout + stderr
+  }> {
+    // Use the local CLI from the monorepo
+    const cliPath = resolve(__dirname, "../../dist/cli.js");
+    const result = await this.runCommand("node", [cliPath, ...args], options);
+    return {
+      ...result,
+      output: result.stdout + result.stderr,
+    };
+  }
+
+  async compile(namespace: string, outDir: string = "./lexicons", options?: { cwd?: string }): Promise<void> {
+    const result = await this.runTypelex(["compile", namespace, "--out", outDir], options);
+    if (result.exitCode !== 0) {
+      throw new Error(`Compilation failed: ${result.output}`);
+    }
+  }
+
+  async init(namespace: string, options?: { cwd?: string }): Promise<void> {
+    const result = await this.runTypelex(["init", "--setup"], {
+      input: `${namespace}\n`,
+      ...options,
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Init failed: ${result.output}`);
+    }
+  }
+
+  async runBuildScript(options?: { cwd?: string }): Promise<{stdout: string; stderr: string}> {
+    const result = await this.runCommand("npm", ["run", "build:typelex"], options);
+    if (result.exitCode !== 0) {
+      throw new Error(`Build failed with exit code ${result.exitCode}:\n${result.output}`);
+    }
+    return { stdout: result.stdout, stderr: result.stderr };
+  }
+
+  async expectBuildToFail(options?: { cwd?: string }): Promise<{stdout: string; stderr: string; output: string}> {
+    const result = await this.runCommand("npm", ["run", "build:typelex"], options);
+    if (result.exitCode === 0) {
+      throw new Error(`Expected build to fail but it succeeded`);
+    }
+    return { stdout: result.stdout, stderr: result.stderr, output: result.output };
+  }
+
+  /**
+   * Compare files in the project against an expected directory
+   * Only checks files that exist in expectedDir
+   */
+  async compareTo(expectedSubdir: string = "expected"): Promise<void> {
+    const { readdir } = await import("fs/promises");
+
+    if (!this.scenarioPath) {
+      throw new Error("scenarioPath not set on TestProject");
+    }
+
+    const expectedDir = join(this.scenarioPath, expectedSubdir);
+
+    // Helper to recursively list all files in a directory
+    async function listAllFiles(dir: string, prefix: string = ""): Promise<string[]> {
+      const files: string[] = [];
+      try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name);
+          const relPath = prefix ? join(prefix, entry.name) : entry.name;
+          if (entry.isDirectory()) {
+            files.push(...await listAllFiles(fullPath, relPath));
+          } else {
+            files.push(relPath);
+          }
+        }
+      } catch {
+        // Directory doesn't exist
+      }
+      return files.sort();
+    }
+
+    async function compareRecursive(relPath: string = "") {
+      const expectedPath = join(expectedDir, relPath);
+      const actualPath = join(this.path, relPath);
+
+      const entries = await readdir(expectedPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const entryRelPath = join(relPath, entry.name);
+
+        if (entry.isDirectory()) {
+          await compareRecursive.call(this, entryRelPath);
+        } else {
+          const expected = await readFile(join(expectedDir, entryRelPath), "utf-8");
+
+          let actual: string;
+          try {
+            actual = await readFile(join(this.path, entryRelPath), "utf-8");
+          } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+              // File is missing - show what files actually exist
+              const actualFiles = await listAllFiles(this.path);
+              throw new Error(
+                `Expected file not found: ${entryRelPath}\n\n` +
+                `Actual files in project:\n${actualFiles.map(f => `  ${f}`).join("\n") || "  (none)"}`
+              );
+            }
+            throw err;
+          }
+
+          if (expected !== actual) {
+            throw new Error(
+              `File mismatch: ${entryRelPath}\n\nExpected:\n${expected}\n\nActual:\n${actual}`
+            );
+          }
+        }
+      }
+    }
+
+    await compareRecursive.call(this);
+  }
+
+  /**
+   * Mock npm/pnpm install by creating node_modules structure
+   * Links to the real packages from the monorepo
+   */
+  async mockInstall(): Promise<void> {
+    const nodeModulesPath = join(this.path, "node_modules");
+    await mkdir(nodeModulesPath, { recursive: true });
+    await mkdir(join(nodeModulesPath, ".bin"), { recursive: true });
+    await mkdir(join(nodeModulesPath, "@typelex"), { recursive: true });
+    await mkdir(join(nodeModulesPath, "@typespec"), { recursive: true });
+
+    // Get paths to real packages in monorepo
+    const monorepoRoot = resolve(__dirname, "../../../..");
+    const cliPackagePath = resolve(monorepoRoot, "packages/cli");
+    const emitterPackagePath = resolve(monorepoRoot, "packages/emitter");
+    const typespecCompilerPath = resolve(monorepoRoot, "node_modules/@typespec/compiler");
+
+    // Create symlinks to real packages
+    const { symlink } = await import("fs/promises");
+
+    try {
+      await symlink(cliPackagePath, join(nodeModulesPath, "@typelex/cli"), "dir");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+    }
+
+    try {
+      await symlink(emitterPackagePath, join(nodeModulesPath, "@typelex/emitter"), "dir");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+    }
+
+    try {
+      await symlink(typespecCompilerPath, join(nodeModulesPath, "@typespec/compiler"), "dir");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+    }
+
+    // Create bin symlink for typelex CLI
+    const cliPath = resolve(cliPackagePath, "dist/cli.js");
+    try {
+      await symlink(cliPath, join(nodeModulesPath, ".bin/typelex"), "file");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+    }
+  }
+}

packages/cli/test/scenarios.test.ts

···
+import { describe, it, afterEach } from "vitest";
+import { readdirSync, statSync, existsSync } from "fs";
+import { readFile, readdir } from "fs/promises";
+import { join, dirname, relative } from "path";
+import { fileURLToPath } from "url";
+import { TestProject } from "./helpers/test-project.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const SCENARIOS_DIR = join(__dirname, "scenarios");
+
+async function copyDirRecursive(src: string, dest: string, project: TestProject) {
+  const { mkdir } = await import("fs/promises");
+  const entries = await readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      // Create the directory in destination (even if empty)
+      const relativePath = relative(project.path, destPath);
+      await mkdir(join(project.path, relativePath), { recursive: true });
+      await copyDirRecursive(srcPath, destPath, project);
+    } else {
+      const content = await readFile(srcPath, "utf-8");
+      const relativePath = relative(project.path, destPath);
+      await project.writeFile(relativePath, content);
+    }
+  }
+}
+
+describe("CLI scenarios", () => {
+  let project: TestProject;
+
+  afterEach(async () => {
+    if (project) {
+      await project.cleanup();
+    }
+  });
+
+  // Auto-discover scenario directories
+  const scenarios = readdirSync(SCENARIOS_DIR)
+    .map((name) => join(SCENARIOS_DIR, name))
+    .filter((path) => statSync(path).isDirectory())
+    .filter((path) => existsSync(join(path, "test.ts")));
+
+  for (const scenarioPath of scenarios) {
+    const scenarioName = scenarioPath.split("/").pop()!;
+
+    it(scenarioName, async () => {
+      // Load test module to get config
+      const testModule = await import(join(scenarioPath, "test.ts"));
+      if (typeof testModule.run !== "function") {
+        throw new Error(`${scenarioName}/test.ts must export a run() function`);
+      }
+
+      // Create project
+      project = await TestProject.create({
+        packageManager: testModule.packageManager || "npm",
+      });
+      project.scenarioPath = scenarioPath;
+
+      // Copy project files
+      const projectDir = join(scenarioPath, "project");
+      if (existsSync(projectDir)) {
+        await copyDirRecursive(projectDir, project.path, project);
+      }
+
+      await project.mockInstall();
+
+      // Run the scenario
+      await testModule.run(project);
+    });
+  }
+});

packages/cli/test/scenarios/README.md

···
+# Test Scenarios
+
+This directory contains declarative test scenarios for the typelex CLI.
+
+## Philosophy
+
+**These tests focus on CLI workflows, NOT language features.**
+
+The CLI's job is to:
+1. Find/create lexicons directories (`./lexicons`, `../lexicons`)
+2. Read existing JSON lexicons from disk
+3. Generate `externals.tsp` from those JSON files
+4. Run compilation while preserving external lexicons
+5. Manage paths and directory structures correctly
+
+Language features (syntax, types, decorators) are tested in the emitter package.
+
+## Test Coverage
+
+All non-trivial branches in the CLI code are tested. Each test was verified by:
+1. Breaking the code (commenting out the condition)
+2. Verifying the test fails
+3. Fixing the code and verifying the test passes
+
+### Current Scenarios (8 total)
+
+**External Lexicon Workflows** (The Core CLI Functionality):
+- `compile-with-external-atproto` - Real JSON→TSP→JSON cycle, externals preserved
+- `compile-to-parent-lexicons` - Compile with `../lexicons` directory
+- `compile-idempotent` - Deterministic output across runs
+
+**Init Workflows** (Directory Detection & File Management):
+- `init-finds-current-lexicons` - Detects `./lexicons`, no `--out` flag
+- `init-finds-parent-lexicons` - Detects `../lexicons`, adds `--out ../lexicons`
+- `init-overwrites-empty-main` - Empty `main.tsp` gets overwritten
+- `init-preserves-build-script` - Existing `build:typelex` not overwritten
+
+**Validation** (Error Handling):
+- `validation-errors` - Namespace format, path validation, file structure
+
+### Branch Coverage Matrix
+
+| File | Line | Branch | Tested By |
+|------|------|--------|-----------|
+| compile.ts | 21 | Path validation | validation-errors |
+| ensure-imports.ts | 20 | First line check | validation-errors |
+| ensure-imports.ts | 26 | Second line check | validation-errors |
+| ensure-imports.ts | 32 | File not found | validation-errors |
+| externals-generator.ts | 87 | No externals case | All compile scenarios |
+| init.ts | 194 | Local lexicons dir | init-finds-current-lexicons |
+| init.ts | 203 | Parent lexicons dir | init-finds-parent-lexicons |
+| init.ts | 231 | Empty main.tsp | init-overwrites-empty-main |
+| init.ts | 252 | No scripts object | All init scenarios (crashes without) |
+| init.ts | 255 | Script exists | init-preserves-build-script |
+
+## Structure
+
+Each scenario directory contains:
+
+```
+scenario-name/
+  project/              # Realistic project structure
+    package.json
+    typelex/
+      main.tsp         # Input TypeSpec
+      externals.tsp    # Boilerplate or generated
+    lexicons/          # REAL JSON FILES (not mocked!)
+      com/atproto/...  # Checked-in external lexicons
+  expected/            # Expected outputs (optional)
+    lexicons/
+      com/myapp/...
+  test.ts              # Test logic with run() function
+```
+
+## Writing Tests
+
+The `test.ts` exports a `run()` function that performs assertions:
+
+```typescript
+import { expect } from "vitest";
+
+export const namespace = "com.myapp.*";
+
+export async function run(project, scenarioPath) {
+  // Compile
+  await project.compile(namespace);
+
+  // Assert on behavior
+  const externals = await project.readFile("typelex/externals.tsp");
+  expect(externals).toContain("namespace com.atproto.label.defs");
+
+  // Verify files match expected
+  await verifyExpectedFiles(join(scenarioPath, "expected"), project);
+}
+```
+
+Available exports:
+- `namespace` - Default namespace
+- `packageManager` - "npm" or "pnpm"
+- `lexiconsDirLocation` - "current", "parent"
+- `run(project, scenarioPath)` - Test logic
+
+Available helpers:
+- `project.compile(namespace, outDir?)` - Compile (throws on error)
+- `project.init(namespace)` - Run init (throws on error)
+- `project.runTypelex(args, options?)` - Run any command
+- `project.writeFile/readFile/readJson/fileExists`
+- `verifyExpectedFiles(expectedDir, project)` - Match expected outputs
+
+## Key Insight
+
+Most tests should have **real lexicons/ folders with JSON files**. This tests the actual CLI behavior: reading JSON from disk, generating externals.tsp, and emitting new JSON that correctly references external lexicons.
+
+Don't test language features here - test file I/O, directory management, and the JSON↔TSP↔JSON workflow.
+
+## Adding New Tests
+
+When adding a new scenario, verify it catches bugs:
+1. Write the test
+2. Break the corresponding code
+3. Run tests - should FAIL
+4. Fix the code
+5. Run tests - should PASS

packages/cli/test/scenarios/basic/expected/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/basic/expected/lexicons/com/test/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.test.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        },
+        "required": [
+          "text",
+          "createdAt"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/basic/expected/package.json

···
+{
+  "name": "test-idempotent",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.test.*"
+  }
+}

packages/cli/test/scenarios/basic/expected/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.test.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.atproto.label.defs {
+  model SelfLabel { }
+  model SelfLabels { }
+}

packages/cli/test/scenarios/basic/expected/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.test.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    @required createdAt: datetime;
+  }
+}

packages/cli/test/scenarios/basic/project/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/basic/project/package.json

···
+{"name":"test-idempotent","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/basic/test.ts

···
+export async function run(project) {
+  await project.init("com.test.*");
+
+  await project.runBuildScript();
+  await project.compareTo("expected");
+
+  // Second build - verify idempotency
+  await project.runBuildScript();
+  await project.compareTo("expected");
+}

packages/cli/test/scenarios/init-preserves-main/expected/lexicons/com/example/custom.json

···
+{
+  "lexicon": 1,
+  "id": "com.example.custom",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "foo": {
+            "type": "string"
+          },
+          "bar": {
+            "type": "integer"
+          }
+        },
+        "required": [
+          "foo",
+          "bar"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/init-preserves-main/expected/package.json

···
+{
+  "name": "test-init-preserves-main",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.example.*"
+  }
+}

packages/cli/test/scenarios/init-preserves-main/expected/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.example.*)
+// No external lexicons found

packages/cli/test/scenarios/init-preserves-main/expected/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.example.custom {
+  @rec("tid")
+  model Main {
+    @required foo: string;
+    @required bar: integer;
+  }
+}

packages/cli/test/scenarios/init-preserves-main/project/package.json

···
+{"name":"test-init-preserves-main","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/init-preserves-main/project/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.example.custom {
+  @rec("tid")
+  model Main {
+    @required foo: string;
+    @required bar: integer;
+  }
+}

packages/cli/test/scenarios/init-preserves-main/test.ts

···
+export async function run(project) {
+  await project.init("com.example.*");
+  await project.runBuildScript();
+  await project.compareTo("expected");
+
+  // Second build - verify idempotency
+  await project.runBuildScript();
+  await project.compareTo("expected");
+}

packages/cli/test/scenarios/missing-dependency/expected/lexicons/com/external/media/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.external.media.defs",
+  "defs": {
+    "video": {
+      "type": "object",
+      "properties": {
+        "url": {
+          "type": "string",
+          "format": "uri"
+        },
+        "mimeType": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "url"
+      ]
+    }
+  }
+}

packages/cli/test/scenarios/missing-dependency/expected/lexicons/com/myapp/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.myapp.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "video": {
+            "type": "ref",
+            "ref": "com.external.media.defs#video"
+          }
+        },
+        "required": [
+          "text"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/missing-dependency/expected/package.json

···
+{
+  "name": "test-missing-dependency",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myapp.*"
+  }
+}

packages/cli/test/scenarios/missing-dependency/expected/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.myapp.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.external.media.defs {
+  model Video { }
+}

packages/cli/test/scenarios/missing-dependency/expected/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    video?: com.external.media.defs.Video;
+  }
+}

packages/cli/test/scenarios/missing-dependency/project/package.json

···
+{"name":"test-missing-dependency","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/missing-dependency/test.ts

···
+export async function run(project) {
+  await project.init("com.myapp.*");
+
+  // Edit main.tsp to reference a missing external lexicon
+  await project.writeFile("typelex/main.tsp", `import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    video?: com.external.media.defs.Video;
+  }
+}
+`);
+
+  // Build should fail because com.external.media.defs doesn't exist
+  const failure = await project.expectBuildToFail();
+  if (!failure.output.includes("com.external.media.defs")) {
+    throw new Error(`Expected error about missing com.external.media.defs, got: ${failure.output}`);
+  }
+
+  // Add the missing external lexicon
+  await project.writeFile("lexicons/com/external/media/defs.json", JSON.stringify({
+    "lexicon": 1,
+    "id": "com.external.media.defs",
+    "defs": {
+      "video": {
+        "type": "object",
+        "properties": {
+          "url": {
+            "type": "string",
+            "format": "uri"
+          },
+          "mimeType": {
+            "type": "string"
+          }
+        },
+        "required": ["url"]
+      }
+    }
+  }, null, 2) + "\n");
+
+  // Now build should succeed
+  await project.runBuildScript();
+  await project.compareTo("expected");
+
+  // Verify idempotency
+  await project.runBuildScript();
+  await project.compareTo("expected");
+}

packages/cli/test/scenarios/nested-init/expected/lexicons/com/myservice/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.myservice.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        },
+        "required": [
+          "text",
+          "createdAt"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/nested-init/expected/package.json

···
+{
+  "name": "test-nested-init",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myservice.*"
+  }
+}

packages/cli/test/scenarios/nested-init/expected/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.myservice.*)
+// No external lexicons found

packages/cli/test/scenarios/nested-init/expected/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myservice.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    @required createdAt: datetime;
+  }
+}

packages/cli/test/scenarios/nested-init/project/package.json

···
+{"name":"test-nested-init","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/nested-init/test.ts

···
+import { join } from "path";
+
+export async function run(project) {
+  const apiDir = join(project.path, "src/api");
+
+  // Init at root (where package.json is)
+  await project.init("com.myservice.*");
+
+  // Build from nested directory should work (this is what we're testing)
+  await project.runBuildScript({ cwd: apiDir });
+  await project.compareTo("expected");
+
+  // Verify idempotency
+  await project.runBuildScript({ cwd: apiDir });
+  await project.compareTo("expected");
+}

packages/cli/test/scenarios/parent-lexicons/expected1/app/package.json

···
+{
+  "name": "test-parent-lexicons",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myapp.* --out ../lexicons"
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected1/app/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ../lexicons (excluding com.myapp.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.atproto.label.defs {
+  model SelfLabel { }
+  model SelfLabels { }
+}

packages/cli/test/scenarios/parent-lexicons/expected1/app/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    @required createdAt: datetime;
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected1/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected1/lexicons/com/myapp/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.myapp.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        },
+        "required": [
+          "text",
+          "createdAt"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected2/app/package.json

···
+{
+  "name": "test-parent-lexicons",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myapp.* --out ../lexicons"
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected2/app/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ../lexicons (excluding com.myapp.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.atproto.label.defs {
+  model SelfLabel { }
+  model SelfLabels { }
+}

packages/cli/test/scenarios/parent-lexicons/expected2/app/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    labels?: com.atproto.label.defs.SelfLabels;
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected2/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/parent-lexicons/expected2/lexicons/com/myapp/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.myapp.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "labels": {
+            "type": "ref",
+            "ref": "com.atproto.label.defs#selfLabels"
+          }
+        },
+        "required": [
+          "text"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/parent-lexicons/project/app/package.json

···
+{"name":"test-parent-lexicons","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/parent-lexicons/project/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/parent-lexicons/test.ts

···
+import { join } from "path";
+
+export async function run(project) {
+  const appDir = join(project.path, "app");
+
+  await project.init("com.myapp.*", { cwd: appDir });
+
+  // Verify init created a working project with default main.tsp
+  await project.runBuildScript({ cwd: appDir });
+  await project.compareTo("expected1");
+
+  // Edit main.tsp to add a post schema with labels (simulates user editing the file)
+  await project.writeFile("app/typelex/main.tsp", `import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    labels?: com.atproto.label.defs.SelfLabels;
+  }
+}
+`);
+
+  await project.runBuildScript({ cwd: appDir });
+  await project.compareTo("expected2");
+
+  // Third build - verify idempotency
+  await project.runBuildScript({ cwd: appDir });
+  await project.compareTo("expected2");
+}

packages/cli/test/scenarios/validation-errors/project/package.json

···
+{"name":"test-validation","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/validation-errors/test.ts

···
+import { expect } from "vitest";
+
+export async function run(project) {
+  // Test: Namespace must end with .*
+  let result = await project.runTypelex(["compile", "com.example"]);
+  expect(result.exitCode).not.toBe(0);
+  expect(result.output).toContain("namespace must end with .*");
+
+  // Test: Output path must end with 'lexicons'
+  await project.writeFile("typelex/main.tsp", `import "@typelex/emitter";\nimport "./externals.tsp";\n`);
+  await project.writeFile("typelex/externals.tsp", `import "@typelex/emitter";\n`);
+
+  result = await project.runTypelex(["compile", "com.test.*", "--out", "./output"]);
+  expect(result.exitCode).not.toBe(0);
+  expect(result.output).toContain("Output directory must end with 'lexicons'");
+
+  // Test: main.tsp must exist
+  await project.runCommand("rm", ["-rf", "typelex"]);
+  result = await project.runTypelex(["compile", "com.test.*"]);
+  expect(result.exitCode).not.toBe(0);
+  expect(result.output).toContain("main.tsp not found");
+
+  // Test: main.tsp first line must be import "@typelex/emitter"
+  await project.writeFile("typelex/main.tsp", `// wrong first line\nimport "./externals.tsp";\n`);
+  await project.writeFile("typelex/externals.tsp", `import "@typelex/emitter";\n`);
+  result = await project.runTypelex(["compile", "com.test.*"]);
+  expect(result.exitCode).not.toBe(0);
+  expect(result.output).toContain('main.tsp must start with: import "@typelex/emitter"');
+
+  // Test: main.tsp second line must be import "./externals.tsp"
+  await project.writeFile("typelex/main.tsp", `import "@typelex/emitter";\n// wrong second line\n`);
+  result = await project.runTypelex(["compile", "com.test.*"]);
+  expect(result.exitCode).not.toBe(0);
+  expect(result.output).toContain('Line 2 of main.tsp must be: import "./externals.tsp"');
+}

packages/cli/test/scenarios/with-external-lexicons/expected1/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected1/lexicons/com/myapp/post.json

···
+{
+  "lexicon": 1,
+  "id": "com.myapp.post",
+  "defs": {
+    "main": {
+      "type": "record",
+      "key": "tid",
+      "record": {
+        "type": "object",
+        "properties": {
+          "text": {
+            "type": "string"
+          },
+          "createdAt": {
+            "type": "string",
+            "format": "datetime"
+          }
+        },
+        "required": [
+          "text",
+          "createdAt"
+        ]
+      }
+    }
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected1/package.json

···
+{
+  "name": "test-external-lexicons",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myapp.*"
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected1/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.myapp.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.atproto.label.defs {
+  model SelfLabel { }
+  model SelfLabels { }
+}

packages/cli/test/scenarios/with-external-lexicons/expected1/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    @required createdAt: datetime;
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected2/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected2/lexicons/com/myapp/profile.json

···
+{
+  "lexicon": 1,
+  "id": "com.myapp.profile",
+  "defs": {
+    "main": {
+      "type": "object",
+      "properties": {
+        "did": {
+          "type": "string",
+          "format": "did"
+        },
+        "handle": {
+          "type": "string",
+          "format": "handle"
+        },
+        "displayName": {
+          "type": "string"
+        },
+        "labels": {
+          "type": "ref",
+          "ref": "com.atproto.label.defs#selfLabels"
+        }
+      },
+      "required": [
+        "did",
+        "handle"
+      ]
+    }
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected2/package.json

···
+{
+  "name": "test-external-lexicons",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "build:typelex": "typelex compile com.myapp.*"
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/expected2/typelex/externals.tsp

···
+import "@typelex/emitter";
+
+// Generated by typelex from ./lexicons (excluding com.myapp.*)
+// This file is auto-generated. Do not edit manually.
+
+@external
+namespace com.atproto.label.defs {
+  model SelfLabel { }
+  model SelfLabels { }
+}

packages/cli/test/scenarios/with-external-lexicons/expected2/typelex/main.tsp

···
+import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.profile {
+  model Main {
+    @required did: did;
+    @required handle: handle;
+    displayName?: string;
+
+    // Reference to external lexicon
+    labels?: com.atproto.label.defs.SelfLabels;
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/project/lexicons/com/atproto/label/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "selfLabels": {
+      "type": "object",
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      },
+      "required": ["values"]
+    },
+    "selfLabel": {
+      "type": "object",
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128
+        }
+      },
+      "required": ["val"]
+    }
+  }
+}

packages/cli/test/scenarios/with-external-lexicons/project/package.json

···
+{"name":"test-external-lexicons","version":"1.0.0","type":"module"}

packages/cli/test/scenarios/with-external-lexicons/test.ts

···
+export async function run(project) {
+  await project.init("com.myapp.*");
+
+  // Verify init created a working project with default main.tsp
+  await project.runBuildScript();
+  await project.compareTo("expected1");
+
+  // Edit main.tsp to add a profile schema (simulates user editing the file)
+  await project.writeFile("typelex/main.tsp", `import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace com.myapp.profile {
+  model Main {
+    @required did: did;
+    @required handle: handle;
+    displayName?: string;
+
+    // Reference to external lexicon
+    labels?: com.atproto.label.defs.SelfLabels;
+  }
+}
+`);
+
+  await project.runBuildScript();
+  await project.compareTo("expected2");
+
+  // Third build - verify idempotency
+  await project.runBuildScript();
+  await project.compareTo("expected2");
+}

packages/cli/vitest.config.ts

···
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    testTimeout: 60000, // CLI operations can take time
+    hookTimeout: 60000,
+  },
+});

pnpm-lock.yaml

···
 
   packages/cli:
     dependencies:
-      '@typelex/emitter':
-        specifier: ^0.2.0
-        version: 0.2.0(@typespec/compiler@1.4.0(@types/node@20.19.19))
       '@typespec/compiler':
         specifier: ^1.4.0
         version: 1.4.0(@types/node@20.19.19)
+      globby:
+        specifier: ^14.0.0
+        version: 14.1.0
       picocolors:
         specifier: ^1.1.1
         version: 1.1.1
···
         specifier: ^18.0.0
         version: 18.0.0
     devDependencies:
+      '@typelex/emitter':
+        specifier: workspace:*
+        version: link:../emitter
       '@types/node':
         specifier: ^20.0.0
         version: 20.19.19
···
       typescript:
         specifier: ^5.0.0
         version: 5.9.3
+      vitest:
+        specifier: ^1.0.0
+        version: 1.6.1(@types/node@20.19.19)
 
   packages/emitter:
     dependencies:
···
 
   '@ts-morph/common@0.25.0':
     resolution: {integrity: sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg==}
-
-  '@typelex/emitter@0.2.0':
-    resolution: {integrity: sha512-4Iw6VAnd9nCFGOkJcu9utWdmu9ZyPeAb1QX/B7KerGBmfc2FuIDqgZZ/mZ6c56atcZd62pb2oYF/3RgSFhEsoQ==}
-    peerDependencies:
-      '@typespec/compiler': ^1.4.0
 
   '@types/babel__core@7.20.5':
     resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
···
       minimatch: 9.0.5
       path-browserify: 1.0.1
       tinyglobby: 0.2.15
-
-  '@typelex/emitter@0.2.0(@typespec/compiler@1.4.0(@types/node@20.19.19))':
-    dependencies:
-      '@typespec/compiler': 1.4.0(@types/node@20.19.19)
 
   '@types/babel__core@7.20.5':
     dependencies: