@elite-dangerous-almanac/core 0.2.0 → 0.2.2

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

@@ -18,8 +18,27 @@ import './module-families.js';
  * `ShipLoadout` reports neither: it is keyed by slot and `fromLoadout` throws a
  * `TypeError` on a duplicate, and every build fills its fixed mounts from the hull
  * defaults. Switch on them when you validate your own list; skip them for a build.
+ *
+ * `thrusterMassExceeded` is the one code that reads a figure rather than the structure,
+ * so it is reported only when the input states both a
+ * {@link LoadoutValidationInput.mass} and the fitted thrusters'
+ * {@link ValidationModule.thrusterMaxMass}. A build supplies both.
+ */
+type LoadoutIssueCode = 'duplicateSlot' | 'unknownSlot' | 'missingRequiredSlot' | 'incompatibleModule' | 'duplicateExclusiveModule' | 'moduleLimitExceeded' | 'thrusterMassExceeded';
+/**
+ * A load a thruster rating is read against, lightest first.
+ *
+ * @remarks
+ * `dry` is the fit alone — hull plus modules, an empty tank and no cargo. `unladen`
+ * adds a full main tank, and is the figure the game and every outfitting tool call a
+ * ship's unladen mass; note that {@link ships!ShipLoadout.unladenMass} is the `dry`
+ * figure, because that is what a journal's `UnladenMass` states. `laden` adds a full
+ * hold on top.
+ *
+ * A ship cannot undock without fuel, so failing at `dry` or `unladen` is an error.
+ * Failing only at `laden` is a warning: the hold is the one load a pilot chooses.
  */
-type LoadoutIssueCode = 'duplicateSlot' | 'unknownSlot' | 'missingRequiredSlot' | 'incompatibleModule' | 'duplicateExclusiveModule' | 'moduleLimitExceeded';
+type ThrusterLoad = 'dry' | 'unladen' | 'laden';
 /** Stable machine-readable constraint behind an `incompatibleModule` issue. */
 type ModuleFitConstraint = 'immutableSlot' | 'armourRequired' | 'wrongHullArmour' | 'restrictedHull' | 'restrictedMount' | 'wrongCoreType' | 'hardpointRequired' | 'utilityRequired' | 'optionalInternalRequired' | 'coreModuleInOptionalSlot' | 'oversized' | 'unknownConstraint';
 /**
@@ -34,8 +53,18 @@ type LoadoutIssueParams = Readonly<Record<string, LoadoutIssueParam>>;
 interface LoadoutIssue {
     /** Machine-readable reason. */
     readonly code: LoadoutIssueCode;
-    /** Invalid input is an error; a missing required module makes the build incomplete. */
-    readonly severity: 'error' | 'incomplete';
+    /**
+     * Invalid input is an error; a missing required module makes the build incomplete;
+     * a warning is a build that flies, but not at every load it can carry.
+     *
+     * @remarks
+     * Only `error` clears {@link LoadoutValidation.valid}, and only `error` or
+     * `incomplete` clears {@link LoadoutValidation.complete}. A `warning` is a note
+     * against a legal, fully-mounted build, so it leaves both answers alone. Branch on
+     * {@link code} rather than on this: one severity covers findings that belong in
+     * different places on a panel.
+     */
+    readonly severity: 'error' | 'incomplete' | 'warning';
     /** Slot involved, in the build's own spelling when possible. */
     readonly slot?: string;
     /** Module symbol involved, when any. */
