@loontail/minecraft-kit 0.4.0 → 0.6.0

package/dist/cli/{index.js → index.mjs}

@@ -9,7 +9,7 @@ import yauzl from 'yauzl';
 import crypto2 from 'crypto';
 import fs from 'fs/promises';
 import { Readable } from 'stream';
-import pLimit from 'p-limit';
+import { AsyncResource } from 'async_hooks';
 import { Buffer as Buffer$1 } from 'buffer';
 import { spawn } from 'child_process';
 
@@ -277,9 +277,14 @@ var targetPaths = {
 // src/types/install.ts
 var InstallPhases = {
   PLANNING: "planning",
+  DOWNLOADING_CLIENT_JAR: "downloading-client-jar",
   DOWNLOADING_LIBRARIES: "downloading-libraries",
+  DOWNLOADING_ASSET_INDEX: "downloading-asset-index",
+  DOWNLOADING_ASSETS: "downloading-assets",
   EXTRACTING_NATIVES: "extracting-natives",
   INSTALLING_RUNTIME: "installing-runtime",
+  INSTALLING_FABRIC: "installing-fabric",
+  INSTALLING_FORGE: "installing-forge",
   RUNNING_FORGE_PROCESSORS: "running-forge-processors",
   WRITING_FILES: "writing-files",
   COMPLETED: "completed"
@@ -1076,6 +1081,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?.({
@@ -1404,7 +1415,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, {
@@ -1527,6 +1539,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(
+      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,
@@ -1591,6 +1720,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;
@@ -1603,50 +1742,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(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++;
-      })
-    )
+  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
       });
@@ -1660,6 +1838,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,
@@ -1675,6 +1854,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(
@@ -1689,9 +1869,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,
@@ -1906,6 +2084,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) => {
@@ -1945,7 +2150,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], {
@@ -2075,8 +2286,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;
@@ -2200,7 +2431,8 @@ async function composeLaunch(input) {
     merged: resolved.merged,
     options,
     placeholderValues,
-    features
+    features,
+    logger: input.logger ?? silentLogger
   });
   return {
     targetId: target.id,
@@ -2382,546 +2614,212 @@ var VerifyFileCategories = {
   RUNTIME_FILE: "runtime-file",
   LOGGING_CONFIG: "logging-config"
 };
+async function sha1OfFile(filePath) {
+  const hash = crypto2.createHash("sha1");
+  await new Promise((resolve, reject) => {
+    const stream = 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: (path16) => map.has(path16),
-    hasNonNative: (path16) => {
-      const cats = map.get(path16);
-      if (!cats) return false;
-      for (const c of cats) {
-        if (c !== VerifyFileCategories.NATIVE) return true;
-      }
-      return false;
-    },
-    categoriesAt: (path16) => map.get(path16) ?? /* @__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;
-    }
-    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
+  const loader = input.target.loader;
+  return runVerification(
+    {
+      targetId: input.target.id,
+      kind: VerificationKinds.FABRIC,
+      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
     },
-    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,
-    durationMs: report.durationMs
-  };
-}
-
-// src/repair/runtime.ts
-async function planRuntimeRepair(input) {
-  return planAspectRepair(
-    input,
-    (action) => action.kind === InstallActionKinds.DOWNLOAD_FILE && action.category === "runtime-file"
-  );
-}
-
-// src/types/runtime.ts
-var RuntimeComponents = {
-  JRE_LEGACY: "jre-legacy"};
-var RuntimePreference = {
-  /** Component declared by the Minecraft manifest. */
-  RECOMMENDED: "recommended",
-  /** Newest component available for the platform. */
-  LATEST: "latest"
-};
-
-// src/targets/index.ts
-var TargetsApi = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  ctx;
-  /** The detected host system used by `resolve()` when no `system` is supplied. */
-  get system() {
-    return this.ctx.system;
-  }
-  /** Build a {@link Target} from already-resolved components. */
-  create(input) {
-    if (!input.id) {
-      throw new MinecraftKitError("INVALID_INPUT", "Target id must be non-empty");
-    }
-    if (!input.directory) {
-      throw new MinecraftKitError("INVALID_INPUT", "Target directory must be non-empty");
-    }
-    if (input.loader.minecraftVersion !== input.minecraft.version) {
-      throw new MinecraftKitError(
-        "INVALID_INPUT",
-        `Loader Minecraft version (${input.loader.minecraftVersion}) does not match resolved Minecraft (${input.minecraft.version})`,
-        {
-          context: {
-            loaderMinecraft: input.loader.minecraftVersion,
-            minecraftVersion: input.minecraft.version
-          }
-        }
+    async (record) => {
+      record(
+        await verifyExistence({
+          path: targetPaths.versionJson(input.target.directory, loader.profile.id),
+          category: VerifyFileCategories.LOADER_LIBRARY
+        })
       );
-    }
-    return {
-      id: input.id,
-      directory: input.directory,
-      minecraft: input.minecraft,
-      loader: input.loader,
-      runtime: input.runtime
-    };
-  }
-  /** Sugar API: resolve every component then assemble a target. */
-  async resolve(input) {
-    const minecraft = await this.ctx.minecraft.resolve({
-      version: input.minecraft.version,
-      ...input.signal !== void 0 ? { signal: input.signal } : {}
-    });
-    const system = input.system ?? this.ctx.system;
-    const componentOverride = input.runtime?.component;
-    const runtimeComponent = componentOverride ?? minecraft.manifest.javaVersion?.component;
-    const resolvedRuntime = await this.ctx.runtime.resolve({
-      system,
-      ...runtimeComponent !== void 0 ? { component: runtimeComponent } : {},
-      preference: input.runtime?.preference ?? RuntimePreference.RECOMMENDED,
-      ...input.signal !== void 0 ? { signal: input.signal } : {}
-    });
-    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 } : {}
+      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 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.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.join(directory, VERSIONS_DIR);
-  const librariesDir = path.join(directory, LIBRARIES_DIR);
-  const assetsDir = path.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.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.join(runtimeDir, component);
-    const javaPath = process.platform === "win32" ? path.join(root, "bin", "javaw.exe") : process.platform === "darwin" ? path.join(root, "jre.bundle", "Contents", "Home", "bin", "java") : path.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.createHash("sha1");
-  await new Promise((resolve, reject) => {
-    const stream = 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) {
+// src/verify/forge.ts
+async function verifyForge(input) {
+  if (input.target.loader.type !== Loaders.FORGE) {
     throw new MinecraftKitError(
       "INVALID_INPUT",
-      `verify.fabric requires a Fabric target (got ${input.target.loader.type})`
+      `verify.forge requires a Forge target (got ${input.target.loader.type})`
     );
   }
-  const loader = input.target.loader;
   return runVerification(
     {
       targetId: input.target.id,
-      kind: VerificationKinds.FABRIC,
+      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: targetPaths.versionJson(input.target.directory, loader.profile.id),
+          path: forgeVersionJsonPath,
           category: VerifyFileCategories.LOADER_LIBRARY
         })
       );
-      const fabricLibraries = planLibraryDownloads({
-        libraries: loader.profile.libraries,
+      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: "fabric-library"
+        category: "forge-library"
       });
-      for (const action of fabricLibraries.downloads) {
+      for (const action of forgeLibraries.downloads) {
         record(
           await verifyHashedFile({
             path: action.target,
@@ -2936,205 +2834,591 @@ async function verifyFabric(input) {
   );
 }
 
-// src/verify/forge.ts
-async function verifyForge(input) {
+// 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
+          });
+        }
+      }
+    }
+  );
+}
+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.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: (path16) => map.has(path16),
+    hasNonNative: (path16) => {
+      const cats = map.get(path16);
+      if (!cats) return false;
+      for (const c of cats) {
+        if (c !== VerifyFileCategories.NATIVE) return true;
+      }
+      return false;
+    },
+    categoriesAt: (path16) => map.get(path16) ?? /* @__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",
-      `verify.forge requires a Forge target (got ${input.target.loader.type})`
+      `repair.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 } : {}
+  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;
     },
-    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
-        })
+    ({ actions, installPlan, issues }) => {
+      if (!issues.has(forgeJsonPath)) return;
+      const alreadyIncluded = new Set(
+        actions.filter((a) => a.kind === InstallActionKinds.DOWNLOAD_FILE).map((a) => a.target)
       );
-      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
-          })
-        );
+      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/verify/minecraft.ts
-async function verifyMinecraft(input) {
-  return runVerification(
-    {
-      targetId: input.target.id,
-      kind: VerificationKinds.MINECRAFT,
-      ...input.onEvent !== void 0 ? { onEvent: input.onEvent } : {}
+// 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
     },
-    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
-        })
+    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,
+    durationMs: report.durationMs
+  };
+}
+
+// src/repair/runtime.ts
+async function planRuntimeRepair(input) {
+  return planAspectRepair(
+    input,
+    (action) => action.kind === InstallActionKinds.DOWNLOAD_FILE && action.category === "runtime-file"
+  );
+}
+
+// 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"};
+var RuntimePreference = {
+  /** Component declared by the Minecraft manifest. */
+  RECOMMENDED: "recommended",
+  /** Newest component available for the platform. */
+  LATEST: "latest"
+};
+
+// src/targets/index.ts
+var TargetsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** The detected host system used by `resolve()` when no `system` is supplied. */
+  get system() {
+    return this.ctx.system;
+  }
+  /** Build a {@link Target} from already-resolved components. */
+  create(input) {
+    if (!input.id) {
+      throw new MinecraftKitError("INVALID_INPUT", "Target id must be non-empty");
+    }
+    if (!input.directory) {
+      throw new MinecraftKitError("INVALID_INPUT", "Target directory must be non-empty");
+    }
+    if (input.loader.minecraftVersion !== input.minecraft.version) {
+      throw new MinecraftKitError(
+        "INVALID_INPUT",
+        `Loader Minecraft version (${input.loader.minecraftVersion}) does not match resolved Minecraft (${input.minecraft.version})`,
+        {
+          context: {
+            loaderMinecraft: input.loader.minecraftVersion,
+            minecraftVersion: input.minecraft.version
+          }
+        }
       );
-      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"
+    }
+    return {
+      id: input.id,
+      directory: input.directory,
+      minecraft: input.minecraft,
+      loader: input.loader,
+      runtime: input.runtime
+    };
+  }
+  /** Sugar API: resolve every component then assemble a target. */
+  async resolve(input) {
+    const minecraft = await this.ctx.minecraft.resolve({
+      version: input.minecraft.version,
+      ...input.signal !== void 0 ? { signal: input.signal } : {}
+    });
+    const system = input.system ?? this.ctx.system;
+    const componentOverride = input.runtime?.component;
+    const runtimeComponent = componentOverride ?? minecraft.manifest.javaVersion?.component;
+    const resolvedRuntime = await this.ctx.runtime.resolve({
+      system,
+      ...runtimeComponent !== void 0 ? { component: runtimeComponent } : {},
+      preference: input.runtime?.preference ?? RuntimePreference.RECOMMENDED,
+      ...input.signal !== void 0 ? { signal: input.signal } : {}
+    });
+    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 } : {}
       });
-      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.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.join(directory, VERSIONS_DIR);
+  const librariesDir = path.join(directory, LIBRARIES_DIR);
+  const assetsDir = path.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.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.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.join(runtimeDir, component);
+    const javaPath = process.platform === "win32" ? path.join(root, "bin", "javaw.exe") : process.platform === "darwin" ? path.join(root, "jre.bundle", "Contents", "Home", "bin", "java") : path.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
@@ -3468,15 +3752,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 {
@@ -3507,7 +3799,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,
@@ -3557,10 +3854,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 } : {},
@@ -5020,5 +5324,5 @@ async function bin() {
 
 // src/cli/index.ts
 void bin();
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map