@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/build/lineup.js

@@ -1,4 +1,5 @@
 // Rockets and what to compare them with, side by side on one baseline at one scale, as one drawing with a ruler. Orthographic, so a metre is the same on every one. Pure.
+import { BESIDE_NAME } from "../beside.js";
 import { build, drawnPieces } from "./index.js";
 import { check } from "../fit.js";
 import { axesOf, cleanView, directionOf, VIEWS } from "../framing.js";
@@ -20,6 +21,23 @@ export const COMPARES = {
     person: { name: "A person, 1.8 m", height: 1.8, width: 0.5 },
     building: { name: "A ten-storey building, 30 m", height: 30, width: 18 },
 };
+/**
+ * The real craft that lie in the fleet band for scale: Starship with Super Heavy, Saturn V, SLS and the International Space Station. Each is a variant of the package, so its length is the sourced figure, `axis` is the way its length runs in its own model
+ * (`y` up the stack, nose up; `x` along the station's long axis), and a rocket points its nose right. They are never scaled: they are drawn at the lineup's own scale.
+ *
+ * @example
+ * ```ts
+ * import { REAL_CRAFT } from "@johnmorrisdotca/uchusen-rockets/build";
+ *
+ * console.log(REAL_CRAFT.map((craft) => craft.name));
+ * ```
+ */
+export const REAL_CRAFT = [
+    { key: "starship:v3", name: BESIDE_NAME, axis: "y" },
+    { key: "saturn-v:saturn-v", name: "Saturn V", axis: "y" },
+    { key: "sls:block-1", name: "SLS Block 1", axis: "y" },
+    { key: "iss:iss", name: "ISS", axis: "x" },
+];
 const xmlText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 const n = (v) => (Math.round(v * 10) / 10).toString();
 /** A rocket painted black all over vanishes on the dark ground of a lineup, so it takes the line look's colour for its outline. Only the lines change: its shape and its figures stay. */
