@johnmorrisdotca/uchusen-rockets 0.2.2 → 0.4.0

package/dist/layout.d.ts

@@ -1,16 +1,80 @@
 import type { Vec3 } from "./framing.ts";
 import type { PartRecord } from "./parts.ts";
+/**
+ * What to show of a rocket: `together`, `apart`, or the slot of one part, such as `booster`.
+ *
+ * @example
+ * ```ts
+ * import type { ShowName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const shows: ShowName[] = ["together", "apart", "booster"];
+ * console.log(shows);
+ * ```
+ */
 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;
+/**
+ * Where one part stands for a choice of what to show: its slot, its position in metres and whether it is shown at all.
+ *
+ * @example
+ * ```ts
+ * import { placesFor, type Place } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const places: Place[] = placesFor([], "together", () => 1);
+ * console.log(places.length);
+ * ```
+ */
 export interface Place {
     slot: string;
     at: Vec3;
     shown: boolean;
 }
-/** The first choices of `show`, then one per slot. */
+/**
+ * The first choices of `show`, then one per slot.
+ *
+ * @param slots A variant's slots, from the bottom.
+ * @returns What can be shown: together and apart first when there is more than one slot, then one for each slot.
+ * @example
+ * ```ts
+ * import { showsOf, variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(showsOf(variantOf("falcon-9", "block-5")?.slots ?? []));
+ * ```
+ */
 export declare const showsOf: (slots: readonly string[]) => string[];
+/**
+ * A value from outside as something that can be shown.
+ *
+ * @param value Anything.
+ * @param slots The variant's slots.
+ * @returns The value if it can be shown, and the first choice (together) for anything else.
+ * @example
+ * ```ts
+ * import { cleanShow, variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const slots = variantOf("falcon-9", "block-5")?.slots ?? [];
+ * console.log(cleanShow("first-stage", slots), cleanShow("nonsense", slots));
+ * ```
+ */
 export declare function cleanShow(value: unknown, slots: readonly string[]): string;
