@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

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

@@ -0,0 +1,266 @@
+// The main drive, station 0 to 58 m: two DCD nozzles with their throat rings, field coils, feed manifolds and chamber heads, each in its own round shroud that narrows aft so the nozzle lips stand out past it. The shroud is
+// enclosed, with service windows in places that show the field coils, the throat rings and the feed lines; a neck carries the feed lines on to the hull, and four plasma verniers stand at the aft corners. The shadow-shield collar that
+// steps from the engines to the hull is its own part (`shadowCollar`), swappable with none. A cutaway leaves the starboard side open. Pure: no three.js and no DOM.
+import { collar, cub, pipeRun, quad, rng, rod, roundStrut, tileShield } from "./adapter.js";
+import { DRIVE, SHADOW_COLLAR, SHROUD } from "./dims.js";
+import { hexClad } from "./hex.js";
+import { collarAt, nozzleProfile, nozzleRadiusAt, OPEN_STARBOARD, ringAt, tubeAt } from "./shapes.js";
+const H = DRIVE.chamberY;
+/** One magnetic nozzle at (x, 0): the bell wall and its liner, the throat rings, the field coils with their spars, the feed manifold and the chamber head. */
+export function nozzle(x, cut, seed) {
+    const out = [];
+    const wall = nozzleProfile(DRIVE.exitY, DRIVE.throatY, H, DRIVE.exitR, DRIVE.throatR, DRIVE.chamberR);
+    const arc = cut && x > 0 ? OPEN_STARBOARD : undefined;
+    const lathe = (material, profile, extra = {}) => ({ kind: "lathe", material, at: [x, 0], segs: 40, profile, ...(arc ? { arc } : {}), ...extra });
+    out.push(lathe("bell", wall.map(([r, y]) => [r + 0.9, y]), { body: true, outline: true }));
+    out.push(lathe("bell-inside", wall.map(([r, y]) => [r + 0.1, y])));
+    // the liner: tiles lie in rings on the inside of the throat
+    for (let y = DRIVE.exitY + 1; y < DRIVE.throatY; y += 2.6)
+        out.push({ ...lathe("engine-metal", [[nozzleRadiusAt(wall, y) + 0.04, y], [nozzleRadiusAt(wall, y + 0.5) + 0.04, y + 0.5]]), only: "mesh" });
+    // field coils: copper rings round the bell, a coil every 1.8 m, wider ones where the bell is wide
+    for (let y = DRIVE.exitY + 1.5; y < DRIVE.throatY + 5; y += 1.8) {
+        const r = nozzleRadiusAt(wall, y) + 0.9 + 0.5;
+        out.push(ringAt("coil", x, 0, r, y, 0.5, arc ? { arc } : {}));
+        out.push(ringAt("hull-grey-dark", x, 0, r + 0.25, y + 0.9, 0.12, arc ? { arc } : {}));
+    }
+    // spars: eight beams along the bell holding the coils, each with a clamp at every coil
+    for (let k = 0; k < 8; k++) {
+        const az = (Math.PI / 4) * k;
+        if (arc && Math.sin(az) > 0.01)
+            continue;
+        const at = (y) => [x + (nozzleRadiusAt(wall, y) + 2.1) * Math.sin(az), y, (nozzleRadiusAt(wall, y) + 2.1) * Math.cos(az)];
+        out.push(rod("hull-grey-dark", at(DRIVE.exitY + 0.5), at(DRIVE.throatY + 5), 0.28, 6));
+    }
+    // throat rings: three steel collars at the narrowest part, each with bolts
+    for (const [i, y] of [DRIVE.throatY - 3, DRIVE.throatY, DRIVE.throatY + 3].entries()) {
+        out.push(collarAt("engine-pale", x, 0, DRIVE.throatR + 0.8, DRIVE.throatR + 2.2 + i * 0.4, y - 0.5, y + 0.5, arc ? { arc } : {}));
+        out.push(ringAt("copper", x, 0, DRIVE.throatR + 2.7 + i * 0.4, y, 0.2, arc ? { arc } : {}));
+    }
+    // exit lip: a heavy ring with a hazard band and the shutter leaves that close over it in the stowed state
+    out.push(collarAt("hull-orange", x, 0, DRIVE.exitR + 0.8, DRIVE.exitR + 2.6, DRIVE.exitY - 0.8, DRIVE.exitY + 0.6, arc ? { arc } : {}));
+    for (let i = 0; i < 24; i++) {
+        const a = (Math.PI * 2 * i) / 24;
+        if (arc && Math.sin(a) > 0)
+            continue;
+        const r = DRIVE.exitR + 1.7;
+        out.push(cub(i % 2 ? "black" : "hazard", [x + r * Math.sin(a) - 0.5, x + r * Math.sin(a) + 0.5], [DRIVE.exitY - 0.9, DRIVE.exitY - 0.82], [r * Math.cos(a) - 0.5, r * Math.cos(a) + 0.5]));
+    }
+    // chamber head: the injector plate with its ring of feed stubs, and the manifold that carries fuel in from the spine
+    out.push(tubeAt("hull-grey-dark", x, 0, DRIVE.chamberR + 1.1, H, H + 4, { segs: 24 }));
+    for (let k = 0; k < 12; k++) {
+        const a = (Math.PI * 2 * k) / 12;
+        if (arc && Math.sin(a) > 0)
+            continue;
+        const p0 = [x + (DRIVE.chamberR + 1) * Math.sin(a), H + 3, (DRIVE.chamberR + 1) * Math.cos(a)];
+        out.push(rod("coolant", p0, [x + (DRIVE.chamberR + 3.3) * Math.sin(a), H + 4.5, (DRIVE.chamberR + 3.3) * Math.cos(a)], 0.34, 6), rod("copper", [p0[0], H + 0.5, p0[2]], [p0[0], H + 3, p0[2]], 0.22, 6));
+    }
+    out.push(ringAt("coolant", x, 0, DRIVE.chamberR + 3.3, H + 4.5, 0.45, arc ? { arc } : {}), ringAt("coolant", x, 0, DRIVE.chamberR + 2.4, H + 1.5, 0.38, arc ? { arc } : {}));
+    // gimbals: two actuators at right angles, each a cylinder and a rod on a clevis
+    for (const az of [Math.PI / 2, Math.PI]) {
+        if (arc && Math.sin(az) > 0.01)
+            continue;
+        const base = [x + 15.5 * Math.sin(az), H + 4.5, 15.5 * Math.cos(az)];
+        const tip = [x + (DRIVE.chamberR + 1.6) * Math.sin(az), H - 4, (DRIVE.chamberR + 1.6) * Math.cos(az)];
+        out.push(rod("hull-grey-dark", base, [(base[0] + tip[0]) / 2, H, (base[2] + tip[2]) / 2], 0.7, 8), rod("engine-pale", [(base[0] + tip[0]) / 2, H, (base[2] + tip[2]) / 2], tip, 0.35, 8), rod("lamp-amber", [base[0], base[1], base[2]], [base[0], base[1] + 0.5, base[2]], 0.3, 6));
+    }
+    void seed;
+    return out;
+}
+/** A vernier: a small bell with three coils, a feed line, a gimbal box and a pod. */
+export function vernier(x, z) {
+    const v = DRIVE.vernier;
+    const wall = nozzleProfile(0.2, 4.2, 8, v.r, 0.7, 1.2, 6);
+    const out = [{ kind: "lathe", material: "bell", at: [x, z], segs: 20, profile: wall.map(([r, y]) => [r + 0.12, y]), body: true, outline: true }, { kind: "lathe", material: "bell-inside", at: [x, z], segs: 20, profile: wall }];
+    for (const y of [1.2, 2.4, 3.6])
+        out.push(ringAt("coil", x, z, nozzleRadiusAt(wall, y) + 0.3, y, 0.16));
+    out.push(cub("hull-grey-dark", [x - 2.4, x + 2.4], [3.6, 8.2], [z - 2.4, z + 2.4]), cub("hull-orange", [x - 2.6, x + 2.6], [8.2, 8.6], [z - 2.6, z + 2.6]));
+    out.push(rod("coolant", [x, 8.4, z], [x * 0.6, 12, z * 0.7], 0.22, 6), cub("lamp-amber", [x - 0.3, x + 0.3], [-0.05, 0.1], [z + 1.2, z + 1.8]));
+    return out;
+}
+/** The radius of the shroud at a height: a smooth rise from its aft lip to the fore end, so it narrows aft. */
+const shroudAt = (y) => SHROUD.rAft + (SHROUD.rFore - SHROUD.rAft) * Math.sin(((y - SHROUD.start) / (SHROUD.end - SHROUD.start)) * (Math.PI / 2)) ** 1.3;
+/** The arcs of a circle left when some windows are cut out of it: each window is a centre and a width, in degrees round from +Z towards +X. */
+function arcsLeft(windows) {
+    const cuts = windows.map(([c, w]) => [((c - w / 2 + 360) % 360), ((c + w / 2 + 360) % 360)]).sort((p, q) => p[0] - q[0]);
+    const deg = (v) => (v * Math.PI) / 180;
+    if (!cuts.length)
+        return [[0, 2 * Math.PI]];
+    const out = [];
+    let from = cuts[cuts.length - 1][1];
+    for (const [a, b] of cuts) {
+        const start = from;
+        const end = a < start ? a + 360 : a;
+        if (end > start)
+            out.push([deg(start), deg(end)]);
+        from = b;
+    }
+    return out;
+}
+/** The shroud of one nozzle: faceted bands in white blanket and gold foil, ring frames and round stringers between, windows cut in some bands. `side` is the nozzle's side (+1 starboard) and the way its outer window faces. */
+function shroud(x, side, cut, detail, seed, hex) {
+    const out = [];
+    const random = rng(`${seed}/shroud/${side}`);
+    const open = cut && side === 1;
+    const outward = side === 1 ? 90 : 270;
+    // the windows by band: the coils from the side, the throat rings and feed lines from above and below, the chamber heads from above
+    const bands = [
+        { y: [7, 13], material: "hull-white", windows: [] },
+        { y: [13, 19], material: "gold", windows: [[outward, 84]] },
+        { y: [19, 25], material: "hull-white-worn", windows: [[0, 56], [180, 56]] },
+        { y: [25, 31], material: "gold", windows: [[outward, 70]] },
+        { y: [31, 36], material: "hull-white", windows: [[0, 64]] },
+    ];
+    for (const band of bands) {
+        const ys = Array.from({ length: 4 }, (_, i) => band.y[0] + ((band.y[1] - band.y[0]) * i) / 3);
+        const profile = ys.map((y) => [shroudAt(y) + 0.5, y]);
+        const arcs = open ? [[Math.PI, 2 * Math.PI]] : arcsLeft(band.windows);
+        for (const [a0, a1] of arcs)
+            out.push({ kind: "lathe", material: hex ? "tile" : band.material, at: [x, 0], segs: hex ? 48 : 16, profile, arc: () => [a0, a1], body: true, outline: true });
+        // a window's frame: an axial bar at each edge and a flange ring at each end
+        for (const [c, w] of band.windows) {
+            if (open)
+                continue;
+            for (const e of [c - w / 2, c + w / 2]) {
+                const a = (e * Math.PI) / 180;
+                const p = (y) => [x + (shroudAt(y) + 0.7) * Math.sin(a), y, (shroudAt(y) + 0.7) * Math.cos(a)];
+                out.push(rod("hull-grey-dark", p(band.y[0]), p(band.y[1]), 0.28, 8));
+            }
+        }
+    }
+    // Ariake: the bands are clad in rows of raised near-black hexagonal tiles, clear of the ring frames and the window frames
+    if (hex) {
+        const rings = [7.1, 13, 19, 25, 31, 36];
+        out.push(...hexClad({ radius: (y) => shroudAt(y) + 0.5, y0: 7.4, y1: 35.8, at: [x, 0], tile: detail < 0.5 ? 1.5 : 1.05, arcs: (y) => {
+                if (rings.some((r) => Math.abs(y - r) < 1))
+                    return [];
+                if (open)
+                    return [[Math.PI, 2 * Math.PI]];
+                const band = bands.find((b) => y >= b.y[0] && y < b.y[1]);
+                return arcsLeft(band?.windows ?? []).map(([a0, a1]) => [a0 + 0.07, a1 - 0.07]).filter(([a0, a1]) => a1 > a0);
+            } }, `${seed}/${side}`));
+    }
+    // ring frames between the bands, standing proud, with a row of bolts
+    for (const y of [7.1, 13, 19, 25, 31, 36]) {
+        out.push(ringAt("hull-grey", x, 0, shroudAt(y) + 0.5, y, 0.5, open ? { arc: () => [Math.PI, 2 * Math.PI] } : {}));
+        if (detail > 0.5)
+            for (let k = 0; k < 24; k++) {
+                const a = (Math.PI * 2 * k) / 24;
+                if (open && Math.sin(a) > 0)
+                    continue;
+                out.push(rod("hull-grey-dark", [x + (shroudAt(y) + 0.95) * Math.sin(a), y - 0.15, (shroudAt(y) + 0.95) * Math.cos(a)], [x + (shroudAt(y) + 0.95) * Math.sin(a), y + 0.15, (shroudAt(y) + 0.95) * Math.cos(a)], 0.14, 6));
+            }
+    }
+    // stringers: round rods along the shroud between the windows, every twenty degrees
+    for (let a = 5; a < 360 && !hex; a += 20 / Math.max(0.3, detail)) {
+        const r = (a * Math.PI) / 180;
+        if (open && Math.sin(r) > 0)
+            continue;
+        if (Math.abs(((a - outward + 540) % 360) - 180) < 52 || a < 32 || a > 328 || Math.abs(a - 180) < 32)
+            continue;
+        out.push(rod(random() < 0.3 ? "hull-grey" : "hull-grey-dark", [x + (shroudAt(7) + 0.7) * Math.sin(r), 7, (shroudAt(7) + 0.7) * Math.cos(r)], [x + (shroudAt(36) + 0.7) * Math.sin(r), 36, (shroudAt(36) + 0.7) * Math.cos(r)], 0.2, 8));
+    }
+    // the fore end: a flat cap, and the aft lip where the shroud ends and the nozzle's own lip stands past it
+    out.push({ kind: "lathe", material: "hull-grey-dark", at: [x, 0], segs: 16, profile: [[0.001, 36], [shroudAt(36) + 0.5, 36]], ...(open ? { arc: () => [Math.PI, 2 * Math.PI] } : {}) });
+    out.push(ringAt("hull-orange", x, 0, shroudAt(7) + 0.2, 7, 0.45, open ? { arc: () => [Math.PI, 2 * Math.PI] } : {}));
+    return out;
+}
+/** The main drive: both nozzles in their shrouds, the neck to the hull with the feed lines, and the verniers. */
+export function driveFrame(cut, detail = 1, seed = "drive", hex = false) {
+    const out = [];
+    const nx = DRIVE.nozzleX;
+    out.push(...nozzle(-nx, cut, seed), ...nozzle(nx, cut, seed), ...shroud(-nx, -1, cut, detail, seed, hex), ...shroud(nx, 1, cut, detail, seed, hex));
+    // a web between the shrouds where they meet, so the two read as one body: a faceted lens of white blanket
+    out.push({ kind: "lathe", material: hex ? "tile" : "hull-white", at: [0, 0], segs: 8, profile: [[0.001, 14], [4.6, 18], [5.2, 26], [4.6, 34], [0.001, 36]], ...(cut ? { arc: () => [Math.PI, 2 * Math.PI] } : {}) });
+    // the neck: a round tube from the shrouds to the engineering module, with the feed lines running along it in round pipes with bends, flanges and clamps
+    out.push(tubeAt("hull-grey-dark", 0, 0, 9.5, 36, 58, { segs: 20, body: true, outline: true }), ...ringsOn(9.5, [40, 46, 52], 0.35));
+    for (const [sx, mat] of [[-1, "coolant"], [1, "copper"]]) {
+        out.push(...pipeRun(mat, [[sx * (nx - 6), 34, 14], [sx * 11, 40, 11.5], [sx * 11, 56, 11.5]], 0.5, { clampEvery: 5, bracket: [0, 0, -1] }));
+        out.push(...pipeRun(sx < 0 ? "copper" : "coolant", [[sx * (nx - 6), 34, -14], [sx * 11, 40, -11.5], [sx * 11, 56, -11.5]], 0.5, { clampEvery: 5, bracket: [0, 0, 1] }));
+    }
+    // the verniers at the aft corners, each held to its shroud by two round struts
+    for (const [x, z] of [[-DRIVE.vernier.x, DRIVE.vernier.z], [DRIVE.vernier.x, DRIVE.vernier.z], [-DRIVE.vernier.x, -DRIVE.vernier.z], [DRIVE.vernier.x, -DRIVE.vernier.z]]) {
+        out.push(...vernier(x, z));
+        const sx = Math.sign(x);
+        for (const dy of [3, 7])
+            out.push(...roundStrut("hull-grey-dark", [x, dy + 4, z * 0.8], [sx * nx + sx * Math.hypot(shroudAt(11) - 2, 0) * 0.9, 11, z * 0.45], 0.4));
+    }
+    out.push(...collar("L", 58, 1));
+    return out;
+}
+/** Rings of structure round a tube. */
+function ringsOn(r, ys, minor) {
+    return ys.map((y) => ringAt("hull-grey", 0, 0, r + minor, y, minor));
+}
+/** The shadow-shield collar: a round ceramic-tile cone that steps from the engines to the hull, as the shadow shields of the nuclear-thermal studies do, with ring frames, a row of bolts and struts to the shrouds. Its own part: swap it for none. */
+export function shadowCollar(cut, detail = 1, seed = "shield-collar", hex = false) {
+    const { y, length, r } = SHADOW_COLLAR;
+    const profile = [[r, y], [r, y + 3], [r - 3, y + 6], [r * 0.7, y + 13], [r * 0.46, y + 19], [14, y + length]];
+    const shield = hex ? hexShield(profile, seed, detail) : tileShield(profile, seed, 24, 20);
+    const out = cut ? shield.map((p) => (p.kind === "lathe" ? { ...p, arc: () => [Math.PI, 2 * Math.PI] } : p)).filter((p) => p.kind !== "plate" || p.frame.o[0] <= 0.5) : shield;
+    for (const yy of [y + 3, y + 6, y + 13, y + 19])
+        out.push(ringAt("hull-grey", 0, 0, (profile.find(([, py]) => py === yy)?.[0] ?? r) + 0.4, yy, 0.45, cut ? { arc: () => [Math.PI, 2 * Math.PI] } : {}));
+    for (let k = 0; k < 32 * Math.min(1, detail + 0.3); k++) {
+        const a = (Math.PI * 2 * k) / 32;
+        if (cut && Math.sin(a) > 0)
+            continue;
+        out.push(rod("hull-grey-dark", [r * Math.sin(a), y + 0.4, r * Math.cos(a)], [r * Math.sin(a), y + 1.4, r * Math.cos(a)], 0.3, 8));
+    }
+    // the cone's dress: removable orange shield panels and gold foil in rows, hatches, lamps, a hazard band, a number, and round pipes with bends from the shrouds to the neck
+    const rows = [[y + 7, y + 11, "hull-orange"], [y + 14, y + 18, "gold"], [y + 19.5, y + 21.5, "hull-white"]];
+    const at = (yy, a, lift) => {
+        const f = (yy - y) / length;
+        const seg = profile.findIndex(([, py], i) => i + 1 < profile.length && yy >= py && yy <= profile[i + 1][1]);
+        const [r0, y0] = profile[Math.max(0, seg)];
+        const [r1, y1] = profile[Math.min(profile.length - 1, Math.max(0, seg) + 1)];
+        const rr = (y1 === y0 ? r0 : r0 + ((r1 - r0) * (yy - y0)) / (y1 - y0)) + lift;
+        void f;
+        return [rr * Math.sin(a), yy, rr * Math.cos(a)];
+    };
+    rows.filter((_, ri) => !hex || ri === 0).forEach(([ya, yb, mat], ri) => {
+        const n = 20 - ri * 2;
+        for (let k = 0; k < n; k++) {
+            const a0 = (Math.PI * 2 * (k + 0.08)) / n;
+            const a1 = (Math.PI * 2 * (k + 0.92)) / n;
+            if (cut && Math.sin((a0 + a1) / 2) > 0)
+                continue;
+            out.push(quad(k % 5 === 4 ? "hull-orange-worn" : mat, at(ya, a0, 0.25), at(ya, a1, 0.25), at(yb, a1, 0.25), at(yb, a0, 0.25), 0.22), cub("hull-grey-dark", [at((ya + yb) / 2, (a0 + a1) / 2, 0.45)[0] - 0.3, at((ya + yb) / 2, (a0 + a1) / 2, 0.45)[0] + 0.3], [(ya + yb) / 2 - 0.2, (ya + yb) / 2 + 0.2], [at((ya + yb) / 2, (a0 + a1) / 2, 0.45)[2] - 0.3, at((ya + yb) / 2, (a0 + a1) / 2, 0.45)[2] + 0.3]));
+        }
+    });
+    for (let k = 0; k < 8; k++) {
+        const a = (Math.PI * 2 * k) / 8 + 0.2;
+        if (cut && Math.sin(a) > 0)
+            continue;
+        const p = at(y + 4.5, a, 0.3);
+        out.push(rod("hazard", at(y + 4.1, a, 0.2), at(y + 4.9, a, 0.2), 0.4, 8), cub("lamp-amber", [p[0] - 0.2, p[0] + 0.2], [p[1] - 0.2, p[1] + 0.2], [p[2] - 0.2, p[2] + 0.2]), cub("panel-dark", [at(y + 2, a, 0.1)[0] - 0.7, at(y + 2, a, 0.1)[0] + 0.7], [y + 1.4, y + 2.6], [at(y + 2, a, 0.1)[2] - 0.7, at(y + 2, a, 0.1)[2] + 0.7]));
+    }
+    for (let k = 0; k < 6; k++) {
+        const a = (Math.PI * 2 * k) / 6 + 0.5;
+        if (cut && Math.sin(a) > 0)
+            continue;
+        out.push(...pipeRun(k % 2 ? "coolant" : "copper", [at(y + 11, a, 0.9), at(y + 14, a + 0.1, 1.6), at(y + 20, a + 0.1, 1.3)], 0.3, { clampEvery: 4 }));
+    }
+    // struts from the collar's face to the two shrouds, round, with ball joints
+    for (const sx of [-1, 1])
+        for (const sz of [-1, 1])
+            out.push(...roundStrut("hull-grey-dark", [sx * 14, y + 1, sz * 14], [sx * (DRIVE.nozzleX - 6), y - 2.5, sz * 12], 0.45));
+    return out;
+}
+/** The bare joint when the collar is swapped for none: a flange ring where the neck meets the hull, so the part is never empty. */
+export function noCollar() {
+    return [ringAt("hull-grey", 0, 0, 11, 0.5, 0.5), ringAt("hull-grey-dark", 0, 0, 11, 1, 0.3), ...Array.from({ length: 16 }, (_, k) => rod("hull-grey-dark", [11.6 * Math.sin((Math.PI * 2 * k) / 16), 0.2, 11.6 * Math.cos((Math.PI * 2 * k) / 16)], [11.6 * Math.sin((Math.PI * 2 * k) / 16), 1.1, 11.6 * Math.cos((Math.PI * 2 * k) / 16)], 0.2, 6)), cub("lamp-amber", [-0.3, 0.3], [0, 0.4], [11.6, 12.2])];
+}
+/** The shield of Ariake's collar: the dark cone, then rows of raised hexagonal tiles over it, clear of the ring frames, the hazard band, the hatches and the orange panel row (which stay as they are on Miyamoto). */
+function hexShield(profile, seed, detail) {
+    const { y } = SHADOW_COLLAR;
+    const radius = (yy) => {
+        const i = profile.findIndex(([, py], k) => k + 1 < profile.length && yy >= py && yy <= profile[k + 1][1]);
+        const [r0, y0] = profile[Math.max(0, i)];
+        const [r1, y1] = profile[Math.min(profile.length - 1, Math.max(0, i) + 1)];
+        return y1 === y0 ? r0 : r0 + ((r1 - r0) * (yy - y0)) / (y1 - y0);
+    };
+    const body = { kind: "lathe", material: "tile", segs: 48, body: true, outline: true, profile, rings: profile.slice(1, -1).map(([, py]) => py) };
+    const clear = [y + 3, y + 6, y + 13, y + 19].map((r) => [r - 0.8, r + 0.8]);
+    const dressed = [[y + 1, y + 3], [y + 3.9, y + 5.1], [y + 6.6, y + 11.4]];
+    const skip = (yy) => clear.some(([a, b]) => yy > a && yy < b) || dressed.some(([a, b]) => yy > a && yy < b);
+    return [body, ...hexClad({ radius, y0: y + 1.6, y1: y + SHADOW_COLLAR.length - 0.4, at: [0, 0], tile: detail < 0.5 ? 1.7 : 1.2, arcs: (yy) => (skip(yy) ? [] : [[0, 2 * Math.PI]]) }, seed)];
+}

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

