@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.10.0

package/dist/model/fleet/ancestors.js

@@ -0,0 +1,47 @@
+// The real hardware each module of the kit descends from: what a reader can look up. Pure: no imports.
+/**
+ * The real hardware each module descends from, by module id: what a reader can look up. The kit starts from real engineering and goes further where a ship needs it (bolder shapes, new materials, armour, scale,
+ * drives that do not exist yet); each module still looks engineered and has a job.
+ */
+export const ANCESTORS = {
+    "engine-fusion-1": "Space Shuttle main engine and Starship Raptor plumbing (feed lines, injector head, gimbal actuators); NERVA's nozzle; Daedalus' fusion nozzle and field coils",
+    "engine-fusion-3": "Starship Super Heavy's engine cluster and its thrust puck; Saturn V's F-1 cluster; Daedalus' first-stage engine",
+    "engine-fusion-4": "Saturn V first stage's four outer engines and its thrust structure",
+    "engine-fusion-7": "Starship Ship's seven-engine base and Saturn V's thrust structure; NASA Mars transfer vehicle studies' engine clusters",
+    "thruster-pod-s": "Apollo service module's reaction-control quads and the ISS's attitude thrusters",
+    "rcs-ring-m": "Space Shuttle's reaction-control jets and Apollo's RCS quad rings",
+    "tank-cryo-12": "Saturn V S-IVB hydrogen tank, Space Shuttle external tank (ring frames, feed lines) and Starship's tank domes",
+    "tank-cryo-24": "Space Shuttle external tank and Saturn V S-II; NASA Mars transfer vehicle studies' long propellant tanks",
+    "tank-slim-18": "Saturn V S-IVB and Falcon 9 tanks",
+    "tank-header-9": "Starship's header tanks and the Space Shuttle's reserve tanks",
+    "tank-spheres-4": "Apollo service module's spherical helium tanks and Orion's service module pressurant spheres",
+    "container-12": "ISO shipping containers, and the ISS's MPLM and cargo pallets",
+    "container-12-cold": "Refrigerated ISO containers; the ISS's cold stowage freezers",
+    "cargo-bay-4": "Container-ship cell guides and twist-lock castings; the ISS's external logistics carriers and Canadarm rails",
+    "habitat-ring-16": "Von Braun's wheel space station, NASA's Nautilus-X centrifuge and the spin habitats of the Mars transfer vehicle studies",
+    "habitat-ring-30": "Von Braun's wheel space station and the Stanford torus study",
+    "habitat-drum-crew": "ISS Destiny and Harmony nodes, and Skylab's workshop",
+    "habitat-drum-large": "ISS Zvezda and the Mars transfer vehicle studies' habitat modules",
+    "farm-drum": "Skylab's and the ISS's plant growth chambers (Veggie, Advanced Plant Habitat); BIOS-3's grow racks",
+    "common-area-m": "ISS Node 1 Unity and the Cupola",
+    "store-drum-m": "ISS Leonardo, the Multi-Purpose Logistics Module",
+    "lab-m": "ISS Columbus and Kibo laboratories; Skylab's workshop",
+    "dome-observation-m": "The ISS Cupola, the seven-window observation dome with its hinged shutters, and the Space Shuttle's overhead windows",
+    "solarium-m": "The ISS Veggie and Advanced Plant Habitat gardens, the Biosphere 2 glass halls, and the O'Neill cylinder studies' farm and park lands",
+    "eva-lock-m": "ISS Quest airlock and the Space Shuttle's airlock",
+    "pod-survey-m": "Orion's service module payload bay and the ISS's Express racks",
+    "pod-medical-m": "ISS's crew health care system and Apollo's medical kits, in a Skylab-sized pod",
+    "deck-nav-m": "Orion's crew module, the Space Shuttle's flight deck and the ISS Cupola",
+    "comms-array-m": "NASA's Deep Space Network dishes, the TDRS satellites and Orion's high-gain antenna",
+    "mast-sensor-40": "Hubble's and JWST's booms, the ISS's Canadarm2 and a Deep Space Network lattice tower",
+    "reactor-fusion": "NASA's Kilopower and NERVA reactors with their shadow shields, and the Mars transfer vehicle studies' reactor and radiator layout; Daedalus' reactor chamber",
+    "radiator-stowed": "ISS's photovoltaic radiators folded for launch, and the Space Shuttle's payload-bay radiators",
+    "radiator-deployed": "ISS's thermal radiator wings on booms; the Mars transfer vehicle studies' large radiators",
+    "node-two": "ISS Node 2 Harmony and the Common Berthing Mechanism",
+    "node-four": "ISS Node 1 Unity and Node 3 Tranquility, with their berthing ports",
+    "truss-m-12": "ISS Integrated Truss Structure segments",
+    "truss-l-24": "ISS Integrated Truss Structure and the Mars transfer vehicle studies' long truss spine",
+    "adapter-m-l": "Saturn V's instrument unit and Spacecraft-LM adapter, and the Space Shuttle's payload adapters",
+    "adapter-l-m": "Saturn V's interstage and Apollo's Spacecraft-LM adapter",
+    "shield-forward": "Daedalus' beryllium dust shield, Orion's heat shield and Apollo's ablative heat shield; the Mars transfer vehicle studies' shadow shield",
+};