@@ -29,6 +47,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 +65,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, the real craft lying beside the fleet (`real`, with their lengths), 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 +75,42 @@ 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] };
+}
+/**
+ * The camera of a real craft lying in the fleet band, square on to its windward side: a rocket (`y`) points its nose right with its windward side towards us, and the station (`x`) runs along its long axis with y up. Orthographic at the lineup's scale, so
+ * a metre is the same on it as on every ship.
+ */
+export function lyingCamera(axis, b, x0, baseY, unit) {
+    const along = axis === "y" ? 1 : 0;
+    return {
+        project: (p) => [x0 + (p[along] - b.min[along]) * unit, axis === "y" ? baseY + (p[0] - b.max[0]) * unit : baseY - (p[1] - b.min[1]) * unit],
+        depth: (p) => -p[2],
+        toward: () => [0, 0, 1],
+        above: false,
+    };
+}
+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 +136,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 +168,100 @@ 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);
+    }
+    // the real craft for scale lie in the same band, one row each, at the same scale: a rocket nose right, the station along its long axis
+    const real = [];
+    let realEnd = 0;
+    if (ships.length && options.real)
+        for (const craft of REAL_CRAFT) {
+            const [rocket, variant] = craft.key.split(":");
+            const named = variantOf(rocket, variant);
+            if (!named || !check({ rocket, variant: named.id }).ok)
+                continue;
+            const built = build({ rocket, variant: named.id });
+            const b = built.boundsOf("together");
+            // a rocket's long axis is y and the picture's up is -x (its windward side faces us); the station's is x, with y up
+            const along = craft.axis === "y" ? 1 : 0;
+            const length = b.max[along] - b.min[along];
+            const tall = craft.axis === "y" ? b.max[0] - b.min[0] : b.max[1] - b.min[1];
+            const baseY = fleetY + 6 + tall * unit;
+            const x0 = rulerRoom;
+            const cam = lyingCamera(craft.axis, b, x0, baseY, unit);
+            const show = built.shows[0];
+            const edge = edgeOf(built, look);
+            for (const place of built.placesOf(show).filter((one) => one.shown).sort((a, c) => a.at[2] - c.at[2])) {
+                const part = 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"/>`);
+            // the length is the sourced one: a rocket's height, the station's overall length
+            const sourced = craft.axis === "y" ? named.facts.height.value : named.facts.diameter.value;
+            const metres = typeof sourced === "number" ? sourced : Math.round(length * 10) / 10;
+            const text = `${craft.name}, ${metres.toLocaleString("en-US")} m`;
+            if (labels)
+                fleetBody.push(`<text x="${n(x0 + length * unit + 8)}" y="${n(baseY - 2)}" font-size="11" fill="currentColor">${xmlText(text)}</text>`);
+            real.push({ key: craft.key, label: craft.name, height: metres });
+            realEnd = Math.max(realEnd, x0 + length * unit + (labels ? 8 + text.length * 6.2 : 0));
+            fleetY = baseY + 10;
+        }
+    if (ships.length) {
+        width = Math.max(width, rulerRoom + longest * unit + 8, realEnd + 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, real, 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[];

package/dist/data/ship02.js

@@ -0,0 +1,100 @@
+// ISV 加美鳴 (かみなり) Kaminari, SPX-207, the Interstellar Heavy Transport, as data. Its status stays "fictional" in the data (the .glb exemption keys on it) and is shown nowhere; every figure names the design bible (docs/fleet/ship-02.md) as its source and
+// none is a measurement of anything real. Sizes are the model's own; the numbers of the voyage are worked out in src/model/fleet/ship-02/journey.ts.
+import {} from "./types.js";
+import { LENGTH } from "../model/fleet/ship-02/dims.js";
+import { SHIP_02_SLOTS, SHIP_02_VARIANT_PARTS } from "../model/fleet/ship-02/index.js";
+import { SECTIONS } from "../model/fleet/ship-02/sections.js";
+import { DECKS, ENGINE_CARDS, HULL_STACK_RING, INSETS, NOTES, SPEC } from "../model/fleet/ship-02/specs.js";
+const S = "uchusen-fleet-ship-02";
+const fig = (value, note) => ({ value, source: S, ...(note ? { note } : {}) });
+export const SHIP_02_LENGTH = fig(LENGTH, "Tail to the tip of the bow mast.");
+const wording = (value, note) => ({ value, source: S, ...(note ? { note } : {}) });
+const t = (n) => (n >= 1e6 ? `${(n / 1e6).toFixed(2)} million t` : `${Math.round(n).toLocaleString("en-US")} t`);
+/** Replace a shell by its inside part where an inset has cut the ship open, so the viewer shows the inside without a cut. */
+const viewerSlots = (slots, cut) => {
+    const insides = new Set(slots.filter((s) => s.endsWith("-inside")).map((s) => s.replace("-inside", "")));
+    return slots.filter((s) => !cut || !(insides.has(s) || (s.startsWith("habitat-") && !s.endsWith("inside") && slots.includes("habitat-inside"))));
+};
+const INSPECTOR = {
+    sections: SECTIONS.map((x) => ({ id: x.id, name: x.name, job: x.job, slot: x.slot, at: x.at, inside: Boolean(x.inside) })),
+    places: Object.fromEntries(SHIP_02_SLOTS.map((slot) => [slot.slot, slot.at])),
+    spec: [
+        ["Name", "ISV 加美鳴 (かみなり) Kaminari, \"thunder\""],
+        ["Role", "大型輸送船, large transport ship"],
+        ["Designation", "SPX-207 · IHT class (Interstellar Heavy Transport)"],
+        ["Operator", "SPX"],
+        ["Drive", "FTD, Fusion Torch Drive, 8 nozzles"],
+        ["Computer", "KAZE core v4"],
+        ["Small craft", "ATC (Auxiliary Transfer Craft)"],
+        ["Status", "Planned: first flight 2520"],
+        ["Length", `${SPEC.length.toLocaleString("en-US")} m`],
+        ["Beam (radiators out)", `${SPEC.beam} m (${SPEC.beamRadiatorsOut} m)`],
+        ["Dry mass", t(SPEC.dryMassT)],
+        ["Full mass", t(SPEC.fullMassT)],
+        ["Crew", `${SPEC.crewNominal} (max ${SPEC.crewMax})`],
+        ["Passengers", SPEC.passengers.toLocaleString("en-US")],
+        ["Cargo", `${t(SPEC.cargoT)}, ${SPEC.containers} containers`],
+        ["Propellant", `${t(SPEC.propellantT)} of ${t(SPEC.tankCapacityT)}`],
+        ...ENGINE_CARDS.map((c) => [c.name, `${c.count} x ${(c.thrustEachN / 1e6).toLocaleString("en-US", { maximumFractionDigits: 2 })} MN, Isp ${Math.round(c.isp).toLocaleString("en-US")} s`]),
+        ["Main thrust", `${(SPEC.mainThrustN / 1e9).toFixed(2)} GN at full mass`],
+        ["Manoeuvring thrust", `${SPEC.maneuverThrustN / 1e6} MN (verniers)`],
+        ["Acceleration", `${SPEC.maxG} g`],
+        ["Cruise / top speed", `${SPEC.cruiseC.toFixed(3)} c / ${SPEC.topC} c`],
+        ["Proxima, 4.37 ly", `${SPEC.proxima.shipYears.toFixed(1)} y on board, ${SPEC.proxima.earthYears.toFixed(1)} y Earth`],
+        ["Range, full payload", `${SPEC.rangeLy} ly`],
+        ["Endurance", `${SPEC.enduranceYears} years sealed`],
+        ["Hull layers (crew rings)", `${HULL_STACK_RING.length}, outside to inside: ${HULL_STACK_RING.map((l) => `${l.n} ${l.name} ${l.thicknessM} m`).join("; ")}`],
+        ["Decks", `${DECKS.length}, bow to stern`],
+    ],
+    notes: { propulsion: NOTES.propulsion, construction: NOTES.construction, history: NOTES.history, equipment: NOTES.equipment },
+    insets: INSETS.map((i) => ({
+        id: i.id,
+        name: i.name,
+        slots: viewerSlots(i.slots, i.cut !== undefined),
+        target: i.view.target,
+        direction: i.view.from,
+        distance: i.view.dist,
+        parts: i.parts.map((p) => ({ n: p.n, name: p.name, at: p.at, slot: "" })),
+    })),
+};
+const STANDARD = {
+    id: "fleet-02",
+    rocket: "fleet-02",
+    name: "ISV 加美鳴 (かみなり) Kaminari, SPX-207",
+    status: "fictional",
+    firstWord: "Planned first flight",
+    firstFlight: { value: "2520", source: S, note: "Planned first flight." },
+    slots: SHIP_02_SLOTS.map((slot) => slot.slot),
+    note: "An original SPX fleet design, drawn in code from the table of numbers in docs/fleet/ship-02.md. The inside parts are the cutaway's contents: show one alone to see it.",
+    inspector: INSPECTOR,
+    facts: {
+        height: SHIP_02_LENGTH,
+        diameter: fig(410, "The bow shield, the widest part of the hull. With both radiator wings out the ship is 910 m across."),
+        parts: Object.fromEntries(SHIP_02_SLOTS.map((slot) => [slot.slot, fig(slot.height)])),
+        engines: { "drive-engines": wording("8 fusion torch nozzles, 4 vernier clusters", "See the design bible for the mechanism and its limits.") },
+        more: {
+            designation: wording("SPX-207", "Interstellar Heavy Transport."),
+            "dry mass, tonnes": fig(1_100_000, "Design target."),
+            "full mass, tonnes": fig(8_450_000, "With 1,000,000 t of payload and 6,350,000 t of propellant."),
+            "width with radiators out, m": fig(910),
+            crew: fig(640),
+            passengers: fig(60000, "24,000 awake in two rings and 36,000 in cold-sleep berths."),
+        },
+    },
+};
+const NAMES = {
+    "fleet-02-survey": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, survey configuration", "Survey pod on the dorsal mount, laboratory pod underneath, relay masts on the wing tips: the same ship for mapping a system."],
+    "fleet-02-tanker": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, tanker configuration", "Tanker pod on the dorsal mount, cargo pod underneath, a tug on each wing tip: the same ship for fuelling a station."],
+    "fleet-02-rescue": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, rescue configuration", "Settlement pod as a refuge on the dorsal mount, rescue pod underneath, a tug on each wing tip: the same ship for an evacuation."],
+};
+const STANDARD_PARTS = Object.fromEntries(SHIP_02_SLOTS.map((s) => [s.slot, `fleet-02-fleet-02-${s.slot}`]));
+export const SHIP_02_VARIANTS = [
+    STANDARD,
+    ...Object.entries(SHIP_02_VARIANT_PARTS).map(([id, swaps]) => ({
+        ...STANDARD,
+        id,
+        name: NAMES[id][0],
+        note: NAMES[id][1],
+        partIds: { ...STANDARD_PARTS, ...swaps },
+    })),
+];