@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.10.0

package/dist/model/fleet/ship-02/journey.d.ts

@@ -0,0 +1,59 @@
+/** The speed of light, metres a second. */
+export declare const C = 299792458;
+/** One standard gravity, metres a second squared. */
+export declare const G0 = 9.80665;
+/** A Julian year, seconds. */
+export declare const YEAR_S = 31557600;
+/** A light year, metres. */
+export declare const LY: number;
+export interface Voyage {
+    /** The distance, in light years. */
+    lightYears: number;
+    /** The proper acceleration, in g. */
+    g: number;
+    /** The rapidity at the midpoint. */
+    rapidity: number;
+    /** The peak speed as a fraction of c, reached at the flip. */
+    peak: number;
+    /** The Lorentz factor at the flip. */
+    gamma: number;
+    /** Years on board. */
+    shipYears: number;
+    /** Years in the frame of the two ends. */
+    endpointYears: number;
+    /** Years on board for the half before the flip. */
+    halfShipYears: number;
+}
+/**
+ * The flip-and-burn voyage over a distance at a proper acceleration.
+ *
+ * @param lightYears The distance between the two ends, in light years.
+ * @param g The proper acceleration, in g (9.80665 m/s^2).
+ * @returns The peak speed, the Lorentz factor and the two durations.
+ * @example
+ * ```ts
+ * import { voyage } from "./journey.ts";
+ *
+ * console.log(voyage(4.37, 0.015).shipYears.toFixed(2));
+ * ```
+ */
+export declare function voyage(lightYears: number, g: number): Voyage;
+/** The mass ratio (start over finish) of the ideal relativistic rocket for a voyage, at an exhaust speed that is a fraction of c. */
+export declare const massRatio: (v: Voyage, exhaustFraction: number) => number;
+/** The farthest a ship can go at a proper acceleration with a mass ratio, in light years: the inverse of `voyage` and `massRatio`. */
+export declare function rangeLightYears(ratio: number, exhaustFraction: number, g: number): number;
+/** The thrust, in newtons, of a ship of this mass (tonnes) at this proper acceleration, in g. */
+export declare const thrustN: (massTonnes: number, g: number) => number;
+/** The jet power, in watts, at a thrust and an exhaust speed that is a fraction of c (the non-relativistic half F v_e, which is the right order for v_e = 0.4 c). */
+export declare const jetPowerW: (thrust: number, exhaustFraction: number) => number;
+/** A ship's voyage numbers worked from its masses: dry, payload and propellant, all in tonnes. */
+export declare function ship02Budget(g: number, exhaustFraction: number, lightYears: number, dryT: number, payloadT: number, propellantT: number): {
+    voyage: Voyage;
+    fullMassT: number;
+    ratio: number;
+    arrivalMassT: number;
+    propellantUsedT: number;
+    propellantLeftT: number;
+    startThrustN: number;
+    startJetPowerW: number;
+};

package/dist/model/fleet/ship-02/journey.js

@@ -0,0 +1,59 @@
+// The voyage arithmetic for Ship 02 (and any ship that flies the same profile): relativistic constant proper acceleration, turning round at the halfway point, in an inertial frame in which both ends
+// are at rest. No cruise coast and no clamp. For a trip of length D at proper acceleration a, with c the speed of light: the midpoint rapidity is eta = acosh(1 + aD / (2c^2)); the peak speed is c tanh(eta);
+// the time on board is 2c eta / a; the time in the endpoints' frame is 2c sinh(eta) / a. A rocket whose exhaust leaves at v_e (a fraction of c) and which changes its rapidity by 2 eta needs the mass
+// ratio exp(2 eta / (v_e / c)). Pure, and the same formulas the other ships use.
+/** The speed of light, metres a second. */
+export const C = 299_792_458;
+/** One standard gravity, metres a second squared. */
+export const G0 = 9.80665;
+/** A Julian year, seconds. */
+export const YEAR_S = 31_557_600;
+/** A light year, metres. */
+export const LY = C * YEAR_S;
+/**
+ * The flip-and-burn voyage over a distance at a proper acceleration.
+ *
+ * @param lightYears The distance between the two ends, in light years.
+ * @param g The proper acceleration, in g (9.80665 m/s^2).
+ * @returns The peak speed, the Lorentz factor and the two durations.
+ * @example
+ * ```ts
+ * import { voyage } from "./journey.ts";
+ *
+ * console.log(voyage(4.37, 0.015).shipYears.toFixed(2));
+ * ```
+ */
+export function voyage(lightYears, g) {
+    const a = g * G0;
+    const d = lightYears * LY;
+    const rapidity = Math.acosh(1 + (a * d) / (2 * C * C));
+    return {
+        lightYears,
+        g,
+        rapidity,
+        peak: Math.tanh(rapidity),
+        gamma: Math.cosh(rapidity),
+        shipYears: (2 * C * rapidity) / a / YEAR_S,
+        endpointYears: (2 * C * Math.sinh(rapidity)) / a / YEAR_S,
+        halfShipYears: (C * rapidity) / a / YEAR_S,
+    };
+}
+/** The mass ratio (start over finish) of the ideal relativistic rocket for a voyage, at an exhaust speed that is a fraction of c. */
+export const massRatio = (v, exhaustFraction) => Math.exp((2 * v.rapidity) / exhaustFraction);
+/** The farthest a ship can go at a proper acceleration with a mass ratio, in light years: the inverse of `voyage` and `massRatio`. */
+export function rangeLightYears(ratio, exhaustFraction, g) {
+    const rapidity = (Math.log(ratio) * exhaustFraction) / 2;
+    return ((Math.cosh(rapidity) - 1) * 2 * C * C) / (g * G0) / LY;
+}
+/** The thrust, in newtons, of a ship of this mass (tonnes) at this proper acceleration, in g. */
+export const thrustN = (massTonnes, g) => massTonnes * 1000 * g * G0;
+/** The jet power, in watts, at a thrust and an exhaust speed that is a fraction of c (the non-relativistic half F v_e, which is the right order for v_e = 0.4 c). */
+export const jetPowerW = (thrust, exhaustFraction) => 0.5 * thrust * exhaustFraction * C;
+/** A ship's voyage numbers worked from its masses: dry, payload and propellant, all in tonnes. */
+export function ship02Budget(g, exhaustFraction, lightYears, dryT, payloadT, propellantT) {
+    const v = voyage(lightYears, g);
+    const full = dryT + payloadT + propellantT;
+    const ratio = massRatio(v, exhaustFraction);
+    const arrival = full / ratio;
+    return { voyage: v, fullMassT: full, ratio, arrivalMassT: arrival, propellantUsedT: full - arrival, propellantLeftT: arrival - dryT - payloadT, startThrustN: thrustN(full, g), startJetPowerW: jetPowerW(thrustN(full, g), exhaustFraction) };
+}

