@elite-dangerous-almanac/core 0.1.0-beta.1

package/dist/ships/modules.js

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

package/dist/ships/modules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/ships/power.d.ts

@@ -0,0 +1,168 @@
+/**
+ * **Power** — what the plant makes, what the build draws, and which priority groups
+ * stay lit when it draws more than it makes.
+ *
+ * The model is the game's own. Every powered module draws its megawatts continuously,
+ * except the ones bolted to a hardpoint: weapons and most utility fittings only draw
+ * while the hardpoints are **deployed**, which is why a build has two totals. Each
+ * module sits in one of five **priority groups**; when the draw exceeds what the plant
+ * makes, the game keeps groups powered from group 1 down and shuts off the first group
+ * whose running total would go over, along with everything below it.
+ *
+ * This module is data-free: hand {@link powerBudget} the plant's capacity and a
+ * {@link PowerConsumer} per fitted module. {@link ShipLoadout.powerBudget} (in
+ * `./ship-loadout`) builds that list from a build for you, post-engineering.
+ *
+ * @remarks
+ * Reference implementation: EDCD/Coriolis, `src/app/shipyard/Ship.js`
+ * (`updatePowerUsed`, `powerUsageType`, `getSlotStatus`), commit
+ * `68c042ca6e3db62372cbbb2077cf972345511712`. The algorithm is ported as fact, not code;
+ * credit and licence terms are in [ATTRIBUTIONS.md](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/ATTRIBUTIONS.md).
+ *
+ * @example
+ * ```ts
+ * import { powerBudget } from '@elite-dangerous-almanac/core/ships/power';
+ *
+ * powerBudget(20.4, [
+ *   { draw: 0.45, priority: 1 },                       // life support
+ *   { draw: 5.72, priority: 1 },                       // thrusters
+ *   { draw: 2.48, priority: 3, deployedOnly: true },   // a beam laser
+ * ]).deployed; // -> 8.65
+ * ```
+ *
+ * @packageDocumentation
+ */
+/** One fitted module's claim on the power plant. */
+interface PowerConsumer {
+    /**
+     * Power draw, in megawatts, post-engineering. Required and finite non-negative
+     * unless {@link drawUnknown} is `true`; ignored when the draw is unknown.
+     */
+    readonly draw?: number;
+    /**
+     * Priority group, `1`–`5`, as the outfitting panel numbers them. Defaults to `1`.
+     *
+     * @remarks
+     * The journal's `Priority` field is **zero-based** — its `0` is this `1`. Values
+     * outside `1`–`5` are clamped into range.
+     */
+    readonly priority?: number;
+    /** Whether the module is switched on. Defaults to `true`; a module switched off draws nothing. */
+    readonly enabled?: boolean;
+    /**
+     * `true` for a module that only draws while the hardpoints are deployed — every
+     * weapon, and the utility fittings that are not
+     * {@link OutfittingModule.alwaysPowered | always powered}. Defaults to `false` for
+     * a known draw. An unresolved utility consumer may omit this along with `draw`,
+     * because whether that fitting is always powered cannot be determined either;
+     * {@link powerBudget} ignores both fields when {@link drawUnknown} is `true`.
+     */
+    readonly deployedOnly?: boolean;
+    /**
+     * `true` when the module's power draw cannot be determined. Its
+     * {@link PowerConsumer.draw | draw} is ignored and the consumer is named in
+     * {@link PowerBudget.unknownDraws} instead of being counted as `0`.
+     */
+    readonly drawUnknown?: boolean;
+    /**
+     * Optional label for the module — the journal slot key when
+     * {@link ShipLoadout.powerBudget} builds the consumer. Ignored by the maths, but it
+     * is how a consumer reported in {@link PowerBudget.unknownDraws} names itself.
+     */
+    readonly label?: string;
+}
+/** One priority group's share of the power budget. */
+interface PowerBand {
+    /** The group number, `1`–`5`. */
+    readonly priority: number;
+    /** This group's own draw with hardpoints retracted, in megawatts. */
+    readonly retracted: number;
+    /**
+     * This group's own draw with hardpoints deployed, in megawatts — everything in
+     * {@link PowerBand.retracted} plus the weapons, which only draw once the hardpoints
+     * are out. Always ≥ `retracted`.
+     */
+    readonly deployed: number;
+    /** Draw of this group and every higher-priority one, retracted, in megawatts. */
+    readonly retractedTotal: number;
+    /** Draw of this group and every higher-priority one, deployed, in megawatts. */
+    readonly deployedTotal: number;
+    /** Whether this group stays powered with hardpoints retracted. */
+    readonly poweredRetracted: boolean;
+    /** Whether this group stays powered with hardpoints deployed. */
+    readonly poweredDeployed: boolean;
+}
+/** What a build's power plant makes and what the build asks of it. */
+interface PowerBudget {
+    /** Power the plant generates, in megawatts, post-engineering. */
+    readonly available: number;
+    /** Total draw with hardpoints retracted, in megawatts. */
+    readonly retracted: number;
+    /** Total draw with hardpoints deployed, in megawatts — the figure that must fit. */
+    readonly deployed: number;
+    /** `available − deployed`, in megawatts. Negative means the build is over budget. */
+    readonly headroom: number;
+    /**
+     * `deployed / available`, as a fraction (`0.93` = 93% of the plant used).
+     * `Infinity` when a build draws power with no plant fitted, `0` when it draws none.
+     */
+    readonly utilisation: number;
+    /** Whether the whole build stays powered with hardpoints deployed. */
+    readonly withinBudget: boolean;
+    /**
+     * The five priority groups, `1` first. A group is powered when its running total —
+     * its own draw plus every higher-priority group's — fits in `available`.
+     */
+    readonly bands: readonly PowerBand[];
+    /**
+     * The **enabled** consumers whose draw is unknown ({@link PowerConsumer.drawUnknown}),
+     * handed straight back so a caller can name them — by
+     * {@link PowerConsumer.label | label}, which is the journal slot key when
+     * {@link ShipLoadout.powerBudget} built the list, or by identity for a
+     * hand-assembled one. A switched-off module is skipped before the flag is read, so
+     * it never appears here. Normally empty.
+     *
+     * **While it is not empty, every other figure here is a lower bound.** The unknown
+     * draws contribute nothing to `retracted`, `deployed` or the bands, so `headroom`
+     * and `utilisation` read too favourably and `withinBudget` and `poweredDeployed`
+     * answer only for the draws that are known. The budget is still reported rather
+     * than refused — the per-band detail is worth having, and one unknown module is not
+     * a reason to withhold the other twenty — but a caller showing it should say so.
+     */
+    readonly unknownDraws: readonly PowerConsumer[];
+}
+/**
+ * Work out a build's power budget: what the plant makes, what the modules draw
+ * retracted and deployed, and which priority groups survive.
+ *
+ * @param available - Power the plant generates, in megawatts (`0` when no plant is
+ * fitted — every group then reads as unpowered). Must be finite and non-negative.
+ * @param consumers - One entry per fitted module. Modules with `enabled: false` are
+ * skipped; the rest fall into their {@link PowerConsumer.priority | priority} group.
+ * @returns The {@link PowerBudget}.
+ * @throws {RangeError} If `available`, or an enabled known consumer's `draw`, is not a
+ * finite non-negative number. Disabled consumers and consumers marked `drawUnknown`
+ * are skipped before their placeholder draw is validated.
+ * @remarks
+ * A group that draws *exactly* the power available stays online, matching the game —
+ * only going over shuts anything down.
+ *
+ * A consumer flagged {@link PowerConsumer.drawUnknown} is left out of every total and
+ * listed in {@link PowerBudget.unknownDraws}, which makes the rest of the answer a
+ * lower bound rather than silently adding the module up as drawing nothing.
+ * @example
+ * ```ts
+ * import { powerBudget } from '@elite-dangerous-almanac/core/ships/power';
+ *
+ * const budget = powerBudget(4.8, [
+ *   { draw: 3.0, priority: 1 },
+ *   { draw: 2.0, priority: 4 },  // over budget: this group goes dark
+ * ]);
+ * budget.withinBudget;               // -> false
+ * budget.bands[3]?.poweredDeployed;  // -> false
+ * budget.bands[0]?.poweredDeployed;  // -> true (priority 1 keeps its power)
+ * ```
+ */
+declare function powerBudget(available: number, consumers: readonly PowerConsumer[]): PowerBudget;
+
+export { type PowerBand, type PowerBudget, type PowerConsumer, powerBudget };

