@run0/jiki 0.1.0

package/dist/kernel.d.ts

@@ -0,0 +1,48 @@
+import { MemFS } from "./memfs";
+import type { IExecuteResult } from "./runtime-interface";
+import { FsShim } from "./polyfills/fs";
+import { Process } from "./polyfills/process";
+import { type InitOptions } from "./transpiler";
+import { transformEsmToCjs } from "./code-transform";
+import { type Module, type RuntimeOptions, type RequireFunction } from "./module-resolver";
+import { builtinModules } from "./builtins";
+import type { PluginRegistry } from "./plugin";
+export type { Module, RuntimeOptions, RequireFunction };
+declare function createRequire(vfs: MemFS, fsShim: FsShim, process: Process, currentDir: string, moduleCache: Record<string, Module>, options: RuntimeOptions, processedCodeCache?: Map<string, string>, pluginRegistry?: PluginRegistry): RequireFunction;
+export declare class Kernel {
+    vfs: MemFS;
+    fsShim: FsShim;
+    process: Process;
+    moduleCache: Record<string, Module>;
+    processedCodeCache: Map<string, string>;
+    private options;
+    private maxCacheSize;
+    private cacheAccessTime;
+    private resolver;
+    /** Plugin registry for this kernel (shared with child kernels). */
+    readonly pluginRegistry?: PluginRegistry;
+    constructor(vfs: MemFS, options?: RuntimeOptions, pluginRegistry?: PluginRegistry);
+    init(options?: InitOptions): Promise<void>;
+    prepareFile(filename: string): Promise<void>;
+    private walkImports;
+    private patchGlobals;
+    execute(code: string, filename?: string): IExecuteResult;
+    executeSync(code: string, filename?: string): IExecuteResult;
+    executeAsync(code: string, filename?: string): Promise<IExecuteResult>;
+    runFile(filename: string): IExecuteResult;
+    runFileSync(filename: string): IExecuteResult;
+    runFileAsync(filename: string): Promise<IExecuteResult>;
+    clearCache(): void;
+    invalidateModule(path: string): void;
+    invalidateModulesMatching(predicate: (path: string) => boolean): void;
+    getVFS(): MemFS;
+    getProcess(): Process;
+    private trimCacheIfOversized;
+    /** Record access time for a module cache entry */
+    touchCacheEntry(key: string): void;
+    createREPL(): {
+        eval: (code: string) => unknown;
+    };
+}
+export { transformEsmToCjs, createRequire, builtinModules };
+export { Kernel as Runtime };

package/dist/memfs.d.ts

