@typed/virtual-modules 1.0.0-beta.1

package/dist/VmcConfigLoader.d.ts

@@ -0,0 +1,31 @@
+import type { VirtualModulePlugin, VirtualModuleResolver } from "./types.js";
+export type VmcPluginEntry = VirtualModulePlugin | string;
+export interface VmcConfig {
+    readonly resolver?: VirtualModuleResolver;
+    readonly plugins?: readonly VmcPluginEntry[];
+}
+export interface LoadVmcConfigOptions {
+    readonly projectRoot: string;
+    /**
+     * TypeScript module used to transpile vmc.config.ts on the fly.
+     * Required only when loading .ts configs.
+     */
+    readonly ts?: typeof import("typescript");
+    /**
+     * Optional explicit config file path (absolute or relative to projectRoot).
+     */
+    readonly configPath?: string;
+}
+export type LoadVmcConfigResult = {
+    readonly status: "not-found";
+} | {
+    readonly status: "loaded";
+    readonly path: string;
+    readonly config: VmcConfig;
+} | {
+    readonly status: "error";
+    readonly path?: string;
+    readonly message: string;
+};
+export declare function loadVmcConfig(options: LoadVmcConfigOptions): LoadVmcConfigResult;
+//# sourceMappingURL=VmcConfigLoader.d.ts.map

package/dist/VmcConfigLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VmcConfigLoader.d.ts","sourceRoot":"","sources":["../src/VmcConfigLoader.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,MAAM,cAAc,GAAG,mBAAmB,GAAG,MAAM,CAAC;AAE1D,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,cAAc,YAAY,CAAC,CAAC;IAC1C;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GAChF;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AA4MnF,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CA0DhF"}

package/dist/VmcConfigLoader.js

