@tsdoctor/registry 0.5.14 → 0.7.0

package/PackageFetcher.js

@@ -1,5 +1,5 @@
-import { MAX_TYPE_BYTES_PER_PACKAGE, MAX_TYPE_FILES_PER_PACKAGE } from "./internal/limits.js";
 import { FileTreeResponse, TYPE_FILE_PATTERN, VersionsResponse, fileTreeUrl, fileUrl, packageJsonUrl, versionsUrl } from "./internal/jsdelivr.js";
+import { MAX_TYPE_BYTES_PER_PACKAGE, MAX_TYPE_FILES_PER_PACKAGE } from "./internal/limits.js";
 import { emit } from "./RegistryEvent.js";
 import { Cause, Context, Duration, Effect, Layer, Ref, Schedule, Schema } from "effect";
 import * as HttpClient from "effect/http/HttpClient";

package/README.md

@@ -72,7 +72,7 @@ await Effect.runPromise(program.pipe(Effect.provide(RegistryLayer)));
 - `TypeRegistry` — the facade over cache, fetcher and resolver: `getVfs`, `getPackageVfs`, `fetchAndCache`, `resolveVersion`, `resolveImport`, `getTypeEntries`, `hasCached`, `clearCache`, `pruneCache`.
 - `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.
+- `TypeResolver` — static resolution of import specifiers and type entry points against a package manifest, covering `exports`, `typesVersions` and legacy fields as TypeScript reads them (via `@effected/package-json`'s `PackageExports`).
 - `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`.
 

package/TypeRegistry.js

@@ -1,6 +1,6 @@
 import { packageJsonUrl } from "./internal/jsdelivr.js";
-import { emit } from "./RegistryEvent.js";
 import { FetchError, PackageFetcher, PackageManifest, PackageNotFoundError, VersionNotFoundError } from "./PackageFetcher.js";
+import { emit } from "./RegistryEvent.js";
 import { TypeCache, TypeCacheMetadata } from "./TypeCache.js";
 import { TypeResolver } from "./TypeResolver.js";
 import { Context, DateTime, Effect, Layer, Option, Schema, Semaphore } from "effect";

package/TypeResolver.js

@@ -1,6 +1,7 @@
-import { compileWildcard, extractTypesFromExport, findMainTypePath, getExportValue, isSafeRelativePath, isTypeDefinition, normalizePath } from "./internal/resolution.js";
+import { isSafeRelativePath, isTypeDefinition, normalizePath } from "./internal/resolution.js";
 import { PackageSpec } from "./PackageSpec.js";
-import { Option, Schema } from "effect";
+import { Option, Result, Schema } from "effect";
+import { PackageExports } from "@effected/package-json";
 
 // src/TypeResolver.ts
 /**
@@ -17,11 +18,6 @@ var ResolvedModule = class extends Schema.Class("ResolvedModule")({
 	/** The package the path belongs to. */
 	package: PackageSpec
 }) {};
-const DUNDER_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
 /**
 * Build a `ResolvedModule` only when the manifest-supplied path stays inside
 * the package: resolved paths reach `PackageFetcher.downloadFile`'s URL and
@@ -38,6 +34,25 @@ const safeResolved = (filePath, pkg) => {
 	}));
 };
 /**
+* The declaration path TypeScript reads for a subpath: the first declaration
+* candidate of `@effected/package-json`'s `PackageExports.resolveTypesResult`,
+* or the manifest's own target when no candidate is a declaration file.
+*
+* @remarks
+* `Option.none()` when the manifest does not answer the subpath. Two kit
+* answers are guesses rather than manifest evidence, and are refused the
+* same way: a legacy subpath probing itself (`source: "file"`), and the
+* root falling to the implicit `index.js` when the manifest has no `main`.
+*/
+const typesPath = (manifest, subpath) => {
+	const resolved = PackageExports.resolveTypesResult(manifest, subpath);
+	if (Result.isFailure(resolved)) return Option.none();
+	const target = resolved.success;
+	if (target.source === "file") return Option.none();
+	if (target.source === "main" && manifest.main === void 0) return Option.none();
+	return Option.some(Option.getOrElse(target.declaration, () => target.target));
+};
+/**
 * Pure `package.json` → declaration-file resolution.
 *
 * @remarks
@@ -48,10 +63,14 @@ const safeResolved = (filePath, pkg) => {
 * too — it returns `Option.none()` where v3 fabricated a guessed fallback
 * path, leaving fallback policy to the caller.
 *
-* All map inputs are untrusted CDN data; the machinery underneath is depth-
-* guarded, wildcard-bounded and prototype-pollution-safe (see
-* `internal/resolution.ts`), and every resolved path is validated to stay
-* inside the package before a `ResolvedModule` is constructed.
+* Resolution is `@effected/package-json`'s `PackageExports`, TypeScript's
+* reading of a manifest: conditions are walked in the manifest's own key
+* order (`types`, `import` and `default` match), targets go through
+* TypeScript's extension substitution (`./x.js` yields `./x.d.ts`), and
+* `typesVersions` is read only when `exports` is absent. All map inputs are
+* untrusted CDN data; the kit confines every target to the package, guards
+* depth and wildcard counts and reads own keys only, and every resolved path
+* is validated again here before a `ResolvedModule` is constructed.
 *
 * @public
 */
@@ -62,12 +81,12 @@ var TypeResolver = class TypeResolver {
 	* manifest.
 	*
 	* @remarks
-	* Resolution order: the `exports` map (`types` condition, then
-	* `import`/`default`, fallback arrays in order), then `typesVersions["*"]`
-	* (exact, then bounded wildcards), then — for the root specifier only —
-	* the top-level `types`/`typings` fields. `Option.none()` when the
-	* manifest offers no evidence for the subpath, or when the evidence names
-	* a path outside the package (hostile manifest — fails closed).
+	* The specifier's subpath resolves through `exports` when present, else
+	* `typesVersions["*"]`, then — for the root — `types`/`typings` and
+	* `main`, each target extension-substituted to the declaration file
+	* TypeScript would read. `Option.none()` when the manifest offers no
+	* evidence for the subpath, or when the evidence names a path outside the
+	* package (hostile manifest — fails closed).
 	*/
 	static resolveImport(specifier, manifest, pkg) {
 		let subpath;
@@ -77,50 +96,20 @@ var TypeResolver = class TypeResolver {
 			const bare = specifier.replace(/^\/+/, "");
 			subpath = bare === "" || bare === "." ? "." : bare.startsWith("./") ? bare : `./${bare}`;
 		}
-		if (manifest.exports !== void 0) {
-			const exportValue = getExportValue(manifest.exports, subpath);
-			const typesPath = extractTypesFromExport(exportValue);
-			if (typesPath !== null) return safeResolved(typesPath, pkg);
-		}
-		if (manifest.typesVersions !== void 0 && Object.hasOwn(manifest.typesVersions, "*")) {
-			const versionMap = manifest.typesVersions["*"];
-			if (versionMap !== void 0) {
-				const lookupPath = subpath === "." ? "." : subpath.replace(/^\.\//, "");
-				if (!DUNDER_KEYS.has(lookupPath) && Object.hasOwn(versionMap, lookupPath)) {
-					const mapped = versionMap[lookupPath];
-					const first = Array.isArray(mapped) ? mapped[0] : mapped;
-					if (typeof first === "string") return safeResolved(first, pkg);
-				}
-				for (const pattern of Object.keys(versionMap)) {
-					if (DUNDER_KEYS.has(pattern) || !pattern.includes("*")) continue;
-					if (!Object.hasOwn(versionMap, pattern)) continue;
-					const regex = compileWildcard(pattern);
-					if (regex === null) continue;
-					const match = regex.exec(lookupPath);
-					if (match === null) continue;
-					const mapped = versionMap[pattern];
-					const first = Array.isArray(mapped) ? mapped[0] : mapped;
-					if (typeof first === "string") return safeResolved(first.replace(/\*/g, match[1] ?? ""), pkg);
-				}
-			}
-		}
-		if (subpath === ".") {
-			if (manifest.types !== void 0) return safeResolved(manifest.types, pkg);
-			if (manifest.typings !== void 0) return safeResolved(manifest.typings, pkg);
-		}
-		return Option.none();
+		return Option.flatMap(typesPath(manifest, subpath), (path) => safeResolved(path, pkg));
 	}
 	/**
 	* Resolve the manifest's main type entry.
 	*
 	* @remarks
-	* Total by the documented `index.d.ts` convention floor: `types`/`typings`,
-	* then the root export's types condition, then a declaration-extension
-	* swap of `main`, then `index.d.ts`. A main path that escapes the package
-	* (hostile manifest) also falls to the floor rather than surviving.
+	* The root subpath as {@link TypeResolver.resolveImport} resolves it, made
+	* total by the documented `index.d.ts` convention floor. A main path that
+	* escapes the package (hostile manifest) also falls to the floor rather
+	* than surviving.
 	*/
 	static resolveMainEntry(manifest, pkg) {
-		return Option.getOrElse(safeResolved(findMainTypePath(manifest), pkg), () => ResolvedModule.make({
+		const main = Option.flatMap(typesPath(manifest, "."), (path) => safeResolved(path, pkg));
+		return Option.getOrElse(main, () => ResolvedModule.make({
 			filePath: "index.d.ts",
 			isTypeDefinition: true,
 			package: pkg
@@ -132,24 +121,20 @@ var TypeResolver = class TypeResolver {
 	* deduplicated by file path.
 	*
 	* @remarks
-	* Wildcard export keys (`"./*"`) are skipped: enumeration has no captured
-	* segment to substitute, so a pattern entry would emit a literal
-	* `dist/*.d.ts`. Pattern subpaths resolve through
-	* {@link TypeResolver.resolveImport}, which has the concrete specifier.
-	* Entries whose paths escape the package are skipped.
+	* Subpaths come from `PackageExports.typesEntriesResult`. Pattern entries
+	* (`"./*"`) are skipped: enumeration has no captured segment to
+	* substitute, so a pattern entry would emit a literal `dist/*.d.ts`.
+	* Pattern subpaths resolve through {@link TypeResolver.resolveImport},
+	* which has the concrete specifier. An `exports` map holding an invalid
+	* target fails enumeration as a whole, leaving only the main entry.
 	*/
 	static resolveTypeEntries(manifest, pkg) {
 		const entries = [TypeResolver.resolveMainEntry(manifest, pkg)];
-		if (manifest.exports !== void 0 && typeof manifest.exports === "object" && !Array.isArray(manifest.exports)) for (const key of Object.keys(manifest.exports)) {
-			if (DUNDER_KEYS.has(key)) continue;
-			if (!key.startsWith(".")) continue;
-			if (key.includes("*")) continue;
-			if (!Object.hasOwn(manifest.exports, key)) continue;
-			const typesPath = extractTypesFromExport(manifest.exports[key]);
-			if (typesPath !== null) {
-				const entry = safeResolved(typesPath, pkg);
-				if (Option.isSome(entry)) entries.push(entry.value);
-			}
+		const enumerated = PackageExports.typesEntriesResult(manifest);
+		if (Result.isSuccess(enumerated)) for (const target of enumerated.success) {
+			if (target.pattern) continue;
+			const entry = safeResolved(Option.getOrElse(target.declaration, () => target.target), pkg);
+			if (Option.isSome(entry)) entries.push(entry.value);
 		}
 		const seen = /* @__PURE__ */ new Set();
 		return entries.filter((entry) => {

package/index.d.ts

@@ -596,10 +596,14 @@ export declare class ResolvedModule extends ResolvedModule_base {}
  * too — it returns `Option.none()` where v3 fabricated a guessed fallback
  * path, leaving fallback policy to the caller.
  *
- * All map inputs are untrusted CDN data; the machinery underneath is depth-
- * guarded, wildcard-bounded and prototype-pollution-safe (see
- * `internal/resolution.ts`), and every resolved path is validated to stay
- * inside the package before a `ResolvedModule` is constructed.
+ * Resolution is `@effected/package-json`'s `PackageExports`, TypeScript's
+ * reading of a manifest: conditions are walked in the manifest's own key
+ * order (`types`, `import` and `default` match), targets go through
+ * TypeScript's extension substitution (`./x.js` yields `./x.d.ts`), and
+ * `typesVersions` is read only when `exports` is absent. All map inputs are
+ * untrusted CDN data; the kit confines every target to the package, guards
+ * depth and wildcard counts and reads own keys only, and every resolved path
+ * is validated again here before a `ResolvedModule` is constructed.
  *
  * @public
  */
@@ -610,22 +614,22 @@ export declare class TypeResolver {
    * manifest.
    *
    * @remarks
-   * Resolution order: the `exports` map (`types` condition, then
-   * `import`/`default`, fallback arrays in order), then `typesVersions["*"]`
-   * (exact, then bounded wildcards), then — for the root specifier only —
-   * the top-level `types`/`typings` fields. `Option.none()` when the
-   * manifest offers no evidence for the subpath, or when the evidence names
-   * a path outside the package (hostile manifest — fails closed).
+   * The specifier's subpath resolves through `exports` when present, else
+   * `typesVersions["*"]`, then — for the root — `types`/`typings` and
+   * `main`, each target extension-substituted to the declaration file
+   * TypeScript would read. `Option.none()` when the manifest offers no
+   * evidence for the subpath, or when the evidence names a path outside the
+   * package (hostile manifest — fails closed).
    */
   static resolveImport(specifier: string, manifest: PackageManifest, pkg: PackageSpec): Option.Option<ResolvedModule>;
   /**
    * Resolve the manifest's main type entry.
    *
    * @remarks
-   * Total by the documented `index.d.ts` convention floor: `types`/`typings`,
-   * then the root export's types condition, then a declaration-extension
-   * swap of `main`, then `index.d.ts`. A main path that escapes the package
-   * (hostile manifest) also falls to the floor rather than surviving.
+   * The root subpath as {@link TypeResolver.resolveImport} resolves it, made
+   * total by the documented `index.d.ts` convention floor. A main path that
+   * escapes the package (hostile manifest) also falls to the floor rather
+   * than surviving.
    */
   static resolveMainEntry(manifest: PackageManifest, pkg: PackageSpec): ResolvedModule;
   /**
@@ -634,11 +638,12 @@ export declare class TypeResolver {
    * deduplicated by file path.
    *
    * @remarks
-   * Wildcard export keys (`"./*"`) are skipped: enumeration has no captured
-   * segment to substitute, so a pattern entry would emit a literal
-   * `dist/*.d.ts`. Pattern subpaths resolve through
-   * {@link TypeResolver.resolveImport}, which has the concrete specifier.
-   * Entries whose paths escape the package are skipped.
+   * Subpaths come from `PackageExports.typesEntriesResult`. Pattern entries
+   * (`"./*"`) are skipped: enumeration has no captured segment to
+   * substitute, so a pattern entry would emit a literal `dist/*.d.ts`.
+   * Pattern subpaths resolve through {@link TypeResolver.resolveImport},
+   * which has the concrete specifier. An `exports` map holding an invalid
+   * target fails enumeration as a whole, leaving only the main entry.
    */
   static resolveTypeEntries(manifest: PackageManifest, pkg: PackageSpec): ReadonlyArray<ResolvedModule>;
   /**

package/index.js

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

package/internal/resolution.js

@@ -1,20 +1,6 @@
 import { isTypeDefinition } from "@tsdoctor/vfs";
 
 // src/internal/resolution.ts
-/**
-* Exports-map resolution machinery. Every input here — `exports` values,
-* `typesVersions` maps, wildcard patterns — is untrusted JSON fetched from a
-* CDN, so every recursive surface carries a depth guard, wildcard patterns
-* are bounded before regex compilation, and untrusted keys are only read
-* through `Object.hasOwn` (a JSON-parsed `{"__proto__": …}` key would
-* otherwise read or, worse, assign the prototype).
-*/
-/** Keys that are never data on a plain object. Skipped everywhere. */
-const DUNDER_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
 /** Normalize backslashes to forward slashes. */
 const normalizePath = (path) => path.replace(/\\/g, "/");
 /**
@@ -28,153 +14,5 @@ const isSafeRelativePath = (filePath) => {
 	if (/^[A-Za-z]:/.test(filePath)) return false;
 	return !filePath.split(/[/\\]+/).some((segment) => segment === "..");
 };
-const escapeRegex = (value) => value.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-/**
-* Compile an exports/typesVersions wildcard pattern to a regex, or `null`
-* when the pattern exceeds the wildcard bound. npm semantics use exactly one
-* `*`; a hostile pattern with many wildcards would compile to a
-* catastrophic-backtracking regex, so past the bound it simply does not
-* match.
-*/
-const compileWildcard = (pattern) => {
-	let stars = 0;
-	for (const char of pattern) if (char === "*") stars += 1;
-	if (stars === 0 || stars > 1) return null;
-	return new RegExp(`^${escapeRegex(pattern).replace(/\\?\*/g, "(.*)")}$`);
-};
-/**
-* Substitute a captured wildcard segment into an exports value.
-*
-* @remarks
-* This is where v3 had a live prototype-pollution defect: it copied untrusted
-* keys into a plain object literal, so an `exports` map containing a
-* `"__proto__"` key assigned the prototype of the result. Substituted maps
-* are built with `Object.create(null)` and dunder keys are skipped. Past the
-* depth guard nothing resolves (`null`).
-*/
-const substituteWildcard = (value, captured, depth = 0) => {
-	if (depth > 256) return null;
-	if (typeof value === "string") return value.split("*").join(captured);
-	if (Array.isArray(value)) return value.map((entry) => substituteWildcard(entry, captured, depth + 1));
-	if (typeof value === "object" && value !== null) {
-		const result = Object.create(null);
-		for (const key of Object.keys(value)) {
-			if (DUNDER_KEYS.has(key)) continue;
-			if (!Object.hasOwn(value, key)) continue;
-			const entry = value[key];
-			result[key] = typeof entry === "string" || typeof entry === "object" && entry !== null ? substituteWildcard(entry, captured, depth + 1) : entry;
-		}
-		return result;
-	}
-	return value;
-};
-/**
-* Look up a subpath in an `exports` map: the root-conditions sugar form
-* first, then exact keys (with and without the `./` prefix), then bounded
-* wildcard patterns resolved by Node's specificity rules. Returns the export
-* value (wildcards substituted) or `null`.
-*/
-const getExportValue = (exports, subpath) => {
-	if (exports === void 0 || exports === null) return null;
-	if (typeof exports === "string") return subpath === "." ? exports : null;
-	if (Array.isArray(exports)) return subpath === "." ? exports : null;
-	if (typeof exports !== "object") return null;
-	const exportsObj = exports;
-	const keys = Object.keys(exportsObj);
-	if (!keys.some((key) => key.startsWith("."))) return subpath === "." ? exportsObj : null;
-	const withoutDot = subpath.replace(/^\.\//, "");
-	for (const key of [subpath, withoutDot]) if (!DUNDER_KEYS.has(key) && Object.hasOwn(exportsObj, key)) return exportsObj[key];
-	let best = null;
-	for (const pattern of keys) {
-		if (DUNDER_KEYS.has(pattern) || !pattern.includes("*")) continue;
-		if (!Object.hasOwn(exportsObj, pattern)) continue;
-		const regex = compileWildcard(pattern);
-		if (regex === null) continue;
-		const match = regex.exec(subpath) ?? regex.exec(withoutDot);
-		if (match === null) continue;
-		const base = pattern.indexOf("*");
-		if (best === null || base > best.base || base === best.base && pattern.length > best.pattern.length) best = {
-			pattern,
-			captured: match[1] ?? "",
-			base
-		};
-	}
-	if (best !== null) return substituteWildcard(exportsObj[best.pattern], best.captured);
-	return null;
-};
-/**
-* Extract a types-bearing path from an export value: `types` first, then
-* `import` / `default`, recursing into nested condition objects under the
-* depth guard. A fallback array (Node semantics) is walked in order and the
-* first entry yielding a types path wins.
-*/
-const extractTypesFromExport = (exportValue, depth = 0) => {
-	if (depth > 256) return null;
-	if (exportValue === void 0 || exportValue === null) return null;
-	if (typeof exportValue === "string") return exportValue;
-	if (Array.isArray(exportValue)) {
-		for (const entry of exportValue) {
-			const found = extractTypesFromExport(entry, depth + 1);
-			if (found !== null) return found;
-		}
-		return null;
-	}
-	if (typeof exportValue !== "object") return null;
-	const conditions = exportValue;
-	for (const condition of [
-		"types",
-		"import",
-		"default"
-	]) {
-		if (!Object.hasOwn(conditions, condition)) continue;
-		const value = conditions[condition];
-		if (typeof value === "string") return value;
-		if (typeof value === "object" && value !== null) {
-			const nested = extractTypesFromExport(value, depth + 1);
-			if (nested !== null) return nested;
-		}
-	}
-	return null;
-};
-/** The conventional lookup candidates for a bare subpath, most specific first. */
-const tryExtensions = (basePath) => [
-	basePath,
-	`${basePath}.d.ts`,
-	`${basePath}.d.mts`,
-	`${basePath}.d.cts`,
-	`${basePath}.ts`,
-	`${basePath}.mts`,
-	`${basePath}.cts`,
-	`${basePath}.js`,
-	`${basePath}.mjs`,
-	`${basePath}.cjs`,
-	`${basePath}/index.d.ts`,
-	`${basePath}/index.d.mts`,
-	`${basePath}/index.d.cts`,
-	`${basePath}/index.ts`,
-	`${basePath}/index.js`
-].map(normalizePath);
-/**
-* The main type entry for a manifest: `types`/`typings`, then the root
-* export's types condition, then a declaration-extension swap of `main`,
-* with the documented `index.d.ts` convention floor — which is what makes
-* `TypeResolver.resolveMainEntry` genuinely total.
-*/
-const findMainTypePath = (manifest) => {
-	if (manifest.types !== void 0) return manifest.types;
-	if (manifest.typings !== void 0) return manifest.typings;
-	if (manifest.exports !== void 0) {
-		const rootExport = getExportValue(manifest.exports, ".");
-		const typesPath = extractTypesFromExport(rootExport);
-		if (typesPath !== null) return typesPath;
-	}
-	if (manifest.main !== void 0) {
-		const mainWithoutExt = manifest.main.replace(/\.(m?[jt]s|cjs)$/, "");
-		const found = tryExtensions(mainWithoutExt).find(isTypeDefinition);
-		if (found !== void 0) return found;
-		return manifest.main;
-	}
-	return "index.d.ts";
-};
 
-export { compileWildcard, extractTypesFromExport, findMainTypePath, getExportValue, isSafeRelativePath, isTypeDefinition, normalizePath, substituteWildcard, tryExtensions };
+export { isSafeRelativePath, isTypeDefinition, normalizePath };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsdoctor/registry",
-	"version": "0.5.14",
+	"version": "0.7.0",
 	"private": false,
 	"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": [
@@ -38,15 +38,16 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/semver": "^0.19.0",
-		"@tsdoctor/vfs": "0.5.0"
+		"@effected/package-json": "^0.29.0",
+		"@effected/semver": "^0.21.0",
+		"@tsdoctor/vfs": "0.7.0"
 	},
 	"peerDependencies": {
-		"@effect/platform-node": "^4.0.7",
-		"@effected/store": "^0.21.0",
-		"@effected/tsconfig-json": "^0.18.0",
-		"@effected/xdg": "^0.17.0",
-		"effect": "^4.0.7"
+		"@effect/platform-node": "~4.1.2",
+		"@effected/store": "^0.23.0",
+		"@effected/tsconfig-json": "^0.20.0",
+		"@effected/xdg": "^0.19.0",
+		"effect": "~4.1.2"
 	},
 	"peerDependenciesMeta": {
 		"@effected/xdg": {

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.60.0"
+      "packageVersion": "7.60.1"
     }
   ]
 }