@esportsplus/typescript 0.31.0 → 0.31.1

package/README.md

@@ -18,6 +18,7 @@ Extends the TypeScript compiler with a plugin architecture for custom AST transf
 - Vite plugin for dev/build integration
 - CLI wrapper for `tsc` with automatic plugin detection
 - Language service caching for incremental compilation
+- `analyze` throw-safety analysis on the `tsc` passthrough and over LSP
 
 ## Usage
 
@@ -74,6 +75,83 @@ tsc
 
 The CLI detects plugins in `tsconfig.json` `compilerOptions.plugins`, loads them, runs coordinated compilation, and automatically calls `tsc-alias` afterward. The package installs `tsc`/`tsc-alias` bins (also under the unambiguous `esportsplus-tsc`/`esportsplus-tsc-alias` names).
 
+## analyze
+
+`analyze` is a static analyzer for effects TypeScript's types leave implicit. It runs a per-function summary fixpoint over the call graph — so a finding points at the *consumer*, the call site where a caller should be careful — and is organised into **channels**, each checking one class of effect:
+
+- **`exceptions`** — calls that may throw with no `catch` on the path to a handler boundary, `@throws` under-declaration, and `catch` rethrows that drop the caught error's `cause`. Carries the throw origin as related information.
+- **`resources`** — acquired resources (timers, event listeners, file handles, sockets, `Disposable`s, …) that can leak: not released, transferred, or `using`-bound on every path — including throwing paths, which it derives from the `exceptions` channel's summaries.
+- **`async`** — unbounded `Promise.all(…)`-style fan-out, orphaned promises whose rejections go unhandled, and awaited cancellable calls that drop an `AbortSignal` the function holds.
+
+Only `exceptions` is on by default; enable the others per project. It rides the `tsc` passthrough (build/CI), and ships an LSP server so editors can render the same findings.
+
+### Enable
+
+Add an `analyze` entry to `compilerOptions.plugins`. Analysis covers every file the tsconfig includes (ignoring excludes); no config beyond the entry is required.
+
+```jsonc
+{
+    "compilerOptions": {
+        "plugins": [
+            {
+                "name": "ts-probe",
+                // Editor squiggle color; "warn" opts down. CLI/build ignore this.
+                "severity": "error",
+                // Fail the tsc/build run when there are findings.
+                "failOnFindings": true,
+                // Per-channel config. `enabled` and `dispatch` are recognised on
+                // every channel; other keys are that channel's own options.
+                "channels": {
+                    "exceptions": {
+                        "enabled": true,
+                        // "consumers" (default): uncaught calls only.
+                        // "cross-module": only when the throwing callee is in another package.
+                        // "all": throws AND uncaught calls.
+                        "report": "consumers",
+                        // Flag `throw`s inside `catch` that drop the caught error's cause.
+                        "errorCause": true
+                    },
+                    "resources": {
+                        "enabled": true,
+                        // Untrackable handling when a resource escapes local analysis:
+                        // "optimist" assumes transfer (silent), "pessimist" reports it.
+                        "dispatch": "optimist",
+                        // Calls that take ownership of a passed resource argument.
+                        "ownership": [{ "callee": "registerCleanup", "params": [0] }]
+                    },
+                    "async": {
+                        "enabled": true,
+                        "fanOut": "warn",                     // "off" | "warn" | "error"
+                        "fanOutAllowLiteralUpTo": 16,         // inline array/tuple size that is fine
+                        "poolFunctions": ["p-limit", "p-map"] // sanctioned concurrency wrappers
+                    }
+                },
+                // Model third-party throw behavior: "node", "express".
+                "presets": ["node"]
+            }
+        ]
+    }
+}
+```
+
+### CLI / build
+
+The `tsc` passthrough runs analyze after a successful compile and prints findings to stderr. With `failOnFindings: true`, a run with findings exits non-zero — drop it into CI as a gate.
+
+```bash
+tsc   # compiles, resolves aliases, then reports analyze findings
+```
+
+### Editor (LSP)
+
+The package ships a standalone language server (`esportsplus-tsc-lsp` bin, or the `@esportsplus/typescript/lsp` export) that publishes analyze findings over LSP. A client spawns it beside the native TypeScript server and merges both diagnostic streams; `severity` drives the squiggle color. Analysis runs against saved files on open and save. Beyond diagnostics it serves **hovers** (the finding plus its origin→boundary chain) and **quick-fixes** — `void`/`await` an orphaned promise, forward an `AbortSignal`, or fix a leaked handle by converting it to `using` or wrapping the region in `try/finally`.
+
+```typescript
+import { startServer } from '@esportsplus/typescript/lsp';
+
+startServer(); // stdio LSP server
+```
+
 ## API
 
 ### `@esportsplus/typescript`
