@lite-fsm/cli 0.1.0

package/dist/export-graph/source-bundle.js

@@ -0,0 +1,48 @@
+import { resolve } from "node:path";
+import { cliDiagnostic } from "../cli/diagnostics.js";
+import { normalizeAbsolutePath, normalizePath } from "../project/source-cache.js";
+const sourcePath = (projectRoot, fileName) => normalizeAbsolutePath(resolve(projectRoot, fileName));
+const createProjectGraphSourceBundle = (context, projectRoot, files) => {
+  const sourceFiles = [];
+  for (const file of files) {
+    const absolutePath = sourcePath(projectRoot, file.fileName);
+    try {
+      if (!context.fs.fileExists(absolutePath)) {
+        return {
+          ok: false,
+          diagnostics: [
+            cliDiagnostic(
+              "LFC_SOURCE_BUNDLE_FILE_UNREADABLE",
+              "error",
+              `Source file '${file.fileName}' could not be embedded in the graph export.`,
+              { file: normalizePath(absolutePath) }
+            )
+          ]
+        };
+      }
+      sourceFiles.push({
+        fileName: file.fileName,
+        language: file.language,
+        hash: file.hash,
+        text: context.fs.readFile(absolutePath)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        diagnostics: [
+          cliDiagnostic(
+            "LFC_SOURCE_BUNDLE_FILE_UNREADABLE",
+            "error",
+            `Source file '${file.fileName}' could not be embedded in the graph export: ${message}`,
+            { file: normalizePath(absolutePath) }
+          )
+        ]
+      };
+    }
+  }
+  return { ok: true, sources: { files: sourceFiles } };
+};
+export {
+  createProjectGraphSourceBundle
+};

package/dist/export-graph/write-output.d.cts

@@ -0,0 +1,10 @@
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type WriteOutputResult = {
+    ok: true;
+    outputPath: string;
+} | {
+    ok: false;
+    diagnostics: CliDiagnostic[];
+};
+export declare const writeOutput: (context: CliContext, outputPath: string, contents: string) => WriteOutputResult;

package/dist/export-graph/write-output.d.ts

@@ -0,0 +1,10 @@
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type WriteOutputResult = {
+    ok: true;
+    outputPath: string;
+} | {
+    ok: false;
+    diagnostics: CliDiagnostic[];
+};
+export declare const writeOutput: (context: CliContext, outputPath: string, contents: string) => WriteOutputResult;

package/dist/export-graph/write-output.js

@@ -0,0 +1,24 @@
+import { dirname, resolve } from "node:path";
+import { cliDiagnostic } from "../cli/diagnostics.js";
+import { normalizeAbsolutePath } from "../project/source-cache.js";
+const writeOutput = (context, outputPath, contents) => {
+  const absoluteOutputPath = normalizeAbsolutePath(resolve(context.cwd, outputPath));
+  try {
+    context.fs.mkdir(dirname(absoluteOutputPath), { recursive: true });
+    context.fs.writeFile(absoluteOutputPath, contents);
+    return { ok: true, outputPath: absoluteOutputPath };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      diagnostics: [
+        cliDiagnostic("LFC_WRITE_FAILED", "error", `Failed to write graph export: ${message}`, {
+          file: absoluteOutputPath
+        })
+      ]
+    };
+  }
+};
+export {
+  writeOutput
+};

package/dist/output/format-diagnostics.d.cts

@@ -0,0 +1,6 @@
+import type { GraphDiagnostic } from "@lite-fsm/graph";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+type PrintableDiagnostic = CliDiagnostic | GraphDiagnostic;
+export declare const formatDiagnostic: (diagnostic: PrintableDiagnostic) => string;
+export declare const formatDiagnostics: (diagnostics: readonly PrintableDiagnostic[]) => string;
+export {};

package/dist/output/format-diagnostics.d.ts

@@ -0,0 +1,6 @@
+import type { GraphDiagnostic } from "@lite-fsm/graph";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+type PrintableDiagnostic = CliDiagnostic | GraphDiagnostic;
+export declare const formatDiagnostic: (diagnostic: PrintableDiagnostic) => string;
+export declare const formatDiagnostics: (diagnostics: readonly PrintableDiagnostic[]) => string;
+export {};