package/dist/model/fleet/collars.d.ts

@@ -0,0 +1,76 @@
+import type { Piece } from "../pieces.ts";
+/**
+ * The four collar classes: S for small craft and service ports, M for the ordinary module spine, L for heavy spines, H for the heaviest.
+ *
+ * @example
+ * ```ts
+ * import type { CollarClass } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const heavy: CollarClass = "L";
+ * console.log(heavy);
+ * ```
+ */
+export type CollarClass = "S" | "M" | "L" | "H";
+/**
+ * What a collar class is, in metres.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS, type CollarSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const medium: CollarSpec = COLLARS.M;
+ * console.log(medium.outer, medium.bore, medium.bolts);
+ * ```
+ */
+export interface CollarSpec {
+    /** Outer diameter of the flange: the diameter of the joint. */
+    outer: number;
+    /** Diameter of the clear port through the middle. */
+    bore: number;
+    /** Bolts on the bolt circle, and latch dogs on the rim. */
+    bolts: number;
+    dogs: number;
+    /** Flange thickness. */
+    thick: number;
+}
+/**
+ * The collar standard: four classes, each twice the one before.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLARS.M.outer, COLLARS.L.bore);
+ * ```
+ */
+export declare const COLLARS: Readonly<Record<CollarClass, CollarSpec>>;
+/**
+ * The collar classes in order of size.
+ *
+ * @example
+ * ```ts
+ * import { COLLAR_CLASSES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLAR_CLASSES.join(" < "));
+ * ```
+ */
+export declare const COLLAR_CLASSES: readonly ["S", "M", "L", "H"];
+/**
+ * Whether two facing collars mate: the same class, and both there.
+ *
+ * @param a The collar on one module's end, or undefined for none.
+ * @param b The collar on the module it meets.
+ * @returns True when both are there and of one class.
+ * @example
+ * ```ts
+ * import { mates } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(mates("L", "L"), mates("L", "M"));
+ * ```
+ */
+export declare const mates: (a: CollarClass | undefined, b: CollarClass | undefined) => boolean;
+/**
+ * One collar's pieces. `y` is the face (the end of the module) and `facing` is +1 for a collar on a module's top (the face looks up) and -1 for one on its bottom. Nothing stands out past `y`:
+ * the flange sits a little back from the face and the bolt heads fill the space to it, so two collars meet face to face.
+ */
+export declare function collar(cls: CollarClass, y: number, facing: 1 | -1): Piece[];

package/dist/model/fleet/collars.js

