@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/model/fleet/ship-03/habitat.d.ts

@@ -0,0 +1,19 @@
+import { type Piece } from "./adapter.ts";
+/** The colours of the rooms: the class's own, and Ariake's dawn theme (warm wood and dawn-gold in place of blue). */
+declare const THEMES: {
+    readonly plain: {
+        readonly bunk: readonly ["hull-blue", "hull-white-worn"];
+        readonly table: "hull-white";
+        readonly bench: "hull-blue";
+        readonly trim: "lamp-blue";
+    };
+    readonly dawn: {
+        readonly bunk: readonly ["hull-dawn", "wood"];
+        readonly table: "wood";
+        readonly bench: "hull-dawn";
+        readonly trim: "lamp-amber";
+    };
+};
+export type Theme = keyof typeof THEMES;
+export declare function habitat(cut: boolean, detail?: number, seed?: string, theme?: Theme): Piece[];
+export {};

package/dist/model/fleet/ship-03/habitat.js

@@ -0,0 +1,98 @@
+// Habitation and medical, station 250 to 302 m: bunks and a mess, a hydroponics rack, water and air recycling, and the six-bed triage bay with its own quarantine and transfer lock. It is a round pressure volume, a drum with
+// berthing rings at both ends and a ring of portholes, like the ISS's modules. The crew decks stand perpendicular to thrust, so they are round floors one above another up the spine. The dorsal and ventral rails carry the
+// radiator banks. A cutaway opens the starboard side. Descends from the ISS's Destiny and Node modules and Skylab's wet workshop, with Orion's armoured shell. Pure: no three.js and no DOM.
+import { collar, contextOf, cub, drum, place, rng, rod } from "./adapter.js";
+import { STATION } from "./dims.js";
+import { capsule, ringAt, tubeAt } from "./shapes.js";
+const [Y0, Y1] = STATION.habitat;
+const R = 13;
+const L = Y1 - Y0;
+/** Where each deck's floor stands up the spine, from the keel end: medical, crew, mess and farm, recycling. */
+const DECKS = { medical: Y0 + 1, crew: Y0 + 9.4, mess: Y0 + 22, recycling: Y0 + 34.5 };
+const INNER = 11.7;
+/** A ring of portholes: a frame, a glass pane and a lit rim, facing out of the drum at a height. */
+function portholes(y, n, start) {
+    const out = [];
+    for (let k = 0; k < n; k++) {
+        const a = start + (Math.PI * 2 * k) / n;
+        const u = [Math.cos(a), 0, -Math.sin(a)];
+        const w = [Math.sin(a), 0, Math.cos(a)];
+        const ring = (material, rad, from, thick) => ({ kind: "plate", material, frame: { o: [(R + from + thick / 2) * w[0], y, (R + from + thick / 2) * w[2]], u, v: [0, 1, 0], w }, outline: Array.from({ length: 12 }, (_, i) => [rad * Math.cos((Math.PI * 2 * i) / 12), rad * Math.sin((Math.PI * 2 * i) / 12)]), thickness: thick, plain: true, only: "mesh" });
+        out.push(ring("hull-grey-dark", 0.62, 0.0, 0.2), ring("glass", 0.46, 0.2, 0.06), ring("lamp-blue", 0.12, 0.26, 0.04));
+        // the burn shutter: a plate on a hinge above the window, drawn back, with its actuator
+        const at = (a2, b2, c2) => [(R + c2) * w[0] + b2 * u[0], y + a2, (R + c2) * w[2] + b2 * u[2]];
+        out.push(rod("hull-grey-dark", at(0.78, -0.7, 0.3), at(0.78, 0.7, 0.3), 0.07, 8), rod("hull-grey", at(0.8, -0.6, 0.45), at(1.5, -0.6, 0.45), 0.05, 8), rod("hull-orange", at(0.82, -0.62, 0.34), at(0.82, 0.62, 0.34), 0.05, 8));
+    }
+    return out;
+}
+/** The colours of the rooms: the class's own, and Ariake's dawn theme (warm wood and dawn-gold in place of blue). */
+const THEMES = {
+    plain: { bunk: ["hull-blue", "hull-white-worn"], table: "hull-white", bench: "hull-blue", trim: "lamp-blue" },
+    dawn: { bunk: ["hull-dawn", "wood"], table: "wood", bench: "hull-dawn", trim: "lamp-amber" },
+};
+function inside(seed, theme) {
+    const t = THEMES[theme];
+    const random = rng(`${seed}/inside`);
+    const out = [];
+    const disc = (y) => ({ kind: "lathe", material: "deck", segs: 40, only: "mesh", profile: [[0.01, y], [INNER, y], [INNER, y + 0.35], [0.01, y + 0.35]] });
+    for (const y of Object.values(DECKS))
+        out.push(disc(y));
+    out.push({ kind: "lathe", material: "hull-white-worn", segs: 40, only: "mesh", profile: [[INNER, Y1 - 1.4], [0.01, Y1 - 1.4]] });
+    // deck 1, medical: six triage berths in two rows of three, each with a monitor arm, a curtain rail and a lamp; a quarantine room behind glass; a transfer lock
+    const m = DECKS.medical + 0.35;
+    for (let r = 0; r < 2; r++)
+        for (let c = 0; c < 3; c++) {
+            const x = -7.6 + c * 3.6;
+            const z = r === 0 ? -7 : 1.4;
+            out.push(cub("hull-white", [x - 1.1, x + 1.1], [m, m + 0.9], [z, z + 4.4]), cub("hull-grey-dark", [x - 0.9, x + 0.9], [m + 0.9, m + 1.15], [z + 0.2, z + 4.2]), cub("glass", [x - 1.15, x + 1.15], [m + 1.2, m + 2.2], [z + 0.2, z + 2.2]));
+            out.push(rod("hull-grey", [x, m + 0.9, z - 0.4], [x, m + 2.9, z - 0.4], 0.07, 12), cub("lamp-blue", [x - 0.4, x + 0.4], [m + 2.9, m + 3.0], [z - 0.7, z - 0.1]), rod("hull-yellow", [x - 1.5, m + 3.2, z - 0.1], [x + 1.5, m + 3.2, z - 0.1], 0.03, 12));
+        }
+    out.push(cub("glass", [4.6, 4.8], [m, m + 4.6], [-9.2, 9.2]), cub("hull-white-worn", [5.4, 9.2], [m, m + 0.9], [-6.4, -2.4]), cub("hull-white-worn", [5.4, 9.2], [m, m + 0.9], [2.4, 6.4]), cub("hazard", [4.5, 4.9], [m, m + 0.2], [-9.2, 9.2]));
+    out.push(cub("hull-orange", [-9.8, -6.8], [m, m + 5.2], [2, 6.4]), cub("hazard", [-9.8, -6.8], [m + 5.2, m + 5.4], [2, 6.4]), cub("lamp-amber", [-9.6, -9], [m + 4.6, m + 4.9], [1.9, 2.1]));
+    // deck 2, crew: two tiers of bunks in two rows, a lit corridor down the middle
+    const c0 = DECKS.crew + 0.35;
+    for (const row of [-1, 1])
+        for (let k = 0; k < 5; k++)
+            for (const tier of [0, 1]) {
+                const x = -6.6 + k * 3.3;
+                const z = row * 6.2;
+                out.push(cub(random() < 0.5 ? t.bunk[0] : t.bunk[1], [x - 1.4, x + 1.4], [c0 + tier * 4.2 + 0.4, c0 + tier * 4.2 + 0.9], [z - 1.1, z + 1.1]), cub("hull-grey-dark", [x - 1.5, x + 1.5], [c0 + tier * 4.2 + 0.2, c0 + tier * 4.2 + 1.1], [z + row * 1.1 - 0.1, z + row * 1.1 + 0.1]), cub("lamp-amber", [x - 0.2, x + 0.2], [c0 + tier * 4.2 + 1.3, c0 + tier * 4.2 + 1.45], [z - row * 0.9 - 0.1, z - row * 0.9 + 0.1]));
+                if (tier === 0)
+                    out.push(rod("hull-grey", [x + 1.6, c0, z], [x + 1.6, c0 + 8.6, z], 0.1, 12));
+            }
+    out.push(cub(t.trim, [-8, 8], [c0 + 0.02, c0 + 0.1], [-0.15, 0.15]));
+    // deck 3, mess and the hydroponics rack: four long tables with benches; racks of green trays under strip lights
+    const e0 = DECKS.mess + 0.35;
+    for (let k = 0; k < 4; k++)
+        out.push(cub(t.table, [-7.2 + k * 2.6, -6 + k * 2.6], [e0 + 0.95, e0 + 1.1], [-7, -1]), cub("hull-grey-dark", [-7 + k * 2.6, -6.2 + k * 2.6], [e0, e0 + 0.95], [-6.6, -6.2]), cub("hull-grey-dark", [-7 + k * 2.6, -6.2 + k * 2.6], [e0, e0 + 0.95], [-1.8, -1.4]), cub(t.bench, [-7.6 + k * 2.6, -7.3 + k * 2.6], [e0 + 0.45, e0 + 0.55], [-7, -1]));
+    for (let t = 0; t < 4; t++)
+        for (let k = 0; k < 4; k++)
+            out.push(cub("plant", [1.5, 8.2], [e0 + 0.6 + t * 2.2, e0 + 0.85 + t * 2.2], [-7.4 + k * 3.4, -4.8 + k * 3.4]), cub("lamp-blue", [1.7, 8], [e0 + 1.7 + t * 2.2, e0 + 1.78 + t * 2.2], [-7.4 + k * 3.4, -4.8 + k * 3.4]), rod("hull-grey-dark", [1.5, e0, -7.5 + k * 3.4], [1.5, e0 + 8.8, -7.5 + k * 3.4], 0.07, 12));
+    out.push(cub("hull-grey", [-5, 5], [e0, e0 + 5.2], [9.8, 10.4], { only: "mesh" }), cub("hull-orange", [-6, -2], [e0, e0 + 3], [7, 9.8]), cub("hull-grey-dark", [-6, -2], [e0 + 3, e0 + 3.2], [7, 9.8]));
+    // deck 4, recycling: four upright tanks (two water, two air), scrubbers, a heat exchanger and a gallery of pipes along the ceiling
+    const r0 = DECKS.recycling + 0.35;
+    for (const [x, z, fluid] of [[-5.5, -5.5, "fuel"], [-5.5, 5.5, "fuel"], [1, -5.5, "hull-white"], [1, 5.5, "hull-white"]])
+        out.push(capsule(fluid, x, z, 2.7, r0, r0 + 11), ringAt("hull-grey-dark", x, z, 2.8, r0 + 3, 0.2), ringAt("hull-grey-dark", x, z, 2.8, r0 + 8, 0.2), ringAt("gold", x, z, 2.8, r0 + 5.5, 0.15));
+    for (const z of [-5, 0, 5])
+        out.push(tubeAt("hull-grey", 7, z, 1.6, r0, r0 + 8, { segs: 14 }), cub("lamp-amber", [6.6, 7.4], [r0 + 6, r0 + 6.4], [z + 1.55, z + 1.7]), ringAt("copper", 7, z, 1.7, r0 + 2, 0.12));
+    for (const z of [-4, 0, 4])
+        out.push(tubeAt(z === 0 ? "copper" : "coolant", 0, z, 0.3, DECKS.recycling + 12, Y1 - 1.6, { segs: 12 }));
+    for (let y = Y0 + 2; y < Y1 - 1.6; y += 6)
+        out.push(rod("hull-yellow", [-8.4, y, 7.8], [-8.4, y + 5, 7.8], 0.05, 12), rod("hull-yellow", [-7.8, y, 7.8], [-7.8, y + 5, 7.8], 0.05, 12));
+    return out;
+}
+export function habitat(cut, detail = 1, seed = "habitat", theme = "plain") {
+    const base = contextOf(`${seed}`, "science", { cutaway: cut, detail, seed }, "command");
+    const ctx = theme === "dawn" ? { ...base, livery: { ...base.livery, accent: "hull-dawn" } } : base;
+    // the drum is built on the spine's axis from 0 to L and opens towards +Z; turn it a quarter so the cut faces starboard
+    const out = [...place(drum(ctx, { R, L, top: "L", bottom: "L", panels: { wide: 2.8, tall: 1.9 }, hatches: 9, roundHatches: true, conduits: 7, trays: 3, vents: 5, ladders: 2, rings: [0.14, 0.3, 0.46, 0.62, 0.78, 0.9], digits: "03", junk: 90 }), { at: [0, Y0, 0], yaw: 90 })];
+    if (cut)
+        out.push(...inside(seed, theme));
+    for (const [y, n, s0] of [[Y0 + 10, 12, 0.1], [Y0 + 24, 12, 0.4], [Y0 + 38, 12, 0.2]])
+        if (!cut)
+            out.push(...portholes(y, n, s0));
+        else
+            out.push(...portholes(y, n, s0).filter((_, i) => Math.sin(s0 + (Math.PI * 2 * Math.floor(i / 3)) / n) < 0));
+    void collar;
+    return out;
+}

