@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.11.0

package/dist/beside.d.ts

@@ -0,0 +1,76 @@
+import type { Description } from "./fit.ts";
+import type { Vec3 } from "./framing.ts";
+import type { Bounds } from "./model/pieces.ts";
+/**
+ * The rocket that can stand beside another for scale: the real Starship stack, Super Heavy and the ship, Block 3. Beside another craft it is drawn in this package's own paint, so no licensed model comes in unseen.
+ *
+ * @example
+ * ```ts
+ * import { BESIDE_ROCKET } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(BESIDE_ROCKET.rocket, BESIDE_ROCKET.variant);
+ * ```
+ */
+export declare const BESIDE_ROCKET: Readonly<Description>;
+/** What the stack beside is called. */
+export declare const BESIDE_NAME = "Starship with Super Heavy";
+/**
+ * The words that say what the craft beside it is: its name and its sourced length, such as "Starship with Super Heavy, 124.4 m".
+ *
+ * @returns The label the 3D view puts under the stack.
+ * @example
+ * ```ts
+ * import { besideLabel } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(besideLabel());
+ * ```
+ */
+export declare function besideLabel(): string;
+/** The least room between the two, in metres. */
+export declare const BESIDE_GAP = 4;
+/**
+ * Whether Starship can stand beside this rocket: every rocket but Starship itself.
+ *
+ * @param rocket A rocket's id.
+ * @returns False for Starship, true for any other.
+ * @example
+ * ```ts
+ * import { canBeside } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(canBeside("saturn-v"), canBeside("starship"));
+ * ```
+ */
+export declare const canBeside: (rocket: string) => boolean;
+/**
+ * Where the other rocket stands: its offset in metres, to add to where its own parts stand, and the box it fills there. It is never scaled. Its foot is on the ground line (y = 0) as every rocket's is, it keeps its own
+ * line (z = 0), and its nearest side is a gap clear of the craft's widest, to the right (+X).
+ *
+ * @param craft The box the craft fills, in metres.
+ * @param other The box the other rocket fills on its own, in metres.
+ * @returns The offset and the box the other rocket fills once it is there.
+ * @example
+ * ```ts
+ * import { besideLayout } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const { at, bounds } = besideLayout({ min: [-4, 0, -4], max: [4, 70, 4] }, { min: [-9, 0, -5], max: [9, 124, 9] });
+ * console.log(at, bounds.max[1]);
+ * ```
+ */
+export declare function besideLayout(craft: Bounds, other: Bounds): {
+    at: Vec3;
+    bounds: Bounds;
+};
+/**
+ * The box that holds both: what the camera must frame, and what Fit fits.
+ *
+ * @param craft The box the craft fills.
+ * @param placed The box the other rocket fills where `besideLayout` put it.
+ * @returns The smallest box that holds both.
+ * @example
+ * ```ts
+ * import { besideBounds } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(besideBounds({ min: [-4, 0, -4], max: [4, 70, 4] }, { min: [8, 0, -5], max: [26, 124, 9] }).max);
+ * ```
+ */
+export declare function besideBounds(craft: Bounds, placed: Bounds): Bounds;

package/dist/beside.js

