@ripple-ts/language-server 0.3.103 → 0.3.105

package/dist/{server-BDTOWnFL.js → server-B91H_hpq.js}

@@ -50,6 +50,8 @@ let path = require("path");
 path = __toESM(path, 1);
 let module$1 = require("module");
 let url = require("url");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
 let _tsrx_core = require("@tsrx/core");
 let node_module = require("node:module");
 let volar_service_css = require("volar-service-css");
@@ -713,6 +715,507 @@ var require_language_core = /* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 }));
 
+//#endregion
+//#region ../typescript-plugin/src/tsconfig-resolution.js
+var import_language_core = require_language_core();
+/**
+* @typedef {object} TsconfigHost
+* @property {(file_name: string) => boolean} fileExists
+* @property {(file_name: string) => string | undefined} readFile
+* @property {import('typescript').ParseConfigHost['readDirectory']} readDirectory
+* @property {boolean | (() => boolean)} useCaseSensitiveFileNames
+* @property {import('typescript').System['getModifiedTime']} [getModifiedTime]
+*/
+/**
+* @typedef {object} TsconfigLayer
+* @property {string} path
+* @property {string} dir
+* @property {Record<string, unknown>} config
+* @property {string | undefined} raw_source
+* @property {import('typescript').Diagnostic[]} parse_diagnostics
+*/
+/** @typedef {TsconfigLayer & { extends_values: unknown[] }} ParsedTsconfigLayer */
+/**
+* @typedef {object} TsconfigExtendsFailure
+* @property {string} config_path
+* @property {unknown} extends_value
+* @property {string | undefined} resolved_path
+* @property {import('typescript').Diagnostic[]} diagnostics
+*/
+/**
+* @typedef {object} ResolvedTsconfigLayers
+* @property {TsconfigLayer[]} layers
+* @property {string[]} dependencies
+* @property {import('typescript').Diagnostic[]} diagnostics
+* @property {TsconfigExtendsFailure[]} extends_failures
+*/
+/**
+* @template TValue
+* @typedef {{state: 'absent'} | {state: 'found', value: TValue}} ConfigValueResult
+*/
+/** @typedef {{config_path: string, config_dir: string}} TsconfigValueOrigin */
+const no_inputs_found_diagnostic_code = 18003;
+const circularity_diagnostic_code = 18e3;
+/**
+* Load a tsconfig and its explicit inheritance graph from lowest to highest
+* precedence. Parsed files are cached, but traversal intentionally does not
+* deduplicate layers because a shared base must be reapplied in every branch.
+*
+* @param {typeof import('typescript')} ts
+* @param {TsconfigHost} host
+* @param {string} config_file_name
+* @returns {ResolvedTsconfigLayers}
+*/
+function load_tsconfig_layers(ts, host, config_file_name) {
+	/** @type {Map<string, ParsedTsconfigLayer>} */
+	const parsed_file_cache = /* @__PURE__ */ new Map();
+	/** @type {TsconfigLayer[]} */
+	const layers = [];
+	/** @type {string[]} */
+	const dependencies = [];
+	const dependency_keys = /* @__PURE__ */ new Set();
+	/** @type {import('typescript').Diagnostic[]} */
+	const diagnostics = [];
+	/** @type {TsconfigExtendsFailure[]} */
+	const extends_failures = [];
+	const diagnostic_keys = /* @__PURE__ */ new Set();
+	const active_stack = /* @__PURE__ */ new Set();
+	const use_case_sensitive_file_names = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
+	/** @type {import('typescript').ParseConfigHost} */
+	const parse_host = {
+		fileExists: host.fileExists,
+		readFile: host.readFile,
+		readDirectory: host.readDirectory,
+		useCaseSensitiveFileNames: use_case_sensitive_file_names
+	};
+	/** @param {string} file_name */
+	function normalize_path(file_name) {
+		return node_path.default.normalize(node_path.default.resolve(file_name));
+	}
+	/** @param {string} file_name */
+	function get_path_key(file_name) {
+		const normalized_path = normalize_path(file_name);
+		return use_case_sensitive_file_names ? normalized_path : normalized_path.toLowerCase();
+	}
+	/** @param {import('typescript').Diagnostic[]} next_diagnostics */
+	function add_diagnostics(next_diagnostics) {
+		for (const diagnostic of next_diagnostics) {
+			const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+			const key = `${diagnostic.code}\0${diagnostic.file?.fileName ?? ""}\0${diagnostic.start ?? ""}\0${message}`;
+			if (!diagnostic_keys.has(key)) {
+				diagnostic_keys.add(key);
+				diagnostics.push(diagnostic);
+			}
+		}
+	}
+	/** @param {string} file_name */
+	function add_dependency(file_name) {
+		const normalized_path = normalize_path(file_name);
+		const key = get_path_key(normalized_path);
+		if (!dependency_keys.has(key)) {
+			dependency_keys.add(key);
+			dependencies.push(normalized_path);
+		}
+	}
+	/**
+	* TypeScript does not expose a failed lookup path for extensionless relative
+	* extends entries. Preserve the conventional JSON candidate so creating it
+	* later invalidates both the mtime cache and the language-server project.
+	* @param {ParsedTsconfigLayer} parsed
+	* @param {unknown} extends_value
+	*/
+	function get_unresolved_relative_dependency(parsed, extends_value) {
+		if (typeof extends_value !== "string" || !node_path.default.isAbsolute(extends_value) && !extends_value.startsWith(".")) return;
+		const candidate_path = node_path.default.resolve(parsed.dir, extends_value);
+		return node_path.default.extname(candidate_path) === "" ? `${candidate_path}.json` : candidate_path;
+	}
+	/** @param {string} file_name */
+	function parse_file(file_name) {
+		const normalized_path = normalize_path(file_name);
+		const key = get_path_key(normalized_path);
+		const cached = parsed_file_cache.get(key);
+		if (cached) return cached;
+		const raw_source = host.readFile(normalized_path);
+		const source_file = ts.readJsonConfigFile(normalized_path, host.readFile);
+		/** @type {import('typescript').Diagnostic[]} */
+		const parse_diagnostics = [...source_file.parseDiagnostics];
+		const converted_config = ts.convertToObject(source_file, parse_diagnostics);
+		const config = converted_config !== null && typeof converted_config === "object" && !Array.isArray(converted_config) ? converted_config : {};
+		const extends_value = config.extends;
+		const extends_values = Array.isArray(extends_value) ? extends_value : extends_value !== void 0 ? [extends_value] : [];
+		const parsed = {
+			path: normalized_path,
+			dir: node_path.default.dirname(normalized_path),
+			config,
+			raw_source,
+			parse_diagnostics,
+			extends_values
+		};
+		parsed_file_cache.set(key, parsed);
+		add_diagnostics(parse_diagnostics);
+		return parsed;
+	}
+	/**
+	* Resolve one immediate extends entry with TypeScript's own config resolver.
+	* A synthetic config isolates the edge; inherited files remain available to
+	* TypeScript so relative, absolute, package, optional-suffix, and cycle
+	* semantics stay aligned with parseJsonSourceFileConfigFileContent.
+	*
+	* @param {ParsedTsconfigLayer} parsed
+	* @param {unknown} extends_value
+	*/
+	function resolve_extends_path(parsed, extends_value) {
+		const synthetic_source = JSON.stringify({
+			extends: extends_value,
+			files: []
+		});
+		const source_file = ts.readJsonConfigFile(parsed.path, () => synthetic_source);
+		const edge_diagnostics = ts.parseJsonSourceFileConfigFileContent(source_file, parse_host, parsed.dir, {}, parsed.path).errors.filter((diagnostic) => diagnostic.code !== no_inputs_found_diagnostic_code);
+		add_diagnostics(edge_diagnostics);
+		const resolved_path = source_file.extendedSourceFiles?.[0];
+		const dependency_path = resolved_path ?? get_unresolved_relative_dependency(parsed, extends_value);
+		if (dependency_path !== void 0) add_dependency(dependency_path);
+		const has_cycle = edge_diagnostics.some((diagnostic) => diagnostic.code === circularity_diagnostic_code);
+		const is_unresolved = resolved_path === void 0 || !host.fileExists(resolved_path);
+		if (is_unresolved || has_cycle) extends_failures.push({
+			config_path: parsed.path,
+			extends_value,
+			resolved_path: dependency_path,
+			diagnostics: edge_diagnostics
+		});
+		return is_unresolved ? void 0 : resolved_path;
+	}
+	/** @param {string} file_name */
+	function visit(file_name) {
+		const normalized_path = normalize_path(file_name);
+		const key = get_path_key(normalized_path);
+		if (active_stack.has(key)) return;
+		active_stack.add(key);
+		add_dependency(normalized_path);
+		const parsed = parse_file(normalized_path);
+		for (const extends_value of parsed.extends_values) {
+			const extended_path = resolve_extends_path(parsed, extends_value);
+			if (extended_path !== void 0) visit(extended_path);
+		}
+		layers.push({
+			path: parsed.path,
+			dir: parsed.dir,
+			config: parsed.config,
+			raw_source: parsed.raw_source,
+			parse_diagnostics: parsed.parse_diagnostics
+		});
+		active_stack.delete(key);
+	}
+	visit(config_file_name);
+	return {
+		layers,
+		dependencies,
+		diagnostics,
+		extends_failures
+	};
+}
+/**
+* Read a nested config value only when every segment is an own property.
+*
+* @param {unknown} config
+* @param {readonly PropertyKey[]} path_parts
+* @returns {ConfigValueResult<unknown>}
+*/
+function get_own_config_value(config, path_parts) {
+	let current = config;
+	for (const path_part of path_parts) {
+		if (current === null || typeof current !== "object" && typeof current !== "function" || !Object.prototype.hasOwnProperty.call(current, path_part)) return { state: "absent" };
+		current = current[path_part];
+	}
+	return {
+		state: "found",
+		value: current
+	};
+}
+/**
+* Resolve a caller-defined value across layers. The last result whose state is
+* not absent wins and is annotated with the config that declared it.
+*
+* @template {{state: string}} TResult
+* @param {readonly TsconfigLayer[]} layers
+* @param {(layer: TsconfigLayer) => TResult} read_layer
+* @returns {{state: 'absent'} | (TResult & TsconfigValueOrigin)}
+*/
+function resolve_inherited_config_value(layers, read_layer) {
+	/** @type {{state: 'absent'} | (TResult & TsconfigValueOrigin)} */
+	let resolved = { state: "absent" };
+	for (const layer of layers) {
+		const value = read_layer(layer);
+		if (value.state !== "absent") resolved = {
+			...value,
+			config_path: layer.path,
+			config_dir: layer.dir
+		};
+	}
+	return resolved;
+}
+
+//#endregion
+//#region ../typescript-plugin/src/consumer-compiler.js
+/** @typedef {{actual_type: string, actual_value: string}} InvalidConfigValueDetails */
+/**
+* @typedef {
+* 	| {state: 'absent'}
+* 	| {state: 'declared', value: string}
+* 	| ({state: 'invalid', target: 'tsrx' | 'compiler'} & InvalidConfigValueDetails)
+* } CompilerDeclaration
+*/
+/**
+* @typedef {object} CompilerResolutionOptions
+* @property {typeof import('typescript')} [ts]
+* @property {string} [configFileName]
+* @property {import('./tsconfig-resolution.js').TsconfigHost} [configHost]
+* @property {Set<string>} [dependencies]
+*/
+/**
+* @typedef {object} ConfigHostResolutionCache
+* @property {Map<string, string | null>} nearest_config_paths
+* @property {Map<string, CachedTsconfigLayers>} resolved_config_layers
+*/
+/**
+* @typedef {object} CachedTsconfigLayers
+* @property {import('./tsconfig-resolution.js').ResolvedTsconfigLayers} value
+* @property {Map<string, number | undefined> | undefined} dependency_modified_times
+*/
+const { log: log$10, logError: logError$5, logWarning: logWarning$1 } = createLogging("[Ripple Language]");
+const bare_package_specifier_pattern = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*(?:\/[A-Za-z0-9][A-Za-z0-9._~-]*)*$/;
+const tsrx_key_pattern = /["']tsrx["']\s*:/;
+/** @type {WeakMap<object, ConfigHostResolutionCache>} */
+let config_host_to_resolution_cache = /* @__PURE__ */ new WeakMap();
+/** @type {Map<string, string | null>} */
+const declared_compiler_path_map = /* @__PURE__ */ new Map();
+/**
+* @param {unknown} value
+* @returns {{ actual_type: string, actual_value: string }}
+*/
+function describe_config_value(value) {
+	return {
+		actual_type: value === null ? "null" : Array.isArray(value) ? "array" : typeof value,
+		actual_value: JSON.stringify(value) ?? String(value)
+	};
+}
+/**
+* Keep filesystem-derived config caches isolated per TypeScript/Volar host.
+* Different hosts can expose different snapshots for the same absolute path.
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+*/
+function get_config_host_cache(host) {
+	let cache = config_host_to_resolution_cache.get(host);
+	if (!cache) {
+		cache = {
+			nearest_config_paths: /* @__PURE__ */ new Map(),
+			resolved_config_layers: /* @__PURE__ */ new Map()
+		};
+		config_host_to_resolution_cache.set(host, cache);
+	}
+	return cache;
+}
+/**
+* @param {string} file_name
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+*/
+function get_config_cache_key(file_name, host) {
+	const normalized_path = path.default.normalize(path.default.resolve(file_name));
+	return (typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames) ? normalized_path : normalized_path.toLowerCase();
+}
+/**
+* @param {unknown} config
+* @returns {CompilerDeclaration}
+*/
+function get_compiler_declaration(config) {
+	const tsrx_result = get_own_config_value(config, ["tsrx"]);
+	if (tsrx_result.state === "absent") return { state: "absent" };
+	const tsrx_value = tsrx_result.value;
+	if (tsrx_value === null || typeof tsrx_value !== "object" || Array.isArray(tsrx_value)) return {
+		state: "invalid",
+		target: "tsrx",
+		...describe_config_value(tsrx_value)
+	};
+	const compiler_result = get_own_config_value(tsrx_value, ["compiler"]);
+	if (compiler_result.state === "absent") return { state: "absent" };
+	const compiler = compiler_result.value;
+	if (typeof compiler === "string" && compiler.trim() !== "") return {
+		state: "declared",
+		value: compiler.trim()
+	};
+	return {
+		state: "invalid",
+		target: "compiler",
+		...describe_config_value(compiler)
+	};
+}
+/**
+* Find the nearest tsconfig.json to use as the root of inheritance resolution.
+* @param {string} start_dir
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+* @param {ConfigHostResolutionCache} cache
+* @returns {string | null}
+*/
+function get_nearest_root_tsconfig(start_dir, host, cache) {
+	let current_dir = start_dir;
+	/** @type {string[]} */
+	const visited_dir_keys = [];
+	while (current_dir) {
+		const current_dir_key = get_config_cache_key(current_dir, host);
+		if (cache.nearest_config_paths.has(current_dir_key)) {
+			const cached_tsconfig = cache.nearest_config_paths.get(current_dir_key) ?? null;
+			for (const visited_dir_key of visited_dir_keys) cache.nearest_config_paths.set(visited_dir_key, cached_tsconfig);
+			return cached_tsconfig;
+		}
+		visited_dir_keys.push(current_dir_key);
+		const tsconfig_path = path.default.join(current_dir, "tsconfig.json");
+		if (host.fileExists(tsconfig_path)) {
+			for (const visited_dir_key of visited_dir_keys) cache.nearest_config_paths.set(visited_dir_key, tsconfig_path);
+			return tsconfig_path;
+		}
+		const parent_dir = path.default.dirname(current_dir);
+		if (parent_dir === current_dir) break;
+		current_dir = parent_dir;
+	}
+	for (const visited_dir_key of visited_dir_keys) cache.nearest_config_paths.set(visited_dir_key, null);
+	return null;
+}
+/**
+* @param {typeof import('typescript')} typescript
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+* @param {string} root_config_path
+* @param {ConfigHostResolutionCache} cache
+*/
+function get_tsconfig_layers(typescript$2, host, root_config_path, cache) {
+	const cache_key = get_config_cache_key(root_config_path, host);
+	const cached = cache.resolved_config_layers.get(cache_key);
+	if (cached && (cached.dependency_modified_times === void 0 || [...cached.dependency_modified_times].every(([dependency, modified_time]) => host.getModifiedTime?.(dependency)?.valueOf() === modified_time))) return cached.value;
+	const value = load_tsconfig_layers(typescript$2, host, root_config_path);
+	const dependency_modified_times = host.getModifiedTime ? new Map(value.dependencies.map((dependency) => [dependency, host.getModifiedTime?.(dependency)?.valueOf()])) : void 0;
+	cache.resolved_config_layers.set(cache_key, {
+		value,
+		dependency_modified_times
+	});
+	return value;
+}
+/**
+* A declaration in the config that owns a failed extends entry, or in a child
+* config above it, has higher precedence than anything the missing base could
+* have declared and therefore makes that failure irrelevant to this value.
+* @param {readonly import('./tsconfig-resolution.js').TsconfigLayer[]} layers
+* @param {import('./tsconfig-resolution.js').TsconfigExtendsFailure} failure
+* @param {string} declaration_config_path
+*/
+function is_extends_failure_overridden(layers, failure, declaration_config_path) {
+	const failure_owner_index = layers.findLastIndex((layer) => layer.path === failure.config_path);
+	const declaration_index = layers.findLastIndex((layer) => layer.path === declaration_config_path);
+	return failure_owner_index >= 0 && declaration_index >= failure_owner_index;
+}
+/**
+* Resolve without a module-resolution cache. This is the recovery path when
+* Node retains a negative package lookup after a dependency is installed.
+* `noDtsResolution` ensures the runtime entry wins over a package's types.
+* @param {typeof import('typescript')} typescript
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+* @param {string} config_path
+* @param {string} specifier
+*/
+function resolve_uncached_declared_compiler(typescript$3, host, config_path, specifier) {
+	return typescript$3.resolveModuleName(specifier, config_path, {
+		module: typescript$3.ModuleKind.Node16,
+		moduleResolution: typescript$3.ModuleResolutionKind.Node16,
+		noDtsResolution: true
+	}, host, void 0, void 0, typescript$3.ModuleKind.CommonJS).resolvedModule?.resolvedFileName;
+}
+/**
+* Resolve the compiler explicitly selected by a consumer tsconfig. Invalid
+* specifiers are stable and cached, while missing packages are retried so
+* tsserver can recover after the dependency is installed.
+* @param {typeof import('typescript')} typescript
+* @param {import('./tsconfig-resolution.js').TsconfigHost} host
+* @param {string} config_path
+* @param {string} specifier
+* @returns {string | null}
+*/
+function resolve_declared_compiler(typescript$4, host, config_path, specifier) {
+	const cache_key = `${config_path}\0${specifier}`;
+	if (declared_compiler_path_map.has(cache_key)) return declared_compiler_path_map.get(cache_key) ?? null;
+	if (!bare_package_specifier_pattern.test(specifier)) {
+		declared_compiler_path_map.set(cache_key, null);
+		logError$5("Declared TSRX compiler must be a bare package specifier:", specifier, `in ${config_path}`);
+		return null;
+	}
+	try {
+		const compiler_path = (0, module$1.createRequire)(config_path).resolve(specifier);
+		declared_compiler_path_map.set(cache_key, compiler_path);
+		log$10("Found declared tsrx compiler at:", compiler_path, "from tsconfig:", config_path);
+		return compiler_path;
+	} catch {
+		const compiler_path = resolve_uncached_declared_compiler(typescript$4, host, config_path, specifier);
+		if (compiler_path !== void 0) {
+			declared_compiler_path_map.set(cache_key, compiler_path);
+			log$10("Found declared tsrx compiler after uncached retry at:", compiler_path, "from tsconfig:", config_path);
+			return compiler_path;
+		}
+		logError$5(`Unable to resolve declared TSRX compiler "${specifier}" from tsconfig`, config_path);
+		return null;
+	}
+}
+/**
+* Return undefined when there is no consumer declaration, null for a declared
+* hard stop, or the resolved compiler path for a valid declaration.
+* @param {string} normalized_file_name
+* @param {CompilerResolutionOptions} [options]
+* @returns {string | null | undefined}
+*/
+function resolve_consumer_compiler_for_file(normalized_file_name, options = {}) {
+	const typescript$5 = options.ts ?? typescript.default;
+	const config_host = options.configHost ?? typescript$5.sys;
+	const host_cache = get_config_host_cache(config_host);
+	const root_config_path = options.configFileName ?? get_nearest_root_tsconfig(path.default.dirname(normalized_file_name), config_host, host_cache);
+	if (root_config_path === null) return;
+	const resolved_layers = get_tsconfig_layers(typescript$5, config_host, root_config_path, host_cache);
+	for (const dependency of resolved_layers.dependencies) options.dependencies?.add(dependency);
+	const unreadable_layers = resolved_layers.layers.filter((layer) => layer.raw_source === void 0);
+	if (unreadable_layers.length > 0) {
+		for (const layer of unreadable_layers) logError$5("Unable to read tsconfig layer:", layer.path);
+		return null;
+	}
+	const malformed_layers = resolved_layers.layers.filter((layer) => layer.parse_diagnostics.length > 0);
+	if (malformed_layers.length > 0) {
+		const has_tsrx_intent = resolved_layers.layers.some((layer) => {
+			if (get_own_config_value(layer.config, ["tsrx"]).state === "found") return true;
+			if (layer.parse_diagnostics.length === 0 || layer.raw_source === void 0) return false;
+			return tsrx_key_pattern.test(layer.raw_source);
+		});
+		const log_parse_error = has_tsrx_intent ? logError$5 : logWarning$1;
+		for (const layer of malformed_layers) for (const diagnostic of layer.parse_diagnostics) log_parse_error("Unable to parse tsconfig layer:", layer.path, typescript$5.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+		return has_tsrx_intent ? null : void 0;
+	}
+	const declaration = resolve_inherited_config_value(resolved_layers.layers, (layer) => get_compiler_declaration(layer.config));
+	if (declaration.state === "invalid") {
+		logError$5(`Invalid TSRX ${declaration.target} declaration:`, declaration.actual_type, declaration.actual_value, `in ${declaration.config_path}`);
+		return null;
+	}
+	const effective_extends_failures = resolved_layers.extends_failures.filter((failure) => declaration.state !== "declared" || !is_extends_failure_overridden(resolved_layers.layers, failure, declaration.config_path));
+	if (effective_extends_failures.length > 0) {
+		for (const failure of effective_extends_failures) {
+			if (failure.diagnostics.length === 0) {
+				logError$5("Unable to resolve tsconfig extends entry:", JSON.stringify(failure.extends_value), `in ${failure.config_path}`);
+				continue;
+			}
+			for (const diagnostic of failure.diagnostics) logError$5("Unable to resolve tsconfig extends entry:", JSON.stringify(failure.extends_value), `in ${failure.config_path}`, typescript$5.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+		}
+		return null;
+	}
+	if (declaration.state === "declared") return resolve_declared_compiler(typescript$5, config_host, declaration.config_path, declaration.value);
+}
+/** Drop all filesystem-derived consumer compiler resolution state. */
+function reset_consumer_compiler_resolution_caches() {
+	config_host_to_resolution_cache = /* @__PURE__ */ new WeakMap();
+	declared_compiler_path_map.clear();
+}
+
 //#endregion
 //#region ../typescript-plugin/src/language.js
 /** @import * as AST from 'estree'; */
@@ -725,9 +1228,9 @@ var require_language_core = /* @__PURE__ */ __commonJSMin(((exports) => {
 /** @typedef {import('@volar/language-core').VirtualCode} VirtualCode */
 /** @typedef {string | { fsPath: string }} ScriptId */
 /** @typedef {typeof import('@volar/typescript')} _VolarTypeScriptAugmentation */
+/** @typedef {import('./consumer-compiler.js').CompilerResolutionOptions} CompilerResolutionOptions */
 /** @typedef {import('@volar/language-core').LanguagePlugin<ScriptId, VirtualCode>} RippleLanguagePlugin */
 /** @typedef {InstanceType<typeof import('./language.js')["TSRXVirtualCode"]>} TSRXVirtualCodeInstance */
-var import_language_core = require_language_core();
 const require$2 = (0, module$1.createRequire)(require("url").pathToFileURL(__filename).href);
 const root_dirname = path.default.dirname((0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
 const { log: log$9, logWarning, logError: logError$4 } = createLogging("[Ripple Language]");
@@ -812,10 +1315,18 @@ function is_ripple_file(file_name) {
 	return RIPPLE_EXTENSIONS$1.some((extension) => file_name.endsWith(extension));
 }
 /**
+* @param {CompilerResolutionOptions} [options]
 * @returns {RippleLanguagePlugin}
 */
-function getRippleLanguagePlugin() {
+function getRippleLanguagePlugin(options = {}) {
 	log$9("Creating Ripple language plugin...");
+	const typescript$1 = options.ts ?? typescript.default;
+	/** @type {CompilerResolutionOptions} */
+	const compiler_resolution_options = {
+		...options,
+		ts: typescript$1,
+		configHost: options.configHost ?? typescript$1.sys
+	};
 	return {
 		getLanguageId(fileNameOrUri) {
 			const file_name = typeof fileNameOrUri === "string" ? fileNameOrUri : fileNameOrUri.fsPath.replace(/\\/g, "/");
@@ -827,7 +1338,7 @@ function getRippleLanguagePlugin() {
 		createVirtualCode(fileNameOrUri, languageId, snapshot) {
 			if (languageId === "ripple") {
 				const file_name = normalizeFileNameOrUri(fileNameOrUri);
-				const ripple = get_tsrx_compiler(file_name);
+				const ripple = get_tsrx_compiler(file_name, compiler_resolution_options);
 				if (!ripple) {
 					logError$4(`Ripple compiler not found for file: ${file_name}`);
 					return;
@@ -1370,9 +1881,9 @@ const resolveConfig = (config) => {
 };
 /** @type {Map<string, string | null>} */
 const path2RipplePathMap = /* @__PURE__ */ new Map();
-/** @type {Map<string, string>} */
+/** @type {Map<string, { mtimeMs: number, size: number, content: string }>} */
 const pathToTypesCache = /* @__PURE__ */ new Map();
-/** @type {Map<string, RegExpMatchArray>} */
+/** @type {Map<string, { text: string, matches: Map<string, RegExpMatchArray> }>} */
 const typeNameMatchCache = /* @__PURE__ */ new Map();
 /** @type {Map<string, { name: string | null, dependencies: Set<string> } | null>} */
 const pathToPackageManifestCache = /* @__PURE__ */ new Map();
@@ -1440,18 +1951,24 @@ function package_manifest_matches_compiler(package_manifest, compiler_name, pack
 }
 /**
 * @param {string} normalized_file_name
+* @param {CompilerResolutionOptions} [options]
 * @returns {TSRXCompilerModule | undefined}
 */
-function get_tsrx_compiler(normalized_file_name) {
-	const compiler_path = get_compiler_entry_for_file(normalized_file_name);
-	if (compiler_path) {
-		const compiler_module = require$2(compiler_path);
-		if (typeof compiler_module?.compile_to_volar_mappings !== "function" && typeof compiler_module?.compileToVolarMappings === "function") return {
-			...compiler_module,
-			compile_to_volar_mappings: compiler_module.compileToVolarMappings
-		};
-		return compiler_module;
-	}
+function get_tsrx_compiler(normalized_file_name, options) {
+	const compiler_path = get_compiler_entry_for_file(normalized_file_name, options);
+	if (compiler_path) return normalize_tsrx_compiler_module(require$2(compiler_path));
+}
+/**
+* Normalize the compiler contract used by Octane and consumer-declared modules.
+* @param {TSRXCompilerModule & { compileToVolarMappings?: TSRXCompilerModule['compile_to_volar_mappings'] }} compiler_module
+* @returns {TSRXCompilerModule}
+*/
+function normalize_tsrx_compiler_module(compiler_module) {
+	if (typeof compiler_module?.compile_to_volar_mappings !== "function" && typeof compiler_module?.compileToVolarMappings === "function") return {
+		...compiler_module,
+		compile_to_volar_mappings: compiler_module.compileToVolarMappings
+	};
+	return compiler_module;
 }
 /**
 * @param {string} normalized_file_name
@@ -1495,10 +2012,13 @@ function find_workspace_compiler_entry_for_file(normalized_file_name, exists_syn
 }
 /**
 * @param {string} normalized_file_name
+* @param {CompilerResolutionOptions} [options]
 * @returns {string | undefined}
 */
-function get_compiler_entry_for_file(normalized_file_name) {
+function get_compiler_entry_for_file(normalized_file_name, options) {
 	const ext = path.default.extname(normalized_file_name);
+	const consumer_compiler_path = resolve_consumer_compiler_for_file(normalized_file_name, options);
+	if (consumer_compiler_path !== void 0) return consumer_compiler_path ?? void 0;
 	const package_manifest = get_nearest_package_manifest(path.default.dirname(normalized_file_name));
 	const workspace_compiler_path = find_workspace_compiler_entry_for_file(normalized_file_name);
 	if (workspace_compiler_path) return workspace_compiler_path;
@@ -1529,16 +2049,18 @@ function get_compiler_entry_for_file(normalized_file_name) {
 }
 /**
 * Resolve the tsrx compiler package that owns a `.tsrx` file (e.g. `'@tsrx/ripple'`,
-* `'@tsrx/react'`), based on the nearest `package.json` dependencies. All targets
-* share the `.tsrx` extension, so this is how the editor layer tells them apart —
-* it reuses the exact same resolution as compilation, so tooling and the compiler
-* always agree on the platform. Returns `undefined` when no compiler resolves.
+* `'@tsrx/react'`) from the exact compiler entry selected for compilation. All
+* targets share the `.tsrx` extension, so this is how the editor layer tells them
+* apart. Returns `undefined` for an unresolved or unknown third-party compiler.
 * @param {string} file_name
+* @param {CompilerResolutionOptions} [options]
 * @returns {string | undefined}
 */
-function get_tsrx_compiler_name_for_file(file_name) {
-	const entry = get_compiler_entry_for_file(file_name.replace(/\\/g, "/"));
+function get_tsrx_compiler_name_for_file(file_name, options) {
+	const entry = get_compiler_entry_for_file(file_name.replace(/\\/g, "/"), options);
 	if (!entry) return;
+	const package_name = get_nearest_package_manifest(path.default.dirname(entry))?.name;
+	if (COMPILER_CANDIDATES.some(([compiler_name]) => compiler_name === package_name)) return package_name ?? void 0;
 	const normalized_entry = entry.replace(/\\/g, "/");
 	for (const [compiler_name, compiler_dir_parts, , , entry_parts = DEFAULT_COMPILER_ENTRY_PARTS] of COMPILER_CANDIDATES) {
 		const suffix = "/" + [...compiler_dir_parts, ...entry_parts].join("/");
@@ -1549,53 +2071,116 @@ function get_tsrx_compiler_name_for_file(file_name) {
 * Whether a `.tsrx` file is compiled by the Ripple target (as opposed to
 * React/Solid/Preact/Vue). Used to gate Ripple-runtime-only editor suggestions.
 * @param {string} file_name
+* @param {CompilerResolutionOptions} [options]
 * @returns {boolean}
 */
-function is_ripple_platform_file(file_name) {
-	return get_tsrx_compiler_name_for_file(file_name) === "@tsrx/ripple";
+function is_ripple_platform_file(file_name, options) {
+	return get_tsrx_compiler_name_for_file(file_name, options) === "@tsrx/ripple";
+}
+/**
+* Create a stable key for filesystem caches. Windows paths are case-insensitive
+* to TypeScript, while file URIs conventionally lowercase their drive letter.
+* @param {string} file_name
+*/
+function getPathCacheKey(file_name) {
+	const is_windows_path = process.platform === "win32" || /^[a-z]:[\\/]/i.test(file_name) || file_name.startsWith("\\\\");
+	const normalized = (is_windows_path ? path.default.win32 : path.default).normalize(file_name);
+	return is_windows_path ? normalized.toLowerCase() : normalized;
 }
 /**
 * @param {string} typesFilePath
 * @returns {string | undefined}
 */
 function getCachedTypeDefinitionFile(typesFilePath) {
-	const cached = pathToTypesCache.get(typesFilePath);
-	if (cached) return cached;
-	if (!fs.default.existsSync(typesFilePath)) {
+	const cache_key = getPathCacheKey(typesFilePath);
+	let stat;
+	try {
+		stat = fs.default.statSync(typesFilePath);
+	} catch {
 		logWarning(`Types file does not exist at path: ${typesFilePath}`);
 		return;
 	}
+	const cached = pathToTypesCache.get(cache_key);
+	if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) return cached.content;
 	log$9(`Found ripple types at: ${typesFilePath}`);
 	const fileContent = fs.default.readFileSync(typesFilePath, "utf8");
 	if (!fileContent) {
 		logWarning(`Failed to read content of types file at: ${typesFilePath}`);
 		return;
 	}
-	pathToTypesCache.set(typesFilePath, fileContent);
+	pathToTypesCache.set(cache_key, {
+		mtimeMs: stat.mtimeMs,
+		size: stat.size,
+		content: fileContent
+	});
 	return fileContent;
 }
 /**
 * @param {string} typeName
 * @param {string} text
+* @param {string} [sourceKey]
 * @returns {RegExpMatchArray | undefined}
 */
-function getCachedTypeMatches(typeName, text) {
-	const cached = typeNameMatchCache.get(typeName);
+function getCachedTypeMatches(typeName, text, sourceKey = text) {
+	const cache_key = sourceKey === text ? text : getPathCacheKey(sourceKey);
+	let source_cache = typeNameMatchCache.get(cache_key);
+	if (!source_cache || source_cache.text !== text) {
+		source_cache = {
+			text,
+			matches: /* @__PURE__ */ new Map()
+		};
+		typeNameMatchCache.set(cache_key, source_cache);
+	}
+	const cached = source_cache.matches.get(typeName);
 	if (cached) return cached;
 	const searchPattern = new RegExp(`(?:export\\s+(?:declare\\s+)?|declare\\s+)(class|function)\\s+${typeName}`);
 	const match = text.match(searchPattern);
 	if (match && match.index !== void 0) {
-		typeNameMatchCache.set(typeName, match);
+		source_cache.matches.set(typeName, match);
 		return match;
 	}
 }
 /**
 * @param {string} normalized_file_name
+* @param {CompilerResolutionOptions} [options]
 * @returns {string | undefined}
 */
-function get_compiler_dir_for_file(normalized_file_name) {
-	const entry = get_compiler_entry_for_file(normalized_file_name);
-	if (entry) return path.default.dirname(path.default.dirname(entry));
+function get_compiler_dir_for_file(normalized_file_name, options) {
+	const entry = get_compiler_entry_for_file(normalized_file_name, options);
+	if (!entry) return;
+	let current_dir = path.default.dirname(entry);
+	while (current_dir) {
+		if (fs.default.existsSync(path.default.join(current_dir, "package.json"))) return current_dir;
+		if (path.default.basename(current_dir) === "node_modules") return;
+		const parent_dir = path.default.dirname(current_dir);
+		if (parent_dir === current_dir) return;
+		current_dir = parent_dir;
+	}
+}
+/**
+* Drop compiler-selection state. Loaded ESM compiler graphs cannot be evicted
+* safely in-process; language-server package watchers restart the process.
+*/
+function invalidateCompilerResolutionCaches() {
+	path2RipplePathMap.clear();
+	pathToPackageManifestCache.clear();
+	reset_consumer_compiler_resolution_caches();
+	loggedCompilationFailures.clear();
+}
+/**
+* Drop cached definition-file content and matches. A path invalidates only one
+* file; omitting it clears all definition state.
+* @param {string} [typesFilePath]
+*/
+function invalidateTypeDefinitionCaches(typesFilePath) {
+	if (typesFilePath) {
+		const cache_key = getPathCacheKey(typesFilePath);
+		pathToTypesCache.delete(cache_key);
+		typeNameMatchCache.delete(cache_key);
+		return;
+	}
+	pathToTypesCache.clear();
+	typeNameMatchCache.clear();
 }
 
 //#endregion
@@ -1715,15 +2300,30 @@ function is_ripple_document(document_uri) {
 	return RIPPLE_EXTENSIONS.some((extension) => document_uri.endsWith(extension));
 }
 /**
+* Reuse the TypeScript project selected by Volar when language-service plugins
+* perform compiler-dependent lookups outside virtual-code generation.
+* @param {LanguageServiceContext} context
+* @returns {import('@tsrx/typescript-plugin/src/consumer-compiler.js').CompilerResolutionOptions | undefined}
+*/
+function get_compiler_resolution_options(context) {
+	const typescript_project = context.project.typescript;
+	if (!typescript_project) return;
+	return {
+		configFileName: typescript_project.configFileName,
+		configHost: typescript_project.sys
+	};
+}
+/**
 * Whether a `.tsrx` document is compiled by the Ripple target (vs React/Solid/
 * Preact/Vue). All targets share the `.tsrx` extension, so this resolves the
-* platform from the nearest `package.json` — used to gate Ripple-runtime-only
+* platform from the active TypeScript project — used to gate Ripple-runtime-only
 * editor suggestions.
 * @param {string} document_uri
+* @param {import('@tsrx/typescript-plugin/src/consumer-compiler.js').CompilerResolutionOptions} [options]
 * @returns {boolean}
 */
-function is_ripple_platform_document(document_uri) {
-	return is_ripple_platform_file(vscode_uri.URI.parse(document_uri).fsPath);
+function is_ripple_platform_document(document_uri, options) {
+	return is_ripple_platform_file(vscode_uri.URI.parse(document_uri).fsPath, options);
 }
 
 //#endregion
@@ -4639,7 +5239,7 @@ var require_main$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.createMessageConnection = exports.createServerSocketTransport = exports.createClientSocketTransport = exports.createServerPipeTransport = exports.createClientPipeTransport = exports.generateRandomPipeName = exports.StreamMessageWriter = exports.StreamMessageReader = exports.SocketMessageWriter = exports.SocketMessageReader = exports.PortMessageWriter = exports.PortMessageReader = exports.IPCMessageWriter = exports.IPCMessageReader = void 0;
 	const ril_1 = require_ril();
 	ril_1.default.install();
-	const path$3 = require("path");
+	const path$4 = require("path");
 	const os = require("os");
 	const crypto_1 = require("crypto");
 	const net_1 = require("net");
@@ -4763,8 +5363,8 @@ var require_main$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
 		const randomSuffix = (0, crypto_1.randomBytes)(21).toString("hex");
 		if (process.platform === "win32") return `\\\\.\\pipe\\vscode-jsonrpc-${randomSuffix}-sock`;
 		let result;
-		if (XDG_RUNTIME_DIR) result = path$3.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
-		else result = path$3.join(os.tmpdir(), `vscode-${randomSuffix}.sock`);
+		if (XDG_RUNTIME_DIR) result = path$4.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+		else result = path$4.join(os.tmpdir(), `vscode-${randomSuffix}.sock`);
 		const limit = safeIpcPathLengths.get(process.platform);
 		if (limit !== void 0 && result.length > limit) (0, ril_1.default)().console.warn(`WARNING: IPC handle "${result}" is longer than ${limit} characters.`);
 		return result;
@@ -11181,7 +11781,7 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.resolveModulePath = exports.FileSystem = exports.resolveGlobalYarnPath = exports.resolveGlobalNodePath = exports.resolve = exports.uriToFilePath = void 0;
 	const url$1 = require("url");
-	const path$2 = require("path");
+	const path$3 = require("path");
 	const fs$2 = require("fs");
 	const child_process_1 = require("child_process");
 	/**
@@ -11198,7 +11798,7 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 			let second = segments[1];
 			if (first.length === 0 && second.length > 1 && second[1] === ":") segments.shift();
 		}
-		return path$2.normalize(segments.join("/"));
+		return path$3.normalize(segments.join("/"));
 	}
 	exports.uriToFilePath = uriToFilePath;
 	function isWindows() {
@@ -11228,7 +11828,7 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 			let newEnv = Object.create(null);
 			Object.keys(env).forEach((key) => newEnv[key] = env[key]);
 			if (nodePath && fs$2.existsSync(nodePath)) {
-				if (newEnv[nodePathKey]) newEnv[nodePathKey] = nodePath + path$2.delimiter + newEnv[nodePathKey];
+				if (newEnv[nodePathKey]) newEnv[nodePathKey] = nodePath + path$3.delimiter + newEnv[nodePathKey];
 				else newEnv[nodePathKey] = nodePath;
 				if (tracer) tracer(`NODE_PATH value is: ${newEnv[nodePathKey]}`);
 			}
@@ -11297,8 +11897,8 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 			}
 			let prefix = stdout.trim();
 			if (tracer) tracer(`'npm config get prefix' value is: ${prefix}`);
-			if (prefix.length > 0) if (isWindows()) return path$2.join(prefix, "node_modules");
-			else return path$2.join(prefix, "lib", "node_modules");
+			if (prefix.length > 0) if (isWindows()) return path$3.join(prefix, "node_modules");
+			else return path$3.join(prefix, "lib", "node_modules");
 			return;
 		} catch (err) {
 			return;
@@ -11333,7 +11933,7 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 			let lines = stdout.trim().split(/\r?\n/);
 			for (let line of lines) try {
 				let yarn = JSON.parse(line);
-				if (yarn.type === "log") return path$2.join(yarn.data, "node_modules");
+				if (yarn.type === "log") return path$3.join(yarn.data, "node_modules");
 			} catch (e) {}
 			return;
 		} catch (err) {
@@ -11354,14 +11954,14 @@ var require_files = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		FileSystem.isCaseSensitive = isCaseSensitive;
 		function isParent(parent, child) {
-			if (isCaseSensitive()) return path$2.normalize(child).indexOf(path$2.normalize(parent)) === 0;
-			else return path$2.normalize(child).toLowerCase().indexOf(path$2.normalize(parent).toLowerCase()) === 0;
+			if (isCaseSensitive()) return path$3.normalize(child).indexOf(path$3.normalize(parent)) === 0;
+			else return path$3.normalize(child).toLowerCase().indexOf(path$3.normalize(parent).toLowerCase()) === 0;
 		}
 		FileSystem.isParent = isParent;
 	})(FileSystem || (exports.FileSystem = FileSystem = {}));
 	function resolveModulePath(workspaceRoot, moduleName, nodePath, tracer) {
 		if (nodePath) {
-			if (!path$2.isAbsolute(nodePath)) nodePath = path$2.join(workspaceRoot, nodePath);
+			if (!path$3.isAbsolute(nodePath)) nodePath = path$3.join(workspaceRoot, nodePath);
 			return resolve(moduleName, nodePath, nodePath, tracer).then((value) => {
 				if (FileSystem.isParent(nodePath, value)) return value;
 				else return Promise.reject(/* @__PURE__ */ new Error(`Failed to load ${moduleName} from node path location.`));
@@ -21019,8 +21619,6 @@ function get_start_offset_from_error(error) {
 //#region src/definitionPlugin.js
 init_main();
 const { log: log$7 } = createLogging("[Ripple Definition Plugin]");
-/** @type {string | undefined} */
-let ripple_dir;
 /**
 * @returns {LanguageServicePlugin}
 */
@@ -21029,6 +21627,7 @@ function createDefinitionPlugin() {
 		name: "ripple-definition",
 		capabilities: { definitionProvider: true },
 		create(context) {
+			const compiler_resolution_options = get_compiler_resolution_options(context);
 			return { async provideDefinition(document, position, token) {
 				/** @type {LocationLink[]} */
 				let tsDefinitions = [];
@@ -21051,7 +21650,7 @@ function createDefinitionPlugin() {
 					const { name: typeName, path: typePath } = customMapping.data.customData.definition.typeReplace;
 					log$7(`Found replace definition for ${typeName}`);
 					const filePath = sourceUri.fsPath || sourceUri.path;
-					ripple_dir = ripple_dir ?? get_compiler_dir_for_file(normalizeFileNameOrUri(filePath));
+					const ripple_dir = get_compiler_dir_for_file(normalizeFileNameOrUri(filePath), compiler_resolution_options);
 					if (!ripple_dir) {
 						log$7(`Could not determine Ripple source directory for file: ${filePath}`);
 						return;
@@ -21059,7 +21658,7 @@ function createDefinitionPlugin() {
 					const typesFilePath = path.default.join(ripple_dir, ...typePath.split("/"));
 					const fileContent = getCachedTypeDefinitionFile(typesFilePath);
 					if (!fileContent) return;
-					const match = getCachedTypeMatches(typeName, fileContent);
+					const match = getCachedTypeMatches(typeName, fileContent, typesFilePath);
 					if (match && match.index !== void 0) {
 						const classStart = match.index + match[0].indexOf(typeName);
 						const classEnd = classStart + typeName.length;
@@ -21691,6 +22290,7 @@ function createCompletionPlugin() {
 			resolveProvider: false
 		} },
 		create(context) {
+			const compiler_resolution_options = get_compiler_resolution_options(context);
 			return {
 				isAdditionalCompletion: true,
 				async provideCompletionItems(document, position, completionContext, _token) {
@@ -21724,7 +22324,7 @@ function createCompletionPlugin() {
 					});
 					const fullText = document.getText();
 					const cursorOffset = document.offsetAt(position);
-					const is_ripple = is_ripple_platform_document(document.uri);
+					const is_ripple = is_ripple_platform_document(document.uri, compiler_resolution_options);
 					if (isInsideImport(fullText, cursorOffset)) {
 						if (is_ripple) items.push(...RIPPLE_IMPORTS);
 						return {
@@ -22571,6 +23171,134 @@ function createTypeScriptServices(ts) {
 	return create(ts);
 }
 
+//#endregion
+//#region src/workspaceState.js
+const WORKSPACE_FILE_PATTERNS = [
+	"**/*.tsrx",
+	"**/*.ts",
+	"**/*.tsx",
+	"**/*.cts",
+	"**/*.mts",
+	"**/*.js",
+	"**/*.jsx",
+	"**/*.cjs",
+	"**/*.mjs",
+	"**/*.json",
+	"**/pnpm-lock.yaml",
+	"**/pnpm-workspace.yaml",
+	"**/yarn.lock",
+	"**/bun.lock",
+	"**/bun.lockb"
+];
+const PACKAGE_STATE_FILE_NAMES = new Set([
+	"package.json",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"pnpm-workspace.yaml",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb"
+]);
+/**
+* @param {string} file_name
+*/
+function isTypeScriptConfigFile(file_name) {
+	const base_name = node_path.default.basename(file_name).toLowerCase();
+	return base_name.endsWith(".json") && (base_name.includes("tsconfig") || base_name.includes("jsconfig"));
+}
+/**
+* @param {string} file_name
+*/
+function isTypeDefinitionFile(file_name) {
+	return /\.d\.[cm]?ts$/i.test(file_name);
+}
+/**
+* @param {string} file_name
+*/
+function isPackageStateFile(file_name) {
+	return PACKAGE_STATE_FILE_NAMES.has(node_path.default.basename(file_name).toLowerCase());
+}
+/**
+* @param {string} file_name
+*/
+function normalizeFileName(file_name) {
+	const is_windows_path = process.platform === "win32" || /^[a-z]:[\\/]/i.test(file_name) || file_name.startsWith("\\\\");
+	const path_api = is_windows_path ? node_path.default.win32 : node_path.default;
+	const normalized = path_api.normalize(path_api.resolve(file_name));
+	return is_windows_path ? normalized.toLowerCase() : normalized;
+}
+/**
+* Record every config file that contributed to a parsed TypeScript project.
+* This set is intentionally additive across project reloads because Volar
+* recreates projects lazily. TypeScript allows both `extends` and
+* project-reference configs to use names other than tsconfig.json, so filename
+* matching alone is not sufficient.
+* @param {Set<string>} config_files
+* @param {{
+*   configFileName?: string,
+*   compilerOptions?: import('typescript').CompilerOptions,
+*   projectReferences?: readonly import('typescript').ProjectReference[],
+*   configDependencies?: Iterable<string>,
+* }} project
+*/
+function trackTypeScriptConfigDependencies(config_files, project) {
+	if (project.configFileName) config_files.add(normalizeFileName(project.configFileName));
+	const config_file = project.compilerOptions?.configFile;
+	for (const extended_file of config_file?.extendedSourceFiles ?? []) config_files.add(normalizeFileName(extended_file));
+	for (const reference of project.projectReferences ?? []) config_files.add(normalizeFileName(reference.path));
+	for (const dependency of project.configDependencies ?? []) config_files.add(normalizeFileName(dependency));
+}
+/**
+* Classify watched changes before mutating project state. Package changes need
+* a process restart because Node does not expose a supported way to evict a
+* loaded ESM compiler and its transitive module graph.
+* @param {import('@volar/language-server').FileEvent[]} changes
+* @param {ReadonlySet<string>} [tracked_config_files]
+*/
+function classifyWorkspaceChanges(changes, tracked_config_files = /* @__PURE__ */ new Set()) {
+	let reloadProjects = false;
+	let restartLanguageServer = false;
+	/** @type {Set<string>} */
+	const changedTypeDefinitions = /* @__PURE__ */ new Set();
+	for (const change of changes) {
+		const uri = vscode_uri.URI.parse(change.uri);
+		const file_name = uri.scheme === "file" ? uri.fsPath : uri.path;
+		if (isTypeScriptConfigFile(file_name) || tracked_config_files.has(normalizeFileName(file_name))) reloadProjects = true;
+		if (isPackageStateFile(file_name)) restartLanguageServer = true;
+		else if (isTypeDefinitionFile(file_name)) changedTypeDefinitions.add(file_name);
+	}
+	return {
+		restartLanguageServer,
+		reloadProjects: reloadProjects && !restartLanguageServer,
+		changedTypeDefinitions: restartLanguageServer ? [] : [...changedTypeDefinitions]
+	};
+}
+/**
+* @param {import('@volar/language-server').FileEvent[]} changes
+* @param {{
+*   restartLanguageServer: () => void,
+*   invalidateCompilerResolutionCaches?: () => void,
+*   reloadProjects: () => void,
+*   requestRefresh: (clearDiagnostics: boolean) => unknown,
+*   invalidateTypeDefinitions: (file_name?: string) => void,
+* }} hooks
+* @param {ReadonlySet<string>} [tracked_config_files]
+*/
+function handleWorkspaceChanges(changes, hooks, tracked_config_files) {
+	const effects = classifyWorkspaceChanges(changes, tracked_config_files);
+	if (effects.restartLanguageServer) {
+		hooks.restartLanguageServer();
+		return effects;
+	}
+	for (const file_name of effects.changedTypeDefinitions) hooks.invalidateTypeDefinitions(file_name);
+	if (effects.reloadProjects) {
+		hooks.invalidateCompilerResolutionCaches?.();
+		hooks.reloadProjects();
+		hooks.requestRefresh(true);
+	}
+	return effects;
+}
+
 //#endregion
 //#region src/server.js
 /** @import {CompilerOptions} from 'typescript' */
@@ -22603,10 +23331,20 @@ function createRippleLanguageServer() {
 	const connection = (0, import_node.createConnection)();
 	const server = (0, import_node.createServer)(connection);
 	connection.listen();
-	const rippleLanguagePlugin = getRippleLanguagePlugin();
-	log("Language plugin instance created");
 	/** @type {WeakSet<Function>} */
 	const wrappedFunctions = /* @__PURE__ */ new WeakSet();
+	/** @type {Set<string>} */
+	const trackedTypeScriptConfigFiles = /* @__PURE__ */ new Set();
+	/** @type {Set<Set<string>>} */
+	const compilerResolutionDependencySets = /* @__PURE__ */ new Set();
+	let restartScheduled = false;
+	/** Restart the process so Node drops the complete ESM compiler graph. */
+	function restartLanguageServer() {
+		if (restartScheduled) return;
+		restartScheduled = true;
+		log("Restarting after package state changed.");
+		setTimeout(() => process.exit(0), 50);
+	}
 	/**
 	* Ensure TypeScript hosts always see compiler options with Ripple defaults.
 	* @param {unknown} target
@@ -22639,12 +23377,25 @@ function createRippleLanguageServer() {
 			log("Initializing Ripple language server...");
 			log("Initialization options:", JSON.stringify(params.initializationOptions, null, 2));
 			const ts = require("typescript");
-			const initResult = server.initialize(params, (0, import_node.createTypeScriptProject)(ts, void 0, ({ projectHost }) => {
+			const initResult = server.initialize(params, (0, import_node.createTypeScriptProject)(ts, void 0, ({ configFileName, projectHost, sys }) => {
 				wrapCompilerOptionsProvider(projectHost, "getCompilationSettings");
+				const compilerResolutionDependencies = /* @__PURE__ */ new Set();
+				const languagePlugin = getRippleLanguagePlugin({
+					ts,
+					configFileName,
+					configHost: sys,
+					dependencies: compilerResolutionDependencies
+				});
+				compilerResolutionDependencySets.add(compilerResolutionDependencies);
 				return {
-					languagePlugins: [rippleLanguagePlugin],
+					languagePlugins: [languagePlugin],
 					setup({ project }) {
 						wrapCompilerOptionsProvider(project?.typescript?.languageServiceHost, "getCompilationSettings");
+						trackTypeScriptConfigDependencies(trackedTypeScriptConfigFiles, {
+							configFileName,
+							compilerOptions: projectHost.getCompilationSettings(),
+							projectReferences: projectHost.getProjectReferences?.()
+						});
 					}
 				};
 			}), [
@@ -22669,21 +23420,21 @@ function createRippleLanguageServer() {
 	connection.onInitialized(async () => {
 		log("Server initialized.");
 		server.initialized();
+		server.fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
+			for (const configDependencies of compilerResolutionDependencySets) trackTypeScriptConfigDependencies(trackedTypeScriptConfigFiles, { configDependencies });
+			if (handleWorkspaceChanges(changes, {
+				restartLanguageServer,
+				invalidateCompilerResolutionCaches,
+				invalidateTypeDefinitions: invalidateTypeDefinitionCaches,
+				reloadProjects: () => {
+					server.project.reload();
+				},
+				requestRefresh: (clearDiagnostics) => server.languageFeatures.requestRefresh(clearDiagnostics)
+			}, trackedTypeScriptConfigFiles).reloadProjects) log("Reloaded TypeScript projects after workspace configuration changed.");
+		});
 		try {
-			await server.fileWatcher.watchFiles([
-				"**/*.ts",
-				"**/*.tsx",
-				"**/*.cts",
-				"**/*.mts",
-				"**/*.js",
-				"**/*.jsx",
-				"**/*.cjs",
-				"**/*.mjs",
-				"**/*.d.ts",
-				"**/tsconfig.json",
-				"**/jsconfig.json"
-			]);
-			log("File watchers registered for TypeScript/JavaScript files.");
+			await server.fileWatcher.watchFiles(WORKSPACE_FILE_PATTERNS);
+			log("Workspace file watchers registered.");
 		} catch (err) {
 			logError("Failed to register file watchers:", err);
 		}
@@ -22713,4 +23464,4 @@ Object.defineProperty(exports, 'createRippleLanguageServer', {
     return createRippleLanguageServer;
   }
 });
-//# sourceMappingURL=server-BDTOWnFL.js.map
+//# sourceMappingURL=server-B91H_hpq.js.map