@johnmorrisdotca/uchusen-rockets 0.0.0-stage → 0.1.0

package/dist/fit.js

@@ -0,0 +1,93 @@
+// Does this rocket go together? One description, checked against the parts' records: only the joints and sizes matter, wherever a part came from. Pure, so a form can ask it on every change; the builder
+// asks it first and refuses what does not fit. A rocket labelled as a real version uses only parts true for it; anything else is a custom build and says so.
+import { MODEL_CREDITS } from "./data/credits.js";
+import { partEntry } from "./model/registry.js";
+import { partIdOf, ROCKETS, variantOf } from "./rockets.js";
+const TOLERANCE = 0.1;
+/** The whole height, joint to joint up the stack, and the widest part. */
+function sizeOf(parts) {
+    let y = 0;
+    let top = 0;
+    for (const { part } of parts) {
+        if (part.strapOn) {
+            top = Math.max(top, part.height);
+            continue;
+        }
+        const base = y - (part.joints.bottom?.y ?? 0);
+        top = Math.max(top, base + part.height);
+        y = base + (part.joints.top ? part.joints.top.y : part.height);
+    }
+    return { height: Math.round(top * 1000) / 1000, diameter: Math.max(...parts.map(({ part }) => part.diameter)) };
+}
+export function check(description) {
+    const issues = [];
+    const fail = (code, message) => issues.push({ code, level: "error", message });
+    const done = (variant, parts, custom) => {
+        const ok = !issues.some((issue) => issue.level === "error");
+        const used = new Map();
+        for (const { part } of parts)
+            if (part.painted) {
+                if (!used.has(part.painted.credit))
+                    used.set(part.painted.credit, []);
+                used.get(part.painted.credit).push(part.name);
+            }
+        return {
+            ok,
+            issues,
+            variant,
+            parts,
+            custom,
+            label: custom ? `Custom build, not a vehicle that flew: ${parts.map(({ part }) => part.name).join(" with ")}` : (variant?.name ?? ""),
+            size: ok ? sizeOf(parts) : null,
+            credits: [...used].map(([id, usedFor]) => ({ ...MODEL_CREDITS[id], id, usedFor })),
+        };
+    };
+    if (!Object.hasOwn(ROCKETS, description.rocket)) {
+        fail("unknown-rocket", `There is no rocket "${description.rocket}" to build.`);
+        return done(null, [], false);
+    }
+    const variant = variantOf(description.rocket, description.variant);
+    if (!variant) {
+        fail("unknown-variant", `${ROCKETS[description.rocket].name} has no variant "${description.variant}".`);
+        return done(null, [], false);
+    }
+    const named = description.parts ?? {};
+    for (const slot of Object.keys(named))
+        if (!variant.slots.includes(slot))
+            fail("unknown-slot", `${variant.name} has no slot "${slot}"; it has ${variant.slots.join(" and ")}.`);
+    let custom = false;
+    const parts = [];
+    for (const slot of variant.slots) {
+        const id = Object.hasOwn(named, slot) ? named[slot] : partIdOf(variant.rocket, variant.id, slot);
+        const entry = partEntry(id);
+        if (!entry) {
+            fail("unknown-part", `There is no part "${id}".`);
+            continue;
+        }
+        const home = partEntry(partIdOf(variant.rocket, variant.id, slot));
+        if (home && entry.record.kind !== home.record.kind)
+            fail("wrong-kind", `${entry.record.name} is a ${entry.record.kind}; this slot takes a ${home.record.kind}.`);
+        if (!entry.record.trueTo.includes(variant.id))
+            custom = true;
+        parts.push({ slot, part: entry.record });
+    }
+    // a side booster stands beside the stack, so the joints that must meet are those of the rest
+    const stacked = parts.filter(({ part }) => !part.strapOn);
+    for (let i = 0; i + 1 < stacked.length; i++) {
+        const below = stacked[i].part;
+        const above = stacked[i + 1].part;
+        const top = below.joints.top;
+        const bottom = above.joints.bottom;
+        if (!top || !bottom) {
+            fail("no-joint", `${below.name} and ${above.name} have no joint to meet at.`);
+            continue;
+        }
+        if (top.kind !== bottom.kind)
+            fail("joint-kind", `${below.name} ends in a ${top.kind} joint and ${above.name} starts with a ${bottom.kind} joint.`);
+        if (Math.abs(top.diameter - bottom.diameter) > TOLERANCE)
+            fail("joint-diameter", `${below.name} is ${top.diameter} m across at the joint and ${above.name} is ${bottom.diameter} m.`);
+    }
+    if (custom)
+        issues.push({ code: "custom", level: "note", message: "A part here is not true for this variant, so this is a custom build, not a vehicle that flew." });
+    return done(variant, parts, custom);
+}

