rspress-plugin-api-extractor 0.11.0 → 0.13.0

package/services/TwoslashCacheService.js

@@ -1,4 +1,8 @@
-import { Context } from "effect";
+import { AppDirsLive, PlatformLive } from "../layers/xdg.js";
+import { decodeTwoslashCache, encodeTwoslashCache, makeTwoslashCache, twoslashBlobKey } from "../twoslash-cache.js";
+import { Context, Effect, Layer, Option, Path } from "effect";
+import { Cache } from "@effected/store";
+import { AppDirs } from "@effected/xdg";
 
 //#region src/services/TwoslashCacheService.ts
 /**
@@ -9,7 +13,129 @@ import { Context } from "effect";
 * hook and cannot await: the service loads once before the render phase and
 * saves once after it, while every lookup in between is a synchronous map hit.
 */
-var TwoslashCacheService = class extends Context.Service()("rspress-plugin-api-extractor/TwoslashCacheService") {};
+var TwoslashCacheService = class TwoslashCacheService extends Context.Service()("rspress-plugin-api-extractor/TwoslashCacheService") {
+	/**
+	* Live Twoslash cache persistence.
+	*
+	* @remarks
+	* Failure is absorbed at TWO levels, and both are load-bearing. Inside the
+	* service, a failed read or write degrades that one operation. Around the
+	* layer, a failed CONSTRUCTION — no HOME for XDG, an unwritable cache
+	* directory, a corrupt database — degrades to {@link DegradedLive}.
+	*
+	* The second is why `Layer.catchCause` wraps this at all. While the sqlite
+	* layer was provided inside each method, a construction failure surfaced as
+	* that method's failure and the in-method handler swallowed it. Hoisting
+	* acquisition to layer construction moved the failure to `ManagedRuntime`
+	* build time, where it would abort the entire build — breaking the contract
+	* this service documents, that an unreachable cache must never fail a build
+	* that would otherwise succeed. `catchCause` rather than a failure-only catch
+	* because a defect thrown by the sqlite driver must degrade too.
+	*
+	* `Layer.suspend` because the composition below is declared after this class:
+	* a static initializer runs while the module body is still evaluating, so
+	* naming those consts directly throws at import time with a clean typecheck.
+	*/
+	static layer = Layer.suspend(() => CacheBackedLive.pipe(Layer.catchCause(() => DegradedLive)));
+	/**
+	* An always-cold in-memory double.
+	*
+	* @remarks
+	* Tests that resolve config must not touch the user's real XDG cache, and
+	* must not have their results depend on whether a previous run warmed it.
+	*
+	* `open` returns a REAL in-memory generation rather than a stub, and that is
+	* not an accident: `registerEnvironment` hands this object to the Twoslash
+	* transformers, so a cache that could not be read or written would change
+	* the render path's SHAPE rather than merely dropping its persistence.
+	*/
+	static makeTest = (overrides = {}) => ({
+		load: overrides.load ?? (() => Effect.succeed(/* @__PURE__ */ new Map())),
+		save: overrides.save ?? (() => Effect.void),
+		open: overrides.open ?? (() => Effect.succeed(makeTwoslashCache())),
+		persist: overrides.persist ?? (() => Effect.succeed(Option.none()))
+	});
+	/** {@link TwoslashCacheService.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(TwoslashCacheService, TwoslashCacheService.makeTest(overrides));
+};
+/**
+* A sqlite-backed `@effected/store` Cache in the XDG cache dir, separate from
+* the registry's `metadata.sqlite`.
+*
+* XDG rather than the repo: these are regenerable results derived from content
+* hashes, so they belong with the user's other caches — shared across worktrees
+* and checkouts of the same project, and untouched by cleaning `dist/`. Nothing
+* here needs to be committed for a build to be correct.
+*/
+const CacheLive = Layer.unwrap(Effect.gen(function* () {
+	const appDirs = yield* AppDirs;
+	const path = yield* Path.Path;
+	const cacheDir = yield* appDirs.ensureCache;
+	return Cache.layerSqlite({ filename: path.join(cacheDir, "twoslash.sqlite") });
+})).pipe(Layer.provide(Layer.mergeAll(AppDirsLive, PlatformLive)));
+/**
+* Live Twoslash cache persistence.
+*
+* Both operations swallow every failure by design — see the service docs. A
+* missing HOME, an unwritable cache dir or a corrupt database degrades the
+* build to "type-check everything", which is exactly the behaviour before this
+* cache existed.
+*/
+/**
+* Add the build-generation half of the service on top of a load/save pair.
+*
+* @remarks
+* Shared by the real and degraded layers so the two cannot drift: a degraded
+* build must still hand out a working in-memory cache, otherwise the
+* transformers have nothing to read or write and the render pass changes
+* shape rather than merely losing persistence.
+*/
+function withGeneration(base) {
+	let open = null;
+	return {
+		...base,
+		open: (envHash) => base.load(envHash).pipe(Effect.map((restored) => {
+			const cache = makeTwoslashCache(restored);
+			open = {
+				cache,
+				envHash
+			};
+			return cache;
+		})),
+		persist: () => Effect.suspend(() => {
+			if (open === null) return Effect.succeed(Option.none());
+			const { cache, envHash } = open;
+			const stats = cache.stats();
+			const report = Option.some({
+				...stats,
+				envHash
+			});
+			return stats.dirty ? base.save(envHash, cache.entries()).pipe(Effect.as(report)) : Effect.succeed(report);
+		})
+	};
+}
+const CacheBackedLive = Layer.effect(TwoslashCacheService, Effect.gen(function* () {
+	const cache = yield* Cache;
+	return withGeneration({
+		load: (envHash) => cache.get(twoslashBlobKey(envHash)).pipe(Effect.map((entry) => Option.isSome(entry) ? decodeTwoslashCache(entry.value.value) : /* @__PURE__ */ new Map()), Effect.catch(() => Effect.succeed(/* @__PURE__ */ new Map()))),
+		save: (envHash, entries) => cache.set({
+			key: twoslashBlobKey(envHash),
+			value: encodeTwoslashCache(entries),
+			tags: ["twoslash"]
+		}).pipe(Effect.catch(() => Effect.void))
+	});
+})).pipe(Layer.provide(CacheLive));
+/**
+* A cache that holds nothing, for when the real one cannot be opened.
+*
+* @remarks
+* `load` returns empty and `save` discards, which is precisely the behaviour
+* before this cache existed: type-check everything, persist nothing.
+*/
+const DegradedLive = Layer.succeed(TwoslashCacheService, withGeneration({
+	load: () => Effect.succeed(/* @__PURE__ */ new Map()),
+	save: () => Effect.void
+}));
 
 //#endregion
 export { TwoslashCacheService };

package/services/TwoslashEnvironments.js

@@ -1,7 +1,35 @@
-import { Context } from "effect";
+import { TwoslashEnvironmentRegistry } from "../twoslash-transformer.js";
+import { Context, Layer } from "effect";
 
 //#region src/services/TwoslashEnvironments.ts
-var TwoslashEnvironments = class extends Context.Service()("rspress-plugin-api-extractor/TwoslashEnvironments") {};
+var TwoslashEnvironments = class extends Context.Service()("rspress-plugin-api-extractor/TwoslashEnvironments") {
+	/**
+	* One environment registry per runtime.
+	*
+	* @remarks
+	* `Layer.sync` rather than `Layer.succeed`: the registry is mutable, and a
+	* `Layer.succeed` would capture a single instance shared by every layer graph
+	* that referenced this const — including, in a test run, every test file in
+	* the process. Building it when the layer builds is what makes substitution
+	* work: a test that wants an isolated registry provides its own layer, which
+	* is what the old static `TwoslashManager.reset()` was standing in for.
+	*
+	* Deliberately NOT `Layer.effect` with a finalizer. The registry holds Shiki
+	* transformers, which the render pass uses AFTER `config()` returns — the same
+	* lifetime constraint the highlighter has, and for the same reason.
+	*/
+	static layer = Layer.sync(this, () => make());
+};
+const make = () => {
+	const registry = new TwoslashEnvironmentRegistry();
+	return {
+		registerEnvironment: (options) => registry.registerEnvironment(options),
+		registerScope: (apiScope, compilerOptions) => registry.registerScope(apiScope, compilerOptions),
+		transformerFor: (apiScope) => registry.transformerFor(apiScope),
+		setCurrentFile: (path) => registry.setCurrentFile(path),
+		reportErrorForTest: (error, code, file) => registry.reportErrorForTest(error, code, file)
+	};
+};
 
 //#endregion
 export { TwoslashEnvironments };

package/services/TypeRegistryService.js

@@ -1,7 +1,183 @@
-import { Context } from "effect";
+import { PluginEvent } from "../observability/events.js";
+import { emit } from "../observability/EventBus.js";
+import { resolveExternalPackageVersions } from "../config-utils.js";
+import { TypeRegistryError } from "../errors.js";
+import { AppDirsLive, PlatformLive } from "../layers/xdg.js";
+import { Context, Duration, Effect, Layer, Path } from "effect";
+import { NodeHttpClient } from "@effect/platform-node";
+import { PackageFetcher, PackageSpec, RegistryObserver, TypeCache, TypeRegistry } from "@tsdoctor/registry";
+import { Cache } from "@effected/store";
+import { AppDirs } from "@effected/xdg";
 
 //#region src/services/TypeRegistryService.ts
-var TypeRegistryService = class extends Context.Service()("rspress-plugin-api-extractor/TypeRegistryService") {};
+var TypeRegistryService = class TypeRegistryService extends Context.Service()("rspress-plugin-api-extractor/TypeRegistryService") {
+	/**
+	* The `@tsdoctor/registry` stack, acquired once.
+	*
+	* @remarks
+	* `Layer.catchCause` keeps a broken environment — no HOME for XDG, an
+	* unwritable cache directory — from aborting the build at `ManagedRuntime`
+	* construction. External type loading is an enhancement: without it code
+	* blocks render without Twoslash enrichment, which is a degradation, not a
+	* failure. That was true while the stack was provided per method and the
+	* in-method handlers absorbed it; hoisting acquisition made it something the
+	* layer has to say for itself.
+	*
+	* `Layer.suspend` because the composition below is declared after this class: a
+	* static initializer runs while the module body is still evaluating, so naming
+	* those consts directly throws at import time with a clean typecheck.
+	*/
+	static layer = Layer.suspend(() => RegistryBackedLive.pipe(Layer.catchCause(() => DegradedLive)));
+	/**
+	* An in-memory double: no network, no XDG cache, no sqlite.
+	*
+	* @remarks
+	* Defaults resolve every spec unchanged and load an empty VFS — the shape a
+	* build takes when nothing external is configured. Override a member to
+	* exercise a specific path; an override for one member leaves the other at
+	* its default rather than forcing the test to restate it, which is the whole
+	* difference from the hand-written `Layer.succeed` doubles this replaces.
+	*/
+	static makeTest = (overrides = {}) => ({
+		resolveVersions: overrides.resolveVersions ?? ((packages) => Effect.succeed([...packages])),
+		loadPackages: overrides.loadPackages ?? (() => Effect.succeed({ vfs: /* @__PURE__ */ new Map() }))
+	});
+	/** {@link TypeRegistryService.makeTest} behind a `Layer`. */
+	static layerTest = (overrides = {}) => Layer.succeed(TypeRegistryService, TypeRegistryService.makeTest(overrides));
+};
+/**
+* Forward @tsdoctor/registry's typed `RegistryEvent`s to the plugin's Effect
+* logger. Since v1 the library emits no logs of its own — observers are the only
+* diagnostic surface — so this restores the build output and routes it through
+* the plugin's configured log level/format (a single source, no duplication).
+*
+* The summary (`BatchComplete`) and failures are surfaced at info/warning;
+* per-package detail stays at debug so a normal build is quiet.
+*/
+const RegistryObserverLayer = Layer.succeed(RegistryObserver, { emit: (event) => {
+	switch (event._tag) {
+		case "VersionResolved": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: { packageName: event.package },
+			level: "debug",
+			kind: "VersionResolved",
+			detail: `${event.requested} -> ${event.resolved}`
+		}));
+		case "VersionResolveFailed": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: { packageName: event.package },
+			level: "debug",
+			kind: "VersionResolveFailed",
+			detail: `${event.requested}: ${event.kind}`
+		}));
+		case "CacheHit":
+		case "CacheMiss":
+		case "FetchStart": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {
+				packageName: event.package,
+				version: event.version
+			},
+			level: "debug",
+			kind: event._tag,
+			detail: ""
+		}));
+		case "CacheStale": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {
+				packageName: event.package,
+				version: event.version
+			},
+			level: "debug",
+			kind: "CacheStale",
+			detail: ""
+		}));
+		case "FetchFailed": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {},
+			level: "debug",
+			kind: "FetchFailed",
+			detail: `HTTP ${event.status}: ${event.url}${event.bodySnippet ? ` — ${event.bodySnippet}` : ""}`
+		}));
+		case "PackageLoaded": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {
+				packageName: event.package,
+				version: event.version
+			},
+			level: "debug",
+			kind: "PackageLoaded",
+			detail: `${event.files} files, ${event.source}`
+		}));
+		case "PackageLoadFailed": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {
+				packageName: event.package,
+				version: event.version
+			},
+			level: "warn",
+			kind: "PackageLoadFailed",
+			detail: `[${event.kind}] ${event.error instanceof Error ? event.error.message : String(event.error)}`
+		}));
+		case "BatchStart": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {},
+			level: "debug",
+			kind: "BatchStart",
+			detail: `${event.total} package(s)`
+		}));
+		case "BatchComplete": return emit(PluginEvent.TypeRegistryEvent({
+			ctx: {},
+			level: "info",
+			kind: "BatchComplete",
+			detail: `${event.loaded}/${event.total} packages, ${event.totalFiles} files, ${Math.round(Duration.toMillis(event.duration))}ms`
+		}));
+	}
+} });
+/** Metadata plane: a sqlite-backed `@effected/store` Cache rooted in the XDG cache dir. */
+const MetadataCacheLive = Layer.unwrap(Effect.gen(function* () {
+	const appDirs = yield* AppDirs;
+	const path = yield* Path.Path;
+	const cacheDir = yield* appDirs.ensureCache;
+	return Cache.layerSqlite({ filename: path.join(cacheDir, "metadata.sqlite") });
+})).pipe(Layer.provide(Layer.mergeAll(AppDirsLive, PlatformLive)));
+/**
+* The full registry runtime: TypeRegistry over an XDG-rooted TypeCache and the
+* jsDelivr PackageFetcher, with the observer that forwards registry events to
+* the plugin's EventBus (found ambiently via serviceOption at emit time).
+*/
+const RegistryLayer = TypeRegistry.layer.pipe(Layer.provideMerge(Layer.mergeAll(TypeCache.layerXdg(), PackageFetcher.layer)), Layer.provideMerge(RegistryObserverLayer), Layer.provide(Layer.mergeAll(MetadataCacheLive, AppDirsLive, PlatformLive, NodeHttpClient.layerUndici)));
+/**
+* TypeRegistryService.layer: uses @tsdoctor/registry Effect programs directly.
+*/
+const RegistryBackedLive = Layer.effect(TypeRegistryService, Effect.gen(function* () {
+	const registry = yield* TypeRegistry;
+	return {
+		resolveVersions: (packages) => resolveExternalPackageVersions(packages, (pkg) => registry.resolveVersion(pkg.name, pkg.version)).pipe(Effect.catch(() => Effect.succeed([...packages]))),
+		loadPackages: (packages) => packages.length === 0 ? Effect.succeed({ vfs: /* @__PURE__ */ new Map() }) : Effect.gen(function* () {
+			const specs = packages.map((pkg) => new PackageSpec({
+				name: pkg.name,
+				version: pkg.version
+			}));
+			return { vfs: yield* registry.getVfs(specs, { autoFetch: true }) };
+		}).pipe(Effect.catch((error) => Effect.fail(new TypeRegistryError({
+			packageName: packages.map((p) => p.name).join(", "),
+			version: packages.map((p) => p.version).join(", "),
+			reason: error instanceof Error ? error.message ?? String(error) : String(error)
+		}))))
+	};
+})).pipe(Layer.provide(RegistryLayer));
+/**
+* The service when the registry stack cannot be built at all.
+*
+* @remarks
+* Preserves exactly the split the working service documents: `resolveVersions`
+* passes its specs through unresolved rather than swallowing the problem, so
+* the failure surfaces from `loadPackages` as a {@link PluginTypeRegistryError}
+* with a message, which `ConfigService.layer` turns into a build-continues
+* warning. Before acquisition moved to layer construction this fell out of the
+* per-method handlers; it has to be stated explicitly now.
+*/
+const DegradedLive = Layer.succeed(TypeRegistryService, {
+	resolveVersions: (packages) => Effect.succeed([...packages]),
+	loadPackages: (packages) => Effect.fail(new TypeRegistryError({
+		packageName: packages.map((p) => p.name).join(", "),
+		version: packages.map((p) => p.version).join(", "),
+		reason: "type registry unavailable: its cache directory or metadata database could not be opened"
+	}))
+});
 
 //#endregion
 export { TypeRegistryService };

