@johnmorrisdotca/uchusen-rockets 0.2.2 → 0.3.0

package/dist/model/electron.js

@@ -0,0 +1,35 @@
+// Electron from a table of numbers: the whole, the stages, the fairing and the width are sourced. The sea-level Rutherford is 0.25 m across, from its infobox; its length and the ring they stand in are judged from photographs.
+import { engineRing, fairingShell, floor, raceway, skirt, tube } from "./kit.js";
+import { merlin } from "./falcon.js";
+const R = 0.6;
+const FIRST = 12.1;
+const GAP = 18 - 12.1 - 2.4 - 2.5;
+const SECOND = 2.4;
+const FAIRING = 2.5;
+const first = () => [
+    tube("black", R, 0.5, FIRST, { rings: [0.52, FIRST - 0.02], welds: [4, 8] }),
+    floor(R, 0.5),
+    ...merlin([0, 0], 0, 0.125, 0.6),
+    ...engineRing(8, 0.42, 0, 0.125, 0.6),
+    raceway("black", R, 0.8, FIRST - 0.2, 180, 0.1, 0.05),
+];
+const gap = () => [tube("black", R, 0, GAP, { rings: [0.02, GAP - 0.02] }), floor(R, 0)];
+const second = () => [
+    ...skirt("black", R, 0, 0.7),
+    tube("black", R, 0.7, SECOND, { rings: [0.72, SECOND - 0.02] }),
+    floor(R, 0.7),
+    ...merlin([0, 0], 0.02, 0.28, 0.7),
+];
+export const ELECTRON_BUILDS = [
+    {
+        rocket: "electron",
+        variant: "electron",
+        drawnFrom: "This package's code, from the sourced whole, stages, fairing and width; the metre the sources leave over is drawn as an interstage, and the paint is judged from photographs. No licensed model is used, and no name or mark is drawn.",
+        parts: [
+            { slot: "first-stage", kind: "first-stage", name: "First stage, Electron", height: FIRST, diameter: R * 2, top: [FIRST, R * 2], pieces: first },
+            { slot: "adapter", kind: "adapter", name: "Interstage, Electron", height: GAP, diameter: R * 2, bottom: [0, R * 2], top: [GAP, R * 2], pieces: gap },
+            { slot: "second-stage", kind: "second-stage", name: "Second stage, Electron", height: SECOND, diameter: R * 2, bottom: [0, R * 2], top: [SECOND, R * 2], pieces: second },
+            { slot: "fairing", kind: "fairing", name: "Fairing, Electron", height: FAIRING, diameter: R * 2, bottom: [0, R * 2], pieces: () => fairingShell("black", R, FAIRING, 0.9, 1.3) },
+        ],
+    },
+];

package/dist/model/falcon.d.ts

@@ -27,6 +27,8 @@ export interface FalconDraw {
 }
 export declare const FALCON_DRAWS: Readonly<Record<string, FalconDraw>>;
 export declare const falconFirstStage: (id: string) => Piece[];
+/** A first stage with no legs of its own: for one that has landed and has them out. */
+export declare const falconFirstStageBare: (id: string) => Piece[];
 export declare const falconSecondStage: (id: string) => Piece[];
 export declare const falconFairing: (id: string) => Piece[];
 export interface DragonDraw {

package/dist/model/falcon.js

@@ -89,12 +89,16 @@ function fairing(d, jointRadius) {
     ];
 }
 export const falconFirstStage = (id) => firstStage(FALCON_DRAWS[id].first, true);
