@loontail/minecraft-kit 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -9,7 +9,7 @@ var yauzl = require('yauzl');
 var crypto2 = require('crypto');
 var fs = require('fs/promises');
 var stream = require('stream');
-var pLimit = require('p-limit');
+var async_hooks = require('async_hooks');
 var buffer = require('buffer');
 var child_process = require('child_process');
 
@@ -20,7 +20,6 @@ var path__default = /*#__PURE__*/_interopDefault(path);
 var yauzl__default = /*#__PURE__*/_interopDefault(yauzl);
 var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
 
 // src/types/logger.ts
 var LogLevels = {
@@ -1123,6 +1122,12 @@ async function downloadFile(http, input) {
       const sourceIterable = response.stream();
       const counting = (async function* () {
         for await (const chunk of sourceIterable) {
+          if (input.pauseController?.paused) {
+            await input.pauseController.waitWhilePaused();
+          }
+          if (input.signal?.aborted) {
+            throw new MinecraftKitError("LAUNCH_ABORTED", "Download aborted by signal");
+          }
           bytesDownloaded += chunk.byteLength;
           hash.update(chunk);
           input.onEvent?.({
@@ -1451,7 +1456,8 @@ function substituteToken(raw, tokens) {
   });
 }
 function stripLiteralPrefix(value) {
-  return value.startsWith("'") ? value.slice(1) : value;
+  const stripped = value.startsWith("'") ? value.slice(1) : value;
+  return stripped.endsWith("'") ? stripped.slice(0, -1) : stripped;
 }
 async function planRuntimeDownloads(input) {
   const manifest = await fetchJson(input.http, input.cache, {
@@ -1574,6 +1580,123 @@ async function planInstall(input) {
     totalBytes
   };
 }
+
+// node_modules/yocto-queue/index.js
+var Node = class {
+  value;
+  next;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var Queue = class {
+  #head;
+  #tail;
+  #size;
+  constructor() {
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (this.#head) {
+      this.#tail.next = node;
+      this.#tail = node;
+    } else {
+      this.#head = node;
+      this.#tail = node;
+    }
+    this.#size++;
+  }
+  dequeue() {
+    const current = this.#head;
+    if (!current) {
+      return;
+    }
+    this.#head = this.#head.next;
+    this.#size--;
+    if (!this.#head) {
+      this.#tail = void 0;
+    }
+    return current.value;
+  }
+  peek() {
+    if (!this.#head) {
+      return;
+    }
+    return this.#head.value;
+  }
+  clear() {
+    this.#head = void 0;
+    this.#tail = void 0;
+    this.#size = 0;
+  }
+  get size() {
+    return this.#size;
+  }
+  *[Symbol.iterator]() {
+    let current = this.#head;
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+  *drain() {
+    while (this.#head) {
+      yield this.dequeue();
+    }
+  }
+};
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (function_, resolve, arguments_) => {
+    activeCount++;
+    const result = (async () => function_(...arguments_))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (function_, resolve, arguments_) => {
+    queue.enqueue(
+      async_hooks.AsyncResource.bind(run.bind(void 0, function_, resolve, arguments_))
+    );
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (function_, ...arguments_) => new Promise((resolve) => {
+    enqueue(function_, resolve, arguments_);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value() {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
 async function materializeRuntimeExtras(input) {
   const root = targetPaths.runtimeRoot(
     input.directory,
@@ -1638,6 +1761,16 @@ function errorMessage(error) {
 }
 
 // src/install/runner.ts
+var DOWNLOAD_GROUPS = [
+  { categories: ["runtime-file"], phase: InstallPhases.INSTALLING_RUNTIME },
+  { categories: ["client-jar"], phase: InstallPhases.DOWNLOADING_CLIENT_JAR },
+  { categories: ["library"], phase: InstallPhases.DOWNLOADING_LIBRARIES },
+  { categories: ["asset-index"], phase: InstallPhases.DOWNLOADING_ASSET_INDEX },
+  { categories: ["asset"], phase: InstallPhases.DOWNLOADING_ASSETS },
+  { categories: ["logging-config"], phase: InstallPhases.WRITING_FILES },
+  { categories: ["fabric-library"], phase: InstallPhases.INSTALLING_FABRIC },
+  { categories: ["forge-installer", "forge-library"], phase: InstallPhases.INSTALLING_FORGE }
+];
 async function runInstall(input) {
   const startedAt = Date.now();
   let bytesDownloaded = 0;
@@ -1650,50 +1783,89 @@ async function runInstall(input) {
     onEvent?.({ type: "install:phase-changed", phase, previous: currentPhase });
     currentPhase = phase;
   };
-  const downloads = input.plan.actions.filter(isDownload);
+  const checkpoint = async () => {
+    if (input.signal?.aborted) {
+      throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
+    }
+    await input.pauseController?.waitWhilePaused();
+    if (input.signal?.aborted) {
+      throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
+    }
+  };
+  const categoryFilter = input.actionCategories;
+  const downloads = input.plan.actions.filter(isDownload).filter((a) => categoryFilter ? categoryFilter.has(a.category) : true);
   const natives = input.plan.actions.filter(isNative);
   const writeActions = input.plan.actions.filter(isWrite);
   const processors = input.plan.actions.filter(isProcessor);
   enterPhase(InstallPhases.PLANNING);
-  enterPhase(InstallPhases.DOWNLOADING_LIBRARIES);
-  const limit = pLimit__default.default(input.concurrency ?? DOWNLOAD_CONCURRENCY);
-  await Promise.all(
-    downloads.map(
-      (action) => limit(async () => {
-        if (input.signal?.aborted) {
-          throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
-        }
-        const result = await downloadFile(input.http, {
-          url: action.url,
-          target: action.target,
-          ...action.expectedSha1 !== void 0 ? { expectedSha1: action.expectedSha1 } : {},
-          ...action.expectedSize !== void 0 ? { expectedSize: action.expectedSize } : {},
-          ...action.category !== void 0 ? { category: action.category } : {},
-          ...input.signal !== void 0 ? { signal: input.signal } : {},
-          ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-        });
-        bytesDownloaded += result.bytesDownloaded;
-        if (result.skipped) actionsSkipped++;
-        actionsCompleted++;
-      })
-    )
+  const limit = pLimit(input.concurrency ?? DOWNLOAD_CONCURRENCY);
+  for (const group of DOWNLOAD_GROUPS) {
+    const groupActions = downloads.filter((action) => group.categories.includes(action.category));
+    if (groupActions.length === 0) continue;
+    await checkpoint();
+    enterPhase(group.phase);
+    await Promise.all(
+      groupActions.map(
+        (action) => limit(async () => {
+          await checkpoint();
+          const result = await downloadFile(input.http, {
+            url: action.url,
+            target: action.target,
+            ...action.expectedSha1 !== void 0 ? { expectedSha1: action.expectedSha1 } : {},
+            ...action.expectedSize !== void 0 ? { expectedSize: action.expectedSize } : {},
+            ...action.category !== void 0 ? { category: action.category } : {},
+            ...input.signal !== void 0 ? { signal: input.signal } : {},
+            ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {},
+            ...input.pauseController !== void 0 ? { pauseController: input.pauseController } : {}
+          });
+          bytesDownloaded += result.bytesDownloaded;
+          if (result.skipped) actionsSkipped++;
+          actionsCompleted++;
+        })
+      )
+    );
+  }
+  const ungrouped = downloads.filter(
+    (action) => !DOWNLOAD_GROUPS.some((g) => g.categories.includes(action.category))
   );
+  if (ungrouped.length > 0) {
+    await checkpoint();
+    enterPhase(InstallPhases.DOWNLOADING_LIBRARIES);
+    await Promise.all(
+      ungrouped.map(
+        (action) => limit(async () => {
+          await checkpoint();
+          const result = await downloadFile(input.http, {
+            url: action.url,
+            target: action.target,
+            ...action.expectedSha1 !== void 0 ? { expectedSha1: action.expectedSha1 } : {},
+            ...action.expectedSize !== void 0 ? { expectedSize: action.expectedSize } : {},
+            ...action.category !== void 0 ? { category: action.category } : {},
+            ...input.signal !== void 0 ? { signal: input.signal } : {},
+            ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {},
+            ...input.pauseController !== void 0 ? { pauseController: input.pauseController } : {}
+          });
+          bytesDownloaded += result.bytesDownloaded;
+          if (result.skipped) actionsSkipped++;
+          actionsCompleted++;
+        })
+      )
+    );
+  }
   if (writeActions.length > 0) {
+    await checkpoint();
     enterPhase(InstallPhases.WRITING_FILES);
     for (const action of writeActions) {
-      if (input.signal?.aborted) {
-        throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
-      }
+      await checkpoint();
       await atomicWrite(action.path, action.content);
       actionsCompleted++;
     }
   }
   if (natives.length > 0) {
+    await checkpoint();
     enterPhase(InstallPhases.EXTRACTING_NATIVES);
     for (const action of natives) {
-      if (input.signal?.aborted) {
-        throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
-      }
+      await checkpoint();
       const { fileCount } = await extractAllToDir(action.source, action.destination, {
         excludePrefixes: action.exclude
       });
@@ -1707,6 +1879,7 @@ async function runInstall(input) {
     }
   }
   if (input.plan.target.runtime !== void 0) {
+    await checkpoint();
     enterPhase(InstallPhases.INSTALLING_RUNTIME);
     const runtimePlan = await planRuntimeDownloads({
       runtime: input.plan.target.runtime,
@@ -1722,6 +1895,7 @@ async function runInstall(input) {
     });
   }
   if (processors.length > 0) {
+    await checkpoint();
     enterPhase(InstallPhases.RUNNING_FORGE_PROCESSORS);
     if (input.plan.target.loader.type !== Loaders.FORGE) {
       throw new MinecraftKitError(
@@ -1736,9 +1910,7 @@ async function runInstall(input) {
       input.plan.target.runtime.installRoot
     );
     for (const action of processors) {
-      if (input.signal?.aborted) {
-        throw new MinecraftKitError("LAUNCH_ABORTED", "Install aborted by signal");
-      }
+      await checkpoint();
       await runProcessor({
         action,
         javaPath,
@@ -1953,6 +2125,33 @@ function pickArguments(args, context) {
   };
 }
 
+// src/launch/jvm-compat.ts
+var FLAG_MIN_JAVA = [
+  { prefix: "--sun-misc-unsafe-memory-access", minJava: 23 },
+  { prefix: "--enable-native-access", minJava: 17 },
+  { prefix: "-XX:+UseCompactObjectHeaders", minJava: 24 },
+  { prefix: "-XX:+UseZGC", minJava: 15 }
+];
+function filterArgsForJava(input) {
+  if (!Number.isFinite(input.javaMajor) || input.javaMajor <= 0) return input.args;
+  const out = [];
+  for (const arg of input.args) {
+    const incompatible = FLAG_MIN_JAVA.find(
+      ({ prefix }) => arg === prefix || arg.startsWith(`${prefix}=`) || arg.startsWith(`${prefix} `)
+    );
+    if (incompatible && input.javaMajor < incompatible.minJava) {
+      input.logger?.log(
+        "warn",
+        `Dropping JVM arg "${arg}" \u2014 requires Java ${incompatible.minJava}, runtime is Java ${input.javaMajor}`,
+        { flag: arg, minJava: incompatible.minJava, runtimeJava: input.javaMajor }
+      );
+      continue;
+    }
+    out.push(arg);
+  }
+  return out;
+}
+
 // src/launch/placeholders.ts
 function substituteArg(raw, values) {
   return raw.replaceAll(/\$\{([a-zA-Z0-9_]+)\}/g, (match, key) => {
@@ -1992,7 +2191,13 @@ function composeArgs(input) {
   const baseJvm = [...memoryArgs, ...BASE_JVM_ARGS, ...macosArgs];
   const substitutedJvm = substituteArgs(rawJvm, input.placeholderValues);
   const substitutedGame = substituteArgs(rawGame, input.placeholderValues);
-  const jvmArgs = [...baseJvm, ...substitutedJvm];
+  const javaMajor = input.target.runtime.majorVersion;
+  const filteredManifestJvm = javaMajor !== void 0 ? filterArgsForJava({
+    args: substitutedJvm,
+    javaMajor,
+    logger: input.logger ?? silentLogger
+  }) : substitutedJvm;
+  const jvmArgs = [...baseJvm, ...filteredManifestJvm];
   if (input.merged.logging?.client?.argument) {
     const logging = input.merged.logging.client;
     const loggingArg = substituteArgs([logging.argument], {
@@ -2122,8 +2327,28 @@ function mergeManifest(parent, child) {
   };
   return merged;
 }
+function libraryDedupeKey(library) {
+  if (!library.name) return null;
+  try {
+    const coord = parseMavenCoordinate(library.name);
+    const classifier = coord.classifier ? `:${coord.classifier}` : "";
+    return `${coord.group}:${coord.artifact}${classifier}`;
+  } catch {
+    return null;
+  }
+}
 function mergeLibraries(parent, child) {
-  return [...parent, ...child];
+  const byKey = /* @__PURE__ */ new Map();
+  const unkeyed = [];
+  for (const lib of [...parent, ...child]) {
+    const key = libraryDedupeKey(lib);
+    if (key === null) {
+      unkeyed.push(lib);
+      continue;
+    }
+    byKey.set(key, lib);
+  }
+  return [...byKey.values(), ...unkeyed];
 }
 function mergeArguments(parent, child) {
   if (!parent && !child) return void 0;
@@ -2247,7 +2472,8 @@ async function composeLaunch(input) {
     merged: resolved.merged,
     options,
     placeholderValues,
-    features
+    features,
+    logger: input.logger ?? silentLogger
   });
   return {
     targetId: target.id,
@@ -2429,193 +2655,553 @@ var VerifyFileCategories = {
   RUNTIME_FILE: "runtime-file",
   LOGGING_CONFIG: "logging-config"
 };
+async function sha1OfFile(filePath) {
+  const hash = crypto2__default.default.createHash("sha1");
+  await new Promise((resolve, reject) => {
+    const stream = fs$1.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", resolve);
+    stream.on("error", reject);
+  });
+  return hash.digest("hex");
+}
 
-// src/repair/helpers.ts
-function asResultArray(from) {
-  return Array.isArray(from) ? from : [from];
+// src/verify/helpers.ts
+async function runVerification(input, check) {
+  const startedAt = Date.now();
+  const results = [];
+  const record = (result) => {
+    results.push(result);
+    input.onEvent?.({ type: "verify:file-checked", file: result });
+  };
+  await check(record);
+  return {
+    targetId: input.targetId,
+    kind: input.kind,
+    isValid: results.every((r) => r.status === VerifyFileStatuses.OK),
+    issues: results.filter((r) => r.status !== VerifyFileStatuses.OK),
+    checkedFiles: results.length,
+    durationMs: Date.now() - startedAt
+  };
 }
-function buildIssueIndex(from) {
-  const map = /* @__PURE__ */ new Map();
-  for (const v of asResultArray(from)) {
-    for (const issue of v.issues) {
-      const set = map.get(issue.path);
-      if (set) set.add(issue.category);
-      else map.set(issue.path, /* @__PURE__ */ new Set([issue.category]));
+async function verifyHashedFile(input) {
+  if (!await fileExists(input.path)) {
+    return {
+      path: input.path,
+      category: input.category,
+      status: VerifyFileStatuses.MISSING,
+      ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
+      ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
+      ...input.url !== void 0 ? { url: input.url } : {}
+    };
+  }
+  if (input.expectedSize !== void 0) {
+    const size = await fileSize(input.path);
+    if (size !== input.expectedSize) {
+      return {
+        path: input.path,
+        category: input.category,
+        status: VerifyFileStatuses.WRONG_SIZE,
+        expectedSize: input.expectedSize,
+        actualSize: size,
+        ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
+        ...input.url !== void 0 ? { url: input.url } : {}
+      };
+    }
+  }
+  if (input.expectedSha1 !== void 0) {
+    const actualSha1 = await sha1OfFile(input.path);
+    if (actualSha1 !== input.expectedSha1) {
+      return {
+        path: input.path,
+        category: input.category,
+        status: VerifyFileStatuses.CORRUPT,
+        expectedSha1: input.expectedSha1,
+        actualSha1,
+        ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
+        ...input.url !== void 0 ? { url: input.url } : {}
+      };
     }
   }
   return {
-    has: (path13) => map.has(path13),
-    hasNonNative: (path13) => {
-      const cats = map.get(path13);
-      if (!cats) return false;
-      for (const c of cats) {
-        if (c !== VerifyFileCategories.NATIVE) return true;
-      }
-      return false;
-    },
-    categoriesAt: (path13) => map.get(path13) ?? /* @__PURE__ */ new Set()
+    path: input.path,
+    category: input.category,
+    status: VerifyFileStatuses.OK,
+    ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
+    ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
+    ...input.url !== void 0 ? { url: input.url } : {}
   };
 }
-function sumDownloadBytes(actions) {
-  return actions.reduce((sum, action) => {
-    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
-      return sum + (action.expectedSize ?? 0);
-    }
-    return sum;
-  }, 0);
-}
-function buildRepairPlan(target, actions) {
+async function verifyExistence(input) {
+  if (await fileExists(input.path)) {
+    return {
+      path: input.path,
+      category: input.category,
+      status: VerifyFileStatuses.OK,
+      ...input.url !== void 0 ? { url: input.url } : {}
+    };
+  }
   return {
-    targetId: target.id,
-    directory: target.directory,
-    target,
-    actions,
-    totalActions: actions.length,
-    totalBytes: sumDownloadBytes(actions)
+    path: input.path,
+    category: input.category,
+    status: VerifyFileStatuses.MISSING,
+    ...input.url !== void 0 ? { url: input.url } : {}
   };
 }
-async function planAspectRepair(input, aspectFilter, postprocess) {
-  const installPlan = await planInstall({
-    target: input.target,
-    http: input.http,
-    cache: input.cache,
-    ...input.signal !== void 0 ? { signal: input.signal } : {}
-  });
-  const issues = buildIssueIndex(input.from);
-  const actions = selectRepairActions({
-    target: input.target,
-    installPlan,
-    issues,
-    aspectFilter
-  });
-  postprocess?.({ actions, installPlan, issues });
-  return buildRepairPlan(input.target, actions);
-}
-function selectRepairActions(input) {
-  const matching = [];
-  for (const action of input.installPlan.actions) {
-    if (!input.aspectFilter(action)) continue;
-    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
-      if (input.issues.hasNonNative(action.target)) {
-        matching.push(action);
-      }
-    } else if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
-      if (input.issues.has(action.path)) {
-        matching.push(action);
-      }
-    } else if (action.kind === InstallActionKinds.EXTRACT_NATIVE) {
-      if (input.issues.has(action.source)) {
-        matching.push(action);
-      }
-    } else {
-      matching.push(action);
+async function findForgeVersionJsonPath(directory, minecraftVersion) {
+  const versionsDir = targetPaths.versionsDir(directory);
+  const dirs = await listChildDirectories(versionsDir);
+  for (const id of dirs) {
+    if (!id.startsWith(`${minecraftVersion}-forge-`)) continue;
+    const jsonPath = targetPaths.versionJson(directory, id);
+    if (!await fileExists(jsonPath)) {
+      return jsonPath;
     }
+    const parsed = await tryParseInheritsFrom(jsonPath);
+    if (parsed === minecraftVersion) return jsonPath;
+  }
+  return null;
+}
+async function tryParseInheritsFrom(jsonPath) {
+  try {
+    const parsed = JSON.parse(await readText(jsonPath));
+    return parsed.inheritsFrom;
+  } catch {
+    return void 0;
   }
-  return matching;
 }
 
-// src/repair/fabric.ts
-async function planFabricRepair(input) {
+// src/verify/fabric.ts
+async function verifyFabric(input) {
   if (input.target.loader.type !== Loaders.FABRIC) {
     throw new MinecraftKitError(
       "INVALID_INPUT",
-      `repair.fabric requires a Fabric target (got ${input.target.loader.type})`
+      `verify.fabric requires a Fabric target (got ${input.target.loader.type})`
     );
   }
-  const fabricJsonPath = targetPaths.versionJson(
-    input.target.directory,
-    input.target.loader.profile.id
-  );
-  return planAspectRepair(input, (action) => {
-    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
-      return action.category === "fabric-library";
-    }
-    if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
-      return action.path === fabricJsonPath;
+  const loader = input.target.loader;
+  return runVerification(
+    {
+      targetId: input.target.id,
+      kind: VerificationKinds.FABRIC,
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
+    },
+    async (record) => {
+      record(
+        await verifyExistence({
+          path: targetPaths.versionJson(input.target.directory, loader.profile.id),
+          category: VerifyFileCategories.LOADER_LIBRARY
+        })
+      );
+      const fabricLibraries = planLibraryDownloads({
+        libraries: loader.profile.libraries,
+        directory: input.target.directory,
+        system: input.target.runtime.system,
+        versionId: input.target.minecraft.version,
+        category: "fabric-library"
+      });
+      for (const action of fabricLibraries.downloads) {
+        record(
+          await verifyHashedFile({
+            path: action.target,
+            expectedSha1: action.expectedSha1,
+            expectedSize: action.expectedSize,
+            ...action.url ? { url: action.url } : {},
+            category: VerifyFileCategories.LOADER_LIBRARY
+          })
+        );
+      }
     }
-    return false;
-  });
+  );
 }
 
-// src/repair/forge.ts
-var FORGE_DOWNLOAD_CATEGORIES = /* @__PURE__ */ new Set([
-  "forge-library",
-  "forge-installer"
-]);
-async function planForgeRepair(input) {
+// src/verify/forge.ts
+async function verifyForge(input) {
   if (input.target.loader.type !== Loaders.FORGE) {
     throw new MinecraftKitError(
       "INVALID_INPUT",
-      `repair.forge requires a Forge target (got ${input.target.loader.type})`
+      `verify.forge requires a Forge target (got ${input.target.loader.type})`
     );
   }
-  const forgeJsonPath = targetPaths.versionJson(
-    input.target.directory,
-    input.target.loader.fullVersion
-  );
-  return planAspectRepair(
-    input,
-    (action) => {
-      if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
-        return FORGE_DOWNLOAD_CATEGORIES.has(action.category);
-      }
-      if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
-        return action.path === forgeJsonPath;
-      }
-      return false;
+  return runVerification(
+    {
+      targetId: input.target.id,
+      kind: VerificationKinds.FORGE,
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
     },
-    ({ actions, installPlan, issues }) => {
-      if (!issues.has(forgeJsonPath)) return;
-      const alreadyIncluded = new Set(
-        actions.filter((a) => a.kind === InstallActionKinds.DOWNLOAD_FILE).map((a) => a.target)
+    async (record) => {
+      const forgeVersionJsonPath = await findForgeVersionJsonPath(
+        input.target.directory,
+        input.target.minecraft.version
       );
-      for (const action of installPlan.actions) {
-        if (action.kind === InstallActionKinds.DOWNLOAD_FILE && action.category === "forge-library" && !alreadyIncluded.has(action.target)) {
-          actions.push(action);
-        } else if (action.kind === InstallActionKinds.RUN_FORGE_PROCESSOR) {
-          actions.push(action);
-        }
+      if (forgeVersionJsonPath === null) return;
+      record(
+        await verifyExistence({
+          path: forgeVersionJsonPath,
+          category: VerifyFileCategories.LOADER_LIBRARY
+        })
+      );
+      if (!await fileExists(forgeVersionJsonPath)) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(await readText(forgeVersionJsonPath));
+      } catch {
+        record({
+          path: forgeVersionJsonPath,
+          category: VerifyFileCategories.LOADER_LIBRARY,
+          status: VerifyFileStatuses.CORRUPT
+        });
+        return;
+      }
+      const forgeLibraries = planLibraryDownloads({
+        libraries: parsed.libraries,
+        directory: input.target.directory,
+        system: input.target.runtime.system,
+        versionId: input.target.minecraft.version,
+        category: "forge-library"
+      });
+      for (const action of forgeLibraries.downloads) {
+        record(
+          await verifyHashedFile({
+            path: action.target,
+            expectedSha1: action.expectedSha1,
+            expectedSize: action.expectedSize,
+            ...action.url ? { url: action.url } : {},
+            category: VerifyFileCategories.LOADER_LIBRARY
+          })
+        );
       }
     }
   );
 }
 
-// src/repair/minecraft.ts
-var MINECRAFT_DOWNLOAD_CATEGORIES = /* @__PURE__ */ new Set([
-  "client-jar",
-  "library",
-  "asset-index",
-  "asset",
-  "logging-config"
-]);
-async function planMinecraftRepair(input) {
-  const vanillaJsonPath = targetPaths.versionJson(
-    input.target.directory,
-    input.target.minecraft.version
-  );
-  return planAspectRepair(input, (action) => {
-    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
-      return MINECRAFT_DOWNLOAD_CATEGORIES.has(action.category);
-    }
-    if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
-      return action.path === vanillaJsonPath;
-    }
-    if (action.kind === InstallActionKinds.EXTRACT_NATIVE) {
-      return true;
+// src/verify/minecraft.ts
+async function verifyMinecraft(input) {
+  return runVerification(
+    {
+      targetId: input.target.id,
+      kind: VerificationKinds.MINECRAFT,
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
+    },
+    async (record) => {
+      const { directory, minecraft, runtime } = input.target;
+      record(
+        await verifyHashedFile({
+          path: targetPaths.versionJar(directory, minecraft.version),
+          expectedSha1: minecraft.manifest.downloads.client.sha1,
+          expectedSize: minecraft.manifest.downloads.client.size,
+          url: minecraft.manifest.downloads.client.url,
+          category: VerifyFileCategories.CLIENT_JAR
+        })
+      );
+      record(
+        await verifyExistence({
+          path: targetPaths.versionJson(directory, minecraft.version),
+          category: VerifyFileCategories.CLIENT_JAR
+        })
+      );
+      if (minecraft.manifest.logging?.client) {
+        const logging = minecraft.manifest.logging.client;
+        record(
+          await verifyHashedFile({
+            path: targetPaths.loggingConfig(directory, logging.file.id),
+            expectedSha1: logging.file.sha1,
+            expectedSize: logging.file.size,
+            url: logging.file.url,
+            category: VerifyFileCategories.LOGGING_CONFIG
+          })
+        );
+      }
+      const libraryPlan = planLibraryDownloads({
+        libraries: minecraft.manifest.libraries,
+        directory,
+        system: runtime.system,
+        versionId: minecraft.version,
+        category: "library"
+      });
+      for (const action of libraryPlan.downloads) {
+        record(
+          await verifyHashedFile({
+            path: action.target,
+            expectedSha1: action.expectedSha1,
+            expectedSize: action.expectedSize,
+            url: action.url,
+            category: VerifyFileCategories.LIBRARY
+          })
+        );
+      }
+      const indexUrl = minecraft.manifest.assetIndex.url;
+      const indexPath = targetPaths.assetIndex(directory, minecraft.manifest.assetIndex.id);
+      record(
+        await verifyHashedFile({
+          path: indexPath,
+          expectedSha1: minecraft.manifest.assetIndex.sha1,
+          expectedSize: minecraft.manifest.assetIndex.size,
+          url: indexUrl,
+          category: VerifyFileCategories.ASSET_INDEX
+        })
+      );
+      const indexDocument = await fetchJson(input.http, input.cache, {
+        url: indexUrl,
+        cacheKey: `asset-index:${minecraft.manifest.assetIndex.id}:${minecraft.manifest.assetIndex.sha1}`,
+        ...input.signal !== void 0 ? { signal: input.signal } : {}
+      });
+      const seenAssetHashes = /* @__PURE__ */ new Set();
+      for (const entry of Object.values(indexDocument.objects)) {
+        if (seenAssetHashes.has(entry.hash)) continue;
+        seenAssetHashes.add(entry.hash);
+        record(
+          await verifyHashedFile({
+            path: targetPaths.assetObject(directory, entry.hash),
+            expectedSha1: entry.hash,
+            expectedSize: entry.size,
+            category: VerifyFileCategories.ASSET
+          })
+        );
+      }
+      const nativesDir = targetPaths.nativesDir(directory, minecraft.version);
+      if (!await fileExists(nativesDir)) {
+        for (const extraction of libraryPlan.nativeExtractions) {
+          record({
+            path: extraction.source,
+            category: VerifyFileCategories.NATIVE,
+            status: VerifyFileStatuses.MISSING
+          });
+        }
+      }
     }
-    return false;
-  });
+  );
 }
-
-// src/repair/runner.ts
-async function runRepair(input) {
-  const report = await runInstall({
-    plan: {
-      ...input.plan,
-      totalActions: input.plan.actions.length,
-      totalBytes: input.plan.totalBytes
+async function verifyRuntime(input) {
+  return runVerification(
+    {
+      targetId: input.target.id,
+      kind: VerificationKinds.RUNTIME,
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
     },
-    http: input.http,
+    async (record) => {
+      let manifest;
+      try {
+        manifest = await fetchJson(input.http, input.cache, {
+          url: input.target.runtime.manifestUrl,
+          cacheKey: `runtime-manifest:${input.target.runtime.component}:${input.target.runtime.platformKey}:${input.target.runtime.manifestSha1}`,
+          ...input.signal !== void 0 ? { signal: input.signal } : {}
+        });
+      } catch {
+        record({
+          path: input.target.runtime.manifestUrl,
+          category: VerifyFileCategories.RUNTIME_FILE,
+          status: VerifyFileStatuses.MISSING
+        });
+        return;
+      }
+      const runtimeRoot = targetPaths.runtimeRoot(
+        input.target.directory,
+        input.target.runtime.component,
+        input.target.runtime.installRoot
+      );
+      for (const [relative, entry] of Object.entries(manifest.files)) {
+        if (entry.type !== "file") continue;
+        record(
+          await verifyHashedFile({
+            path: path__default.default.join(runtimeRoot, relative),
+            expectedSha1: entry.downloads.raw.sha1,
+            expectedSize: entry.downloads.raw.size,
+            url: entry.downloads.raw.url,
+            category: VerifyFileCategories.RUNTIME_FILE
+          })
+        );
+      }
+    }
+  );
+}
+
+// src/repair/helpers.ts
+function asResultArray(from) {
+  return Array.isArray(from) ? from : [from];
+}
+function buildIssueIndex(from) {
+  const map = /* @__PURE__ */ new Map();
+  for (const v of asResultArray(from)) {
+    for (const issue of v.issues) {
+      const set = map.get(issue.path);
+      if (set) set.add(issue.category);
+      else map.set(issue.path, /* @__PURE__ */ new Set([issue.category]));
+    }
+  }
+  return {
+    has: (path13) => map.has(path13),
+    hasNonNative: (path13) => {
+      const cats = map.get(path13);
+      if (!cats) return false;
+      for (const c of cats) {
+        if (c !== VerifyFileCategories.NATIVE) return true;
+      }
+      return false;
+    },
+    categoriesAt: (path13) => map.get(path13) ?? /* @__PURE__ */ new Set()
+  };
+}
+function sumDownloadBytes(actions) {
+  return actions.reduce((sum, action) => {
+    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
+      return sum + (action.expectedSize ?? 0);
+    }
+    return sum;
+  }, 0);
+}
+function buildRepairPlan(target, actions) {
+  return {
+    targetId: target.id,
+    directory: target.directory,
+    target,
+    actions,
+    totalActions: actions.length,
+    totalBytes: sumDownloadBytes(actions)
+  };
+}
+async function planAspectRepair(input, aspectFilter, postprocess) {
+  const installPlan = await planInstall({
+    target: input.target,
+    http: input.http,
+    cache: input.cache,
+    ...input.signal !== void 0 ? { signal: input.signal } : {}
+  });
+  const issues = buildIssueIndex(input.from);
+  const actions = selectRepairActions({
+    target: input.target,
+    installPlan,
+    issues,
+    aspectFilter
+  });
+  postprocess?.({ actions, installPlan, issues });
+  return buildRepairPlan(input.target, actions);
+}
+function selectRepairActions(input) {
+  const matching = [];
+  for (const action of input.installPlan.actions) {
+    if (!input.aspectFilter(action)) continue;
+    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
+      if (input.issues.hasNonNative(action.target)) {
+        matching.push(action);
+      }
+    } else if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
+      if (input.issues.has(action.path)) {
+        matching.push(action);
+      }
+    } else if (action.kind === InstallActionKinds.EXTRACT_NATIVE) {
+      if (input.issues.has(action.source)) {
+        matching.push(action);
+      }
+    } else {
+      matching.push(action);
+    }
+  }
+  return matching;
+}
+
+// src/repair/fabric.ts
+async function planFabricRepair(input) {
+  if (input.target.loader.type !== Loaders.FABRIC) {
+    throw new MinecraftKitError(
+      "INVALID_INPUT",
+      `repair.fabric requires a Fabric target (got ${input.target.loader.type})`
+    );
+  }
+  const fabricJsonPath = targetPaths.versionJson(
+    input.target.directory,
+    input.target.loader.profile.id
+  );
+  return planAspectRepair(input, (action) => {
+    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
+      return action.category === "fabric-library";
+    }
+    if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
+      return action.path === fabricJsonPath;
+    }
+    return false;
+  });
+}
+
+// src/repair/forge.ts
+var FORGE_DOWNLOAD_CATEGORIES = /* @__PURE__ */ new Set([
+  "forge-library",
+  "forge-installer"
+]);
+async function planForgeRepair(input) {
+  if (input.target.loader.type !== Loaders.FORGE) {
+    throw new MinecraftKitError(
+      "INVALID_INPUT",
+      `repair.forge requires a Forge target (got ${input.target.loader.type})`
+    );
+  }
+  const forgeJsonPath = targetPaths.versionJson(
+    input.target.directory,
+    input.target.loader.fullVersion
+  );
+  return planAspectRepair(
+    input,
+    (action) => {
+      if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
+        return FORGE_DOWNLOAD_CATEGORIES.has(action.category);
+      }
+      if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
+        return action.path === forgeJsonPath;
+      }
+      return false;
+    },
+    ({ actions, installPlan, issues }) => {
+      if (!issues.has(forgeJsonPath)) return;
+      const alreadyIncluded = new Set(
+        actions.filter((a) => a.kind === InstallActionKinds.DOWNLOAD_FILE).map((a) => a.target)
+      );
+      for (const action of installPlan.actions) {
+        if (action.kind === InstallActionKinds.DOWNLOAD_FILE && action.category === "forge-library" && !alreadyIncluded.has(action.target)) {
+          actions.push(action);
+        } else if (action.kind === InstallActionKinds.RUN_FORGE_PROCESSOR) {
+          actions.push(action);
+        }
+      }
+    }
+  );
+}
+
+// src/repair/minecraft.ts
+var MINECRAFT_DOWNLOAD_CATEGORIES = /* @__PURE__ */ new Set([
+  "client-jar",
+  "library",
+  "asset-index",
+  "asset",
+  "logging-config"
+]);
+async function planMinecraftRepair(input) {
+  const vanillaJsonPath = targetPaths.versionJson(
+    input.target.directory,
+    input.target.minecraft.version
+  );
+  return planAspectRepair(input, (action) => {
+    if (action.kind === InstallActionKinds.DOWNLOAD_FILE) {
+      return MINECRAFT_DOWNLOAD_CATEGORIES.has(action.category);
+    }
+    if (action.kind === InstallActionKinds.WRITE_VERSION_JSON) {
+      return action.path === vanillaJsonPath;
+    }
+    if (action.kind === InstallActionKinds.EXTRACT_NATIVE) {
+      return true;
+    }
+    return false;
+  });
+}
+
+// src/repair/runner.ts
+async function runRepair(input) {
+  const report = await runInstall({
+    plan: {
+      ...input.plan,
+      totalActions: input.plan.actions.length,
+      totalBytes: input.plan.totalBytes
+    },
+    http: input.http,
     cache: input.cache,
     spawner: input.spawner,
     ...input.signal !== void 0 ? { signal: input.signal } : {},
@@ -2637,6 +3223,58 @@ async function planRuntimeRepair(input) {
   );
 }
 
+// src/repair/all.ts
+async function repairAll(input) {
+  const startedAt = Date.now();
+  const ctx = {
+    target: input.target,
+    http: input.http,
+    cache: input.cache,
+    ...input.signal !== void 0 ? { signal: input.signal } : {}
+  };
+  const verifications = [];
+  const mc = await verifyMinecraft(ctx);
+  verifications.push(mc);
+  const rt = await verifyRuntime(ctx);
+  verifications.push(rt);
+  if (input.target.loader.type === Loaders.FABRIC) {
+    verifications.push(await verifyFabric(ctx));
+  } else if (input.target.loader.type === Loaders.FORGE) {
+    verifications.push(await verifyForge(ctx));
+  }
+  const repairs = /* @__PURE__ */ new Map();
+  let bytesDownloaded = 0;
+  for (const verification of verifications) {
+    if (verification.isValid) continue;
+    const planner = PLANNERS[verification.kind];
+    if (!planner) continue;
+    const plan = await planner({ ...ctx, from: verification });
+    if (plan.totalActions === 0) continue;
+    const report = await runRepair({
+      plan,
+      http: input.http,
+      cache: input.cache,
+      spawner: input.spawner,
+      ...input.signal !== void 0 ? { signal: input.signal } : {},
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
+    });
+    repairs.set(verification.kind, report);
+    bytesDownloaded += report.bytesDownloaded;
+  }
+  return {
+    verifications,
+    repairs,
+    bytesDownloaded,
+    durationMs: Date.now() - startedAt
+  };
+}
+var PLANNERS = {
+  minecraft: planMinecraftRepair,
+  runtime: planRuntimeRepair,
+  fabric: planFabricRepair,
+  forge: planForgeRepair
+};
+
 // src/types/runtime.ts
 var RuntimeComponents = {
   JRE_LEGACY: "jre-legacy",
@@ -2711,485 +3349,125 @@ var TargetsApi = class {
     const runtime = input.runtime?.installRoot !== void 0 ? { ...resolvedRuntime, installRoot: input.runtime.installRoot } : resolvedRuntime;
     let loader;
     if (input.loader.type === Loaders.VANILLA) {
-      loader = {
-        type: Loaders.VANILLA,
-        minecraftVersion: minecraft.version,
-        minecraft
-      };
-    } else if (input.loader.type === Loaders.FABRIC) {
-      loader = await this.ctx.fabric.resolve({
-        minecraftVersion: minecraft.version,
-        ...input.loader.preference !== void 0 ? { preference: input.loader.preference } : {},
-        ...input.loader.version !== void 0 ? { loaderVersion: input.loader.version } : {},
-        ...input.signal !== void 0 ? { signal: input.signal } : {}
-      });
-    } else {
-      loader = await this.ctx.forge.resolve({
-        minecraftVersion: minecraft.version,
-        ...input.loader.preference !== void 0 ? { preference: input.loader.preference } : {},
-        ...input.loader.version !== void 0 ? { forgeVersion: input.loader.version } : {},
-        ...input.signal !== void 0 ? { signal: input.signal } : {}
-      });
-    }
-    return this.create({
-      id: input.id,
-      directory: input.directory,
-      minecraft,
-      loader,
-      runtime
-    });
-  }
-  /** Scan a root directory for Minecraft installations. Returns only what is on disk. */
-  async list(input) {
-    if (!await dirExists(input.rootDir)) return [];
-    const subdirs = await listChildDirectories(input.rootDir);
-    const results = [];
-    for (const id of subdirs) {
-      const directory = path__default.default.join(input.rootDir, id);
-      const discovered = await discoverInstallation(id, directory);
-      if (discovered) results.push(discovered);
-    }
-    return results;
-  }
-};
-async function discoverInstallation(id, directory) {
-  const versionsDir = path__default.default.join(directory, VERSIONS_DIR);
-  const librariesDir = path__default.default.join(directory, LIBRARIES_DIR);
-  const assetsDir = path__default.default.join(directory, ASSETS_DIR);
-  const looksLikeInstall = await dirExists(versionsDir) && (await dirExists(librariesDir) || await dirExists(assetsDir));
-  if (!looksLikeInstall) return null;
-  const versionDirs = await listChildDirectories(versionsDir);
-  const minecraftVersions = [];
-  const loaders = [];
-  for (const versionId of versionDirs) {
-    const hint = inferLoaderFromVersionId(versionId);
-    if (hint) {
-      loaders.push(hint);
-      if (hint.minecraftVersion && !minecraftVersions.includes(hint.minecraftVersion)) {
-        minecraftVersions.push(hint.minecraftVersion);
-      }
-    } else {
-      minecraftVersions.push(versionId);
-    }
-  }
-  const runtime = await discoverRuntime(directory);
-  return { id, directory, minecraftVersions, loaders, ...runtime ? { runtime } : {} };
-}
-async function discoverRuntime(directory) {
-  const runtimeDir = path__default.default.join(directory, RUNTIMES_DIR);
-  if (!await dirExists(runtimeDir)) return void 0;
-  let components;
-  try {
-    components = await listChildDirectories(runtimeDir);
-  } catch {
-    return void 0;
-  }
-  for (const component of components) {
-    const root = path__default.default.join(runtimeDir, component);
-    const javaPath = process.platform === "win32" ? path__default.default.join(root, "bin", "javaw.exe") : process.platform === "darwin" ? path__default.default.join(root, "jre.bundle", "Contents", "Home", "bin", "java") : path__default.default.join(root, "bin", "java");
-    if (await fileExists(javaPath)) {
-      return { component, javaPath };
-    }
-  }
-  return void 0;
-}
-function inferLoaderFromVersionId(versionId) {
-  const fabricMatch = /^fabric-loader-([^-]+)-(.+)$/.exec(versionId);
-  if (fabricMatch?.[1] && fabricMatch[2]) {
-    return { type: Loaders.FABRIC, version: fabricMatch[1], minecraftVersion: fabricMatch[2] };
-  }
-  const forgeMatch = /^([^-]+)-forge-(.+)$/.exec(versionId);
-  if (forgeMatch?.[1] && forgeMatch[2]) {
-    return { type: Loaders.FORGE, minecraftVersion: forgeMatch[1], version: forgeMatch[2] };
-  }
-  return null;
-}
-
-// src/update/runner.ts
-async function planUpdate(input) {
-  return planInstall({
-    target: input.target,
-    http: input.http,
-    cache: input.cache,
-    ...input.signal !== void 0 ? { signal: input.signal } : {}
-  });
-}
-async function runUpdate(input) {
-  const report = await runInstall({
-    plan: input.plan,
-    http: input.http,
-    cache: input.cache,
-    spawner: input.spawner,
-    ...input.signal !== void 0 ? { signal: input.signal } : {},
-    ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-  });
-  return {
-    targetId: report.targetId,
-    bytesDownloaded: report.bytesDownloaded,
-    actionsCompleted: report.actionsCompleted,
-    actionsSkipped: report.actionsSkipped,
-    durationMs: report.durationMs
-  };
-}
-async function sha1OfFile(filePath) {
-  const hash = crypto2__default.default.createHash("sha1");
-  await new Promise((resolve, reject) => {
-    const stream = fs$1.createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", resolve);
-    stream.on("error", reject);
-  });
-  return hash.digest("hex");
-}
-
-// src/verify/helpers.ts
-async function runVerification(input, check) {
-  const startedAt = Date.now();
-  const results = [];
-  const record = (result) => {
-    results.push(result);
-    input.onEvent?.({ type: "verify:file-checked", file: result });
-  };
-  await check(record);
-  return {
-    targetId: input.targetId,
-    kind: input.kind,
-    isValid: results.every((r) => r.status === VerifyFileStatuses.OK),
-    issues: results.filter((r) => r.status !== VerifyFileStatuses.OK),
-    checkedFiles: results.length,
-    durationMs: Date.now() - startedAt
-  };
-}
-async function verifyHashedFile(input) {
-  if (!await fileExists(input.path)) {
-    return {
-      path: input.path,
-      category: input.category,
-      status: VerifyFileStatuses.MISSING,
-      ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
-      ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
-      ...input.url !== void 0 ? { url: input.url } : {}
-    };
-  }
-  if (input.expectedSize !== void 0) {
-    const size = await fileSize(input.path);
-    if (size !== input.expectedSize) {
-      return {
-        path: input.path,
-        category: input.category,
-        status: VerifyFileStatuses.WRONG_SIZE,
-        expectedSize: input.expectedSize,
-        actualSize: size,
-        ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
-        ...input.url !== void 0 ? { url: input.url } : {}
-      };
-    }
-  }
-  if (input.expectedSha1 !== void 0) {
-    const actualSha1 = await sha1OfFile(input.path);
-    if (actualSha1 !== input.expectedSha1) {
-      return {
-        path: input.path,
-        category: input.category,
-        status: VerifyFileStatuses.CORRUPT,
-        expectedSha1: input.expectedSha1,
-        actualSha1,
-        ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
-        ...input.url !== void 0 ? { url: input.url } : {}
-      };
-    }
-  }
-  return {
-    path: input.path,
-    category: input.category,
-    status: VerifyFileStatuses.OK,
-    ...input.expectedSha1 !== void 0 ? { expectedSha1: input.expectedSha1 } : {},
-    ...input.expectedSize !== void 0 ? { expectedSize: input.expectedSize } : {},
-    ...input.url !== void 0 ? { url: input.url } : {}
-  };
-}
-async function verifyExistence(input) {
-  if (await fileExists(input.path)) {
-    return {
-      path: input.path,
-      category: input.category,
-      status: VerifyFileStatuses.OK,
-      ...input.url !== void 0 ? { url: input.url } : {}
-    };
-  }
-  return {
-    path: input.path,
-    category: input.category,
-    status: VerifyFileStatuses.MISSING,
-    ...input.url !== void 0 ? { url: input.url } : {}
-  };
-}
-async function findForgeVersionJsonPath(directory, minecraftVersion) {
-  const versionsDir = targetPaths.versionsDir(directory);
-  const dirs = await listChildDirectories(versionsDir);
-  for (const id of dirs) {
-    if (!id.startsWith(`${minecraftVersion}-forge-`)) continue;
-    const jsonPath = targetPaths.versionJson(directory, id);
-    if (!await fileExists(jsonPath)) {
-      return jsonPath;
-    }
-    const parsed = await tryParseInheritsFrom(jsonPath);
-    if (parsed === minecraftVersion) return jsonPath;
-  }
-  return null;
-}
-async function tryParseInheritsFrom(jsonPath) {
-  try {
-    const parsed = JSON.parse(await readText(jsonPath));
-    return parsed.inheritsFrom;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/verify/fabric.ts
-async function verifyFabric(input) {
-  if (input.target.loader.type !== Loaders.FABRIC) {
-    throw new MinecraftKitError(
-      "INVALID_INPUT",
-      `verify.fabric requires a Fabric target (got ${input.target.loader.type})`
-    );
-  }
-  const loader = input.target.loader;
-  return runVerification(
-    {
-      targetId: input.target.id,
-      kind: VerificationKinds.FABRIC,
-      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-    },
-    async (record) => {
-      record(
-        await verifyExistence({
-          path: targetPaths.versionJson(input.target.directory, loader.profile.id),
-          category: VerifyFileCategories.LOADER_LIBRARY
-        })
-      );
-      const fabricLibraries = planLibraryDownloads({
-        libraries: loader.profile.libraries,
-        directory: input.target.directory,
-        system: input.target.runtime.system,
-        versionId: input.target.minecraft.version,
-        category: "fabric-library"
-      });
-      for (const action of fabricLibraries.downloads) {
-        record(
-          await verifyHashedFile({
-            path: action.target,
-            expectedSha1: action.expectedSha1,
-            expectedSize: action.expectedSize,
-            ...action.url ? { url: action.url } : {},
-            category: VerifyFileCategories.LOADER_LIBRARY
-          })
-        );
-      }
-    }
-  );
-}
-
-// src/verify/forge.ts
-async function verifyForge(input) {
-  if (input.target.loader.type !== Loaders.FORGE) {
-    throw new MinecraftKitError(
-      "INVALID_INPUT",
-      `verify.forge requires a Forge target (got ${input.target.loader.type})`
-    );
-  }
-  return runVerification(
-    {
-      targetId: input.target.id,
-      kind: VerificationKinds.FORGE,
-      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-    },
-    async (record) => {
-      const forgeVersionJsonPath = await findForgeVersionJsonPath(
-        input.target.directory,
-        input.target.minecraft.version
-      );
-      if (forgeVersionJsonPath === null) return;
-      record(
-        await verifyExistence({
-          path: forgeVersionJsonPath,
-          category: VerifyFileCategories.LOADER_LIBRARY
-        })
-      );
-      if (!await fileExists(forgeVersionJsonPath)) return;
-      let parsed;
-      try {
-        parsed = JSON.parse(await readText(forgeVersionJsonPath));
-      } catch {
-        record({
-          path: forgeVersionJsonPath,
-          category: VerifyFileCategories.LOADER_LIBRARY,
-          status: VerifyFileStatuses.CORRUPT
-        });
-        return;
-      }
-      const forgeLibraries = planLibraryDownloads({
-        libraries: parsed.libraries,
-        directory: input.target.directory,
-        system: input.target.runtime.system,
-        versionId: input.target.minecraft.version,
-        category: "forge-library"
-      });
-      for (const action of forgeLibraries.downloads) {
-        record(
-          await verifyHashedFile({
-            path: action.target,
-            expectedSha1: action.expectedSha1,
-            expectedSize: action.expectedSize,
-            ...action.url ? { url: action.url } : {},
-            category: VerifyFileCategories.LOADER_LIBRARY
-          })
-        );
-      }
-    }
-  );
-}
-
-// src/verify/minecraft.ts
-async function verifyMinecraft(input) {
-  return runVerification(
-    {
-      targetId: input.target.id,
-      kind: VerificationKinds.MINECRAFT,
-      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-    },
-    async (record) => {
-      const { directory, minecraft, runtime } = input.target;
-      record(
-        await verifyHashedFile({
-          path: targetPaths.versionJar(directory, minecraft.version),
-          expectedSha1: minecraft.manifest.downloads.client.sha1,
-          expectedSize: minecraft.manifest.downloads.client.size,
-          url: minecraft.manifest.downloads.client.url,
-          category: VerifyFileCategories.CLIENT_JAR
-        })
-      );
-      record(
-        await verifyExistence({
-          path: targetPaths.versionJson(directory, minecraft.version),
-          category: VerifyFileCategories.CLIENT_JAR
-        })
-      );
-      if (minecraft.manifest.logging?.client) {
-        const logging = minecraft.manifest.logging.client;
-        record(
-          await verifyHashedFile({
-            path: targetPaths.loggingConfig(directory, logging.file.id),
-            expectedSha1: logging.file.sha1,
-            expectedSize: logging.file.size,
-            url: logging.file.url,
-            category: VerifyFileCategories.LOGGING_CONFIG
-          })
-        );
-      }
-      const libraryPlan = planLibraryDownloads({
-        libraries: minecraft.manifest.libraries,
-        directory,
-        system: runtime.system,
-        versionId: minecraft.version,
-        category: "library"
+      loader = {
+        type: Loaders.VANILLA,
+        minecraftVersion: minecraft.version,
+        minecraft
+      };
+    } else if (input.loader.type === Loaders.FABRIC) {
+      loader = await this.ctx.fabric.resolve({
+        minecraftVersion: minecraft.version,
+        ...input.loader.preference !== void 0 ? { preference: input.loader.preference } : {},
+        ...input.loader.version !== void 0 ? { loaderVersion: input.loader.version } : {},
+        ...input.signal !== void 0 ? { signal: input.signal } : {}
       });
-      for (const action of libraryPlan.downloads) {
-        record(
-          await verifyHashedFile({
-            path: action.target,
-            expectedSha1: action.expectedSha1,
-            expectedSize: action.expectedSize,
-            url: action.url,
-            category: VerifyFileCategories.LIBRARY
-          })
-        );
-      }
-      const indexUrl = minecraft.manifest.assetIndex.url;
-      const indexPath = targetPaths.assetIndex(directory, minecraft.manifest.assetIndex.id);
-      record(
-        await verifyHashedFile({
-          path: indexPath,
-          expectedSha1: minecraft.manifest.assetIndex.sha1,
-          expectedSize: minecraft.manifest.assetIndex.size,
-          url: indexUrl,
-          category: VerifyFileCategories.ASSET_INDEX
-        })
-      );
-      const indexDocument = await fetchJson(input.http, input.cache, {
-        url: indexUrl,
-        cacheKey: `asset-index:${minecraft.manifest.assetIndex.id}:${minecraft.manifest.assetIndex.sha1}`,
+    } else {
+      loader = await this.ctx.forge.resolve({
+        minecraftVersion: minecraft.version,
+        ...input.loader.preference !== void 0 ? { preference: input.loader.preference } : {},
+        ...input.loader.version !== void 0 ? { forgeVersion: input.loader.version } : {},
         ...input.signal !== void 0 ? { signal: input.signal } : {}
       });
-      const seenAssetHashes = /* @__PURE__ */ new Set();
-      for (const entry of Object.values(indexDocument.objects)) {
-        if (seenAssetHashes.has(entry.hash)) continue;
-        seenAssetHashes.add(entry.hash);
-        record(
-          await verifyHashedFile({
-            path: targetPaths.assetObject(directory, entry.hash),
-            expectedSha1: entry.hash,
-            expectedSize: entry.size,
-            category: VerifyFileCategories.ASSET
-          })
-        );
-      }
-      const nativesDir = targetPaths.nativesDir(directory, minecraft.version);
-      if (!await fileExists(nativesDir)) {
-        for (const extraction of libraryPlan.nativeExtractions) {
-          record({
-            path: extraction.source,
-            category: VerifyFileCategories.NATIVE,
-            status: VerifyFileStatuses.MISSING
-          });
-        }
+    }
+    return this.create({
+      id: input.id,
+      directory: input.directory,
+      minecraft,
+      loader,
+      runtime
+    });
+  }
+  /** Scan a root directory for Minecraft installations. Returns only what is on disk. */
+  async list(input) {
+    if (!await dirExists(input.rootDir)) return [];
+    const subdirs = await listChildDirectories(input.rootDir);
+    const results = [];
+    for (const id of subdirs) {
+      const directory = path__default.default.join(input.rootDir, id);
+      const discovered = await discoverInstallation(id, directory);
+      if (discovered) results.push(discovered);
+    }
+    return results;
+  }
+};
+async function discoverInstallation(id, directory) {
+  const versionsDir = path__default.default.join(directory, VERSIONS_DIR);
+  const librariesDir = path__default.default.join(directory, LIBRARIES_DIR);
+  const assetsDir = path__default.default.join(directory, ASSETS_DIR);
+  const looksLikeInstall = await dirExists(versionsDir) && (await dirExists(librariesDir) || await dirExists(assetsDir));
+  if (!looksLikeInstall) return null;
+  const versionDirs = await listChildDirectories(versionsDir);
+  const minecraftVersions = [];
+  const loaders = [];
+  for (const versionId of versionDirs) {
+    const hint = inferLoaderFromVersionId(versionId);
+    if (hint) {
+      loaders.push(hint);
+      if (hint.minecraftVersion && !minecraftVersions.includes(hint.minecraftVersion)) {
+        minecraftVersions.push(hint.minecraftVersion);
       }
+    } else {
+      minecraftVersions.push(versionId);
     }
-  );
+  }
+  const runtime = await discoverRuntime(directory);
+  return { id, directory, minecraftVersions, loaders, ...runtime ? { runtime } : {} };
 }
-async function verifyRuntime(input) {
-  return runVerification(
-    {
-      targetId: input.target.id,
-      kind: VerificationKinds.RUNTIME,
-      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
-    },
-    async (record) => {
-      let manifest;
-      try {
-        manifest = await fetchJson(input.http, input.cache, {
-          url: input.target.runtime.manifestUrl,
-          cacheKey: `runtime-manifest:${input.target.runtime.component}:${input.target.runtime.platformKey}:${input.target.runtime.manifestSha1}`,
-          ...input.signal !== void 0 ? { signal: input.signal } : {}
-        });
-      } catch {
-        record({
-          path: input.target.runtime.manifestUrl,
-          category: VerifyFileCategories.RUNTIME_FILE,
-          status: VerifyFileStatuses.MISSING
-        });
-        return;
-      }
-      const runtimeRoot = targetPaths.runtimeRoot(
-        input.target.directory,
-        input.target.runtime.component,
-        input.target.runtime.installRoot
-      );
-      for (const [relative, entry] of Object.entries(manifest.files)) {
-        if (entry.type !== "file") continue;
-        record(
-          await verifyHashedFile({
-            path: path__default.default.join(runtimeRoot, relative),
-            expectedSha1: entry.downloads.raw.sha1,
-            expectedSize: entry.downloads.raw.size,
-            url: entry.downloads.raw.url,
-            category: VerifyFileCategories.RUNTIME_FILE
-          })
-        );
-      }
+async function discoverRuntime(directory) {
+  const runtimeDir = path__default.default.join(directory, RUNTIMES_DIR);
+  if (!await dirExists(runtimeDir)) return void 0;
+  let components;
+  try {
+    components = await listChildDirectories(runtimeDir);
+  } catch {
+    return void 0;
+  }
+  for (const component of components) {
+    const root = path__default.default.join(runtimeDir, component);
+    const javaPath = process.platform === "win32" ? path__default.default.join(root, "bin", "javaw.exe") : process.platform === "darwin" ? path__default.default.join(root, "jre.bundle", "Contents", "Home", "bin", "java") : path__default.default.join(root, "bin", "java");
+    if (await fileExists(javaPath)) {
+      return { component, javaPath };
     }
-  );
+  }
+  return void 0;
+}
+function inferLoaderFromVersionId(versionId) {
+  const fabricMatch = /^fabric-loader-([^-]+)-(.+)$/.exec(versionId);
+  if (fabricMatch?.[1] && fabricMatch[2]) {
+    return { type: Loaders.FABRIC, version: fabricMatch[1], minecraftVersion: fabricMatch[2] };
+  }
+  const forgeMatch = /^([^-]+)-forge-(.+)$/.exec(versionId);
+  if (forgeMatch?.[1] && forgeMatch[2]) {
+    return { type: Loaders.FORGE, minecraftVersion: forgeMatch[1], version: forgeMatch[2] };
+  }
+  return null;
+}
+
+// src/update/runner.ts
+async function planUpdate(input) {
+  return planInstall({
+    target: input.target,
+    http: input.http,
+    cache: input.cache,
+    ...input.signal !== void 0 ? { signal: input.signal } : {}
+  });
+}
+async function runUpdate(input) {
+  const report = await runInstall({
+    plan: input.plan,
+    http: input.http,
+    cache: input.cache,
+    spawner: input.spawner,
+    ...input.signal !== void 0 ? { signal: input.signal } : {},
+    ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
+  });
+  return {
+    targetId: report.targetId,
+    bytesDownloaded: report.bytesDownloaded,
+    actionsCompleted: report.actionsCompleted,
+    actionsSkipped: report.actionsSkipped,
+    durationMs: report.durationMs
+  };
 }
 
 // src/versions/fabric.ts
@@ -3523,15 +3801,23 @@ function pickLatestAcrossComponents(entries) {
   return { component: bestComponent, entry: bestEntry };
 }
 function toResolved(component, platformKey, entry, system) {
+  const majorVersion = parseMajorVersion(entry.version.name);
   return {
     component,
     platformKey,
     versionName: entry.version.name,
+    ...majorVersion !== void 0 ? { majorVersion } : {},
     system,
     manifestUrl: entry.manifest.url,
     manifestSha1: entry.manifest.sha1
   };
 }
+function parseMajorVersion(versionName) {
+  const match = /^(\d+)/.exec(versionName);
+  if (!match || !match[1]) return void 0;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
 
 // src/kit.ts
 var MinecraftKit = class {
@@ -3562,7 +3848,12 @@ var MinecraftKit = class {
       ...opts?.signal !== void 0 ? { signal: opts.signal } : {},
       ...opts?.onEvent !== void 0 ? { onEvent: opts.onEvent } : {}
     });
-    const runInstallPlan = (plan, opts) => runInstall({ plan, http, cache, spawner, ...carry(opts) });
+    const carryInstall = (opts) => ({
+      ...carry(opts),
+      ...opts?.pauseController !== void 0 ? { pauseController: opts.pauseController } : {},
+      ...opts?.actionCategories !== void 0 ? { actionCategories: opts.actionCategories } : {}
+    });
+    const runInstallPlan = (plan, opts) => runInstall({ plan, http, cache, spawner, ...carryInstall(opts) });
     this.install = {
       plan: (target, opts) => planInstall({ target, http, cache, ...carry(opts) }),
       run: runInstallPlan,
@@ -3612,10 +3903,17 @@ var MinecraftKit = class {
       runtime: {
         plan: (target, opts) => planRuntimeRepair(repairArgs(target, opts)),
         run: runRepairPlan
-      }
+      },
+      all: (target, opts) => repairAll({
+        target,
+        http,
+        cache,
+        spawner,
+        ...carry(opts)
+      })
     };
     this.launch = {
-      compose: (target, opts) => composeLaunch({ target, options: opts }),
+      compose: (target, opts) => composeLaunch({ target, options: opts, logger }),
       run: (composition, opts) => runLaunch({
         composition,
         ...opts !== void 0 ? { options: opts } : {},
@@ -3625,6 +3923,247 @@ var MinecraftKit = class {
   }
 };
 
+// src/core/pause-controller.ts
+var PauseController = class {
+  #paused = false;
+  #waiters = [];
+  get paused() {
+    return this.#paused;
+  }
+  pause() {
+    this.#paused = true;
+  }
+  resume() {
+    this.#paused = false;
+    const list = this.#waiters;
+    this.#waiters = [];
+    for (const resolve of list) resolve();
+  }
+  waitWhilePaused() {
+    if (!this.#paused) return Promise.resolve();
+    return new Promise((resolve) => this.#waiters.push(resolve));
+  }
+};
+
+// src/install/progress-tracker.ts
+var InstallStages = {
+  PREPARE: "prepare",
+  RUNTIME: "runtime",
+  MINECRAFT: "minecraft",
+  LOADER: "loader",
+  FINALIZE: "finalize"
+};
+var STAGE_FOR_CATEGORY = {
+  "runtime-file": InstallStages.RUNTIME,
+  "client-jar": InstallStages.MINECRAFT,
+  library: InstallStages.MINECRAFT,
+  "asset-index": InstallStages.MINECRAFT,
+  asset: InstallStages.MINECRAFT,
+  "logging-config": InstallStages.MINECRAFT,
+  "fabric-library": InstallStages.LOADER,
+  "forge-library": InstallStages.LOADER,
+  "forge-installer": InstallStages.LOADER
+};
+var STAGE_FOR_PHASE = {
+  [InstallPhases.PLANNING]: InstallStages.PREPARE,
+  [InstallPhases.DOWNLOADING_VERSION_MANIFEST]: InstallStages.PREPARE,
+  [InstallPhases.INSTALLING_RUNTIME]: InstallStages.RUNTIME,
+  [InstallPhases.DOWNLOADING_CLIENT_JAR]: InstallStages.MINECRAFT,
+  [InstallPhases.DOWNLOADING_LIBRARIES]: InstallStages.MINECRAFT,
+  [InstallPhases.DOWNLOADING_ASSET_INDEX]: InstallStages.MINECRAFT,
+  [InstallPhases.DOWNLOADING_ASSETS]: InstallStages.MINECRAFT,
+  [InstallPhases.EXTRACTING_NATIVES]: InstallStages.MINECRAFT,
+  [InstallPhases.WRITING_FILES]: InstallStages.MINECRAFT,
+  [InstallPhases.INSTALLING_FABRIC]: InstallStages.LOADER,
+  [InstallPhases.INSTALLING_FORGE]: InstallStages.LOADER,
+  [InstallPhases.RUNNING_FORGE_PROCESSORS]: InstallStages.LOADER,
+  [InstallPhases.COMPLETED]: InstallStages.FINALIZE
+};
+var ALL_STAGES = [
+  InstallStages.PREPARE,
+  InstallStages.RUNTIME,
+  InstallStages.MINECRAFT,
+  InstallStages.LOADER,
+  InstallStages.FINALIZE
+];
+function createInstallProgressTracker(plan, options = {}) {
+  const throttleMs = options.throttleMs ?? 100;
+  const stageOfTarget = /* @__PURE__ */ new Map();
+  const expectedSizeOf = /* @__PURE__ */ new Map();
+  const stageTotals = {
+    prepare: 0,
+    runtime: 0,
+    minecraft: 0,
+    loader: 0,
+    finalize: 0
+  };
+  let overallTotal = 0;
+  for (const action of plan.actions) {
+    if (action.kind !== "download-file") continue;
+    const stage = STAGE_FOR_CATEGORY[action.category] ?? InstallStages.MINECRAFT;
+    stageOfTarget.set(action.target, stage);
+    const size = action.expectedSize ?? 0;
+    expectedSizeOf.set(action.target, size);
+    stageTotals[stage] += size;
+    overallTotal += size;
+  }
+  const stageDone = {
+    prepare: 0,
+    runtime: 0,
+    minecraft: 0,
+    loader: 0,
+    finalize: 0
+  };
+  const stageInFlight = {
+    prepare: 0,
+    runtime: 0,
+    minecraft: 0,
+    loader: 0,
+    finalize: 0
+  };
+  let totalDone = 0;
+  let totalInFlight = 0;
+  const inFlightByTarget = /* @__PURE__ */ new Map();
+  let currentStage = InstallStages.PREPARE;
+  let currentFile;
+  const listeners = /* @__PURE__ */ new Set();
+  let lastPushAt = 0;
+  let pending = false;
+  let pendingTimer = null;
+  let finished = false;
+  const snapshot = () => {
+    const stageTotal = stageTotals[currentStage];
+    const stageBytes = stageDone[currentStage] + stageInFlight[currentStage];
+    const overallBytes = totalDone + totalInFlight;
+    return {
+      stage: currentStage,
+      stagePercent: stageTotal > 0 ? clamp(stageBytes / stageTotal * 100) : 0,
+      overallPercent: overallTotal > 0 ? clamp(overallBytes / overallTotal * 100) : 0,
+      bytesDownloaded: overallBytes,
+      totalBytes: stageTotal,
+      ...currentFile !== void 0 ? { currentFile } : {}
+    };
+  };
+  const clearTimer = () => {
+    if (pendingTimer) {
+      clearTimeout(pendingTimer);
+      pendingTimer = null;
+    }
+  };
+  const push = () => {
+    pending = false;
+    clearTimer();
+    lastPushAt = Date.now();
+    const snap = snapshot();
+    for (const listener of listeners) listener(snap);
+  };
+  const schedulePush = () => {
+    if (finished) return;
+    const elapsed = Date.now() - lastPushAt;
+    if (elapsed >= throttleMs) {
+      push();
+      return;
+    }
+    if (pending) return;
+    pending = true;
+    pendingTimer = setTimeout(push, throttleMs - elapsed);
+  };
+  const onEvent = (event) => {
+    switch (event.type) {
+      case "install:phase-changed": {
+        const next = STAGE_FOR_PHASE[event.phase];
+        if (next && next !== currentStage) {
+          currentStage = next;
+          currentFile = void 0;
+          push();
+        }
+        return;
+      }
+      case "download:started": {
+        const stage = stageOfTarget.get(event.file.target) ?? currentStage;
+        inFlightByTarget.set(event.file.target, { stage, bytes: 0 });
+        currentFile = event.file.target;
+        schedulePush();
+        return;
+      }
+      case "download:progress": {
+        const entry = inFlightByTarget.get(event.file.target);
+        if (entry) {
+          const delta = event.bytesDownloaded - entry.bytes;
+          if (delta !== 0) {
+            entry.bytes = event.bytesDownloaded;
+            stageInFlight[entry.stage] += delta;
+            totalInFlight += delta;
+          }
+        }
+        currentFile = event.file.target;
+        schedulePush();
+        return;
+      }
+      case "download:skipped": {
+        const stage = stageOfTarget.get(event.file.target);
+        if (stage) {
+          const size = expectedSizeOf.get(event.file.target) ?? 0;
+          stageDone[stage] += size;
+          totalDone += size;
+          schedulePush();
+        }
+        return;
+      }
+      case "download:completed": {
+        const entry = inFlightByTarget.get(event.file.target);
+        if (entry) {
+          const finalBytes = event.bytes ?? entry.bytes;
+          stageInFlight[entry.stage] -= entry.bytes;
+          totalInFlight -= entry.bytes;
+          stageDone[entry.stage] += finalBytes;
+          totalDone += finalBytes;
+          inFlightByTarget.delete(event.file.target);
+        } else {
+          const stage = stageOfTarget.get(event.file.target);
+          if (stage) {
+            const bytes = event.bytes ?? expectedSizeOf.get(event.file.target) ?? 0;
+            stageDone[stage] += bytes;
+            totalDone += bytes;
+          }
+        }
+        schedulePush();
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  return {
+    onEvent,
+    snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(snapshot());
+      return () => listeners.delete(listener);
+    },
+    finish() {
+      finished = true;
+      clearTimer();
+      currentStage = InstallStages.FINALIZE;
+      currentFile = void 0;
+      totalDone = overallTotal;
+      totalInFlight = 0;
+      for (const stage of ALL_STAGES) {
+        stageDone[stage] = stageTotals[stage];
+        stageInFlight[stage] = 0;
+      }
+      const snap = snapshot();
+      for (const listener of listeners) listener(snap);
+    }
+  };
+}
+function clamp(value) {
+  if (value <= 0) return 0;
+  if (value >= 100) return 100;
+  return value;
+}
+
 // src/types/events.ts
 var EventTypes = {
   INSTALL_PHASE_CHANGED: "install:phase-changed",
@@ -3749,6 +4288,7 @@ exports.HTTP_RETRY_MAX = HTTP_RETRY_MAX;
 exports.HTTP_TIMEOUT_MS = HTTP_TIMEOUT_MS;
 exports.InstallActionKinds = InstallActionKinds;
 exports.InstallPhases = InstallPhases;
+exports.InstallStages = InstallStages;
 exports.JAVA_EXECUTABLE = JAVA_EXECUTABLE;
 exports.LAUNCH_PLACEHOLDERS = LAUNCH_PLACEHOLDERS;
 exports.LEGACY_JVM_ARGS = LEGACY_JVM_ARGS;
@@ -3767,6 +4307,7 @@ exports.NODE_ARCH_TO_MOJANG_ARCH = NODE_ARCH_TO_MOJANG_ARCH;
 exports.NODE_PLATFORM_TO_MOJANG_OS = NODE_PLATFORM_TO_MOJANG_OS;
 exports.OperatingSystems = OperatingSystems;
 exports.PROGRESS_EVENT_INTERVAL_MS = PROGRESS_EVENT_INTERVAL_MS;
+exports.PauseController = PauseController;
 exports.RUNTIMES_DIR = RUNTIMES_DIR;
 exports.RUNTIME_PLATFORM_KEYS = RUNTIME_PLATFORM_KEYS;
 exports.RepairPhases = RepairPhases;
@@ -3782,20 +4323,26 @@ exports.VerifyFileCategories = VerifyFileCategories;
 exports.VerifyFileStatuses = VerifyFileStatuses;
 exports.VersionPreference = VersionPreference;
 exports.consoleLogger = consoleLogger;
+exports.createInstallProgressTracker = createInstallProgressTracker;
 exports.createMemoryCache = createMemoryCache;
 exports.detectSystem = detectSystem;
 exports.isErrorCode = isErrorCode;
 exports.isMinecraftKitError = isMinecraftKitError;
 exports.offlineUuidFor = offlineUuidFor;
+exports.parseMajorVersion = parseMajorVersion;
+exports.pickClientJarVersionId = pickClientJarVersionId;
 exports.planFabricRepair = planFabricRepair;
 exports.planForgeRepair = planForgeRepair;
 exports.planMinecraftRepair = planMinecraftRepair;
 exports.planRuntimeInstall = planRuntimeInstall;
 exports.planRuntimeRepair = planRuntimeRepair;
 exports.planStandaloneRuntimeInstall = planStandaloneRuntimeInstall;
+exports.repairAll = repairAll;
+exports.resolveLaunchVersion = resolveLaunchVersion;
 exports.runRepair = runRepair;
 exports.silentLogger = silentLogger;
 exports.stripUuidDashes = stripUuidDashes;
+exports.targetPaths = targetPaths;
 exports.verifyFabric = verifyFabric;
 exports.verifyForge = verifyForge;
 exports.verifyMinecraft = verifyMinecraft;