@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/chunk-YWQ3ALYY.js

@@ -0,0 +1,69 @@
+// src/authority/fast-udp-socket.ts
+var IPV6_FAMILY = 6;
+var lookupTurns = /* @__PURE__ */ new Map();
+var UDP_SCHEME = "udp:";
+var PORT_MAX = 65535;
+var CONNECT_QUEUE_MAX = 32;
+var BARE_PATHS = ["", "/"];
+var onlyHostAndPort = (u) => u.username === "" && u.password === "" && BARE_PATHS.includes(u.pathname) && u.search === "" && u.hash === "";
+function udpEndpoint(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  const port = Number(parsed.port);
+  const portOk = Number.isInteger(port) && port >= 1 && port <= PORT_MAX;
+  if (parsed.protocol !== UDP_SCHEME || !portOk || parsed.hostname === "" || !onlyHostAndPort(parsed)) return null;
+  return { host: parsed.hostname.replace(/^\[(.*)\]$/, "$1"), port };
+}
+var udpFastOpener = ({ createSocket, lookup, isIP }) => (url, receive) => {
+  const to = udpEndpoint(url);
+  if (to === null) return null;
+  let socket = null;
+  let connected = false;
+  let closed = false;
+  let waiting = [];
+  const attach = (address, family) => {
+    if (closed) return;
+    const s = createSocket(family === IPV6_FAMILY ? "udp6" : "udp4");
+    socket = s;
+    s.on("message", (msg) => receive(new Uint8Array(msg.buffer, msg.byteOffset, msg.byteLength)));
+    s.on("error", () => {
+    });
+    s.connect(to.port, address, () => {
+      connected = true;
+      if (!closed) for (const bytes of waiting) s.send(bytes);
+      waiting = [];
+    });
+  };
+  const literal = isIP(to.host);
+  if (literal !== 0) attach(to.host, literal);
+  else {
+    lookup(to.host, { all: true, verbatim: true }, (err, found) => {
+      if (err !== null || found.length === 0) return;
+      const turn = (lookupTurns.get(to.host) ?? 0) % found.length;
+      lookupTurns.set(to.host, turn + 1);
+      attach(found[turn].address, found[turn].family);
+    });
+  }
+  const fast = {
+    send(bytes) {
+      if (closed) return;
+      if (connected) socket?.send(bytes);
+      else waiting = [...waiting, bytes].slice(-CONNECT_QUEUE_MAX);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      socket?.close();
+    }
+  };
+  return fast;
+};
+
+export {
+  udpEndpoint,
+  udpFastOpener
+};

package/dist/{fast-client-CZ41v-oB.d.ts → fast-client--A88q0kk.d.ts}

@@ -1,4 +1,4 @@
-import { I as InputData } from './module-DqtFb5wA.js';
+import { I as InputData } from './module-CSpXrzFc.js';
 
 /** The datagram format's version, the first byte of every datagram. */
 declare const FAST_VERSION = 1;
@@ -21,7 +21,7 @@ declare const FAST_GAP_FILL_MS = 250;
 declare const FAST_SEQ_AHEAD_MS = 5000;
 /** Snapshots each side holds as bases: 533 ms at 60 Hz, over a 409 ms p99 round trip plus an episode. */
 declare const FAST_SNAPSHOT_HISTORY = 32;
-/** The most fragments one snapshot may have (about 37 KB); a larger body is not sent on this channel. */
+/** The most fragments one snapshot may have (about 37 KB); a larger body goes as a partial snapshot (the host cuts it, §17.12). */
 declare const FAST_MAX_FRAGMENTS = 32;
 /** Incomplete snapshots a client gathers at once; the oldest gives way. */
 declare const FAST_REASSEMBLY_SLOTS = 4;