package/dist/ships/power.js

@@ -0,0 +1 @@
+export{powerBudget}from"../chunk-76XKY2Y2.js";//# sourceMappingURL=power.js.map

package/dist/ships/power.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

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

@@ -0,0 +1,147 @@
+import { OutfittingModule } from './modules.js';
+import { PreEngineeredVariant } from './pre-engineered.js';
+import { EngineeringModifier, LoadoutModule } from './slef.js';
+import './engineering-options.js';
+import './slots.js';
+
+/**
+ * Resolving a **pre-engineered variant into a fittable module** — the base module's
+ * catalogue record with the variant's hand-set stat changes applied.
+ *
+ * A {@link PreEngineeredVariant} on its own is a pairing, not a module: it names the
+ * base `symbol` and the engineering baked into it. To build a ship with one you need the
+ * resolved article — mass, power draw, integrity and the rest as the variant actually
+ * 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 334.4 KiB
+ * minified in a consumer bundle; the complete runtime API is 362.9 KiB (38.0 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
+ * {@link identifyPreEngineeredVariant}: it matches the article's reported stat signature
+ * and composes an experimental effect added after purchase before comparing values.
+ *
+ * **What is resolved, and what is not.** The module catalogues carry the mechanical
+ * stats (mass, integrity, power, capacities, optimal mass), defence stats and weapon
+ * stats. {@link unresolvedModifiers} reports any unresolvable label instead of dropping
+ * it.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * The journal-style modifiers a pre-engineered variant applies to its base module.
+ *
+ * Includes the variant's baked experimental effect. Only labels the module catalogues
+ * carry a base value for can be computed; unsupported hand-set labels are listed by
+ * {@link unresolvedModifiers}. The result is the same shape a journal `Loadout` reports
+ * under `Engineering.Modifiers`, so it can be used to construct one.
+ *
+ * @param variant - A pre-engineered variant.
+ * @returns One modifier per computable label, or an empty array when the variant carries
+ * no stat block (every `mercenary` row) or its symbol is unknown.
+ *
+ * @example
+ * ```ts
+ * import { getPreEngineeredByBlueprint } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ * import { getPreEngineeredModifiers } from '@elite-dangerous-almanac/core/ships/pre-engineered-stats';
+ *
+ * const [railgun] = getPreEngineeredByBlueprint('Weapon_HighCapacity');
+ * if (railgun) getPreEngineeredModifiers(railgun);
+ * // -> [{ Label: 'Mass', Value: 2.85, OriginalValue: 1.5 }, ...]
+ * ```
+ */
+declare function getPreEngineeredModifiers(variant: PreEngineeredVariant): EngineeringModifier[];
+/**
+ * Identify the fixed pre-engineered/reward variant described by a fitted loadout module.
+ *
+ * Matching uses the reported post-engineering stat values rather than trusting the
+ * blueprint tuple alone: reward variants carry hand-set values that an ordinary roll of
+ * the named blueprint does not reproduce. A captured experimental effect is composed
+ * with each candidate before comparison, because some fixed articles accept an effect
+ * after purchase (the V1 frame-shift drives are the common example).
+ *
+ * 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.
+ * Variants without a published stat block cannot be identified this way.
+ *
+ * @param module - A module from a journal `Loadout` event or SLEF export.
+ * @returns The uniquely matching catalogue variant, or `null` when the stats do not
+ * identify one.
+ * @throws {TypeError} If a field it reads is present and not a string — `module.Item`,
+ * or a modifier's `Label` or the block's `ExperimentalEffect`. A module with no
+ * engineering block answers `null` before any of them is read.
+ *
+ * @example
+ * ```ts
+ * import { identifyPreEngineeredVariant } from '@elite-dangerous-almanac/core/ships/pre-engineered-stats';
+ * import type { LoadoutEvent } from '@elite-dangerous-almanac/core/ships/slef';
+ *
+ * declare const loadoutEvent: LoadoutEvent;
+ *
+ * const fitted = loadoutEvent.Modules.find((m) => m.Slot === 'FrameShiftDrive')!;
+ * identifyPreEngineeredVariant(fitted)?.acquisition; // -> 'techBroker', or null
+ * ```
+ */
+declare function identifyPreEngineeredVariant(module: LoadoutModule): PreEngineeredVariant | null;
+/**
+ * The labels a variant modifies that cannot be computed for its particular base module.
+ *
+ * This includes labels the catalogues do not model at all and known fields whose base
+ * value is absent from this particular module. Reporting these labels lets a consumer
+ * distinguish "this variant changes nothing else" from "this catalogue cannot say".
+ * Every catalogue variant returns an empty array.
+ *
+ * @param variant - A pre-engineered variant.
+ * @returns The unresolvable labels, in the variant's own order.
+ *
+ * @example
+ * ```ts
+ * import type { PreEngineeredVariant } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ * import { unresolvedModifiers } from '@elite-dangerous-almanac/core/ships/pre-engineered-stats';
+ *
+ * declare const railgun: PreEngineeredVariant;
+ *
+ * unresolvedModifiers(railgun); // -> []  (every label it changes resolves)
+ * ```
+ */
+declare function unresolvedModifiers(variant: PreEngineeredVariant): string[];
+/**
+ * A pre-engineered variant resolved into a module record you can fit.
+ *
+ * Returns the base module's catalogue record with every stat the variant modifies — and
+ * that the catalogue carries — replaced by its engineered value. `symbol`, `name`,
+ * `class`, `rating` and `cost` are the base module's throughout: a pre-engineered
+ * variant is the same article with different numbers, not a different module. A final
+ * variant also carries `engineeringLocked: true`, so fitting the resolved article keeps
+ * that restriction.
+ * Exact damage components scale with an engineered `damage` value so their proportions
+ * and the anti-xeno overlay remain coherent with the resolved scalar.
+ *
+ * A variant with no stat block (every `mercenary` row) resolves to the base record
+ * unchanged, which is the honest answer — the pre-engineering those arrive with is not
+ * published anywhere, so the catalogue does not guess at it.
+ *
+ * @param variant - A pre-engineered variant.
+ * @returns The resolved module record, or `null` when the variant's symbol is not in the
+ * module catalogues.
+ *
+ * @example
+ * ```ts
+ * import { getModuleBySymbol } from '@elite-dangerous-almanac/core/ships/modules';
+ * import { getPreEngineeredVariants } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ * import { getPreEngineeredStats } from '@elite-dangerous-almanac/core/ships/pre-engineered-stats';
+ *
+ * const shard = getPreEngineeredVariants('Hpt_Guardian_ShardCannon_Fixed_Medium')[0]!;
+ * const stock = getModuleBySymbol(shard.symbol)!;
+ * const fitted = getPreEngineeredStats(shard)!;
+ * stock.mass;  // -> 4
+ * fitted.mass; // -> 6  (the variant carries Mass +50%)
+ * ```
+ */
+declare function getPreEngineeredStats(variant: PreEngineeredVariant): OutfittingModule | null;
+
+export { getPreEngineeredModifiers, getPreEngineeredStats, identifyPreEngineeredVariant, unresolvedModifiers };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

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