@@ -0,0 +1,144 @@
+import type { VFSSnapshot } from "./runtime-interface";
+import { createNodeError, type NodeError, type Stats } from "./fs-errors";
+import { type PersistenceAdapter } from "./persistence";
+import type { SandboxGuard } from "./sandbox";
+export { createNodeError, type NodeError, type Stats };
+export interface FSNode {
+    type: "file" | "directory" | "symlink";
+    content?: Uint8Array;
+    children?: Map<string, FSNode>;
+    target?: string;
+    mtime: number;
+    ino: number;
+}
+type ChangeListener = (path: string, content: string) => void;
+type DeleteListener = (path: string) => void;
+export type WatchEventType = "change" | "rename";
+export type WatchListener = (eventType: WatchEventType, filename: string | null) => void;
+export interface FSWatcher {
+    close(): void;
+    ref(): this;
+    unref(): this;
+}
+/** Options for MemFS construction. */
+export interface MemFSOptions {
+    /** Optional persistence adapter. When provided, filesystem mutations are
+     *  automatically persisted to the backend. */
+    persistence?: PersistenceAdapter;
+    /** Optional sandbox guard. When provided, all write operations are
+     *  checked against resource limits and path restrictions. */
+    sandbox?: SandboxGuard;
+}
+export declare class MemFS {
+    private root;
+    private enc;
+    private dec;
+    private watchers;
+    private eventSubs;
+    private nodeIndex;
+    private symlinkLimit;
+    private fdCounter;
+    private fdMap;
+    /** Persistence adapter (if configured). */
+    private persistence?;
+    /** Sandbox guard (if configured). */
+    private sandboxGuard?;
+    constructor(options?: MemFSOptions);
+    /**
+     * Rehydrate the VFS from the persistence adapter.
+     * Call this once during initialisation (e.g. in `Container.init()`) to
+     * restore previously persisted state.
+     */
+    hydrate(): Promise<number>;
+    /**
+     * Flush any pending persistence writes immediately.
+     * Useful before page unload or when you need to guarantee data is saved.
+     */
+    flushPersistence(): Promise<void>;
+    /** Queue a node for persistence (fire-and-forget). */
+    private persist;
+    /** Queue a path deletion for persistence (fire-and-forget). */
+    private unpersist;
+    /** Queue deletion of a path and all its descendants. */
+    private unpersistTree;
+    on(event: "change", listener: ChangeListener): this;
+    on(event: "delete", listener: DeleteListener): this;
+    off(event: "change", listener: ChangeListener): this;
+    off(event: "delete", listener: DeleteListener): this;
+    private fire;
+    toSnapshot(): VFSSnapshot;
+    static fromSnapshot(snapshot: VFSSnapshot): MemFS;
+    export(path: string, _options?: {
+        format?: "json";
+    }): Record<string, unknown>;
+    private treeToJson;
+    private lookupDirect;
+    private followLinks;
+    private ensureDir;
+    private dropIndex;
+    existsSync(path: string): boolean;
+    statSync(path: string): Stats;
+    lstatSync(path: string): Stats;
+    private toStats;
+    readFileSync(path: string): Uint8Array;
+    readFileSync(path: string, encoding: "utf8" | "utf-8"): string;
+    writeFileSync(path: string, data: string | Uint8Array): void;
+    putFile(path: string, data: string | Uint8Array, notify: boolean): void;
+    symlinkSync(target: string, linkPath: string): void;
+    readlinkSync(path: string): string;
+    mkdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    readdirSync(path: string): string[];
+    readdirSync(path: string, options: {
+        withFileTypes: true;
+    }): {
+        name: string;
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isSymbolicLink(): boolean;
+    }[];
+    unlinkSync(path: string): void;
+    rmdirSync(path: string, options?: {
+        recursive?: boolean;
+    }): void;
+    rmSync(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): void;
+    renameSync(oldPath: string, newPath: string): void;
+    copyFileSync(src: string, dest: string): void;
+    utimesSync(path: string, _atime: number | Date, mtime: number | Date): void;
+    accessSync(path: string, _mode?: number): void;
+    realpathSync(path: string): string;
+    openSync(path: string, flags?: string | number): number;
+    closeSync(fd: number): void;
+    readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null): number;
+    writeSync(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null): number;
+    fstatSync(fd: number): Stats;
+    readFile(path: string, optionsOrCb?: {
+        encoding?: string;
+    } | ((err: Error | null, data?: Uint8Array | string) => void), cb?: (err: Error | null, data?: Uint8Array | string) => void): void;
+    stat(path: string, cb: (err: Error | null, stats?: Stats) => void): void;
+    lstat(path: string, cb: (err: Error | null, stats?: Stats) => void): void;
+    readdir(path: string, optionsOrCb?: {
+        withFileTypes?: boolean;
+    } | ((err: Error | null, files?: string[]) => void), cb?: (err: Error | null, files?: unknown) => void): void;
+    realpath(path: string, cb: (err: Error | null, resolved?: string) => void): void;
+    access(path: string, modeOrCb?: number | ((err: Error | null) => void), cb?: (err: Error | null) => void): void;
+    watch(filename: string, optionsOrListener?: {
+        persistent?: boolean;
+        recursive?: boolean;
+        encoding?: string;
+    } | WatchListener, listener?: WatchListener): FSWatcher;
+    private signalWatchers;
+    createReadStream(path: string): {
+        on: (event: string, cb: (...args: unknown[]) => void) => unknown;
+        pipe: (dest: unknown) => unknown;
+    };
+    createWriteStream(path: string): {
+        write: (data: string | Uint8Array) => boolean;
+        end: (data?: string | Uint8Array) => void;
+        on: (event: string, cb: (...args: unknown[]) => void) => unknown;
+    };
+}