@@ -31,6 +31,41 @@ declare const FAST_MAX_RECORD_BYTES = 1024;
 declare const FAST_HANDSHAKE_MS = 1000;
 /** A client with no snapshot for this long falls back to the WebSocket. */
 declare const FAST_STALL_FALLBACK_MS = 2000;
+/** A seat with nothing to send sends an empty uplink this often while snapshots reach it (§17.12
+ *  *Keepalive*): under {@link FAST_SNAPSHOT_HISTORY} snapshots at 120 Hz, so its deltas stay deltas, and far
+ *  under the shortest NAT timer measured, 10 s (Richter et al., IMC 2016: 74% of NATs expire idle UDP state
+ *  in 1 min or less, range 10 to 200 s; RFC 9308 §3.2: assume 30 s). */
+declare const FAST_KEEPALIVE_MS = 250;
+/** Likewise before its first snapshot: a lost first datagram or challenge costs no more than this. */
+declare const FAST_KEEPALIVE_BIND_MS = 50;
+/** A snapshot changing this many records is acknowledged as it lands by a seat with nothing else to send:
+ *  its next delta shrinks by far more than the 57 bytes. */
+declare const FAST_ACK_EAGER_RECORDS = 32;
+/** No eager ack within this long of another uplink: a seat sending inputs every frame sends none. */
+declare const FAST_ACK_EAGER_GAP_MS = 20;
+/** A snapshot id at least this far past the client's newest is a return-path challenge (§17.12 *Return
+ *  path*): the client echoes it at once, whatever the keepalive's clock says. */
+declare const FAST_CHALLENGE_JUMP = 65536;
+/** No frame for this long: the stall deadline's clock did not run, as the seat could not have read a
+ *  snapshot or sent an uplink (a background tab, a suspended app, a long hitch). */
+declare const FAST_FRAME_GAP_MS = 250;
+/** The binding's `rev` from a host that takes empty uplinks and challenges addresses (§17.12 *Keepalive*)
+ *  and offers a fresh binding to a seat that asks (*Return to the channel*). */
+declare const FAST_BIND_REV = 2;
+/** Snapshots a seat must apply on a fresh binding before its inputs and motion move to it: enough to trust
+ *  the path both ways, little enough to swap within a tenth of a second. */
+declare const FAST_RETURN_PROOF = 3;
+/** A retry's delay at attempt 0, before jitter: a dropped-out Wi-Fi is usually back. */
+declare const FAST_RETRY_BASE_MS = 1000;
+/** Its most, before jitter: a blocked network costs a few datagrams a minute, forever. */
+declare const FAST_RETRY_MAX_MS = 60000;
+/** A seat that held the channel this long starts its next backoff from attempt 0; one that lost it sooner
+ *  goes on climbing, so a flapping path does not swap back and forth. */
+declare const FAST_RETURN_STABLE_MS = 30000;
+/** The delay before retry number `attempt` (from 0), jittered by `unit` in [0, 1): doubling from
+ *  {@link FAST_RETRY_BASE_MS} to {@link FAST_RETRY_MAX_MS}, half of it random ("equal jitter"), so seats
+ *  behind one failed link do not come back as one. */
+declare function fastRetryDelayMs(attempt: number, unit: number): number;
 /** The reliable messages of the fast channel (§17.12): the server's binding at join and the client's
  *  fallback. Reserved names (`__`), so no game event can be mistaken for one. */
 declare const FastMessage: {
@@ -39,6 +74,10 @@ declare const FastMessage: {
     /** Client → server: `{ last }`, the last seq the client sent by datagram; its inputs go by
      *  `room.input()` from now on. */
     readonly Off: "__fast:off";
+    /** Client → server: `{}`, a seat off the channel asks for a fresh binding (§17.12 *Return to the channel*). */
+    readonly Again: "__fast:again";
+    /** Client → server: `{ last }`, the last seq it sent by WebSocket; its inputs go by datagram from now on. */
+    readonly On: "__fast:on";
 };
 type FastMessage = (typeof FastMessage)[keyof typeof FastMessage];
 /** Where a browser reaches the seat's channel (§17.12 *WebTransport*): a relay's WebTransport session
@@ -56,11 +95,21 @@ interface FastBindMessage {
     key: string;
     url: string;
     wt?: FastWebTransport;
+    /** The host's revision of the channel ({@link FAST_BIND_REV}); absent from a host older than it, to which
+     *  a client sends no empty uplink and asks for no fresh binding. */
+    rev?: number;
+    /** A fresh binding for a seat on the WebSocket (§17.12 *Return to the channel*): the WebSocket carries
+     *  everything until the seat's `__fast:on`. */
+    probe?: boolean;
 }
 /** The `__fast:off` message's payload. */
 interface FastOffMessage {
     last: number;
 }
