@tsdoctor/registry 0.2.1 → 0.3.0

package/README.md

@@ -5,11 +5,11 @@
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
 [![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-TypeScript virtual file systems for Effect: fetch, cache and resolve type definitions from npm via the jsDelivr CDN, and build `@typescript/vfs` environments for Twoslash-style documentation tooling.
+External TypeScript type loading for Effect: fetch, cache and resolve type definitions from npm via the jsDelivr CDN into a `Vfs`, the virtual file system Twoslash-style documentation tooling type-checks against.
 
 ## Why @tsdoctor/registry
 
-Documentation tooling that typechecks code samples needs the declaration files for whatever packages those samples import, and needs them without a real `node_modules`. Fetching them by hand means writing a CDN client, a disk cache with expiry, and a module resolver that understands `exports`, `typesVersions` and the legacy `types` field. This package is those three things behind one service, with typed errors and no hidden IO — every filesystem, HTTP and database dependency is provided by you at the edge.
+Documentation tooling that typechecks code samples needs the declaration files for whatever packages those samples import, and needs them without a real `node_modules`. Fetching them by hand means writing a CDN client, a disk cache with expiry, and a module resolver that understands `exports`, `typesVersions` and the legacy `types` field. This package is those three things behind one service, with typed errors and no hidden IO — every filesystem, HTTP and database dependency is provided by you at the edge. What it produces is a `Vfs` from [`@tsdoctor/vfs`](../vfs), which also owns the virtual-package and `@typescript/vfs` environment primitives — this package fills a VFS, it does not define one.
 
 ## Install
 
@@ -21,13 +21,11 @@ npm install @tsdoctor/registry effect @effect/platform-node @effected/store @eff
 pnpm add @tsdoctor/registry effect @effect/platform-node @effected/store @effected/semver
 ```
 
-Requires Node.js >=24.11.0. Those four peers are required. The rest are optional and pull in only with the feature that uses them:
+Requires Node.js >=24.11.0. Those four peers are required. `@effected/xdg` is optional and pulls in only with the feature that uses it:
 
 ```bash
 # for TypeCache.layerXdg
 npm install @effected/xdg
-# for TsEnvironment.make
-npm install @effected/tsconfig-json typescript @typescript/vfs
 ```
 
 Every dependency here is a peer rather than a bundled dependency, including `@effected/semver`, whose types appear in no exported signature. That is deliberate: each `@effected/*` package pins an exact `effect` version as its own peer, so bundling one would create a second resolution site that can land on a different `effect` build than yours and fail at import. As peers they all resolve in your closure, against your `effect`.
@@ -75,10 +73,8 @@ await Effect.runPromise(program.pipe(Effect.provide(RegistryLayer)));
 - `TypeCache` — a two-plane cache: declaration files on disk, per-package metadata in an `@effected/store` `Cache` with native TTL expiry and pruning.
 - `PackageFetcher` — the jsDelivr-backed CDN client, requiring only an `HttpClient`.
 - `TypeResolver` — static resolution of import specifiers and type entry points against a package manifest, covering `exports`, `typesVersions` and legacy fields.
-- `TsEnvironment` — builds a `VirtualTypeScriptEnvironment` over a VFS from tsconfig-JSON compiler options, loading the optional `typescript` peers lazily so a consumer that never calls it never loads the compiler.
-- `VirtualPackage` — synthesizes a package from locally supplied declaration content, for API Extractor output and hand-written ambient types.
 - `RegistryEvent` and `RegistryObserver` — an opt-in, zero-cost progress channel; the library logs nothing on its own.
-- Typed errors throughout: `FetchError`, `PackageNotFoundError`, `VersionNotFoundError`, `TypeCacheError`, `BatchLoadError`, `TsEnvironmentError`.
+- Typed errors throughout: `FetchError`, `PackageNotFoundError`, `VersionNotFoundError`, `TypeCacheError`, `BatchLoadError`.
 
 ## Documentation
 

package/TypeRegistry.js

@@ -3,8 +3,8 @@ import { emit } from "./RegistryEvent.js";
 import { FetchError, PackageFetcher, PackageManifest, PackageNotFoundError, VersionNotFoundError } from "./PackageFetcher.js";
 import { TypeCache, TypeCacheMetadata } from "./TypeCache.js";
 import { TypeResolver } from "./TypeResolver.js";
-import { mergeVfs } from "./Vfs.js";
 import { Context, DateTime, Effect, Layer, Option, Schema, Semaphore } from "effect";
+import { mergeVfs } from "@tsdoctor/vfs";
 import { Range, SemVer } from "@effected/semver";
 
 //#region src/TypeRegistry.ts

package/index.d.ts

@@ -1,9 +1,8 @@
-import { Cause, Context, Duration, Effect, FileSystem, Layer, Option, Path, PlatformError, Schema } from "effect";
+import { Cause, Context, Duration, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
-import { CompilerOptions } from "@effected/tsconfig-json";
-import { VirtualTypeScriptEnvironment } from "@typescript/vfs";
 import { Cache } from "@effected/store";
 import { AppDirs, AppDirsError } from "@effected/xdg";
+import { Vfs } from "@tsdoctor/vfs";
 //#region src/PackageSpec.d.ts
 declare const PackageSpec_base: Schema.Class<PackageSpec, Schema.Struct<{
   /** The npm package name (e.g. `"zod"`, `"@effect/schema"`). */
@@ -365,132 +364,6 @@ declare class RegistryObserver extends RegistryObserver_base {
   static readonly layerNoop: Layer.Layer<RegistryObserver>;
 }
 //#endregion
-//#region src/Vfs.d.ts
-/**
- * The package's currency type: a virtual file system mapping
- * `node_modules/`-prefixed paths to file contents.
- */
-/**
- * A virtual file system: file paths (prefixed `node_modules/<package>/`)
- * mapped to their string contents.
- *
- * @remarks
- * This is the value every loading operation produces and every TypeScript
- * integration consumes. Maps from multiple packages merge with {@link mergeVfs};
- * `@typescript/vfs` consumes the merged map directly (see `TsEnvironment`).
- *
- * @public
- */
-type Vfs = Map<string, string>;
-/**
- * The v3 name for {@link Vfs}, kept as an alias for the consumer migration.
- *
- * @public
- */
-type VirtualFileSystem = Vfs;
-/**
- * Merge VFS maps left to right into a new map; later entries win on path
- * collisions.
- *
- * @example
- * ```ts
- * import { mergeVfs } from "@tsdoctor/registry";
- *
- * const combined = mergeVfs(vfsA, vfsB);
- * ```
- *
- * @public
- */
-declare const mergeVfs: (...maps: ReadonlyArray<ReadonlyMap<string, string>>) => Vfs;
-/**
- * Prefix every path in `entries` with `node_modules/<name>/`, normalizing
- * away leading slashes.
- *
- * @public
- */
-declare const prefixVfs: (name: string, entries: ReadonlyMap<string, string>) => Vfs;
-//#endregion
-//#region src/TsEnvironment.d.ts
-declare const TsEnvironmentError_base: Schema.Class<TsEnvironmentError, Schema.TaggedStruct<"TsEnvironmentError", {
-  /** The underlying failure, preserved structurally. */
-  readonly cause: Schema.Defect;
-}>, import("effect/Cause").YieldableError>;
-/**
- * Raised when building a virtual TypeScript environment fails — including
- * when the optional `typescript` / `@typescript/vfs` /
- * `@effected/tsconfig-json` peers are not installed.
- *
- * @public
- */
-declare class TsEnvironmentError extends TsEnvironmentError_base {
-  get message(): string;
-}
-/**
- * Options for {@link TsEnvironment.make}.
- *
- * @public
- */
-interface TsEnvironmentOptions {
-  /** The virtual file system to typecheck against. */
-  readonly vfs: Vfs;
-  /**
-   * Compiler options for the language service, in tsconfig JSON form
-   * (`{ target: "es2022" }`, not `ts.ScriptTarget.ES2022`). Enum-valued
-   * fields are converted to the compiler's numeric enums internally, so this
-   * type has no dependency on the `typescript` package.
-   */
-  readonly compilerOptions: CompilerOptions.Type;
-  /**
-   * The directory VFS paths are rooted under and the filesystem fallback
-   * root. Defaults to `process.cwd()` (which v3 hardcoded).
-   */
-  readonly projectRoot?: string;
-}
-/**
- * The `@typescript/vfs` seam: builds a `VirtualTypeScriptEnvironment` over a
- * {@link Vfs} plus the TypeScript default lib files.
- *
- * @remarks
- * The ONLY module touching the optional `typescript` / `@typescript/vfs` /
- * `@effected/tsconfig-json` peers, and it loads all three lazily inside
- * {@link TsEnvironment.make} — a consumer that never calls it never loads
- * the compiler, and a missing peer fails typed as
- * {@link TsEnvironmentError} instead of crashing at import time. Keep every
- * one of them behind that dynamic `import()`: a static value import here is
- * reachable from `index.ts`, so it would turn an omitted optional peer into
- * an `ERR_MODULE_NOT_FOUND` on the entry graph for consumers who never
- * touch this module. Only the type-only `CompilerOptions` import is safe
- * statically, because it erases. The underlying `createDefaultMapFromNodeModules` /
- * `createFSBackedSystem` read the real filesystem through TypeScript's own
- * `sys`, outside the Effect `FileSystem` service — accepted and documented;
- * this module is why the package is integrated tier on its own surface.
- *
- * No cache map (v3's `createTypeScriptCache` returned a one-entry `Map`
- * keyed by `JSON.stringify(compilerOptions)`): a consumer that wants keyed
- * reuse holds its own map.
- *
- * `VirtualTypeScriptEnvironment` is deliberately not re-exported — import
- * the type from `@typescript/vfs`, which consumers of this module already
- * declare.
- *
- * @example
- * ```ts
- * import { TsEnvironment } from "@tsdoctor/registry";
- *
- * const environment = TsEnvironment.make({
- *   vfs,
- *   compilerOptions: { strict: true, target: "es2022" },
- * });
- * ```
- *
- * @public
- */
-declare class TsEnvironment {
-  private constructor();
-  /** Build a `VirtualTypeScriptEnvironment` over a {@link Vfs}. */
-  static make(options: TsEnvironmentOptions): Effect.Effect<VirtualTypeScriptEnvironment, TsEnvironmentError>;
-}
-//#endregion
 //#region src/TypeCache.d.ts
 declare const TypeCacheMetadata_base: Schema.Class<TypeCacheMetadata, Schema.Struct<{
   /** The pinned version the files on disk belong to. */
@@ -629,7 +502,7 @@ interface TypeCacheShape {
   readonly readMetadata: (pkg: PackageSpec) => Effect.Effect<Option.Option<TypeCacheMetadata>, TypeCacheError>;
   /** Write the package's metadata entry, forwarding its `ttl` to the store. */
   readonly writeMetadata: (pkg: PackageSpec, metadata: TypeCacheMetadata) => Effect.Effect<void, TypeCacheError>;
-  /** Build the package's {@link Vfs}: every cached file keyed `node_modules/<name>/<path>`. */
+  /** Build the package's `Vfs`: every cached file keyed `node_modules/<name>/<path>`. */
   readonly getVfs: (pkg: PackageSpec) => Effect.Effect<Vfs, TypeCacheError>;
   /**
    * Remove the package: metadata first, then files.
@@ -842,7 +715,7 @@ interface TypeRegistryShape {
     readonly ttl?: Duration.Duration;
   }) => Effect.Effect<void, FetchError | PackageNotFoundError | TypeCacheError>;
   /**
-   * Build the {@link Vfs} for one package, fetching it first when missing or
+   * Build the `Vfs` for one package, fetching it first when missing or
    * stale (the stale-vs-miss ladder: live metadata → hit; files on disk with
    * no live metadata → stale, refetched when `autoFetch`, served as-is
    * otherwise; nothing → miss, fetched or failed typed on
@@ -850,7 +723,7 @@ interface TypeRegistryShape {
    */
   readonly getPackageVfs: (pkg: PackageSpec, options?: PackageVfsOptions) => Effect.Effect<Vfs, FetchError | PackageNotFoundError | TypeCacheError>;
   /**
-   * Build a merged {@link Vfs} for several packages, best-effort.
+   * Build a merged `Vfs` for several packages, best-effort.
    *
    * @remarks
    * Loads concurrently (limit 5), accumulates per-package failures, merges
@@ -912,79 +785,5 @@ declare class TypeRegistry extends TypeRegistry_base {
   static readonly layer: Layer.Layer<TypeRegistry, never, TypeCache | PackageFetcher>;
 }
 //#endregion
-//#region src/VirtualPackage.d.ts
-declare const VirtualPackage_base: Schema.Class<VirtualPackage, Schema.Struct<{
-  /** The package name (e.g. `"@my-org/api-types"`). */
-  readonly name: Schema.String;
-  /** The package version. */
-  readonly version: Schema.String;
-  /** Entry file names (e.g. `"index.d.ts"`) mapped to declaration source. */
-  readonly entries: Schema.$ReadonlyMap<Schema.String, Schema.String>;
-}>, {}>;
-/**
- * A synthetic npm package built from locally supplied TypeScript declaration
- * content, for inclusion in a {@link Vfs} without fetching from the CDN.
- *
- * @remarks
- * Useful when you have locally generated `.d.ts` files — API Extractor
- * output, hand-written ambient declarations — and want them in the same VFS
- * `TypeRegistry` builds from remote packages. Instances are transient: they
- * are never persisted to the disk cache.
- *
- * The class is deliberately subclass-friendly (the rspress consumer extends
- * it): construct via `VirtualPackage.make(...)` or the statics, and extend
- * with `class Mine extends VirtualPackage { ... }`.
- *
- * @example
- * ```ts
- * import { VirtualPackage } from "@tsdoctor/registry";
- *
- * const pkg = VirtualPackage.create("@my-org/api-types", "1.0.0", "export interface User { id: string }");
- * const vfs = pkg.toVfs();
- * // node_modules/@my-org/api-types/package.json, node_modules/@my-org/api-types/index.d.ts
- * ```
- *
- * @public
- */
-declare class VirtualPackage extends VirtualPackage_base {
-  /**
-   * Single-entry factory: a virtual package whose sole entry point is
-   * `index.d.ts`.
-   */
-  static create(name: string, version: string, declarations: string): VirtualPackage;
-  /**
-   * Multi-entry factory: one `.d.ts` per entry point, exposed through a
-   * synthetic `exports` map.
-   *
-   * @remarks
-   * An empty entries map is developer wiring, not input — it would produce a
-   * package whose `types` points at a file that does not exist — so it
-   * throws at construction (defect posture), as does an entry set whose
-   * names collide after extension normalization (see
-   * {@link VirtualPackage.toVfs}).
-   */
-  static createMultiEntry(name: string, version: string, entries: ReadonlyMap<string, string>): VirtualPackage;
-  /**
-   * Load a single `.d.ts` file from disk as a virtual package with one
-   * `index.d.ts` entry.
-   *
-   * @remarks
-   * Reads through the platform-agnostic `FileSystem` service; the
-   * `PlatformError` surfaces typed.
-   */
-  static fromFile(name: string, version: string, filePath: string): Effect.Effect<VirtualPackage, PlatformError.PlatformError, FileSystem.FileSystem>;
-  /**
-   * The package's {@link Vfs}: a synthetic `package.json` plus every entry
-   * file, each path prefixed `node_modules/<name>/`.
-   *
-   * @remarks
-   * The `package.json` uses `types` for a single entry and an `exports` map
-   * for multiple entries, so TypeScript module resolution works against the
-   * generated VFS.
-   */
-  toVfs(): Vfs;
-  private toPackageJson;
-}
-//#endregion
-export { BatchLoadError, type CachePruneResult, FetchError, PackageFetcher, type PackageFetcherShape, PackageManifest, PackageNotFoundError, PackageSpec, type PackageVersions, type PackageVfsOptions, RegistryEvent, RegistryObserver, type RegistryObserverShape, ResolvedModule, TsEnvironment, TsEnvironmentError, type TsEnvironmentOptions, TypeCache, TypeCacheError, TypeCacheMetadata, type TypeCacheShape, TypeRegistry, type TypeRegistryShape, TypeResolver, VersionNotFoundError, type Vfs, type VirtualFileSystem, VirtualPackage, mergeVfs, prefixVfs };
+export { BatchLoadError, type CachePruneResult, FetchError, PackageFetcher, type PackageFetcherShape, PackageManifest, PackageNotFoundError, PackageSpec, type PackageVersions, type PackageVfsOptions, RegistryEvent, RegistryObserver, type RegistryObserverShape, ResolvedModule, TypeCache, TypeCacheError, TypeCacheMetadata, type TypeCacheShape, TypeRegistry, type TypeRegistryShape, TypeResolver, VersionNotFoundError };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,11 +1,8 @@
 import { RegistryEvent, RegistryObserver } from "./RegistryEvent.js";
 import { FetchError, PackageFetcher, PackageManifest, PackageNotFoundError, VersionNotFoundError } from "./PackageFetcher.js";
 import { PackageSpec } from "./PackageSpec.js";
-import { TsEnvironment, TsEnvironmentError } from "./TsEnvironment.js";
 import { TypeCache, TypeCacheError, TypeCacheMetadata } from "./TypeCache.js";
 import { ResolvedModule, TypeResolver } from "./TypeResolver.js";
-import { mergeVfs, prefixVfs } from "./Vfs.js";
 import { BatchLoadError, TypeRegistry } from "./TypeRegistry.js";
-import { VirtualPackage } from "./VirtualPackage.js";
 
-export { BatchLoadError, FetchError, PackageFetcher, PackageManifest, PackageNotFoundError, PackageSpec, RegistryEvent, RegistryObserver, ResolvedModule, TsEnvironment, TsEnvironmentError, TypeCache, TypeCacheError, TypeCacheMetadata, TypeRegistry, TypeResolver, VersionNotFoundError, VirtualPackage, mergeVfs, prefixVfs };
+export { BatchLoadError, FetchError, PackageFetcher, PackageManifest, PackageNotFoundError, PackageSpec, RegistryEvent, RegistryObserver, ResolvedModule, TypeCache, TypeCacheError, TypeCacheMetadata, TypeRegistry, TypeResolver, VersionNotFoundError };

package/internal/resolution.js

@@ -1,3 +1,5 @@
+import { isTypeDefinition } from "@tsdoctor/vfs";
+
 //#region src/internal/resolution.ts
 /**
 * Exports-map resolution machinery. Every input here — `exports` values,
@@ -13,8 +15,6 @@ const DUNDER_KEYS = /* @__PURE__ */ new Set([
 	"constructor",
 	"prototype"
 ]);
-/** Whether a path names a TypeScript declaration file. */
-const isTypeDefinition = (filePath) => filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts");
 /** Normalize backslashes to forward slashes. */
 const normalizePath = (path) => path.replace(/\\/g, "/");
 /**

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@tsdoctor/registry",
-	"version": "0.2.1",
+	"version": "0.3.0",
 	"private": false,
-	"description": "TypeScript virtual file systems for Effect: fetch, cache and resolve type definitions from npm via the jsDelivr CDN, and build @typescript/vfs environments for Twoslash-style documentation tooling.",
+	"description": "External TypeScript type loading for Effect: fetch, cache and resolve type definitions from npm via the jsDelivr CDN into a virtual file system.",
 	"keywords": [
 		"typescript",
 		"vfs",
@@ -37,28 +37,19 @@
 		},
 		"./package.json": "./package.json"
 	},
+	"dependencies": {
+		"@tsdoctor/vfs": "0.1.0"
+	},
 	"peerDependencies": {
 		"@effect/platform-node": "4.0.0-rc.109",
 		"@effected/semver": "^0.5.0",
-		"@effected/store": "^0.5.0",
-		"@effected/tsconfig-json": "^0.6.0",
+		"@effected/store": "^0.6.0",
 		"@effected/xdg": "^0.3.0",
-		"@typescript/vfs": "^1.6.4",
-		"effect": "4.0.0-rc.109",
-		"typescript": "^6.0.3"
+		"effect": "4.0.0-rc.109"
 	},
 	"peerDependenciesMeta": {
-		"@effected/tsconfig-json": {
-			"optional": true
-		},
 		"@effected/xdg": {
 			"optional": true
-		},
-		"@typescript/vfs": {
-			"optional": true
-		},
-		"typescript": {
-			"optional": true
 		}
 	},
 	"engines": {

package/TsEnvironment.js

@@ -1,95 +0,0 @@
-import { isTypeDefinition } from "./internal/resolution.js";
-import { Effect, Schema } from "effect";
-
-//#region src/TsEnvironment.ts
-/**
-* Raised when building a virtual TypeScript environment fails — including
-* when the optional `typescript` / `@typescript/vfs` /
-* `@effected/tsconfig-json` peers are not installed.
-*
-* @public
-*/
-var TsEnvironmentError = class extends Schema.TaggedError()("TsEnvironmentError", { 
-/** The underlying failure, preserved structurally. */
-cause: Schema.Defect() }) {
-	get message() {
-		return "Failed to create the virtual TypeScript environment";
-	}
-};
-/**
-* The `@typescript/vfs` seam: builds a `VirtualTypeScriptEnvironment` over a
-* {@link Vfs} plus the TypeScript default lib files.
-*
-* @remarks
-* The ONLY module touching the optional `typescript` / `@typescript/vfs` /
-* `@effected/tsconfig-json` peers, and it loads all three lazily inside
-* {@link TsEnvironment.make} — a consumer that never calls it never loads
-* the compiler, and a missing peer fails typed as
-* {@link TsEnvironmentError} instead of crashing at import time. Keep every
-* one of them behind that dynamic `import()`: a static value import here is
-* reachable from `index.ts`, so it would turn an omitted optional peer into
-* an `ERR_MODULE_NOT_FOUND` on the entry graph for consumers who never
-* touch this module. Only the type-only `CompilerOptions` import is safe
-* statically, because it erases. The underlying `createDefaultMapFromNodeModules` /
-* `createFSBackedSystem` read the real filesystem through TypeScript's own
-* `sys`, outside the Effect `FileSystem` service — accepted and documented;
-* this module is why the package is integrated tier on its own surface.
-*
-* No cache map (v3's `createTypeScriptCache` returned a one-entry `Map`
-* keyed by `JSON.stringify(compilerOptions)`): a consumer that wants keyed
-* reuse holds its own map.
-*
-* `VirtualTypeScriptEnvironment` is deliberately not re-exported — import
-* the type from `@typescript/vfs`, which consumers of this module already
-* declare.
-*
-* @example
-* ```ts
-* import { TsEnvironment } from "@tsdoctor/registry";
-*
-* const environment = TsEnvironment.make({
-*   vfs,
-*   compilerOptions: { strict: true, target: "es2022" },
-* });
-* ```
-*
-* @public
-*/
-var TsEnvironment = class {
-	constructor() {}
-	/** Build a `VirtualTypeScriptEnvironment` over a {@link Vfs}. */
-	static make(options) {
-		return Effect.gen(function* () {
-			const [tsModule, tsVfs, { TsEnumCodec }] = yield* Effect.tryPromise({
-				try: () => Promise.all([
-					import("typescript"),
-					import("@typescript/vfs"),
-					import("@effected/tsconfig-json")
-				]),
-				catch: (cause) => new TsEnvironmentError({ cause })
-			});
-			return yield* Effect.try({
-				try: () => {
-					const typescript = tsModule.default;
-					const projectRoot = options.projectRoot ?? process.cwd();
-					const compilerOptions = TsEnumCodec.encodeCompilerOptions(options.compilerOptions);
-					const executing = typescript.sys?.getExecutingFilePath?.();
-					const libDirectory = executing === void 0 ? void 0 : executing.slice(0, Math.max(executing.lastIndexOf("/"), executing.lastIndexOf("\\")));
-					const system = new Map(tsVfs.createDefaultMapFromNodeModules(compilerOptions, typescript, libDirectory));
-					const rootFiles = [];
-					for (const [path, content] of options.vfs) {
-						const rooted = path.startsWith("/") ? path : `${projectRoot}/${path}`;
-						system.set(rooted, content);
-						if (isTypeDefinition(rooted)) rootFiles.push(rooted);
-					}
-					const sys = tsVfs.createFSBackedSystem(system, projectRoot, typescript, libDirectory);
-					return tsVfs.createVirtualTypeScriptEnvironment(sys, rootFiles, typescript, compilerOptions);
-				},
-				catch: (cause) => new TsEnvironmentError({ cause })
-			});
-		}).pipe(Effect.withSpan("TsEnvironment.make"));
-	}
-};
-
-//#endregion
-export { TsEnvironment, TsEnvironmentError };

package/Vfs.js

@@ -1,33 +0,0 @@
-//#region src/Vfs.ts
-/**
-* Merge VFS maps left to right into a new map; later entries win on path
-* collisions.
-*
-* @example
-* ```ts
-* import { mergeVfs } from "@tsdoctor/registry";
-*
-* const combined = mergeVfs(vfsA, vfsB);
-* ```
-*
-* @public
-*/
-const mergeVfs = (...maps) => {
-	const out = /* @__PURE__ */ new Map();
-	for (const map of maps) for (const [path, content] of map) out.set(path, content);
-	return out;
-};
-/**
-* Prefix every path in `entries` with `node_modules/<name>/`, normalizing
-* away leading slashes.
-*
-* @public
-*/
-const prefixVfs = (name, entries) => {
-	const out = /* @__PURE__ */ new Map();
-	for (const [path, content] of entries) out.set(`node_modules/${name}/${path.replace(/^\/+/, "")}`, content);
-	return out;
-};
-
-//#endregion
-export { mergeVfs, prefixVfs };

package/VirtualPackage.js

@@ -1,126 +0,0 @@
-import { Effect, FileSystem, Schema } from "effect";
-
-//#region src/VirtualPackage.ts
-/**
-* A synthetic npm package built from locally supplied TypeScript declaration
-* content, for inclusion in a {@link Vfs} without fetching from the CDN.
-*
-* @remarks
-* Useful when you have locally generated `.d.ts` files — API Extractor
-* output, hand-written ambient declarations — and want them in the same VFS
-* `TypeRegistry` builds from remote packages. Instances are transient: they
-* are never persisted to the disk cache.
-*
-* The class is deliberately subclass-friendly (the rspress consumer extends
-* it): construct via `VirtualPackage.make(...)` or the statics, and extend
-* with `class Mine extends VirtualPackage { ... }`.
-*
-* @example
-* ```ts
-* import { VirtualPackage } from "@tsdoctor/registry";
-*
-* const pkg = VirtualPackage.create("@my-org/api-types", "1.0.0", "export interface User { id: string }");
-* const vfs = pkg.toVfs();
-* // node_modules/@my-org/api-types/package.json, node_modules/@my-org/api-types/index.d.ts
-* ```
-*
-* @public
-*/
-var VirtualPackage = class VirtualPackage extends Schema.Class("VirtualPackage")({
-	/** The package name (e.g. `"@my-org/api-types"`). */
-	name: Schema.String,
-	/** The package version. */
-	version: Schema.String,
-	/** Entry file names (e.g. `"index.d.ts"`) mapped to declaration source. */
-	entries: Schema.ReadonlyMap(Schema.String, Schema.String)
-}) {
-	/**
-	* Single-entry factory: a virtual package whose sole entry point is
-	* `index.d.ts`.
-	*/
-	static create(name, version, declarations) {
-		return VirtualPackage.make({
-			name,
-			version,
-			entries: /* @__PURE__ */ new Map([["index.d.ts", declarations]])
-		});
-	}
-	/**
-	* Multi-entry factory: one `.d.ts` per entry point, exposed through a
-	* synthetic `exports` map.
-	*
-	* @remarks
-	* An empty entries map is developer wiring, not input — it would produce a
-	* package whose `types` points at a file that does not exist — so it
-	* throws at construction (defect posture), as does an entry set whose
-	* names collide after extension normalization (see
-	* {@link VirtualPackage.toVfs}).
-	*/
-	static createMultiEntry(name, version, entries) {
-		if (entries.size === 0) throw new Error(`VirtualPackage.createMultiEntry: "${name}" needs at least one entry file`);
-		return VirtualPackage.make({
-			name,
-			version,
-			entries
-		});
-	}
-	/**
-	* Load a single `.d.ts` file from disk as a virtual package with one
-	* `index.d.ts` entry.
-	*
-	* @remarks
-	* Reads through the platform-agnostic `FileSystem` service; the
-	* `PlatformError` surfaces typed.
-	*/
-	static fromFile(name, version, filePath) {
-		return Effect.gen(function* () {
-			const content = yield* (yield* FileSystem.FileSystem).readFileString(filePath);
-			return VirtualPackage.create(name, version, content);
-		}).pipe(Effect.withSpan("VirtualPackage.fromFile"));
-	}
-	/**
-	* The package's {@link Vfs}: a synthetic `package.json` plus every entry
-	* file, each path prefixed `node_modules/<name>/`.
-	*
-	* @remarks
-	* The `package.json` uses `types` for a single entry and an `exports` map
-	* for multiple entries, so TypeScript module resolution works against the
-	* generated VFS.
-	*/
-	toVfs() {
-		const vfs = /* @__PURE__ */ new Map();
-		const prefix = `node_modules/${this.name}`;
-		vfs.set(`${prefix}/package.json`, this.toPackageJson());
-		for (const [fileName, content] of this.entries) {
-			if (fileName === "package.json") throw new Error(`VirtualPackage: "${this.name}" cannot define package.json as an entry`);
-			vfs.set(`${prefix}/${fileName}`, content);
-		}
-		return vfs;
-	}
-	toPackageJson() {
-		if (this.entries.size === 0) throw new Error(`VirtualPackage: "${this.name}" has no entry files — nothing to point types at`);
-		const manifest = {
-			name: this.name,
-			version: this.version
-		};
-		if (this.entries.size === 1) {
-			const [only] = this.entries.keys();
-			manifest.types = only ?? "index.d.ts";
-		} else {
-			manifest.exports = {};
-			const sources = /* @__PURE__ */ new Map();
-			for (const fileName of this.entries.keys()) {
-				const baseName = fileName.replace(/\.d\.(m|c)?ts$/, "");
-				const key = baseName === "index" ? "." : `./${baseName}`;
-				const previous = sources.get(key);
-				if (previous !== void 0) throw new Error(`VirtualPackage: "${this.name}" entries "${previous}" and "${fileName}" both normalize to the export key "${key}"`);
-				sources.set(key, fileName);
-				manifest.exports[key] = { types: `./${fileName}` };
-			}
-		}
-		return JSON.stringify(manifest, null, 2);
-	}
-};
-
-//#endregion
-export { VirtualPackage };