type-registry-effect 0.1.0

package/821.js

@@ -0,0 +1,628 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { Context, Data, Duration, Effect, Layer, Schedule, Schema } from "effect";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { FileSystem, HttpClient } from "@effect/platform";
+import { homedir as external_node_os_homedir } from "node:os";
+var TypeRegistry_namespaceObject = {};
+__webpack_require__.r(TypeRegistry_namespaceObject);
+__webpack_require__.d(TypeRegistry_namespaceObject, {
+    clearCache: ()=>clearCache,
+    fetchAndCache: ()=>fetchAndCache,
+    getPackageVFS: ()=>getPackageVFS,
+    getTypeEntries: ()=>getTypeEntries,
+    getVFS: ()=>getVFS,
+    hasCached: ()=>hasCached,
+    resolveImport: ()=>resolveImport,
+    resolveVersion: ()=>resolveVersion
+});
+const PackageNotFoundErrorBase = Data.TaggedError("PackageNotFoundError");
+class PackageNotFoundError extends PackageNotFoundErrorBase {
+}
+const ParseErrorBase = Data.TaggedError("ParseError");
+class ParseError extends ParseErrorBase {
+}
+const CacheService = Context.GenericTag("type-registry-effect/CacheService");
+const PackageFetcher = Context.GenericTag("type-registry-effect/PackageFetcher");
+const JSDELIVR_DATA_API = "https://data.jsdelivr.com/v1";
+const JSDELIVR_CDN = "https://cdn.jsdelivr.net";
+const TYPE_FILE_PATTERN = /\.d\.([^.]+\.)?[cm]?ts$/i;
+new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "diagnostics_channel",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib",
+    "fs/promises",
+    "stream/web",
+    "stream/consumers",
+    "timers/promises",
+    "dns/promises"
+]);
+const TypeResolver = Context.GenericTag("type-registry-effect/TypeResolver");
+const hasCached = (pkg)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        return yield* cache.exists(pkg);
+    });
+const fetchAndCache = (pkg, options)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        const fetcher = yield* PackageFetcher;
+        const packageJson = yield* fetcher.getPackageJson(pkg);
+        const typeFiles = yield* fetcher.getTypeFiles(pkg);
+        yield* cache.write(pkg, "package.json", JSON.stringify(packageJson, null, 2));
+        for (const [filePath, content] of typeFiles){
+            const normalizedPath = filePath.replace(/^\//, "");
+            if ("package.json" !== normalizedPath) yield* cache.write(pkg, normalizedPath, content);
+        }
+        const metadata = {
+            cachedAt: Date.now(),
+            version: pkg.version,
+            ...options?.ttl !== void 0 ? {
+                ttl: options.ttl
+            } : {}
+        };
+        yield* cache.writeMetadata(pkg, metadata);
+    });
+const getPackageVFS = (pkg, options)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        const autoFetch = options?.autoFetch ?? true;
+        const exists = yield* cache.exists(pkg);
+        if (!exists && autoFetch) yield* fetchAndCache(pkg, options);
+        else if (exists || autoFetch) {
+            if (exists && autoFetch) {
+                const isStale = yield* cache.readMetadata(pkg).pipe(Effect.map((meta)=>{
+                    if (void 0 === meta.ttl) return false;
+                    return meta.cachedAt + meta.ttl < Date.now();
+                }), Effect.catchAll(()=>Effect.succeed(false)));
+                if (isStale) yield* fetchAndCache(pkg, options);
+            }
+        } else yield* Effect.fail(new PackageNotFoundError({
+            name: pkg.name,
+            version: pkg.version,
+            message: `Package ${pkg.toString()} is not cached and autoFetch is disabled`
+        }));
+        return yield* cache.getVFS(pkg);
+    });
+const getVFS = (packages, options)=>Effect.gen(function*() {
+        const results = yield* Effect.forEach(packages, (pkg)=>getPackageVFS(pkg, options).pipe(Effect.map((vfs)=>({
+                    _tag: "ok",
+                    vfs
+                })), Effect.catchAll((error)=>Effect.succeed({
+                    _tag: "err",
+                    pkg,
+                    error
+                }))), {
+            concurrency: 5
+        });
+        const merged = new Map();
+        const errors = [];
+        for (const result of results)if ("ok" === result._tag) for (const [path, content] of result.vfs)merged.set(path, content);
+        else errors.push({
+            pkg: result.pkg,
+            error: result.error
+        });
+        if (errors.length === packages.length && packages.length > 0) yield* Effect.fail(new PackageNotFoundError({
+            name: errors.map((e)=>e.pkg.name).join(", "),
+            version: "",
+            message: `Failed to fetch VFS for all packages:\n${errors.map((e)=>`- ${e.pkg.toString()}: ${String(e.error)}`).join("\n")}`
+        }));
+        return merged;
+    });
+const resolveImport = (pkg, specifier)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        const resolver = yield* TypeResolver;
+        const packageJsonContent = yield* cache.read(pkg, "package.json");
+        const packageJson = yield* Effect["try"]({
+            try: ()=>JSON.parse(packageJsonContent),
+            catch: (error)=>new ParseError({
+                    source: "package.json",
+                    message: String(error)
+                })
+        });
+        return yield* resolver.resolveImport(specifier, packageJson, pkg);
+    });
+const getTypeEntries = (pkg)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        const resolver = yield* TypeResolver;
+        const packageJsonContent = yield* cache.read(pkg, "package.json");
+        const packageJson = yield* Effect["try"]({
+            try: ()=>JSON.parse(packageJsonContent),
+            catch: (error)=>new ParseError({
+                    source: "package.json",
+                    message: String(error)
+                })
+        });
+        return yield* resolver.resolveTypeEntries(packageJson, pkg);
+    });
+const resolveVersion = (name, ref)=>Effect.gen(function*() {
+        const fetcher = yield* PackageFetcher;
+        return yield* fetcher.resolveVersion(name, ref);
+    });
+const clearCache = (pkg)=>Effect.gen(function*() {
+        const cache = yield* CacheService;
+        yield* cache.remove(pkg);
+    });
+const CacheMetadata = Schema.Struct({
+    version: Schema.String,
+    cachedAt: Schema.Number,
+    ttl: Schema.optional(Schema.Number)
+});
+const FileTreeEntry = Schema.Struct({
+    name: Schema.String,
+    hash: Schema.String,
+    time: Schema.String,
+    size: Schema.Number
+});
+const FileTreeResponse = Schema.Struct({
+    default: Schema.String,
+    files: Schema.Array(FileTreeEntry)
+});
+const PackageJson = Schema.Struct({
+    name: Schema.String,
+    version: Schema.String,
+    types: Schema.optional(Schema.String),
+    typings: Schema.optional(Schema.String),
+    main: Schema.optional(Schema.String),
+    module: Schema.optional(Schema.String),
+    exports: Schema.optional(Schema.Union(Schema.String, Schema.Record({
+        key: Schema.String,
+        value: Schema.Unknown
+    }))),
+    typesVersions: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.Record({
+            key: Schema.String,
+            value: Schema.Array(Schema.String)
+        })
+    })),
+    dependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    peerDependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    })),
+    devDependencies: Schema.optional(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    }))
+});
+var _computedKey;
+const PackageSpecBase = Data.TaggedClass("PackageSpec");
+_computedKey = Symbol.for("nodejs.util.inspect.custom");
+class PackageSpec extends PackageSpecBase {
+    toString() {
+        return `${this.name}@${this.version}`;
+    }
+    [_computedKey]() {
+        return this.toString();
+    }
+}
+const ResolvedModuleBase = Data.TaggedClass("ResolvedModule");
+class ResolvedModule extends ResolvedModuleBase {
+}
+const CacheErrorBase = Data.TaggedError("CacheError");
+class CacheError extends CacheErrorBase {
+}
+const NetworkErrorBase = Data.TaggedError("NetworkError");
+class NetworkError extends NetworkErrorBase {
+}
+const ResolutionErrorBase = Data.TaggedError("ResolutionError");
+class ResolutionError extends ResolutionErrorBase {
+}
+const TimeoutErrorBase = Data.TaggedError("TimeoutError");
+class TimeoutError extends TimeoutErrorBase {
+}
+function getXdgCacheHome() {
+    const xdgCacheHome = process.env.XDG_CACHE_HOME;
+    if (xdgCacheHome && isAbsolute(xdgCacheHome)) return xdgCacheHome;
+    return join(external_node_os_homedir(), ".cache");
+}
+function getDefaultCacheDir() {
+    return join(getXdgCacheHome(), "effect-type-registry");
+}
+const pkgDir = (baseDir, pkg)=>join(baseDir, pkg.toString());
+const mapToCacheError = (operation, path)=>(error)=>new CacheError({
+            operation,
+            path,
+            message: String(error)
+        });
+const makeNodeCacheLayer = (baseDir)=>Layer.effect(CacheService, Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        const cacheDir = baseDir ?? getDefaultCacheDir();
+        const listRecursive = (dir, relativeTo)=>Effect.gen(function*() {
+                const entries = yield* fs.readDirectory(dir).pipe(Effect.mapError(mapToCacheError("list", dir)));
+                const files = [];
+                for (const entry of entries){
+                    const fullPath = join(dir, entry);
+                    const stat = yield* fs.stat(fullPath).pipe(Effect.mapError(mapToCacheError("list", fullPath)));
+                    if ("Directory" === stat.type) files.push(...yield* listRecursive(fullPath, relativeTo));
+                    else files.push(relative(relativeTo, fullPath));
+                }
+                return files;
+            });
+        return {
+            exists: (pkg)=>fs.exists(pkgDir(cacheDir, pkg)).pipe(Effect.catchAll(()=>Effect.succeed(false))),
+            read: (pkg, filePath)=>{
+                const fullPath = join(pkgDir(cacheDir, pkg), filePath);
+                return fs.readFileString(fullPath).pipe(Effect.mapError(mapToCacheError("read", fullPath)));
+            },
+            write: (pkg, filePath, content)=>{
+                const fullPath = join(pkgDir(cacheDir, pkg), filePath);
+                const dirPath = dirname(fullPath);
+                return Effect.gen(function*() {
+                    yield* fs.makeDirectory(dirPath, {
+                        recursive: true
+                    }).pipe(Effect.mapError(mapToCacheError("write", dirPath)));
+                    yield* fs.writeFileString(fullPath, content).pipe(Effect.mapError(mapToCacheError("write", fullPath)));
+                });
+            },
+            listFiles: (pkg)=>{
+                const cachePath = pkgDir(cacheDir, pkg);
+                return listRecursive(cachePath, cachePath);
+            },
+            readMetadata: (pkg)=>{
+                const metaPath = join(pkgDir(cacheDir, pkg), ".metadata.json");
+                return fs.readFileString(metaPath).pipe(Effect.mapError(mapToCacheError("read", metaPath)), Effect.flatMap((content)=>Effect["try"]({
+                        try: ()=>JSON.parse(content),
+                        catch: mapToCacheError("read", metaPath)
+                    })), Effect.flatMap((parsed)=>Schema.decodeUnknown(CacheMetadata)(parsed).pipe(Effect.mapError(mapToCacheError("read", metaPath)))));
+            },
+            writeMetadata: (pkg, metadata)=>{
+                const metaPath = join(pkgDir(cacheDir, pkg), ".metadata.json");
+                const dirPath = dirname(metaPath);
+                return Effect.gen(function*() {
+                    yield* fs.makeDirectory(dirPath, {
+                        recursive: true
+                    }).pipe(Effect.mapError(mapToCacheError("write", dirPath)));
+                    const encoded = Schema.encodeSync(CacheMetadata)(metadata);
+                    yield* fs.writeFileString(metaPath, JSON.stringify(encoded, null, 2)).pipe(Effect.mapError(mapToCacheError("write", metaPath)));
+                });
+            },
+            getVFS: (pkg)=>Effect.gen(function*() {
+                    const cachePath = pkgDir(cacheDir, pkg);
+                    const files = yield* listRecursive(cachePath, cachePath);
+                    const vfs = new Map();
+                    for (const file of files){
+                        if (".metadata.json" === file) continue;
+                        const fullPath = join(cachePath, file);
+                        const content = yield* fs.readFileString(fullPath).pipe(Effect.mapError(mapToCacheError("read", fullPath)));
+                        const vfsPath = `node_modules/${pkg.name}/${file.replace(/\\/g, "/")}`;
+                        vfs.set(vfsPath, content);
+                    }
+                    return vfs;
+                }),
+            remove: (pkg)=>{
+                const cachePath = pkgDir(cacheDir, pkg);
+                return fs.remove(cachePath, {
+                    recursive: true
+                }).pipe(Effect.mapError(mapToCacheError("delete", cachePath)));
+            }
+        };
+    }));
+const CacheServiceLive = makeNodeCacheLayer();
+const PackageMetadataSchema = Schema.Struct({
+    versions: Schema.mutable(Schema.Array(Schema.String)),
+    tags: Schema.mutable(Schema.Record({
+        key: Schema.String,
+        value: Schema.String
+    }))
+});
+const ResolveResponseSchema = Schema.Struct({
+    version: Schema.String
+});
+const retrySchedule = Schedule.exponential(Duration.millis(100)).pipe(Schedule.compose(Schedule.recurs(3)));
+const defaultTimeout = Duration.seconds(30);
+const PackageFetcherLive = Layer.effect(PackageFetcher, Effect.gen(function*() {
+    const http = yield* HttpClient.HttpClient;
+    const fetchJson = (url)=>http.get(url).pipe(Effect.flatMap((res)=>res.json), Effect.timeout(defaultTimeout), Effect.retry(retrySchedule), Effect.mapError((error)=>new NetworkError({
+                url,
+                message: String(error)
+            })));
+    const fetchText = (url)=>http.get(url).pipe(Effect.flatMap((res)=>res.text), Effect.timeout(defaultTimeout), Effect.retry(retrySchedule), Effect.mapError((error)=>new NetworkError({
+                url,
+                message: String(error)
+            })));
+    const getFileTree = (pkg)=>fetchJson(`${JSDELIVR_DATA_API}/package/npm/${pkg.name}@${pkg.version}/flat`).pipe(Effect.flatMap((data)=>Schema.decodeUnknown(FileTreeResponse)(data).pipe(Effect.mapError((e)=>new ParseError({
+                    source: `${pkg.name}@${pkg.version}/flat`,
+                    message: `Schema validation failed: ${String(e)}`
+                })))));
+    return {
+        getVersions: (name)=>fetchJson(`${JSDELIVR_DATA_API}/package/npm/${name}`).pipe(Effect.flatMap((data)=>Schema.decodeUnknown(PackageMetadataSchema)(data).pipe(Effect.mapError((e)=>new ParseError({
+                        source: `${name}/versions`,
+                        message: `Schema validation failed: ${String(e)}`
+                    }))))),
+        resolveVersion: (name, ref)=>fetchJson(`${JSDELIVR_DATA_API}/package/resolve/npm/${name}@${ref}`).pipe(Effect.flatMap((data)=>Schema.decodeUnknown(ResolveResponseSchema)(data).pipe(Effect.mapError((e)=>new ParseError({
+                        source: `resolve/${name}@${ref}`,
+                        message: `Invalid response: ${String(e)}`
+                    })))), Effect.map((data)=>data.version), Effect.catchTags({
+                ParseError: (e)=>Effect.fail(new PackageNotFoundError({
+                        name,
+                        version: ref,
+                        message: e.message
+                    })),
+                NetworkError: (e)=>e.message.includes("404") ? Effect.fail(new PackageNotFoundError({
+                        name,
+                        version: ref,
+                        message: e.message
+                    })) : Effect.fail(e)
+            })),
+        getFileTree,
+        downloadFile: (pkg, filePath)=>{
+            const normalizedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+            return fetchText(`${JSDELIVR_CDN}/npm/${pkg.name}@${pkg.version}${normalizedPath}`);
+        },
+        getPackageJson: (pkg)=>fetchText(`${JSDELIVR_CDN}/npm/${pkg.name}@${pkg.version}/package.json`).pipe(Effect.flatMap((content)=>Effect["try"]({
+                    try: ()=>JSON.parse(content),
+                    catch: (e)=>new ParseError({
+                            source: `${pkg.name}@${pkg.version}/package.json`,
+                            message: `JSON parse failed: ${String(e)}`
+                        })
+                })), Effect.flatMap((parsed)=>Schema.decodeUnknown(PackageJson)(parsed).pipe(Effect.mapError((e)=>new ParseError({
+                        source: `${pkg.name}@${pkg.version}/package.json`,
+                        message: `Schema validation failed: ${String(e)}`
+                    }))))),
+        getTypeFiles: (pkg)=>Effect.gen(function*() {
+                const fileTree = yield* getFileTree(pkg);
+                const typeFiles = fileTree.files.filter((f)=>TYPE_FILE_PATTERN.test(f.name));
+                const entries = yield* Effect.forEach(typeFiles, (file)=>{
+                    const normalizedPath = file.name.startsWith("/") ? file.name : `/${file.name}`;
+                    return fetchText(`${JSDELIVR_CDN}/npm/${pkg.name}@${pkg.version}${normalizedPath}`).pipe(Effect.map((content)=>[
+                            file.name,
+                            content
+                        ]));
+                }, {
+                    concurrency: 10
+                });
+                const vfs = new Map(entries);
+                const hasPackageJson = fileTree.files.some((f)=>"/package.json" === f.name);
+                if (!hasPackageJson) {
+                    const pkgContent = yield* fetchText(`${JSDELIVR_CDN}/npm/${pkg.name}@${pkg.version}/package.json`);
+                    vfs.set("/package.json", pkgContent);
+                }
+                return vfs;
+            })
+    };
+}));
+function isTypeDefinition(filePath) {
+    return filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts");
+}
+function normalizePath(path) {
+    return path.replace(/\\/g, "/");
+}
+function escapeRegex(str) {
+    return str.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function substituteWildcard(value, captured) {
+    if ("string" == typeof value) return value.replace(/\*/g, captured);
+    if ("object" == typeof value && null !== value) {
+        const result = {};
+        for (const [k, v] of Object.entries(value))if ("string" == typeof v) result[k] = v.replace(/\*/g, captured);
+        else if ("object" == typeof v && null !== v) result[k] = substituteWildcard(v, captured);
+        else result[k] = v;
+        return result;
+    }
+    return value;
+}
+function tryExtensions(basePath) {
+    return [
+        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);
+}
+function getExportValue(exports, subpath) {
+    if (!exports) return null;
+    if ("string" == typeof exports) return "." === subpath ? exports : null;
+    if ("object" == typeof exports && null !== exports) {
+        const exportsObj = exports;
+        const value = exportsObj[subpath];
+        if (void 0 !== value) return value;
+        const withoutDot = subpath.replace(/^\.\//, "");
+        const alt = exportsObj[withoutDot];
+        if (void 0 !== alt) return alt;
+        for (const [pattern, val] of Object.entries(exportsObj))if (pattern.includes("*")) {
+            const escaped = escapeRegex(pattern).replace(/\*/g, "(.*)");
+            const regex = new RegExp(`^${escaped}$`);
+            const match = regex.exec(subpath) || regex.exec(withoutDot);
+            if (match) {
+                const captured = match[1] || "";
+                return substituteWildcard(val, captured);
+            }
+        }
+    }
+    return null;
+}
+function findMainTypePath(packageJson) {
+    if (packageJson.types) return packageJson.types;
+    if (packageJson.typings) return packageJson.typings;
+    if (packageJson.exports) {
+        const rootExport = getExportValue(packageJson.exports, ".");
+        if (rootExport) {
+            const typesPath = extractTypesFromExport(rootExport);
+            if (typesPath) return typesPath;
+        }
+    }
+    if (packageJson.main) {
+        const mainWithoutExt = packageJson.main.replace(/\.(m?[jt]s|cjs)$/, "");
+        const candidates = tryExtensions(mainWithoutExt);
+        const found = candidates.find((c)=>isTypeDefinition(c));
+        if (found) return found;
+        return packageJson.main;
+    }
+    return "index.d.ts";
+}
+function extractTypesFromExport(exportValue) {
+    if (!exportValue) return null;
+    if ("string" == typeof exportValue) return exportValue;
+    if ("object" == typeof exportValue && null !== exportValue) {
+        const obj = exportValue;
+        if ("string" == typeof obj.types) return obj.types;
+        if ("string" == typeof obj.import) return obj.import;
+        if ("string" == typeof obj.default) return obj.default;
+        if ("object" == typeof obj.import) return extractTypesFromExport(obj.import);
+        if ("object" == typeof obj.default) return extractTypesFromExport(obj.default);
+    }
+    return null;
+}
+const TypeResolverLive = Layer.succeed(TypeResolver, {
+    resolveImport: (specifier, packageJson, pkg)=>Effect.sync(()=>{
+            let subpath = specifier;
+            if (specifier.startsWith(pkg.name)) subpath = specifier.slice(pkg.name.length);
+            subpath = subpath.replace(/^\//, "");
+            if (!subpath.startsWith(".")) subpath = `./${subpath}`;
+            if (packageJson.exports) {
+                const lookupPath = subpath.startsWith("./") ? subpath : `./${subpath}`;
+                const exportValue = getExportValue(packageJson.exports, lookupPath);
+                if (exportValue) {
+                    const typesPath = extractTypesFromExport(exportValue);
+                    if (typesPath) return new ResolvedModule({
+                        filePath: normalizePath(typesPath.replace(/^\.\//, "")),
+                        isTypeDefinition: isTypeDefinition(typesPath),
+                        package: pkg
+                    });
+                }
+            }
+            if (packageJson.typesVersions) {
+                const versionMap = packageJson.typesVersions["*"];
+                if (versionMap) {
+                    const lookupPath = subpath.replace(/^\.\//, "");
+                    if (versionMap[lookupPath]) {
+                        const resolved = versionMap[lookupPath];
+                        const path = Array.isArray(resolved) ? resolved[0] : resolved;
+                        if (path) return new ResolvedModule({
+                            filePath: normalizePath(path.replace(/^\.\//, "")),
+                            isTypeDefinition: isTypeDefinition(path),
+                            package: pkg
+                        });
+                    }
+                    for (const [pattern, paths] of Object.entries(versionMap))if (pattern.includes("*")) {
+                        const escaped = escapeRegex(pattern).replace(/\*/g, "(.*)");
+                        const regex = new RegExp(`^${escaped}$`);
+                        if (regex.test(lookupPath)) {
+                            const resolved = Array.isArray(paths) ? paths[0] : paths;
+                            if (resolved) {
+                                const captured = lookupPath.replace(regex, "$1");
+                                const finalPath = resolved.replace("*", captured);
+                                return new ResolvedModule({
+                                    filePath: normalizePath(finalPath.replace(/^\.\//, "")),
+                                    isTypeDefinition: isTypeDefinition(finalPath),
+                                    package: pkg
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            const candidates = tryExtensions(subpath.replace(/^\.\//, ""));
+            for (const candidate of candidates)if (isTypeDefinition(candidate)) return new ResolvedModule({
+                filePath: normalizePath(candidate),
+                isTypeDefinition: true,
+                package: pkg
+            });
+            const fallback = normalizePath(candidates[0] || subpath);
+            return new ResolvedModule({
+                filePath: fallback,
+                isTypeDefinition: isTypeDefinition(candidates[0] || subpath),
+                package: pkg
+            });
+        }),
+    resolveMainEntry: (packageJson, pkg)=>Effect.sync(()=>{
+            const mainPath = findMainTypePath(packageJson);
+            const normalizedPath = normalizePath(mainPath.replace(/^\.\//, ""));
+            return new ResolvedModule({
+                filePath: normalizedPath,
+                isTypeDefinition: isTypeDefinition(normalizedPath),
+                package: pkg
+            });
+        }),
+    resolveTypeEntries: (packageJson, pkg)=>Effect.sync(()=>{
+            const entries = [];
+            const mainPath = findMainTypePath(packageJson);
+            entries.push(new ResolvedModule({
+                filePath: normalizePath(mainPath.replace(/^\.\//, "")),
+                isTypeDefinition: isTypeDefinition(mainPath),
+                package: pkg
+            }));
+            if (packageJson.exports && "object" == typeof packageJson.exports) for (const [key, value] of Object.entries(packageJson.exports)){
+                if (!key.startsWith(".") && "*" !== key) continue;
+                const typesPath = extractTypesFromExport(value);
+                if (typesPath) entries.push(new ResolvedModule({
+                    filePath: normalizePath(typesPath.replace(/^\.\//, "")),
+                    isTypeDefinition: isTypeDefinition(typesPath),
+                    package: pkg
+                }));
+            }
+            const seen = new Set();
+            return entries.filter((e)=>{
+                if (seen.has(e.filePath)) return false;
+                seen.add(e.filePath);
+                return true;
+            });
+        }),
+    findTypeDefinition: (jsFilePath, _packageJson, pkg)=>Effect.sync(()=>{
+            let typePath;
+            if (jsFilePath.endsWith(".mjs")) typePath = jsFilePath.replace(/\.mjs$/, ".d.mts");
+            else if (jsFilePath.endsWith(".cjs")) typePath = jsFilePath.replace(/\.cjs$/, ".d.cts");
+            else if (jsFilePath.endsWith(".js")) typePath = jsFilePath.replace(/\.js$/, ".d.ts");
+            else {
+                const withoutExt = jsFilePath.replace(/\.(m?js|cjs)$/, "");
+                typePath = `${withoutExt}.d.ts`;
+            }
+            return new ResolvedModule({
+                filePath: normalizePath(typePath),
+                isTypeDefinition: true,
+                package: pkg
+            });
+        })
+});
+const TypeRegistryLive = Layer.mergeAll(CacheServiceLive, PackageFetcherLive, TypeResolverLive);
+export { CacheError, CacheErrorBase, CacheMetadata, CacheService, CacheServiceLive, Effect, FileTreeEntry, FileTreeResponse, Layer, NetworkError, NetworkErrorBase, PackageFetcher, PackageFetcherLive, PackageJson, PackageNotFoundError, PackageNotFoundErrorBase, PackageSpec, PackageSpecBase, ParseError, ParseErrorBase, ResolutionError, ResolutionErrorBase, ResolvedModule, ResolvedModuleBase, TimeoutError, TimeoutErrorBase, TypeRegistryLive, TypeRegistry_namespaceObject as TypeRegistry, TypeResolver, TypeResolverLive, fetchAndCache, getDefaultCacheDir, getVFS, hasCached, makeNodeCacheLayer, resolveVersion };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.