package/shiki-transformer.js

@@ -67,7 +67,7 @@ var ShikiCrossLinker = class ShikiCrossLinker {
 	* way and both are immutable per build.
 	*
 	* This replaces a single long-lived instance created at plugin-factory time,
-	* threaded through `ConfigServiceLive`'s constructor and the build context,
+	* threaded through `ConfigService.layer`'s constructor and the build context,
 	* and mutated per API by `reinitialize()`. Scope isolation used to be a
 	* property of internal `…ByScope` maps plus a mutable `currentApiScope` that
 	* any caller could reassign between a lookup and a render; it is now a

package/sync-node-fs.js

@@ -1,4 +1,4 @@
-import fs from "node:fs";
+import fsSync from "node:fs";
 import { Effect, FileSystem, Layer, Option, Path, PlatformError } from "effect";
 
 //#region src/sync-node-fs.ts
@@ -51,21 +51,21 @@ const infoFromStats = (stats) => ({
 	blocks: Option.some(stats.blocks)
 });
 const syncFileSystem = FileSystem.layerNoop({
-	exists: (path) => Effect.sync(() => fs.existsSync(path)),
+	exists: (path) => Effect.sync(() => fsSync.existsSync(path)),
 	stat: (path) => Effect.try({
-		try: () => infoFromStats(fs.statSync(path)),
+		try: () => infoFromStats(fsSync.statSync(path)),
 		catch: (cause) => fail("stat", path, cause)
 	}),
 	readFileString: (path) => Effect.try({
-		try: () => fs.readFileSync(path, "utf8"),
+		try: () => fsSync.readFileSync(path, "utf8"),
 		catch: (cause) => fail("readFileString", path, cause)
 	}),
 	readDirectory: (path) => Effect.try({
-		try: () => fs.readdirSync(path),
+		try: () => fsSync.readdirSync(path),
 		catch: (cause) => fail("readDirectory", path, cause)
 	}),
 	readLink: (path) => Effect.try({
-		try: () => fs.readlinkSync(path),
+		try: () => fsSync.readlinkSync(path),
 		catch: (cause) => fail("readLink", path, cause)
 	})
 });

package/tsconfig-parser.js

@@ -1,10 +1,36 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, isAbsolute, resolve } from "node:path";
-import ts from "typescript";
+import path from "node:path";
+import { TsconfigLoaderSync } from "@effected/tsconfig-json";
 
 //#region src/tsconfig-parser.ts
 /**
+* Reading a `tsconfig.json` into the compiler options the plugin consumes.
+*
+* @remarks
+* A thin adapter over `@effected/tsconfig-json`'s `TsconfigLoaderSync`, which
+* owns `extends` chain resolution (including package specifiers), JSONC
+* parsing and relative-path handling. This module used to hand-roll all three
+* over TypeScript's `parseJsonConfigFileContent`.
+*
+* **The loader returns the tsconfig SPELLING, not the programmatic one.**
+* `target` is `"es2025"` rather than `ts.ScriptTarget.ES2025`, and `lib` is
+* `["esnext"]` rather than `["lib.esnext.d.ts"]`. That is fine, and it is why
+* the normalization seam had to land first: `toProgrammaticCompilerOptions`
+* (`twoslash-transformer.ts`) converts at ONE place, and
+* {@link TypeResolutionCompilerOptions} accepts both spellings by design. Do
+* not convert here — a second conversion site is exactly the drift that made
+* three of four resolution paths load zero lib files once already.
+*
+* @packageDocumentation
+*/
+/**
 * Error thrown when tsconfig.json parsing fails.
+*
+* @remarks
+* Retained as the plugin's own type rather than surfacing the kit's
+* `TsconfigParseError`/`TsconfigExtendsError` directly: `typescript-config.ts`
+* branches on `instanceof TsConfigParseError` to decide whether a failure is
+* already reported, and both kit errors mean the same thing to that caller.
 */
 var TsConfigParseError = class extends Error {
 	configPath;
@@ -17,117 +43,73 @@ var TsConfigParseError = class extends Error {
 	}
 };
 /**
-* Parse a tsconfig.json file and extract compiler options relevant for type resolution.
+* The sync host the kit loader reads through.
 *
-* This function uses TypeScript's native config parsing which automatically handles:
-* - `extends` chains (resolves and merges all extended configs)
-* - Comments in JSON (JSONC support)
-* - Relative path resolution
-*
-* @param configPath - Path to tsconfig.json (relative or absolute)
-* @param projectRoot - Project root directory for resolving relative paths
-* @returns Parsed compiler options
-* @throws TsConfigParseError if the config cannot be read or parsed
-*
-* @example
-* ```ts
-* const options = parseTsConfig("tsconfig.json", "/path/to/project");
-* // Returns: { target: 99, module: 99, lib: ["ESNext", "DOM"], ... }
-* ```
+* @remarks
+* `node:path` satisfies `SyncPath` verbatim. The filesystem half is two
+* functions, so no shim module is needed.
 */
