@johnmorrisdotca/uchusen-rockets 0.8.0 → 0.10.0

package/dist/build/index.js

@@ -4,7 +4,8 @@ import { check } from "../fit.js";
 import { cleanView, DEFAULT_VIEW, PICTURE_H, PICTURE_W, VIEWS } from "../framing.js";
 import { cleanShow, placesFor, showsOf } from "../layout.js";
 import { DEFAULT_LOOK } from "../looks.js";
-import { boundsOf, meshOf } from "../model/pieces.js";
+import { detail } from "../model/detail.js";
+import { boundsOf, boundsOfPieces, meshOf } from "../model/pieces.js";
 import { moved } from "../model/moves.js";
 import { partEntry } from "../model/registry.js";
 import { partIdOf, variantOf } from "../rockets.js";
@@ -35,18 +36,35 @@ export class FitError extends Error {
         this.report = report;
     }
 }
+/**
+ * A part with more pieces than this is not meshed until its triangles are asked for, and the mesh is not kept: a fleet ship's parts hold hundreds of thousands of triangles, and keeping them all as arrays of numbers took a gigabyte.
+ *
+ * @example
+ * ```ts
+ * import { HEAVY_PIECES } from "@johnmorrisdotca/uchusen-rockets/build";
+ *
+ * console.log(HEAVY_PIECES);
+ * ```
+ */
+export const HEAVY_PIECES = 2000;
 const memo = new Map();