@@ -0,0 +1,83 @@
+import { variantOf } from "./rockets.js";
+/**
+ * The rocket that can stand beside another for scale: the real Starship stack, Super Heavy and the ship, Block 3. Beside another craft it is drawn in this package's own paint, so no licensed model comes in unseen.
+ *
+ * @example
+ * ```ts
+ * import { BESIDE_ROCKET } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(BESIDE_ROCKET.rocket, BESIDE_ROCKET.variant);
+ * ```
+ */
+export const BESIDE_ROCKET = { rocket: "starship", variant: "v3" };
+/** What the stack beside is called. */
+export const BESIDE_NAME = "Starship with Super Heavy";
+/**
+ * The words that say what the craft beside it is: its name and its sourced length, such as "Starship with Super Heavy, 124.4 m".
+ *
+ * @returns The label the 3D view puts under the stack.
+ * @example
+ * ```ts
+ * import { besideLabel } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(besideLabel());
+ * ```
+ */
+export function besideLabel() {
+    const height = variantOf(BESIDE_ROCKET.rocket, BESIDE_ROCKET.variant)?.facts.height.value;
+    return typeof height === "number" ? `${BESIDE_NAME}, ${height.toLocaleString("en-US")} m` : BESIDE_NAME;
+}
+/** The least room between the two, in metres. */
+export const BESIDE_GAP = 4;
+/**
+ * Whether Starship can stand beside this rocket: every rocket but Starship itself.
+ *
+ * @param rocket A rocket's id.
+ * @returns False for Starship, true for any other.
+ * @example
+ * ```ts
+ * import { canBeside } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(canBeside("saturn-v"), canBeside("starship"));
+ * ```
+ */
+export const canBeside = (rocket) => rocket !== BESIDE_ROCKET.rocket;
+/**
+ * Where the other rocket stands: its offset in metres, to add to where its own parts stand, and the box it fills there. It is never scaled. Its foot is on the ground line (y = 0) as every rocket's is, it keeps its own
+ * line (z = 0), and its nearest side is a gap clear of the craft's widest, to the right (+X).
+ *
+ * @param craft The box the craft fills, in metres.
+ * @param other The box the other rocket fills on its own, in metres.
+ * @returns The offset and the box the other rocket fills once it is there.
+ * @example
+ * ```ts
+ * import { besideLayout } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const { at, bounds } = besideLayout({ min: [-4, 0, -4], max: [4, 70, 4] }, { min: [-9, 0, -5], max: [9, 124, 9] });
+ * console.log(at, bounds.max[1]);
+ * ```
+ */
+export function besideLayout(craft, other) {
+    const gap = Math.max(BESIDE_GAP, (craft.max[0] - craft.min[0]) * 0.1);
+    const at = [craft.max[0] + gap - other.min[0], 0 - other.min[1], 0];
+    return { at, bounds: { min: [other.min[0] + at[0], other.min[1] + at[1], other.min[2]], max: [other.max[0] + at[0], other.max[1] + at[1], other.max[2]] } };
+}
+/**
+ * The box that holds both: what the camera must frame, and what Fit fits.
+ *
+ * @param craft The box the craft fills.
+ * @param placed The box the other rocket fills where `besideLayout` put it.
+ * @returns The smallest box that holds both.
+ * @example
+ * ```ts
+ * import { besideBounds } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(besideBounds({ min: [-4, 0, -4], max: [4, 70, 4] }, { min: [8, 0, -5], max: [26, 124, 9] }).max);
+ * ```
+ */
+export function besideBounds(craft, placed) {
+    return {
+        min: [Math.min(craft.min[0], placed.min[0]), Math.min(craft.min[1], placed.min[1]), Math.min(craft.min[2], placed.min[2])],
+        max: [Math.max(craft.max[0], placed.max[0]), Math.max(craft.max[1], placed.max[1]), Math.max(craft.max[2], placed.max[2])],
+    };
+}

package/dist/build/glb.js