@@ -0,0 +1,231 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { runInThisContext } from "node:vm";
+import { pathIsUnderBase, resolvePathUnderBase } from "./internal/path.js";
+import { sanitizeErrorMessage } from "./internal/sanitize.js";
+import { validatePathSegment } from "./internal/validation.js";
+const VMC_CONFIG_NAMES = ["vmc.config.ts"];
+const toMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+};
+const isPluginLike = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.name === "string" &&
+        typeof candidate.shouldResolve === "function" &&
+        typeof candidate.build === "function");
+};
+const isResolverLike = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    return typeof value.resolveModule === "function";
+};
+const normalizePluginEntries = (value) => {
+    if (value === undefined)
+        return { ok: true, plugins: [] };
+    if (!Array.isArray(value))
+        return { ok: false };
+    const plugins = [];
+    for (const entry of value) {
+        if (typeof entry === "string" && entry.trim().length > 0) {
+            plugins.push(entry.trim());
+            continue;
+        }
+        if (isPluginLike(entry)) {
+            plugins.push(entry);
+            continue;
+        }
+        return { ok: false };
+    }
+    return { ok: true, plugins };
+};
+function validateProjectRoot(projectRoot) {
+    const projectRootResult = validatePathSegment(projectRoot, "projectRoot");
+    if (!projectRootResult.ok) {
+        return {
+            status: "error",
+            message: projectRootResult.reason,
+        };
+    }
+    const resolvedProjectRoot = resolve(projectRootResult.value);
+    if (!existsSync(resolvedProjectRoot)) {
+        return {
+            status: "error",
+            path: resolvedProjectRoot,
+            message: `projectRoot does not exist: ${resolvedProjectRoot}`,
+        };
+    }
+    if (!statSync(resolvedProjectRoot).isDirectory()) {
+        return {
+            status: "error",
+            path: resolvedProjectRoot,
+            message: `projectRoot must be a directory: ${resolvedProjectRoot}`,
+        };
+    }
+    return resolvedProjectRoot;
+}
+function resolveConfigPath(projectRoot, configPath) {
+    if (configPath !== undefined) {
+        const configPathResult = validatePathSegment(configPath, "configPath");
+        if (!configPathResult.ok) {
+            return {
+                status: "error",
+                message: configPathResult.reason,
+            };
+        }
+        const configPathValue = configPathResult.value;
+        if (!configPathValue.endsWith(".ts")) {
+            return {
+                status: "error",
+                message: `configPath must point to a .ts file: ${configPathValue}`,
+            };
+        }
+        const resolvedPath = resolve(projectRoot, configPathValue);
+        const underBase = resolvePathUnderBase(projectRoot, configPathValue);
+        if (!underBase.ok || resolve(underBase.path) !== resolvedPath) {
+            return {
+                status: "error",
+                message: `vmc config path escapes project root: ${configPathValue}`,
+            };
+        }
+        if (!existsSync(resolvedPath)) {
+            return {
+                status: "error",
+                path: resolvedPath,
+                message: `vmc config not found: ${resolvedPath}`,
+            };
+        }
+        if (!statSync(resolvedPath).isFile()) {
+            return {
+                status: "error",
+                path: resolvedPath,
+                message: `vmc config path must point to a file: ${resolvedPath}`,
+            };
+        }
+        if (!pathIsUnderBase(projectRoot, resolvedPath)) {
+            return {
+                status: "error",
+                path: resolvedPath,
+                message: `vmc config path is outside project root after resolving symlinks: ${resolvedPath}`,
+            };
+        }
+        return resolvedPath;
+    }
+    for (const name of VMC_CONFIG_NAMES) {
+        const candidate = join(projectRoot, name);
+        if (!existsSync(candidate))
+            continue;
+        if (!statSync(candidate).isFile())
+            continue;
+        if (!pathIsUnderBase(projectRoot, candidate)) {
+            return {
+                status: "error",
+                path: candidate,
+                message: `vmc config is outside project root after resolving symlinks: ${candidate}`,
+            };
+        }
+        return candidate;
+    }
+    return { status: "not-found" };
+}
+function loadTsConfigModule(tsMod, configPath) {
+    // vmc config is executable project code.
+    const sourceText = readFileSync(configPath, "utf8");
+    const transpiled = tsMod.transpileModule(sourceText, {
+        fileName: configPath,
+        compilerOptions: {
+            module: tsMod.ModuleKind.CommonJS,
+            target: tsMod.ScriptTarget.ES2020,
+            moduleResolution: tsMod.ModuleResolutionKind.NodeNext,
+            esModuleInterop: true,
+        },
+        reportDiagnostics: false,
+    }).outputText;
+    const localRequire = createRequire(configPath);
+    const module = { exports: {} };
+    const evaluate = runInThisContext(`(function (exports, require, module, __filename, __dirname) {${transpiled}\n})`, { filename: configPath });
+    evaluate(module.exports, localRequire, module, configPath, dirname(configPath));
+    return module.exports;
+}
+function normalizeConfigModule(loadedModule) {
+    const withDefault = loadedModule && typeof loadedModule === "object" && "default" in loadedModule
+        ? loadedModule.default
+        : loadedModule;
+    if (!withDefault || typeof withDefault !== "object") {
+        return { ok: false };
+    }
+    const candidate = withDefault;
+    if (candidate.resolver !== undefined && !isResolverLike(candidate.resolver)) {
+        return { ok: false };
+    }
+    const normalizedPlugins = normalizePluginEntries(candidate.plugins);
+    if (!normalizedPlugins.ok) {
+        return { ok: false };
+    }
+    return {
+        ok: true,
+        config: {
+            ...(candidate.resolver !== undefined
+                ? { resolver: candidate.resolver }
+                : {}),
+            ...(normalizedPlugins.plugins.length > 0 ? { plugins: normalizedPlugins.plugins } : {}),
+        },
+    };
+}
+export function loadVmcConfig(options) {
+    let attemptedPath;
+    try {
+        const projectRootOrStatus = validateProjectRoot(options.projectRoot);
+        if (typeof projectRootOrStatus !== "string")
+            return projectRootOrStatus;
+        const projectRoot = projectRootOrStatus;
+        const resolvedPathOrStatus = resolveConfigPath(projectRoot, options.configPath);
+        if (typeof resolvedPathOrStatus !== "string")
+            return resolvedPathOrStatus;
+        const resolvedPath = resolvedPathOrStatus;
+        attemptedPath = resolvedPath;
+        const loadedModule = resolvedPath.endsWith(".ts")
+            ? (() => {
+                if (!options.ts) {
+                    return {
+                        __vmcConfigLoaderError: "TypeScript module is required to load vmc.config.ts",
+                    };
+                }
+                return loadTsConfigModule(options.ts, resolvedPath);
+            })()
+            : createRequire(resolvedPath)(resolvedPath);
+        if (loadedModule &&
+            typeof loadedModule === "object" &&
+            "__vmcConfigLoaderError" in loadedModule) {
+            return {
+                status: "error",
+                path: resolvedPath,
+                message: loadedModule.__vmcConfigLoaderError,
+            };
+        }
+        const normalized = normalizeConfigModule(loadedModule);
+        if (!normalized.ok) {
+            return {
+                status: "error",
+                path: resolvedPath,
+                message: `Invalid vmc config export in ${resolvedPath}`,
+            };
+        }
+        return {
+            status: "loaded",
+            path: resolvedPath,
+            config: normalized.config,
+        };
+    }
+    catch (error) {
+        return {
+            status: "error",
+            ...(attemptedPath ? { path: attemptedPath } : {}),
+            message: sanitizeErrorMessage(`Failed to load vmc config${attemptedPath ? ` "${attemptedPath}"` : ""}: ${toMessage(error)}`),
+        };
+    }
+}