package/dist/output/format-diagnostics.js

@@ -0,0 +1,33 @@
+const diagnosticFile = (diagnostic) => {
+  if ("file" in diagnostic && diagnostic.file) return diagnostic.file;
+  if (!diagnostic.loc || !("fileName" in diagnostic.loc)) return void 0;
+  return diagnostic.loc.fileName;
+};
+const diagnosticLine = (diagnostic) => {
+  if (!diagnostic.loc) return void 0;
+  if ("line" in diagnostic.loc) return diagnostic.loc.line;
+  return diagnostic.loc.start.line;
+};
+const diagnosticColumn = (diagnostic) => {
+  if (!diagnostic.loc) return void 0;
+  if ("line" in diagnostic.loc) return "column" in diagnostic.loc ? diagnostic.loc.column : void 0;
+  return diagnostic.loc.start.column;
+};
+const formatDiagnostic = (diagnostic) => {
+  const file = diagnosticFile(diagnostic);
+  const line = diagnosticLine(diagnostic);
+  const column = diagnosticColumn(diagnostic);
+  const location = file ? ` ${file}${line === void 0 ? "" : `:${line}:${column ?? 1}`}` : "";
+  const hint = "hint" in diagnostic && diagnostic.hint ? `
+  hint: ${diagnostic.hint}` : "";
+  return `${diagnostic.severity.toUpperCase()} ${diagnostic.code}${location}: ${diagnostic.message}${hint}`;
+};
+const formatDiagnostics = (diagnostics) => {
+  if (diagnostics.length === 0) return "";
+  return `${diagnostics.map(formatDiagnostic).join("\n")}
+`;
+};
+export {
+  formatDiagnostic,
+  formatDiagnostics
+};

package/dist/output/stable-json.d.cts

@@ -0,0 +1 @@
+export declare const stringifyStableJson: (value: unknown) => string;

package/dist/output/stable-json.d.ts

@@ -0,0 +1 @@
+export declare const stringifyStableJson: (value: unknown) => string;

package/dist/output/stable-json.js

@@ -0,0 +1,72 @@
+const KEY_ORDER = [
+  "version",
+  "createdBy",
+  "package",
+  "entry",
+  "path",
+  "tsconfigPath",
+  "graph",
+  "source",
+  "filename",
+  "language",
+  "kind",
+  "entryFileName",
+  "files",
+  "fileName",
+  "roles",
+  "hash",
+  "machines",
+  "managers",
+  "diagnostics",
+  "code",
+  "severity",
+  "message",
+  "machineId",
+  "loc",
+  "start",
+  "end",
+  "line",
+  "column",
+  "offset",
+  "hint",
+  "id",
+  "index",
+  "variableName",
+  "exportName",
+  "managerKeys",
+  "machineRefs",
+  "key",
+  "machineId",
+  "states",
+  "transitions",
+  "emissions",
+  "reducerCases"
+];
+const keyRanks = new Map(KEY_ORDER.map((key, index) => [key, index]));
+const orderedKeys = (value) => {
+  return Object.keys(value).sort((left, right) => {
+    const leftRank = keyRanks.get(left) ?? Number.MAX_SAFE_INTEGER;
+    const rightRank = keyRanks.get(right) ?? Number.MAX_SAFE_INTEGER;
+    return leftRank === rightRank ? left.localeCompare(right) : leftRank - rightRank;
+  });
+};
+const isPlainObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const stableValue = (value) => {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!isPlainObject(value)) return value;
+  const next = {};
+  for (const key of orderedKeys(value)) {
+    const child = value[key];
+    if (child !== void 0) next[key] = stableValue(child);
+  }
+  return next;
+};
+const stringifyStableJson = (value) => {
+  return `${JSON.stringify(stableValue(value), null, 2)}
+`;
+};
+export {
+  stringifyStableJson
+};

package/dist/project/build-project-graph.d.cts

