@treewyrm/freelancer-webgl2 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4452 @@
+import { Matrix3, Matrix4, Quat, RingShape, Shape, Vector3, Vector4 } from "@treewyrm/freelancer/math";
+import { AnimatedColor, AnimatedCurve, AnimatedFloat, AnimatedTransform, Blending, Effect, Node, NodeInstance } from "@treewyrm/freelancer/alchemy";
+import { Primitive, VMeshData, VMeshPart, VMeshRef, VertexFormat } from "@treewyrm/freelancer/vmesh";
+import { Bone, DeformableModel, Level } from "@treewyrm/freelancer/deformable";
+import { CompoundNode, Hardpoint, Joint, JointState } from "@treewyrm/freelancer/compound";
+import { Material } from "@treewyrm/freelancer/material";
+import { MaterialAnim, MaterialAnimLibrary, MeshSource, RigidModel, RigidPart, Sphere } from "@treewyrm/freelancer/rigid";
+import { Surface } from "@treewyrm/freelancer/surface";
+import { AudioProps, Entity, Event, EventTypeName, FogProps, LightProps, ParamCurve, PathProps, Script } from "@treewyrm/freelancer/thn/scene";
+import { AnimationScript } from "@treewyrm/freelancer/animation";
+import { CubeTexture, Texture, TextureEntry } from "@treewyrm/freelancer/texture";
+/** Acquires a WebGL2 context, or throws: the renderer has no fallback for its absence. */
+export declare const createContext: (canvas: HTMLCanvasElement | OffscreenCanvas, options?: WebGLContextAttributes) => WebGL2RenderingContext;
+/** A linked program and its uniform locations. `null` is GL's own: optimized out by the driver. */
+interface Program<U extends string = string> {
+  handle: WebGLProgram;
+  uniforms: Record<U, WebGLUniformLocation | null>;
+}
+/** Compiles and links GLSL ES 3.00 sources, looking up the named uniforms once. */
+export declare const createProgram: <U extends string = never>(gl: WebGL2RenderingContext, vertexSource: string, fragmentSource: string, uniforms?: readonly U[]) => Program<U>;
+interface Common {
+  name: string;
+  /** Absent, 3 (`0x623f7b0`). `FLT_MAX` and `Infinity` both mean never. */
+  lifeSpan: number;
+  transform?: AnimatedTransform;
+}
+interface EmitterCommon extends Common {
+  category: 'emitter';
+  lodCurve?: AnimatedFloat;
+  /** Signed: one retail cone holds `0xCDCDCDCD`, which the DLL adds as it stands (`0x6245cf6`). */
+  initialParticles: number;
+  frequency?: AnimatedCurve;
+  maxParticles?: AnimatedCurve;
+  initLifeSpan?: AnimatedCurve;
+  pressure?: AnimatedCurve;
+  emitCount?: AnimatedCurve;
+  velocityApproach?: AnimatedCurve;
+}
+interface CubeEmitter extends EmitterCommon {
+  kind: 'cube-emitter';
+  width?: AnimatedCurve;
+  height?: AnimatedCurve;
+  depth?: AnimatedCurve;
+  minSpread?: AnimatedCurve;
+  maxSpread?: AnimatedCurve;
+}
+interface SphereEmitter extends EmitterCommon {
+  kind: 'sphere-emitter';
+  minRadius?: AnimatedCurve;
+  maxRadius?: AnimatedCurve;
+}
+interface ConeEmitter extends EmitterCommon {
+  kind: 'cone-emitter';
+  minRadius?: AnimatedCurve;
+  maxRadius?: AnimatedCurve;
+  minSpread?: AnimatedCurve;
+  maxSpread?: AnimatedCurve;
+}
+interface Sprite {
+  color?: AnimatedColor;
+  alpha?: AnimatedFloat;
+  texture?: string;
+  blend?: Blending;
+  texFrame?: AnimatedFloat;
+  commonTexFrame?: AnimatedCurve;
+  useCommonTexFrame: boolean;
+  flipU: boolean;
+  flipV: boolean;
+}
+interface AppearanceCommon extends Common {
+  category: 'appearance';
+  lodCurve?: AnimatedFloat;
+}
+interface BasicAppearance extends AppearanceCommon, Sprite {
+  kind: 'basic-appearance';
+  triTexture: boolean;
+  quadTexture: boolean;
+  motionBlur: boolean;
+  size?: AnimatedFloat;
+  rotate?: AnimatedFloat;
+  aspect?: AnimatedFloat;
+}
+interface DustAppearance extends AppearanceCommon, Sprite {
+  kind: 'dust-appearance';
+  size?: AnimatedFloat;
+}
+interface PerpAppearance extends AppearanceCommon, Sprite {
+  kind: 'perp-appearance';
+  size?: AnimatedFloat;
+  viewingAngleFade: boolean;
+}
+interface RectAppearance extends AppearanceCommon, Sprite {
+  kind: 'rect-appearance';
+  motionBlur: boolean;
+  centerOnPos: boolean;
+  viewingAngleFade: boolean;
+  scale?: AnimatedFloat;
+  length?: AnimatedFloat;
+  width?: AnimatedFloat;
+}
+interface BeamAppearance extends AppearanceCommon, Sprite {
+  kind: 'beam-appearance';
+  quadTexture: boolean;
+  disablePlaceHolder: boolean;
+  dupeFirstParticle: boolean;
+  scale?: AnimatedFloat;
+  width?: AnimatedFloat;
+}
+interface OrientedAppearance extends AppearanceCommon, Sprite {
+  kind: 'oriented-appearance';
+  scale?: AnimatedFloat;
+  width?: AnimatedFloat;
+  height?: AnimatedFloat;
+  viewingAngleFade: boolean;
+  /** Keyed on each particle's age, on top of its position (`0x622c6dd`). */
+  particleTransform?: AnimatedTransform;
+}
+interface ParticleAppearance extends AppearanceCommon {
+  kind: 'particle-appearance';
+  lifeName?: string;
+  deathName?: string;
+  useDynamicRotation: boolean;
+  smoothRotation: boolean;
+}
+interface MeshAppearance extends AppearanceCommon {
+  kind: 'mesh-appearance';
+}
+interface FieldCommon extends Common {
+  category: 'field';
+}
+interface RadialField extends FieldCommon {
+  kind: 'radial-field';
+  radius?: AnimatedCurve;
+  attenuation?: AnimatedFloat;
+  magnitude?: AnimatedCurve;
+  approach?: AnimatedCurve;
+}
+interface CollideField extends FieldCommon {
+  kind: 'collide-field';
+  reflectivity?: AnimatedCurve;
+}
+interface TurbulenceField extends FieldCommon {
+  kind: 'turbulence-field';
+  magnitude?: AnimatedCurve;
+  approach?: AnimatedCurve;
+}
+interface AirField extends FieldCommon {
+  kind: 'air-field';
+  magnitude?: AnimatedCurve;
+  approach?: AnimatedCurve;
+}
+interface GravityField extends FieldCommon {
+  kind: 'gravity-field';
+  gravity?: AnimatedCurve;
+}
+interface DustField extends FieldCommon {
+  kind: 'dust-field';
+  maxRadius?: AnimatedCurve;
+}
+interface BeamField extends FieldCommon {
+  kind: 'beam-field';
+}
+interface FolderNode extends Common {
+  category: 'folder';
+  kind: 'folder';
+}
+type NodeDescriptor = CubeEmitter | SphereEmitter | ConeEmitter | BasicAppearance | DustAppearance | PerpAppearance | RectAppearance | BeamAppearance | OrientedAppearance | ParticleAppearance | MeshAppearance | RadialField | CollideField | TurbulenceField | AirField | GravityField | DustField | BeamField | FolderNode;
+type Appearance = Extract<NodeDescriptor, {
+  category: 'appearance';
+}>;
+interface EffectNode {
+  /** The file's entry this came from, which is how a host names it. */
+  instance: NodeInstance;
+  /** What a CRC resolves to. A flagged entry is a folder and never looked up (`0x621efe7`). */
+  descriptor?: NodeDescriptor;
+  /** The CRC, as text, when it resolved to nothing or to a type no DLL registers. */
+  missing?: string;
+  /** Index in `EffectScene.nodes`, or -1 at the top level. */
+  parent: number;
+  /** In the order they're inserted into their parent, which is entry order. */
+  children: number[];
+  /** From the `Pair` records, in file order. */
+  targets: number[];
+  /** Sorts siblings: appearances 100, fields 200, emitters 300, folders 400 (`+0x38`). */
+  key: number;
+}
+interface EffectScene {
+  name: string;
+  nodes: EffectNode[];
+  /** Top-level nodes, in entry order. */
+  top: number[];
+  /** The node a placement reaches, or none, in which case every top-level node takes it. */
+  root?: number;
+}
+/** Finds a node by CRC. The namespace is one across all loaded files, so which file is the host's. */
+type ResolveNode = (crc: number) => Node | undefined;
+/** An effect by name, for `FxParticleAppearance`. Names no library defines mean no particle. */
+type EffectLookup = (name: string) => EffectScene | undefined;
+export declare const buildEffect: (effect: Effect, resolve: ResolveNode) => EffectScene;
+/** Builds and caches effects by name, the first of a name winning. */
+export declare const lookupOver: (effects: readonly Effect[], resolve: ResolveNode) => EffectLookup;
+/** How many of a kind the game's pool holds, from `dacom.ini`. A full one evicts its oldest. */
+type PoolSizes = Readonly<Record<Appearance['kind'], number>>;
+export declare const RETAIL_POOLS: PoolSizes;
+/** Where evictions are counted, and the random stream. Effects sharing one compete as in the game. */
+interface EffectPools {
+  sizes: PoolSizes;
+  held: Map<Appearance['kind'], Set<AppearanceNode>>;
+  serial: number;
+  rngState: number;
+  rngCount: number;
+}
+export declare const createPools: (seed?: number, sizes?: PoolSizes) => EffectPools;
+interface RunContext {
+  pools: EffectPools;
+  lookup?: EffectLookup;
+  sparam: number;
+  lod: number;
+}
+interface EffectRun {
+  context: RunContext;
+  scene: EffectScene;
+  nodes: RunNode[];
+  top: RunNode[];
+  root?: RunNode;
+}
+interface RunNode {
+  run: EffectRun;
+  index: number;
+  key: number;
+  descriptor?: NodeDescriptor;
+  parent?: RunNode;
+  children: RunNode[];
+  age: number;
+  lifeSpan: number;
+  /** Marked by `+0x5c`: it no longer updates or draws. */
+  dead: boolean;
+  world: Matrix4;
+  /** `+0xc(1, M)`: `parent · override · local`, how a cutscene's placement reaches its node. */
+  override?: Matrix4;
+  /**
+   * `+0xc(0, M)`: the node's world for the next compose, outright, its parent and its own transform
+   * left out (`alchemy!0x624012a`, `0x62401b1`). How every in-flight effect is placed.
+   */
+  placed?: Matrix4;
+  update: (dt: number) => boolean;
+  died?: () => void;
+}
+/** What a field holds between its update and an appearance reading it. */
+type FieldState = {
+  kind: 'gravity-field';
+  change: number;
+} | {
+  kind: 'air-field';
+  magnitude: number;
+  blend: number;
+} | {
+  kind: 'turbulence-field';
+  magnitude: number;
+  blend: number;
+} | {
+  kind: 'radial-field';
+  magnitude: number;
+  inverseRadius: number;
+  attenuation?: AnimatedFloat;
+  blend: number;
+} | {
+  kind: 'collide-field';
+  reflectivity: number;
+  dt: number;
+} | {
+  kind: 'dust-field';
+  radius: number;
+} | {
+  kind: 'beam-field';
+};
+interface FieldNode extends RunNode {
+  state: FieldState;
+}
+/** A run of a lane's records, in emission order, with the holes a ballistic lane leaves. */
+interface Lane {
+  records: Float32Array;
+  capacity: number;
+  /** Up to here is gone. */
+  tail: number;
+  head: number;
+  count: number;
+  /** Pushed each step, so `born == clock` and the vertex stage reads records as they stand. */
+  stepped: boolean;
+  /** Seconds since it last rebased, so a float stays exact. Only `clock - BORN` means anything. */
+  clock: number;
+  /** Bumped when records already uploaded change. */
+  version: number;
+  /** Births, whose parity is the beam's texture mirror. */
+  births: number;
+}
+interface ParticleRecord {
+  state: Float32Array;
+  lifeRun: EffectRun;
+  deathRun?: EffectRun;
+  blend: Vector4;
+}
+interface AppearanceNode extends RunNode {
+  descriptor: Appearance;
+  /** How many emitters feed it (`+0xb0`): none, and nothing held, and it's done. */
+  refs: number;
+  fields: FieldNode[];
+  lane?: Lane;
+  records?: ParticleRecord[];
+}
+interface AdvanceOptions {
+  /** The outer key of every animated property. 0 when absent, as the game's engine-less effects. */
+  sparam?: number;
+  /** `[EffectLOD]`'s key. 1 when absent, what the game shows close up. */
+  lod?: number;
+  /** Where the host has the effect: reaches its control root, or else every top-level node. */
+  placement?: Matrix4;
+  /**
+   * How {@link placement} lands. `world`, every in-flight effect's (`ParticleEffect`,
+   * `Freelancer!0x4f8baa`), replaces the node's world outright, so a rootless effect's top-level
+   * transform is never applied. `override`, a cutscene's (`Thorn_Psys`), is `parent · M · local`.
+   */
+  placing?: 'world' | 'override';
+  /** The camera's world to view, which the dust's streak and fade read. */
+  view?: Matrix4;
+}
+export declare class EffectInstance {
+  #private;
+  readonly top: RunNode[];
+  readonly context: RunContext;
+  /** Seconds, the effect's clock, which is also its top nodes' age. */
+  time: number;
+  /** `view` as given to the last advance, and the one before, for the dust. */
+  view?: Matrix4;
+  previousView?: Matrix4;
+  lastStep: number;
+  cameraTravel: number;
+  previousTravel: number;
+  constructor(scene: EffectScene, { lookup, pools }?: {
+    lookup?: EffectLookup;
+    pools?: EffectPools;
+  });
+  /**
+   * No live appearance: what the game asks before dropping an effect (`+0x2c(4)`,
+   * `Freelancer!0x4f8a88`). An emitter, field or folder still alive doesn't keep it.
+   */
+  get finished(): boolean;
+  /** Its emitters stop, and what they made lives out (`+0x34(1)`, `0x4f84d0`). */
+  stop(): void;
+  /**
+   * Gone: every node dies at once, and what it held leaves the pools, as the game releases the Alchemy
+   * instance of an effect it destroys. One dropped without this keeps its share of the pools, and
+   * every later birth counts it.
+   */
+  release(): void;
+  /**
+   * Every live particle, in sub-effects too: which appearance holds it, its age and span, and where it
+   * stands and heads in the world, as the sprite's vertex stage carries a record to now.
+   */
+  eachParticle(visit: (node: EffectNode, age: number, life: number, position: Vector3, velocity: Vector3) => void): void;
+  /** One of the game's frames, at the step the host chooses (`0x4f8a20`). */
+  advance(dt: number, { sparam, lod, placement, placing, view }?: AdvanceOptions): void;
+}
+interface UVRect {
+  u1: number;
+  v1: number;
+  u2: number;
+  v2: number;
+}
+interface EffectDrawCommon {
+  /** The appearance, as its file names it. */
+  node: EffectNode;
+  /** The appearance's world, as last composed: the game draws with it unadvanced. */
+  world: Matrix4;
+  texture?: {
+    name: string;
+    entry: Texture;
+  };
+  blend?: Blending;
+}
+/** The lists a sprite reads, keyed in the vertex stage by each particle's age. */
+interface SpriteLists {
+  kind: number;
+  color?: AnimatedColor;
+  alpha?: AnimatedFloat;
+  a?: AnimatedFloat;
+  b?: AnimatedFloat;
+  c?: AnimatedFloat;
+  roll?: AnimatedFloat;
+  frame?: AnimatedFloat;
+}
+interface SpriteDraw extends EffectDrawCommon {
+  type: 'sprite';
+  lane: Lane;
+  /** Its clock now: what `BORN` is read against. */
+  time: number;
+  sparam: number;
+  /** `Appearance_LODCurve` at the host's key, on every extent but the dust's. */
+  extent: number;
+  facing: number;
+  shape: number;
+  blur: boolean;
+  centered: boolean;
+  fade: boolean;
+  lists: SpriteLists;
+  /** The atlas frames a particle's own clock picks among. */
+  frames: readonly UVRect[];
+  /** Which of them a particle's -1 picks: the playback's. 0 when absent. */
+  currentFrame?: number;
+  /** The camera, in the appearance's frame. */
+  eye: Vector3;
+  dust?: {
+    previous: Matrix4;
+    step: number;
+    fade: number;
+  };
+}
+/** Interleaved `position, colour, uv` triangles, already in the appearance's frame: a beam, or what the vertex stage can't key. */
+interface TriangleDraw extends EffectDrawCommon {
+  type: 'triangles';
+  vertices: Float32Array;
+  count: number;
+}
+type EffectDraw = SpriteDraw | TriangleDraw;
+interface MaterialMapRule {
+  on: 'name' | 'type';
+  pattern: RegExp;
+  to: string;
+}
+/**
+ * Retail's section, in file order. `shading.dll` matches with Spencer's regular expressions, which
+ * search rather than anchor (`0x6ed0540`), and these patterns mean the same in JavaScript. So a type
+ * rule's plain text matches anywhere in the type. A host with a mod's `dacom.ini` passes its own rules
+ * as `SceneModel.materialMap`: JavaScript's patterns are a superset, and how a mod's unusual pattern
+ * differs under Spencer's engine is unmeasured.
+ */
+export declare const MATERIAL_MAP: readonly MaterialMapRule[];
+/**
+ * The type a material is created as. Each rule is added at the front, so the last listed wins
+ * (`FMaterialLibrary::AddMapRule`, `RemapType`). Only the name is lowercased (`_strlwr`, `0x6ec9afa`).
+ */
+export declare const mapMaterialType: ({ name, type }: Pick<Material, "name" | "type">, rules?: readonly MaterialMapRule[]) => string;
+type TextureFilter = 'nearest' | 'linear';
+type TextureWrap = 'repeat' | 'mirror' | 'clamp';
+interface SamplerState {
+  magnify: TextureFilter;
+  minify: TextureFilter;
+  /** Between mip levels. */
+  mipmap: TextureFilter;
+  wrapU: TextureWrap;
+  wrapV: TextureWrap;
+}
+interface Camera {
+  position: Vector3;
+  /** Rows, as `./thn/scene` reads a THN `orient`. Looks down local -Z, with +Y up (`0x5568b0`). */
+  orientation: Matrix3;
+  /** Half the horizontal field of view, in degrees (`RoomCameraSetHalfFovX`). */
+  fovh: number;
+  near: number;
+  far: number;
+}
+/** `Mᵀ(p - position)`, the game's own right-handed view space (`0x40ff50`). */
+export declare const viewMatrix: ({ position, orientation }: Camera) => Matrix4;
+/** A viewport's size in pixels. */
+interface Viewport {
+  width: number;
+  height: number;
+}
+/**
+ * `FRoomCamera::ClassifySphere`'s rank 2 (`0x55687a`): `π (R / z)²` times its pixel scales, under one
+ * pixel. `HalfWidth` is `(width - 1) / 2`, as `Rect_to_ViewRect`'s edges are inclusive, and its Y
+ * tangent is X's over `width / height` (`RoomCameraConstruct`, `FUN_00556280`).
+ */
+export declare const underPixel: (z: number, radius: number, fovh: number, { width, height }: Viewport) => boolean;
+/**
+ * RP8 flips view Z and applies a left-handed D3D projection (`FDirectX8::SetPerspective`). For a GL
+ * clip space that comes to this plain right-handed perspective: no axis is negated, and z / w maps
+ * onto the same window depth as D3D's. `hvaspect` never reaches the screen, so aspect is the viewport's.
+ */
+export declare const projectionMatrix: ({ fovh, near, far }: Camera, aspect: number) => Matrix4;
+/** `uv * scale + offset`, on stage 0 alone (`0x6ec7330`, `rp8.dll` \`0x6d0fdd2\`). */
+interface UvTransform {
+  offset: [number, number];
+  scale: [number, number];
+}
+/**
+ * `FImaInstance::Tick` and `FillUvMatrix`: a segment's duration is its own length, and the walk moves
+ * on only strictly past it, wrapping always, as nothing reads `MAFlags`. A segment starts at the last
+ * one's key, or four zeros, and its velocities are rates. Stored scales are displacements from 1.
+ */
+export declare const sampleUvAnimation: ({ segments }: MaterialAnim, time: number) => UvTransform;
+/** One level-of-detail list an archetype writes: its own `LODranges`, or a `[LOD]` block's. */
+interface LodList {
+  /** The part a `[LOD]` block is for, by name. Absent on the section's own list. */
+  obj?: string;
+  /** As written, at most eight. */
+  ranges: readonly number[];
+  /** `MinSpecLOD`: the levels low detail skips. 1 when absent, but 0 under three ranges. */
+  minSpecLod?: number;
+}
+/** The `level_of_detail` option, 0 to 1. At 0.75, the default here, it changes nothing. */
+interface LodDetail {
+  detail?: number;
+}
+/** `ApplyLevelOfDetail` (`0x5b4560`): low detail below 0.75, and the scale the far clamp tests. */
+export declare const lodScale: (detail: number) => {
+  low: boolean;
+  scale: number;
+};
+/**
+ * The archetype's `LodPick` (`ComputeLodPickThis`, `0x4021b0`): the largest range any part's list
+ * walked, past which the object draws nothing. -1 when none did. A single model's part is `Root`.
+ */
+export declare const lodRange: (parts: readonly {
+  source: MeshSource;
+  name: string;
+}[], lists: readonly LodList[], { detail }?: LodDetail) => number;
+/**
+ * Each level's end, in `Switch2`'s unit. The first list with no `obj` or with this part's name
+ * overwrites the model's own entry by entry, as far as it reaches and no further (`0x401ed0`), and a
+ * negative value ends it. With no `Switch2` the game's floats are uninitialised: `NaN`, which no metric
+ * reaches. `lists` are in matching order, `[LOD]` blocks first.
+ */
+export declare const levelEnds: (source: MeshSource, name: string, lists?: readonly LodList[], { detail }?: LodDetail) => number[];
+/**
+ * `LodSetPick` (`0x6c32040`): the first level whose end reaches the metric. Only ends are read, so a
+ * level ending under the one before it is never chosen. Past the last, the part draws nothing.
+ */
+export declare const levelAt: (source: MeshSource, metric: number, ends: readonly number[]) => VMeshPart | undefined;
+/**
+ * `FRenderManager::RenderInstance`: view depth of the part's centre, not its distance, times
+ * tan(fovx½), over the largest axis of the matrix given to the draw. So it widens with the view. The
+ * centre being the top level's bounding sphere is inferred (`IEngine +0x88`). Threshold is 1 in a room
+ * (`room_control.cpp`); space's isn't read yet.
+ */
+export declare const levelMetric: (source: MeshSource, part: Matrix4, transform: Matrix4, camera: Camera) => number;
+/** An `[IGraph]`'s `point = x, value` keys, in file order. A colour graph's values are `0xAARRGGBB`. */
+interface Graph {
+  points: readonly (readonly [x: number, value: number])[];
+}
+/** A `[LightSource]`, in the order the system file lists them, which is the game's (`GameLightEnable`). */
+interface SpaceLight {
+  type: 'ambient' | 'point' | 'cone' | 'directional';
+  position: Vector3;
+  /** Made unit, as `direction` is read. Down -Z when absent. */
+  direction?: Vector3;
+  /** As written, 0 to 255. */
+  color: Vector3;
+  range: number;
+  /** Constant, linear and quadratic. `(0, 1, 0)` when absent (`FEngineLight`'s constructor). */
+  attenuation?: Vector3;
+  /** `atten_curve`, but an ambient light's is its `ambientCurve`: the colour over `[0, range]`. */
+  attenuationCurve?: Graph;
+  /** `ambient_curve`: what an ambient light adds, over `[0, range]`. */
+  ambientCurve?: Graph;
+  /** `color_curve`: a tint over the host's clock, repeating every `period` seconds. */
+  colorCurve?: {
+    graph: Graph;
+    period: number;
+  };
+  /** A cone's angles. A `[LightSource]` has none, so its cone lights nothing; equipment's has. */
+  spot?: Spot;
+}
+/** A `[Light]` equipment's keys, and where its hardpoint is. */
+interface EquipmentLight {
+  /** The hardpoint's frame in the world: it shines down its -Z. */
+  world: Matrix4;
+  /** `color`, 0 to 1. */
+  color: Vector3;
+  /** `intensity`: its range. No light at all at 0 or less. */
+  intensity: number;
+  /** `lightsource_cone`, a full angle in degrees: a spot below 180, a point light otherwise. */
+  cone?: number;
+}
+/**
+ * `CliEquipLightInit` (`0x4fda00`): the light a `[Light]` carries, which retail makes only for the
+ * player's own ship. Its range is its intensity, falling off by 16 / range² (`EngineLightSetRadius`).
+ */
+export declare const equipmentLight: ({ world, color, intensity, cone }: EquipmentLight) => SpaceLight | undefined;
+/** A `[LightAnim]`: its `frame = time, r, g, b, intensity` keys, as written, in file order. */
+interface LightAnimation {
+  frames: readonly {
+    time: number;
+    color: Vector3;
+    intensity: number;
+  }[];
+}
+/** An `[Effect]`'s light keys, and the running effect's place and age. */
+interface EffectLight {
+  /** Where the effect is: it has no direction. */
+  position: Vector3;
+  /** `lgt_radius`: its range. No light at all at 0 or less. */
+  radius: number;
+  /** `lgt_color`, as written, 0 to 255. */
+  color: Vector3;
+  /** The `[LightAnim]` its `lgt_effect` names. */
+  animation?: LightAnimation;
+  /** `lgt_range_scale`, which scales each key's intensity. 1 when absent. */
+  rangeScale?: number;
+  /** `lgt_time_scale`, which scales each key's time. 1 when absent. */
+  timeScale?: number;
+  /** Seconds since it started. Retail adds each frame's step to a float. */
+  elapsed: number;
+}
+/**
+ * The light an effect carries (`CreateEffectStart`, `0x544299`), run by its animation
+ * (`GameLightTickAnim`, `0x5386d0`): gone once the animation's last key has passed.
+ */
+export declare const effectLight: ({ position, radius, color, animation, rangeScale, timeScale, elapsed }: EffectLight) => SpaceLight | undefined;
+/** What one object is lit by: at most four lights, and the ambient, 0 to 1. */
+interface ObjectLighting {
+  lights: SceneLight[];
+  ambient: Vector3;
+}
+/** `FGraphData::Evaluate` over `[0, max]`, clamped. */
+export declare const evaluateGraph: (graph: Graph, t: number, max: number) => number;
+/**
+ * `FGraphData::EvaluateColor` over `[0, period]`, repeating: its bytes. Its weight runs from the low
+ * key while the blend still gives the rest to the high one, so retail's colour curves run backwards
+ * between keys (`0x41963c`).
+ */
+export declare const evaluateColorGraph: (graph: Graph, t: number, period: number) => Vector3;
+interface Entry {
+  light: number;
+  x: number;
+  z: number;
+  range: number;
+}
+interface Cell {
+  x: number;
+  z: number;
+  half: number;
+  children: (Cell | undefined)[];
+  /** Newest first, as each payload is pushed on the front. */
+  entries: Entry[];
+}
+/**
+ * The XZ quadtree `LightGridRebuildImpl` builds once per system. Its cells only narrow the search, but
+ * the order it hands lights back in decides which of equal range win the last of the four places.
+ */
+declare class LightGrid {
+  readonly root: Cell;
+  private cells;
+  private entries;
+  constructor(lights: readonly SpaceLight[]);
+  private cell;
+  private child;
+  /** `LightGridInsert` (`0x537d20`): into every quadrant its square reaches, while it fits one. */
+  private insert;
+  private descend;
+  /** `LightTreeCollect`: each cell the query's square reaches, itself before its children. */
+  collect(cell: Cell | undefined, x: number, z: number, radius: number, into: Cell[]): void;
+}
+/**
+ * The directional lights `BandBakeLighting` (`0x54cfb0`) takes at a band's zone: of the first 16
+ * `CollectNearbyLights` gives within 100, the first four directional ones, each the way it travels
+ * (`EngineLightSample`). There's no reach test, and an ambient light adds nothing here.
+ */
+export declare const directionalLightsAt: ({ lights, grid }: LightSet, position: Vector3, time: number) => {
+  found: number;
+  lights: SceneLight[];
+};
+/** `[Ambient] color` as the device takes it: whole bytes, 0 to 1. */
+export declare const systemAmbient: ({ x, y, z }: Vector3) => Vector3;
+/** What `SpaceObject`'s lighting reads, built once a frame from a system's lights. */
+interface LightSet {
+  lights: readonly SpaceLight[];
+  grid: LightGrid;
+}
+export declare const lightSet: (lights: readonly SpaceLight[]) => LightSet;
+/** The `[NebulaLight] ambient` an object is in, as written, and how far in, from 0 to 1. */
+interface NebulaAmbient {
+  ambient: Vector3;
+  factor: number;
+}
+/**
+ * `StarSysApplyObjectLighting` with every option on, from where the object stands and its sphere's
+ * radius. `ambient` is the system's `[Ambient]`, as written. Its fog is `collectSpaceFrame`'s.
+ */
+export declare const lightObject: ({ lights, grid }: LightSet, position: Vector3, radius: number, ambient: Vector3, time: number, nebula?: NebulaAmbient) => ObjectLighting;
+/** `[BackgroundLightning]`, each key over what `FNebulaEffect`'s constructor sets. */
+interface BackgroundLightningSettings {
+  /** `gap`: about how long between flashes, from 0.8 to 1.5 of it. */
+  gap: number;
+  /** `duration`: how long a flash lasts. None at all at 0 or less. */
+  duration: number;
+  /** `color` over 255: added to the fog's, by up to `intensity`. */
+  color: Vector3;
+  intensity: number;
+}
+/** `[DynamicLightning]`, each key over what `FNebulaEffect`'s constructor sets. */
+interface DynamicLightningSettings {
+  /** `gap`: about how long between flashes, from 0.8 to 1.5 of it. */
+  gap: number;
+  /** `duration`: how long a flash lasts. No light at all at 0 or less. */
+  duration: number;
+  /** `color` over 255, by up to the intensity. */
+  color: Vector3;
+  /** `ambient_intensity`. */
+  ambientIntensity: number;
+  /** `intensity_increase`: added while the background flashes too. */
+  intensityIncrease: number;
+}
+/** Checked in `Freelancer-original.exe`, `0x504b06` to `0x504b42`: every nebula flashes unless told not to. */
+export declare const RETAIL_BACKGROUND_LIGHTNING: Readonly<BackgroundLightningSettings>;
+/** Checked in `Freelancer-original.exe`, `0x504b4e` to `0x504b8a`. */
+export declare const RETAIL_DYNAMIC_LIGHTNING: Readonly<DynamicLightningSettings>;
+/** `rand()`'s range: whole numbers from 0 to 32767. */
+type Random = () => number;
+/**
+ * One nebula's lightning timers, which the host keeps for as long as the nebula exists.
+ * `collectSpaceFrame` advances them as retail does: the light on every frame by the scene's `step`,
+ * and the background only on a frame the camera is deep in the nebula. Retail draws from the game's
+ * one `rand()`, so its flashes can't be matched, only their kind.
+ */
+export declare class NebulaLightning {
+  #private;
+  readonly background: BackgroundLightningSettings;
+  readonly dynamic: DynamicLightningSettings;
+  readonly random: Random;
+  constructor(settings?: {
+    background?: Partial<BackgroundLightningSettings>;
+    dynamic?: Partial<DynamicLightningSettings>;
+  }, random?: Random);
+  /** A flash on the next step rather than after its wait, for an editor: retail has no such call. */
+  fire(kind: 'background' | 'dynamic'): void;
+  /** `FNebulaEffect::Update`'s part, each frame: `depth` is its `+0x294`, where `eye` is. */
+  update(step: number, depth: number, eye: Vector3): void;
+  /** Its light while it flashes: directional, at the camera, after the system's own. */
+  get light(): SpaceLight | undefined;
+  /** `FillFogRgb`: `base`, the fog's colour, or a flash over it, `update`'s step later. */
+  fogColor(base: Vector3): Vector3;
+}
+/** A `[Light]`'s flare keys, as `CliEQLight` holds them. The host reads the INI, `inherit` too. */
+interface FlareLight {
+  /** `color` over 255. */
+  color: Vector3;
+  /** `glow_color` over 255. A `color` line copies itself here while this is still black. */
+  glowColor: Vector3;
+  /** `min_color` over 255: the bulb's colour while the blink is dark. */
+  minColor: Vector3;
+  bulbSize: number;
+  glowSize: number;
+  /** `avg_delay`: about how long between blinks. None at 0 or less. */
+  avgDelay: number;
+  /** `blink_duration`: how long one lasts, at most `avg_delay`'s draw. */
+  blinkDuration: number;
+  /**
+   * `flare_cone` in degrees, as written: past the first from its forward axis the glow is gone, and
+   * from the second to the first it fades. None when absent.
+   */
+  flareCone?: readonly [number, number];
+}
+/** `FCliEQLight`'s constructor (`0x40a9e0`), what a `[Light]` with no keys has. */
+export declare const RETAIL_FLARE_LIGHT: Readonly<FlareLight>;
+/**
+ * A light's blink: `CliEquipLightInit` (`0x4fda00`) and its tick (`0x4fdd00`). A triangle up to 1 and
+ * back over the lit part of each period, dark for the rest; always 1 when it doesn't blink. Each
+ * light draws its period and phase from the game's `rand()` as it's made.
+ */
+export declare class LightBlink {
+  #private;
+  brightness: number;
+  constructor({ avgDelay, blinkDuration }: Pick<FlareLight, 'avgDelay' | 'blinkDuration'>, random?: Random);
+  /**
+   * A period and phase given, not drawn: `FFlashLight`'s second constructor (`FUN_00557630`), which a
+   * room's `[FlashlightSet]` makes its lights with. A phase below 0 stays dark until it's passed 0.
+   */
+  static timed(period: number, phase: number, blinkDuration: number): LightBlink;
+  /** Where in its period it is, 0 to 1. */
+  get phase(): number;
+  /** Advances by `step`, which the game holds to 0.1, only on a frame its object drew. */
+  tick(step: number): void;
+}
+/** A light on a ship or solar: its keys, where its hardpoint is, and its blink. */
+interface SpaceFlare {
+  light: FlareLight;
+  /** The hardpoint's frame in the world. */
+  world: Matrix4;
+  /** Steady at full brightness when absent. */
+  blink?: LightBlink;
+}
+/** One quad as the batcher records it (`FScreenQuadRecord`): D3D pixels, depth and `1 / w`. */
+interface ScreenQuad {
+  x0: number;
+  y0: number;
+  x1: number;
+  y1: number;
+  /** `1 - near / -z`, the depth it's tested at. */
+  z: number;
+  rhw: number;
+  u0: number;
+  v0: number;
+  u1: number;
+  v1: number;
+  /** `0xAARRGGBB`, alpha always 255. */
+  color: number;
+}
+/** A texture frame's rectangle, `GetTextureFrame`'s: `u0`, `v0`, `u1`, `v1`. Whole when absent. */
+type FrameRect = readonly [number, number, number, number];
+interface FlareView {
+  camera: Camera;
+  /** The camera's view, `viewMatrix(camera)`. */
+  view: Matrix4;
+  /** The projection's, width over height. */
+  aspect: number;
+  /** The viewport, in pixels. */
+  width: number;
+  height: number;
+  frame?: FrameRect;
+}
+/**
+ * A light's bulb then its glow at `world`, the hardpoint's frame (`ScreenQuadEnqueueFlare`,
+ * `0x4038f0`): squares of its sizes at its depth, each dropped under a pixel. Nothing behind the
+ * camera, though anything nearer than the near plane passes as retail lets it.
+ */
+export declare const flareQuads: (light: FlareLight, world: Matrix4, brightness: number, { camera, view, aspect, width, height, frame }: FlareView) => ScreenQuad[];
+interface SceneLight {
+  color: Vector3;
+  /** World space, the way the light shines. A point light's is unused. */
+  direction: Vector3;
+  /** In world space, which makes it a point light: D3D8's, with no light past `range`. */
+  position?: Vector3;
+  range?: number;
+  /** Constant, linear and quadratic, of the distance. */
+  attenuation?: Vector3;
+  /** With a position, a spot along `direction`: D3D8's angles, inner and outer, in radians. */
+  spot?: Spot;
+  /**
+   * `D3DLIGHT8`'s `Ambient`, which D3D8 adds as the material's ambient times it, attenuated and in
+   * the cone, whichever way the surface faces. A THN light's; a system's is black.
+   */
+  ambient?: Vector3;
+}
+/** `D3DLIGHT8`'s `Theta`, `Phi` and `Falloff`: full angles in radians, no light outside `phi`. */
+interface Spot {
+  theta: number;
+  phi: number;
+  falloff: number;
+}
+/** What a skinned mesh adds: `skinMesh`'s influences and `boneTable`'s matrices, column-major. */
+interface DrawSkin {
+  influences: Float32Array;
+  bones: Float32Array;
+}
+/** One piece of geometry where the host has posed it, at the detail level it chose. */
+interface PlacedPart {
+  reference: VMeshRef;
+  world: Matrix4;
+  /** A generated mesh, which no library holds: a sphere's patch. */
+  mesh?: VMeshData;
+  /** Over each group's own, as a sphere's face names its material and its patch can't. */
+  materialId?: number;
+  /** That material's name, as the file writes it, for a report: an id can't be read back. */
+  materialName?: string;
+  skin?: DrawSkin;
+  /** Added to an `EyeMaterial` group's UVs, as its eye bone turns. */
+  eyeOffset?: [number, number];
+  /** What the engine tells a sphere's shell of its size. Anything else reads 1 (`Field20` unset). */
+  extent?: number;
+}
+interface SceneModel {
+  parts: PlacedPart[];
+  mesh: (id: number) => VMeshData | undefined;
+  material: (id: number) => Material | undefined;
+  texture: (name: string) => TextureEntry | undefined;
+  /** The archetype's `envmap_material`: the model does not say. Absent means no reflection. */
+  environment?: string;
+  /** 0 to 1, the engine's per-object value that nomad surfaces and `cloaked` read. 1 when absent. */
+  fade?: number;
+  /** Drawn through `CloakMaterial`, which the host decides: the game spares nomad archetypes. */
+  cloaked?: boolean;
+  /** UV animations, found by material name as the game does. */
+  materialAnimations?: MaterialAnimLibrary;
+  /** `[MaterialMap]` from the host's own `dacom.ini`, in file order. Retail's when absent. */
+  materialMap?: readonly MaterialMapRule[];
+  /**
+   * Drawn through `StarsphereMaterial`: at the camera, turned with the view alone, under white ambient
+   * and no lights. Or `BackdropMaterial`, where the camera stands, on planes of its own. Both ignore
+   * depth. The host orders models, so a sky goes first.
+   */
+  sky?: 'starsphere' | 'backdrop';
+  /**
+   * The instance's user data, which HUD icons and exclusion zones read: over `Ac` and `Oc`. The engine
+   * sets it, so without it they use the material's own.
+   */
+  instance?: {
+    ambient: Vector3;
+    alpha: number;
+  };
+}
+interface PlaceOptions {
+  /** Choose each part's level as the game does, from this camera. Unless `level` pins one. */
+  camera?: Camera;
+  /** The archetype's level-of-detail lists, in matching order, over the model's own `Switch2`. */
+  lod?: readonly LodList[];
+  /** The `level_of_detail` option, 0 to 1, which the lists answer to. 0.75 changes nothing. */
+  detail?: number;
+  /** Pins a level, clamped to what a part has. The top one when there is no `camera` either. */
+  level?: number;
+  /** A part left out draws nothing, and its children still do. */
+  visible?: (part: CompoundNode<RigidPart>) => boolean;
+  jointState?: (part: CompoundNode<RigidPart>) => JointState | undefined;
+}
+/** A running effect, advanced by the host, and where its textures come from. */
+interface SceneEffect {
+  instance: EffectInstance;
+  texture: (name: string) => TextureEntry | undefined;
+  /** An appearance left out isn't drawn, and still runs: a way of looking. Every one when absent. */
+  visible?: (node: EffectNode) => boolean;
+}
+interface Scene {
+  camera: Camera;
+  /** Width over height of the viewport. */
+  aspect: number;
+  /** 0 to 1. */
+  ambient: Vector3;
+  lights: SceneLight[];
+  models: SceneModel[];
+  /** 0 to 1. Black when absent, which is what the menu clears to. */
+  background?: Vector3;
+  /**
+   * Seconds, the host's clock, for material UV and texture animation. 0 when absent. Retail starts a
+   * material's texture playback when it loads (`FMaterial::Setup`), so 0 is when the models loaded.
+   */
+  time?: number;
+  /** After the models, in the order given. `collectSpaceFrame` has the game's order. */
+  effects?: readonly SceneEffect[];
+  /** Over `RETAIL_FRAME_LIMITS`, for a mod that patches them. */
+  limits?: Partial<FrameLimits>;
+}
+/** What the material and appearance DLLs hardcode, and a mod can patch. */
+interface FrameLimits {
+  /** The least alpha glass draws at, whatever its `Oc` (`FMaterialImpl::BindGlass`). */
+  glassLeastAlpha: number;
+  /** A backdrop's own near and far planes (`FFLAppearanceBase::DrawBackdrop`, `BindArg`'s first flag). */
+  backdropNear: number;
+  backdropFar: number;
+}
+export declare const RETAIL_FRAME_LIMITS: Readonly<FrameLimits>;
+interface DrawTexture {
+  name: string;
+  entry: Texture | CubeTexture;
+  sampler: SamplerState;
+  /** Which of the mesh's UV sets it samples. */
+  uvSet: number;
+}
+/**
+ * Texture stage 1, in the classes that use it. With no texture the rig's picture is as if the stage were
+ * off (`bands`), so that's what draws, though a real D3D8 driver may read it as white: see VALIDATION.md.
+ */
+interface DrawStage {
+  operation: 'add' | 'modulate2x';
+  texture?: DrawTexture;
+  /** A planet mask's `diag(tile, tile)` texture matrix, on UV0 (`SetDetailTileTransform`). */
+  tile?: number;
+}
+/** What `SubmitAtmosphereLock` needs for each vertex's UV, the rest being the same for a draw. */
+interface DrawAtmosphere {
+  /** Towards the camera, in the object's space. */
+  direction: Vector3;
+  /** The cosine of the horizon, where `u` starts. */
+  threshold: number;
+  /** `u` where the vertex faces the camera. */
+  gain: number;
+  /** The row of the fade texture, the whole draw's. */
+  v: number;
+}
+/**
+ * Source and destination: `SRCALPHA / INVSRCALPHA`, `ONE / ONE`, `SRCALPHA / ONE`, `DESTCOLOR / ZERO`,
+ * `ONE / INVSRCCOLOR`, `ONE / INVSRCALPHA`.
+ */
+type BlendMode = 'alpha' | 'add' | 'alphaAdd' | 'multiply' | 'screen' | 'premultiplied';
+interface Draw {
+  mesh: VMeshData;
+  reference: VMeshRef;
+  /** The mesh was built for this frame alone: the renderer frees it once the frame's drawn. */
+  transient?: boolean;
+  /** Into the reference's planned index buffer. */
+  byteOffset: number;
+  count: number;
+  world: Matrix4;
+  materialName: string;
+  diffuse: [number, number, number, number];
+  ambient: Vector3;
+  emissive: Vector3;
+  /** The mesh has vertex colours, which take the place of `diffuse`. */
+  colorVertex: boolean;
+  /** Unlit white at `diffuse`'s alpha, and stage 1 reads the nomad ramp. */
+  nomad: boolean;
+  texture?: DrawTexture;
+  /** A cube, reflected in camera space, as `2 × cube × colour`. */
+  environment?: string;
+  environmentTexture?: CubeTexture;
+  second?: DrawStage;
+  uvTransform?: UvTransform;
+  cull: 'back' | 'front' | 'none';
+  depthWrite: boolean;
+  /** `D3DCMP_LESS` for most. `always` is `ZENABLE 0`, a sky's or the far list's: the same pixels. */
+  depthFunc: 'less' | 'lequal' | 'always';
+  /** Scene ambient in place of the frame's, for this draw. */
+  sceneAmbient?: Vector3;
+  /** The frame's lights don't reach it. */
+  lightless?: boolean;
+  /** In place of the frame's, for this draw: space lights each object by its own. */
+  lights?: SceneLight[];
+  /** In place of the frame's, for this draw. */
+  projection?: Matrix4;
+  /** `D3DVIEWPORT8`'s `MinZ` and `MaxZ`, for this draw: `[0, 1]` when absent. */
+  depthRange?: readonly [number, number];
+  /**
+   * D3D8's `ZBIAS`, 0 to 16, pulling it toward the camera: a room's shadow's 4. How far a level
+   * moves depth is the driver's; here one level is one unit of `polygonOffset`: uncaptured.
+   */
+  depthBias?: number;
+  /** D3D's table fog, on depth: a nebula's, for what it holds (`StarSysApplyObjectLighting`). */
+  fog?: Fog;
+  negateNormals: boolean;
+  normalizeNormals: boolean;
+  blend: boolean;
+  /** `alpha` unless a class sets its own (`bands`). */
+  blendMode: BlendMode;
+  /** Lighting off: white, or the vertex colour, at `diffuse`'s alpha. */
+  unlit: boolean;
+  /** Compared with this, of 255: `D3DRS_ALPHAFUNC`, or `always` with the test off. */
+  alphaReference: number;
+  alphaFunction: 'greater' | 'less' | 'always';
+  atmosphere?: DrawAtmosphere;
+  skin?: DrawSkin;
+}
+/**
+ * Where a host's own drawing goes. `begin` is after the clear, `opaque` before the first blended draw,
+ * and `end` after everything. None of them changes the game's order.
+ */
+type HookName = 'begin' | 'opaque' | 'end';
+interface FrameHook {
+  name: HookName;
+  /** Index of the draw it goes in front of, so the length of `draws` is after the last. */
+  before: number;
+}
+interface ScreenQuadBatch {
+  texture: Texture;
+  quads: ScreenQuad[];
+}
+interface Frame {
+  background: Vector3;
+  hooks: FrameHook[];
+  view: Matrix4;
+  projection: Matrix4;
+  ambient: Vector3;
+  lights: SceneLight[];
+  draws: Draw[];
+  /** Each appearance of each effect, after `draws`, in the game's tree order. */
+  effects: EffectDraw[];
+  /** Over every effect, as `SpaceObjDrawPass` sets it in a nebula. */
+  effectFog?: Fog;
+  /** `less` when absent, as the menu's effects capture it; space's are `lequal`. */
+  effectDepthFunc?: 'less' | 'lequal';
+  /** Each tractor's lines, after the effects, in the walk's own bucket (`EFT_TRACTORBEAM`). */
+  tractors?: Draw[];
+  /** Every shot of the frame, once the effects are walked (`EffectVertexBatchFlush`). */
+  beams?: Draw;
+  /**
+   * Screen quads, after the effects, in D3D's pixels: added, the texture times each quad's colour,
+   * `lequal` without writing depth (`ScreenQuadFlush` in `SpaceEffectsDrawFrame`), under
+   * `effectFog` by `1 / rhw`. Each batch is one texture's.
+   */
+  screenQuads?: ScreenQuadBatch[];
+  /**
+   * Clear depth before `afterEffects`: from the cockpit, with the HUD on or the cockpit showing
+   * (`FirstPersonCameraSceneDraw`, `0x518463`). None of what's already drawn can then hide what's next.
+   */
+  clearDepth?: boolean;
+  /**
+   * Drawn after the screen quads, before the `end` hook: a sun's corona, which the game draws once
+   * its effects are done (`ScaleEnvironmentEffects`, `0x51c7d4`), and from the cockpit, its mesh.
+   */
+  afterEffects?: Draw[];
+  /**
+   * After the `end` hook: what the cockpit's mesh queued with the effects option off, which the
+   * game's batcher draws only as the scene ends, past the HUD and every sun's flare (`EndSceneHalf`).
+   */
+  atEnd?: Draw[];
+  /** What didn't draw as authored: materials M3 is to cover, and any mesh or texture not found. */
+  unsupported: string[];
+  /** Materials of a type no DLL registers. They draw nothing in retail either. */
+  unregistered: string[];
+}
+/** Whether `collectFrame` draws this type, the one `[MaterialMap]` gives. */
+export declare const isBuiltType: (type: string) => boolean;
+/** A compound model's parts, depth first (`li_elite`), for a host that doesn't pose its own. */
+export declare const placeParts: (root: RigidModel, transform: Matrix4, options?: PlaceOptions) => PlacedPart[];
+export declare const collectFrame: ({ camera, aspect, ambient, lights, models, background, time, effects, limits }: Scene) => Frame;
+/** A `[Shape]`'s rectangle in its texture, as UVs. */
+interface TextureShape {
+  texture: Texture;
+  u0: number;
+  v0: number;
+  u1: number;
+  v1: number;
+}
+/**
+ * `TexShapeSetRect` (`0x4256c0`): a `[Shape]`'s `x`, `y`, `w` and `h` in `texture`'s pixels. A corner
+ * of 1 or less is a fraction of the texture, and so is an extent; a zero extent is all of it.
+ */
+export declare const textureShape: (texture: Texture, { x, y, w, h }: {
+  x?: number;
+  y?: number;
+  w?: number;
+  h?: number;
+}) => TextureShape;
+/** A ring file's `[Exterior]`, over `PlanetRing::Load`'s defaults. The host reads the INI. */
+interface RingExterior {
+  /** `shape`. Without one the ring draws nothing. */
+  shape?: TextureShape;
+  /** `detail_shape`, on the second UV set. */
+  detail?: TextureShape;
+  /** `detail_tile` as written: the detail's V at the inner edge, then its U on odd segments. */
+  detailTile?: readonly [number, number];
+  /** `color` over 255. Kept from the last ring loaded when absent: black here. */
+  color?: Vector3;
+  /** 1 when absent, and halved without a detail shape. */
+  opacity?: number;
+  /** `num_segments`, 32 when absent. */
+  segments?: number;
+  /** `transition_dist`, 150 when absent: how far past its edges its immersion fades. */
+  transitionDistance?: number;
+}
+interface RingOptions {
+  /** `high_detail_textures`: under 0.4 the detail shape is dropped (`0x50ac65`). 1 when absent. */
+  highDetailTextures?: number;
+}
+/** A run of segments drawn as one, and the sphere about its vertices that the view tests. */
+interface RingPiece {
+  first: number;
+  last: number;
+  center: Vector3;
+  radius: number;
+  /** Its strip, in world space. */
+  mesh: VMeshData;
+  reference: VMeshRef;
+}
+interface PlanetRing {
+  pieces: RingPiece[];
+  shape?: TextureShape;
+  detail?: TextureShape;
+  zone: RingShape;
+  transitionDistance: number;
+  /** Its `[Clouds]`, which the host makes with `RING_CLOUD_VISIBILITY` and its own `rand()`. */
+  clouds?: readonly Clouds[];
+}
+/**
+ * `PlanetRing::Load`'s mesh (`0x50a8d3` on): a vertex at the outer radius and one at the inner for
+ * each segment, then eight pieces of them, each with the box's sphere. And `DrawPiece`'s strip for
+ * each (`0x50b77e`): the shape's left edge on even segments and its right on odd, its top at the
+ * outer radius and its bottom at the inner, in the colour and opacity, all in world space.
+ */
+export declare const buildRing: (exterior: RingExterior, zone: RingShape, { highDetailTextures }?: RingOptions) => PlanetRing;
+/**
+ * `PlanetRing::GetImmersion` (`0x50bd70`): 1 within the band, ramping to 0 over `transition_dist`
+ * past its radii and past its height. Retail takes the zone's `size` z as the half height here, so
+ * `zone.height` is that value as written.
+ */
+export declare const ringImmersion: ({ zone, transitionDistance }: Pick<PlanetRing, "zone" | "transitionDistance">, point: Vector3) => number;
+/**
+ * `DrawPiece` (`0x50b510`): a piece's strip, unlit, in its vertex colour times the shape, the detail
+ * doubling it, blended over what's there with `LEQUAL` and no depth writes or culling. Nothing
+ * without a shape. Its alpha test and fog are whatever the frame left on: `ring_outside` captures
+ * `GREATER 0` and no fog, outside a nebula. In one, the last object's fog may still be on: uncaptured.
+ */
+export declare const ringPieceDraw: (ring: PlanetRing, piece: RingPiece) => Draw | undefined;
+/** A `[Clouds]` section, over `FUN_00550240`'s defaults. The host reads the INI. */
+interface CloudSettings {
+  /** `puff_count`. */
+  puffCount: number;
+  /** `puff_radius`, 50 when absent. */
+  puffRadius?: number;
+  /** `puff_colora` and `puff_colorb` over 255: each puff's colour lies between. B is A when absent. */
+  colorA?: Vector3;
+  colorB?: Vector3;
+  /** `puff_shape`s, at most eight, one texture between them: the first's is bound for all. */
+  shapes: readonly (TextureShape | undefined)[];
+  /** `puff_weights`, one a shape. Even when absent. */
+  weights?: readonly number[];
+  /** `puff_max_alpha`, 0.75 when absent. */
+  maxAlpha?: number;
+  /** `puff_drift`: how fast a puff wanders. 0 when absent. */
+  drift?: number;
+  /** `max_distance`, 1500 when absent: the puffs' sphere is half of it plus a puff's radius. */
+  maxDistance?: number;
+  /** `near_fade_distance`, 50 and 100 when absent: nearer than the first, nothing. */
+  nearFade?: readonly [number, number];
+  /** `lightning_color` over 255, `lightning_intensity` and its timing: a puff's flash. */
+  lightning?: {
+    color: Vector3;
+    intensity?: number;
+    gap: number;
+    duration: number;
+  };
+  /** `disable_lightning_flash`. */
+  disableFlash?: boolean;
+}
+/**
+ * How the owner's visibility drives its puffs: past `full` they're opaque, `budget` of it allows all
+ * of them, and under `spawn` a puff is placed only where the owner holds it. A nebula's are 0.1, 0.3
+ * and 0.3 (`FUN_00550240`); a ring sets its own.
+ */
+interface CloudVisibility {
+  full: number;
+  budget: number;
+  spawn: number;
+}
+export declare const NEBULA_CLOUD_VISIBILITY: Readonly<CloudVisibility>;
+/** `PlanetRing::Load` (`0x50a735`). */
+export declare const RING_CLOUD_VISIBILITY: Readonly<CloudVisibility>;
+interface Puff {
+  position: Vector3;
+  size: number;
+  color: Vector3;
+  shape: number;
+  velocity: Vector3;
+  /** The drift's clock, negative while it waits. -1 with no lightning. */
+  timer: number;
+  /** `+0x3c`, how much of the lightning colour it flashes. */
+  flash: number;
+  active: boolean;
+  hidden: boolean;
+  /** Its depth in view at the last draw: the order puffs are kept in. */
+  depth: number;
+}
+interface CloudDrawOptions {
+  /** The camera cut this frame (`+0xbc`): the puffs are placed afresh first. */
+  cut?: boolean;
+  /** How far a point is in what holds the clouds, which a fresh puff must be. */
+  holds?: (point: Vector3) => number;
+  /** How far a point is in an exclusion zone of the owner's: past 0.9, a puff there is hidden. */
+  excluded?: (point: Vector3) => number;
+}
+export declare class Clouds {
+  #private;
+  readonly settings: CloudSettings;
+  readonly visibility: CloudVisibility;
+  readonly random: Random;
+  /** Its sphere's radius (`+0x100`). */
+  readonly radius: number;
+  /** How far past the near fade its sphere stands (`+0xbc`). */
+  readonly reach: number;
+  constructor(settings: CloudSettings, { visibility, random, detail }?: {
+    visibility?: CloudVisibility;
+    random?: Random;
+    detail?: number;
+  });
+  /** How many are in its sphere, as of the last update. */
+  get active(): number;
+  get puffs(): readonly Readonly<Puff>[];
+  /** The first shown puff's flash on the next step, for an editor: retail has no such call. */
+  fire(): void;
+  /**
+   * `FUN_00550d40`: the sphere follows the camera; puffs that left it go, and as many as
+   * `visibility` allows come back on its surface, where `holds` says the owner is, and drift. One
+   * back deep in an exclusion zone counts, hidden.
+   */
+  update(camera: Camera, step: number, visibility: number, holds?: (point: Vector3) => number, excluded?: (point: Vector3) => number): void;
+  /**
+   * `TexturePanelDrawClouds`: each puff a square facing the camera, turned to the kept up, faded
+   * near the camera and toward its sphere's edge, all in one list of the first shape's texture.
+   * Unlit, blended, both sides, no depth writes, the alpha test at 5. Nothing with none active.
+   * Its depth function is the main list's, `LEQUAL`, and it draws in view space.
+   */
+  draw(camera: Camera, { cut, holds, excluded }?: CloudDrawOptions): Draw | undefined;
+}
+/** An `[Exterior]` section, over `FNebulaEffect`'s constructor and `Load`'s defaults. */
+interface ExteriorSettings {
+  /** `shape`s, at most eight; a name the shapes don't hold is `undefined`. The first's texture is bound. */
+  shapes: readonly (TextureShape | undefined)[];
+  /** `shape_weights`, one a shape. 1 each when absent. */
+  weights?: readonly number[];
+  /** `bit_radius`. Retail leaves it uninitialised when absent: the host decides. */
+  bitRadius: number;
+  /** `bit_radius_random_variation`, held to [0, 0.9999]: a bit is 1 ± it of the radius. 0 when absent. */
+  radiusVariation?: number;
+  /** `color` over 255. Retail leaves it uninitialised when absent: the host decides. */
+  color: Vector3;
+  /** `plane_slices`, 1 when absent: how many rings of latitude. */
+  planeSlices?: number;
+  /** `min_bits`, 4 when absent: a ring's bits at the poles' end. */
+  minBits?: number;
+  /** `max_bits`, 8 when absent: a ring's bits at the middle. */
+  maxBits?: number;
+  /**
+   * `equator_bias`, 1 when absent: how far the rings spread from the equator toward the poles, 0 to
+   * the whole way, 1 none. The constructor's 0 at `+0xd0` is 1 here.
+   */
+  equatorBias?: number;
+  /** `move_bit_percent`, 0.75 when absent: how many `bit_radius` a bit is pulled in from the surface. */
+  moveBitPercent?: number;
+  /** `opacity`, 0.75 when absent. */
+  opacity?: number;
+}
+/** What the game's `Nebula` option scales (`NebulaRebuild`): `DAT_006132e0` to `DAT_006132e8`. */
+interface ExteriorLimits {
+  /** A bit's size at no detail, of its full. */
+  leastSize: number;
+  /** The bits' count at no detail, of their full. */
+  leastCount: number;
+  /** Their opacity at no detail, of its full. */
+  leastOpacity: number;
+  /** Under this detail, no bits (`0x5d5b58`). */
+  leastDetail: number;
+}
+export declare const RETAIL_EXTERIOR_LIMITS: Readonly<ExteriorLimits>;
+interface Bit {
+  /** From the zone's centre. */
+  position: Vector3;
+  radius: number;
+  shape: TextureShape | undefined;
+  /** Its up, which `NebulaOrientBolts` keeps square to the camera. */
+  axis: Vector3;
+}
+/**
+ * Whether the game blends a texture by its alpha (`FUN_00552420`): DXT1 to DXT5 do, and so does any
+ * format whose descriptor has alpha bits (`DAT_00615ec8`). A 24-bit Targa is narrowed to R5G6B5 (M1)
+ * and a 16-bit one is X1R5G5B5 (`GetTgaSourceFormat`), so neither does.
+ */
+export declare const textureHasAlpha: ({ format }: Texture) => boolean;
+export declare class NebulaExterior {
+  #private;
+  readonly settings: ExteriorSettings;
+  readonly zone: Zone;
+  constructor(settings: ExteriorSettings, zone: Zone, { random, detail, limits }?: {
+    random?: Random;
+    detail?: number;
+    limits?: ExteriorLimits;
+  });
+  /** The bits, from the zone's centre, in the order they draw. */
+  get bits(): readonly Readonly<Bit>[];
+  /**
+   * `FNebulaEffect::Update`'s part: unless the camera was all the way in last frame, the bits turn
+   * to it once a second, or at once on a cut (`NebulaOrientBolts`). Then the clocks run on.
+   */
+  update(eye: Vector3, step: number, depth: number, cut?: boolean): void;
+  /**
+   * `NebulaDrawBolts` from `DrawBoltsPass`: none once the camera is all the way in, nor when the zone
+   * is out of view. Sorted far to near once 1.15 s have passed. Each bit faces the camera about its
+   * up, its back half skipped and its edge fading, fading too as the camera comes within its radius,
+   * and over the second half of the camera's depth. Unlit, unculled, with no depth test or writes,
+   * `ALPHAREF` 4, fogged in the nebula's colour to past its fog's span (`DrawBoltsPass`). `camera` is
+   * the 250000 far plane its callers set; `projection` is that.
+   */
+  draw({ nebula, depth, start, fogDistance }: NebulaState, camera: Camera, view: Matrix4, aspect: number, projection: Matrix4): Draw | undefined;
+}
+/**
+ * What a nebula asks of its zone: `IZone`'s position, `GetRadius`, `GetRadiusAlong`, `GetSize` and
+ * `GetOrientation`.
+ */
+interface Zone {
+  /** Its `shape`: what the exclusion managers measure by kind (`AsteroidExclusionZone::update_dist`). */
+  type: Shape['type'];
+  position: Vector3;
+  /** The sphere around it. */
+  radius: number;
+  /** From its centre to its surface along a unit direction in world space. */
+  radiusAlong: (direction: Vector3) => number;
+  /** `GetSize`: its `size` as written, a missing value 0 (`Universe` zone loading). */
+  size: Vector3;
+  /** `GetOrientation`'s columns: its own x, y and z in world space. */
+  axes: readonly [Vector3, Vector3, Vector3];
+  /** `GetSurfacePoint` (`ZONE`, vt+0x44): where its surface is, for a point. */
+  surfacePoint: (point: Vector3) => Vector3;
+  /** `InZone` (`0x6339220`) with no margin: whether a point is in it. */
+  holds: (point: Vector3) => boolean;
+  /** `Intersect` (vt+0x4c): whether a segment meets it, or starts in it. */
+  meets: (start: Vector3, end: Vector3) => boolean;
+}
+/** A system's `[Nebula]`: its zone, and what its file's `[Fog]` and `[NebulaLight]` say. */
+interface SpaceNebula {
+  zone: Zone;
+  fog: {
+    /** `near`, 0 when absent. */
+    near?: number;
+    /** `distance`, `limits.nebulaFogDistance` when absent. */
+    distance?: number;
+    /** `color` over 255, each kept below 1 (`ParseFogSection`). */
+    color: Vector3;
+  };
+  /** `[NebulaLight] ambient`, as written, 0 to 255. */
+  ambient?: Vector3;
+  /**
+   * `[NebulaLight]`'s suns seen from in it: their glows drawn again at `sun_burnthrough_intensity`
+   * times its depth, 0.5 when absent, and `sun_burnthrough_scaler` times their size, 1.75 when absent
+   * (`FNebulaEffect`'s constructor; `DrainMeshAndAsteroids`, `0x51fad9`).
+   */
+  burnthrough?: {
+    intensity?: number;
+    scaler?: number;
+  };
+  /** `[Exclusion Zones]`, in file order: holes in its fog. */
+  exclusions?: readonly NebulaExclusion[];
+  /** Its flashes, of its fog and of a light, which retail gives every nebula. None when absent. */
+  lightning?: NebulaLightning;
+  /** `[Exterior] fill_shape`: the two sheets drawn across it from outside and in its edge. */
+  fill?: TextureShape;
+  /** `[Exterior]`'s bits about it, seen from outside and in its edge. */
+  exterior?: NebulaExterior;
+  /** Its `[Clouds]`, in file order, drawn about the camera in it. */
+  clouds?: readonly Clouds[];
+  /** Its zone's `edge_fraction`, which a puff spawning in its edge is held to. 0 when absent. */
+  edgeFraction?: number;
+}
+/** An `exclusion` of a nebula's file, and its zone, which retail requires to be a sphere. */
+interface NebulaExclusion {
+  zone: Zone;
+  /** The zone's `edge_fraction`, 0 to 1: how far in from its surface the hole deepens. 0 when absent. */
+  edgeFraction?: number;
+  /** `fog_far`: where the fog ends deep in it. None when absent (`NebulaExclusionZone`'s -1). */
+  fogFar?: number;
+  /** Its `zone_shell`, drawn about it while the camera is in it. */
+  shell?: ExclusionShell;
+}
+/** A `zone_shell` and the keys after it (`FNebulaZoneShell`), shared by every zone naming it. */
+interface ExclusionShell {
+  /** The model placed under `world`, its levels picked as the game's camera picks them. */
+  place: (world: Matrix4) => SceneModel;
+  /** The zone's transform, unscaled: `IZone::GetTransform`. */
+  transform: Matrix4;
+  /** `shell_scalar`, at least 1. 1 when absent. */
+  scalar?: number;
+  /** `max_alpha`, at most 1. 1 when absent. */
+  maxAlpha?: number;
+  /**
+   * `exclusion_tint` over 255, each held to 1. Retail leaves it uninitialised when absent, so a shell
+   * without one draws in whatever the heap held: the host decides.
+   */
+  tint: Vector3;
+}
+/** What retail hardcodes about nebulae, and a mod can patch. */
+interface NebulaLimits {
+  /** A `[Fog]` with no `distance` (`FNebulaEffect::Load`). */
+  nebulaFogDistance: number;
+  /** Past the fog's end, the far plane in a core (`FogFarClamp`, `0x5d9668`). */
+  nebulaFarMargin: number;
+  /** The least far plane in a core (`+0x2bc`, set by `FNebulaEffect`'s constructor). */
+  nebulaLeastFar: number;
+  /** Past an exclusion zone's diameter, the least far plane in it (`FogFarClamp`, `0x5db0c0`). */
+  exclusionFarMargin: number;
+}
+export declare const RETAIL_NEBULA_LIMITS: Readonly<NebulaLimits>;
+/** D3D's fog: linear, none nearer than `start` and all of `color` from `end`, or exponential. */
+interface Fog {
+  /** 0 to 1, whole bytes. */
+  color: Vector3;
+  start: number;
+  end: number;
+  /** `D3DFOGMODE`. A nebula's is linear; a room's `fogmode` can be any. Linear when absent. */
+  mode?: 'linear' | 'exp' | 'exp2';
+  /** What `exp` and `exp2` read: `e^-(density × W)`, and `e^-(density × W)²`. */
+  density?: number;
+}
+/** A zone as written: what `shape` can't hold. A sphere's `rotate` turns its axes alone. */
+interface WrittenZone {
+  /** Its `size`, a missing value 0. From `shape` when absent, as the game's files write it. */
+  size?: Vector3;
+  /** Its `rotate`. From `shape` when absent, none for a sphere. */
+  orientation?: Quat;
+}
+/**
+ * `ZONE::GetRadius`, `GetRadiusAlong`, `GetSize`, `GetOrientation` and `GetSurfacePoint` for each
+ * shape the game knows.
+ */
+export declare const zoneOf: (shape: Shape, written?: WrittenZone) => Zone;
+/** `FNebulaEffect::ZoneExteriorFactor`: 0 outside, rising to 1 a fog distance in from its surface. */
+export declare const exteriorFactor: (zone: Zone, distance: number, point: Vector3) => number;
+/**
+ * `ZONE::GetImmersion` (`0x633ac30`) for a zone `radiusAlong` describes, as a sphere is: 0 outside,
+ * rising to 1 an edge fraction of the way in.
+ */
+export declare const immersion: (zone: Zone, edgeFraction: number, point: Vector3) => number;
+/** The exclusion zone the camera is in, and its immersion there (`+0x24`, `+0x28`). */
+interface InExclusion {
+  exclusion: NebulaExclusion;
+  immersion: number;
+}
+/** What `FNebulaEffect::Update` keeps from where the camera is, each frame. */
+interface NebulaState {
+  nebula: SpaceNebula;
+  fogDistance: number;
+  /** `+0x294`: how deep the camera is, over the fog's whole span, up to 1. */
+  depth: number;
+  /** `+0x2ac`, the fog's start. */
+  start: number;
+  /** `+0x2b0`, the fog's end. */
+  end: number;
+  /** How far the camera is outside its surface, negative inside (`Update`'s `D`). */
+  surface: number;
+  /** Only while the camera is in the nebula. */
+  inExclusion?: InExclusion;
+}
+/** `FNebulaEffect::Update`'s depth and fog range. */
+export declare const nebulaState: (nebula: SpaceNebula, eye: Vector3, limits?: NebulaLimits) => NebulaState;
+/** `FNebulaEffect::FogFactor`: where the fog ends for what stands at `point`. */
+export declare const fogEnd: (state: NebulaState, point: Vector3) => number;
+/** `FNebulaEffect::FogFarClamp`: the pass's far plane in its core, before the system's cuts it. */
+export declare const fogFar: (state: NebulaState, limits?: NebulaLimits) => number;
+/** The nebula a point is in, and how far, from 0 to 1: `Gameobj`'s `+0x38` and `+0x3c`. */
+interface Within {
+  state: NebulaState;
+  factor: number;
+}
+/** `StarSysFindNebula` (`0x5553b0`): the `hint` if it holds `point`, or the first that does. */
+export declare const findNebula: (nebulae: readonly NebulaState[], point: Vector3, hint?: SpaceNebula) => Within | undefined;
+/** The nebula the camera answers to (`DAT_00675244`), and how far it's in. */
+interface SpaceField {
+  state: NebulaState;
+  /** `DAT_0067524c`: 0 outside it, 1 in its edge, 2 in its core. */
+  enclosure: 0 | 1 | 2;
+}
+/** A nebula `SelectFieldControllers` leaves to the far list (`ZItemNebula`), keyed by its score. */
+interface DeferredNebula {
+  state: NebulaState;
+  key: number;
+}
+/** The camera's field, and every other nebula, drawn from the far list. */
+interface NebulaList {
+  field?: SpaceField;
+  deferred: DeferredNebula[];
+}
+/**
+ * `SelectFieldControllers` (`0x51b730`): the first nebula the camera is in, taking a core over an
+ * edge, or else the one whose surface is nearest within `range`. Each other nebula is deferred with
+ * the squared distance to its surface, however far, and a field it replaces with the best score.
+ * In a core, none is (`ClearBuckets`, `0x51b9c7`).
+ */
+export declare const listNebulae: (nebulae: readonly NebulaState[], eye: Vector3, range: number) => NebulaList;
+/** `listNebulae`'s field alone. */
+export declare const pickField: (nebulae: readonly NebulaState[], eye: Vector3, range: number) => SpaceField | undefined;
+type Rgb = readonly [number, number, number];
+/** How a host's frames of the sprites look: none of it is the game's. */
+interface SpriteFrameStyle {
+  /** An appearance's outline; none leaves its sprites unframed. */
+  outline: (node: EffectNode) => Rgb | undefined;
+  axisX: Rgb;
+  axisY: Rgb;
+  normal: Rgb;
+  alpha: number;
+}
+interface HookContext {
+  gl: WebGL2RenderingContext;
+  frame: Frame;
+  /** With D3D's pixel shift, so a host's lines land on the pixels the ship did. */
+  viewProjection: Matrix4;
+  /**
+   * Frames each sprite of these effects as this frame's camera has them, whether or not the frame
+   * draws them: an outline, two axes and a normal, under the depth state the hook has set.
+   */
+  outlineEffects: (effects: readonly SceneEffect[], style: SpriteFrameStyle) => void;
+}
+/**
+ * The host's own drawing. It finds the depth buffer the game path left, with no vertex array or
+ * sampler object bound, and may change any GL state: the renderer sets its own again after each hook,
+ * so nothing leaks into the game path.
+ */
+type FrameHooks = Partial<Record<HookName, (context: HookContext) => void>>;
+/** A rectangle of the target in pixels, from its bottom left as GL counts. */
+interface ViewportRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface RenderOptions {
+  /**
+   * Where the picture goes, as D3D's viewport: drawn and cleared there alone, the rest of the target
+   * left as it was. The letterbox's picture, `(0, bar, w, h − 2·bar)`, with the scene's `aspect` its
+   * own (THN-HOST.md, the letterbox). The whole target when absent.
+   */
+  viewport?: ViewportRect;
+}
+interface Renderer {
+  /** Draws, and answers false if there is no context to draw with for now. */
+  render: (frame: Frame, hooks?: FrameHooks, options?: RenderOptions) => boolean;
+  /** Frees what depends on an edited mesh or texture. The next frame uses it afresh. */
+  invalidate: (asset: VMeshData | Texture | CubeTexture) => void;
+  /** Frees everything, and the renderer with it. */
+  dispose: () => void;
+}
+/**
+ * Takes a context, and keeps only GPU handles keyed on what the host's frames hold. So a lost context
+ * needs nothing from the host but the next frame, whose data rebuilds them.
+ */
+export declare const createRenderer: (gl: WebGL2RenderingContext) => Renderer;
+interface Extent {
+  /** In the model's own space. */
+  center: Vector3;
+  radius: number;
+}
+/** The extent of a model as it loads, with its root at the origin. */
+export declare const instanceExtent: (model: RigidModel) => Extent;
+/** An `[EffectType]` row, each key over its built-in one. */
+interface EffectType {
+  priority: number;
+  /** `generic_priority`, for an effect drawn through its generic appearance. */
+  genericPriority: number;
+  /** `lod_type`: which `[EffectLOD]` row, 1 to 6. 0 is none. */
+  lodType: number;
+  radius: number;
+  /** `visibility = EXIST_OFFSCREEN`: unseen, it runs on instead of ending. */
+  existOffscreen: boolean;
+  /** `update = UPDATE_OFFSCREEN`: unseen, its effect still steps (`0x4f8ae9`). */
+  updateOffscreen: boolean;
+  /** `pbubble`: past near, how far it shows narrows from far by `generic_effect_perf`. */
+  pbubble: {
+    near: number;
+    far: number;
+  };
+  /**
+   * `run_time`: seconds it runs before it ends, counted down as it's walked (`0x4f8a57`). Under 0,
+   * until its effect ends; killed, at most 1 more (`0x4f8680`).
+   */
+  runTime: number;
+}
+/** Each row's nickname, which an `[Effect]`'s `effect_type` and an `[EffectType]` name. */
+export declare const EFFECT_TYPE_NAMES: readonly string[];
+/**
+ * An `effect_type` or `[EffectType]` nickname as `SpaceEffect.type` takes it: case and all, as
+ * `EffectTypeIndexFromName` (`0x4fd500`) compares. `undefined` for a name not in the table.
+ */
+export declare const effectTypeIndex: (name: string) => number | undefined;
+/**
+ * An `[EffectType]`'s `lod_type`, `EFT_LOD_TRAIL` to `EFT_LOD_SMALL_DISTANT`, as 1 to 6: any case
+ * (`LoadEffectTypeSection`). `undefined` for any other, which leaves the row's as it was.
+ */
+export declare const effectLodType: (name: string) => number | undefined;
+/**
+ * An `[EffectLOD]`'s `type`, `lod_type_trail` to `lod_type_small_distant`, as the row of
+ * `effectLods` it fills, 1 to 6: any case (`LoadEffectLodSection`, `0x42dae0`).
+ */
+export declare const effectLodRow: (name: string) => number | undefined;
+/** `EFT_NONE` to `EFT_FLASHLIGHT`, the table `[EffectType]` overlays (`.data` `0x612a68`). */
+export declare const RETAIL_EFFECT_TYPES: readonly Readonly<EffectType>[];
+/** An `[EffectLOD]` row: how large on screen, in pixels, it fades in over, and the least it shows at. */
+interface EffectLodSizes {
+  maxLodScreenSize: number;
+  minLodScreenSize: number;
+  minScreenSize: number;
+}
+/** What the retail effect is drawn under, besides the camera. */
+interface EffectViewOptions {
+  /** The `generic_effect_perf` option, 0 to 1. 1 when absent: every priority shows, to `pbubble`'s far. */
+  effectDetail?: number;
+  /** Over `RETAIL_EFFECT_TYPES`, by index. */
+  effectTypes?: readonly (Partial<EffectType> | undefined)[];
+  /** `[EffectLOD]` rows by `lod_type`, 1 to 6. None when absent, as the static initialiser's -1s. */
+  effectLods?: readonly (EffectLodSizes | undefined)[];
+  /** The viewport's width in pixels, which the LOD's screen size reads. No LOD when absent. */
+  viewportWidth?: number;
+}
+/** A placed effect, as the view test asks of it. */
+interface PlacedEffect {
+  type: number;
+  /** Where it is: its world transform's translation. */
+  position: Vector3;
+  /** Drawn through its `[Effect]`'s generic appearance, which has its own priority. */
+  generic?: boolean;
+  /** The ship or solar it's on. */
+  watched?: {
+    position: Vector3;
+    /** Its cloak, 0 to 1. At 1 the effect hides. */
+    cloak?: number;
+    /** The nebula it was last in, tried first. */
+    nebula?: SpaceNebula;
+  };
+}
+/**
+ * `draw`: seen. `run`: unseen, and `EXIST_OFFSCREEN`. `die`: unseen, and frozen in place to end.
+ * `hold`: not walked this frame, so neither drawn nor stepped, as in a gate tunnel.
+ */
+interface EffectView {
+  fate: 'draw' | 'run' | 'die' | 'hold';
+  /** The `ALCHEMY_LOD` blend, 0 to 1, for its next step's `lod`. */
+  lod: number;
+}
+/** The camera's place in the frame: its view, its nebula, and the system's nebulae. */
+interface EffectViewFrame {
+  camera: Camera;
+  aspect: number;
+  view: Matrix4;
+  field?: SpaceField;
+  nebulae: readonly NebulaState[];
+}
+/**
+ * `UpdateVisibility` and what `EffectTypeBucketWalk` does with it. The game keeps last frame's answer
+ * where it doesn't test, but clears it once an effect draws, so that answer is taken as unseen.
+ */
+export declare const viewEffect: ({ type, position, generic, watched }: PlacedEffect, { camera, aspect, view, field, nebulae }: EffectViewFrame, { effectDetail, effectTypes, effectLods, viewportWidth }?: EffectViewOptions) => EffectView;
+/** A zone with a `spacedust`, which sets its `0x200000` property. */
+interface DustZone {
+  zone: Zone;
+  /** Its `edge_fraction`, 0 when absent. */
+  edgeFraction?: number;
+  /** `spacedust`: an `[Effect]` nickname. Empty as written empty. */
+  dust: string;
+  /** `spacedust_maxparticles`, 0 when absent, which takes 50. */
+  maxParticles?: number;
+}
+/** A started dust effect: what a `SpaceEffect` is but where it is. */
+type DustEffect = Omit<SpaceEffect, 'position' | 'watched'>;
+/** The options `SpaceDustUpdate` reads. */
+interface DustOptions {
+  /** `space_dust_detail` from `PerfOptions.ini`, 1 when absent (`DAT_00614080`). */
+  detail?: number;
+  /** Game option `0x19`, on when absent. Off, each frame drops every dust effect first. */
+  background?: boolean;
+  /** Each effect type's `run_time`, by index: how long a killed one winds down. -1 when absent. */
+  runTimes?: readonly (number | undefined)[];
+}
+/** `SpaceDustUpdate`'s numbers, which a mod can patch. */
+interface DustLimits {
+  /** `DAT_00614084`: the dust's frame, along the camera's Z. */
+  offset: number;
+  /** `DAT_005c8930`: zone dust runs only above this detail. */
+  detailThreshold: number;
+  /** `DAT_005d3e94`: a zone dust's intensity for each of its particles. */
+  intensityPerParticle: number;
+  /** `0x54c013`: a zone's particles when it writes none. */
+  defaultZoneParticles: number;
+  /** `DAT_005c75f0`: a fading dust at or under this intensity is killed. */
+  fadeCutoff: number;
+  /** `FUN_0054bde0`: the system dust's particles at full and at no detail. */
+  systemParticles: {
+    full: number;
+    none: number;
+  };
+  /** `DAT_005e08f8`: the system dust's intensity for each of those. */
+  systemIntensityPerParticle: number;
+  /** `SpaceEffectsDrawFrame` (`0x4f7600`): the most one walk steps an effect by. */
+  maxStep: number;
+}
+export declare const RETAIL_DUST_LIMITS: Readonly<DustLimits>;
+/** A dust effect in the frame's walk, and when it joined it. */
+interface DustEffectAt {
+  effect: SpaceEffect;
+  serial: number;
+}
+/** Where the dust is: its world, and its point. */
+interface DustFrame {
+  world: Matrix4;
+  position: Vector3;
+}
+/**
+ * `GetSmallestZoneWithPropertiesAt(point, 0x200000)` (`0x633b620`): the zone with the least
+ * `GetRadius` that holds the point, the first of equals. Retail asks its zone tree, whose order
+ * isn't read; this takes the order given, so only equal radii can differ.
+ */
+export declare const smallestDustZone: (zones: readonly DustZone[], point: Vector3) => DustZone | undefined;
+export declare class SpaceDust {
+  #private;
+  /** `[Dust] spacedust`, empty when the system has none. */
+  readonly system: string;
+  /** Starts the `[Effect]` of a nickname: none when there's no such archetype. */
+  readonly start: (name: string) => DustEffect | undefined;
+  readonly limits: Readonly<DustLimits>;
+  /**
+   * `FUN_0054bde0`, from `StarSysLoadIni`'s `[Dust]`: a system with no such section passes none, and
+   * its particles stay 0.
+   */
+  constructor(system: string | undefined, start: (name: string) => DustEffect | undefined, limits?: Partial<DustLimits>);
+  /** Every effect it holds, released at once: for a host done with this dust. */
+  release(): void;
+  /**
+   * The dust's frame: the camera's, `offset` along its Z (`FUN_0054c320`). That axis is the
+   * orientation's third column, `(x.z, y.z, z.z)`.
+   */
+  frame({ position, orientation }: Camera): DustFrame;
+  /**
+   * `SpaceDustUpdate` (`FUN_0054beb0`) from `StarSysUpdate`, then each linked effect stepped as the
+   * walk does, by at most `maxStep`. Zone dust runs only above the detail threshold: the zone is the
+   * smallest of `zones` that holds the dust's point, its intensity its particles over 500 times
+   * its immersion there. A new name hands the old effect to the fading slot, which runs at the
+   * rest of that immersion until it's under `fadeCutoff`. The system's dust starts on the first
+   * update and is placed from the next, at 80 particles over 500, or toward 30 as detail falls.
+   */
+  update(camera: Camera, step: number, zones: readonly DustZone[], { detail, background, runTimes }?: DustOptions): void;
+  /** The effects for the frame's walk, newest linked first, each where it was last placed. */
+  effects(): DustEffectAt[];
+  /**
+   * What the frame's view test made of `effects()`, in its order. Unseen and not
+   * `EXIST_OFFSCREEN`, an effect is frozen and dead, and isn't placed again (`0x4f789f`).
+   */
+  viewed(views: readonly (EffectView | undefined)[]): void;
+}
+/** A `[Band]` as written, over `FUN_0054c580`'s defaults. The host reads the INI. */
+interface BandSettings {
+  /** `shape`: only its texture is used. Without one the band draws nothing. */
+  shape?: TextureShape;
+  /** `texture_aspect`, 1 when absent; read times 1.15. */
+  textureAspect?: number;
+  /** `height`, 1000 when absent. */
+  height?: number;
+  /** `offset_dist` takes this from the zone's size; `offset_percent` scales the size by it. */
+  offset?: {
+    distance: number;
+  } | {
+    percent: number;
+  };
+  /** `color_shift`, 1 when absent: the field's colours are multiplied by it. */
+  colorShift?: Vector3;
+  /** `fade`'s four distances, in heights: 1500, 2500, 100000 and 130000 when absent. */
+  fade?: readonly [number, number, number, number];
+  /** `vert_increase`, at least 1: points to a ring's segment, and how often U repeats. */
+  vertIncrease?: number;
+  /** `render_parts`, 1 when absent: the pieces the ring is cut into, at most half its points. */
+  renderParts?: number;
+  /** `cull_mode`: 1 hides the faces turned away, 2 those turned toward. 0 when absent. */
+  cullMode?: number;
+  /** `ambient_intensity`, 1 when absent. */
+  ambientIntensity?: number;
+}
+/** What a band takes of its field: the zone's frame and `size` as written, and the field's colours. */
+interface BandField {
+  position: Vector3;
+  orientation: Quat;
+  /** `size` as written; a sphere's has its radius in X alone. */
+  size: Vector3;
+  /** `diffuse_color` over 255. */
+  diffuse: Vector3;
+  /** `ambient_color` over 255. */
+  ambient: Vector3;
+  /** `ambient_increase`, 0 to 255. */
+  ambientIncrease?: Vector3;
+}
+/** One of the pieces the frame lists: a run of the ring's points and the sphere the view tests. */
+interface BandPiece {
+  first: number;
+  last: number;
+  center: Vector3;
+  radius: number;
+}
+/** What the bake lights a band with: the system's `[Ambient]` as written, and the lights it found. */
+interface BandLighting {
+  ambient: Vector3;
+  /** How many lights `CollectNearbyLights` found. With none, nothing is baked. */
+  found: number;
+  lights: readonly SceneLight[];
+}
+export declare class AsteroidBand {
+  readonly settings: BandSettings;
+  /** Its zone's centre, where it is lit. */
+  readonly position: Vector3;
+  /**
+   * `+0x54`: what its alpha is held under. The field's own band keeps 1; an `[ExclusionBand]` takes
+   * `nearFieldFraction` each frame.
+   */
+  private maxAlpha;
+  /** Each point of the ring, in world space, with its outward normal. */
+  readonly points: readonly {
+    position: Vector3;
+    normal: Vector3;
+  }[];
+  readonly halfHeight: number;
+  readonly pieces: readonly BandPiece[];
+  /** The squares of the four fade distances, in world units. */
+  private readonly fades;
+  private readonly diffuse;
+  private readonly ambient;
+  private readonly increase;
+  /** `+0x34` and `+0x38` of each point: its fade, and whether the camera is on its normal's side. */
+  private readonly fade;
+  private readonly facing;
+  /** `+0x1c` and `+0x28`: the colour seen from the normal's side, and from behind. */
+  private front;
+  private back;
+  private baked;
+  constructor(settings: BandSettings, field: BandField);
+  /**
+   * `BandUpdate`: each point's fade from the camera, in by `fade`'s first two distances and out by
+   * its last two, and edge-on below a |cos| of 0.5. Where it's faded out past the far end, its
+   * facing is last frame's. `maxAlpha` is kept for the draw; under 0.001 nothing else is updated.
+   */
+  update(eye: Vector3, maxAlpha?: number): void;
+  /** Whether `bake` has run with lights to bake. */
+  get isBaked(): boolean;
+  /**
+   * `BandBakeLighting`, once: both sides of each point, the ambient plus each light's diffuse by how
+   * squarely it falls, softened round the back, and held under 1. The ambient is the system's
+   * raised by `ambient_increase`, in the band's ambient tint, times `ambient_intensity`.
+   */
+  bake({ ambient, found, lights }: BandLighting): void;
+  /**
+   * `BandDrawPiece`: a quad between each two points of the piece, in two passes, those with either end
+   * turned away and then those turned toward; each end in its side's colour and its fade, under
+   * the alpha `update` was given, U stepping by `vert_increase`. A quad with both ends transparent is left out, and a
+   * piece with none draws nothing. Unlit, blended, both sides, with no depth test or writes.
+   */
+  pieceDraw(index: number): Draw | undefined;
+}
+/** An `[AsteroidBillboards]` section, over the field's constructor defaults. The host reads it. */
+interface BillboardSettings {
+  /** `shape`. None draws nothing. */
+  shape?: TextureShape;
+  /** `count`, truncated, 100 when absent. */
+  count?: number;
+  /**
+   * `size`, ordered least first: a rock is between the two. When absent the constructor's 500 then
+   * 100, unordered, so rocks run from 500 down to 100.
+   */
+  size?: readonly [number, number];
+  /** `start_dist`, 1500 when absent: how far ahead the rocks begin. */
+  startDistance?: number;
+  /** `fade_dist_percent`, held to [0, 1], 0.3 when absent: how much of the sphere fades. */
+  fadePercent?: number;
+  /** `ambient_intensity`, 1 when absent. */
+  ambientIntensity?: number;
+  /** `color_shift`, 1 each when absent. */
+  colorShift?: Vector3;
+}
+/** What a field gives its billboards. */
+interface BillboardField {
+  zone: Zone;
+  edgeFraction?: number;
+  /** `fill_dist`, truncated, and the `Asteroids` option's reach, `(1 - d) · 0.65 + d`. */
+  fillDistance: number;
+  detailScale?: number;
+  cubeSize: number;
+  /** The field's colours: `diffuse_color` and `ambient_color` over 255. */
+  diffuse: Vector3;
+  ambient: Vector3;
+  /** Its exclusion zones; with none, retail has no manager, and every rock stands. */
+  exclusions?: readonly CubeExclusion[];
+}
+/** What the frame lights the billboards with at the camera, after the field's ambient pass. */
+interface BillboardLighting {
+  /** `D3DRS_AMBIENT` as the pass left it: whole bytes, 0 to 1. */
+  ambient: Vector3;
+  /** Up to four directional lights there, each the way it shines (`directionalLightsAt`). */
+  lights: readonly SceneLight[];
+  /** The `LIGHTING` option: off, the rocks are the tinted diffuse. On when absent. */
+  lit?: boolean;
+  /** What the ambient pass left on: the field's nebula's fog. */
+  fog?: Fog;
+}
+interface Rock$1 {
+  position: Vector3;
+  half: number;
+  alpha: number;
+  visible: boolean;
+  flipU: boolean;
+  flipV: boolean;
+  swap: boolean;
+  negate: boolean;
+  /** Its index over the count: rocks past a zone's density are left out. */
+  phase: number;
+}
+export declare class AsteroidBillboards {
+  #private;
+  readonly settings: BillboardSettings;
+  readonly field: BillboardField;
+  readonly random: Random;
+  /** `Float00`: the rocks' sphere. */
+  readonly radius: number;
+  /** `Float04`: how far ahead its centre is. */
+  readonly ahead: number;
+  /** `Float2C`: how much of it fades, short of the centre's depth. */
+  readonly fade: number;
+  /** `Float40` and `Float44`: nearer than the first a rock fades, gone by the second. */
+  readonly nearFade: readonly [number, number];
+  /** `DensityScale`: with no zone's density, rocks past it are left out. */
+  readonly density: number;
+  constructor(settings: BillboardSettings, field: BillboardField, { random, detail }?: {
+    random?: Random;
+    detail?: number;
+  });
+  get rocks(): readonly Readonly<Rock$1>[];
+  /**
+   * `BillboardNearCamera` (`FUN_0054e040`): whether the camera is within the sphere's reach, a
+   * quarter past it, of the field's surface.
+   */
+  near(eye: Vector3): boolean;
+  /**
+   * `BillboardDraw`: the rocks placed afresh in the sphere on a cut, or those that left it on its
+   * surface; faded toward its edge, more narrowly past its centre, and near the cubes' reach.
+   * Opaque rocks draw first, `ALPHAREF` 128 and no blending, then the faded ones blended with no
+   * depth writes, `ALPHAREF` 5. Each a triangle facing the camera, its base on the right or the up,
+   * lit at its corners from the camera's light. Nothing when the camera is far from the field.
+   */
+  draw(camera: Camera, lighting: BillboardLighting, cut?: boolean): Draw[];
+  /** The alpha a rock at `point` draws with, seen from `camera`. */
+  alphaAt(camera: Camera, point: Vector3): number;
+  /**
+   * The rocks' colours seen from `camera`: a corner's toward the right, the left, the up and the
+   * down, and the centre's.
+   */
+  coloursAt(camera: Camera, lighting: BillboardLighting): {
+    corners: Vector3[];
+    centre: Vector3;
+  };
+}
+/** A `[DynamicAsteroids]` section, over the manager's constructor (`FUN_005256a0`). The host reads it. */
+interface DynamicSettings {
+  /** `count`, truncated, 10 when absent. */
+  count?: number;
+  /**
+   * `placement_radius`, 150 when absent. Its spawn point is 0.7 of it ahead, or 75 when absent.
+   * Every retail file also has `placement_offset`, which nothing reads.
+   */
+  placementRadius?: number;
+  /** `max_velocity`, 50 when absent: the most a rock moves on each axis, a second. */
+  maxVelocity?: number;
+  /** `max_angular_velocity`, 5 when absent: the most it turns about each axis, radians a second. */
+  maxAngularVelocity?: number;
+  /** `color_shift`, 1 each when absent. */
+  colorShift?: Vector3;
+}
+/** What a field gives its dynamic asteroids. */
+interface DynamicField {
+  /** The section's `zone`, or the field's: the spawn point must be within it. None, anywhere. */
+  zone?: Zone;
+  /** That zone's `edge_fraction`. 0 when absent. */
+  edgeFraction?: number;
+  /** The field's `diffuse_color` and `ambient_color` over 255. */
+  diffuse: Vector3;
+  ambient: Vector3;
+  /** Its exclusion zones; those with `excludeDynamicAsteroids` keep the spawn point out. */
+  exclusions?: readonly CubeExclusion[];
+}
+/** A started `particle_effect`: what a `SpaceEffect` is but where it is, which the rock gives it. */
+type DynamicEffect = Omit<SpaceEffect, 'position' | 'watched'>;
+/** One rock to draw: its frame and its fade. */
+interface DynamicDraw {
+  world: Matrix4;
+  alpha: number;
+}
+interface Rock {
+  position: Vector3;
+  orientation: Matrix3;
+  velocity: Vector3;
+  /** Its angular velocity about its own axes. */
+  spin: Vector3;
+  /** `Alpha` (`+0xb0`): the fade last worked out, never written when it's made. */
+  alpha: number;
+  /** `bPlaced` (`+0xad`): within the sphere since it was last placed. */
+  placed: boolean;
+  /** Its companion's `particle_effect`, started as it was placed. */
+  effect?: DynamicEffect;
+  /** What the effect's `SetIntensity` was last given: its `sparam`. */
+  intensity: number;
+  /** The `ALCHEMY_LOD` blend its effect's last view gave. */
+  lod: number;
+  /** When its effect started, over every field's: the game walks a type's newest first. */
+  serial: number;
+}
+/** A started rock effect, and when it started. */
+interface DynamicEffectAt {
+  effect: SpaceEffect;
+  serial: number;
+}
+export declare class DynamicAsteroids {
+  #private;
+  readonly settings: DynamicSettings;
+  readonly field: DynamicField;
+  readonly random: Random;
+  /** `SlotCount`: `count` scaled by the `Asteroids` option, `(1 - d) · 0.5 + d`, rounded. */
+  readonly count: number;
+  /** `PlacementRadius` and `PlacementRadiusInner`. */
+  readonly radius: number;
+  readonly ahead: number;
+  /** `TintedDiffuse` and `TintedAmbient`: `color_shift` times the field's, held under 1. */
+  readonly diffuse: Vector3;
+  readonly ambient: Vector3;
+  /** Starts the archetype's `particle_effect` afresh: none when it has none. */
+  readonly effect: (() => DynamicEffect) | undefined;
+  constructor(settings: DynamicSettings, field: DynamicField, { random, detail, effect }?: {
+    random?: Random;
+    detail?: number;
+    effect?: () => DynamicEffect;
+  });
+  get rocks(): readonly (Readonly<Rock> | undefined)[];
+  /** `CliDynamicAsteroidUpdate`'s spawn point: `ahead` along the view, `(m[2], m[5], m[8])`. */
+  centre({ position, orientation }: Camera): Vector3;
+  /** The fade of a rock at a point in the world, under this camera. */
+  alphaAt(camera: Camera, point: Vector3): number | undefined;
+  /**
+   * `CliDynamicAsteroidUpdate`, after the physics has moved the rocks by `step` seconds; the order
+   * of the two is a guess. A rock inside 1.05 of the sphere is faded over its outer 0.35, by the
+   * radius squared. Any other is placed afresh on the sphere, or released if the spawn point is
+   * outside the zone, in a zone that excludes them, or `blocked`: the player's ship in a lane.
+   * Their effects step by `effectStep`, the effect walk's own, `step` when absent.
+   */
+  update(camera: Camera, step?: number, { blocked, effectStep }?: {
+    blocked?: boolean;
+    effectStep?: number;
+  }): void;
+  /**
+   * The rocks' effects for the frame's walk, in slot order, each where its rock is, with when it
+   * started: the frame walks every field's newest first, as the game's list is (`FUN_004fc920`).
+   */
+  effects(): DynamicEffectAt[];
+  /** What the frame's view test made of `effects()`, in its order: each one's `lod` next step. */
+  viewed(views: readonly (EffectView | undefined)[]): void;
+  /**
+   * `CliDynamicAsteroidDraw`'s rocks, in slot order: each above 0.005, at the alpha it was last
+   * faded to, which a rock placed this frame kept from before. Each drawn hands its alpha, held to
+   * [0, 1], to its effect as its intensity (`0x5265c4`, `FParticleEffect::SetIntensity`).
+   */
+  draws(): DynamicDraw[];
+}
+/** Each axis's four angles in radians, `[Cube]`'s `xaxis_rotation` and the rest. */
+type CubeRotations = readonly [readonly number[], readonly number[], readonly number[]];
+/** `CAsteroidField`'s constructor: quarter turns about each axis. */
+export declare const RETAIL_CUBE_ROTATIONS: CubeRotations;
+/** `xaxis_rotation` and its kin as written, in degrees, to `CubeRotations`. */
+export declare const cubeRotations: (degrees: readonly (readonly number[])[]) => CubeRotations;
+/** `CAsteroidField::closest_cube_pos` (`0x45ee0`). */
+export declare const closestCubePosition: ({ x, y, z }: Vector3, size: number) => Vector3;
+/** `compute_cube_id` (`0x62a6010`): 0 for a position past the grid. */
+export declare const cubeId: ({ x, y, z }: Vector3) => number;
+/** An `asteroid =` line's turn, its three angles in degrees as written. */
+export declare const entryOrientation: (x: number, y: number, z: number) => Matrix4;
+/**
+ * `compute_cube_orientation` (`0x62a4010`): an LCG seeded with the cube's id says whether it's
+ * empty, at `frequency`, and which of each axis's four angles turns it.
+ */
+export declare const cubeOrientation: (id: number, rotations: CubeRotations, frequency: number) => Matrix4 | undefined;
+/** One `asteroid =` of a `[Cube]`: the level it draws, and where in the cube. */
+interface CubeAsteroid {
+  mesh: VMeshData;
+  reference: VMeshRef;
+  /** Its offset in the cube: the line's three, each held to [-1, 1], times half a cube. */
+  offset: Vector3;
+  orientation: Matrix4;
+}
+/**
+ * `CliAsteroidMergeCubeMesh`: every asteroid's vertices turned and moved into the cube, one mesh in
+ * list order, drawn whole with the first's material, each copied into `cubeFormat`'s layout.
+ */
+export declare const mergeCube: (asteroids: readonly CubeAsteroid[]) => {
+  mesh: VMeshData;
+  reference: VMeshRef;
+} | undefined;
+/** A zone that takes cubes, as `[Exclusion Zones]` names it. */
+interface CubeExclusion {
+  zone: Zone;
+  /** Its zone's `edge_fraction`. 0 when absent. */
+  edgeFraction?: number;
+  /** `empty_cube_frequency` of its own: then it thins the cubes rather than taking them. */
+  emptyFrequency?: number;
+  /** `exclude_billboards` above 0: no billboard stands in it. */
+  excludeBillboards?: boolean;
+  /** `billboard_count`, truncated, when above 0: how many billboards stand in it. */
+  billboardCount?: number;
+  /**
+   * `exclude_dynamic_asteroids` above 0, on a sphere or an ellipsoid (`062a4f81`): no dynamic
+   * asteroid is placed about a point in it.
+   */
+  excludeDynamicAsteroids?: boolean;
+}
+/** What the cube walk needs of a field, as its file and zone give it. The host reads them. */
+interface CubeField {
+  zone: Zone;
+  /** Its zone's `edge_fraction`. 0 when absent. */
+  edgeFraction?: number;
+  /** `cube_size`, 400 when absent. */
+  cubeSize: number;
+  /** `fill_dist`, 1200 when absent. */
+  fillDistance: number;
+  /** `empty_cube_frequency`, 0 when absent. */
+  emptyFrequency?: number;
+  /** `max_alpha`, 1 when absent. */
+  maxAlpha?: number;
+  /**
+   * `test_asteroid_placement`, set by the key alone: no cube is drawn, though its band, billboards
+   * and dynamic asteroids are (`CliAsteroidDrawNearField`, `0x522a80`). No retail file sets it.
+   */
+  testPlacement?: boolean;
+  rotations?: CubeRotations;
+  exclusions?: readonly CubeExclusion[];
+  /**
+   * `+0x230`: how far the walk reaches, from the `Asteroids` option as last applied, `(1 - d) ·
+   * 0.65 + d`. 1 when absent, as at 1 and at load.
+   */
+  detailScale?: number;
+}
+/** A cube to draw: where, turned how, and how faded. */
+interface CubeDraw {
+  position: Vector3;
+  orientation: Matrix4;
+  /** `max_alpha`, less over the last half cube before the walk's reach. */
+  alpha: number;
+}
+/** `CAsteroidField::near_field` (`0x62a53c0`): within the zone, or near enough its surface. */
+export declare const nearField: (field: CubeField, eye: Vector3) => boolean;
+/**
+ * `CliAsteroidDrawNearField`: the cubes to draw, in the walk's order. A box of cubes spans the view
+ * out to `fill_dist`; each is kept if it's within the side planes and the reach, the zone holds it
+ * past 0.001, no exclusion takes it, and its id doesn't leave it empty. The camera's own cube is
+ * drawn last if the walk missed it. Nothing past `nearField`, nor with `testPlacement`.
+ */
+export declare const fieldCubes: (field: CubeField, camera: Camera, aspect: number,
+/** Counts the centres within view depth and the frustum, which the zone and exclusions are asked. */
+counted?: {
+  tested: number;
+}) => CubeDraw[];
+/** A field as the frame draws it: its cube walk, its merged mesh's lookups, and its colours. */
+interface SpaceAsteroidField extends CubeField {
+  /** `mergeCube`'s mesh, with the lookups its material and textures resolve through. */
+  cube: Pick<SceneModel, 'material' | 'texture' | 'materialMap'> & {
+    mesh: VMeshData;
+    reference: VMeshRef;
+  };
+  /** `diffuse_color` over 255, or `tint_field`'s. */
+  diffuse: Vector3;
+  /** `ambient_color` over 255, or `tint_field`'s. */
+  ambient: Vector3;
+  /** `ambient_increase`, 0 to 255 a channel, added to the ambient the field is lit by. */
+  ambientIncrease?: Vector3;
+  /**
+   * `contains_fog_zone`: lit and fogged by the nebula the camera is in, at its depth. Without, by
+   * the nebula holding its zone's centre, in full.
+   */
+  containsFogZone?: boolean;
+  /** Its `[Band]`, built from its zone and colours. */
+  band?: AsteroidBand;
+  /** Its `[ExclusionBand]`s, in file order, each about its own `zone`. */
+  exclusionBands?: readonly AsteroidBand[];
+  /** Its `[AsteroidBillboards]`, when the `Asteroids` option is above 1 and effects are on. */
+  billboards?: AsteroidBillboards;
+  /**
+   * Its `[DynamicAsteroids]`, in file order, each with its archetype's top level as `mergeCube`
+   * gives it alone: the whole mesh drawn with its first group's material.
+   */
+  dynamic?: readonly {
+    rocks: DynamicAsteroids;
+    model: SpaceAsteroidField['cube'];
+  }[];
+}
+/** A `[lens_glow]`, over `SunEffectBodyInit`'s defaults (`FUN_0050d300`, `FUN_0050d420`). */
+interface LensGlow {
+  /** `shape`. Nothing draws without one, but its samples still block the flare. */
+  shape?: TextureShape;
+  /** `radius_scale`, 2 when absent: the corona's reach, in the star's radii. */
+  radiusScale?: number;
+  /** `inner_color`, at the centre. White when absent. */
+  innerColor?: Vector3;
+  /** `outer_color`, at the rim. White when absent. */
+  outerColor?: Vector3;
+  /** `glow_fade_in_seconds` and `glow_fade_out_seconds`, 0.25 when absent: each sample's easing. */
+  fadeIn?: number;
+  fadeOut?: number;
+  /** `interior_tween`, 0.5 when absent: where the inner ring stands, centre to rim. */
+  interiorTween?: number;
+  /** `interior_ray_tween`, 1 when absent: where on screen the inner ring's rays are cast from. */
+  interiorRayTween?: number;
+  /** `max_LOD`, truncated, 5 when absent: the most samples, from 0 (one) to 5 (25). */
+  maxLod?: number;
+}
+/** What a ray from the camera hits: `PhySys::FindRayCollisions`'s `RayHit`, and its `CObject`. */
+interface RayHit {
+  /** What the host calls the object, compared with the sun's own solar and the player's ship. */
+  object?: unknown;
+  /** `CObject::WorldPosition`. */
+  position: Vector3;
+  /** `CObject::Radius`. */
+  radius: number;
+  /** The part hit is a shield's: it never blocks. */
+  shield?: boolean;
+}
+/** What the corona asks of the frame. */
+interface CoronaView {
+  camera: Camera;
+  view: Matrix4;
+  /** The viewport in pixels. */
+  width: number;
+  height: number;
+  /**
+   * `PhySys::FindRayCollisions` from the camera to `to`, at most `limit` hits. None when absent, so
+   * nothing blocks.
+   */
+  rayHits?: (from: Vector3, to: Vector3, limit: number) => readonly RayHit[];
+  /** The sun's own solar, which its rays pass through (`0x50c767`). */
+  own?: unknown;
+  /** The player's ship from the cockpit, which they pass through too (`0x50c798`). */
+  player?: unknown;
+  /** The corona's fewest samples, `sunLeastLod`. */
+  leastLod: number;
+  /** `1 - ZoneOcclusion`: the corona's alpha. */
+  visibility: number;
+}
+/**
+ * The `SunEffect` option, as `PerfOptions.ini` writes it, to the quality `G_SunEffectQuality`:
+ * times 1.33333, held to 1 (`LAB_00510bf0`). At 0 or less no corona, spine or flare draws.
+ */
+export declare const sunEffectQuality: (option: number) => number;
+/**
+ * The corona's least LOD at a quality: `ftol((1 - Q) · max + 0.5)`. A star is made after the option
+ * is applied and before its `max_LOD` is read, so this is of the default 5 (`0x510e9c`); the option
+ * changed in a system gives its stars their own `max_LOD`'s instead, which the host can pass.
+ */
+export declare const sunLeastLod: (quality: number, maxLod?: number) => number;
+/**
+ * `UpdateIntensity`, the solar's own update: the step the next draw eases by, and the flare's
+ * brightness toward what the corona last showed. Retail's suns write `intensity_fade_in` 0, which
+ * loads as 1e-7, then `zone_occlusion_fade_in`, which lands there too (`0x511381`).
+ */
+export declare const updateStar: (star: Star, step: number) => void;
+/**
+ * Whether the frame since its last update left every fade as it found it: with the camera still,
+ * the next frame would draw it the same, so a host may stop drawing. Not before its first frame.
+ */
+export declare const starSettled: (star: Star) => boolean;
+/** The flare's brightness, `+0x64`, and how much a zone hides it, `+0x34`. */
+export declare const starIntensity: (star: Star) => {
+  intensity: number;
+  zoneOcclusion: number;
+};
+/** One `spine`: its length and width in the star's pixel scale, its colours base to tip, alpha. */
+interface StarSpine {
+  length: number;
+  width: number;
+  innerColor: Vector3;
+  outerColor: Vector3;
+  alpha: number;
+}
+/** A `[spines]` (`FUN_0050fba0`), over `FStarSphere`'s defaults. */
+interface StarSpines {
+  /** `shape`. Nothing draws without one. */
+  shape?: TextureShape;
+  /** `radius_scale`, 1 when absent: every spine's length and width times it. */
+  radiusScale?: number;
+  /** `min_radius` and `max_radius`, 1 and 1000 when absent: the pixel scale held between. */
+  minRadius?: number;
+  maxRadius?: number;
+  /** In file order, spread evenly round from the right, anticlockwise on screen. */
+  spines: readonly StarSpine[];
+}
+/** A `bead` of a `[lens_flare]`: how far along, how big, its colour and alpha. */
+interface FlareBead {
+  along: number;
+  size: number;
+  color: Vector3;
+  alpha: number;
+}
+/** A `[lens_flare]` (`FUN_0050f3a0`), over `FStarSphere`'s defaults. */
+interface StarLensFlare {
+  /** `shape`: its texture, whole. Nothing draws without one. */
+  shape?: TextureShape;
+  /** `min_radius` and `max_radius`, 5 and 800 when absent: the pixel scale held between. */
+  minRadius?: number;
+  maxRadius?: number;
+  /**
+   * Its beads. Retail sorts them by where the heap put them, but they add, so any order gives the
+   * same pixels.
+   */
+  beads: readonly FlareBead[];
+}
+/**
+ * `FStarSphere::Draw` (`LAB_00511ca0`) after the effects: the zone's occlusion eased toward
+ * `zoneBlocked`, what showed of the corona noted for the flare, the sun projected, its samples
+ * cast, then its spines and its corona drawn. Nothing past a zone's full occlusion, nor with the sun
+ * behind.
+ */
+export declare const starCorona: (star: Star, position: Vector3, zoneBlocked: boolean, view: Omit<CoronaView, "visibility">) => Draw[];
+/**
+ * `FStarSphere::DrawFlare` (`LAB_005124f0`), at the cockpit pass's end: the beads along the line
+ * from the sun through the screen's middle, at the screen place and pixel scale the last draw left,
+ * each a square of the whole texture, added by alpha (`SRCALPHA, ONE`). They fade as the sun nears
+ * the middle, brighten with `Intensity`, and go with the zone's occlusion and the sun behind.
+ */
+export declare const starFlare: (star: Star, view: {
+  view: Matrix4;
+  width: number;
+  height: number;
+}) => Draw | undefined;
+/** A `[star_glow]`, over `FStarSphere`'s defaults. `star_glow` and `star_center` both name one. */
+interface StarGlow {
+  /** `shape`, a `tex_shape` of `StarArch.ini`'s `[Texture]`. Nothing draws without one. */
+  shape?: TextureShape;
+  /** `scale`, 1 when absent: times the star's `radius`, half the fan's width. */
+  scale?: number;
+  /** `inner_color`, at the fan's centre. White when absent; each is held to 1 as it's drawn. */
+  innerColor?: Vector3;
+  /** `outer_color`, at its rim. White when absent. */
+  outerColor?: Vector3;
+}
+/**
+ * A `[star]`, which the host reads (`FStarSphere::Load`, `0x511020`). Its `alpha` keys, its
+ * `star_glow`'s included, are read and never used: the fans take their alpha from the caller.
+ */
+interface Star {
+  /** `radius`, 1000 when absent. */
+  radius?: number;
+  /**
+   * `star_glow`: the first of the section's `star_glow` keys that names a `[star_glow]`. With none,
+   * the defaults: no shape, so nothing draws, but its scale of 1 still sizes the star.
+   */
+  glow?: StarGlow;
+  /** `star_center`: the last key's, and none when that names no `[star_glow]`. */
+  center?: StarGlow;
+  /** `lens_glow`: the first that names a `[lens_glow]`. Its defaults when none does. */
+  lensGlow?: LensGlow;
+  /** `spines`: the first that names a `[spines]`. None when none does. */
+  spines?: StarSpines;
+  /** `lens_flare`: the first that names a `[lens_flare]`. None when none does. */
+  lensFlare?: StarLensFlare;
+  /**
+   * `+0x20` and `+0x24`, 1 s each when absent: how fast the flare follows what the corona shows.
+   * `intensity_fade_in` and `_out` write them, a 0 as 1e-7, but so do `zone_occlusion_fade_in` and
+   * `_out`, unheld (`0x511381`, `0x5113b7`): whichever comes last in the section wins.
+   */
+  intensityFade?: {
+    fadeIn?: number;
+    fadeOut?: number;
+  };
+  /**
+   * `+0x28` and `+0x2c`, 2 s each when absent: how fast a zone between hides it. No key reaches them
+   * in retail, which a mod's patch could.
+   */
+  zoneOcclusionFade?: {
+    fadeIn?: number;
+    fadeOut?: number;
+  };
+}
+/** `StarSphereMaxGlowScale` (`0x512620`): the solar's sphere, `Slot178`'s radius about its position. */
+export declare const starRadius: ({ radius, glow, center }: Star) => number;
+/**
+ * `FStarSphere::DrawBillboard` (`0x5118d0`): the star's `star_glow`, then its `star_center` at
+ * `alpha` squared, each a square of `radius × size × scale` across, turned to face the camera about
+ * its up. Unlit, unculled, with no depth test or writes, under `projection`: the camera's own, its far
+ * plane at 250000. The solar's own draw gives an `alpha` and `size` of 1 (`DrawSimple`).
+ */
+export declare const starGlowDraws: (star: Star, position: Vector3, camera: Camera, projection: Matrix4, alpha?: number, size?: number) => Draw[];
+/** One of an object's physics shapes, in the frame its points are in. */
+interface HitboxSurface {
+  surface: Surface;
+  /** Its frame in the world: the object's for the root part's, its own part's for a `!fxd` one. */
+  world: Matrix4;
+}
+/**
+ * An object's collision shapes as `BuildIVP_Real` (`0x6288dd0`) makes them: its `.sur`'s root part,
+ * which holds every fixed child's hulls too, and each `!fxd` part's own. A `.sph` solar's is a ball
+ * of its `solar_radius` instead (`BuildIVP_Sphere`, from `CSolar`'s `0x62b78c5`).
+ */
+interface Hitbox {
+  surfaces?: readonly HitboxSurface[];
+  /** A ball about the object's position. Its hits have no hull, so part 0, never a shield. */
+  ball?: number;
+  /** Whether a hull's id, a part's, is a shield's (`CObject::is_shield_part`). None when absent. */
+  shield?: (id: number) => boolean;
+}
+/** An object a ray can hit, and what the hit reports of it. */
+interface HitboxObject {
+  /** Handed back as the hit's `object`. */
+  object?: unknown;
+  /** `CObject::WorldPosition`. */
+  position: Vector3;
+  /** `CObject::Radius`. */
+  radius: number;
+  hitbox: Hitbox;
+}
+/**
+ * `FindRayCollisions` from `from` to `to`: each hull entered, nearest first, at most `limit`. Inner
+ * nodes' bounding hulls only cull, as IVP's ledge tree uses them.
+ */
+export declare const castRay: (objects: readonly HitboxObject[], from: Vector3, to: Vector3, limit: number) => RayHit[];
+/** Vertices as `x, y, z, u, v`, colours as D3D's bytes `b, g, r, a`, and triangles. */
+interface ImmediateBatch {
+  vertices: number[];
+  colors: number[];
+  indices: number[];
+  count: number;
+}
+/** What retail hardcodes, and a mod can patch. */
+interface BeamLimits {
+  /** The shot's sphere, in the view test (`FUN_004f9540`'s `+0x74`). */
+  radius: number;
+  /** Seconds it fades over, once it's over, and the most it can have left (`DAT_006129cc`). */
+  fade: number;
+  /** Added to `core_length` and `tail_length` for how far it travels while it grows (`DAT_005d9e0c`). */
+  growthPad: number;
+}
+export declare const RETAIL_BEAM_LIMITS: Readonly<BeamLimits>;
+/** A `[BeamSpear]` or `[BeamBolt]`, as `FUN_0042e4a0` reads it: colours are 0 to 1, by 1/255 as a float. */
+interface BeamArchetype {
+  kind: 'spear' | 'bolt';
+  tipColor: Vector3;
+  tailColor: Vector3;
+  coreColor: Vector3;
+  secCoreColor: Vector3;
+  outerColor: Vector3;
+  secOuterColor: Vector3;
+  headBrightness: number;
+  trailBrightness: number;
+  tipLength: number;
+  tailLength: number;
+  coreLength: number;
+  coreWidth: number;
+  secCoreWidth: number;
+  headWidth: number;
+  /** The width on a shot's first frame, from outside the cockpit. */
+  flashSize: number;
+  /** `head_texture = ball`: the top half of the head's V, where anything else has the bottom. */
+  ballHead: boolean;
+  /** `trail_texture = thin`: the left of the trail's U, where anything else has the right. */
+  thinTrail: boolean;
+}
+/** As written, a colour 0 to 255: the keys `[BeamSpear]` and `[BeamBolt]` use. */
+interface BeamSection {
+  kind: BeamArchetype['kind'];
+  tipColor?: Vector3;
+  tailColor?: Vector3;
+  coreColor?: Vector3;
+  secCoreColor?: Vector3;
+  outerColor?: Vector3;
+  secOuterColor?: Vector3;
+  headBrightness?: number;
+  trailBrightness?: number;
+  tipLength?: number;
+  tailLength?: number;
+  coreLength?: number;
+  coreWidth?: number;
+  secCoreWidth?: number;
+  headWidth?: number;
+  flashSize?: number;
+  headTexture?: string;
+  trailTexture?: string;
+}
+/**
+ * A section to what's drawn: each key defaults to 1 (`FUN_0042e430`), then `FUN_0042e920` holds the
+ * lengths to the widths and each brightness to 0.01 to 1. A bolt's tail is held to `sec_core_width`
+ * where a spear's is to `core_width`.
+ */
+export declare const beamArchetype: (section: BeamSection) => BeamArchetype;
+/**
+ * `LookMatrix` (`Common/common_csys.cpp`): the turn whose -Z runs along `direction`. The player's guns
+ * look along each barrel's aim like this, the shot's own orientation aside (`CliBeamActivateEffects`).
+ * Its side is a retail quirk: `(-x, y)` of the negated direction, and `+Y` straight ahead.
+ */
+export declare const lookMatrix: ({ x, y, z }: Vector3) => Matrix3;
+/** Where a shot starts, as `CliBeamActivateEffects` (`0x53f340`) has it. */
+interface BeamStart {
+  orientation: Matrix3;
+  position: Vector3;
+  /** How fast it leaves, which sets how long it takes to grow to its length. */
+  speed: number;
+  /**
+   * The player's own: it looks along each barrel's aim (`lookMatrix`), and a spear's first frame
+   * takes `flash_size`. Only then does a spear flash, and never from the cockpit.
+   */
+  look?: boolean;
+}
+/**
+ * One shot, from the frame it's fired to the frame it's gone. Each frame the host places it, and
+ * `collectSpaceFrame` ages and draws it.
+ *
+ * A hit ends it at once (`FClientBeamGameobj::Slot194`): the host stops giving it. A life that runs
+ * out `kill`s it: it coasts on and fades, and the host drops it once it's `dead`.
+ */
+export declare class BeamEffect {
+  readonly archetype: BeamArchetype;
+  orientation: Matrix3;
+  position: Vector3;
+  private readonly limits;
+  private readonly look;
+  private readonly growth;
+  private age;
+  private left;
+  private velocity?;
+  dead: boolean;
+  constructor(archetype: BeamArchetype, { orientation, position, speed, look }: BeamStart, limits?: Partial<BeamLimits>);
+  /** Where the shot's object is. A killed shot goes on by itself, and this does nothing. */
+  place(orientation: Matrix3, position: Vector3): void;
+  /**
+   * Its life ran out (`LAB_004f97a0`): from its object's velocity it coasts, and fades over
+   * `limits.fade`, or what it has left of that if killed again.
+   */
+  kill(velocity: Vector3): void;
+  /**
+   * One frame of the walk (`EffectTypeBucketWalk`), the step held to 0.1 there: its coast, then
+   * `UpdateVisibility`, then `TickDraw`, ending with what it builds into `batch`, if it's seen.
+   */
+  walk(step: number, seen: BeamSeen, batch: BeamBatch): void;
+  private build;
+}
+/** The view test's answer for a place and radius. */
+type BeamSeen = (position: Vector3, radius: number) => 'draw' | 'run' | 'die';
+/** A frame's vertices and triangles, as `FUN_0046eab0` and `FUN_004fc9a0` append them. */
+interface BeamBatch extends ImmediateBatch {
+  firstPerson: boolean;
+}
+export declare const beamBatch: (firstPerson?: boolean) => BeamBatch;
+/** What retail hardcodes, and a mod can patch. */
+interface TractorLimits {
+  /** The most arms drawn, counting only those holding loot (`JG 0xa`, `0x512e5f`). */
+  arms: number;
+  /** The beam's segment length, and so its quads' (`0x40a00000`). */
+  width: number;
+  /** How far each point strays, by the segment length (`0x3e4ccccd`). */
+  jitter: number;
+  /** The loot's radius, by its physical radius: where the beam stops (`DAT_005cf100`). */
+  lootScale: number;
+  /** The most the beam's end strays in `+x` and `+y` (`0x3f000000`). */
+  endJitter: number;
+  /** Arcs off a loot the tip is in (`0x513227`). */
+  sparks: number;
+  /** An arc's segment length. */
+  sparkWidth: number;
+  /** The arcs' cone, at a tip a whole radius in (`DAT_005db708`, 0.8π). */
+  sparkSpread: number;
+  /** How far back along the beam from the loot's centre the arcs turn about (`DAT_005d3e08`). */
+  sparkPullBack: number;
+  /** A beam quad's length and width past its segment (`DAT_005c9804`). */
+  lineQuad: number;
+  /** An arc quad's (`DAT_005c9800`). */
+  arcQuad: number;
+}
+export declare const RETAIL_TRACTOR_LIMITS: Readonly<TractorLimits>;
+/** One arm holding loot, as `TractorArm` has it this frame. An arm with none is left out. */
+interface TractorArm {
+  /** `GetTipPos`: how far the arm has reached. */
+  tip: Vector3;
+  /** The loot's place (`CObject +0x2c`). */
+  loot: Vector3;
+  /** Its physical radius (`get_physical_radius_r`). */
+  radius: number;
+}
+/**
+ * A working tractor this frame (`IsFunctioning`); the host leaves out one that isn't. Its `color`
+ * and `maxLength` are its `[Tractor]`'s `color` and `max_length`, as written.
+ */
+interface TractorBeam {
+  /** `CETractor::GetSourcePos`. */
+  source: Vector3;
+  maxLength: number;
+  /** 0 to 255, as written: each is truncated to a byte (`FCliTractor::ReadUnknown`). */
+  color: Vector3;
+  /** In the tractor's own order. */
+  arms: readonly TractorArm[];
+}
+/** A `[layer]` of a `[gate_tunnel]`, as `GateTunnelIniLoad` (`0x4fe1c0`) reads it. */
+interface TunnelLayer {
+  /** `texture`, a shape of `FX/effect_shapes.ini`: its texture's first frame, whole. None if not found. */
+  texture?: Texture;
+  /** `color`, 0 to 1: the bytes as written over 255. */
+  color: Vector3;
+  /**
+   * `near_alpha` and `far_alpha`. Retail's files write `near_alpha_factor` and `far_alpha_factor`,
+   * which `Freelancer-original.exe` has no string for, so every retail layer fades from 1 to 0.
+   */
+  nearAlpha: number;
+  farAlpha: number;
+  radiusFactor: number;
+  /** `u_offset` and `v_offset`: where the texture starts, scrolled on by `du` and `dv` a second. */
+  uOffset: number;
+  vOffset: number;
+  du: number;
+  dv: number;
+  vScale: number;
+}
+/** A `[layer]`'s defaults (`0x4fe70c`). */
+export declare const RETAIL_TUNNEL_LAYER: Readonly<TunnelLayer>;
+/**
+ * A `[gate_tunnel]`'s keys, as `GateTunnelIniLoad` reads them. `fade_distance`, `near_alpha` and
+ * `far_alpha` here are never read.
+ */
+interface TunnelSettings {
+  writeDepth: boolean;
+  /** `num_spline_control_points`. Under 2 builds no curves, where retail reads past their ends. */
+  controlPoints: number;
+  /** `x_range`, `y_range` and `z_range`: the path wanders `x` and `y` across, and runs `z` long. */
+  range: Vector3;
+  minRadius: number;
+  maxRadius: number;
+  /** What the radius is ahead of the ship, at the window's far end. */
+  farRadiusFactor: number;
+  /** Of the path, a second. */
+  minSpeed: number;
+  maxSpeed: number;
+  timeToMaxSpeed: number;
+  /** `num_t_steps`: along the path, the first strip's length 1 / it. */
+  tSteps: number;
+  /** `num_s_steps`: around each ring. */
+  sSteps: number;
+  minRotation: number;
+  maxRotation: number;
+  /** `min_rgb` and `max_rgb`, 0 to 1: the colour offsets' range. */
+  minRgb: Vector3;
+  maxRgb: Vector3;
+  /** Two at most: a third is refused. */
+  layers: readonly TunnelLayer[];
+}
+/** `FGateTunnel`'s constructor (`0x4fee30`). */
+export declare const RETAIL_TUNNEL: Readonly<TunnelSettings>;
+/** `SetState`: 0 idle, 1 built for the jump out, 2 in the tunnel, 3 jumping in. */
+type TunnelState = 0 | 1 | 2 | 3;
+/**
+ * One loaded `[gate_tunnel]`. The game keeps one of each and hands it to the player's jump
+ * (`FJumpShipEffect`, `0x503440`), which places it at the archetype's `jump_out_hp` and drives its state;
+ * the host does both. Loading draws its curves, and so does each jump out.
+ */
+export declare class GateTunnel {
+  /** The gate's `jump_out_hp` in the world: the path runs down its -Z, from 5 out. */
+  frame: Matrix4;
+  state: TunnelState;
+  /** Where the ship is along the path, 0 to 1. */
+  phase: number;
+  /** The ship, as `Update` beams it along the path in states 2 and 3: right, up and back, and where. */
+  ship: Matrix4 | undefined;
+  readonly layers: TunnelLayer[];
+  private readonly settings;
+  private readonly random;
+  private readonly pathX;
+  private readonly pathY;
+  private readonly pathZ;
+  private readonly radius;
+  private readonly rotation;
+  private readonly brightness;
+  private readonly offsetR;
+  private readonly offsetG;
+  private readonly offsetB;
+  private speedClock;
+  private segment;
+  private lit;
+  constructor(settings?: Partial<TunnelSettings>, { random }?: {
+    random?: Random;
+  });
+  /**
+   * The light `EnterState1` makes: directional, mostly down, white, flickering once a draw has
+   * switched it on. In the tunnel the player's ship is lit by it alone, over the jump's
+   * `jump_ambient` (`FClientShipGameobj::Slot184`, `0x546480`); `EnterState3` releases it, so a ship
+   * jumping in has none.
+   */
+  get light(): SceneLight | undefined;
+  /** `SetState` (`FUN_004ff360`). */
+  setState(state: TunnelState): void;
+  /** `Update` (`FUN_004ff3c0`), each step of the jump's states 2 and 3. */
+  update(step: number): void;
+  /**
+   * `Draw` (`FUN_004ffab0`): each layer from 0.1 of the path ahead of the ship to 0.01 behind, one
+   * strip around the tube at a time, nearer strips longer by 1.1 each. Unculled and blended, the
+   * first layer by alpha and the second `ONE, INVSRCALPHA`, unlit in its vertex colour times the
+   * texture, which wraps; depth written as `write_depth_buffer` says. It switches the light on.
+   *
+   * Depth is tested `LEQUAL`, Win3D's own state, and the alpha test and fog are what the frame left:
+   * `GREATER 0` and none, as `jump_hole` captured them.
+   */
+  draws(): Draw[];
+  private build;
+  private makeLight;
+  private pathPoint;
+  private pathFrame;
+  private emitLayer;
+}
+interface SpaceObject {
+  /** Not drawn for a sun: its `star` is. */
+  model: SceneModel;
+  /** `get_position`, which its sort distance is from. */
+  position: Vector3;
+  /** `Slot178`, in world space: what it's tested against the view with. */
+  sphere: {
+    center: Vector3;
+    radius: number;
+  };
+  /** Only a solar reaches the far list. Anything else stops at the system's draw range. */
+  solar?: {
+    /**
+     * In `G_LargeSolars` (`0x540d18`), `extent` over 200 and type bit 7 clear: no
+     * `solarQueryRange` limit.
+     */
+    large?: boolean;
+    /**
+     * `CObject::Radius`: the engine's extent of its instance, the root part's top level, not its
+     * `.sur`. `sphere`'s radius when absent.
+     */
+    extent?: number;
+    /** Planet or moon, `TypeBits & 7` with no star sphere: sorted by its surface, not its centre. */
+    planet?: boolean;
+  };
+  /**
+   * A ship's `pilot_mesh`, placed at its `HpPilot` less the pilot's own `HpConnect`
+   * (`AttachPilotMesh`, `0x544380`). Drawn before the model, only where it reflects (`0x546087`).
+   * The game's option 0x1d turns it off, so the host decides.
+   */
+  pilot?: SceneModel;
+  /**
+   * Equipment with a model, each hung on its hardpoint by `attachJoint` and placed with its own
+   * archetype's lists. The engine joins it as the last child of the part holding the hardpoint, so
+   * it draws after that part's subtree (`ConnectInstanceChild`, `RenderInstance`); here, after the
+   * whole model, in the order given. Only the order within the object can differ: batched glass
+   * still waits for its flush, but an unbatched draw on a part with later siblings goes after them.
+   */
+  attached?: readonly SceneModel[];
+  /**
+   * Its lights' flares, in the order its effect list holds them. They join the frame only when it
+   * draws at the first tier (`GameobjSweepEffectList`), and only then do they blink.
+   */
+  flares?: readonly SpaceFlare[];
+  /**
+   * A solar's `star`: a sun. Its draw is its glow and nothing else, neither its model nor what's
+   * attached (`Slot188`, `0x548220`); `sphere` is `starRadius` about its position (`Slot178`). The
+   * game's sun option (0x24) turns it off, so the host decides.
+   */
+  star?: Star;
+  /**
+   * Its collision shapes, which a sun's corona rays test. A hit reports `position` and `CObject::Radius`,
+   * taken as `solar.extent`, else `sphere`'s radius. Nothing to hit when absent.
+   */
+  hitbox?: Hitbox;
+  /** The archetype's `nomad`: goes three lists up, after everything of its kind (`0x51f5b7`). */
+  nomad?: boolean;
+  /** The archetype's `distance_render`. Past it, it stops reflecting, and `lodRange` may apply. */
+  distanceRender?: number;
+  /** The archetype's `LodPick`, the largest of its `LODranges`. Past it, it draws nothing. */
+  lodRange?: number;
+  /**
+   * The nebula it was last in, which retail keeps and tries first. It matters only where nebulae
+   * overlap, and none do in retail. The first that holds it when absent. `null` for none at all: a
+   * solar finds its nebula once, as its `[Object]` is read (`FUN_005485c0`), so one listed before
+   * the system's `[Nebula]` sections has none (`asteroid_nebula`'s plant).
+   */
+  nebula?: SpaceNebula | null;
+}
+/** A space frame, and what became of each of its effects. */
+interface SpaceFrame extends Frame {
+  /**
+   * In the scene's order: an effect with a `position` is drawn, runs unseen, or ends, as the game
+   * would. The host steps it with `lod` next, by no more than `effectMaxStep`. Undefined for one with no position, which draws.
+   */
+  effectViews: (EffectView | undefined)[];
+  /** Each of the scene's `asteroids`, in order: its cubes drawn, and the centres `fieldCubes` tested. */
+  asteroidCubes: {
+    drawn: number;
+    tested: number;
+  }[];
+}
+/** `EffectTypeInfoByIndex`, from `[EffectType]`: the game's walk is by type. */
+interface SpaceEffect extends SceneEffect, Partial<Omit<PlacedEffect, 'type'>> {
+  /** `[EffectType]`'s index, `EFT_NONE` 0. With a `position`, the view test decides it. */
+  type: number;
+}
+interface SpaceScene {
+  /** Its `far` is ignored: the frame's comes from `farClip`, or the field's. */
+  camera: Camera;
+  aspect: number;
+  /** `[Ambient] color`, as written: 0 to 255. */
+  ambient: Vector3;
+  /** Its `[LightSource]`s, in file order. */
+  lights: readonly SpaceLight[];
+  objects: readonly SpaceObject[];
+  /**
+   * The star sphere's layers, in the order to draw them: those `skyLayers` names. Each stands at its
+   * `instanceExtent` centre, as `StarSphereLoadLayer` (`0x552fd0`) moves it.
+   */
+  sky?: readonly SceneModel[];
+  /** `[SystemInfo] space_farclip`, the far plane, past the draw range by `limits.rangeMargin`. */
+  farClip?: number;
+  /** Over `RETAIL_SPACE_LIMITS`, for a mod that patches them. */
+  limits?: Partial<SpaceLimits>;
+  /** Over `RETAIL_COCKPIT_LIMITS`, for a mod that patches them. */
+  cockpitLimits?: Partial<CockpitLimits>;
+  /** Its `[Nebula]`s, in file order: the first that holds a point is the one it's in. */
+  nebulae?: readonly SpaceNebula[];
+  /** Within a type in the order given, which is newest first in the game (`FUN_004fc920`). */
+  effects?: readonly SpaceEffect[];
+  /**
+   * Every gun's shot in flight, newest first as the game's list holds them (`EffectTypeListLink`).
+   * The frame ages them by `step`. A host drops one once it hits, or once it's `dead`.
+   */
+  beams?: readonly BeamEffect[];
+  /** `tex_shape = code_beam`, from `[Texture]` in `effect_shapes.ini`. */
+  beamTexture?: Texture;
+  /** Every working tractor reaching for loot, newest first as the game's list holds them. */
+  tractors?: readonly TractorBeam[];
+  /** `tex_shape = line`, from `[Texture]` in `effect_shapes.ini`. */
+  lineTexture?: Texture;
+  /** `rand()` for the tractors' jitter. */
+  tractorRandom?: Random;
+  /** Over `RETAIL_TRACTOR_LIMITS`, for a mod that patches them. */
+  tractorLimits?: Partial<TractorLimits>;
+  /**
+   * The camera is the cockpit's (`FFirstPersonCamera`): a shot's first frame shows no flash
+   * (`0x4fa2a0`), and the frame goes on with its pass (`FirstPersonCameraSceneDraw`, `0x518420`).
+   */
+  firstPerson?: boolean;
+  /** The HUD option (`0xa`), on: from the cockpit, depth is cleared for it even with no mesh. */
+  hud?: boolean;
+  /** Its mesh, when the `cockpit` option's applied value is over 0.999. Only from the cockpit. */
+  cockpit?: SpaceCockpit;
+  /**
+   * The effects option (`0x25`), off. The host leaves out the effects and rings then; here it says
+   * only that the batcher's bin 1 stays on, so what the cockpit's mesh queues waits for `atEnd`.
+   */
+  effectsOff?: boolean;
+  /** `[System] space_color`, 0 to 1. Deep in a nebula, its fog's colour instead. */
+  background?: Vector3;
+  time?: number;
+  /** The options and data the effects' view test reads. */
+  effectView?: EffectViewOptions;
+  /**
+   * Seconds since the last frame, which each nebula's lightning advances by, and each drawn light's
+   * blink, held to 0.1. 0 when absent.
+   */
+  step?: number;
+  /**
+   * Seconds the camera has had since the last frame, for what answers it rather than the world: the
+   * suns' fades and the nebulae's turning and sorting. `step` when absent, as in the game, where
+   * they're one. A host that stops its world's clock and lets the camera fly passes 0 as `step`.
+   */
+  cameraStep?: number;
+  /** The camera cut to this frame, as it does entering a system: clouds are placed afresh. */
+  cut?: boolean;
+  /** The player's ship is in a trade lane: no dynamic asteroid is placed (`0x525da9`). */
+  lane?: boolean;
+  /** Its asteroid fields, in the order the system lists them. */
+  asteroids?: readonly SpaceAsteroidField[];
+  /** Its planets' rings, which the effects option shows (`0x25`). */
+  rings?: readonly PlanetRing[];
+  /** The viewport in pixels, which flares are sized and clipped in. No flares when absent. */
+  viewport?: {
+    width: number;
+    height: number;
+  };
+  /** `fx/efx.txm`'s `shine`, from `[Texture]` in `effect_shapes.ini`, and its frame. */
+  shine?: {
+    texture: Texture;
+    frame?: FrameRect;
+  };
+  /**
+   * The `SunEffect` option as `PerfOptions.ini` writes it, the effects, sun and sun effects options
+   * (0x25, 0x24, 0x28) being on. With none, or none above 0, no sun's corona draws.
+   */
+  sunEffect?: number;
+  /**
+   * `PhySys::FindRayCollisions`: what a ray from the camera hits. Each hit's `object` is compared
+   * with a sun's own `SpaceObject` and with `player`. From the objects' `hitbox`es when absent.
+   */
+  rayHits?: CoronaView['rayHits'];
+  /** The player's ship, seen from the cockpit: a sun's rays pass through it. None from outside. */
+  player?: unknown;
+  /** The system's space dust, which the frame updates and steps (`StarSysUpdate`, `0x554ecb`). */
+  dust?: SpaceDust;
+  /** Its zones with a `spacedust`, in file order, which `dust` looks among. */
+  dustZones?: readonly DustZone[];
+  /** `space_dust_detail` and game option `0x19`. Run times are the effect types'. */
+  dustOptions?: Omit<DustOptions, 'runTimes'>;
+  /**
+   * The player is jumping, in the tunnel: the frame is the tunnel, the ship and two of the effect
+   * types, and nothing else of the system, whose nebulae, fields and dust it leaves alone.
+   */
+  jump?: SpaceJump;
+}
+/** `[Cockpit] mesh`, placed where `FirstPersonCameraUpdate` has it, under the ship's turn. */
+interface SpaceCockpit {
+  model: SceneModel;
+  /** Its world bounding sphere (`ClientMeshHolderGetBoundingSphere`), which it's lit by. */
+  sphere: {
+    center: Vector3;
+    radius: number;
+  };
+  /** The ship's nebula, as `Slot18c` gives it, and how deep. Its ambient and fog light the mesh. */
+  within?: {
+    state: NebulaState;
+    factor: number;
+  };
+}
+/** What the cockpit's pass hardcodes, and a mod can patch (`0x5c8914`, `0x5c8918`). */
+interface CockpitLimits {
+  near: number;
+  far: number;
+  /** Its mesh keeps to the back of the depth range, behind all the HUD may draw. */
+  depthRange: readonly [number, number];
+  /** The rest, which the pass leaves set for the HUD and the scene's end. */
+  afterDepthRange: readonly [number, number];
+}
+export declare const RETAIL_COCKPIT_LIMITS: Readonly<CockpitLimits>;
+/**
+ * The player's jump while its ship is in states 2 and 3, the tunnel (`SpaceObjDrawPass`, `0x51c235`).
+ * The host steps the tunnel first (`FJumpShipEffect::Update`), which places the ship.
+ */
+interface SpaceJump {
+  /** The player's ship, where the tunnel beamed it. */
+  ship: SpaceObject;
+  /** The gate's descriptor's `jump_tunnel`, when found. */
+  tunnel?: GateTunnel;
+  /** The descriptor's `jump_ambient`, as written, 0 to 255: the ship's ambient. */
+  ambient: Vector3;
+  /** Its `jump_background_color`, as written, 0 to 255: the clear. */
+  background: Vector3;
+}
+/** A `[Background]` key: `basic_stars`, `complex_stars` or `nebulae`. */
+type SkyLayer = 'basic' | 'complex' | 'nebulae';
+/**
+ * The layers that draw, in order, at the `star_sphere` option: never both kinds of stars
+ * (`StarSphereApplyDetail`, `0x552cd0`; `StarSphereRender`, `0x552ea0`). Strictly above each step.
+ */
+export declare const skyLayers: (detail: number) => SkyLayer[];
+/** What retail hardcodes, and a mod can patch. Distances are in world units. */
+interface SpaceLimits extends FrameLimits, NebulaLimits {
+  /** A system with no `space_farclip` (`FUN_00410130`). */
+  farClip: number;
+  /** The least far plane a `space_farclip` can set (`FUN_00410150`). */
+  leastFarClip: number;
+  /** How far short of the far plane the draw range ends (`FUN_00410150`). */
+  rangeMargin: number;
+  /** The far list's plane (`DAT_00610534`). */
+  farListPlane: number;
+  /** How far from the camera a small solar is looked for (`DAT_00613ec8`). */
+  solarQueryRange: number;
+  /** Nearer than this, an object leaves its field's list. Retail holds its square (`0x5dc35c`). */
+  nearDistance: number;
+  /** How deep in another nebula an object can be and still draw (`0x5cbf58`). */
+  otherFieldDepth: number;
+  /** How far short of the draw range a ring piece goes to the far list (`0x5d3d24`). */
+  ringFarMargin: number;
+  /** The most the effect walk steps an effect by: `SpaceEffectsDrawFrame` (`0x4f75eb`). */
+  effectMaxStep: number;
+}
+export declare const RETAIL_SPACE_LIMITS: Readonly<SpaceLimits>;
+export declare const collectSpaceFrame: ({ camera: given, aspect, ambient, lights, objects, sky, farClip, limits, nebulae, effects, background, time, step, cameraStep, effectView, viewport, shine, sunEffect, rayHits, player, rings, cut, lane, asteroids, dust, dustZones, dustOptions, beams, beamTexture, tractors, lineTexture, tractorRandom, tractorLimits, firstPerson, hud, cockpit, cockpitLimits, effectsOff, jump }: SpaceScene) => SpaceFrame;
+/**
+ * The overlay for a frame in a field, or nothing: none at a depth of 0 or less, nor past the frame
+ * that reached 1. The quad runs from the viewport's corner to its last pixel, `0` to `width - 1`
+ * (`GetViewport`'s rectangle ends on it), under `Win3DSetOrtho2DForCamera`, so retail leaves the
+ * last column and row bare. Without a viewport it covers the whole view. Untextured (`0xde1` off),
+ * blended, with no depth test or writes and no culling; `ALPHAREF` is the frame's, 0 as captured.
+ */
+export declare const fogOverlayDraw: ({ nebula, depth }: NebulaState, view: Matrix4, viewport?: {
+  width: number;
+  height: number;
+}) => Draw | undefined;
+/** A `[FlashlightSet]` or `[FlashlightLine]` from a room's INI. The host reads it. */
+interface FlashlightSet {
+  /** `color`, or `icolor` over 255. */
+  color: Vector3;
+  /** The glow's half-size; the bulb's is a quarter of it. */
+  scale: number;
+  /** Seconds between one light's blink and the next's. */
+  gap: number;
+  /** How long each blink lasts. */
+  blink: number;
+  /** The pause after the last light's, before the first's again. */
+  endpause: number;
+}
+/** One light: its colours, sizes and cone, its blink, and where the host has put it. */
+export declare class FlashLight {
+  readonly color: Vector3;
+  readonly minColor: Vector3;
+  readonly bulbSize: number;
+  readonly glowSize: number;
+  /** `flare_cone`'s cosines: the glow's gone below `inner`, and whole from `outer`. */
+  readonly cone: {
+    inner: number;
+    outer: number;
+  };
+  readonly blink: LightBlink;
+  /** Its hardpoint's frame in the world, which the host keeps up to date (`FUN_00558470`). */
+  world: Matrix4;
+  /** The bulb's colour, `min_color` to `color` with the blink, and the glow's, black to `color`. */
+  bulbColor: Vector3;
+  glowColor: Vector3;
+  constructor(color: Vector3, minColor: Vector3, bulbSize: number, glowSize: number, cone: {
+    inner: number;
+    outer: number;
+  }, blink: LightBlink);
+  /**
+   * A `[Light]` on a prop or ship (`FUN_00557700`), `always_on` and with a hardpoint. Its glow is
+   * `color`'s, not `glow_color`'s, and its period and phase are drawn from `rand()`.
+   */
+  static fromLight(light: FlareLight, random?: Random): FlashLight;
+  /** `RoomControlLoadFlashlights` (`FUN_0044a3a0`): one light per frame, staggered by `gap`. */
+  static ofSet({ color, scale, gap, blink, endpause }: FlashlightSet, frames: readonly Matrix4[]): FlashLight[];
+  /** `FUN_00557860`: the blink advanced by `step` seconds, and both colours made from it. */
+  update(step: number): void;
+}
+/** `FUN_005579b0`'s cone term: 1 inside `outer`, 0 past `inner`, a ramp between. */
+export declare const coneLevel: (light: FlashLight, eye: Vector3) => number;
+/** `fx/efx.txm`'s `shine` and `bulb`. */
+interface FlashlightTextures {
+  shine: Texture;
+  bulb: Texture;
+}
+/** At most this many of a prop's or ship's lights draw (`FUN_00558580`); a room's own aren't held to it. */
+export declare const FLASHLIGHTS_PER_SET = 32;
+/**
+ * `DrawFlashlightFlares`: every glow, then every bulb, each a quad facing the camera, added, `LEQUAL`
+ * without writing depth, no culling and no fog. A black one is left out.
+ */
+export declare const flashlightDraws: (lights: readonly FlashLight[], camera: Camera, { shine, bulb }: FlashlightTextures) => Draw[];
+interface RoomShadow {
+  /**
+   * A ship's or a type-5 prop's (`DrawFadingShadows`, slot 11): it fades and grows with height, and
+   * takes its box. Else a character's (`DrawFixedShadows`, slot 12): a fixed size and darkness, under
+   * a point just behind it.
+   */
+  fading: boolean;
+  /** `Float1C`, the floor's height: where the quad lies. A prop's is 0. */
+  floor: number;
+  /** The instance's world, whose position it's under and whose Z axis turns it. */
+  world: Matrix4;
+  /**
+   * Fading only: the box `IRenderer::GetBounds` gives at 1.0 for the instance's archetype. Which part
+   * of a compound answers is unread. Without it, as for an instance with no archetype, the
+   * character's small box.
+   */
+  bounds?: {
+    min: Vector3;
+    max: Vector3;
+  };
+}
+/** What `DrawShadowLike` hardcodes (`DAT_06704064..90`), and a mod can patch. */
+interface ShadowLimits {
+  /** The small box: half its width in X and Z, and what a fixed shadow lifts its quad by. */
+  extentX: number;
+  extentZ: number;
+  lift: number;
+  /** How far along its Z axis a fixed shadow sits: behind, as it's negative. */
+  offset: number;
+  /** Above this height over the floor, no shadow; heights are fractions of it. */
+  fadeRange: number;
+  /** A fading quad's scale: `fadeQuad × fade² + scaleBias`. */
+  fadeQuad: number;
+  scaleBias: number;
+  /** A fading shadow's alpha is this less the fade, a fixed one's `fixedAlpha`; the colour's is its square. */
+  fadeAlpha: number;
+  fixedAlpha: number;
+}
+export declare const RETAIL_SHADOW_LIMITS: Readonly<ShadowLimits>;
+/** One quad: its corners, each `[x, y, z, u, v]`, and the vertex alpha, of 255. */
+interface ShadowQuad {
+  corners: [number, number, number, number, number][];
+  alpha: number;
+}
+/**
+ * One shadow's quad, and the scale it leaves. `DAT_06704078` is a global that only a fading shadow
+ * sets, so a fixed one takes whatever the last fading one left, in this frame or an earlier one.
+ */
+export declare const shadowQuad: ({ fading, floor, world, bounds }: RoomShadow, scale: number, limits?: ShadowLimits) => {
+  quad?: ShadowQuad;
+  scale: number;
+};
+/**
+ * The quad as `DrawShadowLike` states it: lighting off, the texture times white at the quad's alpha,
+ * blended, `LEQUAL`, no culling, no depth written, `ZBIAS` 4. The alpha test and fog are the device's
+ * as the last object left them; the fog is passed, the test is taken as off: uncaptured.
+ */
+export declare const shadowDraw: ({ corners, alpha }: ShadowQuad, texture: Texture, fog?: Fog) => Draw;
+/** A THN `LIGHT` that's on, in world space. Its type is its shape: `SceneLight`'s. */
+interface RoomLight extends SceneLight {
+  /** `LtGrp`: it lights only objects of its group. */
+  group: number;
+}
+interface RoomObject {
+  /**
+   * Its `render_type` (`ThornGetRenderType`) is the model's `sky`: 1 a starsphere, 2 a backdrop
+   * (`FUN_0044af60`). A character's is always a model.
+   */
+  model: SceneModel;
+  /** The engine instance's position, which its lights are picked from. */
+  position: Vector3;
+  /** `SrtGrp`, a signed byte: lower layers draw first. 0 when absent. */
+  layer?: number;
+  /** `LtGrp`. 0 when absent, the `FRoomObject` default. */
+  lightGroup?: number;
+  /** Slot 2. Drawn all the same when false, under black ambient (`FUN_0044ae80`). True when absent. */
+  visible?: boolean;
+  /** Picks lights. Unlit, it has none, and the ambient alone. True when absent. */
+  lit?: boolean;
+  /** The room's fog reaches it. True when absent. */
+  fog?: boolean;
+  /**
+   * The `SCENE` entity's `ambient` it takes in place of the room's, as written: 0 to 255. A
+   * compound gets one only through its scene (`FThornCompound::SetScene`).
+   */
+  ambient?: Vector3;
+  /** Its own effects, a ship's flames, after every model, in its layer's turn. */
+  effects?: readonly SceneEffect[];
+  /** The shadow it casts, drawn just before it: a character's, a ship's with one, a type-5 prop's. */
+  shadow?: RoomShadow;
+  /**
+   * Its `always_on` `[Light]`s, in its translucent pass (slot 8), the first 32: a prop's with its
+   * fourth THN flag set (`FObjectProp::DrawTranslucent`), a ship's (`FObjectShip::DrawTranslucent`).
+   * The host steps and places them.
+   */
+  flashlights?: readonly FlashLight[];
+}
+interface RoomShadows {
+  /** `efxshadow`, from `fx/efx.txm`. */
+  texture: Texture;
+  /** What the last fading shadow left (`DAT_06704078`): the last frame's `shadowScale`. 1 at first. */
+  scale?: number;
+  /** Over `RETAIL_SHADOW_LIMITS`, for a mod that patches them. */
+  limits?: Partial<ShadowLimits>;
+}
+/** A room's frame, and what its shadows leave for the next. */
+interface RoomFrame extends Frame {
+  shadowScale: number;
+}
+interface RoomScene {
+  camera: Camera;
+  aspect: number;
+  /**
+   * In pixels: a part covering under one isn't drawn (`FRoomCamera::ClassifySphere`'s rank 2). Every
+   * part is sized as if the viewport were infinite when absent.
+   */
+  viewport?: Viewport;
+  /** The `SCENE` entity's `ambient`, as written: 0 to 255 (`RoomData`, `+0xd8`). White when absent. */
+  ambient?: Vector3;
+  /**
+   * Every THN light that's on, in the order the script registered them (`DAT_0066d130`). A room's own
+   * list (`+0xe4`) is never filled in retail, nor is its single-light mode ever set (`+0x4fc`).
+   */
+  lights: readonly RoomLight[];
+  /** In the order they were made, which is the order within a layer (`DAT_00679a10`). */
+  objects: readonly RoomObject[];
+  /**
+   * The `SCENE`'s fog, when it's on and the effects and nebula options are (`GfFogIsActive`). Its
+   * `fogtable` N asks D3D for vertex fog, which here is per pixel all the same: uncaptured.
+   */
+  fog?: Fog;
+  /**
+   * With the shadows option, `shadow_glare` and the room's `ShadowLight` all on (`FUN_0044b370`). No
+   * shadows when absent.
+   */
+  shadows?: RoomShadows;
+  /**
+   * The room's own, from its `[FlashlightSet]`s and `[FlashlightLine]`s, after every object's, all
+   * of them, with the effects and flashlights options on. The host steps them (`FRoomRuntime::Update`).
+   */
+  flashlights?: readonly FlashLight[];
+  /** `shine` and `bulb`, which any flashlight needs to draw. */
+  flashlightTextures?: FlashlightTextures;
+  /** The scripts' `PSYS`es, sequence by sequence, after every object's (`FUN_00456740`). */
+  effects?: readonly SceneEffect[];
+  background?: Vector3;
+  time?: number;
+  limits?: Partial<FrameLimits>;
+}
+/** `FUN_00557170`'s cap, through `GfLightsApplyNearest` (`FUN_005572b0`). */
+export declare const ROOM_LIGHTS_PER_OBJECT = 4;
+/**
+ * `GfLightScore` (`FUN_005586f0`): 3 for a directional light, else 2 less its distance squared over
+ * its range squared, a spot outside its half cone taking the angle's cosine for the 2. Undefined for
+ * no range at all, which isn't picked.
+ */
+export declare const lightScore: (light: SceneLight, position: Vector3) => number | undefined;
+/**
+ * `GfLightsSelectNearest` (`FUN_00557170`) and `EngineLightApplyList`: the group's lights, highest
+ * score first, a later one before an equal one, cut to four, and then any under a byte's worth left off.
+ */
+export declare const pickRoomLights: (lights: readonly RoomLight[], position: Vector3, group: number) => SceneLight[];
+/** What one object is lit by: `FUN_0044ae80`, with the lighting option on. */
+export declare const lightRoomObject: ({ lights, ambient, fog }: Pick<RoomScene, "lights" | "ambient" | "fog">, object: RoomObject) => {
+  lights: SceneLight[];
+  ambient: Vector3;
+  fog?: Fog;
+};
+export declare const collectRoomFrame: (scene: RoomScene) => RoomFrame;
+/**
+ * The sheets for a nebula, or nothing: none once the camera's depth reaches 1, nor without a fill
+ * shape, nor when both face the camera. Sheet A stands along the zone's longer of x and z, sheet B
+ * along its y, each `size` × 1.15 from the centre, and across it to the zone's surface × 1.15.
+ * A sphere written with one value has no y, so its sheet B has no height, and draws.
+ *
+ * Unlit, unculled, alpha-blended, with no depth test or writes (`DrawFogShell`), under the 250000 far
+ * plane its callers set; `projection` is that. Fog and `ALPHAREF` are what the frame left: fog is off
+ * wherever retail calls it, as the far list's nodes and `DrawBoltsPass` leave it, and the alpha test
+ * is taken as `GREATER 0`. **Uncaptured.**
+ */
+export declare const fillSheetsDraw: ({ nebula, depth }: NebulaState, eye: Vector3, projection: Matrix4) => Draw | undefined;
+/** One effect where it is this frame. */
+interface EffectPlacement {
+  /** Names its instance across frames: the first frame a key is placed starts it. */
+  key: unknown;
+  /** Starts its `[Effect]` afresh: the instance, its textures and its type. */
+  start: () => DynamicEffect;
+  /** Its world transform, which it steps at and is tested by. */
+  world: Matrix4;
+  /** `SetIntensity`'s value, its `sparam`. 0 when absent. */
+  sparam?: number;
+  watched?: PlacedEffect['watched'];
+  generic?: boolean;
+  /**
+   * Its owner let go (`FParticleEffect::Kill`, `0x4f84d0`): from the first frame that says so its
+   * emitters stop and it has at most a second left. Where it goes then is still the host's.
+   */
+  released?: boolean;
+}
+export declare class PlacedEffects {
+  #private;
+  /**
+   * This frame's effects for `SpaceScene.effects`, newest first. A key not placed again is dropped,
+   * and one that has ended stays out for as long as it's placed: the game destroys an effect it no
+   * longer sees, and nothing starts it again (`0x4f789f`).
+   */
+  place(placements: readonly EffectPlacement[], { effectTypes }?: EffectViewOptions): SpaceEffect[];
+  /**
+   * After the frame, each placed effect as the walk leaves it: unseen and not `EXIST_OFFSCREEN`, it's
+   * destroyed. Otherwise its run time counts down and it ends at 0, or once its effect has; then it
+   * steps by `scene.step`, held to `effectMaxStep`, at its view's LOD, unless it's unseen and its type
+   * isn't `UPDATE_OFFSCREEN` (`0x4f8ae9`). Not walked (`hold`), nothing happens to it.
+   */
+  step(scene: SpaceScene, { effectViews }: Pick<SpaceFrame, 'effectViews'>): void;
+  /** Every effect held, released: for a host done with them all. */
+  release(): void;
+  /** Whether a key's effect has ended, or `undefined` where it isn't held. */
+  ended(key: unknown): boolean | undefined;
+}
+/**
+ * Every part's world transform: `W_child = W_parent · L_child`, the root at `model`. A joint with no
+ * state stands at rest. Parts are keyed by identity.
+ */
+export declare const partTransforms: <T>(root: CompoundNode<T>, model: Matrix4, stateOf?: (part: CompoundNode<T>) => JointState | undefined) => Map<CompoundNode<T>, Matrix4>;
+/**
+ * The joint that hangs `child`'s hardpoint on `parent`'s, as attached equipment is connected
+ * (`ConnectAttachedHardpoints`, `0x62940c0`, then `HardpointConnect`, `EngBase` `IHardpoint` slot 6).
+ * Two revolute hardpoints make a revolute joint limited by the narrower range. Otherwise the child's
+ * type decides: a fixed one lands its point and frame on the parent's, a revolute one turns about its
+ * own axis within its own limits. A revolute joint's orientation is the parent's times the child's,
+ * untransposed as retail has it; no reference attaches a child whose frame isn't the identity.
+ */
+export declare const attachJoint: (parent: Hardpoint, child: Hardpoint) => Joint;
+/** A `bodyparts.ini` group's table: `switch = percent, distance` rows, the percent descending. */
+interface SwitchTable {
+  rows: readonly (readonly [percent: number, distance: number])[];
+  /** Degrees, the whole angle. `RETAIL_SWITCH_FOVX` when the section writes none. */
+  fovx?: number;
+}
+/** What a `[DetailSwitchTable]` with no `fovx` reads. A mod patching it passes its own as `fovx`. */
+export declare const RETAIL_SWITCH_FOVX = 40;
+/** `DetailSwitchTable::get_switch_distance`: linear between rows, clamped at both ends. */
+export declare const switchDistance: ({ rows }: SwitchTable, percent: number) => number;
+/** `adjust_distance`: a narrow lens counts as closer, against the table's own. `fovh` is half the angle. */
+export declare const adjustedDistance: ({ fovx }: SwitchTable, distance: number, fovh: number) => number;
+/** The first level whose distance reaches this one, or none past the table's far cutoff. */
+export declare const costumeLevel: (levels: readonly Level[], table: SwitchTable, distance: number, fovh: number) => number | undefined;
+/** The game's table holds this many, and nothing checks it (`0x65f3898`). Retail's largest is 86. */
+export declare const MAX_BONES = 150;
+interface SkinMesh {
+  mesh: VMeshData;
+  reference: VMeshRef;
+  /** Four bone indices, then four weights, per vertex. */
+  influences: Float32Array;
+}
+/** The same object for the same level, so a renderer's buffers are shared between characters. */
+export declare const skinMesh: (level: Level, bones: number) => SkinMesh;
+/**
+ * `K = W(root)⁻¹ · W(bone) · B`, `B` being `Bone to root` as stored (`Skin`). A slot with no world keeps
+ * the identity, as one past the bound cursor does in retail.
+ */
+export declare const boneTable: (bones: readonly Bone[], worlds: readonly (Matrix4 | undefined)[], root: Matrix4) => Float32Array;
+interface SkinOptions {
+  /** Pinned, clamped to what a part has. The top one when there's neither this nor `lod`. */
+  level?: number;
+  /** Each part's level as the game chooses it, `tables` in part order. */
+  lod?: {
+    camera: Camera;
+    tables: readonly SwitchTable[];
+  };
+  /**
+   * A level at or past this draws rigid, at bind. A costume's default is the builder's, by slot:
+   * the body none, a head or hand 2 (\`0x443b60\`). It goes by position, the first part taken as the
+   * body, so a costume with no body passes its own, or its head skins every level.
+   */
+  skinnedLevels?: readonly number[];
+  jointState?: (bone: CompoundNode<Bone>) => JointState | undefined;
+  /**
+   * The skin as modelled, ignoring the joints. `chain` is the default and what the game draws: its
+   * joints' rest plus `jointState`. On a body that rest is another pose entirely, which it only ever
+   * shows under a script, so a viewer with none playing wants `bind` (library `DEFORMABLE.md`).
+   */
+  pose?: 'chain' | 'bind';
+}
+interface SkinPose {
+  /** Each bone's world, by its place in the table. A slot with none keeps the identity. */
+  worlds: readonly (Matrix4 | undefined)[];
+  /** The part's root bone's world, which the mesh is drawn with. */
+  root: Matrix4;
+  /** Each bone's parent, by the same place, which an eye's offset is read against. */
+  parents?: readonly (number | undefined)[];
+  /** `Flag70` off: every bone the identity (`0x65f6cc6`), so the level draws at bind. */
+  rigid?: boolean;
+}
+/** One level of a part, for a host that poses and joins its own bones. `placeCostume` is the other way in. */
+export declare const poseSkin: (level: Level, bones: readonly Bone[], { worlds, root, parents, rigid }: SkinPose) => PlacedPart;
+/**
+ * Every bone's world in a costume, by part and by its place in the part's table; nothing for a part
+ * with no root. The skeletons join by shared hardpoint name (`0x65f3540`, library `COSTUME.md`):
+ * walking every bone, the first with a name holds it, and a later one with no parent links to it.
+ * That's a part's root, placing the part, or a detached bone, placing one seam.
+ */
+export declare const costumeWorlds: (models: readonly DeformableModel[], transform: Matrix4, { jointState, pose }?: Pick<SkinOptions, "jointState" | "pose">) => (Matrix4[] | undefined)[];
+/**
+ * A character's parts, body first, each drawn with its root's world and skinned relative to it, its
+ * bones joined as {@link costumeWorlds} joins them. A part with no root or level is skipped.
+ */
+export declare const placeCostume: (models: readonly DeformableModel[], transform: Matrix4, { level, lod, skinnedLevels, jointState, pose }?: SkinOptions) => PlacedPart[];
+/** One model, as a costume of one part. */
+export declare const placeSkin: (model: DeformableModel, transform: Matrix4, options?: SkinOptions) => PlacedPart | undefined;
+interface SphereOptions {
+  /** Decides the level and which faces draw. */
+  camera: Camera;
+  /** Of the viewport, in pixels: the level bounds the sphere's error on screen. */
+  width: number;
+  /** Pins a level, for a host choosing its own density. Faces still cull. */
+  level?: number;
+  /** Finds the seventh side's `Scale`, which its shell culls by. 1 if absent. */
+  material?: (id: number) => Material | undefined;
+  /** As on `SceneModel`, for that side's type. */
+  materialMap?: readonly MaterialMapRule[];
+  /** Over `RETAIL_SPHERE_LEVELS`, for a mod that patches them. */
+  levels?: Partial<SphereLevels>;
+}
+/** `FSphereAnim::Init`'s bounds on a sphere's level, and the bias on its pixel size. */
+interface SphereLevels {
+  minimum: number;
+  maximum: number;
+  bias: number;
+}
+export declare const RETAIL_SPHERE_LEVELS: Readonly<SphereLevels>;
+/**
+ * `SolarSpheresApplyDetail` (`0x5488a0`): the maximum, 7 to 10, and the bias, 3 to 1, the
+ * `level_of_detail` option gives a solar's sphere. Retail applies it only as the option changes, to the
+ * solars that exist then (`SetPerfOptionValue`): at startup none do, so a system's planets keep
+ * `RETAIL_SPHERE_LEVELS` until the player moves the slider in it, and lose it when it reloads.
+ */
+export declare const solarSphereLevels: (detail: number) => Pick<SphereLevels, "maximum" | "bias">;
+/**
+ * `UpdateLevel` (`0x6c2c430`), from `metric`, the world size of a pixel at the sphere times the bias.
+ * Out of `acos`'s range, or at no distance, x87's `ftol` gives `INT_MIN`, so the lowest level.
+ */
+export declare const sphereLevel: (radius: number, metric: number, { minimum, maximum }?: Pick<SphereLevels, "minimum" | "maximum">) => number;
+/**
+ * A sphere's visible faces, as parts, then its shell's, which is the same patch under the seventh
+ * material and culls by its own larger radius. Materials repeat by `Sides`, a retail sun naming one.
+ */
+export declare const placeSphere: ({ radius, sides }: Sphere, world: Matrix4, { camera, width, level, material, materialMap, levels }: SphereOptions) => PlacedPart[];
+/** Fixed attribute locations, so every program fits every mesh. */
+export declare const ATTRIBUTE_LOCATIONS: {
+  readonly position: 0;
+  readonly normal: 1;
+  readonly diffuse: 2;
+  readonly uv0: 3;
+  readonly uv1: 4;
+  readonly boneIndex: 5;
+  readonly boneWeight: 6;
+};
+type AttributeName = keyof typeof ATTRIBUTE_LOCATIONS;
+interface VertexAttribute {
+  name: AttributeName;
+  size: number;
+  /** `D3DCOLOR` bytes, B G R A: a shader reading `diffuse` wants `.bgra`. */
+  normalizedBytes: boolean;
+  offset: number;
+}
+interface VertexLayout {
+  stride: number;
+  attributes: VertexAttribute[];
+}
+/** The FVF's layout: position, normal, point size, diffuse, specular, then UV sets. */
+export declare const vertexLayout: (format: VertexFormat) => VertexLayout;
+interface GroupDraw {
+  /** CRC of the material name. */
+  materialId: number;
+  /** Into the reference's index buffer. */
+  byteOffset: number;
+  count: number;
+}
+interface ReferencePlan {
+  /** Absolute vertices, since WebGL2 has no base vertex parameter. */
+  indices: Uint16Array;
+  groups: GroupDraw[];
+}
+/**
+ * A reference's indices made absolute, one buffer per reference. Retail keeps `ref.vertexStart` as
+ * `BaseVertexIndex`, with `group.vertexStart` already added to its indices (`li_elite`, draw 7).
+ */
+export declare const planReference: (data: VMeshData, reference: VMeshRef) => ReferencePlan;
+/** A curve over `[0, 1]`: what `IParamCurve::Evaluate` returns. */
+interface Curve {
+  readonly type: string;
+  evaluate(t: number): number;
+}
+/** A `param_curve` as thorn makes it, or nothing for a class DACOM doesn't have. */
+declare const createCurve: (curve: ParamCurve) => Curve | undefined;
+/** The timing a property animation's progress reads. */
+interface Timing {
+  /** Milliseconds. */
+  start: number;
+  duration: number;
+  curve?: Curve;
+  /** `pcurve_period`, milliseconds; positive loops the curve. */
+  period: number;
+}
+/**
+ * `EvaluateProgress`: 1 for an instant event, else the elapsed fraction, through the curve when
+ * there is one, which a positive period loops as a sawtooth. **Not clamped.**
+ */
+declare const progress: ({ start, duration, curve, period }: Timing, now: number) => number;
+type Frame$1 = Matrix4;
+type Quaternion = Vector4;
+/** An entity's `spatialprops`: `orient`'s triples are `R`'s columns, which the reader has transposed. */
+declare const placement: (pos?: Vector3, orient?: Matrix3) => Frame$1;
+/** `[Rᵀ | −Rᵀ·t]`, as thorn builds every inverse it takes. */
+declare const inverse: (frame: Frame$1) => Frame$1;
+/** `R(q)` scaled by `2/|q|²`, so a non-unit `q` is tolerated: `x86math.dll` `0x6f723c0`. */
+declare const rotationOf: ({ x, y, z, w }: Quaternion) => Frame$1;
+/** `R`'s quaternion, by the trace or else its largest diagonal: `x86math.dll` `0x6f72290`. */
+declare const quaternionOf: (frame: Frame$1) => Quaternion;
+/**
+ * `x86math.dll`'s `+0x58` (`0x6f724d0`), which every "slerp" in thorn is: a normalised lerp,
+ * folded onto `a`'s hemisphere.
+ */
+declare const nlerp: (a: Quaternion, b: Quaternion, t: number) => Quaternion;
+/**
+ * `BuildAxisFrame` (`FUN_06f2e440`): the rotation turning the local `front` axis onto `d`, its `up`
+ * leaning toward the scene's up, or within the pole toward `up × front` of the scene. The two axes
+ * are written as columns and the third is their cross product. Retail's scene axes are always Y and
+ * Z; `6` means those. `d` must not be zero.
+ */
+declare const lookAt: (d: Vector3, front: number, up: number, sceneUp?: number, sceneFront?: number) => Frame$1;
+/**
+ * `ApplyAxisRotFpu` (`0x6f46eef`): a turn of `degrees` about an axis, applied to `base` in scene axes
+ * for X, Y and Z and in its own for the negative names, whose sign is **not** flipped.
+ */
+declare const axisTurn: (base: Frame$1, axis: number, degrees: number) => Frame$1;
+interface Path {
+  /** In the path's own axes. Held at the first and last key outside `(0, 1)`. */
+  position(u: number): Vector3 | undefined;
+  /** The unit Catmull-Rom tangent toward increasing `u`, lerped between samples; not held at the ends. */
+  tangent(u: number): Vector3 | undefined;
+  /** Squad between keys' orientations; a position-only path has none. */
+  orientation(u: number): Quaternion | undefined;
+}
+/**
+ * A path from its `pathprops`, or nothing where thorn's load fails: a `NULL` path, or fewer than two
+ * keys (`0x6f358fb`), and every animation on it does nothing.
+ */
+declare const createPath: (props: PathProps | undefined) => Path | undefined;
+/** The eight `audioprops`, in key order. Only `attenuation` and `pan` reach a sound (`0x457630`). */
+interface AudioState {
+  /** Decibels. */
+  attenuation: number;
+  pan: number;
+  dmin: number;
+  dmax: number;
+  /** Whole degrees. */
+  ain: number;
+  aout: number;
+  atout: number;
+  rmix: number;
+}
+/** An entity's defaults (`0x6f5e198`). */
+declare const DEFAULT_AUDIO: AudioState;
+/** A block over `base`, each key given a bit in key order. */
+declare const readAudio: (props: AudioProps, base: AudioState) => {
+  audio: AudioState;
+  mask: number;
+};
+/** `TickAudioPropAnim`: masked keys from `from` toward `to` by `u`, the angles truncated. */
+declare const blendAudio: (current: AudioState, from: AudioState, to: AudioState, mask: number, u: number) => AudioState;
+/** One sound a script is playing, for the host to play and to keep up to date. */
+interface SoundRecord {
+  entity: string;
+  /** `[Sound]`, or `VoiceProfile_*`, `BackgroundAmbient`, `BackgroundMusic`, `PlayerShipSound`. */
+  template: string;
+  /**
+   * Milliseconds into the sound to play from: `start_time` plus how late in its tick it started
+   * (`0x4574d0`). The game plays it from there.
+   */
+  offset: number;
+  loop: boolean;
+  /** A 3D source at the entity, `C` not applied; otherwise 2D, panned. */
+  spatial: boolean;
+  /** The playback's clock when it started, milliseconds. */
+  started: number;
+}
+/**
+ * What the game sets on a playing sound (`0x457630`): its volume in decibels, the `[Sound]`'s
+ * attenuation plus the entity's and the room's ambience level `L`, each clamped to [−96, 0], and a 2D
+ * sound's pan in DirectSound's hundredths, clamped to ±10,000.
+ */
+declare const soundLevel: (archetype: number, { attenuation, pan }: AudioState, room?: number) => {
+  volume: number;
+  pan: number;
+};
+/** `kThornLightBit*`: which of a block's keys were given. */
+declare const LIGHT_BITS: {
+  readonly color: 1;
+  readonly direction: 2;
+  readonly range: 4;
+  readonly cutoff: 8;
+  readonly on: 16;
+  readonly infinite: 32;
+  readonly atten: 64;
+  readonly theta: 128;
+  readonly type: 256;
+  readonly specular: 512;
+  readonly ambient: 1024;
+  readonly diffuse: 2048;
+};
+/** A light block: the legacy keys and the `D3DLIGHT8` beside them. Angles in radians. */
+interface LightState {
+  on: boolean;
+  infinite: boolean;
+  /** Whole numbers, 0 to 255, which reach nothing once there is a `type`. */
+  color: Vector3;
+  /** In the light's own axes. */
+  direction: Vector3;
+  /** `D3DLIGHTTYPE`: 1 point, 2 spot, 3 directional. */
+  type: number;
+  diffuse: Vector3;
+  specular: Vector3;
+  ambient: Vector3;
+  range: number;
+  atten: Vector3;
+  theta: number;
+  /** `cutoff`, as D3D's `Phi`. */
+  phi: number;
+}
+/** `FUN_06f41840`: a white spot, range 1000, theta 144°, phi 180°, `Att2` 100 over range². */
+declare const DEFAULT_LIGHT: LightState;
+/** `LoadLightProps` (`FUN_06f27fe0`): the keys a block gives, over `base`, and their mask. */
+declare const readLight: (props: LightProps, base: LightState) => {
+  light: LightState;
+  mask: number;
+};
+/**
+ * An entity's light: the record over the defaults. Only with no `type` does thorn derive the
+ * `D3DLIGHT8` from the legacy keys (`0x6f29492`, `0x6f2eb20`): infinite directional, a negative
+ * cutoff a point, else a spot; diffuse the colour over 255, `Att (1, 0, 4/range²)`, twice the range.
+ * Every retail light has a `type`. That rule is the extension's reading, not traced here.
+ */
+declare const lightOf: (props: LightProps | undefined) => LightState;
+/**
+ * `EvalLightProps`: each masked field from `from` toward `to` by `u`, unclamped; the colour truncated
+ * to whole numbers; `on`, `type` and `infinite` switch only once `u` reaches 1. The direction is
+ * lerped and not renormalised.
+ */
+declare const blendLight: (current: LightState, from: LightState, to: LightState, mask: number, u: number) => LightState;
+/**
+ * The room's light for a THN light (`Thorn_Light`, `0x452fa0`, and `GameLight::set_d3d`, `0x411120`):
+ * at thorn's position, `C` not applied, shining along its frame's turn of `direction`. A point's
+ * cone is a whole sphere; a phi past π is π; no attenuation at all is 0.1 constant. Its type is the
+ * one it was made with: a later change is ignored. `lt_grp` picks what it lights.
+ */
+declare const roomLightOf: (light: LightState, madeAs: number, frame: Frame$1, group: number) => RoomLight;
+/** `GfFog`'s one global state, which every script's `SCENE` shares. Zeroed at room setup. */
+interface FogState {
+  on: boolean;
+  /** `fogtable` as passed: true writes `FOGTABLEMODE`, so `Y` is table fog and `N` vertex fog. */
+  table: boolean;
+  /** Whole numbers, 0 to 255. */
+  color: Vector3;
+  /** `D3DFOGMODE`: 0 none, 1 exp, 2 exp2, 3 linear. */
+  mode: number;
+  start: number;
+  end: number;
+  density: number;
+}
+declare const NO_FOG: FogState;
+/** A `fogprops` block's values and mask (`0x6f27c50`): on 1, table 2, colour 4, mode 8, then 0x10–0x40. */
+declare const readFog: (props: FogProps) => {
+  fog: FogState;
+  mask: number;
+};
+/** `TickFogPropAnim`: on, table and mode switch at `u ≥ 1`; the rest lerp, the colour truncated. */
+declare const blendFog: (current: FogState, from: FogState, to: FogState, mask: number, u: number) => FogState;
+/**
+ * The room's fog (`GfFogApply`, `0x454250`): when on and the `fog` option is, in D3D's mode. Per pixel
+ * here whichever of vertex and table fog the script asks for.
+ */
+declare const roomFogOf: (fog: FogState, enabled?: boolean) => Fog | undefined;
+/** The flag word's bits (`ThornScene.h`). Bit 16 is `q_orient`'s, read by nothing here. */
+declare const FLAGS: {
+  readonly LOOP: 8;
+  readonly POSITION: 2;
+  readonly ORIENTATION: 4;
+  readonly LOOK_AT: 8;
+  readonly ENTITY_RELATIVE: 32;
+  readonly PARENT_CHILD: 64;
+  readonly ORIENTATION_RELATIVE: 128;
+  readonly USE_SCRIPT_DURATION: 1;
+  readonly PATH_POSITION: 2;
+};
+/** What an event needs of the playback it runs in. */
+interface Stage {
+  /** Thorn's frame for an entity: scene space, which the host keeps. */
+  frame(entity: number): Frame$1;
+  setPosition(entity: number, position: Vector3): void;
+  setOrientation(entity: number, orientation: Frame$1): void;
+  /** Whether it has an `ICompoundControl`: a `COMPOUND` or `DEFORMABLE`. */
+  compound(entity: number): boolean;
+  /** `ICompoundControl +0x24` for a `target_type` and `target_part`: nothing when it writes nothing. */
+  part(entity: number, type: number, name: string): Frame$1 | undefined;
+  path(entity: number): Path | undefined;
+  /** `ICompoundControl +0x1c`/`+0x20`, which the host makes a parent link of. */
+  connect(event: ThornEvent): void;
+  disconnect(event: ThornEvent): void;
+  /** A camera's or monitor's `{fovh, near, far, aspect}`, as thorn caches them. */
+  cameraProps(entity: number): CameraProps;
+  /** `ApplyCameraProps`: stored, and on from a camera to every monitor linked to it. */
+  setCameraProps(entity: number, props: CameraProps): void;
+  /** `SET_CAMERA`'s link: the monitor follows the camera from now on. */
+  cut(monitor: number, camera: number): void;
+  /** Whether the entity is a `CAMERA` (not a `MONITOR`). */
+  camera(entity: number): boolean;
+  /** A `LIGHT`'s block as its host holds it, or nothing for another entity. */
+  light(entity: number): LightState | undefined;
+  setLight(entity: number, light: LightState): void;
+  /** The host's one fog state, `on` as in effect (`0x454480`). */
+  fog(): FogState;
+  /** `0x6f43140`: pushed by mask. */
+  setFog(fog: FogState, mask: number): void;
+  /** The entity's type. */
+  kind(entity: number): string | undefined;
+  /** `IPSysControl +0xc`: a new instance of its effect; false where the game made no host. */
+  psysStart(entity: number): boolean;
+  /** `+0x10`: the effect killed outright. */
+  psysStop(entity: number): void;
+  /** `+0x1c`: the host's cache of the last `sparam` set, 0 at first. */
+  sparam(entity: number): number;
+  /** `+0x18`: cached, and handed to the effect only while one runs. */
+  setSparam(entity: number, value: number): void;
+  /** The clock after the tick's step, which a starting event is handed (`ClockAfterDt_`). */
+  readonly now: number;
+  /** `ISoundControl +0xc`: plays the entity's sound, cutting off what it was playing. */
+  soundStart(entity: number, record: {
+    offset: number;
+    loop: boolean;
+    spatial: boolean;
+  }): boolean;
+  /** `+0x10`: cut dead. */
+  soundStop(entity: number): void;
+  /** `ICompoundControl +0xc`/`+0x10`: a script started on a compound or character, and stopped. */
+  motionStart(entity: number, motion: MotionRecord): boolean;
+  motionStop(entity: number, motion: MotionRecord): void;
+  /** `IIKControl +0xc`/`+0x14`/`+0x10`: a character's aim, its target re-sent at every update. */
+  aimStart(entity: number, aim: AimRecord): boolean;
+  aimUpdate(entity: number, aim: AimRecord): void;
+  aimStop(entity: number, aim: AimRecord): void;
+  /** `ICompoundControl +0x28`/`+0x14`: a character's floor height. */
+  floor(entity: number): number | undefined;
+  setFloor(entity: number, height: number): void;
+  /** A `SOUND`'s `audioprops`, or nothing for another entity. */
+  audio(entity: number): AudioState | undefined;
+  setAudio(entity: number, audio: AudioState): void;
+  readonly sceneUp: number;
+  readonly sceneFront: number;
+}
+/** A `START_MOTION` as thorn hands it to the host (`ApplyMotionDesc`, parser `0x6f25a9d`). */
+interface MotionRecord {
+  readonly event: Event;
+  animation: string;
+  /** Seconds into each channel. */
+  startTime: number;
+  /** The blend-in, seconds; 0 replaces. */
+  transTime: number;
+  timeScale: number;
+  /** An amplitude, not a mix weight. */
+  weight: number;
+  /** Radians, or −1 for the character's own yaw. Only parsed off a `COMPOUND`. */
+  heading: number;
+  /** Only parsed on a `COMPOUND`: its object map's translation scale. */
+  transScale: number;
+  lockedBone: string | undefined;
+  /** 1 backwards, 2 loop, 4 bounce, 128 keep what is beneath once blended in. */
+  eventFlags: number;
+}
+/** A `START_IK` as thorn hands it on (`BuildIkPose`): the target and the look-at toward it, in scene space. */
+interface AimRecord {
+  readonly event: Event;
+  endEffector: string;
+  countToRoot: number;
+  damping: number;
+  pointAt: boolean;
+  moveTo: boolean;
+  /** Seconds. */
+  transitionDuration: number;
+  eventFlags: number;
+  target: Vector3;
+  /** Turns the joint's `front` onto the target, its `up` toward the scene's. */
+  rotation: Frame$1;
+}
+/** Thorn's four camera slots: `fovh` (half the horizontal angle, degrees), planes, and `hvaspect`. */
+type CameraProps = readonly [fovh: number, near: number, far: number, aspect: number];
+/** One event, from load to finish. */
+interface ThornEvent {
+  /** The action it runs as: a `START_PATH_ANIMATION` on an entity becomes an `ATTACH_ENTITY`. */
+  readonly action: EventTypeName;
+  readonly type: number;
+  readonly source: Event;
+  /** Milliseconds. */
+  readonly start: number;
+  readonly duration: number;
+  readonly flags: number;
+  readonly primary: number;
+  /** −1 for none. */
+  readonly secondary: number;
+  /** Set at start: −1 never ends. */
+  end: number;
+  /** True to join the active list. */
+  begin(stage: Stage): boolean;
+  /** One update at `now`; the engine then asks whether it still runs. */
+  update(stage: Stage, now: number): void;
+  /** Its end, or every running event's at a stop: `FThornEvent::Stop`. */
+  finish?(stage: Stage): void;
+}
+/**
+ * Seconds to whole milliseconds: `time · 1000` rounded to the x87's 24-bit precision, which D3D8
+ * leaves it at without `FPU_PRESERVE`, then chopped (`LuaMillisecondsToRetailInt`).
+ */
+declare const milliseconds: (seconds: number) => number;
+/**
+ * The flag word: bit 1 when `duration` is nil (`0x6f25760`), then a `flags` key replaces it whole
+ * (`0x6f257c9`). `STREAM` and `FOG_PROPS_REMOVED` have no measured bit, so count for nothing.
+ */
+declare const flagWord: (event: Event) => number;
+/** The actions this library runs. The rest are scheduled and timed, and do nothing yet. */
+declare const RUN: ReadonlySet<EventTypeName>;
+/**
+ * Every event the factory accepts, in script order: a first target that names an entity, and a
+ * second that does when given or required. Entity ids are the script's order, first name winning.
+ */
+declare const eventsOf: (script: Script) => ThornEvent[];
+/** One `rtcslider.ini` line: `set = name, t` on at `t` and above, `set_less` below `t`. */
+interface RtcSetting {
+  name: string;
+  threshold: number;
+  less?: boolean;
+}
+/**
+ * `RtcSlider::is_enabled` (`common!0x627a920`): the first line for a name, ignoring case (`CreateID`), at
+ * the player's cutscene-detail `slider`. A name with no line is on.
+ */
+declare const rtcEnabled: (settings: readonly RtcSetting[], slider: number, name: string) => boolean;
+/** A `userprops` value, its key matched ignoring case as thorn's map does (`_memicmp`). */
+declare const userProp: (entity: Entity, key: string) => string | undefined;
+interface SpawnOptions {
+  /** `rtcslider.ini`'s lines. Every name is on when absent. */
+  rtc?: readonly RtcSetting[];
+  /** The cutscene-detail slider, 0 to 1. */
+  slider?: number;
+}
+/**
+ * Whether the game makes a host for an entity: not when its `priority` is a setting the slider has
+ * off, nor a `PSYS` with no `priority` while `script_particles` is off (`0x44efd3`).
+ */
+declare const spawns: (entity: Entity, { rtc, slider }?: SpawnOptions) => boolean;
+/** `ThornGetRenderType` (`common!0x627c0b0`): `usr_flg` bit 0 starsphere, bit 1 backdrop, which wins. */
+declare const renderTypeOf: (entity: Entity) => "starsphere" | "backdrop" | undefined;
+/** A compound or character the room draws, all but its model. */
+interface RoomEntity {
+  entity: Entity;
+  /** `template_name`, `NULL` as nothing, the entity's own name when absent (`0x6f28a60`). */
+  template: string;
+  /** `userprops.category`, which the host resolves `template` by, case included. */
+  category: string | undefined;
+  /** Where the host puts it: `C · T`. */
+  world: Frame$1;
+  /** Its starsphere or backdrop render type, which the host gives the model as `sky`. */
+  sky: 'starsphere' | 'backdrop' | undefined;
+  /** `running_lights`: whether its `always_on` lights draw. */
+  runningLights: boolean;
+  /** The `RoomObject` fields this decides. */
+  object: Omit<RoomObject, 'model'>;
+}
+/**
+ * Every `COMPOUND` and `DEFORMABLE` the game spawns, in script order, with what `SetFlags` and the
+ * spawn give its room object (`0x44de85`, `FThornCompound::SetFlags`): `LIT_AMBIENT` is `visible`,
+ * `LIT_DYNAMIC` is `lit`, fog unless `nofog`, `srt_grp` its signed layer, `lt_grp` its light group,
+ * and its scene's ambient. A `REFERENCE` is another script's, so isn't here.
+ */
+declare const roomEntities: (playback: Playback, options?: SpawnOptions) => RoomEntity[];
+/** What the host answers for its entities, by name. Every frame is in the entity's own space. */
+interface ThornHost {
+  /**
+   * A hardpoint's frame relative to the entity's root at its current pose, or nothing found. The game
+   * matches names ignoring case, the last duplicate winning (`HardpointSummary::find_name`).
+   */
+  hardpoint?(entity: string, name: string): Frame$1 | undefined;
+  /** A `DEFORMABLE`'s bone by name, ignoring case, relative to its root; nothing when missing. */
+  bone?(entity: string, name: string): Frame$1 | undefined;
+  /**
+   * `ICompoundControl +0x18` and `IPSysControl +0x14`: a compound's, deformable's or effect's time
+   * moves on, before the events at each update instant and once more by 0 at the end of a tick.
+   */
+  advance?(entity: string, milliseconds: number): void;
+}
+interface PlaybackOptions {
+  loop?: boolean;
+  /**
+   * The host's scene frame `C`: a room character's setpoint over its actor (`ThornScriptGetCsys`),
+   * the identity everywhere else. Thorn's own scene frame is always the identity in the game.
+   */
+  frame?: Frame$1;
+  host?: ThornHost;
+  /** The room's fog, which every script shares: pass one holder to them all. A fresh room's when absent. */
+  fog?: {
+    state: FogState;
+  };
+  /** The `fog` detail option, which `GfFogSetOn` ANDs into `on`. */
+  fogEnabled?: boolean;
+  /**
+   * A new instance of a `PSYS`'s `[VisEffect]`, named by its template ignoring case, or nothing
+   * where there's none. `PlayerShipEngines` is the player ship's own engines: the host's.
+   */
+  createEffect?: (entity: string, template: string) => EffectInstance | undefined;
+  /** The detail gate, which decides which entities get a host at all. */
+  spawn?: SpawnOptions;
+  /**
+   * What runs a compound's or character's scripts and aims: false where the game's host answers
+   * other than `S_OK`. The records are kept either way, and every start succeeds without one.
+   */
+  characters?: CharacterHost;
+  /**
+   * What a `REFERENCE` binds to: a live entity of that type and name in another script, by name, or
+   * where the room's set script puts it, in this script's space; nothing leaves it at its record.
+   */
+  resolve?: (type: Entity['type'], name: string) => {
+    playback: Playback;
+    name: string;
+  } | {
+    frame: Frame$1;
+  } | undefined;
+}
+/**
+ * A `CONNECT_HARDPOINTS` while it runs. The game finds the part owning each hardpoint, names
+ * ignoring case, and links the child's under the parent's so the two hardpoints meet:
+ * `childPart = parentPart · H_parent · inverse(H_child)` ({@link connectedFrame}, `0x44fdd0`).
+ */
+interface Connection {
+  readonly event: ThornEvent;
+  readonly child: string;
+  readonly hardpoint: string;
+  readonly parent: string;
+  readonly parentHardpoint: string;
+}
+/**
+ * Where a connected child part goes (`engbase.dll` `0x6626690`): the parent part's world frame, its
+ * hardpoint's frame on it, and the child's hardpoint on the child part. Fixed hardpoints only; a
+ * revolute or prismatic child takes a branch not decoded.
+ */
+declare const connectedFrame: (parentPart: Frame$1, parentHardpoint: Frame$1, childHardpoint: Frame$1) => Frame$1;
+/**
+ * Thorn's first play from 0 to `milliseconds`, as the game starts a script: started, ticked by 0,
+ * then one exact jump. A rewind isn't this: thorn's restores no transform.
+ */
+declare const replay: (script: Script, milliseconds: number, options?: PlaybackOptions) => Playback;
+/** A camera or monitor in the world, as its host holds it. */
+interface CameraView {
+  world: Frame$1;
+  /** Half the horizontal angle, degrees. */
+  fovh: number;
+  near: number;
+  far: number;
+  /** `hvaspect`, which the game never reads: its aspect getter and setter are stubs (`0x454190`). */
+  aspect: number;
+}
+/** `FThornScene`'s playback states, as far as a tick tells them apart. */
+type PlaybackState = 'loaded' | 'playing' | 'looping' | 'stopped' | 'done';
+/** The game's compound and character hosts, as far as thorn drives them. */
+interface CharacterHost {
+  startMotion?(entity: string, motion: MotionRecord): boolean;
+  stopMotion?(entity: string, motion: MotionRecord): void;
+  startAim?(entity: string, aim: AimRecord): boolean;
+  updateAim?(entity: string, aim: AimRecord): void;
+  stopAim?(entity: string, aim: AimRecord): void;
+  /** `IDeformable +0x60`: the root's floor, which each motion applies at its next evaluation. */
+  setFloor?(entity: string, height: number): void;
+  /**
+   * A character's root (`0x452ab0`–`0x452c20`): a position write keeps `x` and `z` and discards `y`,
+   * and `root` is where it stands now, root motion and all, which thorn reads back. In thorn's space.
+   */
+  setPosition?(entity: string, position: Vector3): void;
+  setOrientation?(entity: string, orientation: Frame$1): void;
+  root?(entity: string): Frame$1 | undefined;
+  /** `ICompoundControl +0x18`, with the clock. */
+  advance?(entity: string, milliseconds: number): void;
+}
+/**
+ * VC6's `std::sort`, as thorn sorts its master list and each active group: median-of-three
+ * partitions above 16 (`SortMasterPartitions`, `PartitionActiveEventTypes`), then insertion. Equal
+ * keys keep their order only in a range of 16 or fewer.
+ */
+declare const retailSort: <T>(items: T[], key: (item: T) => number) => T[];
+declare class Playback implements Stage {
+  #private;
+  readonly script: Script;
+  /** Milliseconds: `trunc(duration · 1000)`. */
+  readonly duration: number;
+  readonly loop: boolean;
+  readonly host: ThornHost;
+  /** `C`. */
+  readonly sceneFrame: Frame$1;
+  readonly sceneUp: number;
+  readonly sceneFront: number;
+  /** Actions in the script that are scheduled and timed, but whose effect a later step brings. */
+  readonly ignored: readonly EventTypeName[];
+  constructor(script: Script, options?: PlaybackOptions);
+  get state(): PlaybackState;
+  /** `ClockMs_`: the last instant every active event was updated at. */
+  get clock(): number;
+  /** The events running now, in the order they update. */
+  get active(): readonly ThornEvent[];
+  /** Every `CONNECT_HARDPOINTS` running, in the order made: the host links each child part. */
+  get connections(): readonly Connection[];
+  /** An entity's frame in thorn's scene space, by name. */
+  frameOf(name: string): Frame$1 | undefined;
+  /**
+   * Where the host puts an entity: `C · T` for a compound, deformable, camera, monitor or marker,
+   * thorn's `T` as it is for a light, sound or effect (`Thorn_Psys` never applies `C`). A player
+   * ship's `HpMount` offset after it is the host's.
+   */
+  world(name: string): Frame$1 | undefined;
+  /** `StartPlayback` (`LAB_06f39460`), then a tick by `milliseconds`. The game starts at 0. */
+  start(milliseconds?: number): void;
+  /** `StopPlayback`: every running event finished, the clock back at 0. */
+  stop(): void;
+  /**
+   * `Tick` (engine `+0x68`): forward by whole milliseconds. A negative step rewinds to 0 and replays,
+   * **restoring no transform**. Past the end a loop restarts at exactly 0; a script that doesn't
+   * loop finishes every running event and is done.
+   */
+  tick(milliseconds: number): void;
+  frame(entity: number): Frame$1;
+  /** A camera's write goes on to every monitor linked to it (`0x6f41490`, `0x6f414d0`). */
+  setPosition(entity: number, position: Vector3): void;
+  setOrientation(entity: number, orientation: Frame$1): void;
+  cameraProps(entity: number): CameraProps;
+  setCameraProps(entity: number, props: CameraProps): void;
+  light(entity: number): LightState | undefined;
+  setLight(entity: number, light: LightState): void;
+  fog(): FogState;
+  setFog(fog: FogState, mask: number): void;
+  psysStart(entity: number): boolean;
+  psysStop(entity: number): void;
+  sparam(entity: number): number;
+  setSparam(entity: number, value: number): void;
+  /** Every running effect, in the order made: what the room draws of this script's `PSYS`es. */
+  get effects(): {
+    entity: string;
+    instance: EffectInstance;
+  }[];
+  motionStart(entity: number, motion: MotionRecord): boolean;
+  motionStop(entity: number, motion: MotionRecord): void;
+  aimStart(entity: number, aim: AimRecord): boolean;
+  aimUpdate(entity: number, aim: AimRecord): void;
+  aimStop(entity: number, aim: AimRecord): void;
+  floor(entity: number): number | undefined;
+  setFloor(entity: number, height: number): void;
+  /** The scripts running on compounds and characters, in the order started. */
+  get motions(): {
+    entity: string;
+    motion: MotionRecord;
+  }[];
+  /** Every character's running aim, its target as of the last update. */
+  get aims(): {
+    entity: string;
+    aim: AimRecord;
+  }[];
+  /** A character's floor height: its record's, then what `START_FLR_HEIGHT_ANIM` sets. */
+  floorOf(name: string): number | undefined;
+  get now(): number;
+  soundStart(entity: number, { offset, loop, spatial }: {
+    offset: number;
+    loop: boolean;
+    spatial: boolean;
+  }): boolean;
+  soundStop(entity: number): void;
+  audio(entity: number): AudioState | undefined;
+  setAudio(entity: number, audio: AudioState): void;
+  /**
+   * Every sound playing, in the order made, with its entity's `audioprops` now and, for a 3D one,
+   * where thorn has it. The host plays, cuts and adjusts them to match.
+   */
+  get sounds(): (SoundRecord & {
+    audio: AudioState;
+    position: Vector3;
+  })[];
+  kind(entity: number): string | undefined;
+  /** The room's fog as the frame takes it, or none. */
+  get roomFog(): Fog | undefined;
+  /** The `SCENE`'s `ambient`, 0 to 255, as the record writes it: nothing animates it in the game. */
+  get ambient(): Vector3 | undefined;
+  /**
+   * Every `LIGHT` that's on and spawned, in the order made, as the room's (`0x44b450`). A
+   * `REFERENCE` is another script's light.
+   */
+  roomLights(options?: SpawnOptions): RoomLight[];
+  camera(entity: number): boolean;
+  cut(monitor: number, camera: number): void;
+  /** A camera's or monitor's view in the world: its placement through `C`, and its slots. */
+  view(name: string): CameraView | undefined;
+  /** The camera a monitor follows, by name. */
+  linkedCamera(monitor: string): string | undefined;
+  compound(entity: number): boolean;
+  /**
+   * `ICompoundControl +0x24`. A compound answers a hardpoint, or `PART` `root` or `""` with its root,
+   * in **world** space (`0x451b90`: `C` is not undone, and thorn takes it as scene space); any other
+   * part writes nothing. A deformable answers a hardpoint or a bone in scene space (`0x452730`).
+   */
+  part(entity: number, type: number, name: string): Frame$1 | undefined;
+  path(entity: number): Path | undefined;
+  connect(event: ThornEvent): void;
+  disconnect(event: ThornEvent): void;
+}
+/** What a frame hands every sequence: whole milliseconds, and the rest carried to the next. */
+interface FrameMilliseconds {
+  milliseconds: number;
+  carry: number;
+}
+/**
+ * `0x558ac7`–`0x558afa`: the carry plus the frame's seconds, floored to milliseconds, the remainder
+ * kept as a float. At the x87's 24-bit precision, which D3D8 leaves it at.
+ */
+declare const frameMilliseconds: (carry: number, seconds: number) => FrameMilliseconds;
+/**
+ * One script as a sequence plays it (`FGfScript::Start`, `Update`): started and ticked by 0 before
+ * the first frame, then by each frame's milliseconds. The frame that reaches the end, or skips to
+ * it, ticks 100 more, so a script that doesn't loop finishes its events then.
+ */
+declare class ScriptRun {
+  #private;
+  readonly playback: Playback;
+  constructor(playback: Playback);
+  get finished(): boolean;
+  /** `FGfScript::Pause`, as the skip key sets it: the next update jumps to the end, exactly. */
+  skip(): void;
+  /**
+   * `FGfScript::Update`, true once finished. `catchup` is `0x44f500`'s: how far a finished rebuff
+   * voice line lets the scene jump, 0 everywhere else.
+   */
+  update(milliseconds: number, catchup?: number): boolean;
+}
+/** A frame's rotation as the rows a THN `orient` reads into, which a renderer `Camera` takes. */
+declare const rowsOf: ({ x, y, z }: Frame$1) => Matrix3;
+/** A script camera's view as the renderer's `Camera`. */
+declare const cameraOf: ({ world, fovh, near, far }: CameraView) => Camera;
+/**
+ * `FGfCameraPool`: 256 slots. A `MONITOR` registers selectable with its script's priority (1 for
+ * landing, launch and transitions, else 0); a `CAMERA` registers but never shows. A new slot takes
+ * the view only over a strictly lower priority (`Allocate`, `0x450580`); freeing the shown one
+ * re-elects the highest, ties to the lowest slot (`Free`, `0x450680`). None shown: the room's camera.
+ */
+declare class ViewTable {
+  #private;
+  /** The slot shown, or nothing. */
+  get active(): number | undefined;
+  /** A slot for a camera or monitor, or nothing when all 256 are taken. */
+  register(priority: number, selectable: boolean): number | undefined;
+  release(slot: number): void;
+}
+/**
+ * The letterbox: an amount from 0, no bars, to 1, a 1.85:1 picture, moving toward its target at
+ * `speed` a second. A script that takes the camera aims it at 1 and lets go at 0, both at 3.
+ */
+declare class Letterbox {
+  amount: number;
+  target: number;
+  speed: number;
+  animating: boolean;
+  /** `SetLetterboxTarget` (`FUN_0041a0f0`): under an opaque fade it jumps there. */
+  aim(target: number, speed?: number, faded?: boolean): void;
+  /** The head of `UpdateRoomLetterbox` (`FUN_0041a140`): true while it was moving. */
+  step(seconds: number): boolean;
+  /** `GetLetterboxBarHeight`: each bar, in pixels, rounded half up. */
+  bar({ width, height }: Viewport): number;
+  /**
+   * The picture between the bars, and its aspect, which the room camera's projection takes in
+   * place of the surface's, the horizontal angle held.
+   */
+  view(surface: Viewport): {
+    top: number;
+    viewport: Viewport;
+    aspect: number;
+  };
+}
+/**
+ * An entry's kind: 0 plain, 1 an offer's decision, 2 accept, 3 decline or reject, 4 an info box,
+ * 5 a room's traffic, which repeats, 6 a group offer's other branch.
+ */
+type EntryKind = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+interface SequenceEntry {
+  script: Script;
+  kind?: EntryKind;
+  /** The host's scene frame `C`: a room character's setpoint over its actor, else the identity. */
+  frame?: Frame$1;
+}
+/** A sequence's flags (`0x454920`). The host acts on most of them: letterbox, ducking, fades. */
+interface SequenceFlags {
+  loop?: boolean;
+  /** Letterboxed, the UI hidden. */
+  cinematic?: boolean;
+  skippable?: boolean;
+  /** Its live entities are what other scripts' `REFERENCE`s find (`+0x2f`). */
+  exported?: boolean;
+  /** Its monitors' camera priority: 1 for landing, launch and transitions, else 0. */
+  priority?: number;
+}
+declare class Sequence {
+  #private;
+  readonly entries: readonly SequenceEntry[];
+  readonly flags: SequenceFlags;
+  /** The entry playing, or −1 once done. */
+  current: number;
+  run: ScriptRun | undefined;
+  /** The decision's answer, which the host sets from the offer dialog. */
+  answered: boolean | undefined;
+  infoClosed: boolean;
+  constructor(entries: readonly SequenceEntry[], flags?: SequenceFlags, options?: (frame: Frame$1 | undefined) => PlaybackOptions);
+  /** `Play` (`FUN_00454f80`): the first entry starts, ticked by 0. */
+  play(): void;
+  get done(): boolean;
+  get playback(): Playback | undefined;
+  /** The skip key (`0x456840`): a cinematic, skippable sequence skips to its decision, which plays. */
+  skip(): void;
+  /** The offer answered: the looping decision jumps to its end, so the branch starts next update. */
+  answer(accepted: boolean): void;
+  /** `NextEntryIndex` (`FUN_00455fc0`), single player. */
+  next(): number;
+  /**
+   * `FGfScriptSequence::Update` (`FUN_00456150`): skipping runs each entry out to its end, stopping
+   * at a decision or info box; then the live script by `milliseconds`, and the next entry when it
+   * finishes. True once done.
+   */
+  update(milliseconds: number, catchup?: number): boolean;
+}
+/** `FGfScriptManager`: every sequence, updated in the order made with the same milliseconds. */
+declare class SequenceManager {
+  readonly sequences: Sequence[];
+  add(sequence: Sequence): Sequence;
+  /** `FUN_00456650`: each updated; the finished dropped. */
+  update(milliseconds: number): void;
+  skip(): void;
+  /**
+   * `FindCreatedEntity` (`FUN_00456790`): the first live entity of that type and name in the current
+   * script of an exporting sequence, by the order the sequences were made.
+   */
+  find(type: Entity['type'], name: string): {
+    playback: Playback;
+    name: string;
+  } | undefined;
+}
+/** A prop the set script lists: the room's own models. */
+interface SetProp {
+  entity: Entity;
+  template: string;
+  category: string;
+  frame: Frame$1;
+  /** `LIT_AMBIENT`, `LIT_DYNAMIC`, fog unless `nofog`. */
+  visible: boolean;
+  lit: boolean;
+  fog: boolean;
+  /** A `Room` category or a `hardpoint` userprop: the room's main prop. */
+  main: boolean;
+  lightGroup: number;
+  layer: number;
+  sky: 'starsphere' | 'backdrop' | undefined;
+  loadout: string;
+  priority: string | undefined;
+  runningLights: boolean;
+}
+interface SetCamera {
+  name: string;
+  frame: Frame$1;
+  fovh: number;
+  near: number;
+  far: number;
+}
+/** A shadow or glare source: directional along its turned direction, else at its position. */
+interface SetSource {
+  direction?: Vector3;
+  position?: Vector3;
+  color: Vector3;
+}
+interface SetScript {
+  props: SetProp[];
+  /** Every camera, which is a setpoint of the same name too. */
+  cameras: SetCamera[];
+  setpoints: {
+    name: string;
+    frame: Frame$1;
+  }[];
+  /** `LtShadowSource` and `LtGlareSource`. */
+  shadow?: SetSource;
+  glare?: SetSource;
+  /** Any other light that's on: none in retail. */
+  lights: RoomLight[];
+  /** The `SCENE`'s, 0 to 255. */
+  ambient?: Vector3;
+}
+/**
+ * `RoomData::read_set_script` (`common!0x6274ea0`): the set script as data. Its compounds with a `category`
+ * become props, its cameras cameras and setpoints, its markers setpoints, two lights by name the
+ * shadow and glare sources, and the rest of the lights only when on. No event runs.
+ */
+declare const readSetScript: (script: Script) => SetScript;
+/**
+ * `ThornScriptGetCsys` (`0x627be8f`): the first `DEFORMABLE` whose `actor` isn't `player`, upright at
+ * its floor height: `[R | (x, floor_height, z)]`. The identity with none.
+ */
+declare const scriptAnchor: (script: Script) => Frame$1;
+/**
+ * A room character's fidget (`0x445340`): `C = setpoint · G⁻¹`, so its actor lands there. A
+ * conversation runs at `C = I`.
+ */
+declare const anchoredFrame: (setpoint: Frame$1, script: Script) => Frame$1;
+/**
+ * A room's `scene = ambient, path` line (`0x44a540`): a looping, exporting sequence at `C = I`,
+ * priority 0, not cinematic.
+ */
+declare const ambientSequence: (script: Script, options?: (frame: Frame$1 | undefined) => PlaybackOptions) => Sequence;
+/** Event flags a motion reads. */
+export declare const MotionFlag: {
+  readonly Backwards: 1;
+  readonly Loop: 2;
+  readonly Bounce: 4;
+  /** Keep what is beneath once the fade in completes, rather than stopping it. */
+  readonly KeepBeneath: 128;
+};
+/** `MixerEase` (`FUN_0661d050`): a fade's weight at step `i` of 255, `½(1 − cos(i · step))`. */
+export declare const EASE: Float32Array;
+/**
+ * A fade's weight `time` seconds into `duration`: its step is floored, and a zero-length fade is
+ * whole.
+ */
+export declare const fadeWeight: (time: number, duration: number) => number;
+/** One animatable joint: its name, its parent's, and the joint its constraint makes. */
+interface MixerJoint {
+  name: string;
+  parent: string;
+  joint: Joint;
+}
+interface MixerOptions {
+  /** The root bone's name, which object maps drive. */
+  root: string;
+  /** Every joint, a parent before its children. */
+  joints: readonly MixerJoint[];
+  /** The root's placement in the character's frame. */
+  position?: Vector3;
+  orientation?: Quat;
+}
+/** A motion's record, as `START_MOTION` hands it to `IDeformable +0x1c`. */
+interface MotionOptions {
+  /** Seconds into each channel; past any channel's end the motion does not start. */
+  startTime?: number;
+  /** The players' speed, its sign ignored. */
+  timeScale?: number;
+  /** An amplitude on every channel, not a mix weight. */
+  weight?: number;
+  /** The fade in, per target. 0 stops whatever was on each target. */
+  transTime?: number;
+  eventFlags?: number;
+  /** Radians about Y the root faces; negative keeps its current yaw. */
+  heading?: number;
+}
+interface AimOptions {
+  /** The joint's world rotation, in the space the root is placed in: the root's own turn included. */
+  target: Quat;
+  transitionDuration?: number;
+  eventFlags?: number;
+}
+export declare class Mixer {
+  #private;
+  constructor({ root, joints, position, orientation }: MixerOptions);
+  /** The root's placement in the character's frame, as the mixer last wrote it. */
+  get root(): {
+    position: Vector3;
+    orientation: Quat;
+  };
+  /** `Offset20`. */
+  get floor(): number;
+  /** A joint's state as last written, its rest before anything has. */
+  jointState(name: string): JointState | undefined;
+  /**
+   * `RegisterAnimHandle`: scripts started later leave the joint be, and an aim through it fails.
+   */
+  lock(name: string): void;
+  /** `UnregisterAnimHandle`, as THN's Finish of a motion with a `locked_bone` does. */
+  unlock(name: string): void;
+  /**
+   * `PlayInstanceAnim` (`FUN_065f41d0`): bind the script's maps, stand the root upright at its
+   * `Root height` over the floor facing `heading`, and fade each target in. `undefined` when the
+   * start time is past a channel's end (`TypedTimePlayable`), which retail destroys the script for.
+   */
+  start(script: AnimationScript, options?: MotionOptions): number | undefined;
+  /**
+   * `DestroyHandle`: THN's Finish. Every target lets go at once, with no fade out
+   * (`MixerUnbindTyped`).
+   */
+  stop(handle: number): void;
+  /** Whether any of a motion's channels is still on a target. */
+  playing(handle: number): boolean;
+  /**
+   * `FUN_065f5400` for one joint with `point_at`: the joint's world rotation goes to `target`,
+   * entering its stack as a motion would, with the transition as its fade. The joint locks;
+   * `undefined` when it already was, or is not a sphere joint (on a loose one retail would write a
+   * rotation over its position, which is not reproduced).
+   */
+  aim(joint: string, { target, transitionDuration, eventFlags }: AimOptions): number | undefined;
+  /** THN re-sends an aim's target at every update. */
+  setAimTarget(handle: number, target: Quat): void;
+  /**
+   * `StopAimNode`: the joint unlocks, and the aim ends as a channel running out does. With
+   * {@link MotionFlag.KeepBeneath} it fades back to what is beneath; without, its pose holds.
+   */
+  stopAim(handle: number): void;
+  /**
+   * `MixerWalkAll` (`LAB_066157f0`): every stack ticks, then writes its target. Joints first, then
+   * the root.
+   */
+  advance(dt: number): void;
+  /**
+   * `SetPosePos`: the root goes to `position`'s x and z. Its height is each motion's own: `Root
+   * height` plus its stored height now plus the floor, or the resting height without one;
+   * `position.y` is not read.
+   */
+  setRootPosition(position: Vector3): void;
+  /**
+   * `SetPoseOri`: the root turns to `orientation`, every motion's root turning with it about where
+   * it stands.
+   */
+  setRootOrientation(orientation: Quat): void;
+  /**
+   * `SetHeight` (`0x65f50b0`): the floor, under every motion's root from the next advance. A
+   * motion's root moves by what puts it at its height over the new floor.
+   */
+  setFloor(height: number): void;
+}
+interface MixerCharacters {
+  /** A character's mixer, by entity name, or nothing for one the host doesn't run. */
+  mixer(entity: string): Mixer | undefined;
+  /**
+   * An animation by name, from the one global table every `bodyparts.ini [Animations]` file fills,
+   * ignoring case (`0x435100`). A missing one logs and still succeeds: the event does nothing.
+   */
+  animation(name: string): AnimationScript | undefined;
+}
+/**
+ * A {@link CharacterHost} on mixers. A motion locks its `locked_bone` from its start to its Finish;
+ * an aim is the single-joint `point_at` solve, its scene-space rotation handed on as it is, since the
+ * solve undoes the parent's world, the character's own turn included (`IkSolveSingleJoint`); keep-beneath
+ * from event flag 0x80 (`StartIk`, `0x452460`). Longer chains are left out.
+ */
+declare const mixerCharacters: ({ mixer, animation }: MixerCharacters) => CharacterHost & {
+  /** `ICompoundControl +0x18`: the playback's advance, in milliseconds. */
+  advance(entity: string, milliseconds: number): void;
+  /** Where a character's root stands now, in the character's frame: thorn reads the walk back. */
+  root(entity: string): Frame$1 | undefined;
+};
+declare namespace index_d_exports {
+  export { AimRecord, AudioState, CameraProps, CameraView, CharacterHost, Connection, Curve, DEFAULT_AUDIO, DEFAULT_LIGHT, EntryKind, FLAGS, FogState, Frame$1 as Frame, FrameMilliseconds, LIGHT_BITS, Letterbox, LightState, MixerCharacters, MotionRecord, NO_FOG, Path, Playback, PlaybackOptions, PlaybackState, Quaternion, RUN, RoomEntity, RtcSetting, ScriptRun, Sequence, SequenceEntry, SequenceFlags, SequenceManager, SetCamera, SetProp, SetScript, SetSource, SoundRecord, SpawnOptions, Stage, ThornEvent, ThornHost, Timing, ViewTable, ambientSequence, anchoredFrame, axisTurn, blendAudio, blendFog, blendLight, cameraOf, connectedFrame, createCurve, createPath, eventsOf, flagWord, frameMilliseconds, inverse, lightOf, lookAt, milliseconds, mixerCharacters, nlerp, placement, progress, quaternionOf, readAudio, readFog, readLight, readSetScript, renderTypeOf, replay, retailSort, roomEntities, roomFogOf, roomLightOf, rotationOf, rowsOf, rtcEnabled, scriptAnchor, soundLevel, spawns, userProp };
+}
+export { type AdvanceOptions, type AimOptions, type BackgroundLightningSettings, type BandField, type BandLighting, type BandPiece, type BandSettings, type BeamArchetype, type BeamLimits, type BeamSection, type BeamStart, type BillboardField, type BillboardLighting, type BillboardSettings, type Camera, type CloudDrawOptions, type CloudSettings, type CloudVisibility, type CockpitLimits, type CoronaView, type CubeAsteroid, type CubeDraw, type CubeExclusion, type CubeField, type CubeRotations, type DeferredNebula, type Draw, type DrawSkin, type DrawTexture, type DustEffect, type DustLimits, type DustOptions, type DustZone, type DynamicDraw, type DynamicEffect, type DynamicField, type DynamicLightningSettings, type DynamicSettings, type EffectDraw, type EffectLight, type EffectLodSizes, type EffectLookup, type EffectNode, type EffectPlacement, type EffectPools, type EffectScene, type EffectType, type EffectView, type EffectViewFrame, type EffectViewOptions, type EquipmentLight, type ExclusionShell, type Extent, type ExteriorLimits, type ExteriorSettings, type FlareBead, type FlareLight, type FlareView, type FlashlightSet, type FlashlightTextures, type Fog, type Frame, type FrameHook, type FrameHooks, type FrameLimits, type FrameRect, type Graph, type GroupDraw, type Hitbox, type HitboxObject, type HitboxSurface, type HookContext, type HookName, type InExclusion, type LensGlow, type LightAnimation, type LightSet, type LodDetail, type LodList, type MaterialMapRule, type MixerJoint, type MixerOptions, type MotionOptions, type NebulaAmbient, type NebulaExclusion, type NebulaLimits, type NebulaList, type NebulaState, type ObjectLighting, type PlaceOptions, type PlacedEffect, type PlacedPart, type PlanetRing, type PoolSizes, type Program, type Random, type RayHit, type ReferencePlan, type RenderOptions, type Renderer, type ResolveNode, type Rgb, type RingExterior, type RingOptions, type RingPiece, type RoomFrame, type RoomLight, type RoomObject, type RoomScene, type RoomShadow, type RoomShadows, type Scene, type SceneEffect, type SceneLight, type SceneModel, type ScreenQuad, type ScreenQuadBatch, type ShadowLimits, type ShadowQuad, type SkinMesh, type SkinOptions, type SkinPose, type SkyLayer, type SpaceAsteroidField, type SpaceCockpit, type SpaceEffect, type SpaceField, type SpaceFlare, type SpaceFrame, type SpaceJump, type SpaceLight, type SpaceLimits, type SpaceNebula, type SpaceObject, type SpaceScene, type SphereLevels, type SphereOptions, type Spot, type SpriteDraw, type SpriteFrameStyle, type Star, type StarGlow, type StarLensFlare, type StarSpine, type StarSpines, type SwitchTable, type TextureShape, type TractorArm, type TractorBeam, type TractorLimits, type TriangleDraw, type TunnelLayer, type TunnelSettings, type TunnelState, type UvTransform, type VertexLayout, type Viewport, type ViewportRect, type Within, type WrittenZone, type Zone, index_d_exports as thorn };
+//# sourceMappingURL=index.d.ts.map