gemwright 0.0.0-stage → 0.1.3

package/dist/index.js

@@ -0,0 +1,1686 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { parseArgs } from "node:util";
+import chalk from "chalk";
+
+// src/deploy.ts
+import { randomUUID } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile6, rename, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join7, resolve as resolve2 } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// src/emulators/servuo/staging.ts
+import { cp, mkdir, readFile as readFile2, rm as rm2, stat } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// src/assets.ts
+import { fileURLToPath } from "node:url";
+function assetPath(path) {
+  return fileURLToPath(new URL(`../${path}`, import.meta.url));
+}
+
+// src/process.ts
+import { spawn } from "node:child_process";
+function runCommand(args, cwd = process.cwd()) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(args[0], args.slice(1), { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve({
+      code: code ?? 1,
+      stdout: stdout.trim(),
+      stderr: stderr.trim() || (signal ? `Terminated by ${signal}` : "")
+    }));
+  });
+}
+async function command(args, cwd) {
+  const { code, stdout, stderr } = await runCommand(args, cwd);
+  if (code !== 0)
+    throw new Error(`${args[0]} ${args[1] ?? ""} failed: ${stderr || stdout}`);
+  return stdout;
+}
+async function isAvailable(executable) {
+  try {
+    return (await runCommand([executable, "--version"])).code === 0;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+
+// src/emulators/client-files.ts
+import { createHash } from "node:crypto";
+import { createReadStream, existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+async function packageClientFiles(directory, sourcePath, pattern, validate) {
+  const source = resolve(sourcePath);
+  const names = (await readdir(source, { withFileTypes: true })).filter((entry) => entry.isFile() && pattern.test(entry.name)).map((entry) => entry.name).sort();
+  validate(names.map((name) => name.toLowerCase()));
+  const hash = createHash("sha256");
+  let bytes = 0;
+  for (const name of names) {
+    hash.update(name + "\x00");
+    for await (const chunk of createReadStream(join(source, name))) {
+      hash.update(chunk);
+      bytes += chunk.length;
+    }
+  }
+  const digest = hash.digest("hex");
+  const archive = join(directory, ".gemwright", `client-${digest}.tar.gz`);
+  if (!existsSync(archive))
+    await command(["tar", "--no-xattrs", "-czf", archive, "-C", source, ...names], directory);
+  return { archive, digest, bytes };
+}
+
+// src/emulators/servuo/config.ts
+import { createHash as createHash2 } from "node:crypto";
+import { mkdtemp, readdir as readdir2, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/emulators/accounts.ts
+import { randomBytes } from "node:crypto";
+function validateOwner(value) {
+  if (!/^[A-Za-z0-9_-]{1,16}$/.test(value))
+    return "Use 1-16 letters, numbers, underscores or hyphens.";
+}
+function validateOwnerPassword(value) {
+  if (value !== "" && !/^[\x20-\x7e]{8,16}$/.test(value))
+    return "Use 8-16 printable ASCII characters, or leave blank to generate a password.";
+}
+function generatedOwnerPassword() {
+  return randomBytes(12).toString("base64url");
+}
+
+// src/emulators/servuo/config.ts
+async function fetchServuoConfig(source) {
+  if (!/^[a-f0-9]{40}$/.test(source.revision))
+    throw new Error("Invalid ServUO source revision.");
+  const temporary = await mkdtemp(join2(tmpdir(), "gemwright-config-"));
+  try {
+    const response = await fetch(`https://codeload.github.com/ServUO/ServUO/tar.gz/${source.revision}`, {
+      signal: AbortSignal.timeout(60000)
+    });
+    if (!response.ok)
+      throw new Error(`Could not fetch ServUO config: HTTP ${response.status}`);
+    const archive = join2(temporary, "source.tar.gz");
+    await writeFile(archive, new Uint8Array(await response.arrayBuffer()));
+    await command(["tar", "-xzf", archive, "-C", temporary, "--strip-components=1", `ServUO-${source.revision}/Config`], temporary);
+    const files = {};
+    for (const entry of await readdir2(join2(temporary, "Config"), { withFileTypes: true })) {
+      if (!entry.isFile())
+        throw new Error(`Unsupported entry in upstream Config: ${entry.name}`);
+      files[`Config/${entry.name}`] = await readFile(join2(temporary, "Config", entry.name), "utf8");
+    }
+    return files;
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+function configValue(text, key) {
+  return text.split(/\r?\n/).find((line) => line.startsWith(`${key}=`))?.slice(key.length + 1).trim();
+}
+function setConfigValue(text, key, value) {
+  const newline = text.includes(`\r
+`) ? `\r
+` : `
+`;
+  let found = false;
+  const lines = text.split(/\r?\n/).map((line) => {
+    if (line.startsWith(`${key}=`) || line.startsWith(`@${key}=`) || line.startsWith(`#${key}=`)) {
+      if (found)
+        throw new Error(`Duplicate upstream config key: ${key}`);
+      found = true;
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (!found)
+    throw new Error(`Upstream ServUO config key is missing: ${key}. No files were written.`);
+  return lines.join(newline);
+}
+var expansionNames = {
+  base: "None",
+  t2a: "T2A",
+  uor: "UOR",
+  td: "UOTD",
+  lbr: "LBR",
+  aos: "AOS",
+  se: "SE",
+  ml: "ML",
+  sa: "SA",
+  hs: "HS",
+  tol: "TOL",
+  ej: "EJ"
+};
+function prepareServuoFiles(upstream, config, settings, password) {
+  for (const filename of ["Server", "Expansion", "Accounts", "DataPath"]) {
+    if (typeof upstream[`Config/${filename}.cfg`] !== "string")
+      throw new Error(`Missing upstream Config/${filename}.cfg`);
+  }
+  if (validateOwner(settings.owner))
+    throw new Error(validateOwner(settings.owner));
+  if (!password || validateOwnerPassword(password))
+    throw new Error("Invalid owner password.");
+  const files = { ...upstream };
+  if (config.adminEmail !== undefined)
+    files["Config/General.cfg"] = setConfigValue(files["Config/General.cfg"] ?? "", "SupportEmail", config.adminEmail);
+  if (config.url !== undefined)
+    files["Config/General.cfg"] = setConfigValue(files["Config/General.cfg"] ?? "", "SupportWebsite", config.url);
+  files["Config/Server.cfg"] = setConfigValue(files["Config/Server.cfg"], "Name", config.name);
+  files["Config/Expansion.cfg"] = setConfigValue(files["Config/Expansion.cfg"], "CurrentExpansion", expansionNames[config.expansion]);
+  files["Config/DataPath.cfg"] = setConfigValue(files["Config/DataPath.cfg"], "CustomPath", "data/client");
+  files["Config/Accounts.cfg"] = setConfigValue(files["Config/Accounts.cfg"], "AutoCreateAccounts", settings.autoCreateAccounts ? "True" : "False");
+  const protection = configValue(files["Config/Accounts.cfg"], "ProtectPasswords");
+  const hashes = {
+    Crypt: { algorithm: "md5", element: "cryptPassword", input: password },
+    NewCrypt: { algorithm: "sha1", element: "newCryptPassword", input: settings.owner + password },
+    NewSecureCrypt: { algorithm: "sha512", element: "newSecureCryptPassword", input: settings.owner + password }
+  };
+  const hash = protection ? hashes[protection] : undefined;
+  if (!hash)
+    throw new Error(`Unsupported upstream password protection: ${protection}. No files were written.`);
+  const digest = createHash2(hash.algorithm).update(hash.input, "ascii").digest("hex").toUpperCase().match(/../g).join("-");
+  files["Saves/Accounts/accounts.xml"] = `<?xml version="1.0" encoding="utf-8"?>
+<accounts count="1">
+  <account>
+    <username>${settings.owner}</username>
+    <${hash.element}>${digest}</${hash.element}>
+    <accessLevel>Owner</accessLevel>
+  </account>
+</accounts>
+`;
+  files[".gitignore"] = `Saves/
+Backups/
+Logs/
+data/client/
+.gemwright/
+`;
+  return files;
+}
+
+// src/emulators/compatibility.ts
+function git(directory, args) {
+  return runCommand(["git", "-C", directory, ...args]);
+}
+async function applyCompatibility(directory, expectedRevision, patch, emulator) {
+  if (!/^[a-f0-9]{40}$/.test(expectedRevision))
+    throw new Error(`Invalid recorded ${emulator} revision. No patch was applied.`);
+  const revision = await git(directory, ["rev-parse", "HEAD"]);
+  if (revision.code !== 0 || revision.stdout !== expectedRevision) {
+    throw new Error(`${emulator} compatibility requires revision ${expectedRevision}. No patch was applied.`);
+  }
+  const reverse = await git(directory, ["apply", "--reverse", "--check", patch]);
+  if (reverse.code === 0)
+    return "already-applied";
+  const check = await git(directory, ["apply", "--check", patch]);
+  if (check.code !== 0) {
+    throw new Error(`${emulator} compatibility patch does not apply cleanly to recorded revision ${expectedRevision}. No patch was applied.
+${check.stderr}`);
+  }
+  const result = await git(directory, ["apply", patch]);
+  if (result.code !== 0)
+    throw new Error(`Failed to apply ${emulator} compatibility patch: ${result.stderr}`);
+  return "applied";
+}
+
+// src/emulators/servuo/source.ts
+var servuoSource = {
+  repository: "https://github.com/ServUO/ServUO.git",
+  ref: "pub57",
+  patch: assetPath("patches/servuo-pub57-hosting.patch")
+};
+async function resolveLatestServuoSource(fetcher = fetch) {
+  try {
+    const response = await fetcher(`https://api.github.com/repos/ServUO/ServUO/commits/${servuoSource.ref}`, {
+      headers: { Accept: "application/vnd.github+json", "User-Agent": "gemwright" },
+      signal: AbortSignal.timeout(15000)
+    });
+    if (!response.ok)
+      throw new Error(`GitHub returned HTTP ${response.status}`);
+    const result = await response.json();
+    if (!result || typeof result !== "object" || !("sha" in result) || typeof result.sha !== "string" || !/^[a-f0-9]{40}$/.test(result.sha)) {
+      throw new Error("GitHub returned an invalid commit revision");
+    }
+    return { repository: servuoSource.repository, ref: servuoSource.ref, revision: result.sha };
+  } catch (error) {
+    throw new Error(`Could not resolve the latest ServUO ${servuoSource.ref} revision. Check your connection and retry. ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function applyServuoCompatibility(directory, expectedRevision) {
+  return applyCompatibility(directory, expectedRevision, servuoSource.patch, "ServUO");
+}
+
+// src/emulators/servuo/staging.ts
+async function validateServuoShard(directory, config) {
+  if (!config.source || config.source.repository !== servuoSource.repository || config.source.ref !== servuoSource.ref) {
+    throw new Error("Missing or unsupported ServUO source. Initialize a new shard to record its source revision.");
+  }
+  const server = await readFile2(join3(directory, "Config/Server.cfg"), "utf8");
+  if (configValue(server, "Port") !== "2593" || configValue(server, "Listen") !== "0.0.0.0") {
+    throw new Error("Railway deployment currently requires Server.cfg Listen=0.0.0.0 and Port=2593. Config was not changed.");
+  }
+  const data = await readFile2(join3(directory, "Config/DataPath.cfg"), "utf8");
+  if (configValue(data, "CustomPath") !== "data/client")
+    throw new Error("Deployment currently supports DataPath.cfg CustomPath=data/client. Config was not changed.");
+  const restart = await readFile2(join3(directory, "Config/AutoRestart.cfg"), "utf8").catch(() => "Enabled=False");
+  if (configValue(restart, "Enabled")?.toLowerCase() === "true") {
+    throw new Error("ServUO self-restarts are not supported by the container startup wrapper yet. Config was not changed.");
+  }
+}
+async function stageServuo(directory, config) {
+  const context = join3(directory, ".gemwright/deploy");
+  await rm2(context, { recursive: true, force: true });
+  const server = join3(context, "server");
+  await mkdir(server, { recursive: true });
+  await command(["git", "init", "--quiet"], server);
+  await command(["git", "fetch", "--quiet", "--depth", "1", config.source.repository, config.source.revision], server);
+  await command(["git", "checkout", "--quiet", "--detach", "FETCH_HEAD"], server);
+  await applyServuoCompatibility(server, config.source.revision);
+  await rm2(join3(server, ".git"), { recursive: true, force: true });
+  await rm2(join3(server, "Config"), { recursive: true, force: true });
+  await cp(join3(directory, "Config"), join3(server, "Config"), { recursive: true });
+  for (const folder of ["Scripts", "Data"]) {
+    if ((await stat(join3(directory, folder)).catch(() => {
+      return;
+    }))?.isDirectory())
+      await cp(join3(directory, folder), join3(server, folder), { recursive: true });
+  }
+  await cp(join3(directory, "Saves"), join3(context, "seed/Saves"), { recursive: true });
+  for (const [source, target] of [
+    ["Dockerfile", "Dockerfile"],
+    ["railway-start.sh", "start.sh"],
+    ["start.sh", "run-server.sh"]
+  ]) {
+    await cp(assetPath(`templates/servuo/${source}`), join3(context, target));
+  }
+  return context;
+}
+var clientPattern = /^(?:map[0-5](?:LegacyMUL\.uop|\.mul)|statics[0-5]\.mul|staidx[0-5]\.mul|(?:mapdif|mapdifl|stadif|stadifl|stadifi)[0-5]\.mul|multi\.(?:idx|mul)|MultiCollection\.uop|tiledata\.mul|verdata\.mul)$/i;
+function packageClientFiles2(directory, sourcePath) {
+  return packageClientFiles(directory, sourcePath, clientPattern, (lower) => {
+    if (!lower.includes("tiledata.mul") || !(lower.includes("map0.mul") || lower.includes("map0legacymul.uop")))
+      throw new Error("Client files must include tiledata.mul and map0.mul or map0LegacyMUL.uop.");
+  });
+}
+
+// src/emulators/sphere/staging.ts
+import { cp as cp2, mkdir as mkdir2, readFile as readFile4, rm as rm4, stat as stat2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
+// src/emulators/sphere/config.ts
+import { createHash as createHash3 } from "node:crypto";
+import { mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile3, rm as rm3, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+
+// src/emulators/sphere/rules.ts
+var ruleFlags = {
+  combatFlags: [
+    [1, "Do not turn toward combat targets"],
+    [2, "Require facing the target"],
+    [4, "Instant first melee hit (prehit)"],
+    [8, "Elemental damage and resistances (AOS)"],
+    [16, "Destroy items when maximum durability reaches zero"],
+    [32, "Double-click yourself in combat to dismount"],
+    [64, "Allow attacks from ships"],
+    [128, "Pets stay loyal when attacked by their owner"],
+    [256, "Allow archery while moving"],
+    [512, "Cancel swings when the target leaves range"],
+    [1024, "Retaliate as soon as an attack is noticed"],
+    [2048, "Hide NPC attack announcements"],
+    [4096, "Stack armor coverage"],
+    [8192, "Disable legacy poison-on-hit behavior"]
+  ],
+  magicFlags: [
+    [1, "Do not turn while casting or targeting"],
+    [2, "Precast spells before selecting a target"],
+    [4, "Magic ignores armor rating"],
+    [8, "Allow spells to harm their caster"],
+    [16, "Allow different stat spells to stack"],
+    [32, "Prevent movement while casting"],
+    [64, "Require summoned creatures to be able to walk at their destination"],
+    [128, "Prevent spell fields crossing walls"],
+    [256, "Disable spell animations"],
+    [512, "Use OSI spell damage and duration formulas"],
+    [1024, "Prevent casting while paralyzed with occupied hands"],
+    [2048, "Apply stat changes from polymorph forms"],
+    [4096, "Replace existing field spells on the same tile"]
+  ],
+  racialFlags: [
+    [1, "Human: +60 carrying capacity"],
+    [2, "Human: +2 hit point regeneration"],
+    [4, "Human: gather additional resources"],
+    [8, "Human: minimum 20 skill for untrained abilities"],
+    [16, "Elf: permanent night sight"],
+    [32, "Elf: harder to track while hidden"],
+    [64, "Elf: +20 maximum mana"],
+    [128, "Gargoyle: flight (requires AOS ability book features)"],
+    [256, "Gargoyle: berserk damage bonuses when injured"],
+    [512, "Gargoyle: minimum 20 Throwing skill"],
+    [1024, "Gargoyle: minimum 30 Mysticism skill"]
+  ],
+  revealFlags: [
+    [1, "Reveal when using Detecting Hidden"],
+    [2, "Reveal when looting your own corpse"],
+    [4, "Reveal when looting other corpses"],
+    [8, "Reveal when speaking"],
+    [16, "Reveal when casting spells"]
+  ],
+  npcAI: [
+    [1, "Advanced pathfinding (increases CPU usage)"],
+    [2, "Search for food when hungry"],
+    [4, "Human NPCs equip weapons and night lights"],
+    [8, "Use maximum pathfinding intelligence (requires advanced pathfinding)"],
+    [16, "Intelligent food search"],
+    [64, "Cast helpful spells on allies during combat"],
+    [256, "Loot nearby items and corpses"],
+    [512, "Move items blocking the path when able to use hands"],
+    [1024, "Keep pursuing unreachable targets"],
+    [2048, "Choose combat targets by threat instead of distance"]
+  ]
+};
+function atLeast(expansion, minimum) {
+  return expansions.findIndex((entry) => entry.value === expansion) >= expansions.findIndex((entry) => entry.value === minimum);
+}
+function sphereNumber(value) {
+  if (!/^(?:0[0-9a-fA-F]*|[1-9][0-9]*)(?:\|(?:0[0-9a-fA-F]*|[1-9][0-9]*))*$/.test(value))
+    throw new Error(`Unsupported Sphere numeric expression: ${value}`);
+  return value.split("|").reduce((result, part) => {
+    const number = Number.parseInt(part, part.startsWith("0") ? 16 : 10);
+    if (!Number.isSafeInteger(number) || number > 2147483647)
+      throw new Error(`Sphere numeric expression is out of range: ${value}`);
+    return result | number;
+  }, 0);
+}
+function flagValue(value) {
+  return value ? `0${value.toString(16)}` : "0";
+}
+function validateRules(rules) {
+  for (const key of Object.keys(ruleFlags)) {
+    if (!Number.isInteger(rules[key]) || rules[key] < 0 || rules[key] > 2147483647)
+      throw new Error(`Invalid Sphere ${key}.`);
+  }
+  for (const [key, maximum] of [
+    ["damageEra", 2],
+    ["hitChanceEra", 2],
+    ["speedEra", 4],
+    ["archeryMovementDelay", 2147483647],
+    ["speedScaleFactor", 2147483647]
+  ]) {
+    if (!Number.isInteger(rules[key]) || rules[key] < 0 || rules[key] > maximum || key === "speedScaleFactor" && rules[key] === 0)
+      throw new Error(`Invalid Sphere ${key}.`);
+  }
+  if (rules.npcAI & 8 && !(rules.npcAI & 1))
+    throw new Error("Maximum NPC pathfinding intelligence requires advanced pathfinding.");
+}
+function expansionFlags(expansion, optionFlags, extraFlags) {
+  const options = optionFlags & ~8214 | (atLeast(expansion, "hs") ? 0 : 2) | (atLeast(expansion, "aos") ? 16 : 4) | (atLeast(expansion, "ml") ? 8192 : 0);
+  const extra = extraFlags & ~31 | (atLeast(expansion, "ml") ? 1 : 0) | (atLeast(expansion, "sa") ? 6 : 0) | (atLeast(expansion, "tol") ? 24 : 0);
+  return { OptionFlags: flagValue(options), FeatureExtra: flagValue(extra) };
+}
+
+// src/config.ts
+var expansions = [
+  { value: "base", label: "Base" },
+  { value: "t2a", label: "The Second Age" },
+  { value: "uor", label: "Renaissance" },
+  { value: "td", label: "Third Dawn" },
+  { value: "lbr", label: "Lord Blackthorn's Revenge" },
+  { value: "aos", label: "Age of Shadows" },
+  { value: "se", label: "Samurai Empire" },
+  { value: "ml", label: "Mondain's Legacy" },
+  { value: "sa", label: "Stygian Abyss" },
+  { value: "hs", label: "High Seas" },
+  { value: "tol", label: "Time of Legends" },
+  { value: "ej", label: "Endless Journey" }
+];
+var emulators = [
+  { value: "servuo", label: "ServUO", disabled: false },
+  { value: "sphere", label: "Sphere", disabled: false },
+  { value: "sphere-x", label: "Sphere-X", disabled: true },
+  { value: "runuo", label: "RunUO", disabled: true },
+  { value: "pol", label: "POL", disabled: true }
+];
+var configFilename = "gemwright.json";
+var defaultName = "Gemwright";
+var defaultExpansion = "ej";
+var defaultEmulator = "servuo";
+var acceptedRegions = new Set([
+  "Africa",
+  "America",
+  "Antarctica",
+  "Arctic",
+  "Asia",
+  "Atlantic",
+  "Australia",
+  "Europe",
+  "Indian",
+  "Pacific"
+]);
+function shardId(name) {
+  return (name || defaultName).toLowerCase().replace(/'/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function validateName(name) {
+  if (name !== "" && !/^[\x20-\x7e]{1,32}$/.test(name)) {
+    return "Use 1-32 printable ASCII characters.";
+  }
+}
+function isAcceptedTimezone(zone) {
+  if (!acceptedRegions.has(zone.split("/")[0]))
+    return false;
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: zone });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function timezoneOptions() {
+  const zones = Intl.supportedValuesOf("timeZone").filter(isAcceptedTimezone);
+  const local = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (isAcceptedTimezone(local) && !zones.includes(local))
+    zones.push(local);
+  if (!zones.includes("Europe/London"))
+    zones.push("Europe/London");
+  return zones.sort();
+}
+function defaultTimezone() {
+  const local = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return isAcceptedTimezone(local) ? local : "Europe/London";
+}
+function createConfig(input) {
+  const name = input.name || defaultName;
+  const error = validateName(name);
+  if (error)
+    throw new Error(error);
+  for (const [value, validate] of [
+    [input.adminEmail, validateAdminEmail],
+    [input.url, validateWebsite]
+  ]) {
+    if (value !== undefined) {
+      const error = validate(value);
+      if (error)
+        throw new Error(error);
+    }
+  }
+  const timezone = input.timezone ?? defaultTimezone();
+  if (!isAcceptedTimezone(timezone)) {
+    throw new Error(`Unsupported timezone: ${timezone}. Choose an IANA zone in an accepted region.`);
+  }
+  const expansion = input.expansion ?? defaultExpansion;
+  if (!expansions.some((option) => option.value === expansion)) {
+    throw new Error(`Unknown expansion: ${expansion}. Choose ${expansions.map((option) => option.value).join(", ")}.`);
+  }
+  const emulator = input.emulator ?? defaultEmulator;
+  if (!emulators.some((option) => option.value === emulator && !option.disabled)) {
+    throw new Error(`Unsupported emulator: ${emulator}. Choose servuo or sphere.`);
+  }
+  if (input.source && (!/^[a-f0-9]{40}$/.test(input.source.revision) || !input.source.repository || !input.source.ref)) {
+    throw new Error("Invalid emulator source: repository, ref and a full commit revision are required.");
+  }
+  if (emulator === "sphere" && input.url?.includes("//"))
+    throw new Error("Sphere websites must omit http(s):// and contain no //; use www.example.com.");
+  if (input.sphere) {
+    const settings = input.sphere;
+    if (settings.rules !== undefined)
+      validateRules(settings.rules);
+    if (emulator !== "sphere" || !settings.scriptsSource || !/^[a-f0-9]{40}$/.test(settings.scriptsSource.revision) || !settings.scriptsSource.repository || !settings.scriptsSource.ref || typeof settings.autoCreateAccounts !== "boolean" || !/^[A-Za-z0-9_-]{1,16}$/.test(settings.owner) || !["expansion", "felucca"].includes(settings.maps) || !["modern", "legacy"].includes(settings.mapSize) || settings.clientEncryption !== undefined && !["encrypted", "both", "unencrypted"].includes(settings.clientEncryption) || settings.clientFiles !== undefined && typeof settings.clientFiles !== "string")
+      throw new Error("Invalid Sphere settings or scripts source.");
+  }
+  return {
+    ...input.servuo ? { servuo: { ...input.servuo } } : {},
+    ...input.sphere ? {
+      sphere: {
+        ...input.sphere,
+        ...input.sphere.rules ? { rules: { ...input.sphere.rules } } : {},
+        scriptsSource: { ...input.sphere.scriptsSource }
+      }
+    } : {},
+    ...input.source ? { source: { ...input.source } } : {},
+    ...input.adminEmail !== undefined ? { adminEmail: input.adminEmail } : {},
+    ...input.url !== undefined ? { url: input.url } : {},
+    name,
+    id: shardId(name),
+    timezone,
+    expansion,
+    emulator
+  };
+}
+var defaultAdminEmail = "gemwright@example.com";
+var defaultWebsite = "www.example.com";
+function validateAdminEmail(value) {
+  if (!/^[A-Za-z0-9.!#$%&'*+?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?\.[A-Za-z]{2,}$/.test(value) || value.includes("//"))
+    return "Enter an email address, such as gemwright@example.com.";
+}
+function validateWebsite(value) {
+  if (!/^[\x21-\x7e]+$/.test(value) || /["<>\\]/.test(value))
+    return "Enter a website address without spaces, quotes or backslashes.";
+  try {
+    const url = new URL(/^https?:\/\//i.test(value) ? value : `https://${value}`);
+    if (!["http:", "https:"].includes(url.protocol) || !url.hostname.includes(".") || url.username || url.password)
+      throw new Error;
+  } catch {
+    return "Enter an HTTP(S) website or hostname, such as www.example.com.";
+  }
+}
+
+// src/emulators/sphere/source.ts
+var sphereSources = {
+  server: { repository: "https://github.com/Sphereserver/Source.git", ref: "master" },
+  scripts: { repository: "https://github.com/Sphereserver/Scripts.git", ref: "master" }
+};
+async function resolveLatestSphereSources(fetcher = fetch) {
+  async function resolve(kind) {
+    const source = sphereSources[kind];
+    const repository = kind === "server" ? "Source" : "Scripts";
+    try {
+      const response = await fetcher(`https://api.github.com/repos/Sphereserver/${repository}/commits/${source.ref}`, {
+        headers: { Accept: "application/vnd.github+json", "User-Agent": "gemwright" },
+        signal: AbortSignal.timeout(15000)
+      });
+      if (!response.ok)
+        throw new Error(`GitHub returned HTTP ${response.status}`);
+      const result = await response.json();
+      if (!result || typeof result !== "object" || !("sha" in result) || typeof result.sha !== "string" || !/^[a-f0-9]{40}$/.test(result.sha)) {
+        throw new Error("GitHub returned an invalid commit revision");
+      }
+      return { ...source, revision: result.sha };
+    } catch (error) {
+      throw new Error(`Could not resolve the latest Sphere ${repository} ${source.ref} revision. Check your connection and retry. ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const [server, scripts] = await Promise.all([resolve("server"), resolve("scripts")]);
+  return { server, scripts };
+}
+var spherePatch = assetPath("patches/sphere-hosting.patch");
+function applySphereCompatibility(directory, expectedRevision) {
+  return applyCompatibility(directory, expectedRevision, spherePatch, "Sphere");
+}
+
+// src/emulators/sphere/config.ts
+function validateSphereName(value) {
+  return validateName(value) ?? (/[<>/"\\[\]=]/.test(value) || value.trim() !== value ? 'Sphere names cannot contain < > / " \\ [ ] = or leading/trailing spaces.' : undefined);
+}
+function validateSphereOwner(value) {
+  return validateOwner(value) ?? (/^\d+$/.test(value) || ["EOF", "ACCOUNT", "ADD", "ADDMD5", "BLOCKED", "HELP", "JAILED", "UNUSED", "UPDATE"].includes(value.toUpperCase()) ? "Choose a non-numeric username that is not a reserved Sphere account command." : undefined);
+}
+async function fetchSphereFiles(sources) {
+  for (const kind of ["server", "scripts"]) {
+    const source = sources[kind];
+    if (source.repository !== sphereSources[kind].repository || source.ref !== sphereSources[kind].ref || !/^[a-f0-9]{40}$/.test(source.revision))
+      throw new Error(`Invalid Sphere ${kind} source.`);
+  }
+  const temporary = await mkdtemp2(join4(tmpdir2(), "gemwright-sphere-config-"));
+  try {
+    async function extract(kind) {
+      const repository = kind === "server" ? "Source" : "Scripts";
+      const revision = sources[kind].revision;
+      const response = await fetch(`https://codeload.github.com/Sphereserver/${repository}/tar.gz/${revision}`, {
+        signal: AbortSignal.timeout(60000)
+      });
+      if (!response.ok)
+        throw new Error(`Could not fetch Sphere ${repository}: HTTP ${response.status}`);
+      const archive = join4(temporary, `${kind}.tar.gz`);
+      await writeFile2(archive, new Uint8Array(await response.arrayBuffer()));
+      await command(["tar", "-xzf", archive, "-C", temporary], temporary);
+      return join4(temporary, `${repository}-${revision}`);
+    }
+    const results = await Promise.allSettled([extract("server"), extract("scripts")]);
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure?.status === "rejected")
+      throw failure.reason;
+    const [server, scripts] = results.map((result) => result.value);
+    const files = {};
+    for (const filename of ["sphere.ini", "sphereCrypt.ini"]) {
+      files[filename] = await readFile3(join4(server, "src", filename));
+    }
+    async function readScripts(directory, prefix = "scripts") {
+      for (const entry of await readdir3(directory, { withFileTypes: true })) {
+        const filename = `${prefix}/${entry.name}`;
+        if (entry.isDirectory())
+          await readScripts(join4(directory, entry.name), filename);
+        else if (entry.isFile())
+          files[filename] = await readFile3(join4(directory, entry.name));
+        else
+          throw new Error(`Unsupported Sphere script entry: ${filename}`);
+      }
+    }
+    await readScripts(scripts);
+    return files;
+  } finally {
+    await rm3(temporary, { recursive: true, force: true });
+  }
+}
+function text(files, filename) {
+  const content = files[filename];
+  if (content === undefined)
+    throw new Error(`Missing upstream Sphere file: ${filename}`);
+  return typeof content === "string" ? content : Buffer.from(content).toString("latin1");
+}
+function sphereConfigValue(ini, key) {
+  return ini.split(/\r?\n/).find((line) => line.startsWith(`${key}=`))?.slice(key.length + 1).split("//")[0]?.trim();
+}
+function setValue(ini, key, value) {
+  const lines = ini.split(/\r?\n/);
+  let candidates = lines.flatMap((line, index) => line.startsWith(`${key}=`) ? [index] : []);
+  if (!candidates.length)
+    candidates = lines.flatMap((line, index) => line.startsWith(`//${key}=`) ? [index] : []);
+  if (candidates.length !== 1)
+    throw new Error(`Missing or duplicate upstream Sphere setting: ${key}. No files were written.`);
+  const index = candidates[0];
+  let comment = lines[index].match(/\s+\/\/.*$/)?.[0] ?? "";
+  if (/^Map[01]$/.test(key) && value.startsWith("6144,"))
+    comment = comment.replace("ML size", "Old size");
+  lines[index] = `${key}=${value}${comment}`;
+  return lines.join(ini.includes(`\r
+`) ? `\r
+` : `
+`);
+}
+function sphereMapCount(expansion) {
+  if (atLeast(expansion, "sa"))
+    return 6;
+  if (atLeast(expansion, "se"))
+    return 5;
+  if (atLeast(expansion, "aos"))
+    return 4;
+  if (atLeast(expansion, "td"))
+    return 3;
+  if (atLeast(expansion, "uor"))
+    return 2;
+  return 1;
+}
+function prepareSphereFiles(upstream, config, settings, password) {
+  if (config.url?.includes("//"))
+    throw new Error("Sphere websites must omit http(s):// and contain no //.");
+  const nameError = validateSphereName(config.name);
+  if (nameError)
+    throw new Error(nameError);
+  if (validateSphereOwner(settings.owner))
+    throw new Error(validateSphereOwner(settings.owner));
+  if (!password || validateOwnerPassword(password))
+    throw new Error("Invalid owner password.");
+  if (!["expansion", "felucca"].includes(settings.maps) || !["modern", "legacy"].includes(settings.mapSize))
+    throw new Error("Invalid Sphere map settings.");
+  if (settings.mapSize === "legacy" && atLeast(config.expansion, "ml"))
+    throw new Error("Mondain's Legacy and later require modern map files.");
+  let ini = text(upstream, "sphere.ini");
+  text(upstream, "sphereCrypt.ini");
+  const updates = {
+    ServName: config.name,
+    TimeZone: String(sphereTimezone(config.timezone)),
+    ...config.adminEmail !== undefined ? { AdminEmail: config.adminEmail } : {},
+    ...config.url !== undefined ? { URL: config.url } : {},
+    ScpFiles: "scripts/",
+    WorldSave: "save/",
+    AcctFiles: "accounts/",
+    MulFiles: "data/client/",
+    Log: "logs/",
+    AutoAccountCreation: settings.autoCreateAccounts ? "1" : "0",
+    Md5Passwords: "1"
+  };
+  if (settings.clientEncryption !== undefined) {
+    if (!["encrypted", "both", "unencrypted"].includes(settings.clientEncryption))
+      throw new Error("Invalid Sphere client encryption mode.");
+    updates.UseCrypt = settings.clientEncryption === "unencrypted" ? "0" : "1";
+    updates.UseNoCrypt = settings.clientEncryption === "encrypted" ? "0" : "1";
+  }
+  const optionFlags = sphereConfigValue(ini, "OptionFlags");
+  const extraFlags = sphereConfigValue(ini, "FeatureExtra");
+  if (optionFlags === undefined || extraFlags === undefined)
+    throw new Error("Missing upstream Sphere option or extra feature flags.");
+  Object.assign(updates, expansionFlags(config.expansion, sphereNumber(optionFlags), sphereNumber(extraFlags)));
+  if (settings.rules) {
+    const rules = settings.rules;
+    validateRules(rules);
+    Object.assign(updates, {
+      CombatFlags: flagValue(rules.combatFlags),
+      CombatArcheryMovementDelay: String(rules.archeryMovementDelay),
+      CombatDamageEra: String(rules.damageEra),
+      CombatHitChanceEra: String(rules.hitChanceEra),
+      CombatSpeedEra: String(rules.speedEra),
+      SpeedScaleFactor: String(rules.speedScaleFactor),
+      MagicFlags: flagValue(rules.magicFlags),
+      RacialFlags: flagValue(rules.racialFlags),
+      RevealFlags: flagValue(rules.revealFlags),
+      NPCAI: flagValue(rules.npcAI)
+    });
+  }
+  for (const [key, expansion, value] of [
+    ["FeatureT2A", "t2a", "01|02"],
+    ["FeatureLBR", "lbr", "01|02"],
+    ["FeatureAOS", "aos", "01|02|04|08"],
+    ["FeatureSE", "se", "01|02"],
+    ["FeatureML", "ml", "01"],
+    ["FeatureSA", "sa", "01"],
+    ["FeatureTOL", "tol", "01"]
+  ])
+    updates[key] = atLeast(config.expansion, expansion) ? value : "0";
+  const count = settings.maps === "felucca" ? 1 : sphereMapCount(config.expansion);
+  for (let map = 0;map < 6; map++) {
+    const current = sphereConfigValue(ini, `Map${map}`);
+    if (!current || !/^\d+,\d+,-?\d+,\d+,\d+$/.test(current))
+      throw new Error(`Unsupported upstream Sphere Map${map}.`);
+    updates[`Map${map}`] = map === 5 ? current : map >= count ? "" : map < 2 ? `${settings.mapSize === "modern" ? 7168 : 6144},4096,-1,${map},${map}` : current;
+  }
+  for (const [key, value] of Object.entries(updates))
+    ini = setValue(ini, key, value);
+  const newline = ini.includes(`\r
+`) ? `\r
+` : `
+`;
+  const lines = ini.split(/\r?\n/);
+  const servers = lines.flatMap((line, index) => line.trim().toUpperCase() === "[SERVERS]" ? [index] : []);
+  if (servers.length !== 1)
+    throw new Error("Missing or duplicate upstream Sphere [SERVERS] section.");
+  const index = servers[0] + 1;
+  if (!lines[index] || lines[index + 1] !== "127.0.0.1" || lines[index + 2] !== "2593")
+    throw new Error("Unsupported upstream Sphere local server entry.");
+  lines[index] = config.name;
+  ini = lines.join(newline);
+  let tables = text(upstream, "scripts/spheretables.scp");
+  const found = new Set;
+  tables = tables.split(/\r?\n/).map((line) => {
+    const match = /^(\/\/)?(scripts\/maps\/sphere_map(?:_points)?([0-5])(?:_([a-z]+))?\.scp)$/.exec(line);
+    if (!match)
+      return line;
+    const map = Number(match[3]);
+    found.add(map);
+    if (upstream[match[2]] === undefined)
+      throw new Error(`Missing upstream map script: ${match[2]}`);
+    const extension = match[4];
+    if (extension && !["se", "ml", "sa", "hs", "tol"].includes(extension))
+      throw new Error(`Unsupported upstream Sphere map extension: ${extension}`);
+    const enabled = map < count && (!extension || atLeast(config.expansion, extension)) && (settings.mapSize === "modern" || !extension || extension === "se");
+    return `${enabled ? "" : "//"}${match[2]}`;
+  }).join(tables.includes(`\r
+`) ? `\r
+` : `
+`);
+  if (found.size !== 6)
+    throw new Error("Upstream Sphere map script layout changed. No files were written.");
+  const scriptUpdates = {};
+  if (settings.rules?.speedEra === 4) {
+    let overrides = 0;
+    for (const filename of Object.keys(upstream).filter((name) => name.startsWith("scripts/") && name.endsWith(".scp"))) {
+      const original = text(upstream, filename);
+      const updated = original.replace(/^([ \t]*)\/\/(TAG\.OVERRIDE\.SPEED=\d+[^\r\n]*)/gm, (_line, indentation, value) => {
+        overrides++;
+        return indentation + value;
+      });
+      if (updated !== original)
+        scriptUpdates[filename] = Buffer.from(updated, "latin1");
+    }
+    if (!overrides)
+      throw new Error("ML swing speed requires upstream commented weapon speed overrides. No files were written.");
+  }
+  const digest = createHash3("md5").update(password, "ascii").digest("hex");
+  return {
+    ...upstream,
+    ...scriptUpdates,
+    "sphere.ini": Buffer.from(ini, "latin1"),
+    "scripts/spheretables.scp": Buffer.from(tables, "latin1"),
+    "accounts/sphereaccu.scp": `[${settings.owner}]
+PLEVEL=Owner
+MD5PASSWORD=${digest}
+
+[EOF]
+`,
+    "accounts/sphereacct.scp": `[EOF]
+`,
+    "save/.gitkeep": "",
+    ".gitignore": `accounts/
+save/
+logs/
+data/client/
+.gemwright/
+`
+  };
+}
+function sphereTimezone(zone, year = new Date().getUTCFullYear()) {
+  const formatter = new Intl.DateTimeFormat("en", { timeZone: zone, timeZoneName: "shortOffset" });
+  const offsets = Array.from({ length: 12 }, (_, month) => {
+    const label = formatter.formatToParts(new Date(Date.UTC(year, month, 15))).find((part) => part.type === "timeZoneName").value;
+    if (label === "GMT")
+      return 0;
+    const match = /^GMT([+-])(\d{1,2})(?::(\d{2}))?$/.exec(label);
+    if (!match)
+      throw new Error(`Cannot determine Sphere timezone for ${zone}.`);
+    return (match[1] === "+" ? 1 : -1) * (Number(match[2]) + Number(match[3] ?? 0) / 60);
+  });
+  const offset = -Math.min(...offsets);
+  if (!Number.isInteger(offset))
+    throw new Error(`Sphere cannot represent the fractional-hour timezone ${zone}. Choose a whole-hour zone.`);
+  return offset || 0;
+}
+
+// src/emulators/sphere/staging.ts
+async function validateSphereShard(directory, config) {
+  const scripts = config.sphere?.scriptsSource;
+  if (config.source?.repository !== sphereSources.server.repository || config.source.ref !== sphereSources.server.ref || !scripts || scripts.repository !== sphereSources.scripts.repository || scripts.ref !== sphereSources.scripts.ref)
+    throw new Error("Missing or unsupported Sphere source pair. Initialize a shard to record both revisions.");
+  const ini = await readFile4(join5(directory, "sphere.ini"), "latin1");
+  for (const [key, value] of Object.entries({
+    ServPort: "2593",
+    ScpFiles: "scripts/",
+    WorldSave: "save/",
+    AcctFiles: "accounts/",
+    MulFiles: "data/client/",
+    Log: "logs/"
+  })) {
+    if (sphereConfigValue(ini, key) !== value)
+      throw new Error(`Sphere deployment currently requires ${key}=${value}. Config was not changed.`);
+  }
+  for (const folder of ["scripts", "accounts", "save"]) {
+    if (!(await stat2(join5(directory, folder))).isDirectory())
+      throw new Error(`Missing Sphere ${folder} directory.`);
+  }
+}
+async function stageSphere(directory, config) {
+  await validateSphereShard(directory, config);
+  const context = join5(directory, ".gemwright/deploy");
+  await rm4(context, { recursive: true, force: true });
+  const server = join5(context, "server");
+  await mkdir2(server, { recursive: true });
+  await command(["git", "init", "--quiet"], server);
+  await command(["git", "fetch", "--quiet", "--depth", "1", config.source.repository, config.source.revision], server);
+  await command(["git", "checkout", "--quiet", "--detach", "FETCH_HEAD"], server);
+  await applySphereCompatibility(server, config.source.revision);
+  await rm4(join5(server, ".git"), { recursive: true, force: true });
+  await mkdir2(join5(context, "shard"));
+  for (const name of ["sphere.ini", "sphereCrypt.ini", "scripts"])
+    await cp2(join5(directory, name), join5(context, "shard", name), { recursive: true });
+  for (const name of ["accounts", "save"])
+    await cp2(join5(directory, name), join5(context, "seed", name), { recursive: true });
+  for (const [source, target] of [
+    ["Dockerfile", "Dockerfile"],
+    ["railway-start.sh", "start.sh"],
+    ["start.sh", "run-server.sh"]
+  ])
+    await cp2(assetPath(`templates/sphere/${source}`), join5(context, target));
+  return context;
+}
+var clientPattern2 = /^(?:map[0-5](?:LegacyMUL\.uop|\.mul)|statics[0-5]\.mul|staidx[0-5]\.mul|(?:mapdif|mapdifl|stadif|stadifl|stadifi)[0-5]\.mul|multi\.(?:idx|mul)|hues\.mul|tiledata\.mul|verdata\.mul)$/i;
+async function packageClientFiles3(directory, sourcePath) {
+  const ini = await readFile4(join5(directory, "sphere.ini"), "latin1");
+  return packageClientFiles(directory, sourcePath, clientPattern2, (names) => {
+    const required = ["tiledata.mul", "hues.mul", "multi.idx", "multi.mul"];
+    for (let map = 0;map < 6; map++) {
+      if (!sphereConfigValue(ini, `Map${map}`))
+        continue;
+      required.push(`statics${map}.mul`, `staidx${map}.mul`);
+      if (!names.includes(`map${map}.mul`) && !names.includes(`map${map}legacymul.uop`))
+        throw new Error(`Sphere client files need map${map}.mul or map${map}LegacyMUL.uop for enabled Map${map}.`);
+    }
+    const missing = required.filter((name) => !names.includes(name));
+    if (missing.length)
+      throw new Error(`Sphere client files are missing: ${missing.join(", ")}. MultiCollection.uop is not a replacement for multi.idx/multi.mul in this Sphere version.`);
+  });
+}
+
+// src/emulators/deployment.ts
+var deployments = {
+  servuo: { label: "ServUO", validate: validateServuoShard, stage: stageServuo, packageFiles: packageClientFiles2 },
+  sphere: { label: "Sphere", validate: validateSphereShard, stage: stageSphere, packageFiles: packageClientFiles3 }
+};
+
+// src/shard.ts
+import { readFile as readFile5 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+async function loadShard(directory) {
+  let input;
+  try {
+    input = JSON.parse(await readFile5(join6(directory, configFilename), "utf8"));
+  } catch {
+    throw new Error(`Cannot read ${configFilename}. Run gemwright init in the shard directory first.`);
+  }
+  for (const key of ["name", "id", "timezone", "expansion", "emulator"]) {
+    if (typeof input[key] !== "string")
+      throw new Error(`Invalid ${configFilename}: missing ${key}.`);
+  }
+  const config = createConfig(input);
+  if (config.id !== input.id || !config.id)
+    throw new Error("The recorded shard ID must be a non-empty slug derived from its name.");
+  return config;
+}
+
+// src/deploy.ts
+async function saveState(directory, state) {
+  const path = join7(directory, ".gemwright/railway.json");
+  await mkdir3(join7(directory, ".gemwright"), { recursive: true });
+  await writeFile3(`${path}.tmp`, JSON.stringify(state, null, 2) + `
+`);
+  await rename(`${path}.tmp`, path);
+}
+async function ensureRailway(directory, slug, run, pause = sleep) {
+  let state;
+  try {
+    state = JSON.parse(await readFile6(join7(directory, ".gemwright/railway.json"), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    state = { projectName: `${slug}-${randomUUID().slice(0, 8)}`, environment: "production" };
+    await saveState(directory, state);
+  }
+  if (!state.projectName || !state.environment)
+    throw new Error("Invalid .gemwright/railway.json state.");
+  if (!state.project) {
+    const projects = await run(["project", "list", "--json"]);
+    const matches = projects.filter((project) => project.name === state.projectName && !project.deletedAt);
+    if (matches.length > 1)
+      throw new Error("Multiple projects match the recorded provisioning name.");
+    if (matches.length)
+      state.project = matches[0].id;
+    else {
+      const account = await run(["whoami", "--json"]);
+      if (account.workspaces.length !== 1)
+        throw new Error("Deployment currently requires a single Railway workspace, or a project already recorded in .gemwright/railway.json.");
+      const project = await run([
+        "init",
+        "--name",
+        state.projectName,
+        "--workspace",
+        account.workspaces[0].id,
+        "--json"
+      ]);
+      state.project = project.id;
+    }
+    await saveState(directory, state);
+  }
+  const projectFlags = ["--project", state.project, "--environment", state.environment];
+  if (!state.service) {
+    const services = await run(["service", "list", ...projectFlags, "--json"]);
+    const match = services.find((service) => service.name === slug);
+    if (match)
+      state.service = match.id;
+    else {
+      await run(["link", ...projectFlags, "--json"]);
+      const service = await run(["add", "--service", slug, "--json"]);
+      state.service = service.id;
+    }
+    await saveState(directory, state);
+  }
+  const flags = [...projectFlags, "--service", state.service];
+  const volumes = await run([
+    "volume",
+    ...flags,
+    "list",
+    "--json"
+  ]);
+  const attached = volumes.volumes.filter((volume) => volume.serviceName === slug);
+  if (attached.length > 1)
+    throw new Error("More than one volume is attached to the shard service.");
+  let volume = attached[0];
+  if (!volume) {
+    const created = await run([
+      "volume",
+      ...flags,
+      "add",
+      "--mount-path",
+      "/app/data",
+      "--json"
+    ]);
+    volume = { ...created, mountPath: "/app/data", serviceName: slug };
+  }
+  if (state.volume && state.volume !== volume.id) {
+    delete state.clientDigest;
+    delete state.pendingClientDigest;
+  }
+  state.volume = volume.id;
+  await saveState(directory, state);
+  if (volume.name !== "data" || volume.mountPath !== "/app/data") {
+    for (let attempt = 0;; attempt++) {
+      try {
+        await run([
+          "volume",
+          ...flags,
+          "update",
+          "--volume",
+          volume.id,
+          "--name",
+          "data",
+          "--mount-path",
+          "/app/data",
+          "--json"
+        ]);
+        break;
+      } catch (error) {
+        if (attempt === 9)
+          throw error;
+        await pause(3000);
+      }
+    }
+  }
+  const proxies = await run(["tcp-proxy", "list", ...flags, "--json"]);
+  if (proxies.proxies.length && !proxies.proxies.some((proxy) => proxy.applicationPort === 2593)) {
+    throw new Error("The existing TCP proxy points to another application port. It was not replaced.");
+  }
+  if (!proxies.proxies.length)
+    await run(["tcp-proxy", "create", ...flags, "--port", "2593", "--json"]);
+  await run([
+    "variable",
+    "set",
+    ...flags,
+    "RAILWAY_DOCKERFILE_PATH=Dockerfile",
+    "RAILWAY_DEPLOYMENT_DRAINING_SECONDS=45",
+    "--skip-deploys",
+    "--json"
+  ]);
+  return state;
+}
+async function deploy(options, directory = process.cwd()) {
+  directory = resolve2(directory);
+  if (!await isAvailable("railway"))
+    throw new Error("Railway CLI is missing. Install it and log in before running gemwright deploy.");
+  if (!await isAvailable("git"))
+    throw new Error("Git is required to stage the recorded emulator source.");
+  const run = async (args) => JSON.parse(await command(["railway", ...args], directory));
+  try {
+    await run(["whoami", "--json"]);
+  } catch {
+    throw new Error("Railway is not logged in or cannot be reached. Run railway login and check your connection.");
+  }
+  const config = await loadShard(directory);
+  const emulator = deployments[config.emulator];
+  await emulator.validate(directory, config);
+  const recorded = await readFile6(join7(directory, ".gemwright/railway.json"), "utf8").then((text) => JSON.parse(text), (error) => {
+    if (error.code !== "ENOENT")
+      throw error;
+    return;
+  });
+  if (recorded?.emulator && recorded.emulator !== config.emulator)
+    throw new Error("The recorded Railway service belongs to another emulator. It was not changed.");
+  const clientPath = options.files ?? config[config.emulator]?.clientFiles;
+  console.log(`Staging ${emulator.label} ${config.source.revision.slice(0, 12)}...`);
+  const context = await emulator.stage(directory, config);
+  const client = clientPath ? await emulator.packageFiles(directory, clientPath, config) : undefined;
+  const state = await ensureRailway(directory, config.id, run);
+  state.emulator = config.emulator;
+  await saveState(directory, state);
+  const flags = ["--project", state.project, "--environment", state.environment, "--service", state.service];
+  await run(["variable", "set", ...flags, `TZ=${config.timezone}`, "--skip-deploys", "--json"]);
+  console.log("Uploading build context to Railway...");
+  const upload = await command(["railway", "up", context, "--path-as-root", "--no-gitignore", ...flags, "--detach", "--json"], directory);
+  let deploymentId;
+  for (const line of upload.split(`
+`)) {
+    try {
+      const value = JSON.parse(line);
+      deploymentId = value.deploymentId ?? value.id ?? deploymentId;
+    } catch {}
+  }
+  let active = false;
+  for (let attempt = 0;attempt < 180; attempt++) {
+    const deployments = await run([
+      "deployment",
+      "list",
+      ...flags,
+      "--limit",
+      "1",
+      "--json"
+    ]);
+    const latest = deployments[0];
+    if (latest && (!deploymentId || latest.id === deploymentId)) {
+      if (latest.status === "SUCCESS") {
+        active = true;
+        break;
+      }
+      if (["FAILED", "CRASHED", "REMOVED"].includes(latest.status))
+        throw new Error(`Railway deployment ${latest.id} ${latest.status.toLowerCase()}. Inspect its build and deployment logs.`);
+    }
+    if (attempt % 6 === 0)
+      console.log(`Waiting for Railway build: ${latest?.status ?? "pending"}...`);
+    await sleep(5000);
+  }
+  if (!active)
+    throw new Error("Railway build is still pending. Resources are recorded; rerun deploy to resume.");
+  if (client && state.clientDigest !== client.digest) {
+    const volumeFlags = ["volume", ...flags, "files", "--volume", state.volume];
+    const root = await run([...volumeFlags, "list", "/", "--json"]);
+    const names = new Set(root.files.map((file) => file.name));
+    const ready = names.has(".client-ready");
+    if (state.clientDigest || ready && state.pendingClientDigest !== client.digest) {
+      throw new Error("Different client files are already installed. They were not replaced automatically.");
+    }
+    if (state.pendingClientDigest && state.pendingClientDigest !== client.digest)
+      throw new Error("An import of different client files is pending. Resume with the same files.");
+    state.pendingClientDigest = client.digest;
+    await saveState(directory, state);
+    if (!ready && !names.has("client.tar.gz")) {
+      console.log(`Uploading ${Math.round(client.bytes / 1024 / 1024)} MiB of client data to the volume...`);
+      await run([...volumeFlags, "upload", client.archive, "/client.tar.gz.uploading", "--overwrite", "--json"]);
+      await run([...volumeFlags, "rename", "/client.tar.gz.uploading", "/client.tar.gz", "--json"]);
+    }
+    state.clientDigest = client.digest;
+    delete state.pendingClientDigest;
+    await saveState(directory, state);
+  }
+  const proxies = await run(["tcp-proxy", "list", ...flags, "--json"]);
+  console.log(`Railway deployment active. Shard endpoint: ${proxies.proxies[0]?.endpoint ?? "pending"}`);
+  if (!client && !state.clientDigest)
+    console.log("Waiting for client files. Rerun gemwright deploy --files <directory> to import them.");
+}
+
+// src/init.ts
+import { resolve as resolve5 } from "node:path";
+import * as prompts5 from "@clack/prompts";
+
+// src/emulators/servuo/init.ts
+import { stat as stat3 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+import * as prompts2 from "@clack/prompts";
+
+// src/prompts.ts
+import * as prompts from "@clack/prompts";
+
+class Cancelled extends Error {
+}
+function answer(value) {
+  if (prompts.isCancel(value)) {
+    prompts.cancel("Initialization cancelled.");
+    throw new Cancelled;
+  }
+  return value;
+}
+
+// src/emulators/servuo/init.ts
+async function initializeServuo(config, yes = false, loadConfig = fetchServuoConfig) {
+  let generatedPassword;
+  const upstream = await loadConfig(config.source);
+  const registration = configValue(upstream["Config/Accounts.cfg"] ?? "", "AutoCreateAccounts");
+  if (!registration || !/^(true|false)$/i.test(registration))
+    throw new Error("Upstream automatic registration default is missing or invalid.");
+  const clientFiles = yes ? "" : answer(await prompts2.text({
+    message: "UO client files directory (optional; leave blank to add at deploy)",
+    validate: async (value) => {
+      if (!value)
+        return;
+      try {
+        if (!(await stat3(resolve3(value))).isDirectory())
+          return "Choose a directory.";
+      } catch {
+        return "That directory does not exist.";
+      }
+    }
+  }));
+  const autoCreateAccounts = yes ? registration.toLowerCase() === "true" : answer(await prompts2.confirm({
+    message: "Allow players to create accounts on first login?",
+    initialValue: registration.toLowerCase() === "true"
+  }));
+  const owner = yes ? "admin" : answer(await prompts2.text({
+    message: "Owner username",
+    placeholder: "admin",
+    defaultValue: "admin",
+    validate: (value) => validateOwner(value || "admin")
+  }));
+  let password2 = yes ? "" : answer(await prompts2.password({
+    message: "Owner password (leave blank to generate)",
+    validate: (value) => validateOwnerPassword(value ?? "")
+  }));
+  if (!password2)
+    password2 = generatedPassword = generatedOwnerPassword();
+  const settings = {
+    ...clientFiles ? { clientFiles: resolve3(clientFiles) } : {},
+    autoCreateAccounts,
+    owner
+  };
+  return { settings, files: prepareServuoFiles(upstream, config, settings, password2), generatedPassword };
+}
+
+// src/emulators/sphere/init.ts
+import { stat as stat4 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
+import * as prompts4 from "@clack/prompts";
+
+// src/emulators/sphere/rules-prompts.ts
+import * as prompts3 from "@clack/prompts";
+function defaultRules(ini) {
+  function number(key, fallback) {
+    const value = sphereConfigValue(ini, key);
+    if (value !== undefined)
+      return sphereNumber(value);
+    if (fallback !== undefined && new RegExp(`^//${key}=0(?:\\s|$)`, "m").test(ini))
+      return fallback;
+    throw new Error(`Missing upstream Sphere setting: ${key}.`);
+  }
+  return {
+    combatFlags: number("CombatFlags", 0),
+    archeryMovementDelay: number("CombatArcheryMovementDelay"),
+    damageEra: number("CombatDamageEra"),
+    hitChanceEra: number("CombatHitChanceEra"),
+    speedEra: number("CombatSpeedEra"),
+    speedScaleFactor: number("SpeedScaleFactor"),
+    magicFlags: number("MagicFlags", 0),
+    racialFlags: number("RacialFlags"),
+    revealFlags: number("RevealFlags"),
+    npcAI: number("NPCAI", 0)
+  };
+}
+async function askSphereRules(ini, yes) {
+  const rules = defaultRules(ini);
+  if (yes) {
+    validateRules(rules);
+    return rules;
+  }
+  async function flags(key, message) {
+    const options = ruleFlags[key].map(([value, label]) => ({ value: Number(value), label }));
+    const known = options.reduce((mask, option) => mask | option.value, 0);
+    while (true) {
+      const selected = answer(await prompts3.multiselect({
+        message,
+        options,
+        required: false,
+        maxItems: 8,
+        initialValues: options.filter((option) => rules[key] & option.value).map((option) => option.value)
+      }));
+      rules[key] = rules[key] & ~known | selected.reduce((mask, value) => mask | value, 0);
+      if (key !== "npcAI" || !(rules.npcAI & 8) || rules.npcAI & 1)
+        break;
+      prompts3.log.warn("Maximum intelligence requires advanced pathfinding. Select both or neither.");
+    }
+  }
+  async function integer(message, value, minimum = 0) {
+    return Number(answer(await prompts3.text({
+      message,
+      placeholder: String(value),
+      defaultValue: String(value),
+      validate: (input) => {
+        const text = input || String(value);
+        return !/^\d+$/.test(text) || !Number.isSafeInteger(Number(text)) || Number(text) < minimum || Number(text) > 2147483647 ? `Enter a whole number from ${minimum} to 2147483647.` : undefined;
+      }
+    })));
+  }
+  await flags("combatFlags", "Combat behavior");
+  if (!(rules.combatFlags & 256))
+    rules.archeryMovementDelay = await integer("Archery delay after movement (tenths of a second; pre-AOS 10, AOS 5, SE 2)", rules.archeryMovementDelay);
+  const formulas = [
+    { value: 0, label: "Sphere custom" },
+    { value: 1, label: "Pre-AOS" },
+    { value: 2, label: "AOS" }
+  ];
+  rules.damageEra = answer(await prompts3.select({ message: "Physical damage formula", initialValue: rules.damageEra, options: formulas }));
+  rules.hitChanceEra = answer(await prompts3.select({
+    message: "Hit chance formula",
+    initialValue: rules.hitChanceEra,
+    options: formulas.map((option) => ({
+      ...option,
+      hint: option.value < 2 ? "No Hit Chance Increase support" : "Supports Hit Chance Increase"
+    }))
+  }));
+  await flags("magicFlags", "Magic behavior");
+  await flags("racialFlags", "Racial traits");
+  await flags("revealFlags", "Reveal invisible characters when…");
+  await flags("npcAI", "NPC intelligence");
+  validateRules(rules);
+  return rules;
+}
+
+// src/emulators/sphere/init.ts
+async function initializeSphere(config, sources, yes = false, loadFiles = fetchSphereFiles) {
+  let generatedPassword;
+  const upstream = await loadFiles(sources);
+  const ini = upstream["sphere.ini"];
+  if (ini === undefined)
+    throw new Error("Missing upstream sphere.ini.");
+  const iniText = typeof ini === "string" ? ini : Buffer.from(ini).toString("latin1");
+  const useCrypt = sphereConfigValue(iniText, "UseCrypt");
+  const useNoCrypt = sphereConfigValue(iniText, "UseNoCrypt");
+  if (!["0", "1"].includes(useCrypt ?? "") || !["0", "1"].includes(useNoCrypt ?? "") || useCrypt === "0" && useNoCrypt === "0")
+    throw new Error("Upstream Sphere encryption defaults are missing or invalid.");
+  const defaultEncryption = useCrypt === "0" ? "unencrypted" : useNoCrypt === "0" ? "encrypted" : "both";
+  const registration = sphereConfigValue(typeof ini === "string" ? ini : Buffer.from(ini).toString("latin1"), "AutoAccountCreation");
+  if (registration !== "0" && registration !== "1")
+    throw new Error("Upstream Sphere registration default is missing or invalid.");
+  if (!yes)
+    prompts4.note("Expansion sets client features. Combat and other rules can be customized below; Enter keeps upstream rule defaults.", "Sphere");
+  const clientFiles = yes ? "" : answer(await prompts4.text({
+    message: "UO client files directory (optional; leave blank to add at deploy)",
+    validate: async (value) => {
+      if (!value)
+        return;
+      try {
+        if (!(await stat4(resolve4(value))).isDirectory())
+          return "Choose a directory.";
+      } catch {
+        return "That directory does not exist.";
+      }
+    }
+  }));
+  const clientEncryption = yes ? defaultEncryption : answer(await prompts4.select({
+    message: "Client encryption",
+    initialValue: defaultEncryption,
+    options: [
+      { value: "encrypted", label: "Encrypted clients only" },
+      {
+        value: "both",
+        label: "Encrypted and unencrypted clients",
+        hint: "Allows ClassicUO with encryption off"
+      },
+      { value: "unencrypted", label: "Unencrypted clients only" }
+    ]
+  }));
+  const maps = yes || sphereMapCount(config.expansion) === 1 ? "expansion" : answer(await prompts4.select({
+    message: "World maps",
+    initialValue: "expansion",
+    options: [
+      { value: "expansion", label: "All maps through the selected expansion" },
+      { value: "felucca", label: "Felucca only" }
+    ]
+  }));
+  const mapSize = yes || expansions.findIndex((entry) => entry.value === config.expansion) >= expansions.findIndex((entry) => entry.value === "ml") ? "modern" : answer(await prompts4.select({
+    message: "Which UO map files will you use?",
+    initialValue: "modern",
+    options: [
+      {
+        value: "modern",
+        label: "Mondain's Legacy or newer",
+        hint: "7168 × 4096 Felucca/Trammel terrain"
+      },
+      {
+        value: "legacy",
+        label: "Before Mondain's Legacy",
+        hint: "6144 × 4096 Felucca/Trammel terrain"
+      }
+    ]
+  }));
+  const rules = await askSphereRules(iniText, yes);
+  const autoCreateAccounts = yes ? registration === "1" : answer(await prompts4.confirm({
+    message: "Allow players to create accounts on first login?",
+    initialValue: registration === "1"
+  }));
+  const owner = yes ? "admin" : answer(await prompts4.text({
+    message: "Owner username",
+    placeholder: "admin",
+    defaultValue: "admin",
+    validate: (value) => validateSphereOwner(value || "admin")
+  }));
+  let password = yes ? "" : answer(await prompts4.password({
+    message: "Owner password (leave blank to generate)",
+    validate: (value) => validateOwnerPassword(value ?? "")
+  }));
+  if (!password)
+    password = generatedPassword = generatedOwnerPassword();
+  const settings = {
+    scriptsSource: sources.scripts,
+    ...clientFiles ? { clientFiles: resolve4(clientFiles) } : {},
+    autoCreateAccounts,
+    clientEncryption,
+    owner,
+    maps,
+    mapSize,
+    rules
+  };
+  return { settings, files: prepareSphereFiles(upstream, config, settings, password), generatedPassword };
+}
+
+// src/instance.ts
+import { appendFile, lstat, mkdir as mkdir4, readFile as readFile7, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname, isAbsolute, join as join8 } from "node:path";
+async function existingAncestor(directory) {
+  try {
+    if (!(await stat5(directory)).isDirectory())
+      throw new Error(`Not a directory: ${directory}`);
+    return directory;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    const parent = dirname(directory);
+    if (parent === directory)
+      throw error;
+    return existingAncestor(parent);
+  }
+}
+async function gitStatus(directory) {
+  try {
+    const result = await runCommand(["git", "-C", await existingAncestor(directory), "rev-parse", "--show-toplevel"]);
+    return { available: true, insideRepository: result.code === 0 };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { available: false, insideRepository: false };
+    throw error;
+  }
+}
+async function ensureNewConfig(directory) {
+  try {
+    await stat5(join8(directory, configFilename));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  throw new Error(`${configFilename} already exists in ${directory}. Refusing to overwrite it.`);
+}
+async function saveInstance(directory, config, initializeGit, files = {}) {
+  const output = { ...files, [configFilename]: `${JSON.stringify(config, null, 2)}
+` };
+  if (output[".gitignore"] !== undefined && typeof output[".gitignore"] !== "string")
+    throw new Error(".gitignore must contain text.");
+  for (const filename of Object.keys(output)) {
+    if (isAbsolute(filename) || filename.split(/[\\/]/).some((part) => part === ".." || part === "")) {
+      throw new Error(`Invalid instance file path: ${filename}`);
+    }
+    const parts = filename.split("/");
+    for (let depth = 1;depth < parts.length; depth++) {
+      try {
+        const parent = await lstat(join8(directory, ...parts.slice(0, depth)));
+        if (!parent.isDirectory())
+          throw new Error(`Refusing to write through a non-directory: ${parts.slice(0, depth).join("/")}`);
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+    }
+    try {
+      const info = await lstat(join8(directory, filename));
+      if (filename === ".gitignore" && info.isFile())
+        continue;
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw error;
+    }
+    throw new Error(`Refusing to overwrite ${join8(directory, filename)}.`);
+  }
+  await mkdir4(directory, { recursive: true });
+  for (const [filename, content] of Object.entries(output)) {
+    await mkdir4(dirname(join8(directory, filename)), { recursive: true });
+    if (filename === ".gitignore") {
+      if (typeof content !== "string")
+        throw new Error(".gitignore must contain text.");
+      let existing = "";
+      try {
+        existing = await readFile7(join8(directory, filename), "utf8");
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+      const present = new Set(existing.split(/\r?\n/));
+      const missing = content.split(`
+`).filter((line) => line && !present.has(line));
+      if (missing.length)
+        await appendFile(join8(directory, filename), `${existing && !existing.endsWith(`
+`) ? `
+` : ""}${missing.join(`
+`)}
+`);
+    } else {
+      await writeFile4(join8(directory, filename), content, {
+        flag: "wx",
+        mode: ["Saves/Accounts/accounts.xml", "accounts/sphereaccu.scp"].includes(filename) ? 384 : 420
+      });
+    }
+  }
+  if (initializeGit) {
+    try {
+      await command(["git", "init", directory], directory);
+    } catch (error) {
+      throw new Error(`Saved ${configFilename}, but Git initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+// src/init.ts
+async function initialize(options, resolveServuoSource = resolveLatestServuoSource, loadServuoConfig = fetchServuoConfig, resolveSphereSources = resolveLatestSphereSources, loadSphereFiles = fetchSphereFiles) {
+  const directory = resolve5(options.directory ?? ".");
+  await existingAncestor(directory);
+  await ensureNewConfig(directory);
+  createConfig({
+    name: options.name,
+    timezone: options.timezone,
+    expansion: options.expansion,
+    emulator: options.emulator
+  });
+  const git = await gitStatus(directory);
+  if (options.git && !git.available)
+    throw new Error("Git is not installed. Install Git or omit --git.");
+  if (!options.yes && !process.stdin.isTTY) {
+    throw new Error("The questionnaire requires an interactive terminal. Use --yes to accept defaults.");
+  }
+  prompts5.intro("Create an Ultima Online shard");
+  const name = options.name ?? (options.yes ? defaultName : answer(await prompts5.text({
+    message: "Shard name",
+    placeholder: defaultName,
+    defaultValue: defaultName,
+    validate: (value) => validateName(value ?? "")
+  })));
+  const emulator = options.emulator ?? (options.yes ? defaultEmulator : answer(await prompts5.select({
+    message: "Which server emulator?",
+    initialValue: defaultEmulator,
+    options: [...emulators]
+  })));
+  if (emulator === "sphere") {
+    const error = validateSphereName(name);
+    if (error)
+      throw new Error(error);
+  }
+  const timezone = options.timezone ?? (options.yes ? defaultTimezone() : answer(await prompts5.autocomplete({
+    message: "Timezone",
+    placeholder: "Type to search IANA zones",
+    initialValue: defaultTimezone(),
+    options: timezoneOptions().map((value) => ({ value })),
+    maxItems: 8
+  })));
+  const expansion = options.expansion ?? (options.yes ? defaultExpansion : answer(await prompts5.select({
+    message: "Expansion",
+    initialValue: defaultExpansion,
+    options: expansions.map((option) => ({
+      ...option,
+      ...emulator === "sphere" && option.value === "ej" ? { hint: "Uses Time of Legends features in Sphere" } : {}
+    }))
+  })));
+  const adminEmail = options.yes ? defaultAdminEmail : answer(await prompts5.text({
+    message: "Admin email (optional)",
+    placeholder: defaultAdminEmail,
+    defaultValue: defaultAdminEmail,
+    validate: (value) => validateAdminEmail(value || defaultAdminEmail)
+  }));
+  const url = options.yes ? defaultWebsite : answer(await prompts5.text({
+    message: emulator === "sphere" ? "Shard website (optional; omit http(s)://)" : "Shard website (optional)",
+    placeholder: defaultWebsite,
+    defaultValue: defaultWebsite,
+    validate: (value) => emulator === "sphere" && value?.includes("//") ? "Sphere requires a hostname/path without http(s):// or //." : validateWebsite(value || defaultWebsite)
+  }));
+  const sphereSources = emulator === "sphere" ? await resolveSphereSources() : undefined;
+  const source = emulator === "servuo" ? await resolveServuoSource() : sphereSources?.server;
+  let files = {};
+  let generatedPassword;
+  let config = createConfig({ name, emulator, timezone, expansion, source, adminEmail, url });
+  if (emulator === "servuo") {
+    const result = await initializeServuo(config, options.yes, loadServuoConfig);
+    config = createConfig({ ...config, servuo: result.settings });
+    files = result.files;
+    generatedPassword = result.generatedPassword;
+  } else if (sphereSources) {
+    const result = await initializeSphere(config, sphereSources, options.yes, loadSphereFiles);
+    config = createConfig({ ...config, sphere: result.settings });
+    files = result.files;
+    generatedPassword = result.generatedPassword;
+  }
+  const initializeGit = git.available && !git.insideRepository && (options.git ?? (options.yes ? true : answer(await prompts5.confirm({
+    message: "Initialize a Git repository?",
+    initialValue: true
+  }))));
+  await saveInstance(directory, config, initializeGit, files);
+  if (generatedPassword)
+    prompts5.note(`Username: ${config.servuo?.owner ?? config.sphere?.owner}
+Password: ${generatedPassword}
+Save this password; it will not be shown again.`, "Owner account");
+  prompts5.outro(`Created ${configFilename} in ${directory}`);
+}
+
+// src/index.ts
+var help = `Usage: gemwright init [directory] [options]
+       gemwright deploy [--files <path>]
+
+Options:
+  --name <name>          Shard name (default: Gemwright)
+  --timezone <timezone> IANA timezone (default: local zone or Europe/London)
+  --expansion <code>    Expansion (default: ej)
+  --emulator <name>     Server emulator: servuo or sphere (default: servuo)
+  --git                 Initialize Git if outside a repository
+  --yes                 Accept defaults for unanswered questions
+  --files <path>        UO client files to import during deployment
+  --help                Show this help`;
+async function main(args = process.argv.slice(2)) {
+  const { values, positionals } = parseArgs({
+    args,
+    allowPositionals: true,
+    strict: true,
+    options: {
+      files: { type: "string" },
+      name: { type: "string" },
+      timezone: { type: "string" },
+      expansion: { type: "string" },
+      emulator: { type: "string" },
+      git: { type: "boolean" },
+      yes: { type: "boolean" },
+      help: { type: "boolean" }
+    }
+  });
+  if (values.help || positionals.length === 0) {
+    console.log(help);
+    return;
+  }
+  const [command, directory, ...extra] = positionals;
+  if (command === "deploy") {
+    if (directory || extra.length || Object.keys(values).some((key) => key !== "files"))
+      throw new Error("Usage: gemwright deploy [--files <path>]");
+    await deploy({ files: values.files });
+    return;
+  }
+  if (values.files)
+    throw new Error("--files is only supported by deploy.");
+  if (command !== "init")
+    throw new Error(`Unknown command: ${command}. Run gemwright --help.`);
+  if (extra.length)
+    throw new Error("Expected at most one directory. Run gemwright --help.");
+  await initialize({ directory, ...values });
+}
+if (process.argv[1] && realpathSync(process.argv[1]) === fileURLToPath2(import.meta.url)) {
+  try {
+    await main();
+  } catch (error) {
+    if (error instanceof Cancelled)
+      process.exitCode = 130;
+    else {
+      console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+      process.exitCode = 1;
+    }
+  }
+}
+export {
+  main
+};