package/dist/model/fleet/ship-02/lines.d.ts

@@ -0,0 +1,2 @@
+import { type Piece } from "./adapter.ts";
+export declare function linesPieces(): Piece[];

package/dist/model/fleet/ship-02/lines.js

@@ -0,0 +1,53 @@
+// The propellant plumbing, in ship coordinates: from each tank's tail pole a trunk and a return line run out beneath the tank, round the outside of the shadow shield and down to the drive raft's bulkhead,
+// and crossover lines tie the four tanks together at three heights, so any tank can feed any engine and the ship's trim can be held by moving propellant. Valve houses, flange pairs and clamps all the way.
+import { beam, box, pipe, ring, span } from "./adapter.js";
+import { STATION, TANK } from "./dims.js";
+const T0 = STATION.tank.y;
+const DROP = 337;
+/** A pipe with flange rings every `pitch` metres and a valve house at each of `valves`. */
+function run(a, b, r, material, pitch = 18, valves = []) {
+    const out = [pipe(material, a, b, r, 10)];
+    const len = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    for (let d = pitch / 2; d < len; d += pitch) {
+        const t = d / len;
+        const p = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+        out.push(box("engine-metal", p, [r * 2.7, r * 2.7, r * 2.7]));
+    }
+    for (const t of valves) {
+        const p = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+        out.push(box("dark", p, [r * 4, r * 4, r * 4]), box("hull-yellow", [p[0], p[1], p[2] + r * 2.6], [r * 1.6, r * 1.6, r * 1.2]), box("hull-orange", [p[0], p[1] + r * 2.6, p[2]], [r * 1.2, r * 1.2, r * 1.6]));
+    }
+    return out;
+}
+export function linesPieces() {
+    const out = [];
+    const o = TANK.offset;
+    for (const sx of [-1, 1])
+        for (const sz of [-1, 1]) {
+            // from the tail pole, down to the collector height, out to the trunk column, down to the raft
+            const trunk = [sx * 168, 0, sz * 40];
+            out.push(...run([sx * o, T0 - 1, sz * o], [sx * o, DROP, sz * o], 3.6, "coolant", 12, [0.5]));
+            out.push(...run([sx * o, DROP, sz * o], [trunk[0], DROP, trunk[2]], 3.6, "coolant", 14, [0.35, 0.8]));
+            out.push(...run([trunk[0], DROP, trunk[2]], [trunk[0], 176, trunk[2]], 3.6, "coolant", 16, [0.2, 0.55, 0.85]));
+            out.push(...run([sx * (o + 8), T0 - 1, sz * (o + 8)], [sx * (o + 8), DROP + 4, sz * (o + 8)], 2.2, "hull-orange", 12));
+            out.push(...run([sx * (o + 8), DROP + 4, sz * (o + 8)], [trunk[0] + sx * 8, DROP + 4, trunk[2] + sz * 8], 2.2, "hull-orange", 14));
+            out.push(...run([trunk[0] + sx * 8, DROP + 4, trunk[2] + sz * 8], [trunk[0] + sx * 8, 176, trunk[2] + sz * 8], 2.2, "hull-orange", 16));
+            // brackets: a post from the shield's rim out to the trunk at three heights
+            for (const y of [190, 230, 270, 310])
+                out.push(beam("hull-grey", [sx * 140, y, sz * 36], [trunk[0] - sx * 4, y, trunk[2]], 3, 3));
+            // the feed header where it meets the raft: a fat distribution box, and a ring of pipes to each side
+            out.push(box("dark", [trunk[0], 178, trunk[2]], [18, 8, 14]), box("hull-orange", [trunk[0], 183, trunk[2]], [14, 2, 10]), ring("copper", [trunk[0], trunk[2]], 3.6, 5.2, 176, 180, 10));
+        }
+    // crossovers between neighbouring tanks: across the gap above the spine (x), and through the gap between dorsal and ventral tanks (z), at three heights each
+    for (const y of [T0 + 90, T0 + 220, T0 + 350]) {
+        for (const sz of [-1, 1])
+            out.push(...run([-o + TANK.radius - 1, y, sz * o], [o - TANK.radius + 1, y, sz * o], 2.6, "hull-white", 14, [0.5]));
+        for (const sx of [-1, 1])
+            out.push(...run([sx * o, y, TANK.radius - 1 + 0], [sx * o, y, -TANK.radius + 1], 2.6, "hull-orange", 14, [0.5]));
+        out.push(box("dark", [0, y, 0], [1, 1, 1]));
+    }
+    // a collector ring round the spine under the tanks, joining the four trunks
+    out.push(ring("coolant", [0, 0], 22, 25.4, DROP - 6, DROP - 2, 24), ring("hull-yellow", [0, 0], 25.4, 26.4, DROP - 5, DROP - 3, 24));
+    out.push(span("dark", -26, 26, DROP - 8, DROP - 6, -26, 26));
+    return out;
+}

package/dist/model/fleet/ship-02/pod.d.ts

@@ -0,0 +1,17 @@
+import { type Piece } from "./adapter.ts";
+export declare const POD: {
+    readonly y: 480;
+    readonly z: 62;
+    readonly length: 120;
+    readonly radius: 15;
+};
+/** What both variants share: the keyed collar, the three clamp arms to the spine, the umbilical, and the pod's cylindrical hull with its end domes. */
+export declare function common(seed: number, tone: "hull-orange" | "hull-white"): Piece[];
+/** The survey pod: three laboratory decks with a window strip, a sample hangar door, sensor masts, dishes, and a telescope barrel on the bow end. */
+export declare function podSurvey(): Piece[];
+/** The settlement pod: two decks of round windows, a glazed greenhouse band, two docking ports on the bow end and a ring of clamp lights. */
+export declare function podSettlement(): Piece[];
+/** The tanker pod: a pressurised barrel with two outboard propellant spheres, a transfer manifold and a hose reel, for carrying fuel to another ship or a station. */
+export declare function podTanker(): Piece[];
+/** The cargo pod: a frame holding six small containers round a barrel, with twist-lock plates, a crane rail and a hatch door at each end. */
+export declare function podCargo(): Piece[];