package/dist/model/fleet/ship-03/hangar.d.ts

@@ -0,0 +1,10 @@
+import { type Piece } from "./adapter.ts";
+import { type BayId } from "./dims.ts";
+type Side = "starboard" | "port";
+/** Miyamoto's two shoulders by their side. */
+export declare const BAY_OF: Readonly<Record<Side, BayId>>;
+/** One hangar shoulder, built where it stands in the ship. */
+export declare function hangar(which: Side | BayId, cut: boolean, detail?: number, seed?: string): Piece[];
+/** A cradle: two long I-beams and cross beams on feet, a clamp arm on each side at the ends and the middle (a column, a hydraulic cylinder and a jaw with a pad), and hazard-striped chocks. No craft in it. */
+export declare function cradle(cx: number, cy: number, len: number, wide: number, floor: number): Piece[];
+export {};

package/dist/model/fleet/ship-03/hangar.js

@@ -0,0 +1,278 @@
+// The two hangar shoulders: starboard aft (104 to 204 m, the rescue bay with its gantry, maintenance racks, a pressure vestibule and an empty cradle with clamp arms, guide rails to the door and an umbilical boom) and port forward (222 to 318 m, the survey bay with three cradles
+// and guide rails, an access bridge and emergency shutters). Each is a rectangular shoulder braced to the spine, its outer wall open to a bay door with orange shutter leaves. A cutaway opens the face towards the spine and, on the
+// starboard shoulder, the outer wall. Pure: no three.js and no DOM.
+import { cub, HULL_STACKS, ibeam, pipeRun, rng, rod, roundStrut } from "./adapter.js";
+import { BAYS, bayBox } from "./dims.js";
+import { dressedFace, pipe, wallShells } from "./hulls.js";
+import { along, bolts, conduit, faceOf, frame, hazard, ladder, lamp, on, pt, rail, stencil, WHITE } from "./faces.js";
+/** Miyamoto's two shoulders by their side. */
+export const BAY_OF = { starboard: "starboard-aft", port: "port-fore" };
+const span = (a, b) => (a < b ? [a, b] : [b, a]);
+/** The inside: deck, ceiling rails and a gantry crane, racks, a vestibule, lights, and the hardware that holds, guides and services a craft. No craft is drawn: the bay is empty. */
+function inside(bay, seed) {
+    const side = BAYS[bay].side;
+    const rescue = BAYS[bay].kind === "rescue";
+    const h = bayBox(bay);
+    const [y0, y1] = h.y;
+    const [x0, x1] = h.x;
+    const [z0, z1] = h.z;
+    const cx = h.centre;
+    const cy = (y0 + y1) / 2;
+    const out = [];
+    const random = rng(`${seed}/inside`);
+    // the deck: plates with a hazard border and numbered bays, and lights set in it
+    out.push(cub("deck", [x0 + 1.4, x1 - 1.4], [y0 + 1.4, y1 - 1.4], [z0 + 1.4, z0 + 1.7], { only: undefined }));
+    for (let y = y0 + 4; y < y1 - 3; y += 4)
+        out.push(cub("hull-grey-dark", [x0 + 1.4, x1 - 1.4], [y, y + 0.1], [z0 + 1.7, z0 + 1.78]));
+    for (const x of [cx - 8, cx + 8])
+        out.push(cub("hazard", [x - 0.25, x + 0.25], [y0 + 4, y1 - 4], [z0 + 1.7, z0 + 1.76]));
+    for (let y = y0 + 6; y < y1 - 4; y += 6)
+        for (const x of [x0 + 3, x1 - 3])
+            out.push(cub("lamp-blue", [x - 0.2, x + 0.2], [y - 0.2, y + 0.2], [z0 + 1.7, z0 + 1.8]));
+    // the ceiling: two rails along the bay, a gantry bridge across them with a trolley, hook and cable
+    const rz = z1 - 3.4;
+    for (const x of [x0 + 5, x1 - 5])
+        out.push(...ibeam("hull-yellow", [x, y0 + 3, rz], [x, y1 - 3, rz], 1.0, 0.6, [0, 0, 1]));
+    const gy = cy + (rescue ? 6 : -4);
+    out.push(...ibeam("hull-yellow", [x0 + 5, gy, rz - 0.8], [x1 - 5, gy, rz - 0.8], 1.6, 0.9, [0, 0, 1]), ...roundStrut("hull-grey-dark", [x0 + 5, gy - 1.4, rz - 0.3], [x1 - 5, gy - 1.4, rz - 0.3], 0.18), cub("hull-yellow", [cx - 1.6, cx + 1.6], [gy - 1.6, gy + 1.6], [rz - 2.3, rz - 1.4]), rod("hull-grey-dark", [cx, gy, rz - 2.3], [cx, gy, z0 + 6], 0.08, 6), cub("hazard", [cx - 0.5, cx + 0.5], [gy - 0.5, gy + 0.5], [z0 + 5.4, z0 + 6.2]));
+    // ceiling lamps: a strip of eight, and the sprinkler pipe
+    for (let k = 0; k < 8; k++)
+        out.push(cub("lamp-amber", [cx - 0.4, cx + 0.4], [y0 + 6 + k * ((y1 - y0 - 12) / 7) - 0.8, y0 + 6 + k * ((y1 - y0 - 12) / 7) + 0.8], [z1 - 1.5, z1 - 1.4]));
+    out.push(...pipe([x0 + 3, y0 + 2, z1 - 2], [x0 + 3, y1 - 2, z1 - 2], 0.22, "lamp-red"));
+    // racks against the wall that faces the spine: steel uprights in bays seven metres wide, shelf boards with a front lip, standard cases in three neutral colours with labels and handles, a strap across each shelf and a net of straps down each bay
+    const wall = side === "starboard" ? x0 + 1.4 : x1 - 1.4;
+    const face = side === "starboard" ? 1 : -1; // +1: the shelves stand out of the wall towards +X
+    const depth = 2.2;
+    const tiers = 8;
+    const pitch = (z1 - z0 - 7) / tiers;
+    const cases = ["hull-white-worn", "hull-grey", "hull-blue"];
+    const net = (d, ya, yb, za, zb, r) => cub("black", span(wall + face * d, wall + face * (d + r)), [ya, yb], [za, zb]);
+    for (let y = y0 + 4; y < y1 - 6; y += 7) {
+        for (const uy of [y, y + 3.5, y + 7])
+            out.push(cub("hull-grey-dark", span(wall + face * 0.1, wall + face * (depth + 0.2)), [uy - 0.12, uy + 0.12], [z0 + 2.4, z1 - 3]), rod("hull-grey", [wall + face * (depth + 0.3), uy, z0 + 2.4], [wall + face * (depth + 0.3), uy, z1 - 3], 0.09, 8));
+        for (let t = 0; t < tiers; t++) {
+            const zs = z0 + 2.6 + t * pitch;
+            out.push(cub("hull-white-worn", span(wall, wall + face * depth), [y, y + 7], [zs, zs + 0.18]), cub("hull-grey", span(wall + face * depth, wall + face * (depth + 0.12)), [y, y + 7], [zs, zs + 0.5]));
+            for (let k = 0; k < 3; k++) {
+                if (random() < 0.08)
+                    continue;
+                const kind = cases[Math.floor(random() * 3)];
+                const tall = 1.4 + random() * (pitch - 1.9);
+                const ya = y + 0.15 + k * 2.3;
+                const front = wall + face * (depth - 0.15);
+                out.push(cub(kind, span(wall + face * 0.2, front), [ya, ya + 2.1], [zs + 0.18, zs + 0.18 + tall]), cub("hull-grey-dark", span(front, front + face * 0.04), [ya + 0.06, ya + 2.04], [zs + 0.18 + tall * 0.5 - 0.04, zs + 0.18 + tall * 0.5 + 0.04]), cub("hull-white", span(front, front + face * 0.05), [ya + 0.25, ya + 1.1], [zs + 0.18 + tall - 0.62, zs + 0.18 + tall - 0.18]), cub("black", span(front + face * 0.05, front + face * 0.08), [ya + 0.3, ya + 1.05], [zs + 0.18 + tall - 0.5, zs + 0.18 + tall - 0.4]), cub("hull-grey-dark", span(front, front + face * 0.1), [ya + 1.3, ya + 1.9], [zs + 0.18 + tall - 0.45, zs + 0.18 + tall - 0.3]));
+            }
+            out.push(net(depth + 0.12, y + 0.05, y + 6.95, zs + 0.55, zs + 0.7, 0.05));
+        }
+        for (let k = 0; k < 6; k++)
+            out.push(net(depth + 0.12, y + 0.5 + k * 1.2, y + 0.58 + k * 1.2, z0 + 2.6, z0 + 2.6 + tiers * pitch, 0.04));
+    }
+    // the pressure vestibule at the aft end: a box with two doors, a hazard frame and a status lamp
+    out.push(cub("hull-white-worn", [cx - 6, cx + 6], [y0 + 1.5, y0 + 6], [z0 + 1.7, z0 + 9]), cub("hull-grey-dark", [cx - 3, cx + 3], [y0 + 6, y0 + 6.2], [z0 + 1.9, z0 + 7.6]), cub("hazard", [cx - 3.3, cx + 3.3], [y0 + 6.2, y0 + 6.35], [z0 + 7.6, z0 + 8.1]), cub("lamp-blue", [cx - 0.3, cx + 0.3], [y0 + 6.2, y0 + 6.4], [z0 + 8.3, z0 + 8.7]));
+    out.push(...bayHardware(bay, seed));
+    return out;
+}
+/** One hangar shoulder, built where it stands in the ship. */
+export function hangar(which, cut, detail = 1, seed) {
+    const bay = which === "starboard" || which === "port" ? BAY_OF[which] : which;
+    const side = BAYS[bay].side;
+    const rescue = BAYS[bay].kind === "rescue";
+    seed ??= `hangar-${which}`;
+    const h = bayBox(bay);
+    const [y0, y1] = h.y;
+    const [x0, x1] = h.x;
+    const [z0, z1] = h.z;
+    const sgn = side === "starboard" ? 1 : -1;
+    const T = 1.4;
+    const out = [];
+    const o = { seed, scheme: WHITE, detail, density: 0.34, blanket: true };
+    const openLow = z0 + 5;
+    const openHigh = z1 - 7;
+    const openY = [y0 + 12, y1 - 12];
+    const outer = side === "starboard" ? x1 : x0;
+    // the structural shell as slabs: floor, roof, end walls, the inner wall, and the outer wall in four strips round the bay door
+    const slab = (xr, yr, zr) => cub("hull-grey-dark", xr, yr, zr, { only: undefined });
+    out.push(slab([x0, x1], [y0, y1], [z0, z0 + T]), slab([x0, x1], [y0, y1], [z1 - T, z1]), slab([x0, x1], [y0, y0 + T], [z0, z1]), slab([x0, x1], [y1 - T, y1], [z0, z1]));
+    if (!cut || side === "port")
+        out.push(slab(side === "starboard" ? [x0, x0 + T] : [x1 - T, x1], [y0, y1], [z0, z1]));
+    const strip = (xr, yr, zr) => out.push(slab(xr, yr, zr));
+    const wallX = side === "starboard" ? [outer - T, outer] : [outer, outer + T];
+    if (!(cut && side === "starboard")) {
+        strip(wallX, [y0, y1], [z0, openLow]);
+        strip(wallX, [y0, y1], [openHigh, z1]);
+        strip(wallX, [y0, openY[0]], [openLow, openHigh]);
+        strip(wallX, [openY[1], y1], [openLow, openHigh]);
+    }
+    // plating on every outward face: the roof and floor, the two end walls, the outer wall's strips, and the inner wall
+    const box = { x: [x0, x1], y: [y0, y1], z: [z0, z1] };
+    const dorsal = faceOf(box, "z", 1);
+    const ventral = faceOf(box, "z", -1);
+    const fore = faceOf(box, "y", 1);
+    const aft = faceOf(box, "y", -1);
+    out.push(...dressedFace(dorsal, { ...o, kinds: ["hatch", "vent", "stub", "sensor", "greeble", "number", "lamps"] }), ...dressedFace(ventral, { ...o, kinds: ["vent", "hatch", "greeble", "stub"] }));
+    out.push(...dressedFace(fore, { ...o, density: 0.25 }), ...dressedFace(aft, { ...o, density: 0.25 }));
+    const outerFace = (yr, zr) => ({ n: "x", sign: sgn, at: outer, a: yr, b: zr });
+    if (!(cut && side === "starboard")) {
+        out.push(...dressedFace(outerFace([y0, y1], [z0, openLow]), { ...o, density: 0.4, slot: [8, 4] }), ...dressedFace(outerFace([y0, y1], [openHigh, z1]), { ...o, density: 0.4, slot: [8, 5] }));
+        out.push(...dressedFace(outerFace([y0, openY[0]], [openLow, openHigh]), { ...o, density: 0.4 }), ...dressedFace(outerFace([openY[1], y1], [openLow, openHigh]), { ...o, density: 0.4 }));
+        // the bay door's frame in grey, a hazard band along its sill and lintel, and its orange shutter leaves partly drawn
+        const door = outerFace(openY, [openLow, openHigh]);
+        out.push(...frame(door, (openY[0] + openY[1]) / 2, (openLow + openHigh) / 2, openY[1] - openY[0], openHigh - openLow, 2.1, 1.3, "hull-grey"), ...frame(door, (openY[0] + openY[1]) / 2, (openLow + openHigh) / 2, openY[1] - openY[0] + 0.8, openHigh - openLow + 0.8, 0.5, 1.6, "hull-grey-dark"), ...hazard(door, openLow - 0.3, openY[0], openY[1], 0.5, 1.2), ...hazard(door, openHigh + 0.3, openY[0], openY[1], 0.5, 1.2));
+        // the door's own hardware: a heavy I-beam track along the lintel and along the sill that the leaves run on, bolt rows on the frame, and a gusset at each corner
+        const dn = door.sign;
+        for (const z of [openHigh + 0.2, openLow - 0.2])
+            out.push(...ibeam("hull-grey", pt(door, openY[0] - 0.4, z, 0.9), pt(door, openY[1] + 0.4, z, 0.9), 0.9, 0.6, [dn, 0, 0]));
+        for (const z of [openLow - 1.5, openHigh + 1.5])
+            out.push(...bolts(door, z, openY[0] - 1.5, openY[1] + 1.5, 1.6, 0.18));
+        for (const e of [openY[0] - 1.5, openY[1] + 1.5])
+            out.push(...bolts(along(door), e, openLow - 1.5, openHigh + 1.5, 1.6, 0.18));
+        for (const ea of [openY[0] - 0.9, openY[1] + 0.9])
+            for (const eb of [openLow - 0.9, openHigh + 0.9])
+                out.push(cub("hull-grey-dark", span(door.at + dn * 0.7, door.at + dn * 1.9), [ea - 0.9, ea + 0.9], [eb - 0.9, eb + 0.9]), rod("hull-yellow", pt(door, ea, eb, 1.9), pt(door, ea, eb, 2.0), 0.35, 12));
+        const leaves = 5;
+        const lw = (openY[1] - openY[0]) / leaves;
+        const drawn = rescue ? 2 : 5;
+        for (let k = 0; k < leaves; k++) {
+            const a0 = openY[0] + k * lw;
+            if (k >= leaves - drawn) {
+                const mid = (openLow + openHigh) / 2;
+                const high = openHigh - openLow;
+                const lift = 0.7 + (k % 2) * 0.3;
+                // the leaf: a grey frame on the rails, in which the removable orange panels sit in a grid with a seam between each; hinges, actuators, rollers, stencils and a lamp
+                out.push(on(door, a0 + lw / 2, mid, lw - 0.2, high, 0.1, 0.5, "hull-grey-dark"));
+                // the leaf is a roll-up shutter drawn into a stack: horizontal slats of removable orange panel, each with a stiffening rib and a guide shoe in the tracks at its ends; the leaf's leading edge is hazard striped
+                const slats = 14;
+                const sh = (high - 0.9) / slats;
+                for (let r = 0; r < slats; r++) {
+                    const pz = openLow + 0.45 + sh * (r + 0.5);
+                    const lit = (r + k) % 5 === 0;
+                    out.push(on(door, a0 + lw / 2, pz, lw - 0.9, sh - 0.14, 0.5, 0.74 + (r % 2) * 0.05, lit ? "hull-orange-worn" : "hull-orange"), rod("hull-grey-dark", pt(door, a0 + 0.55, pz, 0.78), pt(door, a0 + lw - 0.55, pz, 0.78), 0.05, 8), cub("hull-grey-dark", [door.at + door.sign * 0.5, door.at + door.sign * 0.9].sort((p2, q2) => p2 - q2), [a0 + 0.12, a0 + 0.55], [pz - 0.12, pz + 0.12]));
+                }
+                for (const e of [a0 + 0.2, a0 + lw - 0.2])
+                    out.push(...ibeam("hull-grey-dark", pt(door, e, openLow + 0.2, lift + 0.2), pt(door, e, openHigh - 0.2, lift + 0.2), 0.7, 0.45, [door.sign, 0, 0]));
+                for (const z of [openLow + high / 2])
+                    out.push(...ibeam("hull-grey", pt(door, a0 + 0.2, z, lift + 0.2), pt(door, a0 + lw - 0.2, z, lift + 0.2), 0.55, 0.4, [door.sign, 0, 0]));
+                // hinges: three barrels on the rail edge with a knuckle bracket each; actuators: two hydraulic cylinders from the lintel to the leaf with a piston rod and a clevis at each end
+                for (const z of [openLow + 1.2, mid, openHigh - 1.2])
+                    out.push(rod("hull-grey", pt(door, a0 + 0.1, z - 0.7, 0.6), pt(door, a0 + 0.1, z + 0.7, 0.6), 0.28, 12), rod("hull-grey-dark", pt(door, a0 + 0.1, z, 0.2), pt(door, a0 + 0.1, z, 0.6), 0.1, 8));
+                for (const s of [-1, 1]) {
+                    const base = pt(door, a0 + lw / 2 + s * 1.2, openHigh + 0.4, 0.9);
+                    const tip = pt(door, a0 + lw / 2 + s * 1.2, openHigh - 2.5, lift + 0.2);
+                    const mid3 = [(base[0] + tip[0]) / 2, (base[1] + tip[1]) / 2, (base[2] + tip[2]) / 2];
+                    out.push(rod("hull-grey-dark", base, mid3, 0.34, 12), rod("engine-pale", mid3, tip, 0.17, 12), rod("hull-grey", base, [base[0], base[1] + 0.05, base[2]], 0.5, 12), rod("hull-yellow", tip, [tip[0], tip[1], tip[2] + 0.01], 0.3, 12));
+                }
+                out.push(...hazard(along(door), a0 + lw - 0.4, openLow + 0.3, openHigh - 0.3, 0.5, 0.9), ...lamp(door, a0 + lw / 2, openHigh - 0.9, "amber", 0.2), ...stencil(door, `${51 + k}`, a0 + lw / 2, mid, 1.6));
+            }
+        }
+        // the opening seam: where the drawn leaves stop there is a dark gap, a tall hazard-striped leading edge on the first leaf, a column of lamps at each end of it and a limit switch on the track
+        const lead = openY[0] + (leaves - drawn) * lw;
+        out.push(on(door, lead - 0.15, (openLow + openHigh) / 2, 0.3, openHigh - openLow, 0.3, 0.95, "black"), ...Array.from({ length: Math.floor(openHigh - openLow - 0.4) }, (_, i) => cub(i % 2 ? "black" : "hazard", span(door.at + dn * 0.2, door.at + dn * 1.15), [lead - 0.05, lead + 0.75], [openLow + 0.2 + i, openLow + 1.2 + i])), cub("hull-grey-dark", span(door.at + dn * 0.9, door.at + dn * 1.5), [lead - 0.8, lead - 0.2], [openHigh - 0.4, openHigh + 0.4]), ...lamp(door, lead - 0.5, openHigh - 1.2, "red", 0.3), ...lamp(door, lead - 0.5, openLow + 1.2, "red", 0.3), ...lamp(door, lead - 0.5, (openLow + openHigh) / 2, "amber", 0.3));
+        // the roller housing above the door: a heavy drum with end flanges and a motor, and a row of frame lights down both jambs and along the lintel
+        out.push(rod("hull-grey-dark", pt(door, openY[0], openHigh + 1.0, 1.4), pt(door, openY[1], openHigh + 1.0, 1.4), 1.3, 20), rod("hull-grey", pt(door, openY[0] - 0.2, openHigh + 1.0, 1.4), pt(door, openY[0] + 0.5, openHigh + 1.0, 1.4), 1.7, 20), rod("hull-grey", pt(door, openY[1] - 0.5, openHigh + 1.0, 1.4), pt(door, openY[1] + 0.2, openHigh + 1.0, 1.4), 1.7, 20), cub("hull-grey-dark", [door.at + door.sign * 0.8, door.at + door.sign * 2.6].sort((p2, q2) => p2 - q2), [openY[0] - 2.4, openY[0]], [openHigh + 0.2, openHigh + 1.8]));
+        for (let k = 0; k < 10; k++)
+            out.push(...lamp(door, openY[0] + 1 + k * ((openY[1] - openY[0] - 2) / 9), openHigh + 0.4, k % 3 === 0 ? "blue" : "amber", 0.26));
+        for (const e of [openY[0] - 0.5, openY[1] + 0.5])
+            for (let k = 0; k < 5; k++)
+                out.push(...lamp(door, e, openLow + 1 + k * ((openHigh - openLow - 2) / 4), "amber", 0.26));
+        out.push(...stencil(door, String(y0), openY[0] - 3, openLow - 1.4, 1.6), ...conduit(door, openHigh + 2.1, openY[0], openY[1], { count: 3, seed }), ...ladder(along(door), openY[1] + 3, openLow, openHigh), ...lamp(door, openY[0] - 1.5, openHigh, "amber"), ...lamp(door, openY[1] + 1.5, openHigh, "blue"));
+        // a rail outside the sill, on posts
+        out.push(...rail(door, openLow - 1.4, openY[0] - 2, openY[1] + 2));
+    }
+    else {
+        // the layers of the floor and the roof show at the cut
+        out.push(...wallShells(HULL_STACKS.command, { axis: "z", sign: -1, at: z0, y: [y0, y1], across: [x0, x1], step: 0.25 }));
+        out.push(...wallShells(HULL_STACKS.command, { axis: "z", sign: 1, at: z1, y: [y0, y1], across: [x0, x1], step: 0.25 }));
+    }
+    // the inner face: facing the spine, with the braces that tie the shoulder to it
+    const innerFace = { n: "x", sign: (side === "starboard" ? -1 : 1), at: side === "starboard" ? x0 : x1, a: [y0, y1], b: [z0, z1] };
+    if (!(cut && side === "port"))
+        out.push(...dressedFace(innerFace, { ...o, density: 0.25 }));
+    for (let y = y0 + 10; y < y1 - 6; y += 22)
+        for (const z of [z0 + 4, z1 - 4])
+            out.push(...roundStrut("hull-grey-dark", [side === "starboard" ? x0 : x1, y, z], [sgn * 8.6, y + (side === "starboard" ? -8 : 8), z * 0.3], 0.55), cub("hull-yellow", sgn === 1 ? [x0 - 0.5, x0 + 0.3] : [x1 - 0.3, x1 + 0.5], [y - 0.7, y + 0.7], [z - 0.7, z + 0.7]));
+    // the inside, always: it is what shows through the bay door
+    out.push(...inside(bay, seed));
+    return out;
+}
+/** A cradle: two long I-beams and cross beams on feet, a clamp arm on each side at the ends and the middle (a column, a hydraulic cylinder and a jaw with a pad), and hazard-striped chocks. No craft in it. */
+export function cradle(cx, cy, len, wide, floor) {
+    const half = wide / 2;
+    const out = [];
+    // the cradle: two long I-beams and cross beams on feet, with a pad at each clamp
+    for (const x of [cx - half, cx + half])
+        out.push(...ibeam("hull-grey", [x, cy - len / 2, floor + 0.7], [x, cy + len / 2, floor + 0.7], 1.0, 0.7, [0, 0, 1]));
+    for (let k = 0; k <= 4; k++)
+        out.push(...ibeam("hull-grey-dark", [cx - half, cy - len / 2 + (k * len) / 4, floor + 0.7], [cx + half, cy - len / 2 + (k * len) / 4, floor + 0.7], 0.8, 0.5, [0, 0, 1]));
+    for (const x of [cx - half, cx + half])
+        for (const y of [cy - len / 2, cy + len / 2])
+            out.push(cub("hull-grey-dark", [x - 0.7, x + 0.7], [y - 0.7, y + 0.7], [floor, floor + 0.3]), rod("hull-grey", [x, y, floor + 0.3], [x, y, floor + 0.2], 0.6, 12));
+    // the clamp arms: a column on each side at the ends and the middle, a hydraulic cylinder to a jaw that closes over where the hull would lie, a pad on the jaw and a lamp
+    for (const side2 of [-1, 1])
+        for (const dy of [-len / 2 + 2, 0, len / 2 - 2]) {
+            const bx = cx + side2 * (half + 0.9);
+            const by = cy + dy;
+            const top = [bx - side2 * 1.6, by, floor + 4.2];
+            out.push(...roundStrut("hull-grey-dark", [bx, by, floor + 0.7], [bx, by, floor + 3.6], 0.35), ...roundStrut("engine-pale", [bx + side2 * 1.8, by, floor + 0.7], [bx + side2 * 0.4, by, floor + 3.2], 0.2), rod("hull-grey-dark", [bx, by, floor + 3.6], top, 0.3, 12), cub("black", [top[0] - 0.9, top[0] + 0.9], [top[1] - 1.1, top[1] + 1.1], [top[2] - 0.35, top[2] + 0.05]), cub("lamp-amber", [bx - 0.2, bx + 0.2], [by - 0.2, by + 0.2], [floor + 3.7, floor + 3.95]));
+        }
+    // chocks at the foot of each cradle, hazard-striped
+    for (const x of [cx - half - 2.2, cx + half + 2.2])
+        out.push(cub("hazard", [x - 0.5, x + 0.5], [cy - 1, cy + 1], [floor, floor + 0.5]));
+    return out;
+}
+/** The hardware of an empty bay: cradles with clamp arms and chocks, guide rails from each cradle out through the door, deck markings, a fuel and service umbilical boom with its hoses, and floodlights. Round tubes and I-beams. */
+function bayHardware(bay, seed) {
+    const side = BAYS[bay].side;
+    const rescue = BAYS[bay].kind === "rescue";
+    const h = bayBox(bay);
+    const [y0, y1] = h.y;
+    const [x0, x1] = h.x;
+    const [z0, z1] = h.z;
+    const cx = h.centre;
+    const floor = z0 + 1.7;
+    const toDoor = side === "starboard" ? 1 : -1;
+    const doorX = side === "starboard" ? x1 - 1.4 : x0 + 1.4;
+    const wallX = side === "starboard" ? x0 + 1.4 : x1 - 1.4;
+    const out = [];
+    const cradles = rescue ? [{ y: (y0 + y1) / 2 - 10, len: 34, wide: 14 }] : [20, 48, 76].map((d) => ({ y: y0 + d, len: 20, wide: 10 }));
+    for (const [n, c] of cradles.entries()) {
+        const half = c.wide / 2;
+        out.push(...cradle(cx, c.y, c.len, c.wide, floor));
+        // guide rails: two round rails on I-beam sleepers from the cradle to the door, with stanchions, a lamp at each end and a stop
+        const rail0 = cx + toDoor * (half + 1.5);
+        for (const dy of [-c.wide / 4, c.wide / 4]) {
+            const y = c.y + dy;
+            out.push(...ibeam("hull-grey-dark", [rail0, y, floor + 0.15], [doorX, y, floor + 0.15], 0.3, 0.9, [0, 0, 1]), rod("hull-yellow", [rail0, y, floor + 0.6], [doorX, y, floor + 0.6], 0.14, 12), rod("hull-yellow", [rail0, y, floor + 0.6], [rail0, y, floor + 0.9], 0.22, 12));
+            for (let x = rail0; (x - doorX) * toDoor < -1; x += toDoor * 3)
+                out.push(rod("hull-grey-dark", [x, y, floor + 0.15], [x, y, floor + 0.6], 0.08, 8));
+        }
+        out.push(cub("lamp-blue", [Math.min(rail0, doorX), Math.max(rail0, doorX)], [c.y - 0.1, c.y + 0.1], [floor + 0.02, floor + 0.08]));
+        // the deck marking: a yellow frame round the cradle, a bay number in our own figures
+        for (const [a, b, wide, deep] of [[cx, c.y - c.len / 2 - 1.6, c.wide + 6, 0.3], [cx, c.y + c.len / 2 + 1.6, c.wide + 6, 0.3]])
+            out.push(cub("hull-yellow", [a - wide / 2, a + wide / 2], [b - deep / 2, b + deep / 2], [floor, floor + 0.07]));
+        for (const x of [cx - half - 3.2, cx + half + 3.2])
+            out.push(cub("hull-yellow", [x - 0.15, x + 0.15], [c.y - c.len / 2 - 1.6, c.y + c.len / 2 + 1.6], [floor, floor + 0.07]));
+        out.push(...stencil({ n: "z", sign: 1, at: floor + 0.07, a: [cx - half, cx + half], b: [c.y - 3, c.y + 3] }, `${(rescue ? 1 : 2) * 10 + n + 1}`, cx, c.y, 2.2, "hull-yellow"));
+    }
+    // the umbilical boom: a pylon on the wall that faces the spine, a boom swinging out over the cradle, and the hoses for fuel, coolant and power hanging from it in loops to a connector head
+    const bz = floor + 7.2;
+    const by0 = cradles[0].y;
+    out.push(cub("hull-grey-dark", [wallX - 0.4, wallX + 0.4 * toDoor + toDoor * 2.4].sort((p, q) => p - q), [by0 - 1.4, by0 + 1.4], [floor, bz + 1]), rod("hull-grey", [wallX + toDoor * 1.4, by0, bz], [wallX + toDoor * 1.4, by0, bz + 0.6], 1.1, 14));
+    const tip = wallX + toDoor * 14;
+    out.push(...ibeam("hull-yellow", [wallX + toDoor * 1.4, by0, bz + 0.2], [tip, by0, bz + 0.2], 1.0, 0.7, [0, 0, 1]), ...roundStrut("hull-grey-dark", [wallX + toDoor * 1.4, by0, bz - 1.6], [wallX + toDoor * 9, by0, bz + 0.1], 0.3));
+    const loops = [["fuel", -0.8], ["coolant", 0], ["copper", 0.8]];
+    for (const [mat, dy] of loops)
+        out.push(...pipeRun(mat, [[tip - toDoor * 0.5, by0 + dy, bz], [tip, by0 + dy, bz - 2], [tip + toDoor * 1.4, by0 + dy, bz - 4.5], [tip + toDoor * 1.4, by0 + dy, floor + 3.6]], 0.2, { clampEvery: 2.2 }));
+    out.push(cub("hull-grey-dark", [tip + toDoor * 1.4 - 0.8, tip + toDoor * 1.4 + 0.8], [by0 - 1.5, by0 + 1.5], [floor + 2.8, floor + 3.8]), cub("lamp-amber", [tip + toDoor * 1.4 - 0.3, tip + toDoor * 1.4 + 0.3], [by0 - 1.5, by0 + 1.5], [floor + 3.8, floor + 3.95]));
+    // the hose reel on the pylon: a drum with flanges
+    out.push(rod("hull-grey", [wallX + toDoor * 1, by0 - 1.3, bz - 3], [wallX + toDoor * 1, by0 + 1.3, bz - 3], 1.4, 16), rod("hull-grey-dark", [wallX + toDoor * 1, by0 - 1.5, bz - 3], [wallX + toDoor * 1, by0 - 1.3, bz - 3], 1.9, 16), rod("hull-grey-dark", [wallX + toDoor * 1, by0 + 1.3, bz - 3], [wallX + toDoor * 1, by0 + 1.5, bz - 3], 1.9, 16));
+    // floodlights on the ceiling beams: eight round housings with lenses, brackets and a guard ring, pointing down at the cradles
+    const lz = z1 - 3.4 - 1;
+    for (let k = 0; k < 8; k++) {
+        const fy = y0 + 8 + k * ((y1 - y0 - 16) / 7);
+        for (const fx of [cx - 5, cx + 5])
+            if ((k + (fx > cx ? 1 : 0)) % 2 === 0)
+                out.push(rod("hull-grey-dark", [fx, fy, lz + 0.8], [fx, fy, lz + 0.2], 0.12, 8), rod("hull-grey-dark", [fx, fy, lz + 0.2], [fx, fy, lz - 0.7], 0.55, 14), rod("lamp-amber", [fx, fy, lz - 0.7], [fx, fy, lz - 0.85], 0.45, 14), rod("hull-grey", [fx, fy, lz - 0.6], [fx, fy, lz - 0.7], 0.7, 14));
+    }
+    void seed;
+    return out;
+}

