@cimplify/sdk 0.108.0 → 0.110.2

package/dist/game.d.mts

@@ -0,0 +1,3546 @@
+import { G as GameError } from './session-grant-CJ27DwrT.mjs';
+export { d as GameErrorCode } from './session-grant-CJ27DwrT.mjs';
+import { f as GameUi, I as InputActions, F as AgentSpawn, H as ArchetypeHandle, J as GameAi, K as SmartObjectSpawn, T as TargetSpawn, L as EaseId, O as InputTap } from './game-Bx8onkhX.mjs';
+export { A as ActionId, Q as Animation, U as AnimationOptions, W as AxisBinding, X as BreakCause, Y as BreakEvent, Z as ButtonBinding, i as CELL_CLASSES, k as CHEMISTRY_GROUPS, l as CHEMISTRY_REFUSALS, m as CHEMISTRY_REFUSAL_TEXT, n as CellBox, o as CellClass, p as CellProbe, _ as Channel, C as Chemistry, h as ChemistryEvent, r as ChemistryGroup, t as ChemistryParticles, u as ChemistryRefusal, g as ChemistryRegion, v as ChemistryVessel, $ as Clip, a0 as ClipDesc, a1 as ClipPlayerId, a2 as ClipTrack, b as DefineResult, D as Delivery, a3 as Destructible, a4 as DestructibleDesc, a5 as DrainSource, a6 as Ease, a7 as FRAME_PHASE_NAMES, a8 as FrameInput, a9 as FramePhase, aa as FramePhases, G as Game, e as GameNet, ab as GameOptions, a as GameUiHost, ac as GestureOptions, ad as HapticPattern, ae as HudSlot, af as HudSlotKind, ag as HudSlotLayout, ah as InputDevice, ai as InputDeviceId, aj as LongPressGesture, ak as LoopbackOptions, al as LoopbackTransport, w as MaterialInfo, M as MessageReader, am as MessageSchema, d as MessageType, an as MessageWriter, ao as NO_UI_ACTION, N as NatureOptions, ap as OrientationState, aq as PinchGesture, ar as PointerDelta, P as PointerFilter, c as PointerPhase, as as PointerState, at as QuantizedField, au as REACTIVE_DEFAULTS, av as RECORDED_EVENT_BYTES, x as ReactionInfo, aw as ReactiveFluid, ax as ReactiveFluidDesc, ay as ReactiveGrid, az as ReactiveHobDesc, aA as ReactiveMediumLook, aB as ReactivePlume, aC as ReactiveSpecies, aD as ReactiveStats, z as RegionOptions, B as RegionStats, aE as Repeat, aF as RepeatMode, R as RoomTransport, aG as STAGE_TIME, aH as STAGE_X, aI as STAGE_Y, aJ as STAGE_Z, aK as ScratchArena, aL as ScratchCapacity, S as SeededRandom, aM as SnapshotBuffer, aN as SwipeGesture, aO as TapGesture, aP as TweenId, aQ as TweenTarget, aR as TweenTargetId, aS as UiActionId, aT as UiValue, aU as ValueSlot, V as VesselState, aV as WheelState, aW as WireField, aX as WireScalar, aY as createGame, aZ as createReactivePlume, a_ as createReactiveStats, a$ as drainSource, b0 as ease, b1 as easeInPlace, b2 as quantized } from './game-Bx8onkhX.mjs';
+import { bq as KernelEngine, bQ as Vec2, V as Vec3, s as GeometryDesc, N as NodeId, i as GeometryId, j as MaterialId, k as MaterialDesc, a5 as NodeDesc, bR as ShapeDesc, a8 as TextStyleDesc, a9 as PickHit, bS as VehiclePort, bT as BehaviourDecl, bU as ConsiderationDecl, bV as InputDecl, bW as ActionDecl, bX as SightDecl, bY as SteeringDecl, bZ as SkillDecl, b_ as NeedDecl, b$ as ScheduleBlockDecl, az as ArchetypeDecl, c0 as CurveDecl, c1 as BuiltinInput, c2 as AI_EVENT_WORDS, c3 as AI_MAX_GAME_SLOTS, c4 as AI_NONE, c5 as AiEventKind, c6 as AiEventKindCode, ax as AiPort, ay as AiWorldOptions, c7 as BUILTIN_INPUTS, c8 as PHASE_IDLE, c9 as PHASE_RECOVER, ca as PHASE_STRIKE, cb as PHASE_WINDUP, aL as NavPort, aM as NavDesc, A as AudioPort, c as AudioCapabilities, b as AssetSource, l as AnalyserSettings, cc as ToneMapping, v as TextureId, u as TextureDesc, I as RenderTargetId, ac as RenderPassId, ae as PostChainId, cd as PostEffectDesc, bp as WorldStreamingPort, o as SceneryPort, ce as SceneryBodyPort, T as TerrainPort, cf as KeyframeDesc, cg as KeyframeStats } from './backend-gUCzs5Kg.mjs';
+export { ch as AGENT_ARRIVED, ci as AGENT_IDLE, cj as AGENT_LOST, ck as AGENT_MOVING, cl as AGENT_ON_LINK, cm as AGENT_REQUESTING, cn as AGENT_STRIDE, co as AGENT_X, cp as AUDIO_PREVIEW_SUFFIX, aO as AgentDesc, e as AnalyserDesc, cq as AssetPriority, cr as AtmosphereDesc, cs as AxisMotion, ct as BRUSH, cu as BatchBuffers, cv as BlendDesc, cw as BlendEquation, cx as BlendFactor, cy as Blending, bh as BodyDesc, cz as BodyKind, B as BrushOp, cA as CLOTH_FEATURE, cB as CastShapeKind, bn as CharacterControllerDesc, bo as CharacterMove, aA as ChemistryEngine, al as ClipActionId, n as ClothInfo, m as ClothPort, cC as CloudDesc, bb as ColliderDesc, cD as ColorSpace, cE as CompareFunction, C as CompoundPartDesc, bm as ContactRuleDesc, cF as ContactRuleTable, cG as CurvePoint, b0 as CurveTable, cH as DEFAULT_COLLIDER_CLASS, cI as DEFAULT_PANNER, cJ as DISTANCE_MODELS, aE as DestructionPort, D as DeviceTier, cK as DistanceModel, aQ as DriverDesc, cL as EmitterCollision, E as EmitterDesc, a1 as EmitterId, cM as EmitterShape, cN as EngineCurveDesc, aa as EnvironmentDesc, cO as FILTER_KINDS, cP as FLUID_CAP_SIMULATION, cQ as FLUID_CAP_SURFACE, cR as FRAME_ALPHA_SLOT, cS as FRAME_NOW_MS_SLOT, cT as FRAME_SECONDS_SLOT, cU as FRAME_STEP_SECONDS_SLOT, cV as FRAME_TICK_SLOT, cW as FftAnalyser, d as FilterDesc, cX as FilterKind, a as FixedStepLoop, ao as FluidPort, cY as FogDesc, a7 as FontId, a6 as FontSource, aH as FractureMesh, aI as FractureOptions, cZ as FracturePiece, c_ as FractureResult, F as FrameTime, c$ as GEAR_AUTO, d0 as GEAR_NEUTRAL, d1 as GEAR_REVERSE, aJ as GPU_PASS_NAMES, G as GameBackend, r as GameSurface, d2 as GearboxDesc, d3 as GeometryGroup, d4 as GlobalIlluminationDesc, d5 as GlobalIlluminationMode, d6 as GlslSource, d7 as GpuBindGroupId, d8 as GpuBindingDesc, d9 as GpuBlend, da as GpuBlendComponent, db as GpuBlendFactor, dc as GpuBufferDesc, dd as GpuBufferId, de as GpuBufferUsage, df as GpuComputePipelineDesc, dg as GpuDispatchOptions, dh as GpuDrawOptions, di as GpuHook, dj as GpuPipelineId, dk as GpuRect, dl as GpuRenderPipelineDesc, dm as GpuSamplerDesc, dn as GpuSamplerId, dp as GpuSceneResource, dq as GpuSceneTexture, dr as GpuShaderId, a4 as GpuStats, ds as GpuTextureCopy, dt as GpuTextureDesc, du as GpuTextureFormat, dv as GpuTextureId, dw as GpuTextureUsage, dx as GpuTopology, q as GraphicsCapabilities, p as GraphicsPort, an as GraphicsStats, dy as Interpolation, dz as JOINT_AXES, dA as JointAxisName, bl as JointDesc, dB as JointDrive, dC as JointLoad, bi as JointPort, ak as KitTint, dD as LaneSpec, dE as LeanDesc, bN as LightKind, dF as LinesMaterialDesc, dG as LodRange, aG as LoopOptions, dH as MAX_CCD_SUBSTEPS, dI as MAX_COLLIDER_CLASSES, dJ as MAX_PGS_ITERATIONS, dK as MAX_SOLVER_ITERATIONS, dL as MEDIUM_DEFAULTS, dM as MEDIUM_MAX, dN as MEDIUM_MAX_EDGE, dO as MatcapMaterialDesc, dP as MaterialCommon, a0 as MaterialStateDesc, $ as MaterialTextureSlot, dQ as MaterialTint, ag as MediumDesc, dR as MediumId, dS as MediumPort, ah as MediumVolume, x as ModelId, aj as ModelInfo, y as ModelUpgrade, dT as MorphTargetDesc, dU as NOISE, dV as NO_CONTACT_RULE, dW as NO_LINK, dX as NodeCommon, dY as NodeKindDesc, g as NoiseKind, b7 as OceanCascades, b6 as OceanDesc, aN as OffMeshLinkDesc, dZ as POSE_DIR_X, d_ as POSE_DIR_Z, d$ as POSE_LANE, e0 as POSE_SPEED, e1 as POSE_STRIDE, e2 as POSE_X, e3 as POSE_Z, P as PannerDesc, e4 as PhysicalMaterialDesc, bc as PhysicsPort, bP as PhysicsWorldDesc, e5 as PointsMaterialDesc, e6 as PolygonOffsetDesc, ad as PostChainDesc, e7 as PrimitiveShapeDesc, b8 as PuddleOptions, aw as Quat, e8 as RAGDOLL_POSE_STRIDE, e9 as REACTIVE_FEATURE, bk as Ragdoll, ea as RagdollBoneDesc, bj as RagdollDesc, eb as RagdollDrive, ec as RagdollRoot, R as RawGpu, aS as RayHit, aR as RayQuery, aB as ReactivePort, ai as RenderPassDesc, ab as RenderTargetDesc, ed as RenderTargetFormat, b9 as RippleOptions, aP as RoadGraphDesc, ee as SCENERY_REGISTER, ef as SCENERY_REGISTER_WORDS, eg as SCENERY_REQUEST_SLOTS, eh as SEA_STATES, ei as SH_COEFFICIENT_FLOATS, ej as SIGNAL_AMBER, ek as SIGNAL_GREEN, el as SIGNAL_RED, em as SOA_EXPORT_NAMES, en as SOFT_BODY_FEATURE, aX as Scalar, b5 as SeaState, eo as ShaderMaterialDesc, ep as ShaderSource, eq as ShadowDesc, a2 as ShadowParamsDesc, er as ShadowType, aV as ShapeCastQuery, es as Side, et as SignalSpec, eu as SkeletonDesc, ev as SkyDesc, bf as SleepThresholds, aT as SoaEngine, ew as SoaExports, b2 as SoftBodyInfo, b1 as SoftBodyPort, be as SolverSettings, ex as SphereOverlap, ey as SpriteMaterialDesc, ez as StandardMaterialDesc, eA as StencilDesc, eB as StencilOperation, eC as TERRAIN_REGISTER, eD as TIME_SCALE_SLOT, eE as TexelData, eF as TexelFormat, eG as TextAlign, eH as TextDirection, eI as TextureEncode, eJ as TextureFilter, eK as TextureKind, z as TextureRegion, eL as TextureSource, eM as TextureTransform, w as TextureUpgrade, eN as TextureWrap, eO as ToonMaterialDesc, eP as Transparency, eQ as UniformDesc, eR as UniformType, eS as UnlitMaterialDesc, eT as VECTOR_SURFACE_CAPS, eU as VECTOR_SURFACE_EDGES, eV as VECTOR_SURFACE_TIERS, f as Vec3Like, eW as Vec3Tuple, eX as Vec4, J as VectorAssetId, K as VectorSurfaceDesc, Y as VectorSurfaceEvent, Q as VectorSurfaceId, X as VectorSurfacePhase, U as VectorSurfacePlay, eY as VectorSurfacePort, W as VectorSurfaceSeek, Z as VectorSurfaceStats, _ as VectorSurfaceTier, av as Vehicle, au as VehicleDesc, eZ as VertexAttributeDesc, t as VertexData, H as VideoFrameSource, a3 as ViewOffset, e_ as VolumetricCloudsDesc, e$ as VolumetricFogDesc, f0 as VolumetricsDesc, f1 as WHEEL_CENTER, f2 as WHEEL_FORCE_LAT, f3 as WHEEL_FORCE_LONG, f4 as WHEEL_GROUND, f5 as WHEEL_LENGTH, f6 as WHEEL_LOAD, f7 as WHEEL_OMEGA, f8 as WHEEL_POINT, f9 as WHEEL_SLIP, fa as WHEEL_SLIP_ANGLE, fb as WHEEL_SPIN, fc as WHEEL_STEER, fd as Water, b4 as WaterDesc, fe as WaterFlow, ba as WaterSample, ff as WaveDesc, af as WeatherState, fg as WgslSource, fh as WheelDesc, fi as analyserSettings, bL as bindChemistryEngine, fj as bindKernelEngine, fk as bindSoaEngine, fl as createGpuStats, aK as createPickHit, fm as createVectorSurfaceStats, fn as detuneRate, fo as encodeVehicleDesc, fp as kernelIsa, fq as materialTint, fr as mediumIndex, fs as mediumTexel, ft as mediumTexelCount, fu as peakCurve, fv as sampleCurve, fw as seaDesc } from './backend-gUCzs5Kg.mjs';
+import { b as TableSchema, a as EntityTable, u as u32, k as f32, F as FixedArray, v as vec4, l as vec3, m as Each, n as vec2, o as i32, p as Kernel, q as Selection, R as RouteDevice, G as GpuDeviceClass, K as KernelRunner, r as quat, E as Entity, s as NavPath, t as CraftPresetName, w as CraftBodyShape, x as CraftDesc, y as CraftTuning, H as HullSource, A as Aircraft, B as Boat, z as Helicopter, T as Transforms, c as PrefetchLayerDesc } from './world-qekkXjJv.mjs';
+export { J as AeroCurveDesc, L as AircraftOptions, M as AircraftPresetName, O as AreaEffect, Q as AreaEffectDesc, U as ArrayField, V as AssistDesc, X as BOAT_SHEET, Y as BOAT_STEER, Z as BOAT_THROTTLE, _ as BatchGraphics, $ as BatchNav, a0 as BatchPhysics, a1 as BehaviourNode, a2 as BoatOptions, a3 as BoatPresetName, a4 as CRAFT_CHANNELS, a5 as CRAFT_PRESETS, a6 as CRAFT_TELEMETRY_WORDS, a7 as CellInfo, a8 as Comparison, a9 as ComponentFields, aa as ComponentSchema, ab as ComponentStore, C as ComponentType, ac as ComputeCode, ad as ComputeDiagnostic, ae as ComputeFrame, af as ComputeRoute, ag as CpuBackend, ah as Craft, ai as CraftOptions, aj as CraftSystem, ak as CraftWheelDesc, al as CrumpleOptions, am as DEFAULT_PREFETCH_CELL, D as DespawnListener, an as Dev, ao as DrainedEvent, ap as ENGINE_COMPUTE_EXPORT_NAMES, aq as EntityCursor, j as EntityTableOptions, ar as EventChannel, as as EventFieldKind, at as EventFields, au as EventPayload, av as FLIGHT_BRAKE, aw as FLIGHT_FLAPS, ax as FLIGHT_GEAR, ay as FLIGHT_PITCH, az as FLIGHT_ROLL, aA as FLIGHT_THROTTLE, aB as FLIGHT_TILT, aC as FLIGHT_YAW, aD as FLOW_COST_BLOCKED, aE as FLOW_COST_ONE, aF as Falloff, aG as FieldName, aH as FieldSpec, aI as FlightMode, aJ as FlowField, aK as FlowFieldDesc, aL as FlowNav, aM as FlowSample, aN as FlowSteer, aO as FlowSteerDesc, aP as FlowStep, aQ as FoilDesc, aR as GPU_KERNEL_EXPORT_NAMES, aS as HelicopterOptions, aT as HelicopterPresetName, aU as HingeDesc, aV as InspectorPool, I as InspectorReadout, aW as Inventory, aX as Joined, aY as KernelCell, aZ as KernelDataReport, a_ as KernelEntity, a$ as KernelFeed, b0 as KernelHandles, b1 as KernelMachine, b2 as KernelMismatch, b3 as KernelMode, b4 as KernelOptions, b5 as KernelOverlap, b6 as KernelPriority, b7 as KernelRouteReport, b8 as KernelRouter, b9 as KernelServiceAudio, ba as KernelServiceChemistry, bb as KernelServiceGraphics, bc as KernelServiceSources, bd as KernelServiceUi, be as KernelServiceVoxels, bf as KernelSet, bg as KernelSettings, bh as KernelSpawnReport, bi as KernelSystemSpec, bj as KernelSystems, bk as KernelTarget, bl as KernelVoxel, bm as KernelWork, bn as KernelWorld, bo as KernelWorldPort, bp as List, bq as MAX_AERO_TABLE, br as MAX_CRAFT_WHEELS, bs as MAX_FOILS, bt as MAX_HULL_POINTS, bu as MAX_HULL_RESOLUTION, bv as MAX_PREFETCH_LEVELS, bw as MAX_ROTORS, bx as MAX_THRUSTERS, by as MixDesc, bz as NO_CHANNEL, bA as NO_ENTITY, bB as NO_REF, N as Nav, bC as NavStep, bD as NearestFeatureOptions, bE as Neighbours, bF as OverlapInfo, bG as PathBatch, bH as PathBatchDesc, e as Physics, f as PhysicsOptions, bI as PickBatch, bJ as PickBatchDesc, bK as PickInfo, bL as PrefetchDistance, d as PrefetchItemDesc, P as PrefetchLayer, bM as PrefetchLevelDesc, bN as PresetOptions, bO as Query, bP as QueryOptions, bQ as QueryWhere, bR as Queue, bS as ROTOR_COLLECTIVE, bT as ROTOR_CYCLIC_PITCH, bU as ROTOR_CYCLIC_ROLL, bV as ROTOR_ENGINE, bW as ROTOR_PEDAL, bX as RayBatch, bY as RayBatchDesc, bZ as RayHitInfo, b_ as Ref, b$ as RigidBody, c0 as RotorDesc, c1 as RoutePin, c2 as Rows, c3 as ScalarField, c4 as ScalarName, c5 as SeaOptions, c6 as SlotsView, S as SoftBodies, i as SoftBody, h as SoftBodyOptions, g as SoftBodyShape, c7 as SoftCollider, c8 as SoftPlastic, c9 as Status, ca as SweepHitInfo, cb as TELEMETRY_AIRSPEED, cc as TELEMETRY_ALPHA, cd as TELEMETRY_APPARENT_WIND, ce as TELEMETRY_BANK, cf as TELEMETRY_CLIMB, cg as TELEMETRY_CONTACTS, ch as TELEMETRY_GEAR, ci as TELEMETRY_GROUND_EFFECT, cj as TELEMETRY_PITCH, ck as TELEMETRY_PLANING, cl as TELEMETRY_ROTOR, cm as TELEMETRY_SPEED, cn as TELEMETRY_SPOOL, co as TELEMETRY_STALLED, cp as TELEMETRY_SUBMERGED, cq as TELEMETRY_THRUST, cr as TableColumns, cs as TableField, ct as ThrusterDesc, cu as Transform, cv as Vec2Columns, cw as Vec2View, cx as Vec3Columns, cy as Vec3View, cz as Vec4Columns, cA as Vec4View, cB as VectorField, cC as VoxelInfo, cD as WaterControls, W as World, cE as WorldColliderOptions, cF as WorldPackReader, cG as WorldPrefetchOptions, cH as WorldStream, cI as WorldStreamOptions, cJ as WorldStreamStats, cK as WorldStreamer, cL as action, cM as add, cN as applyForce, cO as applyImpulse, cP as autoKernel, cQ as behaviour, cR as chemistryAt, cS as chooseDevice, cT as clamp, cU as compiledKernel, cV as computeLogLine, cW as condition, cX as configureKernels, cY as craftConstant, cZ as craftMix, c_ as craftMixWith, c$ as cross, d0 as crossoverRows, d1 as defineComponent, d2 as despawn, d3 as dev, d4 as dist, d5 as distSq, d6 as div, d7 as dot, d8 as entityGeneration, d9 as entityIndex, da as events, db as fields, dc as flow, dd as flowCost, de as groundHeight, df as hash32, dg as invert, dh as isKernel, di as kernel, dj as kernelMachine, dk as leaveBelowRows, dl as len, dm as lenSq, dn as lerp, dp as lineOfSight, dq as list, dr as listPool, ds as mul, dt as nativeTwinOf, du as navNext, dv as negate, dw as noise2, dx as noise3, dy as normalize, dz as onGpu, dA as overlap, dB as pick, dC as pickRows, dD as playClip, dE as playSound, dF as programDigest, dG as qaxis, dH as qconj, dI as qmul, dJ as qrotate, dK as queue, dL as rand01, dM as raycast, dN as readList, dO as scale, dP as selector, dQ as sequence, dR as setAnchor, dS as setClipWeight, dT as setDefaultKernelEngine, dU as setIkTarget, dV as setInstance, dW as setInstanceColour, dX as setKernelWorld, dY as setVelocity, dZ as setVoxel, d_ as smoothstep, d$ as spawn, e0 as spawnInto, e1 as spawnOverflow, e2 as sub, e3 as sweep, e4 as symbol, e5 as voxelAt, e6 as within, e7 as worldPrefetchLayer } from './world-qekkXjJv.mjs';
+import { K as KernelMeta } from './library-DXYaMFhi.mjs';
+export { a as KernelArgMeta, b as KernelLibrary, c as KernelSlotMeta, L as LibraryMeta, r as readKernelLibrary } from './library-DXYaMFhi.mjs';
+import { s as LockstepKernelHost, t as LockstepLink, D as LockstepSession } from './lockstep-BLf6dglI.mjs';
+import { B as Box3, S as Sphere, t as CameraProjection } from './terrain-C-XC1Oui.mjs';
+export { u as CameraProjectionOptions, v as Cylindrical, D as DomInputOptions, F as Frustum, G as GamepadLike, w as GamepadPoller, x as GamepadSource, y as GrassOptions, I as InputSurface, L as LayerOptions, N as NodeMatrixSource, z as Plane, A as PlanetOptions, s as PointerLockDocument, q as PointerLockTarget, E as ProjectionMode, i as Proposal, H as Ray, J as ScatterColumns, K as ScatterRules, O as Spherical, T as Terrain, Q as TerrainOptions, U as TerrainRecipe, V as Triangle, W as attachDomInput, l as chemistryAiSection, m as chemistryAiToml, X as exitPointerLock, Y as isPointerLocked, Z as noise, _ as openPlanet, $ as openTerrain, p as proposalText, o as proposeReaction, a0 as requestOrientationPermission, a1 as requestPointerLock, a2 as screenOrientationDegrees, a3 as wheelPixels } from './terrain-C-XC1Oui.mjs';
+import { b as Graphics, l as PredictorOptions, m as SceneryEdit } from './fluid-DLlEj2cs.mjs';
+export { B as BatchedDraw, n as CLOTH_DEFAULTS, o as ClothCollider, i as ClothOptions, p as ClothPinning, h as ClothShape, j as ClothSheet, C as Cloths, D as DEFAULT_HORIZONS, q as DEFAULT_PREFETCH_BUDGET, g as Fluid, r as FluidColliderOptions, d as FluidDesc, e as FluidEmitterDesc, c as FluidGridDesc, s as FluidLook, F as FluidMaterial, t as FluidShape, f as GamePrefetch, G as GameScene, a as GameSystem, u as GraphicsScenery, I as InstancedBatch, N as NEXT_SCENE_BUDGET, v as PredictorStats, P as PrefetchAssets, E as PrefetchEntryState, w as PrefetchEye, x as PrefetchReach, y as PrefetchStreamOptions, Q as QuatLike, z as ReachGrid, A as ReachNav, H as Renderable, J as SCENERY_CHUNK_EXTENSION, K as SCENERY_LOAD_SHARE, L as SCENERY_MANIFEST_MAGIC, M as SCENERY_MANIFEST_VERSION, O as SCENERY_MANIFEST_VERSION_PARTS, T as SCENERY_NEED_SHARE, U as SCENERY_PART_COARSE, V as SCENERY_PART_FINE, W as SCENERY_PART_MIDDLE, X as SCENERY_PART_WHOLE, Y as SCENERY_TIER_RADII, S as SceneManager, Z as ScenePrefetch, _ as ScenePrefetchDesc, $ as Scenery, a0 as SceneryAssetReader, a1 as SceneryDrapeOptions, a2 as SceneryGrid, a3 as SceneryLoadOptions, a4 as SceneryManifest, a5 as SceneryMotionOptions, a6 as ScenerySource, a7 as SceneryStandIn, a8 as SceneryStats, a9 as SplatBodyOptions, aa as StreamPredictor, ab as parseSceneryManifest, ac as prefetchCone, ad as sceneryEntryRows, ae as sceneryFirstView, af as sceneryPartDrawLevel, ag as sceneryPartReach, ah as sceneryPrefetchItems, ai as sceneryTierRadii } from './fluid-DLlEj2cs.mjs';
+export { d as HOT_EXPORT, H as HotModule, a as HotReloader, b as HotReport, c as HotScenes, e as acceptHot } from './hot-DH3nOhQD.mjs';
+export { jH as SafeAreaInsets, lc as SurfaceSafeAreaListener } from './local-D8_I6UeL.mjs';
+export { D as DEFAULT_WORKLET_SIZES, a as ENGINE_MIX_RATE, E as EngineGraphicsOptions, b as WORKLET_PROCESSOR_NAME, c as WORKLET_PROCESSOR_SOURCE, d as WorkletAudio, W as WorkletAudioOptions, e as WorkletSizes, s as sharedMemoryAvailable } from './features-CZB4rmcD.mjs';
+export { a as AnalyserId, A as Audio, B as BusId, E as EmitterFeedId, b as EmitterFields, c as EmitterOptions, I as ImpulseDesc, d as ImpulseResponse, R as REVERB_PRESETS, e as ReverbDesc, f as ReverbPreset, S as SoundId, g as StreamId, V as VoiceId, h as encodePanner, i as generateImpulse, j as impulseFrames, v as validateLoop, w as writeImpulse } from './audio-DhvyjqdA.mjs';
+import { T as TickRoomTransport } from './tick-transport-C8QEh8Uw.mjs';
+export { R as RealtimeRoom, a as TickRoomOptions, b as TickRoomSource, j as joinTickRoom } from './tick-transport-C8QEh8Uw.mjs';
+export { I as InMemoryNetworkMemory, N as NetworkMemory, R as RoomClient, a as RoomClientOptions, d as RoomPhase, e as RoomPose, f as RoomPresence, g as RoomStats, S as StorageNetworkMemory } from './client-hTKbCuhG.mjs';
+export { R as RoomDialer } from './link-BUTqGmyi.mjs';
+export { W as WebSocketDialer, a as WebTransportDialer } from './web-transport-aYEqXMd9.mjs';
+import { E as EngineRuntime } from './runtime-BRWfkf_q.mjs';
+import { N as NetworkHint } from './network-ZXLD7l1b.mjs';
+export { F as FeedPrefetchLevel, a as NetworkKind, b as PREFETCH_DEPTH, P as PrefetchDepth, p as prefetchDepth } from './network-ZXLD7l1b.mjs';
+import { C as CatalogueKind, S as SceneCatalogue } from './catalogue-DzrTXP3v.mjs';
+export { a as SCENE_CATALOGUE_VERSION, b as STARTER_CATALOGUE, c as SceneAxis, d as SceneKindMeta, e as SceneKinds, f as SceneSizeClass, g as SceneVec3, h as StarterKind, i as extendCatalogue } from './catalogue-DzrTXP3v.mjs';
+import { b as StudioOutgoing, a as StudioMessage } from './studio-CowqWqez.mjs';
+export { C as CANNOT_REWIND, N as NOT_RECORDING, T as TIMELINE_PREFIX, a as TIMELINE_REPORT, b as TIMELINE_TOPIC, c as TimelineMoment, d as TimelineProof, e as TimelineRefused, f as TimelineState } from './timeline-protocol-hp6e8zFB.mjs';
+import './schema-BrWxzKp6.mjs';
+import './ui-DwHicuFv.mjs';
+import './vars-Dc_PrhBK.mjs';
+import './state-replica-stMtdkVD.mjs';
+
+declare const MEDIA_VOLUME_FEATURE = "media_volume_1";
+
+declare const GAME_API_VERSION = "0.1.0";
+declare const NO_RESOURCE = 0;
+declare const ALL_LAYERS = 4294967295;
+
+declare function engineLockstepHost(engine: KernelEngine | null): LockstepKernelHost | null;
+declare function allocateLockstepState(engine: KernelEngine | null, bytes: number): Uint8Array | null;
+
+type LoopElement = "f32" | "f64" | "i32" | "u32" | "u8";
+type LoopFold = "+" | "-" | "*" | "/" | "min" | "max";
+type LoopSchedule = "auto" | "kernel" | "js";
+type LoopArray = Float32Array | Float64Array | Int32Array | Uint32Array | Uint8Array;
+type RowArray = Int32Array | Uint32Array;
+interface LoopField {
+    readonly kind: LoopElement;
+    readonly read: boolean;
+    readonly write: boolean;
+    readonly bind: number;
+    readonly offset: number;
+    readonly gather: number;
+}
+interface LoopTable {
+    readonly bind: number;
+    readonly kind: LoopElement;
+}
+interface LoopPayload {
+    readonly meta: KernelMeta;
+    readonly program: string;
+    readonly fields: readonly LoopField[];
+    readonly bindings: number;
+    readonly scalars: number;
+    readonly offsets: number;
+    readonly gathers: number;
+    readonly tables?: readonly LoopTable[];
+    readonly folds: readonly LoopFold[];
+    readonly origin: number;
+    readonly minRows: number;
+}
+interface LoopEngine {
+    readonly memory: {
+        readonly buffer: ArrayBufferLike;
+    };
+    alloc(bytes: number, align: number): number;
+    free(at: number, bytes: number, align: number): void;
+    load(at: number, bytes: number): number;
+    unload?(program: number): void;
+    runRegion(program: number, columns: number, rows: number, count: number, args: number, argWords: number): number;
+}
+interface LoopSettings {
+    readonly schedule?: LoopSchedule;
+    readonly chunkRows?: number;
+    readonly enabled?: boolean;
+}
+interface LoopStats {
+    readonly kernelRuns: number;
+    readonly jsRuns: number;
+    readonly decided: "trial" | "kernel" | "js";
+    readonly kernelNsPerRow: number;
+    readonly jsNsPerRow: number;
+}
+declare const LOOP_MAX_REGION_ROWS: number;
+declare function setLoopEngine(next: LoopEngine | null): void;
+declare function loopEngineOf(kernels: KernelEngine | null): LoopEngine | null;
+declare function configureLoops(next: LoopSettings): void;
+declare function vmLoopEngine(arenaBytes?: number): LoopEngine;
+declare class LoweredLoop {
+    readonly a: (LoopArray | null)[];
+    readonly s: Float64Array;
+    readonly o: Float64Array;
+    readonly g: (RowArray | null)[];
+    readonly r: Float64Array;
+    private readonly payload;
+    private readonly columns;
+    private readonly slotColumn;
+    private readonly slotStorage;
+    private readonly reductionColumn;
+    private readonly argWords;
+    private readonly argScalar;
+    private readonly argTable;
+    private readonly slotTable;
+    private readonly tableAt;
+    private readonly tableBytes;
+    private readonly argHalves;
+    private readonly argView;
+    private program;
+    private owner;
+    private ownerGeneration;
+    private arena;
+    private capacity;
+    private columnAt;
+    private columnViews;
+    private descriptorAt;
+    private argsAt;
+    private descriptor;
+    private argsView;
+    private sources;
+    private sourceArray;
+    private sourceStart;
+    private sourceRows;
+    private targets;
+    private targetRows;
+    private stamps;
+    private stamp;
+    private phase;
+    private pending;
+    private pendingAt;
+    private pendingRows;
+    private kernelMs;
+    private kernelRows;
+    private kernelRuns;
+    private jsMs;
+    private jsRows;
+    private jsRuns;
+    constructor(payload: LoopPayload);
+    get stats(): LoopStats;
+    run(n: number): boolean;
+    after(): void;
+    private decide;
+    release(): void;
+    private detach;
+    private attach;
+    private admissible;
+    private distinct;
+    private overlaps;
+    private spanStart;
+    private spanEnd;
+    private stageTables;
+    private execute;
+    private inPlace;
+    private reserve;
+    private source;
+    private target;
+    private prepare;
+    private finish;
+}
+interface LoopProbe {
+    enter(): number;
+    exit(loop: string, at: number, rows: number): void;
+}
+declare const LOOP_PROBE_GLOBAL = "__cimplify_loop_probe";
+declare function loopProbe(): LoopProbe | null;
+declare function lowerLoop(payload: string): LoweredLoop;
+
+type RecordedArg = number | readonly number[];
+interface KernelRecording {
+    readonly rows: number;
+    readonly columns: Readonly<Record<string, readonly number[]>>;
+    readonly storage: Readonly<Record<string, string>>;
+    readonly args: Readonly<Record<string, RecordedArg>>;
+    readonly objectiveArgs: Readonly<Record<string, RecordedArg>>;
+    readonly steps: number;
+    readonly warmup: number;
+}
+interface KernelRecordingOptions {
+    readonly args?: Readonly<Record<string, RecordedArg>>;
+    readonly objectiveArgs?: Readonly<Record<string, RecordedArg>>;
+    readonly steps: number;
+    readonly warmup?: number;
+    readonly fields?: readonly string[];
+}
+declare function kernelRecording<S extends TableSchema>(table: EntityTable<S>, options: KernelRecordingOptions): KernelRecording;
+
+type f64 = number;
+declare function f64(x: number | bigint | boolean): f64;
+type u64 = bigint;
+declare function u64(x: number | bigint | boolean): u64;
+declare function toU32(x: number | bigint | boolean): number;
+declare function f64Bits(lo: number, hi: number): f64;
+declare function u64Words(lo: number, hi: number): u64;
+declare function popcnt(x: number | bigint): number;
+declare function clz(x: number | bigint): number;
+declare function ctz(x: number | bigint): number;
+declare function rotl<T extends number | bigint>(x: T, by: number): T;
+declare function rotr<T extends number | bigint>(x: T, by: number): T;
+declare function bitExtract<T extends number | bigint>(x: T, offset: number, count: number): T;
+declare function bitInsert<T extends number | bigint>(base: T, value: T, offset: number, count: number): T;
+declare function morton2(x: number, y: number): number;
+declare function morton3(x: number, y: number, z: number): number;
+declare function morton2Wide(x: number, y: number): u64;
+declare function morton3Wide(x: number, y: number, z: number): u64;
+declare function unmorton2(code: number | bigint): {
+    x: number;
+    y: number;
+};
+declare function unmorton3(code: number | bigint): {
+    x: number;
+    y: number;
+    z: number;
+};
+
+type KernelArrayKind = "f32" | "i32" | "u32";
+type ArrayData<K extends KernelArrayKind> = K extends "f32" ? Float32Array : K extends "i32" ? Int32Array : Uint32Array;
+interface KernelArray<K extends KernelArrayKind = KernelArrayKind> {
+    readonly name: string;
+    readonly kind: K;
+    readonly length: number;
+    readonly data: ArrayData<K>;
+}
+type KernelTable<K extends KernelArrayKind> = ArrayData<K>;
+declare function kernelArray<K extends KernelArrayKind>(name: string, desc: {
+    readonly kind: K;
+    readonly length: number;
+}): KernelArray<K>;
+declare function rowSum<T extends number>(value: T): T;
+declare function rowMin<T extends number>(value: T): T;
+declare function rowMax<T extends number>(value: T): T;
+declare function rowCount(when?: boolean): u32;
+declare function rowArgMin(value: number): u32;
+declare function rowArgMax(value: number): u32;
+declare function rowPrefixSum<T extends number>(value: T, exclusive?: boolean): T;
+type RowScanOp = "add" | "mul" | "min" | "max" | "and" | "or" | "xor";
+declare function rowScan<T extends number>(value: T, op: RowScanOp, exclusive?: boolean): T;
+declare function rowRecur<T extends number>(a: T, b: T, exclusive?: boolean): T;
+declare function rowFeedback(b: f32, a1: f32, a2: f32): f32;
+declare function rowPhase(increment: f32, period: f32, exclusive?: boolean): f32;
+declare function rowPhase64(increment: f32, period: f32, exclusive?: boolean): f64;
+declare function histogram(bins: KernelArray<"u32" | "i32">, bin: u32): void;
+declare function scatterAdd(target: KernelArray, index: u32, value: f32 | number): void;
+declare function compactRows(list: KernelArray<"u32">): u32;
+declare function sortRows(list: KernelArray<"u32">, key: number, descending?: boolean): u32;
+declare function topRows(list: KernelArray<"u32">, key: number, k: u32, smallest?: boolean): u32;
+declare function groupRows(key: number): {
+    readonly group: u32;
+    readonly groups: u32;
+};
+declare function dedupRows(key: number): {
+    readonly first: boolean;
+    readonly distinct: u32;
+};
+
+declare function f32Bits(x: number): number;
+declare function f32From(bits: number): number;
+declare function exp$1(x: number): number;
+declare function exp2(x: number): number;
+declare function log$1(x: number): number;
+declare function log2$1(x: number): number;
+declare function pow$1(xIn: number, yIn: number): number;
+declare function sin$1(x: number): number;
+declare function cos$1(x: number): number;
+declare function tan$1(x: number): number;
+declare function atan2$1(y: number, x: number): number;
+declare function atan$1(x: number): number;
+declare function asin$1(xIn: number): number;
+declare function acos$1(xIn: number): number;
+declare const FMATH_CONSTANTS: {
+    readonly EXP2_HI: number[];
+    readonly EXP2_LO: number[];
+    readonly EXP2_POLY: number[];
+    readonly EXP_POLY: number[];
+    readonly INV_LN2_N: number;
+    readonly SHIFT: number;
+    readonly SHIFT_SCALED: number;
+    readonly EXP_LOW: -104;
+    readonly EXP_HIGH: 89;
+    readonly EXP2_LOW: -151;
+    readonly EXP2_HIGH: 129;
+    readonly INV_C: number[];
+    readonly LOG_C: number[];
+    readonly LOG2_C: number[];
+    readonly LN2: number;
+    readonly LOG_POLY: number[];
+    readonly LOG2_POLY: number[];
+    readonly POW_POLY: number[];
+    readonly POW_SIGN_BIAS: number;
+    readonly POW_OVERFLOW: number;
+    readonly POW_SATURATE: number;
+    readonly POW_UNDERFLOW: -150;
+    readonly LOG_OFF: 1060306944;
+    readonly SUBNORMAL_SCALE: 8388608;
+    readonly SUBNORMAL_BIAS: number;
+    readonly MIN_NORMAL: 8388608;
+    readonly INFINITY_BITS: 2139095040;
+    readonly ONE_BITS: 1065353216;
+    readonly F32_MAX: number;
+    readonly HPI_INV: number;
+    readonly HPI: number;
+    readonly PI63: number;
+    readonly COS_C1: number;
+    readonly COS_C2: number;
+    readonly COS_C3: number;
+    readonly COS_C4: number;
+    readonly SIN_S1: number;
+    readonly SIN_S2: number;
+    readonly SIN_S3: number;
+    readonly LARGE_TOP: number;
+    readonly QUADRANT_ROUND: 8388608;
+    readonly INV_PIO4: number[];
+    readonly QUARTER_PI: number;
+    readonly HALF_PI: number;
+    readonly TAN_PI_8: number;
+    readonly ATAN_COEFFS: number[];
+};
+
+declare const fmath_FMATH_CONSTANTS: typeof FMATH_CONSTANTS;
+declare const fmath_exp2: typeof exp2;
+declare const fmath_f32Bits: typeof f32Bits;
+declare const fmath_f32From: typeof f32From;
+declare namespace fmath {
+  export { fmath_FMATH_CONSTANTS as FMATH_CONSTANTS, acos$1 as acos, asin$1 as asin, atan$1 as atan, atan2$1 as atan2, cos$1 as cos, exp$1 as exp, fmath_exp2 as exp2, fmath_f32Bits as f32Bits, fmath_f32From as f32From, log$1 as log, log2$1 as log2, pow$1 as pow, sin$1 as sin, tan$1 as tan };
+}
+
+declare function scalbn(x: number, n: number): number;
+declare function sin(x: number): number;
+declare function cos(x: number): number;
+declare function tan(x: number): number;
+declare function atan(x: number): number;
+declare function atan2(y: number, x: number): number;
+declare function asin(x: number): number;
+declare function acos(x: number): number;
+declare function exp(x: number): number;
+declare function log(x: number): number;
+declare function log2(x: number): number;
+declare function pow(x: number, y: number): number;
+
+declare const fmath64_acos: typeof acos;
+declare const fmath64_asin: typeof asin;
+declare const fmath64_atan: typeof atan;
+declare const fmath64_atan2: typeof atan2;
+declare const fmath64_cos: typeof cos;
+declare const fmath64_exp: typeof exp;
+declare const fmath64_log: typeof log;
+declare const fmath64_log2: typeof log2;
+declare const fmath64_pow: typeof pow;
+declare const fmath64_scalbn: typeof scalbn;
+declare const fmath64_sin: typeof sin;
+declare const fmath64_tan: typeof tan;
+declare namespace fmath64 {
+  export { fmath64_acos as acos, fmath64_asin as asin, fmath64_atan as atan, fmath64_atan2 as atan2, fmath64_cos as cos, fmath64_exp as exp, fmath64_log as log, fmath64_log2 as log2, fmath64_pow as pow, fmath64_scalbn as scalbn, fmath64_sin as sin, fmath64_tan as tan };
+}
+
+declare const LANE_OP: {
+    readonly F64_ADD: 8192;
+    readonly F64_SUB: 8193;
+    readonly F64_MUL: 8194;
+    readonly F64_DIV: 8195;
+    readonly F64_MIN: 8196;
+    readonly F64_MAX: 8197;
+    readonly F64_MOD: 8198;
+    readonly F64_POW: 8199;
+    readonly F64_ATAN2: 8200;
+    readonly F64_NEG: 8208;
+    readonly F64_ABS: 8209;
+    readonly F64_SQRT: 8210;
+    readonly F64_FLOOR: 8211;
+    readonly F64_CEIL: 8212;
+    readonly F64_ROUND: 8213;
+    readonly F64_TRUNC: 8214;
+    readonly F64_SIGN: 8215;
+    readonly F64_SIN: 8216;
+    readonly F64_COS: 8217;
+    readonly F64_TAN: 8218;
+    readonly F64_ASIN: 8219;
+    readonly F64_ACOS: 8220;
+    readonly F64_ATAN: 8221;
+    readonly F64_EXP: 8222;
+    readonly F64_LOG: 8223;
+    readonly F64_LOG2: 8224;
+    readonly F64_LT: 8240;
+    readonly F64_LE: 8241;
+    readonly F64_EQ: 8242;
+    readonly F64_NE: 8243;
+    readonly F64_FROM_F32: 8256;
+    readonly F64_FROM_I32: 8257;
+    readonly F64_FROM_U32: 8258;
+    readonly F64_TO_F32: 8259;
+    readonly F64_TO_I32: 8260;
+    readonly F64_TO_U32: 8261;
+    readonly F64_FROM_U64: 8262;
+    readonly F64_TO_U64: 8263;
+    readonly BIT_POPCNT: 8448;
+    readonly BIT_CLZ: 8449;
+    readonly BIT_CTZ: 8450;
+    readonly BIT_ROTL: 8451;
+    readonly BIT_ROTR: 8452;
+    readonly BIT_EXTRACT: 8453;
+    readonly BIT_INSERT: 8454;
+    readonly BIT_MORTON2: 8455;
+    readonly BIT_MORTON3: 8456;
+    readonly BIT_UNMORTON2: 8457;
+    readonly BIT_UNMORTON3: 8458;
+    readonly BIT64_POPCNT: 8464;
+    readonly BIT64_CLZ: 8465;
+    readonly BIT64_CTZ: 8466;
+    readonly BIT64_ROTL: 8467;
+    readonly BIT64_ROTR: 8468;
+    readonly BIT64_EXTRACT: 8469;
+    readonly BIT64_INSERT: 8470;
+    readonly BIT64_MORTON2: 8471;
+    readonly BIT64_MORTON3: 8472;
+    readonly BIT64_UNMORTON2: 8473;
+    readonly BIT64_UNMORTON3: 8474;
+    readonly U64_SHL: 8480;
+    readonly U64_SHR: 8481;
+    readonly U64_MUL: 8482;
+    readonly U64_DIV: 8483;
+    readonly U64_REM: 8484;
+};
+declare const INSERT_WIDTH_SHIFT = 8;
+declare const CANONICAL_NAN32 = 2143289344;
+declare function laneSignature(sub: number): readonly [number, number] | null;
+declare function joinF64(lo: number, hi: number): number;
+declare function joinU64(lo: number, hi: number): bigint;
+declare function toUint32(x: number): number;
+declare function toUint64(x: number): bigint;
+declare function runLanes(sub: number, inputs: readonly number[], targets: readonly number[], n: number, read: (word: number, lane: number) => number, write: (register: number, lane: number, value: number) => void): void;
+declare function evalLane(sub: number, v: Uint32Array, out: Uint32Array): void;
+
+declare const lanes_CANONICAL_NAN32: typeof CANONICAL_NAN32;
+declare const lanes_INSERT_WIDTH_SHIFT: typeof INSERT_WIDTH_SHIFT;
+declare const lanes_LANE_OP: typeof LANE_OP;
+declare const lanes_evalLane: typeof evalLane;
+declare const lanes_joinF64: typeof joinF64;
+declare const lanes_joinU64: typeof joinU64;
+declare const lanes_laneSignature: typeof laneSignature;
+declare const lanes_runLanes: typeof runLanes;
+declare const lanes_toUint32: typeof toUint32;
+declare const lanes_toUint64: typeof toUint64;
+declare namespace lanes {
+  export { lanes_CANONICAL_NAN32 as CANONICAL_NAN32, lanes_INSERT_WIDTH_SHIFT as INSERT_WIDTH_SHIFT, lanes_LANE_OP as LANE_OP, lanes_evalLane as evalLane, lanes_joinF64 as joinF64, lanes_joinU64 as joinU64, lanes_laneSignature as laneSignature, lanes_runLanes as runLanes, lanes_toUint32 as toUint32, lanes_toUint64 as toUint64 };
+}
+
+declare const CurveKind: {
+    readonly step: 0;
+    readonly linear: 1;
+    readonly hermite: 2;
+    readonly bezier: 3;
+};
+interface KernelCurve {
+    readonly kind: number;
+    readonly keys: readonly number[];
+    readonly values: readonly number[];
+    readonly channels?: number;
+    readonly tangents?: readonly number[];
+    readonly outs?: readonly number[];
+    readonly ins?: readonly number[];
+}
+interface KernelLut {
+    readonly x0: number;
+    readonly scale: number;
+    readonly values: readonly number[];
+    readonly linear?: boolean;
+    readonly wrap?: boolean;
+}
+interface KernelLut2 {
+    readonly nx: number;
+    readonly ny: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly sx: number;
+    readonly sy: number;
+    readonly values: readonly number[];
+    readonly linear?: boolean;
+    readonly wrap?: boolean;
+}
+interface KernelSampler {
+    readonly width: number;
+    readonly height: number;
+    readonly channels: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly scale: number;
+    readonly cell: number;
+    readonly wrap?: boolean;
+}
+type GridSize = FixedArray<u32, 3>;
+declare function curve$1(c: KernelCurve, x: f32, channel?: u32): f32;
+declare function gradient(c: KernelCurve, t: f32): vec4;
+declare function lut(t: KernelLut, x: f32): f32;
+declare function lut2(t: KernelLut2, x: f32, y: f32): f32;
+declare function bindSampler(name: string, data: Float32Array): void;
+declare function unbindSampler(name: string): void;
+declare function sampler<S extends KernelSampler>(name: string, desc: S): S;
+declare function sample(s: KernelSampler, x: f32, y: f32, channel?: u32, nearest?: boolean): f32;
+declare function satBox(s: KernelSampler, x0: number, y0: number, x1: number, y1: number): f32;
+declare function heightNormal(s: KernelSampler, x: f32, y: f32, channel?: u32): vec3;
+declare function cell<T extends number>(field: T, dx: number, dy: number, dz: number, grid: GridSize, wrap?: boolean): T;
+type mat3 = FixedArray<f32, 9>;
+declare function mat3(...values: number[]): mat3;
+type mat4 = FixedArray<f32, 16>;
+declare function mat4(...values: number[]): mat4;
+declare function m3mul(a: mat3, b: mat3): mat3;
+declare function m4mul(a: mat4, b: mat4): mat4;
+declare function m3vec(m: mat3, v: vec3): vec3;
+declare function m4point(m: mat4, v: vec3): vec3;
+declare function m4dir(m: mat4, v: vec3): vec3;
+declare function m3transpose(m: mat3): mat3;
+declare function m4transpose(m: mat4): mat4;
+declare function m3inverse(m: mat3): mat3;
+declare function m4inverseAffine(m: mat4): mat4;
+
+declare const FAR = 100000000000000000000;
+declare const NO_SEED = 4294967295;
+declare const SCAN_BLOCK = 256;
+declare const FFT_GPU_RELATIVE_BOUND: number;
+declare function isFftSize(n: number): boolean;
+declare class Fft {
+    readonly length: number;
+    readonly twiddleRe: Float32Array;
+    readonly twiddleIm: Float32Array;
+    readonly reverse: Uint16Array;
+    private readonly scale;
+    constructor(length: number);
+    transform(re: Float32Array, im: Float32Array, inverse: boolean, offset?: number, stride?: number): void;
+    forward(re: Float32Array, im: Float32Array): void;
+    inverse(re: Float32Array, im: Float32Array): void;
+}
+declare class Fft2 {
+    readonly width: number;
+    readonly height: number;
+    readonly rows: Fft;
+    readonly columns: Fft;
+    private readonly scale;
+    private native;
+    constructor(width: number, height: number);
+    get length(): number;
+    get onEngine(): boolean;
+    dispose(): void;
+    private runNative;
+    private pass;
+    forward(re: Float32Array, im: Float32Array): void;
+    inverse(re: Float32Array, im: Float32Array): void;
+    forwardReal(input: ArrayLike<number>, re: Float32Array, im: Float32Array): void;
+}
+declare function multiply(re: Float32Array, im: Float32Array, byRe: Float32Array, byIm: Float32Array): void;
+declare class Convolver {
+    private readonly fft;
+    private readonly kernelRe;
+    private readonly kernelIm;
+    private readonly workRe;
+    private readonly workIm;
+    private native;
+    constructor(width: number, height: number, kernel: ArrayLike<number>);
+    get onEngine(): boolean;
+    dispose(): void;
+    private runNative;
+    convolve(image: ArrayLike<number>, out: Float32Array): void;
+    convolvePair(a: ArrayLike<number>, b: ArrayLike<number>, outA: Float32Array, outB: Float32Array): void;
+}
+declare function scan(values: Float32Array, offset?: number, length?: number, stride?: number): void;
+declare class SummedAreaTable {
+    readonly width: number;
+    readonly height: number;
+    private native;
+    constructor(width: number, height: number);
+    get onEngine(): boolean;
+    dispose(): void;
+    build(input: ArrayLike<number>, out: Float32Array): void;
+    buildU32(input: ArrayLike<number>, out: Uint32Array): void;
+}
+declare function boxSum(table: Float32Array, width: number, height: number, x0: number, y0: number, x1: number, y1: number): number;
+declare function boxSumU32(table: Uint32Array, width: number, height: number, x0: number, y0: number, x1: number, y1: number): number;
+declare const BRUTE_FORCE_SEEDS = 2;
+declare const BRUTE_FORCE_SEEDS_LARGE = 5;
+declare const LARGE_GRID: number;
+declare function distanceMethod(cells: number, seeds: number): "bruteForce" | "envelope";
+declare class DistanceTransform {
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    private readonly v;
+    private readonly z;
+    private readonly line;
+    private readonly argLine;
+    private readonly outLine;
+    private readonly outArg;
+    private readonly cost;
+    private readonly seeds;
+    readonly nearest: Uint32Array;
+    constructor(width: number, height: number, depth?: number);
+    private native;
+    get onEngine(): boolean;
+    dispose(): void;
+    private nativeMask;
+    get cells(): number;
+    private run;
+    squared(cost: ArrayLike<number>, out: Float32Array): void;
+    fromMask(mask: ArrayLike<number>, out: Float32Array): void;
+    envelopeFromMask(mask: ArrayLike<number>, out: Float32Array): void;
+    bruteForce(mask: ArrayLike<number>, out: Float32Array): void;
+    signed(mask: ArrayLike<number>, scratch: Float32Array, out: Float32Array): void;
+}
+declare function jfaSteps(width: number, height: number): number[];
+declare function jumpFlood(width: number, height: number, mask: ArrayLike<number>, a: Uint32Array, b: Uint32Array, squared: Uint32Array): void;
+type PoissonBoundary = "dirichlet" | "neumann";
+declare const PRE_SMOOTH = 2;
+declare const POST_SMOOTH = 2;
+declare const COARSE_SWEEPS = 64;
+declare class Multigrid {
+    readonly boundary: PoissonBoundary;
+    private readonly levels;
+    private readonly axes;
+    private readonly weights;
+    constructor(width: number, height: number, depth: number, spacing: number, boundary: PoissonBoundary);
+    get cells(): number;
+    get depth(): number;
+    private sumAt;
+    private diagonal;
+    private smooth;
+    private residual;
+    private restrict;
+    private prolong;
+    private static removeMean;
+    vCycle(): void;
+    private native;
+    get onEngine(): boolean;
+    dispose(): void;
+    solve(u: Float32Array, f: ArrayLike<number>, cycles: number): number;
+}
+
+declare const transforms_BRUTE_FORCE_SEEDS: typeof BRUTE_FORCE_SEEDS;
+declare const transforms_BRUTE_FORCE_SEEDS_LARGE: typeof BRUTE_FORCE_SEEDS_LARGE;
+declare const transforms_COARSE_SWEEPS: typeof COARSE_SWEEPS;
+type transforms_Convolver = Convolver;
+declare const transforms_Convolver: typeof Convolver;
+type transforms_DistanceTransform = DistanceTransform;
+declare const transforms_DistanceTransform: typeof DistanceTransform;
+declare const transforms_FAR: typeof FAR;
+declare const transforms_FFT_GPU_RELATIVE_BOUND: typeof FFT_GPU_RELATIVE_BOUND;
+type transforms_Fft = Fft;
+declare const transforms_Fft: typeof Fft;
+type transforms_Fft2 = Fft2;
+declare const transforms_Fft2: typeof Fft2;
+declare const transforms_LARGE_GRID: typeof LARGE_GRID;
+type transforms_Multigrid = Multigrid;
+declare const transforms_Multigrid: typeof Multigrid;
+declare const transforms_NO_SEED: typeof NO_SEED;
+declare const transforms_POST_SMOOTH: typeof POST_SMOOTH;
+declare const transforms_PRE_SMOOTH: typeof PRE_SMOOTH;
+type transforms_PoissonBoundary = PoissonBoundary;
+declare const transforms_SCAN_BLOCK: typeof SCAN_BLOCK;
+type transforms_SummedAreaTable = SummedAreaTable;
+declare const transforms_SummedAreaTable: typeof SummedAreaTable;
+declare const transforms_boxSum: typeof boxSum;
+declare const transforms_boxSumU32: typeof boxSumU32;
+declare const transforms_distanceMethod: typeof distanceMethod;
+declare const transforms_isFftSize: typeof isFftSize;
+declare const transforms_jfaSteps: typeof jfaSteps;
+declare const transforms_jumpFlood: typeof jumpFlood;
+declare const transforms_multiply: typeof multiply;
+declare const transforms_scan: typeof scan;
+declare namespace transforms {
+  export { transforms_BRUTE_FORCE_SEEDS as BRUTE_FORCE_SEEDS, transforms_BRUTE_FORCE_SEEDS_LARGE as BRUTE_FORCE_SEEDS_LARGE, transforms_COARSE_SWEEPS as COARSE_SWEEPS, transforms_Convolver as Convolver, transforms_DistanceTransform as DistanceTransform, transforms_FAR as FAR, transforms_FFT_GPU_RELATIVE_BOUND as FFT_GPU_RELATIVE_BOUND, transforms_Fft as Fft, transforms_Fft2 as Fft2, transforms_LARGE_GRID as LARGE_GRID, transforms_Multigrid as Multigrid, transforms_NO_SEED as NO_SEED, transforms_POST_SMOOTH as POST_SMOOTH, transforms_PRE_SMOOTH as PRE_SMOOTH, type transforms_PoissonBoundary as PoissonBoundary, transforms_SCAN_BLOCK as SCAN_BLOCK, transforms_SummedAreaTable as SummedAreaTable, transforms_boxSum as boxSum, transforms_boxSumU32 as boxSumU32, transforms_distanceMethod as distanceMethod, transforms_isFftSize as isFftSize, transforms_jfaSteps as jfaSteps, transforms_jumpFlood as jumpFlood, transforms_multiply as multiply, transforms_scan as scan };
+}
+
+declare const WAKE_NEVER: u32;
+interface Regenerating {
+    hp: f32;
+    cap: f32;
+    wake: u32;
+    period: u32;
+}
+declare const REGENERATING_FIELDS: {
+    readonly hp: "f32";
+    readonly cap: "f32";
+    readonly wake: "u32";
+    readonly period: "u32";
+};
+declare function regenerate(e: Each<Regenerating>, tick: u32, amount: f32): void;
+
+declare const STEER_STOP: u32;
+declare const STEER_SEEK: u32;
+declare const STEER_DIRECTION: u32;
+declare const STEER_FACE: u32;
+interface SteerAgent {
+    pos: vec2;
+    vel: vec2;
+    desired: vec2;
+    facing: vec2;
+    point: vec2;
+    mode: u32;
+    arrive: f32;
+    throttle: f32;
+    speedScale: f32;
+}
+interface Particle {
+    pos: vec3;
+    vel: vec3;
+    age: f32;
+    life: f32;
+    size: f32;
+}
+interface ParticleLook {
+    age: f32;
+    life: f32;
+    tint: vec4;
+    scale: f32;
+}
+interface Bounced {
+    pos: vec3;
+    vel: vec3;
+}
+declare const LIFE_TINT: {
+    kind: 1;
+    channels: number;
+    keys: number[];
+    values: number[];
+};
+declare const LIFE_SIZE: {
+    kind: 2;
+    keys: number[];
+    values: number[];
+    tangents: number[];
+};
+declare function arriveVelocity(offset: vec2, arrive: f32, top: f32, throttle: f32, slowing: f32): vec2;
+declare function separationPush(offset: vec2, radius: f32): vec2;
+declare function limitLength2(v: vec2, limit: f32): vec2;
+declare function steerAccelerate(desired: vec2, vel: vec2, budget: f32): vec2;
+declare function headingFrom(v: vec2, fallback: vec2, threshold: f32): vec2;
+declare function steerAgent(e: Each<SteerAgent>, dt: f32, maxSpeed: f32, maxAccel: f32, separationRadius: f32, separationWeight: f32, kinematic: i32): void;
+declare function curlForce(pos: vec3, scale: f32, time: f32, strength: f32): vec3;
+declare function particleVelocity(vel: vec3, force: vec3, damping: f32, dt: f32): vec3;
+declare function planeBounce(pos: vec3, vel: vec3, plane: vec4, bounce: f32): Bounced;
+declare function particleMotion(e: Each<Particle>, dt: f32, gravity: vec3, drag: f32, plane: vec4, bounce: f32, collide: i32, noise: vec3): void;
+declare function particleLook(e: Each<ParticleLook>): void;
+
+declare const PARTICLE_FIELDS: {
+    readonly pos: "vec3";
+    readonly vel: "vec3";
+    readonly age: "f32";
+    readonly life: "f32";
+    readonly size: "f32";
+};
+declare const PARTICLE_LOOK_FIELDS: {
+    readonly age: "f32";
+    readonly life: "f32";
+    readonly tint: "vec4";
+    readonly scale: "f32";
+};
+declare function particleStep(e: Each<Particle>, dt: f32, gravity: vec3, drag: f32, plane: vec4, bounce: f32, collide: i32, noise: vec3): void;
+
+declare const STEER_AGENT_FIELDS: {
+    readonly pos: "vec2";
+    readonly vel: "vec2";
+    readonly desired: "vec2";
+    readonly facing: "vec2";
+    readonly point: "vec2";
+    readonly mode: "u32";
+    readonly arrive: "f32";
+    readonly throttle: "f32";
+    readonly speedScale: "f32";
+};
+
+declare const steerAgents: Kernel<Each<SteerAgent>, [dt: number, maxSpeed: number, maxAccel: number, separationRadius: number, separationWeight: number, kinematic: number]>;
+declare const particleRules: Kernel<Each<Particle>, [dt: number, gravity: vec3, drag: number, plane: vec4, bounce: number, collide: number, noise: vec3]>;
+declare const particleColours: Kernel<Each<ParticleLook>, []>;
+declare const particleMotions: Kernel<Each<Particle>, [dt: number, gravity: vec3, drag: number, plane: vec4, bounce: number, collide: number, noise: vec3]>;
+declare const regenerating: Kernel<Each<Regenerating>, [tick: number, amount: number]>;
+
+declare const NEVER = 4294967295;
+declare const UNREACHED = 4294967295;
+declare const NO_LABEL = 4294967295;
+declare function isDue(tick: number, wake: number): boolean;
+declare class KernelSchedule {
+    private readonly mask;
+    private now;
+    private readonly head;
+    private readonly next;
+    private readonly prev;
+    private readonly slotOf;
+    private readonly rows;
+    private len;
+    private count;
+    constructor(capacity: number, horizon?: number);
+    rebuild(wake: ArrayLike<number>, count: number, now: number): void;
+    private unlink;
+    private insert;
+    set(row: number, wake: number): void;
+    collect(tick: number, wake: ArrayLike<number>): Uint32Array;
+    due(): Uint32Array;
+    settle(wake: ArrayLike<number>): void;
+    into(selection: Selection): Selection;
+}
+declare function stagger(tick: number, every: number, ids: ArrayLike<number> | null, count: number, out: Uint32Array): number;
+declare class KernelWatch {
+    private readonly columns;
+    private readonly capacity;
+    private readonly shadow;
+    private readonly marks;
+    private readonly rows;
+    private len;
+    private count;
+    private primed;
+    constructor(columns: number, capacity: number);
+    mark(row: number): void;
+    markAll(): void;
+    private readonly views;
+    private view;
+    private check;
+    changed(watched: readonly WatchedColumn[], count: number): Uint32Array;
+    commit(watched: readonly WatchedColumn[], count: number): void;
+    into(selection: Selection): Selection;
+}
+type WatchedColumn = Float32Array | Int32Array | Uint32Array | Uint8Array;
+interface Grid {
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+}
+declare function gridCells(grid: Grid): number;
+declare function componentsEdges(nodes: number, a: ArrayLike<number>, b: ArrayLike<number>, parent: Uint32Array, labels: Uint32Array): number;
+declare function componentsGrid(grid: Grid, values: ArrayLike<number>, empty: number, parent: Uint32Array, labels: Uint32Array): number;
+declare function bfsGrid(grid: Grid, passable: ArrayLike<number>, sources: ArrayLike<number>, dist: Uint32Array, queue: Uint32Array): number;
+declare function nearestLabelGrid(grid: Grid, dist: Uint32Array, queue: Uint32Array, reached: number, sources: ArrayLike<number>, sourceLabels: ArrayLike<number>, labels: Uint32Array): void;
+declare function floodFill(grid: Grid, passable: ArrayLike<number>, seeds: ArrayLike<number>, label: number, out: Uint32Array, dist: Uint32Array, queue: Uint32Array): number;
+declare class Csr {
+    private readonly offsets;
+    private readonly targets;
+    private count;
+    constructor(nodes: number, edges: number);
+    build(nodes: number, a: ArrayLike<number>, b: ArrayLike<number>): void;
+    nodes(): number;
+    neighbours(node: number): Uint32Array;
+    maxDegree(): number;
+}
+declare function bfsGraph(graph: Csr, sources: ArrayLike<number>, dist: Uint32Array, queue: Uint32Array): number;
+declare function propagateGraph(graph: Csr, labels: Uint32Array, next: Uint32Array, work: Uint32Array, rounds: number): number;
+declare function propagateGrid(grid: Grid, labels: Uint32Array, next: Uint32Array, rounds: number): number;
+declare const WALL = 4294967295;
+declare function reachSeeded(grid: Grid, labels: ArrayLike<number>, dist: Uint32Array, queue: Uint32Array, seeded: number, owner: Uint32Array | null): number;
+declare function unionNodes(parent: Uint32Array, a: number, b: number): void;
+declare function findNode(parent: Uint32Array, x: number): number;
+
+type toolkit_Csr = Csr;
+declare const toolkit_Csr: typeof Csr;
+type toolkit_Grid = Grid;
+type toolkit_KernelSchedule = KernelSchedule;
+declare const toolkit_KernelSchedule: typeof KernelSchedule;
+type toolkit_KernelWatch = KernelWatch;
+declare const toolkit_KernelWatch: typeof KernelWatch;
+declare const toolkit_NEVER: typeof NEVER;
+declare const toolkit_NO_LABEL: typeof NO_LABEL;
+declare const toolkit_UNREACHED: typeof UNREACHED;
+declare const toolkit_WALL: typeof WALL;
+type toolkit_WatchedColumn = WatchedColumn;
+declare const toolkit_bfsGraph: typeof bfsGraph;
+declare const toolkit_bfsGrid: typeof bfsGrid;
+declare const toolkit_componentsEdges: typeof componentsEdges;
+declare const toolkit_componentsGrid: typeof componentsGrid;
+declare const toolkit_findNode: typeof findNode;
+declare const toolkit_floodFill: typeof floodFill;
+declare const toolkit_gridCells: typeof gridCells;
+declare const toolkit_isDue: typeof isDue;
+declare const toolkit_nearestLabelGrid: typeof nearestLabelGrid;
+declare const toolkit_propagateGraph: typeof propagateGraph;
+declare const toolkit_propagateGrid: typeof propagateGrid;
+declare const toolkit_reachSeeded: typeof reachSeeded;
+declare const toolkit_stagger: typeof stagger;
+declare const toolkit_unionNodes: typeof unionNodes;
+declare namespace toolkit {
+  export { toolkit_Csr as Csr, type toolkit_Grid as Grid, toolkit_KernelSchedule as KernelSchedule, toolkit_KernelWatch as KernelWatch, toolkit_NEVER as NEVER, toolkit_NO_LABEL as NO_LABEL, toolkit_UNREACHED as UNREACHED, toolkit_WALL as WALL, type toolkit_WatchedColumn as WatchedColumn, toolkit_bfsGraph as bfsGraph, toolkit_bfsGrid as bfsGrid, toolkit_componentsEdges as componentsEdges, toolkit_componentsGrid as componentsGrid, toolkit_findNode as findNode, toolkit_floodFill as floodFill, toolkit_gridCells as gridCells, toolkit_isDue as isDue, toolkit_nearestLabelGrid as nearestLabelGrid, toolkit_propagateGraph as propagateGraph, toolkit_propagateGrid as propagateGrid, toolkit_reachSeeded as reachSeeded, toolkit_stagger as stagger, toolkit_unionNodes as unionNodes };
+}
+
+interface TreeWalk {
+    readonly nodes: Uint32Array;
+    readonly thresholds: Float32Array;
+    readonly values: Float32Array;
+}
+interface TreeModelVariant {
+    readonly programs: readonly Uint8Array[];
+    readonly walk: TreeWalk | null;
+}
+type TreeModelBackend = "auto" | "gpu" | "wasm" | "vm" | "js";
+type TreeModelFormat = "xgboost" | "lightgbm" | "onnx";
+type TreeModelTransform = {
+    readonly kind: "none";
+} | {
+    readonly kind: "sigmoid";
+    readonly scale: number;
+} | {
+    readonly kind: "softmax";
+} | {
+    readonly kind: "exp";
+} | {
+    readonly kind: "argmax";
+} | {
+    readonly kind: "step";
+};
+interface TreeModelInfo {
+    readonly name: string;
+    readonly file: string;
+    readonly format: TreeModelFormat;
+    readonly features: number;
+    readonly outputs: number;
+    readonly width: number;
+    readonly featureNames: readonly string[] | null;
+    readonly transform: TreeModelTransform;
+    readonly base: readonly number[];
+    readonly baseLast: boolean;
+    readonly divisor: number;
+    readonly trees: number;
+    readonly nodes: number;
+    readonly depth: number;
+    readonly parts: number;
+    readonly walked?: number;
+}
+interface FlatTrees {
+    readonly treeStart: Int32Array;
+    readonly treeOutput: Int32Array;
+    readonly feature: Int32Array;
+    readonly threshold: Float32Array;
+    readonly left: Int32Array;
+    readonly right: Int32Array;
+    readonly flags: Uint8Array;
+    readonly leaf: Float32Array;
+}
+type TreeModelOutput = Float32Array | readonly Float32Array[];
+declare class TreeModel {
+    readonly info: TreeModelInfo;
+    readonly programs: readonly Uint8Array[];
+    readonly flat: FlatTrees;
+    private readonly parsed;
+    private readonly js;
+    private vm;
+    private wasm;
+    private readonly single;
+    private chosen;
+    readonly walk: TreeWalk | null;
+    readonly walked: TreeModelVariant | null;
+    programsFor(device: "cpu" | "gpu"): TreeModelVariant;
+    constructor(info: TreeModelInfo, programs: readonly Uint8Array[], flat: FlatTrees, walk?: TreeWalk | null, walked?: TreeModelVariant | null);
+    get features(): number;
+    get outputs(): number;
+    get featureNames(): readonly string[] | null;
+    get backend(): TreeModelBackend;
+    use(backend: TreeModelBackend): this;
+    ready(): Promise<TreeModelBackend>;
+    private wasmTrees;
+    predict(columns: readonly Float32Array[], out: TreeModelOutput, count?: number): number;
+    private routed;
+    get device(): RouteDevice;
+    private gpu;
+    private gpuTrees;
+    get wasmReady(): boolean;
+    predictCpu(columns: readonly Float32Array[], outs: readonly Float32Array[], n: number, backend: TreeModelBackend): void;
+}
+declare function model(file: string, payload?: string): TreeModel;
+
+interface GpuSetProbe {
+    readonly class: GpuDeviceClass;
+    readonly rows: number;
+    readonly setFixedNs: number;
+    readonly setOpPs: number;
+    readonly gatherPs: number;
+}
+declare const GPU_PROBE_LOG_PREFIX = "cimplify-gpu-probe ";
+declare const GPU_PROBE_FLAG = "__CIMPLIFY_GPU_PROBE__";
+declare function probeGpuSetCosts(runner?: KernelRunner): GpuSetProbe | null;
+declare function logGpuSetProbe(runner?: KernelRunner): GpuSetProbe | null;
+declare function runGpuProbeIfAsked(runner?: KernelRunner): GpuSetProbe | null;
+
+declare function srgbToLinear(c: f32): f32;
+declare function linearToSrgb(c: f32): f32;
+declare function srgbToLinear3(c: vec3): vec3;
+declare function linearToSrgb3(c: vec3): vec3;
+declare function rgbToHsv(c: vec3): vec3;
+declare function hsvToRgb(c: vec3): vec3;
+declare function rgbToHsl(c: vec3): vec3;
+declare function hslToRgb(c: vec3): vec3;
+declare function linearToOklab(c: vec3): vec3;
+declare function oklabToLinear(c: vec3): vec3;
+declare function oklabToOklch(c: vec3): vec3;
+declare function oklchToOklab(c: vec3): vec3;
+declare function mixOklab(a: vec3, b: vec3, t: f32): vec3;
+declare function luminance(c: vec3): f32;
+declare function premultiply(c: vec4): vec4;
+declare function unpremultiply(c: vec4): vec4;
+declare function blendOver(src: vec4, dst: vec4): vec4;
+
+type fx = i32;
+interface fx64 {
+    hi: i32;
+    lo: u32;
+}
+declare const FX_ONE = 65536;
+declare const FX_HALF = 32768;
+declare const FX_MAX = 2147483647;
+declare const FX_MIN = -2147483648;
+declare function fxFromInt(i: i32): fx;
+declare function fxToInt(a: fx): i32;
+declare function fxFromF32(x: f32): fx;
+declare function fxToF32(a: fx): f32;
+declare function fxAdd(a: fx, b: fx): fx;
+declare function fxSub(a: fx, b: fx): fx;
+declare function fxNeg(a: fx): fx;
+declare function fxAbs(a: fx): fx;
+declare function fxFloor(a: fx): fx;
+declare function fxFrac(a: fx): fx;
+declare function fxMul(a: fx, b: fx): fx;
+declare function fxDiv(a: fx, b: fx): fx;
+declare function fxSqrt(a: fx): fx;
+declare function fxSin(angle: fx): fx;
+declare function fxCos(angle: fx): fx;
+declare function fxLerp(a: fx, b: fx, t: fx): fx;
+declare function fx64FromInt(i: i32): fx64;
+declare function fx64FromFx(a: fx): fx64;
+declare function fx64ToFx(a: fx64): fx;
+declare function fx64Neg(a: fx64): fx64;
+declare function fx64FromF32(x: f32): fx64;
+declare function fx64ToF32(a: fx64): f32;
+declare function fx64Add(a: fx64, b: fx64): fx64;
+declare function fx64Sub(a: fx64, b: fx64): fx64;
+declare function fx64Lt(a: fx64, b: fx64): boolean;
+declare function fx64Mul(a: fx64, b: fx64): fx64;
+declare function fx64Div(a: fx64, b: fx64): fx64;
+declare function fx64Sqrt(a: fx64): fx64;
+declare function fx64Sin(angle: fx64): fx64;
+declare function fx64Cos(angle: fx64): fx64;
+
+interface LaunchAngles {
+    low: f32;
+    high: f32;
+    ok: boolean;
+}
+interface Ballistic {
+    pos: vec3;
+    vel: vec3;
+}
+interface SegmentPair {
+    s: f32;
+    t: f32;
+    a: vec3;
+    b: vec3;
+    distSq: f32;
+}
+interface TriangleHit {
+    t: f32;
+    u: f32;
+    v: f32;
+    hit: boolean;
+}
+declare function interceptTime(relPos: vec3, relVel: vec3, speed: f32): f32;
+declare function interceptTime2(relPos: vec2, relVel: vec2, speed: f32): f32;
+declare function launchAngles(speed: f32, distance: f32, height: f32, gravity: f32): LaunchAngles;
+declare function launchSpeed(angle: f32, distance: f32, height: f32, gravity: f32): f32;
+declare function projectilePos(pos: vec3, vel: vec3, gravity: vec3, t: f32): vec3;
+declare function projectileVel(vel: vec3, gravity: vec3, t: f32): vec3;
+declare function dragPos(pos: vec3, vel: vec3, gravity: vec3, drag: f32, t: f32): vec3;
+declare function dragVel(vel: vec3, gravity: vec3, drag: f32, t: f32): vec3;
+declare function quadDragStep(pos: vec3, vel: vec3, gravity: vec3, drag: f32, dt: f32, substeps: i32): Ballistic;
+declare function closestOnSegment(p: vec3, a: vec3, b: vec3): vec3;
+declare function segmentDistSq(p: vec3, a: vec3, b: vec3): f32;
+declare function closestOnTriangle(p: vec3, a: vec3, b: vec3, c: vec3): vec3;
+declare function closestInAabb(p: vec3, min: vec3, max: vec3): vec3;
+declare function closestInObb(p: vec3, center: vec3, rotation: quat, half: vec3): vec3;
+declare function closestSegments(p1: vec3, q1: vec3, p2: vec3, q2: vec3): SegmentPair;
+declare function raySphere(origin: vec3, dir: vec3, center: vec3, radius: f32): f32;
+declare function rayAabb(origin: vec3, dir: vec3, min: vec3, max: vec3): f32;
+declare function rayPlane(origin: vec3, dir: vec3, plane: vec4): f32;
+declare function rayTriangle(origin: vec3, dir: vec3, a: vec3, b: vec3, c: vec3): TriangleHit;
+declare function inCone(p: vec3, apex: vec3, axis: vec3, cosHalfAngle: f32, range: f32): boolean;
+declare function inPolygon<N extends number>(p: vec2, vertices: FixedArray<vec2, N>, count: i32): boolean;
+declare function inTriangle(p: vec2, a: vec2, b: vec2, c: vec2): boolean;
+declare function spheresOverlap(c1: vec3, r1: f32, c2: vec3, r2: f32): boolean;
+declare function aabbOverlap(min1: vec3, max1: vec3, min2: vec3, max2: vec3): boolean;
+declare function sphereAabbOverlap(center: vec3, radius: f32, min: vec3, max: vec3): boolean;
+declare function sweepSpherePlane(from: vec3, to: vec3, radius: f32, plane: vec4): f32;
+declare function planeFromPoints(a: vec3, b: vec3, c: vec3): vec4;
+
+declare function fsin(x: f32): f32;
+declare function fcos(x: f32): f32;
+declare function ftan(x: f32): f32;
+declare function fasin(x: f32): f32;
+declare function facos(x: f32): f32;
+declare function fatan(x: f32): f32;
+declare function fatan2(y: f32, x: f32): f32;
+declare function fexp(x: f32): f32;
+declare function flog(x: f32): f32;
+declare function flog2(x: f32): f32;
+declare function fpow(x: f32, y: f32): f32;
+declare function umulhi(a: u32, b: u32): u32;
+declare function uaddCarry(a: u32, b: u32, carry: u32): u32;
+declare function usubBorrow(a: u32, b: u32, borrow: u32): u32;
+
+declare function packAnimation(clip: u32, phase: f32): u32;
+interface Damped {
+    value: f32;
+    velocity: f32;
+}
+interface Damped2 {
+    value: vec2;
+    velocity: vec2;
+}
+interface Damped3 {
+    value: vec3;
+    velocity: vec3;
+}
+interface PidState {
+    integral: f32;
+    previous: f32;
+}
+interface PidStep {
+    output: f32;
+    state: PidState;
+}
+declare function smoothDamp(current: f32, target: f32, velocity: f32, smoothTime: f32, maxSpeed: f32, dt: f32): Damped;
+declare function smoothDamp2(current: vec2, target: vec2, velocity: vec2, smoothTime: f32, maxSpeed: f32, dt: f32): Damped2;
+declare function smoothDamp3(current: vec3, target: vec3, velocity: vec3, smoothTime: f32, maxSpeed: f32, dt: f32): Damped3;
+declare function expSmooth(current: f32, target: f32, rate: f32, dt: f32): f32;
+declare function expSmooth2(current: vec2, target: vec2, rate: f32, dt: f32): vec2;
+declare function expSmooth3(current: vec3, target: vec3, rate: f32, dt: f32): vec3;
+declare function approach(current: f32, target: f32, halfLife: f32, dt: f32): f32;
+declare function decay(value: f32, rate: f32, dt: f32): f32;
+declare function moveToward(current: f32, target: f32, maxDelta: f32): f32;
+declare function moveToward2(current: vec2, target: vec2, maxDelta: f32): vec2;
+declare function moveToward3(current: vec3, target: vec3, maxDelta: f32): vec3;
+declare function rotateToward(current: f32, target: f32, maxDelta: f32): f32;
+declare function pidStep(state: PidState, error: f32, kp: f32, ki: f32, kd: f32, dt: f32, integralLimit: f32): PidStep;
+declare function springStep(value: f32, velocity: f32, target: f32, stiffness: f32, damping: f32, dt: f32): Damped;
+
+interface RunningStats {
+    count: f32;
+    mean: f32;
+    m2: f32;
+}
+declare function relu(x: f32): f32;
+declare function leakyRelu(x: f32, slope: f32): f32;
+declare function sigmoid(x: f32): f32;
+declare function tanhf(x: f32): f32;
+declare function softplus(x: f32): f32;
+declare function dense<I extends number, O extends number>(input: FixedArray<f32, I>, weights: FixedArray<f32, number>, bias: FixedArray<f32, O>, out: FixedArray<f32, O>): FixedArray<f32, O>;
+declare function denseRelu<I extends number, O extends number>(input: FixedArray<f32, I>, weights: FixedArray<f32, number>, bias: FixedArray<f32, O>, out: FixedArray<f32, O>): FixedArray<f32, O>;
+declare function denseTable<I extends number, O extends number>(input: FixedArray<f32, I>, table: KernelLut, out: FixedArray<f32, O>): FixedArray<f32, O>;
+declare function quantize(x: f32, scale: f32): i32;
+declare function denseQ8<I extends number, O extends number>(input: FixedArray<i32, I>, packed: FixedArray<u32, number>, bias: FixedArray<i32, O>, scale: f32, out: FixedArray<f32, O>): FixedArray<f32, O>;
+declare function softmax<N extends number>(input: FixedArray<f32, N>, out: FixedArray<f32, N>): FixedArray<f32, N>;
+declare function argmax<N extends number>(input: FixedArray<f32, N>): i32;
+declare function statsAdd(stats: RunningStats, x: f32): RunningStats;
+declare function statsVariance(stats: RunningStats): f32;
+declare function statsSampleVariance(stats: RunningStats): f32;
+declare function ema(average: f32, x: f32, alpha: f32): f32;
+
+declare function simplex2(x: f32, y: f32, seed?: u32): f32;
+declare function simplex2d(x: f32, y: f32, seed?: u32): vec3;
+declare function simplex3d(x: f32, y: f32, z: f32, seed?: u32): vec4;
+declare function simplex3(x: f32, y: f32, z: f32, seed?: u32): f32;
+declare function simplex4(x: f32, y: f32, z: f32, w: f32, seed?: u32): f32;
+declare function worley2(x: f32, y: f32, seed?: u32): vec2;
+declare function worley3(x: f32, y: f32, z: f32, seed?: u32): vec2;
+declare function curl2(x: f32, y: f32, seed?: u32): vec2;
+declare function curl3(x: f32, y: f32, z: f32, seed?: u32): vec3;
+declare function fbm2(x: f32, y: f32, octaves: i32, lacunarity: f32, gain: f32, seed?: u32): f32;
+declare function fbm3(x: f32, y: f32, z: f32, octaves: i32, lacunarity: f32, gain: f32, seed?: u32): f32;
+declare function ridged2(x: f32, y: f32, octaves: i32, lacunarity: f32, gain: f32, seed?: u32): f32;
+declare function ridged3(x: f32, y: f32, z: f32, octaves: i32, lacunarity: f32, gain: f32, seed?: u32): f32;
+declare function warp2(p: vec2, strength: f32, octaves: i32, seed?: u32): vec2;
+declare function warp3(p: vec3, strength: f32, octaves: i32, seed?: u32): vec3;
+
+declare function texNoise(x: f32, y: f32, period: i32, seed?: u32): f32;
+declare function texFbm(u: f32, v: f32, period: i32, octaves: i32, gain: f32, seed?: u32): f32;
+declare function texRidged(u: f32, v: f32, period: i32, octaves: i32, gain: f32, seed?: u32): f32;
+declare function texCells(u: f32, v: f32, period: i32, jitter: f32, seed?: u32): vec3;
+declare function texBricks(u: f32, v: f32, rows: i32, columns: i32, mortar: f32, seed?: u32): vec3;
+declare function texTiles(u: f32, v: f32, count: i32, grout: f32, seed?: u32): vec3;
+declare function texWeave(u: f32, v: f32, count: i32): vec2;
+declare function texRings(u: f32, v: f32, frequency: f32, distortion: f32, seed?: u32): f32;
+declare function texRemap(x: f32, low: f32, high: f32): f32;
+declare function texRamp(t: f32, a: vec3, b: vec3): vec3;
+declare function texNormal(left: f32, right: f32, down: f32, up: f32, strength: f32): vec3;
+
+declare function rngKey(seed: u32, row: u32, tick: u32, site: u32): u32;
+declare function randBits(key: u32, n: u32): u32;
+declare function randUnit(key: u32, n: u32): f32;
+declare function randRange(key: u32, n: u32, low: f32, high: f32): f32;
+declare function randInt(key: u32, n: u32, low: i32, high: i32): i32;
+declare function randChance(key: u32, n: u32, probability: f32): boolean;
+declare function randNormal(key: u32, n: u32): f32;
+declare function randNormal2(key: u32, n: u32): vec2;
+declare function randGaussian(key: u32, n: u32, mean: f32, deviation: f32): f32;
+declare function randExp(key: u32, n: u32, rate: f32): f32;
+declare function randWeighted<N extends number>(key: u32, n: u32, weights: FixedArray<f32, N>): i32;
+declare function randShuffle<N extends number>(key: u32, n: u32, values: FixedArray<f32, N>, out: FixedArray<f32, N>): FixedArray<f32, N>;
+declare function randPermute(key: u32, index: u32, count: u32): u32;
+declare function randInDisc(key: u32, n: u32): vec2;
+declare function randOnCircle(key: u32, n: u32): vec2;
+declare function randOnSphere(key: u32, n: u32): vec3;
+declare function randInBall(key: u32, n: u32): vec3;
+declare function randHemisphere(key: u32, n: u32, normal: vec3): vec3;
+declare function randCosHemisphere(key: u32, n: u32, normal: vec3): vec3;
+declare function poissonPoint(cellX: i32, cellY: i32, cellSize: f32, minDist: f32, seed: u32): vec2;
+
+interface SwingTwist {
+    swing: quat;
+    twist: quat;
+}
+interface AxisAngle {
+    axis: vec3;
+    angle: f32;
+}
+interface Basis {
+    t: vec3;
+    b: vec3;
+}
+declare function qnormalize(q: quat): quat;
+declare function qnlerp(a: quat, b: quat, t: f32): quat;
+declare function qslerp(a: quat, b: quat, t: f32): quat;
+declare function basisFrom(n: vec3): Basis;
+declare function qFromAxisAngle(axis: vec3, angle: f32): quat;
+declare function qToAxisAngle(q: quat): AxisAngle;
+declare function qFromTo(from: vec3, to: vec3): quat;
+declare function qLookRotation(forward: vec3, up: vec3): quat;
+declare function qSwingTwist(q: quat, axis: vec3): SwingTwist;
+declare function qClampSwingTwist(q: quat, axis: vec3, maxSwing: f32, maxTwist: f32): quat;
+declare function qFromEuler(euler: vec3): quat;
+declare function qToEuler(q: quat): vec3;
+declare function wrapAngle(angle: f32): f32;
+declare function angleDiff(from: f32, to: f32): f32;
+declare function rotate2(v: vec2, angle: f32): vec2;
+declare function angleOf2(v: vec2): f32;
+declare function dirOf2(angle: f32): vec2;
+declare function qRotateToward(from: quat, to: quat, maxAngle: f32): quat;
+declare function qAngle(a: quat, b: quat): f32;
+declare function qForward(q: quat): vec3;
+declare function qUp(q: quat): vec3;
+declare function qRight(q: quat): vec3;
+declare function packRotation(q: quat): u32;
+declare function qIntegrate(q: quat, angularVelocity: vec3, dt: f32): quat;
+
+interface SimBody {
+    pos: vec3;
+    vel: vec3;
+}
+interface VerletState {
+    pos: vec3;
+    vel: vec3;
+    acc: vec3;
+}
+interface ImpulseResult {
+    v1: vec3;
+    v2: vec3;
+}
+declare function eulerStep(pos: vec3, vel: vec3, accel: (p: vec3, v: vec3) => vec3, dt: f32, substeps: i32): SimBody;
+declare function verletStep(pos: vec3, vel: vec3, acc: vec3, accel: (p: vec3, v: vec3) => vec3, dt: f32, substeps: i32): VerletState;
+declare function rk2Step(pos: vec3, vel: vec3, accel: (p: vec3, v: vec3) => vec3, dt: f32, substeps: i32): SimBody;
+declare function sphPoly6(distSq: f32, h: f32): f32;
+declare function sphSpikyGrad(offset: vec3, h: f32): vec3;
+declare function sphViscosityLap(r: f32, h: f32): f32;
+declare function reflectVelocity(vel: vec3, normal: vec3, restitution: f32, friction: f32): vec3;
+declare function sphereImpulse(p1: vec3, v1: vec3, m1: f32, p2: vec3, v2: vec3, m2: f32, restitution: f32): ImpulseResult;
+declare function springForce(p1: vec3, p2: vec3, v1: vec3, v2: vec3, rest: f32, stiffness: f32, damping: f32): vec3;
+
+type Block8 = FixedArray<f32, 8>;
+type Block16 = FixedArray<f32, 16>;
+type Block64 = FixedArray<f32, 64>;
+declare function dct8(input: Block8, out: Block8): Block8;
+declare function idct8(input: Block8, out: Block8): Block8;
+declare function dct16(input: Block16, out: Block16): Block16;
+declare function idct16(input: Block16, out: Block16): Block16;
+declare function dct8x8(input: Block64, scratch: Block64, out: Block64): Block64;
+declare function idct8x8(input: Block64, scratch: Block64, out: Block64): Block64;
+
+interface Biquad {
+    b0: f32;
+    b1: f32;
+    b2: f32;
+    a1: f32;
+    a2: f32;
+}
+interface BiquadState {
+    x1: f32;
+    x2: f32;
+    y1: f32;
+    y2: f32;
+}
+interface Filtered {
+    y: f32;
+    state: BiquadState;
+}
+interface DcState {
+    x1: f32;
+    y1: f32;
+}
+interface DcFiltered {
+    y: f32;
+    state: DcState;
+}
+declare function biquadLowpass(freq: f32, rate: f32, q: f32): Biquad;
+declare function biquadHighpass(freq: f32, rate: f32, q: f32): Biquad;
+declare function biquadBandpass(freq: f32, rate: f32, q: f32): Biquad;
+declare function biquadNotch(freq: f32, rate: f32, q: f32): Biquad;
+declare function biquadPeaking(freq: f32, rate: f32, q: f32, gainDb: f32): Biquad;
+declare function biquadStep(c: Biquad, state: BiquadState, x: f32): Filtered;
+declare function onePoleAlpha(cutoff: f32, dt: f32): f32;
+declare function onePole(previous: f32, x: f32, alpha: f32): f32;
+declare function dcBlock(state: DcState, x: f32, r: f32): DcFiltered;
+
+type SH4 = vec4;
+type SH9 = FixedArray<f32, 9>;
+declare function sh4Basis(d: vec3): SH4;
+declare function sh4Project(d: vec3, value: f32): SH4;
+declare function sh4Eval(sh: SH4, d: vec3): f32;
+declare function sh4Irradiance(sh: SH4, normal: vec3): f32;
+declare function sh4Add(a: SH4, b: SH4): SH4;
+declare function sh4Scale(a: SH4, s: f32): SH4;
+declare function sh4Rotate(sh: SH4, rotation: quat): SH4;
+declare function sh9Basis(d: vec3, out: SH9): SH9;
+declare function sh9Project(d: vec3, value: f32, out: SH9): SH9;
+declare function sh9Eval(sh: SH9, d: vec3): f32;
+declare function sh9Irradiance(sh: SH9, normal: vec3): f32;
+declare function sh9Add(a: SH9, b: SH9, out: SH9): SH9;
+declare function sh9Scale(a: SH9, s: f32, out: SH9): SH9;
+declare function sh9Rotate(sh: SH9, rotation: quat, out: SH9): SH9;
+
+declare const KERNEL_STD_SOURCES: Readonly<Record<string, string>>;
+
+declare function gridComponents(value: u32, grid: GridSize): {
+    readonly label: u32;
+    readonly count: u32;
+};
+declare function gridReach(label: u32, source: boolean, grid: GridSize): {
+    readonly dist: u32;
+    readonly owner: u32;
+    readonly reached: u32;
+};
+declare function gridPropagate(label: u32, grid: GridSize, rounds: u32): {
+    readonly label: u32;
+    readonly rounds: u32;
+};
+declare function edgeComponents(labels: KernelArray<"u32">, a: u32, b: u32): u32;
+
+declare const MLP_ACT_LINEAR = 0;
+declare const MLP_ACT_RELU = 1;
+interface MlpLayer {
+    readonly inputs: number;
+    readonly outputs: number;
+    readonly activation: number;
+    readonly multiplier: number;
+    readonly shift: number;
+    readonly zero: number;
+    readonly scale: number;
+    readonly bias: number;
+    readonly weights: number;
+    readonly stride: number;
+}
+interface MlpNet {
+    readonly words: ArrayLike<number>;
+    readonly inputs: number;
+    readonly outputs: number;
+    readonly scale: number;
+    readonly zero: number;
+    readonly layers: readonly MlpLayer[];
+}
+declare function routeMlpLane(net: MlpNet, inputs: ArrayLike<number>, lane: number, stride: number): number;
+declare const MOE_MIN_EXPERTS = 2;
+declare const MOE_MAX_EXPERTS = 16;
+interface MoeNet {
+    readonly inputs: number;
+    readonly outputs: number;
+    readonly router: MlpNet;
+    readonly experts: readonly MlpNet[];
+}
+declare function parseMoe(words: ArrayLike<number>, length: number, inputs: number, outputs: number): MoeNet | null;
+declare function evalMoeLane(net: MoeNet, inputs: ArrayLike<number>, lane: number, stride: number, outputs: Uint32Array): number;
+declare function moeBlob(inputs: number, outputs: number, router: ArrayLike<number>, experts: readonly ArrayLike<number>[]): Uint32Array;
+declare function moe<N extends number>(net: KernelArray<"u32">, inputs: ArrayLike<number>, outputs: N): FixedArray<f32, N>;
+interface MlpLayerSpec {
+    readonly outputs: number;
+    readonly activation: number;
+    readonly multiplier: number;
+    readonly shift: number;
+    readonly zero: number;
+    readonly scale: number;
+    readonly bias: ArrayLike<number>;
+    readonly weights: ArrayLike<number>;
+}
+declare function mlpBlob(inputs: number, scale: number, zero: number, layers: readonly MlpLayerSpec[]): Uint32Array;
+declare function mlp<N extends number>(net: KernelArray<"u32">, inputs: ArrayLike<number>, outputs: N): FixedArray<f32, N>;
+declare function mlpWords(bytes: ArrayBuffer | Uint8Array): Uint32Array;
+declare function setMlp(net: KernelArray<"u32">, words: Uint32Array): void;
+declare function loadMlp(net: KernelArray<"u32">, url: string): Promise<void>;
+
+type LaneKind = "f32" | "i32" | "mask";
+interface Lanes<K extends LaneKind, N extends 2 | 3 | 4> {
+    readonly kind: K;
+    readonly width: N;
+    readonly x: K extends "mask" ? boolean : number;
+    readonly y: K extends "mask" ? boolean : number;
+}
+interface m32x2 extends Lanes<"mask", 2> {
+    readonly x: boolean;
+    readonly y: boolean;
+}
+interface m32x3 extends Lanes<"mask", 3> {
+    readonly x: boolean;
+    readonly y: boolean;
+    readonly z: boolean;
+}
+interface m32x4 extends Lanes<"mask", 4> {
+    readonly x: boolean;
+    readonly y: boolean;
+    readonly z: boolean;
+    readonly w: boolean;
+}
+type F32Vector = f32x2 | f32x3 | f32x4;
+type I32Vector = i32x2 | i32x3 | i32x4;
+type MaskVector = m32x2 | m32x3 | m32x4;
+type NumberVector = F32Vector | I32Vector;
+type AnyVector = NumberVector | MaskVector;
+type MaskOf<V> = V extends Lanes<LaneKind, 2> ? m32x2 : V extends Lanes<LaneKind, 3> ? m32x3 : m32x4;
+type IntOf<V> = V extends Lanes<LaneKind, 2> ? i32x2 : V extends Lanes<LaneKind, 3> ? i32x3 : i32x4;
+type FloatOf<V> = V extends Lanes<LaneKind, 2> ? f32x2 : V extends Lanes<LaneKind, 3> ? f32x3 : f32x4;
+type VecOf<V> = V extends Lanes<LaneKind, 2> ? vec2 : V extends Lanes<LaneKind, 3> ? vec3 : vec4;
+interface f32x2 extends Lanes<"f32", 2> {
+    readonly x: f32;
+    readonly y: f32;
+}
+declare function f32x2(x: f32, y?: f32): f32x2;
+declare function f32x2(v: vec2): f32x2;
+interface f32x3 extends Lanes<"f32", 3> {
+    readonly x: f32;
+    readonly y: f32;
+    readonly z: f32;
+}
+declare function f32x3(x: f32, y?: f32, z?: f32): f32x3;
+declare function f32x3(v: vec3): f32x3;
+interface f32x4 extends Lanes<"f32", 4> {
+    readonly x: f32;
+    readonly y: f32;
+    readonly z: f32;
+    readonly w: f32;
+}
+declare function f32x4(x: f32, y?: f32, z?: f32, w?: f32): f32x4;
+declare function f32x4(v: vec4): f32x4;
+interface i32x2 extends Lanes<"i32", 2> {
+    readonly x: i32;
+    readonly y: i32;
+}
+declare function i32x2(x: i32, y?: i32): i32x2;
+interface i32x3 extends Lanes<"i32", 3> {
+    readonly x: i32;
+    readonly y: i32;
+    readonly z: i32;
+}
+declare function i32x3(x: i32, y?: i32, z?: i32): i32x3;
+interface i32x4 extends Lanes<"i32", 4> {
+    readonly x: i32;
+    readonly y: i32;
+    readonly z: i32;
+    readonly w: i32;
+}
+declare function i32x4(x: i32, y?: i32, z?: i32, w?: i32): i32x4;
+declare function vadd<V extends NumberVector>(a: V, b: V | number): V;
+declare function vsub<V extends NumberVector>(a: V, b: V | number): V;
+declare function vmul<V extends NumberVector>(a: V, b: V | number): V;
+declare function vdiv<V extends F32Vector>(a: V, b: V | number): V;
+declare function vmin<V extends NumberVector>(a: V, b: V | number): V;
+declare function vmax<V extends NumberVector>(a: V, b: V | number): V;
+declare function vabs<V extends NumberVector>(a: V): V;
+declare function vneg<V extends NumberVector>(a: V): V;
+declare function vsqrt<V extends F32Vector>(a: V): V;
+declare function vfloor<V extends F32Vector>(a: V): V;
+declare function vlt<V extends NumberVector>(a: V, b: V | number): MaskOf<V>;
+declare function vle<V extends NumberVector>(a: V, b: V | number): MaskOf<V>;
+declare function veq<V extends NumberVector>(a: V, b: V | number): MaskOf<V>;
+declare function vne<V extends NumberVector>(a: V, b: V | number): MaskOf<V>;
+declare function vselect<V extends NumberVector>(mask: MaskOf<V>, a: V, b: V): V;
+declare function vand<V extends I32Vector | MaskVector>(a: V, b: V | number): V;
+declare function vor<V extends I32Vector | MaskVector>(a: V, b: V | number): V;
+declare function vxor<V extends I32Vector>(a: V, b: V | number): V;
+declare function vnot<V extends I32Vector | MaskVector>(a: V): V;
+declare function vshl<V extends I32Vector>(a: V, b: V | number): V;
+declare function vshr<V extends I32Vector>(a: V, b: V | number): V;
+declare function vushr<V extends I32Vector>(a: V, b: V | number): V;
+declare function vmuladd<V extends F32Vector>(a: V, b: V | number, c: V | number): V;
+declare function vlerp<V extends F32Vector>(a: V, b: V, t: V | number): V;
+declare function vclamp<V extends F32Vector>(x: V, low: V | number, high: V | number): V;
+declare function vfloat<V extends I32Vector>(a: V): FloatOf<V>;
+declare function vint<V extends F32Vector>(a: V): IntOf<V>;
+declare function vlane<V extends AnyVector>(a: V, lane: 0 | 1 | 2 | 3): V["x"];
+declare function vwith<V extends AnyVector>(a: V, lane: 0 | 1 | 2 | 3, value: V["x"]): V;
+declare function vshuffle<V extends AnyVector>(a: V, lanes: readonly number[], b?: V): V;
+declare function vdot<V extends NumberVector>(a: V, b: V): number;
+declare function vsum(a: NumberVector): number;
+declare function vhmin(a: NumberVector): number;
+declare function vhmax(a: NumberVector): number;
+declare function vlength(a: F32Vector): f32;
+declare function vnormalize<V extends F32Vector>(a: V): V;
+declare function vcross(a: f32x3, b: f32x3): f32x3;
+declare function vtovec<V extends F32Vector>(a: V): VecOf<V>;
+
+declare const IMPORT_DEFAULT_SAMPLES = 256;
+declare const IMPORT_DEFAULT_MAX_DRIFT = 0.05;
+type ImportActivation = {
+    readonly kind: "linear";
+} | {
+    readonly kind: "relu";
+} | {
+    readonly kind: "clip";
+    readonly low: number;
+    readonly high: number;
+} | {
+    readonly kind: "tanh";
+};
+interface FloatLayer {
+    readonly inputs: number;
+    readonly outputs: number;
+    readonly weights: Float32Array;
+    readonly bias: Float32Array;
+    activation: ImportActivation;
+}
+interface FloatNet {
+    readonly layers: readonly FloatLayer[];
+}
+interface ImportLayerReport {
+    readonly net: number;
+    readonly layer: number;
+    readonly inputs: number;
+    readonly outputs: number;
+    readonly activation: number;
+    readonly weightScale: number;
+    readonly activationScale: number;
+    readonly multiplier: number;
+    readonly shift: number;
+}
+interface ImportDrift {
+    readonly samples: number;
+    readonly maxError: number;
+    readonly peak: number;
+    readonly relative: number;
+    readonly bound: number;
+}
+interface Imported {
+    readonly blob: Uint32Array;
+    readonly inputScale: number;
+    readonly layers: readonly ImportLayerReport[];
+    readonly drift: ImportDrift;
+    readonly memory: number;
+}
+declare class ImportError extends GameError {
+    constructor(message: string);
+}
+declare function readOnnx(bytes: Uint8Array): FloatNet;
+declare function checkNet(net: FloatNet): void;
+declare function generatedSamples(inputs: number, count?: number, range?: number, seed?: number): Float32Array;
+declare function floatEval(net: FloatNet, input: ArrayLike<number>, out: Float32Array): void;
+interface ImportOptions {
+    readonly samples?: Float32Array;
+    readonly maxDrift?: number;
+    readonly memory?: number;
+}
+declare function importMlp(net: FloatNet, options?: ImportOptions): Imported;
+declare function importMoe(router: FloatNet, experts: readonly FloatNet[], options?: ImportOptions): Imported;
+interface PlainLayer {
+    readonly weights: readonly (readonly number[])[];
+    readonly bias?: readonly number[];
+    readonly activation?: "linear" | "relu" | "tanh" | {
+        readonly clip: readonly [number, number];
+    };
+}
+declare function plainNet(layers: readonly PlainLayer[]): FloatNet;
+
+declare const MLP_MEMORY_MIN = 2;
+declare const MLP_MEMORY_MAX = 4;
+interface MlpMemory {
+    readonly width: number;
+    readonly previous: ArrayLike<number>;
+    readonly next: ArrayLike<number>;
+}
+interface MlpTrainingData {
+    readonly samples: number;
+    readonly inputs: ArrayLike<number>;
+    readonly targets: ArrayLike<number>;
+    readonly memory?: MlpMemory;
+}
+interface MlpEpisode {
+    readonly inputs: readonly (readonly number[])[];
+    readonly targets: readonly (readonly number[])[];
+    readonly memory: readonly (readonly number[])[];
+}
+declare function joinMemory(data: MlpTrainingData): MlpTrainingData;
+declare function memorySamples(episodes: readonly MlpEpisode[]): MlpTrainingData;
+interface MlpTrainingOptions {
+    readonly widths: readonly number[];
+    readonly epochs?: number;
+    readonly batch?: number;
+    readonly learningRate?: number;
+    readonly momentum?: number;
+    readonly seed?: number;
+}
+interface MlpTrained {
+    readonly blob: Uint32Array;
+    readonly loss: Float32Array;
+    readonly blobLoss: number;
+}
+declare function trainMlp(source: MlpTrainingData, options: MlpTrainingOptions): MlpTrained;
+declare const MOE_DEFAULT_BALANCE = 0.5;
+interface MoeTrainingOptions {
+    readonly experts: number;
+    readonly router?: readonly number[];
+    readonly expert?: readonly number[];
+    readonly epochs?: number;
+    readonly batch?: number;
+    readonly learningRate?: number;
+    readonly momentum?: number;
+    readonly seed?: number;
+    readonly balance?: number;
+}
+interface MoeTrained {
+    readonly blob: Uint32Array;
+    readonly loss: Float32Array;
+    readonly blobLoss: number;
+    readonly usage: Uint32Array;
+}
+declare function trainMoe(source: MlpTrainingData, options: MoeTrainingOptions): MoeTrained;
+
+type Mat3Array = Float32Array | Float64Array;
+declare const MAT3_SIZE = 9;
+declare function mat3Identity(out: Mat3Array, o: number): void;
+declare function mat3FromMat4(out: Mat3Array, o: number, m: ArrayLike<number>, mo: number): void;
+declare function mat3Determinant(m: ArrayLike<number>, o: number): number;
+declare function mat3Invert(out: Mat3Array, o: number, m: ArrayLike<number>, mo: number): boolean;
+declare function mat3Transpose(out: Mat3Array, o: number, m: ArrayLike<number>, mo: number): void;
+declare function mat3Multiply(out: Mat3Array, o: number, a: ArrayLike<number>, ao: number, b: ArrayLike<number>, bo: number): void;
+declare function mat3NormalMatrix(out: Mat3Array, o: number, m: ArrayLike<number>, mo: number): boolean;
+declare function mat3SetUvTransform(out: Mat3Array, o: number, tx: number, ty: number, sx: number, sy: number, rotation: number, cx: number, cy: number): void;
+
+declare class Noise {
+    private readonly perm;
+    private readonly perm12;
+    constructor(seed?: number);
+    reseed(seed: number): void;
+    perlin(x: number, y: number, z: number): number;
+    simplex2(xin: number, yin: number): number;
+    simplex3(xin: number, yin: number, zin: number): number;
+    simplex4(x: number, y: number, z: number, w: number): number;
+    fbm2(x: number, y: number, octaves: number, lacunarity?: number, gain?: number): number;
+    fbm3(x: number, y: number, z: number, octaves: number, lacunarity?: number, gain?: number): number;
+    ridged2(x: number, y: number, octaves: number, lacunarity?: number, gain?: number): number;
+    fill2(out: Float32Array, width: number, height: number, scale: number, octaves?: number, offsetX?: number, offsetY?: number): void;
+}
+
+type CurvePoint = Vec2 | Vec3;
+type CatmullRomType = "centripetal" | "chordal" | "catmullrom";
+interface FrenetFrames {
+    readonly segments: number;
+    readonly tangents: Float32Array;
+    readonly normals: Float32Array;
+    readonly binormals: Float32Array;
+}
+declare function allocateFrenetFrames(segments: number): FrenetFrames;
+declare abstract class Curve<V extends CurvePoint> {
+    arcLengthDivisions: number;
+    needsUpdate: boolean;
+    private cache;
+    private scratchA;
+    private scratchB;
+    abstract createPoint(): V;
+    abstract getPoint(t: number, out: V): V;
+    get dimensions(): 2 | 3;
+    protected scratch(which: 0 | 1): V;
+    getPointAt(u: number, out: V): V;
+    getPoints(divisions?: number): V[];
+    getSpacedPointList(divisions?: number): V[];
+    getSpacedPoints(divisions: number, out?: Float32Array, stride?: 2 | 3): Float32Array;
+    getLength(): number;
+    getLengths(divisions?: number): Float64Array;
+    updateArcLengths(): void;
+    getUtoTmapping(u: number, distance?: number): number;
+    getTangent(t: number, out: V): V;
+    getTangentAt(u: number, out: V): V;
+    computeFrenetFrames(segments: number, closed?: boolean, out?: FrenetFrames): FrenetFrames;
+}
+declare abstract class Curve2 extends Curve<Vec2> {
+    createPoint(): Vec2;
+}
+declare abstract class Curve3 extends Curve<Vec3> {
+    createPoint(): Vec3;
+}
+declare class LineCurve extends Curve2 {
+    readonly v1: Vec2;
+    readonly v2: Vec2;
+    constructor(v1?: Vec2, v2?: Vec2);
+    getPoint(t: number, out: Vec2): Vec2;
+    getPointAt(u: number, out: Vec2): Vec2;
+    getTangent(_t: number, out: Vec2): Vec2;
+    getTangentAt(u: number, out: Vec2): Vec2;
+}
+declare class LineCurve3 extends Curve3 {
+    readonly v1: Vec3;
+    readonly v2: Vec3;
+    constructor(v1?: Vec3, v2?: Vec3);
+    getPoint(t: number, out: Vec3): Vec3;
+    getPointAt(u: number, out: Vec3): Vec3;
+    getTangent(_t: number, out: Vec3): Vec3;
+    getTangentAt(u: number, out: Vec3): Vec3;
+}
+declare class QuadraticBezierCurve extends Curve2 {
+    readonly v0: Vec2;
+    readonly v1: Vec2;
+    readonly v2: Vec2;
+    constructor(v0?: Vec2, v1?: Vec2, v2?: Vec2);
+    getPoint(t: number, out: Vec2): Vec2;
+}
+declare class QuadraticBezierCurve3 extends Curve3 {
+    readonly v0: Vec3;
+    readonly v1: Vec3;
+    readonly v2: Vec3;
+    constructor(v0?: Vec3, v1?: Vec3, v2?: Vec3);
+    getPoint(t: number, out: Vec3): Vec3;
+}
+declare class CubicBezierCurve extends Curve2 {
+    readonly v0: Vec2;
+    readonly v1: Vec2;
+    readonly v2: Vec2;
+    readonly v3: Vec2;
+    constructor(v0?: Vec2, v1?: Vec2, v2?: Vec2, v3?: Vec2);
+    getPoint(t: number, out: Vec2): Vec2;
+}
+declare class CubicBezierCurve3 extends Curve3 {
+    readonly v0: Vec3;
+    readonly v1: Vec3;
+    readonly v2: Vec3;
+    readonly v3: Vec3;
+    constructor(v0?: Vec3, v1?: Vec3, v2?: Vec3, v3?: Vec3);
+    getPoint(t: number, out: Vec3): Vec3;
+}
+declare class SplineCurve extends Curve2 {
+    readonly points: Vec2[];
+    constructor(points?: Vec2[]);
+    getPoint(t: number, out: Vec2): Vec2;
+}
+declare class CatmullRomCurve3 extends Curve3 {
+    readonly points: Vec3[];
+    closed: boolean;
+    curveType: CatmullRomType;
+    tension: number;
+    private readonly px;
+    private readonly py;
+    private readonly pz;
+    private readonly head;
+    private readonly tail;
+    constructor(points?: Vec3[], closed?: boolean, curveType?: CatmullRomType, tension?: number);
+    getPoint(t: number, out: Vec3): Vec3;
+}
+declare class EllipseCurve extends Curve2 {
+    aX: number;
+    aY: number;
+    xRadius: number;
+    yRadius: number;
+    aStartAngle: number;
+    aEndAngle: number;
+    aClockwise: boolean;
+    aRotation: number;
+    constructor(aX?: number, aY?: number, xRadius?: number, yRadius?: number, aStartAngle?: number, aEndAngle?: number, aClockwise?: boolean, aRotation?: number);
+    getPoint(t: number, out: Vec2): Vec2;
+}
+declare class ArcCurve extends EllipseCurve {
+    constructor(aX?: number, aY?: number, radius?: number, startAngle?: number, endAngle?: number, clockwise?: boolean);
+}
+declare class FunctionCurve3 extends Curve3 {
+    private readonly fn;
+    constructor(fn: (t: number, out: Vec3) => Vec3);
+    getPoint(t: number, out: Vec3): Vec3;
+}
+declare class CurvePath<V extends CurvePoint> extends Curve<V> {
+    readonly curves: Curve<V>[];
+    autoClose: boolean;
+    private curveLengths;
+    private readonly prototypePoint;
+    constructor(prototypePoint: V);
+    createPoint(): V;
+    add(curve: Curve<V>): this;
+    closePath(): this;
+    getPoint(t: number, out: V): V;
+    getPointAt(u: number, out: V): V;
+    getUtoTmapping(u: number): number;
+    getLength(): number;
+    updateArcLengths(): void;
+    getCurveLengths(): Float64Array;
+    getPoints(divisions?: number): V[];
+}
+declare class CurvePath3 extends CurvePath<Vec3> {
+    constructor();
+}
+declare class Path extends CurvePath<Vec2> {
+    readonly currentPoint: Vec2;
+    constructor(points?: readonly Vec2[]);
+    setFromPoints(points: readonly Vec2[]): this;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
+    splineThru(points: readonly Vec2[]): this;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
+    absarc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
+    ellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
+    absellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
+}
+interface ShapePoints {
+    readonly shape: Vec2[];
+    readonly holes: Vec2[][];
+}
+declare class Shape extends Path {
+    readonly holes: Path[];
+    getPointsHoles(divisions?: number): Vec2[][];
+    extractPoints(divisions?: number): ShapePoints;
+}
+declare function copyCurvePoint<V extends CurvePoint>(out: V, p: V): V;
+
+declare function earcut(data: ArrayLike<number>, holeIndices?: ArrayLike<number> | null, dim?: number): number[];
+declare function earcutDeviation(data: ArrayLike<number>, holeIndices: ArrayLike<number> | null, dim: number, triangles: ArrayLike<number>): number;
+declare function contourArea(contour: readonly Vec2[]): number;
+declare function isClockWise(contour: readonly Vec2[]): boolean;
+declare function triangulateShape(contour: readonly Vec2[], holes: readonly (readonly Vec2[])[]): number[];
+declare const ShapeUtils: {
+    readonly area: typeof contourArea;
+    readonly isClockWise: typeof isClockWise;
+    readonly triangulateShape: typeof triangulateShape;
+};
+
+interface PrimitiveBuffers {
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array;
+    readonly indices: Uint16Array | Uint32Array;
+}
+interface PrimitiveSize {
+    readonly vertices: number;
+    readonly indices: number;
+}
+declare function allocatePrimitive(size: PrimitiveSize): PrimitiveBuffers;
+declare function primitiveDesc(buffers: PrimitiveBuffers): GeometryDesc;
+declare function boxSize(): PrimitiveSize;
+declare function writeBox(out: PrimitiveBuffers, width: number, height: number, depth: number): void;
+declare function planeSize(): PrimitiveSize;
+declare function writePlane(out: PrimitiveBuffers, width: number, height: number): void;
+declare function sphereSize(widthSegments: number, heightSegments: number): PrimitiveSize;
+declare function writeSphere(out: PrimitiveBuffers, radius: number, widthSegments: number, heightSegments: number): void;
+declare function cylinderSize(radialSegments: number): PrimitiveSize;
+declare function writeCylinder(out: PrimitiveBuffers, radiusTop: number, radiusBottom: number, height: number, radialSegments: number): void;
+declare function boxGeometry(width?: number, height?: number, depth?: number): GeometryDesc;
+declare function planeGeometry(width?: number, height?: number): GeometryDesc;
+declare function sphereGeometry(radius?: number, widthSegments?: number, heightSegments?: number): GeometryDesc;
+declare function cylinderGeometry(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number): GeometryDesc;
+
+declare function planeGridSize(widthSegments: number, heightSegments: number): PrimitiveSize;
+declare function writePlaneGrid(out: PrimitiveBuffers, width: number, height: number, widthSegments: number, heightSegments: number): void;
+declare function planeGridGeometry(width?: number, height?: number, widthSegments?: number, heightSegments?: number): GeometryDesc;
+declare function circleSize(segments: number): PrimitiveSize;
+declare function writeCircle(out: PrimitiveBuffers, radius: number, segments: number, thetaStart: number, thetaLength: number): void;
+declare function circleGeometry(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number): GeometryDesc;
+declare function ringSize(thetaSegments: number, phiSegments: number): PrimitiveSize;
+declare function writeRing(out: PrimitiveBuffers, innerRadius: number, outerRadius: number, thetaSegments: number, phiSegments: number, thetaStart: number, thetaLength: number): void;
+declare function ringGeometry(innerRadius?: number, outerRadius?: number, thetaSegments?: number, phiSegments?: number, thetaStart?: number, thetaLength?: number): GeometryDesc;
+declare function cylinderShellSize(radiusTop: number, radiusBottom: number, radialSegments: number, heightSegments: number, openEnded: boolean): PrimitiveSize;
+declare function writeCylinderShell(out: PrimitiveBuffers, radiusTop: number, radiusBottom: number, height: number, radialSegments: number, heightSegments: number, openEnded: boolean, thetaStart: number, thetaLength: number): void;
+declare function cylinderShellGeometry(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean, thetaStart?: number, thetaLength?: number): GeometryDesc;
+declare function coneGeometry(radius?: number, height?: number, radialSegments?: number, heightSegments?: number, openEnded?: boolean, thetaStart?: number, thetaLength?: number): GeometryDesc;
+declare function sphereSectorSize(widthSegments: number, heightSegments: number, thetaStart: number, thetaLength: number): PrimitiveSize;
+declare function writeSphereSector(out: PrimitiveBuffers, radius: number, widthSegments: number, heightSegments: number, phiStart: number, phiLength: number, thetaStart: number, thetaLength: number): void;
+declare function sphereSectorGeometry(radius?: number, widthSegments?: number, heightSegments?: number, phiStart?: number, phiLength?: number, thetaStart?: number, thetaLength?: number): GeometryDesc;
+declare function torusSize(radialSegments: number, tubularSegments: number): PrimitiveSize;
+declare function writeTorus(out: PrimitiveBuffers, radius: number, tube: number, radialSegments: number, tubularSegments: number, arc: number): void;
+declare function torusGeometry(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number): GeometryDesc;
+declare function torusKnotSize(tubularSegments: number, radialSegments: number): PrimitiveSize;
+declare function writeTorusKnot(out: PrimitiveBuffers, radius: number, tube: number, tubularSegments: number, radialSegments: number, p: number, q: number): void;
+declare function torusKnotGeometry(radius?: number, tube?: number, tubularSegments?: number, radialSegments?: number, p?: number, q?: number): GeometryDesc;
+declare function capsuleSize(capSegments: number, radialSegments: number, heightSegments: number): PrimitiveSize;
+declare function writeCapsule(out: PrimitiveBuffers, radius: number, height: number, capSegments: number, radialSegments: number, heightSegments: number): void;
+declare function capsuleGeometry(radius?: number, height?: number, capSegments?: number, radialSegments?: number, heightSegments?: number): GeometryDesc;
+declare function latheSize(points: number, segments: number): PrimitiveSize;
+declare function writeLathe(out: PrimitiveBuffers, points: readonly Vec2[], segments: number, phiStart: number, phiLength: number): void;
+declare function latheGeometry(points?: readonly Vec2[], segments?: number, phiStart?: number, phiLength?: number): GeometryDesc;
+declare function tubeSize(tubularSegments: number, radialSegments: number): PrimitiveSize;
+declare function writeTube<V extends CurvePoint>(out: PrimitiveBuffers, path: Curve<V>, tubularSegments: number, radius: number, radialSegments: number, closed: boolean, frames?: FrenetFrames): void;
+declare function tubeGeometry<V extends CurvePoint>(path: Curve<V>, tubularSegments?: number, radius?: number, radialSegments?: number, closed?: boolean): GeometryDesc;
+type ParametricFunction = (u: number, v: number, out: Vec3) => void;
+declare function parametricSize(slices: number, stacks: number): PrimitiveSize;
+declare function writeParametric(out: PrimitiveBuffers, fn: ParametricFunction, slices: number, stacks: number): void;
+declare function parametricGeometry(fn: ParametricFunction, slices?: number, stacks?: number): GeometryDesc;
+declare function segmentedBoxSize(widthSegments: number, heightSegments: number, depthSegments: number): PrimitiveSize;
+declare function writeSegmentedBox(out: PrimitiveBuffers, width: number, height: number, depth: number, widthSegments: number, heightSegments: number, depthSegments: number): void;
+declare function segmentedBoxGeometry(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number): GeometryDesc;
+declare function roundedBoxGeometry(width?: number, height?: number, depth?: number, segments?: number, radius?: number): GeometryDesc;
+declare function polyhedronGeometry(vertices: ArrayLike<number>, indices: ArrayLike<number>, radius?: number, detail?: number): GeometryDesc;
+declare function tetrahedronGeometry(radius?: number, detail?: number): GeometryDesc;
+declare function octahedronGeometry(radius?: number, detail?: number): GeometryDesc;
+declare function icosahedronGeometry(radius?: number, detail?: number): GeometryDesc;
+declare function dodecahedronGeometry(radius?: number, detail?: number): GeometryDesc;
+declare function shapeGeometry(shapes: Shape | readonly Shape[], curveSegments?: number): GeometryDesc;
+interface ExtrudeOptions {
+    readonly curveSegments?: number;
+    readonly steps?: number;
+    readonly depth?: number;
+    readonly bevelEnabled?: boolean;
+    readonly bevelThickness?: number;
+    readonly bevelSize?: number;
+    readonly bevelOffset?: number;
+    readonly bevelSegments?: number;
+    readonly extrudePath?: Curve<Vec3>;
+}
+declare function extrudeGeometry(shapes: Shape | readonly Shape[], options?: ExtrudeOptions): GeometryDesc;
+interface PositionSource$1 {
+    readonly attributes: GeometryDesc["attributes"];
+    readonly index?: ArrayLike<number>;
+}
+declare function edgesGeometry(geometry: PositionSource$1, thresholdAngleDegrees?: number): GeometryDesc;
+declare function wireframeGeometry(geometry: PositionSource$1): GeometryDesc;
+
+declare function computeVertexNormals(geometry: GeometryDesc): GeometryDesc;
+declare function computeTangents(geometry: GeometryDesc): GeometryDesc;
+declare function toNonIndexed(geometry: GeometryDesc): GeometryDesc;
+declare function mergeGeometries(geometries: readonly GeometryDesc[], useGroups?: boolean): GeometryDesc;
+declare function mergeVertices(geometry: GeometryDesc, tolerance?: number, keep?: readonly string[]): GeometryDesc;
+declare function computeBoundingBox(geometry: GeometryDesc, out: Box3): Box3;
+declare function computeBoundingSphere(geometry: GeometryDesc, out: Sphere, scratch: Box3): Sphere;
+declare function translateGeometry(geometry: GeometryDesc, x: number, y: number, z: number): GeometryDesc;
+declare function centerGeometry(geometry: GeometryDesc, scratch: Box3, offset: Vec3): GeometryDesc;
+declare function applyMatrix4(geometry: GeometryDesc, m: ArrayLike<number>, mo?: number): GeometryDesc;
+
+interface TypefaceGlyph {
+    readonly ha: number;
+    readonly x_min?: number;
+    readonly x_max?: number;
+    readonly o?: string;
+}
+interface TypefaceFont {
+    readonly glyphs: Readonly<Record<string, TypefaceGlyph>>;
+    readonly familyName?: string;
+    readonly resolution: number;
+    readonly ascender?: number;
+    readonly descender?: number;
+    readonly underlineThickness?: number;
+    readonly boundingBox: {
+        readonly xMin?: number;
+        readonly xMax?: number;
+        readonly yMin: number;
+        readonly yMax: number;
+    };
+}
+type TextGeometryDirection = "ltr" | "rtl" | "tb";
+interface TextGeometryOptions extends Omit<ExtrudeOptions, "extrudePath"> {
+    readonly size?: number;
+    readonly direction?: TextGeometryDirection;
+}
+declare class ShapePath {
+    readonly subPaths: Path[];
+    private current;
+    moveTo(x: number, y: number): this;
+    lineTo(x: number, y: number): this;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): this;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;
+    private path;
+    toShapes(): Shape[];
+}
+declare function textShapes(font: TypefaceFont, text: string, size?: number, direction?: TextGeometryDirection): Shape[];
+declare function textGeometry(font: TypefaceFont, text: string, options?: TextGeometryOptions): GeometryDesc;
+
+type Mat4Array = Float32Array | Float64Array;
+declare function mat4Identity(out: Mat4Array, o: number): void;
+declare function mat4Compose(out: Mat4Array, o: number, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number, sx: number, sy: number, sz: number): void;
+declare function mat4Multiply(out: Mat4Array, o: number, a: Mat4Array, ao: number, b: Mat4Array, bo: number): void;
+declare function mat4TransformPoint(m: Mat4Array, o: number, v: Vec3): Vec3;
+declare function mat4Translation(m: Mat4Array, o: number, out: Vec3): Vec3;
+declare function mat4ComposeArrays(out: Mat4Array, o: number, position: Float32Array, po: number, rotation: Float32Array, ro: number, scale: Float32Array, so: number): void;
+declare function quatSlerpArrays(out: Float32Array, o: number, a: Float32Array, ao: number, b: Float32Array, bo: number, weights: Float64Array, wi: number): void;
+declare function mat4Copy(out: Mat4Array, o: number, m: ArrayLike<number>, mo: number): void;
+declare function mat4Transpose(out: Mat4Array, o: number, m: ArrayLike<number>, mo: number): void;
+declare function mat4Determinant(m: ArrayLike<number>, mo: number): number;
+declare function mat4Invert(out: Mat4Array, o: number, m: ArrayLike<number>, mo: number): boolean;
+declare function quatFromRotationColumns(out: Float32Array | Float64Array, o: number, m11: number, m21: number, m31: number, m12: number, m22: number, m32: number, m13: number, m23: number, m33: number): void;
+declare function mat4Decompose(m: ArrayLike<number>, mo: number, position: Float32Array | Float64Array, po: number, rotation: Float32Array | Float64Array, ro: number, scale: Float32Array | Float64Array, so: number): void;
+declare function mat4LookAt(out: Mat4Array, o: number, eyeX: number, eyeY: number, eyeZ: number, targetX: number, targetY: number, targetZ: number, upX: number, upY: number, upZ: number): void;
+declare function mat4Perspective(out: Mat4Array, o: number, fovYRadians: number, aspect: number, near: number, far: number): void;
+declare function mat4Frustum(out: Mat4Array, o: number, left: number, right: number, bottom: number, top: number, near: number, far: number): void;
+declare function mat4Orthographic(out: Mat4Array, o: number, left: number, right: number, bottom: number, top: number, near: number, far: number): void;
+declare function mat4TransformPointArrays(m: ArrayLike<number>, mo: number, v: ArrayLike<number>, vo: number, out: Float32Array | Float64Array, oo: number): void;
+declare function mat4TransformDirection(m: Mat4Array, o: number, v: Vec3): Vec3;
+declare function mat4MaxScale(m: ArrayLike<number>, mo: number): number;
+declare function slerpInto(out: Float32Array, o: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number, t: number): void;
+
+declare function detSin(x: number): number;
+declare function detCos(x: number): number;
+declare function detLog(x: number): number;
+declare function detExp(x: number): number;
+
+declare class LineWriter {
+    readonly capacity: number;
+    readonly positions: Float32Array;
+    readonly colors: Float32Array;
+    count: number;
+    dropped: number;
+    private hex;
+    private r;
+    private g;
+    private b;
+    private a;
+    private readonly corners;
+    private readonly basis;
+    private readonly matrix;
+    private transformed;
+    constructor(capacity: number);
+    get vertexCount(): number;
+    clear(): void;
+    color(hex: number, alpha?: number): this;
+    setMatrix(m: ArrayLike<number> | null, mo?: number): this;
+    segment(ax: number, ay: number, az: number, bx: number, by: number, bz: number): boolean;
+    axes(m: ArrayLike<number> | null, mo: number, size: number): this;
+    axesAt(px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number, size: number): this;
+    box(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, m?: ArrayLike<number> | null, mo?: number): this;
+    frustum(inverseViewProjection: ArrayLike<number>, io: number, apex?: ArrayLike<number> | null): this;
+    circle(cx: number, cy: number, cz: number, radius: number, nx: number, ny: number, nz: number, segments?: number): this;
+    sphere(cx: number, cy: number, cz: number, radius: number, segments?: number): this;
+    cross(x: number, y: number, z: number, size: number): this;
+    arrow(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, length: number, headLength?: number, headWidth?: number): this;
+    grid(size: number, divisions: number, centerColor?: number, gridColor?: number, y?: number): this;
+    polarGrid(radius: number, sectors: number, rings: number, divisions: number, sectorColor?: number, ringColor?: number, y?: number): this;
+    plane(nx: number, ny: number, nz: number, constant: number, size: number): this;
+    path(points: ArrayLike<number>, count: number, closed?: boolean, stride?: number): this;
+    skeleton(parents: ArrayLike<number>, worlds: ArrayLike<number>, count: number, offset?: number): this;
+    normals(positions: ArrayLike<number>, normals: ArrayLike<number>, vertices: number, size: number): this;
+    directionalLight(size: number, length: number): this;
+    spotLight(angle: number, distance: number, segments?: number): this;
+    hemisphere(size: number, skyColor: number, groundColor: number): this;
+    audioCone(innerAngle: number, outerAngle: number, range: number, innerColor?: number, outerColor?: number): this;
+    private cone;
+    private halfCircle;
+    private cornerEdges;
+    private basisFor;
+}
+declare function lineGeometry(writer: LineWriter, dynamic?: boolean): GeometryDesc;
+declare function axesHelper(size?: number): GeometryDesc;
+declare function gridHelper(size?: number, divisions?: number, centerColor?: number, gridColor?: number): GeometryDesc;
+declare function polarGridHelper(radius?: number, sectors?: number, rings?: number, divisions?: number, sectorColor?: number, ringColor?: number): GeometryDesc;
+declare function arrowHelper(direction: readonly [number, number, number], length?: number, color?: number, headLength?: number, headWidth?: number): GeometryDesc;
+declare function boxHelper(min: readonly [number, number, number], max: readonly [number, number, number], color?: number): GeometryDesc;
+declare function cameraHelper(projectionInverse: ArrayLike<number>, color?: number): GeometryDesc;
+declare function directionalLightHelper(size?: number, length?: number, color?: number): GeometryDesc;
+declare function spotLightHelper(angle: number, distance?: number, color?: number, segments?: number): GeometryDesc;
+declare function pointLightHelper(radius?: number, color?: number, segments?: number): GeometryDesc;
+declare function hemisphereLightHelper(size?: number, skyColor?: number, groundColor?: number): GeometryDesc;
+declare function planeHelper(normal: readonly [number, number, number], constant?: number, size?: number, color?: number): GeometryDesc;
+declare function skeletonHelper(parents: ArrayLike<number>, worlds: ArrayLike<number>, color?: number): GeometryDesc;
+declare function vertexNormalsHelper(positions: ArrayLike<number>, normals: ArrayLike<number>, size?: number, color?: number): GeometryDesc;
+declare function positionalAudioHelper(innerAngle: number, outerAngle: number, range?: number, innerColor?: number, outerColor?: number): GeometryDesc;
+declare function helperSegments(desc: GeometryDesc): number;
+
+declare const DEFAULT_DEBUG_SEGMENTS = 8192;
+interface DebugGraphics {
+    createGeometry(desc: GeometryDesc): GeometryId;
+    createMaterial(desc: MaterialDesc): MaterialId;
+    createDetached(desc: NodeDesc): NodeId;
+    markGeometryDirty(geometry: GeometryId, name: string, start?: number, count?: number): void;
+    setDrawRange(geometry: GeometryId, start: number, count: number): void;
+    setLayers(node: NodeId, mask: number): void;
+    setVisible(node: NodeId, visible: boolean): void;
+}
+interface ContactSource {
+    contactCount(): number;
+    contactEntityA(index: number): Entity;
+    contactEntityB(index: number): Entity;
+    contactStarted(index: number): boolean;
+}
+interface PositionSource {
+    position(entity: Entity, out: Vec3): Vec3;
+}
+interface DebugDrawOptions {
+    readonly capacity?: number;
+    readonly layers?: number;
+    readonly depthTest?: boolean;
+    readonly renderOrder?: number;
+}
+declare class DebugDraw {
+    readonly writer: LineWriter;
+    readonly node: NodeId;
+    readonly geometry: GeometryId;
+    readonly material: MaterialId;
+    private readonly graphics;
+    private flushed;
+    private visible;
+    private readonly a;
+    private readonly b;
+    constructor(graphics: DebugGraphics, options?: DebugDrawOptions);
+    get segments(): number;
+    get dropped(): number;
+    get capacity(): number;
+    setLayers(mask: number): void;
+    setVisible(visible: boolean): void;
+    clear(): void;
+    color(hex: number, alpha?: number): this;
+    transform(matrix: ArrayLike<number> | null, offset?: number): this;
+    line(ax: number, ay: number, az: number, bx: number, by: number, bz: number, color?: number): this;
+    ray(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, length: number, color?: number): this;
+    arrow(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, length: number, color?: number): this;
+    box(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, color?: number): this;
+    boxTransformed(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, matrix: ArrayLike<number>, offset?: number, color?: number): this;
+    sphere(x: number, y: number, z: number, radius: number, color?: number, segments?: number): this;
+    circle(x: number, y: number, z: number, radius: number, nx: number, ny: number, nz: number, color?: number, segments?: number): this;
+    axes(matrix: ArrayLike<number>, offset?: number, size?: number): this;
+    axesAt(px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number, size?: number): this;
+    grid(size?: number, divisions?: number, y?: number): this;
+    polarGrid(radius: number, sectors: number, rings: number, divisions?: number, y?: number): this;
+    frustum(projection: CameraProjection, color?: number): this;
+    frustumMatrix(inverseViewProjection: ArrayLike<number>, offset?: number, color?: number): this;
+    plane(nx: number, ny: number, nz: number, constant: number, size: number, color?: number): this;
+    point(x: number, y: number, z: number, size: number, color?: number): this;
+    skeleton(parents: ArrayLike<number>, worlds: ArrayLike<number>, count?: number, color?: number): this;
+    path(points: ArrayLike<number>, count: number, color?: number, closed?: boolean): this;
+    navPath(path: NavPath, color?: number, marker?: number): this;
+    contacts(source: ContactSource, positions: PositionSource, color?: number, startedColor?: number): this;
+    shape(shape: ShapeDesc, matrix: ArrayLike<number>, offset?: number, color?: number): this;
+    flush(): void;
+    private tube;
+}
+
+declare const DEFAULT_LABEL_CAPACITY = 64;
+interface LabelAnchorSource {
+    renderPosition(entity: Entity, out: Vec3): Vec3;
+}
+interface LabelOccluder {
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+}
+interface LabelText {
+    create(entity: Entity, desc: NodeDesc): NodeId;
+    setText(node: NodeId, text: string): void;
+    setVisible(node: NodeId, visible: boolean): void;
+    setTextStyle(node: NodeId, style: TextStyleDesc): void;
+}
+interface LabelPlacement {
+    setPosition(entity: Entity, x: number, y: number, z: number): void;
+}
+interface LabelSpawner {
+    spawn(): Entity;
+}
+interface LabelEngineText {
+    readonly text: LabelText;
+    readonly placement: LabelPlacement;
+    readonly spawner: LabelSpawner;
+    readonly add?: (entity: Entity) => void;
+}
+interface ScreenLabelsOptions {
+    readonly capacity?: number;
+    readonly anchors?: LabelAnchorSource;
+    readonly ui?: GameUi;
+    readonly engineText?: LabelEngineText;
+    readonly occluder?: LabelOccluder;
+    readonly occlusionLayers?: number;
+    readonly fadeNear?: number;
+    readonly fadeFar?: number;
+    readonly clampToEdge?: boolean;
+    readonly margin?: number;
+}
+interface LabelDesc {
+    readonly name?: string;
+    readonly entity?: Entity;
+    readonly point?: readonly [number, number, number];
+    readonly offset?: readonly [number, number, number];
+    readonly text?: string;
+    readonly style?: TextStyleDesc;
+    readonly hud?: boolean;
+    readonly occlude?: boolean;
+}
+declare class ScreenLabels {
+    readonly capacity: number;
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+    readonly depth: Float32Array;
+    readonly distance: Float32Array;
+    readonly opacity: Float32Array;
+    readonly visible: Uint8Array;
+    readonly offscreen: Uint8Array;
+    readonly occluded: Uint8Array;
+    fadeNear: number;
+    fadeFar: number;
+    clampToEdge: boolean;
+    margin: number;
+    occlusionLayers: number;
+    private count;
+    private readonly live;
+    private readonly entities;
+    private readonly points;
+    private readonly offsets;
+    private readonly occludes;
+    private readonly nodes;
+    private readonly labelEntity;
+    private readonly shownOpacity;
+    private readonly shown;
+    private readonly hudX;
+    private readonly hudY;
+    private readonly hudVisible;
+    private readonly hudOpacity;
+    private readonly styles;
+    private readonly anchors;
+    private readonly ui;
+    private readonly engine;
+    private readonly occluder;
+    private readonly world;
+    private readonly ndc;
+    private readonly hit;
+    private readonly origin;
+    private readonly direction;
+    constructor(options?: ScreenLabelsOptions);
+    get size(): number;
+    add(desc: LabelDesc): number;
+    textEntity(label: number): Entity;
+    node(label: number): NodeId;
+    setPoint(label: number, x: number, y: number, z: number): void;
+    setText(label: number, text: string): void;
+    remove(label: number): void;
+    update(projection: CameraProjection): void;
+    private anchor;
+    private occludedBy;
+    private publish;
+}
+declare function engineLabelText(graphics: {
+    create(entity: Entity, desc: NodeDesc): NodeId;
+    setText(node: NodeId, text: string): void;
+    setVisible(node: NodeId, visible: boolean): void;
+    setTextStyle(node: NodeId, style: TextStyleDesc): void;
+}, transforms: LabelPlacement & {
+    add(entity: Entity, x?: number, y?: number, z?: number): number;
+}, world: LabelSpawner): LabelEngineText;
+
+interface VehicleWorld {
+    readChassis(body: number, out: Float64Array): boolean;
+    wakeChassis(body: number): void;
+    writeChassis(body: number, motion: Float64Array, wake: boolean): void;
+    castWheel(body: number, origin: Float64Array, direction: Float64Array, hit: Float64Array): number;
+    applyImpulseAtPoint(body: number, impulse: Float64Array, point: Float64Array): void;
+}
+declare class VehicleSolver implements VehiclePort {
+    private readonly world;
+    private capacity;
+    private inputs;
+    private states;
+    private descs;
+    private runs;
+    private vehicles;
+    private active;
+    private activeCount;
+    private free;
+    private freeCount;
+    private readonly chassis;
+    private readonly origin;
+    private readonly direction;
+    private readonly hit;
+    private readonly impulse;
+    private readonly point;
+    private readonly tmp;
+    private readonly reg;
+    constructor(world: VehicleWorld);
+    get count(): number;
+    reserve(capacity: number): void;
+    createVehicle(body: number, desc: Float32Array): number;
+    destroyVehicle(vehicle: number): void;
+    releaseBody(body: number): void;
+    vehicleInputs(): Float32Array;
+    vehicleStates(): Float32Array;
+    update(dt: number): void;
+    private stepVehicle;
+    private drivetrain;
+    private brakeTowardRest;
+    private lockDifferentials;
+    private lean;
+    private ratio;
+    private rotate;
+    private relativeVelocity;
+    private inertiaApply;
+    private inverseMassAlong;
+    private applyImpulse;
+    private writeState;
+}
+
+declare const CRAFT_BODIES: Readonly<Record<CraftPresetName, CraftBodyShape>>;
+declare function presetDesc(name: CraftPresetName, arcade: boolean): CraftDesc;
+declare function tune(desc: CraftDesc, tuning: CraftTuning): CraftDesc;
+
+declare function hullSamples(source: HullSource | undefined): Float32Array;
+declare function encodeCraft(desc: CraftDesc): Float32Array;
+
+type CraftSteering = "stick" | "tilt";
+interface CraftInputOptions {
+    readonly steering?: CraftSteering;
+    readonly invertPitch?: boolean;
+}
+declare class VirtualStick {
+    private readonly input;
+    private readonly controlX;
+    private readonly controlY;
+    private readonly radius;
+    private pointer;
+    private originX;
+    private originY;
+    x: number;
+    y: number;
+    constructor(input: InputActions, radius?: number, controlX?: string, controlY?: string);
+    get active(): boolean;
+    down(pointer: number, x: number, y: number, timeMs: number): void;
+    move(pointer: number, x: number, y: number, timeMs: number): void;
+    up(pointer: number, timeMs: number): void;
+    private emit;
+}
+declare class VirtualSlider {
+    private readonly input;
+    private readonly control;
+    value: number;
+    constructor(input: InputActions, control?: string);
+    set(value: number, timeMs: number): void;
+}
+interface TiltOptions {
+    readonly rangeDegrees?: number;
+    readonly deadzoneDegrees?: number;
+    readonly smoothing?: number;
+}
+declare class TiltSteering {
+    private readonly input;
+    private readonly range;
+    private readonly deadzone;
+    private readonly smoothing;
+    private restBeta;
+    private restGamma;
+    private calibrated;
+    x: number;
+    y: number;
+    constructor(input: InputActions, options?: TiltOptions);
+    calibrate(beta: number, gamma: number): void;
+    update(beta: number, gamma: number, timeMs: number): void;
+    private shape;
+}
+declare class BoatInput {
+    private readonly input;
+    private readonly throttle;
+    private readonly rudder;
+    private readonly sheet;
+    constructor(input: InputActions, options?: CraftInputOptions);
+    apply(boat: Boat): void;
+}
+declare class AircraftInput {
+    private readonly input;
+    private readonly pitch;
+    private readonly roll;
+    private readonly yaw;
+    private readonly throttle;
+    private readonly flaps;
+    private readonly brake;
+    private readonly invert;
+    constructor(input: InputActions, options?: CraftInputOptions);
+    apply(aircraft: Aircraft): void;
+}
+declare class HelicopterInput {
+    private readonly input;
+    private readonly collective;
+    private readonly pitch;
+    private readonly roll;
+    private readonly pedal;
+    constructor(input: InputActions, options?: CraftInputOptions);
+    apply(helicopter: Helicopter): void;
+}
+declare const CRAFT_VIRTUAL_CONTROLS: {
+    readonly stickX: "craft.stick.x";
+    readonly stickY: "craft.stick.y";
+    readonly tiltX: "craft.tilt.x";
+    readonly tiltY: "craft.tilt.y";
+    readonly slider: "craft.slider";
+    readonly pedal: "craft.pedal";
+};
+
+interface NavTilePoly {
+    readonly verts: readonly number[];
+    readonly neighbours?: readonly number[];
+    readonly area?: number;
+    readonly detailVerts?: readonly (readonly [number, number, number])[];
+    readonly detailTris?: readonly (readonly [number, number, number])[];
+}
+interface NavTileDesc {
+    readonly x: number;
+    readonly z: number;
+    readonly verts: readonly (readonly [number, number, number])[];
+    readonly polys: readonly NavTilePoly[];
+    readonly climb?: number;
+}
+declare function encodeNavTile(desc: NavTileDesc): Uint8Array;
+
+declare const curve: {
+    linear: (slope: number, offset: number) => CurveDecl;
+    rising: () => CurveDecl;
+    falling: () => CurveDecl;
+    polynomial: (exponent: number, slope?: number, offset?: number) => CurveDecl;
+    logistic: (steepness: number, midpoint: number) => CurveDecl;
+    step: (threshold: number, below: number, above: number) => CurveDecl;
+    points: (x: readonly number[], y: readonly number[]) => CurveDecl;
+};
+declare const input: {
+    builtin: (name: BuiltinInput, min: number, max: number) => InputDecl;
+    game: (slot: number, min: number, max: number) => InputDecl;
+    need: (need: number, min?: number, max?: number) => InputDecl;
+};
+declare const behaviour: {
+    idle: () => BehaviourDecl;
+    moveToFocus: (arriveRadius?: number) => BehaviourDecl;
+    pursue: (leadSeconds?: number, arriveRadius?: number) => BehaviourDecl;
+    flee: (safeDistance: number) => BehaviourDecl;
+    keepDistance: (min: number, max: number) => BehaviourDecl;
+    search: (arriveRadius?: number) => BehaviourDecl;
+    wander: () => BehaviourDecl;
+    moveToGoal: (arriveRadius?: number) => BehaviourDecl;
+    attack: (range: number, windupTicks: number, strikeTicks: number, recoverTicks: number) => BehaviourDecl;
+    takeCover: (maxDistance: number) => BehaviourDecl;
+    holdFormation: (arriveRadius?: number) => BehaviourDecl;
+    useObject: (kinds: readonly number[], maxDistance: number) => BehaviourDecl;
+    followSchedule: (arriveRadius?: number) => BehaviourDecl;
+    bark: (lineSet: number) => BehaviourDecl;
+    game: (code: number) => BehaviourDecl;
+};
+declare function consider(name: string, shape: CurveDecl): ConsiderationDecl;
+interface ActionOptions {
+    readonly behaviour: BehaviourDecl;
+    readonly base?: number;
+    readonly momentum?: number;
+    readonly cooldownTicks?: number;
+    readonly speed?: number;
+    readonly consider?: readonly ConsiderationDecl[];
+}
+declare function action(name: string, options: ActionOptions): ActionDecl;
+declare const DEFAULT_STEERING: SteeringDecl;
+declare const DEFAULT_SKILL: SkillDecl;
+declare function skill(partial: Partial<SkillDecl>): SkillDecl;
+interface ArchetypeOptions {
+    readonly thinkEvery?: number;
+    readonly senseEvery?: number;
+    readonly inputs?: Readonly<Record<string, InputDecl>>;
+    readonly actions: readonly ActionDecl[];
+    readonly sight?: SightDecl | null;
+    readonly hearing?: number | null;
+    readonly memorySeconds?: number;
+    readonly awarenessRadius?: number;
+    readonly steering?: Partial<SteeringDecl>;
+    readonly skill?: SkillDecl;
+    readonly needs?: readonly NeedDecl[];
+    readonly schedule?: readonly ScheduleBlockDecl[];
+    readonly scheduleJitterMinutes?: number;
+}
+declare function archetype(name: string, options: ArchetypeOptions): ArchetypeDecl;
+declare function deterministicCos(radians: number): number;
+declare function sight(range: number, fovDegrees: number, options?: Partial<SightDecl>): SightDecl;
+declare function encodeArchetype(decl: ArchetypeDecl): Uint32Array;
+declare function actionIndex(decl: ArchetypeDecl, name: string): number;
+
+declare const KEEPER_GAME_SLOTS: {
+    readonly shotPower: 0;
+    readonly habitStrength: 1;
+    readonly shotPending: 2;
+};
+interface KeeperTuning {
+    readonly reactSlowSeconds: number;
+    readonly reactFastSeconds: number;
+    readonly readNoiseAtSkill0: number;
+    readonly readNoiseAtSkill1: number;
+    readonly guessBase: number;
+}
+declare function keeper(tuning?: KeeperTuning): ArchetypeDecl;
+
+declare const index_AI_EVENT_WORDS: typeof AI_EVENT_WORDS;
+declare const index_AI_MAX_GAME_SLOTS: typeof AI_MAX_GAME_SLOTS;
+declare const index_AI_NONE: typeof AI_NONE;
+declare const index_ActionDecl: typeof ActionDecl;
+type index_ActionOptions = ActionOptions;
+declare const index_AgentSpawn: typeof AgentSpawn;
+declare const index_AiEventKind: typeof AiEventKind;
+declare const index_AiEventKindCode: typeof AiEventKindCode;
+declare const index_AiPort: typeof AiPort;
+declare const index_AiWorldOptions: typeof AiWorldOptions;
+declare const index_ArchetypeDecl: typeof ArchetypeDecl;
+declare const index_ArchetypeHandle: typeof ArchetypeHandle;
+type index_ArchetypeOptions = ArchetypeOptions;
+declare const index_BUILTIN_INPUTS: typeof BUILTIN_INPUTS;
+declare const index_BehaviourDecl: typeof BehaviourDecl;
+declare const index_BuiltinInput: typeof BuiltinInput;
+declare const index_CurveDecl: typeof CurveDecl;
+declare const index_DEFAULT_SKILL: typeof DEFAULT_SKILL;
+declare const index_DEFAULT_STEERING: typeof DEFAULT_STEERING;
+declare const index_GameAi: typeof GameAi;
+declare const index_InputDecl: typeof InputDecl;
+declare const index_KEEPER_GAME_SLOTS: typeof KEEPER_GAME_SLOTS;
+type index_KeeperTuning = KeeperTuning;
+declare const index_NeedDecl: typeof NeedDecl;
+declare const index_PHASE_IDLE: typeof PHASE_IDLE;
+declare const index_PHASE_RECOVER: typeof PHASE_RECOVER;
+declare const index_PHASE_STRIKE: typeof PHASE_STRIKE;
+declare const index_PHASE_WINDUP: typeof PHASE_WINDUP;
+declare const index_ScheduleBlockDecl: typeof ScheduleBlockDecl;
+declare const index_SightDecl: typeof SightDecl;
+declare const index_SkillDecl: typeof SkillDecl;
+declare const index_SmartObjectSpawn: typeof SmartObjectSpawn;
+declare const index_SteeringDecl: typeof SteeringDecl;
+declare const index_TargetSpawn: typeof TargetSpawn;
+declare const index_action: typeof action;
+declare const index_actionIndex: typeof actionIndex;
+declare const index_archetype: typeof archetype;
+declare const index_behaviour: typeof behaviour;
+declare const index_consider: typeof consider;
+declare const index_curve: typeof curve;
+declare const index_deterministicCos: typeof deterministicCos;
+declare const index_encodeArchetype: typeof encodeArchetype;
+declare const index_input: typeof input;
+declare const index_keeper: typeof keeper;
+declare const index_sight: typeof sight;
+declare const index_skill: typeof skill;
+declare namespace index {
+  export { index_AI_EVENT_WORDS as AI_EVENT_WORDS, index_AI_MAX_GAME_SLOTS as AI_MAX_GAME_SLOTS, index_AI_NONE as AI_NONE, index_ActionDecl as ActionDecl, type index_ActionOptions as ActionOptions, index_AgentSpawn as AgentSpawn, index_AiEventKind as AiEventKind, index_AiEventKindCode as AiEventKindCode, index_AiPort as AiPort, index_AiWorldOptions as AiWorldOptions, index_ArchetypeDecl as ArchetypeDecl, index_ArchetypeHandle as ArchetypeHandle, type index_ArchetypeOptions as ArchetypeOptions, index_BUILTIN_INPUTS as BUILTIN_INPUTS, index_BehaviourDecl as BehaviourDecl, index_BuiltinInput as BuiltinInput, index_CurveDecl as CurveDecl, index_DEFAULT_SKILL as DEFAULT_SKILL, index_DEFAULT_STEERING as DEFAULT_STEERING, index_GameAi as GameAi, index_InputDecl as InputDecl, index_KEEPER_GAME_SLOTS as KEEPER_GAME_SLOTS, type index_KeeperTuning as KeeperTuning, index_NeedDecl as NeedDecl, index_PHASE_IDLE as PHASE_IDLE, index_PHASE_RECOVER as PHASE_RECOVER, index_PHASE_STRIKE as PHASE_STRIKE, index_PHASE_WINDUP as PHASE_WINDUP, index_ScheduleBlockDecl as ScheduleBlockDecl, index_SightDecl as SightDecl, index_SkillDecl as SkillDecl, index_SmartObjectSpawn as SmartObjectSpawn, index_SteeringDecl as SteeringDecl, index_TargetSpawn as TargetSpawn, index_action as action, index_actionIndex as actionIndex, index_archetype as archetype, index_behaviour as behaviour, index_consider as consider, index_curve as curve, index_deterministicCos as deterministicCos, index_encodeArchetype as encodeArchetype, index_input as input, index_keeper as keeper, index_sight as sight, index_skill as skill };
+}
+
+declare class JsNav implements NavPort {
+    readonly name = "js-nav";
+    private mesh;
+    private links;
+    private query;
+    private crowd;
+    private traffic;
+    private readonly filter;
+    private extents;
+    private path;
+    private complete;
+    get pathComplete(): boolean;
+    private requireMesh;
+    private requireQuery;
+    private requireCrowd;
+    init(desc: NavDesc): void;
+    private requireLinks;
+    addTile(bytes: Uint8Array): number;
+    removeTile(x: number, z: number): void;
+    addLink(start: readonly [number, number, number], end: readonly [number, number, number], radius: number, bidirectional: boolean, area: number, user: number): number;
+    removeLink(link: number): void;
+    setAreaCost(area: number, cost: number): void;
+    setIncludeMask(low: number, high: number): void;
+    nearest(x: number, y: number, z: number, out: Float32Array): boolean;
+    findPath(sx: number, sy: number, sz: number, ex: number, ey: number, ez: number, out: Float32Array): number;
+    addAgent(x: number, y: number, z: number, radius: number, speed: number, accel: number): number;
+    removeAgent(agent: number): void;
+    setAgentTarget(agent: number, x: number, y: number, z: number): void;
+    stopAgent(agent: number): void;
+    agents(): Float32Array;
+    loadRoads(words: Uint32Array): void;
+    private roads;
+    addVehicle(lane: number, position: number, speed: number, driver: Float32Array): number;
+    removeVehicle(vehicle: number): void;
+    setExternalVehicle(vehicle: number, lane: number, position: number, speed: number): void;
+    vehicles(): Float32Array;
+    signal(lane: number): number;
+    step(dt: number): void;
+    dispose(): void;
+}
+
+interface WebAudioOptions {
+    readonly createMediaElement?: () => HTMLMediaElement;
+}
+declare class WebAudioPort implements AudioPort {
+    readonly name = "web-audio";
+    readonly capabilities: AudioCapabilities;
+    private readonly context;
+    private readonly buffers;
+    private readonly buses;
+    private readonly voices;
+    private readonly analysers;
+    private readonly sends;
+    private readonly streams;
+    private readonly meterScratch;
+    private readonly createMediaElement;
+    private nextVoice;
+    private readonly onEnded;
+    constructor(context: AudioContext, maxVoices?: number, options?: WebAudioOptions);
+    get sampleRate(): number;
+    get unlocked(): boolean;
+    unlock(): void;
+    decode(source: AssetSource): Promise<number>;
+    createSound(samples: Float32Array, channels: number, sampleRate: number): number;
+    createBus(_name: string, parent: number): number;
+    createReverb(parent: number, impulse: number): number;
+    setBusGain(bus: number, gain: number, rampSeconds: number): void;
+    setBusFilter(bus: number, kind: number, frequency: number, q: number, gainDb: number): void;
+    meter(bus: number, out: Float32Array): void;
+    createAnalyser(bus: number, settings: AnalyserSettings): number;
+    readAnalyser(analyser: number, mode: number, out: Float32Array | Uint8Array): void;
+    setBusSend(bus: number, target: number, gain: number): void;
+    play(sound: number, bus: number, gain: number, rate: number, loop: boolean, spatial: boolean): number;
+    stop(voice: number, fadeSeconds: number): void;
+    isPlaying(voice: number): boolean;
+    setVoiceGain(voice: number, gain: number, rampSeconds: number): void;
+    setVoiceRate(voice: number, rate: number, detuneCents: number): void;
+    setVoiceSpatial(voice: number, params: Float32Array): void;
+    setVoiceLoop(voice: number, loop: boolean, startSeconds: number, endSeconds: number): void;
+    setVoicePosition(voice: number, matrix: Float32Array, offset: number): void;
+    setListener(matrix: Float32Array, offset: number): void;
+    openStream(source: AssetSource, bus: number): Promise<number>;
+    private stream;
+    playStream(stream: number, gain: number, loop: boolean): void;
+    pauseStream(stream: number): void;
+    seekStream(stream: number, seconds: number): void;
+    streamTime(stream: number): number;
+    streamDuration(stream: number): number;
+    closeStream(stream: number): void;
+    suspend(): void;
+    resume(): void;
+    dispose(): void;
+    private ramp;
+    private release;
+}
+
+type EnvironmentPreset = "studio" | "outdoor" | "night" | "color" | "debug";
+interface EnvironmentOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly intensity?: number;
+    readonly format?: "rgba16f" | "rgba32f";
+    readonly sunDirection?: readonly [number, number, number];
+    readonly sunColor?: number;
+    readonly sunIntensity?: number;
+    readonly skyColor?: number;
+    readonly horizonColor?: number;
+    readonly groundColor?: number;
+    readonly color?: number;
+    readonly moonDirection?: readonly [number, number, number];
+    readonly starDensity?: number;
+    readonly seed?: number;
+}
+interface ApplyEnvironmentOptions extends EnvironmentOptions {
+    readonly background?: boolean;
+    readonly backgroundBlurriness?: number;
+    readonly environmentIntensity?: number;
+    readonly toneMapping?: ToneMapping;
+    readonly exposure?: number;
+}
+declare function toHalf(value: number): number;
+declare function fromHalf(bits: number): number;
+declare function environmentTexture(preset: EnvironmentPreset, options?: EnvironmentOptions): TextureDesc;
+declare function applyEnvironmentPreset(graphics: Graphics, preset: EnvironmentPreset, options?: ApplyEnvironmentOptions): TextureId;
+
+type TransitionKind = "fade" | "wipe" | "iris" | "dissolve" | "pixelate";
+interface TransitionOptions {
+    readonly color?: number;
+    readonly direction?: readonly [number, number];
+    readonly softness?: number;
+    readonly center?: readonly [number, number];
+    readonly cellSize?: number;
+    readonly noiseScale?: number;
+    readonly edge?: number;
+}
+declare const TRANSITION_PROGRESS = "progress";
+declare function transitionEffect(kind: TransitionKind, options?: TransitionOptions): PostEffectDesc;
+declare class ScreenTransition {
+    private readonly graphics;
+    readonly chain: PostChainId;
+    readonly effect: number;
+    progress: number;
+    private from;
+    private to;
+    private elapsed;
+    private duration;
+    private curve;
+    private state;
+    constructor(graphics: Graphics, chain: PostChainId, effect?: number);
+    static create(graphics: Graphics, kind: TransitionKind, options?: TransitionOptions): ScreenTransition;
+    get done(): boolean;
+    get running(): boolean;
+    play(seconds: number, curve?: EaseId, from?: number, to?: number): void;
+    cover(seconds: number, curve?: EaseId): void;
+    reveal(seconds: number, curve?: EaseId): void;
+    set(progress: number): void;
+    update(dtSeconds: number): void;
+    private write;
+}
+interface CrossfadeOptions {
+    readonly camera: Entity;
+    readonly cameraNode: NodeId;
+    readonly width: number;
+    readonly height: number;
+    readonly fovDegrees: number;
+    readonly near: number;
+    readonly aspect: number;
+    readonly layers?: number;
+    readonly overlayLayer?: number;
+}
+declare class CrossfadeTransition {
+    private readonly graphics;
+    readonly target: RenderTargetId;
+    readonly pass: RenderPassId;
+    readonly overlay: Entity;
+    readonly material: MaterialId;
+    readonly geometry: GeometryId;
+    progress: number;
+    private elapsed;
+    private duration;
+    private curve;
+    private state;
+    private live;
+    private pending;
+    private readonly node;
+    constructor(graphics: Graphics, transforms: Transforms, overlay: Entity, options: CrossfadeOptions);
+    capture(live?: boolean): void;
+    play(seconds: number, curve?: EaseId): void;
+    get done(): boolean;
+    update(dtSeconds: number): void;
+    private write;
+}
+
+interface BatchedMeshOptions {
+    readonly material: MaterialId;
+    readonly maxVertices: number;
+    readonly maxGeometries?: number;
+    readonly maxInstances: number;
+    readonly maxInstanceVertices?: number;
+    readonly colors?: boolean;
+    readonly castShadow?: boolean;
+    readonly receiveShadow?: boolean;
+    readonly native?: boolean;
+}
+declare class BatchedMesh {
+    readonly geometry: GeometryId;
+    readonly node: NodeId;
+    readonly maxInstances: number;
+    private readonly graphics;
+    private readonly sourcePositions;
+    private readonly sourceNormals;
+    private readonly sourceUvs;
+    private sourceUsed;
+    private readonly geometryStart;
+    private readonly geometryCount;
+    private readonly freeHead;
+    private geometries;
+    private readonly positions;
+    private readonly normals;
+    private readonly uvs;
+    private readonly colors;
+    private outputUsed;
+    private readonly instanceGeometry;
+    private readonly instanceStart;
+    private readonly instanceFlags;
+    private readonly instanceNext;
+    private readonly matrices;
+    private readonly instanceColor;
+    private instances;
+    private dirtyLow;
+    private dirtyHigh;
+    private colorDirtyLow;
+    private colorDirtyHigh;
+    private drawn;
+    private readonly draw;
+    private nativeCount;
+    private slotsDirty;
+    private instancesDirty;
+    private sourceDirtyLow;
+    private sourceDirtyHigh;
+    constructor(graphics: Graphics, options: BatchedMeshOptions);
+    get native(): boolean;
+    get geometryCountUsed(): number;
+    get instanceCount(): number;
+    get vertexCount(): number;
+    addGeometry(desc: GeometryDesc): number;
+    addInstance(geometry: number): number;
+    private addNativeInstance;
+    private writeNative;
+    deleteInstance(id: number): void;
+    setMatrixAt(id: number, matrix: ArrayLike<number>, offset?: number): void;
+    getMatrixAt(id: number, out: Float32Array | Float64Array, offset?: number): void;
+    setVisibleAt(id: number, visible: boolean): void;
+    setColorAt(id: number, r: number, g: number, b: number): void;
+    update(): void;
+    private updateNative;
+    private requireLive;
+    private markRange;
+    private collapse;
+    private bake;
+}
+
+declare class HeadlessAudio implements AudioPort {
+    readonly name = "headless";
+    readonly capabilities: AudioCapabilities;
+    readonly sampleRate = 48000;
+    private unlockedValue;
+    private soundCount;
+    private busCount;
+    private readonly busGains;
+    private readonly busFilters;
+    private readonly busMeters;
+    private readonly sends;
+    private readonly reverbs;
+    private readonly analysers;
+    private readonly analyserBus;
+    private readonly streams;
+    private readonly voiceSound;
+    private readonly voiceLoop;
+    private readonly voicePosition;
+    private readonly voiceGain;
+    private readonly voiceRate;
+    private readonly voiceLoopPoints;
+    private readonly voiceSpatial;
+    private readonly listener;
+    private nextVoice;
+    constructor(maxVoices?: number);
+    get unlocked(): boolean;
+    unlock(): void;
+    decode(_source: AssetSource): Promise<number>;
+    createSound(samples: Float32Array, channels: number, sampleRate: number): number;
+    createBus(_name: string, _parent: number): number;
+    setBusGain(bus: number, gain: number, _rampSeconds: number): void;
+    busGain(bus: number): number;
+    setBusFilter(bus: number, kind: number, frequency: number, q: number, gainDb: number): void;
+    busFilter(bus: number, out: Float32Array): void;
+    meter(bus: number, out: Float32Array): void;
+    inject(bus: number, samples: Float32Array): void;
+    createAnalyser(bus: number, settings: AnalyserSettings): number;
+    readAnalyser(analyser: number, mode: number, out: Float32Array | Uint8Array): void;
+    createReverb(parent: number, impulse: number): number;
+    reverbImpulse(bus: number): number;
+    setBusSend(bus: number, target: number, gain: number): void;
+    busSend(bus: number, target: number): number;
+    play(sound: number, _bus: number, gain: number, rate: number, loop: boolean, _spatial: boolean): number;
+    stop(voice: number, _fadeSeconds: number): void;
+    isPlaying(voice: number): boolean;
+    setVoiceGain(voice: number, gain: number, _rampSeconds: number): void;
+    voiceGainOf(voice: number): number;
+    setVoiceRate(voice: number, rate: number, detuneCents: number): void;
+    voiceRateOf(voice: number, out: Float32Array): void;
+    setVoiceSpatial(voice: number, params: Float32Array): void;
+    voiceSpatialOf(voice: number, out: Float32Array): void;
+    setVoiceLoop(voice: number, loop: boolean, startSeconds: number, endSeconds: number): void;
+    voiceLoopOf(voice: number, out: Float32Array): void;
+    setVoicePosition(voice: number, matrix: Float32Array, offset: number): void;
+    voiceX(voice: number): number;
+    setListener(matrix: Float32Array, offset: number): void;
+    openStream(_source: AssetSource, bus: number): Promise<number>;
+    private stream;
+    playStream(stream: number, gain: number, loop: boolean): void;
+    pauseStream(stream: number): void;
+    seekStream(stream: number, seconds: number): void;
+    streamTime(stream: number): number;
+    streamDuration(stream: number): number;
+    streamState(stream: number): number;
+    closeStream(stream: number): void;
+    commit(frame: Float64Array, at: number): void;
+    suspend(): void;
+    resume(): void;
+    dispose(): void;
+}
+
+interface TickLockstepLinkOptions {
+    readonly seats: number;
+    readonly channel?: string;
+}
+declare class TickLockstepLink implements LockstepLink {
+    readonly transport: TickRoomTransport;
+    private readonly seats;
+    private readonly channel;
+    private readonly presence;
+    private readonly record;
+    private session;
+    private lastTick;
+    private readonly sink;
+    constructor(transport: TickRoomTransport, options: TickLockstepLinkOptions);
+    get seat(): number;
+    toReferee(payload: Uint8Array, length: number): void;
+    toPeers(payload: Uint8Array, length: number): void;
+    poll(session: LockstepSession): void;
+    close(): void;
+}
+
+declare const GAME_API_PROFILE = "game_api";
+declare const DIRECT_ENGINE_PREFIX = "direct_engine:";
+type AdmittedEngine = "three" | "phaser";
+type GameProfile = {
+    readonly kind: "game_api";
+} | {
+    readonly kind: "direct_engine";
+    readonly engine: AdmittedEngine;
+};
+interface GameManifest {
+    readonly profile: string;
+}
+interface ProfileParseResult {
+    readonly ok: boolean;
+    readonly profile: GameProfile | null;
+    readonly error: string | null;
+}
+interface SourceFile {
+    readonly path: string;
+    readonly source: string;
+}
+type ProfileViolationReason = "engine_import" | "foreign_engine_import" | "backend_import" | "dynamic_import";
+interface ProfileViolation {
+    readonly path: string;
+    readonly line: number;
+    readonly specifier: string | null;
+    readonly reason: ProfileViolationReason;
+    readonly engine: string | null;
+}
+interface ProfileCheckResult {
+    readonly ok: boolean;
+    readonly profile: GameProfile | null;
+    readonly violations: readonly ProfileViolation[];
+    readonly error: string | null;
+}
+declare function parseGameProfile(value: string): ProfileParseResult;
+declare function engineOf(specifier: string): string | null;
+declare function checkGameSources(manifest: GameManifest, files: readonly SourceFile[]): ProfileCheckResult;
+interface FoundImport {
+    readonly specifier: string | null;
+    readonly line: number;
+    readonly dynamic: boolean;
+}
+declare function scanImports(source: string): FoundImport[];
+
+declare const ENGINE_STREAM_EXPORT_NAMES: readonly ["engine_stream_open", "engine_stream_close", "engine_stream_provide", "engine_stream_update", "engine_stream_registers", "engine_stream_open_logic", "engine_stream_step_logic", "engine_stream_collider"];
+type StreamExports = Readonly<Record<(typeof ENGINE_STREAM_EXPORT_NAMES)[number], (...args: number[]) => number>>;
+declare class EngineWorldStreaming implements WorldStreamingPort {
+    private readonly runtime;
+    private readonly exports;
+    private readonly render;
+    private readonly eye;
+    private readonly actors;
+    private readonly ops;
+    private readonly scratch;
+    private buffer;
+    private floats;
+    private words;
+    private bytes;
+    private lazySupport;
+    constructor(runtime: EngineRuntime, exports: StreamExports, render: () => number);
+    private views;
+    private ensure;
+    private stage;
+    lazyPacks(): boolean;
+    open(world: Uint8Array, materials: readonly number[], tier: number): number;
+    provide(stream: number, pack: Uint8Array): number;
+    update(stream: number, eye: Float32Array): void;
+    registers(stream: number): Uint32Array;
+    openLogic(stream: number, stepSeconds: number, budget: number, actors: number): number;
+    stepLogic(stream: number, actors: Float32Array, count: number, ops: Uint32Array): number;
+    collider(stream: number, index: number, out: Float32Array): void;
+    close(stream: number): void;
+}
+
+interface SimulatedLink {
+    readonly bytesPerSecond: number;
+    readonly latencyMs: number;
+    readonly concurrency?: number;
+    readonly budgetBytes?: number;
+    readonly prefetchSlots?: number;
+    readonly preempt?: boolean;
+}
+interface SimulatedEngine {
+    readonly radius: number;
+    readonly need: number;
+    readonly unload?: number;
+    readonly maxInflight?: number;
+}
+type CameraPath = Float32Array | Float64Array | readonly (readonly [number, number, number])[];
+interface StreamingSimulation {
+    readonly layer: PrefetchLayerDesc;
+    readonly path: CameraPath;
+    readonly fps?: number;
+    readonly link: SimulatedLink;
+    readonly engine: SimulatedEngine;
+    readonly predictor?: PredictorOptions | false;
+    readonly network?: NetworkHint | null;
+}
+interface StreamingReport {
+    readonly frames: number;
+    readonly startupFrames: number;
+    readonly startupMs: number;
+    readonly startupBytes: number;
+    readonly stallFrames: number;
+    readonly firstStallFrame: number;
+    readonly bytesFetched: number;
+    readonly bytesWasted: number;
+    readonly peakHeldBytes: number;
+    readonly prefetchRequests: number;
+    readonly engineRequests: number;
+    readonly prefetchHits: number;
+    readonly preemptedFetches: number;
+}
+declare function simulateStreaming(simulation: StreamingSimulation): StreamingReport;
+declare function scriptedPath(keys: readonly {
+    readonly t: number;
+    readonly at: readonly [number, number, number];
+}[], fps?: number): Float64Array;
+
+/** The part of a catalogue variant a twin needs. `services.catalogue.product` returns this shape in `variants`. */
+interface TwinVariant {
+    readonly variant_id: string;
+    readonly name: string;
+    readonly available: boolean;
+}
+/** One variant's look: the edit each named or numbered region takes. Regions it leaves out go back to the captured look. */
+type TwinLook = Readonly<Record<string, SceneryEdit>>;
+interface TwinBody {
+    edit(region: number | string, edit: SceneryEdit): void;
+}
+interface SplatTwinOptions {
+    /** The splat body or scenery showing the product. */
+    readonly body: TwinBody;
+    readonly variants: readonly TwinVariant[];
+    /** Looks by variant id or, as a fallback, by variant name. A variant with no look shows the capture as it is. */
+    readonly looks: Readonly<Record<string, TwinLook>>;
+    /** Selected when the twin is made. The first available variant if left out. */
+    readonly selected?: string;
+}
+/** Connects a catalogue product's variants to edits on one capture, so colours and finishes need no new capture. */
+declare class SplatTwin {
+    private readonly body;
+    private readonly variants;
+    private readonly looks;
+    private touched;
+    private current;
+    constructor(options: SplatTwinOptions);
+    /** The selected variant, whose id goes to the cart or purchase intent. */
+    get selected(): TwinVariant | null;
+    /** Whether a variant has a look of its own, so a picker can mark the ones the capture cannot show. */
+    shows(variantId: string): boolean;
+    private lookOf;
+    /** Shows a variant. It does not refuse an unavailable one: a shopper may look at a sold-out colour. */
+    select(variantId: string): TwinVariant;
+}
+
+declare const ENGINE_SPLAT_EXPORT_NAMES: readonly ["engine_splat_open", "engine_splat_close", "engine_splat_provide", "engine_splat_fail", "engine_splat_update", "engine_splat_requests", "engine_splat_set_transform", "engine_splat_registers"];
+type SplatExports = Readonly<Record<(typeof ENGINE_SPLAT_EXPORT_NAMES)[number], (...args: number[]) => number>>;
+declare class EngineScenery implements SceneryPort {
+    private readonly runtime;
+    private readonly exports;
+    private readonly render;
+    private scratch;
+    private scratchBytes;
+    private live;
+    private buffer;
+    private floats;
+    private words;
+    private bytes;
+    readonly bodies: SceneryBodyPort | null;
+    constructor(runtime: EngineRuntime, exports: SplatExports, render: () => number);
+    private stageBody;
+    private views;
+    private ensureScratch;
+    private stage;
+    open(manifest: Uint8Array): number;
+    provide(scene: number, index: number, chunk: Uint8Array): number;
+    fail(scene: number, index: number): number;
+    update(scene: number, eye: Float32Array, requests: Uint32Array): number;
+    setTransform(scene: number, transform: Float32Array): void;
+    registers(scene: number): Uint32Array;
+    close(scene: number): void;
+}
+
+type SceneVec2 = readonly [number, number];
+type SceneRect = readonly [number, number, number, number];
+type SceneCompass = "north" | "south" | "east" | "west";
+interface SceneRegionSpec {
+    readonly rect: SceneRect;
+    readonly ground?: string;
+}
+interface ScenePathSpec {
+    readonly points: readonly SceneVec2[];
+    readonly width?: number;
+}
+interface SceneAreaSpec {
+    readonly size: SceneVec2;
+    readonly ground?: string;
+    readonly regions?: Readonly<Record<string, SceneRegionSpec>>;
+    readonly paths?: Readonly<Record<string, ScenePathSpec>>;
+    readonly points?: Readonly<Record<string, SceneVec2>>;
+}
+interface SceneObjectSpec<K extends string = CatalogueKind> {
+    readonly kind: K;
+    readonly count?: number;
+    readonly at?: SceneVec2;
+    readonly yaw?: number;
+    readonly near?: string;
+    readonly within?: number;
+    readonly along?: string;
+    readonly offset?: number;
+    readonly facing?: string;
+    readonly on?: string;
+    readonly inside?: string;
+    readonly reachable_from?: string;
+    readonly visible_from?: string;
+    readonly clear?: number;
+    readonly no_overlap?: boolean;
+    readonly in_bounds?: boolean;
+    readonly spacing?: SceneVec2 | number;
+}
+interface SceneQuality {
+    readonly candidates?: number;
+    readonly iterations?: number;
+    readonly tries?: number;
+}
+interface SceneAgent {
+    readonly radius?: number;
+    readonly eye?: number;
+}
+interface SceneSpec<K extends string = CatalogueKind> {
+    readonly area: SceneAreaSpec;
+    readonly objects: Readonly<Record<string, SceneObjectSpec<K>>>;
+    readonly style?: string;
+    readonly seed?: number;
+    readonly quality?: SceneQuality;
+    readonly agent?: SceneAgent;
+}
+interface SceneDefinition<K extends string = CatalogueKind> {
+    readonly kind: "scene";
+    readonly name: string;
+    readonly spec: SceneSpec<K>;
+}
+type WireTarget = {
+    readonly point: number;
+} | {
+    readonly region: number;
+} | {
+    readonly line: number;
+} | {
+    readonly object: number;
+} | {
+    readonly object: number;
+    readonly instance: number;
+} | {
+    readonly object: number;
+    readonly anchor: number;
+} | {
+    readonly area: true;
+} | {
+    readonly direction: number;
+};
+type WireRelation = {
+    readonly type: "near";
+    readonly target: WireTarget;
+    readonly within: number;
+} | {
+    readonly type: "along";
+    readonly line: number;
+    readonly offset: number;
+} | {
+    readonly type: "facing";
+    readonly target: WireTarget;
+} | {
+    readonly type: "on";
+    readonly object: number;
+} | {
+    readonly type: "inside";
+    readonly target: WireTarget;
+} | {
+    readonly type: "reachable_from";
+    readonly target: WireTarget;
+} | {
+    readonly type: "visible_from";
+    readonly target: WireTarget;
+};
+interface WireKind {
+    readonly name: string;
+    readonly footprint: readonly [number, number];
+    readonly height: number;
+    readonly solid: boolean;
+    readonly anchors: readonly {
+        readonly name: string;
+        readonly at: readonly [number, number, number];
+    }[];
+}
+interface WireObject {
+    readonly name: string;
+    readonly kind: number;
+    readonly count: number;
+    readonly at: readonly [number, number] | null;
+    readonly yaw: number | null;
+    readonly clear: number;
+    readonly overlap: boolean;
+    readonly bounds: boolean;
+    readonly spacing: readonly [number, number] | null;
+    readonly relations: readonly WireRelation[];
+}
+interface SceneWire {
+    readonly version: 1;
+    readonly name: string;
+    readonly seed: number;
+    readonly style: string;
+    readonly ground: string;
+    readonly area: readonly [number, number];
+    readonly quality: {
+        readonly candidates: number;
+        readonly iterations: number;
+        readonly tries: number;
+    };
+    readonly agent: {
+        readonly radius: number;
+        readonly eye: number;
+        readonly cell: number;
+    };
+    readonly kinds: readonly WireKind[];
+    readonly points: readonly {
+        readonly name: string;
+        readonly at: readonly [number, number];
+    }[];
+    readonly regions: readonly {
+        readonly name: string;
+        readonly rect: readonly [number, number, number, number];
+    }[];
+    readonly lines: readonly {
+        readonly name: string;
+        readonly points: readonly (readonly [number, number])[];
+        readonly outward: 1 | -1;
+    }[];
+    readonly objects: readonly WireObject[];
+}
+type SceneDiagnosticCode = "scene.unknown_kind" | "scene.unknown_target" | "scene.bad_target" | "scene.unknown_anchor" | "scene.duplicate_name" | "scene.cycle" | "scene.invalid_value" | "scene.capacity" | "scene.too_large" | "scene.no_top" | "scene.not_static";
+interface SceneDiagnostic {
+    readonly code: SceneDiagnosticCode;
+    readonly severity: "error" | "warning";
+    readonly message: string;
+    readonly object: string | null;
+    readonly field: string | null;
+    readonly fix: string | null;
+}
+interface SceneCompilation {
+    readonly wire: SceneWire | null;
+    readonly diagnostics: readonly SceneDiagnostic[];
+}
+interface ScenePlacement {
+    readonly group: number;
+    readonly instance: number;
+    readonly kind: number;
+    readonly yaw: number;
+    readonly flags: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly support: number;
+}
+interface ScenePlacementReport {
+    readonly version: 1;
+    readonly scene: string;
+    readonly seed: number;
+    readonly style: string;
+    readonly ground: string;
+    readonly status: "solved" | "unsatisfied";
+    readonly try: number;
+    readonly score: number;
+    readonly digest: string;
+    readonly placements: readonly {
+        readonly name: string;
+        readonly group: string;
+        readonly kind: string;
+        readonly at: readonly [number, number, number];
+        readonly yaw: number;
+        readonly support: string | null;
+        readonly violations: readonly string[];
+    }[];
+    readonly violations: readonly {
+        readonly object: string;
+        readonly code: string;
+        readonly relation: string;
+        readonly amount: number;
+        readonly other: string | null;
+    }[];
+    readonly conflicts?: {
+        readonly objects: readonly string[];
+        readonly reasons: readonly string[];
+    };
+    readonly timings?: {
+        readonly setup_ms: number;
+        readonly solve_ms: number;
+    };
+}
+
+interface CompileSceneOptions {
+    readonly catalogue?: SceneCatalogue;
+}
+declare function yawStep(degrees: number): number;
+declare function compileScene(def: SceneDefinition<string>, options?: CompileSceneOptions): SceneCompilation;
+declare function yawDegrees(step: number): number;
+
+declare function scene<const S extends SceneSpec<CatalogueKind>>(name: string, spec: S): SceneDefinition<CatalogueKind>;
+declare function isSceneDefinition(value: unknown): value is SceneDefinition<string>;
+
+declare const SCENE_OUTPUT_MAGIC = 1313035075;
+declare const SCENE_OUTPUT_VERSION = 1;
+declare const SCENE_HEADER_BYTES = 48;
+declare const SCENE_PLACEMENT_BYTES = 24;
+declare const SCENE_VIOLATION_BYTES = 12;
+declare const SCENE_FLAG_PINNED = 1;
+declare const SCENE_FLAG_SUPPORTED = 2;
+declare const SCENE_FLAG_VIOLATING = 4;
+declare const SCENE_SOLVER_EXPORTS: readonly ["engine_scene_alloc", "engine_scene_free", "engine_scene_open", "engine_scene_error", "engine_scene_error_len", "engine_scene_solve", "engine_scene_output", "engine_scene_output_len", "engine_scene_report", "engine_scene_report_len", "engine_scene_close"];
+interface SceneSolveResult {
+    readonly status: "solved" | "unsatisfied";
+    readonly bytes: Uint8Array;
+    readonly placements: readonly ScenePlacement[];
+    readonly report: ScenePlacementReport;
+}
+interface SceneSolver {
+    solve(wire: SceneWire | string, seed?: number): SceneSolveResult;
+}
+interface SceneOutputHeader {
+    readonly status: "solved" | "unsatisfied";
+    readonly placements: number;
+    readonly violations: number;
+    readonly conflicts: number;
+    readonly tryIndex: number;
+    readonly seed: number;
+}
+declare function readSceneHeader(bytes: Uint8Array): SceneOutputHeader;
+declare function decodePlacements(bytes: Uint8Array): ScenePlacement[];
+declare function createSceneSolver(source: BufferSource | WebAssembly.Module): Promise<SceneSolver>;
+
+declare const ENGINE_TERRAIN_EXPORT_NAMES: readonly ["engine_terrain_open", "engine_terrain_close", "engine_terrain_update", "engine_terrain_registers", "engine_terrain_height", "engine_terrain_normal", "engine_terrain_sculpt", "engine_terrain_colliders", "engine_physics_radial_gravity", "engine_terrain_grass", "engine_terrain_wind", "engine_terrain_interactors", "engine_terrain_look", "engine_terrain_scatter", "engine_noise", "engine_noise_fbm"];
+type TerrainExports = Readonly<Record<(typeof ENGINE_TERRAIN_EXPORT_NAMES)[number], (...args: number[]) => number>>;
+declare class EngineTerrain implements TerrainPort {
+    private readonly runtime;
+    private readonly exports;
+    private readonly render;
+    private readonly world;
+    private readonly scratch;
+    private readonly second;
+    private readonly columns;
+    private buffer;
+    private floats;
+    private words;
+    private bytes;
+    constructor(runtime: EngineRuntime, exports: TerrainExports, render: () => number, world: () => number);
+    private views;
+    private ensure;
+    private put;
+    open(desc: Float32Array, source: number, recipe: Float32Array, pack: Uint8Array | null): number;
+    close(terrain: number): void;
+    update(terrain: number, eye: Float32Array): number;
+    registers(terrain: number): Uint32Array;
+    height(x: number, z: number): number;
+    normal(x: number, z: number, out: Float32Array): boolean;
+    sculpt(terrain: number, brush: Float32Array): number;
+    colliders(terrain: number, x: number, y: number, z: number): number;
+    gravity(x: number, y: number, z: number, surface: number, radius: number): number;
+    grass(params: Float32Array): number;
+    wind(x: number, z: number, strength: number, gust: number): void;
+    interactors(data: Float32Array, count: number): void;
+    look(layers: Float32Array, count: number): void;
+    scatter(rules: Float32Array, out: Float32Array, capacity: number): number;
+    noise(kind: number, x: number, y: number, z: number, seed: number): number;
+    fbm(x: number, z: number, octaves: number, frequency: number, seed: number): number;
+}
+
+declare const INPUT_SOURCES: readonly ["touch", "gesture", "tilt", "key", "choice", "gift", "vote", "ai"];
+type InputSource = (typeof INPUT_SOURCES)[number];
+declare const DEFAULT_LOG_INPUTS: number;
+declare const DEFAULT_LOG_BYTES: number;
+interface RecordedInput {
+    tick: number;
+    source: InputSource;
+    a: number;
+    b: number;
+    c: number;
+    bytes: Uint8Array | null;
+}
+declare function createRecordedInput(): RecordedInput;
+declare class InputLog {
+    private readonly ticks;
+    private readonly sources;
+    private readonly words;
+    private readonly at;
+    private readonly lengths;
+    private readonly pool;
+    private count;
+    private used;
+    constructor(inputs?: number, bytes?: number);
+    get length(): number;
+    get lastTick(): number;
+    record(tick: number, source: InputSource, a?: number, b?: number, c?: number, bytes?: Uint8Array | null): void;
+    first(tick: number): number;
+    read(index: number, out: RecordedInput): RecordedInput;
+    forEachAt(tick: number, visit: (input: RecordedInput) => void, scratch: RecordedInput): number;
+    truncateAfter(tick: number): void;
+    clear(): void;
+}
+interface KeyframeStore {
+    readonly keyframeEvery: number;
+    keyframe(tick: number): boolean;
+    nearestKeyframe(at: number): number | null;
+    seekKeyframe(tick: number): boolean;
+    truncateKeyframes(after: number): void;
+    clearKeyframes(): void;
+}
+interface TimelineSim {
+    restart(): void;
+    step(tick: number, log: InputLog): void;
+}
+declare class TimeTravel {
+    private readonly store;
+    readonly log: InputLog;
+    private readonly sim;
+    private tickValue;
+    constructor(store: KeyframeStore, log: InputLog, sim: TimelineSim);
+    get tick(): number;
+    start(): void;
+    advance(): void;
+    diverge(): void;
+    seek(target: number): number;
+}
+interface TraceEvent {
+    readonly tick: number;
+    readonly name: string;
+    readonly value: string;
+}
+declare class RunTrace {
+    private readonly digests;
+    private ticks;
+    readonly events: TraceEvent[];
+    readonly variables: Map<string, string>;
+    constructor(capacity: number);
+    get length(): number;
+    digest(tick: number, value: bigint): void;
+    at(tick: number): bigint;
+    event(tick: number, name: string, value: string): void;
+    variable(name: string, value: string): void;
+}
+interface TraceDiff {
+    readonly firstDivergence: number | null;
+    readonly ticksCompared: number;
+    readonly variables: readonly {
+        readonly name: string;
+        readonly a: string | undefined;
+        readonly b: string | undefined;
+    }[];
+    readonly onlyInA: readonly TraceEvent[];
+    readonly onlyInB: readonly TraceEvent[];
+}
+declare function diffTraces(a: RunTrace, b: RunTrace): TraceDiff;
+
+declare const MIRROR_MAX_DEPTH = 4;
+/**
+ * Keeps copies of an object's plain state (its numbers, true or false values, typed arrays and nested plain objects)
+ * in preallocated slots, so a keyframe can bring back state that lives outside the engine. The layout is read once;
+ * saving and loading allocate nothing.
+ */
+declare class StateMirror {
+    readonly slots: number;
+    private readonly scalars;
+    private readonly arrays;
+    private readonly scalarSlots;
+    private readonly arraySlots;
+    private readonly arrayBytes;
+    private readonly copies;
+    constructor(target: object, slots: number, skip?: ReadonlySet<string>);
+    get bytes(): number;
+    save(slot: number): void;
+    load(slot: number): void;
+    private slot;
+}
+
+declare const TIMELINE_KEYFRAME_EVERY = 30;
+declare const TIMELINE_KEYFRAME_SLOTS = 64;
+declare const TIMELINE_MAX_TICKS: number;
+interface TimelineSnapshots extends KeyframeStore {
+    enableKeyframes(desc: KeyframeDesc): boolean;
+    digest(): bigint;
+    keyframeStats(): KeyframeStats | null;
+}
+interface TimelineGame {
+    readonly input: InputActions;
+    readonly tickHz: number;
+    snapshots(): TimelineSnapshots | null;
+    step(): void;
+    values(): {
+        readonly [name: string]: string;
+    };
+}
+type TimelineSend = (message: StudioOutgoing) => void;
+/**
+ * Time travel for a game in a Studio preview. While it records, every drain of the input queue goes into an input log
+ * and keyframes are taken on a cadence (the engine's world, the attached script state and the input state). Seeking
+ * restores the nearest keyframe and replays the log step by step, so every moment comes back exactly; proving replays
+ * the recording and checks each keyframe's world digest against the one taken live.
+ */
+declare class StudioTimeline implements InputTap, KeyframeStore {
+    private readonly game;
+    private readonly send;
+    readonly keyframeEvery = 30;
+    private readonly log;
+    private readonly scratch;
+    private readonly digests;
+    private readonly mirror;
+    private travel;
+    private store;
+    private live;
+    private proving;
+    private divergence;
+    private checked;
+    private endTick;
+    private recordingValue;
+    private holdingValue;
+    private readonly replayInput;
+    private readonly sim;
+    constructor(game: TimelineGame, send: TimelineSend);
+    get recording(): boolean;
+    get holding(): boolean;
+    get tick(): number;
+    handle(message: StudioMessage): void;
+    record(): void;
+    stop(): void;
+    /** One live fixed step while recording. */
+    step(): void;
+    seek(target: number): void;
+    play(): void;
+    moment(target: number): void;
+    prove(): void;
+    drained(nowMs: number, events: Uint8Array, count: number): void;
+    keyframe(tick: number): boolean;
+    nearestKeyframe(at: number): number | null;
+    seekKeyframe(tick: number): boolean;
+    truncateKeyframes(after: number): void;
+    clearKeyframes(): void;
+    private from;
+    private resimulate;
+    private refuse;
+    private report;
+}
+
+export { ALL_LAYERS, type AdmittedEngine, Aircraft, AircraftInput, AnalyserSettings, type AnyVector, type ApplyEnvironmentOptions, ArcCurve, AssetSource, AudioCapabilities, AudioPort, type AxisAngle, type Ballistic, type Basis, BatchedMesh, type BatchedMeshOptions, type Biquad, type BiquadState, type Block16, type Block64, type Block8, Boat, BoatInput, type Bounced, Box3, CRAFT_BODIES, CRAFT_VIRTUAL_CONTROLS, type CameraPath, CameraProjection, CatalogueKind, CatmullRomCurve3, type CatmullRomType, type CompileSceneOptions, type ContactSource, CraftBodyShape, CraftDesc, type CraftInputOptions, CraftPresetName, type CraftSteering, CraftTuning, type CrossfadeOptions, CrossfadeTransition, CubicBezierCurve, CubicBezierCurve3, Curve, Curve2, Curve3, CurveKind, CurvePath, CurvePath3, type CurvePoint as CurveSample, DEFAULT_DEBUG_SEGMENTS, DEFAULT_LABEL_CAPACITY, DEFAULT_LOG_BYTES, DEFAULT_LOG_INPUTS, DIRECT_ENGINE_PREFIX, type Damped, type Damped2, type Damped3, type DcFiltered, type DcState, DebugDraw, type DebugDrawOptions, type DebugGraphics, ENGINE_SPLAT_EXPORT_NAMES, ENGINE_STREAM_EXPORT_NAMES, ENGINE_TERRAIN_EXPORT_NAMES, Each, EaseId, EllipseCurve, EngineScenery, EngineTerrain, EngineWorldStreaming, Entity, EntityTable, type EnvironmentOptions, type EnvironmentPreset, type ExtrudeOptions, type F32Vector, FX_HALF, FX_MAX, FX_MIN, FX_ONE, type Filtered, FixedArray, type FlatTrees, type FloatLayer, type FloatNet, type FoundImport, type FrenetFrames, FunctionCurve3, GAME_API_PROFILE, GAME_API_VERSION, GPU_PROBE_FLAG, GPU_PROBE_LOG_PREFIX, GameAi, GameError, type GameManifest, type GameProfile, GameUi, GeometryDesc, GeometryId, type PositionSource$1 as GeometryPositionSource, GpuDeviceClass, type GpuSetProbe, Graphics, type GridSize, HeadlessAudio, Helicopter, HelicopterInput, HullSource, type I32Vector, IMPORT_DEFAULT_MAX_DRIFT, IMPORT_DEFAULT_SAMPLES, INPUT_SOURCES, type ImportActivation, type ImportDrift, ImportError, type ImportLayerReport, type ImportOptions, type Imported, type ImpulseResult, InputActions, InputLog, type InputSource, InputTap, JsNav, KERNEL_STD_SOURCES, Kernel, type KernelArray, type KernelArrayKind, type KernelCurve, KernelEngine, type KernelLut, type KernelLut2, KernelMeta, type KernelRecording, type KernelRecordingOptions, KernelRunner, type KernelSampler, KernelSchedule, type KernelTable, KernelWatch, type KeyframeStore, LIFE_SIZE, LIFE_TINT, LOOP_MAX_REGION_ROWS, LOOP_PROBE_GLOBAL, type LabelAnchorSource, type LabelDesc, type LabelEngineText, type LabelOccluder, type LaunchAngles, LineCurve, LineCurve3, LineWriter, type LoopElement, type LoopEngine, type LoopField, type LoopFold, type LoopPayload, type LoopProbe, type LoopSchedule, type LoopSettings, type LoopStats, LoweredLoop, MAT3_SIZE, MEDIA_VOLUME_FEATURE, MIRROR_MAX_DEPTH, MLP_ACT_LINEAR, MLP_ACT_RELU, MLP_MEMORY_MAX, MLP_MEMORY_MIN, MOE_DEFAULT_BALANCE, MOE_MAX_EXPERTS, MOE_MIN_EXPERTS, type MaskVector, type Mat3Array, type Mat4Array, MaterialDesc, MaterialId, type MlpEpisode, type MlpLayerSpec, type MlpMemory, type MlpTrained, type MlpTrainingData, type MlpTrainingOptions, type MoeNet, type MoeTrained, type MoeTrainingOptions, NO_RESOURCE, NavDesc, NavPath, NavPort, type NavTileDesc, type NavTilePoly, NetworkHint, NodeDesc, NodeId, Noise, type NumberVector, PARTICLE_FIELDS, PARTICLE_LOOK_FIELDS, type ParametricFunction, type Particle, type ParticleLook, Path, PickHit, type PidState, type PidStep, type PlainLayer, type PositionSource, PostChainId, PostEffectDesc, PredictorOptions, PrefetchLayerDesc, type PrimitiveBuffers, type PrimitiveSize, type ProfileCheckResult, type ProfileParseResult, type ProfileViolation, type ProfileViolationReason, QuadraticBezierCurve, QuadraticBezierCurve3, REGENERATING_FIELDS, type RecordedArg, type RecordedInput, type Regenerating, RenderPassId, RenderTargetId, type RowScanOp, RunTrace, type RunningStats, SCENE_FLAG_PINNED, SCENE_FLAG_SUPPORTED, SCENE_FLAG_VIOLATING, SCENE_HEADER_BYTES, SCENE_OUTPUT_MAGIC, SCENE_OUTPUT_VERSION, SCENE_PLACEMENT_BYTES, SCENE_SOLVER_EXPORTS, SCENE_VIOLATION_BYTES, type SH4, type SH9, STEER_AGENT_FIELDS, STEER_DIRECTION, STEER_FACE, STEER_SEEK, STEER_STOP, type SceneAgent, type SceneAreaSpec, SceneCatalogue, type SceneCompass, type SceneCompilation, type SceneDefinition, type SceneDiagnostic, type SceneDiagnosticCode, type SceneObjectSpec, type SceneOutputHeader, type ScenePathSpec, type ScenePlacement, type ScenePlacementReport, type SceneQuality, type SceneRect, type SceneRegionSpec, type SceneSolveResult, type SceneSolver, type SceneSpec, type SceneVec2, type SceneWire, SceneryBodyPort, SceneryEdit, SceneryPort, ScreenLabels, type ScreenLabelsOptions, ScreenTransition, type SegmentPair, Selection, Shape, ShapeDesc, ShapePath, type ShapePoints, ShapeUtils, type SimBody, type SimulatedEngine, type SimulatedLink, type SourceFile, Sphere, SplatTwin, type SplatTwinOptions, SplineCurve, StateMirror, type SteerAgent, type StreamingReport, type StreamingSimulation, StudioTimeline, type SwingTwist, TIMELINE_KEYFRAME_EVERY, TIMELINE_KEYFRAME_SLOTS, TIMELINE_MAX_TICKS, TRANSITION_PROGRESS, TableSchema, TerrainPort, type TextGeometryDirection, type TextGeometryOptions, TextStyleDesc, TextureDesc, TextureId, TickLockstepLink, type TickLockstepLinkOptions, TickRoomTransport, type TiltOptions, TiltSteering, TimeTravel, type TimelineGame, type TimelineSend, type TimelineSim, type TimelineSnapshots, ToneMapping, type TraceDiff, type TraceEvent, Transforms, type TransitionKind, type TransitionOptions, TreeModel, type TreeModelBackend, type TreeModelFormat, type TreeModelInfo, type TreeModelOutput, type TreeModelTransform, type TreeModelVariant, type TreeWalk, type TriangleHit, type TwinBody, type TwinLook, type TwinVariant, type TypefaceFont, type TypefaceGlyph, Vec2, Vec3, VehiclePort, VehicleSolver, type VehicleWorld, type VerletState, VirtualSlider, VirtualStick, WAKE_NEVER, type WebAudioOptions, WebAudioPort, type WireKind, type WireObject, type WireRelation, type WireTarget, WorldStreamingPort, aabbOverlap, index as ai, allocateFrenetFrames, allocateLockstepState, allocatePrimitive, angleDiff, angleOf2, applyEnvironmentPreset, applyMatrix4 as applyGeometryMatrix4, approach, argmax, arriveVelocity, arrowHelper, axesHelper, basisFrom, bindSampler, biquadBandpass, biquadHighpass, biquadLowpass, biquadNotch, biquadPeaking, biquadStep, bitExtract, bitInsert, blendOver, boxGeometry, boxHelper, boxSize, cameraHelper, capsuleGeometry, capsuleSize, cell, centerGeometry, checkGameSources, checkNet, circleGeometry, circleSize, closestInAabb, closestInObb, closestOnSegment, closestOnTriangle, closestSegments, clz, compactRows, compileScene, computeBoundingBox, computeBoundingSphere, computeTangents, computeVertexNormals, coneGeometry, configureLoops, contourArea, copyCurvePoint, createRecordedInput, createSceneSolver, ctz, curl2, curl3, curlForce, curve$1 as curve, cylinderGeometry, cylinderShellGeometry, cylinderShellSize, cylinderSize, dcBlock, dct16, dct8, dct8x8, decay, decodePlacements, dedupRows, dense, denseQ8, denseRelu, denseTable, detCos, detExp, detLog, detSin, diffTraces, dirOf2, directionalLightHelper, dodecahedronGeometry, dragPos, dragVel, earcut, earcutDeviation, edgeComponents, edgesGeometry, ema, encodeCraft, encodeNavTile, engineLabelText, engineLockstepHost, engineOf, environmentTexture, eulerStep, evalMoeLane, expSmooth, expSmooth2, expSmooth3, extrudeGeometry, f32, f32x2, f32x3, f32x4, f64, f64Bits, facos, fasin, fatan, fatan2, fbm2, fbm3, fcos, fexp, floatEval, flog, flog2, fpow, fromHalf, fsin, ftan, type fx, type fx64, fx64Add, fx64Cos, fx64Div, fx64FromF32, fx64FromFx, fx64FromInt, fx64Lt, fx64Mul, fx64Neg, fx64Sin, fx64Sqrt, fx64Sub, fx64ToF32, fx64ToFx, fxAbs, fxAdd, fxCos, fxDiv, fxFloor, fxFrac, fxFromF32, fxFromInt, fxLerp, fxMul, fxNeg, fxSin, fxSqrt, fxSub, fxToF32, fxToInt, generatedSamples, gradient, gridComponents, gridHelper, gridPropagate, gridReach, groupRows, headingFrom, heightNormal, helperSegments, hemisphereLightHelper, histogram, hslToRgb, hsvToRgb, hullSamples, i32, i32x2, i32x3, i32x4, icosahedronGeometry, idct16, idct8, idct8x8, importMlp, importMoe, inCone, inPolygon, inTriangle, interceptTime, interceptTime2, isClockWise, isSceneDefinition, joinMemory, kernelArray, lanes as kernelLanes, fmath as kernelMath, fmath64 as kernelMath64, kernelRecording, toolkit as kernelToolkit, transforms as kernelTransforms, latheGeometry, latheSize, launchAngles, launchSpeed, leakyRelu, limitLength2, lineGeometry, linearToOklab, linearToSrgb, linearToSrgb3, loadMlp, logGpuSetProbe, loopEngineOf, loopProbe, lowerLoop, luminance, lut, lut2, type m32x2, type m32x3, type m32x4, m3inverse, m3mul, m3transpose, m3vec, m4dir, m4inverseAffine, m4mul, m4point, m4transpose, mat3, mat3Determinant, mat3FromMat4, mat3Identity, mat3Invert, mat3Multiply, mat3NormalMatrix, mat3SetUvTransform, mat3Transpose, mat4, mat4Compose, mat4ComposeArrays, mat4Copy, mat4Decompose, mat4Determinant, mat4Frustum, mat4Identity, mat4Invert, mat4LookAt, mat4MaxScale, mat4Multiply, mat4Orthographic, mat4Perspective, mat4TransformDirection, mat4TransformPoint, mat4TransformPointArrays, mat4Translation, mat4Transpose, memorySamples, mergeGeometries, mergeVertices, mixOklab, mlp, mlpBlob, mlpWords, model, moe, moeBlob, morton2, morton2Wide, morton3, morton3Wide, moveToward, moveToward2, moveToward3, octahedronGeometry, oklabToLinear, oklabToOklch, oklchToOklab, onePole, onePoleAlpha, packAnimation, packRotation, parametricGeometry, parametricSize, parseGameProfile, parseMoe, particleColours, particleLook, particleMotion, particleMotions, particleRules, particleStep, particleVelocity, pidStep, plainNet, planeBounce, planeFromPoints, planeGeometry, planeGridGeometry, planeGridSize, planeHelper, planeSize, pointLightHelper, poissonPoint, polarGridHelper, polyhedronGeometry, popcnt, positionalAudioHelper, premultiply, presetDesc, primitiveDesc, probeGpuSetCosts, projectilePos, projectileVel, qAngle, qClampSwingTwist, qForward, qFromAxisAngle, qFromEuler, qFromTo, qIntegrate, qLookRotation, qRight, qRotateToward, qSwingTwist, qToAxisAngle, qToEuler, qUp, qnlerp, qnormalize, qslerp, quadDragStep, quantize, quat, quatFromRotationColumns, quatSlerpArrays, randBits, randChance, randCosHemisphere, randExp, randGaussian, randHemisphere, randInBall, randInDisc, randInt, randNormal, randNormal2, randOnCircle, randOnSphere, randPermute, randRange, randShuffle, randUnit, randWeighted, rayAabb, rayPlane, raySphere, rayTriangle, readOnnx, readSceneHeader, reflectVelocity, regenerate, regenerating, relu, rgbToHsl, rgbToHsv, ridged2, ridged3, ringGeometry, ringSize, rk2Step, rngKey, rotate2, rotateToward, rotl, rotr, roundedBoxGeometry, routeMlpLane, rowArgMax, rowArgMin, rowCount, rowFeedback, rowMax, rowMin, rowPhase, rowPhase64, rowPrefixSum, rowRecur, rowScan, rowSum, runGpuProbeIfAsked, sample, sampler, satBox, scanImports, scatterAdd, scene, scriptedPath, segmentDistSq, segmentedBoxGeometry, segmentedBoxSize, separationPush, setLoopEngine, setMlp, sh4Add, sh4Basis, sh4Eval, sh4Irradiance, sh4Project, sh4Rotate, sh4Scale, sh9Add, sh9Basis, sh9Eval, sh9Irradiance, sh9Project, sh9Rotate, sh9Scale, shapeGeometry, sigmoid, simplex2, simplex2d, simplex3, simplex3d, simplex4, simulateStreaming, skeletonHelper, slerpInto, smoothDamp, smoothDamp2, smoothDamp3, softmax, softplus, sortRows, sphPoly6, sphSpikyGrad, sphViscosityLap, sphereAabbOverlap, sphereGeometry, sphereImpulse, sphereSectorGeometry, sphereSectorSize, sphereSize, spheresOverlap, spotLightHelper, springForce, springStep, srgbToLinear, srgbToLinear3, statsAdd, statsSampleVariance, statsVariance, steerAccelerate, steerAgent, steerAgents, sweepSpherePlane, tanhf, tetrahedronGeometry, texBricks, texCells, texFbm, texNoise, texNormal, texRamp, texRemap, texRidged, texRings, texTiles, texWeave, textGeometry, textShapes, toHalf, toNonIndexed, toU32, topRows, torusGeometry, torusKnotGeometry, torusKnotSize, torusSize, trainMlp, trainMoe, transitionEffect, translateGeometry, triangulateShape, tubeGeometry, tubeSize, tune, u32, u64, u64Words, uaddCarry, umulhi, unbindSampler, unmorton2, unmorton3, unpremultiply, usubBorrow, vabs, vadd, vand, vclamp, vcross, vdiv, vdot, vec2, vec3, vec4, veq, verletStep, vertexNormalsHelper, vfloat, vfloor, vhmax, vhmin, vint, vlane, vle, vlength, vlerp, vlt, vmLoopEngine, vmax, vmin, vmul, vmuladd, vne, vneg, vnormalize, vnot, vor, vselect, vshl, vshr, vshuffle, vsqrt, vsub, vsum, vtovec, vushr, vwith, vxor, warp2, warp3, wireframeGeometry, worley2, worley3, wrapAngle, writeBox, writeCapsule, writeCircle, writeCylinder, writeCylinderShell, writeLathe, writeParametric, writePlane, writePlaneGrid, writeRing, writeSegmentedBox, writeSphere, writeSphereSector, writeTorus, writeTorusKnot, writeTube, yawDegrees, yawStep };