@typed/virtual-modules 1.0.0-beta.1

package/dist/LanguageServiceAdapter.js

@@ -0,0 +1,488 @@
+import { fileURLToPath } from "node:url";
+import { unlinkSync } from "node:fs";
+import { materializeVirtualFile, rewriteSourceForPreviewLocation, } from "./internal/materializeVirtualFile.js";
+import { createVirtualRecordStore, toResolvedModule, } from "./internal/VirtualRecordStore.js";
+import { VIRTUAL_MODULE_URI_SCHEME, VIRTUAL_NODE_MODULES_RELATIVE, } from "./internal/path.js";
+/** Prefix VSCode uses when sending non-file URIs to tsserver (query params are dropped). */
+const IN_MEMORY_RESOURCE_PREFIX = "^";
+/** Schemes used by VSCode extension for virtual module preview docs. */
+const PREVIEW_SCHEMES = ["virtual-module", VIRTUAL_MODULE_URI_SCHEME];
+/**
+ * Parse a fileName that may be:
+ * 1) Full URI: virtual-module:///module.ts?id=x&importer=y (query may be dropped by VSCode)
+ * 2) tsserver path: ^/virtual-module/ts-nul-authority/path/to/__virtual_plugin_hash.ts
+ */
+function parsePreviewUri(fileName) {
+    const pathBased = tryParsePathBasedFromTsServer(fileName);
+    if (pathBased)
+        return pathBased;
+    if (!fileName.includes("://"))
+        return undefined;
+    try {
+        const url = new URL(fileName);
+        if (!PREVIEW_SCHEMES.includes(url.protocol.replace(":", "")))
+            return undefined;
+        const id = url.searchParams.get("id");
+        const importerRaw = url.searchParams.get("importer");
+        if (!id || !importerRaw)
+            return undefined;
+        const importer = importerRaw.startsWith("file:")
+            ? (() => {
+                try {
+                    return fileURLToPath(importerRaw);
+                }
+                catch {
+                    return importerRaw;
+                }
+            })()
+            : importerRaw;
+        return { id, importer };
+    }
+    catch {
+        return undefined;
+    }
+}
+function tryParsePathBasedFromTsServer(fileName) {
+    if (!fileName.startsWith(IN_MEMORY_RESOURCE_PREFIX + "/"))
+        return undefined;
+    const rest = fileName.slice(IN_MEMORY_RESOURCE_PREFIX.length);
+    const parts = rest.split("/");
+    if (parts.length < 4)
+        return undefined;
+    const [scheme] = [parts[1], parts[2]];
+    if (!PREVIEW_SCHEMES.includes(scheme))
+        return undefined;
+    const path = "/" + parts.slice(3).join("/");
+    if (!path.includes("__virtual_"))
+        return undefined;
+    return { virtualPath: path };
+}
+const ADAPTER_DIAGNOSTIC_CODE = 99001;
+const toTsDiagnostic = (tsMod, message, file) => ({
+    category: tsMod.DiagnosticCategory.Error,
+    code: ADAPTER_DIAGNOSTIC_CODE,
+    file,
+    start: 0,
+    length: 0,
+    messageText: message,
+});
+export const attachLanguageServiceAdapter = (options) => {
+    if (typeof options.projectRoot !== "string" || options.projectRoot.trim() === "") {
+        throw new Error("projectRoot must be a non-empty string");
+    }
+    const host = options.languageServiceHost;
+    const watchHost = (options.watchHost ??
+        options.languageServiceHost);
+    const diagnosticsByFile = new Map();
+    let epoch = 0;
+    let inResolution = false;
+    let inResolveRecord = false;
+    let pendingRetry = false;
+    const originalGetScriptFileNames = host.getScriptFileNames?.bind(host);
+    const originalResolveModuleNameLiterals = host.resolveModuleNameLiterals?.bind(host);
+    const originalResolveModuleNames = host.resolveModuleNames?.bind(host);
+    const originalGetScriptSnapshot = host.getScriptSnapshot?.bind(host);
+    const originalGetScriptVersion = host.getScriptVersion?.bind(host);
+    const originalGetProjectVersion = host.getProjectVersion?.bind(host);
+    const originalFileExists = host.fileExists?.bind(host);
+    const originalReadFile = host.readFile?.bind(host);
+    const originalGetSemanticDiagnostics = options.languageService.getSemanticDiagnostics.bind(options.languageService);
+    const originalGetSyntacticDiagnostics = options.languageService.getSyntacticDiagnostics.bind(options.languageService);
+    const addDiagnosticForFile = (filePath, message) => {
+        const diagnostic = toTsDiagnostic(options.ts, message);
+        const diagnostics = diagnosticsByFile.get(filePath) ?? [];
+        diagnostics.push(diagnostic);
+        diagnosticsByFile.set(filePath, diagnostics);
+    };
+    const clearDiagnosticsForFile = (filePath) => {
+        diagnosticsByFile.delete(filePath);
+    };
+    const store = createVirtualRecordStore({
+        projectRoot: options.projectRoot,
+        resolver: options.resolver,
+        createTypeInfoApiSession: options.createTypeInfoApiSession,
+        debounceMs: options.debounceMs,
+        watchHost,
+        shouldEvictRecord: (record) => {
+            const currentFiles = new Set(originalGetScriptFileNames ? originalGetScriptFileNames() : []);
+            return !currentFiles.has(record.importer);
+        },
+        onFlushStale: () => {
+            epoch += 1;
+        },
+        onBeforeResolve: () => {
+            inResolveRecord = true;
+        },
+        onAfterResolve: () => {
+            inResolveRecord = false;
+        },
+        onRecordResolved: (record) => {
+            clearDiagnosticsForFile(record.importer);
+        },
+        onEvictRecord: (record) => {
+            clearDiagnosticsForFile(record.importer);
+            if (record.virtualFileName.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+                try {
+                    unlinkSync(record.virtualFileName);
+                }
+                catch {
+                    /* ignore if already deleted or missing */
+                }
+            }
+        },
+    });
+    const { recordsByVirtualFile } = store;
+    const getOrBuildRecord = (id, importer) => {
+        store.evictStaleImporters();
+        if (inResolveRecord) {
+            return {
+                status: "error",
+                diagnostic: {
+                    code: "re-entrant-resolution",
+                    pluginName: "",
+                    message: "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()",
+                },
+            };
+        }
+        return store.getOrBuildRecord(id, importer);
+    };
+    const rebuildRecordIfNeeded = (record) => {
+        if (!record.stale) {
+            return record;
+        }
+        const rebuilt = store.resolveRecord(record.id, record.importer, record);
+        if (rebuilt.status === "resolved") {
+            clearDiagnosticsForFile(record.importer);
+            return rebuilt.record;
+        }
+        if (rebuilt.status === "error") {
+            const diagnostic = toTsDiagnostic(options.ts, `Virtual module rebuild failed: ${rebuilt.diagnostic.message}`);
+            const diagnostics = diagnosticsByFile.get(record.importer) ?? [];
+            diagnostics.push(diagnostic);
+            diagnosticsByFile.set(record.importer, diagnostics);
+        }
+        return record;
+    };
+    const fallbackResolveModule = (moduleName, containingFile, compilerOptions) => {
+        const result = options.ts.resolveModuleName(moduleName, containingFile, compilerOptions ?? {}, {
+            fileExists: (path) => host.fileExists?.(path) ?? false,
+            readFile: (path) => host.readFile?.(path),
+            directoryExists: (path) => host.directoryExists?.(path) ?? options.ts.sys.directoryExists(path),
+            getCurrentDirectory: () => host.getCurrentDirectory?.() ?? options.ts.sys.getCurrentDirectory(),
+            getDirectories: (path) => {
+                const fromHost = host.getDirectories?.(path);
+                if (fromHost !== undefined)
+                    return [...fromHost];
+                const fromSys = options.ts.sys.getDirectories?.(path);
+                return fromSys !== undefined ? [...fromSys] : [];
+            },
+            realpath: (path) => host.realpath?.(path) ?? options.ts.sys.realpath?.(path) ?? path,
+            useCaseSensitiveFileNames: host.useCaseSensitiveFileNames?.() ?? options.ts.sys.useCaseSensitiveFileNames,
+        });
+        return result.resolvedModule;
+    };
+    host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) => {
+        if (inResolution) {
+            if (inResolveRecord) {
+                const diagnostic = toTsDiagnostic(options.ts, "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()");
+                const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+                diagnostics.push(diagnostic);
+                diagnosticsByFile.set(containingFile, diagnostics);
+            }
+            return moduleNames.map(() => undefined);
+        }
+        inResolution = true;
+        try {
+            const parsed = parsePreviewUri(containingFile);
+            let effectiveContainingFile = containingFile;
+            let importerForVirtual = containingFile;
+            if (parsed) {
+                if ("virtualPath" in parsed) {
+                    const r = recordsByVirtualFile.get(parsed.virtualPath);
+                    if (r) {
+                        effectiveContainingFile = r.virtualFileName;
+                        importerForVirtual = r.importer;
+                    }
+                }
+                else {
+                    const r = getOrBuildRecord(parsed.id, parsed.importer);
+                    if (r.status === "resolved") {
+                        effectiveContainingFile = r.record.virtualFileName;
+                        importerForVirtual = r.record.importer;
+                    }
+                }
+            }
+            const fallback = originalResolveModuleNames
+                ? originalResolveModuleNames(moduleNames, effectiveContainingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile)
+                : moduleNames.map((moduleName) => fallbackResolveModule(moduleName, effectiveContainingFile, compilerOptions));
+            let hadVirtualError = false;
+            let hadUnresolvedVirtual = false;
+            const results = moduleNames.map((moduleName, index) => {
+                const resolved = getOrBuildRecord(moduleName, importerForVirtual);
+                if (resolved.status === "resolved") {
+                    pendingRetry = false;
+                    return toResolvedModule(options.ts, resolved.record.virtualFileName);
+                }
+                if (resolved.status === "error") {
+                    hadVirtualError = true;
+                    addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+                    if (resolved.diagnostic.code === "re-entrant-resolution") {
+                        return undefined;
+                    }
+                }
+                if (resolved.status === "unresolved" && moduleName.includes(":")) {
+                    hadUnresolvedVirtual = true;
+                }
+                return fallback[index];
+            });
+            if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+                pendingRetry = true;
+                epoch += 1;
+            }
+            return results;
+        }
+        finally {
+            inResolution = false;
+        }
+    };
+    const assignResolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames) => {
+        if (inResolution) {
+            if (inResolveRecord) {
+                const diagnostic = toTsDiagnostic(options.ts, "Re-entrant resolution not allowed; plugins must not trigger module resolution during build()");
+                const diagnostics = diagnosticsByFile.get(containingFile) ?? [];
+                diagnostics.push(diagnostic);
+                diagnosticsByFile.set(containingFile, diagnostics);
+            }
+            return moduleLiterals.map(() => ({ resolvedModule: undefined }));
+        }
+        inResolution = true;
+        try {
+            const parsed = parsePreviewUri(containingFile);
+            let effectiveContainingFile = containingFile;
+            let importerForVirtual = containingFile;
+            if (parsed) {
+                if ("virtualPath" in parsed) {
+                    const r = recordsByVirtualFile.get(parsed.virtualPath);
+                    if (r) {
+                        effectiveContainingFile = r.virtualFileName;
+                        importerForVirtual = r.importer;
+                    }
+                }
+                else {
+                    const r = getOrBuildRecord(parsed.id, parsed.importer);
+                    if (r.status === "resolved") {
+                        effectiveContainingFile = r.record.virtualFileName;
+                        importerForVirtual = r.record.importer;
+                    }
+                }
+            }
+            const fallback = originalResolveModuleNameLiterals
+                ? originalResolveModuleNameLiterals(moduleLiterals, effectiveContainingFile, redirectedReference, compilerOptions, containingSourceFile, reusedNames)
+                : moduleLiterals.map((moduleLiteral) => ({
+                    resolvedModule: fallbackResolveModule(moduleLiteral.text, effectiveContainingFile, compilerOptions),
+                }));
+            let hadVirtualError = false;
+            let hadUnresolvedVirtual = false;
+            const results = moduleLiterals.map((moduleLiteral, index) => {
+                const resolved = getOrBuildRecord(moduleLiteral.text, importerForVirtual);
+                if (moduleLiteral.text.includes(":")) {
+                    try {
+                        require("node:fs").appendFileSync("/tmp/vm-ts-plugin-debug.log", JSON.stringify({
+                            tag: "LS:resolveLiterals",
+                            id: moduleLiteral.text,
+                            status: resolved.status,
+                            err: resolved.status === "error" ? resolved.diagnostic?.message : undefined,
+                            t: Date.now(),
+                        }) + "\n", { flag: "a" });
+                    }
+                    catch {
+                        /* noop */
+                    }
+                }
+                if (resolved.status === "resolved") {
+                    pendingRetry = false;
+                    return {
+                        resolvedModule: toResolvedModule(options.ts, resolved.record.virtualFileName),
+                    };
+                }
+                if (resolved.status === "error") {
+                    hadVirtualError = true;
+                    addDiagnosticForFile(containingFile, resolved.diagnostic.message);
+                    if (resolved.diagnostic.code === "re-entrant-resolution") {
+                        return fallback[index];
+                    }
+                }
+                if (resolved.status === "unresolved" && moduleLiteral.text.includes(":")) {
+                    hadUnresolvedVirtual = true;
+                }
+                return fallback[index];
+            });
+            if ((hadVirtualError || hadUnresolvedVirtual) && !pendingRetry) {
+                pendingRetry = true;
+                epoch += 1;
+            }
+            return results;
+        }
+        finally {
+            inResolution = false;
+        }
+    };
+    host.resolveModuleNameLiterals = assignResolveModuleNameLiterals;
+    const projectService = host.projectService;
+    host.getScriptSnapshot = (fileName) => {
+        let record = recordsByVirtualFile.get(fileName);
+        if (!record) {
+            const parsed = parsePreviewUri(fileName);
+            if (parsed) {
+                if ("virtualPath" in parsed) {
+                    record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+                }
+                else {
+                    const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+                    if (resolved.status === "resolved")
+                        record = resolved.record;
+                }
+            }
+        }
+        if (!record) {
+            return originalGetScriptSnapshot?.(fileName);
+        }
+        const freshRecord = rebuildRecordIfNeeded(record);
+        let sourceToServe = freshRecord.sourceText;
+        const isNodeModulesPath = fileName.includes(VIRTUAL_NODE_MODULES_RELATIVE);
+        if (isNodeModulesPath) {
+            sourceToServe = rewriteSourceForPreviewLocation(freshRecord.sourceText, freshRecord.importer, fileName);
+            materializeVirtualFile(fileName, freshRecord.importer, freshRecord.sourceText);
+        }
+        // In tsserver, setDocument(key, path, sourceFile) requires a ScriptInfo for path (Debug.checkDefined(getScriptInfoForPath(path))).
+        // If we never register the virtual file, createProgram → acquireOrUpdateDocument → setDocument throws "Debug Failure".
+        // So when projectService exists (tsserver), always register the virtual file so setDocument can find it.
+        if (projectService?.getOrCreateOpenScriptInfo) {
+            projectService.getOrCreateOpenScriptInfo(fileName, sourceToServe, options.ts.ScriptKind.TS, false, options.projectRoot);
+        }
+        return options.ts.ScriptSnapshot.fromString(sourceToServe);
+    };
+    if (originalGetScriptVersion) {
+        host.getScriptVersion = (fileName) => {
+            let record = recordsByVirtualFile.get(fileName);
+            if (!record) {
+                const parsed = parsePreviewUri(fileName);
+                if (parsed) {
+                    if ("virtualPath" in parsed) {
+                        record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+                    }
+                    else {
+                        const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+                        if (resolved.status === "resolved")
+                            record = resolved.record;
+                    }
+                }
+            }
+            if (!record)
+                return originalGetScriptVersion(fileName);
+            return String(record.version);
+        };
+    }
+    if (originalGetProjectVersion) {
+        host.getProjectVersion = () => `${originalGetProjectVersion()}:vm:${epoch}`;
+    }
+    if (originalGetScriptFileNames) {
+        host.getScriptFileNames = () => {
+            const files = originalGetScriptFileNames();
+            const virtualFiles = [...recordsByVirtualFile.keys()];
+            return [...new Set([...files, ...virtualFiles])];
+        };
+    }
+    host.fileExists = (path) => {
+        if (recordsByVirtualFile.has(path))
+            return true;
+        const parsed = parsePreviewUri(path);
+        if (parsed) {
+            if ("virtualPath" in parsed) {
+                if (recordsByVirtualFile.has(parsed.virtualPath))
+                    return true;
+            }
+            else {
+                const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+                if (resolved.status === "resolved")
+                    return true;
+            }
+        }
+        return originalFileExists ? originalFileExists(path) : false;
+    };
+    host.readFile = (path) => {
+        let record = recordsByVirtualFile.get(path);
+        if (!record) {
+            const parsed = parsePreviewUri(path);
+            if (parsed) {
+                if ("virtualPath" in parsed) {
+                    record = recordsByVirtualFile.get(parsed.virtualPath) ?? undefined;
+                }
+                else {
+                    const resolved = getOrBuildRecord(parsed.id, parsed.importer);
+                    if (resolved.status === "resolved")
+                        record = resolved.record;
+                }
+            }
+        }
+        if (record)
+            return rebuildRecordIfNeeded(record).sourceText;
+        return originalReadFile?.(path);
+    };
+    options.languageService.getSemanticDiagnostics = (fileName) => {
+        const diagnostics = originalGetSemanticDiagnostics(fileName);
+        const adapterDiagnostics = diagnosticsByFile.get(fileName);
+        if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+            return [...diagnostics];
+        }
+        return [...diagnostics, ...adapterDiagnostics];
+    };
+    options.languageService.getSyntacticDiagnostics = (fileName) => {
+        const diagnostics = originalGetSyntacticDiagnostics(fileName);
+        const adapterDiagnostics = diagnosticsByFile.get(fileName);
+        if (!adapterDiagnostics || adapterDiagnostics.length === 0) {
+            return [...diagnostics];
+        }
+        const withLocation = adapterDiagnostics.filter((d) => d.file !== undefined);
+        return [...diagnostics, ...withLocation];
+    };
+    return {
+        dispose() {
+            for (const [virtualPath] of recordsByVirtualFile) {
+                if (virtualPath.includes(VIRTUAL_NODE_MODULES_RELATIVE)) {
+                    try {
+                        unlinkSync(virtualPath);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+            host.resolveModuleNameLiterals =
+                originalResolveModuleNameLiterals;
+            host.resolveModuleNames = originalResolveModuleNames;
+            if (originalGetScriptSnapshot) {
+                host.getScriptSnapshot = originalGetScriptSnapshot;
+            }
+            if (originalGetScriptVersion) {
+                host.getScriptVersion = originalGetScriptVersion;
+            }
+            if (originalGetProjectVersion) {
+                host.getProjectVersion = originalGetProjectVersion;
+            }
+            if (originalGetScriptFileNames) {
+                host.getScriptFileNames = originalGetScriptFileNames;
+            }
+            if (originalFileExists) {
+                host.fileExists = originalFileExists;
+            }
+            if (originalReadFile) {
+                host.readFile = originalReadFile;
+            }
+            options.languageService.getSemanticDiagnostics = originalGetSemanticDiagnostics;
+            options.languageService.getSyntacticDiagnostics = originalGetSyntacticDiagnostics;
+            store.dispose();
+            diagnosticsByFile.clear();
+        },
+    };
+};

package/dist/LanguageServiceSession.d.ts

@@ -0,0 +1,16 @@
+import type { CreateTypeInfoApiSession, TypeTargetSpec } from "./types.js";
+export interface CreateLanguageServiceSessionFactoryOptions {
+    readonly ts: typeof import("typescript");
+    readonly projectRoot: string;
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+    readonly tsconfigPath?: string;
+}
+/**
+ * Creates a LanguageService-backed CreateTypeInfoApiSession factory.
+ * Use when you need type-aware virtual module resolution with a program that
+ * evolves as files change (e.g. Vite dev server, standalone tooling).
+ *
+ * Returns undefined if tsconfig cannot be found or parsed.
+ */
+export declare function createLanguageServiceSessionFactory(options: CreateLanguageServiceSessionFactoryOptions): CreateTypeInfoApiSession | undefined;
+//# sourceMappingURL=LanguageServiceSession.d.ts.map

package/dist/LanguageServiceSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LanguageServiceSession.d.ts","sourceRoot":"","sources":["../src/LanguageServiceSession.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,wBAAwB,EAAsB,cAAc,EAAE,MAAM,YAAY,CAAC;AAqB/F,MAAM,WAAW,0CAA0C;IACzD,QAAQ,CAAC,EAAE,EAAE,cAAc,YAAY,CAAC,CAAC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IACrD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;GAMG;AACH,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,0CAA0C,GAClD,wBAAwB,GAAG,SAAS,CAkHtC"}

package/dist/LanguageServiceSession.js

@@ -0,0 +1,122 @@
+/**
+ * Creates a CreateTypeInfoApiSession factory backed by a TypeScript Language Service.
+ * The program evolves over time as files change (via getModifiedTime versioning),
+ * so type-aware virtual module builds stay current during development.
+ */
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createTypeInfoApiSession } from "./TypeInfoApi.js";
+import { ensureTypeTargetBootstrapFile, getProgramWithTypeTargetBootstrap, getTypeTargetBootstrapPath, } from "./typeTargetBootstrap.js";
+function findTsconfig(fromDir) {
+    let dir = resolve(fromDir);
+    const root = resolve(dir, "/");
+    while (dir !== root) {
+        const candidate = join(dir, "tsconfig.json");
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+/**
+ * Creates a LanguageService-backed CreateTypeInfoApiSession factory.
+ * Use when you need type-aware virtual module resolution with a program that
+ * evolves as files change (e.g. Vite dev server, standalone tooling).
+ *
+ * Returns undefined if tsconfig cannot be found or parsed.
+ */
+export function createLanguageServiceSessionFactory(options) {
+    const { ts, projectRoot, typeTargetSpecs, tsconfigPath: explicitTsconfigPath } = options;
+    const tsconfigPath = explicitTsconfigPath ?? findTsconfig(projectRoot);
+    if (!tsconfigPath)
+        return undefined;
+    let parsed;
+    try {
+        // oxlint-disable-next-line typescript/unbound-method
+        const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+        if (configFile.error)
+            return undefined;
+        const configDir = dirname(tsconfigPath);
+        parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configDir, undefined, tsconfigPath);
+        if (parsed.errors.length > 0)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    let rootNames = parsed.fileNames;
+    if (typeTargetSpecs && typeTargetSpecs.length > 0) {
+        ensureTypeTargetBootstrapFile(projectRoot, typeTargetSpecs);
+        const bootstrapPath = getTypeTargetBootstrapPath(projectRoot);
+        rootNames = [...rootNames, bootstrapPath];
+    }
+    const sys = ts.sys;
+    const compilerOptions = parsed.options;
+    const host = {
+        getCompilationSettings: () => compilerOptions,
+        getScriptFileNames: () => rootNames,
+        getScriptVersion: (fileName) => {
+            const mtime = sys.getModifiedTime?.(fileName);
+            return mtime ? String(mtime.getTime()) : "0";
+        },
+        getScriptSnapshot: (fileName) => {
+            if (!sys.fileExists(fileName))
+                return undefined;
+            const content = sys.readFile(fileName);
+            return content !== undefined ? ts.ScriptSnapshot.fromString(content) : undefined;
+        },
+        getCurrentDirectory: () => dirname(tsconfigPath),
+        getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+        directoryExists: sys.directoryExists?.bind(sys),
+        fileExists: sys.fileExists?.bind(sys),
+        readFile: sys.readFile?.bind(sys),
+        readDirectory: sys.readDirectory?.bind(sys),
+    };
+    const languageService = ts.createLanguageService(host);
+    const createTypeInfoApiSessionFn = ({ id: _id, importer: _importer, }) => {
+        let session = null;
+        let apiUsed = false;
+        const getSession = () => {
+            if (session)
+                return session;
+            const program = languageService.getProgram();
+            if (!program) {
+                throw new Error("TypeInfo session creation failed: Program not yet available from Language Service. Retry when project is loaded.");
+            }
+            const programWithBootstrap = getProgramWithTypeTargetBootstrap(ts, program, projectRoot, typeTargetSpecs);
+            session = createTypeInfoApiSession({
+                ts,
+                program: programWithBootstrap,
+                ...(typeTargetSpecs && typeTargetSpecs.length > 0
+                    ? { typeTargetSpecs, failWhenNoTargetsResolved: false }
+                    : {}),
+            });
+            return session;
+        };
+        return {
+            api: {
+                file: (path, opts) => {
+                    apiUsed = true;
+                    return getSession().api.file(path, opts);
+                },
+                directory: (glob, opts) => {
+                    apiUsed = true;
+                    return getSession().api.directory(glob, opts);
+                },
+                resolveExport: (baseDir, filePath, exportName) => {
+                    apiUsed = true;
+                    return getSession().api.resolveExport(baseDir, filePath, exportName);
+                },
+                isAssignableTo: (node, targetId, projection) => {
+                    apiUsed = true;
+                    return getSession().api.isAssignableTo(node, targetId, projection);
+                },
+            },
+            consumeDependencies: () => (apiUsed ? getSession().consumeDependencies() : []),
+        };
+    };
+    return createTypeInfoApiSessionFn;
+}

package/dist/NodeModulePluginLoader.d.ts

@@ -0,0 +1,8 @@
+import type { NodeModulePluginLoadInput, NodeModulePluginLoadResult } from "./types.js";
+export type { NodeModulePluginLoadInput };
+export declare class NodeModulePluginLoader {
+    #private;
+    load(input: NodeModulePluginLoadInput): NodeModulePluginLoadResult;
+    loadMany(inputs: readonly NodeModulePluginLoadInput[]): readonly NodeModulePluginLoadResult[];
+}
+//# sourceMappingURL=NodeModulePluginLoader.d.ts.map

package/dist/NodeModulePluginLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeModulePluginLoader.d.ts","sourceRoot":"","sources":["../src/NodeModulePluginLoader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,yBAAyB,EACzB,0BAA0B,EAG3B,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAmF1C,qBAAa,sBAAsB;;IACjC,IAAI,CAAC,KAAK,EAAE,yBAAyB,GAAG,0BAA0B;IAwFlE,QAAQ,CAAC,MAAM,EAAE,SAAS,yBAAyB,EAAE,GAAG,SAAS,0BAA0B,EAAE;CAoF9F"}