@skastr0/quartz-engine 0.2.0

package/dist/index.js

@@ -0,0 +1,2949 @@
+// @bun
+// src/index.ts
+import { version as version2 } from "typescript";
+
+// src/context.ts
+import { resolve as resolve3 } from "path";
+
+// src/discovery.ts
+import { execFileSync } from "child_process";
+import { basename, dirname, join, relative, resolve } from "path";
+import { readdirSync } from "fs";
+
+// src/errors.ts
+class QuartzEngineError extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "QuartzEngineError";
+    this.code = code;
+    this.cause = cause;
+  }
+}
+
+// src/discovery.ts
+var ignoredDirectories = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  "coverage",
+  ".turbo",
+  ".cache"
+]);
+var discoverPackages = (rootDirectory, selectedTsconfigPaths) => {
+  const resolvedRoot = resolve(rootDirectory);
+  try {
+    const tsconfigPaths = selectedTsconfigPaths === undefined ? findTsconfigs(resolvedRoot) : selectedTsconfigPaths.map((tsconfigPath) => resolve(resolvedRoot, tsconfigPath));
+    return toPackageInfo(resolvedRoot, tsconfigPaths);
+  } catch (cause) {
+    throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Could not discover TypeScript packages under ${resolvedRoot}`, cause);
+  }
+};
+var findTsconfigs = (rootDirectory) => {
+  const trackedFiles = getGitTrackedFiles(rootDirectory);
+  if (trackedFiles.length > 0) {
+    return trackedFiles.filter((file) => basename(file) === "tsconfig.json" && !file.includes("node_modules")).map((file) => join(rootDirectory, file));
+  }
+  return walkForTsconfigs(rootDirectory);
+};
+var getGitTrackedFiles = (rootDirectory) => {
+  try {
+    const stdout = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: rootDirectory,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return stdout.trim().split(`
+`).filter((file) => file.length > 0);
+  } catch {
+    return [];
+  }
+};
+var walkForTsconfigs = (directory) => readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+  const path = join(directory, entry.name);
+  if (entry.isDirectory())
+    return ignoredDirectories.has(entry.name) ? [] : walkForTsconfigs(path);
+  return entry.name === "tsconfig.json" ? [path] : [];
+});
+var toPackageInfo = (rootDirectory, tsconfigPaths) => [...new Set(tsconfigPaths.map((tsconfigPath) => resolve(rootDirectory, tsconfigPath)))].map((tsconfigPath) => {
+  const packagePath = dirname(tsconfigPath);
+  const relativePath = relative(rootDirectory, packagePath);
+  return {
+    name: relativePath === "" ? "(root)" : relativePath,
+    path: packagePath,
+    tsconfigPath
+  };
+}).sort((left, right) => {
+  if (left.name === "(root)")
+    return -1;
+  if (right.name === "(root)")
+    return 1;
+  return left.name.localeCompare(right.name);
+});
+
+// src/workspace.ts
+import { existsSync } from "fs";
+import { AsyncLocalStorage } from "async_hooks";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { pathToFileURL } from "url";
+import { version } from "typescript";
+import { API } from "typescript/unstable/async";
+
+// src/diagnostics.ts
+import { DiagnosticCategory } from "typescript/unstable/async";
+var severityFor = (category) => {
+  switch (category) {
+    case DiagnosticCategory.Error:
+      return "error";
+    case DiagnosticCategory.Warning:
+      return "warning";
+    case DiagnosticCategory.Suggestion:
+      return "suggestion";
+    case DiagnosticCategory.Message:
+      return "message";
+  }
+};
+var lineAndColumnAt = (text, position) => {
+  const bounded = Math.max(0, Math.min(position, text.length));
+  let line = 1;
+  let lineStart = 0;
+  for (let index = 0;index < bounded; index += 1) {
+    if (text.charCodeAt(index) === 10) {
+      line += 1;
+      lineStart = index + 1;
+    }
+  }
+  return { line, column: bounded - lineStart + 1 };
+};
+var diagnosticKey = (diagnostic) => [diagnostic.fileName ?? "", diagnostic.pos, diagnostic.end, diagnostic.code, diagnostic.category, diagnostic.text].join("\x00");
+var collectDiagnostics = async (project) => {
+  const diagnosticGroups = await Promise.all([
+    project.program.getConfigFileParsingDiagnostics(),
+    project.program.getSyntacticDiagnostics(),
+    project.program.getSemanticDiagnostics()
+  ]);
+  const diagnostics = diagnosticGroups.flat();
+  const unique = new Map;
+  for (const diagnostic of diagnostics)
+    unique.set(diagnosticKey(diagnostic), diagnostic);
+  const sourceTextByFile = new Map;
+  const sourceTextFor = (fileName) => {
+    const cached = sourceTextByFile.get(fileName);
+    if (cached !== undefined)
+      return cached;
+    const pending = project.program.getSourceFile(fileName).then((sourceFile) => sourceFile?.text ?? null);
+    sourceTextByFile.set(fileName, pending);
+    return pending;
+  };
+  const mapped = await Promise.all([...unique.values()].map(async (diagnostic) => {
+    if (diagnostic.fileName === undefined) {
+      return {
+        file: null,
+        line: null,
+        column: null,
+        endLine: null,
+        endColumn: null,
+        code: diagnostic.code,
+        severity: severityFor(diagnostic.category),
+        message: diagnostic.text
+      };
+    }
+    const sourceText = await sourceTextFor(diagnostic.fileName);
+    const start = sourceText === null ? null : lineAndColumnAt(sourceText, diagnostic.pos);
+    const end = sourceText === null ? null : lineAndColumnAt(sourceText, diagnostic.end);
+    return {
+      file: diagnostic.fileName,
+      line: start?.line ?? null,
+      column: start?.column ?? null,
+      endLine: end?.line ?? null,
+      endColumn: end?.column ?? null,
+      code: diagnostic.code,
+      severity: severityFor(diagnostic.category),
+      message: diagnostic.text
+    };
+  }));
+  return mapped.sort((left, right) => {
+    const fileOrder = (left.file ?? "").localeCompare(right.file ?? "");
+    if (fileOrder !== 0)
+      return fileOrder;
+    return (left.line ?? 0) - (right.line ?? 0) || (left.column ?? 0) - (right.column ?? 0) || left.code - right.code;
+  });
+};
+
+// src/workspace.ts
+var resolveTypeScriptExecutable = () => {
+  const platformPackage = `@typescript/typescript-${process.platform}-${process.arch}`;
+  const executableName = process.platform === "win32" ? "tsc.exe" : "tsc";
+  const executableBase = pathToFileURL(join2(dirname2(process.execPath), "__quartz_resolver.cjs")).href;
+  const resolvers = [createRequire(import.meta.url), createRequire(executableBase)];
+  for (const resolver of resolvers) {
+    const packageJsonCandidates = [];
+    try {
+      const typescriptPackageJson = resolver.resolve("typescript/package.json");
+      packageJsonCandidates.push(createRequire(pathToFileURL(typescriptPackageJson)).resolve(`${platformPackage}/package.json`));
+    } catch {}
+    try {
+      packageJsonCandidates.push(resolver.resolve(`${platformPackage}/package.json`));
+    } catch {}
+    for (const packageJson of packageJsonCandidates) {
+      const executable = join2(dirname2(packageJson), "lib", executableName);
+      if (existsSync(executable))
+        return executable;
+    }
+  }
+  throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Unable to resolve ${platformPackage}. Reinstall Quartz with platform dependencies enabled.`);
+};
+var createRevisionState = (snapshot, revision) => ({
+  snapshot,
+  revision,
+  drained: Promise.withResolvers(),
+  readers: 0,
+  retired: false,
+  disposePromise: null
+});
+
+class QuartzWorkspace {
+  root;
+  configFile;
+  configFiles;
+  #api;
+  #current;
+  #mutationTail = Promise.resolve();
+  #closing = false;
+  #closed = false;
+  #closePromise = null;
+  #retirements = new Set;
+  #activeOperations = 0;
+  #operationsDrained = null;
+  #revisionLease = new AsyncLocalStorage;
+  constructor(root, configFiles, api, state) {
+    this.root = root;
+    this.configFiles = configFiles;
+    this.configFile = configFiles[0];
+    this.#api = api;
+    this.#current = state;
+  }
+  static async open(root, options = {}) {
+    const resolvedRoot = resolve2(root);
+    const primaryConfig = resolve2(resolvedRoot, options.tsconfigPath ?? "tsconfig.json");
+    const configFiles = [
+      primaryConfig,
+      ...(options.tsconfigPaths ?? []).map((configFile) => resolve2(resolvedRoot, configFile))
+    ].filter((configFile, index, all) => all.indexOf(configFile) === index);
+    const api = new API({
+      cwd: resolvedRoot,
+      tsserverPath: options.tsserverPath ?? resolveTypeScriptExecutable(),
+      ...options.collectTiming === undefined ? {} : { collectTiming: options.collectTiming }
+    });
+    try {
+      const snapshot = await api.updateSnapshot({ openProjects: configFiles });
+      const missingConfig = configFiles.find((configFile) => snapshot.getProject(configFile) === undefined);
+      if (missingConfig !== undefined) {
+        await snapshot.dispose();
+        throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `TypeScript did not load the configured project at ${missingConfig}`);
+      }
+      return new QuartzWorkspace(resolvedRoot, configFiles, api, createRevisionState(snapshot, 1));
+    } catch (cause) {
+      await api.close().catch(() => {
+        return;
+      });
+      if (cause instanceof QuartzEngineError)
+        throw cause;
+      throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Failed to open Quartz workspace at ${resolvedRoot}`, cause);
+    }
+  }
+  get metadata() {
+    return {
+      root: this.root,
+      configFile: this.configFile,
+      configFiles: this.configFiles,
+      revision: this.#current?.revision ?? 0,
+      analysisTypescriptVersion: version,
+      closed: this.#closed
+    };
+  }
+  async diagnostics(configFile = this.configFile) {
+    return this.withProject((project) => collectDiagnostics(project), configFile);
+  }
+  getTimingInfo() {
+    this.#assertAcceptingWork();
+    return this.#api.getTimingInfo();
+  }
+  resetTimingInfo() {
+    this.#assertAcceptingWork();
+    return this.#api.resetTimingInfo();
+  }
+  withProject(operation, configFile = this.configFile) {
+    const resolvedConfig = resolve2(configFile);
+    return this.#withProject((state) => {
+      const project = state.snapshot.getProject(resolvedConfig);
+      if (project === undefined) {
+        throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Project is not open at ${resolvedConfig}`);
+      }
+      return operation(project, state.revision);
+    });
+  }
+  async withVirtualFile(tsconfigPath, filePath, content, operation) {
+    this.#assertAcceptingWork();
+    this.#beginOperation();
+    const resolvedConfig = resolve2(tsconfigPath);
+    const resolvedFile = resolve2(filePath);
+    const inheritedLease = this.#revisionLease.getStore();
+    const base = inheritedLease?.active === true ? inheritedLease.state : this.#requireCurrent();
+    const lease = { state: base, active: true };
+    base.readers += 1;
+    try {
+      let result;
+      await this.#revisionLease.run(lease, async () => {
+        await this.#api.runWithTemporaryFileUpdate(base.snapshot, resolvedFile, content, async (temporarySnapshot) => {
+          this.#assertAcceptingWork();
+          const project = await temporarySnapshot.getDefaultProjectForFile(resolvedFile) ?? temporarySnapshot.getProject(resolvedConfig);
+          if (project === undefined) {
+            throw new QuartzEngineError("WORKSPACE_REFRESH_FAILED", `TypeScript did not load a project for temporary file ${resolvedFile}`);
+          }
+          result = await operation(project, resolvedFile);
+        });
+      });
+      return result;
+    } catch (cause) {
+      if (cause instanceof QuartzEngineError)
+        throw cause;
+      throw new QuartzEngineError("WORKSPACE_REFRESH_FAILED", `Temporary file analysis failed for ${resolvedFile}`, cause);
+    } finally {
+      lease.active = false;
+      this.#releaseState(base);
+      this.#endOperation();
+    }
+  }
+  refresh(changes) {
+    this.#assertAcceptingWork();
+    return this.#enqueueMutation(async () => {
+      try {
+        const previous = this.#requireCurrent();
+        const snapshot = await this.#api.updateSnapshot({
+          fileChanges: changes === undefined ? { invalidateAll: true } : {
+            ...changes.changed === undefined ? {} : { changed: changes.changed.map((path) => resolve2(path)) },
+            ...changes.created === undefined ? {} : { created: changes.created.map((path) => resolve2(path)) },
+            ...changes.deleted === undefined ? {} : { deleted: changes.deleted.map((path) => resolve2(path)) }
+          }
+        });
+        const missingConfig = this.configFiles.find((configFile) => snapshot.getProject(configFile) === undefined);
+        if (missingConfig !== undefined) {
+          await snapshot.dispose();
+          throw new QuartzEngineError("WORKSPACE_REFRESH_FAILED", `TypeScript lost the configured project at ${missingConfig}`);
+        }
+        this.#current = createRevisionState(snapshot, previous.revision + 1);
+        this.#retire(previous);
+        return this.metadata;
+      } catch (cause) {
+        if (cause instanceof QuartzEngineError)
+          throw cause;
+        throw new QuartzEngineError("WORKSPACE_REFRESH_FAILED", `Failed to refresh ${this.root}`, cause);
+      }
+    });
+  }
+  close() {
+    if (this.#closePromise !== null)
+      return this.#closePromise;
+    this.#closing = true;
+    this.#closePromise = (async () => {
+      await this.#operationsDrained?.promise;
+      await this.#enqueueMutation(async () => {
+        const current = this.#current;
+        this.#current = null;
+        if (current !== null)
+          this.#retire(current);
+        await Promise.all([...this.#retirements]);
+        await this.#api.close();
+        this.#closed = true;
+      });
+    })();
+    return this.#closePromise;
+  }
+  async#withProject(operation) {
+    this.#assertAcceptingWork();
+    this.#beginOperation();
+    const state = this.#requireCurrent();
+    const lease = { state, active: true };
+    state.readers += 1;
+    try {
+      return await this.#revisionLease.run(lease, () => operation(state));
+    } finally {
+      lease.active = false;
+      this.#releaseState(state);
+      this.#endOperation();
+    }
+  }
+  #beginOperation() {
+    if (this.#activeOperations === 0)
+      this.#operationsDrained = Promise.withResolvers();
+    this.#activeOperations += 1;
+  }
+  #endOperation() {
+    this.#activeOperations -= 1;
+    if (this.#activeOperations === 0) {
+      this.#operationsDrained?.resolve();
+      this.#operationsDrained = null;
+    }
+  }
+  #releaseState(state) {
+    state.readers -= 1;
+    if (state.retired && state.readers === 0)
+      state.drained.resolve();
+  }
+  #enqueueMutation(operation) {
+    const result = this.#mutationTail.then(operation);
+    this.#mutationTail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  }
+  #retire(state) {
+    if (state.disposePromise !== null)
+      return;
+    state.retired = true;
+    if (state.readers === 0)
+      state.drained.resolve();
+    const retirement = state.drained.promise.then(() => state.snapshot.dispose());
+    state.disposePromise = retirement;
+    this.#retirements.add(retirement);
+    retirement.then(() => this.#retirements.delete(retirement), () => this.#retirements.delete(retirement));
+  }
+  #assertAcceptingWork() {
+    if (this.#closing || this.#closed) {
+      throw new QuartzEngineError("WORKSPACE_CLOSED", `Quartz workspace at ${this.root} is closed`);
+    }
+  }
+  #requireCurrent() {
+    const current = this.#current;
+    if (current === null) {
+      throw new QuartzEngineError("WORKSPACE_CLOSED", `Quartz workspace at ${this.root} is closed`);
+    }
+    return current;
+  }
+}
+var openQuartzWorkspace = (root, options) => QuartzWorkspace.open(root, options);
+
+// src/context.ts
+class AnalyzerContext {
+  defaultConfigPath;
+  root;
+  packages;
+  workspace;
+  #dirty = false;
+  #dirtyGeneration = 0;
+  #dirtyRefresh = null;
+  #revisionCache = new Map;
+  constructor(root, packages, workspace, defaultConfigPath) {
+    this.defaultConfigPath = defaultConfigPath;
+    this.root = root;
+    this.packages = packages;
+    this.workspace = workspace;
+  }
+  static async open(root, options = {}) {
+    const resolvedRoot = resolve3(root);
+    const selectedTsconfigPaths = options.tsconfigPath !== undefined ? [options.tsconfigPath, ...options.tsconfigPaths ?? []] : options.tsconfigPaths === undefined ? undefined : ["tsconfig.json", ...options.tsconfigPaths];
+    const packages = discoverPackages(resolvedRoot, selectedTsconfigPaths);
+    if (packages.length === 0) {
+      throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `No tsconfig.json found under ${resolvedRoot}`);
+    }
+    const primaryConfig = options.tsconfigPath === undefined ? (packages.find((pkg) => pkg.name === "(root)") ?? packages[0]).tsconfigPath : resolve3(resolvedRoot, options.tsconfigPath);
+    const defaultConfigPath = options.tsconfigPath === undefined ? packages.length === 1 || packages.some((pkg) => pkg.name === "(root)") ? primaryConfig : undefined : primaryConfig;
+    const workspace = await openQuartzWorkspace(resolvedRoot, {
+      ...options,
+      tsconfigPath: primaryConfig,
+      tsconfigPaths: packages.map((pkg) => pkg.tsconfigPath)
+    });
+    return new AnalyzerContext(resolvedRoot, packages, workspace, defaultConfigPath);
+  }
+  package(packageName) {
+    if (packageName === undefined || packageName.length === 0) {
+      const defaultPackage = this.defaultConfigPath === undefined ? undefined : this.packages.find((pkg2) => pkg2.tsconfigPath === this.defaultConfigPath);
+      if (defaultPackage !== undefined)
+        return defaultPackage;
+      if (this.packages.length === 1)
+        return this.packages[0];
+      throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Multiple packages found. Please specify a package: ${this.packages.map((pkg2) => pkg2.name).join(", ")}`);
+    }
+    const normalized = packageName.replace(/^\//, "");
+    const pkg = this.packages.find((candidate) => candidate.name === packageName || candidate.name === normalized || candidate.path.endsWith(packageName));
+    if (pkg === undefined) {
+      throw new QuartzEngineError("WORKSPACE_OPEN_FAILED", `Unknown TypeScript package: ${packageName}. Available: ${this.packages.map((candidate) => candidate.name).join(", ")}`);
+    }
+    return pkg;
+  }
+  async withProject(operation, packageName) {
+    await this.#ensureFresh();
+    const pkg = this.package(packageName);
+    return this.workspace.withProject((project, revision) => operation(project, pkg, revision), pkg.tsconfigPath);
+  }
+  cacheForRevision(key, revision, load) {
+    const cached = this.#revisionCache.get(key);
+    if (cached?.revision === revision)
+      return cached.value;
+    const value = load();
+    this.#revisionCache.set(key, { revision, value });
+    return value;
+  }
+  async refresh(changes) {
+    const generationAtStart = this.#dirtyGeneration;
+    const metadata = await this.workspace.refresh(changes);
+    this.#revisionCache.clear();
+    if (this.#dirtyGeneration === generationAtStart)
+      this.#dirty = false;
+    else
+      this.#dirty = true;
+    return metadata;
+  }
+  refreshPackage(packageName) {
+    const pkg = this.package(packageName);
+    return this.refresh({ changed: [pkg.tsconfigPath] });
+  }
+  markDirty() {
+    this.#dirty = true;
+    this.#dirtyGeneration += 1;
+  }
+  async#ensureFresh() {
+    if (!this.#dirty)
+      return;
+    const refresh = this.#dirtyRefresh ??= this.refresh();
+    try {
+      await refresh;
+    } finally {
+      if (this.#dirtyRefresh === refresh)
+        this.#dirtyRefresh = null;
+    }
+    if (this.#dirty)
+      await this.#ensureFresh();
+  }
+  close() {
+    return this.workspace.close();
+  }
+}
+
+// src/leaf-operations.ts
+import { isAbsolute, relative as relative3, resolve as resolve5 } from "path";
+import {
+  DiagnosticCategory as DiagnosticCategory2,
+  ModifierFlags,
+  NodeBuilderFlags,
+  SignatureKind,
+  SymbolFlags as SymbolFlags2
+} from "typescript/unstable/async";
+import { SyntaxKind } from "typescript/unstable/ast";
+import {
+  isClassDeclaration,
+  isEnumDeclaration,
+  isExportSpecifier,
+  isFunctionDeclaration,
+  isIdentifier,
+  isInterfaceDeclaration,
+  isTypeAliasDeclaration,
+  isTypeReferenceNode,
+  isVariableDeclaration,
+  isVariableStatement
+} from "typescript/unstable/ast/is";
+
+// src/virtual-files.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, extname, join as join3, relative as relative2, resolve as resolve4 } from "path";
+import { SymbolFlags } from "typescript/unstable/async";
+var resolveVirtualFileDirectory = (packageRoot) => {
+  const root = resolve4(packageRoot);
+  for (const candidate of ["types", "src", "lib", "source"]) {
+    const directory = join3(root, candidate);
+    if (existsSync2(directory))
+      return directory;
+  }
+  return root;
+};
+var modulePathFor = (from, fileName) => {
+  const withoutExtension = fileName.slice(0, -extname(fileName).length);
+  const path = relative2(dirname3(from), withoutExtension).replaceAll("\\", "/");
+  return path.startsWith(".") ? path : `./${path}`;
+};
+var isSourceFileIn = (fileName, root) => {
+  const resolved = resolve4(fileName);
+  const base = resolve4(root);
+  return resolved === base || resolved.startsWith(`${base}/`);
+};
+var isIndexFile = (fileName) => /(?:^|\/)index\.[cm]?[jt]sx?$/.test(fileName.replaceAll("\\", "/"));
+var packageSources = async (project, packageRoot, virtualFilePath) => {
+  const files = (await project.program.getSourceFileNames()).filter((fileName) => fileName !== virtualFilePath && isSourceFileIn(fileName, packageRoot) && !fileName.endsWith(".d.ts") && /\.[cm]?[jt]sx?$/.test(fileName)).sort((left, right) => {
+    const leftRelative = relative2(packageRoot, left);
+    const rightRelative = relative2(packageRoot, right);
+    const rank = (value) => value === "index.ts" || value === "index.tsx" ? 0 : value.startsWith("src/") ? 1 : 2;
+    return rank(leftRelative) - rank(rightRelative) || leftRelative.localeCompare(rightRelative);
+  });
+  const loaded = (await Promise.all(files.map((fileName) => project.program.getSourceFile(fileName)))).filter((source) => source !== undefined);
+  const entry = loaded.find((source) => isIndexFile(source.fileName));
+  return entry === undefined ? loaded : [entry];
+};
+var synthesizePackageImports = async (project, packageRoot, virtualFilePath) => {
+  const sources = await packageSources(project, packageRoot, virtualFilePath);
+  if (sources.length === 0)
+    return { content: "", lineOffset: 0 };
+  const claimedNames = new Set;
+  const lines = [];
+  for (const source of sources) {
+    const moduleSymbol = await project.checker.getSymbolAtLocation(source);
+    if (moduleSymbol === undefined)
+      continue;
+    const exported = await project.checker.getExportsOfModule(moduleSymbol);
+    const typeNames = [];
+    const valueNames = [];
+    for (const symbol of exported) {
+      if (symbol.name === "default" || claimedNames.has(symbol.name) || !/^[A-Za-z_$][\w$]*$/.test(symbol.name))
+        continue;
+      claimedNames.add(symbol.name);
+      if ((symbol.flags & SymbolFlags.Value) !== SymbolFlags.None)
+        valueNames.push(symbol.name);
+      else
+        typeNames.push(symbol.name);
+    }
+    const modulePath = modulePathFor(virtualFilePath, source.fileName);
+    if (typeNames.length > 0)
+      lines.push(`import type { ${typeNames.sort().join(", ")} } from ${JSON.stringify(modulePath)}`);
+    if (valueNames.length > 0)
+      lines.push(`import { ${valueNames.sort().join(", ")} } from ${JSON.stringify(modulePath)}`);
+  }
+  return { content: lines.length === 0 ? "" : `${lines.join(`
+`)}
+`, lineOffset: lines.length };
+};
+var createVirtualFileRegistry = (root, prefix = "__quartz_snippet_") => {
+  const directory = resolve4(root);
+  const files = new Map;
+  let sequence = 0;
+  const acquire = (content, extension = ".ts") => {
+    const token = Symbol("virtual-file");
+    const id = `${Date.now().toString(36)}_${(sequence++).toString(36)}`;
+    const path = join3(directory, `${prefix}${id}${extension}`);
+    const entry = { path, content, token };
+    files.set(path, entry);
+    let disposed = false;
+    return {
+      ...entry,
+      dispose: () => {
+        if (disposed)
+          return;
+        disposed = true;
+        const current = files.get(path);
+        if (current?.token === token)
+          files.delete(path);
+      }
+    };
+  };
+  return {
+    acquire,
+    create: acquire,
+    get: (path) => files.get(path)?.content,
+    has: (path) => files.has(path),
+    entries: () => [...files.values()],
+    get size() {
+      return files.size;
+    },
+    clear: () => files.clear()
+  };
+};
+var withVirtualFile = async (registry, content, operation, extension = ".ts") => {
+  const lease = registry.acquire(content, extension);
+  try {
+    return await operation(lease);
+  } finally {
+    lease.dispose();
+  }
+};
+
+// src/leaf-operations.ts
+var TYPE_FLAGS = NodeBuilderFlags.NoTruncation | NodeBuilderFlags.UseStructuralFallback | NodeBuilderFlags.WriteTypeArgumentsOfSignature | NodeBuilderFlags.InTypeAlias | NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope;
+var EXPAND_FLAGS = TYPE_FLAGS | NodeBuilderFlags.WriteArrayAsGenericType;
+var MAX_PROPERTIES = 50;
+var MAX_NODE_TEXT = 100;
+var kindToString = (kind) => {
+  switch (kind) {
+    case SyntaxKind.InterfaceDeclaration:
+      return "interface";
+    case SyntaxKind.TypeAliasDeclaration:
+      return "type";
+    case SyntaxKind.ClassDeclaration:
+      return "class";
+    case SyntaxKind.FunctionDeclaration:
+      return "function";
+    case SyntaxKind.VariableDeclaration:
+      return "variable";
+    case SyntaxKind.EnumDeclaration:
+      return "enum";
+    case SyntaxKind.ModuleDeclaration:
+      return "module";
+    default:
+      return (SyntaxKind[kind] ?? "unknown").replace(/Declaration$/, "").replace(/Statement$/, "").toLowerCase();
+  }
+};
+var sourceFilesFor = (context, project, packageInfo, revision) => context.cacheForRevision(`source-files:${packageInfo.tsconfigPath}`, revision, async () => {
+  const root = resolve5(packageInfo.path);
+  const names = await project.program.getSourceFileNames();
+  const files = await Promise.all(names.map(async (name) => {
+    const source = await project.program.getSourceFile(name);
+    if (source === undefined || await project.program.isSourceFileFromExternalLibrary(source))
+      return;
+    const file = resolve5(source.fileName);
+    return file === root || file.startsWith(`${root}/`) ? source : undefined;
+  }));
+  return files.filter((source) => source !== undefined);
+});
+var relativePath = (root, file) => {
+  const absolute = resolve5(file);
+  const base = resolve5(root);
+  return absolute === base || absolute.startsWith(`${base}/`) ? relative3(base, absolute) : absolute;
+};
+var declarationName = (node) => {
+  if (isClassDeclaration(node) || isEnumDeclaration(node) || isFunctionDeclaration(node) || isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) {
+    return node.name?.text;
+  }
+  if (isVariableDeclaration(node) && isIdentifier(node.name))
+    return node.name.text;
+  return;
+};
+var declarationSymbol = async (project, node) => {
+  if (isClassDeclaration(node) || isEnumDeclaration(node) || isFunctionDeclaration(node) || isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) {
+    return node.name === undefined ? undefined : project.checker.getSymbolAtLocation(node.name);
+  }
+  if (isVariableDeclaration(node) && isIdentifier(node.name))
+    return project.checker.getSymbolAtLocation(node.name);
+  return;
+};
+var declarationsIn = (source) => {
+  const declarations = [];
+  for (const statement of source.statements) {
+    if (isClassDeclaration(statement) || isEnumDeclaration(statement) || isFunctionDeclaration(statement) || isInterfaceDeclaration(statement) || isTypeAliasDeclaration(statement)) {
+      declarations.push(statement);
+    } else if (isVariableStatement(statement)) {
+      declarations.push(...statement.declarationList.declarations);
+    }
+  }
+  return declarations;
+};
+var isExported = (node) => {
+  const modifiers = node.modifierFlags;
+  return modifiers !== undefined && (modifiers & ModifierFlags.Export) !== 0;
+};
+var isDefault = (node) => {
+  const modifiers = node.modifierFlags;
+  return modifiers !== undefined && (modifiers & ModifierFlags.Default) !== 0;
+};
+var exportMatchesFor = async (project, source) => {
+  const moduleSymbol = await project.checker.getSymbolAtLocation(source);
+  if (moduleSymbol === undefined)
+    return [];
+  const exported = await project.checker.getExportsOfModule(moduleSymbol);
+  const matches = [];
+  for (const exportedSymbol of exported) {
+    const resolvedSymbol = (exportedSymbol.flags & SymbolFlags2.Alias) !== SymbolFlags2.None ? await project.checker.getAliasedSymbol(exportedSymbol) : exportedSymbol;
+    for (const handle of resolvedSymbol.declarations) {
+      const node = await handle.resolve(project);
+      if (node === undefined)
+        continue;
+      const name = declarationName(node);
+      if (name !== undefined) {
+        matches.push({ node, symbol: await declarationSymbol(project, node) ?? resolvedSymbol, exportedName: exportedSymbol.name });
+        break;
+      }
+      if (isExportSpecifier(node)) {
+        const target = await project.checker.getAliasedSymbol(exportedSymbol);
+        for (const targetHandle of target.declarations) {
+          const targetNode = await targetHandle.resolve(project);
+          if (targetNode === undefined)
+            continue;
+          const targetName = declarationName(targetNode);
+          if (targetName !== undefined) {
+            matches.push({ node: targetNode, symbol: await declarationSymbol(project, targetNode) ?? target, exportedName: exportedSymbol.name });
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+  return matches;
+};
+var exportedMatches = async (project, sourceFiles) => {
+  const all = await Promise.all(sourceFiles.map((source) => exportMatchesFor(project, source)));
+  return all.flat();
+};
+var exportedMatchesFor = (context, project, packageInfo, revision, sourceFiles) => context.cacheForRevision(`exported-matches:${packageInfo.tsconfigPath}`, revision, () => exportedMatches(project, sourceFiles));
+var parseFileReference = (value) => {
+  if (!value.startsWith("@file:"))
+    return null;
+  const rest = value.slice(6);
+  const index = rest.lastIndexOf(":");
+  return index < 0 ? { file: rest, symbol: "*" } : { file: rest.slice(0, index), symbol: rest.slice(index + 1) };
+};
+var findMatch = async (project, sourceFiles, root, symbolName, matches) => {
+  const reference = parseFileReference(symbolName);
+  if (reference !== null) {
+    const source = sourceFiles.find((candidate) => resolve5(candidate.fileName) === resolve5(root, reference.file) || candidate.fileName.endsWith(reference.file));
+    if (source === undefined || reference.symbol === "*")
+      return null;
+    const [rootName2, ...members] = reference.symbol.split(".");
+    const local = declarationsIn(source).find((node) => declarationName(node) === rootName2);
+    if (local === undefined)
+      return null;
+    const symbol = await declarationSymbol(project, local);
+    if (symbol === undefined)
+      return null;
+    let current2 = { node: local, symbol };
+    for (const member of members) {
+      const type = await typeForNode(current2.node, current2.symbol, project);
+      const property = await project.checker.getPropertyOfType(type, member);
+      if (property === undefined)
+        return null;
+      const node = await property.declarations[0]?.resolve(project);
+      if (node === undefined)
+        return null;
+      current2 = { node, symbol: property };
+    }
+    return current2;
+  }
+  const parts = symbolName.split(".");
+  const rootName = parts[0];
+  const match = matches.find((candidate) => candidate.exportedName === rootName || declarationName(candidate.node) === rootName);
+  if (match === undefined)
+    return null;
+  let current = match;
+  for (const member of parts.slice(1)) {
+    const type = await typeForNode(current.node, current.symbol, project);
+    const property = await project.checker.getPropertyOfType(type, member);
+    if (property === undefined)
+      return null;
+    const node = await property.declarations[0]?.resolve(project);
+    if (node === undefined)
+      return null;
+    current = { node, symbol: property };
+  }
+  return current;
+};
+var typeForNode = async (node, symbol, project) => {
+  if (isClassDeclaration(node) || isEnumDeclaration(node) || isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) {
+    return project.checker.getDeclaredTypeOfSymbol(symbol);
+  }
+  return project.checker.getTypeOfSymbol(symbol);
+};
+var hasOptional = (symbol) => (symbol.flags & SymbolFlags2.Optional) !== SymbolFlags2.None;
+var propertiesFor = async (type, project, location, root, includeFrom, flags = TYPE_FLAGS) => {
+  const properties = await project.checker.getPropertiesOfType(type);
+  if (properties.length === 0 || properties.length > MAX_PROPERTIES)
+    return [];
+  const declarations = await Promise.all(properties.map(async (property) => {
+    const handle = property.declarations[0];
+    return handle === undefined ? undefined : await handle.resolve(project);
+  }));
+  const packageRoot = resolve5(root);
+  const included = [];
+  for (let index = 0;index < properties.length; index += 1) {
+    const property = properties[index];
+    const declaration = declarations[index];
+    if (includeFrom && declaration !== undefined && resolve5(declaration.getSourceFile().fileName).includes(`${packageRoot}/node_modules/`)) {
+      continue;
+    }
+    included.push({ property, declaration });
+  }
+  if (included.length === 0)
+    return [];
+  const propertyTypes = await project.checker.getTypeOfSymbol(included.map((item) => item.property));
+  const typeByProperty = new Map;
+  for (let index = 0;index < included.length; index += 1) {
+    typeByProperty.set(included[index].property, propertyTypes[index]);
+  }
+  return Promise.all(included.map(async ({ property, declaration }) => {
+    const propertyType = typeByProperty.get(property);
+    const result = {
+      name: property.name,
+      type: await project.checker.typeToString(propertyType, declaration ?? location, flags),
+      ...hasOptional(property) ? { optional: true } : {}
+    };
+    if (includeFrom && declaration !== undefined) {
+      return { ...result, from: relativePath(root, declaration.getSourceFile().fileName) };
+    }
+    return result;
+  }));
+};
+var makeTypeInfo = async (match, project, packageInfo, root) => {
+  const type = await typeForNode(match.node, match.symbol, project);
+  const kind = declarationName(match.node) === undefined ? SyntaxKind[match.node.kind] ?? "unknown" : kindToString(match.node.kind);
+  const info = {
+    name: match.symbol.name,
+    kind,
+    type: await project.checker.typeToString(type, match.node, TYPE_FLAGS),
+    location: { file: relativePath(root, match.node.getSourceFile().fileName), line: match.node.getSourceFile().getLineAndCharacterOfPosition(match.node.getStart()).line + 1 },
+    package: packageInfo.name
+  };
+  const withSignature = isClassDeclaration(match.node) ? { ...info, signature: `class ${match.symbol.name}` } : isInterfaceDeclaration(match.node) ? { ...info, signature: `interface ${match.symbol.name}` } : isTypeAliasDeclaration(match.node) ? { ...info, signature: `type ${match.symbol.name}` } : info;
+  let result = withSignature;
+  if (isFunctionDeclaration(match.node)) {
+    const signatures = await project.checker.getSignaturesOfType(type, SignatureKind.Call);
+    const texts = await Promise.all(signatures.map(async (signature2) => signature2.declaration === undefined ? undefined : (await signature2.declaration.resolve(project))?.getText()));
+    const signature = texts.filter((text) => text !== undefined).join(`
+`);
+    if (signature.length > 0)
+      result = { ...result, signature };
+  }
+  const properties = await propertiesFor(type, project, match.node, root, true);
+  return properties.length > 0 ? { ...result, properties } : result;
+};
+var metadataFor = async (project, source) => {
+  const matches = await exportMatchesFor(project, source);
+  const direct = declarationsIn(source).flatMap((node) => {
+    const name = declarationName(node);
+    if (name === undefined)
+      return [];
+    return [{ node, name, exported: isExported(source.statements.find((statement) => statement.pos <= node.pos && statement.end >= node.end) ?? node), isDefaultExport: isDefault(node) }];
+  });
+  const aliases = matches.flatMap((match) => {
+    const name = declarationName(match.node);
+    if (name === undefined)
+      return [];
+    return [{ node: match.node, name, exported: true, isDefaultExport: match.exportedName === "default", ...match.exportedName !== name && match.exportedName !== "default" ? { exportedAs: match.exportedName } : {} }];
+  });
+  const byNode = new Map;
+  for (const item of [...direct, ...aliases])
+    byNode.set(item.node.pos, item);
+  return [...byNode.values()];
+};
+var diagnosticCategory = (category) => DiagnosticCategory2[category];
+var sourceLocation = (source, position) => {
+  if (source === undefined || position < 0)
+    return;
+  const point = source.getLineAndCharacterOfPosition(Math.min(position, source.text.length));
+  return { line: point.line + 1, column: point.character + 1 };
+};
+var mapDiagnostic = async (diagnostic, project, root) => {
+  const source = diagnostic.fileName === undefined ? undefined : await project.program.getSourceFile(diagnostic.fileName);
+  const location = sourceLocation(source, diagnostic.pos);
+  const category = diagnosticCategory(diagnostic.category);
+  return {
+    message: diagnostic.text,
+    code: diagnostic.code,
+    ...category === undefined ? {} : { category },
+    ...diagnostic.fileName === undefined ? {} : { file: relativePath(root, diagnostic.fileName) },
+    ...location === undefined ? {} : { line: location.line, column: location.column }
+  };
+};
+var findNodeAt = (node, position) => {
+  let best = node;
+  node.forEachChild((child) => {
+    if (child.pos <= position && position <= child.end)
+      best = findNodeAt(child, position);
+  });
+  return best;
+};
+var semanticTypeNode = (node) => {
+  let current = node.parent;
+  while (current !== undefined && current.kind !== SyntaxKind.SourceFile) {
+    if (isTypeReferenceNode(current)) {
+      return node.pos >= current.typeName.pos && node.end <= current.typeName.end ? current : node;
+    }
+    current = current.parent;
+  }
+  return node;
+};
+var evaluateTypeExpression = async (expression, context, packageName, registry) => {
+  const normalized = expression.trim();
+  if (normalized.length === 0)
+    return { error: `Could not evaluate type expression: ${expression}` };
+  const pkg = context.package(packageName);
+  return withVirtualFile(registry, "", async (lease) => {
+    const imports = await context.withProject((project) => synthesizePackageImports(project, pkg.path, lease.path), packageName);
+    const content = `${imports.content}type __QuartzEval = ${normalized}
+const __QuartzEvalValue: ${normalized} = undefined as unknown as ${normalized}
+void __QuartzEvalValue
+`;
+    return context.workspace.withVirtualFile(pkg.tsconfigPath, lease.path, content, async (project, filePath) => {
+      const source = await project.program.getSourceFile(filePath);
+      const declaration = source?.statements.filter(isVariableStatement).flatMap((statement) => statement.declarationList.declarations).find((candidate) => isIdentifier(candidate.name) && candidate.name.text === "__QuartzEvalValue");
+      if (source === undefined || declaration === undefined) {
+        return { error: `Could not evaluate type expression: ${expression}` };
+      }
+      const diagnostics = (await project.program.getSemanticDiagnostics(filePath)).filter((diagnostic) => diagnostic.category === DiagnosticCategory2.Error);
+      if (diagnostics[0] !== undefined)
+        return { error: diagnostics[0].text };
+      const type = await project.checker.getTypeAtLocation(declaration);
+      const [result, expanded] = await Promise.all([
+        project.checker.typeToString(type, declaration, TYPE_FLAGS),
+        project.checker.typeToString(type, declaration, EXPAND_FLAGS)
+      ]);
+      return {
+        result,
+        expanded: expanded === result ? result : expanded
+      };
+    });
+  });
+};
+var createLeafOperations = (context) => {
+  const virtualFiles = createVirtualFileRegistry(resolveVirtualFileDirectory(context.root), "__quartz_type_eval_");
+  const getPackages = async () => context.packages;
+  const listSymbols = (options = {}) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const matches = await exportedMatchesFor(context, project, pkg, revision, sourceFiles);
+    const namePattern = options.pattern === undefined ? undefined : new RegExp(options.pattern, "i");
+    const filePattern = options.file === undefined ? undefined : new RegExp(options.file, "i");
+    const all = [];
+    for (const match of matches) {
+      const name = match.exportedName === "default" ? declarationName(match.node) ?? "default" : match.exportedName ?? declarationName(match.node);
+      if (name === undefined)
+        continue;
+      const file = relativePath(context.root, match.node.getSourceFile().fileName);
+      const isIndexExport = /(?:^|\/)index(?:\.[cm]?[jt]sx?)?$/.test(file);
+      if (options.indexOnly === true && !isIndexExport)
+        continue;
+      if (filePattern !== undefined && !filePattern.test(file))
+        continue;
+      const kind = kindToString(match.node.kind);
+      if (options.kind !== undefined && options.kind !== "all" && options.kind !== kind)
+        continue;
+      if (namePattern !== undefined && !namePattern.test(name))
+        continue;
+      all.push({ name, kind, file, line: match.node.getSourceFile().getLineAndCharacterOfPosition(match.node.getStart()).line + 1, package: pkg.name, isIndexExport });
+    }
+    all.sort((left, right) => left.isIndexExport === right.isIndexExport ? left.name.localeCompare(right.name) : left.isIndexExport ? -1 : 1);
+    const limit = options.limit ?? 100;
+    return { symbols: all.slice(0, limit), total: all.length, truncated: all.length > limit, package: pkg.name };
+  }, options.packageName);
+  const getTypeInfo = (symbolName, packageName) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const matches = await exportedMatchesFor(context, project, pkg, revision, sourceFiles);
+    const match = await findMatch(project, sourceFiles, context.root, symbolName, matches);
+    return match === null ? null : makeTypeInfo(match, project, pkg, context.root);
+  }, packageName);
+  const expandType = (symbolName, packageName) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const matches = await exportedMatchesFor(context, project, pkg, revision, sourceFiles);
+    const match = await findMatch(project, sourceFiles, context.root, symbolName, matches);
+    if (match === null)
+      return null;
+    const type = await typeForNode(match.node, match.symbol, project);
+    const [rendered, properties] = await Promise.all([
+      project.checker.typeToString(type, match.node, EXPAND_FLAGS),
+      propertiesFor(type, project, match.node, context.root, true, EXPAND_FLAGS)
+    ]);
+    return { original: rendered, expanded: rendered, properties };
+  }, packageName);
+  const searchTypes = (options) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const matches = await exportedMatchesFor(context, project, pkg, revision, sourceFiles);
+    const pattern = options.pattern ?? options.query;
+    const regex = pattern === undefined ? undefined : new RegExp(pattern, "i");
+    const results = [];
+    for (const match of matches) {
+      const name = match.exportedName === "default" ? declarationName(match.node) ?? "default" : match.exportedName ?? declarationName(match.node);
+      if (name === undefined || regex !== undefined && !regex.test(name))
+        continue;
+      const type = await typeForNode(match.node, match.symbol, project);
+      if (options.hasProperty !== undefined && await project.checker.getPropertyOfType(type, options.hasProperty) === undefined)
+        continue;
+      if (options.extends !== undefined) {
+        const bases = await type.getBaseTypes();
+        if (bases === undefined || !(await Promise.all(bases.map(async (base) => await (await base.getSymbol())?.name === options.extends))).some(Boolean))
+          continue;
+      }
+      results.push(await makeTypeInfo(match, project, pkg, context.root));
+      if (results.length >= (options.limit ?? 25))
+        break;
+    }
+    return results;
+  }, options.packageName);
+  const evalType = (expression, packageName) => evaluateTypeExpression(expression, context, packageName, virtualFiles);
+  const getFileDeclarations = (file, options = {}) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const target = isAbsolute(file) ? resolve5(file) : resolve5(context.root, file);
+    const source = sourceFiles.find((candidate) => resolve5(candidate.fileName) === target || candidate.fileName.endsWith(file));
+    if (source === undefined)
+      return null;
+    const filter = options.symbol === undefined ? undefined : new RegExp(options.symbol, "i");
+    const metadata = await metadataFor(project, source);
+    const declarations = [];
+    for (const item of metadata) {
+      if (filter !== undefined && !filter.test(item.name))
+        continue;
+      if (!item.exported && options.includePrivate !== true)
+        continue;
+      let info = { name: item.name, kind: kindToString(item.node.kind), line: source.getLineAndCharacterOfPosition(item.node.getStart()).line + 1, exported: item.exported, isDefaultExport: item.isDefaultExport, ...item.exportedAs === undefined ? {} : { exportedAs: item.exportedAs } };
+      const symbol = await declarationSymbol(project, item.node);
+      if (symbol !== undefined) {
+        const type = await typeForNode(item.node, symbol, project);
+        if (info.kind !== "class" && info.kind !== "interface" && info.kind !== "enum")
+          info = { ...info, type: await project.checker.typeToString(type, item.node, TYPE_FLAGS) };
+        if (info.kind === "function") {
+          const signatures = await project.checker.getSignaturesOfType(type, SignatureKind.Call);
+          const parts = await Promise.all(signatures.map(async (signature) => {
+            const params = await signature.getParameters();
+            const rendered = await Promise.all(params.map(async (parameter) => `${parameter.name}: ${await project.checker.typeToString(await project.checker.getTypeOfSymbolAtLocation(parameter, item.node), item.node, TYPE_FLAGS)}`));
+            return `(${rendered.join(", ")}) => ${await project.checker.typeToString(await project.checker.getReturnTypeOfSignature(signature), item.node, TYPE_FLAGS)}`;
+          }));
+          if (parts.length > 0)
+            info = { ...info, signature: parts.join(" | ") };
+        }
+      }
+      declarations.push(info);
+    }
+    declarations.sort((left, right) => left.exported === right.exported ? left.name.localeCompare(right.name) : left.exported ? -1 : 1);
+    return { file: relativePath(context.root, source.fileName), package: pkg.name, declarations, total: declarations.length };
+  }, options.packageName);
+  const checkCompatibility = (from, to, packageName) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const matches = await exportedMatchesFor(context, project, pkg, revision, sourceFiles);
+    const fromMatch = await findMatch(project, sourceFiles, context.root, from, matches);
+    const toMatch = await findMatch(project, sourceFiles, context.root, to, matches);
+    if (fromMatch === null || toMatch === null) {
+      const missing = fromMatch === null ? from : to;
+      const message = `Symbol "${missing}" not found`;
+      return { compatible: false, from, to, reason: message, issues: [{ kind: "other", message }] };
+    }
+    const fromType = await typeForNode(fromMatch.node, fromMatch.symbol, project);
+    const toType = await typeForNode(toMatch.node, toMatch.symbol, project);
+    const [fromText, toText] = await Promise.all([
+      project.checker.typeToString(fromType, fromMatch.node),
+      project.checker.typeToString(toType, toMatch.node)
+    ]);
+    if (await project.checker.isTypeAssignableTo(fromType, toType))
+      return { compatible: true, from: fromText, to: toText };
+    const issues = [];
+    const reasons = [];
+    const [fromProperties, targetProperties] = await Promise.all([
+      project.checker.getPropertiesOfType(fromType),
+      project.checker.getPropertiesOfType(toType)
+    ]);
+    const fromNames = new Set(fromProperties.map((property) => property.name));
+    const missingRequired = targetProperties.filter((property) => !hasOptional(property) && !fromNames.has(property.name));
+    if (missingRequired.length > 0) {
+      const missingTypes = await project.checker.getTypeOfSymbol(missingRequired);
+      const expectedTexts = await Promise.all(missingTypes.map((missingType) => project.checker.typeToString(missingType, toMatch.node)));
+      for (let index = 0;index < missingRequired.length; index += 1) {
+        const property = missingRequired[index];
+        const expected = expectedTexts[index];
+        const message = `Property '${property.name}' is missing in type '${fromText}' but required in type '${toText}' (expected: ${expected})`;
+        reasons.push(message);
+        issues.push({ kind: "missing_property", property: property.name, expectedType: expected, message });
+      }
+    }
+    for (const property of fromProperties) {
+      const target = await project.checker.getPropertyOfType(toType, property.name);
+      if (target === undefined)
+        continue;
+      const [actualType, expectedType] = await Promise.all([
+        project.checker.getTypeOfSymbolAtLocation(property, fromMatch.node),
+        project.checker.getTypeOfSymbolAtLocation(target, toMatch.node)
+      ]);
+      if (await project.checker.isTypeAssignableTo(actualType, expectedType))
+        continue;
+      const [actual, expected] = await Promise.all([
+        project.checker.typeToString(actualType, fromMatch.node),
+        project.checker.typeToString(expectedType, toMatch.node)
+      ]);
+      const message = `Property '${property.name}' has incompatible types: '${actual}' is not assignable to '${expected}'`;
+      reasons.push(message);
+      issues.push({ kind: "type_mismatch", property: property.name, actualType: actual, expectedType: expected, message });
+    }
+    if (reasons.length === 0) {
+      const message = `Type '${fromText}' is not assignable to type '${toText}'`;
+      reasons.push(message);
+      issues.push({ kind: "other", message });
+    }
+    return { compatible: false, from: fromText, to: toText, reason: reasons.join("; "), issues };
+  }, packageName);
+  const getDiagnostics = (packageNameOrOptions) => context.withProject(async (project, pkg) => {
+    const options = typeof packageNameOrOptions === "object" ? packageNameOrOptions : undefined;
+    const diagnostics = (await Promise.all([project.program.getConfigFileParsingDiagnostics(), project.program.getSyntacticDiagnostics(), project.program.getSemanticDiagnostics()])).flat();
+    const packageRoot = resolve5(pkg.path);
+    const unique = new Map;
+    for (const diagnostic of diagnostics) {
+      if (diagnostic.fileName !== undefined && !(resolve5(diagnostic.fileName) === packageRoot || resolve5(diagnostic.fileName).startsWith(`${packageRoot}/`)))
+        continue;
+      unique.set([diagnostic.fileName ?? "", diagnostic.pos, diagnostic.code, diagnostic.text].join("\x00"), diagnostic);
+    }
+    const errors = await Promise.all([...unique.values()].map((diagnostic) => mapDiagnostic(diagnostic, project, context.root)));
+    if (options?.explain !== true)
+      return errors;
+    const explained = errors.map((error) => ({ ...error, explanation: null }));
+    return { totalErrors: explained.length, explained: 0, truncated: false, errors: explained };
+  }, typeof packageNameOrOptions === "string" ? packageNameOrOptions : packageNameOrOptions?.packageName);
+  const getTypeAtPosition = (filePath, line, column, packageName) => context.withProject(async (project, pkg, revision) => {
+    const sourceFiles = await sourceFilesFor(context, project, pkg, revision);
+    const targetPath = isAbsolute(filePath) ? resolve5(filePath) : resolve5(context.root, filePath);
+    const source = sourceFiles.find((candidate) => resolve5(candidate.fileName) === targetPath || candidate.fileName.endsWith(filePath));
+    if (source === undefined || line < 1 || column < 1)
+      return null;
+    let position;
+    try {
+      position = source.getPositionOfLineAndCharacter(line - 1, column - 1);
+    } catch {
+      return null;
+    }
+    if (position > source.text.length)
+      return null;
+    const node = semanticTypeNode(findNodeAt(source, position));
+    const type = await project.checker.getTypeAtLocation(node);
+    const point = source.getLineAndCharacterOfPosition(node.getStart());
+    const [typeText, expandedText] = await Promise.all([
+      project.checker.typeToString(type, node),
+      project.checker.typeToString(type, node, EXPAND_FLAGS)
+    ]);
+    const text = node.getText(source);
+    const nodeText = text.length > MAX_NODE_TEXT ? `${text.slice(0, MAX_NODE_TEXT)}...` : text;
+    return {
+      type: typeText,
+      expanded: expandedText === typeText ? typeText : expandedText,
+      nodeKind: SyntaxKind[node.kind] ?? "unknown",
+      nodeText,
+      location: {
+        file: relativePath(context.root, source.fileName),
+        line: point.line + 1,
+        column: point.character + 1
+      }
+    };
+  }, packageName);
+  const explainType = async (expression, packageName) => {
+    const result = await evaluateTypeExpression(expression, context, packageName, virtualFiles);
+    const final = "error" in result ? `Error: ${result.error}` : result.expanded;
+    return { expression, steps: [{ step: 1, description: `Expand ${expression}`, expression, result: final }], final };
+  };
+  return { getPackages, listSymbols, getTypeInfo, expandType, searchTypes, evalType, getFileDeclarations, checkCompatibility, getDiagnostics, getTypeAtPosition, explainType };
+};
+
+// src/reference-operations.ts
+import { relative as relative4, resolve as resolve6 } from "path";
+import { SyntaxKind as SyntaxKind2 } from "typescript/unstable/ast";
+import { isTypeReferenceNode as isTypeReferenceNode2 } from "typescript/unstable/ast/is";
+var PRIMITIVE_NAMES = {
+  string: true,
+  number: true,
+  boolean: true,
+  undefined: true,
+  null: true,
+  void: true,
+  any: true,
+  never: true,
+  object: true,
+  symbol: true,
+  bigint: true,
+  Date: true,
+  Array: true,
+  Object: true,
+  String: true,
+  Number: true,
+  Boolean: true,
+  Promise: true,
+  Map: true,
+  Set: true,
+  WeakMap: true,
+  WeakSet: true,
+  Error: true,
+  Function: true
+};
+var MAX_RENAME_LOCATIONS = 100;
+var MAX_STRING_OR_COMMENT_LOCATIONS = 20;
+var MAX_REFERENCE_RESULTS_PER_FILE = 100;
+var MAX_GRAPH_DEPTH = 4;
+var createReferenceOperations = (context) => ({
+  findRelated: (symbolName, packageName) => context.withProject(async (project, pkg, revision) => {
+    const target = await findTarget(context, project, pkg, revision, symbolName);
+    if (target === null)
+      return null;
+    return {
+      symbol: symbolName,
+      referencedBy: await findIncomingReferences(project, target),
+      references: await findOutgoingReferences(project, target)
+    };
+  }, packageName),
+  generateGraph: (symbolName, options = {}) => context.withProject(async (project, pkg, revision) => {
+    const depth = Math.max(0, Math.min(options.depth ?? 2, MAX_GRAPH_DEPTH));
+    const format = options.format ?? "mermaid";
+    const targets = targetIndexFor(context, project, pkg, revision);
+    const rootTarget = await targets.lookup(symbolName);
+    if (rootTarget === null)
+      return null;
+    const nodes = [symbolName];
+    const nodeIds = new Set([String(rootTarget.symbol.id)]);
+    const edges = [];
+    const edgeKeys = new Set;
+    const visited = new Set;
+    const visit = async (target, displayName, currentDepth) => {
+      const targetId = String(target.symbol.id);
+      if (visited.has(targetId) || currentDepth > depth)
+        return;
+      visited.add(targetId);
+      const outgoing = await findOutgoingReferences(project, target);
+      if (currentDepth >= depth)
+        return;
+      for (const reference of outgoing) {
+        const child = await targets.lookup(reference.symbol);
+        if (child === null)
+          continue;
+        const childId = String(child.symbol.id);
+        const childName = child.symbol.name;
+        if (!nodeIds.has(childId)) {
+          nodes.push(childName);
+        }
+        const edgeKey = `${targetId}:${childId}:${reference.context}`;
+        if (!edgeKeys.has(edgeKey)) {
+          edgeKeys.add(edgeKey);
+          edges.push({ from: displayName, to: childName, label: reference.context });
+        }
+        await visit(child, childName, currentDepth + 1);
+      }
+    };
+    await visit(rootTarget, symbolName, 0);
+    return {
+      root: symbolName,
+      format,
+      depth,
+      nodes,
+      edges,
+      graph: format === "mermaid" ? toMermaid(edges) : toDot(edges)
+    };
+  }, options.packageName),
+  previewRefactor: (options) => context.withProject(async (project, pkg, revision) => {
+    if (options.action !== "rename") {
+      throw new Error(`Unsupported refactor action: ${options.action}`);
+    }
+    const target = await findTarget(context, project, pkg, revision, options.symbol);
+    if (target === null) {
+      throw new Error(`Symbol "${options.symbol}" not found`);
+    }
+    const sites = await findRenameSites(project, target);
+    const locations = [];
+    const predictedErrors = [];
+    const affectedFiles = new Set;
+    for (const site of sites) {
+      const sourceFile = site.sourceFile;
+      const file = relativePath2(context.root, sourceFile.fileName);
+      const position = sourceFile.getLineAndCharacterOfPosition(site.node.getStart(sourceFile));
+      const line = position.line + 1;
+      const lineText = getLineText(sourceFile, position.line);
+      const before = lineText.trim();
+      const after = replaceSiteOnTrimmedLine(lineText, before, position.character, site.node.getText(sourceFile), options.to);
+      affectedFiles.add(sourceFile.fileName);
+      addRenameSafetyError(predictedErrors, sourceFile, file, pkg.path, line);
+      locations.push({ file, line, column: position.character + 1, before, after });
+    }
+    const stringLiteralLocations = [];
+    const commentLocations = [];
+    for (const fileName of affectedFiles) {
+      const sourceFile = await project.program.getSourceFile(fileName);
+      if (sourceFile === undefined)
+        continue;
+      collectStringLiteralLocations(sourceFile, context.root, options.symbol, stringLiteralLocations);
+      collectCommentLocations(sourceFile, context.root, options.symbol, commentLocations);
+    }
+    const safetyNotes = [];
+    if (stringLiteralLocations.length > 0) {
+      safetyNotes.push(`${stringLiteralLocations.length} string literal(s) contain "${options.symbol}" and won't be renamed automatically`);
+    }
+    if (commentLocations.length > 0) {
+      safetyNotes.push(`${commentLocations.length} comment(s) contain "${options.symbol}" and may need manual review`);
+    }
+    return {
+      action: "rename",
+      from: options.symbol,
+      to: options.to,
+      locations: locations.slice(0, MAX_RENAME_LOCATIONS),
+      totalLocations: locations.length,
+      predictedErrors,
+      confidence: predictedErrors.length > 0 ? "low" : "high",
+      safe: predictedErrors.length === 0 && safetyNotes.length === 0,
+      safetyNotes,
+      stringLiteralLocations: stringLiteralLocations.slice(0, MAX_STRING_OR_COMMENT_LOCATIONS),
+      commentLocations: commentLocations.slice(0, MAX_STRING_OR_COMMENT_LOCATIONS)
+    };
+  }, options.packageName)
+});
+var findTarget = (context, project, pkg, revision, requestedName) => targetIndexFor(context, project, pkg, revision).lookup(requestedName);
+var targetIndexFor = (context, project, pkg, revision) => context.cacheForRevision(`target-index:${pkg.tsconfigPath}`, revision, () => {
+  const memo = new Map;
+  let declarationIndex;
+  const loadDeclarationIndex = () => {
+    declarationIndex ??= buildDeclarationTargetIndex(project, pkg.path, context.root);
+    return declarationIndex;
+  };
+  return {
+    lookup: (requestedName) => {
+      const cached = memo.get(requestedName);
+      if (cached !== undefined)
+        return cached;
+      const pending = (async () => {
+        const byName = await loadDeclarationIndex();
+        const fromIndex = byName.get(requestedName);
+        if (fromIndex !== undefined)
+          return fromIndex;
+        return findTargetByScan(project, pkg.path, context.root, requestedName);
+      })();
+      memo.set(requestedName, pending);
+      return pending;
+    }
+  };
+});
+var buildDeclarationTargetIndex = async (project, packagePath, rootPath) => {
+  const byName = new Map;
+  const sourceFiles = await projectSourceFiles(project, packagePath);
+  for (const sourceFile of sourceFiles) {
+    const named = [];
+    visit(sourceFile, (node) => {
+      if (node.kind === SyntaxKind2.Identifier && declarationForName(node) !== undefined) {
+        named.push(node);
+        return;
+      }
+      if (node.kind === SyntaxKind2.ExportSpecifier) {
+        const exportName = node.name;
+        if (exportName.kind === SyntaxKind2.Identifier)
+          named.push(exportName);
+      }
+    });
+    if (named.length === 0)
+      continue;
+    const symbols = await project.checker.getSymbolAtLocation(named);
+    for (let index = 0;index < named.length; index += 1) {
+      const nameNode = named[index];
+      const key = nameNode.getText(sourceFile);
+      if (byName.has(key))
+        continue;
+      const symbol = symbols[index];
+      if (symbol === undefined)
+        continue;
+      const resolved = await resolveSymbol(project, symbol);
+      const declaration = declarationForName(nameNode) ?? await findDeclarationForSymbol(sourceFile, project, resolved);
+      if (declaration !== undefined) {
+        byName.set(key, { symbol: resolved, declaration, packagePath, rootPath });
+        continue;
+      }
+      const first = resolved.declarations[0];
+      const fallback = first === undefined ? undefined : await first.resolve(project);
+      if (fallback !== undefined)
+        byName.set(key, { symbol: resolved, declaration: fallback, packagePath, rootPath });
+    }
+  }
+  if (!byName.has("default")) {
+    for (const sourceFile of sourceFiles) {
+      const moduleSymbol = await project.checker.getSymbolAtLocation(sourceFile);
+      if (moduleSymbol === undefined)
+        continue;
+      const exports = await project.checker.getExportsOfModule(moduleSymbol);
+      const defaultExport = exports.find((candidate) => candidate.name === "default");
+      if (defaultExport === undefined)
+        continue;
+      const resolved = await resolveSymbol(project, defaultExport);
+      const declaration = await findDeclarationForSymbol(sourceFile, project, resolved);
+      if (declaration !== undefined) {
+        byName.set("default", { symbol: resolved, declaration, packagePath, rootPath });
+        break;
+      }
+      const first = resolved.declarations[0];
+      const node = first === undefined ? undefined : await first.resolve(project);
+      if (node !== undefined) {
+        byName.set("default", { symbol: resolved, declaration: node, packagePath, rootPath });
+        break;
+      }
+    }
+  }
+  return byName;
+};
+var findTargetByScan = async (project, packagePath, rootPath, requestedName) => {
+  const sourceFiles = await projectSourceFiles(project, packagePath);
+  let canonical;
+  for (const sourceFile of sourceFiles) {
+    const identifiers = [];
+    visit(sourceFile, (node) => {
+      if (node.kind === SyntaxKind2.Identifier && node.getText(sourceFile) === requestedName)
+        identifiers.push(node);
+    });
+    if (identifiers.length === 0)
+      continue;
+    const symbols = await project.checker.getSymbolAtLocation(identifiers);
+    for (let index = 0;index < identifiers.length; index += 1) {
+      const identifier = identifiers[index];
+      const symbol = symbols[index];
+      if (symbol === undefined)
+        continue;
+      const resolved = await resolveSymbol(project, symbol);
+      canonical ??= resolved;
+      if (resolved.id !== canonical.id)
+        continue;
+      const declaration = declarationForName(identifier);
+      if (declaration !== undefined)
+        return { symbol: resolved, declaration, packagePath, rootPath };
+    }
+    if (canonical !== undefined)
+      break;
+  }
+  if (canonical !== undefined) {
+    for (const sourceFile of sourceFiles) {
+      const declaration2 = await findDeclarationForSymbol(sourceFile, project, canonical);
+      if (declaration2 !== undefined)
+        return { symbol: canonical, declaration: declaration2, packagePath, rootPath };
+    }
+    const first = canonical.declarations[0];
+    const declaration = first === undefined ? undefined : await first.resolve(project);
+    if (declaration !== undefined)
+      return { symbol: canonical, declaration, packagePath, rootPath };
+  }
+  if (requestedName === "default") {
+    for (const sourceFile of sourceFiles) {
+      const moduleSymbol = await project.checker.getSymbolAtLocation(sourceFile);
+      if (moduleSymbol === undefined)
+        continue;
+      const exports = await project.checker.getExportsOfModule(moduleSymbol);
+      const defaultExport = exports.find((candidate) => candidate.name === "default");
+      if (defaultExport === undefined)
+        continue;
+      const resolved = await resolveSymbol(project, defaultExport);
+      const declaration = await findDeclarationForSymbol(sourceFile, project, resolved);
+      if (declaration !== undefined)
+        return { symbol: resolved, declaration, packagePath, rootPath };
+      const first = resolved.declarations[0];
+      const node = first === undefined ? undefined : await first.resolve(project);
+      if (node !== undefined)
+        return { symbol: resolved, declaration: node, packagePath, rootPath };
+    }
+  }
+  return null;
+};
+var findDeclarationForSymbol = async (sourceFile, project, target) => {
+  for (const handle of target.declarations) {
+    const declaration = await handle.resolve(project);
+    if (declaration !== undefined && declaration.getSourceFile().fileName === sourceFile.fileName)
+      return declaration;
+  }
+  return;
+};
+var findIncomingReferences = async (project, target) => {
+  const results = [];
+  const seen = new Set;
+  const perFileCounts = new Map;
+  const add = async (node, symbol = target.symbol) => {
+    if (node.kind !== SyntaxKind2.Identifier || isImportReference(node))
+      return;
+    const sourceFile = node.getSourceFile();
+    if (!isProjectSourceFile(sourceFile.fileName, target.packagePath))
+      return;
+    const fileCount = perFileCounts.get(sourceFile.fileName) ?? 0;
+    if (fileCount >= MAX_REFERENCE_RESULTS_PER_FILE)
+      return;
+    if (!await matchesCanonicalSymbol(project, symbol, target.symbol))
+      return;
+    if (isTargetDeclarationName(node, target))
+      return;
+    const containing = await findContainingSymbol(project, node.parent, target.symbol);
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const context = classifyReferenceContext(node.parent);
+    const key = `${sourceFile.fileName}:${node.getStart(sourceFile)}:${containing}:${context}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    perFileCounts.set(sourceFile.fileName, fileCount + 1);
+    results.push({
+      symbol: containing,
+      context,
+      file: relativePath2(target.rootPath, sourceFile.fileName),
+      line: position.line + 1
+    });
+  };
+  const declarationName2 = declarationNameNode(target.declaration) ?? target.declaration;
+  const declarationPosition = declarationName2.getStart(declarationName2.getSourceFile());
+  try {
+    const referenced = await project.checker.getReferencedSymbolsForNode(declarationName2, declarationPosition);
+    for (const entry of referenced) {
+      const handles = [entry.definition, ...entry.references];
+      for (const handle of handles) {
+        const node = await handle.resolve(project);
+        if (node !== undefined)
+          await add(node, entry.symbol ?? target.symbol);
+      }
+    }
+    if (results.length > 0)
+      return results;
+  } catch {}
+  const sourceFiles = await projectSourceFiles(project, target.packagePath);
+  for (const sourceFile of sourceFiles) {
+    const handles = await project.checker.getReferencesToSymbolInFile(sourceFile.fileName, target.symbol);
+    for (const handle of handles) {
+      const node = await handle.resolve(project);
+      if (node !== undefined)
+        await add(node);
+    }
+    const typeNodes = [];
+    visit(sourceFile, (node) => {
+      if (node.kind === SyntaxKind2.Identifier && isTypeReferencePosition(node))
+        typeNodes.push(node);
+    });
+    if (typeNodes.length === 0)
+      continue;
+    const symbols = await project.checker.getSymbolAtLocation(typeNodes);
+    for (let index = 0;index < typeNodes.length; index += 1) {
+      await add(typeNodes[index], symbols[index]);
+    }
+  }
+  return results;
+};
+var findOutgoingReferences = async (project, target) => {
+  const references = [];
+  const seen = new Set;
+  const add = async (symbol, context) => {
+    if (symbol === undefined)
+      return;
+    const resolved = await resolveSymbol(project, symbol);
+    if (resolved.id === target.symbol.id || PRIMITIVE_NAMES[resolved.name] === true)
+      return;
+    const key = `${resolved.id}:${context}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    references.push({ symbol: resolved.name, context });
+  };
+  const type = await project.checker.getTypeAtLocation(target.declaration);
+  if (await skipOutgoingType(type))
+    return references;
+  const properties = await project.checker.getPropertiesOfType(type);
+  for (const property of properties.slice(0, 50)) {
+    const declarationHandle = property.declarations[0];
+    if (declarationHandle === undefined)
+      continue;
+    const declaration = await declarationHandle.resolve(project);
+    if (declaration === undefined)
+      continue;
+    const propertyType = await project.checker.getTypeOfSymbolAtLocation(property, declaration);
+    await add(await propertyType.getSymbol() ?? await propertyType.getAliasSymbol(), `property "${property.name}"`);
+  }
+  if (type.isClassOrInterface()) {
+    const baseTypes = await project.checker.getBaseTypes(type);
+    for (const baseType of baseTypes)
+      await add(await baseType.getSymbol() ?? await baseType.getAliasSymbol(), "extends");
+  }
+  return references;
+};
+var findRenameSites = async (project, target) => {
+  const sites = [];
+  const seen = new Set;
+  const declarationName2 = declarationNameNode(target.declaration) ?? target.declaration;
+  const position = declarationName2.getStart(declarationName2.getSourceFile());
+  try {
+    const referenced = await project.checker.getReferencedSymbolsForNode(declarationName2, position);
+    for (const entry of referenced) {
+      const handles = [entry.definition, ...entry.references];
+      for (const handle of handles) {
+        const node = await handle.resolve(project);
+        if (node === undefined || node.kind !== SyntaxKind2.Identifier)
+          continue;
+        const sourceFile = node.getSourceFile();
+        if (!isProjectSourceFile(sourceFile.fileName, target.packagePath))
+          continue;
+        addSite(sites, seen, sourceFile, node);
+      }
+    }
+    if (sites.length > 0)
+      return sites;
+  } catch {}
+  const sourceFiles = await projectSourceFiles(project, target.packagePath);
+  const resolvedTarget = await resolveSymbol(project, target.symbol);
+  for (const sourceFile of sourceFiles) {
+    const nodes = [];
+    visit(sourceFile, (node) => {
+      if (node.kind === SyntaxKind2.Identifier)
+        nodes.push(node);
+    });
+    if (nodes.length === 0)
+      continue;
+    const symbols = await project.checker.getSymbolAtLocation(nodes);
+    for (let index = 0;index < nodes.length; index += 1) {
+      const node = nodes[index];
+      const symbol = symbols[index];
+      if (symbol === undefined)
+        continue;
+      const resolved = await resolveSymbol(project, symbol);
+      if (resolved.id !== resolvedTarget.id)
+        continue;
+      addSite(sites, seen, sourceFile, node);
+    }
+  }
+  return sites;
+};
+var addSite = (sites, seen, sourceFile, node) => {
+  const key = `${sourceFile.fileName}:${node.pos}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  sites.push({ sourceFile, node });
+};
+var findContainingSymbol = async (project, start, target) => {
+  let current = start;
+  while (current !== undefined && current.kind !== SyntaxKind2.SourceFile) {
+    const nameNode = declarationNameNode(current);
+    if (nameNode !== undefined) {
+      const symbol = await project.checker.getSymbolAtLocation(nameNode);
+      if (symbol !== undefined && !await matchesCanonicalSymbol(project, symbol, target))
+        return symbol.name;
+    }
+    current = current.parent;
+  }
+  const sourceFile = start.getSourceFile();
+  const moduleSymbol = await project.checker.getSymbolAtLocation(sourceFile);
+  return moduleSymbol?.name ?? "anonymous";
+};
+var resolveSymbol = async (project, symbol) => {
+  try {
+    return await project.checker.getAliasedSymbol(symbol);
+  } catch {
+    return symbol;
+  }
+};
+var matchesCanonicalSymbol = async (project, candidate, target) => (await resolveSymbol(project, candidate)).id === target.id;
+var projectSourceFiles = async (project, packagePath) => {
+  const names = await project.program.getSourceFileNames();
+  const files = [];
+  for (const name of names) {
+    if (!isProjectSourceFile(name, packagePath))
+      continue;
+    const sourceFile = await project.program.getSourceFile(name);
+    if (sourceFile !== undefined)
+      files.push(sourceFile);
+  }
+  return files;
+};
+var isProjectSourceFile = (fileName, packagePath) => {
+  const file = resolve6(fileName);
+  const root = resolve6(packagePath);
+  return (file === root || file.startsWith(`${root}/`)) && !file.includes("/node_modules/");
+};
+var relativePath2 = (root, fileName) => {
+  const file = resolve6(fileName);
+  const normalizedRoot = resolve6(root);
+  return file === normalizedRoot || file.startsWith(`${normalizedRoot}/`) ? relative4(normalizedRoot, file) : file;
+};
+var visit = (node, callback) => {
+  callback(node);
+  node.forEachChild((child) => {
+    visit(child, callback);
+  });
+};
+var declarationForName = (nameNode) => {
+  const parent = nameNode.parent;
+  if (declarationNameNode(parent) === nameNode)
+    return parent;
+  return;
+};
+var isImportReference = (node) => {
+  let current = node.parent;
+  while (current !== undefined && current.kind !== SyntaxKind2.SourceFile) {
+    if (current.kind === SyntaxKind2.ImportDeclaration)
+      return true;
+    current = current.parent;
+  }
+  return false;
+};
+var declarationNameNode = (node) => {
+  switch (node.kind) {
+    case SyntaxKind2.ClassDeclaration:
+    case SyntaxKind2.ClassExpression:
+    case SyntaxKind2.FunctionDeclaration:
+    case SyntaxKind2.FunctionExpression:
+    case SyntaxKind2.InterfaceDeclaration:
+    case SyntaxKind2.TypeAliasDeclaration:
+    case SyntaxKind2.EnumDeclaration:
+    case SyntaxKind2.VariableDeclaration:
+    case SyntaxKind2.MethodDeclaration:
+    case SyntaxKind2.MethodSignature:
+    case SyntaxKind2.PropertyDeclaration:
+    case SyntaxKind2.PropertySignature:
+    case SyntaxKind2.EnumMember:
+    case SyntaxKind2.ImportEqualsDeclaration:
+      return node.name;
+    default:
+      return;
+  }
+};
+var isTargetDeclarationName = (node, target) => {
+  const declaration = declarationForName(node);
+  return declaration !== undefined && declaration.pos === target.declaration.pos;
+};
+var isTypeReferencePosition = (node) => {
+  const parent = node.parent;
+  return parent !== undefined && (parent.kind === SyntaxKind2.TypeReference || parent.kind === SyntaxKind2.ExpressionWithTypeArguments || isTypeReferenceNode2(parent));
+};
+var classifyReferenceContext = (parent) => {
+  switch (parent.kind) {
+    case SyntaxKind2.HeritageClause:
+      return "extends";
+    case SyntaxKind2.TypeReference:
+    case SyntaxKind2.ExpressionWithTypeArguments:
+      return "type reference";
+    case SyntaxKind2.PropertyAccessExpression:
+      return "property access";
+    case SyntaxKind2.CallExpression:
+      return "call";
+    default:
+      return "usage";
+  }
+};
+var skipOutgoingType = async (type) => {
+  if (type.isIntrinsicType() || type.isLiteralType())
+    return true;
+  if (type.isUnionType()) {
+    const members = await type.getTypes();
+    return members.every((member) => member.isIntrinsicType() || member.isLiteralType());
+  }
+  return false;
+};
+var toMermaid = (edges) => {
+  const lines = ["graph TD"];
+  const seen = new Set;
+  for (const edge of edges) {
+    const from = sanitizeMermaidId(edge.from);
+    const to = sanitizeMermaidId(edge.to);
+    const key = `${from}-->${to}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const label = edge.label?.replace(/"/g, "'").replace(/[|[\]]/g, "");
+    lines.push(label === undefined ? `  ${from} --> ${to}` : `  ${from} -->|${label}| ${to}`);
+  }
+  return lines.join(`
+`);
+};
+var toDot = (edges) => {
+  const lines = ["digraph G {", "  rankdir=TB;", "  node [shape=box];"];
+  const seen = new Set;
+  for (const edge of edges) {
+    const key = `${edge.from}->${edge.to}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const from = `"${edge.from.replace(/"/g, "\\\"")}"`;
+    const to = `"${edge.to.replace(/"/g, "\\\"")}"`;
+    const label = edge.label?.replace(/"/g, "\\\"");
+    lines.push(label === undefined ? `  ${from} -> ${to};` : `  ${from} -> ${to} [label="${label}"];`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+};
+var sanitizeMermaidId = (name) => name.replace(/[^a-zA-Z0-9_]/g, "_");
+var addRenameSafetyError = (errors, sourceFile, file, packagePath, line) => {
+  if (errors.some((error) => error.file === file && error.line === line))
+    return;
+  if (sourceFile.isDeclarationFile)
+    errors.push({ file, line, message: "Cannot rename: declaration file (.d.ts)" });
+  else if (!isProjectSourceFile(sourceFile.fileName, packagePath))
+    errors.push({ file, line, message: "Cannot rename: file is outside package boundary" });
+};
+var getLineText = (sourceFile, line) => {
+  const starts = sourceFile.getLineStarts();
+  const start = starts[line] ?? 0;
+  const end = starts[line + 1] ?? sourceFile.text.length;
+  return sourceFile.text.slice(start, end).replace(/\r$/, "");
+};
+var replaceSiteOnTrimmedLine = (lineText, trimmed, character, token, replacement) => {
+  const trimOffset = lineText.length - lineText.trimStart().length;
+  const relativeCharacter = character - trimOffset;
+  if (relativeCharacter >= 0 && relativeCharacter + token.length <= trimmed.length && trimmed.slice(relativeCharacter, relativeCharacter + token.length) === token) {
+    return `${trimmed.slice(0, relativeCharacter)}${replacement}${trimmed.slice(relativeCharacter + token.length)}`;
+  }
+  return trimmed.replace(new RegExp(`\\b${escapeRegex(token)}\\b`, "g"), replacement);
+};
+var collectStringLiteralLocations = (sourceFile, root, symbolName, results) => {
+  const regex = new RegExp(`\\b${escapeRegex(symbolName)}\\b`);
+  visit(sourceFile, (node) => {
+    if (node.kind !== SyntaxKind2.StringLiteral)
+      return;
+    const content = node.getText(sourceFile).slice(1, -1);
+    if (!regex.test(content))
+      return;
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    results.push({ file: relativePath2(root, sourceFile.fileName), line: position.line + 1, content: content.length > 50 ? `${content.slice(0, 50)}...` : content });
+  });
+};
+var collectCommentLocations = (sourceFile, root, symbolName, results) => {
+  const regex = new RegExp(`\\b${escapeRegex(symbolName)}\\b`);
+  const lines = sourceFile.text.split(/\n/);
+  const file = relativePath2(root, sourceFile.fileName);
+  for (let index = 0;index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, "");
+    const singleLine = line.match(/\/\/(.*)$/);
+    if (singleLine !== null && regex.test(singleLine[1])) {
+      results.push({ file, line: index + 1, content: truncateComment(singleLine[1].trim()) });
+      continue;
+    }
+    if ((line.includes("/*") || line.includes("*")) && regex.test(line)) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("*") || trimmed.startsWith("/*") || trimmed.startsWith("//"))
+        results.push({ file, line: index + 1, content: truncateComment(trimmed) });
+    }
+  }
+};
+var truncateComment = (content) => content.length > 50 ? `${content.slice(0, 50)}...` : content;
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+// src/transform-search/index.ts
+import { join as join4, relative as relative5 } from "path";
+import {
+  ModifierFlags as ModifierFlags2,
+  SignatureKind as SignatureKind2,
+  TypeFlags
+} from "typescript/unstable/async";
+import {
+  SyntaxKind as SyntaxKind3
+} from "typescript/unstable/ast";
+import {
+  isArrowFunction,
+  isCallExpression,
+  isCallSignatureDeclaration,
+  isClassDeclaration as isClassDeclaration2,
+  isConstructorDeclaration,
+  isFunctionDeclaration as isFunctionDeclaration2,
+  isFunctionExpression,
+  isInterfaceDeclaration as isInterfaceDeclaration2,
+  isMethodDeclaration,
+  isMethodSignatureDeclaration,
+  isNewExpression,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isPropertySignatureDeclaration,
+  isTypeAliasDeclaration as isTypeAliasDeclaration2,
+  isVariableDeclaration as isVariableDeclaration2,
+  isVariableStatement as isVariableStatement2
+} from "typescript/unstable/ast/is";
+var modifierFlagsOf = (node) => node.modifierFlags ?? ModifierFlags2.None;
+var hasModifier = (node, flag) => (modifierFlagsOf(node) & flag) !== ModifierFlags2.None;
+var textOfName = (node, sourceFile) => node.name?.getText(sourceFile).replace(/^["']|["']$/g, "") ?? "anonymous";
+var variableStatement = (node) => {
+  let current = node.parent;
+  while (current !== undefined && current.kind !== SyntaxKind3.SourceFile) {
+    if (isVariableStatement2(current))
+      return current;
+    current = current.parent;
+  }
+  return null;
+};
+var exportedFrom = (node) => {
+  let current = node;
+  while (current !== undefined && current.kind !== SyntaxKind3.SourceFile) {
+    if (hasModifier(current, ModifierFlags2.Export))
+      return true;
+    current = current.parent;
+  }
+  const statement = variableStatement(node);
+  return statement !== null && hasModifier(statement, ModifierFlags2.Export);
+};
+var containerNameOf = (node, sourceFile) => {
+  let current = node.parent;
+  while (current !== undefined && current.kind !== SyntaxKind3.SourceFile) {
+    if (isClassDeclaration2(current) || isInterfaceDeclaration2(current) || isTypeAliasDeclaration2(current)) {
+      return textOfName(current, sourceFile);
+    }
+    if (isObjectLiteralExpression(current) && current.parent !== undefined && isVariableDeclaration2(current.parent)) {
+      return textOfName(current.parent, sourceFile);
+    }
+    current = current.parent;
+  }
+  return null;
+};
+var returnTypeNodeOf = (node) => node.type ?? null;
+var nodeName = (node, sourceFile) => {
+  const named = node;
+  return named.name === undefined ? "anonymous" : named.name.getText(sourceFile).replace(/^["']|["']$/g, "");
+};
+var enclosingNameNode = (node) => {
+  let current = node.parent;
+  while (current !== undefined && current.kind !== SyntaxKind3.SourceFile) {
+    const name = current.name;
+    if (name !== undefined)
+      return name;
+    current = current.parent;
+  }
+  return null;
+};
+var enumerate = (sourceFiles) => {
+  const candidates = [];
+  const append = (sourceFile, callable, kind, name, symbolNode) => {
+    const containerName = containerNameOf(callable, sourceFile);
+    candidates.push({
+      callableId: `declaration:${candidates.length}`,
+      signatureKey: null,
+      compilerSignature: null,
+      symbolNode,
+      sourceFile,
+      callable,
+      name,
+      kind,
+      exported: exportedFrom(callable),
+      deprecated: /@deprecated\b/.test(callable.getFullText(sourceFile)),
+      containerName,
+      params: callable.parameters,
+      returnNode: returnTypeNodeOf(callable)
+    });
+  };
+  const visit2 = (node, sourceFile) => {
+    if (isFunctionDeclaration2(node) && node.name !== undefined) {
+      const implementationExists = sourceFile.statements.some((statement) => isFunctionDeclaration2(statement) && statement.name?.getText(sourceFile) === node.name?.getText(sourceFile) && statement.body !== undefined);
+      if (node.body !== undefined || !implementationExists)
+        append(sourceFile, node, "Function", nodeName(node, sourceFile), node.name);
+    } else if (isVariableDeclaration2(node) && node.initializer !== undefined && (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+      append(sourceFile, node.initializer, "VariableCallable", nodeName(node, sourceFile), node.name);
+    } else if (isMethodDeclaration(node)) {
+      const kind = isClassDeclaration2(node.parent) ? hasModifier(node, ModifierFlags2.Static) ? "StaticMethod" : "ClassMethod" : "ObjectMethod";
+      append(sourceFile, node, kind, nodeName(node, sourceFile), node.name);
+    } else if (isConstructorDeclaration(node)) {
+      const className = isClassDeclaration2(node.parent) ? node.parent.name ?? null : null;
+      append(sourceFile, node, "Constructor", "constructor", className);
+    } else if (isMethodSignatureDeclaration(node) || isCallSignatureDeclaration(node)) {
+      const symbolNode = isMethodSignatureDeclaration(node) ? node.name : enclosingNameNode(node);
+      append(sourceFile, node, isMethodSignatureDeclaration(node) ? "InterfaceMethod" : "TypeLiteralMethod", nodeName(node, sourceFile), symbolNode);
+    } else if (isPropertySignatureDeclaration(node) && node.type !== undefined && (node.type.kind === SyntaxKind3.FunctionType || node.type.kind === SyntaxKind3.ConstructorType)) {
+      append(sourceFile, node.type, "CallableProperty", nodeName(node, sourceFile), node.name);
+    } else if (isPropertyAssignment(node) && (isArrowFunction(node.initializer) || isFunctionExpression(node.initializer))) {
+      append(sourceFile, node.initializer, "ObjectMethod", nodeName(node, sourceFile), node.name);
+    }
+    node.forEachChild((child) => visit2(child, sourceFile));
+  };
+  for (const sourceFile of sourceFiles)
+    visit2(sourceFile, sourceFile);
+  return candidates;
+};
+var signatureKeyForNode = (node) => {
+  const sourceFile = node.getSourceFile();
+  return `${sourceFile.fileName}:${node.getStart(sourceFile)}:${node.getEnd()}:${node.kind}`;
+};
+var needsSignatureExpansion = (group) => group.seedCount > 1 || (group.symbol?.declarations.length ?? 0) > 1;
+var symbolsForSeeds = async (project, seeds) => {
+  const indexes = [];
+  const nodes = [];
+  for (let index = 0;index < seeds.length; index += 1) {
+    const node = seeds[index].symbolNode;
+    if (node === null)
+      continue;
+    indexes.push(index);
+    nodes.push(node);
+  }
+  const symbols = nodes.length === 0 ? [] : await project.checker.getSymbolAtLocation(nodes);
+  const bySeed = new Map;
+  for (let index = 0;index < symbols.length; index += 1) {
+    const symbol = symbols[index];
+    if (symbol !== undefined)
+      bySeed.set(indexes[index], symbol);
+  }
+  return bySeed;
+};
+var groupCandidateSeeds = (seeds, symbols) => {
+  const groups = new Map;
+  for (let index = 0;index < seeds.length; index += 1) {
+    const seed = seeds[index];
+    const symbol = symbols.get(index) ?? null;
+    const callableId = symbol === null ? seed.callableId : `${symbol.id}:${seed.kind}`;
+    const existing = groups.get(callableId);
+    groups.set(callableId, existing === undefined ? { seed, symbol, seedCount: 1 } : { ...existing, seedCount: existing.seedCount + 1 });
+  }
+  return groups;
+};
+var valueTypesForGroups = async (project, groups) => {
+  const entries = [...groups.entries()].filter((entry) => entry[1].symbol !== null && entry[1].seed.kind !== "TypeLiteralMethod" && needsSignatureExpansion(entry[1]));
+  const types = entries.length === 0 ? [] : await project.checker.getTypeOfSymbol(entries.map(([, group]) => group.symbol));
+  return new Map(entries.map(([callableId], index) => [callableId, types[index]]));
+};
+var expandCandidateGroup = async (project, callableId, group, valueTypes) => {
+  if (group.symbol === null || !needsSignatureExpansion(group)) {
+    return [{ ...group.seed, callableId, signatureKey: signatureKeyForNode(group.seed.callable) }];
+  }
+  const type = group.seed.kind === "TypeLiteralMethod" ? await project.checker.getDeclaredTypeOfSymbol(group.symbol) : valueTypes.get(callableId);
+  const signatureKind = group.seed.kind === "Constructor" || group.seed.callable.kind === SyntaxKind3.ConstructorType ? SignatureKind2.Construct : SignatureKind2.Call;
+  const signatures = type.isErrorType() ? [] : await project.checker.getSignaturesOfType(type, signatureKind);
+  const candidates = [];
+  for (const signature of signatures) {
+    const declaration = await signature.declaration?.resolve(project);
+    const callable = declaration;
+    if (callable === undefined || callable.parameters === undefined)
+      continue;
+    const sourceFile = callable.getSourceFile();
+    candidates.push({
+      ...group.seed,
+      callableId,
+      signatureKey: signatureKeyForNode(callable),
+      compilerSignature: signature,
+      sourceFile,
+      callable,
+      deprecated: /@deprecated\b/.test(callable.getFullText(sourceFile)),
+      params: callable.parameters,
+      returnNode: returnTypeNodeOf(callable)
+    });
+  }
+  return candidates.length === 0 ? [{ ...group.seed, callableId, signatureKey: null, compilerSignature: null }] : candidates;
+};
+var compilerCandidates = async (project, seeds) => {
+  const groups = groupCandidateSeeds(seeds, await symbolsForSeeds(project, seeds));
+  const valueTypes = await valueTypesForGroups(project, groups);
+  const candidates = [];
+  for (const [callableId, group] of groups) {
+    candidates.push(...await expandCandidateGroup(project, callableId, group, valueTypes));
+  }
+  return candidates;
+};
+var typeText = (node, sourceFile) => node === null ? "unknown" : node.getText(sourceFile).trim();
+var wrapperOf = (text) => {
+  const match = /^(Promise|PromiseLike|Effect|Observable|Task)\s*</.exec(text.replace(/\s/g, ""));
+  return match === null ? null : match[1];
+};
+var unwrapText = (text, wrapper) => {
+  if (wrapper === null)
+    return text;
+  const compact = text.replace(/\s/g, "");
+  return compact.slice(wrapper.length + 1, compact.endsWith(">") ? -1 : undefined);
+};
+var erased = (type) => type !== null && (type.flags & TypeFlags.AnyOrUnknown) !== 0;
+var lineFor = (candidate) => candidate.sourceFile.getLineAndCharacterOfPosition(candidate.callable.getStart(candidate.sourceFile)).line + 1;
+var signatureFor = (candidate, resolvedReturnText) => {
+  const params = candidate.params.map((param) => param.getText(candidate.sourceFile).trim()).join(", ");
+  const returnText = resolvedReturnText ?? (candidate.returnNode === null ? "unknown" : typeText(candidate.returnNode, candidate.sourceFile));
+  return `${candidate.name}(${params}): ${returnText}`;
+};
+var compareMatches = (left, right) => right.score - left.score || left.candidate.name.localeCompare(right.candidate.name) || left.candidate.sourceFile.fileName.localeCompare(right.candidate.sourceFile.fileName) || lineFor(left.candidate) - lineFor(right.candidate);
+var groupMatchesByCallable = (matches) => {
+  const byCallable = new Map;
+  const groups = [];
+  for (const match of matches) {
+    const existing = byCallable.get(match.candidate.callableId);
+    if (existing === undefined) {
+      const group = [match];
+      byCallable.set(match.candidate.callableId, group);
+      groups.push(group);
+    } else {
+      existing.push(match);
+    }
+  }
+  return groups;
+};
+var confidenceFor = (match) => {
+  if (match.verified && (match.exactFrom || match.exactTo))
+    return "high";
+  if (!match.partial && (match.exactFrom || match.exactTo))
+    return "medium";
+  return "low";
+};
+var queryTypeFor = async (raw, sourceFiles, checker, availableTypes) => {
+  const normalized = raw.trim();
+  const exact = availableTypes.get(normalized);
+  if (exact !== undefined) {
+    return { raw: normalized, type: exact.type, exactText: normalized, resolved: !exact.type.isErrorType() };
+  }
+  let declarationType = null;
+  let declarationName2 = null;
+  const visit2 = (node) => {
+    if (declarationType !== null)
+      return;
+    if (isTypeAliasDeclaration2(node) && node.name.getText(node.getSourceFile()) === normalized) {
+      declarationType = node.type;
+      declarationName2 = node.name;
+    } else if ((node.kind === SyntaxKind3.InterfaceDeclaration || node.kind === SyntaxKind3.ClassDeclaration) && node.name?.getText(node.getSourceFile()) === normalized) {
+      declarationName2 = node.name;
+    }
+    node.forEachChild(visit2);
+  };
+  for (const sourceFile of sourceFiles)
+    visit2(sourceFile);
+  if (declarationType !== null) {
+    const type = await checker.getTypeAtLocation(declarationType);
+    return { raw: normalized, type, exactText: normalized, resolved: !type.isErrorType() };
+  }
+  if (declarationName2 !== null) {
+    const symbol = await checker.getSymbolAtLocation(declarationName2);
+    if (symbol !== undefined) {
+      const type = await checker.getDeclaredTypeOfSymbol(symbol);
+      return { raw: normalized, type, exactText: normalized, resolved: !type.isErrorType() };
+    }
+  }
+  return { raw: normalized, type: null, exactText: null, resolved: false };
+};
+var createExplanation = (match) => {
+  const from = match.from === null ? undefined : {
+    description: `${match.from.paramName} accepts ${match.from.queryType}`,
+    paramName: match.from.paramName,
+    paramIndex: match.from.paramIndex,
+    compatibility: match.from.exact ? "exact" : "assignable"
+  };
+  const to = match.to === null ? undefined : {
+    description: `returns ${match.to.queryType}`,
+    compatibility: match.to.exact ? "exact" : "assignable",
+    ...match.to.unwrapped && match.to.wrapper !== null ? { unwrapped: { wrapper: match.to.wrapper, originalType: match.to.returnType } } : {}
+  };
+  return {
+    summary: [from === undefined ? null : `accepts ${match.from?.queryType}`, to === undefined ? null : `returns ${match.to?.queryType}`].filter(Boolean).join(" and "),
+    details: {
+      ...from === undefined ? {} : { fromMatch: from },
+      ...to === undefined ? {} : { toMatch: to },
+      verification: { method: match.verification.method === "synthetic" ? "synthetic" : "assignability-only", passed: match.verification.status === "verified" }
+    },
+    confidence: match.confidence
+  };
+};
+var syntheticSequence = 0;
+var diagnosticText = (diagnostic) => typeof diagnostic.text === "string" ? diagnostic.text : String(diagnostic.text);
+var findSyntheticCall = (sourceFile) => {
+  let found = null;
+  const visit2 = (node) => {
+    if (found !== null)
+      return;
+    if (isCallExpression(node) || isNewExpression(node)) {
+      found = node;
+      return;
+    }
+    node.forEachChild(visit2);
+  };
+  sourceFile.forEachChild(visit2);
+  return found;
+};
+var syntheticCall = (match) => {
+  const candidate = match.candidate;
+  if (!candidate.exported || match.from === null || match.to === null)
+    return null;
+  if (candidate.kind === "InterfaceMethod" || candidate.kind === "TypeLiteralMethod")
+    return null;
+  const args = candidate.params.map((_, index) => index === match.from?.paramIndex ? "__input" : "undefined as never").join(", ");
+  if (candidate.kind === "Constructor") {
+    return candidate.containerName === null ? null : `new ${candidate.containerName}(${args})`;
+  }
+  if (candidate.containerName === null)
+    return `${candidate.name}(${args})`;
+  if (candidate.kind === "StaticMethod" || candidate.kind === "ObjectMethod") {
+    return `${candidate.containerName}.${candidate.name}(${args})`;
+  }
+  return `(null as unknown as (typeof ${candidate.containerName})["prototype"]).${candidate.name}(${args})`;
+};
+var verifySyntheticMatch = async (context, project, packageInfo, match, options) => {
+  const call = syntheticCall(match);
+  if (call === null || options.from === undefined || options.to === undefined) {
+    return {
+      verification: { status: "unverifiable", method: null, reason: "not_importable" },
+      selectedSignatureKey: null
+    };
+  }
+  const virtualFilePath = join4(resolveVirtualFileDirectory(packageInfo.path), `__quartz_transform_verify_${(syntheticSequence++).toString(36)}.ts`);
+  const imports = await synthesizePackageImports(project, packageInfo.path, virtualFilePath);
+  const assignment = match.to?.unwrapped && (match.to.wrapper === "Promise" || match.to.wrapper === "PromiseLike") ? `async function __quartzVerify() {
+  const __output: __QueryTo = await ${call}
+}` : `const __output: __QueryTo = ${call}`;
+  const syntheticCode = `${imports.content}type __QueryFrom = ${options.from}
+type __QueryTo = ${options.to}
+declare const __input: __QueryFrom
+${assignment}
+`;
+  const syntheticResult = await context.workspace.withVirtualFile(packageInfo.tsconfigPath, virtualFilePath, syntheticCode, async (syntheticProject, filePath) => {
+    const diagnostics = (await Promise.all([
+      syntheticProject.program.getSyntacticDiagnostics(filePath),
+      syntheticProject.program.getBindDiagnostics(filePath),
+      syntheticProject.program.getSemanticDiagnostics(filePath)
+    ])).flat();
+    if (diagnostics.length > 0)
+      return { diagnostics, selectedSignatureKey: null };
+    const sourceFile = await syntheticProject.program.getSourceFile(filePath);
+    const callNode = sourceFile === undefined ? null : findSyntheticCall(sourceFile);
+    if (callNode === null)
+      return { diagnostics, selectedSignatureKey: null };
+    const signature = await syntheticProject.checker.getResolvedSignature(callNode);
+    if (await syntheticProject.checker.isUnknownSignature(signature)) {
+      return { diagnostics, selectedSignatureKey: null };
+    }
+    const declaration = await signature.declaration?.resolve(syntheticProject);
+    return {
+      diagnostics,
+      selectedSignatureKey: declaration === undefined ? null : signatureKeyForNode(declaration)
+    };
+  });
+  const failed = syntheticResult.diagnostics.length > 0 || syntheticResult.selectedSignatureKey === null;
+  return {
+    verification: {
+      status: failed ? "unverified" : "verified",
+      method: "synthetic",
+      reason: failed ? "synthetic_check_failed" : "synthetic_check_passed",
+      ...syntheticResult.diagnostics.length > 0 && options.includeDiagnostics === true ? { diagnostics: syntheticResult.diagnostics.map((diagnostic) => ({ code: diagnostic.code, message: diagnosticText(diagnostic) })) } : {},
+      ...options.includeSyntheticCode === true ? { syntheticCode } : {}
+    },
+    selectedSignatureKey: syntheticResult.selectedSignatureKey
+  };
+};
+var SYNTHETIC_OVERSCAN = 10;
+var SYNTHETIC_VERIFICATION_BATCH_SIZE = 8;
+var SOURCE_FILE_BATCH_SIZE = 32;
+var verifyUnfilteredGroups = async (groups, limit, verify) => {
+  const prefixLength = Math.min(groups.length, limit + SYNTHETIC_OVERSCAN);
+  const verifiedPrefix = await Promise.all(groups.slice(0, prefixLength).map(verify));
+  return [...verifiedPrefix, ...groups.slice(prefixLength).map((group) => group[0])].sort(compareMatches);
+};
+var verifyTrustedGroups = async (groups, limit, verify) => {
+  if (limit === 0)
+    return [];
+  const matches = [];
+  let verifiedCount = 0;
+  let start = 0;
+  while (start < groups.length) {
+    if (verifiedCount >= limit) {
+      const threshold = matches.filter((match) => match.verification.status === "verified").sort(compareMatches)[limit - 1];
+      const nextUpperBound = groups[start]?.[0];
+      if (threshold === undefined || nextUpperBound === undefined || compareMatches(nextUpperBound, threshold) >= 0) {
+        break;
+      }
+    }
+    const batchSize = verifiedCount < limit ? Math.min(SYNTHETIC_VERIFICATION_BATCH_SIZE, limit - verifiedCount) : 1;
+    const batch = await Promise.all(groups.slice(start, start + batchSize).map(verify));
+    matches.push(...batch);
+    verifiedCount += batch.filter((match) => match.verification.status === "verified").length;
+    start += batchSize;
+  }
+  return matches.sort(compareMatches);
+};
+var loadTransformIndex = async (project) => {
+  const sourceNames = await project.program.getSourceFileNames();
+  const sourceFiles = [];
+  for (let start = 0;start < sourceNames.length; start += SOURCE_FILE_BATCH_SIZE) {
+    const batch = await Promise.all(sourceNames.slice(start, start + SOURCE_FILE_BATCH_SIZE).map((name) => project.program.getSourceFile(name)));
+    sourceFiles.push(...batch.filter((sourceFile) => sourceFile !== undefined && !sourceFile.isDeclarationFile && !sourceFile.fileName.includes("node_modules")));
+  }
+  const allCandidates = await compilerCandidates(project, enumerate(sourceFiles));
+  const availableNodes = [];
+  for (const candidate of allCandidates) {
+    for (const param of candidate.params) {
+      const type = param.type;
+      if (type !== undefined)
+        availableNodes.push(type);
+    }
+    if (candidate.returnNode !== null)
+      availableNodes.push(candidate.returnNode);
+  }
+  const availableTypes = new Map;
+  const byNode = new Map;
+  const checkerNodes = [...availableNodes, ...allCandidates.map((candidate) => candidate.callable)];
+  if (checkerNodes.length > 0) {
+    const values = await project.checker.getTypeAtLocation(checkerNodes);
+    for (let index = 0;index < checkerNodes.length; index += 1) {
+      const node = checkerNodes[index];
+      const value = values[index];
+      byNode.set(node, value);
+      if (index < availableNodes.length) {
+        const typeNode = availableNodes[index];
+        if (!availableTypes.has(typeNode.getText(typeNode.getSourceFile()).trim())) {
+          availableTypes.set(typeNode.getText(typeNode.getSourceFile()).trim(), { node: typeNode, type: value });
+        }
+      }
+    }
+  }
+  const inferredReturnTypes = new Map;
+  const inferredReturnTexts = new Map;
+  for (const candidate of allCandidates) {
+    let returnType = candidate.returnNode === null ? null : byNode.get(candidate.returnNode) ?? null;
+    if (candidate.returnNode === null) {
+      if (candidate.compilerSignature !== null) {
+        returnType = await project.checker.getReturnTypeOfSignature(candidate.compilerSignature);
+      } else {
+        const callableType = byNode.get(candidate.callable);
+        if (callableType !== undefined) {
+          const signatures = await project.checker.getSignaturesOfType(callableType, SignatureKind2.Call);
+          const signature = signatures[0];
+          if (signature !== undefined)
+            returnType = await project.checker.getReturnTypeOfSignature(signature);
+        }
+      }
+      if (returnType !== null) {
+        inferredReturnTexts.set(candidate, await project.checker.typeToString(returnType, candidate.callable));
+      }
+    }
+    inferredReturnTypes.set(candidate, returnType);
+  }
+  return { sourceFiles, allCandidates, availableTypes, byNode, inferredReturnTypes, inferredReturnTexts };
+};
+var createTransformSearchOperation = (context) => async (options) => {
+  const started = performance.now();
+  const paramPosition = options.paramPosition ?? 0;
+  const unwrapReturn = options.unwrapReturn ?? true;
+  const exportedOnly = options.exportedOnly ?? true;
+  const limit = Math.max(0, options.limit ?? 25);
+  if (options.from === undefined && options.to === undefined)
+    throw new Error("At least one of 'from' or 'to' is required");
+  return context.withProject(async (project, pkg, revision) => {
+    const index = await context.cacheForRevision(`transform-index:${pkg.tsconfigPath}`, revision, () => loadTransformIndex(project));
+    const { sourceFiles, availableTypes, byNode, inferredReturnTypes, inferredReturnTexts } = index;
+    const candidates = index.allCandidates.filter((candidate) => !exportedOnly || candidate.exported);
+    const fromQuery = options.from === undefined ? null : await queryTypeFor(options.from, sourceFiles, project.checker, availableTypes);
+    const toQuery = options.to === undefined ? null : await queryTypeFor(options.to, sourceFiles, project.checker, availableTypes);
+    const unresolved = fromQuery?.resolved === false ? { field: "from", query: fromQuery } : toQuery?.resolved === false ? { field: "to", query: toQuery } : null;
+    if (unresolved !== null) {
+      throw new QuartzEngineError("TRANSFORM_QUERY_UNRESOLVED", `Could not resolve transform-search ${unresolved.field} type ${JSON.stringify(unresolved.query.raw)}. Declare an exported named type or alias and retry.`);
+    }
+    const matches = [];
+    for (const candidate of candidates) {
+      const positions = paramPosition === "any" ? candidate.params.map((_, index2) => index2) : [paramPosition];
+      let fromMatch = null;
+      let fromAssignable = options.from === undefined;
+      let fromErased = false;
+      let exactFrom = options.from === undefined;
+      if (fromQuery !== null) {
+        for (const index2 of positions) {
+          const param = candidate.params[index2];
+          if (param === undefined)
+            continue;
+          const paramType = byNode.get(param.type ?? param) ?? null;
+          const paramErased = erased(paramType);
+          if (!options.allowTypeErasure && paramErased)
+            continue;
+          const assignable = fromQuery.type !== null && paramType !== null ? await project.checker.isTypeAssignableTo(fromQuery.type, paramType) : typeText(param.type ?? null, candidate.sourceFile) === fromQuery.raw;
+          if (!assignable)
+            continue;
+          const paramName = param.name?.getText(candidate.sourceFile) ?? `arg${index2}`;
+          const paramText = typeText(param.type ?? null, candidate.sourceFile);
+          const exact = paramText.replace(/\s/g, "") === fromQuery.raw.replace(/\s/g, "");
+          fromMatch = { matched: true, paramIndex: index2, paramName, queryType: fromQuery.raw, paramType: paramText, exact, ...paramErased ? { typeErasure: true } : {} };
+          fromAssignable = true;
+          fromErased = paramErased;
+          exactFrom = exact;
+          break;
+        }
+      }
+      if (fromQuery !== null && !fromAssignable)
+        continue;
+      let toMatch = null;
+      let toAssignable = options.to === undefined;
+      let toErased = false;
+      let exactTo = options.to === undefined;
+      let returnType = inferredReturnTypes.get(candidate) ?? null;
+      let returnText = candidate.returnNode === null ? inferredReturnTexts.get(candidate) ?? "unknown" : typeText(candidate.returnNode, candidate.sourceFile);
+      if (candidate.kind === "Constructor" && candidate.containerName !== null)
+        returnText = candidate.containerName;
+      const wrapper = wrapperOf(returnText);
+      let comparisonText = returnText;
+      let unwrapped = false;
+      if (unwrapReturn && wrapper !== null) {
+        comparisonText = unwrapText(returnText, wrapper);
+        if (returnType !== null && returnType.isTypeReference()) {
+          const args = await project.checker.getTypeArguments(returnType);
+          if (args[0] !== undefined)
+            returnType = args[0];
+        }
+        unwrapped = true;
+      }
+      if (toQuery !== null) {
+        const returnErased = erased(returnType);
+        if (!options.allowTypeErasure && returnErased)
+          continue;
+        const constructorExact = candidate.kind === "Constructor" && candidate.containerName === toQuery.raw;
+        const assignable = constructorExact || (toQuery.type !== null && returnType !== null ? await project.checker.isTypeAssignableTo(returnType, toQuery.type) : comparisonText.replace(/\s/g, "") === toQuery.raw.replace(/\s/g, ""));
+        if (!assignable)
+          continue;
+        const exact = constructorExact || comparisonText.replace(/\s/g, "") === toQuery.raw.replace(/\s/g, "");
+        toMatch = { matched: true, returnType: returnText, queryType: toQuery.raw, exact, unwrapped, wrapper, ...returnErased ? { typeErasure: true } : {} };
+        toAssignable = true;
+        toErased = returnErased;
+        exactTo = exact;
+      }
+      const partial = fromQuery === null || toQuery === null || !fromQuery.resolved || !toQuery?.resolved;
+      const assignabilityOk = !partial && fromAssignable && toAssignable && !fromErased && !toErased;
+      const verification = assignabilityOk ? {
+        status: "unverified",
+        method: exactFrom && exactTo ? "exact_match" : "assignability_only",
+        reason: "assignability_pending_synthetic"
+      } : {
+        status: "unverified",
+        method: "assignability_only",
+        reason: partial ? "partial_query" : fromErased || toErased ? "type_erasure" : "synthetic_check_failed"
+      };
+      const score = (exactFrom ? 40 : fromMatch === null ? 0 : 24) + (exactTo ? 40 : toMatch === null ? 0 : 24) + (assignabilityOk ? 20 : 0) + (candidate.exported ? 8 : 0) - (candidate.deprecated ? 15 : 0) + (candidate.kind === "Function" ? 2 : 0) - (toMatch?.unwrapped ? 10 : 0);
+      const confidence = confidenceFor({ exactFrom, exactTo, verified: false, partial });
+      matches.push({ candidate, from: fromMatch, to: toMatch, fromAssignable, toAssignable, returnText, verification, score, confidence });
+    }
+    matches.sort(compareMatches);
+    const matchGroups = groupMatchesByCallable(matches);
+    const assignabilityMs = performance.now() - started;
+    const syntheticStarted = performance.now();
+    const trustFiltered = options.verifiedOnly === true || options.minVerificationStatus === "verified";
+    const finalizeVerification = (match, verification) => {
+      const verified = verification.status === "verified";
+      return {
+        ...match,
+        verification,
+        confidence: verification.reason === "synthetic_check_failed" ? "low" : confidenceFor({
+          exactFrom: match.from?.exact === true,
+          exactTo: match.to?.exact === true,
+          verified,
+          partial: match.from === null || match.to === null || !fromQuery?.resolved || !toQuery?.resolved
+        })
+      };
+    };
+    const verifyPending = async (group) => {
+      const provisional = group[0];
+      if (provisional.verification.reason !== "assignability_pending_synthetic") {
+        return finalizeVerification(provisional, provisional.verification);
+      }
+      const synthetic = await verifySyntheticMatch(context, project, pkg, provisional, options);
+      const selected = synthetic.selectedSignatureKey === null ? undefined : group.find((match) => match.candidate.signatureKey === synthetic.selectedSignatureKey);
+      if (synthetic.verification.status === "verified" && selected === undefined) {
+        return finalizeVerification(provisional, {
+          ...synthetic.verification,
+          status: "unverified",
+          reason: "synthetic_check_failed"
+        });
+      }
+      return finalizeVerification(selected ?? provisional, synthetic.verification);
+    };
+    const rankedMatches = trustFiltered ? await verifyTrustedGroups(matchGroups, limit, verifyPending) : await verifyUnfilteredGroups(matchGroups, limit, verifyPending);
+    const syntheticMs = performance.now() - syntheticStarted;
+    const statusCounts = { verified: 0, unverified: 0, unverifiable: 0 };
+    for (const match of rankedMatches)
+      statusCounts[match.verification.status] += 1;
+    const filtered = rankedMatches.filter((match) => {
+      if (match.verification.reason === "synthetic_check_failed" && options.includeFailedVerification !== true)
+        return false;
+      if (options.verifiedOnly && match.verification.status !== "verified")
+        return false;
+      if (options.minVerificationStatus !== undefined) {
+        const order = { unverifiable: 0, unverified: 1, verified: 2 };
+        if (order[match.verification.status] < order[options.minVerificationStatus])
+          return false;
+      }
+      return true;
+    }).slice(0, limit);
+    const results = filtered.map((match) => ({
+      name: match.candidate.containerName === null ? match.candidate.name : `${match.candidate.containerName}.${match.candidate.name}`,
+      signature: signatureFor(match.candidate, match.returnText),
+      kind: match.candidate.kind,
+      file: relative5(pkg.path, match.candidate.sourceFile.fileName).replaceAll("\\", "/"),
+      line: lineFor(match.candidate),
+      exported: match.candidate.exported,
+      deprecated: match.candidate.deprecated,
+      score: match.score,
+      confidence: match.confidence,
+      explanation: createExplanation(match),
+      verification: match.verification,
+      matchDetails: { fromMatch: match.from, toMatch: match.to }
+    }));
+    const totalMs = performance.now() - started;
+    return {
+      results,
+      query: {
+        from: options.from?.trim() ?? null,
+        to: options.to?.trim() ?? null,
+        options: {
+          paramPosition,
+          unwrapReturn,
+          exportedOnly,
+          ...options.verifiedOnly === undefined ? {} : { verifiedOnly: options.verifiedOnly },
+          ...options.minVerificationStatus === undefined ? {} : { minVerificationStatus: options.minVerificationStatus },
+          ...options.includeDiagnostics === undefined ? {} : { includeDiagnostics: options.includeDiagnostics },
+          ...options.includeSyntheticCode === undefined ? {} : { includeSyntheticCode: options.includeSyntheticCode },
+          ...options.includeFailedVerification === undefined ? {} : { includeFailedVerification: options.includeFailedVerification }
+        }
+      },
+      stats: {
+        totalCandidates: new Set(candidates.map((candidate) => candidate.callableId)).size,
+        assignableMatches: matchGroups.length,
+        verifiedMatches: statusCounts.verified,
+        verification: statusCounts,
+        returned: results.length,
+        timing: { indexLookupMs: 0, resolutionMs: 0, assignabilityMs: Math.max(0, assignabilityMs), syntheticMs: Math.max(0, syntheticMs), totalMs }
+      }
+    };
+  }, options.packageName);
+};
+
+// src/verification-operations.ts
+import { DiagnosticCategory as DiagnosticCategory3 } from "typescript/unstable/async";
+var workspaceWithVirtualFile = (context) => {
+  const workspace = context.workspace;
+  if (typeof workspace.withVirtualFile !== "function") {
+    throw new Error("checkSnippet requires QuartzWorkspace.withVirtualFile(tsconfigPath, filePath, content, operation), which runs runWithTemporaryFileUpdate against the immutable base snapshot");
+  }
+  return workspace;
+};
+var lineAndColumn = (source, position) => {
+  const location = source.getLineAndCharacterOfPosition(Math.max(0, position));
+  return { line: location.line + 1, column: location.character + 1 };
+};
+var snippetDiagnostics = async (project, filePath, lineOffset = 0) => {
+  const diagnostics = (await Promise.all([
+    project.program.getSyntacticDiagnostics(filePath),
+    project.program.getBindDiagnostics(filePath),
+    project.program.getSemanticDiagnostics(filePath)
+  ])).flat();
+  const sourceFile = await project.program.getSourceFile(filePath);
+  const seen = new Set;
+  const result = [];
+  for (const diagnostic of diagnostics) {
+    const key = `${diagnostic.code}\x00${diagnostic.pos}\x00${diagnostic.end}\x00${diagnostic.text}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const location = sourceFile === undefined ? { line: 1, column: 1 } : lineAndColumn(sourceFile, diagnostic.pos);
+    result.push({
+      message: diagnostic.text,
+      line: Math.max(1, location.line - lineOffset),
+      column: location.column,
+      severity: diagnostic.category === DiagnosticCategory3.Error ? "error" : "warning"
+    });
+  }
+  return result.sort((left, right) => left.line - right.line || left.column - right.column || left.message.localeCompare(right.message));
+};
+var typePatterns = [
+  /Type '([^']+)' is not assignable to type '([^']+)'/,
+  /Argument of type '([^']+)' is not assignable to parameter of type '([^']+)'/,
+  /Type ([\w$]+(?:\.[\w$]+)*) is not assignable to type ([\w$]+(?:\.[\w$]+)*)/,
+  /Argument of type ([\w$]+(?:\.[\w$]+)*) is not assignable to parameter of type ([\w$]+(?:\.[\w$]+)*)/,
+  /Property '[^']+' does not exist on type '([^']+)'/,
+  /Property '[^']+' is missing in type '([^']+)' but required in type '([^']+)'/,
+  /Property ([\w$]+) is missing in type ([\w$]+(?:\.[\w$]+)*) but required in type ([\w$]+(?:\.[\w$]+)*)/,
+  /Type '([^']+)' has no properties in common with type '([^']+)'/
+];
+var propertyPatterns = [
+  /Property '([^']+)' does not exist/,
+  /Property '([^']+)' is missing/,
+  /Property ([\w$]+) does not exist/,
+  /Property ([\w$]+) is missing/,
+  /Did you mean '([^']+)'\?/
+];
+var extractErrorParts = (message) => {
+  const types = [];
+  const properties = [];
+  for (const pattern of typePatterns) {
+    const match = pattern.exec(message);
+    if (match === null)
+      continue;
+    for (const value of match.slice(1)) {
+      if (value !== undefined && !(value.startsWith("{") && value.endsWith("}")))
+        types.push(value);
+    }
+    break;
+  }
+  for (const pattern of propertyPatterns) {
+    const match = pattern.exec(message);
+    if (match?.[1] !== undefined)
+      properties.push(match[1]);
+  }
+  return { types, properties };
+};
+var asDiagnostics = (value) => ("errors" in value) ? value.errors : value;
+var skipped = (summary) => ({ ran: false, passed: null, blocking: false, summary });
+var toVerifyDiagnostic = (diagnostic) => ({
+  file: diagnostic.file ?? "",
+  line: diagnostic.line ?? 1,
+  column: diagnostic.column ?? 1,
+  message: diagnostic.message,
+  code: diagnostic.code
+});
+var createVerificationOperations = (context, dependencies) => {
+  const checkSnippet = async (code, packageName) => {
+    const pkg = context.package(packageName);
+    const registry = dependencies.virtualFiles ?? createVirtualFileRegistry(resolveVirtualFileDirectory(pkg.path));
+    const workspace = workspaceWithVirtualFile(context);
+    return withVirtualFile(registry, code, async (lease) => {
+      const imports = typeof context.withProject !== "function" ? { content: "", lineOffset: 0 } : await context.withProject((project) => synthesizePackageImports(project, pkg.path, lease.path), packageName);
+      return workspace.withVirtualFile(pkg.tsconfigPath, lease.path, `${imports.content}${lease.content}`, async (project, filePath) => {
+        const errors = await snippetDiagnostics(project, filePath, imports.lineOffset);
+        return errors.length === 0 ? { valid: true } : { valid: false, errors };
+      });
+    });
+  };
+  const explainError = async (options) => {
+    let code = options.code ?? 0;
+    let message = options.message ?? "";
+    if (message.length === 0 && (options.code !== undefined || options.file !== undefined && options.line !== undefined)) {
+      const diagnostics = asDiagnostics(await dependencies.diagnostics(options.packageName));
+      const match = options.file !== undefined && options.line !== undefined ? diagnostics.find((diagnostic) => diagnostic.file?.endsWith(options.file) && diagnostic.line === options.line && (options.code === undefined || diagnostic.code === options.code)) : diagnostics.find((diagnostic) => diagnostic.code === options.code);
+      if (match !== undefined) {
+        code = match.code;
+        message = match.message;
+      }
+    }
+    if (message.length === 0)
+      return null;
+    const extracted = extractErrorParts(message);
+    const explanationIssues = [];
+    const suggestions = [];
+    const result = { error: { code, message }, explanation: message, issues: explanationIssues, suggestions };
+    const firstType = extracted.types[0];
+    const secondType = extracted.types[1];
+    if ((code === 2322 || code === 2345) && firstType !== undefined && secondType !== undefined) {
+      let compatibility;
+      try {
+        const packageOption = options.packageName === undefined ? {} : { packageName: options.packageName };
+        compatibility = await dependencies.compatibility(firstType, secondType, packageOption.packageName);
+      } catch {
+        compatibility = undefined;
+      }
+      const issues = compatibility?.issues ?? [];
+      explanationIssues.push(...issues);
+      if (!compatibility?.compatible) {
+        result.explanation = `You're trying to use a value of type '${firstType}' where a value of type '${secondType}' is expected. These types are not compatible.`;
+      }
+      suggestions.push(`Add missing properties: ${secondType}`);
+      suggestions.push(`Use Partial<${secondType}> if properties should be optional`);
+    } else if (code === 2339 && firstType !== undefined && extracted.properties[0] !== undefined) {
+      const property = extracted.properties[0];
+      explanationIssues.push({ kind: "missing_property", property, message: `Property '${property}' does not exist on type '${firstType}'` });
+      result.explanation = `You're trying to access property '${property}' on type '${firstType}', but this property doesn't exist.`;
+      suggestions.push(`Check for typos in the property name`);
+      suggestions.push(`Add property '${property}' to the type`);
+    } else if (code === 2741 && extracted.properties[0] !== undefined && secondType !== undefined) {
+      const property = extracted.properties[0];
+      explanationIssues.push({ kind: "missing_property", property, message: `Property '${property}' is required but missing` });
+      result.explanation = `Type '${firstType ?? "the source"}' is missing required property '${property}' that '${secondType}' expects.`;
+      suggestions.push(`Add '${property}' to your object`);
+      suggestions.push(`Make '${property}' optional in ${secondType} using '${property}?:'`);
+    } else {
+      explanationIssues.push({ kind: "other", message });
+      suggestions.push("Review the types involved using type_expand");
+      suggestions.push("Check type compatibility using type_compatible");
+    }
+    return result;
+  };
+  const verifyContract = async (options) => {
+    const from = options.from?.trim() || undefined;
+    const to = options.to?.trim() || undefined;
+    const symbol = options.symbol?.trim() || undefined;
+    const packageName = options.packageName?.trim() || undefined;
+    const checks = {
+      compatibility: skipped("Skipped because both from and to were not provided."),
+      snippet: skipped("Skipped because no snippet was provided."),
+      diagnostics: skipped("Skipped because includeDiagnostics was false."),
+      transform: skipped("Skipped because both from and to were not provided.")
+    };
+    const evidence = {};
+    const gaps = [];
+    const nextSteps = new Set;
+    const explanations = [];
+    if (from === undefined !== (to === undefined)) {
+      gaps.push("Only one side of the from/to contract was provided.");
+      nextSteps.add("Provide both from and to to run compatibility and transform verification.");
+    } else if (from !== undefined && to !== undefined) {
+      const compatibility = await dependencies.compatibility(from, to, packageName);
+      evidence.compatibility = compatibility;
+      checks.compatibility = {
+        ran: true,
+        passed: compatibility.compatible,
+        blocking: false,
+        summary: compatibility.compatible ? `${from} is directly assignable to ${to}.` : `${from} is not directly assignable to ${to}; verified transform evidence can still satisfy a conversion contract.`,
+        evidence: compatibility
+      };
+      if (!compatibility.compatible) {
+        gaps.push("Direct assignability is not established for from -> to.");
+        const explanationOptions = {
+          code: 2322,
+          message: compatibility.reason ?? `Type ${from} is not assignable to type ${to}.`,
+          ...packageName === undefined ? {} : { packageName }
+        };
+        const explanation = await explainError(explanationOptions);
+        if (explanation !== null)
+          explanations.push(explanation);
+      }
+    }
+    if (options.snippet === undefined) {
+      gaps.push("No snippet was supplied, so Quartz did not verify a concrete call site.");
+      nextSteps.add("Add a minimal snippet that exercises the proposed contract at a call site.");
+    } else {
+      const snippet = await checkSnippet(options.snippet, packageName);
+      evidence.snippet = snippet;
+      checks.snippet = {
+        ran: true,
+        passed: snippet.valid,
+        blocking: true,
+        summary: snippet.valid ? "Snippet compiles under the package TypeScript project." : "Snippet has TypeScript errors.",
+        evidence: snippet
+      };
+      if (!snippet.valid) {
+        gaps.push("The supplied snippet does not compile.");
+        nextSteps.add("Repair the snippet until check-snippet returns valid: true.");
+        const firstError = snippet.errors?.[0];
+        if (firstError !== undefined) {
+          const explanationOptions = {
+            message: firstError.message,
+            ...packageName === undefined ? {} : { packageName }
+          };
+          const explanation = await explainError(explanationOptions);
+          if (explanation !== null)
+            explanations.push(explanation);
+        }
+      }
+    }
+    if (options.includeDiagnostics !== false) {
+      const diagnostics = asDiagnostics(await dependencies.diagnostics(packageName));
+      const diagnosticEvidence = diagnostics.map(toVerifyDiagnostic);
+      evidence.diagnostics = diagnosticEvidence;
+      checks.diagnostics = {
+        ran: true,
+        passed: diagnosticEvidence.length === 0,
+        blocking: true,
+        summary: diagnosticEvidence.length === 0 ? "Package diagnostics are clean." : `Package has ${diagnosticEvidence.length} TypeScript diagnostic(s).`,
+        evidence: diagnosticEvidence
+      };
+      if (diagnosticEvidence.length > 0) {
+        gaps.push("The package has ambient TypeScript diagnostics.");
+        nextSteps.add("Inspect diagnostics before trusting the contract in this project state.");
+      }
+    }
+    if (from !== undefined && to !== undefined) {
+      if (options.includeTransformEvidence === false) {
+        gaps.push("Transform evidence was skipped by includeTransformEvidence: false.");
+        if (symbol !== undefined)
+          nextSteps.add("Enable transform evidence to verify that the requested symbol backs the contract.");
+      } else {
+        const transformOptions = {
+          from,
+          to,
+          verifiedOnly: true,
+          limit: options.transformLimit ?? 10,
+          ...packageName === undefined ? {} : { packageName }
+        };
+        const transformSearch = await dependencies.transformSearch(transformOptions);
+        evidence.transformSearch = transformSearch;
+        const verifiedResults = transformSearch.results.filter((result) => result.verification.status === "verified");
+        const symbolMatched = symbol === undefined || verifiedResults.some((result) => result.name === symbol || result.name.endsWith(`.${symbol}`));
+        const passed = verifiedResults.length > 0 && symbolMatched;
+        checks.transform = {
+          ran: true,
+          passed,
+          blocking: true,
+          summary: passed ? "A compiler-verified transform satisfies the requested contract." : symbol === undefined ? "No compiler-verified transform candidate matched the requested contract." : `No compiler-verified transform candidate matched the requested symbol '${symbol}'.`,
+          evidence: transformSearch
+        };
+        if (!passed) {
+          gaps.push(symbol === undefined ? "No compiler-verified transform candidate matched the requested contract." : `No compiler-verified transform candidate matched the requested symbol '${symbol}'.`);
+          nextSteps.add("Run transform-search with includeDiagnostics/includeSyntheticCode to inspect candidate verifier failures.");
+        }
+      }
+    }
+    if (explanations.length > 0)
+      evidence.explanations = explanations;
+    const directAssignable = checks.compatibility.passed === true;
+    const transformPassed = checks.transform.passed === true;
+    const snippetOk = checks.snippet.passed !== false;
+    const diagnosticsOk = checks.diagnostics.passed !== false;
+    const hasFromTo = from !== undefined && to !== undefined;
+    const contractEvidenceOk = hasFromTo ? directAssignable || transformPassed : true;
+    const hasPositiveEvidence = directAssignable || transformPassed || checks.snippet.passed === true;
+    const blockingChecksPassed = Object.values(checks).every((check) => !check.blocking || check.passed === true);
+    const ok = snippetOk && diagnosticsOk && contractEvidenceOk && hasPositiveEvidence && blockingChecksPassed;
+    if (!ok)
+      nextSteps.add("Treat this contract as untrusted until a blocking check passes.");
+    return {
+      schemaVersion: "verify-contract/v1",
+      ok,
+      contract: { ...from === undefined ? {} : { from }, ...to === undefined ? {} : { to }, ...symbol === undefined ? {} : { symbol }, package: context.package(packageName).name },
+      checks,
+      evidence,
+      gaps,
+      next_steps: [...nextSteps]
+    };
+  };
+  return { checkSnippet, explainError, verifyContract };
+};
+
+// src/analyzer.ts
+class QuartzAnalyzer {
+  #context;
+  #leaf;
+  #references;
+  #transformSearchOperation;
+  #verification;
+  #disposePromise = null;
+  constructor(context) {
+    this.#context = context;
+    this.#leaf = createLeafOperations(context);
+    this.#references = createReferenceOperations(context);
+    this.#transformSearchOperation = createTransformSearchOperation(context);
+    this.#verification = createVerificationOperations(context, {
+      compatibility: this.#leaf.checkCompatibility,
+      diagnostics: this.#leaf.getDiagnostics,
+      transformSearch: this.#transformSearchOperation
+    });
+  }
+  static async open(root, options) {
+    return new QuartzAnalyzer(await AnalyzerContext.open(root, options));
+  }
+  get metadata() {
+    return this.#context.workspace.metadata;
+  }
+  getTimingInfo = () => this.#context.workspace.getTimingInfo();
+  resetTimingInfo = () => this.#context.workspace.resetTimingInfo();
+  getPackages = async () => {
+    this.#assertOpen();
+    return this.#leaf.getPackages();
+  };
+  listSymbols = (options) => this.#leaf.listSymbols(options);
+  getTypeInfo = (symbolName, packageName) => this.#leaf.getTypeInfo(symbolName, packageName);
+  expandType = (symbolName, packageName) => this.#leaf.expandType(symbolName, packageName);
+  findRelated = (symbolName, packageName) => this.#references.findRelated(symbolName, packageName);
+  searchTypes = (options) => this.#leaf.searchTypes(options);
+  evalType = (expression, packageName) => this.#leaf.evalType(expression, packageName);
+  checkSnippet = (code, packageName) => this.#verification.checkSnippet(code, packageName);
+  getFileDeclarations = (file, options) => this.#leaf.getFileDeclarations(file, options);
+  checkCompatibility = (from, to, packageName) => this.#leaf.checkCompatibility(from, to, packageName);
+  generateGraph = (symbol, options) => this.#references.generateGraph(symbol, options);
+  previewRefactor = (options) => this.#references.previewRefactor(options);
+  getDiagnostics = async (packageNameOrOptions) => {
+    const packageName = typeof packageNameOrOptions === "string" ? packageNameOrOptions : packageNameOrOptions?.packageName;
+    const diagnostics = await this.#leaf.getDiagnostics(packageName);
+    if (typeof packageNameOrOptions !== "object" || packageNameOrOptions.explain !== true) {
+      return diagnostics;
+    }
+    const raw = diagnostics;
+    const errors = [];
+    for (const diagnostic of raw.slice(0, 10)) {
+      const explanation = await this.#verification.explainError({
+        code: diagnostic.code,
+        message: diagnostic.message,
+        ...diagnostic.file === undefined ? {} : { file: diagnostic.file },
+        ...diagnostic.line === undefined ? {} : { line: diagnostic.line },
+        ...packageName === undefined ? {} : { packageName }
+      });
+      errors.push({ ...diagnostic, explanation });
+    }
+    return {
+      totalErrors: raw.length,
+      explained: errors.length,
+      truncated: raw.length > 10,
+      errors
+    };
+  };
+  getTypeAtPosition = (filePath, line, column, packageName) => this.#leaf.getTypeAtPosition(filePath, line, column, packageName);
+  explainError = (options) => this.#verification.explainError(options);
+  explainType = (expression, packageName) => this.#leaf.explainType(expression, packageName);
+  transformSearch = (options) => this.#transformSearchOperation(options);
+  verifyContract = (options) => this.#verification.verifyContract(options);
+  async refresh(packageName) {
+    if (packageName === undefined) {
+      await this.#context.refresh();
+      return "Refreshed all TypeScript projects";
+    }
+    const pkg = this.#context.package(packageName);
+    await this.#context.refreshPackage(packageName);
+    return `Refreshed package ${pkg.name}`;
+  }
+  async markDirty() {
+    this.#context.markDirty();
+  }
+  dispose() {
+    this.#disposePromise ??= this.#context.close();
+    return this.#disposePromise;
+  }
+  #assertOpen() {
+    if (this.#disposePromise !== null) {
+      throw new QuartzEngineError("WORKSPACE_CLOSED", `Quartz analyzer at ${this.#context.root} is closed`);
+    }
+  }
+}
+var createTypeAnalyzer = (root, options) => QuartzAnalyzer.open(root, options);
+export {
+  openQuartzWorkspace,
+  createTypeAnalyzer,
+  version2 as analysisTypeScriptVersion,
+  QuartzWorkspace,
+  QuartzEngineError,
+  QuartzAnalyzer
+};