-function parseTsConfig(configPath, projectRoot) {
-	return parseTsConfigWithMetadata(configPath, projectRoot).compilerOptions;
-}
+const syncHost = {
+	fileSystem: {
+		exists: existsSync,
+		readFile: (filePath) => readFileSync(filePath, "utf8")
+	},
+	path
+};
 /**
-* Parse a tsconfig.json file and return detailed metadata including extended paths.
+* Parse a `tsconfig.json` and extract the compiler options used for type
+* resolution.
 *
 * @param configPath - Path to tsconfig.json (relative or absolute)
 * @param projectRoot - Project root directory for resolving relative paths
-* @returns Parse result with compiler options and metadata
+* @returns The declared compiler options, in the tsconfig spelling
 * @throws TsConfigParseError if the config cannot be read or parsed
 *
 * @example
 * ```ts
-* const result = parseTsConfigWithMetadata("tsconfig.json", "/path/to/project");
-* console.log(result.configPath);      // Absolute path to resolved config
-* console.log(result.extendedPaths);   // ["base.json", "tsconfig.json"]
-* console.log(result.compilerOptions); // Merged compiler options
+* const options = parseTsConfig("tsconfig.json", "/path/to/project");
+* // Returns: { target: "es2025", module: "nodenext", lib: ["esnext"], ... }
 * ```
 */
