@elite-dangerous-almanac/core 0.2.7 → 0.2.9

package/dist/ships/pre-engineered-stats.d.ts

@@ -99,7 +99,7 @@ declare function getPreEngineeredJournalModifiers(variant: PreEngineeredVariant)
  * The module symbol and blueprint therefore identify the purchase at grade 1 and after
  * upgrading it through grades 2–5. The fitted grade and experimental effect remain the
  * loadout's current engineering state; the returned variant carries the original purchase
- * grade, Merc Coin price and — on the ten rows sold with one — the effect the shop bakes
+ * grade, Merc Coin price and, on the rows sold with one, the effect the shop bakes
  * in. So a capture that states a different effect, or none, still identifies the article
  * it was bought as: read the capture for what is fitted now, the variant for what was
  * bought.

package/dist/ships/pre-engineered-stats.js

@@ -1 +1 @@
-export{getPreEngineeredJournalModifiers,getPreEngineeredModifiers,getPreEngineeredStats,identifyPreEngineeredVariant,unresolvedModifiers}from"../chunk-4U7KYQGK.js";                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             //# sourceMappingURL=pre-engineered-stats.js.map
+export{getPreEngineeredJournalModifiers,getPreEngineeredModifiers,getPreEngineeredStats,identifyPreEngineeredVariant,unresolvedModifiers}from"../chunk-C3YZ5KTA.js";                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             //# sourceMappingURL=pre-engineered-stats.js.map

package/dist/ships/pre-engineered.d.ts

@@ -18,16 +18,16 @@
  * grade already applied. Most blueprint ids join to `BLUEPRINTS`; the festive
  * `Decorative_*` ids instead identify fixed grade-5 reward articles with no craftable
  * recipe or material cost.
- * The 22 Mercenary entries are bought at grade 1 and their bespoke recipes start at
+ * Mercenary entries are bought at grade 1 and their bespoke recipes start at
  * grade 2 — price the remaining upgrade with `getBlueprintCost(blueprint, target,
  * grade)` from `ships/blueprint-costs`, which answers with the materials and the Merc
  * Coin the climb costs.
  * Community-goal and tech-broker entries instead identify fixed reward articles; their
  * blueprint ids do not grant a recipe to the stock module.
  *
- * Note that one base module can appear more than once: the medium Seeker Missile Rack is
- * sold or awarded in six different pre-engineered flavours, so
- * `Hpt_BasicMissileRack_Fixed_Medium` has six entries. Look variants up with
+ * One base module can appear more than once: the medium Seeker Missile Rack is sold or
+ * awarded in several pre-engineered flavours, so `Hpt_BasicMissileRack_Fixed_Medium` has
+ * one entry per flavour. Look variants up with
  * {@link getPreEngineeredVariants} (plural) rather than assuming one.
  *
  * Most variants carry a `modifiers` block — the hand-set stat
@@ -35,19 +35,19 @@
  * computed. Resolve them against the base module with `getPreEngineeredStats` from
  * `./pre-engineered-stats.js`; it lives in its own module so that consumers who only
  * want the catalogue do not bundle the module and engineering tables.
- * Final articles carry {@link PreEngineeredVariant.engineeringLocked}. These are the seven
+ * Final articles carry {@link PreEngineeredVariant.engineeringLocked}. These are the
  * pre-engineered Guardian weapons, whose stock counterparts can take Anti-Guardian Zone
- * Resistance, and five fixed Enzyme/AX rewards whose stock modules have no engineering menu.
+ * Resistance, and the fixed Enzyme/AX rewards whose stock modules have no engineering menu.
  *
  * @packageDocumentation
  */
 /**
  * Where a pre-engineered variant is obtained.
  *
- * - `mercenary` — bought from the Merc-Coin shop; always arrives at grade 1, ten of them
+ * - `mercenary` — bought from the Merc-Coin shop; always arrives at grade 1, some of them
  *   with an experimental effect already applied beside that grade-1 blueprint.
- * - `communityGoal` — awarded for taking part in a community goal; mostly grade 5, 8 of
- *   the 30 carrying an experimental effect.
+ * - `communityGoal` — awarded for taking part in a community goal; mostly grade 5, a
+ *   minority carrying an experimental effect.
  * - `techBroker` — unlocked at a tech broker. Records the route stated by the source.
  * - `eventReward` — awarded already transformed by an event; the festive articles are grade 5.
  */
