@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.10.0

package/dist/data/ship02.js

@@ -0,0 +1,100 @@
+// ISV 加美鳴 (かみなり) Kaminari, SPX-207, the Interstellar Heavy Transport, as data. Its status stays "fictional" in the data (the .glb exemption keys on it) and is shown nowhere; every figure names the design bible (docs/fleet/ship-02.md) as its source and
+// none is a measurement of anything real. Sizes are the model's own; the numbers of the voyage are worked out in src/model/fleet/ship-02/journey.ts.
+import {} from "./types.js";
+import { LENGTH } from "../model/fleet/ship-02/dims.js";
+import { SHIP_02_SLOTS, SHIP_02_VARIANT_PARTS } from "../model/fleet/ship-02/index.js";
+import { SECTIONS } from "../model/fleet/ship-02/sections.js";
+import { DECKS, ENGINE_CARDS, HULL_STACK_RING, INSETS, NOTES, SPEC } from "../model/fleet/ship-02/specs.js";
+const S = "uchusen-fleet-ship-02";
+const fig = (value, note) => ({ value, source: S, ...(note ? { note } : {}) });
+export const SHIP_02_LENGTH = fig(LENGTH, "Tail to the tip of the bow mast.");
+const wording = (value, note) => ({ value, source: S, ...(note ? { note } : {}) });
+const t = (n) => (n >= 1e6 ? `${(n / 1e6).toFixed(2)} million t` : `${Math.round(n).toLocaleString("en-US")} t`);
+/** Replace a shell by its inside part where an inset has cut the ship open, so the viewer shows the inside without a cut. */
+const viewerSlots = (slots, cut) => {
+    const insides = new Set(slots.filter((s) => s.endsWith("-inside")).map((s) => s.replace("-inside", "")));
+    return slots.filter((s) => !cut || !(insides.has(s) || (s.startsWith("habitat-") && !s.endsWith("inside") && slots.includes("habitat-inside"))));
+};
+const INSPECTOR = {
+    sections: SECTIONS.map((x) => ({ id: x.id, name: x.name, job: x.job, slot: x.slot, at: x.at, inside: Boolean(x.inside) })),
+    places: Object.fromEntries(SHIP_02_SLOTS.map((slot) => [slot.slot, slot.at])),
+    spec: [
+        ["Name", "ISV 加美鳴 (かみなり) Kaminari, \"thunder\""],
+        ["Role", "大型輸送船, large transport ship"],
+        ["Designation", "SPX-207 · IHT class (Interstellar Heavy Transport)"],
+        ["Operator", "SPX"],
+        ["Drive", "FTD, Fusion Torch Drive, 8 nozzles"],
+        ["Computer", "KAZE core v4"],
+        ["Small craft", "ATC (Auxiliary Transfer Craft)"],
+        ["Status", "Planned: first flight 2520"],
+        ["Length", `${SPEC.length.toLocaleString("en-US")} m`],
+        ["Beam (radiators out)", `${SPEC.beam} m (${SPEC.beamRadiatorsOut} m)`],
+        ["Dry mass", t(SPEC.dryMassT)],
+        ["Full mass", t(SPEC.fullMassT)],
+        ["Crew", `${SPEC.crewNominal} (max ${SPEC.crewMax})`],
+        ["Passengers", SPEC.passengers.toLocaleString("en-US")],
+        ["Cargo", `${t(SPEC.cargoT)}, ${SPEC.containers} containers`],
+        ["Propellant", `${t(SPEC.propellantT)} of ${t(SPEC.tankCapacityT)}`],
+        ...ENGINE_CARDS.map((c) => [c.name, `${c.count} x ${(c.thrustEachN / 1e6).toLocaleString("en-US", { maximumFractionDigits: 2 })} MN, Isp ${Math.round(c.isp).toLocaleString("en-US")} s`]),
+        ["Main thrust", `${(SPEC.mainThrustN / 1e9).toFixed(2)} GN at full mass`],
+        ["Manoeuvring thrust", `${SPEC.maneuverThrustN / 1e6} MN (verniers)`],
+        ["Acceleration", `${SPEC.maxG} g`],
+        ["Cruise / top speed", `${SPEC.cruiseC.toFixed(3)} c / ${SPEC.topC} c`],
+        ["Proxima, 4.37 ly", `${SPEC.proxima.shipYears.toFixed(1)} y on board, ${SPEC.proxima.earthYears.toFixed(1)} y Earth`],
+        ["Range, full payload", `${SPEC.rangeLy} ly`],
+        ["Endurance", `${SPEC.enduranceYears} years sealed`],
+        ["Hull layers (crew rings)", `${HULL_STACK_RING.length}, outside to inside: ${HULL_STACK_RING.map((l) => `${l.n} ${l.name} ${l.thicknessM} m`).join("; ")}`],
+        ["Decks", `${DECKS.length}, bow to stern`],
+    ],
+    notes: { propulsion: NOTES.propulsion, construction: NOTES.construction, history: NOTES.history, equipment: NOTES.equipment },
+    insets: INSETS.map((i) => ({
+        id: i.id,
+        name: i.name,
+        slots: viewerSlots(i.slots, i.cut !== undefined),
+        target: i.view.target,
+        direction: i.view.from,
+        distance: i.view.dist,
+        parts: i.parts.map((p) => ({ n: p.n, name: p.name, at: p.at, slot: "" })),
+    })),
+};
+const STANDARD = {
+    id: "fleet-02",
+    rocket: "fleet-02",
+    name: "ISV 加美鳴 (かみなり) Kaminari, SPX-207",
+    status: "fictional",
+    firstWord: "Planned first flight",
+    firstFlight: { value: "2520", source: S, note: "Planned first flight." },
+    slots: SHIP_02_SLOTS.map((slot) => slot.slot),
+    note: "An original SPX fleet design, drawn in code from the table of numbers in docs/fleet/ship-02.md. The inside parts are the cutaway's contents: show one alone to see it.",
+    inspector: INSPECTOR,
+    facts: {
+        height: SHIP_02_LENGTH,
+        diameter: fig(410, "The bow shield, the widest part of the hull. With both radiator wings out the ship is 910 m across."),
+        parts: Object.fromEntries(SHIP_02_SLOTS.map((slot) => [slot.slot, fig(slot.height)])),
+        engines: { "drive-engines": wording("8 fusion torch nozzles, 4 vernier clusters", "See the design bible for the mechanism and its limits.") },
+        more: {
+            designation: wording("SPX-207", "Interstellar Heavy Transport."),
+            "dry mass, tonnes": fig(1_100_000, "Design target."),
+            "full mass, tonnes": fig(8_450_000, "With 1,000,000 t of payload and 6,350,000 t of propellant."),
+            "width with radiators out, m": fig(910),
+            crew: fig(640),
+            passengers: fig(60000, "24,000 awake in two rings and 36,000 in cold-sleep berths."),
+        },
+    },
+};
+const NAMES = {
+    "fleet-02-survey": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, survey configuration", "Survey pod on the dorsal mount, laboratory pod underneath, relay masts on the wing tips: the same ship for mapping a system."],
+    "fleet-02-tanker": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, tanker configuration", "Tanker pod on the dorsal mount, cargo pod underneath, a tug on each wing tip: the same ship for fuelling a station."],
+    "fleet-02-rescue": ["ISV 加美鳴 (かみなり) Kaminari, SPX-207, rescue configuration", "Settlement pod as a refuge on the dorsal mount, rescue pod underneath, a tug on each wing tip: the same ship for an evacuation."],
+};
+const STANDARD_PARTS = Object.fromEntries(SHIP_02_SLOTS.map((s) => [s.slot, `fleet-02-fleet-02-${s.slot}`]));
+export const SHIP_02_VARIANTS = [
+    STANDARD,
+    ...Object.entries(SHIP_02_VARIANT_PARTS).map(([id, swaps]) => ({
+        ...STANDARD,
+        id,
+        name: NAMES[id][0],
+        note: NAMES[id][1],
+        partIds: { ...STANDARD_PARTS, ...swaps },
+    })),
+];

