rspress-plugin-api-extractor 0.10.0 → 0.12.0

package/shiki-transformer.js

@@ -43,100 +43,53 @@
 * @see the `@tsdoctor/model` CrossLinker for the markdown equivalent
 * @see {@link TwoslashManager} for type-aware documentation features
 */
-var ShikiCrossLinker = class {
-	/** Map of API scopes to their route maps (API item name to route) */
-	apiItemRoutesByScope = /* @__PURE__ */ new Map();
-	/** Map of API scopes to their kind maps (API item name to kind) */
-	apiItemKindsByScope = /* @__PURE__ */ new Map();
-	/** Map of API scopes to their class members maps (class name to member names) */
-	classMembersMapByScope = /* @__PURE__ */ new Map();
-	/**
-	* Current API scope being processed (e.g., "claude-binary-plugin")
-	*/
-	currentApiScope = null;
-	/**
-	* Creates a new ShikiCrossLinker instance. Call reinitialize() with routes, kinds,
-	* and API scope before using the transformer.
-	*/
-	constructor(routes, kinds, apiScope) {
-		if (routes && kinds && apiScope) this.reinitialize(routes, kinds, apiScope);
+var ShikiCrossLinker = class ShikiCrossLinker {
+	/** API item name to route, for THIS scope. */
+	apiItemRoutes;
+	/** API item name to kind (Class, Interface, …), for THIS scope. */
+	apiItemKinds;
+	/** Parent name to its member names, longest first, for THIS scope. */
+	classMembersMap;
+	/** The scope this linker links for. Read-only after construction. */
+	apiScope;
+	constructor(apiScope, apiItemRoutes, apiItemKinds, classMembersMap) {
+		this.apiScope = apiScope;
+		this.apiItemRoutes = apiItemRoutes;
+		this.apiItemKinds = apiItemKinds;
+		this.classMembersMap = classMembersMap;
 	}
 	/**
-	* Initialize or reinitialize the cross-link maps with new data for a specific API scope.
-	* This allows the same transformer instance to be used across multiple API packages,
-	* with each API's routes stored separately and scoped to prevent cross-API linking.
+	* One linker for one API's routes.
+	*
+	* @remarks
+	* Mirrors `@tsdoctor/model`'s `CrossLinker.fromRoutes`, deliberately: the
+	* two halves of cross-linking — prose and code blocks — are built the same
+	* way and both are immutable per build.
 	*
-	* @param routes - Map of API item names to their documentation routes
-	* @param kinds - Map of API item names to their kinds (Class, Interface, etc.)
-	* @param apiScope - The API scope identifier (e.g., "claude-binary-plugin", "rslib-builder")
+	* This replaces a single long-lived instance created at plugin-factory time,
+	* 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
+	* property of the instance, which cannot be pointed at another package's
+	* routes at all.
 	*/
-	reinitialize(routes, kinds, apiScope) {
-		this.apiItemRoutesByScope.set(apiScope, new Map(routes));
-		this.apiItemKindsByScope.set(apiScope, new Map(kinds));
+	static fromRoutes(routes, kinds, apiScope) {
 		const classMembersMap = /* @__PURE__ */ new Map();
-		for (const [name] of routes.entries()) if (name.includes(".")) {
+		for (const [name] of routes.entries()) {
 			const dotIndex = name.indexOf(".");
+			if (dotIndex === -1) continue;
 			const className = name.substring(0, dotIndex);
 			const memberName = name.substring(dotIndex + 1);
-			if (!classMembersMap.has(className)) classMembersMap.set(className, []);
 			const members = classMembersMap.get(className);
-			if (members && !members.includes(memberName)) members.push(memberName);
+			if (members === void 0) classMembersMap.set(className, [memberName]);
+			else if (!members.includes(memberName)) members.push(memberName);
 		}
 		for (const members of classMembersMap.values()) members.sort((a, b) => b.length - a.length);
-		this.classMembersMapByScope.set(apiScope, classMembersMap);
-		this.currentApiScope = apiScope;
-	}
-	/**
-	* Set the current API scope for cross-linking.
-	* This should be called before rendering each file to ensure links are scoped correctly.
-	*
-	* @param apiScope - The API scope identifier (e.g., "claude-binary-plugin")
-	*/
-	setApiScope(apiScope) {
-		this.currentApiScope = apiScope;
-	}
-	/**
-	* Get the routes map for the current API scope
-	*/
-	getRoutesForCurrentScope() {
-		if (!this.currentApiScope) return /* @__PURE__ */ new Map();
-		return this.apiItemRoutesByScope.get(this.currentApiScope) || /* @__PURE__ */ new Map();
-	}
-	/**
-	* Get the kinds map for the current API scope
-	*/
-	getKindsForCurrentScope() {
-		if (!this.currentApiScope) return /* @__PURE__ */ new Map();
-		return this.apiItemKindsByScope.get(this.currentApiScope) || /* @__PURE__ */ new Map();
-	}
-	/**
-	* Get the class members map for the current API scope
-	*/
-	getClassMembersForCurrentScope() {
-		if (!this.currentApiScope) return /* @__PURE__ */ new Map();
-		return this.classMembersMapByScope.get(this.currentApiScope) || /* @__PURE__ */ new Map();
-	}
-	/**
-	* Get the routes map for a specific API scope
-	*/
-	getRoutesForScope(scope) {
-		if (!scope) return /* @__PURE__ */ new Map();
-		return this.apiItemRoutesByScope.get(scope) || /* @__PURE__ */ new Map();
-	}
-	/**
-	* Get the kinds map for a specific API scope
-	*/
-	getKindsForScope(scope) {
-		if (!scope) return /* @__PURE__ */ new Map();
-		return this.apiItemKindsByScope.get(scope) || /* @__PURE__ */ new Map();
-	}
-	/**
-	* Get the class members map for a specific API scope
-	*/
-	getClassMembersForScope(scope) {
-		if (!scope) return /* @__PURE__ */ new Map();
-		return this.classMembersMapByScope.get(scope) || /* @__PURE__ */ new Map();
+		return new ShikiCrossLinker(apiScope, new Map(routes), new Map(kinds), classMembersMap);
 	}
+	/** A linker that links nothing — for a scope with no documented routes. */
+	static empty = new ShikiCrossLinker("", /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
 	/**
 	* Transform a finalized HAST tree to add cross-links to type references.
 	*
@@ -145,162 +98,28 @@ var ShikiCrossLinker = class {
 	* positions before we add anchor links.
 	*
 	* @param hast - The finalized HAST root node from Shiki
-	* @param apiScope - Optional API scope to use for lookups. If not provided, uses currentApiScope.
 	* @returns The transformed HAST with cross-links added
 	*
+	* @remarks
+	* There is no scope parameter. A linker IS a scope — the caller picks the
+	* right instance (from the `VfsRegistry` entry for the page's scope) rather
+	* than picking the right argument. The parameter it replaces was optional
+	* and fell back to a mutable `currentApiScope`, so omitting it linked
+	* against whichever package happened to render last.
+	*
 	* @example
 	* ```ts
 	* const hast = await highlighter.codeToHast(code, { transformers: [twoslashTransformer] });
-	* const linkedHast = crossLinker.transformHast(hast, "my-api");
+	* const linkedHast = crossLinker.transformHast(hast);
 	* ```
 	*/
-	transformHast(hast, apiScope) {
-		const effectiveScope = apiScope ?? this.currentApiScope;
-		return this.transformRootWithScope(hast, effectiveScope);
+	transformHast(hast) {
+		return this.transformRoot(hast);
 	}
-	/**
-	* Transform the root node of the syntax tree with explicit scope
-	*/
-	transformRootWithScope(node, scope) {
-		const apiItemRoutes = this.getRoutesForScope(scope);
-		const apiItemKinds = this.getKindsForScope(scope);
-		const classMembersMap = this.getClassMembersForScope(scope);
-		const scopeStack = [];
-		const preElement = node.children.find((child) => child.type === "element" && child.tagName === "pre");
-		if (preElement?.type !== "element") return node;
-		const codeElement = preElement.children.find((child) => child.type === "element" && child.tagName === "code");
-		if (codeElement?.type !== "element") return node;
-		for (const lineElement of codeElement.children) {
-			if (lineElement.type !== "element" || lineElement.tagName !== "span") continue;
-			const getText = (node) => {
-				if (node.type === "text") return node.value;
-				if (node.type === "element") return node.children.map(getText).join("");
-				return "";
-			};
-			const lineText = lineElement.children.map(getText).join("");
-			const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
-			if (currentScope) {
-				const members = classMembersMap.get(currentScope);
-				if (members) for (const spanElement of lineElement.children) {
-					if (spanElement.type !== "element" || spanElement.tagName !== "span") continue;
-					if (spanElement.children?.length !== 1) continue;
-					const textNode = spanElement.children[0];
-					if (textNode.type !== "text") continue;
-					const rawContent = textNode.value;
-					const content = rawContent.trim();
-					if (!content) continue;
-					if (members.includes(content)) {
-						const fullMemberName = `${currentScope}.${content}`;
-						const memberRoute = apiItemRoutes.get(fullMemberName);
-						if (memberRoute) {
-							const memberKind = apiItemKinds.get(fullMemberName);
-							const memberSemanticClass = memberKind ? this.getSemanticClass(memberKind) : null;
-							const leadingSpace = rawContent.match(/^\s*/)?.[0] || "";
-							const trailingSpace = rawContent.match(/\s*$/)?.[0] || "";
-							const classNames = ["api-type-link"];
-							if (memberSemanticClass) classNames.push(memberSemanticClass);
-							const newChildren = [];
-							if (leadingSpace) newChildren.push({
-								type: "text",
-								value: leadingSpace
-							});
-							newChildren.push({
-								type: "element",
-								tagName: "a",
-								properties: {
-									href: memberRoute,
-									class: classNames.join(" ")
-								},
-								children: [{
-									type: "text",
-									value: content
-								}]
-							});
-							if (trailingSpace) newChildren.push({
-								type: "text",
-								value: trailingSpace
-							});
-							spanElement.children = newChildren;
-							spanElement.properties = {
-								...spanElement.properties,
-								"data-api-processed": "true"
-							};
-						}
-					}
-				}
-			}
-			const classMatch = lineText.match(/(?:class|interface|namespace)\s+(\w+)\s*(?:<[^>]*>)?\s*(?:extends|implements)?[^{]*\{/);
-			if (classMatch) {
-				if ((lineText.match(/\{/g) || []).length > (lineText.match(/\}/g) || []).length) scopeStack.push(classMatch[1]);
-			}
-			const openBraces = (lineText.match(/\{/g) || []).length;
-			const excessCloses = (lineText.match(/\}/g) || []).length - openBraces;
-			for (let i = 0; i < excessCloses && scopeStack.length > 0; i++) scopeStack.pop();
-		}
-		const findTwoslashSpans = (element) => {
-			const results = [];
-			if (element.properties?.class && String(element.properties.class).includes("twoslash-hover")) results.push(element);
-			if (element.children) {
-				for (const child of element.children) if (child.type === "element") results.push(...findTwoslashSpans(child));
-			}
-			return results;
-		};
-		const twoslashSpans = findTwoslashSpans(codeElement);
-		for (const twoslashSpan of twoslashSpans) {
-			if (twoslashSpan.properties?.["data-api-processed"] === "true") continue;
-			const methodInfo = this.extractMethodInfoFromTwoslashTooltip(twoslashSpan);
-			if (!methodInfo) continue;
-			const { className, methodName } = methodInfo;
-			const fullMemberName = `${className}.${methodName}`;
-			const memberRoute = apiItemRoutes.get(fullMemberName);
-			if (!memberRoute) continue;
-			const memberKind = apiItemKinds.get(fullMemberName);
-			const memberSemanticClass = memberKind ? this.getSemanticClass(memberKind) : null;
-			const memberClassNames = ["api-type-link"];
-			if (memberSemanticClass) memberClassNames.push(memberSemanticClass);
-			const textContent = this.extractTextFromTwoslash(twoslashSpan);
-			if (!textContent) continue;
-			this.wrapTwoslashTextInAnchor(twoslashSpan, textContent.trim(), memberRoute, memberClassNames);
-			twoslashSpan.properties = {
-				...twoslashSpan.properties,
-				"data-api-processed": "true"
-			};
-		}
-		const typeNames = Array.from(apiItemRoutes.keys()).filter((name) => !name.includes(".")).sort((a, b) => b.length - a.length);
-		if (typeNames.length > 0) {
-			for (const twoslashSpan of twoslashSpans) {
-				if (twoslashSpan.properties?.["data-api-processed"] === "true") continue;
-				const text = this.extractTextFromTwoslash(twoslashSpan);
-				if (!text) continue;
-				const content = text.trim();
-				const route = apiItemRoutes.get(content);
-				if (!route) continue;
-				const kind = apiItemKinds.get(content);
-				const semanticClass = kind ? this.getSemanticClass(kind) : null;
-				const classNames = ["api-type-link"];
-				if (semanticClass) classNames.push(semanticClass);
-				this.wrapTwoslashTextInAnchor(twoslashSpan, content, route, classNames);
-				twoslashSpan.properties = {
-					...twoslashSpan.properties,
-					"data-api-processed": "true"
-				};
-			}
-			const escapedNames = typeNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-			const typePattern = new RegExp(`\\b(${escapedNames.join("|")})\\b`, "g");
-			for (const lineElement of codeElement.children) {
-				if (lineElement.type !== "element" || lineElement.tagName !== "span") continue;
-				this.linkTypeReferencesInLine(lineElement, typePattern, apiItemRoutes, apiItemKinds);
-			}
-		}
-		return node;
-	}
-	/**
-	* Transform the root node of the syntax tree
-	*/
 	transformRoot(node) {
-		const apiItemRoutes = this.getRoutesForCurrentScope();
-		const apiItemKinds = this.getKindsForCurrentScope();
-		const classMembersMap = this.getClassMembersForCurrentScope();
+		const apiItemRoutes = this.apiItemRoutes;
+		const apiItemKinds = this.apiItemKinds;
+		const classMembersMap = this.classMembersMap;
 		const scopeStack = [];
 		const preElement = node.children.find((child) => child.type === "element" && child.tagName === "pre");
 		if (preElement?.type !== "element") return node;
@@ -434,9 +253,9 @@ var ShikiCrossLinker = class {
 	* Transform a line element
 	*/
 	transformLine(node) {
-		const apiItemRoutes = this.getRoutesForCurrentScope();
-		const apiItemKinds = this.getKindsForCurrentScope();
-		const classMembersMap = this.getClassMembersForCurrentScope();
+		const apiItemRoutes = this.apiItemRoutes;
+		const apiItemKinds = this.apiItemKinds;
+		const classMembersMap = this.classMembersMap;
 		if (!node.children) return;
 		for (let i = 0; i < node.children.length; i++) {
 			const child = node.children[i];
@@ -521,8 +340,8 @@ var ShikiCrossLinker = class {
 	* Transform a span element
 	*/
 	transformSpan(node, _line, _col) {
-		const apiItemRoutes = this.getRoutesForCurrentScope();
-		const apiItemKinds = this.getKindsForCurrentScope();
+		const apiItemRoutes = this.apiItemRoutes;
+		const apiItemKinds = this.apiItemKinds;
 		if (node.properties?.["data-api-processed"] === "true") return;
 		const firstChild = node.children?.[0];
 		if (firstChild && firstChild.type === "element" && firstChild.tagName === "a") return;

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

@@ -0,0 +1,48 @@
+//#region src/twoslash-access.ts
+/** The uninstalled state: no environments, so nothing to hand out. */
+const NOT_INSTALLED = {
+	transformerFor: () => null,
+	setCurrentFile: () => {}
+};
+let current = NOT_INSTALLED;
+/**
+* Bind the render pass to this build's environments.
+*
+* @remarks
+* Called from `plugin.ts`'s Effect program, beside the other seam wiring, and
+* NOT from `ConfigService.layer` — config resolution should compute a value, not
+* also mutate module state on the side.
+*/
+function installTwoslashAccess(environments) {
+	current = environments;
+}
+/**
+* Reset to the uninstalled state.
+*
+* @remarks
+* Called at the start of every build, next to `VfsRegistry.clear()`, for the
+* same reason that call exists: a dev HMR session reuses the process, so a
+* holder from the previous build would otherwise outlive it and hand the
+* render pass transformers built against declarations that have since changed.
+*/
+function clearTwoslashAccess() {
+	current = NOT_INSTALLED;
+}
+/**
+* The transformer for a scope, for the remark plugins.
+*
+* @returns `null` when nothing is installed — an inert build, which registers
+* no environments at all. A `with-api` fence still renders; it just renders
+* without type information, which is the honest answer when the build
+* documents no API.
+*/
+function twoslashTransformerFor(apiScope) {
+	return current.transformerFor(apiScope);
+}
+/** Attribute subsequent Twoslash diagnostics to a source file. */
+function setTwoslashFile(path) {
+	current.setCurrentFile(path);
+}
+
+//#endregion
+export { clearTwoslashAccess, installTwoslashAccess, setTwoslashFile, twoslashTransformerFor };