package/dist/model/fleet/ship-02/pod.js

@@ -0,0 +1,119 @@
+// The swappable mission pod: one 120 m module on a dorsal keyed collar between the two upper tanks, the one part of the ship that changes with the mission while the frame stays the same. Two variants stand in
+// the same mount: a survey pod (laboratories, sensor masts and a sample hangar) and a settlement pod (round-windowed habitat decks, a greenhouse and two docking ports). Both take the same three clamp arms, the
+// same 12 m standard collar and the same service umbilical. The pod lies along y at z = 62 over the spine; its local frame has its mount at (0, 0, 0).
+import { beam, box, collar, cyl, dish, drum, forDrawing, hatch, hazard, lights, mast, onHull, pipe, plating, PLATE, revolve, ring, rng, span, stencil, facesOf, vent } from "./adapter.js";
+export const POD = { y: 480, z: 62, length: 120, radius: 15 };
+/** What both variants share: the keyed collar, the three clamp arms to the spine, the umbilical, and the pod's cylindrical hull with its end domes. */
+export function common(seed, tone) {
+    const r = rng(seed);
+    const out = [];
+    const R = POD.radius;
+    out.push({ kind: "lathe", material: "hull-grey", at: [0, 0], segs: 28, body: true, outline: true, rings: [10, 110], profile: [[0.001, 0], [R * 0.7, 2], [R, 8], [R, POD.length - 8], [R * 0.7, POD.length - 2], [0.001, POD.length]] });
+    // the pod lies on its side, so its axis is y and its up is +z; the mount is the underside, at z = -R, 3 clamp arms to the spine's dorsal face at z = 18 - 62
+    for (const y of [14, 60, 106]) {
+        out.push(beam("hull-orange", [-R * 0.8, y, -R * 0.55], [-9, y, -POD.z + 20], 3, 3, true), beam("hull-orange", [R * 0.8, y, -R * 0.55], [9, y, -POD.z + 20], 3, 3, true));
+        out.push(box("hull-yellow", [0, y, -R - 0.5], [8, 3, 1.6]), ring("engine-pale", [0, 0], 0.01, 0.02, 0, 0.01, 4));
+    }
+    out.push(span("dark", -12, 12, 0, POD.length, -POD.z + 17, -POD.z + 20, true));
+    // the keyed collar: a standard 12 m collar facing the spine, with its key lug, and an umbilical bundle
+    out.push(...collar([0, -POD.z + 20], 0, 1, 6).map((p) => p).slice(0, 0));
+    out.push(box("coolant", [-3, 40, -R - 1], [2.4, 80, 1.6]), box("hull-orange", [3, 40, -R - 1], [2.4, 80, 1.6]), box("black", [0, 20, -R - 1.8], [8, 3, 1.2]));
+    // hull bands, plating, panels and stencils
+    for (let k = 0; k < 18; k++) {
+        const a = (k / 18) * 2 * Math.PI;
+        for (const [y0, y1] of [[10, 50], [54, 94]])
+            if (!r.chance(0.08))
+                out.push(onHull(r.pick([tone, "hull-grey", "hull-grey", "hull-grey-dark", "hull-white"]), [0, 0], a, R, (y0 + y1) / 2, 5.4, y1 - y0 - 1, 0.35 + 0.25 * r.next()));
+    }
+    out.push(ring(tone, [0, 0], R, R + 0.6, 6, 12, 28), ring(tone, [0, 0], R, R + 0.6, POD.length - 12, POD.length - 6, 28), ring("hull-yellow", [0, 0], R, R + 0.5, 56, 58, 28));
+    void drum;
+    void forDrawing;
+    void hatch;
+    void hazard;
+    void lights;
+    void mast;
+    void pipe;
+    void plating;
+    void PLATE;
+    void revolve;
+    void stencil;
+    void facesOf;
+    void vent;
+    void cyl;
+    void dish;
+    return out;
+}
+/** The survey pod: three laboratory decks with a window strip, a sample hangar door, sensor masts, dishes, and a telescope barrel on the bow end. */
+export function podSurvey() {
+    const out = common(2100, "hull-white");
+    const R = POD.radius;
+    for (let k = 0; k < 18; k++) {
+        const a = (k / 18) * 2 * Math.PI + 0.1;
+        if (Math.cos(a) < 0.1 && Math.sin(a) !== 0)
+            continue;
+        out.push(onHull("glass", [0, 0], a, R + 0.3, 30, 4, 3, 0.3), onHull("lamp-blue", [0, 0], a, R + 0.5, 30, 3, 0.8, 0.2), onHull("glass", [0, 0], a, R + 0.3, 74, 4, 3, 0.3));
+    }
+    // a sample hangar door on the outboard side, hazard frame
+    out.push(onHull("dark", [0, 0], Math.PI / 2, R, 82, 14, 22, 1.2), onHull("hull-yellow", [0, 0], Math.PI / 2, R + 1, 82, 12, 20, 0.5), onHull("hull-orange", [0, 0], Math.PI / 2, R + 1.4, 82, 10, 18, 0.4));
+    // sensor masts, dishes, a telescope barrel at the bow end (+y), spectrometer drum
+    for (const [x, y] of [[-7, 30], [7, 44], [0, 90]])
+        out.push(beam("engine-metal", [x, y, R], [x, y, R + 14], 0.8, 0.8), box("lamp-red", [x, y, R + 14.4], [1.6, 1.6, 1.6]), box("engine-metal", [x, y, R + 11], [6, 0.6, 0.6]));
+    out.push(...dish([-8, 66], R + 3, 7), ...dish([8, 96], R + 3, 6));
+    out.push(drum("engine-pale", [0, 0], 6, POD.length, POD.length + 26, 24), ring("copper", [0, 0], 6, 7, POD.length + 10, POD.length + 14, 24), ring("dark", [0, 0], 0.01, 6.4, POD.length + 26, POD.length + 28, 24), ring("dark", [0, 0], 6.4, 8, POD.length + 24, POD.length + 26, 24));
+    out.push(box("lamp-blue", [0, 32, -3], [1, 1, 1]));
+    return out;
+}
+/** The settlement pod: two decks of round windows, a glazed greenhouse band, two docking ports on the bow end and a ring of clamp lights. */
+export function podSettlement() {
+    const out = common(2101, "hull-white");
+    const R = POD.radius;
+    for (let k = 0; k < 24; k++) {
+        const a = (k / 24) * 2 * Math.PI;
+        for (const y of [20, 34, 76, 90])
+            out.push(onHull("dark", [0, 0], a, R + 0.2, y, 3.4, 3.4, 0.4), onHull("glass", [0, 0], a, R + 0.5, y, 2.4, 2.4, 0.3), onHull("lamp-blue", [0, 0], a, R + 0.7, y, 1.6, 0.5, 0.2));
+    }
+    out.push({ kind: "lathe", material: "glass", at: [0, 0], segs: 28, only: "mesh", profile: [[R + 0.8, 44], [R + 0.8, 66]] }, { kind: "lathe", material: "plant", at: [0, 0], segs: 28, only: "mesh", profile: [[R - 3, 44], [R - 3, 66]] });
+    for (let y = 46; y < 66; y += 4)
+        out.push(ring("engine-metal", [0, 0], R + 0.7, R + 1.5, y, y + 0.8, 28));
+    out.push(...collar([-6, 0], POD.length, 1, 5), ...collar([6, 0], POD.length, 1, 5));
+    out.push(box("dark", [0, POD.length + 4, 0], [22, 8, 12]), box("hull-yellow", [0, POD.length + 8.3, 0], [18, 0.6, 8]));
+    return out;
+}
+/** The tanker pod: a pressurised barrel with two outboard propellant spheres, a transfer manifold and a hose reel, for carrying fuel to another ship or a station. */
+export function podTanker() {
+    const out = common(2102, "hull-white");
+    const R = POD.radius;
+    for (const sx of [-1, 1])
+        for (const y of [34, 86]) {
+            out.push(revolve("hull-grey", [sx * (R + 9), 0], Array.from({ length: 9 }, (_, i) => [9 * Math.sin((i / 8) * Math.PI), y - 9 * Math.cos((i / 8) * Math.PI)]), 20));
+            out.push(ring("engine-pale", [sx * (R + 9), 0], 8.9, 9.6, y - 0.8, y + 0.8, 20), beam("engine-metal", [sx * R * 0.9, y, 0], [sx * (R + 4), y, 0], 2, 2));
+            out.push(...mastPair(sx, y));
+        }
+    out.push(pipe("coolant", [-R - 9, 20, 0], [R + 9, 20, 0], 1.4, 8), pipe("hull-orange", [-R - 9, 100, 0], [R + 9, 100, 0], 1.4, 8));
+    out.push(drum("dark", [0, 0], 4, POD.length, POD.length + 14, 16), ring("hull-yellow", [0, 0], 4, 6, POD.length + 4, POD.length + 8, 16), ...collar([0, 0], POD.length + 14, 1, 5));
+    return out;
+}
+function mastPair(sx, y) {
+    return [pipe("coolant", [sx * (POD.radius + 9), y + 9, 0], [sx * (POD.radius + 9), y + 16, 0], 0.8, 8), box("hull-yellow", [sx * (POD.radius + 9), y + 17, 0], [2.4, 2, 2.4])];
+}
+/** The cargo pod: a frame holding six small containers round a barrel, with twist-lock plates, a crane rail and a hatch door at each end. */
+export function podCargo() {
+    const out = common(2103, "hull-white");
+    const R = POD.radius;
+    const r = rng(2104);
+    for (let k = 0; k < 6; k++) {
+        const a = (k / 6) * 2 * Math.PI + Math.PI / 6;
+        const x = (R + 6) * Math.sin(a);
+        const z = (R + 6) * Math.cos(a);
+        for (const y of [32, 82]) {
+            out.push(box(r.pick(["hull-orange", "hull-grey", "hull-white", "coolant", "blanket"]), [x, y, z], [9, 40, 9]));
+            for (const sx of [-1, 1])
+                for (const sy of [-1, 1])
+                    out.push(box("dark", [x + sx * 4, y + sy * 19, z + sz(sx)], [1.6, 1.6, 1.6]));
+            out.push(box("hull-yellow", [x, y - 20.4, z], [6, 0.8, 6]), beam("hull-grey", [x * 0.55, y - 20, z * 0.55], [x, y - 20, z], 1.2, 1.2));
+        }
+    }
+    out.push(span("hull-yellow", -0.4, 0.4, 6, POD.length - 6, R + 11, R + 11.8), ...collar([0, 0], POD.length, 1, 5));
+    return out;
+}
+const sz = (sx) => sx * 2;

