osrs-tools 2.8.1 → 2.9.1

package/dist/runescape/model/hunter/HunterRumours.js

@@ -0,0 +1,346 @@
+import { LevelRequirement, QuestRequirement } from "../Requirement";
+import { Skill } from "../account/Skill";
+import { GuildHunterName, HuntingMethod, RumourTier, createHunterLevelRequirement } from "./HunterRumour";
+// ========== Rumour Definitions ==========
+// Each rumour represents a hunter creature that can be assigned.
+// Reference: https://oldschool.runescape.wiki/w/Hunters%27_Rumours#List_of_rumours
+const hunterLevel = (level) => createHunterLevelRequirement(level);
+const tropicalWagtail = {
+    creature: "Tropical wagtail",
+    hunterRequirement: hunterLevel(19),
+    method: HuntingMethod.BirdSnare,
+    locations: ["Feldip Hunter area", "The Great Conch", "Tlati Rainforest"],
+    requirements: [],
+};
+const wildKebbit = {
+    creature: "Wild kebbit",
+    hunterRequirement: hunterLevel(23),
+    method: HuntingMethod.Deadfall,
+    locations: ["Piscatoris Hunter area", "Auburnvale"],
+    requirements: [],
+};
+const sapphireGlacialis = {
+    creature: "Sapphire glacialis",
+    hunterRequirement: hunterLevel(25),
+    method: HuntingMethod.ButterflyNet,
+    locations: ["Rellekka Hunter area", "Farming Guild", "Mons Gratia"],
+    requirements: [],
+};
+const swampLizard = {
+    creature: "Swamp lizard",
+    hunterRequirement: hunterLevel(29),
+    method: HuntingMethod.NetTrap,
+    locations: ["Canifis Hunter area", "North-west of Slepe"],
+    requirements: [new QuestRequirement("Priest in Peril")],
+};
+const spinedLarupia = {
+    creature: "Spined larupia",
+    hunterRequirement: hunterLevel(31),
+    method: HuntingMethod.SpikedPit,
+    locations: ["Feldip Hunter area"],
+    requirements: [],
+};
+const barbTailedKebbit = {
+    creature: "Barb-tailed kebbit",
+    hunterRequirement: hunterLevel(33),
+    method: HuntingMethod.Deadfall,
+    locations: ["Feldip Hunter area"],
+    requirements: [],
+};
+const snowyKnight = {
+    creature: "Snowy knight",
+    hunterRequirement: hunterLevel(35),
+    method: HuntingMethod.ButterflyNet,
+    locations: ["Rellekka Hunter area", "Weiss", "Farming Guild", "Mons Gratia"],
+    requirements: [],
+};
+const pricklyKebbit = {
+    creature: "Prickly kebbit",
+    hunterRequirement: hunterLevel(37),
+    method: HuntingMethod.Deadfall,
+    locations: ["Piscatoris Hunter area"],
+    requirements: [],
+};
+const embertailedJerboa = {
+    creature: "Embertailed jerboa",
+    hunterRequirement: hunterLevel(39),
+    method: HuntingMethod.BoxTrap,
+    locations: ["West of Hunter Guild", "North-west of the Locus Oasis"],
+    requirements: [new QuestRequirement("Eagles' Peak")],
+};
+const hornedGraahk = {
+    creature: "Horned graahk",
+    hunterRequirement: hunterLevel(41),
+    method: HuntingMethod.SpikedPit,
+    locations: ["Karamja Hunter area"],
+    requirements: [],
+};
+const spottedKebbit = {
+    creature: "Spotted kebbit",
+    hunterRequirement: hunterLevel(43),
+    method: HuntingMethod.Falconry,
+    locations: ["Piscatoris falconry area"],
+    requirements: [],
+};
+const blackWarlock = {
+    creature: "Black warlock",
+    hunterRequirement: hunterLevel(45),
+    method: HuntingMethod.ButterflyNet,
+    locations: ["Feldip Hunter area", "Farming Guild", "Crypt of Tonali hunter area", "Tlati Rainforest", "Shimmering Atoll"],
+    requirements: [],
+};
+const orangeSalamander = {
+    creature: "Orange salamander",
+    hunterRequirement: hunterLevel(47),
+    method: HuntingMethod.NetTrap,
+    locations: ["The Great Conch", "Uzer Hunter area", "Necropolis Hunter area"],
+    requirements: [],
+};
+const razorBackedKebbit = {
+    creature: "Razor-backed kebbit",
+    hunterRequirement: hunterLevel(49),
+    method: HuntingMethod.TrackingKebbit,
+    locations: ["Piscatoris Hunter area"],
+    requirements: [],
+};
+const sabreToothKebbit = {
+    creature: "Sabre-toothed kebbit",
+    hunterRequirement: hunterLevel(51),
+    method: HuntingMethod.Deadfall,
+    locations: ["Rellekka Hunter area"],
+    requirements: [],
+};
+const greyChinchompa = {
+    creature: "Grey chinchompa",
+    hunterRequirement: hunterLevel(53),
+    method: HuntingMethod.BoxTrap,
+    locations: ["Piscatoris Hunter area", "Kourend Woodland", "Isle of Souls"],
+    requirements: [new QuestRequirement("Eagles' Peak")],
+};
+const sabreToothKyatt = {
+    creature: "Sabre-toothed kyatt",
+    hunterRequirement: hunterLevel(55),
+    method: HuntingMethod.SpikedPit,
+    locations: ["Rellekka Hunter area"],
+    requirements: [],
+};
+const darkKebbit = {
+    creature: "Dark kebbit",
+    hunterRequirement: hunterLevel(57),
+    method: HuntingMethod.Falconry,
+    locations: ["Piscatoris falconry area"],
+    requirements: [],
+};
+const pyreFox = {
+    creature: "Pyre fox",
+    hunterRequirement: hunterLevel(57),
+    method: HuntingMethod.Deadfall,
+    locations: ["Avium Savannah"],
+    requirements: [],
+};
+const redSalamander = {
+    creature: "Red salamander",
+    hunterRequirement: hunterLevel(59),
+    method: HuntingMethod.NetTrap,
+    locations: ["Ourania Hunter area", "Charred Island"],
+    requirements: [],
+};
+const redChinchompa = {
+    creature: "Red chinchompa",
+    hunterRequirement: hunterLevel(63),
+    method: HuntingMethod.BoxTrap,
+    locations: ["Chinchompa Island", "Feldip Hunter area", "The Great Conch", "Gwenith Hunter area", "Red chinchompa hunting ground", "Tlati Rainforest"],
+    requirements: [new QuestRequirement("Eagles' Peak")],
+};
+const dashingKebbit = {
+    creature: "Dashing kebbit",
+    hunterRequirement: hunterLevel(69),
+    method: HuntingMethod.Falconry,
+    locations: ["Piscatoris falconry area"],
+    requirements: [],
+};
+const sunlightAntelope = {
+    creature: "Sunlight antelope",
+    hunterRequirement: hunterLevel(72),
+    method: HuntingMethod.SpikedPit,
+    locations: ["Avium Savannah"],
+    requirements: [],
+};
+const sunlightMoth = {
+    creature: "Sunlight moth",
+    hunterRequirement: hunterLevel(75),
+    method: HuntingMethod.ButterflyNet,
+    locations: ["Avium Savannah", "Neypotzli"],
+    requirements: [],
+};
+const tecuSalamander = {
+    creature: "Tecu salamander",
+    hunterRequirement: hunterLevel(79),
+    method: HuntingMethod.NetTrap,
+    locations: ["Ralos' Rise"],
+    requirements: [],
+};
+const herbiboar = {
+    creature: "Herbiboar",
+    hunterRequirement: hunterLevel(80),
+    method: HuntingMethod.TrackingHerbiboar,
+    locations: ["Mushroom Forest on Fossil Island"],
+    requirements: [new QuestRequirement("Bone Voyage"), new LevelRequirement(Skill.Herblore, 31, false)],
+};
+const moonlightMoth = {
+    creature: "Moonlight moth",
+    hunterRequirement: hunterLevel(85),
+    method: HuntingMethod.ButterflyNet,
+    locations: ["The Burrow", "Neypotzli", "Ruins of Tapoyauik", "Tonali Cavern"],
+    requirements: [],
+};
+const moonlightAntelope = {
+    creature: "Moonlight antelope",
+    hunterRequirement: hunterLevel(91),
+    method: HuntingMethod.SpikedPit,
+    locations: ["The Burrow"],
+    requirements: [],
+};
+// ========== All Rumours ==========
+/** All hunter rumours sorted by Hunter level */
+export const ALL_RUMOURS = [
+    tropicalWagtail,
+    wildKebbit,
+    sapphireGlacialis,
+    swampLizard,
+    spinedLarupia,
+    barbTailedKebbit,
+    snowyKnight,
+    pricklyKebbit,
+    embertailedJerboa,
+    hornedGraahk,
+    spottedKebbit,
+    blackWarlock,
+    orangeSalamander,
+    razorBackedKebbit,
+    sabreToothKebbit,
+    greyChinchompa,
+    sabreToothKyatt,
+    darkKebbit,
+    pyreFox,
+    redSalamander,
+    redChinchompa,
+    dashingKebbit,
+    sunlightAntelope,
+    sunlightMoth,
+    tecuSalamander,
+    herbiboar,
+    moonlightMoth,
+    moonlightAntelope,
+];
+// ========== Guild Hunter Definitions ==========
+/**
+ * Huntmaster Gilman (Novice) - Can assign all rumours.
+ */
+export const Gilman = {
+    name: GuildHunterName.Gilman,
+    tier: RumourTier.Novice,
+    levelRequired: hunterLevel(46),
+    rumours: [...ALL_RUMOURS],
+};
+/**
+ * Guild Hunter Cervus (Adept) - Has a distinct adept rumour list.
+ */
+export const Cervus = {
+    name: GuildHunterName.Cervus,
+    tier: RumourTier.Adept,
+    levelRequired: hunterLevel(57),
+    rumours: [swampLizard, hornedGraahk, spottedKebbit, blackWarlock, orangeSalamander, razorBackedKebbit, sabreToothKebbit, greyChinchompa, darkKebbit, pyreFox, redChinchompa, sunlightMoth],
+};
+/**
+ * Guild Hunter Ornus (Adept) - Has a distinct adept rumour list.
+ */
+export const Ornus = {
+    name: GuildHunterName.Ornus,
+    tier: RumourTier.Adept,
+    levelRequired: hunterLevel(57),
+    rumours: [spinedLarupia, snowyKnight, embertailedJerboa, spottedKebbit, orangeSalamander, sabreToothKebbit, sabreToothKyatt, pyreFox, redSalamander, redChinchompa],
+};
+/**
+ * Guild Hunter Aco (Expert) - Has a distinct expert rumour list.
+ */
+export const Aco = {
+    name: GuildHunterName.Aco,
+    tier: RumourTier.Expert,
+    levelRequired: hunterLevel(72),
+    rumours: [orangeSalamander, sabreToothKebbit, greyChinchompa, sabreToothKyatt, darkKebbit, redSalamander, redChinchompa, dashingKebbit, sunlightAntelope, tecuSalamander, moonlightMoth],
+};
+/**
+ * Guild Hunter Teco (Expert) - Has a distinct expert rumour list.
+ */
+export const Teco = {
+    name: GuildHunterName.Teco,
+    tier: RumourTier.Expert,
+    levelRequired: hunterLevel(72),
+    rumours: [sabreToothKebbit, greyChinchompa, sabreToothKyatt, darkKebbit, redSalamander, redChinchompa, dashingKebbit, sunlightAntelope, sunlightMoth, herbiboar],
+};
+/**
+ * Guild Hunter Wolf (Master) - Requires completion of At First Light.
+ */
+export const Wolf = {
+    name: GuildHunterName.Wolf,
+    tier: RumourTier.Master,
+    levelRequired: hunterLevel(91),
+    questRequired: "At First Light",
+    rumours: [redSalamander, redChinchompa, dashingKebbit, sunlightAntelope, tecuSalamander, herbiboar, moonlightMoth, moonlightAntelope],
+};
+/** All guild hunters */
+export const ALL_GUILD_HUNTERS = [Gilman, Cervus, Ornus, Aco, Teco, Wolf];
+// ========== Utility Functions ==========
+/**
+ * Get a guild hunter by name.
+ * @param name - The guild hunter's name (enum or string)
+ * @returns The guild hunter, or undefined if not found
+ */
+export function getGuildHunterByName(name) {
+    return ALL_GUILD_HUNTERS.find((h) => h.name === name);
+}
+/**
+ * Get all guild hunters for a specific tier.
+ * @param tier - The rumour tier
+ * @returns Array of guild hunters for that tier
+ */
+export function getGuildHuntersByTier(tier) {
+    return ALL_GUILD_HUNTERS.filter((h) => h.tier === tier);
+}
+/**
+ * Get the available rumours for a guild hunter, excluding any creatures
+ * already assigned as active rumours from other hunters.
+ *
+ * This implements the "blocking" mechanic: players cannot receive the same
+ * task from multiple guild hunters at once. By obtaining a task from one
+ * hunter first, it is blocked from appearing with another.
+ *
+ * Example: If Gilman assigns "Swamp lizard", Cervus cannot assign "Swamp lizard"
+ * until the Gilman assignment is completed or reset.
+ *
+ * @param hunter - The guild hunter to get available rumours for
+ * @param activeRumours - Rumours currently assigned from other guild hunters
+ * @returns Rumours the hunter can assign, excluding blocked ones
+ */
+export function getAvailableRumours(hunter, activeRumours = []) {
+    const blockedCreatures = new Set(activeRumours.map((r) => r.creature));
+    return hunter.rumours.filter((r) => !blockedCreatures.has(r.creature));
+}
+/**
+ * Find a rumour by creature name.
+ * @param creature - The creature name to search for (case-insensitive)
+ * @returns The matching rumour, or undefined if not found
+ */
+export function getRumourByCreature(creature) {
+    const lower = creature.toLowerCase();
+    return ALL_RUMOURS.find((r) => r.creature.toLowerCase() === lower);
+}
+/**
+ * Get all guild hunters that can assign a specific rumour.
+ * @param rumour - The rumour to check
+ * @returns Array of guild hunters who include this rumour in their list
+ */
+export function getHuntersForRumour(rumour) {
+    return ALL_GUILD_HUNTERS.filter((h) => h.rumours.some((r) => r.creature === rumour.creature));
+}

