azeroth-shell 0.0.0-stage → 0.1.1

package/src/domain/pet/petActionBar.ts

@@ -0,0 +1,180 @@
+// The vanilla pet action bar as data: 10 slots, the client's own icons, Ctrl-N binds. No DOM, so
+// both bars build from this list. Layout is the server's: Unit.cpp:9508-9521 InitPetActionBar.
+
+import type { Character, PetState } from '../character/character.ts';
+import type { CreatureDef, SpellDef } from '../../data/schema.ts';
+import type { DataStore } from '../../data/dataStore.ts';
+import { getSpellRecoveryTime } from '../../engine/spells/recovery.ts';
+import { petKnownSpells, petAutocastOn } from './pet.ts';
+
+export type PetCommand = 'attack' | 'follow' | 'stay';
+export type PetReact = 'aggressive' | 'defensive' | 'passive';
+
+/** PetActionBarFrame.lua:6-12 — PET_*_TEXTURE, lowercased to our icon basenames. */
+export const PET_COMMAND_ICON: Record<PetCommand, string> = {
+  attack: 'ability_ghoulfrenzy',
+  follow: 'ability_tracking',
+  stay: 'spell_nature_timestop',
+};
+export const PET_REACT_ICON: Record<PetReact, string> = {
+  aggressive: 'ability_racial_bloodrage',
+  defensive: 'ability_defend',
+  passive: 'ability_seal',
+};
+
+/** GlobalStrings PET_MODE_* / the client's own button names. */
+export const PET_COMMAND_NAME: Record<PetCommand, string> = {
+  attack: 'Attack',
+  follow: 'Follow',
+  stay: 'Stay',
+};
+export const PET_REACT_NAME: Record<PetReact, string> = {
+  aggressive: 'Aggressive',
+  defensive: 'Defensive',
+  passive: 'Passive',
+};
+
+export const PET_COMMAND_TIP: Record<PetCommand, string> = {
+  attack: 'Send your pet at your current target.',
+  follow: 'Your pet follows you and stops attacking.',
+  stay: 'Your pet holds this spot until you move it.',
+};
+export const PET_REACT_TIP: Record<PetReact, string> = {
+  aggressive: 'Attacks anything hostile that comes into range.',
+  defensive: 'Attacks what attacks you or your pet.',
+  passive: 'Never attacks until you send it in.',
+};
+
+/** Slot 1..10 → its default bind. BONUSACTIONBUTTON10 is Ctrl-0. */
+export function petSlotHotkey(slot: number): string {
+  return `ctrl+${slot === 10 ? 0 : slot}`;
+}
+
+/** 'ctrl+1' → 'Ctrl-1', the label the client prints on the button. */
+export function petSlotKeyLabel(slot: number): string {
+  return `Ctrl-${slot === 10 ? 0 : slot}`;
+}
+
+// Ms left on a pet ability from the SAVED world clock — what the bar shows between pulls, since
+// Dash and Sacrifice outlive the fight that spent them. Same max(own, category) as the player's.
+export function petWorldCooldownMs(pet: PetState, spell: SpellDef, now: number): number {
+  const own = Math.max(0, (pet.spellCooldowns?.[spell.id] ?? 0) - now);
+  const cat = spell.category != null
+    ? Math.max(0, (pet.categoryCooldowns?.[spell.category] ?? 0) - now)
+    : 0;
+  return Math.max(own, cat);
+}
+
+/** Where a bar reads the pet's live state and cooldowns from. Every field optional. */
+export type PetBarLive = {
+  command?: PetCommand;
+  react?: PetReact;
+  /** ms left per ability id, from the LIVE session's pet. Wins over `now`. */
+  cooldownRemainingMs?: (spellId: number) => number;
+  /** Epoch ms, to read the saved world clock instead. Neither given = no cooldown drawn. */
+  now?: number;
+};
+
+export type PetBarSlot =
+  | {
+    slot: number; hotkey: string; keyLabel: string;
+    kind: 'command'; command: PetCommand;
+    icon: string; name: string; tip: string; active: boolean;
+  }
+  | {
+    slot: number; hotkey: string; keyLabel: string;
+    kind: 'react'; react: PetReact;
+    icon: string; name: string; tip: string; active: boolean;
+  }
+  | {
+    slot: number; hotkey: string | null; keyLabel: string | null;
+    kind: 'spell'; spellId: number;
+    icon: string; name: string; tip: string; autocast: boolean;
+    /** ms until the pet can cast it (0 = ready) - the swipe and countdown the bar draws. */
+    cooldownRemainingMs: number;
+    /** Full recovery (RecoveryTime), so the swipe knows how much of the arc to cover. */
+    cooldownMs: number;
+  };
+
+/** ACTION_BAR_INDEX_PET_SPELL_END - _START = 4 keyed spell slots (Unit.h:866-869). */
+export const PET_SPELL_SLOTS = 4;
+
+const slotOf = (index: number): { slot: number; hotkey: string; keyLabel: string } => {
+  const slot = index + 1;
+  return { slot, hotkey: petSlotHotkey(slot), keyLabel: petSlotKeyLabel(slot) };
+};
+
+// The bar for a pet, in slot order, with the LIVE command and react states. Every known ability is
+// listed: the first four take the keyed slots and the rest ride after slot 10 without a bind.
+export function petBarSlots(
+  char: Character,
+  cdef: CreatureDef,
+  ds: DataStore,
+  live?: PetBarLive,
+): PetBarSlot[] {
+  const pet = char.pet;
+  if (!pet) return [];
+  const command = live?.command ?? pet.command ?? 'follow';
+  const react = live?.react ?? pet.react ?? 'defensive';
+  const out: PetBarSlot[] = [];
+  const commands: PetCommand[] = ['attack', 'follow', 'stay'];
+  commands.forEach((c, i) => {
+    out.push({
+      ...slotOf(i),
+      kind: 'command',
+      command: c,
+      icon: PET_COMMAND_ICON[c],
+      name: PET_COMMAND_NAME[c],
+      tip: PET_COMMAND_TIP[c],
+      // Attack is a momentary order, never a lit state — the client only checks the
+      // standing commands. Cite: PetAI.cpp:376-377 staying/following.
+      active: c !== 'attack' && command === c,
+    });
+  });
+  const spells = petKnownSpells(char, cdef, ds);
+  spells.forEach((s, i) => {
+    const keyed = i < PET_SPELL_SLOTS;
+    out.push({
+      // Overflow abilities keep a clickable slot id past the bar's last button (10) so they
+      // stay toggleable; only the first four get a bind.
+      slot: keyed ? i + 4 : 11 + (i - PET_SPELL_SLOTS),
+      hotkey: keyed ? petSlotHotkey(i + 4) : null,
+      keyLabel: keyed ? petSlotKeyLabel(i + 4) : null,
+      kind: 'spell',
+      spellId: s.id,
+      icon: s.icon ?? '',
+      name: s.name,
+      tip: petAutocastOn(pet, s, ds)
+        ? `${s.name} - autocast on (click to turn off)`
+        : `${s.name} - autocast off (click to turn on)`,
+      autocast: petAutocastOn(pet, s, ds),
+      cooldownRemainingMs: live?.cooldownRemainingMs
+        ? Math.max(0, live.cooldownRemainingMs(s.id))
+        : (live?.now != null ? petWorldCooldownMs(pet, s, live.now) : 0),
+      cooldownMs: getSpellRecoveryTime(s) || 0,
+    });
+  });
+  const reacts: PetReact[] = ['aggressive', 'defensive', 'passive'];
+  reacts.forEach((r, i) => {
+    out.push({
+      ...slotOf(7 + i),
+      kind: 'react',
+      react: r,
+      icon: PET_REACT_ICON[r],
+      name: PET_REACT_NAME[r],
+      tip: PET_REACT_TIP[r],
+      active: react === r,
+    });
+  });
+  return out;
+}
+
+/** The slot a Ctrl-N press means, or null. Accepts 'ctrl+1'..'ctrl+9', 'ctrl+0'. */
+export function petSlotForHotkey(hotkey: string): number | null {
+  const m = /^ctrl\+([0-9])$/.exec(hotkey);
+  if (!m) return null;
+  const n = Number(m[1]);
+  return n === 0 ? 10 : n;
+}
+
+

