landlord-ts 1.0.2

package/dist/index.cjs

@@ -0,0 +1,2487 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALL_CARDS: () => ALL_CARDS,
+  BasicLandType: () => BasicLandType,
+  COLOR_CONSTRAINED_THRESHOLD: () => COLOR_CONSTRAINED_THRESHOLD,
+  CardKind: () => CardKind,
+  DRAW_DEPENDENT_THRESHOLD: () => DRAW_DEPENDENT_THRESHOLD,
+  DeckcodeError: () => DeckcodeError,
+  PlayOrder: () => PlayOrder,
+  Rarity: () => Rarity,
+  RunValidationError: () => RunValidationError,
+  SPECIAL_LANDS: () => SPECIAL_LANDS,
+  asLondonMulligan: () => asLondonMulligan,
+  asNeverMulligan: () => asNeverMulligan,
+  autoTapByTurn: () => autoTapByTurn,
+  availableTurnForLand: () => availableTurnForLand,
+  basicLandTypesFromTypeLine: () => basicLandTypesFromTypeLine,
+  checkTypesFromOracleText: () => checkTypesFromOracleText,
+  createMulberry32: () => createMulberry32,
+  deckFlatten: () => deckFlatten,
+  deckFromCards: () => deckFromCards,
+  deckFromList: () => deckFromList,
+  decklist: () => decklist,
+  drawCmcAutoTap: () => drawCmcAutoTap,
+  etbClauseFromOracle: () => etbClauseFromOracle,
+  getAllCards: () => getAllCards,
+  handFromOpeningAndDraws: () => handFromOpeningAndDraws,
+  hashCardName: () => hashCardName,
+  isLand: () => isLand,
+  isLandKind: () => isLandKind,
+  landKindFromOracleText: () => landKindFromOracleText,
+  loadCardsFromGzipBytes: () => loadCardsFromGzipBytes,
+  londonNever: () => londonNever,
+  manaCostCmc: () => manaCostCmc,
+  manaCostFromRgbuwc: () => manaCostFromRgbuwc,
+  manaCostsFromStr: () => manaCostsFromStr,
+  observationsForCard: () => observationsForCard,
+  pMana: () => pMana,
+  pManaGivenCmc: () => pManaGivenCmc,
+  pPlay: () => pPlay,
+  parseDecklist: () => parseDecklist,
+  playCmcAutoTap: () => playCmcAutoTap,
+  run: () => run,
+  runAsync: () => runAsync,
+  scryfallCardToCard: () => scryfallCardToCard,
+  scryfallCardsToCards: () => scryfallCardsToCards,
+  setAllCards: () => setAllCards,
+  simulationFromConfig: () => simulationFromConfig,
+  simulationFromConfigAsync: () => simulationFromConfigAsync,
+  wilsonHalfWidth: () => wilsonHalfWidth
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/card/mana-cost.ts
+var R_BITS = 1;
+var G_BITS = 2;
+var B_BITS = 4;
+var U_BITS = 8;
+var W_BITS = 16;
+var C_BITS = 32;
+function emptyManaCost() {
+  return { bits: 0, r: 0, w: 0, b: 0, u: 0, g: 0, c: 0 };
+}
+function manaCostFromRgbuwc(r, g, b, u, w, c) {
+  return {
+    bits: calculateSignature(r, g, b, u, w, c),
+    r,
+    w,
+    b,
+    u,
+    g,
+    c
+  };
+}
+function manaCostCmc(cost) {
+  return cost.r + cost.w + cost.b + cost.u + cost.g + cost.c;
+}
+function updateManaCostBits(cost) {
+  return {
+    ...cost,
+    bits: calculateSignature(cost.r, cost.g, cost.b, cost.u, cost.w, cost.c)
+  };
+}
+function calculateSignature(r, g, b, u, w, c) {
+  return Math.min(1, r) << 0 & R_BITS | Math.min(1, g) << 1 & G_BITS | Math.min(1, b) << 2 & B_BITS | Math.min(1, u) << 3 & U_BITS | Math.min(1, w) << 4 & W_BITS | Math.min(1, c) << 5 & C_BITS;
+}
+function manaColorFromStr(color) {
+  switch (color.charAt(0)) {
+    case "B":
+      return 2 /* Black */;
+    case "U":
+      return 3 /* Blue */;
+    case "G":
+      return 1 /* Green */;
+    case "R":
+      return 0 /* Red */;
+    case "W":
+      return 4 /* White */;
+    default:
+      return 5 /* Colorless */;
+  }
+}
+function applyColor(cost, color, count) {
+  switch (color) {
+    case 2 /* Black */:
+      cost.b += count;
+      break;
+    case 3 /* Blue */:
+      cost.u += count;
+      break;
+    case 1 /* Green */:
+      cost.g += count;
+      break;
+    case 0 /* Red */:
+      cost.r += count;
+      break;
+    case 4 /* White */:
+      cost.w += count;
+      break;
+    case 5 /* Colorless */:
+      cost.c += count;
+      break;
+  }
+}
+function manaCostKey(cost) {
+  return `${cost.r},${cost.g},${cost.b},${cost.u},${cost.w},${cost.c},${cost.bits}`;
+}
+function compareManaCost(a, b) {
+  if (a.bits !== b.bits) return a.bits - b.bits;
+  if (a.r !== b.r) return a.r - b.r;
+  if (a.w !== b.w) return a.w - b.w;
+  if (a.b !== b.b) return a.b - b.b;
+  if (a.u !== b.u) return a.u - b.u;
+  if (a.g !== b.g) return a.g - b.g;
+  return a.c - b.c;
+}
+function manaCostsFromStr(manaCostStr) {
+  const symbolStack = manaCostSymbolsFromStr(manaCostStr);
+  const results = /* @__PURE__ */ new Map();
+  manaCostsFromStrRecur(results, emptyManaCost(), symbolStack, 0);
+  return [...results.values()].sort(compareManaCost);
+}
+function manaCostsFromStrRecur(results, current, symbolStack, idx) {
+  if (symbolStack.length <= idx) {
+    const updated = updateManaCostBits(current);
+    results.set(manaCostKey(updated), updated);
+    return;
+  }
+  const [leftSym, rightSym] = symbolStack[idx];
+  const left = {
+    bits: 0,
+    r: leftSym.r + current.r,
+    g: leftSym.g + current.g,
+    b: leftSym.b + current.b,
+    u: leftSym.u + current.u,
+    w: leftSym.w + current.w,
+    c: leftSym.c + current.c
+  };
+  manaCostsFromStrRecur(results, left, symbolStack, idx + 1);
+  if (rightSym) {
+    const right = {
+      bits: 0,
+      r: rightSym.r + current.r,
+      g: rightSym.g + current.g,
+      b: rightSym.b + current.b,
+      u: rightSym.u + current.u,
+      w: rightSym.w + current.w,
+      c: rightSym.c + current.c
+    };
+    manaCostsFromStrRecur(results, right, symbolStack, idx + 1);
+  }
+}
+function manaCostSymbolsFromStr(manaCostStr) {
+  let sigil = "";
+  const symbolStack = [];
+  let shouldPushRight = false;
+  let idx = 0;
+  for (const ch of manaCostStr) {
+    switch (ch) {
+      case "{": {
+        sigil = "";
+        symbolStack.push([emptyManaCost(), null]);
+        idx = symbolStack.length - 1;
+        shouldPushRight = false;
+        break;
+      }
+      case "/":
+      case "\\": {
+        const color = manaColorFromStr(sigil);
+        const count = Number.parseInt(sigil, 10);
+        const n = Number.isFinite(count) ? count : 1;
+        const cost = emptyManaCost();
+        applyColor(cost, color, n);
+        symbolStack[idx][0] = cost;
+        shouldPushRight = true;
+        sigil = "";
+        break;
+      }
+      case "}": {
+        const color = manaColorFromStr(sigil);
+        const count = Number.parseInt(sigil, 10);
+        const n = Number.isFinite(count) ? count : 1;
+        const cost = emptyManaCost();
+        applyColor(cost, color, n);
+        if (shouldPushRight) {
+          symbolStack[idx][1] = cost;
+        } else {
+          symbolStack[idx][0] = cost;
+        }
+        sigil = "";
+        break;
+      }
+      default:
+        sigil += ch;
+        break;
+    }
+  }
+  return symbolStack;
+}
+
+// src/card/types.ts
+var CardKind = /* @__PURE__ */ ((CardKind2) => {
+  CardKind2["BasicLand"] = "BasicLand";
+  CardKind2["TapLand"] = "TapLand";
+  CardKind2["CheckLand"] = "CheckLand";
+  CardKind2["ShockLand"] = "ShockLand";
+  CardKind2["FastLand"] = "FastLand";
+  CardKind2["SlowLand"] = "SlowLand";
+  CardKind2["BattleLand"] = "BattleLand";
+  CardKind2["TurnLand"] = "TurnLand";
+  CardKind2["SurveilLand"] = "SurveilLand";
+  CardKind2["BounceLand"] = "BounceLand";
+  CardKind2["TriomeLand"] = "TriomeLand";
+  CardKind2["CyclingLand"] = "CyclingLand";
+  CardKind2["PainLand"] = "PainLand";
+  CardKind2["FetchLand"] = "FetchLand";
+  CardKind2["CanopyLand"] = "CanopyLand";
+  CardKind2["PathwayLand"] = "PathwayLand";
+  CardKind2["OtherLand"] = "OtherLand";
+  CardKind2["ForcedLand"] = "ForcedLand";
+  CardKind2["Creature"] = "Creature";
+  CardKind2["Spell"] = "Spell";
+  CardKind2["Enchantment"] = "Enchantment";
+  CardKind2["Instant"] = "Instant";
+  CardKind2["Planeswalker"] = "Planeswalker";
+  CardKind2["Sorcery"] = "Sorcery";
+  CardKind2["Artifact"] = "Artifact";
+  CardKind2["Unknown"] = "Unknown";
+  return CardKind2;
+})(CardKind || {});
+var Rarity = /* @__PURE__ */ ((Rarity2) => {
+  Rarity2["Common"] = "common";
+  Rarity2["Uncommon"] = "uncommon";
+  Rarity2["Rare"] = "rare";
+  Rarity2["Mythic"] = "mythic";
+  Rarity2["Special"] = "special";
+  Rarity2["Bonus"] = "bonus";
+  Rarity2["Other"] = "other";
+  return Rarity2;
+})(Rarity || {});
+function cloneCard(card) {
+  return {
+    ...card,
+    manaCost: { ...card.manaCost },
+    allManaCosts: card.allManaCosts.map((c) => ({ ...c })),
+    basicLandTypes: card.basicLandTypes ?? 0,
+    checkTypes: card.checkTypes ?? 0,
+    manaPerTap: card.manaPerTap ?? 1
+  };
+}
+function isLandKind(kind) {
+  return kind === "BasicLand" /* BasicLand */ || kind === "ShockLand" /* ShockLand */ || kind === "CheckLand" /* CheckLand */ || kind === "TapLand" /* TapLand */ || kind === "FastLand" /* FastLand */ || kind === "SlowLand" /* SlowLand */ || kind === "BattleLand" /* BattleLand */ || kind === "TurnLand" /* TurnLand */ || kind === "SurveilLand" /* SurveilLand */ || kind === "BounceLand" /* BounceLand */ || kind === "TriomeLand" /* TriomeLand */ || kind === "CyclingLand" /* CyclingLand */ || kind === "PainLand" /* PainLand */ || kind === "FetchLand" /* FetchLand */ || kind === "CanopyLand" /* CanopyLand */ || kind === "PathwayLand" /* PathwayLand */ || kind === "OtherLand" /* OtherLand */ || kind === "ForcedLand" /* ForcedLand */;
+}
+function isLand(card) {
+  return isLandKind(card.kind);
+}
+function hashCardName(name) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (let i = 0; i < name.length; i++) {
+    hash ^= BigInt(name.charCodeAt(i));
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return Number(hash & 0x1fffffffffffffn);
+}
+function parseRarity(raw) {
+  switch (raw.toLowerCase()) {
+    case "common":
+      return "common" /* Common */;
+    case "uncommon":
+      return "uncommon" /* Uncommon */;
+    case "rare":
+      return "rare" /* Rare */;
+    case "mythic":
+      return "mythic" /* Mythic */;
+    case "special":
+      return "special" /* Special */;
+    case "bonus":
+      return "bonus" /* Bonus */;
+    default:
+      return "other" /* Other */;
+  }
+}
+function parseSetCode(raw) {
+  return raw.toLowerCase();
+}
+
+// src/card/land-types.ts
+var BasicLandType = {
+  Plains: 1 << 0,
+  Island: 1 << 1,
+  Swamp: 1 << 2,
+  Mountain: 1 << 3,
+  Forest: 1 << 4
+};
+var TYPE_NAME_TO_BIT = [
+  ["plains", BasicLandType.Plains],
+  ["island", BasicLandType.Island],
+  ["swamp", BasicLandType.Swamp],
+  ["mountain", BasicLandType.Mountain],
+  ["forest", BasicLandType.Forest]
+];
+function basicLandTypesFromTypeLine(typeLine) {
+  const lower = typeLine.toLowerCase();
+  let bits2 = 0;
+  for (const [name, bit] of TYPE_NAME_TO_BIT) {
+    if (lower.includes(name)) bits2 |= bit;
+  }
+  return bits2;
+}
+function basicLandTypeCount(typeLine) {
+  const bits2 = basicLandTypesFromTypeLine(typeLine);
+  let n = 0;
+  for (let b = bits2; b !== 0; b >>= 1) n += b & 1;
+  return n;
+}
+function checkTypesFromOracleText(oracleText) {
+  const lower = oracleText.toLowerCase();
+  const idx = lower.indexOf("unless you control");
+  if (idx === -1) return 0;
+  const clause = lower.slice(idx);
+  let bits2 = 0;
+  for (const [name, bit] of TYPE_NAME_TO_BIT) {
+    if (clause.includes(name)) bits2 |= bit;
+  }
+  return bits2;
+}
+function normalizeOracleForEtb(oracleText) {
+  return oracleText.toLowerCase().replace(/enters the battlefield tapped/g, "enters tapped").replace(/\s+/g, " ").trim();
+}
+
+// src/card/mana-color-count.ts
+function newManaColorCount() {
+  return {
+    total: 0,
+    b: 0,
+    u: 0,
+    g: 0,
+    r: 0,
+    w: 0,
+    c: 0,
+    wu: 0,
+    wb: 0,
+    ub: 0,
+    ur: 0,
+    br: 0,
+    bg: 0,
+    rg: 0,
+    rw: 0,
+    gw: 0,
+    gu: 0
+  };
+}
+function countManaColor(mcc, card) {
+  mcc.total += 1;
+  mcc.u += card.u;
+  mcc.r += card.r;
+  mcc.b += card.b;
+  mcc.g += card.g;
+  mcc.w += card.w;
+  mcc.c += card.c;
+  const key = `${card.r},${card.g},${card.b},${card.u},${card.w}`;
+  switch (key) {
+    case "1,1,0,0,0":
+      mcc.rg += 1;
+      break;
+    case "1,0,1,0,0":
+      mcc.br += 1;
+      break;
+    case "1,0,0,1,0":
+      mcc.ur += 1;
+      break;
+    case "1,0,0,0,1":
+      mcc.rw += 1;
+      break;
+    case "0,1,1,0,0":
+      mcc.bg += 1;
+      break;
+    case "0,1,0,1,0":
+      mcc.gu += 1;
+      break;
+    case "0,1,0,0,1":
+      mcc.gw += 1;
+      break;
+    case "0,0,1,1,0":
+      mcc.ub += 1;
+      break;
+    case "0,0,1,0,1":
+      mcc.wb += 1;
+      break;
+    case "0,0,0,1,1":
+      mcc.wu += 1;
+      break;
+  }
+}
+
+// node_modules/fflate/esm/index.mjs
+var import_module = require("module");
+var require2 = (0, import_module.createRequire)("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var gzs = function(d) {
+  if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+    err(6, "invalid gzip data");
+  var flg = d[3];
+  var st = 10;
+  if (flg & 4)
+    st += (d[10] | d[11] << 8) + 2;
+  for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+    ;
+  return st + (flg & 2);
+};
+var gzl = function(d) {
+  var l = d.length;
+  return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+};
+function gunzipSync(data, opts) {
+  var st = gzs(data);
+  if (st + 8 > data.length)
+    err(6, "invalid gzip data");
+  return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// src/data.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_url = require("url");
+
+// src/collection.ts
+function collectionFromCards(cards) {
+  const sorted = [...cards].sort(
+    (a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())
+  );
+  return { cards: sorted };
+}
+function cardFromName(collection, name) {
+  const nameLower = name.toLowerCase();
+  let lo = 0;
+  let hi = collection.cards.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const probe = collection.cards[mid].name.toLowerCase();
+    if (probe.localeCompare(nameLower) < 0) lo = mid + 1;
+    else hi = mid;
+  }
+  const found = collection.cards[lo];
+  if (found && found.name.toLowerCase() === nameLower) return found;
+  return void 0;
+}
+function otherFacesByName(collection, name) {
+  const card = cardFromName(collection, name);
+  if (!card || card.oracleId === "") return [];
+  return collection.cards.filter((c) => c.oracleId === card.oracleId && c.name !== card.name);
+}
+function asCollectionApi(collection) {
+  return {
+    ...collection,
+    cardFromName: (name) => cardFromName(collection, name),
+    otherFacesByName: (name) => otherFacesByName(collection, name),
+    get length() {
+      return collection.cards.length;
+    }
+  };
+}
+
+// src/data.ts
+function resolveDataPath() {
+  const here = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+  const candidates = [
+    (0, import_node_path.join)(here, "../data/all_cards.json.gz"),
+    (0, import_node_path.join)(process.cwd(), "data/all_cards.json.gz")
+  ];
+  for (const p of candidates) {
+    if ((0, import_node_fs.existsSync)(p)) return p;
+  }
+  throw new Error("Cannot find data/all_cards.json.gz \u2014 run `npm run card-update` first");
+}
+function loadCardsFromGzipBytes(bytes) {
+  const jsonBytes = gunzipSync(bytes);
+  const text = new TextDecoder().decode(jsonBytes);
+  const cards = JSON.parse(text);
+  return asCollectionApi(collectionFromCards(cards));
+}
+function loadCardsFromFile(path) {
+  const buf = (0, import_node_fs.readFileSync)(path);
+  return loadCardsFromGzipBytes(new Uint8Array(buf));
+}
+var cached = null;
+function getAllCards() {
+  if (!cached) {
+    cached = loadCardsFromFile(resolveDataPath());
+  }
+  return cached;
+}
+function setAllCards(collection) {
+  cached = collection;
+}
+var ALL_CARDS = new Proxy({}, {
+  get(_target, prop, receiver) {
+    const real = getAllCards();
+    const value = Reflect.get(real, prop, receiver);
+    return typeof value === "function" ? value.bind(real) : value;
+  }
+});
+
+// src/deck.ts
+var DeckcodeError = class extends Error {
+  /**
+   * All unresolved card names from this parse (set/collector stripped).
+   * Prefer this for UI lists when multiple cards are missing.
+   */
+  unknownCardNames;
+  /** First unknown card name; same as `unknownCardNames[0]` when present. */
+  unknownCardName;
+  constructor(message, options) {
+    super(message);
+    this.name = "DeckcodeError";
+    const names = options?.unknownCardNames ?? (options?.unknownCardName ? [options.unknownCardName] : []);
+    this.unknownCardNames = names;
+    this.unknownCardName = names[0] ?? options?.unknownCardName;
+  }
+};
+function newDeck() {
+  return {
+    title: null,
+    url: null,
+    cards: [],
+    format: "standard" /* Standard */,
+    cardCount: 0
+  };
+}
+function deckBuilderBuild(builder) {
+  const deck = newDeck();
+  let count = 0;
+  for (const { card, count: c } of builder.values()) {
+    deck.cards.push({ card, count: c });
+    count += c;
+  }
+  deck.cardCount = count;
+  deck.cards.sort((a, b) => a.card.name.localeCompare(b.card.name));
+  return deck;
+}
+function insertCount(builder, card, count) {
+  const existing = builder.get(card.name);
+  if (existing) existing.count += count;
+  else builder.set(card.name, { card, count });
+}
+function deckFromCards(cards) {
+  const builder = /* @__PURE__ */ new Map();
+  for (const card of cards) insertCount(builder, card, 1);
+  return deckBuilderBuild(builder);
+}
+function deckFlatten(deck) {
+  const result = [];
+  for (const cc of deck.cards) {
+    for (let i = 0; i < cc.count; i++) result.push(cc.card);
+  }
+  return result;
+}
+function deckIsEmpty(deck) {
+  return deck.cardCount === 0;
+}
+function deckIter(deck) {
+  return deck.cards;
+}
+function stripInlineModifiersFromName(name) {
+  for (const sep of [" M=", " m=", " T=", " t=", " X=", " x="]) {
+    const idx = name.lastIndexOf(sep);
+    if (idx !== -1) return name.slice(0, idx).trim();
+  }
+  return name.trim();
+}
+function applyLandFaceFromCard(card, landFace) {
+  card.manaCost = { ...landFace.manaCost };
+  card.allManaCosts = landFace.allManaCosts.map((c) => ({ ...c }));
+  card.manaCostString = landFace.manaCostString;
+  card.turn = landFace.turn;
+  card.kind = "ForcedLand" /* ForcedLand */;
+  card.basicLandTypes = landFace.basicLandTypes ?? 0;
+  card.checkTypes = landFace.checkTypes ?? 0;
+}
+function applyLandFace(card, leftCardName, line) {
+  const landFace = ALL_CARDS.otherFacesByName(leftCardName).find((c) => isLand(c));
+  if (!landFace) {
+    throw new DeckcodeError(
+      `M=auto specified but no land face found for "${leftCardName}" at line ${line}`
+    );
+  }
+  applyLandFaceFromCard(card, landFace);
+}
+var INLINE_M = /\sM\s*=\s*(auto|(?:\{[WUBRGC\d]+\})+)/i;
+var INLINE_T = /\sT\s*=\s*(\d+)/i;
+var INLINE_X = /\sX\s*=\s*(\d+)/i;
+function inlineModifier(line, letter) {
+  const re = letter === "M" ? INLINE_M : letter === "T" ? INLINE_T : INLINE_X;
+  return line.match(re)?.[1];
+}
+var ARENA_LINE_REGEX = /^\s*(?<amount>\d+)\s+(?<name>[^#(\n\r]+)(?:\s*\((?<set>\w+)\)\s+(?<setnum>\d+))?\s*#?(?:\s*[Xx]\s*=\s*(?<X>\d+))?(?:\s*[Tt]\s*=\s*(?<T>\d+))?(?:\s*[Mm]\s*=\s*(?<M>auto|(?:\{[WUBRGC\d]+\})+))?/;
+function deckFromList(list) {
+  const builder = /* @__PURE__ */ new Map();
+  let lookingForDeckLine = false;
+  const unknownCardNames = [];
+  for (const line of list.trim().split(/\r?\n/)) {
+    const trimmed = line.trim();
+    const trimmedLower = trimmed.toLowerCase();
+    if (trimmedLower === "deck") {
+      lookingForDeckLine = false;
+      continue;
+    }
+    if (trimmedLower === "commander" || trimmedLower === "companion" || trimmedLower === "about") {
+      lookingForDeckLine = true;
+      continue;
+    }
+    if (trimmedLower === "sideboard" || trimmedLower === "maybeboard") break;
+    if (trimmed.startsWith("#")) continue;
+    if (lookingForDeckLine) continue;
+    if (trimmed.length === 0) break;
+    const caps = ARENA_LINE_REGEX.exec(trimmed);
+    if (!caps?.groups) {
+      throw new DeckcodeError(`Cannot regex capture deck list line: ${line}`);
+    }
+    const amount = Number.parseInt(caps.groups.amount, 10);
+    if (!Number.isFinite(amount)) {
+      throw new DeckcodeError(`Cannot parse card amount from deck list line: ${line}`);
+    }
+    const name = stripInlineModifiersFromName(caps.groups.name.trim());
+    const set = caps.groups.set ? parseSetCode(caps.groups.set) : "";
+    const leftCardName = name.split("//")[0]?.trim();
+    if (!leftCardName) {
+      throw new DeckcodeError(`Cannot parse card name from deck list line: ${line}`);
+    }
+    const found = ALL_CARDS.cardFromName(leftCardName);
+    if (!found) {
+      if (!unknownCardNames.includes(name)) unknownCardNames.push(name);
+      continue;
+    }
+    const card = cloneCard(found);
+    const xValStr = caps.groups.X ?? inlineModifier(trimmed, "X");
+    if (xValStr !== void 0 && card.manaCostString.includes("X")) {
+      const xVal = Number.parseInt(xValStr, 10);
+      if (!Number.isFinite(xVal)) {
+        throw new DeckcodeError(`Cannot parse X= value from deck list line: ${line}`);
+      }
+      card.manaCost = { ...card.manaCost, c: xVal };
+      card.allManaCosts = card.allManaCosts.map((cost) => ({ ...cost, c: xVal }));
+      card.manaCostString = card.manaCostString.replace(/X/g, String(xVal));
+      card.turn = manaCostCmc(card.manaCost);
+    }
+    const mValStr = caps.groups.M ?? inlineModifier(trimmed, "M");
+    if (mValStr !== void 0) {
+      if (mValStr.toLowerCase() === "auto") {
+        applyLandFace(card, leftCardName, line);
+      } else {
+        const allManaCosts = manaCostsFromStr(mValStr);
+        if (allManaCosts.length === 0) {
+          throw new DeckcodeError(`Problematic mana cost ('M = ') specified at line ${line}`);
+        }
+        card.manaCost = { ...allManaCosts[0] };
+        card.allManaCosts = allManaCosts.map((c) => ({ ...c }));
+        card.turn = manaCostCmc(card.manaCost);
+        card.kind = "ForcedLand" /* ForcedLand */;
+        card.basicLandTypes = 0;
+        card.checkTypes = 0;
+      }
+    } else if (!isLand(card)) {
+      const landFace = ALL_CARDS.otherFacesByName(leftCardName).find((c) => isLand(c));
+      if (landFace) applyLandFaceFromCard(card, landFace);
+    }
+    const turnValStr = caps.groups.T ?? inlineModifier(trimmed, "T");
+    if (turnValStr !== void 0) {
+      const turnVal = Number.parseInt(turnValStr, 10);
+      if (!Number.isFinite(turnVal)) {
+        throw new DeckcodeError(`Cannot parse T= value from deck list line: ${line}`);
+      }
+      card.turn += turnVal;
+    }
+    card.set = set;
+    insertCount(builder, card, amount);
+  }
+  if (unknownCardNames.length > 0) {
+    const message = unknownCardNames.length === 1 ? `Cannot find card named "${unknownCardNames[0]}" in collection` : `Cannot find cards in collection: ${unknownCardNames.map((n) => `"${n}"`).join(", ")}`;
+    throw new DeckcodeError(message, { unknownCardNames });
+  }
+  return deckBuilderBuild(builder);
+}
+function decklist(list) {
+  return deckFromList(list);
+}
+function parseDecklist(list) {
+  try {
+    const deck = deckFromList(list);
+    if (deckIsEmpty(deck)) {
+      return { ok: false, error: new DeckcodeError("Empty deckcode") };
+    }
+    return { ok: true, deck };
+  } catch (e) {
+    if (e instanceof DeckcodeError) return { ok: false, error: e };
+    return { ok: false, error: new DeckcodeError(String(e)) };
+  }
+}
+
+// src/mulligan/types.ts
+function createMulberry32(seed) {
+  let t = seed >>> 0;
+  return {
+    genRange(min, max2) {
+      t = t + 1831565813 >>> 0;
+      let r = Math.imul(t ^ t >>> 15, 1 | t);
+      r ^= r + Math.imul(r ^ r >>> 7, 61 | r);
+      const u = ((r ^ r >>> 14) >>> 0) / 4294967296;
+      return min + Math.floor(u * (max2 - min));
+    }
+  };
+}
+function createEntropyRng() {
+  return createMulberry32(Math.random() * 4294967295 >>> 0);
+}
+function partialShuffle(slice, rng, amount) {
+  const n = Math.min(amount, slice.length);
+  for (let i = 0; i < n; i++) {
+    const j = rng.genRange(i, slice.length);
+    const tmp = slice[i];
+    slice[i] = slice[j];
+    slice[j] = tmp;
+  }
+  return slice.slice(0, n);
+}
+
+// src/bipartite.ts
+function maximumBipartiteMatching(edges, mCount, nCount, seen, matches) {
+  let matchCount = 0;
+  for (let i = 0; i < matches.length; i++) matches[i] = -1;
+  for (let m = 0; m < mCount; m++) {
+    for (let i = 0; i < seen.length; i++) seen[i] = false;
+    if (recursiveFindMatch(edges, nCount, m, seen, matches)) {
+      matchCount += 1;
+    }
+  }
+  return matchCount;
+}
+function recursiveFindMatch(edges, nCount, m, seen, matches) {
+  for (let n = 0; n < nCount; n++) {
+    const i = nCount * m + n;
+    if (edges[i] !== 0 && !seen[n]) {
+      seen[n] = true;
+      const prior = matches[n];
+      const available = prior < 0 || recursiveFindMatch(edges, nCount, prior, seen, matches);
+      if (available) {
+        matches[n] = m;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// src/hand.ts
+function simCardFromCard(card) {
+  return {
+    hash: card.hash,
+    kind: card.kind,
+    manaCost: { ...card.manaCost },
+    basicLandTypes: card.basicLandTypes ?? 0,
+    checkTypes: card.checkTypes ?? 0,
+    manaPerTap: card.manaPerTap ?? 1
+  };
+}
+var PlayOrder = /* @__PURE__ */ ((PlayOrder2) => {
+  PlayOrder2["First"] = "First";
+  PlayOrder2["Second"] = "Second";
+  return PlayOrder2;
+})(PlayOrder || {});
+function newScratch(maxLandCount, maxPipCount) {
+  return {
+    lands: [],
+    edges: new Array(maxLandCount * maxPipCount).fill(0),
+    seen: new Array(maxLandCount).fill(false),
+    matches: new Array(maxLandCount).fill(-1)
+  };
+}
+function handFromOpeningAndDraws(opening, draws, startingHandSize = 7) {
+  const cards = [];
+  for (const card of opening) cards.push(simCardFromCard(card));
+  for (const card of draws) cards.push(simCardFromCard(card));
+  const openingHandSize = opening.length;
+  return {
+    cards,
+    startingHandSize,
+    openingHandSize,
+    mulliganCount: startingHandSize - openingHandSize
+  };
+}
+function handFromMulligan(mulligan, rng, deck, draws) {
+  return mulligan.simulateHand(rng, deck, draws);
+}
+function handOpening(hand) {
+  return hand.cards.slice(0, hand.openingHandSize);
+}
+function handDraws(hand, drawCount) {
+  return hand.cards.slice(hand.openingHandSize, hand.openingHandSize + drawCount);
+}
+function handOpeningWithDraws(hand, drawCount) {
+  return hand.cards.slice(0, hand.openingHandSize + drawCount);
+}
+function countInOpeningWithDraws(hand, drawCount, predicate) {
+  let count = 0;
+  for (const card of handOpeningWithDraws(hand, drawCount)) {
+    if (predicate(card)) count += 1;
+  }
+  return count;
+}
+function autoTapByTurn(hand, goal, turn, playOrder) {
+  const scratch = newScratch(30, 8);
+  return autoTapWithScratch(hand, simCardFromCard(goal), turn, playOrder, scratch);
+}
+function playCmcAutoTap(hand, goal) {
+  return autoTapByTurn(hand, goal, Math.max(1, goal.turn), "First" /* First */);
+}
+function drawCmcAutoTap(hand, goal) {
+  return autoTapByTurn(hand, goal, Math.max(1, goal.turn), "Second" /* Second */);
+}
+function isAlwaysAvailableKind(kind) {
+  return kind === "BasicLand" /* BasicLand */ || kind === "OtherLand" /* OtherLand */ || kind === "ForcedLand" /* ForcedLand */ || kind === "ShockLand" /* ShockLand */ || kind === "PainLand" /* PainLand */ || kind === "FetchLand" /* FetchLand */ || kind === "CanopyLand" /* CanopyLand */ || kind === "PathwayLand" /* PathwayLand */;
+}
+function isConditionalEtbKind(kind) {
+  return kind === "TapLand" /* TapLand */ || kind === "CheckLand" /* CheckLand */ || kind === "FastLand" /* FastLand */ || kind === "SlowLand" /* SlowLand */ || kind === "BattleLand" /* BattleLand */ || kind === "TurnLand" /* TurnLand */ || kind === "SurveilLand" /* SurveilLand */ || kind === "BounceLand" /* BounceLand */ || kind === "TriomeLand" /* TriomeLand */ || kind === "CyclingLand" /* CyclingLand */;
+}
+function pushLandColumns(lands, card) {
+  const copies = card.manaPerTap ?? 1;
+  for (let k = 0; k < copies; k++) lands.push(card);
+}
+function availableTurnForLand(card, playTurn, otherLands, boardTypes, basicsOnBoard = 0) {
+  switch (card.kind) {
+    case "TapLand" /* TapLand */:
+    case "SurveilLand" /* SurveilLand */:
+    case "BounceLand" /* BounceLand */:
+    case "TriomeLand" /* TriomeLand */:
+    case "CyclingLand" /* CyclingLand */:
+      return playTurn + 1;
+    case "CheckLand" /* CheckLand */: {
+      const unlocked = (boardTypes & card.checkTypes) !== 0;
+      return unlocked ? playTurn : playTurn + 1;
+    }
+    case "FastLand" /* FastLand */:
+      return otherLands <= 2 ? playTurn : playTurn + 1;
+    case "SlowLand" /* SlowLand */:
+      return otherLands >= 2 ? playTurn : playTurn + 1;
+    case "BattleLand" /* BattleLand */:
+      return basicsOnBoard >= 2 ? playTurn : playTurn + 1;
+    case "TurnLand" /* TurnLand */:
+      return playTurn <= 3 ? playTurn : playTurn + 1;
+    default:
+      return playTurn;
+  }
+}
+function scheduleLandPlays(openingHand, drawn, playOrder) {
+  const candidates = [];
+  let openingLandIdx = 0;
+  for (const card of openingHand) {
+    if (!isLandKind(card.kind)) continue;
+    openingLandIdx += 1;
+    candidates.push({ card, earliest: openingLandIdx });
+  }
+  for (let drawIdx = 0; drawIdx < drawn.length; drawIdx++) {
+    const card = drawn[drawIdx];
+    if (!isLandKind(card.kind)) continue;
+    const earliest = playOrder === "First" /* First */ ? drawIdx + 2 : drawIdx + 1;
+    candidates.push({ card, earliest });
+  }
+  const scheduled = [];
+  let lastPlayTurn = 0;
+  for (const { card, earliest } of candidates) {
+    const playTurn = Math.max(earliest, lastPlayTurn + 1);
+    scheduled.push({ card, playTurn });
+    lastPlayTurn = playTurn;
+  }
+  return scheduled;
+}
+function autoTapWithScratch(hand, goal, turn, playOrder, scratch) {
+  const drawCount = playOrder === "First" /* First */ ? turn - 1 : turn;
+  const openingHand = handOpening(hand);
+  const drawn = handDraws(hand, drawCount);
+  let inOpeningHand = false;
+  let inDrawHand = false;
+  for (const card of openingHand) {
+    if (card.hash === goal.hash) inOpeningHand = true;
+  }
+  for (const card of drawn) {
+    if (card.hash === goal.hash) inDrawHand = true;
+  }
+  const scheduled = scheduleLandPlays(openingHand, drawn, playOrder);
+  scratch.lands.length = 0;
+  let boardTypes = 0;
+  let basicsOnBoard = 0;
+  for (let i = 0; i < scheduled.length; i++) {
+    const { card, playTurn } = scheduled[i];
+    const otherLands = i;
+    if (isAlwaysAvailableKind(card.kind)) {
+      pushLandColumns(scratch.lands, card);
+    } else if (isConditionalEtbKind(card.kind)) {
+      const availableTurn = availableTurnForLand(
+        card,
+        playTurn,
+        otherLands,
+        boardTypes,
+        basicsOnBoard
+      );
+      if (availableTurn <= turn) pushLandColumns(scratch.lands, card);
+    } else {
+      pushLandColumns(scratch.lands, card);
+    }
+    boardTypes |= card.basicLandTypes;
+    if (card.kind === "BasicLand" /* BasicLand */) basicsOnBoard += 1;
+  }
+  const pipCount = goal.manaCost.r + goal.manaCost.g + goal.manaCost.b + goal.manaCost.u + goal.manaCost.w + goal.manaCost.c;
+  const landCount = scratch.lands.length;
+  if (landCount < pipCount) {
+    return { paid: false, cmc: false, inOpeningHand, inDrawHand };
+  }
+  const edgeLen = pipCount * landCount;
+  if (scratch.edges.length !== edgeLen) {
+    scratch.edges = new Array(edgeLen).fill(0);
+  } else {
+    scratch.edges.fill(0);
+  }
+  if (scratch.seen.length !== landCount) {
+    scratch.seen = new Array(landCount).fill(false);
+  }
+  if (scratch.matches.length !== landCount) {
+    scratch.matches = new Array(landCount).fill(-1);
+  }
+  let row = 0;
+  for (let m = 0; m < goal.manaCost.r; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.r;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.g; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.g;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.b; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.b;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.u; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.u;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.w; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = scratch.lands[n].manaCost.w;
+    }
+  }
+  for (let m = 0; m < goal.manaCost.c; m++, row++) {
+    for (let n = 0; n < landCount; n++) {
+      scratch.edges[landCount * row + n] = 1;
+    }
+  }
+  const pipsPaid = maximumBipartiteMatching(
+    scratch.edges,
+    pipCount,
+    landCount,
+    scratch.seen,
+    scratch.matches
+  );
+  return {
+    paid: pipsPaid === pipCount,
+    cmc: true,
+    inOpeningHand,
+    inDrawHand
+  };
+}
+
+// src/mulligan/london.ts
+var STARTING_HAND_SIZE = 7;
+function londonNever() {
+  return {
+    startingHandSize: STARTING_HAND_SIZE,
+    mulliganDownTo: STARTING_HAND_SIZE,
+    mulliganOnLands: /* @__PURE__ */ new Set(),
+    acceptableHandList: []
+  };
+}
+function londonSimulateHand(self, rng, deck, draws) {
+  const deckSize = deck.length;
+  const startingHandSize = Math.min(self.startingHandSize, deckSize);
+  const mulliganDownTo = Math.min(self.mulliganDownTo, startingHandSize);
+  const maxMulliganRounds = startingHandSize - mulliganDownTo + 1;
+  const cardsToDraw = Math.min(startingHandSize + draws + maxMulliganRounds, deckSize);
+  const indexRange = Array.from({ length: deckSize }, (_, i) => i);
+  const mustKeepCardIndices = [];
+  const seenCardHashes = /* @__PURE__ */ new Set();
+  for (let round = 0; round < maxMulliganRounds; round++) {
+    const shuffledIndices2 = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+    const shuffledDeck2 = shuffledIndices2.map((i) => deck[i]);
+    const startingHand = shuffledDeck2.slice(0, startingHandSize);
+    const isLastRound = round === maxMulliganRounds - 1;
+    let landCount = 0;
+    for (const c of startingHand) {
+      if (isLand(c)) landCount += 1;
+    }
+    const sufficientLandCount = !self.mulliganOnLands.has(landCount);
+    if (!isLastRound && !sufficientLandCount) continue;
+    let foundAcceptableHand = false;
+    for (const acceptableHand of self.acceptableHandList) {
+      mustKeepCardIndices.length = 0;
+      seenCardHashes.clear();
+      for (let i = 0; i < startingHand.length; i++) {
+        const card = startingHand[i];
+        if (seenCardHashes.has(card.hash)) continue;
+        if (acceptableHand.has(card.hash)) mustKeepCardIndices.push(i);
+        seenCardHashes.add(card.hash);
+      }
+      foundAcceptableHand = mustKeepCardIndices.length === acceptableHand.size;
+      if (foundAcceptableHand) break;
+    }
+    const disregardFoundAcceptableHand = self.acceptableHandList.length === 0;
+    const keep = isLastRound || sufficientLandCount && (disregardFoundAcceptableHand || foundAcceptableHand);
+    if (!keep) continue;
+    const openingHandSize = startingHandSize - round;
+    let landsSaved = 0;
+    for (let i = 0; i < startingHand.length; i++) {
+      const card = startingHand[i];
+      if (!isLandKind(card.kind)) continue;
+      const needMoreLands = self.mulliganOnLands.has(landsSaved) && landsSaved < openingHandSize;
+      if (needMoreLands) {
+        mustKeepCardIndices.push(i);
+        landsSaved += 1;
+      } else {
+        break;
+      }
+    }
+    mustKeepCardIndices.sort((a, b) => a - b);
+    {
+      let w = 0;
+      for (let r = 0; r < mustKeepCardIndices.length; r++) {
+        if (r === 0 || mustKeepCardIndices[r] !== mustKeepCardIndices[r - 1]) {
+          mustKeepCardIndices[w++] = mustKeepCardIndices[r];
+        }
+      }
+      mustKeepCardIndices.length = w;
+    }
+    for (let i = 0; i < mustKeepCardIndices.length; i++) {
+      const mustKeepI = mustKeepCardIndices[i];
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[mustKeepI];
+      shuffledDeck2[mustKeepI] = tmp;
+    }
+    let discardCount = 0;
+    for (let i = openingHandSize; i < startingHandSize; i++) {
+      const j = cardsToDraw - 1 - discardCount;
+      const tmp = shuffledDeck2[i];
+      shuffledDeck2[i] = shuffledDeck2[j];
+      shuffledDeck2[j] = tmp;
+      discardCount += 1;
+    }
+    return handFromOpeningAndDraws(
+      shuffledDeck2.slice(0, openingHandSize),
+      shuffledDeck2.slice(openingHandSize),
+      startingHandSize
+    );
+  }
+  const shuffledIndices = partialShuffle(indexRange.slice(), rng, cardsToDraw);
+  const shuffledDeck = shuffledIndices.map((i) => deck[i]);
+  return handFromOpeningAndDraws(
+    shuffledDeck.slice(0, startingHandSize),
+    shuffledDeck.slice(startingHandSize),
+    startingHandSize
+  );
+}
+function asLondonMulligan(london) {
+  return {
+    simulateHand: (rng, deck, draws) => londonSimulateHand(london, rng, deck, draws)
+  };
+}
+
+// src/mulligan/never.ts
+var STARTING_HAND_SIZE2 = 7;
+function newNever() {
+  return { startingHandSize: STARTING_HAND_SIZE2 };
+}
+function neverSimulateHand(self, rng, deck, draws) {
+  const deckLen = deck.length;
+  const cardsToDraw = Math.min(deckLen, self.startingHandSize + draws);
+  const startingHandSize = Math.min(deckLen, self.startingHandSize);
+  const indexRange = Array.from({ length: deckLen }, (_, i) => i);
+  const shuffledIndices = partialShuffle(indexRange, rng, cardsToDraw);
+  const shuffledDeck = shuffledIndices.map((i) => deck[i]);
+  return handFromOpeningAndDraws(
+    shuffledDeck.slice(0, startingHandSize),
+    shuffledDeck.slice(startingHandSize),
+    startingHandSize
+  );
+}
+function asNeverMulligan(n = newNever()) {
+  return {
+    simulateHand: (rng, deck, draws) => neverSimulateHand(n, rng, deck, draws)
+  };
+}
+
+// src/simulation.ts
+var import_node_os2 = require("os");
+
+// src/parallel.ts
+var import_node_fs2 = require("fs");
+var import_node_os = require("os");
+var import_node_path2 = require("path");
+var import_node_url2 = require("url");
+var import_node_worker_threads = require("worker_threads");
+function createShardWorker(payload) {
+  const fromSrc = /[/\\]src[/\\]/.test((0, import_node_url2.fileURLToPath)(importMetaUrl));
+  if (fromSrc) {
+    return new import_node_worker_threads.Worker(new URL("./simulation-worker.ts", importMetaUrl), {
+      workerData: payload,
+      execArgv: ["--import", "tsx"]
+    });
+  }
+  return new import_node_worker_threads.Worker(new URL("./simulation-worker.js", importMetaUrl), {
+    workerData: payload
+  });
+}
+function generateHandsParallelSync(req) {
+  const nWorkers = Math.max(1, Math.min(req.workers, req.runCount));
+  const dir = (0, import_node_fs2.mkdtempSync)((0, import_node_path2.join)((0, import_node_os.tmpdir)(), "landlord-hands-"));
+  const sab = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * nWorkers);
+  const statuses = new Int32Array(sab);
+  const workers = [];
+  const baseSeed = req.seed ?? Math.random() * 4294967295 >>> 0;
+  try {
+    let remaining = req.runCount;
+    let offset = 0;
+    for (let i = 0; i < nWorkers; i++) {
+      const shard = Math.floor(remaining / (nWorkers - i));
+      remaining -= shard;
+      const outFile = (0, import_node_path2.join)(dir, `shard-${i}.json`);
+      const seed = baseSeed + offset * 2654435769 >>> 0;
+      offset += shard;
+      const payload = {
+        outFile,
+        statusIndex: i,
+        sab,
+        runCount: shard,
+        drawCount: req.drawCount,
+        deck: req.deck,
+        seed,
+        startingHandSize: req.startingHandSize,
+        mulliganDownTo: req.mulliganDownTo,
+        mulliganOnLands: req.mulliganOnLands,
+        acceptableHandList: req.acceptableHandList
+      };
+      const worker = createShardWorker(payload);
+      workers.push(worker);
+      worker.on("error", () => {
+        Atomics.store(statuses, i, -1);
+        Atomics.notify(statuses, i);
+      });
+    }
+    for (let i = 0; i < nWorkers; i++) {
+      while (Atomics.load(statuses, i) === 0) {
+        Atomics.wait(statuses, i, 0, 50);
+      }
+      if (Atomics.load(statuses, i) < 0) {
+        throw new Error(`worker shard ${i} failed`);
+      }
+    }
+    const hands = [];
+    for (let i = 0; i < nWorkers; i++) {
+      const text = (0, import_node_fs2.readFileSync)((0, import_node_path2.join)(dir, `shard-${i}.json`), "utf8");
+      const shardHands = JSON.parse(text);
+      hands.push(...shardHands);
+    }
+    return hands;
+  } finally {
+    for (const w of workers) {
+      void w.terminate();
+    }
+    try {
+      (0, import_node_fs2.rmSync)(dir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/yield-macrotask.ts
+function yieldMacrotask() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
+// src/simulation.ts
+function newObservations() {
+  return { mana: 0, cmc: 0, play: 0, inOpeningHand: 0, totalRuns: 0 };
+}
+function pMana(obs) {
+  return obs.mana / obs.totalRuns;
+}
+function pManaGivenCmc(obs) {
+  return obs.cmc === 0 ? 0 : obs.mana / obs.cmc;
+}
+function pPlay(obs) {
+  return obs.play / obs.totalRuns;
+}
+function wilsonHalfWidth(successes, trials, z = 1.96) {
+  if (trials <= 0) return 1;
+  const p = successes / trials;
+  const z2 = z * z;
+  const denom = 1 + z2 / trials;
+  const center = p + z2 / (2 * trials);
+  const margin = z * Math.sqrt((p * (1 - p) + z2 / (4 * trials)) / trials);
+  const hi = (center + margin) / denom;
+  const lo = (center - margin) / denom;
+  return (hi - lo) / 2;
+}
+var PARALLEL_THRESHOLD = 2e3;
+var EARLY_STOP_BATCH = 1e3;
+function accumulateOpeningStats(hands) {
+  return {
+    accumulatedOpeningHandSize: hands.reduce((sum, hand) => sum + handOpening(hand).length, 0),
+    accumulatedOpeningHandLandCount: hands.reduce(
+      (sum, hand) => sum + countInOpeningWithDraws(hand, 0, (c) => isLandKind(c.kind)),
+      0
+    )
+  };
+}
+function generateHandsSequential(runCount, mulligan, deck, drawCount, seed) {
+  const rng = seed !== void 0 ? createMulberry32(seed) : createEntropyRng();
+  const hands = [];
+  for (let i = 0; i < runCount; i++) {
+    hands.push(handFromMulligan(mulligan, rng, deck, drawCount));
+  }
+  return hands;
+}
+function shouldParallel(config) {
+  if (config.parallel === false) return false;
+  if (config.seed !== void 0 && config.parallel !== true) return false;
+  if (config.parallel === true) return config.runCount >= 2;
+  return config.runCount >= PARALLEL_THRESHOLD;
+}
+function simulationFromConfig(config) {
+  if (config.runCount <= 0) throw new Error("runCount must be > 0");
+  const deck = deckFlatten(config.deck);
+  let hands;
+  if (shouldParallel(config)) {
+    try {
+      hands = generateHandsParallelSync({
+        runCount: config.runCount,
+        drawCount: config.drawCount,
+        deck,
+        seed: config.seed,
+        startingHandSize: config.startingHandSize ?? 7,
+        mulliganDownTo: config.mulliganDownTo ?? config.startingHandSize ?? 7,
+        mulliganOnLands: config.mulliganOnLands ?? [],
+        acceptableHandList: config.acceptableHandList ?? [],
+        workers: Math.min((0, import_node_os2.availableParallelism)(), config.runCount)
+      });
+    } catch {
+      hands = generateHandsSequential(
+        config.runCount,
+        config.mulligan,
+        deck,
+        config.drawCount,
+        config.seed
+      );
+    }
+  } else {
+    hands = generateHandsSequential(
+      config.runCount,
+      config.mulligan,
+      deck,
+      config.drawCount,
+      config.seed
+    );
+  }
+  const stats = accumulateOpeningStats(hands);
+  return {
+    hands,
+    ...stats,
+    onThePlay: config.onThePlay
+  };
+}
+function simulationFromConfigAdaptive(config, cards) {
+  if (config.epsilon === void 0) return simulationFromConfig(config);
+  const maxRuns = config.runCount;
+  const hands = [];
+  let seed = config.seed;
+  const playOrder = config.onThePlay ? "First" /* First */ : "Second" /* Second */;
+  while (hands.length < maxRuns) {
+    const batch = Math.min(EARLY_STOP_BATCH, maxRuns - hands.length);
+    const batchConfig = {
+      ...config,
+      runCount: batch,
+      seed,
+      parallel: false
+    };
+    const batchSim = simulationFromConfig(batchConfig);
+    hands.push(...batchSim.hands);
+    if (seed !== void 0) seed = seed + batch * 2654435769 >>> 0;
+    if (hands.length >= Math.min(EARLY_STOP_BATCH, maxRuns)) {
+      if (aggregateWilsonMet(hands, cards, playOrder, config.epsilon)) break;
+    }
+  }
+  const stats = accumulateOpeningStats(hands);
+  return { hands, ...stats, onThePlay: config.onThePlay };
+}
+var DEFAULT_ASYNC_BATCH = 500;
+function throwIfAborted(signal) {
+  signal?.throwIfAborted();
+}
+function aggregateWilsonMet(hands, cards, playOrder, epsilon) {
+  let mana = 0;
+  let cmc = 0;
+  const scratch = newScratch(30, 10);
+  for (const card of cards) {
+    if (isLandKind(card.kind)) continue;
+    for (const hand of hands) {
+      let result = {
+        paid: false,
+        cmc: false,
+        inOpeningHand: false,
+        inDrawHand: false
+      };
+      for (const manaCost of card.allManaCosts) {
+        const goal = {
+          hash: card.hash,
+          manaCost: { ...manaCost },
+          kind: card.kind,
+          basicLandTypes: card.basicLandTypes ?? 0,
+          checkTypes: card.checkTypes ?? 0,
+          manaPerTap: card.manaPerTap ?? 1
+        };
+        result = autoTapWithScratch(hand, goal, card.turn, playOrder, scratch);
+        if (result.paid) break;
+      }
+      if (!result.cmc) continue;
+      cmc += 1;
+      if (result.paid) mana += 1;
+    }
+  }
+  return cmc > 0 && wilsonHalfWidth(mana, cmc) < epsilon;
+}
+async function simulationFromConfigAsync(config, options = {}) {
+  if (config.runCount <= 0) throw new Error("runCount must be > 0");
+  const onProgress = options.onProgress;
+  const signal = options.signal;
+  const total = config.runCount;
+  const playOrder = config.onThePlay ? "First" /* First */ : "Second" /* Second */;
+  const shouldYield = onProgress !== void 0 || signal !== void 0;
+  const report = async (completed) => {
+    throwIfAborted(signal);
+    onProgress?.({ completed, total });
+    if (!shouldYield) return;
+    await yieldMacrotask();
+    throwIfAborted(signal);
+  };
+  if (config.epsilon !== void 0) {
+    if (options.cards === void 0) {
+      throw new Error("cards is required when epsilon is set");
+    }
+    const batchSize2 = EARLY_STOP_BATCH;
+    const cards = options.cards;
+    const hands2 = [];
+    let seed = config.seed;
+    while (hands2.length < total) {
+      throwIfAborted(signal);
+      const batch = Math.min(batchSize2, total - hands2.length);
+      const batchConfig = {
+        ...config,
+        runCount: batch,
+        seed,
+        parallel: false,
+        epsilon: void 0
+      };
+      const batchSim = simulationFromConfig(batchConfig);
+      hands2.push(...batchSim.hands);
+      if (seed !== void 0) seed = seed + batch * 2654435769 >>> 0;
+      await report(hands2.length);
+      if (hands2.length >= Math.min(EARLY_STOP_BATCH, total) && aggregateWilsonMet(hands2, cards, playOrder, config.epsilon)) {
+        break;
+      }
+    }
+    const stats2 = accumulateOpeningStats(hands2);
+    return { hands: hands2, ...stats2, onThePlay: config.onThePlay };
+  }
+  const deck = deckFlatten(config.deck);
+  const batchSize = Math.max(1, options.batchSize ?? DEFAULT_ASYNC_BATCH);
+  const rng = config.seed !== void 0 ? createMulberry32(config.seed) : createEntropyRng();
+  const hands = [];
+  while (hands.length < total) {
+    throwIfAborted(signal);
+    const n = Math.min(batchSize, total - hands.length);
+    for (let i = 0; i < n; i++) {
+      hands.push(handFromMulligan(config.mulligan, rng, deck, config.drawCount));
+    }
+    await report(hands.length);
+  }
+  const stats = accumulateOpeningStats(hands);
+  return { hands, ...stats, onThePlay: config.onThePlay };
+}
+function observationsForCard(sim, card) {
+  return observationsForCardByTurn(sim, card, card.turn);
+}
+function observationsForCardByTurn(sim, card, turn) {
+  const observations = newObservations();
+  observations.totalRuns = sim.hands.length;
+  const scratch = newScratch(30, 10);
+  const playOrder = sim.onThePlay ? "First" /* First */ : "Second" /* Second */;
+  for (const hand of sim.hands) {
+    let result = {
+      paid: false,
+      cmc: false,
+      inOpeningHand: false,
+      inDrawHand: false
+    };
+    for (const manaCost of card.allManaCosts) {
+      const goal = {
+        hash: card.hash,
+        manaCost: { ...manaCost },
+        kind: card.kind,
+        basicLandTypes: card.basicLandTypes ?? 0,
+        checkTypes: card.checkTypes ?? 0,
+        manaPerTap: card.manaPerTap ?? 1
+      };
+      result = autoTapWithScratch(hand, goal, turn, playOrder, scratch);
+      if (result.paid) break;
+    }
+    if (result.inOpeningHand) observations.inOpeningHand += 1;
+    if (!result.cmc) continue;
+    observations.cmc += 1;
+    if (result.paid) {
+      observations.mana += 1;
+      if (result.inOpeningHand || result.inDrawHand) {
+        observations.play += 1;
+      }
+    }
+  }
+  return observations;
+}
+
+// src/observations-report.ts
+var COLOR_CONSTRAINED_THRESHOLD = 0.15;
+var DRAW_DEPENDENT_THRESHOLD = 0.15;
+function emptyObservationsReport() {
+  return {
+    totalSimulations: 0,
+    avgOpeningHandSize: 0,
+    avgOpeningLandCount: 0,
+    deckSize: 0,
+    deckAverageCmc: 0,
+    cards: [],
+    weakestOnCurve: [],
+    colorConstrained: [],
+    drawDependent: []
+  };
+}
+function cardReportFromInput(input) {
+  const { observations: o } = input;
+  const total = o.totalRuns;
+  const played = o.play;
+  return {
+    name: input.name,
+    manaCost: input.manaCost,
+    imageUri: input.imageUri,
+    kind: input.kind,
+    turn: input.turn,
+    copies: input.copies,
+    cmc: input.cmc,
+    playedOnCurve: played,
+    notPlayedOnCurve: total - played,
+    totalSimulations: total,
+    pCastOnCurve: pPlay(o),
+    pManaGivenCmc: pManaGivenCmc(o),
+    pInOpeningHand: total === 0 ? 0 : o.inOpeningHand / total,
+    notEnoughLands: total - o.cmc,
+    colorOrTimingFail: o.cmc - o.mana,
+    manaOkUndrawn: o.mana - o.play
+  };
+}
+function compareCardsByCmcThenName(a, b) {
+  return a.cmc - b.cmc || a.name.localeCompare(b.name);
+}
+function buildObservationsReport(input) {
+  const total = input.totalSimulations;
+  const cards = input.cards.map(cardReportFromInput);
+  cards.sort(compareCardsByCmcThenName);
+  const weakestOnCurve = cards.map((c) => ({
+    name: c.name,
+    pCastOnCurve: c.pCastOnCurve,
+    turn: c.turn
+  })).sort((a, b) => a.pCastOnCurve - b.pCastOnCurve);
+  const colorConstrained = [];
+  const drawDependent = [];
+  for (const inputCard of input.cards) {
+    const o = inputCard.observations;
+    if (o.cmc > 0 && (o.cmc - o.mana) / o.cmc >= COLOR_CONSTRAINED_THRESHOLD) {
+      colorConstrained.push({
+        name: inputCard.name,
+        colorOrTimingFail: o.cmc - o.mana,
+        cmcOpportunities: o.cmc
+      });
+    }
+    if (o.mana > 0 && (o.mana - o.play) / o.mana >= DRAW_DEPENDENT_THRESHOLD) {
+      drawDependent.push({
+        name: inputCard.name,
+        manaOkUndrawn: o.mana - o.play,
+        manaHits: o.mana
+      });
+    }
+  }
+  colorConstrained.sort(
+    (a, b) => b.colorOrTimingFail / b.cmcOpportunities - a.colorOrTimingFail / a.cmcOpportunities
+  );
+  drawDependent.sort((a, b) => b.manaOkUndrawn / b.manaHits - a.manaOkUndrawn / a.manaHits);
+  return {
+    totalSimulations: total,
+    avgOpeningHandSize: total === 0 ? 0 : input.accumulatedOpeningHandSize / total,
+    avgOpeningLandCount: total === 0 ? 0 : input.accumulatedOpeningHandLandCount / total,
+    deckSize: input.deckSize,
+    deckAverageCmc: input.deckAverageCmc,
+    cards,
+    weakestOnCurve,
+    colorConstrained,
+    drawDependent
+  };
+}
+
+// src/run.ts
+var RunValidationError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RunValidationError";
+  }
+};
+function emptyLandCounts() {
+  return {
+    totalLandCounts: newManaColorCount(),
+    basicLandCounts: newManaColorCount(),
+    tapLandCounts: newManaColorCount(),
+    checkLandCounts: newManaColorCount(),
+    shockLandCounts: newManaColorCount(),
+    fastLandCounts: newManaColorCount(),
+    slowLandCounts: newManaColorCount(),
+    battleLandCounts: newManaColorCount(),
+    turnLandCounts: newManaColorCount(),
+    surveilLandCounts: newManaColorCount(),
+    bounceLandCounts: newManaColorCount(),
+    triomeLandCounts: newManaColorCount(),
+    cyclingLandCounts: newManaColorCount(),
+    painLandCounts: newManaColorCount(),
+    fetchLandCounts: newManaColorCount(),
+    canopyLandCounts: newManaColorCount(),
+    pathwayLandCounts: newManaColorCount(),
+    otherLandCounts: newManaColorCount(),
+    nonLandCounts: newManaColorCount()
+  };
+}
+function emptyOutput() {
+  const report = emptyObservationsReport();
+  return {
+    ...report,
+    landCounts: [],
+    ...emptyLandCounts()
+  };
+}
+function prepareRun(input) {
+  let deck;
+  try {
+    deck = deckFromList(input.code);
+  } catch (e) {
+    const msg = e instanceof DeckcodeError ? e.message : String(e);
+    throw new RunValidationError(`Bad deckcode: ${msg}`, { cause: e });
+  }
+  if (deckIsEmpty(deck)) {
+    throw new RunValidationError("Empty deckcode");
+  }
+  const highestTurn = deckIter(deck).reduce((max2, c) => Math.max(max2, c.card.turn), 0);
+  const startingHandSize = input.startingHandSize ?? 7;
+  const london = londonNever();
+  london.startingHandSize = startingHandSize;
+  london.mulliganDownTo = input.mulliganDownTo;
+  london.mulliganOnLands = new Set(input.mulliganOnLands);
+  const acceptableHashes = [];
+  for (let i = 0; i < input.acceptableHandList.length; i++) {
+    const acceptableHand = input.acceptableHandList[i];
+    const keepCards = /* @__PURE__ */ new Set();
+    for (const cardName of acceptableHand) {
+      const card = ALL_CARDS.cardFromName(cardName);
+      if (!card) {
+        throw new RunValidationError(`Bad card name in acceptableHandList row ${i}: ${cardName}`);
+      }
+      keepCards.add(card.hash);
+    }
+    if (keepCards.size > 0) {
+      london.acceptableHandList.push(keepCards);
+      acceptableHashes.push([...keepCards]);
+    }
+  }
+  const simConfig = {
+    runCount: input.runs,
+    drawCount: highestTurn,
+    mulligan: asLondonMulligan(london),
+    deck,
+    onThePlay: input.onThePlay,
+    seed: input.seed,
+    epsilon: input.epsilon,
+    parallel: input.parallel,
+    startingHandSize,
+    mulliganDownTo: input.mulliganDownTo,
+    mulliganOnLands: input.mulliganOnLands,
+    acceptableHandList: acceptableHashes
+  };
+  const nonLandCards = deckIter(deck).filter((c) => !isLand(c.card)).map((c) => c.card);
+  return { deck, simConfig, nonLandCards };
+}
+function simulationToOutput(deck, sim) {
+  const outputs = emptyOutput();
+  const nonLandWithObs = deckIter(deck).filter((c) => !isLand(c.card)).map((c) => ({
+    name: c.card.name,
+    manaCost: c.card.manaCostString,
+    imageUri: c.card.imageUri,
+    kind: c.card.kind,
+    turn: c.card.turn,
+    copies: c.count,
+    cmc: manaCostCmc(c.card.manaCost),
+    observations: observationsForCardByTurn(sim, c.card, c.card.turn)
+  }));
+  const deckLen = deck.cardCount;
+  const nonLandEntries = deckIter(deck).filter((c) => !isLand(c.card));
+  const nonLandCount = nonLandEntries.reduce((n, c) => n + c.count, 0);
+  const deckAverageCmc = nonLandCount === 0 ? 0 : nonLandEntries.reduce((sum, c) => sum + c.count * manaCostCmc(c.card.manaCost), 0) / nonLandCount;
+  const report = buildObservationsReport({
+    cards: nonLandWithObs,
+    totalSimulations: sim.hands.length,
+    accumulatedOpeningHandSize: sim.accumulatedOpeningHandSize,
+    accumulatedOpeningHandLandCount: sim.accumulatedOpeningHandLandCount,
+    deckSize: deckLen,
+    deckAverageCmc
+  });
+  outputs.totalSimulations = report.totalSimulations;
+  outputs.avgOpeningHandSize = report.avgOpeningHandSize;
+  outputs.avgOpeningLandCount = report.avgOpeningLandCount;
+  outputs.deckSize = report.deckSize;
+  outputs.deckAverageCmc = report.deckAverageCmc;
+  outputs.cards = report.cards;
+  outputs.weakestOnCurve = report.weakestOnCurve;
+  outputs.colorConstrained = report.colorConstrained;
+  outputs.drawDependent = report.drawDependent;
+  outputs.landCounts = deckIter(deck).filter((c) => isLand(c.card)).map((c) => ({
+    name: c.card.name,
+    manaCost: c.card.manaCostString,
+    imageUri: c.card.imageUri,
+    kind: c.card.kind,
+    copies: c.count,
+    hash: c.card.hash
+  }));
+  outputs.landCounts.sort(
+    (a, b) => String(a.kind).localeCompare(String(b.kind)) || a.name.localeCompare(b.name)
+  );
+  for (const cc of deckIter(deck)) {
+    for (let i = 0; i < cc.count; i++) {
+      const card = cc.card;
+      if (isLand(card)) {
+        countManaColor(outputs.totalLandCounts, card.manaCost);
+      }
+      switch (card.kind) {
+        case "BasicLand" /* BasicLand */:
+          countManaColor(outputs.basicLandCounts, card.manaCost);
+          break;
+        case "CheckLand" /* CheckLand */:
+          countManaColor(outputs.checkLandCounts, card.manaCost);
+          break;
+        case "TapLand" /* TapLand */:
+          countManaColor(outputs.tapLandCounts, card.manaCost);
+          break;
+        case "ShockLand" /* ShockLand */:
+          countManaColor(outputs.shockLandCounts, card.manaCost);
+          break;
+        case "FastLand" /* FastLand */:
+          countManaColor(outputs.fastLandCounts, card.manaCost);
+          break;
+        case "SlowLand" /* SlowLand */:
+          countManaColor(outputs.slowLandCounts, card.manaCost);
+          break;
+        case "BattleLand" /* BattleLand */:
+          countManaColor(outputs.battleLandCounts, card.manaCost);
+          break;
+        case "TurnLand" /* TurnLand */:
+          countManaColor(outputs.turnLandCounts, card.manaCost);
+          break;
+        case "SurveilLand" /* SurveilLand */:
+          countManaColor(outputs.surveilLandCounts, card.manaCost);
+          break;
+        case "BounceLand" /* BounceLand */:
+          countManaColor(outputs.bounceLandCounts, card.manaCost);
+          break;
+        case "TriomeLand" /* TriomeLand */:
+          countManaColor(outputs.triomeLandCounts, card.manaCost);
+          break;
+        case "CyclingLand" /* CyclingLand */:
+          countManaColor(outputs.cyclingLandCounts, card.manaCost);
+          break;
+        case "PainLand" /* PainLand */:
+          countManaColor(outputs.painLandCounts, card.manaCost);
+          break;
+        case "FetchLand" /* FetchLand */:
+          countManaColor(outputs.fetchLandCounts, card.manaCost);
+          break;
+        case "CanopyLand" /* CanopyLand */:
+          countManaColor(outputs.canopyLandCounts, card.manaCost);
+          break;
+        case "PathwayLand" /* PathwayLand */:
+          countManaColor(outputs.pathwayLandCounts, card.manaCost);
+          break;
+        case "OtherLand" /* OtherLand */:
+        case "ForcedLand" /* ForcedLand */:
+          countManaColor(outputs.otherLandCounts, card.manaCost);
+          break;
+        default:
+          countManaColor(outputs.nonLandCounts, card.manaCost);
+          break;
+      }
+    }
+  }
+  return outputs;
+}
+function run(input) {
+  const { deck, simConfig, nonLandCards } = prepareRun(input);
+  const sim = input.epsilon !== void 0 ? simulationFromConfigAdaptive(simConfig, nonLandCards) : simulationFromConfig(simConfig);
+  return simulationToOutput(deck, sim);
+}
+async function runAsync(input) {
+  const { deck, simConfig, nonLandCards } = prepareRun(input);
+  const onProgress = input.onProgress;
+  const signal = input.signal;
+  const sim = await simulationFromConfigAsync(simConfig, {
+    batchSize: input.batchSize,
+    onProgress: onProgress ? (p) => onProgress({ ...p, phase: "simulating" }) : void 0,
+    cards: nonLandCards,
+    signal
+  });
+  signal?.throwIfAborted();
+  if (onProgress) {
+    onProgress({
+      completed: sim.hands.length,
+      total: simConfig.runCount,
+      phase: "scoring"
+    });
+  }
+  if (onProgress !== void 0 || signal !== void 0) {
+    await yieldMacrotask();
+    signal?.throwIfAborted();
+  }
+  return simulationToOutput(deck, sim);
+}
+
+// src/scryfall.ts
+var SPECIAL_LANDS = /* @__PURE__ */ new Map([
+  ["Slayers' Stronghold", manaCostFromRgbuwc(0, 0, 0, 0, 0, 1)],
+  ["Alchemist's Refuge", manaCostFromRgbuwc(0, 0, 0, 0, 0, 1)],
+  ["Desolate Lighthouse", manaCostFromRgbuwc(0, 0, 0, 0, 0, 1)],
+  ["Command Tower", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Opal Palace", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Path of Ancestry", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Arid Mesa", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Bloodstained Mire", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Flooded Strand", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Marsh Flats", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Misty Rainforest", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Polluted Delta", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Scalding Tarn", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Verdant Catacombs", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Windswept Heath", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Wooded Foothills", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Fabled Passage", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Evolving Wilds", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Axgard Armory", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Bretagard Stronghold", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Gates of Istfell", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Gnottvold Slumbermound", manaCostFromRgbuwc(1, 0, 0, 0, 0, 0)],
+  ["Great Hall of Starnheim", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  ["Immersturm Skullcairn", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  ["Littjara Mirrorlake", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Port of Karfell", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Skemfar Elderhall", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Surtland Frostpyre", manaCostFromRgbuwc(1, 0, 0, 0, 0, 0)],
+  ["Terramorphic Expanse", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Prismatic Vista", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Barkchannel Pathway // Tidechannel Pathway", manaCostFromRgbuwc(0, 1, 0, 1, 0, 0)],
+  ["Barkchannel Pathway", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Tidechannel Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Blightstep Pathway // Searstep Pathway", manaCostFromRgbuwc(1, 0, 1, 0, 0, 0)],
+  ["Blightstep Pathway", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  // Matches Rust SPECIAL_LANDS (historical quirk: U instead of R)
+  ["Searstep Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Branchloft Pathway // Boulderloft Pathway", manaCostFromRgbuwc(0, 1, 0, 0, 1, 0)],
+  ["Branchloft Pathway", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Boulderloft Pathway", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Brightclimb Pathway // Grimclimb Pathway", manaCostFromRgbuwc(0, 0, 1, 0, 1, 0)],
+  ["Brightclimb Pathway", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Grimclimb Pathway", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  ["Clearwater Pathway // Murkwater Pathway", manaCostFromRgbuwc(0, 0, 1, 1, 0, 0)],
+  ["Clearwater Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Murkwater Pathway", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  ["Cragcrown Pathway // Timbercrown Pathway", manaCostFromRgbuwc(1, 1, 0, 0, 0, 0)],
+  ["Cragcrown Pathway", manaCostFromRgbuwc(1, 0, 0, 0, 0, 0)],
+  ["Timbercrown Pathway", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Darkbore Pathway // Slitherbore Pathway", manaCostFromRgbuwc(0, 1, 1, 0, 0, 0)],
+  ["Darkbore Pathway", manaCostFromRgbuwc(0, 0, 1, 0, 0, 0)],
+  ["Slitherbore Pathway", manaCostFromRgbuwc(0, 1, 0, 0, 0, 0)],
+  ["Hengegate Pathway // Mistgate Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 1, 0)],
+  ["Hengegate Pathway", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Mistgate Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Needleverge Pathway // Pillarverge Pathway", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Needleverge Pathway", manaCostFromRgbuwc(1, 0, 0, 0, 0, 0)],
+  ["Pillarverge Pathway", manaCostFromRgbuwc(0, 0, 0, 0, 1, 0)],
+  ["Riverglide Pathway // Lavaglide Pathway", manaCostFromRgbuwc(1, 0, 0, 1, 0, 0)],
+  ["Riverglide Pathway", manaCostFromRgbuwc(0, 0, 0, 1, 0, 0)],
+  ["Lavaglide Pathway", manaCostFromRgbuwc(1, 0, 0, 0, 0, 0)],
+  ["Kor Haven", manaCostFromRgbuwc(0, 0, 0, 0, 0, 1)],
+  // Chooser / tribal lands: "Add one mana of any color. Spend this mana only to cast
+  // [a spell of a chosen/specific type]..." — modeled as rainbow, assuming the player
+  // always chooses a type/restriction that matches the goal spell (same approximation as Command Tower).
+  ["Cavern of Souls", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Secluded Courtyard", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Unclaimed Territory", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Ancient Ziggurat", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Pillar of the Paruns", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)],
+  ["Abundant Countryside", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Ally Encampment", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["A-Base Camp", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Avengers Tower", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Base Camp", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Brotherhood Headquarters", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Bucolic Ranch", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Castle Doom", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Corrupted Crossroads", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Echoing Cavern", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Eclipsed Realms", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Gallifrey Council Chamber", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Great Hall of the Biblioplex", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Haven of the Spirit Dragon", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Jasmine Dragon Tea Shop", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Maelstrom of the Spirit Dragon", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Mech Hangar", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Plaza of Heroes", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Power Depot", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Primal Beyond", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Sliver Hive", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["The Seedcore", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Turtle Lair", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Villainous Hideout", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Voldaren Estate", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["White Lotus Hideout", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Second City", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Secret Base", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Tarkir Omenpath", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  ["Underdome", manaCostFromRgbuwc(1, 1, 1, 1, 1, 1)],
+  // Lotus Field: "Add three mana of any one color." Modeled as WUBRG + manaPerTap=3,
+  // which overestimates multicolor costs (matcher can spend the 3 units as different colors).
+  ["Lotus Field", manaCostFromRgbuwc(1, 1, 1, 1, 1, 0)]
+]);
+var MULTI_MANA_LANDS = /* @__PURE__ */ new Map([
+  ["Ancient Tomb", 2],
+  ["Lotus Field", 3]
+]);
+function landKindFromOracleText(oracleText, typeLine, name = "") {
+  const text = normalizeOracleForEtb(oracleText);
+  const isShock = text.includes("you may pay 2 life") && text.includes("enters tapped");
+  const isCheck = text.includes("enters tapped unless you control a");
+  const isFast = text.includes("two or fewer other lands");
+  const isSlow = text.includes("two or more other lands");
+  const isBattle = text.includes("two or more basic lands");
+  const isTurn = text.includes("first, second, or third turn");
+  const isBounce = text.includes("enters tapped") && text.includes("return a land you control");
+  const isSurveil = text.includes("enters tapped") && text.includes("surveil");
+  const isTriome = text.includes("enters tapped") && basicLandTypeCount(typeLine) >= 3;
+  const isCycling = text.includes("enters tapped") && text.includes("cycling");
+  const isTap = text.includes("enters tapped");
+  const isFetch = text.includes("search your library") && (text.includes("sacrifice") || text.includes("sac ")) && (text.includes("basic land") || text.includes("plains") || text.includes("island") || text.includes("swamp") || text.includes("mountain") || text.includes("forest"));
+  const isCanopy = text.includes("draw a card") && (text.includes("sacrifice this land") || text.includes("sacrifice ~"));
+  const isPain = text.includes("deals 1 damage to you") && !text.includes("enters tapped") && !isCanopy;
+  const isPathway = name.toLowerCase().includes("pathway");
+  const isBasic = typeLine.includes("Basic Land");
+  if (isShock) return "ShockLand" /* ShockLand */;
+  if (isCheck) return "CheckLand" /* CheckLand */;
+  if (isFast) return "FastLand" /* FastLand */;
+  if (isSlow) return "SlowLand" /* SlowLand */;
+  if (isBattle) return "BattleLand" /* BattleLand */;
+  if (isTurn) return "TurnLand" /* TurnLand */;
+  if (isBounce) return "BounceLand" /* BounceLand */;
+  if (isSurveil) return "SurveilLand" /* SurveilLand */;
+  if (isTriome) return "TriomeLand" /* TriomeLand */;
+  if (isCycling) return "CyclingLand" /* CyclingLand */;
+  if (isTap) return "TapLand" /* TapLand */;
+  if (isFetch) return "FetchLand" /* FetchLand */;
+  if (isCanopy) return "CanopyLand" /* CanopyLand */;
+  if (isPain) return "PainLand" /* PainLand */;
+  if (isPathway) return "PathwayLand" /* PathwayLand */;
+  if (isBasic) return "BasicLand" /* BasicLand */;
+  return "OtherLand" /* OtherLand */;
+}
+function etbClauseFromOracle(oracleText) {
+  const text = normalizeOracleForEtb(oracleText);
+  const idx = text.indexOf("enters tapped");
+  if (idx === -1) return null;
+  let clause = text.slice(idx);
+  const end = clause.search(/[.\n]/);
+  if (end !== -1) clause = clause.slice(0, end + 1);
+  return clause.trim();
+}
+function colorLetter(color) {
+  switch (color) {
+    case 0 /* Red */:
+      return "R";
+    case 1 /* Green */:
+      return "G";
+    case 2 /* Black */:
+      return "B";
+    case 3 /* Blue */:
+      return "U";
+    case 4 /* White */:
+      return "W";
+    default:
+      return "";
+  }
+}
+function isColor01(colorIdentity, oracleText, color) {
+  const letter = colorLetter(color);
+  if (letter !== "" && colorIdentity.has(letter) || color === 5 /* Colorless */ && colorIdentity.size === 0 || oracleText.includes("Add one mana of any color.") && !oracleText.includes("Add one mana of any color. Spend this mana only")) {
+    return 1;
+  }
+  return 0;
+}
+function resolveImageUri(card) {
+  const normal = card.image_uris?.["normal"];
+  if (normal) return normal;
+  return card.card_faces?.[0]?.image_uris?.["normal"] ?? "";
+}
+function scryfallCardToCard(raw) {
+  const name = raw.name ?? "";
+  const oracleText = raw.oracle_text ?? "";
+  const typeLine = raw.type_line ?? "";
+  const manaCostStr = raw.mana_cost ?? "";
+  const colorIdentity = new Set(raw.color_identity ?? []);
+  const isLand2 = typeLine.includes("Land");
+  let kind;
+  let manaCost;
+  let allManaCosts;
+  let basicLandTypes = 0;
+  let checkTypes = 0;
+  let manaPerTap = 1;
+  if (isLand2) {
+    const special = SPECIAL_LANDS.get(name);
+    manaCost = special ?? manaCostFromRgbuwc(
+      isColor01(colorIdentity, oracleText, 0 /* Red */),
+      isColor01(colorIdentity, oracleText, 1 /* Green */),
+      isColor01(colorIdentity, oracleText, 2 /* Black */),
+      isColor01(colorIdentity, oracleText, 3 /* Blue */),
+      isColor01(colorIdentity, oracleText, 4 /* White */),
+      isColor01(colorIdentity, oracleText, 5 /* Colorless */)
+    );
+    kind = landKindFromOracleText(oracleText, typeLine, name);
+    allManaCosts = [manaCost];
+    basicLandTypes = basicLandTypesFromTypeLine(typeLine);
+    checkTypes = kind === "CheckLand" /* CheckLand */ ? checkTypesFromOracleText(oracleText) : 0;
+    manaPerTap = MULTI_MANA_LANDS.get(name) ?? 1;
+  } else {
+    kind = "Unknown" /* Unknown */;
+    allManaCosts = manaCostsFromStr(manaCostStr);
+    const first = allManaCosts[0] ?? emptyManaCost();
+    manaCost = manaCostFromRgbuwc(first.r, first.g, first.b, first.u, first.w, first.c);
+  }
+  const turn = Math.max(1, manaCostCmc(manaCost));
+  const set = (raw.set ?? "").toLowerCase();
+  return {
+    name,
+    oracleId: raw.oracle_id ?? "",
+    manaCostString: manaCostStr,
+    imageUri: resolveImageUri(raw),
+    kind,
+    hash: hashCardName(name),
+    turn,
+    manaCost,
+    allManaCosts,
+    arenaId: raw.arena_id ?? 0,
+    rarity: parseRarity(raw.rarity ?? ""),
+    set,
+    isFace: raw.object === "card_face",
+    basicLandTypes,
+    checkTypes,
+    manaPerTap
+  };
+}
+function isLegalInSomeFormat(card) {
+  const values = Object.values(card.legalities ?? {});
+  return !values.every((l) => l === "not_legal");
+}
+function flattenScryfallCardFaces(cards) {
+  const out = [...cards];
+  for (const card of cards) {
+    for (const face of card.card_faces ?? []) {
+      const flattened = { ...face };
+      const faceImages = face.image_uris ?? {};
+      if (Object.keys(faceImages).length === 0) {
+        flattened.image_uris = card.image_uris ? { ...card.image_uris } : {};
+      }
+      flattened.set = card.set;
+      flattened.oracle_id = card.oracle_id;
+      flattened.id = card.id;
+      flattened.rarity = card.rarity;
+      flattened.collector_number = card.collector_number;
+      flattened.object = "card_face";
+      out.push(flattened);
+    }
+  }
+  return out;
+}
+function scryfallCardsToCards(cards) {
+  const filtered = cards.filter(isLegalInSomeFormat);
+  const flattened = flattenScryfallCardFaces(filtered);
+  return flattened.map(scryfallCardToCard);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_CARDS,
+  BasicLandType,
+  COLOR_CONSTRAINED_THRESHOLD,
+  CardKind,
+  DRAW_DEPENDENT_THRESHOLD,
+  DeckcodeError,
+  PlayOrder,
+  Rarity,
+  RunValidationError,
+  SPECIAL_LANDS,
+  asLondonMulligan,
+  asNeverMulligan,
+  autoTapByTurn,
+  availableTurnForLand,
+  basicLandTypesFromTypeLine,
+  checkTypesFromOracleText,
+  createMulberry32,
+  deckFlatten,
+  deckFromCards,
+  deckFromList,
+  decklist,
+  drawCmcAutoTap,
+  etbClauseFromOracle,
+  getAllCards,
+  handFromOpeningAndDraws,
+  hashCardName,
+  isLand,
+  isLandKind,
+  landKindFromOracleText,
+  loadCardsFromGzipBytes,
+  londonNever,
+  manaCostCmc,
+  manaCostFromRgbuwc,
+  manaCostsFromStr,
+  observationsForCard,
+  pMana,
+  pManaGivenCmc,
+  pPlay,
+  parseDecklist,
+  playCmcAutoTap,
+  run,
+  runAsync,
+  scryfallCardToCard,
+  scryfallCardsToCards,
+  setAllCards,
+  simulationFromConfig,
+  simulationFromConfigAsync,
+  wilsonHalfWidth
+});