package/dist/framing.d.ts

@@ -0,0 +1,32 @@
+export type Vec3 = [number, number, number];
+/** The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long. */
+export declare const FOV_DEG = 24;
+/** The picture's shape. */
+export declare const PICTURE_W = 480;
+export declare const PICTURE_H = 640;
+export declare const VIEW_NAMES: readonly ["three-quarter", "front", "back", "side", "below"];
+export type ViewName = (typeof VIEW_NAMES)[number];
+export declare const DEFAULT_VIEW: ViewName;
+/** An angle to look from: `az` degrees round from the windward side towards +X, `el` degrees above the horizon. Front is the windward, tiled side; back is the steel side. */
+export interface Angle {
+    az: number;
+    el: number;
+}
+export declare const VIEWS: Readonly<Record<ViewName, Angle>>;
+export declare const cleanView: (value: unknown) => ViewName;
+export declare const deg: (d: number) => number;
+/** The unit vector from what is looked at towards the camera. */
+export declare function directionOf({ az, el }: Angle): Vec3;
+export interface Framing {
+    target: Vec3;
+    position: Vec3;
+    distance: number;
+}
+/** The camera's own axes for looking along `direction`, with up as near to +Y as it can be. */
+export declare function axesOf(direction: Vec3): {
+    right: Vec3;
+    up: Vec3;
+    forward: Vec3;
+};
+/** The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`. */
+export declare function frameFor(min: Vec3, max: Vec3, angle: Angle, aspect: number, margin?: number): Framing;

package/dist/framing.js