package/dist/data/sources.d.ts

@@ -29,6 +29,14 @@ export interface Source {
  * ```
  */
 export declare const SOURCES: {
+    readonly "uchusen-design": {
+        readonly title: "The SPX fleet of this package: original ships and modules, drawn by its own code";
+        readonly publisher: "SPX";
+        readonly url: "https://github.com/johnmorrisdotca/uchusen-rockets";
+        readonly date: "2026-11-04";
+        readonly read: "direct";
+        readonly licence: "MIT";
+    };
     readonly "wikipedia-starship": {
         readonly title: "SpaceX Starship (the block table and infobox, read as raw wikitext)";
         readonly publisher: "Wikipedia";
@@ -636,6 +644,14 @@ export declare const SOURCES: {
         readonly date: "2017-05-31";
         readonly read: "direct";
     };
+    readonly "uchusen-fleet-ship-02": {
+        readonly title: "ISV 加美鳴 (かみなり) Kaminari, SPX-207, the Interstellar Heavy Transport: an original SPX fleet design (docs/fleet/ship-02.md)";
+        readonly publisher: "John Morris, uchusen-rockets";
+        readonly url: "https://github.com/johnmorrisdotca/uchusen-rockets/blob/main/docs/fleet/ship-02.md";
+        readonly date: "2026-11-04";
+        readonly read: "direct";
+        readonly licence: "MIT";
+    };
 };
 /**
  * The id of a source in `SOURCES`.

package/dist/data/sources.js

@@ -11,6 +11,7 @@
  * ```
  */
 export const SOURCES = {
+    "uchusen-design": { title: "The SPX fleet of this package: original ships and modules, drawn by its own code", publisher: "SPX", url: "https://github.com/johnmorrisdotca/uchusen-rockets", date: "2026-11-04", read: "direct", licence: "MIT" },
     "wikipedia-starship": { title: "SpaceX Starship (the block table and infobox, read as raw wikitext)", publisher: "Wikipedia", url: "https://en.wikipedia.org/wiki/SpaceX_Starship", date: "2026-10-31", read: "direct", licence: "CC BY-SA 4.0" },
     "wikipedia-super-heavy": { title: "SpaceX Super Heavy", publisher: "Wikipedia", url: "https://en.wikipedia.org/wiki/SpaceX_Super_Heavy", date: "2026-10-31", read: "direct", licence: "CC BY-SA 4.0" },
     "wikipedia-ship": { title: "SpaceX Starship (spacecraft)", publisher: "Wikipedia", url: "https://en.wikipedia.org/wiki/SpaceX_Starship_(spacecraft)", date: "2026-10-31", read: "direct", licence: "CC BY-SA 4.0" },
@@ -89,4 +90,5 @@ export const SOURCES = {
     "sfn-cots1-timeline": { title: "Falcon 9/COTS 1 launch timeline", publisher: "Spaceflight Now", url: "https://spaceflightnow.com/falcon9/002/launchtimeline.html", date: "2010-12-06", read: "direct" },
     "sfn-cots1-presskit": { title: "SpaceX COTS Demo Flight 1 press kit (its mission timeline, page 7)", publisher: "SpaceX, as hosted by Spaceflight Now", url: "https://spaceflightnow.com/falcon9/002/cots1_presskit.pdf", date: "2026-11-03", read: "direct" },
     "sfn-flight-35": { title: "Timeline of SpaceX's 35th Falcon 9 launch", publisher: "Spaceflight Now", url: "https://spaceflightnow.com/?p=24998", date: "2017-05-31", read: "direct" },
+    "uchusen-fleet-ship-02": { title: "ISV 加美鳴 (かみなり) Kaminari, SPX-207, the Interstellar Heavy Transport: an original SPX fleet design (docs/fleet/ship-02.md)", publisher: "John Morris, uchusen-rockets", url: "https://github.com/johnmorrisdotca/uchusen-rockets/blob/main/docs/fleet/ship-02.md", date: "2026-11-04", read: "direct", licence: "MIT" },
 };

package/dist/data/types.d.ts

@@ -75,7 +75,7 @@ export declare function figureWords(figure: Figure<number | string> | undefined,
  * console.log(status);
  * ```
  */
-export type VariantStatus = "flown" | "announced" | "artist-model" | "test-vehicle" | "support";
+export type VariantStatus = "flown" | "announced" | "artist-model" | "test-vehicle" | "support" | "fictional";
 /**
  * The sourced numbers of a variant: its height and diameter, each part's height by slot, its engines, other facts and any sizes that are not a height or a width.
  *
@@ -100,6 +100,62 @@ export interface VariantFacts {
     /** Sizes that are not a height or a width, shown as they are named here: "Deck length". */
     sizes?: Readonly<Record<string, Figure>>;
 }
+/**
+ * One inset of the viewer's panel: a system that opens on a click, the slots that show and the numbered parts.
+ *
+ * @example
+ * ```ts
+ * import { variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(variantOf("ship-02")?.inspector?.insets[0]?.name);
+ * ```
+ */
+export interface InspectorInset {
+    id: string;
+    name: string;
+    /** The slots that show while it is open. */
+    slots: readonly string[];
+    target: readonly [number, number, number];
+    direction: readonly [number, number, number];
+    distance: number;
+    parts: readonly {
+        n: number;
+        name: string;
+        at: readonly [number, number, number];
+        slot: string;
+    }[];
+}
+/**
+ * What the viewer's panel shows for a ship that has one: named sections with leader anchors, a spec table, the notes tabs and the insets that open on a click. Fictional ships only.
+ *
+ * @example
+ * ```ts
+ * import { variantOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(variantOf("ship-02")?.inspector?.sections.length);
+ * ```
+ */
+export interface Inspector {
+    /** Each section: its name, what it does, the part it belongs to and where its label points, in the ship's own metres. */
+    sections: readonly {
+        id: string;
+        name: string;
+        job: string;
+        slot: string;
+        at: readonly [number, number, number];
+        inside: boolean;
+    }[];
+    /** Where each part's origin stands when the ship is together. */
+    places: Readonly<Record<string, readonly [number, number, number]>>;
+    spec: readonly (readonly [string, string])[];
+    /** Spec rows that are links, by the row's name: a click goes to that rocket and variant (the sister ship). */
+    links?: Readonly<Record<string, {
+        rocket: string;
+        variant: string;
+    }>>;
+    notes: Readonly<Record<string, readonly string[]>>;
+    insets: readonly InspectorInset[];
+}
 /**
  * One version of a rocket as data: its id, name, status, first flight, its parts from the bottom up, and the sourced facts about it.
  *
@@ -131,4 +187,6 @@ export interface Variant {
     note?: string;
     /** The side a to-scale lineup shows of it when asked for the front, because the front hides what it is: the orbiter stands behind the Shuttle's tank. */
     lineupView?: "back" | "side";
+    /** The panel that goes with the viewer: sections, specification, notes and insets. */
+    inspector?: Inspector;
 }

package/dist/element/panel.d.ts

@@ -0,0 +1,34 @@
+import type { Inspector } from "../data/types.ts";
+import type { ViewerFocus, ViewerMark } from "./scene.ts";
+export interface PanelHooks {
+    marks: (marks: ViewerMark[] | null) => void;
+    focus: (focus: ViewerFocus | null) => void;
+    /** The 3D view is there: labels and insets need it. */
+    drawn: () => boolean;
+    /** Tells the page the Labels toggle changed. */
+    onLabels: (on: boolean) => void;
+    /** Saves the full-detail model on screen as a .glb file. */
+    download: () => void;
+    /** Goes to another rocket and variant: a spec row that is a link (the sister ship). */
+    go?: (rocket: string, variant: string) => void;
+}
+export declare class Panel {
+    readonly el: HTMLElement;
+    private tab;
+    private labelsOn;
+    private open;
+    private body;
+    private bar;
+    private inspector;
+    private hooks;
+    constructor(inspector: Inspector, hooks: PanelHooks);
+    /** The Labels toggle, set from the page (the `labels` attribute) or the button. */
+    labels(on: boolean): void;
+    /** The 3D view has come in or changed: send the labels again. */
+    refresh(): void;
+    private applyMarks;
+    private button;
+    private render;
+    private table;
+    private renderInsets;
+}

package/dist/element/panel.js

@@ -0,0 +1,144 @@
+const TABS = [
+    ["spec", "Specification"],
+    ["propulsion", "Propulsion and limits"],
+    ["construction", "Construction"],
+    ["history", "History"],
+    ["equipment", "Equipment"],
+    ["insets", "Insets"],
+];
+export class Panel {
+    el;
+    tab = "spec";
+    labelsOn = false;
+    open = null;
+    body;
+    bar;
+    inspector;
+    hooks;
+    constructor(inspector, hooks) {
+        this.inspector = inspector;
+        this.hooks = hooks;
+        this.el = document.createElement("section");
+        this.el.className = "panel";
+        this.el.setAttribute("part", "panel");
+        this.bar = document.createElement("div");
+        this.bar.className = "bar";
+        this.bar.setAttribute("role", "tablist");
+        this.body = document.createElement("div");
+        this.body.className = "body";
+        this.body.setAttribute("role", "tabpanel");
+        this.el.append(this.bar, this.body);
+        this.render();
+    }
+    /** The Labels toggle, set from the page (the `labels` attribute) or the button. */
+    labels(on) {
+        this.labelsOn = on;
+        this.applyMarks();
+        this.render();
+    }
+    /** The 3D view has come in or changed: send the labels again. */
+    refresh() {
+        this.applyMarks();
+    }
+    applyMarks() {
+        if (this.open) {
+            this.hooks.marks(this.open.parts.map((p) => ({ id: `${this.open.id}-${p.n}`, text: String(p.n), at: [...p.at], slot: p.slot, numbered: true })));
+            return;
+        }
+        if (!this.labelsOn)
+            return this.hooks.marks(null);
+        this.hooks.marks(this.inspector.sections
+            .filter((s) => !s.inside)
+            .map((s) => ({ id: s.id, text: s.name, at: [...s.at], slot: s.slot, rest: [...(this.inspector.places[s.slot] ?? s.at)] })));
+    }
+    button(text, extra, onClick) {
+        const b = document.createElement("button");
+        b.type = "button";
+        b.textContent = text;
+        for (const [k, v] of Object.entries(extra))
+            b.setAttribute(k, v);
+        b.addEventListener("click", onClick);
+        return b;
+    }
+    render() {
+        this.bar.replaceChildren();
+        for (const [id, name] of TABS)
+            if (id !== "insets" || this.inspector.insets.length)
+                this.bar.append(this.button(name, { role: "tab", "aria-selected": String(this.tab === id), "data-tab": id }, () => {
+                    this.tab = id;
+                    this.render();
+                }));
+        const toggle = this.button("Labels", { "aria-pressed": String(this.labelsOn), "data-labels": "" }, () => {
+            this.labelsOn = !this.labelsOn;
+            this.hooks.onLabels(this.labelsOn);
+            this.applyMarks();
+            this.render();
+        });
+        if (!this.hooks.drawn())
+            toggle.title = "Labels need the 3D view";
+        this.bar.append(toggle);
+        const save = this.button("Download 3D model", { "data-download": "", title: "Saves the full-detail model on screen as a .glb file" }, () => this.hooks.download());
+        this.bar.append(save);
+        this.body.replaceChildren();
+        if (this.tab === "spec")
+            this.body.append(this.table(this.inspector.spec.map(([a, b]) => [a, b]), this.inspector.links));
+        else if (this.tab === "insets")
+            this.renderInsets();
+        else
+            for (const text of this.inspector.notes[this.tab] ?? []) {
+                const p = document.createElement("p");
+                p.textContent = text;
+                this.body.append(p);
+            }
+    }
+    table(rows, links) {
+        const table = document.createElement("table");
+        for (const [a, b] of rows) {
+            const tr = table.insertRow();
+            const th = document.createElement("th");
+            th.scope = "row";
+            th.textContent = a;
+            tr.append(th);
+            const go = links?.[a];
+            if (go && this.hooks.go) {
+                const link = this.button(b, { "data-go": `${go.rocket}/${go.variant}`, title: "Go to the sister ship" }, () => this.hooks.go?.(go.rocket, go.variant));
+                link.className = "link";
+                tr.insertCell().append(link);
+            }
+            else
+                tr.insertCell().textContent = b;
+        }
+        return table;
+    }
+    renderInsets() {
+        if (this.open) {
+            const inset = this.open;
+            const back = this.button("Back to the whole ship", { "data-back": "" }, () => {
+                this.open = null;
+                this.hooks.focus(null);
+                this.applyMarks();
+                this.render();
+            });
+            const h = document.createElement("p");
+            h.textContent = inset.name;
+            h.style.fontWeight = "600";
+            this.body.append(h, this.table(inset.parts.map((p) => [String(p.n), p.name])), back);
+            return;
+        }
+        const note = document.createElement("p");
+        note.textContent = this.hooks.drawn() ? "Choose a system to fly to it, with its numbered parts." : "Insets open in the 3D view.";
+        this.body.append(note);
+        for (const inset of this.inspector.insets) {
+            const b = this.button(inset.name, { "data-inset": inset.id }, () => {
+                if (!this.hooks.drawn())
+                    return;
+                this.open = inset;
+                this.hooks.focus({ slots: inset.slots, target: [...inset.target], direction: [...inset.direction], distance: inset.distance });
+                this.applyMarks();
+                this.render();
+            });
+            b.disabled = !this.hooks.drawn();
+            this.body.append(b);
+        }
+    }
+}

package/dist/element/scene.d.ts

@@ -1,18 +1,37 @@
 import type { Built } from "../build/index.ts";
-import { type Angle, type ViewChoice } from "../framing.ts";
+import { type Angle, type Vec3, type ViewChoice } from "../framing.ts";
 import { type LookName } from "../looks.ts";
 import { type FlightClock } from "../flight.ts";
 import type { Spin } from "../spin.ts";
+/** A label on a part: its text, where it points in the ship's own metres, the part it follows and where that part stands at rest (so the label moves with it). `number` draws a numbered disc. */
+export interface ViewerMark {
+    id: string;
+    text: string;
+    at: Vec3;
+    slot: string;
+    rest?: Vec3;
+    numbered?: boolean;
+}
+export interface ViewerFocus {
+    slots: readonly string[];
+    target: Vec3;
+    direction: Vec3;
+    distance: number;
+}
 export interface ViewerOptions {
     label: string;
     reducedMotion: boolean;
     onLost: () => void;
+    /** Said once, when the camera first comes near what is on screen: the page may then build the fine detail. */
+    onNear?: () => void;
     /** Where the licensed models are. */
     assets: string;
     /** Tells the page which painted parts have come in, or "" when the look is not painted. */
     onPainted: (state: string) => void;
     /** Tells the page a timeline moved. */
     onFlight?: () => void;
+    /** Tells the page the view was drawn, so labels that follow a part can move with it. */
+    onDraw?: () => void;
 }
 export declare class RocketViewer {
     readonly canvas: HTMLCanvasElement;
@@ -28,6 +47,9 @@ export declare class RocketViewer {
     private built;
     private look;
     private show;
+    private sun;
+    /** The fleet is lit with a shadow: its ships are big enough for one part to fall on another. A rocket is not, so it keeps the one light it has. */
+    private shadows;
     private plumes;
     private lit;
     /** What was lit before a flight took over the engines. */
@@ -44,6 +66,9 @@ export declare class RocketViewer {
     private burnSlots;
     private generation;
     private materialCache;
+    /** The materials that glow when the engines are lit, and whether they do now. */
+    private glowing;
+    private glowOn;
     private outlineMaterial;
     private textures;
     private steelMap;
@@ -65,6 +90,11 @@ export declare class RocketViewer {
     private compiling;
     private compiled;
     private settled;
+    private marks;
+    private markHost;
+    private focusing;
+    private nearSaid;
+    private nearAt;
     constructor(holder: HTMLElement, options: ViewerOptions);
     private homeAngle;
     setLabel(label: string): void;
@@ -112,6 +142,8 @@ export declare class RocketViewer {
     private useModel;
     /** Behind a licensed model this package's code shows nothing, except the nozzle the model lacks, and not while the stage is nested in the one below. */
     private showCode;
+    /** The key light looks at the middle of what shows, from far enough to take in all of it, and its shadow map covers just that. */
+    private fitShadow;
     /** Together, apart, or one part alone: an animated move, or a cut under reduced motion. */
     setShow(show: string): void;
     private framingFor;
@@ -122,6 +154,12 @@ export declare class RocketViewer {
     private startPose;
     private finishParts;
     /** Where the camera is looking from. */
+    /** Where a point of what shows, in metres, falls on the canvas in CSS pixels, and whether it is in front of the camera and inside the picture. A label that follows a part asks for it each time the view is drawn. */
+    screenPoint(point: Vec3): {
+        x: number;
+        y: number;
+        visible: boolean;
+    };
     currentAngle(): Angle;
     /** Turns to look from an angle. */
     setAngle(angle: Angle, animate: boolean): void;
@@ -149,6 +187,12 @@ export declare class RocketViewer {
     private onVisibility;
     private touched;
     private wake;
+    /** Labels on the parts: each follows its part as the model turns, hides with its part, and gives way to a label drawn before it that it would cover. Null takes them away. */
+    setMarks(marks: readonly ViewerMark[] | null): void;
+    /** Put the labels where their parts are now. */
+    private placeMarks;
+    /** Show only some slots and fly to look at them: an inset. Null puts the ship back as it was. */
+    focusOn(focus: ViewerFocus | null): void;
     private tick;
     private syncSizes;
     private fit;