@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/linters/markdownlint-types/@types/markdownlint-cli2.d.mts

@@ -0,0 +1,67 @@
+/// <reference path="../../../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The types for `markdownlint-cli2`'s programmatic entry point, which the package itself describes in JSDoc
+ * and ships no declaration for. Vendored here, beside the configuration-schema types, for the same reason.
+ *
+ * Only the parameters {@link lintMarkdownContent} passes are declared. The full parameter object also carries
+ * `argv`, `allowStdin`, `fileContents`, `fs`, `noImport` and `optionsOverride`, none of which a caller linting
+ * one in-memory document has any use for — and declaring an option nobody passes is a claim about a shape
+ * nothing here ever checks.
+ */
+
+declare module 'markdownlint-cli2' {
+  /**
+   * The parameters of {@link main}.
+   */
+  interface MarkdownlintCli2Parameters {
+    /**
+     * The directory whose `markdownlint-cli2` configuration applies, and the base every reported path is
+     * relative to.
+     *
+     * @default `process.cwd()`
+     */
+    readonly directory?: string | undefined;
+
+    /**
+     * Called once per finding, with the line the default output formatter would have printed.
+     */
+    readonly logError?: ((message: string) => void) | undefined;
+
+    /**
+     * Called with the banner and the progress lines — everything that is not a finding.
+     */
+    readonly logMessage?: ((message: string) => void) | undefined;
+
+    /**
+     * Whether to skip glob expansion entirely, including the `globs` the configuration declares. Set it when
+     * the only input is {@link nonFileContents}, so the run cannot wander into the repository's own files.
+     *
+     * @default `false`
+     */
+    readonly noGlobs?: boolean | undefined;
+
+    /**
+     * Content to lint that is not read from disk, keyed by the POSIX path it is linted AS. The path decides
+     * which directory's configuration applies and how the path-relative rules (such as `relative-links`)
+     * resolve, so it should be the path the content is destined for.
+     */
+    readonly nonFileContents?: Record<string, string> | undefined;
+
+    /**
+     * The options the discovered configuration is merged OVER — a base, not an override. `config` is merged
+     * key by key and every other option is replaced wholesale, so anything the repository states itself wins.
+     */
+    readonly optionsDefault?: import('./markdownlint-cli2-config-schema.d.mjs').MarkdownlintCli2ConfigurationSchema | undefined;
+  }
+
+  /**
+   * Runs `markdownlint-cli2`.
+   *
+   * @param parameters - The {@link MarkdownlintCli2Parameters}.
+   * @returns A {@link Promise} that resolves to the process exit code: `0` when nothing was reported, `1`
+   * when something was, `2` when the run itself failed.
+   */
+  export function main(parameters: MarkdownlintCli2Parameters): Promise<number>;
+}

package/dist/lib/esm/linters/markdownlint.d.mts