+/** A first stage with no legs of its own: for one that has landed and has them out. */
+export const falconFirstStageBare = (id) => firstStage({ ...FALCON_DRAWS[id].first, legs: false }, 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 },
+    // the same sizes: its article gives one set for both versions. It has no windows
+    "cargo-dragon-2": { capsule: 4.5, nest: 0.342, trunk: 3.94, baseRadius: 2, trunkRadius: 1.92, windows: false, wings: false, fins: true },
 };
 export function capsule(d) {
     const H = d.capsule;

package/dist/model/falcon1.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const FALCON_1_BUILDS: readonly StackBuild[];

package/dist/model/falcon1.js

@@ -0,0 +1,53 @@
+// Falcon 1 from a table of numbers. The whole and the fairing are sourced; how the rest shares that out is judged from photographs of its fourth flight's vehicle: a white first stage, a black interstage and a white second stage under the fairing.
+import { merlin } from "./falcon.js";
+import { deg } from "../framing.js";
+import { floor, nose, raceway, tube } from "./kit.js";
+import { variantOfFairing } from "../data/falcon1.js";
+const R = 0.85;
+const DRAWS = {
+    // 21.3 m: 15.8 of first stage with its interstage, 2 showing of the second stage, and the sourced 3.5 of fairing
+    "falcon-1": { first: 15.8, interstage: 3.2, second: 4.5, joint: 2.5, fairing: { height: 3.5, radius: 0.77, straight: 1.5, blunt: 1.25 } },
+    // 27.4 m: the 90 feet, with the sourced 4.4 of fairing
+    "falcon-1e": { first: 20.8, interstage: 3.2, second: 4.7, joint: 2.5, fairing: { height: 4.4, radius: 0.85, straight: 1.7, blunt: 1.15 } },
+};
+function firstStage(d) {
+    const tank = d.first - d.interstage;
+    const skirt = 1.7;
+    return [
+        tube("white", R, skirt, tank, { rings: [skirt + 0.02, tank - 0.02], welds: [tank * 0.5, tank * 0.72] }),
+        tube("black", R, tank, d.first, { rings: [d.first - 0.02] }),
+        floor(R, skirt),
+        // the single engine, and the frame that holds it
+        ...merlin([0, 0], 0, 0.42, 2),
+        { kind: "lathe", material: "engine-metal", segs: 16, under: true, only: "mesh", profile: [[R * 0.7, skirt], [R * 0.32, skirt - 0.6]] },
+        // the cable run up its side
+        raceway("white", R, skirt + 0.2, d.first - 0.2, 180, 0.16, 0.08),
+    ];
+}
+function secondStage(d) {
+    return [
+        tube("white", R, d.joint, d.second, { rings: [d.joint + 0.02], welds: [(d.joint + d.second) / 2] }),
+        floor(R, d.joint),
+        ...merlin([0, 0], 0, 0.36, d.joint * 0.95),
+    ];
+}
+function fairing(d) {
+    const shell = nose("white", d.radius, d.straight, d.height, d.blunt);
+    const seam = (a) => shell.profile.map(([r, y]) => [(r + 0.008) * Math.sin(a), y, (r + 0.008) * Math.cos(a)]);
+    return [
+        { ...shell, profile: [[d.radius, 0], ...shell.profile], rings: [d.straight] },
+        floor(d.radius, 0),
+        { kind: "lines", weight: "feature", paths: [seam(deg(90)), seam(deg(-90))] },
+    ];
+}
+const FROM = "This package's code, sized from SpaceX's user's guide; how the stages share out the whole is judged from photographs. No licensed model shows it.";
+export const FALCON_1_BUILDS = Object.entries(DRAWS).map(([variant, d]) => ({
+    rocket: "falcon-1",
+    variant,
+    drawnFrom: variant === "falcon-1" ? FROM : `${FROM} It never flew, so no photograph shows it: Falcon 1's look on the guide's sizes.`,
+    parts: [
+        { slot: "first-stage", kind: "first-stage", name: `First stage, ${variant === "falcon-1" ? "Falcon 1" : "Falcon 1e"}`, height: d.first, diameter: R * 2, top: [d.first, R * 2], pieces: () => firstStage(d) },
+        { slot: "second-stage", kind: "second-stage", name: `Second stage, ${variant === "falcon-1" ? "Falcon 1" : "Falcon 1e"}`, height: d.second, diameter: R * 2, bottom: [d.joint, R * 2], top: [d.second, R * 2], pieces: () => secondStage(d) },
+        { slot: "fairing", kind: "fairing", name: `Fairing, ${variant === "falcon-1" ? "Falcon 1" : "Falcon 1e"}`, height: d.fairing.height, diameter: d.fairing.radius * 2, bottom: [0, R * 2], sourcedDiameter: variantOfFairing(variant), pieces: () => fairing(d.fairing) },
+    ],
+}));

package/dist/model/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const GEMINI_BUILDS: readonly StackBuild[];

package/dist/model/gemini.js

@@ -0,0 +1,28 @@
+// Gemini in plain shapes, for the line looks: its length and width are sourced, and where the adapter ends and the capsule's shape are measured from NASA's model at that scale. The painted look is NASA's model.
+import { GEMINI_WIDE } from "../data/gemini.js";
+import { blank } from "../data/types.js";
+import { floor, taper, tube } from "./kit.js";
+const WHOLE = 5.61;
+const SCALE = WHOLE / 13.67;
+const ADAPTER = (5.95 - 0.14) * SCALE;
+const R = (GEMINI_WIDE.value ?? 0) / 2;
+const NECK = 1.07;
+const adapter = () => [taper("white", R, 0, NECK * 1.12, ADAPTER * 0.55, { rings: [0.02], welds: [ADAPTER * 0.25] }), tube("white", NECK * 1.12, ADAPTER * 0.55, ADAPTER * 0.62), taper("white", NECK * 1.12, ADAPTER * 0.62, NECK, ADAPTER, { rings: [ADAPTER - 0.02] }), floor(R, 0.02)];
+const capsule = () => [
+    taper("black", NECK, 0, 0.42, 1.55, { rings: [0.02, 1.53] }),
+    tube("black", 0.42, 1.55, 2.2, { rings: [1.9] }),
+    taper("black", 0.42, 2.2, 0.36, WHOLE - ADAPTER - 0.25),
+    tube("white", 0.36, WHOLE - ADAPTER - 0.25, WHOLE - ADAPTER),
+];
+const FROM = "NASA's model for the painted look. This package's plain shapes for the two line looks, from the sourced length and width; where the adapter ends is measured from NASA's model. No flag or lettering is drawn.";
+export const GEMINI_BUILDS = [
+    {
+        rocket: "gemini",
+        variant: "gemini",
+        drawnFrom: FROM,
+        parts: [
+            { slot: "adapter", kind: "spacecraft", name: "Adapter, Gemini", height: ADAPTER, diameter: R * 2, sourcedDiameter: GEMINI_WIDE, painted: { file: "gemini-adapter.glb", credit: "nasa-gemini" }, pieces: adapter },
+            { slot: "capsule", kind: "capsule", name: "Reentry module, Gemini", height: WHOLE - ADAPTER, diameter: NECK * 2, place: { x: 0, z: 0, y: ADAPTER }, sourcedDiameter: blank("No source read here gives its size."), painted: { file: "gemini-capsule.glb", credit: "nasa-gemini" }, pieces: capsule },
+        ],
+    },
+];

package/dist/model/hubble.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const HUBBLE_BUILDS: readonly StackBuild[];

package/dist/model/hubble.js

@@ -0,0 +1,28 @@
+// Hubble in plain shapes, for the line looks: its length and width are sourced, and where its arrays and door stand is measured from NASA's model at that scale. The painted look is NASA's model.
+import { HUBBLE_WIDE } from "../data/hubble.js";
+import { tube } from "./kit.js";
+const H = 13.2;
+const R = (HUBBLE_WIDE.value ?? 0) / 2;
+const TUBE_R = R * 0.74;
+const WAIST = 5.1;
+const array = (side) => {
+    const frame = { o: [side * (R + 3.5), WAIST, 0], u: [1, 0, 0], v: [0, 0, 1], w: [0, 1, 0] };
+    return { kind: "plate", material: "gold", frame, outline: [[-1.2, -6.2], [1.2, -6.2], [1.2, 6.2], [-1.2, 6.2]], thickness: 0.06, ribs: [[[-1.2, 0], [1.2, 0]]] };
+};
+const telescope = () => [
+    tube("steel", R, 0, WAIST, { rings: [0.02, 2.2, WAIST - 0.02] }),
+    { kind: "lathe", material: "dark", segs: 28, under: true, profile: [[0, 0], [R, 0]] },
+    tube("steel", TUBE_R, WAIST, H, { rings: [8.4], welds: [10.2] }),
+    { kind: "lathe", material: "soot", segs: 28, under: true, only: "mesh", profile: [[TUBE_R * 0.96, H], [0, H]] },
+    { kind: "plate", material: "engine-pale", frame: { o: [0, H + 0.02, 0], u: [1, 0, 0], v: [0, 0, 1], w: [0, 1, 0] }, outline: [[-TUBE_R, -TUBE_R], [TUBE_R, -TUBE_R], [TUBE_R, TUBE_R], [-TUBE_R, TUBE_R]], thickness: 0.05, plain: true },
+    array(1),
+    array(-1),
+];
+export const HUBBLE_BUILDS = [
+    {
+        rocket: "hubble",
+        variant: "hubble",
+        drawnFrom: "NASA's model for the painted look. This package's plain shapes for the two line looks, from the sourced length and width; its arrays and door are measured from NASA's model. No lettering or mark is drawn.",
+        parts: [{ slot: "telescope", kind: "spacecraft", name: "Hubble Space Telescope", height: H, diameter: R * 2, sourcedDiameter: HUBBLE_WIDE, painted: { file: "hubble-telescope.glb", credit: "nasa-hubble" }, pieces: telescope }],
+    },
+];

package/dist/model/iss.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const ISS_BUILDS: readonly StackBuild[];

package/dist/model/iss.js

@@ -0,0 +1,32 @@
+// The station in plain shapes, for the line looks: its length and truss are sourced, and where its arrays and modules stand is measured from NASA's model at that scale. Boxes and tubes, few enough for a drawing. The painted look is NASA's model.
+import { ISS_DRAWN_TALL, ISS_LONG } from "../data/iss.js";
+import { tube } from "./kit.js";
+import { strut } from "./pieces.js";
+const SPAN = (ISS_LONG.value ?? 0) / 2;
+const TRUSS_Y = 34;
+const TRUSS = 94 / 2;
+const array = (x, y0, y1) => {
+    const frame = { o: [x, 0, 0], u: [1, 0, 0], v: [0, 1, 0], w: [0, 0, 1] };
+    return { kind: "plate", material: "gold", frame, outline: [[-2.4, y0], [2.4, y0], [2.4, y1], [-2.4, y1]], thickness: 0.1 };
+};
+const station = () => {
+    const out = [strut("engine-pale", [-TRUSS, TRUSS_Y, 0], [TRUSS, TRUSS_Y, 0], 1.5, 1.5, { plain: false })];
+    for (const x of [SPAN - 3, SPAN - 17, -(SPAN - 3), -(SPAN - 17)])
+        out.push(array(x, 0, TRUSS_Y - 2), array(x, TRUSS_Y + 2, ISS_DRAWN_TALL));
+    // the long run of modules, and the crossing ones
+    out.push(tube("white", 2.1, 16, 47, { rings: [24, 34, 40] }));
+    for (const [y, half] of [[20, 7], [44, 8]])
+        out.push(strut("white", [-half, y, 0], [half, y, 0], 3.6, 3.6));
+    // radiators
+    for (const side of [1, -1])
+        out.push({ kind: "plate", material: "white", frame: { o: [side * 22, 0, 0], u: [1, 0, 0], v: [0, 1, 0], w: [0, 0, 1] }, outline: [[-6, 18], [6, 18], [6, TRUSS_Y - 1], [-6, TRUSS_Y - 1]], thickness: 0.1 });
+    return out;
+};
+export const ISS_BUILDS = [
+    {
+        rocket: "iss",
+        variant: "iss",
+        drawnFrom: "NASA's model for the painted look, with its colours judged from photographs. This package's plain shapes for the two line looks, from the sourced length and truss; where its arrays and modules stand is measured from NASA's model. No flag or mark is drawn.",
+        parts: [{ slot: "station", kind: "spacecraft", name: "International Space Station", height: ISS_DRAWN_TALL, diameter: SPAN * 2, sourcedDiameter: ISS_LONG, painted: { file: "iss-station.glb", credit: "nasa-iss" }, pieces: station }],
+    },
+];

package/dist/model/jupiterc.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const JUPITER_C_BUILDS: readonly StackBuild[];

package/dist/model/jupiterc.js

@@ -0,0 +1,24 @@
+// Jupiter-C in plain shapes, for the line looks: its height and width are sourced, and its outline is measured from NASA's model at that scale. The painted look is NASA's model.
+import { JUPITER_C_WIDE } from "../data/jupiterc.js";
+import { fins, floor, stripes, taper, tube } from "./kit.js";
+const H = 21.3;
+const R = (JUPITER_C_WIDE.value ?? 0) / 2;
+const vehicle = () => [
+    tube("white", R, 0.42, 3.1, { rings: [0.44, 3.08] }),
+    ...stripes("black", R, 0.42, 3.1, [0, 180], 60),
+    floor(R, 0.42),
+    ...fins("engine-pale", R, [45, 135, 225, 315], [[0, 0.9], [0.5, 0.1], [0.55, 0.9], [0, 2.9]], 0.06),
+    tube("steel", R, 3.1, 14.6, { rings: [9.2], welds: [6, 12] }),
+    taper("steel", R, 14.6, 0.47, 18.2, { rings: [14.62] }),
+    taper("steel", 0.47, 18.2, 0.17, 19.4),
+    tube("engine-pale", 0.17, 19.4, H - 0.4),
+    taper("engine-pale", 0.17, H - 0.4, 0.02, H),
+];
+export const JUPITER_C_BUILDS = [
+    {
+        rocket: "jupiter-c",
+        variant: "jupiter-c",
+        drawnFrom: "NASA's model for the painted look, its lettering removed. This package's plain shapes for the two line looks, from the sourced height and width. No lettering is drawn.",
+        parts: [{ slot: "vehicle", kind: "first-stage", name: "Jupiter-C", height: H, diameter: R * 2, sourcedDiameter: JUPITER_C_WIDE, painted: { file: "jupiter-c-vehicle.glb", credit: "nasa-jupiter-c" }, pieces: vehicle }],
+    },
+];

package/dist/model/kit.d.ts

@@ -0,0 +1,36 @@
+import type { MaterialName } from "./materials.ts";
+import { type Lathe, type Piece, type Plate } from "./pieces.ts";
+type Extra = Partial<Omit<Lathe, "kind" | "material" | "profile">>;
+/** A straight tube from y0 to y1. */
+export declare const tube: (material: MaterialName, r: number, y0: number, y1: number, extra?: Extra) => Lathe;
+/** A cone or a step between two radii. */
+export declare const taper: (material: MaterialName, r0: number, y0: number, r1: number, y1: number, extra?: Extra) => Lathe;
+/** A rounded nose from a radius at y0 to a point at y1. `blunt` above 1 is fuller at the shoulder, below 1 is sharper. */
+export declare function nose(material: MaterialName, r: number, y0: number, y1: number, blunt?: number, extra?: Extra): Lathe;
+/** A flat dark floor closing a tube from below. */
+export declare const floor: (r: number, y: number, material?: MaterialName) => Lathe;
+/** Stripes down a hull: `width` degrees wide, each centred on one of `azimuths`, just proud of it. */
+export declare const stripes: (material: MaterialName, r: number, y0: number, y1: number, azimuths: readonly number[], width: number) => Lathe[];
+/** Engines in a ring, the first at `start` degrees. */
+export declare function engineRing(count: number, ringRadius: number, y: number, exit: number, length: number, start?: number): Piece[];
+/** A long box up the side of a hull at `az` degrees: a raceway or a cable tunnel. */
+export declare const raceway: (material: MaterialName, r: number, y0: number, y1: number, az: number, width?: number, depth?: number) => Plate;
+/** Fins on a hull, each a flat outline given as [out from the hull, y] points. */
+export declare const fins: (material: MaterialName, r: number, azimuths: readonly number[], outline: readonly (readonly [number, number])[], thickness?: number) => Plate[];
+/** A straight strut between two points given in cylinder terms: [radius, y, azimuth in degrees]. */
+export declare function brace(material: MaterialName, a: readonly [number, number, number], b: readonly [number, number, number], width?: number): Plate;
+/** An open skirt: a tube seen from outside and from inside, so an engine under it shows from below. */
+export declare const skirt: (material: MaterialName, r: number, y0: number, y1: number, extra?: Extra) => Piece[];
+/** A cone over an engine, off the axis: a fairing at the foot of a stage. */
+export declare const pod: (material: MaterialName, at: readonly [number, number], r0: number, y0: number, r1: number, y1: number, extra?: Extra) => Lathe;
+/** A fairing: straight from the joint, then a rounded nose, with the seam where its halves meet. */
+export declare function fairingShell(material: MaterialName, r: number, height: number, straight: number, blunt?: number, jointRadius?: number): Piece[];
+/** Legs folded against a hull, as dark ribs from the foot up. */
+export declare const foldedLegs: (material: MaterialName, r: number, azimuths: readonly number[], foot: number, top: number, width: number) => Plate[];
+/** Pieces turned round the Y axis by `turn` degrees, then moved along the ground. For putting a whole structure in its place on a map. A lathe's arc and lean are left as they are, so they are for pieces with neither. */
+export declare function moved(pieces: readonly Piece[], x: number, z: number, turn?: number): Piece[];
+/** A box on the ground, `wide` by `deep` and turned `turn` degrees, from y0 to y1. */
+export declare function slab(material: MaterialName, x: number, z: number, wide: number, deep: number, turn: number, y0: number, y1: number, plain?: boolean): Plate;
+/** A road on the ground, from point to point. */
+export declare const road: (material: MaterialName, points: readonly (readonly [number, number])[], width: number, y: number) => Plate[];
+export {};

package/dist/model/kit.js

@@ -0,0 +1,95 @@
+// The small shapes a rocket is put together from, so a new rocket is a table of numbers. Each returns plain pieces: the mesh and the drawing are made from them as for any other part. Pure.
+import { deg } from "../framing.js";
+import { merlin } from "./falcon.js";
+import { pointOf, radial, strut } from "./pieces.js";
+/** A straight tube from y0 to y1. */
+export const tube = (material, r, y0, y1, extra = {}) => ({ kind: "lathe", material, segs: 40, body: true, outline: true, profile: [[r, y0], [r, y1]], ...extra });
+/** A cone or a step between two radii. */
+export const taper = (material, r0, y0, r1, y1, extra = {}) => ({ kind: "lathe", material, segs: 40, body: true, outline: true, profile: [[r0, y0], [r1, y1]], ...extra });
+/** A rounded nose from a radius at y0 to a point at y1. `blunt` above 1 is fuller at the shoulder, below 1 is sharper. */
+export function nose(material, r, y0, y1, blunt = 1.7, extra = {}) {
+    const steps = 10;
+    const profile = [];
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+        profile.push([r * Math.sqrt(Math.max(0, 1 - t ** (2 * blunt))), y0 + (y1 - y0) * t]);
+    }
+    profile[steps] = [0.001, y1];
+    return { kind: "lathe", material, segs: 40, body: true, outline: true, profile, ...extra };
+}
+/** A flat dark floor closing a tube from below. */
+export const floor = (r, y, material = "soot") => ({ kind: "lathe", material, segs: 32, under: true, profile: [[0, y], [r, y]] });
+/** Stripes down a hull: `width` degrees wide, each centred on one of `azimuths`, just proud of it. */
+export const stripes = (material, r, y0, y1, azimuths, width) => azimuths.map((az) => ({ kind: "lathe", material, segs: 72, body: true, profile: [[r * 1.012, y0], [r * 1.012, y1]], arc: () => [deg(az - width / 2), deg(az + width / 2)] }));
+/** Engines in a ring, the first at `start` degrees. */
+export function engineRing(count, ringRadius, y, exit, length, start = 0) {
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const a = deg(start + (i * 360) / count);
+        out.push(...merlin([ringRadius * Math.sin(a), ringRadius * Math.cos(a)], y, exit, length));
+    }
+    return out;
+}
+/** A long box up the side of a hull at `az` degrees: a raceway or a cable tunnel. */
+export const raceway = (material, r, y0, y1, az, width = 0.2, depth = 0.1) => {
+    const f = radial(deg(az));
+    return strut(material, pointOf(f, r + depth / 2, y0), pointOf(f, r + depth / 2, y1), width, depth, { plain: false });
+};
+/** Fins on a hull, each a flat outline given as [out from the hull, y] points. */
+export const fins = (material, r, azimuths, outline, thickness = 0.1) => azimuths.map((az) => ({ kind: "plate", material, frame: radial(deg(az)), outline: outline.map(([out, y]) => [r + out, y]), thickness }));
+/** A straight strut between two points given in cylinder terms: [radius, y, azimuth in degrees]. */
+export function brace(material, a, b, width = 0.1) {
+    const at = ([r, y, az]) => [r * Math.sin(deg(az)), y, r * Math.cos(deg(az))];
+    return strut(material, at(a), at(b), width, width);
+}
+/** An open skirt: a tube seen from outside and from inside, so an engine under it shows from below. */
+export const skirt = (material, r, y0, y1, extra = {}) => [tube(material, r, y0, y1, extra), { kind: "lathe", material: "soot", segs: 32, under: true, only: "mesh", profile: [[r * 0.97, y1], [r * 0.97, y0]] }];
+/** A cone over an engine, off the axis: a fairing at the foot of a stage. */
+export const pod = (material, at, r0, y0, r1, y1, extra = {}) => ({ kind: "lathe", material, at, segs: 14, profile: [[r0, y0], [r1, y1]], ...extra });
+/** A fairing: straight from the joint, then a rounded nose, with the seam where its halves meet. */
+export function fairingShell(material, r, height, straight, blunt = 1.4, jointRadius = r) {
+    const shell = nose(material, r, straight, height, blunt);
+    const seam = (a) => shell.profile.map(([x, y]) => [(x * 1.005) * Math.sin(a), y, (x * 1.005) * Math.cos(a)]);
+    return [
+        { ...shell, profile: [[jointRadius, 0], ...shell.profile], rings: [straight] },
+        floor(jointRadius, 0),
+        { kind: "lines", weight: "feature", paths: [seam(deg(90)), seam(deg(-90))] },
+    ];
+}
+/** Legs folded against a hull, as dark ribs from the foot up. */
+export const foldedLegs = (material, r, azimuths, foot, top, width) => azimuths.map((az) => {
+    const f = radial(deg(az));
+    return strut(material, pointOf(f, r + 0.1, foot), pointOf(f, r + 0.1, top), width, 0.3, { plain: false });
+});
+/** Pieces turned round the Y axis by `turn` degrees, then moved along the ground. For putting a whole structure in its place on a map. A lathe's arc and lean are left as they are, so they are for pieces with neither. */
+export function moved(pieces, x, z, turn = 0) {
+    const c = Math.cos(deg(turn));
+    const s = Math.sin(deg(turn));
+    const spin = ([a, b, d]) => [a * c + d * s, b, -a * s + d * c];
+    const at = (p) => {
+        const [a, b, d] = spin(p);
+        return [a + x, b, d + z];
+    };
+    return pieces.map((piece) => {
+        if (piece.kind === "plate")
+            return { ...piece, frame: { o: at(piece.frame.o), u: spin(piece.frame.u), v: spin(piece.frame.v), w: spin(piece.frame.w) } };
+        if (piece.kind === "lines")
+            return { ...piece, paths: piece.paths.map((path) => path.map(at)) };
+        const [a0, d0] = piece.at ?? [0, 0];
+        const [a, , d] = at([a0, 0, d0]);
+        return { ...piece, at: [a, d] };
+    });
+}
+/** A box on the ground, `wide` by `deep` and turned `turn` degrees, from y0 to y1. */
+export function slab(material, x, z, wide, deep, turn, y0, y1, plain = true) {
+    const c = Math.cos(deg(turn));
+    const s = Math.sin(deg(turn));
+    return { kind: "plate", material, frame: { o: [x, (y0 + y1) / 2, z], u: [c, 0, s], v: [-s, 0, c], w: [0, 1, 0] }, outline: [[-wide / 2, -deep / 2], [wide / 2, -deep / 2], [wide / 2, deep / 2], [-wide / 2, deep / 2]], thickness: y1 - y0, plain };
+}
+/** A road on the ground, from point to point. */
+export const road = (material, points, width, y) => points.slice(1).map((b, i) => {
+    const a = points[i];
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    return slab(material, (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, Math.hypot(dx, dz) + width, width, (Math.atan2(dz, dx) * 180) / Math.PI, y, y + 0.2);
+});

package/dist/model/landing.d.ts

@@ -0,0 +1,3 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const DRONESHIP_BUILDS: readonly StackBuild[];
+export declare const LANDING_ZONE_BUILDS: readonly StackBuild[];

package/dist/model/landing.js

@@ -0,0 +1,81 @@
+// A drone ship's deck, a landing pad, and a Falcon 9 first stage standing on them with its legs out. The deck's and the pad's sizes are sourced where the data says so; hull, equipment and legs are judged from photographs.
+import { blank } from "../data/types.js";
+import { deg } from "../framing.js";
+import { falconFirstStageBare, FALCON_DRAWS } from "./falcon.js";
+import { brace } from "./kit.js";
+const DECK_L = 91.44;
+const DECK_W = 51.82;
+const HULL_L = DECK_L * 1.18;
+const HULL_W = 30.5;
+const HULL_H = 6;
+const DECK_T = 0.8;
+const DECK_TOP = HULL_H + DECK_T;
+const PAD_R = 85.95 / 2;
+const PAD_T = 0.4;
+const FOOT = 9;
+const LEG_TOP = 10.5;
+const FLAT = (y) => ({ o: [0, y, 0], u: [1, 0, 0], v: [0, 0, 1], w: [0, 1, 0] });
+const box = (material, x0, x1, z0, z1, y0, y1, plain = true) => ({ kind: "plate", material, frame: FLAT((y0 + y1) / 2), outline: [[x0, z0], [x1, z0], [x1, z1], [x0, z1]], thickness: y1 - y0, plain });
+const disc = (material, r, r0, y) => ({ kind: "lathe", material, segs: 72, body: true, profile: [[r, y], [r0, y]] });
+function deck() {
+    const L = DECK_L / 2;
+    const W = DECK_W / 2;
+    const hull = HULL_L / 2;
+    const h = HULL_W / 2;
+    const out = [
+        box("dark", -hull, hull, -h, h, 0, HULL_H, false),
+        { ...box("fin", -L, L, -W, W, HULL_H, DECK_TOP, false), plain: false },
+        // the plain ring: no mark, no name
+        disc("white", 23, 21.8, DECK_TOP + 0.03),
+        // the deck's yellow edge
+        box("yellow", -L, L, W - 0.5, W, DECK_TOP, DECK_TOP + 0.05),
+        box("yellow", -L, L, -W, -W + 0.5, DECK_TOP, DECK_TOP + 0.05),
+    ];
+    // equipment at each end, on the hull; thrusters at the corners
+    for (const side of [1, -1]) {
+        const a = side * (L + 0.6);
+        const b = side * (hull - 0.6);
+        const [lo, hi] = a < b ? [a, b] : [b, a];
+        out.push(box("white", lo, hi, -h + 1, -h + 4, HULL_H, HULL_H + 3));
+        out.push(box("gold", lo, hi, -h + 5, -h + 8, HULL_H, HULL_H + 2.6));
+        out.push(box("white", lo, hi, h - 8, h - 5, HULL_H, HULL_H + 2.6));
+        out.push(box("blue", lo, hi, h - 4, h - 1, HULL_H, HULL_H + 3));
+        for (const z of [1, -1])
+            out.push(box("black", side * L - 3, side * L + 3, z * (h + 0.1), z * (h + 3.2), 1, HULL_H - 0.6));
+    }
+    return out;
+}
+function pad() {
+    return [
+        { kind: "lathe", material: "concrete", segs: 72, body: true, outline: true, profile: [[PAD_R, 0], [PAD_R, PAD_T], [0.001, PAD_T]], rings: [PAD_T] },
+        disc("white", PAD_R * 0.62, PAD_R * 0.6, PAD_T + 0.03),
+    ];
+}
+function landed() {
+    const r = FALCON_DRAWS["block-5"].first.radius;
+    const out = falconFirstStageBare("block-5");
+    for (const az of [45, 135, 225, 315]) {
+        // a leg down from its hinge, a pusher from high on the hull, and a foot
+        out.push(brace("black", [r, 1, az], [FOOT, 0.4, az], 0.55));
+        out.push(brace("black", [r + 0.05, LEG_TOP, az], [FOOT, 0.5, az], 0.28));
+        const a = deg(az);
+        out.push(box("dark", FOOT * Math.sin(a) - 0.7, FOOT * Math.sin(a) + 0.7, FOOT * Math.cos(a) - 0.7, FOOT * Math.cos(a) + 0.7, 0, 0.2));
+    }
+    return out;
+}
+const LANDED_NAME = "First stage, Falcon 9 Block 5, landed with its legs out";
+const NONE = blank("No source read here gives it.");
+const standing = (y) => ({ slot: "landed", kind: "first-stage", name: LANDED_NAME, height: FALCON_DRAWS["block-5"].first.height, diameter: FOOT * 2, place: { x: 0, z: 0, y }, sourcedDiameter: NONE, pieces: landed });
+const SHIP_FROM = "This package's code. Its deck's size is the first barge's, in its article; hull, equipment and legs are judged from photographs. No name, mark or logo is drawn.";
+export const DRONESHIP_BUILDS = ["ocisly", "jrti", "asog"].map((variant) => ({
+    rocket: "droneship",
+    variant,
+    drawnFrom: SHIP_FROM,
+    parts: [{ slot: "deck", kind: "deck", name: "Deck and hull", height: DECK_TOP, diameter: DECK_L, sourcedDiameter: NONE, pieces: deck }, standing(DECK_TOP)],
+}));
+export const LANDING_ZONE_BUILDS = ["lz-1", "lz-4"].map((variant) => ({
+    rocket: "landing-zone",
+    variant,
+    drawnFrom: "This package's code, a plain round pad at the size the source gives for the Cape's; the stage's legs are judged from photographs. No mark is drawn.",
+    parts: [{ slot: "pad", kind: "deck", name: "Landing pad", height: PAD_T, diameter: PAD_R * 2, ...(variant === "lz-4" ? { sourcedDiameter: NONE } : {}), pieces: pad }, standing(PAD_T)],
+}));

package/dist/model/lunarmodule.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const LUNAR_MODULE_BUILDS: readonly StackBuild[];

package/dist/model/lunarmodule.js

@@ -0,0 +1,43 @@
+// The lunar module in plain shapes, for the line looks: its height and widths are sourced, and where its legs and tanks stand is measured from NASA's model at that scale. The painted look is NASA's model.
+import { LM_ASCENT_WIDTH, LM_WIDTH } from "../data/lunarmodule.js";
+import { deg } from "../framing.js";
+import { merlin } from "./falcon.js";
+import { brace, taper, tube } from "./kit.js";
+const WHOLE = 7.04;
+const SCALE = WHOLE / 5.02;
+const DESCENT = 3.96;
+const ASCENT_AT = (2.1 - 0.1) * SCALE;
+const R = 4.22 / 2;
+function descent() {
+    const out = [tube("gold", R, 1.36, 3.25, { segs: 8, rings: [1.38, 3.23] }), { kind: "lathe", material: "soot", segs: 8, under: true, profile: [[0, 1.36], [R, 1.36]] }, ...merlin([0, 0], 0.45, 0.75, 1)];
+    for (const az of [0, 90, 180, 270]) {
+        out.push(brace("gold", [4.2, 0.35, az], [2.1, 2.9, az], 0.14), brace("engine-pale", [3, 1.3, az], [2.1, 1.45, az + 28], 0.07), brace("engine-pale", [3, 1.3, az], [2.1, 1.45, az - 28], 0.07));
+        out.push({ kind: "lathe", material: "gold", at: [4.3 * Math.sin(deg(az)), 4.3 * Math.cos(deg(az))], segs: 12, outline: true, profile: [[0.001, 0], [0.42, 0.04], [0.42, 0.1], [0.001, 0.28]] });
+    }
+    for (const az of [45, 135, 225, 315])
+        out.push(brace("engine-pale", [1.9, 3.25, az], [1.9, DESCENT, az], 0.1));
+    return out;
+}
+function ascent() {
+    const r = (LM_ASCENT_WIDTH.value ?? 0) / 2;
+    const out = [tube("engine-pale", r * 0.92, 0.7, 2.9, { segs: 8, rings: [0.72] }), taper("engine-pale", r * 0.92, 2.9, r * 0.55, 3.35, { segs: 8 }), { kind: "lathe", material: "dark", segs: 8, under: true, profile: [[0, 0.7], [r * 0.92, 0.7]] }];
+    for (const az of [45, 135, 225, 315]) {
+        const a = deg(az);
+        out.push({ kind: "lathe", material: "gold", at: [r * 1.05 * Math.sin(a), r * 1.05 * Math.cos(a)], segs: 8, profile: [[0.08, 1.8], [0.08, 2.25]] });
+    }
+    // the dish and its mast
+    out.push({ kind: "lathe", material: "white", at: [0, -0.6], segs: 14, outline: true, profile: [[0.001, 3.55], [0.45, 3.9], [0.48, 4]] }, brace("engine-pale", [0.6, 3.2, 180], [0.6, 3.6, 180], 0.06), brace("engine-pale", [0.9, 3.2, 90], [0.9, 4.2, 90], 0.03));
+    return out;
+}
+const FROM = "NASA's model for the painted look. This package's plain shapes for the two line looks, from the sourced height and widths; where its parts stand is measured from NASA's model.";
+export const LUNAR_MODULE_BUILDS = [
+    {
+        rocket: "lunar-module",
+        variant: "lunar-module",
+        drawnFrom: FROM,
+        parts: [
+            { slot: "descent", kind: "spacecraft", name: "Descent stage, Apollo lunar module", height: DESCENT, diameter: LM_WIDTH.value ?? 0, sourcedDiameter: LM_WIDTH, painted: { file: "lunar-module-descent.glb", credit: "nasa-lunar-module" }, pieces: descent },
+            { slot: "ascent", kind: "spacecraft", name: "Ascent stage, Apollo lunar module", height: WHOLE - ASCENT_AT, diameter: LM_ASCENT_WIDTH.value ?? 0, place: { x: 0, z: 0, y: ASCENT_AT }, sourcedDiameter: LM_ASCENT_WIDTH, painted: { file: "lunar-module-ascent.glb", credit: "nasa-lunar-module" }, pieces: ascent },
+        ],
+    },
+];

package/dist/model/materials.d.ts

@@ -109,5 +109,47 @@ export declare const MATERIALS: {
         readonly rough: 0.5;
         readonly fill: "metal";
     };
+    readonly foam: {
+        readonly color: "#a9592a";
+        readonly metal: 0;
+        readonly rough: 0.8;
+        readonly fill: "foam";
+    };
+    readonly yellow: {
+        readonly color: "#c9a227";
+        readonly metal: 0.1;
+        readonly rough: 0.6;
+        readonly fill: "metal";
+    };
+    readonly concrete: {
+        readonly color: "#8b8d8a";
+        readonly metal: 0;
+        readonly rough: 0.9;
+        readonly fill: "metal";
+    };
+    readonly ground: {
+        readonly color: "#4d5a41";
+        readonly metal: 0;
+        readonly rough: 1;
+        readonly fill: "dark";
+    };
+    readonly sand: {
+        readonly color: "#c3b58c";
+        readonly metal: 0;
+        readonly rough: 1;
+        readonly fill: "white";
+    };
+    readonly water: {
+        readonly color: "#27475e";
+        readonly metal: 0.1;
+        readonly rough: 0.4;
+        readonly fill: "dark";
+    };
+    readonly red: {
+        readonly color: "#a4322b";
+        readonly metal: 0.1;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
 };
 export type MaterialName = keyof typeof MATERIALS;

package/dist/model/materials.js

@@ -16,4 +16,11 @@ export const MATERIALS = {
     solar: { color: "#10163a", metal: 0.4, rough: 0.22, fill: "dark" },
     glass: { color: "#141c26", metal: 0.1, rough: 0.08, fill: "dark" },
     blue: { color: "#1d4f96", metal: 0.25, rough: 0.5, fill: "metal" },
+    foam: { color: "#a9592a", metal: 0, rough: 0.8, fill: "foam" },
+    yellow: { color: "#c9a227", metal: 0.1, rough: 0.6, fill: "metal" },
+    concrete: { color: "#8b8d8a", metal: 0, rough: 0.9, fill: "metal" },
+    ground: { color: "#4d5a41", metal: 0, rough: 1, fill: "dark" },
+    sand: { color: "#c3b58c", metal: 0, rough: 1, fill: "white" },
+    water: { color: "#27475e", metal: 0.1, rough: 0.4, fill: "dark" },
+    red: { color: "#a4322b", metal: 0.1, rough: 0.5, fill: "metal" },
 };

package/dist/model/mercury.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const MERCURY_BUILDS: readonly StackBuild[];

package/dist/model/mercury.js

@@ -0,0 +1,19 @@
+// The Mercury spacecraft in a plain shape, for the line looks: its length and width are sourced, and its outline is measured from NASA's model at those scales. The painted look is NASA's model.
+import { MERCURY_WIDE } from "../data/mercury.js";
+const H = 3.3;
+const R = (MERCURY_WIDE.value ?? 0) / 2;
+const capsule = () => [
+    { kind: "lathe", material: "engine-metal", segs: 28, body: true, outline: true, profile: [[0.24, 0], [0.44, 0.12], [0.5, 0.42]], rings: [0.42] },
+    { kind: "lathe", material: "soot", segs: 36, body: true, outline: true, profile: [[0.5, 0.42], [R, 0.55], [R * 0.98, 0.6]] },
+    { kind: "lathe", material: "tile-plain", segs: 36, body: true, outline: true, profile: [[R * 0.98, 0.6], [0.35, 2.15]], welds: [1.1, 1.6] },
+    { kind: "lathe", material: "engine-metal", segs: 28, body: true, outline: true, profile: [[0.35, 2.15], [0.35, 2.75]], rings: [2.17, 2.73] },
+    { kind: "lathe", material: "engine-pale", segs: 28, body: true, outline: true, profile: [[0.35, 2.75], [0.29, 2.95], [0.26, H]], rings: [2.95] },
+];
+export const MERCURY_BUILDS = [
+    {
+        rocket: "mercury",
+        variant: "friendship-7",
+        drawnFrom: "NASA's model for the painted look, with its colours judged from photographs. This package's plain shape for the two line looks, from the sourced length and width. No name or flag is drawn.",
+        parts: [{ slot: "capsule", kind: "capsule", name: "Mercury spacecraft, Friendship 7", height: H, diameter: R * 2, sourcedDiameter: MERCURY_WIDE, painted: { file: "mercury-capsule.glb", credit: "nasa-friendship-7" }, pieces: capsule }],
+    },
+];

package/dist/model/newglenn.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const NEW_GLENN_BUILDS: readonly StackBuild[];