@eveshipfit/fitting 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 EVEShipFit Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,68 @@
+# @eveshipfit/fitting
+
+EVE Online ship fits that recalculate themselves, on top of
+[`@eveshipfit/dogma-engine`](https://www.npmjs.com/package/@eveshipfit/dogma-engine).
+
+Part of [EVEShip.fit](https://eveship.fit).
+
+## Install
+
+```sh
+npm install @eveshipfit/fitting @eveshipfit/dogma-engine @eveshipfit/sde-loader @eveshipfit/sde
+```
+
+## Usage
+
+The examples use Vite's `?url` imports to get the URL of a data file.
+
+```ts
+import wasmUrl from "@eveshipfit/dogma-engine/esf_dogma_engine_bg.wasm?url";
+import { createEngine } from "@eveshipfit/fitting";
+import sdeUrl from "@eveshipfit/sde/dist/sde.dat?url";
+import { loadSde } from "@eveshipfit/sde-loader";
+
+const engine = await createEngine(await loadSde({ url: sdeUrl }), { wasm: wasmUrl });
+
+const fit = engine.createFit({ ship: 587 }); // a Rifter
+fit.fit(engine.sde.typeByName("200mm AutoCannon II")!.id); // first free high slot
+fit.fit(engine.sde.typeByName("EMP S")!.id); // loaded into every gun that takes it
+
+const { stats } = fit.getSnapshot();
+stats.ship.get("cpuLoad");
+stats.slots.high; // { used: 1, total: 3 }
+stats.violations; // the fitting rules the fit breaks
+
+fit.undo();
+```
+
+The engine can hold only one SDE per page; `createEngine` with another one throws.
+
+A fit is flown by a character with every skill at V, unless you pass another to `createFit` or `setCharacter`.
+
+### React
+
+`subscribe` and `getSnapshot` are bound, so a store goes straight into `useSyncExternalStore`:
+
+```ts
+const { fit, stats } = useSyncExternalStore(store.subscribe, store.getSnapshot);
+```
+
+Every change gives a new snapshot; old ones never change.
+
+### Previews
+
+`preview` shows what an edit would do, without doing it:
+
+```ts
+const { before, after } = fit.preview((draft) => draft.fit(typeId));
+after.stats.ship.get("cpuLoad")! - before.stats.ship.get("cpuLoad")!;
+```
+
+### Rules
+
+`placementOf`, `canFit`, `acceptsCharge` and `chargesFor` say where a type goes, whether a module fits a hull, and
+which charges go in a module; for example to filter a market browser.
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,155 @@
+import { Calculation, Character, Fit, FitItem, InitInput, ItemResult, Rule, Slot, Slot as Slot$1, State, Violation } from "@eveshipfit/dogma-engine";
+import { Sde, SdeType } from "@eveshipfit/sde-loader";
+//#region src/types.d.ts
+type SlotType = Slot$1["type"];
+/** The racks a ship has a fixed number of numbered slots in. */
+type Rack = "high" | "medium" | "low" | "rig" | "subsystem" | "service";
+/** An item of a fit, as its index into `fit.items`. */
+type ItemRef = number;
+//#endregion
+//#region src/character.d.ts
+/** A character with every published skill at `level`. */
+export declare function allSkills(sde: Sde, level: number): Character;
+//#endregion
+//#region src/stats.d.ts
+interface Usage {
+  readonly used: number;
+  readonly total: number;
+}
+/** Calculated attributes of one thing in the fit, by name or by ID. */
+export declare class Attributes {
+  #private;
+  constructor(sde: Sde, result: ItemResult);
+  /** The value after every effect applied. */
+  get(attribute: string | number): number | undefined;
+  /** The value before any effect applied. */
+  base(attribute: string | number): number | undefined;
+}
+interface ItemStats {
+  /** The state reached, which can be lower than the one asked for. */
+  readonly state: State;
+  readonly maxState: State;
+  readonly attributes: Attributes;
+  readonly charge: Attributes | undefined;
+}
+/** A calculation of a fit, with named access and the totals a fitting window shows. */
+export declare class Stats {
+  readonly calculation: Calculation;
+  readonly ship: Attributes;
+  readonly character: Attributes;
+  readonly mode: Attributes | undefined;
+  /** Index-parallel to `fit.items`. */
+  readonly items: readonly ItemStats[];
+  /** Every fitting rule the fit breaks; empty when it can be flown as is. */
+  readonly violations: readonly Violation[];
+  readonly slots: Readonly<Record<Rack, Usage>>;
+  readonly hardpoints: {
+    readonly turret: Usage;
+    readonly launcher: Usage;
+  };
+  /** In m³. */
+  readonly cargo: Usage;
+  constructor(sde: Sde, fit: Fit, calculation: Calculation);
+}
+//#endregion
+//#region src/edits.d.ts
+export declare function emptyFit(shipTypeId: number): Fit;
+//#endregion
+//#region src/store.d.ts
+interface Snapshot {
+  /** Without `character`; who flies the fit is set on the store. */
+  readonly fit: Fit;
+  readonly stats: Stats;
+}
+interface Preview {
+  readonly before: Snapshot;
+  readonly after: Snapshot;
+}
+interface Calculator {
+  readonly sde: Sde;
+  calculate(fit: Fit, character: Character): Stats;
+}
+/**
+ * A fit that recalculates itself on every change. `subscribe` and
+ * `getSnapshot` are bound, so they can go straight into `useSyncExternalStore`.
+ */
+export declare class FitStore {
+  #private;
+  constructor(calculator: Calculator, fit: Fit, character: Character);
+  getSnapshot: () => Snapshot;
+  subscribe: (listener: () => void) => (() => void);
+  get character(): Character;
+  get canUndo(): boolean;
+  get canRedo(): boolean;
+  /** Picks the rack and the first free slot, unless `slot` says where. */
+  fit(typeId: number, slot?: Slot): ItemRef | undefined;
+  remove(ref: ItemRef): void;
+  setState(ref: ItemRef, state: State): void;
+  setCharge(ref: ItemRef, chargeTypeId: number | undefined): void;
+  setQuantity(ref: ItemRef, quantity: number): void;
+  setName(name: string): void;
+  /** Swap in another fit entirely, like an import; undo brings the old one back. */
+  replace(fit: Fit): void;
+  /** Who flies the fit is not an edit of it, so this does not go in the history. */
+  setCharacter(character: Character): void;
+  undo(): void;
+  redo(): void;
+  /** What `edit` would do, without doing it. */
+  preview(edit: (fit: FitStore) => void): Preview;
+}
+//#endregion
+//#region src/engine.d.ts
+interface EngineOptions {
+  /** Where to load the WASM from; by default, next to the engine's JavaScript. */
+  wasm?: InitInput;
+}
+export declare function createEngine(sde: Sde, options?: EngineOptions): Promise<Engine>;
+export declare class Engine implements Calculator {
+  #private;
+  readonly sde: Sde;
+  constructor(sde: Sde);
+  /** Every published skill at level V; what a fit is flown by until told otherwise. */
+  get defaultCharacter(): Character;
+  createFit(fit: Fit | {
+    ship: number;
+  }, character?: Character): FitStore;
+  calculate(fit: Fit, character?: Character): Stats;
+}
+//#endregion
+//#region src/rules/attributes.d.ts
+/** A type's value for an attribute as the SDE has it, before any effect applies. */
+export declare function baseValue(sde: Sde, type: SdeType, name: string): number | undefined;
+//#endregion
+//#region src/rules/filters.d.ts
+/** Whether `module` can load `charge`: the right group, the right size, and room for at least one. */
+export declare function acceptsCharge(sde: Sde, module: SdeType, charge: SdeType): boolean;
+/** Every published charge `module` can load, sorted by name. */
+export declare function chargesFor(sde: Sde, module: SdeType): SdeType[];
+/**
+ * Whether `type` may go on `ship` at all: hull restrictions, rig size and
+ * subsystems of the right hull. Whether there is room left is the
+ * calculation's job, as that depends on the rest of the fit.
+ */
+export declare function canFit(sde: Sde, type: SdeType, ship: SdeType): boolean;
+//#endregion
+//#region src/rules/placement.d.ts
+type Placement = {
+  type: Exclude<Rack, "subsystem">;
+} |
+/** Implants, boosters and subsystems each have one slot they go in. */
+{
+  type: "implant" | "booster" | "subsystem";
+  index: number;
+} | {
+  type: "drone_bay" | "fighter_bay" | "cargo";
+} |
+/** Loaded into a module; `cargo` when no module takes it. */
+{
+  type: "charge";
+};
+/** Where an item of this type goes when fitted; `undefined` for what cannot be part of a fit, like a ship. */
+export declare function placementOf(sde: Sde, type: SdeType): Placement | undefined;
+/** The lowest slot index in `rack` nothing is fitted in, if below `available`. */
+export declare function firstFreeIndex(fit: Fit, rack: SlotType, available: number): number | undefined;
+//#endregion
+export type { Calculation, Calculator, Character, EngineOptions, Fit, FitItem, ItemRef, ItemResult, ItemStats, Placement, Preview, Rack, Rule, Slot, SlotType, Snapshot, State, Usage, Violation };

package/dist/index.mjs

@@ -0,0 +1,571 @@
+import init, { calculate, load_sde } from "@eveshipfit/dogma-engine";
+//#region src/ids.ts
+/** Well-known IDs from the SDE; CCP does not renumber these. */
+const Category = {
+	Ship: 6,
+	Module: 7,
+	Charge: 8,
+	Skill: 16,
+	Drone: 18,
+	Implant: 20,
+	Subsystem: 32,
+	Fighter: 87
+};
+const Effect = {
+	LowPower: 11,
+	HighPower: 12,
+	MediumPower: 13,
+	LauncherFitted: 40,
+	TurretFitted: 42,
+	RigSlot: 2663,
+	Subsystem: 3772,
+	ServiceSlot: 6306
+};
+//#endregion
+//#region src/character.ts
+/** A character with every published skill at `level`. */
+function allSkills(sde, level) {
+	const skills = {};
+	for (const type of sde.types()) if (type.categoryId === Category.Skill && type.published) skills[type.id] = level;
+	return { skills };
+}
+//#endregion
+//#region src/rules/attributes.ts
+/** A type's value for an attribute as the SDE has it, before any effect applies. */
+function baseValue(sde, type, name) {
+	const id = sde.attributeId(name);
+	return id === void 0 ? void 0 : type.attributes.get(id);
+}
+/** Every value of a numbered attribute family, like `chargeGroup1` to `chargeGroup5`. */
+function baseValues(sde, type, names) {
+	const values = [];
+	for (const name of names) {
+		const value = baseValue(sde, type, name);
+		if (value !== void 0) values.push(value);
+	}
+	return values;
+}
+//#endregion
+//#region src/rules/filters.ts
+const chargeGroups = [
+	"chargeGroup1",
+	"chargeGroup2",
+	"chargeGroup3",
+	"chargeGroup4",
+	"chargeGroup5"
+];
+const shipGroups = Array.from({ length: 20 }, (_, i) => `canFitShipGroup${String(i + 1).padStart(2, "0")}`);
+const shipTypes = Array.from({ length: 12 }, (_, i) => `canFitShipType${i + 1}`);
+/** Whether `module` can load `charge`: the right group, the right size, and room for at least one. */
+function acceptsCharge(sde, module, charge) {
+	if (charge.categoryId !== Category.Charge) return false;
+	if (!baseValues(sde, module, chargeGroups).includes(charge.groupId)) return false;
+	const size = baseValue(sde, module, "chargeSize");
+	if (size !== void 0 && baseValue(sde, charge, "chargeSize") !== size) return false;
+	return (charge.volume ?? 0) <= (module.capacity ?? 0);
+}
+/** Every published charge `module` can load, sorted by name. */
+function chargesFor(sde, module) {
+	const groups = new Set(baseValues(sde, module, chargeGroups));
+	if (groups.size === 0) return [];
+	const charges = [];
+	for (const type of sde.types()) if (type.published && groups.has(type.groupId) && acceptsCharge(sde, module, type)) charges.push(type);
+	return charges.toSorted((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Whether `type` may go on `ship` at all: hull restrictions, rig size and
+* subsystems of the right hull. Whether there is room left is the
+* calculation's job, as that depends on the rest of the fit.
+*/
+function canFit(sde, type, ship) {
+	const groups = baseValues(sde, type, shipGroups);
+	const types = baseValues(sde, type, shipTypes);
+	if ((groups.length > 0 || types.length > 0) && !groups.includes(ship.groupId) && !types.includes(ship.id)) return false;
+	const rigSize = baseValue(sde, type, "rigSize");
+	if (rigSize !== void 0 && rigSize !== baseValue(sde, ship, "rigSize")) return false;
+	const hull = baseValue(sde, type, "fitsToShipType");
+	if (hull !== void 0 && hull !== ship.id) return false;
+	return true;
+}
+//#endregion
+//#region src/rules/placement.ts
+const rackEffects = [
+	[Effect.HighPower, "high"],
+	[Effect.MediumPower, "medium"],
+	[Effect.LowPower, "low"],
+	[Effect.RigSlot, "rig"],
+	[Effect.ServiceSlot, "service"]
+];
+/** Where an item of this type goes when fitted; `undefined` for what cannot be part of a fit, like a ship. */
+function placementOf(sde, type) {
+	switch (type.categoryId) {
+		case Category.Ship: return;
+		case Category.Charge: return { type: "charge" };
+		case Category.Drone: return { type: "drone_bay" };
+		case Category.Fighter: return { type: "fighter_bay" };
+		case Category.Subsystem: {
+			const flag = baseValue(sde, type, "subSystemSlot");
+			return flag === void 0 ? void 0 : {
+				type: "subsystem",
+				index: flag - 125
+			};
+		}
+		case Category.Implant: {
+			const implant = baseValue(sde, type, "implantness");
+			if (implant !== void 0) return {
+				type: "implant",
+				index: implant
+			};
+			const booster = baseValue(sde, type, "boosterness");
+			if (booster !== void 0) return {
+				type: "booster",
+				index: booster
+			};
+			return { type: "cargo" };
+		}
+	}
+	for (const [effect, rack] of rackEffects) if (type.effectIds.has(effect)) return { type: rack };
+	return { type: "cargo" };
+}
+/** The lowest slot index in `rack` nothing is fitted in, if below `available`. */
+function firstFreeIndex(fit, rack, available) {
+	const taken = /* @__PURE__ */ new Set();
+	for (const item of fit.items) if (item.slot.type === rack && "index" in item.slot) taken.add(item.slot.index);
+	for (let index = 0; index < available; index++) if (!taken.has(index)) return index;
+}
+//#endregion
+//#region src/edits.ts
+function emptyFit(shipTypeId) {
+	return {
+		ship: { type_id: shipTypeId },
+		items: []
+	};
+}
+/**
+* Put a type where EVE would: modules in the first free slot of their rack,
+* charges in every module that takes them, drones and fighters in their bay,
+* anything else in the cargo. With `slot`, only that slot is tried, replacing
+* what is there.
+*/
+function fitType(sde, fit, stats, typeId, slot) {
+	const nowhere = {
+		fit,
+		ref: void 0
+	};
+	const type = sde.type(typeId);
+	const placement = type && placementOf(sde, type);
+	if (type === void 0 || placement === void 0) return nowhere;
+	if (slot !== void 0 && placement.type !== "charge" && slot.type !== placement.type) return nowhere;
+	switch (placement.type) {
+		case "high":
+		case "medium":
+		case "low":
+		case "rig":
+		case "service": {
+			const index = slot === void 0 ? firstFreeIndex(fit, placement.type, stats.slots[placement.type].total) : slotIndex(slot);
+			if (index === void 0) return nowhere;
+			return putInSlot(fit, {
+				type_id: typeId,
+				slot: {
+					type: placement.type,
+					index
+				},
+				state: "active"
+			});
+		}
+		case "subsystem":
+		case "implant":
+		case "booster":
+			if (slot !== void 0 && !sameSlot(slot, placement)) return nowhere;
+			return putInSlot(fit, {
+				type_id: typeId,
+				slot: placement,
+				state: "active"
+			});
+		case "charge": {
+			const modules = fit.items.map((item, ref) => ({
+				item,
+				ref
+			})).filter(({ item }) => slot === void 0 || sameSlot(item.slot, slot)).filter(({ item }) => {
+				const module = sde.type(item.type_id);
+				return module !== void 0 && acceptsCharge(sde, module, type);
+			});
+			if (modules.length === 0) {
+				if (slot !== void 0) return nowhere;
+				return addToStack(fit, {
+					type_id: typeId,
+					slot: { type: "cargo" },
+					quantity: 1,
+					state: "offline"
+				});
+			}
+			let loaded = fit;
+			for (const { ref } of modules) loaded = setCharge(loaded, ref, typeId);
+			return {
+				fit: loaded,
+				ref: modules[0].ref
+			};
+		}
+		case "drone_bay": return addToStack(fit, {
+			type_id: typeId,
+			slot: { type: "drone_bay" },
+			quantity: 1,
+			state: "active"
+		});
+		case "fighter_bay": return append(fit, {
+			type_id: typeId,
+			slot: { type: "fighter_bay" },
+			quantity: baseValue(sde, type, "fighterSquadronMaxSize") ?? 1,
+			state: "offline"
+		});
+		case "cargo": return addToStack(fit, {
+			type_id: typeId,
+			slot: { type: "cargo" },
+			quantity: 1,
+			state: "offline"
+		});
+	}
+}
+function remove(fit, ref) {
+	if (fit.items[ref] === void 0) return fit;
+	return {
+		...fit,
+		items: fit.items.toSpliced(ref, 1)
+	};
+}
+function setState(fit, ref, state) {
+	return update(fit, ref, (item) => item.state === state ? item : {
+		...item,
+		state
+	});
+}
+function setCharge(fit, ref, chargeTypeId) {
+	return update(fit, ref, (item) => {
+		if (item.charge?.type_id === chargeTypeId) return item;
+		if (chargeTypeId !== void 0) return {
+			...item,
+			charge: { type_id: chargeTypeId }
+		};
+		const { charge: _, ...unloaded } = item;
+		return unloaded;
+	});
+}
+/** A quantity of zero removes the item. */
+function setQuantity(fit, ref, quantity) {
+	if (quantity <= 0) return remove(fit, ref);
+	return update(fit, ref, (item) => (item.quantity ?? 1) === quantity ? item : {
+		...item,
+		quantity
+	});
+}
+function setName(fit, name) {
+	return fit.name === name ? fit : {
+		...fit,
+		name
+	};
+}
+function update(fit, ref, change) {
+	const item = fit.items[ref];
+	if (item === void 0) return fit;
+	const changed = change(item);
+	return changed === item ? fit : {
+		...fit,
+		items: fit.items.with(ref, changed)
+	};
+}
+function append(fit, item) {
+	return {
+		fit: {
+			...fit,
+			items: [...fit.items, item]
+		},
+		ref: fit.items.length
+	};
+}
+function putInSlot(fit, item) {
+	const ref = fit.items.findIndex((existing) => sameSlot(existing.slot, item.slot));
+	if (ref === -1) return append(fit, item);
+	return {
+		fit: {
+			...fit,
+			items: fit.items.with(ref, item)
+		},
+		ref
+	};
+}
+/** Drones and cargo of the same type and state share a stack. */
+function addToStack(fit, item) {
+	const ref = fit.items.findIndex((existing) => existing.slot.type === item.slot.type && existing.type_id === item.type_id && existing.state === item.state);
+	if (ref === -1) return append(fit, item);
+	return {
+		fit: setQuantity(fit, ref, (fit.items[ref].quantity ?? 1) + 1),
+		ref
+	};
+}
+function slotIndex(slot) {
+	return "index" in slot ? slot.index : void 0;
+}
+function sameSlot(a, b) {
+	return a.type === b.type && slotIndex(a) === slotIndex(b);
+}
+//#endregion
+//#region src/stats.ts
+/** Calculated attributes of one thing in the fit, by name or by ID. */
+var Attributes = class {
+	#sde;
+	#result;
+	constructor(sde, result) {
+		this.#sde = sde;
+		this.#result = result;
+	}
+	/** The value after every effect applied. */
+	get(attribute) {
+		return this.#find(attribute)?.value;
+	}
+	/** The value before any effect applied. */
+	base(attribute) {
+		return this.#find(attribute)?.base;
+	}
+	#find(attribute) {
+		const id = typeof attribute === "number" ? attribute : this.#sde.attributeId(attribute);
+		return id === void 0 ? void 0 : this.#result.attributes.get(id);
+	}
+};
+const rackAttributes = {
+	high: "hiSlots",
+	medium: "medSlots",
+	low: "lowSlots",
+	rig: "rigSlots",
+	subsystem: "maxSubSystems",
+	service: "serviceSlots"
+};
+/** A calculation of a fit, with named access and the totals a fitting window shows. */
+var Stats = class {
+	calculation;
+	ship;
+	character;
+	mode;
+	/** Index-parallel to `fit.items`. */
+	items;
+	/** Every fitting rule the fit breaks; empty when it can be flown as is. */
+	violations;
+	slots;
+	hardpoints;
+	/** In m³. */
+	cargo;
+	constructor(sde, fit, calculation) {
+		this.calculation = calculation;
+		this.ship = new Attributes(sde, calculation.ship);
+		this.character = new Attributes(sde, calculation.character);
+		this.mode = calculation.mode && new Attributes(sde, calculation.mode);
+		this.items = calculation.items.map((item) => ({
+			state: item.state,
+			maxState: item.max_state,
+			attributes: new Attributes(sde, item),
+			charge: item.charge && new Attributes(sde, item.charge)
+		}));
+		this.violations = calculation.violations ?? [];
+		const used = {
+			high: 0,
+			medium: 0,
+			low: 0,
+			rig: 0,
+			subsystem: 0,
+			service: 0,
+			turret: 0,
+			launcher: 0,
+			cargo: 0
+		};
+		for (const item of fit.items) {
+			const type = sde.type(item.type_id);
+			switch (item.slot.type) {
+				case "high":
+					used.high += 1;
+					if (type?.effectIds.has(Effect.TurretFitted)) used.turret += 1;
+					if (type?.effectIds.has(Effect.LauncherFitted)) used.launcher += 1;
+					break;
+				case "medium":
+				case "low":
+				case "rig":
+				case "subsystem":
+				case "service":
+					used[item.slot.type] += 1;
+					break;
+				case "cargo": used.cargo += (type?.volume ?? 0) * (item.quantity ?? 1);
+			}
+		}
+		const total = (attribute) => this.ship.get(attribute) ?? 0;
+		const usage = (rack) => ({
+			used: used[rack],
+			total: total(rackAttributes[rack])
+		});
+		this.slots = {
+			high: usage("high"),
+			medium: usage("medium"),
+			low: usage("low"),
+			rig: usage("rig"),
+			subsystem: usage("subsystem"),
+			service: usage("service")
+		};
+		this.hardpoints = {
+			turret: {
+				used: used.turret,
+				total: total("turretSlotsLeft")
+			},
+			launcher: {
+				used: used.launcher,
+				total: total("launcherSlotsLeft")
+			}
+		};
+		this.cargo = {
+			used: used.cargo,
+			total: total("capacity")
+		};
+	}
+};
+//#endregion
+//#region src/store.ts
+const HISTORY_LIMIT = 100;
+/**
+* A fit that recalculates itself on every change. `subscribe` and
+* `getSnapshot` are bound, so they can go straight into `useSyncExternalStore`.
+*/
+var FitStore = class FitStore {
+	#calculator;
+	#character;
+	#snapshot;
+	#undo = [];
+	#redo = [];
+	#listeners = /* @__PURE__ */ new Set();
+	constructor(calculator, fit, character) {
+		this.#calculator = calculator;
+		this.#character = character;
+		this.#snapshot = this.#calculate(withoutCharacter(fit));
+	}
+	getSnapshot = () => this.#snapshot;
+	subscribe = (listener) => {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	};
+	get character() {
+		return this.#character;
+	}
+	get canUndo() {
+		return this.#undo.length > 0;
+	}
+	get canRedo() {
+		return this.#redo.length > 0;
+	}
+	/** Picks the rack and the first free slot, unless `slot` says where. */
+	fit(typeId, slot) {
+		const { fit, ref } = fitType(this.#calculator.sde, this.#snapshot.fit, this.#snapshot.stats, typeId, slot);
+		this.#commit(fit);
+		return ref;
+	}
+	remove(ref) {
+		this.#commit(remove(this.#snapshot.fit, ref));
+	}
+	setState(ref, state) {
+		this.#commit(setState(this.#snapshot.fit, ref, state));
+	}
+	setCharge(ref, chargeTypeId) {
+		this.#commit(setCharge(this.#snapshot.fit, ref, chargeTypeId));
+	}
+	setQuantity(ref, quantity) {
+		this.#commit(setQuantity(this.#snapshot.fit, ref, quantity));
+	}
+	setName(name) {
+		this.#commit(setName(this.#snapshot.fit, name));
+	}
+	/** Swap in another fit entirely, like an import; undo brings the old one back. */
+	replace(fit) {
+		this.#commit(withoutCharacter(fit));
+	}
+	/** Who flies the fit is not an edit of it, so this does not go in the history. */
+	setCharacter(character) {
+		this.#character = character;
+		this.#publish(this.#calculate(this.#snapshot.fit));
+	}
+	undo() {
+		const fit = this.#undo.pop();
+		if (fit === void 0) return;
+		this.#redo.push(this.#snapshot.fit);
+		this.#publish(this.#calculate(fit));
+	}
+	redo() {
+		const fit = this.#redo.pop();
+		if (fit === void 0) return;
+		this.#undo.push(this.#snapshot.fit);
+		this.#publish(this.#calculate(fit));
+	}
+	/** What `edit` would do, without doing it. */
+	preview(edit) {
+		const draft = new FitStore(this.#calculator, this.#snapshot.fit, this.#character);
+		edit(draft);
+		return {
+			before: this.#snapshot,
+			after: draft.getSnapshot()
+		};
+	}
+	#commit(fit) {
+		if (fit === this.#snapshot.fit) return;
+		this.#undo.push(this.#snapshot.fit);
+		if (this.#undo.length > HISTORY_LIMIT) this.#undo.shift();
+		this.#redo.length = 0;
+		this.#publish(this.#calculate(fit));
+	}
+	#calculate(fit) {
+		return Object.freeze({
+			fit,
+			stats: this.#calculator.calculate(fit, this.#character)
+		});
+	}
+	#publish(snapshot) {
+		this.#snapshot = snapshot;
+		for (const listener of this.#listeners) listener();
+	}
+};
+function withoutCharacter({ character: _, ...fit }) {
+	return fit;
+}
+//#endregion
+//#region src/engine.ts
+let loaded;
+async function createEngine(sde, options = {}) {
+	if (loaded === void 0) loaded = {
+		sde,
+		ready: init({ module_or_path: options.wasm }).then(() => void load_sde(sde.bytes))
+	};
+	else if (loaded.sde !== sde) throw new Error("The engine already holds another SDE; there can only be one per page");
+	const { ready } = loaded;
+	try {
+		await ready;
+	} catch (error) {
+		if (loaded?.ready === ready) loaded = void 0;
+		throw error;
+	}
+	return new Engine(sde);
+}
+var Engine = class {
+	sde;
+	#defaultCharacter;
+	constructor(sde) {
+		this.sde = sde;
+	}
+	/** Every published skill at level V; what a fit is flown by until told otherwise. */
+	get defaultCharacter() {
+		this.#defaultCharacter ??= allSkills(this.sde, 5);
+		return this.#defaultCharacter;
+	}
+	createFit(fit, character = this.defaultCharacter) {
+		return new FitStore(this, "items" in fit ? fit : emptyFit(fit.ship), character);
+	}
+	calculate(fit, character = this.defaultCharacter) {
+		return new Stats(this.sde, fit, calculate({
+			...fit,
+			character
+		}, { validate: true }));
+	}
+};
+//#endregion
+export { Attributes, Engine, FitStore, Stats, acceptsCharge, allSkills, baseValue, canFit, chargesFor, createEngine, emptyFit, firstFreeIndex, placementOf };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@eveshipfit/fitting",
+  "version": "1.0.0",
+  "description": "EVE Online ship fits that recalculate themselves",
+  "license": "MIT",
+  "author": "EVEShipFit Team <info@eveship.fit>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EVEShipFit/eveship.fit.git",
+    "directory": "packages/fitting"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@eveshipfit/sde-loader": "1.0.0"
+  },
+  "devDependencies": {
+    "@eveshipfit/dogma-engine": "^13.0.1",
+    "@eveshipfit/sde": "^7.3539543.0",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.23.0"
+  },
+  "peerDependencies": {
+    "@eveshipfit/dogma-engine": "^13.0.0"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}