package/dist/model/fleet/ship-02/radiators.d.ts

@@ -0,0 +1,5 @@
+import { type Piece } from "./adapter.ts";
+/** One wing, from the hull's flank outward on the x axis, from y 0 to its length. `side` is the sign of x. */
+export declare function wing(side: 1 | -1, length?: number, panels?: number, panelWidth?: number, root?: number): Piece[];
+/** A stowed pack: six panels folded into a stack 56 m by 56 m by 24 m, held by four latch brackets, on a short arm. */
+export declare function stowed(length?: number): Piece[];

package/dist/model/fleet/ship-02/radiators.js

@@ -0,0 +1,62 @@
+// The radiator wings: two flat wings, one each side, in the plane between the upper and lower tanks. Each is six panels (a header pipe, tube rows, ribs and a hinge edge) hung from a boom, deployed. A stowed
+// pack of folded panels rides on each side of the spine as well, shown as the folded stack with its latch brackets: the same panel, folded.
+import { beam, box, forDrawing, pipe, rng, span, stencil, facesOf } from "./adapter.js";
+/** One wing, from the hull's flank outward on the x axis, from y 0 to its length. `side` is the sign of x. */
+export function wing(side, length = 560, panels = 6, panelWidth = 56, root = 44) {
+    const r = rng(2080 + side);
+    const out = [];
+    const s = side;
+    // the boom along the root edge: a box girder with a pipe header either side
+    out.push(span("hull-grey", s > 0 ? root - 3 : -root - 3, s > 0 ? root + 3 : -root + 3, 0, length, -4, 4, true));
+    out.push(pipe("hull-orange", [s * (root + 3), 0, 3], [s * (root + 3), length, 3], 1.8, 8, false), pipe("coolant", [s * (root + 3), 0, -3], [s * (root + 3), length, -3], 1.8, 8, false));
+    const sections = 8;
+    const sl = length / sections;
+    for (let p = 0; p < panels; p++) {
+        const x0 = root + 3 + p * (panelWidth + 2);
+        const mid = s * (x0 + panelWidth / 2);
+        out.push(forDrawing(span("dark", Math.min(s * x0, s * (x0 + panelWidth)), Math.max(s * x0, s * (x0 + panelWidth)), 0, length, -0.7, 0.7, true)));
+        for (let q = 0; q < sections; q++) {
+            const y0 = q * sl + 1.2;
+            const m = r.chance(0.08) ? "hull-grey-dark" : "dark";
+            // the panel face: a thin plate; tube rows across it as thin raised strips; ribs between sections
+            out.push(span(m, Math.min(s * x0, s * (x0 + panelWidth)), Math.max(s * x0, s * (x0 + panelWidth)), y0, y0 + sl - 2.4, -0.7, 0.7, false));
+            for (let t = 0; t < 7; t++) {
+                const xx = s * (x0 + 4 + t * 8);
+                out.push(span("coolant", xx - 0.8, xx + 0.8, y0 + 1, y0 + sl - 3.4, 0.7, 1.5), span("coolant", xx - 0.8, xx + 0.8, y0 + 1, y0 + sl - 3.4, -1.5, -0.7));
+            }
+            out.push(span("engine-metal", Math.min(s * x0, s * (x0 + panelWidth)), Math.max(s * x0, s * (x0 + panelWidth)), y0 + sl - 3.4, y0 + sl - 2.4, -1.6, 1.6));
+            if (r.chance(0.2))
+                out.push(box("hull-orange-worn", [mid + r.range(-14, 14), y0 + sl / 2, 1], [r.range(6, 14), r.range(6, 14), 0.3]));
+        }
+        // hinge edge: a rod with knuckles every section, and a lit edge strip
+        const xe = s * (x0 + panelWidth);
+        out.push(pipe("engine-metal", [xe, 0, 0], [xe, length, 0], 1.6, 8, false));
+        for (let q = 0; q <= sections; q++)
+            out.push(box("hull-yellow", [xe, q * sl + 0.6, 0], [3, 2.2, 3.4]));
+        // a pair of struts across the panel from the hinge to the one before
+        if (p > 0)
+            for (let q = 0; q < sections; q += 2)
+                out.push(beam("engine-metal", [s * x0, q * sl + 2, 0], [s * (x0 - 2), q * sl + sl, 0], 1, 1, false));
+    }
+    // end-cap stencil and the tip lamps
+    const tip = s * (root + 3 + panels * (panelWidth + 2));
+    out.push(box("hull-yellow", [tip, 4, 0], [4, 6, 4]), box("lamp-red", [tip, length - 4, 0], [4, 6, 4]));
+    void stencil;
+    void facesOf;
+    return out;
+}
+/** A stowed pack: six panels folded into a stack 56 m by 56 m by 24 m, held by four latch brackets, on a short arm. */
+export function stowed(length = 240) {
+    const out = [];
+    for (let p = 0; p < 6; p++) {
+        out.push(span(p % 2 ? "hull-grey" : "dark", -28, 28, 0, length, p * 3.6, p * 3.6 + 2.6, true));
+        for (let t = 0; t < 6; t++)
+            out.push(span("coolant", -24 + t * 9, -23 + t * 9, 0, length, p * 3.6 + 2.6, p * 3.6 + 3.2));
+    }
+    for (const y of [8, 60, 120, 180, 232]) {
+        out.push(span("hull-orange", -30, 30, y, y + 4, -1.5, 23.4, true));
+        out.push(box("hull-yellow", [-30.5, y + 2, 11], [1.4, 5, 3]), box("hull-yellow", [30.5, y + 2, 11], [1.4, 5, 3]));
+    }
+    out.push(span("hull-grey", -2, 2, 0, length, -3, 0, true));
+    return out;
+}