@@ -0,0 +1,52 @@
+// Where the camera stands. One rule for the drawing and the 3D view, so the drawing turns into the 3D view without a jump. Pure, in metres.
+/** The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long. */
+export const FOV_DEG = 24;
+/** The picture's shape. */
+export const PICTURE_W = 480;
+export const PICTURE_H = 640;
+export const VIEW_NAMES = ["three-quarter", "front", "back", "side", "below"];
+export const DEFAULT_VIEW = "three-quarter";
+export const VIEWS = {
+    "three-quarter": { az: 32, el: 9 },
+    front: { az: 0, el: 3 },
+    back: { az: 180, el: 3 },
+    side: { az: 90, el: 3 },
+    below: { az: 24, el: -70 },
+};
+export const cleanView = (value) => (VIEW_NAMES.includes(value) ? value : DEFAULT_VIEW);
+export const deg = (d) => (d * Math.PI) / 180;
+/** The unit vector from what is looked at towards the camera. */
+export function directionOf({ az, el }) {
+    const c = Math.cos(deg(el));
+    return [c * Math.sin(deg(az)), Math.sin(deg(el)), c * Math.cos(deg(az))];
+}
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const unit = (a) => {
+    const l = Math.hypot(...a) || 1;
+    return [a[0] / l, a[1] / l, a[2] / l];
+};
+/** The camera's own axes for looking along `direction`, with up as near to +Y as it can be. */
+export function axesOf(direction) {
+    const forward = [-direction[0], -direction[1], -direction[2]];
+    const near = Math.abs(forward[1]) > 0.999;
+    const right = unit(cross(forward, near ? [0, 0, -1] : [0, 1, 0]));
+    return { right, up: cross(right, forward), forward };
+}
+/** The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`. */
+export function frameFor(min, max, angle, aspect, margin = 1.08) {
+    const target = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+    const direction = directionOf(angle);
+    const { right, up, forward } = axesOf(direction);
+    const tanV = Math.tan(deg(FOV_DEG) / 2);
+    const tanH = tanV * aspect;
+    let distance = 0;
+    for (const x of [min[0], max[0]])
+        for (const y of [min[1], max[1]])
+            for (const z of [min[2], max[2]]) {
+                const q = [x - target[0], y - target[1], z - target[2]];
+                const depth = dot(q, forward);
+                distance = Math.max(distance, (Math.abs(dot(q, right)) * margin) / tanH - depth, (Math.abs(dot(q, up)) * margin) / tanV - depth);
+            }
+    return { target, distance, position: [target[0] + direction[0] * distance, target[1] + direction[1] * distance, target[2] + direction[2] * distance] };
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { PLANNED_ROCKETS, ROCKETS, partIdOf, SLOT_NAMES, variantOf } from "./rockets.ts";
+export type { PlannedRocket, RocketEntry, RocketStatus } from "./rockets.ts";
+export { blank, figureWords } from "./data/types.ts";
+export type { Disagreement, Figure, Variant, VariantFacts, VariantStatus } from "./data/types.ts";
+export { SOURCES } from "./data/sources.ts";
+export type { Source, SourceId } from "./data/sources.ts";
+export { creditLine, MODEL_CREDITS } from "./data/credits.ts";
+export type { CreditId, ModelCredit } from "./data/credits.ts";
+export type { Joint, PartKind, PartRecord } from "./parts.ts";
+export { PART_ENTRIES, partEntry } from "./model/registry.ts";
+export { check } from "./fit.ts";
+export type { Description, FitCode, FitIssue, FitReport, SlotPart } from "./fit.ts";
+export { axesOf, cleanView, DEFAULT_VIEW, directionOf, FOV_DEG, frameFor, PICTURE_H, PICTURE_W, VIEW_NAMES, VIEWS } from "./framing.ts";
+export type { Angle, Framing, Vec3, ViewName } from "./framing.ts";
+export { cleanLook, DEFAULT_LOOK, LOOK_NAMES, LOOKS } from "./looks.ts";
+export type { Look, LookName } from "./looks.ts";
+export { cleanShow, placesFor, showsOf } from "./layout.ts";
+export type { Place, ShowName } from "./layout.ts";
+export { CROSSFADE_MS, DRAWING_HOLD_MS, REDUCED_FADE_MS, revealDelay } from "./crossfade.ts";
+export { tiltMode, tiltTurn } from "./tilt.ts";
+export type { Reading, TiltMode } from "./tilt.ts";
+export { MATERIALS } from "./model/materials.ts";
+export type { MaterialName, MaterialSpec } from "./model/materials.ts";

package/dist/index.js

@@ -0,0 +1,13 @@
+// The pure core: the rockets and their variants with sourced sizes, the parts and how they fit, the camera rule, the looks and the layout. No three.js, no DOM.
+export { PLANNED_ROCKETS, ROCKETS, partIdOf, SLOT_NAMES, variantOf } from "./rockets.js";
+export { blank, figureWords } from "./data/types.js";
+export { SOURCES } from "./data/sources.js";
+export { creditLine, MODEL_CREDITS } from "./data/credits.js";
+export { PART_ENTRIES, partEntry } from "./model/registry.js";
+export { check } from "./fit.js";
+export { axesOf, cleanView, DEFAULT_VIEW, directionOf, FOV_DEG, frameFor, PICTURE_H, PICTURE_W, VIEW_NAMES, VIEWS } from "./framing.js";
+export { cleanLook, DEFAULT_LOOK, LOOK_NAMES, LOOKS } from "./looks.js";
+export { cleanShow, placesFor, showsOf } from "./layout.js";
+export { CROSSFADE_MS, DRAWING_HOLD_MS, REDUCED_FADE_MS, revealDelay } from "./crossfade.js";
+export { tiltMode, tiltTurn } from "./tilt.js";
+export { MATERIALS } from "./model/materials.js";

package/dist/layout.d.ts

@@ -0,0 +1,17 @@
+import type { Vec3 } from "./framing.ts";
+import type { PartRecord } from "./parts.ts";
+export type ShowName = "together" | "apart" | (string & {});
+/** A part's own width from the axis, for keeping apart parts clear of each other. */
+export type WidthOf = (part: PartRecord) => number;
+export interface Place {
+    slot: string;
+    at: Vec3;
+    shown: boolean;
+}
+/** The first choices of `show`, then one per slot. */
+export declare const showsOf: (slots: readonly string[]) => string[];
+export declare function cleanShow(value: unknown, slots: readonly string[]): string;
+export declare function placesFor(parts: readonly {
+    slot: string;
+    part: PartRecord;
+}[], show: string, widthOf: WidthOf): Place[];

package/dist/layout.js

@@ -0,0 +1,33 @@
+/** Seen square-on to the diagonal the parts take the whole distance; from the front or the side, seven tenths of it. */
+const APART_SPREAD = 1.45;
+/** The first choices of `show`, then one per slot. */
+export const showsOf = (slots) => (slots.length > 1 ? ["together", "apart", ...slots] : [...slots]);
+export function cleanShow(value, slots) {
+    const shows = showsOf(slots);
+    return typeof value === "string" && shows.includes(value) ? value : shows[0];
+}
+export function placesFor(parts, show, widthOf) {
+    if (show === "apart") {
+        const widths = parts.map(({ part }) => widthOf(part));
+        const total = widths.reduce((sum, width) => sum + width * 2, 0) + (parts.length - 1) * 3;
+        let x = -total / 2;
+        // along a diagonal of the ground, so they stand clear of each other from the front, the back and the side alike
+        return parts.map(({ slot }, i) => {
+            const along = (x + widths[i]) * APART_SPREAD;
+            const at = [along * Math.SQRT1_2, 0, -along * Math.SQRT1_2];
+            x += widths[i] * 2 + 3;
+            return { slot, at, shown: true };
+        });
+    }
+    // up the stack, joint to joint; a side booster stands on the ground beside it
+    let y = 0;
+    return parts.map(({ slot, part }) => {
+        const together = show === "together";
+        if (part.strapOn)
+            return { slot, at: [together ? part.strapOn.x : 0, 0, together ? part.strapOn.z : 0], shown: together || show === slot };
+        const base = y - (part.joints.bottom?.y ?? 0);
+        const at = [0, together ? base : 0, 0];
+        y = base + (part.joints.top ? part.joints.top.y : part.height);
+        return { slot, at, shown: together || show === slot };
+    });
+}

package/dist/looks.d.ts

@@ -0,0 +1,25 @@
+export declare const LOOK_NAMES: readonly ["line", "thick", "painted"];
+export type LookName = (typeof LOOK_NAMES)[number];
+export declare const DEFAULT_LOOK: LookName;
+export interface Look {
+    /** The colour of its lines. */
+    line: string;
+    /** Pixels wide in a 3D view: the outline and the lines between. */
+    outlinePx: number;
+    featurePx: number;
+    weldPx: number;
+    /** How much of the weld lines shows. */
+    weldOpacity: number;
+    /** The drawing's strokes, in its units. */
+    outline: number;
+    feature: number;
+    weld: number;
+    /** The drawing's fills, by material group. */
+    fills: Readonly<Record<FillName, readonly [string, string, string]>>;
+    /** The soft light behind the rocket in a drawing. */
+    halo: boolean;
+}
+export type FillName = "hull" | "white" | "tile" | "metal" | "dark" | "bell";
+export declare const LOOKS: Readonly<Record<LookName, Look>>;
+/** A value from outside as a look's name: the default for anything else. */
+export declare const cleanLook: (value: unknown) => LookName;

package/dist/looks.js

@@ -0,0 +1,36 @@
+// The three looks, each one table entry: the line drawing, the thick lines, and the painted rocket. A look changes lines, colours and fills, never a shape. Pure.
+export const LOOK_NAMES = ["line", "thick", "painted"];
+export const DEFAULT_LOOK = "line";
+const NIGHT = {
+    hull: ["#0c1422", "#2a3850", "#0c1422"],
+    white: ["#0e1626", "#33435f", "#0e1626"],
+    tile: ["#05080e", "#101827", "#05080e"],
+    metal: ["#16202f", "#3a475c", "#16202f"],
+    dark: ["#070b12", "#121a28", "#070b12"],
+    bell: ["#0a0f18", "#242f42", "#0a0f18"],
+};
+export const LOOKS = {
+    line: { line: "#8fa1b8", outlinePx: 1.4, featurePx: 1, weldPx: 0.6, weldOpacity: 0.45, outline: 1.2, feature: 0.8, weld: 0.45, fills: NIGHT, halo: true },
+    thick: { line: "#b4c2d4", outlinePx: 3.4, featurePx: 2, weldPx: 0.9, weldOpacity: 0.5, outline: 3.4, feature: 1.7, weld: 0.6, fills: NIGHT, halo: true },
+    painted: {
+        line: "#30343a",
+        outlinePx: 0,
+        featurePx: 1,
+        weldPx: 1,
+        weldOpacity: 0.28,
+        outline: 0.6,
+        feature: 0.5,
+        weld: 0.3,
+        fills: {
+            hull: ["#7f858c", "#e6e9ec", "#8d9399"],
+            white: ["#b9bab5", "#f4f4ef", "#c2c3be"],
+            tile: ["#0b0c0e", "#26282c", "#0b0c0e"],
+            metal: ["#5a5f66", "#a9afb6", "#5a5f66"],
+            dark: ["#111316", "#2a2d31", "#111316"],
+            bell: ["#141518", "#3c3f44", "#141518"],
+        },
+        halo: false,
+    },
+};
+/** A value from outside as a look's name: the default for anything else. */
+export const cleanLook = (value) => (LOOK_NAMES.includes(value) ? value : DEFAULT_LOOK);

package/dist/model/falcon.d.ts

@@ -0,0 +1,48 @@
+import { type Piece } from "./pieces.ts";
+/** A rocket engine from its exit up: bell, dark inside and a body. */
+export declare function merlin(at: readonly [number, number], y: number, exit: number, length: number): Piece[];
+export interface FirstStageDraw {
+    /** With its interstage. */
+    height: number;
+    interstage: number;
+    radius: number;
+    /** "octaweb": eight round one. "grid": three by three, as v1.0. */
+    engines: "octaweb" | "grid";
+    legs: boolean;
+    fins: boolean;
+}
+export interface FalconDraw {
+    first: FirstStageDraw;
+    second: {
+        height: number;
+        joint: number;
+        radius: number;
+        nozzle: number;
+    };
+    fairing: {
+        height: number;
+        radius: number;
+    };
+}
+export declare const FALCON_DRAWS: Readonly<Record<string, FalconDraw>>;
+export declare const falconFirstStage: (id: string) => Piece[];
+export declare const falconSecondStage: (id: string) => Piece[];
+export declare const falconFairing: (id: string) => Piece[];
+export interface DragonDraw {
+    capsule: number;
+    /** How far its heat shield nests into the trunk. */
+    nest: number;
+    trunk: number;
+    baseRadius: number;
+    trunkRadius: number;
+    windows: boolean;
+    wings: boolean;
+    fins: boolean;
+}
+export declare const DRAGON_DRAWS: Readonly<Record<string, DragonDraw>>;
+export declare function capsule(d: DragonDraw): Piece[];
+export declare function trunk(d: DragonDraw): Piece[];
+/** A side booster, with its nose cone in place of an upper stage. */
+export declare function sideBooster(height: number, r: number, side: 1 | -1): Piece[];
+export declare function centreCore(height: number, r: number): Piece[];
+export declare function grasshopper(height: number): Piece[];

package/dist/model/falcon.js

@@ -0,0 +1,206 @@
+// Falcon 9, Falcon Heavy, Dragon and Grasshopper from tables of numbers. Heights and diameters are the sourced figures where there are any. How a part is drawn is not a published figure: Block 5, Dragon 2, Dragon 1, Falcon Heavy
+// and Grasshopper take their proportions from their licensed models at the sourced sizes (see NOTICE.md), and the older Falcons from the sourced totals and the documented differences.
+import { deg } from "../framing.js";
+import { pointOf, radial, strut } from "./pieces.js";
+import { gridFin } from "./starship.js";
+/** A rocket engine from its exit up: bell, dark inside and a body. */
+export function merlin(at, y, exit, length) {
+    const neck = y + length * 0.62;
+    const throat = exit * 0.34;
+    const bell = { kind: "lathe", material: "bell", at, segs: 12, under: true, outline: true, rings: [y], profile: [[exit, y], [exit * 0.82, y + (neck - y) * 0.4], [exit * 0.5, y + (neck - y) * 0.8], [throat, neck]] };
+    const inside = { kind: "lathe", material: "bell-inside", at, segs: 12, under: true, profile: [[throat * 0.8, neck - 0.05], [exit * 0.96, y + 0.01]] };
+    const head = { kind: "lathe", material: "engine-metal", at, segs: 8, under: true, only: "mesh", profile: [[throat, neck], [exit * 0.5, y + length * 0.82], [exit * 0.4, y + length]] };
+    return [bell, inside, head];
+}
+const R = 1.85;
+/** Each part's height is the sourced figure where there is one; the others share out what the sourced whole leaves, so the parts add up to it. */
+const falconOf = (first, interstage, secondHeight, joint, fairing, fairingRadius, engines, legs, fins) => ({
+    first: { height: first, interstage, radius: R, engines, legs, fins },
+    second: { height: secondHeight, joint, radius: R, nozzle: joint * 0.9 },
+    fairing: { height: fairing, radius: fairingRadius },
+});
+export const FALCON_DRAWS = {
+    // 54.9 m in all: 39.6 m of stage. The interstage, second stage and fairing are shared out: thin evidence
+    "v1.0": falconOf(44.5, 4.9, 7, 3, 6.4, 2.6, "grid", false, false),
+    // 68.4 m in all: 41.2 m of stage
+    "v1.1": falconOf(46, 4.8, 13.8, 4.5, 13.1, 2.6, "octaweb", true, false),
+    ft: falconOf(47.7, 6.5, 13.8, 4.8, 13.1, 2.6, "octaweb", true, true),
+    "block-5": falconOf(47.7, 6.5, 13.8, 4.8, 13.1, 2.6, "octaweb", true, true),
+};
+function firstStage(d, withTop) {
+    const { height: H, interstage, radius: r } = d;
+    const tank = H - interstage;
+    const pieces = [];
+    const skirt = 1.2;
+    const hull = { kind: "lathe", material: "white", segs: 48, uv: false, body: true, outline: true, profile: [[r, skirt], [r, tank]], rings: [skirt + 0.02, tank * 0.28, tank * 0.74], welds: [tank * 0.5, tank * 0.62, tank * 0.86] };
+    pieces.push(hull);
+    if (withTop)
+        pieces.push({ kind: "lathe", material: "black", segs: 48, body: true, outline: true, profile: [[r, tank], [r, H]], rings: [tank + 0.02, H - 0.02], welds: [tank + interstage * 0.5] });
+    pieces.push({ kind: "lathe", material: "soot", segs: 36, under: true, profile: [[0, skirt + 0.5], [r - 0.1, skirt + 0.5], [r, skirt]], rings: [skirt + 0.5] });
+    if (d.engines === "grid") {
+        for (let i = -1; i <= 1; i++)
+            for (let j = -1; j <= 1; j++)
+                pieces.push(...merlin([i * 1.05, j * 1.05], 0, 0.42, 2));
+    }
+    else {
+        pieces.push(...merlin([0, 0], 0, 0.46, 2));
+        for (let i = 0; i < 8; i++) {
+            const a = deg(22.5 + i * 45);
+            pieces.push(...merlin([1.32 * Math.sin(a), 1.32 * Math.cos(a)], 0.1, 0.46, 1.9));
+        }
+    }
+    // a raceway up the back
+    pieces.push(strut("black", pointOf(radial(Math.PI), r + 0.06, skirt + 1), pointOf(radial(Math.PI), r + 0.06, tank + 0.5), 0.28, 0.14, { plain: false }));
+    if (d.legs)
+        for (const az of [45, 135, 225, 315]) {
+            const frame = radial(deg(az));
+            pieces.push({ kind: "plate", material: "black", frame, outline: [[r - 0.05, 0.8], [r + 0.5, 0.8], [r + 0.55, 3], [r + 0.15, 10.5], [r - 0.05, 11]], thickness: 1.2 });
+        }
+    if (d.fins)
+        for (const az of [45, 135, 225, 315])
+            pieces.push(...gridFin(az, tank + 0.1, r, r + 1.4, 1.5, 0.3, false));
+    return pieces;
+}
+function secondStage(d) {
+    const { height, joint, radius: r, nozzle } = d;
+    const pieces = [];
+    pieces.push({ kind: "lathe", material: "white", segs: 48, body: true, outline: true, profile: [[r * 0.6, joint - 0.5], [r, joint], [r, height]], rings: [joint + 0.5, height - 0.05], welds: [(joint + height) / 2] });
+    pieces.push({ kind: "lathe", material: "soot", segs: 36, under: true, only: "mesh", profile: [[0, joint - 0.5], [r * 0.6, joint - 0.5]] });
+    pieces.push(...merlin([0, 0], 0, r * 0.62, nozzle * 1.06));
+    return pieces;
+}
+function fairing(d, jointRadius) {
+    const { height: H, radius: r } = d;
+    const profile = [[jointRadius, 0], [r, H * 0.16]];
+    const steps = 10;
+    const start = H * 0.4;
+    for (let i = 0; i <= steps; i++) {
+        const t = 1 - (1 - i / steps) ** 1.7;
+        profile.push([r * Math.sqrt(Math.max(0, 1 - t ** 2.1)), start + (H - start) * t]);
+    }
+    profile[profile.length - 1] = [0.001, H];
+    const seam = (a) => profile.slice(1).map(([rr, y]) => [(rr + 0.01) * Math.sin(a), y, (rr + 0.01) * Math.cos(a)]);
+    return [
+        { kind: "lathe", material: "white", segs: 48, body: true, outline: true, profile, rings: [H * 0.16] },
+        { kind: "lathe", material: "soot", segs: 24, under: true, only: "mesh", profile: [[0, 0], [jointRadius, 0]] },
+        { kind: "lines", weight: "feature", paths: [seam(deg(90)), seam(deg(-90))] },
+    ];
+}
+export const falconFirstStage = (id) => firstStage(FALCON_DRAWS[id].first, true);
+export const falconSecondStage = (id) => secondStage(FALCON_DRAWS[id].second);
+export const falconFairing = (id) => fairing(FALCON_DRAWS[id].fairing, R);
+export const DRAGON_DRAWS = {
+    "dragon-1": { capsule: 3.8, nest: 0, trunk: 2.3, baseRadius: 1.85, trunkRadius: 1.8, windows: false, wings: true, fins: false },
+    // the capsule's 4.5 m includes its heat shield, which nests 0.34 m into the trunk: 3.94 m of trunk and that make the sourced 8.1 m
+    "dragon-2": { capsule: 4.5, nest: 0.342, trunk: 3.94, baseRadius: 2, trunkRadius: 1.92, windows: true, wings: false, fins: true },
+};
+export function capsule(d) {
+    const H = d.capsule;
+    const r = d.baseRadius;
+    const shoulder = H * 0.74;
+    const n = d.nest;
+    const profile = [[r * 0.9, n], [r, n + 0.3], [r * 0.93, n + 0.7], [r * 0.5, shoulder], [r * 0.47, H * 0.84], [r * 0.3, H * 0.95], [0.001, H]];
+    const pieces = [{ kind: "lathe", material: "white", segs: 48, body: true, outline: true, profile, rings: [n + 0.3, shoulder], welds: [H * 0.3] }];
+    pieces.push({ kind: "lathe", material: "soot", segs: 40, under: true, profile: [[0, 0], [r * 0.72, 0], [r * 0.9, n]], rings: [n] });
+    if (d.windows)
+        for (const az of [38, -38, 142, -142]) {
+            const frame = radial(deg(az));
+            pieces.push({ kind: "plate", material: "glass", frame, outline: [[r * 0.76, H * 0.31], [r * 0.73, H * 0.39], [r * 0.64, H * 0.43], [r * 0.6, H * 0.36]], thickness: 0.36 });
+        }
+    return pieces;
+}
+export function trunk(d) {
+    const H = d.trunk;
+    const r = d.trunkRadius;
+    const pieces = [];
+    if (d.fins) {
+        // half of it is solar cells, half white, with four fins at the foot
+        const half = (y) => { void y; return [-Math.PI / 2, Math.PI / 2]; };
+        pieces.push({ kind: "lathe", material: "solar", segs: 40, body: true, profile: [[r, 0], [r, H]], arc: half, rings: [H - 0.02] });
+        pieces.push({ kind: "lathe", material: "white", segs: 40, body: true, profile: [[r, 0], [r, H]], arc: () => [Math.PI / 2, (3 * Math.PI) / 2], rings: [H - 0.02] });
+        for (const az of [45, 135, 225, 315])
+            pieces.push({ kind: "plate", material: "white", frame: radial(deg(az)), outline: [[r - 0.05, 0], [r + 0.6, 0], [r + 0.25, 1.4], [r - 0.05, 1.8]], thickness: 0.12 });
+    }
+    else {
+        pieces.push({ kind: "lathe", material: "white", segs: 40, body: true, outline: true, profile: [[r, 0], [r, H]], rings: [0.02, H - 0.02], welds: [H * 0.5] });
+    }
+    pieces.push({ kind: "lathe", material: "soot", segs: 30, under: true, only: "mesh", profile: [[0, 0.02], [r, 0.02]] });
+    if (d.wings) {
+        for (const side of [1, -1]) {
+            const frame = radial(deg(90 * side), H * 0.5);
+            pieces.push({ kind: "plate", material: "solar", frame, outline: [[r + 0.5, -0.75], [r + 5.8, -0.75], [r + 5.8, 0.75], [r + 0.5, 0.75]], thickness: 0.08, ribs: [1.5, 2.5, 3.5, 4.5].map((u) => [[r + u, -0.75], [r + u, 0.75]]) });
+            pieces.push(strut("gold", pointOf(frame, r - 0.05, 0), pointOf(frame, r + 0.55, 0), 0.14, 0.14));
+        }
+    }
+    return pieces;
+}
+// ---------------------------------------------------------------------------------------------------------------------------------
+// Falcon Heavy
+/** A side booster, with its nose cone in place of an upper stage. */
+export function sideBooster(height, r, side) {
+    const nose = 5.5;
+    const tank = height - nose;
+    const pieces = firstStage({ height: tank, interstage: 0.001, radius: r, engines: "octaweb", legs: true, fins: false }, false);
+    const profile = [[r, tank]];
+    for (let i = 1; i <= 8; i++) {
+        const t = i / 8;
+        profile.push([r * Math.sqrt(Math.max(0, 1 - t ** 1.9)), tank + nose * t]);
+    }
+    profile[profile.length - 1] = [0.001, height];
+    pieces.push({ kind: "lathe", material: "white", segs: 40, body: true, outline: true, profile, rings: [tank + 0.02] });
+    // where it holds the centre core
+    const frame = radial(deg(90 * -side));
+    pieces.push(strut("black", pointOf(frame, r, tank - 1), pointOf(frame, r + 0.5, tank - 1), 0.4, 0.4));
+    for (const az of [0, 180])
+        pieces.push(...gridFin(az + 45, tank - 0.3, r, r + 1.4, 1.5, 0.3, false));
+    return pieces;
+}
+export function centreCore(height, r) {
+    const first = 47.7;
+    const pieces = firstStage({ height: first, interstage: 6.5, radius: r, engines: "octaweb", legs: true, fins: false }, true);
+    const secondTop = height - 13.1;
+    pieces.push({ kind: "lathe", material: "white", segs: 40, body: true, outline: true, profile: [[r, first], [r, secondTop]], rings: [secondTop - 0.02] });
+    const fair = fairing({ height: 13.1, radius: 2.6 }, r);
+    for (const piece of fair) {
+        if (piece.kind === "lathe")
+            pieces.push({ ...piece, profile: piece.profile.map(([a, b]) => [a, b + secondTop]), rings: piece.rings?.map((y) => y + secondTop), under: false, body: true });
+        else if (piece.kind === "lines")
+            pieces.push({ ...piece, paths: piece.paths.map((path) => path.map(([x, y, z]) => [x, y + secondTop, z])) });
+    }
+    return pieces;
+}
+// ---------------------------------------------------------------------------------------------------------------------------------
+// Grasshopper
+export function grasshopper(height) {
+    const hullBottom = height * 0.17;
+    const r = 1.57;
+    const frameTop = hullBottom + 0.2;
+    const pieces = [];
+    const profile = [[r, hullBottom], [r, height - 2.4], [r * 0.7, height - 1], [r * 0.32, height - 0.2], [0.001, height]];
+    pieces.push({ kind: "lathe", material: "white", segs: 40, body: true, outline: true, profile, rings: [height - 2.4, hullBottom + 0.05], welds: [height * 0.4, height * 0.6, height * 0.8] });
+    pieces.push({ kind: "lathe", material: "soot", segs: 30, under: true, only: "mesh", profile: [[0, hullBottom], [r, hullBottom]] });
+    pieces.push(...merlin([0, 0], 1.2, 0.5, 3.2));
+    // the blue frame
+    const low = hullBottom - 2.8;
+    for (const a of [45, 135, 225, 315]) {
+        const f = radial(deg(a));
+        pieces.push(strut("blue", pointOf(f, 2.2, low), pointOf(f, 2.2, frameTop), 0.2, 0.2, { plain: false }));
+        pieces.push(strut("blue", pointOf(f, 2.2, low), pointOf(f, 0.5, low + 1), 0.16, 0.16, { plain: false }));
+        // the leg: from the frame out to a foot, and a strut back up
+        pieces.push(strut("engine-pale", pointOf(f, 2.2, low + 0.5), pointOf(f, 5.3, 0.1), 0.2, 0.2, { plain: false }));
+        pieces.push(strut("engine-pale", pointOf(f, 2.2, frameTop - 0.5), pointOf(f, 5.3, 0.1), 0.14, 0.14, { plain: false }));
+        pieces.push({ kind: "plate", material: "dark", frame: { o: [f.u[0] * 5.3, 0.05, f.u[2] * 5.3], u: f.u, v: f.w, w: [0, 1, 0] }, outline: [[-0.45, -0.45], [0.45, -0.45], [0.45, 0.45], [-0.45, 0.45]], thickness: 0.1, plain: true });
+    }
+    for (let i = 0; i < 4; i++) {
+        const a = (i * 90 + 45) * (Math.PI / 180);
+        const b = ((i + 1) * 90 + 45) * (Math.PI / 180);
+        const p = (ang, y) => [2.2 * Math.sin(ang), y, 2.2 * Math.cos(ang)];
+        for (const y of [low, frameTop])
+            pieces.push(strut("blue", p(a, y), p(b, y), 0.18, 0.18, { plain: false }));
+        pieces.push(strut("blue", p(a, low), p(b, frameTop), 0.12, 0.12, { plain: true }));
+    }
+    // the bottles round the frame
+    for (const a of [0, 90, 180, 270])
+        pieces.push({ kind: "plate", material: "dark", frame: radial(deg(a)), outline: [[2.05, frameTop - 1.6], [2.28, frameTop - 1.6], [2.28, frameTop - 0.5], [2.05, frameTop - 0.5]], thickness: 2.4, plain: false });
+    return pieces;
+}