@@ -0,0 +1,32 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.
+ */
+/**
+ * Parameters for the {@link lint} function.
+ */
+export interface LintOptions {
+    /**
+     * The configuration file copied to the project root when the project has none. Without it,
+     * `markdownlint-cli2` runs with its own defaults.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * Optional file paths to lint. If omitted, lints the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to fix linting issues automatically.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+}
+/**
+ * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.
+ *
+ * @param options - The {@link LintOptions}.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;

package/dist/lib/esm/linters/markdownlint.mjs

@@ -0,0 +1,124 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toArray } from "@mnaoumov/typescript-lib/async";
+import { getLibDebugger } from "@mnaoumov/typescript-lib/debug";
+import { basename } from "@mnaoumov/typescript-lib/path";
+import { existsSync } from "node:fs";
+import {
+  cp,
+  glob
+} from "node:fs/promises";
+import { relative } from "node:path";
+import { getNonIgnoredFiles } from "../git.mjs";
+import { resolveToolCommand } from "../package-manager.mjs";
+import { RepoPaths } from "../repo-paths.mjs";
+import {
+  execFromRoot,
+  getRootFolder,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+import {
+  checkIsInNodeModules,
+  NODE_MODULES_IGNORE_GLOB
+} from "./markdownlint-ignores.mjs";
+async function lint(options) {
+  const { defaultConfigFilePath, paths, shouldFix = false } = options ?? {};
+  const configFiles = [
+    RepoPaths.MarkdownlintCli2ConfigJsonc,
+    RepoPaths.MarkdownlintCli2ConfigYaml,
+    RepoPaths.MarkdownlintCli2ConfigCjs,
+    RepoPaths.MarkdownlintCli2ConfigMjs,
+    RepoPaths.MarkdownlintConfigJsonc,
+    RepoPaths.MarkdownlintConfigJson,
+    RepoPaths.MarkdownlintConfigYaml,
+    RepoPaths.MarkdownlintConfigYml,
+    RepoPaths.MarkdownlintConfigCjs,
+    RepoPaths.MarkdownlintConfigMjs
+  ];
+  const doesConfigFileExist = configFiles.some((configFile) => {
+    const configFilePath = resolvePathFromRootSafe({ path: configFile });
+    return existsSync(configFilePath);
+  });
+  if (!doesConfigFileExist && defaultConfigFilePath) {
+    getLibDebugger("markdownlint:lint")("markdownlint configuration file not found. Creating default config...");
+    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));
+  }
+  const targets = paths?.length ? paths : [RepoPaths.CurrentFolder];
+  await execFromRoot([...resolveToolCommand({ tool: "markdownlint-cli2" }), ...shouldFix ? ["--fix"] : [], { batchedArguments: targets }]);
+  const rootFolder = getRootFolder() ?? process.cwd();
+  const mdFiles = paths?.length ? paths.map((p) => relative(rootFolder, p).replaceAll("\\", "/") || p) : await getMarkdownFiles();
+  await execFromRoot([
+    ...resolveToolCommand({ tool: "linkinator" }),
+    "--retry",
+    "--retry-errors",
+    "--retry-errors-count",
+    "3",
+    "--retry-errors-jitter",
+    "5",
+    "--url-rewrite-search",
+    String.raw`https://www\.npmjs\.com/package/`,
+    "--url-rewrite-replace",
+    "https://registry.npmjs.org/",
+    { batchedArguments: mdFiles }
+  ]);
+}
+const MARKDOWN_PATHSPEC = "*.md";
+async function getMarkdownFiles() {
+  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });
+  return nonIgnoredFiles ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path)) : await toArray(glob(["**/*.md"], {
+    exclude: [
+      ".git/**",
+      "dist/**",
+      NODE_MODULES_IGNORE_GLOB
+    ]
+  }));
+}
+export {
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/linters/markdownlint.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n */\n\nimport { toArray } from '@mnaoumov/typescript-lib/async';\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { basename } from '@mnaoumov/typescript-lib/path';\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  glob\n} from 'node:fs/promises';\nimport { relative } from 'node:path';\n\nimport { getNonIgnoredFiles } from '../git.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  getRootFolder,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport {\n  checkIsInNodeModules,\n  NODE_MODULES_IGNORE_GLOB\n} from './markdownlint-ignores.ts';\n\n/**\n * Parameters for the {@link lint} function.\n */\nexport interface LintOptions {\n  /**\n   * The configuration file copied to the project root when the project has none. Without it,\n   * `markdownlint-cli2` runs with its own defaults.\n   */\n  readonly defaultConfigFilePath?: string | undefined;\n\n  /**\n   * Optional file paths to lint. If omitted, lints the entire project.\n   */\n  readonly paths?: string[] | undefined;\n\n  /**\n   * Whether to fix linting issues automatically.\n   *\n   * @default `false`\n   */\n  readonly shouldFix?: boolean | undefined;\n}\n\n/**\n * Lint markdown documentation using `markdownlint-cli2` and `linkinator`.\n *\n * @param options - The {@link LintOptions}.\n */\nexport async function lint(options?: LintOptions): Promise<void> {\n  const { defaultConfigFilePath, paths, shouldFix = false } = options ?? {};\n  const configFiles = [\n    RepoPaths.MarkdownlintCli2ConfigJsonc,\n    RepoPaths.MarkdownlintCli2ConfigYaml,\n    RepoPaths.MarkdownlintCli2ConfigCjs,\n    RepoPaths.MarkdownlintCli2ConfigMjs,\n    RepoPaths.MarkdownlintConfigJsonc,\n    RepoPaths.MarkdownlintConfigJson,\n    RepoPaths.MarkdownlintConfigYaml,\n    RepoPaths.MarkdownlintConfigYml,\n    RepoPaths.MarkdownlintConfigCjs,\n    RepoPaths.MarkdownlintConfigMjs\n  ];\n\n  const doesConfigFileExist = configFiles.some((configFile) => {\n    const configFilePath = resolvePathFromRootSafe({ path: configFile });\n    return existsSync(configFilePath);\n  });\n\n  if (!doesConfigFileExist && defaultConfigFilePath) {\n    getLibDebugger('markdownlint:lint')('markdownlint configuration file not found. Creating default config...');\n    await cp(defaultConfigFilePath, resolvePathFromRootSafe({ path: basename(defaultConfigFilePath) }));\n  }\n\n  /* v8 ignore start -- The paths-provided branches are only exercised by consumer projects passing file lists. */\n  const targets = paths?.length ? paths : [RepoPaths.CurrentFolder];\n  /* v8 ignore stop */\n  await execFromRoot([...resolveToolCommand({ tool: 'markdownlint-cli2' }), ...(shouldFix ? ['--fix'] : []), { batchedArguments: targets }]);\n\n  /* v8 ignore start -- The paths-provided branch is only exercised by consumer projects passing file lists. */\n  const rootFolder = getRootFolder() ?? process.cwd();\n  const mdFiles = paths?.length\n    ? paths.map((p) => relative(rootFolder, p).replaceAll('\\\\', '/') || p)\n    : await getMarkdownFiles();\n  /* v8 ignore stop */\n  await execFromRoot([\n    ...resolveToolCommand({ tool: 'linkinator' }),\n    '--retry',\n    '--retry-errors',\n    '--retry-errors-count',\n    '3',\n    '--retry-errors-jitter',\n    '5',\n    '--url-rewrite-search',\n    String.raw`https://www\\.npmjs\\.com/package/`,\n    '--url-rewrite-replace',\n    'https://registry.npmjs.org/',\n    { batchedArguments: mdFiles }\n  ]);\n}\n\n/**\n * The git pathspec matching every markdown file in the repository, at any depth.\n */\nconst MARKDOWN_PATHSPEC = '*.md';\n\n/**\n * Lists the markdown files to hand to `linkinator`.\n *\n * `linkinator` takes a file list rather than an ignore configuration, so the gitignored files have to be\n * dropped before it is invoked. Git itself answers that (nested ignore files, `!` negations and all); the\n * hand-maintained glob exclusions below are only the fallback for a checkout without git, and they are the\n * very lists this indirection exists to stop from drifting.\n *\n * The `node_modules` filter is applied to the git-derived list too, and deliberately so: git only skips\n * what the repository asked it to skip, and a repository can deliberately TRACK a vendored `node_modules`\n * tree. That is the one exclusion `.gitignore` cannot answer \u2014 see `markdownlint-ignores.ts`. Applying it\n * here keeps `linkinator` in step with the markdownlint half, which ignores the same paths by glob.\n *\n * @returns A {@link Promise} that resolves with the markdown file paths, relative to the root folder.\n */\nasync function getMarkdownFiles(): Promise<string[]> {\n  const nonIgnoredFiles = await getNonIgnoredFiles({ patterns: [MARKDOWN_PATHSPEC] });\n  return nonIgnoredFiles\n    ? nonIgnoredFiles.filter((path) => !checkIsInNodeModules(path))\n    : (await toArray(glob(['**/*.md'], {\n      exclude: [\n        '.git/**',\n        'dist/**',\n        NODE_MODULES_IGNORE_GLOB\n      ]\n    })));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;AAEzB,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA8BP,eAAsB,KAAK,SAAsC;AAC/D,QAAM,EAAE,uBAAuB,OAAO,YAAY,MAAM,IAAI,WAAW,CAAC;AACxE,QAAM,cAAc;AAAA,IAClB,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,IACV,UAAU;AAAA,EACZ;AAEA,QAAM,sBAAsB,YAAY,KAAK,CAAC,eAAe;AAC3D,UAAM,iBAAiB,wBAAwB,EAAE,MAAM,WAAW,CAAC;AACnE,WAAO,WAAW,cAAc;AAAA,EAClC,CAAC;AAED,MAAI,CAAC,uBAAuB,uBAAuB;AACjD,mBAAe,mBAAmB,EAAE,uEAAuE;AAC3G,UAAM,GAAG,uBAAuB,wBAAwB,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC,CAAC;AAAA,EACpG;AAGA,QAAM,UAAU,OAAO,SAAS,QAAQ,CAAC,UAAU,aAAa;AAEhE,QAAM,aAAa,CAAC,GAAG,mBAAmB,EAAE,MAAM,oBAAoB,CAAC,GAAG,GAAI,YAAY,CAAC,OAAO,IAAI,CAAC,GAAI,EAAE,kBAAkB,QAAQ,CAAC,CAAC;AAGzI,QAAM,aAAa,cAAc,KAAK,QAAQ,IAAI;AAClD,QAAM,UAAU,OAAO,SACnB,MAAM,IAAI,CAAC,MAAM,SAAS,YAAY,CAAC,EAAE,WAAW,MAAM,GAAG,KAAK,CAAC,IACnE,MAAM,iBAAiB;AAE3B,QAAM,aAAa;AAAA,IACjB,GAAG,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAAA,IAC5C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA,EAAE,kBAAkB,QAAQ;AAAA,EAC9B,CAAC;AACH;AAKA,MAAM,oBAAoB;AAiB1B,eAAe,mBAAsC;AACnD,QAAM,kBAAkB,MAAM,mBAAmB,EAAE,UAAU,CAAC,iBAAiB,EAAE,CAAC;AAClF,SAAO,kBACH,gBAAgB,OAAO,CAAC,SAAS,CAAC,qBAAqB,IAAI,CAAC,IAC3D,MAAM,QAAQ,KAAK,CAAC,SAAS,GAAG;AAAA,IACjC,SAAS;AAAA,MACP;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC,CAAC;AACN;",
  "names": []
}