@@ -91,6 +169,14 @@ No exports. Import the TypeScript compiler API directly from `typescript/unstabl
 | `plugin` | Built-in plugins (`tsc`, `vite`) |
 | `uid` | Unique identifier generation |
 
+### `@esportsplus/typescript/lsp`
+
+| Export | Description |
+|---|---|
+| `startServer` | Start the stdio analyze LSP server |
+| `createServer` | Wire the server onto an existing JSON-RPC connection |
+| `AnalyzeWorkspace` | Long-lived native session that re-runs the analysis |
+
 ### Types
 
 ```typescript

package/bin/tsc-lsp

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../build/lsp/bin.js';

package/build/cli/diagnostics.d.ts

@@ -1,4 +1,8 @@
 import { type Diagnostic } from 'typescript/unstable/sync';
+import type { PositionMapping } from '../compiler/sourcemap.js';
 declare const flatten: (diagnostic: Diagnostic, indent?: number) => string;
-declare const format: (diagnostics: readonly Diagnostic[], root: string) => string;
+declare const format: (diagnostics: readonly Diagnostic[], root: string, transformed?: Map<string, {
+    code: string;
+    mapping: PositionMapping;
+}>) => string;
 export { flatten, format };

package/build/cli/diagnostics.js

@@ -2,6 +2,7 @@ import { readFileSync } from 'fs';
 import { computeLineStarts } from 'typescript/unstable/ast/scanner';
 import { DiagnosticCategory } from 'typescript/unstable/sync';
 import path from 'path';
+import { resolveOffset } from '../compiler/sourcemap.js';
 const ANSI_BLUE = '\x1b[94m';
 const ANSI_CYAN = '\x1b[96m';
 const ANSI_GREY = '\x1b[90m';
@@ -34,16 +35,18 @@ function categoryLabel(category) {
             return 'message';
     }
 }