@@ -0,0 +1,19 @@
+import { type LiteFsmGraphProjectResult } from "@lite-fsm/graph";
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type ProjectGraphBuildOptions = {
+    entry: string;
+    tsconfig?: string;
+};
+export type ProjectGraphBuildResult = {
+    project: {
+        entryPath: string;
+        absoluteEntryPath: string;
+        projectRoot: string;
+        tsconfigPath?: string;
+    };
+    graphResult?: LiteFsmGraphProjectResult;
+    diagnostics: CliDiagnostic[];
+    blocking: boolean;
+};
+export declare const buildProjectGraph: (context: CliContext, options: ProjectGraphBuildOptions) => ProjectGraphBuildResult;

package/dist/project/build-project-graph.d.ts

@@ -0,0 +1,19 @@
+import { type LiteFsmGraphProjectResult } from "@lite-fsm/graph";
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type ProjectGraphBuildOptions = {
+    entry: string;
+    tsconfig?: string;
+};
+export type ProjectGraphBuildResult = {
+    project: {
+        entryPath: string;
+        absoluteEntryPath: string;
+        projectRoot: string;
+        tsconfigPath?: string;
+    };
+    graphResult?: LiteFsmGraphProjectResult;
+    diagnostics: CliDiagnostic[];
+    blocking: boolean;
+};
+export declare const buildProjectGraph: (context: CliContext, options: ProjectGraphBuildOptions) => ProjectGraphBuildResult;

package/dist/project/build-project-graph.js

@@ -0,0 +1,64 @@
+import { relative, resolve } from "node:path";
+import { compileLiteFsmGraphProject } from "@lite-fsm/graph";
+import { cliDiagnostic, hasBlockingCliDiagnostics } from "../cli/diagnostics.js";
+import { createProjectHost } from "./create-project-host.js";
+import { createProjectModuleResolver } from "./module-resolver.js";
+import { createSourceCache, normalizeAbsolutePath, normalizePath } from "./source-cache.js";
+import { resolveProjectTsconfig } from "./tsconfig.js";
+const toDisplayPath = (path, cwd) => {
+  const relativePath = normalizePath(relative(cwd, path));
+  return relativePath === "" || !relativePath.startsWith("../") && relativePath !== ".." ? relativePath || "." : normalizePath(path);
+};
+const buildProjectGraph = (context, options) => {
+  const absoluteEntryPath = normalizeAbsolutePath(resolve(context.cwd, options.entry));
+  const tsconfig = resolveProjectTsconfig(context, {
+    entryFileName: absoluteEntryPath,
+    explicitTsconfigPath: options.tsconfig
+  });
+  const project = {
+    entryPath: toDisplayPath(absoluteEntryPath, normalizeAbsolutePath(context.cwd)),
+    absoluteEntryPath,
+    projectRoot: tsconfig.projectRoot,
+    tsconfigPath: tsconfig.tsconfigPath ? toDisplayPath(tsconfig.tsconfigPath, normalizeAbsolutePath(context.cwd)) : void 0
+  };
+  if (tsconfig.blocking) {
+    return {
+      project,
+      diagnostics: tsconfig.diagnostics,
+      blocking: true
+    };
+  }
+  try {
+    const sourceCache = createSourceCache(context.fs);
+    const resolver = createProjectModuleResolver({
+      compilerOptions: tsconfig.compilerOptions,
+      projectRoot: tsconfig.projectRoot,
+      sourceCache
+    });
+    const host = createProjectHost(sourceCache, resolver);
+    const graphResult = compileLiteFsmGraphProject({
+      entryFileName: absoluteEntryPath,
+      projectRoot: tsconfig.projectRoot,
+      host
+    });
+    return {
+      project,
+      graphResult,
+      diagnostics: tsconfig.diagnostics,
+      blocking: hasBlockingCliDiagnostics(tsconfig.diagnostics)
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      project,
+      diagnostics: [
+        ...tsconfig.diagnostics,
+        cliDiagnostic("LFC_GRAPH_PROJECT_FAILED", "error", `Project graph build failed unexpectedly: ${message}`)
+      ],
+      blocking: true
+    };
+  }
+};
+export {
+  buildProjectGraph
+};

package/dist/project/create-project-host.d.cts

@@ -0,0 +1,4 @@
+import type { LiteFsmGraphProjectHost } from "@lite-fsm/graph";
+import type { ProjectModuleResolver } from "./module-resolver.js";
+import type { SourceCache } from "./source-cache.js";
+export declare const createProjectHost: (sourceCache: SourceCache, resolver: ProjectModuleResolver) => LiteFsmGraphProjectHost;