package/dist/model/fleet/ship-03/hex.d.ts

@@ -0,0 +1,24 @@
+import { type MaterialName, type Piece } from "./adapter.ts";
+export interface HexSurface {
+    /** The surface's radius at a height. */
+    radius: (y: number) => number;
+    y0: number;
+    y1: number;
+    /** Where its axis stands, across and up. */
+    at: readonly [number, number];
+    /** The arcs of the circle the cladding may cover at a height, in radians from +Z towards +X. */
+    arcs: (y: number) => readonly (readonly [number, number])[];
+    /** A tile's circumradius in metres (the hexagon is a little under twice that across). */
+    tile: number;
+    /** How far a tile stands off the surface, in metres. */
+    raise?: number;
+    /** Square cells (a solar cell, with its width and height in metres) in plain rows in place of hexagons. */
+    cells?: {
+        w: number;
+        h: number;
+    };
+    /** What the tiles are made of, by cumulative share. */
+    tones?: readonly (readonly [number, MaterialName])[];
+}
+/** The tiles of a surface: staggered rows up it, each tile a raised hexagon leaving a seam of 12% between neighbours. */
+export declare function hexClad(s: HexSurface, seed: string): Piece[];

package/dist/model/fleet/ship-03/hex.js

@@ -0,0 +1,48 @@
+// Hexagonal cladding for a surface of revolution: rows of raised six-sided tiles, each a plate with a seam round it, set on the surface so the rows follow it round and up. Ariake's drive shrouds and her collar wear it in
+// near-black in place of Miyamoto's white and gold bands. The tiles are real geometry (a raised plate each, the dark body showing in the seams), drawn from one template of outline and thickness. Pure: no three.js and no DOM.
+import { rng } from "./adapter.js";
+/** What a tile is made of, by share: a third the black tile, most the dark panel, a few of the grey. */
+const TONES = [[0.35, "tile"], [0.9, "panel-dark"], [1, "hull-grey-dark"]];
+/** A hexagon of circumradius r, point up the surface. */
+const hexagon = (r) => Array.from({ length: 6 }, (_, i) => [r * Math.cos(Math.PI / 6 + (Math.PI / 3) * i), r * Math.sin(Math.PI / 6 + (Math.PI / 3) * i)]);
+/** The tiles of a surface: staggered rows up it, each tile a raised hexagon leaving a seam of 12% between neighbours. */
+export function hexClad(s, seed) {
+    const random = rng(`${seed}/hex`);
+    const raise = s.raise ?? 0.2;
+    const R = s.tile;
+    const colPitch = s.cells ? s.cells.w : Math.sqrt(3) * R;
+    const rowPitch = s.cells ? s.cells.h : 1.5 * R;
+    const outline = s.cells ? [[-s.cells.w * 0.46, -s.cells.h * 0.46], [s.cells.w * 0.46, -s.cells.h * 0.46], [s.cells.w * 0.46, s.cells.h * 0.46], [-s.cells.w * 0.46, s.cells.h * 0.46]] : hexagon(R * 0.88);
+    const tones = s.tones ?? TONES;
+    const stagger = s.cells ? 0 : 0.5;
+    const out = [];
+    let row = 0;
+    for (let y = s.y0 + (s.cells ? s.cells.h / 2 : R); y < s.y1 - (s.cells ? s.cells.h / 2 : R * 0.5); row++) {
+        const r = s.radius(y);
+        const dr = (s.radius(y + 0.25) - s.radius(y - 0.25)) / 0.5;
+        const slope = Math.atan(-dr);
+        const step = rowPitch / Math.sqrt(1 + dr * dr);
+        const n = Math.max(6, Math.floor((2 * Math.PI * r) / colPitch));
+        const half = colPitch / (2 * r) + 0.02;
+        const arcs = s.arcs(y);
+        for (let k = 0; k < n; k++) {
+            const a = (2 * Math.PI * (k + (row % 2) * stagger)) / n;
+            const wrapped = a % (2 * Math.PI);
+            const inside = arcs.some(([a0, a1]) => (a0 <= 0 && a1 >= 2 * Math.PI) || (wrapped - half >= a0 && wrapped + half <= a1) || (wrapped + 2 * Math.PI - half >= a0 && wrapped + 2 * Math.PI + half <= a1));
+            if (!inside)
+                continue;
+            const pick = random();
+            const material = tones.find(([share]) => pick < share)[1];
+            const nrm = [Math.sin(a), 0, Math.cos(a)];
+            const tangent = [nrm[2], 0, -nrm[0]];
+            const up = [-nrm[0] * Math.sin(slope), Math.cos(slope), -nrm[2] * Math.sin(slope)];
+            const out3 = [nrm[0] * Math.cos(slope), Math.sin(slope), nrm[2] * Math.cos(slope)];
+            const lift = raise / 2 + 0.01;
+            const o = [s.at[0] + nrm[0] * r + out3[0] * lift, y + out3[1] * lift, s.at[1] + nrm[2] * r + out3[2] * lift];
+            const tile = { kind: "plate", material, frame: { o, u: tangent, v: up, w: out3 }, outline, thickness: raise, plain: true, only: "mesh" };
+            out.push(tile);
+        }
+        y += step;
+    }
+    return out;
+}

