@cimplify/sdk 0.108.0 → 0.110.2

package/dist/policy-CMqOSQIu.d.ts

@@ -0,0 +1,3078 @@
+import { dO as CtxAchievements, eq as CtxWallet, m0 as WalletOffer, kx as SpendAllowance, kC as SpendResult, iW as ReplayRules, iT as ReplayClass, iX as ReplayScoreRule, iV as ReplayRecording, en as CtxSocial, B as CtxRequest, dD as CounterApi, $ as Persona, hA as ParticipantId, d0 as ChallengeResult, a7 as SocialPostResult, iH as RankMode, kt as SortDirection, ez as DataScope, iL as RankedEntry, e7 as CtxLeaderboards, jO as ScoreReceipt, gG as LeaderboardScope, gH as LeaderboardWindow, gE as LeaderboardPage, je as RoomApi, U as Unsubscribe, bd as AiResult, j as AiRun, b5 as AiEvent, a4 as MediaRef, e5 as CtxIdentity, bX as AvatarConsent, cQ as CapturedIdentity, X as DeclaredAgeRange, dV as CtxCamera, cG as CameraFacing, cN as CameraViewPlacement, cL as CameraView, F as FaceColours, fe as FACE_LAYOUT, fZ as IdentityCaptureCode, e9 as CtxMedia, fV as HostCall, ac as GraphicsSurface, kk as ShareAudience, a8 as ShareResult } from './local-VZkqsCzR.js';
+import { K as KeySource } from './ports-CGU_3e_0.js';
+import { E as Economy } from './tycoon-hmHo-3HX.js';
+import { E as EconomyDecl, i as InWorldContext, b as CimplesOffer, D as DisclosedOdds, F as Faucet, h as GenreTemplate } from './template-BkEGVTQj.js';
+import { S as SeededRandom, d as MessageType, e as GameNet, G as Game, f as GameUi, g as ChemistryRegion, h as ChemistryEvent, i as CELL_CLASSES, j as CHEMISTRY_EVENT_KINDS, k as CHEMISTRY_GROUPS$1, l as CHEMISTRY_REFUSALS, m as CHEMISTRY_REFUSAL_TEXT, n as CellBox, o as CellClass, p as CellProbe, C as Chemistry, q as ChemistryEventKind, r as ChemistryGroup, s as ChemistryMemory, t as ChemistryParticles, u as ChemistryRefusal, v as ChemistryVessel, b as DefineResult, w as MaterialInfo, N as NatureOptions, x as ReactionInfo, y as ReactionTerm, z as RegionOptions, B as RegionStats, V as VesselState, E as groupNames, I as InputActions, A as ActionId } from './game-fgQy2YIm.js';
+import { h as TurnRoomPort, M as MoveListener, R as ResetListener, g as TurnHistory } from './ludo-B8ClkDqr.js';
+import { aW as RollbackState, b as AssetSource, N as NodeId, v as TextureId, F as FrameTime, br as CHEMISTRY_ATMOSPHERE, bs as CHEMISTRY_BOX_WORDS, bt as CHEMISTRY_COLUMNS, bu as CHEMISTRY_EVENT_HEADER, bv as CHEMISTRY_EVENT_WORDS, bw as CHEMISTRY_EXPORT_NAMES, bx as CHEMISTRY_NATURE_WORDS, by as CHEMISTRY_PROBE_WORDS, bz as CHEMISTRY_REACTION_WORDS, bA as CHEMISTRY_REFUSED, bB as CHEMISTRY_SLOTS, bC as CHEMISTRY_SPECIES_WORDS, bD as CHEMISTRY_STATS_WORDS, bE as CHEMISTRY_TQ, bF as CHEMISTRY_UNSET, bG as CHEMISTRY_VACUUM, bH as CHEMISTRY_VESSEL_SLOTS, bI as CHEMISTRY_VESSEL_WORDS, aA as ChemistryEngine, bJ as ChemistryExportName, bK as ChemistryExports, bL as bindChemistryEngine, V as Vec3$1, aw as Quat, f as Vec3Like, a9 as PickHit, am as ClipAnimationPort, al as ClipActionId, bM as ClipLoop, ar as BlendSpaceId, aq as ClipEvent, i as GeometryId, j as MaterialId, bN as LightKind, aj as ModelInfo, $ as MaterialTextureSlot, D as DeviceTier, af as WeatherState, aZ as ComponentMemory, bO as TypedArray, aX as Scalar, aY as ArrayFor, bg as WorldSnapshots, a_ as TransformColumns, bP as PhysicsWorldDesc, bk as Ragdoll } from './backend-gUCzs5Kg.js';
+import { E as Entity, K as KernelRunner, T as Transforms } from './world-PvILHDR1.js';
+import { b as Graphics, I as InstancedBatch, G as GameScene, a as GameSystem } from './fluid-ARr0qUIL.js';
+import { a as IdentityParams, I as IdentityBase } from './params-DxFb5G_U.js';
+import { a as IdentityFitter, I as IdentityCapture, b as IdentityFitOptions, c as IdentityFit } from './fit-DK0oT7zO.js';
+import { V as Vec3Array } from './courier-Cnn-edJ4.js';
+import { bs as ThirdPersonRig, bz as TouchViewportSource, by as TouchViewport, ab as ClipEventReader } from './play-BRRlfLhX.js';
+import { SlotMap, SlotTemplate, SlotValues, RemixManifest, RemixSources, ThemeSlot, CharacterSlot, TrackSlot, ParamsSlot } from './game/kit/slots.js';
+import { E as EndlessRunner } from './runner-CQcLL7By.js';
+import { P as PenaltyShootout } from './shootout-BJZeX6FG.js';
+import { G as GameTheme } from './game-theme-Dg-ict5A.js';
+import { G as GameUi$1 } from './ui-hi7S2YcH.js';
+import { AI_CAPABILITY, BOX_CAPACITY, CHEMISTRY_GROUPS, CHEMISTRY_PROMPT, CHEMISTRY_SCHEMA, CHEMISTRY_SCHEMA_NAME, CHEMISTRY_TEMPLATE, ChemistryAi, ChemistryRequest, EVENT, EVENT_A, EVENT_B, EVENT_C_HIGH, EVENT_C_LOW, EVENT_KIND, EVENT_PLAYER, EVENT_WORDS, FIELD, FRAME_MAGIC, FRAME_VERSION, FrontierCommands, FrontierLink, FrontierMirror, FrontierPlanet, FrontierPlanetOptions, FrontierSession, HEADER_BYTES, HEALTH_FIELDS, HERD, HERD_FIELDS, HERD_HEALTH, INVENTION_SCHEMA, INVENT_PROMPT, INVENT_SCHEMA, INVENT_TEMPLATE, InventionAi, InventionRequest, KINDS, LANES, LAYER, MACHINE_FLAG, MAX_ACTIVATION, MAX_BEHAVIOURS, MAX_CHEMISTRY_NAME, MAX_COUNT, MAX_DENSITY, MAX_ENTHALPY, MAX_GROUPS, MAX_GROUP_CHARS, MAX_HARDNESS, MAX_HEAT_CAPACITY, MAX_INGREDIENTS, MAX_KELVIN, MAX_KNOWN_CHARS, MAX_LATENT, MAX_MATERIAL_CHARS, MAX_NAME_CHARS, MAX_PARAM, MAX_QUANTITY, MAX_RATE_MILLI, MAX_STEPS, MAX_STEP_VALUE, MAX_SURVEYED, MAX_TERMS, MIRROR_EVENTS, PLOT, PLOT_FIELDS, PLOT_HEALTH, PROCESSES, REACTOR, REACTOR_FIELDS, REACTOR_SLOTS, REGION_METRES, ReplayFrontierLink, SLOT_FIELDS, TickFrontierLink, VERBS, chemistryRequest, frontierAiSection, frontierAiToml, frontierChemistryAiSection, inventionRequest, itemFromCode, joinFrontierPlanet, requestChemistry, requestInvention } from './game/kit/frontier.js';
+import { A as ACTION, a as ACTION_BASE, b as AI_RUN_BYTES, c as AI_RUN_PREFIX, C as CHANNEL, d as COMPARE, e as CommandWriter, F as FRONTIER_CHANNEL_SLOT, f as FrontierCommand, I as INVENTION_FLAG, M as MAX_COMMAND_BYTES, N as NO_INVENTION, g as NO_ITEM$1, P as PATHOGEN, h as PROCESS, R as RUN_ID_BYTES, i as RegionRef, T as TRAIT, j as actionOf, k as encodeCommand, l as inventionItem, m as isInvention, n as materialItem, r as regionFromBigInt, o as regionKey, p as runIdFromAiRun, q as runIdFromHex } from './protocol-C8qbpUbT.js';
+import { C as CHEMISTRY_AI_CAPABILITY, a as CHEMISTRY_PROMPT$1, b as CHEMISTRY_SCHEMA$1, c as CHEMISTRY_TEMPLATE$1, d as ChemistryAi$1, M as MAX_FORMULA, e as MAX_KNOWN_CHARS$1, f as MAX_NAME, g as MAX_SPECIES, h as MAX_TERMS$1, P as PROPOSAL_SCHEMA, i as Proposal, j as ProposedMaterial, k as ProposedTerm, R as ReactionIdea, l as chemistryAiSection, m as chemistryAiToml, n as knownMaterials, p as proposalText, o as proposeReaction, r as reactionRequest, q as PointerLockTarget, s as PointerLockDocument, t as CameraProjection, T as Terrain } from './terrain-BMxEc6Oc.js';
+import { ACTION as ACTION$1, AI_CAPABILITY as AI_CAPABILITY$1, BLESSED, BOX_CAPACITY as BOX_CAPACITY$1, ByteWriter, CHRONICLE_MAX_UNITS, CHRONICLE_PROMPT, CHRONICLE_TEMPLATE, CONSTITUTION_PROMPT, CONSTITUTION_SCHEMA, CONSTITUTION_SCHEMA_NAME, CONSTITUTION_TEMPLATE, CURSED, ChronicleRequest, Clause, Constitution, ConstitutionRequest, DECREE_REFUSALS, DECREE_REFUSAL_BASE, DEFAULT_NATURE, DESTINY, DISASTER, Decree, EDIT_RING, ENVELOPE, Edit, Effect, EraReply, FACT_KINDS, FACT_RING, FACT_SLOTS, FIELD as FIELD$1, FORECAST_FAILED, FRAME, Fact, FaithRecord, Filter, ForecastReply, ForecastYear, Found, GENESIS_ACTIVE_WORDS, GENESIS_CHANNEL_SLOT, GENESIS_EXPORT_NAMES, GENESIS_INDICATOR_WORDS, GENESIS_OPEN_WORDS, GENESIS_REFUSED, GENESIS_SETTLEMENT_WORDS, GIFTED, GOVERNMENT, GenesisAi, GenesisCommands, GenesisEngine, GenesisExportName, GenesisExports, GenesisLink, GenesisMirror, GenesisNature, GenesisSession, GenesisState, GenesisWorld, GenesisWorldOptions, HUMAN, LAT_BANDS_MAX, LocalGenesis, LocalIndicators, LocalStart, MAX_DECREE_BYTES, MAX_FACT_CHARS, MAX_FAITHS, MAX_NAME_CHARS as MAX_NAME_CHARS$1, MAX_SETTLEMENTS, MAX_WORLD_CHARS, MONTHS_PER_YEAR, NONE, NO_FAITH, NameRefusal, Nature, OP, Office, PROPERTY, PersonRecord, Power, Predicate, Q16, REFUSED_DRAFT, REFUSED_FULL, REFUSED_MALFORMED, REFUSED_SEAT, RIGHT, RIGHTS_ALL, RUN_ID_BYTES as RUN_ID_BYTES$1, ReplayGenesisLink, Review, Rule, SELECTION, SINK, START_MONTH, Species, TERRAIN, TIER, TRIGGER, Target, TickGenesisLink, applyNature, bindGenesisEngine, chronicleRequest, constitutionRequest, encodeDecree, encodeReviewedLaw, factsText, finalize, genesisAiSection, genesisAiToml, joinGenesisWorld, mix, nameOf, percentQ16, ratioQ16, requestChronicle, requestConstitution, screenName, writeConstitution, writeNature, yearOf } from './game/kit/genesis.js';
+import { b as CompiledThing, s as ThingEffect, t as ThingEffectKind, V as Vec3$2, D as ThingShapeKind, r as ThingCombine, z as ThingMirror, A as ThingPart, B as ThingShape, H as WorldDoc, P as PhoneCost, N as Point2, R as Road, K as WorldPlacement, G as GroundStroke, l as ScatterStroke, F as WeatherPreset, O as WorldSky } from './types-D_f6UUxM.js';
+import { S as SoundId } from './audio-m0w8cnxq.js';
+import { S as SceneCatalogue } from './catalogue-DzrTXP3v.js';
+import { W as WorldWeight } from './weight-CPGjsgjV.js';
+import { w as UiBinding, q as MusicBed, j as CrowdDoc, c as BindState, A as AdaptiveMusic, g as CheerMeter, h as Conductor, x as VotePoll } from './crowd-DdHFbqKK.js';
+import { b as StudioOutgoing, a as StudioMessage } from './studio-CowqWqez.js';
+import { E as EngineRuntime, c as EngineExports } from './runtime-DyuBMkKM.js';
+
+type KitErrorCode = "invalid_declaration" | "one_way_money" | "odds_required" | "odds_mismatch" | "catalogue_mismatch" | "minor_restricted" | "spend_limited" | "consent_denied" | "newer_save" | "invalid_save" | "illegal_move" | "not_your_turn" | "seam_unavailable" | "capacity_exceeded";
+declare class KitError extends Error {
+    readonly code: KitErrorCode;
+    constructor(code: KitErrorCode, message: string);
+}
+
+declare const achievementSlotBrand: unique symbol;
+type AchievementSlot = number & {
+    readonly [achievementSlotBrand]: true;
+};
+declare const NO_ACHIEVEMENT = -1;
+interface AchievementDecl<Id extends string = string> {
+    readonly id: Id;
+    readonly target: number;
+}
+declare class Achievements<Id extends string = string> {
+    readonly decls: readonly AchievementDecl<Id>[];
+    private readonly port;
+    private readonly keys;
+    private readonly slots;
+    private readonly targets;
+    private readonly progressValues;
+    private readonly pending;
+    private readonly unlockedFlags;
+    private readonly queue;
+    private queueHead;
+    private queueCount;
+    constructor(decls: readonly AchievementDecl<Id>[], port: CtxAchievements, keys: KeySource);
+    slot(id: Id): AchievementSlot;
+    record(slot: AchievementSlot, increment?: number): void;
+    progress(slot: AchievementSlot): number;
+    unlocked(slot: AchievementSlot): boolean;
+    pollUnlocked(): AchievementSlot | typeof NO_ACHIEVEMENT;
+    sync(): Promise<void>;
+    flush(): Promise<number>;
+    private apply;
+}
+
+type EconomyViolationCode = "identifier" | "duplicate_id" | "currency_class" | "unknown_reference" | "class_mismatch" | "quantity" | "price" | "one_way_money" | "odds_missing" | "odds_total" | "odds_outcome" | "real_money_name" | "in_world_context";
+interface EconomyViolation {
+    readonly code: EconomyViolationCode;
+    readonly subject: string;
+    readonly message: string;
+}
+declare const ECONOMY_IDENTIFIER: RegExp;
+declare function auditEconomy(decl: EconomyDecl, context?: InWorldContext | null): EconomyViolation[];
+
+interface ManifestCurrency {
+    readonly id: string;
+    readonly name: string;
+    readonly class: "soft" | "premium";
+    readonly inWorld: boolean;
+}
+interface ManifestItem {
+    readonly id: string;
+    readonly name: string;
+    readonly currency: string | null;
+    readonly price: number | null;
+    readonly random: boolean;
+}
+interface ManifestOdds {
+    readonly item: string;
+    readonly outcomes: readonly {
+        readonly value: string;
+        readonly partsPerMillion: number;
+    }[];
+}
+type ManifestGrantKind = "item" | "currency" | "unlock" | "effect";
+interface ManifestGrant {
+    readonly kind: ManifestGrantKind;
+    readonly id: string;
+    readonly quantity: number;
+}
+interface ManifestOfferOutcome {
+    readonly label: string;
+    readonly partsPerMillion: number;
+    readonly grants: readonly ManifestGrant[];
+}
+interface ManifestOffer {
+    readonly id: string;
+    readonly name: string;
+    readonly priceCimples: number;
+    readonly grants: readonly ManifestGrant[];
+    readonly odds: readonly ManifestOfferOutcome[];
+}
+interface ManifestRule {
+    readonly id: string;
+    readonly kind: "faucet" | "sink";
+    readonly currency: string | null;
+    readonly item: string | null;
+    readonly maxQuantity: number;
+}
+interface ManifestEconomy {
+    readonly currencies: readonly ManifestCurrency[];
+    readonly items: readonly ManifestItem[];
+    readonly odds: readonly ManifestOdds[];
+    readonly offers: readonly ManifestOffer[];
+    readonly rules: readonly ManifestRule[];
+}
+declare function economyManifest(economy: Economy): ManifestEconomy;
+declare function economyToml(manifest: ManifestEconomy): string;
+
+interface PremiumStorePorts {
+    readonly wallet: Pick<CtxWallet, "offers" | "spend" | "allowance">;
+    readonly keys: KeySource;
+}
+interface PresentedOffer {
+    readonly offer: CimplesOffer;
+    readonly host: WalletOffer;
+}
+declare function oddsMatch(declared: DisclosedOdds, host: WalletOffer["odds"]): boolean;
+declare function offerMatches(offer: CimplesOffer, host: WalletOffer): boolean;
+declare function remainingCimples(allowance: SpendAllowance): number;
+declare class PremiumStore {
+    private readonly economy;
+    private readonly ports;
+    private readonly verified;
+    constructor(economy: Economy, ports: PremiumStorePorts);
+    catalogue(): Promise<readonly PresentedOffer[]>;
+    allowance(): Promise<SpendAllowance>;
+    buy(offerId: string, quantity?: number): Promise<SpendResult>;
+}
+
+interface DropOutcome {
+    readonly faucet: Faucet;
+    readonly quantity: number;
+    readonly weight: number;
+}
+declare class DropTable {
+    readonly outcomes: readonly DropOutcome[];
+    private readonly cumulative;
+    private readonly total;
+    constructor(outcomes: readonly DropOutcome[]);
+    roll(random: SeededRandom): number;
+    probability(index: number): number;
+}
+
+declare const REPLAY_RATES: Readonly<Record<ReplayClass, {
+    readonly simulationHz: number;
+    readonly physicsHz: number;
+}>>;
+interface ReplayDeclaration {
+    readonly rules: ReplayRules;
+    readonly class: ReplayClass;
+    readonly score: ReplayScoreRule;
+}
+interface LocalReplay {
+    readonly score: number | null;
+    readonly digest: string;
+}
+declare class ReplayRecorder {
+    readonly declaration: ReplayDeclaration;
+    private readonly inputs;
+    private ticksValue;
+    private readonly external;
+    constructor(declaration: ReplayDeclaration);
+    get ticks(): number;
+    get full(): boolean;
+    record(axisX: number, axisZ: number, buttons: number): boolean;
+    reset(): void;
+    recordExternal(runId: string, outputDigest: string, bytes: Uint8Array): boolean;
+    replay(): LocalReplay;
+    recording(): ReplayRecording;
+}
+declare function replayInputs(inputs: Uint8Array, ticks: number, declaration: ReplayDeclaration): LocalReplay;
+
+type CounterOpener = (request: CtxRequest<"counter.open">) => Promise<CounterApi>;
+interface LeaderboardOptions {
+    readonly name: string;
+    readonly scope: DataScope;
+    readonly mode?: RankMode;
+    readonly direction?: SortDirection;
+}
+declare const FIRST_RANK = 1;
+declare class Leaderboard {
+    readonly counter: CounterApi;
+    readonly mode: RankMode;
+    readonly direction: SortDirection;
+    private constructor();
+    static open(open: CounterOpener, options: LeaderboardOptions): Promise<Leaderboard>;
+    submit(member: string, score: number): Promise<RankedEntry>;
+    top(limit: number): Promise<readonly RankedEntry[]>;
+    rankOf(member: string): Promise<RankedEntry | null>;
+    around(member: string, radius: number): Promise<readonly RankedEntry[]>;
+}
+declare class RankedScores {
+    private readonly port;
+    private readonly keys;
+    constructor(port: CtxLeaderboards, keys: KeySource);
+    submit(leaderboardId: string, score: number, replay: ReplayRecorder): Promise<ScoreReceipt>;
+    page(leaderboardId: string, scope: LeaderboardScope, window: LeaderboardWindow, limit: number): Promise<LeaderboardPage>;
+    friends(leaderboardId: string, window: LeaderboardWindow, limit: number): Promise<LeaderboardPage>;
+}
+type ScoreDirection = "higher" | "lower";
+declare function beats(score: number, target: number, direction: ScoreDirection): boolean;
+type ChallengePort = Pick<CtxSocial, "friends" | "challenge" | "post">;
+declare class FriendChallenges {
+    private readonly social;
+    constructor(social: ChallengePort);
+    friends(limit: number): Promise<readonly Persona[]>;
+    send(recipients: readonly ParticipantId[], score: number, roomId?: string | null): Promise<ChallengeResult>;
+    postResult(score: number): Promise<SocialPostResult>;
+}
+
+declare class CtxTurnRoom implements TurnRoomPort {
+    private readonly room;
+    private readonly keys;
+    readonly seat: number;
+    readonly seats: number;
+    private seedValue;
+    private match;
+    private constructor();
+    static open(room: RoomApi, keys: KeySource): Promise<CtxTurnRoom>;
+    get seed(): number;
+    submit(turn: number, move: number): Promise<void>;
+    onMove(listener: MoveListener): Unsubscribe;
+    onReset(listener: ResetListener): Unsubscribe;
+    history(): Promise<TurnHistory>;
+}
+
+declare const REPLAY_FORMAT_VERSION = 1;
+interface ReplayManifest {
+    readonly version: number;
+    readonly interactive_id: string;
+    readonly revision: string;
+    readonly tick_hz: number;
+    readonly start_tick: number;
+    readonly ticks: number;
+    readonly input_stride: number;
+    readonly sections: readonly number[];
+    readonly play_from_here: boolean;
+    readonly state_digest: string;
+    readonly final_digest: string;
+}
+interface ReplayClip {
+    readonly manifest: ReplayManifest;
+    readonly state: Uint8Array;
+    readonly inputs: Uint8Array;
+}
+interface ReplaySimulation {
+    readonly states: readonly RollbackState[];
+    step(tick: number, input: Uint8Array): void;
+}
+declare function stateDigest(states: readonly RollbackState[]): string;
+declare function encodeReplay(clip: ReplayClip): Uint8Array;
+declare function decodeReplay(bytes: Uint8Array): ReplayClip;
+interface ReplayRecorderOptions {
+    readonly window_ticks: number;
+    readonly keyframe_every: number;
+    readonly input_stride: number;
+    readonly tick_hz: number;
+    readonly interactive_id: string;
+    readonly revision: string;
+    readonly play_from_here: boolean;
+}
+declare class ReplayClipRecorder {
+    private readonly options;
+    private readonly layout;
+    private readonly keyframes;
+    private readonly keyTicks;
+    private slots;
+    private readonly inputs;
+    private readonly inputTicks;
+    private last;
+    private first;
+    breaks: number;
+    constructor(sim: Pick<ReplaySimulation, "states">, options: ReplayRecorderOptions);
+    private reset;
+    record(tick: number, input: Uint8Array): void;
+    get recordedTicks(): number;
+    private keyframeFor;
+    keep(ticks: number): ReplayClip | null;
+}
+interface ReplayRun {
+    readonly digest: string;
+    readonly matches: boolean;
+    readonly next_tick: number;
+}
+declare function simulateReplay(clip: ReplayClip, sim: ReplaySimulation): ReplayRun;
+declare function playFromReplay(clip: ReplayClip, sim: ReplaySimulation): ReplayRun;
+
+interface AiWatch {
+    watch(run: AiRun, listener: (event: AiEvent) => void): () => void;
+}
+type AiApply = (result: AiResult) => void;
+declare class AiInbox {
+    private readonly pending;
+    private readonly stops;
+    private readonly ai;
+    private readonly recorder;
+    constructor(ai: AiWatch, recorder?: ReplayRecorder | null);
+    track(run: AiRun, onDelta?: ((text: string) => void) | null): void;
+    get waiting(): number;
+    applyAtStep(apply: AiApply): number;
+    dispose(): void;
+}
+
+declare const SNAPSHOT_CHANNEL = "kit.snapshot";
+interface PlanarSnapshotOptions {
+    readonly entities: number;
+    readonly extent: number;
+    readonly bits?: number;
+    readonly history?: number;
+}
+declare class PlanarSnapshotSync {
+    readonly entities: number;
+    readonly type: MessageType;
+    private readonly channel;
+    private readonly writer;
+    private readonly reader;
+    private readonly buffer;
+    private readonly fields;
+    private readonly tickField;
+    private readonly position;
+    private readonly rotation;
+    private readonly sampled;
+    private readonly sampledRotation;
+    private latestTick;
+    constructor(net: GameNet, options: PlanarSnapshotOptions);
+    get latest(): number;
+    publish(tick: number, xz: Float32Array): void;
+    receive(): number;
+    sample(tick: number, out: Float32Array): boolean;
+}
+
+type AvatarRig = "humanoid" | "head" | "sprite";
+type AvatarRole = "player" | "friend";
+interface AvatarCharacter {
+    readonly participant: ParticipantId;
+    readonly displayName: string;
+    readonly role: AvatarRole;
+    readonly model: AssetSource;
+    readonly portrait: MediaRef | null;
+}
+interface AvatarRosterPorts {
+    readonly identity: Pick<CtxIdentity, "current">;
+    readonly social: Pick<CtxSocial, "friends" | "avatars">;
+}
+interface AvatarRosterOptions {
+    readonly rig: AvatarRig;
+    readonly maxFriends: number;
+    readonly models: Readonly<Record<AvatarRig, AssetSource>>;
+}
+declare class AvatarRoster {
+    readonly player: AvatarCharacter | null;
+    readonly friends: readonly AvatarCharacter[];
+    private constructor();
+    static load(ports: AvatarRosterPorts, options: AvatarRosterOptions): Promise<AvatarRoster>;
+    static share(social: Pick<CtxSocial, "avatar_consent">, share: boolean): Promise<AvatarConsent>;
+    friend(seed: number): AvatarCharacter | null;
+}
+declare class AvatarModels {
+    private readonly graphics;
+    private readonly models;
+    private readonly portraits;
+    constructor(graphics: Graphics);
+    spawn(entity: Entity, character: AvatarCharacter): Promise<NodeId>;
+    portrait(character: AvatarCharacter): Promise<TextureId> | null;
+}
+
+interface FaceIdentitySource {
+    captureIdentity(): Promise<CapturedIdentity>;
+}
+interface FaceCapture {
+    readonly identity: Uint8Array;
+    readonly params: IdentityParams;
+}
+declare function captureFace(face: FaceIdentitySource): Promise<FaceCapture>;
+
+type CaptureSource = "camera" | "library";
+type CaptureSubject = "self" | "other";
+interface CaptureContext {
+    readonly ageRange: DeclaredAgeRange;
+    readonly consented: boolean;
+    readonly subject: CaptureSubject;
+    readonly source: CaptureSource;
+    readonly faces: number;
+    readonly yaw: number;
+    readonly pitch: number;
+    readonly faceWidth: number;
+}
+type CaptureRefusal = "consent_required" | "age_restricted" | "age_undeclared" | "self_only" | "live_camera_only" | "one_face_only" | "face_turned" | "face_too_small";
+interface CapturePolicy {
+    readonly allowed: boolean;
+    readonly refusal: CaptureRefusal | null;
+    readonly minStylise: number;
+    readonly residual: boolean;
+    readonly shareable: boolean;
+}
+declare function identityCapturePolicy(context: CaptureContext): CapturePolicy;
+
+interface IdentityFromCapture {
+    readonly policy: CapturePolicy;
+    readonly fit: IdentityFit | null;
+}
+declare function identityFromCapture(base: IdentityBase | IdentityFitter, capture: IdentityCapture, context: CaptureContext, options?: IdentityFitOptions): IdentityFromCapture;
+
+interface IdentityBuildOptions {
+    readonly lod?: number;
+    readonly name?: string;
+}
+declare function buildIdentityCharacter(base: IdentityBase, params: IdentityParams, options?: IdentityBuildOptions): Uint8Array;
+
+declare const LAUNCH_RIG = "kit-humanoid";
+declare const LAUNCH_ITEMS: {
+    readonly baseCharacter: "cimplify/base-character";
+    readonly animations: "cimplify/humanoid-animations";
+    readonly identity: "cimplify/identity-base";
+    readonly materials: "cimplify/starter-materials";
+};
+declare const LAUNCH_FILES: {
+    readonly baseCharacter: "base-character.glb";
+    readonly animations: "animations.glb";
+    readonly clips: "clips.json";
+    readonly identity: "identity.cidb";
+    readonly materials: "materials.json";
+};
+declare const LAUNCH_CLIPS: {
+    readonly locomotion: readonly ["walk", "walk_back", "walk_formal", "walk_carry", "jog", "jog_back", "run", "crouch_walk", "crouch_back", "swim", "jump", "fall", "land", "roll", "slide", "climb_up"];
+    readonly strafe: readonly ["walk", "strafe_forward_left", "strafe_left", "strafe_back_left", "walk_back", "strafe_back_right", "strafe_right", "strafe_forward_right"];
+    readonly turn: readonly ["turn_left_45", "turn_left_90", "turn_left_180", "turn_right_45", "turn_right_90", "turn_right_180"];
+    readonly idle: readonly ["idle", "idle_talk", "idle_fold_arms", "idle_phone", "crouch_idle", "swim_idle"];
+    readonly emote: readonly ["wave", "clap", "cheer", "bow", "point", "shrug", "salute", "nod", "look_around", "fist_pump", "dance", "yes", "no"];
+    readonly sports: readonly ["kick", "header", "throw_in", "throw", "punch_jab", "punch_cross", "keeper_ready", "dive_left", "dive_right", "keeper_smother", "keeper_hold"];
+    readonly driving: readonly ["drive", "steer_left", "steer_right", "honk"];
+    readonly sitting: readonly ["sit_down", "sit", "sit_talk", "sit_cheer", "sit_clap", "stand_up", "get_up"];
+    readonly reaction: readonly ["hit_chest", "hit_head", "stumble", "stagger", "fall_down"];
+};
+declare const LAUNCH_HAIR_STYLES: readonly ["parted", "buzzed", "long", "buns", "buzzed_soft", "none"];
+
+interface Exemplar {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8Array;
+}
+interface QuiltOptions {
+    readonly size: number;
+    readonly block: number;
+    readonly overlap: number;
+    readonly candidates: number;
+    readonly seed: number;
+}
+declare function quiltTexture(exemplar: Exemplar, options: QuiltOptions): Uint8Array;
+
+type Vec3 = readonly [number, number, number];
+type PropShape = {
+    readonly box: Vec3;
+    readonly at: Vec3;
+} | {
+    readonly frustum: readonly [number, number, number, number];
+    readonly at?: readonly [number, number];
+    readonly caps?: boolean;
+    readonly segments?: number;
+} | {
+    readonly sphere: number;
+    readonly at: Vec3;
+    readonly segments?: number;
+} | {
+    readonly rod: readonly [Vec3, Vec3];
+    readonly radius: number;
+    readonly segments?: number;
+};
+interface PropPart {
+    readonly material: string;
+    readonly tint?: readonly [number, number, number];
+    readonly shapes: readonly PropShape[];
+}
+interface PropRecipe {
+    readonly name: string;
+    readonly parts: readonly PropPart[];
+}
+type PropLevel = "close" | "middle" | "far";
+declare const PROP_LEVELS: readonly PropLevel[];
+declare function propBounds(recipe: PropRecipe): {
+    readonly min: Vec3;
+    readonly max: Vec3;
+};
+declare function propTriangles(recipe: PropRecipe, level?: PropLevel): number;
+declare function buildPropGlb(recipe: PropRecipe, level?: PropLevel): Uint8Array;
+
+type SoundRoute = "auto" | "kernels" | "js";
+interface SoundOptions {
+    readonly route?: SoundRoute;
+    readonly runner?: KernelRunner;
+}
+interface SoundMode {
+    readonly frequency: number;
+    readonly decay: number;
+    readonly gain: number;
+}
+type SoundRecipe = {
+    readonly kind: "impact";
+    readonly seconds: number;
+    readonly seed: number;
+    readonly modes: readonly SoundMode[];
+    readonly noise: number;
+    readonly brightness: number;
+    readonly contact: number;
+} | {
+    readonly kind: "engine";
+    readonly seconds: number;
+    readonly seed: number;
+    readonly rpm: number;
+    readonly cylinders: number;
+    readonly harmonics: number;
+    readonly rolloff: number;
+    readonly roughness: number;
+} | {
+    readonly kind: "rain";
+    readonly seconds: number;
+    readonly seed: number;
+    readonly drops: number;
+    readonly radius: readonly [number, number];
+    readonly bed: number;
+} | {
+    readonly kind: "wind";
+    readonly seconds: number;
+    readonly seed: number;
+    readonly strength: number;
+    readonly gust: number;
+    readonly pitch: number;
+};
+declare function synthesizeSound(recipe: SoundRecipe, options?: SoundOptions): Float32Array;
+declare function encodeWav(samples: Float32Array, rate?: number): Uint8Array;
+
+type RecipeRgb = readonly [number, number, number];
+type TexturePattern = {
+    readonly kind: "fbm";
+    readonly period: number;
+    readonly octaves: number;
+    readonly gain: number;
+} | {
+    readonly kind: "ridged";
+    readonly period: number;
+    readonly octaves: number;
+    readonly gain: number;
+} | {
+    readonly kind: "cells";
+    readonly period: number;
+    readonly jitter: number;
+} | {
+    readonly kind: "bricks";
+    readonly rows: number;
+    readonly columns: number;
+    readonly mortar: number;
+} | {
+    readonly kind: "tiles";
+    readonly count: number;
+    readonly grout: number;
+} | {
+    readonly kind: "weave";
+    readonly count: number;
+} | {
+    readonly kind: "rings";
+    readonly frequency: number;
+    readonly distortion: number;
+};
+interface TextureRecipe {
+    readonly size: number;
+    readonly seed: number;
+    readonly pattern: TexturePattern;
+    readonly detail: number;
+    readonly dark: RecipeRgb;
+    readonly light: RecipeRgb;
+    readonly variation: number;
+    readonly roughness: readonly [number, number];
+    readonly normal: number;
+}
+interface SynthesizedTexture {
+    readonly size: number;
+    readonly albedo: Uint8Array;
+    readonly normal: Uint8Array;
+}
+declare function synthesizeTexture(recipe: TextureRecipe): SynthesizedTexture;
+
+declare const TEXTURE_RECIPES: Readonly<Record<string, TextureRecipe>>;
+declare const PROP_RECIPES: readonly PropRecipe[];
+declare const SOUND_RECIPES: Readonly<Record<string, SoundRecipe>>;
+
+declare const CATALOGUE_PROP_RECIPES: readonly PropRecipe[];
+declare const CATALOGUE_RECIPE_SOURCES: {
+    readonly [kind: string]: string;
+};
+
+type ArkitName = (typeof FACE_LAYOUT.arkit)[number];
+declare const FaceExpression: {
+    readonly Smile: number;
+    readonly JawOpen: number;
+    readonly BlinkLeft: number;
+    readonly BlinkRight: number;
+    readonly BrowRaise: number;
+    readonly Pucker: number;
+};
+type FaceExpressionId = number;
+declare const EXPRESSION_COUNT: 6;
+declare const HeadPose: {
+    readonly Yaw: number;
+    readonly Pitch: number;
+    readonly Roll: number;
+    readonly X: number;
+    readonly Y: number;
+    readonly Z: number;
+};
+type HeadPoseAxis = number;
+declare const POSE_COUNT: 6;
+declare const ARKIT_COUNT: 52;
+declare function arkitWeight(name: ArkitName): number;
+declare const FaceLandmark: {
+    readonly NoseTip: 0;
+    readonly Forehead: 1;
+    readonly Chin: 2;
+    readonly LeftEye: 3;
+    readonly RightEye: 4;
+    readonly Mouth: 5;
+};
+type FaceLandmarkId = (typeof FaceLandmark)[keyof typeof FaceLandmark];
+declare const LANDMARK_COUNT: number;
+type FaceCameraPort = Pick<CtxCamera, "request" | "release" | "track_face" | "view"> & Partial<Pick<CtxCamera, "capture_identity">>;
+interface FaceSessionOptions {
+    readonly facing?: CameraFacing;
+    readonly recording?: boolean;
+    readonly smoothingSeconds?: number;
+}
+declare const METRIC_WIDTH = 0;
+declare class FaceSession {
+    readonly expressions: Float32Array<ArrayBuffer>;
+    readonly pose: Float32Array<ArrayBuffer>;
+    readonly arkit: Float32Array<ArrayBuffer>;
+    readonly landmarks: Float32Array<ArrayBuffer>;
+    readonly metrics: Float64Array<ArrayBuffer>;
+    private readonly camera;
+    private readonly grant;
+    private readonly tracker;
+    private readonly smoothing;
+    private readonly views;
+    private trackingValue;
+    private primed;
+    private closed;
+    private constructor();
+    static start(camera: FaceCameraPort, options?: FaceSessionOptions): Promise<FaceSession>;
+    get tracking(): boolean;
+    get measured(): boolean;
+    view(placement: CameraViewPlacement): Promise<CameraView>;
+    update(time: FrameTime): boolean;
+    advance(seconds: number): boolean;
+    private track;
+    private place;
+    expression(id: FaceExpressionId): number;
+    headPose(axis: HeadPoseAxis): number;
+    weight(index: number): number;
+    faceWidth(): number;
+    captureIdentity(): Promise<CapturedIdentity>;
+    colours(): Promise<FaceColours | null>;
+    close(): Promise<void>;
+}
+interface FaceAnchor {
+    readonly landmark: FaceLandmarkId;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly scale: number;
+}
+declare const ANCHOR_X = 0;
+declare const ANCHOR_Y = 1;
+declare const ANCHOR_SCALE = 2;
+declare const ANCHOR_ROLL = 3;
+declare const ANCHOR_STRIDE = 4;
+declare class FaceAnchors {
+    readonly anchors: readonly FaceAnchor[];
+    readonly out: Float32Array;
+    constructor(anchors: readonly FaceAnchor[]);
+    update(face: FaceSession): void;
+}
+
+declare class IdentityCaptureError extends Error {
+    readonly code: IdentityCaptureCode;
+    constructor(code: IdentityCaptureCode);
+}
+
+declare const DEFAULT_CLIP_MS = 15000;
+interface ClipPorts {
+    readonly media: Pick<CtxMedia, "record_clip"> & Partial<Pick<CtxMedia, "keep_clip">>;
+    readonly share: HostCall<"share.open">;
+    readonly social: Pick<CtxSocial, "post">;
+}
+declare class ClipRecorder {
+    private readonly ports;
+    private recording;
+    private lastClip;
+    constructor(ports: ClipPorts);
+    get active(): boolean;
+    get clip(): MediaRef | null;
+    start(surface: GraphicsSurface, maxMs?: number): Promise<void>;
+    stop(): Promise<MediaRef>;
+    /** Saves what the host already captured, for a goal or a win: no start needed, the host always keeps the last few seconds. */
+    keepLast(ms?: number): Promise<MediaRef>;
+    cancel(): void;
+    share(audience?: ShareAudience | null): Promise<ShareResult>;
+    post(score?: number | null): Promise<SocialPostResult>;
+    private requireClip;
+}
+
+interface ManifestEconomyInput {
+    readonly currencies: readonly {
+        readonly id: string;
+        readonly name?: string;
+        readonly class: string;
+        readonly inWorld?: boolean;
+    }[];
+    readonly items: readonly {
+        readonly id: string;
+        readonly currency: string | null;
+        readonly random?: boolean;
+    }[];
+    readonly odds: readonly {
+        readonly item: string;
+        readonly outcomes: readonly {
+            readonly value: string;
+            readonly partsPerMillion: number;
+        }[];
+    }[];
+}
+declare function auditManifestEconomy(manifest: ManifestEconomyInput, context?: InWorldContext | null): EconomyViolation[];
+type KitGateName = "currency classes" | "odds disclosure" | "one-way money" | "economy declaration";
+interface KitGateResult {
+    readonly name: KitGateName;
+    readonly passed: boolean;
+    readonly detail: string;
+}
+declare function judgeEconomy(violations: readonly EconomyViolation[]): KitGateResult[];
+declare function kitPublicationGates(economy: EconomyDecl | null, manifest?: ManifestEconomyInput | null, context?: InWorldContext | null): KitGateResult[];
+
+declare const BOX_X = 0;
+declare const BOX_Y = 1;
+declare const BOX_Z = 2;
+declare const BOX_ROTATION = 3;
+declare const BOX_SX = 7;
+declare const BOX_SY = 8;
+declare const BOX_SZ = 9;
+declare class BoxBatch {
+    readonly batch: InstancedBatch;
+    readonly box: Float32Array<ArrayBuffer>;
+    private readonly game;
+    private count;
+    constructor(game: Game, capacity: number, roughness?: number);
+    begin(): void;
+    add(rgb: number): void;
+    sizes(sx: number, sy: number, sz: number): this;
+    addAt(source: Float64Array | Float32Array, at: number, rgb: number, lift?: number): void;
+    standAt(source: Float64Array | Float32Array, at: number, rgb: number): void;
+    end(): void;
+}
+declare function addSceneCamera(game: Game, x: number, y: number, z: number, fov: number, pitch: number): Entity;
+
+declare const NO_ITEM = -1;
+declare const DEFAULT_STACK_LIMIT = 99;
+declare const INVENTORY_SNAPSHOT_STRIDE = 2;
+declare class Inventory {
+    readonly items: Int32Array;
+    readonly counts: Int32Array;
+    readonly stackLimit: number;
+    constructor(slots: number, stackLimit?: number);
+    get slots(): number;
+    count(item: number): number;
+    has(item: number, quantity?: number): boolean;
+    room(item: number): number;
+    add(item: number, quantity: number): number;
+    remove(item: number, quantity: number): boolean;
+    clear(): void;
+    saveInto(out: Int32Array): void;
+    restore(source: Int32Array): void;
+}
+
+interface ShopOffer {
+    readonly item: number;
+    readonly quantity: number;
+    readonly price: number;
+    readonly stock?: number;
+}
+declare const ShopResult: {
+    readonly Bought: 0;
+    readonly UnknownOffer: 1;
+    readonly TooPoor: 2;
+    readonly SoldOut: 3;
+    readonly NoRoom: 4;
+};
+type ShopResultCode = (typeof ShopResult)[keyof typeof ShopResult];
+declare const UNLIMITED_STOCK = -1;
+declare class Shop {
+    readonly currency: number;
+    readonly items: Int32Array;
+    readonly quantities: Int32Array;
+    readonly prices: Int32Array;
+    readonly stock: Int32Array;
+    private readonly initialStock;
+    constructor(currency: number, offers: readonly ShopOffer[]);
+    get offers(): number;
+    check(offer: number, inventory: Inventory): ShopResultCode;
+    buy(offer: number, inventory: Inventory): ShopResultCode;
+    restock(): void;
+}
+
+interface ObjectiveDecl {
+    readonly id: string;
+    readonly target: number;
+    readonly after?: string;
+}
+declare const NO_OBJECTIVE = -1;
+declare class Objectives {
+    readonly ids: readonly string[];
+    readonly targets: Float64Array;
+    readonly progress: Float64Array;
+    readonly done: Uint8Array;
+    readonly prerequisite: Int32Array;
+    private readonly completedQueue;
+    private queueHead;
+    private queueCount;
+    private doneCount;
+    constructor(decls: readonly ObjectiveDecl[]);
+    index(id: string): number;
+    get count(): number;
+    get completed(): number;
+    get allDone(): boolean;
+    unlocked(objective: number): boolean;
+    active(objective: number): boolean;
+    record(objective: number, amount?: number): boolean;
+    firstActive(): number;
+    pollCompleted(): number;
+    fractionInto(out: Float64Array, slot: number, objective: number): void;
+    reset(): void;
+}
+
+interface WaveDecl {
+    readonly count: number;
+    readonly interval: number;
+    readonly delay?: number;
+}
+interface WavesOptions {
+    readonly waitForClear?: boolean;
+    readonly endless?: boolean;
+    readonly growth?: number;
+}
+declare const NO_SLOT = -1;
+declare class Waves {
+    readonly state: Float64Array<ArrayBuffer>;
+    private readonly decls;
+    private readonly waitForClear;
+    private readonly endless;
+    private readonly growth;
+    constructor(waves: readonly WaveDecl[], options?: WavesOptions);
+    get wave(): number;
+    get spawned(): number;
+    get resting(): boolean;
+    get finished(): boolean;
+    waveSize(): number;
+    step(time: FrameTime, alive: number): number;
+    reset(): void;
+    private declOffset;
+    private advance;
+}
+declare class SlotPool {
+    readonly alive: Uint8Array;
+    private readonly free;
+    private freeCount;
+    constructor(capacity: number);
+    get capacity(): number;
+    get count(): number;
+    acquire(): number;
+    release(slot: number): boolean;
+    clear(): void;
+}
+
+interface ScoreTimerOptions {
+    readonly seconds?: number;
+    readonly comboWindow?: number;
+    readonly maxCombo?: number;
+    readonly clockSeconds?: number;
+}
+interface ScoreHudNames {
+    readonly score?: string;
+    readonly clock?: string;
+    readonly combo?: string;
+}
+declare const SCORE = 0;
+declare const SCORE_BEST = 1;
+declare const SCORE_COMBO = 2;
+declare const SCORE_COMBO_LEFT = 3;
+declare const SCORE_ELAPSED = 4;
+declare const SCORE_REMAINING = 5;
+declare const SCORE_TIME_UP = 6;
+declare class ScoreTimer {
+    readonly state: Float64Array<ArrayBuffer>;
+    readonly seconds: number;
+    readonly comboWindow: number;
+    readonly maxCombo: number;
+    private readonly labels;
+    constructor(options?: ScoreTimerOptions);
+    get score(): number;
+    get best(): number;
+    get combo(): number;
+    get timeUp(): boolean;
+    step(time: FrameTime): boolean;
+    add(points: number): number;
+    clockText(): string;
+    reset(): void;
+}
+declare class ScoreHud {
+    private readonly ui;
+    private readonly timer;
+    private readonly scoreSlot;
+    private readonly clockSlot;
+    private readonly comboSlot;
+    constructor(ui: GameUi, timer: ScoreTimer, names?: ScoreHudNames);
+    update(): void;
+}
+
+interface ScheduleStop {
+    readonly hour: number;
+    readonly x: number;
+    readonly z: number;
+    readonly activity: number;
+}
+interface NpcSpawn {
+    readonly x: number;
+    readonly z: number;
+    readonly speed: number;
+    readonly stops: readonly ScheduleStop[];
+}
+declare const HOURS_PER_DAY = 24;
+declare const NPC_WALKING = -1;
+declare const NPC_STRIDE = 3;
+declare const DAY_HOUR = 0;
+declare const DAY_INDEX = 1;
+declare class DayClock {
+    readonly state: Float64Array<ArrayBuffer>;
+    readonly secondsPerDay: number;
+    constructor(secondsPerDay: number, startHour?: number);
+    get hour(): number;
+    get day(): number;
+    step(time: FrameTime): boolean;
+}
+declare class NpcSchedules {
+    readonly positions: Float64Array;
+    readonly facing: Float64Array;
+    readonly activities: Int32Array;
+    readonly stopIndex: Int32Array;
+    private readonly speeds;
+    private readonly stops;
+    private readonly stopCounts;
+    private readonly maxStops;
+    private readonly arriveRadius;
+    private npcs;
+    constructor(capacity: number, maxStops: number, arriveRadius?: number);
+    get count(): number;
+    add(spawn: NpcSpawn): number;
+    stopAt(npc: number, clock: DayClock): number;
+    step(clock: DayClock, time: FrameTime): void;
+}
+
+interface CheckpointOptions {
+    readonly radius: number;
+    readonly ordered?: boolean;
+    readonly killY?: number;
+}
+declare const NO_CHECKPOINT = -1;
+declare class Checkpoints {
+    readonly positions: Float64Array;
+    readonly reachedFlags: Uint8Array;
+    readonly spawn: Float64Array<ArrayBuffer>;
+    readonly radius: number;
+    readonly ordered: boolean;
+    readonly killY: number;
+    private used;
+    private reachedCount;
+    private last;
+    constructor(capacity: number, options: CheckpointOptions);
+    get count(): number;
+    get reached(): number;
+    get lastReached(): number;
+    get finished(): boolean;
+    setSpawn(x: number, y: number, z: number): void;
+    add(x: number, y: number, z: number): number;
+    next(): number;
+    touch(source: Vec3Array, offset: number): number;
+    fallen(source: Vec3Array, offset: number): boolean;
+    respawnInto(out: Float64Array, offset?: number): void;
+    reset(): void;
+}
+
+interface ArenaOptions {
+    readonly half: number;
+    readonly wallHeight: number;
+    readonly wallThickness?: number;
+    readonly groundDepth?: number;
+}
+interface DaylightOptions {
+    readonly sun?: number;
+    readonly sky?: number;
+    readonly sunX?: number;
+    readonly sunY?: number;
+    readonly sunZ?: number;
+}
+declare function staticBox(game: Game, x: number, y: number, z: number, hx: number, hy: number, hz: number): Entity;
+declare function walledArena(game: Game, options: ArenaOptions): void;
+declare function daylight(game: Game, options?: DaylightOptions): void;
+
+interface SeekBotOptions {
+    readonly arrive?: number;
+    readonly jumpEvery?: number;
+    readonly jumpHold?: number;
+}
+declare class SeekBot {
+    private readonly arrive;
+    private readonly jumpEvery;
+    private readonly jumpHold;
+    private slotX;
+    private slotY;
+    private slotJump;
+    private jumpHeld;
+    constructor(options?: SeekBotOptions);
+    drive(game: Game, rig: ThirdPersonRig, goal: Float64Array, frame: number): void;
+}
+
+interface SlottedGenre<S extends SlotMap, Scene extends GameScene<Game>> {
+    readonly template: SlotTemplate<S>;
+    readonly base: GenreTemplate<Scene>;
+    build(values: SlotValues<S>): GenreTemplate<Scene>;
+    remix(manifest: RemixManifest, sources?: RemixSources): GenreTemplate<Scene>;
+}
+declare function playable<S extends SlotMap, Scene extends GameScene<Game>>(t: SlotTemplate<S>, build: (values: SlotValues<S>) => GenreTemplate<Scene>): SlottedGenre<S, Scene>;
+
+declare const slottedShootout: SlottedGenre<{
+    readonly theme: ThemeSlot;
+    readonly music: TrackSlot;
+    readonly rules: ParamsSlot<{
+        readonly kicksPerSeries: {
+            readonly type: "int";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly seriesPauseSeconds: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+    }>;
+}, PenaltyShootout>;
+declare const slottedRunner: SlottedGenre<{
+    readonly theme: ThemeSlot;
+    readonly hero: CharacterSlot;
+    readonly music: TrackSlot;
+    readonly rules: ParamsSlot<{
+        readonly startSpeed: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly maxSpeed: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+        readonly jumpVelocity: {
+            readonly type: "number";
+            readonly min: number;
+            readonly max: number;
+        };
+    }>;
+}, EndlessRunner>;
+
+declare const SHOWCASE: {
+    readonly arenaHalf: 16;
+    readonly wallHeight: 1;
+    readonly characters: 6;
+    readonly ring: 7;
+    readonly wander: 2.6;
+    readonly hitRadius: 2.4;
+    readonly hitDamage: 25;
+    readonly maxHealth: 100;
+    readonly bounty: 100;
+    readonly contactRadius: 1.1;
+    readonly contactDamage: 18;
+    readonly regen: 6;
+    readonly scoreSeconds: 0.6;
+};
+declare const SHOWCASE_NAMES: readonly ["Ada", "Kofi", "Zuri", "Tunde", "Amara", "Kwame"];
+declare const SHOWCASE_THEME: GameTheme;
+interface ShowcaseOptions {
+    readonly ui: GameUi$1 | null;
+    readonly font?: number;
+    readonly surface?: TouchViewportSource | null;
+    readonly viewport?: TouchViewport;
+    readonly flush?: boolean;
+}
+declare class GameUiShowcase implements GameScene<Game> {
+    readonly name = "game-ui-showcase";
+    rig: ThirdPersonRig | null;
+    paused: boolean;
+    score: number;
+    downs: number;
+    readonly health: Int32Array<ArrayBuffer>;
+    private readonly closest;
+    readonly positions: Float64Array<ArrayBuffer>;
+    readonly anchors: Float64Array<ArrayBuffer>;
+    private readonly state;
+    private readonly phase;
+    private readonly hurt;
+    private readonly statics;
+    private boxes;
+    private hud;
+    private plates;
+    private readonly options;
+    get playerHealth(): number;
+    constructor(options: ShowcaseOptions);
+    enter(game: Game): void;
+    setPaused(paused: boolean): void;
+    restart(): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(): void;
+    nearestToPlayer(game: Game): number;
+    private strike;
+    private place;
+    private layoutStatics;
+    private draw;
+}
+declare const gameUiShowcaseTemplate: GenreTemplate<GameUiShowcase>;
+
+type showcase_GameUiShowcase = GameUiShowcase;
+declare const showcase_GameUiShowcase: typeof GameUiShowcase;
+declare const showcase_SHOWCASE: typeof SHOWCASE;
+declare const showcase_SHOWCASE_NAMES: typeof SHOWCASE_NAMES;
+declare const showcase_SHOWCASE_THEME: typeof SHOWCASE_THEME;
+type showcase_ShowcaseOptions = ShowcaseOptions;
+declare const showcase_gameUiShowcaseTemplate: typeof gameUiShowcaseTemplate;
+declare namespace showcase {
+  export { showcase_GameUiShowcase as GameUiShowcase, showcase_SHOWCASE as SHOWCASE, showcase_SHOWCASE_NAMES as SHOWCASE_NAMES, showcase_SHOWCASE_THEME as SHOWCASE_THEME, type showcase_ShowcaseOptions as ShowcaseOptions, showcase_gameUiShowcaseTemplate as gameUiShowcaseTemplate };
+}
+
+declare const index$2_ACTION: typeof ACTION;
+declare const index$2_ACTION_BASE: typeof ACTION_BASE;
+declare const index$2_AI_CAPABILITY: typeof AI_CAPABILITY;
+declare const index$2_AI_RUN_BYTES: typeof AI_RUN_BYTES;
+declare const index$2_AI_RUN_PREFIX: typeof AI_RUN_PREFIX;
+declare const index$2_BOX_CAPACITY: typeof BOX_CAPACITY;
+declare const index$2_CHANNEL: typeof CHANNEL;
+declare const index$2_CHEMISTRY_GROUPS: typeof CHEMISTRY_GROUPS;
+declare const index$2_CHEMISTRY_PROMPT: typeof CHEMISTRY_PROMPT;
+declare const index$2_CHEMISTRY_SCHEMA: typeof CHEMISTRY_SCHEMA;
+declare const index$2_CHEMISTRY_SCHEMA_NAME: typeof CHEMISTRY_SCHEMA_NAME;
+declare const index$2_CHEMISTRY_TEMPLATE: typeof CHEMISTRY_TEMPLATE;
+declare const index$2_COMPARE: typeof COMPARE;
+declare const index$2_ChemistryAi: typeof ChemistryAi;
+declare const index$2_ChemistryRequest: typeof ChemistryRequest;
+declare const index$2_CommandWriter: typeof CommandWriter;
+declare const index$2_EVENT: typeof EVENT;
+declare const index$2_EVENT_A: typeof EVENT_A;
+declare const index$2_EVENT_B: typeof EVENT_B;
+declare const index$2_EVENT_C_HIGH: typeof EVENT_C_HIGH;
+declare const index$2_EVENT_C_LOW: typeof EVENT_C_LOW;
+declare const index$2_EVENT_KIND: typeof EVENT_KIND;
+declare const index$2_EVENT_PLAYER: typeof EVENT_PLAYER;
+declare const index$2_EVENT_WORDS: typeof EVENT_WORDS;
+declare const index$2_FIELD: typeof FIELD;
+declare const index$2_FRAME_MAGIC: typeof FRAME_MAGIC;
+declare const index$2_FRAME_VERSION: typeof FRAME_VERSION;
+declare const index$2_FRONTIER_CHANNEL_SLOT: typeof FRONTIER_CHANNEL_SLOT;
+declare const index$2_FrontierCommand: typeof FrontierCommand;
+declare const index$2_FrontierCommands: typeof FrontierCommands;
+declare const index$2_FrontierLink: typeof FrontierLink;
+declare const index$2_FrontierMirror: typeof FrontierMirror;
+declare const index$2_FrontierPlanet: typeof FrontierPlanet;
+declare const index$2_FrontierPlanetOptions: typeof FrontierPlanetOptions;
+declare const index$2_FrontierSession: typeof FrontierSession;
+declare const index$2_HEADER_BYTES: typeof HEADER_BYTES;
+declare const index$2_HEALTH_FIELDS: typeof HEALTH_FIELDS;
+declare const index$2_HERD: typeof HERD;
+declare const index$2_HERD_FIELDS: typeof HERD_FIELDS;
+declare const index$2_HERD_HEALTH: typeof HERD_HEALTH;
+declare const index$2_INVENTION_FLAG: typeof INVENTION_FLAG;
+declare const index$2_INVENTION_SCHEMA: typeof INVENTION_SCHEMA;
+declare const index$2_INVENT_PROMPT: typeof INVENT_PROMPT;
+declare const index$2_INVENT_SCHEMA: typeof INVENT_SCHEMA;
+declare const index$2_INVENT_TEMPLATE: typeof INVENT_TEMPLATE;
+declare const index$2_InventionAi: typeof InventionAi;
+declare const index$2_InventionRequest: typeof InventionRequest;
+declare const index$2_KINDS: typeof KINDS;
+declare const index$2_LANES: typeof LANES;
+declare const index$2_LAYER: typeof LAYER;
+declare const index$2_MACHINE_FLAG: typeof MACHINE_FLAG;
+declare const index$2_MAX_ACTIVATION: typeof MAX_ACTIVATION;
+declare const index$2_MAX_BEHAVIOURS: typeof MAX_BEHAVIOURS;
+declare const index$2_MAX_CHEMISTRY_NAME: typeof MAX_CHEMISTRY_NAME;
+declare const index$2_MAX_COMMAND_BYTES: typeof MAX_COMMAND_BYTES;
+declare const index$2_MAX_COUNT: typeof MAX_COUNT;
+declare const index$2_MAX_DENSITY: typeof MAX_DENSITY;
+declare const index$2_MAX_ENTHALPY: typeof MAX_ENTHALPY;
+declare const index$2_MAX_GROUPS: typeof MAX_GROUPS;
+declare const index$2_MAX_GROUP_CHARS: typeof MAX_GROUP_CHARS;
+declare const index$2_MAX_HARDNESS: typeof MAX_HARDNESS;
+declare const index$2_MAX_HEAT_CAPACITY: typeof MAX_HEAT_CAPACITY;
+declare const index$2_MAX_INGREDIENTS: typeof MAX_INGREDIENTS;
+declare const index$2_MAX_KELVIN: typeof MAX_KELVIN;
+declare const index$2_MAX_KNOWN_CHARS: typeof MAX_KNOWN_CHARS;
+declare const index$2_MAX_LATENT: typeof MAX_LATENT;
+declare const index$2_MAX_MATERIAL_CHARS: typeof MAX_MATERIAL_CHARS;
+declare const index$2_MAX_NAME_CHARS: typeof MAX_NAME_CHARS;
+declare const index$2_MAX_PARAM: typeof MAX_PARAM;
+declare const index$2_MAX_QUANTITY: typeof MAX_QUANTITY;
+declare const index$2_MAX_RATE_MILLI: typeof MAX_RATE_MILLI;
+declare const index$2_MAX_STEPS: typeof MAX_STEPS;
+declare const index$2_MAX_STEP_VALUE: typeof MAX_STEP_VALUE;
+declare const index$2_MAX_SURVEYED: typeof MAX_SURVEYED;
+declare const index$2_MAX_TERMS: typeof MAX_TERMS;
+declare const index$2_MIRROR_EVENTS: typeof MIRROR_EVENTS;
+declare const index$2_NO_INVENTION: typeof NO_INVENTION;
+declare const index$2_PATHOGEN: typeof PATHOGEN;
+declare const index$2_PLOT: typeof PLOT;
+declare const index$2_PLOT_FIELDS: typeof PLOT_FIELDS;
+declare const index$2_PLOT_HEALTH: typeof PLOT_HEALTH;
+declare const index$2_PROCESS: typeof PROCESS;
+declare const index$2_PROCESSES: typeof PROCESSES;
+declare const index$2_REACTOR: typeof REACTOR;
+declare const index$2_REACTOR_FIELDS: typeof REACTOR_FIELDS;
+declare const index$2_REACTOR_SLOTS: typeof REACTOR_SLOTS;
+declare const index$2_REGION_METRES: typeof REGION_METRES;
+declare const index$2_RUN_ID_BYTES: typeof RUN_ID_BYTES;
+declare const index$2_RegionRef: typeof RegionRef;
+declare const index$2_ReplayFrontierLink: typeof ReplayFrontierLink;
+declare const index$2_SLOT_FIELDS: typeof SLOT_FIELDS;
+declare const index$2_TRAIT: typeof TRAIT;
+declare const index$2_TickFrontierLink: typeof TickFrontierLink;
+declare const index$2_VERBS: typeof VERBS;
+declare const index$2_actionOf: typeof actionOf;
+declare const index$2_chemistryRequest: typeof chemistryRequest;
+declare const index$2_encodeCommand: typeof encodeCommand;
+declare const index$2_frontierAiSection: typeof frontierAiSection;
+declare const index$2_frontierAiToml: typeof frontierAiToml;
+declare const index$2_frontierChemistryAiSection: typeof frontierChemistryAiSection;
+declare const index$2_inventionItem: typeof inventionItem;
+declare const index$2_inventionRequest: typeof inventionRequest;
+declare const index$2_isInvention: typeof isInvention;
+declare const index$2_itemFromCode: typeof itemFromCode;
+declare const index$2_joinFrontierPlanet: typeof joinFrontierPlanet;
+declare const index$2_materialItem: typeof materialItem;
+declare const index$2_regionFromBigInt: typeof regionFromBigInt;
+declare const index$2_regionKey: typeof regionKey;
+declare const index$2_requestChemistry: typeof requestChemistry;
+declare const index$2_requestInvention: typeof requestInvention;
+declare const index$2_runIdFromAiRun: typeof runIdFromAiRun;
+declare const index$2_runIdFromHex: typeof runIdFromHex;
+declare namespace index$2 {
+  export { index$2_ACTION as ACTION, index$2_ACTION_BASE as ACTION_BASE, index$2_AI_CAPABILITY as AI_CAPABILITY, index$2_AI_RUN_BYTES as AI_RUN_BYTES, index$2_AI_RUN_PREFIX as AI_RUN_PREFIX, index$2_BOX_CAPACITY as BOX_CAPACITY, index$2_CHANNEL as CHANNEL, index$2_CHEMISTRY_GROUPS as CHEMISTRY_GROUPS, index$2_CHEMISTRY_PROMPT as CHEMISTRY_PROMPT, index$2_CHEMISTRY_SCHEMA as CHEMISTRY_SCHEMA, index$2_CHEMISTRY_SCHEMA_NAME as CHEMISTRY_SCHEMA_NAME, index$2_CHEMISTRY_TEMPLATE as CHEMISTRY_TEMPLATE, index$2_COMPARE as COMPARE, index$2_ChemistryAi as ChemistryAi, index$2_ChemistryRequest as ChemistryRequest, index$2_CommandWriter as CommandWriter, index$2_EVENT as EVENT, index$2_EVENT_A as EVENT_A, index$2_EVENT_B as EVENT_B, index$2_EVENT_C_HIGH as EVENT_C_HIGH, index$2_EVENT_C_LOW as EVENT_C_LOW, index$2_EVENT_KIND as EVENT_KIND, index$2_EVENT_PLAYER as EVENT_PLAYER, index$2_EVENT_WORDS as EVENT_WORDS, index$2_FIELD as FIELD, index$2_FRAME_MAGIC as FRAME_MAGIC, index$2_FRAME_VERSION as FRAME_VERSION, index$2_FRONTIER_CHANNEL_SLOT as FRONTIER_CHANNEL_SLOT, index$2_FrontierCommand as FrontierCommand, index$2_FrontierCommands as FrontierCommands, index$2_FrontierLink as FrontierLink, index$2_FrontierMirror as FrontierMirror, index$2_FrontierPlanet as FrontierPlanet, index$2_FrontierPlanetOptions as FrontierPlanetOptions, index$2_FrontierSession as FrontierSession, index$2_HEADER_BYTES as HEADER_BYTES, index$2_HEALTH_FIELDS as HEALTH_FIELDS, index$2_HERD as HERD, index$2_HERD_FIELDS as HERD_FIELDS, index$2_HERD_HEALTH as HERD_HEALTH, index$2_INVENTION_FLAG as INVENTION_FLAG, index$2_INVENTION_SCHEMA as INVENTION_SCHEMA, index$2_INVENT_PROMPT as INVENT_PROMPT, index$2_INVENT_SCHEMA as INVENT_SCHEMA, index$2_INVENT_TEMPLATE as INVENT_TEMPLATE, index$2_InventionAi as InventionAi, index$2_InventionRequest as InventionRequest, index$2_KINDS as KINDS, index$2_LANES as LANES, index$2_LAYER as LAYER, index$2_MACHINE_FLAG as MACHINE_FLAG, index$2_MAX_ACTIVATION as MAX_ACTIVATION, index$2_MAX_BEHAVIOURS as MAX_BEHAVIOURS, index$2_MAX_CHEMISTRY_NAME as MAX_CHEMISTRY_NAME, index$2_MAX_COMMAND_BYTES as MAX_COMMAND_BYTES, index$2_MAX_COUNT as MAX_COUNT, index$2_MAX_DENSITY as MAX_DENSITY, index$2_MAX_ENTHALPY as MAX_ENTHALPY, index$2_MAX_GROUPS as MAX_GROUPS, index$2_MAX_GROUP_CHARS as MAX_GROUP_CHARS, index$2_MAX_HARDNESS as MAX_HARDNESS, index$2_MAX_HEAT_CAPACITY as MAX_HEAT_CAPACITY, index$2_MAX_INGREDIENTS as MAX_INGREDIENTS, index$2_MAX_KELVIN as MAX_KELVIN, index$2_MAX_KNOWN_CHARS as MAX_KNOWN_CHARS, index$2_MAX_LATENT as MAX_LATENT, index$2_MAX_MATERIAL_CHARS as MAX_MATERIAL_CHARS, index$2_MAX_NAME_CHARS as MAX_NAME_CHARS, index$2_MAX_PARAM as MAX_PARAM, index$2_MAX_QUANTITY as MAX_QUANTITY, index$2_MAX_RATE_MILLI as MAX_RATE_MILLI, index$2_MAX_STEPS as MAX_STEPS, index$2_MAX_STEP_VALUE as MAX_STEP_VALUE, index$2_MAX_SURVEYED as MAX_SURVEYED, index$2_MAX_TERMS as MAX_TERMS, index$2_MIRROR_EVENTS as MIRROR_EVENTS, index$2_NO_INVENTION as NO_INVENTION, NO_ITEM$1 as NO_ITEM, index$2_PATHOGEN as PATHOGEN, index$2_PLOT as PLOT, index$2_PLOT_FIELDS as PLOT_FIELDS, index$2_PLOT_HEALTH as PLOT_HEALTH, index$2_PROCESS as PROCESS, index$2_PROCESSES as PROCESSES, index$2_REACTOR as REACTOR, index$2_REACTOR_FIELDS as REACTOR_FIELDS, index$2_REACTOR_SLOTS as REACTOR_SLOTS, index$2_REGION_METRES as REGION_METRES, index$2_RUN_ID_BYTES as RUN_ID_BYTES, index$2_RegionRef as RegionRef, index$2_ReplayFrontierLink as ReplayFrontierLink, index$2_SLOT_FIELDS as SLOT_FIELDS, index$2_TRAIT as TRAIT, index$2_TickFrontierLink as TickFrontierLink, index$2_VERBS as VERBS, index$2_actionOf as actionOf, index$2_chemistryRequest as chemistryRequest, index$2_encodeCommand as encodeCommand, index$2_frontierAiSection as frontierAiSection, index$2_frontierAiToml as frontierAiToml, index$2_frontierChemistryAiSection as frontierChemistryAiSection, index$2_inventionItem as inventionItem, index$2_inventionRequest as inventionRequest, index$2_isInvention as isInvention, index$2_itemFromCode as itemFromCode, index$2_joinFrontierPlanet as joinFrontierPlanet, index$2_materialItem as materialItem, index$2_regionFromBigInt as regionFromBigInt, index$2_regionKey as regionKey, index$2_requestChemistry as requestChemistry, index$2_requestInvention as requestInvention, index$2_runIdFromAiRun as runIdFromAiRun, index$2_runIdFromHex as runIdFromHex };
+}
+
+declare const SANDBOX_TOOLS: readonly [{
+    readonly id: "sand";
+    readonly label: "Sand";
+    readonly material: "sand";
+}, {
+    readonly id: "water";
+    readonly label: "Water";
+    readonly material: "H2O";
+}, {
+    readonly id: "wood";
+    readonly label: "Wood";
+    readonly material: "wood";
+}, {
+    readonly id: "oil";
+    readonly label: "Oil";
+    readonly material: "oil";
+}, {
+    readonly id: "salt";
+    readonly label: "Salt";
+    readonly material: "NaCl";
+}, {
+    readonly id: "iron";
+    readonly label: "Iron";
+    readonly material: "Fe";
+}, {
+    readonly id: "rust";
+    readonly label: "Rust";
+    readonly material: "hematite";
+}, {
+    readonly id: "aluminium";
+    readonly label: "Aluminium";
+    readonly material: "Al";
+}, {
+    readonly id: "charcoal";
+    readonly label: "Charcoal";
+    readonly material: "charcoal";
+}, {
+    readonly id: "limestone";
+    readonly label: "Limestone";
+    readonly material: "CaCO3";
+}, {
+    readonly id: "acid";
+    readonly label: "Acid";
+    readonly material: "HCl";
+}, {
+    readonly id: "sodium";
+    readonly label: "Sodium";
+    readonly material: "Na";
+}, {
+    readonly id: "tnt";
+    readonly label: "TNT";
+    readonly material: "TNT";
+}, {
+    readonly id: "gunpowder";
+    readonly label: "Gunpowder";
+    readonly material: "gunpowder";
+}, {
+    readonly id: "fire";
+    readonly label: "Fire";
+    readonly material: "";
+}, {
+    readonly id: "frost";
+    readonly label: "Frost";
+    readonly material: "";
+}, {
+    readonly id: "spark";
+    readonly label: "Spark";
+    readonly material: "";
+}, {
+    readonly id: "erase";
+    readonly label: "Erase";
+    readonly material: "";
+}];
+type SandboxToolId = (typeof SANDBOX_TOOLS)[number]["id"];
+interface SandboxOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly seed?: number;
+    readonly brush?: number;
+    readonly viewport?: () => {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly background?: number;
+    readonly onEvent?: (event: Readonly<ChemistryEvent>) => void;
+    readonly onMenu?: (which: "tool" | "invent") => void;
+}
+declare class ChemistrySandbox implements GameScene<Game> {
+    private readonly options;
+    readonly name = "chemistry-sandbox";
+    readonly width: number;
+    readonly height: number;
+    region: ChemistryRegion | null;
+    tool: SandboxToolId;
+    explosions: number;
+    reactions: number;
+    private pixels;
+    private texture;
+    private material;
+    private node;
+    private readonly pointer;
+    private wasDown;
+    private readonly materials;
+    private readonly brush;
+    private readonly background;
+    private readonly countEvent;
+    constructor(options?: SandboxOptions);
+    enter(game: Game): void;
+    private layout;
+    selectTool(tool: SandboxToolId): void;
+    nextTool(): SandboxToolId;
+    toolLabel(): string;
+    applyAt(cellX: number, cellY: number): void;
+    applyScreen(x: number, y: number, viewportWidth: number, viewportHeight: number): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    exit(game: Game): void;
+}
+
+declare const index$1_CELL_CLASSES: typeof CELL_CLASSES;
+declare const index$1_CHEMISTRY_AI_CAPABILITY: typeof CHEMISTRY_AI_CAPABILITY;
+declare const index$1_CHEMISTRY_ATMOSPHERE: typeof CHEMISTRY_ATMOSPHERE;
+declare const index$1_CHEMISTRY_BOX_WORDS: typeof CHEMISTRY_BOX_WORDS;
+declare const index$1_CHEMISTRY_COLUMNS: typeof CHEMISTRY_COLUMNS;
+declare const index$1_CHEMISTRY_EVENT_HEADER: typeof CHEMISTRY_EVENT_HEADER;
+declare const index$1_CHEMISTRY_EVENT_KINDS: typeof CHEMISTRY_EVENT_KINDS;
+declare const index$1_CHEMISTRY_EVENT_WORDS: typeof CHEMISTRY_EVENT_WORDS;
+declare const index$1_CHEMISTRY_EXPORT_NAMES: typeof CHEMISTRY_EXPORT_NAMES;
+declare const index$1_CHEMISTRY_NATURE_WORDS: typeof CHEMISTRY_NATURE_WORDS;
+declare const index$1_CHEMISTRY_PROBE_WORDS: typeof CHEMISTRY_PROBE_WORDS;
+declare const index$1_CHEMISTRY_REACTION_WORDS: typeof CHEMISTRY_REACTION_WORDS;
+declare const index$1_CHEMISTRY_REFUSALS: typeof CHEMISTRY_REFUSALS;
+declare const index$1_CHEMISTRY_REFUSAL_TEXT: typeof CHEMISTRY_REFUSAL_TEXT;
+declare const index$1_CHEMISTRY_REFUSED: typeof CHEMISTRY_REFUSED;
+declare const index$1_CHEMISTRY_SLOTS: typeof CHEMISTRY_SLOTS;
+declare const index$1_CHEMISTRY_SPECIES_WORDS: typeof CHEMISTRY_SPECIES_WORDS;
+declare const index$1_CHEMISTRY_STATS_WORDS: typeof CHEMISTRY_STATS_WORDS;
+declare const index$1_CHEMISTRY_TQ: typeof CHEMISTRY_TQ;
+declare const index$1_CHEMISTRY_UNSET: typeof CHEMISTRY_UNSET;
+declare const index$1_CHEMISTRY_VACUUM: typeof CHEMISTRY_VACUUM;
+declare const index$1_CHEMISTRY_VESSEL_SLOTS: typeof CHEMISTRY_VESSEL_SLOTS;
+declare const index$1_CHEMISTRY_VESSEL_WORDS: typeof CHEMISTRY_VESSEL_WORDS;
+declare const index$1_CellBox: typeof CellBox;
+declare const index$1_CellClass: typeof CellClass;
+declare const index$1_CellProbe: typeof CellProbe;
+declare const index$1_Chemistry: typeof Chemistry;
+declare const index$1_ChemistryEngine: typeof ChemistryEngine;
+declare const index$1_ChemistryEvent: typeof ChemistryEvent;
+declare const index$1_ChemistryEventKind: typeof ChemistryEventKind;
+declare const index$1_ChemistryExportName: typeof ChemistryExportName;
+declare const index$1_ChemistryExports: typeof ChemistryExports;
+declare const index$1_ChemistryGroup: typeof ChemistryGroup;
+declare const index$1_ChemistryMemory: typeof ChemistryMemory;
+declare const index$1_ChemistryParticles: typeof ChemistryParticles;
+declare const index$1_ChemistryRefusal: typeof ChemistryRefusal;
+declare const index$1_ChemistryRegion: typeof ChemistryRegion;
+type index$1_ChemistrySandbox = ChemistrySandbox;
+declare const index$1_ChemistrySandbox: typeof ChemistrySandbox;
+declare const index$1_ChemistryVessel: typeof ChemistryVessel;
+declare const index$1_DefineResult: typeof DefineResult;
+declare const index$1_MAX_FORMULA: typeof MAX_FORMULA;
+declare const index$1_MAX_NAME: typeof MAX_NAME;
+declare const index$1_MAX_SPECIES: typeof MAX_SPECIES;
+declare const index$1_MaterialInfo: typeof MaterialInfo;
+declare const index$1_NatureOptions: typeof NatureOptions;
+declare const index$1_PROPOSAL_SCHEMA: typeof PROPOSAL_SCHEMA;
+declare const index$1_Proposal: typeof Proposal;
+declare const index$1_ProposedMaterial: typeof ProposedMaterial;
+declare const index$1_ProposedTerm: typeof ProposedTerm;
+declare const index$1_ReactionIdea: typeof ReactionIdea;
+declare const index$1_ReactionInfo: typeof ReactionInfo;
+declare const index$1_ReactionTerm: typeof ReactionTerm;
+declare const index$1_RegionOptions: typeof RegionOptions;
+declare const index$1_RegionStats: typeof RegionStats;
+declare const index$1_SANDBOX_TOOLS: typeof SANDBOX_TOOLS;
+type index$1_SandboxOptions = SandboxOptions;
+type index$1_SandboxToolId = SandboxToolId;
+declare const index$1_VesselState: typeof VesselState;
+declare const index$1_bindChemistryEngine: typeof bindChemistryEngine;
+declare const index$1_chemistryAiSection: typeof chemistryAiSection;
+declare const index$1_chemistryAiToml: typeof chemistryAiToml;
+declare const index$1_groupNames: typeof groupNames;
+declare const index$1_knownMaterials: typeof knownMaterials;
+declare const index$1_proposalText: typeof proposalText;
+declare const index$1_proposeReaction: typeof proposeReaction;
+declare const index$1_reactionRequest: typeof reactionRequest;
+declare namespace index$1 {
+  export { index$1_CELL_CLASSES as CELL_CLASSES, index$1_CHEMISTRY_AI_CAPABILITY as CHEMISTRY_AI_CAPABILITY, index$1_CHEMISTRY_ATMOSPHERE as CHEMISTRY_ATMOSPHERE, index$1_CHEMISTRY_BOX_WORDS as CHEMISTRY_BOX_WORDS, index$1_CHEMISTRY_COLUMNS as CHEMISTRY_COLUMNS, index$1_CHEMISTRY_EVENT_HEADER as CHEMISTRY_EVENT_HEADER, index$1_CHEMISTRY_EVENT_KINDS as CHEMISTRY_EVENT_KINDS, index$1_CHEMISTRY_EVENT_WORDS as CHEMISTRY_EVENT_WORDS, index$1_CHEMISTRY_EXPORT_NAMES as CHEMISTRY_EXPORT_NAMES, CHEMISTRY_GROUPS$1 as CHEMISTRY_GROUPS, index$1_CHEMISTRY_NATURE_WORDS as CHEMISTRY_NATURE_WORDS, index$1_CHEMISTRY_PROBE_WORDS as CHEMISTRY_PROBE_WORDS, CHEMISTRY_PROMPT$1 as CHEMISTRY_PROMPT, index$1_CHEMISTRY_REACTION_WORDS as CHEMISTRY_REACTION_WORDS, index$1_CHEMISTRY_REFUSALS as CHEMISTRY_REFUSALS, index$1_CHEMISTRY_REFUSAL_TEXT as CHEMISTRY_REFUSAL_TEXT, index$1_CHEMISTRY_REFUSED as CHEMISTRY_REFUSED, CHEMISTRY_SCHEMA$1 as CHEMISTRY_SCHEMA, index$1_CHEMISTRY_SLOTS as CHEMISTRY_SLOTS, index$1_CHEMISTRY_SPECIES_WORDS as CHEMISTRY_SPECIES_WORDS, index$1_CHEMISTRY_STATS_WORDS as CHEMISTRY_STATS_WORDS, CHEMISTRY_TEMPLATE$1 as CHEMISTRY_TEMPLATE, index$1_CHEMISTRY_TQ as CHEMISTRY_TQ, index$1_CHEMISTRY_UNSET as CHEMISTRY_UNSET, index$1_CHEMISTRY_VACUUM as CHEMISTRY_VACUUM, index$1_CHEMISTRY_VESSEL_SLOTS as CHEMISTRY_VESSEL_SLOTS, index$1_CHEMISTRY_VESSEL_WORDS as CHEMISTRY_VESSEL_WORDS, index$1_CellBox as CellBox, index$1_CellClass as CellClass, index$1_CellProbe as CellProbe, index$1_Chemistry as Chemistry, ChemistryAi$1 as ChemistryAi, index$1_ChemistryEngine as ChemistryEngine, index$1_ChemistryEvent as ChemistryEvent, index$1_ChemistryEventKind as ChemistryEventKind, index$1_ChemistryExportName as ChemistryExportName, index$1_ChemistryExports as ChemistryExports, index$1_ChemistryGroup as ChemistryGroup, index$1_ChemistryMemory as ChemistryMemory, index$1_ChemistryParticles as ChemistryParticles, index$1_ChemistryRefusal as ChemistryRefusal, index$1_ChemistryRegion as ChemistryRegion, index$1_ChemistrySandbox as ChemistrySandbox, index$1_ChemistryVessel as ChemistryVessel, index$1_DefineResult as DefineResult, index$1_MAX_FORMULA as MAX_FORMULA, MAX_KNOWN_CHARS$1 as MAX_KNOWN_CHARS, index$1_MAX_NAME as MAX_NAME, index$1_MAX_SPECIES as MAX_SPECIES, MAX_TERMS$1 as MAX_TERMS, index$1_MaterialInfo as MaterialInfo, index$1_NatureOptions as NatureOptions, index$1_PROPOSAL_SCHEMA as PROPOSAL_SCHEMA, index$1_Proposal as Proposal, index$1_ProposedMaterial as ProposedMaterial, index$1_ProposedTerm as ProposedTerm, index$1_ReactionIdea as ReactionIdea, index$1_ReactionInfo as ReactionInfo, index$1_ReactionTerm as ReactionTerm, index$1_RegionOptions as RegionOptions, index$1_RegionStats as RegionStats, index$1_SANDBOX_TOOLS as SANDBOX_TOOLS, type index$1_SandboxOptions as SandboxOptions, type index$1_SandboxToolId as SandboxToolId, index$1_VesselState as VesselState, index$1_bindChemistryEngine as bindChemistryEngine, index$1_chemistryAiSection as chemistryAiSection, index$1_chemistryAiToml as chemistryAiToml, index$1_groupNames as groupNames, index$1_knownMaterials as knownMaterials, index$1_proposalText as proposalText, index$1_proposeReaction as proposeReaction, index$1_reactionRequest as reactionRequest };
+}
+
+declare const index_BLESSED: typeof BLESSED;
+declare const index_ByteWriter: typeof ByteWriter;
+declare const index_CHRONICLE_MAX_UNITS: typeof CHRONICLE_MAX_UNITS;
+declare const index_CHRONICLE_PROMPT: typeof CHRONICLE_PROMPT;
+declare const index_CHRONICLE_TEMPLATE: typeof CHRONICLE_TEMPLATE;
+declare const index_CONSTITUTION_PROMPT: typeof CONSTITUTION_PROMPT;
+declare const index_CONSTITUTION_SCHEMA: typeof CONSTITUTION_SCHEMA;
+declare const index_CONSTITUTION_SCHEMA_NAME: typeof CONSTITUTION_SCHEMA_NAME;
+declare const index_CONSTITUTION_TEMPLATE: typeof CONSTITUTION_TEMPLATE;
+declare const index_CURSED: typeof CURSED;
+declare const index_ChronicleRequest: typeof ChronicleRequest;
+declare const index_Clause: typeof Clause;
+declare const index_Constitution: typeof Constitution;
+declare const index_ConstitutionRequest: typeof ConstitutionRequest;
+declare const index_DECREE_REFUSALS: typeof DECREE_REFUSALS;
+declare const index_DECREE_REFUSAL_BASE: typeof DECREE_REFUSAL_BASE;
+declare const index_DEFAULT_NATURE: typeof DEFAULT_NATURE;
+declare const index_DESTINY: typeof DESTINY;
+declare const index_DISASTER: typeof DISASTER;
+declare const index_Decree: typeof Decree;
+declare const index_EDIT_RING: typeof EDIT_RING;
+declare const index_ENVELOPE: typeof ENVELOPE;
+declare const index_Edit: typeof Edit;
+declare const index_Effect: typeof Effect;
+declare const index_EraReply: typeof EraReply;
+declare const index_FACT_KINDS: typeof FACT_KINDS;
+declare const index_FACT_RING: typeof FACT_RING;
+declare const index_FACT_SLOTS: typeof FACT_SLOTS;
+declare const index_FORECAST_FAILED: typeof FORECAST_FAILED;
+declare const index_FRAME: typeof FRAME;
+declare const index_Fact: typeof Fact;
+declare const index_FaithRecord: typeof FaithRecord;
+declare const index_Filter: typeof Filter;
+declare const index_ForecastReply: typeof ForecastReply;
+declare const index_ForecastYear: typeof ForecastYear;
+declare const index_Found: typeof Found;
+declare const index_GENESIS_ACTIVE_WORDS: typeof GENESIS_ACTIVE_WORDS;
+declare const index_GENESIS_CHANNEL_SLOT: typeof GENESIS_CHANNEL_SLOT;
+declare const index_GENESIS_EXPORT_NAMES: typeof GENESIS_EXPORT_NAMES;
+declare const index_GENESIS_INDICATOR_WORDS: typeof GENESIS_INDICATOR_WORDS;
+declare const index_GENESIS_OPEN_WORDS: typeof GENESIS_OPEN_WORDS;
+declare const index_GENESIS_REFUSED: typeof GENESIS_REFUSED;
+declare const index_GENESIS_SETTLEMENT_WORDS: typeof GENESIS_SETTLEMENT_WORDS;
+declare const index_GIFTED: typeof GIFTED;
+declare const index_GOVERNMENT: typeof GOVERNMENT;
+declare const index_GenesisAi: typeof GenesisAi;
+declare const index_GenesisCommands: typeof GenesisCommands;
+declare const index_GenesisEngine: typeof GenesisEngine;
+declare const index_GenesisExportName: typeof GenesisExportName;
+declare const index_GenesisExports: typeof GenesisExports;
+declare const index_GenesisLink: typeof GenesisLink;
+declare const index_GenesisMirror: typeof GenesisMirror;
+declare const index_GenesisNature: typeof GenesisNature;
+declare const index_GenesisSession: typeof GenesisSession;
+declare const index_GenesisState: typeof GenesisState;
+declare const index_GenesisWorld: typeof GenesisWorld;
+declare const index_GenesisWorldOptions: typeof GenesisWorldOptions;
+declare const index_HUMAN: typeof HUMAN;
+declare const index_LAT_BANDS_MAX: typeof LAT_BANDS_MAX;
+declare const index_LocalGenesis: typeof LocalGenesis;
+declare const index_LocalIndicators: typeof LocalIndicators;
+declare const index_LocalStart: typeof LocalStart;
+declare const index_MAX_DECREE_BYTES: typeof MAX_DECREE_BYTES;
+declare const index_MAX_FACT_CHARS: typeof MAX_FACT_CHARS;
+declare const index_MAX_FAITHS: typeof MAX_FAITHS;
+declare const index_MAX_SETTLEMENTS: typeof MAX_SETTLEMENTS;
+declare const index_MAX_WORLD_CHARS: typeof MAX_WORLD_CHARS;
+declare const index_MONTHS_PER_YEAR: typeof MONTHS_PER_YEAR;
+declare const index_NONE: typeof NONE;
+declare const index_NO_FAITH: typeof NO_FAITH;
+declare const index_NameRefusal: typeof NameRefusal;
+declare const index_Nature: typeof Nature;
+declare const index_OP: typeof OP;
+declare const index_Office: typeof Office;
+declare const index_PROPERTY: typeof PROPERTY;
+declare const index_PersonRecord: typeof PersonRecord;
+declare const index_Power: typeof Power;
+declare const index_Predicate: typeof Predicate;
+declare const index_Q16: typeof Q16;
+declare const index_REFUSED_DRAFT: typeof REFUSED_DRAFT;
+declare const index_REFUSED_FULL: typeof REFUSED_FULL;
+declare const index_REFUSED_MALFORMED: typeof REFUSED_MALFORMED;
+declare const index_REFUSED_SEAT: typeof REFUSED_SEAT;
+declare const index_RIGHT: typeof RIGHT;
+declare const index_RIGHTS_ALL: typeof RIGHTS_ALL;
+declare const index_ReplayGenesisLink: typeof ReplayGenesisLink;
+declare const index_Review: typeof Review;
+declare const index_Rule: typeof Rule;
+declare const index_SELECTION: typeof SELECTION;
+declare const index_SINK: typeof SINK;
+declare const index_START_MONTH: typeof START_MONTH;
+declare const index_Species: typeof Species;
+declare const index_TERRAIN: typeof TERRAIN;
+declare const index_TIER: typeof TIER;
+declare const index_TRIGGER: typeof TRIGGER;
+declare const index_Target: typeof Target;
+declare const index_TickGenesisLink: typeof TickGenesisLink;
+declare const index_applyNature: typeof applyNature;
+declare const index_bindGenesisEngine: typeof bindGenesisEngine;
+declare const index_chronicleRequest: typeof chronicleRequest;
+declare const index_constitutionRequest: typeof constitutionRequest;
+declare const index_encodeDecree: typeof encodeDecree;
+declare const index_encodeReviewedLaw: typeof encodeReviewedLaw;
+declare const index_factsText: typeof factsText;
+declare const index_finalize: typeof finalize;
+declare const index_genesisAiSection: typeof genesisAiSection;
+declare const index_genesisAiToml: typeof genesisAiToml;
+declare const index_joinGenesisWorld: typeof joinGenesisWorld;
+declare const index_mix: typeof mix;
+declare const index_nameOf: typeof nameOf;
+declare const index_percentQ16: typeof percentQ16;
+declare const index_ratioQ16: typeof ratioQ16;
+declare const index_requestChronicle: typeof requestChronicle;
+declare const index_requestConstitution: typeof requestConstitution;
+declare const index_runIdFromAiRun: typeof runIdFromAiRun;
+declare const index_screenName: typeof screenName;
+declare const index_writeConstitution: typeof writeConstitution;
+declare const index_writeNature: typeof writeNature;
+declare const index_yearOf: typeof yearOf;
+declare namespace index {
+  export { ACTION$1 as ACTION, AI_CAPABILITY$1 as AI_CAPABILITY, index_BLESSED as BLESSED, BOX_CAPACITY$1 as BOX_CAPACITY, index_ByteWriter as ByteWriter, index_CHRONICLE_MAX_UNITS as CHRONICLE_MAX_UNITS, index_CHRONICLE_PROMPT as CHRONICLE_PROMPT, index_CHRONICLE_TEMPLATE as CHRONICLE_TEMPLATE, index_CONSTITUTION_PROMPT as CONSTITUTION_PROMPT, index_CONSTITUTION_SCHEMA as CONSTITUTION_SCHEMA, index_CONSTITUTION_SCHEMA_NAME as CONSTITUTION_SCHEMA_NAME, index_CONSTITUTION_TEMPLATE as CONSTITUTION_TEMPLATE, index_CURSED as CURSED, index_ChronicleRequest as ChronicleRequest, index_Clause as Clause, index_Constitution as Constitution, index_ConstitutionRequest as ConstitutionRequest, index_DECREE_REFUSALS as DECREE_REFUSALS, index_DECREE_REFUSAL_BASE as DECREE_REFUSAL_BASE, index_DEFAULT_NATURE as DEFAULT_NATURE, index_DESTINY as DESTINY, index_DISASTER as DISASTER, index_Decree as Decree, index_EDIT_RING as EDIT_RING, index_ENVELOPE as ENVELOPE, index_Edit as Edit, index_Effect as Effect, index_EraReply as EraReply, index_FACT_KINDS as FACT_KINDS, index_FACT_RING as FACT_RING, index_FACT_SLOTS as FACT_SLOTS, FIELD$1 as FIELD, index_FORECAST_FAILED as FORECAST_FAILED, index_FRAME as FRAME, index_Fact as Fact, index_FaithRecord as FaithRecord, index_Filter as Filter, index_ForecastReply as ForecastReply, index_ForecastYear as ForecastYear, index_Found as Found, index_GENESIS_ACTIVE_WORDS as GENESIS_ACTIVE_WORDS, index_GENESIS_CHANNEL_SLOT as GENESIS_CHANNEL_SLOT, index_GENESIS_EXPORT_NAMES as GENESIS_EXPORT_NAMES, index_GENESIS_INDICATOR_WORDS as GENESIS_INDICATOR_WORDS, index_GENESIS_OPEN_WORDS as GENESIS_OPEN_WORDS, index_GENESIS_REFUSED as GENESIS_REFUSED, index_GENESIS_SETTLEMENT_WORDS as GENESIS_SETTLEMENT_WORDS, index_GIFTED as GIFTED, index_GOVERNMENT as GOVERNMENT, index_GenesisAi as GenesisAi, index_GenesisCommands as GenesisCommands, index_GenesisEngine as GenesisEngine, index_GenesisExportName as GenesisExportName, index_GenesisExports as GenesisExports, index_GenesisLink as GenesisLink, index_GenesisMirror as GenesisMirror, index_GenesisNature as GenesisNature, index_GenesisSession as GenesisSession, index_GenesisState as GenesisState, index_GenesisWorld as GenesisWorld, index_GenesisWorldOptions as GenesisWorldOptions, index_HUMAN as HUMAN, index_LAT_BANDS_MAX as LAT_BANDS_MAX, index_LocalGenesis as LocalGenesis, index_LocalIndicators as LocalIndicators, index_LocalStart as LocalStart, index_MAX_DECREE_BYTES as MAX_DECREE_BYTES, index_MAX_FACT_CHARS as MAX_FACT_CHARS, index_MAX_FAITHS as MAX_FAITHS, MAX_NAME_CHARS$1 as MAX_NAME_CHARS, index_MAX_SETTLEMENTS as MAX_SETTLEMENTS, index_MAX_WORLD_CHARS as MAX_WORLD_CHARS, index_MONTHS_PER_YEAR as MONTHS_PER_YEAR, index_NONE as NONE, index_NO_FAITH as NO_FAITH, index_NameRefusal as NameRefusal, index_Nature as Nature, index_OP as OP, index_Office as Office, index_PROPERTY as PROPERTY, index_PersonRecord as PersonRecord, index_Power as Power, index_Predicate as Predicate, index_Q16 as Q16, index_REFUSED_DRAFT as REFUSED_DRAFT, index_REFUSED_FULL as REFUSED_FULL, index_REFUSED_MALFORMED as REFUSED_MALFORMED, index_REFUSED_SEAT as REFUSED_SEAT, index_RIGHT as RIGHT, index_RIGHTS_ALL as RIGHTS_ALL, RUN_ID_BYTES$1 as RUN_ID_BYTES, index_ReplayGenesisLink as ReplayGenesisLink, index_Review as Review, index_Rule as Rule, index_SELECTION as SELECTION, index_SINK as SINK, index_START_MONTH as START_MONTH, index_Species as Species, index_TERRAIN as TERRAIN, index_TIER as TIER, index_TRIGGER as TRIGGER, index_Target as Target, index_TickGenesisLink as TickGenesisLink, index_applyNature as applyNature, index_bindGenesisEngine as bindGenesisEngine, index_chronicleRequest as chronicleRequest, index_constitutionRequest as constitutionRequest, index_encodeDecree as encodeDecree, index_encodeReviewedLaw as encodeReviewedLaw, index_factsText as factsText, index_finalize as finalize, index_genesisAiSection as genesisAiSection, index_genesisAiToml as genesisAiToml, index_joinGenesisWorld as joinGenesisWorld, index_mix as mix, index_nameOf as nameOf, index_percentQ16 as percentQ16, index_ratioQ16 as ratioQ16, index_requestChronicle as requestChronicle, index_requestConstitution as requestConstitution, index_runIdFromAiRun as runIdFromAiRun, index_screenName as screenName, index_writeConstitution as writeConstitution, index_writeNature as writeNature, index_yearOf as yearOf };
+}
+
+declare const BUTTON_PRIMARY = 1;
+declare const BUTTON_SECONDARY = 2;
+declare const BUTTON_MIDDLE = 4;
+interface CameraControl {
+    enabled: boolean;
+    update(dt: number): void;
+    dispose(): void;
+}
+interface ControlViewOptions {
+    readonly fov?: number;
+    readonly aspect?: number;
+}
+declare function frameDamping(factor: number, dt: number): number;
+declare class CameraPose {
+    readonly position: Vec3$1;
+    readonly rotation: Quat;
+    readonly transforms: Transforms;
+    readonly camera: Entity;
+    constructor(transforms: Transforms, camera: Entity);
+    read(): void;
+    write(): void;
+    axis(index: number, out: Vec3$1): Vec3$1;
+    forward(out: Vec3$1): Vec3$1;
+}
+
+interface OrbitControlsOptions extends ControlViewOptions {
+    readonly target?: readonly [number, number, number];
+    readonly enableDamping?: boolean;
+    readonly dampingFactor?: number;
+    readonly minDistance?: number;
+    readonly maxDistance?: number;
+    readonly minPolarAngle?: number;
+    readonly maxPolarAngle?: number;
+    readonly minAzimuthAngle?: number;
+    readonly maxAzimuthAngle?: number;
+    readonly autoRotate?: boolean;
+    readonly autoRotateSpeed?: number;
+    readonly screenSpacePanning?: boolean;
+    readonly zoomToCursor?: boolean;
+    readonly orthographicHeight?: number;
+}
+declare class OrbitControls implements CameraControl {
+    enabled: boolean;
+    enableRotate: boolean;
+    enableZoom: boolean;
+    enablePan: boolean;
+    enableDamping: boolean;
+    dampingFactor: number;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    minDistance: number;
+    maxDistance: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+    screenSpacePanning: boolean;
+    zoomToCursor: boolean;
+    fov: number;
+    aspect: number;
+    orthographicHeight: number;
+    rotateButtons: number;
+    panButtons: number;
+    dollyButtons: number;
+    readonly target: Vec3$1;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly spherical;
+    private readonly sphericalDelta;
+    private readonly panOffset;
+    private scale;
+    private cursorX;
+    private cursorY;
+    private cursorZoom;
+    private readonly offset;
+    private readonly column;
+    private readonly scratch;
+    private readonly cursorPoint;
+    private readonly savedTarget;
+    private readonly savedPosition;
+    private readonly projection;
+    private readonly world;
+    private readonly ray;
+    private readonly plane;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: OrbitControlsOptions);
+    get distance(): number;
+    get polarAngle(): number;
+    get azimuthAngle(): number;
+    setViewport(width: number, height: number): void;
+    setTarget(target: Vec3Like): void;
+    saveState(): void;
+    reset(): void;
+    rotateLeft(angle: number): void;
+    rotateUp(angle: number): void;
+    dolly(scale: number): void;
+    pan(normalizedX: number, normalizedY: number): void;
+    update(dt: number): void;
+    dispose(): void;
+    private zoomScale;
+    private readInput;
+    private setCursor;
+    private apply;
+    private cursorTarget;
+}
+declare class MapControls extends OrbitControls {
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: OrbitControlsOptions);
+}
+
+type LookMode = "drag" | "pointer" | "none";
+interface MovementKeys {
+    readonly forward: readonly string[];
+    readonly backward: readonly string[];
+    readonly left: readonly string[];
+    readonly right: readonly string[];
+    readonly up: readonly string[];
+    readonly down: readonly string[];
+}
+declare const DEFAULT_MOVEMENT_KEYS: MovementKeys;
+declare class MovementAxes {
+    readonly forward: ActionId;
+    readonly strafe: ActionId;
+    readonly lift: ActionId;
+    constructor(input: InputActions, prefix: string, keys?: MovementKeys);
+}
+interface FirstPersonControlsOptions extends ControlViewOptions {
+    readonly lookSpeed?: number;
+    readonly movementSpeed?: number;
+    readonly lookMode?: LookMode;
+    readonly lookVertical?: boolean;
+    readonly maxPitch?: number;
+    readonly keys?: MovementKeys;
+    readonly actionPrefix?: string;
+}
+declare class FirstPersonControls implements CameraControl {
+    enabled: boolean;
+    lookSpeed: number;
+    movementSpeed: number;
+    lookMode: LookMode;
+    lookVertical: boolean;
+    maxPitch: number;
+    aspect: number;
+    yaw: number;
+    pitch: number;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly axes;
+    private readonly angles;
+    private readonly scratch;
+    private readonly turn;
+    private readonly direction;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: FirstPersonControlsOptions);
+    setViewport(width: number, height: number): void;
+    look(yawDelta: number, pitchDelta: number): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+interface PointerLockControlsOptions {
+    readonly pointerSpeed?: number;
+    readonly minPolarAngle?: number;
+    readonly maxPolarAngle?: number;
+    readonly movementSpeed?: number;
+    readonly keys?: MovementKeys;
+    readonly actionPrefix?: string;
+}
+declare class PointerLockControls implements CameraControl {
+    enabled: boolean;
+    locked: boolean;
+    pointerSpeed: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    movementSpeed: number;
+    yaw: number;
+    pitch: number;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly axes;
+    private readonly angles;
+    private readonly scratch;
+    private readonly turn;
+    private readonly direction;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: PointerLockControlsOptions);
+    lock(target: PointerLockTarget): Promise<boolean>;
+    unlock(doc: PointerLockDocument): void;
+    moveForward(distance: number): void;
+    moveRight(distance: number): void;
+    private shiftForward;
+    private shiftRight;
+    update(dt: number): void;
+    dispose(): void;
+}
+
+interface FlyRotationKeys {
+    readonly pitchUp: readonly string[];
+    readonly pitchDown: readonly string[];
+    readonly yawLeft: readonly string[];
+    readonly yawRight: readonly string[];
+    readonly rollLeft: readonly string[];
+    readonly rollRight: readonly string[];
+}
+declare const DEFAULT_FLY_ROTATION_KEYS: FlyRotationKeys;
+interface FlyControlsOptions extends ControlViewOptions {
+    readonly movementSpeed?: number;
+    readonly rollSpeed?: number;
+    readonly dragToLook?: boolean;
+    readonly dragSpeed?: number;
+    readonly keys?: MovementKeys;
+    readonly rotationKeys?: FlyRotationKeys;
+    readonly actionPrefix?: string;
+}
+declare class FlyControls implements CameraControl {
+    enabled: boolean;
+    movementSpeed: number;
+    rollSpeed: number;
+    dragToLook: boolean;
+    dragSpeed: number;
+    aspect: number;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly axes;
+    private readonly pitchAxis;
+    private readonly yawAxis;
+    private readonly rollAxis;
+    private readonly move;
+    private readonly delta;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: FlyControlsOptions);
+    setViewport(width: number, height: number): void;
+    rotate(pitch: number, yaw: number, roll: number): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+
+interface TrackballControlsOptions extends ControlViewOptions {
+    readonly target?: readonly [number, number, number];
+    readonly rotateSpeed?: number;
+    readonly zoomSpeed?: number;
+    readonly panSpeed?: number;
+    readonly staticMoving?: boolean;
+    readonly dynamicDampingFactor?: number;
+    readonly minDistance?: number;
+    readonly maxDistance?: number;
+}
+declare class TrackballControls implements CameraControl {
+    enabled: boolean;
+    rotateSpeed: number;
+    zoomSpeed: number;
+    panSpeed: number;
+    staticMoving: boolean;
+    dynamicDampingFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    aspect: number;
+    rotateButtons: number;
+    zoomButtons: number;
+    panButtons: number;
+    readonly target: Vec3$1;
+    readonly up: Vec3$1;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly eye;
+    private readonly eyeDirection;
+    private readonly upDirection;
+    private readonly sideways;
+    private readonly moveDirection;
+    private readonly axis;
+    private readonly lastAxis;
+    private readonly pan;
+    private readonly scratch;
+    private readonly turn;
+    private lastAngle;
+    private pendingX;
+    private pendingY;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: TrackballControlsOptions);
+    setViewport(width: number, height: number): void;
+    rotate(dx: number, dy: number): void;
+    private turnBy;
+    zoom(factor: number): void;
+    update(dt: number): void;
+    dispose(): void;
+    private panBy;
+}
+
+interface DragPicker {
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+    nodeOf(entity: Entity): NodeId | null;
+}
+interface DragControlsOptions {
+    readonly layers?: number;
+    readonly far?: number;
+}
+declare class DragControls implements CameraControl {
+    enabled: boolean;
+    layers: number;
+    far: number;
+    dragging: Entity;
+    hovered: Entity;
+    dragStarted: boolean;
+    dragEnded: boolean;
+    readonly objects: Entity[];
+    readonly hit: PickHit;
+    private readonly picker;
+    private readonly transforms;
+    private readonly projection;
+    private readonly input;
+    private readonly ray;
+    private readonly plane;
+    private readonly offset;
+    private readonly point;
+    private readonly position;
+    private readonly normal;
+    private readonly origin;
+    private readonly direction;
+    private wasDown;
+    constructor(picker: DragPicker, transforms: Transforms, projection: CameraProjection, input: InputActions, objects: Entity[], options?: DragControlsOptions);
+    update(): void;
+    dispose(): void;
+    private release;
+    private pick;
+}
+
+interface GyroLookOptions {
+    readonly alphaOffset?: number;
+    readonly smoothing?: number;
+    readonly screenOrientation?: number;
+}
+declare function deviceQuaternion(out: Quat, alpha: number, beta: number, gamma: number, orientation: number, scratch: Quat): Quat;
+declare class GyroLookControls implements CameraControl {
+    enabled: boolean;
+    alphaOffset: number;
+    smoothing: number;
+    screenOrientation: number;
+    readonly pose: CameraPose;
+    private readonly input;
+    private readonly goal;
+    private readonly scratch;
+    private readonly base;
+    private settled;
+    constructor(transforms: Transforms, camera: Entity, input: InputActions, options?: GyroLookOptions);
+    setYawOffset(radians: number): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+
+declare const graphParamBrand: unique symbol;
+declare const graphStateBrand: unique symbol;
+declare const graphEventBrand: unique symbol;
+type GraphParam = number & {
+    readonly [graphParamBrand]: true;
+};
+type GraphState = number & {
+    readonly [graphStateBrand]: true;
+};
+type GraphEvent = number & {
+    readonly [graphEventBrand]: true;
+};
+type AnimationGraphPort = Pick<ClipAnimationPort, "crossFade" | "fadeClip" | "setClipTime" | "setClipSpeed" | "setClipLoop" | "setClipSync" | "setBlendParameterFrom" | "readClipState" | "readClipEvents">;
+type GraphParamKind = "float" | "bool" | "trigger";
+type GraphConditionOp = "greater" | "less" | "equal" | "notEqual" | "true" | "false" | "trigger";
+interface GraphParamDef {
+    readonly name: string;
+    readonly kind: GraphParamKind;
+    readonly initial?: number | boolean;
+}
+interface GraphClipStateDef {
+    readonly name: string;
+    readonly kind: "clip";
+    readonly action: ClipActionId;
+    readonly speed?: number;
+    readonly speedParam?: string;
+    readonly loop?: ClipLoop;
+    readonly repetitions?: number;
+    readonly clampWhenFinished?: boolean;
+    readonly sync?: number | null;
+    readonly duration?: number;
+    readonly restart?: boolean;
+}
+interface GraphBlendStateDef {
+    readonly name: string;
+    readonly kind: "blend";
+    readonly space: BlendSpaceId;
+    readonly x: string;
+    readonly y?: string;
+    readonly duration?: number;
+}
+type GraphStateDef = GraphClipStateDef | GraphBlendStateDef;
+interface GraphConditionDef {
+    readonly param: string;
+    readonly op: GraphConditionOp;
+    readonly value?: number;
+}
+interface GraphTransitionDef {
+    readonly from: string;
+    readonly to: string;
+    readonly conditions?: readonly GraphConditionDef[];
+    readonly exitTime?: number;
+    readonly seconds?: number;
+    readonly warp?: boolean;
+    readonly priority?: number;
+    readonly allowSelf?: boolean;
+}
+interface GraphClipEventDef {
+    readonly name: string;
+    readonly id: number;
+}
+interface AnimationGraphDef {
+    readonly params?: readonly GraphParamDef[];
+    readonly states: readonly GraphStateDef[];
+    readonly entry?: string;
+    readonly transitions?: readonly GraphTransitionDef[];
+    readonly clipEvents?: readonly GraphClipEventDef[];
+    readonly eventActions?: readonly ClipActionId[];
+    readonly events?: ClipEventReader | null;
+}
+type GraphStateListener = (graph: AnimationGraph, state: GraphState, other: GraphState) => void;
+type GraphClipEventListener = (graph: AnimationGraph, event: GraphEvent, action: ClipActionId, time: number) => void;
+declare const ANY_STATE = "any";
+declare const NO_STATE: GraphState;
+declare const GRAPH_CURRENT = 0;
+declare const GRAPH_PREVIOUS = 1;
+declare const GRAPH_TRANSITION = 2;
+declare const GRAPH_ELAPSED = 3;
+declare const GRAPH_BLEND_SECONDS = 4;
+declare const GRAPH_STATE_SECONDS = 5;
+declare const GRAPH_PRIORITY = 6;
+declare class AnimationGraph {
+    readonly state: Float64Array<ArrayBuffer>;
+    readonly values: Float64Array;
+    private readonly port;
+    private readonly paramNames;
+    private readonly paramKinds;
+    private readonly paramLookup;
+    private readonly stateNames;
+    private readonly stateLookup;
+    private readonly nodeKind;
+    private readonly nodeAction;
+    private readonly nodeSpace;
+    private readonly nodeX;
+    private readonly nodeY;
+    private readonly nodeDuration;
+    private readonly nodeSpeed;
+    private readonly nodeSpeedParam;
+    private readonly nodeSentSpeed;
+    private readonly nodeRestart;
+    private readonly blendIo;
+    private readonly blendSent;
+    private readonly blendTarget;
+    private readonly blendRate;
+    private readonly transitionTo;
+    private readonly transitionFrom;
+    private readonly transitionExit;
+    private readonly transitionSeconds;
+    private readonly transitionWarp;
+    private readonly transitionPriority;
+    private readonly transitionSelf;
+    private readonly conditionStart;
+    private readonly conditionParam;
+    private readonly conditionOp;
+    private readonly conditionValue;
+    private readonly candidateStart;
+    private readonly candidates;
+    private readonly eventNames;
+    private readonly eventIds;
+    private readonly eventActions;
+    private readonly reader;
+    private readonly ownsEvents;
+    private readonly clip;
+    private readonly enterListeners;
+    private readonly exitListeners;
+    private readonly eventListeners;
+    constructor(port: AnimationGraphPort, def: AnimationGraphDef);
+    param(name: string): GraphParam;
+    stateOf(name: string): GraphState;
+    clipEvent(name: string): GraphEvent;
+    paramName(param: GraphParam): string;
+    stateName(state: GraphState): string;
+    setFloat(param: GraphParam, value: number): void;
+    setBool(param: GraphParam, value: boolean): void;
+    trigger(param: GraphParam): void;
+    resetTrigger(param: GraphParam): void;
+    getFloat(param: GraphParam): number;
+    getBool(param: GraphParam): boolean;
+    currentState(): GraphState;
+    previousState(): GraphState;
+    inTransition(): boolean;
+    activeTransition(): number;
+    transitionProgress(): number;
+    stateSeconds(): number;
+    onEnter(state: GraphState, listener: GraphStateListener): void;
+    onExit(state: GraphState, listener: GraphStateListener): void;
+    onClipEvent(event: GraphEvent, listener: GraphClipEventListener): void;
+    update(dt: number): void;
+    forwardClipEvents(events: readonly ClipEvent[], count: number): void;
+    private settle;
+    private evaluate;
+    private passes;
+    private phase;
+    private fire;
+    private notify;
+    private crossNodes;
+    private drive;
+    private paramIndex;
+    private floatParam;
+    private stateIndex;
+}
+
+declare function wrapAngle(angle: number): number;
+declare function yawOfQuat(rotation: Float32Array | Float64Array, at: number): number;
+
+interface PortAssetReader {
+    take(asset: string): Promise<Uint8Array>;
+}
+declare const AXIS_X = 0;
+declare const AXIS_Y = 1;
+declare const AXIS_Z = 2;
+declare const CAST_SHADOW = 1;
+declare const RECEIVE_SHADOW = 2;
+type PortKeyEventType = "keydown" | "keyup";
+type PortPointerEventType = "pointerdown" | "pointerup";
+interface PortKeyEvent {
+    readonly type: PortKeyEventType;
+    readonly code: string;
+    readonly key: string;
+    readonly repeat: boolean;
+    preventDefault(): void;
+}
+interface PortPointerEvent {
+    readonly type: PortPointerEventType;
+    readonly button: number;
+    clientX: number;
+    clientY: number;
+    preventDefault(): void;
+}
+type PortKeyListener = (event: PortKeyEvent) => void;
+type PortPointerListener = (event: PortPointerEvent) => void;
+declare function keyOfCode(code: string): string;
+interface PortLightOptions {
+    readonly color?: number;
+    readonly intensity?: number;
+    readonly distance?: number;
+    readonly decay?: number;
+    readonly angle?: number;
+    readonly penumbra?: number;
+    readonly groundColor?: number;
+    readonly castShadow?: boolean;
+    readonly shadowMapSize?: number;
+    readonly width?: number;
+    readonly height?: number;
+}
+declare function clamp(value: number, min: number, max: number): number;
+declare function lerp(from: number, to: number, t: number): number;
+declare function damp(from: number, to: number, lambda: number, dt: number): number;
+declare function degToRad(degrees: number): number;
+declare function radToDeg(radians: number): number;
+declare function smoothstep(value: number, min: number, max: number): number;
+declare function euclideanModulo(n: number, m: number): number;
+declare const MathUtils: {
+    readonly clamp: typeof clamp;
+    readonly lerp: typeof lerp;
+    readonly damp: typeof damp;
+    readonly degToRad: typeof degToRad;
+    readonly radToDeg: typeof radToDeg;
+    readonly smoothstep: typeof smoothstep;
+    readonly euclideanModulo: typeof euclideanModulo;
+};
+declare class PortClipAction {
+    private readonly port;
+    readonly root: Entity;
+    readonly clip: string;
+    private action;
+    private loop;
+    private speed;
+    constructor(port: ThreePort, root: Entity, clip: string);
+    play(fadeSeconds?: number): this;
+    stop(fadeSeconds?: number): this;
+    fadeIn(seconds: number): this;
+    fadeOut(seconds: number): this;
+    reset(): this;
+    setLoop(repeat: boolean): this;
+    setEffectiveTimeScale(speed: number): this;
+    setEffectiveWeight(weight: number): this;
+    isRunning(): boolean;
+}
+declare class ThreePort {
+    readonly game: Game;
+    private readonly assets;
+    private readonly euler;
+    private readonly facing;
+    private readonly quat;
+    private readonly position;
+    private readonly keyActions;
+    private readonly keyDown;
+    private readonly keyUp;
+    private readonly keyDownListeners;
+    private readonly keyUpListeners;
+    private readonly pointerDownListeners;
+    private readonly pointerUpListeners;
+    private readonly pointerDown;
+    private readonly pointerUp;
+    private readonly pointerAt;
+    private pointerAction;
+    constructor(game: Game, assets?: PortAssetReader | null);
+    object(): Entity;
+    group(): Entity;
+    mesh(geometry: GeometryId, material: MaterialId, shadows?: number): Entity;
+    light(light: LightKind, options?: PortLightOptions): Entity;
+    perspectiveCamera(fovDegrees: number, near: number, far: number): Entity;
+    orthographicCamera(left: number, right: number, top: number, bottom: number, near: number, far: number): Entity;
+    add(parent: Entity, child: Entity): void;
+    detach(child: Entity): void;
+    setVisible(entity: Entity, visible: boolean): void;
+    positionAxis(entity: Entity, axis: number): number;
+    setPositionAxis(entity: Entity, axis: number, value: number): void;
+    addPositionAxis(entity: Entity, axis: number, delta: number): void;
+    scaleAxis(entity: Entity, axis: number): number;
+    setScaleAxis(entity: Entity, axis: number, value: number): void;
+    addScaleAxis(entity: Entity, axis: number, delta: number): void;
+    rotationAxis(entity: Entity, axis: number): number;
+    setRotationAxis(entity: Entity, axis: number, radians: number): void;
+    addRotationAxis(entity: Entity, axis: number, radians: number): void;
+    setRotation(entity: Entity, x: number, y: number, z: number): void;
+    copyPosition(target: Entity, source: Entity): void;
+    distanceSquared(a: Entity, b: Entity): number;
+    distance(a: Entity, b: Entity): number;
+    lookAt(entity: Entity, x: number, y: number, z: number): void;
+    lookAtEntity(entity: Entity, target: Entity): void;
+    model(path: string): Promise<ModelInfo>;
+    instantiate(model: ModelInfo): Entity;
+    texture(path: string): Promise<TextureId>;
+    withTexture(material: MaterialId, slot: MaterialTextureSlot, texture: Promise<TextureId>): MaterialId;
+    clipAction(root: Entity, clip: string): PortClipAction;
+    setScalar(entity: Entity, scale: number): void;
+    remove(parent: Entity, child: Entity): void;
+    keys(codes: readonly string[]): void;
+    addKeyListener(type: PortKeyEventType, listener: PortKeyListener): void;
+    addPointerListener(type: PortPointerEventType, listener: PortPointerListener): void;
+    dispatchInput(): void;
+    random(): number;
+    elapsedSeconds(): number;
+    private take;
+    private applyEuler;
+    private storeEuler;
+}
+
+declare function bakeThingGlb(compiled: CompiledThing, name: string): Uint8Array;
+
+type EffectWaitReason = "needs_break_bake" | "needs_sound" | "unsupported_here";
+interface WaitingEffect {
+    readonly index: number;
+    readonly kind: ThingEffectKind;
+    readonly reason: EffectWaitReason;
+}
+interface BrokenThing {
+    readonly model: ModelInfo;
+    readonly fracture: Uint8Array;
+}
+interface ThingEffectsInputs {
+    readonly camera: Entity;
+    readonly sounds?: ReadonlyMap<string, SoundId>;
+    readonly broken?: BrokenThing | null;
+}
+declare class ThingEffects implements GameSystem<Game> {
+    private readonly game;
+    readonly thing: Entity;
+    readonly effects: readonly ThingEffect[];
+    private readonly options;
+    readonly waiting: readonly WaitingEffect[];
+    readonly running: Uint8Array;
+    private readonly live;
+    private readonly offsets;
+    private readonly starts;
+    private readonly ends;
+    private readonly smokeActive;
+    private readonly at;
+    private readonly position;
+    private readonly rotation;
+    private smoke;
+    private medium;
+    private fluid;
+    private destructible;
+    private elapsed;
+    private playing;
+    private smokeDirty;
+    constructor(game: Game, thing: Entity, effects: readonly ThingEffect[], options: ThingEffectsInputs);
+    get seconds(): number;
+    play(): void;
+    stop(): void;
+    fixedUpdate(game: Game): void;
+    update(game: Game): void;
+    dispose(): void;
+    private make;
+    private spray;
+    private openSmoke;
+    private openFluid;
+    private place;
+    private advance;
+    private start;
+    private end;
+    private shatter;
+    private flushSmoke;
+    private stopAll;
+}
+declare function loadThingSounds(game: Game, effects: readonly ThingEffect[]): Promise<Map<string, SoundId>>;
+
+interface FlatThingPart {
+    readonly shape: ThingShapeKind;
+    readonly size: Vec3$2;
+    readonly radius: number;
+    readonly length: number;
+    readonly at: Vec3$2;
+    readonly turn: Vec3$2;
+    readonly material: string;
+    readonly combine: ThingCombine;
+    readonly mirror: ThingMirror;
+}
+declare const DEFAULT_PART_SIZE: Vec3$2;
+declare const DEFAULT_PART_RADIUS = 0.1;
+declare const DEFAULT_PART_LENGTH = 0.2;
+declare function flatPart(part: ThingPart): FlatThingPart;
+declare function shapeOfFlat(flat: Pick<FlatThingPart, "shape" | "size" | "radius" | "length">): ThingShape;
+declare function partOfFlat(id: string, name: string, flat: FlatThingPart): ThingPart;
+
+type PlaceCamera = "walk" | "orbit";
+declare const PLACE_VIEWER_SET = "world.set";
+declare const PLACE_VIEWER_CAMERA = "world.camera";
+declare const EYE_HEIGHT = 1.6;
+interface PlaceShown {
+    readonly doc: WorldDoc;
+    readonly tier: DeviceTier;
+}
+declare class PlaceViewerScene implements GameScene<Game> {
+    private readonly catalogue;
+    private readonly characterBytes;
+    readonly name = "place-viewer";
+    private game;
+    private box;
+    private readonly materials;
+    private readonly spawned;
+    private camera;
+    private walk;
+    private orbit;
+    private mode;
+    private shown;
+    private elapsed;
+    private readonly models;
+    private readonly loading;
+    private character;
+    private readonly things;
+    private peopleShown;
+    private readonly thingEntities;
+    private shownCount;
+    get shownVersion(): number;
+    get thingsShown(): readonly Entity[];
+    get cameraEntity(): Entity | null;
+    constructor(shown?: PlaceShown | null, catalogue?: SceneCatalogue, characterBytes?: ArrayBuffer | null);
+    get solids(): number;
+    get modelled(): number;
+    get hour(): number;
+    get people(): number;
+    get hasCharacter(): boolean;
+    enter(game: Game): void;
+    ready(): Promise<void>;
+    private level;
+    private load;
+    private arrived;
+    exit(): void;
+    show(shown: PlaceShown): void;
+    setThings(glbs: readonly Uint8Array[]): Promise<void>;
+    setCamera(mode: PlaceCamera, reset?: boolean): void;
+    update(game: Game): void;
+    private instance;
+    private placed;
+    private solid;
+    private clear;
+}
+
+declare const CROWD_CHARACTER_ASSET: string;
+declare const CROWD_CHARACTER_ITEM: "cimplify/base-character";
+declare const CATALOGUE_MODELS: {
+    readonly [kind: string]: string;
+};
+declare const LEVEL_FOR_TIER: {
+    readonly [T in DeviceTier]: PropLevel;
+};
+interface ModelCost {
+    readonly triangles: {
+        readonly [L in PropLevel]: number;
+    };
+    readonly cost: PhoneCost;
+}
+declare function modelRecipeFor(kind: string): PropRecipe | null;
+declare function hasModel(kind: string): boolean;
+declare function modelCost(kind: string): ModelCost | null;
+declare function kindsWithoutModels(): readonly string[];
+declare function blockoutKinds(doc: WorldDoc, placed: readonly {
+    readonly kind: string;
+}[]): readonly string[];
+
+declare const CELL_SOLID = 1;
+declare const CELL_ROAD = 2;
+declare const CELL_TAKEN = 4;
+declare const DEFAULT_CELL = 0.5;
+declare class OccupancyGrid {
+    readonly size: Point2;
+    readonly cell: number;
+    readonly columns: number;
+    readonly rows: number;
+    readonly cells: Uint8Array;
+    constructor(size: Point2, cell?: number);
+    index(x: number, z: number): number;
+    at(x: number, z: number): number;
+    centre(i: number): Point2;
+    forRect(at: Point2, footprint: Point2, yaw: number, visit: (i: number) => boolean): boolean;
+    mark(at: Point2, footprint: Point2, yaw: number, flags: number): void;
+    clear(at: Point2, footprint: Point2, yaw: number, blocking: number): boolean;
+    markRoad(road: Road): void;
+}
+declare function footprintOf(catalogue: SceneCatalogue, kind: string): {
+    readonly footprint: Point2;
+    readonly solid: boolean;
+};
+declare function markPlacement(grid: OccupancyGrid, catalogue: SceneCatalogue, placement: WorldPlacement): void;
+declare function gridOf(doc: WorldDoc, catalogue: SceneCatalogue, placements: readonly WorldPlacement[], cell?: number): OccupancyGrid;
+
+declare const SCATTER_ATTEMPTS = 12;
+declare function scatter(stroke: ScatterStroke, grid: OccupancyGrid, catalogue: SceneCatalogue): WorldPlacement[];
+declare function simplifyStroke(points: readonly Point2[], tolerance: number): Point2[];
+declare function applyGround(terrain: Pick<Terrain, "sculpt">, strokes: readonly GroundStroke[]): number;
+
+declare const SHOP_TAG = "shop";
+type WorldCheckId = "reachable" | "gates" | "inside";
+interface WorldCheck {
+    readonly id: WorldCheckId;
+    readonly ok: boolean;
+    readonly summary: string;
+    readonly offenders: readonly number[];
+}
+declare function walkFrom(grid: OccupancyGrid, starts: readonly Point2[]): Uint8Array;
+declare function checkWorld(doc: WorldDoc, grid: OccupancyGrid, catalogue: SceneCatalogue, placements: readonly WorldPlacement[]): WorldCheck[];
+
+type SkyPresetReach = "worldwide" | "regional";
+interface SkyPreset {
+    readonly weather: WeatherState;
+    readonly hour: number | null;
+    readonly reach: SkyPresetReach;
+}
+declare const SKY_PRESETS: {
+    readonly [P in Exclude<WeatherPreset, "real_sky">]: SkyPreset;
+};
+declare function weatherOf(preset: WeatherPreset, live?: WeatherState | null): WeatherState;
+declare function choosePreset(sky: WorldSky, preset: WeatherPreset): WorldSky;
+declare function hourAt(sky: WorldSky, elapsedSeconds: number): number;
+interface SkyTarget {
+    setWeather(state: WeatherState): void;
+    setTimeOfDay(hours: number, latitude?: number, dayOfYear?: number): void;
+}
+declare function applySky(target: SkyTarget, sky: WorldSky, elapsedSeconds: number, latitude?: number, live?: WeatherState | null): void;
+declare function clockText(hour: number): string;
+
+interface BuiltWorld {
+    readonly placements: readonly WorldPlacement[];
+    readonly people: readonly WorldPlacement[];
+    readonly grid: OccupancyGrid;
+    readonly weight: WorldWeight;
+    readonly checks: readonly WorldCheck[];
+}
+declare function buildWorld(doc: WorldDoc, catalogue?: SceneCatalogue, cell?: number): BuiltWorld;
+declare function peopleForTier(built: BuiltWorld, doc: WorldDoc, tier: DeviceTier): readonly WorldPlacement[];
+
+interface LiveBinding {
+    readonly name: string;
+    readonly binding: UiBinding;
+}
+interface LiveDoc {
+    readonly bindings: readonly LiveBinding[];
+    readonly music: MusicBed;
+    readonly crowd: CrowdDoc;
+}
+interface LiveFrame {
+    readonly seconds: number;
+    readonly tick: number;
+    readonly hour: number;
+    readonly people: number;
+}
+declare const LIVE_VALUES: {
+    readonly hour: "hour";
+    readonly time: "time";
+    readonly people: "people";
+    readonly cheer: "cheer";
+    readonly watchers: "watchers";
+};
+declare const START_MOMENT = "start";
+declare const CHEER_FULL_MOMENT = "cheer_full";
+declare const PLAYER_WATCHER = 0;
+declare const ONE_WATCHER = 1;
+declare function voteKey(id: string, field: string): string;
+declare function giftKey(gift: string): string;
+declare class LivePlayer {
+    private readonly ui;
+    readonly doc: LiveDoc;
+    readonly state: BindState;
+    readonly music: AdaptiveMusic;
+    readonly cheer: CheerMeter;
+    private readonly binder;
+    private readonly clock;
+    private readonly votes;
+    private elapsed;
+    private cheerFull;
+    private meter;
+    private meterShown;
+    private started;
+    private lastTick;
+    constructor(ui: GameUi$1 | null, doc: LiveDoc, conductor: Conductor, sounds: ReadonlyMap<string, SoundId>, stepsPerSecond: number);
+    get waitingFor(): readonly string[];
+    get votePolls(): readonly VotePoll[];
+    moment(name: string, tick: number): void;
+    gift(gift: string, tick?: number): number;
+    tapCheer(): void;
+    vote(index: number, choice: number, tick: number): void;
+    frame(frame: LiveFrame): void;
+    private updateVote;
+    private showCheer;
+    private mount;
+    private mountVote;
+    private mountCheer;
+}
+
+type AuthorValue = {
+    readonly kind: "uint";
+    readonly value: bigint;
+} | {
+    readonly kind: "int" | "float" | "color" | "ref";
+    readonly value: number;
+} | {
+    readonly kind: "bool";
+    readonly value: boolean;
+} | {
+    readonly kind: "str";
+    readonly value: string;
+} | {
+    readonly kind: "bytes";
+    readonly value: Uint8Array;
+};
+type VectorSchemaField = "uint" | "int" | "float" | "color" | "bool" | "str" | "bytes" | "ref";
+interface VectorSchemaType {
+    readonly key: number;
+    readonly name: string;
+    readonly parents: readonly number[];
+    readonly concrete: boolean;
+}
+interface VectorSchemaProp {
+    readonly key: number;
+    readonly owner: number;
+    readonly name: string;
+    readonly field: VectorSchemaField;
+}
+interface VectorSchema {
+    readonly types: readonly VectorSchemaType[];
+    readonly props: readonly VectorSchemaProp[];
+}
+interface AuthorRefusal {
+    readonly item: number | null;
+    readonly property: number | null;
+}
+
+declare const VECTOR_VIEWER: {
+    readonly open: "vector.open";
+    readonly edit: "vector.edit";
+    readonly image: "vector.image";
+    readonly undo: "vector.undo";
+    readonly redo: "vector.redo";
+    readonly checkpoint: "vector.checkpoint";
+    readonly show: "vector.show";
+    readonly play: "vector.play";
+    readonly seek: "vector.seek";
+    readonly input: "vector.input";
+    readonly hit: "vector.hit";
+    readonly save: "vector.save";
+};
+declare const VECTOR_REPORT: {
+    readonly ready: "vector.ready";
+    readonly document: "vector.document";
+    readonly refused: "vector.refused";
+    readonly saved: "vector.saved";
+    readonly pointer: "vector.pointer";
+    readonly picked: "vector.picked";
+};
+type VectorViewerAction = keyof typeof VECTOR_VIEWER;
+type VectorRef = number | {
+    readonly created: number;
+};
+type VectorValue = {
+    readonly kind: "uint";
+    readonly value: number | string;
+} | {
+    readonly kind: "int" | "float" | "color";
+    readonly value: number;
+} | {
+    readonly kind: "bool";
+    readonly value: boolean;
+} | {
+    readonly kind: "ref";
+    readonly value: number;
+} | {
+    readonly kind: "ref";
+    readonly created: number;
+} | {
+    readonly kind: "str";
+    readonly value: string;
+} | {
+    readonly kind: "bytes";
+    readonly value: readonly number[];
+};
+interface VectorPropValue {
+    readonly key: number;
+    readonly value: VectorValue;
+}
+type VectorOp = {
+    readonly op: "set";
+    readonly id: VectorRef;
+    readonly key: number;
+    readonly value: VectorValue;
+} | {
+    readonly op: "unset";
+    readonly id: VectorRef;
+    readonly key: number;
+} | {
+    readonly op: "insert";
+    readonly parent: VectorRef;
+    readonly type: number;
+    readonly props?: readonly VectorPropValue[];
+    readonly before?: VectorRef | null;
+} | {
+    readonly op: "add";
+    readonly owner: VectorRef;
+    readonly type: number;
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "remove";
+    readonly id: VectorRef;
+} | {
+    readonly op: "asset";
+    readonly type: number;
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "artboard";
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "bind";
+    readonly target: VectorRef;
+    readonly type: number;
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "text";
+    readonly parent: VectorRef;
+    readonly text: string;
+    readonly size: number;
+    readonly font?: VectorRef | null;
+    readonly color?: number;
+} | {
+    readonly op: "layout";
+    readonly parent: VectorRef;
+    readonly width: number;
+    readonly height: number;
+} | {
+    readonly op: "viewModel";
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "viewModelProperty";
+    readonly viewModel: VectorRef;
+    readonly type: number;
+    readonly props?: readonly VectorPropValue[];
+} | {
+    readonly op: "viewModelInstance";
+    readonly viewModel: VectorRef;
+    readonly props?: readonly VectorPropValue[];
+};
+interface VectorImagePlacement {
+    readonly parent: number;
+    readonly type: number;
+    readonly assetKey: number;
+    readonly props: readonly VectorPropValue[];
+}
+interface VectorImageRequest {
+    readonly type: number;
+    readonly props: readonly VectorPropValue[];
+    readonly place: VectorImagePlacement | null;
+}
+interface VectorView {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    readonly scale: number;
+}
+interface VectorShow {
+    readonly artboard: number;
+    readonly view: VectorView;
+}
+type VectorPlayKind = "animation" | "machine" | "stop";
+interface VectorPlayback {
+    readonly kind: VectorPlayKind;
+    readonly index: number;
+}
+type VectorSeekKind = Exclude<VectorPlayKind, "stop">;
+interface VectorSeek {
+    readonly kind: VectorSeekKind;
+    readonly index: number;
+    readonly seconds: number;
+}
+interface VectorHit {
+    readonly artboard: number;
+    readonly x: number;
+    readonly y: number;
+}
+interface VectorPicked extends VectorHit {
+    readonly item: number;
+}
+interface VectorInput {
+    readonly name: string;
+    readonly value: number | boolean;
+}
+type VectorPointerPhase = "down" | "move" | "up";
+interface VectorPointer {
+    readonly phase: VectorPointerPhase;
+    readonly u: number;
+    readonly v: number;
+}
+interface VectorRefused extends AuthorRefusal {
+    readonly action: VectorViewerAction;
+    readonly message: string;
+}
+interface VectorAuthorPort {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly refused: AuthorRefusal;
+    json(): string;
+    editJson(ops: string): readonly number[];
+    checkpoint(): void;
+    undo(): boolean;
+    redo(): boolean;
+    addAsset(type: number, contents: Uint8Array | null): number;
+    insert(parent: number, type: number, before?: number | null): number;
+    set(id: number, key: number, value: AuthorValue): void;
+    hit(artboard: number, x: number, y: number): number;
+    write(): Uint8Array;
+    bake(): Uint8Array;
+    close(): void;
+}
+interface VectorViewerPorts {
+    open(file: Uint8Array): VectorAuthorPort;
+    send(message: StudioOutgoing): void;
+    draw(file: Uint8Array): void;
+    show(show: VectorShow): void;
+    play(play: VectorPlayback): void;
+    seek(seek: VectorSeek): void;
+    input(input: VectorInput): void;
+}
+declare const BLANK_ARTBOARD_NAME = "Artboard";
+declare const BLANK_ARTBOARD_SIZE = 500;
+declare function blankVectorFile(width?: number, height?: number, name?: string): Uint8Array<ArrayBuffer>;
+declare class VectorMessageError extends Error {
+    constructor(message: string);
+}
+declare function authorValue(value: VectorValue): AuthorValue;
+declare function readImageRequest(body: unknown): VectorImageRequest;
+declare function readShow(body: unknown): VectorShow;
+declare function readPlayback(body: unknown): VectorPlayback;
+declare function readInput(body: unknown): VectorInput;
+declare class VectorEditSession {
+    private readonly ports;
+    private author;
+    private merging;
+    constructor(ports: VectorViewerPorts);
+    get opened(): boolean;
+    handle(message: StudioMessage): void;
+    close(): void;
+    private open;
+    private live;
+    private run;
+    private image;
+    private changed;
+    private refuse;
+}
+
+declare const AVATAR_OUTPUT_FLOATS: number;
+declare const AVATAR_MOODS: readonly ["neutral", "happy", "angry", "sad", "relaxed", "surprised"];
+declare const AVATAR_SPRING_GROUPS: readonly ["hair", "accessories", "clothing"];
+declare const AVATAR_SLOTS: readonly ["head", "hair_cover", "face", "ears", "neck", "top", "bottom", "full_body", "outerwear", "feet", "hands", "back", "assistive"];
+type AvatarMood = (typeof AVATAR_MOODS)[number];
+type AvatarSpringGroup = (typeof AVATAR_SPRING_GROUPS)[number];
+type AvatarSlot = (typeof AVATAR_SLOTS)[number];
+type AvatarFieldValue = number | string | boolean | null;
+type AvatarOp = {
+    readonly op: "set";
+    readonly field: string;
+    readonly value: AvatarFieldValue;
+} | {
+    readonly op: "face" | "body";
+    readonly index: number;
+    readonly value: number;
+} | {
+    readonly op: "identity";
+    readonly cidp: string;
+} | {
+    readonly op: "expression";
+    readonly name: string;
+    readonly terms: Readonly<Record<string, number>>;
+} | {
+    readonly op: "remove_expression";
+    readonly name: string;
+} | {
+    readonly op: "spring";
+    readonly group: AvatarSpringGroup;
+    readonly stiffness?: number;
+    readonly drag?: number;
+    readonly gravity?: number;
+    readonly gravity_dir?: readonly [number, number, number];
+    readonly hit_radius?: number;
+} | {
+    readonly op: "wear";
+    readonly slot: AvatarSlot;
+    readonly part: string;
+} | {
+    readonly op: "unwear";
+    readonly slot: AvatarSlot;
+} | {
+    readonly op: "assistive";
+    readonly kind: string;
+    readonly side?: string;
+    readonly part?: number;
+} | {
+    readonly op: "clear_assistive";
+};
+interface AvatarSchemaField {
+    readonly name: string;
+    readonly group: string;
+    readonly kind: {
+        readonly type: string;
+        readonly min?: number;
+        readonly max?: number;
+        readonly unit?: string;
+        readonly names?: readonly string[];
+    };
+    readonly default: AvatarFieldValue;
+    readonly description: string;
+}
+interface AvatarSchema {
+    readonly fields: readonly AvatarSchemaField[];
+    readonly face_shapes: readonly string[];
+    readonly spring_groups: readonly string[];
+    readonly slots: readonly string[];
+    readonly assistive: readonly string[];
+    readonly sides: readonly string[];
+    readonly max_expressions: number;
+    readonly max_terms: number;
+    readonly ops: readonly string[];
+}
+interface AvatarDocument {
+    readonly format: number;
+    readonly basis: number;
+    readonly identity: string;
+    readonly face: readonly number[];
+    readonly body: readonly number[];
+    readonly fields: Readonly<Record<string, AvatarFieldValue>>;
+    readonly expressions: readonly {
+        readonly name: string;
+        readonly terms: Readonly<Record<string, number>>;
+    }[];
+    readonly springs: Readonly<Record<AvatarSpringGroup, {
+        stiffness: number;
+        drag: number;
+        gravity: number;
+        gravity_dir: number[];
+        hit_radius: number;
+    }>>;
+    readonly wear: Readonly<Partial<Record<AvatarSlot, string>>>;
+    readonly assistive: readonly {
+        readonly kind: string;
+        readonly side: string;
+        readonly part: number;
+    }[];
+}
+declare const ENGINE_AVATAR_EXPORT_NAMES: readonly ["engine_avatar_open", "engine_avatar_close", "engine_avatar_registers", "engine_avatar_json", "engine_avatar_schema", "engine_avatar_edit_json", "engine_avatar_error", "engine_avatar_undo", "engine_avatar_redo", "engine_avatar_write", "engine_avatar_identity", "engine_avatar_performer_create", "engine_avatar_performer_destroy", "engine_avatar_performer_outputs", "engine_avatar_say", "engine_avatar_hear", "engine_avatar_feel", "engine_avatar_express", "engine_avatar_track", "engine_avatar_perform"];
+type AvatarExports = Readonly<Record<(typeof ENGINE_AVATAR_EXPORT_NAMES)[number], (...args: number[]) => number>>;
+declare function engineAvatarExports(runtime: EngineRuntime): AvatarExports | null;
+declare class AvatarDesigner {
+    private readonly runtime;
+    private readonly exports;
+    private readonly handle;
+    private readonly scratch;
+    private closed;
+    constructor(runtime: EngineRuntime, exports: AvatarExports, file?: Uint8Array);
+    static schema(runtime: EngineRuntime, exports: AvatarExports): AvatarSchema;
+    private live;
+    private registers;
+    private check;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    get expressionCount(): number;
+    document(): AvatarDocument;
+    edit(ops: readonly AvatarOp[]): number;
+    undo(): boolean;
+    redo(): boolean;
+    write(): Uint8Array;
+    identity(): Uint8Array;
+    performer(sampleRate: number): AvatarPerformer;
+    close(): void;
+}
+declare class AvatarPerformer {
+    private readonly runtime;
+    private readonly exports;
+    private readonly handle;
+    private readonly scratch;
+    private readonly tracker;
+    private outputs;
+    private arkitView;
+    private presetView;
+    private buffer;
+    private samples;
+    private sampleCapacity;
+    private closed;
+    constructor(runtime: EngineRuntime, exports: AvatarExports, handle: number);
+    private view;
+    private live;
+    private check;
+    say(line: string): number;
+    hear(samples: Float32Array): void;
+    feel(mood: AvatarMood, weight?: number): void;
+    express(expression: number, weight?: number): void;
+    track(values: ArrayLike<number> | null): void;
+    step(micros: number): Float32Array;
+    get arkit(): Float32Array;
+    get presets(): Float32Array;
+    close(): void;
+}
+
+declare const AVATAR_DESIGN: {
+    readonly open: "avatar.design.open";
+    readonly edit: "avatar.design.edit";
+    readonly undo: "avatar.design.undo";
+    readonly redo: "avatar.design.redo";
+    readonly save: "avatar.design.save";
+};
+declare const AVATAR_DESIGN_REPORT: {
+    readonly ready: "avatar.design.ready";
+    readonly document: "avatar.design.document";
+    readonly refused: "avatar.design.refused";
+    readonly saved: "avatar.design.saved";
+};
+type AvatarDesignAction = keyof typeof AVATAR_DESIGN;
+interface AvatarDesignReady {
+    readonly designing: boolean;
+    readonly schema: AvatarSchema | null;
+}
+interface AvatarDesignState {
+    readonly document: AvatarDocument;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+}
+interface AvatarDesignRefused {
+    readonly action: AvatarDesignAction;
+    readonly message: string;
+}
+interface AvatarDesignerPort {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    document(): AvatarDocument;
+    edit(ops: readonly AvatarOp[]): number;
+    undo(): boolean;
+    redo(): boolean;
+    write(): Uint8Array;
+    identity(): Uint8Array;
+    close(): void;
+}
+interface AvatarDesignPorts {
+    open(file: Uint8Array): AvatarDesignerPort;
+    send(message: StudioOutgoing): void;
+    show(identity: Uint8Array): void;
+}
+/** One character open for editing in a Studio viewer: every change is one engine edit, all or none, with one undo step. */
+declare class AvatarDesignSession {
+    private readonly ports;
+    private designer;
+    constructor(ports: AvatarDesignPorts);
+    get opened(): boolean;
+    handle(message: StudioMessage): void;
+    close(): void;
+    private live;
+    private run;
+    private changed;
+}
+
+declare class EngineMemory implements ComponentMemory {
+    private readonly runtime;
+    private readonly pointers;
+    private readonly sizes;
+    constructor(runtime: EngineRuntime);
+    owns(array: TypedArray): boolean;
+    allocate<S extends Scalar>(scalar: S, length: number): ArrayFor<S>;
+    release(): void;
+}
+
+declare class EngineSession {
+    readonly exports: EngineExports;
+    readonly memory: EngineMemory;
+    private readonly runtime;
+    world: number;
+    registerWords: Uint32Array<ArrayBuffer>;
+    registerFloats: Float32Array<ArrayBuffer>;
+    descWords: Uint32Array<ArrayBuffer>;
+    descFloats: Float32Array<ArrayBuffer>;
+    contactA: Uint32Array<ArrayBuffer>;
+    contactB: Uint32Array<ArrayBuffer>;
+    contactBegan: Uint8Array<ArrayBuffer>;
+    contacts: number;
+    snapshots: WorldSnapshots | null;
+    private commandWords;
+    private commandFloats;
+    private commandCapacity;
+    private pending;
+    private columns;
+    constructor(runtime: EngineRuntime, memory: EngineMemory);
+    bind(columns: TransformColumns): void;
+    open(desc: PhysicsWorldDesc): void;
+    private createRollback;
+    require(): number;
+    check(code: number, what: string): number;
+    command(op: number, body: number): number;
+    get commandPayload(): Float32Array;
+    get commandPayloadWords(): Uint32Array;
+    get symbols(): Readonly<Record<string, unknown>>;
+    get buffer(): ArrayBuffer;
+    discard(): void;
+    flush(): void;
+    step(): void;
+    close(): void;
+    private bindLayout;
+}
+
+declare const ENGINE_RAGDOLL_POLICY_EXPORT_NAMES: readonly ["engine_ragdoll_mjcf", "engine_ragdoll_observe", "engine_ragdoll_act", "engine_ragdoll_policy_create", "engine_ragdoll_policy_destroy", "engine_ragdoll_policy_control"];
+type PolicyExports = Readonly<Record<(typeof ENGINE_RAGDOLL_POLICY_EXPORT_NAMES)[number], (...args: number[]) => number>>;
+declare const POLICY_ACTION_MODES: readonly ["orientation", "axes"];
+declare const POLICY_DRIVE_PRESETS: readonly ["soft", "firm", "stiff"];
+type PolicyActionMode = (typeof POLICY_ACTION_MODES)[number];
+type PolicyDrivePreset = (typeof POLICY_DRIVE_PRESETS)[number];
+interface RagdollPolicySpec {
+    readonly mode?: PolicyActionMode;
+    readonly preset?: PolicyDrivePreset;
+    readonly substeps?: number;
+    readonly goal?: number;
+    readonly ground?: number;
+    readonly feet?: readonly number[];
+}
+declare function policyObservationSize(joints: number, spec: RagdollPolicySpec): number;
+declare function policyActionSize(joints: number): number;
+declare class RagdollPolicy {
+    private readonly session;
+    private readonly exports;
+    private readonly handle;
+    private readonly goal;
+    private closed;
+    constructor(session: EngineSession, exports: PolicyExports, handle: number, goalSize: number);
+    control(goal?: ArrayLike<number>): void;
+    destroy(): void;
+}
+declare class RagdollPolicies {
+    private readonly session;
+    private readonly exports;
+    private readonly spec;
+    constructor(session: EngineSession, exports: PolicyExports);
+    static of(session: EngineSession): RagdollPolicies | null;
+    private world;
+    mjcf(ragdoll: Ragdoll, spec?: RagdollPolicySpec): string;
+    observe(ragdoll: Ragdoll, spec: RagdollPolicySpec, goal: Float32Array, out: Uint32Array): number;
+    act(ragdoll: Ragdoll, spec: RagdollPolicySpec, action: Float32Array): void;
+    create(ragdoll: Ragdoll, spec: RagdollPolicySpec, heads: readonly Uint32Array[]): RagdollPolicy;
+}
+
+export { BOX_SX as $, ANCHOR_ROLL as A, type AvatarDesignAction as B, type AvatarDesignPorts as C, type AvatarDesignReady as D, type AvatarDesignRefused as E, AvatarDesignSession as F, type AvatarDesignState as G, AvatarDesigner as H, type AvatarDesignerPort as I, type AvatarDocument as J, type AvatarFieldValue as K, AvatarModels as L, type AvatarMood as M, type AvatarOp as N, AvatarPerformer as O, type AvatarRig as P, type AvatarRole as Q, AvatarRoster as R, type AvatarRosterOptions as S, type AvatarRosterPorts as T, type AvatarSchema as U, type AvatarSchemaField as V, type AvatarSlot as W, type AvatarSpringGroup as X, BLANK_ARTBOARD_NAME as Y, BLANK_ARTBOARD_SIZE as Z, BOX_ROTATION as _, ANCHOR_SCALE as a, type FaceCapture as a$, BOX_SY as a0, BOX_SZ as a1, BOX_X as a2, BOX_Y as a3, BOX_Z as a4, BUTTON_MIDDLE as a5, BUTTON_PRIMARY as a6, BUTTON_SECONDARY as a7, BoxBatch as a8, type BrokenThing as a9, DEFAULT_CLIP_MS as aA, DEFAULT_FLY_ROTATION_KEYS as aB, DEFAULT_MOVEMENT_KEYS as aC, DEFAULT_PART_LENGTH as aD, DEFAULT_PART_RADIUS as aE, DEFAULT_PART_SIZE as aF, DEFAULT_STACK_LIMIT as aG, DayClock as aH, type DaylightOptions as aI, DragControls as aJ, type DragControlsOptions as aK, type DragPicker as aL, type DropOutcome as aM, DropTable as aN, ECONOMY_IDENTIFIER as aO, ENGINE_AVATAR_EXPORT_NAMES as aP, ENGINE_RAGDOLL_POLICY_EXPORT_NAMES as aQ, EXPRESSION_COUNT as aR, EYE_HEIGHT as aS, type EconomyViolation as aT, type EconomyViolationCode as aU, type EffectWaitReason as aV, type Exemplar as aW, FIRST_RANK as aX, type FaceAnchor as aY, FaceAnchors as aZ, type FaceCameraPort as a_, type BuiltWorld as aa, CAST_SHADOW as ab, CATALOGUE_MODELS as ac, CATALOGUE_PROP_RECIPES as ad, CATALOGUE_RECIPE_SOURCES as ae, CELL_ROAD as af, CELL_SOLID as ag, CELL_TAKEN as ah, CHEER_FULL_MOMENT as ai, CROWD_CHARACTER_ASSET as aj, CROWD_CHARACTER_ITEM as ak, type CameraControl as al, CameraPose as am, type CaptureContext as an, type CapturePolicy as ao, type ChallengePort as ap, type CheckpointOptions as aq, Checkpoints as ar, type ClipPorts as as, ClipRecorder as at, type ControlViewOptions as au, type CounterOpener as av, CtxTurnRoom as aw, DAY_HOUR as ax, DAY_INDEX as ay, DEFAULT_CELL as az, ANCHOR_STRIDE as b, METRIC_WIDTH as b$, FaceExpression as b0, type FaceExpressionId as b1, type FaceIdentitySource as b2, FaceLandmark as b3, type FaceLandmarkId as b4, FaceSession as b5, type FaceSessionOptions as b6, FirstPersonControls as b7, type FirstPersonControlsOptions as b8, type FlatThingPart as b9, type GyroLookOptions as bA, HOURS_PER_DAY as bB, HeadPose as bC, type HeadPoseAxis as bD, INVENTORY_SNAPSHOT_STRIDE as bE, IdentityCaptureError as bF, Inventory as bG, KitError as bH, type KitErrorCode as bI, type KitGateName as bJ, type KitGateResult as bK, LANDMARK_COUNT as bL, LAUNCH_CLIPS as bM, LAUNCH_FILES as bN, LAUNCH_HAIR_STYLES as bO, LAUNCH_ITEMS as bP, LAUNCH_RIG as bQ, LEVEL_FOR_TIER as bR, LIVE_VALUES as bS, Leaderboard as bT, type LeaderboardOptions as bU, type LiveBinding as bV, type LiveDoc as bW, type LiveFrame as bX, LivePlayer as bY, type LocalReplay as bZ, type LookMode as b_, FlyControls as ba, type FlyControlsOptions as bb, type FlyRotationKeys as bc, FriendChallenges as bd, GRAPH_BLEND_SECONDS as be, GRAPH_CURRENT as bf, GRAPH_ELAPSED as bg, GRAPH_PREVIOUS as bh, GRAPH_PRIORITY as bi, GRAPH_STATE_SECONDS as bj, GRAPH_TRANSITION as bk, type GraphBlendStateDef as bl, type GraphClipEventDef as bm, type GraphClipEventListener as bn, type GraphClipStateDef as bo, type GraphConditionDef as bp, type GraphConditionOp as bq, type GraphEvent as br, type GraphParam as bs, type GraphParamDef as bt, type GraphParamKind as bu, type GraphState as bv, type GraphStateDef as bw, type GraphStateListener as bx, type GraphTransitionDef as by, GyroLookControls as bz, ANCHOR_X as c, REPLAY_FORMAT_VERSION as c$, type ManifestCurrency as c0, type ManifestEconomy as c1, type ManifestEconomyInput as c2, type ManifestGrant as c3, type ManifestGrantKind as c4, type ManifestItem as c5, type ManifestOdds as c6, type ManifestOffer as c7, type ManifestOfferOutcome as c8, type ManifestRule as c9, POSE_COUNT as cA, PROP_LEVELS as cB, PROP_RECIPES as cC, type PlaceCamera as cD, type PlaceShown as cE, PlaceViewerScene as cF, type PlanarSnapshotOptions as cG, PlanarSnapshotSync as cH, PointerLockControls as cI, type PointerLockControlsOptions as cJ, type PolicyActionMode as cK, type PolicyDrivePreset as cL, type PortAssetReader as cM, PortClipAction as cN, type PortKeyEvent as cO, type PortKeyEventType as cP, type PortKeyListener as cQ, type PortLightOptions as cR, type PortPointerEvent as cS, type PortPointerEventType as cT, type PortPointerListener as cU, PremiumStore as cV, type PremiumStorePorts as cW, type PresentedOffer as cX, type PropLevel as cY, type PropRecipe as cZ, RECEIVE_SHADOW as c_, MapControls as ca, MathUtils as cb, type ModelCost as cc, MovementAxes as cd, type MovementKeys as ce, NO_ACHIEVEMENT as cf, NO_CHECKPOINT as cg, NO_ITEM as ch, NO_OBJECTIVE as ci, NO_SLOT as cj, NO_STATE as ck, NPC_STRIDE as cl, NPC_WALKING as cm, NpcSchedules as cn, type NpcSpawn as co, ONE_WATCHER as cp, type ObjectiveDecl as cq, Objectives as cr, OccupancyGrid as cs, OrbitControls as ct, type OrbitControlsOptions as cu, PLACE_VIEWER_CAMERA as cv, PLACE_VIEWER_SET as cw, PLAYER_WATCHER as cx, POLICY_ACTION_MODES as cy, POLICY_DRIVE_PRESETS as cz, ANCHOR_Y as d, type VectorPicked as d$, REPLAY_RATES as d0, RagdollPolicies as d1, RagdollPolicy as d2, type RagdollPolicySpec as d3, RankedScores as d4, type ReplayClip as d5, ReplayClipRecorder as d6, type ReplayDeclaration as d7, type ReplayManifest as d8, ReplayRecorder as d9, type ShopOffer as dA, ShopResult as dB, type ShopResultCode as dC, type SkyPreset as dD, type SkyPresetReach as dE, type SkyTarget as dF, SlotPool as dG, type SlottedGenre as dH, type SoundRecipe as dI, TEXTURE_RECIPES as dJ, type TextureRecipe as dK, ThingEffects as dL, type ThingEffectsInputs as dM, ThreePort as dN, TrackballControls as dO, type TrackballControlsOptions as dP, UNLIMITED_STOCK as dQ, VECTOR_REPORT as dR, VECTOR_VIEWER as dS, type VectorAuthorPort as dT, VectorEditSession as dU, type VectorHit as dV, type VectorImagePlacement as dW, type VectorImageRequest as dX, type VectorInput as dY, VectorMessageError as dZ, type VectorOp as d_, type ReplayRecorderOptions as da, type ReplayRun as db, type ReplaySimulation as dc, SCATTER_ATTEMPTS as dd, SCORE as de, SCORE_BEST as df, SCORE_COMBO as dg, SCORE_COMBO_LEFT as dh, SCORE_ELAPSED as di, SCORE_REMAINING as dj, SCORE_TIME_UP as dk, SHOP_TAG as dl, SKY_PRESETS as dm, SNAPSHOT_CHANNEL as dn, SOUND_RECIPES as dp, START_MOMENT as dq, type ScheduleStop as dr, type ScoreDirection as ds, ScoreHud as dt, type ScoreHudNames as du, ScoreTimer as dv, type ScoreTimerOptions as dw, SeekBot as dx, type SeekBotOptions as dy, Shop as dz, ANY_STATE as e, keyOfCode as e$, type VectorPlayKind as e0, type VectorPlayback as e1, type VectorPointer as e2, type VectorPointerPhase as e3, type VectorPropValue as e4, type VectorRef as e5, type VectorRefused as e6, type VectorSchema as e7, type VectorSchemaField as e8, type VectorSchemaProp as e9, buildPropGlb as eA, buildWorld as eB, captureFace as eC, checkWorld as eD, index$1 as eE, choosePreset as eF, clockText as eG, daylight as eH, decodeReplay as eI, deviceQuaternion as eJ, economyManifest as eK, economyToml as eL, encodeReplay as eM, encodeWav as eN, engineAvatarExports as eO, flatPart as eP, footprintOf as eQ, frameDamping as eR, index$2 as eS, index as eT, giftKey as eU, gridOf as eV, hasModel as eW, hourAt as eX, identityCapturePolicy as eY, identityFromCapture as eZ, judgeEconomy as e_, type VectorSchemaType as ea, type VectorSeek as eb, type VectorSeekKind as ec, type VectorShow as ed, type VectorValue as ee, type VectorView as ef, type VectorViewerAction as eg, type VectorViewerPorts as eh, type WaitingEffect as ei, type WaveDecl as ej, Waves as ek, type WavesOptions as el, type WorldCheck as em, type WorldCheckId as en, addSceneCamera as eo, applyGround as ep, applySky as eq, arkitWeight as er, auditEconomy as es, auditManifestEconomy as et, authorValue as eu, bakeThingGlb as ev, beats as ew, blankVectorFile as ex, blockoutKinds as ey, buildIdentityCharacter as ez, ARKIT_COUNT as f, kindsWithoutModels as f0, kitPublicationGates as f1, loadThingSounds as f2, markPlacement as f3, modelCost as f4, modelRecipeFor as f5, oddsMatch as f6, offerMatches as f7, partOfFlat as f8, peopleForTier as f9, walledArena as fA, weatherOf as fB, wrapAngle as fC, yawOfQuat as fD, playFromReplay as fa, playable as fb, policyActionSize as fc, policyObservationSize as fd, propBounds as fe, propTriangles as ff, quiltTexture as fg, readImageRequest as fh, readInput as fi, readPlayback as fj, readShow as fk, remainingCimples as fl, replayInputs as fm, scatter as fn, shapeOfFlat as fo, showcase as fp, simplifyStroke as fq, simulateReplay as fr, slottedRunner as fs, slottedShootout as ft, stateDigest as fu, staticBox as fv, synthesizeSound as fw, synthesizeTexture as fx, voteKey as fy, walkFrom as fz, AVATAR_DESIGN as g, AVATAR_DESIGN_REPORT as h, AVATAR_MOODS as i, AVATAR_OUTPUT_FLOATS as j, AVATAR_SLOTS as k, AVATAR_SPRING_GROUPS as l, AXIS_X as m, AXIS_Y as n, AXIS_Z as o, type AchievementDecl as p, type AchievementSlot as q, Achievements as r, type AiApply as s, AiInbox as t, type AiWatch as u, AnimationGraph as v, type AnimationGraphDef as w, type AnimationGraphPort as x, type ArenaOptions as y, type AvatarCharacter as z };