-function parseTsConfigWithMetadata(configPath, projectRoot) {
-	const absolutePath = isAbsolute(configPath) ? configPath : resolve(projectRoot, configPath);
+function parseTsConfig(configPath, projectRoot) {
+	const absolutePath = path.isAbsolute(configPath) ? configPath : path.resolve(projectRoot, configPath);
 	if (!existsSync(absolutePath)) throw new TsConfigParseError(absolutePath, "File not found");
-	const configFileContent = ts.readConfigFile(absolutePath, (path) => readFileSync(path, "utf-8"));
-	if (configFileContent.error) {
-		const message = ts.flattenDiagnosticMessageText(configFileContent.error.messageText, "\n");
-		throw new TsConfigParseError(absolutePath, message, configFileContent.error);
-	}
-	const configDir = dirname(absolutePath);
-	const parsedConfig = ts.parseJsonConfigFileContent(configFileContent.config, ts.sys, configDir, void 0, absolutePath);
-	const significantErrors = parsedConfig.errors.filter((error) => {
-		const message = ts.flattenDiagnosticMessageText(error.messageText, "\n");
-		return error.code !== 18003 && !message.includes("No inputs were found");
-	});
-	if (significantErrors.length > 0) {
-		const errorMessages = significantErrors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("; ");
-		throw new TsConfigParseError(absolutePath, errorMessages, significantErrors);
-	}
-	const extendedPaths = [absolutePath];
-	collectExtendedPaths(configFileContent.config, configDir, extendedPaths);
-	const tsOptions = parsedConfig.options;
-	return {
-		compilerOptions: extractTypeResolutionOptions(tsOptions),
-		configPath: absolutePath,
-		extendedPaths
-	};
-}
-/**
-* Recursively collect extended config paths.
-* @internal
-*/
-function collectExtendedPaths(config, baseDir, paths) {
-	if (!config || typeof config !== "object") return;
-	const extendsValue = config.extends;
-	if (typeof extendsValue === "string") {
-		const extendedPath = resolveExtendedPath(extendsValue, baseDir);
-		if (extendedPath && !paths.includes(extendedPath)) paths.unshift(extendedPath);
-	} else if (Array.isArray(extendsValue)) {
-		for (const ext of extendsValue) if (typeof ext === "string") {
-			const extendedPath = resolveExtendedPath(ext, baseDir);
-			if (extendedPath && !paths.includes(extendedPath)) paths.unshift(extendedPath);
-		}
-	}
-}
-/**
-* Resolve an extended config path.
-* @internal
-*/
-function resolveExtendedPath(extendsValue, baseDir) {
+	let options;
 	try {
-		if (extendsValue.startsWith(".")) return resolve(baseDir, extendsValue);
-		return extendsValue;
-	} catch {
-		return null;
+		options = TsconfigLoaderSync.compilerOptions(absolutePath, syncHost);
+	} catch (error) {
+		throw new TsConfigParseError(absolutePath, error instanceof Error ? error.message : String(error), error);
 	}
+	return extractTypeResolutionOptions(options);
 }
 /**
-* Extract TypeResolutionCompilerOptions from full TypeScript CompilerOptions.
-* @internal
+* Narrow the full compiler options to the ones the plugin actually consumes.
+*
+* @remarks
+* Deliberately a whitelist. Everything here reaches Twoslash's TypeScript
+* environment, and passing through options the plugin does not understand
+* would let a consumer's unrelated build setting change how examples
+* type-check.
 */
-function extractTypeResolutionOptions(tsOptions) {
-	const options = {};
-	if (tsOptions.target !== void 0) options.target = tsOptions.target;
-	if (tsOptions.module !== void 0) options.module = tsOptions.module;
-	if (tsOptions.moduleResolution !== void 0) options.moduleResolution = tsOptions.moduleResolution;
-	if (tsOptions.lib !== void 0 && tsOptions.lib.length > 0) options.lib = tsOptions.lib;
-	if (tsOptions.strict !== void 0) options.strict = tsOptions.strict;
-	if (tsOptions.skipLibCheck !== void 0) options.skipLibCheck = tsOptions.skipLibCheck;
-	if (tsOptions.esModuleInterop !== void 0) options.esModuleInterop = tsOptions.esModuleInterop;
-	if (tsOptions.allowSyntheticDefaultImports !== void 0) options.allowSyntheticDefaultImports = tsOptions.allowSyntheticDefaultImports;
-	if (tsOptions.jsx !== void 0) options.jsx = tsOptions.jsx;
-	if (tsOptions.types !== void 0 && tsOptions.types.length > 0) options.types = tsOptions.types;
-	return options;
+function extractTypeResolutionOptions(options) {
+	const result = {};
+	const scalar = (value) => typeof value === "string" || typeof value === "number" ? value : void 0;
+	const target = scalar(options.target);
+	if (target !== void 0) result.target = target;
+	const module_ = scalar(options.module);
+	if (module_ !== void 0) result.module = module_;
+	const moduleResolution = scalar(options.moduleResolution);
+	if (moduleResolution !== void 0) result.moduleResolution = moduleResolution;
+	const jsx = scalar(options.jsx);
+	if (jsx !== void 0) result.jsx = jsx;
+	if (typeof options.strict === "boolean") result.strict = options.strict;
+	if (typeof options.skipLibCheck === "boolean") result.skipLibCheck = options.skipLibCheck;
+	if (typeof options.esModuleInterop === "boolean") result.esModuleInterop = options.esModuleInterop;
+	if (typeof options.allowSyntheticDefaultImports === "boolean") result.allowSyntheticDefaultImports = options.allowSyntheticDefaultImports;
+	if (Array.isArray(options.lib) && options.lib.length > 0) result.lib = options.lib.map(String);
+	if (Array.isArray(options.types) && options.types.length > 0) result.types = options.types.map(String);
+	return result;
 }
 
 //#endregion
-export { TsConfigParseError, parseTsConfig, parseTsConfigWithMetadata };
+export { TsConfigParseError, parseTsConfig };

package/twoslash-access.js

@@ -10,7 +10,7 @@ let current = NOT_INSTALLED;
 *
 * @remarks
 * Called from `plugin.ts`'s Effect program, beside the other seam wiring, and
-* NOT from `ConfigServiceLive` — config resolution should compute a value, not
+* NOT from `ConfigService.layer` — config resolution should compute a value, not
 * also mutate module state on the side.
 */
 function installTwoslashAccess(environments) {

package/twoslash-transformer.js

@@ -456,7 +456,7 @@ function addTypeRoutes(routes) {
 *
 * Clears ONLY the routes. The environments are per-build too, but they are
 * owned by the layer now, so nothing here can discard the per-scope
-* transformers `ConfigServiceLive` just built.
+* transformers `ConfigService.layer` just built.
 */
 function clearTypeRoutes() {
 	typeRoutes.clear();