@loontail/minecraft-kit 0.3.0 → 0.5.0

package/dist/index.d.cts

@@ -0,0 +1,1714 @@
+/** Pluggable in-memory cache for HTTP metadata responses. */
+interface MetadataCache {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttlMs?: number): void;
+    delete(key: string): void;
+    clear(): void;
+}
+
+/** Subset of fetch headers the library actually uses. */
+type HttpHeaders = Readonly<Record<string, string>>;
+/** Response delivered by the {@link HttpClient} interface. */
+interface HttpResponse {
+    readonly status: number;
+    readonly headers: HttpHeaders;
+    readonly url: string;
+    text(): Promise<string>;
+    json<T = unknown>(): Promise<T>;
+    bytes(): Promise<Uint8Array>;
+    /** Stream the body. The stream may be consumed at most once. */
+    stream(): AsyncIterable<Uint8Array>;
+}
+/** Options for an HTTP request. */
+interface HttpRequestOptions {
+    readonly headers?: HttpHeaders;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    /** When true, do not consult the in-memory cache. */
+    readonly noCache?: boolean;
+}
+/**
+ * Pluggable HTTP client. The default implementation uses Node's built-in fetch; consumers
+ * can inject a fake (e.g. for tests) by passing an `httpClient` to the {@link MinecraftKit}
+ * constructor.
+ */
+interface HttpClient {
+    request(url: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+}
+
+/**
+ * Minecraft release channels matching the `type` field of Mojang version manifest entries.
+ */
+declare const MinecraftChannels: {
+    readonly RELEASE: "release";
+    readonly SNAPSHOT: "snapshot";
+    readonly OLD_BETA: "old_beta";
+    readonly OLD_ALPHA: "old_alpha";
+};
+/** Channel literal as it appears in version manifest entries. */
+type MinecraftChannel = (typeof MinecraftChannels)[keyof typeof MinecraftChannels];
+/**
+ * One entry from the top-level Minecraft `version_manifest_v2.json` listing.
+ *
+ * Note: this is a summary entry, not the full per-version manifest. Use
+ * {@link ResolvedMinecraft} for the resolved/parsed full manifest.
+ */
+interface MinecraftVersionSummary {
+    /** Version id (e.g. `"1.20.1"`). */
+    readonly id: string;
+    /** Release channel. */
+    readonly type: MinecraftChannel;
+    /** URL to the per-version manifest JSON. */
+    readonly url: string;
+    /** Manifest's last edit time (ISO-8601). */
+    readonly time: string;
+    /** Original release time (ISO-8601). */
+    readonly releaseTime: string;
+    /** SHA-1 of the per-version manifest (added in v2). */
+    readonly sha1: string;
+    /** Compliance level: 0 = legacy, 1 = secure-chat / safety features. */
+    readonly complianceLevel: number;
+}
+/** Subset of the per-version manifest used by resolvers and consumers. */
+interface MinecraftVersionManifest {
+    readonly id: string;
+    readonly type: MinecraftChannel | string;
+    readonly mainClass: string;
+    /** Asset index reference. */
+    readonly assetIndex: AssetIndexReference;
+    /** Asset index id (also exposed for legacy callers). */
+    readonly assets: string;
+    readonly downloads: MinecraftDownloads;
+    readonly libraries: readonly MinecraftLibrary[];
+    /** Modern (1.13+) argument structure. Mutually exclusive with {@link minecraftArguments}. */
+    readonly arguments?: MinecraftArguments;
+    /** Legacy (≤1.12.2) argument string. Mutually exclusive with {@link arguments}. */
+    readonly minecraftArguments?: string;
+    readonly javaVersion?: MinecraftJavaVersion;
+    readonly logging?: MinecraftLogging;
+    readonly inheritsFrom?: string;
+    readonly releaseTime?: string;
+    readonly time?: string;
+    readonly minimumLauncherVersion?: number;
+    readonly complianceLevel?: number;
+}
+/** Reference to the asset-index JSON file. */
+interface AssetIndexReference {
+    readonly id: string;
+    readonly sha1: string;
+    readonly size: number;
+    readonly totalSize: number;
+    readonly url: string;
+}
+/** Per-platform downloads block of the Minecraft per-version manifest. */
+interface MinecraftDownloads {
+    readonly client: ArtifactDownload;
+    readonly server?: ArtifactDownload;
+    readonly client_mappings?: ArtifactDownload;
+    readonly server_mappings?: ArtifactDownload;
+}
+/** A single hash-verified download. */
+interface ArtifactDownload {
+    readonly sha1: string;
+    readonly size: number;
+    readonly url: string;
+}
+/** Library entry. Combines vanilla, modern-natives, and legacy-classifier shapes. */
+interface MinecraftLibrary {
+    readonly name: string;
+    readonly downloads?: MinecraftLibraryDownloads;
+    readonly natives?: Readonly<Record<string, string>>;
+    readonly extract?: {
+        readonly exclude?: readonly string[];
+    };
+    readonly rules?: readonly LibraryRule[];
+    /** Some Fabric/Forge libraries carry only a Maven base URL plus a coordinate. */
+    readonly url?: string;
+}
+/** Library downloads block. */
+interface MinecraftLibraryDownloads {
+    readonly artifact?: LibraryArtifact;
+    readonly classifiers?: Readonly<Record<string, LibraryArtifact>>;
+}
+/** An individual library artifact (jar/zip). */
+interface LibraryArtifact extends ArtifactDownload {
+    readonly path: string;
+}
+/** Rule entry used by libraries and modern arguments. */
+interface LibraryRule {
+    readonly action: "allow" | "disallow";
+    readonly os?: {
+        readonly name?: string;
+        readonly arch?: string;
+        readonly version?: string;
+    };
+    readonly features?: Readonly<Record<string, boolean>>;
+}
+/** Modern (1.13+) arguments structure. */
+interface MinecraftArguments {
+    readonly game: readonly ArgumentEntry[];
+    readonly jvm: readonly ArgumentEntry[];
+}
+/** A single argument entry: bare string or rule-gated value. */
+type ArgumentEntry = string | {
+    readonly rules: readonly LibraryRule[];
+    readonly value: string | readonly string[];
+};
+/** Required Java runtime descriptor from the version manifest. */
+interface MinecraftJavaVersion {
+    /** Mojang java-runtime component name (e.g. `java-runtime-gamma`). */
+    readonly component: string;
+    readonly majorVersion: number;
+}
+/** Logging-config entry from the version manifest. */
+interface MinecraftLogging {
+    readonly client?: {
+        readonly argument: string;
+        readonly file: ArtifactDownload & {
+            readonly id: string;
+        };
+        readonly type: string;
+    };
+}
+/**
+ * Fully resolved Minecraft version: summary + parsed manifest, ready to feed into
+ * `kit.targets.create` or `kit.install.plan`.
+ */
+interface ResolvedMinecraft {
+    /** Version id (e.g. `"1.20.1"`). */
+    readonly version: string;
+    readonly channel: MinecraftChannel;
+    readonly manifest: MinecraftVersionManifest;
+    readonly summary: MinecraftVersionSummary;
+}
+/** Asset index document body. */
+interface AssetIndexDocument {
+    readonly objects: Readonly<Record<string, AssetObject>>;
+    readonly virtual?: boolean;
+    readonly map_to_resources?: boolean;
+}
+/** A single asset object hash + size. */
+interface AssetObject {
+    readonly hash: string;
+    readonly size: number;
+}
+
+/** Summary entry from `/v2/versions/loader`. */
+interface FabricLoaderSummary {
+    readonly version: string;
+    readonly stable: boolean;
+    readonly maven: string;
+    readonly build: number;
+    readonly separator: string;
+}
+/** Compatibility entry from `/v2/versions/loader/{minecraftVersion}`. */
+interface FabricCompatibilityEntry {
+    readonly loader: FabricLoaderSummary;
+    readonly intermediary: {
+        readonly version: string;
+        readonly maven: string;
+        readonly stable: boolean;
+    };
+}
+/** Fabric profile JSON returned by `/v2/versions/loader/{mc}/{loader}/profile/json`. */
+interface FabricProfile {
+    readonly id: string;
+    readonly inheritsFrom: string;
+    readonly type: string;
+    readonly mainClass: string;
+    readonly libraries: readonly MinecraftLibrary[];
+    readonly arguments?: {
+        readonly game?: readonly string[];
+        readonly jvm?: readonly string[];
+    };
+}
+/** Resolved Fabric loader for a specific Minecraft version. */
+interface ResolvedFabricLoader {
+    readonly type: typeof Loaders.FABRIC;
+    readonly minecraftVersion: string;
+    readonly loaderVersion: string;
+    readonly profile: FabricProfile;
+}
+
+/** A Forge build entry derived from the Maven metadata XML. */
+interface ForgeBuildSummary {
+    /** Full Maven version string e.g. `"1.20.1-47.2.0"`. */
+    readonly fullVersion: string;
+    /** Minecraft version e.g. `"1.20.1"`. */
+    readonly minecraftVersion: string;
+    /** The portion after the first dash, including any branch suffix. */
+    readonly forgeVersion: string;
+    /** True when this build is the recommended one per `promotions_slim.json`. */
+    readonly isRecommended: boolean;
+    /** True when this build is the latest one per `promotions_slim.json`. */
+    readonly isLatest: boolean;
+}
+/** Modern Forge `install_profile.json` (spec 1) shape — only fields we actually consume. */
+interface ForgeInstallProfile {
+    readonly spec: number;
+    readonly profile: string;
+    readonly version: string;
+    readonly minecraft: string;
+    readonly path?: string | null;
+    readonly json: string;
+    readonly logo?: string;
+    readonly welcome?: string;
+    readonly data: Readonly<Record<string, ForgeProfileData>>;
+    readonly libraries: readonly MinecraftLibrary[];
+    readonly processors: readonly ForgeProcessor[];
+    readonly serverJarPath?: string;
+}
+/** Side-keyed data value pair. */
+interface ForgeProfileData {
+    readonly client: string;
+    readonly server: string;
+}
+/** A single processor invocation. */
+interface ForgeProcessor {
+    readonly sides?: readonly ("client" | "server" | "extract")[];
+    readonly jar: string;
+    readonly classpath: readonly string[];
+    readonly args: readonly string[];
+    readonly outputs?: Readonly<Record<string, string>>;
+}
+/** The version.json stored inside the Forge installer JAR. */
+interface ForgeVersionJson {
+    readonly id: string;
+    readonly inheritsFrom: string;
+    readonly type: string;
+    readonly mainClass: string;
+    readonly libraries: readonly MinecraftLibrary[];
+    readonly arguments?: {
+        readonly game?: readonly string[];
+        readonly jvm?: readonly string[];
+    };
+}
+/** Resolved Forge loader. */
+interface ResolvedForgeLoader {
+    readonly type: typeof Loaders.FORGE;
+    readonly minecraftVersion: string;
+    readonly forgeVersion: string;
+    readonly fullVersion: string;
+    readonly installerUrl: string;
+}
+
+/**
+ * Trivial loader used when no mod loader is in play. Carries the resolved Minecraft so the
+ * launch composer has a uniform view across vanilla / Fabric / Forge.
+ */
+interface ResolvedVanillaLoader {
+    readonly type: typeof Loaders.VANILLA;
+    /** Minecraft version this loader is pinned to. */
+    readonly minecraftVersion: string;
+    /** The Minecraft manifest used for launch — same as the target's `minecraft.manifest`. */
+    readonly minecraft: ResolvedMinecraft;
+}
+
+/**
+ * Discriminator literal identifying which mod loader is active for a target.
+ *
+ * Use the {@link Loaders} const object instead of bare strings. `loader.type === Loaders.FABRIC`
+ * is preferred over `loader.type === "fabric"`.
+ */
+declare const Loaders: {
+    /** Plain vanilla Minecraft, no mod loader. */
+    readonly VANILLA: "vanilla";
+    /** Fabric mod loader. */
+    readonly FABRIC: "fabric";
+    /** Modern (1.13+) Forge mod loader. */
+    readonly FORGE: "forge";
+};
+/** Loader-kind literal (used as discriminator on loader objects). */
+type LoaderKind = (typeof Loaders)[keyof typeof Loaders];
+/**
+ * A fully resolved loader pinned to a specific Minecraft version. Use the `type` field to
+ * narrow to the concrete shape.
+ */
+type Loader = ResolvedVanillaLoader | ResolvedFabricLoader | ResolvedForgeLoader;
+/**
+ * Resolution preference used when a user wants the latest, recommended, or a specific version.
+ * Preferences are inputs to resolvers; resolved targets always carry concrete versions.
+ */
+declare const VersionPreference: {
+    readonly LATEST: "latest";
+    readonly RECOMMENDED: "recommended";
+};
+/** Resolution-preference literal. */
+type VersionPreferenceKind = (typeof VersionPreference)[keyof typeof VersionPreference];
+
+/**
+ * Operating-system identifiers used by Mojang launcher metadata.
+ *
+ * Mojang manifests use `windows`, `osx`, and `linux` as canonical names. These differ
+ * from Node's {@link NodeJS.Platform} values (`win32` / `darwin` / `linux`).
+ */
+declare const OperatingSystems: {
+    readonly WINDOWS: "windows";
+    readonly OSX: "osx";
+    readonly LINUX: "linux";
+};
+/** OS literal as used inside Mojang/Forge/Fabric JSON manifests. */
+type OperatingSystem = (typeof OperatingSystems)[keyof typeof OperatingSystems];
+/**
+ * CPU architecture identifiers. Matches the values that appear in Mojang library `os.arch`
+ * fields, after normalization from Node's {@link NodeJS.Architecture}.
+ */
+declare const Architectures: {
+    readonly X86: "x86";
+    readonly X64: "x64";
+    readonly ARM64: "arm64";
+};
+/** Architecture literal used in launcher metadata. */
+type Architecture = (typeof Architectures)[keyof typeof Architectures];
+/**
+ * Identifies the host system for the launcher. All resolvers consume this object to
+ * pick the right artifacts (libraries, natives, runtime).
+ */
+interface RuntimeSystem {
+    /** OS identifier (mojang naming). */
+    readonly os: OperatingSystem;
+    /** CPU architecture (mojang naming). */
+    readonly arch: Architecture;
+    /** OS version string from `os.release()`. Used to evaluate library `os.version` regex rules. */
+    readonly osVersion: string;
+}
+
+/**
+ * Mojang Java-runtime component identifiers. New components appear over time
+ * (e.g. `java-runtime-delta` for Java 21).
+ *
+ * The launcher must respect the `javaVersion.component` field declared by the per-version
+ * Minecraft manifest. This list captures the set we have direct knowledge about; unknown
+ * components are still allowed and resolved dynamically against the runtime index.
+ */
+declare const RuntimeComponents: {
+    readonly JRE_LEGACY: "jre-legacy";
+    readonly JAVA_RUNTIME_ALPHA: "java-runtime-alpha";
+    readonly JAVA_RUNTIME_BETA: "java-runtime-beta";
+    readonly JAVA_RUNTIME_GAMMA: "java-runtime-gamma";
+    readonly JAVA_RUNTIME_GAMMA_SNAPSHOT: "java-runtime-gamma-snapshot";
+    readonly JAVA_RUNTIME_DELTA: "java-runtime-delta";
+    readonly JAVA_RUNTIME_EPSILON: "java-runtime-epsilon";
+    readonly MINECRAFT_JAVA_EXE: "minecraft-java-exe";
+};
+/** Runtime component literal. */
+type RuntimeComponent = string;
+/** User-supplied resolution preferences. */
+declare const RuntimePreference: {
+    /** Component declared by the Minecraft manifest. */
+    readonly RECOMMENDED: "recommended";
+    /** Newest component available for the platform. */
+    readonly LATEST: "latest";
+};
+/** Runtime preference literal. */
+type RuntimePreferenceKind = (typeof RuntimePreference)[keyof typeof RuntimePreference];
+/** Top-level runtime index returned by Mojang. */
+type RuntimeIndex = Readonly<Record<string, RuntimeIndexPlatform>>;
+/** Per-platform component map inside the runtime index. */
+type RuntimeIndexPlatform = Readonly<Record<string, readonly RuntimeIndexEntry[]>>;
+/** A single available runtime release. */
+interface RuntimeIndexEntry {
+    readonly availability: {
+        readonly group: number;
+        readonly progress: number;
+    };
+    readonly manifest: {
+        readonly sha1: string;
+        readonly size: number;
+        readonly url: string;
+    };
+    readonly version: {
+        readonly name: string;
+        readonly released: string;
+    };
+}
+/** Inner per-component file manifest. */
+interface RuntimeFilesManifest {
+    readonly files: Readonly<Record<string, RuntimeFileEntry>>;
+}
+/** A single file in the runtime manifest. */
+type RuntimeFileEntry = RuntimeFileFile | RuntimeFileDirectory | RuntimeFileLink;
+/** A file entry: real bytes to download, may have lzma sidecar. */
+interface RuntimeFileFile {
+    readonly type: "file";
+    readonly executable: boolean;
+    readonly downloads: {
+        readonly raw: {
+            readonly sha1: string;
+            readonly size: number;
+            readonly url: string;
+        };
+        readonly lzma?: {
+            readonly sha1: string;
+            readonly size: number;
+            readonly url: string;
+        };
+    };
+}
+/** A directory placeholder. */
+interface RuntimeFileDirectory {
+    readonly type: "directory";
+}
+/** A relative symlink. */
+interface RuntimeFileLink {
+    readonly type: "link";
+    readonly target: string;
+}
+/** Resolved runtime ready to install or launch with. */
+interface ResolvedRuntime {
+    /** Mojang component name (e.g. `java-runtime-gamma`). */
+    readonly component: string;
+    /** Platform key inside the runtime index (e.g. `windows-x64`). */
+    readonly platformKey: string;
+    /** Version name (e.g. `"17.0.8"`). */
+    readonly versionName: string;
+    /** Major Java version when known. */
+    readonly majorVersion?: number;
+    readonly system: RuntimeSystem;
+    /** URL of the per-component file manifest. */
+    readonly manifestUrl: string;
+    /** SHA-1 of the file manifest. */
+    readonly manifestSha1: string;
+    /**
+     * Absolute path containing component directories. When set, runtime files for `component`
+     * live at `<installRoot>/<component>/...`. When unset, defaults to `<target.directory>/runtime`.
+     */
+    readonly installRoot?: string;
+}
+
+/**
+ * Fully resolved target: a concrete Minecraft + loader + runtime + directory.
+ *
+ * The library never persists a target — consumers are responsible for storing/recreating
+ * it. `kit.targets.create` produces a Target from already-resolved components;
+ * `kit.targets.resolve` resolves them in one go.
+ */
+interface Target {
+    /** Stable identifier chosen by the consumer. Used for diagnostics, not persistence. */
+    readonly id: string;
+    /** Absolute or relative path to the per-target Minecraft directory. */
+    readonly directory: string;
+    readonly minecraft: ResolvedMinecraft;
+    readonly loader: Loader;
+    readonly runtime: ResolvedRuntime;
+}
+/** Inputs accepted by `kit.targets.create`. */
+interface TargetCreateInput {
+    readonly id: string;
+    readonly directory: string;
+    readonly minecraft: ResolvedMinecraft;
+    readonly loader: Loader;
+    readonly runtime: ResolvedRuntime;
+}
+/**
+ * Discovered installation found by scanning a root directory. Contains only what was
+ * actually read from disk — no assumptions about correctness, completeness, or repair state.
+ */
+interface DiscoveredTarget {
+    /** Subdirectory name under the scanned root. */
+    readonly id: string;
+    /** Absolute or normalized directory path. */
+    readonly directory: string;
+    /** Minecraft version ids found under `versions/`. */
+    readonly minecraftVersions: readonly string[];
+    /** Loader entries inferred from version-name conventions. */
+    readonly loaders: readonly DiscoveredLoaderHint[];
+    /** Detected Java executable, when one is present in the per-target `runtime/` folder. */
+    readonly runtime?: DiscoveredRuntimeHint;
+}
+/** Inferred loader hint (does not assert correctness). */
+interface DiscoveredLoaderHint {
+    readonly type: LoaderKind;
+    readonly minecraftVersion?: string;
+    readonly version?: string;
+}
+/** Detected runtime files. */
+interface DiscoveredRuntimeHint {
+    readonly component?: string;
+    readonly javaPath?: string;
+    readonly javaVersion?: string;
+}
+
+/**
+ * Coarse-grained install phases. Used in `install:phase-changed` events so consumers can
+ * render a progress bar with named steps.
+ */
+declare const InstallPhases: {
+    readonly PLANNING: "planning";
+    readonly DOWNLOADING_VERSION_MANIFEST: "downloading-version-manifest";
+    readonly DOWNLOADING_CLIENT_JAR: "downloading-client-jar";
+    readonly DOWNLOADING_LIBRARIES: "downloading-libraries";
+    readonly DOWNLOADING_ASSET_INDEX: "downloading-asset-index";
+    readonly DOWNLOADING_ASSETS: "downloading-assets";
+    readonly EXTRACTING_NATIVES: "extracting-natives";
+    readonly INSTALLING_RUNTIME: "installing-runtime";
+    readonly INSTALLING_FABRIC: "installing-fabric";
+    readonly INSTALLING_FORGE: "installing-forge";
+    readonly RUNNING_FORGE_PROCESSORS: "running-forge-processors";
+    readonly WRITING_FILES: "writing-files";
+    readonly COMPLETED: "completed";
+};
+/** Install phase literal. */
+type InstallPhase = (typeof InstallPhases)[keyof typeof InstallPhases];
+/** Action kinds inside an {@link InstallPlan}. */
+declare const InstallActionKinds: {
+    readonly DOWNLOAD_FILE: "download-file";
+    readonly EXTRACT_NATIVE: "extract-native";
+    readonly RUN_FORGE_PROCESSOR: "run-forge-processor";
+    readonly WRITE_VERSION_JSON: "write-version-json";
+    readonly WRITE_LOGGING_CONFIG: "write-logging-config";
+};
+/** Discriminator for an install action. */
+type InstallActionKind = (typeof InstallActionKinds)[keyof typeof InstallActionKinds];
+/** A single download step. */
+interface DownloadAction {
+    readonly kind: typeof InstallActionKinds.DOWNLOAD_FILE;
+    readonly url: string;
+    readonly target: string;
+    readonly expectedSha1?: string;
+    readonly expectedSize?: number;
+    readonly category: "client-jar" | "library" | "asset-index" | "asset" | "logging-config" | "fabric-library" | "forge-library" | "runtime-file" | "forge-installer";
+}
+/** A native extraction step. Source jar must already exist on disk. */
+interface ExtractNativeAction {
+    readonly kind: typeof InstallActionKinds.EXTRACT_NATIVE;
+    readonly source: string;
+    readonly destination: string;
+    readonly exclude: readonly string[];
+}
+/**
+ * A Forge processor invocation. `Main-Class` is intentionally NOT carried here — the
+ * runner reads it from `classpath[0]`'s manifest at execution time, because the JAR is
+ * not guaranteed to exist on disk during planning (newer Forge versions ship some
+ * processor JARs as regular Maven libraries instead of bundling them in the installer).
+ */
+interface RunForgeProcessorAction {
+    readonly kind: typeof InstallActionKinds.RUN_FORGE_PROCESSOR;
+    readonly index: number;
+    /** First entry is the processor JAR; remaining entries are its declared classpath. */
+    readonly classpath: readonly string[];
+    readonly args: readonly string[];
+    readonly outputs: Readonly<Record<string, string>>;
+}
+/** Write a version JSON to disk (Fabric / Forge). */
+interface WriteVersionJsonAction {
+    readonly kind: typeof InstallActionKinds.WRITE_VERSION_JSON;
+    readonly path: string;
+    readonly content: string;
+}
+/** Write a logging config (log4j XML) to disk. */
+interface WriteLoggingConfigAction {
+    readonly kind: typeof InstallActionKinds.WRITE_LOGGING_CONFIG;
+    readonly path: string;
+    readonly content: string;
+}
+/** Discriminated union of install actions. */
+type InstallAction = DownloadAction | ExtractNativeAction | RunForgeProcessorAction | WriteVersionJsonAction | WriteLoggingConfigAction;
+/**
+ * Pre-computed install plan: a flat ordered list of actions plus computed totals.
+ *
+ * The runner consumes this; nothing is downloaded or written during planning. The plan
+ * carries a reference to the resolved target so the runner does not need a second target
+ * argument.
+ */
+interface InstallPlan {
+    readonly targetId: string;
+    readonly directory: string;
+    readonly target: Target;
+    readonly actions: readonly InstallAction[];
+    readonly totalBytes: number;
+    readonly totalActions: number;
+}
+/** Outcome summary returned by `install.run`. */
+interface InstallReport {
+    readonly targetId: string;
+    readonly bytesDownloaded: number;
+    readonly actionsCompleted: number;
+    readonly actionsSkipped: number;
+    readonly durationMs: number;
+}
+
+/** Inputs to {@link planRuntimeInstall}. */
+interface PlanRuntimeInstallInput {
+    readonly target: Target;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Build an install plan that downloads ONLY the Java runtime declared by `target.runtime`.
+ *
+ * Useful when the consumer wants to provision a JRE without touching the rest of the
+ * Minecraft installation (no client jar, no libraries, no assets). When `target.runtime.installRoot`
+ * is set the runtime files land in a shared global location instead of the per-target folder.
+ *
+ * The returned plan is a regular {@link InstallPlan}, so it can be passed to the existing
+ * install runner — directory placeholders and symlinks declared by the runtime manifest are
+ * still materialized after downloads complete.
+ */
+declare function planRuntimeInstall(input: PlanRuntimeInstallInput): Promise<InstallPlan>;
+/** Inputs to {@link planStandaloneRuntimeInstall}. */
+interface PlanStandaloneRuntimeInstallInput {
+    readonly id: string;
+    /** Where the runtime files live. Used as `directory` if `runtime.installRoot` is unset. */
+    readonly directory: string;
+    readonly runtime: ResolvedRuntime;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Plan a runtime-only install **without a Minecraft target**. Useful for "Install Java/runtime"
+ * flows where the user just wants a JRE on disk and never had a Minecraft version to choose
+ * from. The returned plan is shaped exactly like a normal {@link InstallPlan} and runs through
+ * the standard install runner — but its `target.minecraft` and `target.loader` fields are
+ * intentional placeholders. The runner only reads `target.runtime` for runtime-only plans, so
+ * the placeholders are never accessed at runtime.
+ */
+declare function planStandaloneRuntimeInstall(input: PlanStandaloneRuntimeInstallInput): Promise<InstallPlan>;
+
+/** Log levels accepted by the pluggable logger. */
+declare const LogLevels: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+/** Log-level literal. */
+type LogLevel = (typeof LogLevels)[keyof typeof LogLevels];
+/** Pluggable logger. Default implementation is a silent logger; pass your own to surface logs. */
+interface Logger {
+    log(level: LogLevel, message: string, fields?: Readonly<Record<string, unknown>>): void;
+}
+
+/** Shared context passed to every resolver. */
+interface ResolverContext {
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly logger: Logger;
+}
+
+/** Inputs to {@link FabricVersionsApi.list}. */
+interface FabricListInput {
+    readonly minecraftVersion?: string;
+    readonly signal?: AbortSignal;
+}
+/** Inputs to {@link FabricVersionsApi.resolve}. */
+interface FabricResolveInput {
+    readonly minecraftVersion: string;
+    readonly preference?: VersionPreferenceKind;
+    readonly loaderVersion?: string;
+    readonly signal?: AbortSignal;
+}
+/** Public Fabric versions API surface. */
+declare class FabricVersionsApi {
+    private readonly ctx;
+    constructor(ctx: ResolverContext);
+    /** List Fabric loader versions, optionally constrained to a Minecraft version. */
+    list(input?: FabricListInput): Promise<readonly FabricLoaderSummary[]>;
+    /** Resolve a Fabric loader version against a Minecraft version. */
+    resolve(input: FabricResolveInput): Promise<ResolvedFabricLoader>;
+}
+
+/** Inputs to {@link ForgeVersionsApi.list}. */
+interface ForgeListInput {
+    readonly minecraftVersion?: string;
+    readonly signal?: AbortSignal;
+}
+/** Inputs to {@link ForgeVersionsApi.resolve}. */
+interface ForgeResolveInput {
+    readonly minecraftVersion: string;
+    readonly preference?: VersionPreferenceKind;
+    readonly forgeVersion?: string;
+    readonly signal?: AbortSignal;
+}
+/** Public Forge versions API surface. */
+declare class ForgeVersionsApi {
+    private readonly ctx;
+    constructor(ctx: ResolverContext);
+    /** List Forge builds (across all Minecraft versions, or filtered to one). */
+    list(input?: ForgeListInput): Promise<readonly ForgeBuildSummary[]>;
+    /** Resolve a Forge build for a Minecraft version. */
+    resolve(input: ForgeResolveInput): Promise<ResolvedForgeLoader>;
+}
+
+/** Inputs to {@link MinecraftVersionsApi.list}. */
+interface MinecraftListInput {
+    readonly channel?: MinecraftChannel;
+    readonly signal?: AbortSignal;
+}
+/** Inputs to {@link MinecraftVersionsApi.latest}. */
+interface MinecraftLatestInput {
+    readonly channel?: MinecraftChannel;
+    readonly signal?: AbortSignal;
+}
+/** Inputs to {@link MinecraftVersionsApi.get} / `.resolve`. */
+interface MinecraftGetInput {
+    readonly version: string;
+    readonly signal?: AbortSignal;
+}
+/** Public Minecraft versions API surface. */
+declare class MinecraftVersionsApi {
+    private readonly ctx;
+    constructor(ctx: ResolverContext);
+    /** List all Minecraft versions, optionally filtered by channel. */
+    list(input?: MinecraftListInput): Promise<readonly MinecraftVersionSummary[]>;
+    /** Return the latest version on the given channel (defaults to RELEASE). */
+    latest(input?: MinecraftLatestInput): Promise<MinecraftVersionSummary>;
+    /** Return a single version summary or throw `MANIFEST_NOT_FOUND`. */
+    get(input: MinecraftGetInput): Promise<MinecraftVersionSummary>;
+    /** Fetch and parse the per-version manifest in addition to the summary. */
+    resolve(input: MinecraftGetInput): Promise<ResolvedMinecraft>;
+    private fetchManifestRoot;
+}
+
+/** Inputs to {@link RuntimeVersionsApi.list}. */
+interface RuntimeListInput {
+    readonly system: RuntimeSystem;
+    readonly minecraftVersion?: string;
+    readonly signal?: AbortSignal;
+}
+/** A summary entry for the list API. */
+interface RuntimeListEntry {
+    readonly component: string;
+    readonly platformKey: string;
+    readonly versionName: string;
+    readonly released: string;
+    readonly manifestUrl: string;
+}
+/** Inputs to {@link RuntimeVersionsApi.resolve}. */
+interface RuntimeResolveInput {
+    readonly system: RuntimeSystem;
+    readonly minecraftVersion?: string;
+    readonly component?: string;
+    readonly preference?: RuntimePreferenceKind;
+    readonly signal?: AbortSignal;
+}
+/** Public runtime versions API surface. */
+declare class RuntimeVersionsApi {
+    private readonly ctx;
+    constructor(ctx: ResolverContext);
+    /** List available runtime entries for the host platform. */
+    list(input: RuntimeListInput): Promise<readonly RuntimeListEntry[]>;
+    /** Resolve a single runtime for the host platform and Minecraft version. */
+    resolve(input: RuntimeResolveInput): Promise<ResolvedRuntime>;
+    private fetchIndex;
+}
+
+/** Inputs to {@link TargetsApi.resolve}. */
+interface TargetResolveInput {
+    readonly id: string;
+    readonly directory: string;
+    readonly minecraft: {
+        readonly version: string;
+    };
+    readonly loader: TargetLoaderInput;
+    readonly runtime?: {
+        readonly preference?: RuntimePreferenceKind;
+        /** Override the runtime component. Defaults to the Minecraft manifest's `javaVersion.component`. */
+        readonly component?: string;
+        /**
+         * Custom install root (absolute path) holding the component directories.
+         * When unset, runtime files live under `<directory>/runtime/`.
+         */
+        readonly installRoot?: string;
+    };
+    readonly system?: RuntimeSystem;
+    readonly signal?: AbortSignal;
+}
+/** Loader input variants. */
+type TargetLoaderInput = {
+    readonly type: typeof Loaders.VANILLA;
+} | {
+    readonly type: typeof Loaders.FABRIC;
+    readonly preference?: VersionPreferenceKind;
+    readonly version?: string;
+} | {
+    readonly type: typeof Loaders.FORGE;
+    readonly preference?: VersionPreferenceKind;
+    readonly version?: string;
+};
+/** Inputs to {@link TargetsApi.list}. */
+interface TargetListInput {
+    readonly rootDir: string;
+}
+/** Constructor inputs for {@link TargetsApi}. */
+interface TargetsApiContext {
+    readonly minecraft: MinecraftVersionsApi;
+    readonly fabric: FabricVersionsApi;
+    readonly forge: ForgeVersionsApi;
+    readonly runtime: RuntimeVersionsApi;
+    readonly system: RuntimeSystem;
+}
+/** Public Targets API surface. */
+declare class TargetsApi {
+    private readonly ctx;
+    constructor(ctx: TargetsApiContext);
+    /** The detected host system used by `resolve()` when no `system` is supplied. */
+    get system(): RuntimeSystem;
+    /** Build a {@link Target} from already-resolved components. */
+    create(input: TargetCreateInput): Target;
+    /** Sugar API: resolve every component then assemble a target. */
+    resolve(input: TargetResolveInput): Promise<Target>;
+    /** Scan a root directory for Minecraft installations. Returns only what is on disk. */
+    list(input: TargetListInput): Promise<readonly DiscoveredTarget[]>;
+}
+
+/** Aspect of an installation a verification result describes. */
+declare const VerificationKinds: {
+    readonly MINECRAFT: "minecraft";
+    readonly FABRIC: "fabric";
+    readonly FORGE: "forge";
+    readonly RUNTIME: "runtime";
+};
+/** Verification kind literal. */
+type VerificationKind = (typeof VerificationKinds)[keyof typeof VerificationKinds];
+/** Status of an individual file checked during verification. */
+declare const VerifyFileStatuses: {
+    readonly OK: "ok";
+    readonly MISSING: "missing";
+    readonly CORRUPT: "corrupt";
+    readonly WRONG_SIZE: "wrong-size";
+};
+/** File status literal. */
+type VerifyFileStatus = (typeof VerifyFileStatuses)[keyof typeof VerifyFileStatuses];
+/** Categories assigned to each verified file for easier filtering. */
+declare const VerifyFileCategories: {
+    readonly CLIENT_JAR: "client-jar";
+    readonly LIBRARY: "library";
+    readonly ASSET: "asset";
+    readonly ASSET_INDEX: "asset-index";
+    readonly NATIVE: "native";
+    readonly LOADER_LIBRARY: "loader-library";
+    readonly RUNTIME_FILE: "runtime-file";
+    readonly LOGGING_CONFIG: "logging-config";
+};
+/** Verification file category literal. */
+type VerifyFileCategory = (typeof VerifyFileCategories)[keyof typeof VerifyFileCategories];
+/** A single verified file. */
+interface VerificationFileResult {
+    readonly path: string;
+    readonly category: VerifyFileCategory;
+    readonly status: VerifyFileStatus;
+    readonly expectedSha1?: string;
+    readonly actualSha1?: string;
+    readonly expectedSize?: number;
+    readonly actualSize?: number;
+    /** Optional URL where the file can be re-downloaded if it's broken. */
+    readonly url?: string;
+}
+/** Aggregate verification result returned by each `verify.<kind>.run` API. */
+interface VerificationResult {
+    readonly targetId: string;
+    readonly kind: VerificationKind;
+    readonly isValid: boolean;
+    readonly issues: readonly VerificationFileResult[];
+    readonly checkedFiles: number;
+    readonly durationMs: number;
+}
+
+/** Coarse-grained repair phases used for `repair:phase-changed` events. */
+declare const RepairPhases: {
+    readonly PLANNING: "planning";
+    readonly REPAIRING_CLIENT_JAR: "repairing-client-jar";
+    readonly REPAIRING_LIBRARIES: "repairing-libraries";
+    readonly REPAIRING_ASSETS: "repairing-assets";
+    readonly REPAIRING_NATIVES: "repairing-natives";
+    readonly REPAIRING_RUNTIME: "repairing-runtime";
+    readonly REPAIRING_LOADER: "repairing-loader";
+    readonly COMPLETED: "completed";
+};
+/** Repair phase literal. */
+type RepairPhase = (typeof RepairPhases)[keyof typeof RepairPhases];
+/**
+ * A repair plan is, structurally, an install plan limited to actions needed to fix the
+ * issues reported by a previous {@link VerificationResult}. The runner is the same.
+ */
+interface RepairPlan {
+    readonly targetId: string;
+    readonly directory: string;
+    readonly target: Target;
+    readonly actions: readonly InstallAction[];
+    readonly totalBytes: number;
+    readonly totalActions: number;
+}
+/** Repair report — same shape as install report. */
+interface RepairReport {
+    readonly targetId: string;
+    readonly bytesDownloaded: number;
+    readonly actionsCompleted: number;
+    readonly durationMs: number;
+}
+/**
+ * Inputs accepted by every aspect-specific `planXxxRepair` (`planMinecraftRepair`,
+ * `planFabricRepair`, `planForgeRepair`, `planRuntimeRepair`). The per-aspect input types
+ * are aliases over this shape.
+ */
+interface AspectRepairInput {
+    readonly target: Target;
+    readonly from: VerificationResult | readonly VerificationResult[];
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+}
+
+/**
+ * Stable string constants for the `type` discriminator of every {@link ProgressEvent}.
+ * Use these instead of bare string literals when filtering events.
+ */
+declare const EventTypes: {
+    readonly INSTALL_PHASE_CHANGED: "install:phase-changed";
+    readonly DOWNLOAD_STARTED: "download:started";
+    readonly DOWNLOAD_PROGRESS: "download:progress";
+    readonly DOWNLOAD_SKIPPED: "download:skipped";
+    readonly DOWNLOAD_COMPLETED: "download:completed";
+    readonly DOWNLOAD_FAILED: "download:failed";
+    readonly INTEGRITY_VERIFIED: "integrity:verified";
+    readonly INTEGRITY_MISMATCH: "integrity:mismatch";
+    readonly ARCHIVE_EXTRACTED: "archive:extracted";
+    readonly FORGE_PROCESSOR_STARTED: "forge:processor-started";
+    readonly FORGE_PROCESSOR_COMPLETED: "forge:processor-completed";
+    readonly FORGE_PROCESSOR_OUTPUT_VERIFIED: "forge:processor-output-verified";
+    readonly VERIFY_FILE_CHECKED: "verify:file-checked";
+    readonly VERIFY_COMPLETED: "verify:completed";
+    readonly REPAIR_PHASE_CHANGED: "repair:phase-changed";
+    readonly LAUNCH_STARTING: "launch:starting";
+    readonly LAUNCH_STARTED: "launch:started";
+    readonly LAUNCH_STDOUT: "launch:stdout";
+    readonly LAUNCH_STDERR: "launch:stderr";
+    readonly LAUNCH_EXITED: "launch:exited";
+    readonly LAUNCH_ABORTED: "launch:aborted";
+};
+/** Literal type of the `type` discriminator of a {@link ProgressEvent}. */
+type EventType = (typeof EventTypes)[keyof typeof EventTypes];
+/** Reference to a single file used in download events. */
+interface FileRef {
+    readonly url: string;
+    readonly target: string;
+    readonly category?: string;
+}
+/** A single processor description used in Forge events. */
+interface ProcessorRef {
+    readonly index: number;
+    readonly mainClass: string;
+}
+/**
+ * Discriminated union of all runtime progress events. Pass an `onEvent` callback to
+ * `install.run`, `update.run`, `verify.run`, `repair.run`, or `launch.run` to receive these.
+ */
+type ProgressEvent = {
+    readonly type: "install:phase-changed";
+    readonly phase: InstallPhase;
+    readonly previous: InstallPhase | null;
+} | {
+    readonly type: "download:started";
+    readonly file: FileRef;
+    readonly expectedSize: number;
+} | {
+    readonly type: "download:progress";
+    readonly file: FileRef;
+    readonly bytesDownloaded: number;
+    readonly totalBytes: number;
+} | {
+    readonly type: "download:skipped";
+    readonly file: FileRef;
+} | {
+    readonly type: "download:completed";
+    readonly file: FileRef;
+    readonly durationMs: number;
+    readonly bytes: number;
+} | {
+    readonly type: "download:failed";
+    readonly file: FileRef;
+    readonly error: Error;
+    readonly willRetry: boolean;
+} | {
+    readonly type: "integrity:verified";
+    readonly file: FileRef;
+    readonly algorithm: "sha1" | "sha256";
+    readonly hash: string;
+} | {
+    readonly type: "integrity:mismatch";
+    readonly file: FileRef;
+    readonly algorithm: "sha1" | "sha256";
+    readonly expected: string;
+    readonly actual: string;
+} | {
+    readonly type: "archive:extracted";
+    readonly archive: string;
+    readonly target: string;
+    readonly fileCount: number;
+} | {
+    readonly type: "forge:processor-started";
+    readonly processor: ProcessorRef;
+    readonly total: number;
+} | {
+    readonly type: "forge:processor-completed";
+    readonly processor: ProcessorRef;
+    readonly exitCode: number;
+    readonly durationMs: number;
+} | {
+    readonly type: "forge:processor-output-verified";
+    readonly processor: ProcessorRef;
+    readonly path: string;
+} | {
+    readonly type: "verify:file-checked";
+    readonly file: VerificationFileResult;
+} | {
+    readonly type: "verify:completed";
+    readonly summary: VerificationResult;
+} | {
+    readonly type: "repair:phase-changed";
+    readonly phase: RepairPhase;
+    readonly previous: RepairPhase | null;
+} | {
+    readonly type: "launch:starting";
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+} | {
+    readonly type: "launch:started";
+    readonly pid: number;
+} | {
+    readonly type: "launch:stdout";
+    readonly line: string;
+} | {
+    readonly type: "launch:stderr";
+    readonly line: string;
+} | {
+    readonly type: "launch:exited";
+    readonly code: number | null;
+    readonly signal: NodeJS.Signals | null;
+} | {
+    readonly type: "launch:aborted";
+    readonly reason: string;
+};
+/** Listener signature accepted by every long-running operation. */
+type ProgressListener = (event: ProgressEvent) => void;
+/** Common options accepted by long-running operations. */
+interface OperationOptions {
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+
+/** Authentication modes accepted by the launch composer. */
+declare const AuthModes: {
+    /** Offline-mode play with a chosen username and synthetic UUID. */
+    readonly OFFLINE: "offline";
+    /** Pre-authenticated session — caller provides the access token and identity. */
+    readonly ONLINE: "online";
+};
+/** Auth mode literal. */
+type AuthMode = (typeof AuthModes)[keyof typeof AuthModes];
+/** Offline authentication. */
+interface OfflineAuth {
+    readonly mode: typeof AuthModes.OFFLINE;
+    readonly username: string;
+    /** Optional explicit UUID. When omitted, a deterministic UUID is derived from the username. */
+    readonly uuid?: string;
+}
+/** Online (token-based) authentication. */
+interface OnlineAuth {
+    readonly mode: typeof AuthModes.ONLINE;
+    readonly username: string;
+    readonly uuid: string;
+    readonly accessToken: string;
+    readonly userType?: string;
+    readonly clientId?: string;
+    readonly xuid?: string;
+}
+/** Auth shape consumed by `kit.launch.compose`. */
+type LaunchAuth = OfflineAuth | OnlineAuth;
+
+/** Optional memory configuration. */
+interface LaunchMemoryOptions {
+    readonly minMb?: number;
+    readonly maxMb?: number;
+}
+/** Optional resolution / window configuration. */
+interface LaunchResolutionOptions {
+    readonly width: number;
+    readonly height: number;
+}
+/** Inputs for `kit.launch.compose` (and the lower-level `composeLaunch` helper). */
+interface LaunchOptions {
+    readonly auth: LaunchAuth;
+    readonly memory?: LaunchMemoryOptions;
+    readonly resolution?: LaunchResolutionOptions;
+    readonly fullscreen?: boolean;
+    /** Brand string injected as `${launcher_name}`. */
+    readonly launcherName?: string;
+    /** Version string injected as `${launcher_version}`. */
+    readonly launcherVersion?: string;
+    /** Extra JVM args appended after composed JVM args. */
+    readonly extraJvmArgs?: readonly string[];
+    /** Extra game args appended after composed game args. */
+    readonly extraGameArgs?: readonly string[];
+    /** Set of feature flags evaluated by argument rules (e.g. `is_demo_user`). */
+    readonly features?: Readonly<Record<string, boolean>>;
+}
+/** Fully composed launch command, ready to be passed to `kit.launch.run`. */
+interface LaunchComposition {
+    readonly targetId: string;
+    readonly directory: string;
+    readonly javaPath: string;
+    readonly mainClass: string;
+    readonly jvmArgs: readonly string[];
+    readonly gameArgs: readonly string[];
+    readonly classpath: readonly string[];
+    readonly nativesDirectory: string;
+    readonly auth: LaunchAuth;
+    /** Spawn working directory (almost always equal to {@link directory}). */
+    readonly workingDirectory: string;
+    /** Environment variables to set on the spawned process. */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** Live handle for a running game process. */
+interface LaunchSession {
+    /** Operating-system process id. */
+    readonly pid: number;
+    /** Resolves with the exit code/signal when the process terminates. */
+    readonly exited: Promise<LaunchExit>;
+    /** Best-effort cancel — sends SIGTERM, then SIGKILL after the grace period. */
+    abort(reason?: string): void;
+}
+/** Outcome of a finished launch. */
+interface LaunchExit {
+    readonly code: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly aborted: boolean;
+}
+/** Options for `kit.launch.run` (and the lower-level `runLaunch` helper). */
+interface LaunchRunOptions {
+    readonly signal?: AbortSignal;
+    readonly onEvent?: (event: ProgressEvent) => void;
+    /** Milliseconds to wait between SIGTERM and SIGKILL when aborting. */
+    readonly killGracePeriodMs?: number;
+}
+
+/** Stream-of-text channel exposed by spawned processes. */
+interface ProcessStream {
+    on(event: "data", listener: (chunk: string) => void): void;
+}
+/** Live handle for a child process. */
+interface SpawnedProcess {
+    readonly pid: number;
+    readonly stdout: ProcessStream;
+    readonly stderr: ProcessStream;
+    /** Resolves when the process exits with its exit info. */
+    readonly exited: Promise<{
+        readonly code: number | null;
+        readonly signal: NodeJS.Signals | null;
+    }>;
+    /** Send a termination signal. Returns true on success. */
+    kill(signal?: NodeJS.Signals): boolean;
+}
+/** Options accepted by the spawner. */
+interface SpawnOptions {
+    readonly cwd: string;
+    readonly env?: Readonly<Record<string, string>>;
+}
+/**
+ * Pluggable process spawner. The default implementation uses `node:child_process`; tests
+ * inject a fake to avoid spawning real processes.
+ */
+interface Spawner {
+    spawn(command: string, args: readonly string[], options: SpawnOptions): SpawnedProcess;
+}
+
+/** Update plan — additive list of actions to bring an installation up to date. */
+interface UpdatePlan {
+    readonly targetId: string;
+    readonly directory: string;
+    readonly target: Target;
+    readonly actions: readonly InstallAction[];
+    readonly totalBytes: number;
+    readonly totalActions: number;
+}
+/** Update report. */
+interface UpdateReport {
+    readonly targetId: string;
+    readonly bytesDownloaded: number;
+    readonly actionsCompleted: number;
+    /** Actions that found their target already correct on disk and were skipped. */
+    readonly actionsSkipped: number;
+    readonly durationMs: number;
+}
+
+/** Constructor options for {@link MinecraftKit}. */
+interface MinecraftKitOptions {
+    readonly httpClient?: HttpClient;
+    readonly cache?: MetadataCache;
+    readonly logger?: Logger;
+    readonly system?: RuntimeSystem;
+    readonly spawner?: Spawner;
+}
+/**
+ * Single facade for the entire library.
+ *
+ * @example
+ * ```ts
+ * const kit = new MinecraftKit();
+ * const target = await kit.targets.resolve({ id, directory, minecraft: { version: '1.20.1' }, loader: { type: Loaders.VANILLA } });
+ * const plan = await kit.install.plan(target);
+ * await kit.install.run(plan, { onEvent: console.log });
+ * ```
+ */
+declare class MinecraftKit {
+    readonly versions: {
+        readonly minecraft: MinecraftVersionsApi;
+        readonly fabric: FabricVersionsApi;
+        readonly forge: ForgeVersionsApi;
+        readonly runtime: RuntimeVersionsApi;
+    };
+    readonly targets: TargetsApi;
+    readonly install: {
+        plan(target: Target, options?: OperationOptions): Promise<InstallPlan>;
+        run(plan: InstallPlan, options?: OperationOptions): Promise<InstallReport>;
+        /** Install only the Java runtime declared by `target.runtime` (honours `installRoot`). */
+        readonly runtime: {
+            plan(target: Target, options?: OperationOptions): Promise<InstallPlan>;
+            run(plan: InstallPlan, options?: OperationOptions): Promise<InstallReport>;
+            /**
+             * Plan a runtime-only install without an existing Minecraft Target. The caller
+             * supplies a {@link ResolvedRuntime} (typically from `kit.versions.runtime.resolve`)
+             * plus a directory and stable id.
+             */
+            standalonePlan(input: Omit<PlanStandaloneRuntimeInstallInput, "http" | "cache">): Promise<InstallPlan>;
+        };
+    };
+    readonly update: {
+        plan(target: Target, options?: OperationOptions): Promise<UpdatePlan>;
+        run(plan: UpdatePlan, options?: OperationOptions): Promise<UpdateReport>;
+    };
+    readonly verify: {
+        /** Verify the vanilla Minecraft slice (client jar, libraries, assets, natives, log config). */
+        readonly minecraft: {
+            run(target: Target, options?: VerifyOperationOptions): Promise<VerificationResult>;
+        };
+        /** Verify the Fabric loader slice (profile JSON + libraries). Throws on non-Fabric targets. */
+        readonly fabric: {
+            run(target: Target, options?: VerifyOperationOptions): Promise<VerificationResult>;
+        };
+        /** Verify the Forge loader slice (version JSON + libraries). Throws on non-Forge targets. */
+        readonly forge: {
+            run(target: Target, options?: VerifyOperationOptions): Promise<VerificationResult>;
+        };
+        /** Verify the Java runtime files. Honours `target.runtime.installRoot` for shared installs. */
+        readonly runtime: {
+            run(target: Target, options?: VerifyOperationOptions): Promise<VerificationResult>;
+        };
+    };
+    readonly repair: {
+        /** Repair the vanilla Minecraft slice (client jar, libraries, assets, natives, log config). */
+        readonly minecraft: RepairAspect;
+        /** Repair the Fabric loader slice (profile JSON + libraries). Throws on non-Fabric targets. */
+        readonly fabric: RepairAspect;
+        /** Repair the Forge loader slice (version JSON + libraries + processors). Throws on non-Forge. */
+        readonly forge: RepairAspect;
+        /** Repair the Java runtime files. Honours `target.runtime.installRoot`. */
+        readonly runtime: RepairAspect;
+    };
+    readonly launch: {
+        compose(target: Target, options: LaunchOptions): Promise<LaunchComposition>;
+        run(composition: LaunchComposition, options?: LaunchRunOptions): LaunchSession;
+    };
+    /** Cache surface useful for advanced consumers (e.g. clearing between operations). */
+    readonly cache: MetadataCache;
+    constructor(options?: MinecraftKitOptions);
+}
+/** Options accepted by every `verify.<kind>.run`. */
+interface VerifyOperationOptions {
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/** Options for any `repair.<aspect>.plan` call. Accepts one or many verification results. */
+interface RepairPlanOptions {
+    readonly from: VerificationResult | readonly VerificationResult[];
+    readonly signal?: AbortSignal;
+}
+/** Shared shape of every aspect-specific repair surface (`repair.minecraft`, `.fabric`, …). */
+interface RepairAspect {
+    plan(target: Target, options: RepairPlanOptions): Promise<RepairPlan>;
+    run(plan: RepairPlan, options?: OperationOptions): Promise<RepairReport>;
+}
+
+/** Inputs to {@link createMemoryCache}. */
+interface MemoryCacheOptions {
+    readonly maxEntries?: number;
+    readonly ttlMs?: number;
+}
+/** In-memory metadata cache backed by `lru-cache`. */
+declare function createMemoryCache(options?: MemoryCacheOptions): MetadataCache;
+
+/** Inputs allowing the host system to be derived from current Node values or overrides. */
+interface DetectSystemInput {
+    readonly platform?: NodeJS.Platform;
+    readonly arch?: NodeJS.Architecture;
+    readonly osVersion?: string;
+}
+/**
+ * Resolve the current host system identifiers.
+ *
+ * @throws {@link MinecraftKitError} with code `RUNTIME_UNSUPPORTED_PLATFORM` when the
+ * platform/arch combination is not understood.
+ */
+declare function detectSystem(input?: DetectSystemInput): RuntimeSystem;
+
+/** Inputs to {@link verifyMinecraft}. */
+interface VerifyMinecraftInput {
+    readonly target: Target;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/**
+ * Verify the vanilla Minecraft slice of an installation: the client jar, version JSON,
+ * libraries (incl. native jars), assets (index + objects), logging config, and the
+ * extracted natives directory.
+ */
+declare function verifyMinecraft(input: VerifyMinecraftInput): Promise<VerificationResult>;
+
+/** Inputs to {@link verifyFabric}. */
+interface VerifyFabricInput {
+    readonly target: Target;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/** Verify the Fabric loader slice: profile JSON + every library it pulls in. */
+declare function verifyFabric(input: VerifyFabricInput): Promise<VerificationResult>;
+
+/** Inputs to {@link verifyForge}. */
+interface VerifyForgeInput {
+    readonly target: Target;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/**
+ * Verify the Forge loader slice: the on-disk Forge version JSON and every library it
+ * declares. Libraries can only be enumerated once the JSON is present *and parsable*; a
+ * malformed JSON is surfaced as a CORRUPT issue so repair rewrites it before re-running.
+ */
+declare function verifyForge(input: VerifyForgeInput): Promise<VerificationResult>;
+
+/** Inputs to {@link verifyRuntime}. */
+interface VerifyRuntimeInput {
+    readonly target: Target;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/**
+ * Verify the Java runtime files. Honours `target.runtime.installRoot` when set so a
+ * shared/global runtime install is checked at its real location instead of the per-target
+ * `runtime/` subfolder.
+ */
+declare function verifyRuntime(input: VerifyRuntimeInput): Promise<VerificationResult>;
+
+/** Inputs to {@link runRepair}. Shared across all aspect-specific repair flows. */
+interface RunRepairInput {
+    readonly plan: RepairPlan;
+    readonly http: HttpClient;
+    readonly cache: MetadataCache;
+    readonly spawner: Spawner;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: ProgressListener;
+}
+/** Execute any repair plan. Reuses the install runner. */
+declare function runRepair(input: RunRepairInput): Promise<RepairReport>;
+
+/** Inputs to {@link planMinecraftRepair}. */
+type PlanMinecraftRepairInput = AspectRepairInput;
+/**
+ * Build a repair plan covering only the vanilla Minecraft slice: client jar, version JSON,
+ * libraries (incl. native jars), assets, logging config, and native extractions.
+ */
+declare function planMinecraftRepair(input: PlanMinecraftRepairInput): Promise<RepairPlan>;
+
+/** Inputs to {@link planFabricRepair}. */
+type PlanFabricRepairInput = AspectRepairInput;
+/** Build a repair plan covering the Fabric loader slice: profile JSON + libraries. */
+declare function planFabricRepair(input: PlanFabricRepairInput): Promise<RepairPlan>;
+
+/** Inputs to {@link planForgeRepair}. */
+type PlanForgeRepairInput = AspectRepairInput;
+/**
+ * Build a repair plan covering the Forge loader slice: version JSON, libraries, installer
+ * download, and the Forge processors that produce the final installation. When the Forge
+ * version JSON was missing during verify (so libraries couldn't be enumerated), every
+ * forge-library download is added defensively — `downloadFile` skips files already on disk.
+ */
+declare function planForgeRepair(input: PlanForgeRepairInput): Promise<RepairPlan>;
+
+/** Inputs to {@link planRuntimeRepair}. */
+type PlanRuntimeRepairInput = AspectRepairInput;
+/**
+ * Build a repair plan covering the Java runtime files. `target.runtime.installRoot` is
+ * honoured automatically because both `planInstall` and the verify side resolve runtime
+ * paths through the same `targetPaths.runtimeRoot(..., installRoot)` helper.
+ */
+declare function planRuntimeRepair(input: PlanRuntimeRepairInput): Promise<RepairPlan>;
+
+/**
+ * Stable error code discriminator. Consumers can `switch (e.code)` exhaustively.
+ *
+ * Codes are stable across releases — adding new codes is non-breaking; removing or renaming
+ * a code is a breaking change.
+ */
+type MinecraftKitErrorCode = "NETWORK_TIMEOUT" | "NETWORK_HTTP_ERROR" | "NETWORK_ABORTED" | "INTEGRITY_HASH_MISMATCH" | "INTEGRITY_SIZE_MISMATCH" | "MANIFEST_INVALID" | "MANIFEST_NOT_FOUND" | "METADATA_PARSE_ERROR" | "FILESYSTEM_PATH_TRAVERSAL" | "FILESYSTEM_WRITE_ERROR" | "FILESYSTEM_READ_ERROR" | "ARCHIVE_INVALID" | "ARCHIVE_TOO_LARGE" | "ARCHIVE_ENTRY_REJECTED" | "RUNTIME_NOT_FOUND" | "RUNTIME_UNSUPPORTED_PLATFORM" | "FORGE_PROCESSOR_FAILED" | "FORGE_INSTALLER_INVALID" | "LAUNCH_JAVA_NOT_FOUND" | "LAUNCH_PROCESS_FAILED" | "LAUNCH_ABORTED" | "VERIFICATION_FAILED" | "INVALID_INPUT" | "NOT_IMPLEMENTED" | "UNSUPPORTED_VERSION" | "LZMA_DECODE_ERROR";
+/** Structured context attached to errors. */
+interface MinecraftKitErrorContext {
+    readonly url?: string;
+    readonly filePath?: string;
+    readonly expectedHash?: string;
+    readonly actualHash?: string;
+    readonly expectedSize?: number;
+    readonly actualSize?: number;
+    readonly httpStatus?: number;
+    readonly exitCode?: number;
+    readonly platform?: string;
+    readonly version?: string;
+    readonly [key: string]: unknown;
+}
+
+/**
+ * The single error class thrown by every public API in `@loontail/minecraft-kit`.
+ *
+ * Use {@link isMinecraftKitError} or {@link isErrorCode} for type-narrowing in `catch` blocks.
+ */
+declare class MinecraftKitError extends Error {
+    readonly name = "MinecraftKitError";
+    /** Stable discriminator. */
+    readonly code: MinecraftKitErrorCode;
+    /** Structured context; safe to serialize. */
+    readonly context: Readonly<MinecraftKitErrorContext>;
+    constructor(code: MinecraftKitErrorCode, message: string, options?: {
+        cause?: unknown;
+        context?: MinecraftKitErrorContext;
+    });
+    /** JSON-friendly representation. */
+    toJSON(): Record<string, unknown>;
+}
+/** True when `e` is an {@link MinecraftKitError}. */
+declare function isMinecraftKitError(e: unknown): e is MinecraftKitError;
+/** True when `e` is an {@link MinecraftKitError} carrying the given code. */
+declare function isErrorCode<C extends MinecraftKitErrorCode>(e: unknown, code: C): e is MinecraftKitError & {
+    code: C;
+};
+
+/**
+ * Derive a stable v3-style UUID for an offline player username.
+ *
+ * Mojang's offline-mode formula: `MD5("OfflinePlayer:" + name)` with the version/variant
+ * bits patched to UUID v3.
+ */
+declare function offlineUuidFor(username: string): string;
+/** Strip the dashes from a UUID. Used by `${auth_uuid}`. */
+declare function stripUuidDashes(uuid: string): string;
+
+/**
+ * Default {@link HttpClient} implementation backed by Node's built-in `fetch` (undici under
+ * the hood). Maps fetch errors to {@link MinecraftKitError}.
+ */
+declare class FetchHttpClient implements HttpClient {
+    request(url: string, options?: HttpRequestOptions): Promise<HttpResponse>;
+}
+
+/** Default spawner backed by `node:child_process.spawn`. */
+declare class ChildProcessSpawner implements Spawner {
+    spawn(command: string, args: readonly string[], options: SpawnOptions): SpawnedProcess;
+}
+
+/** Logger that drops every message. Default when no logger is supplied. */
+declare const silentLogger: Logger;
+/** Logger that mirrors messages to `console.<level>` with structured fields. */
+declare const consoleLogger: Logger;
+
+/**
+ * Endpoint builders for every external HTTP request the library makes. Code MUST go through
+ * these — never hard-code URLs at call sites.
+ */
+/** Endpoint builders. */
+declare const ApiEndpoints: {
+    readonly mojang: {
+        /** Top-level Minecraft version manifest (v2). */
+        readonly versionManifest: () => string;
+        /** Mojang Java-runtime index. */
+        readonly runtimeIndex: () => string;
+    };
+    readonly resources: {
+        /** Hash-addressed Minecraft asset object. */
+        readonly asset: (hash: string) => string;
+    };
+    readonly fabric: {
+        readonly gameVersions: () => string;
+        readonly loaderVersions: () => string;
+        readonly loaderForGame: (minecraftVersion: string) => string;
+        readonly profile: (minecraftVersion: string, loaderVersion: string) => string;
+    };
+    readonly forge: {
+        /** Forge Maven listing of all builds across all MC versions. */
+        readonly mavenMetadata: () => string;
+        /** Slim "recommended" / "latest" promotion mapping. */
+        readonly promotions: () => string;
+        /** URL of the modern installer JAR for a Maven version (e.g. `1.20.1-47.2.0`). */
+        readonly installer: (mavenVersion: string) => string;
+    };
+};
+/** Surface type useful for DI. */
+type ApiEndpointsShape = typeof ApiEndpoints;
+
+/** HTTP request timeout for metadata calls, in milliseconds. */
+declare const HTTP_TIMEOUT_MS = 30000;
+/** Maximum retry attempts for transient HTTP failures. */
+declare const HTTP_RETRY_MAX = 4;
+/** Base delay for exponential backoff, in milliseconds. */
+declare const HTTP_RETRY_BACKOFF_BASE_MS = 500;
+/** Maximum delay for exponential backoff, in milliseconds. */
+declare const HTTP_RETRY_BACKOFF_CAP_MS = 30000;
+/**
+ * Default per-host concurrency for downloads. The runner uses a worker-pool: when one file
+ * finishes, the next file in the queue starts immediately. There is no batch barrier.
+ */
+declare const DOWNLOAD_CONCURRENCY = 32;
+/** TTL for in-memory metadata cache entries, in milliseconds. */
+declare const CACHE_TTL_MS: number;
+/** Maximum number of entries kept in the metadata cache. */
+declare const CACHE_MAX_ENTRIES = 256;
+/** User-agent value sent on every HTTP request. */
+declare const USER_AGENT = "minecraft-kit/0.1";
+/** Default launcher brand sent through `${launcher_name}`. */
+declare const DEFAULT_LAUNCHER_NAME = "minecraft-kit";
+/** Default launcher version sent through `${launcher_version}`. */
+declare const DEFAULT_LAUNCHER_VERSION = "0.1.0";
+/** Default min heap size in megabytes. */
+declare const DEFAULT_MIN_MB = 1024;
+/** Default max heap size in megabytes. */
+declare const DEFAULT_MAX_MB = 4096;
+/** Time after a SIGTERM before escalating to SIGKILL when aborting a launch. */
+declare const DEFAULT_KILL_GRACE_MS = 5000;
+/** Throttle interval for emitting download:progress events (in milliseconds). */
+declare const PROGRESS_EVENT_INTERVAL_MS = 100;
+/** Maximum number of stderr lines retained from a Forge processor for diagnostics. */
+declare const MAX_PROCESSOR_STDERR_LINES = 20;
+/**
+ * Maximum bytes per line emitted by {@link ChildProcessSpawner}. Lines longer than this
+ * are split: a Minecraft crash that prints megabytes of unbroken text should not exhaust
+ * memory inside the launcher.
+ */
+declare const SPAWNER_MAX_LINE_BYTES: number;
+
+/**
+ * Relative-path segments used to build per-target directory layouts.
+ *
+ * These are SEGMENTS — never use them as absolute paths. Compose with `path.join` at call sites.
+ */
+declare const VERSIONS_DIR = "versions";
+declare const LIBRARIES_DIR = "libraries";
+declare const ASSETS_DIR = "assets";
+declare const ASSETS_OBJECTS_DIR = "assets/objects";
+declare const ASSETS_INDEXES_DIR = "assets/indexes";
+declare const ASSETS_VIRTUAL_DIR = "assets/virtual";
+declare const ASSETS_LEGACY_DIR = "assets/virtual/legacy";
+declare const ASSETS_RESOURCES_DIR = "resources";
+declare const ASSETS_LOG_CONFIGS_DIR = "assets/log_configs";
+declare const RUNTIMES_DIR = "runtime";
+declare const NATIVES_DIR_NAME = "natives";
+declare const FORGE_INSTALLERS_DIR = "forge-installers";
+/** Java executable filename per OS (relative to the runtime root). */
+declare const JAVA_EXECUTABLE: {
+    readonly windows: "bin/javaw.exe";
+    readonly windowsConsole: "bin/java.exe";
+    readonly linux: "bin/java";
+    /** Note: macOS uses an extra `jre.bundle/Contents/Home/` prefix above this. */
+    readonly osx: "bin/java";
+};
+/** macOS runtime layout adds this prefix above {@link JAVA_EXECUTABLE.osx}. */
+declare const MAC_RUNTIME_PREFIX = "jre.bundle/Contents/Home";
+
+/** JVM args appended for every launch. */
+declare const BASE_JVM_ARGS: readonly ["-XX:+UnlockExperimentalVMOptions", "-XX:+UseG1GC", "-XX:G1NewSizePercent=20", "-XX:G1ReservePercent=20", "-XX:MaxGCPauseMillis=50", "-XX:G1HeapRegionSize=32M"];
+/** JVM args added for legacy (≤1.12) versions that lack `arguments.jvm`. */
+declare const LEGACY_JVM_ARGS: readonly ["-Djava.library.path=${natives_directory}", "-Dminecraft.launcher.brand=${launcher_name}", "-Dminecraft.launcher.version=${launcher_version}", "-cp", "${classpath}"];
+/** macOS-only JVM args (suppress dock label). */
+declare const MACOS_JVM_ARGS: readonly ["-Xdock:name=Minecraft"];
+
+/** Per-file size cap during archive extraction (bytes). */
+declare const EXTRACTION_MAX_FILE_SIZE: number;
+/** Total decompressed-bytes cap per archive. */
+declare const EXTRACTION_MAX_TOTAL_SIZE: number;
+/** Maximum compression ratio (decompressed / compressed) before treating as a zip bomb. */
+declare const EXTRACTION_MAX_COMPRESSION_RATIO = 200;
+/** Maximum entry count per archive. */
+declare const EXTRACTION_MAX_ENTRY_COUNT = 100000;
+/** Reasonable maximum bytes a Forge installer JAR can be. */
+declare const FORGE_INSTALLER_MAX_SIZE: number;
+
+/** Default Maven base URL when a library entry has no `url`. */
+declare const DEFAULT_LIBRARY_REPOSITORY = "https://libraries.minecraft.net/";
+/** Fabric's Maven base. */
+declare const FABRIC_MAVEN_BASE = "https://maven.fabricmc.net/";
+/** Forge's Maven base. */
+declare const FORGE_MAVEN_BASE = "https://maven.minecraftforge.net/";
+
+/**
+ * All `${...}` tokens substituted into JVM and game arguments.
+ *
+ * This map drives both substitution at launch time and documentation generation.
+ */
+declare const LAUNCH_PLACEHOLDERS: {
+    readonly "${auth_player_name}": "Player display name.";
+    readonly "${version_name}": "Resolved Minecraft version id.";
+    readonly "${game_directory}": "Per-target directory.";
+    readonly "${assets_root}": "Assets root (`<directory>/assets`).";
+    readonly "${assets_index_name}": "Asset index id from the manifest.";
+    readonly "${auth_uuid}": "Player UUID (no dashes).";
+    readonly "${auth_access_token}": "Yggdrasil/MSA access token.";
+    readonly "${auth_session}": "Legacy session token (`token:<token>:<uuid>`).";
+    readonly "${clientid}": "MSA client id.";
+    readonly "${auth_xuid}": "Xbox user id.";
+    readonly "${user_type}": "`msa` | `mojang` | `legacy`.";
+    readonly "${user_properties}": "User properties JSON (often `{}`).";
+    readonly "${version_type}": "Channel string, e.g. `release`.";
+    readonly "${game_assets}": "Legacy virtual assets directory.";
+    readonly "${resolution_width}": "Window width (feature-gated).";
+    readonly "${resolution_height}": "Window height (feature-gated).";
+    readonly "${natives_directory}": "Extracted natives directory.";
+    readonly "${classpath}": "Joined classpath of libraries + version jar.";
+    readonly "${classpath_separator}": "OS-specific classpath separator (`:` / `;`).";
+    readonly "${library_directory}": "Per-target libraries directory.";
+    readonly "${launcher_name}": "Launcher brand string.";
+    readonly "${launcher_version}": "Launcher version string.";
+    readonly "${path}": "Path to the log4j config file (logging.client.argument only).";
+};
+/** Token literal type. */
+type LaunchPlaceholder = keyof typeof LAUNCH_PLACEHOLDERS;
+
+/** Mapping from Node's `process.platform` to Mojang OS names. */
+declare const NODE_PLATFORM_TO_MOJANG_OS: {
+    readonly win32: "windows";
+    readonly darwin: "osx";
+    readonly linux: "linux";
+};
+/** Mapping from Node's `process.arch` to Mojang/Mojang-runtime arch tags. */
+declare const NODE_ARCH_TO_MOJANG_ARCH: {
+    readonly x64: "x64";
+    readonly ia32: "x86";
+    readonly arm64: "arm64";
+};
+/** Mapping from {OperatingSystem, Architecture} to the runtime-index platform key. */
+declare const RUNTIME_PLATFORM_KEYS: Readonly<Record<OperatingSystem, Readonly<Record<Architecture, string>>>>;
+
+/**
+ * Fallback Mojang component when the per-version manifest declares none. Pre-1.7 vanilla
+ * versions and a handful of legacy snapshots fall in this bucket.
+ */
+declare const FALLBACK_COMPONENT: string;
+
+export { ASSETS_DIR, ASSETS_INDEXES_DIR, ASSETS_LEGACY_DIR, ASSETS_LOG_CONFIGS_DIR, ASSETS_OBJECTS_DIR, ASSETS_RESOURCES_DIR, ASSETS_VIRTUAL_DIR, ApiEndpoints, type ApiEndpointsShape, type Architecture, Architectures, type ArgumentEntry, type ArtifactDownload, type AspectRepairInput, type AssetIndexDocument, type AssetIndexReference, type AssetObject, type AuthMode, AuthModes, BASE_JVM_ARGS, CACHE_MAX_ENTRIES, CACHE_TTL_MS, ChildProcessSpawner, DEFAULT_KILL_GRACE_MS, DEFAULT_LAUNCHER_NAME, DEFAULT_LAUNCHER_VERSION, DEFAULT_LIBRARY_REPOSITORY, DEFAULT_MAX_MB, DEFAULT_MIN_MB, DOWNLOAD_CONCURRENCY, type DetectSystemInput, type DiscoveredLoaderHint, type DiscoveredRuntimeHint, type DiscoveredTarget, type DownloadAction, EXTRACTION_MAX_COMPRESSION_RATIO, EXTRACTION_MAX_ENTRY_COUNT, EXTRACTION_MAX_FILE_SIZE, EXTRACTION_MAX_TOTAL_SIZE, type EventType, EventTypes, type ExtractNativeAction, FABRIC_MAVEN_BASE, FALLBACK_COMPONENT, FORGE_INSTALLERS_DIR, FORGE_INSTALLER_MAX_SIZE, FORGE_MAVEN_BASE, type FabricCompatibilityEntry, type FabricListInput, type FabricLoaderSummary, type FabricProfile, type FabricResolveInput, FabricVersionsApi, FetchHttpClient, type FileRef, type ForgeBuildSummary, type ForgeInstallProfile, type ForgeListInput, type ForgeProcessor, type ForgeProfileData, type ForgeResolveInput, type ForgeVersionJson, ForgeVersionsApi, HTTP_RETRY_BACKOFF_BASE_MS, HTTP_RETRY_BACKOFF_CAP_MS, HTTP_RETRY_MAX, HTTP_TIMEOUT_MS, type HttpClient, type HttpHeaders, type HttpRequestOptions, type HttpResponse, type InstallAction, type InstallActionKind, InstallActionKinds, type InstallPhase, InstallPhases, type InstallPlan, type InstallReport, JAVA_EXECUTABLE, LAUNCH_PLACEHOLDERS, LEGACY_JVM_ARGS, LIBRARIES_DIR, type LaunchAuth, type LaunchComposition, type LaunchExit, type LaunchMemoryOptions, type LaunchOptions, type LaunchPlaceholder, type LaunchResolutionOptions, type LaunchRunOptions, type LaunchSession, type LibraryArtifact, type LibraryRule, type Loader, type LoaderKind, Loaders, type LogLevel, LogLevels, type Logger, MACOS_JVM_ARGS, MAC_RUNTIME_PREFIX, MAX_PROCESSOR_STDERR_LINES, type MemoryCacheOptions, type MetadataCache, type MinecraftArguments, type MinecraftChannel, MinecraftChannels, type MinecraftDownloads, type MinecraftGetInput, type MinecraftJavaVersion, MinecraftKit, MinecraftKitError, type MinecraftKitErrorCode, type MinecraftKitErrorContext, type MinecraftKitOptions, type MinecraftLatestInput, type MinecraftLibrary, type MinecraftLibraryDownloads, type MinecraftListInput, type MinecraftLogging, type MinecraftVersionManifest, type MinecraftVersionSummary, MinecraftVersionsApi, NATIVES_DIR_NAME, NODE_ARCH_TO_MOJANG_ARCH, NODE_PLATFORM_TO_MOJANG_OS, type OfflineAuth, type OnlineAuth, type OperatingSystem, OperatingSystems, type OperationOptions, PROGRESS_EVENT_INTERVAL_MS, type PlanFabricRepairInput, type PlanForgeRepairInput, type PlanMinecraftRepairInput, type PlanRuntimeInstallInput, type PlanRuntimeRepairInput, type PlanStandaloneRuntimeInstallInput, type ProcessStream, type ProcessorRef, type ProgressEvent, type ProgressListener, RUNTIMES_DIR, RUNTIME_PLATFORM_KEYS, type RepairAspect, type RepairPhase, RepairPhases, type RepairPlan, type RepairPlanOptions, type RepairReport, type ResolvedFabricLoader, type ResolvedForgeLoader, type ResolvedMinecraft, type ResolvedRuntime, type ResolvedVanillaLoader, type ResolverContext, type RunForgeProcessorAction, type RunRepairInput, type RuntimeComponent, RuntimeComponents, type RuntimeFileDirectory, type RuntimeFileEntry, type RuntimeFileFile, type RuntimeFileLink, type RuntimeFilesManifest, type RuntimeIndex, type RuntimeIndexEntry, type RuntimeIndexPlatform, type RuntimeListEntry, type RuntimeListInput, RuntimePreference, type RuntimePreferenceKind, type RuntimeResolveInput, type RuntimeSystem, RuntimeVersionsApi, SPAWNER_MAX_LINE_BYTES, type SpawnOptions, type SpawnedProcess, type Spawner, type Target, type TargetCreateInput, type TargetListInput, type TargetLoaderInput, type TargetResolveInput, TargetsApi, type TargetsApiContext, USER_AGENT, type UpdatePlan, type UpdateReport, VERSIONS_DIR, type VerificationFileResult, type VerificationKind, VerificationKinds, type VerificationResult, type VerifyFabricInput, VerifyFileCategories, type VerifyFileCategory, type VerifyFileStatus, VerifyFileStatuses, type VerifyForgeInput, type VerifyMinecraftInput, type VerifyOperationOptions, type VerifyRuntimeInput, VersionPreference, type VersionPreferenceKind, type WriteLoggingConfigAction, type WriteVersionJsonAction, consoleLogger, createMemoryCache, detectSystem, isErrorCode, isMinecraftKitError, offlineUuidFor, planFabricRepair, planForgeRepair, planMinecraftRepair, planRuntimeInstall, planRuntimeRepair, planStandaloneRuntimeInstall, runRepair, silentLogger, stripUuidDashes, verifyFabric, verifyForge, verifyMinecraft, verifyRuntime };