package/dist/project/create-project-host.d.ts

@@ -0,0 +1,4 @@
+import type { LiteFsmGraphProjectHost } from "@lite-fsm/graph";
+import type { ProjectModuleResolver } from "./module-resolver.js";
+import type { SourceCache } from "./source-cache.js";
+export declare const createProjectHost: (sourceCache: SourceCache, resolver: ProjectModuleResolver) => LiteFsmGraphProjectHost;

package/dist/project/create-project-host.js

@@ -0,0 +1,11 @@
+const createProjectHost = (sourceCache, resolver) => ({
+  readSource(fileName) {
+    return sourceCache.readSource(fileName);
+  },
+  resolveModule(input) {
+    return resolver.resolveModule(input);
+  }
+});
+export {
+  createProjectHost
+};

package/dist/project/module-resolver.d.cts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import type { LiteFsmGraphProjectModuleResolution } from "@lite-fsm/graph";
+import type { SourceCache } from "./source-cache.js";
+export type ProjectModuleResolver = {
+    resolveModule(input: {
+        fromFileName: string;
+        moduleSpecifier: string;
+    }): LiteFsmGraphProjectModuleResolution;
+};
+export type ProjectModuleResolverOptions = {
+    compilerOptions: ts.CompilerOptions;
+    projectRoot: string;
+    sourceCache: SourceCache;
+};
+export declare const createProjectModuleResolver: ({ compilerOptions, projectRoot, sourceCache, }: ProjectModuleResolverOptions) => ProjectModuleResolver;

package/dist/project/module-resolver.d.ts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import type { LiteFsmGraphProjectModuleResolution } from "@lite-fsm/graph";
+import type { SourceCache } from "./source-cache.js";
+export type ProjectModuleResolver = {
+    resolveModule(input: {
+        fromFileName: string;
+        moduleSpecifier: string;
+    }): LiteFsmGraphProjectModuleResolution;
+};
+export type ProjectModuleResolverOptions = {
+    compilerOptions: ts.CompilerOptions;
+    projectRoot: string;
+    sourceCache: SourceCache;
+};
+export declare const createProjectModuleResolver: ({ compilerOptions, projectRoot, sourceCache, }: ProjectModuleResolverOptions) => ProjectModuleResolver;

package/dist/project/module-resolver.js

