@adatechnology/game-items 0.0.0-stage → 0.1.1

package/dist/index.global.js

@@ -0,0 +1,790 @@
+"use strict";
+var GameItems = (() => {
+  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, {
+    ARSENAL_CATEGORIES: () => ARSENAL_CATEGORIES,
+    BODY_SLOTS: () => BODY_SLOTS,
+    DEFAULT_RULES: () => DEFAULT_RULES,
+    DURABILITY_KINDS: () => DURABILITY_KINDS,
+    ITEM_CATEGORIES: () => ITEM_CATEGORIES,
+    RARITIES: () => RARITIES,
+    advanceAge: () => advanceAge,
+    bagOption: () => bagOption,
+    blockChance: () => blockChance,
+    canCraft: () => canCraft,
+    canTake: () => canTake,
+    carriedKg: () => carriedKg,
+    chargeLevel: () => chargeLevel,
+    checkItems: () => checkItems,
+    craft: () => craft,
+    createFindsProvider: () => createFindsProvider,
+    createItems: () => createItems,
+    depletionFactor: () => depletionFactor,
+    failsToStart: () => failsToStart,
+    freshness: () => freshness,
+    itemsFromArsenal: () => itemsFromArsenal,
+    loadState: () => loadState,
+    maxLoadKg: () => maxLoadKg,
+    moveToStorage: () => moveToStorage,
+    pieceBlock: () => pieceBlock,
+    placeFinds: () => placeFinds,
+    repairPiece: () => repairPiece,
+    resolveUse: () => resolveUse,
+    rollByCategory: () => rollByCategory,
+    rollExplicitPool: () => rollExplicitPool,
+    scaleCount: () => scaleCount,
+    shelfRatio: () => shelfRatio,
+    spawnAgeDays: () => spawnAgeDays,
+    spawnData: () => spawnData,
+    storageMultiplier: () => storageMultiplier,
+    toLootTables: () => toLootTables,
+    wearBlocked: () => wearBlocked
+  });
+
+  // ../game-contracts/dist/index.js
+  var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+  var deepMerge = (base, patch) => {
+    if (!patch) return base;
+    const result = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0 || UNSAFE_KEYS.has(key)) continue;
+      const current = result[key];
+      result[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+    }
+    return result;
+  };
+  var mergeById = (shipped, extra) => {
+    const entries = /* @__PURE__ */ new Map();
+    for (const entry of [...shipped, ...extra ?? []]) entries.set(entry.id, entry);
+    return entries;
+  };
+  var applyPatches = (entries, patches) => {
+    for (const [id, patch] of Object.entries(patches ?? {})) {
+      const entry = entries.get(id);
+      if (entry) entries.set(id, deepMerge(entry, patch));
+    }
+  };
+  var removeIds = (entries, ids) => {
+    for (const id of ids ?? []) entries.delete(id);
+  };
+
+  // src/categories.ts
+  var ITEM_CATEGORIES = [
+    { id: "food", name: "Food" },
+    { id: "drink", name: "Drink" },
+    { id: "medical", name: "Medical" },
+    { id: "tools", name: "Tools" },
+    { id: "melee", name: "Melee" },
+    { id: "materials", name: "Materials" },
+    { id: "clothing", name: "Clothing" },
+    { id: "bags", name: "Bags" },
+    { id: "electronics", name: "Electronics" },
+    { id: "fuel", name: "Fuel" },
+    { id: "outdoors", name: "Outdoors" },
+    { id: "books", name: "Books" },
+    { id: "collectibles", name: "Collectibles" },
+    { id: "keys", name: "Keys" }
+  ];
+
+  // src/types.ts
+  var RARITIES = ["common", "uncommon", "rare", "very_rare", "legendary", "unique"];
+  var BODY_SLOTS = ["head", "eyes", "torso", "arms", "hands", "legs", "feet", "over"];
+  var DURABILITY_KINDS = ["uses", "portions", "doses", "hits", "cuts", "shots", "condition", "charges", "seconds", "days", "infinite", "container"];
+
+  // src/check-items.ts
+  var findDuplicateIds = (kind, entries) => {
+    const seen = /* @__PURE__ */ new Set();
+    const problems = [];
+    for (const { id } of entries ?? []) {
+      if (seen.has(id)) problems.push(`${kind} "${id}" is listed more than once`);
+      seen.add(id);
+    }
+    return problems;
+  };
+  var isFraction = (value) => value === void 0 || value >= 0 && value <= 1;
+  var isPositive = (value) => Number.isFinite(value) && value > 0;
+  var checkItem = (item, { categories, places }) => {
+    const problems = [];
+    const issue = (text) => problems.push(`item "${item.id}" ${text}`);
+    if (!categories.has(item.category)) issue(`has unknown category "${item.category}"`);
+    if (!RARITIES.includes(item.rarity)) issue(`has unknown rarity "${item.rarity}"`);
+    if (item.size.length !== 3 || !item.size.every(isPositive)) issue(`has an invalid size [${item.size.join(", ")}]`);
+    if (!(item.weight >= 0) || !Number.isFinite(item.weight)) issue(`has a weight of ${item.weight} kg`);
+    if (item.volume !== void 0 && !isPositive(item.volume)) issue(`has a volume of ${item.volume} L`);
+    if (item.shelfLife !== void 0 && !isPositive(item.shelfLife)) issue(`has a shelf life of ${item.shelfLife} days`);
+    if (item.portions !== void 0 && !(Number.isInteger(item.portions) && item.portions > 0)) issue(`has ${item.portions} portions`);
+    if (item.durability && !DURABILITY_KINDS.includes(item.durability.kind)) issue(`has unknown durability kind "${item.durability.kind}"`);
+    const { protection } = item;
+    if (protection) {
+      for (const slot of protection.slots) if (!BODY_SLOTS.includes(slot)) issue(`protects unknown body slot "${slot}"`);
+      if (protection.slots.length === 0) issue("has protection but covers no body slot");
+      if (![protection.bite, protection.scratch, protection.warmth].every(isFraction)) issue("has a protection value outside 0..1");
+    }
+    if (item.carry && !(item.carry.capacityKg > 0 && isFraction(item.carry.weightReduction))) issue("has an invalid carry (capacity above 0, reduction within 0..1)");
+    if (places.size > 0) {
+      for (const place of item.finds?.places ?? []) if (!places.has(place)) issue(`is found in unknown place "${place}"`);
+    }
+    return problems;
+  };
+  var checkContainer = (container, { categories }) => {
+    const problems = [];
+    for (const category of Object.keys(container.categories ?? {})) {
+      if (!categories.has(category)) problems.push(`container "${container.id}" draws from unknown category "${category}"`);
+    }
+    const [low, high] = container.count ?? [0, 0];
+    if (low < 0 || high < low) problems.push(`container "${container.id}" has an invalid count [${low}, ${high}]`);
+    return problems;
+  };
+  var checkRules = ({ rarity, freshness: freshness2, storage, carry, protection }) => {
+    const problems = [];
+    const hasNegativeWeight = RARITIES.some((id) => !(rarity.weights[id] >= 0));
+    if (hasNegativeWeight || !RARITIES.some((id) => rarity.weights[id] > 0 && !rarity.fixedOnly.includes(id))) {
+      problems.push("rules.rarity.weights must be non-negative with at least one rollable rarity above 0");
+    }
+    if (!(freshness2.stale > 0 && freshness2.stale < freshness2.spoiled && freshness2.spoiled < freshness2.rotten)) problems.push("rules.freshness must rise: 0 < stale < spoiled < rotten");
+    for (const [id, rule] of Object.entries(storage)) if (!isPositive(rule.multiplier) || rule.limitDays !== void 0 && !isPositive(rule.afterLimit ?? 0)) problems.push(`rules.storage "${id}" is invalid`);
+    if (!(isPositive(carry.baseKg) && carry.perStrengthKg >= 0 && isPositive(carry.factor) && carry.encumbered > 0 && carry.overloaded > carry.encumbered)) problems.push("rules.carry is invalid");
+    if (!(protection.cap > 0 && protection.cap <= 1 && isFraction(protection.tornShare))) problems.push("rules.protection is invalid");
+    return problems;
+  };
+  var checkItems = (parts) => [
+    ...[...parts.items.values()].flatMap((item) => checkItem(item, parts)),
+    ...[...parts.containers.values()].flatMap((container) => checkContainer(container, parts)),
+    ...checkRules(parts.rules)
+  ];
+
+  // src/rules.ts
+  var DEFAULT_RULES = {
+    rarity: {
+      weights: { common: 60, uncommon: 28, rare: 9, very_rare: 2.5, legendary: 0.5, unique: 0 },
+      fixedOnly: ["legendary", "unique"]
+    },
+    freshness: { stale: 0.5, spoiled: 1, rotten: 1.5 },
+    storage: {
+      fridge: { multiplier: 0.33, needsPower: true },
+      freezer: { multiplier: 0.1, needsPower: true },
+      cooler: { multiplier: 0.5, limitDays: 2, afterLimit: 1 },
+      delivery_bag: { multiplier: 0.8 },
+      cellar: { multiplier: 0.66 },
+      ambient: { multiplier: 1 },
+      hot: { multiplier: 2 }
+    },
+    carry: { baseKg: 8, perStrengthKg: 2.5, factor: 1.2, encumbered: 1, overloaded: 1.5 },
+    protection: { cap: 0.9, wear: { bite: 8, scratch: 3 }, tornShare: 0.25, repairMargin: 10 },
+    aging: { thawShelfDays: { freezer: 2 } },
+    inventory: { defaultSlots: 10, encumberedRunFactor: 0.75 },
+    use: {
+      freshness: {
+        stale: { satietyFactor: 0.7, poisonChance: 0.1, morale: 0, isEdible: true },
+        spoiled: { satietyFactor: 0.7, poisonChance: 0.5, morale: -20, isEdible: true },
+        rotten: { satietyFactor: 0, poisonChance: 0, morale: 0, isEdible: false }
+      },
+      cookedPoisonFactor: 0.25
+    },
+    spawn: {
+      retailNew: true,
+      retailPlaces: ["supermarket", "pharmacy", "mall", "gas_station", "gun_shop"],
+      retailContainers: ["store_shelf", "stockroom"],
+      condition: { common: [30, 90], uncommon: [40, 90], rare: [50, 100], very_rare: [50, 100], legendary: [50, 100], unique: [50, 100] },
+      ageShare: [0, 0.6],
+      charge: [0.2, 1],
+      fillable: ["fuel_jerrycan"],
+      fill: [0, 0.6]
+    },
+    finds: {
+      fallbackContainer: "zombie_corpse",
+      rollExcluded: ["ammo_7_62x39"],
+      depletion: [
+        { places: ["pharmacy", "gun_shop", "police_station"], perDay: 0.05, floor: 0.3 },
+        { places: ["supermarket", "gas_station"], perDay: 0.04, floor: 0.35 },
+        { places: ["mall", "hospital"], perDay: 0.025, floor: 0.5 },
+        { places: ["house", "apartment"], perDay: 0.01, floor: 0.7 },
+        { places: ["farm", "warehouse", "mine", "dam", "lodge", "church"], perDay: 5e-3, floor: 0.85 },
+        { places: ["military_base"], perDay: 0, floor: 1 }
+      ],
+      regionMultiplier: {},
+      states: { normal: "normal", fortified: "fortified", abandoned: "abandoned" },
+      pool: {
+        defaultFootprint: 0.5,
+        offset: 1.5,
+        perSquareMetre: 3,
+        jitter: 1.5,
+        min: 2,
+        max: 5,
+        fortifiedExtra: 2,
+        supplyWeight: 2.5,
+        supplyExtraQty: 1,
+        abandonedEmptyChance: 0.4,
+        abandonedKept: 1,
+        junkChance: 0.5,
+        junkItem: "food_packaging",
+        spoiledFoodItem: "leftover_meal",
+        coldContainers: ["geladeira", "refrig_exp", "freezer"]
+      }
+    }
+  };
+
+  // src/create-items.ts
+  var LITRES_PER_CUBIC_METRE = 1e3;
+  var withDerivedFields = (item) => item.volume === void 0 ? { ...item, volume: item.size[0] * item.size[1] * item.size[2] * LITRES_PER_CUBIC_METRE } : item;
+  var buildPools = (options, packs) => {
+    const pools = /* @__PURE__ */ new Map();
+    for (const source of [...packs, options]) for (const [key, entries] of Object.entries(source.pools ?? {})) pools.set(key, entries);
+    const problems = [];
+    for (const source of [...packs, options]) {
+      for (const [alias, key] of Object.entries(source.poolAliases ?? {})) {
+        const entries = pools.get(key);
+        if (entries) pools.set(alias, entries);
+        else problems.push(`pool alias "${alias}" points to unknown pool "${key}"`);
+      }
+    }
+    if (problems.length > 0) throw new Error(`game-items: the catalog is not consistent:
+${problems.map((problem) => `  - ${problem}`).join("\n")}`);
+    return pools;
+  };
+  var groupBy = (items, keysOf) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of items) for (const key of keysOf(item)) groups.set(key, [...groups.get(key) ?? [], item]);
+    return groups;
+  };
+  var createItems = (options = {}) => {
+    const packs = options.packs ?? [];
+    const items = mergeById([], packs.flatMap((pack) => pack.items));
+    applyPatches(items, options.patch);
+    removeIds(items, options.remove);
+    if (options.include) {
+      for (const [id, item] of items) if (!options.include(item)) items.delete(id);
+    }
+    for (const [id, item] of items) items.set(id, withDerivedFields(item));
+    const categories = mergeById(ITEM_CATEGORIES, [...packs.flatMap((pack) => pack.categories ?? []), ...options.categories ?? []]);
+    const places = mergeById([], [...packs.flatMap((pack) => pack.places ?? []), ...options.places ?? []]);
+    const containers = mergeById([], [...packs.flatMap((pack) => pack.containers ?? []), ...options.containers ?? []]);
+    const useEffects = [...mergeById([], [...packs.flatMap((pack) => pack.useEffects ?? []), ...options.useEffects ?? []]).values()];
+    const recipes = mergeById([], [...packs.flatMap((pack) => pack.recipes ?? []), ...options.recipes ?? []]);
+    const pools = buildPools(options, packs);
+    const rules = deepMerge(DEFAULT_RULES, options.rules);
+    const problems = [
+      ...packs.flatMap((pack) => findDuplicateIds(`item in pack "${pack.id}"`, pack.items)),
+      ...findDuplicateIds("category", options.categories),
+      ...findDuplicateIds("place", options.places),
+      ...findDuplicateIds("container", options.containers),
+      ...findDuplicateIds("use effect", options.useEffects),
+      ...findDuplicateIds("recipe", options.recipes),
+      ...checkItems({ items, categories, places, containers, rules })
+    ];
+    if (problems.length > 0) throw new Error(`game-items: the catalog is not consistent:
+${problems.map((problem) => `  - ${problem}`).join("\n")}`);
+    const byCategory = groupBy(items.values(), (item) => [item.category]);
+    const byPlace = groupBy(items.values(), (item) => item.finds?.places ?? []);
+    const byTag = groupBy(items.values(), (item) => item.tags ?? []);
+    return {
+      items,
+      categories,
+      places,
+      containers,
+      pools,
+      useEffects,
+      recipes,
+      rules,
+      has: (id) => items.has(id),
+      get(id) {
+        const item = items.get(id);
+        if (!item) throw new Error(`game-items: unknown item "${id}"`);
+        return item;
+      },
+      list: () => [...items.values()],
+      byCategory: (category) => [...byCategory.get(category) ?? []],
+      byPlace: (place) => [...byPlace.get(place) ?? []],
+      byTag: (tag) => [...byTag.get(tag) ?? []]
+    };
+  };
+
+  // src/decay.ts
+  var storageRuleOf = (rules, storage) => {
+    const rule = rules.storage[storage];
+    if (!rule) throw new Error(`game-items: unknown storage "${storage}"`);
+    return rule;
+  };
+  var storageMultiplier = (storage, options = {}) => {
+    const { powered = true, rules = DEFAULT_RULES, heldDays = 0 } = options;
+    const rule = storageRuleOf(rules, storage);
+    if (rule.needsPower && !powered) return 1;
+    if (rule.limitDays !== void 0 && heldDays >= rule.limitDays) return rule.afterLimit ?? 1;
+    return rule.multiplier;
+  };
+  var accruedDays = (storage, window, options) => {
+    const { powered = true, rules = DEFAULT_RULES } = options;
+    const rule = storageRuleOf(rules, storage);
+    const elapsed = window.to - window.from;
+    if (elapsed <= 0) return 0;
+    if (rule.needsPower && !powered) return elapsed;
+    if (rule.limitDays === void 0) return elapsed * rule.multiplier;
+    const limitEnd = window.storedAt + rule.limitDays;
+    const early = Math.max(0, Math.min(window.to, limitEnd) - Math.max(window.from, window.storedAt));
+    return early * rule.multiplier + (elapsed - early) * (rule.afterLimit ?? 1);
+  };
+  var advanceAge = (state, now, options = {}) => {
+    const { powered = true, rules = DEFAULT_RULES } = options;
+    const rule = storageRuleOf(rules, state.storage);
+    const thawDays = rules.aging.thawShelfDays[state.storage];
+    const isThawing = rule.needsPower === true && !powered && thawDays !== void 0 && state.shelfLife === void 0;
+    const base = isThawing ? { ...state, ageDays: 0, shelfLife: thawDays } : state;
+    const ageDays = base.ageDays + accruedDays(state.storage, { storedAt: state.storedAt, from: state.since, to: now }, options);
+    return { ...base, ageDays, since: Math.max(now, state.since) };
+  };
+  var moveToStorage = (state, now, storage, options = {}) => ({
+    ...advanceAge(state, now, options),
+    storage,
+    storedAt: now
+  });
+  var shelfRatio = (item, state) => {
+    const shelfLife = state.shelfLife ?? item.shelfLife;
+    return shelfLife === void 0 ? 0 : state.ageDays / shelfLife;
+  };
+  var freshness = (item, state, now, options = {}) => {
+    const { rules = DEFAULT_RULES } = options;
+    const ratio = shelfRatio(item, advanceAge(state, now, options));
+    if (ratio >= rules.freshness.rotten) return "rotten";
+    if (ratio >= rules.freshness.spoiled) return "spoiled";
+    if (ratio >= rules.freshness.stale) return "stale";
+    return "fresh";
+  };
+  var chargeLevel = (item, initialCharge, ageDays) => {
+    if (!item.charge) return initialCharge;
+    return Math.max(0, initialCharge - item.charge.lossPerMonth * (ageDays / 30));
+  };
+  var failsToStart = (item, ageDays, random) => {
+    if (!item.agingFault || ageDays <= item.agingFault.afterDays) return false;
+    return random() < item.agingFault.chance;
+  };
+
+  // src/protection.ts
+  var FULL_CONDITION = 100;
+  var covers = (piece, slot) => piece.item.protection?.slots.includes(slot) ?? false;
+  var pieceBlock = (piece, attack, rules = DEFAULT_RULES) => {
+    const value = piece.item.protection?.[attack] ?? 0;
+    const share = piece.condition <= 0 ? rules.protection.tornShare : piece.condition / FULL_CONDITION;
+    return value * share;
+  };
+  var blockChance = (pieces, slot, attack, rules = DEFAULT_RULES) => {
+    const unblocked = pieces.filter((piece) => covers(piece, slot)).reduce((product, piece) => product * (1 - pieceBlock(piece, attack, rules)), 1);
+    return Math.min(rules.protection.cap, 1 - unblocked);
+  };
+  var wearBlocked = (pieces, slot, attack, rules = DEFAULT_RULES) => pieces.map((piece) => {
+    if (!covers(piece, slot) || pieceBlock(piece, attack, rules) <= 0) return piece;
+    return { ...piece, condition: Math.max(0, piece.condition - rules.protection.wear[attack]) };
+  });
+  var repairPiece = (piece, rules = DEFAULT_RULES, maxCondition = FULL_CONDITION) => ({
+    ...piece,
+    condition: Math.max(piece.condition, maxCondition - rules.protection.repairMargin)
+  });
+
+  // src/carry.ts
+  var maxLoadKg = (strength, rules = DEFAULT_RULES) => (rules.carry.baseKg + rules.carry.perStrengthKg * strength) * rules.carry.factor;
+  var sumKg = (entries) => entries.reduce((total, entry) => total + entry.item.weight * entry.count, 0);
+  var carriedKg = (parts) => sumKg(parts.loose) + sumKg(parts.packed ?? []) * (1 - (parts.weightReduction ?? 0));
+  var loadState = (loadKg, maxKg, rules = DEFAULT_RULES) => {
+    const ratio = maxKg > 0 ? loadKg / maxKg : Number.POSITIVE_INFINITY;
+    if (ratio > rules.carry.overloaded) return { ratio, level: "overloaded", runFactor: 0, canRun: false };
+    if (ratio > rules.carry.encumbered) return { ratio, level: "encumbered", runFactor: rules.inventory.encumberedRunFactor, canRun: true };
+    return { ratio, level: "normal", runFactor: 1, canRun: true };
+  };
+  var bagOption = (bag, characterMaxKg, rules = DEFAULT_RULES) => ({
+    slots: bag?.carry ? Math.round(bag.carry.capacityKg) : rules.inventory.defaultSlots,
+    capacityKg: characterMaxKg
+  });
+  var canTake = (item, bag, used) => {
+    if (used.slots >= bag.slots) return "bag_full";
+    if (used.loadKg + item.weight > bag.capacityKg) return "too_heavy";
+    return "ok";
+  };
+
+  // src/use-effect.ts
+  var FRESH_NUTRITION = { satietyFactor: 1, poisonChance: 0, morale: 0, isEdible: true };
+  var nutritionOf = (item, context, rules) => {
+    const state = context.freshness ?? "fresh";
+    const effect = state === "fresh" ? FRESH_NUTRITION : rules.use.freshness[state];
+    const poisonShare = context.isCooked ? rules.use.cookedPoisonFactor : 1;
+    return {
+      satiety: (item.nutrition?.satiety ?? 0) * effect.satietyFactor,
+      hydration: item.nutrition?.hydration ?? 0,
+      morale: effect.morale,
+      poisonChance: effect.poisonChance * poisonShare,
+      isEdible: effect.isEdible
+    };
+  };
+  var findEffect = (item, effects) => effects.find((entry) => entry.items?.includes(item.id)) ?? effects.find((entry) => entry.category?.includes(item.category));
+  var resolveUse = (item, effects, context = {}, rules = DEFAULT_RULES) => {
+    const def = findEffect(item, effects);
+    if (!def) return void 0;
+    const base = { useId: def.id, effect: def.effect, params: def.params ?? {}, consumes: def.consumes };
+    if (def.effect !== "consume_nutrition") return base;
+    const nutrition = nutritionOf(item, context, rules);
+    return { ...base, consumes: def.consumes && nutrition.isEdible, nutrition };
+  };
+
+  // src/recipes.ts
+  var countOf = (context, id) => context.inventory.get(id) ?? 0;
+  var candidatesOf = (input, context) => {
+    if (input.item !== void 0) return [input.item];
+    if (input.any) return [...input.any];
+    if (!input.match) return [];
+    const { category, cookable } = input.match;
+    return context.catalog.list().filter((item) => (category === void 0 || item.category === category) && (cookable === void 0 || item.cookable === cookable)).map((item) => item.id);
+  };
+  var describeInput = (input) => {
+    if (input.item !== void 0) return `item:${input.item}`;
+    if (input.any) return `any:${input.any.join("|")}`;
+    if (input.match) return `match:${input.match.category ?? "cookable"}`;
+    if (input.fluid !== void 0) return `fluid:${input.fluid}`;
+    return `world:${(input.world ?? []).join("|")}`;
+  };
+  var takeUnits = (candidates, needed, context) => {
+    const taken = [];
+    let remaining = needed;
+    for (const id of candidates) {
+      if (remaining <= 0) break;
+      const count = Math.min(remaining, countOf(context, id));
+      if (count > 0) taken.push({ item: id, count });
+      remaining -= count;
+    }
+    return remaining > 0 ? void 0 : taken;
+  };
+  var consumptionFor = (input, context) => {
+    if (input.world) return input.world.some((thing) => context.world?.has(thing)) ? [] : void 0;
+    if (input.fluid !== void 0) {
+      const liters = input.liters ?? 1;
+      return (context.fluids?.[input.fluid] ?? 0) >= liters ? [{ fluid: input.fluid, liters }] : void 0;
+    }
+    const taken = takeUnits(candidatesOf(input, context), input.qty ?? 1, context);
+    if (!taken || input.meters === void 0) return taken;
+    return taken.map((entry) => "item" in entry ? { ...entry, meters: input.meters } : entry);
+  };
+  var toolMissing = (recipe, context) => recipe.tools.flatMap((tool) => {
+    const missing = [];
+    if (tool.anyOf.length > 0 && !tool.anyOf.some((id) => countOf(context, id) > 0)) missing.push(`tool:${tool.anyOf.join("|")}`);
+    if (tool.world && !tool.world.some((station) => context.world?.has(station))) missing.push(`world:${tool.world.join("|")}`);
+    return missing;
+  });
+  var gateMissing = (recipe, context) => {
+    const missing = [];
+    if (context.skills && recipe.skill && (context.skills[recipe.skill.id] ?? 0) < recipe.skill.level) missing.push(`skill:${recipe.skill.id}:${recipe.skill.level}`);
+    if (context.unlocked && recipe.unlockedBy !== void 0 && !context.unlocked.has(recipe.unlockedBy)) missing.push(`unlock:${recipe.unlockedBy}`);
+    return missing;
+  };
+  var canCraft = (recipe, context) => {
+    const missing = [
+      ...gateMissing(recipe, context),
+      ...toolMissing(recipe, context),
+      ...recipe.inputs.filter((input) => consumptionFor(input, context) === void 0).map(describeInput)
+    ];
+    return { isPossible: missing.length === 0, missing };
+  };
+  var outcomeOf = (output, random) => {
+    if ("effect" in output) return { effect: output.effect, params: output.params, ...output.text === void 0 ? {} : { text: output.text } };
+    const [low, high] = output.qty;
+    return { item: output.item, count: low + Math.floor(random() * (high - low + 1)) };
+  };
+  var craft = (recipe, context, random) => {
+    const check = canCraft(recipe, context);
+    if (!check.isPossible) return { isCrafted: false, missing: check.missing };
+    const consumed = recipe.inputs.flatMap((input) => consumptionFor(input, context) ?? []);
+    return { isCrafted: true, seconds: recipe.seconds, consumed, output: outcomeOf(recipe.output, random) };
+  };
+
+  // src/finds/depletion.ts
+  var depletionFactor = (place, day, rules) => {
+    if (day <= 0) return 1;
+    const rule = rules.finds.depletion.find((entry) => entry.places.includes(place));
+    return rule ? Math.max(rule.floor, 1 - rule.perDay * day) : 1;
+  };
+  var scaleCount = (count, scale, rules) => {
+    const region = scale.region === void 0 ? 1 : rules.finds.regionMultiplier[scale.region] ?? 1;
+    return Math.round(count * depletionFactor(scale.place, scale.day, rules) * region);
+  };
+
+  // src/finds/rarity-pool.ts
+  var rollableItems = (catalog, category, place) => {
+    const { rules } = catalog;
+    const rollable = catalog.byCategory(category).filter((item) => !rules.rarity.fixedOnly.includes(item.rarity) && !rules.finds.rollExcluded.includes(item.id));
+    const here = rollable.filter((item) => item.finds?.places.includes(place));
+    return here.length > 0 ? here : rollable;
+  };
+  var rarityWeight = (catalog, item) => catalog.rules.rarity.weights[item.rarity];
+
+  // src/finds/category-roll.ts
+  var pickCategory = (weights, random) => {
+    let remaining = random();
+    const categories = Object.keys(weights);
+    for (const category of categories) {
+      remaining -= weights[category];
+      if (remaining <= 0) return category;
+    }
+    return categories[0];
+  };
+  var rollByCategory = (catalog, query) => {
+    const { rules } = catalog;
+    const table = catalog.containers.get(query.container) ?? catalog.containers.get(rules.finds.fallbackContainer);
+    if (!table) return [];
+    const [low, high] = table.count ?? [0, 0];
+    const drawn = low + Math.floor(query.rng() * (high - low + 1));
+    const count = scaleCount(drawn, { place: query.place, day: query.day ?? 0, ...query.region === void 0 ? {} : { region: query.region } }, rules);
+    const weights = table.categories ?? table.categoriesByPlace?.[query.place] ?? table.categoriesByPlace?.["*"];
+    if (!weights) return [];
+    const picked = [];
+    for (let stack = 0; stack < count; stack++) {
+      const category = pickCategory(weights, query.rng);
+      const pool = category === void 0 ? [] : rollableItems(catalog, category, query.place);
+      if (pool.length === 0) continue;
+      const total = pool.reduce((sum, item) => sum + rarityWeight(catalog, item), 0);
+      let remaining = query.rng() * total;
+      for (const item of pool) {
+        remaining -= rarityWeight(catalog, item);
+        if (remaining <= 0) {
+          picked.push(item.id);
+          break;
+        }
+      }
+    }
+    return picked;
+  };
+
+  // src/finds/explicit-pool.ts
+  var weightedOrder = (candidates, random) => {
+    const remaining = [...candidates];
+    const ordered = [];
+    while (remaining.length > 0) {
+      const total = remaining.reduce((sum, candidate) => sum + candidate.weight, 0);
+      let x = random() * total;
+      let index = 0;
+      for (; index < remaining.length - 1; index++) {
+        x -= remaining[index].weight;
+        if (x < 0) break;
+      }
+      ordered.push(...remaining.splice(index, 1));
+    }
+    return ordered;
+  };
+  var countFor = (pool, state, footprint, query, rules) => {
+    const settings = rules.finds.pool;
+    const base = Math.max(settings.min, Math.min(settings.max, Math.round(settings.offset + footprint * settings.perSquareMetre + query.rng() * settings.jitter)));
+    if (state === "fortified") return Math.min(pool.length, base + settings.fortifiedExtra);
+    if (state === "abandoned") return query.rng() < settings.abandonedEmptyChance ? 0 : settings.abandonedKept;
+    return base;
+  };
+  var rollExplicitPool = (pool, state, query, rules) => {
+    const settings = rules.finds.pool;
+    const n = countFor(pool, state, query.footprint ?? settings.defaultFootprint, query, rules);
+    const isFortified = state === "fortified";
+    const candidates = pool.map((entry) => ({ entry, weight: isFortified && entry.isSupply ? entry.weight * settings.supplyWeight : entry.weight }));
+    const picks = [];
+    for (const { entry } of weightedOrder(candidates, query.rng).slice(0, n)) {
+      const [low, high] = entry.qty;
+      const bonus = isFortified && entry.isSupply ? settings.supplyExtraQty : 0;
+      picks.push({ itemId: entry.item, count: low + Math.floor(query.rng() * (high - low + 1)) + bonus, entry });
+    }
+    if (state === "abandoned") {
+      if (picks.length === 0 && query.rng() < settings.junkChance) picks.push({ itemId: settings.junkItem, count: 1 });
+      if (settings.coldContainers.includes(query.container) || query.key !== void 0 && settings.coldContainers.includes(query.key)) picks.push({ itemId: settings.spoiledFoodItem, count: 1 });
+    }
+    return picks;
+  };
+
+  // src/finds/spawn-state.ts
+  var WEARING_DURABILITY = ["condition", "hits", "cuts"];
+  var hasCondition = (item) => item.protection !== void 0 || item.weapon !== void 0 || WEARING_DURABILITY.includes(item.durability?.kind ?? "");
+  var between = (range, random) => range[0] + random() * (range[1] - range[0]);
+  var spawnAgeDays = (item, outbreakDays, random, catalog) => item.shelfLife === void 0 ? void 0 : outbreakDays + between(catalog.rules.spawn.ageShare, random) * item.shelfLife;
+  var isRetailStock = (query, catalog) => {
+    const { spawn } = catalog.rules;
+    const isRetail = spawn.retailNew && (query.day ?? 0) <= 0 && spawn.retailPlaces.includes(query.place);
+    return isRetail && (spawn.retailContainers.length === 0 || spawn.retailContainers.includes(query.container));
+  };
+  var spawnData = (item, query, catalog) => {
+    const { spawn } = catalog.rules;
+    const data = {};
+    const ageDays = spawnAgeDays(item, query.day ?? 0, query.rng, catalog);
+    if (ageDays !== void 0) data.ageDays = ageDays;
+    if (hasCondition(item)) data.condition = isRetailStock(query, catalog) ? 100 : Math.round(between(spawn.condition[item.rarity], query.rng));
+    if (item.charge) data.charge = between(spawn.charge, query.rng);
+    if (spawn.fillable.includes(item.id)) data.fill = between(spawn.fill, query.rng);
+    return Object.keys(data).length > 0 ? data : void 0;
+  };
+
+  // src/finds/provider.ts
+  function createFindsProvider(catalog, options = {}) {
+    const rules = options.rules ? deepMerge(catalog.rules, options.rules) : catalog.rules;
+    const scoped = rules === catalog.rules ? catalog : { ...catalog, rules };
+    const usesPools = (options.pools ?? "team") === "team";
+    const aliases = options.placeAliases ?? {};
+    const poolPlaces = options.poolPlaces;
+    const passes = options.unknownContainers === "pass";
+    const choose = (query) => {
+      const pool = usesPools && (poolPlaces === void 0 || poolPlaces.includes(query.place)) ? scoped.pools.get(query.key ?? query.container) ?? scoped.pools.get(query.container) : void 0;
+      if (!pool && passes && !scoped.containers.has(query.container)) return null;
+      if (!pool) return rollByCategory(scoped, query).map((itemId) => ({ itemId, count: 1 }));
+      return rollExplicitPool(pool, rules.finds.states[query.state] ?? "normal", query, rules).map(({ itemId, count }) => ({ itemId, count }));
+    };
+    return {
+      findsFor(asked) {
+        const query = aliases[asked.place] === void 0 ? asked : { ...asked, place: aliases[asked.place] };
+        const chosen = choose(query);
+        if (chosen === null) return null;
+        return chosen.filter((stack) => scoped.has(stack.itemId)).map((stack) => {
+          const data = spawnData(scoped.get(stack.itemId), query, scoped);
+          return data ? { ...stack, data } : stack;
+        });
+      }
+    };
+  }
+
+  // ../game-interactables/dist/index.js
+  function fitsSize(size, max) {
+    const eps = 1e-9;
+    if (size[1] > max[1] + eps) return false;
+    return size[0] <= max[0] + eps && size[2] <= max[2] + eps || size[2] <= max[0] + eps && size[0] <= max[2] + eps;
+  }
+
+  // src/finds/place-finds.ts
+  var placeFinds = (stacks, slots, catalog) => {
+    const contents = slots.map(() => null);
+    const leftover = [];
+    for (const stack of stacks) {
+      const item = catalog.get(stack.itemId);
+      const stackMax = item.stack ?? 1;
+      let remaining = stack.count;
+      while (remaining > 0) {
+        const index = slots.findIndex((slot, position) => contents[position] === null && fitsSize(item.size, slot.max));
+        if (index < 0) break;
+        const qty = Math.min(remaining, stackMax);
+        contents[index] = { type: item.id, qty, ...stack.data ? { data: { ...stack.data } } : {} };
+        remaining -= qty;
+      }
+      if (remaining > 0) leftover.push({ ...stack, count: remaining });
+    }
+    return { contents, leftover };
+  };
+
+  // src/finds/loot-tables.ts
+  var weightsOf = (container, place) => container.categories ?? container.categoriesByPlace?.[place] ?? container.categoriesByPlace?.["*"];
+  var tableFor = (catalog, container, query) => {
+    const weights = weightsOf(container, query.place);
+    if (!weights) return void 0;
+    const entries = Object.entries(weights).flatMap(([category, categoryWeight]) => {
+      const pool = rollableItems(catalog, category, query.place);
+      const total = pool.reduce((sum, item) => sum + rarityWeight(catalog, item), 0);
+      return total > 0 ? pool.map((item) => ({ type: item.id, weight: categoryWeight * rarityWeight(catalog, item) / total })) : [];
+    });
+    const [low, high] = container.count ?? [0, 0];
+    const region = query.region === void 0 ? 1 : catalog.rules.finds.regionMultiplier[query.region] ?? 1;
+    const expected = (low + high) / 2 * depletionFactor(query.place, query.day ?? 0, catalog.rules) * region;
+    return entries.length > 0 && high > 0 ? { fill: Math.min(1, expected / high), entries } : void 0;
+  };
+  var toLootTables = (catalog, query) => {
+    const tables = {};
+    for (const container of catalog.containers.values()) {
+      if (container.places && container.places.length > 0 && !container.places.includes(query.place)) continue;
+      const table = tableFor(catalog, container, query);
+      if (table) tables[container.id] = table;
+    }
+    return tables;
+  };
+
+  // src/arsenal-items.ts
+  var ARSENAL_CATEGORIES = [
+    { id: "ammo", name: "Ammo" },
+    { id: "firearms", name: "Firearms" },
+    { id: "throwables", name: "Throwables" }
+  ];
+  var MM = 1e-3;
+  var BOX_TARE_KG = 0.03;
+  var BOX_WALL = 6 * MM;
+  var ROUNDS_BY_CASE = { tiny: 50, pistol: 50, rifle: 20, shell: 25, big: 10 };
+  var DEFAULT_ROUNDS = 12;
+  var CARTRIDGE_MASS_FACTOR = 2.3;
+  var SHELL_MASS_FACTOR = 1.5;
+  var BOX_DENSITY_KG_PER_M3 = 600;
+  var THROWABLE_DENSITY_KG_PER_M3 = 1500;
+  var cubeSide = (mass, density) => Math.cbrt(mass / density);
+  var estimateBox = (caliber) => {
+    const rounds = ROUNDS_BY_CASE[caliber.caseType ?? ""] ?? DEFAULT_ROUNDS;
+    const factor = caliber.caseType === "shell" ? SHELL_MASS_FACTOR : CARTRIDGE_MASS_FACTOR;
+    const weight = Number((rounds * caliber.bulletGrams * (caliber.pellets ?? 1) * factor * 1e-3 + BOX_TARE_KG).toFixed(3));
+    return { rounds, weight, size: boxSize(caliber, rounds, weight) };
+  };
+  var boxSize = (caliber, rounds, weight) => {
+    if (!caliber.cartridge) {
+      const side = cubeSide(weight, BOX_DENSITY_KG_PER_M3);
+      return [side, side, side];
+    }
+    const rows = Math.ceil(Math.sqrt(rounds));
+    const columns = Math.ceil(rounds / rows);
+    const { caseDiameter, overallLength } = caliber.cartridge;
+    return [rows * caseDiameter * MM + BOX_WALL, overallLength * MM + BOX_WALL, columns * caseDiameter * MM + BOX_WALL];
+  };
+  var ammoItem = (caliber, record) => {
+    const estimate = estimateBox(caliber);
+    const weight = record?.weight ?? estimate.weight;
+    return {
+      id: record?.id ?? `ammo_${caliber.id}`,
+      category: "ammo",
+      size: record?.weight === void 0 ? estimate.size : boxSize(caliber, record.rounds ?? estimate.rounds, weight),
+      weight,
+      stack: 4,
+      shape: "box",
+      rarity: record?.rarity ?? "uncommon"
+    };
+  };
+  var firearmSize = (weapon) => {
+    const length = weapon.dimensions?.length ?? 0.15 + 0.2 * weapon.mass;
+    return [length, 0.08 + 0.12 * length, 0.02 + 0.03 * length];
+  };
+  var weaponItem = (weapon, record) => {
+    const isFirearm = weapon.action.kind === "firearm";
+    const side = cubeSide(weapon.mass, THROWABLE_DENSITY_KG_PER_M3);
+    return {
+      id: record?.id ?? `${isFirearm ? "firearm" : "throwable"}_${weapon.id}`,
+      category: isFirearm ? "firearms" : "throwables",
+      size: isFirearm ? firearmSize(weapon) : [side, side, side],
+      weight: record?.weight ?? weapon.mass,
+      stack: 1,
+      shape: isFirearm ? "long_tool" : "jar",
+      rarity: record?.rarity ?? "unique",
+      weapon: weapon.id
+    };
+  };
+  var recordFor = (records, match) => records.find(match);
+  var itemsFromArsenal = (arsenal, options = {}) => {
+    const records = options.records ?? [];
+    const items = [];
+    for (const caliber of arsenal.calibers.values()) items.push(ammoItem(caliber, recordFor(records, (record) => record.kind === "ammo_box" && record.caliber === caliber.id)));
+    for (const weapon of arsenal.weapons.values()) {
+      const kind = weapon.action.kind;
+      if (kind !== "firearm" && kind !== "throwable") continue;
+      items.push(weaponItem(weapon, recordFor(records, (record) => record.kind === kind && (record.weapon === weapon.id || record.weapon === weapon.action.explosive))));
+    }
+    return { id: "arsenal", items, categories: ARSENAL_CATEGORIES };
+  };
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map