-function formatOne(diagnostic, root) {
+function formatOne(diagnostic, root, sources, transformed) {
     let category = categoryLabel(diagnostic.category), code = `${ANSI_GREY}TS${diagnostic.code}${ANSI_RESET}`, color = categoryColor(diagnostic.category), message = flatten(diagnostic);
     if (diagnostic.fileName === undefined) {
         return `${color}${category}${ANSI_RESET} ${code}: ${message}`;
     }
-    let location = `${ANSI_CYAN}${path.relative(root, diagnostic.fileName).replace(BACKSLASH_REGEX, '/')}${ANSI_RESET}`, text = readSource(diagnostic.fileName);
+    let location = `${ANSI_CYAN}${path.relative(root, diagnostic.fileName).replace(BACKSLASH_REGEX, '/')}${ANSI_RESET}`, entry = transformed?.get(diagnostic.fileName.replace(BACKSLASH_REGEX, '/')), end = entry ? resolveOffset(entry.mapping, diagnostic.end) : diagnostic.end, pos = entry ? resolveOffset(entry.mapping, diagnostic.pos) : diagnostic.pos, sourceInfo = sources.get(diagnostic.fileName) ?? readSourceInfo(diagnostic.fileName);
+    sources.set(diagnostic.fileName, sourceInfo);
+    const text = sourceInfo.text;
     if (text === undefined) {
         return `${location} - ${color}${category}${ANSI_RESET} ${code}: ${message}`;
     }
-    let lineStarts = computeLineStarts(text), line = lineOfPosition(lineStarts, diagnostic.pos), character = diagnostic.pos - lineStarts[line], lineEnd = line + 1 < lineStarts.length ? lineStarts[line + 1] : text.length, source = text.slice(lineStarts[line], lineEnd).replace(TRAILING_NEWLINE_REGEX, ''), width = Math.max(1, Math.min(diagnostic.end, lineEnd) - diagnostic.pos), underline = `${' '.repeat(character)}${color}${'~'.repeat(width)}${ANSI_RESET}`, header = `${location}:${ANSI_YELLOW}${line + 1}${ANSI_RESET}:${ANSI_YELLOW}${character + 1}${ANSI_RESET} - ${color}${category}${ANSI_RESET} ${code}: ${message}`;
+    let lineStarts = sourceInfo.lineStarts, line = lineOfPosition(lineStarts, pos), character = pos - lineStarts[line], lineEnd = line + 1 < lineStarts.length ? lineStarts[line + 1] : text.length, source = text.slice(lineStarts[line], lineEnd).replace(TRAILING_NEWLINE_REGEX, ''), width = Math.max(1, Math.min(end, lineEnd) - pos), underline = `${' '.repeat(character)}${color}${'~'.repeat(width)}${ANSI_RESET}`, header = `${location}:${ANSI_YELLOW}${line + 1}${ANSI_RESET}:${ANSI_YELLOW}${character + 1}${ANSI_RESET} - ${color}${category}${ANSI_RESET} ${code}: ${message}`;
     return `${header}\n\n${source}\n${underline}`;
 }
 function lineOfPosition(lineStarts, position) {
@@ -59,12 +62,13 @@ function lineOfPosition(lineStarts, position) {
     }
     return high < 0 ? 0 : high;
 }
-function readSource(fileName) {
+function readSourceInfo(fileName) {
     try {
-        return readFileSync(fileName, 'utf8');
+        const text = readFileSync(fileName, 'utf8');
+        return { lineStarts: computeLineStarts(text), text };
     }
     catch {
-        return undefined;
+        return { lineStarts: [], text: undefined };
     }
 }
 const flatten = (diagnostic, indent = 0) => {
@@ -80,10 +84,11 @@ const flatten = (diagnostic, indent = 0) => {
     }
     return result;
 };
-const format = (diagnostics, root) => {
+const format = (diagnostics, root, transformed) => {
     let parts = [];
+    const sources = new Map();
     for (let i = 0, n = diagnostics.length; i < n; i++) {
-        parts.push(formatOne(diagnostics[i], root));
+        parts.push(formatOne(diagnostics[i], root, sources, transformed));
     }
     return parts.join('\n\n');
 };

package/build/cli/tsc.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from '../compiler/types.js';
 import { API } from 'typescript/unstable/sync';
+import { stripJsonc } from '../jsonc.js';
 type PluginConfig = {
     transform: string;
 };
@@ -13,6 +14,7 @@ declare function isPlugin(value: unknown): value is Plugin;
 declare function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugin[]>;
 declare function main(): void;
 declare function normalizePath(fileName: string): string;
+declare function projectPath(args: string[]): string | null;
 declare function resolvePluginConfigs(tsconfig: string): PluginConfig[];
 declare function runTscAlias(args: string[]): Promise<number>;
-export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, resolvePluginConfigs, runTscAlias };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runTscAlias, stripJsonc };

package/build/cli/tsc.js

@@ -1,4 +1,4 @@
-import { API, DiagnosticCategory } from 'typescript/unstable/sync';
+import { DiagnosticCategory } from 'typescript/unstable/sync';
 import { createRequire } from 'module';
 import { format } from './diagnostics.js';
 import { PACKAGE_NAME } from '../constants.js';
@@ -9,30 +9,36 @@ import fs from 'fs';
 import languageService from '../compiler/language-service.js';
 import path from 'path';
 import sourcemap from '../compiler/sourcemap.js';
+import { analyze, analyzeProgram } from '../probe/kernel/analyze.js';
+import { formatDiagnostics } from '../probe/kernel/format.js';
+import { loadConfigFromTsconfig } from '../probe/kernel/config.js';
+import { stripJsonc } from '../jsonc.js';
+import { readPlugins } from '../tsconfig.js';
 const BACKSLASH_REGEX = /\\/g;
 const INFORMATIONAL_FLAGS = new Set(['--help', '--init', '--showConfig', '--version', '-h', '-v']);
 const NO_EMIT_FLAGS = new Set(['--noEmit', '-noEmit']);
 const WATCH_FLAGS = new Set(['--watch', '-w']);
-let require = createRequire(import.meta.url), skipFlags = new Set(['--help', '--init', '--noEmit', '--showConfig', '--version', '-h', '-noEmit', '-v']);
+let require = createRequire(import.meta.url), skipFlags = new Set([...INFORMATIONAL_FLAGS, ...NO_EMIT_FLAGS]);
 async function build(tsconfig, pluginConfigs, instance, noEmit = false) {
-    let root = path.dirname(path.resolve(tsconfig)), owned = instance === undefined, api = instance ?? new API({ cwd: root }), snapshot = api.updateSnapshot({ openProjects: [tsconfig] }), project = snapshot.getProject(tsconfig);
+    let opened = instance === undefined ? languageService.open(tsconfig) : undefined, root = path.dirname(path.resolve(tsconfig)), owned = instance === undefined, api = opened?.api ?? instance, snapshot = opened?.snapshot ?? api.updateSnapshot({ openProjects: [tsconfig] }), project = opened?.project ?? snapshot.getProject(tsconfig);
     if (!project) {
-        teardown(snapshot, api, root, owned);
+        teardown(snapshot, tsconfig, owned);
         throw new Error(`${PACKAGE_NAME}: project not found for ${tsconfig}`);
     }
     let configDiagnostics = project.program.getConfigFileParsingDiagnostics();
     if (configDiagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
         console.error(format(configDiagnostics, root));
-        teardown(snapshot, api, root, owned);
+        teardown(snapshot, tsconfig, owned);
         process.exit(1);
     }
     let { fileNames, options } = api.parseConfigFile(tsconfig), plugins, shared = new Map(), transformedFiles = new Map();
+    runAnalyze(tsconfig, project.program, project.checker);
     try {
         plugins = await loadPlugins(pluginConfigs, root);
     }
     catch (error) {
         console.error(error instanceof Error ? error.message : String(error));
-        teardown(snapshot, api, root, owned);
+        teardown(snapshot, tsconfig, owned);
         process.exit(1);
     }
     for (let i = 0, n = fileNames.length; i < n; i++) {
@@ -40,15 +46,14 @@ async function build(tsconfig, pluginConfigs, instance, noEmit = false) {
         if (!sourceFile) {
             continue;
         }
-        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, { checker: project.checker, program: project.program }, root, shared);
+        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, { checker: project.checker, configPath: tsconfig, program: project.program }, root, shared);
         if (result.changed) {
             transformedFiles.set(normalizePath(fileName), { code: result.code, mapping: result.map });
         }
     }
-    let program = project.program;
-    for (let [fileName, entry] of transformedFiles) {
-        program = languageService.update(root, fileName, entry.code).program;
-    }
+    let program = transformedFiles.size === 0
+        ? project.program
+        : languageService.updateMany(tsconfig, new Map([...transformedFiles].map(([fileName, entry]) => [fileName, entry.code]))).program;
     let diagnostics = [
         ...program.getConfigFileParsingDiagnostics(),
         ...program.getSyntacticDiagnostics(),
@@ -58,18 +63,18 @@ async function build(tsconfig, pluginConfigs, instance, noEmit = false) {
         ...program.getProgramDiagnostics()
     ];
     if (diagnostics.length > 0) {
-        console.error(format(diagnostics, root));
+        console.error(format(diagnostics, root, transformedFiles));
     }
     if (diagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
-        teardown(snapshot, api, root, owned);
+        teardown(snapshot, tsconfig, owned);
         process.exit(1);
     }
     if (noEmit) {
-        teardown(snapshot, api, root, owned);
+        teardown(snapshot, tsconfig, owned);
         process.exit(0);
     }
     let code = await emit(tsconfig, fileNames, transformedFiles, root, options);
-    teardown(snapshot, api, root, owned);
+    teardown(snapshot, tsconfig, owned);
     if (code !== 0) {
         process.exit(code);
     }
@@ -187,36 +192,6 @@ async function emit(tsconfig, fileNames, transformedFiles, root, options) {
         fs.rmSync(mirror, { force: true, recursive: true });
     }
 }
-function extendsTarget(specifier, fromDir) {
-    if (typeof specifier !== 'string') {
-        return null;
-    }
-    if (specifier.startsWith('.')) {
-        let resolved = path.resolve(fromDir, specifier);
-        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
-            return resolved;
-        }
-        if (fs.existsSync(resolved + '.json')) {
-            return resolved + '.json';
-        }
-        let nested = path.join(resolved, 'tsconfig.json');
-        if (fs.existsSync(nested)) {
-            return nested;
-        }
-        return null;
-    }
-    try {
-        return require.resolve(specifier, { paths: [fromDir] });
-    }
-    catch {
-        try {
-            return require.resolve(specifier + '/tsconfig.json', { paths: [fromDir] });
-        }
-        catch {
-            return null;
-        }
-    }
-}
 function isPlugin(value) {
     return typeof value === 'object' && value !== null && 'transform' in value && typeof value.transform === 'function';
 }