package/dist/model/fleet/ship-02/reactor.d.ts

@@ -0,0 +1,6 @@
+import { type Piece } from "./adapter.ts";
+export declare function reactorPieces(): Piece[];
+/** The shadow shield: an octagon over the hall, three spaced layers on standoffs, orange tiles on the outer face. */
+export declare function shadowShieldPieces(): Piece[];
+/** The six reactors and their works, in the hall's frame. */
+export declare function reactorInside(): Piece[];

package/dist/model/fleet/ship-02/reactor.js

@@ -0,0 +1,133 @@
+// The reactor hall: an eight-sided armoured shell round the spine, behind a layered shadow shield. Outside: heavy plating, blast doors, isolation valves, radiator manifolds with the roots of both radiator
+// wings, feed trunks to the drive raft. Inside (a separate part, for the cutaway): six fusion reactors round the spine, each with coil stacks, a turbine drum, heat exchangers and a service gantry.
+import { PLATE, beam, box, cyl, facesOf, hatch, hazard, lights, onFace, onHull, pipe, plating, polar, ring, rng, slab, span, vent, ngon } from "./adapter.js";
+const R = 100;
+const Y0 = 8;
+const Y1 = 140;
+export function reactorPieces() {
+    const r = rng(2004);
+    const out = [];
+    // the shell: an octagonal prism, with a lower and an upper collar ring
+    out.push(slab("hull-grey", ngon(8, R / Math.cos(Math.PI / 8), Math.PI / 8), Y0, Y1, [0, 0], true));
+    out.push(slab("dark", ngon(8, R * 1.05), 0, Y0, [0, 0], true), slab("dark", ngon(8, R * 1.05), Y1, Y1 + 4, [0, 0], true));
+    // the wall as nested shells: bumper, armour, a water jacket, a lead layer and the pressure shell, each an octagon with its own thickness
+    {
+        let a = R - 0.1;
+        for (const [m, t] of [["hull-grey", 0.4], ["hull-grey", 1.0], ["fuel", 4.0], ["dark", 1.2], ["engine-pale", 0.3]]) {
+            out.push(slab(m, ngon(8, (a - t) / Math.cos(Math.PI / 8), Math.PI / 8), Y0 + 6, Y1 - 6, [0, 0]));
+            a -= t + 0.1;
+        }
+    }
+    // face plating on each of the eight flats, with hatches, vents and lettering
+    for (let k = 0; k < 8; k++) {
+        const a = (k / 8) * 2 * Math.PI;
+        const apothem = R;
+        for (let row = 0; row < 6; row++) {
+            for (let col = 0; col < 7; col++) {
+                if (r.chance(0.07))
+                    continue;
+                const wide = (2 * R * Math.sin(Math.PI / 8)) / 7;
+                const y = Y0 + 2 + row * ((Y1 - Y0 - 4) / 6) + (Y1 - Y0 - 4) / 12;
+                const t = (col - 3) * wide;
+                out.push(onHullFlat(r.pick(PLATE), a, apothem, y, t, wide - 1.6, (Y1 - Y0 - 4) / 6 - 1.6, 0.4 + 0.4 * r.next()));
+            }
+        }
+        // a blast door on every flat: two leaves with hazard bands across the head
+        out.push(onHullFlat("dark", a, apothem, 38, 0, 24, 30, 1.4), onHullFlat("hull-orange", a, apothem, 38, -6.2, 11, 28, 2.1), onHullFlat("hull-orange", a, apothem, 38, 6.2, 11, 28, 2.1), onHullFlat("hull-yellow", a, apothem, 53.5, 0, 24, 1.8, 2.4), onHullFlat("black", a, apothem, 22.5, 0, 24, 1.8, 2.4));
+        out.push(onHullFlat("black", a, apothem, 100, 20, 22, 14, 1.2), onHullFlat("engine-metal", a, apothem, 102, 20, 20, 1.2, 1.9), onHullFlat("engine-metal", a, apothem, 98, 20, 20, 1.2, 1.9), onHullFlat("engine-metal", a, apothem, 94, 20, 20, 1.2, 1.9));
+        out.push(onHullFlat("dark", a, apothem, 100, -20, 12, 12, 1.2), onHullFlat("hull-yellow", a, apothem, 100, -20, 7, 7, 1.8));
+    }
+    // radiator manifolds at the port and starboard flats: a pipe header the wing roots plug into
+    for (const sx of [-1, 1]) {
+        const x = sx * (R + 3);
+        out.push(span("dark", sx > 0 ? x - 2 : x - 6, sx > 0 ? x + 6 : x + 2, 30, 124, -12, 12, true));
+        for (let i = 0; i < 5; i++)
+            out.push(pipe(i % 2 ? "coolant" : "hull-orange", [x, 34 + i * 20, -9], [x + sx * 22, 34 + i * 20, -9], 2.3, 8), pipe(i % 2 ? "hull-white" : "coolant", [x, 34 + i * 20, 9], [x + sx * 22, 34 + i * 20, 9], 2.3, 8));
+        out.push(box("hull-yellow", [x + sx * 4, 128, 0], [8, 4, 24]));
+    }
+    // feed trunks, from the drive raft up the outside of the shell: four big pipes in clamps
+    for (const [x, z] of [[-12, -12], [12, -12], [-12, 12], [12, 12]]) {
+        out.push(pipe("coolant", [x * 1.2, -4, z * 1.2], [x * 1.2, Y0 + 4, z * 1.2], 3.2, 10));
+    }
+    // dorsal and ventral: service decks on the two flats facing +z and -z are the radial flats; the top collar gets rails and hatches
+    for (const f of facesOf([0, Y1 + 2, 0], [2 * R, 4, 2 * R], ["y+"])) {
+        out.push(...hazard(f, 0, -R * 0.82, 120, 3, 24), ...lights(f, -R * 0.8, R * 0.9, R * 0.8, R * 0.9, 12, 2.2, "lamp-red"), ...lights(f, -R * 0.8, -R * 0.9, R * 0.8, -R * 0.9, 12, 2.2, "hull-yellow"));
+        for (let i = 0; i < 4; i++)
+            out.push(...hatch(f, -60 + i * 40, 60, 8, 8, "dark", "hull-yellow"));
+    }
+    // vents high on the hall, a coolant ring round the top
+    out.push(ring("coolant", [0, 0], R * 0.93, R * 0.99, Y1 - 6, Y1 - 2, 8));
+    void vent;
+    void onFace;
+    void cyl;
+    void beam;
+    void onHull;
+    void plating;
+    return out;
+}
+/** The shadow shield: an octagon over the hall, three spaced layers on standoffs, orange tiles on the outer face. */
+export function shadowShieldPieces() {
+    const r = rng(2005);
+    const out = [];
+    // the shadow shield: an octagon over the hall, three spaced layers on standoffs, orange tiles on the outer face
+    const sy = 0;
+    out.push(slab("dark", ngon(8, 148), sy, sy + 4, [0, 0], true), slab("hull-grey", ngon(8, 142), sy + 8, sy + 11, [0, 0], true), slab("hull-orange", ngon(8, 136), sy + 15, sy + 17, [0, 0], true));
+    for (let k = 0; k < 16; k++) {
+        const a = (k / 16) * 2 * Math.PI;
+        const [x, z] = polar(a, 120);
+        out.push(pipe("engine-metal", [x, sy + 4, z], [x, sy + 15, z], 2.4, 8, false));
+    }
+    // tiles on the shield's face: a grid, clipped to the octagon by distance
+    for (let i = -6; i <= 6; i++)
+        for (let j = -6; j <= 6; j++) {
+            const x = i * 20;
+            const z = j * 20;
+            if (Math.hypot(x, z) > 126 || r.chance(0.1))
+                continue;
+            out.push(box(r.pick(["hull-orange", "hull-orange", "hull-orange", "hull-grey", "hull-grey-dark", "hull-white"]), [x, sy + 18, z], [18.4, 1.6, 18.4]));
+        }
+    for (let k = 0; k < 8; k++) {
+        const [x, z] = polar((k / 8) * 2 * Math.PI + Math.PI / 8, 130);
+        out.push(box("hull-yellow", [x, sy + 19, z], [6, 2, 6]));
+    }
+    return out;
+}
+/** A thin box standing on one flat of the eight-sided shell. `a` is the flat's angle round the y axis, `apothem` its distance from the axis, `t` along the flat and `h` up it. */
+function onHullFlat(material, a, apothem, y, t, w, h, thick) {
+    const n = [Math.sin(a), 0, Math.cos(a)];
+    const u = [Math.cos(a), 0, -Math.sin(a)];
+    const o = [n[0] * (apothem + thick / 2) + u[0] * t, y, n[2] * (apothem + thick / 2) + u[2] * t];
+    return { kind: "plate", material, frame: { o, u, v: [0, 1, 0], w: n }, outline: [[-w / 2, -h / 2], [w / 2, -h / 2], [w / 2, h / 2], [-w / 2, h / 2]], thickness: thick, plain: true, only: "mesh" };
+}
+/** The six reactors and their works, in the hall's frame. */
+export function reactorInside() {
+    const out = [];
+    const r = rng(2006);
+    for (let k = 0; k < 6; k++) {
+        const a = (k / 6) * 2 * Math.PI;
+        const at = polar(a, 62);
+        out.push(cyl("engine-pale", at, 20, Y0 + 14, Y1 - 12, 28, { only: undefined, outline: true }));
+        for (let i = 0; i < 6; i++)
+            out.push(ring("copper", at, 20, 24.5, Y0 + 24 + i * 16, Y0 + 24 + i * 16 + 7, 28), ring("dark", at, 24.5, 25.5, Y0 + 22 + i * 16, Y0 + 33 + i * 16, 28));
+        out.push(cyl("dark", at, 14, Y1 - 12, Y1 - 4, 20), cyl("coolant", at, 8, Y1 - 4, Y1, 16), cyl("dark", at, 24, Y0 + 8, Y0 + 14, 20));
+        // a turbine and heat exchanger drum beside each reactor, and pipes between
+        const side = polar(a + 0.38, 78);
+        out.push(cyl("hull-grey", side, 9, Y0 + 20, Y1 - 30, 16, { only: undefined, outline: true }), ring("hull-orange", side, 9, 11, Y0 + 40, Y0 + 46, 16), ring("hull-orange", side, 9, 11, Y1 - 50, Y1 - 44, 16));
+        out.push(pipe("coolant", [at[0], Y0 + 60, at[1]], [side[0], Y0 + 60, side[1]], 2.2, 8), pipe("hull-orange", [at[0], Y1 - 40, at[1]], [side[0], Y1 - 40, side[1]], 2.2, 8));
+        // a gantry round each reactor at mid height with rail posts
+        out.push(ring("hull-yellow", at, 25.5, 29, Y0 + 70, Y0 + 72, 24));
+        for (let i = 0; i < 8; i++) {
+            const [px, pz] = polar(a + (i / 8) * 2 * Math.PI, 28.6, at);
+            out.push(box("hull-yellow", [px, Y0 + 76, pz], [0.8, 8, 0.8]));
+        }
+        const [lx, lz] = polar(a, 40);
+        out.push(beam("hull-yellow", [lx, Y0 + 71, lz], [polar(a, 48)[0] - 0 * lx, Y0 + 71, polar(a, 48)[1]], 3, 1));
+    }
+    // the central service core round the spine, a deck and corridor ring, a crane rail overhead
+    out.push(ring("concrete", [0, 0], 24, 28, Y0 + 3, Y0 + 5, 24), ring("hull-white", [0, 0], 24, 27, Y0 + 5, Y0 + 7, 24));
+    for (let i = 0; i < 24; i++) {
+        const [x, z] = polar((i / 24) * 2 * Math.PI, 40);
+        out.push(box(r.pick(["dark", "hull-grey", "engine-metal"]), [x, Y0 + 12, z], [4 + r.next() * 3, 18 + r.next() * 12, 4 + r.next() * 3]));
+    }
+    return out;
+}