@@ -0,0 +1,111 @@
+import { extname, isAbsolute, relative, resolve } from "node:path";
+import ts from "typescript";
+import { normalizeAbsolutePath, normalizePath } from "./source-cache.js";
+const SUPPORTED_EXTENSION = ".ts";
+const isRelativeSpecifier = (moduleSpecifier) => {
+  return moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../");
+};
+const isCoreSpecifier = (moduleSpecifier) => {
+  return moduleSpecifier === "@lite-fsm/core" || moduleSpecifier === "lite-fsm";
+};
+const explicitExtension = (moduleSpecifier) => {
+  const segments = moduleSpecifier.split("/");
+  const lastSegment = segments[segments.length - 1] ?? moduleSpecifier;
+  const extension = extname(lastSegment);
+  return extension === "" ? void 0 : extension;
+};
+const isInsideRoot = (fileName, projectRoot) => {
+  const relativePath = normalizePath(relative(projectRoot, fileName));
+  return relativePath === "" || !relativePath.startsWith("../") && relativePath !== ".." && !isAbsolute(relativePath);
+};
+const pathPatternToRegExp = (pattern) => {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`);
+};
+const matchesPaths = (moduleSpecifier, paths) => {
+  if (!paths) return false;
+  return Object.keys(paths).some((pattern) => pathPatternToRegExp(pattern).test(moduleSpecifier));
+};
+const isBaseUrlCandidate = (moduleSpecifier, baseUrl) => {
+  return Boolean(baseUrl) && !moduleSpecifier.startsWith("@") && !moduleSpecifier.startsWith("lite-fsm/");
+};
+const firstSpecifierSegment = (moduleSpecifier) => {
+  const separatorIndex = moduleSpecifier.indexOf("/");
+  return separatorIndex === -1 ? moduleSpecifier : moduleSpecifier.slice(0, separatorIndex);
+};
+const hasBaseUrlProjectPrefix = (moduleSpecifier, baseUrl, sourceCache) => {
+  const candidate = normalizeAbsolutePath(resolve(baseUrl, firstSpecifierSegment(moduleSpecifier)));
+  return sourceCache.fileExists(`${candidate}.ts`) || sourceCache.directoryExists(candidate);
+};
+const resolutionHost = (sourceCache) => ({
+  fileExists(path) {
+    return sourceCache.fileExists(path);
+  },
+  /* v8 ignore next 3 -- TypeScript only asks readFile for package metadata/declaration strategies outside the CLI source traversal path. */
+  readFile(path) {
+    return sourceCache.readSource(path);
+  },
+  directoryExists(path) {
+    return sourceCache.directoryExists(path);
+  },
+  /* v8 ignore next 3 -- realpath is supplied for TypeScript host completeness; current supported resolver paths do not require it. */
+  realpath(path) {
+    return sourceCache.realpath(path);
+  },
+  getCurrentDirectory() {
+    return "/";
+  }
+});
+const resolutionFromFileName = (moduleSpecifier, fileName, projectRoot) => {
+  const extension = extname(fileName);
+  if (extension !== SUPPORTED_EXTENSION) {
+    return {
+      kind: "unsupported-extension",
+      moduleSpecifier,
+      /* v8 ignore next -- unsupported resolved modules always have an extension in supported TypeScript resolution. */
+      extension: extension || "unknown"
+    };
+  }
+  if (!isInsideRoot(fileName, projectRoot)) return { kind: "external", moduleSpecifier };
+  return { kind: "resolved", fileName };
+};
+const createProjectModuleResolver = ({
+  compilerOptions,
+  projectRoot,
+  sourceCache
+}) => {
+  const normalizedProjectRoot = normalizeAbsolutePath(projectRoot);
+  const host = resolutionHost(sourceCache);
+  return {
+    resolveModule({ fromFileName, moduleSpecifier }) {
+      if (isCoreSpecifier(moduleSpecifier)) return { kind: "core", moduleSpecifier };
+      if (moduleSpecifier.startsWith("lite-fsm/")) return { kind: "external", moduleSpecifier };
+      const extension = explicitExtension(moduleSpecifier);
+      if (extension && extension !== SUPPORTED_EXTENSION) {
+        return { kind: "unsupported-extension", moduleSpecifier, extension };
+      }
+      const relativeSpecifier = isRelativeSpecifier(moduleSpecifier);
+      const pathsCandidate = matchesPaths(moduleSpecifier, compilerOptions.paths);
+      const baseUrl = compilerOptions.baseUrl;
+      const baseUrlCandidate = isBaseUrlCandidate(moduleSpecifier, baseUrl);
+      const projectLocalCandidate = relativeSpecifier || pathsCandidate || baseUrlCandidate;
+      if (!projectLocalCandidate) return { kind: "external", moduleSpecifier };
+      const resolvedModule = ts.resolveModuleName(
+        moduleSpecifier,
+        normalizeAbsolutePath(fromFileName),
+        compilerOptions,
+        host
+      ).resolvedModule;
+      if (!resolvedModule) {
+        const unresolvedProjectLocal = relativeSpecifier || pathsCandidate || baseUrlCandidate && hasBaseUrlProjectPrefix(moduleSpecifier, baseUrl, sourceCache);
+        return unresolvedProjectLocal ? { kind: "not-found", moduleSpecifier } : { kind: "external", moduleSpecifier };
+      }
+      if (resolvedModule.isExternalLibraryImport) return { kind: "external", moduleSpecifier };
+      const resolvedFileName = normalizeAbsolutePath(resolve(resolvedModule.resolvedFileName));
+      return resolutionFromFileName(moduleSpecifier, resolvedFileName, normalizedProjectRoot);
+    }
+  };
+};
+export {
+  createProjectModuleResolver
+};

package/dist/project/source-cache.d.cts

@@ -0,0 +1,11 @@
+import type { CliFileSystem } from "../cli/context.js";
+export declare const normalizeAbsolutePath: (path: string) => string;
+export declare const normalizePath: (path: string) => string;
+export type SourceCache = {
+    readSource(path: string): string | undefined;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    realpath(path: string): string;
+    sourceHash(path: string): string | undefined;
+};
+export declare const createSourceCache: (fs: CliFileSystem) => SourceCache;

package/dist/project/source-cache.d.ts

@@ -0,0 +1,11 @@
+import type { CliFileSystem } from "../cli/context.js";
+export declare const normalizeAbsolutePath: (path: string) => string;
+export declare const normalizePath: (path: string) => string;
+export type SourceCache = {
+    readSource(path: string): string | undefined;
+    fileExists(path: string): boolean;
+    directoryExists(path: string): boolean;
+    realpath(path: string): string;
+    sourceHash(path: string): string | undefined;
+};
+export declare const createSourceCache: (fs: CliFileSystem) => SourceCache;

package/dist/project/source-cache.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { extname, resolve } from "node:path";
+const toPosixPath = (path) => path.replace(/\\/g, "/");
+const normalizeAbsolutePath = (path) => toPosixPath(resolve(path));
+const normalizePath = (path) => toPosixPath(path);
+const createSourceCache = (fs) => {
+  const sourceByPath = /* @__PURE__ */ new Map();
+  const fileExistsByPath = /* @__PURE__ */ new Map();
+  const directoryExistsByPath = /* @__PURE__ */ new Map();
+  const normalizeKey = (path) => normalizeAbsolutePath(path);
+  const fileExists = (path) => {
+    const key = normalizeKey(path);
+    const cached = fileExistsByPath.get(key);
+    if (cached !== void 0) return cached;
+    const exists = fs.fileExists(key);
+    fileExistsByPath.set(key, exists);
+    return exists;
+  };
+  const directoryExists = (path) => {
+    const key = normalizeKey(path);
+    const cached = directoryExistsByPath.get(key);
+    if (cached !== void 0) return cached;
+    const exists = fs.directoryExists(key);
+    directoryExistsByPath.set(key, exists);
+    return exists;
+  };
+  const readSource = (path) => {
+    const key = normalizeKey(path);
+    if (extname(key) !== ".ts") return void 0;
+    if (sourceByPath.has(key)) return sourceByPath.get(key);
+    const source = fileExists(key) ? fs.readFile(key) : void 0;
+    sourceByPath.set(key, source);
+    return source;
+  };
+  const sourceHash = (path) => {
+    const source = readSource(path);
+    if (source === void 0) return void 0;
+    return createHash("sha256").update(source).digest("hex");
+  };
+  return {
+    readSource,
+    fileExists,
+    directoryExists,
+    realpath(path) {
+      const key = normalizeKey(path);
+      return fs.realpath ? normalizeAbsolutePath(fs.realpath(key)) : key;
+    },
+    sourceHash
+  };
+};
+export {
+  createSourceCache,
+  normalizeAbsolutePath,
+  normalizePath
+};

package/dist/project/tsconfig.d.cts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type ProjectTsconfig = {
+    tsconfigPath?: string;
+    projectRoot: string;
+    compilerOptions: ts.CompilerOptions;
+    diagnostics: CliDiagnostic[];
+    blocking: boolean;
+};
+export type ResolveProjectTsconfigOptions = {
+    entryFileName: string;
+    explicitTsconfigPath?: string;
+};
+export declare const resolveProjectTsconfig: (context: CliContext, options: ResolveProjectTsconfigOptions) => ProjectTsconfig;

package/dist/project/tsconfig.d.ts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+import type { CliContext } from "../cli/context.js";
+import type { CliDiagnostic } from "../cli/diagnostics.js";
+export type ProjectTsconfig = {
+    tsconfigPath?: string;
+    projectRoot: string;
+    compilerOptions: ts.CompilerOptions;
+    diagnostics: CliDiagnostic[];
+    blocking: boolean;
+};
+export type ResolveProjectTsconfigOptions = {
+    entryFileName: string;
+    explicitTsconfigPath?: string;
+};
+export declare const resolveProjectTsconfig: (context: CliContext, options: ResolveProjectTsconfigOptions) => ProjectTsconfig;