@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives.d.ts

@@ -0,0 +1,2430 @@
+import { C as Ctx, a9 as StatusLine, aa as SessionCompletion, L as LifecycleEvent, M as UiEvent, b as UiNode, H as HostSheetRequest, ab as SheetResult, S as SurfaceOptions, ac as GraphicsSurface, f as PlatformEngine, _ as RenderingProfile, $ as Persona, x as LocaleInfo, ad as GenerateSource, ae as Generated, af as AiContentKind, ag as GenerateRequest, ah as AiContentCalls, ai as AiContentRule, aj as CtxGenerate, ak as DEFAULT_RETRIES, al as DEFAULT_TIMEOUT_MS, am as GenerateOptions, an as GenerateReason, ao as GenerateScope, ap as MAX_TIMEOUT_MS, aq as MIN_TIMEOUT_MS, ar as PrefetchEntry, as as acceptContent, at as contentRequest, au as createGenerate, av as runContent, aw as ProgressiveCancelled, ax as ProgressiveFeed, h as ProgressiveListener, i as ProgressiveLoad } from './local-VZkqsCzR.js';
+export { ay as AchievementId, az as AchievementList, aA as AchievementProgressRequest, aB as AchievementState, aC as AckFrame, aD as ActionName, aE as ActionReceipt, aF as ActionRef, aG as ActionStatus, aH as ActionSummary, aI as AdFormat, aJ as AddressRef, aK as Admission, aL as AgentAskRequest, aM as AgentBudget, aN as AgentEvent, aO as AgentRun, aP as AgentRunId, aQ as AgentRunRef, aR as AgentRunState, aS as AgentRunStatus, aT as AiAction, aU as AiActionName, aV as AiActionSetName, aW as AiAudience, aX as AiCharacterName, aY as AiChoiceName, aZ as AiContent, a_ as AiContentFallback, a$ as AiContentOutcome, b0 as AiContentPayment, b1 as AiContentPrefetchRequest, b2 as AiContentRequest, b3 as AiContentScope, b4 as AiConverseRequest, b5 as AiEvent, A as AiGenerateRequest, b6 as AiImageRequest, b7 as AiOutput, b8 as AiOutputSpec, b9 as AiPayerKind, ba as AiPrefetchReceipt, bb as AiPrefetchRequest, bc as AiPromptName, bd as AiResult, be as AiRetraction, bf as AiRoute, j as AiRun, bg as AiRunId, bh as AiRunRef, bi as AiRunState, bj as AiRunStatus, bk as AiSchemaName, bl as AiSlotName, bm as AiSlotValue, bn as AiSpeakRequest, bo as AiSpeechSource, bp as AiStyleName, bq as AiThreadForgotten, br as AiThreadKey, bs as AiThreadRef, bt as AiTranscribeRequest, bu as AiTranslateRequest, bv as AiUsage, bw as AnalyticsAccepted, bx as AnalyticsBatch, by as AnalyticsEvent, bz as AnalyticsEventName, bA as AnalyticsProperty, bB as AnalyticsValue, bC as ArcChallenge, bD as ArcChallengePage, bE as ArcChallengesQuery, bF as ArcEntryId, bG as ArcEntryKind, bH as ArcEntryReceipt, bI as ArcEntryRequest, bJ as ArcId, bK as ArcMilestone, bL as ArcProgress, bM as ArcRef, bN as ArcStatus, bO as ArgumentProblem, bP as Assignment, bQ as AudioBus, bR as AudioBusName, bS as AudioClip, bT as Availability, bU as AvailabilityQuery, bV as AvatarCast, bW as AvatarCharacter, bX as AvatarConsent, bY as AvatarConsentRequest, bZ as AvatarQuery, b_ as Balances, b$ as BalancesQuery, c0 as BindingName, c1 as BlobCommitRequest, c2 as BlobContentType, c3 as BlobDeleted, c4 as BlobDownload, c5 as BlobKey, c6 as BlobListRequest, c7 as BlobObject, c8 as BlobPage, c9 as BlobPutRequest, ca as BlobRef, cb as BlobScreening, cc as BlobUpload, cd as BlobVisibility, ce as BlockRequest, cf as BlockResult, cg as BookableSlot, ch as BookingRequest, ci as BotFill, cj as BoundCall, ck as BoundValue, cl as BusinessId, cm as CAMERA_LAYOUT, cn as CTX_CAPABILITIES, co as CTX_COMPATIBLE_FINGERPRINTS, cp as CTX_CONTRACT_FINGERPRINT, cq as CTX_CONTRACT_VERSION, cr as CTX_LIMITS, cs as CTX_MIN_SUPPORTED_CONTRACT_VERSION, ct as CacheApi, cu as CacheEntry, cv as CacheKey, cw as CacheKeyRequest, cx as CacheNamespace, cy as CacheNamespaceId, cz as CacheOpenRequest, cA as CacheScope, cB as CacheSetRequest, cC as CacheStored, cD as CameraConsent, cE as CameraConsentRequest, cF as CameraConsentStatus, cG as CameraFacing, cH as CameraGrantId, cI as CameraGrantRef, cJ as CameraPurpose, cK as CameraRig, cL as CameraView, cM as CameraViewLayer, cN as CameraViewPlacement, cO as CapabilityGrant, cP as CapacityTier, cQ as CapturedIdentity, cR as CartAddRequest, cS as CartId, cT as CartLine, cU as CartLineId, cV as CartQuery, cW as CartUpdateRequest, cX as CartView, cY as CatalogueSearch, cZ as CellKey, c_ as ChallengeId, c$ as ChallengeRequest, d0 as ChallengeResult, d1 as ChannelApi, d2 as ChannelClosed, d3 as ChannelDelivery, d4 as ChannelDestination, d5 as ChannelEvent, d6 as ChannelHandle, d7 as ChannelHeader, d8 as ChannelId, n as ChannelMessage, d9 as ChannelName, da as ChannelOrdering, db as ChannelRef, dc as ChannelStatus, dd as CheckpointId, de as ClipRecording, df as ClockReading, dg as ClockSource, dh as ColumnName, di as ColumnSpec, dj as ColumnType, dk as CommitStamp, dl as Comparison, dm as CompletionReceipt, dn as ComputeLimits, dp as ComputeRequest, dq as ComputeResult, a1 as ConsentKind, dr as Consistency, ds as ConsumeReceipt, dt as ConsumeRequest, du as ContentAudience, dv as ContentDigest, dw as ContentLevel, dx as ContentPurpose, dy as ContributionId, dz as ContributionKind, dA as ContributionReceipt, dB as ContributionStatus, dC as CounterAddRequest, dD as CounterApi, q as CounterFrame, dE as CounterHandle, dF as CounterId, dG as CounterKind, dH as CounterName, dI as CounterOpenRequest, dJ as CounterReadRequest, dK as CounterValue, dL as CreateRoomRequest, dM as CreateWorkerRequest, dN as CreateWorldRequest, dO as CtxAchievements, dP as CtxActions, dQ as CtxAds, dR as CtxAgent, dS as CtxAi, dT as CtxAnalytics, g as CtxAssets, k as CtxAudio, dU as CtxBlob, dV as CtxCamera, dW as CtxClock, dX as CtxCrypto, dY as CtxDb, dZ as CtxEconomy, Z as CtxError, d_ as CtxEvents, d$ as CtxFiles, e0 as CtxFlow, e1 as CtxGame, e2 as CtxGameServices, e3 as CtxGifts, c as CtxGraphics, e4 as CtxId, e5 as CtxIdentity, e6 as CtxInput, e7 as CtxLeaderboards, y as CtxLifecycle, e8 as CtxLocale, e9 as CtxMedia, ea as CtxModerate, eb as CtxNotify, z as CtxOperationName, ec as CtxOperations, ed as CtxProgram, ee as CtxProvider, ef as CtxPubsub, eg as CtxQueue, eh as CtxRandom, ei as CtxReport, B as CtxRequest, D as CtxResponse, ej as CtxSearch, ek as CtxSecrets, el as CtxServices, em as CtxSession, en as CtxSocial, eo as CtxTx, ep as CtxUi, eq as CtxWallet, er as CurrencyBalance, es as CurrencyClass, et as CurrencyCode, eu as CurrencyDescriptor, ev as CurrencyId, ew as Cursor, ex as DataClassification, ey as DataLineage, ez as DataScope, eA as DbDescription, eB as DbMigrateRequest, eC as DbQuery, eD as DbQueryRequest, eE as DbRows, eF as DbSchema, eG as DbValue, eH as DbWrite, eI as DecimalAmount, X as DeclaredAgeRange, eJ as DeliveryDestination, eK as DeliveryOption, eL as DeliveryOptionId, eM as DeliveryQuoteRequest, eN as DeliveryQuotes, eO as DenialReason, eP as DepartureReason, eQ as DisplayToken, eR as DownloadHandle, eS as Easing, eT as EconomyCatalogue, eU as EconomyRule, eV as EditRequest, eW as EditRequestId, eX as EditRequestReceipt, eY as EffectId, eZ as ElementKey, e_ as EmoteAccepted, e$ as EmoteId, f0 as EmoteRequest, E as EngineAttachOptions, a as EngineSurface, f1 as EnqueueRequest, f2 as EnterVenueRequest, f3 as Entitlements, f4 as EntryName, f5 as Epoch, f6 as EventEnvelope, f7 as EventSource, f8 as ExchangeId, f9 as ExchangeReceipt, fa as ExchangeRequest, fb as ExecutionLocation, fc as ExitVenueRequest, fd as ExternalInput, fe as FACE_LAYOUT, u as FRAME_CODES, ff as FRAME_FLAGS, fg as FRAME_LAYOUT, fh as FRAME_LIMITS, fi as FRAME_VERSION, F as FaceColours, fj as FaceTracker, Q as Family, fk as FastReadHeader, fl as FastReadMessage, t as FastReader, fm as FastValueHeader, p as FastValueMessage, fn as FeatureName, fo as FilePickOptions, fp as FlowCheckpointRequest, fq as FlowExpectation, fr as FlowId, fs as FlowRef, ft as FlowResultRequest, fu as FlowState, fv as FlowStatus, fw as FrameBufferPool, fx as FrameCode, fy as FrameFault, fz as FrameKindName, m as FrameListener, l as FramePublisher, fA as FriendsPage, fB as FriendsQuery, fC as GameFeel, O as GameLoop, fD as GeoPoint, fE as GestureId, fF as GiftEffectEvent, fG as GiftKindId, fH as GiftKindList, fI as GiftKindView, fJ as GiftKindsQuery, fK as GiftRecipient, fL as GiftSendResult, fM as GiftVenue, fN as GrantChanged, fO as GrantStatus, G as GraphicsApi, fP as GraphicsFeatures, fQ as HandoffEvent, fR as HandoffId, fS as HandoffResult, fT as HandoffStatus, fU as HapticKind, fV as HostCall, J as HostEvent, K as HostEventFamily, fW as HostEventOf, fX as HostRequest, Y as HostResponse, fY as HourCycle, fZ as IdentityCaptureCode, f_ as IdentityCaptureFailure, f$ as ImageSize, g0 as IncidentId, g1 as IndexName, g2 as IndexSpec, g3 as InputActionMap, g4 as InputActions, g5 as InputBinding, g6 as InstanceKey, g7 as IntegrationId, g8 as InteractiveCredit, g9 as InteractiveId, ga as InviteToken, gb as ItemDescriptor, gc as ItemHolding, gd as ItemId, ge as JobId, gf as JobRef, gg as JobState, gh as JobStatus, gi as JoinRoomRequest, gj as JoinWorldRequest, gk as KvApi, gl as KvCompareAndSetRequest, gm as KvCompareAndSetResult, gn as KvEntry, go as KvGetRequest, gp as KvKey, gq as KvKeyRequest, gr as KvListRequest, gs as KvNamespace, gt as KvNamespaceId, gu as KvOpenRequest, gv as KvPage, gw as KvRead, gx as KvSetRequest, gy as KvVersion, gz as LanguageTag, gA as LaunchContext, gB as LaunchSource, gC as LeaderboardEntry, gD as LeaderboardId, gE as LeaderboardPage, gF as LeaderboardQuery, gG as LeaderboardScope, gH as LeaderboardWindow, gI as LedgerEntryId, gJ as LedgerReceipt, gK as LedgerRequest, V as LifecycleState, gL as LimitKind, s as Listener, gM as LocalWorker, gN as LocalWorkerOptions, gO as LocationId, gP as LoopCallbacks, gQ as MAX_DATAGRAM_BYTES, gR as MeasurementSystem, gS as MediaId, gT as MediaPlayback, a4 as MediaRef, gU as MemberConnection, gV as MeterKind, gW as MetricKind, gX as MetricName, gY as MetricQuery, gZ as MetricSample, g_ as MetricSummary, g$ as MetricWindow, h0 as MilestoneId, h1 as MirrorPolicy, h2 as ModuleDigest, h3 as ModuleRef, h4 as Money, h5 as MoveInput, h6 as NearbyPage, h7 as NearbyQuery, h8 as NearbyVenue, h9 as NoArgumentCall, ha as NoArguments, hb as NotifyOptIn, hc as NotifyReceipt, hd as NotifyRequest, he as NotifyTopic, hf as OddsOutcome, hg as OddsRoll, hh as OfferId, hi as OpenChannelRequest, hj as OpenStoreRequest, hk as OperationId, hl as OptInRequest, hm as OptInState, hn as OrderDetail, ho as OrderId, hp as OrderLine, hq as OrderPage, hr as OrderProgress, hs as OrderRef, ht as OrderSummary, hu as OrdersQuery, hv as Outcome, hw as PackId, hx as PackRef, hy as PackedRgb, hz as PageRequest, hA as ParticipantId, hB as ParticleEmitter, hC as ParticleEmitterOptions, hD as PartsEvent, hE as PartsEvictionReason, hF as Payload, hG as PersonaList, hH as PersonaQuery, hI as PhysicsBodyDescriptor, hJ as PhysicsWorld, hK as PickedFile, hL as PlaceContribution, hM as PlaceDetail, hN as PlaceId, hO as PlacePage, hP as PlaceProvenance, hQ as PlaceRef, hR as PlaceSearch, hS as PlaceSummary, hT as PlacementId, hU as PlacementOutcome, hV as PlacementRequest, hW as PlacementStatus, hX as PlanarAxis, P as PlatformAudioDecoder, hY as PlatformEngineFunction, e as PlatformEngineRuntime, hZ as PlatformProfile, h_ as PlayOptions, h$ as PointerState, i0 as PostId, i1 as Predicate, i2 as PremiumHolding, i3 as PrepareActionRequest, i4 as PreparedAction, i5 as PreparedEngine, i6 as PresenceDeltaEntry, i7 as PresenceDeltaView, i8 as PresenceEntry, i9 as PresenceHeader, r as PresenceTickView, ia as PresenceVisibility, ib as PrizeId, ic as PrizesQuery, id as ProductDetail, ie as ProductId, ig as ProductPage, ih as ProductRef, ii as ProductSummary, w as ProgramInfo, ij as ProviderCallRequest, ik as ProviderEvent, il as ProviderEventId, im as ProviderOperationName, io as ProviderOutcome, ip as ProviderSubscribeRequest, iq as ProviderTopic, ir as PublishRequest, is as Published, it as PurchaseIntentId, iu as PurchaseIntentRef, iv as PurchaseIntentRequest, iw as PurchaseIntentStatus, ix as PurchaseIntentView, iy as QUANTISATION, iz as QueueName, iA as QueueRef, iB as QueueStats, iC as QuotaKind, iD as QuotaUsage, iE as RankLookup, iF as RankMember, iG as RankMemberQuery, iH as RankMode, iI as RankRangeQuery, iJ as RankUpdate, iK as RankWrite, iL as RankedEntry, iM as RankedPage, iN as RateLimitDecision, iO as RateLimitRequest, iP as ReadOptions, iQ as RegionCode, iR as RemixLineage, iS as RemoteWorkerRequest, iT as ReplayClass, iU as ReplayId, N as ReplayListener, a6 as ReplayMode, iV as ReplayRecording, iW as ReplayRules, iX as ReplayScoreRule, iY as ReplayVerdict, iZ as ReportId, a3 as ReportReason, i_ as ReportReceipt, i$ as ReportRequest, a2 as ReportTarget, a0 as RequestEnvelope, j0 as RequestId, j1 as RequestKey, j2 as ResourceKind, a5 as ResponseEnvelope, j3 as ResultId, j4 as ResultStatus, j5 as ResumeRequest, j6 as RetryPolicy, j7 as ReturnToken, j8 as Revision, j9 as RevisionId, ja as RevisionNotice, jb as RevocationReason, jc as RewardIntent, jd as RoomAccess, je as RoomApi, jf as RoomCommand, jg as RoomControlRequest, jh as RoomDeparture, ji as RoomEvent, jj as RoomHandle, jk as RoomHistory, jl as RoomHistoryRequest, jm as RoomId, jn as RoomInputHeader, o as RoomInputMessage, jo as RoomInviteRequest, jp as RoomInviteResult, jq as RoomMember, jr as RoomMode, js as RoomModel, jt as RoomMoveReceipt, ju as RoomMoveRequest, R as RoomRealtime, jv as RoomRef, jw as RoomResult, jx as RoomResultRequest, jy as RoomRetention, jz as RoomRole, jA as RoomState, jB as RoomStatus, jC as RoomTarget, jD as RowScope, jE as RuleId, jF as RuleKind, jG as SPEND_LIMITS, jH as SafeAreaInsets, jI as SaveSlots, jJ as Scene, jK as SceneManager, jL as ScheduleRequest, jM as SchemaName, jN as SchemaRef, jO as ScoreReceipt, jP as ScoreStatus, jQ as ScreenedContent, jR as ScreeningId, jS as ScreeningRef, jT as ScreeningRequest, jU as ScreeningResult, jV as ScreeningVerdict, jW as SearchDocument, jX as SearchDocumentId, jY as SearchHit, jZ as SearchIndexName, j_ as SearchIndexRequest, j$ as SearchIndexed, k0 as SearchQuery, k1 as SearchRemoveRequest, k2 as SearchRemoved, k3 as SearchResults, k4 as SecretHandle, k5 as SecretHandleGrant, k6 as SecretName, k7 as SecretRequest, k8 as SecretSignRequest, k9 as SecretSignature, ka as SeedGrant, kb as SeedRequest, kc as SeedScope, kd as SeededStream, ke as SelectedContext, kf as SelectedContextKind, kg as SendGiftRequest, kh as ServiceId, ki as SessionOutcome, kj as SessionToken, kk as ShareAudience, kl as ShareRequest, a8 as ShareResult, km as ShareTarget, kn as ShareToken, ko as SignatureAlgorithm, kp as SlotId, kq as SnapshotHoldMs, kr as SocialPostKind, ks as SocialPostRequest, a7 as SocialPostResult, kt as SortDirection, ku as SortKey, kv as SpawnTarget, kw as SpectatorPolicy, kx as SpendAllowance, ky as SpendGrant, kz as SpendLimit, kA as SpendReceiptId, kB as SpendRequest, kC as SpendResult, kD as SpendStatus, kE as SponsoredItem, kF as SponsoredItemId, kG as SponsoredItemList, kH as SponsoredItemsQuery, kI as SponsoredPrize, kJ as SponsoredPrizeList, kK as Standing, kL as StatementName, kM as StatusLineRequest, kN as StepResult, kO as StoreAccess, kP as StoreApi, kQ as StoreCheckpoint, kR as StoreCheckpointRequest, kS as StoreCommit, kT as StoreCommitRequest, kU as StoreEntry, kV as StoreEntryPage, kW as StoreEvent, kX as StoreGetRequest, kY as StoreHandle, kZ as StoreId, k_ as StoreKey, k$ as StoreListRequest, l0 as StoreMigrateRequest, l1 as StoreRestoreRequest, l2 as StoreSubscribeRequest, l3 as StoreSubscription, l4 as StoreWrite, l5 as SubmitScoreRequest, l6 as SubscriptionClosed, I as SubscriptionGrant, l7 as SubscriptionId, l8 as SubscriptionRef, l9 as SurfacePointer, la as SurfacePointerListener, lb as SurfacePointerPhase, lc as SurfaceSafeAreaListener, ld as SurfaceWheelListener, le as TableName, lf as TableSpec, lg as TaskApi, lh as TaskEvent, li as TaskId, lj as TaskRef, lk as TaskState, ll as TaskStatus, lm as TextDirection, ln as TickAdmission, T as TickEndpoints, lo as TimeZoneName, lp as TopicApi, lq as TopicMessage, lr as TopicName, ls as TopicRequest, lt as TopicSubscription, lu as TradeId, lv as TradeLeg, lw as TradeOffer, lx as TradeProposal, ly as TradeRef, lz as TradeSettlement, lA as TradeStatus, lB as TransactionCommit, lC as TransactionId, lD as TransactionRef, lE as TransactionStep, lF as TurnEngine, lG as TurnView, lH as TxAborted, lI as TxBeginRequest, lJ as TxCommitRequest, lK as TxHandle, lL as TxStageRequest, lM as TxStaged, lN as UiActionName, v as UiPresentation, lO as UiTrigger, lP as UniversalLink, lQ as UnixMillis, lR as UnlockId, U as Unsubscribe, lS as UploadHandle, lT as UserDecision, lU as VariantId, lV as VariantSummary, lW as VenueId, lX as VenueKind, lY as VenueSession, lZ as VisibilityRequest, l_ as VisibilityState, l$ as VoiceName, m0 as WalletOffer, m1 as WalletOffers, m2 as Weekday, m3 as WorkerApi, m4 as WorkerDelivery, m5 as WorkerEvent, m6 as WorkerHandle, m7 as WorkerId, m8 as WorkerLimits, m9 as WorkerMessage, ma as WorkerPlacement, mb as WorkerRef, mc as WorkerStatus, md as WorldAccess, me as WorldAdmin, mf as WorldApi, mg as WorldDeparture, mh as WorldEvent, mi as WorldGround, mj as WorldHandle, mk as WorldId, ml as WorldInstanceId, mm as WorldInvite, mn as WorldInviteRequest, mo as WorldLifecycle, mp as WorldLighting, mq as WorldList, mr as WorldListRequest, ms as WorldMember, mt as WorldMode, mu as WorldModerationRequest, mv as WorldPoint, mw as WorldRating, mx as WorldRef, my as WorldRole, mz as WorldRoleRequest, mA as WorldSanction, mB as WorldSession, mC as WorldSessionApi, mD as WorldSky, mE as WorldTemplate, mF as acknowledges, mG as compareStamps, mH as decodeAck, mI as decodeChannelFrame, mJ as decodeCounterAdd, mK as decodeCounterValue, mL as decodeFastRead, mM as decodeFastValue, mN as decodeMoveInput, mO as decodePresenceDelta, mP as decodePresenceTick, mQ as decodeRoomInputFrame, mR as dequantiseAxis, mS as dequantiseCellOffset, mT as dequantiseHeight, mU as dequantiseYaw, mV as encodeAck, mW as encodeCounterAdd, mX as encodeCounterValue, mY as encodeMoveInput, mZ as finishPresenceTick, m_ as frameLength, m$ as frameTag, n0 as peekFrameCode, n1 as quantiseAxis, n2 as quantiseCellOffset, n3 as quantiseHeight, n4 as quantiseYaw, n5 as readPresenceDeltaEntry, n6 as readPresenceEntry, n7 as stampChannelSender, n8 as writeChannelHeader, n9 as writeFastReadHeader, na as writeFastValueHeader, nb as writePresenceEntry, nc as writeRoomInputHeader } from './local-VZkqsCzR.js';
+import { N as NetworkMemory } from './client-Dytx_ZTC.js';
+export { C as ChannelSink, G as GAME_CHANNEL_RELIABLE_BASE, b as GAME_CHANNEL_SLOTS, I as InMemoryNetworkMemory, L as LocomotionMotion, M as Motion, c as MotionFactory, R as RoomClient, a as RoomClientOptions, d as RoomPhase, e as RoomPose, f as RoomPresence, g as RoomStats, S as StorageNetworkMemory, h as currentNetwork, l as locomotionMotion, p as previousSend, s as sendsOn } from './client-Dytx_ZTC.js';
+import { R as RoomDialer, D as Dialed, B as Bytes, L as LinkHandler, a as Lane } from './link-BUTqGmyi.js';
+export { P as Pace, b as RoomLink, c as Transport, T as TransportKind } from './link-BUTqGmyi.js';
+export { M as MAX_STATE_FRAGMENTS, R as ROOM_STATE_SLOT, S as STATE_CHUNK_BYTES, a as STATE_FRAME_VERSION, b as STATE_HEADER_BYTES, c as StateListener, d as StatePredictor, e as StateReplicaStats, T as TickStateReplica } from './state-replica-stMtdkVD.js';
+export { W as WebSocketDialer, a as WebTransportDialer } from './web-transport-C7MkBL0a.js';
+export { LockstepLoopback, LockstepLoopbackOptions, TICK_COMMAND_AREA_BYTES, TICK_DEADLINE_MS, TICK_GUEST_HEAP_BYTES, TICK_MAX_COMMAND_PAYLOAD_BYTES, TICK_MAX_STATE_BYTES, TickLayout, TickSeed, TickSimulation, TickSimulationOptions, createTickRoomSimulation, tickLayout, tickSeededWords } from './interactives-tick.js';
+import { T as TickRoomCtx } from './lockstep-D50Ia0JW.js';
+export { L as LOCKSTEP_AXIS_LIMIT, a as LOCKSTEP_AXIS_X, b as LOCKSTEP_AXIS_Z, c as LOCKSTEP_BATCH_BYTES, d as LOCKSTEP_BUTTONS, e as LOCKSTEP_CONFIG_HEADER_BYTES, f as LOCKSTEP_CONFIG_MAX_WORDS, g as LOCKSTEP_CONFIG_TAG, h as LOCKSTEP_INPUT_ACTION, i as LOCKSTEP_INPUT_STRIDE, j as LOCKSTEP_MAX_SEATS, k as LOCKSTEP_PRESENT, l as LOCKSTEP_REFEREE_BYTES, m as LOCKSTEP_STORAGE_U64_HI, n as LOCKSTEP_STORAGE_U64_LO, o as LOCKSTEP_TABLE_ALIGN, p as LOCKSTEP_WINDOW, q as LockstepColumnType, r as LockstepKernel, s as LockstepKernelHost, t as LockstepLink, u as LockstepPhase, v as LockstepPhaseKind, w as LockstepRecord, x as LockstepRecordKind, y as LockstepRecordOut, z as LockstepRoomOptions, A as LockstepRules, B as LockstepRulesDefinition, C as LockstepSchema, D as LockstepSession, E as LockstepSessionOptions, F as LockstepStats, G as LockstepTable, H as LockstepTableOptions, I as LockstepWorld, J as TickRoom, K as TickRoomDefinition, M as TickRoomError, N as TickRoomErrorCode, O as TickState, P as TickStateSchema, Q as TickStateType, R as decodeLockstepRecord, S as defineLockstep, U as defineLockstepRoom, V as defineTickRoom, W as defineTickState, X as encodeLockstepConfig, Y as lockstepChecksum, Z as lockstepConfigHash, _ as lockstepKernel, $ as lockstepKernelHost, a0 as lockstepRefereeState, a1 as lockstepRefereeTick, a2 as lockstepTable, a3 as quantiseLockstepAxis, a4 as setLockstepKernelHost, a5 as unwrapTick16 } from './lockstep-D50Ia0JW.js';
+import { S as ScriptEvaluator } from './fallback-CrG_lTFk.js';
+import { U as UiElement, N as NumberOptions, G as GameUi, F as FontTable, C as CompiledStyle, b as UiStyles, c as UiProps, d as UiExclusion } from './ui-hi7S2YcH.js';
+export { A as AccessibilityOptions, B as BREAKPOINT_LG, e as BREAKPOINT_SM, f as CompiledEntry, g as CompiledWords, h as GameUiError, i as GameUiListener, a as GameUiOptions, j as GameUiSink, P as PassthroughListener, R as RootOptions, S as STYLE_RECORD_REFERENCED, k as STYLE_RECORD_SAFE_EDGES, l as SlotFactory, m as StyleRecord, T as TextMeasurer, n as TransitionOptions, o as UiCondition, p as UiConditional, q as UiDynamicStyle, r as UiEnvironment, s as UiExact, t as UiMeasureStyle, u as UiStateName, v as UiStyleArg, w as UiStyleDefinition, x as UiStyleGradient, y as UiStyleInput, z as UiStyleProperty, D as UiStyleShadow, E as UiStyleSheet, H as UiStyleSheetOf, I as UiStyleValues, J as UiTextMeasureStyle, K as UiTextMetrics, L as UiTextOptions, W as WorldAnchorOptions, M as collectingSink, O as encodeStyleRecords, Q as props, V as styles } from './ui-hi7S2YcH.js';
+import { U as UiClock } from './clock-B-UAjkKa.js';
+export { a as UI_CLOCK_SECONDS, u as uiClock } from './clock-B-UAjkKa.js';
+import { G as GameTheme } from './game-theme-Dg-ict5A.js';
+export { D as DEFAULT_THEME, N as NineSlice, t as theme } from './game-theme-Dg-ict5A.js';
+import { q as UiStyleError, h as UiStyle, b as UiColor, U as UiTheme, a as UiVarGroup } from './vars-Dc_PrhBK.js';
+export { E as ExclusionRecord, G as GameUiEventView, N as NO_NODE, P as PatchWriter, S as StyleCache, T as TextComposition, r as UI_EVENT_BYTES, s as UI_EVENT_DX_OFFSET, t as UI_EVENT_DY_OFFSET, u as UI_EVENT_KIND_OFFSET, v as UI_EVENT_NODE_OFFSET, w as UI_EVENT_PHASE_OFFSET, x as UI_EVENT_POINTER_OFFSET, y as UI_EVENT_TIME_OFFSET, z as UI_EVENT_VALUE_OFFSET, A as UI_EVENT_X_OFFSET, B as UI_EVENT_Y_OFFSET, C as UI_EXCLUSION_HEADER_WORDS, D as UI_HEADER_BYTES, F as UI_MAGIC, H as UI_MAX_EXCLUSIONS, I as UI_RECORD_HEADER_WORDS, J as UI_SLOT_REFERENCE, K as UI_STYLE_REFERENCED, L as UI_STYLE_SAFE_EDGES, M as UI_TOKENS_REPLACE, O as UI_VERSION, Q as UiAction, f as UiAlign, R as UiAnchor, p as UiAnchorName, V as UiEasing, m as UiEasingName, W as UiEdges, X as UiEventKind, o as UiEventName, Y as UiExclusionShape, Z as UiFlag, _ as UiFocusFlag, $ as UiGradient, a0 as UiKind, i as UiKindName, d as UiLength, a1 as UiNumberFormat, c as UiNumberFormatName, a2 as UiOp, a3 as UiProp, a4 as UiRole, n as UiRoleName, a5 as UiShadow, a6 as UiSlot, a7 as UiTextOption, a8 as UiTrait, a9 as UiTransition, l as UiTransitionName, aa as UiUnit, e as UiVar, g as UiVarValue, ab as UiVectorData, ac as UiVectorDataKind, ad as UiVectorPlay, j as UiVectorPlayKind, k as UiVectorSeekKind, ae as WorldRootRecord, af as codePointOffset, ag as createTheme, ah as defineVars, ai as eventStride, aj as parseColor, ak as readEvent, al as textComposition, am as textEventCapacity, an as textEventPadding, ao as varId, ap as writeStyle, aq as writeTextEvent } from './vars-Dc_PrhBK.js';
+import { A as ACTION_BASE, a as Action, C as CENTIDEGREES_PER_TURN, b as COMMAND_BYTES, c as COMMAND_OP_ID_BYTES, d as CommandPort, e as CommandWriter, D as DEFAULT_ANGLE_STEP_CENTIDEGREES, f as DEFAULT_GRID_MM, G as Ground, L as Lighting, g as Likeness, h as LocalWorld, i as LoopbackOptions, M as MAX_SELECT_IDS, j as MILLIMETRES_PER_METRE, k as MessageKind, l as MirroredResult, N as NOT_SENT, m as NO_BUILDER, n as Notice, O as OBJECT_RECORD_BYTES, P as POSITION, Q as QUATERNION_SCALE, R as ROTATION, S as SCALE, o as SCALE_UNIT_PERMILLE, p as SNAP_GRID, q as SNAP_SURFACE, r as Sanction, s as SelectMode, t as Sky, u as Status, T as TRANSFORM_BYTES, v as TRANSFORM_WORDS, V as Visibility, W as WORLD_CHANNEL_SLOT, w as WORLD_DEPTH_MM, x as WORLD_EXTENT_MM, y as WorldBuilder, z as WorldClockState, B as WorldConnection, E as WorldConnectionOptions, F as WorldMirror, H as WorldRoleCode, I as WorldSettings, J as connectWorld, K as encodeBare, U as encodeClock, X as encodeDuplicate, Y as encodeJoinCopy, Z as encodeModerate, _ as encodePlace, $ as encodeSelect, a0 as encodeSetTransform, a1 as encodeSettings, a2 as encodeTransformSelection, a3 as identityTransform, a4 as yawRotation } from './online-XeymeM9s.js';
+import { D as Dialogue, I as Infer, S as Schema, O as ObjectOf, J as JsonSchema, A as ArrayOptions, a as JsonValue, N as NumberOptions$1, b as StringOptions, d as dialogueSchema, t } from './schema-BrWxzKp6.js';
+import { n as PackageWeaveRef, o as WEAVE_BOUNDARY_MASK, p as WEAVE_CHILD_ENTRY_BYTES, q as WEAVE_HEAD_DOMAIN, r as WEAVE_LEAF_DECORATED, s as WEAVE_LEAF_ENTRY_BYTES, t as WEAVE_LEAF_TWINNED, u as WEAVE_MAX_HEIGHT, v as WEAVE_MAX_NODE_BYTES, w as WEAVE_MAX_NODE_ENTRIES, x as WEAVE_MIN_NODE_ENTRIES, y as WEAVE_NODE_HEADER_BYTES, z as WEAVE_NODE_MAGIC, A as WEAVE_NODE_ZONE, B as WEAVE_VERSION, F as WeaveChunk, H as WeaveHead, J as WeaveHeadChunk, L as WeaveHeadGroup, N as WeaveLeaf, O as WeaveLeafVisitor, Q as WeaveNodeSource, R as WeavePlan, T as WeaveRefusal, U as WeaveRoot, V as WeaveRuntimeTag, X as WeaveScheduled, Y as WeaveSession, Z as WeaveTree, W as WeaveTrust, _ as WeaveVerifyError, $ as WeaveWalk, a0 as WovenIndex, a1 as buildWeave, a2 as childDigestAt, a3 as chunkWeaveSource, a4 as deliverSchedule, a5 as leafAt, a6 as leafDigest, a7 as leafDigestAt, a8 as leafFlags, a9 as leafLength, aa as leafZone, ab as nodeMatches, ac as openWeaveHead, ad as openWeaveSession, ae as planWeave, af as storeWeaveSource, ag as unweaveIndex, ah as validWeaveRoot, ai as verifyChild, aj as verifyRoot, ak as walkWeave, al as weaveHeadMessage, am as weaveNodeCount, an as weaveNodeLevel, ao as weaveNodeValid, ap as weaveParts, aq as woven } from './weave-delivery-CW-Kstut.js';
+export { D as DEFAULT_DISK_RESERVE_BYTES, d as DEFAULT_KEPT_BUDGET_BYTES, e as DEFAULT_PART_STORE_BUDGET_BYTES, f as DEFAULT_PART_ZONE, E as EvictionListener, g as EvictionReason, G as GamePart, I as InstallOptions, K as KEEP_REASONS, h as KeepReason, M as MemoryPartBackend, i as PartEviction, j as PartSession, P as PartStoreBackend, c as PartStoreDisk, b as PartStoreOptions, a as PartStoreSnapshot, k as PartStoreStats, l as PartVerifyError, S as SharedPartStore } from './weave-delivery-CW-Kstut.js';
+export { T as TOKEN_NAMESPACE, a as TokenName, t as themeTokens, b as tokens } from './tokens-K8yxwd6G.js';
+import './network-ZXLD7l1b.js';
+import './library-DXYaMFhi.js';
+
+declare const KEY_NAMES: readonly string[];
+declare const STYLE_PROPERTY_NAMES: readonly string[];
+declare const Condition: {
+    readonly pressed: 1;
+    readonly focus: number;
+    readonly disabled: number;
+    readonly landscape: number;
+    readonly portrait: number;
+    readonly safe: number;
+    readonly sm: number;
+    readonly lg: number;
+};
+declare function conditionPriority(mask: number): number;
+
+declare const STYLE_BLOCK_MAGIC = 827937875;
+declare const STYLE_BLOCK_VERSION = 1;
+declare const VariantKind: {
+    readonly literal: 0;
+    readonly null: 1;
+    readonly referenced: 2;
+};
+declare const SLOT_REFERENCE = 2147483648;
+type StyleErrorKind = "property" | "condition" | "value" | "class" | "dynamic";
+declare class UiStyleCompileError extends UiStyleError {
+    readonly kind: StyleErrorKind;
+    readonly subject: string;
+    readonly suggestion: string | null;
+    constructor(message: string, kind: StyleErrorKind, subject: string, suggestion: string | null);
+}
+declare function compileStyle(definition: unknown): Uint32Array;
+interface BlockVariant {
+    readonly key: number;
+    readonly mask: number;
+    readonly kind: number;
+    readonly unit: number;
+    readonly refs: number;
+    readonly payload: readonly number[];
+}
+declare function readBlock(words: ArrayLike<number>): BlockVariant[];
+
+declare function tailwindVocabulary(): readonly string[];
+declare function tailwindStyle(classes: string): Record<string, unknown>;
+declare function compileClasses(classes: string): Uint32Array;
+
+declare function suggest(input: string, candidates: Iterable<string>): string | null;
+
+declare const Connecting: {
+    readonly Idle: 0;
+    readonly Pending: 1;
+    readonly Won: 2;
+    readonly Failed: 3;
+};
+type Connecting = (typeof Connecting)[keyof typeof Connecting];
+declare const Settled: {
+    readonly Waiting: 0;
+    readonly Dialed: 1;
+    readonly Failed: 2;
+};
+type Settled = (typeof Settled)[keyof typeof Settled];
+declare class Attempt implements LinkHandler {
+    readonly dialer: RoomDialer;
+    private readonly race;
+    settled: Settled;
+    dialed: Dialed | null;
+    constructor(dialer: RoomDialer, race: Connector);
+    start(request: Bytes): void;
+    frame(lane: Lane, bytes: Uint8Array): void;
+    closed(): void;
+    backpressure(failures: number, status: number): void;
+    private readonly done;
+    private readonly failed;
+}
+declare class Connector {
+    private readonly primary;
+    private readonly fallback;
+    private readonly memory;
+    private readonly network;
+    private sink;
+    private request;
+    private first;
+    private second;
+    private won;
+    private networkKey;
+    private startedAt;
+    private lastNow;
+    private state;
+    constructor(primary: RoomDialer | null, fallback: RoomDialer | null, memory: NetworkMemory, network: () => string);
+    get winner(): Dialed | null;
+    begin(request: Bytes, sink: LinkHandler, nowMs: number): void;
+    poll(nowMs: number): Connecting;
+    cancel(): void;
+    release(): Dialed | null;
+    forward(attempt: Attempt, lane: Lane, bytes: Uint8Array): void;
+    lost(attempt: Attempt): void;
+    backpressure(attempt: Attempt, failures: number, status: number): void;
+    settled(attempt: Attempt): void;
+    private launchFallback;
+    private exhausted;
+    private fail;
+}
+
+declare const JoinStatus: {
+    readonly Admitted: 0;
+    readonly Malformed: 1;
+    readonly Forged: 2;
+    readonly Expired: 3;
+    readonly UnknownResume: 4;
+    readonly Full: 5;
+    readonly Overloaded: 6;
+    readonly Unavailable: 7;
+    readonly Prewarmed: 8;
+    readonly Denied: 9;
+};
+type JoinStatus = (typeof JoinStatus)[keyof typeof JoinStatus];
+interface JoinReply {
+    status: JoinStatus;
+    slot: number;
+    route: number;
+    readonly resume: Uint8Array;
+    simulationHz: number;
+    sendHz: number;
+    tick: number;
+}
+declare function blankReply(): JoinReply;
+declare function ticketRequest(ticket: Uint8Array, version?: number): Bytes;
+declare function resumeRequest(token: Uint8Array, version?: number): Bytes;
+declare function decodeJoinReply(bytes: Uint8Array, out: JoinReply): boolean;
+
+interface Body {
+    x: number;
+    z: number;
+    axisX: number;
+    axisZ: number;
+    buttons: number;
+}
+declare function perAxisUnit(unitsPerSecond: number, stepNs: number): number;
+declare function isqrt(value: number): number;
+declare function spawn(body: Body, slot: number): void;
+declare function steer(body: Body, axisX: number, axisZ: number, buttons: number): void;
+declare class Locomotion {
+    readonly substeps: number;
+    readonly stepNs: number;
+    readonly walk: number;
+    readonly sprint: number;
+    constructor(simulationHz: number, physicsHz: number);
+    step(body: Body): void;
+}
+
+interface PanelOptions {
+    readonly theme?: GameTheme;
+    readonly style?: UiStyle;
+}
+declare function panel(ui: GameUi, options?: PanelOptions): UiElement;
+interface IconButtonOptions {
+    readonly icon: number;
+    readonly natural?: readonly [number, number];
+    readonly label?: string;
+    readonly size?: number;
+    readonly theme?: GameTheme;
+    readonly style?: UiStyle;
+    readonly onTap: () => void;
+}
+interface IconButton {
+    readonly root: UiElement;
+    setEnabled(enabled: boolean): void;
+}
+declare function iconButton(ui: GameUi, options: IconButtonOptions): IconButton;
+interface ProgressBarOptions {
+    readonly value: number;
+    readonly max?: number;
+    readonly color?: UiColor;
+    readonly width?: number;
+    readonly height?: number;
+    readonly theme?: GameTheme;
+    readonly label?: string;
+}
+interface ProgressBar {
+    readonly root: UiElement;
+    readonly fill: UiElement;
+    set(value: number): void;
+}
+declare function progressBar(ui: GameUi, options: ProgressBarOptions): ProgressBar;
+interface CurrencyCounterOptions {
+    readonly value: number;
+    readonly icon?: number;
+    readonly theme?: GameTheme;
+    readonly number?: NumberOptions;
+    readonly width?: number;
+    readonly label?: string;
+}
+interface CurrencyCounter {
+    readonly root: UiElement;
+    readonly amount: UiElement;
+    set(value: number): void;
+    animateTo(value: number, seconds: number): void;
+    update(clock: UiClock): void;
+}
+declare function currencyCounter(ui: GameUi, options: CurrencyCounterOptions): CurrencyCounter;
+interface TabsOptions {
+    readonly labels: readonly string[];
+    readonly selected?: number;
+    readonly theme?: GameTheme;
+    readonly onChange: (index: number) => void;
+}
+interface Tabs {
+    readonly root: UiElement;
+    readonly tabs: readonly UiElement[];
+    select(index: number): void;
+}
+declare function tabs(ui: GameUi, options: TabsOptions): Tabs;
+interface ItemCardOptions {
+    readonly icon: number;
+    readonly natural?: readonly [number, number];
+    readonly title: string;
+    readonly price?: number;
+    readonly currency_icon?: number;
+    readonly rarity?: UiColor;
+    readonly theme?: GameTheme;
+    readonly onTap?: () => void;
+}
+interface ItemCard {
+    readonly root: UiElement;
+    setTitle(title: string): void;
+    setPrice(price: number): void;
+    setSelected(selected: boolean): void;
+}
+declare function itemCard(ui: GameUi, options: ItemCardOptions): ItemCard;
+interface Toast {
+    readonly root: UiElement;
+    show(text: string, seconds?: number): void;
+    update(clock: UiClock): void;
+}
+declare function toast(ui: GameUi, options?: {
+    readonly theme?: GameTheme;
+}): Toast;
+interface DialogueBoxOptions {
+    readonly theme?: GameTheme;
+    readonly portrait?: number;
+    readonly characters_per_second?: number;
+    readonly onNext?: () => void;
+}
+interface DialogueBox {
+    readonly root: UiElement;
+    say(speaker: string, line: string): void;
+    skip(): void;
+    update(clock: UiClock): void;
+    readonly finished: boolean;
+}
+declare function dialogueBox(ui: GameUi, options?: DialogueBoxOptions): DialogueBox;
+interface WorldLabelOptions {
+    readonly text: string;
+    readonly position: readonly [number, number, number];
+    readonly health?: number;
+    readonly theme?: GameTheme;
+    readonly reference_distance?: number;
+}
+interface WorldLabel {
+    readonly root: UiElement;
+    move(x: number, y: number, z: number): void;
+    setText(text: string): void;
+    setHealth(ratio: number): void;
+    setOccluded(occluded: boolean): void;
+}
+declare function worldLabel(ui: GameUi, options: WorldLabelOptions): WorldLabel;
+
+interface SimulatorHost {
+    render(tree: UiNode): void;
+    openSheet?(request: HostSheetRequest): Promise<SheetResult>;
+    toast(text: string): void;
+    acquireSurface?(options: SurfaceOptions): Promise<GraphicsSurface>;
+    engine?(): Promise<PlatformEngine>;
+    requestFrame?(callback: (time: number) => void): number;
+    cancelFrame?(handle: number): void;
+}
+interface SimulatorOptions {
+    readonly host: SimulatorHost;
+    readonly profile: RenderingProfile;
+    readonly interactiveId?: string;
+    readonly persona?: Persona;
+    readonly locale?: LocaleInfo;
+    readonly now?: () => number;
+    readonly seed?: number;
+}
+interface Simulator {
+    readonly ctx: Ctx;
+    readonly unsupported: ReadonlySet<string>;
+    readonly status: StatusLine;
+    readonly completions: readonly SessionCompletion[];
+    emit(event: LifecycleEvent): void;
+    dispatch(event: UiEvent): void;
+    dispose(): void;
+}
+declare class SimulatorUnsupportedError extends Error {
+    readonly member: string;
+    constructor(member: string);
+}
+declare const SIMULATOR_FIXED_STEP_MS: number;
+declare function createSimulatorCtx(options: SimulatorOptions): Simulator;
+
+declare const ENGINE_ABI_VERSION = 1882262861;
+declare const ENGINE_ABI_DIGEST = 1886559909;
+declare const ENGINE_EXPORT_PROTOTYPES: Readonly<Record<string, number>>;
+
+declare const ENGINE_COMPATIBILITY_EXPORT_NAMES: readonly ["engine_export_prototype_of", "engine_abi_compatible"];
+declare const ENGINE_FEATURE_NAMES: readonly ["particles", "raw_compute", "raw_render", "text", "pick", "post_shaders", "audio", "physics", "models", "images", "ai", "ui", "animation", "render_targets", "kernel_isa_1", "kernel_gpu_1", "kernel_isa_2", "fluid_1", "destruction_1", "chemistry_1", "genesis_1", "kernel_isa_3", "kernel_isa_4", "transforms_1", "scenery_1", "world_lazy_packs_1", "kernel_gather_1", "render_kernel_instances_1", "asset_reload_1", "kernel_scan_1", "texture_encode_1", "vector_1", "arena_commit_1", "vector_data_1", "compute_budget_1", "rollback_1", "inspector_1", "soft_body_1", "fluid_elastic_1", "render_feed_pose_1", "audio_lockstep_1", "audio_worklet_1", "kernel_mlp_1", "voxel_facet_1", "kernel_simd_1", "media_volume_1", "gpu_smoke_1", "reactive_fluid_1", "cloth_1", "script_shaders_1", "vector_world_1", "joints_6dof_1", "ragdoll_1", "shapes_compound_1", "rigid_coupling_1", "destruction_2", "ragdoll_policy_1", "kernel_query_rank_1", "kernel_moe_1"];
+type EngineFeatureName = (typeof ENGINE_FEATURE_NAMES)[number];
+interface EngineFeatureUse {
+    readonly types: readonly string[];
+    readonly property: string;
+    readonly values: readonly string[];
+}
+interface EngineFeature {
+    readonly exports: readonly string[];
+    readonly calls: readonly string[];
+    readonly web?: readonly string[];
+    readonly uses?: readonly EngineFeatureUse[];
+}
+declare function engineFeatureMember(call: string): string;
+declare const ENGINE_FEATURES: Readonly<Record<EngineFeatureName, EngineFeature>>;
+declare const ENGINE_ARENA_FEATURE: EngineFeatureName;
+declare const ENGINE_ARENA_BASELINE_BYTES: number;
+declare const ENGINE_ARENA_CHUNK_BYTES: number;
+declare const ENGINE_ARENA_MAX_CEILING_BYTES: number;
+declare const ENGINE_OPTIONAL_EXPORTS: ReadonlySet<string>;
+interface EngineExportUse {
+    readonly name: string;
+    readonly prototype: number;
+}
+declare function engineExportsUsed(glue: readonly string[], engine: ReadonlyMap<string, number>): EngineExportUse[];
+declare function unmetEngineExport(required: readonly EngineExportUse[], advertised: ReadonlyMap<string, number>): string | null;
+declare function engineFeatureExports(feature: EngineFeature, web: boolean): readonly string[];
+declare function unmetEngineFeature(required: readonly string[], available: readonly string[]): string | null;
+
+declare const GATED_ENGINE_FEATURES: readonly ["physics", "models", "images"];
+declare const TEXT_DICTIONARIES_ASSET = "runtime/text-dictionaries.bin";
+declare const TEXT_DICTIONARIES_FILE = "text-dictionaries.bin";
+type GatedEngineFeature = (typeof GATED_ENGINE_FEATURES)[number];
+interface EngineCoreVariant {
+    readonly name: string;
+    readonly features: readonly GatedEngineFeature[];
+    readonly file: string;
+    readonly threaded?: boolean;
+    readonly scripts?: boolean;
+    readonly shaders?: boolean;
+    readonly gl?: boolean;
+}
+declare const ENGINE_CORE_GL_UNIT = "@cimplify/engine-core-gl";
+declare const GL_CORE_GROUP = "gpu:webgl2";
+declare const GL_CORE_PATH = "runtime/engine-core-gl.wasm";
+declare const BASE_ENGINE_VARIANT: EngineCoreVariant;
+declare const PHYSICS_ENGINE_VARIANT: EngineCoreVariant;
+declare const CONTENT_ENGINE_VARIANT: EngineCoreVariant;
+declare const FULL_ENGINE_VARIANT: EngineCoreVariant;
+declare const THREADED_ENGINE_VARIANT: EngineCoreVariant;
+declare const ENGINE_VARIANTS: readonly EngineCoreVariant[];
+declare const THREADED_ENGINE_VARIANTS: readonly EngineCoreVariant[];
+declare const SCRIPTS_ENGINE_VARIANT: EngineCoreVariant;
+declare const SCRIPTS_ENGINE_VARIANTS: readonly EngineCoreVariant[];
+declare const SCRIPTS_SHADERS_ENGINE_VARIANT: EngineCoreVariant;
+declare const SCRIPTS_SHADERS_ENGINE_VARIANTS: readonly EngineCoreVariant[];
+declare const GL_ENGINE_VARIANTS: readonly EngineCoreVariant[];
+declare function isGlVariant(variant: EngineCoreVariant): boolean;
+declare function glVariantOf(variant: EngineCoreVariant): EngineCoreVariant | null;
+declare function webGpuVariantOf(variant: EngineCoreVariant): EngineCoreVariant;
+declare const ENGINE_FEATURE_CARGO: Readonly<Record<string, readonly string[]>>;
+declare function engineVariantFor(features: readonly string[], scripts?: boolean, shaders?: boolean): EngineCoreVariant;
+declare function scriptsVariantOf(core: EngineCoreVariant): EngineCoreVariant;
+declare function scriptsShadersVariantOf(core: EngineCoreVariant): EngineCoreVariant;
+declare function isScriptsVariant(variant: EngineCoreVariant): boolean;
+declare function isShadersVariant(variant: EngineCoreVariant): boolean;
+declare function threadedVariantOf(core: EngineCoreVariant): EngineCoreVariant;
+declare function isThreadedVariant(variant: EngineCoreVariant): boolean;
+
+declare const ENGINE_AUDIO_UNIT = "@cimplify/engine-audio";
+declare const AUDIO_WORKLET_GROUP = "audio:worklet";
+declare const AUDIO_WORKLET_PATH = "runtime/engine-audio.wasm";
+declare const AUDIO_WORKLET_FILE = "engine_audio_web.wasm";
+declare const AUDIO_RELAY_EXPORT = "engine_audio_relay_create";
+
+type ExceptionEncoding = "legacy" | "exnref";
+declare const LUAU_VM_EXCEPTIONS: ExceptionEncoding;
+type WasmValidator = (bytes: BufferSource) => boolean;
+interface ExceptionSupport {
+    readonly legacy: boolean;
+    readonly exnref: boolean;
+}
+declare function exceptionSupport(validate?: WasmValidator | null): ExceptionSupport;
+
+type LuauScriptsPath = "vm" | "fallback";
+interface LuauScriptsOptions {
+    readonly seed?: number;
+    readonly memoryLimit?: number;
+}
+interface LuauScripts {
+    readonly path: LuauScriptsPath;
+    load(bytecode: Uint8Array): Promise<number>;
+    call(module: number, name: string, ...args: number[]): number;
+    frames(module: number, name: string, dt: number, count: number): bigint;
+    setBudget(budget: number): void;
+    budget(): number;
+    setClock(seconds: number, epoch: number): void;
+    digest(): bigint;
+    resetDigest(): void;
+}
+declare class LuauScriptError extends Error {
+    readonly budget: boolean;
+    constructor(message: string, budget?: boolean);
+}
+
+type ModuleCompiler = (response: Response) => Promise<WebAssembly.Module>;
+declare class LuauVmModules {
+    private readonly compile;
+    private readonly compiled;
+    private started;
+    constructor(compile?: ModuleCompiler);
+    get compilations(): number;
+    has(address: string): boolean;
+    get(address: string): Promise<WebAssembly.Module> | null;
+    streamed(address: string, open: () => Promise<Response>): Promise<WebAssembly.Module>;
+    adopt(address: string, compiled: () => Promise<WebAssembly.Module>): Promise<WebAssembly.Module>;
+    private remember;
+}
+declare const luauVmModules: LuauVmModules;
+
+declare const ENGINE_LUAU_UNIT = "@cimplify/engine-luau";
+declare const LUAU_SCRIPTS_GROUP = "scripts:luau";
+declare const LUAU_VM_PATH = "runtime/engine-luau.wasm";
+declare const LUAU_VM_FILE = "engine_luau.wasm";
+declare const ENGINE_CORE_SCRIPTS_UNIT = "@cimplify/engine-core-scripts";
+declare const SCRIPTS_CORE_GROUP = "scripts:engine";
+declare const SCRIPTS_CORE_PATH = "runtime/engine-core-scripts.wasm";
+declare function luauVmRunsHere(): boolean;
+interface OpenLuauScripts {
+    readonly vm: () => Promise<WebAssembly.Module>;
+    readonly options?: LuauScriptsOptions;
+    readonly support?: ExceptionSupport;
+    readonly evaluate?: ScriptEvaluator;
+}
+declare function openLuauScripts(request: OpenLuauScripts): Promise<LuauScripts>;
+
+declare const UI_INSPECT_HOOK = "__cimplify_inspect";
+declare const UI_CHECKS: readonly ["text_overflow", "tap_target", "contrast", "safe_area", "text_size"];
+type UiCheckName = (typeof UI_CHECKS)[number];
+declare const UI_EXEMPT_REASONS: {
+    readonly text_overflow: readonly ["intentional_clip", "marquee", "decorative"];
+    readonly tap_target: readonly ["expanded_hit_area", "dense_grid", "secondary_control", "decorative"];
+    readonly contrast: readonly ["decorative", "disabled", "logo", "inside_image"];
+    readonly safe_area: readonly ["full_bleed_background", "dismissible_overlay", "decorative"];
+    readonly text_size: readonly ["badge_counter", "legal_fine_print", "decorative"];
+};
+type UiExemptReason<C extends UiCheckName> = (typeof UI_EXEMPT_REASONS)[C][number];
+interface UiInspectHook {
+    site(node: number, where: string, name: string | null): void;
+    exempt(node: number, check: string, reason: string): void;
+    scene(): string | null;
+    sceneApplied(name: string): void;
+    sceneEntered?(name: string): void;
+}
+declare function uiSite<E extends UiElement>(element: E, where: string, name?: string): E;
+declare function exemptUi<E extends UiElement, C extends UiCheckName>(element: E, check: C, reason: UiExemptReason<C>): E;
+declare function inspectScene(registered: (name: string) => boolean): string | null;
+declare function inspectSceneSwitch(target: string, registered: (name: string) => boolean): string;
+declare function inspectSceneEntered(name: string): void;
+
+declare function registerFontTable(font: number, table: FontTable): void;
+declare function fontTable(font: number): FontTable | undefined;
+
+declare class BreakDictionaries {
+    readonly languages: number;
+    private readonly first;
+    private readonly last;
+    private readonly offset;
+    private readonly count;
+    private readonly root;
+    private readonly edges;
+    constructor(bytes: ArrayBuffer);
+    language(codepoint: number): number;
+    child(language: number, node: number, label: number): number;
+    contains(word: string): boolean;
+    rootOf(language: number): number;
+    firstOf(language: number): number;
+    lastOf(language: number): number;
+}
+declare function registerBreakDictionaries(bytes: ArrayBuffer | null): BreakDictionaries | null;
+declare function breakDictionaries(): BreakDictionaries | null;
+
+declare const KIT_NAMESPACE = "kit";
+declare const UI_FONT_SET: readonly ["sans", "rounded", "condensed", "serif", "mono", "pixel"];
+type UiFontName = (typeof UI_FONT_SET)[number] | (string & {});
+declare const UI_DEFAULT_FONT = 0;
+declare const UI_FONT_ROLES: readonly ["body", "display", "mono"];
+type UiFontRole = (typeof UI_FONT_ROLES)[number];
+interface KitMetrics {
+    readonly radius: number;
+    readonly radiusSmall: number;
+    readonly padding: number;
+    readonly gap: number;
+    readonly gapSmall: number;
+    readonly small: number;
+    readonly body: number;
+    readonly title: number;
+    readonly display: number;
+    readonly borderWidth: number;
+    readonly focusWidth: number;
+    readonly pressScale: number;
+}
+interface KitColors {
+    readonly surface: UiColor;
+    readonly raised: UiColor;
+    readonly border: UiColor;
+    readonly accent: UiColor;
+    readonly onAccent: UiColor;
+    readonly text: UiColor;
+    readonly muted: UiColor;
+    readonly track: UiColor;
+    readonly danger: UiColor;
+    readonly success: UiColor;
+    readonly gold: UiColor;
+    readonly focus: UiColor;
+    readonly scrim: UiColor;
+    readonly highlight: UiColor;
+    readonly shadow: UiColor;
+    readonly onDanger: UiColor;
+    readonly silver: UiColor;
+    readonly bronze: UiColor;
+}
+interface KitFonts {
+    readonly body: UiFontName;
+    readonly display: UiFontName;
+    readonly mono: UiFontName;
+}
+declare const kitVars: UiVarGroup<{
+    readonly focus: "#ffffffff";
+    readonly scrim: "#05070cb3";
+    readonly highlight: "#ffffff1f";
+    readonly shadow: "#0000008c";
+    readonly onDanger: "#ffffffff";
+    readonly silver: "#c7ccd6ff";
+    readonly bronze: "#cd7f32ff";
+    readonly radius: number;
+    readonly radiusSmall: number;
+    readonly padding: number;
+    readonly gap: number;
+    readonly gapSmall: number;
+    readonly small: number;
+    readonly body: number;
+    readonly title: number;
+    readonly display: number;
+    readonly borderWidth: number;
+    readonly focusWidth: number;
+    readonly pressScale: number;
+}>;
+declare const AI_MARK_NAMESPACE = "ai_mark";
+interface AiMarkTheme {
+    readonly fill: UiColor;
+    readonly text: UiColor;
+    readonly fontSize: number;
+    readonly radius: number;
+    readonly paddingInline: number;
+}
+declare const DEFAULT_AI_MARK: AiMarkTheme;
+declare const aiMarkVars: UiVarGroup<{
+    readonly fill: UiColor;
+    readonly text: UiColor;
+    readonly fontSize: number;
+    readonly radius: number;
+    readonly paddingInline: number;
+}>;
+declare function aiMarkTheme(overrides: Partial<AiMarkTheme>): UiTheme;
+interface ThemePackDefinition {
+    readonly name: string;
+    readonly colors: KitColors;
+    readonly metrics?: Partial<KitMetrics>;
+    readonly fonts: KitFonts;
+    readonly motion?: number;
+    readonly aiMark?: Partial<AiMarkTheme>;
+}
+interface ThemePack {
+    readonly name: string;
+    readonly colors: KitColors;
+    readonly metrics: KitMetrics;
+    readonly fonts: KitFonts;
+    readonly game: GameTheme;
+    readonly theme: UiTheme;
+}
+declare function themePack(definition: ThemePackDefinition): ThemePack;
+declare const NEON_ARCADE: ThemePack;
+declare const COZY_PASTEL: ThemePack;
+declare const SPORTS_BROADCAST: ThemePack;
+declare const FANTASY_PARCHMENT: ThemePack;
+declare const THEME_PACKS: readonly ThemePack[];
+declare function kitFamily(ui: GameUi, role: UiFontRole): number;
+declare function fontStyle(ui: GameUi, role: UiFontRole): CompiledStyle;
+declare function registerUiFont(ui: GameUi, name: UiFontName, font: number, weight?: number): void;
+declare function applyThemePack(ui: GameUi, pack: ThemePack): void;
+declare function currentThemePack(ui: GameUi): ThemePack | null;
+
+type UiLayoutKeys = {
+    margin?: unknown;
+    marginInline?: unknown;
+    marginBlock?: unknown;
+    marginTop?: unknown;
+    marginRight?: unknown;
+    marginBottom?: unknown;
+    marginLeft?: unknown;
+    width?: unknown;
+    minWidth?: unknown;
+    maxWidth?: unknown;
+    height?: unknown;
+    minHeight?: unknown;
+    maxHeight?: unknown;
+    grow?: unknown;
+    shrink?: unknown;
+    basis?: unknown;
+    alignSelf?: unknown;
+    position?: unknown;
+    inset?: unknown;
+    top?: unknown;
+    right?: unknown;
+    bottom?: unknown;
+    left?: unknown;
+    zIndex?: unknown;
+};
+type UiSurfaceKeys = {
+    fill?: unknown;
+    backgroundColor?: unknown;
+    borderColor?: unknown;
+    borderWidth?: unknown;
+    radius?: unknown;
+    borderRadius?: unknown;
+    shadow?: unknown;
+    gradient?: unknown;
+    opacity?: unknown;
+};
+type UiTextKeys = {
+    fontSize?: unknown;
+    fontWeight?: unknown;
+    textColor?: unknown;
+    color?: unknown;
+    letterSpacing?: unknown;
+    lineHeight?: unknown;
+    textAlign?: unknown;
+};
+type UiPaddingKeys = {
+    padding?: unknown;
+    paddingInline?: unknown;
+    paddingBlock?: unknown;
+    gap?: unknown;
+};
+
+declare const AI_MARK_SOURCES: readonly ["generated", "cached", "replicated"];
+declare const AI_MARK_TEXT = "AI";
+declare const AI_MARK_LABEL = "AI generated";
+type AiMarkSource = GenerateSource | null | undefined;
+declare function isAiGenerated(source: AiMarkSource): boolean;
+type AiMarkStyle = UiStyles<UiSurfaceKeys & UiPaddingKeys & UiLayoutKeys>;
+type AiMarkTextStyle = UiStyles<UiTextKeys>;
+type GeneratedTextStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys & UiPaddingKeys>;
+interface AiMarkOptions {
+    readonly text?: string;
+    readonly style?: AiMarkStyle;
+    readonly textStyle?: AiMarkTextStyle;
+}
+declare class AiMark {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    private readonly states;
+    private on;
+    constructor(ui: GameUi, options?: AiMarkOptions);
+    get shown(): boolean;
+    show(source: AiMarkSource): boolean;
+}
+declare function aiMark(ui: GameUi, options?: AiMarkOptions): AiMark;
+declare function aiLabel(text: string, marked: boolean): string;
+interface GeneratedTextOptions {
+    readonly text?: string;
+    readonly source?: AiMarkSource;
+    readonly role?: UiFontRole;
+    readonly wrap?: boolean;
+    readonly style?: GeneratedTextStyle;
+    readonly textStyle?: UiStyles<UiTextKeys>;
+    readonly mark?: AiMarkOptions;
+}
+declare class GeneratedText {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    readonly mark: AiMark;
+    private current;
+    private source;
+    private shown;
+    private readonly a11y;
+    constructor(ui: GameUi, options?: GeneratedTextOptions);
+    get value(): string;
+    get marked(): boolean;
+    set(text: string, source?: AiMarkSource): void;
+    show(result: Pick<Generated<string>, "value" | "source">): void;
+}
+declare function generatedText(ui: GameUi, options?: GeneratedTextOptions): GeneratedText;
+
+type UiMove = "next" | "previous" | "up" | "down" | "left" | "right";
+interface UiFocusTarget {
+    readonly root: UiElement;
+    readonly focusNode?: UiElement;
+    activate?(): void;
+    move?(move: UiMove): boolean;
+    focusChanged?(focused: boolean): void;
+}
+type UiFocusListener = (target: UiFocusTarget | null) => void;
+declare class UiFocusScope {
+    readonly columns: number;
+    onBack: (() => boolean) | null;
+    readonly targets: UiFocusTarget[];
+    current: number;
+    constructor(columns?: number, onBack?: (() => boolean) | null);
+    add(target: UiFocusTarget): this;
+    remove(target: UiFocusTarget): this;
+    clear(): void;
+}
+declare function focusNodeOf(target: UiFocusTarget): UiElement;
+declare class UiNavigator {
+    readonly base: UiFocusScope;
+    private readonly scopes;
+    private readonly listeners;
+    private shown;
+    constructor(base?: UiFocusScope);
+    get scope(): UiFocusScope;
+    get depth(): number;
+    get focused(): UiFocusTarget | null;
+    onChange(listener: UiFocusListener): () => void;
+    has(scope: UiFocusScope): boolean;
+    push(scope: UiFocusScope): void;
+    pop(scope?: UiFocusScope | null): void;
+    focus(target: UiFocusTarget): boolean;
+    move(move: UiMove): boolean;
+    activate(): boolean;
+    back(): boolean;
+    blur(): void;
+    private first;
+    private restore;
+    private show;
+    private set;
+}
+
+type CollectionStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys>;
+interface InventoryGridOptions {
+    readonly columns: number;
+    readonly rows: number;
+    readonly cell?: number;
+    readonly gap?: number;
+    readonly label?: string;
+    readonly natural?: readonly [number, number];
+    readonly style?: CollectionStyle;
+    readonly scope?: UiFocusScope;
+    readonly onMove?: (from: number, to: number) => void;
+    readonly onSelect?: (index: number) => void;
+}
+declare class InventoryGrid implements UiFocusTarget {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly cells: readonly UiElement[];
+    readonly icons: readonly UiElement[];
+    readonly counts: readonly UiElement[];
+    readonly ghost: UiElement;
+    readonly ghostIcon: UiElement;
+    readonly assets: Int32Array;
+    readonly amounts: Int32Array;
+    readonly names: string[];
+    readonly columns: number;
+    readonly rows: number;
+    onMove: ((from: number, to: number) => void) | null;
+    onSelect: ((index: number) => void) | null;
+    private readonly pitch;
+    private readonly size;
+    private readonly cellStates;
+    private readonly iconStates;
+    private readonly ghostStates;
+    private readonly countStates;
+    private readonly natural;
+    private readonly cellA11y;
+    private cursorAt;
+    private focused;
+    private source;
+    private hover;
+    private readonly travel;
+    private readonly cellColumn;
+    private readonly cellRow;
+    private held;
+    constructor(ui: GameUi, options: InventoryGridOptions);
+    get cursor(): number;
+    get dragging(): number;
+    setSlot(index: number, asset: number, count: number, name: string): void;
+    clearSlot(index: number): void;
+    swap(a: number, b: number): void;
+    select(index: number): void;
+    focusChanged(focused: boolean): void;
+    move(move: UiMove): boolean;
+    activate(): void;
+    cancel(): boolean;
+    private begin;
+    private drag;
+    private drop;
+    private pitchesIn;
+    private placeGhost;
+    private render;
+    private paint;
+}
+declare function inventoryGrid(ui: GameUi, options: InventoryGridOptions): InventoryGrid;
+interface VirtualRow {
+    readonly root: UiElement;
+}
+interface VirtualListOptions<R extends VirtualRow> {
+    readonly count: number;
+    readonly rowHeight?: number;
+    readonly heightOf?: (index: number) => number;
+    readonly height?: number;
+    readonly width?: number;
+    readonly label?: string;
+    readonly style?: CollectionStyle;
+    readonly scope?: UiFocusScope;
+    create(ui: GameUi): R;
+    bind(row: R, index: number): void;
+    readonly onSelect?: (index: number) => void;
+}
+declare class VirtualList<R extends VirtualRow> implements UiFocusTarget {
+    readonly ui: GameUi;
+    private readonly options;
+    readonly root: UiElement;
+    readonly content: UiElement;
+    readonly slots: readonly UiElement[];
+    readonly rows: readonly R[];
+    readonly rowHeight: number;
+    readonly height: number;
+    onSelect: ((index: number) => void) | null;
+    private total;
+    private offsetY;
+    private cursorAt;
+    private focused;
+    private readonly bound;
+    private readonly flags;
+    private readonly states;
+    private readonly heightOf;
+    private offsets;
+    constructor(ui: GameUi, options: VirtualListOptions<R>);
+    get count(): number;
+    get offset(): number;
+    get cursor(): number;
+    get pool(): number;
+    get variable(): boolean;
+    rowTop(index: number): number;
+    rowSize(index: number): number;
+    get contentHeight(): number;
+    invalidateHeights(from?: number): void;
+    private measureRows;
+    private firstVisible;
+    setCount(count: number): void;
+    rebind(): void;
+    scrollTo(offset: number): void;
+    scrollToIndex(index: number): void;
+    focusChanged(focused: boolean): void;
+    move(move: UiMove): boolean;
+    activate(): void;
+    private choose;
+    private scrolled;
+    private maxOffset;
+    private extend;
+    private refresh;
+}
+declare function virtualList<R extends VirtualRow>(ui: GameUi, options: VirtualListOptions<R>): VirtualList<R>;
+interface LeaderboardOptions {
+    readonly height?: number;
+    readonly rowHeight?: number;
+    readonly width?: number;
+    readonly label?: string;
+    readonly style?: CollectionStyle;
+    readonly scope?: UiFocusScope;
+    readonly onSelect?: (index: number) => void;
+}
+interface LeaderboardRow extends VirtualRow {
+    readonly rank: UiElement;
+    readonly name: UiElement;
+    readonly score: UiElement;
+}
+declare class Leaderboard {
+    readonly ui: GameUi;
+    readonly list: VirtualList<LeaderboardRow>;
+    private names;
+    private scores;
+    private me;
+    private readonly rowStates;
+    private readonly rankStates;
+    private readonly nameStates;
+    private readonly scoreStyle;
+    constructor(ui: GameUi, options?: LeaderboardOptions);
+    get root(): UiElement;
+    setEntries(names: readonly string[], scores: ArrayLike<number>, me?: number): void;
+    showMe(): void;
+    private bind;
+}
+declare function leaderboard(ui: GameUi, options?: LeaderboardOptions): Leaderboard;
+interface ChatLogOptions {
+    readonly width?: number;
+    readonly height?: number;
+    readonly fontSize?: number;
+    readonly capacity?: number;
+    readonly label?: string;
+    readonly style?: CollectionStyle;
+    readonly scope?: UiFocusScope;
+}
+interface ChatLogRow extends VirtualRow {
+    readonly line: UiElement;
+}
+declare class ChatLog {
+    readonly ui: GameUi;
+    readonly list: VirtualList<ChatLogRow>;
+    readonly capacity: number;
+    private readonly lines;
+    private head;
+    private readonly lineWidth;
+    private readonly measured;
+    private readonly measureStyle;
+    constructor(ui: GameUi, options?: ChatLogOptions);
+    get root(): UiElement;
+    get count(): number;
+    line(index: number): string;
+    push(sender: string, message: string): void;
+    private heightOf;
+}
+declare function chatLog(ui: GameUi, options?: ChatLogOptions): ChatLog;
+
+type ButtonVariant = "primary" | "secondary" | "ghost" | "danger";
+type ButtonStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys & UiPaddingKeys>;
+type ButtonLabelStyle = UiStyles<UiTextKeys>;
+type ControlStyle = UiStyles<UiLayoutKeys>;
+interface TextButtonOptions {
+    readonly label: string;
+    readonly variant?: ButtonVariant;
+    readonly icon?: number;
+    readonly natural?: readonly [number, number];
+    readonly disabled?: boolean;
+    readonly style?: ButtonStyle;
+    readonly labelStyle?: ButtonLabelStyle;
+    readonly scope?: UiFocusScope;
+    readonly onPress?: () => void;
+}
+declare class TextButton implements UiFocusTarget {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    onPress: (() => void) | null;
+    private readonly a11y;
+    constructor(ui: GameUi, options: TextButtonOptions);
+    get disabled(): boolean;
+    setLabel(value: string): void;
+    setDisabled(disabled: boolean): void;
+    activate(): void;
+}
+declare function textButton(ui: GameUi, options: TextButtonOptions): TextButton;
+interface ToggleOptions {
+    readonly label: string;
+    readonly value?: boolean;
+    readonly disabled?: boolean;
+    readonly style?: ControlStyle;
+    readonly scope?: UiFocusScope;
+    readonly onChange?: (value: boolean) => void;
+}
+declare class Toggle implements UiFocusTarget {
+    readonly root: UiElement;
+    readonly track: UiElement;
+    readonly knob: UiElement;
+    onChange: ((value: boolean) => void) | null;
+    private on;
+    private readonly tracks;
+    private readonly knobs;
+    private readonly a11y;
+    constructor(ui: GameUi, options: ToggleOptions);
+    get value(): boolean;
+    set(value: boolean, notify?: boolean): void;
+    setDisabled(disabled: boolean): void;
+    activate(): void;
+}
+declare function toggle(ui: GameUi, options: ToggleOptions): Toggle;
+interface SliderOptions {
+    readonly label: string;
+    readonly value?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly width?: number;
+    readonly format?: (value: number) => string;
+    readonly disabled?: boolean;
+    readonly style?: ControlStyle;
+    readonly scope?: UiFocusScope;
+    readonly onChange?: (value: number) => void;
+}
+declare class Slider implements UiFocusTarget {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly rail: UiElement;
+    readonly fill: UiElement;
+    readonly thumb: UiElement;
+    readonly readout: UiElement;
+    readonly min: number;
+    readonly max: number;
+    readonly step: number;
+    onChange: ((value: number) => void) | null;
+    private index;
+    private dragFrom;
+    private readonly steps;
+    private readonly travel;
+    private readonly width;
+    private readonly texts;
+    private readonly a11y;
+    constructor(ui: GameUi, options: SliderOptions);
+    get value(): number;
+    set(value: number, notify?: boolean): void;
+    select(step: number, notify?: boolean): void;
+    nudge(direction: number): void;
+    setDisabled(disabled: boolean): void;
+    move(move: UiMove): boolean;
+}
+declare function slider(ui: GameUi, options: SliderOptions): Slider;
+interface DropdownOptions {
+    readonly label: string;
+    readonly options: readonly string[];
+    readonly selected?: number;
+    readonly width?: number;
+    readonly disabled?: boolean;
+    readonly style?: ControlStyle;
+    readonly scope?: UiFocusScope;
+    readonly navigator?: UiNavigator;
+    readonly onChange?: (index: number) => void;
+}
+declare class DropdownOption implements UiFocusTarget {
+    private readonly owner;
+    readonly index: number;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    private readonly a11y;
+    constructor(ui: GameUi, owner: Dropdown, index: number, value: string);
+    mark(selected: boolean): void;
+    activate(): void;
+}
+declare class Dropdown implements UiFocusTarget {
+    readonly options: DropdownOptions;
+    readonly root: UiElement;
+    readonly field: UiElement;
+    readonly current: UiElement;
+    readonly chevron: UiElement;
+    readonly popup: UiElement;
+    readonly items: readonly DropdownOption[];
+    readonly scope: UiFocusScope;
+    readonly optionProps: readonly [UiProps, UiProps];
+    readonly optionText: readonly [UiProps, UiProps];
+    onChange: ((index: number) => void) | null;
+    private chosen;
+    private shown;
+    private readonly popups;
+    private readonly chevrons;
+    private readonly navigator;
+    private readonly a11y;
+    private readonly popupA11y;
+    constructor(ui: GameUi, options: DropdownOptions);
+    get focusNode(): UiElement;
+    get selected(): number;
+    get open(): boolean;
+    choose(index: number, notify: boolean): void;
+    activate(): void;
+    show(): void;
+    close(): void;
+    setDisabled(disabled: boolean): void;
+    move(move: UiMove): boolean;
+}
+declare function dropdown(ui: GameUi, options: DropdownOptions): Dropdown;
+
+type HudStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys>;
+interface CountdownOptions {
+    readonly seconds: number;
+    readonly mode?: "down" | "up";
+    readonly warnAt?: number;
+    readonly label?: string;
+    readonly style?: HudStyle;
+    readonly autostart?: boolean;
+    readonly onExpire?: () => void;
+}
+declare class Countdown {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    onExpire: (() => void) | null;
+    private readonly clock;
+    private shown;
+    private warned;
+    private active;
+    private readonly roots;
+    private readonly texts;
+    private readonly mode;
+    private readonly warnAt;
+    constructor(ui: GameUi, options: CountdownOptions);
+    get remaining(): number;
+    get running(): boolean;
+    get warning(): boolean;
+    start(seconds: number): void;
+    pause(): void;
+    resume(): void;
+    add(seconds: number): void;
+    update(frame: UiClock): void;
+    private render;
+}
+declare function countdown(ui: GameUi, options: CountdownOptions): Countdown;
+type MarkerKind = "accent" | "danger" | "success" | "gold";
+declare const MAP_PAN_X = 0;
+declare const MAP_PAN_Y = 1;
+declare const MAP_HEADING = 2;
+interface MinimapOptions {
+    readonly asset: number;
+    readonly natural: readonly [number, number];
+    readonly size?: number;
+    readonly mapSize?: readonly [number, number];
+    readonly shape?: "circle" | "square";
+    readonly markers?: number;
+    readonly compass?: boolean;
+    readonly label?: string;
+    readonly style?: HudStyle;
+}
+declare class Minimap {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly image: UiElement;
+    readonly markers: readonly UiElement[];
+    readonly needle: UiElement;
+    readonly size: number;
+    private readonly markerStates;
+    private readonly hiddenMarker;
+    readonly view: Float64Array<ArrayBuffer>;
+    readonly points: Float64Array;
+    private readonly kinds;
+    private readonly shown;
+    private readonly imageBase;
+    constructor(ui: GameUi, options: MinimapOptions);
+    setImage(asset: number, width: number, height: number): void;
+    pan(x: number, y: number): void;
+    heading(radians: number): void;
+    marker(index: number, x: number, y: number, kind?: MarkerKind): void;
+    setMarkerKind(index: number, kind: MarkerKind): void;
+    hideMarker(index: number): void;
+    apply(): void;
+    private writePan;
+    private writeHeading;
+    private place;
+}
+declare function minimap(ui: GameUi, options: MinimapOptions): Minimap;
+interface RadialItem {
+    readonly label: string;
+    readonly icon?: number;
+    readonly natural?: readonly [number, number];
+}
+interface RadialMenuOptions {
+    readonly items: readonly RadialItem[];
+    readonly radius?: number;
+    readonly label?: string;
+    readonly scope?: UiFocusScope;
+    readonly deadZone?: number;
+    readonly onSelect?: (index: number) => void;
+}
+declare class RadialMenu implements UiFocusTarget {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly items: readonly UiElement[];
+    readonly center: UiElement;
+    onSelect: ((index: number) => void) | null;
+    private chosen;
+    private shown;
+    private readonly travel;
+    private readonly itemStates;
+    private readonly states;
+    private readonly labels;
+    private readonly a11y;
+    private readonly deadZone;
+    private readonly directions;
+    constructor(ui: GameUi, options: RadialMenuOptions);
+    get open(): boolean;
+    get selected(): number;
+    show(): void;
+    hide(): void;
+    point(dx: number, dy: number): void;
+    private aim;
+    select(index: number): void;
+    confirm(): number;
+    activate(): void;
+    move(move: UiMove): boolean;
+}
+declare function radialMenu(ui: GameUi, options: RadialMenuOptions): RadialMenu;
+type DamageKind = "hit" | "crit" | "heal" | "miss";
+interface DamageNumbersOptions {
+    readonly capacity?: number;
+    readonly seconds?: number;
+    readonly rise?: number;
+    readonly z?: number;
+}
+declare class DamageNumbers {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly entries: readonly UiElement[];
+    private readonly x;
+    private readonly y;
+    private readonly age;
+    private readonly kind;
+    private readonly states;
+    private readonly hidden;
+    private readonly config;
+    private cursor;
+    private live;
+    constructor(ui: GameUi, options?: DamageNumbersOptions);
+    get active(): number;
+    spawn(value: number, x: number, y: number, kind?: DamageKind): void;
+    update(frame: UiClock): void;
+    clear(): void;
+}
+declare function damageNumbers(ui: GameUi, options?: DamageNumbersOptions): DamageNumbers;
+interface BadgeOptions {
+    readonly host: UiElement;
+    readonly count?: number;
+    readonly max?: number;
+    readonly dot?: boolean;
+    readonly label?: string;
+}
+declare class Badge {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly text: UiElement;
+    private current;
+    private readonly clock;
+    private readonly states;
+    private readonly overflow;
+    private readonly labels;
+    private readonly max;
+    private readonly dot;
+    private readonly a11y;
+    constructor(ui: GameUi, options: BadgeOptions);
+    get count(): number;
+    set(count: number): void;
+    update(frame: UiClock): void;
+}
+declare function badge(ui: GameUi, options: BadgeOptions): Badge;
+
+type ModalStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys & UiPaddingKeys>;
+interface ModalOptions {
+    readonly title?: string;
+    readonly dismissible?: boolean;
+    readonly style?: ModalStyle;
+    readonly columns?: number;
+}
+declare class Modal {
+    readonly ui: GameUi;
+    readonly layer: UiElement;
+    readonly root: UiElement;
+    readonly title: UiElement | null;
+    readonly content: UiElement;
+    readonly scope: UiFocusScope;
+    dismissible: boolean;
+    onClose: (() => void) | null;
+    private readonly layers;
+    private readonly cards;
+    private readonly a11y;
+    stack: ModalStack | null;
+    constructor(ui: GameUi, options?: ModalOptions);
+    add(target: UiFocusTarget): this;
+    append(element: UiElement): this;
+    get open(): boolean;
+    shown(on: boolean, top: boolean): void;
+}
+declare function modal(ui: GameUi, options?: ModalOptions): Modal;
+interface ModalStackOptions {
+    readonly navigator?: UiNavigator;
+    readonly inert?: readonly UiElement[];
+    readonly z?: number;
+}
+declare class ModalStack {
+    readonly ui: GameUi;
+    private readonly modals;
+    private readonly navigator;
+    private readonly inert;
+    private readonly z;
+    private readonly rooting;
+    constructor(ui: GameUi, options?: ModalStackOptions);
+    get depth(): number;
+    get top(): Modal | null;
+    contains(modal: Modal): boolean;
+    push(modal: Modal): void;
+    pop(): Modal | null;
+    remove(modal: Modal): void;
+    clear(): void;
+    back(): boolean;
+}
+declare function modalStack(ui: GameUi, options?: ModalStackOptions): ModalStack;
+interface TooltipOptions {
+    readonly target: UiElement;
+    readonly text: string;
+    readonly placement?: "above" | "below";
+    readonly seconds?: number;
+    readonly navigator?: UiNavigator;
+}
+declare class Tooltip {
+    readonly ui: GameUi;
+    readonly options: TooltipOptions;
+    readonly root: UiElement;
+    readonly bubble: UiElement;
+    readonly text: UiElement;
+    private readonly remaining;
+    private pinned;
+    private visible;
+    private readonly states;
+    constructor(ui: GameUi, options: TooltipOptions);
+    get shown(): boolean;
+    setText(value: string): void;
+    show(): void;
+    pin(): void;
+    hide(): void;
+    update(frame: UiClock): void;
+    private reveal;
+}
+declare function tooltip(ui: GameUi, options: TooltipOptions): Tooltip;
+
+type ParticleKind = "confetti" | "sparkle";
+interface UiParticlesOptions {
+    readonly capacity?: number;
+    readonly z?: number;
+    readonly seed?: number;
+}
+declare class UiParticles {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly pieces: readonly UiElement[];
+    private readonly data;
+    private readonly kind;
+    private readonly color;
+    private readonly launchColors;
+    private readonly states;
+    private readonly dead;
+    private cursor;
+    private row;
+    private live;
+    constructor(ui: GameUi, options?: UiParticlesOptions);
+    get active(): number;
+    burst(kind: ParticleKind, x: number, y: number, count: number): void;
+    update(frame: UiClock): void;
+    clear(): void;
+    private draw;
+}
+declare function uiParticles(ui: GameUi, options?: UiParticlesOptions): UiParticles;
+
+interface PauseScreenOptions {
+    readonly stack: ModalStack;
+    readonly title?: string;
+    readonly onResume?: () => void;
+    readonly onSettings?: () => void;
+    readonly onQuit?: () => void;
+}
+declare class PauseScreen {
+    private readonly options;
+    readonly modal: Modal;
+    readonly resume: TextButton;
+    readonly settings: TextButton;
+    readonly quit: TextButton;
+    constructor(ui: GameUi, options: PauseScreenOptions);
+    get open(): boolean;
+    show(): void;
+    close(): void;
+}
+declare function pauseScreen(ui: GameUi, options: PauseScreenOptions): PauseScreen;
+interface SettingsValues {
+    music: number;
+    effects: number;
+    haptics: boolean;
+    quality: number;
+    language: number;
+}
+type SettingsKey = keyof SettingsValues;
+interface SettingsScreenOptions {
+    readonly stack: ModalStack;
+    readonly navigator?: UiNavigator;
+    readonly values?: Partial<SettingsValues>;
+    readonly qualities?: readonly string[];
+    readonly languages?: readonly string[];
+    readonly onChange?: (values: Readonly<SettingsValues>, key: SettingsKey) => void;
+    readonly onDone?: (values: Readonly<SettingsValues>) => void;
+}
+declare const DEFAULT_QUALITIES: readonly string[];
+declare const DEFAULT_LANGUAGES: readonly string[];
+declare class SettingsScreen {
+    private readonly options;
+    readonly modal: Modal;
+    readonly music: Slider;
+    readonly effects: Slider;
+    readonly haptics: Toggle;
+    readonly quality: Dropdown;
+    readonly language: Dropdown;
+    readonly done: TextButton;
+    readonly values: SettingsValues;
+    constructor(ui: GameUi, options: SettingsScreenOptions);
+    get open(): boolean;
+    show(): void;
+    close(): void;
+}
+declare function settingsScreen(ui: GameUi, options: SettingsScreenOptions): SettingsScreen;
+interface ResultsScreenOptions {
+    readonly stack: ModalStack;
+    readonly particles?: UiParticles;
+    readonly celebrateAt?: readonly [number, number];
+    readonly rewards?: number;
+    readonly natural?: readonly [number, number];
+    readonly onRetry?: () => void;
+    readonly onShare?: () => void;
+}
+interface ResultsData {
+    readonly victory: boolean;
+    readonly score: number;
+    readonly stars: number;
+}
+declare class ResultsScreen {
+    readonly ui: GameUi;
+    private readonly options;
+    readonly modal: Modal;
+    readonly title: UiElement;
+    readonly score: UiElement;
+    readonly stars: readonly UiElement[];
+    readonly rewards: readonly UiElement[];
+    readonly rewardIcons: readonly UiElement[];
+    readonly rewardAmounts: readonly UiElement[];
+    readonly retry: TextButton;
+    readonly share: TextButton;
+    private readonly starStates;
+    private readonly rewardStates;
+    private readonly natural;
+    private target;
+    private shownScore;
+    private earned;
+    private revealed;
+    private readonly clock;
+    private readonly a11y;
+    constructor(ui: GameUi, options: ResultsScreenOptions);
+    get open(): boolean;
+    get starsShown(): number;
+    get scoreShown(): number;
+    show(result: ResultsData): void;
+    setReward(index: number, icon: number, amount: number): void;
+    hideReward(index: number): void;
+    close(): void;
+    update(frame: UiClock): void;
+    private at;
+}
+declare function resultsScreen(ui: GameUi, options: ResultsScreenOptions): ResultsScreen;
+interface LoadingScreenOptions {
+    readonly title?: string;
+    readonly tips?: readonly string[];
+    readonly tipSeconds?: number;
+    readonly z?: number;
+}
+declare class LoadingScreen {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly spinner: UiElement;
+    readonly fill: UiElement;
+    readonly percent: UiElement;
+    readonly tip: UiElement;
+    private readonly states;
+    private readonly tips;
+    private readonly clock;
+    private tipIndex;
+    private shownPercent;
+    private visible;
+    private readonly a11y;
+    constructor(ui: GameUi, options?: LoadingScreenOptions);
+    get shown(): boolean;
+    show(): void;
+    hide(): void;
+    setProgress(ratio: number): void;
+    setPercent(value: number): void;
+    update(frame: UiClock): void;
+}
+declare function loadingScreen(ui: GameUi, options?: LoadingScreenOptions): LoadingScreen;
+interface TutorialHintOptions {
+    readonly navigator?: UiNavigator;
+    readonly z?: number;
+    readonly onDone?: () => void;
+}
+declare class TutorialHint {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly bubble: UiElement;
+    readonly text: UiElement;
+    readonly dots: readonly UiElement[];
+    readonly next: TextButton;
+    readonly skip: TextButton;
+    readonly arrow: UiElement;
+    readonly scope: UiFocusScope;
+    onDone: (() => void) | null;
+    private steps;
+    private step;
+    private readonly at;
+    private visible;
+    private readonly states;
+    private readonly dotStates;
+    private readonly navigator;
+    private readonly a11y;
+    constructor(ui: GameUi, options?: TutorialHintOptions);
+    get shown(): boolean;
+    get index(): number;
+    show(steps: readonly string[], x: number, y: number): void;
+    advance(): void;
+    hide(): void;
+    update(frame: UiClock): void;
+    private finish;
+    private go;
+}
+declare function tutorialHint(ui: GameUi, options?: TutorialHintOptions): TutorialHint;
+
+type TextBlockStyle = UiStyles<UiLayoutKeys & UiSurfaceKeys>;
+interface ChatPanelOptions {
+    readonly lines?: number;
+    readonly width?: number;
+    readonly label?: string;
+    readonly style?: TextBlockStyle;
+}
+declare class ChatPanel {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly rows: readonly UiElement[];
+    readonly names: readonly UiElement[];
+    readonly bodies: readonly UiElement[];
+    private readonly senders;
+    private readonly messages;
+    private readonly colors;
+    private readonly lineStates;
+    private readonly nameStates;
+    private readonly bodyStates;
+    private head;
+    private size;
+    constructor(ui: GameUi, options?: ChatPanelOptions);
+    get count(): number;
+    push(sender: string, message: string, color?: number): void;
+    system(message: string): void;
+    clear(): void;
+    private render;
+}
+declare function chatPanel(ui: GameUi, options?: ChatPanelOptions): ChatPanel;
+declare const RICH_COLORS: readonly ["text", "muted", "accent", "gold", "danger", "success"];
+type RichColor = (typeof RICH_COLORS)[number];
+declare class RichTextError extends Error {
+    constructor(message: string);
+}
+interface RichTextOptions {
+    readonly markup?: string;
+    readonly spans?: number;
+    readonly icons?: Readonly<Record<string, number>>;
+    readonly natural?: readonly [number, number];
+    readonly style?: TextBlockStyle;
+    readonly source?: AiMarkSource;
+    readonly mark?: AiMarkOptions;
+    readonly flowAround?: readonly UiExclusion[];
+}
+declare class RichText {
+    readonly ui: GameUi;
+    readonly root: UiElement;
+    readonly texts: readonly UiElement[];
+    readonly images: readonly UiElement[];
+    readonly mark: AiMark;
+    private source;
+    private readonly cache;
+    private readonly textStates;
+    private readonly hiddenText;
+    private readonly iconStates;
+    private readonly icons;
+    private readonly natural;
+    private shown;
+    private current;
+    private readonly a11y;
+    constructor(ui: GameUi, options?: RichTextOptions);
+    flowAround(exclusions: readonly UiExclusion[] | null): this;
+    get marked(): boolean;
+    get markup(): string;
+    get spans(): number;
+    show(result: Pick<Generated<string>, "value" | "source">): void;
+    set(markup: string, source?: AiMarkSource): void;
+}
+declare function richText(ui: GameUi, options?: RichTextOptions): RichText;
+
+declare const BOUNDS_MIN = 0;
+declare const BOUNDS_MAX = 3;
+declare const BOUNDS_WORDS = 6;
+declare function canonical(t: Float64Array): Float64Array;
+declare function bounds(t: ArrayLike<number>, offset: number, halfExtentsMm: ArrayLike<number>, halfOffset: number, out: Float64Array): Float64Array;
+declare function overlapsFootprint(a: ArrayLike<number>, b: ArrayLike<number>): boolean;
+declare function snappedToGrid(t: Float64Array, gridMm: number, angleStepCentidegrees: number): Float64Array;
+declare function snapHeightToGrid(t: Float64Array, gridMm: number): void;
+declare function movedAbout(t: ArrayLike<number>, pivotX: number, pivotY: number, pivotZ: number, dx: number, dy: number, dz: number, rotation: ArrayLike<number>, scalePermille: number, out: Float64Array): Float64Array;
+declare function withinWorld(t: ArrayLike<number>): boolean;
+declare function copyTransform(src: ArrayLike<number>, srcOffset: number, out: Float64Array, outOffset?: number): Float64Array;
+
+declare const index$3_ACTION_BASE: typeof ACTION_BASE;
+declare const index$3_Action: typeof Action;
+declare const index$3_BOUNDS_MAX: typeof BOUNDS_MAX;
+declare const index$3_BOUNDS_MIN: typeof BOUNDS_MIN;
+declare const index$3_BOUNDS_WORDS: typeof BOUNDS_WORDS;
+declare const index$3_CENTIDEGREES_PER_TURN: typeof CENTIDEGREES_PER_TURN;
+declare const index$3_COMMAND_BYTES: typeof COMMAND_BYTES;
+declare const index$3_COMMAND_OP_ID_BYTES: typeof COMMAND_OP_ID_BYTES;
+declare const index$3_CommandPort: typeof CommandPort;
+declare const index$3_CommandWriter: typeof CommandWriter;
+declare const index$3_DEFAULT_ANGLE_STEP_CENTIDEGREES: typeof DEFAULT_ANGLE_STEP_CENTIDEGREES;
+declare const index$3_DEFAULT_GRID_MM: typeof DEFAULT_GRID_MM;
+declare const index$3_Ground: typeof Ground;
+declare const index$3_Lighting: typeof Lighting;
+declare const index$3_Likeness: typeof Likeness;
+declare const index$3_LocalWorld: typeof LocalWorld;
+declare const index$3_LoopbackOptions: typeof LoopbackOptions;
+declare const index$3_MAX_SELECT_IDS: typeof MAX_SELECT_IDS;
+declare const index$3_MILLIMETRES_PER_METRE: typeof MILLIMETRES_PER_METRE;
+declare const index$3_MessageKind: typeof MessageKind;
+declare const index$3_MirroredResult: typeof MirroredResult;
+declare const index$3_NOT_SENT: typeof NOT_SENT;
+declare const index$3_NO_BUILDER: typeof NO_BUILDER;
+declare const index$3_Notice: typeof Notice;
+declare const index$3_OBJECT_RECORD_BYTES: typeof OBJECT_RECORD_BYTES;
+declare const index$3_POSITION: typeof POSITION;
+declare const index$3_QUATERNION_SCALE: typeof QUATERNION_SCALE;
+declare const index$3_ROTATION: typeof ROTATION;
+declare const index$3_SCALE: typeof SCALE;
+declare const index$3_SCALE_UNIT_PERMILLE: typeof SCALE_UNIT_PERMILLE;
+declare const index$3_SNAP_GRID: typeof SNAP_GRID;
+declare const index$3_SNAP_SURFACE: typeof SNAP_SURFACE;
+declare const index$3_Sanction: typeof Sanction;
+declare const index$3_SelectMode: typeof SelectMode;
+declare const index$3_Sky: typeof Sky;
+declare const index$3_Status: typeof Status;
+declare const index$3_TRANSFORM_BYTES: typeof TRANSFORM_BYTES;
+declare const index$3_TRANSFORM_WORDS: typeof TRANSFORM_WORDS;
+declare const index$3_Visibility: typeof Visibility;
+declare const index$3_WORLD_CHANNEL_SLOT: typeof WORLD_CHANNEL_SLOT;
+declare const index$3_WORLD_DEPTH_MM: typeof WORLD_DEPTH_MM;
+declare const index$3_WORLD_EXTENT_MM: typeof WORLD_EXTENT_MM;
+declare const index$3_WorldBuilder: typeof WorldBuilder;
+declare const index$3_WorldClockState: typeof WorldClockState;
+declare const index$3_WorldConnection: typeof WorldConnection;
+declare const index$3_WorldConnectionOptions: typeof WorldConnectionOptions;
+declare const index$3_WorldMirror: typeof WorldMirror;
+declare const index$3_WorldRoleCode: typeof WorldRoleCode;
+declare const index$3_WorldSettings: typeof WorldSettings;
+declare const index$3_bounds: typeof bounds;
+declare const index$3_canonical: typeof canonical;
+declare const index$3_connectWorld: typeof connectWorld;
+declare const index$3_copyTransform: typeof copyTransform;
+declare const index$3_encodeBare: typeof encodeBare;
+declare const index$3_encodeClock: typeof encodeClock;
+declare const index$3_encodeDuplicate: typeof encodeDuplicate;
+declare const index$3_encodeJoinCopy: typeof encodeJoinCopy;
+declare const index$3_encodeModerate: typeof encodeModerate;
+declare const index$3_encodePlace: typeof encodePlace;
+declare const index$3_encodeSelect: typeof encodeSelect;
+declare const index$3_encodeSetTransform: typeof encodeSetTransform;
+declare const index$3_encodeSettings: typeof encodeSettings;
+declare const index$3_encodeTransformSelection: typeof encodeTransformSelection;
+declare const index$3_identityTransform: typeof identityTransform;
+declare const index$3_movedAbout: typeof movedAbout;
+declare const index$3_overlapsFootprint: typeof overlapsFootprint;
+declare const index$3_snapHeightToGrid: typeof snapHeightToGrid;
+declare const index$3_snappedToGrid: typeof snappedToGrid;
+declare const index$3_withinWorld: typeof withinWorld;
+declare const index$3_yawRotation: typeof yawRotation;
+declare namespace index$3 {
+  export { index$3_ACTION_BASE as ACTION_BASE, index$3_Action as Action, index$3_BOUNDS_MAX as BOUNDS_MAX, index$3_BOUNDS_MIN as BOUNDS_MIN, index$3_BOUNDS_WORDS as BOUNDS_WORDS, index$3_CENTIDEGREES_PER_TURN as CENTIDEGREES_PER_TURN, index$3_COMMAND_BYTES as COMMAND_BYTES, index$3_COMMAND_OP_ID_BYTES as COMMAND_OP_ID_BYTES, index$3_CommandPort as CommandPort, index$3_CommandWriter as CommandWriter, index$3_DEFAULT_ANGLE_STEP_CENTIDEGREES as DEFAULT_ANGLE_STEP_CENTIDEGREES, index$3_DEFAULT_GRID_MM as DEFAULT_GRID_MM, index$3_Ground as Ground, index$3_Lighting as Lighting, index$3_Likeness as Likeness, index$3_LocalWorld as LocalWorld, index$3_LoopbackOptions as LoopbackOptions, index$3_MAX_SELECT_IDS as MAX_SELECT_IDS, index$3_MILLIMETRES_PER_METRE as MILLIMETRES_PER_METRE, index$3_MessageKind as MessageKind, index$3_MirroredResult as MirroredResult, index$3_NOT_SENT as NOT_SENT, index$3_NO_BUILDER as NO_BUILDER, index$3_Notice as Notice, index$3_OBJECT_RECORD_BYTES as OBJECT_RECORD_BYTES, index$3_POSITION as POSITION, index$3_QUATERNION_SCALE as QUATERNION_SCALE, index$3_ROTATION as ROTATION, index$3_SCALE as SCALE, index$3_SCALE_UNIT_PERMILLE as SCALE_UNIT_PERMILLE, index$3_SNAP_GRID as SNAP_GRID, index$3_SNAP_SURFACE as SNAP_SURFACE, index$3_Sanction as Sanction, index$3_SelectMode as SelectMode, index$3_Sky as Sky, index$3_Status as Status, index$3_TRANSFORM_BYTES as TRANSFORM_BYTES, index$3_TRANSFORM_WORDS as TRANSFORM_WORDS, index$3_Visibility as Visibility, index$3_WORLD_CHANNEL_SLOT as WORLD_CHANNEL_SLOT, index$3_WORLD_DEPTH_MM as WORLD_DEPTH_MM, index$3_WORLD_EXTENT_MM as WORLD_EXTENT_MM, index$3_WorldBuilder as WorldBuilder, index$3_WorldClockState as WorldClockState, index$3_WorldConnection as WorldConnection, index$3_WorldConnectionOptions as WorldConnectionOptions, index$3_WorldMirror as WorldMirror, index$3_WorldRoleCode as WorldRoleCode, index$3_WorldSettings as WorldSettings, index$3_bounds as bounds, index$3_canonical as canonical, index$3_connectWorld as connectWorld, index$3_copyTransform as copyTransform, index$3_encodeBare as encodeBare, index$3_encodeClock as encodeClock, index$3_encodeDuplicate as encodeDuplicate, index$3_encodeJoinCopy as encodeJoinCopy, index$3_encodeModerate as encodeModerate, index$3_encodePlace as encodePlace, index$3_encodeSelect as encodeSelect, index$3_encodeSetTransform as encodeSetTransform, index$3_encodeSettings as encodeSettings, index$3_encodeTransformSelection as encodeTransformSelection, index$3_identityTransform as identityTransform, index$3_movedAbout as movedAbout, index$3_overlapsFootprint as overlapsFootprint, index$3_snapHeightToGrid as snapHeightToGrid, index$3_snappedToGrid as snappedToGrid, index$3_withinWorld as withinWorld, index$3_yawRotation as yawRotation };
+}
+
+declare const REPLICATION_GRACE_MS = 2000;
+interface RoomLink {
+    readonly roomId: string;
+    readonly authority: boolean;
+    publish(message: Uint8Array): void;
+    subscribe(listener: (message: Uint8Array) => void): () => void;
+}
+declare class RoomGenerateError extends Error {
+    constructor(message: string);
+}
+interface RoomGenerate {
+    generate<T>(kind: AiContentKind, key: string, request: GenerateRequest<T>): Promise<Generated<T>>;
+    dialogue(key: string, request: GenerateRequest<Dialogue>): Promise<Generated<Dialogue>>;
+    text(key: string, request: GenerateRequest<string>): Promise<Generated<string>>;
+    item<T>(key: string, request: GenerateRequest<T>): Promise<Generated<T>>;
+    quest<T>(key: string, request: GenerateRequest<T>): Promise<Generated<T>>;
+    room<T>(key: string, request: GenerateRequest<T>): Promise<Generated<T>>;
+    dispose(): void;
+}
+declare function createRoomGenerate(ai: AiContentCalls | null, link: RoomLink): RoomGenerate;
+
+declare function roomRecipeSchema<const K extends readonly string[]>(kinds: K, grounds?: readonly string[]): Schema<ObjectOf<{
+    readonly name: Schema<string>;
+    readonly size: Schema<number[]>;
+    readonly ground: Schema<string>;
+    readonly style: Schema<string | undefined> & {
+        readonly optional: true;
+    };
+    readonly points: Schema<ObjectOf<{
+        readonly name: Schema<string>;
+        readonly at: Schema<number[]>;
+    }>[] | undefined> & {
+        readonly optional: true;
+    };
+    readonly objects: Schema<ObjectOf<{
+        readonly name: Schema<string>;
+        readonly kind: Schema<K[number]>;
+        readonly count: Schema<number>;
+        readonly near: Schema<string | undefined> & {
+            readonly optional: true;
+        };
+        readonly within: Schema<number | undefined> & {
+            readonly optional: true;
+        };
+        readonly facing: Schema<string | undefined> & {
+            readonly optional: true;
+        };
+        readonly along: Schema<string | undefined> & {
+            readonly optional: true;
+        };
+        readonly on: Schema<string | undefined> & {
+            readonly optional: true;
+        };
+        readonly clear: Schema<number | undefined> & {
+            readonly optional: true;
+        };
+        readonly reachable_from: Schema<string | undefined> & {
+            readonly optional: true;
+        };
+    }>[]>;
+}>>;
+type RoomRecipe = Infer<ReturnType<typeof roomRecipeSchema<readonly string[]>>>;
+interface SceneSpecLike {
+    readonly area: {
+        readonly size: readonly [number, number];
+        readonly ground: string;
+        readonly points: {
+            readonly [name: string]: readonly [number, number];
+        };
+    };
+    readonly objects: {
+        readonly [name: string]: {
+            readonly [field: string]: unknown;
+        };
+    };
+    readonly style?: string;
+    readonly seed: number;
+}
+declare function recipeToScene(recipe: RoomRecipe, seed: number): SceneSpecLike;
+interface SceneCompilerLike<W> {
+    (name: string, spec: SceneSpecLike): {
+        readonly wire: W | null;
+        readonly diagnostics: readonly unknown[];
+    };
+}
+interface SceneSolverLike<W, R> {
+    solve(wire: W, seed?: number): R;
+}
+type SolvedRoom<R> = {
+    readonly status: "solved";
+    readonly result: R;
+    readonly seed: number;
+} | {
+    readonly status: "rejected";
+    readonly diagnostics: readonly unknown[];
+};
+declare function solveRoom<W, R>(recipe: RoomRecipe, seed: number, compile: SceneCompilerLike<W>, solver: SceneSolverLike<W, R>): SolvedRoom<R>;
+
+declare function validateValue(schema: JsonSchema, value: unknown, at?: string): string | null;
+declare function select(value: unknown, path: string): unknown[];
+declare function applyRules(rules: readonly AiContentRule[], value: unknown): string | null;
+declare const rule: {
+    range: (path: string, min: number, max: number) => AiContentRule;
+    total: (path: string, max: number) => AiContentRule;
+    count: (path: string, min: number, max: number) => AiContentRule;
+    oneOf: (path: string, values: readonly string[]) => AiContentRule;
+    distinct: (path: string) => AiContentRule;
+};
+
+declare const CONTENT_CHANNEL_SLOT: number;
+declare function tickContentAsk<T>(key: string, kind: AiContentKind, request: GenerateRequest<T>): Uint8Array;
+declare function requestTickContent<T>(ctx: TickRoomCtx, key: string, kind: AiContentKind, request: GenerateRequest<T>): boolean;
+declare function createTickContentLink(roomId: string, subscribe: (listener: (payload: Uint8Array) => void) => () => void): RoomLink;
+
+declare const index$2_AiContentCalls: typeof AiContentCalls;
+declare const index$2_ArrayOptions: typeof ArrayOptions;
+declare const index$2_CONTENT_CHANNEL_SLOT: typeof CONTENT_CHANNEL_SLOT;
+declare const index$2_CtxGenerate: typeof CtxGenerate;
+declare const index$2_DEFAULT_RETRIES: typeof DEFAULT_RETRIES;
+declare const index$2_DEFAULT_TIMEOUT_MS: typeof DEFAULT_TIMEOUT_MS;
+declare const index$2_Dialogue: typeof Dialogue;
+declare const index$2_GenerateOptions: typeof GenerateOptions;
+declare const index$2_GenerateReason: typeof GenerateReason;
+declare const index$2_GenerateRequest: typeof GenerateRequest;
+declare const index$2_GenerateScope: typeof GenerateScope;
+declare const index$2_GenerateSource: typeof GenerateSource;
+declare const index$2_Generated: typeof Generated;
+declare const index$2_Infer: typeof Infer;
+declare const index$2_JsonSchema: typeof JsonSchema;
+declare const index$2_JsonValue: typeof JsonValue;
+declare const index$2_MAX_TIMEOUT_MS: typeof MAX_TIMEOUT_MS;
+declare const index$2_MIN_TIMEOUT_MS: typeof MIN_TIMEOUT_MS;
+declare const index$2_ObjectOf: typeof ObjectOf;
+declare const index$2_PrefetchEntry: typeof PrefetchEntry;
+declare const index$2_REPLICATION_GRACE_MS: typeof REPLICATION_GRACE_MS;
+type index$2_RoomGenerate = RoomGenerate;
+type index$2_RoomGenerateError = RoomGenerateError;
+declare const index$2_RoomGenerateError: typeof RoomGenerateError;
+type index$2_RoomLink = RoomLink;
+type index$2_RoomRecipe = RoomRecipe;
+type index$2_SceneCompilerLike<W> = SceneCompilerLike<W>;
+type index$2_SceneSolverLike<W, R> = SceneSolverLike<W, R>;
+type index$2_SceneSpecLike = SceneSpecLike;
+declare const index$2_Schema: typeof Schema;
+type index$2_SolvedRoom<R> = SolvedRoom<R>;
+declare const index$2_StringOptions: typeof StringOptions;
+declare const index$2_acceptContent: typeof acceptContent;
+declare const index$2_applyRules: typeof applyRules;
+declare const index$2_contentRequest: typeof contentRequest;
+declare const index$2_createGenerate: typeof createGenerate;
+declare const index$2_createRoomGenerate: typeof createRoomGenerate;
+declare const index$2_createTickContentLink: typeof createTickContentLink;
+declare const index$2_dialogueSchema: typeof dialogueSchema;
+declare const index$2_recipeToScene: typeof recipeToScene;
+declare const index$2_requestTickContent: typeof requestTickContent;
+declare const index$2_roomRecipeSchema: typeof roomRecipeSchema;
+declare const index$2_rule: typeof rule;
+declare const index$2_runContent: typeof runContent;
+declare const index$2_select: typeof select;
+declare const index$2_solveRoom: typeof solveRoom;
+declare const index$2_t: typeof t;
+declare const index$2_tickContentAsk: typeof tickContentAsk;
+declare const index$2_validateValue: typeof validateValue;
+declare namespace index$2 {
+  export { index$2_AiContentCalls as AiContentCalls, index$2_ArrayOptions as ArrayOptions, index$2_CONTENT_CHANNEL_SLOT as CONTENT_CHANNEL_SLOT, index$2_CtxGenerate as CtxGenerate, index$2_DEFAULT_RETRIES as DEFAULT_RETRIES, index$2_DEFAULT_TIMEOUT_MS as DEFAULT_TIMEOUT_MS, index$2_Dialogue as Dialogue, index$2_GenerateOptions as GenerateOptions, index$2_GenerateReason as GenerateReason, index$2_GenerateRequest as GenerateRequest, index$2_GenerateScope as GenerateScope, index$2_GenerateSource as GenerateSource, index$2_Generated as Generated, index$2_Infer as Infer, index$2_JsonSchema as JsonSchema, index$2_JsonValue as JsonValue, index$2_MAX_TIMEOUT_MS as MAX_TIMEOUT_MS, index$2_MIN_TIMEOUT_MS as MIN_TIMEOUT_MS, NumberOptions$1 as NumberOptions, index$2_ObjectOf as ObjectOf, index$2_PrefetchEntry as PrefetchEntry, index$2_REPLICATION_GRACE_MS as REPLICATION_GRACE_MS, type index$2_RoomGenerate as RoomGenerate, index$2_RoomGenerateError as RoomGenerateError, type index$2_RoomLink as RoomLink, type index$2_RoomRecipe as RoomRecipe, type index$2_SceneCompilerLike as SceneCompilerLike, type index$2_SceneSolverLike as SceneSolverLike, type index$2_SceneSpecLike as SceneSpecLike, index$2_Schema as Schema, type index$2_SolvedRoom as SolvedRoom, index$2_StringOptions as StringOptions, index$2_acceptContent as acceptContent, index$2_applyRules as applyRules, index$2_contentRequest as contentRequest, index$2_createGenerate as createGenerate, index$2_createRoomGenerate as createRoomGenerate, index$2_createTickContentLink as createTickContentLink, index$2_dialogueSchema as dialogueSchema, index$2_recipeToScene as recipeToScene, index$2_requestTickContent as requestTickContent, index$2_roomRecipeSchema as roomRecipeSchema, index$2_rule as rule, index$2_runContent as runContent, index$2_select as select, index$2_solveRoom as solveRoom, index$2_t as t, index$2_tickContentAsk as tickContentAsk, index$2_validateValue as validateValue };
+}
+
+declare const PART_MAGIC = 1414680643;
+declare const PART_VERSION = 1;
+declare const PART_HEADER_BYTES = 8;
+declare const MANIFEST_MAGIC = 1296126019;
+declare const MANIFEST_VERSION = 1;
+declare const MANIFEST_HEADER_BYTES = 24;
+declare const MANIFEST_PART_BYTES: number;
+declare const SEGMENT_BYTES$1 = 16;
+declare const MAX_MANIFEST_PARTS = 65535;
+declare const MAX_ASSET_BYTES: number;
+declare const PartKind: {
+    readonly data: 0;
+    readonly scene: 1;
+    readonly mesh_index: 2;
+    readonly mesh_vertex: 3;
+    readonly skeleton: 4;
+    readonly clip: 5;
+    readonly texture: 6;
+    readonly image: 7;
+    readonly material: 8;
+    readonly audio: 9;
+    readonly shader: 10;
+    readonly kernel: 11;
+    readonly cell: 12;
+    readonly font: 13;
+};
+type PartKindName = keyof typeof PartKind;
+type PartKindCode = (typeof PartKind)[PartKindName];
+declare function partKindName(code: number): PartKindName;
+declare const SegmentOp: {
+    readonly literal: 0;
+    readonly part: 1;
+    readonly delta: 2;
+};
+type Segment = {
+    readonly op: typeof SegmentOp.literal;
+    readonly offset: number;
+    readonly length: number;
+} | {
+    readonly op: typeof SegmentOp.part;
+    readonly part: number;
+    readonly offset: number;
+    readonly length: number;
+} | {
+    readonly op: typeof SegmentOp.delta;
+    readonly part: number;
+    readonly offset: number;
+    readonly length: number;
+    readonly output: number;
+};
+interface PartRef {
+    readonly digest: string;
+    readonly kind: PartKindCode;
+    readonly length: number;
+}
+interface AssetManifest {
+    readonly kind: number;
+    readonly length: number;
+    readonly parts: readonly PartRef[];
+    readonly segments: readonly Segment[];
+    readonly literal: Uint8Array;
+}
+declare class PartFormatError extends Error {
+    constructor(message: string);
+}
+declare function encodePart(kind: PartKindCode, body: Uint8Array): Uint8Array;
+interface DecodedPart {
+    readonly kind: PartKindCode;
+    readonly body: Uint8Array;
+}
+declare function decodePart(payload: Uint8Array): DecodedPart;
+declare function isManifest(payload: Uint8Array): boolean;
+declare function manifestBytes(manifest: AssetManifest): number;
+declare function encodeManifest(manifest: AssetManifest): Uint8Array;
+declare function decodeManifest(payload: Uint8Array): AssetManifest;
+declare function segmentOutput(segment: Segment): number;
+
+declare const DeltaOp: {
+    readonly copy: 0;
+    readonly insert: 1;
+    readonly table: 2;
+    readonly map: 3;
+    readonly fill: 4;
+};
+declare function applyDelta(base: Uint8Array, delta: Uint8Array, out: Uint8Array, at: number, length: number): void;
+declare function encodeDelta(base: Uint8Array, target: Uint8Array, limit?: number): Uint8Array | null;
+
+type PartBodies = (index: number) => Uint8Array;
+declare function assembleInto(manifest: AssetManifest, body: PartBodies, out: Uint8Array, at?: number): void;
+declare function soleSpan(manifest: AssetManifest): {
+    readonly part: number;
+    readonly offset: number;
+} | null;
+declare function assemble(manifest: AssetManifest, body: PartBodies): Uint8Array;
+
+interface Span {
+    readonly start: number;
+    readonly end: number;
+    readonly kind: PartKindCode | null;
+}
+declare const MIN_PART_BYTES = 2048;
+declare const CDC_MIN_BYTES: number;
+declare const CDC_MAX_BYTES: number;
+declare function contentSpans(bytes: Uint8Array, start: number, end: number, kind: PartKindCode): Span[];
+declare function coalesce(input: readonly Span[], minPart?: number): Span[];
+declare function structuralSpans(bytes: Uint8Array): Span[] | null;
+declare function progressiveSpans(bytes: Uint8Array): {
+    readonly base: Span[];
+    readonly refine: Span[];
+} | null;
+declare function splitAsset(bytes: Uint8Array, minPart?: number): Span[] | null;
+
+declare const DELTA_LIMIT = 0.5;
+type Seal = (payload: Uint8Array) => string;
+interface SealedPart {
+    readonly digest: string;
+    readonly kind: PartKindCode;
+    readonly body: Uint8Array;
+    readonly payload: Uint8Array;
+}
+interface DeltaUse {
+    readonly base: string;
+    readonly variantBytes: number;
+    readonly deltaBytes: number;
+}
+interface BuiltAsset {
+    readonly manifest: Uint8Array;
+    readonly parts: readonly SealedPart[];
+    readonly deltas: readonly DeltaUse[];
+    readonly literalBytes: number;
+}
+interface BuildAssetOptions {
+    readonly bases?: DeltaBases | null;
+    readonly minPart?: number;
+}
+interface DeltaBases {
+    has(digest: string): boolean;
+    candidates(kind: PartKindCode, body: Uint8Array): SealedPart[];
+}
+declare function combinedBases(...sources: readonly DeltaBases[]): DeltaBases;
+declare class PartIndex implements DeltaBases {
+    private readonly parts;
+    private readonly digests;
+    private readonly byAnchor;
+    private readonly byLength;
+    get size(): number;
+    has(digest: string): boolean;
+    add(part: SealedPart): void;
+    candidates(kind: PartKindCode, body: Uint8Array): SealedPart[];
+}
+declare function sealPart(kind: PartKindCode, body: Uint8Array, seal: Seal): SealedPart;
+declare function buildAsset(bytes: Uint8Array, assetKind: number, seal: Seal, options?: BuildAssetOptions): BuiltAsset | null;
+
+type index$1_AssetManifest = AssetManifest;
+type index$1_BuildAssetOptions = BuildAssetOptions;
+type index$1_BuiltAsset = BuiltAsset;
+declare const index$1_CDC_MAX_BYTES: typeof CDC_MAX_BYTES;
+declare const index$1_CDC_MIN_BYTES: typeof CDC_MIN_BYTES;
+declare const index$1_DELTA_LIMIT: typeof DELTA_LIMIT;
+type index$1_DecodedPart = DecodedPart;
+type index$1_DeltaBases = DeltaBases;
+declare const index$1_DeltaOp: typeof DeltaOp;
+type index$1_DeltaUse = DeltaUse;
+declare const index$1_MANIFEST_HEADER_BYTES: typeof MANIFEST_HEADER_BYTES;
+declare const index$1_MANIFEST_MAGIC: typeof MANIFEST_MAGIC;
+declare const index$1_MANIFEST_PART_BYTES: typeof MANIFEST_PART_BYTES;
+declare const index$1_MANIFEST_VERSION: typeof MANIFEST_VERSION;
+declare const index$1_MAX_ASSET_BYTES: typeof MAX_ASSET_BYTES;
+declare const index$1_MAX_MANIFEST_PARTS: typeof MAX_MANIFEST_PARTS;
+declare const index$1_MIN_PART_BYTES: typeof MIN_PART_BYTES;
+declare const index$1_PART_HEADER_BYTES: typeof PART_HEADER_BYTES;
+declare const index$1_PART_MAGIC: typeof PART_MAGIC;
+declare const index$1_PART_VERSION: typeof PART_VERSION;
+declare const index$1_PackageWeaveRef: typeof PackageWeaveRef;
+type index$1_PartBodies = PartBodies;
+type index$1_PartFormatError = PartFormatError;
+declare const index$1_PartFormatError: typeof PartFormatError;
+type index$1_PartIndex = PartIndex;
+declare const index$1_PartIndex: typeof PartIndex;
+declare const index$1_PartKind: typeof PartKind;
+type index$1_PartKindCode = PartKindCode;
+type index$1_PartKindName = PartKindName;
+type index$1_PartRef = PartRef;
+type index$1_Seal = Seal;
+type index$1_SealedPart = SealedPart;
+type index$1_Segment = Segment;
+declare const index$1_SegmentOp: typeof SegmentOp;
+type index$1_Span = Span;
+declare const index$1_WEAVE_BOUNDARY_MASK: typeof WEAVE_BOUNDARY_MASK;
+declare const index$1_WEAVE_CHILD_ENTRY_BYTES: typeof WEAVE_CHILD_ENTRY_BYTES;
+declare const index$1_WEAVE_HEAD_DOMAIN: typeof WEAVE_HEAD_DOMAIN;
+declare const index$1_WEAVE_LEAF_DECORATED: typeof WEAVE_LEAF_DECORATED;
+declare const index$1_WEAVE_LEAF_ENTRY_BYTES: typeof WEAVE_LEAF_ENTRY_BYTES;
+declare const index$1_WEAVE_LEAF_TWINNED: typeof WEAVE_LEAF_TWINNED;
+declare const index$1_WEAVE_MAX_HEIGHT: typeof WEAVE_MAX_HEIGHT;
+declare const index$1_WEAVE_MAX_NODE_BYTES: typeof WEAVE_MAX_NODE_BYTES;
+declare const index$1_WEAVE_MAX_NODE_ENTRIES: typeof WEAVE_MAX_NODE_ENTRIES;
+declare const index$1_WEAVE_MIN_NODE_ENTRIES: typeof WEAVE_MIN_NODE_ENTRIES;
+declare const index$1_WEAVE_NODE_HEADER_BYTES: typeof WEAVE_NODE_HEADER_BYTES;
+declare const index$1_WEAVE_NODE_MAGIC: typeof WEAVE_NODE_MAGIC;
+declare const index$1_WEAVE_NODE_ZONE: typeof WEAVE_NODE_ZONE;
+declare const index$1_WEAVE_VERSION: typeof WEAVE_VERSION;
+declare const index$1_WeaveChunk: typeof WeaveChunk;
+declare const index$1_WeaveHead: typeof WeaveHead;
+declare const index$1_WeaveHeadChunk: typeof WeaveHeadChunk;
+declare const index$1_WeaveHeadGroup: typeof WeaveHeadGroup;
+declare const index$1_WeaveLeaf: typeof WeaveLeaf;
+declare const index$1_WeaveLeafVisitor: typeof WeaveLeafVisitor;
+declare const index$1_WeaveNodeSource: typeof WeaveNodeSource;
+declare const index$1_WeavePlan: typeof WeavePlan;
+declare const index$1_WeaveRefusal: typeof WeaveRefusal;
+declare const index$1_WeaveRoot: typeof WeaveRoot;
+declare const index$1_WeaveRuntimeTag: typeof WeaveRuntimeTag;
+declare const index$1_WeaveScheduled: typeof WeaveScheduled;
+declare const index$1_WeaveSession: typeof WeaveSession;
+declare const index$1_WeaveTree: typeof WeaveTree;
+declare const index$1_WeaveTrust: typeof WeaveTrust;
+declare const index$1_WeaveVerifyError: typeof WeaveVerifyError;
+declare const index$1_WeaveWalk: typeof WeaveWalk;
+declare const index$1_WovenIndex: typeof WovenIndex;
+declare const index$1_applyDelta: typeof applyDelta;
+declare const index$1_assemble: typeof assemble;
+declare const index$1_assembleInto: typeof assembleInto;
+declare const index$1_buildAsset: typeof buildAsset;
+declare const index$1_buildWeave: typeof buildWeave;
+declare const index$1_childDigestAt: typeof childDigestAt;
+declare const index$1_chunkWeaveSource: typeof chunkWeaveSource;
+declare const index$1_coalesce: typeof coalesce;
+declare const index$1_combinedBases: typeof combinedBases;
+declare const index$1_contentSpans: typeof contentSpans;
+declare const index$1_decodeManifest: typeof decodeManifest;
+declare const index$1_decodePart: typeof decodePart;
+declare const index$1_deliverSchedule: typeof deliverSchedule;
+declare const index$1_encodeDelta: typeof encodeDelta;
+declare const index$1_encodeManifest: typeof encodeManifest;
+declare const index$1_encodePart: typeof encodePart;
+declare const index$1_isManifest: typeof isManifest;
+declare const index$1_leafAt: typeof leafAt;
+declare const index$1_leafDigest: typeof leafDigest;
+declare const index$1_leafDigestAt: typeof leafDigestAt;
+declare const index$1_leafFlags: typeof leafFlags;
+declare const index$1_leafLength: typeof leafLength;
+declare const index$1_leafZone: typeof leafZone;
+declare const index$1_manifestBytes: typeof manifestBytes;
+declare const index$1_nodeMatches: typeof nodeMatches;
+declare const index$1_openWeaveHead: typeof openWeaveHead;
+declare const index$1_openWeaveSession: typeof openWeaveSession;
+declare const index$1_partKindName: typeof partKindName;
+declare const index$1_planWeave: typeof planWeave;
+declare const index$1_progressiveSpans: typeof progressiveSpans;
+declare const index$1_sealPart: typeof sealPart;
+declare const index$1_segmentOutput: typeof segmentOutput;
+declare const index$1_soleSpan: typeof soleSpan;
+declare const index$1_splitAsset: typeof splitAsset;
+declare const index$1_storeWeaveSource: typeof storeWeaveSource;
+declare const index$1_structuralSpans: typeof structuralSpans;
+declare const index$1_unweaveIndex: typeof unweaveIndex;
+declare const index$1_validWeaveRoot: typeof validWeaveRoot;
+declare const index$1_verifyChild: typeof verifyChild;
+declare const index$1_verifyRoot: typeof verifyRoot;
+declare const index$1_walkWeave: typeof walkWeave;
+declare const index$1_weaveHeadMessage: typeof weaveHeadMessage;
+declare const index$1_weaveNodeCount: typeof weaveNodeCount;
+declare const index$1_weaveNodeLevel: typeof weaveNodeLevel;
+declare const index$1_weaveNodeValid: typeof weaveNodeValid;
+declare const index$1_weaveParts: typeof weaveParts;
+declare const index$1_woven: typeof woven;
+declare namespace index$1 {
+  export { type index$1_AssetManifest as AssetManifest, type index$1_BuildAssetOptions as BuildAssetOptions, type index$1_BuiltAsset as BuiltAsset, index$1_CDC_MAX_BYTES as CDC_MAX_BYTES, index$1_CDC_MIN_BYTES as CDC_MIN_BYTES, index$1_DELTA_LIMIT as DELTA_LIMIT, type index$1_DecodedPart as DecodedPart, type index$1_DeltaBases as DeltaBases, index$1_DeltaOp as DeltaOp, type index$1_DeltaUse as DeltaUse, index$1_MANIFEST_HEADER_BYTES as MANIFEST_HEADER_BYTES, index$1_MANIFEST_MAGIC as MANIFEST_MAGIC, index$1_MANIFEST_PART_BYTES as MANIFEST_PART_BYTES, index$1_MANIFEST_VERSION as MANIFEST_VERSION, index$1_MAX_ASSET_BYTES as MAX_ASSET_BYTES, index$1_MAX_MANIFEST_PARTS as MAX_MANIFEST_PARTS, index$1_MIN_PART_BYTES as MIN_PART_BYTES, index$1_PART_HEADER_BYTES as PART_HEADER_BYTES, index$1_PART_MAGIC as PART_MAGIC, index$1_PART_VERSION as PART_VERSION, index$1_PackageWeaveRef as PackageWeaveRef, type index$1_PartBodies as PartBodies, index$1_PartFormatError as PartFormatError, index$1_PartIndex as PartIndex, index$1_PartKind as PartKind, type index$1_PartKindCode as PartKindCode, type index$1_PartKindName as PartKindName, type index$1_PartRef as PartRef, SEGMENT_BYTES$1 as SEGMENT_BYTES, type index$1_Seal as Seal, type index$1_SealedPart as SealedPart, type index$1_Segment as Segment, index$1_SegmentOp as SegmentOp, type index$1_Span as Span, index$1_WEAVE_BOUNDARY_MASK as WEAVE_BOUNDARY_MASK, index$1_WEAVE_CHILD_ENTRY_BYTES as WEAVE_CHILD_ENTRY_BYTES, index$1_WEAVE_HEAD_DOMAIN as WEAVE_HEAD_DOMAIN, index$1_WEAVE_LEAF_DECORATED as WEAVE_LEAF_DECORATED, index$1_WEAVE_LEAF_ENTRY_BYTES as WEAVE_LEAF_ENTRY_BYTES, index$1_WEAVE_LEAF_TWINNED as WEAVE_LEAF_TWINNED, index$1_WEAVE_MAX_HEIGHT as WEAVE_MAX_HEIGHT, index$1_WEAVE_MAX_NODE_BYTES as WEAVE_MAX_NODE_BYTES, index$1_WEAVE_MAX_NODE_ENTRIES as WEAVE_MAX_NODE_ENTRIES, index$1_WEAVE_MIN_NODE_ENTRIES as WEAVE_MIN_NODE_ENTRIES, index$1_WEAVE_NODE_HEADER_BYTES as WEAVE_NODE_HEADER_BYTES, index$1_WEAVE_NODE_MAGIC as WEAVE_NODE_MAGIC, index$1_WEAVE_NODE_ZONE as WEAVE_NODE_ZONE, index$1_WEAVE_VERSION as WEAVE_VERSION, index$1_WeaveChunk as WeaveChunk, index$1_WeaveHead as WeaveHead, index$1_WeaveHeadChunk as WeaveHeadChunk, index$1_WeaveHeadGroup as WeaveHeadGroup, index$1_WeaveLeaf as WeaveLeaf, index$1_WeaveLeafVisitor as WeaveLeafVisitor, index$1_WeaveNodeSource as WeaveNodeSource, index$1_WeavePlan as WeavePlan, index$1_WeaveRefusal as WeaveRefusal, index$1_WeaveRoot as WeaveRoot, index$1_WeaveRuntimeTag as WeaveRuntimeTag, index$1_WeaveScheduled as WeaveScheduled, index$1_WeaveSession as WeaveSession, index$1_WeaveTree as WeaveTree, index$1_WeaveTrust as WeaveTrust, index$1_WeaveVerifyError as WeaveVerifyError, index$1_WeaveWalk as WeaveWalk, index$1_WovenIndex as WovenIndex, index$1_applyDelta as applyDelta, index$1_assemble as assemble, index$1_assembleInto as assembleInto, index$1_buildAsset as buildAsset, index$1_buildWeave as buildWeave, index$1_childDigestAt as childDigestAt, index$1_chunkWeaveSource as chunkWeaveSource, index$1_coalesce as coalesce, index$1_combinedBases as combinedBases, index$1_contentSpans as contentSpans, index$1_decodeManifest as decodeManifest, index$1_decodePart as decodePart, index$1_deliverSchedule as deliverSchedule, index$1_encodeDelta as encodeDelta, index$1_encodeManifest as encodeManifest, index$1_encodePart as encodePart, index$1_isManifest as isManifest, index$1_leafAt as leafAt, index$1_leafDigest as leafDigest, index$1_leafDigestAt as leafDigestAt, index$1_leafFlags as leafFlags, index$1_leafLength as leafLength, index$1_leafZone as leafZone, index$1_manifestBytes as manifestBytes, index$1_nodeMatches as nodeMatches, index$1_openWeaveHead as openWeaveHead, index$1_openWeaveSession as openWeaveSession, index$1_partKindName as partKindName, index$1_planWeave as planWeave, index$1_progressiveSpans as progressiveSpans, index$1_sealPart as sealPart, index$1_segmentOutput as segmentOutput, index$1_soleSpan as soleSpan, index$1_splitAsset as splitAsset, index$1_storeWeaveSource as storeWeaveSource, index$1_structuralSpans as structuralSpans, index$1_unweaveIndex as unweaveIndex, index$1_validWeaveRoot as validWeaveRoot, index$1_verifyChild as verifyChild, index$1_verifyRoot as verifyRoot, index$1_walkWeave as walkWeave, index$1_weaveHeadMessage as weaveHeadMessage, index$1_weaveNodeCount as weaveNodeCount, index$1_weaveNodeLevel as weaveNodeLevel, index$1_weaveNodeValid as weaveNodeValid, index$1_weaveParts as weaveParts, index$1_woven as woven };
+}
+
+declare const PROGRESSIVE_MAGIC = 1196576835;
+declare const PROGRESSIVE_VERSION = 1;
+declare const HEADER_BYTES = 32;
+declare const LEVEL_BYTES = 8;
+declare const UNIT_BYTES = 12;
+declare const SEGMENT_BYTES = 12;
+declare const PATCH_BYTES = 16;
+declare const PPM = 1000000;
+declare const MAX_PROGRESSIVE_BYTES = 2147483647;
+declare const MAX_PROGRESSIVE_DECODE_BYTES: number;
+declare const Header: {
+    readonly magic: 0;
+    readonly version: 4;
+    readonly kind: 5;
+    readonly levels: 6;
+    readonly output: 8;
+    readonly units: 12;
+    readonly segments: 16;
+    readonly patches: 20;
+    readonly table: 24;
+    readonly staging: 28;
+};
+declare const ProgressiveKind: {
+    readonly opaque: 0;
+    readonly texture: 1;
+    readonly mesh: 2;
+    readonly splat: 3;
+    readonly audio: 4;
+    readonly cells: 5;
+};
+type ProgressiveKindName = keyof typeof ProgressiveKind;
+type ProgressiveKindCode = (typeof ProgressiveKind)[ProgressiveKindName];
+declare function progressiveKindName(code: number): ProgressiveKindName;
+declare const SEGMENT_STAGED = 1;
+declare const PatchOp: {
+    readonly write: 0;
+    readonly staged: 1;
+    readonly merge: 2;
+    readonly unlift: 3;
+    readonly length: 4;
+    readonly fill: 5;
+};
+declare const FILL_BYTE_MAX = 255;
+type PatchOpCode = (typeof PatchOp)[keyof typeof PatchOp];
+declare const MERGE_PARAM_BYTES = 12;
+declare const UNLIFT_PARAM_BYTES = 12;
+declare const SAMPLE_BYTES = 2;
+declare class ProgressiveFormatError extends Error {
+    constructor(message: string);
+}
+interface PlanSegment {
+    readonly dest: number;
+    readonly bytes: Uint8Array;
+    readonly staged?: boolean;
+}
+interface PlanPatch {
+    readonly op: PatchOpCode;
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+}
+interface PlanUnit {
+    readonly segments: readonly PlanSegment[];
+    readonly patches: readonly PlanPatch[];
+    readonly quality: number;
+}
+interface ProgressivePlan {
+    readonly kind: ProgressiveKindCode;
+    readonly output: number;
+    readonly levels: readonly (readonly PlanUnit[])[];
+    readonly table: Uint8Array;
+}
+declare class TableWriter {
+    private chunks;
+    length: number;
+    bytes(data: Uint8Array): number;
+    words(...values: readonly number[]): number;
+    finish(): Uint8Array;
+}
+declare function writePatch(table: TableWriter, dest: number, data: Uint8Array): PlanPatch;
+declare function headBytes(levels: number, units: number, segments: number, patches: number, table: number): number;
+declare class ProgressiveLayout {
+    kind: ProgressiveKindCode;
+    output: number;
+    levels: number;
+    units: number;
+    segments: number;
+    patches: number;
+    table: number;
+    staging: number;
+    levelsAt: number;
+    unitsAt: number;
+    segmentsAt: number;
+    patchesAt: number;
+    tableAt: number;
+    head: number;
+}
+declare function readLayout(view: DataView, into?: ProgressiveLayout): ProgressiveLayout;
+declare function checkLayout(view: DataView, l: ProgressiveLayout): void;
+declare function coarseKeys(count: number, step: number): number;
+declare function isCoarseKey(index: number, count: number, step: number): boolean;
+interface EncodedContainer {
+    readonly bytes: Uint8Array;
+    readonly head: number;
+    readonly first: number;
+    readonly levelEnds: readonly number[];
+    readonly unitEnds: readonly number[];
+}
+declare function encodeContainer(plan: ProgressivePlan): EncodedContainer;
+interface ContainerBounds {
+    readonly kind: ProgressiveKindCode;
+    readonly head: number;
+    readonly first: number;
+    readonly unitEnds: readonly number[];
+}
+declare function containerBounds(bytes: Uint8Array): ContainerBounds | null;
+declare function isProgressive(bytes: Uint8Array): boolean;
+
+declare class ProgressiveDecoder {
+    private head;
+    private headView;
+    private headLength;
+    private headNeeded;
+    private readonly shape;
+    private layout;
+    private out;
+    private outView;
+    private view;
+    private readonly views;
+    private nextView;
+    private staging;
+    private stagingView;
+    private segment;
+    private segmentDone;
+    private unit;
+    private levelIndex;
+    private consumed;
+    private first;
+    private full;
+    private ppm;
+    get ready(): boolean;
+    get usable(): boolean;
+    get done(): boolean;
+    get kind(): ProgressiveKindCode | null;
+    get output(): Uint8Array | null;
+    get quality(): number;
+    get level(): number;
+    get levels(): number;
+    get units(): number;
+    get received(): number;
+    get firstBytes(): number;
+    get fullBytes(): number;
+    get outputBytes(): number;
+    levelEndBytes(level: number): number;
+    reset(): void;
+    push(src: Uint8Array, start?: number, end?: number): number;
+    private viewOf;
+    private ensureHead;
+    private openHead;
+    private settle;
+    private apply;
+}
+declare function decodeProgressive(container: Uint8Array): Uint8Array;
+
+type Inflate = (bytes: Uint8Array) => Uint8Array | null;
+type Compress = (bytes: Uint8Array) => Uint8Array;
+interface SplatPlanResult {
+    readonly plan: ProgressivePlan;
+    readonly source: Uint8Array;
+}
+declare function planSplat(bytes: Uint8Array, inflate: Inflate | null, compress: Compress | null): SplatPlanResult | null;
+
+declare const MIN_PROGRESSIVE_BYTES: number;
+declare const DEFAULT_PROGRESSIVE_KINDS: ReadonlySet<ProgressiveKindName>;
+interface ProgressiveBuildOptions {
+    readonly inflate?: Inflate | null;
+    readonly compress?: Compress | null;
+    readonly minBytes?: number;
+    readonly kinds?: ReadonlySet<ProgressiveKindName>;
+}
+interface ProgressiveAsset {
+    readonly kind: ProgressiveKindCode;
+    readonly source: Uint8Array;
+    readonly container: Uint8Array;
+    readonly head: number;
+    readonly first: number;
+    readonly levelEnds: readonly number[];
+    readonly unitEnds: readonly number[];
+    readonly levelQuality: readonly number[];
+}
+declare function buildProgressive(input: Uint8Array, options?: ProgressiveBuildOptions): ProgressiveAsset | null;
+
+interface MeshPlanResult {
+    readonly plan: ProgressivePlan;
+    readonly source: Uint8Array;
+}
+declare function planMesh(bytes: Uint8Array): MeshPlanResult | null;
+
+interface KtxLayout {
+    readonly start: number;
+    readonly end: number;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly levels: number;
+    readonly offsets: readonly number[];
+}
+declare function readKtx2(bytes: Uint8Array, start?: number, end?: number): KtxLayout | null;
+declare function planTexture(bytes: Uint8Array): ProgressivePlan | null;
+
+declare function planAudio(bytes: Uint8Array): ProgressivePlan | null;
+
+declare function planCells(bytes: Uint8Array): ProgressivePlan | null;
+
+interface LiftedBand {
+    readonly low: Int16Array;
+    readonly detail: Int16Array;
+}
+declare function liftForward(samples: Int16Array, frames: number, channels: number): LiftedBand;
+
+type index_Compress = Compress;
+type index_ContainerBounds = ContainerBounds;
+declare const index_DEFAULT_PROGRESSIVE_KINDS: typeof DEFAULT_PROGRESSIVE_KINDS;
+type index_EncodedContainer = EncodedContainer;
+declare const index_FILL_BYTE_MAX: typeof FILL_BYTE_MAX;
+declare const index_HEADER_BYTES: typeof HEADER_BYTES;
+declare const index_Header: typeof Header;
+type index_Inflate = Inflate;
+declare const index_LEVEL_BYTES: typeof LEVEL_BYTES;
+declare const index_MAX_PROGRESSIVE_BYTES: typeof MAX_PROGRESSIVE_BYTES;
+declare const index_MAX_PROGRESSIVE_DECODE_BYTES: typeof MAX_PROGRESSIVE_DECODE_BYTES;
+declare const index_MERGE_PARAM_BYTES: typeof MERGE_PARAM_BYTES;
+declare const index_MIN_PROGRESSIVE_BYTES: typeof MIN_PROGRESSIVE_BYTES;
+declare const index_PATCH_BYTES: typeof PATCH_BYTES;
+declare const index_PPM: typeof PPM;
+declare const index_PROGRESSIVE_MAGIC: typeof PROGRESSIVE_MAGIC;
+declare const index_PROGRESSIVE_VERSION: typeof PROGRESSIVE_VERSION;
+declare const index_PatchOp: typeof PatchOp;
+type index_PatchOpCode = PatchOpCode;
+type index_PlanPatch = PlanPatch;
+type index_PlanSegment = PlanSegment;
+type index_PlanUnit = PlanUnit;
+type index_ProgressiveAsset = ProgressiveAsset;
+type index_ProgressiveBuildOptions = ProgressiveBuildOptions;
+declare const index_ProgressiveCancelled: typeof ProgressiveCancelled;
+type index_ProgressiveDecoder = ProgressiveDecoder;
+declare const index_ProgressiveDecoder: typeof ProgressiveDecoder;
+declare const index_ProgressiveFeed: typeof ProgressiveFeed;
+type index_ProgressiveFormatError = ProgressiveFormatError;
+declare const index_ProgressiveFormatError: typeof ProgressiveFormatError;
+declare const index_ProgressiveKind: typeof ProgressiveKind;
+type index_ProgressiveKindCode = ProgressiveKindCode;
+type index_ProgressiveKindName = ProgressiveKindName;
+type index_ProgressiveLayout = ProgressiveLayout;
+declare const index_ProgressiveLayout: typeof ProgressiveLayout;
+declare const index_ProgressiveListener: typeof ProgressiveListener;
+declare const index_ProgressiveLoad: typeof ProgressiveLoad;
+type index_ProgressivePlan = ProgressivePlan;
+declare const index_SAMPLE_BYTES: typeof SAMPLE_BYTES;
+declare const index_SEGMENT_BYTES: typeof SEGMENT_BYTES;
+declare const index_SEGMENT_STAGED: typeof SEGMENT_STAGED;
+type index_TableWriter = TableWriter;
+declare const index_TableWriter: typeof TableWriter;
+declare const index_UNIT_BYTES: typeof UNIT_BYTES;
+declare const index_UNLIFT_PARAM_BYTES: typeof UNLIFT_PARAM_BYTES;
+declare const index_buildProgressive: typeof buildProgressive;
+declare const index_checkLayout: typeof checkLayout;
+declare const index_coarseKeys: typeof coarseKeys;
+declare const index_containerBounds: typeof containerBounds;
+declare const index_decodeProgressive: typeof decodeProgressive;
+declare const index_encodeContainer: typeof encodeContainer;
+declare const index_headBytes: typeof headBytes;
+declare const index_isCoarseKey: typeof isCoarseKey;
+declare const index_isProgressive: typeof isProgressive;
+declare const index_liftForward: typeof liftForward;
+declare const index_planAudio: typeof planAudio;
+declare const index_planCells: typeof planCells;
+declare const index_planMesh: typeof planMesh;
+declare const index_planSplat: typeof planSplat;
+declare const index_planTexture: typeof planTexture;
+declare const index_progressiveKindName: typeof progressiveKindName;
+declare const index_readKtx2: typeof readKtx2;
+declare const index_readLayout: typeof readLayout;
+declare const index_writePatch: typeof writePatch;
+declare namespace index {
+  export { type index_Compress as Compress, type index_ContainerBounds as ContainerBounds, index_DEFAULT_PROGRESSIVE_KINDS as DEFAULT_PROGRESSIVE_KINDS, type index_EncodedContainer as EncodedContainer, index_FILL_BYTE_MAX as FILL_BYTE_MAX, index_HEADER_BYTES as HEADER_BYTES, index_Header as Header, type index_Inflate as Inflate, index_LEVEL_BYTES as LEVEL_BYTES, index_MAX_PROGRESSIVE_BYTES as MAX_PROGRESSIVE_BYTES, index_MAX_PROGRESSIVE_DECODE_BYTES as MAX_PROGRESSIVE_DECODE_BYTES, index_MERGE_PARAM_BYTES as MERGE_PARAM_BYTES, index_MIN_PROGRESSIVE_BYTES as MIN_PROGRESSIVE_BYTES, index_PATCH_BYTES as PATCH_BYTES, index_PPM as PPM, index_PROGRESSIVE_MAGIC as PROGRESSIVE_MAGIC, index_PROGRESSIVE_VERSION as PROGRESSIVE_VERSION, index_PatchOp as PatchOp, type index_PatchOpCode as PatchOpCode, type index_PlanPatch as PlanPatch, type index_PlanSegment as PlanSegment, type index_PlanUnit as PlanUnit, type index_ProgressiveAsset as ProgressiveAsset, type index_ProgressiveBuildOptions as ProgressiveBuildOptions, index_ProgressiveCancelled as ProgressiveCancelled, index_ProgressiveDecoder as ProgressiveDecoder, index_ProgressiveFeed as ProgressiveFeed, index_ProgressiveFormatError as ProgressiveFormatError, index_ProgressiveKind as ProgressiveKind, type index_ProgressiveKindCode as ProgressiveKindCode, type index_ProgressiveKindName as ProgressiveKindName, index_ProgressiveLayout as ProgressiveLayout, index_ProgressiveListener as ProgressiveListener, index_ProgressiveLoad as ProgressiveLoad, type index_ProgressivePlan as ProgressivePlan, index_SAMPLE_BYTES as SAMPLE_BYTES, index_SEGMENT_BYTES as SEGMENT_BYTES, index_SEGMENT_STAGED as SEGMENT_STAGED, index_TableWriter as TableWriter, index_UNIT_BYTES as UNIT_BYTES, index_UNLIFT_PARAM_BYTES as UNLIFT_PARAM_BYTES, index_buildProgressive as buildProgressive, index_checkLayout as checkLayout, index_coarseKeys as coarseKeys, index_containerBounds as containerBounds, index_decodeProgressive as decodeProgressive, index_encodeContainer as encodeContainer, index_headBytes as headBytes, index_isCoarseKey as isCoarseKey, index_isProgressive as isProgressive, index_liftForward as liftForward, index_planAudio as planAudio, index_planCells as planCells, index_planMesh as planMesh, index_planSplat as planSplat, index_planTexture as planTexture, index_progressiveKindName as progressiveKindName, index_readKtx2 as readKtx2, index_readLayout as readLayout, index_writePatch as writePatch };
+}
+
+export { AI_MARK_LABEL, AI_MARK_NAMESPACE, AI_MARK_SOURCES, AI_MARK_TEXT, AUDIO_RELAY_EXPORT, AUDIO_WORKLET_FILE, AUDIO_WORKLET_GROUP, AUDIO_WORKLET_PATH, AiContentKind, AiContentRule, AiMark, type AiMarkOptions, type AiMarkSource, type AiMarkStyle, type AiMarkTextStyle, type AiMarkTheme, BASE_ENGINE_VARIANT, Badge, type BadgeOptions, type BlockVariant, type Body, BreakDictionaries, type ButtonLabelStyle, type ButtonStyle, type ButtonVariant, CONTENT_ENGINE_VARIANT, COZY_PASTEL, ChatLog, type ChatLogOptions, type ChatLogRow, ChatPanel, type ChatPanelOptions, type CollectionStyle, CompiledStyle, Condition, Connecting, Connector, type ControlStyle, Countdown, type CountdownOptions, Ctx, CtxGenerate, type CurrencyCounter, type CurrencyCounterOptions, DEFAULT_AI_MARK, DEFAULT_LANGUAGES, DEFAULT_QUALITIES, type DamageKind, DamageNumbers, type DamageNumbersOptions, Dialed, type DialogueBox, type DialogueBoxOptions, Dropdown, type DropdownOptions, ENGINE_ABI_DIGEST, ENGINE_ABI_VERSION, ENGINE_ARENA_BASELINE_BYTES, ENGINE_ARENA_CHUNK_BYTES, ENGINE_ARENA_FEATURE, ENGINE_ARENA_MAX_CEILING_BYTES, ENGINE_AUDIO_UNIT, ENGINE_COMPATIBILITY_EXPORT_NAMES, ENGINE_CORE_GL_UNIT, ENGINE_CORE_SCRIPTS_UNIT, ENGINE_EXPORT_PROTOTYPES, ENGINE_FEATURES, ENGINE_FEATURE_CARGO, ENGINE_FEATURE_NAMES, ENGINE_LUAU_UNIT, ENGINE_OPTIONAL_EXPORTS, ENGINE_VARIANTS, type EngineCoreVariant, type EngineExportUse, type EngineFeature, type EngineFeatureName, type EngineFeatureUse, type ExceptionEncoding, type ExceptionSupport, FANTASY_PARCHMENT, FULL_ENGINE_VARIANT, FontTable, GATED_ENGINE_FEATURES, GL_CORE_GROUP, GL_CORE_PATH, GL_ENGINE_VARIANTS, GameTheme, GameUi, type GatedEngineFeature, GenerateRequest, Generated, GeneratedText, type GeneratedTextOptions, type GeneratedTextStyle, GraphicsSurface, HostSheetRequest, type HudStyle, type IconButton, type IconButtonOptions, InventoryGrid, type InventoryGridOptions, type ItemCard, type ItemCardOptions, type JoinReply, JoinStatus, KIT_NAMESPACE, type KitColors, type KitFonts, type KitMetrics, LUAU_SCRIPTS_GROUP, LUAU_VM_EXCEPTIONS, LUAU_VM_FILE, LUAU_VM_PATH, Lane, Leaderboard, type LeaderboardOptions, type LeaderboardRow, LifecycleEvent, LinkHandler, LoadingScreen, type LoadingScreenOptions, LocaleInfo, Locomotion, LuauScriptError, type LuauScripts, type LuauScriptsOptions, type LuauScriptsPath, LuauVmModules, MAP_HEADING, MAP_PAN_X, MAP_PAN_Y, type MarkerKind, Minimap, type MinimapOptions, Modal, type ModalOptions, ModalStack, type ModalStackOptions, type ModalStyle, NEON_ARCADE, NetworkMemory, NumberOptions, type OpenLuauScripts, PHYSICS_ENGINE_VARIANT, type PanelOptions, type ParticleKind, PauseScreen, type PauseScreenOptions, Persona, PlatformEngine, type ProgressBar, type ProgressBarOptions, RICH_COLORS, type RadialItem, RadialMenu, type RadialMenuOptions, RenderingProfile, type ResultsData, ResultsScreen, type ResultsScreenOptions, type RichColor, RichText, RichTextError, type RichTextOptions, RoomDialer, SCRIPTS_CORE_GROUP, SCRIPTS_CORE_PATH, SCRIPTS_ENGINE_VARIANT, SCRIPTS_ENGINE_VARIANTS, SCRIPTS_SHADERS_ENGINE_VARIANT, SCRIPTS_SHADERS_ENGINE_VARIANTS, SIMULATOR_FIXED_STEP_MS, SLOT_REFERENCE, SPORTS_BROADCAST, STYLE_BLOCK_MAGIC, STYLE_BLOCK_VERSION, KEY_NAMES as STYLE_KEYS, STYLE_PROPERTY_NAMES, SessionCompletion, type SettingsKey, SettingsScreen, type SettingsScreenOptions, type SettingsValues, SheetResult, type Simulator, type SimulatorHost, type SimulatorOptions, SimulatorUnsupportedError, Slider, type SliderOptions, StatusLine, type StyleErrorKind, SurfaceOptions, TEXT_DICTIONARIES_ASSET, TEXT_DICTIONARIES_FILE, THEME_PACKS, THREADED_ENGINE_VARIANT, THREADED_ENGINE_VARIANTS, type Tabs, type TabsOptions, type TextBlockStyle, TextButton, type TextButtonOptions, type ThemePack, type ThemePackDefinition, TickRoomCtx, type Toast, Toggle, type ToggleOptions, Tooltip, type TooltipOptions, TutorialHint, type TutorialHintOptions, UI_CHECKS, UI_DEFAULT_FONT, UI_EXEMPT_REASONS, UI_FONT_ROLES, UI_FONT_SET, UI_INSPECT_HOOK, type UiCheckName, UiClock, UiColor, UiElement, UiEvent, UiExclusion, type UiExemptReason, type UiFocusListener, UiFocusScope, type UiFocusTarget, type UiFontName, type UiFontRole, type UiInspectHook, type UiLayoutKeys, type UiMove, UiNavigator, UiNode, type UiPaddingKeys, UiParticles, type UiParticlesOptions, UiProps, UiStyle, UiStyleCompileError, UiStyleError, UiStyles, type UiSurfaceKeys, type UiTextKeys, UiTheme, UiVarGroup, VariantKind, VirtualList, type VirtualListOptions, type VirtualRow, type WorldLabel, type WorldLabelOptions, aiLabel, aiMark, aiMarkTheme, aiMarkVars, applyThemePack, badge, blankReply, breakDictionaries, chatLog, chatPanel, compileClasses, compileStyle, conditionPriority, countdown, createSimulatorCtx, currencyCounter, currentThemePack, damageNumbers, decodeJoinReply, dialogueBox, dropdown, engineExportsUsed, engineFeatureExports, engineFeatureMember, engineVariantFor, exceptionSupport, exemptUi, focusNodeOf, fontStyle, fontTable, generatedText, index$2 as generation, glVariantOf, iconButton, inspectScene, inspectSceneEntered, inspectSceneSwitch, inventoryGrid, isAiGenerated, isGlVariant, isScriptsVariant, isShadersVariant, isThreadedVariant, isqrt, itemCard, kitFamily, kitVars, leaderboard, loadingScreen, luauVmModules, luauVmRunsHere, minimap, modal, modalStack, openLuauScripts, panel, index$1 as parts, pauseScreen, perAxisUnit, progressBar, index as progressive, radialMenu, readBlock, registerBreakDictionaries, registerFontTable, registerUiFont, resultsScreen, resumeRequest, richText, scriptsShadersVariantOf, scriptsVariantOf, settingsScreen, slider, spawn, steer, suggest, tabs, tailwindStyle, tailwindVocabulary, textButton, themePack, threadedVariantOf, ticketRequest, toast, toggle, tooltip, tutorialHint, uiParticles, uiSite, unmetEngineExport, unmetEngineFeature, virtualList, webGpuVariantOf, worldLabel, index$3 as worlds };