@@ -77,6 +106,18 @@ interface ValidationModule {
     readonly limitGroup?: ModuleLimitGroup;
     /** Per-ship count allowance increase this resolved module grants, when any. */
     readonly limitIncrease?: ModuleLimitIncrease;
+    /**
+     * The mass this module can still move, in tonnes — a thruster's post-engineering
+     * `maxMass`, and the top of its mass curve.
+     *
+     * @remarks
+     * Present only on the fitted thrusters, and only where their record carries the
+     * figure. Above it the curve contributes nothing and the ship does not move, which
+     * is what {@link LoadoutValidationInput.mass} is weighed against. Leave it off every
+     * other module: a shield generator's curve has a `maxMass` of its own and is not a
+     * limit on the build's mass.
+     */
+    readonly thrusterMaxMass?: number;
 }
 /** Input to {@link validateLoadout}. */
 interface LoadoutValidationInput {
@@ -86,12 +127,57 @@ interface LoadoutValidationInput {
     readonly slots: readonly BuildSlot[];
     /** Fitted modules. Duplicate keys must be retained here so they can be diagnosed. */
     readonly modules: readonly ValidationModule[];
+    /**
+     * What the assembled ship weighs, for the one rule that reads a figure: thrusters
+     * rated below the ship's mass cannot move it.
+     *
+     * Omit it to check structure alone.
+     */
+    readonly mass?: LoadoutMass;
+}
+/**
+ * What a build weighs at each load a thruster rating is read against, in tonnes.
+ *
+ * @remarks
+ * State as much as the build knows. {@link fuel} and {@link cargo} are *capacities*,
+ * not a chosen load: the rule weighs a full tank and a full hold, because those are the
+ * heaviest the build can become without being re-fitted. Leave one off and the loads
+ * above it simply go unchecked.
+ */
+interface LoadoutMass {
+    /**
+     * Hull plus every fitted module, an empty tank and no cargo — a build's
+     * {@link ships!ShipLoadout.unladenMass | unladenMass}.
+     *
+     * @remarks
+     * Despite that name this is the *dry* figure: a journal's `UnladenMass` excludes
+     * fuel, while the game's own "unladen mass" readout includes a full tank. The two
+     * are told apart here as {@link ThrusterLoad}'s `dry` and `unladen`.
+     */
+    readonly dry: number;
+    /** Main-tank capacity. The reserve is not counted, as the flight model does not. */
+    readonly fuel?: number;
+    /** Cargo capacity, as fitted racks allow rather than as any hold currently holds. */
+    readonly cargo?: number;
 }
 /**
  * Validate a resolved fitted build without importing any catalogue.
  *
- * @param input - Hull layout and resolved module classifications.
+ * @param input - Hull layout and resolved module classifications, and optionally what
+ * the assembled ship weighs.
  * @returns Structural validity, operational completeness, and diagnostics.
+ * @remarks
+ * Every rule but one reads the structure alone. The exception is
+ * `thrusterMassExceeded`: state {@link LoadoutValidationInput.mass} and the fitted
+ * thrusters' {@link ValidationModule.thrusterMaxMass}, and a ship too heavy for its own
+ * thrusters is reported, because above that rating the thruster curve contributes
+ * nothing and the ship does not move at all.
+ *
+ * The rating is weighed against each {@link ThrusterLoad} the input can state, and the
+ * lightest load that is already too heavy is the one reported. A ship that cannot move
+ * `dry` or `unladen` is an error — it cannot leave a pad, where the tank is always
+ * full. One that only fails `laden` is a warning, and leaves the build both valid and
+ * complete: the hold is the one load a pilot chooses.
  * @example
  * ```ts
  * import { validateLoadout } from '@elite-dangerous-almanac/core/ships/loadout-validation';
@@ -99,9 +185,29 @@ interface LoadoutValidationInput {
  * const result = validateLoadout({ shipSymbol: 'CustomHull', slots: [], modules: [] });
  * result.valid; // -> true: no impossible fit was claimed
  * result.complete; // -> true: the supplied layout has no required mounts
+ *
+ * const overloaded = validateLoadout({
+ *     shipSymbol: 'CustomHull',
+ *     slots: [],
+ *     mass: { dry: 60.6, fuel: 25 },
+ *     modules: [
+ *         {
+ *             slot: 'MainEngines',
+ *             symbol: 'Int_Engine_Size2_Class1',
+ *             requiresKnownSlot: false,
+ *             fitError: null,
+ *             thrusterMaxMass: 72,
+ *         },
+ *     ],
+ * });
+ * overloaded.valid; // -> false
+ * overloaded.issues[0]?.code; // -> 'thrusterMassExceeded'
+ * overloaded.issues[0]?.params?.load; // -> 'unladen': it is the full tank that sinks it
  * ```
  * @throws {TypeError} If `input.slots` is not an array.
+ * @throws {RangeError} If a figure in `input.mass`, or a module's `thrusterMaxMass`, is
+ * present and is not a finite number of zero or more.
  */
 declare function validateLoadout(input: LoadoutValidationInput): LoadoutValidation;
 
-export { type LoadoutIssue, type LoadoutIssueCode, type LoadoutIssueParam, type LoadoutIssueParams, type LoadoutValidation, type LoadoutValidationInput, type ModuleFitConstraint, type ValidationModule, validateLoadout };
+export { type LoadoutIssue, type LoadoutIssueCode, type LoadoutIssueParam, type LoadoutIssueParams, type LoadoutMass, type LoadoutValidation, type LoadoutValidationInput, type ModuleFitConstraint, type ThrusterLoad, type ValidationModule, validateLoadout };

package/dist/ships/loadout-validation.js

@@ -1 +1 @@
-export{validateLoadout}from"../chunk-B4ZSTOM4.js";                                                          //# sourceMappingURL=loadout-validation.js.map
+export{validateLoadout}from"../chunk-OJC6AUL7.js";                                                          //# sourceMappingURL=loadout-validation.js.map

package/dist/ships/mobility-capacitor.d.ts

@@ -17,7 +17,7 @@ import { MobilityInput, ThrusterParams } from './mobility.js';
  * {@link MobilityMetrics.boost}, along with the loaded mass and the two curve
  * multipliers these figures share.
  *
- * This module is data-free. {@link BuildMetrics.mobilityCapacitorMetrics} (in
+ * This module is data-free. {@link BuildMetrics.mobilityCapacitorMetricsResult} (in
  * `./build-metrics`) reads the hull, the loaded mass and the powered thrusters out of a
  * build and calls {@link mobilityCapacitorMetrics} for you.
  *

package/dist/ships/mobility-capacitor.js

@@ -1 +1 @@
-export{mobilityCapacitorMetrics}from"../chunk-XUHAPOM6.js";                                                                                       //# sourceMappingURL=mobility-capacitor.js.map
+export{mobilityCapacitorMetrics}from"../chunk-VEEBJFJ7.js";                                                                                       //# sourceMappingURL=mobility-capacitor.js.map

package/dist/ships/mobility.js

@@ -1 +1 @@
-export{mobilityMetrics,thrusterMassCurveMultiplier}from"../chunk-Y6KJJMIM.js";                                                          //# sourceMappingURL=mobility.js.map
+export{mobilityMetrics,thrusterMassCurveMultiplier}from"../chunk-A4QKXXZD.js";                                                                                       //# sourceMappingURL=mobility.js.map

package/dist/ships/modules-all.js

@@ -1 +1 @@
-export{ALL_MODULES}from"../chunk-QY3L5BKN.js";                                                                                                                                                                              //# sourceMappingURL=modules-all.js.map
+export{ALL_MODULES}from"../chunk-7ZERP4TB.js";                                                                                                                                                                              //# sourceMappingURL=modules-all.js.map

package/dist/ships/modules-core.js

@@ -1 +1 @@
-export{CORE_MODULES}from"../chunk-EVJ32UF3.js";                                                          //# sourceMappingURL=modules-core.js.map
+export{CORE_MODULES}from"../chunk-FA5JVXVG.js";                                                          //# sourceMappingURL=modules-core.js.map

package/dist/ships/modules-internal.js

@@ -1 +1 @@
-export{INTERNAL_MODULES}from"../chunk-4ZGUSHTP.js";                                                          //# sourceMappingURL=modules-internal.js.map
+export{INTERNAL_MODULES}from"../chunk-4CBMQULR.js";                                                          //# sourceMappingURL=modules-internal.js.map

package/dist/ships/modules.d.ts

@@ -44,7 +44,7 @@ import { ModuleSlot, SlotRestriction } from './slots.js';
  *
  * @remarks
  * **This is the one default that costs real bundle weight.** A lookup imported from
- * here pulls all four catalogues — 337.4 KiB minified (33.3 KiB gzipped) — since
+ * here pulls all four catalogues — ~338 KiB minified (~33 KiB gzipped) — since
  * that is what it falls back to, and passing an explicit catalogue does not undo it.
  * A build that must carry only one category should import that catalogue and search
  * it directly:
@@ -333,6 +333,26 @@ interface OutfittingModuleIdentity {
      * `"ELITE_HORIZONS_V_PLANETARY_LANDINGS"`. Present only on gated modules.
      */
     readonly entitlement?: string;
+    /**
+     * `true` on an article that arrives granted — with a hull or with a bundle — and
+     * that no outfitting screen sells. Absent on every module a station offers.
+     *
+     * @remarks
+     * The fifteen are the nine starter `*_free` fittings and the six bundle-granted
+     * Vessel Hangars. Each is a second identity for an article the game already sells:
+     * `Int_Engine_Size2_Class1_free` is the 2E Thrusters again, which is why
+     * {@link ShipLoadout.modulesForSlot} leaves them out — a picker that offered both
+     * would list "2E Thrusters" twice, once unpriced.
+     *
+     * They are still real fitted articles, so they stay in the catalogues and every
+     * lookup resolves one: a build imported from a journal can carry one, and
+     * {@link getModuleBySymbol} answers for it like any other symbol. Absent is not
+     * `false` — nothing carries `grantOnly: false`.
+     *
+     * Do not read it as a price: {@link OutfittingModule.cost} is missing on these but
+     * also on articles that are sold and simply unpriced by every registry.
+     */
+    readonly grantOnly?: true;
     /**
      * The hull symbol(s) a module is restricted to, when it is ship-specific — e.g.
      * `["Explorer_NX"]` for the Python Mk II's MkII Gravity Optimised thrusters.

package/dist/ships/modules.js

@@ -1 +1 @@
-export{getBulkheadsForShip,getModuleBySymbol,getModulesByName}from"../chunk-PA5EITW5.js";                                                                                                                                                                                                                                                                     //# sourceMappingURL=modules.js.map
+export{getBulkheadsForShip,getModuleBySymbol,getModulesByName}from"../chunk-3LZXB2MC.js";                                                                                                                                                                                                                                                                     //# sourceMappingURL=modules.js.map

package/dist/ships/power.js

@@ -1 +1 @@
-export{powerBudget}from"../chunk-D6YEHR5S.js";//# sourceMappingURL=power.js.map
+export{powerBudget}from"../chunk-GGQMIQPC.js";                             //# sourceMappingURL=power.js.map

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

@@ -15,8 +15,8 @@ import './slots.js';
  * arrives, not as the stock module leaves the shipyard. That is what
  * {@link getPreEngineeredStats} returns.
  *
- * This module imports every module record to resolve stats. Its resolver is 362.5 KiB
- * minified in a consumer bundle; the complete runtime API is 396.3 KiB (43.1 KiB
+ * This module imports every module record to resolve stats. Its resolver is ~363 KiB
+ * minified in a consumer bundle; the complete runtime API is ~397 KiB (~43 KiB
  * gzipped). Consumers that only list variants can import `./pre-engineered.js` without
  * these module catalogues.
  * A journal or SLEF module can instead be classified with
@@ -100,16 +100,23 @@ declare function getPreEngineeredJournalModifiers(variant: PreEngineeredVariant)
  *
  * A locked fixed article is also identified by its unique
  * symbol/blueprint/grade/experimental tuple when a SLEF capture omits the `Modifiers` key
- * entirely. A present empty or partial array does not use this shortcut: older library
- * exports can carry an ordinary roll with the same tuple, and its values must not be
- * replaced by reward stats. A third-party export can omit the array from such a roll;
- * that record is indistinguishable from the fixed article, so the catalogue identity
- * wins.
+ * entirely: being final, no ordinary roll could have written that tuple. A present empty
+ * or partial array does not use this shortcut: older library exports can carry an ordinary
+ * roll with the same tuple, and its values must not be replaced by reward stats. A third-
+ * party export can omit the array from such a roll; that record is indistinguishable from
+ * the fixed article, so the catalogue identity wins.
+ *
+ * An unlocked article that shares a blueprint with no craftable recipe of its base module
+ * is identified the same way, but by `ShipLoadout.fromLoadout` rather than here — that
+ * reading needs each module's engineering menu, a catalogue this module deliberately does
+ * not carry into a consumer's bundle.
  *
  * Frontier journals and captures may omit a derived modifier, so one predicted value may
- * be absent. Every stated predicted value must agree within journal float noise, and all
- * but at most one must be present. Ambiguous or incomplete evidence returns `null` rather
- * than guessing.
+ * be absent. Every stated predicted value must agree to within one part in ten thousand of
+ * the stat's unmodified base — wide enough for a producer that stores the multiplier and
+ * re-derives the value, narrow enough that no other candidate fits — and all but at most
+ * one must be present. Ambiguous or incomplete evidence returns `null` rather than
+ * guessing.
  * Other variants without a published stat block cannot be identified.
  *
  * @param module - A module from a journal `Loadout` event or SLEF export.

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

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

package/dist/ships/resistances.js

@@ -1 +1 @@
-export{effectiveHitPoints,mapDamageTypes,stackArmourResistance,stackShieldResistance,systemsResistance}from"../chunk-JGOAQLYW.js";                             //# sourceMappingURL=resistances.js.map
+export{effectiveHitPoints,mapDamageTypes,stackArmourResistance,stackShieldResistance,systemsResistance}from"../chunk-F44QX47A.js";                             //# sourceMappingURL=resistances.js.map

package/dist/ships/shield-capacitor.d.ts

@@ -22,7 +22,7 @@ import { DamageResistances, DamageTypeValues } from './resistances.js';
  * raised shield — is {@link shieldRecovery}, which takes the same allocation and the
  * generator's regeneration rates.
  *
- * This module is data-free. {@link BuildMetrics.shieldCapacitorMetrics} (in
+ * This module is data-free. {@link BuildMetrics.shieldCapacitorMetricsResult} (in
  * `./build-metrics`) resolves the powered generator, boosters and distributor for you.
  *
  * @remarks

package/dist/ships/shield-capacitor.js

@@ -1 +1 @@
-export{shieldCapacitorMetrics}from"../chunk-6L56LWTT.js";                                                                                       //# sourceMappingURL=shield-capacitor.js.map
+export{shieldCapacitorMetrics}from"../chunk-XQJERZUS.js";                                                                                       //# sourceMappingURL=shield-capacitor.js.map

package/dist/ships/shield-recovery.js

@@ -1 +1 @@
-export{cellBankSummary,shieldRecovery}from"../chunk-4KJ7CR74.js";                             //# sourceMappingURL=shield-recovery.js.map
+export{cellBankSummary,shieldRecovery}from"../chunk-JMAXSXXQ.js";                                                          //# sourceMappingURL=shield-recovery.js.map

package/dist/ships/shields.d.ts

@@ -19,7 +19,7 @@ import { DamageResistances, DamageTypeValues, DamageResistanceParams } from './r
  * `./resistances`. Everything here is **pip-free**: the SYS capacitor's own resistance,
  * and the effective figures it buys, live in `./shield-capacitor`.
  *
- * This module is data-free. {@link BuildMetrics.shieldMetrics} (in `./build-metrics`)
+ * This module is data-free. {@link BuildMetrics.shieldMetricsResult} (in `./build-metrics`)
  * pulls the generator, boosters and reinforcement packages out of a build,
  * post-engineering, and calls {@link shieldMetrics} for you.
  *

package/dist/ships/shields.js

@@ -1 +1 @@
-export{shieldMassCurveMultiplier,shieldMetrics,shieldStrength}from"../chunk-QTAMQ6ME.js";                                                                                       //# sourceMappingURL=shields.js.map
+export{shieldMassCurveMultiplier,shieldMetrics,shieldStrength}from"../chunk-5VWACBTN.js";                                                                                       //# sourceMappingURL=shields.js.map

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

@@ -160,10 +160,17 @@ type LoadoutSlot = BuildSlot & {
  * A change made while normalizing a journal or SLEF loadout against the catalogues.
  *
  * @remarks
- * `ShipLoadout.fromLoadout` states the rule these outcomes report: a removable mount is
+ * `ShipLoadout.fromLoadout` states the rules these outcomes report: a removable mount is
  * `emptied` of an article the catalogue cannot resolve, and a fixed mount is `defaulted`
  * to the hull's stock article whenever the source left none it can hold — with a `null`
- * `sourceSymbol` when the source named nothing there at all.
+ * `sourceSymbol` when the source named nothing there at all. A module whose source stated
+ * a recipe and no `Modifiers` reports `unresolvedEngineering` when neither a craftable
+ * recipe nor a catalogued article answers to what it named, because that module alone
+ * keeps the figures of an unengineered one. Two further entries report a *reading* the
+ * import chose rather than a change it made: `ambiguousEngineering` where an identity-only
+ * block was rolled while a catalogued article answers to it just as well, and
+ * `rerolledEngineering` where a stated modifier block moved nothing the module has and the
+ * recipe beside it was rolled in its place.
  *
  * @example
  * ```ts
@@ -194,6 +201,57 @@ type LoadoutImportOutcome = {
     readonly sourceSymbol: string | null;
     /** Stock module identity installed in the mount. */
     readonly replacementSymbol: string;
+} | {
+    /**
+     * The source stated engineering with no `Modifiers`, and what it named could
+     * not be rolled — an unknown or unoffered blueprint or experimental effect, a
+     * grade or quality outside the recipe, or a base stat the catalogues do not
+     * carry — so this module's figures are the unengineered ones.
+     */
+    readonly action: 'unresolvedEngineering';
+    /** Exact slot spelling used by the imported build. */
+    readonly slot: string;
+    /** Module identity the recipe was stated for. */
+    readonly sourceSymbol: string;
+    /** Recipe the source named, in its own spelling. */
+    readonly blueprintSymbol: string;
+} | {
+    /**
+     * The source stated a recipe and no `Modifiers`, and both readings of that
+     * identity are legitimate: the module's own engineering menu offers the recipe,
+     * *and* a catalogued fixed article carries the same blueprint at the same grade
+     * and effect. The roll was fitted, because that is what nearly every such block
+     * is; {@link preEngineeredVariant} is the article passed over.
+     */
+    readonly action: 'ambiguousEngineering';
+    /** Exact slot spelling used by the imported build. */
+    readonly slot: string;
+    /** Module identity the recipe was stated for. */
+    readonly sourceSymbol: string;
+    /** Recipe the source named, in its own spelling. */
+    readonly blueprintSymbol: string;
+    /**
+     * The catalogued article the same block equally describes. Pass it to
+     * {@link ships!ShipLoadout.setPreEngineeredVariant |
+     * ShipLoadout.setPreEngineeredVariant} to take that reading instead.
+     */
+    readonly preEngineeredVariant: PreEngineeredVariant;
+} | {
+    /**
+     * The source stated `Modifiers` that move no stat this module has — an empty
+     * array, or labels the catalogues model nothing for — and identified no
+     * catalogued article, so the module would have published unengineered figures
+     * while reporting that it is engineered. The recipe stated beside them was
+     * rolled at the stated grade and quality in their place, and the source's own
+     * modifier block is gone from the build.
+     */
+    readonly action: 'rerolledEngineering';
+    /** Exact slot spelling used by the imported build. */
+    readonly slot: string;
+    /** Module identity the recipe was stated for. */
+    readonly sourceSymbol: string;
+    /** Recipe the source named, in its own spelling. */
+    readonly blueprintSymbol: string;
 };
 
 /**
@@ -378,8 +436,9 @@ interface EngineeringNormalized {
     /** Discriminator for a successful normalization. */
     readonly kind: 'normalized';
     /**
-     * Quality reported by the fitted module before normalization, in `[0, 1]`. It reads
-     * `1` where a completed roll stated no modifiers and this call spelled them out.
+     * Quality reported by the fitted module before normalization, in `[0, 1]`. A block
+     * that stated no modifiers still reports the quality it stated, so this reads `1` for
+     * a completed roll whose figures this call was the first to spell out.
      */
     readonly previousQuality: number;
     /** Completed engineering quality. Always `1`. */
@@ -525,7 +584,7 @@ interface SlefExportOptions extends LoadoutExportOptions {
  * const metrics = BuildMetrics.of(build);
  * metrics.maxJumpRange(); // -> 60.5478   (ly, best single jump)
  * metrics.powerBudget().withinBudget; // -> true
- * metrics.shieldMetrics()?.strength; // -> 743.12  (MJ)
+ * metrics.shieldMetricsResult().value?.strength; // -> 743.12  (MJ)
  * metrics.armourMetrics().hitPoints; // -> 307.8
  * ```
  */
@@ -541,7 +600,8 @@ declare class ShipLoadout {
      * Defaults to the first.
      * @returns The loadout for that entry.
      * @remarks Module normalization follows {@link ShipLoadout.fromLoadout}; inspect
-     * {@link importOutcomes} for modules that were emptied or defaulted.
+     * {@link importOutcomes} for modules that were emptied or defaulted, and for stated
+     * engineering it could not resolve.
      * @throws {SyntaxError} If `input` is a string that is not valid JSON.
      * @throws {TypeError} If the export holds no usable loadout, `index` is out of range,
      * or the selected entry names a hull absent from the catalogue.
@@ -560,6 +620,29 @@ declare class ShipLoadout {
      * and the catalogue's stat block then supplies the values the capture omits; the
      * capture's own modifiers stay authoritative over it.
      *
+     * **A recipe stated without `Modifiers` is rolled.** A journal writes the modifier
+     * block beside the recipe, but SLEF permits stating the recipe alone and Inara does,
+     * so such a block is materialised here at the grade and quality it states — otherwise
+     * the module would report that it is engineered while publishing the figures of one
+     * that is not. Where the module's own engineering menu offers the recipe, the block
+     * is read as an ordinary roll of it, even if a fixed article of that module carries
+     * the same blueprint at the same grade — a reading {@link importOutcomes} reports as
+     * `ambiguousEngineering`, carrying the article passed over so
+     * {@link setPreEngineeredVariant} can take the other one. A Mercenary article is read
+     * as its own article at the grade it was bought at, and as that purchase climbed by
+     * its bespoke recipe above it. Where the menu does not offer the recipe, no ordinary
+     * roll could have written the block, so a single catalogued article answering to it
+     * is fitted. Where neither answers, the module keeps unengineered figures and
+     * {@link importOutcomes} reports the slot as `unresolvedEngineering`.
+     *
+     * **A stated modifier block that moves nothing is replaced by the roll.** A block
+     * naming only stats the module has no value for describes some other module, and
+     * preserving it would publish unengineered figures under an engineered block, so the
+     * recipe stated beside it is rolled instead and the slot is reported as
+     * `rerolledEngineering`. Every block that moves at least one stat this module carries
+     * stays exactly as the source wrote it: a capture's own figures are what the game
+     * reported, and outrank anything recomputed here.
+     *
      * Modules are imported as one complete snapshot, so their order does not affect
      * per-ship count allowances. An entry stands as the event stated it when the mount
      * can hold the article the catalogue resolves, when its slot is a known cosmetic or
@@ -725,18 +808,28 @@ declare class ShipLoadout {
      */
     get sourcePurchase(): SourcePurchaseRecord | null;
     /**
-     * Changes made while importing this build, in source order, followed by the fixed
-     * mounts stocked from the hull defaults because the source named none, in the
-     * defaults' own order.
+     * What the import made of this build: the changes it applied, in source order,
+     * followed by the fixed mounts stocked from the hull defaults because the source
+     * named none, in the defaults' own order, followed by what it made of each module's
+     * stated engineering.
      *
      * @returns A deeply frozen list. It is empty for builds created with
      * {@link ShipLoadout.empty} or {@link ShipLoadout.default}, and for imports that
-     * needed no normalization.
+     * needed no normalization and read every stated recipe unambiguously.
      * @remarks
      * Each entry names the exact slot, and the source identity where the source gave one.
      * `emptied` means an unknown module was removed from a removable mount; `defaulted`
      * names the stock article fitted to armour, a core internal or the cargo hatch, with
      * a `null` `sourceSymbol` when the source named nothing there at all.
+     * `rerolledEngineering` names a module whose stated `Modifiers` moved no stat it
+     * carries, so the recipe beside them was rolled in their place.
+     *
+     * Two entries report no change to the fit at all. `unresolvedEngineering` means the
+     * source stated a recipe and no `Modifiers`, nothing the catalogues carry answers to
+     * it, and that module alone keeps the figures of an unengineered one.
+     * `ambiguousEngineering` means such a block had *two* answers — an ordinary roll and
+     * a catalogued fixed article — and carries the article that was passed over, ready
+     * for {@link setPreEngineeredVariant} (see {@link ShipLoadout.fromLoadout}).
      */
     get importOutcomes(): readonly LoadoutImportOutcome[];
     /**
@@ -744,11 +837,29 @@ declare class ShipLoadout {
      *
      * @remarks
      * `valid` asks whether the fit is legal: a module in a nonexistent or incompatible
-     * slot, a duplicated exclusive family, or a module count past the build's allowance
-     * makes it `false`. `complete` asks that *and* whether armour and the seven core
-     * mounts are filled — every build fills those, so on a build the two answers agree.
-     * Neither question reports import normalization, so read {@link importOutcomes}
-     * beside them.
+     * slot, a duplicated exclusive family, a module count past the build's allowance, or
+     * a ship heavier than its own thrusters can move makes it `false`. `complete` asks
+     * that *and* whether armour and the seven core mounts are filled — every build fills
+     * those, so on a build the two answers agree. Neither question reports import
+     * normalization, so read {@link importOutcomes} beside them.
+     *
+     * The thruster rule weighs the fitted thrusters' post-engineering `maxMass` against
+     * what the ship comes to at each load it can reach without being re-fitted:
+     * {@link unladenMass} alone, then with a full {@link fuelCapacity | main tank}, then
+     * with a full {@link cargoCapacity | hold} as well. The lightest of those that is
+     * already too heavy is what gets reported. A ship that cannot move on a full tank is
+     * an error — it never leaves the pad, where the tank always is one — while a ship
+     * that only fails with the hold full is a warning, and leaves the build valid and
+     * complete: how much cargo to take is the pilot's call. Either way
+     * {@link ships!BuildMetrics.mobilityMetricsResult | BuildMetrics.mobilityMetricsResult} reports
+     * a speed of zero at the load in question.
+     *
+     * A capture may state a mass nobody can weigh — a negative `UnladenMass`, or an
+     * engineering modifier that drives a rating below zero. Neither is refused here:
+     * this method reports a build rather than rejecting one, so an unweighable figure is
+     * left out and the rule it feeds simply does not run. The figure itself is still
+     * reported, as a thrown one, by whichever {@link ships!BuildMetrics | BuildMetrics}
+     * calculation reads it.
      *
      * @returns The validation report, recomputed from the current fit on every call.
      */
@@ -836,6 +947,13 @@ declare class ShipLoadout {
      * satisfied, with candidates that would worsen a one-per-ship or module-count limit
      * omitted.
      *
+     * @remarks
+     * This is the outfitting *offer*, so the fifteen {@link ships!OutfittingModule.grantOnly | grantOnly}
+     * articles are never in it: each is a second identity for a module the game already
+     * sells — `Int_Engine_Size2_Class1_free` is the 2E Thrusters — and listing both puts
+     * the same article on the screen twice, once with no price. A build that already
+     * carries one keeps it; only the choices are filtered.
+     *
      * @param slotKey - The slot key to fit, matched case-insensitively (journal spelling).
      * @returns The fitting modules, in complete-catalogue order.
      * @throws {RangeError} If the hull has no slot with that key.
@@ -1019,9 +1137,13 @@ declare class ShipLoadout {
      * purchase identity. A refusal never changes the loadout.
      *
      * A block that names a blueprint and grade but states no `Modifiers` at all is rolled
-     * here too, even at quality `1` — SLEF permits that identity-only shape and Inara
-     * writes it, so a capture of a completed roll would otherwise stay stock. A stated
-     * modifier array, empty or partial, is left alone at quality `1`.
+     * here too, even at quality `1`, so a completed roll cannot stay stock. On an imported
+     * build such a block is one {@link ShipLoadout.fromLoadout} did not roll: a catalogued
+     * article it fitted instead, whose fixed modifiers this spells out unless the article
+     * is final; a Mercenary article at the grade it was bought at, whose block no registry
+     * publishes and which this refuses; or a recipe nothing answered to, which this
+     * refuses for the reason the import could not roll it. A stated modifier array, empty
+     * or partial, is left alone at quality `1`.
      *
      * @param slotKey - The engineered slot, matched case-insensitively.
      * @returns A frozen result identifying a normalized, unchanged or unsupported state.

package/dist/ships/ship-loadout.js

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

package/dist/ships/slef.d.ts

@@ -90,7 +90,10 @@ interface BlueprintModuleEngineering {
      * `BlueprintName`, `Level` and `Quality` — the specification's own example omits it —
      * so an export from another app may name the blueprint and its roll without spelling
      * out the resulting stats. Treat a missing array as "not stated", not as "nothing was
-     * changed". A craftable recipe can be reconstructed with
+     * changed". {@link ShipLoadout.fromLoadout} resolves what a missing array implies —
+     * rolling the stated recipe, or fitting the catalogued article the identity can only
+     * mean — so a build imported through it needs none of this. Working from the wire
+     * shape directly, a craftable recipe is reconstructed with
      * {@link ShipLoadout.applyBlueprint}, or rolled where it stands with
      * {@link ShipLoadout.completeEngineeringGrade}, which spells out a stated identity
      * at quality `1`; resolve a fixed identity through the pre-engineered catalogue and

package/dist/ships/slef.js

@@ -1 +1 @@
-export{getLoadoutModifier,inspectSlef,parseSlef,stringifySlef,toSlef}from"../chunk-OVUHQEH5.js";                                                          //# sourceMappingURL=slef.js.map
+export{getLoadoutModifier,inspectSlef,parseSlef,stringifySlef,toSlef}from"../chunk-T4MKUKYS.js";                                                          //# sourceMappingURL=slef.js.map

package/dist/ships/weapons-capacitor.js

@@ -1 +1 @@
-export{weaponsCapacitorMetrics}from"../chunk-RRYBSAPX.js";                             //# sourceMappingURL=weapons-capacitor.js.map
+export{weaponsCapacitorMetrics}from"../chunk-M4FZRDAH.js";                                                          //# sourceMappingURL=weapons-capacitor.js.map

package/dist/ships/weapons.js

@@ -1 +1 @@
-export{armourPiercingFactor,combinedRateOfFire,damageFalloff,damagePerSecond,energyPerSecond,heatPerSecond,splitDamage,sumWeaponMetrics,sustainedDamagePerSecond,sustainedFireFactor,weaponMetrics}from"../chunk-7TQ2X6Q3.js";//# sourceMappingURL=weapons.js.map
+export{armourPiercingFactor,combinedRateOfFire,damageFalloff,damagePerSecond,energyPerSecond,heatPerSecond,splitDamage,sumWeaponMetrics,sustainedDamagePerSecond,sustainedFireFactor,weaponMetrics}from"../chunk-37JIMWLK.js";                             //# sourceMappingURL=weapons.js.map