+/** The `__fast:on` message's payload. */
+interface FastOnMessage {
+    last: number;
+}
 /** The datagram kinds, the second byte. */
 declare const FastKind: {
     readonly Uplink: 1;
@@ -368,6 +417,10 @@ declare function encodeRecord(r: MotionRecord): FastResult<Uint8Array>;
  *  left out reads as its default. */
 declare function decodeRecord(bytes: Uint8Array): FastResult<MotionRecord>;
 
+/** Round trips a socket that opens asynchronously may take to open, where that is longer than
+ *  {@link FAST_HANDSHAKE_MS}: WebTransport over QUIC and HTTP/3 took three in Safari 26 (Chromium's two
+ *  are within it), so a long route's seat is not sent back for its session's own handshake. */
+declare const FAST_OPEN_ROUND_TRIPS = 4;
 /** A datagram socket to the room's fast endpoint. `send` never throws; a lost datagram is the
  *  channel's normal case. */
 interface FastDatagramSocket {
@@ -380,12 +433,20 @@ interface FastDatagramSocket {
      *  `maxDatagramSize`): below the seat's largest uplink ({@link uplinkMaxBytes}), the seat falls back
      *  at once. */
     maxDatagramBytes?(): number | undefined;
+    /** True while a socket that opens asynchronously is still opening (WebTransport: round trips before a
+     *  first datagram can leave). The handshake then runs twice: to the socket opening, {@link FAST_HANDSHAKE_MS}
+     *  or {@link FAST_OPEN_ROUND_TRIPS} of the seat's round trips, whichever is longer; and from then to the
+     *  first snapshot, {@link FAST_HANDSHAKE_MS}. */
+    opening?(): boolean;
 }
 /** Opens a socket to a `__fast` `url`, handing each datagram that arrives to `receive`; null when this
  *  client cannot reach that kind of url (the seat then falls back at once). `bind` is the whole
  *  binding (the client always passes it), for an opener that reaches the channel another way
  *  (`bind.wt`, WebTransport). */
-type FastSocketOpener = (url: string, receive: (bytes: Uint8Array) => void, bind?: FastBindMessage) => FastDatagramSocket | null;
+type FastSocketOpener = ((url: string, receive: (bytes: Uint8Array) => void, bind?: FastBindMessage) => FastDatagramSocket | null) & {
+    /** Why this opener answers null for `bind` (default {@link FastFallbackReason.Unreachable}). */
+    whyNull?: (bind: FastBindMessage) => FastFallbackReason;
+};
 /** Why a fast seat went back to the WebSocket. */
 declare const FastFallbackReason: {
     /** The `__fast` binding was malformed, this client cannot open its url, or its socket failed. */
@@ -396,6 +457,14 @@ declare const FastFallbackReason: {
     readonly Stall: "stall";
     /** The server asked for it (`__fast:off` from the server). */
     readonly Server: "server";
+    /** A browser with no `WebTransport` (or not a secure context): the seat never asked for the channel. */
+    readonly NoWebTransport: "no-webtransport";
+    /** The binding carries no `wt` this browser can open: the room's server runs no relay. */
+    readonly NoRelay: "no-relay";
+    /** The seat asked and no binding came within {@link FAST_HANDSHAKE_MS} of its first frame: the room's
+     *  server has no channel, or is too old to offer it. The seat was on the WebSocket all along, and a
+     *  binding that comes after all still opens. */
+    readonly NotOffered: "not-offered";
 };
 type FastFallbackReason = (typeof FastFallbackReason)[keyof typeof FastFallbackReason];
 /** One applied snapshot as the session uses it: its header and the motion records that differ from the
@@ -420,6 +489,8 @@ interface FastClientOptions {
     open: FastSocketOpener;
     /** The clock the deadlines run on (ms). */
     now: () => number;
+    /** The seat's round trip as measured so far (ms; 0 or absent: not yet known). */
+    roundTripMs?: () => number;
     /** Each applied snapshot, after the receive state took it. */
     onSnapshot?: (s: FastSnapshot) => void;
 }
@@ -432,11 +503,16 @@ interface FastClient {
     readonly lastQueued: number;
     /** True once closed: nothing is sent or received again. */
     readonly closed: boolean;
+    /** True while the socket is still opening. */
+    opening(): boolean;
     /** An input sent this frame: seqs ascend by one from the first queued. */
     queue(input: FastInput): void;
     /** One datagram carrying the inputs queued since the last flush and the redundant window (one more for
      *  each further window's worth of new inputs); nothing when none was queued. */
     flush(): void;
+    /** An empty uplink when one is due (§17.12 *Keepalive*), from a host that takes them: the seat binds with
+     *  no input, its snapshots stay acknowledged and its NAT mapping stays open. */
+    keepalive(): void;
     /** The input of seq `seq` while it is still held. */
     inputAt(seq: number): FastInput | undefined;
     /** When the input of seq `seq` was first sent (by `now`), for each of the newest {@link seqAheadMax}
@@ -445,6 +521,11 @@ interface FastClient {
     sentAt(seq: number): number | undefined;
     /** The latest decoded record of `id` of `kind` (from the newest applied snapshot), else undefined. */
     motionOf(kind: MotionRecordKind, id: string): MotionRecord | undefined;
+    /** Every record of the newest applied snapshot. */
+    records(): MotionRecord[];
+    /** A frame begins: time since the last frame past {@link FAST_FRAME_GAP_MS} is taken off both deadlines'
+     *  clocks (§17.12 *Keepalive*), so a seat whose frames stopped does not read its own stop as a dead path. */
+    framed(): void;
     /** Whether a deadline has passed (§17.12 *Fallback*), by the injected clock. */
     due(): FastFallbackReason | null;
     /** One datagram from the socket. A fault, a stale or duplicate fragment or a datagram for another
@@ -462,4 +543,4 @@ declare function heldInputs(sent: readonly FastInput[], inputAck: number, tickHz
 /** Opens a seat's fast channel on `o.bind`; null when the opener cannot reach its url. */
 declare function openFastClient(o: FastClientOptions): FastClient | null;
 
-export { blankEntityMotion as $, AcceptKind as A, type FastReceipt as B, type ClientRx as C, type FastResult as D, type EntityMotion as E, type FastSocketOpener as F, type FastSnapshot as G, type FastWebTransport as H, type Fragment as I, type HeldSnapshot as J, INPUT_REDUNDANCY_MAX as K, INPUT_REDUNDANCY_MIN as L, INPUT_REDUNDANCY_MS as M, type MotionRecord as N, MotionRecordKind as O, type PartialSnapshot as P, type ReceiveResult as Q, RECORD_ID_MAX_CHARS as R, type Records as S, type SeatEcho as T, type SeatRx as U, type SnapshotBody as V, type SnapshotHead as W, type Uplink as X, type UplinkOptions as Y, acceptUplink as Z, applyBody as _, type FastBindMessage as a, blankSeatEcho as a0, decodeFragment as a1, decodeRecord as a2, decodeUplink as a3, deltaBase as a4, dequantizeCode as a5, diffSnapshot as a6, emptyClientRx as a7, encodeRecord as a8, encodeSnapshot as a9, encodeUplink as aa, fromHex as ab, gapFillMax as ac, heldInputs as ad, inputRedundancyTicks as ae, isFastBind as af, isPress as ag, openFastClient as ah, parseBody as ai, quantizeCode as aj, receiveFragment as ak, renderStamp as al, seqAheadMax as am, toHex as an, uplinkFor as ao, uplinkMaxBytes as ap, FastFallbackReason as b, type AcceptOptions as c, type AcceptResult as d, type AcceptedInput as e, FAST_GAP_FILL_MS as f, FAST_HANDSHAKE_MS as g, FAST_KEY_BYTES as h, FAST_MAX_ACTIONS as i, FAST_MAX_DATAGRAM_BYTES as j, FAST_MAX_FRAGMENTS as k, FAST_MAX_RECORD_BYTES as l, FAST_REASSEMBLY_SLOTS as m, FAST_SEQ_AHEAD_MS as n, FAST_SNAPSHOT_HISTORY as o, FAST_STALL_FALLBACK_MS as p, FAST_VERSION as q, type FastBinding as r, type FastClient as s, type FastClientOptions as t, type FastDatagramSocket as u, FastFault as v, type FastInput as w, FastKind as x, FastMessage as y, type FastOffMessage as z };
+export { MotionRecordKind as $, AcceptKind as A, FAST_SNAPSHOT_HISTORY as B, type ClientRx as C, FAST_STALL_FALLBACK_MS as D, type EntityMotion as E, type FastSocketOpener as F, FAST_VERSION as G, type FastBinding as H, type FastClient as I, type FastClientOptions as J, type FastDatagramSocket as K, FastFault as L, type FastInput as M, FastKind as N, FastMessage as O, type FastOffMessage as P, type FastOnMessage as Q, type FastReceipt as R, type FastResult as S, type FastSnapshot as T, type FastWebTransport as U, type Fragment as V, type HeldSnapshot as W, INPUT_REDUNDANCY_MAX as X, INPUT_REDUNDANCY_MIN as Y, INPUT_REDUNDANCY_MS as Z, type MotionRecord as _, FastFallbackReason as a, type PartialSnapshot as a0, RECORD_ID_MAX_CHARS as a1, type ReceiveResult as a2, type Records as a3, type SeatEcho as a4, type SeatRx as a5, type SnapshotBody as a6, type SnapshotHead as a7, type Uplink as a8, type UplinkOptions as a9, seqAheadMax as aA, toHex as aB, uplinkFor as aC, uplinkMaxBytes as aD, acceptUplink as aa, applyBody as ab, blankEntityMotion as ac, blankSeatEcho as ad, decodeFragment as ae, decodeRecord as af, decodeUplink as ag, deltaBase as ah, dequantizeCode as ai, diffSnapshot as aj, emptyClientRx as ak, encodeRecord as al, encodeSnapshot as am, encodeUplink as an, fastRetryDelayMs as ao, fromHex as ap, gapFillMax as aq, heldInputs as ar, inputRedundancyTicks as as, isFastBind as at, isPress as au, openFastClient as av, parseBody as aw, quantizeCode as ax, receiveFragment as ay, renderStamp as az, type FastBindMessage as b, type AcceptOptions as c, type AcceptResult as d, type AcceptedInput as e, FAST_ACK_EAGER_GAP_MS as f, FAST_ACK_EAGER_RECORDS as g, FAST_BIND_REV as h, FAST_CHALLENGE_JUMP as i, FAST_FRAME_GAP_MS as j, FAST_GAP_FILL_MS as k, FAST_HANDSHAKE_MS as l, FAST_KEEPALIVE_BIND_MS as m, FAST_KEEPALIVE_MS as n, FAST_KEY_BYTES as o, FAST_MAX_ACTIONS as p, FAST_MAX_DATAGRAM_BYTES as q, FAST_MAX_FRAGMENTS as r, FAST_MAX_RECORD_BYTES as s, FAST_OPEN_ROUND_TRIPS as t, FAST_REASSEMBLY_SLOTS as u, FAST_RETRY_BASE_MS as v, FAST_RETRY_MAX_MS as w, FAST_RETURN_PROOF as x, FAST_RETURN_STABLE_MS as y, FAST_SEQ_AHEAD_MS as z };

package/dist/index.js

@@ -3,9 +3,9 @@ import {
   createPrivate,
   joinPrivate,
   matchmake
-} from "./chunk-7QVOIHJF.js";
-import "./chunk-UX3F6YTV.js";
-import "./chunk-ZSWF4VCN.js";
+} from "./chunk-QY3QQNDJ.js";
+import "./chunk-FPWP22Y7.js";
+import "./chunk-CSQEEANB.js";
 export {
   connect,
   createPrivate,

package/dist/level-build-CbRqrYJq.d.ts

@@ -0,0 +1,140 @@
+/** Why a level was refused. A refusal says this code and names what to change. */
+declare const LevelRefusalCode: {
+    /** Not a glb or a glTF, or not a file that can be read. */
+    readonly NotGltf: "not_gltf";
+    /** A glb's chunks do not add up. */
+    readonly BadContainer: "bad_container";
+    /** glTF 1 or a version this reader does not take. */
+    readonly BadVersion: "bad_version";
+    /** An index that names nothing: a scene, a node, a mesh, an accessor, a buffer. */
+    readonly BadReference: "bad_reference";
+    /** An accessor or a view that does not fit what it reads or is not what it must be. */
+    readonly BadAccessor: "bad_accessor";
+    /** A triangle's index past its vertices. */
+    readonly BadIndex: "bad_index";
+    /** A transform or a field of the wrong shape. */
+    readonly BadValue: "bad_value";
+    /** NaN, an infinity, or a coordinate past the format's range. */
+    readonly NotFinite: "not_finite";
+    /** A cycle, or a node with two parents. */
+    readonly NodeCycle: "node_cycle";
+    /** Past a stated limit (LEVEL_LIMITS). */
+    readonly TooLarge: "too_large";
+    /** Draco or meshopt on something that collides. */
+    readonly Compressed: "compressed";
+    /** A required extension this reader cannot honour. */
+    readonly UnknownExtension: "unknown_extension";
+    /** A buffer URI that leaves the input's folder, names the network, or is not a plain file. */
+    readonly UriRefused: "uri_refused";
+    /** A skinned mesh that collides. */
+    readonly Skinned: "skinned";
+    /** A mesh posed by morph targets that collides. */
+    readonly Morphed: "morphed";
+    /** A kind of three.js object the helper cannot read. */
+    readonly Unsupported: "unsupported";
+    /** A mesh with no triangle left of any area. */
+    readonly Degenerate: "degenerate";
+    /** More triangles on one edge than any surface has. */
+    readonly NonManifold: "non_manifold";
+    /** No spawn: a fit starts from where a hull can stand. */
+    readonly NoSpawn: "no_spawn";
+    /** Nothing collides. */
+    readonly NoSurface: "no_surface";
+    /** A mark that is not one. */
+    readonly BadMark: "bad_mark";
+};
+type LevelRefusalCode = (typeof LevelRefusalCode)[keyof typeof LevelRefusalCode];
+/** A level refused by name: `code` says why, the message names the node or field and what to do. */
+declare class LevelRefusal extends Error {
+    readonly code: LevelRefusalCode;
+    constructor(code: LevelRefusalCode, message: string);
+}
+/** What this path takes. Each is refused before anything is decoded or allocated for it. */
+declare const LEVEL_LIMITS: {
+    /** One glb, or one external buffer, and all buffers together. */
+    readonly maxFileBytes: number;
+    /** Triangles in the level, instances counted. A fit reads a scene of this size; art past it needs a proxy. */
+    readonly maxTriangles: 8000000;
+    /** Vertices one accessor may read. */
+    readonly maxVertices: 24000000;
+    readonly maxNodes: 1000000;
+    readonly maxDepth: 1024;
+    /** Points a `hull` holds, as the scene format says. */
+    readonly maxHullPoints: 4096;
+    /** No surface puts more triangles on one edge: past this it is junk, or an attack on what reads it. */
+    readonly maxTrianglesOnEdge: 64;
+};
+/** What a surface answers, as a creator marks it. `both` is the default; `none` is only drawn. */
+declare const LevelCollide: {
+    readonly Both: "both";
+    readonly Move: "move";
+    readonly Shot: "shot";
+    readonly None: "none";
+};
+type LevelCollide = (typeof LevelCollide)[keyof typeof LevelCollide];
+/** How a mesh becomes surfaces. Unmarked, a closed axis-aligned cube becomes an exact box and the rest stays triangles. */
+declare const LevelShape: {
+    readonly Mesh: "mesh";
+    readonly Box: "box";
+    readonly Hull: "hull";
+};
+type LevelShape = (typeof LevelShape)[keyof typeof LevelShape];
+/** A node's own mark, from its name and its `extras.genex` (`userData.genex` in three.js). */
+interface LevelMark {
+    readonly collide?: LevelCollide;
+    readonly shape?: LevelShape;
+    readonly movable?: boolean;
+    readonly prop?: boolean;
+    readonly spawn?: boolean;
+    readonly tags?: readonly string[];
+}
+/** A node's own mark: what its name spells, then its `extras.genex`, which wins. Refuses a mark that is not one. */
+declare function levelMarkOf(name: string, genex: unknown, where?: string, allowSettings?: boolean): LevelMark;
+interface LevelHull {
+    readonly radius: number;
+    readonly height: number;
+    readonly crouchHeight: number;
+    readonly step: number;
+    readonly jump: number;
+    readonly leap: number;
+}
+/** The scene as JSON holds it, base64 for the big arrays: `parseWorldScene` takes exactly this. */
+interface RawWorldScene {
+    readonly format: 'genex-world-scene';
+    readonly version: 1;
+    readonly unitsPerMeter: number;
+    readonly source: Readonly<Record<string, string>>;
+    readonly hull?: LevelHull;
+    readonly actors: readonly RawActor[];
+    readonly spawns: readonly {
+        readonly at: readonly number[];
+        readonly name?: string;
+        readonly tags?: readonly string[];
+    }[];
+}
+interface RawActor {
+    readonly name: string;
+    readonly tags?: readonly string[];
+    readonly surfaces: readonly RawSurface[];
+}
+type RawSurface = {
+    readonly kind: string;
+} & Readonly<Record<string, unknown>>;
+interface LevelStats {
+    readonly actors: number;
+    readonly boxes: number;
+    readonly hulls: number;
+    readonly meshes: number;
+    readonly triangles: number;
+    readonly spawns: number;
+}
+interface LevelScene {
+    readonly scene: RawWorldScene;
+    /** What was kept or dropped that a creator may want to look at. Never in the scene's bytes. */
+    readonly notes: readonly string[];
+    readonly stats: LevelStats;
+    /** The scene's bytes, as text: one file, the same on every OS. */
+    readonly json: string;
+}
+
+export { type LevelScene as L, type RawWorldScene as R, type LevelHull as a, LEVEL_LIMITS as b, LevelCollide as c, type LevelMark as d, LevelRefusal as e, LevelRefusalCode as f, LevelShape as g, levelMarkOf as l };