knip 6.33.0 → 6.35.0

package/dist/schema/plugins.d.ts

@@ -326,6 +326,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    mise: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     mocha: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -74,6 +74,7 @@ export const pluginsSchema = z.object({
     mdx: pluginSchema,
     mdxlint: pluginSchema,
     metro: pluginSchema,
+    mise: pluginSchema,
     mocha: pluginSchema,
     moonrepo: pluginSchema,
     msw: pluginSchema,

package/dist/session/index.d.ts

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.ts';
 export type { DependencyNode, DependencyNodes } from '../graph-explorer/operations/get-dependency-usage.ts';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.ts';
 export { getIssuePrefix } from '../reporters/util/util.ts';

package/dist/session/index.js

@@ -1,4 +1,4 @@
-export { IMPORT_STAR, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
+export { IMPORT_STAR, ISSUE_TYPES, KNIP_CONFIG_LOCATIONS, SIDE_EFFECTS } from '../constants.js';
 export { finalizeConfigurationHints } from '../reporters/util/configuration-hints.js';
 export { getIssuePrefix } from '../reporters/util/util.js';
 export { createOptions } from '../util/create-options.js';

package/dist/session/session.js

@@ -1,18 +1,36 @@
 import { run } from '../run.js';
+import { createPreprocessor, toReporterOptions } from '../util/preprocessor.js';
 import { buildFileDescriptor } from './file-descriptor.js';
 import { buildPackageJsonDescriptor } from './package-json-descriptor.js';
 export const createSession = async (options) => {
     const { session, results } = await run(options);
     if (!session)
         throw new Error('Unable to initialize watch session');
-    return createSessionAdapter(session, results, options);
-};
-const createSessionAdapter = (session, results, options) => {
-    return {
+    const adapter = {
         handleFileChanges: session.handleFileChanges,
         getIssues: session.getIssues,
         getResults: () => results,
         describeFile: (filePath, opts) => buildFileDescriptor(filePath, options.cwd, session.getGraph(), session.getEntryPaths(), opts),
         describePackageJson: () => buildPackageJsonDescriptor(session.getGraph(), session.getEntryPaths()),
     };
+    if (options.preprocessor.length === 0)
+        return adapter;
+    const input = toReporterOptions(options, results);
+    const preprocess = await createPreprocessor(options.preprocessor);
+    const updateResults = async () => {
+        const data = await preprocess({ ...input, ...structuredClone(session.getIssues()) });
+        results.issues = data.issues;
+        results.counters = data.counters;
+        results.tagHints = data.tagHints;
+        results.configurationHints = data.configurationHints;
+    };
+    await updateResults();
+    adapter.handleFileChanges = async (changes) => {
+        const update = await session.handleFileChanges(changes);
+        if (update)
+            await updateResults();
+        return update;
+    };
+    adapter.getIssues = () => results;
+    return adapter;
 };

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
-export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mdx', 'mdxlint', 'metro', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-markdoc' | 'astro-og-canvas' | 'ava' | 'babel' | 'biome' | 'borp' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'catalyst' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'electron-vite' | 'eleventy' | 'esbuild' | 'eslint' | 'eve' | 'execa' | 'expo' | 'expressive-code' | 'fast' | 'fumadocs' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'laravel-vite-plugin' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lit' | 'lockfile-lint' | 'lost-pixel' | 'lunaria' | 'markdownlint' | 'marko' | 'mdx' | 'mdxlint' | 'metro' | 'mise' | 'mocha' | 'moonrepo' | 'msw' | 'nano-spawn' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nuxtjs-i18n' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'openclaw' | 'orval' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'pre-commit' | 'preconstruct' | 'prettier' | 'prisma' | 'quasar' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'tauri' | 'temporal' | 'travis' | 'ts-node' | 'tsd' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'unplugin-auto-import' | 'unplugin-icons' | 'unplugin-vue-components' | 'unplugin-vue-i18n' | 'unplugin-vue-markdown' | 'unplugin-vue-router' | 'vercel' | 'vercel-og' | 'vike' | 'vite' | 'vite-plugin-pages' | 'vite-plugin-pwa' | 'vite-plugin-vue-layouts-next' | 'vite-plus' | 'vite-pwa-assets-generator' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'wxt' | 'xo' | 'yarn' | 'yorkie' | 'zx';
+export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-markdoc', 'astro-og-canvas', 'ava', 'babel', 'biome', 'borp', 'bumpp', 'bun', 'c8', 'capacitor', 'catalyst', 'changelogen', 'changelogithub', 'changesets', 'commitizen', 'commitlint', 'convex', 'create-typescript-app', 'cspell', 'cucumber', 'cypress', 'danger', 'dependency-cruiser', 'docusaurus', 'dotenv', 'drizzle', 'electron-vite', 'eleventy', 'esbuild', 'eslint', 'eve', 'execa', 'expo', 'expressive-code', 'fast', 'fumadocs', 'gatsby', 'github-action', 'github-actions', 'glob', 'graphql-codegen', 'hardhat', 'husky', 'i18next-parser', 'jest', 'karma', 'knex', 'ladle', 'laravel-vite-plugin', 'lefthook', 'lint-staged', 'linthtml', 'lit', 'lockfile-lint', 'lost-pixel', 'lunaria', 'markdownlint', 'marko', 'mdx', 'mdxlint', 'metro', 'mise', 'mocha', 'moonrepo', 'msw', 'nano-spawn', 'nano-staged', 'nest', 'netlify', 'next', 'next-intl', 'next-mdx', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nuxtjs-i18n', 'nx', 'nyc', 'oclif', 'openapi-ts', 'openclaw', 'orval', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'pre-commit', 'preconstruct', 'prettier', 'prisma', 'quasar', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', 'svgo', 'svgr', 'swc', 'syncpack', 'tailwind', 'tanstack-router', 'taskfile', 'tauri', 'temporal', 'travis', 'ts-node', 'tsd', 'tsdown', 'tsup', 'tsx', 'typedoc', 'typescript', 'unbuild', 'unocss', 'unplugin-auto-import', 'unplugin-icons', 'unplugin-vue-components', 'unplugin-vue-i18n', 'unplugin-vue-markdown', 'unplugin-vue-router', 'vercel', 'vercel-og', 'vike', 'vite', 'vite-plugin-pages', 'vite-plugin-pwa', 'vite-plugin-vue-layouts-next', 'vite-plus', 'vite-pwa-assets-generator', 'vitepress', 'vitest', 'vue', 'webdriver-io', 'webpack', 'wireit', 'wrangler', 'wxt', 'xo', 'yarn', 'yorkie', 'zx'];

package/dist/types/PluginNames.js

@@ -63,6 +63,7 @@ export const pluginNames = [
     'mdx',
     'mdxlint',
     'metro',
+    'mise',
     'mocha',
     'moonrepo',
     'msw',

package/dist/types/config.d.ts

@@ -1,7 +1,7 @@
 import type { Program, VisitorObject } from 'oxc-parser';
 import type { Word } from 'unbash';
 import type { z } from 'zod/mini';
-import type { AsyncCompilers, CompilerSync, HasDependency, SyncCompilers } from '../compilers/types.ts';
+import type { Compiler, HasDependency, RawCompilers } from '../compilers/types.ts';
 import type { knipConfigurationSchema, workspaceConfigurationSchema } from '../schema/configuration.ts';
 import type { pluginSchema } from '../schema/plugins.ts';
 import type { ParsedCLIArgs } from '../util/cli-arguments.ts';
@@ -56,8 +56,7 @@ export interface Configuration {
     ignoreUnresolved: IgnorePatterns;
     ignoreWorkspaces: string[];
     isIncludeEntryExports: boolean;
-    syncCompilers: SyncCompilers;
-    asyncCompilers: AsyncCompilers;
+    compilers: RawCompilers;
     rootPluginConfigs: Partial<PluginsConfiguration>;
 }
 type NormalizedGlob = string[];
@@ -121,7 +120,7 @@ export type ResolveSourceMap = (options: ResolveSourceMapOptions) => Promise<Sou
 export type HandleInput = (input: Input) => string | undefined;
 type RegisterCompilerInput = {
     extension: string;
-    compiler: CompilerSync;
+    compiler: Compiler;
 };
 export type RegisterCompiler = (input: RegisterCompilerInput) => void;
 export type ResolveFromAST = (program: Program, options: PluginOptions & {
@@ -141,7 +140,9 @@ export type PluginVisitorContext = {
     markImportExpressionHandled: (pos: number) => void;
     addImportGlob: (patterns: string[], options?: {
         base?: string;
+        cwd?: string;
         filter?: RegExp;
+        analyzeExports?: boolean;
     }) => void;
     markExportRegistered: (name: string) => void;
 };

package/dist/types/module-graph.d.ts

@@ -30,6 +30,7 @@ export interface Import extends Position {
     readonly identifier: string | undefined;
     readonly isTypeOnly: boolean;
     readonly modifiers: number;
+    readonly jsDocTags: Tags | undefined;
 }
 export interface ExternalRef {
     readonly specifier: string;
@@ -57,6 +58,7 @@ export interface ExportMember extends Position {
 type ExportMap = Map<Identifier, Export>;
 export type Imports = Set<Import>;
 export type FileNode = {
+    skipExports: boolean;
     imports: {
         readonly internal: ImportMap;
         readonly external: Set<Import>;
@@ -76,7 +78,9 @@ export type FileNode = {
 export interface ImportGlob {
     patterns: string[];
     base?: string;
+    cwd?: string;
     filter?: RegExp;
+    analyzeExports?: boolean;
 }
 export type ModuleGraph = Map<FilePath, FileNode>;
 export {};

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+export type { Compiler, CompilerResult } from './compilers/types.ts';
 export type { RawConfigurationOrFn as KnipConfig, RawConfiguration as KnipConfiguration, WorkspaceProjectConfig, } from './types/config.ts';
 export type { Issue, IssueRecords, IssueType, Preprocessor, Reporter, ReporterOptions } from './types/issues.ts';
 export type { JSONReport, JSONReportEntry, JSONReportItem, JSONReportNamedItem } from './reporters/json.ts';

package/dist/typescript/SourceFileManager.d.ts

@@ -1,15 +1,19 @@
-import type { AsyncCompilers, SyncCompilers } from '../compilers/types.ts';
+import type { Compilers } from '../compilers/types.ts';
 interface SourceFileManagerOptions {
-    compilers: [SyncCompilers, AsyncCompilers];
+    compilers: Compilers;
+    isSession?: boolean;
 }
 export declare class SourceFileManager {
-    sourceTextCache: Map<string, string>;
-    syncCompilers: SyncCompilers;
-    asyncCompilers: AsyncCompilers;
-    constructor({ compilers }: SourceFileManagerOptions);
-    readFile(filePath: string): string;
+    sourceTextCache: Map<string, string | Promise<string>>;
+    compilers: Compilers;
+    private rawContentHashes;
+    private isSession;
+    constructor({ compilers, isSession }: SourceFileManagerOptions);
+    loadSourceText(filePath: string): string | Promise<string>;
     invalidate(filePath: string): void;
-    compileAndAddSourceFile(filePath: string): Promise<void>;
-    private readRawFile;
+    hasChanged(filePath: string): boolean;
+    readRawFile(filePath: string): string | undefined;
+    private cacheSourceText;
+    private validateCompilerResult;
 }
 export {};

package/dist/typescript/SourceFileManager.js

@@ -1,21 +1,24 @@
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { FOREIGN_FILE_EXTENSIONS } from '../constants.js';
 import { debugLog } from '../util/debug.js';
+import { CompilerError, ConfigurationError } from '../util/errors.js';
 import { extname, isInternal } from '../util/path.js';
 export class SourceFileManager {
     sourceTextCache = new Map();
-    syncCompilers;
-    asyncCompilers;
-    constructor({ compilers }) {
-        this.syncCompilers = compilers[0];
-        this.asyncCompilers = compilers[1];
+    compilers;
+    rawContentHashes = new Map();
+    isSession;
+    constructor({ compilers, isSession = false }) {
+        this.compilers = compilers;
+        this.isSession = isSession;
     }
-    readFile(filePath) {
+    loadSourceText(filePath) {
         const cachedSourceText = this.sourceTextCache.get(filePath);
         if (cachedSourceText !== undefined)
             return cachedSourceText;
         const ext = extname(filePath);
-        const compiler = this.syncCompilers.get(ext);
+        const compiler = this.compilers.get(ext);
         if (FOREIGN_FILE_EXTENSIONS.has(ext) && !compiler) {
             this.sourceTextCache.set(filePath, '');
             return '';
@@ -27,26 +30,47 @@ export class SourceFileManager {
             this.sourceTextCache.set(filePath, '');
             return '';
         }
-        const compiled = compiler ? compiler(contents, filePath) : contents;
-        if (compiler)
-            debugLog('*', `Compiled ${filePath}`);
-        this.sourceTextCache.set(filePath, compiled);
-        return compiled;
+        if (!compiler)
+            return this.cacheSourceText(filePath, contents, contents);
+        let result;
+        try {
+            result = compiler(contents, filePath);
+            if (result !== null && (typeof result === 'object' || typeof result === 'function')) {
+                const pending = Promise.resolve(result).then(result => {
+                    const isCurrent = this.sourceTextCache.get(filePath) === pending;
+                    if (isCurrent)
+                        this.sourceTextCache.delete(filePath);
+                    const sourceText = this.validateCompilerResult(result, filePath, ext);
+                    if (isCurrent)
+                        this.cacheSourceText(filePath, sourceText, contents);
+                    debugLog('*', `Compiled ${filePath}`);
+                    return sourceText;
+                }, cause => {
+                    if (this.sourceTextCache.get(filePath) === pending)
+                        this.sourceTextCache.delete(filePath);
+                    throw new CompilerError(`Compiler for ${ext} failed (${filePath})`, { cause });
+                });
+                this.sourceTextCache.set(filePath, pending);
+                return pending;
+            }
+        }
+        catch (cause) {
+            throw new CompilerError(`Compiler for ${ext} failed (${filePath})`, { cause });
+        }
+        const sourceText = this.validateCompilerResult(result, filePath, ext);
+        debugLog('*', `Compiled ${filePath}`);
+        return this.cacheSourceText(filePath, sourceText, contents);
     }
     invalidate(filePath) {
         this.sourceTextCache.delete(filePath);
+        this.rawContentHashes.delete(filePath);
     }
-    async compileAndAddSourceFile(filePath) {
+    hasChanged(filePath) {
+        const previousHash = this.rawContentHashes.get(filePath);
+        if (previousHash === undefined)
+            return true;
         const contents = this.readRawFile(filePath);
-        if (contents === undefined)
-            throw new Error(`Unable to read ${filePath}`);
-        const ext = extname(filePath);
-        const compiler = this.asyncCompilers.get(ext);
-        if (compiler) {
-            const compiled = await compiler(contents, filePath);
-            debugLog('*', `Compiled ${filePath}`);
-            this.sourceTextCache.set(filePath, compiled);
-        }
+        return contents === undefined || createHash('sha1').update(contents).digest('hex') !== previousHash;
     }
     readRawFile(filePath) {
         try {
@@ -56,4 +80,16 @@ export class SourceFileManager {
             return undefined;
         }
     }
+    cacheSourceText(filePath, sourceText, contents) {
+        this.sourceTextCache.set(filePath, sourceText);
+        if (this.isSession)
+            this.rawContentHashes.set(filePath, createHash('sha1').update(contents).digest('hex'));
+        return sourceText;
+    }
+    validateCompilerResult(result, filePath, ext) {
+        if (typeof result === 'string')
+            return result;
+        const category = result === null ? 'null' : typeof result;
+        throw new ConfigurationError(`Compiler for ${ext} returned ${category} for ${filePath}; expected a string or PromiseLike<string>`);
+    }
 }

package/dist/typescript/get-imports-and-exports.js

@@ -62,6 +62,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
             col: opts.col,
             isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
             modifiers,
+            jsDocTags: undefined,
         });
         const file = internal.get(importFilePath);
         const importMaps = file ?? createImports();
@@ -146,6 +147,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                         col,
                         isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                         modifiers,
+                        jsDocTags,
                     });
                 }
             }
@@ -171,6 +173,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
                     col,
                     isTypeOnly: isDts || !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
                     modifiers,
+                    jsDocTags: undefined,
                 });
             }
         }
@@ -280,7 +283,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         pluginCtx.addScript = (s) => scripts.add(s);
         pluginCtx.addImport = (spec, pos, mod) => addImport(spec, undefined, undefined, undefined, pos, mod);
         pluginCtx.markImportExpressionHandled = (pos) => handledImportExpressions.add(pos);
-        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, base: opts?.base, filter: opts?.filter });
+        pluginCtx.addImportGlob = (patterns, opts) => importGlobs.push({ patterns, ...opts });
         pluginCtx.markExportRegistered = (name) => registeredCustomElements.add(name);
     }
     const localRefs = _walkAST(result.program, sourceText, filePath, result.module.hasModuleSyntax, {
@@ -326,6 +329,7 @@ const getImportsAndExports = (filePath, sourceText, resolveModule, options, igno
         }
     }
     return {
+        skipExports,
         imports: { internal, external, externalRefs: new Set(), programFiles, entryFiles, imports, unresolved },
         exports,
         duplicates: [...aliasedExports.values()],

package/dist/typescript/glob-imports.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { _syncGlob } from '../util/glob.js';
-import { dirname, isAbsolute, join, toRelative } from '../util/path.js';
+import { dirname, isAbsolute, join, toAbsolute, toRelative } from '../util/path.js';
 function resolveBaseDir(base, dir, resolveGlobPattern) {
     if (base.startsWith('.'))
         return join(dir, base);
@@ -15,8 +15,13 @@ function resolveBaseDir(base, dir, resolveGlobPattern) {
 export function resolveImportGlobs(items, containingFile, resolveGlobPattern, workspaceRoot) {
     const filePaths = [];
     const dir = dirname(containingFile);
-    for (const { patterns, base, filter } of items) {
-        if (base !== undefined) {
+    for (const { patterns, base, cwd, filter } of items) {
+        if (cwd !== undefined) {
+            for (const filePath of _syncGlob({ patterns, cwd: toAbsolute(cwd, workspaceRoot) })) {
+                filePaths.push(filePath);
+            }
+        }
+        else if (base !== undefined) {
             const cwd = resolveBaseDir(base, dir, resolveGlobPattern);
             if (!cwd)
                 continue;

package/dist/typescript/visitors/calls.js

@@ -256,7 +256,7 @@ export function handleNewExpression(node, s) {
         node.arguments[1].property.name === 'url') {
         const specifier = getStringValue(node.arguments[0]);
         if (specifier)
-            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL);
+            s.addImport(specifier, undefined, undefined, undefined, node.arguments[0].start, IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL, undefined, s.getJSDocTags(node.start));
         return;
     }
     if (s.hasWorkerThreadsImport &&

package/dist/typescript/visitors/exports.js

@@ -123,10 +123,14 @@ export function handleExportNamed(node, s) {
                                         s.accessedAliases.add(name);
                                     }
                                 }
-                                else if (prop.type === 'Property' &&
-                                    prop.value?.type === 'ObjectExpression' &&
-                                    prop.key?.type === 'Identifier') {
-                                    findSpreads(prop.value, [...path, prop.key.name]);
+                                else if (prop.type === 'Property' && prop.value?.type === 'ObjectExpression') {
+                                    const key = prop.key?.type === 'Identifier'
+                                        ? prop.key.name
+                                        : prop.key?.type === 'Literal' && typeof prop.key.value === 'string'
+                                            ? prop.key.value
+                                            : undefined;
+                                    if (key)
+                                        findSpreads(prop.value, [...path, key]);
                                 }
                             }
                         };

package/dist/typescript/visitors/walk.d.ts

@@ -1,4 +1,4 @@
-import { Visitor, type Class, type Function as FunctionNode, type Program, type Span, type VariableDeclarator } from 'oxc-parser';
+import { Visitor, type Class, type Function as FunctionNode, type Program, type Span, type TSInterfaceDeclaration, type VariableDeclarator } from 'oxc-parser';
 import type { PluginVisitorObject } from '../../types/config.ts';
 import type { GetImportsAndExportsOptions } from '../../types/config.ts';
 import type { Fix } from '../../types/exports.ts';
@@ -67,10 +67,12 @@ export interface WalkState extends WalkContext {
     scopeEnds: number[];
     shadowScopes: Map<string, [number, number][]>;
     localDeclarations: Map<string, FunctionNode | Class | VariableDeclarator>;
+    localInterfaces: Map<string, TSInterfaceDeclaration | null>;
     pendingCallRefs: Array<{
         name: string;
         exportName: string;
         seen: Set<string>;
+        kind: 'callee' | 'argument';
     }>;
     pendingMemberCallRefs: Array<{
         objectName: string;

package/dist/typescript/visitors/walk.js

@@ -49,7 +49,7 @@ const _addExport = (identifier, type, pos, members, fix, isReExport, jsDocTags)
         });
     }
 };
-const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), inBody = false) => {
+const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), inBody = false, thisType) => {
     if (!node)
         return;
     const type = node.type;
@@ -64,10 +64,14 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
             if (node.typeName?.type === 'Identifier')
                 _addRefInExport(node.typeName.name, exportName);
             break;
+        case 'TSThisType':
+            if (thisType)
+                _addRefInExport(thisType, exportName);
+            return;
         case 'CallExpression': {
             const callee = node.callee;
             if (callee?.type === 'Identifier') {
-                state.pendingCallRefs.push({ name: callee.name, exportName, seen });
+                state.pendingCallRefs.push({ name: callee.name, exportName, seen, kind: 'callee' });
             }
             else if (callee?.type === 'MemberExpression' &&
                 !callee.computed &&
@@ -84,8 +88,9 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
                 const args = node.arguments;
                 if (args) {
                     for (const arg of args) {
-                        if (arg?.type === 'Identifier')
-                            state.pendingCallRefs.push({ name: arg.name, exportName, seen });
+                        if (arg?.type === 'Identifier') {
+                            state.pendingCallRefs.push({ name: arg.name, exportName, seen, kind: 'argument' });
+                        }
                     }
                 }
             }
@@ -101,14 +106,14 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
         case 'TSSatisfiesExpression':
             if (inBody) {
                 if (node.expression)
-                    _collectRefsInType(node.expression, exportName, signatureOnly, seen, inBody);
+                    _collectRefsInType(node.expression, exportName, signatureOnly, seen, inBody, thisType);
                 return;
             }
             break;
         case 'VariableDeclarator':
             if (inBody) {
                 if (node.init)
-                    _collectRefsInType(node.init, exportName, signatureOnly, seen, inBody);
+                    _collectRefsInType(node.init, exportName, signatureOnly, seen, inBody, thisType);
                 return;
             }
             break;
@@ -124,14 +129,63 @@ const _collectRefsInType = (node, exportName, signatureOnly, seen = new Set(), i
         if (Array.isArray(val)) {
             for (const item of val) {
                 if (item)
-                    _collectRefsInType(item, exportName, signatureOnly, seen, childInBody);
+                    _collectRefsInType(item, exportName, signatureOnly, seen, childInBody, thisType);
             }
         }
         else {
-            _collectRefsInType(val, exportName, signatureOnly, seen, childInBody);
+            _collectRefsInType(val, exportName, signatureOnly, seen, childInBody, thisType);
         }
     }
 };
+const _collectRefsInDirectMemberResult = (fn, exportName, seen) => {
+    const body = fn.body;
+    if (body?.type !== 'MemberExpression' ||
+        body.computed ||
+        body.object?.type !== 'Identifier' ||
+        body.property?.type !== 'Identifier') {
+        return false;
+    }
+    const params = Array.isArray(fn.params) ? fn.params : (fn.params?.items ?? []);
+    const param = params.find((param) => param.type === 'Identifier' && param.name === body.object.name);
+    const paramType = param?.typeAnnotation?.typeAnnotation;
+    if (paramType?.type !== 'TSTypeReference' || paramType.typeName?.type !== 'Identifier' || paramType.typeArguments) {
+        return false;
+    }
+    const declaration = state.localInterfaces.get(paramType.typeName.name);
+    if (!declaration || declaration.typeParameters)
+        return false;
+    const members = declaration.body.body.filter((member) => member.type === 'TSPropertySignature' &&
+        !member.computed &&
+        member.key?.type === 'Identifier' &&
+        member.key.name === body.property.name &&
+        Boolean(member.typeAnnotation));
+    if (members.length !== 1)
+        return false;
+    _collectRefsInType(members[0].typeAnnotation, exportName, true, seen, false, paramType.typeName.name);
+    return true;
+};
+const _collectRefsInCallResult = (node, exportName, seen) => {
+    const annotatedType = node.type === 'VariableDeclarator' ? node.id.typeAnnotation?.typeAnnotation : undefined;
+    if (annotatedType?.type === 'TSFunctionType') {
+        _collectRefsInType(annotatedType.typeParameters, exportName, true, seen);
+        return _collectRefsInType(annotatedType.returnType, exportName, true, seen);
+    }
+    if (annotatedType)
+        return _collectRefsInType(annotatedType, exportName, true, seen);
+    const fn = node.type === 'VariableDeclarator' ? node.init : node;
+    if (fn?.type !== 'ArrowFunctionExpression' &&
+        fn?.type !== 'FunctionDeclaration' &&
+        fn?.type !== 'FunctionExpression') {
+        return _collectRefsInType(node, exportName, true, seen);
+    }
+    if (fn.returnType) {
+        _collectRefsInType(fn.typeParameters, exportName, true, seen);
+        return _collectRefsInType(fn.returnType, exportName, true, seen);
+    }
+    if (_collectRefsInDirectMemberResult(fn, exportName, seen))
+        return;
+    _collectRefsInType(fn, exportName, true, seen);
+};
 const _addRefInExport = (name, exportName) => {
     const refs = state.referencedInExport.get(name);
     if (refs)
@@ -221,6 +275,12 @@ const coreVisitorObject = {
                 state.addImport(specifier, name, undefined, undefined, node.id.start, IMPORT_FLAGS.TYPE_ONLY | IMPORT_FLAGS.AUGMENT);
         }
     },
+    TSInterfaceDeclaration(node) {
+        if (state.scopeDepth > 0 || state.isInNamespace(node))
+            return;
+        const name = node.id.name;
+        state.localInterfaces.set(name, state.localInterfaces.has(name) ? null : node);
+    },
     ClassDeclaration(node) {
         state.classNameStack.push(node.id?.name ?? '');
         if (node.id?.name) {
@@ -740,6 +800,7 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
         scopeEnds: [],
         shadowScopes: new Map(),
         localDeclarations: new Map(),
+        localInterfaces: new Map(),
         pendingCallRefs: [],
         pendingMemberCallRefs: [],
         localToExports: new Map(),
@@ -756,14 +817,18 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
     ctx.visitor.visit(program);
     while (state.pendingCallRefs.length > 0 || state.pendingMemberCallRefs.length > 0) {
         while (state.pendingCallRefs.length > 0) {
-            const { name, exportName, seen } = state.pendingCallRefs.pop();
-            if (seen.has(name))
+            const { name, exportName, seen, kind } = state.pendingCallRefs.pop();
+            const key = `${kind}:${name}`;
+            if (seen.has(key))
                 continue;
             const decl = state.localDeclarations.get(name);
             if (!decl)
                 continue;
-            seen.add(name);
-            _collectRefsInType(decl, exportName, true, seen);
+            seen.add(key);
+            if (kind === 'callee')
+                _collectRefsInCallResult(decl, exportName, seen);
+            else
+                _collectRefsInType(decl, exportName, true, seen);
         }
         while (state.pendingMemberCallRefs.length > 0) {
             const { objectName, propertyName, exportName, seen } = state.pendingMemberCallRefs.pop();
@@ -780,7 +845,7 @@ function walkAST(program, sourceText, filePath, hasModuleSyntax, ctx) {
             if (fn.type !== 'ArrowFunctionExpression' && fn.type !== 'FunctionExpression')
                 continue;
             seen.add(key);
-            _collectRefsInType(fn, exportName, true, seen);
+            _collectRefsInCallResult(fn, exportName, seen);
         }
     }
     for (let i = 0; i < state.memberRefsInFile.length; i += 2) {

package/dist/util/catalog.d.ts

@@ -4,8 +4,13 @@ export declare const DEFAULT_CATALOG = "default";
 export type CatalogReference = {
     catalogName: string;
     packageName: string;
+    selector?: string;
+};
+export type OverrideCatalogReference = CatalogReference & {
+    selector: string;
 };
 export declare const getCatalogReference: (specifier: string) => CatalogReference | undefined;
 export declare const getCatalogContainer: (cwd: string, manifest: PackageJson, manifestPath: string, pnpmWorkspacePath?: string, pnpmWorkspace?: any) => Promise<CatalogContainer>;
 export declare const parseCatalog: (container: CatalogContainer) => Set<string>;
+export declare const getOverrideCatalogReferences: (overrides: Record<string, string> | undefined) => OverrideCatalogReference[];
 export declare const extractCatalogReferences: (manifest: PackageJson) => CatalogReference[];