libram 0.9.5 → 0.9.7

package/dist/Clan.js

@@ -92,7 +92,7 @@ export class Clan {
             startingClan.join();
         }
     }
-    static withStash(clanIdOrName, items, // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    static withStash(clanIdOrName, items, // eslint-disable-line @typescript-eslint/no-explicit-any
     callback) {
         return Clan._withStash(() => Clan.with(clanIdOrName, (clan) => clan.take(items)), (borrowed) => Clan.with(clanIdOrName, (clan) => clan.put(borrowed)), callback);
     }

package/dist/challengePaths/2015/CommunityService.js

@@ -1,5 +1,5 @@
-import { equippedItem, familiarWeight, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, weightAdjustment, } from "kolmafia";
-import { have } from "../../lib.js";
+import { equippedItem, getPower, haveEquipped, myAdventures, myBasestat, myBuffedstat, myFamiliar, myMaxhp, myThrall, myTurncount, numericModifier, print, runChoice, toSlot, visitUrl, } from "kolmafia";
+import { have, totalFamiliarWeight } from "../../lib.js";
 import { Requirement } from "../../maximize.js";
 import { get } from "../../property.js";
 import { MummingTrunk } from "../../resources/index.js";
@@ -18,7 +18,6 @@ const statCommunityServicePredictor = (stat) => {
                     : stat)));
 };
 const visitCouncil = () => visitUrl("council.php");