@@ -150,7 +150,6 @@ interface PreEngineeredVariant {
  * ```ts
  * import { PRE_ENGINEERED_MODULES } from '@elite-dangerous-almanac/core/ships/pre-engineered';
  *
- * PRE_ENGINEERED_MODULES.length; // -> 76
  * PRE_ENGINEERED_MODULES[0];
  * // -> { symbol: 'Hpt_Mining_AbrBlstr_Fixed_Small', name: 'Abrasion Blaster',
  * //      blueprintSymbol: 'AbrasionBlaster_FarReaching', grade: 1,

package/dist/ships/pre-engineered.js

@@ -1 +1 @@
-export{PRE_ENGINEERED_MODULES,getPreEngineeredVariants,isPreEngineered}from"../chunk-BJU27V6C.js";                                                                                       //# sourceMappingURL=pre-engineered.js.map
+export{PRE_ENGINEERED_MODULES,getPreEngineeredVariants,isPreEngineered}from"../chunk-AUBV6S7V.js";                                                                                       //# sourceMappingURL=pre-engineered.js.map

package/dist/ships/ship-loadout.d.ts

@@ -314,8 +314,8 @@ type LoadoutEditErrorCode = 'immutableSlot' | 'requiredSlot' | 'incompatibleModu
  * An editor request that the current hull or build constraints cannot accept.
  *
  * @remarks
- * This remains a `TypeError`, so existing `instanceof TypeError` handling continues to
- * work. Localized editors should switch on {@link code}, then use {@link constraint}
+ * It is a `TypeError`, so `instanceof TypeError` handling catches it. Localized editors
+ * should switch on {@link code}, then use {@link constraint}
  * and {@link params} instead of parsing the English fallback in `message`.
  *
  * @example
@@ -990,12 +990,18 @@ declare class ShipLoadout {
      * omitted.
      *
      * @remarks
-     * This is the outfitting *offer*, so the fifteen {@link ships!OutfittingModule.grantOnly | grantOnly}
+     * This is the outfitting *offer*, so the {@link ships!OutfittingModule.grantOnly | grantOnly}
      * articles are never in it: each is a second identity for a module the game already
      * sells — `Int_Engine_Size2_Class1_free` is the 2E Thrusters — and listing both puts
      * the same article on the screen twice, once with no price. A build that already
      * carries one keeps it; only the choices are filtered.
      *
+     * The Cargo Hatch is absent for the same reason it cannot be removed: it is part of
+     * the hull. The source registry files it under the `internal` category — which is
+     * why {@link ships/modules-internal!INTERNAL_MODULES | INTERNAL_MODULES} carries it
+     * — but the hull is built with one and the fixed `CargoHatch` mount is the only
+     * place it goes, so no mount this method describes accepts it.
+     *
      * @param slotKey - The slot key to fit, matched case-insensitively (journal spelling).
      * @returns The fitting modules, in complete-catalogue order.
      * @throws {RangeError} If the hull has no slot with that key.
@@ -1156,7 +1162,7 @@ declare class ShipLoadout {
      * leave the build unchanged and return stable structured data.
      *
      * A Mercenary article is recomputed rather than composed, and that limits what can be
-     * done to the effect ten of those rows are sold carrying. At its purchase grade there
+     * done to the effect some of those rows are sold carrying. At its purchase grade there
      * is no recipe to recompute from — the bespoke recipe starts at grade 2 — so every
      * edit is refused with `unsupportedEngineering`. Once engineered to grade 2 or above
      * an edit recomputes normally, but only to an effect the module's own menu offers:
@@ -1292,9 +1298,9 @@ declare class ShipLoadout {
      * Set a fitted module's power-priority group.
      *
      * @param slotKey - The slot's journal key, matched case-insensitively.
-     * @param priority - The journal's **zero-based** group, `0`–`4`. Note that the
-     * outfitting panel — and {@link ships!BuildMetrics.powerBudget | BuildMetrics.powerBudget}'s `bands[].priority` — number the same
-     * five groups `1`–`5`.
+     * @param priority - The journal's **zero-based** group, `0`–`4`. The outfitting
+     * panel, and {@link ships!BuildMetrics.powerBudget | BuildMetrics.powerBudget}'s
+     * `bands[].priority`, number the same five groups `1`–`5`.
      * @returns `this`, for chaining.
      * @throws {RangeError} If the slot is empty, or `priority` is not an integer in `[0, 4]`.
      * @throws {TypeError} If `slotKey` is not a string.

package/dist/ships/ship-loadout.js

@@ -1 +1 @@
-export{LoadoutEditError,ShipLoadout}from"../chunk-TSEDU73T.js";                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    //# sourceMappingURL=ship-loadout.js.map
+export{LoadoutEditError,ShipLoadout}from"../chunk-HIJR7DOC.js";                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    //# sourceMappingURL=ship-loadout.js.map

package/dist/ships/ships.d.ts

@@ -5,7 +5,7 @@ import { CoreSlots, HardpointSlotSpec, OptionalSlotSpec, ShipSlots } from './slo
  * stats, and its slot layout in one record**, with the lookups an app needs to turn
  * an internal symbol or a display name into a {@link Ship}.
  *
- * There is only one list of ships and it is tiny (48 records), so the lookups here
+ * There is only one list of ships and it is small, so the lookups here
  * take no catalogue argument at all — they always search {@link SHIPS}. Importing one
  * bundles the whole ship list, which is what you wanted anyway. Stock module identities
  * live in `./default-loadouts`, keeping this small hull catalogue independent of them.
@@ -143,7 +143,6 @@ interface Ship {
  * ```ts
  * import { SHIPS } from '@elite-dangerous-almanac/core/ships/ships';
  *
- * SHIPS.length;                                  // -> 48
  * SHIPS.find((s) => s.symbol === 'Anaconda')?.name; // -> 'Anaconda'
  * ```
  */

package/dist/ships/ships.js

@@ -1 +1 @@
-export{SHIPS,getShipByName,getShipBySymbol,getShipSlots}from"../chunk-6UNAD74Z.js";                                                                                       //# sourceMappingURL=ships.js.map
+export{SHIPS,getShipByName,getShipBySymbol,getShipSlots}from"../chunk-C4FUV6GF.js";                                                                                       //# sourceMappingURL=ships.js.map

package/dist/ships/slots.d.ts

@@ -5,7 +5,7 @@
  * A hull offers a fixed set of mounts: seven core internals, a handful of weapon
  * hardpoints, some tiny utility mounts, and a column of optional internals. Some of
  * those mounts are **restricted** to one family of modules — military and
- * planetary-approach optionals on most hulls, and, on three hulls, cargo-only,
+ * planetary-approach optionals on most hulls, and, on a few hulls, cargo-only,
  * limpet-controller-only, vessel-hangar-only and passenger-cabin-only optionals and
  * mining-only hardpoints (see {@link SlotRestriction}). This module gives
  * each mount a stable **slot key** and a {@link BuildSlot} descriptor, and
@@ -15,7 +15,7 @@
  *
  * It holds no data; {@link enumerateSlots} takes a {@link ShipSlots} layout (from a
  * hull's `Ship` record via `getShipSlots` in `./ships`) and expands it into keyed
- * {@link BuildSlot}s. Most hulls number their mounts by rule; on ten the game does
+ * {@link BuildSlot}s. Most hulls number their mounts by rule; on some the game does
  * not, and a mount there carries its own `name` — see {@link enumerateSlots}.
  *
  * @packageDocumentation
@@ -149,7 +149,7 @@ interface BuildSlotBase {
      * `core` function name is a *different* string (`thrusters` vs the key
      * `MainEngines`); see {@link CoreSlotType}.
      *
-     * **Do not compute one.** The numbering looks regular and on ten hulls is
+     * **Do not compute one.** The numbering looks regular and on some hulls is
      * not: the Anaconda's smallest optionals are `Slot13_Size2` and `Slot14_Size1`
      * with no slots 11 or 12, the Type-9 Heavy starts at `Slot00_Size8`, the Type-7
      * Transporter uses the number `09` twice, and the Keelback's `Slot03_Size3` sits
@@ -341,7 +341,7 @@ interface ParsedSlot {
  * @returns Every mount the hull offers, as {@link BuildSlot}s.
  * @remarks
  * Unrestricted optionals are numbered `Slot01_SizeN`, `Slot02_SizeN`, … with no gaps,
- * and hardpoints `1, 2, 3` within each size class. **Ten hulls disagree**, and no
+ * and hardpoints `1, 2, 3` within each size class. **Some hulls disagree**, and no
  * rule derives what they do instead, so a mount on one of them carries its own
  * {@link OptionalSlotSpec.name} / {@link HardpointSlotSpec.name} and that wins:
  *
@@ -394,7 +394,7 @@ declare function enumerateSlots(layout: ShipSlots): BuildSlot[];
  * mount. The returned `core` and `restriction` values keep this library's own
  * camelCase spelling whatever the input looked like.
  *
- * **A `_SizeN` suffix is what the name says, not what the mount is.** On three hulls
+ * **A `_SizeN` suffix is what the name says, not what the mount is.** On some hulls
  * the game's own key disagrees with the mount it names — the Keelback's
  * `Slot03_Size3` is a size-4 mount, the Asp Scout's `Slot01_Size4` a size-5 one, and
  * five of the Type-7 Transporter's ten are off. To size a mount, find it in the hull's

package/dist/suits-B37rAORs.d.ts

@@ -0,0 +1,414 @@
+import { PersonalModifier } from './equipment/engineering.js';
+
+/**
+ * Odyssey handheld weapons: their journal identifiers, combat stats, sight
+ * magnification, reload time, grade-dependent damage, and the damage per second those
+ * stats resolve to.
+ *
+ * @packageDocumentation
+ */
+
+/** A weapon manufacturer's shared Pioneer grade-upgrade recipe. */
+type WeaponUpgradeGroup = 'karma' | 'takada' | 'manticore';
+/** Technology suffix used to disambiguate personal-weapon modification recipes. */
+type PersonalWeaponEngineeringType = 'kinetic' | 'laser' | 'plasma';
+/** A handheld weapon's form factor. */
+type PersonalWeaponClass = 'pistol' | 'carbine' | 'rifle' | 'shotgun' | 'sniper' | 'launcher';
+/** Which suit weapon slot accepts the weapon. */
+type PersonalWeaponSlot = 'primary' | 'secondary';
+/** The damage family relevant to resistances and some modification recipes. */
+type PersonalDamageType = 'kinetic' | 'thermal' | 'plasma' | 'explosive';
+/** A handheld weapon firing cycle. */
+type PersonalFireMode = 'automatic' | 'semi-automatic' | 'burst';
+/** A weapon's aim-down-sights magnification, before and after the Scope modification. */
+interface ScopeMagnification {
+    /** Magnification of the sight the weapon ships with, e.g. `1.12` for 1.12x. */
+    readonly default: number;
+    /** Magnification of the sight the Scope modification fits, e.g. `1.41` for 1.41x. */
+    readonly upgraded: number;
+}
+/** A weapon's magazine reload time, before and after the Reload Speed modification. */
+interface ReloadTime {
+    /** Seconds to reload the weapon as it ships, e.g. `2.7` for 2.7 s. */
+    readonly default: number;
+    /** Seconds to reload with the Reload Speed modification fitted, e.g. `2.16` for 2.16 s. */
+    readonly upgraded: number;
+}
+/** Grade-dependent stats for one handheld weapon. */
+interface PersonalWeaponGrade {
+    /** Damage per projectile or pellet. */
+    readonly damage: number;
+    /** Permanent engineering-modification slots available, from `0` through `4`. */
+    readonly modificationSlots: number;
+}
+/** One handheld weapon sold by Pioneer Supplies. */
+interface PersonalWeapon {
+    /** Frontier item id reported by journal loadout events. */
+    readonly symbol: string;
+    /** English display name. */
+    readonly name: string;
+    /** Manufacturer recipe family used for grade upgrades. */
+    readonly upgradeGroup: WeaponUpgradeGroup;
+    /** Recipe suffix used when the journal omits a modification's weapon technology. */
+    readonly engineeringType: PersonalWeaponEngineeringType;
+    /** Weapon form factor. */
+    readonly class: PersonalWeaponClass;
+    /** Suit slot this weapon occupies. */
+    readonly slot: PersonalWeaponSlot;
+    /** Base damage family. */
+    readonly damageType: PersonalDamageType;
+    /** Firing cycle. */
+    readonly fireMode: PersonalFireMode;
+    /** Trigger pulls per second, so bursts per second on a burst weapon. */
+    readonly rateOfFire: number;
+    /**
+     * Projectiles one round fires, each doing the full
+     * {@link PersonalWeaponGrade.damage}. Absent on every weapon that fires a single
+     * projectile — only the Manticore Intimidator, a shotgun, carries it.
+     */
+    readonly projectiles?: number;
+    /**
+     * Rounds one trigger pull fires, spent from the magazine. Present only when
+     * {@link PersonalWeapon.fireMode} is `"burst"`, together with
+     * {@link PersonalWeapon.burstRateOfFire}.
+     */
+    readonly burstRounds?: number;
+    /** Rounds per second within one burst. Absent whenever `burstRounds` is. */
+    readonly burstRateOfFire?: number;
+    /**
+     * Rounds loaded in one magazine. A burst weapon spends
+     * {@link PersonalWeapon.burstRounds} of them per trigger pull.
+     */
+    readonly magazineSize: number;
+    /** Spare rounds carried before suit-capacity changes. */
+    readonly reserveAmmo: number;
+    /** Headshot damage multiplier (`2` means 200%). */
+    readonly headshotMultiplier: number;
+    /** Nominal effective range in metres. */
+    readonly effectiveRange: number;
+    /**
+     * Aim-down-sights magnification with the stock sight and with the one the Scope
+     * modification fits. Scope carries no modifier of its own: this pair is its whole
+     * numeric effect, and it differs per weapon.
+     */
+    readonly scopeMagnification: ScopeMagnification;
+    /**
+     * Seconds to reload the magazine with the stock weapon and with the Reload Speed
+     * modification fitted. Reload Speed carries no modifier of its own: this pair is its
+     * whole numeric effect, and it differs per weapon.
+     */
+    readonly reloadTime: ReloadTime;
+    /**
+     * Grade records keyed by `"1"` through `"5"` — every weapon carries all five,
+     * unlike {@link Suit.grades}. Read one through
+     * {@link getPersonalWeaponGrade} to get the same nullable answer suits give.
+     */
+    readonly grades: Readonly<Record<`${EquipmentGrade}`, PersonalWeaponGrade>>;
+}
+/**
+ * Every handheld weapon, in catalogue order.
+ *
+ * @example
+ * ```ts
+ * import { PERSONAL_WEAPONS } from '@elite-dangerous-almanac/core/equipment/weapons';
+ * PERSONAL_WEAPONS[0]?.symbol; // -> 'wpn_s_pistol_kinetic_sauto'
+ * ```
+ */
+declare const PERSONAL_WEAPONS: readonly PersonalWeapon[];
+/**
+ * Look up a handheld weapon by its Frontier journal symbol, case-insensitively.
+ *
+ * @param symbol - Journal item id such as `"wpn_m_assaultrifle_kinetic_fauto"`,
+ * matched case-insensitively after trimming surrounding whitespace.
+ * @returns The frozen weapon record, or `null` when unknown.
+ * @throws {TypeError} If `symbol` is present and not a string. A nullish symbol is a
+ * miss, answered like an unrecognised one.
+ * @example
+ * ```ts
+ * import { getPersonalWeaponBySymbol } from '@elite-dangerous-almanac/core/equipment/weapons';
+ * getPersonalWeaponBySymbol('wpn_m_assaultrifle_kinetic_fauto')?.name; // -> 'Karma AR-50'
+ * ```
+ */
+declare function getPersonalWeaponBySymbol(symbol: string): PersonalWeapon | null;
+/**
+ * Look up a handheld weapon by display name, case-insensitively.
+ *
+ * @param name - English display name such as `"Karma AR-50"`; surrounding
+ * whitespace is ignored.
+ * @returns The frozen weapon record, or `null` when unknown.
+ * @throws {TypeError} If `name` is present and not a string. A nullish name is a miss,
+ * answered like an unrecognised one.
+ * @example
+ * ```ts
+ * import { getPersonalWeaponByName } from '@elite-dangerous-almanac/core/equipment/weapons';
+ * getPersonalWeaponByName('Karma AR-50')?.symbol; // -> 'wpn_m_assaultrifle_kinetic_fauto'
+ * ```
+ */
+declare function getPersonalWeaponByName(name: string): PersonalWeapon | null;
+/**
+ * Read one handheld weapon's stats at a grade.
+ *
+ * @param weapon - A catalogue weapon record.
+ * @param grade - Integer grade `1`–`5`.
+ * @returns The frozen grade record, or `null` when the record carries no such grade.
+ * Every catalogued weapon carries all five, so the `null` is the same promise
+ * {@link getSuitGrade} makes rather than an outcome the shipped catalogue produces —
+ * write the two the same way and neither can surprise you.
+ * @throws {RangeError} If `grade` is not an integer from 1 through 5.
+ * @example
+ * ```ts
+ * import { PERSONAL_WEAPONS, getPersonalWeaponGrade } from '@elite-dangerous-almanac/core/equipment/weapons';
+ * getPersonalWeaponGrade(PERSONAL_WEAPONS[0]!, 5)?.modificationSlots; // -> 4
+ * ```
+ */
+declare function getPersonalWeaponGrade(weapon: PersonalWeapon, grade: number): PersonalWeaponGrade | null;
+/**
+ * What one handheld weapon does per second at a grade, sustained and unsustained.
+ *
+ * @remarks
+ * Frozen, so a result can be held and shared without a defensive copy.
+ */
+interface PersonalWeaponMetrics {
+    /** Damage of one trigger pull — every projectile of every round in it. */
+    readonly damagePerShot: number;
+    /** {@link PersonalWeaponMetrics.damagePerShot} with every projectile hitting the head. */
+    readonly headshotDamagePerShot: number;
+    /** Trigger pulls per second. */
+    readonly rateOfFire: number;
+    /** Trigger pulls per second averaged over reloads. */
+    readonly sustainedRateOfFire: number;
+    /** Damage per second while firing, reloads ignored. */
+    readonly damagePerSecond: number;
+    /** Damage per second averaged over reloads — the figure a long fight sees. */
+    readonly sustainedDamagePerSecond: number;
+}
+/**
+ * Everything the on-foot damage arithmetic gives you for one weapon: damage per trigger
+ * pull, per second, and per second once reloads are counted.
+ *
+ * A grade record states damage **per projectile**, so a shot is that damage times the
+ * projectiles a round carries times the rounds one trigger pull fires. The sustained
+ * figures then average in the reload: a magazine's worth of fire takes the shots after
+ * the first, plus the tail of the last burst, plus the reload.
+ *
+ * ```text
+ * damagePerShot = damage × projectiles × burstRounds
+ * DPS           = damagePerShot × rateOfFire
+ * SDPS          = damagePerShot × (magazine's shots / one magazine-and-reload cycle)
+ * ```
+ *
+ * @param weapon - A catalogue weapon record.
+ * @param grade - Integer grade `1`–`5`.
+ * @param modifiers - Fitted modification modifiers, folded per stat the way
+ * {@link applyPersonalModifiers} does. `magazineSize` and `headshotMultiplier` are the
+ * two this arithmetic reads; modifiers naming other stats are ignored. A Reload Speed
+ * modification carries no modifier at all, so it arrives through `options` instead. A
+ * fractional magazine is held to whole rounds, rounding **up**, as `ships/weapons` does.
+ * @param options - `reloadSpeed` takes the reload from
+ * {@link PersonalWeapon.reloadTime | reloadTime.upgraded} rather than `.default`,
+ * because Reload Speed carries its magnitude as that pair rather than as a modifier.
+ * @returns The frozen {@link PersonalWeaponMetrics}, or `null` when the record carries
+ * no such grade — the same nullable answer {@link getPersonalWeaponGrade} gives. A
+ * magazine that modifiers empty to zero rounds or fewer reports no sustained fire.
+ * @throws {RangeError} If `grade` is not an integer from 1 through 5.
+ * @example
+ * ```ts
+ * import {
+ *     getPersonalWeaponByName,
+ *     personalWeaponMetrics,
+ * } from '@elite-dangerous-almanac/core/equipment/weapons';
+ *
+ * const shotgun = getPersonalWeaponByName('Manticore Intimidator')!;
+ * personalWeaponMetrics(shotgun, 5)?.damagePerShot; // -> 52.15  (ten pellets of 5.215)
+ * personalWeaponMetrics(shotgun, 5)?.damagePerSecond; // -> 65.19
+ * personalWeaponMetrics(shotgun, 5)?.sustainedDamagePerSecond; // -> 31.6  (with the 2.5 s reload)
+ * ```
+ */
+declare function personalWeaponMetrics(weapon: PersonalWeapon, grade: number, modifiers?: readonly PersonalModifier[], options?: {
+    readonly reloadSpeed?: boolean;
+}): PersonalWeaponMetrics | null;
+
+/**
+ * Odyssey personal suits: their journal identifiers, the suit-wide component stats every
+ * grade shares, and the grade-dependent defensive stats.
+ *
+ * @packageDocumentation
+ */
+
+/** A Pioneer Supplies equipment grade, from the stock grade 1 through grade 5. */
+type EquipmentGrade = 1 | 2 | 3 | 4 | 5;
+/**
+ * Frontier's own `SlotName` for a suit weapon mount, exactly as the journal spells it.
+ *
+ * @remarks
+ * The `SuitLoadout`, `CreateSuitLoadout`, `SwitchSuitLoadout`, `LoadoutEquipModule` and
+ * `LoadoutRemoveModule` events all write one of these three strings. The secondary mount
+ * carries no number, because the game gives it none. Compare a key with `===`; it is
+ * case-sensitive, like every other journal key.
+ */
+type PersonalMountKey = 'PrimaryWeapon1' | 'PrimaryWeapon2' | 'SecondaryWeapon';
+/**
+ * One weapon mount on a suit.
+ *
+ * @remarks
+ * {@link PersonalMount.key} is Frontier's journal `SlotName`, so a `SuitLoadout`
+ * module joins straight onto a mount without a positional index.
+ * @example
+ * ```ts
+ * import { getSuitByFamily } from '@elite-dangerous-almanac/core/equipment/suits';
+ *
+ * const suit = getSuitByFamily('tacticalsuit')!;
+ * suit.mounts.map((mount) => mount.key);
+ * // -> ['PrimaryWeapon1', 'PrimaryWeapon2', 'SecondaryWeapon']
+ * suit.mounts.filter((mount) => mount.kind === 'primary').map((mount) => mount.key);
+ * // -> ['PrimaryWeapon1', 'PrimaryWeapon2']
+ * ```
+ */
+interface PersonalMount {
+    /** Frontier journal `SlotName`, e.g. `"PrimaryWeapon1"`. */
+    readonly key: PersonalMountKey;
+    /** Which weapons the mount takes; a weapon whose `slot` equals it fits here. */
+    readonly kind: PersonalWeaponSlot;
+}
+/** The stats of one suit at one equipment grade. */
+interface SuitGrade {
+    /** Frontier item symbol for this exact suit and grade. */
+    readonly symbol: string;
+    /** Permanent engineering-modification slots available, from `0` through `4`. */
+    readonly modificationSlots: number;
+    /** Base shield strength in shield points. */
+    readonly shieldStrength: number;
+    /** Shield points regenerated per second. */
+    readonly shieldRegeneration: number;
+    /** Kinetic damage resistance as a fraction; negative values increase damage. */
+    readonly kineticResistance: number;
+    /** Thermal damage resistance as a fraction. */
+    readonly thermalResistance: number;
+    /** Plasma damage resistance as a fraction; negative values increase damage. */
+    readonly plasmaResistance: number;
+    /** Explosive damage resistance as a fraction. */
+    readonly explosiveResistance: number;
+}
+/** One personal suit model sold by Pioneer Supplies. */
+interface Suit {
+    /** Suit family without a grade suffix, e.g. `"utilitysuit"`. */
+    readonly family: string;
+    /** English display name, e.g. `"Maverick Suit"`. */
+    readonly name: string;
+    /**
+     * Every weapon mount the suit carries, in the order the game lists them: the
+     * primary mounts by their number, then the secondary mount.
+     *
+     * @remarks
+     * Count a kind by filtering:
+     * `suit.mounts.filter((mount) => mount.kind === 'primary').length`.
+     */
+    readonly mounts: readonly PersonalMount[];
+    /** Suit health in health points, the pool the shield protects. */
+    readonly health: number;
+    /** Suit mass in kilograms. */
+    readonly mass: number;
+    /** Battery capacity in energy units, the pool the suit's tools draw from. */
+    readonly batteryCapacity: number;
+    /** Emergency air, in seconds of life support. */
+    readonly oxygenTime: number;
+    /** Jump-assist boost acceleration, the bare figure the panel shows, which has no unit. */
+    readonly boostAcceleration: number;
+    /** Backpack goods capacity in items. */
+    readonly goodsCapacity: number;
+    /** Backpack assets capacity in components. */
+    readonly assetsCapacity: number;
+    /** Backpack data capacity in items. */
+    readonly dataCapacity: number;
+    /** How far footsteps carry, as a multiplier of the base audible range. */
+    readonly footstepAudibleRange: number;
+    /** Line-of-sight analysis range in metres. */
+    readonly losAnalysisRange: number;
+    /** Seconds of line of sight the suit needs to complete an analysis. */
+    readonly losAnalysisTime: number;
+    /**
+     * Available grade records, keyed by `"1"` through `"5"`.
+     *
+     * @remarks
+     * A grade changes exactly what {@link SuitGrade} carries — the four resistances,
+     * shield strength, shield regeneration, the modification slots and the item symbol.
+     * Every stat above is a property of the suit family and is the same at all five.
+     */
+    readonly grades: Readonly<Partial<Record<`${EquipmentGrade}`, SuitGrade>>>;
+}
+/**
+ * Every personal suit, including the non-upgradeable Flight Suit.
+ *
+ * @example
+ * ```ts
+ * import { SUITS } from '@elite-dangerous-almanac/core/equipment/suits';
+ * SUITS.find((suit) => suit.family === 'utilitysuit')?.name; // -> 'Maverick Suit'
+ * ```
+ */
+declare const SUITS: readonly Suit[];
+/**
+ * Look up a suit model by its grade-independent family, case-insensitively.
+ *
+ * @param family - Family such as `"utilitysuit"`, matched case-insensitively after
+ * trimming surrounding whitespace.
+ * @returns The frozen suit record, or `null` when unknown.
+ * @throws {TypeError} If `family` is present and not a string. A nullish family is a
+ * miss, answered like an unrecognised one.
+ * @example
+ * ```ts
+ * import { getSuitByFamily } from '@elite-dangerous-almanac/core/equipment/suits';
+ * getSuitByFamily('utilitysuit')?.name; // -> 'Maverick Suit'
+ * ```
+ */
+declare function getSuitByFamily(family: string): Suit | null;
+/**
+ * Look up a suit by its display name, case-insensitively.
+ *
+ * @param name - Display name such as `"Maverick Suit"`, matched case-insensitively
+ * after trimming surrounding whitespace.
+ * @returns The frozen suit record, or `null` when unknown.
+ * @throws {TypeError} If `name` is present and not a string. A nullish name is a miss,
+ * answered like an unrecognised one.
+ * @example
+ * ```ts
+ * import { getSuitByName } from '@elite-dangerous-almanac/core/equipment/suits';
+ * getSuitByName('Maverick Suit')?.family; // -> 'utilitysuit'
+ * ```
+ */
+declare function getSuitByName(name: string): Suit | null;
+/**
+ * Resolve the grade-specific Frontier item symbol reported by journal suit events.
+ *
+ * @param symbol - Item symbol such as `"utilitysuit_class3"`, matched
+ * case-insensitively after trimming surrounding whitespace.
+ * @returns The owning suit and its numeric grade, or `null` when unknown.
+ * @throws {TypeError} If `symbol` is present and not a string. A nullish symbol is a
+ * miss, answered like an unrecognised one.
+ * @example
+ * ```ts
+ * import { getSuitBySymbol } from '@elite-dangerous-almanac/core/equipment/suits';
+ * getSuitBySymbol('utilitysuit_class3')?.grade; // -> 3
+ * ```
+ */
+declare function getSuitBySymbol(symbol: string): Readonly<{
+    suit: Suit;
+    grade: EquipmentGrade;
+}> | null;
+/**
+ * Read a suit's stats at one grade.
+ *
+ * @param suit - A catalogue suit record.
+ * @param grade - Integer grade `1`–`5`.
+ * @returns The frozen grade record, or `null` when that suit has no such grade.
+ * @throws {RangeError} If `grade` is not an integer from 1 through 5.
+ * @example
+ * ```ts
+ * import { getSuitByFamily, getSuitGrade } from '@elite-dangerous-almanac/core/equipment/suits';
+ * const suit = getSuitByFamily('utilitysuit');
+ * if (!suit) throw new Error('Maverick Suit is missing');
+ * getSuitGrade(suit, 5)?.modificationSlots; // -> 4
+ * ```
+ */
+declare function getSuitGrade(suit: Suit, grade: number): SuitGrade | null;
+
+export { type EquipmentGrade as E, PERSONAL_WEAPONS as P, type ReloadTime as R, SUITS as S, type WeaponUpgradeGroup as W, type PersonalDamageType as a, type PersonalFireMode as b, type PersonalMount as c, type PersonalMountKey as d, type PersonalWeapon as e, type PersonalWeaponClass as f, type PersonalWeaponEngineeringType as g, type PersonalWeaponGrade as h, type PersonalWeaponMetrics as i, type PersonalWeaponSlot as j, type ScopeMagnification as k, type Suit as l, type SuitGrade as m, getPersonalWeaponByName as n, getPersonalWeaponBySymbol as o, getPersonalWeaponGrade as p, getSuitByFamily as q, getSuitByName as r, getSuitBySymbol as s, getSuitGrade as t, personalWeaponMetrics as u };

package/dist/{system-address-cyJaeZIS.d.ts → system-address-DmzXRD48.d.ts}

@@ -271,8 +271,9 @@ declare function decodeModSystemAddress(id64: SystemAddressInput): DecodedAddres
  * `resolveNamingRegionOrigin` in `./naming-region-origins`.
  * @returns The 64-bit system address.
  * @throws {RangeError} If the mass code is outside 0–7, a letter is outside 0–25, `n1`
- * is not one the boxel packer accepts, the origin has a negative coordinate, the name's boxel code or sector falls outside the
- * address layout, or the sequence does not fit its size-class-dependent field.
+ * is not one the boxel packer accepts, the origin has a negative coordinate, the name's
+ * boxel code or sector falls outside the address layout, or the sequence does not fit
+ * its size-class-dependent field.
  * @example
  * ```ts
  * import { resolveNamingRegionOrigin } from '@elite-dangerous-almanac/core/astro/naming-region-origins';
@@ -297,8 +298,9 @@ declare function encodeSystemAddress(parts: SystemNameParts, origin: NamingRegio
  * @returns The 64-bit modulated system address. These routinely exceed `2^53`, so
  * keep them as `bigint` (or a decimal string) rather than a JS `number`.
  * @throws {RangeError} If the mass code is outside 0–7, a letter is outside 0–25, `n1`
- * is not one the boxel packer accepts, the origin has a negative coordinate, the name's boxel code or sector falls outside the
- * address layout, or the sequence does not fit the 15-bit modulated field.
+ * is not one the boxel packer accepts, the origin has a negative coordinate, the name's
+ * boxel code or sector falls outside the address layout, or the sequence does not fit
+ * the 15-bit modulated field.
  * @example
  * ```ts
  * import { resolveNamingRegionOrigin } from '@elite-dangerous-almanac/core/astro/naming-region-origins';