package/src/domain/pet/petSpellbook.ts

@@ -0,0 +1,39 @@
+// Pure selector: active pet's known abilities → display rows for the Spellbook Pet tab.
+// No DOM. Maps petKnownSpells (SpellDef[]) into UI-ready fields without re-deriving names/icons.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { Character } from '../character/character.ts';
+import { getSpellRecoveryTime } from '../../engine/spells/recovery.ts';
+import { petKnownSpells } from './pet.ts';
+
+/** One spellbook Pet-tab row, shaped from a resolved SpellDef. */
+export interface PetSpellbookEntry {
+  id: number;
+  name: string;
+  icon?: string;
+  rank: number;
+  cost: number;
+  /** SpellDef.cooldownMs (ms). */
+  cooldown: number;
+  passive: boolean;
+}
+
+// Display rows for the active living pet's known abilities. Empty when there is no pet, the pet is dead, or
+// its creature def is missing.
+export function petSpellbookEntries(char: Character, ds: DataStore): PetSpellbookEntry[] {
+  const pet = char.pet;
+  if (!pet || pet.health <= 0) return [];
+  const cdef = ds.creature(pet.creature);
+  if (!cdef) return [];
+  return petKnownSpells(char, cdef, ds).map((s) => ({
+    id: s.id,
+    name: s.name,
+    icon: s.icon,
+    rank: s.rank,
+    // Flat ManaCost: pet kit is not baked with costPct (ManaCostPercentage).
+    // resolveSpellCost(s, 0, 0) would hide a pct cost; do not pass empty create pools.
+    cost: s.cost,
+    cooldown: getSpellRecoveryTime(s),
+    passive: !!s.passive,
+  }));
+}