package/dist/model/fleet/ship-03/hulls.d.ts

@@ -0,0 +1,50 @@
+import { type MaterialName, type Piece, type Vec3 } from "./adapter.ts";
+import type { Box } from "./dims.ts";
+import { type Face, rail, type Scheme } from "./faces.ts";
+import type { HullStack } from "./adapter.ts";
+export type Kind = "hatch" | "vent" | "windows" | "lamps" | "greeble" | "number" | "stub" | "bolts" | "hazard" | "sensor" | "dish";
+export interface Dress {
+    seed: string;
+    scheme: Scheme;
+    /** Plating cell, and the slot the hardware is set in, both across the face's two axes. */
+    cell?: readonly [number, number];
+    slot?: readonly [number, number];
+    /** The share of slots that hold hardware. */
+    density?: number;
+    kinds?: readonly Kind[];
+    /** A scale for counts: 1 is full detail. */
+    detail?: number;
+    raise?: number;
+    /** Quilted blanket pillows in big cells, instead of small panels. */
+    blanket?: boolean;
+    /** A slot whose centre this says no to is left plain. */
+    avoid?: (a: number, b: number) => boolean;
+}
+/** One face of a hull, plated and dressed. `lift` is how far the hardware stands out of the base (the plating's depth). */
+export declare function dressedFace(face: Face, o: Dress): Piece[];
+/** The six faces of a box: +x, -x, +y, -y, +z, -z. */
+export declare const facesOf: (box: Box) => {
+    stbd: Face;
+    port: Face;
+    bow: Face;
+    aft: Face;
+    dorsal: Face;
+    ventral: Face;
+};
+/** A solid hull: the core box in the dark under-colour (it is what shows in every seam), and every wanted face dressed. */
+export declare function hullBox(box: Box, core: MaterialName, faces: readonly (keyof ReturnType<typeof facesOf>)[], o: Dress): Piece[];
+/** The walls of a hull as separate shells, one for each layer of a stack, outermost first; each inner layer stands in `step` metres at its ends so the stack shows at a cut. `axis` is the way the wall's thickness runs. */
+export declare function wallShells(stack: HullStack, o: {
+    axis: "x" | "z";
+    sign: 1 | -1;
+    at: number;
+    y: readonly [number, number];
+    across: readonly [number, number];
+    step?: number;
+    scale?: number;
+}): Piece[];
+/** A row of rails and posts: a catwalk of grating with a handrail, along Y at (x, z). */
+export declare function catwalk(y0: number, y1: number, x: number, z: number, width?: number): Piece[];
+/** A pipe run from a to b: a round tube with a bend half way, flanges at the ends and a valve block on it, for the feed lines. */
+export declare function pipe(a: Vec3, b: Vec3, r: number, material?: MaterialName): Piece[];
+export { rail };