@@ -0,0 +1,5 @@
+import { type Piece } from "./adapter.ts";
+/** The rooms inside, in ship metres. */
+export declare function engineeringInside(): Piece[];
+/** Engineering from outside, and from the starboard side when `cut`. */
+export declare function engineering(cut: boolean, detail?: number, seed?: string): Piece[];

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

@@ -0,0 +1,59 @@
+// Engineering and isolators, station 58 to 90 m: the reactor chambers, the locked-out service corridor, two isolated auxiliary power units, the emergency fission battery room and the distribution breakers. The propulsion
+// loop and the hotel loop are separate rooms with a hazard-marked lock between them. It is a round pressure drum with berthing rings at both ends, wrapped in gold foil blankets, with the feed lines to the drive strung on
+// its flank. A cutaway opens the starboard side. Descends from the ISS's Zvezda service module and the reactor and shadow-shield section of NASA's Mars transfer vehicle studies. Pure: no three.js and no DOM.
+import { contextOf, cub, drum, pipeRun, place, rod } from "./adapter.js";
+import { STATION } from "./dims.js";
+import { catwalk, pipe } from "./hulls.js";
+import { hazard } from "./faces.js";
+import { collarAt, ringAt, tubeAt } from "./shapes.js";
+const [Y0, Y1] = STATION.engineering;
+const R = 13;
+const L = Y1 - Y0;
+/** The rooms inside, in ship metres. */
+export function engineeringInside() {
+    const out = [];
+    // the reactor chamber: a vessel with a glowing core, field rings and a coolant manifold, on the propulsion side (port)
+    out.push(tubeAt("hull-grey", -5.5, 1, 4.6, Y0 + 2, Y0 + 16, { segs: 28 }), tubeAt("core", -5.5, 1, 1.7, Y0 + 3.4, Y0 + 14.6, { segs: 16 }));
+    for (let y = Y0 + 3.5; y < Y0 + 15.5; y += 1.6)
+        out.push(ringAt("coil", -5.5, 1, 5, y, 0.32, { segs: 28 }));
+    for (let k = 0; k < 8; k++) {
+        const a = (Math.PI * 2 * k) / 8;
+        out.push(rod("coolant", [-5.5 + 5.5 * Math.sin(a), Y0 + 3, 1 + 5.5 * Math.cos(a)], [-5.5 + 5.5 * Math.sin(a), Y0 + 15.5, 1 + 5.5 * Math.cos(a)], 0.2, 12));
+    }
+    out.push(collarAt("panel-dark", -5.5, 1, 3.6, 5.4, Y0 + 15.8, Y0 + 17.2));
+    // two isolated auxiliary power units, each in a cage with its own breaker cabinet
+    for (const x of [3, 7.2]) {
+        out.push(tubeAt("hull-white", x, -4.4, 1.9, Y0 + 3, Y0 + 12, { segs: 20 }), ...[0, 1, 2, 3, 4].map((k) => ringAt("hull-grey-dark", x, -4.4, 1.95, Y0 + 4 + k * 1.8, 0.14, { segs: 20 })));
+        out.push(cub("hull-grey-dark", [x - 2.2, x + 2.2], [Y0 + 2.6, Y0 + 12.4], [-7.3, -7.0]), cub("lamp-blue", [x - 0.3, x + 0.3], [Y0 + 11, Y0 + 11.6], [-7.4, -7.3]));
+        out.push(...pipeRun("coolant", [[x, Y0 + 12, -4.4], [x, Y0 + 14, -4.4], [x, Y0 + 14, -1.5]], 0.2), ...pipeRun("copper", [[x, Y0 + 2.6, -4.4], [x - 2, Y0 + 2, -2], [x - 2, Y0 + 2, 0]], 0.17));
+    }
+    // the emergency fission battery room: a sealed box of cells in three rows, behind a lock
+    out.push(cub("hull-grey-dark", [3, 9.6], [Y0 + 19, Y0 + 28], [-2.4, 5.2], { only: "mesh" }));
+    for (let r = 0; r < 3; r++)
+        for (let c = 0; c < 3; c++)
+            out.push(cub(c % 2 ? "hull-yellow" : "hull-white", [3.5 + c * 2.1, 5.4 + c * 2.1], [Y0 + 19.6 + r * 2.8, Y0 + 22], [-1.9, 4.7]), cub("lamp-amber", [3.9 + c * 2.1, 5 + c * 2.1], [Y0 + 21.9 + r * 2.8, Y0 + 22.1], [4.7, 4.9]));
+    out.push(...hazard({ n: "x", sign: 1, at: 9.6, a: [Y0 + 19, Y0 + 28], b: [-2.4, 5.2] }, 1, Y0 + 19, Y0 + 28, 0.5, 1));
+    // the distribution breakers: a row of cabinets along the port side with a cable trench in front
+    for (let y = Y0 + 20; y < Y1 - 1.5; y += 1.9)
+        out.push(cub("panel-dark", [-9.8, -7.8], [y, y + 1.6], [-6, 2]), cub("lamp-blue", [-7.8, -7.7], [y + 0.5, y + 0.9], [-5.6, -4.2]), cub("lamp-amber", [-7.8, -7.7], [y + 0.5, y + 0.9], [-1, 0.2]));
+    // the service corridor: a deck along the room and a catwalk, and an isolation lock between the loops: two doors with an airlock between
+    out.push(cub("deck", [-9.5, 9.5], [Y0 + 1, Y1 - 1], [-8.6, -8.4]), ...catwalk(Y0 + 1, Y1 - 1, 0, -8.4, 2));
+    for (const y of [Y0 + 17.5, Y0 + 18.6])
+        out.push(cub("hull-orange", [-9.5, 9.5], [y, y + 0.25], [-6, 7]), ...[-1, 1].map((s) => cub("hazard", [s * 2 - 0.5, s * 2 + 0.5], [y, y + 0.3], [-3, 6])));
+    return out;
+}
+/** Engineering from outside, and from the starboard side when `cut`. */
+export function engineering(cut, detail = 1, seed = "eng") {
+    const ctx = contextOf(seed, "science", { cutaway: cut, detail, seed }, "command");
+    const out = [...place(drum(ctx, { R, L, top: "L", bottom: "L", panels: { wide: 2.6, tall: 1.8 }, hatches: 7, roundHatches: true, conduits: 8, trays: 3, vents: 6, ladders: 1, rings: [0.2, 0.4, 0.6, 0.8], digits: "03", junk: 60 }), { at: [0, Y0, 0], yaw: 90 })];
+    if (cut)
+        out.push(...engineeringInside());
+    // gold foil blankets: faceted collars round the drum, as on the lunar module's descent stage and Hubble
+    for (const [y, h] of [[Y0 + 6, 5], [Y0 + 19, 6], [Y0 + 28, 3]])
+        out.push({ kind: "lathe", material: "gold", segs: 10, profile: [[R + 0.18, y], [R + 0.5, y + 0.4], [R + 0.5, y + h - 0.4], [R + 0.18, y + h]], only: "mesh", ...(cut ? { arc: () => [Math.PI, 2 * Math.PI] } : {}) });
+    // the feed lines to the drive: a pair of round pipes along the flank with flanges, clamps and a bend at each end
+    for (const [x, mat] of [[-3, "coolant"], [3, "copper"]])
+        out.push(...pipeRun(mat, [[x, Y0 + 0.5, R + 0.9], [x, Y0 + 2, R + 1.4], [x, Y1 - 2, R + 1.4], [x, Y1 - 0.5, R + 0.9]], 0.34, { clampEvery: 4, bracket: [0, 0, -1.1] }));
+    out.push(...pipe([-3, Y0 + 15, R + 1.4], [3, Y0 + 15, R + 1.4], 0.25, "lamp-red"));
+    return out;
+}

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