+const memoKey = (id) => `${detail.level}/${id}`;
 function made(id) {
-    const known = memo.get(id);
+    const known = memo.get(memoKey(id));
     if (known)
         return known;
     const entry = partEntry(id);
     if (!entry)
         throw new Error(`There is no part "${id}".`);
     const pieces = entry.pieces();
+    if (pieces.length > HEAVY_PIECES) {
+        const heavy = { pieces, bounds: boundsOfPieces(pieces), get mesh() { return meshOf(pieces); } };
+        memo.set(memoKey(id), heavy);
+        return heavy;
+    }
     const mesh = meshOf(pieces);
     const result = { pieces, mesh, bounds: boundsOf(mesh) };
-    memo.set(id, result);
+    memo.set(memoKey(id), result);
     return result;
 }
 const xmlText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -71,8 +89,8 @@ function flameKindOf(part) {
 }
 function assembled(report) {
     const parts = report.parts.map(({ slot, part }) => {
-        const { pieces, mesh, bounds } = made(part.id);
-        return { slot, record: part, pieces, mesh, bounds, flame: flameKindOf(part) };
+        const one = made(part.id);
+        return { slot, record: part, pieces: one.pieces, get mesh() { return one.mesh; }, bounds: one.bounds, flame: flameKindOf(part) };
     });
     const slots = parts.map((part) => part.slot);
     const placesOf = (show) => placesFor(report.parts, cleanShow(show, slots), (part) => widthOf(part.id));
@@ -159,6 +177,7 @@ export function drawnPieces(part, together) {
  * A rocket from a description. Throws FitError when it does not go together.
  *
  * @param description The rocket, its variant and any other part in a slot.
+ * @param options `detail`: `"coarse"` leaves out the small 3D-only detail of a very detailed part, for a fast first view; left out, every piece is made.
  * @returns The built rocket. It throws a `FitError` when the description does not go together.
  * @example
  * ```ts
@@ -168,11 +187,20 @@ export function drawnPieces(part, together) {
  * console.log(rocket.report.label, rocket.glb().bytes.length > 1000);
  * ```
  */
-export function build(description) {
+export function build(description, options = {}) {
     const report = check(description);
     if (!report.ok)
         throw new FitError(report);
-    return assembled(report);
+    const before = detail.level;
+    detail.level = options.detail ?? "full";
+    try {
+        const built = assembled(report);
+        // a part's pieces are made when it is assembled, at this level: the lazy parts of a heavy part keep the level they were made at
+        return built;
+    }
+    finally {
+        detail.level = before;
+    }
 }
 /**
  * One part on its own, by its id.
@@ -191,11 +219,12 @@ export function buildPart(id) {
     const entry = partEntry(id);
     if (!entry)
         throw new Error(`There is no part "${id}".`);
-    const { pieces, mesh, bounds } = made(id);
+    const { pieces, bounds } = made(id);
+    const one = made(id);
     return {
         record: entry.record,
         bounds,
-        glb: () => toGlb([{ name: entry.record.id, mesh, at: [0, 0, 0] }]),
+        glb: () => toGlb([{ name: entry.record.id, mesh: one.mesh, at: [0, 0, 0] }]),
         svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW } = {}) => {
             const angle = typeof view === "string" ? VIEWS[cleanView(view)] : view;
             return wrap(drawPart(pieces, [0, 0, 0], perspective(bounds, angle), look, 1), look, PICTURE_W, PICTURE_H, entry.record.name);

package/dist/build/lineup.d.ts

@@ -72,12 +72,19 @@ export interface LineupOptions {
     show?: string;
     ruler?: boolean;
     labels?: boolean;
+    /** `rockets` or `fleet` leaves out the other kind; `all` (the default) draws both. A fleet ship (a rocket whose id starts with `fleet-`) lies lengthwise in its own band below the rockets. */
+    filter?: "all" | "rockets" | "fleet";
+    /** Shrinks the scale, never grows it, until the whole drawing fits this many pixels across and down (either may be left out). Without it the scale is `unit`, as it always was. */
+    fit?: {
+        width?: number;
+        height?: number;
+    };
 }
 /**
  * The whole picture as SVG text. Unknown items are left out.
  *
  * @param options The items and how they are drawn.
- * @returns The picture as SVG text, the items it holds, and its width and height.
+ * @returns The picture as SVG text, the items it holds, its width and height and the scale it was drawn at (pixels a metre: less than `unit` when `fit` shrank it).
  * @example
  * ```ts
  * import { lineupSvg } from "@johnmorrisdotca/uchusen-rockets/build";
@@ -91,4 +98,5 @@ export declare function lineupSvg(options: LineupOptions): {
     items: LineupItem[];
     width: number;
     height: number;
+    unit: number;
 };

package/dist/build/lineup.js

@@ -29,6 +29,7 @@ const edgeOf = (built, look) => {
     const hulls = built.parts.flatMap((part) => part.pieces).filter((piece) => piece.kind === "lathe" && piece.body);
     return hulls.length && hulls.every((piece) => piece.kind === "lathe" && MATERIALS[piece.material].fill === "dark") ? LOOKS.line.line : undefined;
 };
+const isFleet = (key) => key.startsWith("fleet-");
 function comparison(id, x, base, unit, line, fill) {
     const { height, width } = COMPARES[id];
     const h = height * unit;
@@ -46,7 +47,7 @@ function comparison(id, x, base, unit, line, fill) {
  * The whole picture as SVG text. Unknown items are left out.
  *
  * @param options The items and how they are drawn.
- * @returns The picture as SVG text, the items it holds, and its width and height.
+ * @returns The picture as SVG text, the items it holds, its width and height and the scale it was drawn at (pixels a metre: less than `unit` when `fit` shrank it).
  * @example
  * ```ts
  * import { lineupSvg } from "@johnmorrisdotca/uchusen-rockets/build";
@@ -56,7 +57,29 @@ function comparison(id, x, base, unit, line, fill) {
  * ```
  */
 export function lineupSvg(options) {
-    const { items, unit, look = DEFAULT_LOOK, view = "front", ruler = true, labels = true } = options;
+    const filter = options.filter ?? "all";
+    const keys = options.items.map((raw) => raw.trim()).filter((key) => (isFleet(key) ? filter !== "rockets" : filter !== "fleet" || false));
+    const fleetKeys = keys.filter(isFleet);
+    const rocketKeys = keys.filter((key) => !isFleet(key));
+    // the fleet filter shows ships only: no person, no building
+    const standing = filter === "fleet" ? [] : rocketKeys;
+    let unit = options.unit;
+    let drawn = draw({ ...options, items: standing }, fleetKeys, unit);
+    const room = options.fit;
+    if (room)
+        for (let i = 0; i < 40 && ((room.width !== undefined && drawn.width > room.width) || (room.height !== undefined && drawn.height > room.height)); i++) {
+            unit *= 0.88;
+            drawn = draw({ ...options, items: standing }, fleetKeys, unit);
+        }
+    return { ...drawn, unit };
+}
+/** The pieces' extent, front to back and side to side and up and down, in metres, of a ship lying lengthwise (its long axis y drawn across the page, z up). */
+function lying(built) {
+    const b = built.boundsOf("together");
+    return { length: b.max[1] - b.min[1], beam: b.max[0] - b.min[0], height: b.max[2] - b.min[2], from: b.min[1], low: b.min[2] };
+}
+function draw(options, fleetKeys, unit) {
+    const { items, look = DEFAULT_LOOK, view = "front", ruler = true, labels = true } = options;
     const angle = VIEWS[cleanView(view)];
     const known = [];
     for (const raw of items) {
@@ -82,8 +105,8 @@ export function lineupSvg(options) {
     const top = 26;
     const labelRoom = labels ? 44 : 0;
     const rulerRoom = ruler ? 46 : 8;
-    const tallest = Math.max(10, ...known.map((item) => item.height));
-    const height = top + tallest * unit + labelRoom + 10;
+    const tallest = known.length ? Math.max(10, ...known.map((item) => item.height)) : 0;
+    const bandHeight = known.length ? top + tallest * unit + labelRoom + 10 : 0;
     const base = top + tallest * unit;
     const minCell = 96;
     let x = rulerRoom;
@@ -114,15 +137,64 @@ export function lineupSvg(options) {
         }
         x += cell;
     }
-    const width = x + 8;
+    let width = known.length ? x + 8 : rulerRoom + 8;
+    // the fleet: each ship lies lengthwise (its long axis across the page) in its own band below the rockets, at the same scale
+    const ships = [];
+    for (const key of fleetKeys) {
+        const [rocket, variant] = key.split(":");
+        const named = variantOf(rocket, variant);
+        if (!named || !check({ rocket, variant: named.id }).ok)
+            continue;
+        const built = build({ rocket, variant: named.id });
+        ships.push({ key, label: named.name, built, size: lying(built) });
+    }
+    let fleetY = bandHeight + (known.length && ships.length ? 12 : 0);
+    const fleetBody = [];
+    let longest = 0;
+    const fleetBase = [];
+    for (const ship of ships) {
+        const { length, height: tall, from, low } = ship.size;
+        const baseY = fleetY + 8 + tall * unit;
+        const x0 = rulerRoom;
+        const cam = { project: (p) => [x0 + (p[1] - from) * unit, baseY - (p[2] - low) * unit], depth: (p) => -p[0], toward: () => [1, 0, 0], above: false };
+        const show = options.show && ship.built.shows.includes(options.show) ? options.show : ship.built.shows[0];
+        const places = ship.built.placesOf(show).filter((place) => place.shown).sort((a, b) => a.at[0] - b.at[0]);
+        const edge = edgeOf(ship.built, look);
+        for (const place of places) {
+            const part = ship.built.parts.find((p) => p.slot === place.slot);
+            if (part)
+                fleetBody.push(drawPart(drawnPieces(part, show === "together"), place.at, cam, look, 0.7, edge));
+        }
+        fleetBody.push(`<path d="M${n(x0)} ${n(baseY)}H${n(x0 + length * unit)}" stroke="currentColor" stroke-width=".6" opacity=".4"/>`);
+        if (labels)
+            fleetBody.push(`<text x="${n(x0)}" y="${n(baseY + 15)}" font-size="11" fill="currentColor">${xmlText(ship.label)}</text>`);
+        fleetBase.push(baseY);
+        longest = Math.max(longest, length);
+        fleetY = baseY + (labels ? 26 : 12);
+    }
+    if (ships.length) {
+        width = Math.max(width, rulerRoom + longest * unit + 8);
+        if (ruler) {
+            // the metres, along the ground of the fleet band, the same scale as the rockets' ruler
+            const steps = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000];
+            const step = steps.find((v) => v * unit >= 56) ?? 2000;
+            const yy = fleetY + 4;
+            fleetBody.push(`<path d="M${n(rulerRoom)} ${n(yy)}H${n(rulerRoom + longest * unit)}" stroke="currentColor" stroke-width="1" opacity=".7"/>`);
+            for (let m = 0; m <= longest + 0.001; m += step)
+                fleetBody.push(`<path d="M${n(rulerRoom + m * unit)} ${n(yy)}v5" stroke="currentColor" stroke-width="1" opacity=".7"/><text x="${n(rulerRoom + m * unit)}" y="${n(yy + 16)}" text-anchor="middle" font-size="10" fill="currentColor" opacity=".85">${m.toLocaleString("en-US")}</text>`);
+            fleetBody.push(`<text x="${n(rulerRoom + longest * unit + 4)}" y="${n(yy + 16)}" font-size="10" fill="currentColor" opacity=".85">m</text>`);
+            fleetY = yy + 24;
+        }
+    }
+    const height = known.length || ships.length ? Math.max(bandHeight, 0) + (ships.length ? fleetY - bandHeight : 0) : 36;
     let rule = "";
-    if (ruler) {
+    if (ruler && known.length) {
         const step = tallest * unit < 240 ? 10 : 20;
         rule += `<path d="M${rulerRoom - 8} ${n(base)}V${n(base - tallest * unit)}" stroke="currentColor" stroke-width="1" opacity=".7"/>`;
         for (let m = 0; m <= tallest + 0.001; m += step)
             rule += `<path d="M${rulerRoom - 8} ${n(base - m * unit)}h-5" stroke="currentColor" stroke-width="1" opacity=".7"/><text x="${rulerRoom - 16}" y="${n(base - m * unit + 3.5)}" text-anchor="end" font-size="10" fill="currentColor" opacity=".85">${m}</text>`;
         rule += `<text x="${rulerRoom - 16}" y="${n(base - tallest * unit - 10)}" text-anchor="end" font-size="10" fill="currentColor" opacity=".85">m</text><path d="M${rulerRoom - 8} ${n(base)}H${n(width)}" stroke="currentColor" stroke-width=".6" opacity=".4"/>`;
     }
-    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(width)} ${n(height)}" width="${n(width)}" height="${n(height)}" role="img" aria-label="${xmlText(`To scale: ${known.map((item) => item.label).join(", ")}`)}">${defsOf(look)}${rule}${body.join("")}</svg>`;
-    return { svg, width, height, items: known.map(({ key, label, height: h }) => ({ key, label, height: h })) };
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(width)} ${n(height)}" width="${n(width)}" height="${n(height)}" role="img" aria-label="${xmlText(`To scale: ${[...known.map((item) => item.label), ...ships.map((ship) => ship.label)].join(", ")}`)}">${defsOf(look)}${rule}${body.join("")}${fleetBody.join("")}</svg>`;
+    return { svg, width, height, items: [...known.map(({ key, label, height: h }) => ({ key, label, height: h })), ...ships.map((ship) => ({ key: ship.key, label: ship.label, height: ship.size.length }))] };
 }

package/dist/builder.js

@@ -22,7 +22,8 @@ const fitsOn = (part, below) => {
     const { bottom } = part.joints;
     return Boolean(top && bottom && top.kind === bottom.kind && Math.abs(top.diameter - bottom.diameter) <= JOINT_TOLERANCE);
 };
-const REAL_PARTS = () => PART_ENTRIES.map(({ record }) => record).filter((record) => record.trueTo.length > 0);
+/** The fleet kit has its own way of building ships, so the builder of real rockets leaves it out. */
+const REAL_PARTS = () => PART_ENTRIES.map(({ record }) => record).filter((record) => record.trueTo.length > 0 && !record.rocket.startsWith("fleet-"));
 const optionOf = (part) => ({ id: part.id, name: part.name, rocket: ROCKETS[part.rocket]?.name ?? part.rocket });
 /**
  * The rows for these picks, from the bottom. A pick that is not offered, for a change lower down or a hostile value, gives way to the part that belongs with what is below, or else the first that fits.

package/dist/data/fleet.d.ts

@@ -0,0 +1,27 @@
+import type { KitModule, ModuleKind } from "../model/fleet/types.ts";
+import { type Variant } from "./types.ts";
+/** The groups the kit's modules are listed in: a rocket for each, so a picker row never holds more than a dozen. */
+export declare const FLEET_GROUPS: readonly {
+    id: string;
+    name: string;
+    kinds: readonly ModuleKind[]; /** Modules chosen by id, for a group that is not one kind. */
+    ids?: readonly string[];
+}[];
+/** The id of a group's part for a module. */
+export declare const groupOf: (module: KitModule) => string;
+/** What to call each slot of the fleet's variants: a module by its name, a ship's place with its number, an inset's part with its number. */
+export declare const FLEET_SLOT_NAMES: Readonly<Record<string, string>>;
+/**
+ * The fleet kit's rockets, by id: each module on its own and opened, in groups, and the sample ships.
+ *
+ * @example
+ * ```ts
+ * import { FLEET_KIT_ROCKETS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(FLEET_KIT_ROCKETS));
+ * ```
+ */
+export declare const FLEET_KIT_ROCKETS: Readonly<Record<string, {
+    name: string;
+    variants: readonly Variant[];
+}>>;

package/dist/data/fleet.js

@@ -0,0 +1,96 @@
+// The fleet kit as rockets and variants: each module on its own (and opened, where it has an inside), grouped by what it is, and the kit's sample ships. All fictional: this package's own design, so every
+// figure is blank and says so.
+import { designation, INSETS, KIT, SAMPLE_SHIPS, shipParts } from "../model/fleet/kit.js";
+import { blank } from "./types.js";
+const FICTION = "This package's own design, with no source.";
+const fiction = (brief) => blank(FICTION, brief);
+const metres = (value) => `${Number(value.toFixed(1))} m, as designed`;
+/** The groups the kit's modules are listed in: a rocket for each, so a picker row never holds more than a dozen. */
+export const FLEET_GROUPS = [
+    { id: "fleet-engines", name: "Fleet engines and thrusters", kinds: ["engine", "thruster"] },
+    { id: "fleet-tanks", name: "Fleet tanks", kinds: ["tank"] },
+    { id: "fleet-cargo", name: "Fleet cargo", kinds: ["cargo"] },
+    { id: "fleet-habitats", name: "Fleet habitat rings and drums", kinds: [], ids: ["habitat-ring-16", "habitat-ring-30", "habitat-drum-crew", "habitat-drum-large"] },
+    { id: "fleet-decks", name: "Fleet crew and service decks", kinds: [], ids: ["farm-drum", "common-area-m", "store-drum-m", "eva-lock-m", "dome-observation-m", "solarium-m"] },
+    { id: "fleet-labs", name: "Fleet labs, pods and bridge", kinds: [], ids: ["lab-m", "pod-survey-m", "pod-medical-m", "deck-nav-m"] },
+    { id: "fleet-systems", name: "Fleet reactors, radiators and sensors", kinds: ["reactor", "radiator", "sensor"] },
+    { id: "fleet-structure", name: "Fleet nodes, trusses and shields", kinds: ["node", "truss", "adapter", "shield"] },
+];
+/** The id of a group's part for a module. */
+export const groupOf = (module) => FLEET_GROUPS.find((group) => group.ids?.includes(module.id) ?? group.kinds.includes(module.kind))?.id ?? "fleet-structure";
+const moduleVariant = (module, rocket, cutaway) => {
+    const id = cutaway ? `${module.id}-cutaway` : module.id;
+    return {
+        id,
+        rocket,
+        name: `${module.name}${cutaway ? ", cutaway" : ""}`,
+        status: "fictional",
+        firstWord: "Designed",
+        firstFlight: blank(FICTION, "Planned: not yet flown"),
+        slots: ["module"],
+        partIds: { module: id },
+        note: `${module.note} ${module.length} m long, ${module.width} m across, ${module.mass} t dry${module.propellant ? `, ${module.propellant} t of propellant when full` : ""}.`,
+        facts: { height: fiction(metres(module.length)), diameter: fiction(metres(Math.max(module.width, module.depth))), parts: { module: fiction(metres(module.length)) }, engines: {}, more: {} },
+    };
+};
+const CODES = { hauler: "KIT-H", scout: "KIT-S", bulwark: "KIT-B" };
+/** What to call each slot of the fleet's variants: a module by its name, a ship's place with its number, an inset's part with its number. */
+export const FLEET_SLOT_NAMES = (() => {
+    const names = { module: "Module" };
+    for (const inset of Object.values(INSETS))
+        for (const one of inset.parts)
+            names[`part-${one.n}`] = `${one.n}. ${one.name}`;
+    for (const [i, place] of SAMPLE_SHIPS.hauler.entries())
+        names[`${place.module}-${i + 1}`] = `${i + 1}. ${KIT[place.module].name}`;
+    return names;
+})();
+const sample = (rocket, id, name) => {
+    const parts = shipParts(`${rocket}-${id}`, SAMPLE_SHIPS[id], { detail: 0.4 });
+    return {
+        id,
+        rocket,
+        name: `${designation(CODES[id])} ${name}`,
+        status: "fictional",
+        firstWord: "Designed",
+        firstFlight: blank(FICTION, "Planned: not yet flown"),
+        slots: parts.slots,
+        partIds: parts.partIds,
+        note: `A sample ship made only of kit modules, ${parts.assembly.length.toFixed(0)} m long and ${(parts.assembly.mass / 1000).toFixed(1)} thousand tonnes dry. It shows the modules on a spine; it is not one of the fleet's three ships.`,
+        facts: { height: fiction(metres(parts.assembly.length)), diameter: fiction(metres(Math.max(parts.assembly.width, parts.assembly.depth))), parts: Object.fromEntries(parts.slots.map((slot) => [slot, fiction(metres(KIT[slot.replace(/-\d+$/, "")].length))])), engines: {}, more: {} },
+    };
+};
+const insetVariant = (inset) => ({
+    id: inset.id,
+    rocket: "fleet-insets",
+    name: `${inset.name} inset`,
+    status: "fictional",
+    firstWord: "Designed",
+    firstFlight: blank(FICTION, "Planned: not yet flown"),
+    slots: inset.parts.map((one) => `part-${one.n}`),
+    partIds: Object.fromEntries(inset.parts.map((one) => [`part-${one.n}`, `inset-${inset.id}-${one.n}`])),
+    note: `${inset.note} ${inset.parts.map((one) => `${one.n} ${one.name}`).join(", ")}. Press "apart" to open it.`,
+    facts: { height: fiction("about 6 m, as designed"), diameter: fiction("about 12 m, as designed"), parts: Object.fromEntries(inset.parts.map((one) => [`part-${one.n}`, fiction(metres(one.size[1]))])), engines: {}, more: {} },
+});
+/**
+ * The fleet kit's rockets, by id: each module on its own and opened, in groups, and the sample ships.
+ *
+ * @example
+ * ```ts
+ * import { FLEET_KIT_ROCKETS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(FLEET_KIT_ROCKETS));
+ * ```
+ */
+export const FLEET_KIT_ROCKETS = {
+    "fleet-insets": { name: "Fleet system insets", variants: Object.values(INSETS).map(insetVariant) },
+    "fleet-samples": { name: "Fleet kit sample ship", variants: [sample("fleet-samples", "hauler", "Kit hauler")] },
+    ...Object.fromEntries(FLEET_GROUPS.map((group) => [
+        group.id,
+        {
+            name: group.name,
+            variants: Object.values(KIT)
+                .filter((module) => groupOf(module) === group.id)
+                .flatMap((module) => [moduleVariant(module, group.id, false), ...(module.inside ? [moduleVariant(module, group.id, true)] : [])]),
+        },
+    ])),
+};

package/dist/data/makers.d.ts

@@ -11,11 +11,12 @@ import { type Figure } from "./types.ts";
  */
 export declare const MAKERS: {
     readonly spacex: "SpaceX";
-    readonly nasa: "NASA and partners";
+    readonly nasa: "NASA";
     readonly "blue-origin": "Blue Origin";
     readonly "rocket-lab": "Rocket Lab";
     readonly russia: "Russia";
     readonly "us-army": "US Army";
+    readonly fleet: "SPX";
     readonly sites: "Sites";
 };
 /**

package/dist/data/makers.js

@@ -10,7 +10,7 @@ import { blank } from "./types.js";
  * console.log(MAKERS.spacex, Object.keys(MAKERS).length);
  * ```
  */
-export const MAKERS = { spacex: "SpaceX", nasa: "NASA and partners", "blue-origin": "Blue Origin", "rocket-lab": "Rocket Lab", russia: "Russia", "us-army": "US Army", sites: "Sites" };
+export const MAKERS = { spacex: "SpaceX", nasa: "NASA", "blue-origin": "Blue Origin", "rocket-lab": "Rocket Lab", russia: "Russia", "us-army": "US Army", fleet: "SPX", sites: "Sites" };
 const SITE = { maker: "sites", madeBy: blank("A place or a ship, not a vehicle: its maker is not read here.") };
 export const MADE_BY = {
     starship: { maker: "spacex", madeBy: { value: "SpaceX", source: "wikipedia-starship" } },
@@ -32,6 +32,10 @@ export const MADE_BY = {
     "jupiter-c": { maker: "us-army", madeBy: { value: "Designed by the US Army Ballistic Missile Agency; built by Chrysler", source: "wikipedia-jupiter-c" } },
     iss: { maker: "nasa", madeBy: { value: "Its US segment built by NASA, ESA, JAXA and CSA, its Russian segment developed by Roscosmos", source: "wikipedia-iss" } },
     hubble: { maker: "nasa", madeBy: { value: "NASA's Great Observatories program; operated by STScI; built by Lockheed Martin and Perkin-Elmer", source: "wikipedia-hubble" } },
+    "fleet-ship-03": { maker: "fleet", madeBy: { value: "SPX", source: "uchusen-design" } },
+    "fleet-ship-ariake": { maker: "fleet", madeBy: { value: "SPX", source: "uchusen-design" } },
+    "fleet-kit": { maker: "fleet", madeBy: { value: "SPX", source: "uchusen-design" } },
+    "fleet-02": { maker: "fleet", madeBy: { value: "SPX", source: "uchusen-fleet-ship-02", note: "An original design." } },
     droneship: SITE,
     "landing-zone": SITE,
     "launch-tower": SITE,

package/dist/data/ship-03.d.ts

@@ -0,0 +1,12 @@
+import { type Variant } from "./types.ts";
+/** Miyamoto's variants. */
+export declare const SHIP_03_VARIANTS: readonly Variant[];
+/** The sister ship: the same model, its own name, registry, hull marks and mission pod. A row of its own in the picker. */
+export declare const ARIAKE_VARIANTS: readonly Variant[];
+/** Miyamoto's insets and propulsion cards, as one more row of the picker. */
+export declare const SHIP_03_INSET_ROCKET: {
+    readonly name: "Romurusu class insets and engine cards";
+    readonly variants: readonly Variant[];
+};
+/** What to call each slot of the ship's variants in the picker: a module by its name, a sub-part of an inset with its number. */
+export declare const SHIP_03_SLOT_NAMES: Readonly<Record<string, string>>;

package/dist/data/ship-03.js

@@ -0,0 +1,103 @@
+// ISV Miyamoto (SPX-452), the Romurusu class's first ship, and its sister ISV Ariake (SPX-186): planned interstellar flagships, this package's own design. It is four variants of one ship: stowed, with its radiators out, with the relief pod on its collar, and cut open to the
+// starboard side. Every figure is blank and says it is a design: no source gives them. The ship's own numbers are in `src/model/fleet/ship-03/specs.ts`.
+import { MIYAMOTO_PARTS, MIYAMOTO_VARIANT_SLOTS } from "../model/fleet/ship-03/variants.js";
+import { CARDS, SHIP_INSETS } from "../model/fleet/ship-03/insets.js";
+import { blank } from "./types.js";
+import { ENGINES, HISTORY, SECTIONS, specification } from "../model/fleet/ship-03/specs.js";
+import { HULL } from "../model/fleet/ship-03/specs.js";
+const FICTION = "A design of this package, with no source.";
+const fiction = (brief) => blank(FICTION, brief);
+const metres = (value) => `${Number(value.toFixed(1))} m, as designed`;
+const NOTES = {
+    miyamoto: "ISV 宮本 Miyamoto, SPX-452, Romurusu class (ロムルス級, ICV type), the flagship and command vessel, stowed, with the relay pod on its keyed collar. A narrow spine, two staggered hangar shoulders, a layered bow and two recessed drives, 380 m by 118 m by 74 m, 105,000 t at departure. Status: planned, first flight 2456. All numbers are design targets; the drive and its limits are described in the ship's bible.",
+    "miyamoto-deployed": "Miyamoto with both radiator banks out: four leaves of 25 by 60 m on each, clear of the hangar corridors. Sustained main burn needs every leaf out.",
+    "miyamoto-relief": "Miyamoto with the relief pod on its collar: six relief and equipment containers under a gantry, in place of the relay pod.",
+    "miyamoto-no-collar": "ISV Miyamoto with the drive's neck bare: the shadow-shield collar swapped for none, to compare the two ways the engines meet the hull.",
+    ariake: "ISV 有明 Ariake, SPX-186, \"daybreak\": the sister of ISV Miyamoto in the Romurusu class (ロムルス級), the same model with its own registry and hull marks, a dawn-gold livery with pinstripes, a survey pod on its collar, a sensor mast and a solarium each side of the dome, and warm rooms. Status: planned, first flight 2456.",
+    "ariake-cutaway": "Ariake opened to starboard at the habitation drum: the four decks in warm wood and dawn-gold.",
+    "miyamoto-cutaway": "Miyamoto opened to starboard: the layers of its armour at the cut edge, the reactor and power rooms, the barrels, both bays, the decks of the habitat and the operations ring of the citadel.",
+};
+const NAMES = { miyamoto: "ISV 宮本 Miyamoto, SPX-452", "miyamoto-deployed": "ISV 宮本 Miyamoto, SPX-452, radiators out", "miyamoto-relief": "ISV 宮本 Miyamoto, SPX-452, relief pod", "miyamoto-cutaway": "ISV 宮本 Miyamoto, SPX-452, cutaway", "miyamoto-no-collar": "ISV 宮本 Miyamoto, SPX-452, no collar", ariake: "ISV 有明 Ariake, SPX-186", "ariake-cutaway": "ISV 有明 Ariake, SPX-186, cutaway" };
+/** What the viewer's panel shows for a variant: the labels of every named section, the specification (with the sister ship's row as a link), and the notes. The other ship is one click away. */
+const inspectorOf = (id, slots) => {
+    const ship = id.startsWith("ariake") ? "ariake" : "miyamoto";
+    const cut = id.endsWith("cutaway");
+    const other = ship === "ariake" ? { rocket: "fleet-ship-03", variant: cut ? "miyamoto-cutaway" : "miyamoto", name: "ISV 宮本 Miyamoto, SPX-452" } : { rocket: "fleet-ship-ariake", variant: cut ? "ariake-cutaway" : "ariake", name: "ISV 有明 Ariake, SPX-186" };
+    const lines = specification(ship);
+    const pick = (names) => lines.filter((l) => names.includes(l.name)).map((l) => (l.note ? `${l.name}: ${l.value} (${l.note}).` : `${l.name}: ${l.value}.`));
+    return {
+        sections: SECTIONS.filter((sec) => sec.module in slots).map((sec) => ({ id: `${sec.module}/${sec.id}`, name: sec.name, job: sec.does, slot: sec.module, at: [sec.at[0], (sec.y0 + sec.y1) / 2, sec.at[1]], inside: Boolean(sec.deck) })),
+        places: Object.fromEntries(Object.entries(slots).map(([slot, part]) => {
+            const one = MIYAMOTO_PARTS.find((p) => p.id === part);
+            return [slot, [one?.place?.x ?? 0, one?.y0 ?? 0, one?.place?.z ?? 0]];
+        })),
+        spec: [...lines.map((l) => [l.name, l.note ? `${l.value} (${l.note})` : l.value]), ["Sister ship", other.name]],
+        links: { "Sister ship": { rocket: other.rocket, variant: other.variant } },
+        notes: {
+            propulsion: [...Object.values(ENGINES).map((c) => `${c.name}: ${c.count} x ${(c.thrust / 1e6).toFixed(c.thrust >= 1e6 ? 1 : 2)} MN, ${c.note}`), ...pick(["Main drive", "Acceleration", "Peak speed", "Range"])],
+            construction: [...HULL.layers.map((l) => `${l.n}. ${l.name}: ${l.made}, ${l.mm} mm.`)],
+            history: Object.values(HISTORY),
+            equipment: pick(["Small craft", "Ship computer", "Power", "Solar array", "Heat rejection", "Manoeuvring", "Crew"]),
+        },
+        insets: [],
+    };
+};
+/** The ship's variants. */
+const variantOf = ([id, slots]) => {
+    const stacked = Object.keys(slots);
+    return {
+        id,
+        rocket: id.startsWith("ariake") ? "fleet-ship-ariake" : "fleet-ship-03",
+        name: NAMES[id],
+        status: "fictional",
+        firstWord: "Planned first flight",
+        firstFlight: blank(FICTION, "Planned for 2456"),
+        slots: stacked,
+        partIds: Object.fromEntries(Object.entries(slots).map(([slot, part]) => [slot, `fleet-ship-03-${part}`])),
+        note: NOTES[id],
+        inspector: inspectorOf(id, slots),
+        facts: {
+            height: fiction(metres(380)),
+            diameter: fiction(metres(118)),
+            parts: Object.fromEntries(Object.entries(slots).map(([slot, part]) => [slot, fiction(metres(MIYAMOTO_PARTS.find((one) => one.id === part)?.height ?? 0))])),
+            engines: { drive: blank(FICTION, "2 DCD (Directed Conversion Drives), 4 plasma verniers") },
+            more: {},
+        },
+    };
+};
+/** Miyamoto's variants. */
+export const SHIP_03_VARIANTS = Object.entries(MIYAMOTO_VARIANT_SLOTS).filter(([id]) => !id.startsWith("ariake")).map(variantOf);
+/** The sister ship: the same model, its own name, registry, hull marks and mission pod. A row of its own in the picker. */
+export const ARIAKE_VARIANTS = Object.entries(MIYAMOTO_VARIANT_SLOTS).filter(([id]) => id.startsWith("ariake")).map(variantOf);
+const insetVariant = (inset) => ({
+    id: inset.id,
+    rocket: "fleet-insets-ship-03",
+    name: `${inset.name} inset`,
+    status: "fictional",
+    firstWord: "Planned first flight",
+    firstFlight: blank(FICTION, "Planned for 2456"),
+    slots: inset.parts.map((one) => `${inset.id}-${one.n}`),
+    partIds: Object.fromEntries(inset.parts.map((one) => [`${inset.id}-${one.n}`, `fleet-ship-03-inset-${inset.id}-${one.n}`])),
+    note: `${inset.note} ${inset.parts.map((one) => `${one.n} ${one.name}`).join(", ")}. Press "apart" to open it.`,
+    facts: { height: fiction("about 6 m, as designed"), diameter: fiction("about 12 m, as designed"), parts: Object.fromEntries(inset.parts.map((one) => [`${inset.id}-${one.n}`, fiction(metres(one.size[1]))])), engines: {}, more: {} },
+});
+const cardVariant = (card) => ({
+    id: card.id,
+    rocket: "fleet-insets-ship-03",
+    name: card.name,
+    status: "fictional",
+    firstWord: "Planned first flight",
+    firstFlight: blank(FICTION, "Planned for 2456"),
+    slots: ["engine"],
+    partIds: { engine: `fleet-ship-03-${card.id}` },
+    note: `${card.name}: the engine on its own, with its bell, throat, chamber, feed manifolds, field coils and gimbal. Its numbers are on the ship's engine cards.`,
+    facts: { height: fiction(metres(card.size[1])), diameter: fiction(metres(Math.max(card.size[0], card.size[2]))), parts: { engine: fiction(metres(card.size[1])) }, engines: {}, more: {} },
+});
+/** Miyamoto's insets and propulsion cards, as one more row of the picker. */
+export const SHIP_03_INSET_ROCKET = { name: "Romurusu class insets and engine cards", variants: [...Object.values(SHIP_INSETS).map(insetVariant), ...Object.values(CARDS).map(cardVariant)] };
+/** What to call each slot of the ship's variants in the picker: a module by its name, a sub-part of an inset with its number. */
+export const SHIP_03_SLOT_NAMES = {
+    ...Object.fromEntries(MIYAMOTO_PARTS.filter((part) => !part.id.endsWith("-cutaway")).map((part) => [part.id.replace(/-(stowed|deployed)$/, "").replace(/^(pod|radiators-dorsal|radiators-ventral)-.*/, (m) => (m.startsWith("pod") ? "pod" : m.startsWith("radiators-dorsal") ? "radiators-dorsal" : "radiators-ventral")), part.name.replace(/, (stowed|deployed|relay|relief)$/, "").replace(/^Mission pod.*/, "Mission pod")])),
+    ...Object.fromEntries(Object.values(SHIP_INSETS).flatMap((inset) => inset.parts.map((one) => [`${inset.id}-${one.n}`, `${one.n}. ${one.name}`]))),
+    engine: "Engine",
+};

package/dist/data/ship02.d.ts

@@ -0,0 +1,3 @@
+import { type Figure, type Variant } from "./types.ts";
+export declare const SHIP_02_LENGTH: Figure;
+export declare const SHIP_02_VARIANTS: readonly Variant[];