@genex-ai/multiplayer 0.17.6 → 0.17.8

package/dist/world-fit/index.d.ts

@@ -0,0 +1,549 @@
+import { C as ClaimVerdict } from '../shot-world-D22tqOUT.js';
+export { J as WorldLimits } from '../shot-world-D22tqOUT.js';
+import { L as LevelScene, a as LevelHull } from '../level-build-CbRqrYJq.js';
+export { b as LEVEL_LIMITS, c as LevelCollide, d as LevelMark, e as LevelRefusal, f as LevelRefusalCode, g as LevelShape, R as RawWorldScene, l as levelMarkOf } from '../level-build-CbRqrYJq.js';
+
+interface Lattice {
+    /** Cell side in scene units. */
+    readonly h: number;
+    /** The corner of cell (0, 0, 0). A point's centre is x0 + (i + 0.5) h; a plane of height is z0 + k h. */
+    readonly x0: number;
+    readonly y0: number;
+    readonly z0: number;
+    readonly nx: number;
+    readonly ny: number;
+    readonly nz: number;
+    /** 32-bit words a column. */
+    readonly w: number;
+}
+type Layer = Uint32Array;
+
+/** The format's name and the one version this reader takes. A new meaning is a new version, never a changed one. */
+declare const WORLD_SCENE_FORMAT = "genex-world-scene";
+declare const WORLD_SCENE_VERSION = 1;
+/** Which traces a surface answers. `move` stops a hull, `shot` stops a bullet. A clip wall is `move` only, a thin fence
+ *  a hull may not walk through and a bullet may pass is `move` too, a mesh that stops bullets alone is `shot`. */
+declare const SceneChannel: {
+    readonly Move: "move";
+    readonly Shot: "shot";
+};
+type SceneChannel = (typeof SceneChannel)[keyof typeof SceneChannel];
+/** Tags the fit reads. Any other tag is carried through for the game's own use. */
+declare const SceneTag: {
+    /** Moves or disappears at run time: never part of the static world. Named in the report. */
+    readonly Movable: "movable";
+    /** May be simplified or dropped when a budget runs out, before anything else that costs reach. */
+    readonly Prop: "prop";
+};
+type SceneTag = (typeof SceneTag)[keyof typeof SceneTag];
+declare const SceneSurfaceKind: {
+    readonly Box: "box";
+    readonly Hull: "hull";
+    readonly Sphere: "sphere";
+    readonly Capsule: "capsule";
+    readonly Mesh: "mesh";
+    readonly Heightfield: "heightfield";
+};
+type SceneSurfaceKind = (typeof SceneSurfaceKind)[keyof typeof SceneSurfaceKind];
+type SceneVec3 = readonly [number, number, number];
+interface SurfaceCommon {
+    /** Defaults to both channels. */
+    readonly channels?: readonly SceneChannel[];
+    readonly tags?: readonly string[];
+}
+/** An oriented box: `axes` are three orthonormal rows (identity when left out), `half` the half extents along them. */
+interface SceneBox extends SurfaceCommon {
+    readonly kind: 'box';
+    readonly center: SceneVec3;
+    readonly axes?: readonly [SceneVec3, SceneVec3, SceneVec3];
+    readonly half: SceneVec3;
+}
+/** The convex hull of its points. */
+interface SceneHull extends SurfaceCommon {
+    readonly kind: 'hull';
+    readonly points: readonly SceneVec3[];
+}
+interface SceneSphere extends SurfaceCommon {
+    readonly kind: 'sphere';
+    readonly center: SceneVec3;
+    readonly radius: number;
+}
+interface SceneCapsule extends SurfaceCommon {
+    readonly kind: 'capsule';
+    readonly a: SceneVec3;
+    readonly b: SceneVec3;
+    readonly radius: number;
+}
+/** Triangles: x y z per vertex, three indices per triangle. Open or closed, wound either way: the surface is what counts. */
+interface SceneMesh extends SurfaceCommon {
+    readonly kind: 'mesh';
+    readonly vertices: Float32Array;
+    readonly indices: Uint32Array;
+}
+/** A regular grid of heights (a landscape, a terrain): `heights[row * cols + col]` at
+ *  `origin + (col * cell[0], row * cell[1])`. Solid below its surface. NaN in `heights` is a hole. */
+interface SceneHeightfield extends SurfaceCommon {
+    readonly kind: 'heightfield';
+    readonly origin: readonly [number, number];
+    readonly cell: readonly [number, number];
+    readonly cols: number;
+    readonly rows: number;
+    readonly heights: Float32Array;
+}
+type SceneSurface = SceneBox | SceneHull | SceneSphere | SceneCapsule | SceneMesh | SceneHeightfield;
+interface SceneActor {
+    /** What a refusal names: the engine's own name for it, so a creator can find it. */
+    readonly name: string;
+    readonly tags: readonly string[];
+    readonly surfaces: readonly SceneSurface[];
+}
+interface SceneSpawn {
+    readonly at: SceneVec3;
+    readonly name?: string;
+    readonly tags?: readonly string[];
+}
+/** The hull the fit serves, in scene units: the room's own firstperson parameters. */
+interface SceneHullSize {
+    /** Half the side of the square footprint. */
+    readonly radius: number;
+    readonly height: number;
+    readonly crouchHeight: number;
+    /** The highest ledge walked up without a jump. */
+    readonly step: number;
+    /** The highest a jump lifts the feet. */
+    readonly jump: number;
+    /** The farthest a running jump carries over flat ground. */
+    readonly leap: number;
+}
+/** Where a creator says a level ends, in plan: the fit adds solid around it, and over it at `ceiling` if one is stated. */
+interface SceneBound {
+    readonly min: readonly [number, number];
+    readonly max: readonly [number, number];
+    readonly ceiling?: number;
+}
+interface WorldScene {
+    readonly format: typeof WORLD_SCENE_FORMAT;
+    readonly version: typeof WORLD_SCENE_VERSION;
+    /** World units in a metre: what the report's areas are in, and how a missing `hull` is sized. */
+    readonly unitsPerMeter: number;
+    /** Where the scene came from, for the report: `{ engine, level, tool }` or whatever an exporter knows. */
+    readonly source?: Readonly<Record<string, string>>;
+    readonly hull?: SceneHullSize;
+    readonly actors: readonly SceneActor[];
+    readonly spawns: readonly SceneSpawn[];
+    readonly bound?: SceneBound;
+}
+/** Why a scene was refused: the path of the first bad value. */
+declare class WorldSceneError extends RangeError {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+/** Checks a scene as read from JSON and decodes its arrays. Throws {@link WorldSceneError} with the first bad value's path. */
+declare function parseWorldScene(raw: unknown): WorldScene;
+/** Whether a surface answers a channel. A surface that names no channels answers both. */
+declare function surfaceAnswers(surface: SceneSurface, channel: SceneChannel): boolean;
+
+type WorldBox = [number, number, number, number, number, number];
+type WorldRamp = [number, number, number, number, number, number, number, number, number];
+declare const SolidStage: {
+    readonly Exact: "exact";
+    readonly Ramp: "ramp";
+    readonly Tile: "tile";
+    readonly Cover: "cover";
+    readonly Prop: "prop";
+};
+type SolidStage = (typeof SolidStage)[keyof typeof SolidStage];
+
+/** The cells to clear from a hull-footprint layer so the lattice sees the doors it can't, as a layer of its own: a check of a
+ *  fitted world clears the same ones, since the fit leaves them open by the same reasoning. */
+/** A door a hull clears by under a cell, between walls the fit can't keep exact: its cover can't hold a gap finer than its lattice
+ *  without either closing it or widening it into a place a hull stands on nothing the source has. It is kept shut and named. */
+interface ShutDoor {
+    readonly actor: string;
+    readonly at: readonly [number, number, number];
+}
+
+interface Reach {
+    /** Each hull position standing: column * nz + height cell. */
+    readonly nodes: Int32Array;
+    readonly count: number;
+    /** One bit per standing position. */
+    readonly standing: Layer;
+    /** Every cell a hull's body was in, on a hull position's column. */
+    readonly body: Layer;
+    /** Columns a hull fell out of the bottom of everything from, one a column. */
+    readonly fell: Uint8Array;
+    readonly fellOut: number;
+    /** Spawns with nowhere to stand within the lattice, by index. */
+    readonly unplaced: readonly number[];
+}
+interface ReachCompare {
+    readonly truthNodes: number;
+    readonly fitNodes: number;
+    /** Truth's positions the fit has nothing for within the height tolerance, and the same the other way. */
+    readonly lostNodes: number;
+    readonly extraNodes: number;
+    readonly lostPct: number;
+    /** Of the lost, the share with no position of the fit's within the slack: real, not a wall's face moved. */
+    readonly lostBeyondSlackPct: number;
+    readonly extraPct: number;
+    readonly worstLostM2: number;
+    readonly worstExtraM2: number;
+    /** Extra positions with no source surface near the feet and the source above them: under a floor. A hard fail. A hull
+     *  above everything the source has is lifted, which is the floor figures' business. */
+    readonly underFloorNodes: number;
+    /** Columns a hull falls out of the level from where the source holds it. A hard fail. */
+    readonly newFalls: number;
+    /** Lost positions beyond the slack, to repair. */
+    readonly lost: readonly number[];
+    readonly extra: readonly number[];
+}
+
+/** How a fit ended. Only `ok` carries a world. */
+declare const FitStatus: {
+    readonly Ok: "ok";
+    /** Even the coarsest fit needs more solids than the budget. */
+    readonly OverBudget: "over_budget";
+    /** A hull gets under the source's floor or out of the level in every fit tried. */
+    readonly FallsThrough: "falls_through";
+    /** A fit within budget loses more reach than a fit may. */
+    readonly ReachLost: "reach_lost";
+    /** A gap the source has shut is open, or shut by less than the stated margin, in every fit tried: never a world. */
+    readonly OpenSlits: "open_slits";
+    /** In every fit tried, feet stay further from the source's floor than a player can miss, and the budget cannot buy them back. */
+    readonly FloorOver: "floor_over";
+    /** No spawn stands anywhere, so there is no reach to fit. */
+    readonly NoReach: "no_reach";
+};
+type FitStatus = (typeof FitStatus)[keyof typeof FitStatus];
+interface FitOptions {
+    readonly maxBoxes: number;
+    readonly maxRamps: number;
+    /** A finer or coarser lattice than the level's size asks for, in scene units. */
+    readonly cell?: number;
+    /** A fixed floor range and slack rather than a search: for tests and comparisons. */
+    readonly rung?: FitRung;
+    /** Skips the repair rounds: what the unchecked fit gives. For tests. */
+    readonly noRepair?: boolean;
+    readonly keepProbe?: boolean;
+    readonly log?: (line: string) => void;
+}
+interface FitRung {
+    /** Cells of height a floor tile may span. */
+    readonly floorRange: number;
+    /** Cells a wall may recede from a hull. */
+    readonly slack: number;
+    /** Small actors as a box a surface. */
+    readonly props: boolean;
+}
+interface FitActorCost {
+    readonly name: string;
+    readonly boxes: number;
+    readonly ramps: number;
+    /** The reach this actor's bounds stand on: what a creator loses by making it one box. */
+    readonly reachIfBoxedPct: number;
+}
+/** Sampled hull positions: the highest surface under the footprint in the fit, against the same in the source. */
+/** How far the source's reach runs past what the level holds. Flagged, never refused: a creator answers with a `bound`. */
+interface FitReachExtent {
+    /** The plan of the spawns and every actor but flat ground as wide as the level. */
+    readonly coreMin: readonly [number, number];
+    readonly coreMax: readonly [number, number];
+    readonly reachM2: number;
+    /** What a hull gets to from a spawn walking and stepping, with no jump. */
+    readonly walkedM2: number;
+    /** The share of the reach only a jump gets to. */
+    readonly beyondWalkPct: number;
+    /** The share of the reach further than a run jump past the plan of all that walking gets to. */
+    readonly outsideWalkedPct: number;
+    /** The reach further than a run jump past the core. */
+    readonly outsideCoreM2: number;
+    readonly outsideCorePct: number;
+    readonly farthestFromCoreM: number;
+    /** The scene states a bound. */
+    readonly bounded: boolean;
+    readonly flagged: boolean;
+}
+interface FitFloorError {
+    readonly samples: number;
+    readonly p50Units: number;
+    readonly p95Units: number;
+    readonly p99Units: number;
+    /** The worst at the lattice's points. A real hull stands between them and can read more: see upperBoundUnits. */
+    readonly maxUnits: number;
+    /** No grounded hull, at any position over the reach, reads further from the source than this. A ledge's height wherever a
+     *  footprint can overlap a ledge by a hair more in one world than the other. */
+    readonly upperBoundUnits: number;
+    /** The same with a hair's overlap taken out: at every position, a hull within half a cell reads the source's height to this. */
+    readonly edgeFreeUnits: number;
+    /** Share of positions standing above the source's surface. */
+    readonly abovePct: number;
+    /** The worst positions, so a creator can go and look: feet, and the highest surface under the footprint on each side. */
+    readonly worst: readonly {
+        readonly at: readonly [number, number, number];
+        readonly source: number;
+        readonly fit: number;
+    }[];
+}
+interface FitReport {
+    readonly status: FitStatus;
+    /** Why, in a sentence that names what to do. */
+    readonly detail: string;
+    readonly budget: {
+        readonly maxBoxes: number;
+        readonly maxRamps: number;
+    };
+    readonly boxes: number;
+    readonly ramps: number;
+    readonly stages: Readonly<Record<SolidStage, number>>;
+    readonly cell: number;
+    readonly rung: FitRung;
+    /** How far the fit's floors are from the source's, measured under a hull's whole footprint. Null if never checked. */
+    readonly floor: FitFloorError | null;
+    /** How far a floor tile may span, and a wall's face may recede: the settings of this fit, not its error. */
+    readonly floorTileSpanUnits: number;
+    readonly wallSlackUnits: number;
+    readonly reach: Omit<ReachCompare, 'lost' | 'extra'> & {
+        readonly truthFellOut: number;
+        readonly fitFellOut: number;
+    };
+    /** How much narrower a hull could be and still fit nowhere the source's doesn't: a gap shut in the source stays shut by this. */
+    readonly gapMarginUnits: number;
+    /** Gaps between solids the fit made shut by less than that margin, or open, too narrow for the lattice to see. Zero is the rule. */
+    readonly openSlits: number;
+    /** Doors a hull clears by under a lattice cell in walls the fit can't keep exact: shut in this world, by name. */
+    readonly narrowDoorsShut: readonly ShutDoor[];
+    /** Positions on a leaning face or a lip under a cell wide, with the face rising beside them, closed as no floor. */
+    readonly leanLedges: number;
+    readonly reachExtent: FitReachExtent;
+    /** Rounds of re-covering around places the check found a difference. */
+    readonly repairs: number;
+    readonly unreachableActors: number;
+    /** Named: what moves at run time and so is not in a static world. */
+    readonly movableActors: readonly string[];
+    /** Actors baked as boxes because the budget ran out. */
+    readonly cutProps: readonly string[];
+    /** The costliest actors, first. On a refusal these are what to simplify. */
+    readonly actors: readonly FitActorCost[];
+    readonly spawnsNotPlaced: readonly string[];
+    readonly seconds: number;
+}
+interface FitWorld {
+    readonly boxes: readonly WorldBox[];
+    readonly ramps: readonly WorldRamp[];
+    readonly hash: number;
+}
+interface FitResult {
+    readonly report: FitReport;
+    /** Present only with status `ok`. */
+    readonly world: FitWorld | null;
+    /** With `keepProbe`: the lattice and the source's reach, and what the last try placed even when refused. */
+    readonly probe?: FitProbe;
+}
+/** What a test needs to walk a world over the source's own reach. */
+interface FitProbe {
+    readonly l: Lattice;
+    readonly truth: Reach;
+    readonly attempted: {
+        readonly boxes: readonly WorldBox[];
+        readonly ramps: readonly WorldRamp[];
+    };
+    /** The flood of what was placed, when it was checked. */
+    readonly fitted: Reach | null;
+}
+/** Feet against the highest surface under the footprint, in hull radii: at the 99th percentile and at worst. Past this a player sees
+ *  the float. Floors win over budget: a level that cannot hold them is refused by name, never fitted floating. */
+declare const FLOOR_P99_RADII = 0.5;
+declare const FLOOR_MAX_RADII = 1;
+/** The actor a stated bound's solid goes by, in a report and a budget. */
+declare const BOUND_ACTOR = "Bound";
+declare function sceneHull(scene: WorldScene): SceneHullSize;
+/** §17.7's hash: 32-bit FNV-1a over the counts and every value as a little-endian binary32. */
+declare function fitWorldHash(boxes: readonly (readonly number[])[], ramps: readonly (readonly number[])[]): number;
+/** The ladder, finest first. Floors loosen before walls: a floor's error is a foot's height, a wall's is a clipped shoulder. */
+declare function fitRungs(hull: SceneHullSize, h: number): readonly FitRung[];
+/** Where a hull can be in a scene, with no world made: what a shot world starts from. */
+declare function sceneReach(scene: WorldScene, cell?: number): {
+    readonly hull: SceneHullSize;
+    readonly l: Lattice;
+    readonly truth: Reach;
+};
+/** Fits a scene to a world within a budget, or refuses by name. */
+declare function fitScene(scene: WorldScene, options: FitOptions): FitResult;
+
+/** How a shot fit ended. Only `ok` carries a world. */
+declare const ShotFitStatus: {
+    readonly Ok: "ok";
+    /** Even the coarsest shot world needs more boxes or bytes than the budget. */
+    readonly OverBudget: "over_budget";
+    /** No spawn stands anywhere, so no muzzle sees anything. */
+    readonly NoReach: "no_reach";
+    /** Within budget, but rays disagree with the source past what a shot world may. */
+    readonly Inaccurate: "inaccurate";
+};
+type ShotFitStatus = (typeof ShotFitStatus)[keyof typeof ShotFitStatus];
+interface ShotFitOptions {
+    readonly maxBoxes: number;
+    /** The shot world's JSON may be at most this long: what it adds to a module. */
+    readonly maxBytes?: number;
+    /** One lattice rather than the ladder, in scene units. */
+    readonly cell?: number;
+    /** Rays the report's accuracy is read from. */
+    readonly rays?: number;
+    /** Least facings to measure claims at, for choosing `MIN_CLAIM_FACING` from data. */
+    readonly facings?: readonly number[];
+    /** A surface further than this from any hull is not in it. Default 1,024 hull radii. */
+    readonly range?: number;
+    readonly log?: (line: string) => void;
+}
+/** Rays from where a hull stands, the fitted world against the source's own surfaces. */
+interface ShotAccuracy {
+    readonly rays: number;
+    /** Share of rays on which one world stopped the ray and the other did not. */
+    readonly hitMissPct: number;
+    /** The source stopped it, the shot world did not: a bullet through a wall. */
+    readonly passesPct: number;
+    /** The shot world stopped it, the source did not: a bullet stopped by air. */
+    readonly stopsPct: number;
+    /** Rays both stop: how far apart along the ray. */
+    readonly stopped: number;
+    readonly p50Units: number;
+    readonly p95Units: number;
+    readonly p99Units: number;
+    readonly maxUnits: number;
+    /** Where the fit's stops are from a surface of the source, on any axis, by steps of the lattice. Along a ray a near miss of an edge reads
+     *  as the whole way to the next wall; this reads what is really off. */
+    readonly surfaceP50Units: number;
+    readonly surfaceP99Units: number;
+    readonly surfaceMaxUnits: number;
+    /** The worst rays, so a creator can go and look. */
+    readonly worst: readonly {
+        readonly from: readonly [number, number, number];
+        readonly dir: readonly [number, number, number];
+        readonly source: number | null;
+        readonly fit: number | null;
+    }[];
+}
+/** What a tolerance is worth, read from the same rays by the rule a room's `ctx.world.claim` uses. */
+interface ShotClaimMargin {
+    readonly toleranceUnits: number;
+    /** The least a ray is taken to face a surface: `tolerance / minFacing` is the most a graze reaches along the ray. */
+    readonly minFacing: number;
+    /** Rays either world stops on which an honest claim, the source's own stop, is refused or capped. */
+    readonly honestOffPct: number;
+    /** Rays the source stops on which a hostile claim, `HOSTILE_PAST_RADII` beyond the source's stop, stands: a body behind what it hit. */
+    readonly hostilePassPct: number;
+    /** How far past the source's real surface the most a claim may say reaches. */
+    readonly hostileGainP50Units: number;
+    readonly hostileGainP99Units: number;
+    readonly hostileGainMaxUnits: number;
+}
+interface ShotActorCost {
+    readonly name: string;
+    readonly boxes: number;
+}
+interface ShotFitReport {
+    readonly status: ShotFitStatus;
+    /** Why, in a sentence that names what to do. */
+    readonly detail: string;
+    readonly budget: {
+        readonly maxBoxes: number;
+        readonly maxBytes: number;
+    };
+    readonly boxes: number;
+    /** Source boxes on the axes, kept to a grid of a few hundredths of a cell. */
+    readonly exactBoxes: number;
+    readonly coverBoxes: number;
+    /** What it adds to a module, as JSON. */
+    readonly bytes: number;
+    readonly cell: number;
+    /** How far off a surface this world's stops are at the 99th percentile, at least a grid step: the world's own `tolerance`. */
+    readonly toleranceUnits: number;
+    readonly accuracy: ShotAccuracy | null;
+    /** Tolerances, measured: the cheat margin each buys and the honest shots each refuses. */
+    readonly claims: readonly ShotClaimMargin[];
+    /** With `facings`: the same at each of them, at each tolerance. */
+    readonly claimGrid: readonly ShotClaimMargin[];
+    /** Share of the lattice's cells a muzzle's line can reach. */
+    readonly seenAirPct: number;
+    /** Named: what moves at run time and so is not in a static world. */
+    readonly movableActors: readonly string[];
+    /** Actors no muzzle sees: nothing of them is in the world. */
+    readonly unseenActors: readonly string[];
+    /** The costliest actors, first. */
+    readonly actors: readonly ShotActorCost[];
+    readonly seconds: number;
+}
+/** What a module exports as `shotWorld`. */
+interface ShotWorld {
+    readonly boxes: readonly (readonly number[])[];
+    readonly ramps: readonly (readonly number[])[];
+    readonly tolerance: number;
+}
+interface ShotFitResult {
+    readonly report: ShotFitReport;
+    readonly world: ShotWorld | null;
+}
+/** Where a hostile claim says a shot stopped, past the source's stop: a body behind what it hit. */
+declare const HOSTILE_PAST_RADII = 3;
+/** A ray through a fitted shot world, by the rule a room's `ctx.world.ray` uses: boxes as open solids. For the fit's own check and tests. */
+declare function shotRay(world: ShotWorld, origin: readonly [number, number, number], dir: readonly [number, number, number], range?: number): {
+    readonly dist: number;
+    readonly solid: number;
+    readonly axis: number;
+} | null;
+/** A verdict from a ray's stop, with no ray in it: the rule of a room's `ctx.world.claim` for a weapon that does not pierce (guest-prelude.ts
+ *  `worldClaim`, held to it by authority-host's world-claim-model.test.ts). `facing` is how squarely the ray meets its stop, 1 for none. */
+declare function claimArithmetic(server: number, facing: number, claimed: number | null, tolerance: number, range: number, minFacing?: number): {
+    readonly dist: number;
+    readonly verdict: ClaimVerdict;
+    readonly slack: number;
+};
+/** What a room's `ctx.world.claim` answers for a weapon that does not pierce: for a report to measure, and a test to hold to the room. */
+declare function claimedStop(world: ShotWorld, origin: readonly [number, number, number], dir: readonly [number, number, number], claimed: number | null, tolerance: number, range: number, minFacing?: number): {
+    readonly dist: number;
+    readonly verdict: ClaimVerdict;
+    readonly slack: number;
+    readonly server: number | null;
+};
+/** A ray against a scene's own shot surfaces: what an exporter's check holds its file to an engine's physics with. */
+declare function sceneShotRays(scene: WorldScene): (origin: readonly [number, number, number], dir: readonly [number, number, number], range: number) => number | null;
+/** Fits what a muzzle can see of a scene, within a budget, or refuses by name. */
+declare function fitShotWorld(scene: WorldScene, options: ShotFitOptions): ShotFitResult;
+
+/** Room units in a metre when a level does not say: the Source defaults every preset starts from. */
+declare const DEFAULT_UNITS_PER_METER = 39.37;
+interface GltfLevelOptions {
+    readonly unitsPerMeter?: number;
+    readonly hull?: LevelHull;
+    readonly spawns?: readonly {
+        readonly at: readonly [number, number, number];
+        readonly name?: string;
+        readonly tags?: readonly string[];
+    }[];
+}
+interface GltfLevel extends LevelScene {
+    readonly sha256: string;
+}
+/** Reads a `.glb` or `.gltf` into the scene format. Throws {@link LevelRefusal} naming what to change. Same file, same
+ *  bytes and hash, on every OS: `json` is what to write and `sha256` its hash. */
+declare function readGltfLevel(path: string, options?: GltfLevelOptions): GltfLevel;
+
+/** Exit codes, as `genex world fit` has them: fine, a call that is not this command's, a level that is refused. */
+declare const WorldGltfExit: {
+    readonly Ok: 0;
+    readonly Usage: 1;
+    readonly Refused: 3;
+};
+type WorldGltfExit = (typeof WorldGltfExit)[keyof typeof WorldGltfExit];
+/** Where the lines go, the shape `genex world` hands in: `print` carries one result line a caller can parse, `error` what a
+ *  person reads. */
+interface WorldGltfIo {
+    readonly print: (line: string) => void;
+    readonly error: (line: string) => void;
+}
+/** Reads one level and writes its scene. Takes positional arguments and nothing else. Prints `SCENE {...}` on success
+ *  and `REFUSED {"code","message"}` on a refusal, which writes nothing. */
+declare function runWorldGltf(args: readonly string[], io?: WorldGltfIo): WorldGltfExit;
+
+export { BOUND_ACTOR, DEFAULT_UNITS_PER_METER, FLOOR_MAX_RADII, FLOOR_P99_RADII, type FitActorCost, type FitFloorError, type FitOptions, type FitProbe, type FitReachExtent, type FitReport, type FitResult, type FitRung, FitStatus, type FitWorld, type GltfLevel, type GltfLevelOptions, HOSTILE_PAST_RADII, LevelHull, LevelScene, type SceneActor, type SceneBound, type SceneBox, type SceneCapsule, SceneChannel, type SceneHeightfield, type SceneHull, type SceneHullSize, type SceneMesh, type SceneSpawn, type SceneSphere, type SceneSurface, SceneSurfaceKind, SceneTag, type SceneVec3, type ShotAccuracy, type ShotActorCost, type ShotClaimMargin, type ShotFitOptions, type ShotFitReport, type ShotFitResult, ShotFitStatus, type ShotWorld, WORLD_SCENE_FORMAT, WORLD_SCENE_VERSION, WorldGltfExit, type WorldGltfIo, type WorldScene, WorldSceneError, claimArithmetic, claimedStop, fitRungs, fitScene, fitShotWorld, fitWorldHash, parseWorldScene, readGltfLevel, runWorldGltf, sceneHull, sceneReach, sceneShotRays, shotRay, surfaceAnswers };