package/dist/model/fleet/ship-02/sections.d.ts

@@ -0,0 +1,15 @@
+export interface Section {
+    id: string;
+    name: string;
+    job: string;
+    /** The part (slot) the section belongs to. */
+    slot: string;
+    /** Where the leader ends. */
+    at: readonly [number, number, number];
+    /** True for something seen only in the cutaway. */
+    inside?: boolean;
+}
+/** The sections sorted nose to tail. */
+export declare const SECTIONS: readonly Section[];
+/** At least one label for every 5 per cent of the length. */
+export declare const LABEL_SPACING_M: number;

package/dist/model/fleet/ship-02/sections.js

@@ -0,0 +1,74 @@
+// Every named section of SPX-207 加美鳴 (かみなり) Kaminari, from the nose to the tail: what it is called, what it does, which part holds it and where its label's leader ends (metres, ship space: x starboard, y from the tail, z up).
+// The renders label from this table, and the 3D view's labels follow the same anchors as the parts move. Sections for a 1,820 m ship: one for every 29 m on average.
+import { LENGTH } from "./dims.js";
+const s = (id, name, job, slot, x, y, z, inside = false) => ({ id, name, job, slot, at: [x, y, z], ...(inside ? { inside } : {}) });
+/** Nose to tail. */
+const LIST = [
+    s("bow-mast", "Dust-clearing mast", "Magnetic coil that sweeps dust and gas from the path", "shield", 0, 1812, 0),
+    s("shield-face", "Forward shield face", "Removable orange tiles over the first plate", "shield", 90, 1787, 4),
+    s("shield-stack", "Whipple stack", "Three spaced plates break up dust and grit before the hull", "shield", 150, 1772, 0),
+    s("debris-sensors", "Debris sensor ring", "Sixteen domes watch the path for grains", "shield", -90, 1789, 0),
+    s("comms", "Comms dishes and masts", "Four dishes: one to Earth, one to the destination, two spare", "command", 28, 1754, 0),
+    s("bridge", "Bridge deck", "Ring of consoles round the navigation table", "command-bridge", 0, 1717, 0, true),
+    s("crew-deck", "Crew decks and sick bay", "Bunks and mess tables", "command-crew", -10, 1702, 0, true),
+    s("attitude", "Attitude thruster blocks", "Thirty-two small thrusters in four blocks point the dishes and turn the ship", "attitude-thrusters", 52, 1736, 0),
+    s("pods", "Escape pods", "Eight pods in hazard-framed bays", "command", 0, 1700, 46),
+    s("ring-b", "Habitat ring B", "Spun at 1.65 rpm for half a gravity; 12,000 people", "habitat-b", 190, 1658, 0),
+    s("ring-b-decks", "Streets and parks, ring B", "Three decks of blocks, trams and park", "habitat-b-deck-2", -165, 1668, 0, true),
+    s("hub", "Hub and bearings", "Ring bearings, drive motors, lift tubes", "habitat-a", 25, 1630, 28),
+    s("ring-a", "Habitat ring A", "Turns the other way, so the two cancel each other's spin", "habitat-a", -190, 1606, 0),
+    s("spokes", "Lift spokes", "Six spokes, each a lift tube and a service pipe", "habitat-a", 100, 1608, 18),
+    s("farm", "Farm drum", "Twelve glazed panes; planted terraces inside", "farm", 66, 1540, 0),
+    s("farm-in", "Farm terraces", "Three terraces of planted trays under lamp rails", "farm-terrace-2", -45, 1540, 0, true),
+    s("mirrors", "Light mirrors", "Four tilted panels feed daylight-spectrum light in", "farm", 96, 1540, 0),
+    s("drydock", "Drydock towers", "Cradle arms hold a craft up to 90 m", "dock", 68, 1495, 110),
+    s("hangar", "Dorsal hangar", "Open cage with a gantry crane and two doors", "dock", 0, 1425, 92),
+    s("parked", "Craft in its cradle", "A 70 m spacecraft under repair", "dock-hangar", 0, 1400, 55, true),
+    s("hub-4", "Last cargo frame", "Spine clamps and end plates of the forward station", "cargo-4", 21, 1340, 26),
+    s("dock-arms", "Dock arms", "Girders to standard 12 m collars, two a side", "dock", 150, 1378, 3),
+    s("works", "Manufacturing hall", "Machine tools, robot arms, stores racks", "dock", 0, 1425, -80),
+    s("cargo-4", "Cargo station 4", "48 containers in four cells", "cargo-4", 76, 1268, 76),
+    s("cargo-4-in", "Pallets and drums", "What the containers hold", "cargo-inside", -37, 1268, 37, true),
+    s("cell-clamps", "Cell clamps", "Girders tie each cell frame to the spine", "cargo-3", 21, 1200, 26),
+    s("hub-1", "Station hub frame", "Cross frame and clamps at each station end", "cargo-1", 20, 936, 20),
+    s("hub-2", "Twist-lock plates", "Yellow plates lock each container to its cell", "cargo-2", 61, 1072, 61),
+    s("cargo-3", "Cargo station 3", "48 containers in four cells", "cargo-3", -76, 1132, 76),
+    s("cargo-2", "Cargo station 2", "48 containers in four cells", "cargo-2", 76, 996, 76),
+    s("cargo-1", "Cargo station 1", "48 containers in four cells", "cargo-1", -76, 860, 76),
+    s("spine-bays", "Truss spine", "36 m square, 24 m bays, 1,760 m long", "spine", 18, 790, 18),
+    s("tank-fwd", "Forward domes", "Vent stacks and relief valves", "tank-1", 80, 770, 80),
+    s("tank-body", "Propellant tank", "80 m by 440 m; four hold 6.35 million t", "tank-1", 80, 640, 120),
+    s("tank-bands", "Insulation tiers", "Cream and orange blanket bands in three tiers", "tank-2", -80, 580, 120),
+    s("tank-gauge", "Level gauge and hatches", "Service hatches and a level scale on the outboard flat", "tank-3", 80, 700, -120),
+    s("tank-in", "Propellant", "Filled to 90 per cent; anti-slosh rings, standpipe", "tank-inside", -80, 560, 0, true),
+    s("manifold", "Feed manifold", "Trunk and two lines face the spine, valves every 30 m", "tank-2", -40, 520, 80),
+    s("radiator-s", "Radiator wing, starboard", "Six panels, 560 m by 56 m, tube rows on both faces", "radiator-starboard", 300, 480, 0),
+    s("radiator-p", "Radiator wing, port", "Rejects 220 GW of waste heat", "radiator-port", -300, 440, 0),
+    s("stowed", "Stowed radiator pack", "The same panels folded, held by four latches", "radiators-stowed", 0, 520, 40),
+    s("cradle", "Cradle rings", "Four rings per tank, each braced to the spine", "tank-3", -80, 390, -120),
+    s("tank-aft", "Tank tail domes", "Pumps and feed ports at the pole", "tank-4", -80, 346, -80),
+    s("lines", "Propellant lines to the drive", "Trunks carry fuel round the shield to the raft", "propellant-lines", 168, 337, 40),
+    s("shadow", "Shadow shield", "Three layers shade the crew from the reactors", "shadow-shield", 120, 330, 0),
+    s("hall", "Reactor hall", "Eight-sided armoured shell, a blast door on each flat", "reactor", 100, 250, 0),
+    s("reactors", "Six fusion reactors", "Coil stacks round the spine, turbine drum beside each", "reactor-inside", 0, 250, 62, true),
+    s("rad-roots", "Radiator manifolds", "Pipe headers where the wing roots plug in", "reactor", 106, 250, 0),
+    s("blast-doors", "Blast doors", "Hazard-banded isolation doors", "reactor", 0, 212, 100),
+    s("thrust-frame", "Thrust bulkhead", "Carries the whole drive's push into the spine", "drive", 0, 160, 60),
+    s("heat-sinks", "Heat-sink louvres", "Dark banks on the top and bottom of the raft", "drive", -90, 166, 60),
+    s("gantry", "Service gantry", "Catwalks round every nozzle at y = 104", "drive", 0, 104, 62),
+    s("feed", "Nozzle feed lines", "Four lines to each injector ring", "drive-engines", 105, 138, -32),
+    s("chambers", "Torch chambers", "Magnet drums and coil stacks over each throat", "drive-engines", -35, 120, 32),
+    s("coils", "Field coils", "Seven copper rings along each bell", "drive-engines", 35, 55, 32),
+    s("main-drive", "Main drive", "Eight fusion torch nozzles, 50 m across the lip", "drive-engines", 105, 20, -32),
+    s("shutters", "Plasma shutter leaves", "Twelve leaves round each lip, open", "drive-engines", -105, 2, 32),
+    s("header-v", "Vernier header tanks", "Four 7,500 t spheres feed the verniers while the main pumps start", "header-tanks", 150, 112, 94),
+    s("header-m", "Main-drive header tanks", "Two cylinders hold the 800 t start charge", "header-tanks", 0, 150, 100),
+    s("hp-dorsal", "Dorsal hardpoint", "Keyed mount for the mission pod: survey, settlement or tanker", "pod", 0, 540, 78),
+    s("hp-ventral", "Ventral hardpoint", "The same mount underneath: cargo, laboratory or rescue pod", "pod-ventral", 0, 540, -78),
+    s("hp-tips", "Wing-tip hardpoints", "Relay mast or tug on the end of each radiator wing", "tip-starboard", 472, 480, 0),
+    s("verniers", "Vernier clusters", "Four clusters of three: steering and docking", "verniers", 160, 36, 52),
+];
+/** The sections sorted nose to tail. */
+export const SECTIONS = [...LIST].sort((a, b) => b.at[1] - a.at[1]);
+/** At least one label for every 5 per cent of the length. */
+export const LABEL_SPACING_M = LENGTH / SECTIONS.length;

package/dist/model/fleet/ship-02/shield.d.ts

@@ -0,0 +1,2 @@
+import { type Piece } from "./adapter.ts";
+export declare function shieldPieces(): Piece[];