package/dist/VmcResolverLoader.d.ts

@@ -0,0 +1,30 @@
+import type { VmcPluginEntry } from "./VmcConfigLoader.js";
+import type { NodeModulePluginLoadError, TypeTargetSpec, VirtualModulePlugin, VirtualModuleResolver } from "./types.js";
+export interface LoadPluginsFromEntriesResult {
+    readonly plugins: readonly VirtualModulePlugin[];
+    readonly pluginSpecifiers: readonly string[];
+    readonly errors: readonly NodeModulePluginLoadError[];
+}
+export declare function loadPluginsFromEntries(entries: readonly VmcPluginEntry[], baseDir: string): LoadPluginsFromEntriesResult;
+export type LoadResolverFromVmcConfigResult = {
+    readonly status: "not-found";
+} | {
+    readonly status: "error";
+    readonly path?: string;
+    readonly message: string;
+} | {
+    readonly status: "loaded";
+    readonly path: string;
+    readonly resolver?: VirtualModuleResolver;
+    readonly pluginSpecifiers: readonly string[];
+    readonly pluginLoadErrors: readonly NodeModulePluginLoadError[];
+    /** Type target specs from config for structural assignability in TypeInfo API. */
+    readonly typeTargetSpecs?: readonly TypeTargetSpec[];
+};
+export interface LoadResolverFromVmcConfigOptions {
+    readonly projectRoot: string;
+    readonly ts: typeof import("typescript");
+    readonly configPath?: string;
+}
+export declare function loadResolverFromVmcConfig(options: LoadResolverFromVmcConfigOptions): LoadResolverFromVmcConfigResult;
+//# sourceMappingURL=VmcResolverLoader.d.ts.map

package/dist/VmcResolverLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VmcResolverLoader.d.ts","sourceRoot":"","sources":["../src/VmcResolverLoader.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EACV,yBAAyB,EACzB,cAAc,EACd,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AASpB,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACjD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,SAAS,yBAAyB,EAAE,CAAC;CACvD;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,OAAO,EAAE,MAAM,GACd,4BAA4B,CA0B9B;AAED,MAAM,MAAM,+BAA+B,GACvC;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC9E;IACE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IAC1C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAChE,kFAAkF;IAClF,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACtD,CAAC;AAEN,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,EAAE,cAAc,YAAY,CAAC,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,+BAA+B,CAqCjC"}

package/dist/VmcResolverLoader.js

