@spawnite/engine 0.1.0-beta.15

package/dist/replay.d.ts

@@ -0,0 +1 @@
+export { Blobs, ClockEvent, ConsoleEvent, CorrectionsEvent, DecodedRecord, ImageEntity, LoggedRoomAction, LongFrameEvent, MarkEvent, PauseEvent, PerformanceEvent, ReplayEvent, ReplayEventType, ReplayLine, ReplayWindow, RoomAction, RoomActionKind, RoomCheckpoint, RoomCheckpointRead, RoomEvent, RoomState, SkippedTrait, WorldCapture, WorldChange, WorldEvent, WorldImage, readReplayRecords, readRoomActions, readRoomCheckpoint, readWorldLines, recordingFormat, worldImageFormat } from "./public.js";

package/dist/replay.js

@@ -0,0 +1 @@
+import{u as e}from"./B_HFa2lJ.js";import{c as t,l as n}from"./SMby3e6M.js";import{_ as r}from"./BLB4-b4b.js";import{n as i}from"./BR3nbYwS.js";export{i as readReplayRecords,t as readRoomActions,n as readRoomCheckpoint,r as readWorldLines,e as recordingFormat};

package/dist/testing.d.ts

@@ -0,0 +1,542 @@
+import { ActorMotion, AngleInputDeclaration, ArmAngles, ArmColliderRadii, ArmColliders, ArmSpread, AuthoritativeStep, AuthoritativeSystem, Authority, AvatarName, AxisInputDeclaration, AxisKeys, BooleanMessageField, ButtonInputDeclaration, CharacterCapsule, CharacterCapsuleTrait, CharacterController, CharacterControllerTrait, CharacterOverlay, CharacterSpawnHook, CharacterSpawnProps, ClientStep, CollisionLayerHandle, CollisionMask, ControlReleaseContext, ControlReleaseHook, CoreTrait, DeepReadonly, Disposer, EngineQueryParameter, EntitiesMessageField, EntityAuthority, EntityMessageField, EventDelivery, EventHandle, EventRecord, EventScope, FieldsPayload, GroundMark, GroundSurface, HandleOf, HeadlessGame, HeadlessGameOptions, HeadlessScene, InputContextDeclaration, InputContextDeclarations, InputContextHandle, InputContextHandles, InputDeclarations, InputHandle, InputHandles, InputKind, InputValue, JoinStep, JointLimits, JointMotorRecord, JointRecord, JointType, KeyCode, LeaveReason, MessageDeclaration, MessageDeclarations, MessageField, MessageFieldKind, MessageFields, MessageHandle, MessageHandles, MessagePayload, MessageSettings, MessageShape, ModelClip, ModelClipSpeeds, ModelMaterial, ModelName, MountedScene, MovementPreset, MovementSettings, NameplateAudience, NameplateOptions, NameplateProps, NameplateSetting, NameplateWalls, NavMeshHandle, NoInputContexts, NoInputs, NoMessages, NoPageActions, NumberMessageField, Omission, PageActionDeclaration, PageActionDeclarations, PageActionHandle, PageActionHandles, PayloadOf, Phase, PhaseName, PhysicsActor, PhysicsHandle, PhysicsOptions, PhysicsSettings, PhysicsValues, PlaceholderShape, PlatformOnLeave, PlayerHook, PlayerJoinContext, PlayerJoinHook, PlayerLeaveContext, PlayerLeaveHook, PlayerRestoreContext, PlayerSaveContext, PluginConfig, PluginFactory, PluginList, PluginSave, PluginSetup, PluginSystems, PredictedDraw, PredictedEntity, PredictedModifier, PredictedQuery, PredictedStep, PredictedSystem, PredictedTrait, PredictedTuple, PressDeclaration, PressHandle, ReadEventOptions, ReadonlyQuaternion, ReadonlyVector2, ReadonlyVector3, RecordsOf, ReleaseReason, ReplaceableHandle, Requirement, ResourceKey, RespawnOptions, RespawnPlace, RestoreContext, RunContext, SaveContext, SavePlayer, SaveSchema, SaveScope, SaveScopeName, StepInput, StepOptions, StreamedFeet, StringMessageField, SweepRecord, System, SystemHandle, SystemHandles, SystemStep, TouchControl, VectorInputDeclaration, VectorKeys, VectorValue, VrmBody, WorldSaveContext, characterMovementSettings, createGroundSurface } from "./public.js";
+import type { ColorRepresentation } from 'three';
+import type { ComponentType } from 'react';
+import { ConfigurableTrait } from 'koota';
+import { CoverKind } from '@spawnite/schema';
+import { Entity } from 'koota';
+import type { IconName } from '@spawnite/ui';
+import { InstancesFromParameters } from 'koota';
+import type { JsonValue } from '@spawnite/schema';
+import { MapTerrain } from '@spawnite/schema';
+import type { Material } from 'three';
+import type { MeshBVH } from 'three-mesh-bvh';
+import type { NavMesh } from '@recast-navigation/core';
+import type { NavMeshQuery } from '@recast-navigation/core';
+import { Object3D } from 'three';
+import { PropShape } from '@spawnite/schema';
+import type { PropsWithChildren } from 'react';
+import { Quaternion } from 'three';
+import { Query } from 'koota';
+import { QueryParameter } from 'koota';
+import type RAPIER from '../../../rapier/types/rapier';
+import type { ReactNode } from 'react';
+import { RelationPair } from 'koota';
+import type { SavedHealth } from '@spawnite/schema';
+import type { SavedStat } from '@spawnite/schema';
+import { SaveMigrations } from '@spawnite/schema';
+import { ScatterFamily } from '@spawnite/schema';
+import { ScatterKind } from '@spawnite/schema';
+import { Schema } from 'koota';
+import { TerrainMap } from '@spawnite/schema';
+import { TestAPI } from 'vitest';
+import { Trait } from 'koota';
+import { TraitRecord } from 'koota';
+import { TraitValue } from 'koota';
+import type { Vector } from '../../../rapier/types/rapier';
+import type { Vector2 } from 'three';
+import { Vector3 } from 'three';
+import { Vector3Tuple } from 'three';
+import { VRMHumanBoneName } from '@pixiv/three-vrm';
+import { World } from 'koota';
+import { z } from '@spawnite/schema';
+
+/** Joins a player to `world` as a room joins a connection, at the lowest
+ *  free seat: her player entity, each plugin's `onPlayerJoin`, then each
+ *  `onPlayerReady`. Answers her player entity. A card game's test adds
+ *  two and reads each one's hand.
+ *  @category Testing */
+export declare function addPlayer(world: World, { name, account, avatar, returning }: AddPlayerOptions): Entity;
+
+/** What `addPlayer` takes.
+ *  @category Testing */
+export declare interface AddPlayerOptions {
+    /** What she plays under. */
+    name: string;
+    /** Her account's id: her name when left out. */
+    account?: string;
+    /** The registered avatar her account carries: none when left out. */
+    avatar?: string;
+    /** Whether her account held a seat in this world earlier, which
+     *  `onPlayerJoin` reads: false when left out. */
+    returning?: boolean;
+}
+
+/** Any phase record, its keys any string: what a record built at run
+ *  time is typed as. */
+declare type AnyPhaseShape = Readonly<Record<string, unknown>>;
+
+/** A system the world's step runs once on the room alone: a rule the room
+ *  judges and streams, such as a spawn, a score or damage. It runs on a
+ *  room and in a game played alone, never on a page in a room, so its step
+ *  is the room's, the authority every outcome function takes: no
+ *  `if (step.authoritative)` needed.
+ *  @category Plugins */
+declare interface AuthoritativeSystemEntry<Of extends PhaseName = PhaseName, Sibling extends string = string> extends SystemEntryFields<Of, Sibling> {
+    system: AuthoritativeSystem;
+    predicted?: false;
+    /** On the room alone: left out, or said. */
+    runsOn?: RunContext.Server;
+    /** Another plugin's system on the room alone whose place this one
+     *  takes, `replaces: behaviours.systems.reapDead`. */
+    replaces?: ReplaceableHandle<Of, false, RunContext.Server>;
+}
+
+declare const authorityBrand: unique symbol;
+
+/** A system written as its function alone, which runs on the room alone,
+ *  so its step is the room's. It holds no `predicted` and no `runsOn`, so an
+ *  entry written inline is typed by both whether it says them or not. */
+declare type BareSystem = AuthoritativeSystem & {
+    predicted?: undefined;
+    runsOn?: undefined;
+    replaces?: undefined;
+};
+
+/** A joint as the scene built it: Rapier's joint, the fixed body a joint
+ *  to the world holds to, and the record it was built from, so a change
+ *  edits only what changed. */
+declare interface BuiltJoint {
+    joint: RAPIER.ImpulseJoint;
+    anchorBody: RAPIER.RigidBody | null;
+    record: JointRecord;
+    /** Each body's scale its anchor was last set at. */
+    scale: Vector3;
+    toScale: Vector3;
+}
+
+declare interface CharacterOverlayProps {
+    entity: Entity;
+    height: number;
+}
+
+declare const coreBrand: unique symbol;
+
+/** Makes a headless game as `createHeadlessGame` does, its world destroyed
+ *  after the case: the `createGame` fixture. */
+export declare type CreateGame = (options: HeadlessGameOptions) => Promise<HeadlessGame>;
+
+/** Makes a dev world running what `plugins` compose, the `plugins`
+ *  fixture's list when left out, with its physics scene stepping with
+ *  `physics`, every default when left out, destroyed after the case: the
+ *  `createWorld` fixture, for a helper a case hands it to. */
+export declare type CreateWorld = (plugins?: PluginList, physics?: PhysicsSettings) => {
+    world: World;
+    step: Step;
+};
+
+declare type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+
+/** Hands each event emitted on `world` since the last drain to the views
+ *  that listen, in order, once: what the frame loop does once a frame,
+ *  after its steps and its animation. An event a listener emits is heard
+ *  at the next drain. A world never drained keeps nothing for its views. */
+export declare function drainEvents(world: World): void;
+
+/** Drops `player`'s connection as a closed socket does: she is held, with
+ *  `ConnectionTrait` naming the tick her hold ends on, and each plugin's
+ *  `onPlayerDisconnect` runs. Nothing ends the hold on its own: a test
+ *  calls `rejoinPlayer` or `removePlayer`.
+ *  @category Testing */
+export declare function dropPlayer(world: World, player: Entity, { holdSeconds }?: DropPlayerOptions): void;
+
+/** What `dropPlayer` takes.
+ *  @category Testing */
+export declare interface DropPlayerOptions {
+    /** Seconds the hold lasts, which `ConnectionTrait` counts in ticks: 15
+     *  when left out, a room's hold after a close frame. */
+    holdSeconds?: number;
+}
+
+/** What `updateEachPredicted` hands its callback for each character: the query's
+ *  traits, as `updateEach` hands them, and the character, whose predicted
+ *  traits the callback may write.
+ *  @category Game */
+declare type EachPredictedCallback<T extends QueryParameter[]> = (traits: InstancesFromParameters<T>, character: PredictedEntity) => void;
+
+/** What `updateEachPredicted` hands its callback over the engine's query of a
+ *  predicted trait: each predicted record writable, a tracking modifier's
+ *  read-only, and the character.
+ *  @category Game */
+declare type EachPredictedTraitCallback<T extends EngineQueryParameter[]> = (traits: RecordsOf<T, "write">, character: PredictedEntity) => void;
+
+declare const entityAuthorityBrand: unique symbol;
+
+/** The handle an entry makes, typed by what it says: predicted, where it
+ *  runs, or a function alone, which runs on the room alone. */
+declare type EntryHandle<Of extends PhaseName, Entry> = Entry extends {
+    predicted: true;
+} ? SystemHandle<Of, true, RunContext.Both> : Entry extends {
+    runsOn: infer RunsOn extends RunContext;
+} ? SystemHandle<Of, false, RunsOn> : SystemHandle<Of, false, RunContext.Server>;
+
+declare type FieldPayload<Field extends MessageField> = Field extends NumberMessageField ? number : Field extends StringMessageField ? string : Field extends EntityMessageField & {
+    optional: true;
+} ? Entity | null : Field extends EntityMessageField ? Entity : Field extends EntitiesMessageField ? readonly Entity[] : boolean;
+
+/** The four phases' handles as one record, as an editor shows it. */
+declare type FlatSystemHandles<Handles> = {
+    readonly [Key in keyof Handles]: Handles[Key];
+};
+
+declare type FunctionNumber = "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24";
+
+declare type GroundPosition = Pick<Vector3, "x" | "z">;
+
+/** Holds `record` as an event of `event` the room's stream brought to a
+ *  page, on `entity` where one is given, and hands it to the page's views,
+ *  as a frame does once the delta lands: for a test of a view on a page,
+ *  which decides no outcome and so emits none.
+ *  @category Testing */
+export declare function hearStreamedEvent<Handle extends EventHandle>(world: World, event: Handle, record: EventRecord<Handle>, { entity }?: ReadEventOptions): void;
+
+declare const inputValue: unique symbol;
+
+/** The value an input's declaration holds. */
+declare type InputValueOf<Declaration> = Declaration extends AxisInputDeclaration ? number : Declaration extends AngleInputDeclaration ? number : Declaration extends VectorInputDeclaration ? VectorValue : boolean;
+
+/** `test` under the name the repository's cases use. */
+export declare const it: TestAPI<Omit<Omit<Omit<Omit<Omit<Omit<object, "$__test"> & Record<"plugins", PluginList> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList>) | undefined;
+}, "$__test"> & Record<"createWorld", CreateWorld> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld>) | undefined;
+}, "$__test"> & Record<"world", World> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World>) | undefined;
+}, "$__test"> & Record<"step", Step> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step>) | undefined;
+}, "$__test"> & Record<"createGame", CreateGame> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step> & Record<"createGame", CreateGame>) | undefined;
+}, "$__test"> & Record<"scene", Scene> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step> & Record<"createGame", CreateGame> & Record<"scene", Scene>) | undefined;
+}>;
+
+declare const joinStepBrand: unique symbol;
+
+declare const layerBrand: unique symbol;
+
+declare type Letter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+
+/** The file's own name for each clip that is not named as `ModelClip`
+ *  names it, such as `{ run: "Sprint" }`.
+ *  @category Player */
+declare type ModelClips = Partial<Record<ModelClip, string>>;
+
+/** What every step a system reads holds: the caller's options and the
+ *  step's number. */
+declare interface NumberedStep extends StepOptions {
+    /** The room's tick the step is for: on a room, its own step; on her
+     *  page, the tick her page leads the room on, a replayed step the tick
+     *  it first ran on; in a game with no room, its own step, from 0. */
+    readonly tick: number;
+    /** The world the step runs on: what a hook that receives a step, such
+     *  as `onPlayerJoin(step, player)`, reads its world from. */
+    readonly world: World;
+}
+
+declare const omissionBrand: unique symbol;
+
+/** One `runsOn` of a system her page runs too, with what it may replace. */
+declare interface PageSystemEntry<Of extends PhaseName, Sibling extends string, RunsOn extends RunContext.Both | RunContext.Client> extends SystemEntryFields<Of, Sibling> {
+    system: System;
+    predicted?: false;
+    runsOn: RunsOn;
+    /** Another plugin's system of the same `runsOn` whose place this one
+     *  takes, `replaces: behaviours.systems.chase`. */
+    replaces?: ReplaceableHandle<Of, false, RunsOn>;
+}
+
+declare type Path = TerrainMap["paths"][string];
+
+declare const payloadType: unique symbol;
+
+/** One phase's handles, optional where the record's key is, and none by
+ *  name for a record built at run time, whose keys are not known. */
+declare type PhaseHandles<Of extends PhaseName, Shape> = string extends keyof Shape ? unknown : {
+    readonly [Key in keyof Shape]: EntryHandle<Of, NonNullable<Shape[Key]>>;
+};
+
+/** One phase's systems by key, mapped over the record as written, so a
+ *  key spread in on a flag stays optional. Each anchor names another key
+ *  of the same record, never its own, and the keys come from the record,
+ *  never from an anchor. Each entry is its own type too, so its handle
+ *  reads what it says: `predicted` and `runsOn`. */
+declare type PhaseSystems<Of extends PhaseName, Shape> = {
+    readonly [Key in keyof Shape]: Shape[Key] & (BareSystem | PluginSystem<Of, NoInfer<SiblingKeys<Shape, Key>>>);
+};
+
+declare const physicsBrand: unique symbol;
+
+/** A plugin's `onPlayerReady`: her save has restored, and the step
+ *  reaches what her join reached.
+ *  @category Players */
+declare type PlayerReadyHook = (step: JoinStep, player: Entity) => void;
+
+/** What `definePlugin` makes: the config, branded, with a typed handle per
+ *  message and per system.
+ *  @category Plugins */
+declare interface Plugin_2<Messages extends MessageDeclarations = MessageDeclarations, Systems extends object = SystemHandles, Inputs extends InputDeclarations = InputDeclarations, Actions extends PageActionDeclarations = PageActionDeclarations, Layers extends string = string, Contexts extends InputContextDeclarations = InputContextDeclarations> extends Omit<PluginConfig<Messages>, "messages" | "systems" | "inputs" | "contexts" | "actions" | "requires" | "collisionLayers"> {
+    readonly [pluginBrand]: true;
+    /** The plugins this one needs listed, by name. */
+    readonly requires: readonly string[];
+    /** The systems this one needs running, by handle. */
+    readonly requiresSystems: readonly SystemHandle[];
+    /** One typed handle per declared message, `siege.messages.pick`. */
+    readonly messages: MessageHandles<Messages>;
+    /** One typed handle per declared input, `sprint.inputs.sprint`. */
+    readonly inputs: InputHandles<Inputs>;
+    /** One handle per declared input context, `karts.contexts.driving`. */
+    readonly contexts: InputContextHandles<Contexts>;
+    /** One handle per declared page action, `siege.actions.ready`. */
+    readonly actions: PageActionHandles<Actions>;
+    /** One handle per declared collision layer, `karts.collisionLayers.ball`. */
+    readonly collisionLayers: {
+        readonly [Key in Layers]: CollisionLayerHandle;
+    };
+    /** One typed handle per system, `siege.systems.spawn`: what another
+     *  plugin's `before`, `after`, `replaces` and `requires` name it by,
+     *  and what `omit` takes. */
+    readonly systems: Systems;
+    readonly [pluginEntries]: PluginSystems;
+}
+
+declare const pluginBrand: unique symbol;
+
+declare const pluginEntries: unique symbol;
+
+/** The plugin name a factory makes, which a requirement reads. */
+declare const pluginFactoryName: unique symbol;
+
+/** A system with what the composer needs beyond the function: a predicted
+ *  system's entry, a system's on the room alone, or one's that her page
+ *  runs too.
+ *  @category Plugins */
+declare type PluginSystem<Of extends PhaseName = PhaseName, Sibling extends string = string> = PredictedSystemEntry<Of, Sibling> | AuthoritativeSystemEntry<Of, Sibling> | WorldSystemEntry<Of, Sibling>;
+
+/** What a `PredictedEntity` adds to koota's entity methods: each also
+ *  takes a predicted trait. */
+declare interface PredictedAccess {
+    get<S extends Schema>(trait: PredictedTrait<S>): TraitRecord<S> | undefined;
+    set<S extends Schema>(trait: PredictedTrait<S>, value: TraitValue<S> | ((previous: TraitRecord<S>) => TraitValue<S>), flagChanged?: boolean): void;
+    has(trait: PredictedTrait): boolean;
+    add(...traits: (ConfigurableTrait | PredictedTrait | PredictedTuple)[]): void;
+    remove(...traits: (Trait | RelationPair | PredictedTrait)[]): void;
+}
+
+declare const predictedBrand: unique symbol;
+
+declare const predictedEntityBrand: unique symbol;
+
+declare const predictedModifierBrand: unique symbol;
+
+declare const predictedQueryBrand: unique symbol;
+
+declare const predictedStepBrand: unique symbol;
+
+/** What a predicted system's step holds beyond any system's. */
+declare interface PredictedStepFields {
+    readonly [predictedStepBrand]: true;
+    /** Calls `callback` for each character this step steps that `query`
+     *  matches, and writes each trait back, as `updateEach` does: on a
+     *  room and in a game played alone, every character; on her page in a room,
+     *  her own character alone, the one under the client's authority, since the
+     *  room's stream moves every other; and
+     *  on a step of one character, the entity `rerunEntity` names, as on her page's
+     *  replay after a correction. An entity no player controls is never
+     *  handed to it, whatever the query matches. As Unity's Netcode
+     *  filters a predicted system with its `Simulate` tag. The only
+     *  writable pass over a predicted trait. */
+    readonly updateEachPredicted: UpdateEachPredicted;
+    /** On a step of one character, her page's replay after a correction, the
+     *  character it steps; left out on the world's step. */
+    readonly rerunEntity?: PredictedEntity;
+}
+
+/** A system that steps a character on her own clock, a dash or a knockback:
+ *  it runs on the world's step over every character, and again for her alone
+ *  in her page's replay when the room corrects her, where `step.rerunEntity`
+ *  names her. Its state lives in traits declared `predicted`, which the
+ *  replay restores. The room and her page both run it, so it declares no
+ *  `runsOn`. A reaction to an event is never one.
+ *  @category Plugins */
+declare interface PredictedSystemEntry<Of extends PhaseName = PhaseName, Sibling extends string = string> extends SystemEntryFields<Of, Sibling> {
+    system: PredictedSystem;
+    predicted: true;
+    /** Both ends, as a predicted system always runs: said or left out. */
+    runsOn?: RunContext.Both;
+    /** Another plugin's predicted system whose place this one takes: its
+     *  slot in the order, its anchors, and every anchor and requirement
+     *  naming it, `replaces: characters.systems.movement`. */
+    replaces?: ReplaceableHandle<Of, true, RunContext.Both>;
+}
+
+/** The record of each event of `event` that `world` holds now, oldest
+ *  first, on `entity` alone where one is given: what a case reads of the
+ *  events a step emitted, which the step after next lets go. The dump's
+ *  `events` lists the same, each entity as its key.
+ *  @category Testing */
+export declare function readHeldEvents<Handle extends EventHandle>(world: World, event: Handle, { entity }?: ReadEventOptions): EventRecord<Handle>[];
+
+declare const recordType: unique symbol;
+
+/** Takes `player` back within her hold, as a rejoin with her key does: she
+ *  is connected again, and each plugin's `onPlayerReconnect` runs.
+ *  @category Testing */
+export declare function rejoinPlayer(world: World, player: Entity): void;
+
+/** Takes `player` out of `world` as a leave does: each plugin's
+ *  `onPlayerLeave`, then her player entity goes.
+ *  @category Testing */
+export declare function removePlayer(world: World, player: Entity, { reason }?: RemovePlayerOptions): void;
+
+/** What `removePlayer` takes.
+ *  @category Testing */
+export declare interface RemovePlayerOptions {
+    /** Why she leaves, which `onPlayerLeave` reads: `LeaveReason.Left` when
+     *  left out. */
+    reason?: LeaveReason;
+}
+
+/** Ends the page's save once the write its last close sent has reached
+ *  its host, so the next Game loads the host's record afresh: what a test
+ *  that renders its Game awaits after each case, and after it unmounts its
+ *  Game before it reads what was saved.
+ *  @category Testing */
+export declare function resetPageSave(): Promise<void>;
+
+/** Puts every persisted store back to its defaults, unloaded, and frees
+ *  them from any save: what a test calls between cases.
+ *  @category Testing */
+export declare function resetPersistedStores(): void;
+
+declare const resourceKeyBrand: unique symbol;
+
+/** Mounts `Scene` headless on `world`, a new dev world when left out, and
+ *  unmounts it after the case: the `scene` fixture, for a helper a case
+ *  hands it to. */
+export declare type Scene = (Scene: ComponentType, world?: World) => Promise<MountedScene>;
+
+/** The keys a system under `Key` may anchor to: the record's others, or
+ *  any string for a record built at run time, whose keys are not known. */
+declare type SiblingKeys<Shape, Key> = string extends keyof Shape ? string : Exclude<Extract<keyof Shape, string>, Key>;
+
+/** Where a body `moveAndSlide` moved stood before its first move of the
+ *  tick. */
+declare interface SlidStart {
+    position: Vector3;
+    rotation: Quaternion;
+}
+
+/** Advances `world` by `steps` fixed steps through `stepWorld`, each
+ *  reading `input` where one is given. */
+export declare type Step = (steps?: number, input?: StepInput) => void;
+
+/** What `before` and `after` take: another plugin's system by its handle,
+ *  or one of the same plugin and phase by its key, `"second"` of
+ *  `{ first, second }`. A name such as `"characters.movement"` is neither.
+ *  @category Plugins */
+declare type SystemAnchor<Of extends PhaseName = PhaseName, Sibling extends string = string> = SystemHandle<Of> | Sibling;
+
+/** What every system's entry may carry beyond the function. */
+declare interface SystemEntryFields<Of extends PhaseName, Sibling extends string> {
+    description?: string;
+    /** Systems of the same phase this one runs before or after, each a
+     *  handle or a key of its own plugin's:
+     *  `after: [characters.systems.movement]`. */
+    before?: readonly SystemAnchor<Of, Sibling>[];
+    after?: readonly SystemAnchor<Of, Sibling>[];
+}
+
+declare const systemHandleBrand: unique symbol;
+
+/** A ground's terrain in the scene: one fixed body on the ground entity,
+ *  holding its heightfield, the wall along each of its edges and a hull per
+ *  merge group of its scatter's bake. */
+declare interface TerrainBody {
+    body: RAPIER.RigidBody;
+    /** The surface the heightfield was sampled from, so a map edit is told
+     *  from the old by reference; null for one a checkpoint restored from an
+     *  older surface, which the next step rebuilds. */
+    surface: GroundSurface | null;
+    /** The bake the hulls stand for, so a new bake is told from the old
+     *  by reference: null for none, undefined for one a checkpoint
+     *  restored from an older bake, which the next step bakes again. */
+    obstacles: MeshBVH | null | undefined;
+    hulls: RAPIER.Collider[];
+}
+
+/** Vitest's `test` with the engine's fixtures, the same as `createHeadlessGame`
+ *  sets up: a dev world on the `plugins` fixture's list, the core alone
+ *  unless a file sets it, stepped 1/60 s at a time, with Rapier loaded. A
+ *  game's cases list its own plugins once,
+ *  `const it = test.extend("plugins", () => plugins)`, and a case that
+ *  needs another list makes its world with `createWorld(plugins)`. */
+export declare const test: TestAPI<Omit<Omit<Omit<Omit<Omit<Omit<object, "$__test"> & Record<"plugins", PluginList> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList>) | undefined;
+}, "$__test"> & Record<"createWorld", CreateWorld> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld>) | undefined;
+}, "$__test"> & Record<"world", World> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World>) | undefined;
+}, "$__test"> & Record<"step", Step> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step>) | undefined;
+}, "$__test"> & Record<"createGame", CreateGame> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step> & Record<"createGame", CreateGame>) | undefined;
+}, "$__test"> & Record<"scene", Scene> & {
+readonly $__worker?: object | undefined;
+readonly $__file?: object | undefined;
+readonly $__test?: (object & Record<"plugins", PluginList> & Record<"createWorld", CreateWorld> & Record<"world", World> & Record<"step", Step> & Record<"createGame", CreateGame> & Record<"scene", Scene>) | undefined;
+}>;
+
+/** `updateEachPredicted`, over koota's query or the engine's query of a
+ *  predicted trait. */
+declare interface UpdateEachPredicted {
+    <T extends QueryParameter[]>(query: Query<T>, callback: EachPredictedCallback<T>): void;
+    <T extends EngineQueryParameter[]>(query: PredictedQuery<T>, callback: EachPredictedTraitCallback<T>): void;
+}
+
+/** What a walk reads of a character's shape: her capsule and the
+ *  controller's step and snap, merged once a call so the walk reads no
+ *  koota record. */
+declare interface WalkerBody extends CharacterCapsule {
+    /** The controller's `stepHeight`. */
+    step: number;
+    /** The controller's `floorSnapDistance`. */
+    floorSnapDistance: number;
+}
+
+/** A system the world's step runs once on her page too, where `runsOn`
+ *  says: `RunContext.Both` for one her page runs beside the room, such as
+ *  one that only reads, and `RunContext.Client` for one that only draws. A
+ *  game with no room runs every system, whatever it declares. Its step may
+ *  be her page's, so an outcome in it sits inside
+ *  `if (step.authoritative)`.
+ *  @category Plugins */
+declare type WorldSystemEntry<Of extends PhaseName = PhaseName, Sibling extends string = string> = PageSystemEntry<Of, Sibling, RunContext.Both> | PageSystemEntry<Of, Sibling, RunContext.Client>;
+
+/** Sets `entity`'s predicted `trait` between steps, adding it where it
+ *  lacks it: a test's way to put a character's predicted state where a case
+ *  needs it, which a game writes only in a predicted step or with
+ *  `grantPredicted`. Named so a reader sees a test reach past that rule. */
+export declare function writePredictedForTest<S extends Schema>(entity: Entity, trait: PredictedTrait<S>, value: TraitValue<S> | ((previous: TraitRecord<S>) => TraitValue<S>)): void;
+
+export { }