+/**
+ * Where each part stands: up the stack joint to joint, or spread apart on a diagonal of the ground, or one part alone.
+ *
+ * @param parts The parts with their slots, from the bottom.
+ * @param show What to show.
+ * @param widthOf The width of a part, for spacing when they are apart.
+ * @returns A place for each part.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { placesFor } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const rocket = build({ rocket: "falcon-9", variant: "block-5" });
+ * const parts = rocket.parts.map((part) => ({ slot: part.slot, part: part.record }));
+ * console.log(placesFor(parts, "apart", (part) => part.diameter / 2).map((place) => place.slot));
+ * ```
+ */
 export declare function placesFor(parts: readonly {
     slot: string;
     part: PartRecord;

package/dist/layout.js

@@ -1,11 +1,53 @@
 /** 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. */
+/**
+ * The first choices of `show`, then one per slot.
+ *
+ * @param slots A variant's slots, from the bottom.
+ * @returns What can be shown: together and apart first when there is more than one slot, then one for each slot.
+ * @example
+ * ```ts
+ * import { showsOf, variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(showsOf(variantOf("falcon-9", "block-5")?.slots ?? []));
+ * ```
+ */
 export const showsOf = (slots) => (slots.length > 1 ? ["together", "apart", ...slots] : [...slots]);
+/**
+ * A value from outside as something that can be shown.
+ *
+ * @param value Anything.
+ * @param slots The variant's slots.
+ * @returns The value if it can be shown, and the first choice (together) for anything else.
+ * @example
+ * ```ts
+ * import { cleanShow, variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const slots = variantOf("falcon-9", "block-5")?.slots ?? [];
+ * console.log(cleanShow("first-stage", slots), cleanShow("nonsense", slots));
+ * ```
+ */
 export function cleanShow(value, slots) {
     const shows = showsOf(slots);
     return typeof value === "string" && shows.includes(value) ? value : shows[0];
 }
+/**
+ * Where each part stands: up the stack joint to joint, or spread apart on a diagonal of the ground, or one part alone.
+ *
+ * @param parts The parts with their slots, from the bottom.
+ * @param show What to show.
+ * @param widthOf The width of a part, for spacing when they are apart.
+ * @returns A place for each part.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { placesFor } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const rocket = build({ rocket: "falcon-9", variant: "block-5" });
+ * const parts = rocket.parts.map((part) => ({ slot: part.slot, part: part.record }));
+ * console.log(placesFor(parts, "apart", (part) => part.diameter / 2).map((place) => place.slot));
+ * ```
+ */
 export function placesFor(parts, show, widthOf) {
     if (show === "apart") {
         const widths = parts.map(({ part }) => widthOf(part));
@@ -24,7 +66,7 @@ export function placesFor(parts, show, widthOf) {
     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 };
+            return { slot, at: [together ? part.strapOn.x : 0, together ? (part.strapOn.y ?? 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);

package/dist/looks.d.ts

@@ -1,6 +1,48 @@
+/**
+ * The names of the looks: `line`, `thick` and `painted`.
+ *
+ * @example
+ * ```ts
+ * import { LOOK_NAMES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(LOOK_NAMES.join(", "));
+ * ```
+ */
 export declare const LOOK_NAMES: readonly ["line", "thick", "painted"];
+/**
+ * The name of one look in `LOOK_NAMES`.
+ *
+ * @example
+ * ```ts
+ * import type { LookName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const look: LookName = "thick";
+ * console.log(look);
+ * ```
+ */
 export type LookName = (typeof LOOK_NAMES)[number];
+/**
+ * The look used when none is named or the name is not a look: `line`.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_LOOK } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(DEFAULT_LOOK);
+ * ```
+ */
 export declare const DEFAULT_LOOK: LookName;
+/**
+ * What a look changes: the colour and width of its lines in a 3D view and in a drawing, how much of the weld lines shows, the fills by material group and whether there is a halo. A look never changes a shape.
+ *
+ * @example
+ * ```ts
+ * import { LOOKS, type Look } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const thick: Look = LOOKS.thick;
+ * console.log(thick.line, thick.outline);
+ * ```
+ */
 export interface Look {
     /** The colour of its lines. */
     line: string;
@@ -19,7 +61,28 @@ export interface Look {
     /** The soft light behind the rocket in a drawing. */
     halo: boolean;
 }
-export type FillName = "hull" | "white" | "tile" | "metal" | "dark" | "bell";
+export type FillName = "hull" | "white" | "tile" | "metal" | "dark" | "bell" | "foam";
+/**
+ * Every look, by name. A look is one entry of this table.
+ *
+ * @example
+ * ```ts
+ * import { LOOKS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(LOOKS));
+ * ```
+ */
 export declare const LOOKS: Readonly<Record<LookName, Look>>;
-/** A value from outside as a look's name: the default for anything else. */
+/**
+ * A value from outside as a look's name: the default for anything else.
+ *
+ * @param value Anything.
+ * @returns The look's name if it is one, and the default (`line`) for anything else.
+ * @example
+ * ```ts
+ * import { cleanLook } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(cleanLook("painted"), cleanLook("shiny"));
+ * ```
+ */
 export declare const cleanLook: (value: unknown) => LookName;

package/dist/looks.js

@@ -1,5 +1,25 @@
 // 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.
+/**
+ * The names of the looks: `line`, `thick` and `painted`.
+ *
+ * @example
+ * ```ts
+ * import { LOOK_NAMES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(LOOK_NAMES.join(", "));
+ * ```
+ */
 export const LOOK_NAMES = ["line", "thick", "painted"];
+/**
+ * The look used when none is named or the name is not a look: `line`.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_LOOK } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(DEFAULT_LOOK);
+ * ```
+ */
 export const DEFAULT_LOOK = "line";
 const NIGHT = {
     hull: ["#0c1422", "#2a3850", "#0c1422"],
@@ -8,7 +28,18 @@ const NIGHT = {
     metal: ["#16202f", "#3a475c", "#16202f"],
     dark: ["#070b12", "#121a28", "#070b12"],
     bell: ["#0a0f18", "#242f42", "#0a0f18"],
+    foam: ["#16202f", "#3a475c", "#16202f"],
 };
+/**
+ * Every look, by name. A look is one entry of this table.
+ *
+ * @example
+ * ```ts
+ * import { LOOKS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(LOOKS));
+ * ```
+ */
 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 },
@@ -28,9 +59,21 @@ export const LOOKS = {
             metal: ["#5a5f66", "#a9afb6", "#5a5f66"],
             dark: ["#111316", "#2a2d31", "#111316"],
             bell: ["#141518", "#3c3f44", "#141518"],
+            foam: ["#6e3a1b", "#c8743a", "#6e3a1b"],
         },
         halo: false,
     },
 };
-/** A value from outside as a look's name: the default for anything else. */
+/**
+ * A value from outside as a look's name: the default for anything else.
+ *
+ * @param value Anything.
+ * @returns The look's name if it is one, and the default (`line`) for anything else.
+ * @example
+ * ```ts
+ * import { cleanLook } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(cleanLook("painted"), cleanLook("shiny"));
+ * ```
+ */
 export const cleanLook = (value) => (LOOK_NAMES.includes(value) ? value : DEFAULT_LOOK);

package/dist/model/apollosoyuz.d.ts

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

package/dist/model/apollosoyuz.js

@@ -0,0 +1,46 @@
+// Apollo and Soyuz docked, in plain shapes, for the line looks: each is its sourced length and width, stood on end with Apollo's engine down. Where their parts begin is measured from NASA's model at those scales. The painted look is NASA's model.
+import { AS_CSM_LONG, AS_CSM_WIDE, AS_SOYUZ_LONG, AS_SOYUZ_WIDE } from "../data/apollosoyuz.js";
+import { blank } from "../data/types.js";
+import { floor, taper, tube } from "./kit.js";
+const CSM = AS_CSM_LONG.value ?? 0;
+const CSM_R = (AS_CSM_WIDE.value ?? 0) / 2;
+const ALONG = CSM / 11.84;
+const ENGINE = 2.59;
+const CM_AT = CSM - 3.28;
+const DOCK_AT = CSM - (0.32 * ALONG);
+const DOCK = 2.33;
+const SOYUZ_AT = DOCK_AT + 2.32 * ALONG;
+const SOYUZ = AS_SOYUZ_LONG.value ?? 0;
+const SOYUZ_R = (AS_SOYUZ_WIDE.value ?? 0) / 2;
+const csm = () => [
+    taper("engine-pale", 1.2, 0, 0.45, ENGINE, { rings: [0.02] }),
+    tube("white", CSM_R, ENGINE, CM_AT, { rings: [ENGINE + 0.02, CM_AT - 0.02], welds: [ENGINE + 1.5] }),
+    floor(CSM_R, ENGINE),
+    taper("steel", CSM_R, CM_AT, 0.3, CSM),
+];
+const dock = () => [tube("dark", 0.7, 0.1, DOCK, { rings: [0.3, DOCK - 0.25] }), floor(0.7, 0.1)];
+const wing = (side) => {
+    const frame = { o: [side * SOYUZ_R, 5.9, 0], u: [side, 0, 0], v: [0, 1, 0], w: [0, 0, 1] };
+    return { kind: "plate", material: "solar", frame, outline: [[0.1, -0.5], [2.75, -0.5], [2.75, 0.5], [0.1, 0.5]], thickness: 0.04 };
+};
+const soyuz = () => [
+    { kind: "lathe", material: "white", segs: 28, body: true, outline: true, profile: [[0.3, 0.1], [0.75, 0.25], [1.05, 0.8], [1.05, 1.4], [0.72, 2.1]] },
+    { kind: "lathe", material: "white", segs: 28, body: true, outline: true, profile: [[0.72, 2.1], [SOYUZ_R * 0.88, 3], [SOYUZ_R * 0.9, 4.6]], rings: [3] },
+    tube("engine-pale", SOYUZ_R * 0.95, 4.6, 6.6, { rings: [4.62] }),
+    { kind: "lathe", material: "white", segs: 28, body: true, outline: true, profile: [[SOYUZ_R * 0.95, 6.6], [SOYUZ_R, SOYUZ]] },
+    wing(1),
+    wing(-1),
+];
+const FROM = "NASA's model for the painted look. This package's plain shapes for the two line looks, from each craft's sourced length and width; where its parts begin is measured from NASA's model. No flag or lettering is drawn.";
+export const APOLLO_SOYUZ_BUILDS = [
+    {
+        rocket: "apollo-soyuz",
+        variant: "apollo-soyuz",
+        drawnFrom: FROM,
+        parts: [
+            { slot: "csm", kind: "spacecraft", name: "Apollo command and service module", height: CSM, diameter: CSM_R * 2, sourcedDiameter: AS_CSM_WIDE, painted: { file: "apollo-soyuz-csm.glb", credit: "nasa-apollo-soyuz" }, pieces: csm },
+            { slot: "docking-module", kind: "spacecraft", name: "Docking module", height: DOCK, diameter: 1.41, place: { x: 0, z: 0, y: DOCK_AT }, sourcedDiameter: blank("No source read here gives its size."), painted: { file: "apollo-soyuz-docking-module.glb", credit: "nasa-apollo-soyuz" }, pieces: dock },
+            { slot: "soyuz", kind: "spacecraft", name: "Soyuz 7K-TM", height: SOYUZ, diameter: SOYUZ_R * 2, place: { x: 0, z: 0, y: SOYUZ_AT }, sourcedDiameter: AS_SOYUZ_WIDE, painted: { file: "apollo-soyuz-soyuz.glb", credit: "nasa-apollo-soyuz" }, pieces: soyuz },
+        ],
+    },
+];

package/dist/model/dragoninside.d.ts

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

package/dist/model/dragoninside.js

@@ -0,0 +1,67 @@
+// Inside Crew Dragon: the capsule cut open down its middle, at Dragon 2's sourced sizes. Four seats and the three-screen panel over the two centre seats are sourced, with the cargo below them; where each sits and its size are judged from one published picture of the cabin. For scale, a plain person of 1.8 m, not a fact about anyone.
+import { DRAGON_DRAWS } from "./falcon.js";
+import { deg } from "../framing.js";
+import { strut } from "./pieces.js";
+const d = DRAGON_DRAWS["dragon-2"];
+const H = d.capsule;
+const R = d.baseRadius;
+const N = d.nest;
+const SHOULDER = H * 0.74;
+const OUTER = [[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 BACK = () => [deg(90), deg(270)];
+const FLOOR_Y = N + 0.75;
+const shell = (profile, material, extra = {}) => ({ kind: "lathe", material, segs: 48, body: true, arc: BACK, profile, ...extra });
+const box = (material, a, b, width, depth) => strut(material, a, b, width, depth, { plain: false });
+function seat(x, y, z) {
+    return [
+        box("white", [x, y, z - 0.3], [x, y + 0.82, z - 0.62], 0.58, 0.1),
+        box("black", [x, y + 0.02, z - 0.28], [x, y + 0.08, z + 0.26], 0.54, 0.12),
+        box("black", [x, y + 0.72, z - 0.5], [x, y + 0.84, z - 0.54], 0.3, 0.14),
+    ];
+}
+/** A plain person for scale, standing. */
+function person(x, y, z) {
+    const tall = 1.8;
+    const head = 0.12;
+    const at = [x, z];
+    return [
+        { kind: "lathe", material: "engine-pale", at, segs: 12, profile: [[0.14, y], [0.2, y + tall * 0.5], [0.23, y + tall * 0.8], [0.09, y + tall - 2 * head]] },
+        { kind: "lathe", material: "engine-pale", at, segs: 12, profile: [[0.001, y + tall - 2 * head], [head * 0.72, y + tall - 1.72 * head], [head, y + tall - head], [head * 0.72, y + tall - 0.28 * head], [0.001, y + tall]] },
+    ];
+}
+function inside() {
+    const inner = OUTER.map(([r, y]) => [Math.max(0.001, r * 0.93), y + 0.03]).reverse();
+    const out = [
+        shell(OUTER, "white", { outline: true, rings: [N + 0.3, SHOULDER] }),
+        // the inner wall, seen through the cut
+        shell(inner, "engine-pale"),
+        { kind: "lathe", material: "soot", segs: 40, under: true, profile: [[0, 0], [R * 0.72, 0], [R * 0.9, N]], rings: [N] },
+        // the floor and the cut edge of the shell
+        { kind: "lathe", material: "dark", segs: 40, body: true, profile: [[R * 0.86, FLOOR_Y], [0.001, FLOOR_Y]] },
+        // the cargo under the centre seats
+        box("engine-pale", [-0.55, FLOOR_Y, 0.1], [-0.55, FLOOR_Y + 0.5, 0.1], 0.5, 0.55),
+        box("engine-metal", [0, FLOOR_Y, 0.15], [0, FLOOR_Y + 0.46, 0.15], 0.4, 0.55),
+        box("engine-pale", [0.55, FLOOR_Y, 0.1], [0.55, FLOOR_Y + 0.5, 0.1], 0.5, 0.55),
+        // the two centre seats, higher, and the outer two
+        ...seat(-0.34, FLOOR_Y + 0.72, -0.15),
+        ...seat(0.34, FLOOR_Y + 0.72, -0.15),
+        ...seat(-1.02, FLOOR_Y + 0.42, -0.42),
+        ...seat(1.02, FLOOR_Y + 0.42, -0.42),
+        // the panel over the centre seats, with its three screens
+        box("engine-metal", [0, FLOOR_Y + 1.62, 0.22], [0, FLOOR_Y + 1.92, 0.08], 1.34, 0.08),
+        ...[-0.42, 0, 0.42].map((x) => box("glass", [x, FLOOR_Y + 1.66, 0.25], [x, FLOOR_Y + 1.88, 0.15], 0.38, 0.03)),
+        // a window on each side of the cabin, and the docking port in the ceiling
+        ...[-1, 1].map((side) => box("glass", [side * 1.36, FLOOR_Y + 0.96, -0.1], [side * 1.2, FLOOR_Y + 1.24, -0.1], 0.3, 0.06)),
+        { kind: "lathe", material: "engine-metal", segs: 20, body: true, profile: [[0.38, H * 0.8], [0.38, H * 0.86], [0.001, H * 0.86]] },
+        ...person(1.5, FLOOR_Y, 0.9),
+    ];
+    return out;
+}
+export const DRAGON_INSIDE_BUILDS = [
+    {
+        rocket: "dragon",
+        variant: "crew-dragon-inside",
+        drawnFrom: "This package's code. The outside is Dragon 2's sourced size; its four seats, panel and cargo are from its article, placed by eye from one published picture of the cabin. Their sizes have no source. Cut open to look inside: the real capsule's front half is not drawn. The figure of 1.8 m is for scale.",
+        parts: [{ slot: "capsule", kind: "capsule", name: "Inside Crew Dragon, cut open", height: H, diameter: R * 2, pieces: inside }],
+    },
+];

package/dist/model/electron.d.ts

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

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 }],
+    },
+];