package/dist/runescape/model/hunter/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hunter Rumours Module
+ * Complete Hunters' Rumours system including guild hunters, rumour data, and utilities.
+ * Reference: https://oldschool.runescape.wiki/w/Hunters%27_Rumours
+ */
+export { HuntingMethod, RumourTier, HunterLootSackType, GuildHunterName, DROP_RATES, TIER_XP_MODIFIER, HUNTER_LOOT_SACK_INFO, RUMOUR_MILESTONE_UNLOCKS, calculateRumourExperience, createHunterLevelRequirement, getMilestoneUnlocks, openHuntersLootSack, } from './HunterRumour';
+export type { DropRateInfo, HunterRumour, GuildHunter, HunterLootSackInfo, RumourMilestoneUnlock, OpenLootSackResult, } from './HunterRumour';
+export { ALL_RUMOURS, ALL_GUILD_HUNTERS, Gilman, Cervus, Ornus, Aco, Teco, Wolf, getGuildHunterByName, getGuildHuntersByTier, getAvailableRumours, getRumourByCreature, getHuntersForRumour, } from './HunterRumours';
+//# sourceMappingURL=index.d.ts.map

package/dist/runescape/model/hunter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/hunter/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,EACxB,yBAAyB,EACzB,4BAA4B,EAC5B,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,KAAK,EACL,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,iBAAiB,CAAC"}