package/src/domain/pet/petStable.ts

@@ -0,0 +1,81 @@
+// Hunter pet stable: purchased slots and swap in or out. Pure — gold is deducted by the caller.
+// Cite: Pet.h MAX_PET_STABLES; NPCHandler.cpp HandleBuyStableSlot / HandleStablePet.
+
+import type { Character, PetState } from '../character/character.ts';
+
+/** Cite: Pet.h `#define MAX_PET_STABLES 2`. */
+export const MAX_PET_STABLES = 2;
+
+// Copper price for the next slot, indexed by how many are already owned: DBC rows 1 → 500 and
+// 2 → 50000. Cite: StableSlotPrices.dbc; NPCHandler.cpp HandleBuyStableSlot.
+export const STABLE_SLOT_PRICES: readonly number[] = [500, 50_000];
+
+/** Cite: Pet.h PetSaveMode. FIRST_STABLE_SLOT=1 .. LAST_STABLE_SLOT=MAX_PET_STABLES. */
+export const PET_SAVE_FIRST_STABLE_SLOT = 1;
+export const PET_SAVE_LAST_STABLE_SLOT = MAX_PET_STABLES;
+
+/** How many slots this character has bought (0..2). Absent save field → 0. */
+export function purchasedStableSlots(char: Pick<Character, 'stableSlots'>): number {
+  const n = char.stableSlots ?? 0;
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.min(MAX_PET_STABLES, n | 0);
+}
+
+/** Copper to buy the next slot, or null when both are owned. */
+export function nextStableSlotCost(stableSlots: number): number | null {
+  const owned = Math.max(0, stableSlots | 0);
+  if (owned >= MAX_PET_STABLES) return null;
+  return STABLE_SLOT_PRICES[owned] ?? null;
+}
+
+/** Pet in 1-based stable slot, or null if the slot is empty / unpurchased. */
+export function stableOccupant(
+  char: Pick<Character, 'stableSlots' | 'stablePets'>,
+  slot: number,
+): PetState | null {
+  if (slot < PET_SAVE_FIRST_STABLE_SLOT || slot > purchasedStableSlots(char)) return null;
+  const p = char.stablePets?.[slot - 1];
+  return p && typeof p === 'object' ? p : null;
+}
+
+// First empty purchased slot in query order (1, 2, …), or null. Cite: NPCHandler.cpp HandleStablePet
+// free_slot scan ~677–699.
+export function findFreeStableSlot(char: Pick<Character, 'stableSlots' | 'stablePets'>): number | null {
+  const owned = purchasedStableSlots(char);
+  for (let slot = PET_SAVE_FIRST_STABLE_SLOT; slot <= owned; slot++) {
+    if (!stableOccupant(char, slot)) return slot;
+  }
+  return null;
+}
+
+export interface BuyStableSlotResult {
+  ok: boolean;
+  reason?: string;
+  stableSlots: number;
+  cost: number;
+}
+
+/** Purchase the next slot. Gold is deducted by the caller. */
+export function buyStableSlot(stableSlots: number, gold: number): BuyStableSlotResult {
+  const owned = Math.max(0, stableSlots | 0);
+  const cost = nextStableSlotCost(owned);
+  if (cost == null) return { ok: false, reason: 'All stable slots are bought', stableSlots: owned, cost: 0 };
+  if (gold < cost) return { ok: false, reason: "You don't have enough money", stableSlots: owned, cost };
+  return { ok: true, stableSlots: owned + 1, cost };
+}
+
+/** Write `pet` (or empty) into a 1-based purchased slot. Length stays MAX_PET_STABLES. */
+export function setStableOccupant(
+  pets: Character['stablePets'],
+  slot: number,
+  pet: PetState | null,
+): (PetState | null)[] {
+  const next: (PetState | null)[] = [
+    pets?.[0] ?? null,
+    pets?.[1] ?? null,
+  ];
+  next[slot - 1] = pet;
+  return next;
+}
+
+export const STABLE_ICON = 'inv_box_petcarrier_01';