package/dist/lib/esm/linters/over-exposure.d.mts

@@ -0,0 +1,357 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Over-exposure analyzer.
+ *
+ * Finds declarations exposed more broadly than their references require, so the exposure can be
+ * tightened:
+ *
+ * - `export`ed symbols referenced only within their own file — the `export` can be dropped.
+ * - `public` class members referenced only inside their own class — they can be `private`.
+ * - `public` class members referenced only inside their own class and its subclasses — they can be
+ *   `protected`.
+ * - `protected` class members referenced only inside their own class — they can be `private`.
+ *
+ * The analysis is whole-program and type-aware: it uses the TypeScript language service's
+ * find-all-references to locate every use of each declaration, then classifies the tightest
+ * exposure that still covers all references. Because `findReferences` does not link a string-literal
+ * argument back to a member declaration when the parameter is a conditional/mapped key type (e.g.
+ * `bind(component, 'someSetting')` where the key is typed `ConditionalKeys<Settings, …>`), member
+ * analysis additionally treats a string literal whose text equals the member name as a reference —
+ * but only when its contextual type is a string-literal type (or union of them) all of whose members
+ * are keys of the declaring class, so incidental same-named strings (`console.log('name')`) are not
+ * miscounted. Members invoked by the framework via registration
+ * rather than by visible references (Obsidian lifecycle hooks, settings-tab `display`, etc.) are
+ * excluded via {@link LIFECYCLE_ALLOWLIST}, as are `override` and `static` members whose exposure is
+ * constrained by a base declaration. ECMAScript hard-private members (`#name`) are also excluded —
+ * they are already maximally private and cannot carry a visibility modifier. A declaration carrying
+ * a TSDoc (`/** … *\/`) documentation comment is likewise excluded — whether a top-level `export` or
+ * a class member, documenting it is a deliberate signal that it is part of the intended public API,
+ * regardless of where it currently happens to be referenced.
+ *
+ * A member referenced only from test files is reported with {@link OverExposureFinding.isForcedByTestOnly}
+ * set, surfacing members widened purely for testability — the canonical case for extracting logic
+ * into an independently testable component instead.
+ *
+ * Beyond reporting, passing `shouldFix` to {@link findOverExposure} / {@link analyzeOverExposure}
+ * rewrites the source in place: dropping the `export` keyword, or replacing/inserting a `private`
+ * or `protected` modifier. Each finding then carries {@link OverExposureFinding.wasFixed} /
+ * {@link OverExposureFinding.skipReason}. Changes that cannot be safely automated — those forced
+ * only by test references, decorated members, or an `export` shared with a still-exported sibling —
+ * are reported as skipped and left untouched.
+ *
+ * Additionally passing `shouldForce` (only meaningful together with `shouldFix`) tightens the
+ * declarations held wide purely by test references too — the production half of the canonical
+ * test-only migration: the member becomes `private` / the `export` is dropped, leaving only the
+ * test to switch to a cast-based access. Decorated members and exports shared with a still-exported
+ * sibling stay skipped even under `shouldForce`, because no edit can be applied safely.
+ */
+import type { CompilerOptions, LanguageService, LanguageServiceHost } from 'typescript';
+/**
+ * Parameters for {@link analyzeOverExposure}.
+ */
+export interface AnalyzeOverExposureParams {
+    /**
+    The language service to query for references and types.
+     */
+    readonly languageService: LanguageService;
+    /**
+     * Optional callback invoked once per analyzed source file, before that file is processed. The
+     * whole-program reference analysis is slow, so this lets callers report live progress instead of
+     * appearing to hang.
+     */
+    readonly onProgress?: (progress: OverExposureProgress) => void;
+    /**
+     * When `true`, each fixable finding is tightened in place via {@link writeFile} (which must then
+     * be provided), and the returned findings carry {@link OverExposureFinding.wasFixed} /
+     * {@link OverExposureFinding.skipReason}. When `false` or omitted, the analysis only reports.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+    /**
+     * When `true` (only meaningful together with {@link shouldFix}), declarations held wide purely by
+     * test references are tightened too, instead of being skipped with a `test-only`
+     * {@link OverExposureFinding.skipReason}. Decorated members and exports shared with a
+     * still-exported sibling stay skipped regardless, because no edit can be applied safely.
+     *
+     * @default `false`
+     */
+    readonly shouldForce?: boolean | undefined;
+    /**
+     * Absolute (canonical) path of the project's `src` folder. Only declarations in non-test files
+     * under this folder are analyzed; declarations elsewhere (test files, dependencies) are ignored
+     * but still counted as reference sites.
+     */
+    readonly srcFolder: string;
+    /**
+     * Writes the tightened contents of a changed file back to disk. Required when {@link shouldFix}
+     * is `true`; ignored otherwise.
+     *
+     * @param path - Absolute path of the file to write (original casing, as stored in the program).
+     * @param content - The full new file contents.
+     */
+    readonly writeFile?: (path: string, content: string) => void;
+}
+/**
+ * Parameters for {@link createLanguageServiceHost}.
+ */
+export interface CreateLanguageServiceHostParams {
+    /**
+    The compiler options.
+     */
+    readonly compilerOptions: CompilerOptions;
+    /**
+    The files to include in the program.
+     */
+    readonly fileNames: readonly string[];
+    /**
+    The file-system operations used to read sources.
+     */
+    readonly fileSystem: OverExposureFileSystem;
+}
+/**
+ * Parameters for {@link createProjectLanguageService}.
+ */
+export interface CreateProjectLanguageServiceParams {
+    /**
+    Absolute path to the project's `tsconfig.json`.
+     */
+    readonly tsConfigPath: string;
+}
+/**
+ * The exposure level a declaration currently has.
+ */
+export type CurrentExposure = 'export' | 'protected' | 'public';
+/**
+ * Parameters for {@link findOverExposure}.
+ */
+export interface FindOverExposureParams {
+    /**
+     * Optional callback invoked once per analyzed source file, for live progress reporting. Forwarded
+     * to {@link analyzeOverExposure}.
+     */
+    readonly onProgress?: (progress: OverExposureProgress) => void;
+    /**
+    Absolute path to the project root (the folder containing `tsconfig.json` and `src`).
+     */
+    readonly projectFolder: string;
+    /**
+     * When `true`, fixable findings are tightened in place on disk (the `export` keyword is dropped,
+     * or a `private` / `protected` modifier is inserted/replaced). When `false` or omitted, the
+     * project is only analyzed.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+    /**
+     * When `true` (only meaningful together with {@link shouldFix}), declarations held wide purely by
+     * test references are tightened too, instead of being skipped. Decorated members and exports
+     * shared with a still-exported sibling stay skipped regardless. Forwarded to
+     * {@link analyzeOverExposure}.
+     *
+     * @default `false`
+     */
+    readonly shouldForce?: boolean | undefined;
+}
+/**
+ * Options for {@link formatOverExposureFindings}.
+ */
+export interface FormatOverExposureFindingsOptions {
+    /**
+     * When set, file paths in the report are rendered relative to this folder (typically the current
+     * working directory) instead of as absolute paths. Paths outside the folder stay absolute.
+     */
+    readonly baseFolder?: string;
+}
+/**
+ * The subset of file-system operations the language-service host needs. Injecting this (rather than
+ * always using `typescript`'s `sys`) lets tests drive the analyzer against in-memory sources with no
+ * real file-system access.
+ */
+export interface OverExposureFileSystem {
+    /**
+     * Checks whether a directory exists.
+     *
+     * @param path - Directory path.
+     * @returns `true` when the directory exists.
+     */
+    directoryExists: (path: string) => boolean;
+    /**
+     * Checks whether a file exists.
+     *
+     * @param path - File path.
+     * @returns `true` when the file exists.
+     */
+    fileExists: (path: string) => boolean;
+    /**
+     * Resolves the directory that relative paths are resolved against.
+     *
+     * @returns The current working directory.
+     */
+    getCurrentDirectory: () => string;
+    /**
+     * Lists the immediate subdirectories of a directory.
+     *
+     * @param path - Directory path.
+     * @returns The immediate subdirectory names.
+     */
+    getDirectories: (path: string) => string[];
+    /**
+     * Lists the files under a directory, filtered by extension and include/exclude patterns.
+     *
+     * @param path - Root directory.
+     * @param extensions - Extensions to include.
+     * @param exclude - Patterns to exclude.
+     * @param include - Patterns to include.
+     * @param depth - Maximum recursion depth.
+     * @returns The matching file paths.
+     */
+    readDirectory: (path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number) => string[];
+    /**
+     * Reads a file as text.
+     *
+     * @param path - File path.
+     * @returns The file contents, or `undefined` when absent.
+     */
+    readFile: (path: string) => string | undefined;
+}
+/**
+ * A single over-exposed declaration.
+ */
+export interface OverExposureFinding {
+    /**
+    1-based column of the declaration's name.
+     */
+    readonly column: number;
+    /**
+    The current exposure level.
+     */
+    readonly currentExposure: CurrentExposure;
+    /**
+    Absolute path of the file declaring the symbol.
+     */
+    readonly filePath: string;
+    /**
+    `true` when the declaration has no references at all (besides itself).
+     */
+    readonly hasNoReferences: boolean;
+    /**
+     * `true` when the declaration would qualify for a tighter exposure if not for references coming
+     * exclusively from test files — i.e. it is exposed purely for testability.
+     */
+    readonly isForcedByTestOnly: boolean;
+    /**
+    `true` for a class member, `false` for a top-level export.
+     */
+    readonly isMember: boolean;
+    /**
+    1-based line of the declaration's name.
+     */
+    readonly line: number;
+    /**
+    The declared name.
+     */
+    readonly name: string;
+    /**
+     * In a fix run, why this finding was left untouched instead of tightened; `null` when it was
+     * fixed or when the analysis only reported (`shouldFix` off).
+     */
+    readonly skipReason: null | OverExposureSkipReason;
+    /**
+    The exposure the declaration could be tightened to.
+     */
+    readonly suggestedExposure: SuggestedExposure;
+    /**
+    `true` when a fix run tightened this declaration in place. Always `false` in a report run.
+     */
+    readonly wasFixed: boolean;
+}
+/**
+ * Progress reported while analyzing a project, one event per analyzed source file.
+ */
+export interface OverExposureProgress {
+    /**
+    Number of source files fully analyzed before the current one (0-based).
+     */
+    readonly analyzedFileCount: number;
+    /**
+    Absolute (canonical) path of the source file about to be analyzed.
+     */
+    readonly currentFilePath: string;
+    /**
+    Total number of source files that will be analyzed.
+     */
+    readonly totalFileCount: number;
+}
+/**
+ * Why a fix run left a finding untouched:
+ *
+ * - `decorated` — the member carries a decorator, so the modifier insertion point is ambiguous.
+ * - `shared-export` — the `export` keyword is shared with a still-exported sibling declarator.
+ * - `test-only` — the declaration is exposed purely for tests, so tightening would break the test.
+ */
+export type OverExposureSkipReason = 'decorated' | 'shared-export' | 'test-only';
+/**
+ * The (tighter) exposure level a declaration could be reduced to.
+ */
+export type SuggestedExposure = 'file-local' | 'private' | 'protected';
+/**
+ * Lifecycle and framework members invoked by Obsidian or a base class via registration rather than
+ * by references the language service can see. Tightening these would break the framework contract,
+ * so they are never reported.
+ */
+export declare const LIFECYCLE_ALLOWLIST: ReadonlySet<string>;
+/**
+ * Analyzes a project (already loaded into a language service) for over-exposed declarations, and —
+ * when {@link AnalyzeOverExposureParams.shouldFix} is set — tightens every fixable finding in place
+ * via {@link AnalyzeOverExposureParams.writeFile}. Findings that cannot be safely automated (exposed
+ * only for tests, decorated, or sharing an `export` keyword with a still-exported sibling) carry a
+ * {@link OverExposureFinding.skipReason} and are left untouched — unless
+ * {@link AnalyzeOverExposureParams.shouldForce} is set, which additionally tightens the test-only
+ * findings (decorated and shared-export ones still stay skipped).
+ *
+ * @param params - The {@link AnalyzeOverExposureParams}.
+ * @returns The over-exposed declarations, in discovery order.
+ */
+export declare function analyzeOverExposure(params: AnalyzeOverExposureParams): OverExposureFinding[];
+/**
+ * Builds a {@link LanguageServiceHost} backed by an explicit file list and file system.
+ *
+ * @param params - The {@link CreateLanguageServiceHostParams}.
+ * @returns The language-service host.
+ */
+export declare function createLanguageServiceHost(params: CreateLanguageServiceHostParams): LanguageServiceHost;
+/**
+ * Builds a language service over every file in a project's `tsconfig.json`.
+ *
+ * @param params - The {@link CreateProjectLanguageServiceParams}.
+ * @returns A language service ready for {@link analyzeOverExposure}.
+ */
+export declare function createProjectLanguageService(params: CreateProjectLanguageServiceParams): LanguageService;
+/**
+ * Finds over-exposed declarations in a project on disk. When
+ * {@link FindOverExposureParams.shouldFix} is set, each fixable finding is also tightened in place
+ * (rewriting the affected source files via `typescript`'s `sys.writeFile`).
+ *
+ * @param params - The {@link FindOverExposureParams}.
+ * @returns The over-exposed declarations.
+ */
+export declare function findOverExposure(params: FindOverExposureParams): OverExposureFinding[];
+/**
+ * Formats over-exposure findings as a human-readable report, using the grouped layout of ESLint's
+ * `stylish` formatter. Findings are grouped by file and sorted by line: each file is rendered as a
+ * `path` header line, followed by one indented `  line:column  change -- reason` row per finding (the
+ * `line:column` is right-padded so the rows align within a file). Terminals such as VS Code render
+ * each indented `line:column` as a clickable link — resolved against the file header above it — that
+ * jumps straight to the declaration. File groups are separated by a blank line. In a fix run (findings
+ * carrying {@link OverExposureFinding.wasFixed} / {@link OverExposureFinding.skipReason}) each change
+ * row is suffixed with `[fixed]` or `[skipped: …]`, and the trailing summary appends the fixed/skipped
+ * counts.
+ *
+ * @param findings - The findings to format.
+ * @param options - The {@link FormatOverExposureFindingsOptions}.
+ * @returns The report text. Empty-finding input yields a single "no findings" line.
+ */
+export declare function formatOverExposureFindings(findings: readonly OverExposureFinding[], options?: FormatOverExposureFindingsOptions): string;