package/dist/runescape/model/hunter/index.js

@@ -0,0 +1,9 @@
+/**
+ * Hunter Rumours Module
+ * Complete Hunters' Rumours system including guild hunters, rumour data, and utilities.
+ * Reference: https://oldschool.runescape.wiki/w/Hunters%27_Rumours
+ */
+// Model definitions
+export { HuntingMethod, RumourTier, HunterLootSackType, GuildHunterName, DROP_RATES, TIER_XP_MODIFIER, HUNTER_LOOT_SACK_INFO, RUMOUR_MILESTONE_UNLOCKS, calculateRumourExperience, createHunterLevelRequirement, getMilestoneUnlocks, openHuntersLootSack, } from './HunterRumour';
+// Data and utilities
+export { ALL_RUMOURS, ALL_GUILD_HUNTERS, Gilman, Cervus, Ornus, Aco, Teco, Wolf, getGuildHunterByName, getGuildHuntersByTier, getAvailableRumours, getRumourByCreature, getHuntersForRumour, } from './HunterRumours';

package/dist/runescape/model/leagues/DemonicPact.d.ts

@@ -0,0 +1,23 @@
+import { DemonicPact, DemonicPactScoringContext, DemonicPactTree, CombatStyle, UnlockEvaluation, DemonicPactOptimizerOptions, DemonicPactOptimizationResult } from "./DemonicPact.model";
+export type DemonicPactScorer = (pact: DemonicPact, context: DemonicPactScoringContext) => number;
+export declare function getInitialUnlockedPactIds(tree: DemonicPactTree): string[];
+export declare function getPactsByStyle(tree: DemonicPactTree, style: CombatStyle, includeUniversal?: boolean): DemonicPact[];
+export declare function getPactById(tree: DemonicPactTree, pactId: string): DemonicPact | undefined;
+/**
+ *  Calculates the total points spent on a given selection of pacts based on their official point costs.
+ * @param tree  The demonic pact tree containing all pacts.
+ * @param unlockedPactIds  The IDs of the pacts that have been unlocked.
+ * @returns The total points spent on the unlocked pacts.
+ */
+export declare function calculateSpentPoints(tree: DemonicPactTree, unlockedPactIds: readonly string[]): number;
+/**
+ *  Determines if a pact can be unlocked given the current tree state and already unlocked pacts.
+ * @param tree
+ * @param unlockedPactIds
+ * @param pactId
+ * @returns
+ */
+export declare function canUnlockPact(tree: DemonicPactTree, unlockedPactIds: readonly string[], pactId: string): UnlockEvaluation;
+export declare function getUnlockablePacts(tree: DemonicPactTree, unlockedPactIds: readonly string[], style?: CombatStyle): DemonicPact[];
+export declare function optimizeDemonicPactLoadout(tree: DemonicPactTree, options: DemonicPactOptimizerOptions): DemonicPactOptimizationResult;
+//# sourceMappingURL=DemonicPact.d.ts.map