package/dist/metrics.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Performance metrics for jiki containers.
+ *
+ * Tracks timing and counts for key operations: module resolution,
+ * transpilation, file I/O, cache hits/misses, and package installs.
+ *
+ * @example
+ * ```ts
+ * const container = boot();
+ * // ... do work ...
+ * const m = container.metrics.snapshot();
+ * console.log(`Resolved ${m.resolveCount} modules in ${m.resolveTimeMs}ms`);
+ * ```
+ */
+export interface MetricsSnapshot {
+    /** Total module resolutions performed. */
+    resolveCount: number;
+    /** Total time spent in module resolution (ms). */
+    resolveTimeMs: number;
+    /** Total transpilation calls. */
+    transpileCount: number;
+    /** Total time spent in transpilation (ms). */
+    transpileTimeMs: number;
+    /** Total VFS read operations. */
+    vfsReadCount: number;
+    /** Total VFS write operations. */
+    vfsWriteCount: number;
+    /** Module cache hits. */
+    cacheHits: number;
+    /** Module cache misses. */
+    cacheMisses: number;
+    /** Cache hit rate (0–1). */
+    cacheHitRate: number;
+    /** Total shell commands executed. */
+    commandCount: number;
+    /** Total packages installed. */
+    installCount: number;
+    /** Total time spent installing packages (ms). */
+    installTimeMs: number;
+    /** Timestamp of when metrics collection started. */
+    startedAt: number;
+    /** Elapsed time since metrics collection started (ms). */
+    uptimeMs: number;
+}
+export declare class Metrics {
+    private _resolveCount;
+    private _resolveTimeMs;
+    private _transpileCount;
+    private _transpileTimeMs;
+    private _vfsReadCount;
+    private _vfsWriteCount;
+    private _cacheHits;
+    private _cacheMisses;
+    private _commandCount;
+    private _installCount;
+    private _installTimeMs;
+    private _startedAt;
+    /** Record a module resolution. */
+    trackResolve(durationMs: number): void;
+    /** Record a transpilation. */
+    trackTranspile(durationMs: number): void;
+    /** Record a VFS read. */
+    trackRead(): void;
+    /** Record a VFS write. */
+    trackWrite(): void;
+    /** Record a cache hit. */
+    trackCacheHit(): void;
+    /** Record a cache miss. */
+    trackCacheMiss(): void;
+    /** Record a shell command execution. */
+    trackCommand(): void;
+    /** Record a package install. */
+    trackInstall(durationMs: number): void;
+    /** Get a snapshot of all metrics. */
+    snapshot(): MetricsSnapshot;
+    /** Reset all metrics. */
+    reset(): void;
+}

package/dist/module-resolver.d.ts

@@ -0,0 +1,60 @@
+import { MemFS } from "./memfs";
+import type { FsShim } from "./polyfills/fs";
+import type { Process } from "./polyfills/process";
+import type { PluginRegistry } from "./plugin";
+export interface Module {
+    id: string;
+    filename: string;
+    exports: unknown;
+    loaded: boolean;
+    children: Module[];
+    paths: string[];
+}
+export interface AutoInstallProvider {
+    installSync(name: string): void;
+}
+export interface RuntimeOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    onConsole?: (method: string, args: unknown[]) => void;
+    onStdout?: (data: string) => void;
+    onStderr?: (data: string) => void;
+    autoInstall?: boolean;
+    autoInstallProvider?: AutoInstallProvider;
+    /** Enable inline source maps for TypeScript/JSX transpilation. */
+    sourceMaps?: boolean;
+}
+export interface RequireFunction {
+    (id: string): unknown;
+    resolve: ((id: string) => string) & {
+        paths: (id: string) => string[] | null;
+    };
+    cache: Record<string, Module>;
+}
+export declare class ModuleResolver {
+    private vfs;
+    private fsShim;
+    private proc;
+    private opts;
+    private cache;
+    private transformedCache;
+    private debug;
+    private pluginRegistry?;
+    private pkgJsonMemo;
+    private resolveMemo;
+    clearMemos(): void;
+    /** Invalidate cached resolution entries that match the given file path.
+     *  This enables per-entry cache invalidation when a file changes on disk. */
+    invalidate(path: string): void;
+    constructor(vfs: MemFS, fsShim: FsShim, proc: Process, cache: Record<string, Module>, opts: RuntimeOptions, transformedCache: Map<string, string>, pluginRegistry?: PluginRegistry);
+    makeRequire(fromDir: string): RequireFunction;
+    resolve(id: string, fromDir: string): string;
+    load(resolved: string): Module;
+    private cacheAndReturn;
+    private readPkg;
+    probeFile(base: string): string | null;
+    private resolvePackageImport;
+    private extractPackageName;
+    private resolveFromNodeModules;
+    private tryPackageEntry;
+}