package/dist/testing.js

@@ -0,0 +1 @@
+import{Af as e,D as t,Da as n,Df as r,Ea as i,Ia as a,Na as o,Ra as s,Sf as c,Ta as l,Tf as u,Zc as d,_ as f,_o as p,at as m,el as h,ja as g,l as _,nl as v,vd as y}from"./-MLBVTaO.js";import{Mn as b,Pn as x,Vr as S}from"./V70ADx0g.js";import{n as C}from"./BrfUaL46.js";import{u as w}from"./DCIejHqp.js";import{s as T}from"./CIq9KviM.js";import{test as E}from"vitest";function D({error:e}){throw e}function O(e,t,r){let i=n(e,t);if(!i)throw C(/* @__PURE__ */ Error(`${r}() got an entity that is no player of this world: pass the entity addPlayer returned.`),`SP0442`,void 0);return i}function k(e,{name:t,account:n=t,avatar:r=``,returning:a=!1}){let o=s(e,{account:n,name:t,seat:i(e),role:v.Player,avatar:r});return g(e,o,{returning:a,rethrow:!0}),o.entity}function A(e,t,{holdSeconds:n=15}={}){let r=O(e,t,`dropPlayer`);if(r.connection===d.Held)return;let i=b(e)+Math.round(n/_);l(e,r,i,D)}function j(e,t){let n=O(e,t,`rejoinPlayer`);n.connection!==d.Connected&&a(e,n,D)}function M(e,t,{reason:n=h.Left}={}){let r=O(e,t,`removePlayer`);o(e,r,n,D)}async function N(e,t){let n=[];for(let t of e)try{await t.unmount()}catch(e){n.push(e)}for(let e of[...t])try{e.destroy()}catch(e){n.push(e)}if(n.length===1)throw n[0];if(n.length>1)throw AggregateError(n,`Several fixtures failed to tear down.`)}function P(e,t,n){S(e,t,n)}function F(t,n,{entity:r}={}){return e(t).filter(e=>e.name===n.name&&(r===void 0||e.on===r)).map(e=>e.record)}function I(e,t,n,{entity:r}={}){u(e,{name:t.name,tick:b(e),on:r??-1,record:n}),c(e)}function L(e){return r(e),(t=1,n)=>{for(let r=0;r<t;r++)f(e,{deltaSeconds:_,input:n});c(e)}}var R=/* @__PURE__ */ new WeakMap;function z(e){let t=R.get(e);if(!t)throw C(/* @__PURE__ */ Error(`The scene and createGame fixtures need the engine's createWorld fixture: extend the test with fixtures of your own rather than replacing createWorld.`),`SP0372`,void 0);return t}var B=E.extend(`plugins`,()=>[]).extend(`createWorld`,async({plugins:e},{onCleanup:t})=>{await Promise.all([y(),p()]);let n=[],r=/* @__PURE__ */ new Set;t(()=>N(n,r));let i=e=>{r.add(e);let t=e.destroy.bind(e);return e.destroy=()=>{r.delete(e)&&t()},e},a=(t=e,n)=>{let r=i(m(t,n));return r.add(x),{world:r,step:L(r)}};return R.set(a,{scenes:n,own:i}),a}).extend(`world`,({createWorld:e})=>e().world).extend(`step`,({world:e})=>L(e)).extend(`createGame`,({createWorld:e,plugins:n})=>{let{own:r}=z(e);return e=>t({...e,plugins:e.plugins??n,scene:t=>e.scene(r(t))})}).extend(`scene`,({createWorld:e})=>{let{scenes:t}=z(e);return async(n,r=e().world)=>{let{mountHeadlessScene:i}=await import(`./CU0epHFG.js`).then(e=>e.t),a=await i(n,r);return t.push(a),a}}),V=B;export{k as addPlayer,c as drainEvents,A as dropPlayer,I as hearStreamedEvent,V as it,F as readHeldEvents,j as rejoinPlayer,M as removePlayer,T as resetPageSave,w as resetPersistedStores,B as test,P as writePredictedForTest};