@@ -0,0 +1,215 @@
+/**
+ * The **pre-engineered module catalogue** — the outfitting rows you buy already
+ * engineered, each paired with the base module it fits as and the blueprint baked in.
+ *
+ * A pre-engineered module has **no symbol of its own**. The game sells an ordinary
+ * module with engineering already applied, so a journal `Loadout` reports the base
+ * `symbol` plus an `Engineering` block — which is why you will not find, say, a
+ * `Hpt_Railgun_Fixed_Medium_Merc` in the module catalogues. This catalogue supplies the
+ * link that would otherwise be missing: which stock modules are purchasable
+ * pre-engineered, and with what.
+ *
+ * Its own module (and data file) so consumers who never touch pre-engineered variants
+ * do not bundle it.
+ *
+ * Each entry is a {@link PreEngineeredVariant}: `symbol` joins to the module catalogues,
+ * `blueprint` to `BLUEPRINTS`, and `grade` is the grade already applied at purchase.
+ * Because grade 1 is what the bought module already contains, these blueprints' own
+ * recipes start at grade 2 — price the remaining upgrade with
+ * `getBlueprintCost(blueprint, target, grade)` from `ships/blueprint-costs`.
+ *
+ * Note that one base module can appear more than once: the medium Seeker Missile Rack is
+ * sold or awarded in six different pre-engineered flavours, so
+ * `Hpt_BasicMissileRack_Fixed_Medium` has six entries. Look variants up with
+ * {@link getPreEngineeredVariants} (plural) rather than assuming one.
+ *
+ * Most variants carry a {@link PreEngineeredVariant.modifiers} block — the hand-set stat
+ * changes the variant arrives with, which is what lets one be fitted and its stats
+ * computed. Resolve them against the base module with `getPreEngineeredStats` from
+ * `./pre-engineered-stats.js`; it lives in its own module so that consumers who only
+ * want the catalogue do not bundle the module and engineering tables.
+ * The only pre-engineered Guardian variants are seven Guardian-weapon records. They are
+ * final articles and carry {@link PreEngineeredVariant.engineeringLocked}; their stock
+ * counterparts can take Anti-Guardian Zone Resistance, but the resolved pre-engineered
+ * articles cannot.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Where a pre-engineered variant is obtained.
+ *
+ * - `mercenary` — bought from the Merc-Coin shop; always arrives at grade 1.
+ * - `communityGoal` — awarded for taking part in a community goal; mostly grade 5, and
+ *   often carrying an experimental effect the shop rows do not.
+ * - `techBroker` — unlocked at a tech broker. Records the route stated by the source.
+ */
+type PreEngineeredAcquisition = 'mercenary' | 'communityGoal' | 'techBroker';
+/**
+ * One hand-set stat change a pre-engineered variant arrives with.
+ *
+ * Same vocabulary as a blueprint feature or experimental contribution: a journal
+ * Modifier `label`, the `method` by which it applies, and its `value`. Unlike a
+ * blueprint feature there is no `min`/`max` — a pre-engineered variant is a fixed
+ * article, not a roll.
+ */
+interface PreEngineeredModifier {
+    /** Journal Modifier Label, e.g. `"PowerDraw"`, `"ArmourPenetration"`. */
+    readonly label: string;
+    /** How the value applies to the base stat. */
+    readonly method: 'multiplicative' | 'additive' | 'overwrite';
+    /**
+     * The modifier value: a fraction for `multiplicative` (`0.5` is `+50%`), an absolute
+     * delta for `additive`, and the replacement value for `overwrite`.
+     */
+    readonly value: number;
+}
+/**
+ * One purchasable pre-engineered module variant — a pairing of a stock module with the
+ * blueprint it ships with, not a module in its own right.
+ */
+interface PreEngineeredVariant {
+    /** The base module's symbol, e.g. `"Hpt_Railgun_Fixed_Medium"`. Joins to the module catalogues. */
+    readonly symbol: string;
+    /** The base module's display name, e.g. `"Rail Gun"`. */
+    readonly name: string;
+    /**
+     * The blueprint recipe's Frontier `fdname`, e.g. `"RailGun_LongShot"`. Joins to
+     * `BLUEPRINTS`.
+     *
+     * @remarks
+     * On a reward variant this **identifies** the article rather than reproducing it.
+     * Alongside its blueprint and effect, a reward carries hand-set modifier overrides no
+     * blueprint grants — that is what makes it a reward rather than a shortcut — so
+     * rolling this recipe to this {@link PreEngineeredVariant.grade | grade} does not
+     * arrive at the same module, and `getBlueprintCost` (in `ships/blueprint-costs`)
+     * against it prices ordinary engineering rather than the reward. Read
+     * {@link PreEngineeredVariant.modifiers | modifiers} for what the article actually
+     * carries.
+     */
+    readonly blueprint: string;
+    /** The blueprint grade already applied (1–5). */
+    readonly grade: number;
+    /**
+     * The experimental effect's Frontier `fdname`, e.g.
+     * `"special_feedback_cascade_cooled"`. Joins to `EXPERIMENTAL_EFFECTS`. Absent when
+     * the variant carries none.
+     */
+    readonly experimental?: string;
+    /** Where the variant comes from. */
+    readonly acquisition: PreEngineeredAcquisition;
+    /**
+     * Whether the article is final and accepts no further engineering.
+     *
+     * @remarks
+     * Present as `true` on the pre-engineered Guardian weapons. Their stock counterparts
+     * can take Anti-Guardian Zone Resistance, but the pre-engineered articles cannot:
+     * neither that recipe nor any ordinary weapon recipe may be applied to them.
+     * Absence means this catalogue does not lock further engineering.
+     */
+    readonly engineeringLocked?: true;
+    /**
+     * The shop price in Merc Coin. Present only on `mercenary` rows — the other routes
+     * are not bought with a currency. Merc Coin has no credit equivalent, which is why
+     * this is separate from the credit `cost` a module carries.
+     */
+    readonly mercCoinCost?: number;
+    /**
+     * The hand-set stat block the variant arrives with, sorted by `label`.
+     *
+     * Absent on every `mercenary` row: no registry publishes the grade-1 pre-engineering
+     * those arrive with. Present on all 51 community-goal and tech-broker rows.
+     */
+    readonly modifiers?: readonly PreEngineeredModifier[];
+}
+/**
+ * Every purchasable pre-engineered module variant.
+ *
+ * @remarks
+ * This catalogue omits pre-engineered Guardian module rewards whose variant details have
+ * no traceable source. The gap is tracked at
+ * https://github.com/DarkSession/Elite-Dangerous-Almanac/issues/224.
+ *
+ * @example
+ * ```ts
+ * import { PRE_ENGINEERED_MODULES } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ *
+ * PRE_ENGINEERED_MODULES.length; // -> 73
+ * PRE_ENGINEERED_MODULES[0];
+ * // -> { symbol: 'Hpt_Mining_AbrBlstr_Fixed_Small', name: 'Abrasion Blaster',
+ * //      blueprint: 'AbrasionBlaster_FarReaching', grade: 1,
+ * //      acquisition: 'mercenary', mercCoinCost: 400 }
+ * ```
+ */
+declare const PRE_ENGINEERED_MODULES: readonly PreEngineeredVariant[];
+/**
+ * Every pre-engineered variant sold for a given base module symbol.
+ *
+ * Matching is case-insensitive and tolerates surrounding whitespace, so a raw journal
+ * value can be passed straight in. Returns an empty array when the module is not sold
+ * pre-engineered — never `null`, so the result is always safe to iterate.
+ *
+ * @param symbol - A module symbol, e.g. `"Hpt_BasicMissileRack_Fixed_Medium"`.
+ * @returns Every pre-engineered variant of that module, in catalogue order.
+ *
+ * @throws {TypeError} If `symbol` is present and not a string. A nullish
+ * `symbol` is a miss, answered the way an unrecognised one is.
+ * @example
+ * ```ts
+ * import { getPreEngineeredVariants } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ *
+ * getPreEngineeredVariants('Hpt_BasicMissileRack_Fixed_Medium').map((v) => v.blueprint);
+ * // -> ['SeekerMissileRack_Drag',
+ * //     'SeekerMissileRack_LightWeightThermal',
+ * //     'SeekerMissileRackMedium_Lockdown',
+ * //     'Weapon_HighCapacity', 'Weapon_HighCapacity', 'Weapon_HighCapacity']
+ *
+ * getPreEngineeredVariants('Int_Hyperdrive_Size2_Class1'); // -> []
+ * ```
+ */
+declare function getPreEngineeredVariants(symbol: string): readonly PreEngineeredVariant[];
+/**
+ * Every pre-engineered variant sold with a given blueprint.
+ *
+ * One blueprint can be sold on more than one base module — the Drag seeker
+ * pre-engineering, for instance, is offered on both the medium and the large missile
+ * rack — so this returns an array. Matching is case-insensitive and trims whitespace,
+ * and a miss is an empty array rather than `null`.
+ *
+ * @param fdname - A blueprint recipe `fdname`, e.g. `"RailGun_LongShot"`.
+ * @returns Every variant sold with that blueprint, in catalogue order.
+ *
+ * @throws {TypeError} If `fdname` is present and not a string. A nullish
+ * `fdname` is a miss, answered the way an unrecognised one is.
+ * @example
+ * ```ts
+ * import { getPreEngineeredByBlueprint } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ *
+ * getPreEngineeredByBlueprint('RailGun_LongShot').map((v) => v.symbol);
+ * // -> ['Hpt_Railgun_Fixed_Medium']
+ *
+ * getPreEngineeredByBlueprint('SeekerMissileRack_Drag').map((v) => v.symbol);
+ * // -> ['Hpt_BasicMissileRack_Fixed_Medium', 'Hpt_BasicMissileRack_Fixed_Large']
+ *
+ * getPreEngineeredByBlueprint('NoSuchBlueprint'); // -> []
+ * ```
+ */
+declare function getPreEngineeredByBlueprint(fdname: string): readonly PreEngineeredVariant[];
+/**
+ * Whether a module is sold in at least one pre-engineered form.
+ *
+ * @param symbol - A module symbol.
+ * @returns `true` when {@link getPreEngineeredVariants} would return anything.
+ *
+ * @throws {TypeError} If `symbol` is present and not a string. A nullish
+ * `symbol` is a miss, answered the way an unrecognised one is.
+ * @example
+ * ```ts
+ * import { isPreEngineered } from '@elite-dangerous-almanac/core/ships/pre-engineered';
+ *
+ * isPreEngineered('Hpt_Railgun_Fixed_Medium'); // -> true
+ * isPreEngineered('Int_Hyperdrive_Size2_Class1'); // -> false
+ * ```
+ */
+declare function isPreEngineered(symbol: string): boolean;
+
+export { PRE_ENGINEERED_MODULES, type PreEngineeredAcquisition, type PreEngineeredModifier, type PreEngineeredVariant, getPreEngineeredByBlueprint, getPreEngineeredVariants, isPreEngineered };

package/dist/ships/pre-engineered.js

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}