package/dist/network-interceptor.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Network request interception and mocking for jiki containers.
+ *
+ * Allows intercepting and mocking outgoing `fetch()` calls from executed
+ * code. Useful for testing, offline scenarios, and CORS avoidance.
+ *
+ * @example
+ * ```ts
+ * const container = boot();
+ * container.mockFetch('/api/users', { json: [{ name: 'Alice' }] });
+ * container.execute('fetch("/api/users").then(r => r.json()).then(console.log)');
+ * ```
+ */
+export interface MockResponse {
+    /** HTTP status code. Default: 200. */
+    status?: number;
+    /** Response headers. */
+    headers?: Record<string, string>;
+    /** Response body as string. */
+    body?: string;
+    /** Response body as JSON (auto-serialized). Overrides `body`. */
+    json?: unknown;
+}
+export type FetchHandler = (url: string, init?: RequestInit) => MockResponse | null | undefined | Promise<MockResponse | null | undefined>;
+/**
+ * Intercepts fetch calls and returns mock responses when a URL matches
+ * a registered pattern.
+ */
+export declare class NetworkInterceptor {
+    private rules;
+    private handlers;
+    /**
+     * Register a static mock response for a URL pattern.
+     *
+     * @param pattern - String (exact match or prefix) or RegExp
+     * @param response - Mock response to return
+     */
+    mock(pattern: string | RegExp, response: MockResponse): void;
+    /**
+     * Register a dynamic handler that can inspect the request and return
+     * a response. Return `null` to pass through to the next handler or
+     * the real network.
+     */
+    onFetch(handler: FetchHandler): void;
+    /**
+     * Remove all mock rules and handlers.
+     */
+    clear(): void;
+    /** Number of registered rules. */
+    get ruleCount(): number;
+    /** Number of registered handlers. */
+    get handlerCount(): number;
+    /**
+     * Try to match a URL against registered rules and handlers.
+     * Returns a Response-like object if matched, or `null` to pass through.
+     */
+    intercept(url: string, init?: RequestInit): Promise<MockResponse | null>;
+    private matches;
+}
+/**
+ * Convert a MockResponse to a format suitable for the `fetch` polyfill.
+ */
+export declare function mockResponseToFetchResponse(mock: MockResponse): {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    text: () => Promise<string>;
+    json: () => Promise<unknown>;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+};

package/dist/npm/cache.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Package cache for npm manifests and tarballs.
+ *
+ * Provides an in-memory cache with an optional persistent backing store
+ * (IndexedDB or any `PersistenceAdapter`-like backend). Manifests have a
+ * configurable TTL; tarballs are immutable by URL and cached indefinitely.
+ *
+ * @example
+ * ```ts
+ * const cache = new PackageCache();
+ * const registry = new Registry();
+ * // Wrap getManifest with cache
+ * const manifest = await cache.getManifest('react', () => registry.getManifest('react'));
+ * ```
+ */
+import type { PackageManifest } from "./registry";
+export interface PackageCacheOptions {
+    /** Manifest TTL in milliseconds. Default: 1 hour. */
+    manifestTtlMs?: number;
+    /** Maximum number of manifests to keep in memory. Default: 500. */
+    maxManifests?: number;
+    /** Maximum number of tarballs to keep in memory. Default: 200. */
+    maxTarballs?: number;
+}
+/**
+ * In-memory cache for npm package manifests and tarball data.
+ *
+ * - **Manifests** are keyed by package name with a configurable TTL (default
+ *   1 hour). After TTL expiry the manifest is re-fetched on next access.
+ * - **Tarballs** are keyed by URL. Since npm tarball URLs are immutable
+ *   (content-addressed), they are cached indefinitely.
+ */
+export declare class PackageCache {
+    private manifests;
+    private tarballs;
+    private manifestTtlMs;
+    private maxManifests;
+    private maxTarballs;
+    constructor(options?: PackageCacheOptions);
+    /**
+     * Get a cached manifest, or fetch and cache it.
+     *
+     * @param name - Package name
+     * @param fetcher - Async function that fetches the manifest from the registry
+     * @returns The manifest (from cache or freshly fetched)
+     */
+    getManifest(name: string, fetcher: () => Promise<PackageManifest>): Promise<PackageManifest>;
+    /** Check if a manifest is cached and not expired. */
+    hasManifest(name: string): boolean;
+    /** Store a manifest in the cache. */
+    setManifest(name: string, manifest: PackageManifest): void;
+    /**
+     * Get a cached tarball, or fetch and cache it.
+     *
+     * @param url - Tarball URL (immutable by npm convention)
+     * @param fetcher - Async function that downloads the tarball
+     * @returns The tarball data
+     */
+    getTarball(url: string, fetcher: () => Promise<Uint8Array>): Promise<Uint8Array>;
+    /** Check if a tarball is cached. */
+    hasTarball(url: string): boolean;
+    /** Store a tarball in the cache. */
+    setTarball(url: string, data: Uint8Array): void;
+    /** Number of cached manifests. */
+    get manifestCount(): number;
+    /** Number of cached tarballs. */
+    get tarballCount(): number;
+    /** Total bytes of cached tarballs. */
+    get tarballBytes(): number;
+    /** Clear all cached manifests. */
+    clearManifests(): void;
+    /** Clear all cached tarballs. */
+    clearTarballs(): void;
+    /** Clear all cached data. */
+    clear(): void;
+}

