@johnmorrisdotca/uchusen-rockets 0.3.0 → 0.5.0

package/dist/framing.js

@@ -1,11 +1,69 @@
 // Where the camera stands. One rule for the drawing and the 3D view, so the drawing turns into the 3D view without a jump. Pure, in metres.
-/** The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long. */
+/**
+ * The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long.
+ *
+ * @example
+ * ```ts
+ * import { FOV_DEG } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(FOV_DEG);
+ * ```
+ */
 export const FOV_DEG = 24;
-/** The picture's shape. */
+/**
+ * The width of the picture a drawing is made in, in drawing units.
+ *
+ * @example
+ * ```ts
+ * import { PICTURE_W, PICTURE_H } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(PICTURE_W, PICTURE_H);
+ * ```
+ */
 export const PICTURE_W = 480;
+/**
+ * The height of the picture a drawing is made in, in drawing units.
+ *
+ * @example
+ * ```ts
+ * import { PICTURE_H } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(PICTURE_H);
+ * ```
+ */
 export const PICTURE_H = 640;
+/**
+ * The names of the views, in the order the demo lists them: `three-quarter`, `front`, `back`, `side` and `below`.
+ *
+ * @example
+ * ```ts
+ * import { VIEW_NAMES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(VIEW_NAMES.join(", "));
+ * ```
+ */
 export const VIEW_NAMES = ["three-quarter", "front", "back", "side", "below"];
+/**
+ * The view used when none is named or the name is not a view: `three-quarter`.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_VIEW } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(DEFAULT_VIEW);
+ * ```
+ */
 export const DEFAULT_VIEW = "three-quarter";