@@ -0,0 +1,78 @@
+import { cub, type MaterialName, type Piece, type Vec3 } from "./adapter.ts";
+export type Axis = "x" | "y" | "z";
+/** One side of a box: which axis it faces, which way, where it stands on that axis, and the extent of its two surface axes. */
+export interface Face {
+    n: Axis;
+    sign: 1 | -1;
+    at: number;
+    a: readonly [number, number];
+    b: readonly [number, number];
+    /** The two surface axes the other way round: a runs along the second. */
+    swap?: boolean;
+}
+/** The colours a hull is plated in. */
+export interface Scheme {
+    main: MaterialName;
+    worn: MaterialName;
+    block: MaterialName;
+    blockWorn: MaterialName;
+    accent: MaterialName;
+}
+export declare const WHITE: Scheme;
+export declare const SHUTTER: Scheme;
+export declare const ARMOUR: Scheme;
+export declare const SPINE: Scheme;
+/** The same face with its axes the other way round, so a run along `a` goes along the spine on a dorsal or ventral face. */
+export declare const along: (face: Face) => Face;
+/** The point at surface coordinates (a, b), `h` metres out of the face. */
+export declare function pt(face: Face, a: number, b: number, h?: number): Vec3;
+/** A box on a face: centred on (a, b), `da` by `db` across, standing from `h0` to `h1` metres out of it. */
+export declare function on(face: Face, a: number, b: number, da: number, db: number, h0: number, h1: number, material: MaterialName, extra?: Partial<Parameters<typeof cub>[4]>): import("./adapter.ts").Plate;
+/** A face of a box given by its ranges. */
+export declare function faceOf(box: {
+    x: readonly [number, number];
+    y: readonly [number, number];
+    z: readonly [number, number];
+}, n: Axis, sign: 1 | -1): Face;
+/** Plating: rows and columns of raised panels, a hand's width apart, in the scheme's colours, some worn, some bare, some in the block colour; sizes vary by row so no two walls are the same. */
+export declare function skin(face: Face, scheme: Scheme, seed: string, o?: {
+    cell?: readonly [number, number];
+    raise?: number;
+    blocks?: number;
+    bare?: number;
+    detail?: number;
+    blanket?: boolean;
+    skip?: (a: number, b: number) => boolean;
+}): Piece[];
+/** An access hatch: a frame of four jambs, a door with hinges and a latch, a hazard bar and a lamp. */
+export declare function hatch(face: Face, a: number, b: number, s?: number): Piece[];
+/** A louvred vent: a dark frame with slats. */
+export declare function vent(face: Face, a: number, b: number, wide?: number, tall?: number, slats?: number): Piece[];
+/** A bundle of pipes along the surface axis `a`, at `b`, held off the face by clamps every few metres. */
+export declare function conduit(face: Face, b: number, a0: number, a1: number, o: {
+    count?: number;
+    pipe?: number;
+    materials?: readonly MaterialName[];
+    seed: string;
+    stand?: number;
+}): Piece[];
+/** A handrail along the surface axis `a`, at `b`: posts and a top rail in service yellow. */
+export declare function rail(face: Face, b: number, a0: number, a1: number, height?: number): Piece[];
+/** A ladder along `a`: two rails and rungs. */
+export declare function ladder(face: Face, b: number, a0: number, a1: number, width?: number): Piece[];
+/** A lamp: a small dome on a stalk. */
+export declare const lamp: (face: Face, a: number, b: number, colour: "amber" | "blue" | "red", size?: number) => Piece[];
+/** A row of bolt heads along `a` at `b`. */
+export declare function bolts(face: Face, b: number, a0: number, a1: number, pitch?: number, size?: number): Piece[];
+/** A row of windows (dark glass in a frame) along `a` at `b`. */
+export declare function windows(face: Face, b: number, a0: number, a1: number, n: number, size?: number): Piece[];
+/** Digits in seven bars, our own figures, on a face: `size` is a digit's height. */
+export declare function stencil(face: Face, text: string, a: number, b: number, size: number, material?: MaterialName): Piece[];
+/** A stripe of hazard blocks along `a` at `b`. */
+export declare function hazard(face: Face, b: number, a0: number, a1: number, tall?: number, block?: number): Piece[];
+/** A frame round an opening: four beams standing out of the face. */
+export declare function frame(face: Face, a: number, b: number, da: number, db: number, thick: number, h: number, material: MaterialName): Piece[];
+/** A beam from one surface point to another, standing `h` out of the face: a brace, a pipe, a cable. */
+export declare const strutOn: (face: Face, p: readonly [number, number], q: readonly [number, number], w: number, d: number, h: number, material: MaterialName) => Piece;
+/** A seeded pick: n of the list's items, in order, that the random numbers choose. */
+export declare function some<T>(random: () => number, items: readonly T[], share: number): T[];

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