package/dist/npm/index.d.ts

@@ -0,0 +1,60 @@
+import { MemFS } from "../memfs";
+import { RegistryOptions } from "./registry";
+import { ResolvedPackage } from "./resolver";
+import { PackageCache } from "./cache";
+export interface LayoutStrategy {
+    getPackageDir(cwd: string, pkgName: string, pkgVersion: string): string;
+    createTopLevelLink(vfs: MemFS, cwd: string, pkgName: string, pkgVersion: string): void;
+    createDependencyLinks(vfs: MemFS, cwd: string, pkg: ResolvedPackage, allResolved: Map<string, ResolvedPackage>): void;
+    createBinStub(vfs: MemFS, cwd: string, cmdName: string, targetPath: string): void;
+}
+export declare class NpmLayout implements LayoutStrategy {
+    getPackageDir(cwd: string, pkgName: string, _pkgVersion: string): string;
+    createTopLevelLink(): void;
+    createDependencyLinks(): void;
+    createBinStub(vfs: MemFS, cwd: string, cmdName: string, targetPath: string): void;
+}
+export declare function parsePackageSpec(spec: string): {
+    name: string;
+    version: string;
+};
+export interface InstallOptions {
+    registry?: string;
+    save?: boolean;
+    saveDev?: boolean;
+    includeDev?: boolean;
+    includeOptional?: boolean;
+    onProgress?: (message: string) => void;
+    transform?: boolean;
+    concurrency?: number;
+}
+export interface InstallResult {
+    installed: Map<string, ResolvedPackage>;
+    added: string[];
+}
+export declare class PackageManager {
+    private vfs;
+    private registry;
+    private cwd;
+    readonly layout: LayoutStrategy;
+    /** Package cache for manifests and tarballs. */
+    readonly cache: PackageCache;
+    constructor(vfs: MemFS, options?: {
+        cwd?: string;
+        layout?: LayoutStrategy;
+        cache?: PackageCache;
+    } & RegistryOptions);
+    /** Clear the package cache (manifests and tarballs). */
+    clearCache(): void;
+    install(packageSpec: string | string[], options?: InstallOptions): Promise<InstallResult>;
+    installFromPackageJson(options?: InstallOptions): Promise<InstallResult>;
+    list(): string[];
+    private updatePackageJson;
+}
+export declare function buildLockfile(vfs: MemFS, resolved: Map<string, ResolvedPackage>, cwd?: string): void;
+export { Registry } from "./registry";
+export type { RegistryOptions } from "./registry";
+export type { ResolvedPackage } from "./resolver";
+export { satisfies, compareVersions } from "./resolver";
+export { readLockfile, lockfileToResolved } from "./lockfile-reader";
+export type { LockfileData, LockfileEntry } from "./lockfile-reader";

package/dist/npm/lockfile-reader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Lockfile reader for package-lock.json (v3 format).
+ *
+ * When a lockfile exists, the package manager can skip dependency resolution
+ * entirely and use the exact versions and tarball URLs from the lockfile.
+ * Combined with the package cache, this enables zero-network deterministic
+ * installs.
+ */
+import type { MemFS } from "../memfs";
+import type { ResolvedPackage } from "./resolver";
+/** A single package entry parsed from a lockfile. */
+export interface LockfileEntry {
+    name: string;
+    version: string;
+    resolved: string;
+    dependencies?: Record<string, string>;
+}
+/** Parsed lockfile data. */
+export interface LockfileData {
+    lockfileVersion: number;
+    packages: Map<string, LockfileEntry>;
+}
+/**
+ * Read and parse a package-lock.json (v3 format) from the VFS.
+ * Returns `null` if no lockfile exists or it can't be parsed.
+ */
+export declare function readLockfile(vfs: MemFS, cwd: string): LockfileData | null;
+/**
+ * Convert lockfile entries to ResolvedPackage map for use by the installer.
+ * This replaces the full dependency resolution step when a lockfile is available.
+ */
+export declare function lockfileToResolved(lockfile: LockfileData): Map<string, ResolvedPackage>;