+/**
+ * The angle of each named view.
+ *
+ * @example
+ * ```ts
+ * import { VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(VIEWS.front, VIEWS.below);
+ * ```
+ */
 export const VIEWS = {
     "three-quarter": { az: 32, el: 9 },
     front: { az: 0, el: 3 },
@@ -13,13 +71,49 @@ export const VIEWS = {
     side: { az: 90, el: 3 },
     below: { az: 24, el: -70 },
 };
+/**
+ * A value from outside as a view's name.
+ *
+ * @param value Anything.
+ * @returns The name if it is one of the views, and `three-quarter` for anything else.
+ * @example
+ * ```ts
+ * import { cleanView } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(cleanView("side"), cleanView("sideways"), cleanView(42));
+ * ```
+ */
 export const cleanView = (value) => (VIEW_NAMES.includes(value) ? value : DEFAULT_VIEW);
 export const deg = (d) => (d * Math.PI) / 180;
-/** What the family's view controls choose: the turn and tip, in degrees, from a base angle. Dragging right makes `yaw` larger, which carries the camera the other way round; `tilt` larger tips the top away, which lowers the camera. */
+/**
+ * What the family's view controls choose: the turn and tip, in degrees, from a base angle. Dragging right makes `yaw` larger, which carries the camera the other way round; `tilt` larger tips the top away, which lowers the camera.
+ *
+ * @param base The angle to turn from.
+ * @param yaw Degrees turned round.
+ * @param tilt Degrees tipped up or down.
+ * @returns The new angle.
+ * @example
+ * ```ts
+ * import { turnedBy, VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(turnedBy(VIEWS.front, 30, 10));
+ * ```
+ */
 export function turnedBy(base, yaw, tilt) {
     return { az: base.az - yaw, el: Math.min(87, Math.max(-87, base.el - tilt)) };
 }
-/** The unit vector from what is looked at towards the camera. */
+/**
+ * The unit vector from what is looked at towards the camera.
+ *
+ * @param angle The angle to look from.
+ * @returns A unit vector.
+ * @example
+ * ```ts
+ * import { directionOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(directionOf({ az: 0, el: 0 }));
+ * ```
+ */
 export function directionOf({ az, el }) {
     const c = Math.cos(deg(el));
     return [c * Math.sin(deg(az)), Math.sin(deg(el)), c * Math.cos(deg(az))];
@@ -30,14 +124,41 @@ const unit = (a) => {
     const l = Math.hypot(...a) || 1;
     return [a[0] / l, a[1] / l, a[2] / l];
 };
-/** The camera's own axes for looking along `direction`, with up as near to +Y as it can be. */
+/**
+ * The camera's own axes for looking along `direction`, with up as near to +Y as it can be.
+ *
+ * @param direction The direction from the target to the camera.
+ * @returns The camera's right, up and forward axes.
+ * @example
+ * ```ts
+ * import { axesOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(axesOf([0, 0, 1]));
+ * ```
+ */
 export function axesOf(direction) {
     const forward = [-direction[0], -direction[1], -direction[2]];
     const near = Math.abs(forward[1]) > 0.999;
     const right = unit(cross(forward, near ? [0, 0, -1] : [0, 1, 0]));
     return { right, up: cross(right, forward), forward };
 }
-/** The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`. */
+/**
+ * The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`.
+ *
+ * @param min The lowest corner of the box to hold.
+ * @param max The highest corner.
+ * @param angle The angle to look from.
+ * @param aspect The picture's width over its height.
+ * @param margin Room left round the box, as a multiple. Defaults to 1.08.
+ * @returns The camera that holds the whole box.
+ * @example
+ * ```ts
+ * import { frameFor, VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const framing = frameFor([-4.5, 0, -4.5], [4.5, 124, 4.5], VIEWS.front, 480 / 640);
+ * console.log(framing.target, framing.distance.toFixed(0));
+ * ```
+ */
 export function frameFor(min, max, angle, aspect, margin = 1.08) {
     const target = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
     const direction = directionOf(angle);

package/dist/index.d.ts

@@ -6,6 +6,9 @@ export { MAKERS } from "./data/makers.ts";
 export type { MakerId } from "./data/makers.ts";
 export { FLIGHT_LOG, flightLogOf } from "./data/flight-log.ts";
 export type { LoggedFlight } from "./data/flight-log.ts";
+export { moved, movingGroupsOf } from "./model/moves.ts";
+export { PROPELLANTS, propellantOf } from "./data/propellants.ts";
+export type { EnginePropellant, FlameKind } from "./data/propellants.ts";
 export { SOURCES } from "./data/sources.ts";
 export type { Source, SourceId } from "./data/sources.ts";
 export { creditLine, MODEL_CREDITS } from "./data/credits.ts";

package/dist/index.js

@@ -3,6 +3,8 @@ export { PLANNED_ROCKETS, ROCKETS, partIdOf, SLOT_NAMES, variantOf } from "./roc
 export { blank, figureWords } from "./data/types.js";
 export { MAKERS } from "./data/makers.js";
 export { FLIGHT_LOG, flightLogOf } from "./data/flight-log.js";
+export { moved, movingGroupsOf } from "./model/moves.js";
+export { PROPELLANTS, propellantOf } from "./data/propellants.js";
 export { SOURCES } from "./data/sources.js";
 export { creditLine, MODEL_CREDITS } from "./data/credits.js";
 export { PART_ENTRIES, partEntry } from "./model/registry.js";

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));

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;
@@ -20,6 +62,27 @@ export interface Look {
     halo: boolean;
 }
 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"],
@@ -10,6 +30,16 @@ const NIGHT = {
     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 },
@@ -34,5 +64,16 @@ export const LOOKS = {
         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/falcon.js

@@ -56,11 +56,11 @@ function firstStage(d, withTop) {
     if (d.legs)
         for (const az of [45, 135, 225, 315]) {
             const frame = radial(deg(az));
-            pieces.push({ kind: "plate", material: "black", frame, outline: [[r - 0.05, 0.8], [r + 0.5, 0.8], [r + 0.55, 3], [r + 0.15, 10.5], [r - 0.05, 11]], thickness: 1.2 });
+            pieces.push({ kind: "plate", material: "black", frame, outline: [[r - 0.05, 0.8], [r + 0.5, 0.8], [r + 0.55, 3], [r + 0.15, 10.5], [r - 0.05, 11]], thickness: 1.2, move: { name: "legs", pivot: pointOf(frame, r + 0.2, 0.8), axis: frame.w } });
         }
     if (d.fins)
         for (const az of [45, 135, 225, 315])
-            pieces.push(...gridFin(az, tank + 0.1, r, r + 1.4, 1.5, 0.3, false));
+            pieces.push(...gridFin(az, tank + 0.1, r, r + 1.4, 1.5, 0.3, false, { name: "grid-fins", about: "tangent" }));
     return pieces;
 }
 function secondStage(d) {

package/dist/model/materials.d.ts

@@ -1,4 +1,15 @@
 import type { FillName } from "../looks.ts";
+/**
+ * One material: its colour, how metal and how rough it is in a 3D view, and the fill group it takes in a drawing.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS, type MaterialSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const steel: MaterialSpec = MATERIALS.steel;
+ * console.log(steel.color, steel.fill);
+ * ```
+ */
 export interface MaterialSpec {
     color: string;
     metal: number;
@@ -6,6 +17,16 @@ export interface MaterialSpec {
     /** The fill it takes in a drawing. */
     fill: FillName;
 }
+/**
+ * Every material the meshes use, by name. One naming scheme serves every source.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(MATERIALS).length > 5);
+ * ```
+ */
 export declare const MATERIALS: {
     readonly steel: {
         readonly color: "#c3c7cb";
@@ -152,4 +173,15 @@ export declare const MATERIALS: {
         readonly fill: "metal";
     };
 };
+/**
+ * The name of one material in `MATERIALS`.
+ *
+ * @example
+ * ```ts
+ * import type { MaterialName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const name: MaterialName = "steel";
+ * console.log(name);
+ * ```
+ */
 export type MaterialName = keyof typeof MATERIALS;

package/dist/model/materials.js

@@ -1,3 +1,13 @@
+/**
+ * Every material the meshes use, by name. One naming scheme serves every source.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(MATERIALS).length > 5);
+ * ```
+ */
 export const MATERIALS = {
     steel: { color: "#c3c7cb", metal: 1, rough: 0.3, fill: "hull" },
     tile: { color: "#101114", metal: 0, rough: 0.62, fill: "tile" },

package/dist/model/moves.d.ts

@@ -0,0 +1,36 @@
+import type { Piece, Vec3 } from "./pieces.ts";
+/** A direction turned by `degrees` right-handed about `axis` (Rodrigues' rotation). */
+export declare function turnedVector(v: Vec3, axis: Vec3, degrees: number): Vec3;
+/** A point turned about a pivot. */
+export declare function turnedPoint(p: Vec3, pivot: Vec3, axis: Vec3, degrees: number): Vec3;
+/**
+ * The pieces with each moving group turned by the angle its name has in `angles` (degrees, 0 where it has none). A turned piece no longer carries its `move`: it is drawn where it stands. A body of revolution cannot turn, and is left as it is.
+ *
+ * @param pieces The pieces of a part.
+ * @param angles Degrees by the name of a moving group, such as `grid-fins`.
+ * @returns The pieces, with the moving groups turned.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { movingGroupsOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const booster = build({ rocket: "starship", variant: "v3" }).parts[0];
+ * console.log(booster ? movingGroupsOf(booster.pieces) : []);
+ * ```
+ */
+export declare function moved(pieces: readonly Piece[], angles: Readonly<Record<string, number>>): readonly Piece[];
+/**
+ * The names of the groups a part has that a flight can turn.
+ *
+ * @param pieces The pieces of a part.
+ * @returns The distinct names, in the order they come.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { movingGroupsOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const stage = build({ rocket: "falcon-9", variant: "block-5" }).parts[0];
+ * console.log(stage ? movingGroupsOf(stage.pieces) : []);
+ * ```
+ */
+export declare function movingGroupsOf(pieces: readonly Piece[]): string[];

package/dist/model/moves.js

@@ -0,0 +1,70 @@
+const unit = (v) => {
+    const length = Math.hypot(...v) || 1;
+    return [v[0] / length, v[1] / length, v[2] / length];
+};
+/** A direction turned by `degrees` right-handed about `axis` (Rodrigues' rotation). */
+export function turnedVector(v, axis, degrees) {
+    const k = unit(axis);
+    const a = (degrees * Math.PI) / 180;
+    const cos = Math.cos(a);
+    const sin = Math.sin(a);
+    const dot = k[0] * v[0] + k[1] * v[1] + k[2] * v[2];
+    const cross = [k[1] * v[2] - k[2] * v[1], k[2] * v[0] - k[0] * v[2], k[0] * v[1] - k[1] * v[0]];
+    return [v[0] * cos + cross[0] * sin + k[0] * dot * (1 - cos), v[1] * cos + cross[1] * sin + k[1] * dot * (1 - cos), v[2] * cos + cross[2] * sin + k[2] * dot * (1 - cos)];
+}
+/** A point turned about a pivot. */
+export function turnedPoint(p, pivot, axis, degrees) {
+    const d = turnedVector([p[0] - pivot[0], p[1] - pivot[1], p[2] - pivot[2]], axis, degrees);
+    return [pivot[0] + d[0], pivot[1] + d[1], pivot[2] + d[2]];
+}
+const turnedFrame = (f, move, degrees) => ({
+    o: turnedPoint(f.o, move.pivot, move.axis, degrees),
+    u: turnedVector(f.u, move.axis, degrees),
+    v: turnedVector(f.v, move.axis, degrees),
+    w: turnedVector(f.w, move.axis, degrees),
+});
+/**
+ * The pieces with each moving group turned by the angle its name has in `angles` (degrees, 0 where it has none). A turned piece no longer carries its `move`: it is drawn where it stands. A body of revolution cannot turn, and is left as it is.
+ *
+ * @param pieces The pieces of a part.
+ * @param angles Degrees by the name of a moving group, such as `grid-fins`.
+ * @returns The pieces, with the moving groups turned.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { movingGroupsOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const booster = build({ rocket: "starship", variant: "v3" }).parts[0];
+ * console.log(booster ? movingGroupsOf(booster.pieces) : []);
+ * ```
+ */
+export function moved(pieces, angles) {
+    if (!pieces.some((piece) => piece.move && angles[piece.move.name]))
+        return pieces;
+    return pieces.map((piece) => {
+        const move = piece.move;
+        const degrees = move ? (angles[move.name] ?? 0) : 0;
+        if (!move || degrees === 0 || piece.kind === "lathe")
+            return piece;
+        if (piece.kind === "plate")
+            return { ...piece, move: undefined, frame: turnedFrame(piece.frame, move, degrees) };
+        return { ...piece, move: undefined, paths: piece.paths.map((path) => path.map((p) => turnedPoint(p, move.pivot, move.axis, degrees))) };
+    });
+}
+/**
+ * The names of the groups a part has that a flight can turn.
+ *
+ * @param pieces The pieces of a part.
+ * @returns The distinct names, in the order they come.
+ * @example
+ * ```ts
+ * import { build } from "@johnmorrisdotca/uchusen-rockets/build";
+ * import { movingGroupsOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const stage = build({ rocket: "falcon-9", variant: "block-5" }).parts[0];
+ * console.log(stage ? movingGroupsOf(stage.pieces) : []);
+ * ```
+ */
+export function movingGroupsOf(pieces) {
+    return [...new Set(pieces.flatMap((piece) => (piece.move ? [piece.move.name] : [])))];
+}