package/src/domain/professions/autoDisenchant.ts

@@ -0,0 +1,236 @@
+// Auto-disenchant: break down bagged gear that is not an upgrade for you, or for companions when
+// that option is on, if the party has Enchanting. Reuses findUpgrades — no parallel scoring.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { Character } from '../character/character.ts';
+import type { Inventory } from '../items/inventory.ts';
+import type { Companion } from '../bots/squad.ts';
+import {
+  companionCharacter,
+  companionLevel,
+  companionSpellbook,
+} from '../bots/squad.ts';
+import { findUpgrades } from '../items/equipmentHelper.ts';
+import {
+  disenchantRuleFor,
+  isDisenchantable,
+} from './enchanting.ts';
+import { pickDisenchanter } from './partyDisenchant.ts';
+import { DUAL_WIELD_SPELL_ID, type EquipOpts } from '../items/equipment.ts';
+import { companionPlayerbotSpecId, characterPlayerbotSpecId } from '../bots/playerbotStatWeight.ts';
+import { knows, type SpellBook } from '../character/spellbook.ts';
+import type { SkillLine } from '../../data/schema.ts';
+
+/** Max quality to auto-DE: 2 green, 3 rare/superior, 4 epic (ceiling inclusive). */
+export type AutoDisenchantMaxQuality = 2 | 3 | 4;
+
+export interface AutoDisenchantConfig {
+  enabled: boolean;
+  /** Quality ceiling (inclusive). Default green when enabled. */
+  maxQuality: AutoDisenchantMaxQuality;
+  // When true (default), auto-DE / junk skip gear that is an upgrade for squad, roster, or raid companions.
+  // Player upgrades are always kept.
+  protectCompanionUpgrades: boolean;
+}
+
+export const DEFAULT_AUTO_DISENCHANT_CONFIG: AutoDisenchantConfig = {
+  enabled: false,
+  maxQuality: 2,
+  protectCompanionUpgrades: true,
+};
+
+/** Coerce stored value; missing/partial → defaults (off, green ceiling, keep squad upgrades). */
+export function normalizeAutoDisenchantConfig(raw: unknown): AutoDisenchantConfig {
+  const r = (raw && typeof raw === 'object' ? raw : {}) as Partial<AutoDisenchantConfig>;
+  const mq = r.maxQuality;
+  const maxQuality: AutoDisenchantMaxQuality =
+    mq === 2 || mq === 3 || mq === 4 ? mq : DEFAULT_AUTO_DISENCHANT_CONFIG.maxQuality;
+  return {
+    enabled: typeof r.enabled === 'boolean' ? r.enabled : DEFAULT_AUTO_DISENCHANT_CONFIG.enabled,
+    maxQuality,
+    protectCompanionUpgrades: typeof r.protectCompanionUpgrades === 'boolean'
+      ? r.protectCompanionUpgrades
+      : DEFAULT_AUTO_DISENCHANT_CONFIG.protectCompanionUpgrades,
+  };
+}
+
+/** OR both layers: on if either is on; ceiling is the max of enabled layers. */
+export function mergeAutoDisenchantConfigs(
+  global: AutoDisenchantConfig | unknown,
+  character: AutoDisenchantConfig | unknown,
+): AutoDisenchantConfig {
+  const g = normalizeAutoDisenchantConfig(global);
+  const c = normalizeAutoDisenchantConfig(character);
+  // Either layer can keep squad upgrades (same as existing always-on guard).
+  const protectCompanionUpgrades = g.protectCompanionUpgrades || c.protectCompanionUpgrades;
+  if (!g.enabled && !c.enabled) {
+    return {
+      enabled: false,
+      maxQuality: Math.max(g.maxQuality, c.maxQuality) as AutoDisenchantMaxQuality,
+      protectCompanionUpgrades,
+    };
+  }
+  const maxQuality = Math.max(
+    g.enabled ? g.maxQuality : 0,
+    c.enabled ? c.maxQuality : 0,
+  ) as AutoDisenchantMaxQuality;
+  return { enabled: true, maxQuality: maxQuality < 2 ? 2 : maxQuality, protectCompanionUpgrades };
+}
+
+export type AutoDisenchantEnchanter =
+  | { kind: 'player' }
+  | { kind: 'companion'; id: string; name: string };
+
+export type PartyEnchanter =
+  | { kind: 'player'; char: Character }
+  | { kind: 'companion'; comp: Companion; char: Character };
+
+// Active group/raid enchanters: you and squad + raid seats. Bag verbs use resolveRosterEnchanters
+// (adds the bench). Player first so skill-ups prefer your line.
+export function resolvePartyEnchanters(
+  player: Character,
+  squad: readonly Companion[] | undefined,
+  raidMembers: Readonly<Record<string, Companion>> | undefined,
+  ds: DataStore,
+): PartyEnchanter[] {
+  const out: PartyEnchanter[] = [{ kind: 'player', char: player }];
+  const seen = new Set<string>();
+  const push = (comp: Companion): void => {
+    if (seen.has(comp.id) || comp.mission) return;
+    seen.add(comp.id);
+    const lvl = companionLevel(comp, player.level);
+    out.push({ kind: 'companion', comp, char: companionCharacter(comp, lvl, ds) });
+  };
+  for (const c of squad ?? []) push(c);
+  for (const c of Object.values(raidMembers ?? {})) push(c);
+  return out;
+}
+
+/** All companions whose gear we must not destroy as "not an upgrade" (squad + roster + raid). */
+export function companionsForUpgradeGuard(
+  squad: readonly Companion[] | undefined,
+  botRoster: Readonly<Record<string, Companion>> | undefined,
+  raidMembers: Readonly<Record<string, Companion>> | undefined,
+): Companion[] {
+  const map = new Map<string, Companion>();
+  for (const c of squad ?? []) map.set(c.id, c);
+  for (const c of Object.values(botRoster ?? {})) map.set(c.id, c);
+  for (const c of Object.values(raidMembers ?? {})) map.set(c.id, c);
+  return [...map.values()];
+}
+
+/** Same as companionsForUpgradeGuard when cfg.protectCompanionUpgrades, else none (player still guarded). */
+export function companionsForOptionalUpgradeGuard(
+  cfg: AutoDisenchantConfig | unknown,
+  squad: readonly Companion[] | undefined,
+  botRoster: Readonly<Record<string, Companion>> | undefined,
+  raidMembers: Readonly<Record<string, Companion>> | undefined,
+): Companion[] {
+  if (!normalizeAutoDisenchantConfig(cfg).protectCompanionUpgrades) return [];
+  return companionsForUpgradeGuard(squad, botRoster, raidMembers);
+}
+
+/** Dual wield + weightscale for a bot, so every caller scores that body the same way. */
+export function companionEquipOpts(comp: Companion, lvl: number, ds: DataStore): EquipOpts {
+  const sb = companionSpellbook(comp, lvl, ds);
+  return {
+    canDualWield: knows(sb, DUAL_WIELD_SPELL_ID),
+    specId: companionPlayerbotSpecId(comp.cls, comp.specIdx, comp.role, ds),
+    role: comp.role,
+  };
+}
+
+// Every bag entry that is a strict upgrade for the player or any owned companion, as ONE
+// findUpgrades pass per body — disposition used to call this per item.
+export function partyUpgradeEntries(
+  player: Character,
+  playerInv: Inventory,
+  playerEquipOpts: EquipOpts,
+  companions: readonly Companion[],
+  ds: DataStore,
+): Set<number> {
+  const out = new Set<number>();
+  for (const u of findUpgrades(player, playerInv, ds, playerEquipOpts)) out.add(u.entry);
+  for (const comp of companions) {
+    const lvl = companionLevel(comp, player.level);
+    const char = companionCharacter(comp, lvl, ds);
+    const opts = companionEquipOpts(comp, lvl, ds);
+    for (const u of findUpgrades(char, playerInv, ds, opts)) out.add(u.entry);
+  }
+  return out;
+}
+
+// True when `entry` in `playerInv` is a strict upgrade for the player or any owned companion. Same
+// findUpgrades path as the equipment helper / companion gear UI.
+export function isUpgradeForParty(
+  entry: number,
+  player: Character,
+  playerInv: Inventory,
+  playerEquipOpts: EquipOpts,
+  companions: readonly Companion[],
+  ds: DataStore,
+): boolean {
+  return partyUpgradeEntries(player, playerInv, playerEquipOpts, companions, ds).has(entry);
+}
+
+// Whether bagged `entry` is a valid auto-DE target under cfg (quality, DE rules, not upgrade,
+// quest-protected, party enchanter skill). Does not check bag space for mats.
+export function canAutoDisenchantEntry(
+  entry: number,
+  cfg: AutoDisenchantConfig,
+  player: Character,
+  playerInv: Inventory,
+  playerEquipOpts: EquipOpts,
+  companions: readonly Companion[],
+  enchanters: readonly PartyEnchanter[],
+  ds: DataStore,
+  questProtected: ReadonlySet<number>,
+  upgradeEntries?: ReadonlySet<number>,
+): { ok: true; enchanter: AutoDisenchantEnchanter } | { ok: false; reason: string } {
+  if (!cfg.enabled) return { ok: false, reason: 'Auto-disenchant off' };
+  if (questProtected.has(entry)) return { ok: false, reason: 'Needed for a quest' };
+  const item = ds.item(entry);
+  if (!item) return { ok: false, reason: 'Unknown item' };
+  const q = item.quality ?? 0;
+  if (q < 2) return { ok: false, reason: 'Quality too low' };
+  if (q > cfg.maxQuality) return { ok: false, reason: 'Above quality ceiling' };
+  if (!isDisenchantable(item)) return { ok: false, reason: 'Not disenchantable gear' };
+  if (!disenchantRuleFor(item, ds)) return { ok: false, reason: 'No disenchant yield band' };
+  const upgrade = upgradeEntries
+    ? upgradeEntries.has(entry)
+    : isUpgradeForParty(entry, player, playerInv, playerEquipOpts, companions, ds);
+  if (upgrade) {
+    return {
+      ok: false,
+      reason: companions.length > 0 ? 'Upgrade for you or a companion' : 'Upgrade for you',
+    };
+  }
+  // One picker for the automatic pass and the bag-bar button, so the two can never disagree
+  // about who breaks a given item down.
+  const who = pickDisenchanter(entry, playerInv, ds, enchanters);
+  if (!who) return { ok: false, reason: 'No party enchanter with enough skill' };
+  return who.kind === 'player'
+    ? { ok: true, enchanter: { kind: 'player' } }
+    : { ok: true, enchanter: { kind: 'companion', id: who.id!, name: who.name } };
+}
+
+/** Dual-wield helper for callers building EquipOpts for the player. */
+export function playerCanDualWield(spellbook: SpellBook): boolean {
+  return knows(spellbook, DUAL_WIELD_SPELL_ID);
+}
+
+export function playerEquipOptsFrom(
+  char: Character,
+  spellbook: SpellBook,
+  ds: DataStore,
+  opts?: { role?: string; specName?: string | null },
+): EquipOpts {
+  return {
+    canDualWield: playerCanDualWield(spellbook),
+    specId: characterPlayerbotSpecId(char, ds, opts),
+    role: opts?.role as never,
+  };
+}
+
+/** Skill line key for companion profession writeback. */
+export const ENCHANTING_LINE: SkillLine = 'enchanting';