package/dist/npm/pnpm.d.ts

@@ -0,0 +1,18 @@
+import { MemFS } from "../memfs";
+import { LayoutStrategy } from "./index";
+import { ResolvedPackage } from "./resolver";
+/**
+ * pnpm-style content-addressable store layout.
+ *
+ * Structure:
+ *   node_modules/.pnpm/<name>@<version>/node_modules/<name>/  ← actual files
+ *   node_modules/<name>  →  symlink to store path above
+ *   node_modules/.pnpm/<name>@<version>/node_modules/<dep>  →  symlink to dep store
+ */
+export declare class PnpmLayout implements LayoutStrategy {
+    private storePath;
+    getPackageDir(cwd: string, pkgName: string, pkgVersion: string): string;
+    createTopLevelLink(vfs: MemFS, cwd: string, pkgName: string, pkgVersion: string): void;
+    createDependencyLinks(vfs: MemFS, cwd: string, pkg: ResolvedPackage, allResolved: Map<string, ResolvedPackage>): void;
+    createBinStub(vfs: MemFS, cwd: string, cmdName: string, targetPath: string): void;
+}

package/dist/npm/registry.d.ts

@@ -0,0 +1,45 @@
+import type { PackageCache } from "./cache";
+export interface RegistryOptions {
+    registry?: string;
+    token?: string;
+    /** Optional package cache for manifest and tarball caching. */
+    cache?: PackageCache;
+}
+export interface PackageManifest {
+    name: string;
+    "dist-tags": Record<string, string>;
+    versions: Record<string, PackageVersion>;
+}
+export interface PackageVersion {
+    name: string;
+    version: string;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
+    bin?: string | Record<string, string>;
+    main?: string;
+    module?: string;
+    exports?: unknown;
+    dist: {
+        tarball: string;
+        shasum: string;
+        integrity?: string;
+    };
+}
+export declare class Registry {
+    private baseUrl;
+    private token?;
+    private inMemoryCache;
+    private packageCache?;
+    constructor(options?: RegistryOptions);
+    getManifest(name: string): Promise<PackageManifest>;
+    private fetchManifest;
+    getVersion(name: string, version: string): Promise<PackageVersion>;
+    downloadTarball(url: string): Promise<ArrayBuffer>;
+    private fetchTarball;
+    clearCache(): void;
+}

package/dist/npm/resolver.d.ts

@@ -0,0 +1,39 @@
+import type { Registry } from "./registry";
+export interface ResolvedPackage {
+    name: string;
+    version: string;
+    dependencies: Record<string, string>;
+    dist: {
+        tarball: string;
+        shasum: string;
+    };
+    bin?: string | Record<string, string>;
+}
+export interface ResolveOptions {
+    registry: Registry;
+    includeDev?: boolean;
+    includeOptional?: boolean;
+}
+export declare class SemVer {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly pre: string;
+    constructor(raw: string);
+    compareTo(other: SemVer): number;
+    matches(range: string): boolean;
+    toString(): string;
+}
+declare function satisfies(version: string, range: string): boolean;
+declare function compareVersions(a: string, b: string): number;
+declare function findBestVersion(versions: string[], range: string): string | null;
+export declare function resolveDependencies(name: string, versionRange: string, options: ResolveOptions): Promise<Map<string, ResolvedPackage>>;
+export declare function resolveFromPackageJson(packageJson: {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}, options: ResolveOptions): Promise<Map<string, ResolvedPackage>>;
+/** Merge non-optional peerDependencies into deps. Existing deps take precedence. */
+export declare function mergePeerDeps(deps: Record<string, string>, peerDeps: Record<string, string>, peerMeta?: Record<string, {
+    optional?: boolean;
+}>): Record<string, string>;
+export { satisfies, compareVersions, findBestVersion };