@@ -0,0 +1,218 @@
+// Detail on the flat faces of Miyamoto's boxy hull: plating in rows with a gap between, hatches, vents, conduits, rails, ladders, lamps, bolts and our own stencils. A face is one side of an axis-aligned box. Its two
+// surface axes follow the cycle x -> y -> z: on an X face they are Y then Z, on a Y face Z then X, on a Z face X then Y. Everything stands off the surface by a few centimetres up to a metre, so a close view has depth.
+// All of it is plain pieces, mesh only unless said, and the same description gives the same bytes. Pure: no three.js and no DOM.
+import { beam, cub, rng, rod } from "./adapter.js";
+export const WHITE = { main: "hull-white", worn: "hull-white-worn", block: "hull-grey", blockWorn: "hull-grey-dark", accent: "hull-yellow" };
+export const SHUTTER = { main: "hull-orange", worn: "hull-orange-worn", block: "hull-grey", blockWorn: "hull-grey-dark", accent: "hull-yellow" };
+export const ARMOUR = { main: "hull-grey", worn: "hull-grey-dark", block: "hull-white", blockWorn: "hull-white-worn", accent: "hull-orange" };
+export const SPINE = { main: "hull-grey-dark", worn: "panel-dark", block: "hull-grey", blockWorn: "hull-grey-dark", accent: "hull-yellow" };
+const AXES = { x: ["y", "z"], y: ["z", "x"], z: ["x", "y"] };
+const axesOf = (face) => (face.swap ? [AXES[face.n][1], AXES[face.n][0]] : AXES[face.n]);
+/** The same face with its axes the other way round, so a run along `a` goes along the spine on a dorsal or ventral face. */
+export const along = (face) => ({ ...face, swap: !face.swap, a: face.b, b: face.a });
+/** The point at surface coordinates (a, b), `h` metres out of the face. */
+export function pt(face, a, b, h = 0) {
+    const p = { x: 0, y: 0, z: 0 };
+    const [ta, tb] = axesOf(face);
+    p[ta] = a;
+    p[tb] = b;
+    p[face.n] = face.at + face.sign * h;
+    return [p.x, p.y, p.z];
+}
+/** A box on a face: centred on (a, b), `da` by `db` across, standing from `h0` to `h1` metres out of it. */
+export function on(face, a, b, da, db, h0, h1, material, extra = {}) {
+    const r = { x: [0, 0], y: [0, 0], z: [0, 0] };
+    const [ta, tb] = axesOf(face);
+    r[ta] = [a - da / 2, a + da / 2];
+    r[tb] = [b - db / 2, b + db / 2];
+    r[face.n] = [face.at + face.sign * h0, face.at + face.sign * h1];
+    return cub(material, r.x, r.y, r.z, extra);
+}
+/** A face of a box given by its ranges. */
+export function faceOf(box, n, sign) {
+    const [ta, tb] = AXES[n];
+    return { n, sign, at: sign === 1 ? box[n][1] : box[n][0], a: box[ta], b: box[tb] };
+}
+/** Plating: rows and columns of raised panels, a hand's width apart, in the scheme's colours, some worn, some bare, some in the block colour; sizes vary by row so no two walls are the same. */
+export function skin(face, scheme, seed, o = {}) {
+    const random = rng(`${seed}/skin/${face.n}${face.sign}`);
+    // a lower level of detail plates in bigger cells: a quarter of the detail is a quarter of the plates
+    const k = 1 / Math.sqrt(Math.max(0.2, Math.min(1, o.detail ?? 1)));
+    const [ca, cb] = (o.cell ?? [4, 3]).map((c) => c * k);
+    const raise = o.raise ?? 0.22;
+    const gap = Math.min(0.12, ca * 0.03);
+    const out = [];
+    let b = face.b[0];
+    while (b < face.b[1] - 0.2) {
+        const hb = Math.min(face.b[1] - b, cb * (0.7 + random() * 0.7));
+        // a row has one tone: mostly white, sometimes a worn band, now and then a block colour, so the plating reads in bands
+        const tone = random();
+        const rowMain = tone < 0.04 ? scheme.block : tone < 0.3 ? scheme.worn : scheme.main;
+        let a = face.a[0];
+        while (a < face.a[1] - 0.2) {
+            const wa = Math.min(face.a[1] - a, ca * (0.6 + random() * 0.9));
+            const cA = a + wa / 2;
+            const cB = b + hb / 2;
+            a += wa;
+            if (o.skip?.(cA, cB))
+                continue;
+            const roll = random();
+            if (roll < (o.bare ?? 0.03))
+                continue;
+            const pick = random();
+            if (o.blanket) {
+                // a quilted blanket: one pillow to a cell, white, now and then worn, now and then gold foil, with a thin seam between and no extra plates
+                const m = pick < 0.07 ? "gold" : pick < 0.25 ? scheme.worn : scheme.main;
+                const hh = raise * (0.8 + random() * 0.4);
+                out.push(on(face, cA, cB, wa - gap, hb - gap, 0, hh * 0.6, m), on(face, cA, cB, wa - gap - 0.5, hb - gap - 0.5, hh * 0.6, hh, m), on(face, cA, cB, wa - gap - 1.2, hb - gap - 1.2, hh, hh * 1.25, m));
+                continue;
+            }
+            const material = pick < 0.9 ? rowMain : pick < 0.96 ? scheme.worn : pick < 0.985 ? scheme.main : pick < 0.995 ? scheme.accent : scheme.blockWorn;
+            const h = raise * (0.55 + random() * 0.45);
+            out.push(on(face, cA, cB, wa - gap, hb - gap, 0, h, material));
+            // an access plate or a rivet strip on some panels, so no panel is blank
+            const dress = random();
+            if (dress < 0.34 && wa > 1.2 && hb > 1)
+                out.push(on(face, cA, cB, wa * 0.55, hb * 0.5, h, h + 0.04, material === scheme.main ? scheme.worn : scheme.main), on(face, cA - wa * 0.22, cB, 0.14, hb * 0.5, h + 0.04, h + 0.1, "hull-grey-dark"), on(face, cA + wa * 0.22, cB, 0.14, hb * 0.5, h + 0.04, h + 0.1, "hull-grey-dark"));
+            else if (dress < 0.46 && wa > 1.2)
+                for (const s of [-0.38, -0.13, 0.13, 0.38])
+                    out.push(on(face, cA + wa * s, cB + hb * 0.34, 0.12, 0.12, h, h + 0.07, "hull-grey-dark"));
+            else if (dress < 0.52)
+                out.push(on(face, cA, cB, 0.5, 0.5, h, h + 0.12, "panel-dark"), on(face, cA, cB, 0.32, 0.32, h + 0.12, h + 0.17, "lamp-amber"));
+        }
+        b += hb;
+    }
+    return out;
+}
+/** An access hatch: a frame of four jambs, a door with hinges and a latch, a hazard bar and a lamp. */
+export function hatch(face, a, b, s = 1.6) {
+    return [
+        on(face, a, b + s * 0.56, s * 1.2, s * 0.1, 0, 0.14, "hull-grey-dark"),
+        on(face, a, b - s * 0.56, s * 1.2, s * 0.1, 0, 0.14, "hull-grey-dark"),
+        on(face, a + s * 0.56, b, s * 0.1, s * 1.0, 0, 0.14, "hull-grey-dark"),
+        on(face, a - s * 0.56, b, s * 0.1, s * 1.0, 0, 0.14, "hull-grey-dark"),
+        on(face, a, b, s * 0.98, s * 0.98, 0, 0.08, "hull-grey"),
+        on(face, a - s * 0.5, b + s * 0.3, 0.12, 0.26, 0.08, 0.17, "panel-dark"),
+        on(face, a - s * 0.5, b - s * 0.3, 0.12, 0.26, 0.08, 0.17, "panel-dark"),
+        on(face, a + s * 0.38, b, 0.14, 0.34, 0.08, 0.16, "lamp-amber"),
+        on(face, a, b - s * 0.4, s * 0.8, 0.08, 0.08, 0.1, "hazard"),
+        on(face, a, b + s * 0.4, s * 0.8, 0.08, 0.08, 0.1, "hazard"),
+    ];
+}
+/** A louvred vent: a dark frame with slats. */
+export function vent(face, a, b, wide = 1.6, tall = 1, slats = 6) {
+    const out = [on(face, a, b, wide, tall, 0, 0.1, "panel-dark")];
+    for (let i = 0; i < slats; i++)
+        out.push(on(face, a, b + ((i + 0.5) / slats - 0.5) * (tall - 0.1), wide - 0.12, (tall / slats) * 0.5, 0.1, 0.2, "hull-grey"));
+    return out;
+}
+/** A bundle of pipes along the surface axis `a`, at `b`, held off the face by clamps every few metres. */
+export function conduit(face, b, a0, a1, o) {
+    const random = rng(`${o.seed}/conduit/${b.toFixed(2)}/${a0.toFixed(1)}`);
+    const count = o.count ?? 3;
+    const pr = o.pipe ?? 0.16;
+    const pitch = pr * 2.5;
+    const stand = o.stand ?? 0.3 + pr;
+    const mats = o.materials ?? ["coolant", "hull-white-worn", "copper", "lamp-red", "coolant"];
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const side = b + (i - (count - 1) / 2) * pitch;
+        out.push(rod(mats[Math.floor(random() * mats.length)], pt(face, a0, side, stand), pt(face, a1, side, stand), pr, 8));
+    }
+    const span = (count - 1) * pitch + pr * 3.2;
+    for (let a = a0 + 0.6; a < a1 - 0.2; a += 3 + random() * 1.5)
+        out.push(on(face, a, b, 0.22, span, 0, stand * 1.4, "hull-grey-dark"));
+    // a valve block part of the way along
+    const v = a0 + (a1 - a0) * (0.3 + random() * 0.4);
+    out.push(on(face, v, b, 0.9, span + 0.3, stand * 0.2, stand * 1.9, "hull-grey-dark"), on(face, v, b, 0.5, 0.5, stand * 1.9, stand * 2.3, "lamp-red"));
+    return out;
+}
+/** A handrail along the surface axis `a`, at `b`: posts and a top rail in service yellow. */
+export function rail(face, b, a0, a1, height = 1.1) {
+    // round tubes of twelve sides, posts with a flange at the foot, and a ball at each bend of the end
+    const out = [rod("hull-yellow", pt(face, a0, b, height), pt(face, a1, b, height), 0.06, 12), rod("hull-yellow", pt(face, a0, b, height * 0.55), pt(face, a1, b, height * 0.55), 0.045, 12), rod("hull-yellow", pt(face, a0, b, 0), pt(face, a0, b, height), 0.06, 12), rod("hull-yellow", pt(face, a1, b, 0), pt(face, a1, b, height), 0.06, 12)];
+    for (let a = a0; a <= a1 + 0.01; a += 2.5)
+        out.push(rod("hull-grey-dark", pt(face, a, b, 0), pt(face, a, b, height), 0.05, 12), rod("hull-grey", pt(face, a, b, 0), pt(face, a, b, 0.08), 0.16, 12));
+    return out;
+}
+/** A ladder along `a`: two rails and rungs. */
+export function ladder(face, b, a0, a1, width = 0.6) {
+    // round side rails of twelve sides standing off on stays, round rungs, and a stay with a foot every two metres
+    const out = [rod("hull-yellow", pt(face, a0, b - width / 2, 0.2), pt(face, a1, b - width / 2, 0.2), 0.045, 12), rod("hull-yellow", pt(face, a0, b + width / 2, 0.2), pt(face, a1, b + width / 2, 0.2), 0.045, 12)];
+    for (let a = a0 + 0.25; a < a1; a += 0.32)
+        out.push(rod("hull-yellow", pt(face, a, b - width / 2, 0.2), pt(face, a, b + width / 2, 0.2), 0.03, 10));
+    for (let a = a0 + 0.1; a <= a1; a += 2)
+        for (const s of [-1, 1])
+            out.push(rod("hull-grey-dark", pt(face, a, b + (s * width) / 2, 0), pt(face, a, b + (s * width) / 2, 0.2), 0.035, 8), rod("hull-grey", pt(face, a, b + (s * width) / 2, 0), pt(face, a, b + (s * width) / 2, 0.05), 0.1, 10));
+    return out;
+}
+/** A lamp: a small dome on a stalk. */
+export const lamp = (face, a, b, colour, size = 0.14) => [on(face, a, b, size * 1.8, size * 1.8, 0, size * 0.6, "hull-grey-dark"), on(face, a, b, size * 1.2, size * 1.2, size * 0.6, size * 1.5, colour === "amber" ? "lamp-amber" : colour === "blue" ? "lamp-blue" : "lamp-red")];
+/** A row of bolt heads along `a` at `b`. */
+export function bolts(face, b, a0, a1, pitch = 1, size = 0.12) {
+    const out = [];
+    for (let a = a0; a <= a1 + 0.01; a += pitch)
+        out.push(on(face, a, b, size, size, 0, size * 0.8, "hull-grey-dark"));
+    return out;
+}
+/** A row of windows (dark glass in a frame) along `a` at `b`. */
+export function windows(face, b, a0, a1, n, size = 0.8) {
+    const out = [];
+    for (let i = 0; i < n; i++) {
+        const a = a0 + ((i + 0.5) * (a1 - a0)) / n;
+        out.push(on(face, a, b, size * 1.3, size * 0.9, 0, 0.12, "hull-grey-dark"), on(face, a, b, size, size * 0.62, 0.12, 0.17, i % 5 === 2 ? "lamp-blue" : "glass"));
+    }
+    return out;
+}
+const SEGMENTS = { "0": "abcdef", "1": "bc", "2": "abged", "3": "abgcd", "4": "fgbc", "5": "afgcd", "6": "afgedc", "7": "abc", "8": "abcdefg", "9": "abcdfg" };
+/** Digits in seven bars, our own figures, on a face: `size` is a digit's height. */
+export function stencil(face, text, a, b, size, material = "black") {
+    const out = [];
+    const t = size * 0.12;
+    const w = size * 0.55;
+    text.split("").forEach((ch, i) => {
+        const cx = a + (i - (text.length - 1) / 2) * (w + t * 2);
+        const seg = SEGMENTS[ch] ?? "";
+        const place = (s) => {
+            if (s === "a")
+                return [cx, b + size / 2 - t / 2, w, t];
+            if (s === "g")
+                return [cx, b, w, t];
+            if (s === "d")
+                return [cx, b - size / 2 + t / 2, w, t];
+            if (s === "b")
+                return [cx + w / 2 - t / 2, b + size / 4, t, size / 2];
+            if (s === "c")
+                return [cx + w / 2 - t / 2, b - size / 4, t, size / 2];
+            if (s === "f")
+                return [cx - w / 2 + t / 2, b + size / 4, t, size / 2];
+            if (s === "e")
+                return [cx - w / 2 + t / 2, b - size / 4, t, size / 2];
+            return null;
+        };
+        for (const s of seg) {
+            const p = place(s);
+            if (p)
+                out.push(on(face, p[0], p[1], p[2], p[3], 0.22, 0.27, material));
+        }
+    });
+    return out;
+}
+/** A stripe of hazard blocks along `a` at `b`. */
+export function hazard(face, b, a0, a1, tall = 0.6, block = 0.9) {
+    const out = [];
+    let i = 0;
+    for (let a = a0; a < a1 - 0.01; a += block, i++)
+        out.push(on(face, Math.min(a + block / 2, a1 - 0.05), b, Math.min(block, a1 - a), tall, 0, 0.1, i % 2 ? "black" : "hazard"));
+    return out;
+}
+/** A frame round an opening: four beams standing out of the face. */
+export function frame(face, a, b, da, db, thick, h, material) {
+    return [on(face, a, b + db / 2 + thick / 2, da + thick * 2, thick, 0, h, material), on(face, a, b - db / 2 - thick / 2, da + thick * 2, thick, 0, h, material), on(face, a + da / 2 + thick / 2, b, thick, db, 0, h, material), on(face, a - da / 2 - thick / 2, b, thick, db, 0, h, material)];
+}
+/** A beam from one surface point to another, standing `h` out of the face: a brace, a pipe, a cable. */
+export const strutOn = (face, p, q, w, d, h, material) => beam(material, pt(face, p[0], p[1], h), pt(face, q[0], q[1], h), w, d, { only: "mesh" });
+/** A seeded pick: n of the list's items, in order, that the random numbers choose. */
+export function some(random, items, share) {
+    return items.filter(() => random() < share);
+}