@@ -0,0 +1,76 @@
+import { annulus, box, boltRing, disc, hoop, post, ringOf, rod, stamp } from "./detail.js";
+/**
+ * The collar standard: four classes, each twice the one before.
+ *
+ * @example
+ * ```ts
+ * import { COLLARS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLARS.M.outer, COLLARS.L.bore);
+ * ```
+ */
+export const COLLARS = {
+    S: { outer: 3, bore: 1.4, bolts: 8, dogs: 4, thick: 0.1 },
+    M: { outer: 6, bore: 3, bolts: 16, dogs: 8, thick: 0.14 },
+    L: { outer: 12, bore: 6, bolts: 24, dogs: 12, thick: 0.24 },
+    H: { outer: 24, bore: 12, bolts: 36, dogs: 18, thick: 0.44 },
+};
+/**
+ * The collar classes in order of size.
+ *
+ * @example
+ * ```ts
+ * import { COLLAR_CLASSES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(COLLAR_CLASSES.join(" < "));
+ * ```
+ */
+export const COLLAR_CLASSES = ["S", "M", "L", "H"];
+/**
+ * Whether two facing collars mate: the same class, and both there.
+ *
+ * @param a The collar on one module's end, or undefined for none.
+ * @param b The collar on the module it meets.
+ * @returns True when both are there and of one class.
+ * @example
+ * ```ts
+ * import { mates } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(mates("L", "L"), mates("L", "M"));
+ * ```
+ */
+export const mates = (a, b) => a !== undefined && a === b;
+/**
+ * One collar's pieces. `y` is the face (the end of the module) and `facing` is +1 for a collar on a module's top (the face looks up) and -1 for one on its bottom. Nothing stands out past `y`:
+ * the flange sits a little back from the face and the bolt heads fill the space to it, so two collars meet face to face.
+ */
+export function collar(cls, y, facing) {
+    const c = COLLARS[cls];
+    const t = c.thick;
+    const R = c.outer / 2;
+    const r = c.bore / 2;
+    const back = (d) => y - facing * d;
+    const lo = Math.min(back(t * 1.5), back(t * 0.5));
+    const out = [annulus("hull-grey", r * 1.12, R, lo, lo + t, 64, { outline: false, body: true })];
+    // the seal: a dark ring round the bore, on the flange's outer face
+    out.push(hoop("black", r * 1.16, back(t * 0.5), t * 0.28, 32, 5));
+    // hazard blocks between the seal and the bolts, on the flange face
+    for (let i = 0; i < c.bolts; i++) {
+        const a0 = (2 * Math.PI * i) / c.bolts;
+        out.push({ kind: "lathe", material: i % 2 ? "black" : "hazard", segs: 3, only: "mesh", profile: [[r * 1.24, back(t * 0.46)], [r * 1.24 + (R - r) * 0.14, back(t * 0.46)]], arc: () => [a0, a0 + (2 * Math.PI) / c.bolts] });
+    }
+    // bolts on the bolt circle
+    out.push(...boltRing(r + (R - r) * 0.62, back(t * 0.5), c.bolts, t * 0.83, facing === -1));
+    // alignment pins, four, between bolts
+    const pin = { kind: "lathe", material: "hull-yellow", segs: 8, only: "mesh", profile: [[t * 0.55, back(t * 0.5)], [t * 0.35, y], [0.001, y]] };
+    out.push(...stamp([pin], ringOf(4, r + (R - r) * 0.34, 0, 45)));
+    // latch dogs on the rim
+    out.push(...stamp([box("panel-dark", [0, lo, R - t], t * 2.6, t * 2.2, t * 1.5)], ringOf(c.dogs, 0, 0)));
+    // the port: a tube down from the bore and a pressure door in it
+    const doorY = back(Math.max(0.6, c.bore * 0.22));
+    out.push(post("hull-grey-dark", [0, 0], r, Math.min(y, doorY), r, Math.max(y, doorY), 24));
+    out.push(disc("hull-grey", [0, 0], r * 0.97, doorY - (facing === 1 ? 0.08 : 0), 0.08, 24));
+    out.push(hoop("hull-grey-dark", r * 0.7, doorY + facing * 0.12, 0.05, 24, 5));
+    out.push(rod("hull-grey", [-r * 0.55, doorY + facing * 0.12, 0], [r * 0.55, doorY + facing * 0.12, 0], 0.05, 6), rod("hull-grey", [0, doorY + facing * 0.12, -r * 0.55], [0, doorY + facing * 0.12, r * 0.55], 0.05, 6));
+    return out;
+}

package/dist/model/fleet/detail.d.ts