package/dist/runescape/model/leagues/DemonicPact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DemonicPact.d.ts","sourceRoot":"","sources":["../../../../source/runescape/model/leagues/DemonicPact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,yBAAyB,EAAE,eAAe,EAAE,WAAW,EAAE,gBAAgB,EAAE,2BAA2B,EAAE,6BAA6B,EAAgB,MAAM,qBAAqB,CAAC;AAEvM,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,yBAAyB,KAAK,MAAM,CAAC;AAUlG,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,EAAE,CAEzE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,WAAW,EAAE,gBAAgB,UAAO,GAAG,WAAW,EAAE,CAMjH;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAE1F;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,eAAe,EAAE,eAAe,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAGtG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE,eAAe,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CA8CzH;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,EAAE,eAAe,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,CAGhI;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,2BAA2B,GAAG,6BAA6B,CAoFrI"}

package/dist/runescape/model/leagues/DemonicPact.js

@@ -0,0 +1,210 @@
+import { CombatStyle, PactNodeSize } from "./DemonicPact.model";
+const DEFAULT_BEAM_WIDTH = 48;
+export function getInitialUnlockedPactIds(tree) {
+    return [tree.rootNodeId];
+}
+export function getPactsByStyle(tree, style, includeUniversal = true) {
+    if (style === CombatStyle.Universal) {
+        return tree.pacts.filter((pact) => pact.style === CombatStyle.Universal);
+    }
+    return tree.pacts.filter((pact) => pact.style === style || (includeUniversal && pact.style === CombatStyle.Universal));
+}
+export function getPactById(tree, pactId) {
+    return tree.pacts.find((pact) => pact.id === pactId);
+}
+/**
+ *  Calculates the total points spent on a given selection of pacts based on their official point costs.
+ * @param tree  The demonic pact tree containing all pacts.
+ * @param unlockedPactIds  The IDs of the pacts that have been unlocked.
+ * @returns The total points spent on the unlocked pacts.
+ */
+export function calculateSpentPoints(tree, unlockedPactIds) {
+    const unlockedSet = new Set(unlockedPactIds);
+    return tree.pacts.filter((pact) => unlockedSet.has(pact.id)).reduce((total, pact) => total + pact.pointCost, 0);
+}
+/**
+ *  Determines if a pact can be unlocked given the current tree state and already unlocked pacts.
+ * @param tree
+ * @param unlockedPactIds
+ * @param pactId
+ * @returns
+ */
+export function canUnlockPact(tree, unlockedPactIds, pactId) {
+    const unlockedSet = new Set(unlockedPactIds);
+    const pact = getPactById(tree, pactId);
+    const spent = calculateSpentPoints(tree, unlockedPactIds);
+    const pointsRemaining = tree.totalPointsAvailable - spent;
+    if (!pact) {
+        return { unlockable: false, reason: `Unknown pact id: ${pactId}`, pointsRemaining };
+    }
+    if (unlockedSet.has(pact.id)) {
+        return { unlockable: false, reason: `Pact already unlocked: ${pact.id}`, pointsRemaining };
+    }
+    if (pact.pointCost > pointsRemaining) {
+        return {
+            unlockable: false,
+            reason: `Not enough points to unlock ${pact.id}`,
+            pointsRemaining,
+        };
+    }
+    if (unlockedSet.size === 0) {
+        if (pact.id === tree.rootNodeId) {
+            return { unlockable: true, pointsRemaining: pointsRemaining - pact.pointCost };
+        }
+        return {
+            unlockable: false,
+            reason: `The root pact ${tree.rootNodeId} must be unlocked first`,
+            pointsRemaining,
+            missingLinkedPactIds: [tree.rootNodeId],
+        };
+    }
+    const linkedUnlockedIds = pact.linkedNodeIds.filter((linkedNodeId) => unlockedSet.has(linkedNodeId));
+    if (linkedUnlockedIds.length === 0) {
+        return {
+            unlockable: false,
+            reason: `Pact must connect to an already unlocked pact`,
+            pointsRemaining,
+            missingLinkedPactIds: pact.linkedNodeIds,
+        };
+    }
+    return { unlockable: true, pointsRemaining: pointsRemaining - pact.pointCost };
+}
+export function getUnlockablePacts(tree, unlockedPactIds, style) {
+    const candidates = style ? getPactsByStyle(tree, style) : tree.pacts;
+    return candidates.filter((pact) => canUnlockPact(tree, unlockedPactIds, pact.id).unlockable);
+}
+export function optimizeDemonicPactLoadout(tree, options) {
+    const pointBudget = options.pointBudget ?? tree.totalPointsAvailable;
+    const preferredStyles = options.preferredStyles.length > 0 ? options.preferredStyles : [CombatStyle.Universal];
+    const excludedPactIds = new Set(options.excludedPactIds ?? []);
+    const requiredPactIds = new Set(options.requiredPactIds ?? []);
+    const beamWidth = options.beamWidth ?? DEFAULT_BEAM_WIDTH;
+    const startingPactIds = getStartingPactIds(tree, options);
+    validateStartingPacts(tree, startingPactIds, pointBudget);
+    let states = [
+        {
+            selectedPactIds: [...startingPactIds],
+            unlockOrder: [...startingPactIds],
+            score: calculateSelectionScore(tree, startingPactIds, preferredStyles, options.scorer),
+        },
+    ];
+    while (true) {
+        const nextStates = new Map();
+        let expandedAnyState = false;
+        for (const state of states) {
+            const unlockablePacts = getUnlockablePacts(tree, state.selectedPactIds).filter((pact) => !excludedPactIds.has(pact.id));
+            let expandedState = false;
+            for (const pact of unlockablePacts) {
+                const nextSelectedPactIds = [...state.selectedPactIds, pact.id];
+                const spentPoints = calculateSpentPoints(tree, nextSelectedPactIds);
+                if (spentPoints > pointBudget) {
+                    continue;
+                }
+                expandedAnyState = true;
+                expandedState = true;
+                const nextState = {
+                    selectedPactIds: nextSelectedPactIds,
+                    unlockOrder: [...state.unlockOrder, pact.id],
+                    score: state.score + scorePact(tree, pact, state.selectedPactIds, preferredStyles, options.scorer),
+                };
+                const stateKey = nextSelectedPactIds.join("|");
+                const existingState = nextStates.get(stateKey);
+                if (!existingState || compareStates(nextState, existingState) < 0) {
+                    nextStates.set(stateKey, nextState);
+                }
+            }
+            if (!expandedState) {
+                const stateKey = state.selectedPactIds.join("|");
+                const existingState = nextStates.get(stateKey);
+                if (!existingState || compareStates(state, existingState) < 0) {
+                    nextStates.set(stateKey, state);
+                }
+            }
+        }
+        if (!expandedAnyState) {
+            break;
+        }
+        states = [...nextStates.values()].sort(compareStates).slice(0, beamWidth);
+    }
+    const bestState = [...states].filter((state) => hasRequiredPacts(state.selectedPactIds, requiredPactIds)).sort(compareStates)[0];
+    if (!bestState) {
+        throw new Error("Unable to satisfy the required pact selection within the provided point budget");
+    }
+    const spentPoints = calculateSpentPoints(tree, bestState.selectedPactIds);
+    return {
+        selectedPactIds: [...bestState.selectedPactIds],
+        unlockOrder: [...bestState.unlockOrder],
+        selectedPacts: bestState.selectedPactIds.map((pactId) => getPactById(tree, pactId)).filter((pact) => Boolean(pact)),
+        spentPoints,
+        remainingPoints: pointBudget - spentPoints,
+        score: bestState.score,
+        unlockableNextPacts: getUnlockablePacts(tree, bestState.selectedPactIds).filter((pact) => !excludedPactIds.has(pact.id)),
+    };
+}
+function getStartingPactIds(tree, options) {
+    const providedPactIds = options.startingPactIds ? [...new Set(options.startingPactIds)] : [];
+    if (providedPactIds.length > 0) {
+        return providedPactIds;
+    }
+    if (options.includeRoot === false) {
+        return [];
+    }
+    return getInitialUnlockedPactIds(tree);
+}
+function validateStartingPacts(tree, startingPactIds, pointBudget) {
+    const validatedPactIds = [];
+    for (const pactId of startingPactIds) {
+        const evaluation = canUnlockPact(tree, validatedPactIds, pactId);
+        if (!evaluation.unlockable) {
+            throw new Error(evaluation.reason ?? `Invalid starting pact: ${pactId}`);
+        }
+        validatedPactIds.push(pactId);
+    }
+    const spentPoints = calculateSpentPoints(tree, validatedPactIds);
+    if (spentPoints > pointBudget) {
+        throw new Error(`Starting pact selection spends ${spentPoints} points, exceeding the ${pointBudget} point budget`);
+    }
+}
+function calculateSelectionScore(tree, selectedPactIds, preferredStyles, scorer) {
+    let score = 0;
+    const runningSelection = [];
+    for (const pactId of selectedPactIds) {
+        const pact = getPactById(tree, pactId);
+        if (!pact) {
+            continue;
+        }
+        score += scorePact(tree, pact, runningSelection, preferredStyles, scorer);
+        runningSelection.push(pactId);
+    }
+    return score;
+}
+function scorePact(tree, pact, selectedPactIds, preferredStyles, scorer) {
+    const scoringContext = {
+        tree,
+        selectedPactIds,
+        preferredStyles,
+    };
+    return scorer ? scorer(pact, scoringContext) : scorePactByStyleAndSize(pact, preferredStyles);
+}
+function scorePactByStyleAndSize(pact, preferredStyles) {
+    const styleWeight = preferredStyles.includes(pact.style) ? 7 : pact.style === CombatStyle.Universal ? 4 : 1;
+    const sizeWeight = pact.nodeSize === PactNodeSize.Capstone ? 4 : pact.nodeSize === PactNodeSize.Major ? 2 : 1;
+    return styleWeight + sizeWeight + pact.linkedNodeIds.length * 0.05;
+}
+function hasRequiredPacts(selectedPactIds, requiredPactIds) {
+    for (const pactId of requiredPactIds) {
+        if (!selectedPactIds.includes(pactId)) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareStates(left, right) {
+    if (left.score !== right.score) {
+        return right.score - left.score;
+    }
+    if (left.selectedPactIds.length !== right.selectedPactIds.length) {
+        return right.selectedPactIds.length - left.selectedPactIds.length;
+    }
+    return left.selectedPactIds.join("|").localeCompare(right.selectedPactIds.join("|"));
+}