@@ -0,0 +1,71 @@
+import { dirname } from "node:path";
+import { collectTypeTargetSpecsFromPlugins } from "./collectTypeTargetSpecs.js";
+import { NodeModulePluginLoader } from "./NodeModulePluginLoader.js";
+import { PluginManager } from "./PluginManager.js";
+import { loadVmcConfig } from "./VmcConfigLoader.js";
+function collectFromResolver(resolver) {
+    const pm = resolver;
+    if (!Array.isArray(pm.plugins) || pm.plugins.length === 0)
+        return undefined;
+    const merged = collectTypeTargetSpecsFromPlugins(pm.plugins);
+    return merged.length > 0 ? merged : undefined;
+}
+export function loadPluginsFromEntries(entries, baseDir) {
+    const loader = new NodeModulePluginLoader();
+    const plugins = [];
+    const pluginSpecifiers = [];
+    const errors = [];
+    for (const entry of entries) {
+        if (typeof entry === "string") {
+            pluginSpecifiers.push(entry);
+            const loaded = loader.load({ specifier: entry, baseDir });
+            if (loaded.status === "loaded") {
+                plugins.push(loaded.plugin);
+            }
+            else {
+                errors.push(loaded);
+            }
+            continue;
+        }
+        plugins.push(entry);
+    }
+    return {
+        plugins,
+        pluginSpecifiers,
+        errors,
+    };
+}
+export function loadResolverFromVmcConfig(options) {
+    const loadedVmcConfig = loadVmcConfig(options);
+    if (loadedVmcConfig.status === "not-found") {
+        return loadedVmcConfig;
+    }
+    if (loadedVmcConfig.status === "error") {
+        return loadedVmcConfig;
+    }
+    const vmcPlugins = loadedVmcConfig.config.plugins ?? [];
+    const pluginSpecifiers = vmcPlugins.filter((entry) => typeof entry === "string");
+    if (loadedVmcConfig.config.resolver) {
+        const resolver = loadedVmcConfig.config.resolver;
+        const typeTargetSpecs = collectFromResolver(resolver);
+        return {
+            status: "loaded",
+            path: loadedVmcConfig.path,
+            resolver,
+            pluginSpecifiers,
+            pluginLoadErrors: [],
+            ...(typeTargetSpecs ? { typeTargetSpecs } : {}),
+        };
+    }
+    const loadedPlugins = loadPluginsFromEntries(vmcPlugins, dirname(loadedVmcConfig.path));
+    const resolver = loadedPlugins.plugins.length > 0 ? new PluginManager(loadedPlugins.plugins) : undefined;
+    const typeTargetSpecs = resolver ? collectFromResolver(resolver) : undefined;
+    return {
+        status: "loaded",
+        path: loadedVmcConfig.path,
+        ...(resolver ? { resolver } : {}),
+        pluginSpecifiers: loadedPlugins.pluginSpecifiers,
+        pluginLoadErrors: loadedPlugins.errors,
+        ...(typeTargetSpecs ? { typeTargetSpecs } : {}),
+    };
+}

package/dist/collectTypeTargetSpecs.d.ts

@@ -0,0 +1,6 @@
+import type { TypeTargetSpec, VirtualModulePlugin } from "./types.js";
+/**
+ * Collects and merges typeTargetSpecs from plugins. Dedupes by id (first wins).
+ */
+export declare function collectTypeTargetSpecsFromPlugins(plugins: readonly VirtualModulePlugin[]): readonly TypeTargetSpec[];
+//# sourceMappingURL=collectTypeTargetSpecs.d.ts.map

package/dist/collectTypeTargetSpecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectTypeTargetSpecs.d.ts","sourceRoot":"","sources":["../src/collectTypeTargetSpecs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtE;;GAEG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,SAAS,cAAc,EAAE,CAc3B"}

package/dist/collectTypeTargetSpecs.js

