@gamecrate/cli 0.1.0

package/dist/gamecrate.js

@@ -0,0 +1,4365 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { chown, cp, mkdir as mkdir4, readdir as readdir8, readFile as readFile5, rm as rm2, rmdir, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename7, dirname as dirname5, join as join14 } from "node:path";
+import { setTimeout as sleep4 } from "node:timers/promises";
+
+// src/cli/args.ts
+import { Command, CommanderError, Option } from "commander";
+
+// src/types.ts
+var Exit = {
+  Ok: 0,
+  GameFailed: 1,
+  Usage: 2,
+  Config: 3,
+  Resolution: 4,
+  Environment: 5,
+  MarkerTimeout: 6,
+  Refused: 7,
+  Stale: 8,
+  Interrupted: 130
+};
+
+class GamecrateError extends Error {
+  code;
+  detail;
+  constructor(message, code, detail) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.name = "GamecrateError";
+  }
+}
+var RESERVED_NAMES = [
+  "run",
+  "list",
+  "mods",
+  "doctor",
+  "clean",
+  "clone",
+  "logs",
+  "build",
+  "shell",
+  "config",
+  "fix-perms",
+  "verify",
+  "help",
+  "version",
+  "modless"
+];
+var NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function own(bag, key) {
+  return bag !== undefined && Object.hasOwn(bag, key) ? bag[key] : undefined;
+}
+
+// src/cli/args.ts
+var RUN_FLAGS = [
+  "--mod",
+  "--without",
+  "--only",
+  "--mode",
+  "--marker",
+  "--timeout",
+  "--render-wait",
+  "--resolution",
+  "--network",
+  "--log",
+  "--pull",
+  "--build",
+  "--no-build",
+  "--no-stale-check",
+  "--replace",
+  "--no-replace",
+  "--sort",
+  "--docker-arg",
+  "--dry-run",
+  "--print-plan",
+  "--root",
+  "--worktree",
+  "--no-worktree",
+  "--instance",
+  "--use"
+];
+var SUBCOMMANDS = [
+  {
+    name: "run",
+    summary: "resolve, stage, launch (implied when the first word is a game)",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile", "rest"],
+    flags: RUN_FLAGS
+  },
+  {
+    name: "list",
+    summary: "games, profiles, and each profile's provenance",
+    usage: "[game]",
+    positionals: ["game"],
+    flags: []
+  },
+  {
+    name: "mods",
+    summary: "resolved mod set with source kind and absolute path",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--mod", "--without", "--only", "--sort"]
+  },
+  {
+    name: "doctor",
+    summary: "preflight: docker, CDI, registry auth, game dirs, scan roots, perms",
+    usage: "",
+    positionals: [],
+    flags: []
+  },
+  {
+    name: "clean",
+    summary: "tiered wipe of a profile",
+    usage: "<game> <profile>",
+    positionals: ["game", "profile"],
+    flags: ["--staging", "--logs", "--all", "--yes", "--instance", "--worktree", "--no-worktree"]
+  },
+  {
+    name: "clone",
+    summary: "reflink-copy a profile's precious tier",
+    usage: "<game> <src> <dst>",
+    positionals: ["game", "rest"],
+    flags: ["--yes"]
+  },
+  {
+    name: "logs",
+    summary: "tail or open the last run's captured logs",
+    usage: "<game> <profile>",
+    positionals: ["game", "profile"],
+    flags: ["--instance", "--worktree", "--no-worktree"]
+  },
+  {
+    name: "build",
+    summary: "build or pull the runtime image, no launch",
+    usage: "<game>",
+    positionals: ["game"],
+    flags: ["--pull"]
+  },
+  {
+    name: "shell",
+    summary: "same mounts, bash instead of the game",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: [
+      "--mod",
+      "--without",
+      "--only",
+      "--docker-arg",
+      "--root",
+      "--worktree",
+      "--no-worktree",
+      "--instance",
+      "--use",
+      "--replace",
+      "--log"
+    ]
+  },
+  {
+    name: "verify",
+    summary: "what the running container actually bound, and whether it looks current",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--instance", "--worktree", "--no-worktree"]
+  },
+  {
+    name: "config",
+    summary: "open profiles.json in $EDITOR, validate on save",
+    usage: "edit",
+    positionals: ["rest"],
+    flags: []
+  },
+  {
+    name: "fix-perms",
+    summary: "chown foreign-owned files back to the caller",
+    usage: "<game> [profile]",
+    positionals: ["game", "profile"],
+    flags: ["--yes", "--dry-run"]
+  },
+  {
+    name: "help",
+    summary: "help for a subcommand or a game",
+    usage: "[topic]",
+    positionals: ["rest"],
+    flags: []
+  },
+  {
+    name: "version",
+    summary: "print the version",
+    usage: "",
+    positionals: [],
+    flags: []
+  }
+];
+var GLOBAL_FLAGS = ["--json", "--help"];
+var MODES = ["headed", "headless", "screenshot"];
+var PULL_POLICIES = ["always", "missing", "never"];
+var NETWORK_POLICIES = ["none", "bridge", "host"];
+var BUILD_POLICIES = ["auto", "always", "never"];
+var SORTS = ["topo", "none"];
+var FLAG_ENV = {
+  "--instance": "GAMECRATE_INSTANCE",
+  "--mode": "GAMECRATE_MODE",
+  "--marker": "GAMECRATE_MARKER",
+  "--timeout": "GAMECRATE_TIMEOUT",
+  "--render-wait": "GAMECRATE_RENDER_WAIT",
+  "--network": "GAMECRATE_NETWORK",
+  "--pull": "GAMECRATE_PULL",
+  "--build": "GAMECRATE_BUILD",
+  "--sort": "GAMECRATE_SORT",
+  "--root": "GAMECRATE_ROOT"
+};
+function collect(value, previous) {
+  return [...previous, value];
+}
+function choice(flag, values) {
+  return (raw) => {
+    if (!values.includes(raw)) {
+      throw usage(`${flag} must be one of ${values.join(", ")}, got ${raw}`);
+    }
+    return raw;
+  };
+}
+function enumOption(flags, summary, values) {
+  const long = flags.split(/[ ,]+/).find((token) => token.startsWith("--"));
+  return new Option(flags, summary).choices([...values]).argParser(choice(long, values));
+}
+function buildProgram() {
+  const program = new Command;
+  program.name("gamecrate").exitOverride().helpOption(false).allowExcessArguments(true).showSuggestionAfterError(false).configureOutput({ writeOut: () => {}, writeErr: () => {} }).argument("[args...]").option("--mod <id>", "add a mod to the profile set", collect, []).option("--without <id>", "drop a mod from the resolved set", collect, []).option("--only <id>", "restrict the resolved set to these mods", collect, []).option("--worktree <path>", "promote mods from this git worktree, in its own instance ($GAMECRATE_WORKTREE)", collect, []).option("--use <packageId>=<path>", "force one mod to load from this directory, whatever the profile pins", collect, []).option("--no-worktree", "ignore the current worktree and $GAMECRATE_WORKTREE").option("--instance <name>", "run under a named sub-profile with its own saves, logs and container").addOption(enumOption(`--mode <${MODES.join("|")}>`, "how the game is displayed", MODES)).option("--marker <str>", "exit 0 as soon as this string appears in the log").option("--timeout <seconds>", "kill the container after this long", (v) => seconds("--timeout", v)).option("--render-wait <seconds>", "settle time before a screenshot is taken", (v) => seconds("--render-wait", v)).option("--resolution <width>x<height>", "override the game resolution", parseResolution).addOption(enumOption(`--network <${NETWORK_POLICIES.join("|")}>`, "the container's network mode", NETWORK_POLICIES)).option("--log <path>", "route launch stdout and stderr to one file").addOption(enumOption(`--pull <${PULL_POLICIES.join("|")}>`, "when to pull the runtime image", PULL_POLICIES)).option("--build", "build local C# mods before launching").option("--no-build", "never build, even when an assembly is stale").option("--no-stale-check", "do not warn when a mod's sources are newer than its assemblies").option("--replace", "stop whatever is holding this profile and instance, then launch").option("--no-replace", "refuse when this profile and instance are already running").addOption(enumOption(`--sort <${SORTS.join("|")}>`, "load order: the profile order, or a topological sort", SORTS)).option("--docker-arg <arg>", "one extra argv element for docker run", collect, []).option("--dry-run", "resolve and validate fully, write nothing").option("--print-plan", "print the resolved launch plan instead of launching").option("--json", "machine-readable output").option("--root", "run as root instead of mapping the host uid").option("--staging", "clean: wipe .stage only (the default)").option("--logs", "clean: wipe the captured run logs").option("--all", "clean: wipe the whole profile, saves included (needs --yes)").option("-y, --yes", "skip destructive-action confirmation").option("-h, --help", "this help");
+  return program;
+}
+function checkValueTokens(program, head) {
+  const valued = (name) => program.options.find((o) => (o.long === name || o.short === name) && (o.required || o.optional));
+  for (let i = 0;i < head.length; i++) {
+    const token = head[i];
+    if (!token.startsWith("-") || token === "-")
+      continue;
+    const eq = token.indexOf("=");
+    if (token.startsWith("--") && eq !== -1) {
+      const name = token.slice(0, eq);
+      if (eq === token.length - 1 && valued(name) !== undefined)
+        throw usage(`${name} needs a value`);
+      continue;
+    }
+    const option = valued(token);
+    if (option === undefined)
+      continue;
+    const value = head[++i];
+    if (value === undefined)
+      return;
+    if (option.long === "--docker-arg")
+      continue;
+    if (value.startsWith("-") && value.length > 1) {
+      throw usage(`${option.long ?? token} needs a value, got the flag ${value}`);
+    }
+  }
+}
+function parseArgs(argv, opts = {}) {
+  const env = opts.env ?? process.env;
+  const sep = argv.indexOf("--");
+  const head = sep === -1 ? argv : argv.slice(0, sep);
+  const program = buildProgram();
+  const seen = new Set;
+  const counts = new Map;
+  const worktree = [];
+  let cleanTier;
+  for (const option of program.options) {
+    const long = option.long ?? option.flags;
+    program.on(`option:${option.name()}`, (value) => {
+      seen.add(long);
+      counts.set(long, (counts.get(long) ?? 0) + 1);
+      if (long === "--worktree" && value !== undefined)
+        worktree.push(value);
+      if (long === "--staging" || long === "--logs" || long === "--all") {
+        cleanTier = long.slice(2);
+      }
+    });
+  }
+  checkValueTokens(program, head);
+  try {
+    program.parse(head, { from: "user" });
+  } catch (error) {
+    throw translate(error, program);
+  }
+  for (const option of program.options) {
+    const long = option.long ?? option.flags;
+    const repeatable = Array.isArray(option.defaultValue);
+    if (option.required && !repeatable && (counts.get(long) ?? 0) > 1) {
+      throw usage(`${long} given more than once`);
+    }
+  }
+  if (seen.has("--build") && seen.has("--no-build"))
+    throw usage("--build and --no-build contradict");
+  if (seen.has("--replace") && seen.has("--no-replace"))
+    throw usage("--replace and --no-replace contradict");
+  const values = program.opts();
+  const envBuild = applyEnv(program, seen, env, values);
+  const out = {
+    subcommand: "run",
+    mods: values["mod"],
+    without: values["without"],
+    only: values["only"],
+    dockerArgs: values["dockerArg"],
+    gameArgs: sep === -1 ? [] : argv.slice(sep + 1),
+    dryRun: values["dryRun"] === true,
+    printPlan: values["printPlan"] === true,
+    json: values["json"] === true,
+    root: values["root"] === true,
+    yes: values["yes"] === true,
+    help: values["help"] === true,
+    worktree,
+    noWorktree: seen.has("--no-worktree"),
+    noStaleCheck: seen.has("--no-stale-check"),
+    replace: values["replace"] === true,
+    use: values["use"],
+    rest: []
+  };
+  out.mode = values["mode"];
+  out.marker = values["marker"];
+  out.timeout = values["timeout"];
+  out.renderWait = values["renderWait"];
+  out.resolution = values["resolution"];
+  out.network = values["network"];
+  out.log = values["log"];
+  out.pull = values["pull"];
+  out.sort = values["sort"];
+  out.instance = values["instance"];
+  out.build = envBuild ?? policy(values["build"]);
+  out.cleanTier = cleanTier;
+  if (opts.defaults?.game !== undefined)
+    out.game = opts.defaults.game;
+  if (opts.defaults?.profile !== undefined)
+    out.profile = opts.defaults.profile;
+  applyPositionals(out, program.args, opts.games);
+  if (opts.defaults !== undefined)
+    applyDefaults(out, seen, opts.defaults, sep !== -1);
+  return out;
+}
+function policy(value) {
+  if (value === true)
+    return "always";
+  if (value === false)
+    return "never";
+  return;
+}
+function translate(error, program) {
+  if (!(error instanceof CommanderError))
+    return error;
+  const token = /'([^']+)'/.exec(error.message)?.[1] ?? "";
+  if (error.code === "commander.unknownOption") {
+    const name = token.split("=")[0];
+    const known = program.options.find((o) => o.long === name || o.short === name);
+    if (known !== undefined)
+      return usage(`${name} takes no value`);
+    return usage(`unknown flag ${name}`, suggest(name, flagNames(program)));
+  }
+  if (error.code === "commander.optionMissingArgument") {
+    return usage(`${token.split(" ")[0]} needs a value`);
+  }
+  return new GamecrateError(error.message.replace(/^error: /, ""), Exit.Usage);
+}
+function applyPositionals(out, positional, games) {
+  const first = positional[0];
+  if (first === undefined) {
+    if (out.game !== undefined)
+      return;
+    out.subcommand = "help";
+    out.help = true;
+    return;
+  }
+  const sub = SUBCOMMANDS.find((s) => s.name === first);
+  let slots;
+  let rest;
+  if (sub) {
+    out.subcommand = sub.name;
+    slots = [...sub.positionals];
+    rest = positional.slice(1);
+  } else {
+    const known = !NAME_PATTERN.test(first) ? false : games === undefined || games.includes(first);
+    if (!known) {
+      const candidates = [...SUBCOMMANDS.map((s) => s.name), ...games ?? []];
+      throw usage(`${first} is not a game or a subcommand`, suggest(first, candidates));
+    }
+    out.subcommand = "run";
+    out.game = first;
+    slots = ["profile", "rest"];
+    rest = positional.slice(1);
+  }
+  for (const slot of slots) {
+    if (slot === "rest") {
+      out.rest = rest;
+      rest = [];
+      break;
+    }
+    const value = rest.shift();
+    if (value === undefined)
+      break;
+    if (!NAME_PATTERN.test(value))
+      throw usage(`${value} is not a valid ${slot} name`);
+    if (slot === "game")
+      out.game = value;
+    else
+      out.profile = value;
+  }
+  if (rest.length > 0) {
+    const shape = sub ? `${sub.name} ${sub.usage}`.trim() : `${out.game} [profile]`;
+    throw usage(`unexpected argument ${rest[0]}`, `gamecrate ${shape}`);
+  }
+}
+function applyEnv(program, seen, env, values) {
+  let build;
+  for (const [flag, name] of Object.entries(FLAG_ENV)) {
+    if (seen.has(flag))
+      continue;
+    if (flag === "--build" && seen.has("--no-build"))
+      continue;
+    const raw = env[name];
+    if (raw === undefined || raw === "")
+      continue;
+    seen.add(flag);
+    if (flag === "--build") {
+      if (!BUILD_POLICIES.includes(raw)) {
+        throw usage(`${name} must be one of ${BUILD_POLICIES.join(", ")}, got ${raw}`);
+      }
+      build = raw;
+      continue;
+    }
+    const option = program.options.find((o) => o.long === flag);
+    const key = option.attributeName();
+    if (!option.required) {
+      if (truthy(raw))
+        values[key] = true;
+      continue;
+    }
+    if (option.argChoices && !option.argChoices.includes(raw)) {
+      throw usage(`${name} must be one of ${option.argChoices.join(", ")}, got ${raw}`);
+    }
+    values[key] = option.parseArg === undefined ? raw : option.parseArg(raw, values[key]);
+  }
+  return build;
+}
+function applyDefaults(out, seen, defaults, hasGameArgs) {
+  if (!seen.has("--mod") && defaults.mods !== undefined)
+    out.mods = [...defaults.mods];
+  if (!seen.has("--without") && defaults.without !== undefined)
+    out.without = [...defaults.without];
+  if (!seen.has("--only") && defaults.only !== undefined)
+    out.only = [...defaults.only];
+  if (!seen.has("--docker-arg") && defaults.dockerArgs !== undefined)
+    out.dockerArgs = [...defaults.dockerArgs];
+  if (!seen.has("--worktree") && !seen.has("--no-worktree") && defaults.worktree !== undefined) {
+    out.worktree = [...defaults.worktree];
+  }
+  if (!seen.has("--use") && defaults.use !== undefined)
+    out.use = [...defaults.use];
+  if (!hasGameArgs && defaults.gameArgs !== undefined)
+    out.gameArgs = [...defaults.gameArgs];
+  out.mode ??= defaults.mode;
+  out.marker ??= defaults.marker;
+  out.timeout ??= defaults.timeout;
+  out.renderWait ??= defaults.renderWait;
+  out.resolution ??= defaults.resolution;
+  out.network ??= defaults.network;
+  out.log ??= defaults.log;
+  out.pull ??= defaults.pull;
+  out.build ??= defaults.build;
+  out.sort ??= defaults.sort;
+  out.instance ??= defaults.instance;
+  if (!seen.has("--dry-run"))
+    out.dryRun = defaults.dryRun ?? out.dryRun;
+  if (!seen.has("--print-plan"))
+    out.printPlan = defaults.printPlan ?? out.printPlan;
+  if (!seen.has("--json"))
+    out.json = defaults.json ?? out.json;
+  if (!seen.has("--root"))
+    out.root = defaults.root ?? out.root;
+  if (!seen.has("--no-worktree") && !seen.has("--worktree")) {
+    out.noWorktree = defaults.noWorktree ?? out.noWorktree;
+  }
+  if (!seen.has("--no-stale-check"))
+    out.noStaleCheck = defaults.noStaleCheck ?? out.noStaleCheck;
+  if (!seen.has("--replace") && !seen.has("--no-replace"))
+    out.replace = defaults.replace ?? out.replace;
+}
+function truthy(value) {
+  return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+function flagNames(program) {
+  return program.options.flatMap((o) => [o.long, o.short].filter((f) => f !== undefined));
+}
+function seconds(flag, value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) {
+    throw usage(`${flag} takes a whole number of seconds, got ${value}`);
+  }
+  return n;
+}
+function parseResolution(value) {
+  const match = /^(\d+)x(\d+)$/i.exec(value);
+  const width = Number(match?.[1]);
+  const height = Number(match?.[2]);
+  if (!Number.isSafeInteger(width) || width <= 0 || !Number.isSafeInteger(height) || height <= 0) {
+    throw usage(`--resolution takes positive dimensions like 1920x1080, got ${value}`);
+  }
+  return { width, height };
+}
+function usage(message, suggestion) {
+  return new GamecrateError(message, Exit.Usage, suggestion ? `did you mean ${suggestion}?` : undefined);
+}
+function suggest(word, candidates) {
+  const target = word.toLowerCase();
+  const limit = Math.max(2, Math.floor(target.length / 3));
+  let best;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    const d = distance(target, candidate.toLowerCase());
+    if (d < bestDistance && d <= limit) {
+      best = candidate;
+      bestDistance = d;
+    }
+  }
+  return best;
+}
+function distance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1;i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1;j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row[j] = Math.min(row[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    prev = row;
+  }
+  return prev[b.length];
+}
+
+// src/cli/help.ts
+var NAME = "gamecrate";
+function flags() {
+  return buildProgram().options;
+}
+function renderHelp(topic, config) {
+  if (!topic)
+    return topLevel(config);
+  const sub = SUBCOMMANDS.find((s) => s.name === topic);
+  if (sub)
+    return subcommandHelp(sub);
+  const game = own(config?.games, topic);
+  if (game)
+    return gameHelp(topic, game);
+  const candidates = [...SUBCOMMANDS.map((s) => s.name), ...Object.keys(config?.games ?? {})];
+  const hint = suggest(topic, candidates);
+  throw new GamecrateError(`no help topic ${topic}`, Exit.Usage, hint ? `did you mean ${hint}?` : `topics: ${candidates.join(", ")}`);
+}
+function topLevel(config) {
+  const lines = [
+    `${NAME} — run modded games in containers`,
+    "",
+    "usage:",
+    `  ${NAME} <game> [profile] [flags] [-- game args]`,
+    `  ${NAME} <subcommand> [args] [flags]`,
+    "",
+    "subcommands:"
+  ];
+  const verbs = SUBCOMMANDS.map((s) => [`${s.name} ${s.usage}`.trim(), s.summary]);
+  lines.push(...columns(verbs, 2));
+  lines.push("", "flags:");
+  lines.push(...columns(flags().map(flagRow), 2));
+  const games = Object.entries(config?.games ?? {});
+  if (games.length > 0) {
+    lines.push("", "games:");
+    lines.push(...columns(games.map(([name, game]) => [name, gameSummary(game)]), 2));
+    lines.push("", `${NAME} help <game> lists that game's profiles.`);
+  }
+  lines.push("", "Game args go after a bare --. Env vars are GAMECRATE_ prefixed fallbacks only.");
+  return lines.join(`
+`) + `
+`;
+}
+function subcommandHelp(sub) {
+  const lines = [`usage: ${NAME} ${sub.name} ${sub.usage}`.trimEnd() + " [flags]", "", `  ${sub.summary}`];
+  const names = [...sub.flags, ...GLOBAL_FLAGS];
+  const all = flags();
+  const specs = names.map((name) => all.find((f) => f.long === name)).filter((f) => f !== undefined);
+  if (specs.length > 0) {
+    lines.push("", "flags:");
+    lines.push(...columns(specs.map(flagRow), 2));
+  }
+  if (sub.name === "run") {
+    lines.push("", `  The subcommand slot defaults to run, so \`${NAME} <game> <profile>\` works.`);
+  }
+  return lines.join(`
+`) + `
+`;
+}
+function gameHelp(name, game) {
+  const lines = [`usage: ${NAME} ${name} [profile] [flags] [-- game args]`, "", "profiles:"];
+  const rows = [];
+  for (const [profile, config] of Object.entries(game.profiles)) {
+    const notes = [];
+    if (config.alias)
+      notes.push(`alias for ${config.alias}`);
+    if (config.extends)
+      notes.push(`extends ${config.extends}`);
+    if (config.autoDependencies)
+      notes.push("auto dependencies");
+    const count = config.mods?.length ?? 0;
+    if (!config.alias)
+      notes.push(count === 1 ? "1 entry" : `${count} entries`);
+    if (config.aliases?.length)
+      notes.push(`aka ${config.aliases.join(", ")}`);
+    rows.push([profile, notes.join(", ")]);
+  }
+  if (rows.length === 0)
+    rows.push(["(none declared)", ""]);
+  lines.push(...columns(rows, 2));
+  if (game.aliases && Object.keys(game.aliases).length > 0) {
+    lines.push("", "mod name aliases:");
+    lines.push(...columns(Object.entries(game.aliases).map(([k, v]) => [k, v]), 2));
+  }
+  lines.push("", `modes: ${game.modes.join(", ")}`);
+  lines.push(`core: ${game.core}`);
+  if (game.dlc.length > 0)
+    lines.push(`dlc: ${game.dlc.join(", ")}`);
+  lines.push(`game files: ${game.gameFiles.source === "mount" ? game.gameFiles.host ?? "(unset)" : game.image.ref}`);
+  return lines.join(`
+`) + `
+`;
+}
+function gameSummary(game) {
+  const count = Object.keys(game.profiles).length;
+  return `${count === 1 ? "1 profile" : `${count} profiles`}; modes ${game.modes.join(", ")}`;
+}
+function flagRow(spec) {
+  const notes = [];
+  if (Array.isArray(spec.defaultValue))
+    notes.push("repeatable");
+  const env = FLAG_ENV[spec.long ?? ""];
+  if (env)
+    notes.push(`$${env}`);
+  const summary = spec.description;
+  return [spec.flags, notes.length > 0 ? `${summary} (${notes.join(", ")})` : summary];
+}
+function placeholder(spec) {
+  return spec.flags.split(/[ ,]+/).find((token) => token.startsWith("<")) ?? "";
+}
+function columns(rows, indent) {
+  const width = Math.max(0, ...rows.map((r) => r[0].length));
+  const pad = " ".repeat(indent);
+  return rows.map(([left, right]) => right ? `${pad}${left.padEnd(width)}  ${right}` : `${pad}${left}`);
+}
+function renderCompletion(shell) {
+  const verbs = SUBCOMMANDS.map((s) => s.name).join(" ");
+  const options = flags();
+  const names = options.flatMap((f) => f.short ? [f.long, f.short] : [f.long]).join(" ");
+  const valueFlags = options.filter((f) => f.required).map((f) => f.long);
+  const fn = `_${NAME.replace(/-/g, "_")}`;
+  if (shell === "bash") {
+    const cases = options.filter((f) => f.argChoices).map((f) => `    ${f.long}) COMPREPLY=($(compgen -W "${f.argChoices.join(" ")}" -- "$cur")); return ;;`).join(`
+`);
+    return `${fn}() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  case "$prev" in
+${cases}
+    ${valueFlags.join("|")}) return ;;
+  esac
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=($(compgen -W "${names}" -- "$cur"))
+    return
+  fi
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    local games
+    games=$(${NAME} list --json 2>/dev/null | grep -oE '"[A-Za-z0-9._-]+"' | tr -d '"')
+    COMPREPLY=($(compgen -W "${verbs} $games" -- "$cur"))
+  fi
+}
+complete -F ${fn} ${NAME}
+`;
+  }
+  const zshVerbs = SUBCOMMANDS.map((s) => `    '${s.name}:${s.summary.replace(/'/g, "'\\''")}'`).join(`
+`);
+  const zshFlags = options.map((f) => {
+    const desc = f.description.replace(/'/g, "'\\''").replace(/[[\]:]/g, "");
+    const arg = placeholder(f);
+    const value = arg ? `:${arg.replace(/[<>]/g, "")}:${f.argChoices ? `(${f.argChoices.join(" ")})` : "_files"}` : "";
+    const repeat = Array.isArray(f.defaultValue) ? "*" : "";
+    return `    '${repeat}${f.long}[${desc}]${value}'`;
+  }).join(`
+`);
+  return `#compdef ${NAME}
+
+${fn}() {
+  local -a verbs
+  verbs=(
+${zshVerbs}
+  )
+  _arguments -s \\
+${zshFlags} \\
+    '1: :{_describe verb verbs}' \\
+    '*:: :->rest'
+}
+
+${fn} "$@"
+`;
+}
+
+// src/cli/output.ts
+import { closeSync, existsSync as existsSync2, lstatSync, mkdirSync, openSync, readdirSync, rmSync, symlinkSync, unlinkSync, writeSync } from "node:fs";
+import { basename as basename2, join as join3, resolve } from "node:path";
+
+// src/docker/spec.ts
+import { existsSync, realpathSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { basename, join } from "node:path";
+var CONTAINER_RUNTIME_DIR = "/tmp/xdg";
+var CONTAINER_LOG_DIR = "/logs";
+var X11_SOCKET_DIR = "/tmp/.X11-unix";
+var CONTAINER_XAUTHORITY = "/tmp/xauth";
+var CONTAINER_XDG_DIR = "/xdg";
+var RUNTIME_DIR_SIZE = "64m";
+var HOME_SIZE = "64m";
+var MASK_SIZE = "1m";
+function buildRunSpec(plan, modMounts, identity) {
+  const { gameConfig: game, settings } = plan;
+  const headed = plan.mode === "headed";
+  const mounts = [];
+  const env = {
+    HOME: identity.home,
+    USER: identity.user,
+    LOGNAME: identity.user
+  };
+  if (game.gameFiles.source === "mount") {
+    if (!game.gameFiles.host) {
+      throw new GamecrateError(`gameFiles.source is "mount" but no host path is set for ${plan.game}`, Exit.Config);
+    }
+    mounts.push({ type: "bind", source: hostPath(game.gameFiles.host), target: game.gameFiles.container, readonly: true });
+  }
+  mounts.push({ type: "bind", source: hostPath(plan.stageDirHost), target: game.modsDir.container, readonly: true });
+  for (const mount of modMounts) {
+    mounts.push(mount.type === "bind" ? { ...mount, readonly: true } : mount);
+  }
+  mounts.push({ type: "bind", source: hostPath(plan.dataDirHost), target: game.dataDir.container });
+  const command = headed ? [game.executable] : [
+    "xvfb-run",
+    "-a",
+    `--server-args=-screen 0 ${settings.width}x${settings.height}x24`,
+    game.executable
+  ];
+  if (game.dataDir.mode === "arg") {
+    command.push(validateDataDirArg(game.dataDir));
+  } else {
+    Object.assign(env, game.dataDir.env);
+  }
+  if (game.logFile.mode === "arg") {
+    mounts.push({ type: "bind", source: hostPath(plan.runDirHost), target: CONTAINER_LOG_DIR });
+    command.push(game.logFile.arg, `${CONTAINER_LOG_DIR}/Player.log`);
+  }
+  for (const target of game.modsDir.mask ?? []) {
+    mounts.push({ type: "tmpfs", target, size: MASK_SIZE, uid: identity.uid, gid: identity.gid, mode: "755" });
+  }
+  if (identity.uid !== 0) {
+    mounts.push({ type: "tmpfs", target: identity.home, size: HOME_SIZE, uid: identity.uid, gid: identity.gid, mode: "700" });
+  }
+  mounts.push({
+    type: "tmpfs",
+    target: CONTAINER_RUNTIME_DIR,
+    size: RUNTIME_DIR_SIZE,
+    uid: identity.uid,
+    gid: identity.gid,
+    mode: "700"
+  });
+  env.XDG_RUNTIME_DIR = CONTAINER_RUNTIME_DIR;
+  mounts.push({ type: "bind", source: hostPath(plan.configDirHost), target: CONTAINER_XDG_DIR });
+  env.XDG_CONFIG_HOME = `${CONTAINER_XDG_DIR}/config`;
+  env.XDG_CACHE_HOME = `${CONTAINER_XDG_DIR}/cache`;
+  env.XDG_DATA_HOME ??= `${CONTAINER_XDG_DIR}/data`;
+  if (headed) {
+    if (settings.display === "x11") {
+      const x11 = x11Session();
+      if (x11) {
+        mounts.push({ type: "bind", source: X11_SOCKET_DIR, target: X11_SOCKET_DIR });
+        env.DISPLAY = x11.display;
+        env.XDG_SESSION_TYPE = "x11";
+        env.SDL_VIDEODRIVER = "x11";
+        env.QT_QPA_PLATFORM = "xcb";
+        if (x11.xauthority) {
+          mounts.push({ type: "bind", source: x11.xauthority, target: CONTAINER_XAUTHORITY, readonly: true });
+          env.XAUTHORITY = CONTAINER_XAUTHORITY;
+        }
+      }
+    } else {
+      const wayland = waylandSocket();
+      if (wayland) {
+        const target = `${CONTAINER_RUNTIME_DIR}/${wayland.name}`;
+        mounts.push({ type: "bind", source: wayland.source, target });
+        env.WAYLAND_DISPLAY = wayland.name;
+        env.XDG_SESSION_TYPE = "wayland";
+        env.SDL_VIDEODRIVER = "wayland";
+        env.QT_QPA_PLATFORM = "wayland";
+      }
+    }
+    if (settings.audio) {
+      for (const socket of audioSockets()) {
+        mounts.push({ type: "bind", source: socket.source, target: `${CONTAINER_RUNTIME_DIR}/${socket.name}` });
+      }
+      env.PULSE_SERVER = `unix:${CONTAINER_RUNTIME_DIR}/pulse/native`;
+    }
+  }
+  const deviceCgroupRules = [];
+  if (settings.input) {
+    mounts.push({ type: "bind", source: "/dev/input", target: "/dev/input", readonly: true });
+    deviceCgroupRules.push("c 13:* rmw");
+  }
+  const devices = [];
+  if (settings.gpu)
+    devices.push("nvidia.com/gpu=all");
+  Object.assign(env, glEnv(settings.gpu));
+  command.push(...settings.gameArgs ?? []);
+  return {
+    image: game.image.ref,
+    name: containerName(plan),
+    labels: {
+      "gamecrate.game": plan.game,
+      "gamecrate.profile": plan.profile,
+      ...plan.instance === undefined ? {} : { "gamecrate.instance": plan.instance }
+    },
+    identity,
+    env,
+    mounts,
+    devices,
+    deviceCgroupRules,
+    network: settings.network,
+    memory: settings.memory,
+    memorySwap: settings.memory,
+    cpus: settings.cpus,
+    pidsLimit: settings.pidsLimit,
+    ulimits: ["core=0"],
+    workdir: game.gameFiles.container,
+    ...headed && settings.display === "x11" ? { hostname: hostname() } : {},
+    command,
+    extraArgs: [...settings.dockerArgs ?? []]
+  };
+}
+function containerName(plan) {
+  const base = `gamecrate-${plan.game}-${plan.profile}`;
+  return plan.instance === undefined ? base : `${base}-${plan.instance}`;
+}
+function windowTitle(plan) {
+  const base = `${plan.game} ${plan.profile}`;
+  return plan.instance === undefined ? base : `${base} / ${plan.instance}`;
+}
+function toDockerArgs(spec) {
+  const args = ["run", "--rm", "--init", "--name", spec.name];
+  if (spec.hostname !== undefined)
+    args.push("--hostname", spec.hostname);
+  for (const [key, value] of Object.entries(spec.labels))
+    args.push("--label", `${key}=${value}`);
+  args.push("--user", `${spec.identity.uid}:${spec.identity.gid}`);
+  for (const [key, value] of Object.entries(spec.env))
+    args.push("--env", `${key}=${value}`);
+  for (const mount of spec.mounts)
+    args.push(...mountArgs(mount));
+  for (const device of spec.devices)
+    args.push("--device", device);
+  for (const rule of spec.deviceCgroupRules)
+    args.push("--device-cgroup-rule", rule);
+  for (const ulimit of spec.ulimits)
+    args.push("--ulimit", ulimit);
+  args.push("--network", spec.network);
+  args.push("--memory", spec.memory);
+  args.push("--memory-swap", spec.memorySwap);
+  args.push("--cpus", String(spec.cpus));
+  args.push("--pids-limit", String(spec.pidsLimit));
+  args.push("--workdir", spec.workdir);
+  args.push(...spec.extraArgs);
+  args.push("--pull=never");
+  const [entrypoint, ...rest] = spec.command;
+  if (entrypoint !== undefined)
+    args.push("--entrypoint", entrypoint);
+  args.push(spec.image, ...rest);
+  return args;
+}
+function mountArgs(mount) {
+  if (mount.type === "tmpfs") {
+    const opts = ["rw"];
+    if (mount.uid !== undefined)
+      opts.push(`uid=${mount.uid}`);
+    if (mount.gid !== undefined)
+      opts.push(`gid=${mount.gid}`);
+    if (mount.mode)
+      opts.push(`mode=${mount.mode}`);
+    opts.push(`size=${mount.size ?? RUNTIME_DIR_SIZE}`);
+    return ["--tmpfs", `${mount.target}:${opts.join(",")}`];
+  }
+  if (!mount.source) {
+    throw new GamecrateError(`bind mount at ${mount.target} has no source`, Exit.Config);
+  }
+  const fields = [`type=bind`, `src=${mount.source}`, `dst=${mount.target}`];
+  if (mount.readonly)
+    fields.push("readonly");
+  return ["--mount", fields.map(csvField).join(",")];
+}
+function csvField(field) {
+  if (!field.includes(",") && !field.includes('"'))
+    return field;
+  return `"${field.replaceAll('"', '""')}"`;
+}
+function validateDataDirArg(dataDir) {
+  if (dataDir.container.includes("=")) {
+    throw new GamecrateError(`container data path contains "=": ${dataDir.container}`, Exit.Config, "RimWorld silently ignores -savedatafolder when the argv element does not split into exactly two parts, and the save is lost with --rm.");
+  }
+  const parts = dataDir.arg.split("=");
+  if (parts.length !== 2) {
+    throw new GamecrateError(`dataDir.arg must contain exactly one "=": ${dataDir.arg}`, Exit.Config);
+  }
+  if (trimSlash(parts[1] ?? "") !== trimSlash(dataDir.container)) {
+    throw new GamecrateError(`dataDir.arg points at ${parts[1]} but the mount target is ${dataDir.container}`, Exit.Config, "The engine would write to a path that is not the mounted data directory.");
+  }
+  return dataDir.arg;
+}
+function trimSlash(path) {
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+function glEnv(gpu) {
+  if (!gpu)
+    return { LIBGL_ALWAYS_SOFTWARE: "1", GALLIUM_DRIVER: "llvmpipe" };
+  const env = { LIBGL_ALWAYS_SOFTWARE: "0", GALLIUM_DRIVER: "" };
+  if (hasNvidia()) {
+    env.__GLX_VENDOR_LIBRARY_NAME = "nvidia";
+    env.__NV_PRIME_RENDER_OFFLOAD = "1";
+  }
+  return env;
+}
+function hasNvidia() {
+  return existsSync("/dev/nvidiactl") || existsSync("/etc/cdi/nvidia.yaml") || existsSync("/usr/share/vulkan/icd.d/nvidia_icd.json");
+}
+function x11Session() {
+  const display = process.env.DISPLAY;
+  if (!display)
+    return null;
+  const cookie = process.env.XAUTHORITY ?? join(homedir(), ".Xauthority");
+  return { display, xauthority: existsSync(cookie) ? cookie : null };
+}
+function waylandSocket() {
+  const display = process.env.WAYLAND_DISPLAY;
+  const runtime = process.env.XDG_RUNTIME_DIR;
+  if (!display)
+    return null;
+  const source = display.startsWith("/") ? display : runtime ? join(runtime, display) : null;
+  if (!source || !existsSync(source))
+    return null;
+  return { source, name: basename(source) };
+}
+function audioSockets() {
+  const runtime = process.env.XDG_RUNTIME_DIR;
+  if (!runtime)
+    return [];
+  const found = [];
+  for (const name of ["pipewire-0", "pulse/native"]) {
+    const source = join(runtime, name);
+    if (existsSync(source))
+      found.push({ source, name });
+  }
+  return found;
+}
+function hostPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+// src/mods/staleness.ts
+import { readdir, stat } from "node:fs/promises";
+import { join as join2, relative } from "node:path";
+var SKIP_DIRS = new Set([".git", ".retired", ".vs", "bin", "node_modules", "obj"]);
+var ENTRY_LIMIT = 20000;
+async function scanBuildTimes(dir) {
+  const times = { sourceTimes: [] };
+  let budget = ENTRY_LIMIT;
+  const walk = async (current, inAssemblies) => {
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (budget-- <= 0)
+        return;
+      const path = join2(current, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name.toLowerCase()))
+          continue;
+        await walk(path, inAssemblies || entry.name === "Assemblies");
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const lower = entry.name.toLowerCase();
+      const isSource = lower.endsWith(".cs");
+      const isAssembly = inAssemblies && lower.endsWith(".dll");
+      if (!isSource && !isAssembly)
+        continue;
+      let mtimeMs;
+      try {
+        mtimeMs = (await stat(path)).mtimeMs;
+      } catch {
+        continue;
+      }
+      const found = { path: relative(dir, path), mtimeMs };
+      if (isSource) {
+        times.sourceTimes.push(mtimeMs);
+        if (mtimeMs > (times.newestSource?.mtimeMs ?? -1))
+          times.newestSource = found;
+      } else if (mtimeMs > (times.newestAssembly?.mtimeMs ?? -1)) {
+        times.newestAssembly = found;
+      }
+    }
+  };
+  await walk(dir, false);
+  return times;
+}
+function decideStale(times) {
+  const { newestSource, newestAssembly } = times;
+  if (newestSource === undefined)
+    return false;
+  return newestAssembly === undefined || newestSource.mtimeMs > newestAssembly.mtimeMs;
+}
+function staleReport(times) {
+  const { newestSource, newestAssembly } = times;
+  if (newestSource === undefined || newestAssembly === undefined)
+    return null;
+  if (newestSource.mtimeMs <= newestAssembly.mtimeMs)
+    return null;
+  return {
+    newestSource: newestSource.path,
+    newestSourceMs: newestSource.mtimeMs,
+    assembly: newestAssembly.path,
+    assemblyMs: newestAssembly.mtimeMs,
+    newerCount: times.sourceTimes.filter((t) => t > newestAssembly.mtimeMs).length
+  };
+}
+var INDENT = " ".repeat("warning: ".length);
+function staleWarning(packageId, report, now = Date.now()) {
+  const files = report.newerCount === 1 ? "1 source file" : `${report.newerCount} source files`;
+  return [
+    `${packageId} has ${files} newer than ${report.assembly}`,
+    `${INDENT}newest: ${report.newestSource} (${ago(report.newestSourceMs, now)})`,
+    `${INDENT}you are probably running a stale build`
+  ].join(`
+`);
+}
+function duration(ms) {
+  const seconds2 = Math.max(0, Math.round(ms / 1000));
+  if (seconds2 < 60)
+    return `${seconds2}s`;
+  if (seconds2 < 3600)
+    return `${Math.floor(seconds2 / 60)}m`;
+  if (seconds2 < 86400)
+    return `${Math.floor(seconds2 / 3600)}h`;
+  return `${Math.floor(seconds2 / 86400)}d`;
+}
+function ago(mtimeMs, now = Date.now()) {
+  return `${duration(now - mtimeMs)} ago`;
+}
+
+// src/cli/output.ts
+function status(message) {
+  process.stderr.write(line(message));
+}
+function warn(message) {
+  process.stderr.write(line(`warning: ${message}`));
+}
+function redirectOutput(path) {
+  const fd = openSync(path, "w");
+  const stdout = process.stdout.write;
+  const stderr = process.stderr.write;
+  let open = true;
+  const write = (chunk, encodingOrCallback, callback) => {
+    append(fd, chunk);
+    const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    done?.();
+    return true;
+  };
+  process.stdout.write = write;
+  process.stderr.write = write;
+  return {
+    close() {
+      if (!open)
+        return;
+      open = false;
+      process.stdout.write = stdout;
+      process.stderr.write = stderr;
+      closeSync(fd);
+    }
+  };
+}
+async function forwardOutput(stream, target) {
+  for await (const chunk of stream)
+    target.write(chunk);
+}
+function line(message) {
+  return message.endsWith(`
+`) ? message : `${message}
+`;
+}
+function reportProblems(problems) {
+  if (problems.length === 0) {
+    process.stderr.write(line("resolution failed with no reported detail"));
+    process.exit(Exit.Resolution);
+  }
+  const groups = new Map;
+  for (const problem of problems) {
+    const group = groups.get(problem.where);
+    if (group)
+      group.push(problem);
+    else
+      groups.set(problem.where, [problem]);
+  }
+  const out = [`${problems.length} problem${problems.length === 1 ? "" : "s"}:`];
+  for (const [where, group] of groups) {
+    out.push(`  ${where}`);
+    for (const problem of group) {
+      out.push(`    ${problem.message}`);
+      if (problem.suggestion)
+        out.push(`      did you mean ${problem.suggestion}?`);
+    }
+  }
+  process.stderr.write(`${out.join(`
+`)}
+`);
+  process.exit(Exit.Resolution);
+}
+function planWarnings(plan) {
+  if (!plan.warnOnStale)
+    return plan.warnings;
+  const stale = plan.mods.filter((mod) => mod.staleReport !== undefined).map((mod) => staleWarning(mod.packageId, mod.staleReport));
+  return [...plan.warnings, ...stale];
+}
+function planPayload(plan) {
+  return {
+    game: plan.game,
+    profile: plan.profile,
+    ...plan.instance === undefined ? {} : { instance: plan.instance },
+    mode: plan.mode,
+    ...plan.marker === undefined ? {} : { marker: plan.marker },
+    timeoutSeconds: plan.timeoutSeconds,
+    renderWaitSeconds: plan.renderWaitSeconds,
+    profileDir: resolve(plan.profileDir),
+    instanceDir: resolve(plan.instanceDir),
+    containerName: containerName(plan),
+    dataDirHost: resolve(plan.dataDirHost),
+    stageDirHost: resolve(plan.stageDirHost),
+    logsDirHost: resolve(plan.logsDirHost),
+    mods: plan.mods.map((mod) => ({
+      packageId: mod.packageId,
+      kind: mod.kind,
+      hostDir: resolve(mod.hostDir),
+      containerDir: mod.containerDir,
+      origin: mod.explicit ? "explicit" : "auto",
+      stale: mod.stale === true,
+      ...mod.staleReport === undefined ? {} : { staleReport: mod.staleReport },
+      ...mod.workshopId === undefined ? {} : { workshopId: mod.workshopId }
+    })),
+    warnings: planWarnings(plan)
+  };
+}
+function printPlan(plan, asJson) {
+  const payload = planPayload(plan);
+  if (asJson) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return;
+  }
+  const title = payload.instance === undefined ? `${payload.game} ${payload.profile} (${payload.mode})` : `${payload.game} ${payload.profile} / ${payload.instance} (${payload.mode})`;
+  const out = [
+    title,
+    `  profile   ${payload.profileDir}`,
+    `  instance  ${payload.instanceDir}`,
+    `  container ${payload.containerName}`,
+    `  data      ${payload.dataDirHost}`,
+    `  stage     ${payload.stageDirHost}`,
+    `  logs      ${payload.logsDirHost}`
+  ];
+  if (payload.marker !== undefined)
+    out.push(`  marker    ${payload.marker}`);
+  out.push(`  timeout   ${payload.timeoutSeconds}s, render wait ${payload.renderWaitSeconds}s`);
+  out.push(`  mods      ${payload.mods.length}`);
+  const width = Math.max(0, ...payload.mods.map((m) => m.packageId.length));
+  for (const mod of payload.mods) {
+    const notes = [mod.kind, mod.origin];
+    if (mod.stale)
+      notes.push("stale");
+    out.push(`    ${mod.packageId.padEnd(width)}  ${notes.join(" ")}  ${mod.hostDir} -> ${mod.containerDir}`);
+  }
+  for (const warning of payload.warnings)
+    out.push(`  warning: ${warning}`);
+  process.stdout.write(`${out.join(`
+`)}
+`);
+}
+function runTimestamp(now = new Date) {
+  return now.toISOString().replace(/[-:.]/g, "");
+}
+function openRunLog(logsDir, now) {
+  const runsDir = join3(logsDir, "runs");
+  mkdirSync(runsDir, { recursive: true });
+  const dir = uniqueRunDir(runsDir, runTimestamp(now));
+  mkdirSync(dir);
+  linkCurrent(logsDir, dir);
+  rotateRuns(logsDir, 10);
+  return dir;
+}
+var encoder = new TextEncoder;
+function append(fd, chunk) {
+  writeSync(fd, typeof chunk === "string" ? encoder.encode(chunk) : chunk);
+}
+function uniqueRunDir(runsDir, stamp) {
+  let candidate = join3(runsDir, stamp);
+  for (let n = 2;existsSync2(candidate); n++)
+    candidate = join3(runsDir, `${stamp}-${n}`);
+  return candidate;
+}
+function linkCurrent(logsDir, target) {
+  const link = join3(logsDir, "current");
+  try {
+    lstatSync(link);
+    unlinkSync(link);
+  } catch {}
+  symlinkSync(join3("runs", basename2(target)), link, "dir");
+}
+function rotateRuns(logsDir, keep) {
+  const runsDir = join3(logsDir, "runs");
+  if (keep < 1 || !existsSync2(runsDir))
+    return [];
+  const dirs = readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+  const removed = dirs.slice(keep);
+  for (const name of removed)
+    rmSync(join3(runsDir, name), { recursive: true, force: true });
+  return removed;
+}
+
+// src/config/load.ts
+import { parse as parseYaml } from "yaml";
+import { z as z2 } from "zod";
+import { access, readdir as readdir2, readFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join5, resolve as resolve3 } from "node:path";
+
+// src/plugin.ts
+import { readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join as join4, resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { exports as exportsField, legacy } from "resolve.exports";
+var PLUGIN_API_VERSION = 1;
+var REQUIRED_FUNCTIONS = [
+  "parseManifest",
+  "renderModsConfig",
+  "mergePrefs",
+  "parseVersion"
+];
+function fail(spec, message, detail) {
+  throw new GamecrateError(`plugin "${spec}": ${message}`, Exit.Config, detail);
+}
+function entryOf(dir) {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(join4(dir, "package.json"), "utf8"));
+  } catch {
+    return resolve2(dir, "index.js");
+  }
+  let entry;
+  try {
+    entry = exportsField(manifest, ".", { conditions: ["bun"] })?.[0];
+  } catch {}
+  entry ??= legacy(manifest, { fields: ["module", "main"] });
+  return resolve2(dir, entry ?? "index.js");
+}
+function packageDir(spec, from) {
+  let dir = resolve2(from);
+  for (;; ) {
+    const candidate = join4(dir, "node_modules", spec);
+    if (statSync(join4(candidate, "package.json"), { throwIfNoEntry: false })?.isFile())
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function locate(spec, from) {
+  const expanded = expandHome(spec);
+  let target;
+  if (expanded.startsWith(".") || isAbsolute(expanded)) {
+    target = resolve2(from, expanded);
+  } else {
+    target = packageDir(expanded, from);
+    if (target === null) {
+      fail(spec, `cannot be resolved from ${from}`, "install it, or give a path starting with ./");
+    }
+  }
+  return statSync(target, { throwIfNoEntry: false })?.isDirectory() ? entryOf(target) : target;
+}
+function check(spec, value) {
+  if (typeof value !== "object" || value === null)
+    fail(spec, "has no default export");
+  const plugin = value;
+  if (plugin.apiVersion !== PLUGIN_API_VERSION) {
+    fail(spec, `speaks apiVersion ${String(plugin.apiVersion)}, this build speaks ${PLUGIN_API_VERSION}`);
+  }
+  if (typeof plugin.game !== "string" || plugin.game === "")
+    fail(spec, "declares no game name");
+  const missing = REQUIRED_FUNCTIONS.filter((name) => typeof plugin[name] !== "function");
+  if (missing.length > 0)
+    fail(spec, `is missing ${missing.join(", ")}`);
+  if (typeof plugin.defaults !== "object" || plugin.defaults === null) {
+    fail(spec, "declares no defaults object");
+  }
+  if (typeof plugin.windowedPrefs !== "object" || plugin.windowedPrefs === null) {
+    fail(spec, "declares no windowedPrefs object");
+  }
+  return plugin;
+}
+async function loadPlugins(specs, configFile) {
+  const from = dirname(configFile);
+  const out = new Map;
+  for (const spec of specs) {
+    const target = locate(spec, from);
+    let module;
+    try {
+      module = await import(pathToFileURL(target).href);
+    } catch (error) {
+      fail(spec, `failed to load ${target}`, error instanceof Error ? error.message : String(error));
+    }
+    const plugin = check(spec, module.default);
+    if (out.has(plugin.game))
+      fail(spec, `also claims the game "${plugin.game}"`);
+    out.set(plugin.game, plugin);
+  }
+  return out;
+}
+function requirePlugin(plugins, game) {
+  const plugin = plugins.get(game);
+  if (plugin === undefined) {
+    throw new GamecrateError(`no plugin provides the game "${game}"`, Exit.Config, `loaded plugins: ${[...plugins.keys()].join(", ") || "(none)"}`);
+  }
+  return plugin;
+}
+
+// src/config/builtin.ts
+var DEFAULT_DATA_ROOT = "~/.local/share/gamecrate";
+var DEFAULT_SETTINGS = {
+  width: 1920,
+  height: 1080,
+  devMode: true,
+  runInBackground: true,
+  resetModsConfigOnCrash: false,
+  gpu: true,
+  audio: true,
+  input: false,
+  network: "bridge",
+  display: "x11",
+  memory: "8g",
+  cpus: 6,
+  pidsLimit: 1024
+};
+
+// src/config/jsonc.ts
+import { parse, printParseErrorCode } from "jsonc-parser";
+function parseJsonc(text) {
+  const errors = [];
+  const value = parse(text, errors, { allowTrailingComma: true, allowEmptyContent: false });
+  const first = errors[0];
+  if (first !== undefined) {
+    throw new GamecrateError("config is not valid JSON", Exit.Config, `${printParseErrorCode(first.error)} at offset ${first.offset}`);
+  }
+  return value;
+}
+
+// src/config/validate.ts
+import { z } from "zod";
+var MODES2 = ["headed", "headless", "screenshot"];
+var HINTS = "\x00gamecrate/hints:";
+function obj(shape) {
+  const known = Object.keys(shape);
+  return z.strictObject(shape, {
+    error: (issue) => issue.code === "unrecognized_keys" ? HINTS + JSON.stringify(issue.keys.map((key) => suggest(key, known) ?? null)) : "expected an object"
+  });
+}
+function hintsFor(message) {
+  if (!message.startsWith(HINTS))
+    return [];
+  return JSON.parse(message.slice(HINTS.length));
+}
+function requiredWhen(key, when) {
+  return (ctx) => {
+    if (!when(ctx.value) || ctx.value[key] !== undefined)
+      return;
+    ctx.issues.push({ code: "custom", message: `missing required key "${key}"`, path: [key], input: ctx.value });
+  };
+}
+var str = z.string({ error: "expected a string" });
+var num = z.number({ error: "expected a number" });
+var bool = z.boolean({ error: "expected a boolean" });
+var strArray = z.array(z.string({ error: "expected an array of strings" }), {
+  error: "expected an array of strings"
+});
+var strMap = z.record(z.string(), z.string({ error: "expected an object of string values" }), {
+  error: "expected an object of string values"
+});
+function oneOf(values) {
+  return z.enum(values, { error: `expected one of ${values.join(", ")}` });
+}
+var modeName = z.unknown().check((ctx) => {
+  const value = ctx.value;
+  if (typeof value === "string" && MODES2.includes(value))
+    return;
+  const hint = typeof value === "string" ? suggest(value, MODES2) : undefined;
+  ctx.issues.push({
+    code: "custom",
+    message: `expected one of ${MODES2.join(", ")}`,
+    input: value,
+    ...hint === undefined ? {} : { params: { suggestion: `did you mean "${hint}"?` } }
+  });
+});
+var settings = obj({
+  width: num.optional(),
+  height: num.optional(),
+  devMode: bool.optional(),
+  runInBackground: bool.optional(),
+  resetModsConfigOnCrash: bool.optional(),
+  gpu: bool.optional(),
+  audio: bool.optional(),
+  input: bool.optional(),
+  network: oneOf(["none", "bridge", "host"]).optional(),
+  display: oneOf(["x11", "wayland"]).optional(),
+  memory: str.optional(),
+  cpus: num.optional(),
+  pidsLimit: num.optional(),
+  prefsExtra: strMap.optional(),
+  gameArgs: strArray.optional(),
+  dockerArgs: strArray.optional()
+});
+var dynamicModEntry = obj({
+  match: str,
+  first: strArray.optional(),
+  sort: oneOf(["alpha", "none"]).optional(),
+  minMatches: num.optional()
+});
+var objectModEntry = obj({
+  id: str,
+  workshop: num.optional(),
+  path: str.optional(),
+  optional: bool.optional()
+});
+var modEntry = z.unknown().check((ctx) => {
+  const value = ctx.value;
+  if (typeof value === "string") {
+    if (value.trim() === "")
+      ctx.issues.push({ code: "custom", message: "mod entry is empty", input: value });
+    return;
+  }
+  if (!isObj(value)) {
+    ctx.issues.push({ code: "custom", message: "expected a packageId string or an object", input: value });
+    return;
+  }
+  const schema = value["match"] !== undefined ? dynamicModEntry : objectModEntry;
+  const result = schema.safeParse(value);
+  if (result.success)
+    return;
+  for (const issue of result.error.issues)
+    ctx.issues.push({ ...issue, input: value });
+});
+var profile = obj({
+  mods: z.array(modEntry, { error: "expected an array" }).optional(),
+  extends: str.optional(),
+  exclude: strArray.optional(),
+  includeBase: bool.optional(),
+  autoDependencies: bool.optional(),
+  settings: settings.optional(),
+  instances: z.record(z.string(), obj({ worktree: str.optional(), settings: settings.optional() }), {
+    error: "expected an object"
+  }).optional(),
+  alias: str.optional(),
+  aliases: strArray.optional()
+}).check((ctx) => {
+  const v = ctx.value;
+  if (v.alias !== undefined && (v.extends !== undefined || v.mods !== undefined)) {
+    ctx.issues.push({
+      code: "custom",
+      message: 'an alias profile cannot also declare "mods" or "extends"',
+      input: v
+    });
+  }
+});
+var game = obj({
+  gameFiles: obj({ source: oneOf(["mount", "image"]), host: str.optional(), container: str }).check(requiredWhen("host", (v) => v["source"] === "mount")),
+  dataDir: obj({
+    container: str,
+    mode: oneOf(["arg", "env"]),
+    arg: str.optional(),
+    env: strMap.optional()
+  }).check(requiredWhen("arg", (v) => v["mode"] === "arg"), requiredWhen("env", (v) => v["mode"] === "env")),
+  modsDir: obj({ container: str, mask: strArray.optional() }),
+  logFile: obj({ mode: oneOf(["arg", "copy-out"]), arg: str.optional(), from: str.optional() }).check(requiredWhen("arg", (v) => v["mode"] === "arg"), requiredWhen("from", (v) => v["mode"] === "copy-out")),
+  image: obj({ ref: str, acquire: oneOf(["pull", "build"]), context: str.optional() }).check(requiredWhen("context", (v) => v["acquire"] === "build")),
+  executable: str,
+  steamAppId: num,
+  workshopRoot: z.union([z.string(), z.null()], { error: "expected a string or null" }),
+  scanRoots: z.array(obj({ path: str, maxDepth: num, exclude: strArray.optional() }), {
+    error: "expected an array"
+  }),
+  manifest: obj({ file: str }),
+  modsConfig: obj({ file: str }),
+  prefs: obj({ file: str }),
+  saveExtensions: strArray,
+  core: str,
+  dlc: strArray,
+  preCore: strArray.optional(),
+  base: strArray.optional(),
+  library: z.record(z.string(), obj({ workshop: num.optional(), path: str.optional() }).check((ctx) => {
+    if (ctx.value["workshop"] === undefined && ctx.value["path"] === undefined) {
+      ctx.issues.push({
+        code: "custom",
+        message: 'library entry needs a "workshop" id or a "path"',
+        input: ctx.value
+      });
+    }
+  }), { error: "expected an object" }).optional(),
+  modes: z.array(modeName, { error: "expected a non-empty array" }).min(1, {
+    error: "expected a non-empty array"
+  }),
+  aliases: strMap.optional(),
+  settings: settings.optional(),
+  ignoresWmDelete: bool.optional(),
+  profiles: z.record(z.string(), profile, { error: "expected an object" })
+});
+var root = obj({
+  plugins: strArray.optional(),
+  dataRoot: str,
+  defaults: obj({ settings: settings.optional() }).optional(),
+  games: z.unknown()
+});
+function validateConfig(cfg) {
+  const problems = [];
+  if (!isObj(cfg)) {
+    problems.push({ where: "", message: "expected the config to be an object" });
+    return { config: { dataRoot: "", games: {} }, problems };
+  }
+  collect2(problems, "", root, cfg);
+  const games = cfg["games"];
+  if (!isObj(games)) {
+    problems.push({ where: "/games", message: 'missing required key "games", or it is not an object' });
+    return { config: cfg, problems };
+  }
+  for (const [name, entry] of Object.entries(games)) {
+    collect2(problems, `/games/${esc(name)}`, game, entry);
+  }
+  crossReference(problems, games);
+  return { config: cfg, problems };
+}
+function collect2(problems, prefix, schema, value) {
+  const result = schema.safeParse(value);
+  if (result.success)
+    return;
+  for (const issue of result.error.issues) {
+    if (issue.code === "unrecognized_keys") {
+      const hints = hintsFor(issue.message);
+      issue.keys.forEach((key2, i) => {
+        const problem2 = {
+          where: `${prefix}${pointer(issue.path)}/${esc(key2)}`,
+          message: `unknown key "${key2}"`
+        };
+        const hint2 = hints[i];
+        if (hint2 != null)
+          problem2.suggestion = `did you mean "${hint2}"?`;
+        problems.push(problem2);
+      });
+      continue;
+    }
+    const key = issue.path.at(-1);
+    const missing = typeof key === "string" && valueAt(value, issue.path) === undefined;
+    const problem = {
+      where: `${prefix}${pointer(issue.path)}`,
+      message: missing ? `missing required key "${key}"` : issue.message
+    };
+    const hint = issue.params?.suggestion;
+    if (hint !== undefined)
+      problem.suggestion = hint;
+    problems.push(problem);
+  }
+}
+function pointer(path) {
+  return path.map((segment) => `/${esc(String(segment))}`).join("");
+}
+function valueAt(root_, path) {
+  let current = root_;
+  for (const segment of path) {
+    if (current === null || typeof current !== "object")
+      return;
+    current = own(current, String(segment));
+  }
+  return current;
+}
+function crossReference(p, games) {
+  for (const [gameName, game_] of Object.entries(games)) {
+    const where = `/games/${esc(gameName)}`;
+    checkName(p, where, gameName, "game");
+    if (!isObj(game_))
+      continue;
+    const profiles = game_["profiles"];
+    if (!isObj(profiles))
+      continue;
+    const names = Object.keys(profiles);
+    for (const [name, prof] of Object.entries(profiles)) {
+      const w = `${where}/profiles/${esc(name)}`;
+      checkName(p, w, name, "profile");
+      if (!isObj(prof))
+        continue;
+      const parent = prof["extends"];
+      if (typeof parent === "string" && !Object.hasOwn(profiles, parent)) {
+        const prob = { where: `${w}/extends`, message: `extends unknown profile "${parent}"` };
+        const hint = suggest(parent, names);
+        if (hint)
+          prob.suggestion = `did you mean "${hint}"?`;
+        p.push(prob);
+      }
+      const alias = prof["alias"];
+      if (typeof alias === "string" && alias !== "modless" && !Object.hasOwn(profiles, alias)) {
+        const prob = { where: `${w}/alias`, message: `alias of unknown profile "${alias}"` };
+        const hint = suggest(alias, [...names, "modless"]);
+        if (hint)
+          prob.suggestion = `did you mean "${hint}"?`;
+        p.push(prob);
+      }
+      if (typeof alias === "string" && alias === name) {
+        p.push({ where: `${w}/alias`, message: "a profile cannot alias itself" });
+      }
+      const aliases = prof["aliases"];
+      if (Array.isArray(aliases)) {
+        for (const [i, entry] of aliases.entries()) {
+          if (typeof entry !== "string")
+            continue;
+          const at = `${w}/aliases/${i}`;
+          checkName(p, at, entry, "profile alias");
+          if (names.some((k) => k.toLowerCase() === entry.toLowerCase())) {
+            p.push({ where: at, message: `alias "${entry}" is already a profile name` });
+          }
+        }
+      }
+      const instances = prof["instances"];
+      if (isObj(instances)) {
+        for (const instance of Object.keys(instances)) {
+          checkName(p, `${w}/instances/${esc(instance)}`, instance, "instance");
+        }
+      }
+    }
+  }
+}
+function checkName(p, where, name, kind) {
+  if (RESERVED_NAMES.includes(name)) {
+    p.push({ where, message: `"${name}" is a reserved name and cannot be used as a ${kind} name` });
+    return;
+  }
+  if (!NAME_PATTERN.test(name)) {
+    p.push({ where, message: `${kind} name "${name}" must match ${NAME_PATTERN.source}` });
+  }
+}
+function esc(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function isObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/config/load.ts
+function defaultConfigPath() {
+  const base = process.env["XDG_CONFIG_HOME"] ?? join5(homedir2(), ".config");
+  return join5(base, "gamecrate", "profiles.json");
+}
+var PROJECT_CONFIG = ".gamecrate.yml";
+var projectName = z2.custom((v) => typeof v === "string" && NAME_PATTERN.test(v), "expected a name");
+var projectStr = z2.string({ error: "expected a string" });
+var projectBool = z2.boolean({ error: "expected true or false" });
+var projectList = z2.custom((v) => Array.isArray(v) && v.every((entry) => typeof entry === "string"), "expected an array of strings");
+var projectSeconds = z2.custom((v) => Number.isSafeInteger(v) && v >= 0, "expected a whole number of seconds");
+function oneOf2(values) {
+  return z2.enum(values, { error: `expected one of ${values.join(", ")}` });
+}
+var BUILD_POLICIES2 = ["auto", "always", "never"];
+var projectResolution = z2.string({ error: "expected dimensions like 1920x1080" }).check((ctx) => {
+  try {
+    parseResolution(ctx.value);
+  } catch (error) {
+    ctx.issues.push({ code: "custom", message: error.message, input: ctx.value });
+  }
+}).transform(parseResolution);
+var PROJECT_SCHEMA = z2.strictObject({
+  game: projectName.optional(),
+  profile: projectName.optional(),
+  mods: projectList.optional(),
+  without: projectList.optional(),
+  only: projectList.optional(),
+  dockerArgs: projectList.optional(),
+  gameArgs: projectList.optional(),
+  worktree: projectList.optional(),
+  use: projectList.optional(),
+  marker: projectStr.optional(),
+  instance: projectStr.optional(),
+  log: projectStr.optional(),
+  timeout: projectSeconds.optional(),
+  renderWait: projectSeconds.optional(),
+  dryRun: projectBool.optional(),
+  printPlan: projectBool.optional(),
+  json: projectBool.optional(),
+  root: projectBool.optional(),
+  noWorktree: projectBool.optional(),
+  noStaleCheck: projectBool.optional(),
+  replace: projectBool.optional(),
+  mode: oneOf2(["headed", "headless", "screenshot"]).optional(),
+  pull: oneOf2(["always", "missing", "never"]).optional(),
+  sort: oneOf2(["topo", "none"]).optional(),
+  network: oneOf2(["none", "bridge", "host"]).optional(),
+  build: z2.union([z2.boolean().transform((on) => on ? "always" : "never"), z2.enum(BUILD_POLICIES2)], {
+    error: `expected one of ${BUILD_POLICIES2.join(", ")}`
+  }).optional(),
+  resolution: projectResolution.optional()
+}, { error: "expected an object" });
+async function findProjectConfig(start = process.cwd()) {
+  let dir = resolve3(start);
+  for (;; ) {
+    const file = join5(dir, PROJECT_CONFIG);
+    try {
+      await access(file);
+      return file;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir)
+      return;
+    dir = parent;
+  }
+}
+async function loadProjectDefaults(start = process.cwd()) {
+  const file = await findProjectConfig(start);
+  if (file === undefined)
+    return {};
+  let raw;
+  try {
+    raw = parseYaml(await readFile(file, "utf8"));
+  } catch (error) {
+    throw new GamecrateError(`project config is invalid: ${file}`, Exit.Config, error.message);
+  }
+  return validateProjectDefaults(raw, file);
+}
+function validateProjectDefaults(raw, file) {
+  if (raw === null)
+    return {};
+  const result = PROJECT_SCHEMA.safeParse(raw);
+  if (result.success)
+    return result.data;
+  const problems = [];
+  for (const issue of result.error.issues) {
+    if (issue.code === "unrecognized_keys") {
+      for (const key of issue.keys)
+        problems.push(`  /${key}: unknown key`);
+      continue;
+    }
+    problems.push(`  /${issue.path.join("/")}: ${issue.message}`);
+  }
+  throw new GamecrateError(`project config is invalid: ${file}`, Exit.Config, problems.join(`
+`));
+}
+async function loadConfig(path) {
+  const file = path ?? defaultConfigPath();
+  let user;
+  try {
+    user = parseJsonc(await readFile(file, "utf8"));
+  } catch (err) {
+    if (err instanceof GamecrateError) {
+      throw new GamecrateError(`${err.message}: ${file}`, err.code, err.detail);
+    }
+    if (err.code !== "ENOENT")
+      throw err;
+  }
+  const specs = isObj(user) && user["plugins"] !== undefined ? user["plugins"] : [];
+  if (!Array.isArray(specs) || specs.some((s) => typeof s !== "string")) {
+    throw new GamecrateError(`config is invalid: ${file}`, Exit.Config, "  /plugins: expected an array of strings");
+  }
+  const plugins = await loadPlugins(specs, file);
+  const base = {
+    dataRoot: DEFAULT_DATA_ROOT,
+    defaults: { settings: structuredClone(DEFAULT_SETTINGS) },
+    games: Object.fromEntries([...plugins].map(([name, plugin]) => [name, structuredClone(plugin.defaults)]))
+  };
+  const { config, problems } = validateConfig(user === undefined ? base : deepMerge(base, user));
+  if (problems.length > 0) {
+    const detail = problems.map((p) => {
+      const hint = p.suggestion ? ` (${p.suggestion})` : "";
+      return `  ${p.where || "/"}: ${p.message}${hint}${origin(p.where, user, plugins)}`;
+    }).join(`
+`);
+    const merged = plugins.size === 0 ? "" : ` (merged with defaults from: ${[...plugins.keys()].join(", ")})`;
+    throw new GamecrateError(`config is invalid: ${file}${merged}`, Exit.Config, detail);
+  }
+  return { config: expandPaths(config), plugins };
+}
+function origin(where, user, plugins) {
+  if (!where.startsWith("/"))
+    return "";
+  const segments = where.slice(1).split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+  if (valueAt2(user, segments) !== undefined)
+    return "";
+  const [section, name, ...rest] = segments;
+  const plugin = section === "games" && name !== undefined ? plugins.get(name) : undefined;
+  if (plugin === undefined)
+    return "  <- not in this file";
+  return valueAt2(plugin.defaults, rest) === undefined ? `  <- not in this file, and the ${name} plugin's defaults do not supply it` : `  <- from the ${name} plugin's defaults, not this file`;
+}
+function valueAt2(value, segments) {
+  let current = value;
+  for (const segment of segments) {
+    if (Array.isArray(current))
+      current = current[Number(segment)];
+    else if (isObj(current))
+      current = own(current, segment);
+    else
+      return;
+  }
+  return current;
+}
+function resolveSettings(root2, game2, profile2, ...overrides) {
+  let out = structuredClone(DEFAULT_SETTINGS);
+  for (const layer of [root2.defaults?.settings, game2.settings, profile2.settings, ...overrides]) {
+    if (layer)
+      out = deepMerge(out, layer, true);
+  }
+  return out;
+}
+function resolveProfile(game2, name) {
+  return resolveNamed(game2, name, []);
+}
+function resolveNamed(game2, name, seen) {
+  if (name.toLowerCase() === "modless")
+    return { mods: [], exclude: [], includeBase: false };
+  const key = profileKey(game2, name);
+  if (key === undefined) {
+    throw new GamecrateError(`unknown profile "${name}"`, Exit.Resolution, `known profiles: ${Object.keys(game2.profiles).join(", ") || "(none)"}, modless`);
+  }
+  if (seen.includes(key)) {
+    throw new GamecrateError(`profile "${key}" inherits from itself`, Exit.Config, [...seen, key].join(" -> "));
+  }
+  const self = own(game2.profiles, key);
+  if (self.alias !== undefined)
+    return resolveNamed(game2, self.alias, [...seen, key]);
+  const parent = self.extends !== undefined ? resolveNamed(game2, self.extends, [...seen, key]) : {};
+  const exclude = [...parent.exclude ?? [], ...self.exclude ?? []];
+  const out = {
+    mods: subtract([...parent.mods ?? [], ...self.mods ?? []], exclude),
+    exclude,
+    settings: deepMerge(parent.settings ?? {}, self.settings ?? {}, true)
+  };
+  const instances = deepMerge(parent.instances ?? {}, self.instances ?? {}, true);
+  if (Object.keys(instances).length > 0)
+    out.instances = instances;
+  const includeBase = self.includeBase ?? parent.includeBase;
+  if (includeBase !== undefined)
+    out.includeBase = includeBase;
+  const auto = self.autoDependencies ?? parent.autoDependencies;
+  if (auto !== undefined)
+    out.autoDependencies = auto;
+  return out;
+}
+function canonicalProfile(game2, name) {
+  if (name.toLowerCase() === "modless")
+    return "modless";
+  const seen = [];
+  let current = name;
+  for (;; ) {
+    const key = profileKey(game2, current);
+    if (key === undefined || seen.includes(key))
+      return key ?? current;
+    const next = own(game2.profiles, key)?.alias;
+    if (next === undefined)
+      return key;
+    seen.push(key);
+    current = next;
+  }
+}
+function profileDataDir(root2, game2, profile2) {
+  return resolve3(expandHome(root2.dataRoot), game2, canonicalProfile(own(root2.games, game2), profile2));
+}
+async function profileDirs(root2, game2, profile2) {
+  if (profile2 !== undefined)
+    return [profileDataDir(root2, game2, profile2)];
+  const dir = join5(expandHome(root2.dataRoot), game2);
+  return (await readdir2(dir).catch(() => [])).map((name) => join5(dir, name));
+}
+function profileKey(game2, name) {
+  if (Object.hasOwn(game2.profiles, name))
+    return name;
+  const lower = name.toLowerCase();
+  const direct = Object.keys(game2.profiles).find((k) => k.toLowerCase() === lower);
+  if (direct !== undefined)
+    return direct;
+  return Object.keys(game2.profiles).find((k) => (own(game2.profiles, k)?.aliases ?? []).some((a) => a.toLowerCase() === lower));
+}
+function subtract(mods, exclude) {
+  if (exclude.length === 0)
+    return mods;
+  const patterns = exclude.map(globToRegExp);
+  return mods.filter((entry) => {
+    const ids = entryIds(entry);
+    if (ids.length === 0)
+      return true;
+    return !ids.some((id) => patterns.some((re) => re.test(id)));
+  });
+}
+function entryIds(entry) {
+  if (typeof entry === "string")
+    return [entry, entry.replace(/^(workshop|path):/, "")];
+  if ("id" in entry)
+    return [entry.id];
+  return [];
+}
+function globToRegExp(pattern) {
+  const body = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${body}$`, "i");
+}
+function deepMerge(base, over, concatArrays = false) {
+  if (Array.isArray(base) && Array.isArray(over)) {
+    return concatArrays ? [...base, ...over] : [...over];
+  }
+  if (isObj(base) && isObj(over)) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(over)) {
+      if (v === undefined)
+        continue;
+      out[k] = Object.hasOwn(out, k) ? deepMerge(out[k], v, concatArrays) : v;
+    }
+    return out;
+  }
+  return over;
+}
+function expandPaths(config) {
+  config.dataRoot = expandHome(config.dataRoot);
+  for (const game2 of Object.values(config.games)) {
+    if (game2.gameFiles.host !== undefined)
+      game2.gameFiles.host = expandHome(game2.gameFiles.host);
+    if (game2.image.context !== undefined)
+      game2.image.context = expandHome(game2.image.context);
+    if (game2.workshopRoot !== null)
+      game2.workshopRoot = expandHome(game2.workshopRoot);
+    for (const root2 of game2.scanRoots)
+      root2.path = expandHome(root2.path);
+    for (const entry of Object.values(game2.library ?? {})) {
+      if (entry.path !== undefined)
+        entry.path = expandHome(entry.path);
+    }
+  }
+  return config;
+}
+function expandHome(p) {
+  if (p === "~")
+    return homedir2();
+  return p.startsWith("~/") ? join5(homedir2(), p.slice(2)) : p;
+}
+
+// src/docker/identity.ts
+import { userInfo } from "node:os";
+function resolveIdentity(useRoot) {
+  if (useRoot)
+    return { uid: 0, gid: 0, home: "/root", user: "root" };
+  const uid = process.getuid?.() ?? 0;
+  const gid = process.getgid?.() ?? 0;
+  return { uid, gid, home: "/tmp/home", user: hostUserName(uid) };
+}
+function hostUserName(uid) {
+  try {
+    const name = userInfo().username;
+    if (name)
+      return name;
+  } catch {}
+  return process.env.USER ?? process.env.LOGNAME ?? `uid-${uid}`;
+}
+
+// src/docker/preflight.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename3, join as join7 } from "node:path";
+
+// src/docker/run.ts
+import { spawn } from "node:child_process";
+import { createWriteStream, mkdirSync as mkdirSync2 } from "node:fs";
+import { open, readdir as readdir3, stat as stat2 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { TextDecoder } from "node:util";
+function spawnArgv(argv, stdio) {
+  return spawn(argv[0], argv.slice(1), { stdio });
+}
+function exited(proc) {
+  return new Promise((resolve4, reject) => {
+    proc.once("error", reject);
+    proc.once("close", (code) => resolve4(code ?? 1));
+  });
+}
+async function collect3(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function capture(argv) {
+  try {
+    const proc = spawnArgv(argv, ["ignore", "pipe", "pipe"]);
+    const [stdout, stderr, code] = await Promise.all([
+      collect3(proc.stdout),
+      collect3(proc.stderr),
+      exited(proc)
+    ]);
+    return { code, stdout, stderr };
+  } catch (error) {
+    return { code: 127, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
+  }
+}
+var STDOUT_LOG = "stdout.log";
+var MARKER_POLL_MS = 200;
+async function runContainer(spec, opts) {
+  const stopTimeout = opts.stopTimeoutSeconds ?? 10;
+  mkdirSync2(opts.logDir, { recursive: true });
+  const sink = createWriteStream(join6(opts.logDir, STDOUT_LOG));
+  const proc = spawnArgv(["docker", ...toDockerArgs(spec)], ["inherit", "pipe", "pipe"]);
+  let interrupted = false;
+  const onSignal = () => {
+    if (interrupted)
+      return;
+    interrupted = true;
+    stopContainer(spec.name, stopTimeout);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const code = exited(proc);
+  try {
+    await Promise.all([
+      tee(proc.stdout, sink, process.stdout),
+      tee(proc.stderr, sink, process.stderr)
+    ]);
+    const status2 = await code;
+    return interrupted ? Exit.Interrupted : status2;
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    await new Promise((resolve4) => sink.end(resolve4));
+  }
+}
+async function stopContainer(name, timeoutSeconds) {
+  const proc = spawnArgv(["docker", "stop", "--timeout", String(timeoutSeconds), name], "ignore");
+  await exited(proc).catch(() => {});
+}
+async function waitForMarker(sources, marker, timeoutSeconds) {
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  const carry = Math.max(marker.length - 1, 0);
+  const seen = new Map;
+  const startedAt = Date.now();
+  while (true) {
+    for (const path of await expandSources(sources)) {
+      let state = seen.get(path);
+      if (state === undefined) {
+        state = { offset: await staleSize(path, startedAt), tail: "", decoder: new TextDecoder };
+        seen.set(path, state);
+      }
+      if (await scan(path, state, marker, carry))
+        return true;
+    }
+    if (Date.now() >= deadline)
+      return false;
+    await sleep(Math.min(MARKER_POLL_MS, Math.max(deadline - Date.now(), 0)));
+  }
+}
+async function staleSize(path, startedAt) {
+  return stat2(path).then((info) => info.mtimeMs < startedAt ? info.size : 0, () => 0);
+}
+async function scan(path, state, marker, carry) {
+  const handle = await open(path, "r").catch(() => null);
+  if (handle === null)
+    return false;
+  try {
+    const { size } = await handle.stat();
+    if (size < state.offset) {
+      state.offset = 0;
+      state.tail = "";
+      state.decoder = new TextDecoder;
+    }
+    if (size <= state.offset)
+      return false;
+    const buffer = Buffer.alloc(size - state.offset);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, state.offset);
+    state.offset += bytesRead;
+    const text = state.tail + state.decoder.decode(buffer.subarray(0, bytesRead), { stream: true });
+    if (text.includes(marker))
+      return true;
+    state.tail = carry > 0 ? text.slice(-carry) : "";
+    return false;
+  } catch {
+    return false;
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+async function expandSources(sources) {
+  const out = [];
+  for (const source of sources) {
+    const info = await stat2(source).catch(() => null);
+    if (info === null) {
+      out.push(source);
+      continue;
+    }
+    if (!info.isDirectory()) {
+      out.push(source);
+      continue;
+    }
+    const entries = await readdir3(source).catch(() => []);
+    for (const entry of entries) {
+      if (entry.toLowerCase().endsWith(".log"))
+        out.push(join6(source, entry));
+    }
+  }
+  return out;
+}
+async function tee(stream, sink, mirror) {
+  for await (const chunk of stream) {
+    mirror.write(chunk);
+    sink.write(chunk);
+  }
+}
+
+// src/docker/preflight.ts
+var CDI_SPEC = "/etc/cdi/nvidia.yaml";
+async function preflight(plan) {
+  const problems = [];
+  const game2 = plan.gameConfig;
+  const dockerOk = await checkDocker(problems);
+  if (dockerOk) {
+    await checkImage(plan, problems);
+  }
+  if (plan.settings.gpu)
+    checkCdi(problems);
+  checkGameDir(plan, problems);
+  checkBindSources(plan, problems);
+  if (plan.mode === "headed")
+    checkDisplay(plan, problems);
+  if (game2.gameFiles.source === "image" && game2.image.acquire === "build" && !game2.image.context) {
+    problems.push({
+      where: `/games/${plan.game}/image/context`,
+      message: 'image.acquire is "build" but no build context is configured'
+    });
+  }
+  return problems;
+}
+async function checkDocker(problems) {
+  const result = await capture(["docker", "version", "--format", "{{.Server.Version}}"]);
+  if (result.code === 0)
+    return true;
+  problems.push({
+    where: "docker",
+    message: `docker is not reachable: ${firstLine(result.stderr) || `exit ${result.code}`}`,
+    suggestion: "start the docker daemon, or check that your user is in the docker group"
+  });
+  return false;
+}
+async function checkImageRunnable(ref, where, game2, problems) {
+  const run = await capture(["docker", "run", "--rm", "--entrypoint", "/bin/true", ref]);
+  if (run.code === 0)
+    return;
+  const err = firstLine(run.stderr);
+  const corrupt = /content store|failed to extract layer|not found/i.test(run.stderr);
+  problems.push({
+    where,
+    message: corrupt ? `image ${ref} is present but unrunnable; its layers are missing from the content store` : `image ${ref} is present but failed to start: ${err || `exit ${run.code}`}`,
+    suggestion: corrupt ? `docker image rm ${ref} && docker builder prune -f, then gamecrate build ${game2}` : undefined
+  });
+}
+async function checkImage(plan, problems) {
+  const image = plan.gameConfig.image;
+  const where = `/games/${plan.game}/image/ref`;
+  const present = await capture(["docker", "image", "inspect", image.ref]);
+  if (present.code === 0) {
+    await checkImageRunnable(image.ref, where, plan.game, problems);
+    return;
+  }
+  if (image.acquire === "build") {
+    problems.push({
+      where,
+      message: `image ${image.ref} is not present locally`,
+      suggestion: `gamecrate build ${plan.game}`
+    });
+    return;
+  }
+  const remote = await capture(["docker", "manifest", "inspect", image.ref]);
+  if (remote.code === 0)
+    return;
+  const host = registryHost(image.ref);
+  if (host && needsLogin(remote.stderr) && !hasStoredAuth(host)) {
+    problems.push({
+      where,
+      message: `not authenticated to ${host}, so ${image.ref} cannot be pulled`,
+      suggestion: `docker login ${host}`
+    });
+    return;
+  }
+  problems.push({
+    where,
+    message: `image ${image.ref} is not present locally and cannot be pulled: ${firstLine(remote.stderr) || `exit ${remote.code}`}`,
+    suggestion: host ? `docker login ${host}` : undefined
+  });
+}
+function checkDisplay(plan, problems) {
+  if (plan.settings.display === "x11") {
+    if (x11Session())
+      return;
+    problems.push({
+      where: "DISPLAY",
+      message: "DISPLAY is not set; a headed X11 launch would open nothing",
+      suggestion: 'set settings.display to "wayland", or use --mode headless'
+    });
+    return;
+  }
+  if (waylandSocket())
+    return;
+  problems.push({
+    where: "WAYLAND_DISPLAY",
+    message: "no wayland socket found; a headed launch would open a blank window",
+    suggestion: "run from a wayland session, or use --mode headless"
+  });
+}
+function checkCdi(problems) {
+  if (!existsSync3(CDI_SPEC)) {
+    problems.push({
+      where: CDI_SPEC,
+      message: "no CDI spec, so --device nvidia.com/gpu=all cannot resolve",
+      suggestion: "sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml"
+    });
+    return;
+  }
+  let text = "";
+  try {
+    text = readFileSync2(CDI_SPEC, "utf8");
+  } catch (error) {
+    problems.push({ where: CDI_SPEC, message: `CDI spec is unreadable: ${message(error)}` });
+    return;
+  }
+  if (!/^\s*-?\s*name:\s*["']?all["']?\s*$/m.test(text)) {
+    problems.push({
+      where: CDI_SPEC,
+      message: 'CDI spec does not declare a device named "all"',
+      suggestion: "sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml"
+    });
+  }
+}
+function checkGameDir(plan, problems) {
+  const files = plan.gameConfig.gameFiles;
+  if (files.source !== "mount")
+    return;
+  const where = `/games/${plan.game}/gameFiles/host`;
+  if (!files.host) {
+    problems.push({ where, message: 'gameFiles.source is "mount" but no host path is set' });
+    return;
+  }
+  if (!existsSync3(files.host)) {
+    problems.push({ where, message: `game directory does not exist: ${files.host}` });
+    return;
+  }
+  const executable = join7(files.host, basename3(plan.gameConfig.executable));
+  if (!existsSync3(executable)) {
+    problems.push({
+      where,
+      message: `${files.host} does not contain ${basename3(plan.gameConfig.executable)}`,
+      suggestion: "point gameFiles.host at the install directory, not its parent"
+    });
+  }
+}
+function checkBindSources(plan, problems) {
+  let mounts;
+  try {
+    mounts = buildRunSpec(plan, [], resolveIdentity(false)).mounts;
+  } catch (error) {
+    problems.push({
+      where: `/games/${plan.game}`,
+      message: error instanceof GamecrateError ? error.message : message(error),
+      suggestion: error instanceof GamecrateError ? error.detail : undefined
+    });
+    return;
+  }
+  for (const mount of mounts) {
+    if (mount.type !== "bind" || !mount.source)
+      continue;
+    if (existsSync3(mount.source))
+      continue;
+    if (mount.source.startsWith(plan.profileDir))
+      continue;
+    problems.push({
+      where: mount.source,
+      message: `bind source does not exist and would be mounted at ${mount.target}`
+    });
+  }
+}
+function registryHost(ref) {
+  const first = ref.split("/")[0];
+  if (!first || !ref.includes("/"))
+    return null;
+  if (first === "localhost" || first.includes(".") || first.includes(":"))
+    return first;
+  return null;
+}
+function needsLogin(stderr) {
+  return /unauthorized|authentication required|denied|forbidden/i.test(stderr);
+}
+function hasStoredAuth(host) {
+  const path = join7(process.env.DOCKER_CONFIG ?? join7(homedir3(), ".docker"), "config.json");
+  try {
+    const config = JSON.parse(readFileSync2(path, "utf8"));
+    if (config.credsStore || config.credHelpers?.[host])
+      return true;
+    return Object.keys(config.auths ?? {}).some((key) => key === host || key.includes(`//${host}`));
+  } catch {
+    return false;
+  }
+}
+function firstLine(text) {
+  return text.trim().split(`
+`)[0]?.trim() ?? "";
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/docker/window.ts
+import { basename as basename4 } from "node:path";
+import { setTimeout as sleep2 } from "node:timers/promises";
+var WAIT_MS = 180000;
+var POLL_MS = 500;
+async function toplevels() {
+  const { code, stdout } = await capture(["wmctrl", "-lx"]);
+  if (code === 127)
+    return null;
+  const found = [];
+  for (const line2 of stdout.split(`
+`)) {
+    const [id, , wmClass] = line2.trim().split(/\s+/);
+    if (id !== undefined && wmClass !== undefined)
+      found.push({ id, wmClass });
+  }
+  return found;
+}
+async function adoptNewWindow(opts) {
+  const before = await toplevels();
+  if (before === null) {
+    warn("wmctrl is not installed, so the window keeps the game's own title");
+    return { stop: () => {} };
+  }
+  const seen = new Set(before.map((w) => w.id));
+  const wanted = basename4(opts.executable).toLowerCase();
+  let stopped = false;
+  (async () => {
+    const deadline = Date.now() + WAIT_MS;
+    while (!stopped && Date.now() < deadline) {
+      await sleep2(POLL_MS);
+      if (stopped)
+        return;
+      const now = await toplevels() ?? [];
+      const match = now.find((w) => !seen.has(w.id) && w.wmClass.toLowerCase().includes(wanted));
+      if (match === undefined)
+        continue;
+      await capture(["wmctrl", "-i", "-r", match.id, "-N", opts.title]);
+      await adopt(match.id, opts);
+      if (opts.stripDelete)
+        await watchForClose(match.id, () => stopped, opts.onClosed);
+      return;
+    }
+  })();
+  return { stop: () => void (stopped = true) };
+}
+async function watchForClose(id, stopped, onClosed) {
+  let misses = 0;
+  while (!stopped()) {
+    await sleep2(POLL_MS);
+    if (stopped())
+      return;
+    const now = await toplevels();
+    if (now === null)
+      return;
+    misses = now.some((w) => w.id === id) ? 0 : misses + 1;
+    if (misses >= 2) {
+      onClosed();
+      return;
+    }
+  }
+}
+async function adopt(id, opts) {
+  const protocols = await capture(["xprop", "-id", id, "WM_PROTOCOLS"]);
+  if (protocols.code === 127) {
+    warn("xprop is not installed, so nothing out here can fix the window's close button");
+    return;
+  }
+  await claimPid(id);
+  if (opts.stripDelete)
+    await dropDeleteProtocol(id, parseAtoms(protocols.stdout));
+}
+async function claimPid(id) {
+  const pid = String(process.pid);
+  await capture(["xprop", "-id", id, "-f", "_NET_WM_PID", "32c", "-set", "_NET_WM_PID", pid]);
+}
+async function dropDeleteProtocol(id, atoms) {
+  if (!atoms.includes("WM_DELETE_WINDOW"))
+    return;
+  const kept = atoms.filter((atom) => atom !== "WM_DELETE_WINDOW");
+  if (kept.length === 0) {
+    await capture(["xprop", "-id", id, "-remove", "WM_PROTOCOLS"]);
+    return;
+  }
+  const format = `32${"a".repeat(kept.length)}`;
+  await capture([
+    "xprop",
+    "-id",
+    id,
+    "-f",
+    "WM_PROTOCOLS",
+    format,
+    "-set",
+    "WM_PROTOCOLS",
+    kept.join(", ")
+  ]);
+}
+function parseAtoms(stdout) {
+  const list = stdout.slice(stdout.indexOf(":") + 1).replace(/^\s*protocols\s*/, "");
+  return list.split(",").map((atom) => atom.trim()).filter((atom) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(atom));
+}
+
+// src/launch/generate.ts
+import { mkdir, readdir as readdir4, readFile as readFile2, writeFile } from "node:fs/promises";
+import { dirname as dirname3, join as join8 } from "node:path";
+async function readInstallVersion(game2, plugin) {
+  const host = game2.gameFiles.host;
+  if (game2.gameFiles.source !== "mount" || host === undefined)
+    return null;
+  let raw;
+  try {
+    raw = await readFile2(join8(expandHome(host), "Version.txt"), "utf8");
+  } catch {
+    return null;
+  }
+  return plugin.parseVersion(raw.replace(/^/, "").trim());
+}
+async function readKnownExpansions(game2, plugin, warnings) {
+  if (game2.dlc.length === 0)
+    return [];
+  const host = game2.gameFiles.host;
+  if (game2.gameFiles.source !== "mount" || host === undefined)
+    return [...game2.dlc];
+  const dataDir = join8(expandHome(host), "Data");
+  let entries;
+  try {
+    entries = await readdir4(dataDir, { withFileTypes: true });
+  } catch {
+    warnings.push(`could not read ${dataDir}; falling back to the configured dlc list`);
+    return [...game2.dlc];
+  }
+  const found = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    let id = null;
+    try {
+      id = plugin.parseManifest(await readFile2(join8(dataDir, entry.name, game2.manifest.file), "utf8"))?.packageId ?? null;
+    } catch {
+      continue;
+    }
+    if (id !== null && id.toLowerCase() !== game2.core.toLowerCase())
+      found.push(id);
+  }
+  const order = game2.dlc.map((id) => id.toLowerCase());
+  return found.sort((a, b) => {
+    const ai = order.indexOf(a.toLowerCase());
+    const bi = order.indexOf(b.toLowerCase());
+    return (ai === -1 ? order.length : ai) - (bi === -1 ? order.length : bi);
+  });
+}
+async function generateModsConfig(plan) {
+  const game2 = plan.gameConfig;
+  const target = join8(plan.dataDirHost, game2.modsConfig.file);
+  await mkdir(dirname3(target), { recursive: true });
+  const installed = await readInstallVersion(game2, plan.plugin);
+  if (installed === null) {
+    plan.warnings.push(`could not read Version.txt for ${plan.game}; ModsConfig version may be rejected`);
+  }
+  const declared = new Map([game2.core, ...game2.dlc].map((id) => [id.toLowerCase(), id]));
+  const seen = new Set;
+  const activeMods = [];
+  for (const mod of plan.mods) {
+    const key = mod.packageId.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    activeMods.push(key);
+  }
+  const knownExpansions = (await readKnownExpansions(game2, plan.plugin, plan.warnings)).map((id) => declared.get(id.toLowerCase()) ?? id);
+  await writeFile(target, fromPlugin(target, () => plan.plugin.renderModsConfig({
+    version: installed?.version ?? "",
+    buildNumber: installed?.buildNumber ?? -1,
+    activeMods,
+    knownExpansions
+  })));
+  return target;
+}
+function fromPlugin(target, render) {
+  try {
+    return render();
+  } catch (cause) {
+    if (cause instanceof GamecrateError)
+      throw cause;
+    const error = new GamecrateError(`${target}: ${cause instanceof Error ? cause.message : String(cause)}`, Exit.Config);
+    error.cause = cause;
+    throw error;
+  }
+}
+function ownedPrefs(plan) {
+  const { settings: settings2 } = plan;
+  const bool2 = (value) => value ? "True" : "False";
+  const owned = {
+    screenWidth: String(settings2.width),
+    screenHeight: String(settings2.height),
+    devMode: bool2(settings2.devMode),
+    runInBackground: bool2(settings2.runInBackground),
+    ...plan.plugin.windowedPrefs
+  };
+  Object.assign(owned, settings2.prefsExtra ?? {});
+  owned.resetModsConfigOnCrash = "False";
+  return owned;
+}
+async function mergePrefs(plan) {
+  const target = join8(plan.dataDirHost, plan.gameConfig.prefs.file);
+  await mkdir(dirname3(target), { recursive: true });
+  let existing = null;
+  try {
+    existing = await readFile2(target, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  await writeFile(target, fromPlugin(target, () => plan.plugin.mergePrefs(existing, ownedPrefs(plan))));
+  return target;
+}
+
+// src/launch/prepare.ts
+import { existsSync as existsSync4 } from "node:fs";
+import { open as open2, readdir as readdir5, readFile as readFile3, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { setTimeout as sleep3 } from "node:timers/promises";
+async function inherit(argv, stdin) {
+  const proc = spawnArgv(argv, [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"]);
+  const code = exited(proc);
+  if (stdin !== undefined) {
+    proc.stdin.on("error", () => {});
+    proc.stdin.end(stdin);
+  }
+  await Promise.all([
+    forwardOutput(proc.stdout, process.stdout),
+    forwardOutput(proc.stderr, process.stderr)
+  ]);
+  return code;
+}
+async function imageDigest(ref) {
+  const { code, stdout } = await capture(["docker", "image", "inspect", "--format", "{{.Id}}", ref]);
+  const id = stdout.trim();
+  return code === 0 && id.length > 0 ? id : null;
+}
+async function imageLabel(ref, label) {
+  const format = `{{index .Config.Labels "${label}"}}`;
+  const { code, stdout } = await capture(["docker", "image", "inspect", "--format", format, ref]);
+  const value = stdout.trim();
+  if (code !== 0 || value.length === 0 || value === "<no value>")
+    return null;
+  return value;
+}
+async function acquireImage(game2, config, pull) {
+  const { image } = config;
+  const present = await imageDigest(image.ref) !== null;
+  if (image.acquire === "build") {
+    if (image.context === undefined) {
+      throw new GamecrateError(`${game2} has image.acquire "build" but no context`, Exit.Config);
+    }
+    if (present && pull !== "always")
+      return;
+    if (await inherit(["docker", "build", "--tag", image.ref, image.context]) !== 0) {
+      throw new GamecrateError(`docker build failed for ${image.ref}`, Exit.Environment);
+    }
+    return;
+  }
+  if (pull === "never") {
+    if (present)
+      return;
+    throw new GamecrateError(`--pull never but ${image.ref} is not present locally`, Exit.Environment);
+  }
+  if (pull === "missing" && present)
+    return;
+  if (await inherit(["docker", "pull", image.ref]) !== 0) {
+    if (present)
+      return;
+    throw new GamecrateError(`docker pull failed for ${image.ref}`, Exit.Environment);
+  }
+}
+var RUNTIME_PACKAGES = ["xorg-server-xvfb", "xorg-xwd", "imagemagick", "mesa", "ttf-dejavu"];
+var RUNTIME_SUFFIX = "-gamecrate";
+var BASE_LABEL = "gamecrate.base";
+function runtimeLayerRef(ref) {
+  const at = ref.indexOf("@");
+  const head = at > 0 ? ref.slice(0, at) : ref;
+  const colon = head.lastIndexOf(":");
+  const tagged = colon > head.lastIndexOf("/");
+  const name = tagged ? head.slice(0, colon) : head;
+  if (at > 0) {
+    const digest = ref.slice(at + 1);
+    const hex = digest.slice(digest.indexOf(":") + 1);
+    return `${name}:sha-${hex.slice(0, 12)}${RUNTIME_SUFFIX}`;
+  }
+  return `${name}:${tagged ? head.slice(colon + 1) : "latest"}${RUNTIME_SUFFIX}`;
+}
+async function ensureRuntimeLayer(ref) {
+  const derived = runtimeLayerRef(ref);
+  const base = await imageDigest(ref);
+  if (base !== null && await imageLabel(derived, BASE_LABEL) === base)
+    return derived;
+  const pacman = `pacman -Syu --noconfirm --needed ${RUNTIME_PACKAGES.join(" ")} && pacman -Scc --noconfirm`;
+  const apt = "apt-get update && apt-get install -y --no-install-recommends" + " xvfb x11-apps imagemagick libgl1-mesa-dri fonts-dejavu && rm -rf /var/lib/apt/lists/*";
+  const install = `if command -v pacman >/dev/null 2>&1; then ${pacman};` + ` elif command -v apt-get >/dev/null 2>&1; then ${apt};` + ' else echo "no supported package manager in the base image" >&2; exit 1; fi';
+  const dockerfile = [
+    `FROM ${ref}`,
+    "USER root",
+    `RUN ${install}`,
+    "RUN command -v xvfb-run && command -v Xvfb",
+    `LABEL ${BASE_LABEL}=${base}`
+  ].join(`
+`);
+  const code = await inherit(["docker", "build", "--tag", derived, "-f", "-", "."], new TextEncoder().encode(dockerfile));
+  if (code !== 0) {
+    throw new GamecrateError(`could not build the offscreen runtime layer ${derived}`, Exit.Environment, "headless and screenshot modes need an X server in the image");
+  }
+  return derived;
+}
+async function buildTarget(dir) {
+  let entries;
+  try {
+    entries = await readdir5(dir);
+  } catch {
+    return null;
+  }
+  const slnx = entries.find((e) => e.endsWith(".slnx"));
+  if (slnx)
+    return join9(dir, slnx);
+  const csproj = entries.find((e) => e.endsWith(".csproj"));
+  return csproj ? join9(dir, csproj) : null;
+}
+async function buildLocalMods(plan, policy2) {
+  if (policy2 === "never")
+    return;
+  const wanted = plan.mods.filter((m) => m.kind === "local" && (policy2 === "always" || m.stale === true));
+  if (wanted.length === 0)
+    return;
+  for (const mod of wanted) {
+    const target = await buildTarget(mod.hostDir);
+    if (target === null)
+      continue;
+    const code = await inherit(["dotnet", "build", target, "-v", "quiet", "--nologo"]);
+    if (code !== 0) {
+      throw new GamecrateError(`dotnet build failed for ${mod.packageId}`, Exit.Environment, target);
+    }
+    mod.stale = false;
+    delete mod.staleReport;
+  }
+}
+async function takeLock(plan) {
+  const path = lockPath(plan);
+  const what = plan.instance === undefined ? plan.profile : `${plan.profile} (${plan.instance})`;
+  const name = containerName(plan);
+  const up = await capture(["docker", "ps", "--quiet", "--filter", `name=^${name}$`]);
+  if (up.stdout.trim().length > 0) {
+    throw new GamecrateError(`${plan.game} ${what} is already running (container ${name})`, Exit.Refused, `stop it with: docker stop ${name}
+or relaunch with --replace`);
+  }
+  if (existsSync4(path)) {
+    const holder = await readFile3(path, "utf8").catch(() => "");
+    const pid = Number(holder.split(`
+`)[0]);
+    const alive = Number.isInteger(pid) && pid > 0 && isRunning(pid);
+    if (alive) {
+      throw new GamecrateError(`${plan.game} ${what} is already running (pid ${pid})`, Exit.Refused, `if that is wrong, delete ${path}
+or relaunch with --replace`);
+    }
+    await unlink(path).catch(() => {});
+  }
+  const handle = await open2(path, "wx").catch(() => null);
+  if (handle === null) {
+    throw new GamecrateError(`could not take the launch lock at ${path}`, Exit.Environment);
+  }
+  await handle.writeFile(`${process.pid}
+${new Date().toISOString()}
+`);
+  await handle.close();
+  return {
+    release: async () => {
+      await unlink(path).catch(() => {});
+    }
+  };
+}
+function lockPath(plan) {
+  return join9(plan.instanceDir, ".gamecrate", "lock");
+}
+var RELEASE_WAIT_MS = 1e4;
+var RELEASE_POLL_MS = 100;
+var REPLACE_STOP_TIMEOUT_SECONDS = 10;
+async function replacePrevious(plan) {
+  const name = containerName(plan);
+  const path = lockPath(plan);
+  const up = await capture(["docker", "ps", "--quiet", "--filter", `name=^${name}$`]);
+  const running = up.stdout.trim().length > 0;
+  if (!running && !existsSync4(path))
+    return;
+  if (running) {
+    status(`stopping ${name}`);
+    await stopContainer(name, REPLACE_STOP_TIMEOUT_SECONDS);
+  }
+  const deadline = Date.now() + RELEASE_WAIT_MS;
+  while (existsSync4(path) && Date.now() < deadline) {
+    const holder = await readFile3(path, "utf8").catch(() => "");
+    const pid = Number(holder.split(`
+`)[0]);
+    if (!Number.isInteger(pid) || pid <= 0 || !isRunning(pid))
+      break;
+    await sleep3(RELEASE_POLL_MS);
+  }
+  await unlink(path).catch(() => {});
+}
+function isRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function captureScreenshot(container, plan) {
+  const name = `${plan.game}.png`;
+  const target = `${CONTAINER_LOG_DIR}/${name}`;
+  const script = 'D=":$(ls /tmp/.X11-unix 2>/dev/null | head -1 | tr -d X)";' + ' [ "$D" = ":" ] && { echo "no X socket in the container" >&2; exit 1; };' + ` import -display "$D" -window root ${target} 2>/dev/null` + ` || xwd -root -display "$D" | magick xwd:- ${target}`;
+  const code = await inherit(["docker", "exec", container, "sh", "-c", script]);
+  const host = join9(plan.runDirHost, name);
+  if (code !== 0 || !existsSync4(host))
+    return null;
+  return host;
+}
+async function writeLaunchRecord(plan, image) {
+  const digest = await imageDigest(image);
+  const line2 = JSON.stringify({
+    at: new Date().toISOString(),
+    game: plan.game,
+    profile: plan.profile,
+    ...plan.instance === undefined ? {} : { instance: plan.instance },
+    image,
+    digest,
+    mode: plan.mode,
+    mods: plan.mods.map((m) => ({
+      packageId: m.packageId,
+      hostDir: m.hostDir,
+      ...m.worktree === undefined ? {} : { worktree: m.worktree }
+    }))
+  });
+  const path = join9(plan.instanceDir, ".gamecrate", "launches.jsonl");
+  await writeFile2(path, `${line2}
+`, { flag: "a" });
+}
+
+// src/launch/instance.ts
+import { createHash } from "node:crypto";
+import { basename as basename5, join as join10 } from "node:path";
+
+// src/mods/worktree.ts
+import { spawnSync } from "node:child_process";
+import { existsSync as existsSync5, realpathSync as realpathSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, resolve as resolve4, sep } from "node:path";
+function inspect(dir) {
+  const r = spawnSync("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir", "--abbrev-ref", "HEAD"], { encoding: "utf8" });
+  if (r.status !== 0 || typeof r.stdout !== "string")
+    return null;
+  const lines = r.stdout.trim().split(`
+`);
+  if (lines.length < 4)
+    return null;
+  const [toplevel, gitDir, gitCommonDir, branch] = lines;
+  return { toplevel, gitDir, gitCommonDir, branch };
+}
+function canonical(p) {
+  try {
+    return realpathSync2(p);
+  } catch {
+    return resolve4(p);
+  }
+}
+function resolveWorktree(dir, source, order) {
+  const raw = expandHome(dir);
+  const abs = isAbsolute2(raw) ? raw : resolve4(process.cwd(), raw);
+  if (!existsSync5(abs)) {
+    return { where: abs, message: `--worktree path does not exist`, suggestion: "check the path, or drop the flag" };
+  }
+  const info = inspect(abs);
+  if (info === null) {
+    return source === "cwd" ? { where: abs, message: "not a git repository", suggestion: "ignored" } : { where: abs, message: "not a git repository, or its gitdir has been pruned", suggestion: "run `git worktree prune` in the parent repo" };
+  }
+  if (info.gitDir === info.gitCommonDir) {
+    return source === "cwd" ? { where: abs, message: "primary checkout, not a linked worktree", suggestion: "ignored" } : {
+      where: abs,
+      message: "is the primary checkout, not a linked worktree",
+      suggestion: "nothing to promote; drop --worktree"
+    };
+  }
+  return { root: canonical(info.toplevel), branch: info.branch, source, order };
+}
+function contains(request, dir) {
+  const target = canonical(dir);
+  return target === request.root || target.startsWith(request.root + sep);
+}
+function collectRequests(flags2, env, cwd, disabled) {
+  if (disabled)
+    return { requests: [], problems: [] };
+  const requests = [];
+  const problems = [];
+  let order = 0;
+  const add = (dir, source) => {
+    const got = resolveWorktree(dir, source, order);
+    if ("root" in got) {
+      if (!requests.some((r) => r.root === got.root)) {
+        requests.push(got);
+        order += 1;
+      }
+    } else if (source !== "cwd") {
+      problems.push(got);
+    }
+  };
+  for (const f of flags2)
+    add(f, "flag");
+  if (env !== undefined && env !== "" && env !== "off")
+    add(env, "env");
+  add(cwd, "cwd");
+  return { requests, problems };
+}
+
+// src/launch/instance.ts
+var SLUG_LIMIT = 24;
+function resolveInstance(options) {
+  const { profileDir, profile: profile2, args } = options;
+  const configured = lookup(profile2, args.instance);
+  const flags2 = configured?.worktree === undefined ? args.worktree ?? [] : [configured.worktree, ...args.worktree ?? []];
+  const { requests, problems } = collectRequests(flags2, options.env ?? process.env["GAMECRATE_WORKTREE"], options.cwd ?? process.cwd(), args.noWorktree ?? false);
+  const name = args.instance === undefined ? derive(requests) : named(args.instance);
+  return {
+    ...name === undefined ? {} : { name },
+    dir: name === undefined ? profileDir : join10(profileDir, "instances", name),
+    requests,
+    problems,
+    ...configured?.settings === undefined ? {} : { settings: configured.settings }
+  };
+}
+function lookup(profile2, name) {
+  const instances = profile2?.instances;
+  if (instances === undefined || name === undefined)
+    return;
+  const exact = own(instances, name);
+  if (exact !== undefined)
+    return exact;
+  const lower = name.toLowerCase();
+  const key = Object.keys(instances).find((k) => k.toLowerCase() === lower);
+  return key === undefined ? undefined : own(instances, key);
+}
+function named(name) {
+  if (!NAME_PATTERN.test(name)) {
+    throw new GamecrateError(`invalid instance name "${name}"`, Exit.Usage, `it becomes a directory and a container name, so it must match ${NAME_PATTERN.source}`);
+  }
+  return name;
+}
+function derive(requests) {
+  const first = requests[0];
+  if (first === undefined)
+    return;
+  const digest = createHash("sha256").update(requests.map((r) => r.root).join("\x00")).digest("hex");
+  return `${slug(first.root)}-${digest.slice(0, 6)}`;
+}
+function slug(root2) {
+  const body = basename5(root2).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").slice(0, SLUG_LIMIT).replace(/[-._]+$/, "");
+  return body === "" ? "wt" : body;
+}
+
+// src/launch/resolve.ts
+import { join as join12 } from "node:path";
+
+// src/mods/modindex.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { mkdir as mkdir2, readdir as readdir6, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join11, relative as relative2, resolve as resolvePath } from "node:path";
+import picomatch from "picomatch";
+function cacheDir() {
+  return join11(process.env["XDG_CACHE_HOME"] ?? join11(homedir4(), ".cache"), "gamecrate");
+}
+function globMatch(pattern, path) {
+  return picomatch.isMatch(path, pattern.replace(/[[\]{}()!,@+|^$.\\]/g, "\\$&"), { dot: true });
+}
+function excluded(patterns, relativePath) {
+  return patterns.some((p) => globMatch(p, relativePath) || globMatch(p, `${relativePath}/`));
+}
+var ALWAYS_EXCLUDE = ["**/.worktrees/**", "**/.claude/worktrees/**"];
+function inLinkedWorktree(dir, stopAt) {
+  let current = dir;
+  for (;; ) {
+    const git = join11(current, ".git");
+    if (existsSync6(git)) {
+      try {
+        if (statSync2(git).isFile())
+          return true;
+      } catch {
+        return false;
+      }
+      return false;
+    }
+    if (current === stopAt)
+      return false;
+    const parent = dirname4(current);
+    if (parent === current)
+      return false;
+    current = parent;
+  }
+}
+async function scanLocalRoot(root2, rootIndex, manifestFile, found) {
+  const base = resolvePath(expandHome(root2.path));
+  const exclude = [...root2.exclude ?? [], ...rootIndex === -1 ? [] : ALWAYS_EXCLUDE];
+  const walk = async (dir, depth) => {
+    const manifest = join11(dir, manifestFile);
+    if (existsSync6(manifest)) {
+      found.push({
+        dir,
+        kind: "local",
+        rootIndex,
+        linkedWorktree: inLinkedWorktree(dir, base)
+      });
+      return;
+    }
+    if (depth >= root2.maxDepth)
+      return;
+    let entries;
+    try {
+      entries = await readdir6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".git"))
+        continue;
+      const child = join11(dir, entry.name);
+      if (excluded(exclude, relative2(base, child)))
+        continue;
+      await walk(child, depth + 1);
+    }
+  };
+  if (!existsSync6(base))
+    return;
+  await walk(base, 0);
+}
+async function scanWorkshopRoot(workshopRoot, rootIndex, manifestFile, found) {
+  const base = resolvePath(expandHome(workshopRoot));
+  let entries;
+  try {
+    entries = await readdir6(base, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
+      continue;
+    const dir = join11(base, entry.name);
+    if (!existsSync6(join11(dir, manifestFile)))
+      continue;
+    found.push({ dir, kind: "workshop", rootIndex, linkedWorktree: false, workshopId: Number(entry.name) });
+  }
+}
+async function scanGameData(game2, rootIndex, found) {
+  const host = game2.gameFiles.host;
+  if (game2.gameFiles.source !== "mount" || host === undefined)
+    return;
+  const data = join11(resolvePath(expandHome(host)), "Data");
+  let entries;
+  try {
+    entries = await readdir6(data, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const dir = join11(data, entry.name);
+    if (!existsSync6(join11(dir, game2.manifest.file)))
+      continue;
+    found.push({ dir, kind: "official", rootIndex, linkedWorktree: false });
+  }
+}
+var CACHE_VERSION = 2;
+function workshopStamp(game2) {
+  if (game2.workshopRoot === null)
+    return null;
+  const acf = join11(dirname4(dirname4(resolvePath(expandHome(game2.workshopRoot)))), `appworkshop_${game2.steamAppId}.acf`);
+  try {
+    const info = statSync2(acf);
+    return `${info.mtimeMs}:${info.size}`;
+  } catch {
+    return null;
+  }
+}
+async function readWorkshopCache(game2, stamp) {
+  try {
+    const raw = JSON.parse(await readFile4(join11(cacheDir(), `${game2}.workshop.json`), "utf8"));
+    if (raw.version !== CACHE_VERSION || raw.stamp !== stamp)
+      return null;
+    return raw.records;
+  } catch {
+    return null;
+  }
+}
+async function writeWorkshopCache(game2, stamp, records) {
+  const payload = { version: CACHE_VERSION, stamp, records };
+  try {
+    await mkdir2(cacheDir(), { recursive: true });
+    await writeFile3(join11(cacheDir(), `${game2}.workshop.json`), JSON.stringify(payload));
+  } catch {}
+}
+function toRecord(candidate, manifest, game2) {
+  const kind = manifest.packageId.toLowerCase() === game2.core.toLowerCase() ? "core" : candidate.kind;
+  const record = {
+    packageId: manifest.packageId,
+    dir: candidate.dir,
+    kind,
+    manifest,
+    linkedWorktree: candidate.linkedWorktree,
+    rootIndex: candidate.rootIndex
+  };
+  if (candidate.workshopId !== undefined)
+    record.workshopId = candidate.workshopId;
+  return record;
+}
+function tier(r) {
+  return [
+    r.overridden ?? Number.MAX_SAFE_INTEGER,
+    r.selectedWorktree ?? Number.MAX_SAFE_INTEGER,
+    r.kind === "workshop" ? 1 : 0,
+    r.linkedWorktree ? 1 : 0,
+    r.rootIndex
+  ];
+}
+function compareTiers(a, b) {
+  const x = tier(a);
+  const y = tier(b);
+  for (let i = 0;i < x.length; i += 1) {
+    if (x[i] !== y[i])
+      return x[i] - y[i];
+  }
+  return 0;
+}
+function rank(a, b) {
+  return compareTiers(a, b) || (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0);
+}
+async function applyWorktreeRequests(index, requests, config) {
+  if (requests.length === 0)
+    return;
+  const known = new Set;
+  for (const bucket of index.byPackageId.values()) {
+    for (const record of bucket) {
+      known.add(record.dir);
+      for (const request of requests) {
+        if (!contains(request, record.dir))
+          continue;
+        record.worktree = { root: request.root, branch: request.branch, source: request.source };
+        record.selectedWorktree = request.order;
+        break;
+      }
+    }
+  }
+  for (const request of requests) {
+    const found = [];
+    await scanLocalRoot({ path: request.root, maxDepth: WORKTREE_SCAN_DEPTH, exclude: WORKTREE_EXCLUDE }, -1, config.manifest.file, found);
+    const fresh = found.filter((c) => !known.has(c.dir));
+    if (fresh.length === 0)
+      continue;
+    for (const record of await parseAll(fresh, config, index.plugin, index.problems)) {
+      record.worktree = { root: request.root, branch: request.branch, source: request.source };
+      record.selectedWorktree = request.order;
+      insert(index, record);
+    }
+  }
+  for (const bucket of index.byPackageId.values())
+    bucket.sort(rank);
+}
+var WORKTREE_SCAN_DEPTH = 5;
+var WORKTREE_EXCLUDE = ["**/.retired/**", "**/node_modules/**", "**/bin/**", "**/obj/**"];
+async function applySourceOverrides(index, overrides, config) {
+  const problems = [];
+  if (overrides.length === 0)
+    return problems;
+  for (const [order, spec] of overrides.entries()) {
+    const eq = spec.indexOf("=");
+    if (eq < 1) {
+      problems.push({ where: spec, message: "--use takes <packageId>=<path>" });
+      continue;
+    }
+    const wanted = spec.slice(0, eq);
+    const dir = resolvePath(expandHome(spec.slice(eq + 1)));
+    const file = join11(dir, config.manifest.file);
+    if (!existsSync6(file)) {
+      problems.push({
+        where: spec,
+        message: `no ${config.manifest.file} under ${dir}`,
+        suggestion: "point --use at the mod directory, not the repo root"
+      });
+      continue;
+    }
+    let manifest;
+    try {
+      manifest = index.plugin.parseManifest(readFileSync3(file, "utf8"));
+    } catch (error) {
+      problems.push({ where: file, message: `could not parse: ${String(error)}` });
+      continue;
+    }
+    if (manifest === null) {
+      problems.push({ where: file, message: `${file} declares no packageId` });
+      continue;
+    }
+    if (manifest.packageId.toLowerCase() !== wanted.toLowerCase()) {
+      problems.push({
+        where: spec,
+        message: `${dir} declares ${manifest.packageId}, not ${wanted}`,
+        suggestion: `use --use ${manifest.packageId}=${dir}`
+      });
+      continue;
+    }
+    const key = manifest.packageId.toLowerCase();
+    const existing = (index.byPackageId.get(key) ?? []).find((r) => r.dir === dir);
+    if (existing) {
+      existing.overridden = order;
+    } else {
+      const record = toRecord({ dir, kind: "local", rootIndex: -1, linkedWorktree: false }, manifest, config);
+      record.overridden = order;
+      insert(index, record);
+    }
+    index.byPackageId.get(key)?.sort(rank);
+  }
+  return problems;
+}
+function insert(index, record) {
+  const key = record.packageId.toLowerCase();
+  const bucket = index.byPackageId.get(key);
+  if (bucket)
+    bucket.push(record);
+  else
+    index.byPackageId.set(key, [record]);
+  if (record.workshopId !== undefined && !index.byWorkshopId.has(record.workshopId)) {
+    index.byWorkshopId.set(record.workshopId, record);
+  }
+  const short = key.split(".").pop();
+  if (short !== undefined && short.length > 0) {
+    const ids = index.byShortName.get(short);
+    if (ids) {
+      if (!ids.includes(record.packageId))
+        ids.push(record.packageId);
+    } else {
+      index.byShortName.set(short, [record.packageId]);
+    }
+  }
+}
+async function buildIndex(game2, config, plugin) {
+  const index = {
+    game: game2,
+    plugin,
+    byPackageId: new Map,
+    byWorkshopId: new Map,
+    byShortName: new Map,
+    problems: []
+  };
+  const local = [];
+  await scanGameData(config, -1, local);
+  for (const [i, root2] of config.scanRoots.entries()) {
+    await scanLocalRoot(root2, i, config.manifest.file, local);
+  }
+  for (const record of await parseAll(local, config, plugin, index.problems))
+    insert(index, record);
+  if (config.workshopRoot !== null) {
+    const stamp = workshopStamp(config);
+    const cached = stamp === null ? null : await readWorkshopCache(game2, stamp);
+    if (cached) {
+      for (const record of cached)
+        insert(index, record);
+    } else {
+      const items = [];
+      await scanWorkshopRoot(config.workshopRoot, config.scanRoots.length, config.manifest.file, items);
+      const records = await parseAll(items, config, plugin, index.problems);
+      for (const record of records)
+        insert(index, record);
+      if (stamp !== null)
+        await writeWorkshopCache(game2, stamp, records);
+    }
+  }
+  for (const bucket of index.byPackageId.values())
+    bucket.sort(rank);
+  return index;
+}
+async function parseAll(candidates, config, plugin, problems) {
+  const records = await Promise.all(candidates.map(async (candidate) => {
+    const file = join11(candidate.dir, config.manifest.file);
+    try {
+      const manifest = plugin.parseManifest(await readFile4(file, "utf8"));
+      return manifest === null ? null : toRecord(candidate, manifest, config);
+    } catch (error) {
+      problems.push({
+        where: file,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }));
+  return records.filter((r) => r !== null);
+}
+function resolveModRef(index, ref, game2) {
+  return honorOverride(index, resolveRaw(index, ref, game2));
+}
+function honorOverride(index, record) {
+  if (record === null || record.overridden !== undefined)
+    return record;
+  const best = index.byPackageId.get(record.packageId.toLowerCase())?.[0];
+  return best?.overridden !== undefined ? best : record;
+}
+function resolveRaw(index, ref, game2) {
+  if (ref.startsWith("path:"))
+    return byPath(index, ref.slice(5), game2);
+  if (ref.startsWith("workshop:")) {
+    const id = Number(ref.slice(9));
+    return Number.isInteger(id) ? index.byWorkshopId.get(id) ?? null : null;
+  }
+  const direct = pick(index, ref.toLowerCase(), ref);
+  if (direct)
+    return direct;
+  const alias = own(game2.aliases, ref) ?? own(game2.aliases, ref.toLowerCase());
+  if (alias !== undefined && alias.toLowerCase() !== ref.toLowerCase()) {
+    return resolveRaw(index, alias, game2);
+  }
+  const short = index.byShortName.get(ref.toLowerCase());
+  if (short && short.length === 1)
+    return pick(index, short[0].toLowerCase(), ref);
+  if (short && short.length > 1) {
+    throw new GamecrateError(`"${ref}" is a short name for ${short.length} mods`, Exit.Resolution, short.join(", "));
+  }
+  return null;
+}
+function pick(index, key, ref) {
+  const bucket = index.byPackageId.get(key);
+  const best = bucket?.[0];
+  if (!best)
+    return null;
+  const runnerUp = bucket[1];
+  if (runnerUp && compareTiers(best, runnerUp) === 0) {
+    if (best.selectedWorktree !== undefined || runnerUp.selectedWorktree !== undefined) {
+      throw new GamecrateError(`"${ref}" is declared by ${bucket.length} indistinguishable directories`, Exit.Resolution, bucket.map((r) => r.dir).join(`
+`));
+    }
+    index.problems.push({
+      where: ref,
+      message: `resolved by directory name: ${bucket.length} candidates tie on every rule`,
+      suggestion: `using ${best.dir}`
+    });
+  }
+  return best;
+}
+function byPath(index, raw, game2) {
+  const dir = resolvePath(expandHome(raw));
+  for (const bucket of index.byPackageId.values()) {
+    const hit = bucket.find((record) => record.dir === dir || record.dir === raw);
+    if (hit)
+      return hit;
+  }
+  const file = join11(dir, game2.manifest.file);
+  if (!existsSync6(file))
+    return null;
+  try {
+    const manifest = index.plugin.parseManifest(readFileSync3(file, "utf8"));
+    if (manifest === null)
+      return null;
+    return toRecord({ dir, kind: "local", rootIndex: -1, linkedWorktree: false }, manifest, game2);
+  } catch {
+    return null;
+  }
+}
+
+// src/launch/resolve.ts
+var DEFAULT_TIMEOUT_SECONDS = 420;
+var DEFAULT_RENDER_WAIT_SECONDS = 25;
+function isDynamic(entry) {
+  return typeof entry !== "string" && "match" in entry;
+}
+function refFor(entry, game2) {
+  const object = typeof entry === "string" ? { id: entry } : entry;
+  if (object.path !== undefined)
+    return `path:${object.path}`;
+  if (object.workshop !== undefined)
+    return `workshop:${object.workshop}`;
+  if (object.id.includes(":"))
+    return object.id;
+  const pin = own(game2.library, object.id) ?? own(game2.library, object.id.toLowerCase());
+  if (pin?.path !== undefined)
+    return `path:${pin.path}`;
+  if (pin?.workshop !== undefined)
+    return `workshop:${pin.workshop}`;
+  return object.id;
+}
+function expandDynamic(entry, index, where, problems) {
+  const pattern = globToRegExp(entry.match);
+  const matched = [];
+  for (const records of index.byPackageId.values()) {
+    const record = records[0];
+    if (record && pattern.test(record.packageId))
+      matched.push(record.packageId);
+  }
+  const minMatches = entry.minMatches ?? 1;
+  if (matched.length < minMatches) {
+    problems.push({
+      where,
+      message: `"${entry.match}" matched ${matched.length} mod(s), needs at least ${minMatches}`
+    });
+  }
+  const firstOrder = (entry.first ?? []).map((id) => id.toLowerCase());
+  const head = matched.filter((id) => firstOrder.includes(id.toLowerCase())).sort((a, b) => firstOrder.indexOf(a.toLowerCase()) - firstOrder.indexOf(b.toLowerCase()));
+  const rest = matched.filter((id) => !firstOrder.includes(id.toLowerCase()));
+  if ((entry.sort ?? "alpha") === "alpha") {
+    rest.sort((a, b) => a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0);
+  }
+  return [...head, ...rest];
+}
+function collectSlots(game2, gameName, profileName, profile2, args) {
+  const modless = profileName === "modless";
+  const slots = [];
+  const at = `/games/${gameName}`;
+  if (!modless)
+    for (const [i, id] of (game2.preCore ?? []).entries())
+      slots.push({ entry: id, where: `${at}/preCore/${i}` });
+  slots.push({ entry: game2.core, where: `${at}/core` });
+  for (const [i, id] of game2.dlc.entries())
+    slots.push({ entry: id, where: `${at}/dlc/${i}`, dlc: true });
+  if (!modless && profile2.includeBase !== false) {
+    for (const [i, id] of (game2.base ?? []).entries())
+      slots.push({ entry: id, where: `${at}/base/${i}` });
+  }
+  const only = args.only ?? [];
+  const declared = only.length > 0 ? only : profile2.mods ?? [];
+  const source = only.length > 0 ? "flag --only" : `${at}/profiles/${profileName}/mods`;
+  for (const [i, entry] of declared.entries())
+    slots.push({ entry, where: `${source}/${i}` });
+  for (const [i, id] of (args.mods ?? []).entries())
+    slots.push({ entry: id, where: `flag --mod/${i}` });
+  return slots;
+}
+function insertDependencies(list, present, index, game2, problems) {
+  let i = 0;
+  outer:
+    while (i < list.length) {
+      const mod = list[i];
+      for (const dep of mod.record.manifest.modDependencies) {
+        const key = dep.packageId.toLowerCase();
+        if (present.has(key))
+          continue;
+        present.add(key);
+        const record = resolveModRef(index, dep.packageId, game2);
+        if (!record) {
+          problems.push({
+            where: mod.record.packageId,
+            message: `declares a dependency on ${dep.packageId}, which is not installed`,
+            suggestion: dep.steamWorkshopUrl
+          });
+          continue;
+        }
+        present.add(record.packageId.toLowerCase());
+        list.splice(i, 0, { record, explicit: false });
+        continue outer;
+      }
+      i++;
+    }
+}
+function topoSort(list, problems, core) {
+  const position = new Map;
+  for (const [i, mod] of list.entries())
+    position.set(mod.record.packageId.toLowerCase(), i);
+  const edges = new Set;
+  const addEdge = (from, to) => {
+    if (from === undefined || to === undefined || from === to)
+      return;
+    edges.add(`${from}>${to}`);
+  };
+  for (const [i, mod] of list.entries()) {
+    const { loadAfter, loadBefore, forceLoadAfter, forceLoadBefore } = mod.record.manifest;
+    for (const id of [...loadAfter, ...forceLoadAfter])
+      addEdge(position.get(id.toLowerCase()), i);
+    for (const id of [...loadBefore, ...forceLoadBefore])
+      addEdge(i, position.get(id.toLowerCase()));
+  }
+  const indegree = list.map(() => 0);
+  const outgoing = list.map(() => []);
+  const incoming = list.map(() => []);
+  for (const edge of edges) {
+    const [from, to] = edge.split(">").map(Number);
+    outgoing[from].push(to);
+    incoming[to].push(from);
+    indegree[to] += 1;
+  }
+  const preCore = new Set;
+  const coreIndex = core === undefined ? undefined : position.get(core.toLowerCase());
+  if (coreIndex !== undefined) {
+    const queue = [coreIndex];
+    while (queue.length > 0) {
+      for (const from of incoming[queue.pop()]) {
+        if (preCore.has(from))
+          continue;
+        preCore.add(from);
+        queue.push(from);
+      }
+    }
+  }
+  const phase = (i) => preCore.has(i) ? 0 : 1;
+  const sorted = [];
+  const done = list.map(() => false);
+  for (;; ) {
+    let next = -1;
+    for (let i = 0;i < list.length; i++) {
+      if (done[i] || indegree[i] !== 0)
+        continue;
+      if (next === -1 || phase(i) < phase(next))
+        next = i;
+    }
+    if (next === -1)
+      break;
+    done[next] = true;
+    sorted.push(list[next]);
+    for (const to of outgoing[next])
+      indegree[to] -= 1;
+  }
+  const cycle = list.filter((_, i) => !done[i]);
+  if (cycle.length > 0) {
+    problems.push({
+      where: "flag --sort topo",
+      message: `load-order cycle among ${cycle.map((m) => m.record.packageId).join(", ")}; left in profile order`
+    });
+    sorted.push(...cycle);
+  }
+  return sorted;
+}
+function incompatibilityWarnings(list) {
+  const byId = new Map(list.map((mod) => [mod.record.packageId.toLowerCase(), mod.record.packageId]));
+  const seen = new Set;
+  const warnings = [];
+  for (const mod of list) {
+    for (const id of mod.record.manifest.incompatibleWith) {
+      const other = byId.get(id.toLowerCase());
+      if (!other)
+        continue;
+      const pair = [mod.record.packageId, other].map((s) => s.toLowerCase()).sort().join("|");
+      if (seen.has(pair))
+        continue;
+      seen.add(pair);
+      warnings.push(`${mod.record.packageId} declares it is incompatible with ${other}; both are active`);
+    }
+  }
+  return warnings;
+}
+async function resolvePlan(options) {
+  const { game: gameName, profile: requestedProfile, root: root2 } = options;
+  const args = options.args ?? {};
+  const problems = [];
+  const warnings = [];
+  const game2 = own(root2.games, gameName);
+  if (!game2) {
+    throw new GamecrateError(`unknown game "${gameName}"`, Exit.Config, `known: ${Object.keys(root2.games).join(", ")}`);
+  }
+  if (!NAME_PATTERN.test(requestedProfile)) {
+    throw new GamecrateError(`invalid profile name "${requestedProfile}"`, Exit.Usage);
+  }
+  const profileName = canonicalProfile(game2, requestedProfile);
+  const profile2 = profileName === "modless" ? { mods: [], includeBase: false } : resolveProfile(game2, profileName);
+  const profileDir = profileDataDir(root2, gameName, profileName);
+  const instance = resolveInstance({
+    profileDir,
+    profile: profile2,
+    args,
+    ...options.cwd === undefined ? {} : { cwd: options.cwd }
+  });
+  problems.push(...instance.problems);
+  const settings2 = resolveSettings(root2, game2, profile2, instance.settings, args.resolution);
+  if (args.network !== undefined)
+    settings2.network = args.network;
+  if (args.gameArgs?.length)
+    settings2.gameArgs = [...settings2.gameArgs ?? [], ...args.gameArgs];
+  if (args.dockerArgs?.length)
+    settings2.dockerArgs = [...settings2.dockerArgs ?? [], ...args.dockerArgs];
+  const plugin = requirePlugin(options.plugins, gameName);
+  const index = options.index ?? await buildIndex(gameName, game2, plugin);
+  await applyWorktreeRequests(index, instance.requests, game2);
+  problems.push(...await applySourceOverrides(index, args.use ?? [], game2));
+  const excluded2 = [...profile2.exclude ?? [], ...args.without ?? []].map(globToRegExp);
+  const isExcluded = (id) => excluded2.some((pattern) => pattern.test(id));
+  const staged = [];
+  const present = new Set;
+  for (const slot of collectSlots(game2, gameName, profileName, profile2, args)) {
+    const entry = slot.entry;
+    const refs = isDynamic(entry) ? expandDynamic(entry, index, slot.where, problems).map((id) => ({ ref: id, optional: false })) : [{ ref: refFor(entry, game2), optional: typeof entry !== "string" && entry.optional === true }];
+    for (const { ref, optional } of refs) {
+      const record = resolveModRef(index, ref, game2);
+      if (!record) {
+        if (slot.dlc === true)
+          continue;
+        if (optional)
+          warnings.push(`optional mod ${ref} is not installed; skipped`);
+        else
+          problems.push({ where: slot.where, message: `no mod matches "${ref}"` });
+        continue;
+      }
+      const key = record.packageId.toLowerCase();
+      if (present.has(key) || isExcluded(record.packageId))
+        continue;
+      present.add(key);
+      staged.push({ record, explicit: true });
+    }
+  }
+  if (profile2.autoDependencies === true)
+    insertDependencies(staged, present, index, game2, problems);
+  const ordered = args.sort === "none" ? staged : topoSort(staged, problems, game2.core);
+  warnings.push(...incompatibilityWarnings(ordered));
+  const mods = [];
+  for (const { record, explicit } of ordered) {
+    const times = record.kind === "local" ? await scanBuildTimes(record.dir) : null;
+    const report = times === null ? null : staleReport(times);
+    if (record.worktree) {
+      warnings.push(`${record.packageId} comes from worktree ${record.worktree.branch} (${record.worktree.source}): ${record.dir}`);
+    }
+    const shadowed = (index.byPackageId.get(record.packageId.toLowerCase()) ?? []).filter((other) => other.dir !== record.dir).map((other) => other.dir);
+    mods.push({
+      packageId: record.packageId,
+      hostDir: record.dir,
+      containerDir: `${game2.modsDir.container}/${record.packageId}`,
+      kind: record.kind,
+      ...record.workshopId === undefined ? {} : { workshopId: record.workshopId },
+      explicit,
+      stale: times === null ? false : decideStale(times),
+      ...report === null ? {} : { staleReport: report },
+      ...record.worktree === undefined ? {} : { worktree: { ...record.worktree, selected: record.selectedWorktree !== undefined } },
+      ...shadowed.length === 0 ? {} : { shadowed }
+    });
+  }
+  problems.push(...index.problems);
+  if (game2.dataDir.mode === "arg" && game2.dataDir.arg.split("=").length !== 2) {
+    problems.push({
+      where: `/games/${gameName}/dataDir/arg`,
+      message: `"${game2.dataDir.arg}" must contain exactly one "="; RimWorld silently ignores anything else`
+    });
+  }
+  if (game2.dataDir.container.includes("=")) {
+    problems.push({
+      where: `/games/${gameName}/dataDir/container`,
+      message: `container data path "${game2.dataDir.container}" contains "=", which disables the override silently`
+    });
+  }
+  const mode = args.mode ?? "headed";
+  if (!game2.modes.includes(mode)) {
+    problems.push({ where: "flag --mode", message: `${gameName} does not support mode "${mode}"` });
+  }
+  const plan = {
+    game: gameName,
+    gameConfig: game2,
+    plugin,
+    profile: profileName,
+    settings: settings2,
+    mods,
+    profileDir,
+    ...instance.name === undefined ? {} : { instance: instance.name },
+    instanceDir: instance.dir,
+    dataDirHost: join12(instance.dir, "game"),
+    configDirHost: join12(profileDir, "config"),
+    stageDirHost: join12(instance.dir, ".stage"),
+    logsDirHost: join12(instance.dir, "logs"),
+    runDirHost: join12(instance.dir, "logs"),
+    mode,
+    ...args.marker === undefined ? {} : { marker: args.marker },
+    timeoutSeconds: args.timeout ?? DEFAULT_TIMEOUT_SECONDS,
+    renderWaitSeconds: args.renderWait ?? DEFAULT_RENDER_WAIT_SECONDS,
+    warnOnStale: args.noStaleCheck !== true,
+    warnings
+  };
+  return { plan, problems };
+}
+
+// src/launch/stage.ts
+import { lstat, mkdir as mkdir3, readdir as readdir7, realpath, rm, stat as stat3 } from "node:fs/promises";
+import { basename as basename6, join as join13 } from "node:path";
+async function stageMods(plan) {
+  await rm(plan.stageDirHost, { recursive: true, force: true });
+  await mkdir3(plan.stageDirHost, { recursive: true });
+  const mounts = [];
+  for (const mod of plan.mods) {
+    if (mod.kind === "core" || mod.kind === "official")
+      continue;
+    let source;
+    try {
+      source = await realpath(mod.hostDir);
+    } catch {
+      throw new GamecrateError(`mod directory for ${mod.packageId} is missing`, Exit.Environment, mod.hostDir);
+    }
+    if (!(await stat3(source)).isDirectory()) {
+      throw new GamecrateError(`${mod.packageId} does not resolve to a directory`, Exit.Environment, source);
+    }
+    await mkdir3(join13(plan.stageDirHost, basename6(mod.containerDir)), { recursive: true });
+    mounts.push({ type: "bind", source, target: mod.containerDir, readonly: true });
+  }
+  return mounts;
+}
+async function ensureProfileTree(plan) {
+  for (const dir of [
+    plan.profileDir,
+    plan.instanceDir,
+    plan.dataDirHost,
+    join13(plan.configDirHost, "config"),
+    join13(plan.configDirHost, "data"),
+    join13(plan.configDirHost, "cache"),
+    join13(plan.logsDirHost, "runs"),
+    plan.stageDirHost,
+    join13(plan.instanceDir, ".gamecrate"),
+    ...engineDirs(plan)
+  ]) {
+    await mkdir3(dir, { recursive: true });
+  }
+}
+function engineDirs(plan) {
+  const { dataDir, modsDir } = plan.gameConfig;
+  if (!modsDir.container.startsWith(`${dataDir.container}/`))
+    return [];
+  return [join13(plan.dataDirHost, modsDir.container.slice(dataDir.container.length + 1))];
+}
+async function detectForeignOwnership(dir, uid, limit = 100) {
+  const foreign = [];
+  const queue = [dir];
+  while (queue.length > 0 && foreign.length < limit) {
+    const current = queue.shift();
+    let info;
+    try {
+      info = await lstat(current);
+    } catch {
+      continue;
+    }
+    if (info.uid !== uid) {
+      foreign.push(current);
+      if (foreign.length >= limit)
+        break;
+    }
+    if (!info.isDirectory())
+      continue;
+    try {
+      for (const entry of await readdir7(current))
+        queue.push(join13(current, entry));
+    } catch {
+      continue;
+    }
+  }
+  return foreign;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var STOP_TIMEOUT_SECONDS = 10;
+async function main(argv) {
+  const probe = parseArgs(argv);
+  if (probe.subcommand === "version") {
+    process.stdout.write(`gamecrate ${VERSION}
+`);
+    return Exit.Ok;
+  }
+  const [{ config, plugins }, defaults] = await Promise.all([loadConfig(), loadProjectDefaults()]);
+  const args = parseArgs(argv, { games: Object.keys(config.games), defaults });
+  if (args.help) {
+    process.stdout.write(renderHelp(helpTopic(args), config));
+    return Exit.Ok;
+  }
+  const redirect = args.log !== undefined && (args.subcommand === "run" || args.subcommand === "shell") ? redirectOutput(args.log) : undefined;
+  try {
+    return await dispatch(args, config, plugins);
+  } catch (error) {
+    return reportFatal(error);
+  } finally {
+    redirect?.close();
+  }
+}
+async function dispatch(args, config, plugins) {
+  switch (args.subcommand) {
+    case "help":
+      return help(args, config);
+    case "list":
+      return list(args, config);
+    case "mods":
+      return mods(args, config, plugins);
+    case "doctor":
+      return doctor(config, plugins);
+    case "clean":
+      return clean(args, config);
+    case "clone":
+      return clone(args, config);
+    case "logs":
+      return logs(args, config);
+    case "verify":
+      return verify(args, config, plugins);
+    case "build":
+      return build(args, config);
+    case "shell":
+      return run(args, config, plugins, true);
+    case "config":
+      return configEdit(args);
+    case "fix-perms":
+      return fixPerms(args, config);
+    case "run":
+      return run(args, config, plugins, false);
+    default:
+      throw new GamecrateError(`no such subcommand ${args.subcommand}`, Exit.Usage);
+  }
+}
+function helpTopic(args) {
+  if (args.subcommand === "help")
+    return args.rest[0];
+  if (args.subcommand === "run")
+    return args.game;
+  return args.subcommand;
+}
+function help(args, config) {
+  const topic = args.rest[0];
+  if (topic === "completion") {
+    const shell = args.rest[1];
+    if (shell !== "bash" && shell !== "zsh") {
+      throw new GamecrateError("help completion takes bash or zsh", Exit.Usage);
+    }
+    process.stdout.write(renderCompletion(shell));
+    return Exit.Ok;
+  }
+  process.stdout.write(renderHelp(topic, config));
+  return Exit.Ok;
+}
+function requireGame(args, config) {
+  const game2 = args.game;
+  if (game2 === undefined) {
+    throw new GamecrateError(`${args.subcommand} needs a game`, Exit.Usage, `known games: ${Object.keys(config.games).join(", ")}`);
+  }
+  if (!Object.hasOwn(config.games, game2)) {
+    throw new GamecrateError(`unknown game "${game2}"`, Exit.Config, `known games: ${Object.keys(config.games).join(", ")}`);
+  }
+  return game2;
+}
+function instanceDir(args, config, game2, profile2) {
+  const dir = profileDataDir(config, game2, profile2);
+  let spec;
+  try {
+    spec = resolveProfile(config.games[game2], profile2);
+  } catch {
+    spec = undefined;
+  }
+  return resolveInstance({ profileDir: dir, ...spec === undefined ? {} : { profile: spec }, args }).dir;
+}
+function reportEnvironment(problems) {
+  process.stderr.write(`${problems.length} environment problem(s):
+`);
+  for (const problem of problems) {
+    process.stderr.write(`  ${problem.where}
+    ${problem.message}
+`);
+    if (problem.suggestion)
+      process.stderr.write(`      try: ${problem.suggestion}
+`);
+  }
+  process.exit(Exit.Environment);
+}
+async function run(args, config, plugins, asShell) {
+  const game2 = requireGame(args, config);
+  const profile2 = args.profile ?? "modless";
+  const index = await buildIndex(game2, config.games[game2], requirePlugin(plugins, game2));
+  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args, index });
+  if (problems.length > 0)
+    reportProblems(problems);
+  const identity = resolveIdentity(args.root);
+  if (args.printPlan || args.dryRun) {
+    const environment2 = await preflight(plan);
+    buildRunSpec(plan, [], identity);
+    if (args.printPlan)
+      printPlan(plan, args.json);
+    for (const warning of planWarnings(plan))
+      warn(warning);
+    if (environment2.length > 0)
+      return reportEnvironment(environment2);
+    if (!args.printPlan) {
+      const what = plan.instance === undefined ? profile2 : `${profile2}/${plan.instance}`;
+      status(`${game2} ${what}: ${plan.mods.length} mods resolve cleanly`);
+    }
+    return Exit.Ok;
+  }
+  const environment = await preflight(plan);
+  if (environment.length > 0)
+    return reportEnvironment(environment);
+  await ensureProfileTree(plan);
+  if (args.replace)
+    await replacePrevious(plan);
+  const lock = await takeLock(plan);
+  try {
+    return await launch(plan, args, config, identity, asShell);
+  } finally {
+    await lock.release();
+  }
+}
+async function launch(plan, args, config, identity, asShell) {
+  const game2 = plan.game;
+  const profile2 = plan.profile;
+  const foreign = await detectForeignOwnership(plan.dataDirHost, identity.uid, 5);
+  if (foreign.length > 0) {
+    throw new GamecrateError(`${foreign.length} path(s) under ${plan.dataDirHost} are not owned by uid ${identity.uid}`, Exit.Environment, `${foreign.join(`
+`)}
+run: gamecrate fix-perms ${game2} ${profile2}`);
+  }
+  const runDir = openRunLog(plan.logsDirHost);
+  plan.runDirHost = runDir;
+  await buildLocalMods(plan, args.build ?? "auto");
+  await acquireImage(game2, config.games[game2], args.pull ?? "missing");
+  const runtimeImage = plan.mode === "headed" ? config.games[game2].image.ref : await ensureRuntimeLayer(config.games[game2].image.ref);
+  const modMounts = await stageMods(plan);
+  await generateModsConfig(plan);
+  await mergePrefs(plan);
+  for (const warning of planWarnings(plan))
+    warn(warning);
+  const spec = buildRunSpec(plan, modMounts, identity);
+  spec.image = runtimeImage;
+  if (asShell) {
+    spec.command = ["/bin/bash"];
+    spec.extraArgs = [...spec.extraArgs, "--interactive", "--tty"];
+  }
+  await writeLaunchRecord(plan, spec.image);
+  try {
+    if (plan.marker !== undefined && !asShell)
+      return await runWithMarker(spec, plan, runDir);
+    if (plan.mode === "screenshot" && !asShell)
+      return await runWithScreenshot(spec, plan, runDir);
+    if (plan.mode !== "headed" && !asShell)
+      return await runBounded(spec, plan, runDir);
+    let windowClosed = false;
+    const window = asShell || plan.settings.display !== "x11" ? null : await adoptNewWindow({
+      executable: plan.gameConfig.executable,
+      title: windowTitle(plan),
+      stripDelete: plan.gameConfig.ignoresWmDelete === true,
+      onClosed: () => {
+        windowClosed = true;
+        stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
+      }
+    });
+    try {
+      const code = await runContainer(spec, {
+        logDir: runDir,
+        stopTimeoutSeconds: STOP_TIMEOUT_SECONDS
+      });
+      return windowClosed ? Exit.Ok : normalize(code);
+    } finally {
+      window?.stop();
+    }
+  } finally {
+    await copyOutLogs(plan);
+  }
+}
+function markerSources(plan, logDir) {
+  const sources = [join14(logDir, STDOUT_LOG)];
+  const { logFile } = plan.gameConfig;
+  if (logFile.mode === "arg")
+    sources.push(join14(logDir, "Player.log"));
+  else
+    sources.push(join14(plan.dataDirHost, logFile.from));
+  return sources;
+}
+async function runBounded(spec, plan, logDir) {
+  const container = runContainer(spec, { logDir, stopTimeoutSeconds: STOP_TIMEOUT_SECONDS });
+  const winner = await Promise.race([
+    container.then((code) => ({ kind: "exit", code })),
+    sleep4(plan.timeoutSeconds * 1000).then(() => ({ kind: "timeout" }))
+  ]);
+  if (winner.kind === "exit")
+    return normalize(winner.code);
+  status(`no marker given; stopping after ${plan.timeoutSeconds}s`);
+  await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
+  await container;
+  return Exit.Ok;
+}
+async function runWithScreenshot(spec, plan, logDir) {
+  const container = runContainer(spec, { logDir, stopTimeoutSeconds: STOP_TIMEOUT_SECONDS });
+  const settled = sleep4(plan.renderWaitSeconds * 1000).then(() => "ready");
+  const winner = await Promise.race([
+    container.then((code) => ({ kind: "exit", code })),
+    settled.then(() => ({ kind: "ready" }))
+  ]);
+  if (winner.kind === "exit") {
+    status(`game exited before the ${plan.renderWaitSeconds}s render wait finished; no frame captured`);
+    return normalize(winner.code);
+  }
+  const shot = await grabFrame(spec.name, plan);
+  await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
+  await container;
+  return shot === null ? Exit.Environment : Exit.Ok;
+}
+async function grabFrame(container, plan) {
+  const path = await captureScreenshot(container, plan);
+  if (path === null)
+    warn("screenshot capture failed; is imagemagick in the image?");
+  else
+    status(`screenshot: ${path}`);
+  return path;
+}
+async function runWithMarker(spec, plan, logDir) {
+  const marker = plan.marker;
+  const container = runContainer(spec, { logDir, stopTimeoutSeconds: STOP_TIMEOUT_SECONDS });
+  const seen = waitForMarker(markerSources(plan, logDir), marker, plan.timeoutSeconds);
+  const winner = await Promise.race([
+    container.then((code) => ({ kind: "exit", code })),
+    seen.then((hit) => ({ kind: "marker", hit }))
+  ]);
+  if (winner.kind === "exit")
+    return normalize(winner.code);
+  if (plan.mode === "screenshot")
+    await grabFrame(spec.name, plan);
+  await stopContainer(spec.name, STOP_TIMEOUT_SECONDS);
+  await container;
+  if (winner.hit) {
+    status(`marker seen: ${marker}`);
+    return Exit.Ok;
+  }
+  status(`marker "${marker}" not seen within ${plan.timeoutSeconds}s`);
+  return Exit.MarkerTimeout;
+}
+function normalize(code) {
+  return Number.isInteger(code) && code >= 0 && code <= 255 ? code : Exit.GameFailed;
+}
+async function copyOutLogs(plan) {
+  const spec = plan.gameConfig.logFile;
+  if (spec.mode !== "copy-out")
+    return;
+  const source = join14(plan.dataDirHost, spec.from);
+  if (!existsSync7(source))
+    return;
+  const target = join14(plan.runDirHost, basename7(spec.from.replace(/\/+$/, "")));
+  try {
+    await cp(source, target, { recursive: true, force: true });
+  } catch (error) {
+    warn(`could not copy ${source}: ${describe(error)}`);
+  }
+}
+function list(args, config) {
+  const games = args.game === undefined ? Object.keys(config.games) : [requireGame(args, config)];
+  if (args.json) {
+    const payload = games.map((name) => {
+      const game2 = config.games[name];
+      return {
+        game: name,
+        core: game2.core,
+        dlc: game2.dlc,
+        modes: game2.modes,
+        profiles: Object.entries(game2.profiles).map(([profile2, spec]) => ({
+          profile: profile2,
+          alias: spec.alias ?? null,
+          extends: spec.extends ?? null,
+          mods: spec.mods?.length ?? 0,
+          instances: Object.keys(spec.instances ?? {})
+        }))
+      };
+    });
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return Exit.Ok;
+  }
+  const out = [];
+  for (const name of games) {
+    const game2 = config.games[name];
+    const width = Math.max(7, ...Object.keys(game2.profiles).map((n) => n.length));
+    out.push(`${name}  (${game2.modes.join(", ")})`);
+    out.push(`  ${"modless".padEnd(width)}  built-in: core + official DLC`);
+    for (const [profile2, spec] of Object.entries(game2.profiles)) {
+      const notes = [];
+      if (spec.alias)
+        notes.push(`alias for ${spec.alias}`);
+      if (spec.extends)
+        notes.push(`extends ${spec.extends}`);
+      const count = spec.mods?.length ?? 0;
+      if (!spec.alias)
+        notes.push(count === 1 ? "1 entry" : `${count} entries`);
+      if (spec.aliases?.length)
+        notes.push(`aka ${spec.aliases.join(", ")}`);
+      out.push(`  ${profile2.padEnd(width)}  ${notes.join(", ")}`);
+      const instances = Object.keys(spec.instances ?? {});
+      if (instances.length > 0)
+        out.push(`  ${" ".repeat(width)}  instances: ${instances.join(", ")}`);
+    }
+  }
+  process.stdout.write(`${out.join(`
+`)}
+`);
+  return Exit.Ok;
+}
+async function mods(args, config, plugins) {
+  const game2 = requireGame(args, config);
+  const profile2 = args.profile ?? "modless";
+  const index = await buildIndex(game2, config.games[game2], requirePlugin(plugins, game2));
+  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args, index });
+  if (problems.length > 0)
+    reportProblems(problems);
+  printPlan(plan, args.json);
+  return Exit.Ok;
+}
+async function doctor(config, plugins) {
+  let failed = false;
+  for (const game2 of Object.keys(config.games)) {
+    const { plan, problems } = await resolvePlan({ game: game2, profile: "modless", root: config, plugins });
+    const all = [...problems, ...await preflight(plan)];
+    if (all.length === 0) {
+      status(`${game2}: ok`);
+      continue;
+    }
+    failed = true;
+    status(`${game2}: ${all.length} problem(s)`);
+    for (const problem of all) {
+      process.stderr.write(`  ${problem.where}
+    ${problem.message}
+`);
+      if (problem.suggestion)
+        process.stderr.write(`      try: ${problem.suggestion}
+`);
+    }
+  }
+  return failed ? Exit.Environment : Exit.Ok;
+}
+async function logs(args, config) {
+  const game2 = requireGame(args, config);
+  const profile2 = args.profile ?? "modless";
+  const runs = join14(instanceDir(args, config, game2, profile2), "logs", "runs");
+  const latest = (await readdir8(runs, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+  if (latest === undefined) {
+    throw new GamecrateError(`no runs recorded for ${game2} ${profile2}`, Exit.Usage, runs);
+  }
+  const dir = join14(runs, latest);
+  const files = (await readdir8(dir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify({ run: latest, dir, files }, null, 2)}
+`);
+    return Exit.Ok;
+  }
+  status(dir);
+  for (const name of files) {
+    const text = await readFile5(join14(dir, name), "utf8").catch(() => "");
+    for (const line2 of text.split(`
+`)) {
+      if (line2.length > 0)
+        process.stdout.write(`${name}: ${line2}
+`);
+    }
+  }
+  return Exit.Ok;
+}
+async function inspectContainer(name) {
+  const { code, stdout: text } = await capture(["docker", "inspect", name]);
+  if (code !== 0)
+    return null;
+  let first;
+  try {
+    first = JSON.parse(text)[0];
+  } catch {
+    return null;
+  }
+  if (first === undefined)
+    return null;
+  const startedAt = Date.parse(first.State?.StartedAt ?? "");
+  return {
+    running: first.State?.Running === true,
+    startedAt: Number.isNaN(startedAt) ? Date.now() : startedAt,
+    mounts: (first.Mounts ?? []).filter((m) => m.Source !== undefined && m.Destination !== undefined).map((m) => ({ source: m.Source, destination: m.Destination }))
+  };
+}
+function boundStatus(mod) {
+  if (mod.report !== null) {
+    const files = mod.report.newerCount === 1 ? "1 source" : `${mod.report.newerCount} sources`;
+    return `STALE - ${files} newer`;
+  }
+  if (mod.assembly !== null)
+    return "OK";
+  return mod.hasSources ? "STALE - never built" : "(xml only)";
+}
+async function verify(args, config, plugins) {
+  const game2 = requireGame(args, config);
+  const profile2 = args.profile ?? "modless";
+  const { plan, problems } = await resolvePlan({ game: game2, profile: profile2, root: config, plugins, args });
+  if (problems.length > 0)
+    reportProblems(problems);
+  const name = containerName(plan);
+  const info = await inspectContainer(name);
+  if (info === null || !info.running) {
+    throw new GamecrateError(`no container named ${name} is running`, Exit.Environment, "launch it first, or name the run with --instance or --worktree");
+  }
+  const prefix = `${plan.gameConfig.modsDir.container}/`;
+  const bound = info.mounts.filter((m) => m.destination.startsWith(prefix)).filter((m) => !m.destination.slice(prefix.length).includes("/")).sort((a, b) => a.destination < b.destination ? -1 : 1);
+  const boundMods = await Promise.all(bound.map(async (mount) => {
+    const times = await scanBuildTimes(mount.source);
+    const request = resolveWorktree(mount.source, "ref", 0);
+    return {
+      packageId: mount.destination.slice(prefix.length),
+      hostDir: mount.source,
+      branch: "root" in request ? request.branch : null,
+      assembly: times.newestAssembly ?? null,
+      hasSources: times.newestSource !== undefined,
+      stale: decideStale(times),
+      report: staleReport(times)
+    };
+  }));
+  const stale = boundMods.filter((mod) => mod.stale);
+  if (args.json) {
+    const payload = {
+      container: name,
+      running: true,
+      upSeconds: Math.round((Date.now() - info.startedAt) / 1000),
+      instance: plan.instance ?? plan.profile,
+      stale: stale.length,
+      mods: boundMods.map((mod) => ({
+        packageId: mod.packageId,
+        hostDir: mod.hostDir,
+        branch: mod.branch,
+        assembly: mod.assembly?.path ?? null,
+        assemblyMs: mod.assembly?.mtimeMs ?? null,
+        stale: mod.stale,
+        status: boundStatus(mod),
+        ...mod.report === null ? {} : { report: mod.report }
+      }))
+    };
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return stale.length > 0 ? Exit.Stale : Exit.Ok;
+  }
+  process.stdout.write(`${renderVerify(name, info, plan, boundMods)}
+`);
+  return stale.length > 0 ? Exit.Stale : Exit.Ok;
+}
+function renderVerify(name, info, plan, boundMods) {
+  const out = [
+    "",
+    `  container   ${name} (up ${duration(Date.now() - info.startedAt)})`,
+    `  instance    ${plan.instance ?? plan.profile}`,
+    ""
+  ];
+  if (boundMods.length === 0) {
+    out.push("  no boundMods are bind-mounted into this container");
+    return out.join(`
+`);
+  }
+  const paths = boundMods.map((mod) => shortenHome(mod.hostDir));
+  const idWidth = Math.max(...boundMods.map((mod) => mod.packageId.length));
+  const pathWidth = Math.max(...paths.map((p) => p.length));
+  const stamps = boundMods.map((mod) => mod.assembly === null ? "no assemblies" : `${mod.assembly.path}  ${ago(mod.assembly.mtimeMs)}`);
+  const stampWidth = Math.max(...stamps.map((s) => s.length));
+  for (const [i, mod] of boundMods.entries()) {
+    const origin2 = mod.branch === null ? "" : `worktree ${mod.branch}`;
+    out.push(`  ${mod.packageId.padEnd(idWidth)}  ${paths[i].padEnd(pathWidth)} ${origin2}`.trimEnd());
+    out.push(`  ${" ".repeat(idWidth)}  ${stamps[i].padEnd(stampWidth)}   ${boundStatus(mod)}`);
+  }
+  return out.join(`
+`);
+}
+function shortenHome(path) {
+  const home = homedir5();
+  return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path;
+}
+async function clean(args, config) {
+  const game2 = requireGame(args, config);
+  const profile2 = args.profile;
+  if (profile2 === undefined)
+    throw new GamecrateError("clean needs a profile", Exit.Usage);
+  const dir = profileDataDir(config, game2, profile2);
+  const tier2 = args.cleanTier ?? "staging";
+  const saveSuffixes = config.games[game2].saveExtensions.map((ext) => `.${ext.replace(/^\./, "")}`.toLowerCase());
+  if (tier2 !== "all") {
+    const target = join14(instanceDir(args, config, game2, profile2), tier2 === "logs" ? "logs" : ".stage");
+    await rm2(target, { recursive: true, force: true });
+    status(`removed ${target}`);
+    return Exit.Ok;
+  }
+  const saves = await countSaves(dir, saveSuffixes);
+  if (!args.yes) {
+    throw new GamecrateError(`clean --all would delete ${dir}, including ${saves} save file(s)`, Exit.Usage, "add --yes to confirm");
+  }
+  await rm2(dir, { recursive: true, force: true });
+  status(`removed ${dir} (${saves} save file(s))`);
+  return Exit.Ok;
+}
+async function countSaves(dir, suffixes) {
+  let count = 0;
+  const queue = [dir];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    let entries;
+    try {
+      entries = await readdir8(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory())
+        queue.push(join14(current, entry.name));
+      else if (suffixes.some((s) => entry.name.toLowerCase().endsWith(s)))
+        count++;
+    }
+  }
+  return count;
+}
+async function clone(args, config) {
+  const game2 = requireGame(args, config);
+  const [src, dst] = args.rest;
+  if (src === undefined || dst === undefined) {
+    throw new GamecrateError("clone needs a source and a destination profile", Exit.Usage);
+  }
+  const from = join14(profileDataDir(config, game2, src), "game");
+  const to = join14(profileDataDir(config, game2, dst), "game");
+  if (!existsSync7(from))
+    throw new GamecrateError(`${from} does not exist`, Exit.Usage);
+  if (existsSync7(to) && !args.yes) {
+    throw new GamecrateError(`${to} already exists`, Exit.Usage, "add --yes to overwrite");
+  }
+  await mkdir4(to, { recursive: true });
+  const code = await spawnStatus(["cp", "-a", "--reflink=auto", `${from}/.`, to]);
+  if (code !== 0)
+    throw new GamecrateError(`cp failed with exit ${code}`, Exit.Environment);
+  status(`cloned ${from} -> ${to}`);
+  return Exit.Ok;
+}
+async function build(args, config) {
+  const game2 = requireGame(args, config);
+  await acquireImage(game2, config.games[game2], args.pull ?? "always");
+  status(`${config.games[game2].image.ref} is ready`);
+  return Exit.Ok;
+}
+async function configEdit(args) {
+  if (args.rest[0] !== "edit")
+    throw new GamecrateError("config takes one word: edit", Exit.Usage);
+  const path = defaultConfigPath();
+  await mkdir4(dirname5(path), { recursive: true });
+  if (!existsSync7(path))
+    await writeFile4(path, `{
+  "games": {}
+}
+`);
+  const editor = process.env.VISUAL ?? process.env.EDITOR;
+  if (editor === undefined)
+    throw new GamecrateError("no $EDITOR or $VISUAL set", Exit.Usage, path);
+  if (await spawnStatus([...editor.split(" "), path], true) !== 0)
+    return Exit.Usage;
+  await loadConfig(path);
+  status(`${path} is valid`);
+  return Exit.Ok;
+}
+async function fixPerms(args, config) {
+  const game2 = requireGame(args, config);
+  const identity = resolveIdentity(false);
+  const found = [];
+  for (const dir of await profileDirs(config, game2, args.profile)) {
+    if (!existsSync7(dir))
+      continue;
+    found.push(...await detectForeignOwnership(dir, identity.uid, 1e4));
+  }
+  if (found.length === 0) {
+    status(`${game2}: every path is owned by uid ${identity.uid}`);
+    return Exit.Ok;
+  }
+  if (args.dryRun || !args.yes) {
+    for (const path of found)
+      process.stdout.write(`would chown ${identity.uid}:${identity.gid} ${path}
+`);
+    status(`${found.length} foreign-owned path(s); re-run with --yes to chown them`);
+    return Exit.Environment;
+  }
+  let fixed = 0;
+  const stuck = [];
+  for (const path of found) {
+    const chowned = await chown(path, identity.uid, identity.gid).then(() => true, () => false);
+    if (chowned) {
+      fixed += 1;
+      continue;
+    }
+    if (await removeIfEmptyDir(path)) {
+      status(`removed empty ${path}; it will be recreated on the next run`);
+      fixed += 1;
+      continue;
+    }
+    stuck.push(path);
+  }
+  if (fixed > 0)
+    status(`fixed ${fixed} path(s) for ${identity.uid}:${identity.gid}`);
+  if (stuck.length > 0) {
+    for (const path of stuck)
+      warn(`cannot chown ${path}`);
+    throw new GamecrateError(`${stuck.length} path(s) still not owned by uid ${identity.uid}`, Exit.Environment, `sudo chown -R ${identity.uid}:${identity.gid} ${stuck.join(" ")}`);
+  }
+  return Exit.Ok;
+}
+async function removeIfEmptyDir(path) {
+  const info = await stat4(path).catch(() => null);
+  if (info === null || !info.isDirectory())
+    return false;
+  const entries = await readdir8(path).catch(() => null);
+  if (entries === null || entries.length > 0)
+    return false;
+  return rmdir(path).then(() => true, () => false);
+}
+async function spawnStatus(argv, interactive = false) {
+  const proc = spawnArgv(argv, [interactive ? "inherit" : "ignore", "inherit", "inherit"]);
+  return exited(proc);
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function reportFatal(error) {
+  if (error instanceof GamecrateError) {
+    process.stderr.write(`gamecrate: ${error.message}
+`);
+    if (error.detail)
+      process.stderr.write(`${error.detail}
+`);
+    return error.code;
+  }
+  process.stderr.write(`gamecrate: ${describe(error)}
+`);
+  return Exit.GameFailed;
+}
+try {
+  process.exit(await main(process.argv.slice(2)));
+} catch (error) {
+  process.exit(reportFatal(error));
+}