@@ -254,22 +229,24 @@ async function loadPlugins(configs, root) {
     return plugins;
 }
 function main() {
-    let tsconfig = languageService.findConfig(process.cwd());
+    let args = process.argv.slice(2), tsconfig = projectPath(args) ?? languageService.findConfig(process.cwd());
     if (!tsconfig) {
         return passthrough();
     }
+    let flags = classifyFlags(args);
     let pluginConfigs = resolvePluginConfigs(tsconfig);
     if (pluginConfigs.length === 0) {
+        if (!flags.informational && !flags.watch) {
+            runAnalyze(tsconfig);
+        }
         return passthrough();
     }
-    let flags = classifyFlags(process.argv.slice(2));
     if (flags.informational) {
         return passthrough();
     }
     if (flags.watch) {
         console.error(`${PACKAGE_NAME}: --watch is not supported on the transformer plugin path; run a one-shot build or use real tsc directly`);
         process.exit(1);
-        return;
     }
     console.log(`${PACKAGE_NAME}: found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
     build(tsconfig, pluginConfigs, undefined, flags.noEmit).catch((err) => {
@@ -280,6 +257,49 @@ function main() {
 function normalizePath(fileName) {
     return path.resolve(fileName).replace(BACKSLASH_REGEX, '/');
 }
+function projectPath(args) {
+    for (let i = 0, n = args.length; i < n; i++) {
+        let arg = args[i], value;
+        if (arg === '-p' || arg === '--project') {
+            value = args[i + 1];
+        }
+        else if (arg.startsWith('--project=')) {
+            value = arg.slice('--project='.length);
+        }
+        if (value !== undefined) {
+            let resolved = path.resolve(value);
+            return fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()
+                ? path.join(resolved, 'tsconfig.json')
+                : resolved;
+        }
+    }
+    return null;
+}
+function runAnalyze(tsconfig, program, checker) {
+    let config;
+    try {
+        config = loadConfigFromTsconfig(tsconfig);
+    }
+    catch (error) {
+        console.error(`${PACKAGE_NAME}: analyze config error: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (!config) {
+        return;
+    }
+    try {
+        let result = program && checker ? analyzeProgram(program, checker, config) : analyze(config);
+        if (result.diagnostics.length > 0) {
+            console.error(formatDiagnostics(result.diagnostics, config.projectRoot));
+            if (config.failOnFindings) {
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`${PACKAGE_NAME}: analyze failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 function passthrough() {
     let args = process.argv.slice(2), tsDir = path.dirname(require.resolve('typescript/package.json'));
     spawn(process.execPath, [path.join(tsDir, 'lib', 'tsc.js'), ...args], { stdio: 'inherit' })
@@ -290,39 +310,8 @@ function passthrough() {
         process.exit(code ?? 0);
     });
 }
-function readPlugins(tsconfig, seen) {
-    let id = path.resolve(tsconfig);
-    if (seen.has(id)) {
-        return undefined;
-    }
-    seen.add(id);
-    let config;
-    try {
-        config = JSON.parse(stripJsonc(fs.readFileSync(id, 'utf8')));
-    }
-    catch {
-        return undefined;
-    }
-    let plugins;
-    if (config?.extends !== undefined) {
-        let bases = Array.isArray(config.extends) ? config.extends : [config.extends];
-        for (let i = 0, n = bases.length; i < n; i++) {
-            let target = extendsTarget(bases[i], path.dirname(id));
-            if (target) {
-                let inherited = readPlugins(target, seen);
-                if (inherited !== undefined) {
-                    plugins = inherited;
-                }
-            }
-        }
-    }
-    if (Array.isArray(config?.compilerOptions?.plugins)) {
-        plugins = config.compilerOptions.plugins;
-    }
-    return plugins;
-}
 function resolvePluginConfigs(tsconfig) {
-    let plugins = readPlugins(tsconfig, new Set());
+    let plugins = readPlugins(tsconfig);
     if (!Array.isArray(plugins)) {
         return [];
     }
@@ -345,7 +334,7 @@ function spawnTsc(tscJs, args) {
         child.on('exit', (code) => resolve(code ?? 0));
     });
 }
-function stripJsonc(text) {
+function legacyStripJsonc(text) {
     let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
     for (let i = 0, n = text.length; i < n; i++) {
         let char = text[i], next = text[i + 1];
@@ -429,16 +418,17 @@ function stripJsonc(text) {
     }
     return result;
 }
-function teardown(snapshot, api, root, owned) {
+void legacyStripJsonc;
+function teardown(snapshot, configPath, owned) {
+    if (owned) {
+        languageService.dispose(configPath);
+        return;
+    }
     if (!snapshot.isDisposed()) {
         snapshot.dispose();
     }
-    if (owned) {
-        api.close();
-    }
-    languageService.dispose(root);
 }
 if (process.env.VITEST === undefined) {
     main();
 }
-export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, resolvePluginConfigs, runTscAlias };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runTscAlias, stripJsonc };

package/build/compiler/coordinator.d.ts

@@ -6,10 +6,10 @@ type CoordinatorResult = {
     changed: boolean;
     code: string;
     map: PositionMapping;
-    sourceFile: SourceFile;
 };
 declare const transform: (plugins: Plugin[], code: string, file: SourceFile, project: {
     checker: Checker;
+    configPath?: string;
     program: Program;
 }, root: string, shared: SharedContext) => {
     changed: boolean;
@@ -17,7 +17,6 @@ declare const transform: (plugins: Plugin[], code: string, file: SourceFile, pro
     map: {
         generations: OffsetAnchor[][];
     };
-    sourceFile: SourceFile;
 };
 declare const _default: {
     transform: typeof transform;

package/build/compiler/coordinator.js

@@ -26,18 +26,15 @@ function applyImports(code, file, intents) {
             });
         }
     }
-    let batches = [], keys = [...merged.keys()];
+    let edits = [], keys = [...merged.keys()];
     for (let i = 0, n = keys.length; i < n; i++) {
-        let before = code, result = modify(code, file, keys[i], merged.get(keys[i]));
-        code = result.code;
-        if (result.edits.length > 0) {
-            batches.push({ before, edits: result.edits });
-        }
-        if (i < n - 1) {
-            file = languageService.parse(file.fileName, code);
-        }
+        let result = modify(code, file, keys[i], merged.get(keys[i]));
+        edits.push(...result.edits);
+    }
+    if (edits.length === 0) {
+        return { batches: [], code };
     }
-    return { batches, code };
+    return { batches: [{ before: code, edits }], code: replaceReverse(code, edits) };
 }
 function applyIntents(code, file, intents) {
     if (intents.length === 0) {
@@ -84,6 +81,9 @@ function modify(code, file, pkg, options) {
         return { code, edits: [] };
     }
     let { namespace } = options, add = options.add ? new Set(options.add) : null, found = imports.all(file, pkg);
+    if (namespace && !add && !options.remove && found.some(info => info.namespace === namespace)) {
+        return { code, edits: [] };
+    }
     if (found.length === 0) {
         let statements = [];
         if (namespace) {
@@ -98,7 +98,7 @@ function modify(code, file, pkg, options) {
         let newText = statements.join('\n') + '\n';
         return { code: newText + code, edits: [{ end: 0, newText, start: 0 }] };
     }
-    let remove = options.remove ? new Set(options.remove) : null, specifiers = new Set();
+    let remove = options.remove ? new Set(options.remove) : null, specifiers = new Set(), nonNamespace = found.filter(info => !info.namespace), existingNamespace = found.some(info => info.namespace === namespace), defaultImport = nonNamespace.find(info => info.defaultName), target = defaultImport ?? nonNamespace[0];
     for (let i = 0, n = found.length; i < n; i++) {
         for (let [name, alias] of found[i].specifiers) {
             if (!remove || (!remove.has(name) && !remove.has(alias))) {
@@ -113,20 +113,34 @@ function modify(code, file, pkg, options) {
         }
     }
     let statements = [];
-    if (namespace) {
+    if (namespace && !existingNamespace) {
         statements.push(`import * as ${namespace} from '${pkg}';`);
     }
-    if (specifiers.size > 0) {
+    if (target) {
+        let named = specifiers.size > 0 ? `{ ${[...specifiers].sort().join(', ')} }` : '', defaultName = target.defaultName, clause = defaultName && named ? `${defaultName}, ${named}` : defaultName ?? named;
+        if (clause) {
+            statements.push(`import ${clause} from '${pkg}';`);
+        }
+    }
+    else if (specifiers.size > 0) {
         statements.push(`import { ${[...specifiers].sort().join(', ')} } from '${pkg}';`);
     }
     let replacements = [];
     for (let i = 0, n = found.length; i < n; i++) {
+        let info = found[i];
+        if (info.namespace) {
+            continue;
+        }
         replacements.push({
-            end: found[i].end,
-            newText: i === 0 ? statements.join('\n') : '',
-            start: found[i].start
+            end: info.end,
+            newText: info === target ? statements.join('\n') : info.defaultName ? `import ${info.defaultName} from '${pkg}';` : '',
+            start: info.start
         });
     }
+    if (!target && statements.length > 0) {
+        let first = found[0];
+        replacements.push({ end: first.start, newText: statements.join('\n') + '\n', start: first.start });
+    }
     return { code: replaceReverse(code, replacements), edits: replacements };
 }
 function replaceReverse(code, replacements) {
@@ -150,7 +164,7 @@ function replaceReverse(code, replacements) {
 }
 const transform = (plugins, code, file, project, root, shared) => {
     if (plugins.length === 0) {
-        return { changed: false, code, map: { generations: [] }, sourceFile: file };
+        return { changed: false, code, map: { generations: [] } };
     }
     uid.scope(root, file.fileName, code);
     let changed = false, currentCode = code, currentFile = file, currentProject = project, fileName = file.fileName, generations = [], last = plugins.length - 1;
@@ -199,15 +213,12 @@ const transform = (plugins, code, file, project, root, shared) => {
         if (pluginChanged) {
             changed = true;
             if (i < last) {
-                currentProject = languageService.update(root, fileName, currentCode);
+                currentProject = languageService.update(project.configPath ?? languageService.findConfig(root) ?? root, fileName, currentCode);
                 currentFile = currentProject.program.getSourceFile(fileName) ??
                     languageService.parse(fileName, currentCode);
             }
-            else {
-                currentFile = languageService.parse(fileName, currentCode);
-            }
         }
     }
-    return { changed, code: currentCode, map: { generations }, sourceFile: currentFile };
+    return { changed, code: currentCode, map: { generations } };
 };
 export default { transform };

package/build/compiler/imports.d.ts

@@ -1,7 +1,9 @@
 import type { Node, SourceFile } from 'typescript/unstable/ast';
 import type { Checker } from 'typescript/unstable/sync';
 type ImportInfo = {
+    defaultName?: string;
     end: number;
+    namespace?: string;
     specifiers: Map<string, string>;
     typeOnly: Set<string>;
     start: number;

package/build/compiler/imports.js

@@ -1,5 +1,5 @@
 import { SyntaxKind } from 'typescript/unstable/ast';
-import { isIdentifier, isImportDeclaration, isNamedImports, isStringLiteral } from 'typescript/unstable/ast/is';
+import { isIdentifier, isImportDeclaration, isNamedImports, isNamespaceImport, isStringLiteral } from 'typescript/unstable/ast/is';
 import { SymbolFlags } from 'typescript/unstable/sync';
 let cache = new WeakMap();
 function fileNameMatchesPackage(fileName, pkg) {
@@ -27,7 +27,14 @@ const all = (file, pkg) => {
                 }
             }
         }
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file), typeOnly });
+        imports.push({
+            defaultName: stmt.importClause?.name?.text,
+            end: stmt.end,
+            namespace: bindings && isNamespaceImport(bindings) ? bindings.name.text : undefined,
+            specifiers,
+            start: stmt.getStart(file),
+            typeOnly
+        });
     }
     return imports;
 };