@@ -0,0 +1,445 @@
+import type { MaterialName } from "../materials.ts";
+import { type Frame, type Lathe, type Lines, type Piece, type Plate, type Vec3 } from "../pieces.ts";
+/** A seeded random number generator: the same text gives the same numbers, so the same description gives the same bytes. */
+export type Rng = () => number;
+/** @param seed Any text. @returns A function giving numbers from 0 up to (not including) 1, always the same ones for the same seed. */
+export declare function rng(seed: string): Rng;
+type Extra = Partial<Omit<Plate, "kind" | "material" | "frame" | "outline" | "thickness">>;
+type LatheExtra = Partial<Omit<Lathe, "kind" | "material" | "profile">>;
+/** The tangent frame at a point of a cylinder: u along the circle, v up, w outwards. A plate lying in it lies on the surface. */
+export declare function patch(r: number, az: number, y: number): Frame;
+/** The sag of a flat piece `wide` across on a cylinder of radius `r`: how far its edges stand off the surface. */
+export declare const sagOf: (r: number, wide: number) => number;
+/** A raised rectangle lying on a cylinder, `wide` along the circle and `tall` up it, `raise` metres proud of the surface. */
+export declare function panel(material: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number, extra?: Extra): Plate;
+/** A box standing on a plane: centre of its base at `at`, turned `yaw` degrees about Y; `wide` along its u, `deep` along its v, `tall` up. */
+export declare function box(material: MaterialName, at: Vec3, wide: number, deep: number, tall: number, yaw?: number, extra?: Extra): Plate;
+/** A round rod (a prism with `sides` faces) from a to b: a pipe, a boom, a cable, a strut. */
+export declare function rod(material: MaterialName, a: Vec3, b: Vec3, radius: number, sides?: number, extra?: Extra): Plate;
+/** A flat-sided beam from a to b, `wide` by `deep`. */
+export declare function beam(material: MaterialName, a: Vec3, b: Vec3, wide: number, deep: number, extra?: Extra): Plate;
+/** A cone or bowl on any axis, built from a few stacked prisms, `radii` from the `a` end to the `b` end: a dish, a horn, a sensor head. */
+export declare function horn(material: MaterialName, a: Vec3, b: Vec3, radii: readonly number[], sides?: number, extra?: Extra): Plate[];
+/** A vertical lathe, simple: a straight tube or taper at an offset, from y0 to y1. */
+export declare const post: (material: MaterialName, at: readonly [number, number], r0: number, y0: number, r1: number, y1: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A vertical disc (a lid, a plate, a pad) at height y, closed on both faces. */
+export declare const disc: (material: MaterialName, at: readonly [number, number], r: number, y: number, thick: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A ring of rectangular section round the axis: inside radius `r0`, outside `r1`, from y0 to y1. */
+export declare const annulus: (material: MaterialName, r0: number, r1: number, y0: number, y1: number, segs?: number, extra?: LatheExtra) => Lathe;
+/** A round tube bent into a ring (a torus) of major radius `major` and tube radius `minor`, at height y: a cable ring, a field coil, a hoop. */
+export declare function hoop(material: MaterialName, major: number, y: number, minor: number, segs?: number, sides?: number, extra?: LatheExtra): Lathe;
+/** Lines in the drawing only: seams, so the line looks read the same as the mesh. */
+export declare const seams: (weight: Lines["weight"], paths: readonly (readonly Vec3[])[]) => Lines;
+export interface Pose {
+    at: Vec3;
+    /** Degrees about Y, from +Z towards +X. */
+    yaw?: number;
+}
+/** Pieces moved to a pose: turned about Y, then moved. A lathe keeps its axis (vertical): its offset, arc and lean turn with it. Everything the kit draws goes through this, and so does a ship's assembly. */
+export declare function place(pieces: readonly Piece[], pose: Pose): Piece[];
+/** One template put at many poses. The way to repeat bolts, windows, tiles, nozzles, containers: the template is written once and every copy is merged into the part's mesh. */
+export declare const stamp: (template: readonly Piece[], poses: readonly Pose[]) => Piece[];
+/** `count` poses evenly round a circle of radius `r` at height `y`, the first at `start` degrees, each turned to face outwards. */
+export declare function ringOf(count: number, r: number, y: number, start?: number): Pose[];
+/**
+ * A colour scheme: the panel colours of a module. One maker, so every module takes one of a few.
+ *
+ * @example
+ * ```ts
+ * import { LIVERY, type Livery } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const scheme: Livery = LIVERY.science;
+ * console.log(scheme.main, scheme.mainWorn);
+ * ```
+ */
+export interface Livery {
+    /** The main hull colour, its worn twin, a second colour for blocks, its worn twin, an accent, and the dark structural colour. */
+    main: MaterialName;
+    mainWorn: MaterialName;
+    block: MaterialName;
+    blockWorn: MaterialName;
+    accent: MaterialName;
+    dark: MaterialName;
+    /** The colour of the structure under the panels. */
+    under: MaterialName;
+    /** The foil on the hardware that wears it: silver by default, gold kapton for the industrial and foil schemes. */
+    foil?: MaterialName;
+}
+/**
+ * The fleet's liveries. Every one is mostly white thermal blanket, with a few rigid panels in light grey or white, foil on the hardware that wears it, and orange only on small removable access panels (blue on the command scheme): colour is
+ * small and functional, as on the ISS, JWST and Orion's service module.
+ *
+ * @example
+ * ```ts
+ * import { LIVERY } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(LIVERY.industrial.main, LIVERY.command.block);
+ * ```
+ */
+export declare const LIVERY: {
+    readonly industrial: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "kapton";
+    };
+    readonly science: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+    readonly command: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-grey";
+        readonly blockWorn: "hull-grey-dark";
+        readonly accent: "hull-blue";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+    readonly foil: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "kapton";
+        readonly blockWorn: "foil";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "kapton";
+    };
+    readonly transport: {
+        readonly main: "blanket";
+        readonly mainWorn: "blanket-worn";
+        readonly block: "hull-white";
+        readonly blockWorn: "hull-white-worn";
+        readonly accent: "hull-orange";
+        readonly dark: "panel-dark";
+        readonly under: "hull-grey";
+        readonly foil: "foil";
+    };
+};
+/**
+ * The name of a livery in `LIVERY`.
+ *
+ * @example
+ * ```ts
+ * import type { LiveryName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const name: LiveryName = "command";
+ * console.log(name);
+ * ```
+ */
+export type LiveryName = keyof typeof LIVERY;
+export interface PanelOptions {
+    r: number;
+    y0: number;
+    y1: number;
+    /** The part of the circle covered, in radians; left out: all of it. */
+    az?: readonly [number, number];
+    livery: Livery;
+    seed: string;
+    /** Average panel size, metres. */
+    wide?: number;
+    tall?: number;
+    /** Metres standing proud of the hull. */
+    raise?: number;
+    /** The share of cells left bare, so the dark structure shows through. */
+    bare?: number;
+    /** Places to leave bare for hardware that stands on the hull (hatches, vents, ladders, cable channels): the middle's azimuth in radians, its height, and its size in metres along the surface. */
+    clear?: readonly {
+        az: number;
+        y: number;
+        wide: number;
+        tall: number;
+    }[];
+}
+/** Hexagonal bolt heads on a frame's face, as flat hexes standing `lift` metres off it: the rows of fixings on a panel's frame. */
+export declare function bolts(f: Frame, spots: readonly (readonly [number, number])[], size: number, lift: number, material?: MaterialName): Plate[];
+/** A grab handle: two stanchions and a round bar, standing `lift` off a frame's face, `length` long along u, centred at (a, b). */
+export declare function grabHandle(f: Frame, a: number, b: number, length: number, lift: number): Piece[];
+/** A quilted thermal blanket on a cylinder: a raised skin of pillows with a crease where two meet, so light and shadow run across it. */
+export declare function blanketPanel(material: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number): Plate;
+/** A rigid panel with a raised frame round a sunk field, and bolts in the frame's corners (and along it when it is big): plating, an access panel, a louvre. */
+export declare function framedPanel(frame: MaterialName, field: MaterialName, r: number, az: number, y: number, wide: number, tall: number, raise: number, bolted?: boolean): Piece[];
+/**
+ * A window in a hull of radius `r` at azimuth `az` and height `y`: a framed port with a raised frame and bolts, a pane that reflects the sky (and glows when the engines are lit), mullions across it every metre or so and a lit sill strip under it.
+ * Glass reads as glass: a dark reflective pane held in a frame, never a flat coloured slab.
+ */
+export declare function glazing(r: number, az: number, y: number, wide: number, tall: number, raise?: number, pane?: MaterialName): Piece[];
+/**
+ * Crinkled foil on a cylinder: a skin of flat triangles with each corner pushed in or out a little, so every facet takes the light on its own, as the multi-layer insulation of Hubble, JWST and the lunar module does. `cell` is the size of a facet's cell,
+ * `crumple` how far a corner can be pushed.
+ *
+ * @param material `foil` (silver) or `kapton` (gold), or any material.
+ * @param r Radius of the surface under it.
+ * @param y0 Bottom of the band.
+ * @param y1 Top of the band.
+ * @param a0 First azimuth, radians.
+ * @param a1 Last azimuth, radians.
+ * @param seed Any text: the same text gives the same crinkles.
+ * @param cell Size of a facet's cell, metres.
+ * @param crumple How far a corner is pushed in or out, metres.
+ * @returns The pieces: a few plates, each holding a few hundred facets.
+ */
+export declare function foilBand(material: MaterialName, r: number, y0: number, y1: number, a0: number, a1: number, seed: string, cell?: number, crumple?: number): Plate[];
+/**
+ * Plating: rows of panels with a gap between, each a quilted thermal blanket (most of them: the hull reads as white blanket), a rigid panel with a raised frame, bolts and sometimes a grab handle, a patch of crinkled foil, a louvre, or, rarely, a small
+ * orange access panel standing on a blanket. Some are worn, some bare, and a seam line for each row and column is in the drawing. The skin of every hull.
+ */
+export declare function hullPanels(o: PanelOptions): Piece[];
+export interface HatchOptions {
+    r: number;
+    az: number;
+    y: number;
+    /** Side of the square door, metres. */
+    size?: number;
+    /** A round hatch with a handwheel (a pressure door) instead of a square access panel. */
+    round?: boolean;
+}
+/** An access hatch: a raised frame, a door in its own colour with hinges, a latch or a handwheel, a warning stripe and a lamp. */
+export declare function hatch(o: HatchOptions): Piece[];
+export interface ConduitOptions {
+    r: number;
+    az: number;
+    y0: number;
+    y1: number;
+    /** How many pipes run side by side. */
+    count?: number;
+    /** Pipe radius, metres. */
+    pipe?: number;
+    material?: MaterialName;
+    seed: string;
+}
+/** A conduit run up a hull: pipes in a bundle held off the surface by clamps, each leaving the structure through a gland and an elbow at the bottom and going back in at the top, with a flange joint half way. Pipes come in the colours pipes come in: stainless, white, grey and a coloured one. */
+export declare function conduitRun(o: ConduitOptions): Piece[];
+/** A ring of pipe round a hull at height y: a coolant or cable ring, with a clamp and a valve. */
+export declare function pipeRing(material: MaterialName, r: number, y: number, pipe?: number, segs?: number): Piece[];
+/** A cable tray up a hull: a channel with cables lying in it. */
+export declare function cableTray(r: number, az: number, y0: number, y1: number, width?: number, seed?: string): Piece[];
+/** A louvred vent: a frame with slats. */
+export declare function vent(r: number, az: number, y: number, wide?: number, tall?: number, slats?: number): Piece[];
+/** A ladder up a hull: two rails and rungs. */
+export declare function ladder(r: number, az: number, y0: number, y1: number, width?: number): Piece[];
+/** A hazard stripe: alternating blocks of warning yellow and black round a hull between two heights. */
+export declare function hazardBand(r: number, y0: number, y1: number, blocks?: number, az?: readonly [number, number]): Piece[];
+/** Digits in seven bars on a hull: the module's number, in our own simple figures. `size` is the height of a digit in metres. */
+export declare function stencil(digits: string, r: number, az: number, y: number, size: number, material?: MaterialName): Piece[];
+/** A ring of bolt heads (hexagons) on a flat face, at radius `r`, standing from height `y` up (`down` false) or down (`down` true). */
+export declare function boltRing(r: number, y: number, count: number, size: number, down?: boolean, material?: MaterialName): Piece[];
+export interface Lamp {
+    at: Vec3;
+    /** `amber` (work), `blue` (docking), `red` (warning), `port` (the red navigation light), `starboard` (the green one), `strobe` (a white flash) or `flood` (a floodlight's lens). All of them light up with the engines ("Engines: Lit"). */
+    colour: "amber" | "blue" | "red" | "port" | "starboard" | "strobe" | "flood";
+    size?: number;
+}
+/** Lamps: small domes in a bright colour. They glow when the viewer's engines are lit. */
+export declare function lamps(list: readonly Lamp[]): Piece[];
+/** A navigation light on a hull of radius `r` at azimuth `az` (radians) and height `y`: a housing, a stalk and a lens, red (`port`) or green (`starboard`), or a white `strobe`. Lit with the engines. */
+export declare function navLight(colour: "port" | "starboard" | "strobe", r: number, az: number, y: number, size?: number): Piece[];
+/** A floodlight on a hull of radius `r` at azimuth `az` and height `y`, aimed along the hull by `tilt` (radians, up positive): a bracket, a round housing with cooling fins and a bright lens. Lit with the engines. */
+export declare function floodlight(r: number, az: number, y: number, tilt?: number): Piece[];
+/**
+ * How a separation joint is made: how many latch hooks and umbilical plates it has. Set on a ship's place (`separation`) or a module's options.
+ *
+ * @example
+ * ```ts
+ * import { shipPieces, type SeparationOptions } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const joint: SeparationOptions = { latches: 8, umbilicals: 2 };
+ * console.log(shipPieces([{ module: "tank-cryo-12" }, { module: "tank-cryo-12", separation: joint }], { detail: 0.3 }).length > 0);
+ * ```
+ */
+export interface SeparationOptions {
+    /** Latch hooks round the joint (default 12). */
+    latches?: number;
+    /** Umbilical plates (default 4). */
+    umbilicals?: number;
+}
+/**
+ * A separation joint at a module boundary: where a ship is planned to come apart in flight. A split collar ring with a groove between its halves, hooked latches round it, pyrotechnic bolt caps, umbilical plates with their
+ * sockets and strobes, and a hazard stencil along the cut. Place it at the height `y` where two modules meet, on a hull of radius `r` (a collar's outer radius).
+ *
+ * @param r Radius of the joint's ring, metres.
+ * @param y Height of the joint plane.
+ * @param options How many latches and umbilical plates.
+ * @returns The pieces: mesh only, apart from the groove's seam line.
+ */
+export declare function separationJoint(r: number, y: number, options?: SeparationOptions): Piece[];
+export type AntennaKind = "whip" | "dish" | "yagi" | "phased" | "omni" | "horn";
+/** An antenna on a base point, pointing along `dir` (a unit direction; up is [0, 1, 0]): a whip, a dish on a pole, a boom with elements, a phased panel, a ball or a horn. `size` is its length or width in metres. */
+export declare function antenna(kind: AntennaKind, base: Vec3, dir: Vec3, size: number, seed?: string): Piece[];
+export interface RadiatorOptions {
+    /** The wing stands from the hull at radius `r0` and goes out `reach` metres, `height` tall, in the plane of the spine and azimuth `az`. */
+    r0: number;
+    az: number;
+    y: number;
+    reach: number;
+    height: number;
+    seed: string;
+    /** Folded against the hull in a box (stowed), or spread out (deployed). */
+    stowed?: boolean;
+    /** Number of panels. */
+    panels?: number;
+}
+/** A radiator wing, stowed or deployed. Deployed: a boom out from the hull, hinged panels along it with coolant pipes in them and a manifold. Stowed: the same panels folded into a closed box with latches. */
+export declare function radiator(o: RadiatorOptions): Piece[];
+/** A shield or heat-shield dome: tiles in a mosaic on a cone or a dome (`profile` is [radius, y] going up), with a ring of seam line at each step, radial seams, and a band of fixings at the rim. */
+export declare function tileShield(profile: readonly (readonly [number, number])[], seed: string, segs?: number, radial?: number): Piece[];
+export interface GreebleOptions {
+    r: number;
+    y0: number;
+    y1: number;
+    az: readonly [number, number];
+    /** How many in all, before the module's detail level. */
+    count: number;
+    seed: string;
+    livery: Livery;
+}
+/** Small machinery scattered over a patch of hull: junction boxes, valve wheels, sensor posts, pump housings, bollards, in sizes from a hand to a person. */
+export declare function greebles(o: GreebleOptions): Piece[];
+/** A sphere, for the elbow where two pipes meet: round whichever way they run. */
+export declare const ball: (material: MaterialName, at: Vec3, radius: number) => Lathe;
+export type PipeEnd = "flange" | "cap" | "bulkhead" | "valve";
+export interface PipeOptions {
+    /** Sides of the tube: 12 reads as round. */
+    sides?: number;
+    /** A flange every this many metres along a run, and at each end. */
+    flangeEvery?: number;
+    /** A clamp bracket every this many metres. */
+    bracketEvery?: number;
+    /** The way the structure is from the pipe, as a unit vector: brackets stand off the structure on a leg that way. Left out: no legs. */
+    support?: Vec3;
+    /** Material of the flanges and brackets. */
+    fittings?: MaterialName;
+    /** How a run ends, at its first and its last point. A `flange` is bolted to a mating flange on a short stub, a `cap` is a bolted blind flange, a `bulkhead` is a gland where the pipe goes through the structure (a pad, a boot and a bolt circle) and a `valve` is a valve body with its handwheel. Default: both ends flanged. */
+    ends?: readonly [PipeEnd, PipeEnd];
+    /** The radius of a bend, in pipe radii: the corner is rounded to it. 0 gives a sharp corner with a round elbow. Default 3. */
+    bend?: number;
+    /** A colour-coding band round the pipe at each joint: teal for coolant, copper for power. */
+    band?: MaterialName;
+}
+/**
+ * A pipe along a path: a round tube for each straight run, corners rounded to a real bend (a chain of short tubes with a round joint at each, `bend` pipe radii of curve), bolted flange joints at an interval, clamp brackets with stand-off
+ * posts, and a proper end for each run: a flange bolted to a mating flange, a blind cap, a gland through the structure or a valve. Never a bare end, never a square bar: the tube has twelve sides by default.
+ *
+ * @param points The path, in metres: two or more points.
+ * @param radius The pipe's radius.
+ * @param material The pipe's material: `pipe-steel` for stainless, `coolant` for a coolant or feed line, `copper` for a power or coil line.
+ * @param options Sides, spacing of flanges and brackets, the way the structure is, the fittings' material, the ends, the bend and a colour-coding band.
+ * @returns The pieces.
+ */
+export declare function pipeRun(points: readonly Vec3[], radius: number, material: MaterialName, options?: PipeOptions): Piece[];
+/**
+ * An I-beam from a to b: a web between two flanges. `up` is the way the web stands; `height` and `width` are the section's, `t` the plate thickness.
+ *
+ * @param material The beam's material.
+ * @param a The start.
+ * @param b The end.
+ * @param up The direction the web stands, a unit vector not along the beam.
+ * @param height The section's height.
+ * @param width The flange width.
+ * @param t The plate thickness.
+ * @returns Three plates: the web and the two flanges.
+ */
+export declare function iBeam(material: MaterialName, a: Vec3, b: Vec3, up: Vec3, height: number, width: number, t?: number): Plate[];
+/** A channel from a to b: a web with a flange at each edge on one side, the open side towards -`up`'s side axis. */
+export declare function channel(material: MaterialName, a: Vec3, b: Vec3, up: Vec3, height: number, width: number, t?: number): Plate[];
+/** A round strut: a tube with a collar at each end, for a brace. */
+export declare function strut(material: MaterialName, a: Vec3, b: Vec3, radius: number, sides?: number): Plate[];
+/**
+ * An armoured porthole in a hull of radius `r` at azimuth `az` and height `y`: a heavy frame ring with a bolt circle, a thick reflective pane in a retaining lip, and a burn shutter on a hinge arm. `open` swings the shutter back
+ * flat against the hull beside the port (the pane glows when the engines are lit); `closed` shuts it over the pane, with four latch dogs, a handwheel and a hazard stripe for the burn.
+ *
+ * @param r Radius of the hull.
+ * @param az Azimuth, radians.
+ * @param y Height.
+ * @param size Outer radius of the frame in metres (default 0.5).
+ * @param shutter `open` or `closed`.
+ * @returns The pieces.
+ */
+export declare function porthole(r: number, az: number, y: number, size?: number, shutter?: "open" | "closed"): Piece[];
+/**
+ * An armoured observation dome on a base ring at `base` (the middle of the ring, at its foot), a descendant of the ISS Cupola: a base ring with lamps, a reflective glass dome with six meridian ribs, two latitude hoops and an oculus
+ * on top, and six armoured petals that either lie open round the base (`open`, the dome shows its glass and glows when the engines are lit) or close over the glass (`closed`, as in a burn or a storm).
+ *
+ * @param base The middle of the ring's foot, in metres.
+ * @param radius Radius of the dome at its foot.
+ * @param shutters `open` or `closed`.
+ * @returns The pieces.
+ */
+export declare function observationDome(base: Vec3, radius: number, shutters?: "open" | "closed"): Piece[];
+/**
+ * The name of a room in `ROOMS`.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS, type RoomKind } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const kind: RoomKind = "garden";
+ * console.log(ROOMS[kind].name);
+ * ```
+ */
+export type RoomKind = "cabin" | "mess" | "gym" | "garden" | "lounge" | "medical" | "shelter" | "recreation" | "school" | "plaza";
+/**
+ * One room: its id, the name a cutaway labels it with, its job, and its size in metres.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS, type RoomSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const mess: RoomSpec = ROOMS.mess;
+ * console.log(mess.name, mess.size);
+ * ```
+ */
+export interface RoomSpec {
+    id: RoomKind;
+    /** The name a cutaway labels it with. */
+    name: string;
+    /** What it is for, in a line. */
+    job: string;
+    /** Floor size in metres: width, depth, and the height of the room. */
+    size: readonly [number, number, number];
+}
+/**
+ * The rooms people need, named, each with a job and a size in metres: a cabin, a mess, a gym, a garden, an observation lounge, medical, a storm shelter, a recreation room, a school and a plaza. A ship places them in a cutaway
+ * with `room`.
+ *
+ * @example
+ * ```ts
+ * import { ROOMS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.values(ROOMS).map((room) => room.name).join(", "));
+ * ```
+ */
+export declare const ROOMS: Readonly<Record<RoomKind, RoomSpec>>;
+/**
+ * One of the rooms in `ROOMS`, furnished, standing on its floor at the origin (the middle of its floor), ready to `place` in a cutaway. Plain boxes and rods in the fleet's materials: nothing is bare.
+ *
+ * @param kind Which room.
+ * @param seed Any text, so two of the same room differ a little.
+ * @returns The pieces.
+ */
+export declare function room(kind: RoomKind, seed?: string): Piece[];
+/** A box from a range on each axis, any of them the thin one. Mesh only unless `extra` says otherwise. */
+export declare function cub(material: MaterialName, x: readonly [number, number], y: readonly [number, number], z: readonly [number, number], extra?: Extra): Plate;
+/** A prism up the spine: the convex outline in (x, z), standing from y0 to y1. */
+export declare function prism(material: MaterialName, outline: readonly (readonly [number, number])[], y0: number, y1: number, extra?: Extra): Plate;
+/** An octagon-ish outline: half widths `hx`, `hz` with the corners cut `c` metres. */
+export declare const chamfered: (hx: number, hz: number, c: number, cx?: number, cz?: number) => [number, number][];
+/** A flat quad through four points that lie in one plane, with a thickness: for the slopes of a taper. */
+export declare function quad(material: MaterialName, a: Vec3, b: Vec3, c: Vec3, d: Vec3, thickness: number, extra?: Extra): Plate;
+/** A regular polygon (a disc, near enough) facing along Z, at (x, y), standing from z0 to z1. */
+export declare function discZ(material: MaterialName, x: number, y: number, z0: number, z1: number, r: number, sides?: number, extra?: Extra): Plate;
+/** The same facing along X, at (y, z), standing from x0 to x1. */
+export declare function discX(material: MaterialName, y: number, z: number, x0: number, x1: number, r: number, sides?: number, extra?: Extra): Plate;
+export {};