-const baseWeight = () => have($effect `Fidoxene`) ? 20 : familiarWeight(myFamiliar());
 function hypotheticalModifier(modifier, ...effects) {
     const newEffects = effects.filter((e) => !have(e));
     return (numericModifier(modifier) +
@@ -240,7 +239,8 @@ export default class CommunityService {
     static Mysticality = new CommunityService(3, "Mysticality", "Build Playground Mazes", statCommunityServicePredictor($stat `Mysticality`), new Requirement(["Mysticality"], {}));
     static Moxie = new CommunityService(4, "Moxie", "Feed Conspirators", statCommunityServicePredictor($stat `Moxie`), new Requirement(["Moxie"], {}));
     static FamiliarWeight = new CommunityService(5, "Familiar Weight", "Breed More Collies", (...effects) => 60 -
-        Math.floor((baseWeight() + hypotheticalModifier("Familiar Weight", ...effects)) /
+        Math.floor((totalFamiliarWeight(myFamiliar(), false) +
+            hypotheticalModifier("Familiar Weight", ...effects)) /
             5), new Requirement(["Familiar Weight"], {}));
     static WeaponDamage = new CommunityService(6, "Weapon Damage", "Reduce Gazelle Population", (...effects) => {
         const weaponPower = getPower(equippedItem($slot `weapon`));
@@ -266,7 +266,7 @@ export default class CommunityService {
     }, new Requirement(["Weapon Damage", "Weapon Damage Percent"], {}));
     static SpellDamage = new CommunityService(7, "Spell Damage", "Make Sausage", (...effects) => {
         const dragonfishDamage = myFamiliar() === $familiar `Magic Dragonfish`
-            ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", baseWeight() + weightAdjustment(), $item.none)
+            ? numericModifier($familiar `Magic Dragonfish`, "Spell Damage Percent", totalFamiliarWeight(), $item.none)
             : 0;
         // We add 0.001 because the floor function sometimes introduces weird rounding errors
         return (60 -
@@ -280,9 +280,9 @@ export default class CommunityService {
         const noncombatRate = -1 * hypotheticalModifier("Combat Rate", ...effects);
         const unsoftcappedRate = (rate) => rate > 25 ? 25 + (rate - 25) * 5 : rate;
         const currentFamiliarModifier = -1 *
-            numericModifier(myFamiliar(), "Combat Rate", familiarWeight(myFamiliar()) + numericModifier("Familiar Weight"), equippedItem($slot `familiar`));
+            numericModifier(myFamiliar(), "Combat Rate", totalFamiliarWeight(), equippedItem($slot `familiar`));
         const newFamiliarModifier = -1 *
-            numericModifier(myFamiliar(), "Combat Rate", familiarWeight(myFamiliar()) +
+            numericModifier(myFamiliar(), "Combat Rate", totalFamiliarWeight(myFamiliar(), false) +
                 hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
         const adjustedRate = unsoftcappedRate(noncombatRate) -
             unsoftcappedRate(currentFamiliarModifier) +
@@ -294,10 +294,10 @@ export default class CommunityService {
         const mummingBuff = mummingCostume && mummingCostume[0] === "Item Drop"
             ? mummingCostume[1]
             : 0;
-        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", baseWeight() + weightAdjustment(), equippedItem($slot `familiar`)) +
+        const familiarItemDrop = numericModifier(myFamiliar(), "Item Drop", totalFamiliarWeight(), equippedItem($slot `familiar`)) +
             mummingBuff -
             numericModifier(equippedItem($slot `familiar`), "Item Drop");
-        const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", baseWeight() + weightAdjustment(), equippedItem($slot `familiar`)) - numericModifier(equippedItem($slot `familiar`), "Booze Drop");
+        const familiarBoozeDrop = numericModifier(myFamiliar(), "Booze Drop", totalFamiliarWeight(), equippedItem($slot `familiar`)) - numericModifier(equippedItem($slot `familiar`), "Booze Drop");
         // Champagne doubling does NOT count for CS, so we undouble
         const multiplier = haveEquipped($item `broken champagne bottle`) &&
             get("garbageChampagneCharge") > 0
@@ -318,8 +318,8 @@ export default class CommunityService {
         preventEquip: $items `broken champagne bottle`,
     }));
     static HotRes = new CommunityService(10, "Hot Resistance", "Clean Steam Tunnels", (...effects) => {
-        const currentFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) + numericModifier("Familiar Weight"), equippedItem($slot `familiar`));
-        const newFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", familiarWeight(myFamiliar()) +
+        const currentFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", totalFamiliarWeight(), equippedItem($slot `familiar`));
+        const newFamiliarModifier = numericModifier(myFamiliar(), "Hot Resistance", totalFamiliarWeight(myFamiliar(), false) +
             hypotheticalModifier("Familiar Weight", ...effects), equippedItem($slot `familiar`));
         return (60 -
             (hypotheticalModifier("Hot Resistance", ...effects) -

package/dist/diet/index.d.ts

@@ -22,6 +22,8 @@ export declare class MenuItem<T> {
     priceOverride?: number;
     mayo?: Item;
     data?: T;
+    private priceCached?;
+    private itemTypeCached?;
     static defaultPriceFunction: (item: Item) => number;
     static defaultOptions<T>(): Map<Item, MenuItemOptions<T>>;
     /**
@@ -41,6 +43,7 @@ export declare class MenuItem<T> {
     equals(other: MenuItem<T>): boolean;
     toString(): string;
     price(): number;
+    itemType(): string;
 }
 declare const organs: readonly ["food", "booze", "spleen item"];
 type Organ = (typeof organs)[number];

package/dist/diet/index.js

@@ -1,5 +1,5 @@
 import { canEquip, fullnessLimit, historicalAge, historicalPrice, inebrietyLimit, itemType, mallPrice, mallPrices, myFullness, myInebriety, myLevel, myPrimestat, mySpleenUse, npcPrice, spleenLimit, } from "kolmafia";
-import { have } from "../lib.js";
+import { getRange, have } from "../lib.js";
 import { get as getModifier } from "../modifier.js";
 import { get } from "../property.js";
 import { Mayo, installed as mayoInstalled, } from "../resources/2015/MayoClinic.js";
@@ -10,27 +10,29 @@ function isMonday() {
     // Checking Tuesday's ruby is a hack to see if it's Monday in Arizona.
     return getModifier("Muscle Percent", $item `Tuesday's ruby`) > 0;
 }
+function seasoningAdventures(item) {
+    const [min, max] = getRange(item.adventures);
+    return max - min <= 1 ? 1 : 0.5;
+}
+/**
 /**
  * Expected adventures from an item given a specified state
  *
  * @todo Include Salty Mouth and potentially other modifiers.
- * @param item Item to consider
+ * @param menuItem Menu item to consider
  * @param modifiers Consumption modifiers to consider
  * @returns Adventures expected
  */
-function expectedAdventures(item, modifiers) {
+function expectedAdventures(menuItem, modifiers) {
+    const item = menuItem.item;
     if (item.adventures === "")
         return 0;
-    const [min, recordedMax] = item.adventures
-        .split(/[-]/)
-        .map((s) => parseInt(s));
-    const max = recordedMax ?? min;
+    const [min, max] = getRange(item.adventures);
     const interpolated = [...new Array(max - min + 1).keys()].map((n) => n + min);
-    const forkMugMultiplier = (itemType(item) === "food" && item.notes?.includes("SALAD")) ||
-        (itemType(item) === "booze" && item.notes?.includes("BEER"))
+    const forkMugMultiplier = (menuItem.itemType() === "food" && item.notes?.includes("SALAD")) ||
+        (menuItem.itemType() === "booze" && item.notes?.includes("BEER"))
         ? 1.5
         : 1.3;
-    const seasoningAdventures = max - min <= 1 ? 1 : 0.5;
     const aioliAdventures = item.fullness;
     const garish = modifiers.garish && item.notes?.includes("LASAGNA") && !isMonday();
     const refinedPalate = modifiers.refinedPalate && item.notes?.includes("WINE");
@@ -52,13 +54,15 @@ function expectedAdventures(item, modifiers) {
         if (item.notes?.includes("MARTINI") && modifiers.tuxedoShirt) {
             adventures += 2;
         }
-        if (itemType(item) === "food" && modifiers.mayoflex)
+        if (menuItem.itemType() === "food" && modifiers.mayoflex)
             adventures++;
-        if (itemType(item) === "food" && modifiers.seasoning)
-            adventures += seasoningAdventures;
-        if (itemType(item) === "food" && modifiers.aioli)
+        if (menuItem.itemType() === "food" && modifiers.seasoning) {
+            adventures += seasoningAdventures(item);
+        }
+        if (menuItem.itemType() === "food" && modifiers.aioli) {
             adventures += aioliAdventures;
-        if (itemType(item) === "food" && modifiers.whetStone)
+        }
+        if (menuItem.itemType() === "food" && modifiers.whetStone)
             adventures++;
         return adventures;
     }) / interpolated.length);
@@ -73,6 +77,8 @@ export class MenuItem {
     priceOverride;
     mayo;
     data;
+    priceCached;
+    itemTypeCached;
     static defaultPriceFunction = (item) => npcPrice(item) > 0 ? npcPrice(item) : mallPrice(item);
     static defaultOptions() {
         return new Map([
@@ -218,7 +224,17 @@ export class MenuItem {
         return this.item.toString();
     }
     price() {
-        return this.priceOverride ?? MenuItem.defaultPriceFunction?.(this.item);
+        if (!this.priceCached) {
+            this.priceCached =
+                this.priceOverride ?? MenuItem.defaultPriceFunction(this.item);
+        }
+        return this.priceCached;
+    }
+    itemType() {
+        if (!this.itemTypeCached) {
+            this.itemTypeCached = itemType(this.item);
+        }
+        return this.itemTypeCached;
     }
 }
 const organs = ["food", "booze", "spleen item"];
@@ -239,6 +255,18 @@ class DietPlanner {
     whetStone;
     aioli;
     spleenValue = 0;
+    baseDefaultModifiers = {
+        forkMug: false,
+        seasoning: false,
+        whetStone: false,
+        aioli: false,
+        mayoflex: false,
+        refinedPalate: have($effect `Refined Palate`),
+        garish: have($effect `Gar-ish`),
+        saucemaven: have($skill `Saucemaven`),
+        pinkyRing: have($item `mafia pinky ring`) && canEquip($item `mafia pinky ring`),
+        tuxedoShirt: have($item `tuxedo shirt`) && canEquip($item `tuxedo shirt`),
+    };
     constructor(mpa, menu) {
         this.mpa = mpa;
         const fork = menu.find((item) => item.item === $item `Ol' Scratch's salad fork`);
@@ -301,7 +329,7 @@ class DietPlanner {
      */
     consumptionHelpersAndValue(menuItem, overrideModifiers) {
         const helpers = [];
-        if (itemType(menuItem.item) === "food" && this.mayoLookup.size) {
+        if (menuItem.itemType() === "food" && this.mayoLookup.size) {
             const mayo = menuItem.mayo
                 ? this.mayoLookup.get(menuItem.mayo)
                 : this.mayoLookup.get(Mayo.flex);
@@ -309,55 +337,38 @@ class DietPlanner {
                 helpers.push(mayo);
         }
         const defaultModifiers = {
-            forkMug: false,
-            seasoning: this.seasoning ? helpers.includes(this.seasoning) : false,
-            whetStone: this.whetStone ? helpers.includes(this.whetStone) : false,
-            aioli: this.aioli ? helpers.includes(this.aioli) : false,
+            ...this.baseDefaultModifiers,
             mayoflex: this.mayoLookup.size
                 ? helpers.some((item) => item.item === Mayo.flex)
                 : false,
-            refinedPalate: have($effect `Refined Palate`),
-            garish: have($effect `Gar-ish`),
-            saucemaven: have($skill `Saucemaven`),
-            pinkyRing: have($item `mafia pinky ring`) && canEquip($item `mafia pinky ring`),
-            tuxedoShirt: have($item `tuxedo shirt`) && canEquip($item `tuxedo shirt`),
             ...overrideModifiers,
         };
         if (this.seasoning &&
-            itemType(menuItem.item) === "food" &&
-            this.mpa *
-                (expectedAdventures(menuItem.item, {
-                    ...defaultModifiers,
-                    seasoning: true,
-                }) -
-                    expectedAdventures(menuItem.item, {
-                        ...defaultModifiers,
-                        seasoning: false,
-                    })) >
-                this.seasoning.price()) {
+            menuItem.itemType() === "food" &&
+            this.mpa * seasoningAdventures(menuItem.item) > this.seasoning.price()) {
             helpers.push(this.seasoning);
         }
         if (this.whetStone &&
-            itemType(menuItem.item) === "food" &&
+            menuItem.itemType() === "food" &&
             this.mpa > this.whetStone.price()) {
             helpers.push(this.whetStone);
         }
         if (this.aioli &&
-            itemType(menuItem.item) === "food" &&
+            menuItem.itemType() === "food" &&
             this.mpa * menuItem.item.fullness > this.aioli.price()) {
             helpers.push(this.aioli);
         }
-        const forkMug = itemType(menuItem.item) === "food"
+        const forkMug = menuItem.itemType() === "food"
             ? this.fork
-            : itemType(menuItem.item) === "booze"
+            : menuItem.itemType() === "booze"
                 ? this.mug
                 : null;
         const forkMugPrice = forkMug ? forkMug.price() : Infinity;
         const baseCost = menuItem.price() + sum(helpers, (item) => item.price());
-        const valueRaw = expectedAdventures(menuItem.item, defaultModifiers) * this.mpa -
+        const valueRaw = expectedAdventures(menuItem, defaultModifiers) * this.mpa -
             baseCost +
             (menuItem.additionalValue ?? 0);
-        const valueForkMug = expectedAdventures(menuItem.item, {
+        const valueForkMug = expectedAdventures(menuItem, {
             ...defaultModifiers,
             forkMug: true,
         }) *
@@ -599,7 +610,7 @@ class DietEntry {
                 const mug = itemType(targetItem) === "booze" &&
                     items.includes($item `Frosty's frosty mug`);
                 return (this.quantity *
-                    expectedAdventures(this.menuItems[this.menuItems.length - 1].item, {
+                    expectedAdventures(this.menuItems[this.menuItems.length - 1], {
                         forkMug: fork || mug,
                         seasoning: items.includes($item `Special Seasoning`),
                         whetStone: items.includes($item `whet stone`),

package/dist/lib.d.ts

@@ -1,5 +1,5 @@
 /** @module GeneralLibrary */
-import { Effect, Element, Familiar, Item, Location, Monster, runCombat, Servant, Skill, Slot, Stat, Thrall } from "kolmafia";
+import { Effect, Element, Familiar, Item, Location, Monster, runCombat, Servant, Skill, Slot, Stat, Thrall, Coinmaster, MafiaClass } from "kolmafia";
 /**
  * Determines the current maximum Accordion Thief songs the player can have in their head
  *
@@ -220,12 +220,18 @@ export declare function canUse(item: Item): boolean;
  * @param thing Thing that can have a mafia "none" value
  * @returns The thing specified or `null`
  */
-export declare function noneToNull<T>(thing: T): T | null;
+export declare function noneToNull<T extends MafiaClass>(thing: T): T | null;
+/**
+ * Parse the sort of range that KoLmafia encodes as a string
+ * @param range KoLmafia-style range string
+ * @returns Tuple of integers representing range
+ */
+export declare function getRange(range: string): [number, number];
 /**
  * Determine the average value from the sort of range that KoLmafia encodes as a string
  *
  * @param range KoLmafia-style range string
- * @returns Average value fo range
+ * @returns Average value for range
  */
 export declare function getAverage(range: string): number;
 /**
@@ -519,4 +525,38 @@ export declare const getScalingRate: (monster: Monster) => number;
  * @returns The current scaling cap of the monster, based on your current in-game state
  */
 export declare const getScalingCap: (monster: Monster) => number;
+/**
+ * Wrap a specified action in mafia's `batchOpen` and `batchClose`
+ *
+ * @param action Action to perform while using mafia's batching feature
+ * @returns The return value of the action
+ */
+export declare function withBatch<T>(action: () => T): T;
+export declare const bulkAutosell: (items: Map<Item, number>) => boolean;
+export declare const bulkPutCloset: (items: Map<Item, number>) => boolean;
+export declare const bulkPutDisplay: (items: Map<Item, number>) => boolean;
+export declare const bulkPutStash: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeCloset: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeDisplay: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeShop: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeStash: (items: Map<Item, number>) => boolean;
+export declare const bulkTakeStorage: (items: Map<Item, number>) => boolean;
+export declare const bulkPutShop: (items: Map<Item, {
+    quantity?: number;
+    limit?: number;
+    price: number;
+}>) => boolean;
+export declare const bulkSell: (coinmaster: Coinmaster, items: Map<Item, number>) => boolean;
+export declare const bulkRepriceShop: (items: Map<Item, {
+    quantity?: number;
+    limit?: number;
+    price: number;
+}>) => boolean;
+/**
+ * Calculate the total weight of a given familiar, including soup & modifiers
+ * @param familiar The familiar to use--defaults to your current one
+ * @param considerAdjustment Whether to include your `weightAdjustment` in the calculation
+ * @returns The total weight of the given familiar
+ */
+export declare function totalFamiliarWeight(familiar?: Familiar, considerAdjustment?: boolean): number;
 export {};

package/dist/lib.js

@@ -1,9 +1,9 @@
 /** @module GeneralLibrary */
-import { appearanceRates, autosellPrice, availableAmount, booleanModifier, choiceFollowsFight, cliExecute, currentRound, Effect, elementalResistance, equip, equippedItem, extractItems as kolmafiaExtractItems, Familiar, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, handlingChoice, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, inMultiFight, Item, Location, mallPrice, Monster, myClass, myEffects, myFamiliar, myFullness, myInebriety, myPath, myPrimestat, mySpleenUse, myThrall, myTurncount, numericModifier, Path, Servant, Skill, Slot, spleenLimit, Thrall, todayToString, toItem, toSkill, totalTurnsPlayed, visitUrl, xpath, monsterEval, } from "kolmafia";
+import { appearanceRates, autosellPrice, availableAmount, booleanModifier, choiceFollowsFight, cliExecute, currentRound, Effect, elementalResistance, equip, equippedItem, extractItems as kolmafiaExtractItems, Familiar, fullnessLimit, getCampground, getCounters, getPlayerId, getPlayerName, getRelated, handlingChoice, haveEffect, haveFamiliar, haveServant, haveSkill, holiday, inebrietyLimit, inMultiFight, Item, Location, mallPrice, Monster, myClass, myEffects, myFamiliar, myFullness, myInebriety, myPath, myPrimestat, mySpleenUse, myThrall, myTurncount, numericModifier, Path, Servant, Skill, Slot, spleenLimit, Thrall, todayToString, toItem, toSkill, totalTurnsPlayed, visitUrl, xpath, monsterEval, batchOpen, batchClose, autosell, putCloset, putDisplay, putShop, putStash, sell, takeCloset, takeDisplay, takeShop, takeStash, takeStorage, repriceShop, familiarWeight, weightAdjustment, MafiaClasses, } from "kolmafia";
 import logger from "./logger.js";
 import { get } from "./property.js";
 import { $class, $effect, $element, $familiar, $item, $items, $monsters, $skill, $stat, } from "./template-string.js";
-import { makeByXFunction, chunk, notNull } from "./utils.js";
+import { makeByXFunction, chunk, notNull, clamp } from "./utils.js";
 /**
  * Determines the current maximum Accordion Thief songs the player can have in their head
  *
@@ -362,12 +362,10 @@ export function getBanishedMonsters() {
             Item.get(`tomayohawk-style reflex hammer`),
             null,
         ].includes(banisherItem)) {
-            if (Skill.get(banisher) === $skill.none) {
-                break;
-            }
-            else {
-                result.set(Skill.get(banisher), Monster.get(foe));
-            }
+            const skill = $skill.get(banisher);
+            if (!skill)
+                continue;
+            result.set(skill, Monster.get(foe));
         }
         else {
             result.set(banisherItem, Monster.get(foe));
@@ -407,32 +405,30 @@ export function canUse(item) {
  * @returns The thing specified or `null`
  */
 export function noneToNull(thing) {
-    if (thing instanceof Effect) {
-        return thing === Effect.none ? null : thing;
-    }
-    if (thing instanceof Familiar) {
-        return thing === Familiar.none ? null : thing;
-    }
-    if (thing instanceof Item) {
-        return thing === Item.none ? null : thing;
-    }
-    return thing;
+    const type = MafiaClasses.find((t) => thing instanceof t);
+    return type && thing === type.none ? null : thing;
+}
+/**
+ * Parse the sort of range that KoLmafia encodes as a string
+ * @param range KoLmafia-style range string
+ * @returns Tuple of integers representing range
+ */
+export function getRange(range) {
+    const [lower, upper] = range
+        .match(/^(-?\d+)(?:-(-?\d+))?$/)
+        ?.slice(1, 3)
+        .map((v) => parseInt(v)) ?? [0];
+    return [lower, Number.isNaN(upper) || upper === undefined ? lower : upper];
 }
 /**
  * Determine the average value from the sort of range that KoLmafia encodes as a string
  *
  * @param range KoLmafia-style range string
- * @returns Average value fo range
+ * @returns Average value for range
  */
 export function getAverage(range) {
-    if (range.indexOf("-") < 0)
-        return Number(range);
-    const [, lower, upper] = range.match(/(-?[0-9]+)-(-?[0-9]+)/) ?? [
-        "0",
-        "0",
-        "0",
-    ];
-    return (Number(lower) + Number(upper)) / 2;
+    const [min, max] = getRange(range);
+    return (min + max) / 2;
 }
 /**
  * Deternube tge average adventures expected from consuming an Item
@@ -623,6 +619,10 @@ export function findFairyMultiplier(familiar) {
     const itemBonus = numericModifier(familiar, "Item Drop", 1, $item.none);
     if (itemBonus === 0)
         return 0;
+    // Assumes you're using LED candle; returns effective weight multiplier
+    if (familiar === $familiar `Jill-of-All-Trades`)
+        return 1.5;
+    // Working out the multiplier based on the Item Drop at 1lb
     return Math.pow(Math.sqrt(itemBonus + 55 / 4 + 3) - Math.sqrt(55) / 2, 2);
 }
 export const holidayWanderers = new Map([
@@ -832,7 +832,6 @@ export function freeCrafts(type = "all") {
             : 0) +
         effectCrafts($effect `Inigo's Incantation of Inspiration`) +
         effectCrafts($effect `Craft Tea`) +
-        // eslint-disable-next-line libram/verify-constants
         effectCrafts($effect `Cooking Concentrate`);
     const food = type === "food" ? 5 - get("_cookbookbatCrafting") : 0;
     const smith = type === "smith" ? 5 - get("_thorsPliersCrafting") : 0;
@@ -996,3 +995,114 @@ export const getScalingRate = makeScalerCalcFunction(scalerRates, SCALE_RATE_PAT
  * @returns The current scaling cap of the monster, based on your current in-game state
  */
 export const getScalingCap = makeScalerCalcFunction(scalerCaps, SCALE_CAP_PATTERN);
+/**
+ * Wrap a specified action in mafia's `batchOpen` and `batchClose`
+ *
+ * @param action Action to perform while using mafia's batching feature
+ * @returns The return value of the action
+ */
+export function withBatch(action) {
+    batchOpen();
+    try {
+        return action();
+    }
+    finally {
+        batchClose();
+    }
+}
+const makeBulkFunction = (action) => (items) => {
+    batchOpen();
+    for (const [item, quantity] of items.entries())
+        action(quantity, item);
+    return batchClose();
+};
+/*
+ * Autosell items in bulk
+ */
+export const bulkAutosell = makeBulkFunction(autosell);
+/*
+ * Closet items in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkPutCloset = makeBulkFunction(putCloset);
+/*
+ * Display items in bulk
+ */
+export const bulkPutDisplay = makeBulkFunction(putDisplay);
+/*
+ * Deposit items into your clan stash in bulk
+ */
+export const bulkPutStash = makeBulkFunction(putStash);
+/*
+ * Remove items from your closet in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkTakeCloset = makeBulkFunction(takeCloset);
+/*
+ * Remove items from your display case in bulk
+ */
+export const bulkTakeDisplay = makeBulkFunction(takeDisplay);
+/*
+ * Remove items from your shop in bulk
+ */
+export const bulkTakeShop = makeBulkFunction(takeShop);
+/*
+ * Withdraw items from your clan stash in bulk
+ * Note: each item transfer will still consume one request
+ */
+export const bulkTakeStash = makeBulkFunction(takeStash);
+/*
+ * Remove items from your Hagnk's in bulk
+ */
+export const bulkTakeStorage = makeBulkFunction(takeStorage);
+/*
+ * Mallsell items in bulk
+ */
+export const bulkPutShop = (items) => {
+    batchOpen();
+    for (const [item, { quantity, limit, price }] of items.entries()) {
+        if (quantity) {
+            putShop(price, limit ?? 0, quantity, item);
+        }
+        else {
+            putShop(price, limit ?? 0, item);
+        }
+    }
+    return batchClose();
+};
+/*
+ * Coinmaster-sell items to the same coinmaster in bulk
+ */
+export const bulkSell = (coinmaster, items) => {
+    batchOpen();
+    for (const [item, quantity] of items.entries())
+        sell(coinmaster, quantity, item);
+    return batchClose();
+};
+/*
+ * Reprice items in your mallstore in bulk
+ */
+export const bulkRepriceShop = (items) => {
+    batchOpen();
+    for (const [item, { limit, price }] of items.entries()) {
+        if (limit) {
+            repriceShop(price, limit, item);
+        }
+        else {
+            repriceShop(price, item);
+        }
+    }
+    return batchClose();
+};
+/**
+ * Calculate the total weight of a given familiar, including soup & modifiers
+ * @param familiar The familiar to use--defaults to your current one
+ * @param considerAdjustment Whether to include your `weightAdjustment` in the calculation
+ * @returns The total weight of the given familiar
+ */
+export function totalFamiliarWeight(familiar = myFamiliar(), considerAdjustment = true) {
+    return (clamp(familiarWeight(myFamiliar()), have($effect `Fidoxene`) ? 20 : 0, Infinity) +
+        familiar.soupWeight +
+        (considerAdjustment ? weightAdjustment() : 0) +
+        (familiar.feasted ? 10 : 0));
+}

package/dist/lib.test.js

@@ -1,6 +1,6 @@
 import { getPlayerId, getPlayerName } from "kolmafia";
 import { describe, it, expect, vi } from "vitest";
-import { getPlayerFromIdOrName, getPlayerIdFromName, getPlayerNameFromId, } from "./lib.js";
+import { getPlayerFromIdOrName, getPlayerIdFromName, getPlayerNameFromId, getRange, } from "./lib.js";
 vi.mocked(getPlayerName).mockImplementation((id) => {
     switch (id) {
         case 1:
@@ -140,3 +140,23 @@ describe(getPlayerFromIdOrName, () => {
         });
     });
 });
+describe("getRange", () => {
+    it.each([
+        // Normal range
+        ["1-2", [1, 2]],
+        // Single number
+        ["1", [1, 1]],
+        // Negative single number
+        ["-1", [-1, -1]],
+        // Invalid
+        ["1-", [0, 0]],
+        // Negative upper bound
+        ["-5--1", [-5, -1]],
+        // Unusual order (let this slide)
+        ["10--1", [10, -1]],
+        // Ending in zero
+        ["-5-0", [-5, 0]],
+    ])("should return the range for %p", (input, expected) => {
+        expect(getRange(input)).toEqual(expected);
+    });
+});

package/dist/maximize.d.ts

@@ -2,6 +2,7 @@ import { Item, Slot } from "kolmafia";
 export type MaximizeOptions = {
     updateOnFamiliarChange: boolean;
     updateOnCanEquipChanged: boolean;
+    updateOnLocationChange: boolean;
     useOutfitCaching: boolean;
     forceEquip: Item[];
     preventEquip: Item[];

package/dist/maximize.js

@@ -1,4 +1,4 @@
-import { availableAmount, bjornifyFamiliar, canEquip, cliExecute, enthroneFamiliar, equip, equippedAmount, equippedItem, getProperty, haveEquipped, isWearingOutfit, Item, maximize, myBasestat, myBjornedFamiliar, myEnthronedFamiliar, myFamiliar, outfit, Slot, } from "kolmafia";
+import { availableAmount, bjornifyFamiliar, canEquip, cliExecute, enthroneFamiliar, equip, equippedAmount, equippedItem, getProperty, haveEquipped, isWearingOutfit, Item, maximize, myBasestat, myBjornedFamiliar, myEnthronedFamiliar, myFamiliar, myLocation, outfit, Slot, } from "kolmafia";
 import { have } from "./lib.js";
 import logger from "./logger.js";
 import { $effect, $familiar, $item, $slot, $slots, $stats, } from "./template-string.js";
@@ -18,6 +18,7 @@ export function mergeMaximizeOptions(defaultOptions, addendums) {
         updateOnFamiliarChange: addendums.updateOnFamiliarChange ?? defaultOptions.updateOnFamiliarChange,
         updateOnCanEquipChanged: addendums.updateOnCanEquipChanged ??
             defaultOptions.updateOnCanEquipChanged,
+        updateOnLocationChange: addendums.updateOnLocationChange ?? defaultOptions.updateOnLocationChange,
         useOutfitCaching: addendums.useOutfitCaching ?? defaultOptions.useOutfitCaching,
         forceEquip: [...defaultOptions.forceEquip, ...(addendums.forceEquip ?? [])],
         preventEquip: [
@@ -41,6 +42,7 @@ export function mergeMaximizeOptions(defaultOptions, addendums) {
 const defaultMaximizeOptions = {
     updateOnFamiliarChange: true,
     updateOnCanEquipChanged: true,
+    updateOnLocationChange: false,
     useOutfitCaching: true,
     forceEquip: [],
     preventEquip: [],
@@ -420,6 +422,7 @@ export function maximizeCached(objectives, options = {}) {
             .map((slot) => `${slot}:${equippedItem(slot)}`)
             .sort(),
         have($effect `Offhand Remarkable`),
+        options.updateOnLocationChange && myLocation(),
     ].join("; ");
     const cacheEntry = checkCache(cacheKey, fullOptions);
     if (cacheEntry && !forceUpdate) {
@@ -473,7 +476,7 @@ export class Requirement {
     merge(other) {
         const optionsA = this.maximizeOptions;
         const optionsB = other.maximizeOptions;
-        const optionalBooleans = mergeOptionalOptions(optionsA, optionsB, "updateOnFamiliarChange", "updateOnCanEquipChanged", "forceUpdate");
+        const optionalBooleans = mergeOptionalOptions(optionsA, optionsB, "updateOnFamiliarChange", "updateOnCanEquipChanged", "updateOnLocationChange", "forceUpdate");
         return new Requirement([...this.maximizeParameters, ...other.maximizeParameters], {
             ...optionalBooleans,
             forceEquip: [