package/dist/three.d.ts

@@ -0,0 +1 @@
+export * from "three";

package/dist/three.js

@@ -0,0 +1 @@
+export*from"three";

package/dist/tracks.d.ts

@@ -0,0 +1 @@
+export { ModelName, Phase, PhaseName, Position, SystemHandle, Track, TrackFrame, TrackMover, TrackMoverProps, TrackMoverTrait, TrackOptions, TrackPoint, TrackRefTrait, TrackScatter, TrackScatterCopy, TrackScatterOptions, TrackScatterProps, TrackScatterRow, TrackSectionPoint, TrackSpot, TrackSurface, TrackSurfaceOptions, TrackSurfaceProps, TrackTerrain, TrackTrigger, TrackTriggerMoversTrait, TrackTriggerProps, TrackTriggerTrait, createTrackFrame, launchTrackMover, tracks } from "./public.js";

package/dist/tracks.js

@@ -0,0 +1 @@
+import{$t as e,Jt as t,Qt as n,Tt as r,Yt as i,Zt as a,en as o,tn as s}from"./-MLBVTaO.js";import{t as c}from"./V70ADx0g.js";import{n as l,r as u,s as d,t as f}from"./BXmxKBbF.js";export{c as Phase,o as Track,d as TrackMover,t as TrackMoverTrait,i as TrackRefTrait,u as TrackScatter,l as TrackSurface,f as TrackTrigger,a as TrackTriggerMoversTrait,n as TrackTriggerTrait,s as createTrackFrame,e as launchTrackMover,r as tracks};