eve-fit-engine 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2196 @@
+/**
+ * Core types for the fitting tool. Shared between:
+ *  - the bundle (loaded into memory client-side from /public/fitting-data/)
+ *  - the calc engine (modifier application, derived stats)
+ *  - the UI components (slot rendering, picker, stats panels)
+ *  - the API endpoints (fit save/load on Prisma)
+ *
+ * Naming convention: this file contains ONLY interfaces & enum-likes. No
+ * runtime constants — those live in `constants.ts` so types can be imported
+ * without pulling in code.
+ */
+interface SdeAttribute {
+    id: number;
+    name: string;
+    displayName?: string;
+    unitID?: number;
+    iconID?: number;
+    defaultValue: number;
+    highIsGood: boolean;
+    stackable: boolean;
+    attributeCategoryID?: number;
+    dataType?: number;
+}
+interface SdeUnit {
+    id: number;
+    name: string;
+    displayName?: string;
+}
+interface SdeModifierInfo {
+    /** Domain strings as they appear in the SDE — values observed:
+     *  `itemID` (= self), `charID` (= the character/skills), `shipID`,
+     *  `target` and `targetID` (both → projected target), `otherID`
+     *  (charge ↔ module), `structureID`. The legacy aliases `'self'` and
+     *  `'char'` are kept for places that historically wrote them by hand.
+     *  All variants are normalised by `FitContext.resolveDomain`. */
+    domain: 'self' | 'itemID' | 'char' | 'charID' | 'shipID' | 'target' | 'targetID' | 'otherID' | 'structureID';
+    func: 'ItemModifier' | 'LocationModifier' | 'LocationGroupModifier' | 'LocationRequiredSkillModifier' | 'OwnerRequiredSkillModifier' | 'EffectStopper';
+    modifiedAttributeID?: number;
+    modifyingAttributeID?: number;
+    operation?: number;
+    groupID?: number;
+    skillTypeID?: number;
+    /** Only set on `func: 'EffectStopper'` modifiers. The numeric SDE
+     *  effect ID this modifier suppresses on the target — e.g. warp
+     *  scrambler / disruptor entries carry `effectID: 6441` (MWD) and
+     *  `effectID: 6442` (MJD). Read by `collectEffectStoppers()` in the
+     *  projection pre-pass. */
+    effectID?: number;
+}
+interface SdeEffect {
+    id: number;
+    name: string;
+    displayName?: string;
+    effectCategoryID?: number;
+    isOffensive: boolean;
+    isAssistance: boolean;
+    isWarpSafe: boolean;
+    durationAttributeID?: number;
+    dischargeAttributeID?: number;
+    rangeAttributeID?: number;
+    falloffAttributeID?: number;
+    trackingSpeedAttributeID?: number;
+    fittingUsageChanceAttributeID?: number;
+    resistanceAttributeID?: number;
+    distribution?: number;
+    propulsionChance: boolean;
+    electronicChance: boolean;
+    rangeChance: boolean;
+    disallowAutoRepeat: boolean;
+    guid?: string;
+    modifierInfo: SdeModifierInfo[];
+}
+interface SdeMetaGroup {
+    id: number;
+    name?: string;
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    iconID?: number;
+}
+interface SdeCategory {
+    id: number;
+    name?: string;
+}
+interface SdeGroup {
+    id: number;
+    categoryID: number;
+    name?: string;
+}
+/** EVE in-game Market window taxonomy node. Forms a tree via
+ *  `parentGroupID`; root nodes have it undefined. The picker uses
+ *  this hierarchy to render Module > Capacitor > Cap Battery the
+ *  same way the in-game Market window does, instead of the flat
+ *  SDE category > group fallback. */
+interface SdeMarketGroup {
+    id: number;
+    name?: string;
+    parentGroupID?: number;
+    iconID?: number;
+    /** True iff items can sit directly under this node (vs. it being
+     *  a pure folder grouping deeper market groups). Useful for
+     *  picking the right level to show as the "leaf" subgroup. */
+    hasTypes?: boolean;
+}
+interface SdeCloneGrade {
+    id: number;
+    name: string;
+    skills: Array<{
+        typeID: number;
+        level: number;
+    }>;
+}
+interface SdeDbuffCollection {
+    id: number;
+    aggregateMode: 'Minimum' | 'Maximum' | 'Sum';
+    operationName: string;
+    displayName?: string;
+    showOutputValueInUI?: 'ShowNormal' | 'ShowInverted' | 'Hide';
+    itemModifiers: Array<{
+        dogmaAttributeID: number;
+    }>;
+    locationModifiers: Array<{
+        dogmaAttributeID: number;
+    }>;
+    locationGroupModifiers: Array<{
+        dogmaAttributeID: number;
+        groupID: number;
+    }>;
+    locationRequiredSkillModifiers: Array<{
+        dogmaAttributeID: number;
+        skillID: number;
+    }>;
+}
+interface SdeDynamicAttribute {
+    id: number;
+    attributeIDs: Array<{
+        id: number;
+        min: number;
+        max: number;
+    }>;
+    inputOutputMapping: Array<{
+        applicableTypes: number[];
+        resultingType: number;
+    }>;
+}
+interface SdeType {
+    id: number;
+    name?: string;
+    groupID: number;
+    categoryID: number;
+    marketGroupID?: number;
+    iconID?: number;
+    metaGroupID?: number;
+    metaLevel?: number;
+    variationParentTypeID?: number;
+    mass?: number;
+    volume?: number;
+    capacity?: number;
+    portionSize?: number;
+    basePrice?: number;
+    attributes: Array<{
+        id: number;
+        v: number;
+    }>;
+    effects: Array<{
+        id: number;
+        def: 0 | 1;
+    }>;
+}
+interface BundleManifest {
+    version: string;
+    builtAt: string;
+    totalBytes: number;
+    files: Record<string, {
+        bytes: number;
+        entries: number;
+    }>;
+}
+interface FittingDataset {
+    version: string;
+    attributes: Map<number, SdeAttribute>;
+    units: Map<number, SdeUnit>;
+    effects: Map<number, SdeEffect>;
+    metaGroups: Map<number, SdeMetaGroup>;
+    categories: Map<number, SdeCategory>;
+    groups: Map<number, SdeGroup>;
+    /** EVE Market-window hierarchy. Pickers walk the parent-chain
+     *  from a type's `marketGroupID` up to the root to render the
+     *  same tree the user sees in-game (Modules → Capacitor →
+     *  Capacitor Battery). Empty when the loaded bundle predates
+     *  market-group support. */
+    marketGroups: Map<number, SdeMarketGroup>;
+    cloneGrades: Map<number, SdeCloneGrade>;
+    dbuffCollections: Map<number, SdeDbuffCollection>;
+    dynamicAttributes: Map<number, SdeDynamicAttribute>;
+    typesByBucket: Partial<Record<TypeBucket, Map<number, SdeType>>>;
+    /** Resolves a type from any already-loaded bucket. */
+    getType(id: number): SdeType | undefined;
+    /** Lazily loads a bucket if not already in memory. */
+    loadBucket(bucket: TypeBucket): Promise<Map<number, SdeType>>;
+}
+type TypeBucket = 'ships' | 'modules' | 'charges' | 'drones' | 'fighters' | 'implants' | 'subsystems' | 'skills' | 'systemEffects' | 'structures' | 'structureModules' | 'mutaplasmids';
+type SlotType = 'HI' | 'MED' | 'LO' | 'RIG' | 'SUBSYSTEM' | 'SERVICE';
+type ModuleState = 'OFFLINE' | 'ONLINE' | 'ACTIVE' | 'OVERLOAD';
+type FitVisibility = 'PRIVATE' | 'PUBLIC' | 'LINK';
+interface MutatorData {
+    /** Mutaplasmid (dynamicItemAttribute) type id used to mutate this module. */
+    dynamicTypeID: number;
+    /** User-picked attribute values within the mutaplasmid's min/max range. */
+    attributes: Record<number, number>;
+    /** Source module type the abyssal was created from. The fit's
+     *  `module.typeID` swaps to the mutaplasmid's `resultingType` (e.g.
+     *  "Abyssal Warp Disruptor") on apply; this preserves the original
+     *  type so the editor can: (a) reuse the source's base attribute
+     *  values to compute slider ranges when re-editing, (b) restore
+     *  the original module typeID when the user clears the mutator. */
+    sourceTypeID?: number;
+}
+interface FitModule {
+    /** Stable id within the fit (uuid client-side, db id server-side). */
+    id: string;
+    slotType: SlotType;
+    /** 0-indexed position within the slot type (max 8). */
+    position: number;
+    typeID: number;
+    state: ModuleState;
+    chargeTypeID?: number;
+    mutator?: MutatorData;
+}
+interface FitDrone {
+    id: string;
+    typeID: number;
+    countTotal: number;
+    countActive: number;
+}
+interface FitFighter {
+    id: string;
+    typeID: number;
+    count: number;
+    abilityState: Record<number, boolean>;
+}
+interface FitCargo {
+    id: string;
+    typeID: number;
+    count: number;
+}
+interface FitImplant {
+    id: string;
+    typeID: number;
+    slot: number;
+}
+interface FitBooster {
+    id: string;
+    typeID: number;
+    slot: number;
+    activeSideEffects: number[];
+}
+interface FitSubsystem {
+    id: string;
+    slot: number;
+    typeID: number;
+}
+interface DamageProfile {
+    id?: string;
+    name: string;
+    em: number;
+    thermal: number;
+    kinetic: number;
+    explosive: number;
+    isPreset?: boolean;
+}
+interface TargetProfile {
+    id?: string;
+    name: string;
+    signatureRadius: number;
+    maxVelocity: number;
+    emResist: number;
+    thermalResist: number;
+    kineticResist: number;
+    explosiveResist: number;
+    isPreset?: boolean;
+}
+interface SkillProfile {
+    id?: string;
+    name: string;
+    isDefault: boolean;
+    source: 'manual' | 'esi' | 'preset';
+    sourceCharacterID?: string;
+    /** typeID → 0..5. Sparse map; missing skills assumed level 0. */
+    skills: Record<number, 0 | 1 | 2 | 3 | 4 | 5>;
+    syncedAt?: string;
+}
+interface Fit {
+    id?: string;
+    discordUserID?: string;
+    shipTypeID: number;
+    name: string;
+    description?: string;
+    visibility: FitVisibility;
+    shareSlug?: string;
+    damageProfileID?: string;
+    targetProfileID?: string;
+    skillProfileID?: string;
+    authorCharacterID?: string;
+    authorName?: string;
+    authorCorpID?: string;
+    authorCorpName?: string;
+    tags: string[];
+    modules: FitModule[];
+    drones: FitDrone[];
+    fighters: FitFighter[];
+    cargo: FitCargo[];
+    implants: FitImplant[];
+    boosters: FitBooster[];
+    subsystems: FitSubsystem[];
+    /** T3D / T3C exclusive mode type id, if any. */
+    modeTypeID?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Every modifier applied by the engine carries one of these operations.
+ * Maps 1:1 to EVE's dogma operation enum. Order is significant — pipeline
+ * applies them in this exact sequence per attribute.
+ */
+type ModifierOperation = 'PreAssign' | 'PreMul' | 'PreDiv' | 'ModAdd' | 'ModSub' | 'PostMul' | 'PostDiv' | 'PostPercent' | 'PostAssign';
+interface ModifierAffliction {
+    sourceKind: 'module' | 'skill' | 'ship' | 'implant' | 'booster' | 'mode' | 'projected' | 'fleet' | 'drone' | 'fighter' | 'subsystem';
+    sourceID: string;
+    operation: ModifierOperation;
+    value: number;
+    /** Stacking penalty group key. null = unstacked. */
+    stackingGroup: string | null;
+    /** Optional resistance attribute applied to this modifier (projected effects). */
+    resistanceAttributeID?: number;
+}
+interface ComputedAttribute {
+    id: number;
+    base: number;
+    final: number;
+    afflictions: ModifierAffliction[];
+}
+/** What computeFit returns — the full derived view of a fit. */
+interface ComputedFit {
+    fit: Fit;
+    /** Computed attributes for the ship itself (capacity, max velocity, etc). */
+    ship: Map<number, ComputedAttribute>;
+    /** Per-module computed state (modified attributes after skills + ship bonuses + module bonuses). */
+    modules: Map<string, ModuleComputed>;
+    drones: Map<string, DroneComputed>;
+    fighters: Map<string, FighterComputed>;
+    derived: DerivedStats;
+}
+interface ModuleComputed {
+    fitModuleID: string;
+    typeID: number;
+    slotType: SlotType;
+    state: ModuleState;
+    attributes: Map<number, ComputedAttribute>;
+    /** Effective CPU/PG cost (modifiable by Engineering skills). */
+    effectiveCpu: number;
+    effectivePower: number;
+}
+interface DroneComputed {
+    fitDroneID: string;
+    typeID: number;
+    attributes: Map<number, ComputedAttribute>;
+    /** DPS contribution from this drone group (per-drone × count). */
+    dps: number;
+}
+interface FighterComputed {
+    fitFighterID: string;
+    typeID: number;
+    attributes: Map<number, ComputedAttribute>;
+    abilities: Array<{
+        effectID: number;
+        enabled: boolean;
+        dps: number;
+    }>;
+}
+interface DerivedStats {
+    fitting: {
+        cpuUsed: number;
+        cpuMax: number;
+        powerUsed: number;
+        powerMax: number;
+        calibrationUsed: number;
+        calibrationMax: number;
+        droneBandwidthUsed: number;
+        droneBandwidthMax: number;
+        droneBayUsed: number;
+        droneBayMax: number;
+        slots: Record<SlotType, {
+            used: number;
+            max: number;
+        }>;
+        /** Per-weapon-class hardpoint accounting. Turrets and launchers
+         *  consume separate physical mount points on the hull (attrs
+         *  `turretHardpoints` 102 and `launcherHardpoints` 101). HI
+         *  modules that are NEITHER turret nor launcher (smartbombs,
+         *  EWAR bursts, command bursts, cloaks, MJD…) consume a HI
+         *  slot but no hardpoint. */
+        hardpoints: {
+            turret: {
+                used: number;
+                max: number;
+            };
+            launcher: {
+                used: number;
+                max: number;
+            };
+        };
+    };
+    defense: {
+        shield: {
+            hp: number;
+            ehpUniform: number;
+            ehpAgainstProfile: number;
+            resistances: {
+                em: number;
+                thermal: number;
+                kinetic: number;
+                explosive: number;
+            };
+        };
+        armor: {
+            hp: number;
+            ehpUniform: number;
+            ehpAgainstProfile: number;
+            resistances: {
+                em: number;
+                thermal: number;
+                kinetic: number;
+                explosive: number;
+            };
+        };
+        hull: {
+            hp: number;
+            ehpUniform: number;
+            ehpAgainstProfile: number;
+            resistances: {
+                em: number;
+                thermal: number;
+                kinetic: number;
+                explosive: number;
+            };
+        };
+        ehpTotalAgainstProfile: number;
+    };
+    offense: {
+        weaponDps: number;
+        /** Reload-amortised weapon DPS. */
+        weaponSustainedDps: number;
+        droneDps: number;
+        fighterDps: number;
+        totalDps: number;
+        /** Reload-amortised total DPS (weapons + drones). */
+        totalSustainedDps: number;
+        alphaStrike: number;
+        weaponOptimal: number;
+        weaponFalloff: number;
+        weaponTracking?: number;
+        explosionVelocity?: number;
+        explosionRadius?: number;
+        breakdown: WeaponContribution[];
+    };
+    capacitor: {
+        capacity: number;
+        rechargeMs: number;
+        peakRechargeRate: number;
+        usagePerSecond: number;
+        stable: boolean;
+        stablePercent: number;
+        secondsToEmpty?: number;
+    };
+    tank: {
+        shieldRepairAmount: number;
+        shieldRepairDuration: number;
+        shieldRepairPerSecond: number;
+        /** Reload-amortised shield rep/sec (paste-fueled AAR / cap-fueled
+         *  ASB modulate this lower than peak). */
+        shieldRepairPerSecondSustained: number;
+        armorRepairAmount: number;
+        armorRepairDuration: number;
+        armorRepairPerSecond: number;
+        armorRepairPerSecondSustained: number;
+        hullRepairAmount: number;
+        hullRepairDuration: number;
+        hullRepairPerSecond: number;
+        hullRepairPerSecondSustained: number;
+        passiveShieldRegenPeak: number;
+    };
+    navigation: {
+        maxVelocity: number;
+        mass: number;
+        agility: number;
+        alignTimeSeconds: number;
+        warpSpeed: number;
+    };
+    targeting: {
+        maxTargetingRange: number;
+        maxLockedTargets: number;
+        signatureRadius: number;
+        scanResolution: number;
+        sensorStrength: number;
+        sensorType: 'radar' | 'ladar' | 'magnetometric' | 'gravimetric' | 'unknown';
+    };
+    drones: {
+        bayUsed: number;
+        bayMax: number;
+        bandwidthUsed: number;
+        bandwidthMax: number;
+        active: number;
+        controlRange: number;
+    };
+    /** Active projected effects from the ProjectedSource list. Empty when
+     *  no projection is configured. */
+    projected: ProjectedEffectReport[];
+    /** Upwell-structure metadata. Populated only when the host typeID
+     *  resolves to a category=65 type; null for ship fits. Carries the
+     *  service-slot summary + total fuel-block consumption across all
+     *  online service modules. */
+    structure: StructureMeta | null;
+    /** Per-module final-attribute snapshot keyed by `Fit.modules[i].id`.
+     *  The engine writes the final (post-skill, post-hull-bonus,
+     *  post-modifier-pipeline) value of every attribute on each
+     *  module + its loaded charge after `applySourceItem` runs.
+     *  Consumed by the hover popover to show user-meaningful values
+     *  ("3.6 km optimal" with skill bonuses) instead of raw SDE base
+     *  values. Each entry is `{ module: Map<attrID, finalValue>,
+     *  charge: Map<attrID, finalValue> | null }`. */
+    moduleSnapshots: Record<string, ModuleAttrSnapshot>;
+}
+interface ModuleAttrSnapshot {
+    module: Record<number, number>;
+    charge: Record<number, number> | null;
+}
+interface StructureServiceModule {
+    /** Index of the module in `Fit.modules`. */
+    moduleIndex: number;
+    typeID: number;
+    name: string;
+    /** ONLINE / ACTIVE / OFFLINE — only ONLINE+ contributes fuel. */
+    state: 'OFFLINE' | 'ONLINE' | 'ACTIVE' | 'OVERLOAD';
+    /** Per-hour fuel block cost (attr 2109 serviceModuleFuelAmount).
+     *  Zero when the module is OFFLINE. */
+    fuelBlocksPerHour: number;
+}
+interface StructureMeta {
+    /** Service-slot capacity from the host hull (attr 2056). */
+    serviceSlotsMax: number;
+    /** Number of modules currently fitted in a SERVICE slot (regardless
+     *  of state). */
+    serviceSlotsUsed: number;
+    /** Sum of `serviceModuleFuelAmount` across modules whose state is
+     *  ONLINE or above. Per-hour rate. */
+    fuelBlocksPerHour: number;
+    /** Per-service-module breakdown for the UI. */
+    services: StructureServiceModule[];
+}
+/** Result of computeFit when the engine cannot compute a portion (missing
+ *  data, malformed fit, etc.). Captures partial results + warnings. */
+interface FitWarning {
+    code: string;
+    message: string;
+    sourceID?: string;
+}
+/**
+ * Projected source — a hostile module/drone applying its effects to the fit
+ * being computed. Modelled as a typeID + state + optional charge so the
+ * same modifier engine can dispatch (with `domain: 'targetID'` resolving to
+ * the fit's own ship as the target). Used for previewing PvP scenarios:
+ * "what does my ship look like under ECM / web / damp?".
+ */
+interface ProjectedSource {
+    id: string;
+    typeID: number;
+    state: ModuleState;
+    chargeTypeID?: number;
+    mutator?: MutatorData;
+    /** Distance in meters between attacker and target. Optional — if
+     *  unset the engine treats the projection as in-optimal (full effect,
+     *  factor = 1). For falloff-projected EWAR (web/damp/paint/track/
+     *  guidance) the engine applies `0.5 ** ((max(0, distance - optimal)
+     *  / falloff) ** 2)` and clamps to 0 past `optimal + 3 × falloff`. */
+    projectionRange?: number;
+}
+/** Summary of an active projected effect — surfaced so the UI can render
+ *  "you're being jammed at X% per cycle" / "your tracking is reduced". */
+interface ProjectedEffectReport {
+    /** Source projected module type. */
+    typeID: number;
+    /** What kind of EWAR this is. */
+    kind: 'ECM' | 'SENSOR_DAMP' | 'TRACKING_DISRUPT' | 'WEB' | 'WARP_SCRAM' | 'WARP_DISRUPT' | 'NEUT' | 'NOS' | 'OTHER' | 'REMOTE_REP_SHIELD' | 'REMOTE_REP_ARMOR' | 'REMOTE_REP_HULL' | 'REMOTE_CAP';
+    /** Per-cycle jam probability (0..1) — only ECM. */
+    jamChance?: number;
+    /** Per-second healing received on the relevant layer (REMOTE_REP_*) or
+     *  per-second cap drain (positive = drain, negative = injection) for
+     *  REMOTE_CAP / NEUT / NOS. */
+    perSecond?: number;
+    /** Free-form summary the UI can render verbatim. */
+    summary: string;
+}
+/**
+ * Per-weapon DPS / range breakdown row. Aggregated into DerivedStats.offense
+ * by `derived/offense.ts::computeOffense`. The UI uses this to render a
+ * "weapon by weapon" listing under the offense tab + to drive the
+ * "max engagement range" / "tracking limit" badges.
+ */
+type WeaponKind = 'TURRET' | 'MISSILE' | 'SMARTBOMB' | 'DOOMSDAY' | 'DRONE';
+interface WeaponContribution {
+    sourceID: string;
+    typeID: number;
+    name?: string;
+    kind: WeaponKind;
+    /** Single-volley damage (sum across all weapons of this row's count). */
+    alpha: number;
+    /** Peak DPS — alpha / cycle. Burst rate during the active firing window. */
+    dps: number;
+    /** DPS amortised across reload windows. For weapons with frequent reloads
+     *  (lasers, cap boosters, capital weapons) this is meaningfully lower
+     *  than `dps`. For HAM/cruise launchers the difference is < 1 %. Equals
+     *  `dps` when no charge / no reload model. */
+    sustainedDps?: number;
+    /** Reload time in seconds (parsed from module's `reloadTime` attribute
+     *  or assigned a 1 s default by Pyfa-parity legacy effects 10/34/67/
+     *  101/6995). */
+    reloadSeconds?: number;
+    /** Charges per loadout — `floor(launcher_capacity / charge_volume)`. */
+    chargesPerLoad?: number;
+    /** Vorton Projector ONLY — best-case chain DPS assuming `arcTargets`
+     *  are within range. Computed as a geometric series of base DPS:
+     *  Σ(base × (1 - reduction)^k) for k=0..N-1. */
+    chainDpsMax?: number;
+    /** Vorton Projector ONLY — number of chain targets (e.g. 10). */
+    chainTargetCount?: number;
+    cycleSeconds: number;
+    damages: {
+        em: number;
+        thermal: number;
+        kinetic: number;
+        explosive: number;
+        total: number;
+    };
+    range: {
+        optimal: number;
+        falloff: number;
+        tracking: number;
+        burstRange: number;
+        explosionRadius: number;
+        explosionVelocity: number;
+        drf: number;
+    };
+    chargeTypeID?: number;
+    count: number;
+    /** Triglavian disintegrator (effect 6995) spool data. Carries the
+     *  fully-modified max bonus (attr 2734 post-ship-hull boosts like
+     *  Babaroga's +20%/level Large Precursor Weapon) and the per-cycle
+     *  bonus (attr 2733). The UI reads these to render the spool slider's
+     *  Min/Max DPS columns and the time-to-full-spool readout without
+     *  re-running the engine. Absent on every other weapon kind. */
+    disintegrator?: {
+        maxBonus: number;
+        bonusPerCycle: number;
+        /** DPS at spool=0 (cold start). Computed by the engine from the
+         *  current `dps` and the spool factor used in this very compute
+         *  pass — `baseDps = dps / (1 + currentSpoolPct × maxBonus)`.
+         *  Storing it here makes the slider Min/Max readouts INVARIANT to
+         *  the slider position: both Min (= baseDps) and Max (= baseDps ×
+         *  (1 + maxBonus)) come straight from this field, instead of the
+         *  UI reverse-engineering them on every render — which produced a
+         *  visible drift while the debounced engine recompute was
+         *  in-flight. */
+        baseDps: number;
+    };
+}
+
+/**
+ * Top-level fit calculation orchestrator.
+ *
+ * `computeFit(fit, dataset, options)` builds the runtime ItemState graph,
+ * applies the canonical EVE modifier pipeline in order, and returns a
+ * ComputedFit suitable for UI rendering.
+ *
+ * Phase 1 scope (this file as of the foundation cut):
+ *   - Build ItemState graph from the persistent Fit + dataset
+ *   - Apply skills via the modifier engine (LocationRequiredSkillModifier
+ *     family) — full coverage for ~93% of skill-based bonuses
+ *   - Apply ship intrinsic effects (LocationModifier on the ship type's
+ *     own effects)
+ *   - Apply module effects filtered by current state (offline excluded)
+ *   - Apply implants / boosters / mode / subsystems via the same dispatcher
+ *   - Snapshot a minimal DerivedStats (ship hp/cap/nav/targeting + slot
+ *     usage). Advanced derived stats (DPS / cap stability / EHP against
+ *     damage profile / projected EWAR) are STUBBED — they live in
+ *     dedicated modules under `derived/` and `effects/` that the next
+ *     phases will fill in.
+ *
+ * Out of scope (Phase 2+):
+ *   - Capacitor stability simulation (cap drain vs recharge curve)
+ *   - Weapon DPS calc (turret tracking + missile DRF)
+ *   - Drone DPS aggregation
+ *   - Damage-profile-aware EHP (requires a target damage distribution)
+ *   - Projected EWAR / fleet command bursts
+ *   - Mutaplasmid attribute application (handled at ItemState construction
+ *     via attributeOverrides, but the UI sliders aren't wired yet)
+ *
+ * The returned `derived` block is intentionally partial in this phase;
+ * downstream code MUST treat it as best-effort and not assume DPS/cap
+ * fields are populated until Phase 2/3.
+ */
+
+interface ComputeFitOptions {
+    /** Skill levels keyed by skill type id. Missing skills default to 0. */
+    skillProfile: SkillProfile;
+    /** Damage profile for EHP-vs-profile computation. Omitted → omni 25%. */
+    damageProfile?: DamageProfile | null;
+    /** Target profile for stats-vs-target (effective DPS at range,
+     *  application drop-off vs sig/speed). Stored on the engine output
+     *  for downstream consumers; the offense aggregator reads it
+     *  directly from there. */
+    targetProfile?: TargetProfile | null;
+    /** Hostile sources projecting onto this fit. Their effects apply with
+     *  `domain: 'targetID'` resolved to the fit's own ship. */
+    projected?: ProjectedSource[];
+    /** Skill levels assumed for the projected attacker. Defaults to All V
+     *  (matches how Pyfa renders projected effects "fed by All V skills"). */
+    projectedSkillLevels?: Map<number, number>;
+    /** Mutadaptive Remote Armor Repairer spool fraction (0..1). 1.0 =
+     *  fully spooled (max bonus); 0 = unspooled (no bonus). Defaults to 1
+     *  if omitted, matching Pyfa's "always-spooled" sustained engagement
+     *  assumption. */
+    spoolPercent?: number;
+    /** Triglavian Entropic Disintegrator spool fraction (0..1). Same
+     *  semantics as `spoolPercent` but applied to disintegrator weapons'
+     *  damageMultiplier (effect 6995, attrs 2733/2734). Defaults to 1
+     *  (full spool) for parity with Pyfa's default DPS column. */
+    disintegratorSpoolPercent?: number;
+    /** System effect beacon typeID (Incursion/Triglavian/Drifter/Wormhole).
+     *  When set, the engine reads the beacon's attrs from the dataset and
+     *  applies the corresponding system-wide debuff/buff. */
+    systemEffectTypeID?: number | null;
+}
+declare function computeFit(fit: Fit, dataset: FittingDataset, opts: ComputeFitOptions): ComputedFit;
+
+/**
+ * EFT (EVE Fitting Tool) text format parser.
+ *
+ * EFT is the de-facto community-standard text format for sharing ship fits.
+ * Pyfa, EFT, AFTER, in-game (after the export-to-clipboard feature), and
+ * almost every fit tool can read/write it.
+ *
+ * Canonical structure:
+ *
+ *     [ShipName, FitName]
+ *     <empty line>
+ *     <Low slot module>
+ *     <Low slot module>
+ *     <empty line>
+ *     <Mid slot module>
+ *     <Mid slot module>
+ *     <empty line>
+ *     <Hi slot module>, <charge name>     ← optional ", <charge>" pairing
+ *     <empty line>
+ *     <Rig module>
+ *     <empty line>                         ← optional Subsystem section (T3C only)
+ *     <Subsystem module>
+ *     <empty line>                         ← Drone bay
+ *     <Drone name> x<count>
+ *     <empty line>                         ← Implants/Boosters/Cargo (mixed)
+ *     <Item name> x<count>
+ *
+ * Real-world EFT exports omit empty sections entirely (no trailing blank
+ * lines), have inconsistent whitespace, occasionally include `[Empty Slot]`
+ * placeholders, and sometimes interleave drones/cargo without a separator.
+ * This parser is forgiving: it tolerates missing sections, extra blank
+ * lines, mixed casing, and resolves names case-insensitively against the
+ * dataset.
+ *
+ * Slot ordering convention (used by every modern tool):
+ *   1. Low slots
+ *   2. Mid slots
+ *   3. High slots
+ *   4. Rigs
+ *   5. Subsystems (T3C only)
+ *   6. Drones
+ *   7. Cargo / Implants / Boosters (mixed, identified by category)
+ *
+ * In-game export reverses this (high → low). We accept both and disambiguate
+ * by counting against the ship's slot attribute values when possible.
+ */
+
+interface EftParseResult {
+    fit: Fit;
+    /** Lines that couldn't be matched to anything in the SDE — surfaced to
+     *  the UI as warnings (typo? renamed item? unsupported entry?). */
+    warnings: Array<{
+        line: number;
+        text: string;
+        reason: string;
+    }>;
+}
+interface NameIndex {
+    /** Lower-cased name → typeID (latest-published wins on collision). */
+    map: Map<string, number>;
+    types: Map<number, SdeType>;
+}
+/**
+ * Build a fast name-lookup index from the dataset. Caller is expected to
+ * have loaded all type buckets that might appear in EFT input — typically
+ * ships + modules + charges + drones + implants + subsystems + skills (for
+ * implant detection — implants live in the implant bucket, but boosters
+ * may also be there depending on SDE version).
+ */
+declare function buildNameIndex(dataset: FittingDataset): NameIndex;
+/**
+ * Parse an EFT-format string into a Fit object. The returned `fit.id` is
+ * left undefined — the caller is responsible for assigning a uuid before
+ * persisting to the database.
+ *
+ * The parser is intentionally tolerant: missing sections, extra blank
+ * lines, charge with leading space, etc. Anything truly unparseable is
+ * collected in `warnings` instead of throwing.
+ */
+declare function parseEft(text: string, dataset: FittingDataset): EftParseResult;
+
+/**
+ * EFT (EVE Fitting Tool) text format writer.
+ *
+ * Output layout matches the in-game export format and what every modern
+ * fit tool produces:
+ *
+ *     [ShipName, FitName]
+ *     <empty line>
+ *     <Low slots>
+ *     <empty line>
+ *     <Mid slots>
+ *     <empty line>
+ *     <High slots, optional ", charge">
+ *     <empty line>
+ *     <Rigs>
+ *     <empty line>
+ *     <Subsystems>     (T3C only — section omitted otherwise)
+ *     <empty line>
+ *     <Drones x N>
+ *     <empty line>
+ *     <Implants / Boosters / Cargo x N>
+ *
+ * Empty sections are omitted entirely (no double blank lines). Implants and
+ * boosters are rendered alongside cargo with quantity suffix per the
+ * in-game export convention.
+ *
+ * Module ordering within a section follows the saved `position` field, then
+ * id as tiebreaker. Stable ordering matters because EFT consumers expect the
+ * same fit to round-trip identically.
+ */
+
+declare function formatEft(fit: Fit, dataset: FittingDataset): string;
+
+/**
+ * Multi-format fit exporters: DNA, Multibuy, plain typeID list. EFT
+ * already lives in [eft/format.ts](eft/format.ts).
+ *
+ *  - DNA: `shipID:moduleID;count::` — used by EVE's in-game chat links
+ *    and several third-party tools. Format ends with `::`.
+ *  - Multibuy: simple "name x count" list, suitable for pasting into
+ *    EVE's market multi-buy window or a contract. Includes ship + every
+ *    fitted item + cargo, deduplicated and aggregated.
+ *  - Type-id list: a flat newline-separated typeID list for tooling.
+ */
+
+/** EVE in-game DNA link format. */
+declare function formatDna(fit: Fit): string;
+/** "Name x count" list for multibuy / contracts. */
+declare function formatMultibuy(fit: Fit, dataset: FittingDataset): string;
+/** typeID-per-line list. */
+declare function formatTypeIds(fit: Fit): string;
+
+/**
+ * Well-known EVE Online dogma constants used by the fitting engine.
+ *
+ * These are stable IDs that have been carried since the SDE existed (2010+).
+ * Fenris Creations occasionally adds new attributes/effects but never reuses or renames
+ * existing ones. This file is the single source of truth — no other module
+ * should hardcode these numeric IDs.
+ *
+ * Sources:
+ *  - Pyfa's `eos/const.py` for the canonical list
+ *  - EVE Reference / EVE Online Static Data Export documentation
+ *  - Cross-referenced against our /server/data/SDE/dogma{Attributes,Effects}.jsonl
+ */
+
+declare const CATEGORY: {
+    readonly SHIP: 6;
+    readonly MODULE: 7;
+    readonly CHARGE: 8;
+    readonly SKILL: 16;
+    readonly DRONE: 18;
+    readonly IMPLANT: 20;
+    readonly SUBSYSTEM: 32;
+    readonly FIGHTER: 87;
+    readonly STRUCTURE_MODULE: 66;
+};
+declare const OPERATION_BY_SDE_CODE: Record<number, ModifierOperation>;
+declare const SLOT_EFFECT_ID: {
+    readonly LO_POWER: 11;
+    readonly HI_POWER: 12;
+    readonly MED_POWER: 13;
+    readonly RIG_SLOT: 2663;
+    readonly SUBSYSTEM: 3772;
+    readonly SERVICE_SLOT: 6306;
+};
+declare const SLOT_EFFECT_TO_SLOT_TYPE: Record<number, 'HI' | 'MED' | 'LO' | 'RIG' | 'SUBSYSTEM' | 'SERVICE'>;
+declare const ACTIVATION_EFFECT_ID: {
+    readonly ONLINE_FOR_STRUCTURES: 16;
+    readonly ONLINE: 16;
+    readonly LASER_TURRET: 10;
+    readonly PROJECTILE_TURRET: 34;
+    readonly HYBRID_TURRET: 35;
+    readonly MISSILE_LAUNCH: 87;
+    readonly MISSILE_LAUNCH_DUMB: 4947;
+    readonly DRONE_DAMAGE_AMP: 5379;
+    readonly SHIELD_BOOSTING: 4;
+    readonly SHIELD_BOOSTING_FUELED: 4936;
+    readonly ARMOR_REPAIR: 27;
+    readonly ARMOR_REPAIR_FUELED: 5275;
+    readonly HULL_REPAIR: 26;
+    readonly AB_THRUST: 6;
+    readonly MWD_THRUST: 8;
+    readonly SHIELD_TRANSFER: 18;
+    readonly ARMOR_TRANSFER: 592;
+    readonly REMOTE_CAP_TRANSFER: 31;
+    readonly NOSFERATU: 1;
+    readonly WEB_TARGETED: 14;
+    readonly WARP_SCRAMBLER: 19;
+    readonly SENSOR_DAMP: 1130;
+    readonly TRACKING_DISRUPTOR: 1799;
+    readonly ECM: 1786;
+    readonly ENERGY_NEUTRALIZE: 28;
+};
+type WeaponEffectKind = 'TURRET' | 'MISSILE' | 'SMARTBOMB' | 'DOOMSDAY';
+declare const WEAPON_EFFECT_KIND: Record<number, WeaponEffectKind>;
+declare const REPAIR_EFFECT_AMOUNT_ATTR: Record<number, {
+    amountAttr: number;
+    layer: 'SHIELD' | 'ARMOR' | 'HULL';
+}>;
+declare const ATTR: {
+    readonly MASS: 4;
+    readonly HP: 9;
+    readonly AGILITY: 70;
+    readonly VOLUME: 161;
+    readonly CAPACITY: 38;
+    readonly POWER_OUTPUT: 11;
+    readonly POWER_USED: 30;
+    readonly CPU_OUTPUT: 48;
+    readonly CPU_USED: 50;
+    readonly UPGRADE_CAPACITY: 1132;
+    readonly UPGRADE_COST: 1153;
+    readonly DRONE_BANDWIDTH: 1271;
+    readonly DRONE_CAPACITY: 283;
+    readonly HI_SLOTS: 14;
+    readonly MED_SLOTS: 13;
+    readonly LOW_SLOTS: 12;
+    readonly RIG_SLOTS: 1137;
+    readonly SUBSYSTEM_SLOTS: 1367;
+    readonly SERVICE_SLOTS: 2056;
+    readonly LAUNCHER_HARDPOINTS: 101;
+    readonly TURRET_HARDPOINTS: 102;
+    readonly RIG_SIZE: 1547;
+    /** Per-ship cap on how many modules of THIS ITEM'S group can be fitted.
+     *  e.g. Medium Breacher Pod Launcher carries `maxGroupFitted = 1`, so
+     *  only one of its group (`Breacher Pod Launcher`) is allowed per hull,
+     *  even if the ship has multiple launcher hardpoints. */
+    readonly MAX_GROUP_FITTED: 1544;
+    /** Per-ship cap on how many modules of THIS EXACT typeID can be fitted.
+     *  Sibling of MAX_GROUP_FITTED — used by a small set of unique-named
+     *  modules (Bastion Module, certain doomsday weapons). */
+    readonly MAX_TYPE_FITTED: 2487;
+    readonly CAPACITOR_CAPACITY: 482;
+    readonly CAPACITOR_RECHARGE_RATE: 55;
+    readonly SHIELD_CAPACITY: 263;
+    readonly SHIELD_RECHARGE_RATE: 479;
+    readonly SHIELD_EM_RES: 271;
+    readonly SHIELD_THERMAL_RES: 274;
+    readonly SHIELD_KINETIC_RES: 273;
+    readonly SHIELD_EXPLOSIVE_RES: 272;
+    readonly ARMOR_HP: 265;
+    readonly ARMOR_EM_RES: 267;
+    readonly ARMOR_THERMAL_RES: 270;
+    readonly ARMOR_KINETIC_RES: 269;
+    readonly ARMOR_EXPLOSIVE_RES: 268;
+    readonly STRUCTURE_EM_RES: 113;
+    readonly STRUCTURE_THERMAL_RES: 110;
+    readonly STRUCTURE_KINETIC_RES: 109;
+    readonly STRUCTURE_EXPLOSIVE_RES: 111;
+    readonly MAX_TARGET_RANGE: 76;
+    /** Theoretical maximum-targeting-range cap (`maximumRangeCap`). Default
+     *  300 km; raised by Sensor Array / Sensor Booster overload etc. via
+     *  PreAssign on attr 797. The SDE encodes this as `maxAttributeID=797`
+     *  on attr 76 — clamping is applied at the engine read site. */
+    readonly MAX_TARGET_RANGE_CAP: 797;
+    readonly MAX_LOCKED_TARGETS: 192;
+    readonly SIGNATURE_RADIUS: 552;
+    readonly SCAN_RESOLUTION: 564;
+    readonly SCAN_RADAR_STRENGTH: 208;
+    readonly SCAN_LADAR_STRENGTH: 209;
+    readonly SCAN_MAGNETOMETRIC_STRENGTH: 210;
+    readonly SCAN_GRAVIMETRIC_STRENGTH: 211;
+    readonly DRONE_CONTROL_RANGE: 458;
+    readonly MAX_VELOCITY: 37;
+    readonly WARP_SPEED_MULTIPLIER: 600;
+    readonly DAMAGE_MULTIPLIER: 64;
+    readonly EM_DAMAGE: 114;
+    readonly THERMAL_DAMAGE: 118;
+    readonly KINETIC_DAMAGE: 117;
+    readonly EXPLOSIVE_DAMAGE: 116;
+    readonly OPTIMAL_RANGE: 54;
+    readonly FALLOFF_RANGE: 158;
+    readonly TRACKING_SPEED: 160;
+    readonly RATE_OF_FIRE: 51;
+    readonly DAMAGE_DURATION: 73;
+    readonly MISSILE_DAMAGE_MULTIPLIER: 212;
+    readonly EXPLOSION_VELOCITY: 653;
+    readonly EXPLOSION_RADIUS: 654;
+    readonly DRF: 858;
+    readonly DOT_DURATION: 5735;
+    readonly DOT_MAX_DAMAGE_PER_TICK: 5736;
+    readonly DOT_MAX_HP_PERCENTAGE_PER_TICK: 5737;
+    readonly CHARGE_GROUP_1: 604;
+    readonly CHARGE_GROUP_2: 605;
+    readonly CHARGE_GROUP_3: 606;
+    readonly CHARGE_GROUP_4: 609;
+    readonly CHARGE_GROUP_5: 610;
+    readonly CHARGE_SIZE: 128;
+    readonly REQUIRED_SKILL_1: 182;
+    readonly REQUIRED_SKILL_2: 183;
+    readonly REQUIRED_SKILL_3: 184;
+    readonly REQUIRED_SKILL_4: 1285;
+    readonly REQUIRED_SKILL_5: 1289;
+    readonly REQUIRED_SKILL_6: 1290;
+    readonly REQUIRED_SKILL_1_LEVEL: 277;
+    readonly REQUIRED_SKILL_2_LEVEL: 278;
+    readonly REQUIRED_SKILL_3_LEVEL: 279;
+    readonly REQUIRED_SKILL_4_LEVEL: 1286;
+    readonly REQUIRED_SKILL_5_LEVEL: 1287;
+    readonly REQUIRED_SKILL_6_LEVEL: 1288;
+    readonly MAX_ACTIVE_DRONES: 352;
+    readonly MAX_VELOCITY_LIMIT: 192;
+    readonly MAX_RANGE_LIMIT: 192;
+    readonly CAN_FIT_SHIP_GROUP_1: 1298;
+    readonly CAN_FIT_SHIP_GROUP_2: 1299;
+    readonly CAN_FIT_SHIP_GROUP_3: 1300;
+    readonly CAN_FIT_SHIP_GROUP_4: 1301;
+    readonly CAN_FIT_SHIP_GROUP_5: 1872;
+    readonly CAN_FIT_SHIP_GROUP_6: 1879;
+    readonly CAN_FIT_SHIP_GROUP_7: 1880;
+    readonly CAN_FIT_SHIP_GROUP_8: 1881;
+    readonly CAN_FIT_SHIP_GROUP_9: 2065;
+    readonly CAN_FIT_SHIP_TYPE_1: 1302;
+    readonly CAN_FIT_SHIP_TYPE_2: 1303;
+    readonly CAN_FIT_SHIP_TYPE_3: 1304;
+    readonly CAN_FIT_SHIP_TYPE_4: 1305;
+};
+/** Pairs of (skill_attr_id, level_attr_id). Used by skill-requirement derivation. */
+declare const REQUIRED_SKILL_PAIRS: ReadonlyArray<readonly [number, number]>;
+declare const STACKING_PENALTY_K = 7.1289;
+interface LegacyEffectEntry {
+    /** SDE effect ID. */
+    id: number;
+    /** Expected SDE `effectName`, or null if the bundle doesn't export one
+     *  for this ID (the engine still relies on the numeric ID). */
+    name: string | null;
+    /** Free-form descriptor: which engine handler / table claims this ID. */
+    handler: string;
+}
+declare const LEGACY_EFFECT_IDS: ReadonlyArray<LegacyEffectEntry>;
+declare const OUT_OF_SCOPE_EFFECT_IDS: ReadonlyArray<LegacyEffectEntry>;
+/** Verify every effect ID in LEGACY_EFFECT_IDS is still present in the
+ *  loaded dataset. Returns an array of complaints (empty when clean) so
+ *  callers can surface the result via console.warn / throw / log telemetry.
+ *
+ *  Two failure modes detected:
+ *    - "missing": SDE no longer carries this effect ID — the handler will
+ *      silently no-op (Fenris Creations either renamed or deleted). Investigate.
+ *    - "name-mismatch": SDE still carries the ID but with a different name
+ *      than registered. Probably a Fenris Creations rename — the engine still works,
+ *      but the registry comment / handler description is stale.
+ *
+ *  Run at engine boot in dev mode (gate via `import.meta.dev`). Production
+ *  callers can opt in by passing the dataset to `verifyLegacyEffectIds()`. */
+declare function verifyLegacyEffectIds(effects: ReadonlyMap<number, {
+    effectName?: string;
+}>): Array<{
+    id: number;
+    kind: 'missing' | 'name-mismatch';
+    expected: string | null;
+    actual: string | null;
+}>;
+
+/**
+ * Per-attribute modification pipeline.
+ *
+ * One instance per (item × attributeID) holds:
+ *  - the base value (from the SDE typeDogma row, possibly preassigned)
+ *  - a flat list of "afflictions" — every modifier that's been applied
+ *    during the calc pass (skills, ship bonuses, modules, fleet, etc.)
+ *
+ * `compute()` runs the EVE-canonical pipeline:
+ *
+ *     base ─► PreAssign override ─► PreMul/PreDiv (stack-penalized)
+ *           ─► ModAdd/ModSub (additive)
+ *           ─► PostMul/PostDiv/PostPercent (stack-penalized)
+ *           ─► PostAssign override ─► (optional cap) ─► final
+ *
+ * `PostPercent` is treated identically to `PostMul(1 + value)` — see
+ * https://wiki.eveuniversity.org/EVE_dogma_engine
+ *
+ * The afflictions list is preserved on the result so the UI can drill into
+ * which sources contributed to a final value (Pyfa-style breakdown).
+ */
+
+declare class ModifiedAttribute {
+    readonly attributeID: number;
+    readonly base: number;
+    readonly afflictions: ModifierAffliction[];
+    private _cache;
+    constructor(attributeID: number, base: number);
+    addAffliction(a: ModifierAffliction): void;
+    /**
+     * Reset all applied modifiers, keeping the base value. Used when the
+     * engine re-runs (e.g. user toggles a module state).
+     */
+    reset(): void;
+    /**
+     * Compute the final value. Result is cached until `addAffliction()` or
+     * `reset()` is called.
+     *
+     * @param maxAttribute optional cap — if provided, final value is clamped
+     *                     to MIN(computed, maxAttribute). Used for attributes
+     *                     with a maxAttributeID reference.
+     */
+    compute(maxAttribute?: number): number;
+    /**
+     * Compute and bundle into a ComputedAttribute (for UI consumption /
+     * breakdown rendering). The afflictions array is shared by reference;
+     * callers should not mutate it.
+     */
+    snapshot(maxAttribute?: number): {
+        id: number;
+        base: number;
+        final: number;
+        afflictions: ModifierAffliction[];
+    };
+}
+
+/**
+ * Runtime state of a single fittable item — ship, module, drone, fighter,
+ * implant, booster, charge, subsystem, mode, character.
+ *
+ * Each item carries its own ModifiedAttribute map keyed by attributeID.
+ * Base values come from the SDE typeDogma row; modifiers are added during
+ * the calc pass via the modifier engine, then `compute()` is called once
+ * the pass is complete.
+ *
+ * Module state matters: only modules that pass `appliesAtState()` contribute
+ * effects to the fit (offline modules don't add CPU usage either). Charges
+ * project their attributes into the parent module's `otherID` domain.
+ */
+
+type ItemKind = 'ship' | 'module' | 'drone' | 'fighter' | 'implant' | 'booster' | 'charge' | 'subsystem' | 'mode' | 'character';
+interface ItemStateInit {
+    kind: ItemKind;
+    /** Stable identifier within the fit (uuid for fit_modules etc.; sentinel
+     *  strings like "ship", "char" for the singletons). */
+    id: string;
+    type: SdeType;
+    /** Module/drone-style runtime state. Defaults to ONLINE for items where
+     *  state semantics don't apply (ship, char). */
+    state?: ModuleState;
+    /** Charge loaded into a module (only meaningful for kind === 'module'). */
+    charge?: ItemState;
+    /** Per-instance attribute overrides (mutaplasmid). */
+    attributeOverrides?: Record<number, number>;
+}
+declare class ItemState {
+    readonly kind: ItemKind;
+    readonly id: string;
+    readonly type: SdeType;
+    readonly typeID: number;
+    readonly groupID: number;
+    readonly categoryID: number;
+    state: ModuleState;
+    charge: ItemState | null;
+    /** Effect IDs the item carries, populated lazily on first access. */
+    readonly effectIDs: ReadonlySet<number>;
+    readonly attrs: Map<number, ModifiedAttribute>;
+    constructor(init: ItemStateInit);
+    /**
+     * Get-or-create the ModifiedAttribute for this id. Returning a fresh
+     * default-valued instance lets modifiers target attributes that aren't
+     * in the type's typeDogma row yet — e.g. a skill that adds CPU output
+     * to a ship that has no base CPU output (rare but valid in EVE).
+     */
+    attr(id: number, defaultBase?: number): ModifiedAttribute;
+    /** Read-only base value; `undefined` if the type doesn't carry the attr. */
+    getBase(id: number): number | undefined;
+    /** Whether this item's typeDogma actually carries the attribute. Use to
+     *  distinguish "missing attr" from "attr present but final value is 0",
+     *  since `getFinal` returns 0 for both. */
+    hasAttr(id: number): boolean;
+    /** Compute the current modified value (cached until next addAffliction). */
+    getFinal(id: number, fallback?: number): number;
+    /** `defaultBase` is the seed base value when the target attribute isn't
+     *  in the item's typeDogma — needed for SDE attrs whose `defaultValue`
+     *  is non-zero (e.g. `missileDamageMultiplier` defaults to 1; without
+     *  this, a BCS PreMul affliction would compute 1.1 × 0 = 0 → zero
+     *  missile DPS on charges that don't carry attr_212 explicitly). */
+    addAffliction(attributeID: number, a: ModifierAffliction, defaultBase?: number): void;
+    /** Reset every attribute on this item — used for incremental recompute. */
+    resetAttributes(): void;
+    /** Snapshot all attributes — for UI rendering or debug breakdown. */
+    snapshotAll(): Map<number, ReturnType<ModifiedAttribute['snapshot']>>;
+    /** Iterator over (attributeID, ModifiedAttribute) — for the engine. */
+    attributesEntries(): IterableIterator<readonly [number, ModifiedAttribute]>;
+    /** Whether this item's effects are active at the current state. */
+    appliesAtState(effect: SdeEffect): boolean;
+    /**
+     * Determine the slot type of a module by inspecting its effects.
+     * Returns null for non-module items (no slot-classifying effect).
+     */
+    slotType(): SlotType | null;
+    /**
+     * Required skills for using this item, derived from typeDogma's reserved
+     * attribute IDs (REQUIRED_SKILL_N → skillTypeID, REQUIRED_SKILL_N_LEVEL
+     * → minimum level). Used by the skill validator + by skill-source
+     * modifier filtering.
+     */
+    requiredSkills(): Array<{
+        skillID: number;
+        level: number;
+    }>;
+}
+
+/**
+ * FitContext aggregates every ItemState participating in a single fit
+ * computation: the ship, the module list, drones, fighters, implants,
+ * boosters, subsystems, the mode (T3D/T3C), the character (skill source),
+ * and an optional projected target for ranged DPS / EWAR projection.
+ *
+ * It also implements the `domain` resolution required by EVE's modifierInfo
+ * model:
+ *   - 'self'        → the source item itself
+ *   - 'shipID'      → the ship hull
+ *   - 'char'        → the character (where skills live)
+ *   - 'otherID'     → the paired item (charge ↔ module)
+ *   - 'targetID'    → the projected target (for hostile EWAR)
+ *   - 'structureID' → citadel structures (rarely used for fits)
+ *
+ * `LocationGroupModifier` and `LocationRequiredSkillModifier` further filter
+ * within the resolved location — see `targetsForModifier()`.
+ */
+
+interface FitContextInit {
+    ship: ItemState;
+    character: ItemState;
+    /** Skill levels keyed by skill type id. Missing entries default to 0. */
+    skillLevels: ReadonlyMap<number, number>;
+    modules: ItemState[];
+    drones: ItemState[];
+    fighters: ItemState[];
+    implants: ItemState[];
+    boosters: ItemState[];
+    subsystems: ItemState[];
+    mode?: ItemState;
+    /** Optional projected target. NULL when no target is selected. */
+    target?: ItemState | null;
+    /** Optional citadel/structure context for structure modifierInfo. */
+    structure?: ItemState | null;
+    skillProfile: SkillProfile;
+    /** Dataset reference — needed for transitive skill prerequisite walks
+     *  (`itemRequiresSkillTransitive`). The skills bucket on the dataset is
+     *  the only place skill type definitions live. */
+    dataset: FittingDataset;
+    /** Triglavian disintegrator spool fraction (0..1). Stored on the
+     *  context so derived/offense.ts can compute the spool=0 baseline DPS
+     *  for the UI (Min/Max labels) without re-running the engine. Without
+     *  this, the slider drag produces a brief race where the spool % has
+     *  updated but the engine's output hasn't, and the derived Min/Max
+     *  drift visibly until the debounced recompute settles. */
+    disintegratorSpoolPercent: number;
+}
+declare class FitContext {
+    readonly ship: ItemState;
+    readonly character: ItemState;
+    readonly skillLevels: ReadonlyMap<number, number>;
+    readonly modules: ItemState[];
+    readonly drones: ItemState[];
+    readonly fighters: ItemState[];
+    readonly implants: ItemState[];
+    readonly boosters: ItemState[];
+    readonly subsystems: ItemState[];
+    readonly mode: ItemState | null;
+    /** Mutable so projection passes can temporarily redirect `targetID`
+     *  domain resolution (e.g. when applying hostile EWAR onto your own
+     *  fit, target is swapped to ctx.ship). The engine restores it after. */
+    target: ItemState | null;
+    readonly structure: ItemState | null;
+    readonly skillProfile: SkillProfile;
+    readonly dataset: FittingDataset;
+    readonly disintegratorSpoolPercent: number;
+    /** Projected hostile sources currently in scope. Populated by the
+     *  engine when ProjectedSource[] is passed in ComputeFitOptions. */
+    projectedSources: ItemState[];
+    /** Effect IDs the dispatcher must skip when applying LOCAL modules
+     *  (modules fitted to ctx.ship). Populated by `collectEffectStoppers()`
+     *  during the projection pre-pass: each `func: EffectStopper`
+     *  modifierInfo on a projected source contributes its `effectID` here.
+     *
+     *  Pyfa-parity: warp scrambler / disruptor effects (5928, 5934, 6745,
+     *  …) suppress effects 6441 (MWD) and 6442 (MJD) on the target — the
+     *  scrambled ship can't activate its prop module. The engine reads
+     *  this set inside `applySourceItem` and skips matching effects on
+     *  ship-mounted modules. Empty by default = no projected scram. */
+    stoppedLocalEffectIDs: Set<number>;
+    constructor(init: FitContextInit);
+    /** All items that can carry effects + receive modifications. */
+    allItems(): IterableIterator<ItemState>;
+    /** Skill level lookup with default 0 for untrained skills. */
+    skillLevel(skillTypeID: number): number;
+    /**
+     * Resolve the `domain` string of a modifier into the corresponding root
+     * ItemState. The `source` is the item carrying the effect (e.g. the
+     * module whose effect we're applying); `self` resolves to it directly.
+     */
+    resolveDomain(domain: SdeModifierInfo['domain'], source: ItemState): ItemState | null;
+    /** Find which module currently has the given charge loaded. */
+    findChargeParent(charge: ItemState): ItemState | null;
+    /**
+     * Resolve the target list for a modifier — combination of `func` +
+     * `domain` + (optional) `groupID` / `skillTypeID` filter.
+     *
+     * - ItemModifier: applies to the single domain item.
+     * - LocationModifier: applies to the location root (typically the ship)
+     *   AND to every item physically located in that location (modules,
+     *   drones, etc.) — interpretation depends on context, but most
+     *   modifierInfo entries we encounter use it for the root only.
+     *   Conservative: target the location root only. The few effects that
+     *   actually want "every item in the location" are usually duplicated
+     *   as LocationGroupModifier with no group filter — handled there.
+     * - LocationGroupModifier: every item in the location whose groupID
+     *   matches modifier.groupID.
+     * - LocationRequiredSkillModifier: every item in the location that
+     *   requires the skill modifier.skillTypeID.
+     * - OwnerRequiredSkillModifier: every item owned by the character that
+     *   requires the skill — i.e. modules + drones + fighters across the
+     *   fit. Used by skill bonuses that should apply regardless of where
+     *   the item is mounted.
+     * - EffectStopper: handled outside this resolver (stops other effects
+     *   rather than applying a modifier).
+     */
+    targetsForModifier(modifier: SdeModifierInfo, source: ItemState): ItemState[];
+    /**
+     * Items that count as "located in" a given root. The exact set depends
+     * on the root kind:
+     *   - Ship: the ship itself + every module + active drone/fighter +
+     *     subsystems + mode + charges
+     *   - Character: every char-attached item (the character itself,
+     *     implants, boosters)
+     *   - Anything else: just the root (no spreading)
+     *
+     * This mirrors Pyfa's location semantics.
+     */
+    private itemsInLocation;
+}
+/** Charge-loadability check: charge.groupID must match one of the module's
+ *  charge group attributes. Used by the editor to validate charge swaps. */
+declare function moduleAcceptsCharge(module: ItemState, charge: ItemState): boolean;
+
+/**
+ * Generic modifierInfo dispatcher.
+ *
+ * For every dogma effect that has a populated `modifierInfo` array (~93% of
+ * the SDE), this engine reads each entry, computes the final modifier value,
+ * resolves the target list via the FitContext domain rules, and pushes an
+ * Affliction onto each target's ModifiedAttribute pipeline.
+ *
+ * The remaining ~7% of effects (capacitor sim, weapon DPS, missile DRF,
+ * EWAR projection probability, etc.) bypass this engine and run through
+ * dedicated handlers in `effects/`. Those handlers are dispatched from the
+ * top-level `engine.ts` orchestrator, NOT from here.
+ *
+ * Skill scaling: modifiers tagged `*RequiredSkillModifier` multiply the
+ * source value by the character's skill level (0..5). The bonus value
+ * stored on the source item is the per-level value (e.g. 5%/level →
+ * the modifyingAttributeID points to an attribute whose value is 0.05).
+ *
+ * Stacking penalty key: defaults to `${attributeID}` so multiple modules
+ * affecting the same attribute share a penalty stack. Skill / ship / mode /
+ * subsystem sources bypass the penalty (`stackingGroup === null`) — these
+ * are intrinsic bonuses that EVE does not penalize. The `stackable` flag
+ * on the dogma attribute also bypasses (some attributes are explicitly
+ * additive without penalty).
+ */
+
+/**
+ * Apply every modifier of every effect on a single source item. Effects are
+ * filtered by the item's current state (only effects active at the current
+ * state contribute). EffectStopper modifiers are NOT applied here — see
+ * `collectEffectStoppers()` for that.
+ */
+declare function applySourceItem(source: ItemState, ctx: FitContext, dataset: FittingDataset): void;
+/**
+ * Apply a single modifier descriptor. Pulled out for testability and so the
+ * top-level engine can call it directly when applying skill effects through
+ * the character item (which exposes effects through its skill book typeIDs).
+ */
+declare function applyOneModifier(source: ItemState, effect: SdeEffect, mi: SdeModifierInfo, ctx: FitContext, dataset: FittingDataset): void;
+/**
+ * Apply skill bonuses by walking the character's skill set and, for each
+ * skill type, dispatching its passive effects through the modifier engine.
+ *
+ * EVE encodes "skill X gives bonus Y per level" as a passive effect on the
+ * SKILL TYPE itself, with a LocationRequiredSkillModifier modifier whose
+ * `skillTypeID` matches the skill in question. The character item carries a
+ * synthetic effect set that delegates to the loaded skill types.
+ *
+ * This function does NOT mutate the character's effect list — it walks the
+ * skill profile externally and applies skill effects directly on behalf of
+ * the character source. Preserves correct attribution (sourceKind = 'skill').
+ */
+declare function applySkills(ctx: FitContext, dataset: FittingDataset): void;
+/** Compute current spool damage bonus (fractional, e.g. 1.5 means +150 %).
+ *  Caller-side helper for UI breakdowns; engine-side application uses the
+ *  same math via `applyLegacyDisintegratorSpool`. */
+declare function disintegratorSpoolBonus(maxBonus: number, spoolPercent: number): number;
+/** Cycles needed to reach full spool — ceil(max / perCycle). Returns 0 when
+ *  the weapon has no spool-up (e.g. attrs missing). */
+declare function disintegratorCyclesToFullSpool(maxBonus: number, bonusPerCycle: number): number;
+declare const LEGACY_HANDLED_EFFECT_IDS: ReadonlySet<number>;
+
+/**
+ * Stacking penalty math.
+ *
+ * Per EVE rules: when multiple multiplicative modifiers stack on the same
+ * attribute (and the attribute is NOT marked stackable in the SDE), the most
+ * impactful modifier applies at full strength while subsequent ones are
+ * exponentially attenuated:
+ *
+ *     effective_multiplier_i = 1 + (raw_i − 1) × exp(−i² / k)
+ *
+ * where i is the 0-indexed position after sorting by absolute deviation from
+ * 1 (descending) and k = 7.1289.
+ *
+ * Bonuses (raw > 1) and penalties (raw < 1) are penalized as TWO INDEPENDENT
+ * sequences — i.e. the strongest bonus is at full strength even if a stronger
+ * penalty exists in the same group, and vice versa. This mirrors Pyfa's
+ * `eos/calc.py::calculateMultiplier`.
+ *
+ * Skill bonuses, ship hull bonuses, and modules with the `stackable` flag
+ * bypass this penalty entirely — they multiply at face value. The caller
+ * decides whether to penalize via the `stackingGroup` field on the Affliction
+ * (null = no penalty).
+ */
+interface StackableValue {
+    /** Raw multiplier (1.05 = +5% bonus, 0.9 = -10% penalty). */
+    value: number;
+}
+/**
+ * Reduce a list of multipliers from the same stacking group into a single
+ * combined factor. Returns 1 for an empty list.
+ */
+declare function combinePenalized(values: readonly StackableValue[]): number;
+/**
+ * Combine UNSTACKED multiplicative modifiers — straight product, no penalty.
+ */
+declare function combineUnstacked(values: readonly StackableValue[]): number;
+/**
+ * Group a flat list of {value, stackingGroup} entries by their stacking
+ * group key, then combine each group via the appropriate path.
+ *
+ * stackingGroup === null means "no penalty for this entry, multiply directly".
+ * Other keys denote a penalty group (typically the attribute id, or
+ * source-type:attribute).
+ */
+declare function combineMultiplicative(entries: readonly {
+    value: number;
+    stackingGroup: string | null;
+}[]): number;
+
+/**
+ * Effective HitPoints (EHP) calculation.
+ *
+ * EVE damage application per layer:
+ *   damage_taken = damage_dealt × (1 - resistance)
+ *
+ * For incoming damage with a known type distribution (DamageProfile):
+ *   absorbed_per_layer = sum over types: weight × HP / (1 - resistance_type)
+ *
+ * Equivalent and easier to compute:
+ *   effective_resistance = sum(weight × resistance_type)
+ *   ehp_layer = HP / (1 - effective_resistance)
+ *
+ * `ehpUniform` uses a uniform 25% per type (used as a default badge in the UI).
+ * `ehpAgainstProfile` uses the user-supplied DamageProfile weights.
+ *
+ * Important: the SDE stores resistances as RESONANCE values (0..1) where
+ * 0 = full resist and 1 = no resist. The fitting engine consumes those raw,
+ * but the UI prefers the inverted "resist %" form. Conversion happens here:
+ *   resist_percent = 1 - resonance
+ */
+
+type DefenseLayerKind = 'SHIELD' | 'ARMOR' | 'HULL';
+interface LayerEhp {
+    hp: number;
+    /** EHP under uniform 25%/type damage. Pyfa's "Uniform" reference. */
+    ehpUniform: number;
+    /** EHP under the supplied profile (or uniform when no profile is given). */
+    ehpAgainstProfile: number;
+    /** Resist percentages (0..1) for the UI. 1 - resonance. */
+    resistances: {
+        em: number;
+        thermal: number;
+        kinetic: number;
+        explosive: number;
+    };
+}
+/**
+ * Compute EHP for a single defense layer. Caller passes the ship state and
+ * a DamageProfile; both omni-EHP and profile-EHP are returned together so
+ * the UI can render a comparison.
+ */
+declare function computeLayerEhp(ship: ItemState, layer: DefenseLayerKind, profile?: DamageProfile | null): LayerEhp;
+/**
+ * Pure math: HP under a damage profile. Resonances passed verbatim from the
+ * SDE (0 = full resist, 1 = no resist).
+ *
+ * Returns Infinity if the layer is mathematically immune (resonance=0
+ * across all types with non-zero weight). The caller should clamp to a
+ * sensible display value.
+ */
+declare function ehpUnderProfile(hp: number, resonanceEm: number, resonanceThermal: number, resonanceKinetic: number, resonanceExplosive: number, profile: DamageProfile): number;
+/**
+ * Combined EHP across all three layers. The "total" EHP a ship can absorb
+ * before going pop is the sum of shield + armor + hull EHP under the same
+ * damage profile (they're consumed sequentially in EVE).
+ */
+declare function computeTotalEhp(shield: LayerEhp, armor: LayerEhp, hull: LayerEhp, useProfile: boolean): number;
+
+/**
+ * Capacitor simulation.
+ *
+ * EVE's capacitor follows a non-linear S-shaped recharge curve. Per the
+ * canonical formula (Pyfa / EVE-Wiki):
+ *
+ *     dC/dt = (10 × C_max / τ) × (√x − x)         where x = C / C_max
+ *
+ * τ is the `capacitorRechargeRate` attribute IN MILLISECONDS. The factor
+ * stems from Newton-fit empirical data: peak recharge rate occurs at
+ * x = 0.25 (i.e. cap at 25% capacity) and equals 2.5 × C_max / τ_seconds.
+ *
+ * Stability check: a fit is "cap stable" if at some level x ∈ (0, 1) the
+ * recharge rate equals the steady-state usage rate. Solving for that level:
+ *
+ *     usage = (10 × C_max / τ) × (√x − x)
+ *     ⇒ √x − x = u  where u = usage × τ / (10 × C_max)
+ *
+ * The function (√x − x) is concave on [0, 1] with maximum 0.25 at x=0.25,
+ * so a solution exists ⇔ u ≤ 0.25, i.e. usage ≤ 2.5 × C_max / τ. The
+ * smaller of the two roots is the *unstable* equilibrium (cap drops to it
+ * if it dips below 25%); the larger root is the stable equilibrium and is
+ * what the UI calls "cap stable at X%".
+ *
+ * If the fit is NOT stable, we report seconds-to-empty: integration of
+ * dC/dt from 100% down to 0% under the assumption that drain rate is
+ * constant at `usage` (a slight under-estimate; the true integral is
+ * shorter because the recharge contribution decreases as cap drops).
+ *
+ * Module drain: each module's effect with a `dischargeAttributeID` reads
+ * its drain per cycle from that attribute, and its cycle duration from
+ * `durationAttributeID`. Drain per second = discharge / (duration / 1000).
+ * Only modules in ACTIVE / OVERLOAD state contribute (offline + online +
+ * passive don't drain).
+ *
+ * --- Cap booster handling: discrete-event simulation (Pyfa parity) ---
+ *
+ * The naïve closed-form approach amortises booster injection across the
+ * (charges × cycle + reload) window and treats it as a constant negative
+ * drain. That's wrong by 5-15 % for fits with a heavy cap booster + high
+ * net injection: in reality, booster activations that would push cap above
+ * 100 % are POSTPONED (`awaitingInjectors` queue in Pyfa's `capSim.py`).
+ * The deferred injection is applied later when cap dips low enough to
+ * absorb it without overshoot.
+ *
+ * The closed-form ignores this overshoot loss and reports a higher cap
+ * stable % than reality. Apoc Navy + Heavy F-RX shows 93 % closed-form vs
+ * 79.9 % Pyfa — 13 pp gap.
+ *
+ * Fix: when any active module has a cap booster effect (effectID 48), run
+ * a discrete-event simulator that mirrors Pyfa's `CapSimulator`:
+ *   - Min-heap of (t_now, duration, capNeed, shot, clipSize, reloadTime,
+ *     isInjector) tuples (negative capNeed for boosters = injection).
+ *   - At each event, regenerate cap analytically since the previous event,
+ *     postpone overshoot injectors, drain/inject, advance.
+ *   - Stop when (cap_now ≥ cap_at_period_start AND awaiting injectors
+ *     match) — the system is stable. Or when cap < 0 (unstable).
+ *
+ * UI metric matches Pyfa: `capState = (cap_low + cap_low_pre) / (2·C_max)`
+ * — average of the post-drain low watermark and the pre-drain low
+ * watermark. Cycle-average operating cap level, which is what writers
+ * actually care about (the closed-form equilibrium is where rate goes to
+ * zero, NOT the average level under a periodic drain schedule).
+ *
+ * Trap encountered & avoided. The OLD per-load amortisation
+ *     rate = N × (capNeed - inject) / (N × cycle + reload)
+ * is mathematically correct as the *long-run mean injection rate* but the
+ * cap-stable solver assumes that mean is delivered every instant — which
+ * over-credits the booster because postponed injections lose effective
+ * value (they get clipped at 100 % cap).
+ */
+
+interface CapacitorReport {
+    /** Max capacitor capacity (GJ). */
+    capacity: number;
+    /** Recharge time τ in milliseconds (raw SDE value). */
+    rechargeMs: number;
+    /** Peak recharge rate, GJ/s, achieved at 25% capacity. */
+    peakRechargeRate: number;
+    /** Total active drain across all online/active modules, GJ/s. Reported
+     *  as the *gross* drain (before accounting for cap booster injection)
+     *  when the fit has injectors. */
+    usagePerSecond: number;
+    /** True iff a stable equilibrium exists. */
+    stable: boolean;
+    /** Equilibrium cap level (0..1) when stable. Always ≥ 0.25 in the
+     *  closed-form path; in the simulator path this is Pyfa's
+     *  (cap_low + cap_low_pre) / (2·capacity). */
+    stablePercent: number;
+    /** Time until cap reaches 0 from full, in seconds. Only meaningful when
+     *  not stable; undefined when stable. */
+    secondsToEmpty?: number;
+}
+declare function computeCapacitor(ctx: FitContext, dataset: FittingDataset): CapacitorReport;
+/**
+ * Peak passive recharge rate at 25% capacity. Used for both the capacitor
+ * and (with shield_capacity / shield_recharge_rate as inputs) the passive
+ * shield regen.
+ *
+ *   rate(x) = (10 × C / τ) × (√x − x)
+ *   peak occurs at x = 0.25 → rate_max = 2.5 × C / τ_seconds
+ */
+declare function peakRecharge(capacity: number, rechargeMs: number): number;
+/**
+ * Recharge rate at an arbitrary cap level (0..1). Useful for time-domain
+ * simulations / charts.
+ */
+declare function rechargeRateAt(capacity: number, rechargeMs: number, fillFraction: number): number;
+
+/**
+ * Tank rate aggregation.
+ *
+ * For each defense layer (shield / armor / hull) we report:
+ *   - Single-cycle repair amount (sum of all repair modules' per-cycle output)
+ *   - Single-cycle duration (the longest cycle among the modules contributing
+ *     — for now we use the average of cycles which is a fair shorthand when
+ *     they're roughly synchronized; refining to a proper time-weighted
+ *     simulation is Phase 5+ territory)
+ *   - Sustained repair-per-second (sum of amount/cycle across all reppers)
+ *
+ * Plus shield-specific:
+ *   - Passive peak shield regen (2.5 × shield_capacity / shield_recharge_seconds)
+ *
+ * Repair handlers are recognised by effect id via REPAIR_EFFECT_AMOUNT_ATTR
+ * — that map is the (small) hand-coded table this engine maintains.
+ * Modules in OFFLINE / ONLINE state don't contribute (you have to actually
+ * be cycling the rep to gain HP back), only ACTIVE / OVERLOAD.
+ *
+ * Ancillary shield/armor reps are treated as plain reps in this iteration:
+ * their FUELED variant doubles output when loaded with a charge, but the
+ * doubling is conditional on cap drain semantics (no cap = doubled rate).
+ * Modelling that requires the cap simulator output and proper charge
+ * tracking — Phase 5 task. For now, ancillary reps report their unfueled
+ * baseline.
+ */
+
+interface TankRates {
+    shieldRepairAmount: number;
+    shieldRepairDuration: number;
+    shieldRepairPerSecond: number;
+    /** Sustained shield rep/sec amortised across reload windows for fueled
+     *  reppers (paste-loaded AAR or cap-charge-loaded ASB). Equals
+     *  `shieldRepairPerSecond` when no fuel-bound repper is contributing. */
+    shieldRepairPerSecondSustained: number;
+    armorRepairAmount: number;
+    armorRepairDuration: number;
+    armorRepairPerSecond: number;
+    armorRepairPerSecondSustained: number;
+    hullRepairAmount: number;
+    hullRepairDuration: number;
+    hullRepairPerSecond: number;
+    hullRepairPerSecondSustained: number;
+    /** Peak passive shield regen (GJ/s ≡ HP/s for shields). */
+    passiveShieldRegenPeak: number;
+}
+declare function computeTank(ctx: FitContext): TankRates;
+
+/**
+ * Offense aggregation — turret + missile + smart-bomb + drone DPS.
+ *
+ * For each fitted module + active drone we:
+ *   1. Classify it as a weapon (effects/weapon.ts)
+ *   2. Read damage components from the right source (charge for turrets +
+ *      missiles, item itself for smart bombs + drones)
+ *   3. Compute raw DPS = (sum_damage × damageMultiplier) / cycle_seconds
+ *   4. Compute reload-aware sustained DPS by amortising the per-load
+ *      damage volley over (cycles_in_load + reload_seconds). When no
+ *      charge or reload time, sustained equals peak.
+ *
+ * Reload model:
+ *   - Modules with effect 10/34/67/101/6995 (Pyfa-parity legacy reload
+ *     effects) get a 1000 ms default reload when no `reloadTime` attribute.
+ *   - Charges-per-load = floor(launcher.capacity / charge.volume) for
+ *     weapons; for cap boosters Pyfa uses the same formula.
+ *   - Time-per-load = chargesPerLoad × cycleSeconds + reloadSeconds.
+ *   - Sustained DPS = (chargesPerLoad × alpha) / timePerLoad.
+ *
+ * What's intentionally still simplified:
+ *   - No tracking application: turret tracking against target velocity /
+ *     sig would multiply DPS by hit-quality < 1. We expose tracking +
+ *     range attributes so the UI can show them, but DPS reported is the
+ *     optimal-range no-tracking-loss baseline.
+ *   - No DRF application for missiles: same reasoning.
+ *   - Drone control range / EWAR projection / fighter ability cooldowns:
+ *     all stubbed.
+ *   - Resists vs damage profile: not applied here; the offense view shows
+ *     RAW damage components, the defense view shows EHP-vs-profile.
+ */
+
+interface OffenseReport {
+    weaponDps: number;
+    /** Reload-amortised weapon DPS — for short-magazine weapons (lasers,
+     *  cap boosters) this is meaningfully lower than `weaponDps`. */
+    weaponSustainedDps: number;
+    droneDps: number;
+    fighterDps: number;
+    totalDps: number;
+    totalSustainedDps: number;
+    /** Single-volley alpha across all weapons (no synchronization assumed —
+     *  this is "if every gun fired right now, total damage applied"). */
+    alphaStrike: number;
+    /** Effective optimal range — minimum of any weapon's optimal that
+     *  contributes meaningful DPS. UI calls it "max engagement range". */
+    weaponOptimal: number;
+    weaponFalloff: number;
+    weaponTracking?: number;
+    explosionVelocity?: number;
+    explosionRadius?: number;
+    breakdown: WeaponContribution[];
+}
+declare function computeOffense(ctx: FitContext, dataset: FittingDataset, fit: {
+    drones: Array<{
+        id: string;
+        typeID: number;
+        countTotal: number;
+        countActive: number;
+    }>;
+    fighters?: Array<{
+        id: string;
+        typeID: number;
+        count: number;
+        abilityState?: Record<number, boolean>;
+    }>;
+}): OffenseReport;
+
+/**
+ * Upwell-structure metadata: service slots + fuel-block consumption.
+ *
+ * Computed only when the host typeID resolves to a category=65 type
+ * (Astrahus / Raitaru / Fortizar / etc.). Ship fits skip this entirely
+ * and the field is reported as null on `ComputedFit.derived.structure`.
+ *
+ * Pyfa parity:
+ *   - `serviceSlotsMax` from the structure hull's attr 2056 (`serviceSlots`)
+ *   - `serviceModuleFuelAmount` (attr 2109) is the per-hour fuel block
+ *     cost of an ONLINE service module. We sum it across modules whose
+ *     state is ONLINE / ACTIVE / OVERLOAD (OFFLINE modules are anchored
+ *     but not contributing to fuel burn).
+ *   - The `serviceModuleFuelOnlineAmount` (attr 2110) attribute is the
+ *     one-time onlining cost (not surfaced in the headline panel).
+ */
+
+declare function computeStructureMeta(ctx: FitContext): StructureMeta | null;
+
+/**
+ * Damage application against a target — what fraction of a weapon's
+ * theoretical DPS actually hits given the target's signature radius,
+ * speed and the engagement range. Used by the "Stats vs Target" panel
+ * and the DPS-over-range graph.
+ *
+ * Two regimes:
+ *   - TURRETS: chance-to-hit = max(0, 0.5^(range_factor² + tracking_factor²))
+ *     where range_factor    = max(0, range - optimal) / falloff
+ *           tracking_factor = (angular_velocity / tracking) × (sig_resolution / sig_radius)
+ *     For a stationary target we set angular_velocity = 0 so only the
+ *     range factor matters.
+ *
+ *   - MISSILES: applied_damage = base × min(1, sig_radius / explosion_radius)
+ *                                       × min(1, (sig × explosion_velocity) / (target_velocity × explosion_radius))^drf
+ *     The first term is the sig-radius drop-off, the second is the
+ *     velocity drop-off raised to the missile's damage reduction factor.
+ *
+ * For drones we approximate as turrets at 0 angular velocity.
+ */
+
+/** Apply hit-chance / sig-and-velocity falloff to a weapon's DPS at the
+ *  given engagement range, against the supplied target profile. Returns
+ *  the effective DPS after application losses. */
+declare function effectiveDps(weapon: WeaponContribution, target: TargetProfile | null, rangeMeters: number): number;
+
+/**
+ * Weapon effect inspection — given an ItemState (a fitted module or a drone),
+ * classify the kind of weapon and extract the canonical attributes used by
+ * the offense aggregator: damage components, cycle time, range, falloff,
+ * tracking, alpha multiplier, missile sig/velocity.
+ *
+ * What this file deliberately does NOT do:
+ *   - Apply tracking against a target (offense.ts handles that — this file
+ *     only surfaces the raw attributes)
+ *   - Compute applied DPS — same reason
+ *   - Iterate the fit — caller picks one item and asks "is this a weapon?"
+ *
+ * The damage source for turrets/missiles is the LOADED CHARGE, not the
+ * launcher. For smart bombs it's the launcher itself (no charge slot).
+ * Drones carry damage attributes baked into the drone type.
+ */
+
+interface WeaponClassification {
+    kind: WeaponEffectKind;
+    /** The dogma effect that classified this item as a weapon. Carries the
+     *  duration / range / falloff / tracking attribute references. */
+    effectID: number;
+    /** ItemState whose attributes provide the damage components. For turrets
+     *  + missiles this is the loaded charge; for smart bombs it's the
+     *  module itself; for drones it's the drone. May be null when the
+     *  weapon has no ammo loaded → caller treats as zero damage. */
+    damageSource: ItemState | null;
+}
+/**
+ * Detect the primary weapon effect on an item. Returns null if the item
+ * isn't a weapon. If multiple weapon effects are present (rare — usually
+ * only on items with both turret + smart-bomb effects historically), the
+ * first match wins by `WEAPON_EFFECT_KIND` lookup order.
+ */
+declare function classifyWeapon(item: ItemState): WeaponClassification | null;
+interface WeaponDamageComponents {
+    em: number;
+    thermal: number;
+    kinetic: number;
+    explosive: number;
+    total: number;
+}
+/**
+ * Read the four damage components from a damage source. Empty (no ammo)
+ * yields all-zero. Turret damage multiplier is NOT applied here — that's
+ * the offense aggregator's concern (the multiplier sits on the LAUNCHER,
+ * not on the charge).
+ */
+declare function readDamageComponents(source: ItemState | null): WeaponDamageComponents;
+interface WeaponCycleInfo {
+    cycleSeconds: number;
+    /** Damage multiplier applied per cycle. 1.0 for missiles / smart bombs;
+     *  the launcher's `damageMultiplier` (attr 64) for turrets. Skill +
+     *  module bonuses already baked in via the modifier engine. */
+    damageMultiplier: number;
+}
+declare function readCycleInfo(item: ItemState, kind: WeaponEffectKind): WeaponCycleInfo;
+interface WeaponRangeInfo {
+    /** Optimal range in meters. 0 for missiles + smart bombs (range is
+     *  tied to flight time × velocity for missiles). */
+    optimal: number;
+    /** Falloff in meters — turret-specific. */
+    falloff: number;
+    /** Tracking speed (rad/s) — turret-specific. */
+    tracking: number;
+    /** Smart-bomb burst range (also used as effective hard cap). */
+    burstRange: number;
+    /** Missile-specific: explosion radius (m). */
+    explosionRadius: number;
+    /** Missile-specific: explosion velocity (m/s). */
+    explosionVelocity: number;
+    /** Missile-specific: damage reduction factor (DRF). */
+    drf: number;
+}
+declare function readRangeInfo(item: ItemState, effect: SdeEffect, kind: WeaponEffectKind): WeaponRangeInfo;
+
+/**
+ * EWAR (Electronic Warfare) classifier.
+ *
+ * Identifies hostile modules that project an electronic effect onto a target
+ * and surfaces the per-effect data needed to render an accurate "under
+ * pressure" view:
+ *   - ECM:                 stochastic (jam chance per cycle)
+ *   - Sensor Dampener:     deterministic (lock range / scan res reduction)
+ *   - Tracking Disruptor:  deterministic (turret tracking / range reduction)
+ *   - Stasis Web:          deterministic (max velocity reduction)
+ *   - Warp Scrambler/Disr: deterministic (warp ability)
+ *   - Energy Neutralizer:  deterministic (cap drain on target)
+ *   - Energy Vampire:      deterministic (cap transfer to source)
+ *
+ * The deterministic effects are already handled by the generic modifier
+ * engine (their modifierInfo applies via `domain: targetID`). This file
+ * exists to:
+ *  1. Classify a module as EWAR for UI rendering
+ *  2. Compute the stochastic ECM jam chance (which has no modifierInfo
+ *     equivalent — it's read against the target's sensor strengths)
+ *
+ * ECM jam chance formula (canonical):
+ *   per_type_chance = ecm_strength_per_type / target_sensor_strength_per_type
+ *   per_cycle_chance = max across the four types
+ *
+ * Each ECM module fires once per cycle, with a per-cycle probability equal
+ * to `per_cycle_chance` clamped to [0, 1]. Multiple ECMs combine via:
+ *   combined = 1 - product(1 - p_i)
+ */
+
+type EwarKind = 'ECM' | 'SENSOR_DAMP' | 'TRACKING_DISRUPT' | 'WEB' | 'WARP_SCRAM' | 'WARP_DISRUPT' | 'NEUT' | 'NOS' | 'OTHER';
+/**
+ * Identify an EWAR module. Returns null if the module isn't EWAR.
+ */
+declare function classifyEwar(item: ItemState): {
+    kind: EwarKind;
+    effectID: number;
+} | null;
+/**
+ * Compute a single ECM module's per-cycle jam chance against a given target.
+ * Picks the maximum of the four sensor-type chances (RADAR/LADAR/MAG/GRAV).
+ *
+ * Returns 0 if the source lacks ECM strength attributes (defensive fallback).
+ */
+declare function ecmJamChance(source: ItemState, target: ItemState): number;
+/**
+ * Combine independent per-cycle jam chances across multiple ECM modules
+ * into a single combined "any jam this cycle" probability via:
+ *   1 - product(1 - p_i)
+ */
+declare function combineJamChances(chances: readonly number[]): number;
+
+/**
+ * EVE Market-window taxonomy walker.
+ *
+ * The picker UIs render the same tree EVE shows in-game (Modules >
+ * Capacitor Modules > Capacitor Battery, Modules > Hybrid Weapons >
+ * Small Hybrid Turret, Drones > Combat Drones > Light Combat) by
+ * walking each type's `marketGroupID` parent chain. Live engine
+ * code never touches market groups — they're a pure presentation
+ * concern routed through this helper.
+ */
+
+interface MarketGroupPlacement {
+    /** Stable category key for collapse/expand state persistence. */
+    categoryKey: string;
+    /** Visible category label (top-level visible bucket in the picker). */
+    categoryName: string;
+    /** Stable subgroup key — also feeds the deterministic hash used
+     *  for open/close persistence within the picker. */
+    subGroupKey: string;
+    /** Visible subgroup label (the leaf bucket directly containing
+     *  the items). */
+    subGroupName: string;
+}
+/**
+ * Map a type to a (category, subgroup) pair using the Market-window
+ * tree.
+ *
+ *  - Walks `t.marketGroupID` up to the root via `parentGroupID`.
+ *  - Subgroup = the leaf (closest to the item) — that's what
+ *    in-game shows directly under each item.
+ *  - Category = parent-of-leaf when the chain has ≥ 2 levels;
+ *    otherwise the leaf itself (top-level Market entries like
+ *    "Apparel" sit there).
+ *  - Falls back to "Other / <SDE group name>" when the type carries
+ *    no `marketGroupID` (skill books, system effects, …).
+ */
+declare function marketGroupPlacement(t: SdeType, dataset: FittingDataset): MarketGroupPlacement;
+
+/**
+ * T3 Cruiser visual-variant resolver for the EstamelGG/EVE_Model_Gallery.
+ *
+ * The repo ships per-subsystem-combination models named like
+ * `<typeID>_<ShipName><dddd>_lite.glb`. Each digit is the 1..3 rank of
+ * the subsystem fitted in that slot. The gallery's digit order is:
+ *
+ *   digit 1 = Core slot       (groupID 958)
+ *   digit 2 = Defensive slot  (groupID 954)
+ *   digit 3 = Offensive slot  (groupID 956)
+ *   digit 4 = Propulsion slot (groupID 957)
+ *
+ * Within each slot the gallery's rank-1/2/3 ordering doesn't follow
+ * typeID, marketGroupID or any other obvious sort key — it appears to be
+ * the editor's hand-picked order from the gallery repo. We therefore
+ * encode the mapping explicitly per subsystem typeID; unknown
+ * subsystems return null so the loader falls back to the base hull.
+ */
+
+/** Returns the 4-digit variant code for a fully-fitted T3C, or null when
+ *  the ship isn't a T3C, the dataset isn't ready, any subsystem slot is
+ *  empty, or any fitted subsystem isn't in the explicit rank table (the
+ *  gallery only ships verified combinations; an unknown rank would yield
+ *  a wrong filename). */
+declare function computeT3CVariantCode(shipTypeID: number, subsystems: ReadonlyArray<FitSubsystem>, dataset: FittingDataset | null | undefined): string | null;
+
+/**
+ * Skill prerequisite analysis. Walks every fitted item (modules, drones,
+ * fighters, charges, implants, boosters, subsystems) and aggregates the
+ * unmet skill requirements against the active SkillProfile.
+ */
+
+interface SkillRequirement {
+    skillID: number;
+    skillName: string;
+    requiredLevel: number;
+    currentLevel: number;
+}
+interface SkillCheckResult {
+    /** Items that can't be used because at least one required skill is below
+     *  the level dictated by the SDE. */
+    unmet: Array<{
+        sourceTypeID: number;
+        sourceName: string;
+        sourceKind: 'module' | 'charge' | 'drone' | 'fighter' | 'implant' | 'booster' | 'subsystem';
+        requirements: SkillRequirement[];
+    }>;
+    /** All distinct skills required by anything in the fit, with the
+     *  highest level demanded across the whole fit. */
+    aggregated: Map<number, {
+        skillName: string;
+        requiredLevel: number;
+        currentLevel: number;
+    }>;
+}
+declare function checkSkills(fit: Fit, dataset: FittingDataset, profile: SkillProfile): SkillCheckResult;
+
+/**
+ * Built-in DamageProfile and TargetProfile presets. These match the
+ * canonical values Pyfa ships, sourced from the EVE Online static data
+ * (NPC race damage distribution + fleet-doctrine targets).
+ *
+ * Presets are read-only; the editor can save custom profiles to the
+ * `damage_profiles` / `target_profiles` Prisma tables, but the presets
+ * here always work even before any DB row exists.
+ */
+
+declare const DAMAGE_PROFILE_PRESETS: ReadonlyArray<DamageProfile>;
+declare const TARGET_PROFILE_PRESETS: ReadonlyArray<TargetProfile>;
+
+/**
+ * Fit-restriction predicates: given a candidate module + a target ship,
+ * return whether the module is allowed by EVE's hard fitting rules.
+ *
+ * What this enforces (module won't physically fit if any check fails):
+ *  - Slot type compatibility (HI / MED / LO / RIG / SUBSYSTEM / SERVICE)
+ *  - canFitShipGroup1-9: module → ship group whitelist
+ *  - canFitShipType1-4: module → ship type whitelist
+ *  - rigSize: rig must match the ship's rig size class
+ *  - Turret hardpoint count: turret weapons need ship.turretHardpoints > 0
+ *  - Launcher hardpoint count: missile launchers need ship.launcherHardpoints > 0
+ *  - Subsystem fitsToShipType: subsystem (categoryID 32) limited to its T3C parent
+ *
+ * What this does NOT enforce (these are soft warnings, not picker filters):
+ *  - CPU / Power Grid availability (a fit can be over-budget temporarily)
+ *  - Calibration cost (rigs)
+ *  - Skill prerequisites
+ *  - maxGroupFitted (only one of group X allowed) — surfaced as warning later
+ *
+ * Soft warnings belong on the fitted module, not on the picker.
+ */
+
+/** Does this type carry an effect that maps to the given slot type? */
+declare function typeFitsSlotType(t: SdeType, slot: SlotType): boolean;
+/** True if the module is a turret weapon (laser / projectile / hybrid). */
+declare function isTurretWeapon(t: SdeType): boolean;
+/** True if the module is a missile launcher (any missile launching effect). */
+declare function isMissileLauncher(t: SdeType): boolean;
+/** True if the module is a smart bomb / AoE high-slot (no hardpoint needed). */
+declare function isSmartBomb(t: SdeType): boolean;
+/**
+ * Collect all canFitShipGroup1-9 values declared on a module. Empty list
+ * means no group restriction.
+ */
+declare function shipGroupRestrictions(t: SdeType): number[];
+/**
+ * Collect all canFitShipType1-4 values. Empty list = no type restriction.
+ */
+declare function shipTypeRestrictions(t: SdeType): number[];
+/** Read `maxGroupFitted` (attr 1544) — undefined if no per-group cap. */
+declare function maxGroupFittedFor(mod: SdeType): number | undefined;
+/** Read `maxTypeFitted` (attr 2487) — undefined if no per-typeID cap. */
+declare function maxTypeFittedFor(mod: SdeType): number | undefined;
+/**
+ * How many more copies of `mod` the ship can still accept under the per-
+ * group / per-type fitting caps (`maxGroupFitted` / `maxTypeFitted`),
+ * given the current fit. Returns `Infinity` when the module declares no
+ * cap. The caller does the slot-availability arithmetic separately
+ * (`freeHardpointsFor`); this only enforces the EVE-wide "max N of this
+ * group/type per hull" rule.
+ *
+ * Example: Medium Breacher Pod Launcher has `maxGroupFitted = 1`. Even on
+ * a Cenotaph with 3 launcher hardpoints, only ONE breacher launcher may
+ * be fitted — the remaining hardpoints stay open for non-breacher
+ * launchers (in practice the Cenotaph's `canFitShipType1` restriction on
+ * the launcher means non-breacher launchers can't replace it; the cap is
+ * the effective "no second breacher" rule).
+ */
+declare function freeFitGroupSlotsFor(mod: SdeType, fittedModules: Array<{
+    typeID: number;
+}>, dataset: {
+    getType(id: number): SdeType | undefined;
+}): number;
+/**
+ * Master predicate: can this module physically fit on this ship?
+ *
+ * @param mod          The candidate module / rig / subsystem.
+ * @param ship         The hull. Must be a category-6 SdeType.
+ * @param slot         Slot the user is trying to fill (HIGH/MED/LO/RIG/SUBSYSTEM/SERVICE).
+ * @param fitContext   Optional current fit + dataset reference. When
+ *                     supplied, the predicate ALSO enforces
+ *                     `maxGroupFitted` / `maxTypeFitted` against the
+ *                     existing modules (one Breacher Pod Launcher per
+ *                     ship, one Bastion Module per ship, …). Omit for the
+ *                     "is this combo even possible?" stateless check.
+ */
+declare function canFitModuleOnShip(mod: SdeType, ship: SdeType | null | undefined, slot: SlotType, fitContext?: {
+    fittedModules: Array<{
+        typeID: number;
+    }>;
+    dataset: {
+        getType(id: number): SdeType | undefined;
+    };
+}): {
+    ok: boolean;
+    reason?: string;
+};
+/**
+ * Returns the set of charge groupIDs accepted by this module — i.e. any
+ * non-zero CHARGE_GROUP_1..5 attribute. Empty set means the module
+ * doesn't take a charge (e.g. damage control, prop mod, smart bomb).
+ */
+declare function chargeGroupsForModule(mod: SdeType): number[];
+/** True if the module declares any chargeGroup attribute — i.e. it takes
+ *  ammo / a script / cap booster charges / etc. */
+declare function moduleAcceptsAnyCharge(mod: SdeType): boolean;
+/**
+ * Charge-fits-module predicate. Both must pass:
+ *   1. charge.groupID ∈ module's CHARGE_GROUP_1..5
+ *   2. charge size ≤ module's chargeSize (when both declare CHARGE_SIZE).
+ *      Modules without an explicit chargeSize accept any size.
+ */
+declare function moduleAcceptsChargeType(mod: SdeType, charge: SdeType): boolean;
+/**
+ * True iff the module declares at least one activation-class effect
+ * (cat 1=active, 2=target-attack, 3=area). These modules accept the
+ * full ONLINE → ACTIVE → OVERLOAD cycle. Pure-passive modules (rigs,
+ * damage controls, gyrostabilizers, signal amplifiers, … with only
+ * cat 0/4/6 effects) don't — they should never expose an "activate"
+ * affordance in the UI because clicking changes nothing in the engine.
+ */
+declare function isActivatableModule(mod: SdeType, effects: Map<number, {
+    effectCategoryID?: number;
+}>): boolean;
+/**
+ * Decide the default state a module should be in when newly fitted /
+ * imported. Modules with at least one activation-class effect want to
+ * be ACTIVE — that's where weapons, propulsion, hardeners, repairers,
+ * EWAR all live. Pure-passive items stay ONLINE.
+ *
+ * Special case: Cloaking Devices (group 330) default to ONLINE even
+ * though they're activatable, because activating one prevents the rest
+ * of the fit from doing anything. The user can manually flip a cloak
+ * to ACTIVE if they want to model a stealth approach.
+ */
+declare function defaultStateForModule(mod: SdeType, effects: Map<number, {
+    effectCategoryID?: number;
+}>): 'ONLINE' | 'ACTIVE';
+/**
+ * Hardpoint usage helper for the multi-fit drag-on-ship feature. Returns
+ * how many turret/launcher hardpoints are still free given the current
+ * fit, so we can decide how many copies of a weapon to drop in.
+ */
+declare function freeHardpointsFor(mod: SdeType, ship: SdeType, fittedHiModules: Array<{
+    typeID: number;
+}>, dataset: {
+    getType(id: number): SdeType | undefined;
+}): number;
+
+export { ACTIVATION_EFFECT_ID, ATTR, type BundleManifest, CATEGORY, type CapacitorReport, type ComputeFitOptions, type ComputedAttribute, type ComputedFit, DAMAGE_PROFILE_PRESETS, type DamageProfile, type DefenseLayerKind, type DerivedStats, type DroneComputed, type EftParseResult, type EwarKind, type FighterComputed, type Fit, type FitBooster, type FitCargo, FitContext, type FitDrone, type FitFighter, type FitImplant, type FitModule, type FitSubsystem, type FitVisibility, type FitWarning, type FittingDataset, type ItemKind, ItemState, LEGACY_EFFECT_IDS, LEGACY_HANDLED_EFFECT_IDS, type LayerEhp, type LegacyEffectEntry, type MarketGroupPlacement, ModifiedAttribute, type ModifierAffliction, type ModifierOperation, type ModuleAttrSnapshot, type ModuleComputed, type ModuleState, type MutatorData, OPERATION_BY_SDE_CODE, OUT_OF_SCOPE_EFFECT_IDS, type OffenseReport, type ProjectedEffectReport, type ProjectedSource, REPAIR_EFFECT_AMOUNT_ATTR, REQUIRED_SKILL_PAIRS, SLOT_EFFECT_ID, SLOT_EFFECT_TO_SLOT_TYPE, STACKING_PENALTY_K, type SdeAttribute, type SdeCategory, type SdeCloneGrade, type SdeDbuffCollection, type SdeDynamicAttribute, type SdeEffect, type SdeGroup, type SdeMarketGroup, type SdeMetaGroup, type SdeModifierInfo, type SdeType, type SdeUnit, type SkillCheckResult, type SkillProfile, type SkillRequirement, type SlotType, type StructureMeta, type StructureServiceModule, TARGET_PROFILE_PRESETS, type TankRates, type TargetProfile, type TypeBucket, WEAPON_EFFECT_KIND, type WeaponContribution, type WeaponEffectKind, type WeaponKind, applyOneModifier, applySkills, applySourceItem, buildNameIndex, canFitModuleOnShip, chargeGroupsForModule, checkSkills, classifyEwar, classifyWeapon, combineJamChances, combineMultiplicative, combinePenalized, combineUnstacked, computeCapacitor, computeFit, computeLayerEhp, computeOffense, computeStructureMeta, computeT3CVariantCode, computeTank, computeTotalEhp, defaultStateForModule, disintegratorCyclesToFullSpool, disintegratorSpoolBonus, ecmJamChance, effectiveDps, ehpUnderProfile, formatDna, formatEft, formatMultibuy, formatTypeIds, freeFitGroupSlotsFor, freeHardpointsFor, isActivatableModule, isMissileLauncher, isSmartBomb, isTurretWeapon, marketGroupPlacement, maxGroupFittedFor, maxTypeFittedFor, moduleAcceptsAnyCharge, moduleAcceptsCharge, moduleAcceptsChargeType, parseEft, peakRecharge, readCycleInfo, readDamageComponents, readRangeInfo, rechargeRateAt, shipGroupRestrictions, shipTypeRestrictions, typeFitsSlotType, verifyLegacyEffectIds };