@@ -132,8 +132,9 @@ export function toGlb(parts) {
     };
     for (const part of parts) {
         // a holder that the viewer moves, and the packed mesh under it; each moving group is a node of its own beside it, at its pivot, with the axis it turns about
-        const children = [packMesh(part.mesh, part.name)];
-        for (const group of part.mesh.moves) {
+        const mesh = part.mesh;
+        const children = [packMesh(mesh, part.name)];
+        for (const group of mesh.moves) {
             const inside = packMesh(group.mesh, `${part.name}~${group.id}`);
             nodes.push({ name: `${part.name}~${group.id}`, children: [inside], translation: group.pivot.map(round6), extras: { axis: group.axis.map(round6), group: group.name } });
             children.push(nodes.length - 1);

package/dist/build/index.d.ts

@@ -2,6 +2,7 @@ import { type FlameKind } from "../data/propellants.ts";
 import { type Description, type FitReport } from "../fit.ts";
 import { type Angle, type Vec3, type ViewName } from "../framing.ts";
 import { type LookName } from "../looks.ts";
+import { type DetailLevel } from "../model/detail.ts";
 import { type PartMesh, type Bounds, type Piece } from "../model/pieces.ts";
 import type { PartRecord } from "../parts.ts";
 import { type LitBell } from "../engines.ts";
@@ -64,6 +65,10 @@ export interface SvgOptions {
     engines?: boolean | Readonly<Record<string, number>>;
     /** Degrees each moving group of each part is turned from where it is drawn at rest, by slot and then by name: `{ booster: { "grid-fins": 12 } }`. A flight asks for them. */
     moves?: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    /** Only these slots, closed up into one stack, centred in `frame` when it is given: a rocket after its first stages have gone. Left out, `show` decides. */
+    only?: readonly string[];
+    /** The bounds the picture is fitted to, from another build's `boundsOf`: parts drawn with it keep the scale of the whole rocket they came from. */
+    frame?: Bounds;
 }
 /**
  * A rocket built from a description: the fit report, its parts, and the ways to ask for its size, where each part stands, its lit engines, a `.glb` file and a drawing.
@@ -80,6 +85,8 @@ export interface SvgOptions {
 export interface Built {
     report: FitReport;
     parts: readonly BuiltPart[];
+    /** The parts of the rocket standing beside it, when it was built `beside`; empty otherwise. They are not in `parts`; `placesOf`, `boundsOf`, `glb` and `svg` take them in. Their slots start `beside-`. */
+    beside: readonly BuiltPart[];
     /** What can be shown: together, apart and each part. */
     shows: readonly string[];
     /** The bounds of a choice of what to show, in metres, and with `lit` the flames of its engines at full thrust. */
@@ -97,6 +104,17 @@ export interface Built {
     /** The drawing, in a look, from an angle. */
     svg(options?: SvgOptions): string;
 }
+/**
+ * A part with more pieces than this is not meshed until its triangles are asked for, and the mesh is not kept: a fleet ship's parts hold hundreds of thousands of triangles, and keeping them all as arrays of numbers took a gigabyte.
+ *
+ * @example
+ * ```ts
+ * import { HEAVY_PIECES } from "@johnmorrisdotca/uchusen-rockets/build";
+ *
+ * console.log(HEAVY_PIECES);
+ * ```
+ */
+export declare const HEAVY_PIECES = 2000;
 /**
  * What a drawing draws of a part: in a stack, what nests inside the part below is out of sight.
  *
@@ -119,6 +137,7 @@ export declare function drawnPieces(part: {
  * A rocket from a description. Throws FitError when it does not go together.
  *
  * @param description The rocket, its variant and any other part in a slot.
+ * @param options `detail`: `"coarse"` leaves out the small 3D-only detail of a very detailed part, for a fast first view; left out, every piece is made. `beside`: the real Starship stack (Block 3) stands beside it at true scale, on the same ground, and `boundsOf`, `placesOf`, `glb` and `svg` take it in; Starship itself has nothing beside it.
  * @returns The built rocket. It throws a `FitError` when the description does not go together.
  * @example
  * ```ts
@@ -128,7 +147,10 @@ export declare function drawnPieces(part: {
  * console.log(rocket.report.label, rocket.glb().bytes.length > 1000);
  * ```
  */
-export declare function build(description: Description): Built;
+export declare function build(description: Description, options?: {
+    detail?: DetailLevel;
+    beside?: boolean;
+}): Built;
 /**
  * One part on its own, by its id.
  *
@@ -150,5 +172,5 @@ export declare function buildPart(id: string): {
 };
 export { toGlb };
 export type { Glb };
-export { COMPARES, lineupSvg } from "./lineup.ts";
+export { COMPARES, lineupSvg, REAL_CRAFT } from "./lineup.ts";
 export type { CompareId, LineupItem, LineupOptions } from "./lineup.ts";

package/dist/build/index.js

@@ -1,10 +1,12 @@
 // The builder: one description into one mesh and one drawing. Works in Node and in a browser, with no dependency: the geometry here is this package's own.
 import { propellantOf } from "../data/propellants.js";
 import { check } from "../fit.js";
+import { BESIDE_ROCKET, besideBounds, besideLayout, canBeside } from "../beside.js";
 import { cleanView, DEFAULT_VIEW, PICTURE_H, PICTURE_W, VIEWS } from "../framing.js";
 import { cleanShow, placesFor, showsOf } from "../layout.js";
 import { DEFAULT_LOOK } from "../looks.js";
-import { boundsOf, meshOf } from "../model/pieces.js";
+import { detail } from "../model/detail.js";
+import { boundsOf, boundsOfPieces, meshOf } from "../model/pieces.js";
 import { moved } from "../model/moves.js";
 import { partEntry } from "../model/registry.js";
 import { partIdOf, variantOf } from "../rockets.js";
@@ -35,18 +37,35 @@ export class FitError extends Error {
         this.report = report;
     }
 }
+/**
+ * A part with more pieces than this is not meshed until its triangles are asked for, and the mesh is not kept: a fleet ship's parts hold hundreds of thousands of triangles, and keeping them all as arrays of numbers took a gigabyte.
+ *
+ * @example
+ * ```ts
+ * import { HEAVY_PIECES } from "@johnmorrisdotca/uchusen-rockets/build";
+ *
+ * console.log(HEAVY_PIECES);
+ * ```
+ */
+export const HEAVY_PIECES = 2000;
 const memo = new Map();
+const memoKey = (id) => `${detail.level}/${id}`;
 function made(id) {
-    const known = memo.get(id);
+    const known = memo.get(memoKey(id));
     if (known)
         return known;
     const entry = partEntry(id);
     if (!entry)
         throw new Error(`There is no part "${id}".`);
     const pieces = entry.pieces();
+    if (pieces.length > HEAVY_PIECES) {
+        const heavy = { pieces, bounds: boundsOfPieces(pieces), get mesh() { return meshOf(pieces); } };
+        memo.set(memoKey(id), heavy);
+        return heavy;
+    }
     const mesh = meshOf(pieces);
     const result = { pieces, mesh, bounds: boundsOf(mesh) };
-    memo.set(id, result);
+    memo.set(memoKey(id), result);
     return result;
 }
 const xmlText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
@@ -69,25 +88,20 @@ function flameKindOf(part) {
     }
     return "neutral";
 }
-function assembled(report) {
-    const parts = report.parts.map(({ slot, part }) => {
-        const { pieces, mesh, bounds } = made(part.id);
-        return { slot, record: part, pieces, mesh, bounds, flame: flameKindOf(part) };
+function assembled(report, other) {
+    const own = report.parts.map(({ slot, part }) => {
+        const one = made(part.id);
+        return { slot, record: part, pieces: one.pieces, get mesh() { return one.mesh; }, bounds: one.bounds, flame: flameKindOf(part) };
     });
-    const slots = parts.map((part) => part.slot);
-    const placesOf = (show) => placesFor(report.parts, cleanShow(show, slots), (part) => widthOf(part.id));
-    const flamesOf = (show) => {
-        const places = placesOf(show);
-        return litBells(places.map((place) => {
-            const part = parts.find((p) => p.slot === place.slot);
-            const told = report.variant?.facts.engines[part.slot]?.value;
-            return { slot: part.slot, atY: place.at[1], shown: place.shown, pieces: part.pieces, beside: place.at[0] !== 0 || place.at[2] !== 0, dark: told === null || told === undefined };
-        }), !show || show === "together");
-    };
-    const boundsOfShow = (show, lit = false) => {
+    const slots = own.map((part) => part.slot);
+    const beside = (other?.parts ?? []).map((part) => ({ slot: `beside-${part.slot}`, record: part.record, pieces: part.pieces, get mesh() { return part.mesh; }, bounds: part.bounds, flame: part.flame }));
+    // what is drawn: the rocket's parts, then the ones beside it
+    const parts = [...own, ...beside];
+    const ownPlaces = (show) => placesFor(report.parts, cleanShow(show, slots), (part) => widthOf(part.id));
+    const boundsOfPlaces = (places) => {
         const min = [Infinity, Infinity, Infinity];
         const max = [-Infinity, -Infinity, -Infinity];
-        for (const place of placesOf(show)) {
+        for (const place of places) {
             if (!place.shown)
                 continue;
             const { bounds } = parts.find((part) => part.slot === place.slot);
@@ -96,6 +110,34 @@ function assembled(report) {
                 max[c] = Math.max(max[c], bounds.max[c] + place.at[c]);
             }
         }
+        return { min, max };
+    };
+    // the other rocket stands whole, on the ground, clear of whatever of this one shows
+    const placesOf = (show) => {
+        const mine = ownPlaces(show);
+        if (!other)
+            return mine;
+        const { at } = besideLayout(boundsOfPlaces(mine), other.boundsOf("together"));
+        return [...mine, ...other.placesOf("together").map((place) => ({ slot: `beside-${place.slot}`, at: [place.at[0] + at[0], place.at[1] + at[1], place.at[2] + at[2]], shown: true }))];
+    };
+    const flamesAt = (places, together) => litBells(places.map((place) => {
+        const part = parts.find((p) => p.slot === place.slot);
+        const told = report.variant?.facts.engines[part.slot]?.value;
+        return { slot: part.slot, atY: place.at[1], shown: place.shown, pieces: part.pieces, beside: place.at[0] !== 0 || place.at[2] !== 0, dark: told === null || told === undefined };
+    }), together);
+    const flamesOf = (show) => flamesAt(placesOf(show), !show || show === "together");
+    // the parts that are left, closed up joint to joint, and centred in a frame when there is one
+    const stackOf = (only, frame) => {
+        const stacked = placesFor(report.parts.filter(({ slot }) => only.includes(slot)), "together", (part) => widthOf(part.id));
+        if (!frame || stacked.length === 0)
+            return stacked;
+        const mine = boundsOfPlaces(stacked);
+        const dy = (frame.min[1] + frame.max[1]) / 2 - (mine.min[1] + mine.max[1]) / 2;
+        return stacked.map((place) => ({ ...place, at: [place.at[0], place.at[1] + dy, place.at[2]] }));
+    };
+    const boundsOfShow = (show, lit = false) => {
+        const mine = boundsOfPlaces(ownPlaces(show));
+        const { min, max } = other ? besideBounds(mine, besideLayout(mine, other.boundsOf("together")).bounds) : mine;
         if (lit)
             for (const bell of flamesOf(show)) {
                 const place = placesOf(show).find((one) => one.slot === bell.slot);
@@ -105,17 +147,19 @@ function assembled(report) {
     };
     return {
         report,
-        parts,
+        parts: own,
+        beside,
         shows: showsOf(slots),
         boundsOf: boundsOfShow,
         placesOf,
         flamesOf,
         glb: () => toGlb(parts.map((part) => ({ name: part.slot, mesh: part.mesh, at: placesOf("together").find((place) => place.slot === part.slot)?.at ?? [0, 0, 0] }))),
-        svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW, show, engines = false, moves } = {}) => {
+        svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW, show, engines = false, moves, only, frame } = {}) => {
             const angle = typeof view === "string" ? VIEWS[cleanView(view)] : view;
-            const places = placesOf(show).filter((place) => place.shown);
+            const placed = only ? stackOf(only, frame) : placesOf(show);
+            const places = placed.filter((place) => place.shown);
             // a flame drawn at full thrust is held in the picture; a count of engines is the timeline's, which has its own room
-            const cam = perspective(boundsOfShow(show, engines === true), angle);
+            const cam = perspective(frame ?? boundsOfShow(show, engines === true), angle);
             const ordered = places
                 .map((place) => {
                 const part = parts.find((p) => p.slot === place.slot);
@@ -123,11 +167,11 @@ function assembled(report) {
                 return { place, part, depth: cam.depth(middle) };
             })
                 .sort((a, b) => b.depth - a.depth);
-            const together = !show || show === "together";
+            const together = only !== undefined || !show || show === "together";
             const flames = typeof engines === "object"
                 ? parts.flatMap((part) => pickBells(bellsOf(part.pieces), engines[part.slot] ?? 0).map((bell) => ({ ...bell, slot: part.slot })))
                 : engines
-                    ? flamesOf(show).filter((bell) => places.some((place) => place.slot === bell.slot))
+                    ? (only ? flamesAt(placed, true) : flamesOf(show)).filter((bell) => places.some((place) => place.slot === bell.slot))
                     : [];
             return wrap(ordered
                 .map(({ place, part }) => drawPart(moved(drawnPieces(part, together), moves?.[part.slot] ?? {}), place.at, cam, look) + plumeMarkup(flames.filter((bell) => bell.slot === place.slot), place.at, cam, look, part.slot, part.flame))
@@ -159,6 +203,7 @@ export function drawnPieces(part, together) {
  * A rocket from a description. Throws FitError when it does not go together.
  *
  * @param description The rocket, its variant and any other part in a slot.
+ * @param options `detail`: `"coarse"` leaves out the small 3D-only detail of a very detailed part, for a fast first view; left out, every piece is made. `beside`: the real Starship stack (Block 3) stands beside it at true scale, on the same ground, and `boundsOf`, `placesOf`, `glb` and `svg` take it in; Starship itself has nothing beside it.
  * @returns The built rocket. It throws a `FitError` when the description does not go together.
  * @example
  * ```ts
@@ -168,11 +213,20 @@ export function drawnPieces(part, together) {
  * console.log(rocket.report.label, rocket.glb().bytes.length > 1000);
  * ```
  */
-export function build(description) {
+export function build(description, options = {}) {
     const report = check(description);
     if (!report.ok)
         throw new FitError(report);
-    return assembled(report);
+    const before = detail.level;
+    detail.level = options.detail ?? "full";
+    try {
+        const built = assembled(report, options.beside && canBeside(description.rocket) ? build(BESIDE_ROCKET, { detail: "full" }) : undefined);
+        // a part's pieces are made when it is assembled, at this level: the lazy parts of a heavy part keep the level they were made at
+        return built;
+    }
+    finally {
+        detail.level = before;
+    }
 }
 /**
  * One part on its own, by its id.
@@ -191,11 +245,12 @@ export function buildPart(id) {
     const entry = partEntry(id);
     if (!entry)
         throw new Error(`There is no part "${id}".`);
-    const { pieces, mesh, bounds } = made(id);
+    const { pieces, bounds } = made(id);
+    const one = made(id);
     return {
         record: entry.record,
         bounds,
-        glb: () => toGlb([{ name: entry.record.id, mesh, at: [0, 0, 0] }]),
+        glb: () => toGlb([{ name: entry.record.id, mesh: one.mesh, at: [0, 0, 0] }]),
         svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW } = {}) => {
             const angle = typeof view === "string" ? VIEWS[cleanView(view)] : view;
             return wrap(drawPart(pieces, [0, 0, 0], perspective(bounds, angle), look, 1), look, PICTURE_W, PICTURE_H, entry.record.name);
@@ -203,4 +258,4 @@ export function buildPart(id) {
     };
 }
 export { toGlb };
-export { COMPARES, lineupSvg } from "./lineup.js";
+export { COMPARES, lineupSvg, REAL_CRAFT } from "./lineup.js";

package/dist/build/lineup.d.ts

@@ -1,5 +1,7 @@
 import { type ViewName } from "../framing.ts";
 import { type LookName } from "../looks.ts";
+import { type Camera } from "../draw/svg.ts";
+import type { Bounds } from "../model/pieces.ts";
 /**
  * Comparison shapes: plain round sizes, for scale, not facts about anything.
  *
@@ -34,6 +36,34 @@ export declare const COMPARES: {
  * ```
  */
 export type CompareId = keyof typeof COMPARES;
+/**
+ * The real craft that lie in the fleet band for scale: Starship with Super Heavy, Saturn V, SLS and the International Space Station. Each is a variant of the package, so its length is the sourced figure, `axis` is the way its length runs in its own model
+ * (`y` up the stack, nose up; `x` along the station's long axis), and a rocket points its nose right. They are never scaled: they are drawn at the lineup's own scale.
+ *
+ * @example
+ * ```ts
+ * import { REAL_CRAFT } from "@johnmorrisdotca/uchusen-rockets/build";
+ *
+ * console.log(REAL_CRAFT.map((craft) => craft.name));
+ * ```
+ */
+export declare const REAL_CRAFT: readonly [{
+    readonly key: "starship:v3";
+    readonly name: "Starship with Super Heavy";
+    readonly axis: "y";
+}, {
+    readonly key: "saturn-v:saturn-v";
+    readonly name: "Saturn V";
+    readonly axis: "y";
+}, {
+    readonly key: "sls:block-1";
+    readonly name: "SLS Block 1";
+    readonly axis: "y";
+}, {
+    readonly key: "iss:iss";
+    readonly name: "ISS";
+    readonly axis: "x";
+}];
 /**
  * One thing standing in a lineup: its key (`starship:v3` or a comparison's name), its label and its height in metres.
  *
@@ -72,12 +102,21 @@ export interface LineupOptions {
     show?: string;
     ruler?: boolean;
     labels?: boolean;
+    /** Real craft for scale: Starship with Super Heavy, Saturn V, SLS and the ISS lie sideways in the fleet band, at the same scale as the fleet ships, nose right, each labelled with its name and length. Left out: not drawn. Only where the fleet band is. */
+    real?: boolean;
+    /** `rockets` or `fleet` leaves out the other kind; `all` (the default) draws both. A fleet ship (a rocket whose id starts with `fleet-`) lies lengthwise in its own band below the rockets. */
+    filter?: "all" | "rockets" | "fleet";
+    /** Shrinks the scale, never grows it, until the whole drawing fits this many pixels across and down (either may be left out). Without it the scale is `unit`, as it always was. */
+    fit?: {
+        width?: number;
+        height?: number;
+    };
 }
 /**
  * The whole picture as SVG text. Unknown items are left out.
  *
  * @param options The items and how they are drawn.
- * @returns The picture as SVG text, the items it holds, and its width and height.
+ * @returns The picture as SVG text, the items it holds, the real craft lying beside the fleet (`real`, with their lengths), its width and height and the scale it was drawn at (pixels a metre: less than `unit` when `fit` shrank it).
  * @example
  * ```ts
  * import { lineupSvg } from "@johnmorrisdotca/uchusen-rockets/build";
@@ -89,6 +128,13 @@ export interface LineupOptions {
 export declare function lineupSvg(options: LineupOptions): {
     svg: string;
     items: LineupItem[];
+    real: LineupItem[];
     width: number;
     height: number;
+    unit: number;
 };
+/**
+ * The camera of a real craft lying in the fleet band, square on to its windward side: a rocket (`y`) points its nose right with its windward side towards us, and the station (`x`) runs along its long axis with y up. Orthographic at the lineup's scale, so
+ * a metre is the same on it as on every ship.
+ */
+export declare function lyingCamera(axis: "x" | "y", b: Bounds, x0: number, baseY: number, unit: number): Camera;