@@ -0,0 +1,19 @@
+/**
+ * Collects and merges typeTargetSpecs from plugins. Dedupes by id (first wins).
+ */
+export function collectTypeTargetSpecsFromPlugins(plugins) {
+    const seen = new Set();
+    const result = [];
+    for (const plugin of plugins) {
+        const specs = plugin.typeTargetSpecs;
+        if (!specs?.length)
+            continue;
+        for (const spec of specs) {
+            if (!seen.has(spec.id)) {
+                seen.add(spec.id);
+                result.push(spec);
+            }
+        }
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./types.js";
+export * from "./PluginManager.js";
+export { collectTypeTargetSpecsFromPlugins } from "./collectTypeTargetSpecs.js";
+export { createTypeInfoApiSession, createTypeInfoApiSessionFactory, createTypeTargetBootstrapContent, resolveTypeTargetsFromSpecs, type CreateTypeInfoApiSessionOptions, type ResolvedTypeTarget, } from "./TypeInfoApi.js";
+export * from "./NodeModulePluginLoader.js";
+export * from "./LanguageServiceAdapter.js";
+export * from "./CompilerHostAdapter.js";
+export * from "./VmcConfigLoader.js";
+export * from "./VmcResolverLoader.js";
+export { createVirtualFileName, createVirtualKey, VIRTUAL_MODULE_URI_SCHEME, VIRTUAL_NODE_MODULES_RELATIVE, type CreateVirtualFileNameParams, type CreateVirtualFileNameOptions, } from "./internal/path.js";
+export { ensureTypeTargetBootstrapFile, getProgramWithTypeTargetBootstrap, getTypeTargetBootstrapPath, TYPE_TARGET_BOOTSTRAP_RELATIVE, type EnsureTypeTargetBootstrapFileFs, } from "./typeTargetBootstrap.js";
+export { createLanguageServiceSessionFactory, type CreateLanguageServiceSessionFactoryOptions, } from "./LanguageServiceSession.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,iCAAiC,EAAE,MAAM,6BAA6B,CAAC;AAChF,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,gCAAgC,EAChC,2BAA2B,EAC3B,KAAK,+BAA+B,EACpC,KAAK,kBAAkB,GACxB,MAAM,kBAAkB,CAAC;AAC1B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,OAAO,EACL,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,6BAA6B,EAC7B,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,GAClC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,6BAA6B,EAC7B,iCAAiC,EACjC,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,+BAA+B,GACrC,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,mCAAmC,EACnC,KAAK,0CAA0C,GAChD,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from "./types.js";
+export * from "./PluginManager.js";
+export { collectTypeTargetSpecsFromPlugins } from "./collectTypeTargetSpecs.js";
+export { createTypeInfoApiSession, createTypeInfoApiSessionFactory, createTypeTargetBootstrapContent, resolveTypeTargetsFromSpecs, } from "./TypeInfoApi.js";
+export * from "./NodeModulePluginLoader.js";
+export * from "./LanguageServiceAdapter.js";
+export * from "./CompilerHostAdapter.js";
+export * from "./VmcConfigLoader.js";
+export * from "./VmcResolverLoader.js";
+export { createVirtualFileName, createVirtualKey, VIRTUAL_MODULE_URI_SCHEME, VIRTUAL_NODE_MODULES_RELATIVE, } from "./internal/path.js";
+export { ensureTypeTargetBootstrapFile, getProgramWithTypeTargetBootstrap, getTypeTargetBootstrapPath, TYPE_TARGET_BOOTSTRAP_RELATIVE, } from "./typeTargetBootstrap.js";
+export { createLanguageServiceSessionFactory, } from "./LanguageServiceSession.js";

package/dist/internal/VirtualRecordStore.d.ts

@@ -0,0 +1,60 @@
+import type * as ts from "typescript";
+import type { ResolveVirtualModuleOptions, VirtualModuleDiagnostic, VirtualModuleRecord, VirtualModuleResolution } from "../types.js";
+export type MutableVirtualRecord = Omit<VirtualModuleRecord, "version" | "stale"> & {
+    version: number;
+    stale: boolean;
+};
+export interface ResolveRecordResultResolved {
+    readonly status: "resolved";
+    readonly record: MutableVirtualRecord;
+}
+export interface ResolveRecordResultUnresolved {
+    readonly status: "unresolved";
+}
+export interface ResolveRecordResultError {
+    readonly status: "error";
+    readonly diagnostic: VirtualModuleDiagnostic;
+}
+export type ResolveRecordResult = ResolveRecordResultResolved | ResolveRecordResultUnresolved | ResolveRecordResultError;
+export interface VirtualRecordStoreOptions {
+    readonly projectRoot: string;
+    readonly resolver: {
+        resolveModule(options: ResolveVirtualModuleOptions): VirtualModuleResolution;
+    };
+    readonly createTypeInfoApiSession?: ResolveVirtualModuleOptions["createTypeInfoApiSession"];
+    readonly debounceMs?: number;
+    readonly watchHost?: {
+        watchFile?(path: string, callback: () => void): ts.FileWatcher;
+        watchDirectory?(path: string, callback: () => void, recursive?: boolean): ts.FileWatcher;
+    };
+    /** Used by evictStaleImporters: records for which this returns true are evicted. */
+    readonly shouldEvictRecord: (record: MutableVirtualRecord) => boolean;
+    /** Called when flushPendingStale runs (after debounce). LS uses for epoch++. */
+    readonly onFlushStale?: () => void;
+    /** Called when a record is marked stale (immediate or after flush). CH uses for invalidatedPaths. */
+    readonly onMarkStale?: (record: MutableVirtualRecord) => void;
+    /** Called at start of resolveRecord (e.g. LS sets inResolveRecord). */
+    readonly onBeforeResolve?: () => void;
+    /** Called in finally after resolveRecord (e.g. LS clears inResolveRecord). */
+    readonly onAfterResolve?: () => void;
+    /** Called after a record is stored and watchers registered (e.g. LS clears diagnostics for importer). */
+    readonly onRecordResolved?: (record: MutableVirtualRecord) => void;
+    /** Called when a record is evicted (e.g. LS clears diagnostics for importer). */
+    readonly onEvictRecord?: (record: MutableVirtualRecord) => void;
+}
+export declare function toResolvedModule(tsMod: typeof import("typescript"), fileName: string): ts.ResolvedModuleFull;
+export declare function createVirtualRecordStore(options: VirtualRecordStoreOptions): {
+    recordsByKey: Map<string, MutableVirtualRecord>;
+    recordsByVirtualFile: Map<string, MutableVirtualRecord>;
+    descriptorToVirtualKeys: Map<string, Set<string>>;
+    watcherByDescriptor: Map<string, ts.FileWatcher>;
+    evictRecord: (record: MutableVirtualRecord) => void;
+    evictStaleImporters: () => void;
+    registerWatchers: (record: MutableVirtualRecord) => void;
+    markStale: (descriptorKey: string) => void;
+    flushPendingStale: () => void;
+    resolveRecord: (id: string, importer: string, previous?: MutableVirtualRecord) => ResolveRecordResult;
+    getOrBuildRecord: (id: string, importer: string) => ResolveRecordResult;
+    dispose: () => void;
+};
+//# sourceMappingURL=VirtualRecordStore.d.ts.map

package/dist/internal/VirtualRecordStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualRecordStore.d.ts","sourceRoot":"","sources":["../../src/internal/VirtualRecordStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,OAAO,CAAC,GAAG;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,uBAAuB,CAAC;CAC9C;AAED,MAAM,MAAM,mBAAmB,GAC3B,2BAA2B,GAC3B,6BAA6B,GAC7B,wBAAwB,CAAC;AAE7B,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE;QACjB,aAAa,CAAC,OAAO,EAAE,2BAA2B,GAAG,uBAAuB,CAAC;KAC9E,CAAC;IACF,QAAQ,CAAC,wBAAwB,CAAC,EAAE,2BAA2B,CAAC,0BAA0B,CAAC,CAAC;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE;QACnB,SAAS,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC;QAC/D,cAAc,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC;KAC1F,CAAC;IACF,oFAAoF;IACpF,QAAQ,CAAC,iBAAiB,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC;IACtE,gFAAgF;IAChF,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IACnC,qGAAqG;IACrG,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC9D,uEAAuE;IACvE,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;IACrC,yGAAyG;IACzG,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnE,iFAAiF;IACjF,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACjE;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,YAAY,CAAC,EAClC,QAAQ,EAAE,MAAM,GACf,EAAE,CAAC,kBAAkB,CAMvB;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB;;;;;0BAoB5C,oBAAoB,KAAG,IAAI;+BAqBxB,IAAI;+BAYF,oBAAoB,KAAG,IAAI;+BAmD3B,MAAM,KAAG,IAAI;6BAtBjB,IAAI;wBAgD5B,MAAM,YACA,MAAM,aACL,oBAAoB,KAC9B,mBAAmB;2BAsDQ,MAAM,YAAY,MAAM,KAAG,mBAAmB;mBAexD,IAAI;EA8BzB"}